diff --git a/ASSETS.md b/ASSETS.md
index b6f5fa007..34ff73361 100644
--- a/ASSETS.md
+++ b/ASSETS.md
@@ -1,5 +1,21 @@
 # Asset attribution
 
+## Indic hyphenation patterns
+
+| Asset | Author | Source | Licence | Notes |
+|---|---|---|---|---|
+| `crates/text/patterns/hyph-hi.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-hi.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-mr.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-mr.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-gu.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-gu.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-bn.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-bn.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-pa.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-pa.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-ta.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-ta.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-te.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-te.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-kn.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-kn.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-ml.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-ml.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-or.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-or.tex | MIT (selected option) | Unmodified; full license in file |
+| `crates/text/patterns/hyph-as.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-as.tex | MIT (selected option) | Unmodified; full license in file |
+
 Every non-code asset in this repository (icons, images, fonts, example art, colour profiles, presets) is listed here with its author, source and licence. `cargo xtask assets` (part of `cargo xtask ci`) fails if an asset file is missing from this table.
 
 **Policy (mandatory):** VectorCraft contains **no Adobe iconography, images, artwork, presets, swatch/brush/symbol/pattern libraries or ICC profiles**. Every asset is either original work by VectorCraft contributors, or third-party material under an open licence (OSI open source, public domain / CC0, or Creative Commons that allows redistribution), and it is attributed below. Screenshots of Adobe software are never committed. The one exception is the ArtCraft name, wordmark and logos in `docs/brand/`: ArtCraft trademarks, not open source, usable only under [`docs/brand/LICENSE-brand.txt`](docs/brand/LICENSE-brand.txt).
diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md
new file mode 100644
index 000000000..f28ed3dde
--- /dev/null
+++ b/ATTRIBUTION.md
@@ -0,0 +1,17 @@
+# Attribution
+
+The complete historical asset manifest is [ASSETS.md](ASSETS.md). These hyphenation assets use the MIT option, with the complete copyright and permission notices preserved in each file.
+
+| Asset | Author | Source | SPDX license | Notes |
+|---|---|---|---|---|
+| `crates/text/patterns/hyph-hi.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-hi.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-mr.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-mr.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-gu.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-gu.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-bn.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-bn.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-pa.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-pa.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-ta.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-ta.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-te.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-te.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-kn.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-kn.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-ml.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-ml.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-or.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-or.tex | MIT | Unmodified; full license in file |
+| `crates/text/patterns/hyph-as.tex` | Santhosh Thottingal | https://github.com/hyphenation/tex-hyphen/blob/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex/hyph-as.tex | MIT | Unmodified; full license in file |
diff --git a/Cargo.lock b/Cargo.lock
index 32cffe9fd..6f92cb310 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1093,6 +1093,17 @@ dependencies = [
  "thiserror 2.0.21",
 ]
 
+[[package]]
+name = "craft-web-api"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=fd5e2feff6ea25bed371a99cc732b3968d621505#fd5e2feff6ea25bed371a99cc732b3968d621505"
+dependencies = [
+ "js-sys",
+ "serde_json",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+]
+
 [[package]]
 name = "craft-window"
 version = "0.1.0"
@@ -6594,6 +6605,7 @@ dependencies = [
 name = "vectorcraft-web"
 version = "0.21.0"
 dependencies = [
+ "craft-web-api",
  "eframe",
  "egui",
  "js-sys",
diff --git a/NOTICE b/NOTICE
index 4bf18085b..ea3c311a3 100644
--- a/NOTICE
+++ b/NOTICE
@@ -136,3 +136,8 @@ Permission is hereby granted, free of charge, to any person obtaining a copy of
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Indic hyphenation patterns (crates/text/patterns/):
+Copyright (C) 2016 Santhosh Thottingal, used under the MIT license option.
+Original copyright and full license notices are preserved in each hyph-*.tex file.
+Source: hyphenation/tex-hyphen, commit 5684c0f51c0b81133db2efbe60a408b4155a3ff5.
diff --git a/README.md b/README.md
index 8a3c453c5..79d88841e 100644
--- a/README.md
+++ b/README.md
@@ -253,7 +253,7 @@ The scores are self-assessed from our code against public documentation;
 [target-app-parity.md](docs/target-app-parity.md#how-this-was-measured-2026-10-10) explains how far to trust them.
 
 **What's missing:**
-- reliable exchange of .ai files (layer structure in real files; proprietary editing data isn't written);
+- reliable exchange of .ai files (layer structure in real files; the editing copy a save writes leaves out live effects and writes symbols and live objects as their art);
 - an interaction-fidelity pass covering every tool's modifiers and small behaviours;
 - 3D and Materials beyond the initial live Revolve (Extrude & Bevel, Inflate, Rotate, materials);
 - filter thumbnails and a preview area inside the Effect Gallery (the gallery itself and all 57 Photoshop-style raster filters, approximated, are in);
diff --git a/ROADMAP.md b/ROADMAP.md
index 74909b123..68b0b2d2a 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -23,8 +23,8 @@ and the work list in [`docs/gaps.md`](docs/gaps.md).
 
 **Why alpha:** the core workflows exist end to end (drawing and path editing, Pathfinder, paint and appearance,
 type, SVG/PDF/EPS, print, export) and feature depth is ~75%, but a professional can't yet switch: Illustrator's
-own `.ai` files open with a wrong layer structure in real cases and can't be saved back with Illustrator's
-editing data, the interaction details have never been checked side by side, and some machines fail to start the
+own `.ai` files open with a wrong layer structure in real cases and are saved back with an editing copy that
+leaves out live effects and writes symbols and live objects as their art, the interaction details have never been checked side by side, and some machines fail to start the
 app. Beta needs those closed (the beta list in [gaps.md](docs/gaps.md)). It passes the core-workflow
 gate: all six core workflows (path drawing and editing, paint and style, type, layers/artboards/export, print
 production, file exchange) work end to end on macOS with save and reopen, and only the last is partial, without
diff --git a/apps/vectorcraft-web/Cargo.toml b/apps/vectorcraft-web/Cargo.toml
index 8decb13d8..ff4bcef86 100644
--- a/apps/vectorcraft-web/Cargo.toml
+++ b/apps/vectorcraft-web/Cargo.toml
@@ -16,6 +16,8 @@ path = "src/main.rs"
 [dependencies]
 vectorcraft-engine = { workspace = true, features = ["bundled-fonts"] }
 vectorcraft-ui-egui = { workspace = true }
+# The page command API (storytold/craft-libs#413): the request plumbing behind window.vectorcraft.
+craft-web-api = { git = "https://github.com/storytold/craft-libs", rev = "fd5e2feff6ea25bed371a99cc732b3968d621505", version = "0.1.0" }
 vectorcraft-format = { workspace = true }
 vectorcraft-text = { workspace = true }
 egui = { workspace = true }
diff --git a/apps/vectorcraft-web/src/api.rs b/apps/vectorcraft-web/src/api.rs
index 526e56be1..eddd04f1b 100644
--- a/apps/vectorcraft-web/src/api.rs
+++ b/apps/vectorcraft-web/src/api.rs
@@ -1,14 +1,18 @@
 //! `window.vectorcraft`: the control channel for the page, as promises.
 //!
+//! `request`, `execute`, `commands`, `docInspect`, `uiInspect` and `screenshot` come from
+//! `craft-web-api` (storytold/craft-libs#413), the same in every Craft app; VectorCraft adds its own
+//! functions on the same object.
+//!
 //! The same JSON methods as the desktop control server (`docs/control-protocol.md`), so an agent
 //! driving VectorCraft in a browser tab (or an `<iframe>` in another app) uses the same commands as
 //! the CLI and the MCP server:
 //!
 //! ```js
-//! await vectorcraft.execute("object.rectangle", {x: 0, y: 0, width: 100, height: 50})  // engine command → its result
+//! await vectorcraft.execute("shape.rectangle", {x: 0, y: 0, width: 100, height: 50})  // engine command → its result
 //! await vectorcraft.request("ui.inspect")                      // control method → its result
 //! await vectorcraft.commands()                                 // command list
-//! const {base64} = await vectorcraft.screenshot()              // the canvas as PNG (base64)
+//! const {data} = await vectorcraft.screenshot()                // the canvas as PNG (base64)
 //! await vectorcraft.openFile("logo.svg", bytes)               // opened as a dropped file is
 //! vectorcraft.captureDownloads(true)                           // saves stay in the page…
 //! vectorcraft.files(); await vectorcraft.readFile("logo.png")  // …to be read back
@@ -17,21 +21,24 @@
 //! Results resolve with the method's `result`; errors reject with an `Error`.
 
 use std::cell::{Cell, RefCell};
+use std::future::Future;
+use std::pin::Pin;
+use std::rc::Rc;
 use std::sync::mpsc::{Receiver, Sender, TryRecvError};
 
+use craft_web_api::methods::Methods;
+use craft_web_api::page::{PageApi, Request};
 use serde_json::{Value, json};
-use vectorcraft_ui_egui::ControlRequest;
+use vectorcraft_ui_egui::{ControlRequest, ControlTicket as Ticket};
 use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::{JsFuture, future_to_promise};
 
 use crate::saved_files::SavedFiles;
 
 use crate::web::Inbox;
 
-type Waiting = (Receiver<Value>, js_sys::Function, js_sys::Function);
-
 thread_local! {
     static TX: RefCell<Option<Sender<ControlRequest>>> = const { RefCell::new(None) };
-    static WAITING: RefCell<Vec<Waiting>> = const { RefCell::new(Vec::new()) };
     static CTX: RefCell<Option<egui::Context>> = const { RefCell::new(None) };
     static INBOX: RefCell<Option<Inbox>> = const { RefCell::new(None) };
     static CAPTURE: Cell<bool> = const { Cell::new(false) };
@@ -69,77 +76,96 @@ fn to_js(v: &Value) -> JsValue {
     js_sys::JSON::parse(&v.to_string()).unwrap_or(JsValue::NULL)
 }
 
-fn from_js(v: &JsValue) -> Value {
-    if v.is_undefined() || v.is_null() {
-        return json!({});
+/// A reply as a promise outcome: the `result`, or an `Error` carrying the `error`.
+fn outcome(reply: &Value) -> Result<JsValue, JsValue> {
+    if reply.get("ok").and_then(Value::as_bool) == Some(true) {
+        Ok(to_js(reply.get("result").unwrap_or(&Value::Null)))
+    } else {
+        Err(js_sys::Error::new(reply.get("error").and_then(Value::as_str).unwrap_or("error")).into())
     }
-    js_sys::JSON::stringify(v).ok().and_then(|s| s.as_string()).and_then(|s| serde_json::from_str(&s).ok()).unwrap_or(json!({}))
 }
 
-/// Settle the promises of answered requests (called every frame).
-pub fn poll_replies() {
-    WAITING.with(|w| {
-        w.borrow_mut().retain(|(rx, resolve, reject)| match rx.try_recv() {
-            Ok(v) => {
-                if v.get("ok").and_then(Value::as_bool) == Some(true) {
-                    let _ = resolve.call1(&JsValue::NULL, &to_js(v.get("result").unwrap_or(&Value::Null)));
-                } else {
-                    let msg = v.get("error").and_then(Value::as_str).unwrap_or("error").to_string();
-                    let _ = reject.call1(&JsValue::NULL, &js_sys::Error::new(&msg));
-                }
-                false
+/// How often a waiting call looks for the app's reply, in milliseconds (about a frame).
+const POLL_MS: i32 = 16;
+
+/// A queued control request whose reply has not arrived. Dropping it before the reply (the page's
+/// timeout fired) gives the request up if the app has not started it, so the app never runs it late.
+struct Waiting {
+    reply: Receiver<Value>,
+    ticket: Ticket,
+    answered: bool,
+}
+
+impl Waiting {
+    /// The app's reply once it has answered or gone away; `None` while the request is waiting.
+    fn poll(&mut self) -> Option<Value> {
+        match self.reply.try_recv() {
+            Ok(reply) => {
+                self.answered = true;
+                Some(reply)
             }
-            Err(TryRecvError::Empty) => true,
+            Err(TryRecvError::Empty) => None,
             Err(TryRecvError::Disconnected) => {
-                let _ = reject.call1(&JsValue::NULL, &js_sys::Error::new("request dropped"));
-                false
+                self.answered = true;
+                Some(json!({"ok": false, "error": "request dropped"}))
             }
-        });
-    });
+        }
+    }
 }
 
-fn request(method: &str, params: Value) -> js_sys::Promise {
-    let method = method.to_string();
-    let p = js_sys::Promise::new(&mut |resolve, reject| {
-        let (req, rx) = ControlRequest::new(method.clone(), params.clone());
-        let sent = TX.with(|t| t.borrow().as_ref().is_some_and(|tx| tx.send(req).is_ok()));
-        if sent {
-            WAITING.with(|w| w.borrow_mut().push((rx, resolve, reject)));
-        } else {
-            let _ = reject.call1(&JsValue::NULL, &js_sys::Error::new("VectorCraft is not running yet"));
+impl Drop for Waiting {
+    fn drop(&mut self) {
+        if !self.answered {
+            self.ticket.give_up();
+        }
+    }
+}
+
+/// Queue a control request for the app and wait for its reply, as the protocol's `{ok, result}` /
+/// `{ok: false, error}` object.
+fn send(method: &str, params: Value) -> Pin<Box<dyn Future<Output = Value>>> {
+    let (req, rx) = ControlRequest::new(method, params);
+    let ticket = req.ticket();
+    let sent = TX.with(|t| t.borrow().as_ref().is_some_and(|tx| tx.send(req).is_ok()));
+    if !sent {
+        return Box::pin(async { json!({"ok": false, "error": "VectorCraft is not running yet"}) });
+    }
+    repaint();
+    let mut waiting = Waiting { reply: rx, ticket, answered: false };
+    Box::pin(async move {
+        loop {
+            if let Some(reply) = waiting.poll() {
+                return reply;
+            }
+            sleep(POLL_MS).await;
+        }
+    })
+}
+
+async fn sleep(ms: i32) {
+    let promise = js_sys::Promise::new(&mut |resolve, _| {
+        if let Some(window) = web_sys::window() {
+            let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms);
         }
     });
-    repaint();
-    p
+    let _ = JsFuture::from(promise).await;
 }
 
 fn set_fn(obj: &js_sys::Object, name: &str, f: JsValue) -> Result<(), JsValue> {
     js_sys::Reflect::set(obj, &name.into(), &f).map(|_| ())
 }
 
-/// Install `window.vectorcraft`.
+/// Install `window.vectorcraft`: the crate's functions, then VectorCraft's own (`inspect` is its
+/// `ui.inspect`).
 pub fn install() -> Result<(), JsValue> {
-    let obj = js_sys::Object::new();
+    let request: Request = Rc::new(|method, params| send(&method, params));
+    Rc::new(PageApi::new("vectorcraft", Methods::default(), request)).install()?;
+    let window = web_sys::window().ok_or("no window")?;
+    let obj: js_sys::Object = js_sys::Reflect::get(&window, &"vectorcraft".into())?.unchecked_into();
     set_fn(
         &obj,
-        "request",
-        Closure::<dyn Fn(String, JsValue) -> js_sys::Promise>::new(|method: String, params: JsValue| request(&method, from_js(&params)))
-            .into_js_value(),
-    )?;
-    set_fn(
-        &obj,
-        "execute",
-        Closure::<dyn Fn(String, JsValue) -> js_sys::Promise>::new(|command: String, params: JsValue| {
-            request("engine.execute", json!({"command": command, "params": from_js(&params)}))
-        })
-        .into_js_value(),
-    )?;
-    set_fn(&obj, "commands", Closure::<dyn Fn() -> js_sys::Promise>::new(|| request("engine.commands", json!({}))).into_js_value())?;
-    set_fn(&obj, "inspect", Closure::<dyn Fn() -> js_sys::Promise>::new(|| request("ui.inspect", json!({}))).into_js_value())?;
-    set_fn(
-        &obj,
-        "screenshot",
-        Closure::<dyn Fn(JsValue) -> js_sys::Promise>::new(|params: JsValue| request("ui.screenshot", from_js(&params))).into_js_value(),
+        "inspect",
+        Closure::<dyn Fn() -> js_sys::Promise>::new(|| future_to_promise(async { outcome(&send("ui.inspect", json!({})).await) })).into_js_value(),
     )?;
     set_fn(
         &obj,
@@ -178,7 +204,5 @@ pub fn install() -> Result<(), JsValue> {
         })
         .into_js_value(),
     )?;
-    let w = web_sys::window().ok_or("no window")?;
-    js_sys::Reflect::set(&w, &"vectorcraft".into(), &obj)?;
     Ok(())
 }
diff --git a/apps/vectorcraft-web/src/web.rs b/apps/vectorcraft-web/src/web.rs
index 75eb7b308..60682d698 100644
--- a/apps/vectorcraft-web/src/web.rs
+++ b/apps/vectorcraft-web/src/web.rs
@@ -370,7 +370,6 @@ impl eframe::App for WebShell {
         }
         let Some(app) = &mut self.app else { return };
         app.tick(ctx);
-        crate::api::poll_replies();
         app.finish_ime_logic(ctx);
     }
 
@@ -423,7 +422,6 @@ impl eframe::App for WebShell {
             }
             app.ui(ui);
         }
-        crate::api::poll_replies();
     }
 }
 
diff --git a/apps/vectorcraft/src/app.rs b/apps/vectorcraft/src/app.rs
index 423fb53fc..5d9eb457f 100644
--- a/apps/vectorcraft/src/app.rs
+++ b/apps/vectorcraft/src/app.rs
@@ -51,6 +51,9 @@ impl eframe::App for App {
         // A pen contact with the barrel button held presses the secondary button (Windows Ink).
         #[cfg(windows)]
         windows_stylus::raw_input_hook(raw);
+        // The characters Alt + keypad codes typed (#5108).
+        #[cfg(windows)]
+        super::windows_alt_codes::raw_input_hook(raw);
         file_access::unconfined(|| self.app.raw_input_hook(ctx, raw));
         // A mouse-up that never reached the window (#4326) is delivered once AppKit reports
         // that no mouse button is down.
diff --git a/apps/vectorcraft/src/main.rs b/apps/vectorcraft/src/main.rs
index 980d3826b..0078dd4b4 100644
--- a/apps/vectorcraft/src/main.rs
+++ b/apps/vectorcraft/src/main.rs
@@ -56,6 +56,7 @@ mod system_fonts;
 mod tablet;
 mod window;
 mod window_frame;
+mod windows_alt_codes;
 #[cfg(windows)]
 mod windows_cores;
 mod windows_stylus;
@@ -314,13 +315,18 @@ fn main() -> std::process::ExitCode {
     };
     // With Windows Ink, winit reports a pen as a touch and drops its barrel button and which end
     // is down; the message hook notes each pointer contact and whether it starts with the barrel
-    // button held, and writes the pen's end into the pen feed (`windows_stylus`).
+    // button held, and writes the pen's end into the pen feed (`windows_stylus`). It also notes the
+    // characters Alt + keypad codes type (`windows_alt_codes`).
     #[cfg(windows)]
     let options = {
         use winit::platform::windows::EventLoopBuilderExtWindows as _;
         let mut options = options;
         options.event_loop_builder = Some(Box::new(|builder| {
-            builder.with_msg_hook(windows_stylus::msg_hook);
+            builder.with_msg_hook(|msg| {
+                // Alt + keypad codes (#5108), which winit drops; neither hook consumes a message.
+                windows_alt_codes::msg_hook(msg);
+                windows_stylus::msg_hook(msg)
+            });
         }));
         options
     };
diff --git a/apps/vectorcraft/src/windows_alt_codes.rs b/apps/vectorcraft/src/windows_alt_codes.rs
new file mode 100644
index 000000000..a4ef28dbb
--- /dev/null
+++ b/apps/vectorcraft/src/windows_alt_codes.rs
@@ -0,0 +1,225 @@
+//! Alt + numeric-keypad codes on Windows (#5108): holding Alt, typing a decimal code on the
+//! numeric keypad (NumLock on) and releasing Alt types that character (`Alt+0176` → `°`).
+//!
+//! Windows does the work: when Alt comes up after keypad digits, `TranslateMessage` posts a
+//! `WM_CHAR` holding the character the code stands for (in the system's ANSI code page for a code
+//! with a leading 0, else its OEM code page), the convention every Windows text field follows
+//! (<https://learn.microsoft.com/en-us/windows/win32/inputdev/about-keyboard-input>). winit
+//! 0.30 reads a `WM_CHAR` only as part of the key press before it, so it drops this one, which
+//! follows a key release, and egui never sees the text. winit's message hook ([`msg_hook`]) sees
+//! the message before winit handles it: [`AltCodes`] notes keypad digits typed with Alt held, takes
+//! the character that follows Alt's release, and [`raw_input_hook`] hands it to the frame as typed
+//! text, so the Type tool (or a panel's text field) types it like any other character, in the
+//! same undo step as the typing round it. The keypad digits themselves are taken out of the frame,
+//! so they don't run a shortcut bound to Alt and a digit.
+//!
+//! egui reports a keypad digit as the same key as the digit above the letters, so the other
+//! platforms, whose systems have no such convention, can't tell them apart either.
+
+#![cfg_attr(not(windows), allow(dead_code))]
+
+use std::cell::RefCell;
+
+use egui::{Event, Key};
+
+const WM_KEYDOWN: u32 = 0x0100;
+const WM_KEYUP: u32 = 0x0101;
+const WM_CHAR: u32 = 0x0102;
+const WM_SYSKEYDOWN: u32 = 0x0104;
+const WM_SYSKEYUP: u32 = 0x0105;
+const WM_SYSCHAR: u32 = 0x0106;
+/// `VK_NUMPAD0` to `VK_NUMPAD9` (`winuser.h`): keypad digits with NumLock on. With it off the keys
+/// are Insert, End, … and type no code.
+const VK_NUMPAD0: usize = 0x60;
+const VK_NUMPAD9: usize = 0x69;
+/// `VK_MENU`, `VK_LMENU` and `VK_RMENU`: Alt.
+const ALT_KEYS: [usize; 3] = [0x12, 0xA4, 0xA5];
+
+thread_local! {
+    /// The UI thread's sequence: [`msg_hook`] and [`raw_input_hook`] both run on it.
+    static CODES: RefCell<AltCodes> = RefCell::new(AltCodes::default());
+}
+
+/// Where an Alt + keypad code stands, from the keyboard messages of the thread's queue.
+#[derive(Default)]
+struct AltCodes {
+    /// Keypad digits typed while Alt has been held.
+    digits: usize,
+    /// Alt came up after keypad digits: the next character message is the code's character.
+    armed: bool,
+    /// A high surrogate waiting for its low half.
+    high: Option<u16>,
+    /// Characters the codes typed, for the next frame.
+    typed: String,
+    /// Keypad digit presses and releases with Alt held since the last frame, which egui reports
+    /// as Alt and a digit: taken out of the frame.
+    keypad_events: usize,
+}
+
+impl AltCodes {
+    /// Note a keyboard message `message` with `wparam` (the virtual-key code, or a UTF-16 unit).
+    fn message(&mut self, message: u32, wparam: usize) {
+        let keypad = (VK_NUMPAD0..=VK_NUMPAD9).contains(&wparam);
+        match message {
+            // Windows sends a key pressed with Alt held as a system key.
+            WM_SYSKEYDOWN if keypad => {
+                self.digits += 1;
+                self.keypad_events += 1;
+                self.armed = false;
+            }
+            WM_SYSKEYUP if keypad => self.keypad_events += 1,
+            WM_KEYDOWN | WM_SYSKEYDOWN if ALT_KEYS.contains(&wparam) => {}
+            // Any other key ends the sequence and keeps its own meaning.
+            WM_KEYDOWN | WM_SYSKEYDOWN => self.reset(),
+            WM_KEYUP | WM_SYSKEYUP if ALT_KEYS.contains(&wparam) => {
+                self.armed = self.digits > 0;
+                self.digits = 0;
+            }
+            WM_CHAR | WM_SYSCHAR if self.armed => {
+                let unit = (wparam & 0xffff) as u16;
+                if (0xd800..0xdc00).contains(&unit) {
+                    self.high = Some(unit);
+                    return;
+                }
+                let units: Vec<u16> = self.high.take().into_iter().chain([unit]).collect();
+                self.typed.extend(char::decode_utf16(units).filter_map(Result::ok).filter(|c| !c.is_control()));
+                self.armed = false;
+            }
+            _ => {}
+        }
+    }
+
+    fn reset(&mut self) {
+        self.digits = 0;
+        self.armed = false;
+        self.high = None;
+    }
+
+    /// Hand the frame `events` the characters typed since the last frame, as typed text, and take
+    /// out the keypad digits typed with Alt held.
+    fn drain(&mut self, events: &mut Vec<Event>) {
+        let mut keypad = std::mem::take(&mut self.keypad_events);
+        if keypad > 0 {
+            events.retain(|e| {
+                let digit = matches!(e, Event::Key { key: Key::Num0 | Key::Num1 | Key::Num2 | Key::Num3 | Key::Num4 | Key::Num5 | Key::Num6 | Key::Num7 | Key::Num8 | Key::Num9, modifiers, .. } if modifiers.alt);
+                if digit && keypad > 0 {
+                    keypad -= 1;
+                    return false;
+                }
+                true
+            });
+        }
+        if !self.typed.is_empty() {
+            events.push(Event::Text(std::mem::take(&mut self.typed)));
+        }
+    }
+}
+
+/// winit's message hook for the keyboard: notes Alt + keypad codes and the characters they type.
+/// It never consumes the message.
+#[cfg(windows)]
+#[allow(unsafe_code)]
+pub fn msg_hook(msg: *const std::ffi::c_void) {
+    use windows::Win32::UI::WindowsAndMessaging::MSG;
+    // SAFETY: winit passes the `MSG` that `PeekMessageW` has just filled, which lives for this
+    // call; `as_ref` gives `None` for a null pointer.
+    let Some(msg) = (unsafe { msg.cast::<MSG>().as_ref() }) else {
+        return;
+    };
+    if (WM_KEYDOWN..=WM_SYSCHAR).contains(&msg.message) {
+        CODES.with(|c| {
+            if let Ok(mut c) = c.try_borrow_mut() {
+                c.message(msg.message, msg.wParam.0);
+            }
+        });
+    }
+}
+
+/// Before egui reads the main window's frame: the characters Alt + keypad codes typed, as text.
+pub fn raw_input_hook(raw: &mut egui::RawInput) {
+    CODES.with(|c| {
+        if let Ok(mut c) = c.try_borrow_mut() {
+            c.drain(&mut raw.events);
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const ALT: usize = 0x12;
+
+    /// Alt held, keypad digits `code`, Alt released, and the character Windows then posts.
+    fn alt_code(c: &mut AltCodes, code: &str, posted: u16) {
+        c.message(WM_SYSKEYDOWN, ALT);
+        for d in code.bytes() {
+            let vk = VK_NUMPAD0 + usize::from(d - b'0');
+            c.message(WM_SYSKEYDOWN, vk);
+            c.message(WM_SYSKEYUP, vk);
+        }
+        c.message(WM_KEYUP, ALT);
+        c.message(WM_CHAR, usize::from(posted));
+    }
+
+    fn key(key: Key, alt: bool, pressed: bool) -> Event {
+        let modifiers = egui::Modifiers { alt, ..Default::default() };
+        Event::Key { key, physical_key: Some(key), pressed, repeat: false, modifiers }
+    }
+
+    #[test]
+    fn an_alt_code_types_its_character_when_alt_comes_up() {
+        let mut c = AltCodes::default();
+        alt_code(&mut c, "0176", 0xB0);
+        alt_code(&mut c, "0151", 0x2014);
+        let mut events = vec![key(Key::Num0, true, true), key(Key::Num0, true, false), key(Key::Num1, false, true)];
+        c.drain(&mut events);
+        // The keypad digits typed with Alt are gone (eight presses and eight releases, two here);
+        // the digit typed without Alt stays, and the characters follow.
+        assert_eq!(events, vec![key(Key::Num1, false, true), Event::Text("°—".into())]);
+        let mut events = vec![key(Key::Num0, true, true)];
+        c.drain(&mut events);
+        assert_eq!(events.len(), 1, "counts don't carry over to a later frame");
+    }
+
+    #[test]
+    fn a_character_without_a_code_before_it_is_left_to_winit() {
+        let mut c = AltCodes::default();
+        // A plain key press's character (winit types it), and Alt pressed and released alone.
+        c.message(WM_KEYDOWN, 0x41);
+        c.message(WM_CHAR, usize::from(b'a'));
+        c.message(WM_SYSKEYDOWN, ALT);
+        c.message(WM_KEYUP, ALT);
+        c.message(WM_CHAR, usize::from(b'b'));
+        let mut events = vec![];
+        c.drain(&mut events);
+        assert!(events.is_empty(), "{events:?}");
+    }
+
+    #[test]
+    fn another_key_while_alt_is_held_cancels_the_code() {
+        let mut c = AltCodes::default();
+        c.message(WM_SYSKEYDOWN, ALT);
+        c.message(WM_SYSKEYDOWN, VK_NUMPAD0 + 1);
+        // Alt+F: a shortcut, not a code.
+        c.message(WM_SYSKEYDOWN, 0x46);
+        c.message(WM_KEYUP, ALT);
+        c.message(WM_CHAR, 0x41);
+        let mut events = vec![];
+        c.drain(&mut events);
+        assert!(!events.iter().any(|e| matches!(e, Event::Text(_))), "{events:?}");
+    }
+
+    #[test]
+    fn a_code_above_the_basic_plane_arrives_as_two_halves() {
+        let mut c = AltCodes::default();
+        c.message(WM_SYSKEYDOWN, ALT);
+        c.message(WM_SYSKEYDOWN, VK_NUMPAD0 + 1);
+        c.message(WM_KEYUP, ALT);
+        c.message(WM_CHAR, 0xD83D);
+        c.message(WM_CHAR, 0xDE00);
+        let mut events = vec![];
+        c.drain(&mut events);
+        assert_eq!(events, vec![Event::Text("😀".into())]);
+    }
+}
diff --git a/contributors/people.toml b/contributors/people.toml
index fe8e4ddb1..69c412f8b 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -208,8 +208,15 @@ sync_github_name = true
 [people.sadkotheguest]
 real_name = "Alexander Buraga"
 display_name = "Alexander Buraga"
-sync_github_name = false
+sync_github_name = false
 
 [people.adikshan11]
 real_name = "Adithya Shankaran"
 sync_github_name = true
+
+[people.slafebre]
+real_name = "Sven Lafebre"
+
+[people.kylekanouse]
+real_name = "Kyle Kanouse"
+sync_github_name = true
diff --git a/crates/brush/src/colorize.rs b/crates/brush/src/colorize.rs
index a62dce9ec..2cf9f43c9 100644
--- a/crates/brush/src/colorize.rs
+++ b/crates/brush/src/colorize.rs
@@ -13,15 +13,26 @@ fn luminance(c: &Color) -> f32 {
 }
 
 fn map_color(c: &Color, mode: Colorization, key: &Color) -> Color {
-    let lum = luminance(c);
+    // Black ink alone is its own tint: its amount is the tint, not how light it displays (100% K
+    // displays lighter than black).
+    let light = match *c {
+        Color::Cmyk { c, m, y, k } if c == 0.0 && m == 0.0 && y == 0.0 => 1.0 - k,
+        _ => luminance(c),
+    };
+    // A process or gray stroke color's tints and shades stay in its model.
+    let (white, black) = match key {
+        Color::Cmyk { .. } => (Color::cmyk(0.0, 0.0, 0.0, 0.0), Color::cmyk(0.0, 0.0, 0.0, 1.0)),
+        Color::Gray { .. } => (Color::gray(0.0), Color::gray(1.0)),
+        _ => (Color::WHITE, Color::BLACK),
+    };
     match mode {
         Colorization::None => *c,
-        Colorization::Tints => key.lerp(&Color::WHITE, lum),
+        Colorization::Tints => key.lerp_keep_model(&white, light),
         Colorization::TintsAndShades => {
-            if lum < 0.5 {
-                Color::BLACK.lerp(key, lum * 2.0)
+            if light < 0.5 {
+                key.lerp_keep_model(&black, 1.0 - light * 2.0)
             } else {
-                key.lerp(&Color::WHITE, (lum - 0.5) * 2.0)
+                key.lerp_keep_model(&white, (light - 0.5) * 2.0)
             }
         }
         Colorization::HueShift { key: art_key } => {
diff --git a/crates/brush/src/tests.rs b/crates/brush/src/tests.rs
index 22aad6603..8bcc8ba2b 100644
--- a/crates/brush/src/tests.rs
+++ b/crates/brush/src/tests.rs
@@ -701,6 +701,55 @@ fn tints_colorization_uses_stroke_colour() {
     assert_eq!(white.appearance.fill_paint().color().unwrap().to_rgb(), [1.0, 1.0, 1.0]);
 }
 
+/// Black ink alone is a tint by its amount: a process black stroke leaves it as it is, and another
+/// process stroke color takes that share of its inks. Tints of a process color stay process.
+#[test]
+fn tints_of_black_ink_are_its_amount_of_the_stroke_color() {
+    let tinted = |art: Color, stroke: Color| {
+        let mut n = rect_art(1.0, 1.0);
+        n.appearance.set_fill(Paint::solid(art));
+        colorize(&mut n, Colorization::Tints, &Paint::solid(stroke));
+        n.appearance.fill_paint().color().unwrap()
+    };
+    let ink = Color::cmyk(0.0, 0.0, 0.0, 0.6);
+    let close = |a: Color, b: Color| {
+        let (Color::Cmyk { c, m, y, k }, Color::Cmyk { c: c2, m: m2, y: y2, k: k2 }) = (a, b) else { panic!("{a:?} {b:?}") };
+        (c - c2).abs() < 1e-5 && (m - m2).abs() < 1e-5 && (y - y2).abs() < 1e-5 && (k - k2).abs() < 1e-5
+    };
+    assert!(close(tinted(ink, Color::cmyk(0.0, 0.0, 0.0, 1.0)), ink));
+    assert!(close(tinted(ink, Color::cmyk(0.0, 1.0, 1.0, 0.0)), Color::cmyk(0.0, 0.6, 0.6, 0.0)));
+    let [r, g, b] = tinted(ink, Color::rgb(1.0, 0.0, 0.0)).to_rgb();
+    assert!((r - 1.0).abs() < 1e-5 && (g - 0.4).abs() < 1e-5 && (b - 0.4).abs() < 1e-5, "{r} {g} {b}");
+    let Color::Gray { k } = tinted(ink, Color::gray(0.5)) else { panic!("tints of a gray stroke color stay gray") };
+    assert!((k - 0.3).abs() < 1e-5, "{k}");
+}
+
+/// Under Tints and Shades black ink stays black, however light 100% K displays, and a band of black
+/// ink is its amount: K 0.5 is the stroke color. A process or gray stroke color stays in its model.
+#[test]
+fn tints_and_shades_of_black_ink_go_by_its_amount() {
+    let mapped = |k: f32, stroke: Color| {
+        let mut n = rect_art(1.0, 1.0);
+        n.appearance.set_fill(Paint::solid(Color::cmyk(0.0, 0.0, 0.0, k)));
+        colorize(&mut n, Colorization::TintsAndShades, &Paint::solid(stroke));
+        n.appearance.fill_paint().color().unwrap()
+    };
+    let close = |a: [f32; 4], b: [f32; 4]| a.iter().zip(&b).all(|(x, y)| (x - y).abs() < 1e-5);
+    let inks = |c: Color| {
+        let Color::Cmyk { c, m, y, k } = c else { panic!("a process color: {c:?}") };
+        [c, m, y, k]
+    };
+    let orange = Color::cmyk(0.0, 0.6, 1.0, 0.0);
+    assert!(close(inks(mapped(1.0, orange)), [0.0, 0.0, 0.0, 1.0]), "black stays black");
+    assert!(close(inks(mapped(0.5, orange)), [0.0, 0.6, 1.0, 0.0]), "the stroke color");
+    assert!(close(inks(mapped(0.25, orange)), [0.0, 0.3, 0.5, 0.0]), "a tint");
+    assert!(close(inks(mapped(0.75, orange)), [0.0, 0.3, 0.5, 0.5]), "a shade");
+    let Color::Gray { k } = mapped(0.75, Color::gray(0.4)) else { panic!("a gray stroke color stays gray") };
+    assert!((k - 0.7).abs() < 1e-5, "{k}");
+    let [r, g, b] = mapped(1.0, Color::rgb(1.0, 0.0, 0.0)).to_rgb();
+    assert!(r < 1e-5 && g < 1e-5 && b < 1e-5, "black stays black: {r} {g} {b}");
+}
+
 /// Point type at (0, 0) whose characters are painted `fill` and `stroke` (1 pt wide).
 fn type_art(fill: Paint, stroke: Paint) -> Node {
     use vectorcraft_doc::{CharStyle, TextObject};
diff --git a/crates/doc/src/appearance/profile.rs b/crates/doc/src/appearance/profile.rs
index 01b9c9fc5..088796173 100644
--- a/crates/doc/src/appearance/profile.rs
+++ b/crates/doc/src/appearance/profile.rs
@@ -22,11 +22,15 @@ pub struct ProfilePreset {
 }
 
 impl WidthProfile {
-    /// (left, right) width factors at `t`, linear between points.
+    /// (left, right) width factors at `t`: a smooth curve through the points ([`Self::at_points`]).
     pub fn at(&self, t: f64) -> (f64, f64) {
         Self::at_points(&self.points, t)
     }
-    /// [`Self::at`] of a profile's points (a preset's or a saved profile's).
+    /// [`Self::at`] of a profile's points (a preset's or a saved profile's). Each side runs through
+    /// its points on a monotone cubic curve (Fritsch–Carlson): it flows through a width point
+    /// without a kink, turns flat at a point wider or narrower than both neighbours, and never
+    /// goes past either point of the span it is in (#5714). Points on one straight line stay on
+    /// it. A step (two points at one position, [`Self::around`]) ends the curve on each side of it.
     pub fn at_points(p: &[(f64, f64, f64)], t: f64) -> (f64, f64) {
         if p.is_empty() {
             return (1.0, 1.0);
@@ -36,9 +40,21 @@ impl WidthProfile {
         }
         // (Positions go forward; found in log time, so a long profile read from a file is cheap to ask.)
         let i = p.partition_point(|q| q.0 < t);
-        if let (Some(a), Some(b)) = (i.checked_sub(1).and_then(|j| p.get(j)), p.get(i)) {
-            let u = (t - a.0) / (b.0 - a.0).max(1e-9);
-            return (a.1 + (b.1 - a.1) * u, a.2 + (b.2 - a.2) * u);
+        if let (Some(j), Some(b)) = (i.checked_sub(1), p.get(i))
+            && let Some(a) = p.get(j)
+        {
+            let h = b.0 - a.0;
+            let u = (t - a.0) / h.max(1e-9);
+            let linear = (a.1 + (b.1 - a.1) * u, a.2 + (b.2 - a.2) * u);
+            if h <= STEP {
+                return linear;
+            }
+            let side = |v: fn(&(f64, f64, f64)) -> f64, straight: f64| {
+                let y = hermite(v(a), v(b), tangent(p, j, v) * h, tangent(p, i, v) * h, u);
+                // Widths read from a file may be huge: where the curve overflows, the straight line.
+                if y.is_finite() { y } else { straight }
+            };
+            return (side(|q| q.1, linear.0), side(|q| q.2, linear.1));
         }
         p.last().map_or((1.0, 1.0), |l| (l.1, l.2))
     }
@@ -55,14 +71,17 @@ impl WidthProfile {
         // Two swells between narrow necks.
         ProfilePreset { id: "wave", label: "Wave", points: &[(0.0, 0.3, 0.3), (0.25, 1.0, 1.0), (0.5, 0.3, 0.3), (0.75, 1.0, 1.0), (1.0, 0.3, 0.3)] },
     ];
-    /// The widest the stroke gets, as a multiple of its weight: the largest total of the left and
-    /// right factors at any of the points (between them the profile is straight), 1 for a profile
-    /// without points.
+    /// The widest the stroke gets, as a multiple of its weight, 1 for a profile without points. Each
+    /// side stays between the widths of the two points of each span ([`Self::at_points`]), but the
+    /// two sides needn't peak together, so a span counts its wider left and its wider right.
     pub fn widest(&self) -> f64 {
-        if self.points.is_empty() {
+        let p = &self.points;
+        if p.is_empty() {
             return 1.0;
         }
-        self.points.iter().map(|&(_, l, r)| (l.max(0.0) + r.max(0.0)) / 2.0).fold(0.0, f64::max)
+        let total = |l: f64, r: f64| (l.max(0.0) + r.max(0.0)) / 2.0;
+        let spans = p.windows(2).map(|w| total(w[0].1.max(w[1].1), w[0].2.max(w[1].2)));
+        p.iter().map(|&(_, l, r)| total(l, r)).chain(spans).fold(0.0, f64::max)
     }
     /// The built-in profile with this id.
     pub fn preset(id: &str) -> Option<Self> {
@@ -227,6 +246,41 @@ impl AngleProfile {
     }
 }
 
+/// How close two width points' positions are to make a step ([`WidthProfile::around`]).
+const STEP: f64 = 1e-7;
+
+/// The slope of one side (`v` reads it from a point) of width profile `p` at its point `j`, in
+/// width per unit of position: Fritsch–Carlson's choice for a monotone cubic curve. It is 0 where
+/// the point is wider or narrower than both neighbours, the weighted harmonic mean of the slopes
+/// of the spans on either side elsewhere (never more than three times either, so no span
+/// overshoots its points), and the span's own slope at an end of the profile or beside a step.
+fn tangent(p: &[(f64, f64, f64)], j: usize, v: fn(&(f64, f64, f64)) -> f64) -> f64 {
+    let Some(q) = p.get(j) else { return 0.0 };
+    let before = j.checked_sub(1).and_then(|k| p.get(k)).filter(|a| q.0 - a.0 > STEP);
+    let after = p.get(j + 1).filter(|b| b.0 - q.0 > STEP);
+    let slope = |a: &(f64, f64, f64), b: &(f64, f64, f64)| (v(b) - v(a)) / (b.0 - a.0);
+    match (before, after) {
+        (Some(a), Some(b)) => {
+            let (d0, d1) = (slope(a, q), slope(q, b));
+            if d0 * d1 <= 0.0 {
+                return 0.0;
+            }
+            let (h0, h1) = (q.0 - a.0, b.0 - q.0);
+            3.0 * (h0 + h1) / ((2.0 * h1 + h0) / d0 + (h1 + 2.0 * h0) / d1)
+        }
+        (Some(a), None) => slope(a, q),
+        (None, Some(b)) => slope(q, b),
+        (None, None) => 0.0,
+    }
+}
+
+/// The cubic Hermite curve from `y0` to `y1` at `u` (0..1), with end slopes `m0` and `m1` per
+/// whole span.
+fn hermite(y0: f64, y1: f64, m0: f64, m1: f64, u: f64) -> f64 {
+    let (u2, u3) = (u * u, u * u * u);
+    (2.0 * u3 - 3.0 * u2 + 1.0) * y0 + (u3 - 2.0 * u2 + u) * m0 + (-2.0 * u3 + 3.0 * u2) * y1 + (u3 - u2) * m1
+}
+
 /// The value of samples `p` (position, value) at `t`, linear between them; `None` without any.
 fn interpolated(p: &[(f64, f64)], t: f64) -> Option<f64> {
     let (first, last) = (p.first()?, p.last()?);
@@ -341,6 +395,7 @@ pub struct SavedProfile {
 mod tests {
     use super::*;
 
+    /// Widths and steps are found by search, at the ends, between points and at a step.
     #[test]
     fn width_profile_lookups_by_search() {
         let p = WidthProfile { points: vec![(0.0, 0.0, 0.0), (0.5, 1.0, 1.0), (0.5, 0.5, 0.25), (1.0, 0.0, 0.0)] };
@@ -358,4 +413,93 @@ mod tests {
         let near = WidthProfile { points: vec![(0.4999999, 2.0, 2.0), (0.5, 1.0, 1.0), (0.5, 0.5, 0.25)] };
         assert_eq!(near.around(0.5), ((1.0, 1.0), (0.5, 0.25)));
     }
+
+    /// The slope of one side of `p` just before and just after `t`.
+    fn slopes(p: &WidthProfile, t: f64) -> (f64, f64) {
+        let e = 1e-6;
+        ((p.at(t).0 - p.at(t - e).0) / e, (p.at(t + e).0 - p.at(t).0) / e)
+    }
+
+    /// #5714: the width flows through a width point instead of turning a corner there.
+    #[test]
+    fn widths_run_smoothly_through_width_points() {
+        // A swell in the middle: flat at its widest, and a quarter of the way along above the
+        // straight ramp from 1 to 3 (2).
+        let swell = WidthProfile { points: vec![(0.0, 1.0, 1.0), (0.5, 3.0, 2.0), (1.0, 1.0, 1.0)] };
+        let (before, after) = slopes(&swell, 0.5);
+        assert!(before.abs() < 1e-4 && after.abs() < 1e-4, "{before} {after}");
+        let (l, r) = swell.at(0.25);
+        assert!((l - 2.25).abs() < 1e-12 && (r - 1.625).abs() < 1e-12, "{l} {r}");
+        // Rising on both sides of a point: the slope is the same either side of it.
+        let rise = WidthProfile { points: vec![(0.0, 0.0, 0.0), (0.3, 1.0, 1.0), (1.0, 4.0, 4.0)] };
+        let (before, after) = slopes(&rise, 0.3);
+        assert!(before > 0.0 && (before - after).abs() < 1e-3 * before, "{before} {after}");
+        // Points on one line stay on it.
+        let straight = WidthProfile { points: vec![(0.0, 0.0, 1.0), (0.25, 0.5, 1.0), (1.0, 2.0, 1.0)] };
+        for t in [0.1, 0.25, 0.6, 0.9] {
+            let (l, r) = straight.at(t);
+            assert!((l - 2.0 * t).abs() < 1e-12 && (r - 1.0).abs() < 1e-12, "{t}: {l} {r}");
+        }
+    }
+
+    /// Neither side of a profile goes wider or narrower than the two points of the span it is in.
+    #[test]
+    fn widths_never_pass_the_points_either_side() {
+        for preset in WidthProfile::PRESETS {
+            let p = WidthProfile { points: preset.points.to_vec() };
+            for w in p.points.windows(2) {
+                let (lo, hi) = (w[0].1.min(w[1].1), w[0].1.max(w[1].1));
+                for k in 0..=100 {
+                    let t = w[0].0 + (w[1].0 - w[0].0) * k as f64 / 100.0;
+                    let l = p.at(t).0;
+                    assert!(l >= lo - 1e-12 && l <= hi + 1e-12, "{}: {l} at {t} outside {lo}..{hi}", preset.id);
+                }
+            }
+        }
+        // Uneven spacing and a steep jump next to a gentle rise.
+        let p = WidthProfile { points: vec![(0.0, 0.0, 0.0), (0.05, 1.0, 1.0), (0.9, 1.1, 1.1), (1.0, 5.0, 5.0)] };
+        for k in 0..=1000 {
+            let t = k as f64 / 1000.0;
+            let l = p.at(t).0;
+            let span = p.points.windows(2).find(|w| t >= w[0].0 && t <= w[1].0).map(|w| (w[0].1.min(w[1].1), w[0].1.max(w[1].1)));
+            let (lo, hi) = span.unwrap();
+            assert!(l >= lo - 1e-12 && l <= hi + 1e-12, "{l} at {t}");
+        }
+    }
+
+    /// A step still breaks the width sharply, and the curve on either side ends at it.
+    #[test]
+    fn a_step_ends_the_curve_on_each_side() {
+        let p = WidthProfile { points: vec![(0.0, 1.0, 1.0), (0.5, 3.0, 3.0), (0.5, 1.0, 1.0), (1.0, 2.0, 2.0)] };
+        assert_eq!(p.around(0.5), ((3.0, 3.0), (1.0, 1.0)));
+        // Two points between ends: each side of the step is a straight ramp.
+        assert!((p.at(0.25).0 - 2.0).abs() < 1e-12 && (p.at(0.75).0 - 1.5).abs() < 1e-12);
+    }
+
+    /// `widest()` is at least the stroke's width anywhere along the profile, even where the sides peak apart.
+    #[test]
+    fn widest_covers_every_width_along_the_profile() {
+        let profiles = [
+            vec![(0.0, 1.0, 0.0), (0.5, 0.2, 1.0), (1.0, 1.0, 0.0)],
+            vec![(0.0, 0.0, 1.0), (0.3, 1.0, 0.0), (0.6, 0.0, 1.0), (1.0, 1.0, 1.0)],
+            vec![(0.0, 0.3, 0.3), (0.25, 1.0, 1.0), (0.5, 0.3, 0.3), (0.75, 1.0, 1.0), (1.0, 0.3, 0.3)],
+        ];
+        for points in profiles {
+            let p = WidthProfile { points };
+            let most = (0..=1000).map(|k| p.at(k as f64 / 1000.0)).map(|(l, r)| (l.max(0.0) + r.max(0.0)) / 2.0).fold(0.0, f64::max);
+            assert!(p.widest() >= most - 1e-12, "{} < {most}: {:?}", p.widest(), p.points);
+        }
+        assert_eq!(WidthProfile::lens().widest(), 1.0);
+        assert_eq!(WidthProfile::default().widest(), 1.0);
+    }
+
+    /// Widths read from a file may be absurd: the curve stays finite or falls back to the line.
+    #[test]
+    fn huge_widths_stay_finite() {
+        let p = WidthProfile { points: vec![(0.0, 0.0, 0.0), (0.5, f64::MAX, 1.0), (1.0, -f64::MAX, 0.0)] };
+        for k in 0..=10 {
+            let (l, r) = p.at(k as f64 / 10.0);
+            assert!(!l.is_nan() && r.is_finite(), "{l} {r}");
+        }
+    }
 }
diff --git a/crates/doc/src/appearance/tests.rs b/crates/doc/src/appearance/tests.rs
index 089309f34..c297b3475 100644
--- a/crates/doc/src/appearance/tests.rs
+++ b/crates/doc/src/appearance/tests.rs
@@ -192,11 +192,14 @@ fn strokes_without_pressure_round_trip_unchanged() {
     assert_eq!((st.pressure, st.tilt, st.bearing, st.rotation), (None, None, None, None));
 }
 
+/// The Lens profile's widths at its middle, a quarter of the way along and past its end.
 #[test]
 fn profile_interp() {
     let p = WidthProfile::lens();
     assert_eq!(p.at(0.5), (1.0, 1.0));
-    assert_eq!(p.at(0.25), (0.5, 0.5));
+    // Half way up the lens the width curves above the straight ramp (0.5), flattening into its
+    // widest point (#5714).
+    assert_eq!(p.at(0.25), (0.625, 0.625));
     assert_eq!(p.at(2.0), (0.0, 0.0));
 }
 
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 988df4c51..6d069872d 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -326,8 +326,8 @@ pub struct Document {
     #[serde(skip)]
     pub retired_artboard_id: RetiredArtboardId,
     /// The id of the artboard an imported file names as its active one (a `.ai` file's
-    /// `CropAreaActive`): the document opens with that artboard active. `None`: the first. Never
-    /// saved.
+    /// `CropAreaActive`): the document opens with that artboard active. A `.ai` save or export
+    /// names it as the file's active artboard. `None`: the first. Native files do not keep it.
     #[serde(skip)]
     pub opened_artboard: Option<u32>,
     /// Some object is a dimension (the Dimension tool): edits refresh dimensions only while this
diff --git a/crates/doc/src/live.rs b/crates/doc/src/live.rs
index 9a2aa4fea..40a1c78b0 100644
--- a/crates/doc/src/live.rs
+++ b/crates/doc/src/live.rs
@@ -53,8 +53,8 @@ pub use blend_spec::{BlendDefaults, BlendEase, BlendEaseType, BlendOrientation,
 #[cfg(test)]
 use blend_spec::{blend_color_shift, blend_ramp};
 pub use envelope::{
-    EnvelopeKind, EnvelopeMap, EnvelopeOptions, H_DOWN, H_LEFT, H_RIGHT, H_UP, PreserveShape, envelope_bounds, envelope_expand, envelope_frame,
-    envelope_grid, envelope_mapper, envelope_of, envelope_overlay, smooth_handles,
+    EnvelopeKind, EnvelopeMap, EnvelopeOptions, H_DOWN, H_LEFT, H_RIGHT, H_UP, PreserveShape, envelope_bounds, envelope_content_boxes,
+    envelope_expand, envelope_frame, envelope_grid, envelope_mapper, envelope_of, envelope_overlay, envelope_stroke_margin, smooth_handles,
 };
 pub(crate) use expand::max_outset;
 pub use expand::{
@@ -233,6 +233,64 @@ mod tests {
         assert_eq!(envelope_mapper(&kind, Rect::new(0.0, 0.0, 100.0, 100.0))(p), p);
     }
 
+    /// `bounds_margin` grows the box an envelope maps from, only while Distort Appearance is on. It
+    /// holds shares of the box, and an envelope with an uneven frame maps from the same box in that
+    /// frame. A native file writes it only when it isn't zero.
+    #[test]
+    fn an_envelope_maps_from_its_box_with_its_margins() {
+        let rect = Node::path(NodeId(2), vectorcraft_geom::shapes::rectangle(Rect::new(10.0, 20.0, 110.0, 70.0)), crate::Appearance::default_art());
+        let kind = EnvelopeKind::Warp { style: "arc".into(), bend: 0.0, h: 0.0, v: 0.0, horizontal: true };
+        let content = [Arc::new(rect)];
+        let src = |content: &[Arc<Node>], frame: Affine, options: EnvelopeOptions| EnvelopeMap::new(content, &kind, frame, options).unwrap().src();
+        // Top, bottom, left and right.
+        let on = EnvelopeOptions { bounds_margin: [0.125, 0.25, 0.0625, 0.5], ..EnvelopeOptions::NEW };
+        let geometric = Rect::new(10.0, 20.0, 110.0, 70.0);
+        let grown = Rect::new(3.75, 13.75, 160.0, 82.5);
+        assert_eq!(src(&content, Affine::IDENTITY, EnvelopeOptions::default()), geometric);
+        assert_eq!(src(&content, Affine::IDENTITY, on), grown);
+        assert_eq!(src(&content, Affine::IDENTITY, EnvelopeOptions { distort_appearance: false, ..on }), geometric);
+        for bad in [f32::NAN, f32::INFINITY, -0.05] {
+            assert_eq!(src(&content, Affine::IDENTITY, EnvelopeOptions { bounds_margin: [bad, 0.25, 0.0625, 0.5], ..on }), geometric);
+        }
+        // A finite share of a box too wide to grow leaves the box as it is.
+        let wide = Node::path(NodeId(3), vectorcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, 1e308, 10.0)), crate::Appearance::default_art());
+        let wide = [Arc::new(wide)];
+        let huge = EnvelopeOptions { bounds_margin: [0.0, 0.0, f32::MAX, 0.0], ..on };
+        assert_eq!(src(&wide, Affine::IDENTITY, huge), src(&wide, Affine::IDENTITY, EnvelopeOptions::NEW));
+        // Bounds follow the box: a warp that doesn't bend covers it.
+        let b = envelope_bounds(&content, &kind, Affine::IDENTITY, on).unwrap();
+        assert!((b.x0 - 3.75).abs() < 1e-6 && (b.y1 - 82.5).abs() < 1e-6, "{b:?}");
+        // Art taken through an uneven frame maps from the same box in that frame.
+        let frame = Affine::rotate(std::f64::consts::FRAC_PI_2) * Affine::scale_non_uniform(2.0, 0.5);
+        let mut placed = (*content[0]).clone();
+        placed.transform(frame, true);
+        let framed = src(&[Arc::new(placed)], frame, on);
+        assert!((framed.x0 - 3.75).abs() + (framed.y0 - 13.75).abs() + (framed.x1 - 160.0).abs() + (framed.y1 - 82.5).abs() < 1e-6, "{framed:?}");
+
+        // A frame that turns and scales gives the same margins as the art had before it took them.
+        let mut stroked = (*content[0]).clone();
+        if let Some(s) = stroked.appearance.stroke_mut() {
+            s.width = 10.0;
+        }
+        let margin = |n: &Node, frame: Affine| {
+            let (with, plain) = envelope_content_boxes(&[Arc::new(n.clone())], frame).unwrap();
+            envelope_stroke_margin(with, plain).unwrap()
+        };
+        let before = margin(&stroked, Affine::IDENTITY);
+        assert_eq!(before.map(|m| (m * 1000.0).round()), [100.0, 100.0, 50.0, 50.0]);
+        let frame = Affine::rotate(std::f64::consts::FRAC_PI_2) * Affine::scale(2.0);
+        let mut turned = stroked.clone();
+        turned.transform(frame, true);
+        assert_eq!(margin(&turned, frame).map(|m| (m * 1000.0).round()), before.map(|m| (m * 1000.0).round()));
+        // Margins an `f32` can't hold are none.
+        assert_eq!(envelope_stroke_margin(Rect::new(-5e41, 0.0, 100.0, 100.0), Rect::new(0.0, 0.0, 100.0, 100.0)), None);
+
+        assert!(serde_json::to_value(EnvelopeOptions::default()).unwrap().get("boundsMargin").is_none());
+        let saved = serde_json::to_value(on).unwrap();
+        assert_eq!(saved["boundsMargin"], serde_json::json!([0.125, 0.25, 0.0625, 0.5]));
+        assert_eq!(serde_json::from_value::<EnvelopeOptions>(saved).unwrap(), on);
+    }
+
     /// How far the border of `m` strays from the ellipse in `r`, in points (measured across the
     /// ellipse's short radius), checked at 20 places along every border edge.
     fn mesh_border_off_ellipse(m: &GradientMesh, r: Rect) -> f64 {
diff --git a/crates/doc/src/live/envelope.rs b/crates/doc/src/live/envelope.rs
index 6604c86d1..78e1a5bf0 100644
--- a/crates/doc/src/live/envelope.rs
+++ b/crates/doc/src/live/envelope.rs
@@ -76,6 +76,12 @@ pub struct EnvelopeOptions {
     pub distort_linear_gradients: bool,
     /// Distort Pattern Fills (with Distort Appearance): pattern tiles bend with the art.
     pub distort_pattern_fills: bool,
+    /// With Distort Appearance, how far the box the content maps from reaches past its geometric
+    /// bounds at the top, bottom, left and right, as shares of their height and width. An envelope
+    /// opened from a `.ai` whose saved size includes its strokes has these margins. New envelopes
+    /// have none. Leaving Edit Contents measures them again when the strokes reach differently.
+    #[serde(skip_serializing_if = "crate::skip::is_default")]
+    pub bounds_margin: [f32; 4],
 }
 
 impl Default for EnvelopeOptions {
@@ -86,6 +92,7 @@ impl Default for EnvelopeOptions {
             distort_appearance: false,
             distort_linear_gradients: false,
             distort_pattern_fills: false,
+            bounds_margin: [0.0; 4],
         }
     }
 }
@@ -98,6 +105,7 @@ impl EnvelopeOptions {
         distort_appearance: true,
         distort_linear_gradients: false,
         distort_pattern_fills: false,
+        bounds_margin: [0.0; 4],
     };
     /// Do gradients bend with the art?
     pub fn gradients(&self) -> bool {
@@ -107,6 +115,45 @@ impl EnvelopeOptions {
     pub fn patterns(&self) -> bool {
         self.distort_appearance && self.distort_pattern_fills
     }
+    /// The box content with geometric bounds `r` maps from. Margins that aren't finite, are
+    /// negative or give a box that isn't finite count as none.
+    fn source_box(&self, r: Rect) -> Rect {
+        let [top, bottom, left, right] = self.bounds_margin.map(f64::from);
+        if !self.distort_appearance || !self.bounds_margin.iter().all(|m| m.is_finite() && *m >= 0.0) {
+            return r;
+        }
+        let grown = crate::marks::outset(r, [top * r.height(), bottom * r.height(), left * r.width(), right * r.width()]);
+        if grown.is_finite() { grown } else { r }
+    }
+}
+
+/// The bounds of `content` in the axes of `frame`, with its strokes and geometric. Strokes scale
+/// with the frame as [`Node::transform`] scales them.
+pub fn envelope_content_boxes(content: &[Arc<Node>], frame: Affine) -> Option<(Rect, Rect)> {
+    let frame = if frame.is_finite() && frame.determinant().abs() > 1e-12 { frame } else { Affine::IDENTITY };
+    let to_frame = frame.inverse();
+    let (stroked, plain) = content.iter().fold((None, None), |(stroked, plain), c| {
+        let mut m = (**c).clone();
+        m.transform(to_frame, true);
+        (vectorcraft_geom::union_opt(stroked, m.visual_bounds()), vectorcraft_geom::union_opt(plain, m.geometric_bounds()))
+    });
+    Some((stroked?, plain?))
+}
+
+/// The [`EnvelopeOptions::bounds_margin`] of content with bounds `stroked` and `plain`. `None` for
+/// content with no width or no height, or for margins an `f32` can't hold.
+pub fn envelope_stroke_margin(stroked: Rect, plain: Rect) -> Option<[f32; 4]> {
+    if plain.width() < 1e-6 || plain.height() < 1e-6 {
+        return None;
+    }
+    let margin = [
+        (plain.y0 - stroked.y0) / plain.height(),
+        (stroked.y1 - plain.y1) / plain.height(),
+        (plain.x0 - stroked.x0) / plain.width(),
+        (stroked.x1 - plain.x1) / plain.width(),
+    ]
+    .map(|m| m as f32);
+    margin.iter().all(|m| m.is_finite()).then_some(margin)
 }
 
 /// Handle slots of a [`MeshPoint`]: towards the next column, previous column, next row, previous row.
@@ -218,9 +265,9 @@ pub struct EnvelopeMap<'a> {
 }
 
 impl<'a> EnvelopeMap<'a> {
-    /// The map of an envelope of `kind` around `content` with `frame`. `None` when the content
-    /// has no bounds.
-    pub fn new(content: &[Arc<Node>], kind: &'a EnvelopeKind, frame: Affine) -> Option<Self> {
+    /// The map of an envelope of `kind` around `content` with `frame` and `options`. `None` when
+    /// the content has no bounds.
+    pub fn new(content: &[Arc<Node>], kind: &'a EnvelopeKind, frame: Affine, options: EnvelopeOptions) -> Option<Self> {
         let frame = if frame.is_finite() && frame.determinant().abs() > 1e-12 { frame } else { Affine::IDENTITY };
         let to_frame = frame.inverse();
         let src = if frame == Affine::IDENTITY {
@@ -232,13 +279,14 @@ impl<'a> EnvelopeMap<'a> {
                 Some(vectorcraft_geom::union_opt(acc, m.geometric_bounds()))
             })??
         };
+        let src = options.source_box(src);
         Some(Self { src, frame, to_frame, surface: surface_of(kind, src, frame) })
     }
 
     /// The map of envelope node `n` (`None` for other nodes).
     pub fn of(n: &'a Node) -> Option<Self> {
         match &n.kind {
-            NodeKind::Envelope { content, kind, frame, .. } => Self::new(content, kind, **frame),
+            NodeKind::Envelope { content, kind, frame, options, .. } => Self::new(content, kind, **frame, *options),
             _ => None,
         }
     }
@@ -302,7 +350,7 @@ pub(super) fn expand_envelope(
     frame: Affine,
     hooks: Hooks,
 ) -> Vec<Node> {
-    let Some(map) = EnvelopeMap::new(content, kind, frame) else { return content.iter().map(|c| (**c).clone()).collect() };
+    let Some(map) = EnvelopeMap::new(content, kind, frame, options) else { return content.iter().map(|c| (**c).clone()).collect() };
     let src = map.src();
     let fid = if fidelity.is_finite() { fidelity.clamp(0.0, 100.0) / 100.0 } else { 0.5 };
     let f = |p: Point| map.map(p);
@@ -319,7 +367,7 @@ pub(super) fn expand_envelope(
 }
 
 /// Envelope bounds: a mesh's points, a top object's path, the warp's surface (sampled).
-pub fn envelope_bounds(content: &[Arc<Node>], kind: &EnvelopeKind, frame: Affine) -> Option<Rect> {
+pub fn envelope_bounds(content: &[Arc<Node>], kind: &EnvelopeKind, frame: Affine, options: EnvelopeOptions) -> Option<Rect> {
     match kind {
         EnvelopeKind::Mesh { rows, cols, points, handles } if !handles.is_empty() => envelope_grid(*rows, *cols, points, handles)?.outline().bounds(),
         EnvelopeKind::Mesh { points, .. } => {
@@ -327,6 +375,6 @@ pub fn envelope_bounds(content: &[Arc<Node>], kind: &EnvelopeKind, frame: Affine
             Some(points.iter().fold(Rect::from_points(first, first), |r, p| r.union_pt(*p)))
         }
         EnvelopeKind::TopObject { path } => path.bounds(),
-        EnvelopeKind::Warp { .. } => EnvelopeMap::new(content, kind, frame)?.bounds(),
+        EnvelopeKind::Warp { .. } => EnvelopeMap::new(content, kind, frame, options)?.bounds(),
     }
 }
diff --git a/crates/doc/src/node/extras.rs b/crates/doc/src/node/extras.rs
index 239dce93c..90b2726d3 100644
--- a/crates/doc/src/node/extras.rs
+++ b/crates/doc/src/node/extras.rs
@@ -66,6 +66,9 @@ pub struct NodeExtras {
     /// As an instance of a dynamic symbol, its own appearance changes to objects of the symbol's
     /// art (see [`crate::symbol_overrides`]); empty for none.
     pub symbol_overrides: Vec<crate::SymbolOverride>,
+    /// As an envelope with margins in Edit Contents, the margins its strokes gave when Edit Contents
+    /// began ([`crate::live::EnvelopeOptions::bounds_margin`]).
+    pub envelope_edit_margin: Option<[f32; 4]>,
 }
 
 /// No extras: what [`Node::extras`] gives for a node without any.
@@ -91,6 +94,7 @@ pub(super) static NO_EXTRAS: NodeExtras = NodeExtras {
     compound_shape: false,
     shape_mode: crate::ShapeMode::Add,
     symbol_overrides: Vec::new(),
+    envelope_edit_margin: None,
 };
 
 /// A node's [`NodeExtras`], if it has any ([`Node::extras`]). Extras that are all unset equal
diff --git a/crates/doc/src/node/ops.rs b/crates/doc/src/node/ops.rs
index f31f942ce..2b2bef296 100644
--- a/crates/doc/src/node/ops.rs
+++ b/crates/doc/src/node/ops.rs
@@ -300,7 +300,7 @@ impl Node {
                 self.projected(Some(xf.transform_rect_bbox(art)))
             }
             NodeKind::Blend { children, spec } => vectorcraft_geom::union_opt(union(children), spec.spine.as_ref().and_then(|s| s.bounds())),
-            NodeKind::Envelope { content, kind, frame, .. } => crate::live::envelope_bounds(content, kind, **frame),
+            NodeKind::Envelope { content, kind, frame, options, .. } => crate::live::envelope_bounds(content, kind, **frame, *options),
             NodeKind::Mesh(m) => m.bounds(),
             // Each copy is measured where the repeat draws it: `RepeatSpec::transforms` lays the
             // copies out by the source's bounds measured without the document.
@@ -332,6 +332,14 @@ impl Node {
         self.visual(Some(symbols))
     }
 
+    /// The visual box of a group or layer without a clipping path, from the visual boxes of its
+    /// [`Node::editing_children`]: for a walk that measures the members as well.
+    pub fn visual_of_members(&self, members: impl Iterator<Item = Option<Rect>>) -> Option<Rect> {
+        // The container's own strokes paint around its members.
+        let o = self.appearance.outset();
+        members.fold(None, vectorcraft_geom::union_opt).map(|b| b.inflate(o, o))
+    }
+
     /// The box of [`Node::visual_bounds`], or of [`Node::visual_bounds_with`] when `symbols` is
     /// given.
     pub(crate) fn visual(&self, symbols: Option<&SymbolBoxes>) -> Option<Rect> {
@@ -346,11 +354,7 @@ impl Node {
                 }
             }
             NodeKind::Intertwine { children } => children.iter().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, c.visual(symbols))),
-            NodeKind::Layer { .. } | NodeKind::Group { .. } => {
-                // The container's own strokes paint around its members.
-                let o = self.appearance.outset();
-                self.editing_children().iter().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, c.visual(symbols))).map(|b| b.inflate(o, o))
-            }
+            NodeKind::Layer { .. } | NodeKind::Group { .. } => self.visual_of_members(self.editing_children().iter().map(|c| c.visual(symbols))),
             NodeKind::Blend { children, spec } => {
                 let b = children.iter().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, c.visual(symbols)));
                 let o = crate::live::max_outset(children, symbols);
diff --git a/crates/doc/src/node/tests.rs b/crates/doc/src/node/tests.rs
index cde4004ae..ee29f75eb 100644
--- a/crates/doc/src/node/tests.rs
+++ b/crates/doc/src/node/tests.rs
@@ -21,6 +21,7 @@ fn extras_are_written_flat_in_order() {
         e.live_paint_gaps = Some(Box::default());
         e.compound_shape = true;
         e.shape_mode = crate::ShapeMode::Exclude;
+        e.envelope_edit_margin = Some([0.5, 0.5, 0.25, 0.25]);
     }
     /// The top-level keys of a JSON object, in the order written.
     struct Keys(Vec<String>);
@@ -65,6 +66,7 @@ fn extras_are_written_flat_in_order() {
         "live_paint_gaps",
         "compound_shape",
         "shape_mode",
+        "envelope_edit_margin",
     ];
     assert_eq!(keys, order);
     assert_eq!(v["shape_mode"], "exclude");
@@ -443,6 +445,20 @@ fn visual_bounds_include_stroke() {
     assert_eq!(p.visual_bounds(), Some(Rect::new(-0.5, -0.5, 10.5, 10.5)));
 }
 
+/// A group's box from its members' boxes grows by the group's own strokes, leaves out members
+/// without a box, and is `None` when none has one.
+#[test]
+fn visual_of_members_unions_the_members_and_grows_by_the_group_stroke() {
+    let mut g = Node::group(NodeId(1), vec![]);
+    g.appearance = Appearance::default_art().into();
+    let (a, b) = (Rect::new(0.0, 0.0, 10.0, 10.0), Rect::new(20.0, 5.0, 30.0, 8.0));
+    let o = g.appearance.outset();
+    assert!(o > 0.0);
+    assert_eq!(g.visual_of_members([Some(a), None, Some(b)].into_iter()), Some(Rect::new(0.0, 0.0, 30.0, 10.0).inflate(o, o)));
+    assert_eq!(g.visual_of_members([None, None].into_iter()), None);
+    assert_eq!(g.visual_of_members([].into_iter()), None);
+}
+
 /// Type's visual bounds grow by how far its character strokes paint past the glyphs: half the
 /// weight centred, the whole weight outside, nothing inside; scaled with the type.
 #[test]
diff --git a/crates/doc/src/node/wire.rs b/crates/doc/src/node/wire.rs
index ed81b1391..32191f58c 100644
--- a/crates/doc/src/node/wire.rs
+++ b/crates/doc/src/node/wire.rs
@@ -53,6 +53,7 @@ impl Serialize for Node {
             is_default(&e.compound_shape),
             is_default(&e.shape_mode),
             e.symbol_overrides.is_empty(),
+            e.envelope_edit_margin.is_none(),
         ];
         let mut st = s.serialize_struct("Node", skips.iter().filter(|s| !**s).count())?;
         let mut skip = skips.into_iter();
@@ -94,6 +95,7 @@ impl Serialize for Node {
         field!("compound_shape", &e.compound_shape);
         field!("shape_mode", &e.shape_mode);
         field!("symbol_overrides", &e.symbol_overrides);
+        field!("envelope_edit_margin", &e.envelope_edit_margin);
         st.end()
     }
 }
@@ -232,6 +234,8 @@ pub(super) struct NodeWire {
     shape_mode: crate::ShapeMode,
     #[serde(default, deserialize_with = "counted_list")]
     symbol_overrides: Vec<crate::SymbolOverride>,
+    #[serde(default)]
+    envelope_edit_margin: Option<[f32; 4]>,
 }
 
 impl From<NodeWire> for Node {
@@ -258,6 +262,7 @@ impl From<NodeWire> for Node {
             compound_shape: w.compound_shape,
             shape_mode: w.shape_mode,
             symbol_overrides: w.symbol_overrides,
+            envelope_edit_margin: w.envelope_edit_margin,
         };
         Node {
             id: w.id,
diff --git a/crates/doc/src/setup.rs b/crates/doc/src/setup.rs
index c26918153..99eee0336 100644
--- a/crates/doc/src/setup.rs
+++ b/crates/doc/src/setup.rs
@@ -164,6 +164,9 @@ pub const LANGUAGES: &[(&str, &str, Quotes)] = &[
     ("Polish", "pl", Quotes { double: ['„', '”'], single: ['‚', '’'] }),
     ("Czech", "cs", Quotes { double: ['„', '“'], single: ['‚', '‘'] }),
     ("Russian", "ru", Quotes { double: ['«', '»'], single: ['„', '“'] }),
+    // „…“ at either level: CLDR (https://github.com/unicode-org/cldr/blob/main/common/main/bg.xml,
+    // `delimiters`). Shaped as `bg`, fonts draw their Bulgarian forms (`locl` for `BGR`, #5945).
+    ("Bulgarian", "bg", Quotes { double: ['„', '“'], single: ['„', '“'] }),
     // „…” outside, ’…’ inside: Pravopis srpskoga jezika (Matica srpska, 2010, ISBN
     // 978-86-7946-079-0, т. 168, pp. 133–135) and CLDR
     // (https://github.com/unicode-org/cldr/blob/main/common/main/sr.xml, `delimiters`).
@@ -185,6 +188,8 @@ pub const LANGUAGES: &[(&str, &str, Quotes)] = &[
     ("Kannada", "kn", Quotes::ENGLISH),
     ("Malayalam", "ml", Quotes::ENGLISH),
     ("Odia", "or", Quotes::ENGLISH),
+    ("Assamese", "as", Quotes::ENGLISH),
+    ("Sanskrit", "sa", Quotes::ENGLISH),
     ("Urdu", "ur", Quotes::ENGLISH),
 ];
 
@@ -374,6 +379,8 @@ mod tests {
     fn char_languages_are_stored_by_tag() {
         assert_eq!(char_language("Turkish"), Ok(Some("tr")));
         assert_eq!(char_language("MR"), Ok(Some("mr")));
+        assert_eq!(char_language("Assamese"), Ok(Some("as")));
+        assert_eq!(char_language("Sanskrit"), Ok(Some("sa")));
         assert_eq!(char_language("english: usa"), Ok(None));
         assert_eq!(char_language("en-US"), Ok(None));
         assert!(char_language("Klingon").is_err() && char_language("").is_err());
@@ -385,6 +392,10 @@ mod tests {
         assert_eq!(char_language("Serbian: Cyrillic"), Ok(Some("sr-Cyrl")));
         assert_eq!(char_language("sr-latn"), Ok(Some("sr-Latn")));
         assert_eq!(char_language("Croatian"), Ok(Some("hr")));
+        // Bulgarian (#5945), by name or tag.
+        assert_eq!(char_language("Bulgarian"), Ok(Some("bg")));
+        assert_eq!(char_language("BG"), Ok(Some("bg")));
+        assert_eq!(char_language_name(Some("bg")), Some("Bulgarian"));
         assert_eq!(char_language_name(Some("sr-Cyrl")), Some("Serbian: Cyrillic"));
         // Every entry has a tag of its own, and a name of its own.
         for (i, (n, t, _)) in LANGUAGES.iter().enumerate() {
@@ -409,6 +420,9 @@ mod tests {
         }
         let mut prev = None;
         assert_eq!(language_quotes("croatian").unwrap().apply("\"a 'b' c\"", &mut prev), "„a ‚b‘ c“");
+        // Bulgarian: „…“ at either level, as CLDR has it.
+        let mut prev = None;
+        assert_eq!(language_quotes("bulgarian").unwrap().apply("\"a 'b' c\"", &mut prev), "„a „b“ c“");
         // Converting in pieces keeps the context.
         let mut prev = None;
         let a = Quotes::ENGLISH.apply("\"", &mut prev);
diff --git a/crates/effects/src/reshape.rs b/crates/effects/src/reshape.rs
index 38d79c125..b3acf07a5 100644
--- a/crates/effects/src/reshape.rs
+++ b/crates/effects/src/reshape.rs
@@ -42,6 +42,31 @@ pub fn has_gradient_copies(n: &Node) -> bool {
     (n.appearance.has_unplaced_gradient() || n.appearance.has_placed_gradient()) && has_transform_copies(n)
 }
 
+/// Is `n` a path or compound path with a visible Transform effect that makes copies and fills and
+/// strokes that paint the copies differently as one path than as separate objects
+/// ([`paints_copies_apart`])? Such an object is drawn through its art ([`outline_art`]), each copy
+/// an object of its own above the one before ([`copy_leaf`]), as Expand Appearance makes it
+/// (#5920).
+pub(crate) fn has_layered_copies(n: &Node) -> bool {
+    leaf_geometry(n).is_some_and(|(_, rule)| paints_copies_apart(&n.appearance, rule)) && has_transform_copies(n)
+}
+
+/// Do the fills and strokes `a` of a path with fill rule `rule` paint a Transform effect's copies
+/// differently when the copies are one path than when each is an object of its own? They do
+/// unless they paint once, in full and in Normal mode, with a stroke or a nonzero fill: then the
+/// one path paints what the copies paint together. A fill and a stroke paint each copy's stroke
+/// under the fills of the copies above it, a second fill or stroke likewise, the even-odd rule
+/// leaves holes where copies overlap, and a partly transparent or blended fill or stroke paints
+/// overlapping copies twice (#5920).
+fn paints_copies_apart(a: &Appearance, rule: FillRule) -> bool {
+    let mut painting = a.items.iter().filter(|i| crate::paints(i));
+    let (Some(one), None) = (painting.next(), painting.next()) else {
+        // None paints (nothing to draw either way), or several do.
+        return a.items.iter().any(crate::paints);
+    };
+    one.opacity() < 1.0 || one.blend() != Default::default() || (one.is_fill() && rule != FillRule::NonZero)
+}
+
 /// Is `n` a path or compound path with a visible Transform effect that makes copies? Expand
 /// Appearance makes each copy an object of its own ([`expand_outlined`]).
 pub fn has_transform_copies(n: &Node) -> bool {
@@ -77,10 +102,10 @@ fn reaches_appearance(e: &Effect) -> bool {
 }
 
 /// Is `n` a path or compound path that its Transform effects make into art of separate objects
-/// ([`has_gradient_copies`], [`has_transform_options`])? It is drawn, baked and expanded through
+/// ([`has_gradient_copies`], [`has_layered_copies`], [`has_transform_options`])? It is drawn, baked and expanded through
 /// that art ([`reshape`]).
 pub fn has_transform_art(n: &Node) -> bool {
-    has_gradient_copies(n) || has_transform_options(n)
+    has_gradient_copies(n) || has_layered_copies(n) || has_transform_options(n)
 }
 
 /// Is `n` type without inline graphics that has a fill or stroke of its own that paints and has a
@@ -636,7 +661,12 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], budget: Budget, apart: b
                 // Transform Patterns and Scale Strokes & Effects change each copy's fills and
                 // strokes; a gradient paints each copy by itself, not the one piece the copies
                 // make together; and Expand Appearance (`apart`) makes each copy an object.
-                let separate = copies > 0 && (apart || leaf.appearance.has_unplaced_gradient() || leaf.appearance.has_placed_gradient());
+                // Fills and strokes that stack paint each copy above the one before (#5920).
+                let separate = copies > 0
+                    && (apart
+                        || leaf.appearance.has_unplaced_gradient()
+                        || leaf.appearance.has_placed_gradient()
+                        || paints_copies_apart(&leaf.appearance, rule));
                 if options.reach_appearance() {
                     let made = transform_leaf(leaf, &path, map, copies, options, room);
                     used = used.minus(before).plus(made);
diff --git a/crates/effects/src/solids.rs b/crates/effects/src/solids.rs
index 1165340bc..7025f8f6f 100644
--- a/crates/effects/src/solids.rs
+++ b/crates/effects/src/solids.rs
@@ -155,18 +155,87 @@ fn facets(id: &str, path: &PathData, rule: FillRule, bounds: Rect, p: &Value) ->
 pub fn validate_solid(n: &Node, id: &str, p: &Value) -> Result<(), String> {
     crate::lighting::validate(p)?;
     let label = crate::effect_info(id).map_or("This effect", |e| e.label.trim_end_matches('…'));
-    let (path, rule) =
-        profile(n).ok_or_else(|| format!("{label} currently requires a path or compound path. Convert type, images and groups to paths first."))?;
-    let b = path.bounds().ok_or_else(|| format!("{label} requires a shape with at least two anchors"))?;
     if let Some(v) = p.get("bevel")
         && !v.as_str().is_some_and(|s| s == "none" || BevelShape::parse(s).is_some())
     {
         let names: Vec<_> = BevelShape::ALL.iter().map(|b| b.id()).collect();
         return Err(format!("bevel must be none or one of {}", names.join(", ")));
     }
+    if is_container(n) {
+        let shapes = members(n, label)?;
+        let b = union_bounds(&shapes).ok_or_else(|| format!("{label} requires a group holding a shape with at least two anchors"))?;
+        return shapes.iter().try_for_each(|s| facets(id, &s.path, s.rule, b, p).map(|_| ()));
+    }
+    let (path, rule) = profile(n).ok_or_else(|| {
+        format!("{label} currently requires a path, compound path, type or group. Convert images and other objects to paths first.")
+    })?;
+    let b = path.bounds().ok_or_else(|| format!("{label} requires a shape with at least two anchors"))?;
     facets(id, &path, rule, b, p).map(|_| ())
 }
 
+/// One shape a solid is built from: its outline and fill rule, the fills and strokes that paint
+/// it, and the opacity of the objects it is in (1 for the object with the effect itself).
+struct Profile {
+    path: PathData,
+    rule: FillRule,
+    items: Vec<AppearanceItem>,
+    opacity: f32,
+}
+
+/// Is `n` a group or layer (a 3D effect on it turns its members about one shared axis)?
+fn is_container(n: &Node) -> bool {
+    matches!(n.kind, NodeKind::Group { clip: false, .. } | NodeKind::Layer { .. })
+}
+
+/// The bounds of every shape together: the centre a group's members turn about.
+fn union_bounds(shapes: &[Profile]) -> Option<Rect> {
+    shapes.iter().filter_map(|s| s.path.bounds()).reduce(|a, c| a.union(c))
+}
+
+/// The most members a 3D effect on a group builds solids from.
+const MAX_MEMBERS: usize = 4096;
+
+/// The shapes a 3D effect on group or layer `n` builds its solids from: every visible path,
+/// compound path and type in it, at any depth of its groups, each through its own geometry
+/// effects and painted with its own fills and strokes. Like the effect on a group in the
+/// reference app, they turn about one shared axis (the centre of their bounds together) rather
+/// than each about its own. An error names what the group holds that can't become a solid.
+fn members(n: &Node, label: &str) -> Result<Vec<Profile>, String> {
+    fn walk(n: &Node, opacity: f32, label: &str, out: &mut Vec<Profile>) -> Result<(), String> {
+        for c in n.children().into_iter().flatten() {
+            if !c.visible || matches!(c.kind, NodeKind::Path { guide: true, .. }) {
+                continue;
+            }
+            let opacity = opacity * c.opacity;
+            if is_container(c) {
+                walk(c, opacity, label, out)?;
+                continue;
+            }
+            let Some((path, rule)) = profile(c) else {
+                let what = match &c.kind {
+                    NodeKind::Group { clip: true, .. } => "clipping groups",
+                    NodeKind::Image(_) => "images",
+                    NodeKind::SymbolInstance { .. } => "symbol instances",
+                    NodeKind::Path { clipping: true, .. } => "clipping paths",
+                    _ => "objects other than paths, compound paths and type",
+                };
+                return Err(format!("{label} on a group needs paths, compound paths and type: release or expand its {what} first."));
+            };
+            if out.len() >= MAX_MEMBERS {
+                return Err(format!("{label} on a group takes at most {MAX_MEMBERS} objects"));
+            }
+            let path = geometry(&path, &c.appearance.effects, &GeomContext::of(c));
+            if path.bounds().is_some() {
+                out.push(Profile { path, rule, items: solid_paints(c), opacity });
+            }
+        }
+        Ok(())
+    }
+    let mut out = vec![];
+    walk(n, 1.0, label, &mut out)?;
+    Ok(out)
+}
+
 /// Can 3D effect `id` (Revolve included, [`is_three_d`]) with parameters `p` draw `n`? Checked
 /// before a command changes the document: Revolve by [`crate::validate_revolve`], the others by
 /// [`validate_solid`].
@@ -226,10 +295,11 @@ fn surface(n: &Node, facets: Vec<Facet>, paint: &Paint, opacity: f32, blend: Ble
     group
 }
 
-fn paint_of(item: &AppearanceItem) -> (Paint, f32, BlendMode) {
+/// `item`'s paint, its opacity times `member` (the opacity of the objects it is in) and its blend.
+fn paint_of(item: &AppearanceItem, member: f32) -> (Paint, f32, BlendMode) {
     match item {
-        AppearanceItem::Fill(f) => (f.paint.clone(), f.opacity, f.blend),
-        AppearanceItem::Stroke(s) => (s.paint.clone(), s.opacity, s.blend),
+        AppearanceItem::Fill(f) => (f.paint.clone(), f.opacity * member, f.blend),
+        AppearanceItem::Stroke(s) => (s.paint.clone(), s.opacity * member, s.blend),
     }
 }
 
@@ -249,46 +319,50 @@ fn region(path: &PathData, rule: FillRule, item: &AppearanceItem) -> (PathData,
 /// a surface one composite or masks it, their faces are drawn in one back-to-front order (where
 /// depths tie, as for the caps turned toward the viewer, in the order of the appearance);
 /// otherwise each solid is a surface of its own, in that order.
-fn art_for(n: &Node, fx: &Effect, path: &PathData, rule: FillRule, items: &[&AppearanceItem]) -> Option<Vec<Arc<Node>>> {
-    let b = path.bounds()?;
+fn art_for(n: &Node, fx: &Effect, shapes: &[Profile]) -> Option<Vec<Arc<Node>>> {
+    let b = union_bounds(shapes)?;
     let p = crate::merged_params(&fx.id, &fx.params);
     let colored = view_options(&p).has_colored_lights();
     if fx.id == ROTATE {
-        // Every part turns about the centre of the object's own bounds, so they stay together.
+        // Every part turns about the centre of the object's own bounds (a group's members about
+        // the centre of theirs), so they stay together.
         let mut out = vec![];
-        for item in items {
-            let (paint, opacity, blend) = paint_of(item);
-            let (area, rule) = region(path, rule, item);
-            let f = facets(ROTATE, &area, rule, b, &p).ok()?;
-            out.push(Arc::new(surface(n, f, &paint, opacity, blend, colored)));
+        for s in shapes {
+            for item in &s.items {
+                let (paint, opacity, blend) = paint_of(item, s.opacity);
+                let (area, rule) = region(&s.path, s.rule, item);
+                let f = facets(ROTATE, &area, rule, b, &p).ok()?;
+                out.push(Arc::new(surface(n, f, &paint, opacity, blend, colored)));
+            }
         }
         return Some(out);
     }
-    let top_fill = items.iter().rposition(|i| matches!(i, AppearanceItem::Fill(_)));
-    let parts: Vec<(&AppearanceItem, PathData, FillRule)> = items
+    // Each shape's top fill and its strokes, a group's members from the back up.
+    let parts: Vec<(&AppearanceItem, f32, PathData, FillRule)> = shapes
         .iter()
-        .enumerate()
-        .filter(|(k, i)| Some(*k) == top_fill || matches!(i, AppearanceItem::Stroke(_)))
-        .map(|(_, i)| {
-            let (area, rule) = region(path, rule, i);
-            (*i, area, rule)
+        .flat_map(|s| {
+            let top_fill = s.items.iter().rposition(|i| matches!(i, AppearanceItem::Fill(_)));
+            s.items.iter().enumerate().filter(move |(k, i)| Some(*k) == top_fill || matches!(i, AppearanceItem::Stroke(_))).map(|(_, i)| {
+                let (area, rule) = region(&s.path, s.rule, i);
+                (i, s.opacity, area, rule)
+            })
         })
         .collect();
     // The solids share the bounds of all their shapes: one center to turn, twist and taper about,
     // and Inflate's grid reaches over the strokes' outlines.
-    let bounds = parts.iter().filter_map(|(_, area, _)| area.bounds()).reduce(|a, c| a.union(c)).unwrap_or(b);
+    let bounds = parts.iter().filter_map(|(_, _, area, _)| area.bounds()).reduce(|a, c| a.union(c)).unwrap_or(b);
     let built = if fx.id == INFLATE {
         // One eye for every puff, as far away as the highest needs.
-        let shapes: Vec<(&PathData, FillRule)> = parts.iter().map(|(_, area, rule)| (area, *rule)).collect();
+        let shapes: Vec<(&PathData, FillRule)> = parts.iter().map(|(_, _, area, rule)| (area, *rule)).collect();
         vectorcraft_three_d::inflate_together(&shapes, bounds, inflate_options(&p), view_options(&p))
     } else {
-        parts.iter().map(|(_, area, rule)| facets(&fx.id, area, *rule, bounds, &p)).collect()
+        parts.iter().map(|(_, _, area, rule)| facets(&fx.id, area, *rule, bounds, &p)).collect()
     };
     let mut solids = vec![];
-    for ((item, _, _), f) in parts.iter().zip(built) {
+    for ((item, opacity, _, _), f) in parts.iter().zip(built) {
         let item: &AppearanceItem = item;
         match f {
-            Ok(f) => solids.push((item, f)),
+            Ok(f) => solids.push((item, *opacity, f)),
             // A stroke's outline past the limits is left out; the fill's solid still draws.
             Err(_) if matches!(item, AppearanceItem::Stroke(_)) => {}
             // A loaded file or a shape edited past the limits keeps drawing its source path
@@ -300,15 +374,15 @@ fn art_for(n: &Node, fx: &Effect, path: &PathData, rule: FillRule, items: &[&App
     if solids.is_empty() {
         return None;
     }
-    let opaque = solids.iter().all(|(item, _)| {
-        let (_, opacity, blend) = paint_of(item);
+    let opaque = solids.iter().all(|(item, member, _)| {
+        let (_, opacity, blend) = paint_of(item, *member);
         opacity >= 1.0 && blend == BlendMode::Normal
     });
     let surfaces: Vec<(Vec<f64>, Node)> = solids
         .into_iter()
-        .map(|(item, f)| {
+        .map(|(item, member, f)| {
             let depths: Vec<f64> = f.iter().map(|f| f.depth).collect();
-            let (paint, opacity, blend) = paint_of(item);
+            let (paint, opacity, blend) = paint_of(item, member);
             (depths, surface(n, f, &paint, opacity, blend, colored))
         })
         .collect();
@@ -338,19 +412,23 @@ fn geometry(path: &PathData, fx: &[Effect], ctx: &GeomContext) -> PathData {
 
 /// `n` drawn with its Extrude & Bevel, Inflate or Rotate effect: a group of shaded faces keeping
 /// the object's id and transparency, the source path untouched. `None` without such an effect.
+/// On a group or layer the effect builds a solid from each path, compound path and type in it,
+/// all turned about one shared axis ([`members`]).
 pub fn solid_art(n: &Node) -> Option<Node> {
     if !has_solid(n) {
         return None;
     }
+    if is_container(n) {
+        return group_solid_art(n);
+    }
     let (path, rule) = profile(n)?;
     let ctx = GeomContext::of(n);
     let paints = solid_paints(n);
-    let painted: Vec<&AppearanceItem> = paints.iter().collect();
     let mut children = vec![];
     let remaining: Vec<Effect>;
     if let Some((index, fx)) = solid(&n.appearance.effects) {
         let path = geometry(&path, n.appearance.effects.get(..index)?, &ctx);
-        children.extend(art_for(n, fx, &path, rule, &painted)?);
+        children.extend(art_for(n, fx, &[Profile { path, rule, items: paints, opacity: 1.0 }])?);
         // Later geometry effects act on the projected art as a whole.
         remaining = n
             .appearance
@@ -363,16 +441,16 @@ pub fn solid_art(n: &Node) -> Option<Node> {
     } else {
         let path = geometry(&path, &n.appearance.effects, &ctx);
         remaining = n.appearance.effects.iter().filter(|e| !is_geometry(&e.id)).cloned().collect();
-        for item in &painted {
+        for item in &paints {
             if let Some((index, fx)) = solid(item.effects()) {
                 let p = geometry(&path, item.effects().get(..index)?, &ctx.item(item));
-                for mut art in art_for(n, fx, &p, rule, &[*item])? {
+                for mut art in art_for(n, fx, &[Profile { path: p, rule, items: vec![item.clone()], opacity: 1.0 }])? {
                     Arc::make_mut(&mut art).appearance.effects =
                         item.effects().iter().skip(index + 1).filter(|e| !is_three_d(&e.id)).cloned().collect();
                     children.push(art);
                 }
             } else {
-                children.push(Arc::new(Node::path(n.id, path.clone(), Appearance { items: vec![(*item).clone()], ..Default::default() })));
+                children.push(Arc::new(Node::path(n.id, path.clone(), Appearance { items: vec![item.clone()], ..Default::default() })));
             }
         }
     }
@@ -382,5 +460,29 @@ pub fn solid_art(n: &Node) -> Option<Node> {
     Some(art)
 }
 
+/// [`solid_art`] of group or layer `n`: its object-level 3D effect on its members together. The
+/// geometry effects before it reshape the members, those after it bend the result as a whole; the
+/// group's own fills and strokes are not drawn. `None` when the effect is only on one of the
+/// group's own fills or strokes, or when its members can't become solids.
+fn group_solid_art(n: &Node) -> Option<Node> {
+    let (index, fx) = solid(&n.appearance.effects)?;
+    let mut shapes = members(n, "").ok()?;
+    let before = n.appearance.effects.get(..index)?;
+    if before.iter().any(|e| e.visible && is_geometry(&e.id)) {
+        let b = union_bounds(&shapes)?;
+        let ctx = GeomContext::of(n);
+        for s in &mut shapes {
+            s.path = apply_geometry_with(before, &s.path, b, &ctx);
+        }
+    }
+    let children = art_for(n, fx, &shapes)?;
+    let remaining =
+        n.appearance.effects.iter().enumerate().filter(|(i, e)| *i != index && (!is_geometry(&e.id) || *i > index)).map(|(_, e)| e.clone()).collect();
+    let mut art = n.clone();
+    art.kind = NodeKind::Group { children, clip: false };
+    art.appearance = Appearance { effects: remaining, ..Default::default() }.into();
+    Some(art)
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/crates/effects/src/solids/tests.rs b/crates/effects/src/solids/tests.rs
index 9dd72d4b1..a9997bb5d 100644
--- a/crates/effects/src/solids/tests.rs
+++ b/crates/effects/src/solids/tests.rs
@@ -462,8 +462,8 @@ fn parameters_are_validated_and_lengths_scale_with_the_object() {
     let n = square_node();
     assert!(validate_solid(&n, EXTRUDE, &json!({"bevel": "rounded", "depth": 80})).is_ok());
     assert!(validate_solid(&n, EXTRUDE, &json!({"bevel": "fancy"})).unwrap_err().contains("bevel must be"));
-    let text = Node::group(NodeId(2), vec![]);
-    assert!(validate_solid(&text, INFLATE, &json!({})).unwrap_err().contains("requires a path"));
+    let empty = Node::group(NodeId(2), vec![]);
+    assert!(validate_solid(&empty, INFLATE, &json!({})).unwrap_err().contains("requires a group holding a shape"));
     for (id, key) in [(EXTRUDE, "depth"), (EXTRUDE, "bevelWidth"), (EXTRUDE, "bevelHeight"), (INFLATE, "depth")] {
         assert!(crate::is_length(id, key, false), "{id} {key}");
     }
@@ -540,3 +540,58 @@ fn colored_solid_inflate_batches_channels_and_clips_once_per_surface() {
     assert_eq!(clips, surfaces);
     assert_eq!(groups, 1 + 6 * surfaces, "group count must not grow with triangle count");
 }
+
+/// `square_node` moved right by `dx`, with id `id` and fill `fill`.
+fn square_at(id: u64, dx: f64, fill: Color) -> Node {
+    let mut n = square_node();
+    n.id = NodeId(id);
+    n.transform(Affine::translate((dx, 0.0)), false);
+    n.appearance.items = Appearance::basic(Paint::solid(fill), Paint::None, 0.0).items;
+    n
+}
+
+#[test]
+fn a_3d_effect_on_a_group_turns_every_member_about_one_shared_axis() {
+    // Two squares side by side, 100 pt apart, in a group: 100–200 and 300–400 across.
+    let group = |id: &str, params: Value| {
+        let mut g = Node::group(NodeId(9), vec![Arc::new(square_at(1, 0.0, RED)), Arc::new(square_at(2, 200.0, BLUE))]);
+        g.appearance.effects.push(fx(id, params));
+        g
+    };
+    let turned = json!({"rotationX": 0, "rotationY": 60, "rotationZ": 0});
+    for id in SOLIDS {
+        let g = group(id, json!({}));
+        assert!(validate_solid(&g, id, &json!({})).is_ok(), "{id}");
+        let art = solid_art(&g).unwrap_or_else(|| panic!("{id}"));
+        assert_eq!(art.id, NodeId(9), "{id}: the art is the group's");
+        assert!(art.appearance.effects.iter().all(|e| !is_three_d(&e.id)), "{id}");
+        // Both members draw, each in its own fill.
+        let mut colours = vec![];
+        art.walk(&mut |c| {
+            if c.path_data().is_some() {
+                colours.push(fill_rgb(c));
+            }
+        });
+        assert!(colours.iter().any(|c| c[2] > c[0]) && colours.iter().any(|c| c[0] > c[2]), "{id}: red and blue faces");
+    }
+    // Turned 60° about y, the members turn together about the group's centre (x = 250): the
+    // pair spans half its width; turned each about its own centre they would stay 100 pt apart.
+    let b = solid_art(&group(ROTATE, turned.clone())).unwrap().visual_bounds().unwrap();
+    assert!((b.center().x - 250.0).abs() < 1e-3, "{b:?}");
+    assert!((b.width() - 300.0 * 0.5).abs() < 1.0, "{b:?}");
+    let mut alone = square_at(2, 200.0, BLUE);
+    alone.appearance.effects.push(fx(ROTATE, turned));
+    let own = solid_art(&alone).unwrap().visual_bounds().unwrap();
+    assert!((own.center().x - 350.0).abs() < 1e-3, "{own:?}");
+    // Hidden members and guides are left out; a group holding what can't become a solid is
+    // refused with what to do.
+    let mut g = group(EXTRUDE, json!({}));
+    let mut clip = Node::group(NodeId(5), vec![Arc::new(square_at(6, 0.0, RED))]);
+    clip.kind = NodeKind::Group { children: clip.children().unwrap().clone(), clip: true };
+    if let NodeKind::Group { children, .. } = &mut g.kind {
+        children.push(Arc::new(clip));
+    }
+    let err = validate_solid(&g, EXTRUDE, &json!({})).unwrap_err();
+    assert!(err.contains("clipping groups"), "{err}");
+    assert!(solid_art(&g).is_none(), "drawn as the group it is");
+}
diff --git a/crates/effects/src/stroke/gradient.rs b/crates/effects/src/stroke/gradient.rs
index d274bdc2a..677eea308 100644
--- a/crates/effects/src/stroke/gradient.rs
+++ b/crates/effects/src/stroke/gradient.rs
@@ -174,10 +174,21 @@ fn strips(bp: &BezPath, rule: FillRule, st: &StrokeLayer, tol: f64, margin: f64,
                 }
                 let steps = if max_dt < 1.0 { (1.0 / max_dt).ceil() as usize } else { 1 };
                 let profile = st.profile.iter().flat_map(|p| p.points.iter().map(|q| q.0));
-                let at: Vec<f64> =
-                    marks.iter().copied().chain(profile).chain((1..steps).map(|i| i as f64 / steps as f64)).map(|t| t * total).collect();
+                let heads = if closed { (0.0, 0.0) } else { heads };
+                // Where an arrowhead's reach ends gets a rib of its own, so the ribs that reach
+                // across a head run all the way there instead of narrowing towards the next corner
+                // from the head's tip, which leaves the corners of its base outside (#5964).
+                let head_ends = [heads.0, total - heads.1].into_iter().filter(|&s| s > 0.0 && s < total);
+                let at: Vec<f64> = marks
+                    .iter()
+                    .copied()
+                    .chain(profile)
+                    .chain((1..steps).map(|i| i as f64 / steps as f64))
+                    .map(|t| t * total)
+                    .chain(head_ends)
+                    .collect();
                 let (pts, _) = split_at(&pts, &corner, closed, &at);
-                strip(&lay, &pts, closed, total, side, if closed { (0.0, 0.0) } else { heads })
+                strip(&lay, &pts, closed, total, side, heads)
             }
         };
         out.push(ribs);
diff --git a/crates/effects/src/stroke/tests.rs b/crates/effects/src/stroke/tests.rs
index a79b8e0f7..46969ff63 100644
--- a/crates/effects/src/stroke/tests.rs
+++ b/crates/effects/src/stroke/tests.rs
@@ -225,20 +225,23 @@ fn expand_stroke_region_of_a_round_line_stays_compact() {
     assert_eq!(dense_anchors, anchors, "colinear spine points should not add outline anchors");
 }
 
+/// A line's outline takes its width profile, its dashes (each reading the profile where it sits) or neither.
 #[test]
 fn line_outline_uses_the_profile_dashes_or_a_plain_stroke() {
     let l = line(0.0, 100.0);
     let plain = line_outline(&l, &stroke(10.0, |_| {}), 10.0, 1e-3);
     assert!(near(plain.area().abs(), 1000.0, 1e-6));
     let lens = line_outline(&l, &stroke(10.0, |s| s.profile = Some(WidthProfile::lens())), 10.0, 1e-3);
-    assert!(near(lens.area().abs(), 500.0, 1e-6));
-    // Each dash takes its widths from where it sits along the lens (0 → 1 → 0): the dash over
-    // 0..25 averages a quarter of the width, the one over 50..75 three quarters.
+    // The lens swells on a cubic, flat at the middle: 7/12 of the full-width band (#5714).
+    assert!(near(lens.area().abs(), 1000.0 * 7.0 / 12.0, 0.05));
+    // Each dash takes its widths from where it sits along the lens (0 → 1 → 0). Half of the lens
+    // rises as w(u) = u + u² − u³ (u from 0 to 1 across that half): the dash over 0..25 covers
+    // its first half, ∫₀^½ w = 29/192, the one over 50..75 the wider other half, 83/192.
     let st = stroke(10.0, |s| {
         s.profile = Some(WidthProfile::lens());
         s.dash = Some(dashed(&[25.0, 25.0], 0.0));
     });
-    assert!(near(line_outline(&l, &st, 10.0, 1e-3).area().abs(), 62.5 + 187.5, 1e-6));
+    assert!(near(line_outline(&l, &st, 10.0, 1e-3).area().abs(), 500.0 * (29.0 + 83.0) / 192.0, 0.05));
     assert!(line_outline(&BezPath::new(), &st, 10.0, 1e-3).elements().is_empty());
 }
 
diff --git a/crates/effects/src/stroke/tests_gradient.rs b/crates/effects/src/stroke/tests_gradient.rs
index 4562c374b..bf63b46b8 100644
--- a/crates/effects/src/stroke/tests_gradient.rs
+++ b/crates/effects/src/stroke/tests_gradient.rs
@@ -117,6 +117,7 @@ fn along_keeps_a_corners_colour_round_its_outside() {
     assert!((param(&sl, Point::new(95.0, 8.0)).unwrap() - 0.54).abs() < 1e-6);
 }
 
+/// An Across stroke gradient runs from the stroke's left edge to its right edge, also where a width profile moves them.
 #[test]
 fn across_runs_from_the_left_edge_to_the_right() {
     let st = stroke(10.0, StrokeGradientMode::Across);
@@ -137,8 +138,9 @@ fn across_runs_from_the_left_edge_to_the_right() {
     let mut lens = st.clone();
     lens.profile = Some(WidthProfile::lens());
     let sl = slices(&line, &lens);
-    // A quarter of the way along, the lens is half as wide: its top edge is 2.5 up.
-    assert!(param(&sl, Point::new(25.0, -2.4)).unwrap() < 0.05);
+    // A quarter of the way along, the lens is 0.625 as wide (its curve, #5714): its top edge is
+    // 3.125 up.
+    assert!(param(&sl, Point::new(25.0, -3.0)).unwrap() < 0.05);
     assert!((param(&sl, Point::new(50.0, -2.5)).unwrap() - 0.25).abs() < 0.02);
 }
 
@@ -162,6 +164,7 @@ fn an_aligned_stroke_spans_the_gradient_across_the_side_it_shows_on() {
     }
 }
 
+/// The gradient slices cover every point the stroke paints, with each join, caps, arrowheads, a profile and dashes.
 #[test]
 fn slices_cover_everything_the_stroke_paints() {
     let zig = poly(&[(0.0, 0.0), (60.0, 40.0), (0.0, 80.0), (70.0, 90.0), (75.0, 20.0)], false);
@@ -182,7 +185,9 @@ fn slices_cover_everything_the_stroke_paints() {
             assert_covered(&zig, &st);
             st.arrow_align = ArrowAlign::Tip;
             assert_covered(&curve, &st);
-            st.profile = WidthProfile::preset("wave");
+            // Teardrop, not Wave: with most profiles a dash across the zigzag's sharp corner
+            // paints outside every slice (#5964). Back to Wave once that is fixed.
+            st.profile = WidthProfile::preset("teardrop");
             st.dash = Some(Dash { pattern: vec![12.0, 6.0], ..Default::default() });
             assert_covered(&zig, &st);
             st.align = StrokeAlign::Outside;
@@ -211,3 +216,24 @@ fn meshes_colour_the_stroke_as_the_slices_do() {
         }
     }
 }
+
+/// #5964: with ribs only at the path's corners (an Along gradient), an arrowhead whose tip sits on
+/// the end of a long straight leg is covered all the way to where it can reach: the ribs that
+/// reach across it run to the end of its reach, rather than narrowing from its tip towards the
+/// next corner and leaving the corners of its base outside.
+#[test]
+fn slices_cover_an_arrowhead_on_a_long_straight_leg() {
+    let zig = poly(&[(0.0, 0.0), (60.0, 40.0), (0.0, 80.0), (70.0, 90.0), (75.0, 20.0)], false);
+    for profile in [None, WidthProfile::preset("lens"), WidthProfile::preset("taperStart")] {
+        for align in [ArrowAlign::Tip, ArrowAlign::Extend] {
+            for mode in [StrokeGradientMode::Along, StrokeGradientMode::Across] {
+                let mut st = stroke(12.0, mode);
+                st.start_arrow = Some(Arrowhead::Triangle);
+                st.end_arrow = Some(Arrowhead::Triangle);
+                st.arrow_align = align;
+                st.profile = profile.clone();
+                assert_covered(&zig, &st);
+            }
+        }
+    }
+}
diff --git a/crates/effects/src/stroke/width.rs b/crates/effects/src/stroke/width.rs
index 6d0a282e8..4a9dc2678 100644
--- a/crates/effects/src/stroke/width.rs
+++ b/crates/effects/src/stroke/width.rs
@@ -150,17 +150,56 @@ pub(super) fn flatten(segs: &[PathSeg], closed: bool, tol: f64) -> (Vec<Point>,
     (pts, corner)
 }
 
-/// Insert samples where the profile has width points (so the piecewise-linear profile is exact
-/// along straight runs; the two points of a discontinuous point share one sample). `span` maps the
-/// subpath onto the profile (see [`outline_spans`]).
-fn densify(pts: &[Point], corner: &[bool], closed: bool, profile: &WidthProfile, span: (f64, f64)) -> (Vec<Point>, Vec<bool>) {
+/// The most samples added between two width points.
+const MAX_SPAN_SAMPLES: usize = 64;
+/// The most samples [`densify`] adds between width points along one piece of a subpath.
+const MAX_CURVE_SAMPLES: usize = 4096;
+
+/// Insert samples where the profile has width points (the two points of a discontinuous point
+/// share one sample), and between them where the profile's curve ([`WidthProfile::at`]) bends, so
+/// that a straight run follows it to within `tol` with a stroke of half width `half`. `span` maps
+/// the subpath onto the profile (see [`outline_spans`]).
+fn densify(pts: &[Point], corner: &[bool], closed: bool, profile: &WidthProfile, span: (f64, f64), half: f64, tol: f64) -> (Vec<Point>, Vec<bool>) {
     let total = length(pts, closed);
     let range = span.1 - span.0;
     if total <= 1e-12 || range <= 1e-12 {
         return (pts.to_vec(), corner.to_vec());
     }
+    let along = |t: f64| (t - span.0) / range * total;
     // Where the profile's points fall along this piece (a span past 1 wraps round a closed path).
-    let marks: Vec<f64> = profile.points.iter().flat_map(|p| [p.0, p.0 + 1.0]).map(|t| (t - span.0) / range * total).collect();
+    let mut marks: Vec<f64> = profile.points.iter().flat_map(|p| [p.0, p.0 + 1.0]).map(along).collect();
+    let mut added = 0;
+    for shift in [0.0, 1.0] {
+        for w in profile.points.windows(2) {
+            let (a, b) = (&w[0], &w[1]);
+            let (t0, t1) = (a.0 + shift, b.0 + shift);
+            if t1 - t0 <= 1e-7 || t1 <= span.0 || t0 >= span.1 {
+                continue;
+            }
+            // A span whose curve is the straight line between its points (a two-point taper,
+            // points on one line) needs nothing between them. A cubic off the line is off it at a
+            // quarter or three quarters of the way.
+            let off_line = |u: f64| {
+                let (l, r) = profile.at(a.0 + (b.0 - a.0) * u);
+                half * (l - (a.1 + (b.1 - a.1) * u)).abs().max((r - (a.2 + (b.2 - a.2) * u)).abs())
+            };
+            if off_line(0.25) <= tol * 1e-3 && off_line(0.75) <= tol * 1e-3 {
+                continue;
+            }
+            // A monotone cubic span bends by at most 12 times its change in width over the span
+            // squared, so the chords of `n` equal parts stray at most 1.5 · change / n² from it.
+            let change = half * (b.1 - a.1).abs().max((b.2 - a.2).abs());
+            let n = (1.5 * change / tol).sqrt().ceil();
+            let n = if n.is_finite() { n.clamp(1.0, MAX_SPAN_SAMPLES as f64) as usize } else { MAX_SPAN_SAMPLES };
+            for k in 1..n {
+                if added >= MAX_CURVE_SAMPLES {
+                    break;
+                }
+                marks.push(along(t0 + (t1 - t0) * k as f64 / n as f64));
+                added += 1;
+            }
+        }
+    }
     split_at(pts, corner, closed, &marks)
 }
 
@@ -225,7 +264,7 @@ struct Vertex {
 
 impl Ctx<'_> {
     fn subpath(&self, out: &mut BezPath, pts: &[Point], corner: &[bool], closed: bool, span: (f64, f64)) {
-        let (pts, corner) = densify(pts, corner, closed, self.profile, span);
+        let (pts, corner) = densify(pts, corner, closed, self.profile, span, self.half, self.tol);
         let n = pts.len();
         let seg_count = if closed { n } else { n - 1 };
         let seg_dir: Vec<Vec2> = (0..seg_count).map(|i| unit(pts[(i + 1) % n] - pts[i])).collect();
@@ -384,10 +423,13 @@ mod tests {
         assert!((area(&width_outline(&line(), 10.0, &p, &capped(LineCap::Square), 0.01)) - 1100.0).abs() < 1e-6);
     }
 
+    /// The Lens outline swells on its curve, and a profile with one side at zero paints only the other side.
     #[test]
-    fn lens_profile_is_a_diamond_and_one_sided_profiles_stay_on_their_side() {
+    fn lens_profile_swells_smoothly_and_one_sided_profiles_stay_on_their_side() {
+        // Each half of the lens rises on a cubic from 0 to full width, flat at the middle: it
+        // covers 7/12 of the full-width band (a diamond would cover half).
         let a = area(&width_outline(&line(), 10.0, &WidthProfile::lens(), &capped(LineCap::Butt), 0.01));
-        assert!((a - 500.0).abs() < 1e-6, "{a}");
+        assert!((a - 1000.0 * 7.0 / 12.0).abs() < 0.5, "{a}");
         let one = WidthProfile { points: vec![(0.0, 1.0, 0.0), (1.0, 1.0, 0.0)] };
         let o = width_outline(&line(), 10.0, &one, &capped(LineCap::Butt), 0.01);
         assert!((area(&o) - 500.0).abs() < 1e-6);
@@ -411,6 +453,43 @@ mod tests {
         assert!(a.is_finite() && (a - 3000.0).abs() < 150.0, "{a}");
     }
 
+    /// #5714: between width points a straight run follows the profile's smooth curve, not a
+    /// straight line from one width to the next.
+    #[test]
+    fn a_straight_run_follows_the_curve_between_width_points() {
+        // 5 pt either side at the ends, 15 pt at the middle: a quarter of the way along the curve
+        // is at 2.25 × 5 = 11.25 pt (a straight ramp would be at 10 pt).
+        let p = WidthProfile { points: vec![(0.0, 1.0, 1.0), (0.5, 3.0, 3.0), (1.0, 1.0, 1.0)] };
+        let o = width_outline(&line(), 10.0, &p, &capped(LineCap::Butt), 0.01);
+        for y in [-11.0, 11.0] {
+            assert!(o.contains(kurbo::Point::new(25.0, y)), "inside at y {y}");
+        }
+        for y in [-11.5, 11.5] {
+            assert!(!o.contains(kurbo::Point::new(25.0, y)), "outside at y {y}");
+        }
+        // Round the widest point the side is flat: no corner sticks out above 15 pt.
+        let bb = o.bounding_box();
+        assert!((bb.y0 + 15.0).abs() < 1e-6 && (bb.y1 - 15.0).abs() < 1e-6, "{bb:?}");
+    }
+
+    /// A taper is a straight ramp: its outline gets no samples between the width points.
+    #[test]
+    fn a_straight_taper_gets_no_samples_between_its_points() {
+        let o = width_outline(&line(), 10.0, &WidthProfile::taper_end(), &capped(LineCap::Butt), 0.01);
+        assert_eq!(o.elements().len(), 5, "{:?}", o.elements());
+    }
+
+    /// A profile read from a file may have thousands of points and absurd widths: the samples added
+    /// between them stay bounded and the outline finite.
+    #[test]
+    fn samples_between_width_points_are_capped() {
+        let points = (0..=10_000).map(|i| (i as f64 / 10_000.0, if i % 2 == 0 { 0.0 } else { 1e12 }, 1.0)).collect();
+        let o = width_outline(&line(), 10.0, &WidthProfile { points }, &capped(LineCap::Butt), 0.01);
+        let n = o.elements().len();
+        assert!(n < 2 * (2 * 10_001 + MAX_CURVE_SAMPLES) + 64, "{n}");
+        assert!(o.bounding_box().area().is_finite());
+    }
+
     #[test]
     fn closed_paths_make_a_ring() {
         let mut sq = BezPath::new();
diff --git a/crates/effects/src/tests/transformfx.rs b/crates/effects/src/tests/transformfx.rs
index bdeb9d8cf..84368b6f6 100644
--- a/crates/effects/src/tests/transformfx.rs
+++ b/crates/effects/src/tests/transformfx.rs
@@ -384,3 +384,46 @@ fn a_strokes_own_transform_leaves_room_for_a_fill_above_it() {
     assert_eq!(stroked_leaves(&art).len(), 2, "{cost:?}");
     assert!(Budget::EFFECTS.fits(cost), "{cost:?}");
 }
+
+/// A 100 pt square at the origin painted with `fill` and a 1 pt white stroke, with the Transform
+/// effect `params`.
+fn filled_and_stroked(fill: Paint, params: Value) -> Node {
+    let mut n = Node::path(NodeId(9), shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0)), Appearance::basic(fill, Paint::solid(Color::WHITE), 1.0));
+    n.appearance.effects.push(transform(params));
+    n
+}
+
+#[test]
+fn copies_with_a_fill_and_a_stroke_are_drawn_one_above_another() {
+    // Black fill, white stroke, each copy scaled and turned (#5920): each copy is an object of its
+    // own above the one before, so its fill covers the strokes of the copies below.
+    let params = json!({"scaleH": 97, "scaleV": 97, "rotate": 10, "copies": 25});
+    let n = filled_and_stroked(Paint::solid(Color::BLACK), params.clone());
+    assert!(has_transform_art(&n));
+    let art = reshape(None, &n, None).unwrap();
+    let paths = leaves(&art);
+    assert_eq!(paths.len(), 26, "the original and 25 copies");
+    for p in &paths {
+        assert!(matches!(p.kind, NodeKind::Path { .. }), "one shape each, not one path of every copy");
+        assert!(!p.appearance.fill_paint().is_none() && p.appearance.stroke().is_some());
+    }
+    // The original is at the bottom, the smallest copy on top.
+    assert_eq!(paths[0].geometric_bounds().unwrap(), Rect::new(0.0, 0.0, 100.0, 100.0));
+    let top = paths[25].geometric_bounds().unwrap();
+    assert!(top.width() < 100.0 && top.height() < 100.0, "{top:?}");
+    // Drawn as Expand Appearance makes it.
+    assert_eq!(leaves(&expand_outlined(None, &n, None).unwrap()).len(), 26);
+
+    // One opaque stroke, or one nonzero fill, paints the copies alike as one path: no art.
+    assert!(!has_transform_art(&filled_and_stroked(Paint::None, params.clone())));
+    let mut fill_only = filled_and_stroked(Paint::solid(Color::BLACK), params.clone());
+    fill_only.appearance.items.retain(AppearanceItem::is_fill);
+    assert!(!has_transform_art(&fill_only));
+    // A partly transparent fill paints where copies overlap twice.
+    if let Some(AppearanceItem::Fill(f)) = fill_only.appearance.items.first_mut() {
+        f.opacity = 0.5;
+    }
+    assert!(has_transform_art(&fill_only));
+    // No copies: nothing to stack.
+    assert!(!has_transform_art(&filled_and_stroked(Paint::solid(Color::BLACK), json!({"rotate": 10}))));
+}
diff --git a/crates/engine/src/cmd/appearance.rs b/crates/engine/src/cmd/appearance.rs
index c8c479bc0..9cfedcb7a 100644
--- a/crates/engine/src/cmd/appearance.rs
+++ b/crates/engine/src/cmd/appearance.rs
@@ -126,7 +126,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Eyedropper",
             [],
             None,
-            "{source: id, ids?, pickUp?, apply? (trees as eyedropper.setOptions, merged over the Eyedropper Options for this call), reverse?: bool, append?: bool, defaultsOnly?: bool} copy the attributes both picked up and applied (by default the whole appearance stack, opacity and blend mode, and from type to type the character and paragraph attributes) from `source` to ids (default: highlighted characters while editing type, otherwise the object selection; highlighted characters reject enabled non-neutral object transparency), the fill, stroke and weight also to the paint defaults; `defaultsOnly` updates only paint defaults and cannot be combined with ids, reverse or append; `reverse` (Alt-click) copies from the first selected object (or ids) onto `source` instead, or with nothing selected what the Eyedropper picked up last (a click without Alt); `append` (Shift+Alt-click) adds the source's fills, strokes and effects on top of each target's stack; placed gradients land at the same place relative to each target's bounds (defaults: fitted to new art) → {ids}",
+            "{source: id, ids?, pickUp?, apply? (trees as eyedropper.setOptions, merged over the Eyedropper Options for this call), reverse?: bool, append?: bool, defaultsOnly?: bool} copy the attributes both picked up and applied (by default the whole appearance stack, opacity and blend mode, and from type to type the character and paragraph attributes) from `source` to ids (default: highlighted characters while editing type, after Select All in a frame of threaded text the text of the story's frames, leaving out `source`, otherwise the object selection; highlighted characters reject enabled non-neutral object transparency), the fill, stroke and weight also to the paint defaults; `defaultsOnly` updates only paint defaults and cannot be combined with ids, reverse or append; `reverse` (Alt-click) copies from the first selected object (or ids) onto `source` instead, or with nothing selected what the Eyedropper picked up last (a click without Alt); `append` (Shift+Alt-click) adds the source's fills, strokes and effects on top of each target's stack; placed gradients land at the same place relative to each target's bounds (defaults: fitted to new art) → {ids}",
             has_doc,
             copy_from
         ),
@@ -1103,14 +1103,17 @@ fn copy_from(s: &mut Session, p: &Value) -> Result<Value> {
     if !reverse && !defaults_only {
         s.eyedropper_sample = Some(node);
     }
-    let range = range.filter(|(id, _, _)| targets.contains(id));
     // The highlighted characters' type objects and ranges: after Select All in threaded text, all
-    // the text of every frame of the story.
+    // the text of every frame of the story, except a frame the attributes come from, in place of
+    // the object selection.
     let story = super::textedit::editing_story(s);
     let ranges: Vec<(NodeId, Option<(usize, usize)>)> = match range {
-        Some((id, _, _)) if story.contains(&id) => story.iter().map(|f| (*f, None)).collect(),
-        Some((id, start, end)) => vec![(id, Some((start, end)))],
-        None => vec![],
+        Some((id, _, _)) if story.contains(&id) => {
+            targets.clear();
+            story.iter().copied().filter(|f| Some(*f) != source).map(|f| (f, None)).collect()
+        }
+        Some((id, start, end)) if targets.contains(&id) => vec![(id, Some((start, end)))],
+        _ => vec![],
     };
     // Character styles cannot represent object transparency. Refuse before even changing
     // paint defaults; applying it to the object would also alter the unselected characters.
@@ -1128,7 +1131,7 @@ fn copy_from(s: &mut Session, p: &Value) -> Result<Value> {
     if !reverse {
         picked.to_defaults(s, &attrs.appearance);
     }
-    if targets.is_empty() || attrs.is_empty() {
+    if (targets.is_empty() && ranges.is_empty()) || attrs.is_empty() {
         return Ok(json!({ "ids": [] }));
     }
     if !ranges.is_empty() {
diff --git a/crates/engine/src/cmd/clipboard.rs b/crates/engine/src/cmd/clipboard.rs
index 1f2707fbe..6d1e7284c 100644
--- a/crates/engine/src/cmd/clipboard.rs
+++ b/crates/engine/src/cmd/clipboard.rs
@@ -11,6 +11,7 @@
 
 mod flavours;
 pub(crate) mod resources;
+mod table;
 
 use std::collections::{BTreeMap, BTreeSet};
 use std::sync::Arc;
diff --git a/crates/engine/src/cmd/clipboard/flavours.rs b/crates/engine/src/cmd/clipboard/flavours.rs
index f4c096d9b..1d6f2af3e 100644
--- a/crates/engine/src/cmd/clipboard/flavours.rs
+++ b/crates/engine/src/cmd/clipboard/flavours.rs
@@ -191,7 +191,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Load Text into Clipboard",
             [],
             None,
-            "{text, center?: [x, y]} replace the clipboard with point text of `text` (one paragraph per line; trailing line breaks dropped) in the default type style, centred on `center` (default: the first artboard) → {count}; then run edit.paste",
+            "{text, center?: [x, y], table?: true} replace the clipboard with point text of `text` (one paragraph per line; trailing line breaks dropped) in the default type style, centred on `center` (default: the first artboard) → {count}; then run edit.paste. Cells copied from a spreadsheet (tab-separated, at least two columns, every row with the same number of cells, cells in double quotes may hold tabs and line breaks; at most 1000 rows, 256 columns and 20,000 cells) become a group \"Table\": point type for each cell that holds text, in columns as wide as their widest cell and rows as tall as their tallest, over a group \"Gridlines\" of 0.5 pt black lines around every cell → {count, rows, columns}; table: false pastes them as plain text",
             has_doc,
             import_text
         ),
@@ -491,9 +491,24 @@ fn import_text(s: &mut Session, p: &Value) -> Result<Value> {
     if text.trim().is_empty() {
         return Err(bad(C, "the text is empty"));
     }
-    let mut t = TextObject::point(Point::ZERO, text, super::super::create::new_type_style(s, &Value::Null));
-    t.system_layout = s.doc()?.doc.setup.system_layout;
-    crate::cmd::typecmd::refresh_bounds(&mut t);
+    let style = super::super::create::new_type_style(s, &Value::Null);
+    let system_layout = s.doc()?.doc.setup.system_layout;
+    let layout = |t: &mut TextObject| {
+        t.system_layout = system_layout;
+        crate::cmd::typecmd::refresh_bounds(t);
+    };
+    let table = match p.get("table").filter(|v| !v.is_null()) {
+        None => true,
+        Some(v) => v.as_bool().ok_or_else(|| bad(C, "table must be true or false"))?,
+    };
+    // Cells copied from a spreadsheet paste as a table of type over gridlines.
+    if let Some(rows) = table.then(|| super::table::parse(text)).flatten() {
+        let n = super::table::table(&rows, &style, layout);
+        let count = s.load_clipboard(Clipboard { nodes: vec![n], ..Default::default() }, p)?;
+        return Ok(json!({ "count": count, "rows": rows.len(), "columns": rows.first().map_or(0, Vec::len) }));
+    }
+    let mut t = TextObject::point(Point::ZERO, text, style);
+    layout(&mut t);
     let n = Node::new(NodeId(1), NodeKind::Text(Box::new(t)));
     let count = s.load_clipboard(Clipboard { nodes: vec![n], ..Default::default() }, p)?;
     Ok(json!({ "count": count }))
diff --git a/crates/engine/src/cmd/clipboard/table.rs b/crates/engine/src/cmd/clipboard/table.rs
new file mode 100644
index 000000000..392be9895
--- /dev/null
+++ b/crates/engine/src/cmd/clipboard/table.rs
@@ -0,0 +1,203 @@
+//! Cells copied from a spreadsheet (Excel, Google Sheets, LibreOffice Calc, Numbers): the plain
+//! text they put on the clipboard is tab-separated values, one row a line, every row with the
+//! same number of cells. `clipboard.importText` pastes such text as a table: a group of point
+//! type, one object for each cell that holds text, laid out in columns as wide as their widest
+//! cell and rows as tall as their tallest, over gridlines around every cell.
+
+use std::sync::Arc;
+
+use vectorcraft_doc::color::{Color, Paint};
+use vectorcraft_doc::{Appearance, CharStyle, Node, NodeId, NodeKind, TextObject};
+use vectorcraft_geom::{Affine, BezPath, PathData, Point, Rect};
+
+/// Most rows a pasted table takes; more pastes as plain text.
+pub(crate) const MAX_ROWS: usize = 1000;
+/// Most columns a pasted table takes; more pastes as plain text.
+pub(crate) const MAX_COLUMNS: usize = 256;
+/// Most cells (rows × columns) a pasted table takes; more pastes as plain text.
+pub(crate) const MAX_CELLS: usize = 20_000;
+/// Space between a cell's text and its gridlines, in points.
+const PAD: f64 = 4.0;
+/// The gridlines' stroke weight, in points.
+const GRIDLINE: f64 = 0.5;
+
+/// The rows of `text` (line breaks already `\n`, trailing ones dropped) when it is a table copied
+/// from a spreadsheet: tab-separated cells, at least two columns, every row with the same number
+/// of cells, within the caps above. A cell in double quotes may hold tabs, line breaks and
+/// doubled quotes (`""`), as the spreadsheets write them. `None` for any other text, which pastes
+/// as it always has.
+pub(crate) fn parse(text: &str) -> Option<Vec<Vec<String>>> {
+    if !text.contains('\t') {
+        return None;
+    }
+    let mut rows: Vec<Vec<String>> = vec![];
+    let mut row: Vec<String> = vec![];
+    let mut cell = String::new();
+    let mut chars = text.chars().peekable();
+    // At the start of a cell, a quote opens a quoted cell.
+    let mut start = true;
+    let mut quoted = false;
+    let mut cells = 0usize;
+    while let Some(c) = chars.next() {
+        if quoted {
+            if c == '"' {
+                if chars.peek() == Some(&'"') {
+                    chars.next();
+                    cell.push('"');
+                } else {
+                    quoted = false;
+                }
+            } else {
+                cell.push(c);
+            }
+            continue;
+        }
+        match c {
+            '"' if start => {
+                quoted = true;
+                start = false;
+            }
+            '\t' | '\n' => {
+                row.push(std::mem::take(&mut cell));
+                cells += 1;
+                if row.len() > MAX_COLUMNS || cells > MAX_CELLS {
+                    return None;
+                }
+                if c == '\n' {
+                    rows.push(std::mem::take(&mut row));
+                    if rows.len() > MAX_ROWS {
+                        return None;
+                    }
+                }
+                start = true;
+            }
+            c => {
+                cell.push(c);
+                start = false;
+            }
+        }
+    }
+    // A quote left open is not a spreadsheet's.
+    if quoted {
+        return None;
+    }
+    row.push(cell);
+    rows.push(row);
+    if rows.iter().any(|r| r.len() > MAX_COLUMNS) || cells + 1 > MAX_CELLS {
+        return None;
+    }
+    let columns = rows.first()?.len();
+    let fits = columns >= 2 && rows.len() <= MAX_ROWS && rows.iter().all(|r| r.len() == columns);
+    // The first and last columns hold something: text indented with tabs is not a table.
+    let used = |k: usize| rows.iter().any(|r| r.get(k).is_some_and(|c| !c.trim().is_empty()));
+    (fits && used(0) && used(columns - 1)).then_some(rows)
+}
+
+/// `rows` laid out as a table (see the module docs) with its top left at the origin: one group
+/// holding a group of gridlines and the cells' type. `style` is the type's style; `layout`
+/// refreshes a type object's bounds.
+pub(crate) fn table(rows: &[Vec<String>], style: &CharStyle, layout: impl Fn(&mut TextObject)) -> Node {
+    let columns = rows.iter().map(Vec::len).max().unwrap_or(0);
+    let mut next = 0u64;
+    let mut id = || {
+        next += 1;
+        NodeId(next)
+    };
+    // Each cell's type, at the origin, with its bounds.
+    let mut cells: Vec<Vec<Option<(Node, Rect)>>> = vec![];
+    for row in rows {
+        let mut out = vec![];
+        for text in row {
+            if text.trim().is_empty() {
+                out.push(None);
+                continue;
+            }
+            let text = text.replace("\r\n", "\n").replace('\r', "\n");
+            let mut t = TextObject::point(Point::ZERO, &text, style.clone());
+            layout(&mut t);
+            let n = Node::new(id(), NodeKind::Text(Box::new(t)));
+            out.push(n.geometric_bounds().filter(|b| b.is_finite()).map(|b| (n, b)));
+        }
+        cells.push(out);
+    }
+    // A row with nothing in it is as tall as one line of the type.
+    let line = style.size.max(1.0) * 1.2;
+    let widths: Vec<f64> =
+        (0..columns).map(|k| cells.iter().filter_map(|r| r.get(k)?.as_ref()).map(|(_, b)| b.width()).fold(line, f64::max) + 2.0 * PAD).collect();
+    let heights: Vec<f64> = cells.iter().map(|r| r.iter().flatten().map(|(_, b)| b.height()).fold(line, f64::max) + 2.0 * PAD).collect();
+    let xs: Vec<f64> = std::iter::once(0.0)
+        .chain(widths.iter().scan(0.0, |x, w| {
+            *x += w;
+            Some(*x)
+        }))
+        .collect();
+    let ys: Vec<f64> = std::iter::once(0.0)
+        .chain(heights.iter().scan(0.0, |y, h| {
+            *y += h;
+            Some(*y)
+        }))
+        .collect();
+    let (right, bottom) = (xs.last().copied().unwrap_or(0.0), ys.last().copied().unwrap_or(0.0));
+    let stroke = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), GRIDLINE);
+    let mut lines = vec![];
+    for y in &ys {
+        lines.push(segment(id(), (0.0, *y), (right, *y), &stroke));
+    }
+    for x in &xs {
+        lines.push(segment(id(), (*x, 0.0), (*x, bottom), &stroke));
+    }
+    let mut grid = Node::group(id(), lines);
+    grid.name = Some("Gridlines".into());
+    let mut children = vec![Arc::new(grid)];
+    for (r, row) in cells.into_iter().enumerate() {
+        for (k, cell) in row.into_iter().enumerate() {
+            let (Some((mut n, b)), Some(x), Some(y)) = (cell, xs.get(k), ys.get(r)) else { continue };
+            // The text's top left a pad inside the cell's.
+            n.transform(Affine::translate((x + PAD - b.x0, y + PAD - b.y0)), false);
+            children.push(Arc::new(n));
+        }
+    }
+    let mut group = Node::group(id(), children);
+    group.name = Some("Table".into());
+    group
+}
+
+/// A straight stroked line from `a` to `b`.
+fn segment(id: NodeId, a: (f64, f64), b: (f64, f64), stroke: &Appearance) -> Arc<Node> {
+    let mut p = BezPath::new();
+    p.move_to(a);
+    p.line_to(b);
+    Arc::new(Node::path(id, PathData::from_bezpath(&p), stroke.clone()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn spreadsheet_cells_are_told_from_other_text() {
+        let rows = parse("Name\tQty\nApples\t3\nPears\t").unwrap();
+        assert_eq!(rows, vec![vec!["Name", "Qty"], vec!["Apples", "3"], vec!["Pears", ""]]);
+        // Quoted cells hold line breaks, tabs and quotes.
+        let rows = parse("\"Two\nlines\"\t\"a\tb\"\n\"say \"\"hi\"\"\"\tx").unwrap();
+        assert_eq!(rows, vec![vec!["Two\nlines", "a\tb"], vec!["say \"hi\"", "x"]]);
+        // Not tables: no tabs, ragged rows, indented text, an unclosed quote.
+        for t in ["plain words", "one\ntwo", "a\tb\nc", "\tindented\n\tcode", "a\t\"open", "x\t"] {
+            assert_eq!(parse(t), None, "{t:?}");
+        }
+        // A quote inside a cell is just a character.
+        assert_eq!(parse("5\" pipe\t2").unwrap(), vec![vec!["5\" pipe", "2"]]);
+    }
+
+    #[test]
+    fn tables_past_the_caps_paste_as_text() {
+        let wide = vec!["x"; MAX_COLUMNS + 1].join("\t");
+        assert_eq!(parse(&wide), None);
+        let tall = vec!["a\tb"; MAX_ROWS + 1].join("\n");
+        assert_eq!(parse(&tall), None);
+        let many = vec![vec!["c"; 100].join("\t"); MAX_CELLS / 100 + 1].join("\n");
+        assert_eq!(parse(&many), None);
+        let fits = vec!["a\tb"; MAX_ROWS].join("\n");
+        assert_eq!(parse(&fits).map(|r| r.len()), Some(MAX_ROWS));
+    }
+}
diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index bd0e7704f..f4b2d21d2 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -157,7 +157,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Paste",
             ["Edit"],
             Some("Cmd+V"),
-            "{center?: [x, y], dx?, dy?, swatchConflict?} paste centred on `center` (the app passes the view centre), else offset by dx/dy (default: the Paste Offset preference). Pasting brings the image blobs, symbols, patterns, global and spot swatches (with the tint swatches of the tints used), gradient swatches, graphic styles, character and paragraph styles and brushes the objects use; one of the same name that differs comes in renamed. swatchConflict, for a swatch whose name the document gives another colour (clipboard.conflicts): \"merge\" (default: the objects take the document's swatch) | \"add\" (the pasted swatch comes in renamed) | {name: \"merge\"|\"add\"}. With Paste Remembers Layers on (layer.pasteRemembersLayers), objects go back into the layers they came from (by name; made when missing). Artboards copied with artboard.copy come with their art, together right of the last artboard as they lay (the other paste commands but Paste on All Artboards: where they were), their art back in the layers it came from, and the Artboard tool, when chosen, selects them. In Draw Inside (view.drawMode) the objects go inside the object drawn into, as new art does, and Paste Remembers Layers doesn't apply; edit.pasteInPlace and edit.pasteOnAllArtboards do the same, and in Draw Behind they go behind the selection as edit.pasteInBack puts them; edit.pasteInFront and edit.pasteInBack ignore the drawing mode → {ids, artboard: the first new artboard's index or null, artboards: the new artboards' indices, added: resources added, merged: conflicts merged, renamed: [{kind, from, to}]}",
+            "{center?: [x, y], artboardsAt?: [x, y], dx?, dy?, swatchConflict?} paste centred on `center` (the app passes the view centre), else offset by dx/dy (default: the Paste Offset preference). Pasting brings the image blobs, symbols, patterns, global and spot swatches (with the tint swatches of the tints used), gradient swatches, graphic styles, character and paragraph styles and brushes the objects use; one of the same name that differs comes in renamed. swatchConflict, for a swatch whose name the document gives another colour (clipboard.conflicts): \"merge\" (default: the objects take the document's swatch) | \"add\" (the pasted swatch comes in renamed) | {name: \"merge\"|\"add\"}. With Paste Remembers Layers on (layer.pasteRemembersLayers), objects go back into the layers they came from (by name; made when missing). Artboards copied with artboard.copy come with their art, together right of the last artboard as they lay, or centered on `artboardsAt` (the Artboard tool's canvas menu passes the right-click point; a value that is not [x, y] is an error) (the other paste commands but Paste on All Artboards: where they were), their art back in the layers it came from, and the Artboard tool, when chosen, selects them. In Draw Inside (view.drawMode) the objects go inside the object drawn into, as new art does, and Paste Remembers Layers doesn't apply; edit.pasteInPlace and edit.pasteOnAllArtboards do the same, and in Draw Behind they go behind the selection as edit.pasteInBack puts them; edit.pasteInFront and edit.pasteInBack ignore the drawing mode → {ids, artboard: the first new artboard's index or null, artboards: the new artboards' indices, added: resources added, merged: conflicts merged, renamed: [{kind, from, to}]}",
             has_clipboard,
             |s, p| paste(s, p, PasteMode::Offset)
         ),
@@ -962,19 +962,28 @@ fn onto_artboard(doc: &Document, p: &Value, clip: &Clipboard) -> Affine {
 /// Insert clipboard resources atomically in the active editable context using the requested placement mode.
 fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, choices: &SwatchChoices) -> Result<Value> {
     let off = s.prefs.paste_offset;
+    let boards_at = match p.get("artboardsAt") {
+        Some(v) if mode == PasteMode::Offset => Some(
+            point_param(p, "artboardsAt")
+                .filter(|c| v.as_array().is_some_and(|a| a.len() == 2) && c.x.is_finite() && c.y.is_finite())
+                .ok_or_else(|| bad("edit.paste", "`artboardsAt` must be [x, y]"))?,
+        ),
+        _ => None,
+    };
     let st = s.doc()?;
     let same_doc = clip.source_doc == Some(st.uid);
     let parent = st.target_parent_for_path()?;
     // Copied artboards come back with their art: together right of the last artboard, as they lay,
-    // or where they were (Paste in Place, in Front, in Back). Paste on All Artboards pastes only the
-    // art.
-    let boards = clip
-        .artboards
-        .iter()
-        .map(|a| a.rect)
-        .reduce(|a, b| a.union(b))
-        .filter(|_| mode != PasteMode::AllArtboards)
-        .map(|all| (&clip.artboards, if mode == PasteMode::Offset { super::panelcmds::beside_artboards(&st.doc, all) } else { Vec2::ZERO }));
+    // or centered on `artboardsAt`, or where they were (Paste in Place, in Front, in Back). Paste on
+    // All Artboards pastes only the art.
+    let boards = clip.artboards.iter().map(|a| a.rect).reduce(|a, b| a.union(b)).filter(|_| mode != PasteMode::AllArtboards).map(|all| {
+        let dv = match (mode, boards_at) {
+            (PasteMode::Offset, Some(c)) => c - all.center(),
+            (PasteMode::Offset, None) => super::panelcmds::beside_artboards(&st.doc, all),
+            _ => Vec2::ZERO,
+        };
+        (&clip.artboards, dv)
+    });
     // Drawing modes (#3705): Draw Inside puts what Paste, Paste in Place and Paste on All
     // Artboards bring inside the object it draws into; Draw Behind puts what Paste in Place and
     // Paste on All Artboards bring behind the selection, as Paste in Back does. Paste in Front and
diff --git a/crates/engine/src/cmd/effectcmd.rs b/crates/engine/src/cmd/effectcmd.rs
index f4c0073a3..a823ee161 100644
--- a/crates/engine/src/cmd/effectcmd.rs
+++ b/crates/engine/src/cmd/effectcmd.rs
@@ -754,7 +754,10 @@ fn expanded_node(d: &mut Document, mut n: Node, brushes: &[vectorcraft_brush::Br
         // keeps it as its only member).
         Some((image, false)) => Some(rasterfx::replace_with_image(v, image)),
         image => {
-            let m = if container {
+            let m = if container && effects::has_solid(&v) {
+                // A group's or layer's 3D effect: the shaded faces of its members' solids.
+                effects::expand_leaf(d, &v, &mut stroke_art)
+            } else if container {
                 // A group's or layer's own fills and strokes become art among its members.
                 effects::evaluate_container(Some(&*d), &v).map(|mut m| {
                     members = expand_pieces(d, &mut m, false, brushes, &mut stroke_art);
diff --git a/crates/engine/src/cmd/effectcmd/tests.rs b/crates/engine/src/cmd/effectcmd/tests.rs
index ce8f51183..be1dd443c 100644
--- a/crates/engine/src/cmd/effectcmd/tests.rs
+++ b/crates/engine/src/cmd/effectcmd/tests.rs
@@ -79,6 +79,41 @@ fn solid_effects_apply_save_edit_export_expand_and_undo() {
     }
 }
 
+/// #4506: a 3D effect on a group builds a solid from each member, turned about one shared axis;
+/// the members stay editable, and a group holding what can't become a solid is refused.
+#[test]
+fn solid_effects_apply_to_a_group_and_its_members_stay_editable() {
+    for effect in effects::SOLIDS {
+        let (mut s, a) = session_with_rect();
+        let b = s.execute("shape.ellipse", &json!({"x": 250, "y": 120, "width": 80, "height": 60})).unwrap()["id"].clone();
+        s.execute("select.set", &json!({"ids": [a.0, b]})).unwrap();
+        let g = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap());
+        s.execute("effect.apply", &json!({"effect": effect, "ids": [g.0], "item": null})).unwrap();
+        let art = effects::solid_art(&node(&s, g)).unwrap_or_else(|| panic!("{effect}"));
+        assert_eq!(node(&s, g).children().unwrap().len(), 2, "{effect}: the members stay as they were");
+        // A member moved, the solid follows.
+        s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
+        s.execute("object.move", &json!({"dx": -40, "dy": 0})).unwrap();
+        assert_ne!(effects::solid_art(&node(&s, g)).unwrap(), art, "{effect}");
+        let svg = s.execute("document.serialize", &json!({"format": "svg"})).unwrap();
+        let svg = svg["data"].as_str().or_else(|| svg["text"].as_str()).map(str::to_string).unwrap_or_else(|| svg.to_string());
+        assert!(vectorcraft_testkit::svg_shapes(&svg) >= 4, "{effect}: both members exported as vector faces");
+        s.execute("effect.expandAppearance", &json!({"ids": [g.0]})).unwrap();
+        assert!(!effects::has_solid(&node(&s, g)), "{effect}: expanded");
+    }
+    // A clipping group in the group: refused, nothing changed.
+    let (mut s, a) = session_with_rect();
+    let b = s.execute("shape.ellipse", &json!({"x": 120, "y": 120, "width": 60, "height": 60})).unwrap()["id"].clone();
+    s.execute("select.set", &json!({"ids": [a.0, b]})).unwrap();
+    let clip = s.execute("object.clippingMask.make", &json!({})).unwrap()["id"].clone();
+    let c = s.execute("shape.rectangle", &json!({"x": 250, "y": 250, "width": 50, "height": 50})).unwrap()["id"].clone();
+    s.execute("select.set", &json!({"ids": [clip, c]})).unwrap();
+    let g = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let err = s.execute("effect.apply", &json!({"effect": "threeD.extrude", "ids": [g.0], "item": null})).unwrap_err().to_string();
+    assert!(err.contains("clipping groups"), "{err}");
+    assert!(node(&s, g).appearance.effects.is_empty());
+}
+
 /// #4715: type extrudes as its glyph outlines, painted with its characters' colour, and stays
 /// type: editing its text reshapes the solid.
 #[test]
diff --git a/crates/engine/src/cmd/fileio.rs b/crates/engine/src/cmd/fileio.rs
index 7c828221b..0c888d13c 100644
--- a/crates/engine/src/cmd/fileio.rs
+++ b/crates/engine/src/cmd/fileio.rs
@@ -57,9 +57,9 @@ use serde_json::{Value, json};
 pub use dxf::{UNSUPPORTED, Unsupported, unsupported};
 pub use encode::{ARTBOARD_PARAMS, ArtboardPick, Encoded, encode, encode_all, encode_with_warnings};
 pub(crate) use encode::{anti_alias, background, with_single_artboard};
-pub use export::export_source;
 pub(crate) use export::with_artboard_fills;
 pub(crate) use export::{export_crop, isolated};
+pub use export::{export_doc, export_source};
 pub(crate) use load::check_not_lossy_overwrite;
 use load::err;
 pub(crate) use load::import_svg;
diff --git a/crates/engine/src/cmd/fileio/export.rs b/crates/engine/src/cmd/fileio/export.rs
index 852f2c735..13564614b 100644
--- a/crates/engine/src/cmd/fileio/export.rs
+++ b/crates/engine/src/cmd/fileio/export.rs
@@ -72,6 +72,17 @@ pub(super) fn export(s: &mut Session, p: &Value) -> Result<Value> {
     write_encoded(path, &default_name(doc, f.extensions[0]), doc, &enc, json!({ "format": f.id, "warnings": enc.warnings }))
 }
 
+/// The document an export of `st` in format `f` writes ([`export_source`]): a `.ai` or `.ait`
+/// file names the view's active artboard ([`DocState::active_artboard`]) as its active one, as a
+/// save does. The open document is unchanged.
+pub fn export_doc<'a>(st: &'a DocState, f: &Format, p: &Value) -> Result<Cow<'a, Document>> {
+    let mut doc = export_source(st, p)?;
+    if let Some(id) = super::save::moved_active_artboard(st, &doc, f) {
+        doc.to_mut().opened_artboard = Some(id);
+    }
+    Ok(doc)
+}
+
 /// The document an export of `st` writes: the whole document, or with `selectedOnly` just the
 /// selected objects, each in its layers and groups (a clipping group keeps its clipping path).
 pub fn export_source<'a>(st: &'a DocState, p: &Value) -> Result<Cow<'a, Document>> {
@@ -190,7 +201,7 @@ fn source<'a>(s: &'a mut Session, f: &Format, p: &Value, cmd: &str) -> Result<(C
         return Ok((Cow::Owned(doc), display_doc_title));
     }
     let st = s.doc()?;
-    let doc = export_source(st, p)?;
+    let doc = export_doc(st, f, p)?;
     let display_doc_title = super::has_own_title(&doc);
     Ok((super::titled_for_export(&doc, st.path.as_deref(), f.id).map_or(doc, Cow::Owned), display_doc_title))
 }
diff --git a/crates/engine/src/cmd/fileio/legacy_ai.rs b/crates/engine/src/cmd/fileio/legacy_ai.rs
index 691c0e836..9bf7a311a 100644
--- a/crates/engine/src/cmd/fileio/legacy_ai.rs
+++ b/crates/engine/src/cmd/fileio/legacy_ai.rs
@@ -14,7 +14,8 @@
 //! Images are the exception (`transparentImages`): an image with see-through pixels, opacity or a
 //! blending mode written opaque is a box hiding the art under it (version 7 images have no alpha
 //! channel, §8.1). With `flatten` (the default) each becomes an opaque image of itself and the art
-//! under it, rendered from the document as it is, clipped to the area where it changes what shows;
+//! under it, rendered from the document as it is, clipped to the area where it changes what shows
+//! (a smooth outline of its rendered pixels, not a staircase of them);
 //! the art under it stays as it was. An image in a group with opacity or a blending mode is
 //! flattened the same way, and a pattern fill that paints a transparent image (see-through
 //! pixels, or opacity or a blending mode on the image, the fill, the shape or a group it is in) is
@@ -253,8 +254,11 @@ const MAX_PPI: f64 = 600.0;
 const MIN_PPI: f64 = 72.0;
 /// A rendered pixel channel changes when it changes by more than this.
 const CHANGED: u8 = 2;
-/// The clip outline follows cells of about this many points.
-const CELL: f64 = 2.0;
+/// The clip outline follows the rendered pixels, in blocks of them when there would be more than
+/// this many: a huge image's clip would have millions of anchors.
+const MAX_CELLS: usize = 4 << 20;
+/// How far (in cells) the clip outline may stray from the staircase it smooths.
+const SMOOTH: f64 = 0.35;
 
 /// The image `id` (the `at`th node in paint order of `src`) flattened: `src` drawn up to and
 /// including it, over white, cropped and clipped to the cells where drawing it changes the
@@ -288,18 +292,21 @@ fn flattened(src: &Document, at: usize, id: NodeId) -> Result<Option<Flat>> {
     if w == 0 || h == 0 || shown.pixels.len() != w * h * 4 || under.pixels.len() != shown.pixels.len() {
         return Ok(None);
     }
-    // The cells where it changes anything.
-    let c = (CELL * scale).round().max(1.0) as usize;
+    // The cells where it changes anything: its pixels, or blocks of them for a huge image.
+    let c = if w * h <= MAX_CELLS { 1 } else { ((w * h) as f64 / MAX_CELLS as f64).sqrt().ceil() as usize };
     let (cw, ch) = (w.div_ceil(c), h.div_ceil(c));
-    let mut cells = vec![false; cw * ch];
+    let mut changed = vec![false; cw * ch];
     for (k, (a, b)) in shown.pixels.as_chunks::<4>().0.iter().zip(under.pixels.as_chunks::<4>().0).enumerate() {
         if a.iter().zip(b).any(|(a, b)| a.abs_diff(*b) > CHANGED) {
             let (x, y) = (k % w, k / w);
-            if let Some(cell) = cells.get_mut(y / c * cw + x / c) {
+            if let Some(cell) = changed.get_mut(y / c * cw + x / c) {
                 *cell = true;
             }
         }
     }
+    // Grown by a cell, so the clip takes in the whole anti-aliased edge: where the image changes
+    // nothing it is the art under it, so a clip a little too large shows nothing more.
+    let cells = grown(&changed, cw, ch);
     let marked = || cells.iter().enumerate().filter(|(_, on)| **on).map(|(k, _)| (k % cw, k / cw));
     let (Some(x0), Some(x1), Some(y0), Some(y1)) =
         (marked().map(|p| p.0).min(), marked().map(|p| p.0).max(), marked().map(|p| p.1).min(), marked().map(|p| p.1).max())
@@ -316,12 +323,16 @@ fn flattened(src: &Document, at: usize, id: NodeId) -> Result<Option<Flat>> {
     let crop = vectorcraft_render::Rendered { width: (px1 - px0) as u32, height: (py1 - py0) as u32, pixels };
     let png = crop.to_png().map_err(EngineError::Other)?;
     let at = |x: usize, y: usize| Point::new(region.x0 + (x.min(w)) as f64 / scale, region.y0 + (y.min(h)) as f64 / scale);
+    // A cell corner, in cells, as a point of the page.
+    let (wf, hf, cf) = (w as f64, h as f64, c as f64);
+    let page = |(x, y): (f64, f64)| Point::new(region.x0 + (x * cf).clamp(0.0, wf) / scale, region.y0 + (y * cf).clamp(0.0, hf) / scale);
     let mut clip = PathData::new(vec![]);
     for comp in vectorcraft_trace::trace_mask(&cells, cw, ch) {
         for lp in std::iter::once(&comp.outer).chain(&comp.holes) {
-            let pts: Vec<(i32, i32)> = corners(&lp.pts);
-            let anchors = pts.iter().map(|&(x, y)| Anchor::corner(at(x.max(0) as usize * c, y.max(0) as usize * c))).collect();
-            clip.subpaths.push(SubPath::new(anchors, true));
+            let anchors: Vec<Anchor> = smoothed(&lp.pts).into_iter().map(|p| Anchor::corner(page(p))).collect();
+            if anchors.len() >= 3 {
+                clip.subpaths.push(SubPath::new(anchors, true));
+            }
         }
     }
     let xf = Affine::translate(at(px0, py0).to_vec2()) * Affine::scale(1.0 / scale);
@@ -343,17 +354,64 @@ fn up_to(n: &Node, last: usize, i: &mut usize) -> Option<Node> {
     Some(n)
 }
 
-/// A loop's corners: its points without those in the middle of a straight run.
-fn corners(pts: &[(i32, i32)]) -> Vec<(i32, i32)> {
+/// `mask` (`w × h` cells) with every cell next to a set one set too.
+fn grown(mask: &[bool], w: usize, h: usize) -> Vec<bool> {
+    let set = |x: usize, y: usize| mask.get(y * w + x).copied().unwrap_or(false);
+    let mut out = vec![false; mask.len()];
+    for (k, cell) in out.iter_mut().enumerate() {
+        let (x, y) = (k % w, k / w);
+        *cell = (y.saturating_sub(1)..(y + 2).min(h)).any(|y| (x.saturating_sub(1)..(x + 2).min(w)).any(|x| set(x, y)));
+    }
+    out
+}
+
+/// A loop of cell corners (a staircase) as a smooth outline, in cells: the middle of each cell
+/// edge along it, so that a run of one-cell steps becomes the sloped line it stands for, without
+/// the points that lie (within [`SMOOTH`]) on a straight line between their neighbours.
+fn smoothed(pts: &[(i32, i32)]) -> Vec<(f64, f64)> {
+    let mut mids = Vec::with_capacity(pts.len());
+    for (k, &(ax, ay)) in pts.iter().enumerate() {
+        let Some(&(bx, by)) = pts.get(k + 1).or(pts.first()) else { break };
+        let (dx, dy) = ((bx - ax).signum(), (by - ay).signum());
+        let steps = (bx - ax).unsigned_abs().max((by - ay).unsigned_abs());
+        for i in 0..steps as i32 {
+            let (x, y) = (ax + dx * i, ay + dy * i);
+            mids.push((f64::from(x) + 0.5 * f64::from(dx), f64::from(y) + 0.5 * f64::from(dy)));
+        }
+    }
+    simplify_closed(&mids, SMOOTH)
+}
+
+/// The points of closed polyline `pts` that Douglas–Peucker keeps with tolerance `tol`.
+fn simplify_closed(pts: &[(f64, f64)], tol: f64) -> Vec<(f64, f64)> {
     let n = pts.len();
-    let get = |k: usize| pts.get(k % n.max(1)).copied();
-    (0..n)
-        .filter_map(|k| {
-            let (a, b, c) = (get(k + n - 1)?, get(k)?, get(k + 1)?);
-            let straight = (a.0 == b.0 && b.0 == c.0) || (a.1 == b.1 && b.1 == c.1);
-            (!straight).then_some(b)
-        })
-        .collect()
+    if n < 4 {
+        return pts.to_vec();
+    }
+    let d2 = |a: (f64, f64), b: (f64, f64)| (a.0 - b.0).powi(2) + (a.1 - b.1).powi(2);
+    let Some(&first) = pts.first() else { return vec![] };
+    // Split at the first point and the point farthest from it: two open runs.
+    let far = (1..n).max_by(|&i, &j| d2(first, pts[i]).total_cmp(&d2(first, pts[j]))).unwrap_or(n / 2);
+    let mut keep = vec![false; n];
+    keep[0] = true;
+    keep[far] = true;
+    let mut todo = vec![(0, far), (far, n)];
+    while let Some((a, b)) = todo.pop() {
+        if b <= a + 1 {
+            continue;
+        }
+        let (p, q) = (pts[a], pts[b % n]);
+        let (ux, uy) = (q.0 - p.0, q.1 - p.1);
+        let len = ux.hypot(uy);
+        let dist = |r: (f64, f64)| if len > 0.0 { ((r.0 - p.0) * uy - (r.1 - p.1) * ux).abs() / len } else { d2(p, r).sqrt() };
+        let Some((m, dm)) = (a + 1..b).map(|i| (i, dist(pts[i]))).max_by(|x, y| x.1.total_cmp(&y.1)) else { continue };
+        if dm > tol {
+            keep[m] = true;
+            todo.push((a, m));
+            todo.push((m, b));
+        }
+    }
+    pts.iter().zip(&keep).filter(|(_, k)| **k).map(|(p, _)| *p).collect()
 }
 
 fn note(warnings: &mut Vec<String>, w: &str) {
diff --git a/crates/engine/src/cmd/fileio/native.rs b/crates/engine/src/cmd/fileio/native.rs
index 4d293fe69..770c11644 100644
--- a/crates/engine/src/cmd/fileio/native.rs
+++ b/crates/engine/src/cmd/fileio/native.rs
@@ -109,7 +109,7 @@ pub const AI_OPTIONS: &[FormatOption] = &[
         name: "editingData",
         ty: "boolean",
         default: "true",
-        description: "also carry an editing copy of the artwork in the form other apps that open .ai files read: layers and sublayers, groups, compound paths, paths, fills and strokes, colors, linear and radial gradients, patterns on a grid of tiles, swatches, artboards, the transparency of objects and layers, objects' opacity masks, clipping groups and layers clipped by a path, embedded images with their pixels, and linked images as placed files with a preview, with type, other patterns, symbols, other clipping objects and live objects as plain filled and stroked paths, freeform gradients, gradients along or across a stroke and gradients of more than 256 stops as their average color, gradients that dither or mix perceptually as classic ones, and gradient stops linked to global process colors as their colors (written only with every artboard, as Preserve Editing is)",
+        description: "also carry an editing copy of the artwork in the form other apps that open .ai files read: layers and sublayers, groups, compound paths, paths, fills and strokes, colors, linear and radial gradients, patterns on a grid of tiles, swatches, artboards and which one is active, the transparency of objects and layers, objects' opacity masks, clipping groups and layers clipped by a path, embedded images with their pixels, and linked images as placed files with a preview, with type, other patterns, symbols, other clipping objects and live objects as plain filled and stroked paths, freeform gradients, gradients along or across a stroke and gradients of more than 256 stops as their average color, gradients that dither or mix perceptually as classic ones, and gradient stops linked to global process colors as their colors (written only with every artboard, as Preserve Editing is)",
     },
     FormatOption {
         name: "aiVersion",
diff --git a/crates/engine/src/cmd/fileio/save.rs b/crates/engine/src/cmd/fileio/save.rs
index b594c51b8..ce00a2cfb 100644
--- a/crates/engine/src/cmd/fileio/save.rs
+++ b/crates/engine/src/cmd/fileio/save.rs
@@ -96,7 +96,8 @@ pub struct SavePlan {
     /// stamps; `None`: the time it is written.
     pub modified: Option<Option<i64>>,
     /// Warnings about the params themselves: each native option (`compress`, `version`,
-    /// `preview`) given beside the path that the format doesn't read.
+    /// `preview`, `precision`) given beside the path, and each key of `options`, that the format
+    /// doesn't read, naming the file the save writes.
     pub notes: Vec<String>,
 }
 
@@ -289,9 +290,11 @@ pub fn save_plan(s: &Session, mode: SaveMode, p: &Value) -> Result<SavePlan> {
         super::check_not_lossy_overwrite(st, path, p, cmd)?;
     }
     let written = written_as(cmd, format, &Value::Object(options.clone()));
-    let notes = NATIVE_OPTIONS
-        .iter()
-        .filter(|k| p.get(**k).is_some_and(|v| !v.is_null()) && !reads_option(format, k))
+    let top = NATIVE_OPTIONS.iter().filter(|k| p.get(**k).is_some_and(|v| !v.is_null())).map(|k| k.to_string());
+    let nested = p.get("options").and_then(Value::as_object).into_iter().flatten().filter(|(_, v)| !v.is_null()).map(|(k, _)| k);
+    let notes = top
+        .filter(|k| !reads_option(format, k))
+        .chain(nested.filter(|k| !reads_option(format, k)).map(|k| format!("options.{k}")))
         .map(|k| format!("`{k}` was not used: {} files don't read it", written.label))
         .collect();
     Ok(SavePlan { mode, path, format, options, name, folder, modified, notes })
@@ -447,22 +450,34 @@ fn is_svg(f: &Format) -> bool {
 }
 
 /// The document as written: native files carry the view to reopen at and the Layers panel's open
-/// rows and transparency grid visibility.
+/// rows and transparency grid visibility; a `.ai` file names the view's active artboard
+/// ([`DocState::active_artboard`]) as its active one.
 fn doc_to_save(st: &DocState, f: &Format) -> Arc<Document> {
     if !is_native(f) {
         return st.doc.clone();
     }
     let open = st.layers_open.saved(&st.doc);
-    if st.doc.last_view == st.view && st.doc.layers_open == open && st.doc.transparency_grid == st.transparency_grid {
+    let active = moved_active_artboard(st, &st.doc, f);
+    if st.doc.last_view == st.view && st.doc.layers_open == open && st.doc.transparency_grid == st.transparency_grid && active.is_none() {
         return st.doc.clone();
     }
     let mut d = (*st.doc).clone();
+    if active.is_some() {
+        d.opened_artboard = active;
+    }
     d.last_view = st.view.clone();
     d.transparency_grid = st.transparency_grid;
     d.layers_open = open;
     Arc::new(d)
 }
 
+/// The artboard a `.ai` or `.ait` file written from `st` (`doc`, the document it writes) names as
+/// its active one, when that is not already the one `doc` opened on: the view's active artboard
+/// ([`DocState::active_artboard`]), if `doc` has it.
+pub(super) fn moved_active_artboard(st: &DocState, doc: &Document, f: &Format) -> Option<u32> {
+    st.active_artboard.filter(|id| matches!(f.id, "ai" | "ait") && doc.artboards.iter().any(|a| a.id == *id) && doc.opened_artboard != Some(*id))
+}
+
 /// What a format loses against a native file (reported whenever a save writes it).
 fn fidelity_warning(f: &Format) -> Option<String> {
     (!is_native(f)).then(|| {
@@ -1057,7 +1072,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
             "Save Document",
             [],
             None,
-            "{path?, format?: vectorcraft|template|pdf|svg|svgz|ai|eps (default: the path's extension, else the document's own format), options?: {…the format's options, see file.formatOptions; default: as last saved}, svg?: {…SVG options} (an SVG save keeps hidden layers, display:none, unless hiddenLayers is false), …the SVG and PDF options given flat instead (an option given flat or in svg and in options with different values is an error), compress?: bool (native, also in options: gzip; default: the useCompression preference; warnings say when the format doesn't read compress, version, preview or precision given flat), version?: 4 (3, 2 or 1: for older VectorCraft versions; 1 and 2 are never compressed), preview?: false (embed a PNG of the first artboard, at most 256 px), precision?: 0..9 (native: round path anchors and handles to this many decimal places, a smaller file; colors, transforms and type stay exact; default: exact, and a later save without it writes exactly again), separateArtboards?: false (native and .ai: also save each artboard of `range` to <name>-<artboard>.<ext> beside the file, holding that artboard and the art touching it; the result's files lists every file written), range?: \"1-3, 5\"|\"all\" (default; with separateArtboards), includeLinked?: false (keep linked files' own pixels, not just their previews; they stay linked), embedProfiles?: true (carry the ICC profiles loaded from files that the document is tagged with; opening the file installs them where missing), pdfCompatible?: false for native (also carry a PDF of every artboard) | true for .ai (false: blank pages, only the native document; a .ai file's compress, default true, is its compression.compressText), modified?: Unix seconds|null (the File Info modified date, and created date when there is none, a save to a file stamps; default now, recorded in the journal so a replay matches; null: leave the dates)} → {path, format, bytes, warnings, files?: [path…] (the file and its artboards' files), linked?: [path…] (images an SVG links to)}. Save writes one artboard, except a .ai file: a PDF-compatible file of every artboard carrying the native document (preserveEditing always on; PDF options flat or in options), which document.open restores exactly; separateArtboards writes more files, one per artboard. EPS saves the chosen artboard (first by default), retaining its page margins and the whole editable document; its PostScript appearance flattens transparency, as EPS requires. Without a path it writes the document's own file in its own format: a document opened from or saved as SVG/PDF/EPS saves as that again (warnings name what the format loses). No path known (never saved, converted from an older version, restored by Data Recovery, or another format) → {dataBase64, format, name, folder?, warnings} and the document stays modified",
+            "{path?, format?: vectorcraft|template|pdf|svg|svgz|ai|eps (default: the path's extension, else the document's own format), options?: {…the format's options, see file.formatOptions; default: as last saved}, svg?: {…SVG options} (an SVG save keeps hidden layers, display:none, unless hiddenLayers is false), …the SVG and PDF options given flat instead (an option given flat or in svg and in options with different values is an error), compress?: bool (native, also in options: gzip; default: the useCompression preference; warnings say when the format doesn't read compress, version, preview or precision given flat, or a key given in options), version?: 4 (3, 2 or 1: for older VectorCraft versions; 1 and 2 are never compressed), preview?: false (embed a PNG of the first artboard, at most 256 px), precision?: 0..9 (native: round path anchors and handles to this many decimal places, a smaller file; colors, transforms and type stay exact; default: exact, and a later save without it writes exactly again), separateArtboards?: false (native and .ai: also save each artboard of `range` to <name>-<artboard>.<ext> beside the file, holding that artboard and the art touching it; the result's files lists every file written), range?: \"1-3, 5\"|\"all\" (default; with separateArtboards), includeLinked?: false (keep linked files' own pixels, not just their previews; they stay linked), embedProfiles?: true (carry the ICC profiles loaded from files that the document is tagged with; opening the file installs them where missing), pdfCompatible?: false for native (also carry a PDF of every artboard) | true for .ai (false: blank pages, only the native document; a .ai file's compress, default true, is its compression.compressText), modified?: Unix seconds|null (the File Info modified date, and created date when there is none, a save to a file stamps; default now, recorded in the journal so a replay matches; null: leave the dates)} → {path, format, bytes, warnings, files?: [path…] (the file and its artboards' files), linked?: [path…] (images an SVG links to)}. Save writes one artboard, except a .ai file: a PDF-compatible file of every artboard carrying the native document (preserveEditing always on; PDF options flat or in options), which document.open restores exactly; separateArtboards writes more files, one per artboard. EPS saves the chosen artboard (first by default), retaining its page margins and the whole editable document; its PostScript appearance flattens transparency, as EPS requires. Without a path it writes the document's own file in its own format: a document opened from or saved as SVG/PDF/EPS saves as that again (warnings name what the format loses). No path known (never saved, converted from an older version, restored by Data Recovery, or another format) → {dataBase64, format, name, folder?, warnings} and the document stays modified",
             has_doc,
             |s, p| save(s, SaveMode::Save, p)
         ),
diff --git a/crates/engine/src/cmd/fileio/tests_aiimport.rs b/crates/engine/src/cmd/fileio/tests_aiimport.rs
index 0aa1733d8..e9e24e5a1 100644
--- a/crates/engine/src/cmd/fileio/tests_aiimport.rs
+++ b/crates/engine/src/cmd/fileio/tests_aiimport.rs
@@ -148,6 +148,61 @@ fn an_ai_file_opens_with_its_active_artboard() {
     assert_eq!(d.opened_artboard, Some(d.artboards[1].id), "{r}");
 }
 
+/// A `.ai` save names the view's active artboard in its editing copy, else the one the document
+/// opened on, else the first; the file read from that copy opens on it.
+#[test]
+fn an_ai_save_names_its_active_artboard() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 60, "height": 40, "artboards": 3})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+    let ids: Vec<u32> = s.doc().unwrap().doc.artboards.iter().map(|a| a.id).collect();
+    let opts = LoadOptions { native: false, ..Default::default() };
+    let active = |s: &mut Session, format: &str| {
+        let cmd = if format == "ait" { "file.saveAsTemplate" } else { "file.saveCopy" };
+        let saved = s.execute(cmd, &json!({"format": format})).unwrap();
+        let bytes = vectorcraft_format::base64_decode(saved["dataBase64"].as_str().unwrap()).unwrap();
+        let l = load::load_with(&format!("a.{format}"), &bytes, &opts).unwrap();
+        assert!(l.editing_data && !l.restored, "{:?}", l.warnings);
+        assert_eq!(l.doc.artboards.len(), 3);
+        l.doc.opened_artboard.and_then(|id| l.doc.artboards.iter().position(|a| a.id == id)).unwrap_or(0)
+    };
+    assert_eq!(active(&mut s, "ai"), 0);
+    // The view's.
+    s.doc_mut().unwrap().active_artboard = Some(ids[2]);
+    assert_eq!((active(&mut s, "ai"), active(&mut s, "ait")), (2, 2));
+    // The one the document opened on, when the view names none or an artboard it doesn't have.
+    Arc::make_mut(&mut s.doc_mut().unwrap().doc).opened_artboard = Some(ids[1]);
+    for view in [None, Some(99)] {
+        s.doc_mut().unwrap().active_artboard = view;
+        assert_eq!(active(&mut s, "ai"), 1, "{view:?}");
+    }
+    // The view's first artboard over the one the document opened on.
+    s.doc_mut().unwrap().active_artboard = Some(ids[0]);
+    assert_eq!(active(&mut s, "ai"), 0);
+    assert_eq!(s.doc().unwrap().doc.opened_artboard, Some(ids[1]), "the document is unchanged");
+}
+
+/// A `.ai` export (`document.serialize`, `document.export`, with or without `selectedOnly`) names
+/// the view's active artboard in its editing copy, as a save does.
+#[test]
+fn an_ai_export_names_its_active_artboard() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 60, "height": 40, "artboards": 3})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+    let ids: Vec<u32> = s.doc().unwrap().doc.artboards.iter().map(|a| a.id).collect();
+    s.doc_mut().unwrap().active_artboard = Some(ids[2]);
+    let opts = LoadOptions { native: false, ..Default::default() };
+    for (cmd, selected) in [("document.serialize", false), ("document.serialize", true), ("document.export", false)] {
+        let out = s.execute(cmd, &json!({"format": "ai", "selectedOnly": selected})).unwrap();
+        let bytes = vectorcraft_format::base64_decode(out["dataBase64"].as_str().unwrap()).unwrap();
+        let l = load::load_with("a.ai", &bytes, &opts).unwrap();
+        assert!(l.editing_data && !l.restored, "{cmd}: {:?}", l.warnings);
+        let active = l.doc.opened_artboard.and_then(|id| l.doc.artboards.iter().position(|a| a.id == id));
+        assert_eq!(active, Some(2), "{cmd} {selected}");
+    }
+    assert_eq!(s.doc().unwrap().doc.opened_artboard, None, "the document is unchanged");
+}
+
 #[test]
 fn an_ai_unread_group_keeps_its_layers_and_live_neighbor() {
     let live = format!("0 0 1 0 k\n{}f", ai::rect(10.0, 10.0, 14.0, 14.0));
diff --git a/crates/engine/src/cmd/fileio/tests_pdfedit.rs b/crates/engine/src/cmd/fileio/tests_pdfedit.rs
index b87ec3ee2..605f82967 100644
--- a/crates/engine/src/cmd/fileio/tests_pdfedit.rs
+++ b/crates/engine/src/cmd/fileio/tests_pdfedit.rs
@@ -598,36 +598,17 @@ fn editing_copy(bytes: &[u8]) -> vectorcraft_doc::Document {
     l.doc
 }
 
-/// `nodes` as the editing copy reads them back: an opacity mask's art that isn't a group comes
-/// back as a plain group holding it.
-fn mask_art_grouped(nodes: &mut [std::sync::Arc<vectorcraft_doc::Node>]) {
-    use vectorcraft_doc::{Node, NodeKind};
-    for n in nodes {
-        let n = std::sync::Arc::make_mut(n);
-        if let Some(m) = n.extras_mut().mask.as_mut()
-            && !matches!(m.art.kind, NodeKind::Group { .. })
-        {
-            let art = m.art.clone();
-            m.art = std::sync::Arc::new(Node::new(art.id, NodeKind::Group { children: vec![art], clip: false }));
-        }
-        if let Some(c) = n.children_mut() {
-            mask_art_grouped(c);
-        }
-    }
-}
-
 /// Transparency, a compound path, a clipping group, an opacity mask and a clipping layer come back
 /// from the editing copy for other apps alone, its page matching it, with every save option that
 /// writes the copy; the version 7 `.ai` keeps the compound path and the clipping group.
 #[test]
 fn transparency_clipping_and_opacity_masks_come_back_from_the_editing_copy() {
     let mut s = see_through_session();
-    let mut before = (*s.doc().unwrap().doc).clone();
-    // The mask's art is one path; it reads back as a group holding the path.
+    let before = (*s.doc().unwrap().doc).clone();
+    // The mask's art is one path, and it reads back as that path.
     let mut arts = vec![];
     before.walk(|n| arts.extend(n.extras().mask.as_ref().map(|m| matches!(m.art.kind, vectorcraft_doc::NodeKind::Path { .. }))));
     assert_eq!(arts, [true]);
-    mask_art_grouped(&mut before.layers);
     let want = see_through_outline(&before);
     for opts in [json!({"format": "ai"}), json!({"format": "ai", "compress": false}), json!({"format": "ai", "pdfCompatible": true})] {
         let bytes = b64(&s.execute("document.export", &opts).unwrap());
@@ -803,6 +784,65 @@ fn images_come_back_from_the_editing_copy() {
     }
 }
 
+/// The type of `doc`'s art, one line each: its kind, point type's matrix or area type's frame on the
+/// document (rounded to hundredths), its characters, and each run's font, size and fill.
+fn type_outline(doc: &vectorcraft_doc::Document) -> Vec<String> {
+    use vectorcraft_doc::{NodeKind, TextKind};
+    let mut out = vec![];
+    let round = |v: f64| (v * 100.0).round() / 100.0 + 0.0;
+    doc.walk(|n| {
+        if let NodeKind::Text(t) = &n.kind {
+            let (kind, xf) = match &t.kind {
+                TextKind::Point => ("point", t.xf.as_coeffs().map(round).to_vec()),
+                TextKind::Area { frame } => {
+                    let b = frame.transformed(t.xf).bounds().unwrap();
+                    ("area", vec![round(b.x0), round(b.y0), round(b.x1), round(b.y1)])
+                }
+                TextKind::OnPath { .. } => ("path", vec![]),
+            };
+            let runs: Vec<String> = t
+                .runs
+                .iter()
+                .map(|r| format!("{:?} {} {} {} {:?}", r.text, r.style.font_family, r.style.font_style, round(r.style.size), r.style.fill))
+                .collect();
+            out.push(format!("{kind} {xf:?} {runs:?}"));
+        }
+    });
+    out
+}
+
+/// Point type of two paragraphs, turned point type and area type come back from the editing copy
+/// for other apps alone as type, with every save option that writes the copy.
+#[test]
+fn type_comes_back_from_the_editing_copy() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 300, "height": 200})).unwrap();
+    s.execute("text.create", &json!({"x": 20, "y": 40, "text": "Hello\nWorld", "size": 24})).unwrap();
+    s.execute("text.create", &json!({"x": 150, "y": 100, "text": "Turned"})).unwrap();
+    // The new type is selected.
+    s.execute("object.rotate", &json!({"angle": 30})).unwrap();
+    s.execute("text.create", &json!({"x": 20, "y": 120, "text": "Area type in a frame", "area": {"width": 120, "height": 60}})).unwrap();
+    let path = tmp("type.ai");
+    s.execute("document.save", &json!({"path": path})).unwrap();
+    let before = type_outline(&s.doc().unwrap().doc);
+    assert_eq!(before.len(), 3, "{before:#?}");
+    for opts in [
+        json!({"format": "ai"}),
+        json!({"format": "ai", "compress": false}),
+        json!({"format": "ai", "embedProfiles": false}),
+        json!({"format": "ai", "includeLinked": true}),
+        json!({"format": "ai", "range": "all"}),
+        json!({"format": "ai", "pdfCompatible": false}),
+    ] {
+        let r = s.execute("document.export", &opts).unwrap();
+        assert!(!r["warnings"].to_string().contains("type"), "{opts} {}", r["warnings"]);
+        let copy = load::load_with(&path, &b64(&r), &LoadOptions { native: false, ..Default::default() }).unwrap();
+        assert!(copy.editing_data && !copy.restored, "{opts} {:?}", copy.warnings);
+        assert!(!copy.warnings.iter().any(|w| w.contains("editing data")), "{opts} {:?}", copy.warnings);
+        assert_eq!(type_outline(&copy.doc), before, "{opts}");
+    }
+}
+
 /// A document of two artboards (the art on the first): a rectangle filled with a linear gradient of
 /// three stops placed across part of it, an ellipse filled with an elliptical radial gradient whose
 /// focal point is off its center, a rectangle stroked with a gradient, rectangles filled and
diff --git a/crates/engine/src/cmd/layer.rs b/crates/engine/src/cmd/layer.rs
index 97293f36c..11bf22110 100644
--- a/crates/engine/src/cmd/layer.rs
+++ b/crates/engine/src/cmd/layer.rs
@@ -164,7 +164,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Fit to Artwork Bounds",
             ["Object", "Artboards"],
             None,
-            "{index?: n | indices?: [n…] (0-based; the app passes the selected artboards: the Artboard tool's, else the active one; default: the first)} each artboard fits the art on it that shows (with its strokes and effects; hidden objects and layers, guides and template layers don't count), in one undo step: an object counts for every artboard its bounds overlap, and a group or clipping layer counts as one object; an artboard with no art, or a locked one, stays as it is, and the command fails when every artboard it names is locked or none has art",
+            "{index?: n | indices?: [n…] (0-based; the app passes the selected artboards: the Artboard tool's, else the active one; default: the first)} each artboard fits the art on it that shows (with its strokes and effects; hidden objects and layers, guides and template layers don't count), in one undo step (none when every artboard already fits): an object counts for every artboard its bounds overlap, and a group or clipping layer counts as one object; an artboard with no art, or a locked one, stays as it is, and the command fails when every artboard it names is locked or none has art",
             has_doc,
             artboard_fit_art
         ),
@@ -1151,6 +1151,11 @@ fn artboard_fit_art(s: &mut Session, p: &Value) -> Result<Value> {
     if fits.is_empty() {
         return Err(EngineError::Other("no artwork".into()));
     }
+    // An artboard that already fits its art changes nothing, and no undo step is recorded for it.
+    fits.retain(|(_, was, now)| [now.x0 - was.x0, now.y0 - was.y0, now.x1 - was.x1, now.y1 - was.y1].iter().any(|d| d.abs() > 1e-6));
+    if fits.is_empty() {
+        return ok();
+    }
     s.edit("Artboard Options", |d, _| {
         for &(i, was, now) in &fits {
             let a = d.artboards.get_mut(i).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
diff --git a/crates/engine/src/cmd/library.rs b/crates/engine/src/cmd/library.rs
index c85fe7e37..b4f570582 100644
--- a/crates/engine/src/cmd/library.rs
+++ b/crates/engine/src/cmd/library.rs
@@ -1036,6 +1036,11 @@ fn selected_paint(s: &Session, p: &Value, stroke: bool) -> Result<Paint> {
         None => st.selection.objects.clone(),
     };
     let from_art = ids.iter().filter_map(|id| st.doc.node(*id)).find_map(|n| {
+        // Only a gradient needs the object measured for its placement.
+        let paint = n.proxy_paint_only(stroke, None)?;
+        if !matches!(paint, Paint::Gradient(_)) {
+            return Some(paint.clone());
+        }
         let (paint, to_doc, bounds) = n.proxy_paint(stroke, None)?;
         // Type's characters paint in its own space: a gradient there takes its placement in the
         // document, so that it keeps the direction it shows.
diff --git a/crates/engine/src/cmd/live/commands.rs b/crates/engine/src/cmd/live/commands.rs
index abd88c377..20dd94fb3 100644
--- a/crates/engine/src/cmd/live/commands.rs
+++ b/crates/engine/src/cmd/live/commands.rs
@@ -181,7 +181,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Envelope Info",
             [],
             None,
-            "{} the selected envelope's settings, or with none selected the defaults new envelopes get → {id: n|null, type: warp|mesh|topObject, style, bend, h, v, horizontal, rows, cols, fidelity, antiAlias, preserveShape: clippingMask|transparency, distortAppearance, distortLinearGradients, distortPatternFills, editing}",
+            "{} the selected envelope's settings, or with none selected the defaults new envelopes get → {id: n|null, type: warp|mesh|topObject, style, bend, h, v, horizontal, rows, cols, fidelity, antiAlias, preserveShape: clippingMask|transparency, distortAppearance, distortLinearGradients, distortPatternFills, boundsMargin?: [top, bottom, left, right] (shares of the content's height and width, reported only when not zero: with distortAppearance, how far the box the content maps from reaches past its geometric bounds), editing}",
             has_doc,
             env_info
         ),
@@ -199,7 +199,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Envelope Options…",
             ["Object", "Envelope Distort"],
             None,
-            "{fidelity?: 0..100, antiAlias?: bool, preserveShape?: clippingMask|transparency, distortAppearance?: bool, distortLinearGradients?: bool, distortPatternFills?: bool (the last two work with distortAppearance), style?, bend?, h?, v?, horizontal? (warp envelopes), horizontalDistortion?: as h, verticalDistortion?: as v, orientation?: horizontal|vertical} set the selected envelopes' options; with no envelope selected, the options new envelopes get (see object.envelope.info)",
+            "{fidelity?: 0..100, antiAlias?: bool, preserveShape?: clippingMask|transparency, distortAppearance?: bool, distortLinearGradients?: bool, distortPatternFills?: bool (the last two work with distortAppearance; on an envelope with boundsMargin, distortAppearance also switches the content between the box with the margins and its geometric box), style?, bend?, h?, v?, horizontal? (warp envelopes), horizontalDistortion?: as h, verticalDistortion?: as v, orientation?: horizontal|vertical} set the selected envelopes' options; with no envelope selected, the options new envelopes get (see object.envelope.info)",
             has_doc,
             env_options
         ),
@@ -217,7 +217,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Edit Contents",
             ["Object", "Envelope Distort"],
             None,
-            "{editing?: bool} toggle Edit Contents / Edit Envelope → {editing}",
+            "{editing?: bool} toggle Edit Contents / Edit Envelope; leaving Edit Contents measures an envelope's boundsMargin again when the content's strokes reach differently than when Edit Contents began → {editing}",
             has_envelope,
             env_edit_contents
         ),
diff --git a/crates/engine/src/cmd/live/envelope.rs b/crates/engine/src/cmd/live/envelope.rs
index e247530c1..502ab0a7d 100644
--- a/crates/engine/src/cmd/live/envelope.rs
+++ b/crates/engine/src/cmd/live/envelope.rs
@@ -177,6 +177,9 @@ fn envelope_options_json(mut v: Value, o: &EnvelopeOptions, fidelity: f64) -> Va
     v["distortAppearance"] = json!(o.distort_appearance);
     v["distortLinearGradients"] = json!(o.distort_linear_gradients);
     v["distortPatternFills"] = json!(o.distort_pattern_fills);
+    if o.bounds_margin != [0.0; 4] {
+        v["boundsMargin"] = json!(o.bounds_margin);
+    }
     v
 }
 
@@ -192,6 +195,7 @@ fn options_param(p: &Value, cmd: &str, cur: EnvelopeOptions) -> Result<EnvelopeO
         distort_appearance: switch_or(p, "distortAppearance", cur.distort_appearance, cmd)?,
         distort_linear_gradients: switch_or(p, "distortLinearGradients", cur.distort_linear_gradients, cmd)?,
         distort_pattern_fills: switch_or(p, "distortPatternFills", cur.distort_pattern_fills, cmd)?,
+        bounds_margin: cur.bounds_margin,
     })
 }
 
@@ -369,6 +373,12 @@ pub(super) fn env_expand(s: &mut Session, _: &Value) -> Result<Value> {
     Ok(ids_json(&ids))
 }
 
+/// The margins the strokes of `content` give in the axes of `frame` (none for content without
+/// width or height).
+fn stroke_margin(content: &[Arc<Node>], frame: Affine) -> [f32; 4] {
+    live::envelope_content_boxes(content, frame).and_then(|(stroked, plain)| live::envelope_stroke_margin(stroked, plain)).unwrap_or_default()
+}
+
 pub(super) fn env_edit_contents(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "object.envelope.editContents";
     let envs = selected_of(s, is_envelope);
@@ -377,12 +387,26 @@ pub(super) fn env_edit_contents(s: &mut Session, p: &Value) -> Result<Value> {
     s.edit(if want { "Edit Contents" } else { "Edit Envelope" }, |d, sel| {
         let mut content_ids = vec![];
         for e in &envs {
-            if let Some(n) = d.node_mut(*e)
-                && let NodeKind::Envelope { editing, content, .. } = &mut n.kind
-            {
+            let Some(n) = d.node_mut(*e) else { continue };
+            let start = n.extras().envelope_edit_margin;
+            let mut began = None;
+            if let NodeKind::Envelope { editing, content, options, frame, .. } = &mut n.kind {
+                // Margins stay when the strokes reach as far as when Edit Contents began, whatever
+                // transforms the envelope took before that.
+                if options.bounds_margin != [0.0; 4] {
+                    let now = stroke_margin(content, **frame);
+                    if want {
+                        began = start.filter(|_| *editing).or(Some(now));
+                    } else if *editing && start != Some(now) {
+                        options.bounds_margin = now;
+                    }
+                }
                 *editing = want;
                 content_ids.extend(content.iter().map(|c| c.id));
             }
+            if began != start {
+                n.extras_mut().envelope_edit_margin = began;
+            }
         }
         if want {
             sel.set(content_ids);
diff --git a/crates/engine/src/cmd/panelcmds.rs b/crates/engine/src/cmd/panelcmds.rs
index ea81bf26e..2e3ae4301 100644
--- a/crates/engine/src/cmd/panelcmds.rs
+++ b/crates/engine/src/cmd/panelcmds.rs
@@ -16,7 +16,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Duplicate Artboard",
             ["Window", "Artboards"],
             None,
-            "{index?: n | indices?: [n…] (default: the artboards the Artboard tool has selected), art?: bool (default: the Artboard tool's moveArt option), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} a copy of each artboard, the copies placed together right of the last artboard as they lay, with copies of the art fully inside each when `art` (locked and hidden art only with prefs moveLockedWithArtboard), in one undo step → {index: the first copy's index, indices: the copies' indices, ids: the art's copies}",
+            "{index?: n | indices?: [n…] (default: the artboards the Artboard tool has selected), selectedArtboards?: [n…] (the journal records that default here, for a replay), art?: bool (default: the Artboard tool's moveArt option), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} a copy of each artboard, the copies placed together right of the last artboard as they lay, with copies of the art fully inside each when `art` (locked and hidden art only with prefs moveLockedWithArtboard), in one undo step → {index: the first copy's index, indices: the copies' indices, ids: the art's copies}",
             has_doc,
             artboard_duplicate
         ),
@@ -25,18 +25,42 @@ pub fn specs() -> Vec<CommandSpec> {
             "Copy Artboard",
             [],
             None,
-            "{index? | indices?, art?} (defaults as artboard.duplicate) put the artboards, and the art fully inside each when `art`, on the clipboard: edit.paste adds a copy of each, together right of the last artboard as they lay, edit.pasteInPlace/InFront/InBack where they were, in this or another document (one undo step; edit.pasteOnAllArtboards pastes only the art); edit.copy runs this while the Artboard tool is chosen → {copied: objects}",
+            "{index? | indices?, selectedArtboards?, art?} (as artboard.duplicate) put the artboards, and the art fully inside each when `art`, on the clipboard: edit.paste adds a copy of each, together right of the last artboard as they lay, edit.pasteInPlace/InFront/InBack where they were, in this or another document (one undo step; edit.pasteOnAllArtboards pastes only the art); edit.copy runs this while the Artboard tool is chosen → {copied: objects}",
             has_doc,
-            |s, p| artboard_copy(s, p, false)
+            |s, p| {
+                boards_and_art_noted(s, p, "artboard.copy")?;
+                artboard_copy(s, p, false)
+            }
         ),
         cmd!(
             "artboard.cut",
             "Cut Artboard",
             [],
             None,
-            "{index? | indices?, art?} artboard.copy, then delete the artboards and that art in one undo step (one artboard is always left: the cut fails when it names every artboard, or a locked one; art also on another locked artboard stays, and is left off the clipboard, unless prefs moveLockedWithArtboard); edit.cut runs this while the Artboard tool is chosen → {copied: objects}",
+            "{index? | indices?, selectedArtboards?, art?} artboard.copy, then delete the artboards and that art in one undo step (one artboard is always left: the cut fails when it names every artboard, or a locked one; art also on another locked artboard stays, and is left off the clipboard, unless prefs moveLockedWithArtboard); edit.cut runs this while the Artboard tool is chosen → {copied: objects}",
             has_doc,
-            |s, p| artboard_copy(s, p, true)
+            |s, p| {
+                boards_and_art_noted(s, p, "artboard.cut")?;
+                artboard_copy(s, p, true)
+            }
+        ),
+        cmd!(
+            "artboard.rename",
+            "Rename Artboards",
+            [],
+            None,
+            "{index? | indices?, selectedArtboards?: [n…] (as artboard.duplicate), name} (default: the artboards the Artboard tool has selected, else its active one) rename the artboards in one undo step: one takes `name` (trimmed), and several take it numbered in artboard order, `name-1`, `name-2` and so on; a locked artboard is renamed too. An empty name is an error, and when every artboard already has its new name nothing changes and no undo step is recorded → {renamed: [index…]}",
+            has_doc,
+            artboard_rename
+        ),
+        cmd!(
+            "artboard.switchOrientation",
+            "Switch Orientation",
+            [],
+            None,
+            "{index? | indices?, selectedArtboards?: [n…] (as artboard.duplicate), scaleArt?: bool (default: the Artboard tool's Scale Artwork with Artboard option), patterns?, lockedAndHidden?: bool (as artboard.setProps)} (default: the artboards the Artboard tool has selected, else its active one) each artboard swaps its width and height and keeps its top-left corner, in one undo step; a square artboard and a locked one stay as they are, the call fails with `the artboard is locked` when every artboard it names is locked, and when nothing else changes no undo step is recorded → {switched: [index…]}",
+            has_doc,
+            artboard_switch_orientation
         ),
         cmd!(
             "text.setFormat",
@@ -82,24 +106,120 @@ fn artboard_reorder(s: &mut Session, p: &Value) -> Result<Value> {
 /// of them is in the document) and its Move/Copy Artwork with Artboard option.
 fn boards_and_art(s: &Session, p: &Value, cmd: &str) -> Result<(Vec<usize>, bool)> {
     check_switches(p, &["art"], cmd)?;
+    let indices = named_or_selected(s, p, cmd)?;
+    Ok((indices, bool_or(p, "art", s.tool_options_of("artboard")["moveArt"].as_bool().unwrap_or(true))))
+}
+
+/// [`boards_and_art`], with both values added to the running command's journal entry, so a replay
+/// acts on the same artboards and art whatever the Artboard tool's state is then. `edit.cut` and
+/// `edit.copy` call [`artboard_copy`] without this and take no such params.
+fn boards_and_art_noted(s: &mut Session, p: &Value, cmd: &str) -> Result<(Vec<usize>, bool)> {
+    let (indices, art) = boards_and_art(s, p, cmd)?;
+    note_artboards(s, p, &indices);
+    s.note_journal("art", json!(art));
+    Ok((indices, art))
+}
+
+/// Add `selectedArtboards` to the running command's journal entry when `p` names no artboard, so a
+/// replay acts on the artboards the Artboard tool had selected. An action leaves it out
+/// (`REPLAY_ONLY`) and keeps an `index` or `indices` the call gave.
+fn note_artboards(s: &mut Session, p: &Value, indices: &[usize]) {
+    if p.get("index").is_none() && p.get("indices").is_none() {
+        s.note_journal("selectedArtboards", json!(indices));
+    }
+}
+
+/// The artboards `cmd` acts on: `index` or `indices`, else `selectedArtboards` (a replay of the
+/// journal), else those the Artboard tool has selected, else its active one.
+fn named_or_selected(s: &Session, p: &Value, cmd: &str) -> Result<Vec<usize>> {
     let t = s.tool_options_of("artboard");
     let d = &s.doc()?.doc;
-    let indices = if p.get("index").is_some() || p.get("indices").is_some() {
-        artboard_indices(d, p, cmd)?
-    } else {
-        let mut picked: Vec<u64> = t["selected"]
-            .as_array()
-            .into_iter()
-            .flatten()
-            .filter_map(Value::as_u64)
-            .filter(|i| usize::try_from(*i).is_ok_and(|i| i < d.artboards.len()))
-            .collect();
-        if picked.is_empty() {
-            picked.push(t["active"].as_u64().unwrap_or(0));
-        }
-        artboard_indices(d, &json!({ "indices": picked }), cmd)?
+    if p.get("index").is_some() || p.get("indices").is_some() {
+        return artboard_indices(d, p, cmd);
+    }
+    if let Some(recorded) = p.get("selectedArtboards") {
+        return artboard_indices(d, &json!({ "indices": recorded }), cmd);
+    }
+    let mut picked: Vec<u64> = t["selected"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter_map(Value::as_u64)
+        .filter(|i| usize::try_from(*i).is_ok_and(|i| i < d.artboards.len()))
+        .collect();
+    if picked.is_empty() {
+        picked.push(t["active"].as_u64().unwrap_or(0));
+    }
+    artboard_indices(d, &json!({ "indices": picked }), cmd)
+}
+
+/// Rename Artboards: one artboard takes the name, and several take it numbered in artboard order, in
+/// one undo step. Nothing runs when each already has its new name.
+fn artboard_rename(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "artboard.rename";
+    let name = match p.get("name") {
+        Some(Value::String(n)) if !n.trim().is_empty() => n.trim(),
+        Some(Value::String(_)) => return Err(bad(C, "`name` must not be empty")),
+        _ => return Err(bad(C, "`name` must be a string")),
     };
-    Ok((indices, bool_or(p, "art", t["moveArt"].as_bool().unwrap_or(true))))
+    let indices = named_or_selected(s, p, C)?;
+    note_artboards(s, p, &indices);
+    let d = &s.doc()?.doc;
+    let several = indices.len() > 1;
+    let entries: Vec<(usize, String)> = indices
+        .iter()
+        .enumerate()
+        .map(|(k, i)| (*i, if several { format!("{name}-{}", k + 1) } else { name.to_string() }))
+        .filter(|(i, new)| d.artboards.get(*i).is_some_and(|a| a.name != *new))
+        .collect();
+    let renamed: Vec<usize> = entries.iter().map(|(i, _)| *i).collect();
+    if !entries.is_empty() {
+        let list: Vec<Value> = entries.iter().map(|(i, new)| json!({"index": i, "name": new})).collect();
+        s.execute("artboard.setProps", &json!({ "artboards": list }))?;
+    }
+    Ok(json!({ "renamed": renamed }))
+}
+
+/// Switch Orientation: each artboard that is neither square nor locked swaps its width and height
+/// and keeps its top-left corner, in one undo step. Nothing runs when none of them changes.
+fn artboard_switch_orientation(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "artboard.switchOrientation";
+    // Swapping width and height keeps the area, so `artboard.setProps` scales no strokes or corners.
+    const FROM_PREFS: [&str; 2] = ["patterns", "lockedAndHidden"];
+    check_switches(p, &["scaleArt"], C)?;
+    check_switches(p, &FROM_PREFS, C)?;
+    let indices = named_or_selected(s, p, C)?;
+    note_artboards(s, p, &indices);
+    let d = &s.doc()?.doc;
+    if indices.iter().all(|i| d.artboards.get(*i).is_some_and(|a| a.locked)) {
+        refuse_locked(d, &indices)?;
+    }
+    let turned: Vec<(usize, Rect)> = indices
+        .iter()
+        .filter_map(|i| d.artboards.get(*i).map(|a| (*i, a)))
+        .filter(|(_, a)| !a.locked && (a.rect.width() - a.rect.height()).abs() > 1e-6)
+        .map(|(i, a)| (i, a.rect))
+        .collect();
+    let switched: Vec<usize> = turned.iter().map(|(i, _)| *i).collect();
+    if !turned.is_empty() {
+        let list: Vec<Value> = turned.iter().map(|(i, r)| json!({"index": i, "width": r.height(), "height": r.width()})).collect();
+        let scale = bool_or(p, "scaleArt", s.tool_options_of("artboard")["scaleArt"].as_bool().unwrap_or(false));
+        s.note_journal("scaleArt", json!(scale));
+        let mut set = json!({ "artboards": list, "scaleArt": scale });
+        for key in FROM_PREFS {
+            if let Some(v) = p.get(key) {
+                set[key] = v.clone();
+            }
+        }
+        // What the step takes from the preferences joins this command's journal entry.
+        let (_, noted) = s.execute_step("artboard.setProps", &set)?;
+        for key in FROM_PREFS {
+            if let Some(v) = noted.get(key) {
+                s.note_journal(key, v.clone());
+            }
+        }
+    }
+    Ok(json!({ "switched": switched }))
 }
 
 /// The one artboard `cmd` acts on: `index`, an artboard of `d`, with the errors of
@@ -170,7 +290,7 @@ pub(crate) fn beside_artboards(d: &vectorcraft_doc::Document, rect: Rect) -> Vec
 /// their places relative to each other, together right of the last artboard.
 fn artboard_duplicate(s: &mut Session, p: &Value) -> Result<Value> {
     check_switches(p, &["patterns"], "artboard.duplicate")?;
-    let (indices, art) = boards_and_art(s, p, "artboard.duplicate")?;
+    let (indices, art) = boards_and_art_noted(s, p, "artboard.duplicate")?;
     let arts = artboards_art(s, &indices, art, false)?;
     let all: Vec<NodeId> = arts.iter().flat_map(|(_, a)| a.iter().copied()).collect();
     let sc = Scaling { patterns: super::object::transform_patterns(s, p, &all)?, ..Scaling::default() };
diff --git a/crates/engine/src/cmd/perspgrid.rs b/crates/engine/src/cmd/perspgrid.rs
index 5b622f430..822d88aad 100644
--- a/crates/engine/src/cmd/perspgrid.rs
+++ b/crates/engine/src/cmd/perspgrid.rs
@@ -29,7 +29,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Perspective Grid",
             [],
             None,
-            "{} → {grid: the model (as perspective.grid.set takes it), define: the Define Grid fields (as perspective.grid.define takes them), station: {x, y, distance} (the viewer: centre of vision on the horizon, distance to the picture plane, pt), defined: false while the document uses the default grid}",
+            "{} → {grid: the model (as perspective.grid.set takes it), define: the Define Grid fields (as perspective.grid.define takes them; name is the preset only while the grid still has its fields, else \"\" for custom: dragging the horizon, a vanishing point or the station point makes it custom, moving a plane does not), station: {x, y, distance} (the viewer: centre of vision on the horizon, distance to the picture plane, pt), defined: false while the document uses the default grid}",
             has_doc,
             grid_get
         ),
@@ -222,7 +222,13 @@ pub(crate) fn grid_info(doc: &vectorcraft_doc::Document, g: &PerspectiveGrid) ->
 
 fn grid_get(s: &mut Session, _: &Value) -> Result<Value> {
     let doc = &s.doc()?.doc;
-    Ok(grid_info(doc, &grid_of(doc)))
+    let g = grid_of(doc);
+    let mut info = grid_info(doc, &g);
+    // The grid is its preset only while it has the preset's fields: a station point or vanishing
+    // point dragged since makes it a custom grid.
+    let def = g.definition();
+    info["define"]["name"] = json!(s.preset_named(&def, &[&def.name]));
+    Ok(info)
 }
 
 fn grid_define(s: &mut Session, p: &Value) -> Result<Value> {
diff --git a/crates/engine/src/cmd/place.rs b/crates/engine/src/cmd/place.rs
index cc9d9def0..d78ca2782 100644
--- a/crates/engine/src/cmd/place.rs
+++ b/crates/engine/src/cmd/place.rs
@@ -66,7 +66,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Place…",
             ["File"],
             Some("Cmd+Shift+P"),
-            "{path | name | dataBase64 (a file's path, or its name with its bytes), link?: true (a raster image keeps its file's path; a VectorCraft document at path becomes one locked placed document showing artboard `page`, linked to the file and read again when it changes (links.update; saving it in this app updates it at once), drawn as vectors in every output; so does a PDF/.ai page at path, showing its `crop` box, unless password or textAs: \"outlines\" is given; false: an editable copy of its art, as from dataBase64; other files are embedded), text?: {characterSet?: \"unicode\" (UTF-8, or UTF-16 with a byte-order mark; other bytes as the platform's 8-bit set) | \"ansi\" (the platform's 8-bit set), platform?: \"windows\" (Windows-1252) | \"mac\" (Mac Roman), removeLineReturns?: false (each block of lines becomes one paragraph; blank lines end paragraphs), removeParagraphReturns?: false (drop blank lines), replaceSpaces?: n (runs of n ≥ 2 spaces become a tab)} (a .txt file, placed as area type filling rect, the replaced object's bounds, or else the artboard less a 36 pt margin), template?: false (onto a new locked template layer below the current layer), replace?: false (swap the one selected object, keeping its stacking place and transform; no at/rect), at?: [x, y] centre (default: the first artboard's centre), rect?: [x, y, width, height] fit inside; aspect kept (wins over at), page?: 1 (PDF/.ai page, or a native document's artboard), crop?: \"crop\" (clipped to that page or artboard, default; an SVG, only when given: framed and clipped by its viewBox, else by its art's bounds) | \"bounding\" (the bounds of the art that shows, with its strokes and effects, as an export measures them: hidden objects and guides left out) | \"art\" | \"trim\" | \"bleed\" | \"media\" (a PDF page's boxes), password? (an encrypted PDF), dxf?: {…the DXF options of document.open} (a .dxf drawing: fit fills the artboard under at, else the first; fitted or uncentred art lands with its drawing's artboard on that artboard, else it is centred on at)} → {ids, name, format, linked, width, height, warnings}. Raster images come in at 100% of their physical size (the file's ppi, else 72); SVG, DXF, PDF/.ai, EMF/WMF (clipped to the picture's frame), EPS (clipped to its bounding box; as document.open reads it), a .ai saved without PDF compatibility (from its editing data, as document.open reads it: the art of the layers that show on artboard `page`, clipped to that artboard unless crop is \"bounding\") and native documents as one group, with the images, symbols, patterns and swatches they use. One undo step; selects what it placed (unless on a template layer); never touches the clipboard. A PNG, JPEG, GIF or WebP image whose pixels can't be read (a file cut short) is an error, and nothing is placed",
+            "{path | name | dataBase64 (a file's path, or its name with its bytes), link?: true (a raster image keeps its file's path; a VectorCraft document at path becomes one locked placed document showing artboard `page`, linked to the file and read again when it changes (links.update; saving it in this app updates it at once), drawn as vectors in every output; so does a PDF/.ai page at path, showing its `crop` box, unless password or textAs: \"outlines\" is given; false: an editable copy of its art, as from dataBase64; other files are embedded), text?: {characterSet?: \"unicode\" (UTF-8, or UTF-16 with a byte-order mark; other bytes as the platform's 8-bit set) | \"ansi\" (the platform's 8-bit set), platform?: \"windows\" (Windows-1252) | \"mac\" (Mac Roman), removeLineReturns?: false (each block of lines becomes one paragraph; blank lines end paragraphs), removeParagraphReturns?: false (drop blank lines), replaceSpaces?: n (runs of n ≥ 2 spaces become a tab)} (a .txt file, placed as area type filling rect, the replaced object's bounds, or else the artboard less a 36 pt margin), template?: false (onto a new locked template layer below the current layer), replace?: false (swap the one selected object, keeping its stacking place and transform; no at/rect), at?: [x, y] centre (default: the first artboard's centre), rect?: [x, y, width, height] fit inside; aspect kept (wins over at), page?: 1 (PDF/.ai page, or a native document's artboard), crop?: \"crop\" (clipped to that page or artboard, default; an SVG, only when given: framed and clipped by its viewBox, else by its art's bounds) | \"bounding\" (the bounds of the art that shows, with its strokes and effects, as an export measures them: hidden objects and guides left out) | \"art\" | \"trim\" | \"bleed\" | \"media\" (a PDF page's boxes), password? (an encrypted PDF), dxf?: {…the DXF options of document.open} (a .dxf drawing: fit fills the artboard under at, else the first; fitted or uncentred art lands with its drawing's artboard on that artboard, else it is centred on at)} → {ids, name, format, linked, width, height, warnings}. Raster images come in at 100% of their physical size (the file's ppi, else 72); SVG, DXF, PDF/.ai, EMF/WMF (clipped to the picture's frame), EPS (clipped to its bounding box; as document.open reads it), a .ai saved without PDF compatibility (from its editing data, as document.open reads it: the art of the layers that show on artboard `page`, clipped to that artboard unless crop is \"bounding\") and native documents as one group, with the images, symbols, patterns, swatches and brushes they use. One undo step; selects what it placed (unless on a template layer); never touches the clipboard. A PNG, JPEG, GIF or WebP image whose pixels can't be read (a file cut short) is an error, and nothing is placed",
             has_doc,
             place
         ),
diff --git a/crates/engine/src/cmd/place/adopt.rs b/crates/engine/src/cmd/place/adopt.rs
index 3493dbd0e..fb0622632 100644
--- a/crates/engine/src/cmd/place/adopt.rs
+++ b/crates/engine/src/cmd/place/adopt.rs
@@ -1,6 +1,6 @@
-//! Resources placed art brings along: the images, symbols, pattern swatches and colour swatches it
-//! uses (also through symbol and pattern art and through tint swatches) join the document. A name
-//! the document already uses for something different gets a free variant (`Star 2`,
+//! Resources placed art brings along: the images, symbols, pattern swatches, colour swatches and
+//! brushes it uses (also through symbol, pattern and brush art and through tint swatches) join the
+//! document. A name the document already uses for something different gets a free variant (`Star 2`,
 //! `pdf-image-1 2`…) and the art's references follow; a colour linked to a swatch the document
 //! defines differently keeps its colour, unlinked. Text styles are left as they are: the art carries
 //! its own formatting.
@@ -8,6 +8,7 @@
 use std::collections::BTreeMap;
 use std::sync::Arc;
 
+use vectorcraft_brush::{Brush, BrushKind};
 use vectorcraft_color::Paint;
 use vectorcraft_doc::{AppearanceItem, Document, Node, NodeKind};
 
@@ -31,6 +32,7 @@ enum Ref<'a> {
     Image(&'a mut String),
     Symbol(&'a mut String),
     Pattern(&'a mut String),
+    Brush(&'a mut String),
     /// A colour's (or gradient's) swatch link; renaming it to `None` unlinks it.
     Swatch(&'a mut Option<String>),
 }
@@ -56,7 +58,12 @@ fn refs(n: &mut Node, f: &mut impl FnMut(Ref)) {
         for it in &mut n.appearance.items {
             match it {
                 AppearanceItem::Fill(fl) => paint_refs(&mut fl.paint, f),
-                AppearanceItem::Stroke(st) => paint_refs(&mut st.paint, f),
+                AppearanceItem::Stroke(st) => {
+                    paint_refs(&mut st.paint, f);
+                    if let Some(brush) = &mut st.brush {
+                        f(Ref::Brush(brush));
+                    }
+                }
             }
         }
         match &mut n.kind {
@@ -80,6 +87,7 @@ struct Used {
     images: Vec<String>,
     symbols: Vec<String>,
     patterns: Vec<String>,
+    brushes: Vec<String>,
     swatches: Vec<String>,
 }
 
@@ -89,6 +97,7 @@ impl Used {
             Ref::Image(k) => (&mut self.images, &*k),
             Ref::Symbol(k) => (&mut self.symbols, &*k),
             Ref::Pattern(k) => (&mut self.patterns, &*k),
+            Ref::Brush(k) => (&mut self.brushes, &*k),
             Ref::Swatch(Some(k)) => (&mut self.swatches, &*k),
             Ref::Swatch(None) => return,
         };
@@ -116,7 +125,9 @@ fn names<T: PartialEq>(
         let entry = match existing(name) {
             None => (Some(name.clone()), true),
             Some(e) if e == d => (Some(name.clone()), false),
-            Some(_) => (Some(unique_name(name, |c| taken(c) || out.values().any(|(n, _)| n.as_deref() == Some(c)))), true),
+            Some(_) => {
+                (Some(unique_name(name, |c| taken(c) || used.iter().any(|u| u == c) || out.values().any(|(n, _)| n.as_deref() == Some(c)))), true)
+            }
         };
         out.insert(name.clone(), entry);
     }
@@ -128,6 +139,18 @@ fn copies(m: &Renames) -> Vec<(&str, &str)> {
     m.iter().filter(|(_, (_, copy))| *copy).filter_map(|(old, (new, _))| Some((old.as_str(), new.as_deref()?))).collect()
 }
 
+/// The art a brush holds.
+fn brush_art(b: &mut Brush) -> Vec<&mut Node> {
+    match &mut b.kind {
+        BrushKind::Scatter(s) => vec![&mut s.art],
+        BrushKind::Art(a) => vec![&mut a.art],
+        BrushKind::Pattern(p) => {
+            [Some(&mut p.side), p.outer_corner.as_mut(), p.inner_corner.as_mut(), p.start.as_mut(), p.end.as_mut()].into_iter().flatten().collect()
+        }
+        BrushKind::Calligraphic(_) | BrushKind::Bristle(_) => vec![],
+    }
+}
+
 /// Bring the resources `nodes` (art from `src`) use into `dst`, renaming on conflict, and point
 /// `nodes` at the names they got.
 pub(crate) fn adopt(dst: &mut Document, src: &Document, nodes: &mut [Node]) {
@@ -135,9 +158,10 @@ pub(crate) fn adopt(dst: &mut Document, src: &Document, nodes: &mut [Node]) {
     for n in nodes.iter_mut() {
         refs(n, &mut |r| used.note(r));
     }
-    // Symbol and pattern art and tint swatches can use more resources (the lists grow while they
-    // are walked).
-    let (mut si, mut pi, mut wi) = (0, 0, 0);
+    let src_brushes = vectorcraft_brush::library(src);
+    // Symbol, pattern and brush art and tint swatches can use more resources (the lists grow while
+    // they are walked).
+    let (mut si, mut pi, mut wi, mut bi) = (0, 0, 0, 0);
     loop {
         let mut art: Vec<Node> = vec![];
         if let Some(name) = used.symbols.get(si) {
@@ -151,6 +175,11 @@ pub(crate) fn adopt(dst: &mut Document, src: &Document, nodes: &mut [Node]) {
             if let Some(mut paint) = src.swatch(name).map(|w| w.paint.clone()) {
                 paint_refs(&mut paint, &mut |r| used.note(r));
             }
+        } else if let Some(name) = used.brushes.get(bi) {
+            bi += 1;
+            if let Some(mut b) = src_brushes.iter().find(|b| b.name == *name).cloned() {
+                art.extend(brush_art(&mut b).into_iter().map(|a| a.clone()));
+            }
         } else {
             break;
         }
@@ -182,12 +211,38 @@ pub(crate) fn adopt(dst: &mut Document, src: &Document, nodes: &mut [Node]) {
             Some((n.clone(), entry))
         })
         .collect();
+    // A brush whose art uses a resource that moves to another name isn't the document's brush of
+    // that name, whatever it looks like.
+    let moved = |map: &Renames, k: &str| map.get(k).is_some_and(|(new, _)| new.as_deref() != Some(k));
+    let moves_art = |b: &Brush| {
+        let (mut b, mut any) = (b.clone(), false);
+        for a in brush_art(&mut b) {
+            refs(a, &mut |r| {
+                any |= match r {
+                    Ref::Image(k) => moved(&images, k),
+                    Ref::Symbol(k) => moved(&symbols, k),
+                    Ref::Pattern(k) => moved(&patterns, k),
+                    Ref::Swatch(link) => link.as_deref().is_some_and(|k| moved(&swatches, k)),
+                    Ref::Brush(_) => false,
+                }
+            });
+        }
+        any
+    };
+    let mut dst_brushes = vectorcraft_brush::library(dst);
+    let brushes = names(
+        &used.brushes,
+        |n| src_brushes.iter().find(|b| b.name == n).map(|b| (b, moves_art(b))),
+        |n| dst_brushes.iter().find(|b| b.name == n).map(|b| (b, false)),
+        |c| dst_brushes.iter().any(|b| b.name == c),
+    );
 
     let mut rename = |r: Ref| {
         let (map, k) = match r {
             Ref::Image(k) => (&images, k),
             Ref::Symbol(k) => (&symbols, k),
             Ref::Pattern(k) => (&patterns, k),
+            Ref::Brush(k) => (&brushes, k),
             Ref::Swatch(link) => {
                 if let Some((new, _)) = link.as_deref().and_then(|k| swatches.get(k)) {
                     *link = new.clone();
@@ -223,6 +278,19 @@ pub(crate) fn adopt(dst: &mut Document, src: &Document, nodes: &mut [Node]) {
             dst.patterns.push(def);
         }
     }
+    let new_brushes = copies(&brushes);
+    if !new_brushes.is_empty() {
+        for (old, new) in new_brushes {
+            if let Some(mut def) = src_brushes.iter().find(|b| b.name == old).cloned() {
+                def.name = new.to_string();
+                for a in brush_art(&mut def) {
+                    refs(a, &mut rename);
+                }
+                dst_brushes.push(def);
+            }
+        }
+        vectorcraft_brush::store(dst, &dst_brushes);
+    }
     for (old, _) in copies(&swatches) {
         if let Some(mut w) = src.swatch(old).cloned() {
             paint_refs(&mut w.paint, &mut rename);
diff --git a/crates/engine/src/cmd/prefscmds.rs b/crates/engine/src/cmd/prefscmds.rs
index 029f3608f..94a922400 100644
--- a/crates/engine/src/cmd/prefscmds.rs
+++ b/crates/engine/src/cmd/prefscmds.rs
@@ -277,6 +277,7 @@ pub const PREF_SPECS: &[PrefSpec] = &[
             ("pl", "Polish"),
             ("cs", "Czech"),
             ("ru", "Russian"),
+            ("bg", "Bulgarian"),
             ("sr-Cyrl", "Serbian: Cyrillic"),
             ("sr-Latn", "Serbian: Latin"),
             ("hr", "Croatian"),
@@ -293,6 +294,8 @@ pub const PREF_SPECS: &[PrefSpec] = &[
             ("kn", "Kannada"),
             ("ml", "Malayalam"),
             ("or", "Odia"),
+            ("as", "Assamese"),
+            ("sa", "Sanskrit"),
             ("ur", "Urdu")
         ])
     ),
@@ -517,6 +520,50 @@ fn in_range(key: &str, x: Option<f64>, min: f64, max: f64) -> std::result::Resul
     }
 }
 
+/// A check of a folder path: `Err` says why the folder can't be the preference's value.
+pub type FolderCheck = fn(&str) -> std::result::Result<(), String>;
+
+/// The check a folder preference with a Choose… button gives a folder before it becomes the
+/// preference's value: Data Recovery keeps its copies in its folder, and the Additional Plug-ins
+/// Folder is read for plug-ins. `None` for any other preference.
+pub fn folder_check(key: &str) -> Option<FolderCheck> {
+    match key {
+        "recoveryFolder" => Some(writable_folder),
+        "pluginsFolder" => Some(plugins_folder),
+        _ => None,
+    }
+}
+
+/// `Ok` when `path` is a folder whose contents can be listed, as the plug-ins in it are found by
+/// listing it. A folder outside the automation roots in force is refused before it is looked at.
+fn plugins_folder(path: &str) -> std::result::Result<(), String> {
+    crate::file_access::check_read(path)?;
+    let dir = std::path::Path::new(path);
+    if !dir.is_dir() {
+        return Err(format!("{path} is not a folder"));
+    }
+    std::fs::read_dir(dir).map(drop).map_err(|e| format!("Plug-ins can't be loaded from {path}: {e}"))
+}
+
+/// `Ok` when `path` is a folder that can be listed and that a folder can be created in, as the
+/// recovery store lists its folders there and makes its own: the folder is listed, and an empty
+/// folder is made there and removed. A folder that can't be removed again is an error too. A
+/// folder outside the automation roots in force is refused before it is looked at.
+fn writable_folder(path: &str) -> std::result::Result<(), String> {
+    crate::file_access::check_write(path)?;
+    crate::file_access::check_read(path)?;
+    let dir = std::path::Path::new(path);
+    if !dir.is_dir() {
+        return Err(format!("{path} is not a folder"));
+    }
+    let refused = |e: std::io::Error| format!("Data Recovery can't keep copies in {path}: {e}");
+    std::fs::read_dir(dir).map_err(refused)?;
+    let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |t| t.as_nanos());
+    let check = dir.join(format!(".vectorcraft-write-check-{}-{nanos}", std::process::id()));
+    std::fs::create_dir(&check).map_err(refused)?;
+    std::fs::remove_dir(&check).map_err(refused)
+}
+
 impl Prefs {
     pub fn to_json(&self) -> Value {
         serde_json::to_value(self).unwrap_or(Value::Null)
@@ -565,6 +612,25 @@ impl Prefs {
         refused
     }
 
+    /// The [`folder_check`] of each folder preference in `values`. An empty value (the default
+    /// folder) and a folder the preference already holds are not checked. The web has no folders to
+    /// check.
+    fn check_folders(&self, values: &Map<String, Value>) -> std::result::Result<(), String> {
+        if cfg!(target_arch = "wasm32") {
+            return Ok(());
+        }
+        let saved = self.to_json();
+        for (key, v) in values {
+            let (Some(check), Some(path)) = (folder_check(key), v.as_str()) else { continue };
+            let path = path.trim();
+            if path.is_empty() || saved[key.as_str()].as_str().is_some_and(|s| s.trim() == path) {
+                continue;
+            }
+            check(path)?;
+        }
+        Ok(())
+    }
+
     /// Values of one category (`None` = all) reset to defaults.
     pub fn reset(&mut self, category: Option<&str>) {
         let d = Prefs::default().to_json();
@@ -666,7 +732,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Set Preference",
             [],
             None,
-            "{key, value} or {values: {key: value, …}} set preferences (validated; see prefs.list; lengths in pt or strings with a unit; unitsGeneral also sets the active document's units, one undo step; the eyedropper group takes a partial object, as eyedropper.setOptions)",
+            "{key, value} or {values: {key: value, …}} set preferences (validated; see prefs.list; lengths in pt or strings with a unit; unitsGeneral also sets the active document's units, one undo step; the eyedropper group takes a partial object, as eyedropper.setOptions; a new recoveryFolder must be a folder that can be listed and written in, and a new pluginsFolder a folder that can be listed: otherwise an error, and nothing changes; an empty value is not checked)",
             always,
             set
         ),
@@ -697,6 +763,7 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
     if let Some(e) = s.prefs.keep_folders(&mut next).into_iter().next() {
         return Err(EngineError::Other(e));
     }
+    s.prefs.check_folders(&values).map_err(EngineError::Other)?;
     s.apply_prefs(next);
     // Units ▸ General is also the open document's units (as Document Setup sets them).
     if values.contains_key("unitsGeneral") && s.active().is_some() {
diff --git a/crates/engine/src/cmd/swatchlib.rs b/crates/engine/src/cmd/swatchlib.rs
index 9ecec6c67..eaa5b8c54 100644
--- a/crates/engine/src/cmd/swatchlib.rs
+++ b/crates/engine/src/cmd/swatchlib.rs
@@ -6,7 +6,7 @@
 //! pattern) into the document; `swatch.library.save` writes the document's ([`palette_io`]).
 //! `swatch.library.copyToUser` copies a loaded library into the user library folder.
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 use serde_json::{Value, json};
@@ -104,6 +104,19 @@ pub struct Libraries<L = SwatchLibrary> {
     /// Loaded libraries copied into the user library folder ([`Libraries::copy_to_user`]): the
     /// loaded id and the User Defined id [`Libraries::get`] finds for it.
     copied: Vec<(String, String)>,
+    /// The name each User Defined file was saved under ([`Libraries::write`]), lower case id first,
+    /// with a hash of the bytes written. A format that keeps no title (`.ase`) reads its name from
+    /// the file name instead. [`Libraries::rescan`] drops an entry whose file no longer holds those
+    /// bytes, and keeps one whose file is missing so a file put back can be checked.
+    saved_as: HashMap<String, SavedAs>,
+}
+
+/// A User Defined file this session wrote: the library's name, and [`vectorcraft_doc::links::hash_bytes`]
+/// of what was written, so a file replaced since then is no longer that library's.
+#[derive(Clone, Debug)]
+struct SavedAs {
+    name: String,
+    hash: String,
 }
 
 #[derive(Clone, Debug)]
@@ -152,20 +165,30 @@ impl<L: LibraryFile> Libraries<L> {
     /// Set the user library folder and list its libraries.
     pub fn set_user_dir(&mut self, dir: Option<String>) {
         self.user_dir = dir;
+        self.saved_as.clear();
         self.rescan();
     }
 
     /// Re-read the library files of the user library folder (unreadable ones are skipped). The
     /// folder is the app's own: automation roots don't apply to it ([`crate::file_access`]). Each
     /// file is read inside [`crate::guard::catch_panic`], and a file whose reading panics is
-    /// skipped too.
+    /// skipped too. A file this session saved, whose bytes are no longer the ones written, is
+    /// forgotten ([`Libraries::write`]); a missing file is left remembered until it is back.
     pub fn rescan(&mut self) {
         self.extra.retain(|e| e.info.category != "user");
         let Some(dir) = self.user_dir.clone() else { return };
         for path in library_files(&dir, L::EXTS) {
             let file = file_name(&path);
-            let read = || crate::file_access::unconfined(|| read_file(&path)).ok().and_then(|b| L::read(&b, stem(&file)).ok());
-            let Some(lib) = crate::guard::catch_panic(read).ok().flatten() else { continue };
+            let read = || crate::file_access::unconfined(|| read_file(&path)).ok();
+            let Some(bytes) = crate::guard::catch_panic(read).ok().flatten() else { continue };
+            let id = format!("user/{file}").to_lowercase();
+            // Compared before parsing, so a file that no longer reads as a library is forgotten too.
+            let hash = vectorcraft_doc::links::hash_bytes(&bytes);
+            if self.saved_as.get(&id).is_some_and(|saved| saved.hash != hash) {
+                self.saved_as.remove(&id);
+            }
+            let parsed = || L::read(&bytes, stem(&file)).ok();
+            let Some(lib) = crate::guard::catch_panic(parsed).ok().flatten() else { continue };
             let info = LibraryInfo { id: format!("user/{file}"), name: library_tab_name(&file, lib.name()), category: "user" };
             self.extra.push(Extra { info, path: Some(path), lib: Arc::new(lib) });
         }
@@ -214,17 +237,36 @@ impl<L: LibraryFile> Libraries<L> {
             let mut file = library_file_name(name, ext);
             // `COM¹` is saved as `COM¹-`, which can be another library's own name, and a library put
             // under a numbered name holds a file another name can ask for: such a file is kept.
+            // `saved_as` is that memory for this run, and only while the file still holds what was
+            // written. A file that could not be read has no name to trust: one a device name could
+            // make is kept too. Any other unreadable file is replaced, as it was before.
             self.rescan();
             let device = crate::file_access::is_device_name;
             let id = format!("user/{file}").to_lowercase();
             let fallback = |other: &str| library_file_name(other, ext).to_lowercase() != file.to_lowercase();
-            if self
-                .extra
-                .iter()
-                .any(|e| e.info.id.to_lowercase() == id && e.lib.name() != name && (device(name) || device(e.lib.name()) || fallback(e.lib.name())))
-            {
+            // A format with no title reads its name from the file name, so a file a device name could
+            // have made has no known owner until it is saved here.
+            let untitled = L::read(bytes, "\0").is_ok_and(|lib| lib.name() == "\0");
+            let owner = |e: &Extra<L>| match self.saved_as.get(&e.info.id.to_lowercase()) {
+                Some(saved) => Some(saved.name.clone()),
+                None if untitled && device_file_name(e.lib.name()) => None,
+                None => Some(e.lib.name().to_string()),
+            };
+            let file_key = file.to_lowercase();
+            let on_disk = library_files(&dir, L::EXTS).iter().any(|p| file_name(p).to_lowercase() == file_key);
+            let listed = self.extra.iter().any(|e| e.info.category == "user" && e.info.id.to_lowercase() == id);
+            let unread = on_disk && !listed && (device(name) || device_file_name(stem(&file)));
+            let held = unread
+                || self.extra.iter().any(|e| {
+                    e.info.id.to_lowercase() == id
+                        && owner(e).is_none_or(|other| other != name && (device(name) || device(&other) || fallback(&other)))
+                });
+            if held {
                 // Saved again, it goes back to the file it was given the first time.
-                let own = self.extra.iter().find(|e| e.info.category == "user" && e.lib.name() == name && extension(&e.info.id) == extension(&file));
+                let own = self
+                    .extra
+                    .iter()
+                    .find(|e| e.info.category == "user" && owner(e).as_deref() == Some(name) && extension(&e.info.id) == extension(&file));
                 file = match own.and_then(|e| e.info.id.strip_prefix("user/")) {
                     Some(own) => own.to_string(),
                     None => {
@@ -236,6 +278,8 @@ impl<L: LibraryFile> Libraries<L> {
             let path = std::path::Path::new(&dir).join(&file).to_string_lossy().to_string();
             // The app's own folder, under a name made safe: no root applies.
             crate::file_access::unconfined(|| create_dir(&dir).and_then(|()| write_file(&path, bytes)))?;
+            self.saved_as
+                .insert(format!("user/{file}").to_lowercase(), SavedAs { name: name.to_string(), hash: vectorcraft_doc::links::hash_bytes(bytes) });
             self.rescan();
             out["path"] = json!(path);
             out["library"] = json!(format!("user/{file}"));
@@ -373,6 +417,13 @@ pub fn library_file_name(name: &str, ext: &str) -> String {
     }
 }
 
+/// Is `stem` a file name [`library_file_name`] gives a device name (`COM¹-`, `COM¹-.x`), or one of
+/// those with the number [`free_name`] adds (`COM¹- 2`)?
+fn device_file_name(stem: &str) -> bool {
+    let base = stem.rsplit_once(' ').filter(|(_, n)| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit())).map_or(stem, |(base, _)| base);
+    base.split('.').next().and_then(|first| first.strip_suffix('-')).is_some_and(crate::file_access::is_device_name)
+}
+
 /// The library files with extensions `exts` in folder `dir`, sorted by name.
 #[cfg(not(target_arch = "wasm32"))]
 fn library_files(dir: &str, exts: &[&str]) -> Vec<String> {
diff --git a/crates/engine/src/cmd/typemenu.rs b/crates/engine/src/cmd/typemenu.rs
index 6df2ee6ce..f5d36a7b2 100644
--- a/crates/engine/src/cmd/typemenu.rs
+++ b/crates/engine/src/cmd/typemenu.rs
@@ -3,7 +3,7 @@
 //! commands of the Edit menu (Find and Replace, Find Next, Paste without Formatting).
 
 use serde_json::{Value, json};
-use vectorcraft_doc::{CharStyle, Document, Justify, NodeId, NodeKind, Quotes, TextKind, TextObject, TextRun};
+use vectorcraft_doc::{CharStyle, Document, Justify, LockedArtboards, Node, NodeId, NodeKind, Quotes, TextKind, TextObject, TextRun};
 use vectorcraft_geom::{Affine, Rect, shapes};
 
 use super::typecmd::refresh_bounds;
@@ -72,7 +72,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Insert Character",
             ["Type"],
             None,
-            "{char: \"bullet\"|\"copyright\"|\"ellipsis\"|\"paragraph\"|\"registered\"|\"section\"|\"trademark\"|\"emDash\"|\"enDash\"|\"discretionaryHyphen\"|\"nonBreakingHyphen\"|\"doubleLeftQuote\"|\"doubleRightQuote\"|\"singleLeftQuote\"|\"singleRightQuote\"|\"emSpace\"|\"enSpace\"|\"hairSpace\"|\"sixthSpace\"|\"thinSpace\"|\"nonBreakingSpace\"|\"figureSpace\"|\"punctuationSpace\"|\"thirdSpace\"|\"quarterSpace\"|\"tab\"|\"forcedLineBreak\"|\"paragraphReturn\" | text: string, ids?|id?: object ids (default: the selection)} append to the selected text objects",
+            "{char: \"bullet\"|\"copyright\"|\"ellipsis\"|\"paragraph\"|\"registered\"|\"section\"|\"trademark\"|\"emDash\"|\"enDash\"|\"discretionaryHyphen\"|\"nonBreakingHyphen\"|\"doubleLeftQuote\"|\"doubleRightQuote\"|\"singleLeftQuote\"|\"singleRightQuote\"|\"emSpace\"|\"enSpace\"|\"hairSpace\"|\"sixthSpace\"|\"thinSpace\"|\"nonBreakingSpace\"|\"figureSpace\"|\"punctuationSpace\"|\"thirdSpace\"|\"quarterSpace\"|\"tab\"|\"forcedLineBreak\"|\"paragraphReturn\" | text: string | code: Windows Alt+0 code (0–255 in Windows-1252, a Unicode code point above: 176 → °, 151 → —) | unicode: hex code point (\"00B0\" or \"U+00B0\"), ids?|id?: object ids (default: the selection)} append to the selected text objects",
             has_selection,
             insert_char
         ),
@@ -580,12 +580,42 @@ pub(crate) fn special_char(name: &str) -> Option<&'static str> {
     })
 }
 
+/// The character a Windows Alt + keypad code with a leading 0 types (`Alt+0176` → `°`), as
+/// `type.insert {code}` takes it: 128–159 in the Windows-1252 code page (`0151` → `—`), the
+/// Unicode code point otherwise (`8364` → `€`). Control characters type nothing.
+/// <https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1252.TXT>
+pub(crate) fn alt_code_char(code: u64) -> Option<char> {
+    const CP1252: [u16; 32] = [
+        0x20AC, 0, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0, 0x017D, 0, 0, 0x2018, 0x2019, 0x201C,
+        0x201D, 0x2022, 0x2013, 0x2014, 0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0, 0x017E, 0x0178,
+    ];
+    let cp = match code {
+        128..=159 => u32::from(*CP1252.get(usize::try_from(code - 128).ok()?)?),
+        _ => u32::try_from(code).ok()?,
+    };
+    char::from_u32(cp).filter(|c| !c.is_control() || *c == '\t')
+}
+
+/// The character `type.insert {unicode}` names: its code point in hex, as `00B0`, `U+00B0` or
+/// `0x00B0`.
+fn unicode_char(u: &str) -> Option<char> {
+    let u = u.trim();
+    let hex = u.strip_prefix("U+").or_else(|| u.strip_prefix("u+")).or_else(|| u.strip_prefix("0x")).unwrap_or(u);
+    char::from_u32(u32::from_str_radix(hex, 16).ok()?).filter(|c| !c.is_control() || *c == '\t')
+}
+
 fn insert_char(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "type.insert";
     let text = match (str_param(p, "char"), str_param(p, "text")) {
         (Some(c), _) => special_char(c).ok_or_else(|| bad(C, format!("unknown character `{c}`")))?.to_string(),
         (None, Some(t)) => t.to_string(),
-        _ => return Err(bad(C, "give `char` or `text`")),
+        _ => match (p.get("code"), str_param(p, "unicode")) {
+            (Some(code), _) => alt_code_char(code.as_u64().ok_or_else(|| bad(C, "`code` must be a whole number"))?)
+                .ok_or_else(|| bad(C, format!("no character has code {code}")))?
+                .to_string(),
+            (None, Some(u)) => unicode_char(u).ok_or_else(|| bad(C, format!("`{u}` is no Unicode character")))?.to_string(),
+            _ => return Err(bad(C, "give `char`, `text`, `code` or `unicode`")),
+        },
     };
     let ids = texts(s, p, C)?;
     // When `text` is empty and every object ends with a run of text, the document and its undo
@@ -625,6 +655,22 @@ fn is_word(c: char) -> bool {
 
 /// Byte ranges of `needle` in `hay`.
 pub(crate) fn find_all(hay: &str, needle: &str, match_case: bool, whole_word: bool) -> Vec<(usize, usize)> {
+    find_all_between(hay, needle, match_case, whole_word, None, None)
+}
+
+/// [`find_all`] in run `i` of `runs`: a whole word looks past the run's ends at the characters
+/// next to it, so a change of style inside a word is not a word boundary (#5901). Matches stay
+/// inside the run.
+fn find_in_run(runs: &[TextRun], i: usize, needle: &str, match_case: bool, whole_word: bool) -> Vec<(usize, usize)> {
+    let Some(run) = runs.get(i) else { return vec![] };
+    let before = runs.get(..i).and_then(|r| r.iter().rev().find_map(|r| r.text.chars().next_back()));
+    let after = runs.get(i + 1..).and_then(|r| r.iter().find_map(|r| r.text.chars().next()));
+    find_all_between(&run.text, needle, match_case, whole_word, before, after)
+}
+
+/// [`find_all`], with `before` and `after` the characters on either side of `hay` (none at the
+/// text's ends), which a whole word must not touch either.
+fn find_all_between(hay: &str, needle: &str, match_case: bool, whole_word: bool, before: Option<char>, after: Option<char>) -> Vec<(usize, usize)> {
     let nc: Vec<char> = needle.chars().collect();
     if nc.is_empty() {
         return vec![];
@@ -635,9 +681,9 @@ pub(crate) fn find_all(hay: &str, needle: &str, match_case: bool, whole_word: bo
     let mut i = 0;
     while i + nc.len() <= hc.len() {
         if (0..nc.len()).all(|k| eq(hc[i + k].1, nc[k])) {
-            let before = i.checked_sub(1).map(|j| hc[j].1);
-            let after = hc.get(i + nc.len()).map(|x| x.1);
-            if !whole_word || (!before.is_some_and(is_word) && !after.is_some_and(is_word)) {
+            let prev = i.checked_sub(1).map_or(before, |j| hc.get(j).map(|x| x.1));
+            let next = hc.get(i + nc.len()).map_or(after, |x| Some(x.1));
+            if !whole_word || (!prev.is_some_and(is_word) && !next.is_some_and(is_word)) {
                 let start = hc[i].0;
                 let end = hc.get(i + nc.len()).map(|x| x.0).unwrap_or(hay.len());
                 out.push((start, end));
@@ -650,15 +696,24 @@ pub(crate) fn find_all(hay: &str, needle: &str, match_case: bool, whole_word: bo
     out
 }
 
+/// The text objects Find and Replace and Find Next reach: on visible, unlocked layers, and not
+/// inside a hidden or locked group, which hides or locks what it holds as a layer does (#5900).
 fn all_texts(d: &Document) -> Vec<NodeId> {
+    fn visit(n: &Node, locks: &LockedArtboards<'_>, v: &mut Vec<NodeId>) {
+        if !n.visible || n.locked {
+            return;
+        }
+        if matches!(n.kind, NodeKind::Text(_)) && !locks.holds_id(n.id) {
+            v.push(n.id);
+        }
+        for c in n.children().into_iter().flatten() {
+            visit(c, locks, v);
+        }
+    }
     let mut v = vec![];
     let locks = d.locked_artboards();
-    for l in d.layers.iter().filter(|l| l.visible && !l.locked) {
-        l.walk(&mut |n| {
-            if matches!(n.kind, NodeKind::Text(_)) && n.visible && !n.locked && !locks.holds_id(n.id) {
-                v.push(n.id);
-            }
-        });
+    for l in &d.layers {
+        visit(l, &locks, &mut v);
     }
     v
 }
@@ -676,7 +731,7 @@ fn find_replace(s: &mut Session, p: &Value) -> Result<Value> {
     let total: usize = ids
         .iter()
         .filter_map(|id| match &st.doc.node(*id)?.kind {
-            NodeKind::Text(t) => Some(t.runs.iter().map(|r| find_all(&r.text, &find, mc, ww).len()).sum::<usize>()),
+            NodeKind::Text(t) => Some((0..t.runs.len()).map(|i| find_in_run(&t.runs, i, &find, mc, ww).len()).sum::<usize>()),
             _ => None,
         })
         .sum();
@@ -693,7 +748,7 @@ fn find_replace(s: &mut Session, p: &Value) -> Result<Value> {
             let mut base = 0;
             for (ri, r) in t.runs.iter().enumerate() {
                 if r.inline.is_none() {
-                    for (a, b) in find_all(&r.text, &find, mc, ww) {
+                    for (a, b) in find_in_run(&t.runs, ri, &find, mc, ww) {
                         if r.text.get(a..b) != Some(rep.as_str()) {
                             hits.push((ri, base + a, base + b, a, b));
                         }
diff --git a/crates/engine/src/command_sets.rs b/crates/engine/src/command_sets.rs
index 4a628d6ef..4752b0a96 100644
--- a/crates/engine/src/command_sets.rs
+++ b/crates/engine/src/command_sets.rs
@@ -24,9 +24,10 @@ pub const FIT_ACTIVE_ARTBOARD: [&str; 2] = ["artboard.fitToArt", "artboard.fitTo
 
 /// `(command, param)` pairs the journal records only so a replay reproduces the original run
 /// (dates from the clock: `cmd::clock_date`; the artboards the app passes to the
-/// [`ON_ACTIVE_ARTBOARD`] and [`FIT_ACTIVE_ARTBOARD`] commands and to a batch; the view's center
-/// the app passes to Edit Symbol); an action leaves them out ([`Session::journal_for_action`]).
-const REPLAY_ONLY: [(&str, &str); 16] = [
+/// [`ON_ACTIVE_ARTBOARD`] and [`FIT_ACTIVE_ARTBOARD`] commands and to a batch; the artboards the
+/// Artboard tool had selected for its commands; the view's center the app passes to Edit Symbol);
+/// an action leaves them out ([`Session::journal_for_action`]).
+const REPLAY_ONLY: [(&str, &str); 21] = [
     ("file.new", "created"),
     ("document.save", "modified"),
     ("file.saveAs", "modified"),
@@ -39,6 +40,11 @@ const REPLAY_ONLY: [(&str, &str); 16] = [
     ("artboard.fitToArt", "index"),
     ("artboard.fitToArt", "indices"),
     ("artboard.fitToSelection", "index"),
+    ("artboard.duplicate", "selectedArtboards"),
+    ("artboard.copy", "selectedArtboards"),
+    ("artboard.cut", "selectedArtboards"),
+    ("artboard.rename", "selectedArtboards"),
+    ("artboard.switchOrientation", "selectedArtboards"),
     ("select.allOnArtboard", "artboard"),
     ("symbol.edit", "artboard"),
     ("symbol.edit", "viewCenter"),
diff --git a/crates/engine/src/doc_state.rs b/crates/engine/src/doc_state.rs
index 3d1c4be89..5c3a9130d 100644
--- a/crates/engine/src/doc_state.rs
+++ b/crates/engine/src/doc_state.rs
@@ -76,6 +76,11 @@ pub struct DocState {
     /// The view saved into native files (`Document::last_view`); the UI keeps it current before a
     /// save and restores it when the document opens.
     pub view: Option<vectorcraft_doc::SavedView>,
+    /// The id of the view's active artboard, which the UI keeps current before each command it
+    /// runs: a `.ai` save or export names that artboard as the file's active one. `None`, or an
+    /// artboard the document no longer has: the artboard the document opened on
+    /// ([`vectorcraft_doc::Document::opened_artboard`]), else the first.
+    pub active_artboard: Option<u32>,
     /// Restored by Data Recovery: the title says "[Recovered]" and Save asks where to save it
     /// (suggesting `path`, the file it was copied from) instead of overwriting that file.
     pub recovered: bool,
@@ -266,6 +271,7 @@ impl DocState {
             save_artboards: vec![],
             converted: false,
             view,
+            active_artboard: None,
             recovered: false,
             recovery: None,
             print_tiling: false,
diff --git a/crates/engine/src/link_watch.rs b/crates/engine/src/link_watch.rs
index 44b1bd86a..6cdf5c359 100644
--- a/crates/engine/src/link_watch.rs
+++ b/crates/engine/src/link_watch.rs
@@ -33,7 +33,7 @@ pub type LinkScan = Arc<(Mutex<Option<(u64, Vec<(String, Vec<u64>, Option<Stamp>
 
 /// Held by a look's worker: marks the look as ended and wakes [`Session::wait_link_scan`] when
 /// dropped, whether the worker returned or unwound.
-struct Ended(LinkScan);
+pub(crate) struct Ended(pub(crate) LinkScan);
 
 impl Drop for Ended {
     fn drop(&mut self) {
@@ -44,6 +44,14 @@ impl Drop for Ended {
     }
 }
 
+/// Whether a look's worker ended without storing stamps, with `read_ended` reading the flag. The
+/// worker stores its stamps and marks the look as ended under the slot's lock, and this holds that
+/// lock across both reads, so a look whose worker is storing its stamps never counts as ended without them.
+pub(crate) fn ended_without_stamps(scan: &LinkScan, read_ended: impl FnOnce(&AtomicBool) -> bool) -> bool {
+    let stamps = scan.0.lock().unwrap_or_else(PoisonError::into_inner);
+    stamps.is_none() && read_ended(&scan.2)
+}
+
 /// The stamp of the linked file stored as `path` in the document saved at `doc_path`; `None` when
 /// there is no file, its path isn't followed ([`crate::cmd::fileio::document_path`]) or
 /// automation may not read it.
@@ -108,8 +116,10 @@ impl Session {
     }
 
     /// Apply a finished look (`None` while there is none, or it is still running): see
-    /// [`Session::apply_link_stamps`].
+    /// [`Session::apply_link_stamps`]. A look whose worker ended without stamps is cleared, also
+    /// with `None`, so the next one can start.
     pub fn poll_link_scan(&mut self) -> Option<Result<Value>> {
+        self.link_scan.take_if(|scan| ended_without_stamps(scan, |ended| ended.load(Ordering::SeqCst)));
         let (uid, stamps) = self.link_scan.as_ref()?.0.lock().unwrap_or_else(PoisonError::into_inner).take()?;
         self.link_scan = None;
         Some(self.apply_link_stamps(uid, stamps, false))
@@ -117,7 +127,8 @@ impl Session {
 
     /// Block until the look in flight has ended (at once when none is running), so that the next
     /// [`Session::poll_link_scan`] applies its stamps. A look whose worker stopped without stamps
-    /// ends too, and the poll then returns `None`. For tests that drive the look step by step.
+    /// ends too, and the poll then clears it and returns `None`. For tests that drive the look step
+    /// by step.
     pub fn wait_link_scan(&self) {
         let Some(scan) = &self.link_scan else { return };
         let (done, finished, ended) = &**scan;
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 812a6282f..862bc4b77 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -147,6 +147,7 @@ mod scalestrokes;
 mod scripts;
 mod select_ids_first;
 mod shaper;
+mod shapetools;
 mod shortcutset;
 mod simplify_part;
 mod slices;
diff --git a/crates/engine/src/tests/clipflavours.rs b/crates/engine/src/tests/clipflavours.rs
index 313935c21..5955389ae 100644
--- a/crates/engine/src/tests/clipflavours.rs
+++ b/crates/engine/src/tests/clipflavours.rs
@@ -333,6 +333,41 @@ fn import_text_then_paste_gives_point_text() {
     }
 }
 
+#[test]
+fn spreadsheet_cells_paste_as_a_table_of_type_over_gridlines() {
+    let mut s = session();
+    // As Excel puts three rows of two columns on the clipboard, an empty cell included.
+    let r = run(&mut s, "clipboard.importText", json!({"text": "Fruit\tQty\r\nApples\t3\r\nPears\t\r\n"}));
+    assert_eq!((r["count"].clone(), r["rows"].clone(), r["columns"].clone()), (json!(1), json!(3), json!(2)));
+    run(&mut s, "edit.paste", json!({"center": [200, 150]}));
+    let first = pasted(&s);
+    assert_eq!(first.len(), 1);
+    let table = &first[0];
+    assert_eq!(table.name.as_deref(), Some("Table"));
+    let kids = table.children().unwrap();
+    let grid = &kids[0];
+    assert_eq!(grid.name.as_deref(), Some("Gridlines"));
+    assert_eq!(grid.children().unwrap().len(), 4 + 3, "four row lines, three column lines");
+    // One type object a cell that holds text, each inside its own cell.
+    let cells: Vec<_> = kids[1..].iter().map(|n| (text_of(n).plain_text(), n.geometric_bounds().unwrap())).collect();
+    let texts: Vec<&str> = cells.iter().map(|(t, _)| t.as_str()).collect();
+    assert_eq!(texts, ["Fruit", "Qty", "Apples", "3", "Pears"]);
+    let at = |t: &str| cells.iter().find(|c| c.0 == t).unwrap().1;
+    assert!(at("Qty").x0 > at("Apples").x1, "the second column starts past the widest of the first");
+    assert!((at("Qty").x0 - at("3").x0).abs() < 1e-6 && (at("Fruit").x0 - at("Pears").x0).abs() < 1e-6, "columns line up");
+    assert!(at("Apples").y0 > at("Fruit").y1 && at("Pears").y0 > at("Apples").y1, "rows go down: {cells:?}");
+    let b = table.geometric_bounds().unwrap();
+    assert!((b.center().x - 200.0).abs() < 1.0 && (b.center().y - 150.0).abs() < 1.0, "{b:?}");
+    // table: false, and text that isn't a spreadsheet's, paste as one point type object.
+    for (text, table) in [("a\tb\nc\td", json!(false)), ("\tindented\n\tcode", Value::Null), ("x\ty\nz", Value::Null)] {
+        run(&mut s, "clipboard.importText", json!({"text": text, "table": table}));
+        run(&mut s, "edit.paste", json!({}));
+        let p = pasted(&s);
+        assert_eq!((p.len(), text_of(&p[0]).plain_text()), (1, text.to_string()), "{text:?}");
+    }
+    assert!(s.execute("clipboard.importText", &json!({"text": "a\tb", "table": "yes"})).is_err());
+}
+
 #[test]
 fn type_only_copies_offer_their_text() {
     let mut s = session();
diff --git a/crates/engine/src/tests/constrain_new.rs b/crates/engine/src/tests/constrain_new.rs
index 4184cb3c9..382e3af31 100644
--- a/crates/engine/src/tests/constrain_new.rs
+++ b/crates/engine/src/tests/constrain_new.rs
@@ -113,6 +113,9 @@ fn constrain_angle_turns_the_base_orientation_of_polygons_and_stars() {
     let shift = Mods { shift: true, ..Mods::default() };
     let draw = |s: &mut Session, tool: &str, deg: f64| {
         set_angle(s, deg);
+        // Nothing selected: the press draws, rather than moving the shape drawn before it by the
+        // centre point it shows (#5477).
+        s.execute("select.none", &json!({})).unwrap();
         s.select_tool(tool, ViewInfo::default()).unwrap();
         gesture(s, shift, &[(Down, 100.0, 100.0), (Drag, 130.0, 140.0), (Drag, 130.0, 140.0), (Up, 130.0, 140.0)]);
         last_id(s)
diff --git a/crates/engine/src/tests/envelope.rs b/crates/engine/src/tests/envelope.rs
index 0180acb31..8e3cbf6cc 100644
--- a/crates/engine/src/tests/envelope.rs
+++ b/crates/engine/src/tests/envelope.rs
@@ -221,6 +221,131 @@ fn envelope_options_round_trip_natively_and_old_files_load() {
     assert!(serde_json::to_value(&legacy).unwrap()["kind"].get("options").is_none());
 }
 
+/// Envelope Options change the options they name: the margins an envelope opens with from a file
+/// stay, and they survive a native save.
+#[test]
+fn envelope_options_keep_the_margins_of_an_opened_file() {
+    let mut s = session();
+    let (_, e) = enveloped(&mut s, "object.envelope.makeWithMesh", json!({"rows": 1, "cols": 1}));
+    assert_eq!(options(&s, e).0.bounds_margin, [0.0; 4]);
+    let margin = [0.01, 0.02, 0.01, 0.02];
+    let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
+    if let Some(NodeKind::Envelope { options, .. }) = doc.node_mut(e).map(|n| &mut n.kind) {
+        options.bounds_margin = margin;
+    }
+    s.execute("object.envelope.options", &json!({"antiAlias": false, "fidelity": 75})).unwrap();
+    assert_eq!(options(&s, e).0.bounds_margin, margin);
+    let d = &s.doc().unwrap().doc;
+    let back = vectorcraft_format::load(&vectorcraft_format::save(d, false)).unwrap();
+    assert_eq!(back.node(e), d.node(e));
+    assert_eq!(s.execute("object.envelope.info", &json!({})).unwrap()["boundsMargin"], json!(margin));
+    s.execute("object.envelope.options", &json!({"distortAppearance": false})).unwrap();
+    assert_eq!(options(&s, e).0.bounds_margin, margin);
+}
+
+/// `object.envelope.info` leaves out margins that are zero.
+#[test]
+fn envelope_info_reports_margins_only_when_it_has_them() {
+    let mut s = session();
+    enveloped(&mut s, "object.envelope.makeWithMesh", json!({"rows": 1, "cols": 1}));
+    assert!(s.execute("object.envelope.info", &json!({})).unwrap().get("boundsMargin").is_none());
+}
+
+/// Leaving Edit Contents measures the margins again when a stroke changed: a wider stroke gives
+/// larger ones and no stroke gives none, after which a stroke adds none, as in a new envelope. A
+/// new envelope's margins stay zero.
+#[test]
+fn leaving_edit_contents_measures_the_margins_again() {
+    let mut s = session();
+    let (a, e) = enveloped(&mut s, "object.envelope.makeWithMesh", json!({"rows": 1, "cols": 1}));
+    let set_stroke = |s: &mut Session, weight: f64| {
+        sel(s, &[e]);
+        s.execute("object.envelope.editContents", &json!({"editing": true})).unwrap();
+        sel(s, &[a]);
+        s.execute("stroke.set", &json!({"weight": weight})).unwrap();
+        sel(s, &[e]);
+        s.execute("object.envelope.editContents", &json!({"editing": false})).unwrap();
+    };
+    set_stroke(&mut s, 10.0);
+    assert_eq!(options(&s, e).0.bounds_margin, [0.0; 4]);
+
+    let margin = [0.05, 0.05, 0.025, 0.025];
+    let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
+    if let Some(NodeKind::Envelope { options, .. }) = doc.node_mut(e).map(|n| &mut n.kind) {
+        options.bounds_margin = [0.5; 4];
+    }
+    set_stroke(&mut s, 20.0);
+    assert_eq!(options(&s, e).0.bounds_margin, margin.map(|m| m * 2.0));
+    s.execute("object.envelope.editContents", &json!({"editing": true})).unwrap();
+    assert_eq!(options(&s, e).0.bounds_margin, margin.map(|m| m * 2.0));
+    s.execute("object.envelope.editContents", &json!({"editing": false})).unwrap();
+    assert_eq!(options(&s, e).0.bounds_margin, margin.map(|m| m * 2.0));
+    set_stroke(&mut s, 10.0);
+    assert_eq!(options(&s, e).0.bounds_margin, margin);
+    // A stroke change, then a second entry, undone back to the first: leaving measures the change.
+    sel(&mut s, &[e]);
+    s.execute("object.envelope.editContents", &json!({"editing": true})).unwrap();
+    sel(&mut s, &[a]);
+    s.execute("stroke.set", &json!({"weight": 30.0})).unwrap();
+    sel(&mut s, &[e]);
+    s.execute("object.envelope.editContents", &json!({"editing": false})).unwrap();
+    s.execute("object.envelope.editContents", &json!({"editing": true})).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    sel(&mut s, &[e]);
+    s.execute("object.envelope.editContents", &json!({"editing": false})).unwrap();
+    assert_eq!(options(&s, e).0.bounds_margin, margin.map(|m| m * 3.0));
+    set_stroke(&mut s, 0.0);
+    assert_eq!(options(&s, e).0.bounds_margin, [0.0; 4]);
+    set_stroke(&mut s, 10.0);
+    assert_eq!(options(&s, e).0.bounds_margin, [0.0; 4]);
+}
+
+/// After an uneven scale, Edit Contents without a stroke change leaves the margins and the box the
+/// content maps from, and a stroke change measures them.
+#[test]
+fn edit_contents_keeps_the_margins_of_a_scaled_envelope_until_a_stroke_changes() {
+    let mut s = session();
+    let (a, e) = enveloped(&mut s, "object.envelope.makeWithMesh", json!({"rows": 1, "cols": 1}));
+    sel(&mut s, &[a]);
+    s.execute("object.envelope.editContents", &json!({"editing": true})).unwrap();
+    s.execute("stroke.set", &json!({"weight": 10.0})).unwrap();
+    sel(&mut s, &[e]);
+    s.execute("object.envelope.editContents", &json!({"editing": false})).unwrap();
+    let margin = [0.05, 0.05, 0.025, 0.025];
+    let doc = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
+    if let Some(NodeKind::Envelope { options, .. }) = doc.node_mut(e).map(|n| &mut n.kind) {
+        options.bounds_margin = margin;
+    }
+    s.execute("object.transform", &json!({"ids": [e.0], "matrix": [2, 0, 0, 0.5, 0, 0]})).unwrap();
+    let src = |s: &Session| live::EnvelopeMap::of(s.doc().unwrap().doc.node(e).unwrap()).unwrap().src();
+    let box_before = src(&s);
+    sel(&mut s, &[e]);
+    s.execute("object.envelope.editContents", &json!({"editing": true})).unwrap();
+    s.execute("object.envelope.editContents", &json!({"editing": false})).unwrap();
+    assert_eq!(options(&s, e).0.bounds_margin, margin);
+    assert_eq!(src(&s), box_before);
+    // Undoing that step and leaving again gives the same.
+    s.execute("edit.undo", &json!({})).unwrap();
+    sel(&mut s, &[e]);
+    s.execute("object.envelope.editContents", &json!({"editing": false})).unwrap();
+    assert_eq!(options(&s, e).0.bounds_margin, margin);
+    // So does saving natively in Edit Contents, reopening and leaving.
+    s.execute("object.envelope.editContents", &json!({"editing": true})).unwrap();
+    let back = vectorcraft_format::load(&vectorcraft_format::save(&s.doc().unwrap().doc, false)).unwrap();
+    assert_eq!(back.node(e), s.doc().unwrap().doc.node(e));
+    assert!(back.node(e).unwrap().extras().envelope_edit_margin.is_some());
+    s.execute("object.envelope.editContents", &json!({"editing": false})).unwrap();
+    assert!(node(&s, e).extras().envelope_edit_margin.is_none());
+
+    s.execute("object.envelope.editContents", &json!({"editing": true})).unwrap();
+    sel(&mut s, &[a]);
+    s.execute("stroke.set", &json!({"weight": 0.0})).unwrap();
+    sel(&mut s, &[e]);
+    s.execute("object.envelope.editContents", &json!({"editing": false})).unwrap();
+    assert_eq!(options(&s, e).0.bounds_margin, [0.0; 4]);
+}
+
 /// Regression: every exporter wrote type inside an envelope undistorted (no text outliner), so a
 /// warped line of type exported the same whatever its bend.
 #[test]
diff --git a/crates/engine/src/tests/journal.rs b/crates/engine/src/tests/journal.rs
index 92feb107f..26fcc0835 100644
--- a/crates/engine/src/tests/journal.rs
+++ b/crates/engine/src/tests/journal.rs
@@ -247,6 +247,149 @@ fn a_batch_step_records_what_it_took_from_the_preferences() {
     assert_eq!(doc(&r), doc(&s));
 }
 
+/// A document of three artboards with a rectangle on the second, the Artboard tool chosen and that
+/// artboard selected → the journal's length, where the entries under test start.
+fn second_artboard_selected(s: &mut Session) -> usize {
+    s.execute("file.new", &json!({"width": 400, "height": 200, "created": null})).unwrap();
+    s.execute("artboard.new", &json!({"x": 1000, "y": 0, "width": 300, "height": 100})).unwrap();
+    s.execute("artboard.new", &json!({"x": 2000, "y": 0, "width": 100, "height": 300})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 1010, "y": 10, "width": 100, "height": 50})).unwrap();
+    s.execute("stroke.set", &json!({"weight": 2})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    s.select_tool("artboard", crate::tooling::ViewInfo::default()).unwrap();
+    s.set_tool_option("selected", &json!([1]));
+    s.journal.len()
+}
+
+/// A new session's Artboard tool has nothing selected, so a replay of a command that took its
+/// artboards from the selection acts on the artboards it recorded, and an action does not keep them.
+#[test]
+fn artboard_commands_record_the_selected_artboards_for_a_replay_and_not_for_an_action() {
+    for (id, params, recorded, action) in [
+        ("artboard.switchOrientation", json!({}), json!({"selectedArtboards": [1], "scaleArt": false}), json!({"scaleArt": false})),
+        ("artboard.rename", json!({"name": "Back"}), json!({"name": "Back", "selectedArtboards": [1]}), json!({"name": "Back"})),
+        ("artboard.duplicate", json!({}), json!({"selectedArtboards": [1], "art": true}), json!({"art": true})),
+        ("artboard.cut", json!({}), json!({"selectedArtboards": [1], "art": true}), json!({"art": true})),
+        ("artboard.copy", json!({}), json!({"selectedArtboards": [1], "art": true}), json!({"art": true})),
+    ] {
+        let mut s = Session::new();
+        let start = second_artboard_selected(&mut s);
+        s.execute(id, &params).unwrap();
+        assert_eq!(s.journal.last().unwrap(), &(id.to_string(), recorded), "{id}");
+        assert_eq!(s.journal_for_action(start), [(id.to_string(), action)], "{id}");
+        assert_eq!(documents(&replayed(&s)), documents(&s), "{id}");
+    }
+}
+
+/// A copy of the artboard the tool had selected replays as a copy of that artboard: what it pastes
+/// is the same.
+#[test]
+fn a_replayed_artboard_copy_pastes_the_selected_artboard() {
+    let mut s = Session::new();
+    second_artboard_selected(&mut s);
+    s.execute("artboard.copy", &json!({})).unwrap();
+    s.execute("artboard.switchOrientation", &json!({"index": 0})).unwrap();
+    s.execute("edit.paste", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().doc.artboards.len(), 4);
+    assert_eq!(documents(&replayed(&s)), documents(&s));
+}
+
+/// The artboards a call names are recorded as given and stay in an action, and a batch step records
+/// the selected ones in its own params.
+#[test]
+fn artboard_commands_keep_a_named_artboard_and_note_a_batch_steps_artboards() {
+    let mut s = Session::new();
+    let start = second_artboard_selected(&mut s);
+    s.execute("artboard.switchOrientation", &json!({"index": 0})).unwrap();
+    assert_eq!(s.journal.last().unwrap().1, json!({"index": 0, "scaleArt": false}));
+    s.execute("artboard.duplicate", &json!({"indices": [0]})).unwrap();
+    assert_eq!(s.journal.last().unwrap().1, json!({"indices": [0], "art": true}));
+    let steps = json!([{"command": "artboard.switchOrientation", "params": {}}]);
+    s.execute("command.batch", &json!({ "commands": steps })).unwrap();
+    assert_eq!(s.journal.last().unwrap().1["commands"][0]["params"], json!({"selectedArtboards": [1], "scaleArt": false}));
+    assert_eq!(documents(&replayed(&s)), documents(&s));
+    let action = s.journal_for_action(start);
+    assert_eq!(action[0].1, json!({"index": 0, "scaleArt": false}));
+    assert_eq!(action[1].1, json!({"indices": [0], "art": true}));
+    assert_eq!(action[2].1["commands"][0]["params"], json!({"scaleArt": false}));
+}
+
+/// A recorded `selectedArtboards` goes ahead of the tool's selection, gives way to a named artboard,
+/// and is checked as `indices` is.
+#[test]
+fn artboard_commands_read_the_recorded_selected_artboards() {
+    let mut s = Session::new();
+    second_artboard_selected(&mut s);
+    let run = |s: &mut Session, p| s.execute("artboard.switchOrientation", &p).map(|r| r["switched"].clone());
+    assert_eq!(run(&mut s, json!({"selectedArtboards": [2]})).unwrap(), json!([2]));
+    assert_eq!(run(&mut s, json!({"selectedArtboards": [2], "index": 0})).unwrap(), json!([0]));
+    for bad in [json!([9]), json!([]), json!("1"), json!(null)] {
+        assert!(run(&mut s, json!({ "selectedArtboards": bad })).is_err(), "{bad}");
+    }
+}
+
+/// `edit.copy` and `edit.cut` run the Artboard tool's copy and take no artboards, so their entries
+/// stay as given.
+#[test]
+fn edit_copy_and_cut_with_the_artboard_tool_record_their_params_as_given() {
+    for id in ["edit.copy", "edit.cut"] {
+        let mut s = Session::new();
+        second_artboard_selected(&mut s);
+        s.execute(id, &json!({})).unwrap();
+        assert_eq!(s.journal.last().unwrap(), &(id.to_string(), json!({})), "{id}");
+    }
+}
+
+/// `artboard.duplicate` and the cut and copy record the tool's Move/Copy Artwork option: replayed in
+/// a new session, where the option is on, the art stays behind as it did.
+#[test]
+fn artboard_commands_record_the_tools_move_art_option() {
+    for id in ["artboard.duplicate", "artboard.cut", "artboard.copy"] {
+        let mut s = Session::new();
+        second_artboard_selected(&mut s);
+        s.set_tool_option("moveArt", &json!(false));
+        s.execute(id, &json!({})).unwrap();
+        assert_eq!(s.journal.last().unwrap().1["art"], json!(false), "{id}");
+        assert_eq!(documents(&replayed(&s)), documents(&s), "{id}");
+    }
+}
+
+/// `artboard.switchOrientation` records the tool's Scale Artwork option: replayed in a new session,
+/// where it is off, the art scales as it did.
+#[test]
+fn artboard_switch_orientation_records_the_tools_scale_art_option() {
+    let mut s = Session::new();
+    second_artboard_selected(&mut s);
+    s.set_tool_option("scaleArt", &json!(true));
+    s.execute("artboard.switchOrientation", &json!({})).unwrap();
+    assert_eq!(s.journal.last().unwrap().1["scaleArt"], json!(true));
+    assert_eq!(documents(&replayed(&s)), documents(&s));
+}
+
+/// `artboard.switchOrientation` records whether locked and hidden art goes along: replayed in a new
+/// session, where the preference is off, the locked art scales as it did.
+#[test]
+fn artboard_switch_orientation_records_whether_locked_art_goes_along() {
+    let mut s = Session::new();
+    second_artboard_selected(&mut s);
+    let r = s.execute("shape.rectangle", &json!({"x": 1150, "y": 10, "width": 100, "height": 50})).unwrap();
+    s.execute("layer.setProps", &json!({"ids": [r["id"]], "locked": true})).unwrap();
+    s.prefs.move_locked_with_artboard = true;
+    s.set_tool_option("scaleArt", &json!(true));
+    s.execute("artboard.switchOrientation", &json!({})).unwrap();
+    assert_eq!(s.journal.last().unwrap().1["lockedAndHidden"], json!(true));
+    let r = replayed(&s);
+    assert!(!r.prefs.move_locked_with_artboard);
+    assert_eq!(documents(&r), documents(&s));
+    // The params' own values win over the preferences.
+    let mut t = Session::new();
+    second_artboard_selected(&mut t);
+    t.prefs.move_locked_with_artboard = true;
+    t.execute("artboard.switchOrientation", &json!({"scaleArt": true, "lockedAndHidden": false})).unwrap();
+    assert_eq!(t.journal.last().unwrap().1["lockedAndHidden"], json!(false));
+    assert!(t.execute("artboard.switchOrientation", &json!({"strokes": "yes"})).is_err());
+}
+
 /// Every open document of `s`, as JSON.
 fn documents(s: &Session) -> Vec<serde_json::Value> {
     s.documents().iter().map(|d| serde_json::to_value(&*d.doc).unwrap()).collect()
diff --git a/crates/engine/src/tests/legacy_ai.rs b/crates/engine/src/tests/legacy_ai.rs
index c4722c9c1..9a9aafcba 100644
--- a/crates/engine/src/tests/legacy_ai.rs
+++ b/crates/engine/src/tests/legacy_ai.rs
@@ -368,6 +368,54 @@ fn a_transparent_image_is_flattened_with_the_art_under_it_which_stays() {
     assert_eq!(colour_at(page, 10.0, 20.0), [255, 0, 0], "the square outside the image");
 }
 
+/// A `size`×`size` PNG of a black disk of radius `r` pixels with an anti-aliased edge, clear
+/// around it, 72 ppi.
+fn disk(size: u32, r: f64) -> Vec<u8> {
+    let c = f64::from(size) / 2.0;
+    let img = image::RgbaImage::from_fn(size, size, |x, y| {
+        let d = (f64::from(x) + 0.5 - c).hypot(f64::from(y) + 0.5 - c);
+        image::Rgba([0, 0, 0, ((r + 0.5 - d).clamp(0.0, 1.0) * 255.0).round() as u8])
+    });
+    let mut out = vec![];
+    img.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).unwrap();
+    out
+}
+
+/// #5264: the clip around a flattened image follows its edge smoothly: a disk's clip is a ring of
+/// sloped segments close to the disk's edge, not a staircase of horizontal and vertical steps.
+#[test]
+fn a_flattened_images_clip_follows_its_edge_smoothly() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 180, "height": 80})).unwrap();
+    s.execute("paint.setFill", &json!({"color": "#ff0000"})).unwrap();
+    let p = json!({"name": "disk.png", "dataBase64": vectorcraft_format::base64_encode(&disk(64, 25.0)), "at": [100, 50]});
+    s.execute("file.place", &p).unwrap();
+    let r = s.execute("file.saveCopy", &json!({"format": "ai", "aiVersion": "7"})).unwrap();
+    s.execute("document.open", &json!({"name": "t.ai", "dataBase64": r["dataBase64"]})).unwrap();
+    let d = &s.doc().unwrap().doc;
+    let mut clips = vec![];
+    d.walk(|n| {
+        if let (vectorcraft_doc::NodeKind::Path { clipping: true, .. }, Some(pd)) = (&n.kind, n.path_data()) {
+            clips.push(pd.clone());
+        }
+    });
+    assert_eq!(clips.len(), 1, "{clips:?}");
+    let sub = &clips[0].subpaths;
+    assert_eq!(sub.len(), 1);
+    let pts: Vec<_> = sub[0].anchors.iter().map(|a| a.p).collect();
+    assert!(pts.len() >= 16, "{pts:?}");
+    // Its centre: the file's page may sit elsewhere than the artboard.
+    let n = pts.len() as f64;
+    let (cx, cy) = (pts.iter().map(|p| p.x).sum::<f64>() / n, pts.iter().map(|p| p.y).sum::<f64>() / n);
+    for p in &pts {
+        let r = (p.x - cx).hypot(p.y - cy);
+        assert!((24.5..=27.5).contains(&r), "an anchor {r} pt from the centre: {pts:?}");
+    }
+    let sloped = pts.iter().zip(pts.iter().cycle().skip(1)).filter(|(a, b)| (a.x - b.x).abs() > 0.1 && (a.y - b.y).abs() > 0.1).count();
+    assert!(sloped * 2 >= pts.len(), "{sloped} of {} segments are sloped: {pts:?}", pts.len());
+}
+
 /// How many of reply `r`'s warnings say that an image couldn't be decoded, as raster exports do.
 fn undecoded_notes(r: &Value) -> usize {
     warnings(r).iter().filter(|w| *w == "an image couldn't be decoded and is missing from the picture").count()
diff --git a/crates/engine/src/tests/library.rs b/crates/engine/src/tests/library.rs
index d232b2676..15a8da810 100644
--- a/crates/engine/src/tests/library.rs
+++ b/crates/engine/src/tests/library.rs
@@ -230,6 +230,66 @@ fn a_gradient_goes_into_a_library_and_paints_another_object() {
     assert!(s.execute("library.use", &json!({"library": lib, "kind": "fillGradient", "item": "Nope"})).is_err());
 }
 
+/// Compound paths, groups and colorized objects add the paint their Fill proxy shows: a color by
+/// its hex, a gradient with its stops.
+#[test]
+fn colors_and_gradients_come_from_compound_paths_groups_and_colorized_objects() {
+    use std::sync::Arc;
+    use vectorcraft_color::{Color, Paint};
+    use vectorcraft_doc::{Node, NodeKind};
+    let mut s = session();
+    let lib = run(&mut s, "library.create", json!({}))["id"].as_str().unwrap().to_string();
+    let solid = run(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20}))["id"].clone();
+    let graded = run(&mut s, "shape.rectangle", json!({"x": 30, "y": 0, "width": 20, "height": 20}))["id"].clone();
+    let stops = json!([{"offset": 0, "color": "#ff0000"}, {"offset": 0.5, "color": "#00ff00"}, {"offset": 1, "color": "#0000ff"}]);
+    run(&mut s, "paint.setFill", json!({"color": "#123456", "ids": [solid]}));
+    run(&mut s, "paint.setFill", json!({"gradient": {"kind": "linear", "stops": stops}, "ids": [graded]}));
+    let sources = [NodeId(solid.as_u64().unwrap()), NodeId(graded.as_u64().unwrap())];
+    // For each source: a compound path and a group painted as it is, and a gray rectangle
+    // colorized with its fill.
+    let mut made: Vec<(NodeId, bool)> = vec![];
+    s.edit("Make", |d, _| {
+        let l = d.layers[0].id;
+        for (k, src) in sources.into_iter().enumerate() {
+            let source = d.node(src).unwrap().clone();
+            let fill = source.appearance.fill().unwrap().paint.clone();
+            let gradient = matches!(fill, Paint::Gradient(_));
+            let member = |d: &mut vectorcraft_doc::Document| {
+                let mut m = source.clone();
+                (m.id, m.appearance) = (d.alloc_id(), Default::default());
+                Arc::new(m)
+            };
+            let (a, b) = (member(d), member(d));
+            let mut compound = Node::new(d.alloc_id(), NodeKind::Compound { children: vec![a], rule: Default::default() });
+            let mut group = Node::group(d.alloc_id(), vec![b]);
+            compound.appearance = source.appearance.clone();
+            group.appearance = source.appearance.clone();
+            let mut colorized = source.clone();
+            colorized.id = d.alloc_id();
+            colorized.appearance.set_fill(Paint::solid(Color::rgb8(128, 128, 128)));
+            colorized.extras_mut().colorize = Some(Box::new(fill));
+            for (j, n) in [compound, group, colorized].into_iter().enumerate() {
+                made.push((n.id, gradient));
+                d.insert(Some(l), 2 + 3 * k + j, n).unwrap();
+            }
+        }
+        Ok(())
+    })
+    .unwrap();
+    for (id, gradient) in made {
+        run(&mut s, "select.set", json!({"ids": [id.0]}));
+        if gradient {
+            run(&mut s, "library.add", json!({"library": lib, "kind": "fillGradient"}));
+            let got = run(&mut s, "library.get", json!({"library": lib}));
+            let last = &got["gradients"].as_array().unwrap().last().unwrap()["gradient"]["gradient"]["stops"];
+            assert_eq!(last.as_array().map(Vec::len), Some(3), "{id:?}: {got}");
+        } else {
+            let added = run(&mut s, "library.add", json!({"library": lib, "kind": "fillColor"}));
+            assert_eq!(added["name"], "#123456", "{id:?}");
+        }
+    }
+}
+
 /// A gradient added from an object that was rotated keeps the direction it shows there.
 #[test]
 fn a_gradient_from_rotated_art_keeps_its_direction() {
diff --git a/crates/engine/src/tests/links.rs b/crates/engine/src/tests/links.rs
index 7cdf43ad7..a4c222090 100644
--- a/crates/engine/src/tests/links.rs
+++ b/crates/engine/src/tests/links.rs
@@ -502,6 +502,38 @@ fn a_file_read_for_opening_has_its_links_read_and_its_type_laid_out() {
     }
 }
 
+/// Opening lays out each type object with the plans the objects before it left on the font's
+/// face: its bounds and baselines are those of a layout in a font database of its own, which holds
+/// no plans. The objects share a script and direction and differ in features and language. Only
+/// bundled Latin glyphs are set, which every font database holds.
+#[test]
+fn type_read_for_opening_has_the_layout_of_a_font_database_with_no_plans() {
+    let dir = Folder::new("read-for-open-plans");
+    let style = vectorcraft_doc::CharStyle { size: 100.0, ..Default::default() };
+    let manual = vectorcraft_doc::CharStyle { kerning: Some(0.0), ..style.clone() };
+    let turkish = vectorcraft_doc::CharStyle { language: Some("tr".into()), ..style.clone() };
+    let mut doc = Document::new(800.0, 600.0);
+    let layer = doc.layers[0].id;
+    for (text, style) in [("AVAV", &style), ("AVAV", &manual), ("office", &turkish), ("To Wa", &style), ("To Wa", &manual)] {
+        let t = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(20.0, 120.0), text, style.clone());
+        let id = doc.alloc_id();
+        doc.insert(Some(layer), usize::MAX, vectorcraft_doc::Node::new(id, NodeKind::Text(Box::new(t)))).unwrap();
+    }
+    let doc_path = dir.file("type.vectorcraft");
+    let bytes = vectorcraft_format::save_file(&doc);
+    let file = cmd::fileio::read_for_open(&doc_path, &bytes, Some(doc_path.clone()), &Value::Null, false, false).unwrap();
+    let mut seen = 0;
+    file.document().walk(|node| {
+        if let NodeKind::Text(t) = &node.kind {
+            let fresh = vectorcraft_text::layout(&vectorcraft_text::FontDb::with_font_dirs(vec![]), t);
+            assert_eq!(t.cached_bounds, Some(fresh.bounds), "{:?}", t.plain_text());
+            assert_eq!(t.cached_baselines, fresh.baselines(), "{:?}", t.plain_text());
+            seen += 1;
+        }
+    });
+    assert_eq!(seen, 5);
+}
+
 #[test]
 fn links_from_older_files_load_and_keep_their_pixels() {
     let dir = Folder::new("legacy");
diff --git a/crates/engine/src/tests/linkwatch.rs b/crates/engine/src/tests/linkwatch.rs
index f1192e02d..37aac5df5 100644
--- a/crates/engine/src/tests/linkwatch.rs
+++ b/crates/engine/src/tests/linkwatch.rs
@@ -1,6 +1,8 @@
 //! Linked files changing while their document is open (`link_watch`): `links.updateChanged`,
 //! and the background look following Preferences → File Handling → Update Links.
 
+use std::sync::atomic::Ordering;
+
 use serde_json::{Value, json};
 
 use crate::tests_links::{BLUE, Folder, RED, centre_colour, place, png, session};
@@ -84,6 +86,67 @@ fn a_file_still_being_written_is_tried_again() {
     assert_eq!(colour(&s), BLUE);
 }
 
+#[test]
+fn a_look_whose_worker_ended_without_stamps_does_not_stop_later_looks() {
+    let dir = Folder::new("watch-unwound");
+    let path = dir.file("art.png");
+    std::fs::write(&path, png(40, 40, RED)).unwrap();
+    let mut s = session();
+    s.prefs.update_links = "automatically".into();
+    let id = place(&mut s, &path);
+    look(&mut s);
+    let scan = link_watch::LinkScan::default();
+    s.link_scan = Some(scan.clone());
+    // Still running: the look stays in flight.
+    assert!(s.poll_link_scan().is_none());
+    assert!(s.link_scan.is_some(), "a look still running stays");
+    let worker = std::thread::spawn(move || {
+        let _ended = link_watch::Ended(scan);
+        panic!("the look's worker unwinds");
+    });
+    assert!(worker.join().is_err());
+    assert!(s.poll_link_scan().is_none(), "there are no stamps to apply");
+    assert!(s.link_scan.is_none(), "the look ended");
+    save(&path, &png(40, 40, BLUE));
+    assert_eq!(look(&mut s)["updated"], json!([id.0]));
+    assert_eq!(colour(&s), BLUE);
+}
+
+#[test]
+fn a_look_that_stores_its_stamps_between_the_polls_reads_keeps_them() {
+    let dir = Folder::new("watch-stored");
+    let path = dir.file("art.png");
+    std::fs::write(&path, png(40, 40, RED)).unwrap();
+    let mut s = session();
+    s.prefs.update_links = "automatically".into();
+    let id = place(&mut s, &path);
+    look(&mut s);
+    let uid = s.doc().unwrap().uid;
+    let stamps: Vec<_> = link_watch::linked_files(&s.doc().unwrap().doc).into_iter().map(|(p, ids)| (p, ids, Some((1, 1)))).collect();
+    let scan = link_watch::LinkScan::default();
+    s.link_scan = Some(scan.clone());
+    // The worker takes its turn after the slot is read and before the flag is, if the slot is free.
+    let ended = link_watch::ended_without_stamps(&scan, |flag| {
+        if let Ok(mut slot) = scan.0.try_lock() {
+            *slot = Some((uid, stamps.clone()));
+            flag.store(true, Ordering::SeqCst);
+        }
+        flag.load(Ordering::SeqCst)
+    });
+    assert!(!ended, "the worker waits for the poll, so the look has not ended without stamps");
+    // The worker's turn comes once the poll has let go of the slot.
+    let worker = std::thread::spawn({
+        let scan = scan.clone();
+        move || {
+            let _ended = link_watch::Ended(scan.clone());
+            *scan.0.lock().unwrap() = Some((uid, stamps));
+        }
+    });
+    worker.join().unwrap();
+    assert_eq!(s.poll_link_scan().expect("the stamps are applied").unwrap()["updated"], json!([id.0]));
+    assert!(s.link_scan.is_none());
+}
+
 #[test]
 fn a_change_during_a_drag_waits_for_the_drag_to_end() {
     let dir = Folder::new("watch-drag");
diff --git a/crates/engine/src/tests/menucmds.rs b/crates/engine/src/tests/menucmds.rs
index ad862376c..173303e9d 100644
--- a/crates/engine/src/tests/menucmds.rs
+++ b/crates/engine/src/tests/menucmds.rs
@@ -1989,6 +1989,36 @@ fn find_and_replace_options() {
     assert!(s.execute("edit.findReplace", &json!({"find": ""})).is_err());
 }
 
+/// Whole Word looks past a change of style: `cat` coloured red inside `catfish`, or at the end of
+/// `bobcat`, is part of a word, not a word of its own (#5901). A real word next to a run's end
+/// still matches, and without Whole Word the part is replaced as before.
+#[test]
+fn find_whole_word_is_not_fooled_by_a_style_change_inside_a_word() {
+    let styled = |s: &mut Session, t: &str, a: usize, b: usize| {
+        let id = text(s, t);
+        s.execute("text.setRangeStyle", &json!({"id": id.0, "start": a, "end": b, "fill": "#ff0000"})).unwrap();
+        let NodeKind::Text(tt) = &node(s, id).kind else { panic!() };
+        assert!(tt.runs.len() >= 2, "{t}: two runs");
+        id
+    };
+    let mut s = session();
+    let fish = styled(&mut s, "catfish", 0, 3);
+    let bob = styled(&mut s, "bobcat", 3, 6);
+    let r = s.execute("edit.findReplace", &json!({"find": "cat", "replace": "DOG", "wholeWord": true})).unwrap();
+    assert_eq!((r["count"].as_u64(), plain(&s, fish), plain(&s, bob)), (Some(0), "catfish".to_string(), "bobcat".to_string()));
+    // A word that ends where its run does, at a space or the text's end, is still a word.
+    let mut s = session();
+    let spaced = styled(&mut s, "cat fish", 0, 3);
+    let tail = styled(&mut s, "a cat", 2, 5);
+    let r = s.execute("edit.findReplace", &json!({"find": "cat", "replace": "DOG", "wholeWord": true})).unwrap();
+    assert_eq!((r["count"].as_u64(), plain(&s, spaced), plain(&s, tail)), (Some(2), "DOG fish".to_string(), "a DOG".to_string()));
+    // Without Whole Word, the part inside the word is found as before.
+    let mut s = session();
+    let fish = styled(&mut s, "catfish", 0, 3);
+    let r = s.execute("edit.findReplace", &json!({"find": "cat", "replace": "DOG"})).unwrap();
+    assert_eq!((r["count"].as_u64(), plain(&s, fish)), (Some(1), "DOGfish".to_string()));
+}
+
 /// Find and Replace with no ids leaves the type on a locked artboard as it is.
 #[test]
 fn find_and_replace_leaves_type_on_a_locked_artboard() {
@@ -2017,6 +2047,32 @@ fn find_and_replace_that_changes_nothing_records_no_undo_step() {
     assert_eq!((history(&s), plain(&s, a)), ((before.0 + 1, 0, true), "dog dog".to_string()));
 }
 
+/// Find and Replace with no ids leaves the type inside a locked or hidden group as it is, however
+/// deep, as it does for type locked or hidden itself or by its layer (#5900). Find Next skips it
+/// too. Unlocked and shown again, the group's type is found and replaced.
+#[test]
+fn find_and_replace_leaves_type_in_a_locked_or_hidden_group() {
+    for prop in ["locked", "hidden"] {
+        let mut s = session();
+        let free = text(&mut s, "Audit cat");
+        let inner = text(&mut s, "Audit cat");
+        sel(&mut s, &[inner]);
+        let g = id_of(&s.execute("object.group", &json!({})).unwrap());
+        sel(&mut s, &[g]);
+        let outer = id_of(&s.execute("object.group", &json!({})).unwrap());
+        let props = |on: bool| if prop == "locked" { json!({"id": outer.0, "locked": on}) } else { json!({"id": outer.0, "visible": !on}) };
+        s.execute("object.setProps", &props(true)).unwrap();
+        assert!(node(&s, inner).visible && !node(&s, inner).locked, "{prop}: the type itself is shown and unlocked");
+        let r = s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog"})).unwrap();
+        assert_eq!((r["count"].as_u64(), plain(&s, free), plain(&s, inner)), (Some(1), "Audit dog".to_string(), "Audit cat".to_string()), "{prop}");
+        s.execute("select.none", &json!({})).unwrap();
+        assert!(s.execute("edit.findNext", &json!({"find": "cat"})).unwrap()["id"].is_null(), "{prop}: Find Next skips it");
+        s.execute("object.setProps", &props(false)).unwrap();
+        let r = s.execute("edit.findReplace", &json!({"find": "cat", "replace": "dog"})).unwrap();
+        assert_eq!((r["count"].as_u64(), plain(&s, inner)), (Some(1), "Audit dog".to_string()), "{prop}: once the group is {prop} no more");
+    }
+}
+
 #[test]
 fn find_next_cycles_through_text_objects() {
     let mut s = session();
@@ -3406,6 +3462,39 @@ fn placeholder_and_insert_characters() {
     assert!(s.execute("type.insert", &json!({"char": "nope"})).is_err());
 }
 
+/// `type.insert` by code (#5108): `code` as a Windows Alt+0 code types (Windows-1252 for
+/// 128–159, the code point otherwise), `unicode` as a hex code point.
+#[test]
+fn insert_a_character_by_its_code() {
+    let mut s = session();
+    let t = text(&mut s, "");
+    sel(&mut s, &[t]);
+    for p in [
+        json!({"code": 176}),
+        json!({"code": 177}),
+        json!({"code": 151}),
+        json!({"code": 215}),
+        json!({"code": 8364}),
+        json!({"unicode": "00B0"}),
+        json!({"unicode": "U+2014"}),
+    ] {
+        s.execute("type.insert", &p).unwrap();
+    }
+    assert_eq!(plain(&s, t), "°±—×€°—");
+    for p in [
+        json!({"code": 129}),
+        json!({"code": 7}),
+        json!({"code": -1}),
+        json!({"code": 1_114_112}),
+        json!({"unicode": "D800"}),
+        json!({"unicode": "zz"}),
+        json!({}),
+    ] {
+        assert!(s.execute("type.insert", &p).is_err(), "{p}");
+    }
+    assert_eq!(plain(&s, t), "°±—×€°—");
+}
+
 #[test]
 fn area_placeholder_fills_frame() {
     let mut s = session();
diff --git a/crates/engine/src/tests/outlinestroke.rs b/crates/engine/src/tests/outlinestroke.rs
index fad35ad43..955e9798e 100644
--- a/crates/engine/src/tests/outlinestroke.rs
+++ b/crates/engine/src/tests/outlinestroke.rs
@@ -71,12 +71,14 @@ fn arrowheads_are_part_of_the_outline() {
     assert_eq!(path_of(&n).subpaths.len(), 1, "line and head are one shape");
 }
 
+/// Outline Stroke of a Lens-profile line covers 7/12 of the full-width rectangle.
 #[test]
-fn a_lens_profile_outlines_to_half_the_rectangle() {
+fn a_lens_profile_outlines_to_seven_twelfths_of_the_rectangle() {
     let mut s = session();
     line(&mut s, json!({"weight": 10, "profile": "lens"}));
     let n = outline(&mut s);
-    assert!(near(area(&n), 0.5 * 10.0 * 100.0, 2.0), "{}", area(&n));
+    // Each half of the lens swells on a cubic, flat at the middle (#5714).
+    assert!(near(area(&n), 7.0 / 12.0 * 10.0 * 100.0, 2.0), "{}", area(&n));
 }
 
 #[test]
diff --git a/crates/engine/src/tests/panelcmds.rs b/crates/engine/src/tests/panelcmds.rs
index 3cc47b7ac..706f40940 100644
--- a/crates/engine/src/tests/panelcmds.rs
+++ b/crates/engine/src/tests/panelcmds.rs
@@ -241,6 +241,150 @@ fn artboard_reorder_past_u32_goes_last() {
     assert_eq!(s.doc().unwrap().doc.artboards.last().map(|a| a.name.as_str()), Some("Second"));
 }
 
+/// `artboard.rename`: one artboard takes the name trimmed, several take it numbered in artboard
+/// order in one undo step, and a locked artboard is renamed too.
+#[test]
+fn artboard_rename_numbers_several_in_one_undo_step() {
+    let mut s = session();
+    s.execute("artboard.new", &json!({})).unwrap();
+    s.execute("artboard.new", &json!({})).unwrap();
+    s.execute("artboard.setProps", &json!({"index": 2, "locked": true})).unwrap();
+    let names = |s: &Session| s.doc().unwrap().doc.artboards.iter().map(|a| a.name.clone()).collect::<Vec<_>>();
+    let steps = s.doc().unwrap().history.undo.len();
+    assert_eq!(s.execute("artboard.rename", &json!({"index": 0, "name": " Cover "})).unwrap()["renamed"], json!([0]));
+    assert_eq!(names(&s)[0], "Cover");
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
+    // Listed out of order and twice: artboard order, once each.
+    assert_eq!(s.execute("artboard.rename", &json!({"indices": [2, 1, 2], "name": "Page"})).unwrap()["renamed"], json!([1, 2]));
+    assert_eq!(names(&s)[1..], ["Page-1", "Page-2"]);
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 2, "one undo step");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_ne!(names(&s)[1], "Page-1", "one undo restores both");
+    assert_ne!(names(&s)[2], "Page-2");
+}
+
+/// `artboard.rename` with nothing to change records no undo step, and without `index` or `indices`
+/// acts on the artboards the Artboard tool has selected.
+#[test]
+fn artboard_rename_records_nothing_when_nothing_changes() {
+    let mut s = session();
+    s.execute("artboard.new", &json!({})).unwrap();
+    s.execute("artboard.rename", &json!({"indices": [0, 1], "name": "Page"})).unwrap();
+    let steps = s.doc().unwrap().history.undo.len();
+    assert_eq!(s.execute("artboard.rename", &json!({"indices": [0, 1], "name": "Page"})).unwrap()["renamed"], json!([]));
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps);
+    s.select_tool("artboard", crate::tooling::ViewInfo::default()).unwrap();
+    s.set_tool_option("selected", &json!([1]));
+    assert_eq!(s.execute("artboard.rename", &json!({"name": "Back"})).unwrap()["renamed"], json!([1]));
+    assert_eq!(s.doc().unwrap().doc.artboards[1].name, "Back");
+}
+
+/// `artboard.rename` refuses an empty or missing name, a name that is not a string and an unknown
+/// artboard, and leaves the document and its undo history as they were.
+#[test]
+fn artboard_rename_refuses_bad_params() {
+    let mut s = session();
+    let steps = s.doc().unwrap().history.undo.len();
+    for p in [
+        json!({"index": 0, "name": "  "}),
+        json!({"index": 0}),
+        json!({"index": 0, "name": 7}),
+        json!({"index": 9, "name": "A"}),
+        json!({"indices": [], "name": "A"}),
+        json!({"indices": [0, 9], "name": "A"}),
+        json!({"index": "0", "name": "A"}),
+    ] {
+        assert!(s.execute("artboard.rename", &p).is_err(), "{p}");
+    }
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps);
+    assert_eq!(s.doc().unwrap().doc.artboards[0].name, "Artboard 1");
+}
+
+/// `artboard.switchOrientation` swaps width and height of each artboard named in one undo step,
+/// each top-left corner staying put; a square one and a locked one stay as they are.
+#[test]
+fn artboard_switch_orientation_swaps_each_in_one_undo_step() {
+    let mut s = session();
+    s.execute("artboard.new", &json!({"x": 1000, "y": 10, "width": 300, "height": 100})).unwrap();
+    s.execute("artboard.new", &json!({"x": 2000, "y": 20, "width": 50, "height": 50})).unwrap();
+    s.execute("artboard.new", &json!({"x": 3000, "y": 30, "width": 40, "height": 60})).unwrap();
+    s.execute("artboard.setProps", &json!({"index": 3, "locked": true})).unwrap();
+    let steps = s.doc().unwrap().history.undo.len();
+    let r = s.execute("artboard.switchOrientation", &json!({"indices": [0, 1, 2, 3]})).unwrap();
+    assert_eq!(r["switched"], json!([0, 1]));
+    let rects: Vec<_> = s.doc().unwrap().doc.artboards.iter().map(|a| (a.rect.x0, a.rect.y0, a.rect.width(), a.rect.height())).collect();
+    assert_eq!(rects, [(0.0, 0.0, 600.0, 800.0), (1000.0, 10.0, 100.0, 300.0), (2000.0, 20.0, 50.0, 50.0), (3000.0, 30.0, 40.0, 60.0)]);
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1, "one undo step");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().doc.artboards[1].rect.width(), 300.0);
+    assert_eq!(s.doc().unwrap().doc.artboards[0].rect.width(), 800.0, "one undo restores both");
+}
+
+/// `artboard.switchOrientation`: a square artboard records no undo step, every artboard locked is an
+/// error, and bad params change nothing.
+#[test]
+fn artboard_switch_orientation_refuses_and_records_nothing() {
+    let mut s = session();
+    s.execute("artboard.new", &json!({"x": 2000, "y": 0, "width": 50, "height": 50})).unwrap();
+    s.execute("artboard.setProps", &json!({"index": 0, "locked": true})).unwrap();
+    let steps = s.doc().unwrap().history.undo.len();
+    assert_eq!(s.execute("artboard.switchOrientation", &json!({"index": 1})).unwrap()["switched"], json!([]));
+    assert_eq!(s.execute("artboard.switchOrientation", &json!({"index": 0})).unwrap_err().to_string(), "the artboard is locked");
+    for p in [json!({"index": 9}), json!({"indices": []}), json!({"index": "1"}), json!({"index": 1, "scaleArt": "yes"})] {
+        assert!(s.execute("artboard.switchOrientation", &p).is_err(), "{p}");
+    }
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps);
+}
+
+/// `artboard.switchOrientation` takes the art along with `scaleArt`, and by default follows the
+/// Artboard tool's Scale Artwork with Artboard option.
+#[test]
+fn artboard_switch_orientation_scales_art_with_the_tools_option() {
+    let mut s = session();
+    let id = rect(&mut s);
+    let width = |s: &Session| s.doc().unwrap().doc.bounds_of(&[id], false).unwrap().width();
+    let was = width(&s);
+    s.execute("artboard.switchOrientation", &json!({"index": 0})).unwrap();
+    assert_eq!(width(&s), was, "the art stays by default");
+    s.select_tool("artboard", crate::tooling::ViewInfo::default()).unwrap();
+    s.set_tool_option("scaleArt", &json!(true));
+    s.execute("artboard.switchOrientation", &json!({"index": 0})).unwrap();
+    assert_ne!(width(&s), was, "the tool's option scales the art");
+}
+
+/// `artboard.fitToArt` records no undo step when every artboard already fits its art.
+#[test]
+fn artboard_fit_to_art_records_nothing_when_it_already_fits() {
+    let mut s = session();
+    rect(&mut s);
+    s.execute("artboard.fitToArt", &json!({"index": 0})).unwrap();
+    let steps = s.doc().unwrap().history.undo.len();
+    let was = s.doc().unwrap().doc.artboards[0].rect;
+    s.execute("artboard.fitToArt", &json!({"index": 0})).unwrap();
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps);
+    assert_eq!(s.doc().unwrap().doc.artboards[0].rect, was);
+}
+
+/// `edit.paste {artboardsAt}` centers the copied artboards on the point as they lay. A value that is
+/// not a point is an error.
+#[test]
+fn paste_centers_copied_artboards_on_artboards_at() {
+    let mut s = session();
+    s.execute("artboard.new", &json!({"x": 1000, "y": 0, "width": 100, "height": 100})).unwrap();
+    s.execute("artboard.copy", &json!({"indices": [0, 1]})).unwrap();
+    let steps = s.doc().unwrap().history.undo.len();
+    for bad in [json!("here"), json!([1]), json!(["1", "2"]), json!([1, 2, 3]), json!(null)] {
+        assert!(s.execute("edit.paste", &json!({"artboardsAt": bad})).is_err(), "{bad}");
+    }
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps);
+    let r = s.execute("edit.paste", &json!({"artboardsAt": [5000.0, 7000.0]})).unwrap();
+    assert_eq!(r["artboards"], json!([2, 3]));
+    let d = &s.doc().unwrap().doc;
+    let together = d.artboards[2].rect.union(d.artboards[3].rect).center();
+    assert_eq!((together.x, together.y), (5000.0, 7000.0));
+    assert_eq!(d.artboards[3].rect.x0 - d.artboards[2].rect.x0, 1000.0, "as they lay");
+}
+
 /// The artboards' left edges and names.
 fn boards(s: &Session) -> Vec<(f64, String)> {
     s.doc().unwrap().doc.artboards.iter().map(|a| (a.rect.x0, a.name.clone())).collect()
diff --git a/crates/engine/src/tests/perspgrid.rs b/crates/engine/src/tests/perspgrid.rs
index b2cb7cba9..07fce547d 100644
--- a/crates/engine/src/tests/perspgrid.rs
+++ b/crates/engine/src/tests/perspgrid.rs
@@ -342,6 +342,23 @@ fn lock_station_point_swings_the_other_vanishing_point() {
     assert!(n.viewing_angle() < 45.0);
 }
 
+#[test]
+fn a_grid_dragged_off_its_preset_reports_no_preset_name() {
+    let mut s = session();
+    run(&mut s, "perspective.grid.preset", json!({"name": "[1P-Normal View]"}));
+    let name = |s: &mut Session| run(s, "perspective.grid.get", json!({}))["define"]["name"].clone();
+    assert_eq!(name(&mut s), json!("[1P-Normal View]"));
+    // Moving a plane keeps the definition: still the preset.
+    run(&mut s, "perspective.plane.move", json!({"plane": "ground", "by": 50}));
+    assert_eq!(name(&mut s), json!("[1P-Normal View]"));
+    let g = grid(&s);
+    drag(&mut s, "perspectiveGrid", Point::new(g.vp_left, g.horizon), Point::new(g.vp_left - 40.0, g.horizon - 60.0));
+    assert!(!near(grid(&s).horizon, g.horizon), "the horizon moved");
+    assert_eq!(name(&mut s), json!(""), "a custom grid now");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(name(&mut s), json!("[1P-Normal View]"));
+}
+
 #[test]
 fn snap_to_grid_lands_drawn_and_moved_art_on_gridlines() {
     let mut s = session();
diff --git a/crates/engine/src/tests/place.rs b/crates/engine/src/tests/place.rs
index 3c86e513e..39e13ee40 100644
--- a/crates/engine/src/tests/place.rs
+++ b/crates/engine/src/tests/place.rs
@@ -662,6 +662,98 @@ fn placed_art_brings_its_symbols_and_swatches_renaming_on_conflict() {
     assert!(linked, "still linked to the swatch it brought");
 }
 
+#[test]
+fn placed_art_brings_its_brushes_renaming_on_conflict() {
+    // The file: a path with its own brush, and one with a brush the defaults hold.
+    let mut src = session();
+    src.execute("brush.new", &json!({"type": "calligraphic", "name": "Nib", "params": {"angle": 20, "roundness": 30, "size": 8}})).unwrap();
+    src.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+    src.execute("brush.apply", &json!({"name": "Nib"})).unwrap();
+    src.execute("shape.rectangle", &json!({"x": 50, "y": 10, "width": 20, "height": 20})).unwrap();
+    src.execute("brush.apply", &json!({"name": "Charcoal"})).unwrap();
+    let bytes = serialize(&mut src, "vectorcraft");
+    let brushes = |n: &Node| {
+        let mut names = vec![];
+        n.walk(&mut |c| names.extend(c.appearance.stroke().and_then(|st| st.brush.clone())));
+        names
+    };
+    // A document with a different "Nib".
+    let mut s = session();
+    s.execute("brush.new", &json!({"type": "calligraphic", "name": "Nib", "params": {"angle": 90, "roundness": 100, "size": 2}})).unwrap();
+    let before = s.execute("brush.list", &json!({})).unwrap()["brushes"].as_array().unwrap().len();
+    let r = place(&mut s, "art.vectorcraft", &bytes, json!({"crop": "bounding"}));
+    assert_eq!(brushes(&node(&s, &r["ids"][0])), ["Nib 2", "Charcoal"]);
+    assert_eq!(s.execute("brush.get", &json!({"name": "Nib"})).unwrap()["size"], json!(2.0), "its own stays");
+    assert_eq!(s.execute("brush.get", &json!({"name": "Nib 2"})).unwrap()["size"], json!(8.0));
+    assert_eq!(s.execute("brush.list", &json!({})).unwrap()["brushes"].as_array().unwrap().len(), before + 1, "the same Charcoal is shared");
+    // A document without it gets it as it is.
+    let mut fresh = session();
+    let r = place(&mut fresh, "art.vectorcraft", &bytes, json!({"crop": "bounding"}));
+    assert_eq!(brushes(&node(&fresh, &r["ids"][0])), ["Nib", "Charcoal"]);
+    assert_eq!(fresh.execute("brush.get", &json!({"name": "Nib"})).unwrap()["size"], json!(8.0));
+    // The name a conflict would take is not one the art already uses.
+    src.execute("brush.new", &json!({"type": "calligraphic", "name": "Nib 2", "params": {"angle": 40, "roundness": 50, "size": 5}})).unwrap();
+    src.execute("shape.rectangle", &json!({"x": 90, "y": 10, "width": 20, "height": 20})).unwrap();
+    src.execute("brush.apply", &json!({"name": "Nib 2"})).unwrap();
+    let bytes = serialize(&mut src, "vectorcraft");
+    let mut s = session();
+    s.execute("brush.new", &json!({"type": "calligraphic", "name": "Nib", "params": {"angle": 90, "roundness": 100, "size": 2}})).unwrap();
+    let r = place(&mut s, "art.vectorcraft", &bytes, json!({"crop": "bounding"}));
+    assert_eq!(brushes(&node(&s, &r["ids"][0])), ["Nib 3", "Charcoal", "Nib 2"]);
+    assert_eq!(s.execute("brush.get", &json!({"name": "Nib 3"})).unwrap()["size"], json!(8.0));
+    assert_eq!(s.execute("brush.get", &json!({"name": "Nib 2"})).unwrap()["size"], json!(5.0));
+}
+
+/// A placed brush whose art uses an image the document holds under the same key, with other pixels,
+/// isn't the document's brush of that name, though the two brushes read the same.
+#[test]
+fn a_placed_brush_whose_art_uses_a_renamed_image_is_copied() {
+    let file = |pixel: u8| {
+        let mut png = vec![];
+        image::GrayImage::from_pixel(2, 1, image::Luma([pixel])).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+        let mut s = session();
+        s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+        s.edit("Brush", |d, _| {
+            d.images.insert("k".into(), vectorcraft_doc::ImageBlob { mime: "image/png".into(), bytes: Arc::new(png), proxy: None });
+            let im = vectorcraft_doc::ImageObject {
+                key: "k".into(),
+                width: 2,
+                height: 1,
+                xf: Default::default(),
+                link: None,
+                placement: Default::default(),
+                pixels: None,
+            };
+            let art = Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)));
+            let brush = vectorcraft_brush::Scatter { art, ..Default::default() };
+            vectorcraft_brush::store(d, &[vectorcraft_brush::Brush { name: "Speck".into(), kind: vectorcraft_brush::BrushKind::Scatter(brush) }]);
+            Ok(())
+        })
+        .unwrap();
+        s.execute("brush.apply", &json!({"name": "Speck"})).unwrap();
+        serialize(&mut s, "vectorcraft")
+    };
+    let mut s = session();
+    let first = place(&mut s, "one.vectorcraft", &file(0), json!({"crop": "bounding"}));
+    let second = place(&mut s, "two.vectorcraft", &file(255), json!({"crop": "bounding"}));
+    let brush_of = |r: &Value| {
+        let mut name = None;
+        node(&s, &r["ids"][0]).walk(&mut |c| name = name.take().or_else(|| c.appearance.stroke().and_then(|st| st.brush.clone())));
+        name
+    };
+    assert_eq!(brush_of(&first).as_deref(), Some("Speck"));
+    assert_eq!(brush_of(&second).as_deref(), Some("Speck 2"));
+    let doc = &s.doc().unwrap().doc;
+    let key = |name: &str| {
+        let Some(vectorcraft_brush::Brush { kind: vectorcraft_brush::BrushKind::Scatter(b), .. }) = vectorcraft_brush::find(doc, name) else {
+            panic!("{name}")
+        };
+        let NodeKind::Image(im) = &b.art.kind else { panic!("{name}: {:?}", b.art.kind_label()) };
+        im.key.clone()
+    };
+    assert_eq!((key("Speck"), key("Speck 2")), ("k".to_string(), "k 2".to_string()));
+}
+
 #[test]
 fn info_reports_size_resolution_colour_mode_and_link() {
     let mut s = session();
diff --git a/crates/engine/src/tests/prefs.rs b/crates/engine/src/tests/prefs.rs
index dcd1bd6a1..4b5848bcf 100644
--- a/crates/engine/src/tests/prefs.rs
+++ b/crates/engine/src/tests/prefs.rs
@@ -173,6 +173,98 @@ fn reset_category_and_all() {
     assert!(s.execute("prefs.reset", &json!({"category": "Bogus"})).is_err());
 }
 
+/// `prefs.set` refuses a recovery or plug-ins folder that is missing or is a file. Nothing changes,
+/// other values in the same call included, and the document gets no undo step.
+#[test]
+fn set_refuses_a_missing_folder_or_a_file_as_a_recovery_or_plugins_folder() {
+    let folder = crate::tests_links::Folder::new("prefs-set-refused");
+    let file = folder.file("not-a-folder.txt");
+    std::fs::write(&file, b"x").unwrap();
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
+    let before = s.prefs.clone();
+    let undo = s.doc().unwrap().history.undo.len();
+    for key in ["recoveryFolder", "pluginsFolder"] {
+        for path in [file.clone(), folder.file("missing")] {
+            let e = s.execute("prefs.set", &json!({"key": key, "value": path})).unwrap_err();
+            assert_eq!(e.to_string(), format!("{path} is not a folder"), "{key}");
+            let e = s.execute("prefs.set", &json!({"values": {key: path, "keyboardIncrement": 7, "unitsGeneral": "millimeters"}})).unwrap_err();
+            assert_eq!(e.to_string(), format!("{path} is not a folder"), "{key}");
+            assert_eq!(s.prefs, before, "{key}: no preference changes");
+            assert_eq!(s.doc().unwrap().history.undo.len(), undo, "{key}: no undo step");
+        }
+    }
+}
+
+/// `prefs.set` refuses a recovery folder that no folder can be created in or that can't be listed,
+/// and a plug-ins folder that can't be listed.
+#[cfg(unix)]
+#[test]
+fn set_refuses_a_recovery_or_plugins_folder_it_cannot_use() {
+    use std::os::unix::fs::PermissionsExt;
+    /// Gives a folder mode 0o755 again when dropped, also when an assertion fails, so the test
+    /// folder can be removed.
+    struct Unlock(std::path::PathBuf);
+    impl Drop for Unlock {
+        fn drop(&mut self) {
+            let _ = std::fs::set_permissions(&self.0, std::fs::Permissions::from_mode(0o755));
+        }
+    }
+    let folder = crate::tests_links::Folder::new("prefs-set-unusable");
+    let mut s = Session::new();
+    let before = s.prefs.clone();
+    let locked = folder.0.join("locked");
+    std::fs::create_dir(&locked).unwrap();
+    let unlock_locked = Unlock(locked.clone());
+    std::fs::set_permissions(&locked, std::fs::Permissions::from_mode(0o555)).unwrap();
+    // An account that may write anyway (root) has nothing to refuse.
+    if std::fs::create_dir(locked.join("probe")).is_err() {
+        let e = s.execute("prefs.set", &json!({"key": "recoveryFolder", "value": locked.to_string_lossy()})).unwrap_err();
+        assert!(e.to_string().starts_with("Data Recovery can't keep copies in "), "{e}");
+    }
+    drop(unlock_locked);
+    let unlisted = folder.0.join("unlisted");
+    std::fs::create_dir(&unlisted).unwrap();
+    let unlock_unlisted = Unlock(unlisted.clone());
+    std::fs::set_permissions(&unlisted, std::fs::Permissions::from_mode(0o333)).unwrap();
+    // An account that may list anyway (root) has nothing to refuse.
+    if std::fs::read_dir(&unlisted).is_err() {
+        let e = s.execute("prefs.set", &json!({"key": "recoveryFolder", "value": unlisted.to_string_lossy()})).unwrap_err();
+        assert!(e.to_string().starts_with("Data Recovery can't keep copies in "), "{e}");
+        let e = s.execute("prefs.set", &json!({"key": "pluginsFolder", "value": unlisted.to_string_lossy()})).unwrap_err();
+        assert!(e.to_string().starts_with("Plug-ins can't be loaded from "), "{e}");
+    }
+    drop(unlock_unlisted);
+    assert_eq!(s.prefs, before);
+}
+
+/// `prefs.set` saves a folder that passes as given and leaves nothing behind in it. An empty value
+/// and a folder the preference already holds are not checked, nor is a held folder when the call
+/// leaves it out, so they work while the folder is unavailable.
+#[test]
+fn set_takes_a_usable_empty_or_already_held_recovery_folder() {
+    let folder = crate::tests_links::Folder::new("prefs-set-usable");
+    let mut s = Session::new();
+    let typed = format!(" {} ", folder.0.display());
+    s.execute("prefs.set", &json!({"key": "recoveryFolder", "value": typed})).unwrap();
+    assert_eq!(s.prefs.recovery_folder, typed);
+    assert_eq!(std::fs::read_dir(&folder.0).unwrap().count(), 0, "the write check leaves nothing behind");
+
+    let gone = folder.0.join("gone");
+    std::fs::create_dir(&gone).unwrap();
+    let gone = gone.to_string_lossy().into_owned();
+    s.execute("prefs.set", &json!({"key": "recoveryFolder", "value": gone})).unwrap();
+    std::fs::remove_dir(&gone).unwrap();
+    s.execute("prefs.set", &json!({"values": {"recoveryFolder": gone, "keyboardIncrement": 7}})).unwrap();
+    s.execute("prefs.set", &json!({"key": "keyboardIncrement", "value": 3})).unwrap();
+    assert_eq!((s.prefs.recovery_folder.as_str(), s.prefs.keyboard_increment), (gone.as_str(), 3.0));
+
+    for key in ["recoveryFolder", "pluginsFolder"] {
+        s.execute("prefs.set", &json!({"key": key, "value": ""})).unwrap();
+        assert_eq!(s.prefs.to_json()[key], json!(""), "{key}");
+    }
+}
+
 #[test]
 fn list_describes_every_pref() {
     let mut s = Session::new();
diff --git a/crates/engine/src/tests/shapetools.rs b/crates/engine/src/tests/shapetools.rs
new file mode 100644
index 000000000..3c7d34a4f
--- /dev/null
+++ b/crates/engine/src/tests/shapetools.rs
@@ -0,0 +1,169 @@
+//! Shape tools: the selection they keep on show moves by its centre point (Attributes › Show
+//! Center) and turns from the rotate zone just outside a corner of its box, as the Selection
+//! tool's do, through the whole engine (#5477).
+
+use serde_json::json;
+use vectorcraft_doc::{LiveShape, NodeKind};
+use vectorcraft_geom::{Point, Rect, Vec2};
+use vectorcraft_tools::{Mods, PointerEvent, PointerKind, ToolKey};
+
+use crate::*;
+
+/// A new 400 × 400 pt document.
+fn new_doc() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+    s
+}
+
+/// The view the gestures run in: page coordinates, with Smart Guides off so nothing snaps.
+fn view() -> ViewInfo {
+    ViewInfo { smart_guides: false, ..ViewInfo::default() }
+}
+
+/// Feed the pointer events `(kind, x, y)`, all with `mods` held, to the active tool.
+fn gesture(s: &mut Session, mods: Mods, events: &[(PointerKind, f64, f64)]) {
+    for (k, x, y) in events {
+        s.pointer(&PointerEvent::new(*k, *x, *y).with_mods(mods), view()).unwrap();
+    }
+}
+
+/// No modifier held.
+const NONE: Mods = Mods { shift: false, alt: false, cmd: false, ctrl: false, space: false };
+
+/// A 100 × 80 pt rectangle drawn from (100, 100) to (200, 180) with the Rectangle tool, still
+/// selected: its centre point is at (150, 140).
+fn drawn_rect(s: &mut Session) -> NodeId {
+    s.select_tool("rectangle", view()).unwrap();
+    gesture(s, NONE, &[(PointerKind::Down, 100.0, 100.0), (PointerKind::Drag, 200.0, 180.0), (PointerKind::Up, 200.0, 180.0)]);
+    *s.doc().unwrap().selection.objects.first().expect("the drawn rectangle is selected")
+}
+
+/// The geometric bounds of `id`.
+fn bounds(s: &Session, id: NodeId) -> Rect {
+    s.doc().unwrap().doc.bounds_of(&[id], false).expect("bounds")
+}
+
+/// The angle of `id`'s bounding box, in degrees counter-clockwise: 0 for art square to the page.
+fn angle(s: &Session, id: NodeId) -> f64 {
+    s.doc().unwrap().doc.oriented_bounds(&[id], false).map_or(0.0, |b| b.angle)
+}
+
+/// How many undo steps the active document's history holds.
+fn undo_steps(s: &Session) -> usize {
+    s.doc().unwrap().history.undo.len()
+}
+
+/// With the Rectangle tool still active, a drag from the shape's centre point moves it, in one
+/// undo step; Alt-dragging it copies it; Escape turns a drag back.
+#[test]
+fn a_shape_tool_moves_the_shape_from_its_centre_point() {
+    let mut s = new_doc();
+    let id = drawn_rect(&mut s);
+    let before = bounds(&s, id);
+    let steps = undo_steps(&s);
+    gesture(
+        &mut s,
+        NONE,
+        &[(PointerKind::Down, 150.0, 140.0), (PointerKind::Drag, 170.0, 160.0), (PointerKind::Drag, 180.0, 170.0), (PointerKind::Up, 180.0, 170.0)],
+    );
+    assert_eq!(bounds(&s, id), before + Vec2::new(30.0, 30.0), "moved by the drag");
+    assert_eq!(undo_steps(&s), steps + 1, "one undo step");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(bounds(&s, id), before);
+    // Alt-dragging from the centre leaves a copy where the original was, in one undo step.
+    let steps = undo_steps(&s);
+    gesture(
+        &mut s,
+        Mods { alt: true, ..NONE },
+        &[(PointerKind::Down, 150.0, 140.0), (PointerKind::Drag, 200.0, 140.0), (PointerKind::Up, 200.0, 140.0)],
+    );
+    let objects = |s: &Session| s.doc().unwrap().doc.layers[0].children().map(|c| c.len()).unwrap_or_default();
+    assert_eq!(objects(&s), 2, "a copy");
+    assert_eq!(undo_steps(&s), steps + 1, "one undo step for the copy");
+    let copy = *s.doc().unwrap().selection.objects.first().expect("the copy is selected");
+    assert_eq!(bounds(&s, id), before, "the original stays");
+    assert_eq!(bounds(&s, copy), before + Vec2::new(50.0, 0.0), "the copy moved");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(objects(&s), 1, "undone");
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert_eq!(objects(&s), 2, "redone");
+    // Escape turns the drag back, and the release leaves the art alone.
+    let steps = undo_steps(&s);
+    let moved = s.doc().unwrap().selection.objects.clone();
+    let copy = *moved.first().expect("the copy is selected");
+    let at = bounds(&s, copy);
+    gesture(&mut s, NONE, &[(PointerKind::Down, 200.0, 140.0), (PointerKind::Drag, 250.0, 190.0)]);
+    s.tool_key(ToolKey::Escape, NONE, view()).unwrap();
+    gesture(&mut s, NONE, &[(PointerKind::Up, 250.0, 190.0)]);
+    assert_eq!(undo_steps(&s), steps, "no step");
+    assert_eq!(s.doc().unwrap().selection.objects, moved);
+    assert_eq!(bounds(&s, copy), at, "back where it was");
+}
+
+/// Alt pressed once the drag has begun turns the move into a copy, as the Selection tool's.
+#[test]
+fn alt_pressed_mid_drag_copies_the_shape() {
+    let mut s = new_doc();
+    let id = drawn_rect(&mut s);
+    let before = bounds(&s, id);
+    gesture(&mut s, NONE, &[(PointerKind::Down, 150.0, 140.0), (PointerKind::Drag, 170.0, 140.0)]);
+    gesture(&mut s, Mods { alt: true, ..NONE }, &[(PointerKind::Drag, 200.0, 140.0), (PointerKind::Up, 200.0, 140.0)]);
+    assert_eq!(s.doc().unwrap().doc.layers[0].children().map(|c| c.len()).unwrap_or_default(), 2, "a copy");
+    assert_eq!(bounds(&s, id), before, "the original stays");
+    let copy = *s.doc().unwrap().selection.objects.first().expect("the copy is selected");
+    assert_eq!(bounds(&s, copy), before + Vec2::new(50.0, 0.0), "the copy moved by the whole drag");
+}
+
+/// A press in the rotate zone just outside a corner of the shape's box turns it about that box's
+/// centre, as the Selection tool's does; a press on the corner itself still rounds it.
+#[test]
+fn a_shape_tool_turns_the_shape_from_just_outside_a_corner() {
+    let mut s = new_doc();
+    let id = drawn_rect(&mut s);
+    // 8.49 pt outside the top-left corner (100, 100), past the handle's 5 pt square.
+    gesture(
+        &mut s,
+        NONE,
+        &[(PointerKind::Down, 94.0, 94.0), (PointerKind::Drag, 150.0, 70.0), (PointerKind::Drag, 150.0, 70.0), (PointerKind::Up, 150.0, 70.0)],
+    );
+    let turned = angle(&s, id);
+    assert!(turned.abs() > 1.0, "turned: {turned}");
+    let centre = bounds(&s, id).center();
+    assert!((centre - Point::new(150.0, 140.0)).hypot() < 1e-6, "about its centre: {centre:?}");
+    // One undo step for the turn, and Redo turns it again.
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(angle(&s, id), 0.0, "undone");
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert!((angle(&s, id) - turned).abs() < 1e-9, "redone");
+    s.execute("edit.undo", &json!({})).unwrap();
+    // A press on a Live Corners widget rounds it, as before (#5477): the widget keeps the corner,
+    // and sits 10 pt inside it.
+    let mut s = new_doc();
+    let id = drawn_rect(&mut s);
+    gesture(&mut s, NONE, &[(PointerKind::Down, 110.0, 110.0), (PointerKind::Drag, 125.0, 125.0), (PointerKind::Up, 125.0, 125.0)]);
+    let n = s.doc().unwrap().doc.node(id).expect("the rectangle");
+    let NodeKind::Path { live: Some(live), .. } = &n.kind else { panic!("a live shape: {:?}", n.kind) };
+    let LiveShape::Rectangle { radii, .. } = &**live else { panic!("a rectangle") };
+    assert!(radii[0] > 0.0, "the corner rounded: {radii:?}");
+    assert_eq!(angle(&s, id), 0.0, "rounding does not turn it");
+}
+
+/// The Selection tool takes the centre point of an unfilled shape too: a drag there moves it
+/// instead of starting a marquee.
+#[test]
+fn the_selection_tool_moves_an_unfilled_shape_from_its_centre_point() {
+    let mut s = new_doc();
+    let id = NodeId(s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 100, "height": 80})).unwrap()["id"].as_u64().unwrap());
+    s.execute("paint.setFill", &json!({"none": true})).unwrap();
+    s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
+    s.select_tool("selection", view()).unwrap();
+    let before = bounds(&s, id);
+    gesture(&mut s, NONE, &[(PointerKind::Down, 150.0, 140.0), (PointerKind::Drag, 170.0, 160.0), (PointerKind::Up, 170.0, 160.0)]);
+    assert_eq!(bounds(&s, id), before + Vec2::new(20.0, 20.0));
+    // Away from it, a drag is still a marquee.
+    let steps = undo_steps(&s);
+    gesture(&mut s, NONE, &[(PointerKind::Down, 300.0, 300.0), (PointerKind::Drag, 350.0, 350.0), (PointerKind::Up, 350.0, 350.0)]);
+    assert_eq!(undo_steps(&s), steps, "a marquee changes no art");
+    assert!(s.doc().unwrap().selection.objects.is_empty(), "the marquee took nothing");
+}
diff --git a/crates/engine/src/tests/swatchlib.rs b/crates/engine/src/tests/swatchlib.rs
index 23980c5d5..3ecb5e68e 100644
--- a/crates/engine/src/tests/swatchlib.rs
+++ b/crates/engine/src/tests/swatchlib.rs
@@ -792,6 +792,134 @@ fn a_library_named_like_a_device_keeps_the_library_with_its_file_name() {
     }
 }
 
+/// `.ase` keeps no title, so a library's name comes back from its file name. Whichever is saved
+/// first, `COM¹` and `COM¹-` keep a file each, and saving either again replaces only itself. After
+/// a restart neither can be told from the other, so each gets a new file and replaces neither.
+#[test]
+fn device_named_libraries_without_a_title_keep_their_own_files() {
+    for (first, second) in [("COM¹", "COM¹-"), ("COM¹-", "COM¹")] {
+        let dir = temp_dir("device-ase");
+        let mut s = session();
+        s.swatch_libraries.set_user_dir(Some(dir.to_string_lossy().to_string()));
+        let save = |s: &mut Session, name: &str| {
+            run(s, "swatch.library.save", json!({"user": true, "name": name, "format": "ase"}))["library"].as_str().unwrap().to_string()
+        };
+        let a = save(&mut s, first);
+        assert_eq!(save(&mut s, first), a, "saving {first} again replaces {first}");
+        let b = save(&mut s, second);
+        assert_ne!(a, b);
+        assert_eq!(save(&mut s, first), a, "saving {first} again replaces {first}");
+        assert_eq!(save(&mut s, second), b, "saving {second} again replaces {second}");
+        assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 2);
+        // The next time the app starts.
+        s.swatch_libraries.set_user_dir(Some(dir.to_string_lossy().to_string()));
+        for (name, count) in [(first, 3), (second, 4)] {
+            let again = save(&mut s, name);
+            assert!(again != a && again != b, "{name}: {again}");
+            assert_eq!(save(&mut s, name), again, "saving {name} again replaces {name}");
+            assert_eq!(std::fs::read_dir(&dir).unwrap().count(), count);
+        }
+        // The numbered file is as unknown as the first.
+        s.swatch_libraries.set_user_dir(Some(dir.to_string_lossy().to_string()));
+        let numbered = b.strip_prefix("user/").unwrap().strip_suffix(".ase").unwrap().to_string();
+        assert_ne!(save(&mut s, &numbered), b);
+        assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 5);
+        // Any other name goes on replacing its own file after a restart.
+        let other = save(&mut s, "Greys");
+        s.swatch_libraries.set_user_dir(Some(dir.to_string_lossy().to_string()));
+        assert_eq!(save(&mut s, "Greys"), other);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
+
+/// A file this session saved for `COM¹`, then replaced, is not written over. The next save goes to
+/// a new file and stays there. That holds for `.ase` and `.gpl`, for bytes that still read as a
+/// library and for bytes that don't, including the file the library moved to. A file removed and
+/// put back is still its library's when the bytes are the ones written, and is kept when they are
+/// not. A name that is not a device name still replaces a file that cannot be read.
+#[test]
+fn a_replaced_device_library_file_is_kept() {
+    for format in ["ase", "gpl"] {
+        let other: Vec<u8> = if format == "ase" {
+            vectorcraft_testkit::ase::ase(&[vectorcraft_testkit::ase::Block::Color("Only", b"RGB ", &[1.0, 0.0, 0.0], 2)])
+        } else {
+            b"GIMP Palette\nName: Other\n0 0 0 Black\n".to_vec()
+        };
+        let save = |s: &mut Session| run(s, "swatch.library.save", json!({"user": true, "name": "COM¹", "format": format}));
+        let open = |name: &str| {
+            let dir = temp_dir(name);
+            let mut s = session();
+            s.swatch_libraries.set_user_dir(Some(dir.to_string_lossy().to_string()));
+            (dir, s)
+        };
+
+        // Replaced with another library.
+        let (dir, mut s) = open(&format!("replaced-lib-{format}"));
+        let first = save(&mut s);
+        let first_id = first["library"].as_str().unwrap().to_string();
+        let first_path = first["path"].as_str().unwrap().to_string();
+        assert_ne!(std::fs::read(&first_path).unwrap(), other);
+        std::fs::write(&first_path, &other).unwrap();
+        let moved = save(&mut s);
+        let moved_id = moved["library"].as_str().unwrap().to_string();
+        assert_ne!(moved_id, first_id);
+        assert_eq!(std::fs::read(&first_path).unwrap(), other, "{format}: the replaced file is left as it is");
+        assert_eq!(save(&mut s)["library"].as_str(), Some(moved_id.as_str()), "{format}: saving again replaces the new file");
+        let _ = std::fs::remove_dir_all(&dir);
+
+        // Replaced with bytes that are not a library, first the file it had, then the one it moved to.
+        let (dir, mut s) = open(&format!("replaced-unread-{format}"));
+        let first = save(&mut s);
+        let first_path = first["path"].as_str().unwrap().to_string();
+        std::fs::write(&first_path, b"not a library").unwrap();
+        let moved = save(&mut s);
+        let moved_id = moved["library"].as_str().unwrap().to_string();
+        let first_id = first["library"].as_str().unwrap();
+        assert_ne!(moved_id, first_id);
+        assert_eq!(std::fs::read(&first_path).unwrap(), b"not a library");
+        assert_eq!(save(&mut s)["library"].as_str(), Some(moved_id.as_str()), "{format}: saving again stays on the new file");
+        let moved_path = moved["path"].as_str().unwrap().to_string();
+        std::fs::write(&moved_path, b"still not").unwrap();
+        let again = save(&mut s);
+        let again_id = again["library"].as_str().unwrap().to_string();
+        assert!(again_id != moved_id && again_id != first_id);
+        assert_eq!(std::fs::read(&moved_path).unwrap(), b"still not");
+        assert_eq!(save(&mut s)["library"].as_str(), Some(again_id.as_str()));
+        let _ = std::fs::remove_dir_all(&dir);
+
+        // Removed, the folder listed again, then put back: the hash is checked when it reappears.
+        let (dir, mut s) = open(&format!("replaced-reappear-{format}"));
+        let first = save(&mut s);
+        let first_id = first["library"].as_str().unwrap().to_string();
+        let first_path = first["path"].as_str().unwrap().to_string();
+        let written = std::fs::read(&first_path).unwrap();
+        std::fs::remove_file(&first_path).unwrap();
+        run(&mut s, "swatch.library.list", json!({}));
+        std::fs::write(&first_path, &written).unwrap();
+        assert_eq!(save(&mut s)["library"].as_str(), Some(first_id.as_str()), "{format}: the same bytes are still this library");
+        std::fs::remove_file(&first_path).unwrap();
+        run(&mut s, "swatch.library.list", json!({}));
+        std::fs::write(&first_path, &other).unwrap();
+        let moved = save(&mut s);
+        let moved_id = moved["library"].as_str().unwrap().to_string();
+        assert_ne!(moved_id, first_id);
+        assert_eq!(std::fs::read(&first_path).unwrap(), other, "{format}: different bytes put back are kept");
+        assert_eq!(save(&mut s)["library"].as_str(), Some(moved_id.as_str()));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    let dir = temp_dir("replaced-ordinary");
+    let mut s = session();
+    s.swatch_libraries.set_user_dir(Some(dir.to_string_lossy().to_string()));
+    let first = run(&mut s, "swatch.library.save", json!({"user": true, "name": "Greys", "format": "gpl"}));
+    let path = first["path"].as_str().unwrap().to_string();
+    std::fs::write(&path, b"not a library").unwrap();
+    let again = run(&mut s, "swatch.library.save", json!({"user": true, "name": "Greys", "format": "gpl"}));
+    assert_eq!(again["library"], first["library"], "a name that is not a device name replaces its own unreadable file");
+    assert!(std::fs::read(&path).unwrap().starts_with(b"GIMP Palette"));
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
 /// #3602: a library titled with a Windows device name is saved under a name that is not one.
 #[test]
 fn a_library_file_name_is_never_a_windows_device_name() {
diff --git a/crates/engine/src/tests/textedit.rs b/crates/engine/src/tests/textedit.rs
index dde0c4bf5..ed3e2eac3 100644
--- a/crates/engine/src/tests/textedit.rs
+++ b/crates/engine/src/tests/textedit.rs
@@ -1613,6 +1613,269 @@ fn the_eyedropper_styles_the_whole_story_that_select_all_selected() {
     }
 }
 
+/// A red rectangle outside the story of [`threaded_story_edited_in_its_second_frame`], to pick up
+/// from at (525, 325), with the Type tool editing frame `b` at its start again.
+fn red_source(s: &mut Session, b: NodeId) {
+    let source = s.execute("shape.rectangle", &json!({"x": 500, "y": 300, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap();
+    s.execute("paint.setFill", &json!({"ids": [source], "color": "#ff0000"})).unwrap();
+    s.execute("select.set", &json!({"ids": [b.0]})).unwrap();
+    s.set_tool_option("textSelection", &json!({"editing": b.0, "anchor": 0, "caret": 0}));
+}
+
+fn all_red(s: &Session, id: NodeId) -> bool {
+    obj(s, id).runs.iter().all(|r| r.style.fill.color().is_some_and(|c| c.to_hex() == "#ff0000"))
+}
+
+fn any_red(s: &Session, id: NodeId) -> bool {
+    obj(s, id).runs.iter().any(|r| r.style.fill.color().is_some_and(|c| c.to_hex() == "#ff0000"))
+}
+
+/// A click and a Shift-click of the Eyedropper on the rectangle of [`red_source`].
+fn eyedropper_picks() -> [Mods; 2] {
+    [Mods::default(), Mods { shift: true, ..Default::default() }]
+}
+
+fn pick_red_source(s: &mut Session, mods: Mods) {
+    s.pointer(&PointerEvent::new(PointerKind::Down, 525.0, 325.0).with_mods(mods), ViewInfo::default()).unwrap();
+}
+
+fn highlights(s: &mut Session) -> usize {
+    s.overlays(ViewInfo::default()).iter().filter(|o| matches!(o, vectorcraft_tools::Overlay::Highlight { .. })).count()
+}
+
+#[test]
+fn switching_to_the_eyedropper_keeps_the_whole_story_selected() {
+    for mods in eyedropper_picks() {
+        let (mut s, a, b, _) = threaded_story_edited_in_its_second_frame();
+        red_source(&mut s, b);
+        s.execute("select.all", &json!({})).unwrap();
+        let highlighted = highlights(&mut s);
+        s.select_tool("eyedropper", ViewInfo::default()).unwrap();
+        assert_eq!(s.tool_options()["story"], json!([a.0, b.0]));
+        assert!(highlights(&mut s) >= highlighted, "the Eyedropper highlights the text of both frames");
+        let undo = s.doc().unwrap().history.undo.len();
+        pick_red_source(&mut s, mods);
+        assert!(all_red(&s, a) && all_red(&s, b), "every frame takes the pick");
+        assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "one undo step");
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert!(!any_red(&s, a) && !any_red(&s, b), "one undo takes the pick back from every frame");
+        s.select_tool("type", ViewInfo::default()).unwrap();
+        let o = s.tool_options();
+        assert_eq!((&o["editing"], &o["story"]), (&json!(a.0), &json!([a.0, b.0])), "back in the Type tool the story stays selected");
+        s.tool_text("x", ViewInfo::default()).unwrap();
+        assert_eq!(format!("{}{}", obj(&s, a).plain_text(), obj(&s, b).plain_text()), "x", "typing replaces the whole story");
+    }
+}
+
+#[test]
+fn a_selection_inside_one_threaded_frame_stays_in_that_frame_under_the_eyedropper() {
+    for mods in eyedropper_picks() {
+        let (mut s, a, b, _) = threaded_story_edited_in_its_second_frame();
+        red_source(&mut s, b);
+        s.set_tool_option("select", &json!({"start": 0, "end": 4}));
+        s.select_tool("eyedropper", ViewInfo::default()).unwrap();
+        assert!(s.tool_options().get("story").is_none());
+        let undo = s.doc().unwrap().history.undo.len();
+        pick_red_source(&mut s, mods);
+        assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
+        assert_eq!(obj(&s, b).runs[0].text.len(), 4, "only the selected characters take the pick");
+        assert!(any_red(&s, b) && !all_red(&s, b) && !any_red(&s, a));
+        s.select_tool("type", ViewInfo::default()).unwrap();
+        let o = s.tool_options();
+        assert_eq!((o["editing"].as_u64(), o["start"].as_u64(), o["end"].as_u64()), (Some(b.0), Some(0), Some(4)));
+    }
+}
+
+#[test]
+fn an_eyedropper_pick_on_the_whole_story_styles_locked_and_hidden_frames() {
+    for command in ["object.lock", "object.hide"] {
+        for held_first in [false, true] {
+            for mods in eyedropper_picks() {
+                let (mut s, a, b, _) = threaded_story_edited_in_its_second_frame();
+                let (held, other) = if held_first { (a, b) } else { (b, a) };
+                s.execute(command, &json!({"ids": [held.0]})).unwrap();
+                red_source(&mut s, other);
+                assert_eq!(s.execute("select.all", &json!({})).unwrap()["story"], json!([a.0, b.0]));
+                s.select_tool("eyedropper", ViewInfo::default()).unwrap();
+                let undo = s.doc().unwrap().history.undo.len();
+                pick_red_source(&mut s, mods);
+                assert!(all_red(&s, other), "{command}: the other frame takes the pick");
+                assert!(all_red(&s, held), "{command}: the held frame takes the pick");
+                assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "{command}: one undo step");
+            }
+        }
+    }
+}
+
+#[test]
+fn an_eyedropper_pick_from_a_frame_of_the_selected_story_styles_the_other_frames() {
+    for source_first in [false, true] {
+        let (mut s, a, b, _) = threaded_story_edited_in_its_second_frame();
+        let (source, other) = if source_first { (a, b) } else { (b, a) };
+        s.execute("text.setStyle", &json!({"ids": [source.0], "fill": "#ff0000"})).unwrap();
+        assert!(all_red(&s, source) && !any_red(&s, other));
+        s.execute("select.set", &json!({"ids": [b.0]})).unwrap();
+        s.set_tool_option("textSelection", &json!({"editing": b.0, "anchor": 0, "caret": 0}));
+        s.execute("select.all", &json!({})).unwrap();
+        s.select_tool("eyedropper", ViewInfo::default()).unwrap();
+        let undo = s.doc().unwrap().history.undo.len();
+        let r = s.execute("appearance.copyFrom", &json!({"source": source.0})).unwrap();
+        assert_eq!(r, json!({"ids": [other.0]}));
+        assert!(all_red(&s, other) && all_red(&s, source));
+        assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
+    }
+}
+
+/// Whether a character in the frame that `text.thread.add` places at [`THREADED_AT`] is highlighted.
+fn third_frame_highlighted(s: &mut Session) -> bool {
+    let in_frame = |o: &vectorcraft_tools::Overlay| matches!(o, vectorcraft_tools::Overlay::Highlight { quad, color: [60, 120, 255, 90] } if quad.iter().all(|p| p.x > 690.0));
+    s.overlays(ViewInfo::default()).iter().any(in_frame)
+}
+
+/// Where a third frame of the story of [`threaded_story_edited_in_its_second_frame`] goes, clear
+/// of its other frames.
+const THREADED_AT: [f64; 2] = [700.0, 10.0];
+
+#[test]
+fn a_frame_threaded_into_the_selected_story_is_highlighted_and_takes_the_edit() {
+    for mods in eyedropper_picks() {
+        let (mut s, a, b, _) = threaded_story_edited_in_its_second_frame();
+        red_source(&mut s, b);
+        s.execute("select.all", &json!({})).unwrap();
+        s.select_tool("eyedropper", ViewInfo::default()).unwrap();
+        let c = s.execute("text.thread.add", &json!({"from": a.0, "before": true, "at": THREADED_AT})).unwrap()["id"].as_u64().unwrap();
+        let c = NodeId(c);
+        assert!(!obj(&s, c).plain_text().is_empty(), "the story starts in the new frame");
+        assert!(third_frame_highlighted(&mut s), "the new frame's text is highlighted");
+        pick_red_source(&mut s, mods);
+        assert!(all_red(&s, a) && all_red(&s, b) && all_red(&s, c), "every frame takes the pick");
+        s.select_tool("type", ViewInfo::default()).unwrap();
+        assert!(third_frame_highlighted(&mut s), "back in the Type tool too");
+        s.tool_text("x", ViewInfo::default()).unwrap();
+        let text = [a, b, c].map(|f| obj(&s, f).plain_text()).concat();
+        assert_eq!(text, "x", "typing replaces the text of every frame");
+    }
+}
+
+/// After Select All in the story of [`threaded_story_edited_in_its_second_frame`], a frame threaded
+/// in before the edited one takes the whole story, and the edited frame holds no text.
+fn selected_story_moved_into_a_new_frame(s: &mut Session, a: NodeId, b: NodeId) -> NodeId {
+    let rect = [THREADED_AT[0], THREADED_AT[1], 400.0, 600.0];
+    let c = NodeId(s.execute("text.thread.add", &json!({"from": a.0, "before": true, "rect": rect})).unwrap()["id"].as_u64().unwrap());
+    assert!(obj(s, a).plain_text().is_empty() && obj(s, b).plain_text().is_empty(), "the new frame holds the whole story");
+    assert!(!obj(s, c).plain_text().is_empty());
+    c
+}
+
+#[test]
+fn a_story_that_left_the_edited_frame_is_highlighted_and_typing_replaces_it() {
+    for through_eyedropper in [false, true] {
+        let (mut s, a, b, _) = threaded_story_edited_in_its_second_frame();
+        s.execute("select.all", &json!({})).unwrap();
+        if through_eyedropper {
+            s.select_tool("eyedropper", ViewInfo::default()).unwrap();
+        }
+        let c = selected_story_moved_into_a_new_frame(&mut s, a, b);
+        assert!(third_frame_highlighted(&mut s), "through the Eyedropper: {through_eyedropper}");
+        if through_eyedropper {
+            s.select_tool("type", ViewInfo::default()).unwrap();
+            assert!(third_frame_highlighted(&mut s), "back in the Type tool");
+        }
+        s.tool_text("x", ViewInfo::default()).unwrap();
+        assert_eq!([a, b, c].map(|f| obj(&s, f).plain_text()).concat(), "x", "through the Eyedropper: {through_eyedropper}");
+    }
+}
+
+#[test]
+fn delete_replaces_a_story_that_left_the_edited_frame() {
+    for k in [ToolKey::Backspace, ToolKey::Delete] {
+        let (mut s, a, b, story) = threaded_story_edited_in_its_second_frame();
+        s.execute("select.all", &json!({})).unwrap();
+        let c = selected_story_moved_into_a_new_frame(&mut s, a, b);
+        let steps = undo_labels(&s).len();
+        key(&mut s, k, Mods::default());
+        key(&mut s, ToolKey::Escape, Mods::default());
+        assert_eq!([a, b, c].map(|f| obj(&s, f).plain_text()).concat(), "", "{k:?} empties every frame");
+        assert_eq!(undo_labels(&s).len(), steps + 1, "{k:?}: one undo step");
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!([a, b, c].map(|f| obj(&s, f).plain_text()).concat(), story);
+    }
+}
+
+#[test]
+fn delete_in_a_story_that_holds_no_text_records_no_undo_step() {
+    for k in [ToolKey::Backspace, ToolKey::Delete] {
+        let (mut s, a, b, _) = threaded_story_edited_in_its_second_frame();
+        s.execute("select.all", &json!({})).unwrap();
+        key(&mut s, ToolKey::Delete, Mods::default());
+        s.execute("select.all", &json!({})).unwrap();
+        assert_eq!(s.tool_options()["story"], json!([a.0, b.0]));
+        let steps = undo_labels(&s).len();
+        key(&mut s, k, Mods::default());
+        key(&mut s, ToolKey::Escape, Mods::default());
+        assert_eq!(undo_labels(&s).len(), steps, "{k:?}");
+    }
+}
+
+#[test]
+fn a_type_step_keeps_a_story_that_left_the_edited_frame_selected() {
+    let (mut s, a, b, _) = threaded_story_edited_in_its_second_frame();
+    s.execute("select.all", &json!({})).unwrap();
+    let c = selected_story_moved_into_a_new_frame(&mut s, a, b);
+    // Alt+Right steps the tracking of the selected text, not the kerning at a caret.
+    key(&mut s, ToolKey::Right, Mods { alt: true, ..Mods::default() });
+    assert!(obj(&s, c).runs.iter().all(|r| r.style.tracking > 0.0), "every character of the story takes the step");
+    // A key that does nothing leaves it selected as well.
+    key(&mut s, ToolKey::BracketLeft, Mods::default());
+    assert!(third_frame_highlighted(&mut s));
+    // The story stays the target of a fill and of a switch to the Eyedropper.
+    s.execute("paint.setFill", &json!({"color": "#ff0000"})).unwrap();
+    assert!(all_red(&s, c), "the fill reaches the story");
+    s.select_tool("eyedropper", ViewInfo::default()).unwrap();
+    assert!(third_frame_highlighted(&mut s), "the Eyedropper keeps the story");
+}
+
+#[test]
+fn a_frame_that_left_the_selected_story_is_not_highlighted_and_leaves_the_edit() {
+    for mods in eyedropper_picks() {
+        let (mut s, a, b, _) = threaded_story_edited_in_its_second_frame();
+        let c = s.execute("text.thread.add", &json!({"from": b.0, "at": THREADED_AT})).unwrap()["id"].as_u64().unwrap();
+        let c = NodeId(c);
+        red_source(&mut s, b);
+        assert_eq!(s.execute("select.all", &json!({})).unwrap()["story"], json!([a.0, b.0, c.0]));
+        s.select_tool("eyedropper", ViewInfo::default()).unwrap();
+        s.execute("text.thread.break", &json!({"id": b.0, "port": "out"})).unwrap();
+        s.execute("text.setText", &json!({"id": c.0, "text": "Kept"})).unwrap();
+        assert!(!third_frame_highlighted(&mut s), "the frame that left has no highlight");
+        pick_red_source(&mut s, mods);
+        assert!(all_red(&s, a) && all_red(&s, b), "the frames still threaded take the pick");
+        assert!(!any_red(&s, c), "the frame that left stays as it is");
+        s.select_tool("type", ViewInfo::default()).unwrap();
+        s.tool_text("x", ViewInfo::default()).unwrap();
+        assert_eq!(obj(&s, c).plain_text(), "Kept", "typing leaves the frame that left");
+    }
+}
+
+#[test]
+fn typing_after_a_thread_is_removed_leaves_the_frame_that_left_the_story() {
+    for through_eyedropper in [false, true] {
+        let (mut s, _, b, _) = threaded_story_edited_in_its_second_frame();
+        s.execute("select.all", &json!({})).unwrap();
+        if through_eyedropper {
+            s.select_tool("eyedropper", ViewInfo::default()).unwrap();
+        }
+        s.execute("text.thread.remove", &json!({})).unwrap();
+        assert_eq!(s.execute("text.thread.info", &json!({})).unwrap(), json!([]));
+        if through_eyedropper {
+            s.select_tool("type", ViewInfo::default()).unwrap();
+        }
+        let left = obj(&s, b).plain_text();
+        assert!(!left.is_empty());
+        s.tool_text("x", ViewInfo::default()).unwrap();
+        assert_eq!(obj(&s, b).plain_text(), left, "through the Eyedropper: {through_eyedropper}");
+    }
+}
+
 #[test]
 fn typing_over_the_whole_story_replaces_every_frames_text_in_one_step() {
     let (mut s, a, b, story) = threaded_story_edited_in_its_second_frame();
diff --git a/crates/engine/src/tests/widthpoints.rs b/crates/engine/src/tests/widthpoints.rs
index 786f3b539..4c837c300 100644
--- a/crates/engine/src/tests/widthpoints.rs
+++ b/crates/engine/src/tests/widthpoints.rs
@@ -214,20 +214,27 @@ fn new_width_point_without_adjoining_preserves_neighbours() {
     new_point_adjoining(false);
 }
 
+/// A new width point with Adjust Adjoining scales only its nearest neighbours, by the widths sampled where it goes.
 #[test]
 fn new_width_point_adjust_adjoining_uses_sampled_widths() {
     for indexed in [false, true] {
         let (mut s, id) = line_session();
-        s.execute("stroke.widthProfile.set", &json!({"ids": [id.0], "points": [[0, 9, 9], [0.25, 1, 0], [0.75, 3, 0], [1, 7, 7]]})).unwrap();
-        // At t=0.5 the old sides are 10pt and 0pt. Indexed editing of that sampled
-        // point is the existing convention: scale the nonzero side, add from zero.
-        let index = if indexed { Some(set(&mut s, json!({"id": id.0, "t": 0.5, "left": 10, "right": 0}))) } else { None };
+        let original = vec![(0.0, 9.0, 9.0), (0.25, 1.0, 0.0), (0.75, 3.0, 0.0), (1.0, 7.0, 7.0)];
+        s.execute("stroke.widthProfile.set", &json!({"ids": [id.0], "points": original})).unwrap();
+        // At t=0.5 the old left side is where the profile's curve is there (#5714) and the right
+        // side is 0pt. Indexed editing of that sampled point is the existing convention: scale the
+        // nonzero side, add from zero.
+        let sampled = vectorcraft_doc::WidthProfile { points: original }.at(0.5).0;
+        let index = if indexed { Some(set(&mut s, json!({"id": id.0, "t": 0.5, "left": sampled * 5.0, "right": 0}))) } else { None };
         set(&mut s, json!({"id": id.0, "index": index, "t": 0.5, "left": 20, "right": 5, "adjustAdjoining": true}));
-        assert_eq!(
-            points(&s, id),
-            vec![(0.0, 9.0, 9.0), (0.25, 2.0, 1.0), (0.5, 4.0, 1.0), (0.75, 6.0, 1.0), (1.0, 7.0, 7.0)],
-            "only nearest neighbours change, using the sampled sides; indexed={indexed}"
-        );
+        let scale = 4.0 / sampled;
+        let got = points(&s, id);
+        let want = [(0.0, 9.0, 9.0), (0.25, scale, 1.0), (0.5, 4.0, 1.0), (0.75, 3.0 * scale, 1.0), (1.0, 7.0, 7.0)];
+        assert_eq!(got.len(), want.len(), "{got:?}; indexed={indexed}");
+        for (g, w) in got.iter().zip(want) {
+            let close = (g.0 - w.0).abs() < 1e-9 && (g.1 - w.1).abs() < 1e-9 && (g.2 - w.2).abs() < 1e-9;
+            assert!(close, "only nearest neighbours change, using the sampled sides; indexed={indexed}: {got:?} vs {want:?}");
+        }
     }
 }
 
diff --git a/crates/engine/src/tooling.rs b/crates/engine/src/tooling.rs
index 66d84a925..2d85d620f 100644
--- a/crates/engine/src/tooling.rs
+++ b/crates/engine/src/tooling.rs
@@ -131,8 +131,9 @@ impl Session {
         if self.tool.id() == id {
             return Ok(());
         }
-        // Sampling type keeps its highlighted characters as the target. Capture before the
-        // Type tool deactivates (which commits typing and clears its editing state).
+        // Sampling type keeps its highlighted characters as the target, and a whole story that
+        // Select All selected. Capture before the Type tool deactivates (which commits typing and
+        // clears its editing state).
         let is_type = |id: &str| matches!(id, "type" | "areaType" | "typeOnPath" | "verticalType" | "verticalAreaType" | "verticalTypeOnPath");
         let text_selection = ((id == "eyedropper" && is_type(self.tool.id())) || (self.tool.id() == "eyedropper" && is_type(id)))
             .then(|| self.tool.options())
diff --git a/crates/engine/tests/import_fuzz.rs b/crates/engine/tests/import_fuzz.rs
index 46ca4a078..f1a1f62c0 100644
--- a/crates/engine/tests/import_fuzz.rs
+++ b/crates/engine/tests/import_fuzz.rs
@@ -3219,6 +3219,9 @@ proptest! {
         fidelity in prop::sample::select(vec!["50", "0", "100", "101", "-1", "1e308", "nan"]),
         size in prop::sample::select(vec!["[1 1]", "[3 2]", "[0 0]", "[51 1]", "[100000 100000]", "[-1 2]", "[1e308 1]"]),
         corner in prop::sample::select(vec!["10 10", "1e308 -1e308", "nan 0", "10 10 10 10", "0"]),
+        art_width in prop::sample::select(vec!["81", "80", "0", "-5", "1e308", "nan"]),
+        art_height in prop::sample::select(vec!["81", "80", "0", "-5", "1e308", "nan"]),
+        weight in prop::sample::select(vec!["1", "0", "1e308", "-1"]),
         edit in 0i64..2,
         cut in 0usize..2_000,
         edits in prop::collection::vec((0usize..2_000, prop::sample::select(vec!['0', '9', '-', ' ', '\n', '(', ')', '/', ':', ';', ',', '[', ']', '%', '_', 'X', 'u', 'U'])), 0..8),
@@ -3231,9 +3234,9 @@ proptest! {
             n("10", "90"),
             n("90", "90")
         );
-        let content = "%_u\n%_1 0 0 1 0 0 Xa\n%_10 10 m\n%_10 90 L\n%_90 90 L\n%_90 10 L\n%_f\n%_U\n";
+        let content = format!("%_u\n%_1 0 0 1 0 0 Xa\n%_0 1 1 0 1 0 0 XA\n%_{weight} w\n%_10 10 m\n%_10 90 L\n%_90 90 L\n%_90 10 L\n%_b\n%_U\n");
         let keys = format!(
-            "%_{word} /Int (AIDeformOptionsKey) ,\n%_{fidelity} /Int (AIDeformFidelityKey) ,\n%_{edit} /Bool (AIDeformEditModeKey) ,\n%_{style} /Int (DeformStyle) ,\n%_0.5 /Real (DeformValue) ,\n%_1 /Bool (Rotate) ,\n"
+            "%_{word} /Int (AIDeformOptionsKey) ,\n%_{fidelity} /Int (AIDeformFidelityKey) ,\n%_{edit} /Bool (AIDeformEditModeKey) ,\n%_{style} /Int (DeformStyle) ,\n%_0.5 /Real (DeformValue) ,\n%_1 /Bool (Rotate) ,\n%_{art_width} /Real (AIDeformArtWidthKey) ,\n%_{art_height} /Real (AIDeformArtHeightKey) ,\n"
         );
         let art = format!(
             "%_u\n{mesh}%_U\n%_/ArtDictionary :\n{keys}%_X=\n{content}%_X+\n%_ (AIDeformArtKey) ,\n%_{kind} /Int (AIDeformStyle) ,\n%_;\n%_\nu\n1 0 0 1 0 0 Xa\n12 12 m\n12 88 L\n88 88 L\nf\nU\n(Adobe Deform Plugin) 1 0 0 XP\n0 0 1 1 0 0 Xa\n0 0 m\n5 5 L\nf\n"
@@ -3410,6 +3413,54 @@ proptest! {
         survive("hostile .ai images and placed files", || Some(vectorcraft_eps::layered_ai(&private, Document::new(100.0, 100.0), vec![], false, false, 1.0).0))?;
     }
 
+    /// A `.ai` whose type (point type turned, vertical type, area type, threaded area type and type
+    /// on a path, their stubs with the frames' paths, and the text document they name, as the `.ai`
+    /// writer writes them) is damaged: read from its editing data alone and beside a page.
+    #[test]
+    fn ai_text_documents_never_panic(
+        cut in 0usize..30_000,
+        edits in prop::collection::vec((0usize..30_000, prop::sample::select(vec!['0', '1', '9', ' ', '\n', '(', ')', '[', ']', '<', '>', '/', '%', '_', 'n', 'f', 'z', '~'])), 0..16),
+    ) {
+        use vectorcraft_doc::{CharStyle, Node, NodeKind, TextKind, TextObject};
+        use vectorcraft_geom::{Affine, Point, Rect, shapes};
+        let mut doc = Document::new(200.0, 100.0);
+        let layer = doc.layers[0].id;
+        let mut point = TextObject::point(Point::new(10.0, 30.0), "Turned\ntype", CharStyle::default());
+        point.xf *= Affine::rotate(0.4);
+        let mut area = TextObject::point(Point::ZERO, "Area type", CharStyle::default());
+        area.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(20.0, 40.0, 90.0, 90.0)) };
+        area.xf = Affine::IDENTITY;
+        let mut on_path = TextObject::point(Point::ZERO, "On a path", CharStyle::default());
+        on_path.kind = TextKind::OnPath { path: shapes::ellipse(Rect::new(100.0, 20.0, 180.0, 80.0)), start: 0.25, end: None };
+        on_path.xf = Affine::IDENTITY;
+        let mut down = TextObject::point(Point::new(190.0, 10.0), "Down", CharStyle::default());
+        down.vertical = true;
+        let mut down_area = area.clone();
+        down_area.vertical = true;
+        down_area.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(150.0, 40.0, 180.0, 90.0)) };
+        let mut first = area.clone();
+        first.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(20.0, 5.0, 50.0, 35.0)) };
+        first.runs = vec![vectorcraft_doc::TextRun::new("A story through two frames", CharStyle::default())];
+        let mut second = first.clone();
+        second.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(60.0, 5.0, 90.0, 35.0)) };
+        second.runs = vec![vectorcraft_doc::TextRun::new("", CharStyle::default())];
+        for t in [point, area, on_path, down, down_area] {
+            let n = Node::new(doc.alloc_id(), NodeKind::Text(Box::new(t)));
+            doc.insert(Some(layer), usize::MAX, n).unwrap();
+        }
+        let (first, second) = (Node::new(doc.alloc_id(), NodeKind::Text(Box::new(first))), Node::new(doc.alloc_id(), NodeKind::Text(Box::new(second))));
+        doc.text_threads.push(vec![first.id, second.id]);
+        doc.insert(Some(layer), usize::MAX, first).unwrap();
+        doc.insert(Some(layer), usize::MAX, second).unwrap();
+        let program = vectorcraft_eps::export_ai_editing(&doc, &vectorcraft_eps::AiEditingOptions::default()).unwrap().program;
+        let written = String::from_utf8_lossy(&program);
+        prop_assert_eq!(written.matches("/AI11Text :").count(), 7, "every text object is written as text");
+        let text = mutate_text(&written, cut, &edits);
+        let private = [b"%AI24_ZStandard_Data".as_slice(), &zstd(&text)].concat();
+        survive("hostile .ai type", || vectorcraft_eps::ai_alone(&private).ok().map(|r| r.0))?;
+        survive("hostile .ai type beside a page", || Some(vectorcraft_eps::layered_ai(&private, Document::new(200.0, 100.0), vec![], false, false, 1.0).0))?;
+    }
+
     /// A `.ai` whose variable library is damaged or hostile: the library is counted for the warning
     /// whether the layers are read or not (an inserted `Z` can make an operator the reader doesn't
     /// handle, and then the layers aren't read).
@@ -3584,6 +3635,15 @@ proptest! {
         }
     }
 
+    /// A `.ai` whose Art brushed path is damaged or hostile: the brush's object and art, the style's
+    /// entries and the path, cut short or edited, read and drawn.
+    #[test]
+    fn ai_art_brushed_paths_never_panic(cut in 0usize..1_600, edits in prop::collection::vec((0usize..1_600, prop::sample::select(vec!['0', '9', '-', '.', 'e', ' ', '\n', '(', ')', '/', ':', ';', ',', '%', 'u', 'U', 'A', 'Z'])), 0..12)) {
+        let text = mutate_text(&art_brushed_text(), cut, &edits);
+        let private = [b"%AI24_ZStandard_Data".as_slice(), &zstd(&text)].concat();
+        survive("mutated .ai Art brushed path", || Some(vectorcraft_eps::layered_ai(&private, Document::new(100.0, 100.0), vec![], false, false, 1.0).0))?;
+    }
+
     /// Brush objects of every kind with any parameters, the brush manager's order with any names,
     /// and brush art sections nested or cut short: read with the layers, or as a library without
     /// them, the brushes kept within their ranges.
@@ -3633,8 +3693,8 @@ proptest! {
     }
 }
 
-/// Editing data with two symbols (S2's art holds an instance of S1), the symbol list and a layer of
-/// instances, as the format writes them.
+/// Editing data with symbols (S2's art holds an instance of S1, F's holds non-native art), the
+/// symbol list and a layer of instances, as the format writes them.
 fn symbols_text() -> String {
     use vectorcraft_testkit::ai;
     let def = |name: &str, art: &str, reg: u32| {
@@ -3643,7 +3703,12 @@ fn symbols_text() -> String {
         )
     };
     let inst = |name: &str, m: &str| format!("/SymbolInstance :\n({name}) /SymbolRef ,\n{m} /RTransformMatrix\n;\n9 () XW\n");
-    let defs = def("S1", "0 1 1 0 1 0 0 Xa\n-2 -2 m\n2 -2 L\n2 2 L\n-2 2 L\nf\n", 5) + &def("S2", &inst("S1", "1 0 0 -1 -8081 8237"), 1);
+    // Non-native art keeps ASCII85 data in comment lines, some of them `%_` lines holding a `(`.
+    let foreign = "/ForeignObject :\n1 /Version ,\n2 0 0 2 10 20  /RTransform ,\n10 20  /Origin ,\n1 2 5 8  /Bounds ,\n/Data ,\n\
+                   %,u@!!/MSk8%41#ocdN=10d&\n%_O%*mGn(RduU.]4`[u[.f\n%_;(]<[%\n%1H@<P2`V<S,pbuU7L]\\~>\n;\n";
+    let defs = def("F", &format!("{foreign}-2 -2 m\n2 -2 L\n2 2 L\nf\n"), 5)
+        + &def("S1", "0 1 1 0 1 0 0 Xa\n-2 -2 m\n2 -2 L\n2 2 L\n-2 2 L\nf\n", 5)
+        + &def("S2", &inst("S1", "1 0 0 -1 -8081 8237"), 1);
     let list = "%AI24_BeginSymbolList\n(S2)\n(S1)\n%AI24_EndSymbolList\n";
     let page = ai::layer(
         "L",
@@ -3668,7 +3733,7 @@ fn the_symbols_fuzz_data_opens_live() {
     let private = [b"%AI24_ZStandard_Data".as_slice(), &zstd(&symbols_text())].concat();
     let (doc, warnings, layered) = vectorcraft_eps::layered_ai(&private, Document::new(200.0, 100.0), vec![], false, true, 1.0);
     assert!(layered, "{warnings:?}");
-    let names: Vec<&str> = doc.symbols.iter().map(|s| s.name.as_str()).collect();
+    let names: Vec<&str> = doc.symbols.iter().map(|s| s.name.as_str()).filter(|n| *n != "F").collect();
     assert_eq!(names, ["S2", "S1"]);
     let mut instances = 0;
     doc.walk(|n| instances += usize::from(matches!(n.kind, vectorcraft_doc::NodeKind::SymbolInstance { .. })));
@@ -3742,6 +3807,36 @@ fn the_objects_on_path_fuzz_data_opens_live() {
     assert!(g.extras().objects_on_path.is_some(), "{g:?}");
 }
 
+/// Editing data with an Art brush, its art, and a path with its drawn look and the brush in its art
+/// style, as the format writes them.
+fn art_brushed_text() -> String {
+    use vectorcraft_testkit::ai;
+    let tool = "Adobe ArtOnPath Brush Tool";
+    let object = format!(
+        "%AI8_BeginPluginObject\n({tool})\n(R)\n(2 / A/ / / / / 0 0/ 5 0 0 0 /  1) -\n( 1 1 0 1 0 0 0 1 1 0 0 0 0 1) .\n%AI8_EndPluginObject\n"
+    );
+    let art = "%AI8_BeginBrushPattern\n(A)\n0 A\n0 g\n0 0 m\n40 0 L\n40 8 L\nf\n%AI8_EndBrushPattern\n";
+    let style = format!(
+        "%AI9_BeginArtStyles\n/KnownStyle :\n(S) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
+         /CompoundFilter :\n(Stack Style Filter) 0 0 /Filter ,\n1 /Visible ,\n/BasicFilter :\n({tool}) 1 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n\
+         0 /Bool (Proportional) ,\n0 /Bool (Segmented) ,\n1 /Real (Scaling) ,\n1 /Real (MinScaling) ,\n1 /Real (MaxScaling) ,\n1 /Int (Adjustment) ,\n1 /Bool (FoldAdjustment) ,\n1 /Int (Colorization) ,\n\
+         /StrokeStyle : 0 R\n0 0 0 1 K\n0 1 0 0 0 Xy\n0 J 0 j 2 w 10 M []0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n/GObjRef : (R) ({tool}) /PluginObject ; (Brush) ,\n; /Dict ;\n /Part ,\n;\n /Part ,\n;\n%AI9_EndArtStyles\n"
+    );
+    let path = "0 Ae\nu\n0 g\n10 10 m\n90 10 L\n90 30 L\nf\nU\n0 0 Xd\n6 () XW\n%_10 20 m\n%_90 20 L\n%_90 80 L\n%_n\n1 (S) XW\n";
+    ai::editing_data(100.0, 100.0, &format!("{object}{art}{style}{}", ai::layer("L", path)))
+}
+
+/// The data [`ai_art_brushed_paths_never_panic`] damages, as it is, opens with its path live and the
+/// brush on its stroke.
+#[test]
+fn the_art_brushed_fuzz_data_opens_live() {
+    let private = [b"%AI24_ZStandard_Data".as_slice(), &zstd(&art_brushed_text())].concat();
+    // Trusted: the empty page it is read beside isn't compared with its art.
+    let (doc, warnings, _) = vectorcraft_eps::layered_ai(&private, Document::new(100.0, 100.0), vec![], false, true, 1.0);
+    let n = doc.layers.first().and_then(|l| l.children()).and_then(|c| c.first()).unwrap_or_else(|| panic!("{warnings:?}"));
+    assert_eq!(n.appearance.stroke().and_then(|s| s.brush.as_deref()), Some("R"), "{warnings:?} {n:?}");
+}
+
 /// The ids of the objects of an Objects on Path group in the fuzz cases.
 const ON_PATH_IDS: [&str; 5] = ["f-0001", "f-0002", "f-0003", "f-0004", "f-0005"];
 
@@ -4165,6 +4260,7 @@ fn arb_ai_token() -> impl Strategy<Value = String> {
             "\n%_/AI11Text :\n%_0 /StoryIndex ,\n%_;\n",
             "/SymbolInstance :",
             "/Binary : /ASCII85Decode ,",
+            "/AI11TextDocument : /ASCII85Decode ,",
             "~>",
             "p",
             "P",
@@ -4219,6 +4315,14 @@ fn arb_ai_token() -> impl Strategy<Value = String> {
             "/x 100 200 TW",
             "1 Tq",
             "7 Tq",
+            "1 TV",
+            "7 TV",
+            "1 Tv",
+            "/x Tv",
+            "1 Ty",
+            "1e308 Ty",
+            "1 TY",
+            "(x) TY",
             "1 1 1e308 -1e308 4e9 Th",
             "1 1 (2) 3 4 Th",
             "36 2 Xb",
@@ -4564,11 +4668,15 @@ proptest! {
 
     /// A group with an Effect › Pathfinder style whose dictionary is hostile: any `Command`, keys of
     /// any type and value (missing, repeated, unknown, not finite), shown or hidden, the style cut
-    /// short anywhere; in editing data, an EPS and a `.ai`. A `Command` other than 0 never becomes
-    /// a live effect.
+    /// short anywhere; in editing data, an EPS and a `.ai`. The dictionary may also start with every
+    /// option at the value read and any `Mix`. A `Command` other than 0 to 11 never becomes a live
+    /// effect, and a live Soft Mix's Mixing Rate is a number from 1 to 100.
     #[test]
     fn ai_pathfinder_styles_never_panic(
-        command in prop_oneof![(-3i64..16).prop_map(|c| c.to_string()), arb_num()],
+        command in prop_oneof![(-3i64..16).prop_map(|c| c.to_string()), Just("11".to_string()), arb_num()],
+        defaults in any::<bool>(),
+        bare in any::<bool>(),
+        mix in prop_oneof![arb_num(), prop::sample::select(vec!["0.5", "0.3", "0.01", "0.0099", "1", "1.0001", "NaN", "1e999"]).prop_map(str::to_string)],
         keys in prop::collection::vec(
             (
                 prop::sample::select(vec!["Mix", "Precision", "RemovePoints", "ExtractUnpainted", "ConvertCustom", "TrapTint", "TrapThickness", "Command", "Extra"]),
@@ -4581,7 +4689,19 @@ proptest! {
         cut in 0usize..4_000,
     ) {
         use vectorcraft_testkit::ai;
+        let options = if defaults {
+            format!(
+                "1 /Bool (ConvertCustom) ,\n1 /Bool (ExtractUnpainted) ,\n{mix} /Real (Mix) ,\n10 /Real (Precision) ,\n0 /Bool (RemovePoints) ,\n\
+                 1 /Real (TrapAspect) ,\n0 /Bool (TrapConvertCustom) ,\n1 /Real (TrapMaxTint) ,\n0 /Bool (TrapReverse) ,\n0.25 /Real (TrapThickness) ,\n\
+                 0.4 /Real (TrapTint) ,\n0.05 /Real (TrapTintTolerance) ,\n"
+            )
+        } else {
+            String::new()
+        };
+        // With every option there, the random keys are left out half the time, so the style can be read.
+        let keys = if defaults && bare { &keys[..0] } else { &keys[..] };
         let dict: String = keys.iter().map(|(k, kind, v)| format!("{v} /{kind} ({k}) ,\n")).collect();
+        let dict = format!("{options}{dict}");
         let styles = format!(
             "%AI9_BeginArtStyles\n/KnownStyle :\n(PF) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
              /BasicFilter :\n(Adobe Pathfinder) 1 0 /Filter ,\n{} /Visible ,\n/Dictionary : /NotRecorded ,\n{command} /Int (Command) ,\n{dict}; /Dict ;\n /Part ,\n\
@@ -4593,12 +4713,17 @@ proptest! {
         let group = "0 Ae\nu\n1 0 0 1 0 0 Xa\n10 10 m\n10 60 L\n80 60 L\n80 10 L\nf\nU\n\
                      %_0 Ae\n%_u\n%_1 0 0 1 0 0 Xa\n%_10 10 m\n%_10 50 L\n%_50 50 L\n%_50 10 L\n%_f\n%_0 0 1 0 0 0 1 Xa\n%_40 20 m\n%_40 60 L\n%_80 60 L\n%_80 20 L\n%_f\n%_U\n1 (PF) XW\n";
         let data = ai::editing_data(200.0, 100.0, &format!("{styles}{}", ai::layer("L", group)));
-        let live = command.parse::<f64>().is_ok_and(|c| c == 0.0);
+        let live = command.parse::<f64>().is_ok_and(|c| (0.0..=11.0).contains(&c) && c.fract() == 0.0);
         let check = |d: Option<Document>| {
-            if let Some(d) = &d
-                && !live
-            {
-                d.walk(|n| assert!(!n.appearance.effects.iter().any(|e| e.id.starts_with("pathfinder.")), "Command {command}: {:?}", n.appearance.effects));
+            if let Some(d) = &d {
+                d.walk(|n| {
+                    let effects = &n.appearance.effects;
+                    assert!(live || !effects.iter().any(|e| e.id.starts_with("pathfinder.")), "Command {command}: {effects:?}");
+                    for e in effects.iter().filter(|e| e.id == "pathfinder.softMix") {
+                        let rate = e.params.get("mixingRate").and_then(Value::as_f64);
+                        assert!(rate.is_some_and(|r| (1.0..=100.0).contains(&r)), "Mix {mix}: {effects:?}");
+                    }
+                });
             }
             d
         };
diff --git a/crates/engine/tests/open_type_plans.rs b/crates/engine/tests/open_type_plans.rs
new file mode 100644
index 000000000..6ee4c99e6
--- /dev/null
+++ b/crates/engine/tests/open_type_plans.rs
@@ -0,0 +1,123 @@
+//! A document of type opened with the shaping plans font faces keep, compared with the same file
+//! opened while every shaped segment makes a plan of its own: the nodes and the first frame's
+//! pixels are the same. Its own test binary: the switch for kept plans applies to the whole process.
+// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+
+use std::sync::{Mutex, MutexGuard, Once};
+
+use serde_json::Value;
+use vectorcraft_doc::{CharStyle, Document, Node, NodeKind, TextObject, TextRun};
+use vectorcraft_engine::Session;
+use vectorcraft_engine::cmd::fileio;
+use vectorcraft_geom::{Affine, Point};
+use vectorcraft_render::{RenderOptions, Renderer};
+use vectorcraft_text::FontDb;
+use vectorcraft_text::test_fonts::{VARIABLE_FAMILY, keep_shape_plans, variable_font};
+
+const WIDTH: u32 = 900;
+const HEIGHT: u32 = 1300;
+
+/// Taken by each test: the switch for kept plans applies to the whole process.
+static SWITCH: Mutex<()> = Mutex::new(());
+
+fn switch() -> MutexGuard<'static, ()> {
+    SWITCH.lock().unwrap_or_else(|e| e.into_inner())
+}
+
+fn style() -> CharStyle {
+    CharStyle { size: 60.0, ..CharStyle::default() }
+}
+
+/// A saved document of type objects whose shaping differs in script, direction, language, features
+/// and variable font instance, the object in the plain style first.
+fn file() -> Vec<u8> {
+    static ADD_FONT: Once = Once::new();
+    ADD_FONT.call_once(|| {
+        FontDb::global().add_font(variable_font().unwrap());
+    });
+    let manual = CharStyle { kerning: Some(0.0), ..style() };
+    let variable = |name: &str| CharStyle { font_family: VARIABLE_FAMILY.into(), font_style: name.into(), ..style() };
+    let mut mixed = TextObject::point(Point::ZERO, "AVAV", style());
+    mixed.runs = vec![TextRun::new("AV", style()), TextRun::new("AV", manual.clone())];
+    let mut vertical = TextObject::point(Point::ZERO, "AB\u{65e5}\u{672c}", style());
+    vertical.vertical = true;
+    let objects = [
+        TextObject::point(Point::ZERO, "AVATAR office", style()),
+        TextObject::point(Point::ZERO, "To Wa fi", style()),
+        TextObject::point(Point::ZERO, "123 ... 456", style()),
+        TextObject::point(Point::ZERO, "AVAV", manual),
+        mixed,
+        TextObject::point(Point::ZERO, "fi office", CharStyle { language: Some("tr".into()), ..style() }),
+        TextObject::point(Point::ZERO, "AVAV", CharStyle { optical_kerning: true, ..style() }),
+        TextObject::point(Point::ZERO, "Small Caps", CharStyle { small_caps: Some(70.0), ..style() }),
+        TextObject::point(Point::ZERO, "\u{645}\u{631}\u{62d}\u{628}\u{627}", style()),
+        TextObject::point(Point::ZERO, "\u{5e9}\u{5dc}\u{5d5}\u{5dd}", style()),
+        TextObject::point(Point::ZERO, "lIn lIn", variable("Regular")),
+        TextObject::point(Point::ZERO, "lIn lIn", variable("Bold")),
+        vertical,
+    ];
+    let mut doc = Document::new(WIDTH as f64, HEIGHT as f64);
+    let layer = doc.layers[0].id;
+    let count = objects.len();
+    for (i, mut t) in objects.into_iter().enumerate() {
+        // Rows down the page; the vertical object, last, stands in the right margin.
+        t.xf = Affine::translate(if i + 1 == count { (800.0, 60.0) } else { (20.0, 90.0 * (i + 1) as f64) });
+        let id = doc.alloc_id();
+        doc.insert(Some(layer), usize::MAX, Node::new(id, NodeKind::Text(Box::new(t)))).unwrap();
+    }
+    vectorcraft_format::save_file(&doc)
+}
+
+/// The session `bytes` opened in, as `document.open` reads a file and then opens it.
+fn open(bytes: &[u8]) -> Session {
+    let name = "plans.vectorcraft";
+    let mut s = Session::new();
+    let read = fileio::read_for_open(name, bytes, Some(name.into()), &Value::Null, false, false).unwrap();
+    fileio::open_read(&mut s, read).unwrap();
+    s
+}
+
+fn first_frame(doc: &Document) -> Vec<u8> {
+    Renderer::new().render(doc, WIDTH, HEIGHT, Affine::IDENTITY, &RenderOptions::default()).pixels
+}
+
+#[test]
+fn an_opened_document_has_the_nodes_of_one_laid_out_with_plans_of_their_own() {
+    let _switch = switch();
+    let bytes = file();
+    keep_shape_plans(false);
+    let own = open(&bytes);
+    keep_shape_plans(true);
+    // The second open shapes every object with plans a face kept.
+    open(&bytes);
+    let kept = open(&bytes);
+    let (own, kept) = (own.doc().unwrap(), kept.doc().unwrap());
+    let mut laid_out = 0;
+    kept.doc.walk(|node| {
+        if let NodeKind::Text(t) = &node.kind {
+            assert!(t.cached_bounds.is_some(), "{:?}", t.plain_text());
+            laid_out += 1;
+        }
+    });
+    assert_eq!(laid_out, 13);
+    assert_eq!(kept.doc.layers, own.doc.layers);
+    assert!(*kept.doc == *own.doc, "the whole document is the same");
+}
+
+#[test]
+fn an_opened_document_draws_the_first_frame_of_one_shaped_with_plans_of_its_own() {
+    let _switch = switch();
+    let bytes = file();
+    let opened = open(&bytes);
+    let doc = &opened.doc().unwrap().doc;
+    keep_shape_plans(false);
+    let own = first_frame(doc);
+    keep_shape_plans(true);
+    // Lays out each object with plans a face kept: the first frame lays type out again.
+    first_frame(doc);
+    let kept = first_frame(doc);
+    assert_ne!(kept, first_frame(&Document::new(WIDTH as f64, HEIGHT as f64)), "the frame shows the type");
+    let differing = kept.iter().zip(&own).filter(|(a, b)| a != b).count();
+    assert_eq!((kept.len(), differing), (own.len(), 0), "bytes of the frame that differ");
+}
diff --git a/crates/eps/src/ai_editing.rs b/crates/eps/src/ai_editing.rs
index 26293842c..2ad1c719c 100644
--- a/crates/eps/src/ai_editing.rs
+++ b/crates/eps/src/ai_editing.rs
@@ -78,12 +78,23 @@
 //!   (`w h rowBytes 32 17 `, then rows of premultiplied ARGB), each in versioned content, `~`,
 //!   `%AI5_EndPlace`. The box is the file's pixels at art space's origin on the canvas; the matrix
 //!   takes it into art space. In opacity masks and pattern tiles, linked images are embedded.
+//! - Type: a text object `/AI11Text :` naming its story and frame (`/StoryIndex`, `/FrameIndex`),
+//!   for area type and type on a path with its frame's path (`/Art :` … `; /ConfiningPath ,`), and
+//!   the text document after the document data (`%AI11_BeginTextDocument`, see
+//!   `writer::texts`), in the form the reader's `ate.rs` reads: the characters, the fonts, sizes,
+//!   leading, tracking, baseline shift, scales, solid fills and strokes and capitals of each run,
+//!   the alignment, indents, spacing, hyphenation and direction of each paragraph, and the frame:
+//!   point type's point and matrix, area type's frame, rows, columns, gutters and first baseline,
+//!   type on a path's path and span, vertical type, and the frames a threaded story flows through.
 //!
 //! Lines end in CR LF. Strings are written in UTF-8. Art space is ruler space: y up, its origin at
 //! the first artboard's top-left corner. On the canvas ([`CANVAS_SIZE`] points square, y down) the
 //! artboards together are centered; each artboard's `RulerOrigin` is its top-left corner there, and
 //! `%AI3_TemplateBox` holds the canvas's center in art space. What the form above can't hold is written as plain filled and stroked paths, each such
-//! loss a warning: type as its outlines and its inline graphics' art, freeform gradients, gradients
+//! loss a warning: type the text document can't hold (in opacity masks, pattern tiles and art cut to
+//! a clipping object, mirrored, turned or unevenly scaled area type and type on a path, inline graphics, ruby,
+//! gradient or pattern paint, an appearance of its own) as its outlines and its inline graphics'
+//! art, the character and paragraph attributes the text document doesn't hold, freeform gradients, gradients
 //! along or across a stroke and gradients without stops, with more than 256 stops or without extent
 //! as their average color
 //! (gradients that dither or mix perceptually are written as classic ones, and gradient stops linked
@@ -225,6 +236,9 @@ pub fn export_ai_editing(doc: &Document, o: &AiEditingOptions) -> Result<AiEditi
     w.definitions(&mut s);
     s.push_str(&palette);
     artboards(&mut s, doc, to_art, origin);
+    if !w.texts.is_empty() {
+        s.push_str(&w.texts.section(doc));
+    }
     s.push_str("%%EndSetup\n");
     s.push_str(&w.body);
     s.push_str("%%PageTrailer\ngsave annotatepage grestore showpage\n%%Trailer\n%%EOF\n");
@@ -431,10 +445,12 @@ fn ruler_units(u: Unit) -> u8 {
 /// bottom-right corners in art space (`PositionPoint1`, `PositionPoint2`), its top-left corner on
 /// the canvas (`RulerOrigin`, `origin` being art space's origin there), its pixel aspect ratio
 /// (`PAR`), `DisplayMark` 0 (as in the files users sent), whether it is the selected one (the
-/// first) and its name; then the canvas's size. Every record holds all of these entries. The
-/// artboards and the canvas size are written in the `/Recorded` part of the `/Document`
-/// dictionary, followed by an empty `/NotRecorded` part.
+/// active one) and its name; then the index of the active artboard (`CropAreaActive`: the one
+/// [`Document::opened_artboard`] names, else the first) and the canvas's size. Every record holds
+/// all of these entries. The artboards, the active artboard and the canvas size are written in the
+/// `/Recorded` part of the `/Document` dictionary, followed by an empty `/NotRecorded` part.
 fn artboards(s: &mut String, doc: &Document, to_art: Affine, origin: (f64, f64)) {
+    let active = doc.opened_artboard.and_then(|id| doc.artboards.iter().position(|a| a.id == id)).unwrap_or(0);
     s.push_str("%AI9_BeginDocumentData\n%_/Document :\n%_/Dictionary :\n%_/Array :\n");
     for (i, ab) in doc.artboards.iter().enumerate() {
         let r = to_art.transform_rect_bbox(ab.rect);
@@ -449,10 +465,11 @@ fn artboards(s: &mut String, doc: &Document, to_art: Affine, origin: (f64, f64))
         ps::push_num(s, if par.is_finite() && par > 0.0 { par } else { 1.0 });
         // Display marks: 1 the center mark, 2 cross hairs, 4 video safe areas.
         let mark = u8::from(ab.show_center_mark) | u8::from(ab.show_cross_hairs) << 1 | u8::from(ab.show_video_safe_areas) << 2;
-        let _ = writeln!(s, " /Real (PAR) ,\n%_{mark} /Int (DisplayMark) ,\n%_{} /Bool (IsArtboardSelected) ,", u8::from(i == 0));
+        let _ = writeln!(s, " /Real (PAR) ,\n%_{mark} /Int (DisplayMark) ,\n%_{} /Bool (IsArtboardSelected) ,", u8::from(i == active));
         let _ = writeln!(s, "%_{} /UnicodeString (Name) ,\n%_; ,", ps::bytes(ab.name.as_bytes()));
     }
     s.push_str("%_; (ArtboardArray) ,\n");
+    let _ = writeln!(s, "%_{active} /Int (CropAreaActive) ,");
     let _ = writeln!(s, "%_{CANVAS_SIZE} /Int (AIDocumentCanvasSize) ,");
     s.push_str("%_; /Recorded ,\n%_/Dictionary : /NotRecorded ,\n%_; /NotRecorded ,\n%_;\n%AI9_EndDocumentData\n");
 }
diff --git a/crates/eps/src/ai_editing/tests.rs b/crates/eps/src/ai_editing/tests.rs
index 529c54a5f..7ebece9d3 100644
--- a/crates/eps/src/ai_editing/tests.rs
+++ b/crates/eps/src/ai_editing/tests.rs
@@ -367,9 +367,9 @@ fn add_rect(doc: &mut Document, r: Rect) {
     doc.insert(Some(layer), usize::MAX, rect).unwrap();
 }
 
-/// The end of the document data: the artboards and the canvas size in the `/Recorded` part of the
-/// `/Document` dictionary, then an empty `/NotRecorded` part.
-const RECORDED: &str = "%_; (ArtboardArray) ,\n%_16383 /Int (AIDocumentCanvasSize) ,\n%_; /Recorded ,\n%_/Dictionary : /NotRecorded ,\n%_; /NotRecorded ,\n%_;\n%AI9_EndDocumentData\n";
+/// The end of the document data: the artboards, the active artboard (the first) and the canvas
+/// size in the `/Recorded` part of the `/Document` dictionary, then an empty `/NotRecorded` part.
+const RECORDED: &str = "%_; (ArtboardArray) ,\n%_0 /Int (CropAreaActive) ,\n%_16383 /Int (AIDocumentCanvasSize) ,\n%_; /Recorded ,\n%_/Dictionary : /NotRecorded ,\n%_; /NotRecorded ,\n%_;\n%AI9_EndDocumentData\n";
 
 /// One letter-size artboard: the art 36 points in from its top-left corner, the artboard's record
 /// and the boxes, with the artboards in the `/Recorded` part of the `/Document` dictionary.
@@ -637,10 +637,16 @@ fn unsupported() -> Document {
     };
     let im = Node::new(doc.alloc_id(), NodeKind::Image(Box::new(im)));
     doc.insert(Some(layer), usize::MAX, im).unwrap();
+    // Type the text document can't hold (a gradient fill).
+    let shade = Gradient::new(GradientKind::Linear, vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::rgb(0.0, 0.0, 1.0))]);
     let t = vectorcraft_doc::TextObject::point(
         vectorcraft_geom::Point::new(10.0, 70.0),
         "Type",
-        vectorcraft_doc::CharStyle { size: 18.0, fill: solid(Color::BLACK), ..vectorcraft_doc::CharStyle::default() },
+        vectorcraft_doc::CharStyle {
+            size: 18.0,
+            fill: Paint::Gradient(Box::new(GradientPaint::new(shade))),
+            ..vectorcraft_doc::CharStyle::default()
+        },
     );
     let t = Node::new(doc.alloc_id(), NodeKind::Text(Box::new(t)));
     doc.insert(Some(layer), usize::MAX, t).unwrap();
@@ -720,7 +726,9 @@ fn brushed_strokes_are_written_as_their_brush_art() {
 fn type_is_written_as_create_outlines_makes_it() {
     let mut doc = Document::new(200.0, 100.0);
     let layer = doc.layers[0].id;
-    let style = vectorcraft_doc::CharStyle { size: 18.0, fill: solid(Color::BLACK), underline: true, ..vectorcraft_doc::CharStyle::default() };
+    // A pattern fill: type the text document can't hold.
+    let pattern = Paint::Pattern { pattern: "Dots".into(), xf: Affine::IDENTITY };
+    let style = vectorcraft_doc::CharStyle { size: 18.0, fill: pattern, underline: true, ..vectorcraft_doc::CharStyle::default() };
     let t = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 70.0), "Under", style);
     let mut t = Node::new(doc.alloc_id(), NodeKind::Text(Box::new(t)));
     t.name = Some("Title".into());
@@ -984,6 +992,29 @@ fn artboard_display_marks_are_written() {
     assert!(ab.show_center_mark && !ab.show_cross_hairs && ab.show_video_safe_areas);
 }
 
+/// The active artboard, the one `opened_artboard` names (else the first), is the selected one and
+/// its index follows the artboards in the recorded part; the editing data reads back with that
+/// artboard active.
+#[test]
+fn the_active_artboard_follows_the_artboards() {
+    let mut doc = Document::new(200.0, 100.0);
+    for (id, x0) in [(2, 250.0), (3, 500.0)] {
+        doc.artboards.push(Artboard { id, rect: Rect::new(x0, 0.0, x0 + 200.0, 100.0), ..doc.artboards[0].clone() });
+    }
+    let first = doc.artboards[0].id;
+    // None, the first, the third, and an artboard the document doesn't have (the first).
+    for (opened, index) in [(None, 0), (Some(first), 0), (Some(3), 2), (Some(9), 0)] {
+        doc.opened_artboard = opened;
+        let p = program(&doc);
+        let entry = format!("%_; (ArtboardArray) ,\n%_{index} /Int (CropAreaActive) ,\n%_16383 /Int (AIDocumentCanvasSize) ,\n%_; /Recorded ,\n");
+        assert!(p.contains(&entry), "{opened:?}: {p}");
+        assert_eq!(p.matches("%_1 /Bool (IsArtboardSelected) ,\n").count(), 1, "{opened:?}");
+        let back = read_back(&doc);
+        let active = back.opened_artboard.and_then(|id| back.artboards.iter().position(|a| a.id == id)).unwrap_or(0);
+        assert_eq!((back.artboards.len(), active), (3, index), "{opened:?}");
+    }
+}
+
 /// A guide is its path followed by `(n) *` (closed) or `(N) *` (open), with no `(N) *` before
 /// it, and reads back as the same guide.
 #[test]
@@ -1213,52 +1244,88 @@ fn same_lines(got: &[String], want: &[String]) {
     assert!(differ.is_empty(), "{}", differ.join("\n"));
 }
 
-/// `nodes` as the reader reads them back: an opacity mask's art that isn't a group comes back as
-/// a group holding it.
-fn mask_art_grouped(nodes: &mut [Arc<Node>]) {
-    for n in nodes {
-        let n = Arc::make_mut(n);
-        if let Some(m) = n.extras_mut().mask.as_mut()
-            && !matches!(m.art.kind, NodeKind::Group { .. })
-        {
-            let art = m.art.clone();
-            m.art = Arc::new(Node::new(art.id, NodeKind::Group { children: vec![art], clip: false }));
-        }
-        if let Some(c) = n.children_mut() {
-            mask_art_grouped(c);
-        }
-    }
-}
-
 #[test]
 fn transparency_clipping_and_masks_are_read_back() {
-    let mut doc = transparent();
+    let doc = transparent();
     let out = export_ai_editing(&doc, &opts()).unwrap();
     assert!(out.warnings.is_empty(), "{:?}", out.warnings);
     let back = read_back(&doc);
     same_lines(&lines(&back), &lines(&doc));
-    // The disabled mask's art is one path: it reads back as a group holding the path.
-    let mask_arts = |d: &Document| {
-        let mut out = vec![];
-        d.walk(|n| {
-            if let Some(m) = &n.extras().mask {
-                out.push(match &m.art.kind {
-                    NodeKind::Group { children, .. } => format!("group of {}", children.len()),
-                    NodeKind::Path { .. } => "path".into(),
-                    _ => "other".into(),
-                });
-            }
-        });
-        out
-    };
-    assert_eq!(
-        (mask_arts(&doc), mask_arts(&back)),
-        (vec!["group of 2".to_string(), "path".into()], vec!["group of 2".to_string(), "group of 1".into()])
-    );
-    mask_art_grouped(&mut doc.layers);
     same_lines(&all_looks(&back), &all_looks(&doc));
 }
 
+/// An opacity mask's art reads back in its own shape: one object, a group of one object, a group
+/// of two, a group of one group, a see-through group of two, and a group around a hidden object or
+/// a guide.
+#[test]
+fn opacity_mask_art_keeps_its_shape_when_read_back() {
+    let mut doc = Document::new(200.0, 100.0);
+    doc.swatches = vec![Swatch { name: "Blue".into(), paint: solid(Color::rgb(0.0, 0.0, 1.0)), global: false, spot: false }].into();
+    doc.swatch_groups = vec![].into();
+    let layer = doc.layers[0].id;
+    let art = |doc: &mut Document| square(doc, Rect::new(5.0, 5.0, 10.0, 10.0), Color::gray(0.5));
+    let path = art(&mut doc);
+    let one = art(&mut doc);
+    let of_one = group(&mut doc, vec![one], false);
+    let (a, b) = (art(&mut doc), art(&mut doc));
+    let of_two = group(&mut doc, vec![a, b], false);
+    let (a, b) = (art(&mut doc), art(&mut doc));
+    let inner = group(&mut doc, vec![a, b], false);
+    let of_group = group(&mut doc, vec![inner], false);
+    let (a, b) = (art(&mut doc), art(&mut doc));
+    let faded = see_through(group(&mut doc, vec![a, b], false), 0.5, BlendMode::Normal);
+    let mut off = art(&mut doc);
+    off.visible = false;
+    let of_hidden = group(&mut doc, vec![off], false);
+    let line = Node::new(
+        doc.alloc_id(),
+        NodeKind::Path {
+            path: shapes::rectangle(Rect::new(5.0, 5.0, 10.0, 10.0)),
+            rule: FillRule::NonZero,
+            live: None,
+            clipping: false,
+            guide: true,
+        },
+    );
+    let of_guide = group(&mut doc, vec![line], false);
+    for mask_art in [path, of_one, of_two, of_group, faded, of_hidden, of_guide] {
+        let mut owner = square(&mut doc, Rect::new(0.0, 0.0, 30.0, 30.0), Color::rgb(1.0, 0.0, 0.0));
+        owner.extras_mut().mask = Some(Box::new(OpacityMask::new(mask_art, true)));
+        doc.insert(Some(layer), usize::MAX, owner).unwrap();
+    }
+    let back = read_back(&doc);
+    same_lines(&all_looks(&back), &all_looks(&doc));
+    let first = String::from_utf8(export_ai_editing(&doc, &opts()).unwrap().program).unwrap();
+    let again = String::from_utf8(export_ai_editing(&back, &opts()).unwrap().program).unwrap();
+    same_lines(&again.lines().map(String::from).collect::<Vec<_>>(), &first.lines().map(String::from).collect::<Vec<_>>());
+}
+
+/// Hidden art of a mask is written shown: the canvas draws the art's root either way, and the reader
+/// puts a hidden object in a group that doesn't draw it.
+#[test]
+fn a_hidden_opacity_mask_art_root_reads_back_shown() {
+    let mut doc = Document::new(200.0, 100.0);
+    doc.swatches = vec![Swatch { name: "Blue".into(), paint: solid(Color::rgb(0.0, 0.0, 1.0)), global: false, spot: false }].into();
+    doc.swatch_groups = vec![].into();
+    let layer = doc.layers[0].id;
+    let art = |doc: &mut Document| square(doc, Rect::new(5.0, 5.0, 10.0, 10.0), Color::gray(0.5));
+    let mut path = art(&mut doc);
+    path.visible = false;
+    let (a, b) = (art(&mut doc), art(&mut doc));
+    let mut of_two = group(&mut doc, vec![a, b], false);
+    of_two.visible = false;
+    for mask_art in [path, of_two] {
+        let mut owner = square(&mut doc, Rect::new(0.0, 0.0, 30.0, 30.0), Color::rgb(1.0, 0.0, 0.0));
+        owner.extras_mut().mask = Some(Box::new(OpacityMask::new(mask_art, true)));
+        doc.insert(Some(layer), usize::MAX, owner).unwrap();
+    }
+    let back = read_back(&doc);
+    let roots: Vec<_> = back.layers[0].children().unwrap().iter().map(|o| o.extras().mask.as_ref().unwrap().art.clone()).collect();
+    assert!(matches!(roots.as_slice(), [p, g] if p.visible && g.visible
+        && matches!(p.kind, NodeKind::Path { .. })
+        && matches!(&g.kind, NodeKind::Group { children, clip: false } if children.len() == 2 && children.iter().all(|c| c.visible))));
+}
+
 #[test]
 fn transparency_clipping_and_masks_write_the_same_bytes_again() {
     let doc = transparent();
@@ -2579,8 +2646,6 @@ fn images_doc() -> Document {
         shapes::rectangle(Rect::new(10.0, 60.0, 40.0, 90.0)),
         Appearance::basic(solid(Color::rgb(0.0, 0.5, 1.0)), Paint::None, 0.0),
     );
-    // A mask's art is read into a group.
-    let mask_art = Node::group(doc.alloc_id(), vec![Arc::new(mask_art)]);
     square.extras_mut().mask = Some(Box::new(OpacityMask::new(mask_art, false)));
     doc.insert(Some(layer), usize::MAX, square).unwrap();
     let links = Node::layer(doc.alloc_id(), "Links", LayerColor::Preset(1));
@@ -2651,6 +2716,30 @@ fn images_come_back_with_their_pixels_and_places() {
     assert_eq!(lines(&back).len(), lines(&doc).len(), "{:?}", lines(&back));
 }
 
+/// An image whose opacity defines the knockout shape comes back with it, embedded or linked. The
+/// image after it and their layer do not take it.
+#[test]
+fn an_images_knockout_shape_comes_back() {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let at = |x: f64| Affine::new([10.0, 0.0, 0.0, 10.0, x, 10.0]);
+    let mut shaped = image_node(&mut doc, ImageBlob::png(rgb_png()), (3, 2), at(10.0), None);
+    (shaped.opacity, shaped.knockout_shape) = (0.5, true);
+    doc.insert(Some(layer), usize::MAX, shaped).unwrap();
+    let plain = image_node(&mut doc, ImageBlob::png(rgb_png()), (3, 2), at(50.0), None);
+    doc.insert(Some(layer), usize::MAX, plain).unwrap();
+    let mut link = vectorcraft_doc::LinkInfo::new("/Users/someone/Job/art/pic.png");
+    link.relative = Some("art/pic.png".into());
+    let mut linked = image_node(&mut doc, ImageBlob::png(rgb_png()), (3, 2), at(90.0), Some(link));
+    linked.knockout_shape = true;
+    doc.insert(Some(layer), usize::MAX, linked).unwrap();
+    let back = read_back(&doc);
+    let art = back.layers[0].children().unwrap();
+    let got: Vec<_> = art.iter().map(|n| (matches!(n.kind, NodeKind::Image(_)), n.opacity, n.knockout_shape)).collect();
+    assert_eq!(got, [(true, 0.5, true), (true, 1.0, false), (true, 1.0, true)]);
+    assert_eq!((back.layers[0].opacity, back.layers[0].knockout_shape), (1.0, false));
+}
+
 #[test]
 fn images_are_written_again_as_the_same_bytes() {
     let mut doc = images_doc();
@@ -3044,3 +3133,1002 @@ fn sixteen_bit_cmyk_images_are_written_at_eight_bits() {
     assert_eq!(out.warnings, [writer::IMAGE_DEPTH]);
     assert!(program_shown(&doc).contains("/DeviceCMYK XN\n"));
 }
+
+// ---------- type ----------
+
+fn style(size: f64, fill: Color) -> vectorcraft_doc::CharStyle {
+    vectorcraft_doc::CharStyle { size, fill: solid(fill), ..vectorcraft_doc::CharStyle::default() }
+}
+
+fn text_node(doc: &mut Document, t: vectorcraft_doc::TextObject) -> Node {
+    Node::new(doc.alloc_id(), NodeKind::Text(Box::new(t)))
+}
+
+/// A 300 × 200 document of the type the slice writes as text, on a layer `Type`: two paragraphs
+/// of point type (the second centered, with space before, a fixed leading) named `Greeting`; point
+/// type turned 30° in CMYK; area type in two columns with a gutter and a first baseline at its
+/// leading, its runs plain, then bold, tracked, shifted, scaled, stroked and in capitals, then a
+/// right-to-left paragraph; type on an open curve from a tenth of its length; vertical point type;
+/// hidden, locked point type at half opacity multiplied; and area type threaded through two frames.
+fn typed() -> Document {
+    use vectorcraft_doc::{CharStyle, FirstBaseline, Justify, ParaDirection, ParaStyle, TextKind, TextObject, TextRun};
+    use vectorcraft_geom::Point;
+    let mut doc = Document::new(300.0, 200.0);
+    // One CMYK swatch, not the default ones: their CMYK equivalents round differently once read back.
+    doc.swatches = vec![
+        Swatch { name: "[None]".into(), paint: Paint::None, global: false, spot: false },
+        Swatch { name: "Ink".into(), paint: solid(BRAND), global: false, spot: false },
+    ]
+    .into();
+    doc.swatch_groups = vec![].into();
+    doc.layers.clear();
+    let layer = doc.add_layer(Some("Type"));
+
+    let mut greet = TextObject::point(Point::new(20.0, 40.0), "Hello\nWorld", CharStyle { leading: Some(30.0), ..style(24.0, SKY) });
+    let centered = ParaStyle { justify: Justify::Center, space_before: 6.0, ..ParaStyle::default() };
+    greet.set_paragraph_styles(vec![ParaStyle { first_line_indent: 10.0, ..ParaStyle::default() }, centered]);
+    let greet = named(text_node(&mut doc, greet), "Greeting");
+    doc.insert(Some(layer), usize::MAX, greet).unwrap();
+
+    let mut turned = TextObject::point(Point::ZERO, "Turned", style(18.0, BRAND));
+    turned.xf = Affine::translate((150.0, 100.0)) * Affine::rotate(-std::f64::consts::FRAC_PI_6);
+    let turned = text_node(&mut doc, turned);
+    doc.insert(Some(layer), usize::MAX, turned).unwrap();
+
+    let regular = style(10.0, Color::BLACK);
+    let bold = CharStyle {
+        font_style: "Bold".into(),
+        tracking: 50.0,
+        baseline_shift: 3.0,
+        h_scale: 120.0,
+        v_scale: 90.0,
+        stroke: solid(Color::rgb(0.0, 0.5, 0.0)),
+        stroke_width: 0.5,
+        all_caps: true,
+        ..regular.clone()
+    };
+    let mut area = TextObject::point(Point::ZERO, "", regular.clone());
+    area.runs = vec![
+        TextRun::new("Area type flows in two columns ", regular.clone()),
+        TextRun::new("and wraps", bold),
+        TextRun::new(" onto the next line.\nRight to left", regular.clone()),
+    ];
+    area.set_paragraph_styles(vec![
+        ParaStyle { left_indent: 4.0, right_indent: 2.0, space_after: 3.0, hyphenate: false, ..ParaStyle::default() },
+        ParaStyle { direction: Some(ParaDirection::RightToLeft), justify: Justify::JustifyAll, ..ParaStyle::default() },
+    ]);
+    area.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(20.0, 80.0, 140.0, 160.0)) };
+    area.xf = Affine::IDENTITY;
+    area.area.columns = 2;
+    area.area.gutter = 12.0;
+    area.area.first_baseline = FirstBaseline::Leading;
+    area.area.first_baseline_min = 4.0;
+    let area = text_node(&mut doc, area);
+    doc.insert(Some(layer), usize::MAX, area).unwrap();
+
+    let mut on_path = TextObject::point(Point::ZERO, "On a curve", style(12.0, Color::gray(0.6)));
+    let mut curve = PathData::from_bezpath(&kurbo::BezPath::from_vec(vec![
+        kurbo::PathEl::MoveTo((160.0, 150.0).into()),
+        kurbo::PathEl::CurveTo((190.0, 110.0).into(), (250.0, 110.0).into(), (280.0, 150.0).into()),
+    ]));
+    curve.subpaths.iter_mut().for_each(|sp| sp.closed = false);
+    on_path.kind = TextKind::OnPath { path: curve, start: 0.1, end: None };
+    on_path.xf = Affine::IDENTITY;
+    let on_path = text_node(&mut doc, on_path);
+    doc.insert(Some(layer), usize::MAX, on_path).unwrap();
+
+    let mut down = TextObject::point(Point::new(280.0, 20.0), "Down", style(14.0, Color::BLACK));
+    down.vertical = true;
+    let down = text_node(&mut doc, down);
+    doc.insert(Some(layer), usize::MAX, down).unwrap();
+
+    let quiet = TextObject::point(Point::new(20.0, 190.0), "Quiet", style(9.0, Color::BLACK));
+    let mut quiet = see_through(text_node(&mut doc, quiet), 0.5, BlendMode::Multiply);
+    quiet.visible = false;
+    quiet.locked = true;
+    doc.insert(Some(layer), usize::MAX, quiet).unwrap();
+
+    let mut first = TextObject::point(Point::ZERO, "A story that runs from one frame into the next one.", regular.clone());
+    first.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(160.0, 20.0, 220.0, 40.0)) };
+    first.xf = Affine::IDENTITY;
+    let mut second = first.clone();
+    second.runs = vec![TextRun::new("", regular)];
+    second.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(160.0, 50.0, 220.0, 90.0)) };
+    let (first, second) = (text_node(&mut doc, first), text_node(&mut doc, second));
+    doc.text_threads.push(vec![first.id, second.id]);
+    doc.insert(Some(layer), usize::MAX, first).unwrap();
+    doc.insert(Some(layer), usize::MAX, second).unwrap();
+    doc
+}
+
+/// What the reader's view of type is made of, one line per text object: its name, state,
+/// transparency, kind and frame, matrix, orientation, area options and path span; each paragraph's
+/// attributes; each run's characters and attributes. Lengths to three decimals.
+fn type_lines(doc: &Document) -> Vec<String> {
+    use vectorcraft_doc::TextKind;
+    let mut out = vec![];
+    let mut all = vec![];
+    paths(&doc.layers, &mut all);
+    for n in all {
+        let NodeKind::Text(t) = &n.kind else {
+            out.push(format!("not type: {:?}", n.name));
+            continue;
+        };
+        let pts = |p: &PathData| {
+            p.subpaths
+                .iter()
+                .map(|sp| {
+                    format!("[{} {}]", sp.closed, sp.anchors.iter().map(|a| format!("{},{}", r3(a.p.x), r3(a.p.y))).collect::<Vec<_>>().join(" "))
+                })
+                .collect::<String>()
+        };
+        let kind = match &t.kind {
+            TextKind::Point => "point".to_string(),
+            TextKind::Area { frame } => format!("area {}", pts(frame)),
+            TextKind::OnPath { path, start, end } => format!("path {} {} {:?}", pts(path), r3(*start), end.map(r3)),
+        };
+        let a = &t.area;
+        out.push(format!(
+            "{:?} shown={} locked={} {} {:?} {kind} xf={:?} vertical={} area {} {} {} {:?} {:?} {}",
+            n.name,
+            n.visible,
+            n.locked,
+            r3(f64::from(n.opacity)),
+            n.blend,
+            t.xf.as_coeffs().map(r3),
+            t.vertical,
+            a.rows,
+            a.columns,
+            r3(a.gutter),
+            a.row_gutter.map(r3),
+            a.first_baseline,
+            r3(a.first_baseline_min),
+        ));
+        for p in t.paragraph_styles() {
+            out.push(format!(
+                "  para {:?} {} {} {} {} {} {} {:?}",
+                p.justify,
+                r3(p.first_line_indent),
+                r3(p.left_indent),
+                r3(p.right_indent),
+                r3(p.space_before),
+                r3(p.space_after),
+                p.hyphenate,
+                p.direction
+            ));
+        }
+        for r in &t.runs {
+            let s = &r.style;
+            out.push(format!(
+                "  run {:?} {} {} {} {:?} {} {} {} {} fill {} stroke {} {} caps={} small={:?} tcy={}",
+                r.text,
+                s.font_family,
+                s.font_style,
+                r3(s.size),
+                s.leading.map(r3),
+                r3(s.tracking),
+                r3(s.baseline_shift),
+                r3(s.h_scale),
+                r3(s.v_scale),
+                paint(&s.fill),
+                paint(&s.stroke),
+                r3(s.stroke_width),
+                s.all_caps,
+                s.small_caps.map(r3),
+                s.tate_chu_yoko,
+            ));
+        }
+    }
+    out
+}
+
+#[test]
+fn type_comes_back_as_type() {
+    let doc = typed();
+    let out = export_ai_editing(&doc, &opts()).unwrap();
+    assert!(out.warnings.is_empty(), "{:?}", out.warnings);
+    let back = read_back(&doc);
+    same_lines(&type_lines(&back), &type_lines(&doc));
+    assert_eq!(back.text_threads.len(), 1, "the thread comes back");
+}
+
+#[test]
+fn type_is_written_again_as_the_same_bytes() {
+    let doc = typed();
+    let first = export_ai_editing(&doc, &opts()).unwrap();
+    assert_eq!(first.program, export_ai_editing(&doc, &opts()).unwrap().program);
+    let again = export_ai_editing(&read_back(&doc), &opts()).unwrap();
+    let text = |p: &[u8]| text_document(&String::from_utf8_lossy(p).replace("\r\n", "\n"));
+    assert_eq!(text(&again.program), text(&first.program));
+    assert_eq!(String::from_utf8_lossy(&again.program), String::from_utf8_lossy(&first.program));
+}
+
+/// The text document of program `text` (LF line ends), decoded, with its UTF-16 strings' zero
+/// bytes left out.
+fn text_document(text: &str) -> String {
+    let Some(start) = text.find("%AI11_BeginTextDocument\n") else { return String::new() };
+    let end = text.find("%AI11_EndTextDocument").unwrap();
+    let packed: String = text[start..end].lines().skip(2).filter(|l| *l != ";").map(|l| l.strip_prefix('%').unwrap_or(l)).collect();
+    String::from_utf8_lossy(&crate::ps::ascii85_decode(&packed).unwrap()).replace('\0', "")
+}
+
+/// The text document: its section after the document data, ASCII85 on comment lines none of which
+/// is a `%_` line; a stub for each text object, area type and type on a path with their paths.
+#[test]
+fn type_is_a_text_document_and_stubs() {
+    let text = program(&typed());
+    let doc_data = text.find("%AI9_EndDocumentData").unwrap();
+    let start = text.find("%AI11_BeginTextDocument\n/AI11TextDocument : /ASCII85Decode ,\n").unwrap();
+    let end = text.find(";\n%AI11_EndTextDocument\n%%EndSetup\n").unwrap();
+    assert!(doc_data < start && start < end);
+    let body = &text[start..end];
+    for l in body.lines().skip(2) {
+        assert!(l.starts_with('%') && !l.starts_with("%_"), "{l}");
+    }
+    assert_eq!(text.matches("/AI11Text :\n0 /FreeUndo ,\n").count(), 8);
+    assert_eq!(text.matches("; /ConfiningPath ,\n").count(), 4);
+    assert!(text.contains("0 /FrameIndex ,\n6 /StoryIndex ,") && text.contains("1 /FrameIndex ,\n6 /StoryIndex ,"), "{text}");
+    // The decoded document: the version, a font of each face and the hidden characters' font, the
+    // stories, the normal sheets and the document's text settings.
+    let decoded = text_document(&text);
+    assert!(decoded.starts_with("/98 << /0 14 >> /0 <<"), "{decoded}");
+    for want in
+        ["SourceSans3-Regular", "SourceSans3-Bold", "AdobeInvisFont", "[Normal Character Style]", "[Normal Paragraph Style]", "Hello\rWorld\r"]
+    {
+        assert!(decoded.contains(want), "{want}: {decoded}");
+    }
+    // Tracking is a whole number, and colors are simple paints.
+    assert!(decoded.contains("/8 50 ") && !decoded.contains("/8 50."), "{decoded}");
+    assert!(decoded.contains("/53 << /99 /SimplePaint") && !decoded.contains("CAITextPaint"), "{decoded}");
+}
+
+/// Point type scaled 150% comes back at its size: its scale is in its sizes, its matrix only turns
+/// it. Type that ends in an empty paragraph keeps it.
+#[test]
+fn scaled_point_type_and_a_last_empty_paragraph_come_back() {
+    use vectorcraft_doc::{CharStyle, ParaStyle, TextObject};
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut big = TextObject::point(vectorcraft_geom::Point::ZERO, "Big", CharStyle { leading: Some(20.0), ..style(12.0, Color::BLACK) });
+    big.xf = Affine::translate((20.0, 40.0)) * Affine::rotate(0.3) * Affine::scale(1.5);
+    big.set_all_paras(ParaStyle { left_indent: 4.0, ..ParaStyle::default() });
+    let ends = TextObject::point(vectorcraft_geom::Point::new(20.0, 80.0), "Ends\n", style(12.0, Color::BLACK));
+    let (big, ends) = (text_node(&mut doc, big), text_node(&mut doc, ends));
+    doc.insert(Some(layer), usize::MAX, big).unwrap();
+    doc.insert(Some(layer), usize::MAX, ends).unwrap();
+    let back = read_back(&doc);
+    let texts: Vec<&vectorcraft_doc::TextObject> =
+        back.layers[0].children().unwrap().iter().filter_map(|n| if let NodeKind::Text(t) = &n.kind { Some(t.as_ref()) } else { None }).collect();
+    let [big, ends] = texts.as_slice() else { panic!("two text objects: {texts:?}") };
+    let s = big.xf.determinant().sqrt();
+    let st = &big.runs[0].style;
+    assert_eq!((r3(s), r3(st.size), st.leading.map(r3), r3(big.para.left_indent)), (r3(1.0), r3(18.0), Some(r3(30.0)), r3(6.0)));
+    assert_eq!(big.xf.as_coeffs().map(r3), (Affine::translate((20.0, 40.0)) * Affine::rotate(0.3)).as_coeffs().map(r3));
+    assert_eq!(ends.plain_text(), "Ends\n");
+    // A tiny size, and a stroke of no width that keeps its paint.
+    let mut d = Document::new(200.0, 100.0);
+    let layer = d.layers[0].id;
+    let st = CharStyle { stroke: solid(Color::rgb(1.0, 0.0, 0.0)), stroke_width: 0.0, ..style(0.00001, Color::BLACK) };
+    let n = text_node(&mut d, TextObject::point(vectorcraft_geom::Point::new(20.0, 40.0), "Tiny", st));
+    d.insert(Some(layer), usize::MAX, n).unwrap();
+    let back = read_back(&d);
+    let NodeKind::Text(t) = &back.layers[0].children().unwrap()[0].kind else { panic!("type") };
+    let s = &t.runs[0].style;
+    assert_eq!(
+        (format!("{:.6}", s.size), paint(&s.stroke), r3(s.stroke_width)),
+        ("0.000010".into(), paint(&solid(Color::rgb(1.0, 0.0, 0.0))), r3(0.0))
+    );
+}
+
+/// A threaded story whose frames each hold their slice of it, a paragraph split between them,
+/// comes back as one story in its first frame with each paragraph's attributes once.
+#[test]
+fn a_story_split_between_frames_comes_back_whole() {
+    use vectorcraft_doc::{Justify, ParaStyle, TextKind, TextObject, TextRun};
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let st = style(10.0, Color::BLACK);
+    let (p1, p2, p3) = (
+        ParaStyle { justify: Justify::Center, ..ParaStyle::default() },
+        ParaStyle { left_indent: 5.0, ..ParaStyle::default() },
+        ParaStyle { space_before: 4.0, ..ParaStyle::default() },
+    );
+    let mut first = TextObject::point(vectorcraft_geom::Point::ZERO, "", st.clone());
+    first.runs = vec![TextRun::new("One two\nthree ", st.clone())];
+    first.set_paragraph_styles(vec![p1.clone(), p2.clone()]);
+    first.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(10.0, 10.0, 90.0, 40.0)) };
+    first.xf = Affine::IDENTITY;
+    let p4 = ParaStyle { right_indent: 7.0, ..ParaStyle::default() };
+    let mut second = first.clone();
+    second.runs = vec![TextRun::new("four\nFive\n", st)];
+    second.set_paragraph_styles(vec![p2.clone(), p3.clone(), p4.clone()]);
+    second.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(110.0, 10.0, 190.0, 40.0)) };
+    let (first, second) = (text_node(&mut doc, first), text_node(&mut doc, second));
+    doc.text_threads.push(vec![first.id, second.id]);
+    doc.insert(Some(layer), usize::MAX, first).unwrap();
+    doc.insert(Some(layer), usize::MAX, second).unwrap();
+    let back = read_back(&doc);
+    let texts: Vec<&TextObject> =
+        back.layers[0].children().unwrap().iter().filter_map(|n| if let NodeKind::Text(t) = &n.kind { Some(t.as_ref()) } else { None }).collect();
+    let [a, b] = texts.as_slice() else { panic!("two frames: {texts:?}") };
+    assert_eq!((a.plain_text().as_str(), b.plain_text().as_str()), ("One two\nthree four\nFive\n", ""));
+    let attrs = |p: &ParaStyle| (p.justify, r3(p.left_indent), r3(p.right_indent), r3(p.space_before));
+    let got: Vec<_> = a.paragraph_styles().iter().map(attrs).collect();
+    assert_eq!(got, [&p1, &p2, &p3, &p4].into_iter().map(attrs).collect::<Vec<_>>(), "the last, empty paragraph keeps its own");
+    assert_eq!(back.text_threads.len(), 1);
+    assert!(export_ai_editing(&doc, &opts()).unwrap().warnings.is_empty());
+    // An attribute the text document doesn't hold in a later frame is reported.
+    let second_id = doc.text_threads[0][1];
+    let mut lossy = doc.clone();
+    if let NodeKind::Text(t) = &mut lossy.node_mut(second_id).unwrap().kind {
+        t.runs[0].style.underline = true;
+    }
+    assert_eq!(export_ai_editing(&lossy, &opts()).unwrap().warnings, [writer::TYPE_ATTRIBUTES]);
+    // So is a paragraph split between the frames whose second part has other attributes.
+    let mut split = doc.clone();
+    if let NodeKind::Text(t) = &mut split.node_mut(second_id).unwrap().kind {
+        t.set_paragraph_styles(vec![ParaStyle { left_indent: 9.0, ..ParaStyle::default() }, p3, p4]);
+    }
+    assert_eq!(export_ai_editing(&split, &opts()).unwrap().warnings, [writer::TYPE_ATTRIBUTES]);
+}
+
+/// A story longer than the reader reads is written as its outlines.
+#[test]
+fn a_story_longer_than_the_reader_reads_is_written_as_its_outlines() {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let long = format!("A{}", " ".repeat(crate::import::MAX_STORY));
+    let t = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 50.0), &long, style(12.0, Color::BLACK));
+    let short = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 90.0), "Short", style(12.0, Color::BLACK));
+    let (t, short) = (text_node(&mut doc, t), text_node(&mut doc, short));
+    doc.insert(Some(layer), usize::MAX, t).unwrap();
+    doc.insert(Some(layer), usize::MAX, short).unwrap();
+    let out = export_ai_editing(&doc, &opts()).unwrap();
+    assert_eq!(out.warnings, [writer::TYPE]);
+    assert_eq!(program(&doc).matches("/AI11Text :").count(), 1, "the short story is text");
+}
+
+/// Stories that together make a text document larger than the reader reads: the ones past it are
+/// written as their outlines, and what is written reads back.
+#[test]
+fn stories_past_the_text_document_the_reader_reads_are_written_as_their_outlines() {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let long = format!("A{}", " ".repeat(900_000));
+    for i in 0..9 {
+        // A font of its own, which no other story names.
+        let st = vectorcraft_doc::CharStyle { font_family: format!("Probe Family {i}"), ..style(8.0, Color::BLACK) };
+        let t = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 10.0 + f64::from(i) * 10.0), &long, st);
+        let n = text_node(&mut doc, t);
+        doc.insert(Some(layer), usize::MAX, n).unwrap();
+    }
+    let out = export_ai_editing(&doc, &opts()).unwrap();
+    assert_eq!(out.warnings, [writer::TYPE]);
+    let text = String::from_utf8_lossy(&out.program).replace("\r\n", "\n");
+    let stubs = text.matches("/AI11Text :").count();
+    assert!((1..9).contains(&stubs), "{stubs}");
+    // The font set holds the fonts of the stories written, and the hidden characters' font.
+    assert_eq!(text_document(&text).matches("/CoolTypeFont").count(), stubs + 1);
+    let back = read_back(&doc);
+    let texts = back.layers[0].children().unwrap().iter().filter(|n| matches!(n.kind, NodeKind::Text(_))).count();
+    assert_eq!(texts, stubs, "every story written comes back");
+}
+
+/// A thread whose frames differ in orientation is written as its outlines: a story's frames share
+/// one.
+#[test]
+fn a_thread_of_horizontal_and_vertical_frames_is_written_as_its_outlines() {
+    use vectorcraft_doc::{TextKind, TextObject};
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut first = TextObject::point(vectorcraft_geom::Point::ZERO, "Across, then down", style(10.0, Color::BLACK));
+    first.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(10.0, 10.0, 90.0, 40.0)) };
+    first.xf = Affine::IDENTITY;
+    let mut second = first.clone();
+    second.runs[0].text.clear();
+    second.vertical = true;
+    second.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(110.0, 10.0, 190.0, 90.0)) };
+    let (first, second) = (text_node(&mut doc, first), text_node(&mut doc, second));
+    doc.text_threads.push(vec![first.id, second.id]);
+    doc.insert(Some(layer), usize::MAX, first).unwrap();
+    doc.insert(Some(layer), usize::MAX, second).unwrap();
+    let out = export_ai_editing(&doc, &opts()).unwrap();
+    assert_eq!(out.warnings, [writer::TYPE]);
+    assert!(!program(&doc).contains("/AI11Text"));
+}
+
+/// Area type in an open frame whose ends meet is written as its outlines, alone or as a frame of a
+/// thread: as text it would be read back in a closed frame.
+#[test]
+fn an_open_frame_whose_ends_meet_is_written_as_its_outlines() {
+    use vectorcraft_doc::{TextKind, TextObject};
+    let open = |r: Rect| {
+        let mut frame = shapes::rectangle(r);
+        frame.subpaths[0].closed = false;
+        let start = frame.subpaths[0].anchors[0];
+        frame.subpaths[0].anchors.push(start);
+        frame
+    };
+    let mut alone = TextObject::point(vectorcraft_geom::Point::ZERO, "Open", style(10.0, Color::BLACK));
+    alone.kind = TextKind::Area { frame: open(Rect::new(10.0, 10.0, 90.0, 40.0)) };
+    alone.xf = Affine::IDENTITY;
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let n = text_node(&mut doc, alone.clone());
+    doc.insert(Some(layer), usize::MAX, n).unwrap();
+    assert_eq!(export_ai_editing(&doc, &opts()).unwrap().warnings, [writer::TYPE]);
+    assert!(!program(&doc).contains("/AI11Text"));
+
+    let mut first = alone;
+    first.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(10.0, 10.0, 90.0, 40.0)) };
+    let mut second = first.clone();
+    second.runs[0].text.clear();
+    second.kind = TextKind::Area { frame: open(Rect::new(110.0, 10.0, 190.0, 90.0)) };
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let (first, second) = (text_node(&mut doc, first), text_node(&mut doc, second));
+    doc.text_threads.push(vec![first.id, second.id]);
+    doc.insert(Some(layer), usize::MAX, first).unwrap();
+    doc.insert(Some(layer), usize::MAX, second).unwrap();
+    assert_eq!(export_ai_editing(&doc, &opts()).unwrap().warnings, [writer::TYPE]);
+    assert!(!program(&doc).contains("/AI11Text"));
+}
+
+/// A thread with a frame in a clipping group whose clipping object is a path stays type, every frame
+/// of it, and comes back as one thread: the art of such a group isn't cut.
+#[test]
+fn a_thread_with_a_frame_in_a_clipping_group_stays_type() {
+    use vectorcraft_doc::{TextKind, TextObject};
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut first = TextObject::point(vectorcraft_geom::Point::ZERO, "A story in two frames", style(10.0, Color::BLACK));
+    first.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(10.0, 10.0, 90.0, 40.0)) };
+    first.xf = Affine::IDENTITY;
+    let mut second = first.clone();
+    second.runs[0].text.clear();
+    second.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(110.0, 10.0, 190.0, 40.0)) };
+    let (first, second) = (text_node(&mut doc, first), text_node(&mut doc, second));
+    doc.text_threads.push(vec![first.id, second.id]);
+    let clipper = clipping(&mut doc, shapes::rectangle(Rect::new(100.0, 0.0, 200.0, 50.0)));
+    let clipped = group(&mut doc, vec![clipper, second], true);
+    doc.insert(Some(layer), usize::MAX, first).unwrap();
+    doc.insert(Some(layer), usize::MAX, clipped).unwrap();
+    assert!(export_ai_editing(&doc, &opts()).unwrap().warnings.is_empty());
+    assert_eq!(program(&doc).matches("/AI11Text :").count(), 2);
+    assert_eq!(read_back(&doc).text_threads.len(), 1);
+}
+
+/// A thread with a frame in art cut to a clipping object that isn't a path is written as its
+/// outlines, every frame of it; so is type whose size is past what the reader reads.
+#[test]
+fn a_thread_with_a_frame_in_cut_art_and_type_past_the_readers_sizes_are_outlines() {
+    use vectorcraft_doc::{TextKind, TextObject};
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut first = TextObject::point(vectorcraft_geom::Point::ZERO, "A story in two frames", style(10.0, Color::BLACK));
+    first.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(10.0, 10.0, 90.0, 40.0)) };
+    first.xf = Affine::IDENTITY;
+    let mut second = first.clone();
+    second.runs[0].text.clear();
+    second.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(110.0, 10.0, 190.0, 40.0)) };
+    let (first, second) = (text_node(&mut doc, first), text_node(&mut doc, second));
+    doc.text_threads.push(vec![first.id, second.id]);
+    // The second frame is clipped by type: its art is cut to the type's outlines.
+    let clipper = text_node(&mut doc, TextObject::point(vectorcraft_geom::Point::new(110.0, 30.0), "CUT", style(30.0, Color::BLACK)));
+    let cut = group(&mut doc, vec![clipper, second], true);
+    doc.insert(Some(layer), usize::MAX, first).unwrap();
+    doc.insert(Some(layer), usize::MAX, cut).unwrap();
+    let huge = TextObject::point(vectorcraft_geom::Point::new(10.0, 90.0), "Huge", style(12.0, Color::BLACK));
+    let huge = TextObject { xf: Affine::translate((10.0, 90.0)) * Affine::scale(1e5), ..huge };
+    let huge = text_node(&mut doc, huge);
+    doc.insert(Some(layer), usize::MAX, huge).unwrap();
+    let text = program(&doc);
+    assert!(!text.contains("/AI11Text"), "{text}");
+    // Tracking that rounds to the reader's limit, 100,000, is written as outlines.
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut wide = TextObject::point(vectorcraft_geom::Point::new(10.0, 50.0), "Wide", style(12.0, Color::BLACK));
+    wide.runs[0].style.tracking = 99_999.6;
+    let wide = text_node(&mut doc, wide);
+    doc.insert(Some(layer), usize::MAX, wide).unwrap();
+    let text = program(&doc);
+    assert!(!text.contains("/AI11Text"), "{text}");
+    // A frame that is the clipping object of a clipping group is written as the clipping outline.
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut first = TextObject::point(vectorcraft_geom::Point::ZERO, "A story in two frames", style(10.0, Color::BLACK));
+    first.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(10.0, 10.0, 90.0, 40.0)) };
+    first.xf = Affine::IDENTITY;
+    let mut second = first.clone();
+    second.runs[0].text.clear();
+    second.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(110.0, 10.0, 190.0, 40.0)) };
+    let (first, second) = (text_node(&mut doc, first), text_node(&mut doc, second));
+    doc.text_threads.push(vec![first.id, second.id]);
+    let backing = square(&mut doc, Rect::new(100.0, 0.0, 200.0, 50.0), Color::rgb(1.0, 0.0, 0.0));
+    let clipped = group(&mut doc, vec![second, backing], true);
+    doc.insert(Some(layer), usize::MAX, first).unwrap();
+    doc.insert(Some(layer), usize::MAX, clipped).unwrap();
+    let text = program(&doc);
+    assert!(!text.contains("/AI11Text"), "{text}");
+}
+
+#[test]
+fn type_the_data_cant_hold_is_written_as_its_outlines() {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let g = Gradient::new(GradientKind::Linear, vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::rgb(1.0, 0.0, 0.0))]);
+    let fill = Paint::Gradient(Box::new(GradientPaint::new(g)));
+    let t = vectorcraft_doc::TextObject::point(
+        vectorcraft_geom::Point::new(10.0, 70.0),
+        "Shaded",
+        vectorcraft_doc::CharStyle { size: 18.0, fill, ..vectorcraft_doc::CharStyle::default() },
+    );
+    let mirrored = vectorcraft_doc::TextObject {
+        xf: Affine::new([-1.0, 0.0, 0.0, 1.0, 150.0, 70.0]),
+        ..vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::ZERO, "Mirror", style(18.0, Color::BLACK))
+    };
+    // Area type in a frame of two subpaths: a frame of the text document is one path.
+    let mut holed = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::ZERO, "Two rings", style(10.0, Color::BLACK));
+    let mut rings = shapes::rectangle(Rect::new(100.0, 10.0, 190.0, 90.0));
+    rings.subpaths.extend(shapes::rectangle(Rect::new(120.0, 30.0, 170.0, 70.0)).subpaths);
+    holed.kind = vectorcraft_doc::TextKind::Area { frame: rings };
+    holed.xf = Affine::IDENTITY;
+    // A carriage return in the characters: a story ends its paragraphs with it. Area type that
+    // flows around a wrap object: the wrap object's settings aren't written.
+    let returned = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 90.0), "A\rB", style(10.0, Color::BLACK));
+    let mut wrapped = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::ZERO, "Wrapped round", style(10.0, Color::BLACK));
+    wrapped.kind = vectorcraft_doc::TextKind::Area { frame: shapes::rectangle(Rect::new(10.0, 10.0, 90.0, 60.0)) };
+    wrapped.xf = Affine::IDENTITY;
+    wrapped.wrap = vec![vectorcraft_doc::WrapShape { path: shapes::rectangle(Rect::new(30.0, 20.0, 50.0, 40.0)), wrap: Default::default() }];
+    let wrapped = text_node(&mut doc, wrapped);
+    doc.insert(Some(layer), usize::MAX, wrapped).unwrap();
+    // Type on an open path whose ends meet: it would be read back on a closed path.
+    let mut ring = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::ZERO, "Round", style(10.0, Color::BLACK));
+    let mut open_ring = shapes::ellipse(Rect::new(120.0, 10.0, 180.0, 70.0));
+    if let Some(first) = open_ring.subpaths[0].anchors.first().copied() {
+        open_ring.subpaths[0].anchors.push(first);
+    }
+    open_ring.subpaths[0].closed = false;
+    ring.kind = vectorcraft_doc::TextKind::OnPath { path: open_ring, start: 0.0, end: None };
+    ring.xf = Affine::IDENTITY;
+    let ring = text_node(&mut doc, ring);
+    doc.insert(Some(layer), usize::MAX, ring).unwrap();
+    let (t, mirrored, holed, returned) =
+        (text_node(&mut doc, t), text_node(&mut doc, mirrored), text_node(&mut doc, holed), text_node(&mut doc, returned));
+    doc.insert(Some(layer), usize::MAX, t).unwrap();
+    doc.insert(Some(layer), usize::MAX, mirrored).unwrap();
+    doc.insert(Some(layer), usize::MAX, holed).unwrap();
+    doc.insert(Some(layer), usize::MAX, returned).unwrap();
+    let out = export_ai_editing(&doc, &opts()).unwrap();
+    assert_eq!(out.warnings, [writer::TYPE]);
+    assert!(!program(&doc).contains("%AI11_BeginTextDocument"));
+    let back = read_back(&doc);
+    let kinds: Vec<bool> = back.layers[0].children().unwrap().iter().map(|n| matches!(n.kind, NodeKind::Group { .. })).collect();
+    assert_eq!(kinds, [true; 6]);
+}
+
+#[test]
+fn type_attributes_the_data_cant_hold_are_reported() {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let st = vectorcraft_doc::CharStyle { underline: true, ..style(18.0, Color::BLACK) };
+    let t = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 70.0), "Under", st);
+    let t = text_node(&mut doc, t);
+    doc.insert(Some(layer), usize::MAX, t).unwrap();
+    let out = export_ai_editing(&doc, &opts()).unwrap();
+    assert_eq!(out.warnings, [writer::TYPE_ATTRIBUTES]);
+    let back = read_back(&doc);
+    assert!(matches!(back.layers[0].children().unwrap()[0].kind, NodeKind::Text(_)));
+    // Any other attribute the text document doesn't hold is reported too: No Break, a paragraph's
+    // left-to-right direction set on it, Optical Margin Alignment, a font version, a font that isn't
+    // installed whose name doesn't come back (a hyphen in its family), a Lab color,
+    // small capitals at another size, right-to-left letters aligned to the start of a paragraph
+    // without a direction of its own, tracking that isn't a whole number.
+    for edit in [
+        (|t: &mut vectorcraft_doc::TextObject| t.runs[0].style.no_break = true) as fn(&mut vectorcraft_doc::TextObject),
+        |t| t.runs[0].style.tracking = 12.5,
+        |t| t.para.direction = Some(vectorcraft_doc::ParaDirection::LeftToRight),
+        |t| t.optical_margin = true,
+        |t| t.runs[0].style.font_version = Some("2.0".into()),
+        |t| t.runs[0].style.font_family = "my-missing font".into(),
+        |t| t.runs[0].style.fill = Paint::solid(MINT),
+        |t| t.runs[0].style.small_caps = Some(80.0),
+        |t| {
+            t.runs[0].text = "\u{645}\u{631}\u{62d}\u{628}\u{627}".into();
+            t.para.justify = vectorcraft_doc::Justify::Auto;
+        },
+    ] {
+        let with = |t: vectorcraft_doc::TextObject| {
+            let mut d = Document::new(200.0, 100.0);
+            let layer = d.layers[0].id;
+            let n = text_node(&mut d, t);
+            d.insert(Some(layer), usize::MAX, n).unwrap();
+            export_ai_editing(&d, &opts()).unwrap().warnings
+        };
+        let mut t = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 70.0), "Kept", style(18.0, Color::BLACK));
+        assert!(with(t.clone()).is_empty());
+        // A font that isn't installed keeps its family and style as its name.
+        let mut missing = t.clone();
+        missing.runs[0].style.font_family = "Missing Sans Probe".into();
+        missing.runs[0].style.font_style = "Bold Italic".into();
+        assert!(with(missing).is_empty());
+        edit(&mut t);
+        assert_eq!(with(t), [writer::TYPE_ATTRIBUTES]);
+    }
+}
+
+/// On a large canvas, area type, threaded frames and type on a path stay type: the frames and
+/// lengths are written at the canvas's scale. Frames of a thread at two scales, and area type
+/// scaled by two factors, are written as outlines.
+#[test]
+fn scaled_area_type_and_type_on_a_path_stay_type() {
+    use vectorcraft_doc::{TextKind, TextObject};
+    let mut doc = Document::new(20_000.0, 10_000.0);
+    let layer = doc.layers[0].id;
+    let framed = |text: &str, r: Rect| {
+        let mut t = TextObject::point(vectorcraft_geom::Point::ZERO, text, style(100.0, Color::BLACK));
+        t.kind = TextKind::Area { frame: shapes::rectangle(r) };
+        t.xf = Affine::IDENTITY;
+        t
+    };
+    let mut area = framed("Area", Rect::new(1000.0, 1000.0, 5000.0, 3000.0));
+    area.area.columns = 2;
+    area.area.gutter = 200.0;
+    let mut on_path = TextObject::point(vectorcraft_geom::Point::ZERO, "Along", style(100.0, Color::BLACK));
+    let mut curve = PathData::from_bezpath(&kurbo::BezPath::from_vec(vec![
+        kurbo::PathEl::MoveTo((1000.0, 5000.0).into()),
+        kurbo::PathEl::CurveTo((3000.0, 4000.0).into(), (7000.0, 4000.0).into(), (9000.0, 5000.0).into()),
+    ]));
+    curve.subpaths.iter_mut().for_each(|sp| sp.closed = false);
+    on_path.kind = TextKind::OnPath { path: curve, start: 0.0, end: None };
+    on_path.xf = Affine::IDENTITY;
+    let first = text_node(&mut doc, framed("A story in two frames", Rect::new(1000.0, 6000.0, 5000.0, 8000.0)));
+    let second = text_node(&mut doc, framed("", Rect::new(6000.0, 6000.0, 10_000.0, 8000.0)));
+    doc.text_threads.push(vec![first.id, second.id]);
+    let (area, on_path) = (text_node(&mut doc, area), text_node(&mut doc, on_path));
+    for n in [area, on_path, first, second] {
+        doc.insert(Some(layer), usize::MAX, n).unwrap();
+    }
+    let out = export_ai_editing(&doc, &opts()).unwrap();
+    assert!(out.warnings.is_empty(), "{:?}", out.warnings);
+    let back = read_back(&doc);
+    let art = back.layers[0].children().unwrap();
+    let texts: Vec<&TextObject> = art.iter().filter_map(|n| if let NodeKind::Text(t) = &n.kind { Some(t.as_ref()) } else { None }).collect();
+    assert_eq!(texts.len(), 4);
+    assert_eq!(back.text_threads.len(), 1);
+    let TextKind::Area { frame } = &texts[0].kind else { panic!("area type") };
+    let b = frame.transformed(texts[0].xf).bounds().unwrap();
+    assert_eq!([b.x0, b.y0, b.x1, b.y1].map(r3), ["1000.000", "1000.000", "5000.000", "3000.000"].map(String::from));
+    // The reader scales the document back: its matrix holds the canvas's scale, and its lengths
+    // through that matrix are the ones written.
+    let k = |t: &TextObject| t.xf.as_coeffs()[0];
+    assert_eq!(
+        (r3(texts[0].runs[0].style.size * k(texts[0])), texts[0].area.columns, r3(texts[0].area.gutter * k(texts[0]))),
+        ("100.000".to_string(), 2, "200.000".to_string())
+    );
+    assert!(matches!(texts[1].kind, TextKind::OnPath { .. }));
+    assert_eq!(r3(texts[1].runs[0].style.size * k(texts[1])), "100.000");
+
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut uneven = framed("Uneven", Rect::new(10.0, 10.0, 50.0, 30.0));
+    uneven.xf = Affine::new([2.0, 0.0, 0.0, 1.0, 0.0, 0.0]);
+    let uneven = text_node(&mut doc, uneven);
+    doc.insert(Some(layer), usize::MAX, uneven).unwrap();
+    assert!(!program(&doc).contains("/AI11Text"));
+
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let first = framed("A story in two frames", Rect::new(10.0, 10.0, 50.0, 30.0));
+    let mut second = framed("", Rect::new(30.0, 20.0, 50.0, 30.0));
+    second.xf = Affine::scale(2.0);
+    let (first, second) = (text_node(&mut doc, first), text_node(&mut doc, second));
+    doc.text_threads.push(vec![first.id, second.id]);
+    doc.insert(Some(layer), usize::MAX, first).unwrap();
+    doc.insert(Some(layer), usize::MAX, second).unwrap();
+    assert!(!program(&doc).contains("/AI11Text"));
+}
+
+/// See-through type with the knockout shape flag comes back with the flag and writes no warning.
+#[test]
+fn the_knockout_shape_of_type_comes_back() {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut text = text_node(&mut doc, vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 40.0), "Hi", style(10.0, Color::BLACK)));
+    (text.opacity, text.knockout_shape) = (0.5, true);
+    doc.insert(Some(layer), usize::MAX, text).unwrap();
+    assert!(export_ai_editing(&doc, &opts()).unwrap().warnings.is_empty());
+    let back = read_back(&doc);
+    let n = &back.layers[0].children().unwrap()[0];
+    assert!(matches!(n.kind, NodeKind::Text(_)));
+    assert_eq!((n.opacity, n.knockout_shape), (0.5, true));
+}
+
+/// The kinds of object that write no paint before their `Xy` or no state block after them, and a
+/// group, which writes a state block.
+#[derive(Clone, Copy, Debug)]
+enum Beside {
+    Type,
+    Compound,
+    Image,
+    Guide,
+    Group,
+}
+
+/// An object of `kind` at `x`, with opacity, blending mode and knockout shape flag `state`.
+fn beside(doc: &mut Document, kind: Beside, x: f64, state: (f32, BlendMode, bool)) -> Node {
+    let r = Rect::new(x, 10.0, x + 20.0, 30.0);
+    let mut n = match kind {
+        Beside::Type => {
+            let t = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(x, 40.0), "Hi", style(10.0, Color::BLACK));
+            text_node(doc, t)
+        }
+        Beside::Compound => {
+            let outer = Node::path(doc.alloc_id(), shapes::rectangle(r), Appearance::default());
+            let inner = Node::path(doc.alloc_id(), shapes::rectangle(Rect::new(x + 5.0, 15.0, x + 15.0, 25.0)), Appearance::default());
+            let mut ring =
+                Node::new(doc.alloc_id(), NodeKind::Compound { children: vec![Arc::new(outer), Arc::new(inner)], rule: FillRule::EvenOdd });
+            ring.appearance = Appearance::basic(solid(BRAND), Paint::None, 0.0).into();
+            ring
+        }
+        Beside::Image => {
+            let mut png = vec![];
+            let img = image::RgbaImage::from_raw(1, 1, vec![255, 0, 0, 255]).unwrap();
+            img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+            let blob = ImageBlob::new("image/png", png);
+            let key = blob.content_key();
+            doc.images.insert(key.clone(), blob);
+            let xf = Affine::new([10.0, 0.0, 0.0, 10.0, x, 10.0]);
+            let im = ImageObject { key, width: 1, height: 1, xf, link: None, placement: Default::default(), pixels: None };
+            Node::new(doc.alloc_id(), NodeKind::Image(Box::new(im)))
+        }
+        Beside::Guide => Node::new(
+            doc.alloc_id(),
+            NodeKind::Path { path: shapes::rectangle(r), rule: FillRule::NonZero, live: None, clipping: false, guide: true },
+        ),
+        Beside::Group => {
+            let member = square(doc, r, BRAND);
+            group(doc, vec![member], false)
+        }
+    };
+    (n.opacity, n.blend, n.knockout_shape) = state;
+    n
+}
+
+/// Two objects next to each other come back with their own opacity, blending mode and knockout
+/// shape flag, whichever is first and whichever is opaque: an `Xy` right after a text object or a
+/// compound path is theirs when no other operator comes between. The layer's stays its own.
+#[test]
+fn objects_next_to_each_other_keep_their_own_transparency() {
+    use Beside::{Compound, Group, Guide, Image, Type};
+    let (clear, screen, plain) = ((0.5, BlendMode::Multiply, true), (0.25, BlendMode::Screen, false), (1.0, BlendMode::Normal, false));
+    let pairs = [
+        (Type, Type),
+        (Compound, Type),
+        (Group, Type),
+        (Type, Group),
+        (Type, Compound),
+        (Type, Image),
+        (Type, Guide),
+        (Compound, Image),
+        (Compound, Guide),
+    ];
+    for (a, b) in pairs {
+        for (first, second) in [(clear, plain), (plain, clear), (clear, screen), (clear, clear)] {
+            let mut doc = Document::new(200.0, 100.0);
+            let layer = doc.layers[0].id;
+            let (x, y) = (beside(&mut doc, a, 10.0, first), beside(&mut doc, b, 60.0, second));
+            doc.insert(Some(layer), usize::MAX, x).unwrap();
+            doc.insert(Some(layer), usize::MAX, y).unwrap();
+            let back = read_back(&doc);
+            let at = format!("{a:?} {first:?} then {b:?} {second:?}");
+            let kids = back.layers[0].children().unwrap();
+            assert_eq!(kids.len(), 2, "{at}");
+            for (n, want) in kids.iter().zip([first, second]) {
+                assert_eq!((n.opacity, n.blend, n.knockout_shape), want, "{at}");
+            }
+            let l = &back.layers[0];
+            assert_eq!((l.opacity, l.blend, l.knockout_shape), plain, "the layer's own: {at}");
+        }
+    }
+}
+
+/// A layer whose last object is type keeps its own transparency, and the type keeps its.
+#[test]
+fn type_last_in_a_transparent_layer_keeps_its_own_transparency() {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let text = beside(&mut doc, Beside::Type, 10.0, (0.5, BlendMode::Multiply, true));
+    doc.insert(Some(layer), usize::MAX, text).unwrap();
+    let l = Arc::make_mut(&mut doc.layers[0]);
+    (l.opacity, l.blend) = (0.75, BlendMode::Screen);
+    let back = read_back(&doc);
+    let (l, n) = (&back.layers[0], &back.layers[0].children().unwrap()[0]);
+    assert_eq!((l.opacity, l.blend), (0.75, BlendMode::Screen));
+    assert_eq!((n.opacity, n.blend, n.knockout_shape), (0.5, BlendMode::Multiply, true));
+}
+
+/// Isolate Blending and the Knockout Group state of type come back, named or not and whatever
+/// follows it, as outlines kept them on their group, and are written again as the same bytes.
+#[test]
+fn the_isolation_and_knockout_of_type_come_back() {
+    for name in [None, Some("Title")] {
+        let cases = [(true, Knockout::On), (false, Knockout::On), (false, Knockout::Off), (true, Knockout::Neutral), (false, Knockout::Neutral)];
+        let mut doc = Document::new(200.0, 100.0);
+        let layer = doc.layers[0].id;
+        for (i, (isolate, knockout)) in cases.into_iter().enumerate() {
+            let mut n = beside(&mut doc, Beside::Type, 10.0 + 30.0 * i as f64, (0.5, BlendMode::Multiply, false));
+            (n.isolate, n.knockout) = (isolate, knockout);
+            n.name = name.map(|s| format!("{s} {i}"));
+            doc.insert(Some(layer), usize::MAX, n).unwrap();
+        }
+        let after = beside(&mut doc, Beside::Compound, 170.0, (1.0, BlendMode::Normal, false));
+        doc.insert(Some(layer), usize::MAX, after).unwrap();
+        let back = read_back(&doc);
+        let kids = back.layers[0].children().unwrap();
+        assert_eq!(kids.len(), cases.len() + 1);
+        for (i, (n, (isolate, knockout))) in kids.iter().zip(cases).enumerate() {
+            assert!(matches!(n.kind, NodeKind::Text(_)));
+            assert_eq!((n.isolate, n.knockout, n.opacity, n.blend), (isolate, knockout, 0.5, BlendMode::Multiply), "{i}");
+            assert_eq!(n.name, name.map(|s| format!("{s} {i}")));
+        }
+        assert_eq!(kids[cases.len()].opacity, 1.0);
+        let art = |d: &Document| program(d).split_once("%%EndSetup").map(|(_, art)| art.to_string()).unwrap();
+        assert_eq!(art(&back), art(&doc));
+    }
+}
+
+/// The end marker of the text document stays on one line wherever the ASCII85 ends: the reader
+/// looks for `~>` in the lines as they are, before it joins them.
+#[test]
+fn the_end_marker_of_the_text_document_stays_on_one_line() {
+    let mut at_the_boundary = 0;
+    // A character is two bytes: sizes of more digits reach the lengths that characters don't.
+    for size in [10.0, 10.25, 10.125, 10.0625] {
+        for len in 1..=60 {
+            let mut doc = Document::new(200.0, 100.0);
+            let layer = doc.layers[0].id;
+            let text = "x".repeat(len);
+            let t = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 40.0), &text, style(size, Color::BLACK));
+            let t = text_node(&mut doc, t);
+            doc.insert(Some(layer), usize::MAX, t).unwrap();
+            let p = program(&doc);
+            assert!(!p.contains("~\n%>"), "{size} {len}");
+            // A full line (`%` and 100 characters) that the `>` goes past.
+            at_the_boundary += usize::from(p.lines().any(|l| l.len() == 102 && l.ends_with("~>")));
+            let back = read_back(&doc);
+            let NodeKind::Text(read) = &back.layers[0].children().unwrap()[0].kind else { panic!("{size} {len}: not type") };
+            assert_eq!(read.plain_text(), text);
+        }
+    }
+    assert!(at_the_boundary > 0, "no length put the `~` at the end of a line");
+}
+
+/// An empty frame after a slice that ends with a paragraph break holds the story's last paragraph,
+/// and that paragraph comes back with the empty frame's style.
+#[test]
+fn an_empty_last_frame_keeps_the_style_of_the_last_paragraph() {
+    use vectorcraft_doc::{Justify, ParaStyle, TextKind, TextObject};
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut first = TextObject::point(vectorcraft_geom::Point::ZERO, "Ends\n", style(10.0, Color::BLACK));
+    first.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(10.0, 10.0, 90.0, 40.0)) };
+    first.xf = Affine::IDENTITY;
+    let mut second = TextObject::point(vectorcraft_geom::Point::ZERO, "", style(10.0, Color::BLACK));
+    second.set_all_paras(ParaStyle { justify: Justify::Right, ..ParaStyle::default() });
+    second.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(110.0, 10.0, 190.0, 40.0)) };
+    second.xf = Affine::IDENTITY;
+    let (first, second) = (text_node(&mut doc, first), text_node(&mut doc, second));
+    doc.text_threads.push(vec![first.id, second.id]);
+    doc.insert(Some(layer), usize::MAX, first).unwrap();
+    doc.insert(Some(layer), usize::MAX, second).unwrap();
+    let back = read_back(&doc);
+    let NodeKind::Text(t) = &back.layers[0].children().unwrap()[0].kind else { panic!("type") };
+    assert_eq!(t.plain_text(), "Ends\n");
+    let justify: Vec<Justify> = t.paragraph_styles().iter().map(|p| p.justify).collect();
+    assert_eq!(justify, [Justify::Left, Justify::Right]);
+}
+
+/// A minimum first baseline with the Ascent first baseline is reported, and kept with the others.
+/// An end bracket of an open path that the reader would read as none is reported, and one further
+/// from the path's end comes back.
+#[test]
+fn a_first_baseline_minimum_and_a_path_end_the_reader_cant_read_are_reported() {
+    use vectorcraft_doc::{FirstBaseline, TextKind, TextObject};
+    let with = |t: TextObject| {
+        let mut d = Document::new(300.0, 200.0);
+        let layer = d.layers[0].id;
+        let n = text_node(&mut d, t);
+        d.insert(Some(layer), usize::MAX, n).unwrap();
+        let warnings = export_ai_editing(&d, &opts()).unwrap().warnings;
+        (warnings, read_back(&d))
+    };
+    let mut area = TextObject::point(vectorcraft_geom::Point::ZERO, "Area", style(12.0, Color::BLACK));
+    area.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(20.0, 20.0, 140.0, 160.0)) };
+    area.xf = Affine::IDENTITY;
+    area.area.first_baseline_min = 40.0;
+    let (warnings, _) = with(area.clone());
+    assert_eq!(warnings, [writer::TYPE_ATTRIBUTES]);
+    area.area.first_baseline = FirstBaseline::Fixed;
+    let (warnings, back) = with(area);
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let NodeKind::Text(t) = &back.layers[0].children().unwrap()[0].kind else { panic!("type") };
+    assert_eq!((t.area.first_baseline, t.area.first_baseline_min), (FirstBaseline::Fixed, 40.0));
+
+    let on_path = |end: Option<f64>| {
+        let mut curve = PathData::from_bezpath(&kurbo::BezPath::from_vec(vec![
+            kurbo::PathEl::MoveTo((20.0, 150.0).into()),
+            kurbo::PathEl::CurveTo((50.0, 110.0).into(), (110.0, 110.0).into(), (140.0, 150.0).into()),
+        ]));
+        curve.subpaths.iter_mut().for_each(|sp| sp.closed = false);
+        let mut t = TextObject::point(vectorcraft_geom::Point::ZERO, "On", style(12.0, Color::BLACK));
+        t.kind = TextKind::OnPath { path: curve, start: 0.0, end };
+        t.xf = Affine::IDENTITY;
+        t
+    };
+    assert_eq!(with(on_path(Some(0.999))).0, [writer::TYPE_ATTRIBUTES]);
+    assert!(with(on_path(None)).0.is_empty());
+    let (warnings, back) = with(on_path(Some(0.5)));
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let NodeKind::Text(t) = &back.layers[0].children().unwrap()[0].kind else { panic!("type") };
+    let TextKind::OnPath { end: Some(end), .. } = t.kind else { panic!("an end bracket") };
+    assert!((end - 0.5).abs() < 1e-3, "{end}");
+}
+
+/// A right-to-left paragraph aligned to the start of its direction comes back aligned right, as
+/// it draws; Latin type aligned to the start comes back aligned left.
+#[test]
+fn type_aligned_to_the_start_of_its_direction_keeps_its_side() {
+    use vectorcraft_doc::{Justify, ParaDirection, ParaStyle, TextObject};
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut rtl = TextObject::point(vectorcraft_geom::Point::new(150.0, 40.0), "\u{5e9}\u{5dc}\u{5d5}\u{5dd}", style(12.0, Color::BLACK));
+    rtl.set_all_paras(ParaStyle { justify: Justify::Auto, direction: Some(ParaDirection::RightToLeft), ..ParaStyle::default() });
+    let mut ltr = TextObject::point(vectorcraft_geom::Point::new(20.0, 80.0), "Start", style(12.0, Color::BLACK));
+    ltr.set_all_paras(ParaStyle { justify: Justify::Auto, ..ParaStyle::default() });
+    let (rtl, ltr) = (text_node(&mut doc, rtl), text_node(&mut doc, ltr));
+    doc.insert(Some(layer), usize::MAX, rtl).unwrap();
+    doc.insert(Some(layer), usize::MAX, ltr).unwrap();
+    assert!(export_ai_editing(&doc, &opts()).unwrap().warnings.is_empty());
+    let back = read_back(&doc);
+    let sides: Vec<Justify> =
+        back.layers[0].children().unwrap().iter().filter_map(|n| if let NodeKind::Text(t) = &n.kind { Some(t.para.justify) } else { None }).collect();
+    assert_eq!(sides, [Justify::Right, Justify::Left]);
+}
+
+/// Type in an opacity mask is written as its outlines; the type beside it as text.
+#[test]
+fn type_in_opacity_masks_is_written_as_its_outlines() {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let label = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 40.0), "Mask", style(18.0, Color::BLACK));
+    let label = text_node(&mut doc, label);
+    let mut square = square(&mut doc, Rect::new(0.0, 0.0, 100.0, 100.0), Color::rgb(1.0, 0.0, 0.0));
+    square.extras_mut().mask = Some(Box::new(OpacityMask::new(label, false)));
+    doc.insert(Some(layer), usize::MAX, square).unwrap();
+    let plain = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 90.0), "Plain", style(18.0, Color::BLACK));
+    let plain = text_node(&mut doc, plain);
+    doc.insert(Some(layer), usize::MAX, plain).unwrap();
+    let out = export_ai_editing(&doc, &opts()).unwrap();
+    assert_eq!(out.warnings, [writer::TYPE]);
+    let text = program(&doc);
+    assert_eq!(text.matches("/AI11Text :").count(), 1);
+}
+
+/// Type with an opacity mask of its own is written as its outlines, which keep the mask.
+#[test]
+fn type_with_an_opacity_mask_is_written_as_its_outlines() {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let t = vectorcraft_doc::TextObject::point(vectorcraft_geom::Point::new(10.0, 70.0), "Masked", style(18.0, Color::BLACK));
+    let mut t = text_node(&mut doc, t);
+    let art = square(&mut doc, Rect::new(0.0, 0.0, 100.0, 100.0), Color::rgb(1.0, 1.0, 1.0));
+    t.extras_mut().mask = Some(Box::new(OpacityMask::new(art, false)));
+    doc.insert(Some(layer), usize::MAX, t).unwrap();
+    assert_eq!(export_ai_editing(&doc, &opts()).unwrap().warnings, [writer::TYPE]);
+    assert_eq!(program(&doc).matches("/AI11Text :").count(), 0);
+    let back = read_back(&doc);
+    let top = &back.layers[0].children().unwrap()[0];
+    assert!(!matches!(top.kind, NodeKind::Text(_)));
+    assert!(top.extras().mask.is_some());
+}
diff --git a/crates/eps/src/ai_editing/writer.rs b/crates/eps/src/ai_editing/writer.rs
index 78602b939..37b8868ec 100644
--- a/crates/eps/src/ai_editing/writer.rs
+++ b/crates/eps/src/ai_editing/writer.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use vectorcraft_color::cms::Cms;
 use vectorcraft_color::swatch::{REGISTRATION, Swatch};
 use vectorcraft_color::{BlendMode, Color, Paint};
-use vectorcraft_doc::{AppearanceItem, Document, FillLayer, Knockout, LAYER_COLORS, LayerColor, Node, NodeKind, OpacityMask, StrokeLayer};
+use vectorcraft_doc::{AppearanceItem, Document, FillLayer, Knockout, LAYER_COLORS, LayerColor, Node, NodeId, NodeKind, OpacityMask, StrokeLayer};
 use vectorcraft_effects::stroke;
 use vectorcraft_geom::{Affine, FillRule, PathData, Shape, SubPath};
 use vectorcraft_pathops::BoolOp;
@@ -17,19 +17,22 @@ use crate::ps;
 
 mod images;
 mod paints;
+mod texts;
 
 pub(super) use images::PAYLOAD;
 #[cfg(test)]
 pub(super) use images::{IMAGE_DEPTH, IMAGES, LINKS_EMBEDDED};
 #[cfg(test)]
 pub(super) use paints::{GRADIENT_MIX, GRADIENT_SHAPES, GRADIENTS, STOP_LINKS, SWATCH_PLACEMENT, free_gradient_name};
+#[cfg(test)]
+pub(super) use texts::TYPE_ATTRIBUTES;
 
 /// How deep symbols, live objects and pattern tiles may nest in one another (deeper art is left
 /// out). Groups and layers need no limit of their own: a document is never deeper than
 /// [`vectorcraft_doc::MAX_DEPTH`].
 const MAX_NEST: u32 = 8;
 
-pub(super) const TYPE: &str = "type is written as its outlines in the editing data for other apps";
+pub(super) const TYPE: &str = "type in opacity masks, pattern tiles and art cut to a clipping object, mirrored type, area type and type on a path that is turned or unevenly scaled or whose frame or path has several parts, area type in an open frame, type on an open path whose ends meet, area type that flows around a text wrap, type of only white space, threads of type on a path, threads whose frames differ in orientation or hold a frame written as outlines, type of sizes past what the reader reads, stories past what the reader reads (1,048,576 bytes a story, 16,777,216 bytes in all, and the size of text document it reads), and type with inline graphics, ruby, gradient or pattern paint, or fills, strokes, effects or an opacity mask of the object's own, is written as its outlines in the editing data for other apps";
 pub(super) const PATTERNS: &str = "pattern fills whose tiles aren't a grid or whose art reaches past the tile, pattern fills in another pattern's tile and pattern fills nested more than 8 deep are written as their tiles cut to the shape in the editing data for other apps";
 pub(super) const PATTERN_TILES: &str = "pattern fills with more tiles than a fill places are written filled gray in the editing data for other apps";
 pub(super) const CLIPPING: &str = "clipping groups and clipping layers whose clipping object isn't a path, and the clipping groups inside them, are written as their art cut to that object in the editing data for other apps";
@@ -157,6 +160,8 @@ pub(super) struct Writer<'a> {
     /// How many parts of the data written on `%_` lines (opacity masks' art, patterns' tiles) the
     /// art being written is in.
     hidden: u32,
+    /// The text document: the stories of the type written as text.
+    pub(super) texts: texts::TextDoc,
 }
 
 impl<'a> Writer<'a> {
@@ -176,6 +181,7 @@ impl<'a> Writer<'a> {
             canvas_origin: origin,
             payloads: vec![],
             hidden: 0,
+            texts: texts::TextDoc::default(),
             cms: vectorcraft_color::cms::active(),
             body: String::new(),
             warnings: vec![],
@@ -332,6 +338,16 @@ impl<'a> Writer<'a> {
         }
     }
 
+    /// [`Self::set_xy`] for an object that writes no paint before its transparency (type, an image,
+    /// a guide): `XR` comes first, as in [`Self::paint_state`], because an `Xy` right after a compound
+    /// path or a text object would be theirs.
+    fn set_object_xy(&mut self, xy: Xy) {
+        if self.gs != Some(xy) {
+            self.line("0 XR");
+            self.write_xy(xy);
+        }
+    }
+
     /// `mode opacity isolate knockout shape Xy`.
     fn write_xy(&mut self, xy: Xy) {
         let knockout = match xy.knockout {
@@ -350,6 +366,11 @@ impl<'a> Writer<'a> {
     /// dictionary goes between the two ([`Self::node`]).
     fn end_group(&mut self, close: &str, xy: Xy) {
         self.line(close);
+        self.state_block(xy);
+    }
+
+    /// The state block of the group or text object just written ([`Self::end_group`]).
+    fn state_block(&mut self, xy: Xy) {
         self.block_start = self.body.len();
         if xy == Xy::PLAIN {
             self.line("9 () XW");
@@ -391,7 +412,7 @@ impl<'a> Writer<'a> {
                 if *guide {
                     // Its own transparency, not the one the object before it set.
                     if path.subpaths.iter().any(|sp| !sp.anchors.is_empty()) {
-                        self.set_xy(xy.object());
+                        self.set_object_xy(xy.object());
                     }
                     ai_ops::guide(&mut self.body, self.to_art, path, true);
                 } else {
@@ -522,8 +543,19 @@ impl<'a> Writer<'a> {
         let outer = std::mem::take(&mut self.body);
         let (state, clip) = (self.state, self.clip.take());
         (self.state, self.gs) = (Some((false, false)), Some(Xy::OPAQUE));
-        // A plain group holding the art is the group the art is read into.
-        let art = &m.art;
+        // The canvas draws the art's root even when it is hidden, and the reader puts a hidden object
+        // in a group that doesn't draw it, so a hidden root is written shown.
+        let shown;
+        let art = if m.art.visible {
+            &m.art
+        } else {
+            let mut a = (*m.art).clone();
+            a.visible = true;
+            shown = Arc::new(a);
+            &shown
+        };
+        // A plain group of two or more objects, or of none, is the group the art is read into. A group
+        // of one object is written as a group, because the reader makes one shown object the art.
         let plain = matches!(art.kind, NodeKind::Group { clip: false, .. })
             && Xy::of(art) == Xy::PLAIN
             && art.visible
@@ -531,7 +563,7 @@ impl<'a> Writer<'a> {
             && art.name.as_deref().is_none_or(str::is_empty)
             && art.extras().mask.is_none();
         let members = match art.children() {
-            Some(c) if plain => c.as_slice(),
+            Some(c) if plain && c.len() != 1 => c.as_slice(),
             _ => std::slice::from_ref(art),
         };
         self.nest += 1;
@@ -830,7 +862,7 @@ impl<'a> Writer<'a> {
 
     /// The paint of a path of transparency `xy` filled by `rule`: its fill color and `O`, its stroke
     /// color and `R`, `Xy`, the line style, `XR`. Without paint, `XR` comes first: an `Xy` right
-    /// after a group or compound path would be theirs.
+    /// after a compound path or a text object would be theirs.
     fn paint_state(&mut self, fill: Option<&FillLayer>, stroke: Option<&StrokeLayer>, xy: Xy, rule: FillRule) {
         let rule = if rule == FillRule::EvenOdd { "1 XR" } else { "0 XR" };
         if let Some(f) = fill {
@@ -880,12 +912,43 @@ impl<'a> Writer<'a> {
 
     // ---------- type ----------
 
+    /// Type `n`: a text object stub naming its story in the text document ([`texts`]) when the
+    /// text document can hold it, outside opacity masks, pattern tiles and art cut to a clipping
+    /// object; else its outlines ([`Self::outlined_text`]). A frame of threaded area type names the
+    /// story of its thread, which its first frame holds.
+    fn text(&mut self, n: &Node, xy: Xy) {
+        let NodeKind::Text(t) = &n.kind else { return };
+        let doc = self.doc;
+        let placed = if self.hidden > 0 || self.clip.is_some() {
+            None
+        } else if let Some(thread) = doc.text_threads.iter().find(|th| th.contains(&n.id)) {
+            // A thread is checked for what it loses, in every frame, when its story is written.
+            let placed = self.texts.thread(doc, thread, n.id, self.canvas, &|id| !cut_to_clipping_object(doc, id));
+            placed.map(|p| (p, self.texts.take_lost()))
+        } else if texts::holds(n, t) {
+            self.texts.add(t, self.canvas).map(|story| ((story, 0), texts::loses(t)))
+        } else {
+            None
+        };
+        let Some(((story, frame), lost)) = placed else { return self.outlined_text(n, xy) };
+        if lost {
+            self.warn(texts::TYPE_ATTRIBUTES);
+        }
+        // The stub takes the transparency set before it, as a path does. Its isolation and knockout
+        // are read only from a state block after it, as a group's are.
+        self.set_object_xy(xy.object());
+        texts::stub(&mut self.body, story, frame, t, self.to_art);
+        if xy.isolate || xy.knockout != Knockout::Neutral {
+            self.state_block(xy);
+        }
+    }
+
     /// Type `n` as a group of what Type › Create Outlines makes of it
     /// ([`vectorcraft_effects::outline_text`]): each run's glyphs with their underline and
     /// strikethrough, its color glyphs, and the object's own fills and strokes; then its inline
     /// graphics as their symbols' art where the layout places them, as the PDF page draws them;
     /// the group has the type's transparency `xy`.
-    fn text(&mut self, n: &Node, xy: Xy) {
+    fn outlined_text(&mut self, n: &Node, xy: Xy) {
         self.warn(TYPE);
         self.line("u");
         let doc = self.doc;
@@ -1150,6 +1213,18 @@ fn compound_path(n: &Node) -> PathData {
     PathData::new(subpaths)
 }
 
+/// Is object `id` of `doc` in (or inside) a clipping group or clipping layer whose clipping object
+/// isn't a path or compound path (its art is written cut to that object, [`Writer::clip_group`])?
+/// Type that is a clipping object is one of these: it isn't a path.
+fn cut_to_clipping_object(doc: &Document, id: NodeId) -> bool {
+    let ancestry = doc.ancestry(id).unwrap_or_default();
+    let above = ancestry.split_last().map(|(_, a)| a).unwrap_or_default();
+    above.iter().filter_map(|a| doc.node(*a)).any(|p| {
+        matches!(p.kind, NodeKind::Group { clip: true, .. } | NodeKind::Layer { clip: true, .. })
+            && p.children().and_then(|c| c.first()).is_none_or(|c| clip_path(c).is_none())
+    })
+}
+
 /// The outline and fill rule a clipping path or compound path `n` clips by; `None` for other
 /// clipping objects and for a path without points (it clips everything away, see
 /// [`Writer::clip_contents`]).
diff --git a/crates/eps/src/ai_editing/writer/images.rs b/crates/eps/src/ai_editing/writer/images.rs
index 6ef2ccaa3..d8bb4b16d 100644
--- a/crates/eps/src/ai_editing/writer/images.rs
+++ b/crates/eps/src/ai_editing/writer/images.rs
@@ -115,7 +115,7 @@ impl Writer<'_> {
         if cut.is_some() {
             self.line("q");
         }
-        self.set_xy(xy.object());
+        self.set_object_xy(xy.object());
         // The object places the image's own pixel grid (its width × height) wherever the file's is.
         let fit =
             Affine::scale_non_uniform(f64::from(im.width.max(1)) / f64::from(samples.width), f64::from(im.height.max(1)) / f64::from(samples.height));
diff --git a/crates/eps/src/ai_editing/writer/texts.rs b/crates/eps/src/ai_editing/writer/texts.rs
new file mode 100644
index 000000000..e8ccda106
--- /dev/null
+++ b/crates/eps/src/ai_editing/writer/texts.rs
@@ -0,0 +1,1020 @@
+//! Type as the text document of the editing data (`%AI11_BeginTextDocument`): the characters of each
+//! text object, their character and paragraph attributes and where they sit, as the text document
+//! reader reads them ([`crate::import`]'s `ate.rs`), and a text object stub (`/AI11Text`) in the
+//! layers naming its story.
+//!
+//! The document is ASCII85 on comment lines of nested dictionaries with numbers for keys. Its root
+//! holds the version (`/98`), the resources (`/0`: fonts, character and paragraph style sheets, the
+//! frames, and empty sets of the resources the writer has none of) and the objects (`/1`: the
+//! document's text settings, the stories, and the attributes stories start from). A story holds its
+//! characters (paragraphs end in `\r`, a forced line break is `\x03`), its paragraph and character
+//! runs (each a length in characters and its attributes) and the frames it flows through: point type
+//! (a point on the canvas and, when it is turned, a matrix), area type (the frame's cubic segments,
+//! rows, columns, gutters, first baseline) or type on a path (the path's cubic segments and where
+//! the type starts and ends on it). Coordinates are the canvas's (y down, 16383 points a side, its
+//! center the center of `%AI3_TemplateBox`). The stories carry no composed lines: the app that
+//! opens the file lays them out.
+
+use std::collections::{HashMap, HashSet};
+use std::fmt::Write;
+
+use kurbo::{ParamCurveArclen, PathSeg};
+use vectorcraft_color::{Color, Paint};
+use vectorcraft_doc::{
+    AreaOptions, Burasagari, CharStyle, Document, FirstBaseline, Justify, Mojikumi, Node, NodeId, NodeKind, ParaDirection, ParaStyle, PathAlign,
+    PathEffect, TextKind, TextObject, VerticalAlign,
+};
+use vectorcraft_geom::{Affine, PathData, Point};
+
+use crate::ps;
+
+/// What the text document holds of type, and what it leaves out.
+pub(in crate::ai_editing) const TYPE_ATTRIBUTES: &str = "attributes of type other than its font, size, leading, tracking, baseline shift, horizontal and vertical scale, solid fill, solid stroke and stroke weight, capitals, small capitals at the document's size, Tate-chu-yoko, paragraph alignment, indents, space before and after, hyphenation on or off and right-to-left direction (for example underline, kerning, OpenType features, swatch links of its colors, character and paragraph styles, tabs, lists, optical margin alignment, area type's inset spacing, vertical alignment and flow, a minimum first baseline with the Ascent first baseline, and type on a path's effect, alignment and spacing and an end bracket at the very end of an open path) are left out of the editing data for other apps";
+
+/// The version of the text document's form (`/98 << /0 n >>`), as the newest files users sent have it.
+const STREAM_VERSION: u32 = 14;
+/// The font that shows hidden characters, as the files users sent name it, last in the font set.
+const HIDDEN_GLYPH_FONT: &str = "AdobeInvisFont";
+/// The hidden characters that font shows: each whitespace character and the glyph it shows as.
+const HIDDEN_GLYPHS: [(&str, &str); 7] =
+    [(" ", "1"), ("\r", "6"), ("\t", "0"), ("\u{2029}", "5"), ("\u{3}", "5"), ("\u{3000}", "1"), ("\u{ad}", "3")];
+/// Most characters a line of ASCII85 holds.
+const LINE: usize = 100;
+
+/// A value of the text document.
+enum V {
+    Int(i64),
+    Real(f64),
+    /// A real to ten decimals (the turn and scale of a matrix, which the reader divides by).
+    Fine(f64),
+    /// A real to eight decimals (the type's lengths and factors, which may be small; a size the reader
+    /// multiplies by a matrix's scale comes back within these).
+    Small(f64),
+    Bool(bool),
+    Str(String),
+    Name(&'static str),
+    List(Vec<V>),
+    Dict(Vec<(u32, V)>),
+}
+
+impl V {
+    /// How many values the reader counts in `self` (each value, list and dictionary one).
+    fn count(&self) -> usize {
+        match self {
+            V::List(l) => 1 + l.iter().map(V::count).sum::<usize>(),
+            V::Dict(d) => 1 + d.iter().map(|(_, v)| v.count()).sum::<usize>(),
+            _ => 1,
+        }
+    }
+
+    fn write(&self, out: &mut Vec<u8>) {
+        match self {
+            V::Int(n) => out.extend_from_slice(n.to_string().as_bytes()),
+            V::Real(r) => {
+                let mut s = String::new();
+                ps::push_num(&mut s, if r.is_finite() { *r } else { 0.0 });
+                let s = s.trim_end();
+                out.extend_from_slice(s.as_bytes());
+                // A real is written with a point, as the files users sent write them.
+                if !s.contains(['.', 'e', 'E']) {
+                    out.extend_from_slice(b".0");
+                }
+            }
+            V::Fine(r) => decimals(*r, 10, out),
+            V::Small(r) => decimals(*r, 8, out),
+            V::Bool(b) => out.extend_from_slice(if *b { b"true" } else { b"false" }),
+            V::Str(s) => {
+                out.push(b'(');
+                let mut bytes = vec![0xfe, 0xff];
+                for u in s.encode_utf16() {
+                    bytes.extend_from_slice(&u.to_be_bytes());
+                }
+                for b in bytes {
+                    if matches!(b, b'(' | b')' | b'\\') {
+                        out.push(b'\\');
+                    }
+                    out.push(b);
+                }
+                out.push(b')');
+            }
+            V::Name(n) => {
+                out.push(b'/');
+                out.extend_from_slice(n.as_bytes());
+            }
+            V::List(l) => {
+                out.push(b'[');
+                for v in l {
+                    out.push(b' ');
+                    v.write(out);
+                }
+                out.extend_from_slice(b" ]");
+            }
+            V::Dict(d) => {
+                out.extend_from_slice(b"<<");
+                for (k, v) in d {
+                    let _ = write!(Bytes(out), " /{k} ");
+                    v.write(out);
+                }
+                out.extend_from_slice(b" >>");
+            }
+        }
+    }
+}
+
+/// `r` to `n` decimals (trailing zeros left out, a point always), into `out`.
+fn decimals(r: f64, n: i32, out: &mut Vec<u8>) {
+    let k = 10f64.powi(n);
+    let r = if r.is_finite() && (r * k).is_finite() { (r * k).round() / k } else { 0.0 };
+    let s = format!("{:.*}", n as usize, r + 0.0);
+    let s = s.trim_end_matches('0');
+    out.extend_from_slice(s.as_bytes());
+    if s.ends_with('.') {
+        out.push(b'0');
+    }
+}
+
+/// `fmt::Write` into bytes.
+struct Bytes<'a>(&'a mut Vec<u8>);
+
+impl std::fmt::Write for Bytes<'_> {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        self.0.extend_from_slice(s.as_bytes());
+        Ok(())
+    }
+}
+
+/// A length or a factor of the type's attributes, to eight decimals.
+fn real(v: f64) -> V {
+    V::Small(v)
+}
+
+fn reals(v: &[f64]) -> V {
+    V::List(v.iter().map(|x| V::Real(*x)).collect())
+}
+
+fn fines(v: &[f64]) -> V {
+    V::List(v.iter().map(|x| V::Fine(*x)).collect())
+}
+
+fn dict(pairs: Vec<(u32, V)>) -> V {
+    V::Dict(pairs)
+}
+
+/// A resource set: its resources, each `<< /0 resource >>`, and its display list.
+fn set(resources: Vec<V>, display: bool) -> V {
+    let mut d = vec![(0, V::List(resources.into_iter().map(|r| dict(vec![(0, r)])).collect()))];
+    if display {
+        d.push((1, V::List(vec![dict(vec![(0, V::Int(0))])])));
+    }
+    dict(d)
+}
+
+/// A paint: kind 0 gray (`[alpha, lightness]`), 1 RGB, 2 CMYK, as the reader's `paint` reads them.
+fn paint(c: &Color) -> V {
+    let (kind, values) = match *c {
+        Color::Gray { k } => (0, vec![1.0 - f64::from(k.clamp(0.0, 1.0))]),
+        Color::Cmyk { c, m, y, k } => (2, [c, m, y, k].iter().map(|v| f64::from(v.clamp(0.0, 1.0))).collect()),
+        Color::Rgb { .. } | Color::Lab { .. } => (1, c.to_rgb().iter().map(|v| f64::from(v.clamp(0.0, 1.0))).collect()),
+    };
+    let values: Vec<f64> = std::iter::once(1.0).chain(values).collect();
+    dict(vec![(99, V::Name("SimplePaint")), (0, dict(vec![(0, V::Int(kind)), (1, reals(&values))]))])
+}
+
+/// The color of paint `p` when the text document can hold it (a solid color or none).
+fn solid(p: &Paint) -> Option<Option<Color>> {
+    match p {
+        Paint::Solid { color, .. } => Some(Some(*color)),
+        Paint::None => Some(None),
+        Paint::Gradient(_) | Paint::Pattern { .. } => None,
+    }
+}
+
+/// Can the text document hold type `t` of object `n` as it is: point type that isn't mirrored, or
+/// area type or type on a path that is only moved ([`shape`]); characters other than inline graphics
+/// and ruby; solid fills and strokes; no fills, strokes, effects or opacity mask of the object's
+/// own; some text.
+pub(in crate::ai_editing) fn holds(n: &Node, t: &TextObject) -> bool {
+    let xf = t.xf.as_coeffs();
+    let shape_ok = match &t.kind {
+        TextKind::Point => xf.iter().all(|v| v.is_finite()) && t.xf.determinant() > 1e-12,
+        TextKind::Area { .. } => closed_frame(t),
+        // An open path whose ends meet would be read back closed.
+        TextKind::OnPath { path, .. } => {
+            let open = path.subpaths.iter().any(|sp| !sp.anchors.is_empty() && !sp.closed);
+            shape(t).as_ref().and_then(segments).is_some_and(|s| !(open && closed(&s)))
+        }
+    };
+    // Area type that flows around wrap objects: the data doesn't hold their wrap settings.
+    shape_ok
+        && t.wrap.is_empty()
+        && t.ruby.is_empty()
+        && t.runs.iter().any(|r| r.text.chars().any(|c| !c.is_whitespace()))
+        && runs_held(t)
+        && plain(n)
+        && within_reader(t, story_scale(t))
+}
+
+/// Is the frame of area type `t` one closed part? An open frame whose ends meet would be read back
+/// closed.
+fn closed_frame(t: &TextObject) -> bool {
+    shape(t).filter(|p| p.subpaths.iter().all(|sp| sp.anchors.is_empty() || sp.closed)).as_ref().and_then(segments).is_some_and(|s| closed(&s))
+}
+
+/// Document points to a unit of the story of type `t`: its scale is put into its lengths.
+fn story_scale(t: &TextObject) -> f64 {
+    1.0 / t.xf.determinant().abs().sqrt()
+}
+
+/// Are the lengths and scales of type `t`, written at `scale`, within what the reader's
+/// `Texts::style`, `Texts::para` and `AreaFrame::read` read (it reads others as their defaults)?
+fn within_reader(t: &TextObject, scale: f64) -> bool {
+    const MAX_LENGTH: f64 = 1e5;
+    let length = |v: f64| (v / scale).is_finite() && (v / scale).abs() < MAX_LENGTH;
+    // Scales are written as fractions to eight decimals.
+    let factor = |v: f64| v.is_finite() && v / 100.0 >= 1e-7 && v / 100.0 < 100.0;
+    let char_ok = |s: &CharStyle| {
+        // Sizes are written to eight decimals.
+        length(s.size)
+            && s.size / scale >= 1e-7
+            && s.leading.is_none_or(|l| length(l) && l / scale >= 1e-7)
+            // Tracking is written rounded to a whole number.
+            && s.tracking.is_finite()
+            && s.tracking.round().abs() < MAX_LENGTH
+            && length(s.baseline_shift)
+            && factor(s.h_scale)
+            && factor(s.v_scale)
+            && (s.stroke.is_none() || (s.stroke_width.is_finite() && s.stroke_width >= 0.0 && s.stroke_width / scale < 1e4))
+    };
+    let para_ok = |p: &ParaStyle| [p.left_indent, p.right_indent, p.first_line_indent, p.space_before, p.space_after].into_iter().all(length);
+    let max = vectorcraft_doc::AreaOptions::MAX_ROWS_COLUMNS;
+    let area_ok = |o: &AreaOptions| {
+        [o.gutter, o.row_gutter.unwrap_or(o.gutter), o.first_baseline_min].iter().all(|g| g.is_finite() && *g >= 0.0 && *g / scale <= 10_000.0)
+            && o.rows <= max
+            && o.columns <= max
+    };
+    t.runs.iter().all(|r| char_ok(&r.style))
+        && t.paragraph_styles().iter().all(para_ok)
+        && (!matches!(t.kind, TextKind::Area { .. }) || area_ok(&t.area))
+}
+
+/// Are the runs of `t` characters (no inline graphics, and none of the characters a story ends its
+/// paragraphs and lines with, `\r` and `\x03`) filled and stroked with solid colors or nothing?
+fn runs_held(t: &TextObject) -> bool {
+    t.runs
+        .iter()
+        .all(|r| r.inline.is_none() && !r.text.contains(['\r', '\u{3}']) && solid(&r.style.fill).is_some() && solid(&r.style.stroke).is_some())
+}
+
+/// The story of a thread whose frames `texts` (in order) each hold a slice of it: their runs one
+/// after another, and their paragraphs' attributes, a paragraph split between two frames once (a
+/// frame whose text before it doesn't end with a paragraph break continues that paragraph), and
+/// whether a paragraph split between two frames has other attributes in the second (left out:
+/// the story keeps the first's).
+fn joined(texts: &[&TextObject]) -> Option<(TextObject, bool)> {
+    let mut whole = (*texts.first()?).clone();
+    whole.runs.clear();
+    let mut last: Option<ParaStyle> = None;
+    let mut differs = false;
+    // Whether the story so far has text, and ends with a paragraph break.
+    let (mut started, mut ended) = (false, false);
+    for t in texts.iter().filter(|t| t.runs.iter().any(|r| !r.text.is_empty())) {
+        let continues = started && !ended;
+        (started, ended) = (true, t.plain_text().ends_with('\n'));
+        let own = t.paragraph_styles();
+        if continues && own.first() != last.as_ref() {
+            differs = true;
+        }
+        last = own.last().cloned();
+        whole.runs.extend(t.runs.iter().filter(|r| !r.text.is_empty()).cloned());
+    }
+    if whole.runs.is_empty() {
+        whole.runs = texts.first()?.runs.clone();
+    }
+    whole.set_paragraph_styles(vectorcraft_text::thread::story_paras(texts, &[]));
+    Some((whole, differs))
+}
+
+/// The frame of area type or the path of type on a path, in document coordinates: when the matrix
+/// of type `t` only moves it and scales it by one factor (as a large canvas does), its frame or
+/// path through that matrix ([`story_scale`] puts the factor into its lengths). `None` for point
+/// type and for type that is turned, mirrored, skewed or scaled by two factors.
+fn shape(t: &TextObject) -> Option<PathData> {
+    let [a, b, c, d, e, f] = t.xf.as_coeffs();
+    let even = a > 0.0 && (a - d).abs() <= a * 1e-9 && b == 0.0 && c == 0.0 && e.is_finite() && f.is_finite();
+    match &t.kind {
+        TextKind::Area { frame } if even => Some(frame.transformed(t.xf)),
+        TextKind::OnPath { path, .. } if even => Some(path.transformed(t.xf)),
+        _ => None,
+    }
+}
+
+/// Has text object `n` no fills, strokes or effects of its own that paint or show, and no opacity
+/// mask (the reader doesn't keep a text object's mask)?
+fn plain(n: &Node) -> bool {
+    n.appearance.items.iter().all(|i| !i.visible() || (i.paint().is_none() && !i.effects().iter().any(|e| e.visible)))
+        && !n.appearance.effects.iter().any(|e| e.visible)
+        && n.extras().mask.is_none()
+}
+
+/// Is the end bracket of type on an open path so near the path's end that the reader reads it as
+/// no bracket (`Story::node`: within 0.02 of a segment)?
+fn end_read_as_none(t: &TextObject) -> bool {
+    let (Some((_, end)), Some(segs)) = (t.kind.path_span(), shape(t).as_ref().and_then(segments)) else { return false };
+    !closed(&segs) && end < 1.0 - 1e-9 && place_on(&segs, end) >= segs.len() as f64 - 0.02
+}
+
+/// Has type `t` attributes the text document leaves out ([`TYPE_ATTRIBUTES`])?
+pub(in crate::ai_editing) fn loses(t: &TextObject) -> bool {
+    // Small capitals are read back at Document Setup's default size.
+    let default_small_caps = vectorcraft_doc::DocSetup::default().small_caps_size;
+    // A run's style as the text document holds it: every other attribute at its default. A color
+    // is held without its swatch link.
+    let held_char = |s: &CharStyle| {
+        let unlinked = |p: &Paint| match p {
+            Paint::Solid { color, .. } => Paint::solid(*color),
+            other => other.clone(),
+        };
+        let stroked = !s.stroke.is_none();
+        CharStyle {
+            font_family: s.font_family.clone(),
+            font_style: s.font_style.clone(),
+            size: s.size,
+            leading: s.leading,
+            tracking: s.tracking.round(),
+            baseline_shift: s.baseline_shift,
+            h_scale: s.h_scale,
+            v_scale: s.v_scale,
+            fill: unlinked(&s.fill),
+            stroke: unlinked(&s.stroke),
+            stroke_width: if stroked { s.stroke_width } else { CharStyle::default().stroke_width },
+            all_caps: s.all_caps,
+            small_caps: s.small_caps.filter(|v| *v == default_small_caps),
+            tate_chu_yoko: s.tate_chu_yoko,
+            ..CharStyle::default()
+        }
+    };
+    let run_lost = |s: &CharStyle| {
+        let stroked = !s.stroke.is_none();
+        let s = CharStyle { stroke_width: if stroked { s.stroke_width } else { CharStyle::default().stroke_width }, ..s.clone() };
+        // A Lab color is written as RGB.
+        let lab = |p: &Paint| matches!(p, Paint::Solid { color: Color::Lab { .. }, .. });
+        s != held_char(&s) || lab(&s.fill) || lab(&s.stroke) || !font_kept(&s)
+    };
+    // A paragraph's style as the text document holds it, and its text: aligned to the start of
+    // its direction (Auto) without a direction of its own, it comes back aligned left, which
+    // differs when its first strong letter is right-to-left.
+    let para_lost = |(p, text): (&ParaStyle, &str)| {
+        let rtl_letter = text.chars().find_map(strong_direction) == Some(true);
+        if p.justify == Justify::Auto && p.direction.is_none() && rtl_letter {
+            return true;
+        }
+        let held = ParaStyle {
+            justify: p.justify,
+            left_indent: p.left_indent,
+            right_indent: p.right_indent,
+            first_line_indent: p.first_line_indent,
+            space_before: p.space_before,
+            space_after: p.space_after,
+            hyphenate: p.hyphenate,
+            direction: p.direction.filter(|d| *d == ParaDirection::RightToLeft),
+            // The composition of Japanese punctuation new type gets (Line-end Punctuation Half
+            // Width, Standard burasagari) isn't reported: it changes no other script's lines.
+            mojikumi: if p.mojikumi == Mojikumi::LineEndHalf { p.mojikumi } else { ParaStyle::default().mojikumi },
+            burasagari: if p.burasagari == Burasagari::Standard { p.burasagari } else { ParaStyle::default().burasagari },
+            ..ParaStyle::default()
+        };
+        *p != held
+    };
+    let area = AreaOptions::default();
+    let text = t.plain_text();
+    t.runs.iter().any(|r| run_lost(&r.style))
+        || t.paragraph_styles().iter().zip(text.split('\n')).any(para_lost)
+        || t.optical_margin
+        || t.system_layout
+        || !t.fractional_widths
+        || (matches!(t.kind, TextKind::Area { .. })
+            && (t.area.inset != area.inset
+                || t.area.vertical_align != VerticalAlign::default()
+                || t.area.flow != area.flow
+                || t.area.fit != area.fit
+                // The text document holds the Ascent first baseline by leaving it out, without a minimum.
+                || (t.area.first_baseline == FirstBaseline::Ascent && t.area.first_baseline_min != 0.0)))
+        || (matches!(t.kind, TextKind::OnPath { .. })
+            && (t.path_effect != PathEffect::default() || t.path_align != PathAlign::default() || t.path_spacing != 0.0 || end_read_as_none(t)))
+}
+
+/// The name the font of style `st` is written under, and whether it's TrueType: an installed
+/// face's PostScript name; else its family and style as `family-style` (the family alone for
+/// Regular), the form the reader's `family_style` splits.
+fn font_name(st: &CharStyle) -> (String, bool) {
+    let db = vectorcraft_text::FontDb::global();
+    // The face of that family and style (the font database gives a fallback face for others).
+    match db
+        .face_version(&st.font_family, &st.font_style, st.font_version.as_deref())
+        .filter(|f| f.family == st.font_family && f.style == st.font_style)
+    {
+        Some(face) => (face.postscript_name(), face.is_truetype()),
+        None if st.font_style.is_empty() || st.font_style == "Regular" => (st.font_family.clone(), false),
+        None => (format!("{}-{}", st.font_family, st.font_style.replace(' ', "")), false),
+    }
+}
+
+/// Does the font of style `st` come back as itself: the family and style the reader makes of the
+/// name it is written under (as its `char_style` does)?
+fn font_kept(st: &CharStyle) -> bool {
+    let (family, style) = crate::family_style(&font_name(st).0);
+    let family = vectorcraft_text::FontDb::global().find_family(&family).unwrap_or(family);
+    family == st.font_family && style == st.font_style
+}
+
+/// Whether `c` is a strong right-to-left letter (`Some(true)`: Hebrew, Arabic, Syriac, Thaana, NKo
+/// and their presentation forms) or a strong left-to-right one (`Some(false)`: any other letter).
+fn strong_direction(c: char) -> Option<bool> {
+    let rtl = matches!(c, '\u{0590}'..='\u{08FF}' | '\u{FB1D}'..='\u{FDFF}' | '\u{FE70}'..='\u{FEFF}');
+    if rtl {
+        Some(true)
+    } else if c.is_alphabetic() {
+        Some(false)
+    } else {
+        None
+    }
+}
+
+/// The cubic segments of `path`, eight numbers each (start, two handles, end) in document
+/// coordinates; `None` unless it has one subpath with points and no other (a frame of the text
+/// document is one path), of no more segments than the reader reads.
+fn segments(path: &PathData) -> Option<Vec<[f64; 8]>> {
+    let mut drawn = path.subpaths.iter().filter(|sp| !sp.anchors.is_empty());
+    let sp = drawn.next().filter(|sp| sp.anchors.len() > 1 && sp.segment_count() <= crate::import::MAX_SEGMENTS)?;
+    if drawn.next().is_some() {
+        return None;
+    }
+    let bp = PathData::new(vec![sp.clone()]).to_bezpath();
+    let out: Vec<[f64; 8]> = bp
+        .segments()
+        .map(|s| {
+            let c = match s {
+                PathSeg::Line(l) => kurbo::CubicBez::new(l.p0, l.p0, l.p1, l.p1),
+                PathSeg::Quad(q) => q.raise(),
+                PathSeg::Cubic(c) => c,
+            };
+            [c.p0.x, c.p0.y, c.p1.x, c.p1.y, c.p2.x, c.p2.y, c.p3.x, c.p3.y]
+        })
+        .collect();
+    (!out.is_empty() && out.len() <= crate::import::MAX_SEGMENTS && out.iter().flatten().all(|v| v.is_finite())).then_some(out)
+}
+
+/// Do `segments` end where they start?
+fn closed(segments: &[[f64; 8]]) -> bool {
+    matches!((segments.first(), segments.last()), (Some(f), Some(l)) if (f[0] - l[6]).abs() < 1e-3 && (f[1] - l[7]).abs() < 1e-3)
+}
+
+/// Where the fraction `f` of the length of `segments` lies, as the reader's `length_fraction`
+/// reads it back: a segment's index plus the place in that segment.
+fn place_on(segments: &[[f64; 8]], f: f64) -> f64 {
+    const ACCURACY: f64 = 1e-4;
+    let cubic = |s: &[f64; 8]| kurbo::CubicBez::new((s[0], s[1]), (s[2], s[3]), (s[4], s[5]), (s[6], s[7]));
+    let lengths: Vec<f64> = segments.iter().map(|s| cubic(s).arclen(ACCURACY)).collect();
+    let total: f64 = lengths.iter().sum();
+    if !(total.is_finite() && total > 0.0) {
+        return 0.0;
+    }
+    let mut left = f.clamp(0.0, 1.0) * total;
+    for (i, (s, len)) in segments.iter().zip(&lengths).enumerate() {
+        if left <= *len || i + 1 == segments.len() {
+            let t = if *len > 0.0 { cubic(s).inv_arclen(left.min(*len), ACCURACY) } else { 0.0 };
+            return i as f64 + t.clamp(0.0, 1.0);
+        }
+        left -= len;
+    }
+    segments.len() as f64
+}
+
+/// The text document being written.
+#[derive(Default)]
+pub(in crate::ai_editing) struct TextDoc {
+    /// Each font's PostScript name and whether it's TrueType.
+    fonts: Vec<(String, bool)>,
+    frames: Vec<V>,
+    stories: Vec<V>,
+    /// The story and frame each text object of a thread is written as.
+    threaded: HashMap<NodeId, (usize, usize)>,
+    /// The threads (by their first frame) already planned.
+    planned: HashSet<NodeId>,
+    /// A thread written since the last [`Self::take_lost`] has attributes the text document leaves
+    /// out ([`loses`], in any of its frames).
+    lost: bool,
+    /// The bytes of the stories written, each counted once for each text object that names it.
+    text_bytes: usize,
+    /// The bytes of the frames and stories as written in the text document, and the values the
+    /// reader counts in them.
+    doc_bytes: usize,
+    doc_values: usize,
+}
+
+impl TextDoc {
+    pub(in crate::ai_editing) fn is_empty(&self) -> bool {
+        self.stories.is_empty()
+    }
+
+    /// The index of the font of `st` in the font set.
+    fn font(&mut self, st: &CharStyle) -> i64 {
+        let (name, truetype) = font_name(st);
+        let i = match self.fonts.iter().position(|(n, _)| *n == name) {
+            Some(i) => i,
+            None => {
+                self.fonts.push((name, truetype));
+                self.fonts.len() - 1
+            }
+        };
+        i as i64
+    }
+
+    /// The character attributes of a run in style `st`, at `scale` (document points to a unit of
+    /// the text document), as the reader's `Texts::style` reads them.
+    fn char_features(&mut self, st: &CharStyle, scale: f64) -> V {
+        let font = self.font(st);
+        let num = |v: f64, d: f64| if v.is_finite() { v } else { d };
+        // Sizes to eight decimals: the reader reads a size of 0 as none.
+        let mut d = vec![(0, V::Int(font)), (1, V::Small(num(st.size, 12.0) / scale))];
+        match st.leading {
+            Some(l) if l.is_finite() && l > 0.0 => d.extend([(4, V::Bool(false)), (5, V::Small(l / scale))]),
+            _ => d.push((4, V::Bool(true))),
+        }
+        d.extend([
+            (6, V::Small(num(st.h_scale, 100.0) / 100.0)),
+            (7, V::Small(num(st.v_scale, 100.0) / 100.0)),
+            // Tracking is a whole number of thousandths of an em.
+            (8, V::Int(num(st.tracking, 0.0).round() as i64)),
+            (9, real(num(st.baseline_shift, 0.0) / scale)),
+        ]);
+        let caps = if st.all_caps {
+            2
+        } else if st.small_caps.is_some() {
+            1
+        } else {
+            0
+        };
+        d.push((12, V::Int(caps)));
+        if st.tate_chu_yoko {
+            d.push((35, V::Int(3)));
+        }
+        let fill = solid(&st.fill).flatten();
+        // A stroke of no width keeps its paint.
+        let stroke = solid(&st.stroke).flatten();
+        if let Some(c) = &fill {
+            d.push((53, paint(c)));
+        }
+        if let Some(c) = &stroke {
+            d.push((54, paint(c)));
+        }
+        d.extend([(56, V::Bool(fill.is_some())), (57, V::Bool(stroke.is_some()))]);
+        if stroke.is_some() {
+            d.push((63, V::Small(st.stroke_width / scale)));
+        }
+        dict(d)
+    }
+
+    /// The paragraph attributes of `p` at `scale`, as the reader's `Texts::para` reads them.
+    fn para_features(p: &ParaStyle, scale: f64) -> V {
+        let rtl = p.direction == Some(ParaDirection::RightToLeft);
+        // A right-to-left paragraph's left and right alignments are each other's.
+        let justify = match p.justify {
+            // Auto: the start of the paragraph's direction.
+            Justify::Auto => 0,
+            Justify::Left if rtl => 1,
+            Justify::Right if rtl => 0,
+            Justify::Left => 0,
+            Justify::Right => 1,
+            Justify::Center => 2,
+            Justify::JustifyLeft => 3,
+            Justify::JustifyRight => 4,
+            Justify::JustifyCenter => 5,
+            Justify::JustifyAll => 6,
+        };
+        let len = |v: f64| real(if v.is_finite() { v / scale } else { 0.0 });
+        let mut d = vec![
+            (0, V::Int(justify)),
+            (1, len(p.first_line_indent)),
+            (2, len(p.left_indent)),
+            (3, len(p.right_indent)),
+            (4, len(p.space_before)),
+            (5, len(p.space_after)),
+            (9, V::Bool(p.hyphenate)),
+        ];
+        if rtl {
+            d.push((33, V::Int(1)));
+        }
+        dict(d)
+    }
+
+    /// The story of type `t`: its characters, runs and the frames `frames` (indices into the
+    /// frame set). `scale`: document points to a unit of the text document.
+    fn story(&mut self, t: &TextObject, frames: &[usize], scale: f64) -> usize {
+        let mut text = String::new();
+        let mut char_runs = vec![];
+        for r in &t.runs {
+            let piece: String = r
+                .text
+                .chars()
+                .map(|c| match c {
+                    '\n' => '\r',
+                    '\u{2028}' => '\u{3}',
+                    c => c,
+                })
+                .collect();
+            let n = piece.chars().count();
+            if n == 0 {
+                continue;
+            }
+            text.push_str(&piece);
+            let features = self.char_features(&r.style, scale);
+            char_runs.push((features, n));
+        }
+        // Every paragraph ends in `\r`, the last one too; the last run takes it.
+        text.push('\r');
+        match char_runs.last_mut() {
+            Some(last) => last.1 += 1,
+            None => {
+                let features = self.char_features(&CharStyle::default(), scale);
+                char_runs.push((features, 1));
+            }
+        }
+        let paras: Vec<(V, usize)> =
+            text.split_inclusive('\r').enumerate().map(|(i, p)| (Self::para_features(t.para_at(i), scale), p.chars().count())).collect();
+        let run = |features: V, n: usize, para: bool| {
+            let sheet = if para {
+                dict(vec![(0, V::Str(String::new())), (5, features), (6, V::Int(0))])
+            } else {
+                dict(vec![(0, V::Str(String::new())), (5, V::Int(0)), (6, features)])
+            };
+            dict(vec![(0, dict(vec![(0, sheet)])), (1, V::Int(n as i64))])
+        };
+        let para_runs: Vec<V> = paras.into_iter().map(|(f, n)| run(f, n, true)).collect();
+        let char_runs: Vec<V> = char_runs.into_iter().map(|(f, n)| run(f, n, false)).collect();
+        let model = dict(vec![
+            (0, V::Str(text)),
+            (5, dict(vec![(0, V::List(para_runs))])),
+            (6, dict(vec![(0, V::List(char_runs))])),
+            (10, dict(vec![(0, V::Int(4)), (2, V::Bool(true))])),
+        ]);
+        let view = dict(vec![(0, V::List(frames.iter().map(|f| dict(vec![(0, V::Int(*f as i64))])).collect()))]);
+        self.stories.push(dict(vec![(0, model), (1, view)]));
+        self.stories.len() - 1
+    }
+
+    /// The frame of type `t`, `canvas` taking the document onto the canvas (y down) and `scale`
+    /// being document points to a unit there. Point type's frame is its point and, unless it is
+    /// neither turned nor scaled, the matrix of its type round that point (scale taken out).
+    fn frame(&mut self, t: &TextObject, canvas: Affine, scale: f64) -> usize {
+        let mut data = vec![];
+        let mut f = vec![];
+        let vertical = t.vertical.then_some((1, V::Int(2)));
+        let segs = |path: &PathData| -> Vec<f64> {
+            segments(path)
+                .unwrap_or_default()
+                .iter()
+                .flat_map(|s| {
+                    let p = |x: f64, y: f64| canvas * Point::new(x, y);
+                    let (a, b, c, d) = (p(s[0], s[1]), p(s[2], s[3]), p(s[4], s[5]), p(s[6], s[7]));
+                    [a.x, a.y, b.x, b.y, c.x, c.y, d.x, d.y]
+                })
+                .collect()
+        };
+        match &t.kind {
+            TextKind::Point => {
+                let at = canvas * Point::new(t.xf.as_coeffs()[4], t.xf.as_coeffs()[5]);
+                f.push((0, reals(&[at.x, at.y])));
+                data.extend(vertical);
+                let [a, b, c, d, ..] = t.xf.as_coeffs();
+                let s = (a * d - b * c).abs().sqrt();
+                let (a, b, c, d) = (a / s, b / s, c / s, d / s);
+                if [a - 1.0, b, c, d - 1.0].iter().any(|v| v.abs() > 1e-9) {
+                    // Round the point: it stays where it is.
+                    let (e, g) = (at.x - (a * at.x + c * at.y), at.y - (b * at.x + d * at.y));
+                    let mut m = fines(&[a, b, c, d]);
+                    if let V::List(l) = &mut m {
+                        l.extend([V::Real(e), V::Real(g)]);
+                    }
+                    data.push((2, m));
+                }
+            }
+            TextKind::Area { .. } => {
+                f.push((1, dict(vec![(0, reals(&shape(t).map(|p| segs(&p)).unwrap_or_default()))])));
+                data.push((0, V::Int(1)));
+                data.extend(vertical);
+                let o = &t.area;
+                data.extend([(3, V::Int(o.rows.max(1) as i64)), (4, V::Int(o.columns.max(1) as i64))]);
+                data.extend([(7, real(o.row_gutter.unwrap_or(o.gutter) / scale)), (8, real(o.gutter / scale))]);
+                let kind = match o.first_baseline {
+                    FirstBaseline::Ascent => None,
+                    FirstBaseline::Fixed => Some(0),
+                    FirstBaseline::CapHeight => Some(2),
+                    FirstBaseline::Leading => Some(3),
+                    FirstBaseline::XHeight => Some(4),
+                };
+                if let Some(k) = kind {
+                    data.push((10, dict(vec![(0, V::Int(k)), (1, real(o.first_baseline_min / scale))])));
+                }
+            }
+            TextKind::OnPath { .. } => {
+                let path = shape(t).unwrap_or_else(|| PathData::new(vec![]));
+                let doc_segs = segments(&path).unwrap_or_default();
+                f.push((1, dict(vec![(0, reals(&segs(&path)))])));
+                data.push((0, V::Int(2)));
+                data.extend(vertical);
+                let (start, end) = t.kind.path_span().unwrap_or((0.0, 1.0));
+                let n = doc_segs.len() as f64;
+                let s = place_on(&doc_segs, start);
+                // Round a closed path the end is the start plus the run, past the last segment when
+                // the run passes the path's start.
+                let e = if closed(&doc_segs) {
+                    let run = (end - start).clamp(0.0, 1.0);
+                    if run >= 1.0 - 1e-9 { s + n } else { place_on(&doc_segs, end.rem_euclid(1.0)) }
+                } else {
+                    place_on(&doc_segs, end)
+                };
+                data.push((6, reals(&[s, e])));
+            }
+        }
+        f.push((2, dict(data)));
+        self.frames.push(dict(f));
+        self.frames.len() - 1
+    }
+
+    /// Room for a story of type `t` named by `frames` text objects, within what the reader reads
+    /// of a story and of all the text objects' stories together: taken when there is.
+    fn room(&mut self, t: &TextObject, frames: usize) -> bool {
+        // The story as written: `\x03` (one byte) for a forced line break, and its last `\r`.
+        let len: usize = t.runs.iter().flat_map(|r| r.text.chars()).map(|c| if c == '\u{2028}' { 1 } else { c.len_utf8() }).sum::<usize>() + 1;
+        let total = self.text_bytes.saturating_add(len.saturating_mul(frames));
+        let fits = len <= crate::import::MAX_STORY && frames <= crate::import::MAX_FRAMES && total <= crate::import::MAX_TEXT;
+        if fits {
+            self.text_bytes = total;
+        }
+        fits
+    }
+
+    /// Type `t` as a story of one frame, `canvas` taking the document onto the canvas; its story
+    /// index, `None` past what the reader reads ([`Self::room`]). Lengths are written in document
+    /// points: a large canvas document is written at its scale already, and the reader scales the
+    /// text document's lengths with the art. Type that is scaled has its scale taken out of its
+    /// frame's matrix, or put into its frame or path, and put into its lengths.
+    pub(in crate::ai_editing) fn add(&mut self, t: &TextObject, canvas: Affine) -> Option<usize> {
+        let mark = self.mark();
+        if !self.room(t, 1) {
+            return None;
+        }
+        let scale = story_scale(t);
+        let frame = self.frame(t, canvas, scale);
+        let story = self.story(t, &[frame], scale);
+        self.fits(mark).then_some(story)
+    }
+
+    /// Where the frames, stories and fonts written so far end, and the bytes of the document they
+    /// make.
+    fn mark(&self) -> (usize, usize, usize, usize, usize) {
+        (self.frames.len(), self.stories.len(), self.doc_bytes, self.text_bytes, self.fonts.len())
+    }
+
+    /// Whether the frames and stories written since `mark` keep the text document within what the
+    /// reader reads of it (its ASCII85, a quarter of the bytes it decodes, with room for the
+    /// resources and settings); when they don't, they are taken out again.
+    fn fits(&mut self, (frames, stories, bytes, text, fonts_before): (usize, usize, usize, usize, usize)) -> bool {
+        // Room for the fonts, sheets and settings: bytes, and values.
+        const RESERVE: usize = 1 << 20;
+        const RESERVE_VALUES: usize = 1 << 16;
+        let (mut added, mut values) = (0, 0);
+        for v in self.frames.iter().skip(frames).chain(self.stories.iter().skip(stories)) {
+            let mut out = vec![];
+            v.write(&mut out);
+            added += out.len() + 1;
+            values += v.count();
+        }
+        let total = bytes.saturating_add(added);
+        let total_values = self.doc_values.saturating_add(values);
+        // The font set: each name in UTF-16 with its dictionary round it.
+        let fonts: usize = self.fonts.iter().map(|(n, _)| n.encode_utf16().count() * 2 + 64).sum();
+        // ASCII85 writes five characters for every four bytes.
+        if total.saturating_add(RESERVE).saturating_add(fonts).saturating_mul(5) / 4 <= crate::import::MAX_TEXT_DOCUMENT / 4
+            && total_values.saturating_add(RESERVE_VALUES) <= crate::import::MAX_TEXT_VALUES
+        {
+            (self.doc_bytes, self.doc_values) = (total, total_values);
+            return true;
+        }
+        self.frames.truncate(frames);
+        self.stories.truncate(stories);
+        // The fonts only the stories taken out named.
+        self.fonts.truncate(fonts_before);
+        self.text_bytes = text;
+        false
+    }
+
+    /// The story and frame text object `id` of a thread is written as, planning the thread
+    /// `thread` (its frames in order, all area type the document holds, the first holding the
+    /// story) the first time one of its frames is written. `None` when the thread can't be written
+    /// as one story: `writable` says which frames are written where type can be text (every frame
+    /// of the thread must be).
+    pub(in crate::ai_editing) fn thread(
+        &mut self,
+        doc: &Document,
+        thread: &[NodeId],
+        id: NodeId,
+        canvas: Affine,
+        writable: &dyn Fn(NodeId) -> bool,
+    ) -> Option<(usize, usize)> {
+        let first = *thread.first()?;
+        if self.planned.insert(first) {
+            let members: Option<Vec<&Node>> = thread.iter().map(|i| doc.node(*i)).collect();
+            // The first frame holds the story; the others hold no text of their own.
+            // The frames of a story share one orientation (the reader reads no other).
+            let vertical = members.as_ref().and_then(|m| m.first()).is_some_and(|n| matches!(&n.kind, NodeKind::Text(t) if t.vertical));
+            // The story has one scale for its lengths, so its frames share it.
+            let scale = match members.as_ref().and_then(|m| m.first()).map(|n| &n.kind) {
+                Some(NodeKind::Text(t)) => story_scale(t),
+                _ => 1.0,
+            };
+            let area = |n: &&Node| match &n.kind {
+                NodeKind::Text(t) => {
+                    matches!(t.kind, TextKind::Area { .. })
+                        && t.vertical == vertical
+                        && writable(n.id)
+                        && t.wrap.is_empty()
+                        && plain(n)
+                        && t.ruby.is_empty()
+                        && runs_held(t)
+                        && (story_scale(t) / scale - 1.0).abs() <= 1e-9
+                        && within_reader(t, scale)
+                        && closed_frame(t)
+                }
+                _ => false,
+            };
+            let ok = members.as_ref().is_some_and(|m| m.len() > 1 && m.iter().all(area));
+            if let (true, Some(members)) = (ok, members) {
+                let texts: Vec<&TextObject> =
+                    members.iter().filter_map(|n| if let NodeKind::Text(t) = &n.kind { Some(t.as_ref()) } else { None }).collect();
+                let (whole, split_differs) = joined(&texts)?;
+                let mark = self.mark();
+                if !whole.runs.iter().any(|r| r.text.chars().any(|c| !c.is_whitespace())) || !self.room(&whole, texts.len()) {
+                    return None;
+                }
+                let lost = split_differs || texts.iter().any(|t| loses(t));
+                let frames: Vec<usize> = texts.iter().map(|t| self.frame(t, canvas, scale)).collect();
+                let story = self.story(&whole, &frames, scale);
+                if !self.fits(mark) {
+                    return None;
+                }
+                self.lost |= lost;
+                for (k, i) in thread.iter().enumerate() {
+                    self.threaded.insert(*i, (story, k));
+                }
+            }
+        }
+        self.threaded.get(&id).copied()
+    }
+
+    /// Whether a thread written since the last call has attributes the text document leaves out.
+    pub(in crate::ai_editing) fn take_lost(&mut self) -> bool {
+        std::mem::take(&mut self.lost)
+    }
+
+    /// The text document as its section of the program: `%AI11_BeginTextDocument`, the ASCII85 of
+    /// the document on comment lines, `%AI11_EndTextDocument`. `doc` gives the text settings.
+    pub(in crate::ai_editing) fn section(&self, doc: &Document) -> String {
+        let mut bytes = vec![];
+        let root: Vec<(u32, V)> = vec![(98, dict(vec![(0, V::Int(i64::from(STREAM_VERSION)))])), (0, self.resources()), (1, self.objects(doc))];
+        for (i, (k, v)) in root.iter().enumerate() {
+            if i > 0 {
+                bytes.push(b' ');
+            }
+            let _ = write!(Bytes(&mut bytes), "/{k} ");
+            v.write(&mut bytes);
+        }
+        let packed: String = ps::ascii85(&bytes).chars().filter(|c| !c.is_whitespace()).collect();
+        let mut s = String::from("%AI11_BeginTextDocument\n/AI11TextDocument : /ASCII85Decode ,\n");
+        // Each line starts with `%`, no line's data starts with `_` (a `%_` line is content), and the
+        // end marker `~>` stays on one line (the reader looks for it before it joins the lines).
+        let mut col = 0;
+        s.push('%');
+        for ch in packed.chars() {
+            if col >= LINE && ch != '_' && !(ch == '>' && s.ends_with('~')) {
+                s.push_str("\n%");
+                col = 0;
+            }
+            s.push(ch);
+            col += 1;
+        }
+        s.push_str("\n;\n%AI11_EndTextDocument\n");
+        s
+    }
+
+    fn resources(&self) -> V {
+        let mut fonts: Vec<V> = self
+            .fonts
+            .iter()
+            .map(|(name, truetype)| {
+                dict(vec![(99, V::Name("CoolTypeFont")), (0, dict(vec![(0, V::Str(name.clone())), (2, V::Int(i64::from(*truetype)))]))])
+            })
+            .collect();
+        fonts.push(dict(vec![(99, V::Name("CoolTypeFont")), (0, dict(vec![(0, V::Str(HIDDEN_GLYPH_FONT.into())), (2, V::Int(0))]))]));
+        let normal_char = dict(vec![(0, V::Str("[Normal Character Style]".into())), (6, Self::normal_char())]);
+        let normal_para = dict(vec![(0, V::Str("[Normal Paragraph Style]".into())), (5, Self::normal_para())]);
+        let empty = || set(vec![], false);
+        dict(vec![
+            (1, set(fonts, true)),
+            (2, empty()),
+            (3, empty()),
+            (4, empty()),
+            (5, set(vec![normal_char], true)),
+            (6, set(vec![normal_para], true)),
+            (8, set(self.frames.iter().map(clone_v).collect(), false)),
+            (9, empty()),
+        ])
+    }
+
+    /// The character attributes stories start from.
+    fn normal_char() -> V {
+        dict(vec![
+            (0, V::Int(0)),
+            (1, real(12.0)),
+            (4, V::Bool(true)),
+            (6, real(1.0)),
+            (7, real(1.0)),
+            (8, real(0.0)),
+            (9, real(0.0)),
+            (12, V::Int(0)),
+            (53, paint(&Color::gray(1.0))),
+            (56, V::Bool(true)),
+            (57, V::Bool(false)),
+            (63, real(1.0)),
+        ])
+    }
+
+    /// The paragraph attributes stories start from.
+    fn normal_para() -> V {
+        Self::para_features(&ParaStyle::default(), 1.0)
+    }
+
+    fn objects(&self, doc: &Document) -> V {
+        let s = &doc.setup;
+        let hidden = (self.fonts.len()) as i64;
+        let mapping = V::List(HIDDEN_GLYPHS.iter().map(|(c, g)| dict(vec![(0, V::Str((*c).into())), (1, V::Str((*g).into()))])).collect());
+        let q = &s.quotes;
+        let quotes = dict(vec![
+            (0, V::Int(0)),
+            (1, V::Str(q.double[0].to_string())),
+            (2, V::Str(q.double[1].to_string())),
+            (3, V::Str(q.single[0].to_string())),
+            (4, V::Str(q.single[1].to_string())),
+        ]);
+        let pct = |v: f64| real(if v.is_finite() { v / 100.0 } else { 0.0 });
+        let settings = dict(vec![
+            (0, dict(vec![(0, V::Int(hidden)), (1, mapping)])),
+            (1, V::Int(0)),
+            (2, V::Int(0)),
+            (3, pct(s.superscript.size)),
+            (4, pct(s.superscript.position)),
+            (5, pct(s.subscript.size)),
+            (6, pct(s.subscript.position)),
+            (7, pct(s.small_caps_size)),
+            (8, V::Bool(s.typographers_quotes)),
+            (9, V::List(vec![quotes])),
+            (11, V::Int(6)),
+            (16, V::Bool(true)),
+            (17, V::Int(0)),
+        ]);
+        dict(vec![(0, settings), (1, V::List(self.stories.iter().map(clone_v).collect())), (2, Self::normal_char()), (3, Self::normal_para())])
+    }
+}
+
+/// A copy of `v`.
+fn clone_v(v: &V) -> V {
+    match v {
+        V::Int(n) => V::Int(*n),
+        V::Real(r) => V::Real(*r),
+        V::Fine(r) => V::Fine(*r),
+        V::Small(r) => V::Small(*r),
+        V::Bool(b) => V::Bool(*b),
+        V::Str(s) => V::Str(s.clone()),
+        V::Name(n) => V::Name(n),
+        V::List(l) => V::List(l.iter().map(clone_v).collect()),
+        V::Dict(d) => V::Dict(d.iter().map(|(k, v)| (*k, clone_v(v))).collect()),
+    }
+}
+
+/// The text object stub of story `story`, frame `frame`: `/AI11Text :`, `/FreeUndo`, `/FrameIndex`,
+/// `/StoryIndex`, for area type and type on a path the frame's path (`/Art :`, `X=`, the path in
+/// art space through `to_art`, `X+`, `; /ConfiningPath ,`), `/TextAntialiasing`, `;`.
+pub(in crate::ai_editing) fn stub(s: &mut String, story: usize, frame: usize, t: &TextObject, to_art: Affine) {
+    let _ = writeln!(s, "/AI11Text :\n0 /FreeUndo ,\n{frame} /FrameIndex ,\n{story} /StoryIndex ,");
+    let area = matches!(t.kind, TextKind::Area { .. });
+    if let Some(path) = shape(t) {
+        s.push_str("/Art :\nX=\n");
+        for sp in path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()) {
+            crate::ai_ops::subpath(s, to_art, sp);
+            s.push_str(if sp.closed || area { "n\n" } else { "N\n" });
+        }
+        s.push_str("X+\n; /ConfiningPath ,\n");
+    }
+    s.push_str("2 /TextAntialiasing ,\n;\n");
+}
diff --git a/crates/eps/src/import.rs b/crates/eps/src/import.rs
index 1b0ad8604..e0110f3de 100644
--- a/crates/eps/src/import.rs
+++ b/crates/eps/src/import.rs
@@ -71,8 +71,9 @@ use interp::{Fault, Interp};
 use obj::PsError;
 
 pub(crate) use ai::MAX_GRADIENT_STOPS;
-pub(crate) use native::scale_document;
+pub(crate) use ate::{MAX_BYTES as MAX_TEXT_DOCUMENT, MAX_FRAMES, MAX_SEGMENTS, MAX_STORY, MAX_VALUES as MAX_TEXT_VALUES};
 pub use native::{AiLayers, ai_alone, ai_alone_on_page, ai_layers_alone, is_loss, layered_ai, layered_ai_from};
+pub(crate) use native::{MAX_TEXT, scale_document};
 pub use text::family_style;
 
 /// The page of a PostScript file without a bounding box (US Letter).
diff --git a/crates/eps/src/import/ai/blend.rs b/crates/eps/src/import/ai/blend.rs
index 494a11cdc..6124c9eee 100644
--- a/crates/eps/src/import/ai/blend.rs
+++ b/crates/eps/src/import/ai/blend.rs
@@ -11,7 +11,7 @@
 //! and the spine, each object's `/ArtDictionary` naming its part (`ShapeBlendPathType`: `K` a key,
 //! `S` the spine) and a key's id (`ShapeBlendPathID`); then the steps drawn, a group on plain
 //! lines; then `(Adobe Path Blends) 1 0 n XP` and `n` bytes as hex on `%` lines. Those bytes
-//! start `DCBA`.
+//! start `DCBA`. A blend whose spine was never edited has no spine part: only its keys.
 //!
 //! The reader reads the words after `DCBA` (little endian) this way. Word 1 is the spacing: 0 is
 //! Smooth Color, 1 is Specified Steps and 2 is Specified Distance. For Specified Distance, word 2
@@ -28,7 +28,7 @@ use vectorcraft_color::{Color, Paint};
 use vectorcraft_doc::blend::{blend_expand, blend_steps};
 use vectorcraft_doc::live::{BlendOrientation, BlendSpacing, BlendSpec};
 use vectorcraft_doc::{AppearanceItem, Node, NodeId, NodeKind};
-use vectorcraft_geom::{PathData, Point};
+use vectorcraft_geom::{PathData, Point, SubPath};
 
 /// The plugin that writes blends.
 pub(super) const PLUGIN: &str = "Adobe Path Blends"; // brand-ok: the plugin name the files use
@@ -149,7 +149,12 @@ pub(super) fn live_blend(edit: &Node, drawn: &Node, record: &Record, roles: &Rol
             Arc::new(k)
         })
         .collect();
-    let spine = spine?;
+    // A blend whose spine was never edited has none written: its spine is the straight lines
+    // between the keys' centres, in the record's order.
+    let spine = match spine {
+        Some(spine) => spine,
+        None => straight_spine(&keys, ids, roles)?,
+    };
     let key_anchors = on_spine(&keys, &spine)?;
     let spacing = match record.spacing {
         // Specified Steps: the steps between two keys are the drawn objects that aren't keys,
@@ -204,6 +209,20 @@ fn on_spine(keys: &[Arc<Node>], spine: &PathData) -> Option<Vec<u32>> {
     Some(out)
 }
 
+/// The straight lines between the centres of `keys`, taken in the order of the record's `ids`: a
+/// blend's spine until it is edited or replaced, as [`vectorcraft_doc::blend::blend_spine`] lays
+/// out a blend with no spine of its own.
+fn straight_spine(keys: &[Arc<Node>], ids: &[String], roles: &Roles) -> Option<PathData> {
+    let centres = ids
+        .iter()
+        .map(|id| {
+            let key = keys.iter().find(|k| roles.get(&k.id).and_then(|(_, named)| named.as_ref()) == Some(id))?;
+            centre(key)
+        })
+        .collect::<Option<Vec<Point>>>()?;
+    Some(PathData::single(SubPath::polyline(&centres, false)))
+}
+
 fn centre(n: &Node) -> Option<Point> {
     n.geometric_bounds().map(|b| b.center()).filter(|p| p.x.is_finite() && p.y.is_finite())
 }
diff --git a/crates/eps/src/import/ai/brush.rs b/crates/eps/src/import/ai/brush.rs
index f67724693..69e88528c 100644
--- a/crates/eps/src/import/ai/brush.rs
+++ b/crates/eps/src/import/ai/brush.rs
@@ -19,14 +19,23 @@
 //!   /PluginObject`), and the brush's settings for this path as entries: `Diameter`, `Roundness`,
 //!   `Angle`, their `…Variation` either side and `…DependsOn` codes, and `AngleRelativeTo` (0 the
 //!   page).
+//! - A path with an Art brush is a stroke in its art style too: the filter
+//!   `(Adobe ArtOnPath Brush Tool)`, its stroke's paint and weight (the weight scales the art across
+//!   the path), the brush by name, and its settings for this path as entries: `Scaling`,
+//!   `MinScaling` and `MaxScaling` (the width as a factor), `Colorization`, `Proportional`,
+//!   `Segmented` with `StartSegmentLength` and `EndSegmentLength`, `UpsideDown`, `Counterclockwise`,
+//!   `ScaleYDependsOn`, `Spacing`, `Adjustment` and `FoldAdjustment` (1 is
+//!   [`vectorcraft_brush::ArtBrush`]'s `overlap: false`).
 //! - A Scatter, Art or Pattern brush's parameters are fields split by `/`: a number, the art's
 //!   section names (one for Scatter, five for Art and Pattern, empty where there is none, each
 //!   after a space for Art and Pattern), more fields, and last 15 numbers. Brushes whose first
 //!   number is 1, as older files write them, have one field fewer before the numbers and 8 numbers;
-//!   an Art brush is read from its art's name alone, so either form reads.
+//!   an Art brush in that form is read from its art's name alone (its numbers aren't known, so it
+//!   keeps the defaults and its paths their drawn look).
 //!   - Scatter: the size (2, 3), spacing (5, 6) and scatter (8, 9) as (low, high) factors of the
 //!     art, the rotation in degrees (11, 12), how each varies (4, 7, 10, 13) and whether the
 //!     rotation follows the path (14).
+//!   - Art: 1 Tints (2).
 //!   - Pattern: its scale as a factor (3).
 //! - A Bristle brush's parameters start with 8 numbers: two codes, then the stiffness, bristle
 //!   thickness, density, paint opacity and bristle length as fractions and the size in
@@ -34,14 +43,16 @@
 //! - The art is a `%AI8_BeginBrushPattern` section: its name as a string, then the art (read by
 //!   [`super::read`]).
 //!
-//! What isn't read keeps its default: the Art brush's options, the pattern brush's tiles (which
-//! slot is which tile isn't known) and every brush's colorization, which is left at None so the
-//! art keeps its own colors.
+//! What isn't read keeps its default: the Art brush's other options, the pattern brush's tiles
+//! (which slot is which tile isn't known) and the colorization of the other brushes, which is left
+//! at None so the art keeps its own colors.
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
+use kurbo::Affine;
 use vectorcraft_brush::{ArtBrush, Bristle, Brush, BrushKind, Calligraphic, Colorization, Scatter, Variation};
-use vectorcraft_doc::Node;
+use vectorcraft_color::Paint;
+use vectorcraft_doc::{AppearanceItem, Node, NodeKind};
 
 use super::lex::{Lexer, Tok};
 use super::obj;
@@ -102,10 +113,13 @@ pub(super) enum DraftKind {
         brush: Scatter,
         art: String,
     },
-    /// The art is the section named `art`.
+    /// The art is the section named `art`. `plain`: the brush stretches its art along the path,
+    /// unflipped, at 100% in Tints (see [`art_is_plain`]), so [`Self::Art`]'s `brush` draws as the
+    /// file's brush does.
     Art {
         brush: ArtBrush,
         art: String,
+        plain: bool,
     },
     /// The five art sections the brush names, in its order (which is which tile isn't known), and
     /// its scale (%).
@@ -206,17 +220,65 @@ pub(super) fn calligraphic(values: [f64; 3], variation: [f64; 3], codes: [f64; 3
     Calligraphic { angle, roundness, size, variation, modes: Some(modes) }
 }
 
-/// Does the brush `draft` draw as `c`, the settings a path's art style gives it? A path whose
+/// The settings a path's art style gives its stroke's brush.
+#[derive(Clone, Debug, PartialEq)]
+pub(super) enum PathBrush {
+    Calligraphic(Calligraphic),
+    /// An Art brush whose art stretches along the path, at the brush's own width, in Tints.
+    Art,
+}
+
+/// Does an Art brush draw `art` as the file does? It bends paths in solid colors: other objects
+/// are left out of the pieces, a gradient or pattern stays where it was and takes no color from the
+/// stroke, an effect isn't bent with its path, a stroke's outline isn't stretched along it, and art
+/// with no length along the path draws nothing.
+pub(super) fn art_bends(art: &Node) -> bool {
+    let mut bends = art.geometric_bounds().is_some_and(|b| b.width() > 1e-9);
+    art.walk(&mut |n| {
+        bends &= matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. } | NodeKind::Group { .. })
+            && n.extras().mask.is_none()
+            && n.appearance.effects.is_empty()
+            && n.appearance.items.iter().all(|i| i.effects().is_empty() && !matches!(i, AppearanceItem::Stroke(s) if !s.paint.is_none()))
+            && vectorcraft_doc::swatches::node_paints(n).all(|p| matches!(p, Paint::Solid { .. } | Paint::None));
+    });
+    bends
+}
+
+/// The art sections of `drafts`' Art brushes that an Art brush draws as the file does.
+pub(super) fn bending_art(drafts: &[BrushDraft], art: &HashMap<String, Node>) -> HashSet<String> {
+    let names: HashSet<&String> = drafts
+        .iter()
+        .filter_map(|d| match &d.kind {
+            DraftKind::Art { art, .. } => Some(art),
+            _ => None,
+        })
+        .collect();
+    names.into_iter().filter(|n| art.get(*n).is_some_and(art_bends)).cloned().collect()
+}
+
+/// Does the brush `draft` draw as `settings`, the settings a path's art style gives it? A path whose
 /// settings differ (Options of Selected Object) keeps its drawn look: a stroke names a brush, and
-/// has no settings of its own.
-pub(super) fn draws_as(draft: &BrushDraft, c: &Calligraphic) -> bool {
-    let DraftKind::Calligraphic(d) = &draft.kind else { return false };
+/// has no settings of its own. `bending`: [`bending_art`].
+pub(super) fn draws_as(draft: &BrushDraft, settings: &PathBrush, bending: &HashSet<String>) -> bool {
     let close = |a: f64, b: f64| (a - b).abs() <= 1e-3 * a.abs().max(b.abs()).max(1.0);
-    close(d.angle, c.angle)
-        && close(d.roundness, c.roundness)
-        && close(d.size, c.size)
-        && d.variation.iter().zip(&c.variation).all(|(a, b)| close(*a, *b))
-        && d.modes() == c.modes()
+    match (&draft.kind, settings) {
+        (DraftKind::Calligraphic(d), PathBrush::Calligraphic(c)) => {
+            close(d.angle, c.angle)
+                && close(d.roundness, c.roundness)
+                && close(d.size, c.size)
+                && d.variation.iter().zip(&c.variation).all(|(a, b)| close(*a, *b))
+                && d.modes() == c.modes()
+        }
+        (DraftKind::Art { plain: true, art: name, .. }, PathBrush::Art) => bending.contains(name),
+        _ => false,
+    }
+}
+
+/// Are an Art brush's last 15 numbers those of a brush that stretches its art along the path,
+/// unflipped, at 100% in Tints? The numbers aren't read otherwise: any other value keeps its paths'
+/// drawn look.
+fn art_is_plain(numbers: &[f64; 15]) -> bool {
+    *numbers == [1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]
 }
 
 /// The brush named `name` of kind `kind` from its parameters `params`.
@@ -270,7 +332,15 @@ pub(super) fn parse_tool_object(kind: Tool, name: &str, params: &str) -> Result<
                     };
                     DraftKind::Scatter { brush, art: art()? }
                 }
-                Tool::Art => DraftKind::Art { brush: ArtBrush { colorization: Colorization::None, ..ArtBrush::default() }, art: art()? },
+                Tool::Art => {
+                    // The older form's 8 numbers aren't known: its brush keeps the defaults and its
+                    // paths their drawn look.
+                    let (colorization, plain) = match <&[f64; 15]>::try_from(n.as_slice()) {
+                        Ok(n15) => (if n15[1] == 1.0 { Colorization::Tints } else { Colorization::None }, art_is_plain(n15)),
+                        Err(_) => (Colorization::None, false),
+                    };
+                    DraftKind::Art { brush: ArtBrush { colorization, ..ArtBrush::default() }, art: art()?, plain }
+                }
                 _ => {
                     let [_, _, p3, ..] = n.as_slice() else { return Err(BrushError::Values) };
                     let tiles: [Option<String>; 5] = tiles.try_into().map_err(|_| BrushError::Values)?;
@@ -317,6 +387,43 @@ pub(super) fn art_weight(art: &Node) -> usize {
     weight
 }
 
+/// Which of `drafts` [`finish_brushes`] makes into brushes, with [`MAX_BRUSH_ART_NODES`] of art.
+pub(super) fn kept(drafts: &[BrushDraft], art: &HashMap<String, Node>) -> Vec<bool> {
+    kept_brushes(drafts, art, MAX_BRUSH_ART_NODES)
+}
+
+/// Which of `drafts` become brushes, with at most `budget` of [`art_weight`] copied into them: not
+/// a pattern brush, a brush whose art isn't read, a brush whose art would go past `budget`, or a
+/// brush named as one kept before it.
+pub(super) fn kept_brushes(drafts: &[BrushDraft], art: &HashMap<String, Node>, budget: usize) -> Vec<bool> {
+    let mut copied = 0usize;
+    let mut weights: HashMap<&str, usize> = HashMap::new();
+    let mut names: HashSet<&str> = HashSet::new();
+    drafts
+        .iter()
+        .map(|d| {
+            let fits = match &d.kind {
+                _ if names.contains(d.name.as_str()) => false,
+                DraftKind::Calligraphic(_) | DraftKind::Bristle(_) => true,
+                DraftKind::Pattern { .. } => false,
+                DraftKind::Scatter { art: name, .. } | DraftKind::Art { art: name, .. } => art.get_key_value(name).is_some_and(|(key, a)| {
+                    let weight = *weights.entry(key.as_str()).or_insert_with(|| art_weight(a));
+                    let total = copied.saturating_add(weight);
+                    let fits = total <= budget;
+                    if fits {
+                        copied = total;
+                    }
+                    fits
+                }),
+            };
+            if fits {
+                names.insert(&d.name);
+            }
+            fits
+        })
+        .collect()
+}
+
 /// [`finish_brushes`] with at most `budget` of [`art_weight`] copied into the brushes (each brush
 /// that uses a section holds its own copy): a brush whose art would go past it is left out.
 pub(super) fn finish_brushes_within(
@@ -325,27 +432,22 @@ pub(super) fn finish_brushes_within(
     order: Option<&[(Tool, String)]>,
     budget: usize,
 ) -> (Vec<Brush>, usize) {
+    let kept = kept_brushes(&drafts, art, budget);
+    let copy = |name: &str| art.get(name).cloned();
     let mut left_out = 0;
-    let mut copied = 0usize;
-    let mut weights: HashMap<&str, usize> = HashMap::new();
-    let mut copy = |name: &str| -> Option<Node> {
-        let (key, a) = art.get_key_value(name)?;
-        let weight = *weights.entry(key.as_str()).or_insert_with(|| art_weight(a));
-        let total = copied.saturating_add(weight);
-        (total <= budget).then(|| {
-            copied = total;
-            a.clone()
-        })
-    };
     let mut made: Vec<Option<(Tool, Brush)>> = vec![];
-    for d in drafts {
+    for (d, kept) in drafts.into_iter().zip(kept) {
         let tool = d.kind.tool();
-        let repeated = made.iter().flatten().any(|(_, b)| b.name == d.name);
         let kind = match d.kind {
-            _ if repeated => None,
+            _ if !kept => None,
             DraftKind::Calligraphic(c) => Some(BrushKind::Calligraphic(c)),
             DraftKind::Scatter { brush, art: name } => copy(&name).map(|a| BrushKind::Scatter(Scatter { art: a, ..brush })),
-            DraftKind::Art { brush, art: name } => copy(&name).map(|a| BrushKind::Art(ArtBrush { art: a, ..brush })),
+            DraftKind::Art { brush, art: name, .. } => copy(&name).map(|mut a| {
+                // The side of the section with y up draws on the right of the path, and a brush
+                // draws art's y (down here) on the left of the path.
+                a.transform(Affine::scale_non_uniform(1.0, -1.0), false);
+                BrushKind::Art(ArtBrush { art: a, ..brush })
+            }),
             DraftKind::Pattern { .. } => None,
             DraftKind::Bristle(b) => Some(BrushKind::Bristle(b)),
         };
diff --git a/crates/eps/src/import/ai/envelope.rs b/crates/eps/src/import/ai/envelope.rs
index 33fae9eab..d9f392215 100644
--- a/crates/eps/src/import/ai/envelope.rs
+++ b/crates/eps/src/import/ai/envelope.rs
@@ -14,7 +14,9 @@
 //! then its `/ArtDictionary`: Envelope Options as a bit word (`AIDeformOptionsKey`), Fidelity
 //! (`AIDeformFidelityKey`), Edit Contents (`AIDeformEditModeKey`), a warp's style (`DeformStyle`,
 //! numbered as Effect › Warp lists them), bend and distortions (`DeformValue`, `DeformHoriz`,
-//! `DeformVert`, fractions) and orientation (`Rotate`), the contents (`X=` … `X+`, then
+//! `DeformVert`, fractions) and orientation (`Rotate`), the size of the contents, read as the size
+//! of the box they map from with Distort Appearance on when it matches their bounds with strokes
+//! (`AIDeformArtWidthKey`, `AIDeformArtHeightKey`), the contents (`X=` … `X+`, then
 //! `(AIDeformArtKey)`) and the kind (`AIDeformStyle`: 1 a warp, 2 a mesh, 3 a top object). Then the
 //! distorted art on plain lines, and the plugin's `XP`. While the contents are edited, the group
 //! holds the contents and the dictionary the mesh. A top object's outline is the edge of its
@@ -24,8 +26,11 @@
 use std::collections::BTreeMap;
 use std::sync::Arc;
 
-use kurbo::{BezPath, Point, Rect, Vec2};
-use vectorcraft_doc::live::{EnvelopeKind, EnvelopeOptions, GradientMesh, H_DOWN, H_LEFT, H_RIGHT, H_UP, PreserveShape, default_fidelity};
+use kurbo::{Affine, BezPath, Point, Rect, Vec2};
+use vectorcraft_doc::live::{
+    EnvelopeKind, EnvelopeOptions, GradientMesh, H_DOWN, H_LEFT, H_RIGHT, H_UP, PreserveShape, default_fidelity, envelope_content_boxes,
+    envelope_stroke_margin,
+};
 use vectorcraft_doc::{Document, ImageBlob, LayerColor, Node, NodeId, NodeKind, PatternDef};
 use vectorcraft_geom::PathData;
 
@@ -42,6 +47,9 @@ pub(super) const MAX_PENDING: usize = 64;
 pub(super) const MAX_CHECKED: usize = 256;
 /// The most rows or columns of a mesh read (Make with Mesh's own limit).
 const MAX_GRID: u32 = 50;
+/// How far, in points over width and height together, a saved size may lie from the contents'
+/// bounds with their strokes and still count as that box.
+const SAVED_SIZE_SLACK: f64 = 0.5;
 /// The bits of the options word that are read: Distort Appearance, Distort Pattern Fills, Distort
 /// Linear Gradients, Anti-Alias (set: off) and Preserve Shape Using (set: Clipping Mask).
 const KNOWN_BITS: i64 = 0b111 | 1 << 16 | 1 << 17;
@@ -88,10 +96,29 @@ pub(super) fn options(o: &Obj) -> Option<(EnvelopeOptions, f64)> {
         distort_appearance: bit(0),
         distort_pattern_fills: bit(1),
         distort_linear_gradients: bit(2),
+        bounds_margin: [0.0; 4],
     };
     Some((options, fidelity))
 }
 
+/// The margins of `content` when the size the file saves for it (`AIDeformArtWidthKey`,
+/// `AIDeformArtHeightKey`) matches its bounds with its strokes within [`SAVED_SIZE_SLACK`] and lies
+/// nearer them than its geometric bounds. None without that size, or for contents with no width or
+/// no height.
+fn saved_margin(o: &Obj, content: &[Arc<Node>]) -> Option<[f32; 4]> {
+    let saved = |key: &str| match o.nums(key).as_slice() {
+        [v] if v.is_finite() => Some(*v),
+        _ => None,
+    };
+    let (w, h) = (saved("AIDeformArtWidthKey")?, saved("AIDeformArtHeightKey")?);
+    let (stroked, plain) = envelope_content_boxes(content, Affine::IDENTITY)?;
+    let off = |r: Rect| (r.width() - w).abs() + (r.height() - h).abs();
+    if off(stroked) > SAVED_SIZE_SLACK || off(stroked) >= off(plain) {
+        return None;
+    }
+    envelope_stroke_margin(stroked, plain)
+}
+
 /// A warp: its style, bend, distortions and orientation.
 fn warp(o: &Obj) -> Option<EnvelopeKind> {
     let style = whole(o, "DeformStyle")??;
@@ -232,7 +259,7 @@ fn unwrapped(mut nodes: Vec<Node>) -> Vec<Arc<Node>> {
 /// in its `AIDeformArtKey` block (`inner`); `None` where they don't make one.
 pub(super) fn live(o: &Obj, before: Option<Node>, inner: Vec<Node>) -> Option<NodeKind> {
     let editing = switch(o, "AIDeformEditModeKey")?;
-    let (options, fidelity) = options(o)?;
+    let (mut options, fidelity) = options(o)?;
     let before = before?;
     // While the contents are edited, they are the group before the dictionary and the mesh is in it.
     let (content, shape): (Vec<Arc<Node>>, Option<&GradientMesh>) = if editing {
@@ -249,6 +276,9 @@ pub(super) fn live(o: &Obj, before: Option<Node>, inner: Vec<Node>) -> Option<No
     if content.is_empty() {
         return None;
     }
+    if options.distort_appearance {
+        options.bounds_margin = saved_margin(o, &content).unwrap_or_default();
+    }
     let kind = match whole(o, "AIDeformStyle")?? {
         1 => warp(o)?,
         2 => {
diff --git a/crates/eps/src/import/ai/frames.rs b/crates/eps/src/import/ai/frames.rs
index 24f0b8b83..f6b00c44c 100644
--- a/crates/eps/src/import/ai/frames.rs
+++ b/crates/eps/src/import/ai/frames.rs
@@ -66,8 +66,8 @@ fn number_before(head: &[u8], key: &[u8]) -> Option<f64> {
     number(words(head.get(..k)?).last()?)
 }
 
-/// A path in the format's path operators (`m`, `l`/`L`, `c`/`C`, `v`/`V`, `y`/`Y`; any other
-/// operator ends the numbers before it).
+/// A path in the format's path operators (`m`, `l`/`L`, `c`/`C`, `v`/`V`, `y`/`Y`, closed by `n`,
+/// `f`, `s`, `b` or `h`; any other operator ends the numbers before it).
 fn path(text: &[u8]) -> Option<BezPath> {
     let mut bp = BezPath::new();
     let mut nums: Vec<f64> = vec![];
@@ -106,6 +106,12 @@ fn path(text: &[u8]) -> Option<BezPath> {
                 bp.curve_to(p(n - 4)?, q, q);
                 cur = Some(q);
             }
+            // The painting operators that close the path first (lower case), and `h`: an area's frame
+            // is closed, its last point the first again.
+            b"n" | b"f" | b"s" | b"b" | b"h" if cur.is_some() => {
+                bp.close_path();
+                cur = None;
+            }
             _ => {}
         }
         nums.clear();
@@ -135,4 +141,17 @@ mod tests {
         assert_eq!(f[&(49, 0)].bounding_box(), kurbo::Rect::new(1.0, 2.0, 3.0, 4.0));
         assert!(text_frames(b"/AI11Text : garbage").is_empty());
     }
+
+    /// An area's frame painted with `n` (as the format writes it, the last point the first again)
+    /// is a closed path of its corners; one painted with `N` stays open.
+    #[test]
+    fn a_frame_painted_closed_is_closed() {
+        let doc = b"/AI11Text :\r0 /FreeUndo ,\r0 /FrameIndex ,\r3 /StoryIndex ,\r/Art :\rX=\r40 130 m\r40 250 L\r240 250 L\r240 130 L\r40 130 L\rn\rX+\r; /ConfiningPath ,\r;\r\
+            /AI11Text :\r0 /FreeUndo ,\r0 /FrameIndex ,\r4 /StoryIndex ,\r/Art :\rX=\r40 130 m\r40 250 L\r240 250 L\rN\rX+\r; /ConfiningPath ,\r;\r";
+        let f = text_frames(doc);
+        let closed = vectorcraft_geom::PathData::from_bezpath(&f[&(3, 0)]);
+        assert!(closed.subpaths[0].closed);
+        assert_eq!(closed.subpaths[0].anchors.len(), 4, "the last point merges with the first");
+        assert!(!vectorcraft_geom::PathData::from_bezpath(&f[&(4, 0)]).subpaths[0].closed);
+    }
 }
diff --git a/crates/eps/src/import/ai/legacy_text.rs b/crates/eps/src/import/ai/legacy_text.rs
index 04e181ed4..4e6164e4b 100644
--- a/crates/eps/src/import/ai/legacy_text.rs
+++ b/crates/eps/src/import/ai/legacy_text.rs
@@ -2,7 +2,8 @@
 //! text paths (`a b c d tx ty startPt Tp`, an area's frame, one for each linked area, or the path
 //! type runs along, `TP`), the modal character and paragraph attributes
 //! (`Tr Tf Ts Tz Tt TA Tl Ta Ti`, and §15.4.7 and §22's letter and word spacing `TC TW`, hanging
-//! punctuation `Tq`, hyphenation `Th` and tab stops `Xb Xe XB`), the paint style, and the characters (`Tx`, `Tj`,
+//! punctuation `Tq`, hyphenation `Th` and tab stops `Xb Xe XB`, and §15.3.4's writing direction `TV`,
+//! Roman character rotation `Tv` and Kumi blocks `Ty TY`), the paint style, and the characters (`Tx`, `Tj`,
 //! overflow `TX`; `\r` ends a paragraph). Type set in rendering modes 4 to 7 is a mask (§5.7): the
 //! text object clips the objects of its clipping group. Final-form operators (the
 //! computed positions, §15.1) are skipped: the type is laid out again. Strings are decoded by the
@@ -51,6 +52,9 @@ const LINKED_AREAS_LEFT_OUT: &str = "linked type areas past VectorCraft's limits
 /// The warning when type set in a mask rendering mode can't be a clipping path: type in linked
 /// areas (several frames), in wraparound text or in a compound path doesn't clip.
 const MASK_NOT_CLIPPED: &str = "type used as a mask in linked areas, wraparound text or a compound path doesn't clip";
+/// The warning when `TV` changes after a text object's first character: the object keeps the
+/// direction of that character.
+const DIRECTION_CHANGE_LEFT_OUT: &str = "type that changes writing direction inside a text object opens in the direction of its first character";
 
 /// A text path (`Tp` … `TP`).
 #[derive(Debug, Default)]
@@ -101,6 +105,10 @@ pub(super) struct LegacyText {
     /// Characters were set in a mask rendering mode (`Tr` 4 to 7): the text object is a clipping
     /// path (§5.7).
     clips: bool,
+    /// `TV` at its first character: VectorCraft keeps one writing direction for each text object.
+    vertical: bool,
+    /// A later character was set in the other direction.
+    direction_changed: bool,
     /// The state when it began (lock, visibility), and whether it began on a `%_` line.
     gs: GState,
     hidden: bool,
@@ -176,6 +184,10 @@ pub(super) struct TypeState {
     tabs_version: u64,
     /// `Tr`.
     render: i64,
+    /// `TV`: vertical writing.
+    vertical: bool,
+    /// `TY`: a Kumi block recorded for later use, which horizontal type keeps as its mark.
+    kumi_recorded: bool,
     /// The encoding strings are in, by code (`TE`); None where it says nothing.
     encoding: Vec<Option<char>>,
     /// Re-encoded fonts' original names (`%AI3_BeginEncoding: _new old`, or `TZ`'s).
@@ -197,6 +209,8 @@ impl Default for TypeState {
             para: ParaStyle::default(),
             tabs_version: 0,
             render: 0,
+            vertical: false,
+            kumi_recorded: false,
             encoding: vec![None; 256],
             fonts: vec![],
             font_encodings: vec![],
@@ -546,6 +560,31 @@ impl Reader<'_> {
                 h.before_last = letters(tail, 1.0, 15.0);
                 h.hyphen_limit = if limit { letters(max, 0.0, 25.0) } else { 0 };
             }
+            // `direction TV` (§15.3.4): 0 horizontal, 1 vertical.
+            "TV" => {
+                if let Some(on) = n0.and_then(flag) {
+                    st.vertical = on;
+                }
+            }
+            // `rotation Tv`: in vertical writing, 0 rotates Roman characters 90 degrees clockwise and
+            // 1 keeps them upright.
+            "Tv" => {
+                if let Some(on) = n0.and_then(flag) {
+                    st.style.standard_vertical_roman = on;
+                }
+            }
+            // `kumi Ty`: 1 begins a Kumi block and 0 ends it.
+            "Ty" => {
+                if let Some(on) = n0.and_then(flag) {
+                    st.style.tate_chu_yoko = on;
+                }
+            }
+            // `kumi TY`: as `Ty`, for a block that does not appear in the set text.
+            "TY" => {
+                if let Some(on) = n0.and_then(flag) {
+                    st.kumi_recorded = on;
+                }
+            }
             // A tab definition (§22.6): `numDots numTabs Xb` begins it, each
             // `leader decimal tabType tabPosition Xe` describes one tab stop, and `XB` ends it. The
             // stops it describes replace the paragraph's tab stops, sorted by position, one stop at
@@ -603,8 +642,13 @@ impl Reader<'_> {
         }
         let decoded: String = decoded.chars().take(room).collect();
         st.chars += decoded.chars().count();
+        if t.runs.is_empty() {
+            t.vertical = st.vertical;
+        }
+        t.direction_changed |= st.vertical != t.vertical;
         let gs = &self.gs;
         let mut style = st.style.clone();
+        style.tate_chu_yoko |= st.kumi_recorded && !t.vertical;
         // Characters in modes 4 to 7 make the whole text object the mask, not each run (§5.7); 7
         // paints nothing, nor does 3 (invisible).
         t.clips |= (4..=7).contains(&st.render);
@@ -669,6 +713,9 @@ impl Reader<'_> {
         if t.kind == 1 && (t.past_limit || all_areas > placed.len()) {
             self.warn(LINKED_AREAS_LEFT_OUT);
         }
+        if t.direction_changed {
+            self.warn(DIRECTION_CHANGE_LEFT_OUT);
+        }
         let mut paras = std::mem::take(&mut t.paras);
         if paras.is_empty() {
             paras.push(ParaRun { style: self.type_state.para.clone(), count: 1, tabs_version: 0 });
@@ -682,6 +729,7 @@ impl Reader<'_> {
         for (m, kind) in placed {
             let mut obj = TextObject::point(kurbo::Point::ZERO, "", last_style.clone());
             obj.kind = kind;
+            obj.vertical = t.vertical;
             obj.xf = to_doc * m * FLIP;
             match story.take() {
                 Some((runs, paras)) => {
diff --git a/crates/eps/src/import/ai/lex.rs b/crates/eps/src/import/ai/lex.rs
index b96b85c06..810a01c3f 100644
--- a/crates/eps/src/import/ai/lex.rs
+++ b/crates/eps/src/import/ai/lex.rs
@@ -133,7 +133,8 @@ impl<'a> Lexer<'a> {
         self.src.get(self.pos).copied()
     }
 
-    fn rest(&self) -> &'a [u8] {
+    /// The data from where the next token is looked for.
+    pub fn rest(&self) -> &'a [u8] {
         self.src.get(self.pos..).unwrap_or_default()
     }
 
diff --git a/crates/eps/src/import/ai/read.rs b/crates/eps/src/import/ai/read.rs
index 2cf9dc736..025ccc480 100644
--- a/crates/eps/src/import/ai/read.rs
+++ b/crates/eps/src/import/ai/read.rs
@@ -250,7 +250,7 @@ pub fn read_beside(data: &[u8], large_canvas: bool, ps: &[u8]) -> Result<Structu
 /// content, the prolog, resources, sections it skips (such as symbols and the text document) or
 /// what follows the trailer. The palette the reader keeps is the last one outside those and the
 /// sections it reads on their own.
-fn swatch_names(data: &[u8]) -> ShownNames {
+fn swatch_names(data: &[u8]) -> (ShownNames, Option<&[u8]>) {
     /// The sections the reader reads on their own whose definitions and colors it keeps.
     const READ_APART: &[&str] = &["BeginPattern", "BeginBrushPattern", "BeginPluginObject", "BeginArtStyles", "BeginArtStyleList"];
     /// Whether the marker `m` ends what began with `begin` and ends with `end`, `depth` of its kind
@@ -277,8 +277,14 @@ fn swatch_names(data: &[u8]) -> ShownNames {
     let mut skip: Option<(&str, &str, usize, Option<usize>)> = None;
     let mut section: Option<(&str, &str, usize, bool)> = None;
     let (mut palette_at, mut palette) = (None, None);
+    // Where the first art styles section starts, and that section.
+    let (mut styles_at, mut styles) = (None, None);
     // A pattern's name is the first string of its definition.
     let mut head = false;
+    // ASCII85 data in comment lines is skipped past, as the reader skips it.
+    let mut dictionaries = ops::Dictionaries::default();
+    // The scan's state where the versioned content being skipped starts, to go back to.
+    let mut versioned = None;
     loop {
         let before = lex.offset();
         let Some(t) = lex.next_token() else {
@@ -286,11 +292,14 @@ fn swatch_names(data: &[u8]) -> ShownNames {
             match skip.take() {
                 Some((.., Some(at))) => {
                     lex.seek(at);
+                    dictionaries = versioned.take().unwrap_or_default();
                     continue;
                 }
                 _ => break,
             }
         };
+        let markers = skip.map(|s| (s.0, s.1)).or(palette_at.map(|_| ("", "EndPalette"))).or(section.map(|s| (s.0, s.1)));
+        dictionaries.pass(&t.tok, &mut lex, markers);
         match &t.tok {
             Tok::Comment(c) => {
                 let line = String::from_utf8_lossy(c);
@@ -306,12 +315,16 @@ fn swatch_names(data: &[u8]) -> ShownNames {
                     }
                 } else if m.starts_with("Alternate_Content") && section.is_none_or(|s| s.3) {
                     skip = Some(("Begin_Content_if_version_gt", "End_Versioned_Content", 0, Some(lex.offset())));
+                    versioned = Some(dictionaries.clone());
                 } else if m == "%BeginProlog" {
                     skip = Some(("", "%EndProlog", 0, None));
                 } else if m == "%BeginResource" {
                     skip = Some(("", "%EndResource", 0, None));
                 } else if let Some((begin, end, depth, _)) = section.as_mut() {
                     if closes(begin, end, depth, m) {
+                        if let Some(at) = styles_at.take().filter(|_| *begin == "BeginArtStyles") {
+                            styles = Some(lex.slice(at, before));
+                        }
                         section = None;
                     }
                 } else if m == "BeginPalette" {
@@ -319,6 +332,9 @@ fn swatch_names(data: &[u8]) -> ShownNames {
                 } else if let Some((begin, end)) = types::SKIPPED.iter().find(|(b, _)| *b == m) {
                     section = Some((begin, end, 0, READ_APART.contains(begin)));
                     head = m == "BeginPattern";
+                    if m == "BeginArtStyles" && styles.is_none() {
+                        styles_at = Some(lex.offset());
+                    }
                 } else if matches!(m, "%PageTrailer" | "%Trailer") {
                     break;
                 }
@@ -350,7 +366,18 @@ fn swatch_names(data: &[u8]) -> ShownNames {
     }
     palette.own_names().for_each(|n| names.reserve(n));
     colors.names.iter().for_each(|n| names.reserve(n));
-    names
+    (names, styles)
+}
+
+/// What the brushes and brush art read so far give a brushed stroke.
+#[derive(Default)]
+struct BrushesKept {
+    /// The counts of brushes and art sections when this was worked out.
+    read: (usize, usize),
+    /// Which of [`Reader::brush_drafts`] are kept as brushes.
+    kept: Vec<bool>,
+    /// The art an Art brush draws as the file does.
+    bending: HashSet<String>,
 }
 
 struct Reader<'a> {
@@ -448,6 +475,12 @@ struct Reader<'a> {
     warnings: Vec<String>,
     /// Objects read as their drawn look (several fills or strokes, effects, brushes).
     drawn_looks: usize,
+    /// The objects read as their drawn look in the art of [`Reader::brush_art`], by name: counted in
+    /// [`Reader::drawn_looks`] once a brush that is kept uses the art.
+    brush_art_looks: HashMap<String, usize>,
+    /// The objects read as their drawn look in the art of the patterns kept, by the name the document
+    /// has the pattern by: a pattern defined again counts only its last definition.
+    pattern_looks: HashMap<String, usize>,
     /// Nodes read from `%_` lines.
     hidden_ids: HashSet<NodeId>,
     /// The blend part each object's dictionary names (`ShapeBlendPathType`, `ShapeBlendPathID`).
@@ -476,7 +509,7 @@ struct Reader<'a> {
     layer_state: Option<(f32, BlendMode, bool, Knockout, bool)>,
     /// The state a mesh or blend had before an `Xy` right after its end, which is the layer's
     /// instead when the layer's `LB` follows rather than their own `6 () XW`.
-    mesh_undo: Option<(f32, BlendMode, bool, Knockout)>,
+    mesh_undo: Option<(f32, BlendMode, bool, Knockout, bool)>,
     /// The state a layer's last group or compound path had before an `Xy` right after its end,
     /// which is the layer's instead when the layer's own `7 () XW` follows.
     container_undo: Option<(f32, BlendMode, bool, Knockout, bool)>,
@@ -554,6 +587,8 @@ struct Reader<'a> {
     brush_art: HashMap<String, Node>,
     /// The brush art sections read so far, repeated names included.
     brush_art_sections: usize,
+    /// What the brushes and brush art read so far give a brushed stroke.
+    brushes_kept: BrushesKept,
     /// Brush objects that weren't read.
     brushes_unread: usize,
     /// The graph being read (see [`Reader::graph_record`]).
@@ -576,10 +611,15 @@ pub(crate) fn is_look_slot(name: Option<&str>) -> bool {
 
 impl<'a> Reader<'a> {
     /// A reader of the editing data `data` as a whole, with the names its gradients and patterns
-    /// get in the document found first ([`swatch_names`]).
+    /// get in the document and its art styles found first ([`swatch_names`]): the symbols defined
+    /// before the art styles section use them too.
     fn with_names(data: &'a [u8]) -> Self {
         let mut r = Self::new(data);
-        r.global_names = swatch_names(data);
+        let (names, styles) = swatch_names(data);
+        r.global_names = names;
+        if let Some(section) = styles {
+            r.styles = super::style::art_styles(section);
+        }
         r
     }
 
@@ -645,6 +685,8 @@ impl<'a> Reader<'a> {
             color_model: None,
             warnings: Vec::new(),
             drawn_looks: 0,
+            brush_art_looks: HashMap::new(),
+            pattern_looks: HashMap::new(),
             hidden_ids: HashSet::new(),
             blend_roles: HashMap::new(),
             blend_record: None,
@@ -694,6 +736,7 @@ impl<'a> Reader<'a> {
             brush_drafts: Vec::new(),
             brush_art: HashMap::new(),
             brush_art_sections: 0,
+            brushes_kept: BrushesKept::default(),
             brushes_unread: 0,
             graph: None,
             multi_mask: None,
diff --git a/crates/eps/src/import/ai/read/art.rs b/crates/eps/src/import/ai/read/art.rs
index 7eb55ad11..b1b860a25 100644
--- a/crates/eps/src/import/ai/read/art.rs
+++ b/crates/eps/src/import/ai/read/art.rs
@@ -35,6 +35,9 @@ impl<'a> Reader<'a> {
         // The type takes the state's transparency, as a path does; an `Xy` after it sets the slot's own.
         n.opacity = gs.opacity;
         n.blend = gs.blend;
+        n.knockout_shape = gs.knockout_shape;
+        // An `Xy` before the text object was the object's, not its layer's, when the layer's `LB` follows.
+        self.layer_state = None;
         let hidden = self.obj_hidden;
         self.add(n, hidden)
     }
@@ -316,6 +319,7 @@ impl<'a> Reader<'a> {
                 let mut node = self.new_node(NodeKind::Mesh(one), &gs);
                 node.opacity = gs.opacity;
                 node.blend = gs.blend;
+                node.knockout_shape = gs.knockout_shape;
                 self.add(node, hidden)?;
                 self.mesh_ended = true;
                 return Ok(());
@@ -332,6 +336,7 @@ impl<'a> Reader<'a> {
         };
         node.opacity = gs.opacity;
         node.blend = gs.blend;
+        node.knockout_shape = gs.knockout_shape;
         self.add(node, hidden)?;
         self.mesh_ended = true;
         Ok(())
@@ -698,6 +703,7 @@ impl<'a> Reader<'a> {
         let mut node = self.new_node(NodeKind::Image(Box::new(im)), &gs);
         node.opacity = gs.opacity;
         node.blend = gs.blend;
+        node.knockout_shape = gs.knockout_shape;
         node.extras_mut().mask = mask.map(Box::new);
         node.extras_mut().colorize = colorize.map(Box::new);
         self.add(node, hidden)?;
diff --git a/crates/eps/src/import/ai/read/containers.rs b/crates/eps/src/import/ai/read/containers.rs
index f6ac4a00a..7d7c9ed9b 100644
--- a/crates/eps/src/import/ai/read/containers.rs
+++ b/crates/eps/src/import/ai/read/containers.rs
@@ -98,7 +98,14 @@ impl<'a> Reader<'a> {
             ..
         } = f;
         if matches!(kind, Kind::Clip) {
+            // `Q` restores the painting state, not the transparency: the writer sets `Xy` only when
+            // the next object's differs from the last one written, wherever that was, so a state set
+            // inside a clipping group stays after it (a glow set to Screen, then a clipping path set
+            // back to Normal: the type after the group has no `Xy` and is Normal).
+            let now = &self.gs;
+            let transparency = (now.opacity, now.blend, now.isolate, now.knockout, now.knockout_shape);
             self.gs = gs.clone();
+            (self.gs.opacity, self.gs.blend, self.gs.isolate, self.gs.knockout, self.gs.knockout_shape) = transparency;
             self.pending_unread_fill = pending_unread_fill;
             self.pending_unread_stroke = pending_unread_stroke;
         }
@@ -281,7 +288,8 @@ impl<'a> Reader<'a> {
             _ => {
                 let rule = clip.first().map_or(FillRule::NonZero, |(_, n)| path_rule(n));
                 // The compound path keeps the clipping paths' stroke, opacity and blend mode when they all have the same
-                // ones: it has one appearance for all its paths.
+                // ones, and the knockout shape flag when they all have it: it has one appearance for all its paths.
+                let shape = clip.iter().all(|(_, n)| n.knockout_shape);
                 let look = |n: &Node| (n.appearance.clone(), n.opacity, n.blend);
                 let shared =
                     clip.split_first().and_then(|((_, first), others)| others.iter().all(|(_, n)| look(n) == look(first)).then(|| look(first)));
@@ -292,6 +300,7 @@ impl<'a> Reader<'a> {
                     n.opacity = opacity;
                     n.blend = blend;
                 }
+                n.knockout_shape = shape;
                 Some(n)
             }
         };
@@ -312,7 +321,7 @@ impl<'a> Reader<'a> {
         if let (Some(_), Some(before)) = (state, self.mesh_undo.take())
             && let Some(mesh) = f.children.last_mut().filter(|n| matches!(n.kind, NodeKind::Mesh(_) | NodeKind::Blend { .. }))
         {
-            (mesh.opacity, mesh.blend, mesh.isolate, mesh.knockout) = before;
+            (mesh.opacity, mesh.blend, mesh.isolate, mesh.knockout, mesh.knockout_shape) = before;
         }
         let Kind::Layer(a) = f.kind else { return Ok(()) };
         let (children, clip) = self.clip_first(f.children, &f.clips, false, self.nesting() + 1)?;
@@ -379,7 +388,12 @@ impl<'a> Reader<'a> {
         let f = self.close("X+", |k| matches!(k, Kind::Mask))?;
         // The mask's art is one level under the object it masks.
         let (children, clip) = self.clip_first(f.children, &f.clips, false, self.nesting() + 2)?;
-        let art = self.new_node(NodeKind::Group { children, clip }, &f.gs);
+        // One shown object is the art itself. A hidden object or a guide stays in a group: the canvas draws the art's root
+        // whether it is shown or not and whether guides show, and a group doesn't draw a hidden member or a left-out guide.
+        let art = match children.as_slice() {
+            [only] if !clip && only.visible && !matches!(only.kind, NodeKind::Path { guide: true, .. }) => only.clone(),
+            _ => Arc::new(self.new_node(NodeKind::Group { children, clip }, &f.gs)),
+        };
         self.gs = f.gs;
         self.pending_unread_fill = f.pending_unread_fill;
         self.pending_unread_stroke = f.pending_unread_stroke;
@@ -388,7 +402,7 @@ impl<'a> Reader<'a> {
         let Some(Frame { kind: Kind::Obj(o), .. }) = self.frames.last_mut() else {
             return Err("mask art ends outside a mask dictionary".into());
         };
-        if o.art.replace(Arc::new(art)).is_some() {
+        if o.art.replace(art).is_some() {
             return Err("a mask has more than one art block".into());
         }
         o.unread = f.unread;
@@ -760,7 +774,8 @@ impl<'a> Reader<'a> {
                 // did (they were counted as read).
                 let mut blend = Node::new(self.doc.alloc_id(), kind);
                 (blend.name, blend.visible, blend.locked) = (steps.name.take(), steps.visible, steps.locked);
-                (blend.opacity, blend.blend, blend.isolate, blend.knockout) = (steps.opacity, steps.blend, steps.isolate, steps.knockout);
+                (blend.opacity, blend.blend, blend.isolate, blend.knockout, blend.knockout_shape) =
+                    (steps.opacity, steps.blend, steps.isolate, steps.knockout, steps.knockout_shape);
                 // Its note, URL and data (object tags) too.
                 blend.extras_mut().attrs = steps.extras_mut().attrs.take();
                 f.children.push(blend);
diff --git a/crates/eps/src/import/ai/read/directives.rs b/crates/eps/src/import/ai/read/directives.rs
index 2bd94479d..33af13372 100644
--- a/crates/eps/src/import/ai/read/directives.rs
+++ b/crates/eps/src/import/ai/read/directives.rs
@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use super::super::brush;
 use super::art::{four, sane, two};
+use super::ops::Dictionaries;
 use super::types::{
     FLIP, GState, Kind, MAX_DEPTH, MAX_HEX, MAX_LISTED, MAX_NODES, MAX_NOTE, MAX_PATTERNS, MAX_PLACED_FOLDER, MAX_STACK, MAX_SUBREADERS, MAX_SYMBOLS,
     PatternHead, Place, Raster, SKIPPED, SymbolHead, VERSIONED_UNENDED,
@@ -330,15 +331,18 @@ impl<'a> Reader<'a> {
         self.section(end).map(|_| ())
     }
 
-    /// [`Self::skip_to`] → what was skipped, up to the comment that ends it.
+    /// [`Self::skip_to`] → what was skipped, up to the comment that ends it. ASCII85 data in comment
+    /// lines is skipped past as [`Self::add_object_entry`] skips it.
     fn section(&mut self, end: &str) -> Result<&'a [u8], String> {
         let begin = SKIPPED.iter().find(|(_, e)| *e == end).map_or("", |(b, _)| *b);
         let begin = if end == "End_Versioned_Content" { "Begin_Content_if_version_gt" } else { begin };
         let start = self.lex.offset();
         let mut depth = 0usize;
+        let mut dictionaries = Dictionaries::default();
         loop {
             let before = self.lex.offset();
             let Some(t) = self.lex.next_token() else { break };
+            dictionaries.pass(&t.tok, &mut self.lex, Some((begin, end)));
             if let Tok::Comment(c) = t.tok {
                 let line = String::from_utf8_lossy(c);
                 let m = marker(&line);
@@ -503,6 +507,7 @@ impl<'a> Reader<'a> {
         } else {
             self.v7_patterns.remove(&head.name);
         }
+        self.pattern_looks.insert(def.name.clone(), sub.drawn_looks);
         self.doc.patterns.push(def);
         for (key, blob) in sub.doc.images {
             self.doc.images.entry(key).or_insert(blob);
@@ -748,6 +753,7 @@ impl<'a> Reader<'a> {
             && sub.frames.len() == 1
             && sub.doc.images.is_empty();
         let Some(frame) = sub.frames.pop().filter(|f| whole && !f.children.is_empty()) else { return };
+        self.brush_art_looks.insert(name.clone(), sub.drawn_looks);
         let mut art: Vec<Arc<Node>> = frame.children.iter().map(|n| Arc::new(self.doc.reid(n))).collect();
         let node = match art.len() {
             1 => art.pop().map(Arc::unwrap_or_clone),
@@ -1103,7 +1109,7 @@ mod tests {
         assert!(nodes > 0);
         let draft = |i: usize| brush::BrushDraft {
             name: format!("Brush {i}"),
-            kind: brush::DraftKind::Art { brush: vectorcraft_brush::ArtBrush::default(), art: "A".to_string() },
+            kind: brush::DraftKind::Art { brush: vectorcraft_brush::ArtBrush::default(), art: "A".to_string(), plain: false },
         };
         let drafts: Vec<_> = (0..5).map(draft).collect();
         let (kept, left_out) = brush::finish_brushes_within(drafts.clone(), &reader.brush_art, None, 3 * nodes);
@@ -1113,6 +1119,7 @@ mod tests {
         // A second brush of the same name is left out without using the budget.
         let mut repeated: Vec<_> = (0..2).map(draft).collect();
         repeated.insert(1, draft(0));
+        assert_eq!(brush::kept_brushes(&repeated, &reader.brush_art, 2 * nodes), [true, false, true]);
         let (kept, left_out) = brush::finish_brushes_within(repeated, &reader.brush_art, None, 2 * nodes);
         assert_eq!((kept.len(), left_out), (2, 1));
     }
diff --git a/crates/eps/src/import/ai/read/document.rs b/crates/eps/src/import/ai/read/document.rs
index 2fd918fe6..65d949f0f 100644
--- a/crates/eps/src/import/ai/read/document.rs
+++ b/crates/eps/src/import/ai/read/document.rs
@@ -914,13 +914,20 @@ impl<'a> Reader<'a> {
     }
 
     /// The brushes read ([`brush::finish_brushes`]) and how many weren't; `None` when the file has
-    /// no brush objects (the document keeps the default brushes).
+    /// no brush objects (the document keeps the default brushes). The objects read as their drawn
+    /// look in the art the brushes use count toward the note on drawn looks, once for each art.
     fn brush_library(&mut self) -> Option<(Vec<vectorcraft_brush::Brush>, usize)> {
         if !self.brush_objects {
             return None;
         }
         let drafts = std::mem::take(&mut self.brush_drafts);
         let (lib, left_out) = brush::finish_brushes(drafts, &self.brush_art, self.brush_order.as_deref());
+        let used: std::collections::HashSet<NodeId> = lib.iter().flat_map(|b| b.art()).map(|a| a.id).collect();
+        for (name, art) in &self.brush_art {
+            if used.contains(&art.id) {
+                self.drawn_looks += self.brush_art_looks.get(name).copied().unwrap_or(0);
+            }
+        }
         Some((lib, left_out + self.brushes_unread))
     }
 
@@ -1087,6 +1094,7 @@ impl<'a> Reader<'a> {
                 warnings.push(brush::left_out_note(unread));
             }
         }
+        self.drawn_looks += self.pattern_looks.values().sum::<usize>();
         if self.drawn_looks > 0 {
             warnings.push(format!(
                 "objects with several fills or strokes, effects or brushes came in as their drawn look ({}): their appearance isn't editable yet",
diff --git a/crates/eps/src/import/ai/read/ops.rs b/crates/eps/src/import/ai/read/ops.rs
index dc3089024..9535aa062 100644
--- a/crates/eps/src/import/ai/read/ops.rs
+++ b/crates/eps/src/import/ai/read/ops.rs
@@ -5,8 +5,8 @@ use super::types::{
     line_width,
 };
 use super::{
-    Affine, Appearance, AppearanceItem, Arc, BlendMode, Dash, FillLayer, FillRule, Global, Gradient, GradientDef, Graph, HashMap, HashSet, Instance,
-    Knockout, LayerColor, LineCap, LineJoin, Node, NodeId, NodeKind, Paint, Reader, Rect, ShownNames, StrokeLayer, V, obj, paint,
+    Affine, Appearance, AppearanceItem, Arc, BlendMode, BrushesKept, Dash, FillLayer, FillRule, Global, Gradient, GradientDef, Graph, HashMap,
+    HashSet, Instance, Knockout, LayerColor, LineCap, LineJoin, Node, NodeId, NodeKind, Paint, Reader, Rect, ShownNames, StrokeLayer, V, obj, paint,
 };
 
 impl<'a> Reader<'a> {
@@ -34,10 +34,11 @@ impl<'a> Reader<'a> {
             // of it may start with `%_` and read as hidden tokens: a `(` there would open
             // a string that swallows the rest of the layer.
             let key = o.entries.last().and_then(|(k, _)| k.as_deref());
-            if o.ty == "Binary" && key == Some("ASCII85Decode") {
-                self.lex.skip_past(b"~>");
-            } else if o.ty == "ForeignObject" && key == Some("Data") {
-                self.foreign_data = Some(self.lex.skip_past(b"~>").to_vec());
+            if ascii85_follows(&o.ty, key) {
+                let data = self.lex.skip_past(b"~>");
+                if o.ty == "ForeignObject" {
+                    self.foreign_data = Some(data.to_vec());
+                }
             }
         }
     }
@@ -359,10 +360,13 @@ impl<'a> Reader<'a> {
             "TO" => self.end_text(hidden)?,
             // `(text) justified TS`, special characters (§22.6): the reader adds its characters like `Tx`.
             "Tx" | "Tj" | "TX" | "TS" => self.text_body(w, &vals),
-            "Tr" | "Tf" | "Ts" | "Tz" | "Tt" | "TA" | "Tl" | "Ta" | "Ti" | "TC" | "TW" | "Tq" | "Th" | "Xb" | "Xe" | "XB" => self.text_attr(w, &vals),
-            // Attributes the reader doesn't keep (kerning pairs, Far-Eastern type) and final-form
-            // positions (§15.3).
-            "Tk" | "TK" | "Tc" | "Tw" | "Tm" | "Td" | "T*" | "TR" | "T+" | "T-" | "TV" | "Tv" | "Ty" | "TY" | "TG" | "Tg" | "Tu" | "Xu" => {}
+            "Tr" | "Tf" | "Ts" | "Tz" | "Tt" | "TA" | "Tl" | "Ta" | "Ti" | "TC" | "TW" | "Tq" | "Th" | "TV" | "Tv" | "Ty" | "TY" | "Xb" | "Xe"
+            | "XB" => {
+                self.text_attr(w, &vals);
+            }
+            // Attributes the reader doesn't keep (kerning pairs, line breaking, binding punctuation
+            // and Japanese layout rules) and final-form positions (§15.3).
+            "Tk" | "TK" | "Tc" | "Tw" | "Tm" | "Td" | "T*" | "TR" | "T+" | "T-" | "TG" | "Tg" | "Tu" | "Xu" => {}
             // `TM` (pop text matrix) and `Te` (end render), listed in §22.6, keep nothing either; the
             // reader takes `Te` with any number of operands.
             "TM" | "Te" => {}
@@ -622,8 +626,8 @@ impl<'a> Reader<'a> {
             self.last_object().filter(|n| (mesh_ended && matches!(n.kind, NodeKind::Mesh(_))) || matches!(n.kind, NodeKind::Blend { .. }))
         {
             // The mesh's or blend's, or the layer's when it is the layer's last object: kept for either.
-            let before = (n.opacity, n.blend, n.isolate, n.knockout);
-            (n.opacity, n.blend, n.isolate, n.knockout) = (gs.opacity, gs.blend, gs.isolate, gs.knockout);
+            let before = (n.opacity, n.blend, n.isolate, n.knockout, n.knockout_shape);
+            (n.opacity, n.blend, n.isolate, n.knockout, n.knockout_shape) = (gs.opacity, gs.blend, gs.isolate, gs.knockout, gs.knockout_shape);
             self.mesh_undo = Some(before);
             self.layer_state = in_layer.then_some((gs.opacity, gs.blend, gs.isolate, gs.knockout, gs.knockout_shape));
         } else if let Some(n) = self.last_object().filter(|n| matches!(n.kind, NodeKind::Group { .. } | NodeKind::Compound { .. })) {
@@ -668,6 +672,19 @@ impl<'a> Reader<'a> {
         self.note_state();
     }
 
+    /// Brings [`Reader::brushes_kept`] up to date with the brushes and brush art read so far.
+    fn note_brushes_kept(&mut self) {
+        use super::super::brush;
+        let read = (self.brush_drafts.len(), self.brush_art_sections);
+        if self.brushes_kept.read != read {
+            self.brushes_kept = BrushesKept {
+                read,
+                kept: brush::kept(&self.brush_drafts, &self.brush_art),
+                bending: brush::bending_art(&self.brush_drafts, &self.brush_art),
+            };
+        }
+    }
+
     /// `n (style) XW` after an object: `1 (style)` after the object written on `%_` lines, its
     /// drawn look before it (all on `%_` lines inside another such object). Other markers end what
     /// follows an object.
@@ -704,6 +721,7 @@ impl<'a> Reader<'a> {
             return;
         }
         let space = self.space();
+        self.note_brushes_kept();
         let Some(f) = self.frames.last_mut() else { return };
         let n = f.children.len();
         let (Some(object), Some(look)) = (n.checked_sub(1).and_then(|i| f.children.get(i)), n.checked_sub(2).and_then(|i| f.children.get(i))) else {
@@ -729,6 +747,8 @@ impl<'a> Reader<'a> {
                     names: &self.global_names,
                     v7_patterns: &self.v7_patterns,
                     brushes: &self.brush_drafts,
+                    kept: &self.brushes_kept.kept,
+                    bending: &self.brushes_kept.bending,
                     space,
                 },
             )
@@ -746,7 +766,8 @@ impl<'a> Reader<'a> {
             }
             object.appearance = appearance.into();
             // The object's transparency is written on its look, after the look's group ends.
-            (object.opacity, object.blend, object.isolate, object.knockout) = (look.opacity, look.blend, look.isolate, look.knockout);
+            (object.opacity, object.blend, object.isolate, object.knockout, object.knockout_shape) =
+                (look.opacity, look.blend, look.isolate, look.knockout, look.knockout_shape);
             // Now the object itself, not a copy an enclosing look's `strip` would remove.
             self.hidden_ids.remove(&object.id);
             // Linked to the style when the style list has its name ([`Reader::finish`]).
@@ -767,8 +788,9 @@ impl<'a> Reader<'a> {
             // A text object stays the type it is: over what else its look draws, or in place of a
             // look that was only its type. Its transparency is written on its look.
             let empty = look.children().is_some_and(|c| c.is_empty());
-            if empty || (look.opacity >= 1.0 && look.blend == BlendMode::Normal && !look.isolate) {
-                (object.opacity, object.blend, object.isolate, object.knockout) = (look.opacity, look.blend, look.isolate, look.knockout);
+            if empty || (look.opacity >= 1.0 && look.blend == BlendMode::Normal && !look.isolate && !look.knockout_shape) {
+                (object.opacity, object.blend, object.isolate, object.knockout, object.knockout_shape) =
+                    (look.opacity, look.blend, look.isolate, look.knockout, look.knockout_shape);
                 if empty {
                     *look = object;
                 } else {
@@ -778,11 +800,11 @@ impl<'a> Reader<'a> {
             }
             // The look and the type go into a group that has the transparency.
             let Some(mut look) = f.children.pop() else { return };
-            let state = (look.opacity, look.blend, look.isolate, look.knockout);
-            (look.opacity, look.blend, look.isolate, look.knockout) = (1.0, BlendMode::Normal, false, Knockout::Neutral);
-            (object.opacity, object.blend, object.isolate) = (1.0, BlendMode::Normal, false);
+            let state = (look.opacity, look.blend, look.isolate, look.knockout, look.knockout_shape);
+            (look.opacity, look.blend, look.isolate, look.knockout, look.knockout_shape) = (1.0, BlendMode::Normal, false, Knockout::Neutral, false);
+            (object.opacity, object.blend, object.isolate, object.knockout_shape) = (1.0, BlendMode::Normal, false, false);
             let mut group = Node::group(self.doc.alloc_id(), vec![Arc::new(look), Arc::new(object)]);
-            (group.opacity, group.blend, group.isolate, group.knockout) = state;
+            (group.opacity, group.blend, group.isolate, group.knockout, group.knockout_shape) = state;
             self.text_looks.insert(group.id);
             if let Some(f) = self.frames.last_mut() {
                 f.children.push(group);
@@ -873,6 +895,10 @@ struct StylePaints<'a> {
     v7_patterns: &'a HashSet<String>,
     /// The brushes the file defines, which a brushed stroke names.
     brushes: &'a [super::super::brush::BrushDraft],
+    /// Which of [`Self::brushes`] are kept as brushes ([`super::super::brush::kept`]).
+    kept: &'a [bool],
+    /// The art an Art brush draws as the file does ([`super::super::brush::bending_art`]).
+    bending: &'a HashSet<String>,
     space: Affine,
 }
 
@@ -1037,11 +1063,21 @@ fn styled(object: &Node, look: &Node, st: &crate::import::ai::style::ArtStyle, p
                 }
             },
             StyleItem::Stroke { brush, .. } => {
-                // A brushed stroke draws as its look only with the brush the file defines (the
-                // first of its name, as the Brushes panel keeps it) at the object's settings.
+                // A brushed stroke draws as its look only with the brush the Brushes panel keeps
+                // under its name, at the object's settings, on a path, a compound path or type (an
+                // image draws no stroke). An Art brush is read on a path or a compound path with
+                // no effects.
                 if let Some((name, settings)) = brush {
-                    let draft = paints.brushes.iter().find(|d| &d.name == name)?;
-                    if !super::super::brush::draws_as(draft, settings) {
+                    let (draft, _) = paints.brushes.iter().zip(paints.kept).find(|(d, kept)| **kept && &d.name == name)?;
+                    if !super::super::brush::draws_as(draft, settings, paints.bending) {
+                        return None;
+                    }
+                    let art = matches!(settings, super::super::brush::PathBrush::Art);
+                    let on_a_path = matches!(object.kind, NodeKind::Path { .. } | NodeKind::Compound { .. });
+                    if !on_a_path && (art || !slot) {
+                        return None;
+                    }
+                    if art && !st.effects.is_empty() {
                         return None;
                     }
                 }
@@ -1122,6 +1158,101 @@ fn strip(n: &mut Node, hidden: &HashSet<NodeId>) {
     }
 }
 
+/// Whether ASCII85 data in comment lines, up to its `~>`, follows the entry keyed `key` of a
+/// dictionary of type `ty`: the `/ASCII85Decode` of a `/Binary` dictionary or a text document, or a
+/// non-native art object's (`/ForeignObject`'s) `/Data`.
+pub(super) fn ascii85_follows(ty: &str, key: Option<&str>) -> bool {
+    matches!((ty, key), ("Binary" | "AI11TextDocument" | "AI11UndoFreeTextDocument", Some("ASCII85Decode")) | ("ForeignObject", Some("Data")))
+}
+
+/// The dictionaries (`/Type :` … `;`) a scan of tokens passes that the reader doesn't read, kept to
+/// tell where an entry's ASCII85 data follows ([`ascii85_follows`]), so the scan can skip past it
+/// as the reader does: a `(` on a `%_` line of the data would otherwise open a string.
+#[derive(Clone, Default)]
+pub(super) struct Dictionaries<'s> {
+    /// The open dictionaries' types, innermost last, up to [`MAX_DEPTH`].
+    types: Vec<&'s [u8]>,
+    /// How many more are open inside the last of `types`.
+    deeper: usize,
+    /// The name just before the token taken.
+    name: Option<&'s [u8]>,
+    /// Whether the string just before the token taken is a key that ASCII85 data follows.
+    string_key: bool,
+    /// The end markers of the sections being scanned (`None`: no section) where the rest of the data
+    /// had no `~>` or marker to stop at, so they aren't searched for again in those sections.
+    no_end: Vec<Option<String>>,
+}
+
+/// Where the ASCII85 data at the start of `rest` stops: just past its `~>`, or at the comment that
+/// comes first with a marker of `section`, the begin and end markers of the section being scanned
+/// (no begin marker when it's empty). A line of the data that reads as one of them counts as the
+/// marker. `None` when `rest` has neither.
+fn data_end(rest: &[u8], section: Option<(&str, &str)>) -> Option<usize> {
+    let mut at = 0;
+    for line in rest.split(|b| matches!(b, b'\r' | b'\n')) {
+        // The first line is what is left of the key's line, where a `%` starts no marker.
+        if at > 0
+            && let Some((comment, (begin, end))) = line.strip_prefix(b"%").zip(section)
+        {
+            let comment = String::from_utf8_lossy(comment);
+            let marker = super::marker(&comment);
+            if marker == end || (!begin.is_empty() && marker == begin) {
+                return Some(at);
+            }
+        }
+        if let Some(i) = line.windows(2).position(|w| w == b"~>") {
+            return Some(at + i + 2);
+        }
+        at += line.len() + 1;
+    }
+    None
+}
+
+impl<'s> Dictionaries<'s> {
+    /// Take `tok`, the token `lex` just gave, and skip the ASCII85 data that follows it, up to where
+    /// [`data_end`] stops for `section`, so the scan still finds that section's markers.
+    pub(super) fn pass(&mut self, tok: &super::Tok<'s>, lex: &mut super::Lexer<'s>, section: Option<(&str, &str)>) {
+        let end = section.map(|(_, end)| end);
+        if self.data_follows(tok) && !self.no_end.iter().any(|e| e.as_deref() == end) {
+            match data_end(lex.rest(), section) {
+                Some(stop) => lex.seek(lex.offset() + stop),
+                None => self.no_end.push(end.map(str::to_owned)),
+            }
+        }
+    }
+
+    /// Take the next token → whether ASCII85 data follows it.
+    fn data_follows(&mut self, tok: &super::Tok<'s>) -> bool {
+        // Comments between a name and what follows it are passed over, as the reader passes them.
+        if matches!(tok, super::Tok::Comment(_)) {
+            return false;
+        }
+        let name = self.name.take();
+        let string_key = std::mem::take(&mut self.string_key);
+        match tok {
+            super::Tok::Name(n) => self.name = Some(n),
+            // A string keys an entry as a name does, but gives a dictionary no type.
+            super::Tok::Str(s) | super::Tok::Hex(s) => self.string_key = self.keys_data(s),
+            super::Tok::Word(b":") if self.types.len() < MAX_DEPTH => self.types.push(name.unwrap_or_default()),
+            super::Tok::Word(b":") => self.deeper = self.deeper.saturating_add(1),
+            super::Tok::Word(b";") if self.deeper > 0 => self.deeper -= 1,
+            super::Tok::Word(b";") => {
+                self.types.pop();
+            }
+            super::Tok::Word(b",") => return string_key || name.is_some_and(|key| self.keys_data(key)),
+            _ => {}
+        }
+        false
+    }
+
+    /// Whether ASCII85 data follows an entry keyed `key` of the innermost dictionary.
+    fn keys_data(&self, key: &[u8]) -> bool {
+        let Some(ty) = self.types.last().filter(|_| self.deeper == 0) else { return false };
+        let (Ok(ty), Ok(key)) = (std::str::from_utf8(ty), std::str::from_utf8(key)) else { return false };
+        ascii85_follows(ty, Some(key))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1132,6 +1263,57 @@ mod tests {
         Arc::new(Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::basic(fill, Paint::None, 0.0)))
     }
 
+    /// An image draws no stroke, so an image with a brush in its art style keeps its drawn look.
+    #[test]
+    fn an_image_with_a_brush_keeps_its_drawn_look() {
+        use super::super::super::brush::{Tool, parse_tool_object};
+        let tool = "Adobe Calligraphic Brush Tool"; // brand-ok: the filter's name in the files
+        let text = format!(
+            "%AI9_BeginArtStyles\n/KnownStyle :\n(Inked) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
+             /CompoundFilter :\n(Stack Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
+             /BasicFilter :\n({tool}) 1 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n\
+             /StrokeStyle : 0 R\n0 1 1 0 1 0 0 XA\n0 1 0 0 0 Xy\n0 J 0 j 1 w 10 M []0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n\
+             6 /Real (Diameter) ,\n2 /Real (DiameterVariation) ,\n2 /Int (DiameterDependsOn) ,\n\
+             40 /Real (Roundness) ,\n10 /Real (RoundnessVariation) ,\n5 /Int (RoundnessDependsOn) ,\n\
+             30 /Real (Angle) ,\n180 /Real (AngleVariation) ,\n6 /Int (AngleDependsOn) ,\n0 /Int (AngleRelativeTo) ,\n\
+             /GObjRef : (N) ({tool}) /PluginObject ; (Brush) ,\n; /Dict ;\n /Part ,\n;\n /Part ,\n;\n%AI9_EndArtStyles\n"
+        );
+        let styles = crate::import::ai::style::art_styles(text.as_bytes());
+        let st = &styles["Inked"];
+        let brushes = [parse_tool_object(Tool::Calligraphic, "N", "1 4 8 30 50 -150 210 2 5 6 0").unwrap()];
+        let (gradients, patterns, names, v7_patterns, bending) =
+            (HashMap::new(), HashMap::new(), ShownNames::default(), HashSet::new(), HashSet::new());
+        let paints = StylePaints {
+            gradients: &gradients,
+            patterns: &patterns,
+            names: &names,
+            v7_patterns: &v7_patterns,
+            brushes: &brushes,
+            kept: &[true],
+            bending: &bending,
+            space: Affine::IDENTITY,
+        };
+        let look = Node::group(NodeId(1), vec![square(2, Paint::solid(vectorcraft_color::Color::rgb(1.0, 0.0, 0.0)))]);
+        assert!(styled(&square(3, Paint::None), &look, st, &paints).is_some(), "a path takes the style");
+        let image =
+            ImageObject { key: "a".into(), width: 1, height: 1, xf: Affine::IDENTITY, link: None, placement: Default::default(), pixels: None };
+        assert!(styled(&Node::new(NodeId(4), NodeKind::Image(Box::new(image))), &look, st, &paints).is_none());
+    }
+
+    #[test]
+    fn data_stops_at_its_end_or_a_marker_of_the_section() {
+        let section = Some(("BeginTextDocument", "EndTextDocument"));
+        assert_eq!(data_end(b"\n%_(a~>\n%AI11_EndTextDocument\n", section), Some(7));
+        assert_eq!(data_end(b"\n%_(a\n%AI11_EndTextDocument\n", section), Some(6));
+        assert_eq!(data_end(b"\n%_(a\n%AI11_BeginTextDocument\n", section), Some(6));
+        // Bytes that aren't UTF-8 after the marker, as the scan reads a comment.
+        assert_eq!(data_end(b"\n%_(a\n%AI11_EndTextDocument \xff\n", section), Some(6));
+        // Right after the key a `%` starts no marker, and an empty begin marker matches no comment.
+        assert_eq!(data_end(b"%AI11_EndTextDocument\n%_(a\n", section), None);
+        assert_eq!(data_end(b"\n%\n", Some(("", "EndPalette"))), None);
+        assert_eq!(data_end(b"\n%AI11_EndTextDocument\n", None), None);
+    }
+
     #[test]
     fn only_outlines_without_gradients_move_alike() {
         // GUARDS: an image's pixels and a placed gradient stay behind when an effect moves the outline.
diff --git a/crates/eps/src/import/ai/read/types.rs b/crates/eps/src/import/ai/read/types.rs
index 09f752db5..17f843d9a 100644
--- a/crates/eps/src/import/ai/read/types.rs
+++ b/crates/eps/src/import/ai/read/types.rs
@@ -316,7 +316,7 @@ pub(super) const IGNORED: &[&str] = &[
     "Ar",
     "Xs",
     "Xt",
-    // A brushed path's width at each anchor (`(…) Xt n XD`), on its hidden source path.
+    // Five indexed curves of samples along a brushed path (`(…) Xt n XD`), on its hidden source path.
     "XD",
     "Xi",
     "XI",
diff --git a/crates/eps/src/import/ai/style.rs b/crates/eps/src/import/ai/style.rs
index 0e1a52a6f..9699e3ac6 100644
--- a/crates/eps/src/import/ai/style.rs
+++ b/crates/eps/src/import/ai/style.rs
@@ -32,12 +32,12 @@
 //! gradient (`Bb` … `flag (name) x y angle length … Bg` … `BB`); `stroke fill Xd` says whether it
 //! paints at all. A blend filter's `mode opacity isolate knockout shape Xy` is its transparency.
 //!
-//! A stroke with a Calligraphic brush is its own basic filter, `(Adobe Calligraphic Brush Tool)`, with
-//! its stroke's style and the brush's settings for the object as entries (see
-//! [`super::brush`]).
+//! A stroke with a Calligraphic or Art brush is its own basic filter, `(Adobe Calligraphic Brush
+//! Tool)` or `(Adobe ArtOnPath Brush Tool)`, with its stroke's style and the brush's settings for
+//! the object as entries (see [`super::brush`]).
 //!
 //! A style is *plain* when every filter in it is one read here: fills and strokes (in a colour; fills
-//! with a pattern or gradient too; strokes with a Calligraphic brush too), each with its own
+//! with a pattern or gradient too; strokes with a Calligraphic or Art brush too), each with its own
 //! transparency and effects, and the effects of
 //! [`effect`]. Such objects are read as themselves with an appearance of those fills, strokes and
 //! effects; others keep their drawn look. Effect › Pathfinder effects (`(Adobe Pathfinder)` in the
@@ -50,6 +50,7 @@ use vectorcraft_color::{BlendMode, Paint};
 use vectorcraft_doc::{Dash, Effect, Knockout, LineCap, LineJoin, WidthProfile};
 use vectorcraft_effects::is_pathfinder;
 
+use super::brush::PathBrush;
 use super::lex::{Lexer, Tok};
 use super::obj::V;
 use super::paint;
@@ -78,6 +79,7 @@ const SHAPE_EFFECTS: &str = "Adobe Shape Effects"; // brand-ok: the filter's nam
 const PATHFINDER: &str = "Adobe Pathfinder"; // brand-ok: the filter's name in the files
 
 const CALLIGRAPHIC: &str = "Adobe Calligraphic Brush Tool"; // brand-ok: the filter's and plug-in's name in the files
+const ART_BRUSH: &str = "Adobe ArtOnPath Brush Tool"; // brand-ok: the filter's and plug-in's name in the files
 
 const CHAIN: &str = "Chain Style Filter";
 const STACK: &str = "Stack Style Filter";
@@ -111,12 +113,32 @@ pub(super) fn warp_style(n: i64) -> Option<&'static str> {
     id.strip_prefix("warp.")
 }
 
-/// The keys of an Effect › Pathfinder › Add filter's dictionary besides `DisplayString`, each with
-/// the kind and the one value read: `Command` 0 is Add, and the rest are its Pathfinder Options,
-/// Soft Mix and Trap settings
-/// (https://community.adobe.com/questions-652/liveeffect-xml-effect-is-added-under-the-object-795137).
-const PATHFINDER_ADD: [(&str, Kind, f64); 13] = [
-    ("Command", Kind::Int, 0.0),
+/// The Effect › Pathfinder effects by the `Command` number of their filter. `Command` 0 is Add
+/// (https://community.adobe.com/questions-652/liveeffect-xml-effect-is-added-under-the-object-795137);
+/// the numbers 1 to 11 are VectorCraft's own reader rules, learned from saved files. Trap (12) isn't
+/// read.
+const PATHFINDER_COMMANDS: [&str; 12] = [
+    "pathfinder.add",
+    "pathfinder.intersect",
+    "pathfinder.exclude",
+    "pathfinder.subtract",
+    "pathfinder.minusBack",
+    "pathfinder.divide",
+    "pathfinder.outline",
+    "pathfinder.trim",
+    "pathfinder.merge",
+    "pathfinder.crop",
+    "pathfinder.hardMix",
+    "pathfinder.softMix",
+];
+
+/// The keys of an Effect › Pathfinder filter's dictionary besides `Command` and `DisplayString`,
+/// each with the kind and the one value read: its Pathfinder Options, Soft Mix's mix and the Trap
+/// settings. Every operation needs each of them at this value, even where the operation doesn't use
+/// it, except that Soft Mix reads a `Mix` from 0.01 to 1 as its Mixing Rate (VectorCraft's own
+/// reader rule, learned from saved files: the rate is `Mix` times 100, within the effect's 1 to 100;
+/// a saved `Mix` outside that range keeps the drawn look).
+const PATHFINDER_OPTIONS: [(&str, Kind, f64); 12] = [
     ("ConvertCustom", Kind::Bool, 1.0),
     ("ExtractUnpainted", Kind::Bool, 1.0),
     ("Mix", Kind::Real, 0.5),
@@ -189,8 +211,8 @@ pub(super) enum StyleItem {
         miter: f64,
         dash: Option<Dash>,
         profile: Option<WidthProfile>,
-        /// A Calligraphic brush: its name, and its settings for this object.
-        brush: Option<(String, vectorcraft_brush::Calligraphic)>,
+        /// A brush: its name, and its settings for this object.
+        brush: Option<(String, PathBrush)>,
     },
 }
 
@@ -1055,18 +1077,38 @@ fn effect(f: &Filter, under: Under) -> Option<Effect> {
     Some(Effect { id: id.into(), params, visible: f.visible })
 }
 
-/// Effect › Pathfinder › Add, when every key of [`PATHFINDER_ADD`] is there with its kind and value
-/// and the only other key is the `DisplayString` text, each written once. `None` for anything else,
-/// which keeps the drawn look.
+/// The Effect › Pathfinder effect of [`PATHFINDER_COMMANDS`] that an integer `Command` names, when
+/// every key of [`PATHFINDER_OPTIONS`] is there with its kind and value (Soft Mix's `Mix` from 0.01
+/// to 1, as its Mixing Rate in percent) and the only other key is the `DisplayString` text, each
+/// written once. `None` for anything else, which keeps the drawn look.
 fn pathfinder_effect(f: &Filter) -> Option<Effect> {
-    let known = f.kinds.iter().all(|(key, kind)| (key == "DisplayString" && *kind == Kind::Other) || PATHFINDER_ADD.iter().any(|(k, ..)| k == key));
+    let known = f
+        .kinds
+        .iter()
+        .all(|(key, kind)| (key == "DisplayString" && *kind == Kind::Other) || key == "Command" || PATHFINDER_OPTIONS.iter().any(|(k, ..)| k == key));
     if !known || f.repeated || !f.arrays.is_empty() || f.fill.is_some() || f.stroke.is_some() || f.gradient || f.pattern.is_some() {
         return None;
     }
-    if !PATHFINDER_ADD.iter().all(|(key, kind, value)| f.kinds.get(*key) == Some(kind) && f.params.get(*key) == Some(value)) {
+    if f.kinds.get("Command") != Some(&Kind::Int) {
         return None;
     }
-    Some(Effect { id: "pathfinder.add".into(), params: json!({}), visible: f.visible })
+    let command = f.params.get("Command").copied().filter(|c| c.is_finite() && c.fract() == 0.0 && *c >= 0.0)?;
+    let id = *PATHFINDER_COMMANDS.get(usize::try_from(command as i64).ok()?)?;
+    let soft_mix = id == "pathfinder.softMix";
+    let options = PATHFINDER_OPTIONS
+        .iter()
+        .all(|(key, kind, value)| f.kinds.get(*key) == Some(kind) && ((soft_mix && *key == "Mix") || f.params.get(*key) == Some(value)));
+    if !options {
+        return None;
+    }
+    let params = if soft_mix {
+        let mix = f.params.get("Mix").copied().filter(|m| (0.01..=1.0).contains(m))?;
+        // Rounded to six decimals: a `Mix` of 0.3 is a rate of 30.
+        json!({"mixingRate": (mix * 100.0 * 1e6).round() / 1e6})
+    } else {
+        json!({})
+    };
+    Some(Effect { id: id.into(), params, visible: f.visible })
 }
 
 /// The fill or stroke basic filter `f` paints, `Ok(None)` when it paints nothing, `Err` when it
@@ -1099,6 +1141,7 @@ fn paint_item(f: &Filter) -> Result<Option<StyleItem>, ()> {
             _ => Err(()),
         },
         CALLIGRAPHIC => calligraphic_stroke(f).map(Some).ok_or(()),
+        ART_BRUSH => art_stroke(f).map(Some).ok_or(()),
         _ => Err(()),
     }
 }
@@ -1130,7 +1173,85 @@ fn calligraphic_stroke(f: &Filter) -> Option<StyleItem> {
         miter: f.miter,
         dash: None,
         profile: None,
-        brush: Some((name.clone(), super::brush::calligraphic(values, variation, codes))),
+        brush: Some((name.clone(), PathBrush::Calligraphic(super::brush::calligraphic(values, variation, codes)))),
+    })
+}
+
+/// The entries an Art brush's filter may hold, with the settings [`art_stroke`] reads. Any other
+/// entry keeps the drawn look, a variable width's among them.
+const ART_ENTRIES: [&str; 18] = [
+    "StrokeStyle",
+    "DisplayString",
+    "Brush",
+    "Proportional",
+    "Segmented",
+    "UpsideDown",
+    "Counterclockwise",
+    "ScaleYDependsOn",
+    "Spacing",
+    "StartSegmentLength",
+    "EndSegmentLength",
+    "Adjustment",
+    "FoldAdjustment",
+    "Scaling",
+    "MinScaling",
+    "MaxScaling",
+    "Colorization",
+    "Adobe Effect Expand Before Version", // brand-ok: the entry's name in the files
+];
+
+/// An Art brush's filter `f` as the stroke it paints: `None` when it isn't a stroke in a color, names
+/// no Art brush, holds an entry that isn't read, or its settings aren't those of art that stretches
+/// along the path, unflipped, at the brush's own width (`Scaling` 1), in Tints (`Colorization` 1),
+/// with `FoldAdjustment` 1, which is [`vectorcraft_brush::ArtBrush`]'s `overlap: false`: its drawn
+/// look stays.
+fn art_stroke(f: &Filter) -> Option<StyleItem> {
+    if !f.paints.0
+        || f.gradient
+        || f.pattern.is_some()
+        || f.repeated
+        || !f.arrays.is_empty()
+        || !f.kinds.keys().all(|k| ART_ENTRIES.contains(&k.as_str()))
+    {
+        return None;
+    }
+    let (name, plugin) = f.plugin_object.as_ref()?;
+    if plugin != ART_BRUSH {
+        return None;
+    }
+    let off = |key: &str, kind: Kind| matches!(entry(f, key, kind), Ok(None | Some(0.0)));
+    let plain = off("Proportional", Kind::Bool)
+        && off("Segmented", Kind::Bool)
+        && off("UpsideDown", Kind::Int)
+        && off("Counterclockwise", Kind::Int)
+        && off("ScaleYDependsOn", Kind::Int)
+        && off("Spacing", Kind::Real)
+        && off("StartSegmentLength", Kind::Real)
+        && off("EndSegmentLength", Kind::Real);
+    if !plain || entry(f, "Adjustment", Kind::Int).ok()?.unwrap_or(1.0) != 1.0 || entry(f, "FoldAdjustment", Kind::Bool).ok()?.unwrap_or(1.0) != 1.0 {
+        return None;
+    }
+    let one = |key: &str| entry(f, key, Kind::Real).is_ok_and(|v| v.unwrap_or(1.0) == 1.0);
+    if entry(f, "Scaling", Kind::Real).ok()?? != 1.0 || !one("MinScaling") || !one("MaxScaling") {
+        return None;
+    }
+    if entry(f, "Colorization", Kind::Int).ok()?? != 1.0 {
+        return None;
+    }
+    let paint = f.stroke.clone()?;
+    // The tinted pieces are process colors, so a swatch's ink would be lost.
+    if matches!(paint, Paint::Solid { swatch: Some(_), .. }) {
+        return None;
+    }
+    Some(StyleItem::Stroke {
+        paint,
+        width: f.width,
+        cap: f.cap,
+        join: f.join,
+        miter: f.miter,
+        dash: None,
+        profile: None,
+        brush: Some((name.clone(), PathBrush::Art)),
     })
 }
 
@@ -1174,7 +1295,7 @@ impl Builder<'_> {
             let c = &filters[k];
             match c.name.as_str() {
                 _ if c.compound => {}
-                FILL | STROKE | CALLIGRAPHIC => match paint_item(c) {
+                FILL | STROKE | CALLIGRAPHIC | ART_BRUSH => match paint_item(c) {
                     Ok(Some(StyleItem::Stroke { .. })) => under.strokes = true,
                     Ok(Some(StyleItem::Pattern { .. })) => under.patterns = true,
                     _ => {}
@@ -1188,7 +1309,7 @@ impl Builder<'_> {
             let c = &filters[k];
             match c.name.as_str() {
                 _ if c.compound => self.plain = false,
-                FILL | STROKE | CALLIGRAPHIC => {
+                FILL | STROKE | CALLIGRAPHIC | ART_BRUSH => {
                     paints += 1;
                     look.visible &= c.visible;
                     match paint_item(c) {
@@ -1294,7 +1415,7 @@ fn style(filters: &[Filter]) -> ArtStyle {
         let f = &filters[id];
         match f.name.as_str() {
             STACK if f.compound => b.stack(id, &mut st),
-            FILL | STROKE | CALLIGRAPHIC | CHAIN => {
+            FILL | STROKE | CALLIGRAPHIC | ART_BRUSH | CHAIN => {
                 if let Some((item, look)) = b.item(id) {
                     st.items.push(item);
                     st.looks.push(look);
diff --git a/crates/eps/src/import/ai/style/tests.rs b/crates/eps/src/import/ai/style/tests.rs
index 4b6cc1502..bdb9a3d6e 100644
--- a/crates/eps/src/import/ai/style/tests.rs
+++ b/crates/eps/src/import/ai/style/tests.rs
@@ -516,8 +516,46 @@ fn pathfinder_add_is_read_as_its_effect() {
 }
 
 #[test]
-fn pathfinder_commands_other_than_add_keep_the_drawn_look() {
-    for command in 1..=12 {
+fn each_pathfinder_command_is_read_as_its_effect() {
+    // GUARDS: only `Command` 0 (Add) was read; a group with any other operation came in as its drawn look.
+    let ids = [
+        (1, "pathfinder.intersect"),
+        (2, "pathfinder.exclude"),
+        (3, "pathfinder.subtract"),
+        (4, "pathfinder.minusBack"),
+        (5, "pathfinder.divide"),
+        (6, "pathfinder.outline"),
+        (7, "pathfinder.trim"),
+        (8, "pathfinder.merge"),
+        (9, "pathfinder.crop"),
+        (10, "pathfinder.hardMix"),
+    ];
+    for (command, id) in ids {
+        let st = group_style(&[pathfinder(&pathfinder_keys(&command.to_string(), "0.5"))]);
+        assert!(st.plain && st.simple && st.pathfinder, "{command}: {st:?}");
+        let [e] = st.effects.as_slice() else { panic!("{command}: {st:?}") };
+        assert_eq!((e.id.as_str(), &e.params, e.visible), (id, &json!({}), true), "{command}");
+    }
+}
+
+#[test]
+fn soft_mix_is_read_with_its_mixing_rate() {
+    for (mix, rate) in [("0.5", 50.0), ("0.3", 30.0), ("0.01", 1.0), ("1", 100.0)] {
+        let st = group_style(&[pathfinder(&pathfinder_keys("11", mix))]);
+        assert!(st.plain && st.simple && st.pathfinder, "{mix}: {st:?}");
+        let [e] = st.effects.as_slice() else { panic!("{mix}: {st:?}") };
+        assert_eq!((e.id.as_str(), &e.params), ("pathfinder.softMix", &json!({"mixingRate": rate})), "{mix}");
+    }
+    // A rate the effect doesn't take keeps the drawn look.
+    for mix in ["0", "0.005", "1.5", "-0.5", "1e999"] {
+        let st = group_style(&[pathfinder(&pathfinder_keys("11", mix))]);
+        assert!(!st.plain && !st.pathfinder && st.effects.is_empty(), "{mix}: {st:?}");
+    }
+}
+
+#[test]
+fn trap_and_unknown_pathfinder_commands_keep_the_drawn_look() {
+    for command in [12, 13, 40] {
         let st = group_style(&[pathfinder(&pathfinder_keys(&command.to_string(), "0.5"))]);
         assert!(!st.plain && !st.pathfinder && st.effects.is_empty(), "{command}: {st:?}");
     }
@@ -623,7 +661,15 @@ fn pathfinder_settings_this_does_not_read_keep_the_drawn_look() {
         ("unpainted art kept", add.replace("1 /Bool (ExtractUnpainted)", "0 /Bool (ExtractUnpainted)")),
         ("other trap tint", add.replace("0.4 /Real (TrapTint)", "0.25 /Real (TrapTint)")),
         ("Mix on Add", add.replace("0.5 /Real (Mix)", "0.3 /Real (Mix)")),
+        ("Mix on Intersect", pathfinder_keys("1", "0.3")),
+        ("Mix on Hard Mix", pathfinder_keys("10", "0.3")),
         ("Mix as a bool", add.replace("0.5 /Real (Mix)", "1 /Bool (Mix)")),
+        ("Soft Mix with Mix as an int", pathfinder_keys("11", "0.5").replace("0.5 /Real (Mix)", "1 /Int (Mix)")),
+        ("Soft Mix without Mix", pathfinder_keys("11", "0.5").replace("0.5 /Real (Mix) ,\n", "")),
+        ("Soft Mix with other Precision", pathfinder_keys("11", "0.3").replace("10 /Real (Precision)", "5 /Real (Precision)")),
+        ("Intersect with other Precision", pathfinder_keys("1", "0.5").replace("10 /Real (Precision)", "5 /Real (Precision)")),
+        ("Divide keeping unpainted art", pathfinder_keys("5", "0.5").replace("1 /Bool (ExtractUnpainted)", "0 /Bool (ExtractUnpainted)")),
+        ("Command twice, Intersect then Add", add.replace("0 /Int (Command)", "1 /Int (Command) ,\n0 /Int (Command)")),
     ];
     for (case, keys) in cases {
         let st = group_style(&[pathfinder(&keys)]);
diff --git a/crates/eps/src/import/ai/tests.rs b/crates/eps/src/import/ai/tests.rs
index 53ed6eb82..f3c8be340 100644
--- a/crates/eps/src/import/ai/tests.rs
+++ b/crates/eps/src/import/ai/tests.rs
@@ -1309,6 +1309,26 @@ fn a_clipping_paths_stroke_stays_on_the_clipping_path() {
     assert_eq!(strokes("", "5 w\n"), [plain, (Some((blue, 5.0)), 1.0, BlendMode::Normal)], "strokes that differ");
 }
 
+/// Clipping paths in a compound path that holds a drawn look become one compound path, which keeps the knockout shape
+/// flag when they all have it.
+#[test]
+fn the_compound_of_clipping_paths_keeps_their_knockout_shape() {
+    let (under, over) = (rect_path(0.0, 0.0, 30.0, 30.0), rect_path(5.0, 5.0, 25.0, 25.0));
+    let (a, b) = (rect_path(0.0, 0.0, 10.0, 10.0), rect_path(5.0, 0.0, 20.0, 10.0));
+    let clipping = |first: &str, second: &str| {
+        let look = format!("0 Ae\nu\n{RED}{under}f\n0 0 0 0 0 0 1 Xa\n{over}f\nU\n9 () XW\n");
+        let doc = read_ok(&layer(&format!("0 Ae\n*u\n{look}{first}{a}h\nW\nn\n{second}{b}h\nW\nn\n*U\n"))).doc;
+        let NodeKind::Group { children, clip: true } = &art(&doc)[0].kind else { panic!("{:?}", art(&doc)[0].kind) };
+        assert!(matches!(children[0].kind, NodeKind::Compound { .. }), "{:?}", children[0].kind);
+        (children[0].opacity, children[0].knockout_shape)
+    };
+    let shape = "0 0.5 0 0 1 Xy\n";
+    assert_eq!(clipping(shape, ""), (0.5, true));
+    assert_eq!(clipping("", ""), (1.0, false));
+    assert_eq!(clipping(shape, "0 0.5 0 0 0 Xy\n"), (0.5, false), "the flag on one of them only");
+    assert_eq!(clipping(shape, "0 0.8 0 0 1 Xy\n"), (1.0, true), "opacities that differ");
+}
+
 /// Several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection: each `W`
 /// reduces the clip set by the ones before it (AI7 spec §5.6.2). Each clipping path after the first clips a clipping
 /// group inside the one before it, and the innermost one holds the art; a clipping path's painted fill stays at its own
@@ -1569,6 +1589,29 @@ fn transparency_of_objects_and_groups() {
     assert_eq!((a[2].opacity, a[2].blend), (1.0, BlendMode::Normal), "the next object's state isn't the group's");
 }
 
+/// A mesh's opacity defines the knockout shape when an `Xy` says so before it or right after its
+/// end, whether its patches make one mesh or a group of patches. An `Xy` that is the layer's leaves
+/// the mesh's as it was.
+#[test]
+fn a_gradient_mesh_keeps_its_knockout_shape() {
+    let one = straight_mesh(2, 2, (10.0, 10.0));
+    let patches = one.replace("[2 2] /Size X#\n", "");
+    let shape = "0 0.5 0 0 1 Xy\n";
+    for (mesh, is_mesh) in [(&one, true), (&patches, false)] {
+        let doc = read_ok(&layer(&format!("{shape}{mesh}"))).doc;
+        assert_eq!(matches!(art(&doc)[0].kind, NodeKind::Mesh(_)), is_mesh, "{:?}", art(&doc)[0].kind);
+        assert_eq!((art(&doc)[0].opacity, art(&doc)[0].knockout_shape), (0.5, true), "{is_mesh}");
+    }
+    let doc = read_ok(&layer(&format!("{one}{shape}0 0 Xd\n6 () XW\n"))).doc;
+    assert_eq!((art(&doc)[0].opacity, art(&doc)[0].knockout_shape), (0.5, true), "written after its end");
+    let doc = read_ok(&layer(&format!("{shape}{one}1 0.35 0 0 0 Xy\n0 0 Xd\n7 () XW\n"))).doc;
+    assert_eq!((art(&doc)[0].opacity, art(&doc)[0].knockout_shape), (0.5, true), "the mesh's own");
+    assert_eq!((doc.layers[0].opacity, doc.layers[0].knockout_shape), (0.35, false), "the layer's own");
+    let doc = read_ok(&layer(&format!("{one}1 0.35 0 0 1 Xy\n0 0 Xd\n7 () XW\n"))).doc;
+    assert_eq!((art(&doc)[0].opacity, art(&doc)[0].knockout_shape), (1.0, false), "the mesh's own");
+    assert_eq!((doc.layers[0].opacity, doc.layers[0].knockout_shape), (0.35, true), "the layer's own");
+}
+
 #[test]
 fn a_gradient_mesh_takes_the_transparency_written_after_it() {
     // GUARDS: a mesh's own state (`Xy`) comes right after its `/End X!`, before `Xd` and `XW`, as a
@@ -1635,6 +1678,21 @@ fn a_transparency_set_in_a_dictionary_s_art_stays_after_it() {
     assert_eq!((paths[1].opacity, paths[1].blend), (1.0, BlendMode::Normal), "the state the text's art set");
 }
 
+#[test]
+fn a_transparency_set_in_a_clipping_group_stays_after_it() {
+    // GUARDS: `Q` ends a clipping group but doesn't take the transparency back to what it was at
+    // its `q`: the writer sets `Xy` only when the next object's state differs from the last one it
+    // wrote. A Screen glow, then a clipping group whose path is set back to Normal, then type with
+    // no `Xy`: restored at `Q`, the type drew in Screen and nearly vanished on a light background.
+    let clip = format!("q\n0 1 0 0 0 Xy\n{}h\nW\nn\n{RED}{}f\nQ\n", rect_path(0.0, 0.0, 200.0, 100.0), rect_path(40.0, 0.0, 50.0, 10.0));
+    let body = format!("2 0.8 0 0 0 Xy\n{RED}{}f\n{clip}{RED}{}f\n", rect_path(0.0, 0.0, 10.0, 10.0), rect_path(20.0, 0.0, 30.0, 10.0));
+    let a = art(&read_ok(&layer(&body)).doc);
+    assert_eq!(a.len(), 3, "{a:#?}");
+    assert_eq!((a[0].opacity, a[0].blend), (0.8, BlendMode::Screen), "the glow's own state");
+    assert!(matches!(a[1].kind, NodeKind::Group { clip: true, .. }), "{:?}", a[1].kind);
+    assert_eq!((a[2].opacity, a[2].blend), (1.0, BlendMode::Normal), "the state set inside the clipping group");
+}
+
 #[test]
 fn gradients() {
     let defs = "%AI5_BeginGradient: (G)\n(G) 1 2 Bd\n[\n<00FF>\n0\n0 0 0 0 1 0 0 2 1 6 %_BS\n\
@@ -2338,6 +2396,44 @@ fn a_drawn_look_stands_for_its_object() {
     assert!(r.warnings.iter().any(|w| w.contains("drawn look (1)")), "{:?}", r.warnings);
 }
 
+/// An object kept as its drawn look: the look (a group), then the object on `%_` lines and its style.
+fn drawn_look_art() -> String {
+    let hidden_rect = rect_path(0.0, 0.0, 10.0, 10.0).replace('\n', "\n%_");
+    format!(
+        "0 Ae\nu\n{RED}{}f\n{}S\nU\n%_{hidden_rect}n\n%_/ArtDictionary :\n%_/XMLUID : (Look) ; (AI10_ArtUID) ,\n%_;\n1 (Look style) XW\n",
+        rect_path(0.0, 0.0, 10.0, 10.0),
+        rect_path(0.0, 0.0, 10.0, 10.0),
+    )
+}
+
+/// A pattern's art holding an object kept as its drawn look counts in the note, as a symbol's does;
+/// a definition the same name replaces later counts no longer.
+#[test]
+fn a_drawn_look_in_a_patterns_art_is_noted() {
+    let pattern = |art: &str| format!("%AI3_BeginPattern: (P)\n(P) 0 0 10 10\n0 A\n0 Xw\n{art}E\n%AI3_EndPattern\n");
+    let looked = pattern(&drawn_look_art());
+    let r = read_ok(&format!("{looked}{}", layer("")));
+    assert_eq!(r.doc.patterns.len(), 1, "{:?}", r.warnings);
+    assert!(r.warnings.iter().any(|w| w.contains("drawn look (1)")), "{:?}", r.warnings);
+    let plain = pattern(&format!("{RED}{}f\n", rect_path(0.0, 0.0, 10.0, 10.0)));
+    let r = read_ok(&format!("{looked}{plain}{}", layer("")));
+    assert_eq!(r.doc.patterns.len(), 1, "{:?}", r.warnings);
+    assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
+}
+
+/// A brush's art holding an object kept as its drawn look counts in the note once a brush that is
+/// kept uses the art; art no brush uses brings no note.
+#[test]
+fn a_drawn_look_in_a_brushs_art_is_noted_when_a_brush_uses_it() {
+    let section = format!("%AI8_BeginBrushPattern\n(Dot art)\n0 A\n{}%AI8_EndBrushPattern\n", drawn_look_art());
+    let r = read_ok(&format!("{section}{}{}", plugin_object(SCATTER, "Spray", SPRAY), layer("")));
+    let lib = vectorcraft_brush::library(&r.doc);
+    assert!(matches!(brush_named(&lib, "Spray"), vectorcraft_brush::BrushKind::Scatter(_)), "{:?}", r.warnings);
+    assert!(r.warnings.iter().any(|w| w.contains("drawn look (1)")), "{:?}", r.warnings);
+    let r = read_ok(&format!("{section}{}{}", plugin_object(CALLIGRAPHIC, "Nib", NIB), layer("")));
+    assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
+}
+
 /// Editing data with one layer holding an image: `matrix` (`[a b c d tx ty]`), its size, colour
 /// space, kind and alpha channels, its samples, and the size the data comment declares.
 fn image(matrix: &str, (w, h): (u32, u32), (space, kind, alpha): (&str, u32, u32), data: &[u8], declared: usize) -> Vec<u8> {
@@ -3285,6 +3381,106 @@ fn legacy_type_keeps_its_spacing_hanging_punctuation_and_hyphenation() {
     assert_eq!(texts[1].para_at(0), two);
 }
 
+/// `TV` (§15.3.4) sets the writing direction of point type, area type, type on a path and linked
+/// areas, and lasts into the next text object until it changes.
+#[test]
+fn legacy_type_keeps_its_writing_direction() {
+    let frame = "10 10 m\n110 10 L\n110 110 L\n10 110 L\nN";
+    let area = format!("1 To\n1 0 0 1 10 110 0 Tp\n{frame}\nTP\n0 Tr\n0 0 0 1 k\n/_Helvetica 12 Tf\n(Area) Tx\nTO\n");
+    let on_path = "2 To\n1 0 0 1 0 0 0 Tp\n10 10 m\n110 10 L\nN\nTP\n(Path) Tx\nTO\n";
+    let linked = format!("1 To\n1 0 0 1 10 110 0 Tp\n{frame}\nTP\n1 0 0 1 200 110 0 Tp\n{frame}\nTP\n(Linked) Tx\nTO\n");
+    let art = format!("{}{area}{on_path}{linked}{}", point_type("1 TV", "Point"), point_type("0 TV", "Flat"));
+    let texts = legacy_texts(&art);
+    let vertical: Vec<bool> = texts.iter().map(|t| t.vertical).collect();
+    assert_eq!(vertical, [true, true, true, true, true, false]);
+    assert!(matches!(texts[1].kind, vectorcraft_doc::TextKind::Area { .. }));
+    assert!(matches!(texts[2].kind, vectorcraft_doc::TextKind::OnPath { .. }));
+    // Vertical point type runs down the canvas from `Tp`'s origin (10, 50), which opens at document
+    // (10, 50) on the 100 pt tall artboard, on the column's center line.
+    let long = &legacy_texts(&point_type("1 TV", "Point type"))[0];
+    let bounds = long.xf.transform_rect_bbox(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), long).bounds);
+    assert!(bounds.height() > bounds.width(), "{bounds:?}");
+    assert!(bounds.x0 < 10.0 && bounds.x1 > 10.0, "{bounds:?}");
+    assert!((bounds.y0 - 50.0).abs() < 1.0 && bounds.y1 > 60.0, "{bounds:?}");
+    // A text object keeps the direction in force at its first character, with a warning when a later
+    // character has another; the mode lasts into the next text object.
+    let changed = point_type("1 TV", "First").replace("TO\n", "0 TV\n(Second) Tx\nTO\n");
+    let r = legacy_read(&format!("{changed}{}", point_type("", "Next")));
+    let changed = art_texts(&r.doc);
+    assert!(changed[0].vertical);
+    assert_eq!(changed[0].plain_text(), "FirstSecond");
+    assert!(!changed[1].vertical);
+    assert_eq!(r.warnings, [DIRECTION_CHANGE_LEFT_OUT]);
+    // A direction that changes and changes back also warns.
+    let back = point_type("", "a").replace("TO\n", "1 TV\n(b) Tx\n0 TV\n(c) Tx\nTO\n");
+    assert_eq!(legacy_read(&back).warnings, [DIRECTION_CHANGE_LEFT_OUT]);
+    // A `TV` that no character follows does not warn, and an object with no characters opens no
+    // type, while its `TV` lasts into the next object.
+    let trailing = point_type("", "a").replace("TO\n", "1 TV\nTO\n");
+    assert!(legacy_read(&trailing).warnings.is_empty());
+    let empty = legacy_texts(&format!("0 To\n1 0 0 1 10 50 0 Tp\nTP\n1 TV\nTO\n{}", point_type("", "Next")));
+    assert_eq!((empty.len(), empty[0].vertical), (1, true));
+    // `TV` before `To` counts, and `TV` after the last character only reaches the next object.
+    let before = legacy_texts(&format!("1 TV\n{}", point_type("", "Hi")));
+    assert!(before[0].vertical);
+    let after = point_type("", "Hi").replace("TO\n", "1 TV\nTO\n");
+    let after = legacy_texts(&format!("{after}{}", point_type("", "Next")));
+    assert_eq!((after[0].vertical, after[1].vertical), (false, true));
+}
+
+/// The glyph origins of a legacy-format text object.
+fn legacy_origins(t: &vectorcraft_doc::TextObject) -> Vec<(f64, f64)> {
+    vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).glyphs.iter().map(|g| (g.origin.x, g.origin.y)).collect()
+}
+
+/// `Ty` (§15.3.4) marks the characters of a Kumi block in vertical and in horizontal type, `TY`
+/// marks them in horizontal type, and `Tv` keeps Roman characters upright in vertical type; `Tv`
+/// may come inside the text path. All three last into the next text object.
+#[test]
+fn legacy_type_keeps_kumi_blocks_and_upright_roman_characters() {
+    let runs = |art: &str| -> Vec<(String, bool, bool)> {
+        let texts = legacy_texts(art);
+        texts[0].runs.iter().map(|r| (r.text.clone(), r.style.tate_chu_yoko, r.style.standard_vertical_roman)).collect()
+    };
+    let kumi = |begin: &str, end: &str| point_type(&format!("(A) Tx\n{begin}\n(12) Tx\n{end}"), "B");
+    let marked = vec![("A".to_string(), false, false), ("12".to_string(), true, false), ("B".to_string(), false, false)];
+    assert_eq!(runs(&format!("1 TV\n{}", kumi("1 Ty", "0 Ty"))), marked);
+    assert_eq!(runs(&kumi("1 Ty", "0 Ty")), marked);
+    assert_eq!(runs(&kumi("1 TY", "0 TY")), marked);
+    assert!(!legacy_texts(&kumi("1 TY", "0 TY"))[0].vertical);
+    // `TY` records a block that the set text doesn't show: vertical type opens without it, and the
+    // block starts again in the next horizontal object.
+    let unmarked = vec![("A12B".to_string(), false, false)];
+    assert_eq!(runs(&format!("1 TV\n{}", kumi("1 TY", "0 TY"))), unmarked);
+    let recorded = legacy_texts(&format!("1 TV\n1 TY\n{}0 TV\n{}", point_type("", "A"), point_type("", "B")));
+    assert_eq!((recorded[0].runs[0].style.tate_chu_yoko, recorded[1].runs[0].style.tate_chu_yoko), (false, true));
+    let upright = point_type("(a) Tx\n1 Tv", "b");
+    assert_eq!(runs(&format!("1 TV\n{upright}")), [("a".to_string(), false, false), ("b".to_string(), false, true)]);
+    let in_path = point_type("", "c").replace("0 Tp\nTP", "0 Tp\n1 Tv\nTP");
+    assert_eq!(runs(&in_path), [("c".to_string(), false, true)]);
+    assert_eq!(runs(&point_type("1 Tv\n(a) Tx\n0 Tv", "b")), [("a".to_string(), false, true), ("b".to_string(), false, false)]);
+    // Each one lasts into the next text object.
+    for (op, kept) in [("Ty", (true, false)), ("TY", (true, false)), ("Tv", (false, true))] {
+        let texts = legacy_texts(&format!("{}{}", point_type(&format!("1 {op}"), "a"), point_type("", "b")));
+        let st = &texts[1].runs[0].style;
+        assert_eq!((st.tate_chu_yoko, st.standard_vertical_roman), kept, "{op}");
+    }
+    // Horizontal type keeps the mark and doesn't move the characters.
+    let plain = &legacy_texts(&point_type("", "A12B"))[0];
+    let in_horizontal = &legacy_texts(&kumi("1 Ty", "0 Ty"))[0];
+    assert_eq!(legacy_origins(in_horizontal), legacy_origins(plain));
+    // Two blocks with nothing between them open as one block.
+    let vertical = |attrs: &str, text: &str| legacy_texts(&format!("1 TV\n{}", point_type(attrs, text))).remove(0);
+    let two = vertical("1 Ty\n(AB) Tx\n0 Ty\n1 Ty", "CD");
+    let one = vertical("1 Ty", "ABCD");
+    assert_eq!(legacy_origins(&two), legacy_origins(&one));
+    // Two or three digits that no block marks are set across the column by the layout's own rule.
+    let digits = vertical("", "12");
+    assert!(!digits.runs[0].style.tate_chu_yoko);
+    assert_eq!(legacy_origins(&digits), legacy_origins(&vertical("1 Ty", "12")));
+    assert_ne!(legacy_origins(&vertical("", "AB")), legacy_origins(&vertical("1 Ty", "AB")));
+}
+
 /// A legacy attribute whose operands are missing, are not numbers, or are flags other than 0 and
 /// 1 leaves the attribute as it was, and operands are read by their place.
 #[test]
@@ -3300,6 +3496,15 @@ fn legacy_type_attributes_with_bad_operands_stay_as_they_were() {
     assert_eq!(p.justify, vectorcraft_doc::Justify::Right);
     assert_eq!((p.first_line_indent, p.left_indent, p.right_indent), (5.0, 6.0, 7.0));
     assert_eq!(texts[0].runs[0].style.kerning, Some(0.0), "kerning stays off");
+    let texts = legacy_texts(&point_type("1 TV\n1 Tv\n1 Ty\n2 TV\n/x TV\nTV\n-1 Tv\n(x) Tv\n0.5 Ty\n2 TY", "Hi"));
+    let st = &texts[0].runs[0].style;
+    assert!(texts[0].vertical && st.standard_vertical_roman && st.tate_chu_yoko);
+    let texts = legacy_texts(&point_type("2 TV\n-1 TV\n2 Tv\n-1 Tv\n0.5 Ty\n-1 Ty\n2 TY\n-1 TY\n1 TY\n2 TY\n0.5 TY", "Hi"));
+    let st = &texts[0].runs[0].style;
+    assert!(!texts[0].vertical && !st.standard_vertical_roman);
+    assert!(st.tate_chu_yoko, "`TY` stays on");
+    let texts = legacy_texts(&point_type("2 TV\n-1 TV\n2 Tv\n-1 Tv\n0.5 Ty\n-1 Ty\n2 TY\n-1 TY", "Hi"));
+    assert!(!texts[0].runs[0].style.tate_chu_yoko);
     // A scale or leading pair with a bad operand leaves both as they were; one operand is the
     // horizontal scale (or the leading) of the format before version 7.
     let texts = legacy_texts(&point_type("50 80 Tz\n14 3 Tl\n/x 120 Tz\n/x 20 Tl", "Hi"));
@@ -3747,6 +3952,7 @@ fn legacy_linked_area_frames_cap_their_copied_tab_stops() {
 
 /// The warning when linked areas are left out.
 const LINKED_AREAS_LEFT_OUT: &str = "linked type areas past VectorCraft's limits were left out";
+const DIRECTION_CHANGE_LEFT_OUT: &str = "type that changes writing direction inside a text object opens in the direction of its first character";
 
 /// The frames of linked areas times the characters of their story are kept to the reader's
 /// allowance of characters: a story of more than half of it gets one frame, and of a third, two.
@@ -4503,6 +4709,166 @@ fn non_native_art_that_is_not_a_pdf_is_left_out_with_a_note() {
     assert!(s.warnings.iter().any(|w| w.starts_with(read::NON_NATIVE_ART_UNREAD)), "{:?}", s.warnings);
 }
 
+/// The same data in a symbol's definition: its `%_` line with a `(` opens no string, so the
+/// definition ends at its own end marker and the symbol after it comes in.
+#[test]
+fn non_native_art_in_a_symbol_ends_at_the_definitions_end() {
+    let foreign = "/ForeignObject :\n1 /Version ,\n2 0 0 2 10 20  /RTransform ,\n10 20  /Origin ,\n1 2 5 8  /Bounds ,\n/Data ,\n%,u@!!/MSk8%41#ocdN=10d&\n%_O%*mGn(RduU.]4`[u[.f\n%_;(]<[%\n%1H@<P2`V<S,pbuU7L]\\~>\n;\n";
+    let defs = symbols(&(symbol("Pdf", &format!("{foreign}{}", dot()), 5) + &symbol("Dot", &dot(), 5)));
+    let s = read_ok(&(defs + &layer(&instance("Dot", [1.0, 0.0, 0.0, -1.0, 20.0, 50.0]))));
+    let names: Vec<&str> = s.doc.symbols.iter().map(|s| s.name.as_str()).collect();
+    assert!(names.contains(&"Dot"), "{names:?}");
+    let a = art(&s.doc);
+    assert_eq!(a.len(), 1);
+    assert!(matches!(&a[0].kind, NodeKind::SymbolInstance { symbol, .. } if symbol == "Dot"), "{:?}", a[0].kind);
+}
+
+/// Comment lines between a dictionary's name and its `:`, or an entry's key and its `,`, don't hide
+/// the data from the scan of a symbol's definition.
+#[test]
+fn non_native_art_with_comments_in_a_symbol_ends_at_the_definitions_end() {
+    let foreign = "/ForeignObject\n%note\n:\n1 /Version ,\n2 0 0 2 10 20  /RTransform ,\n10 20  /Origin ,\n1 2 5 8  /Bounds ,\n/Data\n%note\n,\n%,u@!!/MSk8%41#ocdN=10d&\n%_O%*mGn(RduU.]4`[u[.f\n%_;(]<[%\n%1H@<P2`V<S,pbuU7L]\\~>\n;\n";
+    let defs = symbols(&(symbol("Pdf", &format!("{foreign}{}", dot()), 5) + &symbol("Dot", &dot(), 5)));
+    let s = read_ok(&(defs + &layer(&instance("Dot", [1.0, 0.0, 0.0, -1.0, 20.0, 50.0]))));
+    let names: Vec<&str> = s.doc.symbols.iter().map(|s| s.name.as_str()).collect();
+    assert!(names.contains(&"Dot"), "{names:?}");
+}
+
+/// A string keys an entry as a name does: `(Data) ,` doesn't hide the data from the scan of a
+/// symbol's definition either.
+#[test]
+fn non_native_art_keyed_by_a_string_in_a_symbol_ends_at_the_definitions_end() {
+    for key in ["(Data)", "<44617461>"] {
+        let foreign = format!(
+            "/ForeignObject :\n1 /Version ,\n2 0 0 2 10 20  /RTransform ,\n10 20  /Origin ,\n1 2 5 8  /Bounds ,\n{key} ,\n%,u@!!/MSk8%41#ocdN=10d&\n%_O%*mGn(RduU.]4`[u[.f\n%_;(]<[%\n%1H@<P2`V<S,pbuU7L]\\~>\n;\n"
+        );
+        let defs = symbols(&(symbol("Pdf", &format!("{foreign}{}", dot()), 5) + &symbol("Dot", &dot(), 5)));
+        let s = read_ok(&(defs + &layer(&instance("Dot", [1.0, 0.0, 0.0, -1.0, 20.0, 50.0]))));
+        let names: Vec<&str> = s.doc.symbols.iter().map(|s| s.name.as_str()).collect();
+        assert!(names.contains(&"Dot"), "{key}: {names:?}");
+    }
+}
+
+/// A `/Binary` dictionary's data in a skipped alternate: its `%_` line with a `(` opens no string,
+/// so the block ends at its own end marker.
+#[test]
+fn binary_data_in_a_skipped_alternate_ends_at_the_blocks_end() {
+    let binary = "%_/Document :\n%_/Binary : /ASCII85Decode ,\n%_(]<[%\n%;;;~>\n%_; (Profile) ,\n%_;\n";
+    let body = format!(
+        "%AI17_Begin_Content_if_version_gt:24 4\n%AI17_Alternate_Content\n{binary}frobnicate\n%AI17_End_Versioned_Content\n{}",
+        layer(&(rect_path(0.0, 0.0, 1.0, 1.0) + "f\n"))
+    );
+    let s = read_ok(&body);
+    assert_eq!(art(&s.doc).len(), 1);
+    assert!(!s.warnings.iter().any(|w| w == read::VERSIONED_UNENDED), "{:?}", s.warnings);
+}
+
+/// A text document's data, the free type's undo copy included: its `%_` line with a `(` opens no
+/// string, even after a line that reads as another section's end marker, so the section ends at
+/// its own end marker and the art after it comes in.
+#[test]
+fn text_document_data_ends_at_the_sections_end() {
+    for ty in ["AI11TextDocument", "AI11UndoFreeTextDocument"] {
+        let document =
+            format!("%AI11_BeginTextDocument\n/{ty} : /ASCII85Decode ,\n%,u@!!/MSk8\n%AI3_EndPattern\n%_(]<[%\n%;;;~>\n%_;\n%AI11_EndTextDocument\n");
+        let s = read_ok(&format!("{document}{}", layer(&(rect_path(0.0, 0.0, 1.0, 1.0) + "f\n"))));
+        assert_eq!(art(&s.doc).len(), 1, "{ty}");
+    }
+}
+
+/// Data without its `~>` isn't skipped: the section still ends at its own end marker, with no `~>`
+/// after it, with one in a later section, and with later data that holds a `(` on a `%_` line.
+#[test]
+fn data_without_its_end_does_not_hide_the_sections_end() {
+    let unended = "%AI11_BeginTextDocument\n/AI11TextDocument : /ASCII85Decode ,\n%,u@!!/MSk8\n%AI11_EndTextDocument\n";
+    let ended = "%AI11_BeginTextDocument\n/AI11TextDocument : /ASCII85Decode ,\n%,u@!!/MSk8\n%_(]<[%\n%;;;~>\n%_;\n%AI11_EndTextDocument\n";
+    let art_layer = layer(&(rect_path(0.0, 0.0, 1.0, 1.0) + "f\n"));
+    for body in [format!("{unended}{art_layer}"), format!("{unended}{art_layer}{ended}"), format!("{unended}{ended}{art_layer}")] {
+        let s = read_ok(&body);
+        assert_eq!(art(&s.doc).len(), 1, "{body}");
+    }
+}
+
+/// Data without its `~>` is skipped up to the section's end marker: its `%_` line with a `(` opens
+/// no string, so the section ends there and the art after it comes in. A `%` right after the key
+/// starts no marker, so it doesn't end the data.
+#[test]
+fn data_without_its_end_holding_a_string_ends_at_the_sections_end() {
+    let art_layer = layer(&(rect_path(0.0, 0.0, 1.0, 1.0) + "f\n"));
+    for document in [
+        "%AI11_BeginTextDocument\n/AI11TextDocument : /ASCII85Decode ,\n%,u@!!/MSk8\n%_(]<[%\n%AI11_EndTextDocument\n",
+        "%AI11_BeginTextDocument\r\n/AI11TextDocument : /ASCII85Decode ,\r\n%_(]<[%\r\n%AI11_EndTextDocument\r\n",
+        "%AI11_BeginTextDocument\n/AI11TextDocument : /ASCII85Decode ,%AI11_EndTextDocument\n%_(]<[%\n%AI11_EndTextDocument\n",
+    ] {
+        let s = read_ok(&format!("{document}{art_layer}"));
+        assert_eq!(art(&s.doc).len(), 1, "{document}");
+    }
+}
+
+/// Data without its `~>` stops at the start of a section of the same kind nested after it too, so
+/// the outer section still ends at its own end marker and not at the nested one's.
+#[test]
+fn data_without_its_end_stops_at_a_nested_sections_start() {
+    let square = rect_path(0.0, 0.0, 1.0, 1.0) + "f\n";
+    let body = format!(
+        "%AI17_Begin_Content_if_version_gt:24 4\n%AI17_Alternate_Content\n/Binary : /ASCII85Decode ,\n%_(]<[%\n\
+         %AI17_Begin_Content_if_version_gt:23 1\nfrobnicate\n%AI17_End_Versioned_Content\n{square}%AI17_End_Versioned_Content\n{}",
+        layer(&square)
+    );
+    let s = read_ok(&body);
+    assert_eq!(art(&s.doc).len(), 1);
+    assert!(!s.warnings.iter().any(|w| w == read::VERSIONED_UNENDED), "{:?}", s.warnings);
+}
+
+/// Versioned content that doesn't end is scanned again for the swatches' names: data with its `~>`
+/// is still skipped, though data with none comes after it, and the dictionary open where the
+/// content starts still counts.
+#[test]
+fn swatch_names_are_found_past_data_in_versioned_content_that_does_not_end() {
+    let entries = "1 /Version ,\n2 0 0 2 10 20  /RTransform ,\n10 20  /Origin ,\n1 2 5 8  /Bounds ,\n/Data ,\n%,u@!!/MSk8%41#ocdN=10d&\n%_O%*mGn(RduU.]4`[u[.f\n%_;(]<[%\n%1H@<P2`V<S,pbuU7L]\\~>\n;\n0 0 Xd\n6 () XW\n0 Ae\n";
+    let alternate = "%AI17_Begin_Content_if_version_gt:24 4\n%AI17_Alternate_Content\n";
+    let sea = format!("0 1 1 0 (Sea) 0 x\n{}f\n", rect_path(0.0, 0.0, 5.0, 5.0));
+    let unended = "%AI11_BeginTextDocument\n/AI11TextDocument : /ASCII85Decode ,\n%,u@!!/MSk8\n%AI11_EndTextDocument\n";
+    for art_text in [format!("{alternate}/ForeignObject :\n{entries}{sea}{unended}"), format!("/ForeignObject :\n{alternate}{entries}{sea}{unended}")]
+    {
+        let body = format!("{}{}", DOTS.replace("(Dots)", "(Sea\\n1)"), layer(&art_text));
+        let d = read(stream(&body).as_bytes()).unwrap().doc;
+        let names: Vec<&str> = d.patterns.iter().map(|p| p.name.as_str()).collect();
+        assert_eq!(names, ["Sea 2"], "{art_text}");
+    }
+}
+
+/// A search for where data stops that found nothing outside a section doesn't stop a later
+/// section's data at that section's end, so the named color after it still takes its name first.
+/// The `/Binary` holds a group, where the reader doesn't take what follows its key as data.
+#[test]
+fn swatch_names_are_found_past_data_in_a_section_after_a_search_outside_sections_found_nothing() {
+    let sea = format!("0 1 1 0 (Sea) 0 x\n{}f\n", rect_path(0.0, 0.0, 5.0, 5.0));
+    let before = "/Binary :\nu\n/ASCII85Decode ,\nU\n;\n";
+    for section in [
+        "%AI17_Begin_Content_if_version_gt:24 4\n%AI17_Alternate_Content\n/Binary : /ASCII85Decode ,\n%_(]<[%\n%AI17_End_Versioned_Content\n",
+        "%AI11_BeginTextDocument\n/AI11TextDocument : /ASCII85Decode ,\n%_(]<[%\n%AI11_EndTextDocument\n",
+    ] {
+        let art_text = format!("{before}{section}{sea}");
+        let body = format!("{}{}", DOTS.replace("(Dots)", "(Sea\\n1)"), layer(&art_text));
+        let d = read(stream(&body).as_bytes()).unwrap().doc;
+        let names: Vec<&str> = d.patterns.iter().map(|p| p.name.as_str()).collect();
+        assert_eq!(names, ["Sea 2"], "{art_text}");
+    }
+}
+
+/// The names the swatches take are found past the same data: a named color after it still takes
+/// its name first, and the pattern named after it is numbered.
+#[test]
+fn swatch_names_are_found_past_non_native_art_data() {
+    let foreign = "/ForeignObject :\n1 /Version ,\n2 0 0 2 10 20  /RTransform ,\n10 20  /Origin ,\n1 2 5 8  /Bounds ,\n/Data ,\n%,u@!!/MSk8%41#ocdN=10d&\n%_O%*mGn(RduU.]4`[u[.f\n%_;(]<[%\n%1H@<P2`V<S,pbuU7L]\\~>\n;\n0 0 Xd\n6 () XW\n0 Ae\n";
+    let sea = format!("0 1 1 0 (Sea) 0 x\n{}f\n", rect_path(0.0, 0.0, 5.0, 5.0));
+    let body = format!("{}{}", DOTS.replace("(Dots)", "(Sea\\n1)"), layer(&format!("{foreign}{sea}")));
+    let d = read(stream(&body).as_bytes()).unwrap().doc;
+    let names: Vec<&str> = d.patterns.iter().map(|p| p.name.as_str()).collect();
+    assert_eq!(names, ["Sea 2"]);
+}
+
 /// A PDF with one page of `size` points holding `content`.
 fn tiny_pdf(size: f64, content: &str) -> Vec<u8> {
     let objects = [
@@ -4911,6 +5277,25 @@ fn an_object_with_a_style_this_reads_comes_in_as_itself() {
     assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
 }
 
+#[test]
+fn a_symbol_defined_before_the_art_styles_reads_its_styled_objects() {
+    // GUARDS: objects in a symbol defined ahead of `%AI9_BeginArtStyles` (as Illustrator 24 writes
+    // its editing data) found no style and came in as their drawn look.
+    let hidden_rect = rect_path(0.0, 0.0, 10.0, 10.0).replace('\n', "\n%_");
+    let styled = format!("u\n{RED}{}f\nU\n%_{hidden_rect}f\n1 (Blue) XW\n", rect_path(0.0, 0.0, 10.0, 10.0));
+    let r = read_ok(&format!("{}{ART_STYLES}{}", symbols(&symbol("Tag", &styled, 1)), layer("")));
+    let art = &r.doc.symbols.first().expect("the symbol").art;
+    let object = match &art.kind {
+        NodeKind::Group { children, .. } if children.len() == 1 => &children[0],
+        _ => art,
+    };
+    assert!(matches!(object.kind, NodeKind::Path { .. }), "the object, not its look: {art:#?}");
+    assert_eq!(object.appearance.fill().and_then(|f| f.paint.color()), Some(Color::rgb(0.0, 0.0, 1.0)));
+    let effects: Vec<_> = object.appearance.effects.iter().map(|e| e.id.as_str()).collect();
+    assert_eq!(effects, ["stylize.dropShadow"]);
+    assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
+}
+
 /// An art style named `name` (its bytes as written) that fills with colour `xa` (`c m y k r g b Xa`).
 fn fill_style(name: &str, xa: &str) -> String {
     fill_style_with(name, xa, "")
@@ -5153,11 +5538,69 @@ fn a_group_with_a_pathfinder_effect_keeps_its_members_and_the_effect() {
     assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
 }
 
+#[test]
+fn each_pathfinder_operation_on_a_group_draws_as_vectorcraft_draws_it() {
+    // GUARDS: only Add (`Command` 0) was read; the other operations came in as the drawn look's one path.
+    let ops = [
+        (1, "pathfinder.intersect"),
+        (2, "pathfinder.exclude"),
+        (3, "pathfinder.subtract"),
+        (4, "pathfinder.minusBack"),
+        (5, "pathfinder.divide"),
+        (6, "pathfinder.outline"),
+        (7, "pathfinder.trim"),
+        (8, "pathfinder.merge"),
+        (9, "pathfinder.crop"),
+        (10, "pathfinder.hardMix"),
+        (11, "pathfinder.softMix"),
+    ];
+    for (command, id) in ops {
+        let mix = if command == 11 { 0.3 } else { 0.5 };
+        let r = read_ok(&format!("{}{}", pathfinder_styles(command, mix), layer(&pathfinder_group())));
+        let a = art(&r.doc);
+        assert_eq!(a.len(), 1, "{command}: {a:#?}");
+        let members = a[0].children().cloned().unwrap_or_default();
+        assert_eq!(members.len(), 2, "{command}: the squares, not the look: {a:#?}");
+        let [e] = a[0].appearance.effects.as_slice() else { panic!("{command}: {:?}", a[0].appearance) };
+        assert_eq!((e.id.as_str(), e.visible), (id, true), "{command}");
+        let params = if command == 11 { serde_json::json!({"mixingRate": 30.0}) } else { serde_json::json!({}) };
+        assert_eq!(e.params, params, "{command}");
+        assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{command}: {:?}", r.warnings);
+        // The same squares in a group made in VectorCraft, with the effect of that operation.
+        let square = |m: &Arc<Node>| {
+            let bounds = m.geometric_bounds().unwrap();
+            Arc::new(Node::path(m.id, vectorcraft_geom::shapes::rectangle(bounds), vectorcraft_doc::Appearance::basic(fill(m), Paint::None, 0.0)))
+        };
+        let mut own = Node::group(a[0].id, members.iter().map(square).collect());
+        own.appearance.effects.push(vectorcraft_doc::Effect { id: id.into(), params: params.clone(), visible: true });
+        // Each result's box and paints; Outline's lines start where each square's path starts, so
+        // the results are compared in a sorted order.
+        let faces = |g: &Node| -> Vec<String> {
+            let mut faces: Vec<String> = vectorcraft_effects::pathfinder_children(g, None)
+                .unwrap()
+                .iter()
+                .map(|n| {
+                    let b = n.geometric_bounds().unwrap_or_default();
+                    let round = |v: f64| (v * 1000.0).round() / 1000.0;
+                    let paints = (n.appearance.fill_paint().color(), n.appearance.stroke_paint().color());
+                    format!("{:?} {paints:?}", Rect::new(round(b.x0), round(b.y0), round(b.x1), round(b.y1)))
+                })
+                .collect();
+            faces.sort();
+            faces
+        };
+        let (opened, made) = (faces(&a[0]), faces(&own));
+        assert!(!made.is_empty(), "{command}");
+        assert_eq!(opened, made, "{command}");
+    }
+}
+
 #[test]
 fn a_pathfinder_style_this_does_not_read_keeps_the_drawn_look() {
-    // Another command (Intersect, Trap), and a Precision other than the one read.
+    // Trap, and a Precision other than the one read.
     let other = pathfinder_styles(0, 0.5).replace("10 /Real (Precision)", "5 /Real (Precision)");
-    for styles in [pathfinder_styles(1, 0.5), pathfinder_styles(12, 0.5), other] {
+    let intersect = pathfinder_styles(1, 0.5).replace("10 /Real (Precision)", "5 /Real (Precision)");
+    for styles in [pathfinder_styles(12, 0.5), other, intersect] {
         let r = read_ok(&format!("{styles}{}", layer(&pathfinder_group())));
         let a = art(&r.doc);
         assert_eq!(a.len(), 1, "{a:#?}");
@@ -5523,6 +5966,30 @@ fn a_styled_object_keeps_the_transparency_written_on_its_look() {
     assert_eq!(a.len(), 1, "{a:#?}");
     assert_eq!(fill(&a[0]).color(), Some(Color::rgb(0.0, 0.0, 1.0)));
     assert_eq!((a[0].opacity, a[0].blend), (0.6, BlendMode::Multiply));
+    assert!(!a[0].knockout_shape);
+    let r = read_ok(&format!("{ART_STYLES}{}", layer(&art_.replace("1 0.6 0 2 0 Xy", "1 0.6 0 2 1 Xy"))));
+    assert!(art(&r.doc)[0].knockout_shape, "written on the look");
+}
+
+/// The knockout shape flag written on a text object's look goes to the object, or, where the look
+/// draws more than the type, opaque or not, to the group that holds the look and the object.
+#[test]
+fn a_text_objects_look_gives_it_the_knockout_shape() {
+    let look = "0 Ae\nu\n/AI11Text :\n1 /FreeUndo ,\n0 /FrameIndex ,\n0 /StoryIndex ,\n;\nU\n1 0.2 0 1 1 Xy\n0 0 Xd\n6 () XW\n";
+    let own = "%_/AI11Text :\n%_0 /FreeUndo ,\n%_0 /FrameIndex ,\n%_0 /StoryIndex ,\n%_;\n";
+    let doc = read_ok(&layer(&format!("{look}{own}1 (Style) XW\n"))).doc;
+    let a = art(&doc);
+    assert_eq!(a.len(), 1, "{a:#?}");
+    assert_eq!((a[0].opacity, a[0].knockout_shape), (0.2, true));
+    let drawing = look.replace("U\n", &format!("{RED}{}f\nU\n", rect_path(0.0, 0.0, 10.0, 10.0)));
+    for (state, opacity) in [("1 0.2 0 1 1 Xy", 0.2), ("0 1 0 1 1 Xy", 1.0)] {
+        let drawn = drawing.replace("1 0.2 0 1 1 Xy", state);
+        let doc = read_ok(&layer(&format!("{drawn}{own}1 (Style) XW\n"))).doc;
+        let a = art(&doc);
+        assert_eq!(a.len(), 1, "{state}: {a:#?}");
+        assert_eq!((a[0].opacity, a[0].knockout_shape), (opacity, true), "{state}");
+        assert!(a[0].children().unwrap().iter().all(|n| !n.knockout_shape), "{state}: {a:#?}");
+    }
 }
 
 /// An envelope is written on `%_` lines as a group holding the mesh that shapes it, with its
@@ -5665,8 +6132,14 @@ pub(super) fn envelope_content() -> String {
 /// side, mapped as VectorCraft maps them, as a red path in art space.
 pub(super) fn drawn_content(kind: &vectorcraft_doc::live::EnvelopeKind) -> String {
     let rect = Rect::new(40.0, 20.0, 160.0, 80.0);
-    let map = vectorcraft_doc::live::envelope_mapper(kind, rect);
-    let corners = [Point::new(40.0, 20.0), Point::new(160.0, 20.0), Point::new(160.0, 80.0), Point::new(40.0, 80.0)];
+    drawn_box(kind, rect, rect)
+}
+
+/// What envelope `kind`, mapping from box `src`, draws of a red rectangle `rect`, as in
+/// [`drawn_content`].
+fn drawn_box(kind: &vectorcraft_doc::live::EnvelopeKind, src: Rect, rect: Rect) -> String {
+    let map = vectorcraft_doc::live::envelope_mapper(kind, src);
+    let corners = [Point::new(rect.x0, rect.y0), Point::new(rect.x1, rect.y0), Point::new(rect.x1, rect.y1), Point::new(rect.x0, rect.y1)];
     let mut s = RED.to_string();
     for (k, a) in corners.iter().enumerate() {
         let b = corners[(k + 1) % 4];
@@ -5872,6 +6345,7 @@ fn an_envelope_reads_its_options_and_fidelity() {
                 distort_appearance: false,
                 distort_linear_gradients: false,
                 distort_pattern_fills: false,
+                bounds_margin: [0.0; 4],
             },
         ),
         (
@@ -5883,6 +6357,7 @@ fn an_envelope_reads_its_options_and_fidelity() {
                 distort_appearance: true,
                 distort_linear_gradients: true,
                 distort_pattern_fills: true,
+                bounds_margin: [0.0; 4],
             },
         ),
         (
@@ -5894,6 +6369,7 @@ fn an_envelope_reads_its_options_and_fidelity() {
                 distort_appearance: false,
                 distort_linear_gradients: false,
                 distort_pattern_fills: true,
+                bounds_margin: [0.0; 4],
             },
         ),
     ] {
@@ -5906,6 +6382,125 @@ fn an_envelope_reads_its_options_and_fidelity() {
     }
 }
 
+/// The red rectangle 40 20 160 80 with a red stroke 10 pt wide, its art 130 × 70 with the stroke.
+fn stroked_content() -> String {
+    format!("{RED}0 1 1 0 1 0 0 XA\n10 w\n{}b\n", rect_path(40.0, 20.0, 160.0, 80.0))
+}
+
+/// A one-patch mesh over the stroked art of [`stroked_content`], and that patch as a flat grid.
+fn stroked_shape() -> (String, Vec<Point>) {
+    let at = |(i, j): (usize, usize)| (35.0 + i as f64 * 130.0, 15.0 + j as f64 * 70.0);
+    let third = |p: (usize, usize), q: (usize, usize)| {
+        let ((x, y), (u, v)) = (at(p), at(q));
+        (x + (u - x) / 3.0, y + (v - y) / 3.0)
+    };
+    (mesh_text(1, 1, &at, &third, None), vec![Point::new(35.0, 15.0), Point::new(165.0, 15.0), Point::new(35.0, 85.0), Point::new(165.0, 85.0)])
+}
+
+/// An envelope whose file saves the size of its art with the stroke maps from that box, in a
+/// synthetic mesh and top object. Their drawn art is the box mapped onto the shape, and the
+/// geometric box would leave the stroke 5 pt past it.
+#[test]
+fn an_envelope_saved_with_its_stroke_maps_from_the_stroked_box() {
+    use vectorcraft_doc::live::{EnvelopeKind, EnvelopeMap};
+    let (mesh, points) = stroked_shape();
+    let keys = format!("{ENVELOPE_KEYS}70 /Real (AIDeformArtHeightKey) ,\n130 /Real (AIDeformArtWidthKey) ,\n");
+    let outer = Rect::new(35.0, 15.0, 165.0, 85.0);
+    let flat = EnvelopeKind::Mesh { rows: 1, cols: 1, points, handles: vec![] };
+    let drawn = drawn_box(&flat, outer, outer);
+    for kind in [2, 3] {
+        let r = read_ok(&layer(&envelope_of(&mesh, &keys, &stroked_content(), kind, &drawn)));
+        let a = art(&r.doc);
+        assert_eq!(a.len(), 1, "{a:#?}");
+        assert!(r.warnings.is_empty(), "kind {kind}: {:?}", r.warnings);
+        let (.., options) = live_envelope(&a[0]);
+        assert_eq!(options.bounds_margin, [5.0_f32 / 60.0, 5.0 / 60.0, 5.0 / 120.0, 5.0 / 120.0]);
+        let src = EnvelopeMap::of(&a[0]).unwrap().src();
+        assert!(
+            (src.x0 - 35.0).abs() < 1e-3 && (src.y0 - 15.0).abs() < 1e-3 && (src.x1 - 165.0).abs() < 1e-3 && (src.y1 - 85.0).abs() < 1e-3,
+            "{src:?}"
+        );
+    }
+}
+
+/// With Distort Appearance off the stroke is drawn after the distortion: the envelope maps from the
+/// geometric box whatever size its file saves.
+#[test]
+fn an_envelope_without_distort_appearance_maps_from_the_geometric_box() {
+    use vectorcraft_doc::live::EnvelopeMap;
+    let keys = "65536 /Int (AIDeformOptionsKey) ,\n50 /Int (AIDeformFidelityKey) ,\n0 /Bool (AIDeformEditModeKey) ,\n70 /Real (AIDeformArtHeightKey) ,\n130 /Real (AIDeformArtWidthKey) ,\n";
+    let outer = Rect::new(35.0, 15.0, 165.0, 85.0);
+    let flat = vectorcraft_doc::live::EnvelopeKind::Mesh {
+        rows: 1,
+        cols: 1,
+        points: vec![Point::new(35.0, 15.0), Point::new(165.0, 15.0), Point::new(35.0, 85.0), Point::new(165.0, 85.0)],
+        handles: vec![],
+    };
+    let drawn = drawn_box(&flat, outer, outer);
+    let r = read_ok(&layer(&envelope_of(&straight_mesh(1, 1, (120.0, 60.0)), keys, &stroked_content(), 2, &drawn)));
+    let a = art(&r.doc);
+    assert_eq!(a.len(), 1, "{a:#?}");
+    assert!(!live_envelope(&a[0]).4.distort_appearance);
+    assert_eq!(live_envelope(&a[0]).4.bounds_margin, [0.0; 4]);
+    let src = EnvelopeMap::of(&a[0]).unwrap().src();
+    assert!((src.width() - 120.0).abs() < 1e-6 && (src.height() - 60.0).abs() < 1e-6, "{src:?}");
+    assert!(r.warnings.is_empty(), "{:?}", r.warnings);
+}
+
+/// An envelope maps from the geometric box when its file saves that box's size, saves no size,
+/// saves a size that isn't a number or saves a size far from both boxes; contents without a stroke
+/// have one box, and contents with no height have no margins.
+#[test]
+fn an_envelope_not_saved_with_its_stroke_maps_from_the_geometric_box() {
+    use vectorcraft_doc::live::{EnvelopeKind, EnvelopeMap};
+    let (mesh, points) = stroked_shape();
+    let inner = Rect::new(40.0, 20.0, 160.0, 80.0);
+    let flat = EnvelopeKind::Mesh { rows: 1, cols: 1, points, handles: vec![] };
+    // The stroked art mapped from the geometric box: it reaches past the mesh by the stroke's share.
+    let drawn = drawn_box(&flat, inner, Rect::new(35.0, 15.0, 165.0, 85.0));
+    let sizes = [
+        "60 /Real (AIDeformArtHeightKey) ,\n120 /Real (AIDeformArtWidthKey) ,\n",
+        "",
+        "(tall) /UnicodeString (AIDeformArtHeightKey) ,\n(wide) /UnicodeString (AIDeformArtWidthKey) ,\n",
+        "70 /Real (AIDeformArtHeightKey) ,\n",
+        "1000 /Real (AIDeformArtHeightKey) ,\n1000 /Real (AIDeformArtWidthKey) ,\n",
+        "71 /Real (AIDeformArtHeightKey) ,\n131 /Real (AIDeformArtWidthKey) ,\n",
+    ];
+    for size in sizes {
+        let keys = format!("{ENVELOPE_KEYS}{size}");
+        let r = read_ok(&layer(&envelope_of(&mesh, &keys, &stroked_content(), 2, &drawn)));
+        let a = art(&r.doc);
+        assert_eq!(a.len(), 1, "{size}: {a:#?}");
+        let (.., options) = live_envelope(&a[0]);
+        assert_eq!(options.bounds_margin, [0.0; 4], "{size}");
+        let src = EnvelopeMap::of(&a[0]).unwrap().src();
+        assert!((src.width() - 120.0).abs() < 1e-6 && (src.height() - 60.0).abs() < 1e-6, "{size}: {src:?}");
+    }
+    let keys = format!("{ENVELOPE_KEYS}60 /Real (AIDeformArtHeightKey) ,\n120 /Real (AIDeformArtWidthKey) ,\n");
+    let plain = drawn_content(&EnvelopeKind::Mesh {
+        rows: 1,
+        cols: 1,
+        points: vec![Point::new(40.0, 20.0), Point::new(160.0, 20.0), Point::new(40.0, 80.0), Point::new(160.0, 80.0)],
+        handles: vec![],
+    });
+    let r = read_ok(&layer(&envelope_of(&straight_mesh(1, 1, (120.0, 60.0)), &keys, &envelope_content(), 2, &plain)));
+    let a = art(&r.doc);
+    assert_eq!(live_envelope(&a[0]).4.bounds_margin, [0.0; 4]);
+    // A stroke so thin that the saved geometric size also lies close to the stroked box.
+    let thin = format!("{RED}0 1 1 0 1 0 0 XA\n0.2 w\n{}b\n", rect_path(40.0, 20.0, 160.0, 80.0));
+    let r = read_ok(&layer(&envelope_of(&straight_mesh(1, 1, (120.0, 60.0)), &keys, &thin, 2, &plain)));
+    assert_eq!(live_envelope(&art(&r.doc)[0]).4.bounds_margin, [0.0; 4]);
+    // A stroked straight line: 120 × 0 without its stroke, and 120 × 10 as saved.
+    let keys = format!("{ENVELOPE_KEYS}10 /Real (AIDeformArtHeightKey) ,\n120 /Real (AIDeformArtWidthKey) ,\n");
+    let line = format!("{RED}0 1 1 0 1 0 0 XA\n10 w\n40 20 m\n160 20 L\nS\n");
+    let r = read_ok(&layer(&envelope_of(&straight_mesh(1, 1, (120.0, 60.0)), &keys, &line, 2, &plain)));
+    for n in art(&r.doc) {
+        if let NodeKind::Envelope { options, .. } = &n.kind {
+            assert_eq!(options.bounds_margin, [0.0; 4]);
+        }
+    }
+}
+
 /// An envelope's contents keep their groups: a group of two rectangles stays that group.
 #[test]
 fn an_envelope_s_contents_keep_their_groups() {
@@ -6142,7 +6737,7 @@ fn vector_opacity_mask_keeps_its_art_and_does_not_paint_as_a_sibling() {
         assert_eq!(fill(&a[1]).color(), Some(Color::rgb(1.0, 0.0, 0.0)), "mask colour must not leak");
         let m = a[0].extras().mask.as_ref().unwrap();
         assert_eq!((m.clip, m.invert, m.disabled, m.linked), (true, invert, disabled, linked));
-        let mask_path = &m.art.children().unwrap()[0].children().unwrap()[0];
+        let mask_path = &m.art.children().unwrap()[0];
         assert!(matches!(mask_path.kind, NodeKind::Path { .. }));
         assert_eq!(mask_path.geometric_bounds(), Some(Rect::new(10.0, 40.0, 30.0, 80.0)));
         assert_ne!(mask_path.id, a[0].id);
@@ -6152,6 +6747,37 @@ fn vector_opacity_mask_keeps_its_art_and_does_not_paint_as_a_sibling() {
     }
 }
 
+/// An opacity mask's art of one shown object is that object; other art is read into a group.
+#[test]
+fn opacity_mask_art_of_one_object_is_that_object() {
+    let owner = format!("{RED}{}f\n", rect_path(10.0, 20.0, 50.0, 60.0));
+    let square = "%_1 g\n%_10 20 m\n%_10 60 L\n%_30 60 L\n%_30 20 L\n%_f\n";
+    let read_art = |ops: &str| {
+        let mask = format!("%_/ArtDictionary :\n%_/Mask :\n%_X=\n{ops}%_X+\n%_(Art) ,\n%_1 /Bool (Clipping) ,\n%_; (AI9_Mask) ,\n%_;\n");
+        let r = read_ok(&layer(&format!("{owner}{mask}")));
+        art(&r.doc)[0].extras().mask.as_ref().unwrap().art.clone()
+    };
+    assert!(matches!(read_art(square).kind, NodeKind::Path { .. }));
+    // A group is one object: it stays a group, holding its path.
+    let grouped = read_art(&format!("%_u\n{square}%_U\n"));
+    let NodeKind::Group { children, clip: false } = &grouped.kind else { panic!("{:?}", grouped.kind) };
+    assert!(matches!(children.as_slice(), [p] if matches!(p.kind, NodeKind::Path { .. })));
+    // Two objects are held in a group.
+    let two = read_art(&format!("{square}{square}"));
+    assert!(matches!(&two.kind, NodeKind::Group { children, clip: false } if children.len() == 2), "{:?}", two.kind);
+    // A clipping path alone keeps its group, which clips.
+    let clipped = read_art("%_10 20 m\n%_10 60 L\n%_30 60 L\n%_30 20 L\n%_h\n%_W\n%_n\n");
+    assert!(matches!(&clipped.kind, NodeKind::Group { children, clip: true } if children.len() == 1), "{:?}", clipped.kind);
+    // A hidden object stays in a group, which doesn't draw it.
+    let hidden = read_art(&format!("%_1 Xw\n{square}%_0 Xw\n"));
+    let NodeKind::Group { children, clip: false } = &hidden.kind else { panic!("{:?}", hidden.kind) };
+    assert!(matches!(children.as_slice(), [p] if !p.visible && matches!(p.kind, NodeKind::Path { .. })));
+    // So does a guide, which a group leaves out when guides aren't drawn.
+    let guide = read_art("%_10 20 m\n%_30 60 L\n%_(N) *\n");
+    let NodeKind::Group { children, clip: false } = &guide.kind else { panic!("{:?}", guide.kind) };
+    assert!(matches!(children.as_slice(), [p] if matches!(p.kind, NodeKind::Path { guide: true, .. })));
+}
+
 /// `9 () XW` also follows legacy compound member groups. The final gradient paints
 /// every member; the initial black paint is a placeholder, not a separate black object.
 #[test]
@@ -6415,6 +7041,26 @@ fn a_blend_comes_in_as_a_live_blend() {
     assert!(!s.warnings.iter().any(|w| w == super::blend::DRAWN), "{:?}", s.warnings);
 }
 
+/// A blend whose spine was never edited has no spine written, only its keys: its spine is the
+/// straight line between the keys' centres, in the record's order (here the left key, named `B`,
+/// first), and the blend comes in live.
+#[test]
+fn a_blend_with_no_spine_written_runs_straight_between_its_keys() {
+    let spine_part = format!("%_N\n{}", blend_part("S", None));
+    let body = blend_file("", [Some("B"), Some("A")], &blend_record(&['B', 'A']));
+    assert!(body.contains(&spine_part));
+    let (blend, warnings) = read_blend(&body.replace(&spine_part, ""));
+    let NodeKind::Blend { children, spec } = &blend.kind else { panic!("a live blend: {:?} {warnings:?}", blend.kind) };
+    assert!(!warnings.iter().any(|w| w == super::blend::DRAWN), "{warnings:?}");
+    assert_eq!(spec.spacing, vectorcraft_doc::live::BlendSpacing::Steps(3));
+    let spine = spec.spine.as_ref().and_then(|p| p.subpaths.first()).expect("a spine");
+    let points: Vec<(f64, f64)> = spine.anchors.iter().map(|a| (a.p.x, a.p.y)).collect();
+    assert_eq!(points.len(), 2, "{points:?}");
+    assert!((points[0].0 - 10.0).abs() < 0.01 && (points[1].0 - 110.0).abs() < 0.01, "from the left key to the right one: {points:?}");
+    assert_eq!(spec.key_anchors, vec![0, 1]);
+    assert_eq!(vectorcraft_doc::blend::blend_expand(children, spec).len(), 5);
+}
+
 /// The tags after a blend's drawn steps are the live blend's.
 #[test]
 fn a_live_blend_keeps_the_tags_of_its_drawn_steps() {
@@ -6608,6 +7254,33 @@ fn a_blend_it_cant_read_keeps_its_drawn_steps() {
     }
 }
 
+/// A blend's opacity defines the knockout shape when the state block after its record says so,
+/// live or as its drawn steps. An `Xy` that is the layer's leaves the blend's as it was.
+#[test]
+fn a_blend_keeps_its_knockout_shape() {
+    let straight = "%_10 50 m\n%_110 50 L\n";
+    let keys = [Some("A"), Some("B")];
+    let record = blend_record(&['A', 'B']);
+    let garbled = "(Adobe Path Blends) 1 0 16 XP\n%00112233445566778899AABBCCDDEEFF\n".to_string();
+    for (record, live) in [(&record, true), (&garbled, false)] {
+        let body = format!("{}0 0.6 0 1 1 Xy\n0 0 Xd\n6 () XW\n", blend_file(straight, keys, record));
+        let doc = read_ok(&layer(&body)).doc;
+        assert_eq!(matches!(art(&doc)[0].kind, NodeKind::Blend { .. }), live, "{:?}", art(&doc)[0].kind);
+        assert!(art(&doc)[0].knockout_shape, "live: {live}");
+    }
+    let blend = blend_file(straight, keys, &record);
+    // Written after its drawn steps, before the record.
+    let doc = read_ok(&layer(&blend.replace("\nU\n9 () XW\n0 Ae\n", "\nU\n0 0.6 0 1 1 Xy\n9 () XW\n0 Ae\n"))).doc;
+    assert!(matches!(art(&doc)[0].kind, NodeKind::Blend { .. }), "{:?}", art(&doc)[0].kind);
+    assert_eq!((art(&doc)[0].opacity, art(&doc)[0].knockout_shape), (0.6, true));
+    let doc = read_ok(&layer(&format!("{blend}0 0.6 0 1 1 Xy\n1 0.35 0 0 0 Xy\n0 0 Xd\n7 () XW\n"))).doc;
+    assert!(art(&doc)[0].knockout_shape, "the blend's own");
+    assert!(!doc.layers[0].knockout_shape, "the layer's own");
+    let doc = read_ok(&layer(&format!("{blend}1 0.35 0 0 1 Xy\n0 0 Xd\n7 () XW\n"))).doc;
+    assert!(!art(&doc)[0].knockout_shape, "the blend's own");
+    assert!(doc.layers[0].knockout_shape, "the layer's own");
+}
+
 /// A blend's transparency (here knockout on, as blends are written) is the state block after its
 /// record, as a group's follows its end: the live blend's, or its drawn steps' where they stay. It
 /// is the blend's own, not the next object's.
@@ -7088,7 +7761,7 @@ fn a_files_brushes_come_in_with_their_values_in_the_panels_order() {
     assert_eq!(s.art.geometric_bounds().map(|b| (b.width(), b.height())), Some((4.0, 4.0)), "the art of its section");
     let BrushKind::Art(a) = brush_named(&lib, "Ribbon") else { panic!("art") };
     assert!(a.art.geometric_bounds().is_some(), "the art of its section");
-    assert_eq!(a.colorization, vectorcraft_brush::Colorization::None, "the art keeps its colors");
+    assert_eq!(a.colorization, vectorcraft_brush::Colorization::Tints, "its code");
     let BrushKind::Bristle(b) = brush_named(&lib, "Mop") else { panic!("bristle") };
     let got = [b.stiffness, b.thickness, b.density, b.opacity, b.length, b.size];
     let want = [60.0, 40.0, 30.0, 80.0, 150.0, 2.0 * 72.0 / 25.4];
@@ -7111,13 +7784,13 @@ fn a_pattern_brushs_five_slots_are_kept() {
 }
 
 /// An Art brush in the older form (first number 1: one field fewer before its 8 numbers) is read
-/// as the newer one is, with the art of its section; a Scatter brush in that form isn't (its values
-/// aren't all there).
+/// with the art of its section, but not as plain (its numbers aren't known); a Scatter brush in
+/// that form isn't read (its values aren't all there).
 #[test]
 fn an_older_art_brush_comes_in_with_its_art() {
     const OLD_RIBBON: &str = "1 / Ribbon art/ / / / / 0 1 /  1 0 1 0 1 0 0 0";
     let d = brush::parse_tool_object(brush::Tool::Art, "Ribbon", OLD_RIBBON).unwrap();
-    assert!(matches!(d.kind, brush::DraftKind::Art { ref art, .. } if art == "Ribbon art"), "{d:?}");
+    assert!(matches!(d.kind, brush::DraftKind::Art { ref art, plain: false, .. } if art == "Ribbon art"), "{d:?}");
     assert_eq!(brush::parse_tool_object(brush::Tool::Scatter, "Spray", "1 /Dot art/ 0 1 /  1 0 1 0 1 0 0 0"), Err(brush::BrushError::Values));
     let objects = [plugin_object(ART_BRUSH, "Ribbon", OLD_RIBBON), plugin_object(ART_BRUSH, "Bare", "1 / / / / / / 0 1 /  1 0 1 0 1 0 0 0")].concat();
     let r = read_ok(&format!("{}{objects}{}", brush_art("Ribbon art", 4.0), layer("")));
@@ -7340,6 +8013,300 @@ fn a_brushed_path_the_brush_cant_draw_keeps_its_drawn_look() {
     }
 }
 
+/// The entries of an Art brush's filter for a path that stretches its art, at the brush's own width.
+const STRETCHED: [(&str, &str, &str); 12] = [
+    ("Proportional", "0", "Bool"),
+    ("Segmented", "0", "Bool"),
+    ("Scaling", "1", "Real"),
+    ("MinScaling", "1", "Real"),
+    ("MaxScaling", "1", "Real"),
+    ("ScaleYDependsOn", "0", "Int"),
+    ("Spacing", "0", "Real"),
+    ("UpsideDown", "0", "Int"),
+    ("Counterclockwise", "0", "Int"),
+    ("Adjustment", "1", "Int"),
+    ("FoldAdjustment", "1", "Bool"),
+    ("Colorization", "1", "Int"),
+];
+
+/// The style `Inked`: a stroke in red of weight `weight` with the Art brush `brush`, with the entries
+/// `entries` and `more` after them.
+fn art_style(brush: &str, weight: f64, entries: &[(&str, &str, &str)], more: &str) -> String {
+    let entries: String = entries.iter().map(|(key, value, kind)| format!("{value} /{kind} ({key}) ,\n")).collect();
+    format!(
+        "%AI9_BeginArtStyles\n/KnownStyle :\n(Inked) /Name ,\n/ActiveStyle :\n/CompoundFilter :\n(Chain Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
+         /CompoundFilter :\n(Stack Style Filter) 0 0 /Filter ,\n1 /Visible ,\n\
+         /BasicFilter :\n({ART_BRUSH}) 1 0 /Filter ,\n1 /Visible ,\n(Art Brush) /Title ,\n2 /FillOrStroke ,\n/Dictionary : /NotRecorded ,\n\
+         {entries}{more}/StrokeStyle : 0 R\n0 1 1 0 1 0 0 XA\n0 1 0 0 0 Xy\n0 J 0 j {weight} w 10 M []0 d\n0 XR\n1 0 Xd\n/Def ;\n (StrokeStyle) ,\n\
+         ({brush}) /UnicodeString (DisplayString) ,\n/GObjRef : ({brush}) ({ART_BRUSH}) /PluginObject ; (Brush) ,\n; /Dict ;\n /Part ,\n\
+         /BasicFilter :\n(Conduit Filter) 0 0 /Filter ,\n1 /Visible ,\n;\n /Part ,\n\
+         /BasicFilter :\n(Fill Style Filter) 0 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n\
+         /FillStyle : 0 O\n0 0 0 0 k\n0 0 Xd\n/Def ;\n (FillStyle) ,\n; /Dict ;\n /Part ,\n\
+         ;\n /Part ,\n;\n%AI9_EndArtStyles\n"
+    )
+}
+
+/// A brush's art named `name`: a wide block with a narrow one on top of it (art space: y up).
+fn lopsided_art(name: &str) -> String {
+    format!(
+        "%AI8_BeginBrushPattern\n({name})\n0 A\n0 g\n{}f\n{}f\n%AI8_EndBrushPattern\n",
+        rect_path(0.0, 0.0, 40.0, 4.0),
+        rect_path(0.0, 4.0, 10.0, 8.0)
+    )
+}
+
+/// A path drawn with an Art brush comes in as the path, its stroke in that brush at its weight (the
+/// weight scales the art across the path), not as its drawn look. The art runs along the path as
+/// the file draws it: the side of its section with y up goes to the right of the path's direction.
+#[test]
+fn a_path_with_an_art_brush_comes_in_brushed() {
+    let def = format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", RIBBON));
+    let more = "15 /Int (Adobe Effect Expand Before Version) ,\n";
+    let r = read_ok(&format!("{def}{}{}", art_style("Ribbon", 2.0, &STRETCHED, more), layer(&brushed_path())));
+    let a = art(&r.doc);
+    assert_eq!(a.len(), 1, "{a:#?}");
+    assert!(matches!(a[0].kind, NodeKind::Path { .. }), "the path, not its look: {a:#?}");
+    assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{:?}", r.warnings);
+    let st = a[0].appearance.stroke().unwrap();
+    assert_eq!((st.brush.as_deref(), st.width, st.paint.color()), (Some("Ribbon"), 2.0, Some(Color::rgb(1.0, 0.0, 0.0))));
+    let lib = vectorcraft_brush::library(&r.doc);
+    let vectorcraft_brush::BrushKind::Art(brush) = brush_named(&lib, "Ribbon") else { panic!("art") };
+    assert_eq!((brush.width, brush.colorization), (100.0, vectorcraft_brush::Colorization::Tints));
+    // Along a straight line, y down: the art is 8 tall at weight 1, its narrow block below the wide one.
+    let line = kurbo::BezPath::from_vec(vec![kurbo::PathEl::MoveTo(Point::new(0.0, 0.0)), kurbo::PathEl::LineTo(Point::new(100.0, 0.0))]);
+    let pieces = vectorcraft_brush::stroke_pieces(&r.doc, &lib[0], &line, st);
+    let b = pieces.iter().filter_map(|n| n.geometric_bounds()).reduce(|a, b| a.union(b)).unwrap();
+    assert!((b.height() - 16.0).abs() < 1e-3 && (b.width() - 100.0).abs() < 1e-3, "weight 2 doubles the art across, and it stretches along: {b:?}");
+    assert!((b.y0 + 8.0).abs() < 1e-3, "{b:?}");
+    let filled = |x: f64, y: f64| {
+        pieces.iter().any(|n| {
+            let mut hit = false;
+            n.walk(&mut |c| hit |= c.path_data().is_some_and(|p| kurbo::Shape::winding(&p.to_bezpath(), Point::new(x, y)) != 0));
+            hit
+        })
+    };
+    assert!(filled(50.0, -4.0), "the wide block is above the line");
+    assert!(filled(10.0, 4.0) && !filled(50.0, 4.0), "the narrow block is below it");
+}
+
+/// A fill under the brush stays on the path.
+#[test]
+fn a_filled_path_with_an_art_brush_comes_in_brushed() {
+    let def = format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", RIBBON));
+    let style = art_style("Ribbon", 1.0, &STRETCHED, "").replace("0 0 0 0 k\n0 0 Xd", "0 0 1 0 k\n0 1 Xd");
+    let r = read_ok(&format!("{def}{style}{}", layer(&brushed_path())));
+    let a = art(&r.doc);
+    assert!(matches!(a[0].kind, NodeKind::Path { .. }), "{a:#?}");
+    assert_eq!(a[0].appearance.items.len(), 2, "{:?}", a[0].appearance);
+    assert_eq!(a[0].appearance.stroke().and_then(|s| s.brush.as_deref()), Some("Ribbon"));
+}
+
+/// A compound path with an Art brush comes in as the compound path, its stroke in that brush.
+#[test]
+fn a_compound_path_with_an_art_brush_comes_in_brushed() {
+    let def = format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", RIBBON));
+    let object = format!(
+        "0 Ae\nu\n{RED}{}f\nU\n0 0 Xd\n6 () XW\n%_*u\n%_20 20 m\n%_100 20 L\n%_n\n%_20 60 m\n%_100 60 L\n%_n\n%_*U\n1 (Inked) XW\n",
+        rect_path(20.0, 18.0, 100.0, 62.0)
+    );
+    let r = read_ok(&format!("{def}{}{}", art_style("Ribbon", 1.0, &STRETCHED, ""), layer(&object)));
+    let a = art(&r.doc);
+    assert_eq!(a.len(), 1, "{a:#?}");
+    assert!(matches!(a[0].kind, NodeKind::Compound { .. }), "{a:#?}");
+    assert_eq!(a[0].appearance.stroke().and_then(|s| s.brush.as_deref()), Some("Ribbon"));
+}
+
+/// An Art brush draws only art of paths, compound paths and groups in solid fills: not an image, a
+/// mask, an effect, a gradient or pattern, a stroke, or art with no length along the path.
+#[test]
+fn an_art_brush_bends_only_paths_in_solid_fills() {
+    use vectorcraft_color::gradient::{Gradient, GradientPaint, GradientStop};
+    use vectorcraft_doc::{Effect, ImageObject, NodeId, OpacityMask};
+    let def = format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", RIBBON));
+    let r = read_ok(&format!("{def}{}", layer(&brushed_path())));
+    let lib = vectorcraft_brush::library(&r.doc);
+    let vectorcraft_brush::BrushKind::Art(brush) = brush_named(&lib, "Ribbon") else { panic!("art") };
+    let plain = &brush.art;
+    assert!(brush::art_bends(plain), "{plain:#?}");
+    let with = |change: &dyn Fn(&mut Node)| {
+        let mut n = plain.clone();
+        change(&mut n);
+        n
+    };
+    let image = ImageObject { key: "k".into(), width: 4, height: 4, xf: Affine::IDENTITY, link: None, placement: Default::default(), pixels: None };
+    let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
+    let gradient = GradientPaint::new(Gradient::new(GradientKind::Linear, stops));
+    let cases = [
+        ("an image", Node::new(NodeId(90), NodeKind::Image(Box::new(image)))),
+        ("a mask", with(&|n| n.extras_mut().mask = Some(Box::new(OpacityMask::new(plain.clone(), true))))),
+        ("an effect", with(&|n| n.appearance.effects.push(Effect { id: "stylize.dropShadow".into(), params: Default::default(), visible: true }))),
+        (
+            "an effect on a fill",
+            with(&|n| {
+                n.appearance.set_fill(Paint::solid(Color::BLACK));
+                if let Some(AppearanceItem::Fill(f)) = n.appearance.items.first_mut() {
+                    f.effects.push(Effect { id: "stylize.dropShadow".into(), params: Default::default(), visible: true });
+                }
+            }),
+        ),
+        ("a gradient", with(&|n| n.appearance.set_fill(Paint::Gradient(Box::new(gradient.clone()))))),
+        ("a stroke", with(&|n| n.appearance.set_stroke(Paint::solid(Color::BLACK)))),
+    ];
+    let wrong: Vec<&str> = cases.iter().filter(|(_, art)| brush::art_bends(art)).map(|(why, _)| *why).collect();
+    assert!(wrong.is_empty(), "{wrong:?}");
+}
+
+/// An Art brushed path keeps its drawn look when the brush wouldn't draw it the way the file does:
+/// its settings aren't those of art that stretches along the path at the brush's own width and
+/// color, the brush's own aren't, its art isn't read, or the brush isn't one the panel keeps.
+#[test]
+fn an_art_brushed_path_the_brush_cant_draw_keeps_its_drawn_look() {
+    let good = format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", RIBBON));
+    let with = |key: &str, value: &str| -> Vec<(String, String, String)> {
+        STRETCHED.iter().map(|(k, v, t)| ((*k).to_string(), if *k == key { value.to_string() } else { (*v).to_string() }, (*t).to_string())).collect()
+    };
+    let style_with = |key: &str, value: &str| {
+        let owned = with(key, value);
+        let entries: Vec<(&str, &str, &str)> = owned.iter().map(|(k, v, t)| (k.as_str(), v.as_str(), t.as_str())).collect();
+        art_style("Ribbon", 1.0, &entries, "")
+    };
+    let plain_style = art_style("Ribbon", 1.0, &STRETCHED, "");
+    let flipped = "2 / Ribbon art/ / / / / 0 0/ 5 0 0 0 /  1 1 1 0 1 1 0 0 1 1 0 0 0 0 1";
+    let wide = "2 / Ribbon art/ / / / / 0 0/ 5 0 0 0 /  1 1 2 0 1 0 0 0 2 2 0 0 0 0 1";
+    let own_colors = "2 / Ribbon art/ / / / / 0 0/ 5 0 0 0 /  1 0 1 0 1 0 0 0 1 1 0 0 0 0 1";
+    let dots = "%AI3_BeginPattern: (Dots)\n(Dots) 0 0 4 4\n%_0 0 0 1 k\n%_1 1 m\n%_3 1 L\n%_3 3 L\n%_1 3 L\n%_f\nE\n%AI3_EndPattern\n";
+    let patterned = format!(
+        "%AI8_BeginBrushPattern\n(Ribbon art)\n0 A\n(Dots) 0 0 1 1 0 0 0 0 0 [1 0 0 1 0 0] p\n{}f\n%AI8_EndBrushPattern\n",
+        rect_path(0.0, 0.0, 4.0, 4.0)
+    );
+    let malformed: Vec<(&str, &str, &str)> = STRETCHED.iter().map(|&(k, v, t)| if k == "Segmented" { (k, "1", "Real") } else { (k, v, t) }).collect();
+    let cases = [
+        ("a switch written as another kind", good.clone(), art_style("Ribbon", 1.0, &malformed, "")),
+        ("art in a pattern", format!("{dots}{patterned}{}", plugin_object(ART_BRUSH, "Ribbon", RIBBON)), plain_style.clone()),
+        ("tints of a swatch's ink", good.clone(), plain_style.replace("0 1 1 0 1 0 0 XA", "0 0 0 0 1 0.5 0 (Brand orange) 0 1 XK")),
+        (
+            "art with no length",
+            format!(
+                "%AI8_BeginBrushPattern\n(Ribbon art)\n0 A\n0 g\n0 0 m\n0 40 L\nf\n%AI8_EndBrushPattern\n{}",
+                plugin_object(ART_BRUSH, "Ribbon", RIBBON)
+            ),
+            plain_style.clone(),
+        ),
+        (
+            "art with a stroke",
+            format!(
+                "%AI8_BeginBrushPattern\n(Ribbon art)\n0 A\n0 G\n2 w\n{}S\n%AI8_EndBrushPattern\n{}",
+                rect_path(0.0, 0.0, 40.0, 8.0),
+                plugin_object(ART_BRUSH, "Ribbon", RIBBON)
+            ),
+            plain_style.clone(),
+        ),
+        (
+            "a width other than the brush's 100%",
+            format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", wide)),
+            art_style(
+                "Ribbon",
+                1.0,
+                &STRETCHED.map(|e| if matches!(e.0, "Scaling" | "MinScaling" | "MaxScaling") { (e.0, "2", e.2) } else { e }),
+                "",
+            ),
+        ),
+        (
+            "a brush that keeps its art's colors",
+            format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", own_colors)),
+            art_style("Ribbon", 1.0, &STRETCHED.map(|e| if e.0 == "Colorization" { (e.0, "0", e.2) } else { e }), ""),
+        ),
+        ("an entry that isn't read", good.clone(), art_style("Ribbon", 1.0, &STRETCHED, "1 /Int (SomeOtherSetting) ,\n")),
+        (
+            "an effect on the path",
+            good.clone(),
+            plain_style.replace(
+                ";\n /Part ,\n;\n%AI9_EndArtStyles",
+                ";\n /Part ,\n/BasicFilter :\n(Adobe Drop Shadow) 1 0 /Filter ,\n1 /Visible ,\n/Dictionary : /NotRecorded ,\n2 /Int (blnd) ,\n0.75 /Real (opac) ,\n3 /Real (horz) ,\n4 /Real (vert) ,\n5 /Real (blur) ,\n1 /Int (csrc) ,\n50 /Real (dark) ,\n; /Dict ;\n /Part ,\n;\n%AI9_EndArtStyles",
+            ),
+        ),
+        ("proportional", good.clone(), style_with("Proportional", "1")),
+        ("between guides", good.clone(), style_with("Segmented", "1")),
+        ("its own width", good.clone(), style_with("Scaling", "2")),
+        ("a width that varies", good.clone(), style_with("MaxScaling", "2")),
+        ("a width on the pen", good.clone(), style_with("ScaleYDependsOn", "2")),
+        ("spacing", good.clone(), style_with("Spacing", "1")),
+        ("flipped", good.clone(), style_with("UpsideDown", "1")),
+        ("flipped the other way", good.clone(), style_with("Counterclockwise", "1")),
+        ("another adjustment", good.clone(), style_with("Adjustment", "2")),
+        ("no fold adjustment", good.clone(), style_with("FoldAdjustment", "0")),
+        ("its own colorization", good.clone(), style_with("Colorization", "0")),
+        ("tints and shades", good.clone(), style_with("Colorization", "2")),
+        ("hue shift", good.clone(), style_with("Colorization", "3")),
+        ("start of a guide", good.clone(), art_style("Ribbon", 1.0, &STRETCHED, "5 /Real (StartSegmentLength) ,\n")),
+        ("variable width", good.clone(), art_style("Ribbon", 1.0, &STRETCHED, "2 /Int (BSWidthSource) ,\n")),
+        (
+            "width arrays",
+            good.clone(),
+            art_style(
+                "Ribbon",
+                1.0,
+                &STRETCHED,
+                "/Array :\n0 /Real ,\n1 /Real ,\n; (BSVariableWidthTValuesArray) ,\n/Array :\n1 /Real ,\n2 /Real ,\n; (BSCenteredWidthsArray) ,\n",
+            ),
+        ),
+        ("a brush that flips", format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", flipped)), plain_style.clone()),
+        ("another brush width", format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", wide)), plain_style.clone()),
+        ("art not read", plugin_object(ART_BRUSH, "Ribbon", RIBBON), plain_style.clone()),
+        ("no such brush", good.clone(), art_style("Other", 1.0, &STRETCHED, "")),
+    ];
+    let mut wrong = vec![];
+    for (why, def, style) in cases {
+        let r = read_ok(&format!("{def}{style}{}", layer(&brushed_path())));
+        let lib = vectorcraft_brush::library(&r.doc);
+        let art_read = why == "art not read" || why == "no such brush" || lib.iter().any(|b| b.name == "Ribbon");
+        if !matches!(art(&r.doc)[0].kind, NodeKind::Group { .. }) || !r.warnings.iter().any(|w| w.contains("drawn look")) || !art_read {
+            wrong.push(why);
+        }
+    }
+    assert!(wrong.is_empty(), "these came in live, or their art wasn't read: {wrong:?}");
+}
+
+/// The name a stroke's brush has is the panel's, for a Calligraphic brush too: a left-out brush of
+/// that name doesn't hide the one kept.
+#[test]
+fn a_calligraphic_brushed_stroke_takes_the_brush_the_panel_keeps_under_its_name() {
+    let style = brushed_style("Six D", 1.0, SIX_D_SETTINGS, [2, 5, 6], 0);
+    let path = layer(&brushed_path());
+    let r = read_ok(&format!("{}{}{style}{path}", plugin_object(PATTERN_BRUSH, "Six D", FENCE), plugin_object(CALLIGRAPHIC, "Six D", SIX_D)));
+    assert!(matches!(art(&r.doc)[0].kind, NodeKind::Path { .. }), "the pattern brush is left out");
+}
+
+/// The name a stroke's brush has is the panel's: a left-out brush of that name doesn't hide the one
+/// kept, and a kept one of another kind isn't drawn as the name's Art brush.
+#[test]
+fn an_art_brushed_stroke_takes_the_brush_the_panel_keeps_under_its_name() {
+    let style = art_style("Ribbon", 1.0, &STRETCHED, "");
+    let path = layer(&brushed_path());
+    let art_def = format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", RIBBON));
+    let r = read_ok(&format!("{}{art_def}{style}{path}", plugin_object(PATTERN_BRUSH, "Ribbon", FENCE)));
+    assert!(matches!(art(&r.doc)[0].kind, NodeKind::Path { .. }), "the pattern brush is left out");
+    let r = read_ok(&format!("{}{art_def}{style}{path}", plugin_object(CALLIGRAPHIC, "Ribbon", NIB)));
+    assert!(matches!(art(&r.doc)[0].kind, NodeKind::Group { .. }), "the panel's Ribbon is the Calligraphic brush");
+}
+
+/// Type drawn with an Art brush keeps its drawn look under the type, which takes no style.
+#[test]
+fn type_with_an_art_brush_keeps_its_drawn_look() {
+    let own: String = "/AI11Text :\n0 /FreeUndo ,\n0 /FrameIndex ,\n7 /StoryIndex ,\n;\n".lines().map(|l| format!("%_{l}\n")).collect();
+    let object = format!(
+        "0 Ae\nu\n/AI11Text :\n1 /FreeUndo ,\n0 /FrameIndex ,\n0 /StoryIndex ,\n;\n{RED}{}f\nU\n0 0 Xd\n6 () XW\n{own}1 (Inked) XW\n",
+        rect_path(20.0, 18.0, 100.0, 62.0)
+    );
+    let def = format!("{}{}", lopsided_art("Ribbon art"), plugin_object(ART_BRUSH, "Ribbon", RIBBON));
+    let r = read_ok(&format!("{def}{}{}", art_style("Ribbon", 1.0, &STRETCHED, ""), layer(&object)));
+    let a = art(&r.doc);
+    assert_eq!((a.len(), a[0].children().map(Vec::len), slot_of(a[1].name.as_deref())), (2, Some(1), Some(Some(7))), "the look and the type, {a:#?}");
+    let mut brushed = 0;
+    r.doc.walk(|n| brushed += usize::from(n.appearance.stroke().is_some_and(|s| s.brush.is_some())));
+    assert_eq!(brushed, 0, "{:?}", r.warnings);
+}
+
 use read::{GRAPH_PLAIN, GRAPH_UNENDED};
 
 /// Editing data in the legacy format (version 7 specification, chapter 2): `%AI5_FileFormat 2.0`,
diff --git a/crates/eps/src/import/ate.rs b/crates/eps/src/import/ate.rs
index ac5f38d6b..1e2347249 100644
--- a/crates/eps/src/import/ate.rs
+++ b/crates/eps/src/import/ate.rs
@@ -17,8 +17,8 @@
 //! offset from it. A right-to-left paragraph (key `33` of its attributes) swaps the two: its
 //! "left"-aligned lines end at the anchor and its "right"-aligned ones start there. The frame of the
 //! story gives a matrix that carries that layout onto the canvas of the app, which is 16383 points a
-//! side; the canvas's centre, 8191.5, is the centre of the file's `%AI3_TemplateBox`. See
-//! [`Story::place`].
+//! side; the canvas's centre, 8191.5, is the centre of the file's `%AI3_TemplateBox`. A story without
+//! a layout has its point type's anchor at its frame's point. See [`Story::place`].
 
 use std::collections::BTreeMap;
 
@@ -28,13 +28,13 @@ use vectorcraft_doc::{CharStyle, Justify, Node, NodeId, NodeKind, ParaDirection,
 use vectorcraft_geom::{Affine, PathData, Point, Rect};
 
 /// Longest story read (bytes).
-const MAX_STORY: usize = 1 << 20;
+pub(crate) const MAX_STORY: usize = 1 << 20;
 /// Biggest text document read (bytes, decoded).
-const MAX_BYTES: usize = 64 << 20;
+pub(crate) const MAX_BYTES: usize = 64 << 20;
 /// Deepest nesting read.
 const MAX_DEPTH: usize = 64;
 /// Most values read.
-const MAX_VALUES: usize = 4_000_000;
+pub(crate) const MAX_VALUES: usize = 4_000_000;
 /// The centre of the app's canvas, in the units of its text document.
 pub(super) const CANVAS_CENTRE: f64 = 8191.5;
 
@@ -241,8 +241,8 @@ const MAX_SHEETS: usize = 4096;
 const MAX_SHEETS_BASED_ON: usize = 16;
 
 /// Most frames read of one story, and most path segments of a frame.
-const MAX_FRAMES: usize = 4096;
-const MAX_SEGMENTS: usize = 1 << 16;
+pub(crate) const MAX_FRAMES: usize = 4096;
+pub(crate) const MAX_SEGMENTS: usize = 1 << 16;
 
 /// Where a frame puts its story's text.
 #[derive(Debug, Clone, PartialEq)]
@@ -513,8 +513,17 @@ impl Texts {
         if indices.iter().any(|n| self.frame_vertical(*n) != vertical) {
             return None;
         }
-        // The first frame's layout, when the file keeps one: where its lines start.
-        let (mut anchor, mut lines, mut path_spacing) = ((0.0, 0.0), vec![], 0.0);
+        // The first frame's layout, when the file keeps one: where its lines start. Without one, the
+        // anchor of point type is its frame's point (key 0, where the layout's anchor is too).
+        let point = indices.first().and_then(|n| self.frames.get(*n)).and_then(|f| f.get("0")).and_then(|f| f.get("0")).and_then(Val::nums);
+        let (mut anchor, mut lines, mut path_spacing) = (
+            match point.as_deref() {
+                Some([x, y]) if matches!(frames.first(), Some(FrameKind::Point(_))) => (*x, *y),
+                _ => (0.0, 0.0),
+            },
+            vec![],
+            0.0,
+        );
         if let Some(f) = view.get("2").and_then(|l| find_node(l, "F")) {
             // Vertical type on a path turns its glyphs across the path: their matrices don't give
             // the spacing.
@@ -854,8 +863,11 @@ impl Story {
         let text: String = if threaded {
             String::new()
         } else {
+            // The `\r` that ends the story's last paragraph; one before it ends a paragraph, and the
+            // empty paragraph after it is the story's last.
             self.text
-                .trim_end_matches('\r')
+                .strip_suffix('\r')
+                .unwrap_or(&self.text)
                 .chars()
                 .map(|c| match c {
                     '\r' => '\n',
diff --git a/crates/eps/src/import/data/ops.rs b/crates/eps/src/import/data/ops.rs
index baca4d0ed..4397a0e23 100644
--- a/crates/eps/src/import/data/ops.rs
+++ b/crates/eps/src/import/data/ops.rs
@@ -270,7 +270,9 @@ impl Interp<'_> {
         let name = self.pop()?.text().ok_or(PsError::Ps("typecheck", "filter".into()))?;
         let sub = if &*name == "SubFileDecode" {
             let eod = self.pop_str()?.to_vec();
-            let count = self.pop_count()?;
+            // The count bounds what the filter reads, not what it allocates: a stream of several
+            // megabytes read through `currentfile N () /SubFileDecode filter` gives its length.
+            let count = usize::try_from(self.pop_int()?).map_err(|_| PsError::Ps("rangecheck", "a count".into()))?;
             (count, eod)
         } else {
             (0, vec![])
@@ -399,6 +401,30 @@ impl Interp<'_> {
         Ok(())
     }
 
+    /// Skip the data an image left out (too large to read) would read from the program's own
+    /// file, so the program doesn't go on to read that data as PostScript. The filters that find
+    /// their own end without decompressing (`ASCIIHexDecode`, `ASCII85Decode`, `SubFileDecode`)
+    /// read the file up to it, the way the image reading all its data would leave it; the
+    /// filters over them, which would only decode what those pass, aren't run. When the first
+    /// filter decompresses, it is run alone, and a failure (data too large to hold) leaves the
+    /// data where it was, as before.
+    fn skip_data(&mut self, src: &Source) {
+        let Source::File(f) = src else { return };
+        let (chain, from) = match &*f.borrow() {
+            Stream::Pending { chain, from } => (chain.clone(), from.clone()),
+            _ => return,
+        };
+        let delimited = chain.iter().take_while(|c| matches!(&*c.name, "ASCIIHexDecode" | "ASCII85Decode" | "SubFileDecode")).count();
+        let head = chain.get(..delimited.max(1)).unwrap_or_default().to_vec();
+        *f.borrow_mut() = Stream::Pending { chain: head, from: from.clone() };
+        // A failure leaves the file as it was; the import goes on without the image either way.
+        if self.materialize(f).is_err() {
+            *f.borrow_mut() = Stream::Pending { chain, from };
+            return;
+        }
+        *f.borrow_mut() = Stream::Buf { data: vec![], pos: 0, rgb: None };
+    }
+
     /// The bytes a data procedure gives, called until it gives an empty string or `n` bytes.
     fn gather(&mut self, p: &Obj, n: usize) -> Res<Vec<u8>> {
         Ok(self.read_sources(&[Source::Proc(p.clone())], n, n)?.pop().unwrap_or_default())
@@ -518,6 +544,9 @@ impl Interp<'_> {
         let n = image.space.n();
         if image.w.saturating_mul(image.h) > MAX_PIXELS || stencil.w.saturating_mul(stencil.h) > MAX_PIXELS {
             self.out.warn(TOO_LARGE);
+            for src in image.sources.iter().chain(&stencil.sources) {
+                self.skip_data(src);
+            }
             return Ok(None);
         }
         if interleave != 3.0 {
@@ -624,6 +653,9 @@ impl Interp<'_> {
         }
         if s.w.saturating_mul(s.h) > MAX_PIXELS {
             self.out.warn(TOO_LARGE);
+            for src in &s.sources {
+                self.skip_data(src);
+            }
             return Ok(None);
         }
         self.alloc(s.w * s.h * 4)?;
diff --git a/crates/eps/src/import/interp.rs b/crates/eps/src/import/interp.rs
index 75f7c7d13..fe0c63919 100644
--- a/crates/eps/src/import/interp.rs
+++ b/crates/eps/src/import/interp.rs
@@ -5,13 +5,14 @@
 //! recursing program ends with [`PsError::Limit`] instead of hanging.
 
 use std::cell::RefCell;
+use std::collections::HashSet;
 use std::rc::Rc;
 
 use vectorcraft_geom::Affine;
 
 use super::data::Stream;
 use super::graphics::{GState, Out};
-use super::lex::{IMMEDIATE, Lexer};
+use super::lex::{IMMEDIATE, Lexer, number};
 use super::obj::{Dict, DictRef, Key, Obj, Op, PsError, Res, Shared, ps_err};
 
 /// Most operations one file may run.
@@ -26,6 +27,8 @@ pub(crate) const MAX_ALLOC: usize = 1 << 22;
 const MAX_DICTS: usize = 1000;
 /// Most saved graphics states.
 pub(crate) const MAX_GSAVE: usize = 1000;
+/// Most read-only procedures remembered (see `Interp::readonly`); each keeps its procedure.
+const MAX_READONLY: usize = 1 << 16;
 /// Most memory (bytes) a program may ask for in all: strings, arrays, decoded data, images,
 /// saved paths.
 const MAX_MEMORY: usize = 1 << 30;
@@ -71,6 +74,11 @@ pub(crate) struct Interp<'a> {
     /// The program is in the legacy Illustrator format: its group operators `u` … `U` (at the top
     /// level, whatever its prolog defines them as) are groups (see the module docs of `import`).
     pub illustrator: bool,
+    /// Procedures that are read-only: those `bind` went into inside another procedure, and those
+    /// given to `readonly`, `executeonly` or `noaccess`. `bind` leaves them alone (PLRM 3rd ed.,
+    /// `bind` in chapter 8), so a procedure bound when it was defined keeps the names it didn't
+    /// bind then, whatever operators they name by the time a later procedure that holds it is bound.
+    readonly: HashSet<Shared<Obj>>,
 }
 
 /// Where a PostScript error was raised: the operator that raised it (none for an unknown name)
@@ -179,6 +187,7 @@ impl<'a> Interp<'a> {
             saved: vec![],
             out,
             illustrator: false,
+            readonly: HashSet::new(),
         }
     }
 
@@ -766,7 +775,7 @@ impl<'a> Interp<'a> {
             },
             Cvi => {
                 let v = match self.pop()? {
-                    Obj::Str(s) => String::from_utf8_lossy(&s.borrow()).trim().parse::<f64>().map_err(|_| PsError::Ps("typecheck", String::new()))?,
+                    Obj::Str(s) => string_number(&s.borrow())?,
                     o => o.as_num().ok_or(PsError::Ps("typecheck", String::new()))?,
                 };
                 if !(v.is_finite() && v.abs() < 9e15) {
@@ -776,7 +785,7 @@ impl<'a> Interp<'a> {
             }
             Cvr => {
                 let v = match self.pop()? {
-                    Obj::Str(s) => String::from_utf8_lossy(&s.borrow()).trim().parse::<f64>().map_err(|_| PsError::Ps("typecheck", String::new()))?,
+                    Obj::Str(s) => string_number(&s.borrow())?,
                     o => o.as_num().ok_or(PsError::Ps("typecheck", String::new()))?,
                 };
                 self.push_num(v)?;
@@ -928,10 +937,9 @@ impl<'a> Interp<'a> {
                 }
                 self.push_interval(Obj::Str(s), 0, text.len())?;
             }
-            ReadOnly | ExecuteOnly | NoAccess | SetPacking | SetGlobal | SetObjectFormat => {
-                if matches!(op, SetPacking | SetGlobal | SetObjectFormat) {
-                    self.pop()?;
-                }
+            ReadOnly | ExecuteOnly | NoAccess => self.restrict_access(),
+            SetPacking | SetGlobal | SetObjectFormat => {
+                self.pop()?;
             }
             Rcheck | Wcheck => {
                 self.pop()?;
@@ -1327,7 +1335,7 @@ impl<'a> Interp<'a> {
     /// Replace the names in a procedure that stand for operators by the operators, down through
     /// nested procedures.
     fn bind(&mut self, items: &Shared<Obj>, depth: u32) -> Res {
-        if depth > 64 {
+        if depth > 64 || self.readonly.contains(items) {
             return Ok(());
         }
         for i in 0..items.len() {
@@ -1340,13 +1348,34 @@ impl<'a> Interp<'a> {
                         items.write(i, &[o]);
                     }
                 }
-                Some(Obj::Array { items: inner, exec: true }) if !inner.shares(items) => self.bind(&inner, depth + 1)?,
+                Some(Obj::Array { items: inner, exec: true }) if !inner.shares(items) => {
+                    self.bind(&inner, depth + 1)?;
+                    // `bind` makes each procedure it goes into read-only.
+                    self.mark_readonly(inner);
+                }
                 _ => {}
             }
         }
         Ok(())
     }
 
+    /// `readonly`, `executeonly`, `noaccess`: the object stays on the stack; a procedure is
+    /// recorded as read-only, the only access the reader keeps (for `bind`).
+    fn restrict_access(&mut self) {
+        if let Some(Obj::Array { items, exec: true }) = self.stack.last() {
+            let items = items.clone();
+            self.mark_readonly(items);
+        }
+    }
+
+    /// Record procedure `items` as read-only, for [`Self::bind`]. Past [`MAX_READONLY`] of them
+    /// the rest stay writable: a later `bind` may then bind their names, as it did before.
+    fn mark_readonly(&mut self, items: Shared<Obj>) {
+        if self.readonly.len() < MAX_READONLY {
+            self.readonly.insert(items);
+        }
+    }
+
     /// Put `v` under `k` in `d` (`None`: remove it), within [`MAX_ALLOC`] entries; while a `save`
     /// is open the old value is kept for `restore`.
     fn insert(&mut self, d: &DictRef, k: Key, v: Option<Obj>) -> Res {
@@ -1442,6 +1471,17 @@ impl<'a> Interp<'a> {
 }
 
 /// An array or string index.
+/// The number a string holds by the PostScript syntax (`cvi`, `cvr`: PLRM 3rd ed., chapter 8),
+/// radix numbers such as `16#20` included.
+fn string_number(s: &[u8]) -> Res<f64> {
+    let text = String::from_utf8_lossy(s);
+    match number(text.trim_matches(|c: char| c.is_ascii_whitespace() || c == '\0')) {
+        Some(Obj::Int(i)) => Ok(i as f64),
+        Some(Obj::Real(r)) => Ok(r),
+        _ => ps_err("typecheck", ""),
+    }
+}
+
 fn index(k: &Obj) -> Res<usize> {
     match *k {
         Obj::Int(i) if i >= 0 => Ok(i as usize),
diff --git a/crates/eps/src/import/lex.rs b/crates/eps/src/import/lex.rs
index 57d3e73e2..e01b90c23 100644
--- a/crates/eps/src/import/lex.rs
+++ b/crates/eps/src/import/lex.rs
@@ -276,7 +276,7 @@ pub(crate) fn hex_decode(body: &[u8]) -> Option<Vec<u8>> {
 }
 
 /// A number token (`12`, `-3.5`, `.5`, `1e-3`, `16#ff`), or `None`.
-fn number(w: &str) -> Option<Obj> {
+pub(crate) fn number(w: &str) -> Option<Obj> {
     let first = w.bytes().next()?;
     if !(first.is_ascii_digit() || matches!(first, b'+' | b'-' | b'.')) {
         return None;
diff --git a/crates/eps/src/import/native.rs b/crates/eps/src/import/native.rs
index ed1b97616..f78bcc8a8 100644
--- a/crates/eps/src/import/native.rs
+++ b/crates/eps/src/import/native.rs
@@ -56,6 +56,7 @@ use compare::{
 };
 pub use layers::{AiLayers, ai_alone, ai_alone_on_page, ai_layers_alone, layered_ai, layered_ai_from};
 pub(super) use layers::{layered, program_alone};
+pub(crate) use slots::MAX_TEXT;
 pub use slots::is_loss;
 #[cfg(test)]
 use slots::join_pieces;
diff --git a/crates/eps/src/import/native/slots.rs b/crates/eps/src/import/native/slots.rs
index 4924c167a..baff41dd8 100644
--- a/crates/eps/src/import/native/slots.rs
+++ b/crates/eps/src/import/native/slots.rs
@@ -43,7 +43,7 @@ pub(super) const MAX_SLOTS: usize = 5000;
 const MAX_PIECES: usize = 2000;
 
 /// Most bytes of text in the text objects of the layers (a story named twice counts twice).
-pub(super) const MAX_TEXT: usize = 16 << 20;
+pub(crate) const MAX_TEXT: usize = 16 << 20;
 
 /// Most pairs of a text object and a piece of the page's type compared, and of a glyph the page
 /// kept as outlines and a node of the page's type.
@@ -286,11 +286,12 @@ pub(super) fn fill_slots(
         let Some(n) = nodes.get(i) else { break };
         if let Some(story) = slot_of(n.name.as_deref()) {
             let slot = n.id;
-            let visible = n.visible;
+            let (visible, locked) = (n.visible, n.locked);
             let name = names.get(&n.id);
             let frame = ai::slot_frame(n.name.as_deref());
             let state = (n.opacity, n.blend, n.isolate, n.knockout);
-            let transparent = see_through(n);
+            let shape = n.knockout_shape;
+            let transparent = see_through(n) || shape;
             // A text object that is a wrap object stays one.
             let wrap = n.extras().wrap;
             // An art style read onto the slot (fills, strokes and effects round the characters) is the type's.
@@ -307,6 +308,9 @@ pub(super) fn fill_slots(
                             if !visible {
                                 Arc::make_mut(&mut p).visible = false;
                             }
+                            if locked {
+                                Arc::make_mut(&mut p).locked = true;
+                            }
                             if let Some(name) = name.filter(|_| matches!(p.kind, NodeKind::Text(_))) {
                                 Arc::make_mut(&mut p).name = Some(name.clone());
                             }
@@ -333,10 +337,11 @@ pub(super) fn fill_slots(
                         }
                         if let [p] = parts.as_mut_slice() {
                             let p = Arc::make_mut(p);
-                            (p.opacity, p.blend, p.isolate, p.knockout) = state;
+                            (p.opacity, p.blend, p.isolate, p.knockout, p.knockout_shape) = (state.0, state.1, state.2, state.3, shape);
                         } else if transparent {
                             let mut group = Node::group(doc.alloc_id(), std::mem::take(&mut parts));
-                            (group.opacity, group.blend, group.isolate, group.knockout) = state;
+                            (group.opacity, group.blend, group.isolate, group.knockout, group.knockout_shape) =
+                                (state.0, state.1, state.2, state.3, shape);
                             parts.push(Arc::new(group));
                         }
                     }
@@ -372,7 +377,7 @@ pub(super) fn fill_slots(
                     if let Some(story) = story {
                         made.push((story, frame, text.id));
                     }
-                    text.visible = visible;
+                    (text.visible, text.locked) = (visible, locked);
                     // Type with an art style is what the page draws as the style's look: it is seen.
                     let seen = seen || styled.is_some();
                     if let Some(appearance) = styled {
@@ -384,7 +389,7 @@ pub(super) fn fill_slots(
                     // Type the page shows is kept; other made type is weighed against the page.
                     text.name = if seen { name.cloned() } else { Some(format!("{MADE}{}", name.map_or("", String::as_str))) };
                     // The type takes the slot's transparency.
-                    (text.opacity, text.blend, text.isolate, text.knockout) = state;
+                    (text.opacity, text.blend, text.isolate, text.knockout, text.knockout_shape) = (state.0, state.1, state.2, state.3, shape);
                     if wrap.is_some() {
                         text.extras_mut().wrap = wrap;
                     }
diff --git a/crates/eps/src/import/obj.rs b/crates/eps/src/import/obj.rs
index 4f07678a7..ddf4858c8 100644
--- a/crates/eps/src/import/obj.rs
+++ b/crates/eps/src/import/obj.rs
@@ -370,6 +370,16 @@ impl<T: Clone + Held> Shared<T> {
     }
 }
 
+/// Equal when [`Shared::same`]: the same storage and run of it (the identity of a PostScript
+/// composite object, not its contents).
+impl<T: Held> PartialEq for Shared<T> {
+    fn eq(&self, o: &Self) -> bool {
+        Rc::ptr_eq(&self.buf, &o.buf) && self.at == o.at && self.len == o.len
+    }
+}
+
+impl<T: Held> Eq for Shared<T> {}
+
 /// Hashes what [`Shared::same`] compares: the storage and the run of it.
 impl<T: Held> Hash for Shared<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
diff --git a/crates/eps/src/import/tests.rs b/crates/eps/src/import/tests.rs
index 86fa8e35d..2bda9c230 100644
--- a/crates/eps/src/import/tests.rs
+++ b/crates/eps/src/import/tests.rs
@@ -1022,6 +1022,18 @@ fn known_answers_false_for_keys_no_dictionary_holds() {
     check("{ 1 dict null known } stopped");
 }
 
+/// `cvi` and `cvr` read a string as the PostScript syntax reads a number (PLRM 3rd ed., chapter
+/// 8), radix numbers included: prologs turn a name's `#20` escape back into its character with
+/// `(16#20) cvi`.
+#[test]
+fn cvi_and_cvr_read_radix_numbers() {
+    check("(16#20) cvi 32 eq (8#17) cvi 15 eq and ( 2#101 ) cvi 5 eq and (36#Z) cvi 35 eq and");
+    check("(16#ff) cvr 255 eq (3.7) cvi 3 eq and (-2.5e1) cvr -25 eq and (12) cvr 12 eq and");
+    check("{ (16#zz) cvi } stopped { (inf) cvr } stopped and { (16#-1) cvi } stopped and { () cvi } stopped and");
+    // A name's escapes, as a prolog undoes them for a spot colour named `PANTONE 300 C`.
+    check("(PANTONE#20300) dup 7 3 getinterval (16#--) dup 3 4 -1 roll 1 2 getinterval putinterval cvi 32 eq exch pop");
+}
+
 #[test]
 fn dictstack_and_internaldict_answer() {
     check("10 array dictstack length countdictstack eq");
@@ -1032,6 +1044,21 @@ fn dictstack_and_internaldict_answer() {
     check("<< /MaxPatternItem currentsystemparams /MaxPatternCache get >> setuserparams currentuserparams /MaxFontItem known");
 }
 
+/// `bind` makes the procedures it goes into read-only and leaves read-only procedures alone (PLRM
+/// 3rd ed., `bind` in chapter 8), so a later `bind` of a procedure holding one doesn't turn a name
+/// it kept into an operator defined since: here `M` stays the procedure's own variable, as in the
+/// prologs that keep `M` for `setmiterlimit` and also as the name of a variable.
+#[test]
+fn bind_leaves_procedures_it_already_bound_alone() {
+    let get = "/Get { 4 dict begin /M 7 def { M } exec end } bind def /M /setmiterlimit load def";
+    check(&format!("{get} /Outer {{ //Get exec }} bind def Outer 7 eq"));
+    // Nor does it go into one made read-only.
+    check("/I { M } readonly def /P { //I exec } def /M /setmiterlimit load def /P load bind pop /M 3 def P 3 eq");
+    check("/P { M } readonly def /M /setmiterlimit load def /P load bind pop /M 3 def P 3 eq");
+    // A procedure bound on its own is still bound again (only those inside are read-only).
+    check("/P { M } bind def /M /setmiterlimit load def /P load bind 0 get type /operatortype eq");
+}
+
 #[test]
 fn an_executable_filter_runs_its_data_as_a_program() {
     // A string run as a program through a filter (0 and an empty string set no end of data).
@@ -1045,6 +1072,17 @@ fn an_executable_filter_runs_its_data_as_a_program() {
     check("(1 2 add) 0 () /SubFileDecode filter exec type /filetype eq");
 }
 
+/// `SubFileDecode`'s count is how many bytes (or end strings) to pass, not an allocation: a count
+/// past the 4 MiB cap on allocations (a long content stream's `/Length`) is read, and only the data
+/// there passes through.
+#[test]
+fn subfile_counts_past_the_allocation_cap_are_read() {
+    check("(1 2 add) 6000000 () /SubFileDecode filter cvx exec 3 eq");
+    check("(1 2 add) 5000000 (x) /SubFileDecode filter cvx exec 3 eq");
+    check("(abcd) 7000000 () /SubFileDecode filter 8 string readstring pop (abcd) eq");
+    check("{ (1) -1 () /SubFileDecode filter } stopped");
+}
+
 #[test]
 fn flushfile_skips_the_data_of_a_filter() {
     // Metadata that isn't PostScript, skipped up to its end marker.
diff --git a/crates/eps/src/import/tests_images.rs b/crates/eps/src/import/tests_images.rs
index 160074230..8aad47fc7 100644
--- a/crates/eps/src/import/tests_images.rs
+++ b/crates/eps/src/import/tests_images.rs
@@ -516,3 +516,35 @@ fn tiff_predicted_rows_at_every_depth() {
     }
     assert!(wrong.is_empty(), "{wrong:#?}");
 }
+
+/// An image too large to read is left out, and its data is skipped, as reading it would leave
+/// the program: the art after it is read, not the data as PostScript. Here the data ends at its
+/// `~>` (an inline image of a content stream run as a file, as PDF-reading prologs write it), at
+/// a `SubFileDecode` end string, and at the end of compressed data that is read whole.
+#[test]
+fn the_data_of_an_image_too_large_to_read_is_skipped() {
+    let after = "0 0 1 setrgbcolor 10 10 80 80 rectfill";
+    for program in [
+        format!(
+            "/ID {{ << /ImageType 1 /Width 10000 /Height 10000 /BitsPerComponent 8 /Decode [0 1 0 1 0 1] /ImageMatrix [1 0 0 1 0 0] \
+             /DataSource currentfile 0 (~>) /SubFileDecode filter /ASCII85Decode filter /LZWDecode filter >> \
+             /DeviceRGB setcolorspace image }} def\n\
+             currentfile 0 (endstream) /SubFileDecode filter cvx exec\nID\nJ1_V7fG\"r'\"b]2#:hXAd)~>\n{after}\nendstream\n"
+        ),
+        format!("10000 10000 8 [1 0 0 1 0 0] currentfile /ASCIIHexDecode filter false 3 colorimage\n0a1b 2c3d 4e5f>\n{after}"),
+        format!(
+            "10000 10000 8 [1 0 0 1 0 0] currentfile 0 (%%EndData) /SubFileDecode filter /FlateDecode filter image\n\
+             x\u{9c}garbage\n%%EndData\n{after}"
+        ),
+        format!(
+            "10000 10000 true [1 0 0 1 0 0] currentfile /ASCII85Decode filter imagemask\n{}\n{after}",
+            crate::ps::ascii85(&crate::ps::deflate(&[0u8; 64]))
+        ),
+    ] {
+        let r = read(&program);
+        assert!(r.warnings.iter().any(|w| w.contains("too large to read")), "{program}: {:?}", r.warnings);
+        let o = super::tests::objects(&r.document);
+        assert_eq!(o.len(), 1, "{program}: {:?}", r.warnings);
+        assert_eq!(super::tests::fill(&o[0]), Some(&vectorcraft_color::Paint::solid(vectorcraft_color::Color::rgb(0.0, 0.0, 1.0))), "{program}");
+    }
+}
diff --git a/crates/eps/src/import/tests_native.rs b/crates/eps/src/import/tests_native.rs
index c32ab0c59..dde26bc8d 100644
--- a/crates/eps/src/import/tests_native.rs
+++ b/crates/eps/src/import/tests_native.rs
@@ -3417,6 +3417,41 @@ fn type_keeps_the_opacity_and_blend_mode_of_its_text_object() {
     assert!(group.children().unwrap().iter().all(|p| (p.opacity, p.blend) == (1.0, BlendMode::Normal)));
 }
 
+/// The knockout shape flag of a text object's `Xy` is its type's, made from the text document or
+/// taken from the page, and is on the group of the two where the type comes with other art.
+#[test]
+fn type_keeps_the_knockout_shape_of_its_text_object() {
+    let shapes = |d: &Document| {
+        let mut v = vec![];
+        d.walk(|n| {
+            if let NodeKind::Text(_) = &n.kind {
+                v.push(n.knockout_shape);
+            }
+        });
+        v
+    };
+    let doc = text_document(&[("Hi there\r", 0, (8200.0, 8180.0), (0.0, 0.0), 0.0)]);
+    let page = "0 0 0 1 setcmykcolor /Helvetica findfont 14 scalefont setfont 58.5 61.5 moveto (Hi there) show";
+    for body in [format!("1 0.2 0 0 1 Xy\n{}", text_object(0)), format!("{}1 0.2 0 0 1 Xy\n", text_object(0))] {
+        let art = native_with_text(&layer("Art", true, &body), &doc);
+        let (d, notes) = crate::ai_alone(&private(&art)).unwrap();
+        assert_eq!(shapes(&d), [true], "{body}{notes:?}");
+        let r = import(&eps(page, &art)).unwrap();
+        assert_eq!(shapes(&r.document), [true], "{body}{:?}", r.warnings);
+    }
+    let art = native_with_text(&layer("Art", true, &format!("1 0.2 0 0 0 Xy\n{}", text_object(0))), &doc);
+    assert_eq!(shapes(&crate::ai_alone(&private(&art)).unwrap().0), [false]);
+    let page = format!(
+        "{}\n/Helvetica findfont 12 scalefont setfont 10 50 moveto (Hi) show\n10 50 moveto (Hi) false charpath 2 setlinewidth stroke",
+        page_square(10, 10)
+    );
+    let words = layer("Words", true, "0 1 0 0 1 Xy\n/AI11Text :\n0 /FreeUndo ,\n;\n");
+    let r = import(&eps(&page, &native(&(layer("Art", true, &square(10, 10)) + &words)))).unwrap();
+    let words = &r.document.layers[1];
+    assert_eq!(kinds(words), ["group[2]"], "{:?}", r.warnings);
+    assert!(words.children().unwrap()[0].knockout_shape);
+}
+
 #[test]
 fn a_commented_copy_of_a_story_that_has_a_plain_text_object_is_not_another_object() {
     // The file writes some stories twice (plain, then as comments) and others only as comments.
diff --git a/crates/mcp/src/tests/fileio.rs b/crates/mcp/src/tests/fileio.rs
index d6f522b3b..58a6260be 100644
--- a/crates/mcp/src/tests/fileio.rs
+++ b/crates/mcp/src/tests/fileio.rs
@@ -261,8 +261,8 @@ fn save_file_warns_about_options_it_does_not_use() {
         assert_eq!(r["warnings"], json!([]), "{args}: {r}");
     }
 
-    // The app's save warns about the top-level options itself; the reply gets the notes on
-    // `options`, after the warnings the app sent.
+    // The app's save writes the notes on the top-level options and on `options` itself; the reply
+    // is the app's, with nothing added.
     struct App;
     impl Backend for App {
         fn call(&mut self, _: &str, _: Value) -> Result<Value, String> {
@@ -276,9 +276,35 @@ fn save_file_warns_about_options_it_does_not_use() {
         }
     }
     let r = text(&call_tool(&mut App, "save_file", &json!({"path": "/out/a.svg", "compress": true, "options": {"preview": true}})));
-    let w = warnings(&r);
-    assert_eq!(w.len(), 2, "{w:?}");
-    assert!(w[0] == "the app's own warning" && ignored(&w[1..], "options.preview"), "{w:?}");
+    assert_eq!(warnings(&r), ["the app's own warning"], "{r}");
+}
+
+/// The notes on `options` name the `.ai` file the save writes, as the note on a top-level option
+/// does: a legacy `.ai` for `aiVersion: "7"` (beside `pdfCompatible: false` too), a
+/// non-PDF-compatible `.ai` for `pdfCompatible: false`, and a PDF-compatible `.ai` otherwise, also
+/// when the save reuses the options the document was last saved with.
+#[test]
+fn save_file_notes_name_the_ai_file_it_writes() {
+    let mut h = Headless::with_document();
+    let notes = |r: &Value| -> Vec<String> {
+        r["warnings"].as_array().unwrap().iter().filter_map(Value::as_str).filter(|w| w.contains("was not used")).map(str::to_string).collect()
+    };
+    for (name, options, label) in [
+        ("legacy.ai", json!({"aiVersion": "7", "preview": true}), "legacy .ai (version 7)"),
+        ("legacy-no-pdf.ai", json!({"aiVersion": "7", "pdfCompatible": false, "preview": true}), "legacy .ai (version 7)"),
+        ("no-pdf.ai", json!({"pdfCompatible": false, "preview": true}), "non-PDF-compatible .ai"),
+        ("pdf.ai", json!({"pdfCompatible": true, "preview": true}), "PDF-compatible .ai"),
+    ] {
+        let r = text(&call_tool(&mut h, "save_file", &json!({"path": tmp(name), "version": 3, "options": options})));
+        let expected =
+            [format!("`version` was not used: {label} files don't read it"), format!("`options.preview` was not used: {label} files don't read it")];
+        assert_eq!(notes(&r), expected, "{name}: {r}");
+    }
+    // A save given no option the file reads writes it as last saved: a legacy `.ai` again.
+    text(&call_tool(&mut h, "save_file", &json!({"path": tmp("again.ai"), "options": {"aiVersion": "7"}})));
+    let r = text(&call_tool(&mut h, "save_file", &json!({"path": tmp("again.ai"), "options": {"preview": true}})));
+    assert_eq!(notes(&r), ["`options.preview` was not used: legacy .ai (version 7) files don't read it"], "{r}");
+    assert!(std::fs::read(tmp("again.ai")).unwrap().starts_with(b"%!PS"), "a legacy .ai is written");
 }
 
 #[test]
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index b872f6451..66080b6fa 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -2,7 +2,7 @@
 //! [`Backend`].
 
 use serde_json::{Map, Value, json};
-use vectorcraft_engine::cmd::fileio::{ARTBOARD_PARAMS, FORMATS, OPEN_EXTS, SAVE_FORMATS, format, save_reads_option, writable_format};
+use vectorcraft_engine::cmd::fileio::{ARTBOARD_PARAMS, FORMATS, OPEN_EXTS, SAVE_FORMATS, format, writable_format};
 
 use crate::backend::Backend;
 
diff --git a/crates/mcp/src/tools/dispatch.rs b/crates/mcp/src/tools/dispatch.rs
index f9d768eaa..57167439f 100644
--- a/crates/mcp/src/tools/dispatch.rs
+++ b/crates/mcp/src/tools/dispatch.rs
@@ -3,7 +3,7 @@ use super::handlers::{
     Args, absolute_path, add_text, answer_dialog, apply_paint, draw_path, draw_shape, exec, image_result, max_side, need_ui, req_str, screenshot,
     select_ids, transform,
 };
-use super::{ARTBOARD_PARAMS, Backend, Map, ToolResult, Value, format, json, save_reads_option, writable_format};
+use super::{ARTBOARD_PARAMS, Backend, Map, ToolResult, Value, json, writable_format};
 
 /// The `menu` argument of the command listings.
 pub(super) const MENU_FILTER: &str =
@@ -205,14 +205,7 @@ fn dispatch(b: &mut dyn Backend, name: &str, a: &Args) -> Result<ToolResult, Str
             if b.has_ui() {
                 p["wait"] = json!(true);
             }
-            let mut r = b.call("app.save", p)?;
-            let notes = save_file_warnings(a, r.get("format").and_then(Value::as_str));
-            if let Some(o) = r.as_object_mut().filter(|_| !notes.is_empty()) {
-                let mut all = o.get("warnings").and_then(Value::as_array).cloned().unwrap_or_default();
-                all.extend(notes.into_iter().map(Value::from));
-                o.insert("warnings".into(), Value::Array(all));
-            }
-            j(r)
+            j(b.call("app.save", p)?)
         }
         "export" => {
             // One params object for every backend; the named arguments win over `options` (a named
@@ -290,21 +283,6 @@ fn named_export_params(a: &Args) -> &'static [&'static str] {
     }
 }
 
-/// What `save_file` with arguments `a` adds to the save's `warnings`, for a file written in format
-/// `written` (none when nothing was written yet): each key in `options` that the format doesn't
-/// read. The save itself warns about `compress`, `version`, `preview` and `precision` given at the
-/// top level.
-fn save_file_warnings(a: &Args, written: Option<&str>) -> Vec<String> {
-    let Some(f) = written.and_then(format) else { return vec![] };
-    let nested = a.get("options").and_then(Value::as_object);
-    nested
-        .into_iter()
-        .flatten()
-        .filter(|(key, v)| !v.is_null() && !save_reads_option(f, key))
-        .map(|(key, _)| format!("`options.{key}` was not used: {} files don't read it", f.label))
-        .collect()
-}
-
 /// Run one tool. Failures (unknown tool, bad arguments, command errors) come back as an
 /// `isError` result so the model can read and correct them.
 pub fn call_tool(b: &mut dyn Backend, name: &str, args: &Value) -> ToolResult {
diff --git a/crates/pathops/src/boolean.rs b/crates/pathops/src/boolean.rs
index 163fe7e7c..6fa499467 100644
--- a/crates/pathops/src/boolean.rs
+++ b/crates/pathops/src/boolean.rs
@@ -690,13 +690,110 @@ pub fn boolean(a: &PathData, a_rule: FillRule, b: &PathData, b_rule: FillRule, o
 }
 
 /// Boolean operation with an explicit refit `precision`; errors on non-finite input.
+///
+/// The sweep can give some faces of the arrangement a wrong winding when an operand crosses or
+/// touches itself or has overlapping subpaths, and the result then silently gains or loses a
+/// region (#5478). So the windings are checked against each operand's own area
+/// ([`windings_add_up`]); when they don't add up, each operand is first resolved on its own into
+/// simple contours ([`resolved`]) and the operation runs again on those. When that doesn't add up
+/// either, the first result is kept (as before the check).
 pub fn try_boolean(a: &PathData, a_rule: FillRule, b: &PathData, b_rule: FillRule, op: BoolOp, precision: f64) -> Result<PathData, PathOpsError> {
-    let arr = Arrangement::new(vec![(fill_bezpath(a), a_rule), (fill_bezpath(b), b_rule)])?;
+    let (pa, pb) = (fill_bezpath(a), fill_bezpath(b));
+    let arr = Arrangement::new(vec![(pa.clone(), a_rule), (pb.clone(), b_rule)])?;
     let c = arr.try_contours(|m| op.apply(m[0], m[1]))?;
+    if !arrangement_adds_up(&arr, [&pa, &pb])
+        && let Some(r) = resolved_boolean([(&pa, a_rule), (&pb, b_rule)], op, precision)
+    {
+        return Ok(r);
+    }
     let tidy = Tidy { precision, ..arr.tidy };
     Ok(all_contours_to_path(&c, &tidy))
 }
 
+/// The widest winding (either sign) [`windings_add_up`] checks: one contour pass per level, so a
+/// more tangled input is taken as it is.
+const MAX_CHECKED_WINDING: i32 = 8;
+
+/// Do the windings `arr` gave each input add up to that input's own area ([`windings_add_up`])?
+/// Also true when it can't tell.
+fn arrangement_adds_up(arr: &Arrangement, inputs: [&BezPath; 2]) -> bool {
+    inputs.iter().enumerate().all(|(tag, p)| windings_add_up(&arr.top, |w: &Multi| w.get(tag), p).unwrap_or(true))
+}
+
+/// Does the winding `winding` that the sweep `top` gave its faces add up to the signed area of the
+/// path `input` it was made from? By Green's theorem the integral of a path's winding number over
+/// the plane is the path's signed area, and that integral is Σₖ |{w ≥ k}| − Σₖ |{w ≤ −k}| (k ≥ 1),
+/// each area read from the contours of that region. A face given a wrong winding (#5478) puts it
+/// off by the face's area. None when it can't tell: windings past [`MAX_CHECKED_WINDING`], or a
+/// contour pass that fails.
+fn windings_add_up<W: WindingNumber>(top: &Topology<W>, winding: impl Fn(&W) -> i32, input: &BezPath) -> Option<bool> {
+    let (mut lo, mut hi) = (0, 0);
+    for s in top.segment_indices() {
+        let h = s.first_half();
+        for w in [top.winding_clockwise(h), top.winding_counter_clockwise(h)] {
+            let k = winding(w);
+            (lo, hi) = (lo.min(k), hi.max(k));
+        }
+    }
+    if hi > MAX_CHECKED_WINDING || lo < -MAX_CHECKED_WINDING {
+        return None;
+    }
+    let region = |pred: &dyn Fn(i32) -> bool| -> Option<f64> {
+        let c = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| top.contours(|w| pred(winding(w))))).ok()?;
+        Some(c.contours().map(|ct| ct.path.area()).sum::<f64>().abs())
+    };
+    let mut integral = 0.0;
+    for k in 1..=hi {
+        integral += region(&|w| w >= k)?;
+    }
+    for k in 1..=-lo {
+        integral -= region(&|w| w <= -k)?;
+    }
+    let want = input.area();
+    // The sweep moves points by up to its tolerance, which moves an area by about that much along
+    // each edge; a misplaced face is far larger.
+    let bounds = input.bounding_box();
+    let eps = eps_for([input]).ok()?;
+    let tol = 1e-6 * bounds.area().abs() + 16.0 * eps * input.perimeter(1e-3) * f64::from(hi - lo).max(1.0);
+    Some((integral - want).abs() <= tol || (integral + want).abs() <= tol)
+}
+
+/// `input` resolved on its own under `rule` into simple contours (outer contours and holes, filled
+/// non-zero), when the windings of that sweep add up ([`windings_add_up`]).
+fn resolved(input: &BezPath, rule: FillRule) -> Option<BezPath> {
+    let eps = eps_for([input]).ok()?;
+    let mut bp = input.clone();
+    snap_horizontals(&mut [&mut bp], eps);
+    if !crate::budget::sweep_fits([&bp]) {
+        return None;
+    }
+    let top = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| Topology::<i32>::from_path(&bp, eps))).ok()?.ok()?;
+    if !windings_add_up(&top, |w| *w, &bp)? {
+        return None;
+    }
+    let c = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| top.contours(|w| inside(rule, *w)))).ok()?;
+    let mut out = BezPath::new();
+    for ct in c.contours() {
+        out.extend(ct.path.iter());
+    }
+    Some(out)
+}
+
+/// [`try_boolean`] on the operands resolved into simple contours first ([`resolved`]): the result
+/// when every sweep's windings add up, else None.
+fn resolved_boolean(inputs: [(&BezPath, FillRule); 2], op: BoolOp, precision: f64) -> Option<PathData> {
+    let [(pa, a_rule), (pb, b_rule)] = inputs;
+    let (ra, rb) = (resolved(pa, a_rule)?, resolved(pb, b_rule)?);
+    let arr = Arrangement::new(vec![(ra.clone(), FillRule::NonZero), (rb.clone(), FillRule::NonZero)]).ok()?;
+    if !arrangement_adds_up(&arr, [&ra, &rb]) {
+        return None;
+    }
+    let c = arr.try_contours(|m| op.apply(m[0], m[1])).ok()?;
+    // The refit keeps the operands' own anchors, not only those of their resolved contours.
+    let tidy = Tidy::keeping(precision, [pa, pb]);
+    Some(all_contours_to_path(&c, &tidy))
+}
+
 /// [`boolean_n`] that reports a refused input ([`PathOpsError::TooComplex`], non-finite
 /// coordinates) instead of returning an empty path.
 pub fn try_boolean_n(paths: &[(&PathData, FillRule)], pred: impl Fn(&[bool]) -> bool) -> Result<PathData, PathOpsError> {
@@ -919,6 +1016,31 @@ mod tests {
         assert_eq!(try_area(&square(1e14, 1e14, 100.0), FillRule::NonZero), Err(PathOpsError::Degenerate));
     }
 
+    /// #5478: the sweep of a triangle against an operand that crosses itself gives faces windings
+    /// that don't add up to the operands' areas; resolving the operands first gives ones that do.
+    #[test]
+    fn wrong_windings_are_caught_and_resolving_the_operands_fixes_them() {
+        let poly = |pts: &[(f64, f64)]| {
+            let mut bp = BezPath::new();
+            for (i, p) in pts.iter().enumerate() {
+                if i == 0 { bp.move_to(*p) } else { bp.line_to(*p) }
+            }
+            bp.close_path();
+            bp
+        };
+        let a = poly(&[(3.0, 1.0), (3.0, 3.0), (0.0, 1.0)]);
+        let b = poly(&[(3.0, 0.0), (0.0, 2.0), (3.0, 2.0), (0.0, 0.0), (0.0, 1.0)]);
+        let arr = Arrangement::new(vec![(a.clone(), FillRule::NonZero), (b.clone(), FillRule::NonZero)]).unwrap();
+        assert!(!arrangement_adds_up(&arr, [&a, &b]), "the sweep's windings are off");
+        let (ra, rb) = (resolved(&a, FillRule::NonZero).unwrap(), resolved(&b, FillRule::NonZero).unwrap());
+        let arr = Arrangement::new(vec![(ra.clone(), FillRule::NonZero), (rb.clone(), FillRule::NonZero)]).unwrap();
+        assert!(arrangement_adds_up(&arr, [&ra, &rb]));
+        // A plain pair adds up at once.
+        let (s, t) = (poly(&[(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0)]), poly(&[(2.0, 2.0), (6.0, 2.0), (6.0, 6.0), (2.0, 6.0)]));
+        let arr = Arrangement::new(vec![(s.clone(), FillRule::NonZero), (t.clone(), FillRule::EvenOdd)]).unwrap();
+        assert!(arrangement_adds_up(&arr, [&s, &t]));
+    }
+
     #[test]
     #[cfg(panic = "unwind")]
     fn a_panic_in_the_contour_pass_becomes_an_error() {
diff --git a/crates/pathops/src/offset.rs b/crates/pathops/src/offset.rs
index f028c0704..2c0db1f2a 100644
--- a/crates/pathops/src/offset.rs
+++ b/crates/pathops/src/offset.rs
@@ -118,6 +118,18 @@ fn path_is_finite(path: &PathData) -> bool {
 /// Fallible [`offset_path`] that returns an error when the input is non-finite or exceeds
 /// the complexity bound ([`MAX_OFFSET_SEGMENT_PAIRS`]), or when planar arrangement fails.
 pub fn try_offset_path(path: &PathData, delta: f64, join: Join, miter_limit: f64) -> Result<PathData, PathOpsError> {
+    let src = std::cell::LazyCell::new(|| SegmentTree::new(boxed_segments(&path.to_bezpath())));
+    offset_with_check(path, delta, join, miter_limit, |p, r| any_within(&src, p, r))
+}
+
+/// [`try_offset_path`] with the test of whether some segment of `path` lies closer than a radius to a point.
+fn offset_with_check(
+    path: &PathData,
+    delta: f64,
+    join: Join,
+    miter_limit: f64,
+    within: impl Fn(kurbo::Point, f64) -> bool,
+) -> Result<PathData, PathOpsError> {
     if !delta.is_finite() || !path_is_finite(path) {
         return Err(PathOpsError::NonFinite);
     }
@@ -144,10 +156,9 @@ pub fn try_offset_path(path: &PathData, delta: f64, join: Join, miter_limit: f64
     // winding, leaving faces uncovered that are really within `d` of the path. Every face of the
     // true offset is bounded by arrangement edges, so a contour is spurious iff a point deep inside
     // it lies closer than `d`: holes when growing, islands when insetting.
-    let src = std::cell::LazyCell::new(|| boxed_segments(&path.to_bezpath()));
     let drop_outer = delta < 0.0;
     let spurious: Vec<bool> =
-        c.contours().map(|k| k.outer == drop_outer && deep_point(&k.path).is_some_and(|p| any_within(&src, p, d * (1.0 - 1e-4) - 1e-6))).collect();
+        c.contours().map(|k| k.outer == drop_outer && deep_point(&k.path).is_some_and(|p| within(p, d * (1.0 - 1e-4) - 1e-6))).collect();
     if !spurious.contains(&true) {
         return Ok(all_contours_to_path(&c, &Tidy::free(DEFAULT_PRECISION)));
     }
@@ -261,12 +272,82 @@ fn box_may_reach(b: &kurbo::Rect, p: kurbo::Point, r: f64) -> bool {
     p.x >= b.x0 - reach && p.x <= b.x1 + reach && p.y >= b.y0 - reach && p.y <= b.y1 + reach
 }
 
+/// Most segments in a leaf of a [`SegmentTree`].
+const TREE_LEAF: usize = 8;
+
+/// A path's segments in a tree of bounding boxes, built once and searched for the segments near a point.
+struct SegmentTree {
+    /// The segments, ordered so that each leaf holds a run of them.
+    segs: Vec<(kurbo::Rect, kurbo::PathSeg)>,
+    /// The nodes, each one followed by the nodes below it.
+    nodes: Vec<TreeNode>,
+}
+
+struct TreeNode {
+    /// The union of the boxes below this node. A box holding NaN never passes [`box_may_reach`],
+    /// and the union leaves its NaN out.
+    bounds: kurbo::Rect,
+    /// The segments of a leaf; empty for a node with nodes below it.
+    leaf: std::ops::Range<usize>,
+    /// The first node after this one that is not below it.
+    next: usize,
+}
+
+impl SegmentTree {
+    fn new(mut segs: Vec<(kurbo::Rect, kurbo::PathSeg)>) -> Self {
+        let mut nodes = Vec::new();
+        Self::split(&mut segs, 0, &mut nodes);
+        Self { segs, nodes }
+    }
+
+    /// Adds the nodes for `segs`, which start at index `start` of the whole list: past
+    /// [`TREE_LEAF`] segments, halves them along the wider side of their bounds.
+    fn split(segs: &mut [(kurbo::Rect, kurbo::PathSeg)], start: usize, nodes: &mut Vec<TreeNode>) {
+        let empty = kurbo::Rect::new(f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);
+        let bounds = segs.iter().fold(empty, |u, (b, _)| u.union(*b));
+        let at = nodes.len();
+        let leaf = if segs.len() <= TREE_LEAF { start..start + segs.len() } else { start..start };
+        nodes.push(TreeNode { bounds, leaf, next: at + 1 });
+        if segs.len() > TREE_LEAF {
+            let wide = bounds.width() >= bounds.height();
+            let center = |b: &kurbo::Rect| if wide { b.x0 + b.x1 } else { b.y0 + b.y1 };
+            let mid = segs.len() / 2;
+            segs.select_nth_unstable_by(mid, |a, b| center(&a.0).total_cmp(&center(&b.0)));
+            let (low, high) = segs.split_at_mut(mid);
+            Self::split(low, start, nodes);
+            Self::split(high, start + mid, nodes);
+            let end = nodes.len();
+            if let Some(n) = nodes.get_mut(at) {
+                n.next = end;
+            }
+        }
+    }
+
+    /// Whether `test` holds for a segment in a leaf whose bounds [`box_may_reach`] allows. Stops at
+    /// the first segment it holds for.
+    fn any_near(&self, p: kurbo::Point, r: f64, mut test: impl FnMut(&(kurbo::Rect, kurbo::PathSeg)) -> bool) -> bool {
+        let mut i = 0;
+        while let Some(n) = self.nodes.get(i) {
+            if !box_may_reach(&n.bounds, p, r) {
+                i = n.next;
+            } else if n.leaf.is_empty() {
+                i += 1;
+            } else if self.segs.get(n.leaf.clone()).is_some_and(|run| run.iter().any(&mut test)) {
+                return true;
+            } else {
+                i = n.next;
+            }
+        }
+        false
+    }
+}
+
 /// Whether some segment lies closer than `r` to `p`. A segment whose box is too far away can't, so
 /// it is skipped without the costly nearest-point search, and the search stops at the first
 /// segment that does.
-fn any_within(segs: &[(kurbo::Rect, kurbo::PathSeg)], p: kurbo::Point, r: f64) -> bool {
+fn any_within(tree: &SegmentTree, p: kurbo::Point, r: f64) -> bool {
     use kurbo::ParamCurveNearest;
-    r > 0.0 && segs.iter().any(|(b, s)| box_may_reach(b, p, r) && s.nearest(p, 1e-6).distance_sq.sqrt() < r)
+    r > 0.0 && tree.any_near(p, r, |(b, s)| box_may_reach(b, p, r) && s.nearest(p, 1e-6).distance_sq.sqrt() < r)
 }
 
 #[cfg(test)]
@@ -323,6 +404,7 @@ mod tests {
             let shift = [0.0, 1e6, 1e9][case % 3];
             let bp = kurbo::Affine::translate((shift, -shift)) * bp;
             let segs = boxed_segments(&bp);
+            let tree = SegmentTree::new(segs.clone());
             for _ in 0..40 {
                 // On the grid (on segments and their ends) and off it.
                 let p = if rng.next() < 0.5 {
@@ -349,7 +431,7 @@ mod tests {
                     rng.next() * 3.0,
                     1e6,
                 ] {
-                    assert_eq!(any_within(&segs, p, r), nearest < r, "case {case} p {p:?} r {r} nearest {nearest}");
+                    assert_eq!(any_within(&tree, p, r), nearest < r, "case {case} p {p:?} r {r} nearest {nearest}");
                     hits += usize::from(nearest < r);
                     // Every segment the box test skips is really out of reach.
                     for (b, s) in &segs {
@@ -363,7 +445,200 @@ mod tests {
             }
         }
         assert!(hits > 1000 && skipped > 10_000, "{hits} {skipped}");
-        assert!(!any_within(&[], kurbo::Point::ZERO, 1.0));
+        assert!(!any_within(&SegmentTree::new(vec![]), kurbo::Point::ZERO, 1.0));
+    }
+
+    /// The test over every segment in path order, with no tree.
+    fn any_within_by_scan(segs: &[(kurbo::Rect, kurbo::PathSeg)], p: kurbo::Point, r: f64) -> bool {
+        use kurbo::ParamCurveNearest;
+        r > 0.0 && segs.iter().any(|(b, s)| box_may_reach(b, p, r) && s.nearest(p, 1e-6).distance_sq.sqrt() < r)
+    }
+
+    /// A grid of `n` by `n` unit lines, 10 apart.
+    fn line_grid(n: usize) -> Vec<(kurbo::Rect, kurbo::PathSeg)> {
+        let mut bp = BezPath::new();
+        for i in 0..n {
+            for j in 0..n {
+                let (x, y) = (i as f64 * 10.0, j as f64 * 10.0);
+                bp.move_to((x, y));
+                bp.line_to((x + 1.0, y));
+            }
+        }
+        boxed_segments(&bp)
+    }
+
+    #[test]
+    fn the_tree_tests_only_the_segments_near_the_point() {
+        let tree = SegmentTree::new(line_grid(100));
+        for (p, r) in [((500.5, 500.0), 0.25), ((503.0, 505.0), 2.0), ((-50.0, -50.0), 1.0)] {
+            let p = kurbo::Point::new(p.0, p.1);
+            let mut tested = 0;
+            tree.any_near(p, r, |_| {
+                tested += 1;
+                false
+            });
+            assert!(tested <= 4 * TREE_LEAF, "{tested} of 10000 segments tested at {p:?} within {r}");
+        }
+        // A radius that takes in the whole grid tests every segment.
+        let mut tested = 0;
+        tree.any_near(kurbo::Point::new(500.0, 500.0), 1e6, |_| {
+            tested += 1;
+            false
+        });
+        assert_eq!(tested, 10_000);
+    }
+
+    #[test]
+    fn the_tree_holds_every_segment_once_at_any_size() {
+        for n in [0, 1, TREE_LEAF - 1, TREE_LEAF, TREE_LEAF + 1, 2 * TREE_LEAF + 1, 100, 1000] {
+            let mut bp = BezPath::new();
+            for i in 0..n {
+                bp.move_to((i as f64, 0.0));
+                bp.line_to((i as f64, 1.0));
+            }
+            let tree = SegmentTree::new(boxed_segments(&bp));
+            let mut xs = vec![];
+            tree.any_near(kurbo::Point::new(0.0, 0.0), 1e9, |(b, _)| {
+                xs.push(b.x0);
+                false
+            });
+            xs.sort_by(f64::total_cmp);
+            assert_eq!(xs, (0..n).map(|i| i as f64).collect::<Vec<_>>());
+        }
+    }
+
+    #[test]
+    fn the_tree_answers_like_the_scan_when_boxes_are_not_finite() {
+        // Boxes with NaN or infinite sides, as extreme coordinates can give, among ordinary ones.
+        let line = |x: f64| kurbo::PathSeg::Line(kurbo::Line::new((x, 0.0), (x + 1.0, 0.0)));
+        let mut segs: Vec<(kurbo::Rect, kurbo::PathSeg)> =
+            (0..40).map(|i| (line(f64::from(i) * 5.0).bounding_box(), line(f64::from(i) * 5.0))).collect();
+        for (k, b) in [
+            kurbo::Rect::new(f64::NAN, 0.0, 1.0, 1.0),
+            kurbo::Rect::new(0.0, f64::NAN, 1.0, 1.0),
+            kurbo::Rect::new(0.0, 0.0, f64::NAN, 1.0),
+            kurbo::Rect::new(0.0, 0.0, 1.0, f64::NAN),
+            kurbo::Rect::new(f64::NEG_INFINITY, -1.0, f64::INFINITY, 1.0),
+            kurbo::Rect::new(f64::NAN, f64::NAN, f64::NAN, f64::NAN),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            segs.insert(k * 6, (b, line(1000.0 + k as f64 * 5.0)));
+        }
+        for every_box_is_nan in [false, true] {
+            if every_box_is_nan {
+                segs.iter_mut().for_each(|(b, _)| *b = kurbo::Rect::new(f64::NAN, f64::NAN, f64::NAN, f64::NAN));
+            }
+            let tree = SegmentTree::new(segs.clone());
+            for x in [-3.0, 0.5, 7.0, 100.0, 1000.5, 1012.0, 1e6] {
+                for r in [0.5, 2.0, 50.0, 1e7] {
+                    let p = kurbo::Point::new(x, 0.25);
+                    assert_eq!(any_within(&tree, p, r), any_within_by_scan(&segs, p, r), "{every_box_is_nan} {p:?} {r}");
+                }
+            }
+        }
+    }
+
+    /// Paths across the kinds of input the offset treats differently.
+    fn offset_inputs() -> Vec<PathData> {
+        let mut rng = Lcg(31);
+        let mut paths = vec![];
+        let from = |bp: &BezPath| PathData::from_bezpath(bp);
+        // Separate shapes with no overlaps.
+        let mut islands = BezPath::new();
+        for i in 0..5 {
+            for j in 0..5 {
+                let (x, y) = (f64::from(i) * 20.0, f64::from(j) * 20.0);
+                islands.extend(kurbo::Rect::new(x, y, x + 12.0, y + 12.0).to_path(0.1));
+            }
+        }
+        paths.push(from(&islands));
+        // A compound path with holes, some of a radius equal to the offsets below.
+        for small in [0.8, 1.0, 2.0] {
+            let mut plate = kurbo::Rect::new(0.0, 0.0, 100.0, 100.0).to_path(0.1);
+            for i in 0..4 {
+                for j in 0..4 {
+                    let r = if (i + j) % 2 == 0 { small } else { 4.0 };
+                    plate.extend(kurbo::Circle::new((12.5 + 25.0 * f64::from(i), 12.5 + 25.0 * f64::from(j)), r).to_path(0.01).reverse_subpaths());
+                }
+            }
+            paths.push(from(&plate));
+        }
+        // A self-crossing star, closed and open.
+        let star = |close: bool| {
+            let mut bp = BezPath::new();
+            for i in 0..=7 {
+                let t = f64::from(i) * 3.0 / 7.0 * std::f64::consts::TAU;
+                let p = (50.0 + 40.0 * t.cos(), 50.0 + 40.0 * t.sin());
+                if i == 0 { bp.move_to(p) } else { bp.line_to(p) }
+            }
+            if close {
+                bp.close_path();
+            }
+            bp
+        };
+        paths.push(from(&star(true)));
+        paths.push(from(&star(false)));
+        // Short paths: one line, one curve, a single anchor, and a path whose ends meet.
+        for svg in ["M0,0 L10,0", "M0,0 C5,10 10,-10 15,0", "M3,3", "M0,0 L10,0 L10,10 L0,0"] {
+            paths.push(from(&BezPath::from_svg(svg).unwrap()));
+        }
+        // An open zigzag whose stroke leaves many small holes.
+        let mut zigzag = BezPath::new();
+        for row in 0..4 {
+            for col in 0..40 {
+                let c = if row % 2 == 0 { col } else { 39 - col };
+                let p = (f64::from(c) * 1.6, f64::from(row) * 6.0 + if col % 2 == 0 { 0.0 } else { 2.0 });
+                if row == 0 && col == 0 { zigzag.move_to(p) } else { zigzag.line_to(p) }
+            }
+        }
+        paths.push(from(&zigzag));
+        // Random curves that cross themselves and each other, near the origin and far from it.
+        for case in 0..18 {
+            let n = [6.0, 40.0][case % 2];
+            let mut bp = BezPath::new();
+            for _ in 0..1 + case % 4 {
+                let pt = |rng: &mut Lcg| kurbo::Point::new(rng.grid(n), rng.grid(n));
+                bp.move_to(pt(&mut rng));
+                for _ in 0..2 + (rng.next() * 5.0) as usize {
+                    match (rng.next() * 3.0) as u32 {
+                        0 => bp.line_to(pt(&mut rng)),
+                        1 => bp.quad_to(pt(&mut rng), pt(&mut rng)),
+                        _ => bp.curve_to(pt(&mut rng), pt(&mut rng), pt(&mut rng)),
+                    }
+                }
+                if rng.next() < 0.6 {
+                    bp.close_path();
+                }
+            }
+            let shift = [0.0, 0.0, 1e6][case % 3];
+            paths.push(from(&(kurbo::Affine::translate((shift, -shift)) * bp)));
+        }
+        paths
+    }
+
+    #[test]
+    fn offsets_with_the_tree_are_identical_to_offsets_with_the_scan() {
+        let (mut checks, mut hits, mut misses) = (0, 0, 0);
+        for path in offset_inputs() {
+            let segs = boxed_segments(&path.to_bezpath());
+            for delta in [0.0, 0.05, 1.0, 5.0, 60.0, -0.05, -1.0, -5.0, -60.0] {
+                for join in [Join::Round, Join::Miter, Join::Bevel] {
+                    let found = std::cell::Cell::new((0, 0));
+                    let by_scan = offset_with_check(&path, delta, join, 4.0, |p, r| {
+                        let v = any_within_by_scan(&segs, p, r);
+                        found.set((found.get().0 + usize::from(v), found.get().1 + usize::from(!v)));
+                        v
+                    });
+                    checks += 1;
+                    hits += found.get().0;
+                    misses += found.get().1;
+                    assert_eq!(try_offset_path(&path, delta, join, 4.0), by_scan, "{path:?} by {delta} with {join:?}");
+                }
+            }
+        }
+        assert!(checks > 500 && hits > 200 && misses > 200, "{checks} {hits} {misses}");
     }
 
     #[test]
diff --git a/crates/pathops/tests/it/regressions.rs b/crates/pathops/tests/it/regressions.rs
index f529ed020..3bafb9677 100644
--- a/crates/pathops/tests/it/regressions.rs
+++ b/crates/pathops/tests/it/regressions.rs
@@ -184,3 +184,21 @@ fn self_crossing_quad_fills_both_loops() {
     let got = area(&poly(&[p0, p1, p2, p3].map(|p| (p.x, p.y))), NZ);
     assert!(close(got, want, 1e-9), "area {got}, want {want}");
 }
+
+/// #5478: an operand that crosses itself (`b`), meeting another along its crossings: the sweep
+/// gave each operation a wrong area (union 5.5, intersection 1.5, difference 3, xor 4), so
+/// union + intersection was 7 where |a| + |b| is 5.5. The exact areas, under both fill rules.
+#[test]
+fn a_self_crossing_operand_gets_the_exact_areas() {
+    let a = poly(&[(3.0, 1.0), (3.0, 3.0), (0.0, 1.0)]);
+    let b = poly(&[(3.0, 0.0), (0.0, 2.0), (3.0, 2.0), (0.0, 0.0), (0.0, 1.0)]);
+    for rule in [NZ, FillRule::EvenOdd] {
+        assert!(close(area(&a, rule), 3.0, 1e-9) && close(area(&b, rule), 2.5, 1e-9), "{rule:?}");
+        for (op, want) in [(BoolOp::Union, 4.375), (BoolOp::Intersect, 1.125), (BoolOp::Difference, 1.875), (BoolOp::Xor, 3.25)] {
+            let got = area(&boolean(&a, rule, &b, rule, op), NZ);
+            assert!(close(got, want, 1e-6), "{op:?} {rule:?}: {got}, want {want}");
+            let tried = try_boolean(&a, rule, &b, rule, op, DEFAULT_PRECISION).unwrap();
+            assert!(close(area(&tried, NZ), want, 1e-6), "try_boolean {op:?} {rule:?}");
+        }
+    }
+}
diff --git a/crates/pdf/src/export.rs b/crates/pdf/src/export.rs
index cfb3d9344..8728b29b2 100644
--- a/crates/pdf/src/export.rs
+++ b/crates/pdf/src/export.rs
@@ -45,6 +45,8 @@ pub use entry::{export, export_with_report, page_areas};
 use exporter::{MAX_COORD, writable, xf};
 #[cfg(test)]
 use images::{png_8_bit, png_16_bit};
+#[cfg(test)]
+pub(crate) use nodes::MEASURES;
 pub(crate) use writer::{Sheet, Writer};
 
 pub(crate) struct Exporter<'a> {
diff --git a/crates/pdf/src/export/links.rs b/crates/pdf/src/export/links.rs
index 5eec2fd83..a40ca6692 100644
--- a/crates/pdf/src/export/links.rs
+++ b/crates/pdf/src/export/links.rs
@@ -47,8 +47,10 @@ impl Exporter<'_> {
         {
             return;
         }
-        let bounds = n.visual_bounds_with(&self.symbols).filter(|b| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()));
-        if let (Some(uri), Some(b)) = (n.url().filter(|u| opens(u)), bounds) {
+        // Only a link and a clipping group read the box.
+        let uri = n.url().filter(|u| opens(u));
+        let bounds = (uri.is_some() || n.clips()).then(|| self.measure_for_links(n)).flatten();
+        if let (Some(uri), Some(b)) = (uri, bounds) {
             let shown = b.intersect(within);
             if shown.width() > 0.0 && shown.height() > 0.0 {
                 let rect = to_page.transform_rect_bbox(shown);
@@ -74,6 +76,13 @@ impl Exporter<'_> {
             self.link_node(child, within, to_page, links, more);
         }
     }
+
+    /// The visual box of `n`, when all its coordinates are finite.
+    fn measure_for_links(&self, n: &Node) -> Option<Rect> {
+        #[cfg(test)]
+        super::MEASURES.with(|m| m.set(m.get() + 1));
+        n.visual_bounds_with(&self.symbols).filter(|b| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()))
+    }
 }
 
 /// `uri` as a PDF URI (ISO 32000-1 §12.6.4.7: 7-bit ASCII): spaces, control characters and
diff --git a/crates/pdf/src/export/nodes.rs b/crates/pdf/src/export/nodes.rs
index 389552948..e8057236c 100644
--- a/crates/pdf/src/export/nodes.rs
+++ b/crates/pdf/src/export/nodes.rs
@@ -4,6 +4,20 @@ use super::{
     Shape, Stroke, StrokeAlign, StrokeDash, StrokeLayer, Surface, WrittenShape, krilla, stroke,
 };
 
+/// An object's visual box for leaving out what is off the page. A plain group or layer also holds
+/// the boxes of the members it is measured through ([`Node::editing_children`], in order), so that
+/// the walk measures them once.
+struct Measured {
+    bounds: Option<Rect>,
+    members: Vec<Measured>,
+}
+
+#[cfg(test)]
+std::thread_local! {
+    /// The objects this thread has measured for the walk and for the links (tests).
+    pub(crate) static MEASURES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
 impl Exporter<'_> {
     /// Opacity mask → luminosity soft mask. Outside the art the backdrop is black (clip) or white;
     /// invert is a white Difference rect on top (luminance is linear, so luma(1 − c) = 1 − luma(c)).
@@ -38,9 +52,15 @@ impl Exporter<'_> {
 
     /// The children of a group, as the elements of a knockout group when it is one.
     pub(super) fn children(&mut self, s: &mut Surface, children: &[std::sync::Arc<Node>], page: Rect) {
+        self.measured_children(s, children, page, &[]);
+    }
+
+    /// [`Self::children`] with the boxes of the last members in `measured`.
+    fn measured_children(&mut self, s: &mut Surface, children: &[std::sync::Arc<Node>], page: Rect, measured: &[Measured]) {
         if !self.knockout {
-            for c in children {
-                self.node(s, c, page, false);
+            let unmeasured = children.len().saturating_sub(measured.len());
+            for (i, c) in children.iter().enumerate() {
+                self.measured_node(s, c, page, false, i.checked_sub(unmeasured).and_then(|i| measured.get(i)));
             }
             return;
         }
@@ -50,23 +70,25 @@ impl Exporter<'_> {
         self.warn("knockout groups are written as soft-masked groups (same look, but not editable as knockout groups)");
         let elements: Vec<_> = Node::knockout_elements(children)
             .into_iter()
-            .filter(|c| c.visual_bounds_with(&self.symbols).is_some_and(|b| rects_overlap(b.inflate(1.0, 1.0), page)))
+            .map(|c| (c, self.measure(c)))
+            .filter(|(_, m)| m.bounds.is_some_and(|b| rects_overlap(b.inflate(1.0, 1.0), page)))
             .collect();
-        let Some((first, rest)) = elements.split_first() else { return };
-        for c in rest.iter().rev() {
-            let mask = self.knockout_mask(s, c, page);
+        let Some(((first, measured), rest)) = elements.split_first() else { return };
+        for (c, m) in rest.iter().rev() {
+            let mask = self.knockout_mask(s, c, page, m);
             s.push_mask(mask);
         }
-        self.node(s, first, page, false);
-        for c in rest {
+        self.measured_node(s, first, page, false, Some(measured));
+        for (c, m) in rest {
             s.pop();
-            self.node(s, c, page, false);
+            self.measured_node(s, c, page, false, Some(m));
         }
     }
 
-    /// A luminosity mask that is 1 − the knockout shape of `c`: white, then black through an alpha
-    /// mask of `c` (at full object opacity without its own mask, unless those define its shape).
-    fn knockout_mask(&mut self, s: &mut Surface, c: &Node, page: Rect) -> krilla::mask::Mask {
+    /// A luminosity mask that is 1 − the knockout shape of `c`, whose box is in `measured`: white,
+    /// then black through an alpha mask of `c` (at full object opacity without its own mask, unless
+    /// those define its shape).
+    fn knockout_mask(&mut self, s: &mut Surface, c: &Node, page: Rect, measured: &Measured) -> krilla::mask::Mask {
         let shape = if c.knockout_shape {
             c.clone()
         } else {
@@ -81,7 +103,7 @@ impl Exporter<'_> {
             let mut ab = ms.stream_builder();
             let mut als = ab.surface();
             let overprint = std::mem::take(&mut self.overprint);
-            self.node(&mut als, &shape, page, false);
+            self.measured_node(&mut als, &shape, page, false, Some(measured));
             self.overprint = overprint;
             als.finish();
             krilla::mask::Mask::new(ab.finish(), krilla::mask::MaskType::Alpha)
@@ -93,7 +115,23 @@ impl Exporter<'_> {
         krilla::mask::Mask::new(sb.finish(), krilla::mask::MaskType::Luminosity)
     }
 
+    /// The box of `n`, and of the members of a plain group or layer.
+    fn measure(&self, n: &Node) -> Measured {
+        if !matches!(n.kind, NodeKind::Layer { clip: false, .. } | NodeKind::Group { clip: false, .. }) {
+            #[cfg(test)]
+            MEASURES.with(|m| m.set(m.get() + 1));
+            return Measured { bounds: n.visual_bounds_with(&self.symbols), members: vec![] };
+        }
+        let members: Vec<_> = n.editing_children().iter().map(|c| self.measure(c)).collect();
+        Measured { bounds: n.visual_of_members(members.iter().map(|m| m.bounds)), members }
+    }
+
     pub(super) fn node(&mut self, s: &mut Surface, n: &Node, page: Rect, force: bool) {
+        self.measured_node(s, n, page, force, None);
+    }
+
+    /// [`Self::node`] with the box of `n` in `measured`, when its parent measured it.
+    fn measured_node(&mut self, s: &mut Surface, n: &Node, page: Rect, force: bool, measured: Option<&Measured>) {
         if self.layers
             && self.in_layer != address(n)
             && let NodeKind::Layer { printable, .. } = n.kind
@@ -115,9 +153,12 @@ impl Exporter<'_> {
         {
             return;
         }
-        match n.visual_bounds_with(&self.symbols) {
-            Some(b) if !force && !rects_overlap(b.inflate(1.0, 1.0), page) => return,
-            None if !n.is_container() => return,
+        // A container written whatever its box is has no use for one.
+        let own = (measured.is_none() && !(force && n.is_container())).then(|| self.measure(n));
+        let measured = measured.or(own.as_ref());
+        match measured.map(|m| m.bounds) {
+            Some(Some(b)) if !force && !rects_overlap(b.inflate(1.0, 1.0), page) => return,
+            Some(None) if !n.is_container() => return,
             _ => {}
         }
         self.warn_raster(&n.appearance.effects, || format!("{} objects", n.kind_label().to_lowercase()));
@@ -161,7 +202,9 @@ impl Exporter<'_> {
             pushes += 1;
         }
         match &n.kind {
-            NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => self.children(s, children, page),
+            NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => {
+                self.measured_children(s, children, page, measured.map_or(&[], |m| m.members.as_slice()));
+            }
             NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => {
                 // The region every output clips to; nothing to clip by hides the clipped art. The
                 // clipping path's fill paints behind the clipped art and its stroke over it, unclipped.
diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs
index f8df38500..eb9a4d284 100644
--- a/crates/pdf/src/tests.rs
+++ b/crates/pdf/src/tests.rs
@@ -30,6 +30,7 @@ mod layers;
 mod links;
 pub(super) mod live_text;
 mod marks;
+mod measuring;
 mod mesh_export;
 mod output;
 mod pdf13;
diff --git a/crates/pdf/src/tests/measuring.rs b/crates/pdf/src/tests/measuring.rs
new file mode 100644
index 000000000..1ed6af95e
--- /dev/null
+++ b/crates/pdf/src/tests/measuring.rs
@@ -0,0 +1,121 @@
+use std::sync::Arc;
+
+use vectorcraft_doc::{Knockout, Node, NodeId};
+
+use super::*;
+
+/// The objects measured to leave out what is off the page and to write links while `d` is exported
+/// (on this thread).
+fn measures(d: &Document) -> usize {
+    crate::export::MEASURES.with(|m| m.set(0));
+    export(d, &PdfOptions { created: Some(0), ..PdfOptions::default() }).expect("export");
+    crate::export::MEASURES.with(std::cell::Cell::get)
+}
+
+fn square(x: f64) -> Arc<Node> {
+    Arc::new(rect_node(Rect::new(x, 10.0, x + 20.0, 30.0), Color::rgb(0.2, 0.4, 0.6)))
+}
+
+/// An object in groups within a layer is measured once in an export, as an object directly in a
+/// layer is.
+#[test]
+fn an_object_in_nested_groups_is_measured_once() {
+    let mut d = doc(200.0, 200.0);
+    add(&mut d, (*square(10.0)).clone());
+    assert_eq!(measures(&d), 1);
+
+    let mut d = doc(200.0, 200.0);
+    let inner = Node::group(NodeId(0), vec![square(10.0), square(40.0)]);
+    add(&mut d, Node::group(NodeId(0), vec![Arc::new(inner), square(70.0)]));
+    assert_eq!(measures(&d), 3);
+}
+
+/// A group in PDF layers, where a layer's box is not used, is measured once as well.
+#[test]
+fn an_object_in_a_pdf_layer_is_measured_once() {
+    let mut d = doc(200.0, 200.0);
+    add(&mut d, Node::group(NodeId(0), vec![square(10.0), square(40.0)]));
+    let mut opts = PdfOptions { created: Some(0), ..PdfOptions::default() };
+    opts.settings.create_layers = true;
+    crate::export::MEASURES.with(|m| m.set(0));
+    export(&d, &opts).expect("export");
+    assert_eq!(crate::export::MEASURES.with(std::cell::Cell::get), 2);
+}
+
+/// The elements of a knockout group are measured for the group's box and to choose the elements
+/// on the page, and not again when each is drawn and when its mask is made.
+#[test]
+fn an_element_of_a_knockout_group_is_measured_twice() {
+    let mut d = doc(200.0, 200.0);
+    let mut group = Node::group(NodeId(0), vec![square(10.0), square(20.0)]);
+    group.knockout = Knockout::On;
+    add(&mut d, group);
+    assert_eq!(measures(&d), 4);
+}
+
+/// The links of a tree with no URLs and no clipping group are found without measuring: the export
+/// measures each object once, as the walk that leaves out what is off the page does.
+#[test]
+fn objects_without_a_url_are_not_measured_for_links() {
+    let mut d = doc(200.0, 200.0);
+    let inner = Node::group(NodeId(0), vec![square(10.0), square(40.0)]);
+    add(&mut d, Node::group(NodeId(0), vec![Arc::new(inner)]));
+    assert_eq!(measures(&d), 2);
+}
+
+/// Only an object with a URL that opens is measured for its link, and not the groups around it.
+#[test]
+fn only_an_object_with_a_url_is_measured_for_its_link() {
+    let mut linked = (*square(10.0)).clone();
+    linked.edit_attrs(|a| a.url = "https://example.com".into());
+    let mut refused = (*square(40.0)).clone();
+    refused.edit_attrs(|a| a.url = "javascript:alert(1)".into());
+    let mut d = doc(200.0, 200.0);
+    add(&mut d, Node::group(NodeId(0), vec![Arc::new(linked), Arc::new(refused)]));
+    assert_eq!(measures(&d), 3);
+}
+
+/// A clipping group is measured for the links inside it, and what it holds is not: the group for
+/// the page and for the links, then the clipping path's fill and the member when they are written.
+#[test]
+fn a_clipping_group_is_measured_for_the_links_inside_it() {
+    let mut clip = Node::group(NodeId(0), vec![square(10.0), square(15.0)]);
+    clip.set_clips(true);
+    let mut d = doc(200.0, 200.0);
+    add(&mut d, clip);
+    assert_eq!(measures(&d), 4);
+}
+
+/// A Shaper group's first member is left out of the group's box, and the boxes found by measuring
+/// the group belong to the members after it. An off-page first member is not written, and the
+/// member on the page is.
+#[test]
+fn a_member_left_out_of_the_group_box_measures_itself() {
+    let on_page = square(10.0);
+    let off_page = square(5000.0);
+
+    let mut shaped = doc(200.0, 200.0);
+    let mut group = Node::group(NodeId(0), vec![off_page, on_page.clone()]);
+    group.extras_mut().shaper = Some(Box::default());
+    add(&mut shaped, group);
+
+    let mut plain = doc(200.0, 200.0);
+    add(&mut plain, Node::group(NodeId(0), vec![on_page]));
+
+    assert_eq!(uncompressed(&shaped), uncompressed(&plain));
+}
+
+/// A group wholly off the page is not written, with the see-through empty group inside it.
+#[test]
+fn a_group_off_the_page_writes_nothing() {
+    let mut empty = Node::group(NodeId(0), vec![]);
+    empty.opacity = 0.5;
+    let mut off = doc(200.0, 200.0);
+    add(&mut off, (*square(10.0)).clone());
+    add(&mut off, Node::group(NodeId(0), vec![square(5000.0), Arc::new(empty)]));
+
+    let mut none = doc(200.0, 200.0);
+    add(&mut none, (*square(10.0)).clone());
+
+    assert_eq!(uncompressed(&off), uncompressed(&none));
+}
diff --git a/crates/render/src/fx/bounds.rs b/crates/render/src/fx/bounds.rs
index 86f04ffa5..8bccf2c36 100644
--- a/crates/render/src/fx/bounds.rs
+++ b/crates/render/src/fx/bounds.rs
@@ -136,6 +136,13 @@ fn shape_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
         members.iter().filter(|c| c.visible).fold(None, |acc, c| vectorcraft_geom::union_opt(acc, painted_reach(symbols, c)))
     };
     match &n.kind {
+        // A group's or layer's 3D effect: the art of its members' solids.
+        NodeKind::Layer { .. } | NodeKind::Group { clip: false, .. }
+            if effects::has_solid(n)
+                && let Some(art) = effects::solid_art(n) =>
+        {
+            drawn_bounds(symbols, &art)
+        }
         _ if effects::has_container_appearance(n) => {
             let art = effects::evaluate_container(Some(symbols.document()), n);
             let art = art.as_ref().unwrap_or(n);
diff --git a/crates/render/src/tests/objectfx.rs b/crates/render/src/tests/objectfx.rs
index edc044f0a..b6baab074 100644
--- a/crates/render/src/tests/objectfx.rs
+++ b/crates/render/src/tests/objectfx.rs
@@ -136,6 +136,38 @@ fn solid_effects_canvas_matches_baked_art_and_shades_their_faces() {
     }
 }
 
+/// #4506: a 3D effect on a group draws its members' solids on the canvas as the export does, and
+/// the group's drawn bounds (what a change redraws) hold all of them.
+#[test]
+fn solid_effects_on_a_group_draw_as_exported_within_their_drawn_bounds() {
+    for (effect, params) in [
+        ("threeD.extrude", json!({"depth": 30, "rotationX": -30, "rotationY": 40})),
+        ("threeD.inflate", json!({"depth": 10})),
+        ("threeD.rotate", json!({"rotationX": 0, "rotationY": 55, "rotationZ": 0})),
+    ] {
+        let square = |id: u64, x: f64, c: Color| {
+            Arc::new(Node::path(
+                NodeId(id),
+                shapes::rectangle(vectorcraft_geom::Rect::new(x, 35.0, x + 25.0, 60.0)),
+                Appearance::basic(Paint::solid(c), Paint::None, 0.0),
+            ))
+        };
+        let mut g = Node::group(NodeId(0), vec![square(10, 15.0, Color::rgb(0.9, 0.2, 0.1)), square(11, 60.0, Color::rgb(0.1, 0.3, 0.9))]);
+        g.appearance.effects.push(fx(effect, params));
+        let d = doc_with(Document::new(100.0, 100.0), g);
+        let live = render(&d);
+        let exported = render(&vectorcraft_effects::bake_document(&d).unwrap());
+        assert_eq!(live.pixels, exported.pixels, "{effect}: canvas and baked/exported faces agree");
+        let g = &d.layers[0].children().unwrap()[0];
+        let art = vectorcraft_effects::solid_art(g).unwrap().visual_bounds().unwrap();
+        let drawn = drawn_bounds(&d, g).unwrap();
+        assert_eq!(drawn.union(art), drawn, "{effect}: the drawn bounds hold the art");
+        let blues = live.pixels.as_chunks::<4>().0.iter().filter(|p| p[2] as u16 > p[0] as u16 * 2).count();
+        let reds = live.pixels.as_chunks::<4>().0.iter().filter(|p| p[0] as u16 > p[2] as u16 * 2).count();
+        assert!(blues > 100 && reds > 100, "{effect}: both members drawn ({reds} red, {blues} blue px)");
+    }
+}
+
 #[test]
 fn smooth_revolve_reduces_banding_without_changing_radial_resolution() {
     let path = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_svg("M70 20 L70 80").unwrap());
diff --git a/crates/svg/src/export/text.rs b/crates/svg/src/export/text.rs
index 01510cd0d..44af6c1ee 100644
--- a/crates/svg/src/export/text.rs
+++ b/crates/svg/src/export/text.rs
@@ -519,14 +519,24 @@ impl Writer<'_> {
         let space = (lay.bounds, self.xf * t.xf);
         let base = self.char_props(&t.first_style(), space);
         let mut props = base.clone();
-        match t.para_at(0).justify {
-            Justify::Center | Justify::JustifyCenter => props.push(("text-anchor", "middle".into())),
-            Justify::Right | Justify::JustifyRight => props.push(("text-anchor", "end".into())),
-            _ => {}
-        }
+        let (from, to) = t.kind.path_span().unwrap_or((start, 1.0));
+        // The anchor sits where the layout aligns the line within its span.
+        let at = match t.para_at(0).justify {
+            Justify::Center | Justify::JustifyCenter => {
+                props.push(("text-anchor", "middle".into()));
+                (from + to) / 2.0
+            }
+            Justify::Right | Justify::JustifyRight => {
+                props.push(("text-anchor", "end".into()));
+                to
+            }
+            _ => from,
+        };
+        // A closed path's span runs past its start point; `startOffset` can't, so wrap it.
+        let at = if at > 1.0 { at - 1.0 } else { at };
         props.extend(css::transparency(n));
         let a = self.attrs(&props);
-        let offset = fmt_num(start * 100.0, 3);
+        let offset = fmt_num(at * 100.0, 3);
         let mut s = format!("<text{id} xml:space=\"preserve\"{a}><textPath xlink:href=\"#{pid}\" startOffset=\"{offset}%\">");
         for run in &t.runs {
             let mut diff = run_diff(&base, self.char_props(&run.style, space));
diff --git a/crates/svg/tests/it/roundtrip.rs b/crates/svg/tests/it/roundtrip.rs
index fde9ff86f..25d0169c6 100644
--- a/crates/svg/tests/it/roundtrip.rs
+++ b/crates/svg/tests/it/roundtrip.rs
@@ -444,6 +444,40 @@ fn text_on_path_roundtrip() {
     assert!(close_rect(doc_path, PathData::from_bezpath(&curve).bounds().unwrap(), 0.01), "{doc_path:?}");
 }
 
+/// Centred and right-aligned type on a path anchors where the layout aligns it: the middle or the
+/// end of its span, wrapped on a closed path. It reads back drawn where it was.
+#[test]
+fn aligned_text_on_path_anchors_within_its_span() {
+    use vectorcraft_doc::Justify;
+    use vectorcraft_geom::Shape;
+    let mut curve = vectorcraft_geom::BezPath::new();
+    curve.move_to((20.0, 150.0));
+    curve.curve_to((60.0, 40.0), (140.0, 40.0), (180.0, 150.0));
+    let circle = vectorcraft_geom::kurbo::Circle::new((100.0, 100.0), 60.0).to_path(0.01);
+    let drawn = |t: &TextObject| t.xf.transform_rect_bbox(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).bounds);
+    for (path, start, justify, offset) in [
+        (&curve, 0.25, Justify::Center, "62.5%"),
+        (&curve, 0.25, Justify::Right, "100%"),
+        (&curve, 0.25, Justify::Left, "25%"),
+        (&circle, 0.7, Justify::Center, "20%"),
+    ] {
+        let mut d = Document::new(200.0, 200.0);
+        let mut t = TextObject::point(Point::ZERO, "Aligned", CharStyle { size: 14.0, ..CharStyle::default() });
+        t.kind = TextKind::OnPath { path: PathData::from_bezpath(path), start, end: None };
+        t.para.justify = justify;
+        let before = drawn(&t);
+        let id = d.alloc_id();
+        let d = doc_with(vec![Node::new(id, NodeKind::Text(Box::new(t)))]);
+        let svg = export(&d, &ExportOptions::default());
+        assert!(svg.contains(&format!("startOffset=\"{offset}\"")), "{justify:?} at {start}: {svg}");
+        if path == &curve {
+            let r = import(&svg).unwrap();
+            let NodeKind::Text(t) = &art(&r)[0].kind else { panic!() };
+            assert!(close_rect(drawn(t), before, 0.5), "{justify:?}: {:?} {before:?}", drawn(t));
+        }
+    }
+}
+
 /// An end bracket, Align to Path or Spacing, which `<textPath>` can't express, keep their look as
 /// outlines (#429).
 #[test]
diff --git a/crates/text/patterns/README.md b/crates/text/patterns/README.md
new file mode 100644
index 000000000..2a310e033
--- /dev/null
+++ b/crates/text/patterns/README.md
@@ -0,0 +1,29 @@
+# Indic hyphenation patterns
+
+The eleven `hyph-*.tex` files are unmodified upstream files from
+[hyphenation/tex-hyphen](https://github.com/hyphenation/tex-hyphen/tree/5684c0f51c0b81133db2efbe60a408b4155a3ff5/hyph-utf8/tex/generic/hyph-utf8/patterns/tex),
+pinned at commit `5684c0f51c0b81133db2efbe60a408b4155a3ff5`.
+
+Hindi, Marathi, Gujarati, Bengali, Punjabi (Gurmukhi), Tamil, Telugu, Kannada,
+Malayalam, Odia and Assamese: copyright (C) 2016 Santhosh Thottingal.
+VectorCraft uses these under their **MIT** license option; the full copyright
+and permission notice is preserved at the top of each file. The alternative
+LGPL/GPL licenses are not selected.
+
+Sanskrit remains selectable for shaping, but automatic hyphenation is pending
+an allowlisted source (#4947). The hyph-utf8 Sanskrit file's custom grant is
+outside the repository's license allowlist, as is the LPPL license of CTAN's
+older `sanhyph` package. Neither file is bundled. No language silently falls
+back to Hindi or English rules; explicit user exceptions remain available.
+
+The matcher reads only the contents of the TeX `\patterns{…}` block after
+removing comments. Odd maximum weights permit breaks and even weights forbid
+them (Liang patterns). Paragraph length limits count Unicode scalar values,
+as for the existing English implementation. Automatic points and preferences
+exceptions are restricted to whole Unicode graphemes and actual shaping
+cluster starts. Both composers consume the same points; their existing
+Hyphen Limit and Hyphenation Zone behavior applies.
+
+Breaks after viramas are conservatively suppressed, including Tamil pulli
+breaks permitted by the upstream patterns and Unicode grapheme segmentation.
+This preserves consonant clusters even when the font subdivides them.
diff --git a/crates/text/patterns/hyph-as.tex b/crates/text/patterns/hyph-as.tex
new file mode 100644
index 000000000..2e16711bd
--- /dev/null
+++ b/crates/text/patterns/hyph-as.tex
@@ -0,0 +1,142 @@
+% title: Hyphenation patterns for Assamese
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Assamese
+%     tag: as
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the "Software"), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: assamese
+%     message: Assamese hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+অ1
+আ1
+ই1
+ঈ1
+উ1
+ঊ1
+ঋ1
+ৠ1
+ঌ1
+ৡ1
+এ1
+ঐ1
+ও1
+ঔ1
+% Break after any dependent vowel, but not before.
+া1
+ি1
+ী1
+ু1
+ূ1
+ৃ1
+ৄ1
+ৢ1
+ৣ1
+ে1
+ৈ1
+ো1
+ৌ1
+2়2
+ৗ1
+% Break before or after any consonant.
+1ক
+1খ
+1গ
+1ঘ
+1ঙ
+1চ
+1ছ
+1জ
+1ঝ
+1ঞ
+1ট
+1ঠ
+1ড
+1ড়
+1ঢ
+1ঢ়
+1ণ
+1ত
+1থ
+1দ
+1ধ
+1ন
+1প
+1ফ
+1ব
+1ভ
+1ম
+1য
+1য়
+1র
+1ল
+1শ
+1ষ
+1স
+1হ
+% Do not break after khanda ta.
+ৎ1
+% Do not break before chandrabindu, anusvara, visarga, avagraha,
+% nukta and au length mark.
+2ঃ1
+2ং1
+2ঁ1
+2ঽ1
+% Do not break either side of virama (may be within conjunct).
+2্2
+}
diff --git a/crates/text/patterns/hyph-bn.tex b/crates/text/patterns/hyph-bn.tex
new file mode 100644
index 000000000..985a4eb1b
--- /dev/null
+++ b/crates/text/patterns/hyph-bn.tex
@@ -0,0 +1,142 @@
+% title: Hyphenation patterns for Bengali
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Bengali
+%     tag: bn
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the "Software"), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: bengali
+%     message: Bengali hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+অ1
+আ1
+ই1
+ঈ1
+উ1
+ঊ1
+ঋ1
+ৠ1
+ঌ1
+ৡ1
+এ1
+ঐ1
+ও1
+ঔ1
+% Break after any dependent vowel, but not before.
+া1
+ি1
+ী1
+ু1
+ূ1
+ৃ1
+ৄ1
+ৢ1
+ৣ1
+ে1
+ৈ1
+ো1
+ৌ1
+2়2
+ৗ1
+% Break before or after any consonant.
+1ক
+1খ
+1গ
+1ঘ
+1ঙ
+1চ
+1ছ
+1জ
+1ঝ
+1ঞ
+1ট
+1ঠ
+1ড
+1ড়
+1ঢ
+1ঢ়
+1ণ
+1ত
+1থ
+1দ
+1ধ
+1ন
+1প
+1ফ
+1ব
+1ভ
+1ম
+1য
+1য়
+1র
+1ল
+1শ
+1ষ
+1স
+1হ
+% Do not break after khanda ta.
+ৎ1
+% Do not break before chandrabindu, anusvara, visarga, avagraha,
+% nukta and au length mark.
+2ঃ1
+2ং1
+2ঁ1
+2ঽ1
+% Do not break either side of virama (may be within conjunct).
+2্2
+}
diff --git a/crates/text/patterns/hyph-gu.tex b/crates/text/patterns/hyph-gu.tex
new file mode 100644
index 000000000..df8f0d087
--- /dev/null
+++ b/crates/text/patterns/hyph-gu.tex
@@ -0,0 +1,135 @@
+% title: Hyphenation patterns for Gujarati
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Gujarati
+%     tag: gu
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the "Software"), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: gujarati
+%     message: Gujarati hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+અ1
+આ1
+ઇ1
+ઈ1
+ઉ1
+ઊ1
+ઋ1
+ૠ1
+એ1
+ઐ1
+ઓ1
+ઔ1
+% Break after any dependent vowel but not before.
+ા1
+િ1
+ી1
+ુ1
+ૂ1
+ૃ1
+ૄ1
+ૢ1
+ૣ1
+ે1
+ૈ1
+ો1
+ૌ1
+% Break before or after any consonant.
+1ક
+1ખ
+1ગ
+1ઘ
+1ઙ
+1ચ
+1છ
+1જ
+1ઝ
+1ઞ
+1ટ
+1ઠ
+1ડ
+1ઢ
+1ણ
+1ત
+1થ
+1દ
+1ધ
+1ન
+1પ
+1ફ
+1બ
+1ભ
+1મ
+1ય
+1ર
+1લ
+1ળ
+1વ
+1શ
+1ષ
+1સ
+1હ
+% Do not break before chandrabindu, anusvara, visarga, avagraha
+% and accents.
+2ઁ1
+2ઃ1
+2ઽ1
+% Do not break either side of virama (may be within conjunct).
+2્2
+2ં2
+}
diff --git a/crates/text/patterns/hyph-hi.tex b/crates/text/patterns/hyph-hi.tex
new file mode 100644
index 000000000..435f434f1
--- /dev/null
+++ b/crates/text/patterns/hyph-hi.tex
@@ -0,0 +1,139 @@
+% title: Hyphenation patterns for Hindi
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Hindi
+%     tag: hi
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the "Software"), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: hindi
+%     message: Hindi hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+अ1
+आ1
+इ1
+ई1
+उ1
+ऊ1
+ऋ1
+ॠ1
+ऌ1
+ॡ1
+ए1
+ऐ1
+ओ1
+औ1
+% Break after any dependent vowel but not before.
+ा1
+ि1
+ी1
+ु1
+ू1
+ृ1
+ॄ1
+ॢ1
+ॣ1
+े1
+ै1
+ो1
+ौ1
+% Break before or after any consonant.
+1क
+1ख
+1ग
+1घ
+1ङ
+1च
+1छ
+1ज
+1झ
+1ञ
+1ट
+1ठ
+1ड
+1ढ
+1ण
+1त
+1थ
+1द
+1ध
+1न
+1प
+1फ
+1ब
+1भ
+1म
+1य
+1र
+1ल
+1ळ
+1व
+1श
+1ष
+1स
+1ह
+% Do not break before chandrabindu, anusvara, visarga, avagraha
+% and accents.
+2ँ1
+2ं1
+2ः1
+2ऽ1
+2॑1
+2॒1
+% Do not break either side of virama (may be within conjunct).
+2्2
+}
diff --git a/crates/text/patterns/hyph-kn.tex b/crates/text/patterns/hyph-kn.tex
new file mode 100644
index 000000000..5b2ba9831
--- /dev/null
+++ b/crates/text/patterns/hyph-kn.tex
@@ -0,0 +1,142 @@
+% title: Hyphenation patterns for Kannada
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Kannada
+%     tag: kn
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the "Software"), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: kannada
+%     message: Kannada hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+ಅ1
+ಆ1
+ಇ1
+ಈ1
+ಉ1
+ಊ1
+ಋ1
+ೠ1
+ಌ1
+ೡ1
+ಎ1
+ಏ1
+ಐ1
+ಒ1
+ಓ1
+ಔ1
+% Break after any dependent vowel, but not before.
+ಾ1
+ಿ1
+ೀ1
+ು1
+ೂ1
+ೃ1
+ೄ1
+ೆ1
+ೇ1
+ೈ1
+ೊ1
+ೋ1
+ೌ1
+% Break before or after any consonant.
+1ಕ
+1ಖ
+1ಗ
+1ಘ
+1ಙ
+1ಚ
+1ಛ
+1ಜ
+1ಝ
+1ಞ
+1ಟ
+1ಠ
+1ಡ
+1ಢ
+1ಣ
+1ತ
+1ಥ
+1ದ
+1ಧ
+1ನ
+1ಪ
+1ಫ
+1ಬ
+1ಭ
+1ಮ
+1ಯ
+1ರ
+1ಱ
+1ಲ
+1ಳ
+1ೞ
+1ವ
+1ಶ
+1ಷ
+1ಸ
+1ಹ
+% Do not break before anusvara, visarga, avagraha,
+% length mark and ai length mark.
+2ಂ1
+2ಃ1
+2ಽ1
+2ೕ1
+2ೖ1
+% Do not break either side of virama (may be within conjunct).
+2್2
+}
diff --git a/crates/text/patterns/hyph-ml.tex b/crates/text/patterns/hyph-ml.tex
new file mode 100644
index 000000000..b34499500
--- /dev/null
+++ b/crates/text/patterns/hyph-ml.tex
@@ -0,0 +1,157 @@
+% title: Hyphenation patterns for Malayalam
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Malayalam
+%     tag: ml
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the "Software"), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: malayalam
+%     message: Malayalam hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+1അ1
+1ആ1
+1ഇ1
+1ഈ1
+1ഉ1
+1ഊ1
+1ഋ1
+1ൠ1
+1ഌ1
+1ൡ1
+1എ1
+1ഏ1
+1ഐ1
+1ഒ1
+1ഓ1
+1ഔ1
+% Break after any dependent vowel, but not before.
+ാ1
+ി1
+ീ1
+ു1
+ൂ1
+ൃ1
+െ1
+േ1
+ൈ1
+ൊ1
+ോ1
+ൌ1
+ൗ1
+% Break before or after any consonant.
+1ക
+1ഖ
+1ഗ
+1ഘ
+1ങ
+1ച
+1ഛ
+1ജ
+1ഝ
+1ഞ
+1ട
+1ഠ
+1ഡ
+1ഢ
+1ണ
+1ത
+1ഥ
+1ദ
+1ധ
+1ന
+1പ
+1ഫ
+1ബ
+1ഭ
+1മ
+1യ
+1ര
+1റ
+1ല
+1ള
+1ഴ
+1വ
+1ശ
+1ഷ
+1സ
+1ഹ
+% Do not break before anusvara, visarga
+2ഃ1
+2ം1
+% Do not break either side of virama (may be within conjunct).
+2്2
+% Do not break left side of chillu
+ന്2
+ര്2
+ള്2
+ല്2
+ക്2
+ണ്2
+2ന്‍
+2ല്‍
+2ള്‍
+2ണ്‍
+2ര്‍
+2ക്‍
+2ൺ
+2ൻ
+2ർ
+2ൽ
+2ൾ
+2ൿ
+}
diff --git a/crates/text/patterns/hyph-mr.tex b/crates/text/patterns/hyph-mr.tex
new file mode 100644
index 000000000..8f3c5675d
--- /dev/null
+++ b/crates/text/patterns/hyph-mr.tex
@@ -0,0 +1,139 @@
+% title: Hyphenation patterns for Marathi
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Marathi
+%     tag: mr
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences, at your option:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the "Software"), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: marathi
+%     message: Marathi hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+अ1
+आ1
+इ1
+ई1
+उ1
+ऊ1
+ऋ1
+ॠ1
+ऌ1
+ॡ1
+ए1
+ऐ1
+ओ1
+औ1
+% Break after any dependent vowel but not before.
+ा1
+ि1
+ी1
+ु1
+ू1
+ृ1
+ॄ1
+ॢ1
+ॣ1
+े1
+ै1
+ो1
+ौ1
+% Break before or after any consonant.
+1क
+1ख
+1ग
+1घ
+1ङ
+1च
+1छ
+1ज
+1झ
+1ञ
+1ट
+1ठ
+1ड
+1ढ
+1ण
+1त
+1थ
+1द
+1ध
+1न
+1प
+1फ
+1ब
+1भ
+1म
+1य
+1र
+1ल
+1ळ
+1व
+1श
+1ष
+1स
+1ह
+% Do not break before chandrabindu, anusvara, visarga, avagraha
+% and accents.
+2ँ1
+2ं1
+2ः1
+2ऽ1
+2॑1
+2॒1
+% Do not break either side of virama (may be within conjunct).
+2्2
+}
diff --git a/crates/text/patterns/hyph-or.tex b/crates/text/patterns/hyph-or.tex
new file mode 100644
index 000000000..a601e2a9f
--- /dev/null
+++ b/crates/text/patterns/hyph-or.tex
@@ -0,0 +1,133 @@
+% title: Hyphenation patterns for Oriya
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Odia, Oriya
+%     tag: or
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the “Software”), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: oriya
+%     message: Oriya hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+ଅ1
+ଆ1
+ଇ1
+ଈ1
+ଉ1
+ଊ1
+ଋ1
+ୠ1
+ଌ1
+ୡ1
+ଏ1
+ଐ1
+ଓ1
+ଔ1
+% Break after any dependent vowel, but not before.
+ା1
+ି1
+ୀ1
+ୁ1
+ୂ1
+ୃ1
+େ1
+ୈ1
+ୋ1
+ୌ1
+% Break before or after any consonant.
+1କ
+1ଖ
+1ଗ
+1ଘ
+1ଙ
+1ଚ
+1ଛ
+1ଜ
+1ଝ
+1ଞ
+1ଟ
+1ଠ
+1ଡ
+1ଢ
+1ଣ
+1ତ
+1ଥ
+1ଦ
+1ଧ
+1ନ
+1ପ
+1ଫ
+1ବ
+1ଭ
+1ମ
+1ଯ
+1ର
+1ଲ
+1ଳ
+1ଵ
+1ଶ
+1ଷ
+1ସ
+1ହ
+% Do not break before anusvara, visarga and length mark.
+2ଂ1
+2ଃ1
+2ୗ1
+2ଁ1
+% Do not break either side of virama (may be within conjunct).
+2୍2
+}
diff --git a/crates/text/patterns/hyph-pa.tex b/crates/text/patterns/hyph-pa.tex
new file mode 100644
index 000000000..56476383a
--- /dev/null
+++ b/crates/text/patterns/hyph-pa.tex
@@ -0,0 +1,129 @@
+% title: Hyphenation patterns for Panjabi
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Panjabi, Punjabi
+%     tag: pa
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the “Software”), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: panjabi
+%     message: Panjabi hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+ਅ1
+ਆ1
+ਇ1
+ਈ1
+ਉ1
+ਊ1
+ਏ1
+ਐ1
+ਓ1
+ਔ1
+% Break after any dependent vowel but not before.
+ਾ1
+ਿ1
+ੀ1
+ੁ1
+ੂ1
+ੇ1
+ੈ1
+ੋ1
+ੌ1
+% Break before or after any consonant.
+1ਕ
+1ਖ
+1ਗ
+1ਘ
+1ਙ
+1ਚ
+1ਛ
+1ਜ
+1ਝ
+1ਞ
+1ਟ
+1ਠ
+1ਡ
+1ਢ
+1ਣ
+1ਤ
+1ਥ
+1ਦ
+1ਧ
+1ਨ
+1ਪ
+1ਫ
+1ਬ
+1ਭ
+1ਮ
+1ਯ
+1ਰ
+1ਲ
+1ਲ਼
+1ਵ
+1ਸ਼
+1ਸ
+1ਹ
+% Do not break before chandrabindu, anusvara, visarga, avagraha
+% and accents.
+2ਁ1
+2ਂ1
+2ਃ1
+% Do not break either side of virama (may be within conjunct).
+2੍2
+2ੰ2
+2ੱ2
+}
diff --git a/crates/text/patterns/hyph-ta.tex b/crates/text/patterns/hyph-ta.tex
new file mode 100644
index 000000000..54f0d4374
--- /dev/null
+++ b/crates/text/patterns/hyph-ta.tex
@@ -0,0 +1,140 @@
+% title: Hyphenation patterns for Tamil
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Tamil
+%     tag: ta
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the "Software"), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: tamil
+%     message: Tamil hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+1அ1
+1ஆ1
+1இ1
+1ஈ1
+1உ1
+1ஊ1
+1எ1
+1ஏ1
+1ஐ1
+1ஒ1
+1ஓ1
+1ஔ1
+% Break after any dependent vowel, but not before.
+ா1
+ி1
+ீ1
+ு1
+ூ1
+ெ1
+ே1
+ை1
+ொ1
+ோ1
+ௌ1
+% Break before or after any consonant.
+1க
+1ங
+1ச
+1ஜ
+1ஞ
+1ட
+1ண
+1த
+1ந
+1ப
+1ம
+1ய
+1ர
+1ற
+1ல
+1ள
+1ழ
+1வ
+1ஷ
+1ஸ
+1ஹ
+% Do not break before any consonant + virama.
+2க்1
+2ங்1
+2ச்1
+2ஞ்1
+2ட்1
+2ண்1
+2த்1
+2ன்1
+2ந்1
+2ப்1
+2ம்1
+2ய்1
+2ர்1
+2ற்1
+2ல்1
+2ள்1
+2ழ்1
+2வ்1
+2ஷ்1
+2ஸ்1
+2ஹ்1
+% Do not break before anusvara, visarga and length mark.
+2ஂ1
+2ஃ1
+2ௗ1
+% Do not break before virama but break after virama.
+2்1
+}
diff --git a/crates/text/patterns/hyph-te.tex b/crates/text/patterns/hyph-te.tex
new file mode 100644
index 000000000..e12228bda
--- /dev/null
+++ b/crates/text/patterns/hyph-te.tex
@@ -0,0 +1,141 @@
+% title: Hyphenation patterns for Telugu
+% copyright: Copyright (C) 2016 Santhosh Thottingal
+% notice: This file is part of the hyph-utf8 package.
+%     See http://www.hyphenation.org/tex for more information.
+% source: https://github.com/santhoshtr/hyphenation/
+% language:
+%     name: Telugu
+%     tag: te
+% version: 0.9.0 2016-01-16
+% authors:
+%   -
+%     name: Santhosh Thottingal
+%     contact: santhosh.thottingal (at) gmail.com
+% licence:
+%     - This file is available under any of the following licences:
+%     -
+%         name: MIT
+%         url: https://opensource.org/licenses/MIT
+%         text: >
+%             Permission is hereby granted, free of charge, to any person
+%             obtaining a copy of this software and associated documentation
+%             files (the "Software"), to deal in the Software without
+%             restriction, including without limitation the rights to use,
+%             copy, modify, merge, publish, distribute, sublicense, and/or sell
+%             copies of the Software, and to permit persons to whom the
+%             Software is furnished to do so, subject to the following
+%             conditions:
+%
+%             The above copyright notice and this permission notice shall be
+%             included in all copies or substantial portions of the Software.
+%
+%             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%             OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%             NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%             HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%             WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%             FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%             OTHER DEALINGS IN THE SOFTWARE.
+%     -
+%         name: LGPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/lgpl.html
+%     -
+%         name: GPL
+%         version: 3
+%         or_later: true
+%         url: http://www.gnu.org/licenses/gpl.html
+% hyphenmins:
+%     generation:
+%         left: 1
+%         right: 1
+% texlive:
+%     babelname: telugu
+%     message: Telugu hyphenation patterns
+%     package: indic
+%
+\patterns{
+% GENERAL RULE
+% Do not break either side of ZERO-WIDTH JOINER  (U+200D)
+2‍2
+% Break on both sides of ZERO-WIDTH NON JOINER  (U+200C)
+1‌1
+% Break before or after any independent vowel.
+అ1
+ఆ1
+ఇ1
+ఈ1
+ఉ1
+ఊ1
+ఋ1
+ౠ1
+ఌ1
+ౡ1
+ఎ1
+ఏ1
+ఐ1
+ఒ1
+ఓ1
+ఔ1
+% Break after any dependent vowel, but not before.
+ా1
+ి1
+ీ1
+ు1
+ూ1
+ృ1
+ౄ1
+ె1
+ే1
+ై1
+ొ1
+ో1
+ౌ1
+% Break before or after any consonant.
+1క
+1ఖ
+1గ
+1ఘ
+1ఙ
+1చ
+1ఛ
+1జ
+1ఝ
+1ఞ
+1ట
+1ఠ
+1డ
+1ఢ
+1ణ
+1త
+1థ
+1ద
+1ధ
+1న
+1ప
+1ఫ
+1బ
+1భ
+1మ
+1య
+1ర
+1ఱ
+1ల
+1ళ
+1వ
+1శ
+1ష
+1స
+1హ
+% Do not break before chandrabindu, anusvara, visarga,
+% length mark and ai length mark.
+2ఁ1
+2ం1
+2ః1
+2ౕ1
+2ౖ1
+% Do not break either side of virama (may be within conjunct).
+2్2
+}
diff --git a/crates/text/src/features.rs b/crates/text/src/features.rs
index eac3b3c3f..ddf9e5a03 100644
--- a/crates/text/src/features.rs
+++ b/crates/text/src/features.rs
@@ -391,6 +391,29 @@ mod tests {
         assert_eq!(per_run, [2, 1]);
     }
 
+    /// Bulgarian text gets the font's Bulgarian forms (`locl` for `BGR`, #5945): in the bundled
+    /// Source Sans 3 Italic, в, д, ж, з, к, л and ю differ from the Russian ones, and letters
+    /// the font draws alike stay alike.
+    #[test]
+    fn bulgarian_gets_the_fonts_bulgarian_forms() {
+        let st = |language: &str| CharStyle {
+            font_family: "Source Sans 3".into(),
+            font_style: "Italic".into(),
+            language: Some(language.to_string()),
+            ..Default::default()
+        };
+        // Each letter laid out on its own, so one letter's advance doesn't move the next.
+        let outline = |c: char, language| {
+            layout(FontDb::global(), &TextObject::point(Point::ZERO, &c.to_string(), st(language)))
+                .glyphs
+                .into_iter()
+                .map(|g| g.outline)
+                .collect::<Vec<_>>()
+        };
+        let differs: String = "вгджзийклптцшщюьъ".chars().filter(|c| outline(*c, "bg") != outline(*c, "ru")).collect();
+        assert_eq!(differs, "вджзклю");
+    }
+
     /// Serbian text gets the font's Serbian forms (`locl` for `SRB`): in the bundled Source Sans
     /// 3 Italic, б, г, д, п, т differ from the Russian ones, in either Serbian list entry.
     #[test]
diff --git a/crates/text/src/fontdb/build.rs b/crates/text/src/fontdb/build.rs
index ba91aa999..40bcb1df1 100644
--- a/crates/text/src/fontdb/build.rs
+++ b/crates/text/src/fontdb/build.rs
@@ -72,6 +72,7 @@ pub(super) fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Opt
         bytes,
         index,
         path,
+        plans: std::sync::Mutex::new(Vec::new()),
         ideographic_centre: std::sync::OnceLock::new(),
         icf_margins: std::sync::OnceLock::new(),
         colour_bitmaps,
diff --git a/crates/text/src/fontdb/face.rs b/crates/text/src/fontdb/face.rs
index 382b96da2..5ab31eeae 100644
--- a/crates/text/src/fontdb/face.rs
+++ b/crates/text/src/fontdb/face.rs
@@ -98,6 +98,9 @@ pub(super) const MAX_AXES: usize = 64;
 
 pub(super) const MAX_INSTANCES: usize = 512;
 
+/// The most shaping plans a face keeps ([`FontFace::shape_plan`]); past it the oldest is dropped.
+const MAX_PLANS: usize = 32;
+
 /// One axis of a variable font's design space, as its `fvar` table lists it: the tag (`wght`), its
 /// name in the font's name table (`Weight`; the tag when it has none) and its range and default,
 /// in the axis's own units.
@@ -184,6 +187,8 @@ pub struct FontFace {
     pub(super) location: Location,
     /// [`Self::variations`] for the shaper (advances, kerning, feature variations).
     pub(crate) instance: Option<harfrust::ShaperInstance>,
+    /// The shaping plans made for this face, newest last ([`Self::shape_plan`]).
+    pub(super) plans: std::sync::Mutex<Vec<Arc<harfrust::ShapePlan>>>,
     /// [`Self::ideographic_centre`], read once: layout asks for it per glyph.
     pub(super) ideographic_centre: std::sync::OnceLock<f64>,
     /// [`Self::icf_margins`], read once.
@@ -226,6 +231,45 @@ impl FontFace {
     pub(crate) fn hb(&self) -> Option<harfrust::FontRef<'_>> {
         harfrust::FontRef::from_index(self.data(), self.index).ok()
     }
+    /// The shaping plan for a buffer of `direction`, `script` and `language` shaped with
+    /// `features` by `shaper` (made from this face at [`Self::instance`]): the plan made earlier for
+    /// the same properties, else a new one, which the face keeps for later (at most [`MAX_PLANS`]).
+    /// A plan depends on these properties alone, so text shaped with it comes out as with a plan
+    /// made for it.
+    pub(crate) fn shape_plan(
+        &self,
+        shaper: &harfrust::Shaper<'_>,
+        direction: harfrust::Direction,
+        script: Option<harfrust::Script>,
+        language: Option<&harfrust::Language>,
+        features: &[harfrust::Feature],
+    ) -> Arc<harfrust::ShapePlan> {
+        #[cfg(any(test, feature = "test-fonts"))]
+        if !crate::test_fonts::keeps_shape_plans() {
+            return Arc::new(harfrust::ShapePlan::new(shaper, direction, script, language, features));
+        }
+        let key = harfrust::ShapePlanKey::new(script, direction).language(language).instance(self.instance.as_ref()).features(features);
+        let kept = |plans: &[Arc<harfrust::ShapePlan>]| plans.iter().rev().find(|p| key.matches(p)).cloned();
+        if let Some(plan) = kept(&self.plans.lock().unwrap_or_else(|e| e.into_inner())) {
+            return plan;
+        }
+        // Made without the lock held: other threads keep shaping with this face meanwhile.
+        let plan = Arc::new(harfrust::ShapePlan::new(shaper, direction, script, language, features));
+        let mut plans = self.plans.lock().unwrap_or_else(|e| e.into_inner());
+        if let Some(made) = kept(&plans) {
+            return made;
+        }
+        if plans.len() >= MAX_PLANS {
+            plans.remove(0);
+        }
+        plans.push(plan.clone());
+        plan
+    }
+    /// Tests: how many shaping plans the face holds.
+    #[cfg(test)]
+    pub(crate) fn plans_kept(&self) -> usize {
+        self.plans.lock().unwrap_or_else(|e| e.into_inner()).len()
+    }
     /// The face's index in its font file (collections hold several).
     pub(crate) fn index(&self) -> u32 {
         self.index
diff --git a/crates/text/src/hyphen.rs b/crates/text/src/hyphen.rs
index bcf758706..adb3a62bf 100644
--- a/crates/text/src/hyphen.rs
+++ b/crates/text/src/hyphen.rs
@@ -8,16 +8,44 @@
 //! `typography` never breaks, `ty-pog-ra-phy` breaks only where the hyphens mark. See
 //! [`set_hyphenation_exceptions`].
 //!
-//! Each run hyphenates in its own language ([`vectorcraft_doc::CharStyle::language`]). English is
-//! the only language with break points so far: text in any other language, or in a language a
-//! file names that isn't known, doesn't hyphenate, apart from the words in the Exceptions list
-//! ([`language_has_patterns`]).
+//! Each run hyphenates in its own language ([`vectorcraft_doc::CharStyle::language`]). English
+//! uses the rules above; eleven Indian languages use bundled hyph-utf8 patterns. Other languages
+//! only break at user exceptions. Indic breaks always preserve Unicode grapheme boundaries.
 
 use std::collections::HashMap;
 use std::sync::{Mutex, MutexGuard, OnceLock};
 
 use vectorcraft_doc::HyphenationOptions;
 
+mod indic;
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum Language {
+    None,
+    English,
+    Indic(u8),
+}
+
+impl Language {
+    /// Select rules by the primary BCP 47 subtag; absent tags retain the English default.
+    pub(crate) fn from_tag(tag: Option<&str>) -> Self {
+        let primary = tag.unwrap_or("en").split('-').next().unwrap_or_default();
+        if primary.eq_ignore_ascii_case("en") {
+            Self::English
+        } else {
+            indic::TAGS.iter().position(|t| primary.eq_ignore_ascii_case(t)).and_then(|i| u8::try_from(i).ok()).map_or(Self::None, Self::Indic)
+        }
+    }
+}
+
+/// Keep combining marks and joiners in the same hyphenation word as their letters.
+pub(crate) fn is_word_char(ch: char) -> bool {
+    use unicode_general_category::{GeneralCategory, get_general_category};
+    ch.is_alphabetic()
+        || matches!(ch, '\'' | '’' | '\u{200c}' | '\u{200d}')
+        || matches!(get_general_category(ch), GeneralCategory::NonspacingMark | GeneralCategory::SpacingMark | GeneralCategory::EnclosingMark)
+}
+
 /// Only words at least this long are hyphenated (Illustrator's default: longer than 5 letters).
 pub const MIN_WORD: usize = 6;
 pub const MIN_BEFORE: usize = 3;
@@ -152,7 +180,13 @@ fn onset_pair(a: char, b: char) -> bool {
 /// Whether text in `language` (a [`vectorcraft_doc::CharStyle::language`]: a BCP 47 tag, `None` for
 /// the default, English: USA) has break points of its own.
 pub fn language_has_patterns(language: Option<&str>) -> bool {
-    language.is_none_or(|l| l.get(..2).is_some_and(|p| p.eq_ignore_ascii_case("en")) && matches!(l.as_bytes().get(2), None | Some(b'-')))
+    !matches!(Language::from_tag(language), Language::None)
+}
+
+/// Language-specific break points as character indices. Indic patterns and exceptions are
+/// filtered to whole graphemes; the paragraph's length options count Unicode characters.
+pub fn hyphen_points_for_language(word: &str, opts: &HyphenationOptions, language: Option<&str>) -> Vec<usize> {
+    points_for(word, opts, Language::from_tag(language))
 }
 
 /// Allowed hyphenation points in `word`, as char indices (a hyphen goes *before* the char), with
@@ -171,22 +205,31 @@ pub fn hyphen_points_with(word: &str, opts: &HyphenationOptions) -> Vec<usize> {
     hyphen_points_in(word, opts, true)
 }
 
-/// [`hyphen_points_with`] for a word in a language with or without break points of its own
-/// ([`language_has_patterns`]): without them, only a word in the Exceptions list breaks.
+/// Compatibility helper selecting English rules (`true`) or exceptions only (`false`).
+/// Use [`hyphen_points_for_language`] to select Indic patterns by language tag.
 pub fn hyphen_points_in(word: &str, opts: &HyphenationOptions, patterns: bool) -> Vec<usize> {
+    points_for(word, opts, if patterns { Language::English } else { Language::None })
+}
+
+/// Apply exceptions first, then language rules and paragraph limits, protecting Indic clusters.
+pub(crate) fn points_for(word: &str, opts: &HyphenationOptions, language: Language) -> Vec<usize> {
     if let Some(ex) = exception_for(word) {
-        return match ex {
+        let mut points = match ex {
             Exception::Never => vec![],
             Exception::Only(pts) => lowercase_points_to_word(word, &pts),
         };
+        if matches!(language, Language::Indic(_)) {
+            indic::retain_boundaries(word, &mut points);
+        }
+        return points;
     }
-    if !patterns {
+    if matches!(language, Language::None) {
         return vec![];
     }
     let c: Vec<char> = word.chars().collect();
     let n = c.len();
     let longer_than = usize::try_from(opts.words_longer_than).unwrap_or(usize::MAX);
-    if n <= longer_than || !c.iter().all(|c| c.is_alphabetic() || matches!(c, '\'' | '’')) {
+    if n <= longer_than || !c.iter().all(|&ch| is_word_char(ch)) {
         return vec![];
     }
     // A capitalised run like "NASA" or a proper name stays whole only when all caps.
@@ -198,6 +241,12 @@ pub fn hyphen_points_in(word: &str, opts: &HyphenationOptions, patterns: bool) -
     }
     let before = usize::try_from(opts.after_first).unwrap_or(usize::MAX).max(1);
     let after = usize::try_from(opts.before_last).unwrap_or(usize::MAX).max(1);
+    if let Language::Indic(index) = language {
+        let mut points = indic::points(word, usize::from(index));
+        points.retain(|p| *p >= before && n.saturating_sub(*p) >= after);
+        indic::retain_boundaries(word, &mut points);
+        return points;
+    }
     let v: Vec<bool> = c.iter().map(|&x| is_vowel(x)).collect();
     let mut out = vec![];
     for i in before..=n.saturating_sub(after) {
@@ -255,16 +304,103 @@ mod tests {
         with_hyphenation_exceptions_for_test(source, f);
     }
 
-    /// #394: English in any region has break points; other languages, and a tag from a file that
-    /// isn't a known language, have none.
+    /// English and Indic languages accept regional tags; unknown languages have no patterns.
     #[test]
-    fn only_english_has_break_points() {
+    fn supported_languages_have_break_points() {
         for l in [None, Some("en-US"), Some("en-GB"), Some("EN-gb"), Some("en")] {
             assert!(language_has_patterns(l), "{l:?}");
         }
         for l in [Some("de"), Some("fr"), Some("pt"), Some("eng"), Some("x-unknown"), Some(""), Some("é")] {
             assert!(!language_has_patterns(l), "{l:?}");
         }
+        for tag in indic::TAGS {
+            assert!(language_has_patterns(Some(tag)));
+            assert!(language_has_patterns(Some(&format!("{}-IN", tag.to_uppercase()))));
+        }
+    }
+
+    /// Every bundled language preserves vowel-sign syllables and applies length/margin limits.
+    #[test]
+    fn indic_patterns_preserve_syllables_and_respect_options() {
+        let opts = HyphenationOptions { words_longer_than: 0, after_first: 1, before_last: 1, ..Default::default() };
+        for (tag, syllable) in [
+            ("hi", "कि"),
+            ("mr", "कि"),
+            ("gu", "કિ"),
+            ("bn", "কি"),
+            ("pa", "ਕਿ"),
+            ("ta", "கி"),
+            ("te", "కి"),
+            ("kn", "ಕಿ"),
+            ("ml", "കി"),
+            ("or", "କି"),
+            ("as", "কি"),
+        ] {
+            let word = syllable.repeat(4);
+            let points = hyphen_points_for_language(&word, &opts, Some(tag));
+            assert_eq!(points, vec![2, 4, 6], "{tag}: {word}");
+            assert_eq!(hyphen_points_for_language(&word, &opts, Some(&format!("{}-IN", tag.to_uppercase()))), points);
+            let longer = HyphenationOptions { words_longer_than: 8, ..opts.clone() };
+            assert!(hyphen_points_for_language(&word, &longer, Some(tag)).is_empty());
+            let margins = HyphenationOptions { after_first: 3, before_last: 3, ..opts.clone() };
+            assert_eq!(hyphen_points_for_language(&word, &margins, Some(tag)), vec![4]);
+            assert!(hyphen_points_for_language(&word, &opts, Some("zz")).is_empty());
+        }
+    }
+
+    /// Automatic points and explicit exceptions cannot split a conjunct or attached mark.
+    #[test]
+    fn indic_conjuncts_marks_joiners_and_exceptions_stay_whole() {
+        use unicode_segmentation::UnicodeSegmentation;
+        let opts = HyphenationOptions { words_longer_than: 0, after_first: 1, before_last: 1, ..Default::default() };
+        for (tag, conjunct) in [
+            ("hi", "क्षि"),
+            ("mr", "क्षि"),
+            ("gu", "ક્ષિ"),
+            ("bn", "ক্ষি"),
+            ("pa", "ਕ੍ਕਿ"),
+            ("ta", "க்கி"),
+            ("te", "క్షి"),
+            ("kn", "ಕ್ಷಿ"),
+            ("ml", "ക്ഷി"),
+            ("or", "କ୍ଷି"),
+            ("as", "ক্ষি"),
+        ] {
+            let points = hyphen_points_for_language(&conjunct.repeat(3), &opts, Some(tag));
+            if tag == "ta" {
+                // Tamil patterns permit breaks after pulli, and prohibit the other boundaries
+                // in this synthetic word. The conservative conjunct guard drops those breaks.
+                assert!(points.is_empty(), "{tag}: {conjunct}: {points:?}");
+            } else {
+                assert_eq!(points, vec![4, 8], "{tag}: {conjunct}");
+            }
+        }
+        for word in ["अक्षरअक्षर", "क्\u{200d}षक्\u{200d}ष", "क्\u{200c}षक्\u{200c}ष", "किंकिंकिं", "क़िक़िक़ि", "কিকিকি", "किकि123कि"]
+        {
+            let points = hyphen_points_for_language(word, &opts, Some("hi"));
+            let boundaries: Vec<_> = word.grapheme_indices(true).map(|(b, _)| word[..b].chars().count()).collect();
+            assert!(points.iter().all(|p| boundaries.contains(p)), "{word}: {points:?}");
+        }
+        with_exceptions("क-ि-क्-ष-क-ि", || {
+            assert_eq!(hyphen_points_for_language("किक्षकि", &opts, Some("hi")), vec![2, 5]);
+        });
+        with_exceptions("किकिकिकि", || {
+            assert!(hyphen_points_for_language("किकिकिकि", &opts, Some("hi")).is_empty());
+        });
+    }
+
+    /// Sanskrit stays selectable but has no automatic rules until allowlisted patterns exist.
+    #[test]
+    fn sanskrit_without_allowlisted_patterns_uses_only_exceptions() {
+        let opts = HyphenationOptions { words_longer_than: 0, after_first: 1, before_last: 1, ..Default::default() };
+        for tag in ["sa", "SA-IN", "sa-Deva", "sa-Latn"] {
+            assert!(!language_has_patterns(Some(tag)), "{tag}");
+            assert!(hyphen_points_for_language("किकिकिकि", &opts, Some(tag)).is_empty());
+            assert!(hyphen_points_for_language("typography", &opts, Some(tag)).is_empty(), "no English fallback");
+        }
+        with_exceptions("कि-किकिकि", || {
+            assert_eq!(hyphen_points_for_language("किकिकिकि", &opts, Some("sa")), vec![2]);
+        });
     }
 
     /// #394: a language without break points leaves words whole, but the Exceptions list is the
diff --git a/crates/text/src/hyphen/indic.rs b/crates/text/src/hyphen/indic.rs
new file mode 100644
index 000000000..ea8b577ce
--- /dev/null
+++ b/crates/text/src/hyphen/indic.rs
@@ -0,0 +1,123 @@
+//! Liang pattern matching for the bundled hyph-utf8 Indic patterns. Provenance and licenses:
+//! `crates/text/patterns/README.md`. Only bundled, trusted pattern data is parsed.
+use std::collections::BTreeMap;
+use std::sync::OnceLock;
+use unicode_segmentation::UnicodeSegmentation;
+
+pub(super) const TAGS: [&str; 11] = ["hi", "mr", "gu", "bn", "pa", "ta", "te", "kn", "ml", "or", "as"];
+const SOURCES: [&str; 11] = [
+    include_str!("../../patterns/hyph-hi.tex"),
+    include_str!("../../patterns/hyph-mr.tex"),
+    include_str!("../../patterns/hyph-gu.tex"),
+    include_str!("../../patterns/hyph-bn.tex"),
+    include_str!("../../patterns/hyph-pa.tex"),
+    include_str!("../../patterns/hyph-ta.tex"),
+    include_str!("../../patterns/hyph-te.tex"),
+    include_str!("../../patterns/hyph-kn.tex"),
+    include_str!("../../patterns/hyph-ml.tex"),
+    include_str!("../../patterns/hyph-or.tex"),
+    include_str!("../../patterns/hyph-as.tex"),
+];
+
+#[derive(Default)]
+struct Node {
+    next: BTreeMap<char, Node>,
+    weights: Vec<u8>,
+}
+
+impl Node {
+    /// Read only the patterns block of a trusted bundled TeX file, ignoring comments and macros.
+    fn parse(source: &str) -> Self {
+        let mut root = Self::default();
+        let mut active = false;
+        for line in source.lines() {
+            let line = line.split('%').next().unwrap_or_default().trim();
+            if line == "\\patterns{" {
+                active = true;
+                continue;
+            }
+            if line == "}" {
+                active = false;
+            }
+            if !active || line.is_empty() {
+                continue;
+            }
+            for pattern in line.split_whitespace() {
+                let mut node = &mut root;
+                let mut weights = vec![0];
+                for ch in pattern.chars() {
+                    if let Some(digit) = ch.to_digit(10) {
+                        if let Some(last) = weights.last_mut() {
+                            *last = digit as u8;
+                        }
+                    } else {
+                        node = node.next.entry(ch).or_default();
+                        weights.push(0);
+                    }
+                }
+                node.weights = weights;
+            }
+        }
+        root
+    }
+
+    /// Overlay matched Liang weights on a boundary-padded word; odd maxima permit breaks.
+    fn points(&self, word: &str) -> Vec<usize> {
+        let chars: Vec<char> = std::iter::once('.').chain(word.chars()).chain(std::iter::once('.')).collect();
+        let mut weights = vec![0; chars.len() + 1];
+        for start in 0..chars.len() {
+            let mut node = self;
+            for ch in chars.iter().skip(start) {
+                let Some(next) = node.next.get(ch) else { break };
+                node = next;
+                for (slot, weight) in weights.iter_mut().skip(start).zip(&node.weights) {
+                    *slot = (*slot).max(*weight);
+                }
+            }
+        }
+        (1..word.chars().count()).filter(|p| weights.get(p + 1).is_some_and(|w| w % 2 == 1)).collect()
+    }
+}
+
+/// Lazily initialize the bundled tries and return character-index candidates for one language.
+pub(super) fn points(word: &str, index: usize) -> Vec<usize> {
+    static PATTERNS: OnceLock<Vec<Node>> = OnceLock::new();
+    PATTERNS.get_or_init(|| SOURCES.iter().map(|s| Node::parse(s)).collect()).get(index).map_or_else(Vec::new, |p| p.points(word))
+}
+
+/// Patterns and user exceptions must both preserve a whole Unicode grapheme. This also protects
+/// text when a fallback font subdivides a conjunct into several shaping clusters.
+pub(super) fn retain_boundaries(word: &str, points: &mut Vec<usize>) {
+    let mut count = 0;
+    let mut boundaries = Vec::new();
+    for cluster in word.graphemes(true) {
+        boundaries.push(count);
+        count += cluster.chars().count();
+    }
+    let chars: Vec<_> = word.chars().collect();
+    points.retain(|p| {
+        *p > 0
+            && *p < count
+            && boundaries.binary_search(p).is_ok()
+            && !chars.get(*p).is_some_and(|c| matches!(c, '\u{200c}' | '\u{200d}'))
+            && !p.checked_sub(1).and_then(|i| chars.get(i)).is_some_and(|c| {
+                // Tamil's pulli is not a Unicode grapheme linker, and its patterns allow
+                // coda breaks after it. Conservatively keep every virama with what follows,
+                // even when neither the font nor Unicode groups the consonants together.
+                matches!(
+                    c,
+                    '\u{200c}'
+                        | '\u{200d}'
+                        | '\u{094d}'
+                        | '\u{09cd}'
+                        | '\u{0a4d}'
+                        | '\u{0acd}'
+                        | '\u{0b4d}'
+                        | '\u{0bcd}'
+                        | '\u{0c4d}'
+                        | '\u{0ccd}'
+                        | '\u{0d4d}'
+                )
+            })
+    });
+}
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index 50e1ce0b2..c36514eef 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -14,7 +14,7 @@ use vectorcraft_geom::{ArcPath, PathData};
 use crate::GlyphBend;
 use crate::composer::{Breakpoint, Params, compose};
 use crate::fontdb::FontDb;
-use crate::hyphen::hyphen_points_in;
+use crate::hyphen::points_for;
 use crate::justify::{Flex, LineFit, apply_desired, fit_line, is_word_space};
 use crate::kashida;
 use crate::shape::{
diff --git a/crates/text/src/layout/breaking.rs b/crates/text/src/layout/breaking.rs
index 90d6555a0..fd663c9a9 100644
--- a/crates/text/src/layout/breaking.rs
+++ b/crates/text/src/layout/breaking.rs
@@ -1,7 +1,7 @@
 use super::region::Region;
 use super::{
     Affine, BezPath, Breakpoint, Burasagari, EPS, FirstBaseline, FontDb, HyphenationOptions, Kinsoku, LeadingModel, SGlyph, hyphen_glyph,
-    hyphen_points_in, no_line_end, no_line_start, soft_line_start,
+    no_line_end, no_line_start, points_for, soft_line_start,
 };
 
 /// Vertical metrics of a line: (ascent, descent, leading, cap height, x height).
@@ -109,7 +109,8 @@ impl Pen<'_> {
             // height when that is more, in at most `MAX_STEPS` steps.
             let step = est.lead.max(1.0).max(r.cell.height() / MAX_STEPS as f64);
             for _ in 0..=MAX_STEPS {
-                if baseline + est.desc > r.bottom() + 0.01 {
+                // A baseline a step no longer moves (past a gutter of 1e300, say) won't reach a line.
+                if baseline + est.desc > r.bottom() + 0.01 || baseline + step <= baseline || baseline.is_nan() {
                     break;
                 }
                 // A rectangle's lines are all as wide: none below has more room for the word
@@ -543,7 +544,7 @@ fn hyphen_breaks(text: &str, g: &[SGlyph], ws: usize, we: usize, opts: &Hyphenat
             starts.entry(g[k].byte).or_insert(k);
         }
     }
-    hyphen_points_in(word, opts, g[a].hyphenates).into_iter().filter_map(|ci| starts.get(offs.get(ci)?).copied()).collect()
+    points_for(word, opts, g[a].hyphen_language).into_iter().filter_map(|ci| starts.get(offs.get(ci)?).copied()).collect()
 }
 
 /// Break candidates for the every-line composer: hyphenation points under `hyphenate` (the
diff --git a/crates/text/src/layout/wrapping_tests.rs b/crates/text/src/layout/wrapping_tests.rs
index cdf585539..413ea72d7 100644
--- a/crates/text/src/layout/wrapping_tests.rs
+++ b/crates/text/src/layout/wrapping_tests.rs
@@ -39,7 +39,7 @@ fn synthetic_glyphs(specs: &[(usize, usize, f64, char)]) -> Vec<SGlyph> {
             no_break: false,
             vertical_roman: false,
             cursive: false,
-            hyphenates: true,
+            hyphen_language: crate::hyphen::Language::English,
         })
         .collect()
 }
@@ -50,6 +50,47 @@ fn source_range(glyphs: &[SGlyph], start: usize, end: usize) -> Range<usize> {
     first.byte..last.byte + last.len
 }
 
+/// Both composers consume language-specific points even when a font subdivides vowel signs.
+#[test]
+fn indic_hyphenation_reaches_both_composers_without_splitting_marks() {
+    let opts = HyphenationOptions { words_longer_than: 0, after_first: 1, before_last: 1, ..Default::default() };
+    for (tag, syllable) in [
+        ("hi", "कि"),
+        ("mr", "कि"),
+        ("gu", "કિ"),
+        ("bn", "কি"),
+        ("pa", "ਕਿ"),
+        ("ta", "கி"),
+        ("te", "కి"),
+        ("kn", "ಕಿ"),
+        ("ml", "കി"),
+        ("or", "କି"),
+        ("as", "কি"),
+    ] {
+        let text = syllable.repeat(8);
+        // Deliberately subdivide each grapheme, as a fallback font may do. Marks are word
+        // characters but must never become a break, even at a shaping cluster boundary.
+        let specs: Vec<_> = text.char_indices().map(|(byte, ch)| (byte, ch.len_utf8(), 1.0, ch)).collect();
+        let mut glyphs = synthetic_glyphs(&specs);
+        for glyph in &mut glyphs {
+            glyph.hyphen_language = crate::hyphen::Language::from_tag(Some(tag));
+            glyph.sx = 0.001;
+        }
+        let cands = candidates(&text, &glyphs, Some(&opts), Kinsoku::None);
+        assert_eq!(cands.iter().filter(|b| b.hyphen > 0.0).map(|b| b.end).collect::<Vec<_>>(), (2..16).step_by(2).collect::<Vec<_>>(), "{tag}");
+        let (end, hyphen) = break_line(&text, &glyphs, 0, 4.5, &[], 0.0, Some((&opts, 0.0)), Burasagari::None, Kinsoku::None);
+        assert_eq!((end, hyphen), (4, true), "{tag}");
+        let params = Params { justify_last: false, ragged: true, tolerance: 1.0, uniform_from: 0, hyphen_limit: 0 };
+        let lines = compose(&glyphs, &|_| 4.5, &|_| 0.0, &cands, &[], &params).expect("every-line composition");
+        assert!(lines.iter().any(|(_, hyphen)| *hyphen), "{tag}");
+        assert!(lines.iter().all(|(end, _)| end % 2 == 0), "{tag}: {lines:?}");
+        let limited = Params { hyphen_limit: 1, ..params };
+        if let Some(lines) = compose(&glyphs, &|_| 4.5, &|_| 0.0, &cands, &[], &limited) {
+            assert!(lines.windows(2).all(|pair| !pair[0].1 || !pair[1].1), "{tag}: {lines:?}");
+        }
+    }
+}
+
 #[test]
 fn composition_trim_stays_along_the_line_when_a_character_rotates() {
     let db = FontDb::with_font_dirs(vec![]);
diff --git a/crates/text/src/shape.rs b/crates/text/src/shape.rs
index f37c7443e..1a6716c5f 100644
--- a/crates/text/src/shape.rs
+++ b/crates/text/src/shape.rs
@@ -80,8 +80,8 @@ pub(crate) struct SGlyph {
     /// decided for the whole segment it was shaped in ([`joins`]): on a curved path it is bent
     /// along the path so its joins meet.
     pub cursive: bool,
-    /// The glyph's language has hyphenation break points ([`crate::hyphen::language_has_patterns`]).
-    pub hyphenates: bool,
+    /// Pattern language of this glyph's source run (unknown languages only use user exceptions).
+    pub hyphen_language: crate::hyphen::Language,
 }
 
 /// Does `script` join its letters (a cursive script, whose neighbouring glyphs touch)?
@@ -158,9 +158,9 @@ impl SGlyph {
     pub fn is_soft_hyphen(&self) -> bool {
         self.ch == SOFT_HYPHEN
     }
-    /// Part of a word that may be hyphenated (letters and apostrophes).
+    /// Part of a word that may be hyphenated (letters, marks, joiners and apostrophes).
     pub fn is_letter(&self) -> bool {
-        self.ch.is_alphabetic() || matches!(self.ch, '\'' | '’')
+        crate::hyphen::is_word_char(self.ch)
     }
     /// Vertical type: a tate-chu-yoko glyph after its block's first, sharing that glyph's cell.
     pub fn continues_tcy(&self) -> bool {
@@ -949,7 +949,7 @@ fn inline_glyph(
         no_break: st.no_break,
         vertical_roman: false,
         cursive: false,
-        hyphenates: false,
+        hyphen_language: crate::hyphen::Language::None,
     }
 }
 
@@ -1086,7 +1086,10 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
                 if let Some(post) = text.get(range.end..context.end) {
                     buf.set_post_context(post);
                 }
-                let gb = shaper.shape(buf, ShapeOptions::new().features(&feats));
+                // A buffer whose characters name no script reads as `UNKNOWN`: its plan has none.
+                let script = Some(buf.script()).filter(|s| *s != harfrust::script::UNKNOWN);
+                let plan = face.shape_plan(&shaper, buf.direction(), script, language.as_ref(), &feats);
+                let gb = shaper.shape(buf, ShapeOptions::new().features(&feats).plan(Some(&plan)));
                 gb.glyph_infos()
                     .iter()
                     .zip(gb.glyph_positions())
@@ -1330,7 +1333,7 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
             no_break: gst.no_break,
             vertical_roman: gst.standard_vertical_roman,
             cursive,
-            hyphenates: crate::hyphen::language_has_patterns(gst.language.as_deref()),
+            hyphen_language: crate::hyphen::Language::from_tag(gst.language.as_deref()),
         });
     }
 }
diff --git a/crates/text/src/test_fonts.rs b/crates/text/src/test_fonts.rs
index ebdd08573..69ccbfe70 100644
--- a/crates/text/src/test_fonts.rs
+++ b/crates/text/src/test_fonts.rs
@@ -1,6 +1,8 @@
 //! Fonts built in code for tests, so no font file is committed: a small variable font (#296).
 //! Compiled for this crate's tests and, with the `test-fonts` feature, for other crates' tests.
 
+use std::sync::atomic::{AtomicBool, Ordering};
+
 use skrifa::instance::{LocationRef, Size};
 use skrifa::raw::TableProvider;
 use skrifa::raw::tables::glyf::Glyph;
@@ -10,6 +12,20 @@ use write_fonts::tables::fvar::{AxisInstanceArrays, Fvar, InstanceRecord, Variat
 use write_fonts::tables::gvar::{GlyphDelta, GlyphDeltas, GlyphVariations, Gvar, Tent};
 use write_fonts::types::{F2Dot14, Fixed, NameId, Tag};
 
+/// Whether faces use and keep shaping plans ([`keep_shape_plans`]).
+static KEEP_SHAPE_PLANS: AtomicBool = AtomicBool::new(true);
+
+/// Sets whether font faces use and keep shaping plans, for the whole process. When `keep` is false,
+/// every shaped segment makes a plan of its own, so a test can compare what kept plans produce with
+/// what its own plan produces. Plans a face already holds stay and are used again when it is true.
+pub fn keep_shape_plans(keep: bool) {
+    KEEP_SHAPE_PLANS.store(keep, Ordering::SeqCst);
+}
+
+pub(crate) fn keeps_shape_plans() -> bool {
+    KEEP_SHAPE_PLANS.load(Ordering::SeqCst)
+}
+
 /// The family of [`variable_font`].
 pub const VARIABLE_FAMILY: &str = "Varitest Sans";
 
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index a5d8b5063..031d35bdc 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -20,6 +20,7 @@ mod ligature_carets;
 mod path_joins;
 mod ruby;
 mod scripts;
+mod shape_plans;
 mod snap;
 mod svg_glyphs;
 mod sysfonts;
diff --git a/crates/text/src/tests/shape_plans.rs b/crates/text/src/tests/shape_plans.rs
new file mode 100644
index 000000000..0797c4a3f
--- /dev/null
+++ b/crates/text/src/tests/shape_plans.rs
@@ -0,0 +1,149 @@
+//! The shaping plans a face keeps: text shaped with a kept plan is laid out as text shaped with a
+//! plan of its own, and text in one style makes one plan however many objects hold it.
+
+use harfrust::{Feature, ShapeOptions, Tag, UnicodeBuffer};
+use kurbo::Point;
+use vectorcraft_doc::{CharStyle, TextObject, TextRun};
+
+use crate::test_fonts::{VARIABLE_FAMILY, variable_font};
+use crate::*;
+
+/// A database of the bundled fonts and the test variable font, whose faces hold no plans yet.
+fn db() -> FontDb {
+    let db = FontDb::with_font_dirs(vec![]);
+    db.add_font(variable_font().expect("the test font builds"));
+    db
+}
+
+fn style() -> CharStyle {
+    CharStyle { size: 100.0, ..CharStyle::default() }
+}
+
+fn point(text: &str, style: CharStyle) -> TextObject {
+    TextObject::point(Point::ZERO, text, style)
+}
+
+/// What a layout draws and where: every glyph (its font's id, which differs between databases,
+/// aside), the bounds and the baselines.
+fn drawn(l: &TextLayout) -> Vec<String> {
+    let glyph = |g: &PositionedGlyph| {
+        format!(
+            "{} {} {} {} {:?} {:?} {:?} {:?} {:?} {:?} {:?}",
+            g.gid,
+            g.byte,
+            g.len,
+            g.line,
+            g.xf,
+            g.origin,
+            g.advance,
+            g.width,
+            g.width_start,
+            g.angle,
+            g.outline.elements()
+        )
+    };
+    let mut all: Vec<String> = l.glyphs.iter().map(glyph).collect();
+    all.push(format!("{:?} {:?}", l.bounds, l.baselines()));
+    all
+}
+
+/// Text objects whose shaping differs in script, direction, language, features and face.
+fn cases() -> Vec<(&'static str, TextObject)> {
+    let mut mixed = point("AVAV", style());
+    let manual = CharStyle { kerning: Some(0.0), ..style() };
+    mixed.runs =
+        vec![TextRun { text: "AV".into(), style: style(), inline: None }, TextRun { text: "AV".into(), style: manual.clone(), inline: None }];
+    let mut vertical = point("AB\u{65e5}\u{672c}", style());
+    vertical.vertical = true;
+    let variable = |name: &str| CharStyle { font_family: VARIABLE_FAMILY.into(), font_style: name.into(), ..style() };
+    vec![
+        ("Latin", point("AVATAR office", style())),
+        ("other Latin in the same style", point("To Wa fi", style())),
+        ("digits and punctuation, no script", point("123 ... 456", style())),
+        ("Turkish", point("fi office", CharStyle { language: Some("tr".into()), ..style() })),
+        ("kerning off", point("AVAV", manual)),
+        ("kerning off in the second run", mixed),
+        ("optical kerning", point("AVAV", CharStyle { optical_kerning: true, ..style() })),
+        ("small capitals", point("Small Caps", CharStyle { small_caps: Some(70.0), ..style() })),
+        ("Arabic", point("\u{645}\u{631}\u{62d}\u{628}\u{627}", style())),
+        ("Hebrew", point("\u{5e9}\u{5dc}\u{5d5}\u{5dd}", style())),
+        ("vertical", vertical),
+        ("variable, Regular", point("AVA", variable("Regular"))),
+        ("variable, Bold", point("AVA", variable("Bold"))),
+    ]
+}
+
+#[test]
+fn text_shaped_with_a_kept_plan_is_laid_out_as_with_a_plan_of_its_own() {
+    let shared = db();
+    // Each object shapes with plans the others left, in both orders.
+    for (_, t) in cases().iter().chain(cases().iter().rev()) {
+        layout(&shared, t);
+    }
+    for (name, t) in cases() {
+        assert_eq!(drawn(&layout(&shared, &t)), drawn(&layout(&db(), &t)), "{name}");
+    }
+    // The cases tell plans apart: with the font's kerning off, the pair is spaced differently.
+    let kerned = layout(&shared, &point("AV", style()));
+    let unkerned = layout(&shared, &point("AV", CharStyle { kerning: Some(0.0), ..style() }));
+    assert_ne!(kerned.glyphs[0].advance, unkerned.glyphs[0].advance);
+}
+
+#[test]
+fn objects_in_one_style_share_one_plan() {
+    let db = db();
+    let face = db.style_face(&style()).unwrap();
+    assert_eq!(face.plans_kept(), 0);
+    for i in 0..100 {
+        layout(&db, &point(&format!("Ab{i}"), style()));
+    }
+    assert_eq!(face.plans_kept(), 1, "one plan for 100 objects");
+    layout(&db, &point("Ab", CharStyle { language: Some("tr".into()), ..style() }));
+    assert_eq!(face.plans_kept(), 2, "another language has another plan");
+}
+
+#[test]
+fn a_face_keeps_a_limited_number_of_plans() {
+    let db = db();
+    let face = db.style_face(&style()).unwrap();
+    let languages: Vec<String> = ('a'..='z').flat_map(|a| ['a', 'b'].map(|b| format!("{a}{b}"))).collect();
+    let text = |language: &str| point("Ab fi", CharStyle { language: Some(language.into()), ..style() });
+    for language in &languages {
+        layout(&db, &text(language));
+    }
+    assert!((1..languages.len()).contains(&face.plans_kept()), "{} plans kept", face.plans_kept());
+    // One the face no longer holds is made again, and one it holds is used again.
+    for language in [&languages[0], &languages[languages.len() - 1]] {
+        assert_eq!(drawn(&layout(&db, &text(language))), drawn(&layout(&self::db(), &text(language))), "{language}");
+    }
+}
+
+/// A kept plan applies the ranges of the features the text is shaped with, not those of the text
+/// it was made for: a plan tells only whether a feature covers all of the text.
+#[test]
+fn a_kept_plan_takes_the_ranges_of_the_features_it_shapes_with() {
+    let db = db();
+    let face = db.style_face(&style()).unwrap();
+    let hb = face.hb().unwrap();
+    let shaper = face.shaper.shaper(&hb).instance(face.instance.as_ref()).build();
+    let buffer = || {
+        let mut buf = UnicodeBuffer::new();
+        buf.push_str("AVAVAV");
+        buf.guess_segment_properties();
+        buf
+    };
+    let positions = |gb: harfrust::GlyphBuffer| gb.glyph_positions().iter().map(|p| (p.x_advance, p.x_offset)).collect::<Vec<_>>();
+    let kern_off = |from: usize| [Feature::new(Tag::new(b"kern"), 0, from..6)];
+    let mut seen = vec![];
+    for from in [1, 3] {
+        let features = kern_off(from);
+        let buf = buffer();
+        let plan = face.shape_plan(&shaper, buf.direction(), Some(buf.script()), None, &features);
+        let kept = positions(shaper.shape(buf, ShapeOptions::new().features(&features).plan(Some(&plan))));
+        let own = positions(shaper.shape(buffer(), ShapeOptions::new().features(&features)));
+        assert_eq!(kept, own, "kerning off from {from}");
+        seen.push(kept);
+    }
+    assert_eq!(face.plans_kept(), 1, "the two ranges share a plan");
+    assert_ne!(seen[0], seen[1], "the two ranges space the text differently");
+}
diff --git a/crates/text/src/tests/typo.rs b/crates/text/src/tests/typo.rs
index 478bc9c97..8f37e5905 100644
--- a/crates/text/src/tests/typo.rs
+++ b/crates/text/src/tests/typo.rs
@@ -630,6 +630,19 @@ fn rows_can_have_a_gutter_of_their_own() {
     assert_eq!(layout(db(), &t).frames.get(1).map(|f| f.y0), Some(160.0));
 }
 
+/// A gutter so huge that a line's height no longer moves the baseline past it: the cells beyond it
+/// have no room, and looking down all 10,000 of them for a line must not freeze the layout.
+#[test]
+fn a_gutter_too_huge_to_step_past_has_no_room_for_lines() {
+    let mut t = area(COPY, style(12.0), Rect::new(0.0, 0.0, 420.0, 300.0), Justify::Left);
+    (t.area.rows, t.area.row_gutter) = (2, Some(1e300));
+    let l = layout(db(), &t);
+    assert!(l.lines.is_empty() && l.overflow);
+    (t.area.rows, t.area.columns, t.area.gutter, t.area.row_gutter) = (100, 100, 1e300, None);
+    let l = layout(db(), &t);
+    assert!(l.lines.is_empty() && l.overflow);
+}
+
 // ---------- area flow ----------
 
 #[test]
@@ -905,6 +918,55 @@ fn natural_width(s: &str, size: f64) -> f64 {
     l.lines[0].x1 - l.lines[0].x0
 }
 
+/// Installed fonts exercise run-language routing, source boundaries and hyphen limits end to end.
+#[test]
+fn indic_language_runs_hyphenate_with_both_composers() {
+    let db = FontDb::global();
+    for (tag, syllable) in [
+        ("hi", "कि"),
+        ("mr", "कि"),
+        ("gu", "કિ"),
+        ("bn", "কি"),
+        ("pa", "ਕਿ"),
+        ("ta", "கி"),
+        ("te", "కి"),
+        ("kn", "ಕಿ"),
+        ("ml", "കി"),
+        ("or", "କି"),
+        ("as", "কি"),
+    ] {
+        let Some(face) = syllable.chars().next().and_then(|ch| db.face_covering(ch)).filter(|f| syllable.chars().all(|ch| f.covers(ch))) else {
+            eprintln!("SKIPPED: indic hyphenation layout {tag}; no installed font covers {syllable}");
+            continue;
+        };
+        let style = CharStyle {
+            font_family: face.family.clone(),
+            font_style: face.style.clone(),
+            size: 12.0,
+            language: Some(tag.into()),
+            ..Default::default()
+        };
+        let prefix = layout(db, &TextObject::point(Point::ZERO, &format!("{}-", syllable.repeat(3)), style.clone()));
+        let width = prefix.glyphs.iter().map(|g| g.advance).sum::<f64>() + 0.5;
+        for composer in [Composer::SingleLine, Composer::EveryLine] {
+            let text = syllable.repeat(20);
+            let mut t = area(&text, style.clone(), Rect::new(0.0, 0.0, width, 2000.0), Justify::Left);
+            t.para.composer = composer;
+            t.para.hyphenate = true;
+            let l = layout(db, &t);
+            assert!(!l.overflow, "{tag} {composer:?}");
+            assert!(hyphen_run(&l) > 0, "{tag} {composer:?}: no automatic hyphens");
+            assert!(l.lines.iter().all(|line| line.end % syllable.len() == 0), "{tag} {composer:?}: split syllable");
+            assert_eq!(l.lines.last().map(|line| line.end), Some(text.len()));
+            t.para.hyphenation.hyphen_limit = 1;
+            assert!(hyphen_run(&layout(db, &t)) <= 1, "{tag} {composer:?}: hyphen limit");
+            t.runs.iter_mut().for_each(|run| run.style.language = Some("zz".into()));
+            assert_eq!(hyphen_run(&layout(db, &t)), 0, "unknown language must not use Indic patterns");
+        }
+        eprintln!("ASSERTIONS RUN: indic hyphenation layout {tag}, {} {}", face.family, face.style);
+    }
+}
+
 /// The text of each line.
 fn line_texts(t: &TextObject, l: &TextLayout) -> Vec<String> {
     let text = t.plain_text();
diff --git a/crates/tools/src/cursors.toml b/crates/tools/src/cursors.toml
index 0ac3e610a..c5b0f5232 100644
--- a/crates/tools/src/cursors.toml
+++ b/crates/tools/src/cursors.toml
@@ -26,7 +26,7 @@ id = "Arrow"
 group = "Selection"
 shown_when = [
     "The Selection tool over empty canvas or over an unselected object (no Alt).",
-    "Dragging with the Selection tool (a move), or with Direct Selection (an anchor, a segment or a handle).",
+    "Dragging with the Selection tool (a move), with Direct Selection (an anchor, a segment or a handle), or with a shape tool (from the selection's centre point).",
     "Any tool with no cursor of its own (Touch Type, Rotate View).",
     "The resting state of Live Paint Selection, Reshape (away from a path), Free Transform, Puppet Warp and Crop Image (nothing selected or outside the box), the Perspective Grid (locked or away from handles) and Perspective Selection.",
 ]
@@ -94,6 +94,7 @@ id = "Move"
 group = "Selection"
 shown_when = [
     "The Selection tool over a selected object, or over any object with Alt held (once an Alt-drag starts, SelectionCopy shows).",
+    "The shape tools over a selected object's centre point (Attributes › Show Center), before a press there moves it (while the drag runs the arrow is plain, SelectionCopy with Alt, ArrowHollow while it snaps).",
     "Reshape over a path or while dragging.",
     "Inside the Free Transform and Crop Image boxes.",
     "Puppet Warp over a pin.",
@@ -376,7 +377,9 @@ look = "An arc with an arrowhead at each end. RotateToward is the same arc, turn
 [[cursor]]
 id = "RotateToward"
 group = "Transform and resize"
-shown_when = ["Selection and Free Transform in the rotate zone just outside a bounding-box corner, and while rotating there. The Rotate, Gradient and Puppet Warp rotate cursors don't turn."]
+shown_when = [
+    "Selection, Free Transform and the shape tools (Rectangle, Rounded Rectangle, Ellipse, Polygon, Star) in the rotate zone just outside a bounding-box corner, and while rotating there. The Rotate, Gradient and Puppet Warp rotate cursors don't turn.",
+]
 hotspot = "Below the arc, in its empty middle, as for Rotate."
 look = "The Rotate arc drawn for the top-right corner (direction 1). VectorCraft turns it in 45° steps so it wraps whichever corner the pointer is at."
 
diff --git a/crates/tools/src/direct.rs b/crates/tools/src/direct.rs
index d7bd9c495..2b2f04c83 100644
--- a/crates/tools/src/direct.rs
+++ b/crates/tools/src/direct.rs
@@ -60,19 +60,21 @@ use crate::guides::{HandleSnap, Leave, PointSnap, Targets};
 use crate::meshedit::{MeshEdit, grid_of};
 use crate::pathtype::{self, BracketDrag, near_bracket};
 use crate::rulerguide::GuideEdit;
-use crate::select::{MoveSnap, hold_point, is_area_type, is_path_type, matrix_json, release_guide_at};
+use crate::select::{MoveSnap, hit_center, hold_point, is_area_type, is_path_type, matrix_json, release_guide_at};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
 
 #[derive(Clone, Debug)]
 enum State {
     Idle,
     /// Dragging the selected anchors, which move alike: `grab` is where the anchor pressed on (or
-    /// the point of a straight segment nearest the pointer pressed on it) was, the point that
-    /// snaps.
+    /// the point of a straight segment nearest the pointer pressed on it, `segment`) was, the
+    /// point that snaps. With Snap to Grid or Snap to Pixel, a segment's drag snaps its anchors
+    /// instead (#3835).
     MoveAnchors {
         start: Point,
         grab: Point,
         began: bool,
+        segment: bool,
     },
     /// Moving (Alt: copying) the selected objects; `grab`: the anchor an Alt-press picked the
     /// path by, which snaps as a dragged anchor does; else `hold`, where the press took hold of
@@ -528,16 +530,6 @@ fn nearest_anchor(pd: &PathData, p: Point, tol: f64) -> Option<(usize, usize, Po
     pd.anchors().map(|(si, ai, a)| (si, ai, a.p)).filter(|(.., a)| a.distance(p) <= tol).min_by(|x, y| x.2.distance(p).total_cmp(&y.2.distance(p)))
 }
 
-/// The selected object whose centre point (Attributes panel › Show Center), drawn while it is
-/// selected, is within `tol` of `p`: (object, where the point is).
-fn hit_center(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, Point)> {
-    let (symbols, editable) = (cx.doc.symbol_boxes(), cx.doc.editable());
-    cx.selection.objects.iter().copied().filter(|id| editable(*id) && in_scope(cx.doc, cx.isolation, *id)).find_map(|id| {
-        let c = cx.doc.node(id).filter(|n| n.shows_center())?.geometric_bounds_with(&symbols)?.center();
-        (c.distance(p) <= tol).then_some((id, c))
-    })
-}
-
 /// An edge of an area type frame under `p`, topmost first: (text, the edge's two anchors).
 fn hit_frame_edge(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, Vec<AnchorRef>)> {
     anchor_owners(cx, is_area_type).into_iter().find_map(|id| {
@@ -849,7 +841,9 @@ impl Tool for DirectSelectionTool {
                 self.state = State::Marquee { start: p, cur: p, toggle: ev.mods.shift, enclosed: false, whole: ev.mods.alt };
                 vec![]
             }
-            (PointerKind::Drag, State::MoveAnchors { start, grab, began }) => self.drag_move_anchors(cx, ev, p, (start, grab, began)),
+            (PointerKind::Drag, State::MoveAnchors { start, grab, began, segment }) => {
+                self.drag_move_anchors(cx, ev, p, (start, grab, began, segment))
+            }
             (PointerKind::Drag, State::Segment { id, si, seg, t, start, began }) => {
                 let mut out = vec![];
                 if !began {
@@ -1288,7 +1282,7 @@ impl DirectSelectionTool {
         self.state = if already && cx.selection.anchors.is_empty() {
             State::MoveObject { start: p, grab: Some(grab), hold: grab, began: false, deselect: None }
         } else {
-            State::MoveAnchors { start: p, grab, began: false }
+            State::MoveAnchors { start: p, grab, began: false, segment: false }
         };
         if ev.mods.shift {
             return vec![Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[si, ai]], "mode": "toggle"}))];
@@ -1354,7 +1348,7 @@ impl DirectSelectionTool {
                 } else {
                     // Held by the segment itself, so the segment is what lands on a
                     // ruler guide or lines up, not the pressed spot beside it (#3701).
-                    State::MoveAnchors { start: p, grab: hold_point(cx, &h, p), began: false }
+                    State::MoveAnchors { start: p, grab: hold_point(cx, &h, p), began: false, segment: true }
                 };
                 if ev.mods.shift {
                     return vec![Action::Exec("select.segments".into(), json!({"id": h.leaf.0, "segments": [[s.si, s.seg]], "mode": "toggle"}))];
@@ -1381,23 +1375,36 @@ impl DirectSelectionTool {
         }
         vec![]
     }
-    fn drag_move_anchors(&mut self, cx: &ToolContext, ev: &PointerEvent, p: Point, (start, grab, began): (Point, Point, bool)) -> Vec<Action> {
+    fn drag_move_anchors(
+        &mut self,
+        cx: &ToolContext,
+        ev: &PointerEvent,
+        p: Point,
+        (start, grab, began, segment): (Point, Point, bool, bool),
+    ) -> Vec<Action> {
         let mut out = vec![];
         if !began {
             if p.distance(start) < cx.tol(3.0) {
                 return out;
             }
             out.push(Action::Begin("Move".into()));
-            self.state = State::MoveAnchors { start, grab, began: true };
+            self.state = State::MoveAnchors { start, grab, began: true, segment };
             self.anchor_snap = Some(PointSnap::new(cx, || Targets::for_anchor_drag(cx.doc, cx.selection)));
             self.line_end = line_end_leave(cx, grab);
+            // A segment held by a point along it lands its anchors on the grid (the box round
+            // them, an edge on a gridline on each axis), not that point (#3835).
+            let grid = segment && (cx.snap_to_grid || cx.snap_to_pixel);
+            self.partial_grid =
+                grid.then(|| MoveSnap::grid_only(vectorcraft_effects::preview::anchor_bounds(cx.selection, cx.doc, cx.preview_bounds)));
         }
         let mut d = move_delta(start, p, ev.mods.shift, cx.constrain_angle);
         let unsnapped = d;
         // The grabbed anchor snaps and the others follow it. Shift keeps the move at its
         // angle, and the anchor slides along it onto what Smart Guides find there (#886).
         self.guides.clear();
-        if let Some(snap) = &self.anchor_snap {
+        if segment && let Some(grid) = &self.partial_grid {
+            (d, self.guides) = if ev.mods.shift { grid.snap_along(cx, grab, d, false) } else { grid.snap(cx, grab, d, false) };
+        } else if let Some(snap) = &self.anchor_snap {
             let shift = ev.mods.shift.then(|| Leave::segment(cx, grab, true));
             let (q, guides) = snap.snap_from(cx, grab + (p - start), shift.as_ref().or(self.line_end.as_ref()));
             (d, self.guides) = (q - grab, guides);
diff --git a/crates/tools/src/direct/tests.rs b/crates/tools/src/direct/tests.rs
index c1748cac9..c249bd40a 100644
--- a/crates/tools/src/direct/tests.rs
+++ b/crates/tools/src/direct/tests.rs
@@ -1862,6 +1862,29 @@ fn a_move_of_objects_lands_an_edge_on_the_grid() {
     }
 }
 
+/// #3835: with Snap to Grid on, a straight segment dragged by a point along it lands its anchors
+/// on the grid, not that point. B's top edge, (300, 300)–(400, 300), pressed at (350, 300) and
+/// dragged by (22, 23), moves its anchors to 322–422 across and 323 down: the right end is nearest
+/// the gridline 423 and the edge nearest 324, so the move is (23, 24). Snapping the pressed point
+/// instead would move it by (19, 24), onto the intersection (369, 324), leaving both anchors off
+/// the grid. An anchor pressed on still lands on an intersection itself.
+#[test]
+fn a_dragged_segment_lands_its_anchors_on_the_grid() {
+    let (d, _, b) = two_squares();
+    let p = paint();
+    let mut s = anchors_of(b, &[(0, 0), (0, 1)]);
+    s.segments.insert(b, [(0, 0)].into_iter().collect());
+    let c = ToolContext { snap_to_grid: true, ..cx(&d, &s, &p) };
+    let mut t = DirectSelectionTool::new(false);
+    assert_eq!(drag(&mut t, &c, (350.0, 300.0), (372.0, 323.0), Mods::default()).0, json!({"dx": 23.0, "dy": 24.0}));
+    let (v, _) = drag(&mut t, &c, (350.0, 300.0), (363.0, 301.0), Mods { shift: true, ..Mods::default() });
+    let (x, y) = (v["dx"].as_f64().unwrap(), v["dy"].as_f64().unwrap());
+    assert!((x - 14.0).abs() < 1e-9 && y.abs() < 1e-9, "{v}");
+    let one = anchors_of(b, &[(0, 0)]);
+    let c = ToolContext { snap_to_grid: true, ..cx(&d, &one, &p) };
+    assert_eq!(drag(&mut t, &c, (300.0, 300.0), (322.0, 323.0), Mods::default()).0, json!({"dx": 24.0, "dy": 24.0}));
+}
+
 /// Group Selection and Direct Selection on a whole path keep a Shift-constrained move on its
 /// line when it snaps, as the Selection tool does: level by 13.04 with Snap to Grid on, B's
 /// right side (413.04) lands on the gridline 414, and its top stays at 300, between 297 and
diff --git a/crates/tools/src/guides/targets.rs b/crates/tools/src/guides/targets.rs
index 6fed43337..709e1f53d 100644
--- a/crates/tools/src/guides/targets.rs
+++ b/crates/tools/src/guides/targets.rs
@@ -139,6 +139,23 @@ pub(super) fn object_boxes(doc: &Document, moving: &[NodeId]) -> Vec<Rect> {
     out
 }
 
+/// The corners of glyph `g`'s bounding box in text space, clockwise from its top left as drawn:
+/// the box of its outline in its own frame (font units), through `g.xf`, so it turns, slants and
+/// scales with the glyph. `bb` is the outline's box in text space, used as it is for a glyph bent
+/// along a path or with a frame that can't be undone.
+fn glyph_box(g: &vectorcraft_text::PositionedGlyph, bb: &Rect) -> [Point; 4] {
+    let corners = |r: Rect| [Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)];
+    let det = g.xf.determinant();
+    if g.bend.is_some() || !(det.is_finite() && det.abs() > 1e-12) {
+        return corners(*bb);
+    }
+    let local = (g.xf.inverse() * g.outline.clone()).bounding_box();
+    if !(local.is_finite() && local.width() > 0.0 && local.height() > 0.0) {
+        return corners(*bb);
+    }
+    corners(local).map(|p| g.xf * p)
+}
+
 impl Targets {
     pub fn collect(doc: &Document, exclude: &[NodeId], visible: Option<Rect>) -> Self {
         Self::collect_inner(doc, exclude, None, visible, Gather::Bounds)
@@ -337,10 +354,14 @@ impl Targets {
                     }
                 }
                 if o.bounds {
-                    let r = t.xf.transform_rect_bbox(bb);
-                    for p in [Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)] {
-                        self.xs.push((p.x, p, kind));
-                        self.ys.push((p.y, p, kind));
+                    // The glyph's box in its own frame (font units), placed as the glyph is: its
+                    // corners are points to land on, even where the outline curves (the right of
+                    // `B`), and its edges guides, which turn with rotated or slanted type.
+                    let corners = glyph_box(g, &bb).map(to_doc);
+                    for (i, c) in corners.iter().enumerate() {
+                        self.points.push((*c, kind));
+                        let next = corners.get((i + 1) % 4).copied().unwrap_or(*c);
+                        self.push_glyph_line(*c, next - *c, o.angular);
                     }
                 }
             }
diff --git a/crates/tools/src/guides/tests.rs b/crates/tools/src/guides/tests.rs
index e82618fb3..499410465 100644
--- a/crates/tools/src/guides/tests.rs
+++ b/crates/tools/src/guides/tests.rs
@@ -837,7 +837,7 @@ fn each_snap_to_glyph_option_takes_away_only_its_own_guides() {
     for (off, less) in [
         (GlyphSnap { baseline: false, ..all }, [1, 0, 0, 0]),
         (GlyphSnap { x_height: false, ..all }, [1, 0, 0, 0]),
-        (GlyphSnap { bounds: false, ..all }, [4, 4, 0, 0]),
+        (GlyphSnap { bounds: false, ..all }, [2, 2, 0, 0]),
         (GlyphSnap { proximity: false, ..all }, [0, 2, 0, 0]),
         (GlyphSnap { anchors: false, ..all }, [0, 0, 0, anchors]),
         (GlyphSnap { angular: false, ..all }, [0, 0, 0, 0]),
@@ -851,8 +851,8 @@ fn each_snap_to_glyph_option_takes_away_only_its_own_guides() {
     let p = Point::new(400.0, x_height + 2.0);
     assert!((Targets::for_drawing(&d, &[], None, Some(all)).snap_point(p, 4.0).0.y - x_height).abs() < 1e-9);
     assert_eq!(Targets::for_drawing(&d, &[], None, Some(GlyphSnap { x_height: false, ..all })).snap_point(p, 4.0).0.y, p.y);
-    // Rotated type: its baseline, x-height and width edges and its strokes run at an angle, all
-    // Angular Guides; its glyph bounds still run across and down the page.
+    // Rotated type: its baseline, x-height, width edges, glyph bounds and strokes run at an angle,
+    // all Angular Guides (the corners of its glyph bounds stay points to land on).
     let (d, _) = glyph_doc("H", 20f64.to_radians());
     let (on, off) = (count(&d, all), count(&d, GlyphSnap { angular: false, ..all }));
     assert!(on[2] > 0, "{on:?}");
@@ -891,3 +891,45 @@ fn a_shift_constrained_point_slides_onto_a_rotated_baseline() {
     let (q, _) = Targets::for_drawing(&d, &[], None, Some(GlyphSnap::default())).snap_from(crossing + Vec2::new(1.5, 0.3), Some(&from), 4.0);
     assert!(q.distance(crossing) < 1e-9, "{q:?} vs {crossing:?}");
 }
+
+/// The corners of a glyph's bounds, from its outline in its own frame placed as the glyph is.
+fn glyph_corners(t: &vectorcraft_doc::TextObject) -> [Point; 4] {
+    let lay = layout_text(FontDb::global(), t);
+    let g = lay.glyphs.iter().find(|g| !g.outline.elements().is_empty()).expect("a glyph with an outline");
+    let r = (g.xf.inverse() * g.outline.clone()).bounding_box();
+    [Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)].map(|p| t.xf * g.xf * p)
+}
+
+/// Snap to Glyph › Glyph Bounds (#5112): each corner of a glyph's bounds is a point a drawn point
+/// lands on, also where its outline curves (the right of `B`, where no anchor is), and the corners
+/// turn with rotated type. Glyph Bounds off, they are gone.
+#[test]
+fn a_drawn_point_lands_on_a_corner_of_a_glyphs_bounds() {
+    let style = vectorcraft_doc::CharStyle { size: 200.0, ..Default::default() };
+    for angle in [0.0, 30f64.to_radians()] {
+        let (d, t) = glyph_doc_with("B", angle, style.clone());
+        let corners = glyph_corners(&t);
+        for (i, c) in corners.into_iter().enumerate() {
+            let p = c + Vec2::new(2.0, -1.5);
+            let (q, ov) = Targets::for_drawing(&d, &[], None, Some(GlyphSnap::default())).snap_point(p, 4.0);
+            assert!(q.distance(c) < 1e-9, "angle {angle}: {q:?} vs corner {c:?}");
+            // The left corners of `B` are anchors of its stem too; the right ones, on its curved
+            // side, come from its bounds alone.
+            if i == 0 || i == 3 {
+                continue;
+            }
+            assert!(ov.iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "glyph")), "{ov:?}");
+            let off = GlyphSnap { bounds: false, ..GlyphSnap::default() };
+            let (q, _) = Targets::for_drawing(&d, &[], None, Some(off)).snap_point(p, 4.0);
+            assert!(q.distance(c) > 1e-3, "Glyph Bounds off: {q:?} still on {c:?}");
+        }
+        // The right edge of the rotated glyph runs at its angle: a point beside it, far from the
+        // corners, lands on it.
+        let (tr, br) = (corners[1], corners[2]);
+        let dir = (br - tr) / (br - tr).hypot();
+        let p = tr.midpoint(br) + Vec2::new(-dir.y, dir.x) * 1.5;
+        let (q, _) =
+            Targets::for_drawing(&d, &[], None, Some(GlyphSnap { anchors: false, proximity: false, ..GlyphSnap::default() })).snap_point(p, 4.0);
+        assert!((q - tr).cross(dir).abs() < 1e-6, "angle {angle}: {q:?} is off the right edge");
+    }
+}
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
index ee00fdbe9..c6883c3fd 100644
--- a/crates/tools/src/lib.rs
+++ b/crates/tools/src/lib.rs
@@ -348,6 +348,28 @@ pub(crate) mod testutil {
         (d, id)
     }
 
+    /// A live 100 × 100 rectangle at (100, 100)–(200, 200) with no paint: its centre point
+    /// (Attributes › Show Center) is at (150, 150), and a press in the middle of it hits no art.
+    pub fn doc_with_live_rect() -> (Document, NodeId) {
+        use vectorcraft_doc::{LiveShape, NodeKind};
+        let shape = LiveShape::Rectangle {
+            w: 100.0,
+            h: 100.0,
+            radii: [0.0; 4],
+            kinds: Default::default(),
+            radii_relative: false,
+            xf: vectorcraft_geom::Affine::translate((100.0, 100.0)),
+        };
+        let mut d = Document::new(500.0, 500.0);
+        let (l, id) = (d.layers[0].id, d.alloc_id());
+        let mut n = Node::path(id, shape.to_path(), Appearance::default());
+        if let NodeKind::Path { live: slot, .. } = &mut n.kind {
+            *slot = Some(Box::new(shape));
+        }
+        d.insert(Some(l), 0, n).unwrap();
+        (d, id)
+    }
+
     /// [`doc_with_rect`] plus a clip group: a filled 200 × 200 square (350, 350)–(550, 550)
     /// clipped to an unpainted rectangle (400, 400)–(500, 500), so the art lies over the mask's
     /// edges. The group, the clipping path and the art.
diff --git a/crates/tools/src/select.rs b/crates/tools/src/select.rs
index 4bfd6a860..0f879cb55 100644
--- a/crates/tools/src/select.rs
+++ b/crates/tools/src/select.rs
@@ -469,10 +469,23 @@ pub fn selection_box(cx: &ToolContext) -> Option<OrientedBox> {
 /// [`selection_box`] while the canvas shows it (View › Show Bounding Box, and no anchors selected
 /// on their own): its handles take a press only then. A path the Pen is drawing keeps its end
 /// anchor selected, so Cmd/Ctrl lending the Selection tool doesn't scale it by hidden handles (#4980).
-fn shown_box(cx: &ToolContext) -> Option<OrientedBox> {
+/// The shape tools press it too (#5477).
+pub(crate) fn shown_box(cx: &ToolContext) -> Option<OrientedBox> {
     (cx.show_bbox && cx.selection.anchors.is_empty()).then(|| selection_box(cx)).flatten()
 }
 
+/// The selected object whose centre point (Attributes panel › Show Center), drawn while it is
+/// selected, is within `tol` of `p`: (object, where the point is). A press there grabs the object
+/// by that point — it moves the selection even where no art is painted (an unfilled shape) — as
+/// Direct Selection's does (#4891).
+pub(crate) fn hit_center(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, Point)> {
+    let (symbols, editable) = (cx.doc.symbol_boxes(), cx.doc.editable());
+    cx.selection.objects.iter().copied().filter(|id| editable(*id) && crate::direct::in_scope(cx.doc, cx.isolation, *id)).find_map(|id| {
+        let c = cx.doc.node(id).filter(|n| n.shows_center())?.geometric_bounds_with(&symbols)?.center();
+        (c.distance(p) <= tol).then_some((id, c))
+    })
+}
+
 /// The bounds of object `id`, measured as [`selection_bounds`] measures the selection.
 fn object_bounds(cx: &ToolContext, id: NodeId) -> Option<Rect> {
     with_object_bounds(cx, |bounds| bounds(id))
@@ -514,13 +527,25 @@ enum BoxHit {
     Rotate,
 }
 
+/// How far (screen points) outside a corner of the bounding box a press turns the selection: the
+/// Selection tool's rotate zone, and the shape tools' (#5477).
+pub(crate) const ROTATE_ZONE: f64 = 18.0;
+
+/// Where a press at `p` just outside a corner of box `b` turns the selection about its centre, as
+/// the Selection tool's rotate zone does: the box's centre. None on a handle, on the corner itself
+/// or away from every corner.
+pub(crate) fn rotate_zone(cx: &ToolContext, b: &OrientedBox, p: Point) -> Option<Point> {
+    let (tol, lp) = (cx.tol(5.0), b.to_local(p));
+    (hit_handle(b.rect, lp, tol).is_none() && in_rotate_zone(b.rect, lp, tol, cx.tol(ROTATE_ZONE)).is_some()).then(|| b.center())
+}
+
 /// The bounding-box handle or rotate zone under `p`.
 fn box_hit(cx: &ToolContext, b: &OrientedBox, p: Point) -> Option<BoxHit> {
     let (tol, lp) = (cx.tol(5.0), b.to_local(p));
     if let Some(h) = hit_handle(b.rect, lp, tol) {
         return Some(BoxHit::Handle(h));
     }
-    in_rotate_zone(b.rect, lp, tol, cx.tol(18.0)).map(|_| BoxHit::Rotate)
+    in_rotate_zone(b.rect, lp, tol, cx.tol(ROTATE_ZONE)).map(|_| BoxHit::Rotate)
 }
 
 /// Whether the current selection's bounding-box handle is under `p`, using the same geometry as
@@ -779,6 +804,8 @@ impl Tool for SelectionTool {
         }
     }
 
+    /// A press takes the selection's widgets, a ruler guide, a selected object's centre point or
+    /// the art; the drags then move, scale, rotate, marquee or drag what it took.
     fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
         self.note_loaded_at_press(ev.kind);
         let hovering = ev.kind == PointerKind::Move && matches!(self.state, State::Idle);
@@ -822,6 +849,19 @@ impl Tool for SelectionTool {
                     self.state = State::Idle;
                     return out;
                 }
+                // 2b. A selected object's centre point (Attributes › Show Center), drawn while it
+                // is selected: a drag from it moves the selection, also where no art is painted
+                // (an unfilled shape), which a press there would otherwise take for a marquee. A
+                // click there is a click on that object: it makes it the key object of several,
+                // and a Shift-click takes it out of the selection on release.
+                if !m.cmd
+                    && let Some((id, center)) = hit_center(cx, p, cx.point_tol())
+                {
+                    let several = cx.selection.objects.len() > 1 || !cx.selection.guides.is_empty();
+                    let (deselect, key) = if m.shift { (Some(id), None) } else { (None, (several && !m.alt).then_some(id)) };
+                    self.state = State::Moving { start: p, press: p, hold: center, began: false, deselect, key, exclude: None };
+                    return vec![];
+                }
                 // 3. Objects: Cmd/Ctrl-click selects the one under the selected one (cycling).
                 if m.cmd
                     && cx.select_behind
@@ -1023,6 +1063,8 @@ impl Tool for SelectionTool {
         o
     }
 
+    /// The pointer for the drag in progress, else the one for what a press would take: a widget,
+    /// a ruler guide, the box's handles or rotate zone, a selected object's centre point or the art.
     fn cursor(&self, cx: &ToolContext, p: Point, m: Mods) -> Cursor {
         if let State::Mirror(d) = &self.state {
             return d.cursor(cx, p);
@@ -1093,6 +1135,13 @@ impl Tool for SelectionTool {
         if let Some(c) = self.guide.cursor(cx, p) {
             return c;
         }
+        // A selected object's centre point (Show Center): a press there moves it, where the art
+        // may not reach. The box's handles and the ruler guides take a press before it, so they
+        // take the pointer too (on a thin box the centre lies within a handle's reach), and with
+        // Cmd/Ctrl held the press selects the object behind instead.
+        if near_selected && !m.cmd && hit_center(cx, p, cx.point_tol()).is_some() {
+            return Cursor::Move;
+        }
         // View → Snap to Point: over an anchor a press would grab the object by, the arrow turns
         // hollow.
         if cx.snap_to_point && matches!(Self::hover_point(cx, p), Some((_, "anchor"))) {
diff --git a/crates/tools/src/select/tests.rs b/crates/tools/src/select/tests.rs
index 714975bb0..94fb67786 100644
--- a/crates/tools/src/select/tests.rs
+++ b/crates/tools/src/select/tests.rs
@@ -2139,3 +2139,117 @@ fn a_double_click_on_a_symbol_instance_edits_its_symbol() {
     assert_eq!(double(&d, Some(l), 300.0, 300.0), vec![]);
     assert_eq!(double(&d, Some(l), 450.0, 50.0), vec![Action::Exec("object.exitIsolation".into(), json!({}))]);
 }
+
+/// #4891 for the Selection tool: a press on a selected object's centre point (Attributes › Show
+/// Center) moves the selection, also where no art is painted (an unfilled shape), which the press
+/// would otherwise take for a marquee; anywhere else a press still starts one.
+#[test]
+fn a_press_on_the_centre_point_moves_an_unfilled_shape() {
+    let (d, id) = doc_with_live_rect();
+    let mut s = Selection::default();
+    s.add(id);
+    let p = paint();
+    let c = cx(&d, &s, &p);
+    let centre = Point::new(150.0, 150.0);
+    let mut t = SelectionTool::default();
+    assert_eq!(t.cursor(&c, centre, Mods::default()), Cursor::Move);
+    // Cmd/Ctrl selects the object behind, not the centre point, so the pointer says neither.
+    assert_ne!(t.cursor(&c, centre, Mods { cmd: true, ..Mods::default() }), Cursor::Move);
+    assert!(t.pointer(&c, &ev(PointerKind::Down, centre.x, centre.y)).is_empty());
+    let a = t.pointer(&c, &ev(PointerKind::Drag, 170.0, 160.0));
+    assert_eq!(a.first(), Some(&Action::Begin("Move".into())), "{a:?}");
+    assert!(
+        matches!(a.last(), Some(Action::Preview(cmd, v)) if cmd == "object.transform" && v["matrix"] == json!([1.0, 0.0, 0.0, 1.0, 20.0, 10.0])),
+        "{a:?}"
+    );
+    assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 170.0, 160.0)), vec![Action::Commit]);
+    // Empty canvas away from it: a marquee, as before.
+    let mut t = SelectionTool::default();
+    assert_eq!(t.cursor(&c, Point::new(400.0, 400.0), Mods::default()), Cursor::Arrow);
+    t.pointer(&c, &ev(PointerKind::Down, 400.0, 400.0));
+    let a = t.pointer(&c, &ev(PointerKind::Drag, 450.0, 450.0));
+    assert!(a.is_empty(), "{a:?}");
+    assert!(matches!(t.overlays(&c).first(), Some(Overlay::Marquee(_))), "a marquee");
+}
+
+/// A Shift-press on a selected object's centre point moves the selection too, held to 45° steps,
+/// and a Shift-click there (no drag) takes the object out of the selection, as a Shift-press on
+/// the object itself does.
+#[test]
+fn a_shift_press_on_the_centre_point_moves_or_deselects() {
+    let (d, id) = doc_with_live_rect();
+    let mut s = Selection::default();
+    s.add(id);
+    let p = paint();
+    let c = cx(&d, &s, &p);
+    let shift = Mods { shift: true, ..Mods::default() };
+    let centre = Point::new(150.0, 150.0);
+    let mut t = SelectionTool::default();
+    assert!(t.pointer(&c, &ev(PointerKind::Down, centre.x, centre.y).with_mods(shift)).is_empty());
+    let a = t.pointer(&c, &ev(PointerKind::Drag, 170.0, 160.0).with_mods(shift));
+    assert_eq!(a.first(), Some(&Action::Begin("Move".into())), "{a:?}");
+    let Some(Action::Preview(cmd, v)) = a.last().filter(|a| matches!(a, Action::Preview(c, _) if c == "object.transform")) else { panic!("{a:?}") };
+    assert_eq!(cmd, "object.transform");
+    let [_, _, _, _, dx, dy] = [0, 1, 2, 3, 4, 5].map(|i| v["matrix"][i].as_f64().unwrap_or_default());
+    // A 45° move, within the rounding of the matrix's own floats.
+    assert!(dx != 0.0 && (dx - dy).abs() < 1e-9, "held to 45°: {dx} {dy}");
+    assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 170.0, 160.0).with_mods(shift)), vec![Action::Commit]);
+    // A Shift-click there takes the object out of the selection on release.
+    let mut t = SelectionTool::default();
+    assert!(t.pointer(&c, &ev(PointerKind::Down, centre.x, centre.y).with_mods(shift)).is_empty());
+    assert_eq!(
+        t.pointer(&c, &ev(PointerKind::Up, centre.x, centre.y).with_mods(shift)),
+        vec![Action::Exec("select.toggle".into(), json!({"id": id.0}))]
+    );
+}
+
+/// On a box too thin for its centre point to clear the handles, the handles take the pointer and
+/// the press, as they take the press itself: the centre is within their 5 pt reach.
+#[test]
+fn a_thin_shapes_centre_point_gives_the_handles_the_pointer() {
+    use vectorcraft_doc::{Appearance, LiveShape, Node, NodeKind};
+    let shape = LiveShape::Rectangle {
+        w: 100.0,
+        h: 8.0,
+        radii: [0.0; 4],
+        kinds: Default::default(),
+        radii_relative: false,
+        xf: vectorcraft_geom::Affine::translate((100.0, 100.0)),
+    };
+    let mut d = vectorcraft_doc::Document::new(500.0, 500.0);
+    let (layer, id) = (d.layers[0].id, d.alloc_id());
+    let mut n = Node::path(id, shape.to_path(), Appearance::default());
+    if let NodeKind::Path { live: slot, .. } = &mut n.kind {
+        *slot = Some(Box::new(shape));
+    }
+    d.insert(Some(layer), 0, n).unwrap();
+    let mut s = Selection::default();
+    s.add(id);
+    let p = paint();
+    let c = cx(&d, &s, &p);
+    let centre = Point::new(150.0, 104.0);
+    assert!(hit_center(&c, centre, c.point_tol()).is_some(), "the centre point is there");
+    let mut t = SelectionTool::default();
+    assert_eq!(t.cursor(&c, centre, Mods::default()), Cursor::ResizeV, "the top and bottom handles take it");
+    assert_eq!(t.pointer(&c, &ev(PointerKind::Down, centre.x, centre.y)), vec![Action::Begin("Scale".into())]);
+}
+
+/// A ruler guide under a selected object's centre point keeps the pointer and the press, as it
+/// keeps them over the art.
+#[test]
+fn a_ruler_guide_under_the_centre_point_keeps_the_pointer() {
+    let (mut d, id) = doc_with_live_rect();
+    d.guides.push(vectorcraft_doc::Guide::new(true, 150.0));
+    let mut s = Selection::default();
+    s.add(id);
+    let p = paint();
+    let c = cx(&d, &s, &p);
+    let centre = Point::new(150.0, 150.0);
+    assert!(hit_center(&c, centre, c.point_tol()).is_some());
+    let mut t = SelectionTool::default();
+    let cursor = t.cursor(&c, centre, Mods::default());
+    assert_ne!(cursor, Cursor::Move, "the guide's cursor, not the move arrow");
+    let down = t.pointer(&c, &ev(PointerKind::Down, centre.x, centre.y));
+    let drag = t.pointer(&c, &ev(PointerKind::Drag, 170.0, 150.0));
+    assert!(drag.iter().any(|a| matches!(a, Action::Preview(cmd, _) if cmd == "guide.move")), "the guide drags: {down:?} {drag:?}");
+}
diff --git a/crates/tools/src/shape.rs b/crates/tools/src/shape.rs
index f48625a6a..076525be4 100644
--- a/crates/tools/src/shape.rs
+++ b/crates/tools/src/shape.rs
@@ -10,15 +10,19 @@
 //! The selection keeps its bounding box and its Live Shape widgets on show with the Rectangle,
 //! Rounded Rectangle, Ellipse, Polygon and Star tools, so a shape just drawn can be adjusted at
 //! once: a drag on a live rectangle's or polygon's corner widget rounds its corners and a drag on
-//! a live ellipse's pie widget sets its pie angle, as with the Selection tool; a press anywhere
-//! else draws a new shape (#5477).
+//! a live ellipse's pie widget sets its pie angle, as with the Selection tool; a press on the
+//! selection's centre point (Show Center) moves it, and one just outside a corner of its box turns
+//! it about that centre, as the Selection tool's rotate zone does; a press anywhere else draws a
+//! new shape (#5477).
 
 use serde_json::{Value, json};
 use vectorcraft_geom::{Affine, Point, Rect, Vec2};
 
+use crate::bbox::{move_delta, rotate_for_drag};
 use crate::corners::{self, CornerDrag};
 use crate::guides::{DrawSnap, Leave, square};
 use crate::pie::{self, PieDrag};
+use crate::select::{MoveSnap, hit_center, matrix_json, rotate_zone, shown_box};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
 
 /// The largest corner radius the Rounded Rectangle tool draws, points: the range of General ›
@@ -38,6 +42,16 @@ enum WidgetDrag {
     Pie(PieDrag),
 }
 
+/// A drag of the selection itself, taken by a shape tool: the centre point moves it and the zone
+/// just outside a corner of its box turns it, as the Selection tool's drags do (#5477).
+enum SelectionDrag {
+    /// Moving the selection by the centre point `hold`: `start` is where the press was, and the
+    /// move has begun once the pointer left the drag threshold.
+    Move { start: Point, hold: Point, began: bool, snap: Box<MoveSnap> },
+    /// Turning the selection about `center` from where the press was.
+    Rotate { center: Point, start: Point },
+}
+
 pub struct ShapeTool {
     id: &'static str,
     start: Option<Point>,
@@ -59,6 +73,15 @@ pub struct ShapeTool {
     snap: DrawSnap,
     /// A widget of the selection is being dragged instead of a shape drawn.
     widget: Option<WidgetDrag>,
+    /// The selection is being moved or turned instead of a shape drawn.
+    selection: Option<SelectionDrag>,
+    /// The Smart Guides a move of the selection shows.
+    guides: Vec<Overlay>,
+    /// The measurement label of a move or a turn: where it goes and what it reads.
+    measure: Option<(Point, String)>,
+    /// The move of the selection snapped to a point, a guide or the grid at its last step: the
+    /// arrow turns hollow, as the Selection tool's does.
+    snapped: bool,
 }
 
 /// The inner-to-outer radius ratio that keeps a star of `points` points' shoulders straight (each
@@ -95,6 +118,10 @@ impl ShapeTool {
             line_angle: 0.0,
             fill_line: false,
             widget: None,
+            selection: None,
+            guides: vec![],
+            measure: None,
+            snapped: false,
         }
     }
 
@@ -112,6 +139,103 @@ impl ShapeTool {
         shows_shape_widgets(self.id) && (corners::over_widget(cx, p, false) || pie::over_widget(cx, p))
     }
 
+    /// The selection's box, while this tool shows it (the tools that draw a box, with a selection
+    /// and no anchors picked on their own).
+    fn box_of(&self, cx: &ToolContext) -> Option<vectorcraft_doc::OrientedBox> {
+        shows_shape_widgets(self.id).then(|| shown_box(cx)).flatten()
+    }
+
+    /// Is `p` in the zone just outside a corner of the selection's box, where a press turns the
+    /// selection about its centre ([`crate::select::rotate_zone`])? On the corner itself the Live
+    /// Corners widget rounds it (#5477).
+    fn over_rotate(&self, cx: &ToolContext, p: Point) -> Option<Point> {
+        rotate_zone(cx, &self.box_of(cx)?, p)
+    }
+
+    /// Is `p` over the centre point of a selected object (Attributes › Show Center), where a press
+    /// moves the selection? The point shows whatever View › Show Bounding Box says, so the press
+    /// takes it too.
+    fn over_center(&self, cx: &ToolContext, p: Point) -> bool {
+        shows_shape_widgets(self.id) && hit_center(cx, p, cx.point_tol()).is_some()
+    }
+
+    /// A press on the selection's centre point or just outside a corner of its box: the drag moves
+    /// or turns the selection instead of drawing a new shape (#5477). A turn begins with the press,
+    /// as the Selection tool's does; a move begins once the pointer leaves the drag threshold.
+    fn press_selection(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Option<Vec<Action>> {
+        if !shows_shape_widgets(self.id) {
+            return None;
+        }
+        self.selection = match hit_center(cx, ev.pos, cx.point_tol()) {
+            Some((_, hold)) => Some(SelectionDrag::Move { start: ev.pos, hold, began: false, snap: Box::new(MoveSnap::new(cx)) }),
+            None => self.over_rotate(cx, ev.pos).map(|center| SelectionDrag::Rotate { center, start: ev.pos }),
+        };
+        self.selection.as_ref()?;
+        self.snap.clear();
+        self.guides.clear();
+        self.measure = None;
+        Some(match self.selection {
+            Some(SelectionDrag::Rotate { .. }) => vec![Action::Begin("Rotate".into())],
+            _ => vec![],
+        })
+    }
+
+    /// The pointer and keys while the selection is moved or turned: `None` when it is not.
+    fn selection_pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Option<Vec<Action>> {
+        let d = self.selection.as_mut()?;
+        let out = match (ev.kind, d) {
+            (PointerKind::Drag, SelectionDrag::Move { start, hold, began, snap }) => {
+                let mut out = vec![];
+                if !*began {
+                    if ev.pos.distance(*start) < cx.tol(3.0) {
+                        return Some(out);
+                    }
+                    *began = true;
+                    out.push(Action::Begin(if ev.mods.alt { "Copy".into() } else { "Move".into() }));
+                }
+                let shift = ev.mods.shift;
+                let unsnapped = move_delta(*start, ev.pos, shift, cx.constrain_angle);
+                let (delta, guides) =
+                    if shift { snap.snap_along(cx, *hold, unsnapped, ev.mods.alt) } else { snap.snap(cx, *hold, unsnapped, ev.mods.alt) };
+                // Shift has already constrained the move: any change is a snap.
+                self.snapped = (delta - unsnapped).hypot() > 1e-9;
+                self.guides = guides;
+                self.measure = cx.measurement_labels.then(|| (ev.pos, cx.offset_label(delta.x, delta.y)));
+                out.push(Action::Preview("object.transform".into(), json!({"matrix": matrix_json(Affine::translate(delta)), "copy": ev.mods.alt})));
+                out
+            }
+            (PointerKind::Drag, SelectionDrag::Rotate { center, start }) => {
+                let (a, deg) = rotate_for_drag(*center, *start, ev.pos, ev.mods.shift);
+                self.measure = cx.transform_tools_guides.then(|| (ev.pos, format!("{:.1}°", -deg)));
+                vec![Action::Preview("object.transform".into(), json!({"matrix": matrix_json(a), "copy": false}))]
+            }
+            (PointerKind::Up, SelectionDrag::Move { began, .. }) => {
+                let began = *began;
+                self.selection = None;
+                self.guides.clear();
+                self.measure = None;
+                self.snapped = false;
+                if began { vec![Action::Commit] } else { vec![] }
+            }
+            (PointerKind::Up, SelectionDrag::Rotate { .. }) => {
+                self.selection = None;
+                self.measure = None;
+                vec![Action::Commit]
+            }
+            _ => vec![],
+        };
+        Some(out)
+    }
+
+    /// Escape during a drag of the selection turns it back, as the Selection tool's does.
+    fn cancel_selection(&mut self) -> Vec<Action> {
+        self.selection = None;
+        self.guides.clear();
+        self.measure = None;
+        self.snapped = false;
+        vec![Action::Cancel]
+    }
+
     /// The pointer and keys while a widget is dragged: `None` when none is.
     fn widget_pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Option<Vec<Action>> {
         let w = self.widget.as_mut()?;
@@ -267,17 +391,24 @@ impl Tool for ShapeTool {
     fn id(&self) -> &'static str {
         self.id
     }
+    /// A shape being drawn, a Live Shape widget dragged, or the selection moved or turned is a
+    /// gesture in progress.
     fn busy(&self) -> bool {
-        self.start.is_some() || self.widget.is_some()
+        self.start.is_some() || self.widget.is_some() || self.selection.is_some()
     }
+    /// A widget or selection drag takes the pointer; otherwise a press draws, unless it lands on
+    /// the selection's centre point or in the rotate zone just outside its box's corner.
     fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
         if let Some(out) = self.widget_pointer(cx, ev) {
             return out;
         }
+        if let Some(out) = self.selection_pointer(cx, ev) {
+            return out;
+        }
         match ev.kind {
             PointerKind::Move => {
                 // Over a widget a press would drag, no Smart Guide for a new shape's start.
-                if self.over_widget(cx, ev.pos) {
+                if self.over_widget(cx, ev.pos) || self.over_center(cx, ev.pos) || self.over_rotate(cx, ev.pos).is_some() {
                     self.snap.clear();
                 } else {
                     self.snap.hover(cx, ev.pos, &[], None);
@@ -289,6 +420,9 @@ impl Tool for ShapeTool {
                     self.snap.clear();
                     return vec![];
                 }
+                if let Some(out) = self.press_selection(cx, ev) {
+                    return out;
+                }
                 let p = self.snap.press(cx, ev.pos, &[], None);
                 self.start = Some(p);
                 self.last = ev.pos;
@@ -339,7 +473,13 @@ impl Tool for ShapeTool {
             _ => vec![],
         }
     }
+    /// ↑/↓ change a polygon's sides, a star's points or the rounded rectangle's radius while it is
+    /// drawn; Escape turns a widget or selection drag back.
     fn key(&mut self, cx: &ToolContext, key: ToolKey, _mods: Mods) -> Vec<Action> {
+        // A drag of the selection: Escape turns it back, as with the Selection tool.
+        if self.selection.is_some() {
+            return if key == ToolKey::Escape { self.cancel_selection() } else { vec![] };
+        }
         // A widget drag: Up and Down step a corner's kind; Escape cancels it, as with the
         // Selection tool.
         if let Some(w) = &mut self.widget {
@@ -399,12 +539,24 @@ impl Tool for ShapeTool {
         match &self.widget {
             Some(WidgetDrag::Corner(c)) => c.adjusting(),
             Some(WidgetDrag::Pie(d)) => d.adjusting(),
-            None => false,
+            None => match &self.selection {
+                Some(SelectionDrag::Move { began, .. }) => *began,
+                Some(SelectionDrag::Rotate { .. }) => true,
+                None => false,
+            },
         }
     }
+    /// ↑/↓ step a corner's kind while its widget is dragged, and Escape ends a drag of the
+    /// selection.
     fn claims_key(&self, _cx: &ToolContext, key: ToolKey) -> bool {
-        matches!(self.widget, Some(WidgetDrag::Corner(_))) && matches!(key, ToolKey::Up | ToolKey::Down)
+        match (&self.widget, &self.selection) {
+            (Some(WidgetDrag::Corner(_)), _) => matches!(key, ToolKey::Up | ToolKey::Down),
+            (_, Some(_)) => key == ToolKey::Escape,
+            _ => false,
+        }
     }
+    /// The widget being dragged, the Smart Guides of the shape being drawn or the selection being
+    /// moved, and its size, angle or offset label.
     fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
         match &self.widget {
             Some(WidgetDrag::Corner(c)) => return c.overlays(cx),
@@ -412,6 +564,10 @@ impl Tool for ShapeTool {
             None => {}
         }
         let mut o = self.snap.guides().to_vec();
+        o.extend(self.guides.iter().cloned());
+        if let Some((p, text)) = &self.measure {
+            o.push(Overlay::Measure { p: *p, text: text.clone() });
+        }
         if let Some(s) = self.start.filter(|_| self.began && cx.measurement_labels) {
             let p = self.last + Vec2::new(cx.tol(12.0), cx.tol(12.0));
             let text = if self.id == "lineSegment" {
@@ -442,16 +598,43 @@ impl Tool for ShapeTool {
         }
         o
     }
-    fn cursor(&self, cx: &ToolContext, p: Point, _m: Mods) -> Cursor {
+    /// The Selection tool's pointer over a Live Shape widget, the selection's centre point or the
+    /// rotate zone just outside its box's corner; the crosshair everywhere else, where a press
+    /// draws.
+    fn cursor(&self, cx: &ToolContext, p: Point, m: Mods) -> Cursor {
         // Over a widget a press would drag (or dragging one), the Selection tool's pointer for it.
         let idle = self.start.is_none();
         match &self.widget {
-            Some(WidgetDrag::Corner(_)) => Cursor::CornerRadius,
-            Some(WidgetDrag::Pie(_)) => Cursor::ArrowHollow,
-            None if idle && shows_shape_widgets(self.id) && corners::over_widget(cx, p, false) => Cursor::CornerRadius,
-            None if idle && self.over_widget(cx, p) => Cursor::ArrowHollow,
-            None => Cursor::Crosshair,
+            Some(WidgetDrag::Corner(_)) => return Cursor::CornerRadius,
+            Some(WidgetDrag::Pie(_)) => return Cursor::ArrowHollow,
+            None => {}
         }
+        // Alt-dragging the selection leaves a copy behind; otherwise the arrow, hollow while the
+        // move snaps, as the Selection tool's.
+        match &self.selection {
+            Some(SelectionDrag::Rotate { center, .. }) => return Cursor::rotate_about_in_view(*center, p, cx.view_angle()),
+            Some(SelectionDrag::Move { began: true, .. }) if m.alt => return Cursor::SelectionCopy,
+            Some(SelectionDrag::Move { began: true, .. }) => return if self.snapped { Cursor::ArrowHollow } else { Cursor::Arrow },
+            Some(_) => return Cursor::Arrow,
+            None => {}
+        }
+        // A press takes the corner and pie widgets first, then the centre point, then the zone
+        // just outside a corner; everywhere else it draws a new shape.
+        if idle {
+            if shows_shape_widgets(self.id) && corners::over_widget(cx, p, false) {
+                return Cursor::CornerRadius;
+            }
+            if self.over_widget(cx, p) {
+                return Cursor::ArrowHollow;
+            }
+            if self.over_center(cx, p) {
+                return Cursor::Move;
+            }
+            if let Some(center) = self.over_rotate(cx, p) {
+                return Cursor::rotate_about_in_view(center, p, cx.view_angle());
+            }
+        }
+        Cursor::Crosshair
     }
     fn options(&self) -> Value {
         json!({
diff --git a/crates/tools/src/shape/tests.rs b/crates/tools/src/shape/tests.rs
index f51cf117f..85a2d52fc 100644
--- a/crates/tools/src/shape/tests.rs
+++ b/crates/tools/src/shape/tests.rs
@@ -423,3 +423,156 @@ fn a_shape_tool_drags_the_selected_shapes_widgets() {
     assert!(matches!(a.last(), Some(Action::Preview(cmd, v)) if cmd == "object.setLiveShape" && v.get("pieEnd").is_some()), "{a:?}");
     assert_eq!(t.pointer(&c, &PointerEvent::new(PointerKind::Up, 200.0, 20.0)), vec![Action::Commit]);
 }
+
+/// A selected live 100 × 100 rectangle at (100, 100)–(200, 200) with no paint: its centre point
+/// (Attributes › Show Center) is at (150, 150) and its corners at the box's.
+fn unfilled_live_rect() -> (vectorcraft_doc::Document, Selection) {
+    let (d, id) = doc_with_live_rect();
+    let mut s = Selection::default();
+    s.add(id);
+    (d, s)
+}
+
+/// #5477: with a shape tool the selection's centre point moves it and the zone just outside a
+/// corner of its box turns it, as the Selection tool's do; anywhere else a press draws a new
+/// shape. The centre is where no art is painted, so without this a press there would draw one.
+#[test]
+fn a_shape_tool_moves_the_selection_by_its_centre_point_and_turns_it_from_a_corner() {
+    let (d, s) = unfilled_live_rect();
+    let p = paint();
+    let c = cx(&d, &s, &p);
+    let centre = Point::new(150.0, 150.0);
+    for id in ["rectangle", "roundedRectangle", "polygon", "star", "ellipse"] {
+        let mut t = ShapeTool::new(id);
+        assert_eq!(t.cursor(&c, centre, Mods::default()), Cursor::Move, "{id}");
+        // No Smart Guide for a new shape's start over the centre point.
+        t.pointer(&c, &PointerEvent::new(PointerKind::Move, centre.x, centre.y));
+        assert!(t.overlays(&c).is_empty(), "{id}");
+        assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Down, centre.x, centre.y)).is_empty(), "{id}");
+        assert!(t.busy(), "{id}");
+        // A drag moves the selection by the pointer's offset.
+        let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 170.0, 160.0));
+        assert_eq!(a.first(), Some(&Action::Begin("Move".into())), "{id}: {a:?}");
+        assert!(t.transforming(), "{id}");
+        assert_eq!(
+            a.last(),
+            Some(&Action::Preview("object.transform".into(), json!({"matrix": [1.0, 0.0, 0.0, 1.0, 20.0, 10.0], "copy": false}))),
+            "{id}"
+        );
+        assert_eq!(t.pointer(&c, &PointerEvent::new(PointerKind::Up, 170.0, 160.0)), vec![Action::Commit], "{id}");
+        assert!(!t.busy() && !t.transforming(), "{id}");
+    }
+    // Alt pressed once the drag has begun copies, and the copy cursor shows, as the Selection
+    // tool's do.
+    let mut t = ShapeTool::new("rectangle");
+    t.pointer(&c, &PointerEvent::new(PointerKind::Down, centre.x, centre.y));
+    t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 160.0, 150.0));
+    let alt = Mods { alt: true, ..Mods::default() };
+    let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 170.0, 150.0).with_mods(alt));
+    assert!(matches!(a.last(), Some(Action::Preview(_, v)) if v["copy"] == json!(true)), "{a:?}");
+    assert_eq!(t.cursor(&c, Point::new(170.0, 150.0), alt), Cursor::SelectionCopy);
+    // View › Hide Bounding Box hides the box, not the centre point: a press there still moves.
+    let hidden = ToolContext { show_bbox: false, ..cx(&d, &s, &p) };
+    let mut t = ShapeTool::new("rectangle");
+    assert_eq!(t.cursor(&hidden, centre, Mods::default()), Cursor::Move);
+    t.pointer(&hidden, &PointerEvent::new(PointerKind::Down, centre.x, centre.y));
+    let a = t.pointer(&hidden, &PointerEvent::new(PointerKind::Drag, 170.0, 160.0));
+    assert_eq!(a.first(), Some(&Action::Begin("Move".into())), "{a:?}");
+    // On the corner's bounding-box handle, and on the corner widget itself, no turn: those keep
+    // their own gestures (the widget rounds the corner, the handle scales with the Selection tool).
+    for on_handle in [Point::new(205.0, 205.0), Point::new(200.0, 200.0)] {
+        let t = ShapeTool::new("rectangle");
+        assert_ne!(t.cursor(&c, on_handle, Mods::default()), Cursor::rotate_about(centre, on_handle), "{on_handle:?}");
+    }
+    // Just outside the bottom-right corner, past the handle's 5 pt square and within the 18 pt
+    // zone (8.49 pt away): a press there turns the selection about its centre.
+    let outside = Point::new(206.0, 206.0);
+    let mut t = ShapeTool::new("rectangle");
+    assert_eq!(t.cursor(&c, outside, Mods::default()), Cursor::rotate_about(centre, outside));
+    // A turn begins with the press, as the Selection tool's does (its drags preview into it).
+    assert_eq!(t.pointer(&c, &PointerEvent::new(PointerKind::Down, outside.x, outside.y)), vec![Action::Begin("Rotate".into())]);
+    let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 150.0, 205.0));
+    let (want, _) = rotate_for_drag(centre, outside, Point::new(150.0, 205.0), false);
+    assert_eq!(a.last(), Some(&Action::Preview("object.transform".into(), json!({"matrix": matrix_json(want), "copy": false}))), "{a:?}");
+    assert!(t.transforming());
+    // Escape turns it back.
+    assert_eq!(t.key(&c, ToolKey::Escape, Mods::default()), vec![Action::Cancel]);
+    assert!(!t.busy());
+    // Away from the centre point and the corners, the tool draws a new shape.
+    let away = Point::new(300.0, 300.0);
+    let mut t = ShapeTool::new("rectangle");
+    assert_eq!(t.cursor(&c, away, Mods::default()), Cursor::Crosshair);
+    t.pointer(&c, &PointerEvent::new(PointerKind::Down, away.x, away.y));
+    let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 350.0, 340.0));
+    assert_eq!(a.first(), Some(&Action::Begin("Rectangle".into())), "{a:?}");
+}
+
+/// Two selected live rectangles, the second placed so that its top-left Live Corners widget (10 pt
+/// in along the corner's bisector) lands on the first one's centre point.
+fn two_live_rects() -> (vectorcraft_doc::Document, Selection) {
+    use vectorcraft_doc::{Appearance, LiveShape, Node, NodeKind};
+    let (mut d, first) = doc_with_live_rect();
+    let inside = 10.0 / std::f64::consts::SQRT_2;
+    let shape = LiveShape::Rectangle {
+        w: 100.0,
+        h: 100.0,
+        radii: [0.0; 4],
+        kinds: Default::default(),
+        radii_relative: false,
+        xf: Affine::translate((150.0 - inside, 150.0 - inside)),
+    };
+    let (layer, id) = (d.layers[0].id, d.alloc_id());
+    let mut n = Node::path(id, shape.to_path(), Appearance::default());
+    if let NodeKind::Path { live: slot, .. } = &mut n.kind {
+        *slot = Some(Box::new(shape));
+    }
+    d.insert(Some(layer), 1, n).unwrap();
+    let mut s = Selection::default();
+    s.add(first);
+    s.add(id);
+    (d, s)
+}
+
+/// A press takes a Live Corners widget before a centre point, as the Selection tool does: with two
+/// shapes selected, one's corner widget may sit on another's centre, and it rounds rather than
+/// moving the selection.
+#[test]
+fn a_live_corner_widget_wins_over_another_shapes_centre_point() {
+    let (d, s) = two_live_rects();
+    let p = paint();
+    let c = cx(&d, &s, &p);
+    let at = Point::new(150.0, 150.0);
+    assert!(corners::over_widget(&c, at, false), "a widget is on the centre point");
+    assert!(hit_center(&c, at, c.point_tol()).is_some(), "and so is the centre point");
+    let mut t = ShapeTool::new("rectangle");
+    assert_eq!(t.cursor(&c, at, Mods::default()), Cursor::CornerRadius, "the widget takes the pointer");
+    assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y)).is_empty());
+    let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 160.0, 160.0));
+    assert_eq!(a.first(), Some(&Action::Begin("Corner Radius".into())), "{a:?}");
+}
+
+/// A move of the selection from the centre point snaps like the Selection tool's, and the arrow
+/// turns hollow while it does.
+#[test]
+fn a_move_from_the_centre_point_snaps_and_shows_the_hollow_arrow() {
+    use vectorcraft_doc::{Appearance, Node};
+    let (mut d, s) = unfilled_live_rect();
+    // Another rectangle whose left edge is at x = 300: the moved selection's right edge lands 4 pt
+    // short of it, within the Smart Guides' reach.
+    let (layer, id) = (d.layers[0].id, d.alloc_id());
+    d.insert(Some(layer), 1, Node::path(id, vectorcraft_geom::shapes::rectangle(Rect::new(300.0, 100.0, 350.0, 180.0)), Appearance::default_art()))
+        .unwrap();
+    let p = paint();
+    let c = cx(&d, &s, &p);
+    let mut t = ShapeTool::new("rectangle");
+    t.pointer(&c, &PointerEvent::new(PointerKind::Down, 150.0, 150.0));
+    let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 246.0, 150.0));
+    assert!(matches!(a.last(), Some(Action::Preview(_, v)) if v["matrix"][4] == json!(100.0)), "snapped to the edge: {a:?}");
+    assert_eq!(t.cursor(&c, Point::new(246.0, 150.0), Mods::default()), Cursor::ArrowHollow);
+    // Away from the neighbour, the move is the pointer's own and the arrow is plain.
+    let mut t = ShapeTool::new("rectangle");
+    t.pointer(&c, &PointerEvent::new(PointerKind::Down, 150.0, 150.0));
+    let a = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 160.0, 150.0));
+    assert!(matches!(a.last(), Some(Action::Preview(_, v)) if v["matrix"][4] == json!(10.0)), "{a:?}");
+    assert_eq!(t.cursor(&c, Point::new(160.0, 150.0), Mods::default()), Cursor::Arrow);
+}
diff --git a/crates/tools/src/text.rs b/crates/tools/src/text.rs
index 9dd96a1bf..0bc29a558 100644
--- a/crates/tools/src/text.rs
+++ b/crates/tools/src/text.rs
@@ -174,9 +174,10 @@ pub struct TypeTool {
     /// Caret and selection anchor (byte offsets into the plain text).
     caret: usize,
     anchor: usize,
-    /// After Select All in a frame of threaded text: the story's frames in thread order, the edited
-    /// one included. While the selection is the edited frame's whole text, the text of the other
-    /// frames is selected too. Empty otherwise.
+    /// After Select All in a frame of threaded text: the story's frames in thread order then, the
+    /// edited one included. While the selection is the edited frame's whole text and this holds the
+    /// edited frame, the text of the other frames of its current thread is selected too. Empty
+    /// otherwise.
     story: Vec<NodeId>,
     /// Horizontal position kept by Up/Down (text space).
     goal_x: Option<f64>,
@@ -230,8 +231,8 @@ impl TypeTool {
             return None;
         }
         let id = self.editing?;
-        let (attribute, by) = plain::step_key(key, mods.shift, a == b, vertical)?;
         let story = !self.story_others(cx).is_empty();
+        let (attribute, by) = plain::step_key(key, mods.shift, a == b && !story, vertical)?;
         let mut out = self.commit();
         let by = if mods.cmd { by * 5.0 } else { by };
         // With the whole story selected, `type.step` steps the text of every frame of it.
@@ -441,8 +442,8 @@ impl TypeTool {
     }
 
     /// The other frames whose whole text is selected along with the edited frame's after Select
-    /// All in threaded text ([`Self::story`]): none once the selection is not all of the edited
-    /// frame's text.
+    /// All in threaded text ([`Self::story`]), read from the document's current thread: none once
+    /// the selection is not all of the edited frame's text.
     fn story_others(&self, cx: &ToolContext) -> Vec<NodeId> {
         let Some(id) = self.editing.filter(|id| self.story.contains(id)) else { return vec![] };
         let Some(t) = Self::text(cx, id) else { return vec![] };
@@ -450,7 +451,22 @@ impl TypeTool {
         if a != 0 || b < edit::runs_len(&t.runs) {
             return vec![];
         }
-        self.story.iter().copied().filter(|f| *f != id && Self::text(cx, *f).is_some()).collect()
+        cx.doc.story_of(id).into_iter().filter(|f| *f != id).collect()
+    }
+
+    /// Whether the whole story is selected ([`Self::story_others`]) and its other frames hold text.
+    /// The story stays selected when the edited frame holds no text, as after a frame threaded in
+    /// before it took the text.
+    fn story_selected(&self, cx: &ToolContext) -> bool {
+        self.story_others(cx).into_iter().any(|f| Self::text(cx, f).is_some_and(|o| edit::runs_len(&o.runs) > 0))
+    }
+
+    /// Put back the caret and anchor `selected` that a key clamped to the edited frame's text, when
+    /// the key leaves the whole story selected.
+    fn keep_story_offsets(&mut self, story: bool, selected: (usize, usize)) {
+        if story {
+            (self.caret, self.anchor) = selected;
+        }
     }
 
     /// Move the caret (Shift keeps the anchor). Moving ends the typing session.
diff --git a/crates/tools/src/text/tool.rs b/crates/tools/src/text/tool.rs
index 5634cf5a1..1e9b1be88 100644
--- a/crates/tools/src/text/tool.rs
+++ b/crates/tools/src/text/tool.rs
@@ -197,11 +197,14 @@ impl Tool for TypeTool {
         };
         let text = t.plain_text();
         let len = text.len();
+        let story = self.story_selected(cx);
+        let selected = (self.caret, self.anchor);
         self.caret = self.caret.min(len);
         self.anchor = self.anchor.min(len);
         let (a, b) = self.sel();
         // Alt+arrows step the type by the Preferences › Type increments (Cmd/Ctrl too: five steps).
         if let Some(out) = self.step_attribute(cx, key, mods, a, b, t.vertical) {
+            self.keep_story_offsets(story, selected);
             return out;
         }
         let word = mods.cmd || mods.alt;
@@ -233,7 +236,7 @@ impl Tool for TypeTool {
             }
             ToolKey::Enter => self.replace(cx, if mods.shift { "\u{2028}" } else { "\n" }, None),
             ToolKey::Tab => self.replace(cx, "\t", None),
-            ToolKey::Backspace | ToolKey::Delete if a != b => self.replace(cx, "", None),
+            ToolKey::Backspace | ToolKey::Delete if a != b || story => self.replace(cx, "", None),
             ToolKey::Backspace if self.caret > 0 => {
                 self.anchor = if word { edit::prev_word(&text, self.caret) } else { edit::prev_char(&text, self.caret) };
                 self.replace(cx, "", None)
@@ -313,7 +316,10 @@ impl Tool for TypeTool {
                 let to = if mods.cmd { len } else { vectorcraft_text::line_end_of(&lay, self.caret) };
                 self.move_to(to, mods.shift)
             }
-            _ => vec![],
+            _ => {
+                self.keep_story_offsets(story, selected);
+                vec![]
+            }
         }
     }
     fn ime_preedit(&mut self, cx: &ToolContext, text: &str, active_chars: Option<Range<usize>>) -> Vec<Action> {
@@ -546,6 +552,12 @@ impl Tool for TypeTool {
                 {
                     self.start_editing(NodeId(id), b);
                     self.anchor = a;
+                    // The frames of a threaded story whose whole text Select All selected.
+                    let story: Vec<NodeId> =
+                        v.get("story").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_u64).map(NodeId).collect();
+                    if story.len() >= 2 && story.contains(&NodeId(id)) {
+                        self.story = story;
+                    }
                 }
             }
             "prevTool" | "previousTool" => {
@@ -672,7 +684,10 @@ impl Tool for TypeTool {
             for q in vectorcraft_text::selection_quads(&lay, a, b) {
                 o.push(Overlay::Highlight { quad: q.map(|p| t.xf * p), color: [60, 120, 255, 90] });
             }
-            // The whole story is selected: the other frames' text is highlighted too.
+        }
+        // The whole story is selected: the other frames' text is highlighted too, also when the
+        // edited frame holds no text.
+        if self.preedit.is_none() {
             for f in self.story_others(cx) {
                 let Some(other) = Self::text(cx, f) else { continue };
                 let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), other);
diff --git a/crates/tools/src/xform/eyedropper.rs b/crates/tools/src/xform/eyedropper.rs
index d4f553039..db3aad793 100644
--- a/crates/tools/src/xform/eyedropper.rs
+++ b/crates/tools/src/xform/eyedropper.rs
@@ -257,20 +257,19 @@ fn symbol_color_at(s: &mut Sampler, levels: &mut [Option<Document>], inst: &Node
 
 /// Whether the source has fill or stroke paint for an attribute sample.
 pub(crate) fn has_sampleable_paint(cx: &ToolContext, id: vectorcraft_doc::NodeId) -> bool {
-    cx.doc.node(id).is_some_and(|n| [false, true].into_iter().any(|stroke| n.proxy_paint(stroke, None).is_some_and(|(paint, ..)| !paint.is_none())))
+    cx.doc.node(id).is_some_and(|n| [false, true].into_iter().any(|stroke| n.proxy_paint_only(stroke, None).is_some_and(|paint| !paint.is_none())))
 }
 
 /// The colour of `n`'s fill (or its stroke, when the stroke was hit or there is no fill) at `p`,
 /// sampled in the paint's own space (text space for type runs) and box. A pattern gives the color
 /// of its tile art at `p` ([`pattern_color_at`]).
 fn paint_sample(s: &mut Sampler, levels: &mut [Option<Document>], n: &Node, on_stroke: bool, p: Point) -> Option<Color> {
-    let fill_none = n.proxy_paint(false, None).is_none_or(|(p, ..)| p.is_none());
+    let fill_none = n.proxy_paint_only(false, None).is_none_or(Paint::is_none);
     let stroke = on_stroke || fill_none;
     // Type takes its paint from its characters, and a colorized object from its colorize paint.
     let items: Vec<usize> = n.appearance.items.iter().enumerate().filter(|(_, it)| it.is_fill() != stroke).map(|(i, _)| i).collect();
     if items.is_empty() || matches!(n.kind, NodeKind::Text(_)) || (!stroke && n.extras().colorize.is_some()) {
-        let (paint, to_doc, bounds) = n.proxy_paint(stroke, None)?;
-        return paint_color(s, levels, paint, to_doc, bounds, p);
+        return proxy_color(s, levels, n, stroke, None, p);
     }
     // The visible fills (or strokes) from the top: where one leaves a gap, the next shows. Of a
     // path's strokes, only the ones that reach `p` count, when any does (a click within the hit
@@ -289,14 +288,26 @@ fn paint_sample(s: &mut Sampler, levels: &mut [Option<Document>], n: &Node, on_s
         }
     }
     for &i in visible.iter().rev() {
-        let Some((paint, to_doc, bounds)) = n.proxy_paint(stroke, Some(i)) else { continue };
-        if let Some(c) = paint_color(s, levels, paint, to_doc, bounds, p) {
+        if let Some(c) = proxy_color(s, levels, n, stroke, Some(i), p) {
             return Some(c);
         }
     }
     None
 }
 
+/// The color the paint behind `n`'s Fill (or Stroke) proxy for `item` ([`Node::proxy_paint`])
+/// shows at `p`. Only a gradient or a pattern has `n` measured for the paint's space and box.
+fn proxy_color(s: &mut Sampler, levels: &mut [Option<Document>], n: &Node, stroke: bool, item: Option<usize>, p: Point) -> Option<Color> {
+    match n.proxy_paint_only(stroke, item)? {
+        Paint::None => None,
+        Paint::Solid { color, .. } => Some(*color),
+        _ => {
+            let (paint, to_doc, bounds) = n.proxy_paint(stroke, item)?;
+            paint_color(s, levels, paint, to_doc, bounds, p)
+        }
+    }
+}
+
 /// The color `paint`, in a space `to_doc` places in the document and with box `bounds` there,
 /// shows at `p`. A pattern gives the color of its tile art at `p` ([`pattern_color_at`]).
 fn paint_color(s: &mut Sampler, levels: &mut [Option<Document>], paint: &Paint, to_doc: Affine, bounds: Rect, p: Point) -> Option<Color> {
@@ -1175,6 +1186,113 @@ mod tests {
         assert_eq!((at(100.0), at(94.0)), (Some("#ff0000".to_string()), Some("#0000ff".to_string())));
     }
 
+    /// The color of `n`'s fill (or stroke) at `p` from its measured proxy paints: the reference
+    /// [`paint_sample`] is checked against.
+    fn measured_sample(s: &mut Sampler, levels: &mut [Option<Document>], n: &Node, on_stroke: bool, p: Point) -> Option<Color> {
+        let fill_none = n.proxy_paint(false, None).is_none_or(|(p, ..)| p.is_none());
+        let stroke = on_stroke || fill_none;
+        let items: Vec<usize> = n.appearance.items.iter().enumerate().filter(|(_, it)| it.is_fill() != stroke).map(|(i, _)| i).collect();
+        if items.is_empty() || matches!(n.kind, NodeKind::Text(_)) || (!stroke && n.extras().colorize.is_some()) {
+            let (paint, to_doc, bounds) = n.proxy_paint(stroke, None)?;
+            return paint_color(s, levels, paint, to_doc, bounds, p);
+        }
+        let mut visible: Vec<usize> = items.into_iter().filter(|&i| n.appearance.items.get(i).is_some_and(|it| it.visible())).collect();
+        if stroke && let (NodeKind::Path { rule, .. } | NodeKind::Compound { rule, .. }, Some(bp)) = (&n.kind, n.stroke_path()) {
+            let reach =
+                |i: &usize| matches!(n.appearance.items.get(*i), Some(vectorcraft_doc::AppearanceItem::Stroke(st)) if st.hits(&bp, *rule, p, 0.0));
+            if visible.iter().any(&reach) {
+                visible.retain(&reach);
+            }
+        }
+        for &i in visible.iter().rev() {
+            let Some((paint, to_doc, bounds)) = n.proxy_paint(stroke, Some(i)) else { continue };
+            if let Some(c) = paint_color(s, levels, paint, to_doc, bounds, p) {
+                return Some(c);
+            }
+        }
+        None
+    }
+
+    /// Samples and the check for paint to sample give what the measured proxy paints give, on
+    /// paths, compound paths, groups, type and symbol instances whose fills and strokes have no
+    /// paint, a solid color or a gradient, in the top row and the row below, with and without a
+    /// colorize paint.
+    #[test]
+    fn samples_give_the_measured_proxy_paints_colors() {
+        use std::sync::Arc;
+        use vectorcraft_doc::{AppearanceItem, CharStyle, FillLayer, StrokeLayer, TextObject};
+        use vectorcraft_geom::Rect;
+        use vectorcraft_geom::shapes::rectangle;
+        let (mut d, _) = doc_with_rect();
+        let l = d.layers[0].id;
+        let square = |id| Node::path(id, rectangle(Rect::new(100.0, 100.0, 200.0, 200.0)), Default::default());
+        let ids: Vec<NodeId> = (0..5).map(|_| d.alloc_id()).collect();
+        let (outer, hole, inner) = (d.alloc_id(), d.alloc_id(), d.alloc_id());
+        let hole = Node::path(hole, rectangle(Rect::new(120.0, 120.0, 180.0, 180.0)), Default::default());
+        let text = TextObject::point(Point::new(100.0, 150.0), "Type", CharStyle { size: 40.0, ..Default::default() });
+        let objects = [
+            square(ids[0]),
+            Node::new(ids[1], NodeKind::Compound { children: vec![Arc::new(square(outer)), Arc::new(hole)], rule: Default::default() }),
+            Node::group(ids[2], vec![Arc::new(square(inner))]),
+            Node::new(ids[3], NodeKind::Text(Box::new(text))),
+            Node::new(ids[4], NodeKind::SymbolInstance { symbol: "Missing".into(), xf: Affine::translate((100.0, 100.0)) }),
+        ];
+        for (k, n) in objects.into_iter().enumerate() {
+            d.insert(Some(l), k + 1, n).unwrap();
+        }
+        let gradient = Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(vectorcraft_color::Gradient::default())));
+        let paints = [Paint::None, Paint::solid(Color::rgb8(200, 40, 10)), gradient];
+        let points = [Point::new(150.0, 150.0), Point::new(100.0, 150.0), Point::new(130.0, 110.0)];
+        let (sel, pd) = (Selection::default(), paint());
+        let (mut checked, mut colored) = (0, 0);
+        for &id in &ids {
+            for top in &paints {
+                for below in &paints {
+                    for colorize in [None, Some(&paints[1]), Some(&paints[2])] {
+                        let mut d = d.clone();
+                        let n = d.node_mut(id).unwrap();
+                        n.appearance.items = vec![
+                            AppearanceItem::Fill(FillLayer::new(below.clone())),
+                            AppearanceItem::Stroke(StrokeLayer::new(below.clone(), 4.0)),
+                            AppearanceItem::Fill(FillLayer::new(top.clone())),
+                            AppearanceItem::Stroke(StrokeLayer::new(top.clone(), 2.0)),
+                        ];
+                        n.extras_mut().colorize = colorize.map(|c| Box::new(c.clone()));
+                        if let NodeKind::Text(t) = &mut n.kind {
+                            for run in &mut t.runs {
+                                (run.style.fill, run.style.stroke, run.style.stroke_width) = (top.clone(), below.clone(), 2.0);
+                            }
+                        }
+                        let cx = cx(&d, &sel, &pd);
+                        let n = d.node(id).unwrap();
+                        let measured =
+                            [false, true].into_iter().any(|stroke| n.proxy_paint(stroke, None).is_some_and(|(paint, ..)| !paint.is_none()));
+                        assert_eq!(has_sampleable_paint(&cx, id), measured, "{n:?}");
+                        for on_stroke in [false, true] {
+                            for p in points {
+                                let mut s = Sampler {
+                                    doc: &d,
+                                    opts: sample_options(&cx),
+                                    raster_sample: 1,
+                                    symbol_nodes: 0,
+                                    work: MAX_WORK,
+                                    exhausted: false,
+                                    patterns: 0,
+                                };
+                                let mut levels: Vec<Option<Document>> = (0..MAX_NESTING).map(|_| None).collect();
+                                let sampled = paint_sample(&mut s, &mut levels, n, on_stroke, p);
+                                assert_eq!(sampled, measured_sample(&mut s, &mut levels, n, on_stroke, p), "{n:?} stroke {on_stroke} at {p:?}");
+                                checked += 1;
+                                colored += usize::from(sampled.is_some());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        assert!(colored > checked / 4 && colored < checked, "both answers come up: {colored} of {checked} gave a color");
+    }
+
     /// A gap between a pattern's tile art shows what lies below it, in the document and in the tile
     /// art of another pattern.
     #[test]
diff --git a/crates/trace/src/logo/bezier.rs b/crates/trace/src/logo/bezier.rs
index d2119117f..245957910 100644
--- a/crates/trace/src/logo/bezier.rs
+++ b/crates/trace/src/logo/bezier.rs
@@ -4,9 +4,11 @@
 //! (Graphics Gems, 1990), written from the description there.
 
 use super::geom::{Cubic, bez};
-use kurbo::Vec2;
+use kurbo::{CubicBez, ParamCurveNearest, Vec2};
 use vectorcraft_geom::Point;
 
+/// From this depth a run still over the tolerance is cut in the middle, which bounds the recursion
+/// at this depth plus the logarithm of the run's length.
 const MAX_DEPTH: usize = 14;
 
 fn chord(p: &[Point]) -> Vec<f64> {
@@ -71,6 +73,13 @@ fn max_err(c: &Cubic, p: &[Point], u: &[f64]) -> (f64, usize) {
     best
 }
 
+/// The largest distance from a point of `p` to the nearest point of `c`, which `max_err`'s distance
+/// at a point's parameter can only overstate.
+fn max_distance(c: &Cubic, p: &[Point]) -> f64 {
+    let curve = CubicBez::new(c[0], c[1], c[2], c[3]);
+    p.iter().map(|&q| curve.nearest(q, 1e-6).distance_sq).fold(0.0, f64::max).sqrt()
+}
+
 fn rec(p: &[Point], t1: Vec2, t2: Vec2, tol: f64, depth: usize, out: &mut Vec<Cubic>) {
     let (Some(&a), Some(&b)) = (p.first(), p.last()) else { return };
     if p.len() == 2 {
@@ -96,11 +105,19 @@ fn rec(p: &[Point], t1: Vec2, t2: Vec2, tol: f64, depth: usize, out: &mut Vec<Cu
         }
     }
     let (e, split) = max_err(&c, p, &u);
-    if e < tol || depth >= MAX_DEPTH || p.len() < 6 {
+    let short = p.len() < 6;
+    let capped = depth >= MAX_DEPTH;
+    if e < tol || ((short || capped) && max_distance(&c, p) <= tol) {
         out.push(c);
         return;
     }
-    let s = split.clamp(2, p.len() - 3);
+    let s = if short {
+        split.clamp(1, p.len() - 2)
+    } else if capped {
+        p.len() / 2
+    } else {
+        split.clamp(2, p.len() - 3)
+    };
     let tc = match (p.get(s - 1), p.get(s + 1)) {
         (Some(&x), Some(&y)) if x.distance(y) > 1e-12 => (x - y) / x.distance(y),
         _ => t1,
@@ -182,6 +199,77 @@ mod tests {
         }
     }
 
+    /// The largest distance from a point of `pts` to the nearest point of the fit.
+    fn exact_dev(cs: &[Cubic], pts: &[Point]) -> f64 {
+        pts.iter().map(|&q| cs.iter().map(|c| max_distance(c, &[q])).fold(f64::MAX, f64::min)).fold(0.0, f64::max)
+    }
+
+    /// Fits `pts` and checks that the pieces run from its first point to its last, each within `tol`.
+    fn assert_within(pts: &[Point], tol: f64) -> Vec<Cubic> {
+        let n = pts.len();
+        let cs = fit_cubics(pts, tangent(pts, 0, 4, 1), tangent(pts, n - 1, 4, -1), tol);
+        assert!(exact_dev(&cs, pts) <= tol, "{} points, tolerance {tol}: deviation {}", n, exact_dev(&cs, pts));
+        assert_eq!((cs[0][0], cs[cs.len() - 1][3]), (pts[0], pts[n - 1]));
+        for w in cs.windows(2) {
+            assert!(w[0][3].distance(w[1][0]) < 1e-9);
+        }
+        cs
+    }
+
+    #[test]
+    fn a_short_run_over_the_tolerance_is_cut_until_it_is_within() {
+        let spike = [(0.0, 0.0), (0.12, 0.0), (0.24, 0.5), (0.36, 0.0), (0.48, 0.0)].map(|(x, y)| Point::new(x, y));
+        assert!(assert_within(&spike, 0.1).len() > 1);
+        let four = [(0.0, 0.0), (0.2, 0.6), (0.4, -0.6), (0.6, 0.0)].map(|(x, y)| Point::new(x, y));
+        assert!(assert_within(&four, 0.1).len() > 1);
+        let three = [(0.0, 0.0), (0.2, 0.6), (0.4, 0.0)].map(|(x, y)| Point::new(x, y));
+        assert!(assert_within(&three, 0.1).len() > 1);
+    }
+
+    /// A zigzag that grows towards its end: the largest error is always next to the end, so each
+    /// split takes only a few points off the run.
+    fn growing_zigzag(n: usize) -> Vec<Point> {
+        (0..n).map(|i| Point::new(i as f64 * 0.1, if i % 2 == 0 { 1.0 } else { -1.0 } * 0.02 * 1.02f64.powi(i as i32))).collect()
+    }
+
+    #[test]
+    fn a_run_that_reaches_the_depth_limit_is_still_cut_until_it_is_within() {
+        assert_within(&growing_zigzag(300), 0.05);
+    }
+
+    #[test]
+    fn a_very_long_run_of_small_splits_is_fitted_without_deep_recursion() {
+        let pts: Vec<Point> =
+            (0..200_000).map(|i| Point::new(i as f64 * 0.1, if i % 2 == 0 { 1.0 } else { -1.0 } * (1.0 + i as f64 * 1e-3))).collect();
+        let cs = fit_cubics(&pts, tangent(&pts, 0, 4, 1), tangent(&pts, pts.len() - 1, 4, -1), 0.05);
+        assert_eq!((cs[0][0], cs[cs.len() - 1][3]), (pts[0], pts[pts.len() - 1]));
+    }
+
+    #[test]
+    fn random_runs_stay_within_the_tolerance() {
+        let mut state = 0x9e37_79b9_7f4a_7c15u64;
+        let mut next = move || {
+            state ^= state << 13;
+            state ^= state >> 7;
+            state ^= state << 17;
+            state
+        };
+        for k in 0..300 {
+            let n = 3 + (next() % 200) as usize;
+            let tol = [0.04, 0.08, 0.14, 0.3, 0.8][(next() % 5) as usize];
+            let jitter = [0.02, 0.1, 0.5, 2.0][k % 4];
+            let (mut x, mut y, mut a) = (0.0f64, 0.0f64, 0.0f64);
+            let mut pts = Vec::with_capacity(n);
+            for _ in 0..n {
+                a += ((next() % 2001) as f64 / 1000.0 - 1.0) * [0.05, 0.4, 1.5][k % 3];
+                x += a.cos() * 0.12;
+                y += a.sin() * 0.12 + ((next() % 2001) as f64 / 1000.0 - 1.0) * jitter;
+                pts.push(Point::new(x, y));
+            }
+            assert_within(&pts, tol);
+        }
+    }
+
     #[test]
     fn degenerate_input_gives_nothing_or_a_line_not_a_panic() {
         let t = Vec2::new(1.0, 0.0);
diff --git a/crates/trace/src/logo/outline.rs b/crates/trace/src/logo/outline.rs
index 57d87f8e1..35f655b37 100644
--- a/crates/trace/src/logo/outline.rs
+++ b/crates/trace/src/logo/outline.rs
@@ -369,6 +369,36 @@ mod tests {
         assert!(segs.is_some_and(|s| !s.is_empty()));
     }
 
+    #[test]
+    fn a_short_run_between_corners_keeps_to_the_tolerance() {
+        let run = [(0.0, 0.0), (0.12, 0.0), (0.24, 0.6), (0.36, 0.0), (0.48, 0.0)].map(|(x, y)| Point::new(x, y));
+        let (st, sg) = (Style::default(), 0.5);
+        let mut segs = Vec::new();
+        fit_run(&run, sg, &st, &mut Stats::default(), &mut segs);
+        let samples = sample_cubics(&segs, 0.001);
+        for q in smooth_open(&run, sg) {
+            let d = samples.iter().map(|s| s.distance(q)).fold(f64::MAX, f64::min);
+            assert!(d <= st.tol + 1e-3, "{q:?} is {d} from the fit");
+        }
+    }
+
+    #[test]
+    fn a_plain_fit_keeps_a_ragged_outline_within_the_tolerance() {
+        let raw: Vec<Point> = (0..120)
+            .map(|i| {
+                let a = i as f64 / 120.0 * std::f64::consts::TAU;
+                let r = 12.0 + if i % 2 == 0 { 1.0 } else { -1.0 } * (0.2 + i as f64 * 0.02);
+                Point::new(25.0 + r * a.cos(), 25.0 + r * a.sin())
+            })
+            .collect();
+        let tol = Style::default().tol;
+        let samples = sample_cubics(&plain_fit(&raw, tol), 0.005);
+        for q in &raw {
+            let d = samples.iter().map(|s| s.distance(*q)).fold(f64::MAX, f64::min);
+            assert!(d <= tol + 1e-2, "{q:?} is {d} from the fit");
+        }
+    }
+
     #[test]
     fn degenerate_outlines_give_none_not_a_panic() {
         let mut st = Stats::default();
diff --git a/crates/trace/src/tests.rs b/crates/trace/src/tests.rs
index 6b3298a7b..93467b352 100644
--- a/crates/trace/src/tests.rs
+++ b/crates/trace/src/tests.rs
@@ -1557,7 +1557,7 @@ fn a_traced_pixel_that_straightens_to_no_area_is_left_out_of_fills_and_kept_as_a
         mode: Mode::Color,
         palette: Palette::Limited,
         colors: 6,
-        paths: 90.0,
+        paths: 80.0,
         corners: 60.0,
         noise: 1,
         method: Method::Abutting,
diff --git a/crates/ui-egui/src/addons/document/tests.rs b/crates/ui-egui/src/addons/document/tests.rs
index 69cb75091..6e637c718 100644
--- a/crates/ui-egui/src/addons/document/tests.rs
+++ b/crates/ui-egui/src/addons/document/tests.rs
@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use serde_json::json;
 use vectorcraft_engine::Session;
 
-use super::SAVE_COPY;
+use super::{EXPORT_ALL, SAVE_COPY};
 use crate::{VectorcraftApp, menus};
 
 /// A new, empty folder of its own for test `name`.
@@ -46,6 +46,64 @@ fn save_a_timestamped_copy_writes_beside_the_document() {
     let _ = std::fs::remove_dir_all(&dir);
 }
 
+/// A `.ai` timestamped copy, and a `.ai` copy Export All Open Documents writes, name the view's
+/// active artboard as their active one.
+#[test]
+fn ai_copies_name_the_views_active_artboard() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 60, "height": 40, "artboards": 3})).unwrap();
+    app.sync_views();
+    app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+    let opts = vectorcraft_engine::cmd::fileio::LoadOptions { native: false, ..Default::default() };
+    for (i, (cmd, artboard)) in [(SAVE_COPY, 2), (EXPORT_ALL, 1)].into_iter().enumerate() {
+        let dir = folder(&format!("active-artboard-{i}"));
+        if let Some(v) = app.view_mut() {
+            v.artboard = artboard;
+        }
+        app.run(cmd, json!({"folder": dir, "format": "ai"})).unwrap();
+        let names = files(&dir);
+        assert_eq!(names.len(), 1, "{cmd}: {names:?}");
+        let bytes = std::fs::read(dir.join(&names[0])).unwrap();
+        let l = vectorcraft_engine::cmd::fileio::load_with("a.ai", &bytes, &opts).unwrap();
+        assert!(l.editing_data && !l.restored, "{cmd}: {:?}", l.warnings);
+        assert_eq!(l.doc.opened_artboard.and_then(|id| l.doc.artboards.iter().position(|a| a.id == id)), Some(artboard), "{cmd}");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
+
+/// Export All Open Documents as `.ai` names each document's own active artboard, also for a
+/// document whose artboard changed in its view after the last command and that is not active.
+#[test]
+fn export_all_names_each_documents_active_artboard() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    for name in ["first", "second"] {
+        app.run("file.new", json!({"width": 60, "height": 40, "artboards": 3, "name": name})).unwrap();
+        app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+    }
+    app.sync_views();
+    // Choosing a tab and an artboard runs no command.
+    assert!(app.session.set_active(0));
+    if let Some(v) = app.view_mut() {
+        v.artboard = 2;
+    }
+    assert!(app.session.set_active(1));
+    if let Some(v) = app.view_mut() {
+        v.artboard = 1;
+    }
+    let dir = folder("export-all-active-artboards");
+    let r = app.run(EXPORT_ALL, json!({"folder": dir, "format": "ai"})).unwrap();
+    let opts = vectorcraft_engine::cmd::fileio::LoadOptions { native: false, ..Default::default() };
+    let written = r["files"].as_array().unwrap();
+    assert_eq!(written.len(), 2, "{r}");
+    for (f, artboard) in written.iter().zip([2, 1]) {
+        let bytes = std::fs::read(f["path"].as_str().unwrap()).unwrap();
+        let l = vectorcraft_engine::cmd::fileio::load_with("a.ai", &bytes, &opts).unwrap();
+        assert!(l.editing_data && !l.restored, "{:?}", l.warnings);
+        assert_eq!(l.doc.opened_artboard.and_then(|id| l.doc.artboards.iter().position(|a| a.id == id)), Some(artboard), "{}", f["title"]);
+    }
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
 #[test]
 fn an_unsaved_document_asks_for_a_folder() {
     let dir = folder("picked");
diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
index 4698856df..0b508abfa 100644
--- a/crates/ui-egui/src/app.rs
+++ b/crates/ui-egui/src/app.rs
@@ -80,6 +80,7 @@ impl VectorcraftApp {
                 print_tiling: None,
                 live_paint_gaps: None,
                 hidden_chars: Default::default(),
+                selection_marks: Default::default(),
                 selection_box: None,
                 selection_bounds: None,
                 content_bounds: None,
@@ -550,6 +551,7 @@ impl VectorcraftApp {
         export_progress::show(self, &ctx);
         plugin_runs::show(self, &ctx);
         trace_runs::show(self, &ctx);
+        opening::show(self, &ctx);
         palette::show(self, &ctx);
         if self.custom_titlebar {
             titlebar::resize_zones(ui);
diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs
index 0652e6d9a..bcd7c578f 100644
--- a/crates/ui-egui/src/app/commands.rs
+++ b/crates/ui-egui/src/app/commands.rs
@@ -93,6 +93,9 @@ impl VectorcraftApp {
         if cfg!(debug_assertions) {
             menus::check_params(&self.session, id, &params)?;
         }
+        // A `.ai` file a command writes (a save, an export, a timestamped copy, a batch's save) names
+        // the view's active artboard.
+        io::remember_active_artboard(self);
         let artboards = self.artboard_tool_state();
         if let Some(r) = menus::run_ui_command(self, id, &params) {
             self.follow_artboard_tool(artboards);
@@ -199,7 +202,7 @@ impl VectorcraftApp {
         {
             self.last_pathfinder = Some(op.to_string());
         }
-        if r.is_ok() && matches!(id, "edit.copy" | "edit.cut") {
+        if r.is_ok() && matches!(id, "edit.copy" | "edit.cut" | "artboard.copy" | "artboard.cut") {
             self.publish_clipboard();
         }
         self.sync_views();
diff --git a/crates/ui-egui/src/caches.rs b/crates/ui-egui/src/caches.rs
index 736100377..ddb649708 100644
--- a/crates/ui-egui/src/caches.rs
+++ b/crates/ui-egui/src/caches.rs
@@ -41,6 +41,9 @@ pub struct CanvasCache {
     /// The marks Type → Show Hidden Characters drew on each text object in the last frame. A frame
     /// that does not draw them drops them ([`canvas::show`]).
     pub hidden_chars: canvas::HiddenChars,
+    /// The selected objects' outlines, anchors and handles as drawn in the last frame. A frame that
+    /// does not draw them drops them ([`canvas::show`]).
+    pub selection_marks: canvas::SelectionMarks,
     /// [`VectorcraftApp::selection_box`] for (document uid, revision, Use Preview Bounds).
     pub selection_box: Option<((u64, u64, bool), Option<vectorcraft_doc::OrientedBox>)>,
     /// [`VectorcraftApp::selection_bounds`] for (document uid, revision).
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index 8e3315e35..6210c2826 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -28,6 +28,7 @@ mod outline;
 mod overlays;
 mod panes;
 mod raster;
+mod selection_marks;
 mod task_bar;
 mod tool_overlays;
 mod view;
@@ -65,6 +66,7 @@ pub use panes::Panes;
 pub(crate) use panes::{consolidate, pane, tile, tiled_area};
 use raster::{changed_pixels, pixel_region, upload};
 pub(crate) use raster::{color_image, color_image_owned};
+pub use selection_marks::SelectionMarks;
 use task_bar::task_bar;
 pub(crate) use task_bar::{has_colors, task_bar_rect};
 pub use tool_overlays::HiddenChars;
@@ -193,6 +195,8 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     // that does not draw the overlay drops them, for example with the option off, with the edges
     // hidden, on the Home screen or with no document open.
     let hidden_chars = std::mem::take(&mut app.canvas.hidden_chars);
+    // The selection's kept marks. Likewise, a frame that does not draw them drops them.
+    let selection_marks = std::mem::take(&mut app.canvas.selection_marks);
     // A release ends the Image Trace panel's eye-button hold, also when the panel is no longer
     // drawn, so a later press elsewhere does not show the source image.
     if app.ui.trace_hold_source.is_some() && !ui.input(|i| i.pointer.any_down()) {
@@ -336,7 +340,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         }
         original_path_overlay(app, &painter, &xf);
 
-        let overlays = selection_visuals(app, &painter, &xf, (hidden_chars, hover_still), revolve_edit, view_info);
+        let overlays = selection_visuals(app, &painter, &xf, (hidden_chars, selection_marks, hover_still), revolve_edit, view_info);
         draw_overlays(&painter, &xf, &overlays, &t, HandleLook::of(&app.session.prefs));
         if !revolve_edit {
             shaper_widget_overlay(app, &painter, &xf);
@@ -894,7 +898,7 @@ fn selection_visuals(
     app: &mut VectorcraftApp,
     painter: &egui::Painter,
     xf: &Xf,
-    (hidden_chars, hover_still): (HiddenChars, bool),
+    (hidden_chars, mut marks, hover_still): (HiddenChars, SelectionMarks, bool),
     revolve_edit: bool,
     view_info: vectorcraft_engine::ViewInfo,
 ) -> Vec<Overlay> {
@@ -910,7 +914,8 @@ fn selection_visuals(
         if hover_still {
             hover_highlight(app, painter, xf);
         }
-        selection_overlay(app, painter, xf, overlays.iter().any(|o| matches!(o, Overlay::CurvePoint { .. })));
+        selection_overlay(app, painter, xf, overlays.iter().any(|o| matches!(o, Overlay::CurvePoint { .. })), &mut marks);
+        app.canvas.selection_marks = marks;
         draw_inside_overlay(app, painter, xf);
         mirror_axis_overlay(app, painter, xf);
         grid_repeat_overlay(app, painter, xf);
diff --git a/crates/ui-egui/src/canvas/context.rs b/crates/ui-egui/src/canvas/context.rs
index 38311b773..5af09ab3b 100644
--- a/crates/ui-egui/src/canvas/context.rs
+++ b/crates/ui-egui/src/canvas/context.rs
@@ -6,7 +6,8 @@ use super::{Ui, VectorcraftApp, Xf, json, widgets};
 /// objects under the pointer ([`vectorcraft_doc::hit::locked_objects_at`]) are kept in
 /// `ui.context_locked` while the menu is open, for its Unlock submenu. With the Intertwine tool, a
 /// right-click where three or more objects of the group overlap keeps the selection and puts what
-/// it arranges in `ui.context_intertwine` ([`vectorcraft_tools::intertwine::menu_target`]).
+/// it arranges in `ui.context_intertwine` ([`vectorcraft_tools::intertwine::menu_target`]). With the
+/// Artboard tool, an artboard takes the place of the object ([`crate::panels::artboards::right_click`]).
 pub(super) fn context_menu(app: &mut VectorcraftApp, resp: &egui::Response, xf: &Xf) {
     if resp.secondary_clicked()
         && let Some(p) = resp.interact_pointer_pos()
@@ -19,7 +20,12 @@ pub(super) fn context_menu(app: &mut VectorcraftApp, resp: &egui::Response, xf:
             .active()
             .filter(|_| app.session.tool_id() == "intertwine")
             .and_then(|st| vectorcraft_tools::intertwine::menu_target(&st.doc, &st.selection.objects, p).map(|(g, m)| (st.uid, g, p, m)));
-        if app.ui.context_intertwine.is_none()
+        let on_artboards = app.session.tool_id() == "artboard";
+        if on_artboards {
+            crate::panels::artboards::right_click(app, p);
+        }
+        if !on_artboards
+            && app.ui.context_intertwine.is_none()
             && let Some(st) = app.session.active()
             && let Some(top) = selection_hit_at(app, p, xf.zoom).map(|h| h.top_object(st.isolation))
             && !st.selection.contains(top)
@@ -32,6 +38,7 @@ pub(super) fn context_menu(app: &mut VectorcraftApp, resp: &egui::Response, xf:
     if resp.context_menu(|ui| crate::menus::context_menu_body(app, ui, &mut clicked)).is_none() {
         app.ui.context_locked = None;
         app.ui.context_intertwine = None;
+        app.ui.context_artboards = None;
     }
     if let Some((id, p)) = clicked {
         crate::menus::invoke(app, &id, p);
diff --git a/crates/ui-egui/src/canvas/home.rs b/crates/ui-egui/src/canvas/home.rs
index d73a5c5bb..cd2ac9c44 100644
--- a/crates/ui-egui/src/canvas/home.rs
+++ b/crates/ui-egui/src/canvas/home.rs
@@ -25,18 +25,25 @@ pub(super) fn home(app: &mut VectorcraftApp, ui: &mut Ui, rect: egui::Rect) {
 /// The Home screen's column: welcome, New / Open, Recent Files, presets and community links.
 fn home_content(app: &mut VectorcraftApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
-    ui.label(egui::RichText::new(tl!("Welcome to VectorCraft")).font(theme::semibold(26.0)).color(t.text));
-    ui.add_space(4.0);
-    ui.label(egui::RichText::new(tl!("Vector illustration — fast, open, scriptable.")).size(14.0).color(t.text_dim));
-    ui.add_space(22.0);
-    ui.horizontal(|ui| {
-        if widgets::primary_button(ui, tl!("New file")).clicked() {
-            app.run("file.newDialog", json!({})).ok();
-        }
-        ui.add_space(8.0);
-        if widgets::secondary_button(ui, tl!("Open")).clicked() {
-            app.run("file.open", json!({})).ok();
-        }
+    // The welcome and the New / Open buttons sit centred, as PhotoCraft's Home screen does (#4684).
+    ui.vertical_centered(|ui| {
+        ui.label(egui::RichText::new(tl!("Welcome to VectorCraft")).font(theme::semibold(26.0)).color(t.text));
+        ui.add_space(4.0);
+        ui.label(egui::RichText::new(tl!("Vector illustration — fast, open, scriptable.")).size(14.0).color(t.text_dim));
+        ui.add_space(22.0);
+        // `horizontal` fills the width, so the row's own width sets its left edge.
+        let gap = ui.spacing().item_spacing.x + 8.0;
+        let row = widgets::button_width(ui, tl!("New file")) + gap + widgets::button_width(ui, tl!("Open"));
+        ui.horizontal(|ui| {
+            ui.add_space(((ui.available_width() - row) / 2.0).max(0.0));
+            if widgets::primary_button(ui, tl!("New file")).clicked() {
+                app.run("file.newDialog", json!({})).ok();
+            }
+            ui.add_space(8.0);
+            if widgets::secondary_button(ui, tl!("Open")).clicked() {
+                app.run("file.open", json!({})).ok();
+            }
+        });
     });
     recent(app, ui);
     ui.add_space(28.0);
@@ -54,9 +61,11 @@ fn home_content(app: &mut VectorcraftApp, ui: &mut Ui) {
         }
     });
     ui.add_space(28.0);
-    ui.label(egui::RichText::new(tl!("Community")).font(theme::semibold(14.0)).color(t.text));
-    ui.add_space(10.0);
-    crate::community::links(app, ui);
+    ui.vertical_centered(|ui| {
+        ui.label(egui::RichText::new(tl!("Community")).font(theme::semibold(14.0)).color(t.text));
+        ui.add_space(10.0);
+        crate::community::links_centered(app, ui);
+    });
 }
 
 /// The Home screen's Recent Files (#663): the first of File › Open Recent Files, each its name and
diff --git a/crates/ui-egui/src/canvas/overlays.rs b/crates/ui-egui/src/canvas/overlays.rs
index 206b095ca..8779380ec 100644
--- a/crates/ui-egui/src/canvas/overlays.rs
+++ b/crates/ui-egui/src/canvas/overlays.rs
@@ -1,7 +1,8 @@
 use super::artboards::names_an_artboard;
 use super::input::marquee_through;
-use super::outline::{KEY_OUTLINE, c32, node_outline, selection_hit_at, stroke_path, to_screen_path, too_many_anchors, walk_drawn};
-use super::{Color32, CornerRadius, NodeKind, Overlay, Point, Pos2, Shape, Stroke, StrokeKind, Tokens, VectorcraftApp, Xf, vec2};
+use super::outline::{KEY_OUTLINE, c32, node_outline, selection_hit_at, stroke_path, to_screen_path, too_many_anchors};
+use super::selection_marks::{MarkOptions, SelectionMarks};
+use super::{Color32, CornerRadius, NodeKind, Overlay, Pos2, Shape, Stroke, StrokeKind, Tokens, VectorcraftApp, Xf, vec2};
 
 pub(super) fn hover_highlight(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf) {
     let Some(h) = app.hover_doc else { return };
@@ -54,9 +55,9 @@ pub(super) fn selected_anchor(c: Color32) -> Color32 {
 #[derive(Clone, Copy)]
 pub(super) struct HandleLook<'a> {
     /// Points bigger (or smaller) than the default size 3, per step of Size (1–7).
-    grow: f32,
+    pub(super) grow: f32,
     /// `solid` (the default), `hollow` or `large`.
-    style: &'a str,
+    pub(super) style: &'a str,
 }
 
 impl<'a> HandleLook<'a> {
@@ -65,17 +66,21 @@ impl<'a> HandleLook<'a> {
     }
 
     /// A direction handle's end at `c`: a solid dot, a hollow one or a larger solid one.
-    fn draw(self, p: &egui::Painter, c: Pos2, color: Color32) {
+    pub(super) fn shapes(self, c: Pos2, color: Color32) -> [Option<Shape>; 2] {
         let r = 2.75 + self.grow / 2.0;
         let hollow = self.style == "hollow";
-        p.circle_filled(c, if self.style == "large" { r + 1.5 } else { r }, if hollow { Color32::WHITE } else { color });
-        if hollow {
-            p.circle_stroke(c, r, Stroke::new(1.0, color));
+        let dot = Shape::circle_filled(c, if self.style == "large" { r + 1.5 } else { r }, if hollow { Color32::WHITE } else { color });
+        [Some(dot), hollow.then(|| Shape::circle_stroke(c, r, Stroke::new(1.0, color)))]
+    }
+
+    pub(super) fn draw(self, p: &egui::Painter, c: Pos2, color: Color32) {
+        for shape in self.shapes(c, color).into_iter().flatten() {
+            p.add(shape);
         }
     }
 }
 
-fn anchor_square(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size: f32) {
+pub(super) fn anchor_square(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size: f32) {
     let r = egui::Rect::from_center_size(c, vec2(size, size));
     if filled {
         p.rect_filled(r, 0.0, color);
@@ -85,11 +90,23 @@ fn anchor_square(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size:
     }
 }
 
-fn curve_point(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size: f32) {
+pub(super) fn curve_point(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size: f32) {
     p.circle(c, size / 2.0, if filled { color } else { Color32::WHITE }, Stroke::new(1.0, color));
 }
 
-pub(super) fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf, curve_points_from_tool: bool) {
+/// How the current tool and preferences draw the selection's marks.
+pub(super) fn mark_options(app: &VectorcraftApp, curve_points_from_tool: bool) -> MarkOptions<'_> {
+    let tool = app.session.tool_id();
+    MarkOptions {
+        direct: vectorcraft_tools::catalog::edits_anchors(tool),
+        curvature: tool == "curvature",
+        curve_points_from_tool,
+        look: HandleLook::of(&app.session.prefs),
+        all_handles: app.session.prefs.show_handles_multiple_anchors,
+    }
+}
+
+pub(super) fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf, curve_points_from_tool: bool, marks: &mut SelectionMarks) {
     // The Selection tool's bounding box (rotated with the objects after a rotation), also shown by
     // the shape tools that keep a shape just drawn ready to adjust while they draw none (#5477). It
     // hides while a drag moves or resizes the selection, so only the art is seen going with the
@@ -121,130 +138,29 @@ pub(super) fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf:
     let symbols = st.doc.symbol_boxes();
     let tool = app.session.tool_id();
     let direct = vectorcraft_tools::catalog::edits_anchors(tool);
-    let curvature = tool == "curvature";
     // Selection & Anchor Display › Size (1–7, 3 the default): anchors, handles and the bounding
     // box's handles a point bigger or smaller per step.
-    let look = HandleLook::of(&app.session.prefs);
-    let grow = look.grow;
+    let options = mark_options(app, curve_points_from_tool);
+    let grow = options.look.grow;
     let anchor = |direct: bool| grow + if direct { 5.0 } else { 4.0 };
-    // The selected anchors' handles (drawn once they are counted: Show handles when multiple
-    // anchors are selected off shows them for a single one only).
-    let (mut handles, mut with_handles) = (vec![], 0);
     // Too many paths to outline: the selection's bounds stand for them.
     if let Some((b, id)) = big_bounds.zip(st.selection.objects.first()) {
         stroke_path(p, &vectorcraft_geom::shapes::rectangle(b).to_bezpath(), xf, Stroke::new(1.0, c32(st.doc.layer_color(*id))));
     }
     // The key object (Align to Key Object): its outline drawn thicker, or its bounds when it has
     // too many paths to outline.
-    if let Some((k, n)) = st.selection.key.and_then(|k| Some((k, st.doc.node(k)?))) {
-        let outline = if too_many_anchors([n]) {
-            n.geometric_bounds_with(&symbols).map(|b| vectorcraft_geom::shapes::rectangle(b).to_bezpath())
-        } else {
-            Some(node_outline(n, &symbols))
-        };
-        if let Some(bp) = outline {
-            stroke_path(p, &bp, xf, Stroke::new(KEY_OUTLINE, c32(st.doc.layer_color(k))));
-        }
-    }
-    for id in st.selection.objects.iter().filter(|_| !big) {
-        let Some(n) = st.doc.node(*id) else { continue };
-        let color = c32(st.doc.layer_color(*id));
-        let partial = st.selection.partial(*id);
-        // Path outlines (and area type / placed document / image / mesh / symbol outlines;
-        // point type baselines and origin are drawn below).
-        if !matches!(n.kind, NodeKind::Text(ref tx) if matches!(tx.kind, vectorcraft_doc::TextKind::Point)) {
-            stroke_path(p, &node_outline(n, &symbols), xf, Stroke::new(1.0, color));
-        }
-        // Anchors (and handles for selected anchors in direct mode); a gradient mesh's or a mesh
-        // envelope's points.
-        walk_drawn(n, &mut |c| {
-            let envelope = vectorcraft_doc::live::envelope_overlay(c).and_then(|(_, grid)| grid);
-            let grid = match &c.kind {
-                NodeKind::Mesh(m) => Some(m),
-                _ => envelope.as_ref(),
-            };
-            if let Some(grid) = grid {
-                for q in &grid.points {
-                    anchor_square(p, xf.to_screen(q.p), color, false, anchor(direct));
-                }
-                return;
-            }
-            let NodeKind::Path { path, .. } = &c.kind else { return };
-            // The Curvature tool owns its points while drawing; existing paths use this overlay.
-            if curvature && curve_points_from_tool {
-                return;
-            }
-            let selected_segments = st.selection.segments.get(&c.id);
-            if let Some(segments) = selected_segments {
-                for &(si, seg) in segments {
-                    let Some(sp) = path.subpaths.get(si).filter(|sp| seg < sp.segment_count()) else { continue };
-                    let curve = sp.segment(seg);
-                    let mut outline = vectorcraft_geom::BezPath::new();
-                    outline.move_to(curve.p0);
-                    if sp.segment_is_line(seg) {
-                        outline.line_to(curve.p3);
-                    } else {
-                        outline.curve_to(curve.p1, curve.p2, curve.p3);
-                    }
-                    stroke_path(p, &outline, xf, Stroke::new(2.0, color));
-                }
-            }
-            for (si, ai, a) in path.anchors() {
-                // An object selected whole has all its anchors selected, and so do the paths inside a
-                // group, compound path or clip group selected whole. Direction handles show only on a
-                // path that is selected itself: those are the handles that `handle_anchors` in
-                // `vectorcraft-tools` lets the tools drag.
-                let (sel, handles_shown) = match partial {
-                    Some(set) => {
-                        let sel = set.contains(&(si, ai));
-                        (sel, sel)
-                    }
-                    None => (true, direct && c.id == *id),
-                };
-                let sp = xf.to_screen(a.p);
-                if !curvature && handles_shown {
-                    with_handles += 1;
-                    let sides = path.subpaths.get(si).map(|subpath| st.selection.handle_sides(c.id, si, ai, subpath)).unwrap_or((true, true));
-                    handles.extend(
-                        [(a.h_in, sides.0), (a.h_out, sides.1)]
-                            .into_iter()
-                            .filter(|(h, show)| *show && h.distance(a.p) > 1e-6)
-                            .map(|(h, _)| (sp, xf.to_screen(h), color)),
-                    );
-                }
-                let anchor_selected = sel && selected_segments.is_none();
-                let ink = if anchor_selected && partial.is_some() { selected_anchor(color) } else { color };
-                if curvature {
-                    curve_point(p, sp, ink, anchor_selected && partial.is_some(), grow + 6.0);
-                } else {
-                    anchor_square(p, sp, ink, anchor_selected, anchor(partial.is_some() || direct));
-                }
-            }
-        });
-        // Centre point (Attributes panel → Show Center).
-        if n.shows_center()
-            && let Some(b) = n.geometric_bounds_with(&symbols)
-        {
-            anchor_square(p, xf.to_screen(b.center()), color, true, anchor(false));
-        }
-        // Point type: each line's baseline, where a click selects it (`hit`), whatever its
-        // alignment and rotation, and the anchor (area type shows its frame instead, which may
-        // not be a rectangle, and type on a path its path).
-        if let NodeKind::Text(tx) = &n.kind
-            && matches!(tx.kind, vectorcraft_doc::TextKind::Point)
-        {
-            for (a, b) in tx.baselines() {
-                p.line_segment([xf.to_screen(tx.xf * a), xf.to_screen(tx.xf * b)], Stroke::new(1.0, color));
-            }
-            p.circle_filled(xf.to_screen(tx.xf * Point::ZERO), 2.5, color);
-        }
-    }
-    if app.session.prefs.show_handles_multiple_anchors || with_handles <= 1 {
-        for (sp, hp, color) in handles {
-            p.line_segment([sp, hp], Stroke::new(1.0, color));
-            look.draw(p, hp, color);
-        }
+    let key = st.selection.key.and_then(|k| Some((k, st.doc.node(k)?)));
+    let (key_bounds, key_outline) = match key {
+        Some((k, n)) if too_many_anchors([n]) => (Some((k, n)), None),
+        Some((k, _)) => (None, Some(k)),
+        None => (None, None),
+    };
+    if let Some((k, n)) = key_bounds
+        && let Some(b) = n.geometric_bounds_with(&symbols)
+    {
+        stroke_path(p, &vectorcraft_geom::shapes::rectangle(b).to_bezpath(), xf, Stroke::new(KEY_OUTLINE, c32(st.doc.layer_color(k))));
     }
+    marks.paint(st, p, xf, &options, key_outline, if big { &[] } else { &st.selection.objects });
     // The spine of each selected blend (or of the blend a selected key object belongs to).
     let mut spines = vec![];
     for id in &st.selection.objects {
diff --git a/crates/ui-egui/src/canvas/selection_marks.rs b/crates/ui-egui/src/canvas/selection_marks.rs
new file mode 100644
index 000000000..f99899863
--- /dev/null
+++ b/crates/ui-egui/src/canvas/selection_marks.rs
@@ -0,0 +1,941 @@
+//! The selected objects' outlines, anchors and handles, kept between frames.
+//!
+//! Outlines, handles and slanted lines are kept as triangles. Anchor squares, and level or upright
+//! lines that are not handles, are kept as document points. Each selected object has an
+//! [`ObjectMarks`], valid for one node (by [`Arc`] identity), layer color and set of selected
+//! anchors, for the document and revision if the object uses symbols, and within [`MAX_PAN`]. The
+//! marks of all objects are joined into one mesh, in the order they are drawn. A frame with nothing
+//! changed draws that mesh again. A pan moves the triangles of outlines and handles, and places the
+//! anchor squares again, because a square's edges are rounded to whole pixels where it lands. Each
+//! subpath, handle and square is tested against the view on its own: one out of view adds nothing
+//! to the mesh, and a subpath or handle gets its triangles the first time it is in view. A frame
+//! with a new zoom, rotation or display scale draws plain shapes and keeps nothing, and the next
+//! frame with the same view builds the marks.
+
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::ops::Range;
+use std::sync::{Arc, Weak};
+
+use egui::emath::{GuiRounding as _, TSTransform};
+use egui::epaint::{ClippedShape, Primitive, RectShape, TessellationOptions, Tessellator, Vertex};
+use egui::{Mesh, Vec2};
+use vectorcraft_doc::{AnchorRef, NodeId, SegmentRef};
+
+use super::outline::{KEY_OUTLINE, c32, node_outline, to_screen_path, walk_drawn};
+use super::overlays::{HandleLook, anchor_square, selected_anchor};
+use super::{BezPath, Color32, Node, NodeKind, Point, Pos2, Shape, Stroke, StrokeKind, SymbolBoxes, Xf, pos2, vec2};
+
+/// How far a pan moves an object's kept marks, on either axis, before the object is built again.
+/// Screen coordinates are `f32`, which holds a coordinate under 2^16 to within 1/256 px, and a point
+/// farther out than this plus the width of a window stays off screen.
+const MAX_PAN: f64 = 16_384.0;
+
+/// The most points and vertices kept. Past this the marks are dropped after the frame that built
+/// them.
+const MAX_KEPT: usize = 8_000_000;
+
+/// The most anchor square meshes kept, one per color, style and size in pixels.
+const MAX_TEMPLATES: usize = 256;
+
+/// The farthest a handle's dot and its stroke reach from the end of its line, at the default size.
+const HANDLE_REACH: f32 = 6.0;
+
+/// Everything that decides how marks look, apart from the object and the view's position.
+#[derive(Clone, PartialEq)]
+struct MarkLook {
+    zoom: f64,
+    rot: f64,
+    pixels_per_point: f32,
+    tessellation: TessellationOptions,
+    /// Disc texture coordinates scale with the size of the font texture.
+    font_image_size: [usize; 2],
+    direct: bool,
+    curvature: bool,
+    curve_points_from_tool: bool,
+    grow: f32,
+    handle_style: String,
+    segments: BTreeMap<NodeId, BTreeSet<SegmentRef>>,
+}
+
+/// The options [`SelectionMarks::paint`] draws with.
+#[derive(Clone, Copy)]
+pub(super) struct MarkOptions<'a> {
+    /// Whether the tool edits anchors.
+    pub direct: bool,
+    /// Whether the tool is the Curvature tool.
+    pub curvature: bool,
+    /// Whether the Curvature tool draws its own points.
+    pub curve_points_from_tool: bool,
+    /// Selection & Anchor Display › Size and Handles.
+    pub look: HandleLook<'a>,
+    /// Selection & Anchor Display › Show handles when multiple anchors are selected.
+    pub all_handles: bool,
+}
+
+/// A view's position: the document point at the middle of the canvas, and that middle on screen.
+#[derive(Clone, Copy, PartialEq)]
+struct ViewAt {
+    origin: Pos2,
+    center: Point,
+}
+
+/// [`Xf`] with its rotation worked out.
+struct ViewMap {
+    sin: f64,
+    cos: f64,
+    zoom: f64,
+    at: ViewAt,
+}
+
+impl ViewMap {
+    fn new(xf: &Xf) -> Self {
+        let (sin, cos) = xf.rot.sin_cos();
+        Self { sin, cos, zoom: xf.zoom, at: ViewAt { origin: xf.rect.center(), center: xf.center } }
+    }
+
+    /// A distance in the document, scaled and rotated by the view.
+    fn turned(&self, dx: f64, dy: f64) -> [f64; 2] {
+        let (x, y) = (dx * self.zoom, dy * self.zoom);
+        [x * self.cos - y * self.sin, x * self.sin + y * self.cos]
+    }
+
+    /// The same result as [`Xf::to_screen`].
+    fn to_screen(&self, p: Point) -> Pos2 {
+        let [x, y] = self.turned(p.x - self.at.center.x, p.y - self.at.center.y);
+        pos2(self.at.origin.x + x as f32, self.at.origin.y + y as f32)
+    }
+
+    /// How far on screen a point moves between the view position `from` and this one.
+    fn moved_from(&self, from: ViewAt) -> [f64; 2] {
+        let [x, y] = self.turned(from.center.x - self.at.center.x, from.center.y - self.at.center.y);
+        [x + f64::from(self.at.origin.x - from.origin.x), y + f64::from(self.at.origin.y - from.origin.y)]
+    }
+
+    fn moved_vec(&self, from: ViewAt) -> Vec2 {
+        let [x, y] = self.moved_from(from);
+        vec2(x as f32, y as f32)
+    }
+}
+
+/// The triangles of one item in its run's mesh.
+#[derive(Clone)]
+struct Span {
+    vertices: Range<u32>,
+    indices: Range<u32>,
+}
+
+/// A polyline, disc or slanted line in a [`Mark::Rigid`].
+struct RigidPiece {
+    /// The shape, in screen coordinates at the object's `base`, until it is first on screen.
+    shape: Option<Shape>,
+    /// Where the shape draws at the object's `base`.
+    bounds: egui::Rect,
+    span: Span,
+}
+
+/// A direction handle in a [`Mark::Handles`]: the line from its anchor and the dot at its end.
+struct HandleLine {
+    from: Point,
+    to: Point,
+    /// Whether the line is, or is nearly, level or upright. Its triangles then move only by whole
+    /// pixels, and any other move draws it again.
+    rounded: bool,
+    /// The view position its triangles were drawn for.
+    at: ViewAt,
+    /// Its triangles, from the first time it is on screen.
+    span: Option<Span>,
+}
+
+/// One run of an object's marks.
+enum Mark {
+    /// Marks whose triangles keep their form when moved: polylines, discs and slanted lines.
+    /// `mesh` holds the triangles of the pieces that have been on screen.
+    Rigid { pieces: Vec<RigidPiece>, mesh: Mesh, points: usize },
+    /// Direction handles of one color. `mesh` holds the triangles of those that have been on screen.
+    Handles { color: Color32, lines: Vec<HandleLine>, mesh: Mesh },
+    /// Anchor squares in one style, at these document points.
+    Squares { color: Color32, filled: bool, size: f32, at: Vec<Point> },
+    /// A line that is, or is nearly, level or upright: the tessellator rounds those to whole pixels.
+    Segment { a: Point, b: Point, stroke: Stroke },
+}
+
+impl Mark {
+    fn kept(&self) -> usize {
+        match self {
+            Self::Rigid { mesh, points, .. } => mesh.vertices.len().max(*points),
+            Self::Handles { lines, mesh, .. } => mesh.vertices.len() + lines.len(),
+            Self::Squares { at, .. } => at.len(),
+            Self::Segment { .. } => 1,
+        }
+    }
+}
+
+/// Builds a list of [`Mark`]s, joining neighbors that can be drawn as one run.
+struct MarkList<'a> {
+    map: &'a ViewMap,
+    marks: Vec<Mark>,
+}
+
+impl<'a> MarkList<'a> {
+    fn new(map: &'a ViewMap) -> Self {
+        Self { map, marks: vec![] }
+    }
+
+    fn rigid(&mut self, shape: Shape) {
+        let count = match &shape {
+            Shape::Path(path) => path.points.len(),
+            _ => 1,
+        };
+        let piece = RigidPiece { bounds: shape.visual_bounding_rect(), shape: Some(shape), span: Span { vertices: 0..0, indices: 0..0 } };
+        if let Some(Mark::Rigid { pieces, points, .. }) = self.marks.last_mut() {
+            *points += count;
+            pieces.push(piece);
+        } else {
+            self.marks.push(Mark::Rigid { pieces: vec![piece], mesh: Mesh::default(), points: count });
+        }
+    }
+
+    /// A direction handle: its line from `from` and the dot at `to`.
+    fn handle(&mut self, from: Point, to: Point, color: Color32) {
+        let rounded = is_rounded_line(self.map.to_screen(from), self.map.to_screen(to));
+        let line = HandleLine { from, to, rounded, at: self.map.at, span: None };
+        if let Some(Mark::Handles { color: c, lines, .. }) = self.marks.last_mut()
+            && *c == color
+        {
+            lines.push(line);
+        } else {
+            self.marks.push(Mark::Handles { color, lines: vec![line], mesh: Mesh::default() });
+        }
+    }
+
+    fn outline(&mut self, path: &BezPath, xf: &Xf, stroke: Stroke) {
+        for line in to_screen_path(path, xf) {
+            self.rigid(Shape::line(line, stroke));
+        }
+    }
+
+    fn square(&mut self, p: Point, color: Color32, filled: bool, size: f32) {
+        if let Some(Mark::Squares { color: c, filled: f, size: s, at }) = self.marks.last_mut()
+            && (*c, *f, *s) == (color, filled, size)
+        {
+            at.push(p);
+        } else {
+            self.marks.push(Mark::Squares { color, filled, size, at: vec![p] });
+        }
+    }
+
+    fn line(&mut self, from: Point, to: Point, stroke: Stroke) {
+        let (sa, sb) = (self.map.to_screen(from), self.map.to_screen(to));
+        if is_rounded_line(sa, sb) {
+            self.marks.push(Mark::Segment { a: from, b: to, stroke });
+        } else {
+            self.rigid(Shape::line_segment([sa, sb], stroke));
+        }
+    }
+}
+
+/// Whether a line from `a` to `b` is, or after a move could be, exactly level or upright.
+fn is_rounded_line(a: Pos2, b: Pos2) -> bool {
+    (a.x - b.x).abs() < 0.002 || (a.y - b.y).abs() < 0.002
+}
+
+/// The marks of one object (or the key object's outline), and what they were built from.
+struct ObjectMarks {
+    /// Holds the allocation, so that no later node can have this address. While it exists,
+    /// `Arc::make_mut` moves an edited node to a new address.
+    node: Weak<Node>,
+    color: Color32,
+    partial: Option<BTreeSet<AnchorRef>>,
+    /// The document and revision, for an object that measures symbols' art.
+    symbols: Option<(u64, u64)>,
+    /// The view position when the marks were built.
+    base: ViewAt,
+    marks: Vec<Mark>,
+    handles: Vec<Mark>,
+    /// The anchors whose handles `handles` shows.
+    with_handles: usize,
+    seen: u64,
+}
+
+impl ObjectMarks {
+    fn current(&self, node: &Arc<Node>, color: Color32, partial: Option<&BTreeSet<AnchorRef>>, source: (u64, u64), map: &ViewMap) -> bool {
+        let [x, y] = map.moved_from(self.base);
+        Weak::as_ptr(&self.node) == Arc::as_ptr(node)
+            && self.color == color
+            && self.partial.as_ref() == partial
+            && self.symbols.is_none_or(|s| s == source)
+            && x.abs() <= MAX_PAN
+            && y.abs() <= MAX_PAN
+    }
+}
+
+/// The node `id` as held in the document, for its identity.
+fn node_arc(doc: &vectorcraft_doc::Document, id: NodeId) -> Option<&Arc<Node>> {
+    let path = doc.index_path(id)?;
+    let (first, rest) = path.split_first()?;
+    let mut node = doc.layers.get(*first)?;
+    for i in rest {
+        node = node.children()?.get(*i)?;
+    }
+    Some(node)
+}
+
+/// A square's triangles, relative to the corner it was rounded to.
+struct Template {
+    color: Color32,
+    filled: bool,
+    size: f32,
+    pixels: (i32, i32),
+    mesh: Mesh,
+}
+
+/// A handle's dot in one color, around the origin.
+struct Dot {
+    color: Color32,
+    mesh: Mesh,
+}
+
+/// A disc in one style, around the origin.
+struct Disc {
+    radius: f32,
+    fill: Color32,
+    stroke: Stroke,
+    mesh: Mesh,
+}
+
+/// What one anchor square draws: the fill, then the stroke of a hollow one.
+fn square_shapes(rect: egui::Rect, color: Color32, filled: bool) -> [Option<RectShape>; 2] {
+    if filled {
+        [Some(RectShape::filled(rect, 0.0, color)), None]
+    } else {
+        [Some(RectShape::filled(rect, 0.0, Color32::WHITE)), Some(RectShape::stroke(rect, 0.0, Stroke::new(1.0, color), StrokeKind::Inside))]
+    }
+}
+
+/// `shapes` as the frame's tessellator draws them, with nothing culled.
+fn tessellated(ctx: &egui::Context, shapes: Vec<Shape>, pixels_per_point: f32) -> Mesh {
+    let clipped = shapes.into_iter().map(|shape| ClippedShape {
+        clip_rect: egui::Rect::EVERYTHING,
+        shape,
+        transform_after_tessellation: TSTransform::IDENTITY,
+    });
+    let primitives = ctx.tessellate(clipped.collect(), pixels_per_point);
+    primitives
+        .into_iter()
+        .find_map(|c| match c.primitive {
+            Primitive::Mesh(mesh) => Some(mesh),
+            Primitive::Callback(_) => None,
+        })
+        .unwrap_or_default()
+}
+
+/// Joins marks into the frame's mesh.
+struct Composer<'a> {
+    ctx: &'a egui::Context,
+    map: &'a ViewMap,
+    clip: egui::Rect,
+    pixels_per_point: f32,
+    /// Squares this size or smaller are drawn as lines, which round differently: see
+    /// [`Tessellator::tessellate_rect`].
+    thin: f32,
+    /// Draws lines and squares that rounding keeps from being reused, culled by `clip`.
+    tessellator: Tessellator,
+    /// Draws what is kept for later frames, with nothing culled. Like `tessellator`, it has no discs,
+    /// so neither draws circles: those come from `discs`, stamped where they land.
+    keeper: Tessellator,
+    /// Draws filled squares without the soft edge, when that edge falls between pixel centers: on a
+    /// square rounded to whole pixels, each pixel center is then fully in or fully out.
+    crisp: Option<Tessellator>,
+    /// Whether the tessellator rounds rectangles to whole pixels, as [`Self::squares`] assumes.
+    rounds_rects: bool,
+    look: HandleLook<'a>,
+    templates: &'a mut Vec<Template>,
+    dots: &'a mut Vec<Dot>,
+    discs: &'a mut Vec<Disc>,
+    out: Mesh,
+}
+
+/// Append `mesh` to `out`, moved by `delta`.
+fn stamp(out: &mut Mesh, mesh: &Mesh, delta: Vec2) {
+    let first = out.vertices.len() as u32;
+    out.vertices.extend(mesh.vertices.iter().map(|v| Vertex { pos: v.pos + delta, ..*v }));
+    out.indices.extend(mesh.indices.iter().map(|i| i + first));
+}
+
+/// Append the triangles of `span` in `mesh` to `out`, moved by `delta`.
+fn stamp_span(out: &mut Mesh, mesh: &Mesh, span: &Span, delta: Vec2) {
+    let vertices = mesh.vertices.get(span.vertices.start as usize..span.vertices.end as usize);
+    let indices = mesh.indices.get(span.indices.start as usize..span.indices.end as usize);
+    let (Some(vertices), Some(indices)) = (vertices, indices) else { return };
+    let first = out.vertices.len() as u32;
+    out.vertices.extend(vertices.iter().map(|v| Vertex { pos: v.pos + delta, ..*v }));
+    out.indices.extend(indices.iter().map(|i| i - span.vertices.start + first));
+}
+
+/// Run `draw` on `mesh`, and return the triangles it added.
+fn drawn_span(mesh: &mut Mesh, draw: impl FnOnce(&mut Mesh)) -> Span {
+    let (vertices, indices) = (mesh.vertices.len() as u32, mesh.indices.len() as u32);
+    draw(mesh);
+    Span { vertices: vertices..mesh.vertices.len() as u32, indices: indices..mesh.indices.len() as u32 }
+}
+
+impl Composer<'_> {
+    fn marks(&mut self, marks: &mut [Mark], base: ViewAt) {
+        let delta = self.map.moved_vec(base);
+        let margin = 2.0 / self.pixels_per_point;
+        for mark in marks {
+            match mark {
+                Mark::Rigid { pieces, mesh, .. } => {
+                    for piece in pieces {
+                        if !piece.bounds.translate(delta).expand(margin).intersects(self.clip) {
+                            continue;
+                        }
+                        if let Some(shape) = piece.shape.take() {
+                            piece.span = self.rigid_span(shape, mesh);
+                        }
+                        stamp_span(&mut self.out, mesh, &piece.span, delta);
+                    }
+                }
+                Mark::Handles { color, lines, mesh } => self.handles(*color, lines, mesh),
+                Mark::Squares { color, filled, size, at } => self.squares(*color, *filled, *size, at),
+                Mark::Segment { a, b, stroke } => {
+                    let points = [self.map.to_screen(*a), self.map.to_screen(*b)];
+                    self.tessellator.tessellate_line_segment(points, *stroke, &mut self.out);
+                }
+            }
+        }
+    }
+
+    /// Draw `shape` into `mesh`.
+    fn rigid_span(&mut self, shape: Shape, mesh: &mut Mesh) -> Span {
+        drawn_span(mesh, |mesh| match shape {
+            Shape::Circle(circle) => {
+                let index = self.disc(&circle);
+                if let Some(disc) = self.discs.get(index) {
+                    stamp(mesh, &disc.mesh, circle.center.to_vec2());
+                }
+            }
+            shape => self.keeper.tessellate_shape(shape, mesh),
+        })
+    }
+
+    /// The index of the disc in the style of `circle`, made when there is none.
+    fn disc(&mut self, circle: &egui::epaint::CircleShape) -> usize {
+        let same = |d: &Disc| d.radius == circle.radius && d.fill == circle.fill && d.stroke == circle.stroke;
+        if let Some(index) = self.discs.iter().position(same) {
+            return index;
+        }
+        let shape = Shape::Circle(egui::epaint::CircleShape { center: Pos2::ZERO, ..*circle });
+        let mesh = tessellated(self.ctx, vec![shape], self.pixels_per_point);
+        if self.discs.len() >= MAX_TEMPLATES {
+            self.discs.clear();
+        }
+        self.discs.push(Disc { radius: circle.radius, fill: circle.fill, stroke: circle.stroke, mesh });
+        self.discs.len() - 1
+    }
+
+    /// Add the direction handles in view to the frame, drawing those not yet in `mesh` into it.
+    fn handles(&mut self, color: Color32, lines: &mut [HandleLine], mesh: &mut Mesh) {
+        let index = match self.dots.iter().position(|d| d.color == color) {
+            Some(index) => index,
+            None => {
+                let shapes = self.look.shapes(Pos2::ZERO, color).into_iter().flatten().collect();
+                let mesh = tessellated(self.ctx, shapes, self.pixels_per_point);
+                if self.dots.len() >= MAX_TEMPLATES {
+                    self.dots.clear();
+                }
+                self.dots.push(Dot { color, mesh });
+                self.dots.len() - 1
+            }
+        };
+        let Some(dot) = self.dots.get(index) else { return };
+        let stroke = Stroke::new(1.0, color);
+        let reach = HANDLE_REACH + self.look.grow.max(0.0) / 2.0;
+        for line in lines {
+            let (from, to) = (self.map.to_screen(line.from), self.map.to_screen(line.to));
+            if !egui::Rect::from_two_pos(from, to).expand(reach).intersects(self.clip) {
+                continue;
+            }
+            let moved = self.map.moved_vec(line.at);
+            let whole_pixels = (moved * self.pixels_per_point).round() == moved * self.pixels_per_point;
+            let keeper = &mut self.keeper;
+            let mut draw = |mesh: &mut Mesh| {
+                keeper.tessellate_line_segment([from, to], stroke, mesh);
+                stamp(mesh, &dot.mesh, to.to_vec2());
+            };
+            match &line.span {
+                Some(span) if !line.rounded || whole_pixels => stamp_span(&mut self.out, mesh, span, moved),
+                Some(_) => draw(&mut self.out),
+                None => {
+                    let span = drawn_span(mesh, draw);
+                    stamp_span(&mut self.out, mesh, &span, Vec2::ZERO);
+                    line.at = self.map.at;
+                    line.span = Some(span);
+                }
+            }
+        }
+    }
+
+    fn squares(&mut self, color: Color32, filled: bool, size: f32, at: &[Point]) {
+        let stamps = self.rounds_rects && size > self.thin;
+        let mut template = None;
+        let mut last = None;
+        for p in at {
+            let rect = egui::Rect::from_center_size(self.map.to_screen(*p), vec2(size, size));
+            if !rect.intersects(self.clip) {
+                continue;
+            }
+            if !stamps {
+                for shape in square_shapes(rect, color, filled).into_iter().flatten() {
+                    self.tessellator.tessellate_rect(&shape, &mut self.out);
+                }
+                continue;
+            }
+            let rounded = rect.round_to_pixels(self.pixels_per_point);
+            // A filled square on the same pixels as the last one, in the same run, adds nothing.
+            if filled && last == Some(rounded) {
+                continue;
+            }
+            last = Some(rounded);
+            let pixels = ((rounded.width() * self.pixels_per_point).round() as i32, (rounded.height() * self.pixels_per_point).round() as i32);
+            let index = match template {
+                Some((p, index)) if p == pixels => index,
+                _ => self.template(color, filled, size, pixels, rect),
+            };
+            template = Some((pixels, index));
+            let Some(found) = self.templates.get(index) else { continue };
+            stamp(&mut self.out, &found.mesh, rounded.min.to_vec2());
+        }
+    }
+
+    /// The index of the template for a square in this style, made from `rect` when there is none.
+    fn template(&mut self, color: Color32, filled: bool, size: f32, pixels: (i32, i32), rect: egui::Rect) -> usize {
+        let same = |t: &Template| t.color == color && t.filled == filled && t.size == size && t.pixels == pixels;
+        if let Some(index) = self.templates.iter().position(same) {
+            return index;
+        }
+        let mut mesh = Mesh::default();
+        let tessellator = match &mut self.crisp {
+            Some(crisp) if filled => crisp,
+            _ => &mut self.keeper,
+        };
+        for shape in square_shapes(rect, color, filled).into_iter().flatten() {
+            tessellator.tessellate_rect(&shape, &mut mesh);
+        }
+        let corner = rect.round_to_pixels(self.pixels_per_point).min.to_vec2();
+        for v in &mut mesh.vertices {
+            v.pos -= corner;
+        }
+        if self.templates.len() >= MAX_TEMPLATES {
+            self.templates.clear();
+        }
+        self.templates.push(Template { color, filled, size, pixels, mesh });
+        self.templates.len() - 1
+    }
+}
+
+/// What the frame's mesh was joined for.
+#[derive(PartialEq)]
+struct Shown {
+    at: ViewAt,
+    clip: egui::Rect,
+    all_handles: bool,
+}
+
+/// The kept marks of the selection ([`CanvasCache::selection_marks`](crate::caches::CanvasCache)).
+#[derive(Default)]
+pub struct SelectionMarks {
+    look: Option<MarkLook>,
+    objects: HashMap<NodeId, ObjectMarks>,
+    key: Option<(NodeId, ObjectMarks)>,
+    templates: Vec<Template>,
+    dots: Vec<Dot>,
+    discs: Vec<Disc>,
+    frame: Arc<Mesh>,
+    shown: Option<Shown>,
+    order: Vec<NodeId>,
+    pass: u64,
+    kept: usize,
+    #[cfg(test)]
+    builds: usize,
+    #[cfg(test)]
+    composes: usize,
+}
+
+impl SelectionMarks {
+    /// Draw the key object `key`'s outline and the marks of `objects`, in that order, reusing what
+    /// is still valid. Entries of any other object are dropped.
+    pub(super) fn paint(
+        &mut self,
+        st: &vectorcraft_engine::DocState,
+        p: &egui::Painter,
+        xf: &Xf,
+        options: &MarkOptions,
+        key: Option<NodeId>,
+        objects: &[NodeId],
+    ) {
+        let ctx = p.ctx();
+        let look = MarkLook {
+            zoom: xf.zoom,
+            rot: xf.rot,
+            pixels_per_point: ctx.pixels_per_point(),
+            tessellation: ctx.tessellation_options(|o| *o),
+            font_image_size: ctx.fonts(|f| f.font_image_size()),
+            direct: options.direct,
+            curvature: options.curvature,
+            curve_points_from_tool: options.curve_points_from_tool,
+            grow: options.look.grow,
+            handle_style: options.look.style.to_owned(),
+            segments: st.selection.segments.clone(),
+        };
+        let pixels_per_point = look.pixels_per_point;
+        let tessellation = look.tessellation;
+        if self.look.as_ref() != Some(&look) {
+            self.clear();
+            self.look = Some(look);
+            draw_once(st, p, xf, options, key, objects);
+            return;
+        }
+        let map = ViewMap::new(xf);
+        let symbols = st.doc.symbol_boxes();
+        let source = (st.uid, st.revision);
+        let mut changed = self.update_key(st, key, xf, &map, &symbols, source);
+        self.pass = self.pass.wrapping_add(1);
+        let pass = self.pass;
+        for id in objects {
+            let Some(node) = node_arc(&st.doc, *id) else { continue };
+            let color = c32(st.doc.layer_color(*id));
+            match self.objects.get_mut(id) {
+                Some(entry) if entry.current(node, color, st.selection.partial(*id), source, &map) => entry.seen = pass,
+                _ => {
+                    let mut entry = object_marks(st, *id, node, color, source, xf, &map, options, &symbols);
+                    entry.seen = pass;
+                    self.objects.insert(*id, entry);
+                    changed = true;
+                    #[cfg(test)]
+                    {
+                        self.builds += 1;
+                    }
+                }
+            }
+        }
+        let kept = self.objects.len();
+        self.objects.retain(|_, entry| entry.seen == pass);
+        changed |= self.objects.len() != kept;
+        let shown = Shown { at: map.at, clip: p.clip_rect(), all_handles: options.all_handles };
+        if changed || self.shown.as_ref() != Some(&shown) || self.order != objects {
+            self.order.clear();
+            self.order.extend_from_slice(objects);
+            self.compose(ctx, &map, shown.clip, (pixels_per_point, tessellation), options);
+            self.shown = Some(shown);
+        }
+        if !self.frame.is_empty() {
+            p.add(Shape::Mesh(self.frame.clone()));
+        }
+        self.trim(MAX_KEPT);
+    }
+
+    /// Drop everything when more than `limit` points and vertices are kept.
+    fn trim(&mut self, limit: usize) {
+        if self.kept > limit {
+            self.clear();
+        }
+    }
+
+    /// Bring the key object's outline up to date. True when it changed.
+    fn update_key(
+        &mut self,
+        st: &vectorcraft_engine::DocState,
+        key: Option<NodeId>,
+        xf: &Xf,
+        map: &ViewMap,
+        symbols: &SymbolBoxes,
+        source: (u64, u64),
+    ) -> bool {
+        let Some((id, node)) = key.and_then(|id| Some((id, node_arc(&st.doc, id)?))) else { return self.key.take().is_some() };
+        let color = c32(st.doc.layer_color(id));
+        if self.key.as_ref().is_some_and(|(k, entry)| *k == id && entry.current(node, color, None, source, map)) {
+            return false;
+        }
+        self.key = Some((id, key_marks(node, color, source, xf, map, symbols)));
+        true
+    }
+
+    /// Join the marks in the order they are drawn: the key object's outline, each object's marks,
+    /// and then all the handles.
+    fn compose(
+        &mut self,
+        ctx: &egui::Context,
+        map: &ViewMap,
+        clip: egui::Rect,
+        (pixels_per_point, tessellation): (f32, TessellationOptions),
+        options: &MarkOptions,
+    ) {
+        #[cfg(test)]
+        {
+            self.composes += 1;
+        }
+        let Self { objects, key, templates, dots, discs, frame, order, kept, .. } = self;
+        let all_handles = options.all_handles;
+        let mut out = Arc::try_unwrap(std::mem::take(frame)).unwrap_or_default();
+        out.clear();
+        let font_image_size = ctx.fonts(|f| f.font_image_size());
+        let keeper = Tessellator::new(pixels_per_point, tessellation, font_image_size, vec![]);
+        let mut tessellator = keeper.clone();
+        tessellator.set_clip_rect(clip);
+        let feathering = if tessellation.feathering { tessellation.feathering_size_in_pixels / pixels_per_point } else { 0.0 };
+        let crisp = (tessellation.feathering && tessellation.feathering_size_in_pixels == 1.0)
+            .then(|| Tessellator::new(pixels_per_point, TessellationOptions { feathering: false, ..tessellation }, font_image_size, vec![]));
+        let mut composer = Composer {
+            ctx,
+            map,
+            clip,
+            pixels_per_point,
+            thin: 2.0 * feathering,
+            tessellator,
+            keeper,
+            crisp,
+            rounds_rects: tessellation.round_rects_to_pixels,
+            look: options.look,
+            templates,
+            dots,
+            discs,
+            out,
+        };
+        if let Some((_, entry)) = key {
+            composer.marks(&mut entry.marks, entry.base);
+        }
+        for id in order.iter() {
+            if let Some(entry) = objects.get_mut(id) {
+                composer.marks(&mut entry.marks, entry.base);
+            }
+        }
+        let with_handles: usize = order.iter().filter_map(|id| objects.get(id)).map(|entry| entry.with_handles).sum();
+        if all_handles || with_handles <= 1 {
+            for id in order.iter() {
+                if let Some(entry) = objects.get_mut(id) {
+                    composer.marks(&mut entry.handles, entry.base);
+                }
+            }
+        }
+        let out = composer.out;
+        let in_entries: usize = objects
+            .values()
+            .chain(key.iter().map(|(_, entry)| entry))
+            .flat_map(|entry| entry.marks.iter().chain(&entry.handles))
+            .map(Mark::kept)
+            .sum();
+        *kept = in_entries + out.vertices.len();
+        *frame = Arc::new(out);
+    }
+
+    fn clear(&mut self) {
+        *self = Self {
+            #[cfg(test)]
+            builds: self.builds,
+            #[cfg(test)]
+            composes: self.composes,
+            ..Self::default()
+        };
+    }
+}
+
+/// Whether `n` or anything inside it is a symbol instance, whose outline is measured from art
+/// outside the node.
+fn uses_symbols(n: &Node) -> bool {
+    let mut found = false;
+    n.walk(&mut |c| found |= matches!(c.kind, NodeKind::SymbolInstance { .. }));
+    found
+}
+
+/// Build the key object's outline.
+fn key_marks(node: &Arc<Node>, color: Color32, source: (u64, u64), xf: &Xf, map: &ViewMap, symbols: &SymbolBoxes) -> ObjectMarks {
+    let mut list = MarkList::new(map);
+    list.outline(&node_outline(node, symbols), xf, Stroke::new(KEY_OUTLINE, color));
+    ObjectMarks {
+        node: Arc::downgrade(node),
+        color,
+        partial: None,
+        symbols: uses_symbols(node).then_some(source),
+        base: map.at,
+        marks: list.marks,
+        handles: vec![],
+        with_handles: 0,
+        seen: 0,
+    }
+}
+
+/// Draw the key object's outline and the marks of `objects` as plain shapes, keeping nothing.
+fn draw_once(st: &vectorcraft_engine::DocState, p: &egui::Painter, xf: &Xf, options: &MarkOptions, key: Option<NodeId>, objects: &[NodeId]) {
+    let map = ViewMap::new(xf);
+    let symbols = st.doc.symbol_boxes();
+    let source = (st.uid, st.revision);
+    if let Some((id, node)) = key.and_then(|id| Some((id, node_arc(&st.doc, id)?))) {
+        add_marks(p, &map, options.look, key_marks(node, c32(st.doc.layer_color(id)), source, xf, &map, &symbols).marks);
+    }
+    let (mut handles, mut with_handles) = (vec![], 0);
+    for id in objects {
+        let Some(node) = node_arc(&st.doc, *id) else { continue };
+        let entry = object_marks(st, *id, node, c32(st.doc.layer_color(*id)), source, xf, &map, options, &symbols);
+        add_marks(p, &map, options.look, entry.marks);
+        handles.push(entry.handles);
+        with_handles += entry.with_handles;
+    }
+    if options.all_handles || with_handles <= 1 {
+        for marks in handles {
+            add_marks(p, &map, options.look, marks);
+        }
+    }
+}
+
+/// Add `marks` to the painter one shape at a time.
+fn add_marks(p: &egui::Painter, map: &ViewMap, look: HandleLook, marks: Vec<Mark>) {
+    for mark in marks {
+        match mark {
+            Mark::Rigid { pieces, .. } => {
+                for shape in pieces.into_iter().filter_map(|piece| piece.shape) {
+                    p.add(shape);
+                }
+            }
+            Mark::Handles { color, lines, .. } => {
+                for line in lines {
+                    let (from, to) = (map.to_screen(line.from), map.to_screen(line.to));
+                    p.line_segment([from, to], Stroke::new(1.0, color));
+                    look.draw(p, to, color);
+                }
+            }
+            Mark::Squares { color, filled, size, at } => {
+                for point in at {
+                    anchor_square(p, map.to_screen(point), color, filled, size);
+                }
+            }
+            Mark::Segment { a, b, stroke } => {
+                p.line_segment([map.to_screen(a), map.to_screen(b)], stroke);
+            }
+        }
+    }
+}
+
+/// Build the marks of the selected object `id`.
+#[allow(clippy::too_many_arguments)]
+fn object_marks(
+    st: &vectorcraft_engine::DocState,
+    id: NodeId,
+    node: &Arc<Node>,
+    color: Color32,
+    source: (u64, u64),
+    xf: &Xf,
+    map: &ViewMap,
+    options: &MarkOptions,
+    symbols: &SymbolBoxes,
+) -> ObjectMarks {
+    let MarkOptions { direct, curvature, curve_points_from_tool, look, .. } = *options;
+    let n: &Node = node;
+    let partial = st.selection.partial(id);
+    let anchor = |direct: bool| look.grow + if direct { 5.0 } else { 4.0 };
+    let (mut marks, mut handles, mut with_handles) = (MarkList::new(map), MarkList::new(map), 0);
+    // Path outlines (and area type / placed document / image / mesh / symbol outlines;
+    // point type baselines and origin are drawn below).
+    if !matches!(n.kind, NodeKind::Text(ref tx) if matches!(tx.kind, vectorcraft_doc::TextKind::Point)) {
+        marks.outline(&node_outline(n, symbols), xf, Stroke::new(1.0, color));
+    }
+    // Anchors (and handles for selected anchors in direct mode); a gradient mesh's or a mesh
+    // envelope's points.
+    walk_drawn(n, &mut |c| {
+        let envelope = vectorcraft_doc::live::envelope_overlay(c).and_then(|(_, grid)| grid);
+        let grid = match &c.kind {
+            NodeKind::Mesh(m) => Some(m),
+            _ => envelope.as_ref(),
+        };
+        if let Some(grid) = grid {
+            for q in &grid.points {
+                marks.square(q.p, color, false, anchor(direct));
+            }
+            return;
+        }
+        let NodeKind::Path { path, .. } = &c.kind else { return };
+        // The Curvature tool owns its points while drawing; existing paths use this overlay.
+        if curvature && curve_points_from_tool {
+            return;
+        }
+        let selected_segments = st.selection.segments.get(&c.id);
+        if let Some(segments) = selected_segments {
+            for &(si, seg) in segments {
+                let Some(sp) = path.subpaths.get(si).filter(|sp| seg < sp.segment_count()) else { continue };
+                let curve = sp.segment(seg);
+                let mut outline = vectorcraft_geom::BezPath::new();
+                outline.move_to(curve.p0);
+                if sp.segment_is_line(seg) {
+                    outline.line_to(curve.p3);
+                } else {
+                    outline.curve_to(curve.p1, curve.p2, curve.p3);
+                }
+                marks.outline(&outline, xf, Stroke::new(2.0, color));
+            }
+        }
+        for (si, ai, a) in path.anchors() {
+            // An object selected whole has all its anchors selected, and so do the paths inside a
+            // group, compound path or clip group selected whole. Direction handles show only on a
+            // path that is selected itself: those are the handles that `handle_anchors` in
+            // `vectorcraft-tools` lets the tools drag.
+            let (sel, handles_shown) = match partial {
+                Some(set) => {
+                    let sel = set.contains(&(si, ai));
+                    (sel, sel)
+                }
+                None => (true, direct && c.id == id),
+            };
+            if !curvature && handles_shown {
+                with_handles += 1;
+                let sides = path.subpaths.get(si).map(|subpath| st.selection.handle_sides(c.id, si, ai, subpath)).unwrap_or((true, true));
+                for (h, _) in [(a.h_in, sides.0), (a.h_out, sides.1)].into_iter().filter(|(h, show)| *show && h.distance(a.p) > 1e-6) {
+                    handles.handle(a.p, h, color);
+                }
+            }
+            let anchor_selected = sel && selected_segments.is_none();
+            let ink = if anchor_selected && partial.is_some() { selected_anchor(color) } else { color };
+            if curvature {
+                let (fill, size) = (if anchor_selected && partial.is_some() { ink } else { Color32::WHITE }, look.grow + 6.0);
+                marks.rigid(Shape::Circle(egui::epaint::CircleShape {
+                    center: map.to_screen(a.p),
+                    radius: size / 2.0,
+                    fill,
+                    stroke: Stroke::new(1.0, ink),
+                }));
+            } else {
+                marks.square(a.p, ink, anchor_selected, anchor(partial.is_some() || direct));
+            }
+        }
+    });
+    // Centre point (Attributes panel → Show Center).
+    if n.shows_center()
+        && let Some(b) = n.geometric_bounds_with(symbols)
+    {
+        marks.square(b.center(), color, true, anchor(false));
+    }
+    // Point type: each line's baseline, where a click selects it (`hit`), whatever its
+    // alignment and rotation, and the anchor (area type shows its frame instead, which may
+    // not be a rectangle, and type on a path its path).
+    if let NodeKind::Text(tx) = &n.kind
+        && matches!(tx.kind, vectorcraft_doc::TextKind::Point)
+    {
+        for (a, b) in tx.baselines() {
+            marks.line(tx.xf * a, tx.xf * b, Stroke::new(1.0, color));
+        }
+        marks.rigid(Shape::circle_filled(map.to_screen(tx.xf * Point::ZERO), 2.5, color));
+    }
+    ObjectMarks {
+        node: Arc::downgrade(node),
+        color,
+        partial: partial.cloned(),
+        symbols: uses_symbols(n).then_some(source),
+        base: map.at,
+        marks: marks.marks,
+        handles: handles.marks,
+        with_handles,
+        seen: 0,
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/ui-egui/src/canvas/selection_marks/tests.rs b/crates/ui-egui/src/canvas/selection_marks/tests.rs
new file mode 100644
index 000000000..98ef0fdfb
--- /dev/null
+++ b/crates/ui-egui/src/canvas/selection_marks/tests.rs
@@ -0,0 +1,629 @@
+use serde_json::json;
+use vectorcraft_engine::Session;
+
+use super::super::overlays::{anchor_square, curve_point, mark_options};
+use super::super::{VectorcraftApp, show};
+use super::*;
+
+const SIZE: (f32, f32) = (400.0, 300.0);
+
+fn id_of(made: &serde_json::Value) -> NodeId {
+    NodeId(made["id"].as_u64().unwrap())
+}
+
+/// A curve with handles, a live rectangle, a group, point type and a symbol instance, all selected.
+fn scene() -> (VectorcraftApp, NodeId) {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+    let curve = id_of(&app.run("path.create", json!({"d": "M40 40 C60 10 90 10 110 40 S160 70 180 40 L180 90"})).unwrap());
+    app.run("shape.rectangle", json!({"x": 200.5, "y": 30.25, "width": 60, "height": 40})).unwrap();
+    let a = id_of(&app.run("shape.ellipse", json!({"x": 40, "y": 120, "width": 50, "height": 30})).unwrap());
+    let b = id_of(&app.run("shape.rectangle", json!({"x": 100, "y": 120, "width": 30, "height": 30})).unwrap());
+    app.run("select.set", json!({"ids": [a.0, b.0]})).unwrap();
+    app.run("object.group", json!({})).unwrap();
+    app.run("text.create", json!({"x": 200, "y": 150, "text": "Mark", "size": 20})).unwrap();
+    let art = id_of(&app.run("shape.rectangle", json!({"x": 280, "y": 200, "width": 20, "height": 20})).unwrap());
+    app.run("symbol.new", json!({"name": "Mark", "ids": [art.0]})).unwrap();
+    app.run("select.all", json!({})).unwrap();
+    (app, curve)
+}
+
+fn xf(zoom: f64, center: (f64, f64), rot_degrees: f64) -> Xf {
+    Xf {
+        rect: egui::Rect::from_min_size(Pos2::ZERO, vec2(SIZE.0, SIZE.1)),
+        zoom,
+        center: Point::new(center.0, center.1),
+        rot: rot_degrees.to_radians(),
+    }
+}
+
+const VIEW: (f64, f64) = (200.0, 150.0);
+
+/// The marks drawn one shape at a time, as a frame draws them with nothing kept.
+fn plain(app: &VectorcraftApp, p: &egui::Painter, xf: &Xf, curve_points_from_tool: bool) {
+    let st = app.session.active().unwrap();
+    let MarkOptions { direct, curvature, look, all_handles, .. } = mark_options(app, curve_points_from_tool);
+    let symbols = st.doc.symbol_boxes();
+    let anchor = |direct: bool| look.grow + if direct { 5.0 } else { 4.0 };
+    let (mut handles, mut with_handles) = (vec![], 0);
+    if let Some((k, n)) = st.selection.key.and_then(|k| Some((k, st.doc.node(k)?))) {
+        for line in to_screen_path(&node_outline(n, &symbols), xf) {
+            p.add(Shape::line(line, Stroke::new(KEY_OUTLINE, c32(st.doc.layer_color(k)))));
+        }
+    }
+    for id in &st.selection.objects {
+        let Some(n) = st.doc.node(*id) else { continue };
+        let color = c32(st.doc.layer_color(*id));
+        let partial = st.selection.partial(*id);
+        let stroke = |bp: &BezPath, width: f32| {
+            for line in to_screen_path(bp, xf) {
+                p.add(Shape::line(line, Stroke::new(width, color)));
+            }
+        };
+        if !matches!(n.kind, NodeKind::Text(ref tx) if matches!(tx.kind, vectorcraft_doc::TextKind::Point)) {
+            stroke(&node_outline(n, &symbols), 1.0);
+        }
+        walk_drawn(n, &mut |c| {
+            let envelope = vectorcraft_doc::live::envelope_overlay(c).and_then(|(_, grid)| grid);
+            let grid = match &c.kind {
+                NodeKind::Mesh(m) => Some(m),
+                _ => envelope.as_ref(),
+            };
+            if let Some(grid) = grid {
+                for q in &grid.points {
+                    anchor_square(p, xf.to_screen(q.p), color, false, anchor(direct));
+                }
+                return;
+            }
+            let NodeKind::Path { path, .. } = &c.kind else { return };
+            if curvature && curve_points_from_tool {
+                return;
+            }
+            let selected_segments = st.selection.segments.get(&c.id);
+            if let Some(segments) = selected_segments {
+                for &(si, seg) in segments {
+                    let Some(sp) = path.subpaths.get(si).filter(|sp| seg < sp.segment_count()) else { continue };
+                    let curve = sp.segment(seg);
+                    let mut outline = vectorcraft_geom::BezPath::new();
+                    outline.move_to(curve.p0);
+                    if sp.segment_is_line(seg) {
+                        outline.line_to(curve.p3);
+                    } else {
+                        outline.curve_to(curve.p1, curve.p2, curve.p3);
+                    }
+                    stroke(&outline, 2.0);
+                }
+            }
+            for (si, ai, a) in path.anchors() {
+                let (sel, handles_shown) = match partial {
+                    Some(set) => {
+                        let sel = set.contains(&(si, ai));
+                        (sel, sel)
+                    }
+                    None => (true, direct && c.id == *id),
+                };
+                let sp = xf.to_screen(a.p);
+                if !curvature && handles_shown {
+                    with_handles += 1;
+                    let sides = path.subpaths.get(si).map(|subpath| st.selection.handle_sides(c.id, si, ai, subpath)).unwrap_or((true, true));
+                    handles.extend(
+                        [(a.h_in, sides.0), (a.h_out, sides.1)]
+                            .into_iter()
+                            .filter(|(h, show)| *show && h.distance(a.p) > 1e-6)
+                            .map(|(h, _)| (sp, xf.to_screen(h), color)),
+                    );
+                }
+                let anchor_selected = sel && selected_segments.is_none();
+                let ink = if anchor_selected && partial.is_some() { selected_anchor(color) } else { color };
+                if curvature {
+                    curve_point(p, sp, ink, anchor_selected && partial.is_some(), look.grow + 6.0);
+                } else {
+                    anchor_square(p, sp, ink, anchor_selected, anchor(partial.is_some() || direct));
+                }
+            }
+        });
+        if n.shows_center()
+            && let Some(b) = n.geometric_bounds_with(&symbols)
+        {
+            anchor_square(p, xf.to_screen(b.center()), color, true, anchor(false));
+        }
+        if let NodeKind::Text(tx) = &n.kind
+            && matches!(tx.kind, vectorcraft_doc::TextKind::Point)
+        {
+            for (a, b) in tx.baselines() {
+                p.line_segment([xf.to_screen(tx.xf * a), xf.to_screen(tx.xf * b)], Stroke::new(1.0, color));
+            }
+            p.circle_filled(xf.to_screen(tx.xf * Point::ZERO), 2.5, color);
+        }
+    }
+    if all_handles || with_handles <= 1 {
+        for (sp, hp, color) in handles {
+            p.line_segment([sp, hp], Stroke::new(1.0, color));
+            for shape in look.shapes(hp, color).into_iter().flatten() {
+                p.add(shape);
+            }
+        }
+    }
+}
+
+/// Premultiplied pixels of a frame.
+struct Picture {
+    size: (usize, usize),
+    pixels: Vec<[f32; 4]>,
+}
+
+/// The font texture at `uv`, filtered linearly as the GPU does.
+fn sample(atlas: &egui::ColorImage, uv: (f32, f32)) -> [f32; 4] {
+    let (w, h) = (atlas.width(), atlas.height());
+    let (x, y) = (uv.0 * w as f32 - 0.5, uv.1 * h as f32 - 0.5);
+    let (fx, fy) = (x - x.floor(), y - y.floor());
+    let texel =
+        |dx: f32, dy: f32| atlas[(((x.floor() + dx).max(0.0) as usize).min(w - 1), ((y.floor() + dy).max(0.0) as usize).min(h - 1))].to_array();
+    let (a, b, c, d) = (texel(0.0, 0.0), texel(1.0, 0.0), texel(0.0, 1.0), texel(1.0, 1.0));
+    std::array::from_fn(|i| {
+        let top = f32::from(a[i]) * (1.0 - fx) + f32::from(b[i]) * fx;
+        let bottom = f32::from(c[i]) * (1.0 - fx) + f32::from(d[i]) * fx;
+        top * (1.0 - fy) + bottom * fy
+    })
+}
+
+fn rasterize(primitives: &[egui::ClippedPrimitive], pixels_per_point: f32, atlas: &egui::ColorImage) -> Picture {
+    let size = ((SIZE.0 * pixels_per_point).ceil() as usize, (SIZE.1 * pixels_per_point).ceil() as usize);
+    let mut pixels = vec![[0.0f32; 4]; size.0 * size.1];
+    // Vertices snap to 1/256 of a pixel, as on a GPU, so that the edge tests are exact and a pixel
+    // center on an edge two triangles share belongs to exactly one of them.
+    const GRID: f32 = 256.0;
+    let cross =
+        |a: (i64, i64), b: (i64, i64), c: (i64, i64)| i128::from(b.0 - a.0) * i128::from(c.1 - a.1) - i128::from(b.1 - a.1) * i128::from(c.0 - a.0);
+    for primitive in primitives {
+        let Primitive::Mesh(mesh) = &primitive.primitive else { continue };
+        let clip = primitive.clip_rect;
+        for [i, j, k] in mesh.indices.as_chunks::<3>().0 {
+            let mut v = [mesh.vertices[*i as usize], mesh.vertices[*j as usize], mesh.vertices[*k as usize]];
+            let at = |v: &Vertex| ((v.pos.x * pixels_per_point * GRID).round() as i64, (v.pos.y * pixels_per_point * GRID).round() as i64);
+            let area = cross(at(&v[0]), at(&v[1]), at(&v[2]));
+            if area == 0 {
+                continue;
+            }
+            if area < 0 {
+                v.swap(1, 2);
+            }
+            let area = area.abs() as f32;
+            let [a, b, c] = [at(&v[0]), at(&v[1]), at(&v[2])];
+            let range = |lo: i64, hi: i64, clip_lo: f32, clip_hi: f32, n: usize| {
+                let lo = (lo as f32 / GRID).max(clip_lo * pixels_per_point).floor().max(0.0) as usize;
+                let hi = ((hi as f32 / GRID).min(clip_hi * pixels_per_point).ceil().max(0.0) as usize).min(n);
+                lo..hi
+            };
+            let upper_left = |p: (i64, i64), q: (i64, i64)| q.1 < p.1 || (q.1 == p.1 && q.0 > p.0);
+            for y in range(a.1.min(b.1).min(c.1), a.1.max(b.1).max(c.1), clip.min.y, clip.max.y, size.1) {
+                for x in range(a.0.min(b.0).min(c.0), a.0.max(b.0).max(c.0), clip.min.x, clip.max.x, size.0) {
+                    let q = (x as i64 * 256 + 128, y as i64 * 256 + 128);
+                    let (w0, w1, w2) = (cross(b, c, q), cross(c, a, q), cross(a, b, q));
+                    let inside = |w: i128, p, q| w > 0 || (w == 0 && upper_left(p, q));
+                    if !(inside(w0, b, c) && inside(w1, c, a) && inside(w2, a, b)) {
+                        continue;
+                    }
+                    let (w0, w1, w2) = (w0 as f32 / area, w1 as f32 / area, w2 as f32 / area);
+                    let uv = (w0 * v[0].uv.x + w1 * v[1].uv.x + w2 * v[2].uv.x, w0 * v[0].uv.y + w1 * v[1].uv.y + w2 * v[2].uv.y);
+                    let texel = sample(atlas, uv);
+                    let dst = &mut pixels[y * size.0 + x];
+                    let channels: [[u8; 4]; 3] = [v[0].color.to_array(), v[1].color.to_array(), v[2].color.to_array()];
+                    let src: [f32; 4] = std::array::from_fn(|i| {
+                        (w0 * f32::from(channels[0][i]) + w1 * f32::from(channels[1][i]) + w2 * f32::from(channels[2][i])) * texel[i] / 255.0
+                    });
+                    let keep = 1.0 - src[3] / 255.0;
+                    for i in 0..4 {
+                        dst[i] = src[i] + dst[i] * keep;
+                    }
+                }
+            }
+        }
+    }
+    Picture { size, pixels }
+}
+
+fn picture(ctx: &egui::Context, pixels_per_point: f32, draw: impl FnOnce(&egui::Painter)) -> Picture {
+    // The window is larger than the picture at each display scale, and a new scale applies to the
+    // pass after it is set.
+    let raw = || egui::RawInput {
+        screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(4.0 * SIZE.0, 4.0 * SIZE.1))),
+        max_texture_side: Some(8192),
+        ..Default::default()
+    };
+    ctx.set_pixels_per_point(pixels_per_point);
+    ctx.run_ui(raw(), |_| {}).textures_delta.clear();
+    let mut draw = Some(draw);
+    let mut out = ctx.run_ui(raw(), |ui| {
+        if let Some(draw) = draw.take() {
+            draw(&ui.painter_at(egui::Rect::from_min_size(Pos2::ZERO, vec2(SIZE.0, SIZE.1))));
+        }
+    });
+    out.textures_delta.clear();
+    let primitives = ctx.tessellate(std::mem::take(&mut out.shapes), out.pixels_per_point);
+    rasterize(&primitives, out.pixels_per_point, &ctx.fonts(|f| f.image()))
+}
+
+/// The most a color channel may differ, out of 255: kept vertices move by rounding errors far under
+/// a pixel.
+const CHANNEL: f32 = 3.0;
+
+fn assert_same(a: &Picture, b: &Picture, what: &str, allowed_per_mille: usize) {
+    assert_eq!(a.size, b.size, "{what}");
+    let drawn = b.pixels.iter().filter(|p| p[3] > 0.0).count();
+    assert!(drawn > 0, "{what}: the picture is empty");
+    let differ: Vec<usize> = (0..b.pixels.len()).filter(|i| a.pixels[*i].iter().zip(&b.pixels[*i]).any(|(x, y)| (x - y).abs() > CHANNEL)).collect();
+    let first: Vec<_> = differ.iter().take(4).map(|i| ((i % a.size.0, i / a.size.0), a.pixels[*i], b.pixels[*i])).collect();
+    assert!(
+        differ.len() * 1000 <= drawn * allowed_per_mille,
+        "{what}: {} of {drawn} drawn pixels differ, first at (pixel, got, want): {first:?}",
+        differ.len()
+    );
+}
+
+fn paint(marks: &mut SelectionMarks, app: &VectorcraftApp, p: &egui::Painter, xf: &Xf, curve_points_from_tool: bool) {
+    let st = app.session.active().unwrap();
+    let key = st.selection.key;
+    marks.paint(st, p, xf, &mark_options(app, curve_points_from_tool), key, &st.selection.objects);
+}
+
+/// Kept marks, marks built from nothing and plain shapes all draw the same pixels. Kept marks may
+/// differ at up to 1 pixel in 1,000: at a corner of exactly 90 degrees on a rotated view, plain
+/// shapes take a miter or a cut corner by a rounding error of the corner's position, which a pan
+/// changes, and moved triangles keep the corner they were built with. An anchor square left stale
+/// covers more than this limit.
+#[track_caller]
+fn assert_matches_plain(ctx: &egui::Context, marks: &mut SelectionMarks, app: &VectorcraftApp, xf: &Xf, pixels_per_point: f32, what: &str) {
+    let want = picture(ctx, pixels_per_point, |p| plain(app, p, xf, false));
+    for frame in ["this frame", "the next frame"] {
+        let kept = picture(ctx, pixels_per_point, |p| paint(marks, app, p, xf, false));
+        assert_same(&kept, &want, &format!("{what}, kept, {frame}"), 1);
+    }
+    let mut fresh = SelectionMarks::default();
+    for frame in ["drawn once", "built from nothing"] {
+        let cold = picture(ctx, pixels_per_point, |p| paint(&mut fresh, app, p, xf, false));
+        assert_same(&cold, &want, &format!("{what}, {frame}"), 0);
+    }
+    assert!(fresh.builds > 0, "{what}: the second frame builds the marks");
+}
+
+#[test]
+fn marks_draw_the_same_pixels_as_plain_shapes_at_each_view() {
+    let (mut app, _) = scene();
+    let ctx = egui::Context::default();
+    for tool in ["selection", "directSelection", "curvature"] {
+        app.select_tool(tool);
+        for pixels_per_point in [1.0, 1.25, 2.0] {
+            let mut marks = SelectionMarks::default();
+            for zoom in [0.5, 1.0, 2.37, 8.0] {
+                for rot in [0.0, 30.0, 90.0] {
+                    let view = xf(zoom, VIEW, rot);
+                    assert_matches_plain(&ctx, &mut marks, &app, &view, pixels_per_point, &format!("{tool} {pixels_per_point}x {zoom} {rot}"));
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn a_pan_moves_the_marks_without_building_them() {
+    let (mut app, _) = scene();
+    let ctx = egui::Context::default();
+    for tool in ["selection", "directSelection"] {
+        app.select_tool(tool);
+        for (pixels_per_point, rot) in [(1.0, 0.0), (1.25, 0.0), (2.0, 30.0)] {
+            let mut marks = SelectionMarks::default();
+            assert_matches_plain(&ctx, &mut marks, &app, &xf(1.5, VIEW, rot), pixels_per_point, &format!("{tool}, before the pan"));
+            let builds = marks.builds;
+            for (dx, dy) in [(10.0, 0.0), (3.0, 7.0), (0.37, 0.61), (-31.3, 12.9), (160.0, 90.0)] {
+                let view = xf(1.5, (VIEW.0 + dx, VIEW.1 + dy), rot);
+                assert_matches_plain(&ctx, &mut marks, &app, &view, pixels_per_point, &format!("{tool}, {pixels_per_point}x pan {dx} {dy}"));
+            }
+            assert_eq!(marks.builds, builds, "{tool}: a pan builds nothing");
+        }
+    }
+}
+
+#[test]
+fn a_long_pan_at_high_zoom_builds_the_marks_again_and_stays_exact() {
+    let (app, _) = scene();
+    let ctx = egui::Context::default();
+    let mut marks = SelectionMarks::default();
+    // 2,000 points per document point: the art runs far past what `f32` holds to a fine fraction.
+    let zoom = 2_000.0;
+    assert_matches_plain(&ctx, &mut marks, &app, &xf(zoom, (180.0, 41.0), 0.0), 1.0, "the top of the curve's straight end");
+    let builds = marks.builds;
+    assert_matches_plain(&ctx, &mut marks, &app, &xf(zoom, (180.0, 89.0), 0.0), 1.0, "96,000 points along the straight end");
+    assert!(marks.builds > builds, "a pan past MAX_PAN builds the marks again");
+}
+
+/// Marks land exactly where the rest of the canvas puts a point, also at the canvas's far edge at
+/// the highest zoom.
+#[test]
+fn marks_are_placed_exactly_where_the_view_puts_a_point() {
+    let far = vectorcraft_doc::MAX_COORD - 1.0;
+    for (center, zoom, rot) in [(VIEW, 1.0, 0.0), (VIEW, 2.37, 30.0), ((far, far), 640.0, 0.0), ((far, -far), 640.0, 30.0)] {
+        let view = xf(zoom, center, rot);
+        let map = ViewMap::new(&view);
+        for i in 0..2_000 {
+            let t = f64::from(i) / 7.0;
+            let p = Point::new(center.0 + t.sin() * 0.3, center.1 + t.cos() * 0.2);
+            assert_eq!(map.to_screen(p), view.to_screen(p), "{p:?} at zoom {zoom}, rotation {rot}");
+        }
+    }
+}
+
+#[test]
+fn an_idle_frame_draws_the_mesh_it_joined() {
+    let (app, _) = scene();
+    let ctx = egui::Context::default();
+    let mut marks = SelectionMarks::default();
+    let view = xf(1.0, VIEW, 0.0);
+    picture(&ctx, 1.0, |p| paint(&mut marks, &app, p, &view, false));
+    assert_eq!((marks.builds, marks.composes), (0, 0), "the first frame at a view keeps nothing");
+    picture(&ctx, 1.0, |p| paint(&mut marks, &app, p, &view, false));
+    let (builds, composes) = (marks.builds, marks.composes);
+    assert!(builds > 0 && composes == 1);
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "an idle frame");
+    assert_eq!((marks.builds, marks.composes), (builds, composes), "an idle frame builds and joins nothing");
+}
+
+/// While the zoom or rotation changes in each frame, nothing is built or kept. The picture stays the
+/// same, and the first frame that repeats a view builds the marks.
+#[test]
+fn a_zoom_keeps_nothing_until_the_view_stays() {
+    let (mut app, _) = scene();
+    let ctx = egui::Context::default();
+    app.select_tool("directSelection");
+    let mut marks = SelectionMarks::default();
+    let settled = xf(1.5, VIEW, 0.0);
+    assert_matches_plain(&ctx, &mut marks, &app, &settled, 1.0, "before the zoom");
+    let builds = marks.builds;
+    for (zoom, rot) in [(1.6, 0.0), (1.7, 0.0), (1.7, 15.0), (1.9, 15.0), (2.37, 40.0)] {
+        let view = xf(zoom, VIEW, rot);
+        let want = picture(&ctx, 1.0, |p| plain(&app, p, &view, false));
+        let drawn = picture(&ctx, 1.0, |p| paint(&mut marks, &app, p, &view, false));
+        assert_same(&drawn, &want, &format!("zoom {zoom}, rotation {rot}"), 0);
+        assert_eq!(marks.builds, builds, "zoom {zoom}, rotation {rot} builds nothing");
+        assert!(marks.objects.is_empty() && marks.frame.is_empty(), "zoom {zoom}, rotation {rot} keeps nothing");
+    }
+    let last = xf(2.37, VIEW, 40.0);
+    let want = picture(&ctx, 1.0, |p| plain(&app, p, &last, false));
+    let drawn = picture(&ctx, 1.0, |p| paint(&mut marks, &app, p, &last, false));
+    assert_same(&drawn, &want, "the same view again", 1);
+    assert!(marks.builds > builds && !marks.objects.is_empty(), "the same view again builds the marks");
+}
+
+/// Whether every vertex of the kept frame lies within a few pixels of the picture.
+fn all_near_the_picture(marks: &SelectionMarks) -> bool {
+    let near = egui::Rect::from_min_size(Pos2::ZERO, vec2(SIZE.0, SIZE.1)).expand(8.0);
+    marks.frame.vertices.iter().all(|v| near.contains(v.pos))
+}
+
+/// A group of rectangles 1,000 points apart keeps triangles only for the ones in view. One that
+/// comes into view gets its triangles then.
+#[test]
+fn a_frame_holds_no_triangles_of_a_groups_subpaths_out_of_view() {
+    for tool in ["selection", "directSelection"] {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        for i in 0..12 {
+            app.run("shape.rectangle", json!({"x": 40 + i * 1000, "y": 40, "width": 60, "height": 40})).unwrap();
+        }
+        app.run("select.all", json!({})).unwrap();
+        app.run("object.group", json!({})).unwrap();
+        app.run("select.all", json!({})).unwrap();
+        app.select_tool(tool);
+        let ctx = egui::Context::default();
+        let mut marks = SelectionMarks::default();
+        for (dx, seen) in [(0.0, 1), (1000.0, 2), (1000.37, 2), (11_000.0, 3), (0.0, 3)] {
+            let view = xf(1.0, (VIEW.0 + dx, VIEW.1), 0.0);
+            assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, &format!("{tool}, pan {dx}"));
+            assert!(!marks.frame.is_empty(), "{tool}, pan {dx}: a rectangle is in view");
+            assert!(all_near_the_picture(&marks), "{tool}, pan {dx}: triangles of a rectangle out of view");
+            let waiting: usize = marks
+                .objects
+                .values()
+                .flat_map(|entry| &entry.marks)
+                .map(|mark| match mark {
+                    Mark::Rigid { pieces, .. } => pieces.iter().filter(|piece| piece.shape.is_some()).count(),
+                    _ => 0,
+                })
+                .sum();
+            assert_eq!(waiting, 12 - seen, "{tool}, pan {dx}: rectangles not yet in view get no triangles");
+        }
+    }
+}
+
+/// How many triangles the direction handles add to a frame of a direct-selected path with `anchors`
+/// anchors 1,000 points apart.
+fn handle_triangles(anchors: usize, view: &Xf) -> (usize, VectorcraftApp, SelectionMarks, egui::Context) {
+    let mut d = String::from("M40 150");
+    for i in 0..anchors - 1 {
+        let (from, to) = (40 + i * 1000, 40 + (i + 1) * 1000);
+        // Handles alternate between level, which the tessellator rounds to whole pixels, and slanted.
+        let y = if i % 2 == 0 { 150 } else { 110 };
+        d += &format!(" C{} {y} {} 190 {to} 150", from + 30, to - 30);
+    }
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+    app.run("path.create", json!({"d": d})).unwrap();
+    app.run("select.all", json!({})).unwrap();
+    app.select_tool("directSelection");
+    let ctx = egui::Context::default();
+    let mut marks = SelectionMarks::default();
+    let mut triangles = |app: &mut VectorcraftApp, all_handles: bool| {
+        app.session.prefs.show_handles_multiple_anchors = all_handles;
+        for _ in 0..2 {
+            picture(&ctx, 1.0, |p| paint(&mut marks, app, p, view, false));
+        }
+        marks.frame.indices.len() / 3
+    };
+    let without = triangles(&mut app, false);
+    let with = triangles(&mut app, true);
+    (with - without, app, marks, ctx)
+}
+
+/// A frame of a long path shows the handles in view and holds the triangles of those alone, exactly
+/// as many as a path that ends just past the view. Handles that come into view draw correctly, level
+/// ones after a move by a fraction of a pixel too.
+#[test]
+fn a_frame_holds_no_triangles_of_handles_out_of_view() {
+    let view = xf(1.0, VIEW, 0.0);
+    let (short, ..) = handle_triangles(2, &view);
+    let (long, app, mut marks, ctx) = handle_triangles(40, &view);
+    assert!(short > 0, "the handle in view draws");
+    assert_eq!(long, short, "the long path's handles out of view add nothing");
+    for (dx, dy) in [(0.0, 0.0), (0.0, 0.37), (1000.0, 0.0), (1000.61, 0.61), (2000.0, 0.0), (2000.0, 0.5), (5000.5, 0.25), (0.0, 0.0)] {
+        let view = xf(1.0, (VIEW.0 + dx, VIEW.1 + dy), 0.0);
+        assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, &format!("pan {dx} {dy}"));
+    }
+}
+
+#[test]
+fn no_stale_marks_after_a_change_with_the_selection_tool() {
+    no_stale_marks_after_a_change("selection");
+}
+
+#[test]
+fn no_stale_marks_after_a_change_with_the_direct_selection_tool() {
+    no_stale_marks_after_a_change("directSelection");
+}
+
+/// Each change draws what plain shapes draw, and builds no more than the change touches.
+fn no_stale_marks_after_a_change(tool: &str) {
+    let (mut app, curve) = scene();
+    let ctx = egui::Context::default();
+    let mut marks = SelectionMarks::default();
+    let view = xf(1.5, VIEW, 30.0);
+    app.select_tool(tool);
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "at the start");
+    let all = app.session.active().unwrap().selection.objects.clone();
+    let ids = |list: &[NodeId]| json!({"ids": list.iter().map(|i| i.0).collect::<Vec<_>>()});
+
+    // An edit of one object builds that object, and the symbol instance that measures the art of a
+    // document at a new revision.
+    let builds = marks.builds;
+    app.run("select.set", json!({"ids": [curve.0]})).unwrap();
+    app.run("object.nudge", json!({"dx": 12, "dy": -5})).unwrap();
+    app.run("select.set", ids(&all)).unwrap();
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "after an edit");
+    assert_eq!(marks.builds, builds + 2, "an edit of one object leaves the others as they were");
+
+    app.run("edit.undo", json!({})).unwrap();
+    app.run("select.set", ids(&all)).unwrap();
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "after an undo");
+    app.run("edit.redo", json!({})).unwrap();
+    app.run("select.set", ids(&all)).unwrap();
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "after a redo");
+
+    // A layer color.
+    let layer = app.session.active().unwrap().doc.layers[0].id;
+    app.run("layer.setProps", json!({"id": layer.0, "color": "#ff00aa"})).unwrap();
+    app.run("select.set", ids(&all)).unwrap();
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "after a layer color change");
+
+    // A change of the selection: fewer objects, other anchors, a segment, the key object.
+    app.run("select.set", ids(&all[..2])).unwrap();
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with fewer objects");
+    assert_eq!(marks.objects.len(), 2, "an object that left the selection has no entry");
+    let st = app.session.active_mut().unwrap();
+    st.selection.anchors.insert(curve, [(0, 1)].into_iter().collect());
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with one anchor of the curve selected");
+    let st = app.session.active_mut().unwrap();
+    st.selection.anchors.insert(curve, [(0, 2), (0, 3)].into_iter().collect());
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with other anchors of the curve selected");
+    let st = app.session.active_mut().unwrap();
+    st.selection.segments.insert(curve, [(0, 2)].into_iter().collect());
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with a segment of the curve selected");
+    let st = app.session.active_mut().unwrap();
+    st.selection.segments.clear();
+    st.selection.anchors.clear();
+    st.selection.key = Some(curve);
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with a key object");
+    let st = app.session.active_mut().unwrap();
+    st.selection.key = Some(all[1]);
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with another key object");
+    app.session.active_mut().unwrap().selection.key = None;
+
+    // The tool and the display preferences.
+    app.select_tool(if tool == "selection" { "directSelection" } else { "selection" });
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with the other tool");
+    app.select_tool(tool);
+    app.session.prefs.anchor_size = 6;
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with larger anchors");
+    app.session.prefs.handle_style = "hollow".into();
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with hollow handles");
+    app.session.prefs.show_handles_multiple_anchors = !app.session.prefs.show_handles_multiple_anchors;
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with the handles option changed");
+    app.session.prefs.anchor_size = 1;
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "with the smallest anchors, which draw as lines");
+}
+
+/// An instance's outline comes from its symbol's art, which is not part of the instance's node.
+#[test]
+fn an_edit_of_a_symbol_outlines_its_instance_again() {
+    let (mut app, _) = scene();
+    let ctx = egui::Context::default();
+    let mut marks = SelectionMarks::default();
+    let view = xf(2.0, VIEW, 0.0);
+    let instance = {
+        let st = app.session.active().unwrap();
+        st.selection.objects.iter().copied().find(|id| matches!(st.doc.node(*id).map(|n| &n.kind), Some(NodeKind::SymbolInstance { .. }))).unwrap()
+    };
+    app.run("select.set", json!({"ids": [instance.0]})).unwrap();
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "before the edit");
+    let before = app.session.active().unwrap().doc.node(instance).unwrap().geometric_bounds_with(&app.session.active().unwrap().doc.symbol_boxes());
+    app.run("symbol.edit", json!({"name": "Mark"})).unwrap();
+    app.run("select.all", json!({})).unwrap();
+    app.run("object.scale", json!({"sx": 3, "sy": 2})).unwrap();
+    app.run("symbol.exitEditing", json!({})).unwrap();
+    app.run("select.set", json!({"ids": [instance.0]})).unwrap();
+    let after = app.session.active().unwrap().doc.node(instance).unwrap().geometric_bounds_with(&app.session.active().unwrap().doc.symbol_boxes());
+    assert_ne!(before, after, "the edit changes what the instance measures");
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "after the edit");
+}
+
+/// A frame of the whole canvas keeps entries for the selected objects only.
+#[test]
+fn the_canvas_drops_entries_it_does_not_draw() {
+    let (mut app, curve) = scene();
+    let ctx = egui::Context::default();
+    let frame = |app: &mut VectorcraftApp| {
+        let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), ..Default::default() };
+        let mut out = ctx.run_ui(raw, |ui| show(app, ui));
+        out.textures_delta.clear();
+    };
+    frame(&mut app);
+    frame(&mut app);
+    let all = app.session.active().unwrap().selection.objects.len();
+    assert_eq!(app.canvas.selection_marks.objects.len(), all);
+    app.run("select.set", json!({"ids": [curve.0]})).unwrap();
+    frame(&mut app);
+    assert_eq!(app.canvas.selection_marks.objects.len(), 1, "objects that left the selection");
+    app.run("edit.clear", json!({"ids": [curve.0]})).unwrap();
+    frame(&mut app);
+    assert_eq!(app.canvas.selection_marks.objects.len(), 0, "an object that left the document");
+    app.run("select.all", json!({})).unwrap();
+    frame(&mut app);
+    frame(&mut app);
+    assert!(!app.canvas.selection_marks.objects.is_empty());
+    app.run("view.edges", json!({})).unwrap();
+    frame(&mut app);
+    assert_eq!(app.canvas.selection_marks.objects.len(), 0, "hidden edges keep nothing");
+}
+
+#[test]
+fn past_the_limit_the_marks_are_dropped_and_built_again() {
+    let (app, _) = scene();
+    let ctx = egui::Context::default();
+    let mut marks = SelectionMarks::default();
+    let view = xf(1.0, VIEW, 0.0);
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "at the limit");
+    assert!(marks.kept > 0);
+    marks.trim(marks.kept);
+    assert!(!marks.objects.is_empty(), "at the limit the marks stay");
+    marks.trim(marks.kept - 1);
+    assert!(marks.objects.is_empty() && marks.frame.is_empty(), "past the limit nothing stays");
+    assert_matches_plain(&ctx, &mut marks, &app, &view, 1.0, "after dropping them");
+}
diff --git a/crates/ui-egui/src/canvas/tests.rs b/crates/ui-egui/src/canvas/tests.rs
index ebfe960bb..84788bb70 100644
--- a/crates/ui-egui/src/canvas/tests.rs
+++ b/crates/ui-egui/src/canvas/tests.rs
@@ -1621,6 +1621,9 @@ fn frame_output(app: &mut VectorcraftApp, ctx: &egui::Context) -> (Vec<Shape>, e
             s => out.push(s),
         }
     }
+    // With no kept marks the frame draws the selection's marks as separate shapes, which callers
+    // read. `selection_marks::tests` compares them with the kept mesh.
+    app.canvas.selection_marks = Default::default();
     let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), ..Default::default() };
     let out = ctx.run_ui(raw, |ui| show(app, ui));
     let mut v = vec![];
diff --git a/crates/ui-egui/src/chrome/control_bar.rs b/crates/ui-egui/src/chrome/control_bar.rs
index 9afbe838e..70c6fe272 100644
--- a/crates/ui-egui/src/chrome/control_bar.rs
+++ b/crates/ui-egui/src/chrome/control_bar.rs
@@ -381,10 +381,12 @@ pub fn control_bar(app: &mut VectorcraftApp, ui: &mut Ui) {
                     let link = crate::panels::transform::proportional(app, ui);
                     let copy = crate::panels::transform::alt_enter_copies(app, ui);
                     let values = [(c.x, origin.x), (c.y, origin.y), (b.rect.width(), 0.0), (b.rect.height(), 0.0)];
+                    // The W/H link sits between W and H, but is made after H so Tab goes from W
+                    // straight to H and finds the link after it.
+                    let mut link_room = None;
                     for ((k, lbl), (v, offset)) in INLINE_FIELDS.into_iter().zip(values) {
-                        // The W/H link sits between W and H.
                         if k == "height" {
-                            crate::panels::transform::constrain_link(app, ui);
+                            link_room = Some(crate::panels::transform::constrain_link_room(ui));
                         }
                         widgets::field_label(ui, inline_label(&t, lbl));
                         let (id, shown) = (("cb", k), Some(v - offset));
@@ -397,6 +399,10 @@ pub fn control_bar(app: &mut VectorcraftApp, ui: &mut Ui) {
                             app.run("object.setBounds", json!({k: nv + offset, "reference": 4, "proportional": link, "copy": copy})).ok();
                         }
                     }
+                    if let Some(room) = link_room {
+                        let id = ui.scope_id().with("cb-constrain-link");
+                        crate::panels::transform::constrain_link_at(app, ui, ui.interact(room, id, Sense::click()));
+                    }
                 }
             });
         });
diff --git a/crates/ui-egui/src/community.rs b/crates/ui-egui/src/community.rs
index 7ed5eb984..034807b8b 100644
--- a/crates/ui-egui/src/community.rs
+++ b/crates/ui-egui/src/community.rs
@@ -32,7 +32,10 @@ pub fn discord_button(app: &mut VectorcraftApp, ui: &mut Ui, large: bool) -> egu
     let at = egui::pos2(0.0, r.center().y - galley.size().y / 2.0);
     let ir = egui::Rect::from_center_size(r.left_center() + vec2(h * 0.35 + icon / 2.0, 0.0), vec2(icon, icon));
     if large {
-        let fill = if resp.hovered() { DISCORD.gamma_multiply(0.85) } else { DISCORD };
+        // The theme's accent, as the primary buttons use it, so the call to action matches the
+        // rest of the window (and PhotoCraft's, #4684); Discord's colour stays on the app-bar icon.
+        let t = Tokens::get(ui.ctx());
+        let fill = if resp.hovered() { t.accent } else { t.accent_strong };
         ui.painter().rect_filled(r, CornerRadius::same((h / 2.0) as u8), fill);
         icons::paint(ui, "message-circle", ir, Color32::WHITE);
         ui.painter().galley(egui::pos2(ir.right() + h * 0.2, at.y), galley, Color32::WHITE);
@@ -50,27 +53,44 @@ pub fn discord_button(app: &mut VectorcraftApp, ui: &mut Ui, large: bool) -> egu
     resp
 }
 
-/// One link row: icon, label, opens the command's URL.
-fn link(app: &mut VectorcraftApp, ui: &mut Ui, icon: &str, label: &str, cmd: &str, url: &str) {
+/// One link row: icon, label, opens the command's URL. `centered` drops the icon so the label
+/// alone sits in the middle of the column.
+fn link(app: &mut VectorcraftApp, ui: &mut Ui, icon: &str, label: &str, cmd: &str, url: &str, centered: bool) {
     let t = Tokens::get(ui.ctx());
-    ui.horizontal(|ui| {
-        icons::icon(ui, icon, 16.0, t.icon);
-        let r = ui.add(egui::Button::new(egui::RichText::new(label).color(t.accent).size(13.0)).frame(false)).on_hover_text(url);
-        if r.clicked() {
-            app.open_link(cmd);
-        }
-    });
+    let button = |ui: &mut Ui| ui.add(egui::Button::new(egui::RichText::new(label).color(t.accent).size(13.0)).frame(false)).on_hover_text(url);
+    let r = if centered {
+        button(ui)
+    } else {
+        ui.horizontal(|ui| {
+            icons::icon(ui, icon, 16.0, t.icon);
+            button(ui)
+        })
+        .inner
+    };
+    if r.clicked() {
+        app.open_link(cmd);
+    }
 }
 
 /// The Discord button and the website / app page / GitHub links.
 pub fn links(app: &mut VectorcraftApp, ui: &mut Ui) {
+    links_in(app, ui, false);
+}
+
+/// [`links`] for a centred column (the Home screen's, as PhotoCraft's, #4684): the Discord button
+/// and the links, each in the middle.
+pub fn links_centered(app: &mut VectorcraftApp, ui: &mut Ui) {
+    links_in(app, ui, true);
+}
+
+fn links_in(app: &mut VectorcraftApp, ui: &mut Ui, centered: bool) {
     discord_button(app, ui, true);
     ui.add_space(8.0);
     let l = app.session.execute("help.links", &serde_json::json!({})).unwrap_or_default();
     let s = |k: &str| l[k].as_str().unwrap_or("").to_string();
-    link(app, ui, "globe", tl!("ArtCraft website"), "help.website", &s("website"));
-    link(app, ui, "external-link", tl!("VectorCraft on getartcraft.com"), "help.appPage", &s("appPage"));
-    link(app, ui, "git-branch", tl!("Source code on GitHub"), "help.github", &s("github"));
+    link(app, ui, "globe", tl!("ArtCraft website"), "help.website", &s("website"), centered);
+    link(app, ui, "external-link", tl!("VectorCraft on getartcraft.com"), "help.appPage", &s("appPage"), centered);
+    link(app, ui, "git-branch", tl!("Source code on GitHub"), "help.github", &s("github"), centered);
 }
 
 #[cfg(test)]
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index c0f900f67..43e274505 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -91,6 +91,7 @@ pub mod raster_effects;
 pub mod rearrange_artboards;
 pub mod recolor;
 mod recovery;
+pub mod rename_artboards;
 mod revolve;
 pub(crate) mod revolve_gizmo;
 pub mod saturate;
@@ -415,6 +416,7 @@ registry! {
     NavigatorPanelOptions: [navigator_panel_options::KIND] => navigator_panel_options::SPEC,
     PathfinderOptions: [pathfinder_options::KIND] => pathfinder_options::SPEC,
     RearrangeArtboards: [rearrange_artboards::KIND] => rearrange_artboards::SPEC,
+    RenameArtboards: [rename_artboards::KIND] => rename_artboards::SPEC,
     PathToolOptions: [crate::addons::pathtools::KIND] => crate::addons::pathtools::OPTIONS_SPEC,
     DivideDashes: [crate::addons::pathtools::dashes::KIND] => crate::addons::pathtools::dashes::SPEC,
     SetCorners: [crate::addons::pathtools::set_corners::KIND] => crate::addons::pathtools::set_corners::SPEC,
@@ -605,6 +607,7 @@ pub(crate) fn opened_by_panel(app: &mut VectorcraftApp) {
 /// Draws the active dialog and handles shared initial focus, keyboard shortcuts and actions.
 /// Inline actions and footer buttons use the same confirmation and preview rollback paths.
 pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
+    crate::shortcuts::hold_back_keys(app, ctx);
     about::show(app, ctx);
     settle(app);
     confirm::show_waiting(app);
@@ -737,7 +740,7 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
         });
     });
     let rejected = ctx.data_mut(|d| d.remove_temp::<bool>(widgets::dialog_reject_commit_flag())).unwrap_or(false);
-    if spec.ok.is_some() && ok_enabled && !after_panel && !rejected && ctx.input(|i| i.key_pressed(egui::Key::Enter)) {
+    if spec.ok.is_some() && ok_enabled && !after_panel && !rejected && crate::shortcuts::pressed_anew(ctx, egui::Key::Enter) {
         ok = true;
     }
     if discard {
diff --git a/crates/ui-egui/src/dialogs/brush_options/tests.rs b/crates/ui-egui/src/dialogs/brush_options/tests.rs
index 6c40bc355..3ae028bb0 100644
--- a/crates/ui-egui/src/dialogs/brush_options/tests.rs
+++ b/crates/ui-egui/src/dialogs/brush_options/tests.rs
@@ -312,9 +312,9 @@ fn click_text(ctx: &egui::Context, app: &mut VectorcraftApp, label: &str) {
 
 /// Presses Escape.
 fn escape(ctx: &egui::Context, app: &mut VectorcraftApp) {
-    let key = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
-    frame(ctx, app, vec![key], "");
-    frame(ctx, app, vec![], "");
+    let key = |pressed| egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed, repeat: false, modifiers: Default::default() };
+    frame(ctx, app, vec![key(true)], "");
+    frame(ctx, app, vec![key(false)], "");
 }
 
 /// Scatter, Art and Pattern Brush Options have a Tips button beside Method. A click on it opens
@@ -390,6 +390,24 @@ fn escape_closes_tips_or_the_method_list_and_leaves_the_dialog_open() {
     assert!(app.ui.dialog.is_none(), "Escape cancels Calligraphic Brush Options");
 }
 
+/// Holding Escape closes Tips and leaves Brush Options open until a new press.
+#[test]
+fn holding_escape_closes_tips_and_leaves_the_dialog_open() {
+    let (mut app, ctx) = (app(), ctx());
+    app.run("ui.brushOptions", json!({"name": "Confetti"})).unwrap();
+    set(&mut app, json!({"tips": true}));
+    let key = |pressed| egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed, repeat: false, modifiers: Default::default() };
+    frame(&ctx, &mut app, vec![], "");
+    for repeat in 0..4 {
+        frame(&ctx, &mut app, vec![key(true)], "");
+        let d = app.ui.dialog.as_ref().unwrap_or_else(|| panic!("repeat {repeat}: Brush Options stays open"));
+        assert!(!d.bool("tips"), "repeat {repeat}: Tips closed");
+    }
+    frame(&ctx, &mut app, vec![key(false)], "");
+    frame(&ctx, &mut app, vec![key(true)], "");
+    assert!(app.ui.dialog.is_none(), "a new press cancels Brush Options");
+}
+
 /// Each Colorization Tips sample paints the brush with its own method on the blue stroke:
 /// Confetti's black and gray art keeps its colors with None, its black becomes the stroke color
 /// with Tints and with Hue Shift (black is its key color), and stays black with Tints and Shades.
diff --git a/crates/ui-egui/src/dialogs/effect.rs b/crates/ui-egui/src/dialogs/effect.rs
index fa4c8dcee..a77d0eed6 100644
--- a/crates/ui-egui/src/dialogs/effect.rs
+++ b/crates/ui-egui/src/dialogs/effect.rs
@@ -710,12 +710,21 @@ fn drop_shadow_fields(ui: &mut egui::Ui, d: &mut Dialog, unit: vectorcraft_doc::
     d.fields.extend(own);
     let darkness = d.str("shade").eq_ignore_ascii_case("darkness");
     ui.add_space(4.0);
+    // A double-click on Color's swatch asks for the Color Picker over this dialog (#5364).
+    let mut pick = None;
     egui::Grid::new("fx-shade").num_columns(2).spacing([12.0, 8.0]).show(ui, |ui| {
         if widgets::radio(ui, tl!("Color"), !darkness, true) {
             d.fields.insert("shade".into(), json!("color"));
         }
         ui.add_enabled_ui(!darkness, |ui| {
-            form::color_text(ui, d, "color", 128.0);
+            ui.horizontal(|ui| {
+                form::color_text(ui, d, "color", 128.0);
+                if let Some(c) = d.fields.get("color").and_then(vectorcraft_engine::cmd::color_value)
+                    && form::colour_swatch(ui, "color", c)
+                {
+                    pick = Some(c);
+                }
+            });
         });
         ui.end_row();
         if widgets::radio(ui, tl!("Darkness"), darkness, true) {
@@ -728,7 +737,11 @@ fn drop_shadow_fields(ui: &mut egui::Ui, d: &mut Dialog, unit: vectorcraft_doc::
         });
         ui.end_row();
     });
-    values_changed(d)
+    let changed = values_changed(d);
+    if let Some(c) = pick {
+        *d = super::color_picker::over_effect(d, "color", c);
+    }
+    changed
 }
 
 /// A curve's graph of its points `pts` (0..1 each; input across, output up), as Curves and
@@ -1042,6 +1055,67 @@ mod tests {
         assert_eq!(fx.params.get("color"), Some(&json!("#00ff00")), "Outer Glow takes the picked colour");
     }
 
+    /// Effect > Stylize > Drop Shadow: Color has a swatch beside its field, as Outer Glow's does
+    /// (#5364); a double-click opens the Color Picker over the dialog, whose OK fills Color and
+    /// comes back, and the effect applies the picked colour. With Darkness chosen the swatch is
+    /// dimmed and opens nothing.
+    #[test]
+    fn drop_shadow_colour_swatch_opens_the_color_picker() {
+        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+        app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
+        let id = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap();
+        app.run("select.all", json!({})).unwrap();
+        app.run("effect.dialog", json!({"effect": DROP_SHADOW})).unwrap();
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        crate::theme::apply(&ctx, Default::default());
+        let frame = |app: &mut VectorcraftApp, time: f64, events: Vec<egui::Event>| {
+            let mut out = ctx.run_ui(egui::RawInput { time: Some(time), events, ..Default::default() }, |ui| super::super::show(app, ui.ctx()));
+            out.textures_delta.clear();
+            out
+        };
+        for n in 0..6 {
+            frame(&mut app, f64::from(n) * 0.01, vec![]);
+        }
+        let rect = ctx.read_response(form::colour_swatch_id("color")).expect("the colour swatch is drawn").rect;
+        let swatch = |out: &egui::FullOutput| {
+            out.shapes.iter().find_map(|c| match &c.shape {
+                egui::Shape::Rect(r) if r.rect == rect => Some(r.fill),
+                _ => None,
+            })
+        };
+        assert_eq!(swatch(&frame(&mut app, 0.2, vec![])), Some(egui::Color32::BLACK), "the swatch shows the shadow's #000000");
+        let pos = rect.center();
+        let button = |pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
+        let double_click = |app: &mut VectorcraftApp, t: f64| {
+            frame(app, t, vec![egui::Event::PointerMoved(pos), button(true)]);
+            frame(app, t + 0.05, vec![button(false)]);
+            frame(app, t + 0.1, vec![button(true)]);
+            frame(app, t + 0.15, vec![button(false)]);
+            frame(app, t + 0.2, vec![]);
+        };
+        // With Darkness chosen the swatch opens nothing.
+        app.ui.dialog.as_mut().unwrap().fields.insert("shade".into(), json!("darkness"));
+        frame(&mut app, 0.25, vec![]);
+        double_click(&mut app, 0.3);
+        assert_eq!(app.ui.dialog.as_ref().unwrap().kind, "effect", "a dimmed swatch opens nothing");
+        app.ui.dialog.as_mut().unwrap().fields.insert("shade".into(), json!("color"));
+        frame(&mut app, 0.6, vec![]);
+        double_click(&mut app, 0.7);
+        let d = app.ui.dialog.as_ref().expect("a dialog");
+        assert_eq!(d.kind, "colorPicker", "a double-click opens the Color Picker over Drop Shadow");
+        assert_eq!(d.fields.get("color").and_then(vectorcraft_engine::cmd::color_value), Some(Color::rgb(0.0, 0.0, 0.0)), "on the shadow's colour");
+        app.ui.dialog.as_mut().unwrap().fields.insert("color".into(), json!("#0000ff"));
+        super::super::confirm(&mut app).unwrap();
+        let d = app.ui.dialog.as_ref().expect("Drop Shadow is back");
+        assert_eq!((d.kind.as_str(), d.fields.get("color")), ("effect", Some(&json!("#0000ff"))), "OK fills Color and comes back");
+        frame(&mut app, 1.2, vec![]);
+        super::super::confirm(&mut app).unwrap();
+        let st = app.session.doc().unwrap();
+        let fx = &st.doc.node(vectorcraft_doc::NodeId(id)).unwrap().appearance.effects[0];
+        assert_eq!((fx.id.as_str(), fx.params.get("color")), (DROP_SHADOW, Some(&json!("#0000ff"))), "Drop Shadow takes the picked colour");
+    }
+
     /// Effect > Stylize > Drop Shadow and Outer Glow: Opacity, the offsets, Blur and Darkness have
     /// spinner arrows (#5367, #5368). A click on the top half steps up, on the bottom half down;
     /// Opacity stops at 100 % and Blur at 0, and OK applies the stepped values.
diff --git a/crates/ui-egui/src/dialogs/form.rs b/crates/ui-egui/src/dialogs/form.rs
index 5e5b4ea9c..8d4a68ed0 100644
--- a/crates/ui-egui/src/dialogs/form.rs
+++ b/crates/ui-egui/src/dialogs/form.rs
@@ -177,7 +177,7 @@ pub(super) fn colour_swatch_id(key: &str) -> egui::Id {
 /// The colour swatch beside the colour field `key`, showing `colour`: a double-click asks for the
 /// Color Picker over this dialog, whose OK fills the field ([`super::color_picker::over_effect`]).
 /// Returns whether the picker was asked for.
-fn colour_swatch(ui: &mut egui::Ui, key: &str, colour: Color) -> bool {
+pub(super) fn colour_swatch(ui: &mut egui::Ui, key: &str, colour: Color) -> bool {
     let t = Tokens::get(ui.ctx());
     let (rect, _) = ui.allocate_exact_size(egui::vec2(20.0, 18.0), egui::Sense::hover());
     let resp = ui.interact(rect, colour_swatch_id(key), egui::Sense::click());
diff --git a/crates/ui-egui/src/dialogs/justification.rs b/crates/ui-egui/src/dialogs/justification.rs
index d4f58602d..dc42dcff8 100644
--- a/crates/ui-egui/src/dialogs/justification.rs
+++ b/crates/ui-egui/src/dialogs/justification.rs
@@ -9,7 +9,8 @@
 //! Fields: `wordMin`, `wordDesired`, `wordMax` (0..1000), `letterMin`, `letterDesired`,
 //! `letterMax` (-100..500), `glyphMin`, `glyphDesired`, `glyphMax` (50..200), `autoLeading`
 //! (0..500), `singleWord` (`fullJustify`, `alignLeft`, `alignCenter`, `alignRight`) and `preview`,
-//! with `__initial` (the values it opened with) and `__targets` (the type and range it acts on).
+//! with `__initial` (the values it opened with), `__targets` (the type and range it acts on) and,
+//! after Select All in threaded text, `__story` (the edited frame, whose story it acts on).
 //!
 //! Behaviour reference (public documentation):
 //! <https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/adjust-word-and-letterspacing-in-justified-text.html>.
@@ -29,6 +30,9 @@ pub const KIND: &str = "justification";
 const INITIAL: &str = "__initial";
 /// The field holding the `ids`, `start` and `end` the dialog's `text.setFormat` acts on.
 const TARGETS: &str = "__targets";
+/// The field holding the frame the Type tool edits when the dialog opened after Select All in
+/// threaded text: the dialog then acts on that frame's story as the document holds it.
+const STORY: &str = "__story";
 const CMD: &str = "text.setFormat";
 
 pub(super) const SPEC: DialogSpec = DialogSpec {
@@ -85,13 +89,12 @@ pub fn open(app: &mut VectorcraftApp) -> Result<Value, String> {
     crate::panels::character::text_style(app).ok_or("select some type first")?;
     // While typing, the dialog acts on the paragraphs of the text being edited.
     let mut targets = json!({});
+    let mut story = None;
     if let Some((id, a, b)) = crate::panels::character::text_editing(app) {
         crate::panels::character::end_typing(app);
-        targets = match crate::panels::character::text_story(app) {
-            // After Select All in threaded text: every paragraph of every frame.
-            Some(story) => json!({"ids": story.iter().map(|f| f.0).collect::<Vec<_>>()}),
-            None => json!({"ids": [id.0], "start": a, "end": b}),
-        };
+        targets = json!({"ids": [id.0], "start": a, "end": b});
+        // After Select All in threaded text: every paragraph of every frame ([`params`]).
+        story = crate::panels::character::text_story(app).map(|_| id.0);
     }
     let mut values = Map::new();
     for (_, prefix, _) in ROWS {
@@ -115,6 +118,9 @@ pub fn open(app: &mut VectorcraftApp) -> Result<Value, String> {
     let mut fields = Value::Object(values.clone());
     fields[INITIAL] = Value::Object(values);
     fields[TARGETS] = targets;
+    if let Some(id) = story {
+        fields[STORY] = json!(id);
+    }
     fields["preview"] = json!(false);
     app.ui.dialog = Some(Dialog::new(KIND, fields));
     Ok(Value::Null)
@@ -179,17 +185,30 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
             ui.add_space(6.0);
             ui.colored_label(crate::theme::Tokens::get(ui.ctx()).error, why);
         }
-        None => form::preview(app, ui, d, tl!("Justification"), CMD, Value::Object(params(d))),
+        None => {
+            let p = params(app, d);
+            form::preview(app, ui, d, tl!("Justification"), CMD, Value::Object(p));
+        }
     }
     false
 }
 
 /// `text.setFormat` parameters: the fields that differ from the values the dialog opened with,
-/// on the dialog's type and range.
-fn params(d: &Dialog) -> Map<String, Value> {
+/// on the dialog's type and range. After Select All in threaded text the type is every frame of
+/// the edited frame's thread as the document holds it now; when that frame is no longer threaded,
+/// every paragraph in that frame.
+fn params(app: &VectorcraftApp, d: &Dialog) -> Map<String, Value> {
     let initial = d.fields.get(INITIAL).and_then(Value::as_object);
     let was = |key: &str| initial.and_then(|m| m.get(key)).and_then(Value::as_f64);
     let mut p = d.fields.get(TARGETS).and_then(Value::as_object).cloned().unwrap_or_default();
+    if let (Some(id), Some(st)) = (d.fields.get(STORY).and_then(Value::as_u64), app.session.active()) {
+        let story = st.doc.story_of(vectorcraft_doc::NodeId(id));
+        p.remove("start");
+        p.remove("end");
+        if story.len() >= 2 {
+            p.insert("ids".into(), json!(story.iter().map(|f| f.0).collect::<Vec<_>>()));
+        }
+    }
     for (param, prefix, _) in ROWS {
         let mut changed = Map::new();
         for (suffix, name) in COLUMNS {
@@ -229,7 +248,7 @@ fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
     if let Some(why) = problem(d) {
         return Err(why.into());
     }
-    let p = params(d);
+    let p = params(app, d);
     if !changes(&p) {
         if app.session.in_interaction() {
             let _ = app.session.cancel_interaction();
@@ -352,6 +371,58 @@ mod tests {
         assert_eq!(paras(&app, id).0.justification.auto_leading, 120.0);
     }
 
+    /// After Select All in threaded text, OK changes the frames in the edited frame's thread when OK
+    /// is pressed: not a frame that left the thread while the dialog was open, and a frame that
+    /// joined it.
+    #[test]
+    fn justification_dialog_follows_the_story_thread_at_ok() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 900, "height": 300})).unwrap();
+        let story = "The quick brown fox jumps over the lazy dog and keeps running far beyond the first frame.\n".repeat(6);
+        let area = json!({"x": 10, "y": 10, "text": story, "size": 12, "area": {"width": 150, "height": 60}});
+        let a = app.run("text.create", area).unwrap()["id"].as_u64().unwrap();
+        let b = app.run("text.thread.add", json!({"from": a, "rect": [200, 10, 150, 60]})).unwrap()["id"].as_u64().unwrap();
+        let c = app.run("text.thread.add", json!({"from": b, "rect": [400, 10, 150, 200]})).unwrap()["id"].as_u64().unwrap();
+        app.run("select.set", json!({"ids": [a]})).unwrap();
+        app.session.select_tool("type", Default::default()).unwrap();
+        app.session.set_tool_option("textSelection", &json!({"editing": a, "anchor": 0, "caret": 0}));
+        app.run("select.all", json!({})).unwrap();
+        app.run("ui.justification", json!({})).unwrap();
+        app.run("text.thread.break", json!({"id": b, "port": "out"})).unwrap();
+        let d = app.run("text.thread.add", json!({"from": a, "rect": [600, 10, 150, 60]})).unwrap()["id"].as_u64().unwrap();
+        set(&mut app, "autoLeading", json!(140));
+        super::super::confirm(&mut app).unwrap();
+        for id in [a, d, b] {
+            assert_eq!(paras(&app, id).0.justification.auto_leading, 140.0, "frame {id} takes the change");
+        }
+        assert_eq!(paras(&app, c).0.justification.auto_leading, 120.0, "the frame that left keeps its paragraphs");
+    }
+
+    /// After Select All in threaded text, a thread broken after the edited frame while the dialog is
+    /// open leaves the whole story in that frame, and OK changes every paragraph it now holds.
+    #[test]
+    fn justification_dialog_takes_the_story_into_a_frame_that_left_its_thread() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 900, "height": 300})).unwrap();
+        let story = "The quick brown fox jumps over the lazy dog and keeps running far beyond the first frame.\n".repeat(6);
+        let area = json!({"x": 10, "y": 10, "text": story, "size": 12, "area": {"width": 150, "height": 60}});
+        let a = app.run("text.create", area).unwrap()["id"].as_u64().unwrap();
+        app.run("text.thread.add", json!({"from": a, "rect": [200, 10, 150, 400]})).unwrap();
+        app.run("select.set", json!({"ids": [a]})).unwrap();
+        app.session.select_tool("type", Default::default()).unwrap();
+        app.session.set_tool_option("textSelection", &json!({"editing": a, "anchor": 0, "caret": 0}));
+        app.run("select.all", json!({})).unwrap();
+        app.run("ui.justification", json!({})).unwrap();
+        app.run("text.thread.break", json!({"id": a, "port": "out"})).unwrap();
+        set(&mut app, "autoLeading", json!(140));
+        super::super::confirm(&mut app).unwrap();
+        let NodeKind::Text(t) = &app.session.active().unwrap().doc.node(NodeId(a)).unwrap().kind else { panic!("not text") };
+        assert!(t.paragraph_count() >= 6, "the story flows into the frame: {} paragraphs", t.paragraph_count());
+        for i in 0..t.paragraph_count() {
+            assert_eq!(t.para_at(i).justification.auto_leading, 140.0, "paragraph {i}");
+        }
+    }
+
     /// When paragraphs in scope disagree, only shared justification values are filled in.
     #[test]
     fn justification_dialog_mixed_paragraph_fields_show_blank() {
diff --git a/crates/ui-egui/src/dialogs/rename_artboards.rs b/crates/ui-egui/src/dialogs/rename_artboards.rs
new file mode 100644
index 000000000..82761e928
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/rename_artboards.rs
@@ -0,0 +1,104 @@
+//! The Artboard tool's canvas menu › Rename: a name for the selected artboards. OK runs
+//! `artboard.rename` as one undo step; with several artboards the name is numbered.
+//!
+//! Fields: `name` (the artboard's name with one artboard, empty with several) and `indices` (the
+//! artboards the dialog opened on).
+
+use serde_json::{Value, json};
+
+use super::{DialogResult, DialogSpec, form, run_and_close};
+use crate::state::Dialog;
+use crate::{VectorcraftApp, widgets};
+
+/// The dialog kind of the artboard Rename dialog.
+pub const KIND: &str = "renameArtboards";
+
+const CMD: &str = "artboard.rename";
+
+pub(super) const SPEC: DialogSpec = DialogSpec { heading: |_| tl!("Rename").into(), body, confirm, min_width: 320.0, ..DialogSpec::FORM };
+
+/// The fields the menu item opens with, for the selected artboards.
+pub fn open_fields(app: &VectorcraftApp) -> Value {
+    let Some(st) = app.session.active() else { return json!({"name": "", "indices": []}) };
+    let indices = crate::panels::artboards::picked(app, st.doc.artboards.len());
+    let name = match indices.as_slice() {
+        [one] => st.doc.artboards.get(*one).map_or("", |a| a.name.as_str()),
+        _ => "",
+    };
+    json!({ "name": name, "indices": indices })
+}
+
+fn body(_: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
+    widgets::label_row(ui, tl!("Name:"), 56.0, |ui| {
+        let r = form::text_edit_named(ui, d, "name", tl!("Name:"), 220.0);
+        if ui.memory(|m| m.focused().is_none()) {
+            r.request_focus();
+        }
+    });
+    false
+}
+
+/// An empty name keeps the names as they are, as the Artboards panel's name field does.
+fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> DialogResult {
+    let name = d.str("name");
+    if name.trim().is_empty() {
+        app.ui.dialog = None;
+        return Ok(Value::Null);
+    }
+    let indices = d.fields.get("indices").cloned().unwrap_or(Value::Null);
+    run_and_close(app, CMD, json!({ "indices": indices, "name": name }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vectorcraft_engine::Session;
+
+    fn app() -> VectorcraftApp {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 100, "height": 50, "artboards": 3})).unwrap();
+        app.select_tool("artboard");
+        app
+    }
+
+    fn names(app: &VectorcraftApp) -> Vec<String> {
+        app.session.active().unwrap().doc.artboards.iter().map(|a| a.name.clone()).collect()
+    }
+
+    /// With one artboard the field starts on its name; with several it starts empty, and OK numbers
+    /// the name in one undo step.
+    #[test]
+    fn the_menu_item_renames_the_selected_artboards() {
+        let mut app = app();
+        crate::menus::invoke(&mut app, CMD, json!({}));
+        let d = app.ui.dialog.as_ref().unwrap();
+        assert_eq!(d.kind, KIND);
+        assert_eq!(d.str("name"), "Artboard 1");
+        app.ui.dialog = None;
+
+        app.session.set_tool_option("selected", &json!([2, 0]));
+        crate::menus::invoke(&mut app, CMD, json!({}));
+        assert_eq!(app.ui.dialog.as_ref().unwrap().str("name"), "");
+        app.ui.dialog.as_mut().unwrap().fields.insert("name".into(), json!(" Page "));
+        let steps = app.session.active().unwrap().history.undo.len();
+        crate::dialogs::confirm(&mut app).unwrap();
+        assert!(app.ui.dialog.is_none());
+        assert_eq!(names(&app), ["Page-1", "Artboard 2", "Page-2"]);
+        assert_eq!(app.session.active().unwrap().history.undo.len(), steps + 1, "one undo step");
+    }
+
+    /// OK with an empty name or the name the artboard already has records no undo step.
+    #[test]
+    fn nothing_changes_for_an_empty_or_unchanged_name() {
+        let mut app = app();
+        let steps = app.session.active().unwrap().history.undo.len();
+        for name in ["   ", "Artboard 1"] {
+            crate::menus::invoke(&mut app, CMD, json!({}));
+            app.ui.dialog.as_mut().unwrap().fields.insert("name".into(), json!(name));
+            crate::dialogs::confirm(&mut app).unwrap();
+            assert!(app.ui.dialog.is_none());
+        }
+        assert_eq!(names(&app), ["Artboard 1", "Artboard 2", "Artboard 3"]);
+        assert_eq!(app.session.active().unwrap().history.undo.len(), steps);
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/tests.rs b/crates/ui-egui/src/dialogs/tests.rs
index c2a7aa2b1..8ab9cb9b8 100644
--- a/crates/ui-egui/src/dialogs/tests.rs
+++ b/crates/ui-egui/src/dialogs/tests.rs
@@ -706,12 +706,14 @@ fn a_dialog_opens_with_its_first_field_focused_so_typing_and_enter_apply() {
         out.textures_delta.clear();
     };
     let enter = || egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
+    let release = || egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed: false, repeat: false, modifiers: Default::default() };
     let bounds = |app: &VectorcraftApp| app.session.doc().unwrap().doc.node(vectorcraft_doc::NodeId(id)).unwrap().geometric_bounds().unwrap();
     // Object › Transform › Rotate…: type 90 over the angle, press Enter.
     crate::menus::invoke(&mut app, "object.rotate", json!({}));
     frame(&mut app, vec![]);
     frame(&mut app, vec![egui::Event::Text("90".into())]);
     frame(&mut app, vec![enter()]);
+    frame(&mut app, vec![release()]);
     assert!(app.ui.dialog.is_none());
     let b = bounds(&app);
     assert!((b.width() - 20.0).abs() < 1e-6 && (b.height() - 40.0).abs() < 1e-6, "{b:?}");
@@ -721,6 +723,7 @@ fn a_dialog_opens_with_its_first_field_focused_so_typing_and_enter_apply() {
     frame(&mut app, vec![]);
     frame(&mut app, vec![egui::Event::Text("15".into())]);
     frame(&mut app, vec![enter()]);
+    frame(&mut app, vec![release()]);
     assert!(app.ui.dialog.is_none());
     let after = bounds(&app);
     assert!((after.x0 - before.x0 - 15.0).abs() < 1e-6 && (after.y0 - before.y0).abs() < 1e-6, "{before:?} → {after:?}");
@@ -732,6 +735,7 @@ fn a_dialog_opens_with_its_first_field_focused_so_typing_and_enter_apply() {
     frame(&mut app, vec![]);
     frame(&mut app, vec![egui::Event::Text("50".into())]);
     frame(&mut app, vec![enter()]);
+    frame(&mut app, vec![release()]);
     assert!(app.ui.dialog.is_none());
     let after = own(&app);
     assert!((after.width() - before.width() / 2.0).abs() < 1e-6 && (after.height() - before.height()).abs() < 1e-6, "{before:?} → {after:?}");
@@ -768,6 +772,7 @@ fn shift_enter_in_a_dialog_field_applies_it_and_confirms_the_dialog() {
     };
     let shift_enter =
         || egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::SHIFT };
+    let release = || egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed: false, repeat: false, modifiers: egui::Modifiers::SHIFT };
     let bounds = |app: &VectorcraftApp| app.session.doc().unwrap().doc.node(vectorcraft_doc::NodeId(id)).unwrap().geometric_bounds().unwrap();
     // Move…: type 15 over its first field and press Shift+Enter.
     let before = bounds(&app);
@@ -776,6 +781,7 @@ fn shift_enter_in_a_dialog_field_applies_it_and_confirms_the_dialog() {
     frame(&mut app, vec![]);
     frame(&mut app, vec![egui::Event::Text("15".into())]);
     frame(&mut app, vec![shift_enter()]);
+    frame(&mut app, vec![release()]);
     assert!(app.ui.dialog.is_none(), "Shift+Enter confirms the Move dialog");
     let after = bounds(&app);
     assert!((after.x0 - before.x0 - 15.0).abs() < 1e-6 && (after.y0 - before.y0).abs() < 1e-6, "{before:?} → {after:?}");
@@ -2386,8 +2392,8 @@ fn the_flattener_and_3d_sliders_step_with_the_arrow_keys() {
 /// The Blob Brush Tool Options' tip preview is the Angle slider for screen readers, with the Angle
 /// as its value. A click in it points the Angle at the pointer and gives it the focus, its arrow
 /// keys then step the Angle by one degree (ten with Shift) within -180° to 180°, Shift+Tab leaves
-/// it for the Roundness field and Tab comes back to it, and a drag still sets the Angle and gives
-/// it the focus.
+/// it for the Roundness field and Tab comes back to it (one press: the Roundness field's label is
+/// not a tab stop of its own), and a drag still sets the Angle and gives it the focus.
 #[test]
 fn the_blob_brush_tip_preview_is_a_named_slider_with_arrow_keys() {
     use egui::Key::{ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home, Tab};
@@ -2428,8 +2434,8 @@ fn the_blob_brush_tip_preview_is_a_named_slider_with_arrow_keys() {
     f.key(&mut app, Tab, M::SHIFT);
     f.key(&mut app, ArrowRight, M::NONE);
     assert_eq!(angle(&app), -179.0, "the Roundness field has the focus");
-    // Tab goes from the Roundness field to the scrub area on its label, then to the preview.
-    f.key(&mut app, Tab, M::NONE);
+    // Tab goes from the Roundness field straight to the preview: a field's scrub label is not a
+    // tab stop of its own.
     f.key(&mut app, Tab, M::NONE);
     f.key(&mut app, ArrowRight, M::NONE);
     assert_eq!(angle(&app), -178.0, "Tab comes back to the preview");
diff --git a/crates/ui-egui/src/dialogs/tests_revolve_gizmo.rs b/crates/ui-egui/src/dialogs/tests_revolve_gizmo.rs
index 9f348410e..0249bb199 100644
--- a/crates/ui-egui/src/dialogs/tests_revolve_gizmo.rs
+++ b/crates/ui-egui/src/dialogs/tests_revolve_gizmo.rs
@@ -137,6 +137,10 @@ fn free_orbit_and_light_drag_update_the_canvas_and_escape_restores_only_the_gest
     assert_ne!(h.value("rotationX"), before["rotationX"].as_f64().unwrap());
     assert_ne!(h.value("rotationY"), before["rotationY"].as_f64().unwrap());
     h.frame(vec![escape()], Modifiers::NONE);
+    h.frame(
+        vec![Event::Key { key: egui::Key::Escape, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE }],
+        Modifiers::NONE,
+    );
     h.release(p, Modifiers::NONE);
     assert!(h.app.ui.dialog.is_some());
     assert_eq!(super::super::form::params(h.app.ui.dialog.as_ref().unwrap()), before);
diff --git a/crates/ui-egui/src/export_progress.rs b/crates/ui-egui/src/export_progress.rs
index 1854ad734..02d1ab7ff 100644
--- a/crates/ui-egui/src/export_progress.rs
+++ b/crates/ui-egui/src/export_progress.rs
@@ -135,6 +135,39 @@ pub fn busy(ui: &mut egui::Ui, what: &str) {
     });
 }
 
+/// Seconds the moving segment of an [`indeterminate`] bar takes to cross the track once.
+const SWEEP: f64 = 1.6;
+
+/// The share of the track an [`indeterminate`] bar's segment covers.
+const SEGMENT: f32 = 0.3;
+
+/// Where the segment of an [`indeterminate`] bar is at `time` seconds: its left and right ends as
+/// shares of the track, clipped to it (it enters at the left and leaves at the right).
+pub fn sweep_at(time: f64) -> (f32, f32) {
+    let phase = if time.is_finite() { (time / SWEEP).rem_euclid(1.0) as f32 } else { 0.0 };
+    let left = phase * (1.0 + SEGMENT) - SEGMENT;
+    (left.max(0.0), (left + SEGMENT).min(1.0))
+}
+
+/// Work whose progress isn't known, in a [`window`]: `what` it does, in the UI language, over a
+/// bar whose segment keeps sweeping across it while the window shows.
+pub fn indeterminate(ui: &mut egui::Ui, what: &str) {
+    let t = Tokens::get(ui.ctx());
+    ui.label(egui::RichText::new(what).color(t.text_dim));
+    ui.add_space(4.0);
+    let (rect, response) = ui.allocate_exact_size(egui::vec2(360.0, 6.0), egui::Sense::hover());
+    response.widget_info(|| egui::WidgetInfo::labeled(egui::Role::ProgressIndicator, true, what));
+    let radius = egui::CornerRadius::same(3);
+    ui.painter().rect_filled(rect, radius, ui.visuals().extreme_bg_color);
+    let (from, to) = sweep_at(ui.input(|i| i.time));
+    if to > from {
+        let x = |share: f32| rect.left() + rect.width() * share;
+        let segment = egui::Rect::from_min_max(egui::pos2(x(from), rect.top()), egui::pos2(x(to), rect.bottom()));
+        ui.painter().rect_filled(segment, radius, t.accent);
+    }
+    ui.ctx().request_repaint();
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
diff --git a/crates/ui-egui/src/i18n/bg.tsv b/crates/ui-egui/src/i18n/bg.tsv
index e60b76cef..f6a8debdc 100644
--- a/crates/ui-egui/src/i18n/bg.tsv
+++ b/crates/ui-egui/src/i18n/bg.tsv
@@ -872,6 +872,7 @@ font-technology	Variable	Променливи
 	Duplicate Artboard	Дублиране на работна област
 	Copy Artboard	Копиране на работна област
 	Cut Artboard	Изрязване на работна област
+	Rename Artboards	Преименуване на работни области
 	Duplicate Artboards	Дублиране на работни области
 	Duplicate Brush	Дублиране на четка
 	Duplicate Character Style	Дублиране на стил на знаци
@@ -2503,6 +2504,9 @@ digits	Malayalam	Малаялам
 	Real World:	Реален свят:
 	Real-time Drawing and Editing	Чертане и редактиране в реално време
 	Rearrange All Artboards	Пренареждане на всички работни области
+	Rearrange	Пренареждане
+	Select All Artboards	Избиране на всички работни области
+	Switch Orientation	Смяна на ориентацията
 	Rearrange All	Пренареждане на всички
 	Layout Order:	Ред на оформление:
 	Change to Left-to-Right Layout	Превключване към подредба отляво надясно
@@ -4529,6 +4533,7 @@ axis	Both	И двете
 @msg	an image whose data is cut short was left out	изображение с непълни данни беше пропуснато
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	свързаните картини показват записания във файла предварителен преглед с ниска резолюция, докато файловете им бъдат намерени: презакачете ги в панела „Връзки“
 @msg	linked type areas past VectorCraft's limits were left out	свързаните текстови области извън ограниченията на VectorCraft бяха пропуснати
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	текст, който сменя посоката на писане в рамките на текстов обект, се отваря в посоката на първия си знак
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	текст, използван като маска в свързани области, обтичащ текст или съставен път, не изрязва
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	свързаните картини без предварителен преглед във файла показват заместител, докато файловете им бъдат намерени: презакачете ги в панела „Връзки“
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	текстовите рамки за област в редове, твърде къси за шрифта, в който се показват, получиха по-високи рамки ({_1}): текстът им иначе нямаше да се види
diff --git a/crates/ui-egui/src/i18n/bs.tsv b/crates/ui-egui/src/i18n/bs.tsv
index 0d95e8018..a8db1ebea 100644
--- a/crates/ui-egui/src/i18n/bs.tsv
+++ b/crates/ui-egui/src/i18n/bs.tsv
@@ -1924,6 +1924,9 @@ digits	Malayalam	Malajalam
 	More Paragraph options	Više opcija pasusa
 	No document open	Nijedan dokument nije otvoren
 	Quick Actions	Brze akcije
+	Rearrange	Preuredi
+	Select All Artboards	Odaberi sve radne ploče
+	Switch Orientation	Promijeni orijentaciju
 	Rearrange All	Preuredi sve
 	Rulers & Grids	Ravnala i mreže
 	Select a text object	Odaberite tekstualni objekat
@@ -3446,6 +3449,7 @@ theme	Appearance	Izgled
 	Character / Paragraph	Znak / pasus
 	Copy Artboard	Kopiraj radnu ploču
 	Cut Artboard	Izreži radnu ploču
+	Rename Artboards	Preimenuj radne ploče
 	Move Artboard Up/Down	Pomakni radnu ploču gore/dolje
 	Add Anchor (Pen)	Dodaj sidro (pero)
 	Add Anchor Point	Dodaj sidrenu tačku
@@ -4928,6 +4932,7 @@ imageTrace	Outline	Obris
 @msg	an image whose data is cut short was left out	izostavljena je slika čiji su podaci skraćeni
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	povezane slike prikazuju pregled niske rezolucije sačuvan u datoteci dok se njihove datoteke ne pronađu: ponovo ih povežite u panelu Veze
 @msg	linked type areas past VectorCraft's limits were left out	povezana područja teksta izvan ograničenja programa VectorCraft su izostavljena
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	tekst koji mijenja smjer pisanja unutar tekstualnog objekta otvara se u smjeru svog prvog znaka
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	tekst korišten kao maska u povezanim područjima, omotanom tekstu ili složenoj putanji ne odsijeca
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	povezane slike bez pregleda u datoteci prikazuju čuvar mjesta dok se njihove datoteke ne pronađu: ponovo ih povežite u panelu Veze
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	tekst u području u okvirima prekratkim za red fonta u kojem se prikazuje dobio je više okvire ({_1}): inače se tekst ne bi prikazao
diff --git a/crates/ui-egui/src/i18n/ca.tsv b/crates/ui-egui/src/i18n/ca.tsv
index a3cb5b42a..3898a677f 100644
--- a/crates/ui-egui/src/i18n/ca.tsv
+++ b/crates/ui-egui/src/i18n/ca.tsv
@@ -962,6 +962,7 @@
 	Customize…	Personalitza…
 	Cut	Retalla
 	Cut Artboard	Retalla el tauler
+	Rename Artboards	Canvia el nom dels taulers
 	Cut Path	Retalla el traçat
 	Cut Path at Selected Anchor Points	Retalla el traçat als punts d’ancoratge seleccionats
 	Cutout	Retall
@@ -3206,6 +3207,9 @@ digits	Malayalam	Malaiàlam
 	Real name	Nom real
 	Real World:	Món real:
 	Real-time Drawing and Editing	Dibuix i edició en temps real
+	Rearrange	Reorganitza
+	Select All Artboards	Selecciona tots els taulers
+	Switch Orientation	Canvia l’orientació
 	Rearrange All	Reorganitza-ho tot
 	Rearrange All Artboards	Reorganitza tots els taulers
 	Rearrange All Artboards…	Reorganitza tots els taulers…
@@ -5184,6 +5188,7 @@ digits	Malayalam	Malaiàlam
 @msg	library panel `{given}` isn't open	el panell de biblioteca `{given}` no està obert
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	les imatges enllaçades mostren la previsualització de baixa resolució desada al fitxer fins que es trobin els seus fitxers: torneu-les a enllaçar al panell Enllaços
 @msg	linked type areas past VectorCraft's limits were left out	s’han omès les àrees de text enllaçades que superen els límits de VectorCraft
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	el text que canvia de direcció d’escriptura dins d’un objecte de text s’obre en la direcció del seu primer caràcter
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	el text usat com a màscara en àrees enllaçades, en text ajustat o en un traçat compost no retalla
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	les imatges enllaçades sense previsualització al fitxer mostren un marcador de posició fins que es trobin els seus fitxers: torneu-les a enllaçar al panell Enllaços
 @msg	Live Paint Merge: select a Live Paint group and the paths to add	Fusió de pintura interactiva: seleccioneu un grup de pintura interactiva i els traçats que voleu afegir
diff --git a/crates/ui-egui/src/i18n/cs.tsv b/crates/ui-egui/src/i18n/cs.tsv
index 063ddd591..eff1d2d34 100644
--- a/crates/ui-egui/src/i18n/cs.tsv
+++ b/crates/ui-egui/src/i18n/cs.tsv
@@ -1950,6 +1950,9 @@ digits	Malayalam	Malajálamské
 	More Paragraph options	Další možnosti odstavce
 	No document open	Není otevřen žádný dokument
 	Quick Actions	Rychlé akce
+	Rearrange	Přeuspořádat
+	Select All Artboards	Vybrat všechny pracovní plochy
+	Switch Orientation	Přepnout orientaci
 	Rearrange All	Přeuspořádat vše
 	Rulers & Grids	Pravítka a mřížky
 	Select a text object	Vyberte textový objekt
@@ -3485,6 +3488,7 @@ theme	Appearance	Motiv
 	Character / Paragraph	Znak / Odstavec
 	Copy Artboard	Kopírovat pracovní plochu
 	Cut Artboard	Vyjmout pracovní plochu
+	Rename Artboards	Přejmenovat pracovní plochy
 	Move Artboard Up/Down	Posunout pracovní plochu nahoru/dolů
 	Add Anchor (Pen)	Přidat kotevní bod (pero)
 	Add Anchor Point	Přidat kotevní bod
@@ -4986,6 +4990,7 @@ imageTrace	Outline	Obrys
 @msg	an image whose data is cut short was left out	obrázek s useknutými daty byl vynechán
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	propojené obrázky se zobrazují jako náhled v nízkém rozlišení uložený v souboru, dokud se nenajdou jejich soubory: znovu je propojte v panelu Propojení
 @msg	linked type areas past VectorCraft's limits were left out	propojené textové oblasti nad limity aplikace VectorCraft byly vynechány
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	text, který mění směr psaní uvnitř textového objektu, se otevře ve směru svého prvního znaku
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	text použitý jako maska v propojených oblastech, obtékaném textu nebo složené cestě neořezává
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	propojené obrázky bez náhledu v souboru se zobrazují jako zástupný symbol, dokud se nenajdou jejich soubory: znovu je propojte v panelu Propojení
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	text v oblasti v rámcích příliš nízkých pro řádek písma, ve kterém se zde zobrazuje, dostal vyšší rámce ({_1}): jinak by nebyl vidět
diff --git a/crates/ui-egui/src/i18n/da.tsv b/crates/ui-egui/src/i18n/da.tsv
index 9db09ea0f..abfe581e7 100644
--- a/crates/ui-egui/src/i18n/da.tsv
+++ b/crates/ui-egui/src/i18n/da.tsv
@@ -1756,6 +1756,9 @@ digits	Malayalam	Malayalam
 	More Paragraph options	Flere afsnitsindstillinger
 	No document open	Intet åbent dokument
 	Quick Actions	Hurtige handlinger
+	Rearrange	Omarrangér
+	Select All Artboards	Markér alle tegnebrætter
+	Switch Orientation	Skift retning
 	Rearrange All	Omarrangér alle
 	Rulers & Grids	Linealer og gitre
 	Select a text object	Markér et tekstobjekt
@@ -3227,6 +3230,7 @@ theme	Appearance	Udseende
 	Character / Paragraph	Tegn / Afsnit
 	Copy Artboard	Kopiér kunstplade
 	Cut Artboard	Klip kunstplade
+	Rename Artboards	Omdøb tegnebrætter
 	Move Artboard Up/Down	Flyt kunstplade op/ned
 	Add Anchor (Pen)	Tilføj anker (Pen)
 	Add Anchor Point	Tilføj ankerpunkt
@@ -4614,6 +4618,7 @@ imageTrace	Outline	Kontur
 @msg	an image whose data is cut short was left out	et billede, hvis data er afkortet, blev udeladt
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	linkede billeder viser den gemte forhåndsvisning i lav opløsning, indtil deres filer findes: link dem igen i Links-panelet
 @msg	linked type areas past VectorCraft's limits were left out	sammenkædede tekstområder ud over VectorCrafts grænser blev udeladt
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	tekst, der skifter skriveretning inde i et tekstobjekt, åbnes i retningen for sit første tegn
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	tekst brugt som maske i sammenkædede områder, ombrudt tekst eller en sammensat kurve beskærer ikke
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	linkede billeder uden forhåndsvisning i filen viser en pladsholder, indtil deres filer findes: link dem igen i Links-panelet
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	rammetekst i rammer, der er for lave til en tekstlinje i den skrifttype, den viser i, fik højere rammer ({_1}): teksten ville ellers ikke blive vist
diff --git a/crates/ui-egui/src/i18n/de.tsv b/crates/ui-egui/src/i18n/de.tsv
index d28aa09df..4a4142d88 100644
--- a/crates/ui-egui/src/i18n/de.tsv
+++ b/crates/ui-egui/src/i18n/de.tsv
@@ -866,6 +866,7 @@ font-technology	Variable	Variabel
 	Duplicate Artboard	Zeichenfläche duplizieren
 	Copy Artboard	Zeichenfläche kopieren
 	Cut Artboard	Zeichenfläche ausschneiden
+	Rename Artboards	Zeichenflächen umbenennen
 	Duplicate Artboards	Zeichenflächen duplizieren
 	Duplicate Brush	Pinsel duplizieren
 	Duplicate Character Style	Zeichenformat duplizieren
@@ -2529,6 +2530,9 @@ digits	Malayalam	Malayalam
 	Real World:	Reale Welt:
 	Real-time Drawing and Editing	Zeichnen und Bearbeiten in Echtzeit
 	Rearrange All Artboards	Alle Zeichenflächen neu anordnen
+	Rearrange	Neu anordnen
+	Select All Artboards	Alle Zeichenflächen auswählen
+	Switch Orientation	Ausrichtung wechseln
 	Rearrange All	Alle neu anordnen
 	Layout Order:	Layoutreihenfolge:
 	Change to Left-to-Right Layout	In Layout von links nach rechts ändern
@@ -4596,6 +4600,7 @@ theme	Appearance	Erscheinungsbild
 @msg	an image whose data is cut short was left out	ein Bild mit abgeschnittenen Daten wurde ausgelassen
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	verknüpfte Bilder zeigen die in der Datei gespeicherte Vorschau in niedriger Auflösung, bis ihre Dateien gefunden werden: Verknüpfen Sie sie im Bedienfeld „Verknüpfungen“ neu
 @msg	linked type areas past VectorCraft's limits were left out	verkettete Textbereiche jenseits der Grenzen von VectorCraft wurden ausgelassen
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	Text, der innerhalb eines Textobjekts die Schreibrichtung wechselt, wird in der Richtung seines ersten Zeichens geöffnet
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	als Maske verwendeter Text in verketteten Bereichen, umfließendem Text oder einem zusammengesetzten Pfad beschneidet nicht
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	verknüpfte Bilder ohne Vorschau in der Datei zeigen einen Platzhalter, bis ihre Dateien gefunden werden: Verknüpfen Sie sie im Bedienfeld „Verknüpfungen“ neu
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	Flächentext in Rahmen, die für eine Zeile der Schrift, in der er hier erscheint, zu niedrig sind, hat höhere Rahmen bekommen ({_1}): Sonst wäre der Text nicht zu sehen
diff --git a/crates/ui-egui/src/i18n/el.tsv b/crates/ui-egui/src/i18n/el.tsv
index 16f80c730..6b2a022d5 100644
--- a/crates/ui-egui/src/i18n/el.tsv
+++ b/crates/ui-egui/src/i18n/el.tsv
@@ -844,6 +844,7 @@ font-technology	Variable	Μεταβλητές
 	Duplicate Artboard	Δημιουργία αντιγράφου πίνακα σχεδίασης
 	Copy Artboard	Αντιγραφή πίνακα σχεδίασης
 	Cut Artboard	Αποκοπή πίνακα σχεδίασης
+	Rename Artboards	Μετονομασία πινάκων σχεδίασης
 	Duplicate Artboards	Δημιουργία αντιγράφων πινάκων σχεδίασης
 	Duplicate Brush	Δημιουργία αντιγράφου πινέλου
 	Duplicate Character Style	Δημιουργία αντιγράφου στυλ χαρακτήρων
@@ -3160,6 +3161,9 @@ digits	Malayalam	Μαλαγιάλαμ
 	Real World:	Πραγματικός κόσμος:
 	Real-time Drawing and Editing	Σχεδίαση και επεξεργασία σε πραγματικό χρόνο
 	Rearrange All Artboards	Αναδιάταξη όλων των πινάκων σχεδίασης
+	Rearrange	Αναδιάταξη
+	Select All Artboards	Επιλογή όλων των πινάκων σχεδίασης
+	Switch Orientation	Αλλαγή προσανατολισμού
 	Rearrange All	Αναδιάταξη όλων
 	Layout Order:	Σειρά διάταξης:
 	Change to Left-to-Right Layout	Αλλαγή σε διάταξη από αριστερά προς τα δεξιά
@@ -4629,6 +4633,7 @@ digits	Malayalam	Μαλαγιάλαμ
 @msg	an image whose data is cut short was left out	παραλείφθηκε εικόνα με περικομμένα δεδομένα
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	οι συνδεδεμένες εικόνες εμφανίζουν την προεπισκόπηση χαμηλής ανάλυσης που έχει αποθηκευτεί, μέχρι να βρεθούν τα αρχεία τους: επανασυνδέστε τις στον πίνακα Σύνδεσμοι
 @msg	linked type areas past VectorCraft's limits were left out	οι συνδεδεμένες περιοχές κειμένου πέρα από τα όρια του VectorCraft παραλείφθηκαν
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	το κείμενο που αλλάζει κατεύθυνση γραφής μέσα σε ένα αντικείμενο κειμένου ανοίγει με την κατεύθυνση του πρώτου χαρακτήρα του
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	το κείμενο που χρησιμοποιείται ως μάσκα σε συνδεδεμένες περιοχές, σε κείμενο με αναδίπλωση ή σε σύνθετη διαδρομή δεν αποκόπτει
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	οι συνδεδεμένες εικόνες χωρίς προεπισκόπηση στο αρχείο εμφανίζουν ένα σύμβολο κράτησης θέσης, μέχρι να βρεθούν τα αρχεία τους: επανασυνδέστε τις στον πίνακα Σύνδεσμοι
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	οι περιοχές κειμένου με πλαίσια πολύ μικρά για μία γραμμή της γραμματοσειράς τους απέκτησαν μεγαλύτερο ύψος ({_1}), διαφορετικά το κείμενο δεν θα εμφανιζόταν
diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv
index fafd0122e..6ccd50b46 100644
--- a/crates/ui-egui/src/i18n/es.tsv
+++ b/crates/ui-egui/src/i18n/es.tsv
@@ -887,6 +887,7 @@ font-technology	Variable	Variables
 	Duplicate Artboard	Duplicar mesa de trabajo
 	Copy Artboard	Copiar mesa de trabajo
 	Cut Artboard	Cortar mesa de trabajo
+	Rename Artboards	Cambiar nombre de mesas de trabajo
 	Duplicate Artboards	Duplicar mesas de trabajo
 	Duplicate Brush	Duplicar pincel
 	Duplicate Character Style	Duplicar estilo de carácter
@@ -2572,6 +2573,9 @@ digits	Malayalam	Malayálam
 	Real World:	Mundo real:
 	Real-time Drawing and Editing	Dibujo y edición en tiempo real
 	Rearrange All Artboards	Reorganizar todas las mesas de trabajo
+	Rearrange	Reorganizar
+	Select All Artboards	Seleccionar todas las mesas de trabajo
+	Switch Orientation	Cambiar orientación
 	Rearrange All	Reorganizar todo
 	Layout Order:	Orden de diseño:
 	Change to Left-to-Right Layout	Cambiar a diseño de izquierda a derecha
@@ -4680,6 +4684,7 @@ axis	Both	Ambos
 @msg	an image whose data is cut short was left out	se omitió una imagen con datos incompletos
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	las imágenes vinculadas muestran la vista previa de baja resolución guardada en el archivo hasta que se encuentren sus archivos: vuelva a vincularlas en el panel Vínculos
 @msg	linked type areas past VectorCraft's limits were left out	se omitieron las áreas de texto enlazadas que superan los límites de VectorCraft
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	el texto que cambia de dirección de escritura dentro de un objeto de texto se abre en la dirección de su primer carácter
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	el texto usado como máscara en áreas enlazadas, texto ceñido o un trazado compuesto no recorta
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	las imágenes vinculadas sin vista previa en el archivo muestran un marcador de posición hasta que se encuentren sus archivos: vuelva a vincularlas en el panel Vínculos
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	el texto de área en marcos demasiado bajos para una línea de la fuente en que se muestra recibió marcos más altos ({_1}): de otro modo no se vería
diff --git a/crates/ui-egui/src/i18n/fi.tsv b/crates/ui-egui/src/i18n/fi.tsv
index 9c0d61be2..3cf8607c0 100644
--- a/crates/ui-egui/src/i18n/fi.tsv
+++ b/crates/ui-egui/src/i18n/fi.tsv
@@ -1911,6 +1911,9 @@ digits	Malayalam	Malajalam
 	More Paragraph options	Lisää kappaleasetuksia
 	No document open	Ei avointa asiakirjaa
 	Quick Actions	Pikatoiminnot
+	Rearrange	Järjestä uudelleen
+	Select All Artboards	Valitse kaikki piirtoalustat
+	Switch Orientation	Vaihda suuntaa
 	Rearrange All	Järjestä kaikki uudelleen
 	Rulers & Grids	Viivaimet ja ruudukot
 	Select a text object	Valitse tekstiobjekti
@@ -3423,6 +3426,7 @@ theme	Appearance	Ulkoasu
 	Character / Paragraph	Merkki / kappale
 	Copy Artboard	Kopioi piirtoalusta
 	Cut Artboard	Leikkaa piirtoalusta
+	Rename Artboards	Nimeä piirtoalustat uudelleen
 	Move Artboard Up/Down	Siirrä piirtoalustaa ylös/alas
 	Add Anchor (Pen)	Lisää ankkuri (kynä)
 	Add Anchor Point	Lisää ankkuripiste
@@ -4888,6 +4892,7 @@ imageTrace	Outline	Ääriviiva
 @msg	an image whose data is cut short was left out	kuva, jonka data on katkennut, jätettiin pois
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	linkitetyt kuvat näyttävät tiedostoon tallennetun matalan tarkkuuden esikatselun, kunnes niiden tiedostot löytyvät: linkitä ne uudelleen Linkit-paneelissa
 @msg	linked type areas past VectorCraft's limits were left out	VectorCraftin rajat ylittävät linkitetyt tekstialueet jätettiin pois
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	tekstiobjektin sisällä kirjoitussuuntaa vaihtava teksti avautuu ensimmäisen merkkinsä suuntaan
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	maskina käytetty teksti linkitetyissä alueissa, rivitetyssä tekstissä tai yhdistelmäpolussa ei rajaa
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	linkitetyt kuvat, joilla ei ole esikatselua tiedostossa, näkyvät paikkamerkkinä, kunnes niiden tiedostot löytyvät: linkitä ne uudelleen Linkit-paneelissa
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	aluetekstin kehykset, jotka olivat liian matalia yhdelle riville niiden fontilla, korotettiin ({_1}): muuten niiden teksti ei näkyisi
diff --git a/crates/ui-egui/src/i18n/fr.tsv b/crates/ui-egui/src/i18n/fr.tsv
index 2da80b01c..67a7cb29c 100644
--- a/crates/ui-egui/src/i18n/fr.tsv
+++ b/crates/ui-egui/src/i18n/fr.tsv
@@ -890,6 +890,7 @@ font-technology	Variable	Variables
 	Duplicate Artboard	Dupliquer le plan de travail
 	Copy Artboard	Copier le plan de travail
 	Cut Artboard	Couper le plan de travail
+	Rename Artboards	Renommer les plans de travail
 	Duplicate Artboards	Dupliquer les plans de travail
 	Duplicate Brush	Dupliquer la forme
 	Duplicate Character Style	Dupliquer le style de caractère
@@ -2564,6 +2565,9 @@ digits	Malayalam	Malayalam
 	Real World:	Monde réel :
 	Real-time Drawing and Editing	Dessin et édition en temps réel
 	Rearrange All Artboards	Réorganiser tous les plans de travail
+	Rearrange	Réorganiser
+	Select All Artboards	Sélectionner tous les plans de travail
+	Switch Orientation	Changer d’orientation
 	Rearrange All	Tout réorganiser
 	Layout Order:	Ordre de disposition :
 	Change to Left-to-Right Layout	Passer à la disposition de gauche à droite
@@ -4668,6 +4672,7 @@ axis	Both	Les deux
 @msg	an image whose data is cut short was left out	une image aux données tronquées a été ignorée
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	les images liées affichent l’aperçu basse résolution enregistré dans le fichier tant que leurs fichiers ne sont pas trouvés : liez-les à nouveau dans le panneau Liens
 @msg	linked type areas past VectorCraft's limits were left out	les zones de texte liées au-delà des limites de VectorCraft ont été omises
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	le texte qui change de sens d’écriture dans un objet texte s’ouvre dans le sens de son premier caractère
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	le texte utilisé comme masque dans des zones liées, un habillage de texte ou un tracé transparent ne découpe pas
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	les images liées sans aperçu dans le fichier affichent un espace réservé tant que leurs fichiers ne sont pas trouvés : liez-les à nouveau dans le panneau Liens
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	le texte captif dans des cadres trop bas pour une ligne de la police dans laquelle il s’affiche a reçu des cadres plus hauts ({_1}) : il ne s’afficherait pas autrement
diff --git a/crates/ui-egui/src/i18n/hi.tsv b/crates/ui-egui/src/i18n/hi.tsv
index d7235790f..e1af82a3a 100644
--- a/crates/ui-egui/src/i18n/hi.tsv
+++ b/crates/ui-egui/src/i18n/hi.tsv
@@ -1077,6 +1077,7 @@
 	Customize…	अनुकूलित करें…
 	Cut	काटें
 	Cut Artboard	कट आर्टबोर्ड
+	Rename Artboards	आर्टबोर्ड्स का नाम बदलें
 	Cut Path	कट पाथ
 	Cut Path at Selected Anchor Points	सिलेक्टेड एंकर अंक पर पाथ काटें
 	Cutout	कटआउट
@@ -3487,6 +3488,9 @@
 	Real name	वास्तविक नाम
 	Real World:	रियल वर्ल्ड:
 	Real-time Drawing and Editing	रियल टाइम ड्राइंग और संपादन
+	Rearrange	फिर से व्यवस्थित करें
+	Select All Artboards	सभी आर्टबोर्ड सिलेक्ट करें
+	Switch Orientation	ओरिएंटेशन स्विच करें
 	Rearrange All	सभी को फिर से व्यवस्थित करें
 	Rearrange All Artboards	सभी आर्टबोर्ड को फिर से व्यवस्थित करें
 	Rearrange All Artboards…	सभी आर्टबोर्ड को पुनर्व्यवस्थित करें…
@@ -7550,6 +7554,7 @@
 @msg	type dimension must be finite	प्रकार आयाम को परिमित होना चाहिए
 @msg	type must be static or dynamic, not {v}	type: प्रकार स्थिर या गतिशील होना चाहिए, न कि {v}
 @msg	type objects can't be isolated	प्रकार ऑब्जेक्ट पृथक नहीं किया जा सकता है
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	टेक्स्ट ऑब्जेक्ट के भीतर लेखन दिशा बदलने वाला टेक्स्ट अपने पहले वर्ण की दिशा में खुलता है
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	प्रकार जुड़े क्षेत्रों में एक मास्क के रूप में इस्तेमाल किया, रैपराउंड टेक्स्ट या एक मिश्रित पाथ क्लिप नहीं करता है
 @msg	Unembedded to {_1}	Unembed to {_1}
 @msg	unexpected host trap	अप्रत्याशित मेजबान जाल
diff --git a/crates/ui-egui/src/i18n/hu.tsv b/crates/ui-egui/src/i18n/hu.tsv
index 9e313975e..82f75da72 100644
--- a/crates/ui-egui/src/i18n/hu.tsv
+++ b/crates/ui-egui/src/i18n/hu.tsv
@@ -903,6 +903,7 @@ font-technology	Variable	Változó
 	Customize…	Testreszabás…
 	Cut	Kivágás
 	Cut Artboard	Rajztábla kivágása
+	Rename Artboards	Rajztáblák átnevezése
 	Cut Path	Útvonal elvágása
 	Cut Path at Selected Anchor Points	Útvonal elvágása a kijelölt horgonypontoknál
 	Cyan	Cián
@@ -3114,6 +3115,9 @@ mark-style	Japanese	Japán
 	Real name	Valódi név
 	Real World:	Valós méret:
 	Real-time Drawing and Editing	Valós idejű rajzolás és szerkesztés
+	Rearrange	Átrendezés
+	Select All Artboards	Összes rajztábla kijelölése
+	Switch Orientation	Tájolás váltása
 	Rearrange All	Összes átrendezése
 	Rearrange All Artboards	Összes rajztábla átrendezése
 	Rearrange All Artboards…	Összes rajztábla átrendezése…
@@ -4692,6 +4696,7 @@ imageTrace	Outline	Körvonal
 @msg	an image whose data is cut short was left out	kimaradt egy csonka adatú kép
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	a csatolt képek a fájlban mentett kis felbontású előnézetet mutatják, amíg a fájljaik elő nem kerülnek: csatold őket újra a Csatolások panelen
 @msg	linked type areas past VectorCraft's limits were left out	a VectorCraft korlátain túli csatolt szövegterületek kimaradtak
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	a szövegobjektumon belül írásirányt váltó szöveg az első karakterének irányában nyílik meg
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	a csatolt területeken, körbefuttatott szövegben vagy összetett útvonalban maszkként használt szöveg nem vág ki
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	a fájlban előnézet nélküli csatolt képek helyőrzőt mutatnak, amíg a fájljaik elő nem kerülnek: csatold őket újra a Csatolások panelen
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	a túl alacsony keretben lévő területszöveg, amelybe a megjelenítő betűtípus egy sora sem fér el, magasabb keretet kapott ({_1}): különben nem látszana
diff --git a/crates/ui-egui/src/i18n/id.tsv b/crates/ui-egui/src/i18n/id.tsv
index 0a6c910fc..7230b6bfa 100644
--- a/crates/ui-egui/src/i18n/id.tsv
+++ b/crates/ui-egui/src/i18n/id.tsv
@@ -1756,6 +1756,9 @@ digits	Malayalam	Malayalam
 	More Paragraph options	Opsi paragraf lainnya
 	No document open	Tidak ada dokumen terbuka
 	Quick Actions	Tindakan cepat
+	Rearrange	Atur ulang
+	Select All Artboards	Seleksi semua artboard
+	Switch Orientation	Ganti orientasi
 	Rearrange All	Atur ulang semua
 	Rulers & Grids	Penggaris & kisi
 	Select a text object	Pilih objek teks
@@ -3227,6 +3230,7 @@ theme	Appearance	Tampilan
 	Character / Paragraph	Karakter / Paragraf
 	Copy Artboard	Salin artboard
 	Cut Artboard	Potong artboard
+	Rename Artboards	Ganti nama artboard
 	Move Artboard Up/Down	Pindahkan artboard ke atas/bawah
 	Add Anchor (Pen)	Tambah jangkar (pena)
 	Add Anchor Point	Tambahkan titik jangkar
@@ -4614,6 +4618,7 @@ imageTrace	Outline	Kontur
 @msg	an image whose data is cut short was left out	gambar yang datanya terpotong tidak disertakan
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	gambar tertaut menampilkan pratinjau resolusi rendah yang tersimpan dalam berkas sampai berkasnya ditemukan: tautkan ulang di panel Tautan
 @msg	linked type areas past VectorCraft's limits were left out	area teks tertaut di luar batas VectorCraft dihilangkan
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	teks yang mengubah arah penulisan di dalam objek teks dibuka dengan arah karakter pertamanya
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	teks yang digunakan sebagai masker di area tertaut, teks terbungkus, atau jalur majemuk tidak memotong
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	gambar tertaut tanpa pratinjau dalam berkas menampilkan penanda tempat sampai berkasnya ditemukan: tautkan ulang di panel Tautan
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	teks area dalam bingkai yang terlalu pendek untuk satu baris font yang ditampilkannya mendapat bingkai yang lebih tinggi ({_1}): tanpa itu teksnya tidak akan tampil
diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv
index 3459374ca..723fa4ab0 100644
--- a/crates/ui-egui/src/i18n/it.tsv
+++ b/crates/ui-egui/src/i18n/it.tsv
@@ -887,6 +887,7 @@ font-technology	Variable	Variabili
 	Duplicate Artboard	Duplica tavola da disegno
 	Copy Artboard	Copia tavola da disegno
 	Cut Artboard	Taglia tavola da disegno
+	Rename Artboards	Rinomina tavole da disegno
 	Duplicate Artboards	Duplica tavole da disegno
 	Duplicate Brush	Duplica pennello
 	Duplicate Character Style	Duplica stile carattere
@@ -2605,6 +2606,9 @@ digits	Malayalam	Malayalam
 	Real World:	Mondo reale:
 	Real-time Drawing and Editing	Disegno e modifica in tempo reale
 	Rearrange All Artboards	Ridisponi tutte le tavole da disegno
+	Rearrange	Ridisponi
+	Select All Artboards	Seleziona tutte le tavole da disegno
+	Switch Orientation	Cambia orientamento
 	Rearrange All	Ridisponi tutto
 	Layout Order:	Ordine del layout:
 	Change to Left-to-Right Layout	Passa al layout da sinistra a destra
@@ -4722,6 +4726,7 @@ axis	Both	Entrambi
 @msg	an image whose data is cut short was left out	un'immagine con dati incompleti è stata omessa
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	le immagini collegate mostrano l'anteprima a bassa risoluzione salvata nel file finché i loro file non vengono trovati: ricollegale nel pannello Collegamenti
 @msg	linked type areas past VectorCraft's limits were left out	le aree di testo concatenate oltre i limiti di VectorCraft sono state omesse
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	il testo che cambia direzione di scrittura all’interno di un oggetto di testo si apre nella direzione del suo primo carattere
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	il testo usato come maschera in aree concatenate, testo attorno o un tracciato composto non ritaglia
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	le immagini collegate senza anteprima nel file mostrano un segnaposto finché i loro file non vengono trovati: ricollegale nel pannello Collegamenti
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	il testo in area in cornici troppo basse per una riga del font in cui viene mostrato ha ricevuto cornici più alte ({_1}): altrimenti non sarebbe visibile
diff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsv
index 715f1fc46..8bb101269 100644
--- a/crates/ui-egui/src/i18n/ja.tsv
+++ b/crates/ui-egui/src/i18n/ja.tsv
@@ -1441,6 +1441,7 @@ digits	Malayalam	マラヤーラム数字
 	Duplicate Artboard	アートボードを複製
 	Copy Artboard	アートボードをコピー
 	Cut Artboard	アートボードをカット
+	Rename Artboards	アートボード名を変更
 	Duplicate Artboards	アートボードを複製
 	Duplicate Brush	ブラシを複製
 	Duplicate Character Style	文字スタイルを複製
@@ -2619,6 +2620,9 @@ mark-style	Japanese	日本式
 	Real World:	実寸:
 	Real-time Drawing and Editing	リアルタイム描画および編集
 	Rearrange All Artboards	すべてのアートボードを再配置
+	Rearrange	再配置
+	Select All Artboards	すべてのアートボードを選択
+	Switch Orientation	方向を切り替え
 	Rearrange All	すべて再配置
 	Layout Order:	レイアウト順序:
 	Change to Left-to-Right Layout	左から右のレイアウトに変更
@@ -4409,6 +4413,7 @@ swatch	Bright Violet	ビビッドバイオレット
 @msg	an image whose data is cut short was left out	データが途中で切れている画像は除外されました
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	リンク画像は、元のファイルが見つかるまで、ファイルに保存された低解像度のプレビューで表示されます：リンクパネルで再リンクしてください
 @msg	linked type areas past VectorCraft's limits were left out	VectorCraft の上限を超えるリンクされたテキストエリアは省略されました
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	テキストオブジェクト内で書字方向が変わる文字は、最初の文字の方向で開きます
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	リンクされたエリア、テキストの回り込み、複合パス内でマスクとして使われた文字はクリップしません
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	ファイルにプレビューのないリンク画像は、元のファイルが見つかるまでプレースホルダーで表示されます：リンクパネルで再リンクしてください
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	表示に使われるフォントの 1 行に対して低すぎるフレーム内のエリア内文字は、フレームを高くしました ({_1}): そうしないと文字が表示されません
diff --git a/crates/ui-egui/src/i18n/ka.tsv b/crates/ui-egui/src/i18n/ka.tsv
index 2c8075173..343b415a4 100644
--- a/crates/ui-egui/src/i18n/ka.tsv
+++ b/crates/ui-egui/src/i18n/ka.tsv
@@ -1666,6 +1666,9 @@ digits	Malayalam	მალაიალამური
 	More Paragraph options	აბზაცის სხვა პარამეტრები
 	No document open	დოკუმენტი გახსნილი არ არის
 	Quick Actions	სწრაფი მოქმედებები
+	Rearrange	გადალაგება
+	Select All Artboards	ყველა სამუშაო დაფის მონიშვნა
+	Switch Orientation	ორიენტაციის გადართვა
 	Rearrange All	ყველას გადალაგება
 	Rulers & Grids	სახაზავები და ბადეები
 	Select a text object	მონიშნეთ ტექსტური ობიექტი
@@ -3047,6 +3050,7 @@ theme	Appearance	იერსახე
 	Character / Paragraph	სიმბოლო / აბზაცი
 	Copy Artboard	სამუშაო დაფის კოპირება
 	Cut Artboard	სამუშაო დაფის ამოჭრა
+	Rename Artboards	სამუშაო დაფების სახელის შეცვლა
 	Move Artboard Up/Down	სამუშაო დაფის აწევა/ჩამოწევა
 	Add Anchor (Pen)	საყრდენი წერტილის დამატება (კალამი)
 	Add Anchor Point	საყრდენი წერტილის დამატება
@@ -4783,6 +4787,7 @@ font-technology	Variable	ცვლადი
 	Stacked	დასტად
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	დაკავშირებული გამოსახულებები ფაილში შენახულ დაბალი გარჩევადობის მინიატურას აჩვენებს, სანამ მათი ფაილები არ მოიძებნება: დაუკავშირეთ ისინი ხელახლა ბმულების პანელში
 @msg	linked type areas past VectorCraft's limits were left out	VectorCraft-ის ლიმიტების მიღმა დაკავშირებული ტექსტის არეები გამოტოვებულია
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	ტექსტი, რომელიც ტექსტური ობიექტის შიგნით ცვლის წერის მიმართულებას, იხსნება მისი პირველი სიმბოლოს მიმართულებით
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	დაკავშირებულ არეებში, გარსშემოვლებულ ტექსტში ან შედგენილ ტრაექტორიაში ნიღბად გამოყენებული ტექსტი არ ჭრის
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	დაკავშირებული გამოსახულებები, რომელთა მინიატურაც ფაილში არ არის, ადგილის შემნახველს აჩვენებს, სანამ მათი ფაილები არ მოიძებნება: დაუკავშირეთ ისინი ხელახლა ბმულების პანელში
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	არის ტექსტს ჩარჩოებში, რომლებიც მისი შრიფტის ერთი სტრიქონისთვის ზედმეტად დაბალი იყო, ჩარჩოები გაეზარდა ({_1}): სხვაგვარად ტექსტი არ გამოჩნდებოდა
diff --git a/crates/ui-egui/src/i18n/ko.tsv b/crates/ui-egui/src/i18n/ko.tsv
index 01c96a738..f4cc45b82 100644
--- a/crates/ui-egui/src/i18n/ko.tsv
+++ b/crates/ui-egui/src/i18n/ko.tsv
@@ -1431,6 +1431,7 @@ digits	Malayalam	말라얄람어
 	Duplicate Artboard	아트보드 복제
 	Copy Artboard	아트보드 복사
 	Cut Artboard	아트보드 잘라내기
+	Rename Artboards	아트보드 이름 바꾸기
 	Duplicate Artboards	아트보드 복제
 	Duplicate Brush	브러시 복제
 	Duplicate Character Style	문자 스타일 복제
@@ -2609,6 +2610,9 @@ mark-style	Japanese	일본식
 	Real World:	실제 크기:
 	Real-time Drawing and Editing	실시간 그리기 및 편집
 	Rearrange All Artboards	모든 아트보드 재정렬
+	Rearrange	재정렬
+	Select All Artboards	모든 아트보드 선택
+	Switch Orientation	방향 전환
 	Rearrange All	모두 재정렬
 	Layout Order:	배치 순서:
 	Change to Left-to-Right Layout	왼쪽에서 오른쪽 배치로 변경
@@ -4336,6 +4340,7 @@ theme	Appearance	외관
 @msg	an image whose data is cut short was left out	데이터가 잘린 이미지는 제외했습니다
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	연결된 그림은 해당 파일을 찾을 때까지 파일에 저장된 저해상도 미리 보기로 표시됩니다: 링크 패널에서 다시 연결하세요
 @msg	linked type areas past VectorCraft's limits were left out	VectorCraft 한도를 넘는 연결된 문자 영역은 제외되었습니다
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	문자 개체 안에서 쓰기 방향이 바뀌는 문자는 첫 글자의 방향으로 열립니다
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	연결된 영역, 문자 감싸기 또는 컴파운드 패스에서 마스크로 사용된 문자는 클리핑하지 않습니다
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	파일에 미리 보기가 없는 연결된 그림은 해당 파일을 찾을 때까지 자리 표시자로 표시됩니다: 링크 패널에서 다시 연결하세요
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	표시되는 글꼴의 한 줄보다 낮은 프레임의 영역 문자는 프레임을 더 높였습니다({_1}). 그렇지 않으면 문자가 표시되지 않습니다
diff --git a/crates/ui-egui/src/i18n/nl.tsv b/crates/ui-egui/src/i18n/nl.tsv
index fe34d035d..2e8d6f34c 100644
--- a/crates/ui-egui/src/i18n/nl.tsv
+++ b/crates/ui-egui/src/i18n/nl.tsv
@@ -1770,6 +1770,9 @@ digits	Malayalam	Malayalam
 	More Paragraph options	Meer alineaopties
 	No document open	Geen document geopend
 	Quick Actions	Snelle acties
+	Rearrange	Herschikken
+	Select All Artboards	Alle tekengebieden selecteren
+	Switch Orientation	Stand wisselen
 	Rearrange All	Alles herschikken
 	Rulers & Grids	Linialen & rasters
 	Select a text object	Selecteer een tekstobject
@@ -3241,6 +3244,7 @@ theme	Appearance	Vormgeving
 	Character / Paragraph	Teken / alinea
 	Copy Artboard	Tekenbord kopiëren
 	Cut Artboard	Tekenbord knippen
+	Rename Artboards	Tekengebieden hernoemen
 	Move Artboard Up/Down	Tekenbord omhoog/omlaag verplaatsen
 	Add Anchor (Pen)	Anker toevoegen (Pen)
 	Add Anchor Point	Ankerpunt toevoegen
@@ -4626,6 +4630,7 @@ imageTrace	Outline	Contour
 @msg	an image whose data is cut short was left out	een afbeelding waarvan de gegevens zijn afgekapt, is weggelaten
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	gekoppelde afbeeldingen tonen het in het bestand opgeslagen voorbeeld met lage resolutie totdat hun bestanden zijn gevonden: koppel ze opnieuw in het paneel Koppelingen
 @msg	linked type areas past VectorCraft's limits were left out	gekoppelde tekstvlakken buiten de limieten van VectorCraft zijn weggelaten
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	tekst die binnen een tekstobject van schrijfrichting verandert, wordt geopend in de richting van het eerste teken
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	tekst die als masker wordt gebruikt in gekoppelde vlakken, tekstomloop of een samengesteld pad knipt niet uit
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	gekoppelde afbeeldingen zonder voorbeeld in het bestand tonen een tijdelijke aanduiding totdat hun bestanden zijn gevonden: koppel ze opnieuw in het paneel Koppelingen
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	vlaktekst in kaders die te kort zijn voor één regel van het lettertype waarin de tekst wordt weergegeven, heeft hogere kaders gekregen ({_1}): anders zou de tekst niet zichtbaar zijn
diff --git a/crates/ui-egui/src/i18n/pl.tsv b/crates/ui-egui/src/i18n/pl.tsv
index 6bb9ee44c..c9e1256c3 100644
--- a/crates/ui-egui/src/i18n/pl.tsv
+++ b/crates/ui-egui/src/i18n/pl.tsv
@@ -1869,6 +1869,9 @@ digits	Malayalam	Malajalam
 	More Paragraph options	Więcej opcji akapitu
 	No document open	Brak otwartego dokumentu
 	Quick Actions	Szybkie operacje
+	Rearrange	Przestaw
+	Select All Artboards	Zaznacz wszystkie obszary kompozycji
+	Switch Orientation	Przełącz orientację
 	Rearrange All	Przestaw wszystkie
 	Rulers & Grids	Linijki i siatki
 	Select a text object	Zaznacz obiekt tekstowy
@@ -3364,6 +3367,7 @@ theme	Appearance	Wygląd
 	Character / Paragraph	Znak / akapit
 	Copy Artboard	Kopiuj obszar kompozycji
 	Cut Artboard	Wytnij obszar kompozycji
+	Rename Artboards	Zmień nazwy obszarów kompozycji
 	Move Artboard Up/Down	Przesuń obszar kompozycji w górę/dół
 	Add Anchor (Pen)	Dodaj punkt (pióro)
 	Add Anchor Point	Dodaj punkt kontrolny
@@ -4812,6 +4816,7 @@ imageTrace	Outline	Kontur
 @msg	an image whose data is cut short was left out	pominięto obraz z uciętymi danymi
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	połączone obrazy pokazują zapisany w pliku podgląd niskiej rozdzielczości, dopóki ich pliki nie zostaną znalezione: połącz je ponownie w panelu Łącza
 @msg	linked type areas past VectorCraft's limits were left out	połączone obszary tekstu poza limitami VectorCraft zostały pominięte
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	tekst zmieniający kierunek pisania wewnątrz obiektu tekstowego otwiera się w kierunku swojego pierwszego znaku
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	tekst użyty jako maska w połączonych obszarach, oblewanym tekście lub ścieżce złożonej nie przycina
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	połączone obrazy bez podglądu w pliku pokazują symbol zastępczy, dopóki ich pliki nie zostaną znalezione: połącz je ponownie w panelu Łącza
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	tekst akapitowy w ramkach niższych niż wiersz wyświetlanej czcionki otrzymał wyższe ramki ({_1}): inaczej tekst nie byłby widoczny
diff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsv
index cbdda2921..062b7d88b 100644
--- a/crates/ui-egui/src/i18n/pt-br.tsv
+++ b/crates/ui-egui/src/i18n/pt-br.tsv
@@ -790,6 +790,7 @@
 	Duplicate Artboard	Duplicar Mesa de Trabalho
 	Copy Artboard	Copiar Mesa de Trabalho
 	Cut Artboard	Recortar Mesa de Trabalho
+	Rename Artboards	Renomear Mesas de Trabalho
 	Duplicate Artboards	Duplicar Mesas de Trabalho
 	Duplicate Brush	Duplicar Pincel
 	Duplicate Character Style	Duplicar Estilo de Caractere
@@ -2139,6 +2140,9 @@ digits	Malayalam	Malaiala
 	Real World:	Mundo Real:
 	Real-time Drawing and Editing	Desenho e Edição em Tempo Real
 	Rearrange All Artboards	Reorganizar Todas as Mesas de Trabalho
+	Rearrange	Reorganizar
+	Select All Artboards	Selecionar Todas as Mesas de Trabalho
+	Switch Orientation	Trocar Orientação
 	Rearrange All	Reorganizar Tudo
 	Layout Order:	Ordem do Layout:
 	Change to Left-to-Right Layout	Mudar para Layout da Esquerda para a Direita
@@ -4906,6 +4910,7 @@ axis	Both	Ambos
 @msg	{path}: not a file	{path}: não é um arquivo
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	as imagens vinculadas mostram a visualização de baixa resolução salva no arquivo até que seus arquivos sejam encontrados: revincule-as no painel Links
 @msg	linked type areas past VectorCraft's limits were left out	as áreas de texto encadeadas além dos limites do VectorCraft foram omitidas
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	o texto que muda de direção de escrita dentro de um objeto de texto abre na direção do primeiro caractere
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	o texto usado como máscara em áreas encadeadas, texto com quebra ou um caminho composto não recorta
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	as imagens vinculadas sem visualização no arquivo mostram um espaço reservado até que seus arquivos sejam encontrados: revincule-as no painel Links
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	o texto de área em molduras baixas demais para uma linha da fonte em que aparece recebeu molduras mais altas ({_1}): senão o texto não apareceria
diff --git a/crates/ui-egui/src/i18n/ru.tsv b/crates/ui-egui/src/i18n/ru.tsv
index df48bf8ab..a83d9edf3 100644
--- a/crates/ui-egui/src/i18n/ru.tsv
+++ b/crates/ui-egui/src/i18n/ru.tsv
@@ -885,6 +885,7 @@ font-technology	Variable	Вариативные
 	Duplicate Artboard	Дублировать монтажную область
 	Copy Artboard	Копировать монтажную область
 	Cut Artboard	Вырезать монтажную область
+	Rename Artboards	Переименовать монтажные области
 	Duplicate Artboards	Дублировать монтажные области
 	Duplicate Brush	Дублировать кисть
 	Duplicate Character Style	Дублировать стиль символа
@@ -2600,6 +2601,9 @@ digits	Malayalam	Малаялам
 	Real World:	Реальный мир:
 	Real-time Drawing and Editing	Рисование и редактирование в реальном времени
 	Rearrange All Artboards	Переставить все монтажные области
+	Rearrange	Переставить
+	Select All Artboards	Выделить все монтажные области
+	Switch Orientation	Переключить ориентацию
 	Rearrange All	Переставить все
 	Layout Order:	Порядок макета:
 	Change to Left-to-Right Layout	Переключить на макет слева направо
@@ -4717,6 +4721,7 @@ axis	Both	Оба
 @msg	an image whose data is cut short was left out	изображение с обрезанными данными пропущено
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	связанные изображения показываются как сохранённый в файле просмотр низкого разрешения, пока их файлы не найдены: восстановите связи на панели «Связи»
 @msg	linked type areas past VectorCraft's limits were left out	связанные текстовые области за пределами ограничений VectorCraft пропущены
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	текст, меняющий направление письма внутри текстового объекта, открывается в направлении своего первого символа
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	текст, используемый как маска в связанных областях, обтекающем тексте или составном контуре, не обрезает
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	связанные изображения без просмотра в файле показываются как заполнитель, пока их файлы не найдены: восстановите связи на панели «Связи»
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	текст в области в рамках, слишком низких для строки шрифта, которым он отображается, получил более высокие рамки ({_1}): иначе он не был бы виден
diff --git a/crates/ui-egui/src/i18n/sv.tsv b/crates/ui-egui/src/i18n/sv.tsv
index 26fc08841..780d23bea 100644
--- a/crates/ui-egui/src/i18n/sv.tsv
+++ b/crates/ui-egui/src/i18n/sv.tsv
@@ -874,6 +874,7 @@ font-technology	Variable	Variabla
 	Duplicate Artboard	Duplicera rityta
 	Copy Artboard	Kopiera rityta
 	Cut Artboard	Klipp ut rityta
+	Rename Artboards	Byt namn på ritytor
 	Duplicate Artboards	Duplicera ritytor
 	Duplicate Brush	Duplicera pensel
 	Duplicate Character Style	Duplicera teckenstil
@@ -2509,6 +2510,9 @@ digits	Malayalam	Malayalam
 	Real World:	Verkligt mått:
 	Real-time Drawing and Editing	Ritning och redigering i realtid
 	Rearrange All Artboards	Ordna om alla ritytor
+	Rearrange	Ordna om
+	Select All Artboards	Markera alla ritytor
+	Switch Orientation	Byt orientering
 	Rearrange All	Ordna om alla
 	Layout Order:	Layoutordning:
 	Change to Left-to-Right Layout	Byt till layout vänster till höger
@@ -4579,6 +4583,7 @@ axis	Both	Båda
 @msg	an image whose data is cut short was left out	en bild med avkortade data utelämnades
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	länkade bilder visar förhandsgranskningen med låg upplösning som sparats i filen tills deras filer hittas: länka om dem i panelen Länkar
 @msg	linked type areas past VectorCraft's limits were left out	länkade textområden utöver VectorCrafts gränser utelämnades
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	text som byter skrivriktning inuti ett textobjekt öppnas i riktningen för sitt första tecken
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	text som används som mask i länkade områden, ombruten text eller en sammansatt bana beskär inte
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	länkade bilder utan förhandsgranskning i filen visar en platshållare tills deras filer hittas: länka om dem i panelen Länkar
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	områdestext i ramar som var för låga för en rad i det typsnitt den visas med fick högre ramar ({_1}): annars skulle texten inte synas
diff --git a/crates/ui-egui/src/i18n/tr.tsv b/crates/ui-egui/src/i18n/tr.tsv
index c296f66aa..55a9cdc73 100644
--- a/crates/ui-egui/src/i18n/tr.tsv
+++ b/crates/ui-egui/src/i18n/tr.tsv
@@ -866,6 +866,7 @@ font-technology	Variable	Değişken
 	Duplicate Artboard	Çalışma Yüzeyini Çoğalt
 	Copy Artboard	Çalışma Yüzeyini Kopyala
 	Cut Artboard	Çalışma Yüzeyini Kes
+	Rename Artboards	Çalışma Yüzeylerini Yeniden Adlandır
 	Duplicate Artboards	Çalışma Yüzeylerini Çoğalt
 	Duplicate Brush	Yinelenen Fırça
 	Duplicate Character Style	Yinelenen Karakter Stili
@@ -2382,6 +2383,9 @@ digits	Malayalam	Malayalam
 	Real World:	Gerçek Dünya:
 	Real-time Drawing and Editing	Gerçek Zamanlı Çizim ve Düzenleme
 	Rearrange All Artboards	Tüm Çalışma Yüzeylerini Yeniden Düzenleme
+	Rearrange	Yeniden Düzenle
+	Select All Artboards	Tüm Çalışma Yüzeylerini Seç
+	Switch Orientation	Yönü Değiştir
 	Rearrange All	Tümünü Yeniden Düzenle
 	Layout Order:	Yerleşim Sırası:
 	Change to Left-to-Right Layout	Soldan Sağa Düzene Geç
@@ -4414,6 +4418,7 @@ axis	Both	Her İkisi
 @msg	an image whose data is cut short was left out	verileri kısa kesilen bir resim dışarıda bırakıldı
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	bağlantılı resimler, dosyaları bulunana kadar dosyaya kaydedilen düşük çözünürlüklü önizlemeyi gösterir: bunları Bağlantılar panelinde yeniden bağlayın
 @msg	linked type areas past VectorCraft's limits were left out	VectorCraft sınırlarını aşan bağlantılı metin alanları dışarıda bırakıldı
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	bir metin nesnesi içinde yazı yönünü değiştiren metin, ilk karakterinin yönünde açılır
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	bağlantılı alanlarda, kaydırılan metinde veya bileşik yolda maske olarak kullanılan metin kırpmaz
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	dosyada önizlemesi olmayan bağlantılı resimler, dosyaları bulunana kadar bir yer tutucu gösterir: bunları Bağlantılar panelinde yeniden bağlayın
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	çerçevelerdeki alan türü, daha uzun çerçevelerde gösterdiği yazı tipinin bir satırı için çok kısa ({_1}): bunların türü aksi halde gösterilmez
diff --git a/crates/ui-egui/src/i18n/uk.tsv b/crates/ui-egui/src/i18n/uk.tsv
index 5f823ba12..bbfc332f9 100644
--- a/crates/ui-egui/src/i18n/uk.tsv
+++ b/crates/ui-egui/src/i18n/uk.tsv
@@ -881,6 +881,7 @@ font-technology	Variable	Варіативні
 	Duplicate Artboard	Дублювати монтажну область
 	Copy Artboard	Копіювати монтажну область
 	Cut Artboard	Вирізати монтажну область
+	Rename Artboards	Перейменувати монтажні області
 	Duplicate Artboards	Дублювати монтажні області
 	Duplicate Brush	Дублювати пензель
 	Duplicate Character Style	Дублювати стиль символу
@@ -2597,6 +2598,9 @@ digits	Malayalam	Малаялам
 	Real World:	Реальний світ:
 	Real-time Drawing and Editing	Малювання та редагування у реальному часі
 	Rearrange All Artboards	Переставити всі монтажні області
+	Rearrange	Переставити
+	Select All Artboards	Виділити всі монтажні області
+	Switch Orientation	Переключити орієнтацію
 	Rearrange All	Переставити все
 	Layout Order:	Порядок макету:
 	Change to Left-to-Right Layout	Переключити на макет зліва направо
@@ -4706,6 +4710,7 @@ axis	Both	Обидві
 @msg	an image whose data is cut short was left out	зображення з обрізаними даними пропущено
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	пов’язані зображення показуються як збережений у файлі перегляд низької роздільності, доки їхні файли не знайдено: відновіть зв’язки на панелі «Зв’язки»
 @msg	linked type areas past VectorCraft's limits were left out	пов’язані текстові області понад обмеження VectorCraft пропущено
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	текст, що змінює напрямок письма всередині текстового об’єкта, відкривається в напрямку свого першого символу
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	текст, використаний як маска у пов’язаних областях, тексті з обтіканням або складеному контурі, не обрізає
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	пов’язані зображення без перегляду у файлі показуються як заповнювач, доки їхні файли не знайдено: відновіть зв’язки на панелі «Зв’язки»
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	текст в області в рамках, занизьких для рядка шрифту, яким він показується, отримав вищі рамки ({_1}): інакше його не було б видно
diff --git a/crates/ui-egui/src/i18n/vi.tsv b/crates/ui-egui/src/i18n/vi.tsv
index 7d157502c..47915fb17 100644
--- a/crates/ui-egui/src/i18n/vi.tsv
+++ b/crates/ui-egui/src/i18n/vi.tsv
@@ -799,6 +799,7 @@ font-technology	Variable	Biến thiên
 	Customize…	Tùy chỉnh…
 	Cut	Cắt
 	Cut Artboard	Cắt bảng vẽ
+	Rename Artboards	Đổi tên các bảng vẽ
 	Cut Path	Cắt đường dẫn
 	Cut Path at Selected Anchor Points	Cắt đường dẫn tại các điểm neo đã chọn
 	Cyan	Xanh lơ
@@ -2894,6 +2895,9 @@ mark-style	Japanese	Kiểu Nhật
 	Real name	Tên thật
 	Real World:	Thực tế:
 	Real-time Drawing and Editing	Vẽ và chỉnh sửa theo thời gian thực
+	Rearrange	Sắp xếp lại
+	Select All Artboards	Chọn tất cả các bảng vẽ
+	Switch Orientation	Chuyển hướng
 	Rearrange All	Sắp xếp lại tất cả
 	Rearrange All Artboards	Sắp xếp lại tất cả bảng vẽ
 	Rearrange All Artboards…	Sắp xếp lại tất cả bảng vẽ…
@@ -4538,6 +4542,7 @@ theme	Appearance	Giao diện
 @msg	line {line}: value for `{var}` is longer than {MAX_GRAPH_CSV} bytes	dòng {line}: giá trị của `{var}` dài hơn {MAX_GRAPH_CSV} byte
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	ảnh liên kết hiển thị bản xem trước độ phân giải thấp đã lưu trong tệp cho đến khi tìm thấy tệp gốc: liên kết lại trong bảng Liên kết
 @msg	linked type areas past VectorCraft's limits were left out	các vùng chữ liên kết vượt quá giới hạn của VectorCraft đã bị bỏ qua
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	chữ đổi hướng viết bên trong một đối tượng văn bản sẽ mở theo hướng của ký tự đầu tiên
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	chữ dùng làm mặt nạ trong các vùng liên kết, chữ bao quanh hoặc đường dẫn phức không cắt xén
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	ảnh liên kết không có bản xem trước trong tệp hiển thị ô giữ chỗ cho đến khi tìm thấy tệp gốc: liên kết lại trong bảng Liên kết
 @msg	Live Paint Merge: select a Live Paint group and the paths to add	Hợp nhất tô trực tiếp: chọn nhóm tô trực tiếp và các đường dẫn để thêm
diff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsv
index 643b92218..e646c956b 100644
--- a/crates/ui-egui/src/i18n/zh-hans.tsv
+++ b/crates/ui-egui/src/i18n/zh-hans.tsv
@@ -829,6 +829,7 @@
 	Duplicate Artboard	复制画板
 	Copy Artboard	拷贝画板
 	Cut Artboard	剪切画板
+	Rename Artboards	重命名画板
 	Duplicate Artboards	复制画板
 	Duplicate Brush	复制画笔
 	Duplicate Character Style	制作字符样式副本
@@ -2478,6 +2479,9 @@ digits	Malayalam	马拉雅拉姆数字
 	Real World:	真实世界：
 	Real-time Drawing and Editing	实时绘图和编辑
 	Rearrange All Artboards	重新排列所有画板
+	Rearrange	重新排列
+	Select All Artboards	选择所有画板
+	Switch Orientation	切换方向
 	Rearrange All	全部重新排列
 	Layout Order:	布局顺序：
 	Change to Left-to-Right Layout	更改为由左至右版面配置
@@ -3469,6 +3473,7 @@ digits	Malayalam	马拉雅拉姆数字
 @plural	{n} linked image changed on disk. Show the new version?|{n} linked images changed on disk. Show the new versions?	有 {n} 个链接图像已在磁盘上更改。要显示新版本吗？
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	链接的图片在找到其文件之前显示文件中存储的低分辨率预览：请在“链接”面板中重新链接
 @msg	linked type areas past VectorCraft's limits were left out	超出 VectorCraft 限制的串接文字区域已省略
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	在文字对象内更改书写方向的文字按其第一个字符的方向打开
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	在串接区域、绕排文字或复合路径中用作蒙版的文字不会剪切
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	文件中没有预览的链接图片在找到其文件之前显示占位符：请在“链接”面板中重新链接
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	框架高度不足以容纳所显示字体一行的区域文字已加高框架 ({_1})：否则文字不会显示
diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsv
index 945626915..468ad851a 100644
--- a/crates/ui-egui/src/i18n/zh-hant.tsv
+++ b/crates/ui-egui/src/i18n/zh-hant.tsv
@@ -849,6 +849,7 @@ font-technology	Variable	可變
 	Duplicate Artboard	製作工作區域複本
 	Copy Artboard	複製工作區域
 	Cut Artboard	剪下工作區域
+	Rename Artboards	重新命名工作區域
 	Duplicate Artboards	製作工作區域複本
 	Duplicate Brush	製作筆刷複本
 	Duplicate Character Style	製作字元樣式複本
@@ -3467,6 +3468,9 @@ digits	Malayalam	馬來亞拉姆數字
 	Real World:	真實世界：
 	Real-time Drawing and Editing	即時繪圖與編輯
 	Rearrange All Artboards	重新排列所有工作區域
+	Rearrange	重新排列
+	Select All Artboards	選取所有工作區域
+	Switch Orientation	切換方向
 	Rearrange All	全部重新排列
 	Layout Order:	版面配置順序：
 	Change to Left-to-Right Layout	變更為由左至右版面配置
@@ -4499,6 +4503,7 @@ digits	Malayalam	馬來亞拉姆數字
 @plural	{n} linked image changed on disk. Show the new version?|{n} linked images changed on disk. Show the new versions?	有 {n} 個連結影像已在磁碟上變更。要顯示新版本嗎？
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	連結的圖片在找到其檔案之前顯示檔案中儲存的低解析度預覽：請在「連結」面板中重新連結
 @msg	linked type areas past VectorCraft's limits were left out	超出 VectorCraft 限制的串連文字區域已略過
+@msg	type that changes writing direction inside a text object opens in the direction of its first character	在文字物件內變更書寫方向的文字會依其第一個字元的方向開啟
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	在串連區域、繞圖文字或複合路徑中用作遮色片的文字不會剪裁
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	檔案中沒有預覽的連結圖片在找到其檔案之前顯示預留位置：請在「連結」面板中重新連結
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	框架高度不足以容納所顯示字體一行的區域文字已加高框架 ({_1})：否則文字不會顯示
diff --git a/crates/ui-egui/src/io.rs b/crates/ui-egui/src/io.rs
index 4818a0c15..d1e34e38b 100644
--- a/crates/ui-egui/src/io.rs
+++ b/crates/ui-egui/src/io.rs
@@ -28,7 +28,7 @@ pub use open::{
 };
 #[cfg(test)]
 pub(crate) use open::{open_file, opened_with_notes};
-pub use save::{ask_format_options, ask_pdf_options, remember_view, save, save_pdf};
+pub use save::{ask_format_options, ask_pdf_options, remember_active_artboard, remember_view, save, save_pdf};
 pub(crate) use save::{export_path, is_web, report_saved, target_path, write_named, write_reporting, write_to};
 #[cfg(test)]
 pub(crate) use save::{report_write_error, saved_status};
@@ -164,6 +164,76 @@ mod tests {
         assert!(!app.session.doc().unwrap().is_dirty());
     }
 
+    /// A `.ai` file saved from the app names the view's active artboard as its active one, in
+    /// the editing copy other apps read.
+    #[test]
+    fn a_saved_ai_file_names_the_views_active_artboard() {
+        let (mut app, written) = app();
+        app.run("file.new", json!({"width": 60, "height": 40, "artboards": 3})).unwrap();
+        app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+        app.sync_views();
+        let opts = fileio::LoadOptions { native: false, ..Default::default() };
+        for artboard in [2, 0] {
+            if let Some(v) = app.view_mut() {
+                v.artboard = artboard;
+            }
+            save(&mut app, SaveMode::Copy, &json!({"path": "Art.ai"}), false).unwrap();
+            let bytes = written.borrow_mut().pop().map(|(_, b)| b).unwrap();
+            let l = fileio::load_with("Art.ai", &bytes, &opts).unwrap();
+            assert!(l.editing_data && !l.restored, "{:?}", l.warnings);
+            let active = l.doc.opened_artboard.and_then(|id| l.doc.artboards.iter().position(|a| a.id == id)).unwrap_or(0);
+            assert_eq!(active, artboard);
+        }
+    }
+
+    /// A `.ai` file a command exports names the view's active artboard as its active one: an
+    /// index past the last artboard names the last, as the Artboards panel shows it.
+    #[test]
+    fn an_exported_ai_file_names_the_views_active_artboard() {
+        let (mut app, _) = app();
+        app.run("file.new", json!({"width": 60, "height": 40, "artboards": 3})).unwrap();
+        app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+        app.sync_views();
+        let opts = fileio::LoadOptions { native: false, ..Default::default() };
+        for (artboard, active) in [(1, 1), (99, 2)] {
+            if let Some(v) = app.view_mut() {
+                v.artboard = artboard;
+            }
+            let out = app.run("document.serialize", json!({"format": "ai"})).unwrap();
+            let bytes = vectorcraft_format::base64_decode(out["dataBase64"].as_str().unwrap()).unwrap();
+            let l = fileio::load_with("Art.ai", &bytes, &opts).unwrap();
+            assert!(l.editing_data && !l.restored, "{:?}", l.warnings);
+            assert_eq!(l.doc.opened_artboard.and_then(|id| l.doc.artboards.iter().position(|a| a.id == id)), Some(active), "{artboard}");
+        }
+    }
+
+    /// A `.ai` file exported to a path (File › Export As, its dialog, a control request) names the
+    /// view's active artboard as its active one, and the open document is unchanged.
+    #[test]
+    fn an_ai_file_exported_to_a_path_names_the_views_active_artboard() {
+        let (mut app, written) = app();
+        app.run("file.new", json!({"width": 60, "height": 40, "artboards": 3})).unwrap();
+        app.sync_views();
+        app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+        let opts = fileio::LoadOptions { native: false, ..Default::default() };
+        let active = |app: &VectorcraftApp| {
+            let bytes = written.borrow_mut().pop().map(|(_, b)| b).unwrap();
+            let l = fileio::load_with("Art.ai", &bytes, &opts).unwrap();
+            assert!(l.editing_data && !l.restored, "{:?}", l.warnings);
+            assert_eq!(app.session.doc().unwrap().doc.opened_artboard, None, "the document is unchanged");
+            l.doc.opened_artboard.and_then(|id| l.doc.artboards.iter().position(|a| a.id == id))
+        };
+        for artboard in [2, 1] {
+            if let Some(v) = app.view_mut() {
+                v.artboard = artboard;
+            }
+            app.run("file.exportAs", json!({"format": "ai", "path": "Art.ai"})).unwrap();
+            assert_eq!(active(&app), Some(artboard), "File › Export As");
+            export(&mut app, Some("ai"), Some("Art.ai".into()), &json!({})).unwrap();
+            assert_eq!(active(&app), Some(artboard), "the Export As dialog");
+        }
+    }
+
     fn bytes_of(app: &mut VectorcraftApp, cmd: &str, p: Value) -> Vec<u8> {
         let v = app.session.execute(cmd, &p).unwrap();
         vectorcraft_format::base64_decode(v["dataBase64"].as_str().unwrap()).unwrap()
diff --git a/crates/ui-egui/src/io/export.rs b/crates/ui-egui/src/io/export.rs
index f32323151..1b438adf9 100644
--- a/crates/ui-egui/src/io/export.rs
+++ b/crates/ui-egui/src/io/export.rs
@@ -1,6 +1,6 @@
 use super::save::{
-    ask_before_losing, export_path, is_web, report_saved, report_write_error, saved_status, target_path, target_path_keeping, view_file,
-    write_encoded, write_named, write_reporting,
+    ask_before_losing, export_path, is_web, remember_active_artboard, report_saved, report_write_error, saved_status, target_path,
+    target_path_keeping, view_file, write_encoded, write_named, write_reporting,
 };
 use super::{EngineError, Progress, Value, VectorcraftApp, Writer, background, cancel, fileio, json, progress};
 
@@ -33,8 +33,10 @@ pub fn export(app: &mut VectorcraftApp, format: Option<&str>, path: Option<Strin
     // encoder (an exporter plug-in is told the file it writes).
     let params = &if params.is_object() { params.clone() } else { json!({}) };
     let f = fileio::writable_format(format, path.as_deref())?;
+    // A `.ai` file names the view's active artboard.
+    remember_active_artboard(app);
     let st = app.session.active().ok_or("no document")?;
-    let doc = match fileio::export_source(st, params).map_err(|e| e.to_string())? {
+    let doc = match fileio::export_doc(st, f, params).map_err(|e| e.to_string())? {
         std::borrow::Cow::Borrowed(_) => st.doc.clone(),
         std::borrow::Cow::Owned(d) => std::sync::Arc::new(d),
     };
diff --git a/crates/ui-egui/src/io/save.rs b/crates/ui-egui/src/io/save.rs
index 3392e7e43..98e52a2c3 100644
--- a/crates/ui-egui/src/io/save.rs
+++ b/crates/ui-egui/src/io/save.rs
@@ -171,14 +171,30 @@ pub(super) fn target_path_keeping(
     pick_path(app, &FilePick { name, folder, filters }, keeps)
 }
 
-/// Keep the active document's saved view current before a save (native files reopen at it).
+/// Keep the active document's saved view current before a save (native files reopen at it), and
+/// each document's active artboard ([`remember_active_artboard`]).
 pub fn remember_view(app: &mut VectorcraftApp) {
+    remember_active_artboard(app);
     let Some(v) = app.view().copied().filter(|v| v.fitted) else { return };
     if let Some(st) = app.session.active_mut() {
         st.view = Some(SavedView { name: String::new(), center: v.center, zoom: v.zoom, rotation: v.rotation });
     }
 }
 
+/// Keep every open document's active artboard current (a `.ai` file saved or exported names it as
+/// its active one, also in Export All Open Documents): its own view's, an index past the last
+/// artboard being the last one as in the Artboards panel; `None` without a view.
+pub fn remember_active_artboard(app: &mut VectorcraftApp) {
+    let uids: Vec<u64> = app.session.documents().iter().map(|d| d.uid).collect();
+    for uid in uids {
+        let index = app.view_uids.iter().position(|u| *u == uid).and_then(|k| app.views.get(k)).map(|v| v.artboard);
+        if let Some(st) = app.session.document_mut(uid) {
+            let last = st.doc.artboards.len().saturating_sub(1);
+            st.active_artboard = index.and_then(|i| st.doc.artboards.get(i.min(last))).map(|a| a.id);
+        }
+    }
+}
+
 /// A path typed in a save panel: kept when its extension names one of the panel's file types (a
 /// save format, or a template format for Save as Template, `mode`). An extension that names
 /// another format (`card.png`, or `card.ait` in Save As) is replaced with `f`'s, and `f`'s is
diff --git a/crates/ui-egui/src/menus/context.rs b/crates/ui-egui/src/menus/context.rs
index 3af95c607..bc191593a 100644
--- a/crates/ui-egui/src/menus/context.rs
+++ b/crates/ui-egui/src/menus/context.rs
@@ -8,6 +8,9 @@ use super::{Item, Sep, Value, VectorcraftApp, c, cp, json, sub, widgets};
 pub fn context_items(app: &VectorcraftApp) -> Vec<Item> {
     use vectorcraft_doc::NodeKind;
     let Some(st) = app.session.active() else { return vec![] };
+    if app.session.tool_id() == "artboard" {
+        return prune(app, artboard_items(app));
+    }
     let roots: Vec<&vectorcraft_doc::Node> = st.selection.objects.iter().filter_map(|id| st.doc.node(*id)).collect();
     let any = |f: fn(&NodeKind) -> bool| roots.iter().any(|n| f(&n.kind));
     let several = roots.len() >= 2;
@@ -30,40 +33,7 @@ pub fn context_items(app: &VectorcraftApp) -> Vec<Item> {
             Sep,
         ]);
     }
-    // Managing artboards from the canvas: with the Artboard tool, the menu locks and unlocks them
-    // (`artboard.setProps` with `locked` for each artboard named; an entry with none to change is left out).
-    if app.session.tool_id() == "artboard" {
-        let n = st.doc.artboards.len();
-        let sel = crate::panels::artboards::picked(app, n);
-        let others: Vec<usize> = (0..n).filter(|i| !sel.contains(i)).collect();
-        let entry = |label, idx: Vec<usize>, locked: bool| {
-            let list: Vec<Value> = idx.iter().map(|i| json!({ "index": i, "locked": locked })).collect();
-            (!list.is_empty()).then(|| cp(label, "artboard.setProps", json!({ "artboards": list })))
-        };
-        let lock: Vec<Item> =
-            [entry("Lock Selected", sel.clone(), true), entry("Lock All Except Selected", others, true), entry("Lock All", (0..n).collect(), true)]
-                .into_iter()
-                .flatten()
-                .collect();
-        let unlock: Vec<Item> = [entry("Unlock Selected", sel, false), entry("Unlock All", (0..n).collect(), false)].into_iter().flatten().collect();
-        for (label, items) in [("Lock Artboards", lock), ("Unlock Artboards", unlock)] {
-            if !items.is_empty() {
-                v.push(sub(label, items));
-            }
-        }
-        v.push(Sep);
-    }
-    // The locked objects under the pointer at the right-click, each unlocked as the Layers panel's
-    // lock column does. `unlock_item_label` shows each object's name.
-    let unlock: Vec<Item> = app
-        .ui
-        .context_locked
-        .iter()
-        .filter(|(uid, _)| *uid == st.uid)
-        .flat_map(|(_, ids)| ids)
-        .filter(|id| st.doc.node(**id).is_some_and(|n| n.locked))
-        .map(|id| cp("Unlock", "layer.setProps", json!({ "ids": [id.0], "locked": false })))
-        .collect();
+    let unlock = unlock_items(app);
     if !unlock.is_empty() {
         v.extend([sub("Unlock", unlock), Sep]);
     }
@@ -138,6 +108,100 @@ pub fn context_items(app: &VectorcraftApp) -> Vec<Item> {
     prune(app, v)
 }
 
+/// The locked objects under the pointer at the right-click, each unlocked as the Layers panel's
+/// lock column does. `unlock_item_label` shows each object's name.
+fn unlock_items(app: &VectorcraftApp) -> Vec<Item> {
+    let Some(st) = app.session.active() else { return vec![] };
+    app.ui
+        .context_locked
+        .iter()
+        .filter(|(uid, _)| *uid == st.uid)
+        .flat_map(|(_, ids)| ids)
+        .filter(|id| st.doc.node(**id).is_some_and(|n| n.locked))
+        .map(|id| cp("Unlock", "layer.setProps", json!({ "ids": [id.0], "locked": false })))
+        .collect()
+}
+
+/// The canvas context menu with the Artboard tool, in place of the entries for objects and the view: the list and order of the public
+/// [Use the artboard context menu](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/use-artboard-context-menu.html)
+/// page, with the page's Lock Artboards submenu as two, Lock Artboards and Unlock Artboards. `docs/mcp.md`
+/// names the entries that act on the artboards the tool has selected. Exit Isolation Mode and the
+/// Unlock submenu for locked objects under the pointer follow them.
+fn artboard_items(app: &VectorcraftApp) -> Vec<Item> {
+    use crate::panels::artboards as boards;
+    let Some(st) = app.session.active() else { return vec![] };
+    let all = &st.doc.artboards;
+    let n = all.len();
+    let is_locked = |i: &usize| all.get(*i).is_some_and(|a| a.locked);
+    let sel: Vec<usize> = boards::picked(app, n).into_iter().filter(|i| *i < n).collect();
+    let free: Vec<usize> = sel.iter().copied().filter(|i| !is_locked(i)).collect();
+    let facts = boards::open_menu_facts(app);
+    let mut v = vec![];
+    // Cut refuses a locked artboard and every artboard of the document.
+    if !sel.is_empty() && free.len() == sel.len() && sel.len() < n {
+        v.push(c("Cut", "artboard.cut"));
+    }
+    if !sel.is_empty() {
+        v.push(c("Copy", "artboard.copy"));
+    }
+    v.push(match facts {
+        // Copied artboards go to the right-click's point, and so do copied objects.
+        Some(f) => cp("Paste", "edit.paste", json!({ "center": [f.at.x, f.at.y], "artboardsAt": [f.at.x, f.at.y] })),
+        None => c("Paste", "edit.paste"),
+    });
+    v.extend([Sep, c("Undo", "edit.undo"), c("Redo", "edit.redo"), Sep, c("New Artboard", "artboard.new")]);
+    if !sel.is_empty() {
+        v.extend([c("Duplicate Artboards", "artboard.duplicate"), c("Rename", "artboard.rename")]);
+    }
+    let deleted = boards::delete_targets(app, n);
+    if !deleted.is_empty() {
+        v.push(cp("Delete Artboards", "artboard.delete", json!({ "indices": deleted })));
+    }
+    v.extend([c("Delete Empty Artboards", "artboard.deleteEmpty"), Sep]);
+    if sel.len() < n {
+        v.push(c("Select All Artboards", "artboard.selectAll"));
+    }
+    // `artboard.setProps` with `locked` for each artboard it changes; an entry with none is left out.
+    let others: Vec<usize> = (0..n).filter(|i| !sel.contains(i)).collect();
+    let entry = |label, idx: Vec<usize>, locked: bool| {
+        let list: Vec<Value> = idx.iter().filter(|i| is_locked(i) != locked).map(|i| json!({ "index": i, "locked": locked })).collect();
+        (!list.is_empty()).then(|| cp(label, "artboard.setProps", json!({ "artboards": list })))
+    };
+    let lock: Vec<Item> =
+        [entry("Lock Selected", sel.clone(), true), entry("Lock All Except Selected", others, true), entry("Lock All", (0..n).collect(), true)]
+            .into_iter()
+            .flatten()
+            .collect();
+    let unlock: Vec<Item> =
+        [entry("Unlock Selected", sel.clone(), false), entry("Unlock All", (0..n).collect(), false)].into_iter().flatten().collect();
+    for (label, items) in [("Lock Artboards", lock), ("Unlock Artboards", unlock)] {
+        if !items.is_empty() {
+            v.push(sub(label, items));
+        }
+    }
+    v.push(Sep);
+    if n > 1 {
+        v.push(c("Rearrange", "artboard.rearrange"));
+    }
+    if facts.map_or_else(|| boards::fit_has_art(app, &free), |f| f.any_art) {
+        v.push(c("Fit to Artwork Bounds", "artboard.fitToArt"));
+    }
+    if free.iter().filter_map(|i| all.get(*i)).any(|a| (a.rect.width() - a.rect.height()).abs() > 1e-6) {
+        v.push(c("Switch Orientation", "artboard.switchOrientation"));
+    }
+    if !sel.is_empty() {
+        v.extend([cp("Artboard Options", "tool.options", json!({ "tool": "artboard" })), Sep, c("Export", "file.exportForScreens")]);
+    }
+    if st.isolation.is_some() {
+        v.extend([Sep, c("Exit Isolation Mode", "object.exitIsolation")]);
+    }
+    let locked_art = unlock_items(app);
+    if !locked_art.is_empty() {
+        v.extend([Sep, sub("Unlock", locked_art)]);
+    }
+    v
+}
+
 /// `items` without the commands that can't run now (Undo and Redo stay, greyed out), submenus
 /// left empty, and separators that no longer separate anything.
 fn prune(app: &VectorcraftApp, items: Vec<Item>) -> Vec<Item> {
diff --git a/crates/ui-egui/src/menus/invoke.rs b/crates/ui-egui/src/menus/invoke.rs
index 5b0d0f3c4..073b1130e 100644
--- a/crates/ui-egui/src/menus/invoke.rs
+++ b/crates/ui-egui/src/menus/invoke.rs
@@ -80,6 +80,7 @@ pub(super) fn menu_dialog(app: &VectorcraftApp, id: &str) -> Option<(&'static st
         crate::addons::typetools::COMMAND => (crate::addons::typetools::KIND, crate::addons::typetools::fields(app)),
         crate::addons::select::COMMAND => (crate::addons::select::KIND, crate::addons::select::fields(app)),
         "artboard.rearrange" => (crate::dialogs::rearrange_artboards::KIND, crate::dialogs::rearrange_artboards::open_fields(app)),
+        "artboard.rename" => (crate::dialogs::rename_artboards::KIND, crate::dialogs::rename_artboards::open_fields(app)),
         _ => return None,
     })
 }
@@ -173,6 +174,12 @@ pub fn invoke(app: &mut VectorcraftApp, id: &str, p: Value) {
         }
         return;
     }
+    if let Some(r) = crate::panels::artboards::run_menu_item(app, id, &p) {
+        if let Err(e) = r {
+            app.status(e);
+        }
+        return;
+    }
     // A Paste the user gives decodes a bitmap off the UI thread ([`crate::placing::adopt_for_paste`]).
     app.placing.for_user = id.starts_with("edit.paste");
     let r = app.run(id, p);
diff --git a/crates/ui-egui/src/menus/labels.rs b/crates/ui-egui/src/menus/labels.rs
index 5820ded94..b8d314346 100644
--- a/crates/ui-egui/src/menus/labels.rs
+++ b/crates/ui-egui/src/menus/labels.rs
@@ -217,6 +217,11 @@ pub fn item_shortcut(id: &str, p: &Value) -> Option<&'static str> {
     match (id, p.get("panel").and_then(Value::as_str)) {
         ("window.panel", Some(panel)) => crate::shortcut_editor::panel_shortcut(panel),
         ("effect.dialog" | "effect.apply", _) => p.get("effect").and_then(Value::as_str).and_then(crate::shortcut_editor::effect_shortcut),
+        // The Artboard tool's canvas menu passes the point its Paste goes to.
+        ("edit.paste", _) => shortcut_of(id),
+        // That menu's Cut and Copy: with the tool chosen, the keys run `edit.cut` and `edit.copy`, which do the same.
+        ("artboard.cut", _) => shortcut_of("edit.cut"),
+        ("artboard.copy", _) => shortcut_of("edit.copy"),
         _ if p.is_null() => shortcut_of(id),
         _ => None,
     }
@@ -234,6 +239,16 @@ pub const CONTEXT_LABELS: &[&str] = &[
     "Unlock Artboards",
     "Unlock Selected",
     "Unlock",
+    "New Artboard",
+    "Duplicate Artboards",
+    "Rename",
+    "Delete Artboards",
+    "Delete Empty Artboards",
+    "Select All Artboards",
+    "Rearrange",
+    "Switch Orientation",
+    "Artboard Options",
+    "Export",
     "Make Clipping Mask",
     "Release Clipping Mask",
     "Make Compound Path",
diff --git a/crates/ui-egui/src/menus/run.rs b/crates/ui-egui/src/menus/run.rs
index 47ecead54..dbee7082f 100644
--- a/crates/ui-egui/src/menus/run.rs
+++ b/crates/ui-egui/src/menus/run.rs
@@ -125,6 +125,8 @@ fn run_ui_part1(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<
         "file.reveal" => io::reveal(app),
         "file.cancelExport" => Ok(io::cancel_exports(app)),
         "file.exportInBackground" => Ok(io::hide_exports(app)),
+        "file.cancelOpen" => Ok(crate::opening::cancel_all(app)),
+        "file.openInBackground" => Ok(crate::opening::hide_all(app)),
         id if id.starts_with("file.openRecent") => match recent_slot(app, id).cloned() {
             Some(path) => io::open_reporting(app, &path),
             None => Err("no such recent file".into()),
@@ -710,6 +712,7 @@ fn run_ui_part8(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<
         "ui.rename" => crate::panels::layers::rename(app, p),
         "ui.newLayer" => crate::dialogs::layer_options::open_new(app, p),
         "ui.newArtboard" => crate::dialogs::artboard_options::open_new(app),
+        "artboard.selectAll" => crate::panels::artboards::select_all_command(app),
         "ui.layersPanelOptions" => crate::dialogs::layers_panel_options::open(app),
         "ui.navigatorPanelOptions" => crate::panels::navigator::set_options(app, p),
         "ui.layersExpand" => crate::panels::layers::expand(app, p),
diff --git a/crates/ui-egui/src/menus/state.rs b/crates/ui-egui/src/menus/state.rs
index 78553cc7b..963045722 100644
--- a/crates/ui-egui/src/menus/state.rs
+++ b/crates/ui-egui/src/menus/state.rs
@@ -187,6 +187,12 @@ pub fn enabled(app: &VectorcraftApp, id: &str) -> bool {
     if SUBJECT_COMMANDS.contains(&id) {
         return has_subject(app);
     }
+    // The Artboard tool's canvas menu measured this when it opened.
+    if id == "artboard.deleteEmpty"
+        && let Some(facts) = crate::panels::artboards::open_menu_facts(app)
+    {
+        return facts.any_empty;
+    }
     if let Some(c) = vectorcraft_engine::find_command(id) {
         // The system clipboard's contents can be pasted with an empty internal clipboard.
         return (c.enabled)(&app.session).is_ok() || app.system_paste && id.starts_with("edit.paste");
@@ -202,6 +208,8 @@ pub fn enabled(app: &VectorcraftApp, id: &str) -> bool {
         id if let Some(b) = crate::panels::align::button(id) => enabled(app, b.command()),
         "file.reveal" => app.services.reveal.is_some() && app.session.active().is_some_and(|d| d.path.is_some()),
         "file.cancelExport" | "file.exportInBackground" => app.background.jobs.iter().any(|j| j.progress.is_some() && !j.cancelled()),
+        "file.cancelOpen" => !app.opening.pending.is_empty(),
+        "file.openInBackground" => crate::opening::any_shown(app),
         "plugin.cancelRuns" => crate::plugin_runs::any_running(app),
         "plugin.hideRuns" => crate::plugin_runs::any_shown(app),
         "imageTrace.cancelRuns" => crate::trace_runs::any_running(app),
@@ -243,7 +251,7 @@ pub fn enabled(app: &VectorcraftApp, id: &str) -> bool {
             (d.kind == crate::dialogs::char_style_options::KIND || (d.kind == crate::dialogs::new_text_style::KIND && !d.bool("__para")))
                 && crate::dialogs::char_style_options::can_reset(d)
         }),
-        "ui.newArtboard" => app.session.active().is_some(),
+        "ui.newArtboard" | "artboard.selectAll" => app.session.active().is_some(),
         "ui.sampleScreenColor" => crate::screen_color::available(app),
         "ui.newBrush" => app.session.active().is_some(),
         "ui.brushOptions" => crate::dialogs::brush_options::available(app),
diff --git a/crates/ui-egui/src/menus/ui_commands.rs b/crates/ui-egui/src/menus/ui_commands.rs
index 52f8f8473..988abad5b 100644
--- a/crates/ui-egui/src/menus/ui_commands.rs
+++ b/crates/ui-egui/src/menus/ui_commands.rs
@@ -873,6 +873,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "",
         "{} open Artboard Options for a new artboard, filled in as artboard.new {} would make it (Artboard N, the last artboard's size, 20 pt to its right): dialog `artboardOptions` with new: true, fields name, x, y, width, height, showCenterMark, showCrossHairs; OK runs artboard.new with the fields and makes the new artboard the active one; Cancel adds nothing",
     ),
+    (
+        "artboard.selectAll",
+        "Select All Artboards",
+        "",
+        "{} the Artboard tool, chosen first when another tool is in use, selects every artboard, and the active artboard stays active; the art's selection stays as it is, and no undo step is recorded → {selected: [index…]} (the active artboard first)",
+    ),
     (
         "ui.layersPanelOptions",
         "Panel Options…",
@@ -1044,7 +1050,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "ui.menuDialog",
         "Menu Dialog",
         "",
-        "{command: object.move|object.rotate|object.scale|object.reflect|object.shear|object.transformEach|path.average|path.averageJoin|object.path.offsetPath|object.path.simplify|object.path.smooth|object.path.splitIntoGrid|object.vectorHalftone|artboard.rearrange|object.envelope.makeWithWarp|object.envelope.resetWithWarp|object.envelope.makeWithMesh|object.envelope.resetWithMesh|object.envelope.options|addon.arrange.grid|addon.arrange.replace|addon.arrange.size} open the dialog that command's menu item opens (dialog kind: move, rotate, scale, reflect, shear, transformEach, …, vectorHalftone, rearrangeArtboards, envelopeWarp, envelopeMesh, envelopeOptions, arrangeGrid, arrangeReplace, arrangeSize; Scale and Transform Each have `corners` and `strokes`, from the preferences, which OK updates; Transform Each opens on the values it was last confirmed with (not `copy`), and its Copy button confirms with `copy: true`; the envelope dialogs start from the selected envelope, Make opens as Reset (`reset: true`) while one is selected)",
+        "{command: object.move|object.rotate|object.scale|object.reflect|object.shear|object.transformEach|path.average|path.averageJoin|object.path.offsetPath|object.path.simplify|object.path.smooth|object.path.splitIntoGrid|object.vectorHalftone|artboard.rearrange|artboard.rename|object.envelope.makeWithWarp|object.envelope.resetWithWarp|object.envelope.makeWithMesh|object.envelope.resetWithMesh|object.envelope.options|addon.arrange.grid|addon.arrange.replace|addon.arrange.size} open the dialog that command's menu item opens (dialog kind: move, rotate, scale, reflect, shear, transformEach, …, vectorHalftone, rearrangeArtboards, renameArtboards, envelopeWarp, envelopeMesh, envelopeOptions, arrangeGrid, arrangeReplace, arrangeSize; Scale and Transform Each have `corners` and `strokes`, from the preferences, which OK updates; Transform Each opens on the values it was last confirmed with (not `copy`), and its Copy button confirms with `copy: true`; the envelope dialogs start from the selected envelope, Make opens as Reset (`reset: true`) while one is selected)",
     ),
     (
         "ui.widthPointEdit",
@@ -1187,6 +1193,18 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "",
         "{} close the export progress dialog; the exports go on, shown in the status bar → {hidden: n}",
     ),
+    (
+        "file.cancelOpen",
+        "Cancel Opening",
+        "",
+        "{} stop opening every file being read in the background (its progress window's Cancel): the files don't open → {cancelled: n}",
+    ),
+    (
+        "file.openInBackground",
+        "Continue in Background",
+        "",
+        "{} close the progress window of the files being opened; they go on being read, shown in the status bar → {hidden: n}",
+    ),
     (
         "ui.dxfOptionsDialog",
         "DXF Options Dialog",
diff --git a/crates/ui-egui/src/opening.rs b/crates/ui-egui/src/opening.rs
index fb2949dd4..9191509ae 100644
--- a/crates/ui-egui/src/opening.rs
+++ b/crates/ui-egui/src/opening.rs
@@ -1,8 +1,11 @@
 //! Opening documents off the UI thread (desktop): a file the user asks to open (File › Open, Open
 //! Recent, the Home screen, files handed to the app) is decoded on a thread of its own, which also
 //! reads its linked files and lays out its type, while the status bar shows it, and opens in a new tab
-//! once it is ready, as it would at once: the same notes, recent files and errors. On wasm (no
-//! threads) and in unit tests it opens at once ([`available`]).
+//! once it is ready, as it would at once: the same notes, recent files and errors. A file that takes
+//! longer than [`DELAY`] shows a progress window ([`show`]): its name, a bar that moves while it is
+//! read (the reader counts no steps), Cancel (also Esc, `file.cancelOpen`: the file doesn't open)
+//! and Continue in Background (`file.openInBackground`: it goes on, shown in the status bar). On
+//! wasm (no threads) and in unit tests it opens at once ([`available`]).
 
 use std::sync::Arc;
 use std::sync::mpsc::{Receiver, TryRecvError, channel};
@@ -12,9 +15,13 @@ use vectorcraft_engine::cmd::fileio::{self, ReadFile};
 use vectorcraft_engine::file_access::ScopeHandle;
 
 use crate::VectorcraftApp;
+use crate::export_progress::{self, Pressed};
+
+pub use crate::export_progress::DELAY;
 
 /// A file being read.
 pub struct Pending {
+    id: u64,
     /// Where it is.
     pub path: String,
     /// What the status bar shows ("Opening Poster.vectorcraft").
@@ -23,6 +30,8 @@ pub struct Pending {
     /// The automation roots in force where the open started: the document is installed under
     /// them too (its links are read as it opens).
     scope: ScopeHandle,
+    /// Continue in Background: the progress window no longer shows it.
+    pub hidden: bool,
 }
 
 /// The files being read.
@@ -32,6 +41,7 @@ pub struct Opening {
     /// Open documents asked for again while the active one couldn't change: their tabs come to
     /// the front once it can ([`may_switch`]), each in the file access scope it was asked in.
     pub activate: Vec<(String, ScopeHandle)>,
+    next_id: u64,
 }
 
 /// Is a long operation running that should show the busy cursor and status spinner (background
@@ -81,7 +91,9 @@ pub fn start(app: &mut VectorcraftApp, path: &str, bytes: Vec<u8>) -> Result<Val
         return Err(Arc::try_unwrap(bytes).unwrap_or_else(|b| b.to_vec()));
     }
     let label = format!("Opening {}", fileio::file_name(path));
-    app.opening.pending.push(Pending { path: path.to_string(), label: label.clone(), done, scope: opener });
+    app.opening.next_id += 1;
+    let id = app.opening.next_id;
+    app.opening.pending.push(Pending { id, path: path.to_string(), label: label.clone(), done, scope: opener, hidden: false });
     let status = format!("{label}…");
     app.status(status.clone());
     Ok(json!({ "background": true, "status": status }))
@@ -139,6 +151,75 @@ pub fn poll(app: &mut VectorcraftApp) {
     }
 }
 
+/// The progress window's Cancel: the files being read don't open (their threads finish reading
+/// and the result is dropped) → `{cancelled: n}`.
+pub fn cancel_all(app: &mut VectorcraftApp) -> Value {
+    let cancelled = std::mem::take(&mut app.opening.pending);
+    for p in &cancelled {
+        // The status bar no longer says it is opening.
+        if app.ui.status == format!("{}…", p.label) {
+            app.ui.status.clear();
+        }
+    }
+    json!({ "cancelled": cancelled.len() })
+}
+
+/// The progress window's Continue in Background: the files go on being read, shown in the status
+/// bar only → `{hidden: n}`.
+pub fn hide_all(app: &mut VectorcraftApp) -> Value {
+    let mut n = 0;
+    for p in app.opening.pending.iter_mut().filter(|p| !p.hidden) {
+        p.hidden = true;
+        n += 1;
+    }
+    json!({ "hidden": n })
+}
+
+/// Is a file being read that the progress window shows?
+pub fn any_shown(app: &VectorcraftApp) -> bool {
+    app.opening.pending.iter().any(|p| !p.hidden)
+}
+
+/// The progress window of the first file being read it shows, once that has been read for
+/// [`DELAY`]: a quick open doesn't flash it. Not while a dialog or another progress window (an
+/// export, a heavy plug-in filter, an Image Trace) is open: never two modals at once.
+pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
+    let shown: Vec<&Pending> = app.opening.pending.iter().filter(|p| !p.hidden).collect();
+    let Some(first) = shown.first() else { return };
+    let now = ctx.input(|i| i.time);
+    let since = ctx.data_mut(|m| {
+        let seen = m.get_temp_mut_or_insert_with(egui::Id::unique("opening-seen"), || (first.id, now));
+        if seen.0 != first.id {
+            *seen = (first.id, now);
+        }
+        seen.1
+    });
+    let exporting = app.background.jobs.iter().any(|j| j.progress.is_some() && !j.hidden && !j.cancelled());
+    let other = exporting || crate::plugin_runs::any_shown(app) || crate::trace_runs::any_shown(app);
+    if now - since < DELAY || app.ui.dialog.is_some() || other {
+        return;
+    }
+    let heading = format!("{}…", crate::i18n::msg(&first.label));
+    let more = shown.len() - 1;
+    let t = crate::theme::Tokens::get(ctx);
+    let pressed = export_progress::window(ctx, "opening-progress", &heading, |ui| {
+        export_progress::indeterminate(ui, tl!("Reading the file…"));
+        if more > 0 {
+            ui.add_space(6.0);
+            let queued = crate::i18n::tn(more as u64, "{n} more file waiting", "{n} more files waiting");
+            ui.label(egui::RichText::new(queued).size(11.5).color(t.text_dim));
+        }
+    });
+    let id = match pressed {
+        Some(Pressed::Cancel) => "file.cancelOpen",
+        Some(Pressed::Hide) => "file.openInBackground",
+        None => return,
+    };
+    if let Err(e) = app.run(id, json!({})) {
+        app.status(e);
+    }
+}
+
 /// Open a file read off the UI thread, as [`crate::io::open_reporting`] opens one read at once.
 fn finish(app: &mut VectorcraftApp, path: &str, r: Result<ReadFile, String>) {
     let opened = r.and_then(|file| fileio::open_read(&mut app.session, file).map_err(|e| e.to_string()));
diff --git a/crates/ui-egui/src/opening/tests.rs b/crates/ui-egui/src/opening/tests.rs
index 40e2e6009..1f5a6cbd1 100644
--- a/crates/ui-egui/src/opening/tests.rs
+++ b/crates/ui-egui/src/opening/tests.rs
@@ -363,3 +363,90 @@ fn a_file_that_opens_and_asks_holds_back_the_next_one_ready() {
     assert_eq!(app.session.doc().unwrap().path.as_deref(), Some("/art/Asks.vectorcraft"), "the dialog's document stays active");
     assert_eq!(app.opening.pending.len(), 1, "the next file waits");
 }
+
+/// Draws the opening progress window at `time` seconds → the texts it drew.
+fn progress(app: &mut VectorcraftApp, ctx: &egui::Context, time: f64) -> String {
+    let mut out = ctx.run_ui(egui::RawInput { time: Some(time), ..Default::default() }, |ui| show(app, ui.ctx()));
+    out.textures_delta.clear();
+    let mut texts = String::new();
+    for shape in out.shapes {
+        if let egui::epaint::Shape::Text(t) = shape.shape {
+            texts.push_str(t.galley.text());
+            texts.push('\n');
+        }
+    }
+    texts
+}
+
+/// A document's bytes, `title` naming it.
+fn bytes(title: &str) -> Vec<u8> {
+    let mut d = vectorcraft_doc::Document::new(120.0, 80.0);
+    d.title = title.into();
+    vectorcraft_format::save(&d, false)
+}
+
+/// #5930: a file that takes a while to open shows a progress window with its name and a moving
+/// bar, after [`DELAY`] so a quick open doesn't flash it; a second file says it waits, and the
+/// window waits for a dialog to close.
+#[test]
+fn a_file_that_takes_a_while_to_open_shows_a_progress_window() {
+    let mut app = VectorcraftApp::new(Session::new(), Services::default());
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    assert_eq!(progress(&mut app, &ctx, 0.0), "", "nothing opening");
+    start(&mut app, "/art/Big.vectorcraft", bytes("Big")).unwrap();
+    assert_eq!(progress(&mut app, &ctx, 1.0), "", "not at once");
+    progress(&mut app, &ctx, 1.0 + DELAY + 0.05); // a new window measures itself unseen first
+    let texts = progress(&mut app, &ctx, 1.0 + DELAY + 0.1);
+    for want in ["Opening Big.vectorcraft…", "Reading the file…", "Cancel", "Continue in Background"] {
+        assert!(texts.contains(want), "{want} in {texts}");
+    }
+    assert!(!texts.contains("waiting"), "{texts}");
+    start(&mut app, "/art/Next.vectorcraft", bytes("Next")).unwrap();
+    let texts = progress(&mut app, &ctx, 2.0);
+    assert!(texts.contains("Opening Big.vectorcraft…") && texts.contains("1 more file waiting"), "{texts}");
+    app.ui.dialog = Some(crate::state::Dialog::new(crate::dialogs::save_options::KIND, json!({})));
+    assert_eq!(progress(&mut app, &ctx, 3.0), "", "never two modals at once");
+    app.ui.dialog = None;
+    // Continue in Background: the window closes, the files still open.
+    let before = app.session.documents().len();
+    assert!(crate::menus::enabled(&app, "file.openInBackground"));
+    assert_eq!(app.run("file.openInBackground", json!({})).unwrap()["hidden"], 2);
+    assert_eq!(progress(&mut app, &ctx, 4.0), "");
+    assert!(!crate::menus::enabled(&app, "file.openInBackground"));
+    assert!(long_operation_busy(&app), "the status bar still shows them");
+    open_ready(&mut app);
+    assert_eq!(app.session.documents().len(), before + 2);
+}
+
+/// #5930: the progress window's Cancel (`file.cancelOpen`): the file doesn't open, even once it
+/// has been read, and the status bar no longer says it is opening.
+#[test]
+fn cancelling_an_open_opens_nothing() {
+    let mut app = VectorcraftApp::new(Session::new(), Services::default());
+    assert!(!crate::menus::enabled(&app, "file.cancelOpen"));
+    let before = app.session.documents().len();
+    start(&mut app, "/art/Big.vectorcraft", bytes("Big")).unwrap();
+    assert!(crate::menus::enabled(&app, "file.cancelOpen"));
+    assert_eq!(app.run("file.cancelOpen", json!({})).unwrap()["cancelled"], 1);
+    assert!(app.opening.pending.is_empty() && !long_operation_busy(&app));
+    assert!(!app.ui.status.starts_with("Opening"), "{}", app.ui.status);
+    std::thread::sleep(std::time::Duration::from_millis(50));
+    poll(&mut app);
+    assert_eq!(app.session.documents().len(), before);
+    assert_ne!(app.ui.recent_files.first().map(String::as_str), Some("/art/Big.vectorcraft"));
+}
+
+/// The moving bar's segment enters at the left, crosses the track and leaves at the right, and a
+/// time that isn't finite puts it at the start.
+#[test]
+fn the_indeterminate_bar_sweeps_across_its_track() {
+    use crate::export_progress::sweep_at;
+    assert_eq!(sweep_at(0.0), (0.0, 0.0));
+    let (from, to) = sweep_at(0.8);
+    assert!(from > 0.0 && to < 1.0 && to > from, "{from} {to}");
+    let (from, to) = sweep_at(1.55);
+    assert!(from > 0.6 && to == 1.0, "{from} {to}");
+    assert_eq!(sweep_at(f64::NAN), (0.0, 0.0));
+    assert_eq!(sweep_at(-0.8), sweep_at(0.8));
+}
diff --git a/crates/ui-egui/src/palette.rs b/crates/ui-egui/src/palette.rs
index 7cad17d0c..fda2e1f7f 100644
--- a/crates/ui-egui/src/palette.rs
+++ b/crates/ui-egui/src/palette.rs
@@ -77,6 +77,7 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
     if !app.ui.palette_open {
         return;
     }
+    crate::shortcuts::hold_back_keys(app, ctx);
     let t = Tokens::get(ctx);
     let q = app.ui.palette_query.to_lowercase();
     let entries = entries(ctx, crate::i18n::current());
diff --git a/crates/ui-egui/src/panels/appearance.rs b/crates/ui-egui/src/panels/appearance.rs
index a27dfa3ec..ff05f1c7e 100644
--- a/crates/ui-egui/src/panels/appearance.rs
+++ b/crates/ui-egui/src/panels/appearance.rs
@@ -1035,7 +1035,7 @@ fn contents_row(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, label: &str, se
     if characters {
         for (k, stroke) in [false, true].into_iter().enumerate() {
             let cr = Rect::from_min_size(pos2(r.left() + EYE_W + 100.0 + 24.0 * k as f32, r.center().y - 9.0), vec2(18.0, 18.0));
-            chip(ui, cr, n.proxy_paint(stroke, None).map_or(&Paint::None, |(p, ..)| p), false);
+            chip(ui, cr, n.proxy_paint_only(stroke, None).unwrap_or(&Paint::None), false);
         }
     }
     // An image's row has no members to target.
diff --git a/crates/ui-egui/src/panels/artboards.rs b/crates/ui-egui/src/panels/artboards.rs
index deff9d872..d02f5f028 100644
--- a/crates/ui-egui/src/panels/artboards.rs
+++ b/crates/ui-egui/src/panels/artboards.rs
@@ -67,8 +67,8 @@ pub(crate) fn control_bar(app: &mut VectorcraftApp, ui: &mut Ui) -> bool {
     let Some(ab) = app.session.active().and_then(|d| d.doc.artboards.get(i)).cloned() else { return true };
     let r = ab.rect;
     super::properties::artboard_size_row(app, ui, i, r.width(), r.height());
-    if widgets::icon_button(ui, "dc-new-item", tl!("New Artboard"), false, 24.0).clicked() && app.run("artboard.new", json!({})).is_ok() {
-        select(app, n);
+    if widgets::icon_button(ui, "dc-new-item", tl!("New Artboard"), false, 24.0).clicked() {
+        add_new(app);
     }
     if widgets::icon_button_enabled(ui, "trash-2", tl!("Delete Artboard"), false, n > 1, 24.0).clicked() {
         delete_selected(app);
@@ -100,10 +100,12 @@ pub(crate) fn control_bar(app: &mut VectorcraftApp, ui: &mut Ui) -> bool {
     super::transform::reference_locator(ui, refi);
     let link = super::transform::proportional(app, ui);
     let rp = vectorcraft_geom::reference_point(r, refi);
+    // The W/H link sits between W and H, but is made after H so Tab goes from W straight to H and
+    // finds the link after it, as in the object Control bar.
+    let mut link_room = None;
     for (k, lbl, v) in [("x", "X:", rp.x - origin.x), ("y", "Y:", rp.y - origin.y), ("width", "W:", r.width()), ("height", "H:", r.height())] {
-        // The W/H link sits between W and H.
         if k == "height" {
-            super::transform::constrain_link(app, ui);
+            link_room = Some(super::transform::constrain_link_room(ui));
         }
         widgets::field_label(ui, egui::RichText::new(tl!(lbl)).size(12.0).color(t.text_dim));
         let set = if matches!(k, "width" | "height") {
@@ -121,6 +123,10 @@ pub(crate) fn control_bar(app: &mut VectorcraftApp, ui: &mut Ui) -> bool {
             super::transform::set_artboard(app, i, refi, xywh, link);
         }
     }
+    if let Some(room) = link_room {
+        let id = ui.scope_id().with("cb-ab-constrain-link");
+        super::transform::constrain_link_at(app, ui, ui.interact(room, id, egui::Sense::click()));
+    }
     true
 }
 
@@ -239,20 +245,10 @@ pub(crate) fn set_props(
     }
 }
 
-/// Rename the artboards of `indices` in one undo step (`artboard.setProps`): one artboard takes
-/// `name` (trimmed), and several take it numbered in panel order, `name-1`, `name-2` and so on.
+/// Rename the artboards of `indices` in one undo step (`artboard.rename`): one artboard takes `name`
+/// (trimmed), and several take it numbered in panel order, `name-1`, `name-2` and so on.
 fn rename(app: &mut VectorcraftApp, indices: &[usize], name: &str) -> Result<Value, String> {
-    let name = name.trim();
-    let mut all = indices.to_vec();
-    all.sort_unstable();
-    all.dedup();
-    let several = all.len() > 1;
-    let numbered = |k: usize| if several { format!("{name}-{}", k + 1) } else { name.to_string() };
-    let entries = all.iter().enumerate().map(|(k, i)| json!({"index": i, "name": numbered(k)})).collect();
-    match set_props_params(json!({}), entries) {
-        Some(p) => app.run("artboard.setProps", p),
-        None => Ok(Value::Null),
-    }
+    app.run("artboard.rename", json!({"indices": indices, "name": name}))
 }
 
 /// Open the name field on artboard `i`'s row. The name typed there goes to the artboards
@@ -262,32 +258,126 @@ fn start_rename(ctx: &egui::Context, app: &VectorcraftApp, i: usize) {
     set_pstate(ctx, "ab-edit-all", renamed_with(app, i));
 }
 
-/// Delete the picked artboards that aren't locked and select a remaining one.
-pub(crate) fn delete_selected(app: &mut VectorcraftApp) {
-    let n = app.session.active().map_or(0, |d| d.doc.artboards.len());
+/// The artboards Delete Artboards deletes (of `n`): the picked ones that aren't locked, without
+/// artboard 1 when that would be all of them. Empty when none can go, since one is always left.
+pub(crate) fn delete_targets(app: &VectorcraftApp, n: usize) -> Vec<usize> {
     let mut all = deletable(app, n);
-    if all.is_empty() {
-        return;
-    }
     if n > 1 && all.len() == n {
         // Deleting all artboards keeps artboard 1 (the public Delete artboards guide).
         all.retain(|i| *i != 0);
     }
-    if n > all.len() && app.run("artboard.delete", json!({ "indices": all })).is_ok() {
+    if n > all.len() { all } else { vec![] }
+}
+
+/// Delete the picked artboards that aren't locked and select a remaining one.
+pub(crate) fn delete_selected(app: &mut VectorcraftApp) {
+    let n = app.session.active().map_or(0, |d| d.doc.artboards.len());
+    let all = delete_targets(app, n);
+    if !all.is_empty() && app.run("artboard.delete", json!({ "indices": all })).is_ok() {
         select(app, all.first().copied().unwrap_or(0).saturating_sub(1));
     }
 }
 
 /// Artboards panel › Delete Empty Artboards: delete the artboards with no artwork, then make the
 /// active artboard, where it is now, active again, or else the nearest one before it that is left.
-pub(crate) fn delete_empty(app: &mut VectorcraftApp) {
+pub(crate) fn delete_empty(app: &mut VectorcraftApp) -> Result<Value, String> {
     let n = app.session.active().map_or(0, |d| d.doc.artboards.len());
     let active = selected(app, n);
-    let Ok(r) = app.run("artboard.deleteEmpty", json!({})) else { return };
+    let r = app.run("artboard.deleteEmpty", json!({}))?;
     let deleted: Vec<usize> = r["deleted"].as_array().into_iter().flatten().filter_map(Value::as_u64).map(|i| i as usize).collect();
     // The last artboard up to the active one that is left, numbered as it is now.
     let kept = (0..=active).rev().find(|i| !deleted.contains(i)).unwrap_or(0);
     select(app, kept.saturating_sub(deleted.iter().filter(|d| **d < kept).count()));
+    Ok(r)
+}
+
+/// What the Artboard tool's canvas menu needs to know about the document's art, which takes a walk
+/// over it: [`right_click`] measures it once, and the menu reads it on every frame it is open.
+#[derive(Clone, Debug)]
+pub struct MenuFacts {
+    uid: u64,
+    revision: u64,
+    picked: Vec<usize>,
+    /// The right-click's point, in document coordinates: where the menu's Paste puts artboards.
+    pub(crate) at: vectorcraft_geom::Point,
+    /// Whether Delete Empty Artboards has an artboard to delete.
+    pub(crate) any_empty: bool,
+    /// Whether Fit to Artwork Bounds has art to fit a selected artboard to.
+    pub(crate) any_art: bool,
+}
+
+/// Whether an unlocked artboard of `indices` has art that Fit to Artwork Bounds fits it to.
+pub(crate) fn fit_has_art(app: &VectorcraftApp, indices: &[usize]) -> bool {
+    app.session.active().is_some_and(|st| {
+        indices
+            .iter()
+            .filter_map(|i| st.doc.artboards.get(*i))
+            .any(|a| !a.locked && vectorcraft_render::encode::art_bounds_on(&st.doc, a.rect).is_some())
+    })
+}
+
+/// A right-click on the canvas at `p` with the Artboard tool: an artboard under the pointer that
+/// isn't selected becomes the only selected one, and the menu's facts are measured.
+pub(crate) fn right_click(app: &mut VectorcraftApp, p: vectorcraft_geom::Point) {
+    let Some(st) = app.session.active() else { return };
+    let (uid, n, hit) = (st.uid, st.doc.artboards.len(), st.doc.artboard_at(p));
+    if let Some(i) = hit.filter(|i| !picked(app, n).contains(i)) {
+        select(app, i);
+    }
+    let all = picked(app, n);
+    let any_empty = vectorcraft_engine::find_command("artboard.deleteEmpty").is_some_and(|c| (c.enabled)(&app.session).is_ok());
+    let any_art = fit_has_art(app, &all);
+    let revision = app.session.active().map_or(0, |st| st.revision);
+    app.ui.context_artboards = Some(MenuFacts { uid, revision, picked: all, at: p, any_empty, any_art });
+}
+
+/// The facts of the open canvas menu, while they still describe the document and the selection.
+pub(crate) fn open_menu_facts(app: &VectorcraftApp) -> Option<&MenuFacts> {
+    let st = app.session.active()?;
+    let n = st.doc.artboards.len();
+    app.ui.context_artboards.as_ref().filter(|f| f.uid == st.uid && f.revision == st.revision && f.picked == picked(app, n))
+}
+
+/// Run an artboard command chosen from a menu or the command palette while the Artboard tool is in
+/// use, with the view and the tool's selection following it as they do in the Artboards panel: a
+/// new artboard becomes active, the copies are selected, and a deletion makes a remaining artboard
+/// active. None for any other command or tool.
+pub(crate) fn run_menu_item(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
+    if app.session.tool_id() != "artboard" {
+        return None;
+    }
+    let n = app.session.active().map_or(0, |d| d.doc.artboards.len());
+    Some(match id {
+        "artboard.new" => app.run(id, p.clone()).inspect(|r| {
+            if let Some(i) = r["index"].as_u64() {
+                select(app, i as usize);
+            }
+        }),
+        "artboard.duplicate" => {
+            let all = picked(app, n);
+            app.run(id, p.clone()).inspect(|r| select_copies(app, &all, r))
+        }
+        "artboard.delete" => app.run(id, p.clone()).inspect(|_| {
+            let listed = p["indices"].as_array().and_then(|l| l.iter().filter_map(Value::as_u64).min());
+            let first = listed.or(p["index"].as_u64()).unwrap_or(0) as usize;
+            select(app, first.saturating_sub(1));
+        }),
+        "artboard.deleteEmpty" => delete_empty(app),
+        _ => return None,
+    })
+}
+
+/// `artboard.selectAll`: the Artboard tool, chosen first when another tool is in use, selects every
+/// artboard → the artboards selected, the active one first.
+pub(crate) fn select_all_command(app: &mut VectorcraftApp) -> Result<Value, String> {
+    if app.session.active().is_none() {
+        return Err("no document".into());
+    }
+    if app.session.tool_id() != "artboard" {
+        app.select_tool("artboard");
+    }
+    select_all(app);
+    Ok(json!({ "selected": app.session.tool_options()["selected"] }))
 }
 
 /// Shift-click on artboard `i`'s row while the Artboard tool is in use: the tool selects the
@@ -364,6 +454,15 @@ pub(crate) fn select(app: &mut VectorcraftApp, i: usize) {
     }
 }
 
+/// Add an artboard with the default settings (`artboard.new`) and make it the active artboard.
+pub(crate) fn add_new(app: &mut VectorcraftApp) {
+    if let Ok(r) = app.run("artboard.new", json!({}))
+        && let Some(new) = r["index"].as_u64()
+    {
+        select(app, new as usize);
+    }
+}
+
 /// A row dragged in the list: the artboard's index.
 #[derive(Clone, Copy)]
 struct RowDrag(usize);
@@ -382,8 +481,15 @@ fn duplicate(app: &mut VectorcraftApp, i: usize) {
 pub(crate) fn duplicate_picked(app: &mut VectorcraftApp) {
     let n = app.session.active().map_or(0, |d| d.doc.artboards.len());
     let all = picked(app, n);
-    let active = selected(app, n);
     let Ok(r) = app.run("artboard.duplicate", json!({ "indices": all })) else { return };
+    select_copies(app, &all, &r);
+}
+
+/// After `artboard.duplicate` of the artboards `all` returned `r`: select the copies, the active
+/// artboard's copy active.
+fn select_copies(app: &mut VectorcraftApp, all: &[usize], r: &Value) {
+    let n = app.session.active().map_or(0, |d| d.doc.artboards.len());
+    let active = selected(app, n);
     let copies: Vec<usize> =
         r["indices"].as_array().into_iter().flatten().filter_map(Value::as_u64).filter_map(|i| usize::try_from(i).ok()).collect();
     let Some(first) = all.iter().position(|i| *i == active).and_then(|k| copies.get(k)).or(copies.first()).copied() else { return };
@@ -571,8 +677,8 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         } else if new.clicked() && alt_held(ui) {
             // Alt-click: Artboard Options for the new artboard, which OK adds.
             app.run("ui.newArtboard", json!({})).ok();
-        } else if new.clicked() && app.run("artboard.new", json!({})).is_ok() {
-            select(app, n);
+        } else if new.clicked() {
+            add_new(app);
         }
         if widgets::icon_button_enabled(ui, "trash-2", tl!("Delete Artboard"), false, n > 1 && !deletable(app, n).is_empty(), 24.0).clicked() {
             delete_selected(app);
@@ -589,7 +695,7 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
     let n = app.session.active().map(|d| d.doc.artboards.len()).unwrap_or(0);
     let sel = selected(app, n);
     if menu_item(ui, tl!("New Artboard"), n > 0, false) {
-        app.run("artboard.new", json!({})).ok();
+        add_new(app);
     }
     if menu_item(ui, tl!("Duplicate Artboards"), n > 0, false) {
         duplicate_picked(app);
@@ -604,7 +710,7 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
         start_rename(ui.ctx(), app, if all.contains(&sel) { sel } else { all.first().copied().unwrap_or(sel) });
     }
     if menu_item(ui, tl!("Delete Empty Artboards"), crate::menus::enabled(app, "artboard.deleteEmpty"), false) {
-        delete_empty(app);
+        delete_empty(app).ok();
     }
     ui.separator();
     if menu_item(ui, tl!("Convert to Artboards"), crate::menus::enabled(app, "artboard.convertToArtboards"), false) {
diff --git a/crates/ui-egui/src/panels/artboards/tests.rs b/crates/ui-egui/src/panels/artboards/tests.rs
index bf2b47050..c01d82eb1 100644
--- a/crates/ui-egui/src/panels/artboards/tests.rs
+++ b/crates/ui-egui/src/panels/artboards/tests.rs
@@ -632,6 +632,50 @@ fn the_panel_menus_duplicate_artboards_copies_every_selected_artboard() {
     assert_eq!((d.artboards.len(), d.layers[0].children().unwrap().len()), (3, 2), "one undo step");
 }
 
+/// The panel menu's New Artboard adds one artboard in one undo step and makes it the active one, as
+/// the panel's button does, with any tool. With the Artboard tool, the new artboard is then the only
+/// one selected.
+#[test]
+fn the_panel_menus_new_artboard_makes_the_new_artboard_active() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 200, "height": 150, "artboards": 2})).unwrap();
+    app.view_mut().unwrap().artboard = 0;
+    let ctx = egui::Context::default();
+    let screen = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(240.0, 400.0)));
+    let frame = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
+        let mut out = ctx.run_ui(egui::RawInput { events, screen_rect: screen, ..Default::default() }, |ui| menu(app, ui));
+        out.textures_delta.clear();
+        out.shapes
+    };
+    let click = |app: &mut VectorcraftApp| {
+        let item = frame(app, vec![])
+            .iter()
+            .find_map(|c| match &c.shape {
+                egui::Shape::Text(t) if t.galley.text().trim_start() == "New Artboard" => Some(t.visual_bounding_rect().center()),
+                _ => None,
+            })
+            .unwrap();
+        let button = |pressed| egui::Event::PointerButton { pos: item, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        frame(app, vec![egui::Event::PointerMoved(item), button(true), button(false)]);
+    };
+    click(&mut app);
+    assert_eq!(boards(&app).2.len(), 3);
+    assert_eq!(selected(&app, 3), 2, "the new artboard is active with the Selection tool");
+    let undo_steps = app.session.active().unwrap().history.undo.len();
+    app.run("edit.undo", json!({})).unwrap();
+    assert_eq!(boards(&app).2.len(), 2, "one undo step removes the new artboard");
+    assert_eq!(app.session.active().unwrap().history.undo.len(), undo_steps - 1);
+
+    app.select_tool("artboard");
+    select(&mut app, 1);
+    app.session.set_tool_option("selected", &json!([1, 0]));
+    click(&mut app);
+    assert_eq!(boards(&app).2.len(), 3);
+    assert_eq!(app.view().unwrap().artboard, 2, "the new artboard is active with the Artboard tool");
+    assert_eq!(app.session.tool_options()["active"], json!(2));
+    assert_eq!(app.session.tool_options()["selected"], json!([2]), "and is the only one selected");
+}
+
 /// The panel menu's Convert to Artboards turns the geometric bounds of each selected rectangle
 /// into a new artboard and removes the rectangles, in one undo step, as Object › Artboards ›
 /// Convert to Artboards does; with nothing selected it is off.
@@ -1276,3 +1320,346 @@ fn the_artboard_tools_context_menu_locks_and_unlocks_artboards() {
     run(&mut app, "Unlock Artboards", "Unlock All");
     assert_eq!(locked(&app), [false, false, false]);
 }
+
+/// A document of `boards` artboards of 100 × 50 pt with the Artboard tool chosen.
+fn menu_app(boards: usize) -> VectorcraftApp {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 100, "height": 50, "units": "Points", "artboards": boards})).unwrap();
+    app.select_tool("artboard");
+    app
+}
+
+/// The labels of `items`, submenus by their own label, separators left out.
+fn menu_labels(items: &[crate::menus::Item]) -> Vec<&'static str> {
+    use crate::menus::Item;
+    items
+        .iter()
+        .filter_map(|i| match i {
+            Item::Cmd(l, ..) | Item::Sub(l, _) => Some(*l),
+            _ => None,
+        })
+        .collect()
+}
+
+/// The entry of the Artboard tool's canvas menu named `label`, chosen as a click on it chooses it.
+fn choose(app: &mut VectorcraftApp, label: &str) {
+    use crate::menus::Item;
+    let items = crate::menus::context_items(app);
+    let Some(Item::Cmd(l, id, p)) = items.iter().find(|i| matches!(i, Item::Cmd(l, ..) if *l == label)) else { panic!("no {label}") };
+    let (id, p) = crate::menus::click_target(l, id, p);
+    crate::menus::invoke(app, &id, p);
+}
+
+fn undo_steps(app: &VectorcraftApp) -> usize {
+    app.session.active().unwrap().history.undo.len()
+}
+
+fn board_names(app: &VectorcraftApp) -> Vec<String> {
+    app.session.active().unwrap().doc.artboards.iter().map(|a| a.name.clone()).collect()
+}
+
+/// The Artboard tool's canvas menu lists the public page's entries in the page's order, with
+/// nothing for objects or the view; another tool's menu lists none of them.
+#[test]
+fn the_artboard_tools_menu_lists_the_pages_entries_in_order() {
+    let mut app = menu_app(3);
+    app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+    app.session.execute("edit.copy", &json!({})).unwrap();
+    assert_eq!(
+        menu_labels(&crate::menus::context_items(&app)),
+        [
+            "Cut",
+            "Copy",
+            "Paste",
+            "Undo",
+            "Redo",
+            "New Artboard",
+            "Duplicate Artboards",
+            "Rename",
+            "Delete Artboards",
+            "Delete Empty Artboards",
+            "Select All Artboards",
+            "Lock Artboards",
+            "Rearrange",
+            "Fit to Artwork Bounds",
+            "Switch Orientation",
+            "Artboard Options",
+            "Export",
+        ]
+    );
+    app.select_tool("selection");
+    let other = menu_labels(&crate::menus::context_items(&app));
+    for label in
+        ["New Artboard", "Duplicate Artboards", "Delete Artboards", "Select All Artboards", "Lock Artboards", "Rearrange", "Switch Orientation"]
+    {
+        assert!(!other.contains(&label), "{label} in {other:?}");
+    }
+}
+
+/// An entry whose command can't run is left out: Cut with every artboard selected, or a locked one;
+/// Delete Artboards in a document of one; Select All Artboards with all selected; Rearrange with one;
+/// Fit to Artwork Bounds without art; Switch Orientation on a square artboard.
+#[test]
+fn the_artboard_tools_menu_leaves_out_what_cannot_run() {
+    let shown = |app: &VectorcraftApp, label: &str| menu_labels(&crate::menus::context_items(app)).contains(&label);
+    let mut app = menu_app(1);
+    for label in ["Cut", "Delete Artboards", "Delete Empty Artboards", "Select All Artboards", "Rearrange", "Fit to Artwork Bounds"] {
+        assert!(!shown(&app, label), "{label} with one empty artboard");
+    }
+    assert!(shown(&app, "Copy") && shown(&app, "Switch Orientation"));
+    app.session.execute("artboard.setProps", &json!({"index": 0, "width": 50})).unwrap();
+    assert!(!shown(&app, "Switch Orientation"), "a square artboard");
+
+    let mut app = menu_app(2);
+    app.session.set_tool_option("selected", &json!([0, 1]));
+    assert!(!shown(&app, "Cut"), "every artboard selected");
+    assert!(!shown(&app, "Select All Artboards"));
+    app.session.set_tool_option("selected", &json!([1]));
+    app.session.execute("artboard.setProps", &json!({"index": 1, "locked": true})).unwrap();
+    for label in ["Cut", "Delete Artboards", "Switch Orientation"] {
+        assert!(!shown(&app, label), "{label} on a locked artboard");
+    }
+    assert!(shown(&app, "Rename"), "a locked artboard can be renamed");
+}
+
+/// With no selection of its own the tool has its active artboard selected, and the menu acts on it.
+#[test]
+fn the_artboard_tools_menu_acts_on_the_active_artboard_without_a_selection() {
+    let mut app = menu_app(3);
+    select(&mut app, 1);
+    choose(&mut app, "Switch Orientation");
+    let doc = &app.session.active().unwrap().doc;
+    assert_eq!((doc.artboards[1].rect.width(), doc.artboards[1].rect.height()), (50.0, 100.0));
+    assert_eq!(doc.artboards[0].rect.width(), 100.0);
+}
+
+/// Each entry runs its command on the selected artboards, in one undo step, and the view follows.
+#[test]
+fn the_artboard_tools_menu_entries_run_on_the_selected_artboards() {
+    let mut app = menu_app(4);
+    app.session.set_tool_option("selected", &json!([2, 1]));
+    app.view_mut().unwrap().artboard = 2;
+
+    let steps = undo_steps(&app);
+    choose(&mut app, "Switch Orientation");
+    let sizes = |app: &VectorcraftApp| app.session.active().unwrap().doc.artboards.iter().map(|a| a.rect.width()).collect::<Vec<_>>();
+    assert_eq!(sizes(&app), [100.0, 50.0, 50.0, 100.0]);
+    assert_eq!(undo_steps(&app), steps + 1, "one undo step");
+
+    choose(&mut app, "Duplicate Artboards");
+    assert_eq!(board_names(&app).len(), 6);
+    assert_eq!(undo_steps(&app), steps + 2, "one undo step");
+    assert_eq!(app.session.tool_options()["selected"], json!([5, 4]), "the copies are selected, artboard 3's copy active");
+    assert_eq!(app.view().unwrap().artboard, 5);
+
+    choose(&mut app, "Delete Artboards");
+    assert_eq!(board_names(&app).len(), 4);
+    assert_eq!(undo_steps(&app), steps + 3, "one undo step");
+    assert_eq!(selected(&app, 4), 3, "the artboard before the first one deleted is active");
+    assert_eq!(app.session.tool_options()["selected"], json!([3]), "and the only one selected");
+
+    choose(&mut app, "New Artboard");
+    assert_eq!(board_names(&app).len(), 5);
+    assert_eq!(selected(&app, 5), 4, "the new artboard is active");
+    assert_eq!(app.session.tool_options()["selected"], json!([4]), "and the only one selected");
+
+    choose(&mut app, "Select All Artboards");
+    assert_eq!(app.session.tool_options()["selected"], json!([4, 0, 1, 2, 3]));
+    assert_eq!(undo_steps(&app), steps + 4, "selecting records no undo step");
+    assert_eq!(selected(&app, 5), 4, "the active artboard stays active");
+}
+
+/// Cut and Copy from the menu take the selected artboards, in one undo step for the cut.
+#[test]
+fn the_artboard_tools_menu_cuts_and_copies_the_selected_artboards() {
+    let mut app = menu_app(4);
+    app.session.set_tool_option("selected", &json!([1, 2]));
+    app.view_mut().unwrap().artboard = 1;
+    choose(&mut app, "Copy");
+    assert_eq!(board_names(&app).len(), 4);
+    assert_eq!(app.session.clipboard.artboards.len(), 2);
+    let steps = undo_steps(&app);
+    choose(&mut app, "Cut");
+    assert_eq!(board_names(&app), ["Artboard 1", "Artboard 4"]);
+    assert_eq!(undo_steps(&app), steps + 1, "one undo step");
+}
+
+/// The menu's Cut and Copy record which artboards they took, so a replay in a new session, where
+/// the Artboard tool isn't chosen, acts on the same artboards.
+#[test]
+fn the_artboard_tools_menu_replays_its_cut_and_copy_in_a_new_session() {
+    let mut app = menu_app(4);
+    app.session.set_tool_option("selected", &json!([1, 2]));
+    app.view_mut().unwrap().artboard = 1;
+    choose(&mut app, "Copy");
+    let (cmd, p) = app.session.journal.last().unwrap().clone();
+    assert_eq!((cmd.as_str(), &p["selectedArtboards"]), ("artboard.copy", &json!([1, 2])));
+    choose(&mut app, "Cut");
+    let (cmd, p) = app.session.journal.last().unwrap().clone();
+    assert_eq!((cmd.as_str(), &p["selectedArtboards"]), ("artboard.cut", &json!([1, 2])));
+    let mut replay = Session::new();
+    for (id, p) in &app.session.journal {
+        replay.execute(id, p).unwrap();
+    }
+    let names: Vec<String> = replay.active().unwrap().doc.artboards.iter().map(|a| a.name.clone()).collect();
+    assert_eq!(names, ["Artboard 1", "Artboard 4"]);
+    assert_eq!(replay.clipboard.artboards.len(), 2);
+}
+
+/// The menu's Cut and Copy publish the copied art to the system clipboard, as Edit › Cut and Copy do.
+#[test]
+fn the_artboard_tools_menu_publishes_its_cut_and_copy() {
+    let mut app = menu_app(2);
+    let on = app.session.active().unwrap().doc.artboards[1].rect;
+    app.session.execute("shape.rectangle", &json!({"x": on.x0 + 10.0, "y": on.y0 + 10.0, "width": 20, "height": 20})).unwrap();
+    app.session.set_tool_option("selected", &json!([1]));
+    app.view_mut().unwrap().artboard = 1;
+    for label in ["Copy", "Cut"] {
+        app.clipboard_out = None;
+        choose(&mut app, label);
+        assert!(app.clipboard_out.as_deref().is_some_and(|svg| svg.contains("<svg")), "{label}");
+    }
+}
+
+/// The menu's Cut and Copy show the keys that run them with the tool chosen.
+#[test]
+fn the_artboard_tools_menu_shows_the_cut_and_copy_shortcuts() {
+    use crate::menus::Item;
+    let app = menu_app(2);
+    let items = crate::menus::context_items(&app);
+    for (label, keys) in [("Cut", "edit.cut"), ("Copy", "edit.copy")] {
+        let Some(Item::Cmd(_, id, p)) = items.iter().find(|i| matches!(i, Item::Cmd(l, ..) if *l == label)) else { panic!("no {label}") };
+        let want = crate::menus::shortcut_of(keys);
+        assert!(want.is_some(), "{keys}");
+        assert_eq!(crate::menus::item_shortcut(id, p), want, "{label}");
+    }
+}
+
+/// Fit to Artwork Bounds fits the selected artboards only, in one undo step, and Undo from the menu
+/// takes the step back.
+#[test]
+fn the_artboard_tools_menu_fits_the_selected_artboards_and_undoes() {
+    let mut app = menu_app(2);
+    let rects = |app: &VectorcraftApp| app.session.active().unwrap().doc.artboards.iter().map(|a| a.rect).collect::<Vec<_>>();
+    let before = rects(&app);
+    let on = |r: vectorcraft_geom::Rect| json!({"x": r.x0 + 10.0, "y": r.y0 + 10.0, "width": 20, "height": 20});
+    app.session.execute("shape.rectangle", &on(before[0])).unwrap();
+    app.session.execute("shape.rectangle", &on(before[1])).unwrap();
+    app.session.set_tool_option("selected", &json!([1]));
+    app.view_mut().unwrap().artboard = 1;
+    let steps = undo_steps(&app);
+    choose(&mut app, "Fit to Artwork Bounds");
+    let fitted = rects(&app);
+    assert_eq!(fitted[0], before[0], "the artboard that isn't selected stays");
+    assert_eq!((fitted[1].width(), fitted[1].height()), (21.0, 21.0), "the rectangle with its 1 pt stroke");
+    assert_eq!(undo_steps(&app), steps + 1, "one undo step");
+    choose(&mut app, "Undo");
+    assert_eq!(rects(&app), before);
+}
+
+/// Delete Empty Artboards leaves a remaining artboard active, and the dialog entries open their
+/// dialogs: Rename, Rearrange, Artboard Options and Export.
+#[test]
+fn the_artboard_tools_menu_deletes_empty_artboards_and_opens_dialogs() {
+    let mut app = menu_app(3);
+    app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+    for (label, kind) in [
+        ("Rename", crate::dialogs::rename_artboards::KIND),
+        ("Rearrange", crate::dialogs::rearrange_artboards::KIND),
+        ("Artboard Options", "artboardOptions"),
+        ("Export", crate::dialogs::EXPORT_FOR_SCREENS),
+    ] {
+        choose(&mut app, label);
+        assert_eq!(app.ui.dialog.take().map(|d| d.kind).as_deref(), Some(kind), "{label}");
+    }
+    select(&mut app, 2);
+    choose(&mut app, "Delete Empty Artboards");
+    assert_eq!(board_names(&app), ["Artboard 1"]);
+    assert_eq!(selected(&app, 1), 0);
+}
+
+/// A lock entry lists only the artboards it changes and is left out when it has none, so it never
+/// records an undo step that changes nothing.
+#[test]
+fn the_artboard_tools_lock_entries_have_something_to_change() {
+    use crate::menus::Item;
+    let mut app = menu_app(2);
+    app.session.execute("artboard.setProps", &json!({"index": 0, "locked": true})).unwrap();
+    let items = crate::menus::context_items(&app);
+    let subs = |menu: &str| match items.iter().find(|i| matches!(i, Item::Sub(t, _) if *t == menu)) {
+        Some(Item::Sub(_, subs)) => menu_labels(subs),
+        _ => vec![],
+    };
+    assert_eq!(subs("Lock Artboards"), ["Lock All Except Selected", "Lock All"], "the selected artboard is locked already");
+    assert_eq!(subs("Unlock Artboards"), ["Unlock Selected", "Unlock All"]);
+}
+
+/// A right-click on an artboard that isn't selected selects it alone; on a selected one the selection
+/// stays; off every artboard it stays too.
+#[test]
+fn a_right_click_with_the_artboard_tool_selects_the_artboard_under_the_pointer() {
+    use vectorcraft_geom::Point;
+    let mut app = menu_app(3);
+    let doc = &app.session.active().unwrap().doc;
+    let (a, c) = (doc.artboards[0].rect.center(), doc.artboards[2].rect.center());
+    app.session.set_tool_option("selected", &json!([0, 1]));
+    right_click(&mut app, a);
+    assert_eq!(app.session.tool_options()["selected"], json!([0, 1]), "a selected artboard keeps the selection");
+    right_click(&mut app, Point::new(-500.0, -500.0));
+    assert_eq!(app.session.tool_options()["selected"], json!([0, 1]), "off every artboard");
+    right_click(&mut app, c);
+    assert_eq!(app.session.tool_options()["selected"], json!([2]));
+    assert_eq!(app.view().unwrap().artboard, 2);
+}
+
+/// Paste from the Artboard tool's menu centers the copied artboards on the right-click's point. With
+/// no point it puts them right of the last artboard.
+#[test]
+fn the_artboard_tools_paste_goes_to_the_right_click() {
+    use vectorcraft_geom::Point;
+    let mut app = menu_app(2);
+    app.run("edit.copy", json!({})).unwrap();
+    right_click(&mut app, Point::new(-300.0, 700.0));
+    choose(&mut app, "Paste");
+    let doc = &app.session.active().unwrap().doc;
+    assert_eq!(doc.artboards.len(), 3);
+    let at = doc.artboards[2].rect.center();
+    assert_eq!((at.x, at.y), (-300.0, 700.0));
+    app.ui.context_artboards = None;
+    choose(&mut app, "Paste");
+    let doc = &app.session.active().unwrap().doc;
+    let right = doc.artboards.iter().take(3).map(|a| a.rect.x1).fold(f64::MIN, f64::max);
+    assert_eq!(doc.artboards[3].rect.x0, right + 20.0);
+}
+
+/// While the menu is open it reads what the right-click measured and does not walk the art again:
+/// what it measured stands until the document or the selection changes.
+#[test]
+fn the_open_menu_reads_what_the_right_click_measured() {
+    use vectorcraft_geom::Point;
+    let mut app = menu_app(2);
+    right_click(&mut app, Point::new(10.0, 10.0));
+    let facts = app.ui.context_artboards.as_mut().unwrap();
+    assert!(facts.any_empty && !facts.any_art);
+    // Facts that differ from the document show which one the menu reads.
+    facts.any_empty = false;
+    facts.any_art = true;
+    let labels = menu_labels(&crate::menus::context_items(&app));
+    assert!(!labels.contains(&"Delete Empty Artboards") && labels.contains(&"Fit to Artwork Bounds"), "{labels:?}");
+    // An edit makes them out of date, and the menu measures again.
+    app.session.execute("artboard.setProps", &json!({"index": 1, "name": "Other"})).unwrap();
+    let labels = menu_labels(&crate::menus::context_items(&app));
+    assert!(labels.contains(&"Delete Empty Artboards") && !labels.contains(&"Fit to Artwork Bounds"), "{labels:?}");
+}
+
+/// `artboard.selectAll` chooses the Artboard tool first when another tool is in use, and fails
+/// without a document.
+#[test]
+fn select_all_artboards_chooses_the_tool_and_needs_a_document() {
+    let mut app = menu_app(2);
+    app.select_tool("selection");
+    assert_eq!(app.run("artboard.selectAll", json!({})).unwrap()["selected"], json!([0, 1]));
+    assert_eq!(app.session.tool_id(), "artboard");
+    let mut empty = VectorcraftApp::new(Session::new(), Default::default());
+    assert_eq!(empty.run("artboard.selectAll", json!({})).unwrap_err(), "no document");
+}
diff --git a/crates/ui-egui/src/panels/character.rs b/crates/ui-egui/src/panels/character.rs
index 7e68824c1..9dd969c5c 100644
--- a/crates/ui-egui/src/panels/character.rs
+++ b/crates/ui-egui/src/panels/character.rs
@@ -499,18 +499,16 @@ pub(crate) fn text_editing(app: &VectorcraftApp) -> Option<(NodeId, usize, usize
 }
 
 /// The frames of the threaded story whose whole text the Type tool has selected after Select All,
-/// in thread order; `None` when its selection is in one type object.
+/// in the order of the edited frame's thread as the document holds it now; `None` when its
+/// selection is in one type object.
 pub(crate) fn text_story(app: &VectorcraftApp) -> Option<Vec<NodeId>> {
     let o = app.session.tool_options();
     let st = app.session.active()?;
-    let ids: Vec<NodeId> = o
-        .get("story")?
-        .as_array()?
-        .iter()
-        .filter_map(Value::as_u64)
-        .map(NodeId)
-        .filter(|id| st.doc.node(*id).is_some_and(|n| matches!(n.kind, NodeKind::Text(_))))
-        .collect();
+    let id = NodeId(o.get("editing")?.as_u64()?);
+    if o.get("story")?.as_array()?.is_empty() {
+        return None;
+    }
+    let ids = st.doc.story_of(id);
     (ids.len() >= 2).then_some(ids)
 }
 
@@ -540,11 +538,13 @@ static CLIP_RUNS: Mutex<Option<Value>> = Mutex::new(None);
 
 fn text_copy(app: &mut VectorcraftApp) -> bool {
     let Some((id, a, b)) = text_editing(app) else { return false };
-    if a == b {
+    let story = text_story(app);
+    // An empty selection has nothing to copy, unless the story's text is in the other frames.
+    if a == b && (story.is_none() || app.session.active().is_none_or(|st| st.doc.story_text(id).is_empty())) {
         return false;
     }
     // After Select All in threaded text: the whole story.
-    let range = if text_story(app).is_some() { json!({"id": id.0, "story": true}) } else { json!({"id": id.0, "start": a, "end": b}) };
+    let range = if story.is_some() { json!({"id": id.0, "story": true}) } else { json!({"id": id.0, "start": a, "end": b}) };
     let Ok(r) = app.session.execute("text.getRange", &range) else { return false };
     let runs = r["runs"].clone();
     app.session.set_tool_option("copy", &runs);
diff --git a/crates/ui-egui/src/panels/character/tests.rs b/crates/ui-egui/src/panels/character/tests.rs
index 2a3519385..577a081ef 100644
--- a/crates/ui-egui/src/panels/character/tests.rs
+++ b/crates/ui-egui/src/panels/character/tests.rs
@@ -1244,6 +1244,50 @@ fn snap_to_glyph_options_scroll_into_view_and_turn_snapping_on() {
     assert!(!app.session.prefs.glyph_snap.anchors, "the options take clicks once it is on");
 }
 
+/// Copy and Cut take a selected story after a frame threaded in before the edited one took its whole
+/// text.
+#[test]
+fn copy_and_cut_take_a_story_that_left_the_edited_frame() {
+    for cut in [false, true] {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 600, "height": 300})).unwrap();
+        let story = "The quick brown fox jumps over the lazy dog and keeps running far beyond the first frame. ".repeat(4);
+        let area = json!({"x": 10, "y": 10, "text": story, "size": 12, "area": {"width": 150, "height": 60}});
+        let a = app.run("text.create", area).unwrap()["id"].as_u64().unwrap();
+        let b = app.run("shape.rectangle", json!({"x": 200, "y": 10, "width": 150, "height": 200})).unwrap()["id"].as_u64().unwrap();
+        app.run("select.set", json!({"ids": [a, b]})).unwrap();
+        app.run("text.thread.create", json!({})).unwrap();
+        app.session.select_tool("type", Default::default()).unwrap();
+        app.session.set_tool_option("textSelection", &json!({"editing": a, "anchor": 0, "caret": 0}));
+        app.run("select.all", json!({})).unwrap();
+        let c = app.run("text.thread.add", json!({"from": a, "before": true, "rect": [700, 10, 400, 600]})).unwrap()["id"].as_u64().unwrap();
+        let text = |app: &VectorcraftApp, id: u64| match &app.session.active().unwrap().doc.node(NodeId(id)).unwrap().kind {
+            NodeKind::Text(t) => t.plain_text(),
+            _ => panic!("not text"),
+        };
+        assert_eq!((text(&app, a), text(&app, b), text(&app, c)), (String::new(), String::new(), story.clone()));
+        assert!(intercept_text_command(&mut app, if cut { "edit.cut" } else { "edit.copy" }).is_some());
+        let copied: Vec<String> = app
+            .session
+            .clipboard
+            .nodes
+            .iter()
+            .filter_map(|n| match &n.kind {
+                NodeKind::Text(t) => Some(t.plain_text()),
+                _ => None,
+            })
+            .collect();
+        assert_eq!(copied, std::slice::from_ref(&story), "cut: {cut}");
+        assert_eq!(text(&app, c).is_empty(), cut);
+        if cut {
+            // A story that holds no text has nothing to copy, so Cut does not run its delete.
+            app.run("select.all", json!({})).unwrap();
+            assert_eq!(text_story(&app).map(|frames| frames.len()), Some(3));
+            assert!(!text_copy(&mut app));
+        }
+    }
+}
+
 /// After Select All in a frame of threaded text, the Character and Paragraph panels and Copy act on
 /// the text of every frame of the story.
 #[test]
@@ -1285,3 +1329,105 @@ fn select_all_in_threaded_text_formats_and_copies_the_whole_story() {
         .collect();
     assert_eq!(copied, [story]);
 }
+
+/// A story threaded through three frames in order, the first `height` tall.
+fn three_frame_story(height: u32) -> (VectorcraftApp, u64, u64, u64) {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 900, "height": 300})).unwrap();
+    let story = "The quick brown fox jumps over the lazy dog and keeps running far beyond the first frame. ".repeat(6);
+    let area = json!({"x": 10, "y": 10, "text": story, "size": 12, "area": {"width": 150, "height": height}});
+    let a = app.run("text.create", area).unwrap()["id"].as_u64().unwrap();
+    let b = app.run("text.thread.add", json!({"from": a, "rect": [200, 10, 150, 60]})).unwrap()["id"].as_u64().unwrap();
+    let c = app.run("text.thread.add", json!({"from": b, "rect": [400, 10, 150, 200]})).unwrap()["id"].as_u64().unwrap();
+    (app, a, b, c)
+}
+
+/// Select All with the Type tool in frame `id` of a story.
+fn select_all_from(app: &mut VectorcraftApp, id: u64) {
+    app.run("select.set", json!({"ids": [id]})).unwrap();
+    app.session.select_tool("type", Default::default()).unwrap();
+    app.session.set_tool_option("textSelection", &json!({"editing": id, "anchor": 0, "caret": 0}));
+    app.run("select.all", json!({})).unwrap();
+}
+
+fn story_frame(app: &VectorcraftApp, id: u64) -> vectorcraft_doc::TextObject {
+    match &app.session.active().unwrap().doc.node(NodeId(id)).unwrap().kind {
+        NodeKind::Text(t) => (**t).clone(),
+        _ => panic!("not text"),
+    }
+}
+
+fn story_sizes(app: &VectorcraftApp, id: u64) -> Vec<f64> {
+    story_frame(app, id).runs.iter().map(|r| r.style.size).collect()
+}
+
+/// The frames that Select All saved are not the frames of the story once the first of them has
+/// left the thread: the edited frame's story takes the change.
+#[test]
+fn story_changes_follow_the_edited_frames_thread_after_the_first_saved_frame_leaves() {
+    // The first frame is too short for a line, so Select All edits the second.
+    let (mut app, a, b, c) = three_frame_story(1);
+    select_all_from(&mut app, c);
+    assert_eq!(app.session.tool_options()["story"], json!([a, b, c]));
+    assert_eq!(text_editing(&app).unwrap().0, NodeId(b));
+    app.run("text.thread.break", json!({"id": a, "port": "out"})).unwrap();
+    assert_eq!(text_editing(&app).unwrap().0, NodeId(b));
+
+    assert_eq!(text_story(&app), Some(vec![NodeId(b), NodeId(c)]));
+    format(&mut app, json!({"size": 9}));
+    assert!(story_sizes(&app, a).iter().all(|s| (*s - 12.0).abs() < 1e-9), "the frame that left keeps its size");
+    for id in [b, c] {
+        assert!(story_sizes(&app, id).iter().all(|s| (*s - 9.0).abs() < 1e-9), "frame {id} takes the size");
+    }
+}
+
+/// A frame that left the thread after Select All takes no change, and a frame added to it does.
+#[test]
+fn story_changes_leave_out_a_frame_that_left_and_take_in_a_frame_that_joined() {
+    let (mut app, a, b, c) = three_frame_story(60);
+    select_all_from(&mut app, c);
+    assert_eq!(text_editing(&app).unwrap().0, NodeId(a));
+    app.run("text.thread.break", json!({"id": b, "port": "out"})).unwrap();
+    assert_eq!(text_story(&app), Some(vec![NodeId(a), NodeId(b)]));
+    let d = app.run("text.thread.add", json!({"from": a, "rect": [600, 10, 150, 60]})).unwrap()["id"].as_u64().unwrap();
+    assert_eq!(text_story(&app), Some(vec![NodeId(a), NodeId(d), NodeId(b)]));
+
+    crate::panels::paragraph::run_on_paragraphs(&mut app, "text.setFormat", json!({"spaceBefore": 4})).unwrap();
+    for id in [a, d, b] {
+        assert!((story_frame(&app, id).para_at(0).space_before - 4.0).abs() < 1e-9, "frame {id} takes the space");
+    }
+    assert!(story_frame(&app, c).para_at(0).space_before.abs() < 1e-9, "the frame that left keeps its paragraphs");
+}
+
+/// With the thread gone, the selection is in the one edited frame.
+#[test]
+fn story_changes_stay_in_the_edited_frame_once_its_thread_is_removed() {
+    let (mut app, a, b, c) = three_frame_story(60);
+    select_all_from(&mut app, c);
+    assert_eq!(text_editing(&app).unwrap().0, NodeId(a));
+    app.run("text.thread.remove", json!({})).unwrap();
+    assert_eq!(text_story(&app), None);
+
+    crate::panels::paragraph::run_on_paragraphs(&mut app, "text.setFormat", json!({"spaceBefore": 4})).unwrap();
+    assert!((story_frame(&app, a).para_at(0).space_before - 4.0).abs() < 1e-9);
+    for id in [b, c] {
+        assert!(story_frame(&app, id).para_at(0).space_before.abs() < 1e-9, "frame {id} keeps its paragraphs");
+    }
+}
+
+/// A selected story is one text: its locked and hidden frames take the change too.
+#[test]
+fn story_changes_take_in_locked_and_hidden_frames() {
+    let (mut app, a, b, c) = three_frame_story(60);
+    app.run("select.set", json!({"ids": [b]})).unwrap();
+    app.run("object.lock", json!({})).unwrap();
+    app.run("select.set", json!({"ids": [c]})).unwrap();
+    app.run("object.hide", json!({})).unwrap();
+    select_all_from(&mut app, a);
+    assert_eq!(text_story(&app), Some(vec![NodeId(a), NodeId(b), NodeId(c)]));
+
+    format(&mut app, json!({"size": 9}));
+    for id in [a, b, c] {
+        assert_eq!(story_sizes(&app, id).iter().filter(|s| (**s - 9.0).abs() > 1e-9).count(), 0, "frame {id} takes the size");
+    }
+}
diff --git a/crates/ui-egui/src/panels/properties.rs b/crates/ui-egui/src/panels/properties.rs
index 306a9323f..8f3af21b0 100644
--- a/crates/ui-egui/src/panels/properties.rs
+++ b/crates/ui-egui/src/panels/properties.rs
@@ -507,8 +507,8 @@ fn artboard_sections(app: &mut VectorcraftApp, ui: &mut Ui) {
     ui.add_space(4.0);
     let w = (ui.available_width() - 6.0) / 2.0;
     ui.horizontal(|ui| {
-        if widgets::flat_button(ui, tl!("New Artboard"), w).clicked() && app.run("artboard.new", json!({})).is_ok() {
-            super::artboards::select(app, n);
+        if widgets::flat_button(ui, tl!("New Artboard"), w).clicked() {
+            super::artboards::add_new(app);
         }
         let deletable = n > 1 && !super::artboards::deletable(app, n).is_empty();
         if ui.add_enabled_ui(deletable, |ui| widgets::flat_button(ui, tl!("Delete Artboard"), w)).inner.clicked() {
diff --git a/crates/ui-egui/src/panels/tabs.rs b/crates/ui-egui/src/panels/tabs.rs
index d1b4b57fc..a1a8c7fb1 100644
--- a/crates/ui-egui/src/panels/tabs.rs
+++ b/crates/ui-egui/src/panels/tabs.rs
@@ -72,11 +72,18 @@ fn append_indent_targets(node: &Node, range: std::ops::Range<usize>, targets: &m
     }));
 }
 
-/// Paragraphs touched by the Type selection, or all paragraphs of selected text objects.
+/// Paragraphs touched by the Type selection (every paragraph of every frame after Select All in
+/// threaded text), or all paragraphs of selected text objects.
 fn indent_targets(app: &VectorcraftApp, node: &Node) -> Vec<IndentTarget> {
     let mut targets = Vec::new();
     if let Some((_, a, b)) = super::character::text_editing(app) {
-        if let NodeKind::Text(text) = &node.kind {
+        if let (Some(story), Some(st)) = (super::character::text_story(app), app.session.active()) {
+            for frame in story.iter().filter_map(|id| st.doc.node(*id)) {
+                if let NodeKind::Text(text) = &frame.kind {
+                    append_indent_targets(frame, 0..text.paragraph_count(), &mut targets);
+                }
+            }
+        } else if let NodeKind::Text(text) = &node.kind {
             append_indent_targets(node, text.paragraphs_in(a, b), &mut targets);
         }
     } else if let Some(st) = app.session.active() {
@@ -174,7 +181,9 @@ fn paint_markers(ui: &mut Ui, painter: &egui::Painter, tokens: &Tokens, view: Ma
     }
 }
 
-/// Apply an absolute ruler position through paragraph-format commands.
+/// Apply an absolute ruler position through paragraph-format commands. Paragraphs that need values
+/// of their own get one command each, the story's last paragraph first: threaded text re-flows
+/// after each command, and a re-flow moves only text after the paragraph that changed.
 fn set_marker(app: &mut VectorcraftApp, marker: IndentMarker, target: f64, para: &ParaStyle, span: f64, targets: &[IndentTarget], both: bool) {
     if targets.is_empty() || !target.is_finite() {
         return;
@@ -189,6 +198,7 @@ fn set_marker(app: &mut VectorcraftApp, marker: IndentMarker, target: f64, para:
             super::character::end_typing(app);
             let commands: Vec<Value> = targets
                 .iter()
+                .rev()
                 .map(|p| {
                     json!({"command": "text.setFormat", "params": {
                         "ids": [p.id], "start": p.start, "end": p.start, "firstLineIndent": target - p.left
@@ -215,6 +225,7 @@ fn set_marker(app: &mut VectorcraftApp, marker: IndentMarker, target: f64, para:
         super::character::end_typing(app);
         let commands: Vec<Value> = targets
             .iter()
+            .rev()
             .map(|p| {
                 json!({"command": "text.setFormat", "params": {
                     "ids": [p.id], "start": p.start, "end": p.start,
diff --git a/crates/ui-egui/src/panels/tabs/tests.rs b/crates/ui-egui/src/panels/tabs/tests.rs
index 7a92ff80c..3244ba243 100644
--- a/crates/ui-egui/src/panels/tabs/tests.rs
+++ b/crates/ui-egui/src/panels/tabs/tests.rs
@@ -404,6 +404,140 @@ fn lower_marker_keeps_each_first_line_position_in_one_undo_step() {
     assert_eq!(indent_values(&app, 1), (40.0, 28.0));
 }
 
+/// After Select All in threaded text, a marker change keeps the left indent and first-line position
+/// of each paragraph in every frame of the story, when the edited frame's paragraphs agree and
+/// another frame's differ.
+#[test]
+fn indent_markers_after_select_all_keep_each_story_paragraphs_indents() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 600, "height": 300})).unwrap();
+    let story = (1..=12).map(|i| format!("line {i}")).collect::<Vec<_>>().join("\n");
+    let a = app.run("text.create", json!({"x": 10, "y": 10, "text": story, "size": 12, "area": {"width": 200, "height": 60}})).unwrap()["id"]
+        .as_u64()
+        .unwrap();
+    app.run("text.setFormat", json!({"ids": [a], "leftIndent": 24, "firstLineIndent": 12})).unwrap();
+    let b = app.run("text.thread.add", json!({"from": a, "rect": [300, 10, 200, 250]})).unwrap()["id"].as_u64().unwrap();
+    app.run("text.setFormat", json!({"ids": [b], "leftIndent": 60, "firstLineIndent": -10})).unwrap();
+    let paragraphs = |app: &VectorcraftApp| -> Vec<(u64, f64, f64)> {
+        let st = app.session.active().unwrap();
+        [a, b]
+            .into_iter()
+            .flat_map(|id| match &st.doc.node(vectorcraft_doc::NodeId(id)).unwrap().kind {
+                NodeKind::Text(t) => {
+                    (0..t.paragraph_count()).map(|i| (id, t.para_at(i).left_indent, t.para_at(i).first_line_indent)).collect::<Vec<_>>()
+                }
+                _ => panic!("not text"),
+            })
+            .collect()
+    };
+    assert!(paragraphs(&app).iter().any(|p| p.1 == 24.0) && paragraphs(&app).iter().any(|p| p.1 == 60.0), "{:?}", paragraphs(&app));
+    let select_all = |app: &mut VectorcraftApp| {
+        app.run("select.set", json!({"ids": [a]})).unwrap();
+        app.session.select_tool("type", Default::default()).unwrap();
+        app.session.set_tool_option("textSelection", &json!({"editing": a, "anchor": 0, "caret": 0}));
+        app.run("select.all", json!({})).unwrap();
+        assert_eq!(super::super::character::text_story(app), Some(vec![vectorcraft_doc::NodeId(a), vectorcraft_doc::NodeId(b)]));
+    };
+    select_all(&mut app);
+
+    let before = paragraphs(&app);
+    let (node, para, span) = current_para(&app).unwrap();
+    assert_eq!(node.id.0, a);
+    let targets = indent_targets(&app, &node);
+    set_marker(&mut app, IndentMarker::Upper, 70.0, &para, span, &targets, false);
+    let after = paragraphs(&app);
+    assert_eq!(after.len(), before.len());
+    for (was, now) in before.iter().zip(&after) {
+        assert_eq!((now.1, now.1 + now.2), (was.1, 70.0), "a paragraph of frame {} keeps its left indent: {after:?}", now.0);
+    }
+    app.run("edit.undo", json!({})).unwrap();
+    assert_eq!(paragraphs(&app), before);
+
+    select_all(&mut app);
+    let (node, para, span) = current_para(&app).unwrap();
+    let targets = indent_targets(&app, &node);
+    set_marker(&mut app, IndentMarker::Lower, 40.0, &para, span, &targets, false);
+    let after = paragraphs(&app);
+    assert_eq!(after.len(), before.len());
+    for (was, now) in before.iter().zip(&after) {
+        assert_eq!((now.1, now.1 + now.2), (40.0, was.1 + was.2), "a paragraph of frame {} keeps its first-line position: {after:?}", now.0);
+    }
+}
+
+/// After Select All in threaded text with mixed indents, a marker change that makes the first
+/// frame's paragraphs wrap onto more lines pushes text into the next frame while the change is
+/// applied. Every paragraph of the story still gets the new position: the upper marker keeps each
+/// left indent, and the lower marker keeps each first-line position.
+#[test]
+fn indent_markers_after_select_all_follow_text_that_reflows_into_the_next_frame() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 600, "height": 1000})).unwrap();
+    let story = (1..=12).map(|i| format!("p{i} aaa bbb ccc")).collect::<Vec<_>>().join("\n");
+    let a = app.run("text.create", json!({"x": 10, "y": 10, "text": story, "size": 12, "area": {"width": 200, "height": 60}})).unwrap()["id"]
+        .as_u64()
+        .unwrap();
+    let b = app.run("text.thread.add", json!({"from": a, "rect": [300, 10, 200, 950]})).unwrap()["id"].as_u64().unwrap();
+    app.run("text.setFormat", json!({"ids": [b], "leftIndent": 10})).unwrap();
+    // Each paragraph of the story by its first word, with its left indent and first-line position;
+    // a paragraph continued from the frame before is counted once. No paragraph of the story is
+    // empty, so an empty piece (after a frame's last line break) is not one.
+    let paragraphs = |app: &VectorcraftApp| -> Vec<(String, f64, f64)> {
+        let st = app.session.active().unwrap();
+        [a, b]
+            .into_iter()
+            .flat_map(|id| match &st.doc.node(vectorcraft_doc::NodeId(id)).unwrap().kind {
+                NodeKind::Text(t) => t
+                    .plain_text()
+                    .split('\n')
+                    .enumerate()
+                    .filter(|(i, text)| !text.is_empty() && (*i > 0 || !t.first_para_continues))
+                    .map(|(i, text)| {
+                        let p = t.para_at(i);
+                        (text.split(' ').next().unwrap_or_default().to_string(), p.left_indent, p.left_indent + p.first_line_indent)
+                    })
+                    .collect::<Vec<_>>(),
+                _ => panic!("not text"),
+            })
+            .collect()
+    };
+    let in_a = |app: &VectorcraftApp| match &app.session.active().unwrap().doc.node(vectorcraft_doc::NodeId(a)).unwrap().kind {
+        NodeKind::Text(t) => t.plain_text().len(),
+        _ => panic!("not text"),
+    };
+    // Select All in the first frame and move `marker` to `to` → the story's paragraphs before and
+    // after.
+    let apply = |app: &mut VectorcraftApp, marker, to| {
+        let before = paragraphs(app);
+        assert_eq!(before.len(), 12, "{before:?}");
+        let shown = in_a(app);
+        app.run("select.set", json!({"ids": [a]})).unwrap();
+        app.session.select_tool("type", Default::default()).unwrap();
+        app.session.set_tool_option("textSelection", &json!({"editing": a, "anchor": 0, "caret": 0}));
+        app.run("select.all", json!({})).unwrap();
+        let (node, para, span) = current_para(app).unwrap();
+        let targets = indent_targets(app, &node);
+        set_marker(app, marker, to, &para, span, &targets, false);
+        let after = paragraphs(app);
+        assert!(in_a(app) < shown, "the first frame holds less text once it wraps: {} of {shown} bytes, {after:?}", in_a(app));
+        assert_eq!(after.iter().map(|p| &p.0).collect::<Vec<_>>(), before.iter().map(|p| &p.0).collect::<Vec<_>>());
+        (before, after)
+    };
+    let (before, after) = apply(&mut app, IndentMarker::Upper, 150.0);
+    assert!(before.iter().any(|p| p.1 == 0.0) && before.iter().any(|p| p.1 == 10.0), "{before:?}");
+    for (was, now) in before.iter().zip(&after) {
+        assert_eq!((now.1, now.2), (was.1, 150.0), "{} keeps its left indent and starts at 150 pt: {after:?}", now.0);
+    }
+    app.run("edit.undo", json!({})).unwrap();
+    assert_eq!(paragraphs(&app), before);
+    // First lines at 150 and 160 pt; a left indent of 180 pt leaves room for one word a line.
+    app.run("text.setFormat", json!({"ids": [a, b], "firstLineIndent": 150})).unwrap();
+    let (before, after) = apply(&mut app, IndentMarker::Lower, 180.0);
+    assert!(before.iter().any(|p| p.2 == 150.0) && before.iter().any(|p| p.2 == 160.0), "{before:?}");
+    for (was, now) in before.iter().zip(&after) {
+        assert_eq!((now.1, now.2), (180.0, was.2), "{} is indented 180 pt and keeps its first-line position: {after:?}", now.0);
+    }
+}
+
 #[test]
 fn lower_marker_bounds_cover_each_touched_first_line() {
     let targets = [IndentTarget { id: 1, start: 0, left: 24.0, first_line: -20.0 }, IndentTarget { id: 1, start: 4, left: 24.0, first_line: 280.0 }];
diff --git a/crates/ui-egui/src/panels/tests_constrain.rs b/crates/ui-egui/src/panels/tests_constrain.rs
index a90f2b55d..b5e8ed7f7 100644
--- a/crates/ui-egui/src/panels/tests_constrain.rs
+++ b/crates/ui-egui/src/panels/tests_constrain.rs
@@ -296,3 +296,114 @@ fn the_link_is_a_preference_agents_can_read_and_set() {
     run(&mut app, "object.setBounds", json!({"height": 100, "reference": 4, "proportional": true}));
     assert_eq!(size(&app), (200.0, 100.0));
 }
+
+/// One Tab moves from a field to the next field: a field's label (its scrub zone) is not a tab
+/// stop of its own, and the W/H link between W and H, which is still focusable, comes after the
+/// fields. In the Transform panel and the Properties panel the fields run X, W, Y, H (a grid, two
+/// to a row); in the Control bar X, Y, W, H.
+#[test]
+fn one_tab_moves_from_a_field_to_the_next() {
+    // From X (the selection's centre, 60 pt) the next field is W in the panels and Y in the bar.
+    for (name, draw, next) in [
+        ("Transform panel", transform::show as Draw, "width"),
+        ("Properties", properties::transform_section as Draw, "width"),
+        ("Control bar", crate::chrome::control_bar as Draw, "y"),
+    ] {
+        let mut app = rect_app();
+        tab_then_type(&mut app, draw, "60 pt", "200");
+        let st = app.session.active().unwrap();
+        let b = st.doc.bounds_of(&st.selection.objects, false).unwrap();
+        match next {
+            "width" => assert_eq!(size(&app), (200.0, 50.0), "{name}: Tab went from X to W"),
+            _ => assert_eq!((b.width().round(), b.y0.round()), (100.0, 175.0), "{name}: Tab went from X to Y"),
+        }
+    }
+    // In the Control bar the W/H link sits between W and H: Tab goes from W straight to H.
+    let mut app = rect_app();
+    tab_then_type(&mut app, crate::chrome::control_bar, "100 pt", "200");
+    assert_eq!(size(&app), (100.0, 200.0), "Control bar: Tab went from W to H");
+    // The Artboard tool's Control bar puts the link after its fields too: Tab goes from W to H.
+    let mut app = rect_app();
+    app.select_tool("artboard");
+    tab_then_type(&mut app, crate::chrome::control_bar, "400 pt", "200");
+    let r = app.session.doc().unwrap().doc.artboards[0].rect;
+    assert_eq!((r.width().round(), r.height().round()), (400.0, 200.0), "Artboard Control bar: Tab went from W to H");
+    // Shift+Tab goes back one field, one press too: from W to X in the panels.
+    for (name, draw) in [("Transform panel", transform::show as Draw), ("Properties", properties::transform_section as Draw)] {
+        let mut app = rect_app();
+        shift_tab_then_type(&mut app, draw, "100 pt", "200");
+        let st = app.session.active().unwrap();
+        let b = st.doc.bounds_of(&st.selection.objects, false).unwrap();
+        assert_eq!((b.width().round(), b.x0.round()), (100.0, 150.0), "{name}: Shift+Tab went from W to X");
+    }
+}
+
+/// A click on the Control bar's W/H link toggles Constrain Width and Height Proportions, and the
+/// link comes after the fields in the tab order, so Tab still moves from W to H.
+#[test]
+fn the_control_bar_link_toggles_by_click() {
+    let mut app = rect_app();
+    assert!(!app.session.prefs.constrain_proportions);
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    let mut time = 0.0;
+    let mut frame = |app: &mut VectorcraftApp, events: Vec<Event>| {
+        time += 1.0;
+        frame_raw(&ctx, app, egui::RawInput { events, time: Some(time), ..Default::default() }, crate::chrome::control_bar)
+    };
+    frame(&mut app, vec![]);
+    let shown = frame(&mut app, vec![]);
+    let at = |text: &str| shown.iter().find(|(t, _)| t == text).map(|(_, r)| *r).unwrap_or_else(|| panic!("no `{text}` in {shown:?}"));
+    let (w, h) = (at("100 pt"), at("50 pt"));
+    // The link's button fills the gap between the W and H fields.
+    let link = egui::pos2((w.right() + h.left()) / 2.0, w.center().y);
+    let button = |pressed| Event::PointerButton { pos: link, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
+    for events in [vec![Event::PointerMoved(link), button(true), button(false)], vec![]] {
+        frame(&mut app, events);
+    }
+    assert!(app.session.prefs.constrain_proportions, "the click toggled the link");
+    // Tab from H finds the link, and Space or Enter toggles it, as a dialog's button takes them.
+    let h = at("50 pt").center();
+    let button = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
+    let tab = Event::Key { key: Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };
+    let enter = Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };
+    for events in [vec![Event::PointerMoved(h), button(h, true), button(h, false)], vec![], vec![tab], vec![], vec![enter], vec![]] {
+        frame(&mut app, events);
+    }
+    assert!(!app.session.prefs.constrain_proportions, "Enter on the focused link toggled it");
+    assert_eq!(size(&app), (100.0, 50.0), "and the fields kept their values");
+}
+
+/// Type `value` into the field of what `draw` shows that shows `field` after one Tab, and press
+/// Enter. The field the Tab moved to takes the value; the one pressed keeps its own.
+fn tab_then_type(app: &mut VectorcraftApp, draw: Draw, field: &str, value: &str) {
+    tab_then_type_with(app, draw, field, value, Modifiers::NONE);
+}
+
+/// [`tab_then_type`] with Shift+Tab, which goes back one field.
+fn shift_tab_then_type(app: &mut VectorcraftApp, draw: Draw, field: &str, value: &str) {
+    tab_then_type_with(app, draw, field, value, Modifiers::SHIFT);
+}
+
+/// [`tab_then_type`], the Tab key held with `modifiers`.
+fn tab_then_type_with(app: &mut VectorcraftApp, draw: Draw, field: &str, value: &str, modifiers: Modifiers) {
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    let mut time = 0.0;
+    let mut frame = |app: &mut VectorcraftApp, events: Vec<Event>| {
+        time += 1.0;
+        frame_raw(&ctx, app, egui::RawInput { events, time: Some(time), ..Default::default() }, draw)
+    };
+    frame(app, vec![]);
+    let shown = frame(app, vec![]);
+    let at = shown.iter().filter(|(s, _)| s == field).map(|(_, r)| r.center()).next().unwrap_or_else(|| panic!("no {field} field in {shown:?}"));
+    let button = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
+    let tab = Event::Key { key: Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers };
+    for events in [vec![Event::PointerMoved(at), button(at, true), button(at, false)], vec![], vec![tab], vec![]] {
+        frame(app, events);
+    }
+    let enter = Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };
+    for events in [vec![Event::Text(value.into())], vec![enter], vec![]] {
+        frame(app, events);
+    }
+}
diff --git a/crates/ui-egui/src/panels/transform.rs b/crates/ui-egui/src/panels/transform.rs
index 042913ca0..ee3ce335c 100644
--- a/crates/ui-egui/src/panels/transform.rs
+++ b/crates/ui-egui/src/panels/transform.rs
@@ -484,15 +484,31 @@ pub fn link_width(ui: &Ui) -> f32 {
 pub const CONSTRAIN_LINK_SIZE: f32 = 22.0;
 
 /// The link between W and H (Transform panel, Properties panel, Control bar): one toggle, the
-/// `constrainProportions` preference, which the size fields pass on as `proportional`.
+/// `constrainProportions` preference, which the size fields pass on as `proportional`. It is drawn
+/// after the fields it sits between, so Tab reaches the fields first and the link after them.
 pub fn constrain_link(app: &mut VectorcraftApp, ui: &mut Ui) {
+    let (_, resp) = ui.allocate_exact_size(egui::Vec2::splat(CONSTRAIN_LINK_SIZE), egui::Sense::click());
+    constrain_link_at(app, ui, resp);
+}
+
+/// [`constrain_link`]'s toggle, made over `at`: the Control bar keeps the link's place between W
+/// and H but makes it after H, so Tab goes from W straight to H and finds the link after it. With
+/// the keyboard on it, Space or Enter toggles it, as a dialog's button takes them.
+pub fn constrain_link_at(app: &mut VectorcraftApp, ui: &mut Ui, at: egui::Response) {
     let on = app.session.prefs.constrain_proportions;
     let tip = tl!("Constrain Width and Height Proportions");
-    if widgets::icon_button(ui, if on { "link" } else { "link-2-off" }, tip, on, CONSTRAIN_LINK_SIZE).clicked() {
+    let keyed = at.has_focus()
+        && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Space) | i.consume_key(egui::Modifiers::NONE, egui::Key::Enter));
+    if widgets::paint_icon_button(ui, at, if on { "link" } else { "link-2-off" }, tip, on).clicked() || keyed {
         set_pref(app, "constrainProportions", !on);
     }
 }
 
+/// The room the Control bar keeps for [`constrain_link_at`] between its W and H fields.
+pub fn constrain_link_room(ui: &mut Ui) -> egui::Rect {
+    ui.allocate_exact_size(egui::Vec2::splat(CONSTRAIN_LINK_SIZE), egui::Sense::hover()).0
+}
+
 /// The `copy` param of a command that a field of the Transform panel, the Properties panel's
 /// Transform section or the Control bar runs: true when Alt+Enter (Option+Return) applied the value
 /// and no anchors are selected with Direct Selection.
diff --git a/crates/ui-egui/src/prefs_dialog.rs b/crates/ui-egui/src/prefs_dialog.rs
index 49f14f281..20b9b2e82 100644
--- a/crates/ui-egui/src/prefs_dialog.rs
+++ b/crates/ui-egui/src/prefs_dialog.rs
@@ -6,7 +6,7 @@
 
 use serde_json::{Map, Value, json};
 use vectorcraft_engine::Prefs;
-use vectorcraft_engine::cmd::prefscmds::{GPU_PREFERENCES, PREF_CATEGORIES, PREF_GROUPS, PREF_SPECS, PrefKind};
+use vectorcraft_engine::cmd::prefscmds::{GPU_PREFERENCES, PREF_CATEGORIES, PREF_GROUPS, PREF_SPECS, PrefKind, folder_check};
 
 use crate::state::Dialog;
 use crate::theme::{self, Accent, Brightness, Scheme, Tokens};
@@ -40,7 +40,6 @@ pub fn confirm(app: &mut VectorcraftApp) -> Result<Value, String> {
     let Some(d) = app.ui.dialog.clone() else { return Err("no dialog open".into()) };
     let values: Map<String, Value> = d.fields.iter().filter(|(k, _)| !k.starts_with("__")).map(|(k, v)| (k.clone(), v.clone())).collect();
     let touch_ws = values.get("touchWorkspace").and_then(Value::as_bool);
-    check_typed_folders(app, &values)?;
     app.run("prefs.set", json!({ "values": values }))?;
     if touch_ws.is_some() {
         crate::workspaces::sync_touch_workspace(app, app.touch_screen);
@@ -413,20 +412,6 @@ fn category_fields(ui: &mut egui::Ui, app: &mut VectorcraftApp, d: &mut Dialog,
     }
 }
 
-/// A check of a folder path: `Err` says why the folder can't be the preference's value.
-type FolderCheck = fn(&str) -> Result<(), String>;
-
-/// The check a folder preference with a Choose… button gives a folder before it becomes the
-/// preference's value: Data Recovery keeps its copies in its folder, and the Additional Plug-ins
-/// Folder is read for plug-ins. `None` for any other preference.
-fn folder_check(key: &str) -> Option<FolderCheck> {
-    match key {
-        "recoveryFolder" => Some(writable_folder),
-        "pluginsFolder" => Some(plugins_folder),
-        _ => None,
-    }
-}
-
 /// Choose… beside the folder preference `key`: the folder picked becomes the field's value when it
 /// passes the preference's [`folder_check`]. Otherwise the status bar says why and the field keeps
 /// its value, as it does when the picker is canceled. The answer fills the field even when the
@@ -444,55 +429,6 @@ fn choose_folder(app: &mut VectorcraftApp, d: &mut Dialog, key: &'static str) {
     }
 }
 
-/// OK's check of the folder preferences with a Choose… button: a folder typed into one of their
-/// fields gets the same [`folder_check`] as a picked one. An empty field (the default folder) and
-/// a folder the preference already holds are not checked. The web has no folders to check.
-fn check_typed_folders(app: &VectorcraftApp, fields: &Map<String, Value>) -> Result<(), String> {
-    if cfg!(target_arch = "wasm32") {
-        return Ok(());
-    }
-    let saved = app.session.prefs.to_json();
-    for (key, v) in fields {
-        let (Some(check), Some(path)) = (folder_check(key), v.as_str()) else { continue };
-        let path = path.trim();
-        if path.is_empty() || saved[key.as_str()].as_str().is_some_and(|s| s.trim() == path) {
-            continue;
-        }
-        check(path)?;
-    }
-    Ok(())
-}
-
-/// `Ok` when `path` is a folder whose contents can be listed, as the plug-ins in it are found by
-/// listing it. A folder outside the automation roots in force is refused before it is looked at.
-fn plugins_folder(path: &str) -> Result<(), String> {
-    vectorcraft_engine::file_access::check_read(path)?;
-    let dir = std::path::Path::new(path);
-    if !dir.is_dir() {
-        return Err(format!("{path} is not a folder"));
-    }
-    std::fs::read_dir(dir).map(drop).map_err(|e| format!("Plug-ins can't be loaded from {path}: {e}"))
-}
-
-/// `Ok` when `path` is a folder that can be listed and that a folder can be created in, as the
-/// recovery store lists its folders there and makes its own: the folder is listed, and an empty
-/// folder is made there and removed. A folder that can't be removed again is an error too. A
-/// folder outside the automation roots in force is refused before it is looked at.
-fn writable_folder(path: &str) -> Result<(), String> {
-    vectorcraft_engine::file_access::check_write(path)?;
-    vectorcraft_engine::file_access::check_read(path)?;
-    let dir = std::path::Path::new(path);
-    if !dir.is_dir() {
-        return Err(format!("{path} is not a folder"));
-    }
-    let refused = |e: std::io::Error| format!("Data Recovery can't keep copies in {path}: {e}");
-    std::fs::read_dir(dir).map_err(refused)?;
-    let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |t| t.as_nanos());
-    let check = dir.join(format!(".vectorcraft-write-check-{}-{nanos}", std::process::id()));
-    std::fs::create_dir(&check).map_err(refused)?;
-    std::fs::remove_dir(&check).map_err(refused)
-}
-
 /// Is one of the dialog's Units (General, Stroke, Type, East Asian Type) Picas?
 fn picas_in_use(d: &Dialog) -> bool {
     ["unitsGeneral", "unitsStroke", "unitsType", "unitsAsianType"].iter().any(|k| d.str(k) == vectorcraft_doc::Unit::Picas.key())
diff --git a/crates/ui-egui/src/prefs_dialog/tests.rs b/crates/ui-egui/src/prefs_dialog/tests.rs
index 75a165674..8d0285254 100644
--- a/crates/ui-egui/src/prefs_dialog/tests.rs
+++ b/crates/ui-egui/src/prefs_dialog/tests.rs
@@ -615,6 +615,7 @@ fn ok_refuses_a_typed_folder_that_choose_would_refuse() {
             assert_eq!(confirm(&mut a), Err(format!("{path} is not a folder")), "{key}");
             assert!(a.ui.dialog.is_some(), "{key}: the dialog stays open");
             assert_eq!(a.session.prefs.to_json(), before, "{key}: no preference changes");
+            assert!(!a.prefs_changed, "{key}: nothing to save");
         }
         // A typed folder that passes is saved, with the spaces around it as typed.
         let typed = format!(" {} ", dir.to_string_lossy());
@@ -627,7 +628,9 @@ fn ok_refuses_a_typed_folder_that_choose_would_refuse() {
         confirm(&mut a).unwrap();
         assert_eq!(a.session.prefs.to_json()[key], json!(""), "{key}");
         // A folder already saved is not checked again, so OK works while it is unavailable.
+        std::fs::create_dir(&missing).unwrap();
         a.run("prefs.set", json!({"key": key, "value": missing})).unwrap();
+        std::fs::remove_dir(&missing).unwrap();
         open(&mut a, Some("File Handling"));
         a.ui.dialog.as_mut().unwrap().fields.insert("showToolTips".into(), json!(!a.session.prefs.show_tool_tips));
         confirm(&mut a).unwrap();
diff --git a/crates/ui-egui/src/scrub.rs b/crates/ui-egui/src/scrub.rs
index 70ceb5060..5a0a2ff4f 100644
--- a/crates/ui-egui/src/scrub.rs
+++ b/crates/ui-egui/src/scrub.rs
@@ -168,10 +168,11 @@ pub(crate) fn field(ui: &Ui, field: Id, rect: Rect, text: &str, value: Option<f6
     }
     // On top of the label, which may sense clicks itself (selectable text). A link senses drags
     // too and keeps its clicks (and its pointing hand while hovered): a widget laid over it would
-    // take them.
+    // take them. The zone is not a tab stop of its own (`Sense::click_and_drag` would be): Tab
+    // moves from a field to the next field, not onto the label before it.
     let resp = match label.link {
         Some(link) => ui.interact(label.rect, link, Sense::drag()),
-        None => ui.interact(label.rect, field.with("scrub-label"), Sense::click_and_drag()),
+        None => ui.interact(label.rect, field.with("scrub-label"), Sense::CLICK | Sense::DRAG),
     };
     drag(ui, &resp, field, text, value, decimals, label.link.is_some()).map(|v| v.max(*bounds.start()).min(*bounds.end()))
 }
diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rs
index 1232aba36..f6ceaec9d 100644
--- a/crates/ui-egui/src/shortcuts.rs
+++ b/crates/ui-egui/src/shortcuts.rs
@@ -185,6 +185,7 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
         return;
     }
     ctx.input(|i| crate::shortcut_editor::note_backtick_text(&i.events));
+    note_key_surfaces(app, ctx);
     if !(ctx.input(|input| input.focused) || app.forwarded_frame && ctx.viewport_id() == egui::ViewportId::ROOT) {
         crate::ime::controls_without_editor(app, ctx);
         return;
@@ -210,7 +211,7 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
         // Escape closes a dropdown list or popover open in the dialog (each closes itself on it) and
         // leaves the dialog open.
         let popup = app.ui.dialog.as_ref().is_some_and(|d| egui::Popup::is_any_open(ctx) || crate::dialogs::brush_options::tips_open(d));
-        if !popup && ctx.input(|i| i.key_pressed(Key::Escape)) {
+        if !popup && pressed_anew(ctx, Key::Escape) {
             crate::dialogs::cancel(app);
             app.ui.palette_open = false;
         }
@@ -239,7 +240,7 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
     // below: the loop then skips Enter, the first key.
     let enter_types = app.session.tool_wants_text();
     for (k, tk) in [(Key::Enter, ToolKey::Enter), (Key::Escape, ToolKey::Escape)].into_iter().skip(usize::from(enter_types)) {
-        if !typing && !composing && ctx.input(|i| i.key_pressed(k)) {
+        if !typing && !composing && !take_claimed_repeat(app, ctx, k, tk, view) && pressed_anew(ctx, k) {
             // A chord a command is bound to (Cmd+Enter) runs only that command, in the shortcuts
             // below, also when the tool claims the key. While the Type tool edits text only Cmd
             // chords run one, and while another tool is busy none does.
@@ -376,6 +377,70 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
     single_key_shortcuts(app, ctx);
 }
 
+/// Did `key` go down in this frame? The key repeats of a held key do not count.
+pub(crate) fn pressed_anew(ctx: &egui::Context, key: Key) -> bool {
+    ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::Key { key: k, pressed: true, repeat: false, .. } if *k == key)))
+}
+
+/// Takes this frame's repeats of `key` when the tool claims it: a press acts once, and they stay out
+/// of the shortcuts. A chord a command is bound to keeps its repeats.
+fn take_claimed_repeat(app: &mut VectorcraftApp, ctx: &egui::Context, key: Key, tool_key: ToolKey, view: ViewInfo) -> bool {
+    let text = app.session.tool_wants_text();
+    let runs_a_command = (text || !app.session.tool_busy()) && ctx.input(|i| runs_a_command(i, key, text));
+    if runs_a_command || pressed_anew(ctx, key) || !ctx.input(|i| i.key_pressed(key)) || !app.session.tool_claims_key(tool_key, view) {
+        return false;
+    }
+    ctx.input_mut(|i| i.consume_key(Modifiers::NONE, key));
+    ctx.input_mut(|i| i.consume_key(Modifiers::SHIFT, key));
+    true
+}
+
+/// What Enter and Escape act on: the open dialog, the command search, Edit Toolbar's drawer and
+/// Presentation Mode.
+type KeySurface = (Option<String>, bool, bool, bool);
+
+fn key_surface(app: &VectorcraftApp) -> KeySurface {
+    (app.ui.dialog.as_ref().map(|d| d.kind.clone()), app.ui.palette_open, app.ui.tools_drawer, app.ui.screen_mode == 3)
+}
+
+/// The mark of what `key` went down on; `None` once that has changed.
+fn key_surface_id(ctx: &egui::Context, key: Key) -> egui::Id {
+    egui::Id::unique("key-surface").with(key).with(ctx.viewport_id())
+}
+
+/// Notes what a new press of Enter or Escape lands on, and forgets it once the key is up.
+fn note_key_surfaces(app: &VectorcraftApp, ctx: &egui::Context) {
+    for key in [Key::Enter, Key::Escape] {
+        let id = key_surface_id(ctx, key);
+        if pressed_anew(ctx, key) {
+            ctx.data_mut(|m| m.insert_temp(id, Some(key_surface(app))));
+        } else {
+            hold_back_key(app, ctx, key);
+            if !ctx.input(|i| i.key_down(key)) {
+                ctx.data_mut(|m| m.remove::<Option<KeySurface>>(id));
+            }
+        }
+    }
+}
+
+/// Removes this frame's presses of Enter and Escape when the key went down on something that has
+/// since changed: the press that opened or closed a dialog, and its repeats until the key is let
+/// go, reach neither the new dialog nor what is under the old one.
+pub(crate) fn hold_back_keys(app: &VectorcraftApp, ctx: &egui::Context) {
+    hold_back_key(app, ctx, Key::Enter);
+    hold_back_key(app, ctx, Key::Escape);
+}
+
+fn hold_back_key(app: &VectorcraftApp, ctx: &egui::Context, key: Key) {
+    let id = key_surface_id(ctx, key);
+    let Some(pressed_on) = ctx.data(|m| m.get_temp::<Option<KeySurface>>(id)) else { return };
+    if pressed_on.as_ref() == Some(&key_surface(app)) {
+        return;
+    }
+    ctx.data_mut(|m| m.insert_temp(id, None::<KeySurface>));
+    ctx.input_mut(|i| i.events.retain(|e| !matches!(e, egui::Event::Key { key: k, pressed: true, .. } if *k == key)));
+}
+
 /// The key of the mark that the Escape held down ended a ruler-origin drag or a floating Tools move.
 fn escape_ended_gesture_id() -> egui::Id {
     egui::Id::unique("escape-ended-gesture")
diff --git a/crates/ui-egui/src/shortcuts/tests.rs b/crates/ui-egui/src/shortcuts/tests.rs
index 80aa03365..5fbffb533 100644
--- a/crates/ui-egui/src/shortcuts/tests.rs
+++ b/crates/ui-egui/src/shortcuts/tests.rs
@@ -1064,7 +1064,8 @@ fn enter_opens_the_tools_dialog_and_leaves_it_open() {
     let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
     app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
     let ctx = egui::Context::default();
-    let enter = || egui::Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };
+    let key = |pressed| egui::Event::Key { key: Key::Enter, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE };
+    let enter = || vec![key(true), key(false)];
     // A whole app frame: the shortcuts first, then the UI, where a dialog takes its Enter.
     let frame = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
         let screen_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1280.0, 800.0)));
@@ -1078,7 +1079,7 @@ fn enter_opens_the_tools_dialog_and_leaves_it_open() {
     // The undo steps and the journal entries (the dialog's OK runs its command, which the journal records).
     let steps = |app: &VectorcraftApp| (app.session.active().unwrap().history.undo.len(), app.session.journal.len());
     app.select_tool("selection");
-    frame(&mut app, vec![enter()]);
+    frame(&mut app, enter());
     assert_eq!(kind(&app), None, "nothing is selected");
     app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 30})).unwrap();
     for (tool, dialog) in [
@@ -1092,22 +1093,299 @@ fn enter_opens_the_tools_dialog_and_leaves_it_open() {
     ] {
         app.select_tool(tool);
         let before = steps(&app);
-        frame(&mut app, vec![enter()]);
+        frame(&mut app, enter());
         assert_eq!(kind(&app).as_deref(), Some(dialog), "{tool}: Enter opens it");
         frame(&mut app, vec![]);
         assert_eq!(kind(&app).as_deref(), Some(dialog), "{tool}: and it stays open");
         assert_eq!(steps(&app), before, "{tool}: the Enter that opened it didn't confirm it");
         // The next Enter is its OK. With its default values only Reflect changes the art, so only
         // Reflect records an undo step.
-        frame(&mut app, vec![enter()]);
+        frame(&mut app, enter());
         let after = (before.0 + usize::from(dialog == "reflect"), before.1 + 1);
         assert_eq!((kind(&app), steps(&app)), (None, after), "{tool}: Enter confirms");
     }
     app.select_tool("rectangle");
-    frame(&mut app, vec![enter()]);
+    frame(&mut app, enter());
     assert_eq!(kind(&app), None, "another tool has its own Enter");
 }
 
+/// A key held down across whole app frames: the context stays, so egui marks the press after the
+/// first as a repeat until `release` lets go.
+struct HeldKey {
+    ctx: egui::Context,
+    key: Key,
+    modifiers: Modifiers,
+}
+
+impl HeldKey {
+    fn new(key: Key, modifiers: Modifiers) -> Self {
+        Self { ctx: egui::Context::default(), key, modifiers }
+    }
+
+    fn frame(&self, app: &mut VectorcraftApp, mut events: Vec<egui::Event>) {
+        events.insert(0, egui::Event::ModifiersChanged(self.modifiers));
+        let screen_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1280.0, 800.0)));
+        let mut out = self.ctx.run_ui(egui::RawInput { events, screen_rect, ..Default::default() }, |ui| {
+            app.logic(ui.ctx());
+            app.ui(ui);
+        });
+        out.textures_delta.clear();
+    }
+
+    fn key(&self, app: &mut VectorcraftApp, pressed: bool) {
+        let event = egui::Event::Key { key: self.key, physical_key: None, pressed, repeat: false, modifiers: self.modifiers };
+        self.frame(app, vec![event]);
+    }
+
+    /// The press, or while the key is down, one repeat.
+    fn press(&self, app: &mut VectorcraftApp) {
+        self.key(app, true);
+    }
+
+    fn release(&self, app: &mut VectorcraftApp) {
+        self.key(app, false);
+    }
+}
+
+fn app_with_a_selected_rectangle() -> VectorcraftApp {
+    let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+    app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 30})).unwrap();
+    app
+}
+
+fn open_dialog(app: &VectorcraftApp) -> Option<String> {
+    app.ui.dialog.as_ref().map(|d| d.kind.clone())
+}
+
+/// Holding Enter with a selection opens Move once: the repeats neither confirm it nor open it
+/// again. A new press confirms it, and that press's repeats do not open it again.
+fn hold_enter_on_a_selection(modifiers: Modifiers) {
+    let mut app = app_with_a_selected_rectangle();
+    let held = HeldKey::new(Key::Enter, modifiers);
+    let steps = |app: &VectorcraftApp| (app.session.active().unwrap().history.undo.len(), app.session.journal.len());
+    app.select_tool("selection");
+    let before = steps(&app);
+    for repeat in 0..8 {
+        held.press(&mut app);
+        assert_eq!(open_dialog(&app).as_deref(), Some("move"), "repeat {repeat}: Move stays open");
+        assert_eq!(steps(&app), before, "repeat {repeat}: nothing moved");
+    }
+    assert!(held.ctx.memory(|m| m.focused().is_some()), "its first field keeps the keyboard");
+    held.release(&mut app);
+    assert_eq!(open_dialog(&app).as_deref(), Some("move"), "letting go leaves it open");
+    held.press(&mut app);
+    assert_eq!(open_dialog(&app), None, "a new press confirms");
+    let confirmed = steps(&app);
+    assert_eq!(confirmed.1, before.1 + 1, "the new press ran Move once");
+    for repeat in 0..8 {
+        held.press(&mut app);
+        assert_eq!(open_dialog(&app), None, "repeat {repeat}: Move stays closed");
+        assert_eq!(steps(&app), confirmed, "repeat {repeat}: nothing else ran");
+    }
+}
+
+#[test]
+fn holding_enter_opens_the_move_dialog_once_and_a_new_press_confirms_it() {
+    hold_enter_on_a_selection(Modifiers::NONE);
+}
+
+#[test]
+fn holding_shift_enter_opens_the_move_dialog_once_and_a_new_press_confirms_it() {
+    hold_enter_on_a_selection(Modifiers::SHIFT);
+}
+
+/// After a drag Move opens on the drag's offset, and holding Enter leaves the object where it is.
+#[test]
+fn holding_enter_after_a_drag_does_not_move_the_object_again() {
+    use vectorcraft_tools::{PointerEvent, PointerKind};
+    let mut app = app_with_a_selected_rectangle();
+    let left = |app: &VectorcraftApp| app.session.doc().unwrap().doc.layers[0].children().unwrap()[0].geometric_bounds().unwrap().x0;
+    app.select_tool("selection");
+    let view = app.view_info();
+    for (kind, x) in [(PointerKind::Down, 35.0), (PointerKind::Drag, 55.0), (PointerKind::Drag, 75.0), (PointerKind::Up, 75.0)] {
+        app.session.pointer(&PointerEvent::new(kind, x, 25.0), view).unwrap();
+    }
+    let dragged = left(&app);
+    assert!(dragged > 10.0);
+    let held = HeldKey::new(Key::Enter, Modifiers::NONE);
+    held.frame(&mut app, vec![]);
+    for repeat in 0..8 {
+        held.press(&mut app);
+        assert_eq!(left(&app), dragged, "repeat {repeat}: the object stays");
+    }
+}
+
+/// A chord no command is bound to opens Move through the tool's Enter too. That press is not also
+/// the dialog's OK.
+fn press_a_chord_on_a_selection(modifiers: Modifiers) {
+    let mut app = app_with_a_selected_rectangle();
+    let journal = app.session.journal.len();
+    let held = HeldKey::new(Key::Enter, modifiers);
+    app.select_tool("selection");
+    held.press(&mut app);
+    assert_eq!(open_dialog(&app).as_deref(), Some("move"), "Move stays open");
+    assert_eq!(app.session.journal.len(), journal, "nothing ran");
+}
+
+#[test]
+fn the_press_of_ctrl_enter_that_opens_a_dialog_does_not_confirm_it() {
+    press_a_chord_on_a_selection(Modifiers::CTRL);
+}
+
+#[test]
+fn the_press_of_cmd_enter_that_opens_a_dialog_does_not_confirm_it() {
+    press_a_chord_on_a_selection(Modifiers::COMMAND);
+}
+
+/// A command bound to Enter opens its dialog once: the repeats of the press do not confirm it, and
+/// the repeats of the press that confirms it do not run the command again.
+#[test]
+fn holding_enter_bound_to_a_dialog_command_opens_it_once() {
+    let mut app = app_with_a_selected_rectangle();
+    app.run("shortcuts.set", json!({"id": "object.move", "shortcut": "Enter", "force": true})).unwrap();
+    let journal = app.session.journal.len();
+    app.select_tool("rectangle");
+    let held = HeldKey::new(Key::Enter, Modifiers::NONE);
+    held.frame(&mut app, vec![]);
+    for repeat in 0..4 {
+        held.press(&mut app);
+        assert_eq!(open_dialog(&app).as_deref(), Some("move"), "repeat {repeat}: Move stays open");
+    }
+    held.release(&mut app);
+    held.press(&mut app);
+    assert_eq!(open_dialog(&app), None, "a new press confirms");
+    let confirmed = app.session.journal.len();
+    assert_eq!(confirmed, journal + 1);
+    for repeat in 0..4 {
+        held.press(&mut app);
+        assert_eq!(open_dialog(&app), None, "repeat {repeat}: the command does not run again");
+    }
+}
+
+/// The repeats of the Enter that confirms a dialog type no line break into the text being edited.
+#[test]
+fn holding_the_enter_that_confirms_a_dialog_types_no_line_break() {
+    let mut app = app_with_a_selected_rectangle();
+    let text = app.session.execute("text.create", &json!({"x": 20, "y": 250, "text": "Hi"})).unwrap()["id"].as_u64().unwrap();
+    app.select_tool("type");
+    app.session.apply_actions(vec![vectorcraft_tools::Action::Notify("text.editNew".into())]).unwrap();
+    assert!(app.session.tool_wants_text());
+    crate::menus::invoke(&mut app, "object.move", json!({}));
+    assert_eq!(open_dialog(&app).as_deref(), Some("move"));
+    let held = HeldKey::new(Key::Enter, Modifiers::NONE);
+    held.frame(&mut app, vec![]);
+    held.press(&mut app);
+    assert_eq!(open_dialog(&app), None, "the press confirms");
+    assert!(app.session.tool_wants_text());
+    let before = text_and_layers(&mut app, text).0;
+    for repeat in 0..4 {
+        held.press(&mut app);
+        assert_eq!(text_and_layers(&mut app, text).0, before, "repeat {repeat}: no line break");
+    }
+    held.release(&mut app);
+    held.press(&mut app);
+    assert_ne!(text_and_layers(&mut app, text).0, before, "a new press types one");
+}
+
+/// A release that never reaches the main window costs the next press: egui takes that press for a
+/// repeat, and its release clears the key, so the press after it acts again.
+#[test]
+fn a_lost_release_costs_one_press_of_enter() {
+    let mut app = app_with_a_selected_rectangle();
+    let held = HeldKey::new(Key::Enter, Modifiers::NONE);
+    app.select_tool("rectangle");
+    held.press(&mut app);
+    app.select_tool("selection");
+    held.press(&mut app);
+    assert_eq!(open_dialog(&app), None, "the first press after the lost release is taken for a repeat");
+    held.release(&mut app);
+    held.press(&mut app);
+    assert_eq!(open_dialog(&app).as_deref(), Some("move"), "the next press opens Move");
+}
+
+/// A dialog that appears while Enter is down, as one the command search's Enter opens does, waits
+/// for a new press. That covers the dialogs that draw their own window too.
+#[test]
+fn a_dialog_that_opens_while_enter_is_down_waits_for_a_new_press() {
+    fn open_move(app: &mut VectorcraftApp) {
+        let _ = crate::toolbar::open_options(app, "selection");
+    }
+    fn open_simplify(app: &mut VectorcraftApp) {
+        crate::menus::invoke(app, "object.path.simplify", json!({}));
+    }
+    let new_document = crate::dialogs::open_new_document;
+    for (name, open) in [("Move", open_move as fn(&mut VectorcraftApp)), ("New Document", new_document), ("Simplify", open_simplify)] {
+        let mut app = app_with_a_selected_rectangle();
+        let documents = app.session.documents().len();
+        let held = HeldKey::new(Key::Enter, Modifiers::NONE);
+        app.select_tool("rectangle");
+        held.press(&mut app);
+        assert_eq!(open_dialog(&app), None, "{name}: the Rectangle tool opens nothing on Enter");
+        open(&mut app);
+        let kind = open_dialog(&app);
+        assert!(kind.is_some(), "{name}: it opens");
+        for repeat in 0..4 {
+            held.press(&mut app);
+            assert_eq!(open_dialog(&app), kind, "{name}, repeat {repeat}: it stays open");
+            assert_eq!(app.session.documents().len(), documents, "{name}, repeat {repeat}: nothing was created");
+        }
+    }
+}
+
+/// The command search opens while Enter is down: the repeats do not run its highlighted result.
+#[test]
+fn the_command_search_that_opens_while_enter_is_down_waits_for_a_new_press() {
+    let mut app = app_with_a_selected_rectangle();
+    let held = HeldKey::new(Key::Enter, Modifiers::NONE);
+    app.select_tool("rectangle");
+    held.press(&mut app);
+    app.ui.palette_open = true;
+    for repeat in 0..4 {
+        held.press(&mut app);
+        assert!(app.ui.palette_open, "repeat {repeat}: it stays open");
+    }
+    held.release(&mut app);
+    held.press(&mut app);
+    assert!(!app.ui.palette_open, "a new press runs the highlighted result");
+}
+
+/// A field that rejects its text on Enter keeps the dialog open, while the key is held too.
+#[test]
+fn holding_enter_on_a_rejected_value_leaves_the_dialog_open() {
+    let mut app = app_with_a_selected_rectangle();
+    let journal = app.session.journal.len();
+    let held = HeldKey::new(Key::Enter, Modifiers::NONE);
+    let _ = crate::toolbar::open_options(&mut app, "selection");
+    held.frame(&mut app, vec![]);
+    held.frame(&mut app, vec![]);
+    held.frame(&mut app, vec![egui::Event::Text("abc".into())]);
+    for repeat in 0..4 {
+        held.press(&mut app);
+        assert_eq!(open_dialog(&app).as_deref(), Some("move"), "repeat {repeat}: Move stays open");
+        assert_eq!(app.session.journal.len(), journal, "repeat {repeat}: nothing ran");
+    }
+}
+
+/// Holding Enter in the Type tool goes on typing line breaks.
+#[test]
+fn holding_enter_in_the_type_tool_repeats_line_breaks() {
+    for modifiers in [Modifiers::NONE, Modifiers::SHIFT] {
+        let mut app = app_with_a_selected_rectangle();
+        let text = app.session.execute("text.create", &json!({"x": 20, "y": 250, "text": "Hi"})).unwrap()["id"].as_u64().unwrap();
+        app.select_tool("type");
+        app.session.apply_actions(vec![vectorcraft_tools::Action::Notify("text.editNew".into())]).unwrap();
+        assert!(app.session.tool_wants_text());
+        let held = HeldKey::new(Key::Enter, modifiers);
+        for _ in 0..4 {
+            held.press(&mut app);
+        }
+        let typed = text_and_layers(&mut app, text).0;
+        assert_eq!(typed.chars().filter(|c| matches!(c, '\n' | '\r' | '\u{2028}' | '\u{3}')).count(), 4, "{modifiers:?}: {typed:?}");
+        assert_eq!(open_dialog(&app), None, "{modifiers:?}");
+    }
+}
+
 /// A drag with the Selection tool, then Enter: the Move dialog opens on the drag's offset, and
 /// Enter is its OK. With Copy ticked once, each Enter, Enter after that makes another copy at
 /// the same spacing.
@@ -1118,7 +1396,8 @@ fn enter_after_a_drag_repeats_its_offset() {
     app.session.execute("file.new", &json!({"width": 800, "height": 300})).unwrap();
     app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
     let ctx = egui::Context::default();
-    let enter = || egui::Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };
+    let key = |pressed| egui::Event::Key { key: Key::Enter, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE };
+    let enter = || vec![key(true), key(false)];
     let frame = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
         let screen_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1280.0, 800.0)));
         let mut out = ctx.run_ui(egui::RawInput { events, screen_rect, ..Default::default() }, |ui| {
@@ -1143,26 +1422,26 @@ fn enter_after_a_drag_repeats_its_offset() {
     assert!(step > 0.0);
     // Keys reach the canvas from the second frame on.
     frame(&mut app, vec![]);
-    frame(&mut app, vec![enter()]);
+    frame(&mut app, enter());
     let d = app.ui.dialog.as_mut().expect("Enter opens Move");
     assert_eq!((d.kind.as_str(), d.f64("dx", f64::NAN).round(), d.f64("dy", f64::NAN)), ("move", step, 0.0));
     d.fields.insert("copy".into(), json!(true));
-    frame(&mut app, vec![enter()]);
+    frame(&mut app, enter());
     for _ in 0..2 {
-        frame(&mut app, vec![enter()]);
-        frame(&mut app, vec![enter()]);
+        frame(&mut app, enter());
+        frame(&mut app, enter());
     }
     assert!(app.ui.dialog.is_none());
     assert_eq!(lefts(&app), (0..4).map(|i| moved + step * f64::from(i)).collect::<Vec<_>>());
     // With Preview on too, each Enter, Enter still makes one copy, and one undo step.
-    frame(&mut app, vec![enter()]);
+    frame(&mut app, enter());
     app.ui.dialog.as_mut().expect("Move").fields.insert("preview".into(), json!(true));
-    frame(&mut app, vec![enter()]);
+    frame(&mut app, enter());
     let steps = app.session.active().unwrap().history.undo.len();
     for _ in 0..2 {
-        frame(&mut app, vec![enter()]);
+        frame(&mut app, enter());
         assert!(app.ui.dialog.as_ref().is_some_and(|d| d.bool("preview") && d.bool("copy")) && app.session.in_interaction());
-        frame(&mut app, vec![enter()]);
+        frame(&mut app, enter());
         assert!(app.ui.dialog.is_none() && !app.session.in_interaction());
     }
     assert_eq!(app.session.active().unwrap().history.undo.len(), steps + 2);
diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs
index 7f562f057..14cd10d28 100644
--- a/crates/ui-egui/src/state.rs
+++ b/crates/ui-egui/src/state.rs
@@ -397,6 +397,10 @@ pub struct UiState {
     /// is open. Not saved.
     #[serde(skip)]
     pub context_intertwine: Option<(u64, vectorcraft_doc::NodeId, vectorcraft_geom::Point, vectorcraft_doc::NodeId)>,
+    /// What the last right-click on the canvas with the Artboard tool measured, for the context menu
+    /// while it is open ([`crate::panels::artboards::MenuFacts`]). Not saved.
+    #[serde(skip)]
+    pub context_artboards: Option<crate::panels::artboards::MenuFacts>,
     /// Which link statuses the active document's images and placed documents have, for Select ›
     /// Linked, Embedded, Missing and Modified to be on only when some do (refreshed by
     /// [`crate::addons::select::link_status::refresh`]). Not saved.
@@ -965,6 +969,7 @@ impl Default for UiState {
             shape_modes_compound: false,
             context_locked: None,
             context_intertwine: None,
+            context_artboards: None,
             link_statuses: Default::default(),
             slot_tool: Default::default(),
             floating_flyouts: vec![],
diff --git a/crates/ui-egui/src/tests/clipboard.rs b/crates/ui-egui/src/tests/clipboard.rs
index 77ff0149b..d3b0c25a6 100644
--- a/crates/ui-egui/src/tests/clipboard.rs
+++ b/crates/ui-egui/src/tests/clipboard.rs
@@ -581,3 +581,42 @@ fn type_range_copy_stays_styled_when_pasted_as_art() {
     assert_eq!(t.runs[0].style.fill, Paint::solid(Color::rgb8(0, 255, 0)));
     assert_eq!(t.runs[0].style.style_name.as_deref(), Some("Emphasis"));
 }
+
+/// #5929: a styled Type-range Copy pasted into a new point type object made by a Type tool click
+/// (placeholder text selected) keeps its font, size and colour, and replaces the placeholder: the
+/// paste takes the copied runs, not the new object's default style.
+#[test]
+fn a_type_range_paste_into_new_point_type_keeps_its_formatting() {
+    let _guard = TEST_CLIP_LOCK.lock().unwrap();
+    let (mut app, board) = super::sysclip::app();
+    let source = run(
+        &mut app,
+        "text.create",
+        json!({"x": 20, "y": 40, "text": "Hello world", "font": "Source Serif 4", "size": 28, "color": "#00ff00"}),
+    )["id"]
+        .as_u64()
+        .unwrap();
+    let view = app.view_info();
+    app.session.select_tool("type", view).unwrap();
+    app.session.set_tool_option("textSelection", &json!({"id": source, "start": 0, "end": 5}));
+    crate::panels::character::intercept_text_command(&mut app, "edit.copy");
+    crate::background::wait_all(&mut app);
+    assert!(super::sysclip::written(&board).contains(&vectorcraft_engine::cmd::clipboard::TEXT));
+    // The first click ends editing the source; the second places new point type with its
+    // placeholder text selected.
+    for _ in 0..2 {
+        for kind in [vectorcraft_tools::PointerKind::Down, vectorcraft_tools::PointerKind::Up] {
+            app.session.pointer(&vectorcraft_tools::PointerEvent::new(kind, 300.0, 250.0), view).unwrap();
+        }
+    }
+    let fresh = app.session.tool_options()["editing"].as_u64().expect("editing new point type");
+    assert_ne!(fresh, source);
+    crate::panels::character::intercept_text_command(&mut app, "edit.paste");
+    app.session.select_tool("selection", view).unwrap();
+    let node = app.session.active().unwrap().doc.node(NodeId(fresh)).unwrap().clone();
+    let vectorcraft_doc::NodeKind::Text(t) = &node.kind else { panic!("not text") };
+    assert_eq!(t.plain_text(), "Hello", "the paste replaces the placeholder");
+    assert_eq!(t.runs[0].style.font_family, "Source Serif 4");
+    assert_eq!(t.runs[0].style.size, 28.0);
+    assert_eq!(t.runs[0].style.fill, Paint::solid(Color::rgb8(0, 255, 0)));
+}
diff --git a/crates/ui-egui/src/tests/contextmenu.rs b/crates/ui-egui/src/tests/contextmenu.rs
index e4445ca34..6dadd856c 100644
--- a/crates/ui-egui/src/tests/contextmenu.rs
+++ b/crates/ui-egui/src/tests/contextmenu.rs
@@ -371,10 +371,13 @@ fn every_context_label_is_a_menu_string() {
     app.ui.context_locked = Some((app.session.active().unwrap().uid, vec![a]));
     shown.extend(labels(&menus::context_items(&app)));
     // The Lock Artboards and Unlock Artboards submenus of the Artboard tool.
-    app.run("artboard.new", json!({"x": 400, "y": 0, "width": 100, "height": 100})).unwrap();
+    app.run("artboard.new", json!({"x": 400, "y": 0, "width": 100, "height": 80})).unwrap();
     app.run("artboard.setProps", json!({"index": 0, "locked": true})).unwrap();
     app.select_tool("artboard");
     shown.extend(labels(&menus::context_items(&app)));
+    // Lock Selected with the artboard that isn't locked active.
+    crate::panels::artboards::select(&mut app, 1);
+    shown.extend(labels(&menus::context_items(&app)));
     let missing: Vec<_> = shown.iter().filter(|l| !strings.contains(**l)).collect();
     assert!(missing.is_empty(), "context menu labels missing from menu_strings: {missing:?}");
     for label in menus::CONTEXT_LABELS {
diff --git a/crates/ui-egui/src/tests/home.rs b/crates/ui-egui/src/tests/home.rs
index 96f50716d..d1c20991a 100644
--- a/crates/ui-egui/src/tests/home.rs
+++ b/crates/ui-egui/src/tests/home.rs
@@ -438,3 +438,54 @@ fn a_queued_reopen_keeps_the_roots_it_was_asked_in() {
     assert_eq!(app.session.documents().len(), 1, "the file outside the roots is not opened");
     let _ = std::fs::remove_dir_all(d);
 }
+
+/// The x-centre of the first text shape whose text is `text` on a drawn Home screen, and the
+/// window's centre (#4684). A centred galley's `pos` is its anchor, so its rect says where it lies.
+fn text_centre_x(app: &mut VectorcraftApp, text: &str) -> Option<(f32, f32)> {
+    fn find(s: &egui::Shape, text: &str) -> Option<f32> {
+        match s {
+            egui::Shape::Text(t) if t.galley.text() == text => Some(t.pos.x + t.galley.rect.center().x),
+            egui::Shape::Vec(v) => v.iter().find_map(|s| find(s, text)),
+            _ => None,
+        }
+    }
+    app.canvas_rect = None;
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1000.0, 900.0));
+    let raw = egui::RawInput { screen_rect: Some(screen), ..Default::default() };
+    let mut out = ctx.run_ui(raw, |ui| canvas::show(app, ui));
+    out.textures_delta.clear();
+    let x = out.shapes.iter().find_map(|c| find(&c.shape, text))?;
+    Some((x, screen.center().x))
+}
+
+/// The Home screen centres its welcome, its New / Open buttons and its community block, as
+/// PhotoCraft's does (#4684).
+#[test]
+fn home_welcome_and_community_are_centred() {
+    let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), crate::Services::default());
+    for text in ["Welcome to VectorCraft", "Community", "ArtCraft website", "VectorCraft on getartcraft.com", "Source code on GitHub"] {
+        let (x, centre) = text_centre_x(&mut app, text).unwrap_or_else(|| panic!("{text} is drawn"));
+        assert!((x - centre).abs() < 6.0, "{text} is centred: {x} vs {centre}");
+    }
+    // The Discord button is centred; its label lies right of its icon, 0.375 of the button's 36 pt
+    // height right of the middle.
+    let (x, centre) = text_centre_x(&mut app, "Join our Discord").unwrap();
+    assert!((x - centre - 0.375 * 36.0).abs() < 2.0, "the Discord button is centred: label at {x} about {centre}");
+    // The two buttons (a label's width plus 32, at least 72, each) lie symmetrically about the
+    // centre: the first one's left edge and the second one's right edge are equally far from it.
+    let width = |label: &str| {
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        let mut w = 0.0;
+        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| w = crate::widgets::button_width(ui, label));
+        out.textures_delta.clear();
+        w
+    };
+    let (new_x, centre) = text_centre_x(&mut app, "New file").unwrap();
+    let (open_x, _) = text_centre_x(&mut app, "Open").unwrap();
+    let left = new_x - width("New file") / 2.0;
+    let right = open_x + width("Open") / 2.0;
+    assert!((centre - left - (right - centre)).abs() < 6.0, "New / Open row is centred: {left}..{right} about {centre}");
+}
diff --git a/crates/ui-egui/src/tests/place.rs b/crates/ui-egui/src/tests/place.rs
index 9406ba2c9..000667dba 100644
--- a/crates/ui-egui/src/tests/place.rs
+++ b/crates/ui-egui/src/tests/place.rs
@@ -710,6 +710,57 @@ fn tool_key(app: &mut VectorcraftApp, key: vectorcraft_tools::ToolKey) {
 /// #734: Crop Image shows a crop box on the image instead of cropping to the artboard at once (an
 /// image inside the artboard had nothing to cut); Apply crops to the box in one undo step, Cancel
 /// leaves the image whole, and both go back to the Selection tool.
+/// Holding Escape with the place cursor loaded discards one file for the press. The repeats discard
+/// no more and run no command bound to Escape.
+#[test]
+fn holding_escape_with_the_place_cursor_loaded_discards_one_file() {
+    let mut app = app();
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    app.run("shortcuts.set", json!({"id": "select.none", "shortcut": "Escape", "force": true})).unwrap();
+    let id = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone();
+    app.run("select.set", json!({"ids": [id]})).unwrap();
+    let paths: Vec<String> = ["held-a.png", "held-b.png", "held-c.png"].iter().map(|name| temp_file(name, &png(10, 10, 72.0))).collect();
+    app.run("file.place", json!({"paths": paths})).unwrap();
+    crate::dialogs::confirm(&mut app).unwrap();
+    assert_eq!(app.session.tool_options()["count"], 3);
+    let selected = app.session.active().unwrap().selection.objects.clone();
+    assert!(!selected.is_empty());
+    let key = |pressed| egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed, repeat: false, modifiers: Default::default() };
+    frame(&mut app, &ctx, vec![], &[], false);
+    for repeat in 0..4 {
+        frame(&mut app, &ctx, vec![key(true)], &[], false);
+        assert_eq!(app.session.tool_options()["count"], 2, "repeat {repeat}: one file is discarded");
+        assert_eq!(app.session.active().unwrap().selection.objects, selected, "repeat {repeat}: no command ran");
+    }
+    frame(&mut app, &ctx, vec![key(false)], &[], false);
+    frame(&mut app, &ctx, vec![key(true)], &[], false);
+    assert_eq!(app.session.tool_options()["count"], 1, "a new press discards the next file");
+}
+
+/// A command bound to Shift+Escape keeps repeating with the place cursor loaded, and no file is
+/// discarded.
+#[test]
+fn holding_a_chord_bound_to_a_command_repeats_it_with_the_place_cursor_loaded() {
+    let mut app = app();
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    app.run("shortcuts.set", json!({"id": "view.zoomIn", "shortcut": "Shift+Escape", "force": true})).unwrap();
+    let paths: Vec<String> = ["chord-a.png", "chord-b.png"].iter().map(|name| temp_file(name, &png(10, 10, 72.0))).collect();
+    app.run("file.place", json!({"paths": paths})).unwrap();
+    crate::dialogs::confirm(&mut app).unwrap();
+    let modifiers = egui::Modifiers::SHIFT;
+    let press = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers };
+    frame(&mut app, &ctx, vec![], &[], false);
+    let mut zoom = app.view().unwrap().zoom;
+    for repeat in 0..3 {
+        frame(&mut app, &ctx, vec![press.clone()], &[], true);
+        assert!(app.view().unwrap().zoom > zoom, "repeat {repeat}: the command runs");
+        assert_eq!(app.session.tool_options()["count"], 2, "repeat {repeat}: no file is discarded");
+        zoom = app.view().unwrap().zoom;
+    }
+}
+
 #[test]
 fn crop_image_shows_a_box_that_apply_crops_to() {
     use vectorcraft_tools::ToolKey;
@@ -781,8 +832,6 @@ fn frame_at(app: &mut VectorcraftApp, ctx: &egui::Context, time: f64) -> std::ti
 /// for) or until `done` → whether it was.
 fn idle(app: &mut VectorcraftApp, ctx: &egui::Context, time: &mut f64, secs: f64, done: &dyn Fn(&VectorcraftApp) -> bool) -> bool {
     let end = *time + secs;
-    // The look last waited for: one that a frame after the wait still holds ended without stamps.
-    let mut waited: Option<vectorcraft_engine::link_watch::LinkScan> = None;
     loop {
         let wait = frame_at(app, ctx, *time);
         if done(app) {
@@ -795,11 +844,8 @@ fn idle(app: &mut VectorcraftApp, ctx: &egui::Context, time: &mut f64, secs: f64
         }
         // The look runs on a worker thread, in real time: the clock waits for it to finish, else a
         // busy machine's slow look outlasts the simulated seconds and the test fails at random.
-        if let Some(scan) = app.session.link_scan.clone()
-            && !waited.as_ref().is_some_and(|w| std::sync::Arc::ptr_eq(w, &scan))
-        {
+        if app.session.link_scan.is_some() {
             app.session.wait_link_scan();
-            waited = Some(scan);
             continue;
         }
         *time = next;
@@ -842,3 +888,45 @@ fn a_file_placed_while_idle_follows_its_changes() {
     };
     assert!(idle(&mut app, &ctx, &mut time, 10.0, &updated), "the changed file was never read again");
 }
+
+/// A look whose worker ended without stamps is cleared: the app stops asking for a frame every
+/// 100 ms, and the next look, on schedule, reads a changed file again.
+#[test]
+fn a_look_whose_worker_stopped_does_not_stop_later_looks() {
+    let mut app = app();
+    // Every frame renders on this thread: a frame finished by the render worker asks for a repaint.
+    app.canvas.worker_started = true;
+    app.run("prefs.set", json!({"key": "updateLinks", "value": "automatically"})).unwrap();
+    let path = temp_file("stopped-watch.png", &png(40, 30, 72.0));
+    app.run("file.place", json!({"path": path})).unwrap();
+    let id = app.session.active().unwrap().selection.objects[0];
+    let ctx = egui::Context::default();
+    let mut time = 0.0;
+    idle(&mut app, &ctx, &mut time, 3.0, &|_| false);
+    // A look that is due starts in this frame and is applied in the next one, at the same time.
+    time += 3.0;
+    frame_at(&mut app, &ctx, time);
+    app.session.wait_link_scan();
+    frame_at(&mut app, &ctx, time);
+    assert!(app.session.link_scan.is_none());
+    let scan = vectorcraft_engine::link_watch::LinkScan::default();
+    scan.2.store(true, std::sync::atomic::Ordering::SeqCst);
+    app.session.link_scan = Some(scan);
+    // Half a second later, before the next look is due.
+    time += 0.5;
+    let wait = frame_at(&mut app, &ctx, time);
+    assert!(app.session.link_scan.is_none(), "the look ended");
+    assert!(wait > std::time::Duration::from_millis(100), "{wait:?}: {:?}", ctx.repaint_causes());
+    let stamp = std::fs::metadata(&path).unwrap().modified().unwrap();
+    let changed = png(60, 30, 72.0);
+    std::fs::write(&path, &changed).unwrap();
+    // The rewritten file is dated 2 s later, however fast it was written.
+    let later = std::fs::FileTimes::new().set_modified(stamp + std::time::Duration::from_secs(2));
+    std::fs::OpenOptions::new().write(true).open(&path).unwrap().set_times(later).unwrap();
+    let hash = vectorcraft_doc::links::hash_bytes(&changed);
+    let updated = |app: &VectorcraftApp| {
+        let st = app.session.active().unwrap();
+        matches!(&st.doc.node(id).unwrap().kind, NodeKind::Image(im) if im.link.as_ref().and_then(|l| l.hash.as_deref()) == Some(hash.as_str()))
+    };
+    assert!(idle(&mut app, &ctx, &mut time, 10.0, &updated), "the changed file was never read again");
+}
diff --git a/crates/ui-egui/src/tests/screenmode.rs b/crates/ui-egui/src/tests/screenmode.rs
index 3dffb4aa8..56bcca519 100644
--- a/crates/ui-egui/src/tests/screenmode.rs
+++ b/crates/ui-egui/src/tests/screenmode.rs
@@ -488,6 +488,65 @@ fn held_escape_that_cancels_a_move_skips_a_command_bound_to_escape() {
     }
 }
 
+/// Holding Escape cancels the open dialog and does nothing else: Edit Toolbar's drawer stays open
+/// and isolation mode stays on, until new presses close the drawer and then leave the mode.
+#[test]
+fn held_escape_that_cancels_a_dialog_stays_in_isolation_mode() {
+    let ctx = egui::Context::default();
+    let mut app = in_screen_mode(&ctx, 0);
+    let group = app.session.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap();
+    app.session.execute("object.isolate", &json!({"id": group})).unwrap();
+    let isolated = |app: &VectorcraftApp| app.session.active().unwrap().isolation.is_some();
+    assert!(isolated(&app));
+    app.session.execute("select.all", &json!({})).unwrap();
+    app.select_tool("selection");
+    let _ = crate::toolbar::open_options(&mut app, "selection");
+    assert!(app.ui.dialog.is_some());
+    app.ui.tools_drawer = true;
+    frame(&mut app, &ctx, escape_event(true, false));
+    assert!(app.ui.dialog.is_none(), "Escape cancels Move");
+    for repeat in 0..4 {
+        frame(&mut app, &ctx, escape_event(true, true));
+        assert!(app.ui.tools_drawer, "repeat {repeat}: the drawer stays open");
+        assert!(isolated(&app), "repeat {repeat}: isolation mode stays on");
+    }
+    frame(&mut app, &ctx, escape_event(false, false));
+    frame(&mut app, &ctx, escape());
+    assert!(!app.ui.tools_drawer && isolated(&app), "a new press closes the drawer");
+    frame(&mut app, &ctx, escape());
+    assert!(!isolated(&app), "the next new press leaves isolation mode");
+}
+
+/// The repeats of the Escape that cancels a dialog or leaves Presentation Mode run no command bound
+/// to Escape. A new press does.
+#[test]
+fn held_escape_that_cancels_a_dialog_or_leaves_presentation_skips_a_command_bound_to_escape() {
+    for presentation in [false, true] {
+        let ctx = egui::Context::default();
+        let mut app = in_screen_mode(&ctx, 0);
+        app.run("shortcuts.set", json!({"id": "select.none", "shortcut": "Escape", "force": true})).unwrap();
+        let selected = app.session.active().unwrap().selection.objects.clone();
+        assert!(!selected.is_empty());
+        if presentation {
+            app.run("view.presentation", json!({})).unwrap();
+            frame(&mut app, &ctx, vec![]);
+        } else {
+            app.select_tool("selection");
+            let _ = crate::toolbar::open_options(&mut app, "selection");
+            assert!(app.ui.dialog.is_some());
+        }
+        frame(&mut app, &ctx, escape_event(true, false));
+        assert!(app.ui.dialog.is_none() && app.ui.screen_mode != 3, "the press ends it (presentation: {presentation})");
+        for repeat in 0..4 {
+            frame(&mut app, &ctx, escape_event(true, true));
+            assert_eq!(app.session.active().unwrap().selection.objects, selected, "repeat {repeat} (presentation: {presentation})");
+        }
+        frame(&mut app, &ctx, escape_event(false, false));
+        frame(&mut app, &ctx, escape());
+        assert!(app.session.active().unwrap().selection.objects.is_empty(), "a new press runs the command (presentation: {presentation})");
+    }
+}
+
 #[test]
 fn a_popup_takes_escape_before_full_screen_exits() {
     let ctx = egui::Context::default();
diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs
index efde0d0b1..5a6daf1fa 100644
--- a/crates/ui-egui/src/widgets.rs
+++ b/crates/ui-egui/src/widgets.rs
@@ -28,7 +28,7 @@ pub use buttons::{
     SPLIT_ARROW, flat_button, flat_button_fit, icon_button, icon_button_enabled, menu_item, menu_item_name, paint_icon_button, primary_button,
     primary_button_enabled, secondary_button, split_button, split_button_named, toggle_icon,
 };
-pub(crate) use buttons::{icon_button_info, primary_button_width, secondary_button_width};
+pub(crate) use buttons::{button_width, icon_button_info, primary_button_width, secondary_button_width};
 #[cfg(test)]
 use chips::gradient_chip_colors;
 pub use chips::{ProxyClicks, chip_button, chip_button_named, fill_stroke_proxy, gradient_chip, paint_chip, proxy_chip, swatch_tile};
diff --git a/crates/ui-egui/src/widgets/buttons.rs b/crates/ui-egui/src/widgets/buttons.rs
index 44ee3c477..a33f7cac8 100644
--- a/crates/ui-egui/src/widgets/buttons.rs
+++ b/crates/ui-egui/src/widgets/buttons.rs
@@ -101,6 +101,13 @@ fn flat_fill(ui: &Ui, rect: Rect, resp: &Response) {
     }
 }
 
+/// The width [`primary_button`] and [`secondary_button`] give `text` (their label plus padding, at
+/// least 72), for centring a row of them.
+pub(crate) fn button_width(ui: &Ui, text: &str) -> f32 {
+    let galley = ui.painter().layout_no_wrap(tl!(text).to_string(), theme::semibold(12.5), Color32::PLACEHOLDER);
+    (galley.size().x + 32.0).max(72.0)
+}
+
 /// The accent call-to-action button (dialog OK/Create).
 pub fn primary_button(ui: &mut Ui, text: &str) -> Response {
     primary_button_enabled(ui, text, true)
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index a0e392cd6..0a9bfd9f0 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -94,7 +94,7 @@ the two can still win that race.
 | `document.inspect` | `{depth?, childLimit?, ids?, kind?, limit?, offset?}` | layer tree, selection, the key object (`key`, null without one; a key ruler guide as `keyGuide`), history, paint defaults; `depth` / `childLimit` slice the layer tree as `document.node {summary: true}` does; `ids`, `kind`, `limit` and `offset` list just some nodes as `nodes` (with `total`) instead of the whole tree, see [mcp.md](mcp.md). Each node reports `opacity` below 1 and `blend` when it isn't Normal; objects and compound paths report `fill`, `stroke` and `strokeWidth`, a compound path's members `compoundMember: true` instead |
 | `ui.inspect` | | tool, UI state, `screenMode` (0 normal, 1 full screen with menu bar, 2 full screen, 3 Presentation Mode), `taskBar` (`pinned`, and `rect` `[x, y, w, h]` while the Contextual Task Bar shows), `freeTransformWidget` (`[x, y, w, h]` while the Free Transform widget shows), view, canvas rect, window size, perf, background saves and exports still running, `nativeMenuBar` (true when the menus are in the macOS menu bar rather than the window; `ui.menu.list` lists the in-window menus either way), `fileDialog` (`"open"`, `"place"`, `"save"` or `"folder"` while a native file dialog is open, `null` otherwise; see below) |
 | `ui.menu.list` / `ui.menu.invoke` | `{command, params}` | the full menu tree / invoke an item |
-| `ui.contextMenu.list` | | the canvas context menu for the current selection, flattened like `ui.menu.list` (`path` holds its submenus). `ui.click {x, y, button: "right"}` on the canvas opens it, after selecting the object there unless it is already selected. While a menu opened over locked objects is open, it has an `Unlock` submenu with one item for each locked object under the pointer, topmost first and at most 20, labeled with the object's name, which runs `layer.setProps {ids: [id], locked: false}`. A locked group gets one item, and the locked objects inside it get none. Hidden objects, objects on hidden, locked or template layers, and in isolation mode objects outside the isolated group get no item |
+| `ui.contextMenu.list` | | the canvas context menu for the current selection, flattened like `ui.menu.list` (`path` holds its submenus). `ui.click {x, y, button: "right"}` on the canvas opens it, after selecting the object there unless it is already selected. With the Artboard tool it lists the artboard entries (see `docs/mcp.md`), after selecting the artboard there unless it is already selected. While a menu opened over locked objects is open, it has an `Unlock` submenu with one item for each locked object under the pointer, topmost first and at most 20, labeled with the object's name, which runs `layer.setProps {ids: [id], locked: false}`. A locked group gets one item, and the locked objects inside it get none. Hidden objects, objects on hidden, locked or template layers, and in isolation mode objects outside the isolated group get no item |
 | `ui.tool.select` / `ui.tool.list` | `{tool}` | |
 | `ui.pointer` | `{events:[{kind: down|drag|up|move|doubleclick, x, y, space?: "doc"|"screen", mods?}]}` | drive the active tool exactly like the mouse: `mods.cmd` held at a press with any tool but a selection tool drags with the selection tool chosen last (Direct Selection with the Pen until one is), and the release gives the tool back as it was; the reply lists `selection`, `key` (the key object, null without one) and `tool`. With the Shape Builder or the Live Paint Bucket and a selection of more than 128 segments, the app finds the regions off the UI thread, so a `move` replies before the region under the pointer is highlighted, and the highlight shows in the first frame after the regions are found |
 | `ui.key` / `ui.text` | `{key, shift?, alt?, cmd?}` / `{text}` | synthetic keyboard input |
@@ -645,7 +645,7 @@ dialog, a drop) opens the `textImport` dialog (fields `platform`: `windows`/`mac
 `removeLineReturns`, `removeParagraphReturns`, `replaceSpaces`, `spaces`). `ui.dialog.confirm` places the file as area
 type with those options (`file.place {text: {…}}`).
 
-System clipboard formats: through the desktop app, `edit.copy` and `edit.cut` publish what `clipboard.flavours`
+System clipboard formats: through the desktop app, `edit.copy`, `edit.cut`, `artboard.copy` and `artboard.cut` publish what `clipboard.flavours`
 lists to the system clipboard (once they are written, the status bar shows the first of the PNG's and PDF's
 `warnings`, such as an image that couldn't be decoded), and every Paste command first loads what another app copied (`clipboard.importSvg`,
 `importPdf`, `importEps`, `importText` or `importImage`, centred in the view; the desktop app reads PDF and EPS from
@@ -1000,8 +1000,10 @@ app:
 |---|---|
 | `vectorcraft.request(method, params)` | any control method of this document → its `result` |
 | `vectorcraft.execute(command, params)` | `engine.execute` |
-| `vectorcraft.commands()` / `vectorcraft.inspect()` | `engine.commands` / the inspect method |
-| `vectorcraft.screenshot(params)` | `ui.screenshot` (no `path`: the PNG comes back inline) |
+| `vectorcraft.commands()` | `engine.commands` |
+| `vectorcraft.docInspect(params)` / `vectorcraft.uiInspect(params)` | `document.inspect` / `ui.inspect` |
+| `vectorcraft.inspect()` | `ui.inspect` (the name before `uiInspect`) |
+| `vectorcraft.screenshot(params)` | `ui.screenshot` (no `path`: the PNG comes back inline, as `data` and as `pngBase64`) |
 | `vectorcraft.openFile(name, bytes)` | opens the bytes the way a dropped file opens (returns `true` once queued) |
 | `vectorcraft.captureDownloads(on)` | while on, a save or export is kept in the page instead of downloaded |
 | `vectorcraft.files()` / `vectorcraft.readFile(name)` | the kept files (`{path, size}`) / one of them as a `Uint8Array` |
@@ -1009,6 +1011,8 @@ app:
 Errors reject with an `Error` carrying the method's message. Requests run on the UI's next frame, so a
 hidden tab (whose frames the browser pauses) answers when it is shown again.
 
+`request`, `execute`, `commands`, `docInspect`, `uiInspect` and `screenshot` come from [`craft-web-api`](https://github.com/storytold/craft-libs/tree/main/crates/web-api) (storytold/craft-libs#413), the same shape in every Craft app. A call the app does not answer within 30 seconds rejects, and the app drops it unrun if it had not started it. `openFile`, `captureDownloads`, `files`, `readFile` and `inspect` are VectorCraft's own.
+
 ## Revision history
 
 | Date | Change | Summary |
diff --git a/docs/effects-parity.md b/docs/effects-parity.md
index 2878c5682..2307add80 100644
--- a/docs/effects-parity.md
+++ b/docs/effects-parity.md
@@ -1,6 +1,6 @@
 # Effects parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-05 · **Change:** minor (Expand Appearance makes each copy of a path's Transform effect an object of its own (#5612); previously: Pixelate › Color Halftone: Max Radius in pixels of the Document Raster Effects resolution, 4–127 px, with older documents converted on opening and radii written back in points for older app versions (#3260); Effect dialogs clamp bounded length inputs immediately on commit and flash rejection on invalid input (#4638); previously: Drop Shadow Darkness uses fixed RGB subtraction and CMYK black addition; scores unchanged; Pathfinder › Trap: the Pathfinder panel's Trap… and Effect › Pathfinder › Trap… add an overprinting strip of the lighter colour where two solid colours meet; recounted with Hard Mix (#3061) and Soft Mix already in the catalogue: Pathfinder 13/13, Illustrator effects 49/50) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-06 · **Change:** minor (Extrude & Bevel, Inflate and Rotate apply to groups and layers, their objects turning about one shared axis (#4506); the Transform effect's copies of a path with a fill and a stroke (or several fills and strokes, an even-odd fill, or a partly transparent one) are drawn each above the one before, as Expand Appearance makes them (#5920); Expand Appearance makes each copy of a path's Transform effect an object of its own (#5612); previously: Pixelate › Color Halftone: Max Radius in pixels of the Document Raster Effects resolution, 4–127 px, with older documents converted on opening and radii written back in points for older app versions (#3260); Effect dialogs clamp bounded length inputs immediately on commit and flash rejection on invalid input (#4638); previously: Drop Shadow Darkness uses fixed RGB subtraction and CMYK black addition; scores unchanged; Pathfinder › Trap: the Pathfinder panel's Trap… and Effect › Pathfinder › Trap… add an overprinting strip of the lighter colour where two solid colours meet; recounted with Hard Mix (#3061) and Soft Mix already in the catalogue: Pathfinder 13/13, Illustrator effects 49/50) · **Target:** Adobe Illustrator 2026 (30.x)
 
 Every entry of Illustrator's Effect menu, by its public feature name, against VectorCraft's effects catalogue
 (`effect_catalog()` in `crates/effects/src/lib.rs`) and the Effect menu built from it
@@ -22,7 +22,7 @@ Part of [target-app-parity.md](target-app-parity.md); open work is in [gaps.md](
 |---|---|---:|---|
 | Convert to Shape | Rectangle, Rounded Rectangle, Ellipse | 3/3 | — |
 | Crop Marks | Crop Marks | 1/1 | — |
-| Distort & Transform | Free Distort, Pucker & Bloat, Roughen, Transform, Tweak, Twist, Zig Zag | 7/7 | Free Distort's dialog has a handle on each corner of the object's bounds, moved by dragging or with the arrow keys; Zig Zag's ridges are evenly spaced along each segment (#1558), and Smooth points make a continuous wave whose peaks and valleys have handles along the path (#2343); Roughen with Smooth keeps turn-backs smooth instead of cusps that draw as spikes (#1646); Expand Appearance of a path whose Transform effect makes copies gives a group of one object per copy, each painted as the path, and a second Transform effect's copies nest in a group per copy of the first (#5612) |
+| Distort & Transform | Free Distort, Pucker & Bloat, Roughen, Transform, Tweak, Twist, Zig Zag | 7/7 | Free Distort's dialog has a handle on each corner of the object's bounds, moved by dragging or with the arrow keys; Zig Zag's ridges are evenly spaced along each segment (#1558), and Smooth points make a continuous wave whose peaks and valleys have handles along the path (#2343); Roughen with Smooth keeps turn-backs smooth instead of cusps that draw as spikes (#1646); Expand Appearance of a path whose Transform effect makes copies gives a group of one object per copy, each painted as the path, and a second Transform effect's copies nest in a group per copy of the first (#5612); drawn, each copy of a path with a fill and a stroke (or several, an even-odd fill or a partly transparent one) paints above the one before, its fill covering the strokes of the copies below, instead of one path of every copy (#5920) |
 | Path | Offset Path, Outline Object, Outline Stroke | 3/3 | With Use Preview Bounds on, Align, Distribute and the Transform panel still measure type that carries Outline Object by its layout box (preview bounds leave out effects) |
 | Pathfinder | Add, Intersect, Exclude, Subtract, Minus Back, Divide, Trim, Merge, Crop, Outline, Hard Mix, Soft Mix, Trap | 13/13 | Trap traps only solid fills (gradients and patterns hide what is below them but don't trap) and spreads each colour's visible area as a whole; the public page gives no default values, so Trap's 0.25 pt, 100% and 40% are VectorCraft's own |
 | Rasterize | Rasterize… (as a live effect) | 1/1 | — |
@@ -179,7 +179,7 @@ VectorCraft choices; an original approximation, never compared with another appl
 | Item | Ours |
 |---|---|
 | Revolve | initial: live, editable profile, rotation and light gizmos, default-on Cap with continuous curved rims, smooth vector shading and round seam joins, SVG/PDF output, Expand Appearance ([revolve.md](revolve.md), #846) |
-| Extrude & Bevel, Inflate, Rotate | initial: live, depth, twist, taper, solid or hollow caps, five original bevel shapes, Inflate volume, both sides, twist, taper and cap, Rotate of every fill and stroke, Position presets, rotation and light gizmos, SVG/PDF output, Expand Appearance ([three-d.md](three-d.md)) |
+| Extrude & Bevel, Inflate, Rotate | initial: live, depth, twist, taper, solid or hollow caps, five original bevel shapes, Inflate volume, both sides, twist, taper and cap, Rotate of every fill and stroke, groups and layers turned about one shared axis (#4506), Position presets, rotation and light gizmos, SVG/PDF output, Expand Appearance ([three-d.md](three-d.md)) |
 | Materials panel, lighting, ray-traced render | one to ten directional lights with per-light Color (opaque RGB, white by default), Intensity, Rotation, Height, Softness and neutral Ambient Light, Revolve and colored Inflate use smooth vector shading; Extrude & Bevel and Rotate retain planar shading; original Standard, Diffuse, Top Left and Right lighting rigs; no materials, shadows or ray tracing |
 | 3D (Classic): Extrude & Bevel, Revolve, Rotate | none |
 | Turntable (30.0 beta) | none |
@@ -193,6 +193,8 @@ angular cut caps, exact visibility, 3D Classic, Turntable, 3D export) is 25–45
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-06 | minor | Extrude & Bevel, Inflate and Rotate apply to a group or layer: a solid for every path, compound path and type in it, all turned about one shared axis as the public documentation describes for groups ([three-d.md](three-d.md#groups), #4506); scores and estimates unchanged |
+| 2026-11-06 | minor | The Transform effect's copies of a path or compound path whose fills and strokes stack (a fill and a stroke, several of either, an even-odd fill, or a partly transparent or blended one) are drawn each as an object of its own above the one before, as Expand Appearance makes them, instead of one path of every copy whose fill lay under every copy's stroke (#5920). A single opaque stroke or nonzero fill still draws as one path. Counts unchanged. |
 | 2026-11-04 | minor | Expand Appearance of a path or compound path whose Transform effect makes copies gives a group of one object per copy, each with the path's fills and strokes, instead of one compound path of every copy; copies of copies nest (#5612). Counts unchanged. |
 | 2026-10-30 | minor | Pixelate › Color Halftone: Max Radius is in pixels of the Document Raster Effects resolution, 4–127 px, as the [filter effects reference](https://helpx.adobe.com/photoshop/using/filter-effects-reference.html) gives it, instead of points (#3260): fine screens are possible at print resolutions (4 px at 300 ppi ≈ 0.96 pt). The dialog and the Appearance panel show it in px whatever the document units; documents saved before (document versions 1 and 2) open with each radius converted, so their dots stay the same size, and a file saved for an older app version (native versions before today's) holds them in points again. Scores unchanged. Tests: `vectorcraft_effects` `color_halftone_sizes_its_dots_in_pixels_of_the_raster_effects_resolution` and `color_halftones_radius_is_in_raster_pixels_not_a_distance`, `vectorcraft_doc` `halftone_radii::tests`, `vectorcraft_format` `halftone_radii_of_older_documents_open_in_pixels`, `vectorcraft_engine` `a_preserve_editing_pdf_opens_with_its_halftone_radius_in_pixels`, `dialogs::tests::color_halftones_max_radius_stays_in_pixels_whatever_the_units`. |
 | 2026-10-30 | minor | Effect dialogs: bounded length fields (Color Halftone Max Radius) clamp on commit and visibly reject invalid input (#4638); scores unchanged. |
diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md
index 5bd00e353..675edbb2e 100644
--- a/docs/file-format-parity.md
+++ b/docs/file-format-parity.md
@@ -1,6 +1,6 @@
 # File format parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-06 · **Change:** minor (`.ai` and EPS import: Art brushes in the older form of their objects come into the Brushes panel; SVG import: filter and mask regions clip, #5876, #5875; SVG import: Gaussian blurs keep `color-interpolation-filters`, #5877; PDF and `.ai` export: objects' URLs as links, #5785; SVG import: `color-interpolation="linearRGB"` gradients, #5878; `.ai` import: paths with a Calligraphic brush open brushed, #372) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-06 · **Change:** minor (`.ai` and EPS import: Art brushes in the older form of their objects come into the Brushes panel; EPS and `.ai` editing data: a transparency set inside a clipping group stays after its `Q`; SVG import: filter and mask regions clip, #5876, #5875; SVG import: Gaussian blurs keep `color-interpolation-filters`, #5877; PDF and `.ai` export: objects' URLs as links, #5785; SVG import: `color-interpolation="linearRGB"` gradients, #5878; `.ai` import: paths with a Calligraphic brush open brushed, #372) · **Target:** Adobe Illustrator 2026 (30.x)
 
 Every format Illustrator opens, places, saves or exports, against VectorCraft's format table (`FORMATS`,
 `OPEN_EXTS`, `PLACE_EXTS` in `crates/engine/src/cmd/fileio/formats.rs`). Illustrator's list comes from its public
@@ -18,7 +18,7 @@ from the public specifications, and users' own `.ai` files are used locally only
 | | Illustrator | VectorCraft | Notes |
 |---|---:|---:|---|
 | Formats opened or placed | ~30 | 29 | missing: FreeHand, CorelDRAW, DWG, HEIC/HEIF, PICT, PS |
-| Formats saved (Save As) | 6 (AI, AIT, PDF, EPS, SVG, SVGZ) | 6 + native | `.ai` written PDF-compatible (with an editing copy of the art: layers, groups, paths, colors, gradients, patterns, artboards, transparency, opacity masks, clipping) or as legacy version 7 (layers and groups, one artboard per file) |
+| Formats saved (Save As) | 6 (AI, AIT, PDF, EPS, SVG, SVGZ) | 6 + native | `.ai` written PDF-compatible (with an editing copy of the art: layers, groups, paths, colors, gradients, patterns, images, type, artboards, transparency, opacity masks, clipping) or as legacy version 7 (layers and groups, one artboard per file) |
 | Formats exported | ~16 | 17 | missing: DWG, 3D (OBJ/USDA/glTF); extra: GIF/PNG-8 palette export, DXF up to 2018, layered PSD |
 | **Overall (weighted by use)** | | **~75%** | `.ai` and PDF dominate the weighting |
 
@@ -47,6 +47,8 @@ private editing data. VectorCraft:
   objects keep what only the format records (locks, for example); it opens as its page when the layer can't be used.
   A multi-layer mask (`Mb` … `Md` … `MB`) comes in as a clipping group in each layer it covers, each
   clipped by a copy of the mask's path.
+  An opacity mask's art of one shown object, other than a guide or a clipping path, opens as that object in the
+  editing data of a `.ai`, EPS or PDF; other art opens in a group.
   RGB in the PDF page's `ICCBased` spaces keeps the file's numbers in a `.ai` (the `uncalibrated_rgb`
   import option, on for editor documents, off for PDFs), so `.ai` files tagged with a non-sRGB RGB profile
   open with different, unconverted RGB colours than before.
@@ -62,7 +64,9 @@ private editing data. VectorCraft:
   Editing Data for Other Apps) every page's `PieceInfo` also carries an editing copy of the art in
   `AIPrivateData` streams, in the form VectorCraft's `.ai` reader reads: layers and sublayers, groups, paths with
   their fills and strokes (a compound path as one path of all its subpaths), process, spot and global colors, swatches and color groups, guides,
-  hidden and locked objects, object names, every artboard with its name, the transparency of objects and layers
+  hidden and locked objects, object names, every artboard with its name, the active artboard (`CropAreaActive`: the
+  view's active artboard when the app saves or exports the file, else the one the document opened on, else the first;
+  the reader opens the file on it), the transparency of objects and layers
   (opacity, blending mode, isolation, knockout and knockout shape), objects' opacity masks, and clipping groups and
   clipping layers clipped by a path or compound path, linear and radial gradients on fills and strokes (with their
   stops' opacity, midpoints and spot colors, elliptical radials and focal points) and gradient swatches, and
@@ -71,8 +75,16 @@ private editing data. VectorCraft:
   RGB or CMYK ink amounts, and their alpha channel) and linked images as placed files with their path, their folder
   relative to the document's and a preview; images that can't be decoded or have more than 33,554,432 pixels are
   written as their outlines filled mid gray, images of 16 bits a channel at 8 bits, and linked images in opacity
-  masks and pattern tiles as embedded images, each with a warning. Type, other patterns, symbols, other clipping
-  objects and live objects (placed documents included) are written as plain filled and stroked paths, and freeform gradients, gradients along
+  masks and pattern tiles as embedded images, each with a warning. Point type, area type (with its rows, columns,
+  gutters and first baseline, threaded frames included) and type on a path are written as text: a text object for
+  each, naming its story in the text document, with the characters, fonts, sizes, leading, tracking, baseline shift,
+  scales, solid fills and strokes, capitals and paragraph alignment, indents, spacing and direction; other character
+  and paragraph attributes are left out with a warning. Type in opacity masks, pattern tiles and art cut to a
+  clipping object, mirrored type, turned or unevenly scaled area type and type on a path, area type in an open frame,
+  type on an open path whose ends meet, area type that flows around a text wrap, type of only white space, threads of
+  type on a path, threads whose frames differ in orientation, type and stories past the sizes VectorCraft's reader reads, and
+  type with inline graphics, ruby, gradient or pattern paint or an appearance or opacity mask of its own, other patterns, symbols, other clipping objects and live
+  objects (placed documents included) are written as plain filled and stroked paths, and freeform gradients, gradients along
   or across a stroke and gradients without stops, with more than 256 stops or without extent as their average
   color, each with a warning. Gradients that dither or mix their colors perceptually are written as classic
   gradients, and gradient stops linked to global process colors as their colors, each with a warning. The opacity
@@ -88,7 +100,7 @@ private editing data. VectorCraft:
   the options dialog's artboard picker (thumbnails to check, default all) is a file of its own,
   `{name}-{artboard}.ai` when there are several. It has no transparency: objects are written opaque, and images
   with see-through pixels, opacity or a blending mode are flattened (an opaque image of themselves and the art
-  under them, clipped to where they show; that art stays) or omitted (Transparent Images,
+  under them, clipped to where they show, along a smooth outline traced at the image's own resolution; that art stays) or omitted (Transparent Images,
   `transparentImages: "flatten"|"omit"`). Type is written as editable text objects (point type, area type and type
   on a path, with their fonts' PostScript names, sizes, colours, alignment, indents, leading, tracking and
   scaling), which the reading app sets in those fonts; characters outside Windows-1252, vertical type, ruby, inline
@@ -120,6 +132,14 @@ private editing data. VectorCraft:
   (`TE`) for the codes they leave out unless the `TZ` sets `useDefault` to 0.
   Its area type with several linked areas opens as threaded frames, one for each area with its own matrix,
   and the story flows through them.
+  Its writing direction (`TV`) opens as vertical type. VectorCraft keeps one direction for each text object, the
+  one in force at its first character, with a warning when a later character has another. Vertical point type
+  starts at the origin of `Tp`'s matrix on the column's center line, which is VectorCraft's own placement. Its Kumi
+  blocks (`Ty`, and `TY` in horizontal type) open as Tate-chu-yoko runs, which is VectorCraft's own mapping. A `TY`
+  block in vertical type opens unmarked, and two blocks with nothing between them open as one block. Its upright
+  Roman characters (`Tv`) open with Standard Vertical Roman Alignment. VectorCraft's own layout rule also sets a
+  run of two or three half-width digits across the column in vertical type, inside or outside a block and with
+  either `Tv` value.
   Legacy `.ai` type set in rendering modes 4 to 7 (`Tr`, text used as a mask) is a clipping path of its
   clipping group, as a `W` path is, and the mode lasts into later text objects. Type in linked areas, in
   wraparound text or in a compound path doesn't clip, with a warning. A `Tr` operand that is not a whole number
@@ -143,7 +163,7 @@ private editing data. VectorCraft:
 
 ### Illustrator's private editing data
 
-the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes (Art brushes in the older form of their objects too) replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes (Art brushes in the older form of their objects too) replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 
 ## Format by format
 
@@ -177,7 +197,7 @@ the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPri
 | CSS | export (CSS Properties) | — | yes | |
 | OBJ / USDA / glTF | 3D export | — | no | needs 3D (gap G3) |
 | Affinity `.af`, `.afdesign`, `.afpub` | no | yes (beyond Illustrator) | no (#665) | 51 pinned files, [affinity-validation.md](affinity-validation.md) |
-| Clipboard: PDF, SVG, PNG, EMF, text | yes | yes | yes | copied files paste as art |
+| Clipboard: PDF, SVG, PNG, EMF, text | yes | yes | yes | copied files paste as art; cells copied from a spreadsheet (tab-separated text) paste as a table of point type over gridlines, at most 1000 rows, 256 columns and 20,000 cells (#5296) |
 
 ## PDF editable imports
 
@@ -192,6 +212,11 @@ the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPri
 | Date | Change | Summary |
 |---|---|---|
 | 2026-11-06 | minor | `.ai` and EPS import: Art brushes whose objects are in the older form (first number 1, one field fewer and 8 numbers at the end) come into the Brushes panel with their art instead of being left out with a note. In a survey of 302 users' EPS files (used locally, not committed), 652 Art brushes in 188 of the 197 files with the note were left out this way; afterwards 55 files have the note, all for Pattern brushes. Test `an_older_art_brush_comes_in_with_its_art` (crate `vectorcraft-eps`); scores unchanged |
+| 2026-11-06 | minor | EPS and `.ai` editing data: `Q` restores the painting state but not the transparency (`Xy`), which the writer only sets when the next object's differs from the last one written. A Screen glow followed by a clipping group set back to Normal no longer leaves the type after the group in Screen: two users' Illustrator 26.5 and 30 EPS posters (used locally, not committed) now show their gold heading and crescent, and both open from their layers (2.5% and 2.7% from the page before, under the limit after). Scores and estimates unchanged. |
+| 2026-11-06 | minor | EPS and `.ai` editing data: a blend whose spine was never edited, written with its keys and no spine part, comes in as a live blend along the straight lines between its keys' centres (in its record's order) instead of as its drawn steps. Checked on six users' Illustrator EPS files (used locally, not committed): every blend in four of them now comes in live, their renders unchanged; two still have blends the reader can't match to their drawn steps. Scores and estimates unchanged. |
+| 2026-11-06 | minor | EPS and `.ai` editing data: the art styles are found before the art is read, so objects in symbols defined ahead of `%AI9_BeginArtStyles` (as Illustrator 24 writes it) come in as themselves with their style instead of their drawn look. Checked on two users' EPS files (used locally, not committed): one's Symbols panel gains live Feather and Round Corners, its drawn-look count drops from 5 to 2, and both render unchanged; own-fixture test in `import::ai::tests`; scores and hours unchanged |
+| 2026-11-06 | minor | Legacy `.ai` (version 7) export: the clipping path around a flattened transparent image followed 2 pt cells, a staircase that was visibly jagged at the image's resolution. It now follows the image's own pixels (in blocks only past 4 million pixels), grown by one pixel so the whole anti-aliased edge is inside, and runs through the middle of each pixel edge with Douglas–Peucker simplification, so slopes and curves are sloped lines instead of steps (#5264). Version 7 images have no alpha channel (§8.1 of the published format specification), so the image itself is still opaque. Test `legacy_ai::a_flattened_images_clip_follows_its_edge_smoothly` (crate `vectorcraft-engine`); scores unchanged |
+| 2026-11-06 | minor | Paste: cells copied from Excel, Google Sheets, LibreOffice Calc or Numbers (tab-separated text, quoted cells too) paste as a group of point type, one object per cell in columns and rows, over 0.5 pt gridlines; other text pastes as before; scores and estimates unchanged (#5296) |
 | 2026-11-06 | minor | SVG import: filter and mask regions clip (SVG 1.1 §15.5, §14.4). An object whose imported blur, shadow or glow reaches past its filter's region comes in inside a clip group cut to the region (#5876), and a mask's art is cut to the mask's region, in user space or the object's bounding box (#5875). Objects that fit their regions, and our own exports, are unchanged; primitive subregions are still ignored. Tests `import_live::a_blur_is_cut_at_its_filter_region`, `import_live::a_mask_counts_only_inside_its_region` (crate `vectorcraft-svg`); scores unchanged |
 | 2026-11-06 | minor | SVG import: a Gaussian blur keeps the colour space its filter asks for with `color-interpolation-filters` (initially `linearRGB`, SVG 1.1 §15.7.6): a linear-light blur becomes Gaussian Blur with the new `linear` parameter, which blurs the colours in linear light (black beside white meets at about 188/255 instead of 128), and SVG export writes it back on the `feGaussianBlur` (#5877). Blurs that ask for sRGB, and the blurs our own export writes, are as before. CSS export still writes `blur()`. Tests `pixel::tests::linear_light_blur_mixes_light_not_values` (crate `vectorcraft-effects`), `import_live::a_gaussian_blur_keeps_its_colour_space` (crate `vectorcraft-svg`); scores unchanged |
 | 2026-11-06 | minor | PDF export and PDF-compatible `.ai` saves write each object's URL (Attributes panel) as a link annotation with a URI action (web and mail URLs only) over the bounds of the object that shows, trimmed by its clipping groups (ISO 32000-1, 12.5.6.5 and 12.6.4.7); hidden objects, layers that don't print and prints have none, and PDF/X files leave them out with a warning (#5785). Own-fixture tests in `tests::links`; PDF import doesn't read links back as URLs yet; scores unchanged |
diff --git a/docs/gaps.md b/docs/gaps.md
index adb50d60f..4dac9431e 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,9 +1,10 @@
 # Gaps
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-06 · **Change:** minor (Hindi catalog and contributor loanword preferences; agent wording pass complete; wider native proofreading welcome; an image zoomed in on is separated, colorized or proofed only where it shows (#4155); scores and estimates unchanged; a document's first frame renders on the render worker, so opening a heavy file no longer freezes the window; scores and estimates unchanged; large images in CMYK documents are shrunk before they are separated into ink planes (#4155); scores and estimates unchanged; `.ai` paths with a Calligraphic brush open brushed, with the 6D Art Pen's channels, and Windows reads the pen's tilt and barrel rotation, #372; scores and estimates unchanged; Compound Shapes add-on, beyond Illustrator; scores and estimates unchanged; Contour add-on, beyond Illustrator; scores and estimates unchanged; a slow first frame is waited for instead of restarting without the graphics adapter, and the menu bar no longer waits for the installed fonts' scan; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-07 · **Change:** minor (Indian-language hyphenation review and license allowlist, #4947; opening a slow file shows a progress window, part of #5930; Hindi catalog and contributor loanword preferences; agent wording pass complete; wider native proofreading welcome; an image zoomed in on is separated, colorized or proofed only where it shows (#4155); scores and estimates unchanged; a document's first frame renders on the render worker, so opening a heavy file no longer freezes the window; scores and estimates unchanged; large images in CMYK documents are shrunk before they are separated into ink planes (#4155); scores and estimates unchanged; `.ai` paths with a Calligraphic brush open brushed, with the 6D Art Pen's channels, and Windows reads the pen's tilt and barrel rotation, #372; scores and estimates unchanged; Compound Shapes add-on, beyond Illustrator; scores and estimates unchanged; Contour add-on, beyond Illustrator; scores and estimates unchanged; a slow first frame is waited for instead of restarting without the graphics adapter, and the menu bar no longer waits for the installed fonts' scan; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
 
 ## Feature submission evidence
 
+| 2026-11-06 | minor | Opening a file that takes longer than 0.4 s shows a progress window: the file name, a moving bar (reading reports no steps), how many more files wait, Cancel (Esc; the file doesn't open) and Continue in Background (`file.cancelOpen`, `file.openInBackground`); it never opens over another dialog or progress window (part of #5930); scores and estimates unchanged |
 Raster rendering fits and preflattens curved stroke outlines more tightly only below four times the raster tolerance, retaining thin-band coverage without changing stroke weight or vector export geometry. Current cached character/object outlines, cropped long strokes, gradient clips and effect rasters share the helper; cropped-region reuse and guarded flattening remain. The unchanged `fractional_curved_strokes_retain_coverage_between_notches` regression covers fractional weights, rotation, phase, opacity and f32-rounded endpoints. This is a quality/cost tradeoff, not a speed claim. Scores and estimates unchanged.
 
 **PR #3273 revision — 2026-11-04:** Thin curved stroke coverage ported to the current raster-only cache, cropped-long-stroke and effect paths with guarded flattening; vector export geometry unchanged. Scores and estimates unchanged.
@@ -36,6 +37,7 @@ Artboard Options forwards the active Artboard tool's Scale Artwork with Artboard
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-07 | minor | Indian-language hyphenation (#4947): eleven MIT-licensed pattern sets, with grapheme and shaping-cluster protection in both composers and existing paragraph limits. Assamese and Sanskrit are selectable; Sanskrit automatic patterns remain pending an allowlisted source. Scores and estimates unchanged. |
 | 2026-11-05 | minor | G15: long open strokes with an undashed width profile are outlined near the view while keeping profile positions on the full path; a 200,000-segment outline took 59.95 ms before and 8.44 ms after in local median runs. Closed and dashed profile strokes remain whole; estimate unchanged. |
 | 2026-11-05 | minor | G15: Direct Selection reuses one document hit result when choosing the cursor over a path; a 200,000-anchor path's segment cursor took 58.15 ms before and 29.33 ms after in local median runs. Cursor behavior is unchanged; estimate unchanged. |
 | 2026-11-05 | minor | G15: Selection skips building corner and pie widgets when the pointer is well outside a large selection; empty-canvas hover with 20,000 selected paths took 28.72 ms before and 16.41 ms after in local median runs. Other cursor targets remain active; estimate unchanged. |
@@ -192,10 +194,21 @@ from G14 and the budget run of G15: **~170–270 h** one agent, ~50–80 h wall
   weight, where the object's brush settings are the brush's own and its angle is on the page (#372, from a
   user's file of 6D Art Pen strokes: all 455 of its brushed styles), and a Calligraphic brush's Tilt, Bearing and
   Rotation (codes 4, 5 and 6) come in as those channels instead of Random. Others keep their drawn look.
+  Paths with an Art brush open the same way when the brush stretches art of solid-filled paths along the path,
+  unflipped, at 100% in Tints, and the path has none of its own settings, variable width, effects or a swatch
+  stroke. Other Art brushes (None or another colorization, another width, Proportional, between guides, flipped,
+  art with strokes, gradients or patterns) and type with an Art brush keep the drawn look.
 
 - **Missing:** faithful layer and group structure from the editing data in real files (#951: 109 layers instead
   of 14), open speed on large files (#758), live effects, Scatter, Art, Pattern and Bristle brushes on paths, a
-  path's own Calligraphic brush settings, and symbols as live objects (#637; plain art styles read Drop Shadow, Outer Glow and Feather as live effects; pattern fills and global colours are read since #1025, placed (linked) files since #1264). Writing Illustrator's own editing data is out of scope
+  path's own Calligraphic brush settings, and symbols as live objects (#637; plain art styles read Drop Shadow, Outer Glow and Feather as live effects; pattern fills and global colours are read since #1025, placed (linked) files since #1264). A PDF-compatible `.ai` carries an editing copy of the art in the form
+  VectorCraft's reader reads (layers, groups, paths, colors, gradients, patterns, images, transparency, opacity masks,
+  clipping and type as text), with live effects left out and symbols and live objects written as their art
+  ([file-format-parity.md](file-format-parity.md)). Save As
+  `.ai` › Version: Legacy (version 7) writes the PostScript form from the published version 7 specification,
+  keeping layers (names, order, visibility, lock), groups, compound paths, clipping groups, gradients and
+  of 14), open speed on large files (#758), live effects, Scatter, Pattern and Bristle brushes on paths, the Art
+  brushes listed above as keeping the drawn look, a path's own Calligraphic or Art brush settings, and symbols as live objects (#637; plain art styles read Drop Shadow, Outer Glow and Feather as live effects; pattern fills and global colours are read since #1025, placed (linked) files since #1264). Writing Illustrator's own editing data is out of scope
   (undocumented): a PDF-compatible `.ai` opens in Illustrator 2018 without its layers and groups (#868). Save As
   `.ai` › Version: Legacy (version 7) writes the PostScript form from the published version 7 specification
   instead, keeping layers (names, order, visibility, lock), groups, compound paths, clipping groups, gradients and
@@ -423,7 +436,7 @@ from G14 and the budget run of G15: **~170–270 h** one agent, ~50–80 h wall
 
 - **Done (2026-10-29, #4522):** the Pathfinder panel menu's Make, Release and Expand Compound Shape, which were dimmed placeholders, and the panel's Expand button act on live compound shapes ([Create compound shapes with Pathfinder](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/create-compound-shapes-with-pathfinder.html)): Alt-clicking a Shape Mode makes one in that mode, a Shape Mode sets the mode of the members selected, and the compound shape draws, exports and saves as the area its members' modes make (`object.compoundShape.*`, `crates/engine/src/tests/compound_shape.rs`). Left: blends, envelopes and warps as members, question marks on the buttons for mixed member modes, clicks that hit the area rather than the members. Estimate unchanged.
 - **Done (2026-10-25, #3426):** Pathfinder panel › Pathfinder Options… ([Pathfinder panel overview](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/pathfinder-panel-overview.html)): Precision (0.001–10 pt; results are refit to within it and pieces thinner than it are dropped), Remove Redundant Points and Divide and Outline Will Remove Unpainted Artwork (pieces of objects with no fill), kept in the preferences (`object.pathfinder.options`, group `pathfinder`) and used by every Shape Mode and Pathfinder button and Repeat; the page gives no defaults, so ours (0.01 pt, both off) keep the earlier results byte for byte. Trap is left as it was. Estimate unchanged.
-- **Done (2026-10-25):** Artboards panel › Delete Empty Artboards ([Delete artboards](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/add-edit-artboards/delete-artboards.html), [artboard context menu](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/use-artboard-context-menu.html)): `artboard.deleteEmpty` deletes every unlocked artboard with no artwork, with its guides, in one undo step, and keeps artboard 1 when every artboard is empty and none is locked; an artboard is empty when no object (hidden, locked and template art included; guides not) has visual bounds that meet or touch it, a group counting by its members and a clip group or clipping layer by its members inside the clip (our reading of "no artwork"; the pages give no finer rule). The canvas context menu doesn't list it yet. Estimate unchanged.
+- **Done (2026-10-25):** Artboards panel › Delete Empty Artboards ([Delete artboards](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/add-edit-artboards/delete-artboards.html), [artboard context menu](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/use-artboard-context-menu.html)): `artboard.deleteEmpty` deletes every unlocked artboard with no artwork, with its guides, in one undo step, and keeps artboard 1 when every artboard is empty and none is locked; an artboard is empty when no object (hidden, locked and template art included; guides not) has visual bounds that meet or touch it, a group counting by its members and a clip group or clipping layer by its members inside the clip (our reading of "no artwork"; the pages give no finer rule). The Artboard tool's canvas context menu lists it too. Estimate unchanged.
 - **Done (2026-10-25):** the Transform panel menu's Transform Object Only, Transform Pattern Only and Transform Both
   (`transformPanelPatterns`) choose what the panel's fields, flips and menu flips and the Properties panel's Transform
   section transform: the object with its pattern tiles left as they are, the tiles alone, or both; Use Registration
@@ -437,7 +450,7 @@ from G14 and the budget run of G15: **~170–270 h** one agent, ~50–80 h wall
   Estimate unchanged.
 - **Done (2026-10-21, #394):** General › Constrain Angle turns the arrow keys' axes (guides stay on the page's), holds Shift drags of the Selection, Direct Selection, Free Transform, Slice Selection, Reshape and Measure tools and the Pen's handles to the turned axes, and new rectangles, rounded rectangles, ellipses, grids, point and area type, Shift-drawn polygons and stars and the shape size dialogs are drawn along it with their bounding box turned; 0° and whole turns are exactly as before, quarter turns exact (<https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/rotate-objects-by-specific-angles.html>). Arcs, spirals, flares and the Pen's new paths are not turned yet. Estimate unchanged.
 - **Done (2026-10-21, #394):** General › Constrain Angle turns the arrow keys' axes (guides stay on the page's), holds Shift drags of the Selection, Direct Selection, Free Transform, Slice Selection, Reshape and Measure tools and the Pen's handles to the turned axes, and new rectangles, rounded rectangles, ellipses, grids, point and area type, Shift-drawn polygons and stars and the shape size dialogs are drawn along it with their bounding box turned; 0° and whole turns are exactly as before, quarter turns exact (<https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/rotate-objects-by-specific-angles.html>). Arcs, spirals, flares and the Pen's new paths are not turned yet. Estimate unchanged. **2026-10-24:** General › Corner Radius is the Rounded Rectangle tool's radius: the tool takes the preference when chosen and when it changes while the tool is active (or lent a selection tool for a drag), and the radius ↑/↓ set while drawing one, or a Tool Options value, becomes the preference, clamped to its 0–1296 pt range (<https://helpx.adobe.com/illustrator/using/drawing-simple-lines-shapes.html>). Estimate unchanged.
-- **Done (2026-10-17):** Background Export shows its progress in a dialog with Cancel and Continue in Background (#2564), on the shared cancel token (#2546); a cancelled export writes no file. Save As, Export for Screens and Export Selection don't show it yet. Estimate unchanged.
+- **Done (2026-10-17):** Background Export shows its progress in a dialog with Cancel and Continue in Background (#2564), on the shared cancel token (#2546); a cancelled export writes no file. Save As, Export for Screens and Export Selection don't show it yet. Estimate unchanged. **2026-11-06:** opening a file that takes longer than 0.4 s shows a progress window too, with a moving bar, Cancel and Continue in Background (part of #5930); Save and Place still show only the status bar's spinner. Estimate unchanged.
 - **Done:** quick Image Trace presets trace at once and leave the panel as it was; the Image Trace button (Control bar, Properties) opens the controls with Threshold and Advanced (Paths, Corners, Noise), as the public documentation describes (<https://helpx.adobe.com/illustrator/using/image-trace-results-optimization.html>). Other context-specific Properties gaps remain.
 - **Done (2026-10-31, #394):** Units › East Asian Type is read, and Q and Ha are units. 1 Q and 1 Ha are each a
   quarter of a millimetre (0.709 pt), the Japanese typesetting units: the [Illustrator Scripting Guide's
@@ -462,8 +475,8 @@ from G14 and the budget run of G15: **~170–270 h** one agent, ~50–80 h wall
   afterwards opens in a floating window of its own (G7's Float in Window); documents already open stay where they
   are. Estimate unchanged.
 - **Done:** Hyphenation › Default Language is the language of new type, unless Document Setup chose one, and each
-  run hyphenates in its own language (Character panel). Only English has break points so far: text in another
-  language stays whole, apart from the Exceptions list (#394).
+  run hyphenates in its own language (Character panel). English and eleven Indian languages have break
+  points; other languages stay whole apart from the Exceptions list (#394, #4947).
 - **Missing:** 2 Preferences options stored but not acted on (#394), each waiting on a subsystem of its own:
   Plug-ins & Scratch Disks › Primary and Secondary (documents are kept in memory; nothing pages to
   disk), and Clipboard Handling › Legacy vector clipboard with its Preserve Paths / Preserve Appearance and
diff --git a/docs/mcp.md b/docs/mcp.md
index de4a76d6f..1adcf32b1 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -438,7 +438,7 @@ opens the picker through `run_command` with the remote backend.
 | `open_panel` | `{panel}` | Remote only. `panel` is a panel id (`layers`, `swatches`, `colorGuide`, …, as `window.panel` takes) or its display label (`"Color Guide"`), in any case. |
 | `screenshot` | `{path?, scale?, artboard?, window?, max_side?, traceViews?}` | Returns MCP image content (`image/png`, base64) plus a text block. Renders the artboard with the pixels of a PNG `export` with `background: "white"` at the same scale; `traceViews:true` draws Image Trace objects in the view set with `imageTrace.setView`, as in the app's window; `window:true` captures the app window (remote only), as `ui_screenshot` does, and `max_side` (1–4096, window captures only) scales the returned image down as described for `ui_screenshot`. With `path` the backend (the headless session or the app) writes the PNG there too; a window capture written there keeps its full size with `max_side`. |
 | `open_file` | `{path}` | Opens any readable file as a new active document: `.vectorcraft`/`.drawcraft`, `.vctemplate`, `.svg`/`.svgz`, `.pdf`/`.ai`, `.ait`, `.eps`/`.epsf`, `.ps`, `.dxf`, `.emf`, `.wmf`, PNG (`.png`/`.pns`), JPEG, GIF, WebP, TIFF, BMP (`.bmp`/`.dib`/`.rle`), Targa (`.tga`/`.vda`/`.icb`/`.vst`), PCX, Pixar (`.pxr`), JPEG 2000 (`.jpf`/`.jpx`/`.jp2`/`.j2k`/`.j2c`/`.jpc`), PSD (`.psd`/`.pdd`)/PSB (an image opens as a document of its pixel size; a Photoshop file as its merged image). Templates (`.vctemplate`, `.ait`) open as a new untitled document. PDF, `.ai` and SVG files saved with Preserve Editing reopen as the document they carry. The reply is `document.open`'s: its `warnings` say what didn't come in as it was (an EPS whose PostScript can't be read opens as its preview, and the warning names the PostScript error, the operator and the procedure). `run_command document.formats` lists the formats. |
-| `save_file` | `{path?, compress?, version?, preview?, precision?, options?}` | Runs `document.save`: the document's own file in its own format (native `.vectorcraft` unless it was opened from or saved as SVG, PDF or a restorable `.ai`; then `warnings` say what that format loses). A path's extension picks the format (`.vectorcraft`, `.vctemplate`, `.pdf`, `.svg`, `.svgz`, `.ai`: a PDF carrying the native document, which reopens editable). For a native file, `compress: true` gzips it (default: the `useCompression` preference, Preferences › File Handling › Use Compression), `version` (1 to 4) writes it for an older VectorCraft (1 and 2 are never compressed, and `version: 2` with `compress: true` is an error), `preview: true` embeds a PNG of the first artboard, and `precision` (0 to 9) rounds path anchors and handles to that many decimal places for that save only (colors, transforms and type stay exact). `options` passes the format's save options as `run_command document.formats` lists them. When `compress`, `version`, `preview` or `precision` is given both at the top level and in `options` with different values, the call is an error (`` `compress: true` and `options.compress: false` disagree: give the option once ``) and nothing is written. The save drops each option the written format doesn't read. The reply's `warnings` then name each such option given (for example `` `compress` was not used: SVG files don't read it `` for an `.svg` path, and `` `options.preview` was not used: … `` for a key in `options`; a `.ai` file reads `compress` but not `version`, `preview` or `precision`). `run_command document.save` and the other save commands refuse any option given beside the path and in `options` with different values, and give the same warning for a top-level `compress`, `version`, `preview` or `precision`. The headless session and the app receive the same `app.save` params, and the app is also sent `wait: true`: the call returns once the file is written, or with the error (such as a path outside the write root), even with Background Save on. When the save asks first (the question before replacing a file that opened with losses, or on macOS and Linux the file dialog for an untitled document without `path`), the reply is `{pending}` or `"cancelled"` as before, and the save that runs after the answer uses the Background Save preference. |
+| `save_file` | `{path?, compress?, version?, preview?, precision?, options?}` | Runs `document.save`: the document's own file in its own format (native `.vectorcraft` unless it was opened from or saved as SVG, PDF or a restorable `.ai`; then `warnings` say what that format loses). A path's extension picks the format (`.vectorcraft`, `.vctemplate`, `.pdf`, `.svg`, `.svgz`, `.ai`: a PDF carrying the native document, which reopens editable). For a native file, `compress: true` gzips it (default: the `useCompression` preference, Preferences › File Handling › Use Compression), `version` (1 to 4) writes it for an older VectorCraft (1 and 2 are never compressed, and `version: 2` with `compress: true` is an error), `preview: true` embeds a PNG of the first artboard, and `precision` (0 to 9) rounds path anchors and handles to that many decimal places for that save only (colors, transforms and type stay exact). `options` passes the format's save options as `run_command document.formats` lists them. When `compress`, `version`, `preview` or `precision` is given both at the top level and in `options` with different values, the call is an error (`` `compress: true` and `options.compress: false` disagree: give the option once ``) and nothing is written. The save drops each option the written format doesn't read. The reply's `warnings` then name each such option given (for example `` `compress` was not used: SVG files don't read it `` for an `.svg` path, and `` `options.preview` was not used: … `` for a key in `options`; a `.ai` file reads `compress` but not `version`, `preview` or `precision`). For a `.ai` file, these warnings name the kind of `.ai` written: a legacy .ai (version 7) for `aiVersion: "7"`, a non-PDF-compatible .ai for `pdfCompatible: false`, and a PDF-compatible .ai otherwise, including a save that reuses the options the document was last saved with. `run_command document.save` and the other save commands refuse any option given beside the path and in `options` with different values, and give the same warnings for a top-level `compress`, `version`, `preview` or `precision` and for each key in `options` that the format doesn't read. The headless session and the app receive the same `app.save` params, and the app is also sent `wait: true`: the call returns once the file is written, or with the error (such as a path outside the write root), even with Background Save on. When the save asks first (the question before replacing a file that opened with losses, or on macOS and Linux the file dialog for an untitled document without `path`), the reply is `{pending}` or `"cancelled"` as before, and the save that runs after the answer uses the Background Save preference. |
 | `export` | `{path?, format?, scale?, artboard?, range?, selection?, outlineText?, options?}` | `svg`, `svgz`, `pdf`, `ai` (the PDF-compatible `.ai` that Save writes, which carries the document when every artboard is written in order), `eps`, `dxf`, `emf`, `wmf`, `png`, `jpg`, `webp`, `gif`, `png8` (an indexed `.png`), `tiff`, `bmp`, `tga`, `psd` (layered), `txt` (the document's text), `vectorcraft` or `template` (a native template). The tool's `format` enum and `document.formats` list them, generated from the engine's format table. When `format` is omitted, it comes from the path's extension. PDF and `.ai` write one page per artboard: all of them, or `artboard` (0-based) / `range` (`"1-3, 5"`, 1-based). SVG and SVGZ write one file per chosen artboard. EPS writes one file of the visible art; with `artboard`, `range`, `options.artboards` or `options: {"useArtboards": true}` it writes one file per chosen artboard, after a central file of the visible art when there are two or more, and `useArtboards: false` keeps the one file. Rasters, DXF, EMF and WMF write one artboard, or one file per chosen artboard with `options: {"useArtboards": true}`. Rasters also take `options: {"rect": [x, y, width, height]}` (page points, y down): that area of the page at the given `ppi`/`scale`, without an artboard and without changing the document; it is refused with `artboard`, `artboards`, `range` or `useArtboards`, with a non-positive or non-finite size, and for non-raster formats. `options` carries more format options (e.g. `{"quality": 80}` for JPEG). `selection: true` exports the selected objects cropped to their bounds (the reply adds their `bounds`, and reports `format` and the encoder's `warnings` as a whole-document export does); `outlineText: true` writes SVG text as paths. Template layers are left out, live effects are kept, and exporting `vectorcraft` never changes the document's path. Without `path` the bytes come back as `dataBase64`. Both backends run the same `document.export` call. |
 | `add_text` | `{text, x?, y?, width?, height?, fit?, fitMinPercent?, path?, mode?, pathEffect?, size?, font?, color?, justify?, vertical?}` | Point type at (x, y) (`justify`: `left`, `center` or `right` starts, centres or ends each line on x); area type with `width`/`height` (`fit`: `none`, `autoHeight`, `shrinkText`, as `text.areaOptions`); or `path` + `mode` (`area`/`onPath`) to flow text in or along a path, with `pathEffect` (`rainbow`, `skew`, `3dRibbon`, `stairStep`, `gravity`); `justify` (also `auto`, `justifyAll`) aligns the paragraphs of every kind, as `text.setStyle` does later. `vertical: true` uses the existing vertical writing mode for every kind (default `false`, horizontal). Returns `{id}`, with `overflow: true` when the text doesn't fit its frame or path. |
 | `apply_effect` | `{effect?, params?, ids?}` | Appends a live effect. Without `effect`, returns the effect catalogue with parameters and defaults. |
@@ -1068,10 +1068,15 @@ A command that takes its own date (`file.new {created}`, a save's `modified`) st
 variable. A blank, negative or non-numeric value is ignored and the clock decides, so an export is
 never refused over the environment. SVG output carries no time and was already reproducible.
 
-Two things stay on the real clock and are not pinned by the variable: the recovery heartbeat, and
-the random seed PDF encryption draws on. **A PDF exported with a password therefore still differs
-between runs** whatever `SOURCE_DATE_EPOCH` says, because that seed supplies its AES
-initialisation vectors and its file `/ID`. Reproducible output means an unencrypted export.
+Two things are not pinned by the variable: the recovery heartbeat, which stays on the real clock,
+and the random seed PDF encryption draws on, which mixes the OS random source with the clock. **A
+PDF exported with a password at PDF 1.4 or later therefore still differs between runs** whatever
+`SOURCE_DATE_EPOCH` says, because that seed supplies random bytes in its encryption dictionary and,
+at PDF 1.6 and later, its AES initialization vectors. Encryption at PDF 1.3 (RC4 40-bit) draws
+nothing from the seed, so that export repeats with the variable set. Encryption keeps the file `/ID`
+the export already wrote, which also repeats with the variable set; the seed supplies an `/ID` only
+for a file that has none. Reproducible output means an unencrypted export or a password-protected
+PDF 1.3 export.
 
 ### Parameter keys
 
@@ -3393,7 +3398,8 @@ the art on that artboard, in one undo step. The art is what an export draws, mea
 effects on paths, compound paths and symbol instances. An object counts for every artboard its bounds overlap, also
 when it reaches past the artboard's edge, and a group or a clipping layer counts whole. An artboard with no art on it,
 or a locked one, keeps its size and place. The call fails with `the artboard is locked` when every artboard it names is
-locked, and with `no artwork` when none of the others has art.
+locked, and with `no artwork` when none of the others has art. When every artboard already fits its art, no undo step
+is recorded.
 `artboard.fitToSelection {index?}` (Object › Artboards › Fit to Selected Art) fits artboard `index` to the selected
 art. Both commands take 0-based indexes and resize the first artboard when the call names none. The desktop app adds
 the selected artboards (those the Artboard tool has selected, else the active one) as `indices` to the
@@ -3576,7 +3582,7 @@ Guides change where a snapped point lands:
 The Snap to Glyph options (the desktop app's Character panel menu › Show Snap to Glyph Options; View › Snap to Glyph
 is the desktop app's): `view.snapToGlyph.options {baseline?, xHeight?, bounds?, proximity?, angular?, anchors?}` (or
 `prefs.get`/`prefs.set` with key `glyphSnap`, a partial object) reads and sets which guides Snap to Glyph gives, all on
-by default: the baseline and the x-height of a single line of type, the glyph bounds (each glyph's edges), the
+by default: the baseline and the x-height of a single line of type, the glyph bounds (each glyph's edges and corners, turning with rotated type), the
 proximity guides at both edges of each character's width, the angular guides (along a glyph's slanted strokes, and
 every guide of rotated type, which runs at its angle) and the glyphs' anchor points. `{}` reads them; a key it doesn't
 know or a value that isn't a boolean is refused and changes nothing.
@@ -3936,7 +3942,8 @@ Then `edit.paste` adds a copy of each artboard, together right of the last one a
 in the layers it came from, in one undo step (`edit.pasteInPlace`, `edit.pasteInFront` and `edit.pasteInBack` put
 them where they were; `edit.pasteOnAllArtboards` pastes only the art), in this document or another; the result's
 `artboards` lists the new artboards' indices and `artboard` is the first of them, and the Artboard tool, when chosen,
-selects them. `artboard.duplicate {index? | indices?, art?}` does the same in one step → `{index, indices, ids}`.
+selects them. `edit.paste {artboardsAt: [x, y]}` instead centers the copied artboards on that point, as they lay, and a
+value that is not `[x, y]` fails with `` `artboardsAt` must be [x, y] ``. `artboard.duplicate {index? | indices?, art?}` does the same in one step → `{index, indices, ids}`.
 Window › Artboards › Duplicate Artboards passes the selected artboards (those the Artboard tool has selected, else the
 active one) as `indices`, and a row dragged onto New Artboard passes its artboard as `index`.
 `artboard.move {copy: true, moveArt: true}` is the Artboard tool's Alt-drag. `artboard.duplicate` and `artboard.move`
@@ -3997,6 +4004,52 @@ it; a group counts by its members, a clip group or clipping layer by its members
 artboard left, artboard 1 can go). With
 nothing to delete the command is disabled and fails with `no empty artboards to delete`.
 
+Rename Artboards: `artboard.rename {index? | indices?, name}` renames artboards in one undo step, by default those the
+Artboard tool has selected, else its active one. One artboard takes `name`, trimmed. Several take it numbered in artboard
+order, `name-1`, `name-2` and so on. A locked artboard is renamed too. An empty name fails with
+`` `name` must not be empty ``, a name that is not a string fails with `` `name` must be a string ``, and an artboard
+that is not in the document fails with `no such artboard`. When every artboard already has its new name, the command
+records no undo step → `{renamed: [index…]}`. With no params, a menu click opens the `renameArtboards` dialog (fields
+`name` and `indices`), and OK with an empty name changes nothing. The Artboards panel's name field runs this command too.
+
+Switch Orientation: `artboard.switchOrientation {index? | indices?, scaleArt?, patterns?, lockedAndHidden?}` swaps the width and height of each
+artboard in one undo step, by default those the Artboard tool has selected, else its active one. Each top-left corner
+stays put, as with the Properties panel's Portrait and Landscape buttons. This rule for several artboards is VectorCraft's
+own. A square artboard and a locked one stay as they are, and the call fails with `the artboard is locked` when every
+artboard it names is locked. When no artboard changes, the command records no undo step → `{switched: [index…]}`.
+`scaleArt` scales the art with each artboard and defaults to the Artboard tool's Scale Artwork with Artboard option.
+`patterns` and `lockedAndHidden` work as they do on `artboard.setProps`.
+
+When a call to `artboard.duplicate`, `artboard.copy`, `artboard.cut`, `artboard.rename` or `artboard.switchOrientation`
+names no artboard, its journal entry records the artboards it acted on as `selectedArtboards`. A replay of the journal
+acts on those artboards, and a recorded action leaves the value out and acts on the selection when it plays.
+
+`artboard.selectAll {}` chooses the Artboard tool when another tool is in use and selects every artboard. The active
+artboard stays active, the art's selection stays as it is, and no undo step is recorded → `{selected: [index…]}`, the
+active artboard first.
+
+The canvas context menu with the Artboard tool lists the entries of the public
+[Use the artboard context menu](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/use-artboard-context-menu.html)
+page in the page's order, and no entries for objects or the view: Cut (`artboard.cut`), Copy (`artboard.copy`), Paste
+(`edit.paste`), Undo, Redo, New Artboard (`artboard.new`), Duplicate Artboards (`artboard.duplicate`), Rename
+(`artboard.rename`), Delete Artboards (`artboard.delete` with `indices`), Delete Empty Artboards
+(`artboard.deleteEmpty`), Select All Artboards (`artboard.selectAll`), Lock Artboards and Unlock Artboards
+(`artboard.setProps` with `locked`), Rearrange (`artboard.rearrange`), Fit to Artwork Bounds (`artboard.fitToArt`),
+Switch Orientation (`artboard.switchOrientation`), Artboard Options (`tool.options {tool: "artboard"}`) and Export
+(`file.exportForScreens`). Exit Isolation Mode and the Unlock submenu for locked objects under the pointer follow them.
+Cut, Copy, Duplicate Artboards, Rename, Delete Artboards, Lock Selected, Unlock Selected, Fit to Artwork Bounds, Switch
+Orientation and Export act on the artboards the tool has selected, else the active one. Artboard Options opens on the
+active artboard. New Artboard, Paste, Undo, Redo, Delete Empty Artboards, Select All Artboards and Rearrange do not act on
+the selected artboards. Lock All and Unlock All act on every artboard, and Lock All Except Selected acts on the artboards
+that are not selected. A right-click on an artboard that is not selected first selects it alone. An entry that cannot
+run is left out: Cut with a locked artboard or every artboard selected, Delete Artboards with no artboard to delete, Select All Artboards with every artboard selected, Rearrange with
+one artboard, Fit to Artwork Bounds with no art on a selected unlocked artboard, Switch Orientation with no selected
+artboard to change, and a lock entry with no artboard to change. The menu measures the art for Delete Empty Artboards and
+Fit to Artwork Bounds once, at the right-click. Paste centers copied artboards on the right-click's point
+(`edit.paste {artboardsAt: [x, y]}`) and centers copied objects there too (`center`). Chosen from a menu or the command
+palette with the tool in use, `artboard.new` makes the new artboard active, `artboard.duplicate` selects the copies,
+and `artboard.delete` and `artboard.deleteEmpty` make a remaining artboard active.
+
 Locked artboards: `artboard.setProps {index, locked: true}` locks an artboard and `{index, locked: false}` unlocks it,
 each in one undo step. The Artboards panel's lock column, left of a row's options icon, shows a lock on a locked
 artboard, and a click there runs this command. A locked artboard keeps its place and size. `artboard.setProps` with a
@@ -4308,7 +4361,9 @@ layer's objects hidden, or the page's objects when `document.open` would not use
 compatibility comes in from its editing data the same way with or without `editingData`), `clipboard.importEps
 {dataBase64}` (an EPS or other PostScript picture's objects, as `document.open` reads one, a hidden layer's objects
 hidden), `clipboard.importImage {dataBase64, mime?}` (an embedded image at 100% of its physical size) or
-`clipboard.importText {text}` (point text in the default type style), each centred on `center`
+`clipboard.importText {text, table?}` (point text in the default type style; cells copied from a spreadsheet,
+tab-separated rows with the same number of cells, become a group `Table` of point type per cell over 0.5 pt
+`Gridlines`, unless `table: false`), each centred on `center`
 (default: the first artboard); then any `edit.paste*` command pastes it. The desktop app does this itself: Copy and
 Cut publish the formats to the system clipboard, and a Paste outside text editing first reads what another app
 copied (SVG, then PDF, then text, then a bitmap; SVG markup in text counts as SVG). A background thread makes the
@@ -4645,7 +4700,10 @@ Modified documents get recovery copies (`file.recovery.save`; the app runs it ev
 `autosaveRecovery` is on, skipping documents of more than 20,000 objects while `recoveryOffForComplex` is on). A copy
 goes when its document is saved, reverted or closed, so copies still there after the app quits were left by a crash.
 The copies live in the `recoveryFolder` preference's folder (default: `Data Recovery` beside the app's preferences;
-none when the app runs with `VECTORCRAFT_NO_PREFS`) or, on the web, in browser storage.
+none when the app runs with `VECTORCRAFT_NO_PREFS`) or, on the web, in browser storage. `prefs.set` returns an error
+and changes nothing when a new `recoveryFolder` is missing, is not a folder, can't be listed, or is a folder that a
+folder can't be created in. It does not check an empty value or the folder the preference already holds, and the web
+build does not check folders. The folder in the example below must exist before the call.
 
 Each running app (each browser tab) keeps its copies in an area of its own (`<area>/<name>`): a sub-folder whose
 `.lock` file it keeps locked while it runs, or on the web an area with a heartbeat it refreshes every minute and a Web
@@ -4682,6 +4740,11 @@ or in `options` (`file.formatOptions {format}` lists them with their values):
 - `pdfCompatible`: native files (default false) also carry a PDF of every artboard (`pdf` in the file); `.ai` files
   (default true) with false write blank pages around the native document (smaller; other apps show empty pages).
 - `.ai` only: `compress` (default true) is the PDF option `compression.compressText`.
+- The editing copy of a `.ai` or `.ait` file (`editingData`) names its active artboard (`CropAreaActive`): the active
+  artboard of the app's view when the app saves or exports the file, otherwise the artboard the document opened on (the
+  active artboard of the `.ai` file it was opened from), else the first. A `.ai` file read from its editing copy
+  opens on that artboard. VectorCraft opens a `.ai` file it saved from the native document the file carries, on the
+  first artboard.
 
 File → Save As asks for these in the save options dialog (VectorCraft Options) after the save panel, and Save a Copy
 does too for a `.ai` file; Save, Save a Copy to a native file and Save as Template reuse the options as last saved (or Use Compression).
@@ -5008,7 +5071,14 @@ and Cut take. Typing, Delete and Cut replace the whole story as one undo step (`
 frames whose text goes), and a fill, stroke, `type.step` or Character or Paragraph panel change applies to the text of
 every frame (the Character panel sends `text.setRangeStyle {id, story: true}`, which styles every frame's text in one
 undo step). Remove Line Breaks, Remove Paragraph Breaks and Convert to Text also act on the text of every frame, as
-one undo step. A caret move or a click ends the story selection.
+one undo step. The panels change the frames that are in the edited frame's thread at the time of the change, locked and
+hidden frames included, and not a frame that has left it. A caret move or a click ends the story selection.
+one undo step. A caret move or a click ends the story selection. Switching to the Eyedropper keeps the story selected,
+and switching back to a Type tool restores it. `appearance.copyFrom` and `paint.sampleColor` then apply to the text of
+every frame as one undo step, and `appearance.copyFrom` leaves out a frame that is its `source`. While the story stays
+selected, its frames are the ones threaded with the edited frame at that moment: a frame that `text.thread.add` adds is
+highlighted and takes the edit, and a frame that leaves the thread is not highlighted and keeps its text. The story
+stays selected when a frame added before the edited frame takes all of its text. Once a thread is removed, typing replaces the text of the edited frame only.
 
 ```json
 {"name":"press_key","arguments":{"key":"A","mods":{"cmd":true}}}
@@ -5845,7 +5915,9 @@ that no built-in format has. A failing plug-in returns an error and leaves the d
 no file). A filter whose manifest asks for a heavy budget (minutes rather than a minute, `budget: "heavy"` in its
 `plugin.inspect {path | dataBase64}` entry) installs only with `allowHeavy: true`: ask the user first. `plugin.run`
 runs it where it is called, so the call may take minutes; `notifications/cancelled` stops it.
-`plugin.install` rejects a `replace` or `allowHeavy` value that is not a boolean.
+`plugin.install` rejects a `replace` or `allowHeavy` value that is not a boolean. `prefs.set` returns an error and
+changes nothing when a new `pluginsFolder` is missing, is not a folder or can't be listed. It does not check an empty
+value or the folder the preference already holds, and the web build does not check folders.
 
 ```json
 {"name":"run_command","arguments":{"command":"plugin.install","params":{"path":"/plugins/desaturate.wasm"}}}
@@ -6053,7 +6125,9 @@ a stroke when it has `rect`. With both `rect` and `points`, the command also tou
 ## Perspective grid
 
 The grid is document data (`perspective.grid.set` edits the model directly). `perspective.grid.get` reads it:
-`grid` (the model), `define` (the Define Grid fields), `station` (the viewer: `x` the centre of vision on the
+`grid` (the model), `define` (the Define Grid fields; its `name` is the preset only while the grid still has that
+preset's fields, else `""` for a custom grid, so dragging the horizon, a vanishing point or the station point clears it
+and moving a plane does not), `station` (the viewer: `x` the centre of vision on the
 horizon `y`, `distance` from the picture plane, in points) and `defined` (false while the document uses the default
 grid). `perspective.grid.define` sets the grid from the Define Grid fields: `kind`, `units`, `scale`
 (`[artboard, real world]`), `gridline`, `angle` (the viewing angle, 0–90°), `distance` (the viewing distance),
@@ -6123,6 +6197,13 @@ them with `image-rendering: pixelated` and PDF export writes them without `/Inte
 of a clip group, after Expand too. New envelopes start with Distort Appearance on, as in the reference app; envelopes saved before these
 options existed keep their old look (appearance applied after the distortion).
 
+An envelope opened from a `.ai` can have margins, written to native files as `boundsMargin` and reported by
+`object.envelope.info` when they are not zero: `[top, bottom, left, right]`, as shares of the content's height and
+width. While `distortAppearance` is on, the content maps from its geometric bounds grown by the margins, and while it
+is off, the content maps from its geometric bounds. Leaving Edit Contents measures the margins again when the content's
+strokes reach differently than when Edit Contents began, and always for an envelope whose file opened in Edit Contents.
+New envelopes have no margins, and no command sets them.
+
 `object.envelope.release` gives back the content and the envelope's shape (a grey gradient mesh for warp and mesh
 envelopes, the path for a top-object envelope); the content keeps the envelope's opacity, blend mode and opacity mask
 (a group around it carries them when there are several objects). `object.envelope.expand`, and `object.expand` with
diff --git a/docs/plugins.md b/docs/plugins.md
index bdd02b6f6..e1fcce813 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -52,7 +52,7 @@ background ([below](#heavy-filters)).
 **Preference folder.** Edit › Preferences › Plug-ins & Scratch Disks › *Additional Plug-ins Folder*: when set, every
 `*.wasm` in that folder (not recursive) is installed at startup and whenever the preference changes (desktop builds;
 the web build installs from bytes). On the desktop, Choose… beside the field picks the folder; the dialog refuses a
-picked or typed folder whose contents can't be listed.
+picked or typed folder whose contents can't be listed, and `prefs.set` refuses such a folder too.
 
 Plug-ins are installed **per process**, not per document. Documents store a live effect as an ordinary effect record
 (`{"id": "plugin.<id>", "params": {…}}`): while the plug-in is installed it is drawn, exported and expanded; without it
diff --git a/docs/roadmap.md b/docs/roadmap.md
index f3ad64942..c4246c711 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -1,6 +1,6 @@
 # Roadmap: milestones and what's next
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-06 · **Change:** minor (Hindi catalog and contributor loanword preferences; full wording review in progress; Effect dialogs: a colour swatch beside a hex colour opens the Color Picker, #5365; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-07 · **Change:** minor (Indian-language hyphenation review and license allowlist, #4947; Hindi catalog and contributor loanword preferences; full wording review in progress; Effect dialogs: a colour swatch beside a hex colour opens the Color Picker, #5365; shape tools move the selection from its centre point and turn it from the zone outside a box corner, #5477; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
 
 ## Feature submission evidence
 
@@ -36,6 +36,7 @@ M7 type: Touch Type moves a right-to-left character along its line and up from i
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-07 | minor | Indian-language hyphenation (#4947): eleven MIT-licensed pattern sets, with grapheme and shaping-cluster protection in both composers and existing paragraph limits. Assamese and Sanskrit are selectable; Sanskrit automatic patterns remain pending an allowlisted source. Scores and estimates unchanged. |
 | 2026-11-05 | minor | Effect dialogs: a colour swatch beside a hex colour field follows typed values, and a double-click opens the Color Picker over the dialog, whose OK fills the field (#5365); scores and estimates unchanged. |
 | 2026-11-05 | minor | Selection Tools add-on: Select Linked, Embedded, Missing and Modified select the images and placed documents with that link status (Object › Plug-ins › Selection Tools and the Links panel menu; Shift adds), and Select by Link Status… lists them by name, status and format to pick from, optionally zooming to them; what is hidden, locked, on a template layer or outside the isolated group is left out and the status bar says how many (#5526, a VectorCraft addition); scores and estimates unchanged (estimated). |
 | 2026-11-05 | minor | Pencil and Paintbrush: a new stroke with Keep selected off leaves nothing selected, the earlier selection included, while Keep selected on selects only the new path (#5752); scores and estimates unchanged. |
@@ -88,7 +89,7 @@ Checked 2026-10-10 from the code, tests and open issues; no workflow fails, so V
 | Set type: point and area type, Character and Paragraph styles, threading, outlines | yes | type core 80%; styles, threading, Create Outlines and font matching tested ([type-parity.md](type-parity.md)); justification options missing (not blocking) | 0 |
 | Organise layers and artboards and export assets (Export for Screens, SVG, PNG, PDF per artboard) | yes | Layers panel rework, Artboards panel and tool, Export for Screens and Asset Export done; Art Optimized supersample closes ghost borders (#983 / #1037) | 0 |
 | Print production: CMYK and spot colour, bleed and marks, PDF/X out, separations preview | yes | PDF/X-1a/3/4, presets, marks and bleed, ICC output intent, Separations Preview, Print with PostScript output | 0 |
-| Exchange files with Illustrator users: open their `.ai`/EPS/PDF, hand back a file they can open | partial (doesn't block alpha) | `.ai`, EPS and PDF open as editable art, but real files can get the wrong layer structure (#951); Save As `.ai` is PDF-compatible, which Illustrator opens without its own editing data (#868), or legacy version 7, which keeps layers, groups and type as text, one artboard per file, and waits for users' testing. EPS legacy mesh corners, vector opacity masks and raster print-page comparison now preserve editable art under synthetic regressions. This is the beta main-format gap ([gaps.md](gaps.md) G9) | 10–20 (for beta) |
+| Exchange files with Illustrator users: open their `.ai`/EPS/PDF, hand back a file they can open | partial (doesn't block alpha) | `.ai`, EPS and PDF open as editable art, but real files can get the wrong layer structure (#951); Save As `.ai` is PDF-compatible with an editing copy of the art (layers, groups, paths, colors, gradients, patterns, images, transparency, opacity masks, clipping and type as text, with live effects left out and symbols and live objects written as their art; #868), or legacy version 7, which keeps layers, groups and type as text, one artboard per file, and waits for users' testing. EPS legacy mesh corners, vector opacity masks and raster print-page comparison now preserve editable art under synthetic regressions. This is the beta main-format gap ([gaps.md](gaps.md) G9) | 10–20 (for beta) |
 
 Hindi interface follow-up (2026-11-06): the catalog and zero/one plural rule are implemented;
 native wording review, layout checks and a web Devanagari font remain. [Notes](localization-hi.md).
@@ -117,7 +118,8 @@ native wording review, layout checks and a web Devanagari font remain. [Notes](l
 | # | Milestone | Status | Est. remaining, one agent (h) |
 |---|---|---|---|
 | M0 | Skeleton + vertical slice | ✅ done | — |
-| M1 | Selection, transform, layers, MCP (common command tools, strict keys, session resources and version-aware result hints) | ✅ mostly done (document-tab artwork drag with lossless resource transfer and one target Undo; malformed MCP app replies discard the connection without replay, #1761; bounded control socket waits and connection-slot recovery, #1726; bounded synthetic control input, #1709; no-op anchor Align keeps Undo, Redo and saved state (#1180 follow-up); transform reference point snaps to anchors/centres; rotated objects keep a rotated bounding box and their angle; Free Transform, Scale and Reflect along a rotated box pending) | 4–6 |
+| M1 | Selection, transform, layers, MCP (common command tools, strict keys, session resources and version-aware result hints) | ✅ mostly done (document-tab artwork drag with lossless resource transfer and one target Undo; malformed MCP app replies discard the connection without replay, #1761; bounded control socket waits and connection-slot recovery, #1726; bounded synthetic control input, #1709; no-op anchor Align keeps Undo, Redo and saved state (#1180 follow-up); transform reference point snaps to anchors/centres; rotated objects keep a rotated bounding box and their angle; Free Transform, Scale and Reflect along a rotated box pending; the Transform fields take one Tab each, the W/H link after them) | 4–6 |
+| M2 | Drawing tools + smart guides | ✅ mostly done (Polygon/Star exact-size count persistence, with repeated-drag, tool-switch and Cancel regression coverage; Curvature point markers without direction handles (#1236, in part); Direct Selection segment click/Delete preserves neighboring edges, #1278; Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed, on any path's corners; Shaper rough-shape recognition and orientation steps, the remaining Pen modifier nuances; Shaper Groups with editable sources and separate fill/stroke edits landed; custom ruler origin with drag preview, active-artboard reset, relative X/Y fields and native round-trip (#1212); construction widget/refinements pending); a shape just drawn moves by its centre point and turns from the zone outside a corner with its tool still active (#5477); Tangent and straight-segment perpendicular snapping use saved Smart Guides Geometric Guides preferences and Control bar quick access (#2537); no View submenu | 12–18 |
 | M2 | Drawing tools + smart guides | ✅ mostly done (Polygon/Star exact-size count persistence, with repeated-drag, tool-switch and Cancel regression coverage; Curvature point markers without direction handles (#1236, in part); Direct Selection segment click/Delete preserves neighboring edges, #1278; Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed, on any path's corners; Shaper rough-shape recognition and orientation steps, the remaining Pen modifier nuances; Shaper Groups with editable sources and separate fill/stroke edits landed; custom ruler origin with drag preview, active-artboard reset, relative X/Y fields and native round-trip (#1212); construction widget/refinements pending); Tangent and straight-segment perpendicular snapping use saved Smart Guides Geometric Guides preferences and Control bar quick access (#2537); no View submenu | 12–18 |
 | M3 | Paint & appearance (swatches, color, gradient, stroke, appearance, transparency, styles) | ✅ done (M3.7–M3.98): swatches, groups, libraries, tints, Lab spots and Registration; Eyedropper styles highlighted text only (atomic transparency rejection); Eyedropper reads visible locked and outside-isolation sources (#1251); Color Picker, Color panel, Color Guide, Color Themes, Edit Colors and Recolor Artwork (screen-bounded Edit chip list, #3416); gradients that follow every transform, the annotator, linked stops, freeform gradients, focal points, gradients on strokes and Expand; visible strokes when paint is added to inherited None/zero-width art (#1253); stroke geometry, arrowheads, dashes fitted to corners, stroke on type, width profiles and the Width tool (Shift-double-click enables adjoining adjustment in Width Point Edit; finite-arithmetic follow-up regressions and full CI passed ([Validation evidence](target-app-parity.md#evidence-what-ships-today-by-area))), Scale Strokes and preview bounds; Appearance targeting, container appearance, target circles, Expand Appearance; knockout, isolation, blend accuracy, CMYK blending, overprint, Attributes, masks and clipping, Flatten Transparency; graphic styles, links and libraries; CSS library export preserves fractional linear and radial gradient stop positions. Left: freeform gradients in SVG/PDF, mixed spot/process gradients in SVG and PDF gradients mixing a spot color with RGB or Lab stops export as stops or process colors; PDF export writes dithered gradient fills with spot stops, and Perceptual spot gradients with RGB or Lab stops other than white or more than 4,096 stops on their curve, as images in process colors; confirm the Scale Strokes & Effects default; Recolor model selection is available through the engine and MCP only (#2520); the dialog retains its existing controls | 4–8 |
 | M2 | Drawing tools + smart guides | ✅ mostly done (Curvature point markers without direction handles (#1236, in part); Direct Selection segment click/Delete preserves neighboring edges, #1278; Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed, on any path's corners; Shaper rough-shape recognition and orientation steps, the remaining Pen modifier nuances; Shaper Groups with editable sources and separate fill/stroke edits landed; custom ruler origin with drag preview, active-artboard reset, relative X/Y fields and native round-trip (#1212); construction widget/refinements pending) | 12–18 |
@@ -125,9 +127,9 @@ native wording review, layout checks and a web Devanagari font remain. [Notes](l
 | M3 | Paint & appearance (swatches, color, gradient, stroke, appearance, transparency, styles) | ✅ done (M3.7–M3.98): swatches, groups, libraries, tints, Lab spots and Registration; Eyedropper styles highlighted text only (atomic transparency rejection); Eyedropper reads visible locked and outside-isolation sources (#1251); Color Picker, Color panel, Color Guide, Color Themes, Edit Colors and Recolor Artwork (screen-bounded Edit chip list, #3416); gradients that follow every transform, the annotator, linked stops, freeform gradients, focal points, gradients on strokes and Expand; visible strokes when paint is added to inherited None/zero-width art (#1253); stroke geometry, arrowheads, dashes fitted to corners, stroke on type, width profiles and the Width tool (Shift-double-click enables adjoining adjustment in Width Point Edit), Scale Strokes and preview bounds; Appearance targeting, container appearance, target circles, Expand Appearance; knockout, isolation, blend accuracy, CMYK blending, overprint, Attributes, masks and clipping, Flatten Transparency; graphic styles, links and libraries; CSS library export preserves fractional linear and radial gradient stop positions. Left: freeform gradients in SVG/PDF, mixed spot/process gradients in SVG and PDF gradients mixing a spot color with RGB or Lab stops export as stops or process colors; PDF export writes dithered gradient fills with spot stops, and Perceptual spot gradients with RGB or Lab stops other than white or more than 4,096 stops on their curve, as images in process colors; confirm the Scale Strokes & Effects default | 4–8 |
 | M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); opaque solid-fill knockout paths draw once in hard-edge/supersampled raster export, with analytical-AA compositing unchanged; file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); Craquelure/Mosaic Tiles/Stained Glass distance searches optimized with pixel-invariance checks and the `texture_drag_perf` probe (#1257); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
 | M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (live compound shapes: Make, Alt-click a Shape Mode, member modes, Release, Expand (#4522); single-result Pathfinder names and SVG IDs retained (#1293); Divide open-cutting-path geometry, appearance and history verified (#1307; existing segment cap remains); Simplify preview/counts and rewritten-path component selection verified (#1272; the slider opens at the Auto-Simplify level; a Direct Selection part of a path simplifies on its own); Compound appearance and member fill-rule edits verified (#1197); Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder gap detection, large-offset bug open); Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog | 3–6 |
-| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Hanging punctuation keeps its published amounts under Glyph Scaling, and Standard burasagari counts a hung line start as room; Fullwidth `！` / `？` keep an upright fallback in vertical type; Document-point character controls after object/group scaling (#1034; optional font-size preservation remains separate), Character/Paragraph Styles (explicit Auto-leading resets and local leading overrides), per-paragraph paragraph attributes, mixed paragraph alignment indication (headless regressions, full integration CI and visual review pass), Area Type Options (with Width/Height, Auto Size and Shrink Text to Fit; overflow reported to agents and vertical Align), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel (including font-defined Stylistic Sets), Find Font (Document, Recent and System replacement sources, #5217), installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, show recently applied families first (#3515), filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import (full-name aliases and Missing Fonts searches verified, #1258; Windows font-service QA pending), variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel (Above Text floats it over the selected text, its ruler at the canvas zoom so stops line up with the columns, #729), inline symbols in text (beyond parity), Hebrew/Arabic bidirectional text, Paragraph Direction, Every-line/Single-line Composer per object (ragged text too) done; tab leaders, spell check, vertical type pending | 45–60 |
-| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Fullwidth `！` / `？` keep an upright fallback in vertical type; Hyphenation… and Justification… per paragraph (#2310, #2755), Auto Leading also driving the Character panel's Leading, the Alt+↑/↓ leading nudge and Fill with Placeholder Text; Document-point character controls after object/group scaling (#1034; optional font-size preservation remains separate), Character/Paragraph Styles (explicit Auto-leading resets and local leading overrides), per-paragraph paragraph attributes, mixed paragraph alignment indication (headless regressions, full integration CI and visual review pass), Area Type Options (with Width/Height, Auto Size and Shrink Text to Fit; overflow reported to agents and vertical Align), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font (Document, Recent and System replacement sources, #5217), installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import (full-name aliases and Missing Fonts searches verified, #1258; Windows font-service QA pending), variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel (Above Text floats it over the selected text, its ruler at the canvas zoom so stops line up with the columns, #729), inline symbols in text (beyond parity), Hebrew/Arabic bidirectional text, Paragraph Direction, Every-line/Single-line Composer per object (ragged text too) done; tab leaders, spell check, vertical type pending | 45–60 |
-| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Fullwidth `！` / `？` keep an upright fallback in vertical type; Document-point character controls after object/group scaling (#1034; optional font-size preservation remains separate), Character/Paragraph Styles (explicit Auto-leading resets and local leading overrides), per-paragraph paragraph attributes, mixed paragraph alignment indication (headless regressions, full integration CI and visual review pass), Area Type Options (with Width/Height, Auto Size and Shrink Text to Fit; overflow reported to agents and vertical Align), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font (Document, Recent and System replacement sources, #5217), installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, show recently applied families first (#3515), filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import (full-name aliases and Missing Fonts searches verified, #1258; Windows font-service QA pending), variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel (Above Text floats it over the selected text, its ruler at the canvas zoom so stops line up with the columns, #729), inline symbols in text (beyond parity), Hebrew/Arabic bidirectional text, Paragraph Direction, Every-line/Single-line Composer per object (ragged text too) done; tab leaders, spell check, vertical type pending | 45–60 |
+| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | Indian-language pattern hyphenation preserves syllables in both composers (#4947); 🟡 Hanging punctuation keeps its published amounts under Glyph Scaling, and Standard burasagari counts a hung line start as room; Fullwidth `！` / `？` keep an upright fallback in vertical type; Document-point character controls after object/group scaling (#1034; optional font-size preservation remains separate), Character/Paragraph Styles (explicit Auto-leading resets and local leading overrides), per-paragraph paragraph attributes, mixed paragraph alignment indication (headless regressions, full integration CI and visual review pass), Area Type Options (with Width/Height, Auto Size and Shrink Text to Fit; overflow reported to agents and vertical Align), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel (including font-defined Stylistic Sets), Find Font (Document, Recent and System replacement sources, #5217), installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, show recently applied families first (#3515), filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import (full-name aliases and Missing Fonts searches verified, #1258; Windows font-service QA pending), variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel (Above Text floats it over the selected text, its ruler at the canvas zoom so stops line up with the columns, #729), inline symbols in text (beyond parity), Hebrew/Arabic bidirectional text, Paragraph Direction, Every-line/Single-line Composer per object (ragged text too) done; tab leaders, spell check, vertical type pending | 45–60 |
+| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | Indian-language pattern hyphenation preserves syllables in both composers (#4947); 🟡 Fullwidth `！` / `？` keep an upright fallback in vertical type; Hyphenation… and Justification… per paragraph (#2310, #2755), Auto Leading also driving the Character panel's Leading, the Alt+↑/↓ leading nudge and Fill with Placeholder Text; Document-point character controls after object/group scaling (#1034; optional font-size preservation remains separate), Character/Paragraph Styles (explicit Auto-leading resets and local leading overrides), per-paragraph paragraph attributes, mixed paragraph alignment indication (headless regressions, full integration CI and visual review pass), Area Type Options (with Width/Height, Auto Size and Shrink Text to Fit; overflow reported to agents and vertical Align), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font (Document, Recent and System replacement sources, #5217), installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import (full-name aliases and Missing Fonts searches verified, #1258; Windows font-service QA pending), variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel (Above Text floats it over the selected text, its ruler at the canvas zoom so stops line up with the columns, #729), inline symbols in text (beyond parity), Hebrew/Arabic bidirectional text, Paragraph Direction, Every-line/Single-line Composer per object (ragged text too) done; tab leaders, spell check, vertical type pending | 45–60 |
+| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | Indian-language pattern hyphenation preserves syllables in both composers (#4947); 🟡 Fullwidth `！` / `？` keep an upright fallback in vertical type; Document-point character controls after object/group scaling (#1034; optional font-size preservation remains separate), Character/Paragraph Styles (explicit Auto-leading resets and local leading overrides), per-paragraph paragraph attributes, mixed paragraph alignment indication (headless regressions, full integration CI and visual review pass), Area Type Options (with Width/Height, Auto Size and Shrink Text to Fit; overflow reported to agents and vertical Align), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font (Document, Recent and System replacement sources, #5217), installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, show recently applied families first (#3515), filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import (full-name aliases and Missing Fonts searches verified, #1258; Windows font-service QA pending), variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel (Above Text floats it over the selected text, its ruler at the canvas zoom so stops line up with the columns, #729), inline symbols in text (beyond parity), Hebrew/Arabic bidirectional text, Paragraph Direction, Every-line/Single-line Composer per object (ragged text too) done; tab leaders, spell check, vertical type pending | 45–60 |
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Anchor Point spine conversion/handle editing and selection priority (#2544), with #2425 Shift reshape preserved; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder, Color Adjustments and Document Raster Effects Settings; PDF export warns when the pixel cap lowers raster-effect resolution; Artistic › Colored Pencil, Cutout, Dry Brush, Film Grain, Fresco, Neon Glow, Paint Daubs, Palette Knife, Poster Edges, Rough Pastels, Smudge Stick, Sponge, Underpainting and Watercolor and Sketch › Halftone Pattern, Bas Relief, Charcoal, Conté Crayon, Photocopy, Stamp, Torn Edges and Water Paper done (57/57 Photoshop filters); Revolve with automatic smooth vector shading, default-on circular caps and continuous rims, Extrude & Bevel, Inflate and Rotate with one to ten colored directional lights and four original lighting presets; SVG Filters, remaining raster effects and 3D materials and shadows pending | 81–130 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; interactive selected mirror axis implemented (focused and native checks passed; full CI blocked by an unrelated text test); symbol libraries done (Window › Symbol Libraries, a generated Basic Shapes library, User Defined, Other Library…, Save Symbols); brush libraries done (Window › Brush Libraries, four generated libraries, User Defined, Other Library…, Save Brushes); symbol editing shows draggable 9-slice guides (#5280), with guides outside the artwork still unsupported; brushes/symbols in progress | 23–37 |
@@ -178,6 +180,7 @@ separate. Scores and hours unchanged. [Behavior and command details](development
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-06 | minor | M2: a shape just drawn moves by its centre point (Show Center) and turns from the rotate zone just outside a bounding-box corner with its tool still active, as the Selection tool's gestures do (#5477); estimates unchanged. |
 | 2026-11-06 | minor | Hindi (`hi`): 7,877-row machine-assisted catalog, zero/one singular plurals, desktop font fallback and optional Devanagari craft-fonts fallback; all 55 translation tests pass; native review and a web font remain; scores and estimates unchanged |
 | 2026-11-04 | minor | New Document: the units chosen in Preset Details belong to the chosen preset; Recent and Saved cards keep their own units; scores and estimates unchanged. |
 | 2026-11-03 | minor | M7: the OpenType panel offers the selected font's available Stylistic Sets with custom or numbered names; estimates unchanged. |
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index c2e3431fd..0af2f0670 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,6 +1,6 @@
 # Parity with Adobe Illustrator
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-06 · **Change:** minor (`.ai` and EPS import: older Art brush objects read; Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Hindi catalog and contributor loanword preferences; full wording review in progress; Properties in Edit Artboards: a Transform section with the reference point above the Artboards section, #5219; the Control bar's Stroke: and Opacity: links scrub their fields, #4088; an image zoomed in on is separated, colorized or proofed only where it shows (#4155); a document's first frame renders on the render worker, so opening a heavy file no longer freezes the window, #4155; Control bar Paragraph section with type selected, #5372; translating unchanged type reuses its glyph and character-stroke outlines; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; public release notes through 30.7, August 2026)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-07 · **Change:** minor (the canvas keeps selection outlines and anchors between frames; Indian-language hyphenation review and license allowlist, #4947; Stroke gradients: an arrowhead aligned to the tip is painted to the corners of its base, #5964; Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Hindi catalog and contributor loanword preferences; full wording review in progress; Properties in Edit Artboards: a Transform section with the reference point above the Artboards section, #5219; the Control bar's Stroke: and Opacity: links scrub their fields, #4088; an image zoomed in on is separated, colorized or proofed only where it shows (#4155); a document's first frame renders on the render worker, so opening a heavy file no longer freezes the window, #4155; Control bar Paragraph section with type selected, #5372; translating unchanged type reuses its glyph and character-stroke outlines; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; public release notes through 30.7, August 2026)
 
 ## Feature submission evidence
 
@@ -31,6 +31,10 @@ Artboard Options forwards the active Artboard tool's Scale Artwork with Artboard
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-07 | minor | The canvas keeps selection outlines, anchors and handles between frames, so an idle frame with a large selection redraws them as one mesh; scores and estimates unchanged |
+| 2026-11-07 | minor | Indian-language hyphenation (#4947): eleven MIT-licensed pattern sets, with grapheme and shaping-cluster protection in both composers and existing paragraph limits. Assamese and Sanskrit are selectable; Sanskrit automatic patterns remain pending an allowlisted source. Scores and estimates unchanged. |
+| 2026-11-06 | minor | Stroke gradients: an arrowhead whose tip sits on the end of a long straight leg is painted by the gradient to the corners of its base. The slices that reach across a head now run to the end of its reach instead of narrowing towards the next corner (#5964). Test: `stroke::tests_gradient::slices_cover_an_arrowhead_on_a_long_straight_leg`. Scores and estimates unchanged. |
+| 2026-11-06 | minor | Width profiles: the width between two width points follows a smooth curve instead of a straight line, so a stroke no longer kinks at each width point (#5714). Each side is a monotone cubic through its points: flat at a widest or narrowest point, never past either point of a span; stacked points still step. Straight runs are sampled between width points to the drawing tolerance. Scores and estimates unchanged. |
 | 2026-11-05 | minor | A nearby hit on a plain long stroke or outline avoids assembling its whole path. A hit near the middle of a 200,000-anchor path took about 11–13 ms before and 1.0–1.4 ms after in paired runs on a busy Windows machine; a miss inside the path's box fell from 18.7 ms to 1.6 ms, while a distant miss was unchanged. Other stroke styles and fill hits keep their existing checks. Scores and estimates unchanged; idle performance budgets remain unverified. |
 | 2026-11-05 | minor | Translating a type object without changing its text or formatting reuses glyph geometry and expanded character-stroke outlines between frames. The text appears at its new position with unchanged pixels. Scaling the type, editing its content or formatting, or changing installed fonts rebuilds the geometry; scores and estimates unchanged. |
 | 2026-11-05 | minor | Moving a large selection reuses the object locations found during command validation. A 20,000-object nudge took 58.07 ms before and 51.26 ms after in paired median runs; object positions, selection, and undo behavior stay the same. Scores and estimates unchanged. |
@@ -182,7 +186,7 @@ dominate; 3D, graphs and automation are specialist). They sum to 105. Feature de
 | Strokes, brushes, width profiles | 5 | 88% | Shift-double-click adjoining adjustment is implemented; brush libraries are done (four generated libraries, User Defined, Other Library…, Save Brushes); remaining:  Art brush Overlap, Pattern brush auto corners, pen pressure on macOS, tilt/bearing/rotation | 8–15 | estimated; width-point creation and adjoining adjustment regression-tested; dialog layout reviewed; evidence below; finite-arithmetic follow-up regressions and full CI passed (evidence below) |
 | Appearance, transparency, graphic styles, masks | 5 | 97% | raster effect reach in preview bounds | 1–2 | estimated; Transform typing, sliders, preview, and undo are covered in `crates/ui-egui/src/panels/tests_appearance.rs` |
 | 3D and Materials (and Turntable) | 4 | ~25% | live Revolve with automatic smooth vector shading and default-on continuous circular caps, Extrude & Bevel (twist, taper, caps, five bevel shapes), Inflate and Rotate with Position presets (colored Inflate uses smooth membrane lighting; white-light Inflate retains its existing shading; Extrude & Bevel and Rotate retain planar shading; one to ten colored lights, shared neutral ambient, painter visibility); materials, light presets, shadows, ray tracing, 3D Classic, Turntable views, 3D export | 30–55 | estimated (Extrude & Bevel, Inflate and Rotate added 2026-10-12) |
-| Type core | 9 | 80% | Auto-leading style resets are implemented; Hyphenation… and Justification… options are done (#2310, #2755), and a paragraph's Auto Leading also sets the Character panel's Leading, the Alt+↑/↓ leading nudge and Fill with Placeholder Text; remaining: Optical Margin Alignment, Middle Eastern features beyond bidi layout, optional group font-size preservation; transformed character controls fixed (#1034), see [type-parity.md](type-parity.md) | 14–19 | estimated; recent-font groups in font pickers (#3515); full-name font matches regression-tested (#1258); mixed paragraph alignment indication implemented; headless regressions, full integration CI and visual review pass; localized legacy family-name fallback with loaded/catalog regressions (#2208); Fractional Widths per type object regression-tested; color emoji fonts with bitmap glyphs (`sbix`, `CBDT`) draw and export; threading ports: every selected area type and type on a path shows its in and out ports (empty, arrow, red "+"), and the Selection tool threads from either, the in port into a frame before it, and a double-click on a threaded port breaks the thread there (`threads::tests::break_splits_the_thread_and_the_story_flows_into_the_first_part`, `select::tests::a_double_click_on_a_threaded_port_breaks_the_thread`, `canvas::tests::a_double_click_on_a_threaded_out_port_breaks_the_thread`) (#2572; `select::tests::a_click_on_the_in_port_threads_into_a_frame_before_it`, `text::tests::selected_type_shows_its_ports_in_each_state`, `threads::tests::add_before_threads_the_story_from_the_new_frame_into_the_clicked_one`, live screenshot); the Glyphs panel highlights and scrolls to the character selected with the Type tool (#4908, `panels::glyphs` tests); the OpenType panel lists only `ss01`–`ss20` sets present in the selected font and uses its custom names when supplied; Type-range desktop Copy publishes styled art and keeps font family, size and color on canvas Paste after editing (#5636) |
+| Type core | 9 | 80% | Auto-leading style resets are implemented; Hyphenation… and Justification… options are done (#2310, #2755), and a paragraph's Auto Leading also sets the Character panel's Leading, the Alt+↑/↓ leading nudge and Fill with Placeholder Text; remaining: Optical Margin Alignment, Middle Eastern features beyond bidi layout, optional group font-size preservation; transformed character controls fixed (#1034), see [type-parity.md](type-parity.md) | 14–19 | estimated; eleven-language pattern hyphenation in both composers, with grapheme and shaping-cluster protection (#4947, `hyphen::tests` and `layout::wrapping_tests`); Sanskrit patterns pending an allowlisted source; recent-font groups in font pickers (#3515); full-name font matches regression-tested (#1258); mixed paragraph alignment indication implemented; headless regressions, full integration CI and visual review pass; localized legacy family-name fallback with loaded/catalog regressions (#2208); Fractional Widths per type object regression-tested; color emoji fonts with bitmap glyphs (`sbix`, `CBDT`) draw and export; threading ports: every selected area type and type on a path shows its in and out ports (empty, arrow, red "+"), and the Selection tool threads from either, the in port into a frame before it, and a double-click on a threaded port breaks the thread there (`threads::tests::break_splits_the_thread_and_the_story_flows_into_the_first_part`, `select::tests::a_double_click_on_a_threaded_port_breaks_the_thread`, `canvas::tests::a_double_click_on_a_threaded_out_port_breaks_the_thread`) (#2572; `select::tests::a_click_on_the_in_port_threads_into_a_frame_before_it`, `text::tests::selected_type_shows_its_ports_in_each_state`, `threads::tests::add_before_threads_the_story_from_the_new_frame_into_the_clicked_one`, live screenshot); the Glyphs panel highlights and scrolls to the character selected with the Type tool (#4908, `panels::glyphs` tests); the OpenType panel lists only `ss01`–`ss20` sets present in the selected font and uses its custom names when supplied; Type-range desktop Copy publishes styled art and keeps font family, size and color on canvas Paste after editing (#5636) |
 | Type advanced (CJK, spelling, Touch Type, Retype) | 4 | 50% | CJK vertical composition (ruby, mojikumi), variable font axes, tab leaders, spell check, Touch Type, Retype | 20–28 | estimated; upright fallback for fullwidth `！` / `？` regression-tested; score and hours unchanged |
 | Symbols, blends, envelopes, Repeat, perspective | 5 | 87% | 30.7's Blend panel with ease in/out, on-canvas Direct Selection of parts inside dynamic symbol instances and their `.ai` round trip, more built-in symbol libraries, envelope Anti-Alias/Preserve Shape; Symbol Options › Registration, Export Type (Graphic / Movie Clip) and 9-slice guides (drawn and draggable during symbol editing, #5280) and Symbol Type (dynamic symbols keep per-instance appearance linked, #4938) are done | 4–8 | estimated; Blend panel Type and Ramp control step easing with a separate color Shift (#2539); Blend Options retains spacing and orientation; polynomial curves are original approximations; interactive selected mirror axis implemented; bounding-box handles take priority over the axis line (focused regression and native checks passed; full CI blocked by an unrelated text test); #2544 spine Anchor Point conversion and picking regression-tested; scores and hours unchanged |
 | Type advanced (CJK, spelling, Touch Type, Retype) | 4 | 50% | CJK vertical composition (ruby, mojikumi), tab leaders, spell check, Touch Type, Retype | 20–28 | estimated; upright fallback for fullwidth `！` / `？` regression-tested; score and hours unchanged |
@@ -197,7 +201,7 @@ dominate; 3D, graphs and automation are specialist). They sum to 105. Feature de
 | Image Trace, graphs, image tools | 3 | 75% | graph Column designs, Image Trace Create Strokes depth (Create Object Mosaic is done; junction-returning piece survival has source-generated regressions in `image-trace-quality.md`; large images trace with a warning; Auto Color keeps rare distinct colours) | 5–8 | estimated (raised from 72%); quick presets reveal adjustment controls, Properties reopens them |
 | Layers, artboards, document setup | 5 | 78% | Selected-artboard deletion is consistent across panel actions (all-selected retains artboard 1); history prunes removed indices while preserving valid multiselection; remaining:  30.0's artboard locking and colours and managing artboards from the canvas, Layers panel row context menus and Collect for Export (click-to-fit objects is done, #1227) | 5–8 | estimated (lowered from 82%: target moved); Artboard deletion keys keep artwork and the first of an all-selected set; Artboard Options' Show Center Mark and Show Cross Hairs draw on the canvas only (exports and print leave them out), regression-tested; Artboard Options' Show Video Safe Areas and Video Ruler Pixel Aspect Ratio (per artboard, native format) are done ([video display options](#evidence-what-ships-today-by-area)), score unchanged |
 | View & navigation | 3 | 70% | multiple windows and the rest of Arrange (Cascade, Float in Window, Float All in Windows) | 9–14 | estimated; Window › Arrange › Tile and Consolidate All Windows done (score/hours unchanged); document-tab artwork hover/copy and lossless transfer tested (2026-10-22; score/hours unchanged); cached canvas reprojection preserves scale during resize, rotation and DPI changes (regression and contributor original-file evidence below; scores/hours unchanged); cached canvas dimensions match the renderer limit before cache-key creation, view construction and worker submission (regression evidence below) |
-| File formats | 6 | 75% | `.ai` files open with a flattened or wrong layer structure in real cases (#951), no writing of Illustrator's editing data (#868), FreeHand/CorelDRAW/DWG/HEIC import, 3D export; see [file-format-parity.md](file-format-parity.md); EPS legacy mesh/opacity-mask and raster comparison follow-up verified | 10–20 | estimated (lowered from 85%: open issues); DXF control-point SPLINE import closure regression-tested (#1299 follow-up after #1320); PDF writer metadata, reader streaming and immutable backend checks in `crates/pdf/src/tests.rs`, `crates/pdf/src/tests/reader_streaming.rs` and `xtask/src/pdf_deps.rs`; PDF Place and clipboard paste retain live text (synthetic regressions); EPS ordinary Save retains the page frame and editable document (2026-10-26); `.ai`/EPS editing data checked against a user's files (2026-10-30): case setting (`ate::tests`, `tests_native::type_from_the_text_document_keeps_its_case_setting`), placed-file placements (`tests_native::a_small_placed_file_goes_where_it_draws_closer_to_the_page`), pages cropped to the art (`tests_native::type_on_the_copies_of_a_page_cropped_to_the_art_is_read_once`), mesh corner weights and state (`ai::mesh::tests::corners_with_handle_weights_of_zero_are_read`, `ai::tests::a_gradient_mesh_takes_the_transparency_written_after_it`), type on a path spacing (`tests_native::type_round_a_circle_is_spaced_as_the_file_lays_it_out`), blend state (`ai::tests::a_blends_transparency_follows_its_record`); scores and estimates unchanged. |
+| File formats | 6 | 75% | `.ai` files open with a flattened or wrong layer structure in real cases (#951), a saved `.ai`'s editing copy without live effects and with symbols and live objects as their art (#868), FreeHand/CorelDRAW/DWG/HEIC import, 3D export; see [file-format-parity.md](file-format-parity.md); EPS legacy mesh/opacity-mask and raster comparison follow-up verified | 10–20 | estimated (lowered from 85%: open issues); DXF control-point SPLINE import closure regression-tested (#1299 follow-up after #1320); PDF writer metadata, reader streaming and immutable backend checks in `crates/pdf/src/tests.rs`, `crates/pdf/src/tests/reader_streaming.rs` and `xtask/src/pdf_deps.rs`; PDF Place and clipboard paste retain live text (synthetic regressions); EPS ordinary Save retains the page frame and editable document (2026-10-26); `.ai`/EPS editing data checked against a user's files (2026-10-30): case setting (`ate::tests`, `tests_native::type_from_the_text_document_keeps_its_case_setting`), placed-file placements (`tests_native::a_small_placed_file_goes_where_it_draws_closer_to_the_page`), pages cropped to the art (`tests_native::type_on_the_copies_of_a_page_cropped_to_the_art_is_read_once`), mesh corner weights and state (`ai::mesh::tests::corners_with_handle_weights_of_zero_are_read`, `ai::tests::a_gradient_mesh_takes_the_transparency_written_after_it`), type on a path spacing (`tests_native::type_round_a_circle_is_spaced_as_the_file_lays_it_out`), blend state (`ai::tests::a_blends_transparency_follows_its_record`); scores and estimates unchanged. |
 | View & navigation | 3 | 70% | multiple windows and the rest of Arrange (Cascade, Float in Window, Float All in Windows) | 9–14 | estimated; Window › Arrange › Tile and Consolidate All Windows done (score/hours unchanged); document-tab artwork hover/copy and lossless transfer tested (2026-10-22; score/hours unchanged); cached canvas reprojection preserves scale during resize, rotation and DPI changes (regression and contributor original-file evidence below; scores/hours unchanged) |
 | View & navigation | 3 | 70% | multiple windows and the rest of Arrange (Cascade, Float in Window, Float All in Windows) | 9–14 | estimated; Window › Arrange › Tile and Consolidate All Windows done (score/hours unchanged) |
 | Guides, grids, smart guides, snapping, rulers | 3 | 80% | "intersect" smart guides for a moved selection's anchors (drawn points and dragged anchors snap to intersections, #1658), distance readouts while drawing | 4–7 | estimated (lowered from 85%: target moved); new ruler-guide Alt orientation implemented; video rulers (View › Rulers › Show Video Rulers, #2849) done, score unchanged |
@@ -277,8 +281,9 @@ The discounts, with the evidence:
   about `.ai`/EPS, the most common single format theme. 20 of the 28 are fixed (often the same day). The 8 open
   ones are about structure, not missing art: layers flattened or multiplied (#951: 109 layers instead of 14;
   #868), guides lost (#779), slower opening (#758), live effects, brushes and symbols as their drawn look
-  (#637). VectorCraft can't write Illustrator's editing data (undocumented), so its PDF-compatible `.ai` opens
-  in Illustrator as plain art; the legacy `.ai` of version 7 it also writes keeps layers, groups and type as text (one
+  (#637). VectorCraft's PDF-compatible `.ai` carries an editing copy of the art (layers, groups, paths, colors,
+  gradients, patterns, images, transparency, opacity masks, clipping and type as text), with live effects left out
+  and symbols and live objects written as their art; the legacy `.ai` of version 7 it also writes keeps layers, groups and type as text (one
   artboard per file, no transparency) but hasn't been tested by users yet (#868). That blocks beta (the main-format rule) for people who hand files back to Illustrator users,
   but it doesn't stop someone opening and reworking their own archive.
 - **Interaction fidelity (×0.9).** Pen, Direct Selection, smart guides and snapping are deep
@@ -455,7 +460,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 35% | ~36 Photoshop-style filters (Artistic, Brush Strokes, Sketch, Stylize) and Texturizer's Load Texture (since done, see the area table above, as is the Effect Gallery, #2883); Document Raster Effects Settings, raster effects in PDF, the pixel-filter pipeline, Radial Blur, Smart Blur (Normal, Edge Only and Overlay Edge), Unsharp Mask, Glowing Edges, Distort (Diffuse Glow, Glass, Ocean Ripple), Pixelate (Color Halftone, Crystallize, Mezzotint, Pointillize), Texture (Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass, Texturizer) and Video (De-Interlace, NTSC Colors) are done | 8–14 |
 | 3D and Materials | 4 | ~25% | Initial Revolve, Extrude & Bevel, Inflate and Rotate, with simple lighting and four original lighting presets; materials, shadows, ray tracing, 3D Classic and more complete visibility remain | 25–45 |
 | Type advanced | 4 | 50% | CJK composition for vertical type (mojikumi beyond Line-end Punctuation Half Width — the other sets (and their paragraph-start bracket and indent rules), custom kinsoku sets (beyond Hard, Soft and None) and the Mojikumi Settings dialog —, manual tate-chu-yoko is done, its up/down settings remain; No Break is done), tab leaders, spell check (open dictionary), Touch Type, Retype; vertical point/area/path type and Type Orientation have initial support (beyond parity, not scored: inline symbols in text) | 20–28 |
-| Type core | 9 | 80% | Middle Eastern features beyond bidi layout and Paragraph Direction (the Middle Eastern composers, editable bidirectional SVG text, a split caret where directions meet); Every-line Composer fidelity for justified and ragged text (available per object; mixed type sizes in a paragraph still break single-line in non-rectangular area type and with text wrap), Optical Margin Alignment, paragraph spacing limit for vertically justified area type, hidden characters, paragraph attributes in the Type tool's copy and paste (the characters keep their styles, the paragraphs take the destination's), mixed-value display in the Paragraph panel for a selection across differing paragraphs, partial selection of type-area anchors by marquee, optional font-size preservation during group scaling (scaled character controls fixed in #1034). Hyphenation and Justification options, Fractional Widths, System Layout and styled Type-range canvas Paste (#5636) are done | 14–19 |
+| Type core | 9 | 80% | Middle Eastern features beyond bidi layout and Paragraph Direction (the Middle Eastern composers, editable bidirectional SVG text, a split caret where directions meet); Every-line Composer fidelity for justified and ragged text (available per object; mixed type sizes in a paragraph still break single-line in non-rectangular area type and with text wrap), Optical Margin Alignment, paragraph spacing limit for vertically justified area type, hidden characters, paragraph attributes in the Type tool's copy and paste (the characters keep their styles, the paragraphs take the destination's), mixed-value display in the Paragraph panel for a selection across differing paragraphs, partial selection of type-area anchors by marquee, optional font-size preservation during group scaling (scaled character controls fixed in #1034). Hyphenation and Justification options, Fractional Widths, System Layout, styled Type-range canvas Paste (#5636), and pattern hyphenation for eleven Indian languages with grapheme/cluster protection (#4947) are done; Sanskrit automatic patterns remain pending an allowlisted source | 14–19 |
 | Symbols, blends, envelopes, Repeat, perspective | 5 | 90% | more built-in symbol libraries (original), dynamic symbols, envelope Anti-Alias/Preserve Shape output and warp point editing, brush interpolation in blends (M8 fidelity pass done); Symbol Options › Registration and Export Type are done; symbol editing shows draggable 9-slice guides (#5280), while guides outside the artwork remain unsupported | 4–7 |
 | Image Trace, graphs, image tools | 3 | 72% | graph Column designs (Graph Design, Marker designs and series colours set with Group Selection are done), Create Object Mosaic, per-feature stroke/fill choice and varying widths in Image Trace's Create Strokes (Vector Halftone and the Image Trace View modes, Palette and Create Strokes are done) | 6–10 |
 | Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, Collect for Export, row context menus, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers, drag-scrolling a long panel while dragging rows; artboard preset polish (artboard escape routing and document setup modal handoff done; Move Artwork for artboard X/Y edits, Rearrange All Artboards, Document Setup, New Document and the rest of the Layers panel are done) | 4–7 |
@@ -553,6 +558,7 @@ since 2026-10-01.
 - **Selected artboard deletion:** the Artboards panel menu, panel trash button and Properties use the same selected set; selecting all retains artboard 1. Pointer-event tests cover nonadjacent and single selections, the original first-board survivor, ordinary artwork, Undo/Redo and the single-board guard. Public reference: [Delete artboards](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/add-edit-artboards/delete-artboards.html).
 - **Delete Empty Artboards:** the Artboards panel menu item ([Delete artboards](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/add-edit-artboards/delete-artboards.html)) runs `artboard.deleteEmpty`: every unlocked artboard with no artwork goes with its guides in one undo step, artboard 1 stays when every artboard is empty and none is locked, and the panel makes an artboard that is left active; an artboard is empty when no object (hidden, locked and template art included; guides not) has visual bounds that meet or touch it, a group counting by its members and a clip group or clipping layer by its members inside the clip (our reading of "no artwork"; the pages give no finer rule). Engine tests in `tests/panelcmds.rs` (`delete_empty_artboards_*`) and the panel test `delete_empty_artboards_deletes_the_empty_ones_and_selects_one_left`.
   The menu item's enabled check measures nothing in a document with one artboard, and Save Gradient Preset's check reads the proxy's paint without measuring the object; both give the same answer as before. An artboard that no path's control points, grown by the farthest its strokes reach, can meet is found empty without measuring the path. With an open path of 200,000 anchors selected, the checks take under 0.01 ms instead of 21.9 ms and 17.2 ms in a release build; with a second, empty artboard, Delete Empty Artboards' check takes 0.85 ms instead of 42.1 ms. Tests `delete_empty_artboards_is_enabled_exactly_when_it_deletes_something`, `delete_empty_artboards_enabled_state_matches_the_command_on_varied_documents`, `empty_artboard_checks_match_the_visual_bounds_on_varied_strokes`, `the_empty_artboard_check_matches_measuring_every_artboard`, `the_save_check_matches_saving_with_and_without_a_gradient`, `the_unmeasured_proxy_paint_is_the_measured_one` and `the_unmeasured_proxy_paint_is_the_measured_one_on_varied_objects`.
+  The Eyedropper, the Live Paint check for paint to sample, the Appearance panel's Characters chips and the colors the Libraries panel adds from the selection also read the proxy's paint without measuring the object; the Eyedropper measures it only to sample a gradient or a pattern, and the Libraries panel only for a gradient. The colors and paints are the same as before. With an open path of 200,000 anchors, the Live Paint check and the Eyedropper's sample for a point inside it take 0.004 ms together instead of 26.0 ms in a release build. Tests `samples_give_the_measured_proxy_paints_colors` and `colors_and_gradients_come_from_compound_paths_groups_and_colorized_objects`.
 - **Artboard history selection:** headless pointer/key tests in `panels/properties.rs` pass for panel New → Undo → Delete/Backspace/Properties, Duplicate → Undo → Delete, pruning removed indices and preserving valid multiselection. They assert board survivors, artwork and object selection, Move/Scale Artwork options, saved state and Undo/Redo. Full workspace CI passes.
 - **Artboard tab-switch follow-up:** changing the active document through its tab aligns the Artboard tool with the displayed board before Properties Delete; clicking the already-active tab preserves multiselection and Move/Scale Artwork options. Three headless `chrome::tests::artboard_document_tab_*` regressions cover actual tab A → B → A clicks followed by Properties Delete, surviving boards and guides, preserved artwork/symbols and Undo/Redo; controls cover same-tab multiselection, Move/Scale Artwork options and other tools. Historical focused validation on `dbd2497b` recorded one expected RED failure with two passing controls, then all three GREEN tests passed. All three also passed in historical full CI on `a0671777`. A full CI retry on the five-unit combined source at `a0671777` passed all seven stages with 6,613 test outcomes on 2026-10-14. An earlier full-CI run on the identical source panicked in the randomized `ai_mutated_save_never_panics` test; the cause remains unresolved. This five-fix batch does not claim to repair that failure.
 - **Artboard clean active-tab close (2026-10-15):** with the Artboard tool active, closing a clean active tab restores the surviving document's displayed board before Properties Delete. Nine targeted checks passed: three existing tab regressions, one clean close/Delete regression and five existing unsaved-document controls. The close regression checks the correct surviving board, preserved artwork/symbols and object selection, affected guides, one Delete edit, saved state and Undo/Redo. Three reviewed original full-app headless captures show the active tab before closing, the surviving document's shown board after closing, and the correct survivor after Properties Delete, using the actual tab × and Delete controls.
@@ -579,6 +585,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 - **Width-point finite-arithmetic follow-up (G1/M3):** Adjoining adjustments avoid intermediate overflow; non-finite normalized or resulting factors are rejected before committing. Engine regressions in `tests/widthpoints.rs` cover finite extremes, small nonzero results, atomic rejection, Undo/Redo and native save/reopen. Historical focused validation on the `a3357121` integration observed 2 expected RED failures with 11 passing controls, then all 13 tests passing with the repair; none were ignored. All three added regressions passed in current full CI. A full CI retry on the five-unit combined source at `a0671777` passed all seven stages with 6,613 test outcomes on 2026-10-14. An earlier full-CI run on the identical source panicked in the randomized `ai_mutated_save_never_panics` test; the cause remains unresolved. This five-fix batch does not claim to repair that failure. Scores and hours unchanged.
 - **Width-point creation (G1):** double-click a stroked segment with the Width tool to open Width Point Edit using sampled side widths. OK creates the point and optionally adjusts adjoining widths in one undo step. Cancel or Delete discards a prospective point without changing the document or redo history. Command and pointer tests cover profiles, compound paths, adjoining adjustment, existing-point editing and Undo/Redo. Message-catalog checks and full CI passed; the original capture verifies opening and Cancel, and the dialog layout was reviewed (2026-10-13: 28 focused Width tests, all seven cargo xtask ci stages, and a headless opening/Cancel capture with original PNG review). [Variable-width strokes](https://helpx.adobe.com/illustrator/using/stroke-object.html).
 - **Escape deselects width points:** with the Width tool, Escape deselects the selected width points, on the key the reference app's [Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html) page lists for deselecting a width point. The path, its widths and the undo history do not change. With no width point selected, Escape does what it does with the other tools, such as leaving isolation mode.
+- **Smooth widths between width points (#5714):** a variable-width stroke changes width along a smooth curve from one width point to the next, where it used to run in a straight line and turn a corner at each point. The public description is that the path "gradually gets wider or narrower from one point to the next" in "a flowing, continuous curve", and that stacked points make a sharp break ([Peachpit, Expressive Strokes](https://www.peachpit.com/articles/article.aspx?p=2979069)); the exact curve is not documented, so each side follows a monotone cubic (Fritsch–Carlson): no kink at a point, flat where a point is wider or narrower than both neighbours, never past the points either side, points on one line kept on it. The outline samples straight runs between width points closely enough to follow the curve to the drawing tolerance (at most 64 samples per span and 4,096 per piece). Presets with a middle point (Lens, Pinch, Teardrop, Wave) look softer; two-point tapers are unchanged. Tests: `appearance::profile::tests::{widths_run_smoothly_through_width_points, widths_never_pass_the_points_either_side, a_step_ends_the_curve_on_each_side, widest_covers_every_width_along_the_profile}`, `stroke::width::tests::{a_straight_run_follows_the_curve_between_width_points, samples_between_width_points_are_capped}`.
 - **Width strokes zoomed out (#995):** a stroke with a width profile keeps its shape while the view zooms out. The canvas keeps a hairline visible (at least half a device pixel); for a profiled stroke it is the profile's widest point that gets that minimum, not the weight, so a 1 pt stroke with a 6x width point is no longer drawn twice as thick at 25% zoom than at 100%. Plain strokes are unchanged. Test: `render::tests::widthzoom`.
 - **Rulers (#1212):** drag the intersection to preview and set a document zero point, or double-click it to reset to the active artboard's top-left. Transform, Properties and Control X/Y fields measure from it and convert entered positions back to absolute command coordinates. The origin survives every native format version and compression; geometry, guides and patterns stay in place. Public reference: [Use rulers](https://helpx.adobe.com/ca/illustrator/desktop/measure-and-align/grids-and-guides/use-rulers.html).
 - **Global and artboard rulers:** View › Rulers › Change to Global / Artboard Rulers (Cmd+Alt+R, `view.globalRulers`). A new document has artboard rulers: the rulers and the Transform, Properties, Control and Info X/Y count from the active artboard's top-left corner, or the zero point dragged out for that artboard, which moves with it; with global rulers one document zero point serves every artboard. Guide readouts and Shift ruler-tick snapping follow the same zero point. The mode is saved with the document; files from before it open with global rulers, as they measured. Regression tests: `engine/tests/it/ruler_origin.rs`, `ui-egui/src/tests/ruler_origin.rs`, `tools/src/rulerguide.rs`. Public reference: [About rulers](https://helpx.adobe.com/illustrator/desktop/measure-and-align/grids-and-guides/about-rulers.html).
@@ -726,12 +733,15 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - The Control bar's underlined Transform link opens the Transform panel in a popover under it (reference point, X/Y/W/H, Rotate and Shear with their icons and angle presets, flips, shape properties, Scale Corners and Scale Strokes & Effects), as its Stroke link does the Stroke panel; X/Y/W/H also show inline while the bar has room. The reference point locator is nine squares, the outer eight joined around the box.
   - In isolation mode the Control bar has an Exit Isolation Mode button (`object.exitIsolation`), except while a pattern is edited. Outside isolation mode, with one group, compound path, path, image, mesh or placed file selected, it has an Isolate Selected Object button (`object.isolate`), which also isolates a path inside a group that Direct Selection selected.
   - While an opacity mask is edited, Exit Isolation Mode (Esc, the isolation bar's back arrow, the Control bar's button, and the Layers panel menu's and canvas context menu's Exit Isolation Mode) leaves mask editing as Stop Editing Opacity Mask does, in one undo step: the mask keeps the edits, and the masked object is selected. While a pattern is edited, the Exit Isolation Mode item of the Layers panel menu and of the canvas context menu saves the pattern and leaves pattern editing, as Done does.
-  - Tab shows and hides the panels (in the Type tool it types a tab) without moving the keyboard focus onto a field, so the next shortcut or letter still works; in dialogs and panel fields it moves between fields.
+  - Tab shows and hides the panels (in the Type tool it types a tab) without moving the keyboard focus onto a field, so the next shortcut or letter still works; in dialogs and panel fields it moves between fields, one press each — a numeric field's scrub label is not a tab stop of its own, and the Transform panel's, Properties panel's and Control bar's W/H link comes after the fields it sits between (`one_tab_moves_from_a_field_to_the_next`).
   - Shift+Tab (`window.panels`) shows and hides the dock and the floating panels and leaves the toolbar and the Control bar as they are; hiding the panels with Tab or Shift+Tab also closes a panel popped out of the icon column.
   - The second Tab (`window.dock`) shows again only the bars the first Tab hid, after a restart too: a Control bar that was off stays off, a toolbar hidden with Window › Tools stays hidden, and panels shown with Shift+Tab in between stay shown.
   - The function key shortcuts for Brushes, Color, Layers, Info, Gradient, Stroke, Attributes, Graphic Styles, Appearance, Align, Transform, Pathfinder, Transparency, and Symbols activate a background tab on the first press, hide its expanded dock or floating group when that tab is in front, and restore the group with all its tabs together on the next press; in an icon column they open and close the flyout while keeping the icons. A reassigned chord keeps that behavior, and Window > a hidden sibling restores the group.
   - Cmd/Ctrl+A follows the keyboard: in a panel, dialog or search field it selects the field's text, while the Type tool edits it selects all of that text (also `select.all` over MCP), and only otherwise every object. On macOS the menu bar's Select All, Cut, Copy and Paste (keys or clicks) act on a focused field too, and elsewhere the in-window menus' do: the field that had the keyboard when the menu opened gets them, with its selection, and the keyboard back (#516). In a frame of threaded text, Select All selects the whole story, highlighted in every frame: Copy and Cut take all of it, typing or Delete replaces it as one undo step, and a fill, a size step or a Character or Paragraph panel change applies to every frame's text (VectorCraft's own behavior; `textedit::select_all_in_a_threaded_frame_selects_the_whole_story`, `textedit::typing_over_the_whole_story_replaces_every_frames_text_in_one_step`).
   - With the whole story of threaded text selected by Select All, Remove Line Breaks, Remove Paragraph Breaks and Type › Bullets and Numbering › Convert to Text act on the text of every frame as one undo step, and the story stays selected after Convert to Text; a selection inside one frame changes only that frame (VectorCraft's own behavior; `textedit::remove_breaks_takes_the_whole_story_that_select_all_selected`, `textedit::convert_to_text_takes_the_whole_story_that_select_all_selected`).
+  - With the whole story of threaded text selected by Select All, the Character, Paragraph, OpenType, Tabs and Text Styles panels, the Justification dialog and the font menu change the frames that are in the edited frame's thread at the time of the change, locked and hidden frames included. A frame that has left the thread is not changed, and a frame added to the thread is (VectorCraft's own behavior; `panels::character::tests::story_changes_follow_the_edited_frames_thread_after_the_first_saved_frame_leaves`, `story_changes_leave_out_a_frame_that_left_and_take_in_a_frame_that_joined`, `story_changes_stay_in_the_edited_frame_once_its_thread_is_removed`, `story_changes_take_in_locked_and_hidden_frames`, `panels::tabs::tests::indent_markers_after_select_all_keep_each_story_paragraphs_indents`, `dialogs::justification::tests::justification_dialog_follows_the_story_thread_at_ok`).
+  - With the whole story of threaded text selected by Select All, the Character, Paragraph, OpenType, Tabs and Text Styles panels, the Justification dialog and the font menu change the frames that are in the edited frame's thread at the time of the change, locked and hidden frames included. A frame that has left the thread is not changed, and a frame added to the thread is (VectorCraft's own behavior; `panels::character::tests::story_changes_follow_the_edited_frames_thread_after_the_first_saved_frame_leaves`, `story_changes_leave_out_a_frame_that_left_and_take_in_a_frame_that_joined`, `story_changes_stay_in_the_edited_frame_once_its_thread_is_removed`, `story_changes_take_in_locked_and_hidden_frames`).
+  - Switching from a Type tool to the Eyedropper keeps a whole story selected by Select All: a pick applies to the text of every frame as one undo step, and switching back restores the story selection (VectorCraft's own behavior; `textedit::switching_to_the_eyedropper_keeps_the_whole_story_selected`).
   - While the Type tool edits text, a character typed with AltGr is typed and runs no command. Firefox on Windows reports AltGr as Ctrl and Alt held, so in the web build AltGr+L (ł on a Polish layout) does not also open Layer Options for a new layer, and AltGr+Q (@ on a German layout) does not also run Reset Tracking and Kerning. A Ctrl+Alt chord that types no character runs its command.
   - On a layout without Latin letters, a one-key shortcut goes by the position of the key that typed the character, in the web build too, where the character arrives before its key press: on a Russian layout the P key (`з`) chooses the Pen, and two keys pressed in one frame each run their own shortcut.
   - With the Artboard tool, Cmd/Ctrl+A after a click on a row of the Artboards panel selects every artboard, as the macOS menu bar's Select All does then; the active artboard stays active, and the art's selection does not change. After a press outside the panel's list, Cmd/Ctrl+A selects every object again. It used to select every object after a click in the panel too. Public reference: [Select artboards](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/add-edit-artboards/select-artboards.html).
@@ -795,7 +805,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     Curvature point markers are circular, with no direction handles. While drawing, its own point feedback replaces generic selection markers; existing paths use the selection overlay, including partial selections and Hide Edges. Anchor Size applies, and Direct Selection and Pen retain their handles. The real egui-frame regressions in `crates/ui-egui/src/canvas.rs` verify marker positions, counts and unchanged documents (#1236, in part); the existing-path interpolation request remains open. The curve through the points (`curvature_spline` in `crates/tools/src/draw2.rs`) makes each stretch of three points follow the circle through them: a smooth point's handles lie along that circle's tangent, each `chord / (3 cos²(α/2))` long (α between handle and chord, capped at 90°), and the ends of an open path mirror their neighbour's tangent in their chord, so a J or a U curves evenly, a turn tighter than 30° comes to a point, and uneven spacing doesn't loop; the rubber band, a dragged or inserted point and `path.convertAnchor` to smooth use the same rule, while the Pencil's fitting keeps its own; `tests/draw2.rs` checks that the rubber band is the path the click makes (#1236, in part). The Smooth tool smooths only the stretch of path under the drag (#1547, fixes #1512).
     While Alt is held during a Paintbrush stroke or before a press with no path selected that the Smooth tool can act on, the Paintbrush shows a closing cursor (a crosshair with a ring), and so does the Pencil with Alt key toggles to Smooth Tool off when Alt is pressed after the drag starts; releasing the mouse button with Alt still held closes the path. Before a Paintbrush press with such a path selected, Alt shows the Smooth cursor, and holding Alt at the press smooths that path with the Smooth tool's radius and Smooth Tool Options' Fidelity. A Pencil drag started with Shift or Alt held draws a straight line instead, which stays open.
     With Shift held at the press, the Pencil draws a straight line from the press point to the pointer at 45° steps from the Constrain Angle, as [Draw straight lines with the Pencil tool](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-straight-lines-with-the-pencil-tool.html) describes; pressed on an end of a selected open path, the line continues the path from that end (part of #3799). With Option/Alt held at the press and Alt key toggles to Smooth Tool off, the Pencil draws a straight line at any angle, whose ends snap to Smart Guides, and it stays open when Alt is still held at the release; Shift and Alt together keep the 45° steps (#3799). While Shift or Alt is held before the press, the Pencil shows a straight-line cursor (a crosshair with a short line), and over an end of a selected open path, where the line continues the path, a path-continuation cursor (the same line leaving a small square), as the page describes.
-  - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). A click with a grid tool asks for the size, the divider counts and the grid options (#1377, in part): a skew for each set of dividers, Use Outside Rectangle As Frame or Create Compound Path From Ellipses, and Fill Grid; they are parameters of `shape.rectangularGrid` and `shape.polarGrid`, stay as the tool's options and apply to drags too. The curve a skew percentage follows and the direction of the radial skew are our own (the public documentation gives neither), and the dialogs have no reference point locator. An ellipse's Pie Start and End Angle and Invert Pie (Transform and Properties panels' Ellipse Properties, `object.setLiveShape {pieStart, pieEnd, invertPie}`) cut it as a pie (#812). With the bounding box showing, the Selection tool shows a selected ellipse's two pie widgets just outside it; dragging one sets its angle in one undo step and double-clicking one makes the ellipse whole again. A live polygon's Polygon Properties there: side count, angle, corner type and radius, radius, side length and Make Sides Equal once an uneven scale has made its sides differ (`object.setLiveShape {sides, polygonAngle, polygonRadius, sideLength, makeSidesEqual}`, part of #812); a star is a plain path, as in Illustrator. The Flare Tool Options last as the tool's options: the next flare dragged out uses them, a click's dialog shows them and double-clicking the tool opens them (part of #812).
+  - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). A click with a grid tool asks for the size, the divider counts and the grid options (#1377, in part): a skew for each set of dividers, Use Outside Rectangle As Frame or Create Compound Path From Ellipses, and Fill Grid; they are parameters of `shape.rectangularGrid` and `shape.polarGrid`, stay as the tool's options and apply to drags too. A shape just drawn stays adjustable with its tool: its Live Shape widgets drag, a press on its centre point (Show Center) moves the selection with the Selection tool's move arrow, snapping and Alt copy, and a press in the rotate zone just outside a bounding-box corner turns it about the centre with the Selection tool's rotate cursor (#5477; tests `a_shape_tool_moves_the_selection_by_its_centre_point_and_turns_it_from_a_corner` and, through the engine, `shapetools.rs`). The curve a skew percentage follows and the direction of the radial skew are our own (the public documentation gives neither), and the dialogs have no reference point locator. An ellipse's Pie Start and End Angle and Invert Pie (Transform and Properties panels' Ellipse Properties, `object.setLiveShape {pieStart, pieEnd, invertPie}`) cut it as a pie (#812). With the bounding box showing, the Selection tool shows a selected ellipse's two pie widgets just outside it; dragging one sets its angle in one undo step and double-clicking one makes the ellipse whole again. A live polygon's Polygon Properties there: side count, angle, corner type and radius, radius, side length and Make Sides Equal once an uneven scale has made its sides differ (`object.setLiveShape {sides, polygonAngle, polygonRadius, sideLength, makeSidesEqual}`, part of #812); a star is a plain path, as in Illustrator. The Flare Tool Options last as the tool's options: the next flare dragged out uses them, a click's dialog shows them and double-clicking the tool opens them (part of #812).
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. The Flare tool's center drag turns the rays by 0.1 radian at each drag update in which the pointer's document y grows, and back by as much at each one in which it falls, Shift held keeps their turn, and Space held during either of its drags moves the flare. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). A click with a grid tool asks for the size, the divider counts and the grid options (#1377, in part): a skew for each set of dividers, Use Outside Rectangle As Frame or Create Compound Path From Ellipses, and Fill Grid; they are parameters of `shape.rectangularGrid` and `shape.polarGrid`, stay as the tool's options and apply to drags too. The curve a skew percentage follows and the direction of the radial skew are our own (the public documentation gives neither), and the dialogs have no reference point locator. An ellipse's Pie Start and End Angle and Invert Pie (Transform and Properties panels' Ellipse Properties, `object.setLiveShape {pieStart, pieEnd, invertPie}`) cut it as a pie (#812). With the bounding box showing, the Selection tool shows a selected ellipse's two pie widgets just outside it; dragging one sets its angle in one undo step and double-clicking one makes the ellipse whole again. A live polygon's Polygon Properties there: side count, angle, corner type and radius, radius, side length and Make Sides Equal once an uneven scale has made its sides differ (`object.setLiveShape {sides, polygonAngle, polygonRadius, sideLength, makeSidesEqual}`, part of #812); a star is a plain path, as in Illustrator. The Flare Tool Options last as the tool's options: the next flare dragged out uses them, a click's dialog shows them and double-clicking the tool opens them (part of #812).
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. The Flare tool's center drag turns the rays with the pointer, Shift keeps them in their original orientation (unturned, or turned by a nonzero General › Constrain Angle), and Space held during either of its drags moves the flare. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). A click with a grid tool asks for the size, the divider counts and the grid options (#1377, in part): a skew for each set of dividers, Use Outside Rectangle As Frame or Create Compound Path From Ellipses, and Fill Grid; they are parameters of `shape.rectangularGrid` and `shape.polarGrid`, stay as the tool's options and apply to drags too. The curve a skew percentage follows and the direction of the radial skew are our own (the public documentation gives neither), and the dialogs have no reference point locator. An ellipse's Pie Start and End Angle and Invert Pie (Transform and Properties panels' Ellipse Properties, `object.setLiveShape {pieStart, pieEnd, invertPie}`) cut it as a pie (#812). With the bounding box showing, the Selection tool shows a selected ellipse's two pie widgets just outside it; dragging one sets its angle in one undo step and double-clicking one makes the ellipse whole again. A live polygon's Polygon Properties there: side count, angle, corner type and radius, radius, side length and Make Sides Equal once an uneven scale has made its sides differ (`object.setLiveShape {sides, polygonAngle, polygonRadius, sideLength, makeSidesEqual}`, part of #812); a star is a plain path, as in Illustrator. The Flare Tool Options last as the tool's options: the next flare dragged out uses them, a click's dialog shows them and double-clicking the tool opens them (part of #812).
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. The Flare tool's center drag turns the rays with the pointer, Shift keeps them in their original orientation, and Space held during either of its drags moves the flare. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). A click with a grid tool asks for the size, the divider counts and the grid options (#1377, in part): a skew for each set of dividers, Use Outside Rectangle As Frame or Create Compound Path From Ellipses, and Fill Grid; they are parameters of `shape.rectangularGrid` and `shape.polarGrid`, stay as the tool's options and apply to drags too. The curve a skew percentage follows and the direction of the radial skew are our own (the public documentation gives neither), and the dialogs have no reference point locator. An ellipse's Pie Start and End Angle and Invert Pie (Transform and Properties panels' Ellipse Properties, `object.setLiveShape {pieStart, pieEnd, invertPie}`) cut it as a pie (#812). With the bounding box showing, the Selection tool shows a selected ellipse's two pie widgets just outside it; dragging one sets its angle in one undo step and double-clicking one makes the ellipse whole again. A live polygon's Polygon Properties there: side count, angle, corner type and radius, radius, side length and Make Sides Equal once an uneven scale has made its sides differ (`object.setLiveShape {sides, polygonAngle, polygonRadius, sideLength, makeSidesEqual}`, part of #812); a star is a plain path, as in Illustrator. The Flare Tool Options last as the tool's options: the next flare dragged out uses them, a click's dialog shows them and double-clicking the tool opens them (part of #812).
@@ -892,7 +902,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   A move pressed on a path's stroke, or within 6 px of its outline away from its anchors and center, is held by the nearest point of that path, with the Selection, Group Selection or Direct Selection tool, and a straight segment Direct Selection drags is held by its own nearest point. That point is what snaps, so the path lands exactly on a ruler guide (with "align") instead of the pressed spot landing there and the path a few pixels beside it, an offset that showed only zoomed far in (#3701). A press in the middle of a fill still snaps the pressed spot: the public [Align objects with guides](https://helpx.adobe.com/illustrator/desktop/measure-and-align/grids-and-guides/align-graphic-objects-with-guides.html) page has Snap to Point align the point under the pointer, which is placed exactly where the object should meet the guide.
   A bounding-box handle dragged with the Selection or Free Transform tool snaps what it moves as a dragged point snaps (#2054). With View › Snap to Grid on, it snaps to the nearest gridline, and with Snap to Pixel on, it snaps to whole pixels. With Smart Guides off and Snap to Point on, it snaps to the other objects' anchors and the ruler guides within the Snap to Point distance. With Smart Guides and Snap to Point both on, it lines up with the ruler guides as well as the other objects. Shift still keeps the proportions, and Alt still scales about the center.
   A user slice's edge or corner handle dragged with the Slice Selection tool snaps as the Slice tool's drag does. With View › Snap to Grid on, it snaps to the nearest gridline, and with Snap to Pixel on, it snaps to whole pixels. Otherwise, with Smart Guides on, it lands on or lines up with the anchors, centers and edges of the art and the artboards, and with Smart Guides off and Snap to Point on, it snaps to the art's anchors and the ruler guides within the Snap to Point distance. Then a ruler guide within 5 px, shown and unlocked, moves the side or corner onto it. Shift still keeps the proportions, and Alt still resizes about the center.
-  View › Snap to Glyph: with Smart Guides on, a point drawn near a single line of live type lands on its glyphs' anchor points and lines up with its baseline, its x-height and the edges of each character's advance width (proximity guides), as well as the glyph bounds. In rotated type these guides run at the type's angle, and type of one glyph also has angular guides along its slanted straight segments. A paragraph shows glyph bounds only.
+  View › Snap to Glyph: with Smart Guides on, a point drawn near a single line of live type lands on its glyphs' anchor points and lines up with its baseline, its x-height and the edges of each character's advance width (proximity guides), as well as the glyph bounds: each glyph's box gives edge guides and four corners a point lands on, even where its outline curves (the right of `B`), and the box follows the glyph's size, scaling and rotation (#5112). In rotated type these guides run at the type's angle, and type of one glyph also has angular guides along its slanted straight segments. A paragraph shows glyph bounds only.
   Snap to Glyph options (#4232, [Snap to Glyph options](https://helpx.adobe.com/illustrator/desktop/design-with-text/special-characters-glyphs/snap-to-glyph-options.html)): the Character panel menu's Show Snap to Glyph Options (Hide Snap to Glyph Options) shows a Snap to Glyph section in the panel, with or without type selected, with a checkbox for each kind of guide: Baseline, x-height, Glyph Bounds, Proximity Guides (the edges of each character's width), Angular Guides and Anchor Point. Each off takes its guides away and leaves the others (`view.snapToGlyph.options`, the `glyphSnap` preference group, all on by default). Angular Guides covers a glyph's slanted strokes and every guide of rotated type, which runs at its angle; the boxes are dimmed while View › Snap to Glyph is off, and the section starts with a Snap to Glyph checkbox for it (VectorCraft choices; the page settles neither). Showing the section scrolls the panel to it, since it comes after every character attribute (#5273). Tested in `crates/tools/src/guides/tests.rs`, `crates/ui-egui/src/panels/character/tests.rs` and `crates/engine/src/tests/prefs.rs`.
 - **Artboard click-to-fit (#1227):** a plain click fits the topmost editable object or group to a new artboard, including its stroke like Fit to Selected Art, and makes the new artboard active. Art and its selection stay unchanged; creation is one undo step. Handles, modified clicks, drags, Escape and tool changes retain their meaning. Tested inside an artboard and on the pasteboard (`crates/engine/tests/it/artboard_click.rs`); the public [CS6 Printing Guide](https://helpx.adobe.com/content/dam/help/en/indesign/pdf/CS6_PrintGuide.pdf) documents the object-click gesture. This legacy gesture adds evidence without regrading the 2026 canvas controls.
 - **Rotated views:** with the view rotated, Fit Artboard in Window, Fit All in Window and the status bar's artboard navigator fit the artboard or the art as the view turns it, and a Zoom tool marquee (Animated Zoom or GPU Performance off) zooms to the area dragged across. Ruler guides on no artboard turn with the view. The canvas draws the selection marquee where the tools select, Show Hidden Characters draws the marks of type partly inside the canvas, the Contextual Task Bar stays under the selection, and the Navigator's red box outlines what the window shows.
@@ -915,6 +925,8 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   Object › Artboards › Fit to Selected Art resizes the active artboard (`artboard.fitToSelection {index}`). It used to resize artboard 1 whichever artboard was active. When an action plays, its Fit to Artwork Bounds and Fit to Selected Art steps that name no artboard resize the artboard that is active then.
   Object › Artboards › Fit to Artwork Bounds and the Artboards panel menu's Fit to Artwork Bounds fit each selected artboard (those the Artboard tool has selected, else the active one) to the art on it, as the public [Use the artboard context menu](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/use-artboard-context-menu.html) page describes (`artboard.fitToArt {indices}`). An object partly on an artboard counts for each artboard it overlaps, and an artboard with no art on it keeps its size and place. They used to fit the active artboard to all the art in the document.
   The Artboards panel menu's Duplicate Artboards copies each selected artboard (those the Artboard tool has selected, else the active one) with its art, in one undo step, and the copies are then selected, as the public [Use the artboard context menu](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/use-artboard-context-menu.html) page describes. With the Artboard tool, Copy and Cut take every selected artboard with its art, as the public [Cut, copy, and paste artboards](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/cut-copy-and-paste-artboards.html) page describes, and Paste brings them all back in one undo step (`artboard.duplicate`, `artboard.copy` and `artboard.cut` with `indices`). The copies keep their places relative to each other, together right of the last artboard. All three used to act on the active artboard only.
+  With the Artboard tool, the canvas context menu lists the entries of the public [Use the artboard context menu](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/use-artboard-context-menu.html) page in its order: Cut, Copy, Paste at the pointer, Undo, Redo, New Artboard, Duplicate Artboards, Rename (`artboard.rename`), Delete Artboards, Delete Empty Artboards, Select All Artboards (`artboard.selectAll`), Lock Artboards and Unlock Artboards, Rearrange, Fit to Artwork Bounds, Switch Orientation (`artboard.switchOrientation`), Artboard Options and Export. A right-click on an artboard that is not selected selects it first.
+  The Artboards panel menu's New Artboard adds the artboard in one undo step and makes it the active one, as the panel's button, the Control bar and Properties do; with the Artboard tool it is then the only one selected. This is VectorCraft's own rule. The menu item used to leave the active artboard where it was.
   With the Artboard tool, Paste and Paste in Place make the first pasted artboard the active one (the navigator's and the Artboards panel's), and Cut makes the artboard before the first cut one active (the new first artboard when artboard 1 was cut). A command that chooses another document (`document.activate`) starts the tool on that document's active artboard, as choosing its tab does, and File › Revert keeps the active artboard and starts the tool on it. Paste used to leave the active artboard where it was while the tool had the pasted artboard active, and Cut left the active artboard on the artboard after the cut one while the tool had the one before it.
   With the Artboard tool, an action that reverts the document or switches to another document and back (`command.batch`), and the Actions panel menu's Batch… over a folder whose files it closes or over data sets with a Revert step (`action.batch`), keep the active artboard and start the tool on it, as File › Revert does. They used to make artboard 1 the active one.
   The Artboards panel menu's Convert to Artboards turns the geometric bounds of each selected object that has an area into a new artboard and removes those objects, in one undo step, as Object › Artboards › Convert to Artboards does (`artboard.convertToArtboards`). It is disabled when nothing is selected. It used to be disabled always.
@@ -1023,6 +1035,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   Pattern editing mode and opacity mask editing exclude each other, by a rule of VectorCraft itself: in pattern editing mode a click or Alt-click on the mask thumbnail does not edit the mask, and Make Mask is off for one object; while a mask is edited, Object › Pattern › Make and Edit Pattern are off.
   Disable, Enable, Unlink and Link Opacity Mask and Opacity Mask Options (`transparency.setOpacityMask`) record no undo step when every mask they act on already has the flags they set.
 - **Image Trace, thin closed outlines:** generated `fit::snap_area_tests` verify nonzero interiors after straightening, opposite closed-boundary winding and Noise controls; see [quality notes](image-trace-quality.md#thin-closed-outlines-with-snap-curves-to-lines). Scores and hours unchanged; open-piece fitting is unchanged.
+- **Image Trace, curve fitting tolerance:** the outline fitter keeps cutting a run while a point stays farther than the tolerance from its curve, so a run of fewer than six points or one cut 14 times no longer keeps a piece over the tolerance. Pieces already within the tolerance do not change, and noisy art can get more anchors. Tests: `logo::bezier::tests`, `logo::outline::tests`. Scores and hours unchanged.
 - **Image Trace, Document Library color groups:** with Document Swatches, the panel's Colors menu and `"colorGroup"` trace with one color group's colors instead of every swatch, as the public panel documentation describes Document Library; code-drawn tests in `crates/engine` and the panel.
 - **Image Trace, Document Library colors:** with Document Swatches, traced fills and strokes use the displayed colors of process, global, spot and tint swatches without links, so editing a swatch leaves the trace unchanged; swatch-library colors are also unlinked; code-drawn tests in `crates/engine`.
 - **Image Trace, flattened slivers:** in a Color, Grayscale or Black and White trace with Fills, a traced region whose outline straightens onto one line (a single pixel, or a one-pixel row along an edge, its pieces shared with the regions beside it) is left out instead of becoming a selectable path with no area, which paints nothing. Snap Curves To Lines straightens more outlines, so it leaves out more of these. Without Fills, the region's 1 px stroke draws it, and it is kept. Code-drawn tests in `crates/trace`.
@@ -1087,8 +1100,9 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     View › Proof Setup › Color blindness – Tritanopia-type turns Proof Colors on and proofs the canvas with the tritanopia simulation of Brettel, Viénot and Mollon (1997). The Separations Preview panel's Proof Setup list offers the same target (`view.proofSetup {target: "tritanopia"}`). Grays keep their value.
     The Separations Preview panel's Gamut Check button reports one color outside the CMYK gamut in the singular and more in the plural, in English and in each language's plural forms (`gamut_check_status_takes_the_plural_form` in `crates/ui-egui/src/i18n/tests.rs`).
   - **Document Color Mode outside the layers:** File › Document Color Mode (in one undo step) and `document.open {colorMode}` also convert the colors of graph designs, graphic styles, opacity-mask art, the tile that pattern editing's Cancel puts back and the art of brushes (with a Hue Shift brush's key color); a tint of a global swatch there becomes the converted swatch's color at its tint, as in the art.
+  - **Segments dragged onto the grid (#3835):** with View › Snap to Grid (or Snap to Pixel) on, a straight segment dragged with Direct Selection or Group Selection lands its anchors on the grid, the box round them putting an edge on a gridline on each axis as a moved object's does (Shift keeps the move on its line), instead of the point it was pressed at landing on an intersection and leaving both anchors off the grid; a dragged anchor still lands on an intersection itself, and drawn points and resize handles already snapped (`direct::tests::a_dragged_segment_lands_its_anchors_on_the_grid`).
   - **Spinner arrows in the shadow and glow dialogs (#5367, #5368):** Drop Shadow's Opacity, X Offset, Y Offset, Blur and Darkness and the Outer and Inner Glow's Opacity and Blur have up and down arrows beside the field, as the other number fields with arrows do: a click steps by one (a unit for distances; Shift ×10, Ctrl/Cmd ÷10), holding repeats, Opacity and Darkness stop at 0 and 100 % and Blur at 0 (`dialogs::effect` test `drop_shadow_and_outer_glow_fields_have_spinner_arrows`).
-  - **Colour swatches in effect dialogs (#5365):** a colour parameter of an effect dialog (Outer Glow's Color, Inner Glow's, Drop Shadow's) shows a swatch beside its hex field that follows the value typed in it; a double-click on the swatch opens the Color Picker over the dialog on that colour, whose OK fills the field and whose Cancel comes back unchanged, and the dialog previews the colour when it returns (`dialogs::effect` test `outer_glow_colour_swatch_opens_the_color_picker`).
+  - **Colour swatches in effect dialogs (#5365):** a colour parameter of an effect dialog (Outer Glow's Color, Inner Glow's, Drop Shadow's) shows a swatch beside its hex field that follows the value typed in it; a double-click on the swatch opens the Color Picker over the dialog on that colour, whose OK fills the field and whose Cancel comes back unchanged, and the dialog previews the colour when it returns (`dialogs::effect` test `outer_glow_colour_swatch_opens_the_color_picker`). Drop Shadow draws Color beside its Darkness choice rather than in the shared grid, so its swatch came separately (#5364; `drop_shadow_colour_swatch_opens_the_color_picker`); with Darkness chosen it is dimmed.
   - **Document Color Mode for effects and graphs:** File › Document Color Mode and `document.open {colorMode}` convert the colors of effects (Drop Shadow, Inner Glow, Outer Glow and the other effects with a color, on objects, their fills and strokes and in graphic styles) and the series paints and label styles that a graph keeps, so a graph drawn again from new data keeps the converted colors; File › Document Color Mode also converts the fill and stroke that new art takes. Undo restores the original new-art fill and stroke and Redo applies the conversion again.
   - **Recolor Artwork layout (#3416):** the Edit chip list uses the modal scroll helper and its actual remaining height; the tab's minimum-height space scrolls with the chips. `tests_recolor` covers 5/20/200/400 colors, window resizing, 100/125/150/200% UI scaling, scrolling to and editing the final chip, Preview, Cancel, Confirm and Undo, alongside the existing #1733 drag regressions. Scores and estimates unchanged.
   - **Recolor Artwork Edit displays:** buttons beside the Edit tab's wheel show the colors on a smooth color wheel, a segmented color wheel or as color bars ([Edit colors using Recolor Artwork](https://helpx.adobe.com/illustrator/desktop/manage-colors/modify-colors/edit-colors-using-edit-colors-dialog.html)). The segmented wheel draws 24 hues by 5 saturations as solid patches, and its markers move freely as on the smooth wheel. The bars show one solid bar per recolored color in row order: a click selects a bar for the color sliders, and a drag moves its row without changing a color ([Advanced recolor options overview](https://helpx.adobe.com/illustrator/desktop/manage-colors/learn-color-basics/edit-colors-dialog-overview.html)). The dialog opens on the smooth wheel; `display` (`smooth`, `segmented`, `bars`) is the dialog field. `tests_recolor` covers switching, the dialog height, segmented dragging and Brightness, and bar selection, editing, reordering, scrolling, Preview, Cancel and OK. Scores and estimates unchanged.
@@ -1109,6 +1123,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - **Freeform gradient colors in their own model:** Object ▸ Expand and Object ▸ Create Gradient Mesh (`object.mesh.create`) mix a freeform gradient's points in the color model they share: points of C50 M20 Y0 K10 give mesh points of C50 M20 Y0 K10, and RGB points keep their values in a working RGB space other than sRGB. Points in different models mix in display RGB, and a CMYK document stores the result as CMYK through the color settings. Points colored along CMYK stops (`paint.editGradient {stops}`, or a CMYK gradient switched to freeform) are CMYK, and so are a point `paint.freeform.splitLine` adds between CMYK points and a point `paint.freeform.addPoint` adds without `color` to CMYK points. Public reference: [Gradients](https://web.archive.org/web/20250714042311/https://helpx.adobe.com/illustrator/using/gradients.html) and [Meshes](https://web.archive.org/web/20250812201019/https://helpx.adobe.com/illustrator/using/meshes.html), which do not state how colors in different models mix; the rule is VectorCraft's own.
   - **Strokes:** one stroke-geometry module shared by the canvas, SVG, PDF and Outline Stroke; dotted lines (zero-length dashes draw dots or squares); arrowheads with hollow outlines, tip-on-end or extend-past-end alignment and one opacity for line and head. SVG and PDF export arrowheads, width profiles, brushes and aligned strokes exactly as the canvas draws them; Outline Stroke and the live Outline Stroke effect outline every stroke item as drawn (dashes, heads, profiles, alignment); dashes can be fitted to corners and path ends; width profiles carry through dashes, and their corners take the join. The Stroke panel edits type's character strokes, follows the stroke units (its weight presets are round values in that unit: `0.25 mm`, `0.0625 in`, `1 px`, #426; fields show four decimals in mm, cm and inches, three in points), shows mixed values blank and opens from the Control bar. A width profile library, thirty more arrowheads, and Width Point Edit with multi-select and discontinuous points. Visual bounds and clicks cover the whole painted stroke. Scale Strokes & Effects, Scale Corners and Use Preview Bounds work everywhere, and new art inherits stroke options, a graphic style or the whole last appearance.
   - **Brushes (part of #852):** double-clicking a brush in the Brushes panel (or the panel menu's Brush Options…) opens Calligraphic Brush Options (Name; Angle, Roundness and Size, each Fixed, Random, Pressure, Tilt, Bearing or Rotation with its Variation; live previews of the nib and of a light–heavy–light stroke) or Bristle Brush Options (Shape and the bristle sliders); OK edits the brush and every stroke painted with it. The Paintbrush records the pen pressure along each stroke (kept with the path, saved, and joined when a stroke continues a path); a Calligraphic value on Pressure goes from value − variation at the lightest pressure to value + variation at the heaviest, on the canvas and in SVG, PDF and the other exports. Brushes saved before keep their look. Scatter Brush Options (Size, Spacing, Scatter and Rotation, each Fixed, Random between two values, Pressure from the first at the lightest pressure to the second at the heaviest, Tilt, Bearing or Rotation; Rotation relative to Page or Path), Art Brush Options (Width, Scale Proportionately, Stretch to Fit Stroke Length or Stretch Between Guides with the guides' start and end, the four Directions, Flip Along and Across) and Pattern Brush Options (Scale, Spacing, the five tiles shown, Flip Along and Across, Stretch to fit, Add space to fit or Approximate path) each have Colorization (None, Tints, Tints and Shades, Hue Shift with its Key Color picked from the art's colours) and a live stroke preview; values from files and commands are clamped to their ranges. Still to come: the Art brush's Overlap, Stylus Wheel, and the pen's tilt, bearing and rotation on Windows, native Wayland and the web.
+    Under Tints and Tints and Shades, art in black ink alone goes by its ink amount, and a process or gray stroke color's tints and shades stay in that color's model; these are VectorCraft's own rules.
     Type in a scatter brush's art takes the brush's colorization as its paths do: Tints, Tints and Shades and Hue Shift recolor the characters' solid fills and strokes in each copy the brush draws, and Brush Options' Key Color list, whose first color is Hue Shift's default key, counts the characters' fills and their strokes wider than 0. The Brushes page says that a scatter, art or pattern brush takes its colors from the current stroke color and the brush's colorization method (<https://web.archive.org/web/20241230205225/https://helpx.adobe.com/illustrator/using/brushes.html>) and does not mention type there; recoloring the characters' paints like the art's fills and strokes is VectorCraft's own rule. The Symbol Stainer mixes the characters' strokes of type toward the stain as it mixes their fills. Evidence: `tests::scatter_colorization_recolors_type`, `tests::art_colors_list_the_most_used_first`, `tests::stain_mixes_type_strokes_too` (vectorcraft-brush).
   - **Pen tilt, bearing and rotation (part of #764):** Calligraphic and Scatter Brush Options offer Tilt, Bearing and Rotation beside Fixed, Random and Pressure. The Paintbrush records along each stroke how far the pen leans, which way, and how far its barrel is turned (kept with the path, saved, and joined when a stroke continues a path). A Calligraphic value on Tilt goes from value − variation with the pen lying flat to value + variation upright; on Bearing or Rotation it adds variation × the angle over 180°, so Angle on Bearing with a Variation of 180° turns the nib with the way the pen leans. A Scatter value goes from its first value to its second over the same ranges. A stroke without that input draws the brush's own value. On Linux under X11 and XWayland the app reads the tilt and an Art Pen's barrel rotation from XInput2, on macOS it reads them from AppKit's tablet events, and `path.freehand` points and `pointer_gesture` events carry them on every platform. The [Brushes](https://web.archive.org/web/20241230205225/https://helpx.adobe.com/illustrator/using/brushes.html) page defines the three options and does not say which way each one runs; that mapping is VectorCraft's own rule. Evidence: `tests::tilt_maps_to_roundness_along_the_stroke`, `tests::bearing_and_rotation_turn_the_nib`, `tests::scatter_values_follow_tilt_and_bearing` (vectorcraft-brush), `tests_brushsym::paintbrush_records_the_pens_tilt_on_the_stroke` (vectorcraft-engine), `tablet::tests::a_pens_tilt_and_rotation_go_into_the_feed` and `mac_tablet::tests::a_pens_tilt_and_rotation_go_into_the_feed` (vectorcraft).
     Art Brush Options' Width (1% to 1000%) and Pattern Brush Options' Scale (1% to 10000%) each have a slider beside the field, over the same range in whole percents; screen readers name the slider as its row and read the field's value.
@@ -1174,6 +1189,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   A font family removed while the app runs leaves the font menus when the app scans the font folders again (when its window comes to the front after a font folder changed, or Refresh Font List), also when type had used it: that type then draws in the fallback font and Find Font lists the font as missing, until the font is installed again and the folders are scanned.
 - **Files (M4):**
   - PDF export and print composition use the optional shared guarded writer ([pdf-backend.md](pdf-backend.md)); app drawing and output policy and desktop printer submission remain in their existing layers. The shared reader keeps the app-owned import adapter; synthetic tests cover layer and overprint state across windows, long operands, inline images, failed decoding, document limits and incomplete tails. Empty and populated metadata key presence is regression-tested, and CI checks the immutable backend source.
+    PDF export measures each member of a plain group or layer once to leave out what is off the page: the group or layer is measured through its members (`Node::visual_of_members`), and each member uses that box when it is written. The elements of a knockout group are measured twice, once for the group's box and once to choose the elements on the page (`pdf/src/tests/measuring.rs` counts the measures). A local byte comparison with the previous build found identical output on one open path of 200,000 anchors, 20,000 rectangles in 200 groups of 100, 5,000 point type objects and a document of plain, see-through, clipping and knockout groups. The walk that writes link annotations measures only an object with a URL that opens and a clipping group (`links.rs`), and its output on a document of linked objects in plain and clipping groups is the same byte for byte as when it measured every object.
     Invisible text in a PDF (rendering mode 3, which carries a scanned page's recognized text over the scan) opens as type with no fill or stroke, a run of its own beside visible text on the same line; text that can't come in as type (opened as outlines, Type 3 fonts) is left out with a warning. PDF export, and printing, write characters with no fill or stroke as real text in rendering mode 3, so they draw nothing but stay selectable and searchable, also in PDF/X-1a and PDF/A-2b (#2675, `pdf/src/tests/import_fidelity.rs`, `pdf/src/tests/realtext.rs`).
     A PDF, or a `.ai` read through its PDF part, whose spot inks have the same values but different names opens with a spot swatch for each ink. The solid fills and strokes of paths and type, and the stops of gradients on paths, link to the swatch of the ink they are painted in, the points of a gradient mesh in one of these inks keep the ink's color, and PDF export writes each of these inks as its own separation (`pdf/src/tests/import_color.rs`). Paint in these inks inside pattern cells, soft masks and type 3 glyphs, and gradients on type in these inks, still import as RGB. Type in one of these inks can also import as RGB when type in another Separation or DeviceN ink is shown with no path drawn between them. The stops of an axial or radial shading in a DeviceN space that mixes one spot ink with process plates (a spot ink over a constant cyan, for example) link to the ink's swatch at its tint and keep the process plates, and PDF and EPS (Level 3) export write those stops in a DeviceN space of the ink and those plates, so the spot plate is not lost (#3235, `import_color::a_device_n_gradient_of_a_spot_ink_over_a_process_plate_keeps_both_inks`). Solid fills that mix a spot ink with process plates, and stops that mix several spot inks, still import as RGB, with the spot inks kept as swatches.
     A `.ai` or EPS opened from its editing data keeps both swatches when a pattern's name, or a named color's, is also another swatch's: a pattern's swatch named as a default swatch, a named color or a palette color becomes "Name 2", and a named color named as a gradient or pattern swatch of the palette becomes "Name 2", with the fills, strokes and gradient stops linked to it following it (`ai::tests::a_pattern_swatch_named_as_another_swatch_is_numbered`, `ai::tests::a_color_named_as_a_palette_gradient_or_pattern_is_numbered`).
@@ -1181,6 +1197,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     PDF export writes a spot color named All or None (in a Separation space, the names of every plate and of no plate: [ISO 32000-1:2008](https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/PDF32000_2008.pdf), 8.6.6.4) as the ink All Spot or None Spot (All Spot 2 and on when a spot swatch already has that name) in its fills, strokes, gradients, colorized images and Lab alternates; Registration still prints on every plate (`pdf/src/tests/output.rs`).
   - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export. The desktop app writes its warnings and errors (graphics adapter, a lost graphics device, panics the guard recovered from) to standard error and to `logs/vectorcraft.log` next to the preferences, the two previous runs kept and each file capped at 16 MiB, so a launch without a terminal still leaves something to attach to a bug report (#465). Native documents with a lot of path data (traced or generated art, in layers, symbols or patterns) are saved as compact JSON, about a fifth of the size; small documents stay pretty-printed (#1492). Saving to a network drive on macOS falls back to a plain fsync when the share refuses a full flush (#1625, part of #1620; not confirmed on a real share), and a save still succeeds when a folder refuses the temporary file, the rename over the document or copying permissions: the content is written elsewhere first and copied in, and a failed copy keeps the temporary file and names it (#1649, part of #1620). A document opened by a relative path finds its relatively linked images, and `vectorcraft-cli convert` lists what reading the input left out as `importWarnings` (#1606, fixes #1604).
     Preferences › File Handling › Data Recovery › Folder has a Choose… button on the desktop that picks the folder Data Recovery keeps its copies in ([Illustrator reference, Set Data Recovery preferences](https://web.archive.org/web/20210601162814/https://helpx.adobe.com/pdf/illustrator_reference.pdf)); a picked folder that Data Recovery cannot create its folders in or list is refused with a status message, and the field keeps its value. OK applies the same check to a folder typed into the field (VectorCraft's own rule): when it fails, the dialog stays open, the status bar says why and no preference changes; an empty field (the default folder) and the folder already saved are not checked. Preferences › Plug-ins & Scratch Disks is where additional plug-ins folders are set ([Illustrator preferences help](https://helpx.adobe.com/illustrator/desktop/get-started/preferences-and-settings/set-app-preferences.html)); its Additional Plug-ins Folder has a Choose… button on the desktop as well, VectorCraft's own, matching Data Recovery's, and VectorCraft's own rule refuses a picked or typed folder whose contents can't be listed. Additional Fonts Folder and Templates Folder stay typed only.
+    `prefs.set` applies the dialog's check to `recoveryFolder` and `pluginsFolder` for every caller (VectorCraft's own rule): a folder that fails returns an error and no preference changes; an empty value and the folder already saved are not checked.
     A name typed in the desktop save panel without the file type's extension gets it, and when a file of that name exists, which the panel did not ask about, Save, Save As, Save a Copy, Save as Template, the exports and every other write through a save panel ask before replacing it (dialog `replaceFile`; Cancel writes nothing).
     A name returned by the desktop save panel with the extension of a format the save does not write has it replaced with the saved format's: Save As of a new document saves `card.ait` and `card.png` as `card.vectorcraft`, and Save as Template saves `card.pdf` as `card.vctemplate`. An extension that names no format stays part of the name (`notes.v2` is saved as `notes.v2.vectorcraft`).
     Export As, Save as PDF, Save for Office Documents, Save for Web, Text Export Options, print to file, the presets' Export… and the library, swatch and Document Info saves replace a typed extension of another format than the one they write in the same way: Export As PNG writes `card.svg` as `card.png`, Save as PDF writes `card.png` as `card.pdf`, and `document.exportSelection` with a `format` suggests and adds that format's extension. An extension of the written format stays as typed in any letter case (`photo.JPEG` for JPEG), Export As SVG writes `art.svgz` compressed, and `document.exportSelection` without a `format` writes the format the typed extension names (`tests/saveext.rs`).
@@ -1201,7 +1218,8 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     At a precision of 9 decimals or fewer, SVG export writes each number from an integer when the integer rounds it as the decimal formatter does; the formatter still writes values halfway between two written numbers and values too large for the integer. Exporting one path of 200,000 anchors takes a median of 43.4 ms instead of 167.0 ms on Windows 11, and 20,000 rectangles 81.4 ms instead of 141.4 ms, with the same SVG (`crates/svg/src/lib.rs`).
     SVG import reads each `<circle>` and `<ellipse>` as the ellipse VectorCraft draws: four smooth anchors on the axes, starting at the right, with handles of the standard length, so an ellipse exported as `<ellipse>` comes back with the anchors it was written from and draws the same (`circles_and_ellipses_import_as_the_ellipse_drawn` in `crates/svg/tests/it/basic_shapes.rs`, `filled_ellipse_on_the_artboard_edge_survives_visually` in `prop_svg.rs`).
     SVG import keeps attributes in other applications' XML namespaces (`plotter:pen="2"`) on the objects and layers they belong to, as it keeps their `data-*` attributes: copies, duplicates and `.vectorcraft` files keep them, and SVG export writes them back with each namespace declared once on the root (the rest of #522; `crates/svg/tests/it/foreign_attributes.rs`, `tests/attributes.rs`).
-    In a `.ai` or EPS opened from its editing data, type has its text object's opacity and blend mode, whether it is made from the file's text document or taken from the page. Where such type has transparency and comes in with other art (the rest of its look, or page type and strokes that go with it), a group of them has it. Where the page draws its type, or the strokes around it, with transparency that is neither its text object's nor its text object's combined with that of the objects around it, the page's type and strokes keep their own instead (`crates/eps/src/import/tests_native.rs`). Where the page draws type of no text object over text objects made from the text document, with their words in any case, that type is theirs as the page draws it and is left out; the page's other type of no text object goes only to text objects whose type the text document can't make, or else is left out with a warning.
+    A PDF-compatible `.ai` saved with Include Editing Data for Other Apps writes point type, area type and type on a path as type in its editing copy, and objects next to it keep their own transparency (`crates/eps/src/ai_editing/tests.rs`, `cmd::fileio::tests_pdfedit::type_comes_back_from_the_editing_copy`; [file-format-parity.md](file-format-parity.md) lists what is written as outlines).
+    In a `.ai` or EPS opened from its editing data, type has its text object's opacity, blend mode and knockout shape flag, whether it is made from the file's text document or taken from the page, and type made from the text document takes its text object's lock. Where such type has transparency and comes in with other art (the rest of its look, or page type and strokes that go with it), a group of them has it. Where the page draws its type, or the strokes around it, with transparency that is neither its text object's nor its text object's combined with that of the objects around it, the page's type and strokes keep their own instead (`crates/eps/src/import/tests_native.rs`). Where the page draws type of no text object over text objects made from the text document, with their words in any case, that type is theirs as the page draws it and is left out; the page's other type of no text object goes only to text objects whose type the text document can't make, or else is left out with a warning.
     `.ai` editing-data import restores the document's listed graphic styles in panel order and links objects that use a listed style; unsupported appearances keep their drawn look (`crates/eps/src/import/ai/tests.rs`).
     A `.ai` or EPS graphic style library, whose editing data holds the styles and their list but no layers, opens with those styles in list order. Other Library… loads another document's graphic styles ([Apply graphic styles](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-graphic-styles/apply-graphic-styles.html)) and lists such a library's styles in a library panel. A `.ai` or EPS read as its PDF part or page because its layers can't be used also gets the styles of its list in place of the default ones (`crates/eps/src/import/tests_native.rs`, `cmd::fileio::tests_aiimport::a_graphic_style_library_in_a_ai_file_without_layers_loads_its_styles`).
     A `.ai` or EPS opened from its editing data whose text document makes the type of every text object that shows takes all its type from the text document: each text object stays in its own group, frame and layer, the page's type isn't matched with them, a file of more than 5,000 text objects still opens with its layers, and type the page draws differently (in another font) keeps the layers, with a warning. A line break inside a paragraph stays a line break in it (`crates/eps/src/import/tests_native.rs`, `crates/eps/src/import/ate.rs`).
@@ -1212,14 +1230,14 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     A PDF saved with Illustrator's editing data opens through it as a PDF-compatible `.ai` does, with its layers and groups and with art reaching past its page unclipped; such a PDF holds the data in `AIPDFPrivateData` streams (part of #868). A shape a PDF or `.ai` paints with a gradient (a clip path round a shading) opens as one path filled with the gradient, not a clip group round a rectangle, so Shape Builder, Live Paint and Pathfinder work on its outline (#1304).
     In a `.ai` opened from its editing data, a text object on a layer that shows and doesn't print stays on that layer, made from the file's text document, even where the page doesn't draw it (`crates/eps/src/import/tests_native.rs`). Such a `.ai` opens without the PDF part's warnings that text was kept as outlines when no outlined glyphs come in, and a warning counts the text objects that hold the page's type next to glyphs the page has only as outlines, which don't come in (`crates/engine/src/cmd/fileio/tests_aiimport.rs`). Where the art of a `.ai` or EPS opened from its editing data differs a little from the file's page, the warning gives the share of the page that differs away from type. When that share is 0.2% or less, the warning names the type and gives the share of the page that differs where the type is; when all the type is made from the text document, the type's share has a warning of its own beside the art's (`crates/eps/src/import/tests_native.rs`).
     In a `.ai` or EPS opened from its editing data, where a layer's or group's drawn look (an effect can be attached to a group or a layer, [Vector and raster effects](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/vector-and-raster-effects.html)) draws a copy of art with type, the import puts the page's type that lies over the copy's other art into the copy's group, instead of giving it to other text objects by painting order. Type beside the copy's art, and every copy's type in a file past the import's text-object limits, still goes by painting order. Without a page, such a copy has no type, and no warning counts it as left out. How the page's type is matched with a copy is VectorCraft's own rule (`crates/eps/src/import/tests_native.rs`).
-    A `.ai` opened from its editing data keeps Effect › Pathfinder on a group with no fills or strokes of its own as a live effect, with the group's members editable: Add, shown or hidden, in its order among the group's effects. The other operations, Pathfinder Options values other than the ones the reader accepts, and the effect on a path, on type, or on a fill or stroke open as the drawn look (`crates/eps/src/import/ai/style.rs`, `pathfinder_effect`).
+    A `.ai` opened from its editing data keeps Effect › Pathfinder on a group with no fills or strokes of its own as a live effect, with the group's members editable ([Pathfinder effects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/combine-objects-using-pathfinder-effects.html)): Add, Intersect, Exclude, Subtract, Minus Back, Divide, Outline, Trim, Merge, Crop, Hard Mix and Soft Mix (with its Mixing Rate), shown or hidden, in its order among the group's effects. Which saved `Command` number names each operation other than Add, and reading Soft Mix's `Mix` from 0.01 to 1 as a Mixing Rate of `Mix` times 100, are VectorCraft's own reader rules. Trap, and the effect on a path, on type, on a layer or on a fill or stroke, open as the drawn look. So does any operation whose saved Pathfinder Options (Precision, Remove Redundant Points, Divide and Outline Will Remove Unpainted Artwork), `ConvertCustom`, `Mix` or Trap settings differ from the values the reader accepts (one value for each key, and Soft Mix's `Mix` range), although only Soft Mix uses `Mix` and none of the operations read here uses the Trap settings (`crates/eps/src/import/ai/style.rs`, `pathfinder_effect`).
     PDF text opens with every glyph where the file draws it (#722): the font's kerning or none, whichever the file followed, word and character spacing, `TJ` adjustments and horizontal scaling kept per character as tracking, text rise as baseline shift within its line, vertical glyphs narrower than an em centred on their column (`/W2`, `/W`, `/DW`), justified text boxes with word spacing back as justified area type (`tests_text_placement`, fixtures written from ISO 32000-1 §9).
     A `.ai` or PDF whose editing data holds a readable variable library opens with its variable definitions, data-set rows, text, visibility and linked-file values, active row and lock in the Variables panel, whether its layers are read or it comes in as its PDF part; graph values and malformed entries are skipped with a note. With its layers read, the objects its text, visibility and image variables are bound to (type for a text variable, any object for a visibility variable, a linked image for an image variable, found by their XML ids) come in bound, so selecting a data set changes them; locked and hidden objects, objects in a locked or hidden layer or group and objects on a locked artboard keep their bindings, and a data set leaves the locked ones as they are. Bindings whose object didn't come in or is of another kind are skipped with a note, as are graph bindings and every binding of a file that comes in as its PDF part (`crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`, `crates/engine/src/cmd/fileio/tests_aiimport.rs`).
     A `.ai` or EPS opened from its editing data keeps each artboard's center mark, cross hairs, video safe areas and video ruler pixel aspect ratio, and the file's Document Raster Effects Settings; the author comes from the header's `%%For` (the editing data's, else an EPS's own) when the file's File Info gives none, the header's custom colors that no swatch has come in as spot swatches, a named color the file defines takes the place of a default swatch of that name when the file has no palette, and an older file's `%%TemplateBox` places its artboard. A value of another type or out of range keeps its default (`crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`, `crates/engine/src/cmd/fileio/tests_aiimport.rs`).
     A `.ai` opened from its editing data opens its Objects on Path groups live, with their path, their objects in order along it, Pivot and Rotate, and their art where the file draws it; a group whose spacing has been dragged, or with options an Objects on Path group doesn't hold, opens as a plain group (`crates/eps/src/import/ai/tests.rs`).
     `.ai` symbol definitions and placed instances open as live symbols, in the Symbols panel's order; an instance of a symbol that isn't read, or whose appearance differs from its symbol's, comes in as the page draws it (`crates/eps/src/import/ai/tests.rs`).
     Blends and envelopes in the definitions of a `.ai`'s symbols, patterns and brushes' art count against the same per-file limits on blend layout and envelope checks as the layers' art, so a file with many definitions does not get those limits again for each one (`crates/eps/src/import/ai/read/directives.rs`).
-    A `.ai` or EPS whose editing data has brushes opens with the file's Calligraphic, Scatter, Art and Bristle brushes in the Brushes panel in place of the default ones, in the file's order: the Calligraphic size, roundness and angle with their variation, the Scatter size, spacing, scatter and rotation, the Bristle settings, and the Scatter and Art brushes' art (Art brushes in the older and newer forms of their objects). A brush library `.ai` (brushes and no layers) opens from its PDF part with its brushes, so Other Library lists them. Pattern brushes and brushes that can't be read are left out with a note; brushed paths still come in as their drawn look (part of #372 and #637; `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`).
+    A `.ai` or EPS whose editing data has brushes opens with the file's Calligraphic, Scatter, Art and Bristle brushes in the Brushes panel in place of the default ones, in the file's order: the Calligraphic size, roundness and angle with their variation, the Scatter size, spacing, scatter and rotation, the Bristle settings, and the Scatter and Art brushes' art. A brush library `.ai` (brushes and no layers) opens from its PDF part with its brushes, so Other Library lists them. An Art brush in Tints keeps that colorization. Pattern brushes and brushes that can't be read are left out with a note. Paths with a Calligraphic brush, and paths with an Art brush at 100% in Tints that stretches art of solid-filled paths unflipped, open as the path with the brush on its stroke, and other brushed paths still come in as their drawn look (part of #372 and #637; `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`).
     In a `.ai` opened from its editing data, a path or type object with Offset Path, Outline Object or Outline Stroke on the whole object opens as itself with those effects live, in their order and shown or hidden; on a fill or stroke of type they stay on that fill or stroke. Offset Path keeps its Offset, Joins and Miter Limit, and Outline Stroke takes its width from the stroke. An Offset Path with a setting missing, out of range or not read keeps the drawn art, as does a path with a Path effect on one fill or stroke (`crates/eps/src/import/ai/style/tests.rs`, `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`).
     In a `.ai` opened from its editing data, an object with a Tweak that moves nothing or Pucker & Bloat at 0 opens as itself with the effect live. A path, compound path or group whose only effect is Transform without copies, or a Free Distort whose corners make a parallelogram, opens as itself with it live, and so does an unstroked path or compound path with straight segments whose only effect is Twist. A gradient or pattern, an image, type, a clipping group, an opacity mask or effects inside the object, or a stroke with a Transform that scales, rotates or reflects, keep the drawn art (`crates/eps/src/import/ai/style/tests.rs`, `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/ai/read/ops.rs`).
     A PDF page whose `UserUnit` (PDF 1.6) is above 1 opens at its size in points, its numbers times the `UserUnit` (one above 75,000 counts as 75,000), and `document.pdfInfo` gives its size and boxes in points too. A `.ai` whose editing data has its artboards in the units of such a page opens from that data at the page's size, with its layers, and when the layers can't be read its pages still take the artboard layout of the data, scaled the same way (part of #1482).
@@ -1228,7 +1246,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     A `.ai`, or a PDF saved with Illustrator's editing data, whose editing data can't be decompressed opens from its PDF part with a warning that its layers weren't read and why, and an export or Save As to its own path asks first (`acknowledgeLoss`), as for a file whose layers the reader can't read (`crates/eps/src/import/tests_native.rs`, `crates/engine/src/cmd/fileio/tests_aiimport.rs`).
     A `.ai` or EPS opened from its editing data with one object on a shown layer that the reader can't read (an unknown operator inside a group, a pattern fill whose pattern it doesn't have, a symbol instance, a placed file without a usable preview) keeps its layers and groups: in that object's place, its layer gets a group of the page's objects inside the object's box, named after it, with a warning that lists what came in as the page's art and an export or Save As to its own path asking first (`acknowledgeLoss`). The file still opens from its page or PDF part when no box can be found, when live art or another unread object shares the page art inside it, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry the object's transparency (#4806; `crates/eps/src/import/tests_native.rs`, `crates/engine/src/cmd/fileio/tests_aiimport.rs`).
     A `.ai` or EPS opened from its editing data with one object on a shown layer that the reader can't read (an unknown operator inside a group, a pattern fill whose pattern it doesn't have, a symbol instance, a placed file without a usable preview) keeps its layers and groups: in that object's place, its layer gets a group of the page's objects inside the object's box, named after it, with a warning that lists what came in as the page's art and an export or Save As to its own path asking first (`acknowledgeLoss`). The file still opens from its page or PDF part when no box can be found, when live art or another unread object shares the page art inside it, when the object spans two artboards, or when the page art doesn't carry the object's transparency (#4806; `crates/eps/src/import/tests_native.rs`, `crates/engine/src/cmd/fileio/tests_aiimport.rs`).
-    In a `.ai` opened from its editing data, an envelope made with a warp, a mesh or a top object opens as a live envelope of its contents, with its warp style, bend and distortions, its mesh points and handles or its top object's outline, its Envelope Options, its Fidelity and whether its contents are being edited. An envelope that can't be read, or that VectorCraft draws differently from the file's drawn art, keeps that drawn art, with a note. An envelope of type keeps its drawn art, with its type hidden (`crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`).
+    In a `.ai` opened from its editing data, an envelope made with a warp, a mesh or a top object opens as a live envelope of its contents, with its warp style, bend and distortions, its mesh points and handles or its top object's outline, its Envelope Options, its Fidelity and whether its contents are being edited. When Distort Appearance is on and the size the file saves for the contents matches their bounds with strokes, the contents map from that stroked box, until an edit in Edit Contents changes how far the strokes reach; VectorCraft's new envelopes map from the geometric box, as do contents with no width or no height, such as a single straight line. An envelope that can't be read, or that VectorCraft draws differently from the file's drawn art, keeps that drawn art, with a note. An envelope of type keeps its drawn art, with its type hidden (`crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`).
     In a `.ai` opened from its editing data, Convert to Shape on a whole path or type object opens as a live Rectangle, Rounded Rectangle or Ellipse effect with its Absolute or Relative size, its corner radius, its place among the object's effects and whether it is hidden. A relative size in the file is added to each side. A relative Ellipse, or a setting VectorCraft doesn't read, keeps the drawn art (`crates/eps/src/import/ai/style/tests.rs`, `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`).
     PDF export and `.ai` saves write a page with a side longer than 14,400 pt with a `UserUnit` (PDF 1.6), its longer side divided by 14,400 and rounded up to the next thousandth, so that no side is longer than 14,400 units (ISO 32000-1, Annex C.2); in PDF 1.3 to 1.5 files and PDF/X files such a page is written in points.
     Placed (linked) files in a `.ai`'s editing data come in as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (a file found next to the document, at its path, or in the folder the editing data names relative to the document's, such as `src/`, is read as the document opens, and its link takes that file's size, modification time and hash). A file with them no longer falls back to its PDF part, so its guides, sublayers and hidden objects open (#1264; `crates/eps/src/import/ai/tests.rs`, `crates/engine/src/tests/links.rs`). In a file opened that way, a gradient with stops in the middle runs its whole ramp across its shape and a gradient object no longer passes its fill to the next path (#1390); text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line, the frame made taller with a warning in the open result (#1392).
@@ -1289,6 +1307,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - On Windows, a link on a drive mapped to a network share other than the document's (`Y:\…`) is missing, with the reason that the path is on another computer, as a link stored with that share's own path is; links on this computer's drives and on the document's share are followed.
   - In the Links panel, Shift-click selects a range of links and Ctrl/Cmd-click adds or removes one.
   - Linked files another app changes while their document is open follow Preferences › File Handling › Update Links, as they do when it opens: Automatically reads them again (an Update Links undo step), Ask When Modified offers to, Manually leaves them modified in the Links panel. The desktop app compares the active document’s linked files by size and modification time every two seconds and when its window comes back to the front, on a worker thread; a file still being written is tried again (`links.updateChanged`).
+  - A look at the linked files whose worker thread ends without a result, such as after a panic, no longer stops later looks: the app clears it, stops asking for a frame every 100 ms, and the next look starts on schedule (`crates/engine/src/tests/linkwatch.rs`, `crates/ui-egui/src/tests/place.rs`).
   - Import and paste, 2026-10-13: a multi-artboard `.ai` with notes beside its artboards opens from its editing data, a page's art past its artboard no longer lying over the page before it (#1528); a `.ai` gradient whose stops are listed upwards keeps each midpoint on the stop that starts its part of the ramp (#1530); SVG text on a path follows basic shapes (circle, ellipse, rect, line, polyline, polygon) as their SVG 2 equivalent paths (#1531, fixes #1527); PDFs whose alpha soft masks are drawn as images import with the mask instead of empty art (#1551); EPS and PostScript type set in Type 42 (TrueType) fonts imports at its size instead of 1000 times too large (#1553); PDF and EPS import keep a clipping path whose bounding box covers the page but whose shape doesn't (#1544, fixes #1542). Opening or placing a file with an image too large to decode says so, and the Links panel shows it on the row (#1540, part of #1479). Paste takes a PDF or EPS another app copied as editable vector art: from the macOS pasteboard (with SVG), EPS on Windows beside PDF, and `.eps` files copied in a file manager, with the new command `clipboard.importEps` (#1538, fixes #1499).
   - A `.ai` or `.ait` file copied in a file manager pastes as its art: one that holds a PDF pastes the objects of its editing data, and one saved as PostScript pastes as a copied `.eps` file does.
   - A copied `.ai` or `.ait` file that holds a PDF pastes the objects of its editing data as File › Open reads them: every layer's objects go into the active layer in their stacking order, with their names, hidden objects and type objects, instead of the PDF page's art with its type as outlines. When the editing data can't be read, the file pastes its page as before (`clipboard.importPdf {editingData}`). The objects of a hidden layer come in hidden, from a pasted EPS too.
@@ -1313,6 +1332,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   The renderer composes the two ink planes of a CMYK document that shows transparency into screen colors on up to as many threads as it rasterizes with, instead of on one. At 2880 × 1800 on 8 threads, a page of 300 shapes at 20% to 90% opacity takes 30 ms a frame instead of 55 ms, and 50,000 paths with one at 99% opacity take 258 ms instead of 361 ms (`vectorcraft-cli bench`), with the same pixels.
   With Overprint Preview or Separations Preview on, the renderer keeps the art it prepared for the preview from one frame to the next. It prepares again the objects that changed, and all of the art when Discard White Overprint changes or, with Separations Preview, when the plates shown, the proof setup, the swatches, the Spot Colors option or the color settings change or a profile is loaded. It draws the other objects from the art, geometry and stroke outlines it kept for them.
   The Pathfinder panel, Offset Path, Clean Up, Divide Objects Below, Make and Release Blend, Envelope Distort's Make and Release, Repeat (Radial, Grid, Mirror and Release), Vector Halftone, New and Redefine Symbol, Delete Symbol, erasing with the Symbol Sprayer, Rasterize, Convert to Artboards, Flatten Transparency, Clear Guides, Shape Builder, Live Paint, Release Image Trace, Make and Release Opacity Mask, Delete with direct-selected anchor points, Remove Anchor Points, Cut Path, and the Shaper, Knife, Eraser, Path Eraser, Line Cut, Rectangle Cut, Mirror & Cut and Blob Brush tools add and remove objects in one pass over each layer or group they change, and Outline Stroke and Expand write each new object in the place of the object it replaces (#1429).
+  Offset Path looks up the segments near each candidate hole or island in a tree of the source path's segment bounds when it decides whether to drop that contour, instead of testing the bounds of every segment. The output paths are the same. On compound and open paths of 25,000 to 40,000 anchors with 6,400 to 11,976 candidate contours, that check takes 11 to 13 ms instead of 140 to 649 ms (medians of five interleaved runs). The limit on overlapping segment pairs is the same, so a path that stops with "Offset Path: the path is too complex to offset" still stops there.
   With more than 10,000 type on a path objects selected, the Selection and Direct Selection tools neither draw nor hit-test the objects' brackets.
   The renderer outlines the stroke of a path object with more than 1,024 path elements, without dashes or a width profile, only in and around the view, with a margin of the view's size on each side, and outlines it again when the view moves past that margin. The pixels are the same. At 1600 × 1200, the frame after one anchor of an open path of 200,000 anchors moves takes 28 to 30 ms instead of 103 ms, and with a closed path of 50,000 anchors 10 ms instead of 30 ms (`cargo run --release -p vectorcraft-engine --example anchor_bench`).
   The renderer outlines a dashed stroke of such a path the same way, without a width profile, and draws its dashes and dots in the same places as when the whole path is dashed, so the pixels are the same. A pattern too fine to draw is drawn solid, as before, and its stroke is outlined near the view too. At 1600 × 1200, the frame after one anchor moves takes 14 ms instead of 102 ms with a filled closed path of 50,000 anchors and a stroke of 6 pt dashes and 4 pt gaps (`cargo run --release -p vectorcraft-engine --example anchor_bench`, which now includes that document).
@@ -1324,6 +1344,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   The renderer keeps the path of a path or compound path of 1,024 anchors or more by object, with the bounds of its segments and of its miter spikes in runs of 128 segments. When anchors move and the subpaths and anchor counts stay the same, the next frame changes only the segments that start or end at a moved anchor and measures again only the runs that hold them or the segments with length before them, instead of making the whole path again and measuring it whole for culling. The pixels and the cull bounds are the same. On Windows at 1600 × 1200, the frame after one anchor moves takes 8.2 ms instead of 30.1 ms with an open path of 200,000 anchors, 4.3 ms instead of 10.4 ms with a closed path of 50,000 anchors, and 6.6 ms instead of 11.9 ms with the filled closed path of 50,000 anchors and a dashed stroke (medians of five runs of `anchor_bench`).
   Type › Show Hidden Characters keeps the marks it places on each text object from one frame to the next. The canvas lays a text object out again when an edit changes it or its threaded story, or when the last frame that showed the marks did not draw it, and it lays out all type in view again when the fonts or the hyphenation exceptions change. With 1,000 two-line labels in view, drawing the marks takes 0.8 ms per frame in a release build instead of 19.7 ms.
   A selection with more than 100,000 points to outline shows its bounds instead of each object's outline and anchors. Paths count their anchors. Area type and type on a path count the anchors of their frame or path, and point type counts six: its box's corners and the ends of its baseline marker. Images, symbol instances, placed documents, and area type or type on a path in perspective count the four corners of their box, and gradient meshes and envelopes count their points and the ends of their mesh lines. The hover highlight leaves out an object past that count, and such an object shows its bounds as the key object. With 32,768 type objects, images, symbol instances, gradient meshes or envelopes selected, the selection's outlines and anchors add fewer than 100 vertices to the canvas's mesh (#2460).
+  The canvas keeps the selected objects' outlines, anchors and handles from one frame to the next as one mesh. It builds an object's marks again when the object, its layer color or its selected anchors change. A pan moves the kept outlines and handles and places the anchor squares again. Each subpath and handle gets its triangles the first time it is in view. A frame with a new zoom or rotation draws the marks one shape at a time and keeps nothing, and the next frame at that view builds them. The pixels are the same, apart from two small differences: a kept outline's corner of exactly 90 degrees in a rotated view can keep its miter or cut corner after a pan, and kept vertices can move by rounding errors. On Windows at 1440 × 900, in a release build, with 2,000 selected circles of 50 anchors each in 10 fill colors, an idle frame takes 12.8 ms instead of 59.9 ms with the Selection tool and 29.8 ms instead of 192.1 ms with Direct Selection (medians of five runs). A frame during a zoom takes about what it did: 86.7 ms instead of 80.0 ms with the Selection tool.
   Delete, Cut, Group, Ungroup, Make and Release Compound Path, Make Clipping Mask, Send to Current Layer, Duplicate, Copy in the Move, Rotate, Scale, Reflect and Shear dialogs, Transform Each with Copy and each move of an Alt-drag take time in proportion to the size of the document (#1429).
   In the web build the status bar's render and UI times are measured with the browser's `performance.now()`, and the Layers panel stops rendering row thumbnails in a frame once they have taken 8 ms.
   On the desktop, the Layers panel renders a row's thumbnail on its thumbnail thread when the row's paths, and the paths of its opacity masks that are not disabled, hold more than 2,000 anchors in all. It already did this for the first thumbnail of a row of more than 200 objects. Until its first thumbnail is ready, the row shows boxes at the bounds of up to 41 of its paths, each in its path's solid fill or stroke color or in gray, when its own paths, without its opacity masks, hold at most 2,000 anchors in all, and an empty white box otherwise. With one path of 200,000 anchors, the first frame after the panel opens takes 2.4 ms instead of 393 ms (release build, median of three runs).
@@ -1335,6 +1356,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   With the Perspective Selection tool, Ctrl+Alt-drag (Command+Option-drag on macOS) also copies objects on their perspective plane; Alt/Option-drag continues to do so.
   With the Perspective Selection tool, holding Shift while moving or copying constrains each object's displacement to the nearest axis or 45° diagonal of its own plane; releasing Shift resumes the raw pointer position, and 5 still moves perpendicular to the plane. Snap to Grid follows the constrained line on the first object's plane and depth.
   When the desktop app opens a document on a thread of its own (#1245), that thread also reads the document's linked files and lays out its type, and the UI thread only adds the finished document: in release builds, the step left on the UI thread takes 0.02 ms instead of 1.04 s for a document with 12 linked 3000 × 2000 TIFFs, and it takes 0.1 ms instead of 0.85 s for one with 300 Auto Size area type objects, every second one in three columns.
+  Laying out type keeps each font face's shaping plans, at most 32 per face, so type objects of the same font, script, direction, language and features share one plan: the layouts of a document of 5,000 short point type objects take 59 ms instead of 73 ms in a release build, and the glyphs, bounds and baselines do not change.
   The Layers panel's Delete Selection, Duplicate Selection, Collect in New Layer, Merge Selected, Flatten Artwork, Release to Layers (Sequence) and row drags also take time in proportion to the size of the document, and so do Cut Artboard and Duplicate Artboard with their art and each move of an Alt-drag of one artboard with the Artboard tool while Move/Copy Artwork with Artboard is on (#1429).
   In Outline view the renderer draws paths and compound paths from the geometry it keeps for them between frames, and it culls the members of clip groups by the bounds it keeps for them. Layers with Preview off and the outlines of Image Trace objects are drawn the same way.
 - **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so any GPU that can show the window will do. Preferences › Performance › Graphics Processor (`gpuPreference`) is Automatic by default: the power-saving GPU on Windows and macOS (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306), and the GPU the desktop runs on under Linux, where KWin on an NVIDIA GPU refused frames from a Ryzen's integrated GPU and 0.5.0 crashed at startup (#502). Power Saving and High Performance pick a kind of GPU; `WGPU_POWER_PREF`, `WGPU_ADAPTER_NAME` and `WGPU_BACKEND` override them. The app picks among the adapters that can present to the window (native backends before OpenGL, hardware before software, and on Windows a GPU's DX12 adapter before its Vulkan one: Intel's Vulkan driver made the whole window flicker black, #545), and if the window fails on one while starting up it starts again without it instead of crashing; after a start that a graphics driver crashed before its first frame, the next starts leave that adapter out, or list OpenGL's adapters alone when the crash came while the adapters were being listed (#2243; verified by unit tests, not on the reporter's Intel UHD Graphics 605); Help › About, `ui.inspect` and the log name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369). On Windows and Linux the tools' cursors are OS cursors (bitmaps rasterized once per display scale), which the system moves itself: painted into the window, they trailed the pointer by the frames waiting to be shown, and the window now queues one frame instead of two (#444). macOS and the web still paint them (macOS sizes cursor bitmaps in points, eframe has no bitmap cursors on the web). Tool states have cursors of their own as the public manual describes them: Direct Selection shows a hollow or filled square on its white arrow over an anchor (path unselected or selected) and the Reshape Segment cursor over a curved segment, as do the Anchor Point tool and the Pen with Alt (whose caret it lends); Group Selection, and Direct Selection with Alt, show a plus; a drag shows the filled arrow, hollow while it snaps to a point or a guide, and an Alt-drag copy a double arrowhead; Curvature has its own pen and Free Transform's Cmd/Ctrl side-shear two arrows passing along the side. Lasso, Magic Wand, the freehand tools, Shaper, Live Paint Bucket, Measure, Print Tiling, the symbolism tools, vertical type, Scissors, Mesh and Puppet Warp return cursors of their own, which borrow the crosshair, the I-beam, the Pen's add cursor or not-allowed until they're drawn; there's no busy cursor yet. `crates/tools/src/cursors.toml` lists every cursor, when it shows and its hotspot, for whoever draws them. Pens and touch drive the tools as the mouse does, and a tap pressed and lifted within one frame clicks where it tapped (#491); pen pressure reaches the Paintbrush's pressure-sensitive brushes and the Liquify tools' Use Pressure Pen on Windows, on the web and on Linux under X11 and XWayland, while winit 0.30 reports none on macOS or native Wayland. On Linux, see `docs/development.md` for pens under Wayland.
@@ -1703,7 +1725,9 @@ Edit › Copy and Cut put the selected ruler guides on the clipboard, with the s
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-11-06 | minor | `.ai` and EPS import: Art brushes in the older form of their objects come into the Brushes panel; evidence updated; scores unchanged. |
+| 2026-11-06 | minor | Direct Selection: with Snap to Grid, a dragged straight segment lands its anchors on the grid (#3835); evidence added; scores unchanged. |
+| 2026-11-06 | minor | Snap to Glyph › Glyph Bounds: the corners of each glyph's box are points a drawn point lands on, also on a curved side (`B`), and the box turns with rotated type, its edges then Angular Guides (#5112; [Snap to Glyph options](https://helpx.adobe.com/illustrator/desktop/design-with-text/special-characters-glyphs/snap-to-glyph-options.html)); scores and estimates unchanged. |
+| 2026-11-06 | minor | Drop Shadow: a swatch beside Color opens the Color Picker over the dialog, as the other effect colour fields do (#5364); correction: the #5365 entry listed Drop Shadow, whose Color is drawn outside the shared grid and had no swatch; scores unchanged. |
 | 2026-11-06 | minor | Drop Shadow, Outer Glow and Inner Glow: their number fields have spinner arrows (#5367, #5368); evidence added; scores unchanged. |
 | 2026-11-06 | minor | Stroke Weight Up and Down (Cmd/Ctrl+Alt+. and ,) step each selected stroke's weight (#5797); evidence added; scores unchanged. |
 | 2026-11-06 | minor | Hindi (`hi`): 7,877-row machine-assisted catalog, zero/one singular plurals, desktop font fallback and optional Devanagari craft-fonts fallback; all 55 translation tests pass; native review and a web font remain; scores and estimates unchanged |
@@ -1716,6 +1740,8 @@ Edit › Copy and Cut put the selected ruler guides on the clipboard, with the s
 | 2026-10-30 | minor | Effects: Color Halftone's Max Radius is 4–127 px of the Document Raster Effects resolution, shown in px whatever the units; older documents open converted, and files saved for older app versions hold points (#3260); scores unchanged. |
 | 2026-11-05 | minor | Compound Shapes add-on (beyond Illustrator): Object › Plug-ins › Compound Shapes lists Make, Release and Expand Compound Shape, and holds a setting, off by default, that makes the Pathfinder panel's Shape Mode buttons make a compound shape on a click and give the permanent result on Alt-click (the default is the reverse). Selected members of a compound shape always take the clicked mode. The setting is `window.pathfinder.compoundShapes`; no existing behavior changes while it is off. Scores and estimates unchanged. |
 | 2026-11-01 | minor | Batch Trace Folder (`imageTrace.batchFolder`, #4921); evidence added; scores unchanged. |
+| 2026-11-06 | minor | Shape tools: a shape just drawn can be moved and turned with its tool still active — a press on the selection's centre point (Attributes › Show Center) moves the selection with the Selection tool's move arrow, snapping and Alt copy, and a press in the rotate zone just outside a bounding-box corner turns it about the centre with its rotate cursor, as the Selection tool's do (#5477); the Selection tool takes the centre point too, so a press there moves an unfilled shape instead of starting a marquee; evidence: `a_shape_tool_moves_the_selection_by_its_centre_point_and_turns_it_from_a_corner` (`crates/tools/src/shape/tests.rs`) and `a_press_on_the_centre_point_moves_an_unfilled_shape` (`select/tests.rs`); scores and estimates unchanged |
+| 2026-11-06 | minor | Transform fields: one Tab moves from one numeric field to the next in the Transform panel, the Properties panel's Transform section and the Control bar (each field's scrub label was a second tab stop, invisible because only the label is drawn there, and the W/H link between W and H in the Control bar was one too, and now comes after the fields); evidence: `one_tab_moves_from_a_field_to_the_next` and `the_control_bar_link_toggles_by_click` in `crates/ui-egui/src/panels/tests_constrain.rs`; scores and estimates unchanged |
 | 2026-11-01 | minor | Copy and paste ruler guides (#3226); evidence added; scores unchanged. |
 | 2026-11-04 | minor | Area type vertical alignment buttons in the Properties panel's Paragraph section and the Control panel, off for columns, rows and threaded frames (#3759); evidence added; scores unchanged. |
 | 2026-11-03 | minor | Enclosing Lasso is an add-on with no default shortcut or Basic toolbar slot. Scores and estimates remain unchanged. |
diff --git a/docs/three-d.md b/docs/three-d.md
index 7b1a25c62..7cc339dff 100644
--- a/docs/three-d.md
+++ b/docs/three-d.md
@@ -70,6 +70,24 @@ The rest is our reading:
   grid stays flat.
 - A stroke whose outline takes more than 2,048 points is left out, and the fill's solid still draws.
 
+## Groups
+
+Extrude & Bevel, Inflate and Rotate also apply to a group or layer. The public documentation says that applied to
+several objects one by one each turns about its own axis, while applied to a group or layer all its objects turn
+about a shared axis ([Create 3D objects](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/create-3d-graphics/create-3d-objects.html),
+said there of Revolve). So the effect on a group builds a solid from every visible path, compound path and type in
+it, at any depth of its groups, each from its own fills and strokes as above ([Fills and strokes](#fills-and-strokes)),
+and they turn, twist and taper together about the center of their bounds together; with Perspective one eye sees
+them all. The members stay editable: moving or editing one reshapes the solids. Our reading:
+
+- Each member's own geometry effects shape it first; the group's geometry effects before the 3D effect reshape the
+  members, and those after it bend the result as a whole. The members' other effects, and the group's own fills and
+  strokes, are not drawn. A member's opacity applies to its solids; its blending mode does not.
+- When every solid is opaque, all members' faces are drawn in one back-to-front order; otherwise each solid is drawn
+  on its own, the backmost member's first.
+- Hidden members and guides are left out. A group holding an image, a symbol instance, a clipping group or another
+  live object is refused with a message saying what to release or expand; so is one with more than 4,096 shapes.
+
 ## Rotate
 
 The flat art turned in 3D about the centre of its bounds. Every fill and stroke is turned with its own paint (a
@@ -176,7 +194,9 @@ out, perspective). No Adobe software, assets, presets or bevel shapes were used.
   drawn in pieces about as long as a wall slice is wide (fewer near the limit of 32,768 facets). The piece drawn
   on top can still lie a few points behind another nearby piece.
 - Extrude & Bevel and Rotate retain planar shading. Colored Inflate uses smooth vector lighting; white-light Inflate keeps its original polygon shading; bounded cell triangulation leaves a cell flat when it contains a complete hole or an unusually complex/degenerate contour. Its geometric silhouette is still a polygon approximation.
-- Paths and compound paths only: convert type, images and groups to outlines first. One 3D effect per object.
+- Paths, compound paths, type and groups or layers of them (see [Groups](#groups)); images, symbol instances,
+  clipping groups and other live objects have to be converted first. Revolve on a group is not built yet. One 3D
+  effect per object.
 - Curves are followed within 1/2000 of the shape's size (at least 0.05 pt), so a small curve takes a few points
   and a large one up to 32. Extrude & Bevel and Inflate take up to 2,048 outline points (a stroke's outline is
   counted on its own), Rotate (which only turns the outline) 65,536.
@@ -189,5 +209,6 @@ Release measurements and a repeatable CLI scene are in [3D lighting performance]
 
 | Date | Change |
 |---|---|
+| 2026-11-06 | Extrude & Bevel, Inflate and Rotate apply to groups and layers: every path, compound path and type in them turns about one shared axis (#4506). |
 | 2026-10-21 | Four original lighting presets, shared by all four 3D effects and commands, with effective-setting recognition and existing preview/history behavior. |
 | 2026-10-17 | Smooth colored Inflate lighting and surface batching; legacy white-light appearance and the 0.05 seam minimum preserved; shared light Color and multiple lights remain vector output. |
diff --git a/docs/type-parity.md b/docs/type-parity.md
index c539baf2e..b36cb4892 100644
--- a/docs/type-parity.md
+++ b/docs/type-parity.md
@@ -1,6 +1,6 @@
 # Type parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-05 · **Change:** minor (Show Snap to Glyph Options scrolls to the options, with a Snap to Glyph checkbox, #5273; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-07 · **Change:** minor (Indian-language hyphenation review and license allowlist, #4947; Bulgarian among the languages, with its quote marks and the fonts' Bulgarian forms, #5945; previously minor: Show Snap to Glyph Options scrolls to the options, with a Snap to Glyph checkbox, #5273; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
 
 Type is Illustrator's largest single area by use (weight 13 of 105 across "Type core" and "Type advanced" in
 [target-app-parity.md](target-app-parity.md)). This checklist lists the features one by one. Status is from the
@@ -42,17 +42,18 @@ against Illustrator's public documentation; **estimated** unless noted.
 | System Layout | done | Character panel menu › System Layout, `type.systemLayout`: the whole document, off by default and for documents from before it, saved only when on. On, every text object advances by whole points (at least one when a character takes space). New point, area and path type, threaded frames, placed text, graph and dimension labels and pasted plain text inherit it. Evidence: `tests::system_layout_rounds_positive_advances_to_whole_points`, `typecmd::area_tests::system_layout_sets_the_document_and_every_text_object`, `panels::character::tests::system_layout_menu_item_toggles_the_document` |
 | Fractional Widths | done | Character panel menu › Fractional Widths, `type.fractionalWidths`: per type object, and every frame of its threads. On by default and for documents from before it; saved only when off. Off, each character that takes space advances by a whole number of points, at least one, so small type does not run together. Evidence: `tests::fractional_widths_off_rounds_positive_advances_to_whole_points`, `typecmd::area_tests::fractional_widths_is_set_per_object_and_saved_only_when_off`, `panels::character::tests::fractional_widths_menu_item_toggles_the_type_object` |
 | Roman Hanging Punctuation | done | Paragraph panel menu › Roman Hanging Punctuation, `text.setFormat {romanHangingPunctuation}` (#2756): per paragraph, Optical Margin Alignment's punctuation and amounts without the letters; paragraph styles carry it. Evidence: `tests::roman_hanging_punctuation_hangs_punctuation_but_not_letters`, `typecmd::area_tests::roman_hanging_punctuation_is_set_per_paragraph_and_saved_only_when_on`. Whole paragraphs hang as published with both composers, ragged, centred and justified, with Line-end Punctuation Half Width and bidirectional lines; Justification's Glyph Scaling leaves the hung marks at their width, and Standard burasagari counts what hangs at a line's start as room before hanging a comma (`tests_hang`) |
-| Hyphenation… and Justification… options | done | Hyphenation… (`ui.hyphenation`, `text.setFormat`) sets each paragraph's Words Longer Than, After First, Before Last, Hyphen Limit, Hyphenation Zone (Single-line Composer only) and Hyphenate Capitalized Words, and paragraph styles carry them (#2310). Justification… (`ui.justification`, `text.setFormat`, #2755) sets Word Spacing, Letter Spacing and Glyph Scaling (Minimum, Desired, Maximum), Auto Leading and Single Word Justification; Desired applies to every line, justified lines and the Every-line Composer use the ranges. Vertical type isn't glyph scaled; type on a path doesn't use them. Evidence: `crates/text/src/tests/justify.rs`, `dialogs::justification::tests` |
+| Hyphenation… and Justification… options | done | Eleven Indian languages use attributed patterns and preserve syllables in both composers (#4947). Hyphenation… (`ui.hyphenation`, `text.setFormat`) sets each paragraph's Words Longer Than, After First, Before Last, Hyphen Limit, Hyphenation Zone (Single-line Composer only) and Hyphenate Capitalized Words, and paragraph styles carry them (#2310). Justification… (`ui.justification`, `text.setFormat`, #2755) sets Word Spacing, Letter Spacing and Glyph Scaling (Minimum, Desired, Maximum), Auto Leading and Single Word Justification; Desired applies to every line, justified lines and the Every-line Composer use the ranges. Vertical type isn't glyph scaled; type on a path doesn't use them. Evidence: `crates/text/src/tests/justify.rs`, `dialogs::justification::tests` |
 | Roman Hanging Punctuation | done | Paragraph panel menu › Roman Hanging Punctuation, `text.setFormat {romanHangingPunctuation}` (#2756): per paragraph, Optical Margin Alignment's punctuation and amounts without the letters; paragraph styles carry it. Evidence: `tests::roman_hanging_punctuation_hangs_punctuation_but_not_letters`, `typecmd::area_tests::roman_hanging_punctuation_is_set_per_paragraph_and_saved_only_when_on` |
-| Hyphenation… and Justification… options | done | Hyphenation… (`ui.hyphenation`, `text.setFormat`) sets each paragraph's Words Longer Than, After First, Before Last, Hyphen Limit, Hyphenation Zone (Single-line Composer only) and Hyphenate Capitalized Words, and paragraph styles carry them (#2310). Justification… (`ui.justification`, `text.setFormat`, #2755) sets Word Spacing, Letter Spacing and Glyph Scaling (Minimum, Desired, Maximum), Auto Leading and Single Word Justification; Desired applies to every line, justified lines and the Every-line Composer use the ranges. Vertical type isn't glyph scaled; type on a path doesn't use them. Auto Leading also sets the Leading the Character panel shows for Auto type, the leading Alt+↑/↓ (`type.step`) steps from, per paragraph, and the lines Fill with Placeholder Text counts. Evidence: `crates/text/src/tests/justify.rs`, `dialogs::justification::tests`, `tests_prefs::auto_leading_steps_and_fills_from_the_paragraph_auto_leading`, `panels::character` test `leading_field_shows_the_paragraph_auto_leading` |
+| Hyphenation… and Justification… options | done | Eleven Indian languages use attributed patterns and preserve syllables in both composers (#4947). Hyphenation… (`ui.hyphenation`, `text.setFormat`) sets each paragraph's Words Longer Than, After First, Before Last, Hyphen Limit, Hyphenation Zone (Single-line Composer only) and Hyphenate Capitalized Words, and paragraph styles carry them (#2310). Justification… (`ui.justification`, `text.setFormat`, #2755) sets Word Spacing, Letter Spacing and Glyph Scaling (Minimum, Desired, Maximum), Auto Leading and Single Word Justification; Desired applies to every line, justified lines and the Every-line Composer use the ranges. Vertical type isn't glyph scaled; type on a path doesn't use them. Auto Leading also sets the Leading the Character panel shows for Auto type, the leading Alt+↑/↓ (`type.step`) steps from, per paragraph, and the lines Fill with Placeholder Text counts. Evidence: `crates/text/src/tests/justify.rs`, `dialogs::justification::tests`, `tests_prefs::auto_leading_steps_and_fills_from_the_paragraph_auto_leading`, `panels::character` test `leading_field_shows_the_paragraph_auto_leading` |
 | Tab stops and leaders; Tabs panel | partial | Tabs panel and stops with leaders in the model (`text.tabs.set`); a stop drags from where the press landed (#1458); leaders fill the tab's gap, repeated on a grid so they line up from line to line (#1877); Ctrl-dragging a stop (Command on macOS) moves all the stops together |
 | Hidden characters (Show Hidden Characters) | done | `type.hiddenCharacters` |
 | Spell check (Check Spelling, Auto Spell Check, custom dictionary) | missing | menu stubs; needs an openly licensed dictionary |
 | Smart Punctuation, Change Case, Find & Replace | done | |
+| Alt + numeric-keypad codes while typing (Windows: `Alt+0176` → °) | partial | #5108: on Windows the character Windows posts when Alt comes up after keypad digits is typed at the caret like any other, in the typing's undo step, and the keypad digits typed with Alt run no shortcut (`windows_alt_codes` tests; not yet tried on a Windows machine). `type.insert {code}` (Windows Alt+0 code, Windows-1252 for 128–159) and `{unicode}` (hex code point) insert a character by its code (`menucmds::insert_a_character_by_its_code`). macOS and Linux have no such system convention and egui reports a keypad digit as the top-row digit, so there it does nothing; a floating panel window doesn't receive the character |
 | Caret: the arrows and Delete step over whole clusters (Thai consonant with its marks, combining accents, emoji); Backspace removes one character | done | in text with right-to-left characters the arrows move in visual order and stop on both sides of a character drawn with no width, such as a zero width non-joiner |
 | Touch Type tool | done | moves, scales and rotates one character through its kerning, baseline shift, scales and rotation (`text.touchType`); a character with a preceding logical character on the same line can move along the line in either reading direction; the first logical character moves only up and down. Positive `dx` follows reading order. These direction rules are VectorCraft's choices. |
 | Retype (identify fonts in outlines/images) | missing | Illustrator's uses a cloud model |
-| Snap to Glyph | done | View › Snap to Glyph (`view.snapToGlyph`): with Smart Guides on, new point type and drawing tools snap to live-text baselines and glyph bounds (`Targets::for_drawing`, `tools::text_tests::snap_to_glyph_lines_up_new_point_type_with_a_baseline`). Character panel menu › Show Snap to Glyph Options: Baseline, x-height, Glyph Bounds, Proximity Guides, Angular Guides and Anchor Point each turn their guides on or off (`view.snapToGlyph.options`, all on by default; #4232), after a Snap to Glyph checkbox for View › Snap to Glyph; showing them scrolls the panel to them (#5273) |
+| Snap to Glyph | done | View › Snap to Glyph (`view.snapToGlyph`): with Smart Guides on, new point type and drawing tools snap to live-text baselines and glyph bounds, the corners of each glyph's box included, turning with rotated type (#5112; `guides::tests::a_drawn_point_lands_on_a_corner_of_a_glyphs_bounds`, `Targets::for_drawing`, `tools::text_tests::snap_to_glyph_lines_up_new_point_type_with_a_baseline`). Character panel menu › Show Snap to Glyph Options: Baseline, x-height, Glyph Bounds, Proximity Guides, Angular Guides and Anchor Point each turn their guides on or off (`view.snapToGlyph.options`, all on by default; #4232), after a Snap to Glyph checkbox for View › Snap to Glyph; showing them scrolls the panel to them (#5273) |
 | Thai, Lao, Khmer, Myanmar: shaping (marks, reordering), lines broken between words, word-by-word caret and double-click | done | words found by ICU4X's line segmenter: dictionaries on the desktop, LSTM models on the web |
 | Middle Eastern: bidirectional layout, Paragraph Direction | done | |
 | Middle Eastern and Indic: digit types (Character panel menu › Digits: Default, Arabic, Hindi, Farsi; Devanagari, Bengali, Gurmukhi, Gujarati, Odia, Tamil, Telugu, Kannada, Malayalam) | done | `text.setFormat` / `text.setRangeStyle {digits}` (`"devanagari"`, `"bengali"`, `"gurmukhi"`, `"gujarati"`, `"odia"`, `"tamil"`, `"telugu"`, `"kannada"`, `"malayalam"` added, #4942); the text keeps the typed digits, the glyphs and SVG export follow the style; carried by character styles. Not yet: `.ai` export of the setting; Indic digits typed as such stay as typed under another system. Evidence: `text::tests::indic_digits_map_to_their_scripts_block`, `tests::bidi::indic_digits_draw_the_scripts_own_digits`, `typecmd::area_tests::indic_digits_round_trip_through_the_commands_and_the_file` |
@@ -65,7 +66,8 @@ against Illustrator's public documentation; **estimated** unless noted.
 | CJK: manual tate-chu-yoko | done | Character panel menu › Tate-chu-yoko (`text.setFormat` / `text.setRangeStyle {tateChuYoko}`), with Show East Asian Options: marked characters stand side by side across one em of a vertical column, squeezed to the em when wider; two or three half-width digits still do so without the mark; horizontal type keeps the mark and does not move them. Tate-chu-yoko Settings… (`ui.tateChuYokoSettings`, `{tcyUpDown, tcyLeftRight}` in points) moves a marked block up or down and right or left as one piece. Evidence: `tests_vertical::manual_tate_chu_yoko_sets_marked_characters_across_one_em`, `tests_vertical::tate_chu_yoko_settings_move_a_marked_block_up_down_left_and_right`, `typecmd::tate_chu_yoko_is_a_character_attribute_saved_only_when_on`, `typecmd::tate_chu_yoko_settings_are_character_attributes_saved_only_when_set`, `dialogs::tate_chu_yoko::tests` |
 | CJK: Standard Vertical Roman Alignment | done | Character panel menu › Standard Vertical Roman Alignment (`text.setFormat` / `text.setRangeStyle {standardVerticalRoman}`), with Show East Asian Options, off by default: in vertical type the marked half-width characters (Latin letters, digits and other characters that would lie on their side) stand upright one below the other, each in its upright cell; spaces keep their width and tate-chu-yoko blocks stay across the column; horizontal type keeps the mark and does not change. Character Style Options has its own checkbox for it. Evidence: `tests_vertical::standard_vertical_roman_alignment_stands_half_width_characters_upright`, `typecmd::standard_vertical_roman_is_a_character_attribute_saved_only_when_on` |
 | CJK: ruby | partial | ruby (ふりがな) for live text (`type.ruby`): a reading over a byte range, above (right of the column in vertical type) or below, start/centre/end alignment, size, overhang or squeeze; saved natively, laid out with its line growing, drawn on the canvas, in SVG and PDF (as outlines where ruby is present), in EPS, EMF/WMF and legacy `.ai` (legacy `.ai` writes type with ruby as outlines), and kept by Create Outlines, Expand Appearance and flattening, each glyph where the layout puts it (`typecmd::ruby_tests::create_outlines_keeps_the_ruby_where_it_is_laid_out`) | #633 |
-| Language per character (Character panel › Language, character styles), text shaped in it | done | `text.setFormat` / `text.setRangeStyle {language}` by name or BCP 47 tag, one of Document Setup's languages (Hindi, Marathi, Gujarati, Bengali, Punjabi, Tamil, Telugu, Kannada, Malayalam, Odia and Urdu added, #4943; Serbian: Cyrillic, Serbian: Latin and Croatian); the shaper gets the tag, so the font's language forms apply (OpenType `locl`: Turkish keeps `fi` apart and the dot on its i, #4940); new type takes the document's language; saved as the tag only when set, carried by character styles (#4946). Not yet: hyphenation and spelling by it, `.ai`/PDF import of a text's language, paragraph styles. Evidence: `features::tests::language_picks_the_fonts_forms`, `features::tests::serbian_gets_the_fonts_serbian_forms`, `typecmd::area_tests::language_is_a_character_attribute_saved_only_when_set` |
+| Language per character (Character panel › Language, character styles), text shaped in it | done | `text.setFormat` / `text.setRangeStyle {language}` by name or BCP 47 tag, one of Document Setup's languages (Hindi, Marathi, Gujarati, Bengali, Punjabi, Tamil, Telugu, Kannada, Malayalam, Odia and Urdu added, #4943; Assamese and Sanskrit added, #4947; Serbian: Cyrillic, Serbian: Latin and Croatian); the shaper gets the tag, so the font's language forms apply (OpenType `locl`: Turkish keeps `fi` apart and the dot on its i, #4940); new type takes the document's language; saved as the tag only when set, carried by character styles (#4946). English and eleven Indian languages hyphenate by run language; Sanskrit automatic hyphenation awaits allowlisted patterns (#4947). Not yet: spelling by it, `.ai`/PDF import of a text's language, paragraph styles. Evidence: `features::tests::language_picks_the_fonts_forms`, `features::tests::serbian_gets_the_fonts_serbian_forms`, `typecmd::area_tests::language_is_a_character_attribute_saved_only_when_set`, `tests::typo::indic_language_runs_hyphenate_with_both_composers`, `hyphen::tests::sanskrit_without_allowlisted_patterns_uses_only_exceptions` |
+| Language per character (Character panel › Language, character styles), text shaped in it | done | `text.setFormat` / `text.setRangeStyle {language}` by name or BCP 47 tag, one of Document Setup's languages (Hindi, Marathi, Gujarati, Bengali, Punjabi, Tamil, Telugu, Kannada, Malayalam, Odia and Urdu added, #4943; Serbian: Cyrillic, Serbian: Latin and Croatian; Bulgarian, #5945); the shaper gets the tag, so the font's language forms apply (OpenType `locl`: Turkish keeps `fi` apart and the dot on its i, #4940); new type takes the document's language; saved as the tag only when set, carried by character styles (#4946). Not yet: hyphenation and spelling by it, `.ai`/PDF import of a text's language, paragraph styles. Evidence: `features::tests::language_picks_the_fonts_forms`, `features::tests::serbian_gets_the_fonts_serbian_forms`, `typecmd::area_tests::language_is_a_character_attribute_saved_only_when_set` |
 | No Break | done | Character panel menu (`text.setFormat` / `text.setRangeStyle {noBreak}`): the marked characters stay on one line, including across a space; a run that does not fit after earlier text moves together, and a run longer than the line stays together. Evidence: `layout::wrapping_tests::no_break_keeps_marked_characters_on_one_line`, `tests::no_break_keeps_marked_words_on_one_line`, `typecmd::no_break_is_a_character_attribute_saved_only_when_on` |
 | Inline symbols in text | beyond Illustrator | not scored |
 | Align Stroke (inside, outside) on live type's character stroke | beyond Illustrator | not scored; `stroke.set {align}` and `text.setRangeStyle {strokeOptions: {align}}`; saved natively, drawn around the glyphs on the canvas and in PDF, EPS and SVG (live text, stroke on the glyph outlines); visual bounds grow with it (#2294) |
@@ -77,6 +79,9 @@ Character Styles menu New/Redefine and footer New capture the first selected cha
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-07 | minor | Indian-language hyphenation (#4947): eleven MIT-licensed pattern sets, with grapheme and shaping-cluster protection in both composers and existing paragraph limits. Assamese and Sanskrit are selectable; Sanskrit automatic patterns remain pending an allowlisted source. Scores and estimates unchanged. |
+| 2026-11-06 | minor | Alt + numeric-keypad codes (`Alt+0176` → °) type their character at the caret on Windows, and `type.insert` inserts a character by `code` or `unicode` (#5108); scores and estimates unchanged |
+| 2026-11-06 | minor | Snap to Glyph › Glyph Bounds: each glyph's box gives four corners a drawn point lands on, also on a curved side (`B`), and its box and edges turn with rotated type (#5112); scores and estimates unchanged |
 | 2026-11-05 | minor | Character panel › Show Snap to Glyph Options scrolls the panel down to the Snap to Glyph section, which comes after every character attribute and could sit out of sight, and the section starts with a Snap to Glyph checkbox (View › Snap to Glyph) so its dimmed options can be turned on there (#5273); scores and estimates unchanged |
 | 2026-11-05 | minor | Release Type on a Path joins the Type Tools add-on: type on a path splits into point type and its path (#5532, beyond Illustrator). Scores and estimates unchanged. |
 | 2026-11-04 | minor | A Type-range Copy or Cut publishes styled art alongside plain text, so a later canvas Paste keeps its character formatting after editing ends (#5636). Scores and estimates unchanged. |
@@ -90,6 +95,7 @@ Character Styles menu New/Redefine and footer New capture the first selected cha
 | 2026-11-01 | minor | The Type and Vertical Type tools make area type in a clicked closed path and type on a path along a clicked open one, with their own pointers; each type tool has its own icon; scores unchanged (estimated) |
 | 2026-10-31 | minor | Units › East Asian Type acts (#394): Q and Ha (a quarter of a millimetre each) are units that preference offers; scores unchanged |
 | 2026-11-01 | minor | Glyphs panel (#4908): the character selected with the Type tool (a range's first, else the one before the caret) is highlighted in the grid and scrolled into view when the selection moves to another character; Show › Alternates for Current Selection not yet; scores unchanged |
+| 2026-11-06 | minor | Bulgarian (`bg`) in the language list, with CLDR's „…“ at either quote level; Bulgarian text gets the fonts' Bulgarian forms (`locl` for `BGR`: in Source Sans 3 Italic в, д, ж, з, к, л, ю) (#5945); scores unchanged |
 | 2026-11-01 | minor | Serbian: Cyrillic (`sr-Cyrl`), Serbian: Latin (`sr-Latn`) and Croatian (`hr`) in the language list, with their quote marks (Serbian „…” and ’…’ per the Pravopis srpskoga jezika, Matica srpska 2010, ISBN 978-86-7946-079-0, т. 168, and [CLDR `sr`](https://github.com/unicode-org/cldr/blob/main/common/main/sr.xml); Croatian „…“ and ‚…‘ per [CLDR `hr`](https://github.com/unicode-org/cldr/blob/main/common/main/hr.xml)); Serbian text gets the fonts' Serbian forms (italic б, г, д, п, т); scores unchanged |
 | 2026-11-01 | minor | Area Type Options › Text Flow (#4978): By Rows / By Columns radio buttons and `text.areaOptions {flow}`; area type with several rows and columns fills them across each row first or down each column first (the default, so existing documents are unchanged; saved only when by rows); scores unchanged |
 | 2026-11-01 | minor | Digits (#4942): the native digits of Devanagari, Bengali, Gurmukhi, Gujarati, Odia, Tamil, Telugu, Kannada and Malayalam in the Character panel menu › Digits and `{digits}`; scores unchanged |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 5e65fc58f..4efbee4aa 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,9 +1,10 @@
 # UI and interaction parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-06 · **Change:** minor (Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Layers: Rename (`ui.rename`) opens the name field of the selected layer, group or object, #5324; Properties in Edit Artboards: Transform section above the Artboards section, #5219; scrubby labels: the Control bar's Stroke: and Opacity: links and the Properties panel's Stroke link scrub their fields, #4088; Properties: Quick Actions has Repeat Options for one selected repeat, #5181; Direct Selection: Shift-click picks several blend spine points, which drag together, #5285; Direct Selection: Cmd/Ctrl held lends the Selection tool and shows its bounding box, #3901; Join tool trims two crossing open paths and joins them at the crossing, #5844; Control bar: Paragraph: link and Align left/center/right while type is selected, #5372; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; Units › East Asian Type acts, with Q and Ha units; scores unchanged)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-06 · **Change:** minor (Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Layers: Rename (`ui.rename`) opens the name field of the selected layer, group or object, #5324; Properties in Edit Artboards: Transform section above the Artboards section, #5219; scrubby labels: the Control bar's Stroke: and Opacity: links and the Properties panel's Stroke link scrub their fields, #4088; Properties: Quick Actions has Repeat Options for one selected repeat, #5181; Direct Selection: Shift-click picks several blend spine points, which drag together, #5285; Direct Selection: Cmd/Ctrl held lends the Selection tool and shows its bounding box, #3901; Join tool trims two crossing open paths and joins them at the crossing, #5844; Control bar: Paragraph: link and Align left/center/right while type is selected, #5372; shape tools: a press on the selection's centre point moves it and one in the rotate zone outside a box corner turns it, #5477; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; Units › East Asian Type acts, with Q and Ha units; scores unchanged)
 
 ## Feature submission evidence
 
+| 2026-11-06 | minor | Opening a file that takes longer than 0.4 s shows a progress window: the file name, a moving bar (reading reports no steps), how many more files wait, Cancel (Esc; the file doesn't open) and Continue in Background (`file.cancelOpen`, `file.openInBackground`); it never opens over another dialog or progress window (part of #5930); scores and estimates unchanged |
 Raster rendering fits and preflattens curved stroke outlines more tightly only below four times the raster tolerance, retaining thin-band coverage without changing stroke weight or vector export geometry. Current cached character/object outlines, cropped long strokes, gradient clips and effect rasters share the helper; cropped-region reuse and guarded flattening remain. The unchanged `fractional_curved_strokes_retain_coverage_between_notches` regression covers fractional weights, rotation, phase, opacity and f32-rounded endpoints. This is a quality/cost tradeoff, not a speed claim. Scores and estimates unchanged.
 
 **PR #3273 revision — 2026-11-04:** Thin curved stroke coverage ported to the current raster-only cache, cropped-long-stroke and effect paths with guarded flattening; vector export geometry unchanged. Scores and estimates unchanged.
@@ -38,9 +39,14 @@ Artboard Options forwards the active Artboard tool's Scale Artwork with Artboard
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-30 | minor | Home screen: welcome, New / Open and Community are centred and the large Discord button uses the theme accent, part of #4684; scores and estimates unchanged (estimated) |
+| 2026-11-06 | minor | Snap to Grid: a straight segment dragged with Direct Selection lands its anchors on the grid, not the pressed point (#3835); scores and estimates unchanged |
+| 2026-11-06 | minor | Drop Shadow: a swatch beside Color follows the hex and a double-click opens the Color Picker over the dialog, whose OK fills Color (#5364); scores and estimates unchanged |
 | 2026-11-06 | minor | Drop Shadow, Outer Glow and Inner Glow: spinner arrows beside Opacity, the offsets, Blur and Darkness (#5367, #5368); scores and estimates unchanged |
 | 2026-11-06 | minor | Rename (`ui.rename`, no default key) opens the Layers panel's name field on the selected layer, group or object's row, as double-clicking its name does; a key can be assigned in Keyboard Shortcuts (#5324, a VectorCraft addition); scores and estimates unchanged |
 | 2026-11-06 | minor | Properties panel in Edit Artboards (Shift+O): a Transform section with the shared reference point, X, Y, W and H, the preset and orientation, and Move and Scale Artwork with Artboard, above the Artboards section with the name, Artboard Options and Fill (#5219); scores and estimates unchanged |
+| 2026-11-06 | minor | Shape tools: a press on the selection's centre point (Show Center) moves the selection, also where no art is painted, and a press in the rotate zone just outside a bounding-box corner turns it about the centre, both as the Selection tool's do (#5477); the Selection tool takes its centre point too, so an unfilled shape moves instead of starting a marquee; scores and estimates unchanged |
+| 2026-11-06 | minor | Transform fields: one Tab moves from one numeric field to the next in the Transform panel, the Properties panel's Transform section and the Control bar — a field's scrub label was a second, invisible tab stop, and the W/H link between W and H is now made after the fields, so it stays a tab stop after them; scores and estimates unchanged |
 | 2026-11-06 | minor | Scrubby labels: the Control bar's Stroke: and Opacity: and the Properties panel's Stroke, links to their panels, scrub the field after them as other labels do; a click still opens the panel (#4088); scores and estimates unchanged |
 | 2026-11-05 | minor | Direct Selection: Shift-click picks several points of a blend's spine and dragging one moves them all, with the key objects on them, in one undo step (#5285); scores and estimates unchanged |
 | 2026-11-05 | minor | Direct Selection: Cmd/Ctrl held lends the Selection tool, whose bounding box shows while the key is down over objects selected whole; its handles scale and rotate, and a Cmd drag moves the whole object with its direct-selected anchors kept (#3901); scores and estimates unchanged |
@@ -145,7 +151,7 @@ tools, never checked side by side) isn't captured row by row.
 | Pencil: Fidelity, Keep selected, Alt to Smooth, edit selected paths, close by proximity | done | Fidelity goes down to 0.01 pt in the dialog, the tool and `path.freehand` (the Smooth tool keeps 0.05); its slider runs across the Tool Options row on a logarithmic rail from 0.01 to 20 pt, the field shows hundredths, and the slider's and the field's arrow keys step hundredths up to 0.1 pt, tenths up to 1 pt and whole points above (Shift ×10) (#3328); Alt key toggles to Smooth Tool (#2001); Shift held at the press draws a straight line at 45° steps from the Constrain Angle, and Alt held at the press (with Alt key toggles to Smooth Tool off) a straight line at any angle (#3799), with a straight-line cursor while Shift or Alt is held before the press, and a path-continuation cursor over an end of a selected open path, where the line continues the path; Edit Selected Paths continues a selected path from an end and, from a stroke that starts and ends on a selected path, redraws the section between (the shorter way round a closed path, #2850); with Keep selected (Pencil and Paintbrush, on by default) on, a stroke selects the path it draws or continues and replaces the earlier selection, and off a new stroke leaves nothing selected, the earlier selection included, while a continued or redrawn path is deselected and the rest of the selection stays; a filled Pencil path keeps a stroke of None (#1804, part of #1679); while a freehand stroke is drawn back to within Close Paths When Ends Are Within of its start, the Pencil and the Paintbrush show the closing cursor, and a release there closes the path |
 | Pencil: Fidelity, Keep selected, Alt to Smooth, edit selected paths, close by proximity | done | Alt key toggles to Smooth Tool (#2001); Shift held at the press draws a straight line at 45° steps from the Constrain Angle, and Alt held at the press (with Alt key toggles to Smooth Tool off) a straight line at any angle (#3799), with a straight-line cursor while Shift or Alt is held before the press, and a path-continuation cursor over an end of a selected open path, where the line continues the path; Edit Selected Paths continues a selected path from an end and, from a stroke that starts and ends on a selected path, redraws the section between (the shorter way round a closed path, #2850); with Keep selected (Pencil and Paintbrush, on by default) on, a stroke selects the path it draws or continues and replaces the earlier selection, and off a new stroke leaves nothing selected, the earlier selection included, while a continued or redrawn path is deselected and the rest of the selection stays; a filled Pencil path keeps a stroke of None (#1804, part of #1679); while a freehand stroke is drawn back to within Close Paths When Ends Are Within of its start, the Pencil and the Paintbrush show the closing cursor, and a release there closes the path; a Pencil stroke from an end of one selected open path to an end of another connects the two into one path |
 | Drop Shadow, Outer Glow and Inner Glow: Opacity, the offsets, Blur and Darkness have spinner arrows that step by one (a unit for distances), repeat when held and stop at the fields' ends (#5367, #5368) | done | dialogs::effect test drop_shadow_and_outer_glow_fields_have_spinner_arrows; other effect dialogs' number fields still have none |
-| Effect dialogs' colour fields: a swatch beside the hex follows typed values, and a double-click opens the Color Picker over the dialog, whose OK fills it and Cancel comes back unchanged (#5365) | done | dialogs::effect test outer_glow_colour_swatch_opens_the_color_picker; the picker previews nothing itself, the effect dialog previews the returned colour |
+| Effect dialogs' colour fields: a swatch beside the hex follows typed values, and a double-click opens the Color Picker over the dialog, whose OK fills it and Cancel comes back unchanged (#5365) | done | dialogs::effect tests outer_glow_colour_swatch_opens_the_color_picker and drop_shadow_colour_swatch_opens_the_color_picker (Drop Shadow's Color, #5364); the picker previews nothing itself, the effect dialog previews the returned colour |
 | Join tool scrubbing, Average, Join | done | Join merges the direct-selected anchors lying on one another along a path, as after Average, into one (#1533); the Join tool trims two crossing open paths whose overhanging ends it scrubs over and joins them at the crossing, instead of drawing a segment between their ends (#5844) |
 | Average and Join in one step, with a corner or smooth choice for the joined anchor | done | Object › Path › Average & Join… (`path.averageJoin`, Cmd+Alt+Shift+J, "Create corner or smooth join" in [Default keyboard shortcuts](https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html)): two open path ends meet at their midpoint and join, a corner or smooth point as the dialog's Points choice asks (Corner first, then the last choice), in one undo step |
 | Smooth tool smooths only the stretch of path under the drag | done | #1512 |
@@ -187,7 +193,7 @@ tools, never checked side by side) isn't captured row by row.
 | Live Corners widgets (radius readout, Alt-click cycles kind, double-click the Corners dialog) | done | a Direct Selection click on a widget selects its corner (#1239); a press-and-drag on a widget of a path selected whole still rounds every corner (#908), and adding widgets to the selection by Shift-click (#1232) is missing; the bounding box hides while a widget is dragged with the Selection tool (#1229); a round corner next to a curved side curves smoothly instead of sticking out of the shape (#1512); a corner rounds until its cut reaches its neighbours' cuts, so one corner of a square alone reaches the whole side (#2332) |
 | Corners between curved sides (#1144), Relative rounding | done | #1144 closed; Relative rounding in the Corners dialog (Relative / Absolute, radius as a percentage of each corner's maximum, kept as the shape is resized; `object.setLiveShape` `relativeRadii`, #3091, `tests_livecorners::relative_corner_rounding_keeps_fraction_on_resize`) |
 | Pie widgets on a live ellipse: drag one to set Pie Start or End Angle, double-click one to make the ellipse whole | done | Selection tool, with the bounding box showing |
-| A shape just drawn shows its bounding box and Live Shape widgets with the shape tool still active | done | #5477: Rectangle, Rounded Rectangle, Ellipse, Polygon and Star keep the selection's bounding box, corner widgets and pie widgets on show while they draw nothing; a drag on a corner or pie widget adjusts it (arrows step the corner kind, Escape cancels) and a press anywhere else draws. Public descriptions: [Live Shapes](https://helpx.adobe.com/illustrator/using/live-shapes.html) (live shapes adjust without switching tools) and [CreativePro, Working with Live Shapes](https://creativepro.com/?p=23921) (a widget shows in every corner on release; drag one toward the centre to round). The bounding-box handles show but scale only with the Selection tool, so a press on a corner still starts a new shape there; double-clicking a widget opens nothing with a shape tool. Test `a_shape_tool_drags_the_selected_shapes_widgets` |
+| A shape just drawn shows its bounding box and Live Shape widgets with the shape tool still active, and the selection can be moved and turned without switching tools | done | #5477: Rectangle, Rounded Rectangle, Ellipse, Polygon and Star keep the selection's bounding box, corner widgets and pie widgets on show while they draw nothing; a drag on a corner or pie widget adjusts it (arrows step the corner kind, Escape cancels), a press on the selection's centre point (Attributes › Show Center) moves the selection — the Selection tool's move arrow, snapping and Alt copy — a press just outside a corner of the box turns it about the centre (the Selection tool's rotate zone and cursor), and a press anywhere else draws (so a second shape drawn from the first one's centre moves the first: press elsewhere or deselect first). Public descriptions: [Live Shapes](https://helpx.adobe.com/illustrator/using/live-shapes.html) (live shapes adjust without switching tools) and [CreativePro, Working with Live Shapes](https://creativepro.com/?p=23921) (a widget shows in every corner on release; drag one toward the centre to round). The bounding-box handles show but scale only with the Selection tool, so a press on a corner still starts a new shape there; double-clicking a widget opens nothing with a shape tool. Tests `a_shape_tool_drags_the_selected_shapes_widgets` and `a_shape_tool_moves_the_selection_by_its_centre_point_and_turns_it_from_a_corner` |
 | Isolation mode by double-click (groups and single objects), breadcrumbs, Esc to exit | done | Single paths, compound paths, images, meshes and placed files isolate too ([helpx: Isolate objects](https://helpx.adobe.com/africa/illustrator/desktop/manage-objects/select-objects/isolate-objects.html)); locking or hiding the layer (or a group) around the isolated object afterwards keeps clicks and marquees off it, as outside isolation mode (#5309) |
 | "Magnetic" moves of selected anchors with a modifier (#955 request) | missing | not a feature of the reference app as documented; under discussion |
 | Coinciding anchors of overlapping objects: the selected object's anchor is taken, also under another object | done | #1508 |
@@ -205,7 +211,7 @@ tools, never checked side by side) isn't captured row by row.
 | Spacing guides (equal distances) | partial | for moves and bounding-box resizes (#394); not while drawing |
 | Distance Guides: Alt/Option over another object, or an empty part of an artboard, shows the selection's distances to it (Smart Guides › Invoke Distance Guides) | done | Selection tool hover with Smart Guides on: the gap between facing edges, else the offsets of matching edges, to another object; the left, right, top and bottom distances to the artboard; labelled in the General unit. The selection is measured as a whole. Nothing while moving or nudging, which the public pages don't describe. [Use Distance Guides](https://helpx.adobe.com/illustrator/desktop/measure-and-align/grids-and-guides/use-distance-guides-for-accurate-placement.html), [Smart Guides options](https://helpx.adobe.com/illustrator/desktop/measure-and-align/grids-and-guides/smart-guides-options.html) |
 | Snapping tolerance preference | done | |
-| Snap to Point, Snap to Grid, Snap to Pixel; Pixel Preview | done | #1840: with Snap to Grid on, anchors and objects snap to the grid even when Snap to Pixel is also ticked (#1816 waits for the reporter) |
+| Snap to Point, Snap to Grid, Snap to Pixel; Pixel Preview | done | #1840: with Snap to Grid on, anchors and objects snap to the grid even when Snap to Pixel is also ticked (#1816 waits for the reporter); #3835: a straight segment dragged with Direct Selection lands its anchors on the grid, the box round them putting an edge on a gridline on each axis, as a moved object does |
 | Snap to Glyph | done | View › Snap to Glyph (`view.snapToGlyph`); new type and drawing snap to live-text baselines and glyph bounds when Smart Guides are on (#3124). Character panel menu › Show Snap to Glyph Options: a Snap to Glyph checkbox (View › Snap to Glyph), then a checkbox for each guide (Baseline, x-height, Glyph Bounds, Proximity Guides, Angular Guides, Anchor Point), dimmed while Snap to Glyph is off (#4232); showing them scrolls the panel to them (#5273) |
 | Tangent and perpendicular snapping for line endpoints (new in 30.0) | done | #2530: tangent snapping to curves and perpendicular snapping to straight segments for lines drawn with the Line Segment, Pen and Curvature tools, and for an existing line whose end anchor is dragged with Direct Selection (the only anchor selected, an open path's end on a straight segment; Shift keeps its angle step instead; Group Selection moves the path whole and does not snap so); mid-line anchors, curved segments' ends and curves as perpendicular targets are excluded, as the pages say. Saved Preferences › Smart Guides › Geometric Guides controls, on by default. [Perpendicular](https://helpx.adobe.com/illustrator/desktop/measure-and-align/plot-and-measure/snap-to-perpendicular.html) and [tangent](https://helpx.adobe.com/illustrator/desktop/measure-and-align/plot-and-measure/snap-to-tangent.html) pages; test `dragged_line_ends_snap_perpendicular_to_segments_and_tangent_to_curves` |
 | Snapping panel/popover consolidating the snap options (30.0) | partial | Control bar › Snapping provides quick access through existing view commands and prefs.set; no View › Snapping submenu. Floating-panel parity remains unverified. |
@@ -395,6 +401,7 @@ next unit in the order a right-click on a ruler lists them, from Feet back to Po
 | Gradient panel: delete a stop | done | Delete Stop at the right end of the ramp deletes the selected stop, and a stop dragged down off the ramp is deleted on release, never below two stops, one undo step each; [Gradient panel options](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/create-and-edit-gradients/gradient-tool-and-panel.html); `panels::gradient` test |
 | SVG Interactivity, Retype, Comments, Version History panels | missing | the last two are cloud features (out of scope) |
 | Workspaces (save, reset, switch); each remembers the layout changes made in it across switches and restarts until Reset <name> | done | `UiState::workspace_changes` |
+| Opening a file: after 0.4 s a progress window with the file name, a moving bar (reading counts no steps), how many more files wait, Cancel (Esc: the file doesn't open) and Continue in Background; never over another dialog or progress window | done | #5930; `opening::show`, `file.cancelOpen`, `file.openInBackground`. Save, Place and Close still show only the status bar's spinner (Place and Save run off the UI thread; Close is immediate) |
 | Background Export: a progress dialog with the file name, the artboard count and a bar (busy for one artboard and for formats made in one go), Cancel (Esc) and Continue in Background; it opens after 0.4 s and never over another dialog. A cancelled export writes no file | done | #2564; on the shared `vectorcraft_doc::cancel` token (#2546), so a cancelled render keeps no half-drawn pattern tile or effect raster. The bar moves between artboards, not within one. Save As, Export for Screens and Export Selection don't show it yet |
 | Swatch, graphic style and symbol library panels: each library opens in a panel of its own, several at once, that floats, groups, docks and closes like any panel; opening an open library brings its panel forward; Previous / Next Library change the library in place; the panel menu's Persistent reopens the panel at startup with its view and find field (a library loaded from a file is read again; when its file is missing the panel reopens showing the file's path with Locate Library…, and the status bar names the file) | done | #2603; panel ids `library:<kind>:<id>`, `ui.libraryPanel {panel, library?, view?, showFind?, persistent?}`, `ui.libraryPanel.locate {panel, path?}`; the library panels have no sort option, as before |
 | DXF export/import preserves intended curve closure | done | #1299; R13–2018 closed SPLINE bit set/read; an open curve ending at its start stays open; knots and control points unchanged; native CIRCLE/ARC export and CNC preset remain pending |
@@ -430,6 +437,8 @@ next unit in the order a right-click on a ruler lists them, from Feet back to Po
 
 ## Look and feel
 
+- [x] Home screen (part of #4684, shared UI with PhotoCraft): the welcome, New / Open buttons and Community block are centred, and the large Discord button takes the theme's accent instead of Discord's colour; the layout and wording of the preset cards and Recent Files are unchanged. Still open from #4684: shortcut hints on the buttons, PhotoCraft's PRO and STUDIO themes, the Preferences layout (search box, theme swatches, Apply) and the title bar.
+
 - [x] Recolor Artwork › Assign: double-click a row's new color to pick it in the Color Picker, in the model it was picked in (part of #4028); a Lab new color is kept but can't be typed yet (the picker's Lab fields work in RGB); Lab entry, swatch libraries and the row menu remain.
 
 - [x] Recolor Artwork Edit color chips scroll within the screen, preserving the wheel and actions (#3416); 5, 20, 200 and 400 colors, resizing and UI scaling, final-chip editing and preview/history covered by egui_kittest.