From 47f1315ec2824f16c3449e23002f5b029eca4f3d Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:02:49 +0000
Subject: [PATCH 01/67] test: scan source directories recursively

---
 crates/ui-egui/src/i18n_tests.rs | 32 +++++++++++++++++++++++++-------
 1 file changed, 25 insertions(+), 7 deletions(-)

diff --git a/crates/ui-egui/src/i18n_tests.rs b/crates/ui-egui/src/i18n_tests.rs
index 5b4da85e..d1fedef8 100644
--- a/crates/ui-egui/src/i18n_tests.rs
+++ b/crates/ui-egui/src/i18n_tests.rs
@@ -157,10 +157,9 @@ fn menu_worded_differently() -> BTreeSet<&'static str> {
 fn used_keys() -> BTreeSet<String> {
     let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
     let mut keys = BTreeSet::new();
-    for entry in std::fs::read_dir(dir).unwrap().flatten() {
-        let path = entry.path();
+    for path in sources(&dir) {
         let name = path.file_name().unwrap().to_string_lossy().into_owned();
-        if !name.ends_with(".rs") || name.ends_with("_tests.rs") || name == "i18n.rs" {
+        if name.ends_with("_tests.rs") || name == "i18n.rs" {
             continue;
         }
         keys.extend(literals(&std::fs::read_to_string(&path).unwrap(), LOOKUPS));
@@ -168,6 +167,24 @@ fn used_keys() -> BTreeSet<String> {
     keys
 }
 
+/// Every `.rs` file under `dir`, in subdirectories too, leaving out test code: `tests.rs` and
+/// anything under a `tests` directory.
+fn sources(dir: &std::path::Path) -> Vec<std::path::PathBuf> {
+    let mut out = Vec::new();
+    for entry in std::fs::read_dir(dir).unwrap().flatten() {
+        let path = entry.path();
+        let name = path.file_name().unwrap().to_string_lossy().into_owned();
+        if path.is_dir() {
+            if name != "tests" {
+                out.extend(sources(&path));
+            }
+        } else if name.ends_with(".rs") && name != "tests.rs" {
+            out.push(path);
+        }
+    }
+    out
+}
+
 /// The importers' fixed notes: the string literals passed to `warn` in the `.fig` and REST import
 /// sources. The import report shows a note translated when the catalog has it, so each one is a key
 /// `en.toml` (and every complete language) must have, and an entry for a note the importers no
@@ -176,11 +193,12 @@ fn importer_notes() -> BTreeSet<String> {
     let src = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../format/src");
     let mut keys = BTreeSet::new();
     for dir in ["fig", "rest"] {
-        for entry in std::fs::read_dir(src.join(dir)).unwrap().flatten() {
-            let path = entry.path();
+        // The module root sits beside its directory (`fig.rs` + `fig/`) or inside it (`fig/mod.rs`).
+        let root = src.join(format!("{dir}.rs"));
+        for path in sources(&src.join(dir)).into_iter().chain(root.exists().then_some(root)) {
             let name = path.file_name().unwrap().to_string_lossy().into_owned();
-            // export.rs warns about what a `.fig` export leaves out, not about an import.
-            if !name.ends_with(".rs") || name.contains("tests") || name == "export.rs" {
+            // export.rs and export/ warn about what a `.fig` export leaves out, not about an import.
+            if name.contains("tests") || name == "export.rs" || path.starts_with(src.join("fig/export")) {
                 continue;
             }
             keys.extend(literals(&std::fs::read_to_string(&path).unwrap(), &["warn("]));

From d853eee82039b9f21edd0867f8b3b25eae4ad16d Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:08 +0000
Subject: [PATCH 02/67] refactor(engine): move crates/engine/src/cmd/mod.rs to
 crates/engine/src/cmd.rs

---
 crates/engine/src/{cmd/mod.rs => cmd.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename crates/engine/src/{cmd/mod.rs => cmd.rs} (100%)

diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd.rs
similarity index 100%
rename from crates/engine/src/cmd/mod.rs
rename to crates/engine/src/cmd.rs

From 71524803d11d24dc81358558685de8cc2dffb771 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:08 +0000
Subject: [PATCH 03/67] refactor(engine): move
 crates/engine/src/templates/mod.rs to crates/engine/src/templates.rs

---
 crates/engine/src/{templates/mod.rs => templates.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename crates/engine/src/{templates/mod.rs => templates.rs} (100%)

diff --git a/crates/engine/src/templates/mod.rs b/crates/engine/src/templates.rs
similarity index 100%
rename from crates/engine/src/templates/mod.rs
rename to crates/engine/src/templates.rs

From a99248b2965556ba178b831643342c74391704d2 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:08 +0000
Subject: [PATCH 04/67] refactor(svg): move crates/svg/src/import/mod.rs to
 crates/svg/src/import.rs

---
 crates/svg/src/{import/mod.rs => import.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename crates/svg/src/{import/mod.rs => import.rs} (100%)

diff --git a/crates/svg/src/import/mod.rs b/crates/svg/src/import.rs
similarity index 100%
rename from crates/svg/src/import/mod.rs
rename to crates/svg/src/import.rs

From 47ee566f3d61156c86b13ba5c7df2694a220d03a Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:09 +0000
Subject: [PATCH 05/67] refactor(format): move crates/format/src/fig/mod.rs to
 crates/format/src/fig.rs

---
 crates/format/src/{fig/mod.rs => fig.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename crates/format/src/{fig/mod.rs => fig.rs} (100%)

diff --git a/crates/format/src/fig/mod.rs b/crates/format/src/fig.rs
similarity index 100%
rename from crates/format/src/fig/mod.rs
rename to crates/format/src/fig.rs

From 8d4a4497699533d815c88050fef72e7bcab0c0e1 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:09 +0000
Subject: [PATCH 06/67] refactor(format): move crates/format/src/rest/mod.rs to
 crates/format/src/rest.rs

---
 crates/format/src/{rest/mod.rs => rest.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename crates/format/src/{rest/mod.rs => rest.rs} (100%)

diff --git a/crates/format/src/rest/mod.rs b/crates/format/src/rest.rs
similarity index 100%
rename from crates/format/src/rest/mod.rs
rename to crates/format/src/rest.rs

From e9fb6a533e6be86a2f356f96f3cd3f705901e5db Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:09 +0000
Subject: [PATCH 07/67] refactor(format): move crates/format/src/sketch/mod.rs
 to crates/format/src/sketch.rs

---
 crates/format/src/{sketch/mod.rs => sketch.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename crates/format/src/{sketch/mod.rs => sketch.rs} (100%)

diff --git a/crates/format/src/sketch/mod.rs b/crates/format/src/sketch.rs
similarity index 100%
rename from crates/format/src/sketch/mod.rs
rename to crates/format/src/sketch.rs

From a3179236f33895a3c11495678fcde124360f3eb5 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:14 +0000
Subject: [PATCH 08/67] refactor(engine): move textedit.rs inline tests to
 crates/engine/src/textedit/tests.rs

---
 crates/engine/src/textedit.rs       | 574 +---------------------------
 crates/engine/src/textedit/tests.rs | 571 +++++++++++++++++++++++++++
 2 files changed, 572 insertions(+), 573 deletions(-)
 create mode 100644 crates/engine/src/textedit/tests.rs

diff --git a/crates/engine/src/textedit.rs b/crates/engine/src/textedit.rs
index 2cd9bf97..91e411e5 100644
--- a/crates/engine/src/textedit.rs
+++ b/crates/engine/src/textedit.rs
@@ -796,576 +796,4 @@ pub fn selected_range(s: &Session) -> Option<(NodeId, usize, usize)> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::tools::{PointerEvent, PointerKind};
-    use figcraft_doc::{ListStyle, TextAutoResize, TextCase, TextDecoration};
-    use serde_json::json;
-
-    fn setup(text: &str) -> (Session, NodeId) {
-        let mut s = Session::new();
-        let r = s.execute("text.create", &json!({"text": text, "x": 0, "y": 0, "props": {"fontSize": 24}})).unwrap();
-        let id = crate::params::id_of(&r["id"]).unwrap();
-        (s, id)
-    }
-
-    fn data(s: &Session, id: NodeId) -> TextData {
-        s.doc().unwrap().node(id).unwrap().kind.text().unwrap().clone()
-    }
-
-    fn sel(s: &Session) -> (usize, usize) {
-        let te = s.ds().unwrap().text_edit.clone().unwrap();
-        (te.anchor, te.caret)
-    }
-
-    #[test]
-    fn whole_editing_session_is_one_undo_step() {
-        let (mut s, id) = setup("Hello");
-        let undo_before = s.ds().unwrap().history.undo.len();
-        begin(&mut s, id, Some(5), false).unwrap();
-        insert(&mut s, " big").unwrap();
-        insert(&mut s, " world").unwrap();
-        key(&mut s, "Backspace", false, false, false).unwrap();
-        // Styling a range mid-session joins the same step.
-        set_caret(&mut s, 0, false).unwrap();
-        set_caret(&mut s, 5, true).unwrap();
-        s.execute("text.bold", &json!({})).unwrap();
-        s.execute("text.alignCenter", &json!({})).unwrap();
-        end(&mut s).unwrap();
-        let t = data(&s, id);
-        assert_eq!(t.characters, "Hello big worl");
-        assert_eq!(t.style_at(0).font_style, "Bold");
-        assert_eq!(t.style_at(6).font_style, "Regular");
-        assert_eq!(s.ds().unwrap().history.undo.len(), undo_before + 1);
-        s.undo().unwrap();
-        let t = data(&s, id);
-        assert_eq!(t.characters, "Hello");
-        assert!(t.runs.is_empty());
-        assert_eq!(t.align_h, figcraft_doc::TextAlignH::Left);
-    }
-
-    #[test]
-    fn typing_replaces_selection_and_paste_is_plain() {
-        let (mut s, id) = setup("Hello world");
-        begin(&mut s, id, None, false).unwrap();
-        assert_eq!(sel(&s), (0, 11), "begin without caret selects all");
-        select_word(&mut s, 7).unwrap();
-        assert_eq!(sel(&s), (6, 11));
-        insert(&mut s, "there").unwrap();
-        assert_eq!(data(&s, id).characters, "Hello there");
-        assert_eq!(sel(&s), (11, 11));
-        // Pasted text: CRLF / CR / Unicode separators become newlines, other controls are dropped.
-        insert(&mut s, "\r\na\rb\u{2029}c\u{0}\u{7}\td").unwrap();
-        assert_eq!(data(&s, id).characters, "Hello there\na\nb\nc\td");
-        insert(&mut s, "\u{1}").unwrap();
-        assert_eq!(data(&s, id).characters, "Hello there\na\nb\nc\td");
-        // Select the line (paragraph) then type over it.
-        select_line(&mut s, 0).unwrap();
-        assert_eq!(sel(&s), (0, 11));
-        insert(&mut s, "Hi").unwrap();
-        assert_eq!(data(&s, id).characters, "Hi\na\nb\nc\td");
-        assert_eq!(selected_text(&s).as_deref(), Some(""));
-        end(&mut s).unwrap();
-    }
-
-    #[test]
-    fn word_selection_classes() {
-        let (mut s, id) = setup("foo,  bar_baz!\nnext");
-        begin(&mut s, id, Some(0), false).unwrap();
-        select_word(&mut s, 1).unwrap();
-        assert_eq!(sel(&s), (0, 3));
-        // Right after a word's last char selects the word.
-        select_word(&mut s, 13).unwrap();
-        assert_eq!(sel(&s), (6, 13));
-        // A run of spaces.
-        select_word(&mut s, 4).unwrap();
-        assert_eq!(sel(&s), (4, 6));
-        select_line(&mut s, 16).unwrap();
-        assert_eq!(sel(&s), (15, 19));
-        select_line(&mut s, 999).unwrap();
-        assert_eq!(sel(&s), (15, 19));
-        select_word(&mut s, 999).unwrap();
-        assert_eq!(sel(&s), (15, 19));
-        set_caret(&mut s, 999, false).unwrap();
-        assert_eq!(sel(&s), (19, 19), "carets clamp to the text");
-    }
-
-    #[test]
-    fn keyboard_navigation_and_extension() {
-        let (mut s, id) = setup("one two\nthree");
-        begin(&mut s, id, Some(0), false).unwrap();
-        key(&mut s, "Right", false, true, false).unwrap(); // Alt+Right: end of word
-        assert_eq!(sel(&s), (3, 3));
-        key(&mut s, "Right", true, true, false).unwrap(); // Shift+Alt+Right extends
-        assert_eq!(sel(&s), (3, 7));
-        key(&mut s, "Left", false, false, false).unwrap(); // collapses to the start
-        assert_eq!(sel(&s), (3, 3));
-        key(&mut s, "Right", false, false, true).unwrap(); // Cmd+Right: line end
-        assert_eq!(sel(&s), (7, 7));
-        key(&mut s, "Down", true, false, true).unwrap(); // Shift+Cmd+Down: to the end
-        assert_eq!(sel(&s), (7, 13));
-        key(&mut s, "Left", false, false, true).unwrap(); // Cmd+Left from the collapsed start
-        assert_eq!(sel(&s), (0, 0));
-        key(&mut s, "Delete", false, true, false).unwrap(); // Alt+Delete: word forward
-        assert_eq!(data(&s, id).characters, " two\nthree");
-        key(&mut s, "SelectAll", false, false, false).unwrap();
-        assert_eq!(sel(&s), (0, 10));
-        end(&mut s).unwrap();
-    }
-
-    #[test]
-    fn backspace_removes_only_the_final_thai_mark() {
-        let (mut s, id) = setup("น้ำ");
-        begin(&mut s, id, Some(3), false).unwrap();
-
-        key(&mut s, "Backspace", false, false, false).unwrap();
-
-        assert_eq!(data(&s, id).characters, "น้");
-    }
-
-    fn ev(kind: PointerKind, x: f64, y: f64, shift: bool) -> PointerEvent {
-        let mut e = PointerEvent::at(kind, x, y, 1.0);
-        e.shift = shift;
-        e
-    }
-
-    /// Asserts double-clicking a text layer selects all text, a second double-click selects the
-    /// word without changing the editing session, and drag and Shift+click extend the
-    /// selection.
-    #[test]
-    fn pointer_double_click_drag_and_shift_click() {
-        let (mut s, id) = setup("Hello world");
-        let Some((l, _)) = figcraft_text::layout_node(s.doc().unwrap().node(id).unwrap()) else { return };
-        if l.glyphs.is_empty() {
-            return; // no fonts
-        }
-        let y = l.lines[0].top + l.lines[0].height / 2.0;
-        let x_of = |i: usize| l.caret(i).0;
-        // Double-click inside "world" edits with all the text selected; another one there
-        // selects the word.
-        let mid = (x_of(7) + x_of(8)) / 2.0;
-        s.pointer(&ev(PointerKind::Down, mid, y, false)).unwrap();
-        s.pointer(&ev(PointerKind::Up, mid, y, false)).unwrap();
-        s.pointer(&ev(PointerKind::DoubleClick, mid, y, false)).unwrap();
-        assert_eq!(sel(&s), (0, 11));
-        let epoch = s.ds().unwrap().text_edit.as_ref().unwrap().editing_session;
-        s.pointer(&ev(PointerKind::Down, mid, y, false)).unwrap();
-        s.pointer(&ev(PointerKind::DoubleClick, mid, y, false)).unwrap();
-        s.pointer(&ev(PointerKind::Up, mid, y, false)).unwrap();
-        assert_eq!(sel(&s), (6, 11));
-        assert_eq!(
-            s.ds().unwrap().text_edit.as_ref().unwrap().editing_session,
-            epoch,
-            "a double-click inside the edit is an ordinary edit: same IME replacement epoch"
-        );
-        // Drag-select from the start of "Hello" to the middle.
-        s.pointer(&ev(PointerKind::Down, x_of(0) + 0.5, y, false)).unwrap();
-        assert_eq!(sel(&s), (0, 0));
-        s.pointer(&ev(PointerKind::Move, (x_of(3) + x_of(4)) / 2.0 - 1.0, y, false)).unwrap();
-        s.pointer(&ev(PointerKind::Up, (x_of(3) + x_of(4)) / 2.0 - 1.0, y, false)).unwrap();
-        assert_eq!(sel(&s), (0, 3));
-        // Shift+click extends.
-        s.pointer(&ev(PointerKind::Down, x_of(9) + 0.5, y, true)).unwrap();
-        s.pointer(&ev(PointerKind::Up, x_of(9) + 0.5, y, true)).unwrap();
-        assert_eq!(sel(&s), (0, 9));
-        insert(&mut s, "J").unwrap();
-        assert_eq!(data(&s, id).characters, "Jld");
-    }
-
-    #[test]
-    fn text_commands_apply_to_edited_range() {
-        let (mut s, id) = setup("Hello world");
-        begin(&mut s, id, Some(0), false).unwrap();
-        set_caret(&mut s, 6, true).unwrap(); // "Hello "
-        for (cmd, p) in [
-            ("text.underline", json!({})),
-            ("text.italic", json!({})),
-            ("text.sizeUp", json!({})),
-            ("text.trackingUp", json!({})),
-            ("text.lineHeightUp", json!({})),
-            ("text.caseSmallCaps", json!({})),
-            ("text.link", json!({"url": "https://example.com"})),
-        ] {
-            s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"));
-        }
-        let t = data(&s, id);
-        let (a, b) = (t.style_at(0), t.style_at(8));
-        assert_eq!(a.decoration, TextDecoration::Underline);
-        assert!(a.italic() && !b.italic());
-        assert_eq!(a.font_size, 25.0);
-        assert_eq!(b.font_size, 24.0);
-        assert_eq!(a.case, TextCase::SmallCaps);
-        assert_eq!(a.link.as_deref(), Some("https://example.com"));
-        assert!(b.link.is_none());
-        // text.style with an explicit range (what the panel sends).
-        s.execute("text.style", &json!({"id": id, "start": 6, "end": 11, "fontSize": 40, "textCase": "upper"})).unwrap();
-        let t = data(&s, id);
-        assert_eq!(t.style_at(8).font_size, 40.0);
-        assert_eq!(t.style_at(8).case, TextCase::Upper);
-        // Paragraph commands hit the edited node.
-        s.execute("text.listStyle", &json!({"style": "numbered"})).unwrap();
-        assert_eq!(data(&s, id).list, ListStyle::Numbered);
-        // Every Text-menu command runs while editing.
-        for item in crate::catalog::MENU.iter().filter(|i| i.id.starts_with("text.")) {
-            let p = if item.id == "text.link" { json!({"url": "u"}) } else { json!({}) };
-            if crate::find_command(item.id).is_some() {
-                s.execute(item.id, &p).unwrap_or_else(|e| panic!("{}: {e}", item.id));
-            }
-        }
-        end(&mut s).unwrap();
-    }
-
-    #[test]
-    fn paragraph_and_feature_commands_on_nodes() {
-        let (mut s, id) = setup("Hello");
-        let ids = json!([id]);
-        s.execute("text.setFeatures", &json!({"ids": ids, "features": {"liga": false, "tnum": true}})).unwrap();
-        assert_eq!(data(&s, id).features.get("liga"), Some(&false));
-        s.execute("text.setFeatures", &json!({"ids": ids, "features": {"liga": null, "ss01": 1}})).unwrap();
-        let f = data(&s, id).features;
-        assert_eq!(f.get("liga"), None);
-        assert_eq!(f.get("ss01"), Some(&true));
-        assert_eq!(f.get("tnum"), Some(&true));
-        s.execute("text.setFeatures", &json!({"ids": ids, "features": {"zero": true}, "replace": true})).unwrap();
-        assert_eq!(data(&s, id).features.len(), 1);
-        assert!(s.execute("text.setFeatures", &json!({"ids": ids, "features": {"ligatures": true}})).is_err());
-        assert!(s.execute("text.setFeatures", &json!({"ids": ids, "features": {"liga": "yes"}})).is_err());
-        assert!(s.execute("text.setFeatures", &json!({"ids": ids})).is_err());
-        s.execute("node.set", &json!({"id": id, "props": {"features": {"calt": false}}})).unwrap();
-        assert_eq!(data(&s, id).features.len(), 1);
-        s.execute("text.paragraphIndent", &json!({"ids": ids, "indent": 16})).unwrap();
-        s.execute("text.paragraphSpacing", &json!({"ids": ids, "spacing": 8})).unwrap();
-        s.execute("text.maxLines", &json!({"ids": ids, "lines": 2})).unwrap();
-        s.execute("text.decoration", &json!({"ids": ids, "decoration": "strikethrough"})).unwrap();
-        s.execute("text.case", &json!({"ids": ids, "case": "smallCaps"})).unwrap();
-        s.execute("text.listStyle", &json!({"ids": ids, "style": "bulleted"})).unwrap();
-        let t = data(&s, id);
-        assert_eq!((t.paragraph_indent, t.paragraph_spacing, t.max_lines), (16.0, 8.0, 2));
-        assert_eq!(t.auto_resize, TextAutoResize::Truncate);
-        assert_eq!(t.style.decoration, TextDecoration::Strikethrough);
-        assert_eq!(t.style.case, TextCase::SmallCaps);
-        assert_eq!(t.list, ListStyle::Bulleted);
-        assert!(s.execute("text.listStyle", &json!({"ids": ids, "style": "zigzag"})).is_err());
-        assert!(s.execute("text.paragraphIndent", &json!({"ids": ids, "indent": "NaN"})).is_err());
-        s.execute("node.set", &json!({"id": id, "props": {"textCase": "smallCaps", "paragraphIndent": 4, "maxLines": 0}})).unwrap();
-        assert_eq!(data(&s, id).paragraph_indent, 4.0);
-    }
-
-    fn preedit_state(s: &Session) -> Option<Preedit> {
-        s.ds().unwrap().text_edit.clone().unwrap().preedit
-    }
-
-    #[test]
-    fn ime_composition_is_shown_but_not_in_the_document_until_committed() {
-        let (mut s, id) = setup("Hello world");
-        let undo_before = s.ds().unwrap().history.undo.len();
-        begin(&mut s, id, Some(5), false).unwrap();
-        let doc_before = s.ds().unwrap().doc.clone();
-        s.execute("text.edit.preedit", &json!({"text": "にほ", "cursor": 1})).unwrap();
-        assert_eq!(preedit_state(&s), Some(Preedit { text: "にほ".into(), cursor: 1 }));
-        assert!(std::sync::Arc::ptr_eq(&doc_before, &s.ds().unwrap().doc), "composing leaves the document alone");
-        let (shown, range, cursor) = preedit_doc(&s).unwrap();
-        assert_eq!(shown.node(id).unwrap().kind.text().unwrap().characters, "Helloにほ world");
-        assert_eq!((range, cursor), ((5, 7), 6));
-        let info = s.execute("text.edit.selection", &json!({})).unwrap();
-        assert_eq!(info["preedit"]["text"], "にほ");
-        // Updating the composition replaces it; an empty one cancels it.
-        preedit(&mut s, "にほん", None).unwrap();
-        assert_eq!(preedit_doc(&s).unwrap().2, 8);
-        preedit(&mut s, "", None).unwrap();
-        assert!(preedit_state(&s).is_none() && preedit_doc(&s).is_none());
-        assert_eq!(data(&s, id).characters, "Hello world");
-        // Commit puts the final text at the caret.
-        preedit(&mut s, "にほん", None).unwrap();
-        s.execute("text.edit.insert", &json!({"text": "日本"})).unwrap();
-        assert!(preedit_state(&s).is_none());
-        assert_eq!(data(&s, id).characters, "Hello日本 world");
-        assert_eq!(sel(&s), (7, 7));
-        // Composing over a selection replaces it; moving the caret abandons the composition.
-        set_caret(&mut s, 7, false).unwrap();
-        set_caret(&mut s, 13, true).unwrap();
-        preedit(&mut s, "x", None).unwrap();
-        assert_eq!(data(&s, id).characters, "Hello日本");
-        set_caret(&mut s, 0, false).unwrap();
-        assert!(preedit_state(&s).is_none());
-        assert_eq!(data(&s, id).characters, "Hello日本");
-        // Ending the edit drops an uncommitted composition; the session stays one undo step.
-        preedit(&mut s, "zz", None).unwrap();
-        end(&mut s).unwrap();
-        assert_eq!(data(&s, id).characters, "Hello日本");
-        assert_eq!(s.ds().unwrap().history.undo.len(), undo_before + 1);
-        // Not editing: an error, not a crash.
-        assert!(preedit(&mut s, "a", None).is_err());
-    }
-
-    #[test]
-    fn variable_font_axes_as_commands_and_props() {
-        let (mut s, id) = setup("Hello world");
-        let ids = json!([id]);
-        s.execute("text.setVariations", &json!({"ids": ids, "variations": {"wght": 550, "wdth": 85}})).unwrap();
-        let st = data(&s, id).style;
-        assert_eq!((st.variations.get("wght"), st.variations.get("wdth")), (Some(&550.0), Some(&85.0)));
-        assert_eq!(st.weight(), 550);
-        // null removes one axis; replace clears the rest.
-        s.execute("text.setVariations", &json!({"ids": ids, "variations": {"wdth": null}})).unwrap();
-        assert_eq!(data(&s, id).style.variations.len(), 1);
-        s.execute("text.setVariations", &json!({"ids": ids, "variations": {"opsz": 14}, "replace": true})).unwrap();
-        assert_eq!(data(&s, id).style.variations.keys().collect::<Vec<_>>(), ["opsz"]);
-        // Undo restores the previous values.
-        s.undo().unwrap();
-        assert_eq!(data(&s, id).style.variations.keys().collect::<Vec<_>>(), ["wght"]);
-        // Junk is rejected.
-        assert!(s.execute("text.setVariations", &json!({"ids": ids, "variations": {"weight": 500}})).is_err());
-        assert!(s.execute("text.setVariations", &json!({"ids": ids, "variations": {"wght": "bold"}})).is_err());
-        assert!(s.execute("text.setVariations", &json!({"ids": ids})).is_err());
-        // node.set props (whole text or a range) replace the custom values.
-        s.execute("node.set", &json!({"id": id, "props": {"fontVariations": {"wght": 300}, "start": 6, "end": 11}})).unwrap();
-        let t = data(&s, id);
-        assert_eq!(t.style_at(0).variations.get("wght"), Some(&550.0));
-        assert_eq!(t.style_at(7).variations.get("wght"), Some(&300.0));
-        s.execute("node.set", &json!({"id": id, "props": {"variationSettings": null}})).unwrap();
-        assert!(data(&s, id).runs.is_empty() && data(&s, id).style.variations.is_empty());
-        // Picking a named style (Bold, weight steps) drops the custom weight but keeps width.
-        s.execute("text.setVariations", &json!({"ids": ids, "variations": {"wght": 650, "wdth": 90}})).unwrap();
-        s.execute("text.bold", &json!({"ids": ids})).unwrap();
-        let st = data(&s, id).style;
-        assert_eq!(st.font_style, "Bold", "650 is lighter than bold, so Bold applies");
-        assert!(!st.variations.contains_key("wght"));
-        assert_eq!(st.variations.get("wdth"), Some(&90.0));
-        // While editing, the command styles the selected range only.
-        begin(&mut s, id, Some(0), false).unwrap();
-        set_caret(&mut s, 5, true).unwrap();
-        s.execute("text.setVariations", &json!({"variations": {"wdth": 75}})).unwrap();
-        end(&mut s).unwrap();
-        let t = data(&s, id);
-        assert_eq!(t.style_at(0).variations.get("wdth"), Some(&75.0));
-        assert_eq!(t.style_at(8).variations.get("wdth"), Some(&90.0));
-        // The axes query answers without fonts too.
-        let r = s.execute("text.fonts", &json!({"family": "Inter", "axes": true})).unwrap();
-        assert!(r.is_null() || r["axes"].is_array());
-    }
-
-    /// No text command panics on junk parameters while a text is being edited.
-    #[test]
-    fn text_commands_survive_junk_while_editing() {
-        let junk = [
-            json!({}),
-            json!(null),
-            json!({"index": -5, "features": {"": 1}}),
-            json!({"index": 1e300, "style": 3, "case": null}),
-            json!([1]),
-            json!({"variations": {"wght": "heavy", "toolong": 1}, "text": "\u{0}\u{7}", "cursor": 1e300}),
-            json!({"variations": {"wght": 1e300, "opsz": -1e300}, "replace": "yes", "text": "日本語", "cursor": -1}),
-        ];
-        // `text.rescanFonts` takes no params and walks the font folders: one walk per junk is slow.
-        for spec in crate::cmd::all_commands().iter().filter(|c| c.id.starts_with("text.") && c.id != "text.rescanFonts") {
-            for j in &junk {
-                let (mut s, id) = setup("Hi there\nyou");
-                begin(&mut s, id, Some(2), false).unwrap();
-                set_caret(&mut s, 5, true).unwrap();
-                if let Err(EngineError::Internal { cmd, msg }) = s.execute(spec.id, j) {
-                    panic!("{cmd} panicked on {j}: {msg}");
-                }
-            }
-        }
-    }
-
-    /// Asserts surrounding text is logical UTF-8 text with byte offsets and keeps a reversed
-    /// selection reversed.
-    #[test]
-    fn ime_surrounding_uses_logical_utf8_bytes_and_keeps_selection_direction() {
-        let (mut s, id) = setup("café😀e\u{301}x");
-        begin(&mut s, id, Some(8), false).unwrap();
-        set_caret(&mut s, 8, false).unwrap();
-        set_caret(&mut s, 5, true).unwrap(); // anchor after the emoji, caret before it
-        let ime = ime_surrounding(&s).unwrap();
-        assert_eq!(ime.text, "café😀e\u{301}x");
-        assert_eq!((ime.cursor, ime.anchor), (9, 13), "char 5 and char 8 as UTF-8 bytes");
-        assert!(ime.cursor < ime.anchor, "the reversed selection stays reversed");
-        assert_eq!(ime.owner.node, id);
-        assert_eq!(ime.owner.document, s.ds().unwrap().uid);
-    }
-
-    /// Asserts an active composition is excluded from surrounding text and an empty text layer
-    /// reports an available, empty payload.
-    #[test]
-    fn ime_surrounding_excludes_the_composition_and_empty_text_is_available() {
-        let (mut s, id) = setup("Hi");
-        begin(&mut s, id, Some(2), false).unwrap();
-        preedit(&mut s, "にほ", Some(1)).unwrap();
-        let ime = ime_surrounding(&s).unwrap();
-        assert_eq!(ime.text, "Hi", "the composition is not committed text");
-        assert_eq!((ime.cursor, ime.anchor), (2, 2));
-        end(&mut s).unwrap();
-
-        let (mut s, id) = setup("");
-        begin(&mut s, id, Some(0), false).unwrap();
-        let ime = ime_surrounding(&s).unwrap();
-        assert_eq!((ime.text.as_str(), ime.cursor, ime.anchor), ("", 0, 0), "an empty layer is available, not unavailable");
-    }
-
-    /// Asserts surrounding text is capped at `MAX_IME_SURROUNDING_BYTES`, an exactly budget-sized
-    /// selection is describable, and one byte more is `SelectionTooWide`.
-    #[test]
-    fn ime_surrounding_is_bounded_and_a_too_wide_selection_is_explicitly_unavailable() {
-        let long = "a".repeat(5000);
-        let (mut s, id) = setup(&long);
-        begin(&mut s, id, Some(5000), false).unwrap();
-        let ime = ime_surrounding(&s).unwrap();
-        assert_eq!(ime.text.len(), MAX_IME_SURROUNDING_BYTES);
-        assert_eq!((ime.cursor, ime.anchor), (MAX_IME_SURROUNDING_BYTES, MAX_IME_SURROUNDING_BYTES));
-
-        // Exactly the budget is still describable; one more byte is not.
-        set_caret(&mut s, 1000, false).unwrap();
-        set_caret(&mut s, 5000, true).unwrap();
-        let ime = ime_surrounding(&s).unwrap();
-        assert_eq!(ime.text.len(), 4000);
-        assert_eq!((ime.cursor, ime.anchor), (4000, 0));
-        set_caret(&mut s, 999, false).unwrap();
-        set_caret(&mut s, 5000, true).unwrap();
-        assert_eq!(ime_surrounding(&s), Err(ImeSurroundingUnavailable::SelectionTooWide));
-    }
-
-    /// Asserts edits and caret moves keep the same IME owner, while ending and beginning a new
-    /// edit session changes the generation.
-    #[test]
-    fn ime_owner_is_stable_through_edits_and_the_session_changes_on_begin() {
-        let (mut s, id) = setup("Hello");
-        begin(&mut s, id, Some(0), false).unwrap();
-        let first = ime_surrounding(&s).unwrap().owner;
-        insert(&mut s, "x").unwrap();
-        set_caret(&mut s, 2, false).unwrap();
-        assert_eq!(ime_surrounding(&s).unwrap().owner, first, "edits and caret moves keep the owner");
-        end(&mut s).unwrap();
-        begin(&mut s, id, Some(0), false).unwrap();
-        let replaced = ime_surrounding(&s).unwrap().owner;
-        assert_eq!(replaced.node, id);
-        assert_ne!(replaced.editing_session, first.editing_session, "a new edit session is a replacement epoch");
-    }
-
-    /// Asserts byte deletion around a reversed selection removes whole characters on both
-    /// sides, keeps the selected text and direction, and a final no-op leaves the text alone.
-    #[test]
-    fn ime_delete_surrounding_bytes_keeps_the_reversed_selection_and_deletes_around_it() {
-        let (mut s, id) = setup("ab你好cd");
-        begin(&mut s, id, Some(4), false).unwrap();
-        set_caret(&mut s, 4, false).unwrap();
-        set_caret(&mut s, 2, true).unwrap(); // reversed: caret before 你, anchor after 好
-        assert!(delete_surrounding_bytes(&mut s, 1, 1).unwrap());
-        // "b" (whole character before the selection) and "c" (whole character after it) go; the
-        // selected "你好" stays for the paired commit, and the reversed direction is preserved.
-        assert_eq!(data(&s, id).characters, "a你好d");
-        assert_eq!(sel(&s), (3, 1)); // (anchor, caret), still reversed
-        assert!(delete_surrounding_bytes(&mut s, 1, 1).unwrap());
-        assert_eq!(data(&s, id).characters, "你好");
-        assert_eq!(sel(&s), (2, 0)); // (anchor, caret), still reversed
-        assert!(!delete_surrounding_bytes(&mut s, 1, 1).unwrap(), "nothing is left around the selection");
-        assert_eq!(data(&s, id).characters, "你好", "a no-op delete does not touch the text");
-    }
-
-    /// Asserts character deletion keeps and shifts the selection, and a no-op delete leaves an
-    /// active composition and the revision untouched.
-    #[test]
-    fn ime_delete_surrounding_chars_keeps_the_selection_and_ignores_a_no_op() {
-        let (mut s, id) = setup("ab你好cd");
-        begin(&mut s, id, Some(2), false).unwrap();
-        set_caret(&mut s, 4, true).unwrap(); // "你好"
-        assert!(delete_surrounding_chars(&mut s, 1, 1).unwrap());
-        assert_eq!(data(&s, id).characters, "a你好d");
-        assert_eq!(sel(&s), (1, 3), "the selection is kept, shifted by the deleted prefix");
-        set_caret(&mut s, 0, false).unwrap();
-        // A composition in progress survives a delete that finds nothing to remove.
-        preedit(&mut s, "x", None).unwrap();
-        let revision = s.ds().unwrap().revision;
-        assert!(!delete_surrounding_chars(&mut s, 1, 0).unwrap());
-        assert_eq!(s.ds().unwrap().text_edit.as_ref().and_then(|te| te.preedit.as_ref()).map(|p| p.text.as_str()), Some("x"));
-        assert_eq!(s.ds().unwrap().revision, revision, "a no-op does not bump the revision");
-        assert!(!delete_surrounding_bytes(&mut s, 1, 0).unwrap());
-        assert_eq!(s.ds().unwrap().text_edit.as_ref().and_then(|te| te.preedit.as_ref()).map(|p| p.text.as_str()), Some("x"));
-        assert_eq!(s.ds().unwrap().revision, revision);
-    }
-
-    /// Asserts a text layer in another document has a different IME owner.
-    #[test]
-    fn ime_owner_identity_changes_with_the_document() {
-        let (mut s, id) = setup("Hi");
-        begin(&mut s, id, Some(2), false).unwrap();
-        let first = ime_surrounding(&s).unwrap().owner;
-        end(&mut s).unwrap();
-        s.execute("file.new", &json!({"name": "Second"})).unwrap();
-        let r = s.execute("text.create", &json!({"text": "There", "x": 0, "y": 0})).unwrap();
-        let other = crate::params::id_of(&r["id"]).unwrap();
-        begin(&mut s, other, Some(5), false).unwrap();
-        let second = ime_surrounding(&s).unwrap().owner;
-        assert_ne!(second.document, first.document, "another document is another IME owner");
-        assert_eq!(second.node, other);
-    }
-
-    /// Asserts a space committed after a line-start `-` becomes a bulleted list and reports
-    /// `Transformed`; a plain `"x"` commit reports `Plain`, and an empty commit reports `Nothing`.
-    #[test]
-    fn ime_commit_reports_list_autoformat_as_an_application_transformation() {
-        let (mut s, id) = setup("-");
-        begin(&mut s, id, Some(1), false).unwrap();
-        assert_eq!(insert_ime_commit(&mut s, " ").unwrap(), ImeInsertion::Transformed);
-        assert_eq!(data(&s, id).characters, "");
-        assert_eq!(data(&s, id).para_list(0).list, ListStyle::Bulleted);
-        assert_eq!(insert_ime_commit(&mut s, "x").unwrap(), ImeInsertion::Plain);
-        assert_eq!(insert_ime_commit(&mut s, "").unwrap(), ImeInsertion::Nothing);
-    }
-
-    /// Asserts CRLF normalization reports `Transformed`, control-only input reports `Nothing`,
-    /// and bare newline/CR commits are ignored while a live composition remains.
-    #[test]
-    fn ime_commit_normalisation_is_a_transformation_and_a_bare_newline_is_ignored() {
-        let (mut s, id) = setup("Hi");
-        begin(&mut s, id, Some(2), false).unwrap();
-        // CRLF is inserted as LF, but the editor changed the commit: application-origin.
-        assert_eq!(insert_ime_commit(&mut s, "a\r\nb").unwrap(), ImeInsertion::Transformed);
-        assert_eq!(data(&s, id).characters, "Hia\nb");
-        // Control characters are dropped; the commit itself is a no-op.
-        assert_eq!(insert_ime_commit(&mut s, "\u{0}\u{7}").unwrap(), ImeInsertion::Nothing);
-        assert_eq!(data(&s, id).characters, "Hia\nb");
-        // Stock `TextEdit` ignores a bare newline/CR commit; typing Enter still inserts one.
-        // (It also leaves a live composition alone, unlike the non-ignored commit below.)
-        preedit(&mut s, "x", None).unwrap();
-        assert_eq!(insert_ime_commit(&mut s, "\n").unwrap(), ImeInsertion::Nothing);
-        assert_eq!(insert_ime_commit(&mut s, "\r").unwrap(), ImeInsertion::Nothing);
-        assert_eq!(preedit_state(&s).map(|p| p.text), Some("x".into()));
-        preedit(&mut s, "", None).unwrap();
-        assert_eq!(data(&s, id).characters, "Hia\nb");
-        insert(&mut s, "\n").unwrap();
-        assert_eq!(data(&s, id).characters, "Hia\nb\n");
-    }
-
-    /// Asserts an empty or control-only IME commit ends a live composition (bumping the revision
-    /// once), inserts nothing, and is a harmless no-op when no composition is active.
-    #[test]
-    fn an_empty_ime_commit_ends_the_composition_without_inserting_text() {
-        let (mut s, id) = setup("Hello");
-        begin(&mut s, id, Some(5), false).unwrap();
-        preedit(&mut s, "にほ", None).unwrap();
-        assert_eq!(preedit_state(&s).map(|p| p.text), Some("にほ".into()));
-        let revision = s.ds().unwrap().revision;
-        assert_eq!(insert_ime_commit(&mut s, "").unwrap(), ImeInsertion::Nothing);
-        assert_eq!(s.ds().unwrap().revision, revision + 1, "ending a live composition bumps the revision");
-        assert!(preedit_state(&s).is_none(), "an empty commit ends the composition");
-        assert!(preedit_doc(&s).is_none());
-        assert_eq!(data(&s, id).characters, "Hello", "and inserts nothing");
-
-        // A control-only commit normalises to empty and ends the composition too.
-        preedit(&mut s, "x", None).unwrap();
-        let revision = s.ds().unwrap().revision;
-        assert_eq!(insert_ime_commit(&mut s, "\u{0}\u{7}").unwrap(), ImeInsertion::Nothing);
-        assert_eq!(s.ds().unwrap().revision, revision + 1, "clearing a live composition bumps the revision");
-        assert!(preedit_state(&s).is_none());
-        assert_eq!(data(&s, id).characters, "Hello");
-
-        // With no composition (and not even while editing) an empty commit stays a harmless no-op.
-        let revision = s.ds().unwrap().revision;
-        assert_eq!(insert_ime_commit(&mut s, "").unwrap(), ImeInsertion::Nothing);
-        assert_eq!(s.ds().unwrap().revision, revision);
-        end(&mut s).unwrap();
-        assert_eq!(insert_ime_commit(&mut s, "").unwrap(), ImeInsertion::Nothing);
-    }
-}
+mod tests;
diff --git a/crates/engine/src/textedit/tests.rs b/crates/engine/src/textedit/tests.rs
new file mode 100644
index 00000000..fecca580
--- /dev/null
+++ b/crates/engine/src/textedit/tests.rs
@@ -0,0 +1,571 @@
+use super::*;
+use crate::tools::{PointerEvent, PointerKind};
+use figcraft_doc::{ListStyle, TextAutoResize, TextCase, TextDecoration};
+use serde_json::json;
+
+fn setup(text: &str) -> (Session, NodeId) {
+    let mut s = Session::new();
+    let r = s.execute("text.create", &json!({"text": text, "x": 0, "y": 0, "props": {"fontSize": 24}})).unwrap();
+    let id = crate::params::id_of(&r["id"]).unwrap();
+    (s, id)
+}
+
+fn data(s: &Session, id: NodeId) -> TextData {
+    s.doc().unwrap().node(id).unwrap().kind.text().unwrap().clone()
+}
+
+fn sel(s: &Session) -> (usize, usize) {
+    let te = s.ds().unwrap().text_edit.clone().unwrap();
+    (te.anchor, te.caret)
+}
+
+#[test]
+fn whole_editing_session_is_one_undo_step() {
+    let (mut s, id) = setup("Hello");
+    let undo_before = s.ds().unwrap().history.undo.len();
+    begin(&mut s, id, Some(5), false).unwrap();
+    insert(&mut s, " big").unwrap();
+    insert(&mut s, " world").unwrap();
+    key(&mut s, "Backspace", false, false, false).unwrap();
+    // Styling a range mid-session joins the same step.
+    set_caret(&mut s, 0, false).unwrap();
+    set_caret(&mut s, 5, true).unwrap();
+    s.execute("text.bold", &json!({})).unwrap();
+    s.execute("text.alignCenter", &json!({})).unwrap();
+    end(&mut s).unwrap();
+    let t = data(&s, id);
+    assert_eq!(t.characters, "Hello big worl");
+    assert_eq!(t.style_at(0).font_style, "Bold");
+    assert_eq!(t.style_at(6).font_style, "Regular");
+    assert_eq!(s.ds().unwrap().history.undo.len(), undo_before + 1);
+    s.undo().unwrap();
+    let t = data(&s, id);
+    assert_eq!(t.characters, "Hello");
+    assert!(t.runs.is_empty());
+    assert_eq!(t.align_h, figcraft_doc::TextAlignH::Left);
+}
+
+#[test]
+fn typing_replaces_selection_and_paste_is_plain() {
+    let (mut s, id) = setup("Hello world");
+    begin(&mut s, id, None, false).unwrap();
+    assert_eq!(sel(&s), (0, 11), "begin without caret selects all");
+    select_word(&mut s, 7).unwrap();
+    assert_eq!(sel(&s), (6, 11));
+    insert(&mut s, "there").unwrap();
+    assert_eq!(data(&s, id).characters, "Hello there");
+    assert_eq!(sel(&s), (11, 11));
+    // Pasted text: CRLF / CR / Unicode separators become newlines, other controls are dropped.
+    insert(&mut s, "\r\na\rb\u{2029}c\u{0}\u{7}\td").unwrap();
+    assert_eq!(data(&s, id).characters, "Hello there\na\nb\nc\td");
+    insert(&mut s, "\u{1}").unwrap();
+    assert_eq!(data(&s, id).characters, "Hello there\na\nb\nc\td");
+    // Select the line (paragraph) then type over it.
+    select_line(&mut s, 0).unwrap();
+    assert_eq!(sel(&s), (0, 11));
+    insert(&mut s, "Hi").unwrap();
+    assert_eq!(data(&s, id).characters, "Hi\na\nb\nc\td");
+    assert_eq!(selected_text(&s).as_deref(), Some(""));
+    end(&mut s).unwrap();
+}
+
+#[test]
+fn word_selection_classes() {
+    let (mut s, id) = setup("foo,  bar_baz!\nnext");
+    begin(&mut s, id, Some(0), false).unwrap();
+    select_word(&mut s, 1).unwrap();
+    assert_eq!(sel(&s), (0, 3));
+    // Right after a word's last char selects the word.
+    select_word(&mut s, 13).unwrap();
+    assert_eq!(sel(&s), (6, 13));
+    // A run of spaces.
+    select_word(&mut s, 4).unwrap();
+    assert_eq!(sel(&s), (4, 6));
+    select_line(&mut s, 16).unwrap();
+    assert_eq!(sel(&s), (15, 19));
+    select_line(&mut s, 999).unwrap();
+    assert_eq!(sel(&s), (15, 19));
+    select_word(&mut s, 999).unwrap();
+    assert_eq!(sel(&s), (15, 19));
+    set_caret(&mut s, 999, false).unwrap();
+    assert_eq!(sel(&s), (19, 19), "carets clamp to the text");
+}
+
+#[test]
+fn keyboard_navigation_and_extension() {
+    let (mut s, id) = setup("one two\nthree");
+    begin(&mut s, id, Some(0), false).unwrap();
+    key(&mut s, "Right", false, true, false).unwrap(); // Alt+Right: end of word
+    assert_eq!(sel(&s), (3, 3));
+    key(&mut s, "Right", true, true, false).unwrap(); // Shift+Alt+Right extends
+    assert_eq!(sel(&s), (3, 7));
+    key(&mut s, "Left", false, false, false).unwrap(); // collapses to the start
+    assert_eq!(sel(&s), (3, 3));
+    key(&mut s, "Right", false, false, true).unwrap(); // Cmd+Right: line end
+    assert_eq!(sel(&s), (7, 7));
+    key(&mut s, "Down", true, false, true).unwrap(); // Shift+Cmd+Down: to the end
+    assert_eq!(sel(&s), (7, 13));
+    key(&mut s, "Left", false, false, true).unwrap(); // Cmd+Left from the collapsed start
+    assert_eq!(sel(&s), (0, 0));
+    key(&mut s, "Delete", false, true, false).unwrap(); // Alt+Delete: word forward
+    assert_eq!(data(&s, id).characters, " two\nthree");
+    key(&mut s, "SelectAll", false, false, false).unwrap();
+    assert_eq!(sel(&s), (0, 10));
+    end(&mut s).unwrap();
+}
+
+#[test]
+fn backspace_removes_only_the_final_thai_mark() {
+    let (mut s, id) = setup("น้ำ");
+    begin(&mut s, id, Some(3), false).unwrap();
+
+    key(&mut s, "Backspace", false, false, false).unwrap();
+
+    assert_eq!(data(&s, id).characters, "น้");
+}
+
+fn ev(kind: PointerKind, x: f64, y: f64, shift: bool) -> PointerEvent {
+    let mut e = PointerEvent::at(kind, x, y, 1.0);
+    e.shift = shift;
+    e
+}
+
+/// Asserts double-clicking a text layer selects all text, a second double-click selects the
+/// word without changing the editing session, and drag and Shift+click extend the
+/// selection.
+#[test]
+fn pointer_double_click_drag_and_shift_click() {
+    let (mut s, id) = setup("Hello world");
+    let Some((l, _)) = figcraft_text::layout_node(s.doc().unwrap().node(id).unwrap()) else { return };
+    if l.glyphs.is_empty() {
+        return; // no fonts
+    }
+    let y = l.lines[0].top + l.lines[0].height / 2.0;
+    let x_of = |i: usize| l.caret(i).0;
+    // Double-click inside "world" edits with all the text selected; another one there
+    // selects the word.
+    let mid = (x_of(7) + x_of(8)) / 2.0;
+    s.pointer(&ev(PointerKind::Down, mid, y, false)).unwrap();
+    s.pointer(&ev(PointerKind::Up, mid, y, false)).unwrap();
+    s.pointer(&ev(PointerKind::DoubleClick, mid, y, false)).unwrap();
+    assert_eq!(sel(&s), (0, 11));
+    let epoch = s.ds().unwrap().text_edit.as_ref().unwrap().editing_session;
+    s.pointer(&ev(PointerKind::Down, mid, y, false)).unwrap();
+    s.pointer(&ev(PointerKind::DoubleClick, mid, y, false)).unwrap();
+    s.pointer(&ev(PointerKind::Up, mid, y, false)).unwrap();
+    assert_eq!(sel(&s), (6, 11));
+    assert_eq!(
+        s.ds().unwrap().text_edit.as_ref().unwrap().editing_session,
+        epoch,
+        "a double-click inside the edit is an ordinary edit: same IME replacement epoch"
+    );
+    // Drag-select from the start of "Hello" to the middle.
+    s.pointer(&ev(PointerKind::Down, x_of(0) + 0.5, y, false)).unwrap();
+    assert_eq!(sel(&s), (0, 0));
+    s.pointer(&ev(PointerKind::Move, (x_of(3) + x_of(4)) / 2.0 - 1.0, y, false)).unwrap();
+    s.pointer(&ev(PointerKind::Up, (x_of(3) + x_of(4)) / 2.0 - 1.0, y, false)).unwrap();
+    assert_eq!(sel(&s), (0, 3));
+    // Shift+click extends.
+    s.pointer(&ev(PointerKind::Down, x_of(9) + 0.5, y, true)).unwrap();
+    s.pointer(&ev(PointerKind::Up, x_of(9) + 0.5, y, true)).unwrap();
+    assert_eq!(sel(&s), (0, 9));
+    insert(&mut s, "J").unwrap();
+    assert_eq!(data(&s, id).characters, "Jld");
+}
+
+#[test]
+fn text_commands_apply_to_edited_range() {
+    let (mut s, id) = setup("Hello world");
+    begin(&mut s, id, Some(0), false).unwrap();
+    set_caret(&mut s, 6, true).unwrap(); // "Hello "
+    for (cmd, p) in [
+        ("text.underline", json!({})),
+        ("text.italic", json!({})),
+        ("text.sizeUp", json!({})),
+        ("text.trackingUp", json!({})),
+        ("text.lineHeightUp", json!({})),
+        ("text.caseSmallCaps", json!({})),
+        ("text.link", json!({"url": "https://example.com"})),
+    ] {
+        s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"));
+    }
+    let t = data(&s, id);
+    let (a, b) = (t.style_at(0), t.style_at(8));
+    assert_eq!(a.decoration, TextDecoration::Underline);
+    assert!(a.italic() && !b.italic());
+    assert_eq!(a.font_size, 25.0);
+    assert_eq!(b.font_size, 24.0);
+    assert_eq!(a.case, TextCase::SmallCaps);
+    assert_eq!(a.link.as_deref(), Some("https://example.com"));
+    assert!(b.link.is_none());
+    // text.style with an explicit range (what the panel sends).
+    s.execute("text.style", &json!({"id": id, "start": 6, "end": 11, "fontSize": 40, "textCase": "upper"})).unwrap();
+    let t = data(&s, id);
+    assert_eq!(t.style_at(8).font_size, 40.0);
+    assert_eq!(t.style_at(8).case, TextCase::Upper);
+    // Paragraph commands hit the edited node.
+    s.execute("text.listStyle", &json!({"style": "numbered"})).unwrap();
+    assert_eq!(data(&s, id).list, ListStyle::Numbered);
+    // Every Text-menu command runs while editing.
+    for item in crate::catalog::MENU.iter().filter(|i| i.id.starts_with("text.")) {
+        let p = if item.id == "text.link" { json!({"url": "u"}) } else { json!({}) };
+        if crate::find_command(item.id).is_some() {
+            s.execute(item.id, &p).unwrap_or_else(|e| panic!("{}: {e}", item.id));
+        }
+    }
+    end(&mut s).unwrap();
+}
+
+#[test]
+fn paragraph_and_feature_commands_on_nodes() {
+    let (mut s, id) = setup("Hello");
+    let ids = json!([id]);
+    s.execute("text.setFeatures", &json!({"ids": ids, "features": {"liga": false, "tnum": true}})).unwrap();
+    assert_eq!(data(&s, id).features.get("liga"), Some(&false));
+    s.execute("text.setFeatures", &json!({"ids": ids, "features": {"liga": null, "ss01": 1}})).unwrap();
+    let f = data(&s, id).features;
+    assert_eq!(f.get("liga"), None);
+    assert_eq!(f.get("ss01"), Some(&true));
+    assert_eq!(f.get("tnum"), Some(&true));
+    s.execute("text.setFeatures", &json!({"ids": ids, "features": {"zero": true}, "replace": true})).unwrap();
+    assert_eq!(data(&s, id).features.len(), 1);
+    assert!(s.execute("text.setFeatures", &json!({"ids": ids, "features": {"ligatures": true}})).is_err());
+    assert!(s.execute("text.setFeatures", &json!({"ids": ids, "features": {"liga": "yes"}})).is_err());
+    assert!(s.execute("text.setFeatures", &json!({"ids": ids})).is_err());
+    s.execute("node.set", &json!({"id": id, "props": {"features": {"calt": false}}})).unwrap();
+    assert_eq!(data(&s, id).features.len(), 1);
+    s.execute("text.paragraphIndent", &json!({"ids": ids, "indent": 16})).unwrap();
+    s.execute("text.paragraphSpacing", &json!({"ids": ids, "spacing": 8})).unwrap();
+    s.execute("text.maxLines", &json!({"ids": ids, "lines": 2})).unwrap();
+    s.execute("text.decoration", &json!({"ids": ids, "decoration": "strikethrough"})).unwrap();
+    s.execute("text.case", &json!({"ids": ids, "case": "smallCaps"})).unwrap();
+    s.execute("text.listStyle", &json!({"ids": ids, "style": "bulleted"})).unwrap();
+    let t = data(&s, id);
+    assert_eq!((t.paragraph_indent, t.paragraph_spacing, t.max_lines), (16.0, 8.0, 2));
+    assert_eq!(t.auto_resize, TextAutoResize::Truncate);
+    assert_eq!(t.style.decoration, TextDecoration::Strikethrough);
+    assert_eq!(t.style.case, TextCase::SmallCaps);
+    assert_eq!(t.list, ListStyle::Bulleted);
+    assert!(s.execute("text.listStyle", &json!({"ids": ids, "style": "zigzag"})).is_err());
+    assert!(s.execute("text.paragraphIndent", &json!({"ids": ids, "indent": "NaN"})).is_err());
+    s.execute("node.set", &json!({"id": id, "props": {"textCase": "smallCaps", "paragraphIndent": 4, "maxLines": 0}})).unwrap();
+    assert_eq!(data(&s, id).paragraph_indent, 4.0);
+}
+
+fn preedit_state(s: &Session) -> Option<Preedit> {
+    s.ds().unwrap().text_edit.clone().unwrap().preedit
+}
+
+#[test]
+fn ime_composition_is_shown_but_not_in_the_document_until_committed() {
+    let (mut s, id) = setup("Hello world");
+    let undo_before = s.ds().unwrap().history.undo.len();
+    begin(&mut s, id, Some(5), false).unwrap();
+    let doc_before = s.ds().unwrap().doc.clone();
+    s.execute("text.edit.preedit", &json!({"text": "にほ", "cursor": 1})).unwrap();
+    assert_eq!(preedit_state(&s), Some(Preedit { text: "にほ".into(), cursor: 1 }));
+    assert!(std::sync::Arc::ptr_eq(&doc_before, &s.ds().unwrap().doc), "composing leaves the document alone");
+    let (shown, range, cursor) = preedit_doc(&s).unwrap();
+    assert_eq!(shown.node(id).unwrap().kind.text().unwrap().characters, "Helloにほ world");
+    assert_eq!((range, cursor), ((5, 7), 6));
+    let info = s.execute("text.edit.selection", &json!({})).unwrap();
+    assert_eq!(info["preedit"]["text"], "にほ");
+    // Updating the composition replaces it; an empty one cancels it.
+    preedit(&mut s, "にほん", None).unwrap();
+    assert_eq!(preedit_doc(&s).unwrap().2, 8);
+    preedit(&mut s, "", None).unwrap();
+    assert!(preedit_state(&s).is_none() && preedit_doc(&s).is_none());
+    assert_eq!(data(&s, id).characters, "Hello world");
+    // Commit puts the final text at the caret.
+    preedit(&mut s, "にほん", None).unwrap();
+    s.execute("text.edit.insert", &json!({"text": "日本"})).unwrap();
+    assert!(preedit_state(&s).is_none());
+    assert_eq!(data(&s, id).characters, "Hello日本 world");
+    assert_eq!(sel(&s), (7, 7));
+    // Composing over a selection replaces it; moving the caret abandons the composition.
+    set_caret(&mut s, 7, false).unwrap();
+    set_caret(&mut s, 13, true).unwrap();
+    preedit(&mut s, "x", None).unwrap();
+    assert_eq!(data(&s, id).characters, "Hello日本");
+    set_caret(&mut s, 0, false).unwrap();
+    assert!(preedit_state(&s).is_none());
+    assert_eq!(data(&s, id).characters, "Hello日本");
+    // Ending the edit drops an uncommitted composition; the session stays one undo step.
+    preedit(&mut s, "zz", None).unwrap();
+    end(&mut s).unwrap();
+    assert_eq!(data(&s, id).characters, "Hello日本");
+    assert_eq!(s.ds().unwrap().history.undo.len(), undo_before + 1);
+    // Not editing: an error, not a crash.
+    assert!(preedit(&mut s, "a", None).is_err());
+}
+
+#[test]
+fn variable_font_axes_as_commands_and_props() {
+    let (mut s, id) = setup("Hello world");
+    let ids = json!([id]);
+    s.execute("text.setVariations", &json!({"ids": ids, "variations": {"wght": 550, "wdth": 85}})).unwrap();
+    let st = data(&s, id).style;
+    assert_eq!((st.variations.get("wght"), st.variations.get("wdth")), (Some(&550.0), Some(&85.0)));
+    assert_eq!(st.weight(), 550);
+    // null removes one axis; replace clears the rest.
+    s.execute("text.setVariations", &json!({"ids": ids, "variations": {"wdth": null}})).unwrap();
+    assert_eq!(data(&s, id).style.variations.len(), 1);
+    s.execute("text.setVariations", &json!({"ids": ids, "variations": {"opsz": 14}, "replace": true})).unwrap();
+    assert_eq!(data(&s, id).style.variations.keys().collect::<Vec<_>>(), ["opsz"]);
+    // Undo restores the previous values.
+    s.undo().unwrap();
+    assert_eq!(data(&s, id).style.variations.keys().collect::<Vec<_>>(), ["wght"]);
+    // Junk is rejected.
+    assert!(s.execute("text.setVariations", &json!({"ids": ids, "variations": {"weight": 500}})).is_err());
+    assert!(s.execute("text.setVariations", &json!({"ids": ids, "variations": {"wght": "bold"}})).is_err());
+    assert!(s.execute("text.setVariations", &json!({"ids": ids})).is_err());
+    // node.set props (whole text or a range) replace the custom values.
+    s.execute("node.set", &json!({"id": id, "props": {"fontVariations": {"wght": 300}, "start": 6, "end": 11}})).unwrap();
+    let t = data(&s, id);
+    assert_eq!(t.style_at(0).variations.get("wght"), Some(&550.0));
+    assert_eq!(t.style_at(7).variations.get("wght"), Some(&300.0));
+    s.execute("node.set", &json!({"id": id, "props": {"variationSettings": null}})).unwrap();
+    assert!(data(&s, id).runs.is_empty() && data(&s, id).style.variations.is_empty());
+    // Picking a named style (Bold, weight steps) drops the custom weight but keeps width.
+    s.execute("text.setVariations", &json!({"ids": ids, "variations": {"wght": 650, "wdth": 90}})).unwrap();
+    s.execute("text.bold", &json!({"ids": ids})).unwrap();
+    let st = data(&s, id).style;
+    assert_eq!(st.font_style, "Bold", "650 is lighter than bold, so Bold applies");
+    assert!(!st.variations.contains_key("wght"));
+    assert_eq!(st.variations.get("wdth"), Some(&90.0));
+    // While editing, the command styles the selected range only.
+    begin(&mut s, id, Some(0), false).unwrap();
+    set_caret(&mut s, 5, true).unwrap();
+    s.execute("text.setVariations", &json!({"variations": {"wdth": 75}})).unwrap();
+    end(&mut s).unwrap();
+    let t = data(&s, id);
+    assert_eq!(t.style_at(0).variations.get("wdth"), Some(&75.0));
+    assert_eq!(t.style_at(8).variations.get("wdth"), Some(&90.0));
+    // The axes query answers without fonts too.
+    let r = s.execute("text.fonts", &json!({"family": "Inter", "axes": true})).unwrap();
+    assert!(r.is_null() || r["axes"].is_array());
+}
+
+/// No text command panics on junk parameters while a text is being edited.
+#[test]
+fn text_commands_survive_junk_while_editing() {
+    let junk = [
+        json!({}),
+        json!(null),
+        json!({"index": -5, "features": {"": 1}}),
+        json!({"index": 1e300, "style": 3, "case": null}),
+        json!([1]),
+        json!({"variations": {"wght": "heavy", "toolong": 1}, "text": "\u{0}\u{7}", "cursor": 1e300}),
+        json!({"variations": {"wght": 1e300, "opsz": -1e300}, "replace": "yes", "text": "日本語", "cursor": -1}),
+    ];
+    // `text.rescanFonts` takes no params and walks the font folders: one walk per junk is slow.
+    for spec in crate::cmd::all_commands().iter().filter(|c| c.id.starts_with("text.") && c.id != "text.rescanFonts") {
+        for j in &junk {
+            let (mut s, id) = setup("Hi there\nyou");
+            begin(&mut s, id, Some(2), false).unwrap();
+            set_caret(&mut s, 5, true).unwrap();
+            if let Err(EngineError::Internal { cmd, msg }) = s.execute(spec.id, j) {
+                panic!("{cmd} panicked on {j}: {msg}");
+            }
+        }
+    }
+}
+
+/// Asserts surrounding text is logical UTF-8 text with byte offsets and keeps a reversed
+/// selection reversed.
+#[test]
+fn ime_surrounding_uses_logical_utf8_bytes_and_keeps_selection_direction() {
+    let (mut s, id) = setup("café😀e\u{301}x");
+    begin(&mut s, id, Some(8), false).unwrap();
+    set_caret(&mut s, 8, false).unwrap();
+    set_caret(&mut s, 5, true).unwrap(); // anchor after the emoji, caret before it
+    let ime = ime_surrounding(&s).unwrap();
+    assert_eq!(ime.text, "café😀e\u{301}x");
+    assert_eq!((ime.cursor, ime.anchor), (9, 13), "char 5 and char 8 as UTF-8 bytes");
+    assert!(ime.cursor < ime.anchor, "the reversed selection stays reversed");
+    assert_eq!(ime.owner.node, id);
+    assert_eq!(ime.owner.document, s.ds().unwrap().uid);
+}
+
+/// Asserts an active composition is excluded from surrounding text and an empty text layer
+/// reports an available, empty payload.
+#[test]
+fn ime_surrounding_excludes_the_composition_and_empty_text_is_available() {
+    let (mut s, id) = setup("Hi");
+    begin(&mut s, id, Some(2), false).unwrap();
+    preedit(&mut s, "にほ", Some(1)).unwrap();
+    let ime = ime_surrounding(&s).unwrap();
+    assert_eq!(ime.text, "Hi", "the composition is not committed text");
+    assert_eq!((ime.cursor, ime.anchor), (2, 2));
+    end(&mut s).unwrap();
+
+    let (mut s, id) = setup("");
+    begin(&mut s, id, Some(0), false).unwrap();
+    let ime = ime_surrounding(&s).unwrap();
+    assert_eq!((ime.text.as_str(), ime.cursor, ime.anchor), ("", 0, 0), "an empty layer is available, not unavailable");
+}
+
+/// Asserts surrounding text is capped at `MAX_IME_SURROUNDING_BYTES`, an exactly budget-sized
+/// selection is describable, and one byte more is `SelectionTooWide`.
+#[test]
+fn ime_surrounding_is_bounded_and_a_too_wide_selection_is_explicitly_unavailable() {
+    let long = "a".repeat(5000);
+    let (mut s, id) = setup(&long);
+    begin(&mut s, id, Some(5000), false).unwrap();
+    let ime = ime_surrounding(&s).unwrap();
+    assert_eq!(ime.text.len(), MAX_IME_SURROUNDING_BYTES);
+    assert_eq!((ime.cursor, ime.anchor), (MAX_IME_SURROUNDING_BYTES, MAX_IME_SURROUNDING_BYTES));
+
+    // Exactly the budget is still describable; one more byte is not.
+    set_caret(&mut s, 1000, false).unwrap();
+    set_caret(&mut s, 5000, true).unwrap();
+    let ime = ime_surrounding(&s).unwrap();
+    assert_eq!(ime.text.len(), 4000);
+    assert_eq!((ime.cursor, ime.anchor), (4000, 0));
+    set_caret(&mut s, 999, false).unwrap();
+    set_caret(&mut s, 5000, true).unwrap();
+    assert_eq!(ime_surrounding(&s), Err(ImeSurroundingUnavailable::SelectionTooWide));
+}
+
+/// Asserts edits and caret moves keep the same IME owner, while ending and beginning a new
+/// edit session changes the generation.
+#[test]
+fn ime_owner_is_stable_through_edits_and_the_session_changes_on_begin() {
+    let (mut s, id) = setup("Hello");
+    begin(&mut s, id, Some(0), false).unwrap();
+    let first = ime_surrounding(&s).unwrap().owner;
+    insert(&mut s, "x").unwrap();
+    set_caret(&mut s, 2, false).unwrap();
+    assert_eq!(ime_surrounding(&s).unwrap().owner, first, "edits and caret moves keep the owner");
+    end(&mut s).unwrap();
+    begin(&mut s, id, Some(0), false).unwrap();
+    let replaced = ime_surrounding(&s).unwrap().owner;
+    assert_eq!(replaced.node, id);
+    assert_ne!(replaced.editing_session, first.editing_session, "a new edit session is a replacement epoch");
+}
+
+/// Asserts byte deletion around a reversed selection removes whole characters on both
+/// sides, keeps the selected text and direction, and a final no-op leaves the text alone.
+#[test]
+fn ime_delete_surrounding_bytes_keeps_the_reversed_selection_and_deletes_around_it() {
+    let (mut s, id) = setup("ab你好cd");
+    begin(&mut s, id, Some(4), false).unwrap();
+    set_caret(&mut s, 4, false).unwrap();
+    set_caret(&mut s, 2, true).unwrap(); // reversed: caret before 你, anchor after 好
+    assert!(delete_surrounding_bytes(&mut s, 1, 1).unwrap());
+    // "b" (whole character before the selection) and "c" (whole character after it) go; the
+    // selected "你好" stays for the paired commit, and the reversed direction is preserved.
+    assert_eq!(data(&s, id).characters, "a你好d");
+    assert_eq!(sel(&s), (3, 1)); // (anchor, caret), still reversed
+    assert!(delete_surrounding_bytes(&mut s, 1, 1).unwrap());
+    assert_eq!(data(&s, id).characters, "你好");
+    assert_eq!(sel(&s), (2, 0)); // (anchor, caret), still reversed
+    assert!(!delete_surrounding_bytes(&mut s, 1, 1).unwrap(), "nothing is left around the selection");
+    assert_eq!(data(&s, id).characters, "你好", "a no-op delete does not touch the text");
+}
+
+/// Asserts character deletion keeps and shifts the selection, and a no-op delete leaves an
+/// active composition and the revision untouched.
+#[test]
+fn ime_delete_surrounding_chars_keeps_the_selection_and_ignores_a_no_op() {
+    let (mut s, id) = setup("ab你好cd");
+    begin(&mut s, id, Some(2), false).unwrap();
+    set_caret(&mut s, 4, true).unwrap(); // "你好"
+    assert!(delete_surrounding_chars(&mut s, 1, 1).unwrap());
+    assert_eq!(data(&s, id).characters, "a你好d");
+    assert_eq!(sel(&s), (1, 3), "the selection is kept, shifted by the deleted prefix");
+    set_caret(&mut s, 0, false).unwrap();
+    // A composition in progress survives a delete that finds nothing to remove.
+    preedit(&mut s, "x", None).unwrap();
+    let revision = s.ds().unwrap().revision;
+    assert!(!delete_surrounding_chars(&mut s, 1, 0).unwrap());
+    assert_eq!(s.ds().unwrap().text_edit.as_ref().and_then(|te| te.preedit.as_ref()).map(|p| p.text.as_str()), Some("x"));
+    assert_eq!(s.ds().unwrap().revision, revision, "a no-op does not bump the revision");
+    assert!(!delete_surrounding_bytes(&mut s, 1, 0).unwrap());
+    assert_eq!(s.ds().unwrap().text_edit.as_ref().and_then(|te| te.preedit.as_ref()).map(|p| p.text.as_str()), Some("x"));
+    assert_eq!(s.ds().unwrap().revision, revision);
+}
+
+/// Asserts a text layer in another document has a different IME owner.
+#[test]
+fn ime_owner_identity_changes_with_the_document() {
+    let (mut s, id) = setup("Hi");
+    begin(&mut s, id, Some(2), false).unwrap();
+    let first = ime_surrounding(&s).unwrap().owner;
+    end(&mut s).unwrap();
+    s.execute("file.new", &json!({"name": "Second"})).unwrap();
+    let r = s.execute("text.create", &json!({"text": "There", "x": 0, "y": 0})).unwrap();
+    let other = crate::params::id_of(&r["id"]).unwrap();
+    begin(&mut s, other, Some(5), false).unwrap();
+    let second = ime_surrounding(&s).unwrap().owner;
+    assert_ne!(second.document, first.document, "another document is another IME owner");
+    assert_eq!(second.node, other);
+}
+
+/// Asserts a space committed after a line-start `-` becomes a bulleted list and reports
+/// `Transformed`; a plain `"x"` commit reports `Plain`, and an empty commit reports `Nothing`.
+#[test]
+fn ime_commit_reports_list_autoformat_as_an_application_transformation() {
+    let (mut s, id) = setup("-");
+    begin(&mut s, id, Some(1), false).unwrap();
+    assert_eq!(insert_ime_commit(&mut s, " ").unwrap(), ImeInsertion::Transformed);
+    assert_eq!(data(&s, id).characters, "");
+    assert_eq!(data(&s, id).para_list(0).list, ListStyle::Bulleted);
+    assert_eq!(insert_ime_commit(&mut s, "x").unwrap(), ImeInsertion::Plain);
+    assert_eq!(insert_ime_commit(&mut s, "").unwrap(), ImeInsertion::Nothing);
+}
+
+/// Asserts CRLF normalization reports `Transformed`, control-only input reports `Nothing`,
+/// and bare newline/CR commits are ignored while a live composition remains.
+#[test]
+fn ime_commit_normalisation_is_a_transformation_and_a_bare_newline_is_ignored() {
+    let (mut s, id) = setup("Hi");
+    begin(&mut s, id, Some(2), false).unwrap();
+    // CRLF is inserted as LF, but the editor changed the commit: application-origin.
+    assert_eq!(insert_ime_commit(&mut s, "a\r\nb").unwrap(), ImeInsertion::Transformed);
+    assert_eq!(data(&s, id).characters, "Hia\nb");
+    // Control characters are dropped; the commit itself is a no-op.
+    assert_eq!(insert_ime_commit(&mut s, "\u{0}\u{7}").unwrap(), ImeInsertion::Nothing);
+    assert_eq!(data(&s, id).characters, "Hia\nb");
+    // Stock `TextEdit` ignores a bare newline/CR commit; typing Enter still inserts one.
+    // (It also leaves a live composition alone, unlike the non-ignored commit below.)
+    preedit(&mut s, "x", None).unwrap();
+    assert_eq!(insert_ime_commit(&mut s, "\n").unwrap(), ImeInsertion::Nothing);
+    assert_eq!(insert_ime_commit(&mut s, "\r").unwrap(), ImeInsertion::Nothing);
+    assert_eq!(preedit_state(&s).map(|p| p.text), Some("x".into()));
+    preedit(&mut s, "", None).unwrap();
+    assert_eq!(data(&s, id).characters, "Hia\nb");
+    insert(&mut s, "\n").unwrap();
+    assert_eq!(data(&s, id).characters, "Hia\nb\n");
+}
+
+/// Asserts an empty or control-only IME commit ends a live composition (bumping the revision
+/// once), inserts nothing, and is a harmless no-op when no composition is active.
+#[test]
+fn an_empty_ime_commit_ends_the_composition_without_inserting_text() {
+    let (mut s, id) = setup("Hello");
+    begin(&mut s, id, Some(5), false).unwrap();
+    preedit(&mut s, "にほ", None).unwrap();
+    assert_eq!(preedit_state(&s).map(|p| p.text), Some("にほ".into()));
+    let revision = s.ds().unwrap().revision;
+    assert_eq!(insert_ime_commit(&mut s, "").unwrap(), ImeInsertion::Nothing);
+    assert_eq!(s.ds().unwrap().revision, revision + 1, "ending a live composition bumps the revision");
+    assert!(preedit_state(&s).is_none(), "an empty commit ends the composition");
+    assert!(preedit_doc(&s).is_none());
+    assert_eq!(data(&s, id).characters, "Hello", "and inserts nothing");
+
+    // A control-only commit normalises to empty and ends the composition too.
+    preedit(&mut s, "x", None).unwrap();
+    let revision = s.ds().unwrap().revision;
+    assert_eq!(insert_ime_commit(&mut s, "\u{0}\u{7}").unwrap(), ImeInsertion::Nothing);
+    assert_eq!(s.ds().unwrap().revision, revision + 1, "clearing a live composition bumps the revision");
+    assert!(preedit_state(&s).is_none());
+    assert_eq!(data(&s, id).characters, "Hello");
+
+    // With no composition (and not even while editing) an empty commit stays a harmless no-op.
+    let revision = s.ds().unwrap().revision;
+    assert_eq!(insert_ime_commit(&mut s, "").unwrap(), ImeInsertion::Nothing);
+    assert_eq!(s.ds().unwrap().revision, revision);
+    end(&mut s).unwrap();
+    assert_eq!(insert_ime_commit(&mut s, "").unwrap(), ImeInsertion::Nothing);
+}

From 096b96c699ff2e6f3fbf8617623900146675d905 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:15 +0000
Subject: [PATCH 09/67] refactor(ui-egui): move present.rs inline tests to
 crates/ui-egui/src/present/tests.rs

---
 crates/ui-egui/src/present.rs       | 442 +---------------------------
 crates/ui-egui/src/present/tests.rs | 438 +++++++++++++++++++++++++++
 2 files changed, 439 insertions(+), 441 deletions(-)
 create mode 100644 crates/ui-egui/src/present/tests.rs

diff --git a/crates/ui-egui/src/present.rs b/crates/ui-egui/src/present.rs
index 17825fbf..b5469e6e 100644
--- a/crates/ui-egui/src/present.rs
+++ b/crates/ui-egui/src/present.rs
@@ -2979,444 +2979,4 @@ mod delay_tests;
 mod overlay_anchor_tests;
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use figcraft_doc::NodeKind;
-
-    use crate::present_tests::{Ui, id};
-
-    #[test]
-    fn device_picker_reflows_without_resizing_the_saved_frame_and_can_revert() {
-        let mut session = figcraft_engine::Session::new();
-        let frame = id(&session.execute("node.create", &json!({"type": "frame", "width": 894, "height": 844})).unwrap());
-        let right = id(&session
-            .execute("node.create", &json!({"type": "rectangle", "parent": frame, "x": 804, "y": 20, "width": 80, "height": 40}))
-            .unwrap());
-        session.execute("node.set", &json!({"id": right, "props": {"constraints": {"horizontal": "right", "vertical": "top"}}})).unwrap();
-        let mut ui = Ui::new(session);
-        ui.run("proto.present", json!({"start": frame}));
-
-        let mut presenter = ui.app.ui.present.take().unwrap();
-        presenter.pan = Some((100.0, 200.0));
-        presenter.scroll.insert(frame, (75.0, 50.0));
-        choose_device(&mut ui.app, &mut presenter, "iPhone 17");
-        assert!(presenter.pan.is_none() && presenter.scroll.is_empty());
-        ui.app.ui.present = Some(presenter);
-        ui.frame(vec![]);
-
-        let shown = &ui.app.ui.present.as_ref().unwrap().doc.as_ref().unwrap();
-        assert_eq!((shown.node(frame).unwrap().width, shown.node(frame).unwrap().height), (402.0, 874.0));
-        assert_eq!(shown.world_bounds(right).unwrap().x0, 312.0, "right constraint follows the phone edge");
-        assert_eq!(ui.app.inspect()["presenter"]["viewport"], json!([402.0, 874.0]));
-        assert_eq!(ui.app.inspect()["presenter"]["scrollRange"], json!([0.0, 0.0]));
-        assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0, "the saved design keeps its geometry");
-
-        let area = Rect::from_min_max(pos2(0.0, 40.0), pos2(1440.0, 900.0));
-        let screen_before = layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen;
-        ui.button(pos2(720.0, 440.0), true);
-        ui.frame(vec![egui::Event::PointerMoved(pos2(300.0, 300.0))]);
-        ui.button(pos2(300.0, 300.0), false);
-        assert_eq!(ui.app.inspect()["presenter"]["scroll"], json!([0.0, 0.0]), "fitted content does not move");
-        assert_eq!(layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen, screen_before);
-
-        let mut presenter = ui.app.ui.present.take().unwrap();
-        choose_device(&mut ui.app, &mut presenter, "None");
-        ui.app.ui.present = Some(presenter);
-        ui.frame(vec![]);
-        assert_eq!(ui.app.inspect()["presenter"]["frameSize"], json!([894.0, 844.0]));
-        assert_eq!(ui.app.inspect()["presenter"]["responsive"], Value::Null);
-    }
-
-    #[test]
-    fn device_presets_show_their_screen_at_the_real_resolution_in_their_body() {
-        let mut session = figcraft_engine::Session::new();
-        let frame = id(&session.execute("node.create", &json!({"type": "frame", "width": 894, "height": 844})).unwrap());
-        let mut ui = Ui::new(session);
-        ui.run("proto.present", json!({"start": frame}));
-        let area = Rect::from_min_max(pos2(0.0, 40.0), pos2(1440.0, 860.0));
-
-        for (name, width, height) in
-            [("iPad mini", 744.0, 1133.0), ("MacBook Air", 1280.0, 832.0), ("Desktop", 1440.0, 1024.0), ("iPhone 17", 402.0, 874.0)]
-        {
-            let mut presenter = ui.app.ui.present.take().unwrap();
-            choose_device(&mut ui.app, &mut presenter, name);
-            ui.app.ui.present = Some(presenter);
-            ui.frame(vec![]);
-
-            let presenter = ui.app.ui.present.as_mut().unwrap();
-            let laid = layout(presenter, area, FULL).unwrap();
-            assert!(laid.color.is_some(), "{name}: drawn in its body");
-            assert!((f64::from(laid.screen.width()) / laid.scale - width).abs() < 0.1, "{name}: width");
-            assert!((f64::from(laid.screen.height()) / laid.scale - height).abs() < 0.1, "{name}: height");
-            assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0);
-        }
-    }
-
-    /// A phone shows a frame's content past its screen only as far as the frame's overflow lets it
-    /// scroll: with "No scrolling" it's clipped, like on every other device.
-    #[test]
-    fn a_phone_scrolls_only_what_the_frames_overflow_allows() {
-        let on_phone = |overflow: &str| {
-            let mut session = figcraft_engine::Session::new();
-            let frame = id(&session.execute("node.create", &json!({"type": "frame", "width": 894, "height": 844})).unwrap());
-            session.execute("node.create", &json!({"type": "rectangle", "parent": frame, "x": 650, "y": 1050, "width": 80, "height": 80})).unwrap();
-            session.execute("node.set", &json!({"id": frame, "props": {"overflow": overflow}})).unwrap();
-            let mut ui = Ui::new(session);
-            ui.run("proto.present", json!({"start": frame}));
-            let mut presenter = ui.app.ui.present.take().unwrap();
-            choose_device(&mut ui.app, &mut presenter, "iPhone 17");
-            ui.app.ui.present = Some(presenter);
-            ui.frame(vec![]);
-            (ui, frame)
-        };
-        let start = pos2(720.0, 440.0);
-        let drag = |ui: &mut Ui, to: Pos2| {
-            ui.button(start, true);
-            ui.frame(vec![egui::Event::PointerMoved(to)]);
-            ui.button(to, false);
-            ui.app.inspect()["presenter"].clone()
-        };
-
-        let (mut ui, frame) = on_phone("none");
-        assert_eq!(ui.app.inspect()["presenter"]["scrollRange"], json!([0.0, 0.0]));
-        assert_eq!(drag(&mut ui, start - vec2(100.0, 120.0))["scroll"], json!([0.0, 0.0]), "no scrolling stays clipped");
-        assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0);
-
-        let (mut ui, frame) = on_phone("both");
-        let range = &ui.app.inspect()["presenter"]["scrollRange"];
-        assert!(range[0].as_f64().unwrap() > 0.0 && range[1].as_f64().unwrap() > 0.0, "{range}");
-        let scroll = drag(&mut ui, start - vec2(100.0, 120.0))["scroll"].clone();
-        assert!(scroll[0].as_f64().unwrap() > 0.0 && scroll[1].as_f64().unwrap() > 0.0, "{scroll}");
-        assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0);
-
-        // The content keeps following a drag after the pointer leaves the screen, while the
-        // device itself stays fixed on the stage.
-        ui.frames(60, Vec::new);
-        let area = Rect::from_min_max(pos2(0.0, 40.0), pos2(1440.0, 900.0));
-        let screen_before = layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen;
-        ui.button(start, true);
-        ui.frame(vec![egui::Event::PointerMoved(pos2(300.0, 300.0))]);
-        let during = ui.app.inspect()["presenter"].clone();
-        assert!(during["scroll"][0].as_f64().unwrap() > 0.0, "{during}");
-        assert_eq!(layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen, screen_before);
-        ui.button(pos2(300.0, 300.0), false);
-    }
-
-    fn doc_with_two_frames() -> (Document, NodeId, NodeId) {
-        let mut d = Document::new("t");
-        let page = d.add_page("Page 1");
-        let a = d.create(page, NodeKind::Frame, "A", 0.0, 0.0, 200.0, 400.0).unwrap();
-        let b = d.create(page, NodeKind::Frame, "B", 300.0, 0.0, 200.0, 400.0).unwrap();
-        (d, a, b)
-    }
-
-    #[test]
-    fn closed_overlays_animate_out_unless_instant() {
-        let (_, a, b) = doc_with_two_frames();
-        let mut p = Presenter::new(a);
-        let ov = |transition, opened| OverlayState {
-            id: b,
-            position: OverlayPosition::Center,
-            close_on_outside: true,
-            background: None,
-            anchor: None,
-            offset: None,
-            anchor_to: OverlayAnchor::Screen,
-            opened,
-            transition,
-            dur: 0.3,
-            easing: Easing::EaseOut,
-        };
-        p.overlays.push(ov(Transition::Dissolve, 0.0));
-        assert!(p.close_overlay(10.0));
-        assert!(p.overlays.is_empty());
-        assert_eq!(p.closing.len(), 1);
-        assert_eq!(p.closing[0].0, 10.0, "fully open: the reverse starts now");
-        // Closed half way through opening: it reverses from there.
-        p.overlays.push(ov(Transition::Dissolve, 20.0));
-        p.close_overlay(20.15);
-        assert!((p.closing[1].0 - 20.0).abs() < 1e-9);
-        // Instant overlays just go.
-        p.overlays.push(ov(Transition::Instant, 30.0));
-        p.close_overlay(31.0);
-        assert_eq!(p.closing.len(), 2);
-        assert!(!p.close_overlay(32.0), "nothing left to close");
-    }
-
-    #[test]
-    fn matching_by_name_path() {
-        let (mut d, a, b) = doc_with_two_frames();
-        let ga = d.create(a, NodeKind::Group, "Card", 0.0, 0.0, 10.0, 10.0).unwrap();
-        let ra = d.create(ga, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
-        let ra2 = d.create(ga, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
-        let only_a = d.create(a, NodeKind::Rectangle, "Gone", 0.0, 0.0, 10.0, 10.0).unwrap();
-        let gb = d.create(b, NodeKind::Group, "Card", 0.0, 0.0, 10.0, 10.0).unwrap();
-        let rb = d.create(gb, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
-        let rb2 = d.create(gb, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
-        // Same name, different parent: no match.
-        let _other = d.create(b, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
-        let m = match_layers(&d, a, &d, b);
-        assert_eq!(m, vec![(ga, gb), (ra, rb), (ra2, rb2)]);
-        assert!(!m.iter().any(|(f, _)| *f == only_a));
-        assert_eq!(name_path(&d, a, ra).as_deref(), Some("Card\u{1f}Box"));
-        assert_eq!(name_path(&d, b, ra), None);
-    }
-
-    #[test]
-    fn smart_interpolate_tweens_matched_and_fades_the_rest() {
-        let (mut d, a, b) = doc_with_two_frames();
-        let ra = d.create(a, NodeKind::Rectangle, "Box", 0.0, 0.0, 20.0, 20.0).unwrap();
-        let rb = d.create(b, NodeKind::Rectangle, "Box", 100.0, 200.0, 60.0, 40.0).unwrap();
-        {
-            let n = d.get_mut(ra).unwrap();
-            n.fills = vec![Paint::solid(Color::new(1.0, 0.0, 0.0, 1.0))];
-            n.corners.radii = [0.0; 4];
-            n.opacity = 1.0;
-        }
-        {
-            let n = d.get_mut(rb).unwrap();
-            n.fills = vec![Paint::solid(Color::new(0.0, 0.0, 1.0, 1.0))];
-            n.corners.radii = [20.0; 4];
-            n.opacity = 0.5;
-            // Rotate 90° about its centre.
-            let c = (130.0, 220.0);
-            n.transform = Affine::translate(c) * Affine::rotate(std::f64::consts::FRAC_PI_2) * Affine::translate((-30.0, -20.0));
-        }
-        let only_b = d.create(b, NodeKind::Rectangle, "New", 0.0, 0.0, 5.0, 5.0);
-        let only_a = d.create(a, NodeKind::Rectangle, "Old", 0.0, 0.0, 5.0, 5.0).unwrap();
-        let mid = smart_interpolate(&d, a, &d, b, 0.5);
-        let n = mid.node(rb).unwrap();
-        assert!((n.width - 40.0).abs() < 1e-9 && (n.height - 30.0).abs() < 1e-9);
-        assert!((n.opacity - 0.75).abs() < 1e-6);
-        assert!((n.corners.radii[0] - 10.0).abs() < 1e-9);
-        let c = n.fills[0].solid_color().unwrap();
-        assert!((c.r - 0.5).abs() < 0.02 && (c.b - 0.5).abs() < 0.02, "{c:?}");
-        // Centre halfway between (10, 10) and (130, 220) in frame space; rotated 45°.
-        let ctr = mid.world_transform(b).inverse() * mid.world_transform(rb) * Point::new(n.width / 2.0, n.height / 2.0);
-        assert!((ctr.x - 70.0).abs() < 1e-6 && (ctr.y - 115.0).abs() < 1e-6, "{ctr:?}");
-        let [aa, bb, ..] = n.transform.as_coeffs();
-        assert!((bb.atan2(aa) - std::f64::consts::FRAC_PI_4).abs() < 1e-6);
-        if let Ok(ob) = only_b {
-            assert!((mid.node(ob).unwrap().opacity - 0.5).abs() < 1e-6);
-        }
-        // The source-only layer is copied into the destination frame, half faded.
-        let copies: Vec<_> = mid.node(b).unwrap().children.iter().filter_map(|c| mid.node(*c)).filter(|n| n.name == "Old").collect();
-        assert_eq!(copies.len(), 1);
-        assert!((copies[0].opacity - 0.5).abs() < 1e-6);
-        assert_ne!(copies[0].id, only_a);
-        // At the end it is exactly the destination.
-        let end = smart_interpolate(&d, a, &d, b, 1.0);
-        assert_eq!(end.node(rb), d.node(rb));
-        assert_eq!(end.node(b).unwrap().children, d.node(b).unwrap().children);
-        // At the start the matched layer sits where the source was.
-        let start = smart_interpolate(&d, a, &d, b, 0.0);
-        let s = start.world_bounds(rb).unwrap();
-        let f = start.world_bounds(b).unwrap();
-        assert!((s.x0 - f.x0).abs() < 1e-6 && (s.y0 - f.y0).abs() < 1e-6 && (s.width() - 20.0).abs() < 1e-6);
-    }
-
-    #[test]
-    fn scroll_offsets_fixed_and_sticky() {
-        let (mut d, a, _) = doc_with_two_frames();
-        d.get_mut(a).unwrap().overflow = Overflow::Vertical;
-        let long = d.create(a, NodeKind::Rectangle, "Long", 0.0, 0.0, 200.0, 1000.0).unwrap();
-        let fixed = d.create(a, NodeKind::Rectangle, "Bar", 0.0, 350.0, 200.0, 50.0).unwrap();
-        let sticky = d.create(a, NodeKind::Rectangle, "Header", 0.0, 100.0, 200.0, 40.0).unwrap();
-        d.get_mut(fixed).unwrap().scroll_position = ScrollPosition::Fixed;
-        d.get_mut(sticky).unwrap().scroll_position = ScrollPosition::Sticky;
-        assert_eq!(scroll_range(&d, a), (0.0, 600.0));
-        d.get_mut(a).unwrap().overflow = Overflow::Horizontal;
-        assert_eq!(scroll_range(&d, a), (0.0, 0.0));
-        d.get_mut(a).unwrap().overflow = Overflow::Vertical;
-        let mut s = HashMap::new();
-        s.insert(a, (0.0, 50.0));
-        let out = apply_scroll(&d, &s);
-        let y = |doc: &Document, id| doc.world_bounds(id).unwrap().y0;
-        assert_eq!(y(&out, long), -50.0);
-        assert_eq!(y(&out, fixed), 350.0);
-        assert_eq!(y(&out, sticky), 50.0);
-        s.insert(a, (0.0, 300.0));
-        let out = apply_scroll(&d, &s);
-        assert_eq!(y(&out, long), -300.0);
-        assert_eq!(y(&out, sticky), 0.0);
-    }
-
-    /// A page presented on an iPhone 16 (393×852): a tall screen A that scrolls vertically, with a
-    /// tab bar fixed to its bottom, a nested scrolling list and a layer at its end; screen B.
-    fn device_doc() -> (Document, NodeId, NodeId, NodeId, NodeId, NodeId) {
-        let mut d = Document::new("t");
-        let page = d.add_page("Page 1");
-        if let NodeKind::Page { prototype, .. } = &mut d.get_mut(page).unwrap().kind {
-            prototype.device = "iPhone 16".into();
-        }
-        let a = d.create(page, NodeKind::Frame, "A", 0.0, 0.0, 393.0, 2000.0).unwrap();
-        let b = d.create(page, NodeKind::Frame, "B", 500.0, 0.0, 393.0, 1500.0).unwrap();
-        for f in [a, b] {
-            d.get_mut(f).unwrap().overflow = Overflow::Vertical;
-        }
-        let bar = d.create(a, NodeKind::Rectangle, "Tab bar", 0.0, 1940.0, 393.0, 60.0).unwrap();
-        let n = d.get_mut(bar).unwrap();
-        n.scroll_position = ScrollPosition::Fixed;
-        n.constraints.vertical = VConstraint::Bottom;
-        let list = d.create(a, NodeKind::Frame, "List", 0.0, 1200.0, 393.0, 300.0).unwrap();
-        d.get_mut(list).unwrap().overflow = Overflow::Vertical;
-        let item = d.create(list, NodeKind::Rectangle, "Item", 0.0, 700.0, 393.0, 100.0).unwrap();
-        (d, a, b, bar, list, item)
-    }
-
-    fn player_on(d: Document, start: NodeId) -> Presenter {
-        let mut p = Presenter::new(start);
-        p.sync(&Arc::new(d), 0.0);
-        p
-    }
-
-    #[test]
-    fn device_screen_clips_the_frame_and_it_scrolls_through_its_height() {
-        let (mut d, a, _, bar, list, _) = device_doc();
-        assert_eq!(viewport(&d, a), Some((393.0, 852.0)));
-        // On the device the whole frame scrolls; at its own size nothing overflows it.
-        assert_eq!(scroll_range_in(&d, a, viewport(&d, a)), (0.0, 1148.0));
-        assert_eq!(scroll_range(&d, a), (0.0, 0.0));
-        // Nested frames scroll within themselves.
-        assert_eq!(scroll_range(&d, list), (0.0, 500.0));
-        // The display copy is sized to the screen; the fixed tab bar moves to the screen's bottom.
-        let mut p = player_on(d.clone(), a);
-        let disp = p.display().unwrap();
-        assert_eq!((disp.node(a).unwrap().width, disp.node(a).unwrap().height), (393.0, 852.0));
-        assert_eq!(disp.world_bounds(bar).unwrap().y0, 792.0);
-        // Scrolled, it stays there while the content moves.
-        p.scroll_to(0.0, 400.0);
-        let disp = p.display().unwrap();
-        assert_eq!(disp.world_bounds(bar).unwrap().y0, 792.0);
-        assert_eq!(disp.world_bounds(list).unwrap().y0, 800.0);
-        p.scroll_to(0.0, 99_999.0);
-        assert_eq!(p.scroll[&a], (0.0, 1148.0), "clamped to the range");
-        // A top-level frame taller than the screen scrolls without an overflow setting (its own
-        // range still clips nested content); without a device the frame shows whole.
-        d.get_mut(a).unwrap().overflow = Overflow::None;
-        assert_eq!(scroll_range_in(&d, a, viewport(&d, a)), (0.0, 1148.0));
-        assert_eq!(scroll_range(&d, a), (0.0, 0.0));
-        if let Some(pg) = d.page_of(a)
-            && let NodeKind::Page { prototype, .. } = &mut d.get_mut(pg).unwrap().kind
-        {
-            prototype.device = "None".into();
-        }
-        assert_eq!(viewport(&d, a), None);
-        // A frame wider than the screen scrolls sideways when it scrolls both ways.
-        let (mut d, a, ..) = device_doc();
-        let n = d.get_mut(a).unwrap();
-        n.width = 800.0;
-        n.overflow = Overflow::Both;
-        assert_eq!(scroll_range_in(&d, a, viewport(&d, a)), (407.0, 1148.0));
-    }
-
-    #[test]
-    fn scroll_to_moves_every_scrolling_frame_around_the_layer() {
-        let (d, a, _, _, list, item) = device_doc();
-        let mut p = player_on(d.clone(), a);
-        assert!(p.perform(&Action::ScrollTo { dest: item, offset: [0.0, 0.0] }, item, Transition::Instant, 0.0, Easing::Linear, None, 1.0));
-        // The list brings the item to its top (as far as it scrolls), the screen brings the list.
-        assert_eq!(p.scroll[&list], (0.0, 500.0));
-        assert_eq!(p.scroll[&a], (0.0, 1148.0));
-        // Animated, it gets there over the duration.
-        let mut p = player_on(d, a);
-        assert!(p.perform(&Action::ScrollTo { dest: list, offset: [0.0, 0.0] }, list, Transition::Dissolve, 0.3, Easing::Linear, None, 1.0));
-        let anim = p.scroll_anim.as_ref().unwrap();
-        assert_eq!(anim.frames, vec![(a, (0.0, 0.0), (0.0, 1148.0))]);
-    }
-
-    #[test]
-    fn navigating_resets_scroll_unless_it_preserves_it() {
-        let (d, a, b, ..) = device_doc();
-        let mut p = player_on(d, a);
-        p.scroll_to(0.0, 600.0);
-        assert!(p.perform(&Action::Navigate { dest: b, preserve_scroll: false }, a, Transition::Instant, 0.0, Easing::Linear, None, 1.0));
-        assert_eq!(p.scroll.get(&b), None, "starts at the top");
-        p.restart(a, 2.0);
-        p.scroll_to(0.0, 1000.0);
-        assert!(p.perform(&Action::Navigate { dest: b, preserve_scroll: true }, a, Transition::Instant, 0.0, Easing::Linear, None, 3.0));
-        assert_eq!(p.scroll[&b], (0.0, 648.0), "kept, as far as B scrolls");
-        // Back starts at the top again.
-        assert!(p.perform(&Action::Back, b, Transition::Instant, 0.0, Easing::Linear, None, 4.0));
-        assert_eq!((p.current, p.scroll.get(&a)), (a, None));
-    }
-
-    #[test]
-    fn sync_follows_edits_and_keeps_the_screen() {
-        let (mut d, a, b, _, list, _) = device_doc();
-        let mut p = player_on(d.clone(), a);
-        p.go(b, Transition::Instant, 0.0, Easing::Linear, 1.0, true, false);
-        p.scroll_to(0.0, 600.0);
-        // The same document again changes nothing.
-        let same = Arc::new(d.clone());
-        p.sync(&same, 2.0);
-        let rev = p.rev;
-        p.sync(&same, 2.0);
-        assert_eq!(p.rev, rev);
-        // An edit is copied; the screen and its scroll stay (clamped to the new range).
-        d.get_mut(b).unwrap().height = 1000.0;
-        d.get_mut(b).unwrap().name = "B2".into();
-        p.sync(&Arc::new(d.clone()), 3.0);
-        assert_eq!(p.current, b);
-        assert_eq!(p.inspect()["name"], "B2");
-        assert_eq!(p.scroll[&b], (0.0, 148.0));
-        assert_eq!(p.history.len(), 1);
-        // The screen deleted: back to the start.
-        d.remove(b).unwrap();
-        p.sync(&Arc::new(d.clone()), 4.0);
-        assert_eq!(p.current, a);
-        assert!(p.history.is_empty() && p.scroll.is_empty());
-        // Junk scroll offsets never panic and stay in range.
-        p.scroll.insert(list, (f64::NAN, f64::INFINITY));
-        p.sync(&Arc::new(d), 5.0);
-        assert_eq!(p.scroll[&list], (0.0, 0.0));
-    }
-
-    #[test]
-    fn transitions_move_the_right_way() {
-        let left = transition_frames(Transition::MoveIn { direction: Direction::Left }, 0.0);
-        assert_eq!(left.to_off, (1.0, 0.0));
-        assert_eq!(transition_frames(Transition::MoveIn { direction: Direction::Left }, 1.0).to_off, (0.0, 0.0));
-        let push = transition_frames(Transition::Push { direction: Direction::Top }, 0.5);
-        assert_eq!(push.from_off, (0.0, -0.5));
-        assert_eq!(push.to_off, (0.0, 0.5));
-        let out = transition_frames(Transition::MoveOut { direction: Direction::Right }, 0.25);
-        assert!(out.from_on_top);
-        assert_eq!(out.from_off, (0.25, 0.0));
-        assert_eq!(transition_frames(Transition::Dissolve, 0.3).to_alpha, 0.3);
-        assert_eq!(transition_frames(Transition::Instant, 0.0).from_alpha, 0.0);
-        let r = Transition::SlideIn { direction: Direction::Bottom }.reversed();
-        assert_eq!(r, Transition::SlideOut { direction: Direction::Top });
-    }
-
-    #[test]
-    fn overlay_positions() {
-        let base = Rect::from_min_size(pos2(0.0, 0.0), vec2(400.0, 800.0));
-        let size = vec2(200.0, 100.0);
-        assert_eq!(overlay_rect(OverlayPosition::Center, base, size, None, None).min, pos2(100.0, 350.0));
-        assert_eq!(overlay_rect(OverlayPosition::BottomCenter, base, size, None, None).min, pos2(100.0, 700.0));
-        assert_eq!(overlay_rect(OverlayPosition::TopRight, base, size, None, None).min, pos2(200.0, 0.0));
-        let anchor = Rect::from_min_size(pos2(30.0, 40.0), vec2(50.0, 20.0));
-        assert_eq!(overlay_rect(OverlayPosition::Manual, base, size, Some(anchor), None).min, pos2(30.0, 60.0));
-    }
-
-    /// Smart animate renders a temporary document per animation frame; keep that cheap.
-    #[test]
-    fn smart_animate_frame_cost() {
-        let (mut d, a, b) = doc_with_two_frames();
-        for (f, dx) in [(a, 0.0), (b, 40.0)] {
-            for i in 0..40 {
-                let r = d.create(f, NodeKind::Rectangle, &format!("Row {i}"), dx + 10.0, 10.0 + f64::from(i) * 9.0, 120.0, 8.0).unwrap();
-                d.get_mut(r).unwrap().corners.radii = [4.0; 4];
-            }
-        }
-        let t0 = std::time::Instant::now();
-        let n = 10;
-        for k in 0..n {
-            let tmp = smart_interpolate(&d, a, &d, b, f64::from(k) / f64::from(n));
-            assert!(figcraft_render::render_node(&tmp, b, 2.0).is_some());
-        }
-        let per = t0.elapsed().as_secs_f64() * 1000.0 / f64::from(n);
-        eprintln!("smart animate: {per:.2} ms per frame (80 layers, 400x800 px)");
-    }
-}
+mod tests;
diff --git a/crates/ui-egui/src/present/tests.rs b/crates/ui-egui/src/present/tests.rs
new file mode 100644
index 00000000..bba99878
--- /dev/null
+++ b/crates/ui-egui/src/present/tests.rs
@@ -0,0 +1,438 @@
+use super::*;
+use figcraft_doc::NodeKind;
+
+use crate::present_tests::{Ui, id};
+
+#[test]
+fn device_picker_reflows_without_resizing_the_saved_frame_and_can_revert() {
+    let mut session = figcraft_engine::Session::new();
+    let frame = id(&session.execute("node.create", &json!({"type": "frame", "width": 894, "height": 844})).unwrap());
+    let right =
+        id(&session.execute("node.create", &json!({"type": "rectangle", "parent": frame, "x": 804, "y": 20, "width": 80, "height": 40})).unwrap());
+    session.execute("node.set", &json!({"id": right, "props": {"constraints": {"horizontal": "right", "vertical": "top"}}})).unwrap();
+    let mut ui = Ui::new(session);
+    ui.run("proto.present", json!({"start": frame}));
+
+    let mut presenter = ui.app.ui.present.take().unwrap();
+    presenter.pan = Some((100.0, 200.0));
+    presenter.scroll.insert(frame, (75.0, 50.0));
+    choose_device(&mut ui.app, &mut presenter, "iPhone 17");
+    assert!(presenter.pan.is_none() && presenter.scroll.is_empty());
+    ui.app.ui.present = Some(presenter);
+    ui.frame(vec![]);
+
+    let shown = &ui.app.ui.present.as_ref().unwrap().doc.as_ref().unwrap();
+    assert_eq!((shown.node(frame).unwrap().width, shown.node(frame).unwrap().height), (402.0, 874.0));
+    assert_eq!(shown.world_bounds(right).unwrap().x0, 312.0, "right constraint follows the phone edge");
+    assert_eq!(ui.app.inspect()["presenter"]["viewport"], json!([402.0, 874.0]));
+    assert_eq!(ui.app.inspect()["presenter"]["scrollRange"], json!([0.0, 0.0]));
+    assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0, "the saved design keeps its geometry");
+
+    let area = Rect::from_min_max(pos2(0.0, 40.0), pos2(1440.0, 900.0));
+    let screen_before = layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen;
+    ui.button(pos2(720.0, 440.0), true);
+    ui.frame(vec![egui::Event::PointerMoved(pos2(300.0, 300.0))]);
+    ui.button(pos2(300.0, 300.0), false);
+    assert_eq!(ui.app.inspect()["presenter"]["scroll"], json!([0.0, 0.0]), "fitted content does not move");
+    assert_eq!(layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen, screen_before);
+
+    let mut presenter = ui.app.ui.present.take().unwrap();
+    choose_device(&mut ui.app, &mut presenter, "None");
+    ui.app.ui.present = Some(presenter);
+    ui.frame(vec![]);
+    assert_eq!(ui.app.inspect()["presenter"]["frameSize"], json!([894.0, 844.0]));
+    assert_eq!(ui.app.inspect()["presenter"]["responsive"], Value::Null);
+}
+
+#[test]
+fn device_presets_show_their_screen_at_the_real_resolution_in_their_body() {
+    let mut session = figcraft_engine::Session::new();
+    let frame = id(&session.execute("node.create", &json!({"type": "frame", "width": 894, "height": 844})).unwrap());
+    let mut ui = Ui::new(session);
+    ui.run("proto.present", json!({"start": frame}));
+    let area = Rect::from_min_max(pos2(0.0, 40.0), pos2(1440.0, 860.0));
+
+    for (name, width, height) in
+        [("iPad mini", 744.0, 1133.0), ("MacBook Air", 1280.0, 832.0), ("Desktop", 1440.0, 1024.0), ("iPhone 17", 402.0, 874.0)]
+    {
+        let mut presenter = ui.app.ui.present.take().unwrap();
+        choose_device(&mut ui.app, &mut presenter, name);
+        ui.app.ui.present = Some(presenter);
+        ui.frame(vec![]);
+
+        let presenter = ui.app.ui.present.as_mut().unwrap();
+        let laid = layout(presenter, area, FULL).unwrap();
+        assert!(laid.color.is_some(), "{name}: drawn in its body");
+        assert!((f64::from(laid.screen.width()) / laid.scale - width).abs() < 0.1, "{name}: width");
+        assert!((f64::from(laid.screen.height()) / laid.scale - height).abs() < 0.1, "{name}: height");
+        assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0);
+    }
+}
+
+/// A phone shows a frame's content past its screen only as far as the frame's overflow lets it
+/// scroll: with "No scrolling" it's clipped, like on every other device.
+#[test]
+fn a_phone_scrolls_only_what_the_frames_overflow_allows() {
+    let on_phone = |overflow: &str| {
+        let mut session = figcraft_engine::Session::new();
+        let frame = id(&session.execute("node.create", &json!({"type": "frame", "width": 894, "height": 844})).unwrap());
+        session.execute("node.create", &json!({"type": "rectangle", "parent": frame, "x": 650, "y": 1050, "width": 80, "height": 80})).unwrap();
+        session.execute("node.set", &json!({"id": frame, "props": {"overflow": overflow}})).unwrap();
+        let mut ui = Ui::new(session);
+        ui.run("proto.present", json!({"start": frame}));
+        let mut presenter = ui.app.ui.present.take().unwrap();
+        choose_device(&mut ui.app, &mut presenter, "iPhone 17");
+        ui.app.ui.present = Some(presenter);
+        ui.frame(vec![]);
+        (ui, frame)
+    };
+    let start = pos2(720.0, 440.0);
+    let drag = |ui: &mut Ui, to: Pos2| {
+        ui.button(start, true);
+        ui.frame(vec![egui::Event::PointerMoved(to)]);
+        ui.button(to, false);
+        ui.app.inspect()["presenter"].clone()
+    };
+
+    let (mut ui, frame) = on_phone("none");
+    assert_eq!(ui.app.inspect()["presenter"]["scrollRange"], json!([0.0, 0.0]));
+    assert_eq!(drag(&mut ui, start - vec2(100.0, 120.0))["scroll"], json!([0.0, 0.0]), "no scrolling stays clipped");
+    assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0);
+
+    let (mut ui, frame) = on_phone("both");
+    let range = &ui.app.inspect()["presenter"]["scrollRange"];
+    assert!(range[0].as_f64().unwrap() > 0.0 && range[1].as_f64().unwrap() > 0.0, "{range}");
+    let scroll = drag(&mut ui, start - vec2(100.0, 120.0))["scroll"].clone();
+    assert!(scroll[0].as_f64().unwrap() > 0.0 && scroll[1].as_f64().unwrap() > 0.0, "{scroll}");
+    assert_eq!(ui.app.session.doc().unwrap().node(frame).unwrap().width, 894.0);
+
+    // The content keeps following a drag after the pointer leaves the screen, while the
+    // device itself stays fixed on the stage.
+    ui.frames(60, Vec::new);
+    let area = Rect::from_min_max(pos2(0.0, 40.0), pos2(1440.0, 900.0));
+    let screen_before = layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen;
+    ui.button(start, true);
+    ui.frame(vec![egui::Event::PointerMoved(pos2(300.0, 300.0))]);
+    let during = ui.app.inspect()["presenter"].clone();
+    assert!(during["scroll"][0].as_f64().unwrap() > 0.0, "{during}");
+    assert_eq!(layout(ui.app.ui.present.as_mut().unwrap(), area, FULL).unwrap().screen, screen_before);
+    ui.button(pos2(300.0, 300.0), false);
+}
+
+fn doc_with_two_frames() -> (Document, NodeId, NodeId) {
+    let mut d = Document::new("t");
+    let page = d.add_page("Page 1");
+    let a = d.create(page, NodeKind::Frame, "A", 0.0, 0.0, 200.0, 400.0).unwrap();
+    let b = d.create(page, NodeKind::Frame, "B", 300.0, 0.0, 200.0, 400.0).unwrap();
+    (d, a, b)
+}
+
+#[test]
+fn closed_overlays_animate_out_unless_instant() {
+    let (_, a, b) = doc_with_two_frames();
+    let mut p = Presenter::new(a);
+    let ov = |transition, opened| OverlayState {
+        id: b,
+        position: OverlayPosition::Center,
+        close_on_outside: true,
+        background: None,
+        anchor: None,
+        offset: None,
+        anchor_to: OverlayAnchor::Screen,
+        opened,
+        transition,
+        dur: 0.3,
+        easing: Easing::EaseOut,
+    };
+    p.overlays.push(ov(Transition::Dissolve, 0.0));
+    assert!(p.close_overlay(10.0));
+    assert!(p.overlays.is_empty());
+    assert_eq!(p.closing.len(), 1);
+    assert_eq!(p.closing[0].0, 10.0, "fully open: the reverse starts now");
+    // Closed half way through opening: it reverses from there.
+    p.overlays.push(ov(Transition::Dissolve, 20.0));
+    p.close_overlay(20.15);
+    assert!((p.closing[1].0 - 20.0).abs() < 1e-9);
+    // Instant overlays just go.
+    p.overlays.push(ov(Transition::Instant, 30.0));
+    p.close_overlay(31.0);
+    assert_eq!(p.closing.len(), 2);
+    assert!(!p.close_overlay(32.0), "nothing left to close");
+}
+
+#[test]
+fn matching_by_name_path() {
+    let (mut d, a, b) = doc_with_two_frames();
+    let ga = d.create(a, NodeKind::Group, "Card", 0.0, 0.0, 10.0, 10.0).unwrap();
+    let ra = d.create(ga, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
+    let ra2 = d.create(ga, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
+    let only_a = d.create(a, NodeKind::Rectangle, "Gone", 0.0, 0.0, 10.0, 10.0).unwrap();
+    let gb = d.create(b, NodeKind::Group, "Card", 0.0, 0.0, 10.0, 10.0).unwrap();
+    let rb = d.create(gb, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
+    let rb2 = d.create(gb, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
+    // Same name, different parent: no match.
+    let _other = d.create(b, NodeKind::Rectangle, "Box", 0.0, 0.0, 10.0, 10.0).unwrap();
+    let m = match_layers(&d, a, &d, b);
+    assert_eq!(m, vec![(ga, gb), (ra, rb), (ra2, rb2)]);
+    assert!(!m.iter().any(|(f, _)| *f == only_a));
+    assert_eq!(name_path(&d, a, ra).as_deref(), Some("Card\u{1f}Box"));
+    assert_eq!(name_path(&d, b, ra), None);
+}
+
+#[test]
+fn smart_interpolate_tweens_matched_and_fades_the_rest() {
+    let (mut d, a, b) = doc_with_two_frames();
+    let ra = d.create(a, NodeKind::Rectangle, "Box", 0.0, 0.0, 20.0, 20.0).unwrap();
+    let rb = d.create(b, NodeKind::Rectangle, "Box", 100.0, 200.0, 60.0, 40.0).unwrap();
+    {
+        let n = d.get_mut(ra).unwrap();
+        n.fills = vec![Paint::solid(Color::new(1.0, 0.0, 0.0, 1.0))];
+        n.corners.radii = [0.0; 4];
+        n.opacity = 1.0;
+    }
+    {
+        let n = d.get_mut(rb).unwrap();
+        n.fills = vec![Paint::solid(Color::new(0.0, 0.0, 1.0, 1.0))];
+        n.corners.radii = [20.0; 4];
+        n.opacity = 0.5;
+        // Rotate 90° about its centre.
+        let c = (130.0, 220.0);
+        n.transform = Affine::translate(c) * Affine::rotate(std::f64::consts::FRAC_PI_2) * Affine::translate((-30.0, -20.0));
+    }
+    let only_b = d.create(b, NodeKind::Rectangle, "New", 0.0, 0.0, 5.0, 5.0);
+    let only_a = d.create(a, NodeKind::Rectangle, "Old", 0.0, 0.0, 5.0, 5.0).unwrap();
+    let mid = smart_interpolate(&d, a, &d, b, 0.5);
+    let n = mid.node(rb).unwrap();
+    assert!((n.width - 40.0).abs() < 1e-9 && (n.height - 30.0).abs() < 1e-9);
+    assert!((n.opacity - 0.75).abs() < 1e-6);
+    assert!((n.corners.radii[0] - 10.0).abs() < 1e-9);
+    let c = n.fills[0].solid_color().unwrap();
+    assert!((c.r - 0.5).abs() < 0.02 && (c.b - 0.5).abs() < 0.02, "{c:?}");
+    // Centre halfway between (10, 10) and (130, 220) in frame space; rotated 45°.
+    let ctr = mid.world_transform(b).inverse() * mid.world_transform(rb) * Point::new(n.width / 2.0, n.height / 2.0);
+    assert!((ctr.x - 70.0).abs() < 1e-6 && (ctr.y - 115.0).abs() < 1e-6, "{ctr:?}");
+    let [aa, bb, ..] = n.transform.as_coeffs();
+    assert!((bb.atan2(aa) - std::f64::consts::FRAC_PI_4).abs() < 1e-6);
+    if let Ok(ob) = only_b {
+        assert!((mid.node(ob).unwrap().opacity - 0.5).abs() < 1e-6);
+    }
+    // The source-only layer is copied into the destination frame, half faded.
+    let copies: Vec<_> = mid.node(b).unwrap().children.iter().filter_map(|c| mid.node(*c)).filter(|n| n.name == "Old").collect();
+    assert_eq!(copies.len(), 1);
+    assert!((copies[0].opacity - 0.5).abs() < 1e-6);
+    assert_ne!(copies[0].id, only_a);
+    // At the end it is exactly the destination.
+    let end = smart_interpolate(&d, a, &d, b, 1.0);
+    assert_eq!(end.node(rb), d.node(rb));
+    assert_eq!(end.node(b).unwrap().children, d.node(b).unwrap().children);
+    // At the start the matched layer sits where the source was.
+    let start = smart_interpolate(&d, a, &d, b, 0.0);
+    let s = start.world_bounds(rb).unwrap();
+    let f = start.world_bounds(b).unwrap();
+    assert!((s.x0 - f.x0).abs() < 1e-6 && (s.y0 - f.y0).abs() < 1e-6 && (s.width() - 20.0).abs() < 1e-6);
+}
+
+#[test]
+fn scroll_offsets_fixed_and_sticky() {
+    let (mut d, a, _) = doc_with_two_frames();
+    d.get_mut(a).unwrap().overflow = Overflow::Vertical;
+    let long = d.create(a, NodeKind::Rectangle, "Long", 0.0, 0.0, 200.0, 1000.0).unwrap();
+    let fixed = d.create(a, NodeKind::Rectangle, "Bar", 0.0, 350.0, 200.0, 50.0).unwrap();
+    let sticky = d.create(a, NodeKind::Rectangle, "Header", 0.0, 100.0, 200.0, 40.0).unwrap();
+    d.get_mut(fixed).unwrap().scroll_position = ScrollPosition::Fixed;
+    d.get_mut(sticky).unwrap().scroll_position = ScrollPosition::Sticky;
+    assert_eq!(scroll_range(&d, a), (0.0, 600.0));
+    d.get_mut(a).unwrap().overflow = Overflow::Horizontal;
+    assert_eq!(scroll_range(&d, a), (0.0, 0.0));
+    d.get_mut(a).unwrap().overflow = Overflow::Vertical;
+    let mut s = HashMap::new();
+    s.insert(a, (0.0, 50.0));
+    let out = apply_scroll(&d, &s);
+    let y = |doc: &Document, id| doc.world_bounds(id).unwrap().y0;
+    assert_eq!(y(&out, long), -50.0);
+    assert_eq!(y(&out, fixed), 350.0);
+    assert_eq!(y(&out, sticky), 50.0);
+    s.insert(a, (0.0, 300.0));
+    let out = apply_scroll(&d, &s);
+    assert_eq!(y(&out, long), -300.0);
+    assert_eq!(y(&out, sticky), 0.0);
+}
+
+/// A page presented on an iPhone 16 (393×852): a tall screen A that scrolls vertically, with a
+/// tab bar fixed to its bottom, a nested scrolling list and a layer at its end; screen B.
+fn device_doc() -> (Document, NodeId, NodeId, NodeId, NodeId, NodeId) {
+    let mut d = Document::new("t");
+    let page = d.add_page("Page 1");
+    if let NodeKind::Page { prototype, .. } = &mut d.get_mut(page).unwrap().kind {
+        prototype.device = "iPhone 16".into();
+    }
+    let a = d.create(page, NodeKind::Frame, "A", 0.0, 0.0, 393.0, 2000.0).unwrap();
+    let b = d.create(page, NodeKind::Frame, "B", 500.0, 0.0, 393.0, 1500.0).unwrap();
+    for f in [a, b] {
+        d.get_mut(f).unwrap().overflow = Overflow::Vertical;
+    }
+    let bar = d.create(a, NodeKind::Rectangle, "Tab bar", 0.0, 1940.0, 393.0, 60.0).unwrap();
+    let n = d.get_mut(bar).unwrap();
+    n.scroll_position = ScrollPosition::Fixed;
+    n.constraints.vertical = VConstraint::Bottom;
+    let list = d.create(a, NodeKind::Frame, "List", 0.0, 1200.0, 393.0, 300.0).unwrap();
+    d.get_mut(list).unwrap().overflow = Overflow::Vertical;
+    let item = d.create(list, NodeKind::Rectangle, "Item", 0.0, 700.0, 393.0, 100.0).unwrap();
+    (d, a, b, bar, list, item)
+}
+
+fn player_on(d: Document, start: NodeId) -> Presenter {
+    let mut p = Presenter::new(start);
+    p.sync(&Arc::new(d), 0.0);
+    p
+}
+
+#[test]
+fn device_screen_clips_the_frame_and_it_scrolls_through_its_height() {
+    let (mut d, a, _, bar, list, _) = device_doc();
+    assert_eq!(viewport(&d, a), Some((393.0, 852.0)));
+    // On the device the whole frame scrolls; at its own size nothing overflows it.
+    assert_eq!(scroll_range_in(&d, a, viewport(&d, a)), (0.0, 1148.0));
+    assert_eq!(scroll_range(&d, a), (0.0, 0.0));
+    // Nested frames scroll within themselves.
+    assert_eq!(scroll_range(&d, list), (0.0, 500.0));
+    // The display copy is sized to the screen; the fixed tab bar moves to the screen's bottom.
+    let mut p = player_on(d.clone(), a);
+    let disp = p.display().unwrap();
+    assert_eq!((disp.node(a).unwrap().width, disp.node(a).unwrap().height), (393.0, 852.0));
+    assert_eq!(disp.world_bounds(bar).unwrap().y0, 792.0);
+    // Scrolled, it stays there while the content moves.
+    p.scroll_to(0.0, 400.0);
+    let disp = p.display().unwrap();
+    assert_eq!(disp.world_bounds(bar).unwrap().y0, 792.0);
+    assert_eq!(disp.world_bounds(list).unwrap().y0, 800.0);
+    p.scroll_to(0.0, 99_999.0);
+    assert_eq!(p.scroll[&a], (0.0, 1148.0), "clamped to the range");
+    // A top-level frame taller than the screen scrolls without an overflow setting (its own
+    // range still clips nested content); without a device the frame shows whole.
+    d.get_mut(a).unwrap().overflow = Overflow::None;
+    assert_eq!(scroll_range_in(&d, a, viewport(&d, a)), (0.0, 1148.0));
+    assert_eq!(scroll_range(&d, a), (0.0, 0.0));
+    if let Some(pg) = d.page_of(a)
+        && let NodeKind::Page { prototype, .. } = &mut d.get_mut(pg).unwrap().kind
+    {
+        prototype.device = "None".into();
+    }
+    assert_eq!(viewport(&d, a), None);
+    // A frame wider than the screen scrolls sideways when it scrolls both ways.
+    let (mut d, a, ..) = device_doc();
+    let n = d.get_mut(a).unwrap();
+    n.width = 800.0;
+    n.overflow = Overflow::Both;
+    assert_eq!(scroll_range_in(&d, a, viewport(&d, a)), (407.0, 1148.0));
+}
+
+#[test]
+fn scroll_to_moves_every_scrolling_frame_around_the_layer() {
+    let (d, a, _, _, list, item) = device_doc();
+    let mut p = player_on(d.clone(), a);
+    assert!(p.perform(&Action::ScrollTo { dest: item, offset: [0.0, 0.0] }, item, Transition::Instant, 0.0, Easing::Linear, None, 1.0));
+    // The list brings the item to its top (as far as it scrolls), the screen brings the list.
+    assert_eq!(p.scroll[&list], (0.0, 500.0));
+    assert_eq!(p.scroll[&a], (0.0, 1148.0));
+    // Animated, it gets there over the duration.
+    let mut p = player_on(d, a);
+    assert!(p.perform(&Action::ScrollTo { dest: list, offset: [0.0, 0.0] }, list, Transition::Dissolve, 0.3, Easing::Linear, None, 1.0));
+    let anim = p.scroll_anim.as_ref().unwrap();
+    assert_eq!(anim.frames, vec![(a, (0.0, 0.0), (0.0, 1148.0))]);
+}
+
+#[test]
+fn navigating_resets_scroll_unless_it_preserves_it() {
+    let (d, a, b, ..) = device_doc();
+    let mut p = player_on(d, a);
+    p.scroll_to(0.0, 600.0);
+    assert!(p.perform(&Action::Navigate { dest: b, preserve_scroll: false }, a, Transition::Instant, 0.0, Easing::Linear, None, 1.0));
+    assert_eq!(p.scroll.get(&b), None, "starts at the top");
+    p.restart(a, 2.0);
+    p.scroll_to(0.0, 1000.0);
+    assert!(p.perform(&Action::Navigate { dest: b, preserve_scroll: true }, a, Transition::Instant, 0.0, Easing::Linear, None, 3.0));
+    assert_eq!(p.scroll[&b], (0.0, 648.0), "kept, as far as B scrolls");
+    // Back starts at the top again.
+    assert!(p.perform(&Action::Back, b, Transition::Instant, 0.0, Easing::Linear, None, 4.0));
+    assert_eq!((p.current, p.scroll.get(&a)), (a, None));
+}
+
+#[test]
+fn sync_follows_edits_and_keeps_the_screen() {
+    let (mut d, a, b, _, list, _) = device_doc();
+    let mut p = player_on(d.clone(), a);
+    p.go(b, Transition::Instant, 0.0, Easing::Linear, 1.0, true, false);
+    p.scroll_to(0.0, 600.0);
+    // The same document again changes nothing.
+    let same = Arc::new(d.clone());
+    p.sync(&same, 2.0);
+    let rev = p.rev;
+    p.sync(&same, 2.0);
+    assert_eq!(p.rev, rev);
+    // An edit is copied; the screen and its scroll stay (clamped to the new range).
+    d.get_mut(b).unwrap().height = 1000.0;
+    d.get_mut(b).unwrap().name = "B2".into();
+    p.sync(&Arc::new(d.clone()), 3.0);
+    assert_eq!(p.current, b);
+    assert_eq!(p.inspect()["name"], "B2");
+    assert_eq!(p.scroll[&b], (0.0, 148.0));
+    assert_eq!(p.history.len(), 1);
+    // The screen deleted: back to the start.
+    d.remove(b).unwrap();
+    p.sync(&Arc::new(d.clone()), 4.0);
+    assert_eq!(p.current, a);
+    assert!(p.history.is_empty() && p.scroll.is_empty());
+    // Junk scroll offsets never panic and stay in range.
+    p.scroll.insert(list, (f64::NAN, f64::INFINITY));
+    p.sync(&Arc::new(d), 5.0);
+    assert_eq!(p.scroll[&list], (0.0, 0.0));
+}
+
+#[test]
+fn transitions_move_the_right_way() {
+    let left = transition_frames(Transition::MoveIn { direction: Direction::Left }, 0.0);
+    assert_eq!(left.to_off, (1.0, 0.0));
+    assert_eq!(transition_frames(Transition::MoveIn { direction: Direction::Left }, 1.0).to_off, (0.0, 0.0));
+    let push = transition_frames(Transition::Push { direction: Direction::Top }, 0.5);
+    assert_eq!(push.from_off, (0.0, -0.5));
+    assert_eq!(push.to_off, (0.0, 0.5));
+    let out = transition_frames(Transition::MoveOut { direction: Direction::Right }, 0.25);
+    assert!(out.from_on_top);
+    assert_eq!(out.from_off, (0.25, 0.0));
+    assert_eq!(transition_frames(Transition::Dissolve, 0.3).to_alpha, 0.3);
+    assert_eq!(transition_frames(Transition::Instant, 0.0).from_alpha, 0.0);
+    let r = Transition::SlideIn { direction: Direction::Bottom }.reversed();
+    assert_eq!(r, Transition::SlideOut { direction: Direction::Top });
+}
+
+#[test]
+fn overlay_positions() {
+    let base = Rect::from_min_size(pos2(0.0, 0.0), vec2(400.0, 800.0));
+    let size = vec2(200.0, 100.0);
+    assert_eq!(overlay_rect(OverlayPosition::Center, base, size, None, None).min, pos2(100.0, 350.0));
+    assert_eq!(overlay_rect(OverlayPosition::BottomCenter, base, size, None, None).min, pos2(100.0, 700.0));
+    assert_eq!(overlay_rect(OverlayPosition::TopRight, base, size, None, None).min, pos2(200.0, 0.0));
+    let anchor = Rect::from_min_size(pos2(30.0, 40.0), vec2(50.0, 20.0));
+    assert_eq!(overlay_rect(OverlayPosition::Manual, base, size, Some(anchor), None).min, pos2(30.0, 60.0));
+}
+
+/// Smart animate renders a temporary document per animation frame; keep that cheap.
+#[test]
+fn smart_animate_frame_cost() {
+    let (mut d, a, b) = doc_with_two_frames();
+    for (f, dx) in [(a, 0.0), (b, 40.0)] {
+        for i in 0..40 {
+            let r = d.create(f, NodeKind::Rectangle, &format!("Row {i}"), dx + 10.0, 10.0 + f64::from(i) * 9.0, 120.0, 8.0).unwrap();
+            d.get_mut(r).unwrap().corners.radii = [4.0; 4];
+        }
+    }
+    let t0 = std::time::Instant::now();
+    let n = 10;
+    for k in 0..n {
+        let tmp = smart_interpolate(&d, a, &d, b, f64::from(k) / f64::from(n));
+        assert!(figcraft_render::render_node(&tmp, b, 2.0).is_some());
+    }
+    let per = t0.elapsed().as_secs_f64() * 1000.0 / f64::from(n);
+    eprintln!("smart animate: {per:.2} ms per frame (80 layers, 400x800 px)");
+}

From 5d1b826f7a0a409da54bc4135f7a723ac8e89035 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:39 +0000
Subject: [PATCH 10/67] refactor(engine): move board, board_table,
 board_templates to boards/

---
 crates/engine/src/boards.rs                       | 3 +++
 crates/engine/src/{ => boards}/board.rs           | 0
 crates/engine/src/{ => boards}/board_table.rs     | 0
 crates/engine/src/{ => boards}/board_templates.rs | 0
 crates/engine/src/lib.rs                          | 7 ++++---
 5 files changed, 7 insertions(+), 3 deletions(-)
 create mode 100644 crates/engine/src/boards.rs
 rename crates/engine/src/{ => boards}/board.rs (100%)
 rename crates/engine/src/{ => boards}/board_table.rs (100%)
 rename crates/engine/src/{ => boards}/board_templates.rs (100%)

diff --git a/crates/engine/src/boards.rs b/crates/engine/src/boards.rs
new file mode 100644
index 00000000..685c1d70
--- /dev/null
+++ b/crates/engine/src/boards.rs
@@ -0,0 +1,3 @@
+pub mod board;
+pub mod board_table;
+pub mod board_templates;
diff --git a/crates/engine/src/board.rs b/crates/engine/src/boards/board.rs
similarity index 100%
rename from crates/engine/src/board.rs
rename to crates/engine/src/boards/board.rs
diff --git a/crates/engine/src/board_table.rs b/crates/engine/src/boards/board_table.rs
similarity index 100%
rename from crates/engine/src/board_table.rs
rename to crates/engine/src/boards/board_table.rs
diff --git a/crates/engine/src/board_templates.rs b/crates/engine/src/boards/board_templates.rs
similarity index 100%
rename from crates/engine/src/board_templates.rs
rename to crates/engine/src/boards/board_templates.rs
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 462c184f..bc735299 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -14,9 +14,7 @@ pub mod annotations;
 pub mod arc_handles;
 pub mod background;
 pub mod batch;
-pub mod board;
-pub mod board_table;
-pub mod board_templates;
+mod boards;
 pub mod booleans;
 pub mod branches;
 pub mod catalog;
@@ -72,6 +70,9 @@ pub mod token_roles;
 pub mod tools;
 pub mod vectoredit;
 pub mod widgets;
+pub use boards::board;
+pub use boards::board_table;
+pub use boards::board_templates;
 
 pub use batch::{BatchScope, BatchStep};
 pub use cmd::{CommandSpec, all_commands, find_command};

From 094b01e501c0d65a66cb4d4c65e4ec60cc424e97 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:39 +0000
Subject: [PATCH 11/67] refactor(engine): move tools, snap, distance, guides,
 drop, arc_handles, shape_handles, rotation_origin, al_keys, booleans,
 shapebuilder, textedit, textpreview, vectoredit to canvas/

---
 crates/engine/src/canvas.rs                   | 14 +++++++++
 crates/engine/src/{ => canvas}/al_keys.rs     |  0
 crates/engine/src/{ => canvas}/arc_handles.rs |  0
 crates/engine/src/{ => canvas}/booleans.rs    |  0
 crates/engine/src/{ => canvas}/distance.rs    |  0
 crates/engine/src/{ => canvas}/drop.rs        |  0
 crates/engine/src/{ => canvas}/guides.rs      |  0
 .../src/{ => canvas}/rotation_origin.rs       |  0
 .../engine/src/{ => canvas}/shape_handles.rs  |  0
 .../engine/src/{ => canvas}/shapebuilder.rs   |  0
 crates/engine/src/{ => canvas}/snap.rs        |  0
 crates/engine/src/{ => canvas}/textedit.rs    |  0
 .../engine/src/{ => canvas}/textedit/tests.rs |  0
 crates/engine/src/{ => canvas}/textpreview.rs |  0
 crates/engine/src/{ => canvas}/tools.rs       |  0
 crates/engine/src/{ => canvas}/vectoredit.rs  |  0
 .../engine/src/{ => canvas}/vectoredit/ops.rs |  0
 .../src/{ => canvas}/vectoredit/point_snap.rs |  0
 .../src/{ => canvas}/vectoredit/pointer.rs    |  0
 .../src/{ => canvas}/vectoredit/regions.rs    |  0
 .../{ => canvas}/vectoredit/regions_tests.rs  |  0
 .../src/{ => canvas}/vectoredit/tests.rs      |  0
 .../src/{ => canvas}/vectoredit/transform.rs  |  0
 .../vectoredit/transform_tests.rs             |  0
 .../src/{ => canvas}/vectoredit/width.rs      |  0
 .../vectoredit/width_sides_tests.rs           |  0
 .../{ => canvas}/vectoredit/width_tests.rs    |  0
 crates/engine/src/lib.rs                      | 29 ++++++++++---------
 28 files changed, 29 insertions(+), 14 deletions(-)
 create mode 100644 crates/engine/src/canvas.rs
 rename crates/engine/src/{ => canvas}/al_keys.rs (100%)
 rename crates/engine/src/{ => canvas}/arc_handles.rs (100%)
 rename crates/engine/src/{ => canvas}/booleans.rs (100%)
 rename crates/engine/src/{ => canvas}/distance.rs (100%)
 rename crates/engine/src/{ => canvas}/drop.rs (100%)
 rename crates/engine/src/{ => canvas}/guides.rs (100%)
 rename crates/engine/src/{ => canvas}/rotation_origin.rs (100%)
 rename crates/engine/src/{ => canvas}/shape_handles.rs (100%)
 rename crates/engine/src/{ => canvas}/shapebuilder.rs (100%)
 rename crates/engine/src/{ => canvas}/snap.rs (100%)
 rename crates/engine/src/{ => canvas}/textedit.rs (100%)
 rename crates/engine/src/{ => canvas}/textedit/tests.rs (100%)
 rename crates/engine/src/{ => canvas}/textpreview.rs (100%)
 rename crates/engine/src/{ => canvas}/tools.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/ops.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/point_snap.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/pointer.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/regions.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/regions_tests.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/tests.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/transform.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/transform_tests.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/width.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/width_sides_tests.rs (100%)
 rename crates/engine/src/{ => canvas}/vectoredit/width_tests.rs (100%)

diff --git a/crates/engine/src/canvas.rs b/crates/engine/src/canvas.rs
new file mode 100644
index 00000000..b513ffbd
--- /dev/null
+++ b/crates/engine/src/canvas.rs
@@ -0,0 +1,14 @@
+pub mod al_keys;
+pub mod arc_handles;
+pub mod booleans;
+pub mod distance;
+pub mod drop;
+pub mod guides;
+pub mod rotation_origin;
+pub mod shape_handles;
+pub mod shapebuilder;
+pub mod snap;
+pub mod textedit;
+pub mod textpreview;
+pub mod tools;
+pub mod vectoredit;
diff --git a/crates/engine/src/al_keys.rs b/crates/engine/src/canvas/al_keys.rs
similarity index 100%
rename from crates/engine/src/al_keys.rs
rename to crates/engine/src/canvas/al_keys.rs
diff --git a/crates/engine/src/arc_handles.rs b/crates/engine/src/canvas/arc_handles.rs
similarity index 100%
rename from crates/engine/src/arc_handles.rs
rename to crates/engine/src/canvas/arc_handles.rs
diff --git a/crates/engine/src/booleans.rs b/crates/engine/src/canvas/booleans.rs
similarity index 100%
rename from crates/engine/src/booleans.rs
rename to crates/engine/src/canvas/booleans.rs
diff --git a/crates/engine/src/distance.rs b/crates/engine/src/canvas/distance.rs
similarity index 100%
rename from crates/engine/src/distance.rs
rename to crates/engine/src/canvas/distance.rs
diff --git a/crates/engine/src/drop.rs b/crates/engine/src/canvas/drop.rs
similarity index 100%
rename from crates/engine/src/drop.rs
rename to crates/engine/src/canvas/drop.rs
diff --git a/crates/engine/src/guides.rs b/crates/engine/src/canvas/guides.rs
similarity index 100%
rename from crates/engine/src/guides.rs
rename to crates/engine/src/canvas/guides.rs
diff --git a/crates/engine/src/rotation_origin.rs b/crates/engine/src/canvas/rotation_origin.rs
similarity index 100%
rename from crates/engine/src/rotation_origin.rs
rename to crates/engine/src/canvas/rotation_origin.rs
diff --git a/crates/engine/src/shape_handles.rs b/crates/engine/src/canvas/shape_handles.rs
similarity index 100%
rename from crates/engine/src/shape_handles.rs
rename to crates/engine/src/canvas/shape_handles.rs
diff --git a/crates/engine/src/shapebuilder.rs b/crates/engine/src/canvas/shapebuilder.rs
similarity index 100%
rename from crates/engine/src/shapebuilder.rs
rename to crates/engine/src/canvas/shapebuilder.rs
diff --git a/crates/engine/src/snap.rs b/crates/engine/src/canvas/snap.rs
similarity index 100%
rename from crates/engine/src/snap.rs
rename to crates/engine/src/canvas/snap.rs
diff --git a/crates/engine/src/textedit.rs b/crates/engine/src/canvas/textedit.rs
similarity index 100%
rename from crates/engine/src/textedit.rs
rename to crates/engine/src/canvas/textedit.rs
diff --git a/crates/engine/src/textedit/tests.rs b/crates/engine/src/canvas/textedit/tests.rs
similarity index 100%
rename from crates/engine/src/textedit/tests.rs
rename to crates/engine/src/canvas/textedit/tests.rs
diff --git a/crates/engine/src/textpreview.rs b/crates/engine/src/canvas/textpreview.rs
similarity index 100%
rename from crates/engine/src/textpreview.rs
rename to crates/engine/src/canvas/textpreview.rs
diff --git a/crates/engine/src/tools.rs b/crates/engine/src/canvas/tools.rs
similarity index 100%
rename from crates/engine/src/tools.rs
rename to crates/engine/src/canvas/tools.rs
diff --git a/crates/engine/src/vectoredit.rs b/crates/engine/src/canvas/vectoredit.rs
similarity index 100%
rename from crates/engine/src/vectoredit.rs
rename to crates/engine/src/canvas/vectoredit.rs
diff --git a/crates/engine/src/vectoredit/ops.rs b/crates/engine/src/canvas/vectoredit/ops.rs
similarity index 100%
rename from crates/engine/src/vectoredit/ops.rs
rename to crates/engine/src/canvas/vectoredit/ops.rs
diff --git a/crates/engine/src/vectoredit/point_snap.rs b/crates/engine/src/canvas/vectoredit/point_snap.rs
similarity index 100%
rename from crates/engine/src/vectoredit/point_snap.rs
rename to crates/engine/src/canvas/vectoredit/point_snap.rs
diff --git a/crates/engine/src/vectoredit/pointer.rs b/crates/engine/src/canvas/vectoredit/pointer.rs
similarity index 100%
rename from crates/engine/src/vectoredit/pointer.rs
rename to crates/engine/src/canvas/vectoredit/pointer.rs
diff --git a/crates/engine/src/vectoredit/regions.rs b/crates/engine/src/canvas/vectoredit/regions.rs
similarity index 100%
rename from crates/engine/src/vectoredit/regions.rs
rename to crates/engine/src/canvas/vectoredit/regions.rs
diff --git a/crates/engine/src/vectoredit/regions_tests.rs b/crates/engine/src/canvas/vectoredit/regions_tests.rs
similarity index 100%
rename from crates/engine/src/vectoredit/regions_tests.rs
rename to crates/engine/src/canvas/vectoredit/regions_tests.rs
diff --git a/crates/engine/src/vectoredit/tests.rs b/crates/engine/src/canvas/vectoredit/tests.rs
similarity index 100%
rename from crates/engine/src/vectoredit/tests.rs
rename to crates/engine/src/canvas/vectoredit/tests.rs
diff --git a/crates/engine/src/vectoredit/transform.rs b/crates/engine/src/canvas/vectoredit/transform.rs
similarity index 100%
rename from crates/engine/src/vectoredit/transform.rs
rename to crates/engine/src/canvas/vectoredit/transform.rs
diff --git a/crates/engine/src/vectoredit/transform_tests.rs b/crates/engine/src/canvas/vectoredit/transform_tests.rs
similarity index 100%
rename from crates/engine/src/vectoredit/transform_tests.rs
rename to crates/engine/src/canvas/vectoredit/transform_tests.rs
diff --git a/crates/engine/src/vectoredit/width.rs b/crates/engine/src/canvas/vectoredit/width.rs
similarity index 100%
rename from crates/engine/src/vectoredit/width.rs
rename to crates/engine/src/canvas/vectoredit/width.rs
diff --git a/crates/engine/src/vectoredit/width_sides_tests.rs b/crates/engine/src/canvas/vectoredit/width_sides_tests.rs
similarity index 100%
rename from crates/engine/src/vectoredit/width_sides_tests.rs
rename to crates/engine/src/canvas/vectoredit/width_sides_tests.rs
diff --git a/crates/engine/src/vectoredit/width_tests.rs b/crates/engine/src/canvas/vectoredit/width_tests.rs
similarity index 100%
rename from crates/engine/src/vectoredit/width_tests.rs
rename to crates/engine/src/canvas/vectoredit/width_tests.rs
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index bc735299..c158fd2d 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -9,14 +9,12 @@
 // Tests make and inspect files directly; shipped code goes through `file_access` (clippy.toml).
 #![cfg_attr(test, allow(clippy::disallowed_methods))]
 
-pub mod al_keys;
 pub mod annotations;
-pub mod arc_handles;
 pub mod background;
 pub mod batch;
 mod boards;
-pub mod booleans;
 pub mod branches;
+mod canvas;
 pub mod catalog;
 pub mod cmd;
 pub mod code_connect;
@@ -29,13 +27,10 @@ pub mod dev_measurements;
 pub mod dev_resources;
 pub mod devcompare;
 pub mod devinspect;
-pub mod distance;
 pub mod doc_urls;
-pub mod drop;
 pub mod file_access;
 pub mod fonts;
 pub mod guard;
-pub mod guides;
 pub mod inspect;
 pub mod invite_links;
 pub mod keymap;
@@ -51,28 +46,34 @@ pub mod plugin_directory;
 pub mod plugins;
 pub mod proto_run;
 pub mod rename;
-pub mod rotation_origin;
 pub mod selection_colors;
 pub mod selection_reorder;
 pub mod selection_spacing;
-pub mod shape_handles;
-pub mod shapebuilder;
-pub mod snap;
 pub mod style_vars;
 pub mod synthetic;
 pub mod synthetic_ds;
 pub mod tailwind;
 pub mod templates;
-pub mod textedit;
 pub mod textfit;
-pub mod textpreview;
 pub mod token_roles;
-pub mod tools;
-pub mod vectoredit;
 pub mod widgets;
 pub use boards::board;
 pub use boards::board_table;
 pub use boards::board_templates;
+pub use canvas::al_keys;
+pub use canvas::arc_handles;
+pub use canvas::booleans;
+pub use canvas::distance;
+pub use canvas::drop;
+pub use canvas::guides;
+pub use canvas::rotation_origin;
+pub use canvas::shape_handles;
+pub use canvas::shapebuilder;
+pub use canvas::snap;
+pub use canvas::textedit;
+pub use canvas::textpreview;
+pub use canvas::tools;
+pub use canvas::vectoredit;
 
 pub use batch::{BatchScope, BatchStep};
 pub use cmd::{CommandSpec, all_commands, find_command};

From a587d964c9610be409e3dff946cc81729e2b9ad1 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:40 +0000
Subject: [PATCH 12/67] refactor(engine): move selection_colors,
 selection_reorder, selection_spacing, rename to selection/

---
 crates/engine/src/lib.rs                               | 9 +++++----
 crates/engine/src/selection.rs                         | 4 ++++
 crates/engine/src/{ => selection}/rename.rs            | 0
 crates/engine/src/{ => selection}/selection_colors.rs  | 0
 crates/engine/src/{ => selection}/selection_reorder.rs | 0
 crates/engine/src/{ => selection}/selection_spacing.rs | 0
 6 files changed, 9 insertions(+), 4 deletions(-)
 create mode 100644 crates/engine/src/selection.rs
 rename crates/engine/src/{ => selection}/rename.rs (100%)
 rename crates/engine/src/{ => selection}/selection_colors.rs (100%)
 rename crates/engine/src/{ => selection}/selection_reorder.rs (100%)
 rename crates/engine/src/{ => selection}/selection_spacing.rs (100%)

diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index c158fd2d..4b61ad3f 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -45,10 +45,7 @@ pub mod playground;
 pub mod plugin_directory;
 pub mod plugins;
 pub mod proto_run;
-pub mod rename;
-pub mod selection_colors;
-pub mod selection_reorder;
-pub mod selection_spacing;
+mod selection;
 pub mod style_vars;
 pub mod synthetic;
 pub mod synthetic_ds;
@@ -74,6 +71,10 @@ pub use canvas::textedit;
 pub use canvas::textpreview;
 pub use canvas::tools;
 pub use canvas::vectoredit;
+pub use selection::rename;
+pub use selection::selection_colors;
+pub use selection::selection_reorder;
+pub use selection::selection_spacing;
 
 pub use batch::{BatchScope, BatchStep};
 pub use cmd::{CommandSpec, all_commands, find_command};
diff --git a/crates/engine/src/selection.rs b/crates/engine/src/selection.rs
new file mode 100644
index 00000000..08ab6456
--- /dev/null
+++ b/crates/engine/src/selection.rs
@@ -0,0 +1,4 @@
+pub mod rename;
+pub mod selection_colors;
+pub mod selection_reorder;
+pub mod selection_spacing;
diff --git a/crates/engine/src/rename.rs b/crates/engine/src/selection/rename.rs
similarity index 100%
rename from crates/engine/src/rename.rs
rename to crates/engine/src/selection/rename.rs
diff --git a/crates/engine/src/selection_colors.rs b/crates/engine/src/selection/selection_colors.rs
similarity index 100%
rename from crates/engine/src/selection_colors.rs
rename to crates/engine/src/selection/selection_colors.rs
diff --git a/crates/engine/src/selection_reorder.rs b/crates/engine/src/selection/selection_reorder.rs
similarity index 100%
rename from crates/engine/src/selection_reorder.rs
rename to crates/engine/src/selection/selection_reorder.rs
diff --git a/crates/engine/src/selection_spacing.rs b/crates/engine/src/selection/selection_spacing.rs
similarity index 100%
rename from crates/engine/src/selection_spacing.rs
rename to crates/engine/src/selection/selection_spacing.rs

From e466f4a03a6e0c0ee5c85beb30489468c7afaba6 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:40 +0000
Subject: [PATCH 13/67] refactor(engine): move components, library,
 library_server, library_swap, style_vars, playground, token_roles to assets/

---
 crates/engine/src/assets.rs                       |  7 +++++++
 crates/engine/src/{ => assets}/components.rs      |  0
 .../components_rebase_source_tests.rs             |  0
 .../engine/src/{ => assets}/components_tests.rs   |  0
 crates/engine/src/{ => assets}/library.rs         |  0
 crates/engine/src/{ => assets}/library_server.rs  |  0
 .../src/{ => assets}/library_server_tests.rs      |  0
 crates/engine/src/{ => assets}/library_swap.rs    |  0
 .../engine/src/{ => assets}/library_swap_tests.rs |  0
 crates/engine/src/{ => assets}/library_tests.rs   |  0
 crates/engine/src/{ => assets}/playground.rs      |  0
 crates/engine/src/{ => assets}/style_vars.rs      |  0
 crates/engine/src/{ => assets}/token_roles.rs     |  0
 crates/engine/src/lib.rs                          | 15 ++++++++-------
 14 files changed, 15 insertions(+), 7 deletions(-)
 create mode 100644 crates/engine/src/assets.rs
 rename crates/engine/src/{ => assets}/components.rs (100%)
 rename crates/engine/src/{ => assets}/components_rebase_source_tests.rs (100%)
 rename crates/engine/src/{ => assets}/components_tests.rs (100%)
 rename crates/engine/src/{ => assets}/library.rs (100%)
 rename crates/engine/src/{ => assets}/library_server.rs (100%)
 rename crates/engine/src/{ => assets}/library_server_tests.rs (100%)
 rename crates/engine/src/{ => assets}/library_swap.rs (100%)
 rename crates/engine/src/{ => assets}/library_swap_tests.rs (100%)
 rename crates/engine/src/{ => assets}/library_tests.rs (100%)
 rename crates/engine/src/{ => assets}/playground.rs (100%)
 rename crates/engine/src/{ => assets}/style_vars.rs (100%)
 rename crates/engine/src/{ => assets}/token_roles.rs (100%)

diff --git a/crates/engine/src/assets.rs b/crates/engine/src/assets.rs
new file mode 100644
index 00000000..e648ad3b
--- /dev/null
+++ b/crates/engine/src/assets.rs
@@ -0,0 +1,7 @@
+pub mod components;
+pub mod library;
+pub mod library_server;
+pub mod library_swap;
+pub mod playground;
+pub mod style_vars;
+pub mod token_roles;
diff --git a/crates/engine/src/components.rs b/crates/engine/src/assets/components.rs
similarity index 100%
rename from crates/engine/src/components.rs
rename to crates/engine/src/assets/components.rs
diff --git a/crates/engine/src/components_rebase_source_tests.rs b/crates/engine/src/assets/components_rebase_source_tests.rs
similarity index 100%
rename from crates/engine/src/components_rebase_source_tests.rs
rename to crates/engine/src/assets/components_rebase_source_tests.rs
diff --git a/crates/engine/src/components_tests.rs b/crates/engine/src/assets/components_tests.rs
similarity index 100%
rename from crates/engine/src/components_tests.rs
rename to crates/engine/src/assets/components_tests.rs
diff --git a/crates/engine/src/library.rs b/crates/engine/src/assets/library.rs
similarity index 100%
rename from crates/engine/src/library.rs
rename to crates/engine/src/assets/library.rs
diff --git a/crates/engine/src/library_server.rs b/crates/engine/src/assets/library_server.rs
similarity index 100%
rename from crates/engine/src/library_server.rs
rename to crates/engine/src/assets/library_server.rs
diff --git a/crates/engine/src/library_server_tests.rs b/crates/engine/src/assets/library_server_tests.rs
similarity index 100%
rename from crates/engine/src/library_server_tests.rs
rename to crates/engine/src/assets/library_server_tests.rs
diff --git a/crates/engine/src/library_swap.rs b/crates/engine/src/assets/library_swap.rs
similarity index 100%
rename from crates/engine/src/library_swap.rs
rename to crates/engine/src/assets/library_swap.rs
diff --git a/crates/engine/src/library_swap_tests.rs b/crates/engine/src/assets/library_swap_tests.rs
similarity index 100%
rename from crates/engine/src/library_swap_tests.rs
rename to crates/engine/src/assets/library_swap_tests.rs
diff --git a/crates/engine/src/library_tests.rs b/crates/engine/src/assets/library_tests.rs
similarity index 100%
rename from crates/engine/src/library_tests.rs
rename to crates/engine/src/assets/library_tests.rs
diff --git a/crates/engine/src/playground.rs b/crates/engine/src/assets/playground.rs
similarity index 100%
rename from crates/engine/src/playground.rs
rename to crates/engine/src/assets/playground.rs
diff --git a/crates/engine/src/style_vars.rs b/crates/engine/src/assets/style_vars.rs
similarity index 100%
rename from crates/engine/src/style_vars.rs
rename to crates/engine/src/assets/style_vars.rs
diff --git a/crates/engine/src/token_roles.rs b/crates/engine/src/assets/token_roles.rs
similarity index 100%
rename from crates/engine/src/token_roles.rs
rename to crates/engine/src/assets/token_roles.rs
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 4b61ad3f..59718b0f 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -10,6 +10,7 @@
 #![cfg_attr(test, allow(clippy::disallowed_methods))]
 
 pub mod annotations;
+mod assets;
 pub mod background;
 pub mod batch;
 mod boards;
@@ -21,7 +22,6 @@ pub mod code_connect;
 pub mod codegen;
 pub mod collab;
 pub mod component_codegen;
-pub mod components;
 pub mod datafill;
 pub mod dev_measurements;
 pub mod dev_resources;
@@ -34,26 +34,27 @@ pub mod guard;
 pub mod inspect;
 pub mod invite_links;
 pub mod keymap;
-pub mod library;
-pub mod library_server;
-pub mod library_swap;
 pub mod live;
 pub mod measure;
 pub mod online;
 pub mod params;
-pub mod playground;
 pub mod plugin_directory;
 pub mod plugins;
 pub mod proto_run;
 mod selection;
-pub mod style_vars;
 pub mod synthetic;
 pub mod synthetic_ds;
 pub mod tailwind;
 pub mod templates;
 pub mod textfit;
-pub mod token_roles;
 pub mod widgets;
+pub use assets::components;
+pub use assets::library;
+pub use assets::library_server;
+pub use assets::library_swap;
+pub use assets::playground;
+pub use assets::style_vars;
+pub use assets::token_roles;
 pub use boards::board;
 pub use boards::board_table;
 pub use boards::board_templates;

From 9452ec1adade521b3c5ead487c45f9281c691235 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:40 +0000
Subject: [PATCH 14/67] refactor(engine): move annotations, code_connect,
 codegen, component_codegen, tailwind, devcompare, devinspect,
 dev_measurements, dev_resources to dev/

---
 crates/engine/src/dev.rs                      |  9 +++++++++
 crates/engine/src/{ => dev}/annotations.rs    |  0
 crates/engine/src/{ => dev}/code_connect.rs   |  0
 crates/engine/src/{ => dev}/codegen.rs        |  0
 .../engine/src/{ => dev}/component_codegen.rs |  0
 .../engine/src/{ => dev}/dev_measurements.rs  |  0
 crates/engine/src/{ => dev}/dev_resources.rs  |  0
 crates/engine/src/{ => dev}/devcompare.rs     |  0
 crates/engine/src/{ => dev}/devinspect.rs     |  0
 crates/engine/src/{ => dev}/tailwind.rs       |  0
 crates/engine/src/lib.rs                      | 19 ++++++++++---------
 11 files changed, 19 insertions(+), 9 deletions(-)
 create mode 100644 crates/engine/src/dev.rs
 rename crates/engine/src/{ => dev}/annotations.rs (100%)
 rename crates/engine/src/{ => dev}/code_connect.rs (100%)
 rename crates/engine/src/{ => dev}/codegen.rs (100%)
 rename crates/engine/src/{ => dev}/component_codegen.rs (100%)
 rename crates/engine/src/{ => dev}/dev_measurements.rs (100%)
 rename crates/engine/src/{ => dev}/dev_resources.rs (100%)
 rename crates/engine/src/{ => dev}/devcompare.rs (100%)
 rename crates/engine/src/{ => dev}/devinspect.rs (100%)
 rename crates/engine/src/{ => dev}/tailwind.rs (100%)

diff --git a/crates/engine/src/dev.rs b/crates/engine/src/dev.rs
new file mode 100644
index 00000000..bc46aae9
--- /dev/null
+++ b/crates/engine/src/dev.rs
@@ -0,0 +1,9 @@
+pub mod annotations;
+pub mod code_connect;
+pub mod codegen;
+pub mod component_codegen;
+pub mod dev_measurements;
+pub mod dev_resources;
+pub mod devcompare;
+pub mod devinspect;
+pub mod tailwind;
diff --git a/crates/engine/src/annotations.rs b/crates/engine/src/dev/annotations.rs
similarity index 100%
rename from crates/engine/src/annotations.rs
rename to crates/engine/src/dev/annotations.rs
diff --git a/crates/engine/src/code_connect.rs b/crates/engine/src/dev/code_connect.rs
similarity index 100%
rename from crates/engine/src/code_connect.rs
rename to crates/engine/src/dev/code_connect.rs
diff --git a/crates/engine/src/codegen.rs b/crates/engine/src/dev/codegen.rs
similarity index 100%
rename from crates/engine/src/codegen.rs
rename to crates/engine/src/dev/codegen.rs
diff --git a/crates/engine/src/component_codegen.rs b/crates/engine/src/dev/component_codegen.rs
similarity index 100%
rename from crates/engine/src/component_codegen.rs
rename to crates/engine/src/dev/component_codegen.rs
diff --git a/crates/engine/src/dev_measurements.rs b/crates/engine/src/dev/dev_measurements.rs
similarity index 100%
rename from crates/engine/src/dev_measurements.rs
rename to crates/engine/src/dev/dev_measurements.rs
diff --git a/crates/engine/src/dev_resources.rs b/crates/engine/src/dev/dev_resources.rs
similarity index 100%
rename from crates/engine/src/dev_resources.rs
rename to crates/engine/src/dev/dev_resources.rs
diff --git a/crates/engine/src/devcompare.rs b/crates/engine/src/dev/devcompare.rs
similarity index 100%
rename from crates/engine/src/devcompare.rs
rename to crates/engine/src/dev/devcompare.rs
diff --git a/crates/engine/src/devinspect.rs b/crates/engine/src/dev/devinspect.rs
similarity index 100%
rename from crates/engine/src/devinspect.rs
rename to crates/engine/src/dev/devinspect.rs
diff --git a/crates/engine/src/tailwind.rs b/crates/engine/src/dev/tailwind.rs
similarity index 100%
rename from crates/engine/src/tailwind.rs
rename to crates/engine/src/dev/tailwind.rs
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 59718b0f..1ba0c805 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -9,7 +9,6 @@
 // Tests make and inspect files directly; shipped code goes through `file_access` (clippy.toml).
 #![cfg_attr(test, allow(clippy::disallowed_methods))]
 
-pub mod annotations;
 mod assets;
 pub mod background;
 pub mod batch;
@@ -18,15 +17,9 @@ pub mod branches;
 mod canvas;
 pub mod catalog;
 pub mod cmd;
-pub mod code_connect;
-pub mod codegen;
 pub mod collab;
-pub mod component_codegen;
 pub mod datafill;
-pub mod dev_measurements;
-pub mod dev_resources;
-pub mod devcompare;
-pub mod devinspect;
+mod dev;
 pub mod doc_urls;
 pub mod file_access;
 pub mod fonts;
@@ -44,7 +37,6 @@ pub mod proto_run;
 mod selection;
 pub mod synthetic;
 pub mod synthetic_ds;
-pub mod tailwind;
 pub mod templates;
 pub mod textfit;
 pub mod widgets;
@@ -72,6 +64,15 @@ pub use canvas::textedit;
 pub use canvas::textpreview;
 pub use canvas::tools;
 pub use canvas::vectoredit;
+pub use dev::annotations;
+pub use dev::code_connect;
+pub use dev::codegen;
+pub use dev::component_codegen;
+pub use dev::dev_measurements;
+pub use dev::dev_resources;
+pub use dev::devcompare;
+pub use dev::devinspect;
+pub use dev::tailwind;
 pub use selection::rename;
 pub use selection::selection_colors;
 pub use selection::selection_reorder;

From fa8e917ede4b7ae68d9020421e988095f4864d63 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:40 +0000
Subject: [PATCH 15/67] refactor(engine): move collab, live, online, branches,
 invite_links, background to sharing/

---
 crates/engine/src/lib.rs                            | 13 +++++++------
 crates/engine/src/sharing.rs                        |  6 ++++++
 crates/engine/src/{ => sharing}/background.rs       |  0
 crates/engine/src/{ => sharing}/background_tests.rs |  0
 crates/engine/src/{ => sharing}/branches.rs         |  0
 crates/engine/src/{ => sharing}/collab.rs           |  0
 crates/engine/src/{ => sharing}/invite_links.rs     |  0
 crates/engine/src/{ => sharing}/live.rs             |  0
 crates/engine/src/{ => sharing}/online.rs           |  0
 9 files changed, 13 insertions(+), 6 deletions(-)
 create mode 100644 crates/engine/src/sharing.rs
 rename crates/engine/src/{ => sharing}/background.rs (100%)
 rename crates/engine/src/{ => sharing}/background_tests.rs (100%)
 rename crates/engine/src/{ => sharing}/branches.rs (100%)
 rename crates/engine/src/{ => sharing}/collab.rs (100%)
 rename crates/engine/src/{ => sharing}/invite_links.rs (100%)
 rename crates/engine/src/{ => sharing}/live.rs (100%)
 rename crates/engine/src/{ => sharing}/online.rs (100%)

diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 1ba0c805..a6d847d6 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -10,14 +10,11 @@
 #![cfg_attr(test, allow(clippy::disallowed_methods))]
 
 mod assets;
-pub mod background;
 pub mod batch;
 mod boards;
-pub mod branches;
 mod canvas;
 pub mod catalog;
 pub mod cmd;
-pub mod collab;
 pub mod datafill;
 mod dev;
 pub mod doc_urls;
@@ -25,16 +22,14 @@ pub mod file_access;
 pub mod fonts;
 pub mod guard;
 pub mod inspect;
-pub mod invite_links;
 pub mod keymap;
-pub mod live;
 pub mod measure;
-pub mod online;
 pub mod params;
 pub mod plugin_directory;
 pub mod plugins;
 pub mod proto_run;
 mod selection;
+mod sharing;
 pub mod synthetic;
 pub mod synthetic_ds;
 pub mod templates;
@@ -77,6 +72,12 @@ pub use selection::rename;
 pub use selection::selection_colors;
 pub use selection::selection_reorder;
 pub use selection::selection_spacing;
+pub use sharing::background;
+pub use sharing::branches;
+pub use sharing::collab;
+pub use sharing::invite_links;
+pub use sharing::live;
+pub use sharing::online;
 
 pub use batch::{BatchScope, BatchStep};
 pub use cmd::{CommandSpec, all_commands, find_command};
diff --git a/crates/engine/src/sharing.rs b/crates/engine/src/sharing.rs
new file mode 100644
index 00000000..27d1e560
--- /dev/null
+++ b/crates/engine/src/sharing.rs
@@ -0,0 +1,6 @@
+pub mod background;
+pub mod branches;
+pub mod collab;
+pub mod invite_links;
+pub mod live;
+pub mod online;
diff --git a/crates/engine/src/background.rs b/crates/engine/src/sharing/background.rs
similarity index 100%
rename from crates/engine/src/background.rs
rename to crates/engine/src/sharing/background.rs
diff --git a/crates/engine/src/background_tests.rs b/crates/engine/src/sharing/background_tests.rs
similarity index 100%
rename from crates/engine/src/background_tests.rs
rename to crates/engine/src/sharing/background_tests.rs
diff --git a/crates/engine/src/branches.rs b/crates/engine/src/sharing/branches.rs
similarity index 100%
rename from crates/engine/src/branches.rs
rename to crates/engine/src/sharing/branches.rs
diff --git a/crates/engine/src/collab.rs b/crates/engine/src/sharing/collab.rs
similarity index 100%
rename from crates/engine/src/collab.rs
rename to crates/engine/src/sharing/collab.rs
diff --git a/crates/engine/src/invite_links.rs b/crates/engine/src/sharing/invite_links.rs
similarity index 100%
rename from crates/engine/src/invite_links.rs
rename to crates/engine/src/sharing/invite_links.rs
diff --git a/crates/engine/src/live.rs b/crates/engine/src/sharing/live.rs
similarity index 100%
rename from crates/engine/src/live.rs
rename to crates/engine/src/sharing/live.rs
diff --git a/crates/engine/src/online.rs b/crates/engine/src/sharing/online.rs
similarity index 100%
rename from crates/engine/src/online.rs
rename to crates/engine/src/sharing/online.rs

From 53b04cc7844eb7f701886f268dd6e2714ef3f4f0 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:40 +0000
Subject: [PATCH 16/67] refactor(engine): move plugins, plugin_directory,
 widgets to extensions/

---
 crates/engine/src/extensions.rs                        | 3 +++
 crates/engine/src/{ => extensions}/plugin_directory.rs | 0
 crates/engine/src/{ => extensions}/plugins.rs          | 0
 crates/engine/src/{ => extensions}/widgets.rs          | 0
 crates/engine/src/lib.rs                               | 7 ++++---
 5 files changed, 7 insertions(+), 3 deletions(-)
 create mode 100644 crates/engine/src/extensions.rs
 rename crates/engine/src/{ => extensions}/plugin_directory.rs (100%)
 rename crates/engine/src/{ => extensions}/plugins.rs (100%)
 rename crates/engine/src/{ => extensions}/widgets.rs (100%)

diff --git a/crates/engine/src/extensions.rs b/crates/engine/src/extensions.rs
new file mode 100644
index 00000000..aeac5e34
--- /dev/null
+++ b/crates/engine/src/extensions.rs
@@ -0,0 +1,3 @@
+pub mod plugin_directory;
+pub mod plugins;
+pub mod widgets;
diff --git a/crates/engine/src/plugin_directory.rs b/crates/engine/src/extensions/plugin_directory.rs
similarity index 100%
rename from crates/engine/src/plugin_directory.rs
rename to crates/engine/src/extensions/plugin_directory.rs
diff --git a/crates/engine/src/plugins.rs b/crates/engine/src/extensions/plugins.rs
similarity index 100%
rename from crates/engine/src/plugins.rs
rename to crates/engine/src/extensions/plugins.rs
diff --git a/crates/engine/src/widgets.rs b/crates/engine/src/extensions/widgets.rs
similarity index 100%
rename from crates/engine/src/widgets.rs
rename to crates/engine/src/extensions/widgets.rs
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index a6d847d6..6775f807 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -18,6 +18,7 @@ pub mod cmd;
 pub mod datafill;
 mod dev;
 pub mod doc_urls;
+mod extensions;
 pub mod file_access;
 pub mod fonts;
 pub mod guard;
@@ -25,8 +26,6 @@ pub mod inspect;
 pub mod keymap;
 pub mod measure;
 pub mod params;
-pub mod plugin_directory;
-pub mod plugins;
 pub mod proto_run;
 mod selection;
 mod sharing;
@@ -34,7 +33,6 @@ pub mod synthetic;
 pub mod synthetic_ds;
 pub mod templates;
 pub mod textfit;
-pub mod widgets;
 pub use assets::components;
 pub use assets::library;
 pub use assets::library_server;
@@ -68,6 +66,9 @@ pub use dev::dev_resources;
 pub use dev::devcompare;
 pub use dev::devinspect;
 pub use dev::tailwind;
+pub use extensions::plugin_directory;
+pub use extensions::plugins;
+pub use extensions::widgets;
 pub use selection::rename;
 pub use selection::selection_colors;
 pub use selection::selection_reorder;

From 2cf15106e1e9295ffe56748ce24dea65093bb49e Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:40 +0000
Subject: [PATCH 17/67] refactor(engine): move datafill, textfit, templates,
 synthetic, synthetic_ds to content/

---
 crates/engine/src/content.rs                          |  5 +++++
 crates/engine/src/{ => content}/datafill.rs           |  0
 crates/engine/src/{ => content}/synthetic.rs          |  0
 crates/engine/src/{ => content}/synthetic_ds.rs       |  0
 crates/engine/src/{ => content}/templates.rs          |  0
 .../engine/src/{ => content}/templates/dashboard.rs   |  0
 .../src/{ => content}/templates/design_system.rs      |  0
 crates/engine/src/{ => content}/templates/glyphs.rs   |  0
 crates/engine/src/{ => content}/templates/icon_set.rs |  0
 crates/engine/src/{ => content}/templates/kit.rs      |  0
 crates/engine/src/{ => content}/templates/landing.rs  |  0
 crates/engine/src/{ => content}/templates/mobile.rs   |  0
 crates/engine/src/{ => content}/templates/slides.rs   |  0
 crates/engine/src/{ => content}/templates/social.rs   |  0
 .../engine/src/{ => content}/templates/wireframe.rs   |  0
 crates/engine/src/{ => content}/textfit.rs            |  0
 crates/engine/src/lib.rs                              | 11 ++++++-----
 17 files changed, 11 insertions(+), 5 deletions(-)
 create mode 100644 crates/engine/src/content.rs
 rename crates/engine/src/{ => content}/datafill.rs (100%)
 rename crates/engine/src/{ => content}/synthetic.rs (100%)
 rename crates/engine/src/{ => content}/synthetic_ds.rs (100%)
 rename crates/engine/src/{ => content}/templates.rs (100%)
 rename crates/engine/src/{ => content}/templates/dashboard.rs (100%)
 rename crates/engine/src/{ => content}/templates/design_system.rs (100%)
 rename crates/engine/src/{ => content}/templates/glyphs.rs (100%)
 rename crates/engine/src/{ => content}/templates/icon_set.rs (100%)
 rename crates/engine/src/{ => content}/templates/kit.rs (100%)
 rename crates/engine/src/{ => content}/templates/landing.rs (100%)
 rename crates/engine/src/{ => content}/templates/mobile.rs (100%)
 rename crates/engine/src/{ => content}/templates/slides.rs (100%)
 rename crates/engine/src/{ => content}/templates/social.rs (100%)
 rename crates/engine/src/{ => content}/templates/wireframe.rs (100%)
 rename crates/engine/src/{ => content}/textfit.rs (100%)

diff --git a/crates/engine/src/content.rs b/crates/engine/src/content.rs
new file mode 100644
index 00000000..cf32c3eb
--- /dev/null
+++ b/crates/engine/src/content.rs
@@ -0,0 +1,5 @@
+pub mod datafill;
+pub mod synthetic;
+pub mod synthetic_ds;
+pub mod templates;
+pub mod textfit;
diff --git a/crates/engine/src/datafill.rs b/crates/engine/src/content/datafill.rs
similarity index 100%
rename from crates/engine/src/datafill.rs
rename to crates/engine/src/content/datafill.rs
diff --git a/crates/engine/src/synthetic.rs b/crates/engine/src/content/synthetic.rs
similarity index 100%
rename from crates/engine/src/synthetic.rs
rename to crates/engine/src/content/synthetic.rs
diff --git a/crates/engine/src/synthetic_ds.rs b/crates/engine/src/content/synthetic_ds.rs
similarity index 100%
rename from crates/engine/src/synthetic_ds.rs
rename to crates/engine/src/content/synthetic_ds.rs
diff --git a/crates/engine/src/templates.rs b/crates/engine/src/content/templates.rs
similarity index 100%
rename from crates/engine/src/templates.rs
rename to crates/engine/src/content/templates.rs
diff --git a/crates/engine/src/templates/dashboard.rs b/crates/engine/src/content/templates/dashboard.rs
similarity index 100%
rename from crates/engine/src/templates/dashboard.rs
rename to crates/engine/src/content/templates/dashboard.rs
diff --git a/crates/engine/src/templates/design_system.rs b/crates/engine/src/content/templates/design_system.rs
similarity index 100%
rename from crates/engine/src/templates/design_system.rs
rename to crates/engine/src/content/templates/design_system.rs
diff --git a/crates/engine/src/templates/glyphs.rs b/crates/engine/src/content/templates/glyphs.rs
similarity index 100%
rename from crates/engine/src/templates/glyphs.rs
rename to crates/engine/src/content/templates/glyphs.rs
diff --git a/crates/engine/src/templates/icon_set.rs b/crates/engine/src/content/templates/icon_set.rs
similarity index 100%
rename from crates/engine/src/templates/icon_set.rs
rename to crates/engine/src/content/templates/icon_set.rs
diff --git a/crates/engine/src/templates/kit.rs b/crates/engine/src/content/templates/kit.rs
similarity index 100%
rename from crates/engine/src/templates/kit.rs
rename to crates/engine/src/content/templates/kit.rs
diff --git a/crates/engine/src/templates/landing.rs b/crates/engine/src/content/templates/landing.rs
similarity index 100%
rename from crates/engine/src/templates/landing.rs
rename to crates/engine/src/content/templates/landing.rs
diff --git a/crates/engine/src/templates/mobile.rs b/crates/engine/src/content/templates/mobile.rs
similarity index 100%
rename from crates/engine/src/templates/mobile.rs
rename to crates/engine/src/content/templates/mobile.rs
diff --git a/crates/engine/src/templates/slides.rs b/crates/engine/src/content/templates/slides.rs
similarity index 100%
rename from crates/engine/src/templates/slides.rs
rename to crates/engine/src/content/templates/slides.rs
diff --git a/crates/engine/src/templates/social.rs b/crates/engine/src/content/templates/social.rs
similarity index 100%
rename from crates/engine/src/templates/social.rs
rename to crates/engine/src/content/templates/social.rs
diff --git a/crates/engine/src/templates/wireframe.rs b/crates/engine/src/content/templates/wireframe.rs
similarity index 100%
rename from crates/engine/src/templates/wireframe.rs
rename to crates/engine/src/content/templates/wireframe.rs
diff --git a/crates/engine/src/textfit.rs b/crates/engine/src/content/textfit.rs
similarity index 100%
rename from crates/engine/src/textfit.rs
rename to crates/engine/src/content/textfit.rs
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 6775f807..4a4894b3 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -15,7 +15,7 @@ mod boards;
 mod canvas;
 pub mod catalog;
 pub mod cmd;
-pub mod datafill;
+mod content;
 mod dev;
 pub mod doc_urls;
 mod extensions;
@@ -29,10 +29,6 @@ pub mod params;
 pub mod proto_run;
 mod selection;
 mod sharing;
-pub mod synthetic;
-pub mod synthetic_ds;
-pub mod templates;
-pub mod textfit;
 pub use assets::components;
 pub use assets::library;
 pub use assets::library_server;
@@ -57,6 +53,11 @@ pub use canvas::textedit;
 pub use canvas::textpreview;
 pub use canvas::tools;
 pub use canvas::vectoredit;
+pub use content::datafill;
+pub use content::synthetic;
+pub use content::synthetic_ds;
+pub use content::templates;
+pub use content::textfit;
 pub use dev::annotations;
 pub use dev::code_connect;
 pub use dev::codegen;

From e1b0ea2c1df0505ce73259d893bc2a8dbdc4aab6 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:41 +0000
Subject: [PATCH 18/67] refactor(engine): move batch, params, inspect,
 file_access, doc_urls to automation/

---
 crates/engine/src/automation.rs                       |  5 +++++
 crates/engine/src/{ => automation}/batch.rs           |  0
 crates/engine/src/{ => automation}/doc_urls.rs        |  0
 crates/engine/src/{ => automation}/file_access.rs     |  0
 .../engine/src/{ => automation}/file_access_tests.rs  |  0
 crates/engine/src/{ => automation}/inspect.rs         |  0
 crates/engine/src/{ => automation}/params.rs          |  0
 crates/engine/src/lib.rs                              | 11 ++++++-----
 8 files changed, 11 insertions(+), 5 deletions(-)
 create mode 100644 crates/engine/src/automation.rs
 rename crates/engine/src/{ => automation}/batch.rs (100%)
 rename crates/engine/src/{ => automation}/doc_urls.rs (100%)
 rename crates/engine/src/{ => automation}/file_access.rs (100%)
 rename crates/engine/src/{ => automation}/file_access_tests.rs (100%)
 rename crates/engine/src/{ => automation}/inspect.rs (100%)
 rename crates/engine/src/{ => automation}/params.rs (100%)

diff --git a/crates/engine/src/automation.rs b/crates/engine/src/automation.rs
new file mode 100644
index 00000000..acf11e5c
--- /dev/null
+++ b/crates/engine/src/automation.rs
@@ -0,0 +1,5 @@
+pub mod batch;
+pub mod doc_urls;
+pub mod file_access;
+pub mod inspect;
+pub mod params;
diff --git a/crates/engine/src/batch.rs b/crates/engine/src/automation/batch.rs
similarity index 100%
rename from crates/engine/src/batch.rs
rename to crates/engine/src/automation/batch.rs
diff --git a/crates/engine/src/doc_urls.rs b/crates/engine/src/automation/doc_urls.rs
similarity index 100%
rename from crates/engine/src/doc_urls.rs
rename to crates/engine/src/automation/doc_urls.rs
diff --git a/crates/engine/src/file_access.rs b/crates/engine/src/automation/file_access.rs
similarity index 100%
rename from crates/engine/src/file_access.rs
rename to crates/engine/src/automation/file_access.rs
diff --git a/crates/engine/src/file_access_tests.rs b/crates/engine/src/automation/file_access_tests.rs
similarity index 100%
rename from crates/engine/src/file_access_tests.rs
rename to crates/engine/src/automation/file_access_tests.rs
diff --git a/crates/engine/src/inspect.rs b/crates/engine/src/automation/inspect.rs
similarity index 100%
rename from crates/engine/src/inspect.rs
rename to crates/engine/src/automation/inspect.rs
diff --git a/crates/engine/src/params.rs b/crates/engine/src/automation/params.rs
similarity index 100%
rename from crates/engine/src/params.rs
rename to crates/engine/src/automation/params.rs
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 4a4894b3..9910e027 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -10,22 +10,18 @@
 #![cfg_attr(test, allow(clippy::disallowed_methods))]
 
 mod assets;
-pub mod batch;
+mod automation;
 mod boards;
 mod canvas;
 pub mod catalog;
 pub mod cmd;
 mod content;
 mod dev;
-pub mod doc_urls;
 mod extensions;
-pub mod file_access;
 pub mod fonts;
 pub mod guard;
-pub mod inspect;
 pub mod keymap;
 pub mod measure;
-pub mod params;
 pub mod proto_run;
 mod selection;
 mod sharing;
@@ -36,6 +32,11 @@ pub use assets::library_swap;
 pub use assets::playground;
 pub use assets::style_vars;
 pub use assets::token_roles;
+pub use automation::batch;
+pub use automation::doc_urls;
+pub use automation::file_access;
+pub use automation::inspect;
+pub use automation::params;
 pub use boards::board;
 pub use boards::board_table;
 pub use boards::board_templates;

From 3e23a0f884043fcd5bdb2a22fce25e55160140d1 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:41 +0000
Subject: [PATCH 19/67] refactor(ui-egui): move cursors, frame_labels,
 frame_stats, guides, handles, measure_overlay, proto_canvas, render_worker,
 selection_spacing, live_text, comments, board_bar, board_facilitate,
 widget_bar to canvas/

---
 crates/ui-egui/src/canvas.rs                  | 14 ++++++++++
 crates/ui-egui/src/{ => canvas}/board_bar.rs  |  0
 .../src/{ => canvas}/board_facilitate.rs      |  0
 crates/ui-egui/src/{ => canvas}/comments.rs   |  0
 crates/ui-egui/src/{ => canvas}/cursors.rs    |  0
 .../ui-egui/src/{ => canvas}/frame_labels.rs  |  0
 .../ui-egui/src/{ => canvas}/frame_stats.rs   |  0
 crates/ui-egui/src/{ => canvas}/guides.rs     |  0
 crates/ui-egui/src/{ => canvas}/handles.rs    |  0
 crates/ui-egui/src/{ => canvas}/live_text.rs  |  0
 .../src/{ => canvas}/measure_overlay.rs       |  0
 .../ui-egui/src/{ => canvas}/proto_canvas.rs  |  0
 .../ui-egui/src/{ => canvas}/render_worker.rs |  0
 .../src/{ => canvas}/selection_spacing.rs     |  0
 crates/ui-egui/src/{ => canvas}/widget_bar.rs |  0
 crates/ui-egui/src/lib.rs                     | 28 +++++++++----------
 16 files changed, 28 insertions(+), 14 deletions(-)
 rename crates/ui-egui/src/{ => canvas}/board_bar.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/board_facilitate.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/comments.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/cursors.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/frame_labels.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/frame_stats.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/guides.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/handles.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/live_text.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/measure_overlay.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/proto_canvas.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/render_worker.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/selection_spacing.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/widget_bar.rs (100%)

diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index d227940c..724b441e 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -13,6 +13,20 @@ use crate::FigApp;
 use crate::i18n::{tr, trf, trn};
 use crate::render_worker::{Done, Job, Worker};
 use crate::theme::{COMPONENT, Tokens, doc_c32, regular, semibold};
+pub mod board_bar;
+pub mod board_facilitate;
+pub mod comments;
+pub mod cursors;
+pub mod frame_labels;
+pub mod frame_stats;
+pub mod guides;
+pub mod handles;
+pub mod live_text;
+pub mod measure_overlay;
+pub mod proto_canvas;
+pub mod render_worker;
+pub(crate) mod selection_spacing;
+pub mod widget_bar;
 
 pub struct CanvasState {
     pub rect: Rect,
diff --git a/crates/ui-egui/src/board_bar.rs b/crates/ui-egui/src/canvas/board_bar.rs
similarity index 100%
rename from crates/ui-egui/src/board_bar.rs
rename to crates/ui-egui/src/canvas/board_bar.rs
diff --git a/crates/ui-egui/src/board_facilitate.rs b/crates/ui-egui/src/canvas/board_facilitate.rs
similarity index 100%
rename from crates/ui-egui/src/board_facilitate.rs
rename to crates/ui-egui/src/canvas/board_facilitate.rs
diff --git a/crates/ui-egui/src/comments.rs b/crates/ui-egui/src/canvas/comments.rs
similarity index 100%
rename from crates/ui-egui/src/comments.rs
rename to crates/ui-egui/src/canvas/comments.rs
diff --git a/crates/ui-egui/src/cursors.rs b/crates/ui-egui/src/canvas/cursors.rs
similarity index 100%
rename from crates/ui-egui/src/cursors.rs
rename to crates/ui-egui/src/canvas/cursors.rs
diff --git a/crates/ui-egui/src/frame_labels.rs b/crates/ui-egui/src/canvas/frame_labels.rs
similarity index 100%
rename from crates/ui-egui/src/frame_labels.rs
rename to crates/ui-egui/src/canvas/frame_labels.rs
diff --git a/crates/ui-egui/src/frame_stats.rs b/crates/ui-egui/src/canvas/frame_stats.rs
similarity index 100%
rename from crates/ui-egui/src/frame_stats.rs
rename to crates/ui-egui/src/canvas/frame_stats.rs
diff --git a/crates/ui-egui/src/guides.rs b/crates/ui-egui/src/canvas/guides.rs
similarity index 100%
rename from crates/ui-egui/src/guides.rs
rename to crates/ui-egui/src/canvas/guides.rs
diff --git a/crates/ui-egui/src/handles.rs b/crates/ui-egui/src/canvas/handles.rs
similarity index 100%
rename from crates/ui-egui/src/handles.rs
rename to crates/ui-egui/src/canvas/handles.rs
diff --git a/crates/ui-egui/src/live_text.rs b/crates/ui-egui/src/canvas/live_text.rs
similarity index 100%
rename from crates/ui-egui/src/live_text.rs
rename to crates/ui-egui/src/canvas/live_text.rs
diff --git a/crates/ui-egui/src/measure_overlay.rs b/crates/ui-egui/src/canvas/measure_overlay.rs
similarity index 100%
rename from crates/ui-egui/src/measure_overlay.rs
rename to crates/ui-egui/src/canvas/measure_overlay.rs
diff --git a/crates/ui-egui/src/proto_canvas.rs b/crates/ui-egui/src/canvas/proto_canvas.rs
similarity index 100%
rename from crates/ui-egui/src/proto_canvas.rs
rename to crates/ui-egui/src/canvas/proto_canvas.rs
diff --git a/crates/ui-egui/src/render_worker.rs b/crates/ui-egui/src/canvas/render_worker.rs
similarity index 100%
rename from crates/ui-egui/src/render_worker.rs
rename to crates/ui-egui/src/canvas/render_worker.rs
diff --git a/crates/ui-egui/src/selection_spacing.rs b/crates/ui-egui/src/canvas/selection_spacing.rs
similarity index 100%
rename from crates/ui-egui/src/selection_spacing.rs
rename to crates/ui-egui/src/canvas/selection_spacing.rs
diff --git a/crates/ui-egui/src/widget_bar.rs b/crates/ui-egui/src/canvas/widget_bar.rs
similarity index 100%
rename from crates/ui-egui/src/widget_bar.rs
rename to crates/ui-egui/src/canvas/widget_bar.rs
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index e5bc32a0..8f70ea85 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -8,29 +8,21 @@
 pub mod a11y;
 pub mod assets_panel;
 pub mod bidi;
-pub mod board_bar;
-pub mod board_facilitate;
 mod board_picker;
 pub mod branch_ui;
 pub mod canvas;
 pub mod cjk;
 pub mod colorpicker;
-pub mod comments;
 pub mod component_panel;
 pub mod control;
 pub mod credits;
-pub mod cursors;
 pub mod dev_compare;
 pub mod dev_mode;
 pub mod dialogs;
 pub mod export_panel;
 pub mod field_math;
 pub mod font_preview;
-pub mod frame_labels;
 pub mod frame_presets;
-pub mod frame_stats;
-pub mod guides;
-pub mod handles;
 pub mod home;
 pub mod home_recents;
 pub mod i18n;
@@ -40,23 +32,18 @@ pub mod layers;
 pub mod layout_panel;
 pub mod list_drag;
 pub mod live;
-pub mod live_text;
-pub mod measure_overlay;
 pub mod menus;
 pub mod missing_fonts;
 pub mod online;
 pub mod pending_open;
 pub mod plugins_ui;
 pub mod present;
-pub mod proto_canvas;
 pub mod proto_editor;
 pub mod proto_panel;
-pub mod render_worker;
 pub mod right;
 pub mod scale_panel;
 pub mod section_panel;
 pub mod selection_colors;
-mod selection_spacing;
 pub mod shortcuts;
 pub mod shortcuts_panel;
 pub mod style_picker;
@@ -70,7 +57,6 @@ pub mod variable_ui;
 pub mod variables_panel;
 pub mod vector_panel;
 pub mod versions;
-pub mod widget_bar;
 pub mod widgets;
 pub mod windows;
 
@@ -259,6 +245,20 @@ mod web_save_tests;
 mod windows_qa_tests;
 #[cfg(test)]
 mod windows_tests;
+pub use canvas::board_bar;
+pub use canvas::board_facilitate;
+pub use canvas::comments;
+pub use canvas::cursors;
+pub use canvas::frame_labels;
+pub use canvas::frame_stats;
+pub use canvas::guides;
+pub use canvas::handles;
+pub use canvas::live_text;
+pub use canvas::measure_overlay;
+pub use canvas::proto_canvas;
+pub use canvas::render_worker;
+use canvas::selection_spacing;
+pub use canvas::widget_bar;
 
 use std::collections::BTreeSet;
 use std::ffi::OsStr;

From a0e33576d750ae89950bb15a16be50727843e397 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:41 +0000
Subject: [PATCH 20/67] refactor(ui-egui): move layers, assets_panel, versions,
 right, component_panel, export_panel, layout_panel, section_panel,
 selection_colors, typography, variable_ui, vector_panel, scale_panel,
 frame_presets, list_drag, proto_panel, proto_editor, dev_mode, dev_compare,
 shortcuts_panel to panels/

---
 crates/ui-egui/src/lib.rs                     | 41 ++++++++++---------
 crates/ui-egui/src/panels.rs                  | 20 +++++++++
 .../ui-egui/src/{ => panels}/assets_panel.rs  |  0
 .../src/{ => panels}/component_panel.rs       |  0
 .../ui-egui/src/{ => panels}/dev_compare.rs   |  0
 crates/ui-egui/src/{ => panels}/dev_mode.rs   |  0
 .../ui-egui/src/{ => panels}/export_panel.rs  |  0
 .../ui-egui/src/{ => panels}/frame_presets.rs |  0
 crates/ui-egui/src/{ => panels}/layers.rs     |  0
 .../ui-egui/src/{ => panels}/layout_panel.rs  |  0
 crates/ui-egui/src/{ => panels}/list_drag.rs  |  0
 .../ui-egui/src/{ => panels}/proto_editor.rs  |  0
 .../ui-egui/src/{ => panels}/proto_panel.rs   |  0
 crates/ui-egui/src/{ => panels}/right.rs      |  0
 .../ui-egui/src/{ => panels}/scale_panel.rs   |  0
 .../ui-egui/src/{ => panels}/section_panel.rs |  0
 .../src/{ => panels}/selection_colors.rs      |  0
 .../src/{ => panels}/shortcuts_panel.rs       |  0
 crates/ui-egui/src/{ => panels}/typography.rs |  0
 .../ui-egui/src/{ => panels}/variable_ui.rs   |  0
 .../ui-egui/src/{ => panels}/vector_panel.rs  |  0
 crates/ui-egui/src/{ => panels}/versions.rs   |  0
 22 files changed, 41 insertions(+), 20 deletions(-)
 create mode 100644 crates/ui-egui/src/panels.rs
 rename crates/ui-egui/src/{ => panels}/assets_panel.rs (100%)
 rename crates/ui-egui/src/{ => panels}/component_panel.rs (100%)
 rename crates/ui-egui/src/{ => panels}/dev_compare.rs (100%)
 rename crates/ui-egui/src/{ => panels}/dev_mode.rs (100%)
 rename crates/ui-egui/src/{ => panels}/export_panel.rs (100%)
 rename crates/ui-egui/src/{ => panels}/frame_presets.rs (100%)
 rename crates/ui-egui/src/{ => panels}/layers.rs (100%)
 rename crates/ui-egui/src/{ => panels}/layout_panel.rs (100%)
 rename crates/ui-egui/src/{ => panels}/list_drag.rs (100%)
 rename crates/ui-egui/src/{ => panels}/proto_editor.rs (100%)
 rename crates/ui-egui/src/{ => panels}/proto_panel.rs (100%)
 rename crates/ui-egui/src/{ => panels}/right.rs (100%)
 rename crates/ui-egui/src/{ => panels}/scale_panel.rs (100%)
 rename crates/ui-egui/src/{ => panels}/section_panel.rs (100%)
 rename crates/ui-egui/src/{ => panels}/selection_colors.rs (100%)
 rename crates/ui-egui/src/{ => panels}/shortcuts_panel.rs (100%)
 rename crates/ui-egui/src/{ => panels}/typography.rs (100%)
 rename crates/ui-egui/src/{ => panels}/variable_ui.rs (100%)
 rename crates/ui-egui/src/{ => panels}/vector_panel.rs (100%)
 rename crates/ui-egui/src/{ => panels}/versions.rs (100%)

diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 8f70ea85..a5b1ad70 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -6,31 +6,22 @@
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
 pub mod a11y;
-pub mod assets_panel;
 pub mod bidi;
 mod board_picker;
 pub mod branch_ui;
 pub mod canvas;
 pub mod cjk;
 pub mod colorpicker;
-pub mod component_panel;
 pub mod control;
 pub mod credits;
-pub mod dev_compare;
-pub mod dev_mode;
 pub mod dialogs;
-pub mod export_panel;
 pub mod field_math;
 pub mod font_preview;
-pub mod frame_presets;
 pub mod home;
 pub mod home_recents;
 pub mod i18n;
 pub mod icons;
 pub mod import_report;
-pub mod layers;
-pub mod layout_panel;
-pub mod list_drag;
 pub mod live;
 pub mod menus;
 pub mod missing_fonts;
@@ -38,25 +29,14 @@ pub mod online;
 pub mod pending_open;
 pub mod plugins_ui;
 pub mod present;
-pub mod proto_editor;
-pub mod proto_panel;
-pub mod right;
-pub mod scale_panel;
-pub mod section_panel;
-pub mod selection_colors;
 pub mod shortcuts;
-pub mod shortcuts_panel;
 pub mod style_picker;
 pub mod tabs;
 pub mod theme;
 pub mod toolbar;
-pub mod typography;
 pub mod ui_scale;
 pub mod updates_ui;
-pub mod variable_ui;
 pub mod variables_panel;
-pub mod vector_panel;
-pub mod versions;
 pub mod widgets;
 pub mod windows;
 
@@ -177,6 +157,7 @@ mod panel_remove_tests;
 mod panel_reorder_tests;
 #[cfg(test)]
 mod panel_width_tests;
+mod panels;
 #[cfg(test)]
 mod paste_image_tests;
 #[cfg(test)]
@@ -259,6 +240,26 @@ pub use canvas::proto_canvas;
 pub use canvas::render_worker;
 use canvas::selection_spacing;
 pub use canvas::widget_bar;
+pub use panels::assets_panel;
+pub use panels::component_panel;
+pub use panels::dev_compare;
+pub use panels::dev_mode;
+pub use panels::export_panel;
+pub use panels::frame_presets;
+pub use panels::layers;
+pub use panels::layout_panel;
+pub use panels::list_drag;
+pub use panels::proto_editor;
+pub use panels::proto_panel;
+pub use panels::right;
+pub use panels::scale_panel;
+pub use panels::section_panel;
+pub use panels::selection_colors;
+pub use panels::shortcuts_panel;
+pub use panels::typography;
+pub use panels::variable_ui;
+pub use panels::vector_panel;
+pub use panels::versions;
 
 use std::collections::BTreeSet;
 use std::ffi::OsStr;
diff --git a/crates/ui-egui/src/panels.rs b/crates/ui-egui/src/panels.rs
new file mode 100644
index 00000000..8dd0df07
--- /dev/null
+++ b/crates/ui-egui/src/panels.rs
@@ -0,0 +1,20 @@
+pub mod assets_panel;
+pub mod component_panel;
+pub mod dev_compare;
+pub mod dev_mode;
+pub mod export_panel;
+pub mod frame_presets;
+pub mod layers;
+pub mod layout_panel;
+pub mod list_drag;
+pub mod proto_editor;
+pub mod proto_panel;
+pub mod right;
+pub mod scale_panel;
+pub mod section_panel;
+pub mod selection_colors;
+pub mod shortcuts_panel;
+pub mod typography;
+pub mod variable_ui;
+pub mod vector_panel;
+pub mod versions;
diff --git a/crates/ui-egui/src/assets_panel.rs b/crates/ui-egui/src/panels/assets_panel.rs
similarity index 100%
rename from crates/ui-egui/src/assets_panel.rs
rename to crates/ui-egui/src/panels/assets_panel.rs
diff --git a/crates/ui-egui/src/component_panel.rs b/crates/ui-egui/src/panels/component_panel.rs
similarity index 100%
rename from crates/ui-egui/src/component_panel.rs
rename to crates/ui-egui/src/panels/component_panel.rs
diff --git a/crates/ui-egui/src/dev_compare.rs b/crates/ui-egui/src/panels/dev_compare.rs
similarity index 100%
rename from crates/ui-egui/src/dev_compare.rs
rename to crates/ui-egui/src/panels/dev_compare.rs
diff --git a/crates/ui-egui/src/dev_mode.rs b/crates/ui-egui/src/panels/dev_mode.rs
similarity index 100%
rename from crates/ui-egui/src/dev_mode.rs
rename to crates/ui-egui/src/panels/dev_mode.rs
diff --git a/crates/ui-egui/src/export_panel.rs b/crates/ui-egui/src/panels/export_panel.rs
similarity index 100%
rename from crates/ui-egui/src/export_panel.rs
rename to crates/ui-egui/src/panels/export_panel.rs
diff --git a/crates/ui-egui/src/frame_presets.rs b/crates/ui-egui/src/panels/frame_presets.rs
similarity index 100%
rename from crates/ui-egui/src/frame_presets.rs
rename to crates/ui-egui/src/panels/frame_presets.rs
diff --git a/crates/ui-egui/src/layers.rs b/crates/ui-egui/src/panels/layers.rs
similarity index 100%
rename from crates/ui-egui/src/layers.rs
rename to crates/ui-egui/src/panels/layers.rs
diff --git a/crates/ui-egui/src/layout_panel.rs b/crates/ui-egui/src/panels/layout_panel.rs
similarity index 100%
rename from crates/ui-egui/src/layout_panel.rs
rename to crates/ui-egui/src/panels/layout_panel.rs
diff --git a/crates/ui-egui/src/list_drag.rs b/crates/ui-egui/src/panels/list_drag.rs
similarity index 100%
rename from crates/ui-egui/src/list_drag.rs
rename to crates/ui-egui/src/panels/list_drag.rs
diff --git a/crates/ui-egui/src/proto_editor.rs b/crates/ui-egui/src/panels/proto_editor.rs
similarity index 100%
rename from crates/ui-egui/src/proto_editor.rs
rename to crates/ui-egui/src/panels/proto_editor.rs
diff --git a/crates/ui-egui/src/proto_panel.rs b/crates/ui-egui/src/panels/proto_panel.rs
similarity index 100%
rename from crates/ui-egui/src/proto_panel.rs
rename to crates/ui-egui/src/panels/proto_panel.rs
diff --git a/crates/ui-egui/src/right.rs b/crates/ui-egui/src/panels/right.rs
similarity index 100%
rename from crates/ui-egui/src/right.rs
rename to crates/ui-egui/src/panels/right.rs
diff --git a/crates/ui-egui/src/scale_panel.rs b/crates/ui-egui/src/panels/scale_panel.rs
similarity index 100%
rename from crates/ui-egui/src/scale_panel.rs
rename to crates/ui-egui/src/panels/scale_panel.rs
diff --git a/crates/ui-egui/src/section_panel.rs b/crates/ui-egui/src/panels/section_panel.rs
similarity index 100%
rename from crates/ui-egui/src/section_panel.rs
rename to crates/ui-egui/src/panels/section_panel.rs
diff --git a/crates/ui-egui/src/selection_colors.rs b/crates/ui-egui/src/panels/selection_colors.rs
similarity index 100%
rename from crates/ui-egui/src/selection_colors.rs
rename to crates/ui-egui/src/panels/selection_colors.rs
diff --git a/crates/ui-egui/src/shortcuts_panel.rs b/crates/ui-egui/src/panels/shortcuts_panel.rs
similarity index 100%
rename from crates/ui-egui/src/shortcuts_panel.rs
rename to crates/ui-egui/src/panels/shortcuts_panel.rs
diff --git a/crates/ui-egui/src/typography.rs b/crates/ui-egui/src/panels/typography.rs
similarity index 100%
rename from crates/ui-egui/src/typography.rs
rename to crates/ui-egui/src/panels/typography.rs
diff --git a/crates/ui-egui/src/variable_ui.rs b/crates/ui-egui/src/panels/variable_ui.rs
similarity index 100%
rename from crates/ui-egui/src/variable_ui.rs
rename to crates/ui-egui/src/panels/variable_ui.rs
diff --git a/crates/ui-egui/src/vector_panel.rs b/crates/ui-egui/src/panels/vector_panel.rs
similarity index 100%
rename from crates/ui-egui/src/vector_panel.rs
rename to crates/ui-egui/src/panels/vector_panel.rs
diff --git a/crates/ui-egui/src/versions.rs b/crates/ui-egui/src/panels/versions.rs
similarity index 100%
rename from crates/ui-egui/src/versions.rs
rename to crates/ui-egui/src/panels/versions.rs

From 525d5cb6a160a7c265cb6938da9102fb66ae93a0 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:41 +0000
Subject: [PATCH 21/67] refactor(ui-egui): move credits, missing_fonts,
 import_report, updates_ui, variables_panel, branch_ui, plugins_ui to dialogs/

---
 crates/ui-egui/src/dialogs.rs                      |  7 +++++++
 crates/ui-egui/src/{ => dialogs}/branch_ui.rs      |  0
 crates/ui-egui/src/{ => dialogs}/credits.rs        |  0
 crates/ui-egui/src/{ => dialogs}/credits_tests.rs  |  0
 crates/ui-egui/src/{ => dialogs}/import_report.rs  |  0
 crates/ui-egui/src/{ => dialogs}/missing_fonts.rs  |  0
 crates/ui-egui/src/{ => dialogs}/plugins_ui.rs     |  0
 crates/ui-egui/src/{ => dialogs}/updates_ui.rs     |  0
 .../ui-egui/src/{ => dialogs}/variables_panel.rs   |  0
 crates/ui-egui/src/lib.rs                          | 14 +++++++-------
 10 files changed, 14 insertions(+), 7 deletions(-)
 rename crates/ui-egui/src/{ => dialogs}/branch_ui.rs (100%)
 rename crates/ui-egui/src/{ => dialogs}/credits.rs (100%)
 rename crates/ui-egui/src/{ => dialogs}/credits_tests.rs (100%)
 rename crates/ui-egui/src/{ => dialogs}/import_report.rs (100%)
 rename crates/ui-egui/src/{ => dialogs}/missing_fonts.rs (100%)
 rename crates/ui-egui/src/{ => dialogs}/plugins_ui.rs (100%)
 rename crates/ui-egui/src/{ => dialogs}/updates_ui.rs (100%)
 rename crates/ui-egui/src/{ => dialogs}/variables_panel.rs (100%)

diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 8ada24e8..f10e008a 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -13,6 +13,13 @@ use crate::FigApp;
 use crate::export_panel::{export_layers, save_one, suggested_name};
 use crate::i18n::{self, tr, tr_noop, trf, trn};
 use crate::theme::{Tokens, regular, semibold};
+pub mod branch_ui;
+pub mod credits;
+pub mod import_report;
+pub mod missing_fonts;
+pub mod plugins_ui;
+pub mod updates_ui;
+pub mod variables_panel;
 
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
diff --git a/crates/ui-egui/src/branch_ui.rs b/crates/ui-egui/src/dialogs/branch_ui.rs
similarity index 100%
rename from crates/ui-egui/src/branch_ui.rs
rename to crates/ui-egui/src/dialogs/branch_ui.rs
diff --git a/crates/ui-egui/src/credits.rs b/crates/ui-egui/src/dialogs/credits.rs
similarity index 100%
rename from crates/ui-egui/src/credits.rs
rename to crates/ui-egui/src/dialogs/credits.rs
diff --git a/crates/ui-egui/src/credits_tests.rs b/crates/ui-egui/src/dialogs/credits_tests.rs
similarity index 100%
rename from crates/ui-egui/src/credits_tests.rs
rename to crates/ui-egui/src/dialogs/credits_tests.rs
diff --git a/crates/ui-egui/src/import_report.rs b/crates/ui-egui/src/dialogs/import_report.rs
similarity index 100%
rename from crates/ui-egui/src/import_report.rs
rename to crates/ui-egui/src/dialogs/import_report.rs
diff --git a/crates/ui-egui/src/missing_fonts.rs b/crates/ui-egui/src/dialogs/missing_fonts.rs
similarity index 100%
rename from crates/ui-egui/src/missing_fonts.rs
rename to crates/ui-egui/src/dialogs/missing_fonts.rs
diff --git a/crates/ui-egui/src/plugins_ui.rs b/crates/ui-egui/src/dialogs/plugins_ui.rs
similarity index 100%
rename from crates/ui-egui/src/plugins_ui.rs
rename to crates/ui-egui/src/dialogs/plugins_ui.rs
diff --git a/crates/ui-egui/src/updates_ui.rs b/crates/ui-egui/src/dialogs/updates_ui.rs
similarity index 100%
rename from crates/ui-egui/src/updates_ui.rs
rename to crates/ui-egui/src/dialogs/updates_ui.rs
diff --git a/crates/ui-egui/src/variables_panel.rs b/crates/ui-egui/src/dialogs/variables_panel.rs
similarity index 100%
rename from crates/ui-egui/src/variables_panel.rs
rename to crates/ui-egui/src/dialogs/variables_panel.rs
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index a5b1ad70..7e64906d 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -8,12 +8,10 @@
 pub mod a11y;
 pub mod bidi;
 mod board_picker;
-pub mod branch_ui;
 pub mod canvas;
 pub mod cjk;
 pub mod colorpicker;
 pub mod control;
-pub mod credits;
 pub mod dialogs;
 pub mod field_math;
 pub mod font_preview;
@@ -21,13 +19,10 @@ pub mod home;
 pub mod home_recents;
 pub mod i18n;
 pub mod icons;
-pub mod import_report;
 pub mod live;
 pub mod menus;
-pub mod missing_fonts;
 pub mod online;
 pub mod pending_open;
-pub mod plugins_ui;
 pub mod present;
 pub mod shortcuts;
 pub mod style_picker;
@@ -35,8 +30,6 @@ pub mod tabs;
 pub mod theme;
 pub mod toolbar;
 pub mod ui_scale;
-pub mod updates_ui;
-pub mod variables_panel;
 pub mod widgets;
 pub mod windows;
 
@@ -240,6 +233,13 @@ pub use canvas::proto_canvas;
 pub use canvas::render_worker;
 use canvas::selection_spacing;
 pub use canvas::widget_bar;
+pub use dialogs::branch_ui;
+pub use dialogs::credits;
+pub use dialogs::import_report;
+pub use dialogs::missing_fonts;
+pub use dialogs::plugins_ui;
+pub use dialogs::updates_ui;
+pub use dialogs::variables_panel;
 pub use panels::assets_panel;
 pub use panels::component_panel;
 pub use panels::dev_compare;

From 49ca56c3a42e73bfdb53071533831c730cb7577f Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:41 +0000
Subject: [PATCH 22/67] refactor(ui-egui): move colorpicker, style_picker,
 field_math, font_preview, board_picker to widgets/

---
 crates/ui-egui/src/lib.rs                              | 10 +++++-----
 crates/ui-egui/src/widgets.rs                          |  5 +++++
 crates/ui-egui/src/{ => widgets}/board_picker.rs       |  0
 crates/ui-egui/src/{ => widgets}/colorpicker.rs        |  0
 crates/ui-egui/src/{ => widgets}/field_math.rs         |  0
 crates/ui-egui/src/{ => widgets}/font_preview.rs       |  0
 crates/ui-egui/src/{ => widgets}/style_picker.rs       |  0
 crates/ui-egui/src/{ => widgets}/style_picker_tests.rs |  0
 8 files changed, 10 insertions(+), 5 deletions(-)
 rename crates/ui-egui/src/{ => widgets}/board_picker.rs (100%)
 rename crates/ui-egui/src/{ => widgets}/colorpicker.rs (100%)
 rename crates/ui-egui/src/{ => widgets}/field_math.rs (100%)
 rename crates/ui-egui/src/{ => widgets}/font_preview.rs (100%)
 rename crates/ui-egui/src/{ => widgets}/style_picker.rs (100%)
 rename crates/ui-egui/src/{ => widgets}/style_picker_tests.rs (100%)

diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 7e64906d..f9c2e623 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -7,14 +7,10 @@
 
 pub mod a11y;
 pub mod bidi;
-mod board_picker;
 pub mod canvas;
 pub mod cjk;
-pub mod colorpicker;
 pub mod control;
 pub mod dialogs;
-pub mod field_math;
-pub mod font_preview;
 pub mod home;
 pub mod home_recents;
 pub mod i18n;
@@ -25,7 +21,6 @@ pub mod online;
 pub mod pending_open;
 pub mod present;
 pub mod shortcuts;
-pub mod style_picker;
 pub mod tabs;
 pub mod theme;
 pub mod toolbar;
@@ -260,6 +255,11 @@ pub use panels::typography;
 pub use panels::variable_ui;
 pub use panels::vector_panel;
 pub use panels::versions;
+use widgets::board_picker;
+pub use widgets::colorpicker;
+pub use widgets::field_math;
+pub use widgets::font_preview;
+pub use widgets::style_picker;
 
 use std::collections::BTreeSet;
 use std::ffi::OsStr;
diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs
index 5f08a998..0a39604e 100644
--- a/crates/ui-egui/src/widgets.rs
+++ b/crates/ui-egui/src/widgets.rs
@@ -8,6 +8,11 @@ pub use crate::field_math::{Rel, Typed, eval, parse, stepped};
 use crate::i18n::tr;
 use crate::icons::{self, Icon};
 use crate::theme::{Tokens, regular, semibold};
+pub(crate) mod board_picker;
+pub mod colorpicker;
+pub mod field_math;
+pub mod font_preview;
+pub mod style_picker;
 
 pub const ROW_H: f32 = 32.0;
 pub const FIELD_H: f32 = 24.0;
diff --git a/crates/ui-egui/src/board_picker.rs b/crates/ui-egui/src/widgets/board_picker.rs
similarity index 100%
rename from crates/ui-egui/src/board_picker.rs
rename to crates/ui-egui/src/widgets/board_picker.rs
diff --git a/crates/ui-egui/src/colorpicker.rs b/crates/ui-egui/src/widgets/colorpicker.rs
similarity index 100%
rename from crates/ui-egui/src/colorpicker.rs
rename to crates/ui-egui/src/widgets/colorpicker.rs
diff --git a/crates/ui-egui/src/field_math.rs b/crates/ui-egui/src/widgets/field_math.rs
similarity index 100%
rename from crates/ui-egui/src/field_math.rs
rename to crates/ui-egui/src/widgets/field_math.rs
diff --git a/crates/ui-egui/src/font_preview.rs b/crates/ui-egui/src/widgets/font_preview.rs
similarity index 100%
rename from crates/ui-egui/src/font_preview.rs
rename to crates/ui-egui/src/widgets/font_preview.rs
diff --git a/crates/ui-egui/src/style_picker.rs b/crates/ui-egui/src/widgets/style_picker.rs
similarity index 100%
rename from crates/ui-egui/src/style_picker.rs
rename to crates/ui-egui/src/widgets/style_picker.rs
diff --git a/crates/ui-egui/src/style_picker_tests.rs b/crates/ui-egui/src/widgets/style_picker_tests.rs
similarity index 100%
rename from crates/ui-egui/src/style_picker_tests.rs
rename to crates/ui-egui/src/widgets/style_picker_tests.rs

From 7d3978bedf3f47d0da75e706ab67d0d32ba39e51 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:08:42 +0000
Subject: [PATCH 23/67] refactor(ui-egui): move home_recents, online to home/

---
 crates/ui-egui/src/home.rs                    | 2 ++
 crates/ui-egui/src/{ => home}/home_recents.rs | 0
 crates/ui-egui/src/{ => home}/online.rs       | 0
 crates/ui-egui/src/lib.rs                     | 4 ++--
 4 files changed, 4 insertions(+), 2 deletions(-)
 rename crates/ui-egui/src/{ => home}/home_recents.rs (100%)
 rename crates/ui-egui/src/{ => home}/online.rs (100%)

diff --git a/crates/ui-egui/src/home.rs b/crates/ui-egui/src/home.rs
index 922c0fda..05c8fcda 100644
--- a/crates/ui-egui/src/home.rs
+++ b/crates/ui-egui/src/home.rs
@@ -15,6 +15,8 @@ use crate::i18n::{tr, tr_noop};
 use crate::icons::{self, Icon};
 use crate::theme::{ACCENT, Tokens, regular, semibold};
 use crate::widgets;
+pub mod home_recents;
+pub mod online;
 
 /// The section the home screen shows.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
diff --git a/crates/ui-egui/src/home_recents.rs b/crates/ui-egui/src/home/home_recents.rs
similarity index 100%
rename from crates/ui-egui/src/home_recents.rs
rename to crates/ui-egui/src/home/home_recents.rs
diff --git a/crates/ui-egui/src/online.rs b/crates/ui-egui/src/home/online.rs
similarity index 100%
rename from crates/ui-egui/src/online.rs
rename to crates/ui-egui/src/home/online.rs
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index f9c2e623..1e89a3e7 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -12,12 +12,10 @@ pub mod cjk;
 pub mod control;
 pub mod dialogs;
 pub mod home;
-pub mod home_recents;
 pub mod i18n;
 pub mod icons;
 pub mod live;
 pub mod menus;
-pub mod online;
 pub mod pending_open;
 pub mod present;
 pub mod shortcuts;
@@ -235,6 +233,8 @@ pub use dialogs::missing_fonts;
 pub use dialogs::plugins_ui;
 pub use dialogs::updates_ui;
 pub use dialogs::variables_panel;
+pub use home::home_recents;
+pub use home::online;
 pub use panels::assets_panel;
 pub use panels::component_panel;
 pub use panels::dev_compare;

From 2e7790b58baea5896e20514730b75d5b9cb2f08b Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:20:45 +0000
Subject: [PATCH 24/67] refactor(engine): split canvas/tools.rs into tools/

---
 crates/engine/src/canvas/tools.rs         | 2335 +--------------------
 crates/engine/src/canvas/tools/click.rs   |  344 +++
 crates/engine/src/canvas/tools/drag.rs    |  605 ++++++
 crates/engine/src/canvas/tools/draw.rs    |  229 ++
 crates/engine/src/canvas/tools/handles.rs |  426 ++++
 crates/engine/src/canvas/tools/keys.rs    |  174 ++
 crates/engine/src/canvas/tools/pen.rs     |  276 +++
 crates/engine/src/canvas/tools/pointer.rs |  292 +++
 8 files changed, 2365 insertions(+), 2316 deletions(-)
 create mode 100644 crates/engine/src/canvas/tools/click.rs
 create mode 100644 crates/engine/src/canvas/tools/drag.rs
 create mode 100644 crates/engine/src/canvas/tools/draw.rs
 create mode 100644 crates/engine/src/canvas/tools/handles.rs
 create mode 100644 crates/engine/src/canvas/tools/keys.rs
 create mode 100644 crates/engine/src/canvas/tools/pen.rs
 create mode 100644 crates/engine/src/canvas/tools/pointer.rs

diff --git a/crates/engine/src/canvas/tools.rs b/crates/engine/src/canvas/tools.rs
index 424694b3..fce14f7c 100644
--- a/crates/engine/src/canvas/tools.rs
+++ b/crates/engine/src/canvas/tools.rs
@@ -19,6 +19,25 @@ use crate::shape_handles::{ShapeHandle, ShapeHint};
 use crate::snap::{Guide, Targets};
 use crate::{Result, Session, textedit};
 
+mod click;
+mod drag;
+mod draw;
+mod handles;
+mod keys;
+mod pen;
+mod pointer;
+
+use handles::DRAG_SLOP_PX;
+#[cfg(test)]
+pub(crate) use handles::scale_factor;
+pub use handles::{
+    PENCIL_STROKE, SMALL_BOX_PX, anchor_name, anchor_of, box_sides_px, handle_at, handle_at_corners, label_at, locked_in, scale_anchor_point,
+    selection_box, selection_frame,
+};
+pub(crate) use handles::{SNAP_PX, handle_cursor, readable_text_fills, resized_box};
+#[cfg(test)]
+pub(crate) use pen::pressure_profile;
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Default)]
 pub enum ToolId {
     #[default]
@@ -552,2324 +571,8 @@ pub struct ToolState {
     pub picked: Option<figcraft_color::Color>,
 }
 
-/// Pen pressure along drawn samples as width profile points `[t, scale]`: `t` by length, at most
-/// 32 points, medium pressure (0.5) at the stroke weight, from a tenth to twice it. `None` when no
-/// sample has pressure.
-pub(crate) fn pressure_profile(points: &[Point], pressure: &[Option<f32>]) -> Option<Vec<[f64; 2]>> {
-    if pressure.iter().all(Option::is_none) {
-        return None;
-    }
-    let mut lengths = vec![0.0];
-    for w in points.windows(2) {
-        let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
-        lengths.push(lengths.last().copied().unwrap_or(0.0) + (*b - *a).hypot());
-    }
-    let total = lengths.last().copied().unwrap_or(0.0);
-    if !(total.is_finite() && total > 0.0) {
-        return None;
-    }
-    let at = |i: usize| f64::from(pressure.get(i).copied().flatten().filter(|p| p.is_finite()).unwrap_or(0.5).clamp(0.0, 1.0));
-    let n = points.len().clamp(2, 32);
-    let profile = (0..n).map(|k| {
-        let t = k as f64 / (n - 1) as f64;
-        let s = t * total;
-        let i = lengths.partition_point(|l| *l < s).min(lengths.len().saturating_sub(1));
-        let p = match (i.checked_sub(1).and_then(|j| lengths.get(j)), lengths.get(i)) {
-            (Some(a), Some(b)) if b > a => at(i - 1) + (at(i) - at(i - 1)) * ((s - a) / (b - a)),
-            _ => at(i),
-        };
-        [t, (p / 0.5).clamp(0.1, 2.0)]
-    });
-    Some(profile.collect())
-}
-
-/// A frame or section drawn around layers takes those of its siblings that lie fully inside it
-/// (visible and unlocked ones, in their order; a frame never takes a section). Not in auto layout,
-/// where the new frame is one more item of the flow.
-fn take_enclosed(doc: &mut Document, drawn: NodeId) -> Result<()> {
-    let Some(n) = doc.node(drawn) else { return Ok(()) };
-    let section = matches!(n.kind, NodeKind::Section { .. });
-    let (Some(parent), Some(area)) = (n.parent.and_then(|p| doc.node(p)), doc.world_bounds(drawn)) else { return Ok(()) };
-    if parent.layout.is_some() {
-        return Ok(());
-    }
-    let inside: Vec<NodeId> = parent
-        .children
-        .iter()
-        .copied()
-        .filter(|c| *c != drawn && doc.node(*c).is_some_and(|k| k.visible && !k.locked && (section || !matches!(k.kind, NodeKind::Section { .. }))))
-        .filter(|c| doc.world_bounds(*c).is_some_and(|b| area.contains(b.origin()) && area.contains(Point::new(b.x1, b.y1))))
-        .collect();
-    for c in inside {
-        doc.reparent(c, drawn, None)?;
-    }
-    Ok(())
-}
-
-/// The frame whose name label (see [`ToolState::labels`]) is under `p` on `page`: the topmost
-/// one drawn, if it can be selected (still there, on the page, visible and unlocked).
-pub fn label_at(doc: &Document, page: NodeId, labels: &[(NodeId, [Point; 4])], p: Point) -> Option<NodeId> {
-    labels
-        .iter()
-        .rev()
-        .find(|(id, q)| in_quad(q, p) && doc.page_of(*id) == Some(page) && doc.node(*id).is_some_and(|n| n.visible && !n.locked))
-        .map(|(id, _)| *id)
-}
-
-/// Whether `p` is inside the convex quadrilateral `q` (either winding; edges included).
-fn in_quad(q: &[Point; 4], p: Point) -> bool {
-    let (mut left, mut right) = (false, false);
-    for (a, b) in q.iter().zip(q.iter().cycle().skip(1)) {
-        let side = (*b - *a).cross(p - *a);
-        if !side.is_finite() {
-            return false;
-        }
-        left |= side < 0.0;
-        right |= side > 0.0;
-    }
-    // On one side of every edge (a point can't be on all four edges of a quad with an area).
-    left != right
-}
-
-/// An anchor name (`tl`, `t`, `tr`, `l`, `c`, `r`, `bl`, `b`, `br`) as column and row (0 start,
-/// 1 middle, 2 end).
-pub fn anchor_of(name: &str) -> Option<(u8, u8)> {
-    ANCHORS.iter().position(|a| a.eq_ignore_ascii_case(name.trim())).map(|i| ((i % 3) as u8, (i / 3) as u8))
-}
-
-/// The name of anchor `(column, row)`.
-pub fn anchor_name(a: (u8, u8)) -> &'static str {
-    ANCHORS.get(usize::from(a.1.min(2)) * 3 + usize::from(a.0.min(2))).copied().unwrap_or("tl")
-}
-
-/// The fill new text takes to be readable where it is drawn, in `parent`: white on a dark
-/// background (None: the model's default, black). The background is the nearest layer from `parent`
-/// out whose top visible fill is a mostly opaque solid colour, else the page (#362). For text made
-/// in the app: by the Text tool, or by a command that names no fill while the interface is up.
-pub(crate) fn readable_text_fills(doc: &Document, parent: NodeId) -> Option<Vec<figcraft_color::Paint>> {
-    let dark = std::iter::once(parent).chain(doc.ancestors(parent)).filter_map(|id| doc.node(id)).find_map(|n| match &n.kind {
-        NodeKind::Page { background, .. } => Some(background.is_dark()),
-        _ => n.fills.iter().rev().find(|p| p.visible).and_then(|p| p.solid_color()).filter(|c| c.a >= 0.5).map(|c| c.is_dark()),
-    });
-    dark.unwrap_or(false).then(|| vec![figcraft_color::Paint::solid(figcraft_color::Color::WHITE)])
-}
-
-const ANCHORS: [&str; 9] = ["tl", "t", "tr", "l", "c", "r", "bl", "b", "br"];
-
 impl ToolState {
     pub fn busy(&self) -> bool {
         !matches!(self.gesture, Gesture::None)
     }
 }
-
-const HANDLE_PX: f64 = 5.0;
-const ROTATE_PX: f64 = 18.0;
-/// Snap distance in screen pixels.
-pub(crate) const SNAP_PX: f64 = 5.0;
-/// Screen pixels the pointer travels after a press before a move or resize starts: a click or a
-/// double-click made with an unsteady hand doesn't drag what it lands on.
-const DRAG_SLOP_PX: f64 = 3.0;
-/// Screen pixels from a path within which the Text on a path tool takes it.
-const PATH_REACH_PX: f64 = 6.0;
-
-/// The visible layers under `id` whose box, grown by `reach` (page units), holds `p`, front-most
-/// first: what the Text on a path tool measures its distance to. Content a clipping frame or a
-/// mask hides at `p` and the operands of boolean groups are left out.
-fn path_candidates(doc: &Document, id: NodeId, p: Point, reach: f64, depth: usize, out: &mut Vec<NodeId>) {
-    let Some(n) = doc.node(id) else { return };
-    if !n.visible || depth > 512 || matches!(n.kind, NodeKind::BooleanOp { .. }) {
-        return;
-    }
-    if n.clip && n.kind.is_frame_like() && !n.local_rect().contains(doc.world_transform(id).inverse() * p) {
-        return;
-    }
-    for c in n.paint_order().rev() {
-        let before = out.len();
-        path_candidates(doc, c, p, reach, depth + 1, out);
-        if out.len() > before && figcraft_doc::geometry::masked_out(doc, n, c, p) {
-            out.truncate(before);
-        }
-    }
-    if n.children.is_empty() && !n.is_mask && doc.world_bounds(id).is_some_and(|b| b.inflate(reach, reach).contains(p)) {
-        out.push(id);
-    }
-}
-
-/// Corners of the selection's handle box in page coordinates (tl, tr, br, bl).
-pub fn selection_box(doc: &Document, sel: &[NodeId]) -> Option<[Point; 4]> {
-    let (f, w, h) = selection_frame(doc, sel)?;
-    Some([f * Point::ZERO, f * Point::new(w, 0.0), f * Point::new(w, h), f * Point::new(0.0, h)])
-}
-
-/// The selection's handle box: the page transform of its top-left corner (axes along the box) and
-/// its size. One layer: its own box; several sharing a rotation: a box turned with them;
-/// otherwise the page-aligned bounds.
-pub fn selection_frame(doc: &Document, sel: &[NodeId]) -> Option<(Affine, f64, f64)> {
-    let ids = roots(doc, sel);
-    if let [id] = ids.as_slice() {
-        let n = doc.node(*id)?;
-        return Some((doc.world_transform(*id), n.width, n.height));
-    }
-    let Some(angle) = shared_rotation(doc, &ids) else {
-        let b = doc.bounds_of(&ids)?;
-        return Some((Affine::translate((b.x0, b.y0)), b.width(), b.height()));
-    };
-    let rot = Affine::rotate(angle);
-    let inv = rot.inverse();
-    let b = ids
-        .iter()
-        .filter_map(|i| Some(figcraft_geom::transform_rect_bbox(inv * doc.world_transform(*i), doc.node(*i)?.local_rect())))
-        .reduce(|a, b| a.union(b))?;
-    Some((rot * Affine::translate((b.x0, b.y0)), b.width(), b.height()))
-}
-
-/// The rotation (radians) every layer in `ids` shares, unless it's a multiple of 90 degrees (the
-/// page-aligned box is then the same box). Flipped layers count by their axis, not its direction.
-fn shared_rotation(doc: &Document, ids: &[NodeId]) -> Option<f64> {
-    use std::f64::consts::{FRAC_PI_2, PI};
-    const EPS: f64 = 1e-4;
-    let mut angles = ids.iter().map(|i| {
-        let c = doc.world_transform(*i).as_coeffs();
-        c[1].atan2(c[0])
-    });
-    let a = angles.next()?;
-    let same = |b: f64| {
-        let d = (b - a).rem_euclid(PI);
-        d.min(PI - d) < EPS
-    };
-    let axis_aligned = (a - (a / FRAC_PI_2).round() * FRAC_PI_2).abs() < EPS;
-    (a.is_finite() && !axis_aligned && angles.all(same)).then_some(a)
-}
-
-/// Whether layer `id` is locked or inside a locked layer: it can be selected in the layers panel
-/// but not moved or resized on the canvas.
-pub fn locked_in(doc: &Document, id: NodeId) -> bool {
-    std::iter::once(id).chain(doc.ancestors(id)).any(|a| doc.node(a).is_some_and(|n| n.locked))
-}
-
-/// Whether layer `t` paints below layer `s`: it holds `s`, or it is behind `s` in the stack of the
-/// nearest layer holding both.
-fn paints_below(doc: &Document, t: NodeId, s: NodeId) -> bool {
-    let chain = |id: NodeId| {
-        let mut c: Vec<NodeId> = std::iter::once(id).chain(doc.ancestors(id)).collect();
-        c.reverse();
-        c
-    };
-    let (ct, cs) = (chain(t), chain(s));
-    let shared = ct.iter().zip(&cs).take_while(|(a, b)| a == b).count();
-    match (ct.get(shared), cs.get(shared)) {
-        (None, Some(_)) => true,
-        (Some(a), Some(b)) => shared.checked_sub(1).and_then(|i| ct.get(i)).and_then(|p| doc.node(*p)).is_some_and(|p| {
-            let order: Vec<NodeId> = p.paint_order().collect();
-            order.iter().position(|c| c == a) < order.iter().position(|c| c == b)
-        }),
-        _ => false,
-    }
-}
-
-/// Which handle (if any) is under `p`. A selection with a locked layer has none.
-pub fn handle_at(doc: &Document, sel: &[NodeId], p: Point, zoom: f64) -> Option<Handle> {
-    if sel.is_empty() || sel.iter().any(|i| locked_in(doc, *i)) {
-        return None;
-    }
-    // A connector's handles are its ends (see `board::end_handle_at`): no box to resize or turn.
-    if crate::board::selected_connector_ends(doc, sel).is_some() {
-        return None;
-    }
-    let corners = selection_box(doc, sel)?;
-    // Lines (zero height) only get end handles.
-    let is_line = sel.len() == 1 && sel.first().and_then(|i| doc.node(*i)).is_some_and(|n| matches!(n.kind, NodeKind::Line));
-    handle_at_corners(&corners, p, zoom, is_line)
-}
-
-/// Half the side of the square the canvas draws on each corner of the handle box (screen pixels,
-/// upright whatever the box's rotation).
-const CORNER_SQUARE_PX: f64 = 4.0;
-
-/// Whether `p` is on a corner square of the selection's handle box as drawn: there the corner
-/// resizes, although a corner-radius handle 10 px in reaches that far too.
-fn on_corner_square(doc: &Document, sel: &[NodeId], p: Point, zoom: f64) -> bool {
-    let reach = CORNER_SQUARE_PX / zoom.max(1e-6);
-    matches!(handle_at(doc, sel, p, zoom), Some(Handle::Corner(_)))
-        && selection_box(doc, sel).is_some_and(|c| c.iter().any(|c| (c.x - p.x).abs() <= reach && (c.y - p.y).abs() <= reach))
-}
-
-/// A box whose sides are both shorter than this on screen (pixels) would be covered by its
-/// handles: the canvas draws just its outline (the handles still answer just outside it).
-pub const SMALL_BOX_PX: f64 = 16.0;
-
-/// The stroke the Pencil draws: its colour and weight (the canvas previews it the same).
-pub const PENCIL_STROKE: (figcraft_color::Color, f64) = (figcraft_color::Color::BLACK, 2.0);
-
-/// The shorter and longer sides, in screen pixels, of the box with `corners` (tl, tr, br, bl).
-pub fn box_sides_px(corners: &[Point; 4], zoom: f64) -> (f64, f64) {
-    let [a, b, _, d] = corners;
-    let (w, h) = ((*b - *a).hypot() * zoom, (*d - *a).hypot() * zoom);
-    (w.min(h), w.max(h))
-}
-
-/// Which handle of the box with `corners` (tl, tr, br, bl in page coordinates) is under `p`;
-/// `is_line` keeps only the two end handles.
-pub fn handle_at_corners(corners: &[Point; 4], p: Point, zoom: f64, is_line: bool) -> Option<Handle> {
-    let tol = HANDLE_PX / zoom.max(1e-6);
-    // Inside the box, handles reach in at most a quarter of its shorter side, so that a press in
-    // the middle of a small layer moves it; outside it they reach as far as ever.
-    let inner = if !is_line && in_quad(corners, p) { box_sides_px(corners, zoom).0 / 4.0 / zoom.max(1e-6) } else { f64::INFINITY };
-    let (corner_reach, edge_reach) = ((tol * 1.6).min(inner), tol.min(inner));
-    // The nearest corner, then the nearest edge, in reach (a small box's reaches overlap).
-    let nearest = |hits: &mut dyn Iterator<Item = (f64, Handle)>| hits.min_by(|a, b| a.0.total_cmp(&b.0)).map(|(_, h)| h);
-    let corner = nearest(
-        &mut corners
-            .iter()
-            .enumerate()
-            .filter(|(i, _)| !(is_line && *i >= 2))
-            .map(|(i, c)| ((*c - p).hypot(), Handle::Corner(i as u8)))
-            .filter(|(d, _)| *d <= corner_reach),
-    );
-    if corner.is_some() {
-        return corner;
-    }
-    if !is_line {
-        use figcraft_geom::kurbo::ParamCurveNearest;
-        let edge = nearest(&mut (0..4).filter_map(|i| {
-            let (a, b) = (corners.get(i)?, corners.get((i + 1) % 4)?);
-            let near = figcraft_geom::kurbo::Line::new(*a, *b).nearest(p, 0.001);
-            let d = near.distance_sq.sqrt();
-            (d <= edge_reach && near.t > 0.05 && near.t < 0.95).then_some((d, Handle::Edge(i as u8)))
-        }));
-        if edge.is_some() {
-            return edge;
-        }
-    }
-    // Rotation zones: just outside each corner.
-    let center = Point::new(corners.iter().map(|c| c.x).sum::<f64>() / 4.0, corners.iter().map(|c| c.y).sum::<f64>() / 4.0);
-    let rot = ROTATE_PX / zoom.max(1e-6);
-    for (i, c) in corners.iter().enumerate() {
-        let d = (*c - p).hypot();
-        let outward = (p - *c).dot(*c - center) > 0.0;
-        if d <= rot && d > tol && outward {
-            return Some(Handle::Rotate(i as u8));
-        }
-    }
-    None
-}
-
-fn resize_cursor(doc: &Document, sel: &[NodeId], h: Handle) -> Cursor {
-    selection_box(doc, sel).map_or(Cursor::Default, |c| handle_cursor(&c, h))
-}
-
-/// The cursor over handle `h` of the box with corners `c`.
-pub(crate) fn handle_cursor(c: &[Point; 4], h: Handle) -> Cursor {
-    let angle = |a: Point, b: Point| (b - a).atan2().to_degrees();
-    match h {
-        Handle::Corner(i) => {
-            let a = c.get(i as usize).copied().unwrap_or_default();
-            let b = c.get((i as usize + 2) % 4).copied().unwrap_or_default();
-            // Along the box's own axes at 45°, not the diagonal, so wide or tall boxes still get a
-            // diagonal cursor. A box with no width or height falls back to the diagonal.
-            let unit = |v: figcraft_geom::kurbo::Vec2| {
-                let len = v.hypot();
-                (len.is_finite() && len > 1e-9).then(|| v / len)
-            };
-            let next = c.get((i as usize + 1) % 4).copied().unwrap_or_default();
-            let prev = c.get((i as usize + 3) % 4).copied().unwrap_or_default();
-            match (unit(next - a), unit(prev - a)) {
-                (Some(u), Some(v)) => Cursor::Resize((u + v).atan2().to_degrees()),
-                _ => Cursor::Resize(angle(a, b)),
-            }
-        }
-        Handle::Edge(i) => {
-            let a = c.get(i as usize).copied().unwrap_or_default();
-            let b = c.get((i as usize + 1) % 4).copied().unwrap_or_default();
-            Cursor::Resize(angle(a, b) + 90.0)
-        }
-        Handle::Rotate(i) => {
-            let centre = Point::new(c.iter().map(|p| p.x).sum::<f64>() / 4.0, c.iter().map(|p| p.y).sum::<f64>() / 4.0);
-            Cursor::Rotate(angle(centre, c.get(i as usize).copied().unwrap_or_default()))
-        }
-    }
-}
-
-/// The box (x0, y0, x1, y1) a `w0`×`h0` handle box becomes when `handle` is dragged to `q`, all in
-/// the box's own axes: `keep` constrains proportions, `from_center` resizes about the centre (the
-/// opposite side mirrors the dragged one). Edges that cross over come back reversed (x1 < x0 or
-/// y1 < y0: a flip).
-pub(crate) fn resized_box(handle: Handle, q: Point, w0: f64, h0: f64, keep: bool, from_center: bool) -> (f64, f64, f64, f64) {
-    let (mut x0, mut y0, mut x1, mut y1) = (0.0, 0.0, w0, h0);
-    // The dragged sides: x0 or x1 (`Some(false)` / `Some(true)`), y0 or y1.
-    let (sx, sy) = match handle {
-        Handle::Corner(0) => (Some(false), Some(false)),
-        Handle::Corner(1) => (Some(true), Some(false)),
-        Handle::Corner(2) => (Some(true), Some(true)),
-        Handle::Corner(_) => (Some(false), Some(true)),
-        Handle::Edge(0) => (None, Some(false)),
-        Handle::Edge(1) => (Some(true), None),
-        Handle::Edge(2) => (None, Some(true)),
-        Handle::Edge(_) => (Some(false), None),
-        Handle::Rotate(_) => (None, None),
-    };
-    match sx {
-        Some(false) => (x0, x1) = (q.x, if from_center { w0 - q.x } else { w0 }),
-        Some(true) => (x0, x1) = (if from_center { w0 - q.x } else { 0.0 }, q.x),
-        None => {}
-    }
-    match sy {
-        Some(false) => (y0, y1) = (q.y, if from_center { h0 - q.y } else { h0 }),
-        Some(true) => (y0, y1) = (if from_center { h0 - q.y } else { 0.0 }, q.y),
-        None => {}
-    }
-    if keep && w0 > 1e-9 && h0 > 1e-9 && !matches!(handle, Handle::Rotate(_)) {
-        // One factor for both axes: the dragged axis's (a corner: the one that moved the most),
-        // about the point that stays put (the opposite handle, or the centre).
-        let (kx, ky) = ((x1 - x0) / w0, (y1 - y0) / h0);
-        let k = match (sx, sy) {
-            (None, _) => ky,
-            (_, None) => kx,
-            _ if kx.abs() > ky.abs() => kx,
-            _ => ky,
-        };
-        let pivot = if from_center { Point::new(w0 / 2.0, h0 / 2.0) } else { handle_point(opposite(handle), w0, h0) };
-        (x0, x1) = (pivot.x * (1.0 - k), pivot.x + (w0 - pivot.x) * k);
-        (y0, y1) = (pivot.y * (1.0 - k), pivot.y + (h0 - pivot.y) * k);
-    }
-    (x0, y0, x1, y1)
-}
-
-/// A handle's point in its box's axes (`w0`×`h0`): a corner or an edge's middle.
-fn handle_point(h: Handle, w0: f64, h0: f64) -> Point {
-    match h {
-        Handle::Corner(0) | Handle::Rotate(0) => Point::new(0.0, 0.0),
-        Handle::Corner(1) | Handle::Rotate(1) => Point::new(w0, 0.0),
-        Handle::Corner(2) | Handle::Rotate(2) => Point::new(w0, h0),
-        Handle::Corner(_) | Handle::Rotate(_) => Point::new(0.0, h0),
-        Handle::Edge(0) => Point::new(w0 / 2.0, 0.0),
-        Handle::Edge(1) => Point::new(w0, h0 / 2.0),
-        Handle::Edge(2) => Point::new(w0 / 2.0, h0),
-        Handle::Edge(_) => Point::new(0.0, h0 / 2.0),
-    }
-}
-
-/// Anchor `(column, row)` of a `w`×`h` box, in its axes.
-fn anchor_in_box(anchor: (u8, u8), w: f64, h: f64) -> Point {
-    Point::new(w * f64::from(anchor.0.min(2)) / 2.0, h * f64::from(anchor.1.min(2)) / 2.0)
-}
-
-/// The Scale tool's anchor point on the selection's handle box, in page coordinates.
-pub fn scale_anchor_point(doc: &Document, sel: &[NodeId], anchor: (u8, u8)) -> Option<Point> {
-    let (f, w, h) = selection_frame(doc, sel)?;
-    Some(f * anchor_in_box(anchor, w, h))
-}
-
-/// The handle across the box from `h`.
-fn opposite(h: Handle) -> Handle {
-    match h {
-        Handle::Corner(i) => Handle::Corner((i + 2) % 4),
-        Handle::Edge(i) => Handle::Edge((i + 2) % 4),
-        Handle::Rotate(i) => Handle::Rotate((i + 2) % 4),
-    }
-}
-
-/// The Scale tool's factor and pivot (in the box's axes) for dragging `handle` of a `w0`×`h0` box
-/// to `q`. The pivot is the anchor point (`anchor`: column, row), or the opposite handle when the
-/// anchor lies on the side being dragged, or the centre (`from_center`). Corners follow the axis
-/// that moved the most; a negative factor flips. None when the box has no size to scale by.
-pub(crate) fn scale_factor(handle: Handle, q: Point, w0: f64, h0: f64, anchor: (u8, u8), from_center: bool) -> Option<(f64, Point)> {
-    const EPS: f64 = 1e-9;
-    if !(q.x.is_finite() && q.y.is_finite() && w0.is_finite() && h0.is_finite()) || matches!(handle, Handle::Rotate(_)) {
-        return None;
-    }
-    let h = handle_point(handle, w0, h0);
-    let anchor_pt = anchor_in_box(anchor, w0, h0);
-    // The axes the handle moves along.
-    let (ax_x, ax_y) = match handle {
-        Handle::Edge(0) | Handle::Edge(2) => (false, true),
-        Handle::Edge(_) => (true, false),
-        _ => (true, true),
-    };
-    let on_side = (ax_x && (anchor_pt.x - h.x).abs() < EPS) || (ax_y && (anchor_pt.y - h.y).abs() < EPS);
-    let pivot = if from_center {
-        Point::new(w0 / 2.0, h0 / 2.0)
-    } else if on_side {
-        handle_point(opposite(handle), w0, h0)
-    } else {
-        anchor_pt
-    };
-    let ratio = |on: bool, to: f64, from: f64, p: f64| (on && (from - p).abs() > EPS).then(|| (to - p) / (from - p));
-    let kx = ratio(ax_x, q.x, h.x, pivot.x);
-    let ky = ratio(ax_y, q.y, h.y, pivot.y);
-    let k = match (kx, ky) {
-        (Some(a), Some(b)) => {
-            if a.abs() > b.abs() {
-                a
-            } else {
-                b
-            }
-        }
-        (Some(a), None) | (None, Some(a)) => a,
-        (None, None) => return None,
-    };
-    if !k.is_finite() {
-        return None;
-    }
-    // Never collapse to nothing (or blow up past a usable size); 0 counts as positive.
-    Some((k.signum() * k.abs().clamp(0.01, 1000.0), pivot))
-}
-
-impl Session {
-    /// The pointer left the canvas: what hovering there showed goes (the distances Alt or Dev Mode
-    /// measured and the box measured to, a vector region's highlight), unless a gesture holds it.
-    pub fn pointer_left(&mut self) {
-        if !self.tool.busy() {
-            self.tool.overlay.guides.clear();
-            self.tool.overlay.measure_box = None;
-        }
-        self.vector_pointer_left();
-    }
-
-    /// What a marquee starting at page point `p` selects inside: the top-level frame it starts in
-    /// (its children), or the focus view's frame.
-    pub(crate) fn marquee_within(&self, p: Point) -> Result<Option<NodeId>> {
-        let (doc, page) = (self.doc()?, self.page()?);
-        let within = frame_at(doc, page, p, &[]).filter(|f| doc.node(*f).is_some_and(|n| n.parent == Some(page)));
-        let within = within.filter(|f| doc.world_bounds(*f).is_some_and(|b| b.contains(p)));
-        Ok(self.ds()?.focused().or(within))
-    }
-
-    /// The selection a marquee over page rect `r` makes from `base` (what was selected before):
-    /// the layers it touches (`deep`: nested ones too); `additive` (Shift) toggles them.
-    pub(crate) fn marquee_selection(&self, r: Rect, within: Option<NodeId>, deep: bool, base: &[NodeId], additive: bool) -> Result<Vec<NodeId>> {
-        let (doc, page) = (self.doc()?, self.page()?);
-        let mut hits =
-            if deep { figcraft_doc::geometry::marquee_deep(doc, page, r) } else { figcraft_doc::geometry::marquee_select(doc, page, r, within) };
-        if let Some(f) = self.ds()?.focused() {
-            hits.retain(|h| *h != f && doc.is_ancestor(f, *h));
-        }
-        // A marquee over a frame from outside selects the frame only when it covers it fully.
-        if within.is_none() && !deep {
-            hits.retain(|h| {
-                let full = doc.world_bounds(*h).is_some_and(|b| r.contains(b.origin()) && r.contains(Point::new(b.x1, b.y1)));
-                full || !doc.node(*h).is_some_and(|n| n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. }))
-            });
-        }
-        // Shift toggles: what was selected and is touched again comes out.
-        let mut sel: Vec<NodeId> = base.iter().copied().filter(|b| !(additive && hits.contains(b))).collect();
-        for h in hits {
-            if !base.contains(&h) && !sel.contains(&h) {
-                sel.push(h);
-            }
-        }
-        Ok(sel)
-    }
-
-    pub fn set_tool(&mut self, t: ToolId) {
-        if self.tool.tool == ToolId::Pen && t != ToolId::Pen {
-            let _ = self.pen_finish();
-        }
-        if !matches!(t, ToolId::Move | ToolId::Scale | ToolId::Hand) && self.ds().is_ok_and(|d| d.vector_edit.is_some()) {
-            let _ = crate::vectoredit::end(self);
-        }
-        self.tool.tool = t;
-        self.tool.gesture = Gesture::None;
-        self.tool.pick_only = false;
-        // The tool's cursor shows before the pointer moves.
-        self.tool.overlay =
-            Overlay { builder_remove: self.tool.builder_remove && t == ToolId::ShapeBuilder, cursor: t.cursor(), ..Overlay::default() };
-        self.tool.shape_builder = None;
-        if t == ToolId::ShapeBuilder {
-            // Regions show straight away, before the pointer moves.
-            let sel = self.selection();
-            let _ = crate::shapebuilder::arrangement(self, &sel);
-        }
-        if let Ok(ds) = self.ds_mut() {
-            if !matches!(t, ToolId::Text | ToolId::TextOnPath | ToolId::Move) {
-                ds.text_edit = None;
-            }
-            ds.revision += 1;
-        }
-    }
-
-    /// The tool pointer events go to: in Dev Mode every tool but the hand and comments selects.
-    fn acting_tool(&self) -> ToolId {
-        match self.tool.tool {
-            t if self.tool.dev_mode && !matches!(t, ToolId::Hand | ToolId::Comment) => ToolId::Move,
-            t => t,
-        }
-    }
-
-    /// Drop the gesture under way (a drag, a resize, a shape being drawn), restoring the document
-    /// as Escape does; the UI calls it when Dev Mode starts, where nothing may move.
-    pub fn drop_gesture(&mut self) -> Result<()> {
-        self.tool.gesture = Gesture::None;
-        self.cancel_interaction()
-    }
-
-    /// Feed one pointer event to the current tool.
-    pub fn pointer(&mut self, ev: &PointerEvent) -> Result<()> {
-        // A held button sends the same move every frame: running the gesture again would only
-        // rebuild the same preview (a new document, and a canvas render, every frame).
-        if ev.kind != PointerKind::Move {
-            self.tool.last_move = None;
-        } else if self.tool.busy() {
-            if self.tool.last_move.as_ref() == Some(ev) {
-                return Ok(());
-            }
-            self.tool.last_move = Some(ev.clone());
-        }
-        let tool = self.acting_tool();
-        let edits = matches!(tool, ToolId::Move | ToolId::Scale) && !self.tool.dev_mode;
-        if edits && self.origin_pointer(ev)? {
-            return Ok(());
-        }
-        if edits && self.ds().is_ok_and(|d| d.vector_edit.is_some()) && self.vector_pointer(ev)? {
-            return Ok(());
-        }
-        if tool == ToolId::ShapeBuilder {
-            return self.shape_builder_pointer(ev);
-        }
-        match ev.kind {
-            PointerKind::Hover => self.hover(ev),
-            PointerKind::Down => match tool {
-                ToolId::Move | ToolId::Scale => {
-                    // While a board's vote runs, a click on an object votes.
-                    if tool == ToolId::Move && !self.tool.dev_mode && self.vote_down(ev)? {
-                        return Ok(());
-                    }
-                    // A click on the canvas deselects a ruler guide (the UI selects guides itself).
-                    self.ds_mut()?.guide = None;
-                    self.move_down(ev)
-                }
-                ToolId::Hand => {
-                    let v = &self.ds()?.view;
-                    self.tool.gesture = Gesture::Pan { sx: ev.sx, sy: ev.sy, cx: v.cx, cy: v.cy };
-                    self.tool.overlay.cursor = Cursor::Grabbing;
-                    Ok(())
-                }
-                ToolId::Text => self.text_down(ev),
-                ToolId::TextOnPath => self.text_on_path_down(ev),
-                ToolId::Pen => self.pen_down(ev),
-                ToolId::Pencil => {
-                    self.tool.gesture = Gesture::Pencil { points: vec![ev.p()], pressure: vec![ev.pressure] };
-                    Ok(())
-                }
-                ToolId::Comment => {
-                    self.request_ui("comment.new", json!({"x": ev.x, "y": ev.y}));
-                    Ok(())
-                }
-                ToolId::Eyedropper => self.eyedrop(ev),
-                t if t.on_boards() => self.board_down(ev),
-                t if t.draws_shape() => self.draw_down(ev),
-                _ => Ok(()),
-            },
-            PointerKind::Move => self.drag(ev),
-            PointerKind::Up => self.up(ev),
-            PointerKind::DoubleClick => self.double_click(ev),
-        }
-    }
-
-    /// The rotation origin handle while it shows: a press drags it, a double-click puts it back
-    /// at the centre. True when the event was the handle's.
-    fn origin_pointer(&mut self, ev: &PointerEvent) -> Result<bool> {
-        let dragging = matches!(self.tool.gesture, Gesture::Origin);
-        if !dragging && !self.ds()?.on_origin_handle(ev.p(), ev.zoom) {
-            return Ok(false);
-        }
-        match ev.kind {
-            PointerKind::Down if !dragging => self.tool.gesture = Gesture::Origin,
-            PointerKind::Move if dragging => self.drag_origin_to(ev.p(), ev.zoom)?,
-            PointerKind::Up if dragging => self.tool.gesture = Gesture::None,
-            PointerKind::DoubleClick => self.set_rotation_origin(None)?,
-            PointerKind::Hover => {}
-            _ => return Ok(false),
-        }
-        self.tool.overlay.cursor = Cursor::Move;
-        Ok(true)
-    }
-
-    fn hover(&mut self, ev: &PointerEvent) -> Result<()> {
-        let tool = self.acting_tool();
-        let ds = self.ds()?;
-        let (doc, sel, page) = (ds.doc.clone(), ds.selection.clone(), ds.page);
-        let mut cursor = tool.cursor();
-        // The text being edited, and with the Text tool any text, takes the I-beam: a click there
-        // puts the caret.
-        let on_edited = ds
-            .text_edit
-            .as_ref()
-            .is_some_and(|te| doc.world_bounds(te.id).is_some_and(|b| b.inflate(ev.tol() * 4.0, ev.tol() * 4.0).contains(ev.p())));
-        let on_text =
-            |s: &Self| s.hit(&doc, page, ev.p(), ev.tol() * 2.0).and_then(|l| doc.node(l)).is_some_and(|n| matches!(n.kind, NodeKind::Text(_)));
-        if tool == ToolId::Text && (on_edited || on_text(self)) {
-            cursor = Cursor::Text;
-        }
-        if tool == ToolId::TextOnPath && (on_edited || self.path_at(&doc, page, ev).is_some()) {
-            cursor = Cursor::Text;
-        }
-        let mut hover = None;
-        let mut guides = Vec::new();
-        let mut measure_box = None;
-        let arc_hover = if self.arc_handles_shown() { crate::arc_handles::hit(&doc, &sel, ev.p(), ev.zoom).map(|(_, h)| h) } else { None };
-        self.tool.overlay.arc_hover = arc_hover;
-        let shape_hover = if self.arc_handles_shown() && !on_corner_square(&doc, &sel, ev.p(), ev.zoom) {
-            crate::shape_handles::hit(&doc, &sel, ev.p(), ev.zoom).map(|(_, h)| h)
-        } else {
-            None
-        };
-        self.tool.overlay.shape_hover = shape_hover;
-        if matches!(tool, ToolId::Move | ToolId::Scale) && on_edited {
-            cursor = Cursor::Text;
-        } else if matches!(tool, ToolId::Move | ToolId::Scale) && arc_hover.is_none() && shape_hover.is_none() {
-            if let Some(h) = handle_at(&doc, &sel, ev.p(), ev.zoom).filter(|_| !self.tool.dev_mode) {
-                cursor = resize_cursor(&doc, &sel, h);
-            } else {
-                let leaf = self.hit(&doc, page, ev.p(), ev.tol() * 2.0);
-                if leaf.and_then(|l| crate::widgets::target_at(&doc, l, ev.p())).is_some() {
-                    cursor = Cursor::Pointer;
-                }
-                hover = label_at(&doc, page, &self.tool.labels, ev.p()).or_else(|| leaf.map(|leaf| select_target(&doc, leaf, &sel, ev.cmd)));
-                // Alt over a selected layer: a drag from here duplicates it.
-                if ev.alt && !self.tool.dev_mode && tool == ToolId::Move && hover.is_some_and(|h| sel.contains(&h) && !locked_in(&doc, h)) {
-                    cursor = Cursor::Copy;
-                }
-                if ev.alt || self.tool.dev_mode {
-                    use crate::distance::{Hover, guide_at, hover_lines, padding_frame, parent_of};
-                    // Shift+Alt over an auto layout frame: its padding and gaps. Otherwise from the
-                    // selection to a ruler guide, the hovered layer or (over empty canvas) the parent.
-                    let around: Vec<NodeId> = sel.iter().copied().chain(hover).collect();
-                    let what = hover.filter(|_| ev.alt && ev.shift).and_then(|t| padding_frame(&doc, t)).map(Hover::Padding).or_else(|| {
-                        if sel.is_empty() {
-                            return None;
-                        }
-                        let guide = guide_at(&doc, page, &around, ev.p(), ev.tol() * 4.0).map(|(vertical, at)| Hover::Guide { vertical, at });
-                        guide.or_else(|| hover.or_else(|| parent_of(&doc, page, &sel)).map(Hover::Layer))
-                    });
-                    if let Some(what) = what {
-                        let (g, b) = hover_lines(&doc, page, &sel, what);
-                        guides = g;
-                        measure_box = b.map(|b| [b.x0, b.y0, b.x1, b.y1]);
-                    }
-                }
-            }
-        }
-        if tool == ToolId::Move && !self.tool.dev_mode && crate::board::end_handle_at(&doc, &sel, ev.p(), ev.zoom).is_some() {
-            cursor = Cursor::Grab;
-        }
-        self.tool.overlay.measure_box = measure_box;
-        self.tool.overlay.cursor = cursor;
-        if tool == ToolId::Pen {
-            // Where a click would land (snapped), with its guides.
-            let (to, g) = if ev.shift { (ev.p(), Vec::new()) } else { self.snap_pen_tool(ev)? };
-            guides = g;
-            self.tool.overlay.cursor = Cursor::Pen(self.pen_cursor(&doc, &sel, to, ev.zoom));
-            if let Some((last, _, out)) = self.tool.pen.as_ref().and_then(|pen| pen.points.last()) {
-                // With Shift the band ends where a click puts the point (#970).
-                let to = if ev.shift { at_45_degrees(*last, to) } else { to };
-                self.tool.overlay.rubber = Some([last.x, last.y, to.x, to.y]);
-                self.tool.overlay.rubber_handle = (out.hypot() > 0.0).then_some([last.x + out.x, last.y + out.y]);
-            }
-        }
-        self.tool.overlay.guides = guides;
-        let ds = self.ds_mut()?;
-        if ds.hover != hover {
-            ds.hover = hover;
-            ds.revision += 1;
-        }
-        Ok(())
-    }
-
-    /// What a click with the Pen tool at `p` (where it snaps) would do: close the path on its first
-    /// point, connect to another of its points, go on from a selected open path's end, or add a
-    /// new point (the same tests as [`Self::pen_down`]).
-    fn pen_cursor(&self, doc: &Document, sel: &[NodeId], p: Point, zoom: f64) -> PenCursor {
-        let near = |q: &Point| (*q - p).hypot() * zoom < 8.0;
-        let on_point = match &self.tool.pen {
-            None => selected_end_at(doc, sel, p, 8.0 / zoom.max(1e-6)).is_some(),
-            Some(pen) => {
-                let n = pen.points.len();
-                (n > 2 && pen.points.first().is_some_and(|(q, _, _)| near(q)))
-                    || (1..n.saturating_sub(1)).any(|k| pen.points.get(k).is_some_and(|(q, _, _)| near(q)))
-            }
-        };
-        if on_point { PenCursor::Close } else { PenCursor::New }
-    }
-
-    /// Whether what the gesture did to `ids` so far is an edit only a main component can make
-    /// (`moved`: their place among the layers counts too): it is undone when the gesture ends.
-    fn refused(&self, ids: &[NodeId], moved: bool) -> bool {
-        let Ok(ds) = self.ds() else { return false };
-        ds.interaction.as_ref().is_some_and(|it| {
-            ids.iter().any(|m| {
-                (moved && !crate::components::move_allowed(&it.doc, &ds.doc, *m))
-                    || crate::components::refused_override(&it.doc, &ds.doc, *m).is_some()
-            })
-        })
-    }
-
-    fn move_down(&mut self, ev: &PointerEvent) -> Result<()> {
-        let ds = self.ds()?;
-        let (doc, sel, page) = (ds.doc.clone(), ds.selection.clone(), ds.page);
-        // Clicking outside the text being edited ends editing.
-        if let Some(te) = ds.text_edit.clone() {
-            let inside = doc.world_bounds(te.id).is_some_and(|b| b.inflate(ev.tol() * 4.0, ev.tol() * 4.0).contains(ev.p()));
-            if inside {
-                return self.text_click(te.id, ev, ev.shift);
-            }
-            textedit::end(self)?;
-        }
-        // Handles first: a selected connector's ends, a selected ellipse's arc handles (drawn over
-        // the box), then the box's.
-        let edits = !self.tool.dev_mode;
-        if edits && let Some((id, from)) = crate::board::end_handle_at(&doc, &sel, ev.p(), ev.zoom) {
-            self.tool.gesture = Gesture::Reattach { id, from, start: ev.p() };
-            return Ok(());
-        }
-        if self.arc_handles_shown()
-            && let Some((id, handle)) = crate::arc_handles::hit(&doc, &sel, ev.p(), ev.zoom)
-            && let Some(arc) = crate::arc_handles::arc_of(&doc, id)
-        {
-            self.begin_interaction("Arc")?;
-            self.tool.gesture = Gesture::Arc { id, handle, arc };
-            self.tool.overlay.arc =
-                crate::arc_handles::handle_at(&doc, id, handle, arc, ev.zoom).map(|at| ArcHint { handle, label: arc.label(handle), at });
-            return Ok(());
-        }
-        if self.arc_handles_shown()
-            && !on_corner_square(&doc, &sel, ev.p(), ev.zoom)
-            && let Some((id, handle)) = crate::shape_handles::hit(&doc, &sel, ev.p(), ev.zoom)
-        {
-            self.begin_interaction("Corner radius")?;
-            self.tool.gesture = Gesture::Shape { id, handle };
-            self.tool.overlay.shape = shape_hint(&doc, id, handle, ev.zoom);
-            return Ok(());
-        }
-        if let Some(h) = handle_at(&doc, &sel, ev.p(), ev.zoom).filter(|_| edits) {
-            let ids = roots(&doc, &sel);
-            if let Handle::Rotate(_) = h {
-                let Some(b) = selection_box(&doc, &ids) else { return Ok(()) };
-                let center = self
-                    .ds()?
-                    .moved_origin()
-                    .unwrap_or_else(|| Point::new(b.iter().map(|c| c.x).sum::<f64>() / 4.0, b.iter().map(|c| c.y).sum::<f64>() / 4.0));
-                self.begin_interaction("Rotate")?;
-                self.tool.gesture = Gesture::Rotate { center, start_angle: (ev.p() - center).atan2(), ids };
-                return Ok(());
-            }
-            let nodes: Vec<(NodeId, Affine, f64, f64)> =
-                ids.iter().filter_map(|i| doc.node(*i).map(|n| (*i, doc.world_transform(*i), n.width, n.height))).collect();
-            let Some(frame) = selection_frame(&doc, &ids) else { return Ok(()) };
-            let single = ids.len() == 1;
-            self.begin_interaction(if self.tool.tool == ToolId::Scale { "Scale" } else { "Resize" })?;
-            self.tool.gesture = Gesture::Resize {
-                start: ev.p(),
-                r: Box::new(ResizeStart { nodes, frame, single, handle: h }),
-                scale_tool: self.tool.tool == ToolId::Scale,
-                moved: false,
-            };
-            return Ok(());
-        }
-        // A frame's name label picks the frame itself. The background of a top-level frame with
-        // layers in it is like the canvas (a press starts a marquee inside it) unless the frame is
-        // selected; an empty frame (or a widget, or a board object such as a sticky) is picked and
-        // dragged.
-        let board_background = |leaf: NodeId| {
-            !sel.contains(&leaf)
-                && doc.node(leaf).is_some_and(|n| {
-                    n.parent == Some(page) && n.kind.is_frame_like() && !n.children.is_empty() && !crate::widgets::is_widget(n) && !n.is_board_atom()
-                })
-        };
-        let label = label_at(&doc, page, &self.tool.labels, ev.p());
-        let target = label.or_else(|| {
-            self.hit(&doc, page, ev.p(), ev.tol() * 2.0)
-                .filter(|leaf| ev.cmd || !board_background(*leaf))
-                .map(|leaf| select_target(&doc, leaf, &sel, ev.cmd))
-        });
-        // A press inside the selection's box that reaches nothing above it (an unfilled shape's
-        // inside, the frame or canvas behind it, or a layer stacked below the selected layer the
-        // press is in) drags the selection. In a gap between selected layers, what's there is hit.
-        let in_own_box = |s: NodeId| selection_box(&doc, &[s]).is_some_and(|q| in_quad(&q, ev.p()));
-        let behind_sel = |t: Option<NodeId>| {
-            t.is_none_or(|t| sel.iter().any(|s| *s != t && (doc.is_ancestor(t, *s) || (in_own_box(*s) && paints_below(&doc, t, *s)))))
-        };
-        let target = match sel.iter().copied().find(|s| !locked_in(&doc, *s)) {
-            Some(first) if label.is_none() && !ev.shift && behind_sel(target) && selection_box(&doc, &sel).is_some_and(|q| in_quad(&q, ev.p())) => {
-                Some(first)
-            }
-            _ => target,
-        };
-        match target {
-            Some(target) => {
-                // Clicking inside the current selection's box keeps it (drag them all).
-                let in_sel_box = sel.len() > 1 && doc.bounds_of(&sel).is_some_and(|b| b.contains(ev.p())) && !ev.shift;
-                // Shift on a selected layer takes it out on release if the press doesn't become a
-                // drag; a drag moves the selection with it. Where no drag can start, it goes now.
-                let deselect = (ev.shift && sel.contains(&target)).then_some(target);
-                let without_target = || sel.iter().copied().filter(|x| *x != target).collect::<Vec<_>>();
-                let new_sel = if in_sel_box && (sel.contains(&target) || sel.iter().any(|s| doc.is_ancestor(*s, target))) {
-                    sel.clone()
-                } else if ev.shift && deselect.is_none() {
-                    let mut s2 = sel.clone();
-                    s2.push(target);
-                    s2
-                } else if sel.contains(&target) {
-                    sel.clone()
-                } else {
-                    vec![target]
-                };
-                self.set_selection(new_sel.clone());
-                // Dev Mode only selects (Shift-click still deselects): nothing moves.
-                if !edits {
-                    if deselect.is_some() {
-                        self.set_selection(without_target());
-                    }
-                    return Ok(());
-                }
-                // Locked layers selected in the layers panel stay put.
-                let ids: Vec<NodeId> = roots(&doc, &new_sel).into_iter().filter(|i| !locked_in(&doc, *i)).collect();
-                if new_sel.is_empty() || doc.node(target).is_some_and(|n| n.locked) || ids.is_empty() {
-                    if deselect.is_some() {
-                        self.set_selection(without_target());
-                    }
-                    return Ok(());
-                }
-                let mut targets = Targets::gather(&doc, page, &ids);
-                // A copy dragged out with Alt snaps to the layers it came from too (they stay put).
-                if ev.alt
-                    && let Some(b) = targets.moving
-                {
-                    targets.add_box(b);
-                }
-                if let Err(e) = self.begin_interaction(if ev.alt { "Duplicate" } else { "Move" }) {
-                    if deselect.is_some() {
-                        self.set_selection(without_target());
-                    }
-                    return Err(e);
-                }
-                self.tool.gesture = Gesture::Move { start: ev.p(), ids, targets, duplicate: ev.alt, moved: false, deselect };
-                self.tool.overlay.cursor = if ev.alt { Cursor::Copy } else { Cursor::Default };
-            }
-            None => {
-                let within = self.marquee_within(ev.p())?;
-                if !ev.shift {
-                    self.set_selection(vec![]);
-                }
-                self.tool.gesture = Gesture::Marquee { start: ev.p(), additive: ev.shift, base: if ev.shift { sel } else { vec![] }, within };
-            }
-        }
-        Ok(())
-    }
-
-    fn drag(&mut self, ev: &PointerEvent) -> Result<()> {
-        let g = std::mem::take(&mut self.tool.gesture);
-        let res = match &g {
-            Gesture::None => return self.hover(ev),
-            Gesture::Marquee { start, additive, base, within } => {
-                let r = Rect::from_points(*start, ev.p());
-                self.tool.overlay.marquee = Some([r.x0, r.y0, r.x1, r.y1]);
-                // Cmd/Ctrl: the nested layers it touches.
-                let sel = self.marquee_selection(r, *within, ev.cmd, base, *additive)?;
-                self.set_selection(sel);
-                Ok(())
-            }
-            Gesture::Move { start, moved: false, .. } | Gesture::Resize { start, moved: false, .. } if within_slop(ev, *start) => Ok(()),
-            Gesture::Move { start, ids, targets, duplicate, .. } => {
-                let mut d = ev.p() - *start;
-                if ev.shift {
-                    if d.x.abs() > d.y.abs() {
-                        d.y = 0.0;
-                    } else {
-                        d.x = 0.0;
-                    }
-                }
-                // Cmd/Ctrl (and Control on macOS) held while dragging suspends snapping.
-                let snap_on = self.ds().map(|ds| ds.view.snap_objects).unwrap_or(true) && !ev.cmd && !ev.ctrl;
-                let mut guides = Vec::new();
-                if snap_on {
-                    let (c, g2) = targets.snap_move(d, SNAP_PX / ev.zoom.max(1e-6));
-                    d += c;
-                    guides = g2;
-                }
-                if self.ds().map(|ds| ds.view.snap_pixel).unwrap_or(true) {
-                    // Keep the box's origin on whole pixels (a rotated parent frame's, inside one).
-                    d = targets.round_move(d);
-                }
-                let ids = ids.clone();
-                let dup = *duplicate;
-                let page = self.page()?;
-                let mut drop_cell = None;
-                let mut drop_target = None;
-                let mut in_flow = false;
-                // Placed in a row or column: (is it a column, its gap) for the insertion line.
-                let mut slot_axis: Option<(bool, f64)> = None;
-                self.preview(|doc, sel| {
-                    let mut moving = ids.clone();
-                    if dup {
-                        let mut copies = Vec::new();
-                        for i in &ids {
-                            let parent = doc.get(*i)?.parent.unwrap_or(page);
-                            let idx = doc.index_in_parent(*i).map(|x| x + 1);
-                            copies.push(crate::components::copy_in_file(doc, *i, parent, idx)?);
-                        }
-                        // Connectors copied with what they join join the copies.
-                        let map = crate::board::copy_map(doc, &ids, &copies);
-                        crate::board::rejoin(doc, &crate::board::copied_items(doc, &map), &map, false);
-                        moving = copies;
-                        *sel = moving.clone();
-                    }
-                    let p = ev.p();
-                    let home = moving.first().and_then(|i| doc.node(*i)).and_then(|n| n.parent);
-                    // Absolute children of an auto layout frame stay in it, and so do the layers of
-                    // groups, boolean groups and instances ([`crate::drop::keeps_layers`]); the
-                    // rest may change parent.
-                    let flow = moving.iter().all(|i| doc.node(*i).is_some_and(|n| !n.child_layout.absolute))
-                        && !home.is_some_and(|h| crate::drop::keeps_layers(doc, h));
-                    let target = if flow { crate::drop::drag_parent(doc, page, p, &moving) } else { home.unwrap_or(page) };
-                    let mode = doc.node(target).and_then(|n| n.layout.as_ref()).map(|l| l.mode);
-                    if let (true, Some(mode)) = (flow, mode) {
-                        // Into (or within) an auto layout frame: the layers take the slot (a grid: the
-                        // cell) under the pointer, as the frame shows it now. A frame other than the
-                        // one they come from is outlined too.
-                        let cell = if mode == LayoutMode::Grid { crate::drop::grid_cell_at(doc, target, p) } else { None };
-                        let idx =
-                            if mode == LayoutMode::Grid { 0 } else { crate::drop::auto_layout_slot(doc, target, p, &moving).map_or(0, |(i, _)| i) };
-                        for m in &moving {
-                            if doc.get(*m)?.parent != Some(target) {
-                                doc.reparent(*m, target, None)?;
-                            }
-                        }
-                        if let (Some(first), Some((col, row, rect))) = (moving.first().copied(), cell) {
-                            let cl = &mut doc.get_mut(first)?.child_layout;
-                            cl.grid_column = Some(col);
-                            cl.grid_row = Some(row);
-                            drop_cell = Some(rect);
-                        } else if mode != LayoutMode::Grid {
-                            let mut kids: Vec<NodeId> = doc.get(target)?.children.iter().copied().filter(|c| !moving.contains(c)).collect();
-                            for (k, m) in moving.iter().enumerate() {
-                                kids.insert((idx + k).min(kids.len()), *m);
-                            }
-                            let gap = doc.node(target).and_then(|n| n.layout.as_ref()).map_or(0.0, |l| l.gap);
-                            doc.get_mut(target)?.children = kids;
-                            slot_axis = Some((mode == LayoutMode::Vertical, gap));
-                        }
-                        drop_target = (Some(target) != home).then_some(target);
-                        in_flow = true;
-                        return Ok(());
-                    }
-                    // A free move. Layers dragged out of an auto layout flow leave it (onto the page
-                    // while dragging; the drop puts them in the frame under the pointer).
-                    for m in &moving {
-                        let in_al = doc.node(*m).and_then(|n| n.parent).and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some());
-                        if flow && in_al {
-                            doc.reparent(*m, page, None)?;
-                        }
-                        move_world(doc, *m, d.x, d.y)?;
-                    }
-                    drop_target = (flow && target != page).then_some(target);
-                    Ok(())
-                })?;
-                let placed = if dup { self.selection() } else { ids };
-                // Snapping guides mean nothing while the layout places the layers; with Alt held,
-                // live distances to the neighbours replace them.
-                self.tool.overlay.guides = if in_flow {
-                    Vec::new()
-                } else if ev.alt {
-                    let doc = self.doc()?;
-                    doc.bounds_of(&placed).map(|b| crate::distance::neighbours(doc, page, &placed, b)).unwrap_or_default()
-                } else {
-                    guides
-                };
-                // The preview already shows the layers in their slot: the line marks it there, in
-                // the middle of the gap before them (clear of the selection box).
-                self.tool.overlay.insert_line = slot_axis.and_then(|(vertical, gap)| {
-                    let off = if gap.is_finite() { (gap / 2.0).clamp(3.0, 24.0) } else { 3.0 };
-                    self.doc().ok()?.bounds_of(&placed).map(|b| crate::drop::line_before(b, vertical, off))
-                });
-                self.tool.overlay.drop_cell = drop_cell;
-                self.tool.overlay.drop_target = drop_target;
-                self.tool.overlay.cursor = if self.refused(&placed, true) {
-                    Cursor::NotAllowed
-                } else if dup {
-                    Cursor::Copy
-                } else {
-                    Cursor::Default
-                };
-                self.tool.gesture = g.clone();
-                if let Gesture::Move { moved, .. } = &mut self.tool.gesture {
-                    *moved = true;
-                }
-                return Ok(());
-            }
-            Gesture::Resize { start, r, scale_tool, .. } => {
-                let res = self.resize_drag(ev, *start, r, *scale_tool);
-                self.tool.gesture = Gesture::Resize { start: *start, r: r.clone(), scale_tool: *scale_tool, moved: true };
-                if self.refused(&self.selection(), false) {
-                    self.tool.overlay.cursor = Cursor::NotAllowed;
-                }
-                return res;
-            }
-            Gesture::Rotate { center, start_angle, ids } => {
-                let mut a = ((ev.p() - *center).atan2() - start_angle).to_degrees();
-                if ev.shift {
-                    a = (a / 15.0).round() * 15.0;
-                }
-                let (c, ids) = (*center, ids.clone());
-                self.preview(|doc, _| {
-                    for i in &ids {
-                        crate::cmd::arrange::rotate_world(doc, *i, c, -a)?;
-                    }
-                    Ok(())
-                })?;
-                // The cursor turns with the pointer about the centre.
-                self.tool.overlay.cursor =
-                    if self.refused(&ids, false) { Cursor::NotAllowed } else { Cursor::Rotate((ev.p() - c).atan2().to_degrees()) };
-                Ok(())
-            }
-            Gesture::Draw { start, id, parent, targets } => {
-                let (start, id, parent, targets) = (*start, *id, *parent, targets.clone());
-                self.tool.gesture = g;
-                return self.draw_drag(ev, start, id, parent, &targets);
-            }
-            Gesture::TextBox { id, start, line } => {
-                let (id, start, line) = (*id, *start, *line);
-                self.tool.gesture = g;
-                return self.text_box_drag(ev, id, start, line);
-            }
-            Gesture::Arc { id, handle, arc } => {
-                let (id, handle, arc) = (*id, *handle, *arc);
-                self.tool.gesture = g;
-                return self.arc_drag(ev, id, handle, arc);
-            }
-            Gesture::Shape { id, handle } => {
-                let (id, handle) = (*id, *handle);
-                let doc = self.doc()?.clone();
-                if let Some(props) = crate::shape_handles::drag(&doc, id, handle, ev.p(), ev.alt) {
-                    self.preview(|doc, _| crate::cmd::props::apply("node.set", doc, id, &props))?;
-                }
-                self.tool.overlay.shape = shape_hint(self.doc()?, id, handle, ev.zoom);
-                self.tool.overlay.shape_hover = Some(handle);
-                Ok(())
-            }
-            Gesture::Pan { sx, sy, cx, cy } => {
-                let ds = self.ds_mut()?;
-                let z = ds.view.zoom.max(1e-6);
-                ds.view.cx = cx - (ev.sx - sx) / z;
-                ds.view.cy = cy - (ev.sy - sy) / z;
-                ds.revision += 1;
-                Ok(())
-            }
-            Gesture::Pencil { points, pressure } => {
-                let (mut pts, mut pressure) = (points.clone(), pressure.clone());
-                if pts.last().is_none_or(|l| (*l - ev.p()).hypot() > 0.5 / ev.zoom.max(1e-6)) {
-                    pts.push(ev.p());
-                    pressure.push(ev.pressure);
-                }
-                self.tool.overlay.pen = pts.iter().map(|p| [p.x, p.y]).collect();
-                self.tool.gesture = Gesture::Pencil { points: pts, pressure };
-                if let Ok(ds) = self.ds_mut() {
-                    ds.revision += 1;
-                }
-                return Ok(());
-            }
-            Gesture::TextSelect { id } => {
-                let id = *id;
-                let idx = self.text_index_at(id, ev.p())?;
-                textedit::set_caret(self, idx, true)?;
-                Ok(())
-            }
-            Gesture::Vector(_) | Gesture::ShapeBuild { .. } | Gesture::Origin => Ok(()),
-            Gesture::Connect { from, start } => {
-                let (from, start) = (*from, *start);
-                self.connect_drag(ev, from, start);
-                return Ok(());
-            }
-            Gesture::Erase { gone } => {
-                self.tool.gesture = Gesture::Erase { gone: gone.clone() };
-                return self.erase_at(ev);
-            }
-            Gesture::Reattach { id, from, start } => {
-                let (id, from, start) = (*id, *from, *start);
-                self.reattach_drag(ev, id, from, start);
-                return Ok(());
-            }
-            Gesture::PenDrag { anchor } => {
-                // A click's wobble pulls out no handle.
-                let out = if within_slop(ev, *anchor) { Vec2::ZERO } else { ev.p() - *anchor };
-                if let Some(pen) = self.tool.pen.as_mut()
-                    && let Some(last) = pen.points.last_mut()
-                {
-                    last.2 = out;
-                    last.1 = -out;
-                }
-                self.pen_update()?;
-                Ok(())
-            }
-        };
-        self.tool.gesture = g;
-        res
-    }
-
-    /// An arc handle drag: the new arc, written through `node.set`'s keys.
-    fn arc_drag(&mut self, ev: &PointerEvent, id: NodeId, handle: ArcHandle, arc: crate::arc_handles::Arc) -> Result<()> {
-        let doc = self.doc()?.clone();
-        let Some(next) = crate::arc_handles::drag(&doc, id, handle, arc, ev.p(), ev.shift, ev.zoom) else { return Ok(()) };
-        let props = crate::arc_handles::props(next);
-        self.preview(|doc, _| crate::cmd::props::apply("node.set", doc, id, &props))?;
-        self.tool.gesture = Gesture::Arc { id, handle, arc: next };
-        let at = crate::arc_handles::handle_at(self.doc()?, id, handle, next, ev.zoom);
-        self.tool.overlay.arc = at.map(|at| ArcHint { handle, label: next.label(handle), at });
-        self.tool.overlay.arc_hover = Some(handle);
-        Ok(())
-    }
-
-    fn resize_drag(&mut self, ev: &PointerEvent, start: Point, r: &ResizeStart, scale_tool: bool) -> Result<()> {
-        let page = self.page()?;
-        let snap = self.ds().map(|d| d.view.snap_objects).unwrap_or(true) && !ev.cmd && !ev.ctrl;
-        let ids: Vec<NodeId> = r.nodes.iter().map(|n| n.0).collect();
-        let targets = if snap { Some(Targets::gather(self.doc()?, page, &ids)) } else { None };
-        let mut p = ev.p();
-        let mut guides = Vec::new();
-        if let Some(t) = &targets {
-            let (dx, dy, g) = t.snap_point(p.x, p.y, SNAP_PX / ev.zoom.max(1e-6));
-            p.x += dx;
-            p.y += dy;
-            guides = g;
-        }
-        let _ = start;
-        // In the handle box's own axes (one layer: its local space).
-        let (frame, w0, h0) = r.frame;
-        // The pixel grid: an upright box's dragged sides land on whole pixels (the Scale tool
-        // scales by the factor as dragged).
-        if !scale_tool && self.ds().map(|d| d.view.snap_pixel).unwrap_or(true) && crate::guides::axis_aligned(frame) {
-            p = Point::new(p.x.round(), p.y.round());
-        }
-        let q = frame.inverse() * p;
-        let is_line = r.single && ids.first().and_then(|i| self.doc().ok()?.node(*i).map(|n| matches!(n.kind, NodeKind::Line))).unwrap_or(false);
-        if scale_tool {
-            return self.scale_drag(ev, r, q, guides);
-        }
-        if is_line {
-            // Line end handles: move the end point freely (length + angle).
-            let (a, b) = match r.handle {
-                Handle::Corner(0) => (p, frame * Point::new(w0, 0.0)),
-                _ => (frame * Point::new(0.0, 0.0), p),
-            };
-            let id = ids.first().copied().unwrap_or(NodeId(0));
-            self.preview(|doc, _| {
-                let mut v = b - a;
-                if ev.shift {
-                    let ang = (v.atan2() / (std::f64::consts::PI / 4.0)).round() * std::f64::consts::PI / 4.0;
-                    v = Vec2::from_angle(ang) * v.hypot();
-                }
-                let len = v.hypot();
-                let world = Affine::translate(a.to_vec2()) * Affine::rotate(v.atan2());
-                doc.set_world_transform(id, world)?;
-                figcraft_layout::set_size(doc, id, len, 0.0);
-                Ok(())
-            })?;
-            self.tool.overlay.guides = guides;
-            return Ok(());
-        }
-        // Constrain proportions (Shift, or the node's lock).
-        let keep = ev.shift || r.single && ids.first().and_then(|i| self.doc().ok()?.node(*i).map(|n| n.constrain_proportions)).unwrap_or(false);
-        let (x0, y0, x1, y1) = resized_box(r.handle, q, w0, h0, keep, ev.alt);
-        let (flip_x, flip_y) = (x1 < x0, y1 < y0);
-        let (nx0, ny0) = (x0.min(x1), y0.min(y1));
-        let (nw, nh) = ((x1 - x0).abs(), (y1 - y0).abs());
-        let nodes = r.nodes.clone();
-        let single = r.single;
-        let handle = r.handle;
-        // What's in a section stays where it is on the page, and so does what's in a frame resized
-        // with Cmd/Ctrl held (its constraints are ignored).
-        let keeps = |doc: &Document, id: NodeId| {
-            doc.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Section { .. }) || (ev.cmd && single && n.kind.is_frame_like()))
-        };
-        self.preview(|doc, _| {
-            if single {
-                let Some((id, world, _, _)) = nodes.first() else { return Ok(()) };
-                let kept = if keeps(doc, *id) { crate::cmd::props::children_worlds(doc, *id) } else { Vec::new() };
-                let mut t = *world * Affine::translate((nx0, ny0));
-                if flip_x {
-                    t *= Affine::new([-1.0, 0.0, 0.0, 1.0, nw, 0.0]);
-                }
-                if flip_y {
-                    t *= Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, nh]);
-                }
-                // Text reflow and auto layout can recompute this box after the preview (a size bound
-                // to a variable lets go of it: the resize is an explicit edit).
-                let n = doc.get(*id)?;
-                let crop_images = ev.cmd
-                    && !matches!(n.kind, NodeKind::Text(_))
-                    && !std::iter::once(*id).chain(doc.ancestors(*id)).any(|a| doc.node(a).is_some_and(|n| n.layout.is_some()));
-                if crop_images {
-                    // Crop the layer's image fills without moving their pixels on the page.
-                    // Work from the interaction snapshot, just like the geometry on every move.
-                    let (w, h) = (n.width.max(1e-6), n.height.max(1e-6));
-                    let to_old =
-                        Affine::scale_non_uniform(1.0 / w, 1.0 / h) * world.inverse() * t * Affine::scale_non_uniform(nw.max(0.01), nh.max(0.01));
-                    let mut fills = n.fills.clone();
-                    for paint in &mut fills {
-                        let PaintKind::Image(img) = &mut paint.kind else { continue };
-                        // A repeating image cannot be represented by a single Crop placement.
-                        if img.scale_mode == ImageScaleMode::Tile {
-                            continue;
-                        }
-                        let Some(data) = doc.images.get(&img.image) else { continue };
-                        let (iw, ih) = (f64::from(data.width), f64::from(data.height));
-                        let crop = if img.scale_mode == ImageScaleMode::Crop {
-                            img.effective_crop(iw, ih, w, h)
-                        } else {
-                            let (rw, rh) = img.rotated_size(iw.max(1.0), ih.max(1.0));
-                            let s = if img.scale_mode == ImageScaleMode::Fit { (w / rw).min(h / rh) } else { (w / rw).max(h / rh) };
-                            [w / (rw * s), 0.0, 0.0, h / (rh * s), (rw * s - w) / (2.0 * rw * s), (rh * s - h) / (2.0 * rh * s)]
-                        };
-                        // A degenerate (zero-scale) layer has no inverse: its image keeps its placement.
-                        let crop = (Affine::new(crop) * to_old).as_coeffs();
-                        if !crop.iter().all(|c| c.is_finite()) {
-                            continue;
-                        }
-                        img.crop = Some(crop);
-                        img.scale_mode = ImageScaleMode::Crop;
-                    }
-                    doc.get_mut(*id)?.fills = fills;
-                }
-                doc.set_world_transform(*id, t)?;
-                if kept.is_empty() {
-                    crate::cmd::props::resize_node(doc, *id, nw.max(0.01), nh.max(0.01))?;
-                } else {
-                    figcraft_layout::set_size(doc, *id, nw.max(0.01), nh.max(0.01));
-                    crate::cmd::props::restore_worlds(doc, &kept)?;
-                }
-                let n = doc.get_mut(*id)?;
-                if matches!(handle, Handle::Corner(_) | Handle::Edge(1) | Handle::Edge(3)) {
-                    n.child_layout.sizing_h = Sizing::Fixed;
-                }
-                if matches!(handle, Handle::Corner(_) | Handle::Edge(0) | Handle::Edge(2)) {
-                    n.child_layout.sizing_v = Sizing::Fixed;
-                }
-                if let NodeKind::Text(t) = &mut n.kind {
-                    match handle {
-                        Handle::Edge(1) | Handle::Edge(3) if t.auto_resize == TextAutoResize::Truncate => {}
-                        Handle::Edge(1) | Handle::Edge(3) => t.auto_resize = TextAutoResize::Height,
-                        _ => t.fix_size(true, true),
-                    }
-                }
-                return Ok(());
-            }
-            // Several layers: map the old box onto the new one, in the box's axes. Each layer's
-            // centre follows the box (mirrored when it flips); each keeps its rotation and scales
-            // along its own axes (see `axis_factors`), turning over with the box.
-            let (sx, sy) = (if w0 > 1e-9 { (x1 - x0) / w0 } else { 1.0 }, if h0 > 1e-9 { (y1 - y0) / h0 } else { 1.0 });
-            let mirror = Affine::new([sx.signum(), 0.0, 0.0, sy.signum(), 0.0, 0.0]);
-            let inv = frame.inverse();
-            for (id, world, w, h) in &nodes {
-                let local = inv * *world;
-                let center = local * Point::new(w / 2.0, h / 2.0);
-                let (kw, kh) = figcraft_layout::axis_factors(local, sx, sy);
-                let (w2, h2) = (w * kw, h * kh);
-                let lin = (mirror * local).with_translation(Vec2::ZERO);
-                let origin = Point::new(x0 + center.x * sx, y0 + center.y * sy) - lin * Point::new(w2 / 2.0, h2 / 2.0);
-                let kept = if keeps(doc, *id) { crate::cmd::props::children_worlds(doc, *id) } else { Vec::new() };
-                doc.set_world_transform(*id, frame * lin.with_translation(origin))?;
-                crate::cmd::props::resize_node(doc, *id, w2, h2)?;
-                crate::cmd::props::restore_worlds(doc, &kept)?;
-            }
-            Ok(())
-        })?;
-        self.tool.overlay.guides = guides;
-        Ok(())
-    }
-
-    /// Scale tool handle drag (`q`: the snapped pointer in the handle box's axes): everything
-    /// scales by one factor about the anchor point (Alt: the centre), strokes, effects, radii and
-    /// text included, children by the same factor whatever their constraints.
-    fn scale_drag(&mut self, ev: &PointerEvent, r: &ResizeStart, q: Point, guides: Vec<Guide>) -> Result<()> {
-        let (frame, w0, h0) = r.frame;
-        let Some((k, pivot)) = scale_factor(r.handle, q, w0, h0, self.tool.scale_anchor, ev.alt) else { return Ok(()) };
-        let nodes = r.nodes.clone();
-        let inv = frame.inverse();
-        // A layer's place in the box scales about the pivot; a negative factor turns it over.
-        let about = frame * Affine::translate(pivot.to_vec2() * (1.0 - k));
-        let sign = k.signum();
-        self.preview(|doc, _| {
-            for (id, world, _, _) in &nodes {
-                let c = (inv * *world).as_coeffs();
-                doc.set_world_transform(*id, about * Affine::new([sign * c[0], sign * c[1], sign * c[2], sign * c[3], k * c[4], k * c[5]]))?;
-                crate::cmd::arrange::scale_node(doc, *id, k.abs())?;
-            }
-            Ok(())
-        })?;
-        let p = frame * pivot;
-        self.tool.overlay.scale = Some(ScaleHint { factor: k, pivot: [p.x, p.y] });
-        self.tool.overlay.guides = guides;
-        Ok(())
-    }
-
-    fn draw_down(&mut self, ev: &PointerEvent) -> Result<()> {
-        let ds = self.ds()?;
-        let doc = ds.doc.clone();
-        let page = ds.page;
-        if ds.text_edit.is_some() {
-            textedit::end(self)?;
-        }
-        // Frames drawn inside frames nest; sections only at the top or in sections.
-        let parent = match self.tool.tool {
-            ToolId::Section => {
-                frame_at(&doc, page, ev.p(), &[]).filter(|f| doc.node(*f).is_some_and(|n| matches!(n.kind, NodeKind::Section { .. }))).unwrap_or(page)
-            }
-            _ => frame_at(&doc, page, ev.p(), &[]).unwrap_or(page),
-        };
-        let targets = Targets::gather(&doc, page, &[]);
-        self.begin_interaction(self.tool.tool.label())?;
-        self.tool.gesture = Gesture::Draw { start: ev.p(), id: None, parent, targets };
-        Ok(())
-    }
-
-    fn draw_drag(&mut self, ev: &PointerEvent, start: Point, id: Option<NodeId>, parent: NodeId, targets: &Targets) -> Result<()> {
-        let tool = self.tool.tool;
-        let mut p = ev.p();
-        let mut guides = Vec::new();
-        if self.ds().map(|d| d.view.snap_objects).unwrap_or(true) && !ev.cmd && !ev.ctrl {
-            let (dx, dy, g) = targets.snap_point(p.x, p.y, SNAP_PX / ev.zoom.max(1e-6));
-            p.x += dx;
-            p.y += dy;
-            guides = g;
-        }
-        let pixel = self.ds().map(|d| d.view.snap_pixel).unwrap_or(true);
-        let mut created = id;
-        let page = self.page()?;
-        self.preview(|doc, sel| {
-            let (mut a, mut b) = (start, p);
-            if pixel {
-                a = Point::new(a.x.round(), a.y.round());
-                b = Point::new(b.x.round(), b.y.round());
-            }
-            let pw = doc.world_transform(parent);
-            let (kind, base) = match tool {
-                ToolId::Frame => (NodeKind::Frame, "Frame"),
-                ToolId::Section => (NodeKind::Section { contents_hidden: false }, "Section"),
-                ToolId::Slice => (NodeKind::Slice, "Slice"),
-                ToolId::Rectangle => (NodeKind::Rectangle, "Rectangle"),
-                ToolId::Ellipse => (NodeKind::Ellipse { start: 0.0, sweep: std::f64::consts::TAU, inner: 0.0 }, "Ellipse"),
-                ToolId::Polygon => (NodeKind::Polygon { count: 3 }, "Polygon"),
-                ToolId::Star => (NodeKind::Star { count: 5, inner_ratio: 0.38 }, "Star"),
-                ToolId::Line => (NodeKind::Line, "Line"),
-                ToolId::Arrow => (NodeKind::Line, "Arrow"),
-                _ => return Ok(()),
-            };
-            let name = match tool {
-                ToolId::Frame | ToolId::Section | ToolId::Slice => doc.next_name(base),
-                _ => base.to_string(),
-            };
-            let nid = doc.alloc_id();
-            let mut n = if tool == ToolId::Section { Node::new_section(nid, name, 0.0, 0.0) } else { Node::new(nid, kind, name, 0.0, 0.0) };
-            if tool == ToolId::Arrow {
-                n.stroke.cap_end = StrokeCap::LineArrow;
-            }
-            if matches!(tool, ToolId::Line | ToolId::Arrow) {
-                let mut v = b - a;
-                if ev.shift {
-                    let ang = (v.atan2() / (std::f64::consts::PI / 4.0)).round() * std::f64::consts::PI / 4.0;
-                    v = Vec2::from_angle(ang) * v.hypot();
-                }
-                // Alt draws from the centre, as for the other shapes.
-                let (a, v) = if ev.alt { (a - v, v * 2.0) } else { (a, v) };
-                n.width = v.hypot();
-                n.transform = pw.inverse() * Affine::translate(a.to_vec2()) * Affine::rotate(v.atan2());
-            } else {
-                let mut d = b - a;
-                if ev.shift {
-                    let m = d.x.abs().max(d.y.abs());
-                    d = Vec2::new(m * d.x.signum(), m * d.y.signum());
-                }
-                let (x0, y0, x1, y1) = if ev.alt { (a.x - d.x, a.y - d.y, a.x + d.x, a.y + d.y) } else { (a.x, a.y, a.x + d.x, a.y + d.y) };
-                let r = Rect::new(x0.min(x1), y0.min(y1), x0.max(x1), y0.max(y1));
-                n.width = r.width();
-                n.height = r.height();
-                n.transform = pw.inverse() * Affine::translate((r.x0, r.y0));
-            }
-            doc.insert(n, parent, None)?;
-            *sel = vec![nid];
-            created = Some(nid);
-            let _ = page;
-            Ok(())
-        })?;
-        self.tool.overlay.guides = guides;
-        self.tool.gesture = Gesture::Draw { start, id: created, parent, targets: targets.clone() };
-        Ok(())
-    }
-
-    fn up(&mut self, ev: &PointerEvent) -> Result<()> {
-        let g = std::mem::take(&mut self.tool.gesture);
-        self.tool.overlay.marquee = None;
-        self.tool.overlay.guides.clear();
-        self.tool.overlay.scale = None;
-        self.tool.overlay.arc = None;
-        self.tool.overlay.shape = None;
-        self.tool.overlay.measure_box = None;
-        self.tool.overlay.insert_line = None;
-        self.tool.overlay.drop_cell = None;
-        let drop_target = self.tool.overlay.drop_target.take();
-        match g {
-            Gesture::Move { ids, moved, duplicate, start, deselect, .. } => {
-                if moved {
-                    // A free move lands in the frame under the pointer (or the page) where it was
-                    // dropped; layers in an auto layout frame already sit in their slot.
-                    let page = self.page()?;
-                    let sel = self.selection();
-                    let sources = if duplicate { ids.clone() } else { Vec::new() };
-                    let moving = if duplicate { sel } else { ids };
-                    let doc = self.doc()?.clone();
-                    let in_al =
-                        moving.iter().any(|m| doc.node(*m).and_then(|n| n.parent).and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some()));
-                    let target = drop_target.unwrap_or(page);
-                    let current = moving.first().and_then(|m| doc.node(*m)).and_then(|n| n.parent);
-                    if !in_al && current != Some(target) {
-                        let ds = self.ds_mut()?;
-                        let before = ds.doc.clone();
-                        let d = ds.doc_mut();
-                        for m in &moving {
-                            // Group, boolean group and instance layers stay put: they only move.
-                            let from = d.node(*m).and_then(|n| n.parent);
-                            if from.is_some_and(|f| crate::drop::keeps_layers(d, f)) || crate::components::structure_locked(d, target) {
-                                continue;
-                            }
-                            // A layer can't go into itself; it stays where it is.
-                            let _ = d.reparent(*m, target, None);
-                        }
-                        crate::normalize(ds.doc_mut(), &before);
-                    }
-                    // Reordering or dragging layers out of an instance (outside its slots), or
-                    // moving layers inside one, are edits only its main can make: the gesture is
-                    // undone.
-                    if self.refused(&moving, true) {
-                        self.cancel_interaction()?;
-                    } else {
-                        self.commit_interaction()?;
-                        // Duplicate repeats a free Alt-drag's step (an auto layout places its own).
-                        if duplicate && !in_al && moving.len() == sources.len() {
-                            self.ds_mut()?.last_duplicate = Some(crate::cmd::edit::Duplicated { sources, copies: moving });
-                        }
-                    }
-                } else {
-                    self.cancel_interaction()?;
-                    if let Some(d) = deselect {
-                        let sel = self.selection().into_iter().filter(|x| *x != d).collect();
-                        self.set_selection(sel);
-                    }
-                    if deselect.is_none() && !(ev.shift || ev.cmd || duplicate) {
-                        self.widget_click(start, ev.tol() * 2.0)?;
-                    }
-                }
-            }
-            Gesture::Resize { .. } | Gesture::Rotate { .. } | Gesture::Arc { .. } | Gesture::Shape { .. } => {
-                // Layers inside an instance keep their main's size and rotation.
-                if self.refused(&self.selection(), false) {
-                    self.cancel_interaction()?;
-                } else {
-                    self.commit_interaction()?;
-                }
-            }
-            Gesture::Draw { start, id, parent, .. } => {
-                let tiny = (ev.p() - start).hypot() * ev.zoom < 3.0;
-                if tiny || id.is_none() {
-                    // Click without drag: Figma makes a 100×100 shape (frames 100×100 too).
-                    self.cancel_interaction()?;
-                    self.begin_interaction(self.tool.tool.label())?;
-                    let (w, h) = self.tool.tool.click_size();
-                    let target = start + Vec2::new(w, h);
-                    let mut fake = ev.clone();
-                    fake.x = target.x;
-                    fake.y = target.y;
-                    fake.shift = false;
-                    fake.alt = false;
-                    self.tool.gesture = Gesture::None;
-                    let targets = Targets::default();
-                    self.draw_drag(&fake, start, None, parent, &targets)?;
-                    self.tool.gesture = Gesture::None;
-                }
-                if matches!(self.tool.tool, ToolId::Frame | ToolId::Section)
-                    && let Some(drawn) = self.selection().first().copied()
-                {
-                    let ds = self.ds_mut()?;
-                    let before = ds.doc.clone();
-                    take_enclosed(ds.doc_mut(), drawn)?;
-                    crate::normalize(ds.doc_mut(), &before);
-                }
-                self.commit_interaction()?;
-                if !self.prefs.keep_tool {
-                    self.set_tool(ToolId::Move);
-                }
-            }
-            Gesture::Pan { .. } => {
-                self.tool.overlay.cursor = Cursor::Grab;
-                if let Some(t) = self.tool.temp_from.take() {
-                    self.tool.tool = t;
-                }
-            }
-            Gesture::Pencil { mut points, mut pressure } => {
-                self.tool.overlay.pen.clear();
-                // The stroke ends where the button came up, even without a move to get there.
-                if points.last().is_none_or(|l| (*l - ev.p()).hypot() > 0.5 / ev.zoom.max(1e-6)) {
-                    points.push(ev.p());
-                    pressure.push(ev.pressure);
-                }
-                self.pencil_finish(&points, &pressure)?;
-            }
-            Gesture::Connect { from, start } => self.connect_up(ev, from, start)?,
-            Gesture::Erase { .. } => self.erase_up()?,
-            Gesture::Reattach { id, from, start } => self.reattach_up(ev, id, from, start)?,
-            Gesture::TextSelect { .. } | Gesture::TextBox { .. } | Gesture::Marquee { .. } | Gesture::None => {}
-            Gesture::PenDrag { .. } | Gesture::ShapeBuild { .. } | Gesture::Origin => {}
-            Gesture::Vector(_) => self.commit_interaction()?,
-        }
-        if let Ok(ds) = self.ds_mut() {
-            ds.revision += 1;
-        }
-        Ok(())
-    }
-
-    /// Handle a double-click gesture: finish a pen path, rename or click labels/widgets,
-    /// cancel an in-progress move/resize/draw/marquee, handle board double-clicks, enter text
-    /// editing (select-all on entry, word-select inside the running edit), enter vector editing
-    /// for selected shapes, and step groups/frames one level deeper.
-    /// A double-click on `leaf` that a board object or a widget's editable field takes (typing into
-    /// a sticky or a shape on a board; editing the field like any text, its plugin told when editing
-    /// ends). Whether it was taken.
-    fn object_double_click(&mut self, doc: &Document, leaf: NodeId, sel: &[NodeId], p: Point, edits: bool) -> Result<bool> {
-        if matches!(self.tool.tool, ToolId::Move | ToolId::Scale) && self.board_double_click(doc, leaf, sel)? {
-            return Ok(true);
-        }
-        match crate::widgets::field_at(doc, leaf, p).filter(|_| edits) {
-            Some(field) => textedit::begin(self, field, None, false).map(|()| true),
-            None => Ok(false),
-        }
-    }
-
-    fn double_click(&mut self, ev: &PointerEvent) -> Result<()> {
-        let ds = self.ds()?;
-        let (doc, sel, page) = (ds.doc.clone(), ds.selection.clone(), ds.page);
-        if self.tool.tool == ToolId::Pen {
-            return self.pen_finish();
-        }
-        let edits = !self.tool.dev_mode;
-        // A frame's or section's name label: rename it there (the canvas puts a field over it).
-        // Labels come before widgets, as on a press; the second press began a move: undo it.
-        if edits
-            && matches!(self.tool.tool, ToolId::Move | ToolId::Scale)
-            && !(ev.shift || ev.cmd || ev.alt)
-            && let Some(id) = label_at(&doc, page, &self.tool.labels, ev.p())
-        {
-            self.tool.gesture = Gesture::None;
-            self.cancel_interaction()?;
-            if sel != [id] {
-                self.set_selection(vec![id]);
-            }
-            self.request_ui("canvas.renameLabel", serde_json::json!({"id": id}));
-            return Ok(());
-        }
-        // Quick clicks on a widget's clickable part are clicks, one by one.
-        if edits
-            && matches!(self.tool.tool, ToolId::Move | ToolId::Scale)
-            && !(ev.shift || ev.cmd || ev.alt)
-            && self.hit(&doc, page, ev.p(), ev.tol() * 2.0).and_then(|hit| crate::widgets::target_at(&doc, hit, ev.p())).is_some()
-        {
-            self.tool.gesture = Gesture::None;
-            self.cancel_interaction()?;
-            self.widget_click(ev.p(), ev.tol() * 2.0)?;
-            return Ok(());
-        }
-        // The second press began a move, a resize, a shape or a marquee: a double-click isn't one.
-        if matches!(self.tool.gesture, Gesture::Move { .. } | Gesture::Resize { .. } | Gesture::Draw { .. } | Gesture::Marquee { .. }) {
-            self.tool.gesture = Gesture::None;
-            self.tool.overlay.marquee = None;
-            self.cancel_interaction()?;
-        }
-        let hit_here = self.hit(&doc, page, ev.p(), ev.tol() * 2.0);
-        // A double-click anywhere on the one selected shape edits its points, like Enter: also
-        // inside a hollow (unfilled) closed shape, where the hit test finds nothing under the
-        // pointer (an open path or a line has no inside: only its stroke counts).
-        if edits
-            && let [id] = sel[..]
-            && doc.node(id).is_some_and(|n| n.kind.is_shape() && figcraft_doc::geometry::is_closed(n))
-            && doc.world_bounds(id).is_some_and(|b| b.contains(ev.p()))
-            && hit_here.is_none_or(|h| h == id || doc.is_ancestor(id, h))
-        {
-            return crate::vectoredit::begin_many(self, &[id]);
-        }
-        let Some(leaf) = hit_here else { return Ok(()) };
-        if self.object_double_click(&doc, leaf, &sel, ev.p(), edits)? {
-            return Ok(());
-        }
-        let target = select_target(&doc, leaf, &sel, true);
-        // Text: edit at the click.
-        if edits
-            && doc.node(target).is_some_and(|n| matches!(n.kind, NodeKind::Text(_)))
-            && (sel.contains(&target) || select_target(&doc, leaf, &sel, false) == target)
-        {
-            // Entering a text selects all of it; in the text being edited, the word. A
-            // double-click inside the running edit is an ordinary edit: starting a new session
-            // here would replace the IME owner's epoch and drop a composition on a plain gesture.
-            let editing = self.ds()?.text_edit.as_ref().is_some_and(|te| te.id == target);
-            let idx = self.text_index_at(target, ev.p())?;
-            if editing {
-                textedit::select_word(self, idx)?;
-            } else {
-                textedit::begin(self, target, Some(idx), false)?;
-                textedit::key(self, "SelectAll", false, false, false)?;
-            }
-            return Ok(());
-        }
-        // Shapes and vectors: enter vector edit mode (every selected shape, the clicked one active).
-        // A shape clicked on its own edits even when the click that selects it and the double-click
-        // arrived in one frame (a press and a release the canvas took together), so no selection was
-        // made yet; another layer's shapes are reached one level at a time, as below.
-        if edits && doc.node(target).is_some_and(|n| n.kind.is_shape()) && (sel.contains(&target) || select_target(&doc, leaf, &sel, false) == target)
-        {
-            let mut ids = if sel.contains(&target) { crate::vectoredit::enter_targets(&doc, &sel).unwrap_or_default() } else { vec![target] };
-            ids.retain(|i| *i != target);
-            ids.insert(0, target);
-            return crate::vectoredit::begin_many(self, &ids);
-        }
-        // Groups, frames and boolean groups: select one level deeper (the layer under the pointer).
-        let deeper = figcraft_doc::geometry::enter_target(&doc, leaf, &sel);
-        if deeper != target || !sel.contains(&deeper) {
-            self.set_selection(vec![deeper]);
-        }
-        Ok(())
-    }
-
-    /// A plain click at `p` on a clickable part of a widget calls its plugin back (a failure is
-    /// shown as a message).
-    fn widget_click(&mut self, p: Point, tol: f64) -> Result<()> {
-        let (doc, page) = (self.doc()?.clone(), self.page()?);
-        let Some((id, target)) = self.hit(&doc, page, p, tol).and_then(|hit| crate::widgets::target_at(&doc, hit, p)) else { return Ok(()) };
-        if let Err(e) = self.execute("widget.click", &serde_json::json!({"id": id, "target": target})) {
-            self.message = Some(e.to_string());
-        }
-        Ok(())
-    }
-
-    /// The char index in text node `id` at page point `p`.
-    pub fn text_index_at(&self, id: NodeId, p: Point) -> Result<usize> {
-        let doc = self.doc()?;
-        let n = doc.get(id)?;
-        let local = doc.world_transform(id).inverse() * p;
-        let Some((layout, dy)) = figcraft_text::layout_node(n) else { return Ok(0) };
-        Ok(layout.hit(local.x, local.y - dy))
-    }
-
-    fn text_click(&mut self, id: NodeId, ev: &PointerEvent, extend: bool) -> Result<()> {
-        let idx = self.text_index_at(id, ev.p())?;
-        textedit::set_caret(self, idx, extend)?;
-        self.tool.gesture = Gesture::TextSelect { id };
-        Ok(())
-    }
-
-    fn text_down(&mut self, ev: &PointerEvent) -> Result<()> {
-        let ds = self.ds()?;
-        let (doc, page) = (ds.doc.clone(), ds.page);
-        if let Some(te) = ds.text_edit.clone() {
-            if doc.world_bounds(te.id).is_some_and(|b| b.contains(ev.p())) {
-                return self.text_click(te.id, ev, ev.shift);
-            }
-            textedit::end(self)?;
-        }
-        // Clicking existing text edits it.
-        if let Some(leaf) = self.hit(&doc, page, ev.p(), ev.tol() * 2.0)
-            && doc.node(leaf).is_some_and(|n| matches!(n.kind, NodeKind::Text(_)))
-        {
-            let idx = self.text_index_at(leaf, ev.p())?;
-            textedit::begin(self, leaf, Some(idx), false)?;
-            self.tool.gesture = Gesture::TextSelect { id: leaf };
-            return Ok(());
-        }
-        // New text at the click (Figma puts the baseline-ish top-left there).
-        let parent = frame_at(&doc, page, ev.p(), &[]).unwrap_or(page);
-        let ds = self.ds_mut()?;
-        let d = ds.doc_mut();
-        let id = d.alloc_id();
-        let mut n = Node::new(id, NodeKind::Text(TextData::default()), "Text", 1.0, 14.0);
-        let pw = d.world_transform(parent);
-        let at = Point::new(ev.x.round(), (ev.y - 7.0).round());
-        n.transform = pw.inverse() * Affine::translate(at.to_vec2());
-        n.name = String::new();
-        if let Some(fills) = readable_text_fills(d, parent) {
-            n.fills = fills;
-        }
-        if let Some((w, h)) = figcraft_text::auto_size(&n) {
-            n.width = w.max(1.0);
-            n.height = h;
-        }
-        let line = n.height;
-        d.insert(n, parent, None)?;
-        ds.selection = vec![id];
-        textedit::begin(self, id, Some(0), true)?;
-        self.tool.gesture = Gesture::TextBox { id, start: ev.p(), line };
-        if !self.prefs.keep_tool {
-            self.tool.tool = ToolId::Move;
-        }
-        Ok(())
-    }
-
-    /// The layer whose path is under `ev` for the Text on a path tool and where along it the press
-    /// is (0..1 by length): the front-most shape or vector layer within a few screen pixels of its
-    /// first subpath (the one text follows), not locked and not inside an instance. Layers in front
-    /// whose path is further away don't hide it.
-    pub(crate) fn path_at(&self, doc: &Document, page: NodeId, ev: &PointerEvent) -> Option<(NodeId, f64)> {
-        let reach = ev.tol() * PATH_REACH_PX;
-        let near = |id: NodeId| -> Option<(NodeId, f64)> {
-            let n = doc.node(id)?;
-            let shape = matches!(
-                n.kind,
-                NodeKind::Rectangle
-                    | NodeKind::Ellipse { .. }
-                    | NodeKind::Polygon { .. }
-                    | NodeKind::Star { .. }
-                    | NodeKind::Line
-                    | NodeKind::Vector { .. }
-            );
-            if !shape || locked_in(doc, id) || crate::components::inside_instance(doc, id) {
-                return None;
-            }
-            let geom = figcraft_doc::geometry::stroke_geometry(n)?;
-            let line = figcraft_geom::measure::polylines(&geom)?.into_iter().next()?;
-            // Measured on the page (a layer scaled more one way than the other is still reached
-            // where it shows), the start by length along the layer's own path.
-            let world = doc.world_transform(id);
-            let p = ev.p();
-            let mut best: Option<(f64, f64)> = None;
-            for (i, w) in line.points.windows(2).enumerate() {
-                let (a, b) = (world * w[0], world * w[1]);
-                let d = b - a;
-                let l2 = d.hypot2();
-                let u = if l2 > 1e-18 { ((p - a).dot(d) / l2).clamp(0.0, 1.0) } else { 0.0 };
-                let dist = (a.lerp(b, u) - p).hypot();
-                if best.is_none_or(|(_, bd)| dist < bd) {
-                    let (la, lb) = (*line.lengths.get(i)?, *line.lengths.get(i + 1)?);
-                    best = Some((la + u * (lb - la), dist));
-                }
-            }
-            let (along, dist) = best?;
-            let len = line.length();
-            (len > 1e-9 && dist <= reach).then_some((id, along / len))
-        };
-        let mut candidates = Vec::new();
-        path_candidates(doc, page, ev.p(), reach, 0, &mut candidates);
-        candidates.into_iter().find_map(near)
-    }
-
-    /// A press with the Text on a path tool: on a path, a new empty text layer goes onto it,
-    /// starting where it was pressed, and typing starts. The text takes the path layer's place,
-    /// geometry, transform, constraints and effects, and its fills when one of them shows; the path
-    /// layer is removed. Ending the edit with nothing typed puts the path back without an undo step
-    /// ([`textedit::end`]). Elsewhere a press does nothing.
-    fn text_on_path_down(&mut self, ev: &PointerEvent) -> Result<()> {
-        if let Some(te) = self.ds()?.text_edit.clone() {
-            if self.ds()?.doc.world_bounds(te.id).is_some_and(|b| b.contains(ev.p())) {
-                return self.text_click(te.id, ev, ev.shift);
-            }
-            textedit::end(self)?;
-        }
-        let ds = self.ds()?;
-        let (doc, page) = (ds.doc.clone(), ds.page);
-        let Some((path, start)) = self.path_at(&doc, page, ev) else { return Ok(()) };
-        let Some(pn) = doc.node(path) else { return Ok(()) };
-        let (Some(parent), Some(geom)) = (pn.parent, figcraft_doc::geometry::stroke_geometry(pn)) else { return Ok(()) };
-        let index = doc.index_in_parent(path);
-        self.begin_interaction("Text on a path")?;
-        let ds = self.ds_mut()?;
-        let d = ds.doc_mut();
-        let id = d.alloc_id();
-        let mut n = Node::new(id, NodeKind::Text(TextData::default()), "Text", pn.width, pn.height);
-        n.name = String::new();
-        n.transform = pn.transform;
-        n.constraints = pn.constraints;
-        n.child_layout = pn.child_layout.clone();
-        let effects = !pn.effects.is_empty();
-        if effects {
-            n.effects = pn.effects.clone();
-            n.styles.effect = pn.styles.effect.clone();
-        }
-        // A path drawn with a stroke only has no fill to give: the text gets the usual one.
-        let filled = pn.fills.iter().any(|f| f.visible);
-        if filled {
-            n.fills = pn.fills.clone();
-            n.styles.fill = pn.styles.fill.clone();
-        } else if let Some(fills) = readable_text_fills(d, parent) {
-            n.fills = fills;
-        }
-        // As `text.onPath`: a binding goes with the list it binds into (`fill`, `fills`, `fills/N/…`).
-        let carried = |k: &str| match crate::cmd::lists::list_binding(k) {
-            Some((crate::cmd::lists::BoundList::Fills, ..)) => filled,
-            Some((crate::cmd::lists::BoundList::Effects, ..)) => effects,
-            _ => false,
-        };
-        n.bound = pn.bound.iter().filter(|(k, _)| carried(k)).map(|(k, v)| (k.clone(), v.clone())).collect();
-        if let NodeKind::Text(t) = &mut n.kind {
-            let mut tp = TextPath::new(&geom);
-            tp.start = start;
-            t.path = Some(Box::new(tp));
-        }
-        d.insert(n, parent, index)?;
-        d.remove(path)?;
-        ds.selection = vec![id];
-        textedit::begin(self, id, Some(0), true)?;
-        if !self.prefs.keep_tool {
-            self.tool.tool = ToolId::Move;
-        }
-        Ok(())
-    }
-
-    /// Drag out a new text box: past the drag slop it has the drag's size (at least one line
-    /// tall) and its top-left, and that size is fixed.
-    fn text_box_drag(&mut self, ev: &PointerEvent, id: NodeId, start: Point, line: f64) -> Result<()> {
-        if within_slop(ev, start) {
-            return Ok(());
-        }
-        let r = Rect::from_points(start, ev.p());
-        let d = self.ds_mut()?.doc_mut();
-        let pw = d.node(id).and_then(|n| n.parent).map(|p| d.world_transform(p)).unwrap_or_default();
-        let n = d.get_mut(id)?;
-        n.transform = pw.inverse() * Affine::translate((r.x0.round(), r.y0.round()));
-        n.width = r.width().round().max(1.0);
-        n.height = r.height().round().max(line);
-        n.child_layout.sizing_h = Sizing::Fixed;
-        n.child_layout.sizing_v = Sizing::Fixed;
-        if let NodeKind::Text(t) = &mut n.kind {
-            t.auto_resize = TextAutoResize::None;
-        }
-        self.ds_mut()?.revision += 1;
-        Ok(())
-    }
-
-    fn eyedrop(&mut self, ev: &PointerEvent) -> Result<()> {
-        let ds = self.ds()?;
-        let doc = ds.doc.clone();
-        let view = figcraft_render::View { origin: (ev.x, ev.y), scale: ev.zoom.max(0.01), width: 1, height: 1 };
-        let Some(pix) = figcraft_render::render_view(&doc, ds.page, &view, &Default::default()) else { return Ok(()) };
-        let rgba = figcraft_render::to_rgba8(&pix);
-        let c = figcraft_color::Color::from_rgba8(
-            rgba.first().copied().unwrap_or(0),
-            rgba.get(1).copied().unwrap_or(0),
-            rgba.get(2).copied().unwrap_or(0),
-            255,
-        );
-        let sel = ds.selection.clone();
-        if self.tool.pick_only {
-            self.tool.picked = Some(c);
-        } else if !sel.is_empty() {
-            self.execute("node.set", &json!({"ids": sel, "props": {"fill": c.to_css_hex()}}))?;
-        }
-        self.recent_colors.retain(|x| *x != c);
-        self.recent_colors.insert(0, c);
-        self.recent_colors.truncate(16);
-        self.message = Some(format!("Picked #{}", c.to_hex()));
-        self.set_tool(ToolId::Move);
-        Ok(())
-    }
-
-    /// The pen tool's snapped position for `ev`: its path's vector (or, before it has one, its first
-    /// point) counts among the targets.
-    fn snap_pen_tool(&mut self, ev: &PointerEvent) -> Result<(Point, Vec<Guide>)> {
-        let (id, extra) = match &self.tool.pen {
-            Some(pen) if pen.id.is_some() => (pen.id, Vec::new()),
-            Some(pen) => (None, pen.points.iter().map(|(p, _, _)| *p).collect()),
-            None => (None, Vec::new()),
-        };
-        self.snap_pen(ev, id, &extra)
-    }
-
-    fn pen_down(&mut self, ev: &PointerEvent) -> Result<()> {
-        self.tool.overlay.guides.clear();
-        // The segment being placed shows as itself while the press lasts.
-        self.tool.overlay.rubber = None;
-        self.tool.overlay.rubber_handle = None;
-        let p = if ev.shift { ev.p() } else { self.snap_pen_tool(ev)?.0 };
-        let (doc, page) = {
-            let ds = self.ds()?;
-            (ds.doc.clone(), ds.page)
-        };
-        // With an open path selected, a click on one of its end points continues it in edit mode.
-        if self.tool.pen.is_none()
-            && let Some((id, v)) = selected_end_at(&doc, &self.selection(), ev.p(), 8.0 / ev.zoom.max(1e-6))
-        {
-            return self.pen_edit(id, Some(v));
-        }
-        let pen = self.tool.pen.get_or_insert_with(PenPath::default);
-        // Clicking the first anchor closes the path.
-        if pen.points.len() > 2
-            && let Some((first, _, _)) = pen.points.first()
-            && (*first - p).hypot() * ev.zoom < 8.0
-        {
-            pen.closed = true;
-            self.pen_update()?;
-            return self.pen_finish();
-        }
-        // Clicking another of its own anchors (not the last) connects there and ends the path.
-        let near = |q: &Point| (*q - p).hypot() * ev.zoom < 8.0;
-        if let Some(k) = (1..pen.points.len().saturating_sub(1)).find(|k| pen.points.get(*k).is_some_and(|(q, _, _)| near(q))) {
-            pen.join = Some(k);
-            self.pen_update()?;
-            return self.pen_finish();
-        }
-        if pen.parent.is_none() {
-            pen.parent = Some(frame_at(&doc, page, p, &[]).unwrap_or(page));
-        }
-        let mut p = p;
-        if ev.shift
-            && let Some((last, _, _)) = pen.points.last()
-        {
-            p = at_45_degrees(*last, p);
-        }
-        pen.points.push((p, Vec2::ZERO, Vec2::ZERO));
-        self.tool.gesture = Gesture::PenDrag { anchor: p };
-        self.pen_update()
-    }
-
-    /// Rebuild the pen's vector node from its anchors.
-    fn pen_update(&mut self) -> Result<()> {
-        let Some(pen) = self.tool.pen.clone() else { return Ok(()) };
-        self.tool.overlay.pen = pen.points.iter().map(|(p, _, _)| [p.x, p.y]).collect();
-        self.tool.overlay.pen_handles = pen_handles(&pen.points);
-        if pen.points.len() < 2 {
-            if let Ok(ds) = self.ds_mut() {
-                ds.revision += 1;
-            }
-            return Ok(());
-        }
-        let page = self.page()?;
-        let parent = pen.parent.unwrap_or(page);
-        if pen.id.is_none() {
-            self.begin_interaction("Pen")?;
-        }
-        let ds = self.ds_mut()?;
-        let doc = ds.doc_mut();
-        let pw = doc.world_transform(parent);
-        let inv = pw.inverse();
-        // Anchors and handles into the parent's space.
-        let pts: Vec<(Point, Point, Point)> = pen.points.iter().map(|(p, i, o)| (inv * *p, inv * (*p + *i), inv * (*p + *o))).collect();
-        let mut path = figcraft_geom::BezPath::new();
-        for (k, (p, _, _)) in pts.iter().enumerate() {
-            if k == 0 {
-                path.move_to(*p);
-            } else if let (Some(prev), Some(cur)) = (pts.get(k - 1), pts.get(k)) {
-                path.curve_to(prev.2, cur.1, *p);
-            }
-        }
-        if pen.closed
-            && let (Some(last), Some(first)) = (pts.last(), pts.first())
-        {
-            path.curve_to(last.2, first.1, first.0);
-            path.close_path();
-        }
-        use figcraft_geom::Shape;
-        let bb = path.bounding_box();
-        path.apply_affine(Affine::translate((-bb.x0, -bb.y0)));
-        let mut net = VectorNetwork::from_path(&path);
-        // Straight segments stay straight.
-        for s in &mut net.segments {
-            if (s.ta.0.abs() + s.ta.1.abs()) < 1e-9 && (s.tb.0.abs() + s.tb.1.abs()) < 1e-9 {
-                s.ta = (0.0, 0.0);
-                s.tb = (0.0, 0.0);
-            }
-        }
-        if !pen.closed {
-            net.regions.clear();
-        }
-        // Anchor k is vertex k of the open path.
-        if let (Some(k), Some((last, _, out))) = (pen.join, pts.last()) {
-            let from = pts.len() - 1;
-            crate::vectoredit::ops::connect(&mut net, from, k, (out.x - last.x, out.y - last.y), (0.0, 0.0));
-        }
-        let id = match pen.id {
-            Some(id) if doc.contains(id) => id,
-            _ => {
-                let id = doc.alloc_id();
-                let mut n = Node::new(id, NodeKind::Vector { network: VectorNetwork::default() }, "Vector", 0.0, 0.0);
-                n.fills.clear();
-                n.strokes = vec![figcraft_color::Paint::solid(figcraft_color::Color::BLACK)];
-                n.stroke.align = StrokeAlign::Center;
-                doc.insert(n, parent, None)?;
-                id
-            }
-        };
-        let n = doc.get_mut(id)?;
-        n.kind = NodeKind::Vector { network: net };
-        n.width = bb.width();
-        n.height = bb.height();
-        n.transform = Affine::translate((bb.x0, bb.y0));
-        if pen.closed && n.fills.is_empty() {
-            n.fills = vec![figcraft_color::Paint::solid(figcraft_color::Color::DEFAULT_SHAPE)];
-        }
-        ds.selection = vec![id];
-        ds.revision += 1;
-        if let Some(p) = self.tool.pen.as_mut() {
-            p.id = Some(id);
-        }
-        Ok(())
-    }
-
-    /// Edit `id` as a vector with the pen, going on from point `anchor` (or, without one, starting
-    /// a new path in the same layer at the next click).
-    fn pen_edit(&mut self, id: NodeId, anchor: Option<usize>) -> Result<()> {
-        self.set_tool(ToolId::Move);
-        crate::vectoredit::begin(self, id)?;
-        crate::vectoredit::set_tool(self, crate::vectoredit::VTool::Pen)?;
-        crate::vectoredit::set_state(self, |e| {
-            e.anchor = anchor;
-            e.vertices = anchor.into_iter().collect();
-        })
-    }
-
-    /// Enter/Escape while the pen draws: the path ends but its layer stays in edit mode with the
-    /// pen, so the next path joins the same vector (another Escape leaves edit mode).
-    pub fn pen_end(&mut self) -> Result<()> {
-        let id = self.tool.pen.as_ref().and_then(|p| p.id);
-        self.pen_finish()?;
-        match id {
-            Some(id) if self.doc()?.contains(id) => self.pen_edit(id, None),
-            _ => Ok(()),
-        }
-    }
-
-    /// Finish the pen path (and keep the pen tool: double-click, Delete, a tool switch).
-    pub fn pen_finish(&mut self) -> Result<()> {
-        let pen = self.tool.pen.take();
-        self.tool.overlay.pen.clear();
-        self.tool.overlay.pen_handles.clear();
-        self.tool.overlay.rubber = None;
-        self.tool.overlay.rubber_handle = None;
-        self.tool.gesture = Gesture::None;
-        if pen.as_ref().is_some_and(|p| p.id.is_some()) {
-            self.commit_interaction()?;
-        }
-        Ok(())
-    }
-
-    fn pencil_finish(&mut self, points: &[Point], pressure: &[Option<f32>]) -> Result<()> {
-        if points.len() < 2 {
-            return Ok(());
-        }
-        // Smooth: fit a curve through the samples.
-        let mut poly = figcraft_geom::BezPath::new();
-        for (k, p) in points.iter().enumerate() {
-            if k == 0 {
-                poly.move_to(*p);
-            } else {
-                poly.line_to(*p);
-            }
-        }
-        let fitted = figcraft_geom::kurbo::simplify::simplify_bezpath(poly.iter(), 0.75, &Default::default());
-        let d = fitted.to_svg();
-        if matches!(self.tool.tool, ToolId::Marker | ToolId::Highlighter) {
-            return self.ink_finish(&d);
-        }
-        let page = self.page()?;
-        let parent = frame_at(self.doc()?, page, points.first().copied().unwrap_or_default(), &[]).unwrap_or(page);
-        let pw = self.doc()?.world_transform(parent);
-        let mut local = fitted.clone();
-        local.apply_affine(pw.inverse());
-        let _ = d;
-        let (color, weight) = PENCIL_STROKE;
-        let mut props = json!({"fills": [], "strokes": [color.to_css_hex()], "strokeWeight": weight, "strokeCap": "round", "strokeJoin": "round", "strokeAlign": "center"});
-        // Pen pressure becomes the stroke's width profile (brushes follow it too).
-        if let Some(points) = pressure_profile(points, pressure) {
-            props["widthProfile"] = json!(points);
-        }
-        if let Some(b) = &self.tool.pencil_brush {
-            props["brush"] = serde_json::to_value(b).unwrap_or_default();
-        }
-        self.execute(
-            "node.create",
-            &json!({"type": "vector", "path": local.to_svg(), "closed": false, "parent": parent, "name": "Vector", "props": props}),
-        )?;
-        Ok(())
-    }
-
-    /// Keys the current mode handles before menu shortcuts (vector edit mode's tools and point
-    /// keys, Enter to finish the shape builder). Returns whether the key was used.
-    pub fn tool_key(&mut self, name: &str, shift: bool, alt: bool, cmd: bool) -> Result<bool> {
-        // Dev Mode edits nothing: keys go to the commands (which it refuses in the app).
-        if self.tool.dev_mode {
-            return Ok(false);
-        }
-        if self.ds().is_ok_and(|d| d.vector_edit.is_some()) {
-            return crate::vectoredit::key(self, name, shift, alt, cmd);
-        }
-        if !alt && !cmd && self.guide_key(name, shift)? {
-            return Ok(true);
-        }
-        crate::shapebuilder::key(self, name)
-    }
-
-    /// Keys for a selected ruler guide: Delete removes it, arrows across it nudge it (Shift: the big
-    /// nudge), Escape deselects it.
-    fn guide_key(&mut self, name: &str, shift: bool) -> Result<bool> {
-        let Some((owner, index)) = self.ds()?.selected_guide() else { return Ok(false) };
-        // Backspace is Delete, `Left` is `ArrowLeft`, and so on.
-        let name = crate::keymap::normalize(name).map_or(name, |(k, _)| k);
-        let page = self.page()?;
-        let at = |mut p: serde_json::Value| {
-            if owner != page {
-                p["frame"] = json!(owner);
-            }
-            p
-        };
-        let Some(g) = self.doc()?.node(owner).and_then(|n| n.guides().get(index).cloned()) else { return Ok(false) };
-        let step = if shift { self.prefs.nudge_big } else { self.prefs.nudge_small };
-        let d = match (name, g.vertical) {
-            ("Delete", _) => {
-                self.execute("guide.remove", &at(json!({"index": index})))?;
-                return Ok(true);
-            }
-            ("Escape", _) => {
-                self.execute("guide.select", &json!({}))?;
-                return Ok(true);
-            }
-            ("ArrowLeft", true) | ("ArrowUp", false) => -step,
-            ("ArrowRight", true) | ("ArrowDown", false) => step,
-            _ => return Ok(false),
-        };
-        self.execute("guide.move", &at(json!({"index": index, "offset": g.offset + d})))?;
-        Ok(true)
-    }
-
-    /// The layer under `p` for a click: the topmost on `page`, or in the focus view the focused
-    /// frame's. Boolean groups are hit by their results ([`crate::booleans::result_outline`]); in
-    /// outline mode shapes only on their outlines.
-    pub fn hit(&self, doc: &Document, page: NodeId, p: Point, tol: f64) -> Option<NodeId> {
-        let sel = self.selection();
-        let result = crate::booleans::result_outline(doc, &sel);
-        let focus = self.ds().ok().and_then(crate::DocState::focused);
-        // Outline mode draws no fills: shapes are clicked on their outlines, reaching what's behind.
-        if let Some(v) = self.ds().ok().map(|d| &d.view).filter(|v| v.outlines) {
-            // What it draws besides the shapes can be clicked too.
-            let also = figcraft_doc::geometry::OutlineHits { hidden: v.outline_hidden, bounds: v.outline_bounds };
-            return figcraft_doc::geometry::hit_outlines(doc, focus.unwrap_or(page), p, tol, Some(&result), also);
-        }
-        match focus {
-            Some(f) => figcraft_doc::geometry::hit_in(doc, f, p, tol, Some(&result)),
-            None => doc.hit_test(page, p, tol, Some(&result)),
-        }
-    }
-
-    /// Enter with a shape or frame tool (`tool.place`): what a click with it makes, centred on `at`
-    /// (default the middle of the view) and selected.
-    pub fn place(&mut self, at: Option<Point>) -> Result<()> {
-        let tool = self.tool.tool;
-        let refuse = |why: &str| Err(crate::EngineError::Disabled("tool.place".into(), why.into()));
-        if !tool.draws_shape() {
-            return refuse("choose a shape or frame tool first");
-        }
-        if self.tool.busy() {
-            return refuse("finish the drag first");
-        }
-        let v = &self.ds()?.view;
-        let (c, zoom) = (at.unwrap_or(Point::new(v.cx, v.cy)), v.zoom);
-        let (w, h) = tool.click_size();
-        let ev = |kind| PointerEvent::at(kind, c.x - w / 2.0, c.y - h / 2.0, zoom);
-        let r = self.pointer(&ev(PointerKind::Down)).and_then(|()| self.pointer(&ev(PointerKind::Up)));
-        if r.is_err() {
-            self.tool.gesture = Gesture::None;
-            let _ = self.cancel_interaction();
-        }
-        r
-    }
-
-    /// Keyboard Escape: cancel gestures, finish pens, leave text editing, then deselect (in the
-    /// focus view, once the focused frame or nothing is selected, it ends the focus view).
-    pub fn escape(&mut self) -> Result<()> {
-        // Following someone in a live session: Escape stops that first.
-        if self.live_unfollow() {
-            return Ok(());
-        }
-        if self.tool.pen.is_some() {
-            return self.pen_end();
-        }
-        if self.tool.busy() {
-            self.tool.gesture = Gesture::None;
-            self.tool.overlay = Overlay::default();
-            return self.cancel_interaction();
-        }
-        if self.end_origin_edit() {
-            return Ok(());
-        }
-        if self.ds()?.text_edit.is_some() {
-            return textedit::end(self);
-        }
-        if self.ds()?.vector_edit.is_some() {
-            return crate::vectoredit::escape(self);
-        }
-        if self.tool.tool != ToolId::Move {
-            self.set_tool(ToolId::Move);
-            return Ok(());
-        }
-        let sel = self.selection();
-        if let Some(f) = self.ds()?.focused()
-            && (sel.is_empty() || sel == [f])
-        {
-            self.ds_mut()?.focus = None;
-            return Ok(());
-        }
-        // Escape selects the parent, then nothing.
-        let doc = self.doc()?;
-        let parents: Vec<NodeId> =
-            sel.iter().filter_map(|i| doc.node(*i).and_then(|n| n.parent)).filter(|p| !doc.node(*p).is_some_and(Node::is_page)).collect();
-        if !parents.is_empty() {
-            let mut uniq = Vec::new();
-            for p in parents {
-                if !uniq.contains(&p) {
-                    uniq.push(p);
-                }
-            }
-            self.set_selection(uniq);
-        } else {
-            self.set_selection(vec![]);
-        }
-        Ok(())
-    }
-
-    /// Whether the Move tool shows arc and shape handles now (not while another gesture runs, nor
-    /// in vector or text edit mode).
-    fn arc_handles_shown(&self) -> bool {
-        let arc_drag = matches!(self.tool.gesture, Gesture::Arc { .. } | Gesture::Shape { .. });
-        self.tool.tool == ToolId::Move
-            && !self.tool.dev_mode
-            && (arc_drag || !self.tool.busy())
-            && self.ds().is_ok_and(|ds| ds.vector_edit.is_none() && ds.text_edit.is_none())
-    }
-
-    /// The selected ellipse's arc handles as the canvas shows them at the current zoom.
-    pub fn arc_handles(&self) -> Option<crate::arc_handles::ArcHandles> {
-        let ds = self.ds().ok()?;
-        self.arc_handles_shown().then(|| crate::arc_handles::handles(&ds.doc, &ds.selection, ds.view.zoom)).flatten()
-    }
-
-    /// The selected shape's corner radius and star ratio handles as the canvas shows them now.
-    pub fn shape_handles(&self) -> Vec<(ShapeHandle, [f64; 2])> {
-        let Ok(ds) = self.ds() else { return vec![] };
-        if self.arc_handles_shown() { crate::shape_handles::handles(&ds.doc, &ds.selection, ds.view.zoom) } else { vec![] }
-    }
-
-    /// Snapshot of tool state for the UI / inspect.
-    pub fn tool_info(&self) -> serde_json::Value {
-        let shapes: Vec<serde_json::Value> = self.shape_handles().into_iter().map(|(h, at)| json!({"handle": h, "at": at})).collect();
-        json!({"tool": self.tool.tool.id(), "busy": self.tool.busy(), "overlay": self.tool.overlay, "arcHandles": self.arc_handles(), "shapeHandles": shapes})
-    }
-}
-
-/// The readout of a shape handle drag on `id`.
-fn shape_hint(doc: &Document, id: NodeId, handle: ShapeHandle, zoom: f64) -> Option<ShapeHint> {
-    Some(ShapeHint { handle, value: crate::shape_handles::value(doc, id, handle)?, at: crate::shape_handles::handle_at(doc, id, handle, zoom)? })
-}
-
-#[allow(dead_code)]
-fn unused(_: BTreeMap<u8, u8>) {}
-
-/// An end point of a selected open vector within `tol` of page point `p`: (layer, point).
-fn selected_end_at(doc: &Document, sel: &[NodeId], p: Point, tol: f64) -> Option<(NodeId, usize)> {
-    sel.iter().find_map(|id| {
-        let net = crate::vectoredit::network(doc, *id)?;
-        let w = doc.world_transform(*id);
-        let near = |v: &usize| net.vertices.get(*v).is_some_and(|x| (w * x.point() - p).hypot() <= tol);
-        (0..net.vertices.len()).filter(near).find(|v| net.incident(*v).len() == 1).map(|v| (*id, v))
-    })
-}
diff --git a/crates/engine/src/canvas/tools/click.rs b/crates/engine/src/canvas/tools/click.rs
new file mode 100644
index 00000000..8f21aaca
--- /dev/null
+++ b/crates/engine/src/canvas/tools/click.rs
@@ -0,0 +1,344 @@
+use super::handles::{PATH_REACH_PX, label_at, locked_in, path_candidates, readable_text_fills};
+use super::*;
+
+impl Session {
+    /// Handle a double-click gesture: finish a pen path, rename or click labels/widgets,
+    /// cancel an in-progress move/resize/draw/marquee, handle board double-clicks, enter text
+    /// editing (select-all on entry, word-select inside the running edit), enter vector editing
+    /// for selected shapes, and step groups/frames one level deeper.
+    /// A double-click on `leaf` that a board object or a widget's editable field takes (typing into
+    /// a sticky or a shape on a board; editing the field like any text, its plugin told when editing
+    /// ends). Whether it was taken.
+    fn object_double_click(&mut self, doc: &Document, leaf: NodeId, sel: &[NodeId], p: Point, edits: bool) -> Result<bool> {
+        if matches!(self.tool.tool, ToolId::Move | ToolId::Scale) && self.board_double_click(doc, leaf, sel)? {
+            return Ok(true);
+        }
+        match crate::widgets::field_at(doc, leaf, p).filter(|_| edits) {
+            Some(field) => textedit::begin(self, field, None, false).map(|()| true),
+            None => Ok(false),
+        }
+    }
+
+    pub(super) fn double_click(&mut self, ev: &PointerEvent) -> Result<()> {
+        let ds = self.ds()?;
+        let (doc, sel, page) = (ds.doc.clone(), ds.selection.clone(), ds.page);
+        if self.tool.tool == ToolId::Pen {
+            return self.pen_finish();
+        }
+        let edits = !self.tool.dev_mode;
+        // A frame's or section's name label: rename it there (the canvas puts a field over it).
+        // Labels come before widgets, as on a press; the second press began a move: undo it.
+        if edits
+            && matches!(self.tool.tool, ToolId::Move | ToolId::Scale)
+            && !(ev.shift || ev.cmd || ev.alt)
+            && let Some(id) = label_at(&doc, page, &self.tool.labels, ev.p())
+        {
+            self.tool.gesture = Gesture::None;
+            self.cancel_interaction()?;
+            if sel != [id] {
+                self.set_selection(vec![id]);
+            }
+            self.request_ui("canvas.renameLabel", serde_json::json!({"id": id}));
+            return Ok(());
+        }
+        // Quick clicks on a widget's clickable part are clicks, one by one.
+        if edits
+            && matches!(self.tool.tool, ToolId::Move | ToolId::Scale)
+            && !(ev.shift || ev.cmd || ev.alt)
+            && self.hit(&doc, page, ev.p(), ev.tol() * 2.0).and_then(|hit| crate::widgets::target_at(&doc, hit, ev.p())).is_some()
+        {
+            self.tool.gesture = Gesture::None;
+            self.cancel_interaction()?;
+            self.widget_click(ev.p(), ev.tol() * 2.0)?;
+            return Ok(());
+        }
+        // The second press began a move, a resize, a shape or a marquee: a double-click isn't one.
+        if matches!(self.tool.gesture, Gesture::Move { .. } | Gesture::Resize { .. } | Gesture::Draw { .. } | Gesture::Marquee { .. }) {
+            self.tool.gesture = Gesture::None;
+            self.tool.overlay.marquee = None;
+            self.cancel_interaction()?;
+        }
+        let hit_here = self.hit(&doc, page, ev.p(), ev.tol() * 2.0);
+        // A double-click anywhere on the one selected shape edits its points, like Enter: also
+        // inside a hollow (unfilled) closed shape, where the hit test finds nothing under the
+        // pointer (an open path or a line has no inside: only its stroke counts).
+        if edits
+            && let [id] = sel[..]
+            && doc.node(id).is_some_and(|n| n.kind.is_shape() && figcraft_doc::geometry::is_closed(n))
+            && doc.world_bounds(id).is_some_and(|b| b.contains(ev.p()))
+            && hit_here.is_none_or(|h| h == id || doc.is_ancestor(id, h))
+        {
+            return crate::vectoredit::begin_many(self, &[id]);
+        }
+        let Some(leaf) = hit_here else { return Ok(()) };
+        if self.object_double_click(&doc, leaf, &sel, ev.p(), edits)? {
+            return Ok(());
+        }
+        let target = select_target(&doc, leaf, &sel, true);
+        // Text: edit at the click.
+        if edits
+            && doc.node(target).is_some_and(|n| matches!(n.kind, NodeKind::Text(_)))
+            && (sel.contains(&target) || select_target(&doc, leaf, &sel, false) == target)
+        {
+            // Entering a text selects all of it; in the text being edited, the word. A
+            // double-click inside the running edit is an ordinary edit: starting a new session
+            // here would replace the IME owner's epoch and drop a composition on a plain gesture.
+            let editing = self.ds()?.text_edit.as_ref().is_some_and(|te| te.id == target);
+            let idx = self.text_index_at(target, ev.p())?;
+            if editing {
+                textedit::select_word(self, idx)?;
+            } else {
+                textedit::begin(self, target, Some(idx), false)?;
+                textedit::key(self, "SelectAll", false, false, false)?;
+            }
+            return Ok(());
+        }
+        // Shapes and vectors: enter vector edit mode (every selected shape, the clicked one active).
+        // A shape clicked on its own edits even when the click that selects it and the double-click
+        // arrived in one frame (a press and a release the canvas took together), so no selection was
+        // made yet; another layer's shapes are reached one level at a time, as below.
+        if edits && doc.node(target).is_some_and(|n| n.kind.is_shape()) && (sel.contains(&target) || select_target(&doc, leaf, &sel, false) == target)
+        {
+            let mut ids = if sel.contains(&target) { crate::vectoredit::enter_targets(&doc, &sel).unwrap_or_default() } else { vec![target] };
+            ids.retain(|i| *i != target);
+            ids.insert(0, target);
+            return crate::vectoredit::begin_many(self, &ids);
+        }
+        // Groups, frames and boolean groups: select one level deeper (the layer under the pointer).
+        let deeper = figcraft_doc::geometry::enter_target(&doc, leaf, &sel);
+        if deeper != target || !sel.contains(&deeper) {
+            self.set_selection(vec![deeper]);
+        }
+        Ok(())
+    }
+
+    /// A plain click at `p` on a clickable part of a widget calls its plugin back (a failure is
+    /// shown as a message).
+    pub(super) fn widget_click(&mut self, p: Point, tol: f64) -> Result<()> {
+        let (doc, page) = (self.doc()?.clone(), self.page()?);
+        let Some((id, target)) = self.hit(&doc, page, p, tol).and_then(|hit| crate::widgets::target_at(&doc, hit, p)) else { return Ok(()) };
+        if let Err(e) = self.execute("widget.click", &serde_json::json!({"id": id, "target": target})) {
+            self.message = Some(e.to_string());
+        }
+        Ok(())
+    }
+
+    /// The char index in text node `id` at page point `p`.
+    pub fn text_index_at(&self, id: NodeId, p: Point) -> Result<usize> {
+        let doc = self.doc()?;
+        let n = doc.get(id)?;
+        let local = doc.world_transform(id).inverse() * p;
+        let Some((layout, dy)) = figcraft_text::layout_node(n) else { return Ok(0) };
+        Ok(layout.hit(local.x, local.y - dy))
+    }
+
+    pub(super) fn text_click(&mut self, id: NodeId, ev: &PointerEvent, extend: bool) -> Result<()> {
+        let idx = self.text_index_at(id, ev.p())?;
+        textedit::set_caret(self, idx, extend)?;
+        self.tool.gesture = Gesture::TextSelect { id };
+        Ok(())
+    }
+
+    pub(super) fn text_down(&mut self, ev: &PointerEvent) -> Result<()> {
+        let ds = self.ds()?;
+        let (doc, page) = (ds.doc.clone(), ds.page);
+        if let Some(te) = ds.text_edit.clone() {
+            if doc.world_bounds(te.id).is_some_and(|b| b.contains(ev.p())) {
+                return self.text_click(te.id, ev, ev.shift);
+            }
+            textedit::end(self)?;
+        }
+        // Clicking existing text edits it.
+        if let Some(leaf) = self.hit(&doc, page, ev.p(), ev.tol() * 2.0)
+            && doc.node(leaf).is_some_and(|n| matches!(n.kind, NodeKind::Text(_)))
+        {
+            let idx = self.text_index_at(leaf, ev.p())?;
+            textedit::begin(self, leaf, Some(idx), false)?;
+            self.tool.gesture = Gesture::TextSelect { id: leaf };
+            return Ok(());
+        }
+        // New text at the click (Figma puts the baseline-ish top-left there).
+        let parent = frame_at(&doc, page, ev.p(), &[]).unwrap_or(page);
+        let ds = self.ds_mut()?;
+        let d = ds.doc_mut();
+        let id = d.alloc_id();
+        let mut n = Node::new(id, NodeKind::Text(TextData::default()), "Text", 1.0, 14.0);
+        let pw = d.world_transform(parent);
+        let at = Point::new(ev.x.round(), (ev.y - 7.0).round());
+        n.transform = pw.inverse() * Affine::translate(at.to_vec2());
+        n.name = String::new();
+        if let Some(fills) = readable_text_fills(d, parent) {
+            n.fills = fills;
+        }
+        if let Some((w, h)) = figcraft_text::auto_size(&n) {
+            n.width = w.max(1.0);
+            n.height = h;
+        }
+        let line = n.height;
+        d.insert(n, parent, None)?;
+        ds.selection = vec![id];
+        textedit::begin(self, id, Some(0), true)?;
+        self.tool.gesture = Gesture::TextBox { id, start: ev.p(), line };
+        if !self.prefs.keep_tool {
+            self.tool.tool = ToolId::Move;
+        }
+        Ok(())
+    }
+
+    /// The layer whose path is under `ev` for the Text on a path tool and where along it the press
+    /// is (0..1 by length): the front-most shape or vector layer within a few screen pixels of its
+    /// first subpath (the one text follows), not locked and not inside an instance. Layers in front
+    /// whose path is further away don't hide it.
+    pub(crate) fn path_at(&self, doc: &Document, page: NodeId, ev: &PointerEvent) -> Option<(NodeId, f64)> {
+        let reach = ev.tol() * PATH_REACH_PX;
+        let near = |id: NodeId| -> Option<(NodeId, f64)> {
+            let n = doc.node(id)?;
+            let shape = matches!(
+                n.kind,
+                NodeKind::Rectangle
+                    | NodeKind::Ellipse { .. }
+                    | NodeKind::Polygon { .. }
+                    | NodeKind::Star { .. }
+                    | NodeKind::Line
+                    | NodeKind::Vector { .. }
+            );
+            if !shape || locked_in(doc, id) || crate::components::inside_instance(doc, id) {
+                return None;
+            }
+            let geom = figcraft_doc::geometry::stroke_geometry(n)?;
+            let line = figcraft_geom::measure::polylines(&geom)?.into_iter().next()?;
+            // Measured on the page (a layer scaled more one way than the other is still reached
+            // where it shows), the start by length along the layer's own path.
+            let world = doc.world_transform(id);
+            let p = ev.p();
+            let mut best: Option<(f64, f64)> = None;
+            for (i, w) in line.points.windows(2).enumerate() {
+                let (a, b) = (world * w[0], world * w[1]);
+                let d = b - a;
+                let l2 = d.hypot2();
+                let u = if l2 > 1e-18 { ((p - a).dot(d) / l2).clamp(0.0, 1.0) } else { 0.0 };
+                let dist = (a.lerp(b, u) - p).hypot();
+                if best.is_none_or(|(_, bd)| dist < bd) {
+                    let (la, lb) = (*line.lengths.get(i)?, *line.lengths.get(i + 1)?);
+                    best = Some((la + u * (lb - la), dist));
+                }
+            }
+            let (along, dist) = best?;
+            let len = line.length();
+            (len > 1e-9 && dist <= reach).then_some((id, along / len))
+        };
+        let mut candidates = Vec::new();
+        path_candidates(doc, page, ev.p(), reach, 0, &mut candidates);
+        candidates.into_iter().find_map(near)
+    }
+
+    /// A press with the Text on a path tool: on a path, a new empty text layer goes onto it,
+    /// starting where it was pressed, and typing starts. The text takes the path layer's place,
+    /// geometry, transform, constraints and effects, and its fills when one of them shows; the path
+    /// layer is removed. Ending the edit with nothing typed puts the path back without an undo step
+    /// ([`textedit::end`]). Elsewhere a press does nothing.
+    pub(super) fn text_on_path_down(&mut self, ev: &PointerEvent) -> Result<()> {
+        if let Some(te) = self.ds()?.text_edit.clone() {
+            if self.ds()?.doc.world_bounds(te.id).is_some_and(|b| b.contains(ev.p())) {
+                return self.text_click(te.id, ev, ev.shift);
+            }
+            textedit::end(self)?;
+        }
+        let ds = self.ds()?;
+        let (doc, page) = (ds.doc.clone(), ds.page);
+        let Some((path, start)) = self.path_at(&doc, page, ev) else { return Ok(()) };
+        let Some(pn) = doc.node(path) else { return Ok(()) };
+        let (Some(parent), Some(geom)) = (pn.parent, figcraft_doc::geometry::stroke_geometry(pn)) else { return Ok(()) };
+        let index = doc.index_in_parent(path);
+        self.begin_interaction("Text on a path")?;
+        let ds = self.ds_mut()?;
+        let d = ds.doc_mut();
+        let id = d.alloc_id();
+        let mut n = Node::new(id, NodeKind::Text(TextData::default()), "Text", pn.width, pn.height);
+        n.name = String::new();
+        n.transform = pn.transform;
+        n.constraints = pn.constraints;
+        n.child_layout = pn.child_layout.clone();
+        let effects = !pn.effects.is_empty();
+        if effects {
+            n.effects = pn.effects.clone();
+            n.styles.effect = pn.styles.effect.clone();
+        }
+        // A path drawn with a stroke only has no fill to give: the text gets the usual one.
+        let filled = pn.fills.iter().any(|f| f.visible);
+        if filled {
+            n.fills = pn.fills.clone();
+            n.styles.fill = pn.styles.fill.clone();
+        } else if let Some(fills) = readable_text_fills(d, parent) {
+            n.fills = fills;
+        }
+        // As `text.onPath`: a binding goes with the list it binds into (`fill`, `fills`, `fills/N/…`).
+        let carried = |k: &str| match crate::cmd::lists::list_binding(k) {
+            Some((crate::cmd::lists::BoundList::Fills, ..)) => filled,
+            Some((crate::cmd::lists::BoundList::Effects, ..)) => effects,
+            _ => false,
+        };
+        n.bound = pn.bound.iter().filter(|(k, _)| carried(k)).map(|(k, v)| (k.clone(), v.clone())).collect();
+        if let NodeKind::Text(t) = &mut n.kind {
+            let mut tp = TextPath::new(&geom);
+            tp.start = start;
+            t.path = Some(Box::new(tp));
+        }
+        d.insert(n, parent, index)?;
+        d.remove(path)?;
+        ds.selection = vec![id];
+        textedit::begin(self, id, Some(0), true)?;
+        if !self.prefs.keep_tool {
+            self.tool.tool = ToolId::Move;
+        }
+        Ok(())
+    }
+
+    /// Drag out a new text box: past the drag slop it has the drag's size (at least one line
+    /// tall) and its top-left, and that size is fixed.
+    pub(super) fn text_box_drag(&mut self, ev: &PointerEvent, id: NodeId, start: Point, line: f64) -> Result<()> {
+        if within_slop(ev, start) {
+            return Ok(());
+        }
+        let r = Rect::from_points(start, ev.p());
+        let d = self.ds_mut()?.doc_mut();
+        let pw = d.node(id).and_then(|n| n.parent).map(|p| d.world_transform(p)).unwrap_or_default();
+        let n = d.get_mut(id)?;
+        n.transform = pw.inverse() * Affine::translate((r.x0.round(), r.y0.round()));
+        n.width = r.width().round().max(1.0);
+        n.height = r.height().round().max(line);
+        n.child_layout.sizing_h = Sizing::Fixed;
+        n.child_layout.sizing_v = Sizing::Fixed;
+        if let NodeKind::Text(t) = &mut n.kind {
+            t.auto_resize = TextAutoResize::None;
+        }
+        self.ds_mut()?.revision += 1;
+        Ok(())
+    }
+
+    pub(super) fn eyedrop(&mut self, ev: &PointerEvent) -> Result<()> {
+        let ds = self.ds()?;
+        let doc = ds.doc.clone();
+        let view = figcraft_render::View { origin: (ev.x, ev.y), scale: ev.zoom.max(0.01), width: 1, height: 1 };
+        let Some(pix) = figcraft_render::render_view(&doc, ds.page, &view, &Default::default()) else { return Ok(()) };
+        let rgba = figcraft_render::to_rgba8(&pix);
+        let c = figcraft_color::Color::from_rgba8(
+            rgba.first().copied().unwrap_or(0),
+            rgba.get(1).copied().unwrap_or(0),
+            rgba.get(2).copied().unwrap_or(0),
+            255,
+        );
+        let sel = ds.selection.clone();
+        if self.tool.pick_only {
+            self.tool.picked = Some(c);
+        } else if !sel.is_empty() {
+            self.execute("node.set", &json!({"ids": sel, "props": {"fill": c.to_css_hex()}}))?;
+        }
+        self.recent_colors.retain(|x| *x != c);
+        self.recent_colors.insert(0, c);
+        self.recent_colors.truncate(16);
+        self.message = Some(format!("Picked #{}", c.to_hex()));
+        self.set_tool(ToolId::Move);
+        Ok(())
+    }
+}
diff --git a/crates/engine/src/canvas/tools/drag.rs b/crates/engine/src/canvas/tools/drag.rs
new file mode 100644
index 00000000..0d406673
--- /dev/null
+++ b/crates/engine/src/canvas/tools/drag.rs
@@ -0,0 +1,605 @@
+use super::handles::{
+    SNAP_PX, handle_at, in_quad, label_at, locked_in, on_corner_square, paints_below, resized_box, scale_factor, selection_box, selection_frame,
+    shape_hint,
+};
+use super::*;
+
+impl Session {
+    pub(super) fn move_down(&mut self, ev: &PointerEvent) -> Result<()> {
+        let ds = self.ds()?;
+        let (doc, sel, page) = (ds.doc.clone(), ds.selection.clone(), ds.page);
+        // Clicking outside the text being edited ends editing.
+        if let Some(te) = ds.text_edit.clone() {
+            let inside = doc.world_bounds(te.id).is_some_and(|b| b.inflate(ev.tol() * 4.0, ev.tol() * 4.0).contains(ev.p()));
+            if inside {
+                return self.text_click(te.id, ev, ev.shift);
+            }
+            textedit::end(self)?;
+        }
+        // Handles first: a selected connector's ends, a selected ellipse's arc handles (drawn over
+        // the box), then the box's.
+        let edits = !self.tool.dev_mode;
+        if edits && let Some((id, from)) = crate::board::end_handle_at(&doc, &sel, ev.p(), ev.zoom) {
+            self.tool.gesture = Gesture::Reattach { id, from, start: ev.p() };
+            return Ok(());
+        }
+        if self.arc_handles_shown()
+            && let Some((id, handle)) = crate::arc_handles::hit(&doc, &sel, ev.p(), ev.zoom)
+            && let Some(arc) = crate::arc_handles::arc_of(&doc, id)
+        {
+            self.begin_interaction("Arc")?;
+            self.tool.gesture = Gesture::Arc { id, handle, arc };
+            self.tool.overlay.arc =
+                crate::arc_handles::handle_at(&doc, id, handle, arc, ev.zoom).map(|at| ArcHint { handle, label: arc.label(handle), at });
+            return Ok(());
+        }
+        if self.arc_handles_shown()
+            && !on_corner_square(&doc, &sel, ev.p(), ev.zoom)
+            && let Some((id, handle)) = crate::shape_handles::hit(&doc, &sel, ev.p(), ev.zoom)
+        {
+            self.begin_interaction("Corner radius")?;
+            self.tool.gesture = Gesture::Shape { id, handle };
+            self.tool.overlay.shape = shape_hint(&doc, id, handle, ev.zoom);
+            return Ok(());
+        }
+        if let Some(h) = handle_at(&doc, &sel, ev.p(), ev.zoom).filter(|_| edits) {
+            let ids = roots(&doc, &sel);
+            if let Handle::Rotate(_) = h {
+                let Some(b) = selection_box(&doc, &ids) else { return Ok(()) };
+                let center = self
+                    .ds()?
+                    .moved_origin()
+                    .unwrap_or_else(|| Point::new(b.iter().map(|c| c.x).sum::<f64>() / 4.0, b.iter().map(|c| c.y).sum::<f64>() / 4.0));
+                self.begin_interaction("Rotate")?;
+                self.tool.gesture = Gesture::Rotate { center, start_angle: (ev.p() - center).atan2(), ids };
+                return Ok(());
+            }
+            let nodes: Vec<(NodeId, Affine, f64, f64)> =
+                ids.iter().filter_map(|i| doc.node(*i).map(|n| (*i, doc.world_transform(*i), n.width, n.height))).collect();
+            let Some(frame) = selection_frame(&doc, &ids) else { return Ok(()) };
+            let single = ids.len() == 1;
+            self.begin_interaction(if self.tool.tool == ToolId::Scale { "Scale" } else { "Resize" })?;
+            self.tool.gesture = Gesture::Resize {
+                start: ev.p(),
+                r: Box::new(ResizeStart { nodes, frame, single, handle: h }),
+                scale_tool: self.tool.tool == ToolId::Scale,
+                moved: false,
+            };
+            return Ok(());
+        }
+        // A frame's name label picks the frame itself. The background of a top-level frame with
+        // layers in it is like the canvas (a press starts a marquee inside it) unless the frame is
+        // selected; an empty frame (or a widget, or a board object such as a sticky) is picked and
+        // dragged.
+        let board_background = |leaf: NodeId| {
+            !sel.contains(&leaf)
+                && doc.node(leaf).is_some_and(|n| {
+                    n.parent == Some(page) && n.kind.is_frame_like() && !n.children.is_empty() && !crate::widgets::is_widget(n) && !n.is_board_atom()
+                })
+        };
+        let label = label_at(&doc, page, &self.tool.labels, ev.p());
+        let target = label.or_else(|| {
+            self.hit(&doc, page, ev.p(), ev.tol() * 2.0)
+                .filter(|leaf| ev.cmd || !board_background(*leaf))
+                .map(|leaf| select_target(&doc, leaf, &sel, ev.cmd))
+        });
+        // A press inside the selection's box that reaches nothing above it (an unfilled shape's
+        // inside, the frame or canvas behind it, or a layer stacked below the selected layer the
+        // press is in) drags the selection. In a gap between selected layers, what's there is hit.
+        let in_own_box = |s: NodeId| selection_box(&doc, &[s]).is_some_and(|q| in_quad(&q, ev.p()));
+        let behind_sel = |t: Option<NodeId>| {
+            t.is_none_or(|t| sel.iter().any(|s| *s != t && (doc.is_ancestor(t, *s) || (in_own_box(*s) && paints_below(&doc, t, *s)))))
+        };
+        let target = match sel.iter().copied().find(|s| !locked_in(&doc, *s)) {
+            Some(first) if label.is_none() && !ev.shift && behind_sel(target) && selection_box(&doc, &sel).is_some_and(|q| in_quad(&q, ev.p())) => {
+                Some(first)
+            }
+            _ => target,
+        };
+        match target {
+            Some(target) => {
+                // Clicking inside the current selection's box keeps it (drag them all).
+                let in_sel_box = sel.len() > 1 && doc.bounds_of(&sel).is_some_and(|b| b.contains(ev.p())) && !ev.shift;
+                // Shift on a selected layer takes it out on release if the press doesn't become a
+                // drag; a drag moves the selection with it. Where no drag can start, it goes now.
+                let deselect = (ev.shift && sel.contains(&target)).then_some(target);
+                let without_target = || sel.iter().copied().filter(|x| *x != target).collect::<Vec<_>>();
+                let new_sel = if in_sel_box && (sel.contains(&target) || sel.iter().any(|s| doc.is_ancestor(*s, target))) {
+                    sel.clone()
+                } else if ev.shift && deselect.is_none() {
+                    let mut s2 = sel.clone();
+                    s2.push(target);
+                    s2
+                } else if sel.contains(&target) {
+                    sel.clone()
+                } else {
+                    vec![target]
+                };
+                self.set_selection(new_sel.clone());
+                // Dev Mode only selects (Shift-click still deselects): nothing moves.
+                if !edits {
+                    if deselect.is_some() {
+                        self.set_selection(without_target());
+                    }
+                    return Ok(());
+                }
+                // Locked layers selected in the layers panel stay put.
+                let ids: Vec<NodeId> = roots(&doc, &new_sel).into_iter().filter(|i| !locked_in(&doc, *i)).collect();
+                if new_sel.is_empty() || doc.node(target).is_some_and(|n| n.locked) || ids.is_empty() {
+                    if deselect.is_some() {
+                        self.set_selection(without_target());
+                    }
+                    return Ok(());
+                }
+                let mut targets = Targets::gather(&doc, page, &ids);
+                // A copy dragged out with Alt snaps to the layers it came from too (they stay put).
+                if ev.alt
+                    && let Some(b) = targets.moving
+                {
+                    targets.add_box(b);
+                }
+                if let Err(e) = self.begin_interaction(if ev.alt { "Duplicate" } else { "Move" }) {
+                    if deselect.is_some() {
+                        self.set_selection(without_target());
+                    }
+                    return Err(e);
+                }
+                self.tool.gesture = Gesture::Move { start: ev.p(), ids, targets, duplicate: ev.alt, moved: false, deselect };
+                self.tool.overlay.cursor = if ev.alt { Cursor::Copy } else { Cursor::Default };
+            }
+            None => {
+                let within = self.marquee_within(ev.p())?;
+                if !ev.shift {
+                    self.set_selection(vec![]);
+                }
+                self.tool.gesture = Gesture::Marquee { start: ev.p(), additive: ev.shift, base: if ev.shift { sel } else { vec![] }, within };
+            }
+        }
+        Ok(())
+    }
+
+    pub(super) fn drag(&mut self, ev: &PointerEvent) -> Result<()> {
+        let g = std::mem::take(&mut self.tool.gesture);
+        let res = match &g {
+            Gesture::None => return self.hover(ev),
+            Gesture::Marquee { start, additive, base, within } => {
+                let r = Rect::from_points(*start, ev.p());
+                self.tool.overlay.marquee = Some([r.x0, r.y0, r.x1, r.y1]);
+                // Cmd/Ctrl: the nested layers it touches.
+                let sel = self.marquee_selection(r, *within, ev.cmd, base, *additive)?;
+                self.set_selection(sel);
+                Ok(())
+            }
+            Gesture::Move { start, moved: false, .. } | Gesture::Resize { start, moved: false, .. } if within_slop(ev, *start) => Ok(()),
+            Gesture::Move { start, ids, targets, duplicate, .. } => {
+                let mut d = ev.p() - *start;
+                if ev.shift {
+                    if d.x.abs() > d.y.abs() {
+                        d.y = 0.0;
+                    } else {
+                        d.x = 0.0;
+                    }
+                }
+                // Cmd/Ctrl (and Control on macOS) held while dragging suspends snapping.
+                let snap_on = self.ds().map(|ds| ds.view.snap_objects).unwrap_or(true) && !ev.cmd && !ev.ctrl;
+                let mut guides = Vec::new();
+                if snap_on {
+                    let (c, g2) = targets.snap_move(d, SNAP_PX / ev.zoom.max(1e-6));
+                    d += c;
+                    guides = g2;
+                }
+                if self.ds().map(|ds| ds.view.snap_pixel).unwrap_or(true) {
+                    // Keep the box's origin on whole pixels (a rotated parent frame's, inside one).
+                    d = targets.round_move(d);
+                }
+                let ids = ids.clone();
+                let dup = *duplicate;
+                let page = self.page()?;
+                let mut drop_cell = None;
+                let mut drop_target = None;
+                let mut in_flow = false;
+                // Placed in a row or column: (is it a column, its gap) for the insertion line.
+                let mut slot_axis: Option<(bool, f64)> = None;
+                self.preview(|doc, sel| {
+                    let mut moving = ids.clone();
+                    if dup {
+                        let mut copies = Vec::new();
+                        for i in &ids {
+                            let parent = doc.get(*i)?.parent.unwrap_or(page);
+                            let idx = doc.index_in_parent(*i).map(|x| x + 1);
+                            copies.push(crate::components::copy_in_file(doc, *i, parent, idx)?);
+                        }
+                        // Connectors copied with what they join join the copies.
+                        let map = crate::board::copy_map(doc, &ids, &copies);
+                        crate::board::rejoin(doc, &crate::board::copied_items(doc, &map), &map, false);
+                        moving = copies;
+                        *sel = moving.clone();
+                    }
+                    let p = ev.p();
+                    let home = moving.first().and_then(|i| doc.node(*i)).and_then(|n| n.parent);
+                    // Absolute children of an auto layout frame stay in it, and so do the layers of
+                    // groups, boolean groups and instances ([`crate::drop::keeps_layers`]); the
+                    // rest may change parent.
+                    let flow = moving.iter().all(|i| doc.node(*i).is_some_and(|n| !n.child_layout.absolute))
+                        && !home.is_some_and(|h| crate::drop::keeps_layers(doc, h));
+                    let target = if flow { crate::drop::drag_parent(doc, page, p, &moving) } else { home.unwrap_or(page) };
+                    let mode = doc.node(target).and_then(|n| n.layout.as_ref()).map(|l| l.mode);
+                    if let (true, Some(mode)) = (flow, mode) {
+                        // Into (or within) an auto layout frame: the layers take the slot (a grid: the
+                        // cell) under the pointer, as the frame shows it now. A frame other than the
+                        // one they come from is outlined too.
+                        let cell = if mode == LayoutMode::Grid { crate::drop::grid_cell_at(doc, target, p) } else { None };
+                        let idx =
+                            if mode == LayoutMode::Grid { 0 } else { crate::drop::auto_layout_slot(doc, target, p, &moving).map_or(0, |(i, _)| i) };
+                        for m in &moving {
+                            if doc.get(*m)?.parent != Some(target) {
+                                doc.reparent(*m, target, None)?;
+                            }
+                        }
+                        if let (Some(first), Some((col, row, rect))) = (moving.first().copied(), cell) {
+                            let cl = &mut doc.get_mut(first)?.child_layout;
+                            cl.grid_column = Some(col);
+                            cl.grid_row = Some(row);
+                            drop_cell = Some(rect);
+                        } else if mode != LayoutMode::Grid {
+                            let mut kids: Vec<NodeId> = doc.get(target)?.children.iter().copied().filter(|c| !moving.contains(c)).collect();
+                            for (k, m) in moving.iter().enumerate() {
+                                kids.insert((idx + k).min(kids.len()), *m);
+                            }
+                            let gap = doc.node(target).and_then(|n| n.layout.as_ref()).map_or(0.0, |l| l.gap);
+                            doc.get_mut(target)?.children = kids;
+                            slot_axis = Some((mode == LayoutMode::Vertical, gap));
+                        }
+                        drop_target = (Some(target) != home).then_some(target);
+                        in_flow = true;
+                        return Ok(());
+                    }
+                    // A free move. Layers dragged out of an auto layout flow leave it (onto the page
+                    // while dragging; the drop puts them in the frame under the pointer).
+                    for m in &moving {
+                        let in_al = doc.node(*m).and_then(|n| n.parent).and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some());
+                        if flow && in_al {
+                            doc.reparent(*m, page, None)?;
+                        }
+                        move_world(doc, *m, d.x, d.y)?;
+                    }
+                    drop_target = (flow && target != page).then_some(target);
+                    Ok(())
+                })?;
+                let placed = if dup { self.selection() } else { ids };
+                // Snapping guides mean nothing while the layout places the layers; with Alt held,
+                // live distances to the neighbours replace them.
+                self.tool.overlay.guides = if in_flow {
+                    Vec::new()
+                } else if ev.alt {
+                    let doc = self.doc()?;
+                    doc.bounds_of(&placed).map(|b| crate::distance::neighbours(doc, page, &placed, b)).unwrap_or_default()
+                } else {
+                    guides
+                };
+                // The preview already shows the layers in their slot: the line marks it there, in
+                // the middle of the gap before them (clear of the selection box).
+                self.tool.overlay.insert_line = slot_axis.and_then(|(vertical, gap)| {
+                    let off = if gap.is_finite() { (gap / 2.0).clamp(3.0, 24.0) } else { 3.0 };
+                    self.doc().ok()?.bounds_of(&placed).map(|b| crate::drop::line_before(b, vertical, off))
+                });
+                self.tool.overlay.drop_cell = drop_cell;
+                self.tool.overlay.drop_target = drop_target;
+                self.tool.overlay.cursor = if self.refused(&placed, true) {
+                    Cursor::NotAllowed
+                } else if dup {
+                    Cursor::Copy
+                } else {
+                    Cursor::Default
+                };
+                self.tool.gesture = g.clone();
+                if let Gesture::Move { moved, .. } = &mut self.tool.gesture {
+                    *moved = true;
+                }
+                return Ok(());
+            }
+            Gesture::Resize { start, r, scale_tool, .. } => {
+                let res = self.resize_drag(ev, *start, r, *scale_tool);
+                self.tool.gesture = Gesture::Resize { start: *start, r: r.clone(), scale_tool: *scale_tool, moved: true };
+                if self.refused(&self.selection(), false) {
+                    self.tool.overlay.cursor = Cursor::NotAllowed;
+                }
+                return res;
+            }
+            Gesture::Rotate { center, start_angle, ids } => {
+                let mut a = ((ev.p() - *center).atan2() - start_angle).to_degrees();
+                if ev.shift {
+                    a = (a / 15.0).round() * 15.0;
+                }
+                let (c, ids) = (*center, ids.clone());
+                self.preview(|doc, _| {
+                    for i in &ids {
+                        crate::cmd::arrange::rotate_world(doc, *i, c, -a)?;
+                    }
+                    Ok(())
+                })?;
+                // The cursor turns with the pointer about the centre.
+                self.tool.overlay.cursor =
+                    if self.refused(&ids, false) { Cursor::NotAllowed } else { Cursor::Rotate((ev.p() - c).atan2().to_degrees()) };
+                Ok(())
+            }
+            Gesture::Draw { start, id, parent, targets } => {
+                let (start, id, parent, targets) = (*start, *id, *parent, targets.clone());
+                self.tool.gesture = g;
+                return self.draw_drag(ev, start, id, parent, &targets);
+            }
+            Gesture::TextBox { id, start, line } => {
+                let (id, start, line) = (*id, *start, *line);
+                self.tool.gesture = g;
+                return self.text_box_drag(ev, id, start, line);
+            }
+            Gesture::Arc { id, handle, arc } => {
+                let (id, handle, arc) = (*id, *handle, *arc);
+                self.tool.gesture = g;
+                return self.arc_drag(ev, id, handle, arc);
+            }
+            Gesture::Shape { id, handle } => {
+                let (id, handle) = (*id, *handle);
+                let doc = self.doc()?.clone();
+                if let Some(props) = crate::shape_handles::drag(&doc, id, handle, ev.p(), ev.alt) {
+                    self.preview(|doc, _| crate::cmd::props::apply("node.set", doc, id, &props))?;
+                }
+                self.tool.overlay.shape = shape_hint(self.doc()?, id, handle, ev.zoom);
+                self.tool.overlay.shape_hover = Some(handle);
+                Ok(())
+            }
+            Gesture::Pan { sx, sy, cx, cy } => {
+                let ds = self.ds_mut()?;
+                let z = ds.view.zoom.max(1e-6);
+                ds.view.cx = cx - (ev.sx - sx) / z;
+                ds.view.cy = cy - (ev.sy - sy) / z;
+                ds.revision += 1;
+                Ok(())
+            }
+            Gesture::Pencil { points, pressure } => {
+                let (mut pts, mut pressure) = (points.clone(), pressure.clone());
+                if pts.last().is_none_or(|l| (*l - ev.p()).hypot() > 0.5 / ev.zoom.max(1e-6)) {
+                    pts.push(ev.p());
+                    pressure.push(ev.pressure);
+                }
+                self.tool.overlay.pen = pts.iter().map(|p| [p.x, p.y]).collect();
+                self.tool.gesture = Gesture::Pencil { points: pts, pressure };
+                if let Ok(ds) = self.ds_mut() {
+                    ds.revision += 1;
+                }
+                return Ok(());
+            }
+            Gesture::TextSelect { id } => {
+                let id = *id;
+                let idx = self.text_index_at(id, ev.p())?;
+                textedit::set_caret(self, idx, true)?;
+                Ok(())
+            }
+            Gesture::Vector(_) | Gesture::ShapeBuild { .. } | Gesture::Origin => Ok(()),
+            Gesture::Connect { from, start } => {
+                let (from, start) = (*from, *start);
+                self.connect_drag(ev, from, start);
+                return Ok(());
+            }
+            Gesture::Erase { gone } => {
+                self.tool.gesture = Gesture::Erase { gone: gone.clone() };
+                return self.erase_at(ev);
+            }
+            Gesture::Reattach { id, from, start } => {
+                let (id, from, start) = (*id, *from, *start);
+                self.reattach_drag(ev, id, from, start);
+                return Ok(());
+            }
+            Gesture::PenDrag { anchor } => {
+                // A click's wobble pulls out no handle.
+                let out = if within_slop(ev, *anchor) { Vec2::ZERO } else { ev.p() - *anchor };
+                if let Some(pen) = self.tool.pen.as_mut()
+                    && let Some(last) = pen.points.last_mut()
+                {
+                    last.2 = out;
+                    last.1 = -out;
+                }
+                self.pen_update()?;
+                Ok(())
+            }
+        };
+        self.tool.gesture = g;
+        res
+    }
+
+    /// An arc handle drag: the new arc, written through `node.set`'s keys.
+    fn arc_drag(&mut self, ev: &PointerEvent, id: NodeId, handle: ArcHandle, arc: crate::arc_handles::Arc) -> Result<()> {
+        let doc = self.doc()?.clone();
+        let Some(next) = crate::arc_handles::drag(&doc, id, handle, arc, ev.p(), ev.shift, ev.zoom) else { return Ok(()) };
+        let props = crate::arc_handles::props(next);
+        self.preview(|doc, _| crate::cmd::props::apply("node.set", doc, id, &props))?;
+        self.tool.gesture = Gesture::Arc { id, handle, arc: next };
+        let at = crate::arc_handles::handle_at(self.doc()?, id, handle, next, ev.zoom);
+        self.tool.overlay.arc = at.map(|at| ArcHint { handle, label: next.label(handle), at });
+        self.tool.overlay.arc_hover = Some(handle);
+        Ok(())
+    }
+
+    fn resize_drag(&mut self, ev: &PointerEvent, start: Point, r: &ResizeStart, scale_tool: bool) -> Result<()> {
+        let page = self.page()?;
+        let snap = self.ds().map(|d| d.view.snap_objects).unwrap_or(true) && !ev.cmd && !ev.ctrl;
+        let ids: Vec<NodeId> = r.nodes.iter().map(|n| n.0).collect();
+        let targets = if snap { Some(Targets::gather(self.doc()?, page, &ids)) } else { None };
+        let mut p = ev.p();
+        let mut guides = Vec::new();
+        if let Some(t) = &targets {
+            let (dx, dy, g) = t.snap_point(p.x, p.y, SNAP_PX / ev.zoom.max(1e-6));
+            p.x += dx;
+            p.y += dy;
+            guides = g;
+        }
+        let _ = start;
+        // In the handle box's own axes (one layer: its local space).
+        let (frame, w0, h0) = r.frame;
+        // The pixel grid: an upright box's dragged sides land on whole pixels (the Scale tool
+        // scales by the factor as dragged).
+        if !scale_tool && self.ds().map(|d| d.view.snap_pixel).unwrap_or(true) && crate::guides::axis_aligned(frame) {
+            p = Point::new(p.x.round(), p.y.round());
+        }
+        let q = frame.inverse() * p;
+        let is_line = r.single && ids.first().and_then(|i| self.doc().ok()?.node(*i).map(|n| matches!(n.kind, NodeKind::Line))).unwrap_or(false);
+        if scale_tool {
+            return self.scale_drag(ev, r, q, guides);
+        }
+        if is_line {
+            // Line end handles: move the end point freely (length + angle).
+            let (a, b) = match r.handle {
+                Handle::Corner(0) => (p, frame * Point::new(w0, 0.0)),
+                _ => (frame * Point::new(0.0, 0.0), p),
+            };
+            let id = ids.first().copied().unwrap_or(NodeId(0));
+            self.preview(|doc, _| {
+                let mut v = b - a;
+                if ev.shift {
+                    let ang = (v.atan2() / (std::f64::consts::PI / 4.0)).round() * std::f64::consts::PI / 4.0;
+                    v = Vec2::from_angle(ang) * v.hypot();
+                }
+                let len = v.hypot();
+                let world = Affine::translate(a.to_vec2()) * Affine::rotate(v.atan2());
+                doc.set_world_transform(id, world)?;
+                figcraft_layout::set_size(doc, id, len, 0.0);
+                Ok(())
+            })?;
+            self.tool.overlay.guides = guides;
+            return Ok(());
+        }
+        // Constrain proportions (Shift, or the node's lock).
+        let keep = ev.shift || r.single && ids.first().and_then(|i| self.doc().ok()?.node(*i).map(|n| n.constrain_proportions)).unwrap_or(false);
+        let (x0, y0, x1, y1) = resized_box(r.handle, q, w0, h0, keep, ev.alt);
+        let (flip_x, flip_y) = (x1 < x0, y1 < y0);
+        let (nx0, ny0) = (x0.min(x1), y0.min(y1));
+        let (nw, nh) = ((x1 - x0).abs(), (y1 - y0).abs());
+        let nodes = r.nodes.clone();
+        let single = r.single;
+        let handle = r.handle;
+        // What's in a section stays where it is on the page, and so does what's in a frame resized
+        // with Cmd/Ctrl held (its constraints are ignored).
+        let keeps = |doc: &Document, id: NodeId| {
+            doc.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Section { .. }) || (ev.cmd && single && n.kind.is_frame_like()))
+        };
+        self.preview(|doc, _| {
+            if single {
+                let Some((id, world, _, _)) = nodes.first() else { return Ok(()) };
+                let kept = if keeps(doc, *id) { crate::cmd::props::children_worlds(doc, *id) } else { Vec::new() };
+                let mut t = *world * Affine::translate((nx0, ny0));
+                if flip_x {
+                    t *= Affine::new([-1.0, 0.0, 0.0, 1.0, nw, 0.0]);
+                }
+                if flip_y {
+                    t *= Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, nh]);
+                }
+                // Text reflow and auto layout can recompute this box after the preview (a size bound
+                // to a variable lets go of it: the resize is an explicit edit).
+                let n = doc.get(*id)?;
+                let crop_images = ev.cmd
+                    && !matches!(n.kind, NodeKind::Text(_))
+                    && !std::iter::once(*id).chain(doc.ancestors(*id)).any(|a| doc.node(a).is_some_and(|n| n.layout.is_some()));
+                if crop_images {
+                    // Crop the layer's image fills without moving their pixels on the page.
+                    // Work from the interaction snapshot, just like the geometry on every move.
+                    let (w, h) = (n.width.max(1e-6), n.height.max(1e-6));
+                    let to_old =
+                        Affine::scale_non_uniform(1.0 / w, 1.0 / h) * world.inverse() * t * Affine::scale_non_uniform(nw.max(0.01), nh.max(0.01));
+                    let mut fills = n.fills.clone();
+                    for paint in &mut fills {
+                        let PaintKind::Image(img) = &mut paint.kind else { continue };
+                        // A repeating image cannot be represented by a single Crop placement.
+                        if img.scale_mode == ImageScaleMode::Tile {
+                            continue;
+                        }
+                        let Some(data) = doc.images.get(&img.image) else { continue };
+                        let (iw, ih) = (f64::from(data.width), f64::from(data.height));
+                        let crop = if img.scale_mode == ImageScaleMode::Crop {
+                            img.effective_crop(iw, ih, w, h)
+                        } else {
+                            let (rw, rh) = img.rotated_size(iw.max(1.0), ih.max(1.0));
+                            let s = if img.scale_mode == ImageScaleMode::Fit { (w / rw).min(h / rh) } else { (w / rw).max(h / rh) };
+                            [w / (rw * s), 0.0, 0.0, h / (rh * s), (rw * s - w) / (2.0 * rw * s), (rh * s - h) / (2.0 * rh * s)]
+                        };
+                        // A degenerate (zero-scale) layer has no inverse: its image keeps its placement.
+                        let crop = (Affine::new(crop) * to_old).as_coeffs();
+                        if !crop.iter().all(|c| c.is_finite()) {
+                            continue;
+                        }
+                        img.crop = Some(crop);
+                        img.scale_mode = ImageScaleMode::Crop;
+                    }
+                    doc.get_mut(*id)?.fills = fills;
+                }
+                doc.set_world_transform(*id, t)?;
+                if kept.is_empty() {
+                    crate::cmd::props::resize_node(doc, *id, nw.max(0.01), nh.max(0.01))?;
+                } else {
+                    figcraft_layout::set_size(doc, *id, nw.max(0.01), nh.max(0.01));
+                    crate::cmd::props::restore_worlds(doc, &kept)?;
+                }
+                let n = doc.get_mut(*id)?;
+                if matches!(handle, Handle::Corner(_) | Handle::Edge(1) | Handle::Edge(3)) {
+                    n.child_layout.sizing_h = Sizing::Fixed;
+                }
+                if matches!(handle, Handle::Corner(_) | Handle::Edge(0) | Handle::Edge(2)) {
+                    n.child_layout.sizing_v = Sizing::Fixed;
+                }
+                if let NodeKind::Text(t) = &mut n.kind {
+                    match handle {
+                        Handle::Edge(1) | Handle::Edge(3) if t.auto_resize == TextAutoResize::Truncate => {}
+                        Handle::Edge(1) | Handle::Edge(3) => t.auto_resize = TextAutoResize::Height,
+                        _ => t.fix_size(true, true),
+                    }
+                }
+                return Ok(());
+            }
+            // Several layers: map the old box onto the new one, in the box's axes. Each layer's
+            // centre follows the box (mirrored when it flips); each keeps its rotation and scales
+            // along its own axes (see `axis_factors`), turning over with the box.
+            let (sx, sy) = (if w0 > 1e-9 { (x1 - x0) / w0 } else { 1.0 }, if h0 > 1e-9 { (y1 - y0) / h0 } else { 1.0 });
+            let mirror = Affine::new([sx.signum(), 0.0, 0.0, sy.signum(), 0.0, 0.0]);
+            let inv = frame.inverse();
+            for (id, world, w, h) in &nodes {
+                let local = inv * *world;
+                let center = local * Point::new(w / 2.0, h / 2.0);
+                let (kw, kh) = figcraft_layout::axis_factors(local, sx, sy);
+                let (w2, h2) = (w * kw, h * kh);
+                let lin = (mirror * local).with_translation(Vec2::ZERO);
+                let origin = Point::new(x0 + center.x * sx, y0 + center.y * sy) - lin * Point::new(w2 / 2.0, h2 / 2.0);
+                let kept = if keeps(doc, *id) { crate::cmd::props::children_worlds(doc, *id) } else { Vec::new() };
+                doc.set_world_transform(*id, frame * lin.with_translation(origin))?;
+                crate::cmd::props::resize_node(doc, *id, w2, h2)?;
+                crate::cmd::props::restore_worlds(doc, &kept)?;
+            }
+            Ok(())
+        })?;
+        self.tool.overlay.guides = guides;
+        Ok(())
+    }
+
+    /// Scale tool handle drag (`q`: the snapped pointer in the handle box's axes): everything
+    /// scales by one factor about the anchor point (Alt: the centre), strokes, effects, radii and
+    /// text included, children by the same factor whatever their constraints.
+    fn scale_drag(&mut self, ev: &PointerEvent, r: &ResizeStart, q: Point, guides: Vec<Guide>) -> Result<()> {
+        let (frame, w0, h0) = r.frame;
+        let Some((k, pivot)) = scale_factor(r.handle, q, w0, h0, self.tool.scale_anchor, ev.alt) else { return Ok(()) };
+        let nodes = r.nodes.clone();
+        let inv = frame.inverse();
+        // A layer's place in the box scales about the pivot; a negative factor turns it over.
+        let about = frame * Affine::translate(pivot.to_vec2() * (1.0 - k));
+        let sign = k.signum();
+        self.preview(|doc, _| {
+            for (id, world, _, _) in &nodes {
+                let c = (inv * *world).as_coeffs();
+                doc.set_world_transform(*id, about * Affine::new([sign * c[0], sign * c[1], sign * c[2], sign * c[3], k * c[4], k * c[5]]))?;
+                crate::cmd::arrange::scale_node(doc, *id, k.abs())?;
+            }
+            Ok(())
+        })?;
+        let p = frame * pivot;
+        self.tool.overlay.scale = Some(ScaleHint { factor: k, pivot: [p.x, p.y] });
+        self.tool.overlay.guides = guides;
+        Ok(())
+    }
+}
diff --git a/crates/engine/src/canvas/tools/draw.rs b/crates/engine/src/canvas/tools/draw.rs
new file mode 100644
index 00000000..b594ae27
--- /dev/null
+++ b/crates/engine/src/canvas/tools/draw.rs
@@ -0,0 +1,229 @@
+use super::handles::SNAP_PX;
+use super::pen::take_enclosed;
+use super::*;
+
+impl Session {
+    pub(super) fn draw_down(&mut self, ev: &PointerEvent) -> Result<()> {
+        let ds = self.ds()?;
+        let doc = ds.doc.clone();
+        let page = ds.page;
+        if ds.text_edit.is_some() {
+            textedit::end(self)?;
+        }
+        // Frames drawn inside frames nest; sections only at the top or in sections.
+        let parent = match self.tool.tool {
+            ToolId::Section => {
+                frame_at(&doc, page, ev.p(), &[]).filter(|f| doc.node(*f).is_some_and(|n| matches!(n.kind, NodeKind::Section { .. }))).unwrap_or(page)
+            }
+            _ => frame_at(&doc, page, ev.p(), &[]).unwrap_or(page),
+        };
+        let targets = Targets::gather(&doc, page, &[]);
+        self.begin_interaction(self.tool.tool.label())?;
+        self.tool.gesture = Gesture::Draw { start: ev.p(), id: None, parent, targets };
+        Ok(())
+    }
+
+    pub(super) fn draw_drag(&mut self, ev: &PointerEvent, start: Point, id: Option<NodeId>, parent: NodeId, targets: &Targets) -> Result<()> {
+        let tool = self.tool.tool;
+        let mut p = ev.p();
+        let mut guides = Vec::new();
+        if self.ds().map(|d| d.view.snap_objects).unwrap_or(true) && !ev.cmd && !ev.ctrl {
+            let (dx, dy, g) = targets.snap_point(p.x, p.y, SNAP_PX / ev.zoom.max(1e-6));
+            p.x += dx;
+            p.y += dy;
+            guides = g;
+        }
+        let pixel = self.ds().map(|d| d.view.snap_pixel).unwrap_or(true);
+        let mut created = id;
+        let page = self.page()?;
+        self.preview(|doc, sel| {
+            let (mut a, mut b) = (start, p);
+            if pixel {
+                a = Point::new(a.x.round(), a.y.round());
+                b = Point::new(b.x.round(), b.y.round());
+            }
+            let pw = doc.world_transform(parent);
+            let (kind, base) = match tool {
+                ToolId::Frame => (NodeKind::Frame, "Frame"),
+                ToolId::Section => (NodeKind::Section { contents_hidden: false }, "Section"),
+                ToolId::Slice => (NodeKind::Slice, "Slice"),
+                ToolId::Rectangle => (NodeKind::Rectangle, "Rectangle"),
+                ToolId::Ellipse => (NodeKind::Ellipse { start: 0.0, sweep: std::f64::consts::TAU, inner: 0.0 }, "Ellipse"),
+                ToolId::Polygon => (NodeKind::Polygon { count: 3 }, "Polygon"),
+                ToolId::Star => (NodeKind::Star { count: 5, inner_ratio: 0.38 }, "Star"),
+                ToolId::Line => (NodeKind::Line, "Line"),
+                ToolId::Arrow => (NodeKind::Line, "Arrow"),
+                _ => return Ok(()),
+            };
+            let name = match tool {
+                ToolId::Frame | ToolId::Section | ToolId::Slice => doc.next_name(base),
+                _ => base.to_string(),
+            };
+            let nid = doc.alloc_id();
+            let mut n = if tool == ToolId::Section { Node::new_section(nid, name, 0.0, 0.0) } else { Node::new(nid, kind, name, 0.0, 0.0) };
+            if tool == ToolId::Arrow {
+                n.stroke.cap_end = StrokeCap::LineArrow;
+            }
+            if matches!(tool, ToolId::Line | ToolId::Arrow) {
+                let mut v = b - a;
+                if ev.shift {
+                    let ang = (v.atan2() / (std::f64::consts::PI / 4.0)).round() * std::f64::consts::PI / 4.0;
+                    v = Vec2::from_angle(ang) * v.hypot();
+                }
+                // Alt draws from the centre, as for the other shapes.
+                let (a, v) = if ev.alt { (a - v, v * 2.0) } else { (a, v) };
+                n.width = v.hypot();
+                n.transform = pw.inverse() * Affine::translate(a.to_vec2()) * Affine::rotate(v.atan2());
+            } else {
+                let mut d = b - a;
+                if ev.shift {
+                    let m = d.x.abs().max(d.y.abs());
+                    d = Vec2::new(m * d.x.signum(), m * d.y.signum());
+                }
+                let (x0, y0, x1, y1) = if ev.alt { (a.x - d.x, a.y - d.y, a.x + d.x, a.y + d.y) } else { (a.x, a.y, a.x + d.x, a.y + d.y) };
+                let r = Rect::new(x0.min(x1), y0.min(y1), x0.max(x1), y0.max(y1));
+                n.width = r.width();
+                n.height = r.height();
+                n.transform = pw.inverse() * Affine::translate((r.x0, r.y0));
+            }
+            doc.insert(n, parent, None)?;
+            *sel = vec![nid];
+            created = Some(nid);
+            let _ = page;
+            Ok(())
+        })?;
+        self.tool.overlay.guides = guides;
+        self.tool.gesture = Gesture::Draw { start, id: created, parent, targets: targets.clone() };
+        Ok(())
+    }
+
+    pub(super) fn up(&mut self, ev: &PointerEvent) -> Result<()> {
+        let g = std::mem::take(&mut self.tool.gesture);
+        self.tool.overlay.marquee = None;
+        self.tool.overlay.guides.clear();
+        self.tool.overlay.scale = None;
+        self.tool.overlay.arc = None;
+        self.tool.overlay.shape = None;
+        self.tool.overlay.measure_box = None;
+        self.tool.overlay.insert_line = None;
+        self.tool.overlay.drop_cell = None;
+        let drop_target = self.tool.overlay.drop_target.take();
+        match g {
+            Gesture::Move { ids, moved, duplicate, start, deselect, .. } => {
+                if moved {
+                    // A free move lands in the frame under the pointer (or the page) where it was
+                    // dropped; layers in an auto layout frame already sit in their slot.
+                    let page = self.page()?;
+                    let sel = self.selection();
+                    let sources = if duplicate { ids.clone() } else { Vec::new() };
+                    let moving = if duplicate { sel } else { ids };
+                    let doc = self.doc()?.clone();
+                    let in_al =
+                        moving.iter().any(|m| doc.node(*m).and_then(|n| n.parent).and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some()));
+                    let target = drop_target.unwrap_or(page);
+                    let current = moving.first().and_then(|m| doc.node(*m)).and_then(|n| n.parent);
+                    if !in_al && current != Some(target) {
+                        let ds = self.ds_mut()?;
+                        let before = ds.doc.clone();
+                        let d = ds.doc_mut();
+                        for m in &moving {
+                            // Group, boolean group and instance layers stay put: they only move.
+                            let from = d.node(*m).and_then(|n| n.parent);
+                            if from.is_some_and(|f| crate::drop::keeps_layers(d, f)) || crate::components::structure_locked(d, target) {
+                                continue;
+                            }
+                            // A layer can't go into itself; it stays where it is.
+                            let _ = d.reparent(*m, target, None);
+                        }
+                        crate::normalize(ds.doc_mut(), &before);
+                    }
+                    // Reordering or dragging layers out of an instance (outside its slots), or
+                    // moving layers inside one, are edits only its main can make: the gesture is
+                    // undone.
+                    if self.refused(&moving, true) {
+                        self.cancel_interaction()?;
+                    } else {
+                        self.commit_interaction()?;
+                        // Duplicate repeats a free Alt-drag's step (an auto layout places its own).
+                        if duplicate && !in_al && moving.len() == sources.len() {
+                            self.ds_mut()?.last_duplicate = Some(crate::cmd::edit::Duplicated { sources, copies: moving });
+                        }
+                    }
+                } else {
+                    self.cancel_interaction()?;
+                    if let Some(d) = deselect {
+                        let sel = self.selection().into_iter().filter(|x| *x != d).collect();
+                        self.set_selection(sel);
+                    }
+                    if deselect.is_none() && !(ev.shift || ev.cmd || duplicate) {
+                        self.widget_click(start, ev.tol() * 2.0)?;
+                    }
+                }
+            }
+            Gesture::Resize { .. } | Gesture::Rotate { .. } | Gesture::Arc { .. } | Gesture::Shape { .. } => {
+                // Layers inside an instance keep their main's size and rotation.
+                if self.refused(&self.selection(), false) {
+                    self.cancel_interaction()?;
+                } else {
+                    self.commit_interaction()?;
+                }
+            }
+            Gesture::Draw { start, id, parent, .. } => {
+                let tiny = (ev.p() - start).hypot() * ev.zoom < 3.0;
+                if tiny || id.is_none() {
+                    // Click without drag: Figma makes a 100×100 shape (frames 100×100 too).
+                    self.cancel_interaction()?;
+                    self.begin_interaction(self.tool.tool.label())?;
+                    let (w, h) = self.tool.tool.click_size();
+                    let target = start + Vec2::new(w, h);
+                    let mut fake = ev.clone();
+                    fake.x = target.x;
+                    fake.y = target.y;
+                    fake.shift = false;
+                    fake.alt = false;
+                    self.tool.gesture = Gesture::None;
+                    let targets = Targets::default();
+                    self.draw_drag(&fake, start, None, parent, &targets)?;
+                    self.tool.gesture = Gesture::None;
+                }
+                if matches!(self.tool.tool, ToolId::Frame | ToolId::Section)
+                    && let Some(drawn) = self.selection().first().copied()
+                {
+                    let ds = self.ds_mut()?;
+                    let before = ds.doc.clone();
+                    take_enclosed(ds.doc_mut(), drawn)?;
+                    crate::normalize(ds.doc_mut(), &before);
+                }
+                self.commit_interaction()?;
+                if !self.prefs.keep_tool {
+                    self.set_tool(ToolId::Move);
+                }
+            }
+            Gesture::Pan { .. } => {
+                self.tool.overlay.cursor = Cursor::Grab;
+                if let Some(t) = self.tool.temp_from.take() {
+                    self.tool.tool = t;
+                }
+            }
+            Gesture::Pencil { mut points, mut pressure } => {
+                self.tool.overlay.pen.clear();
+                // The stroke ends where the button came up, even without a move to get there.
+                if points.last().is_none_or(|l| (*l - ev.p()).hypot() > 0.5 / ev.zoom.max(1e-6)) {
+                    points.push(ev.p());
+                    pressure.push(ev.pressure);
+                }
+                self.pencil_finish(&points, &pressure)?;
+            }
+            Gesture::Connect { from, start } => self.connect_up(ev, from, start)?,
+            Gesture::Erase { .. } => self.erase_up()?,
+            Gesture::Reattach { id, from, start } => self.reattach_up(ev, id, from, start)?,
+            Gesture::TextSelect { .. } | Gesture::TextBox { .. } | Gesture::Marquee { .. } | Gesture::None => {}
+            Gesture::PenDrag { .. } | Gesture::ShapeBuild { .. } | Gesture::Origin => {}
+            Gesture::Vector(_) => self.commit_interaction()?,
+        }
+        if let Ok(ds) = self.ds_mut() {
+            ds.revision += 1;
+        }
+        Ok(())
+    }
+}
diff --git a/crates/engine/src/canvas/tools/handles.rs b/crates/engine/src/canvas/tools/handles.rs
new file mode 100644
index 00000000..fd765f66
--- /dev/null
+++ b/crates/engine/src/canvas/tools/handles.rs
@@ -0,0 +1,426 @@
+use super::*;
+
+/// The frame whose name label (see [`ToolState::labels`]) is under `p` on `page`: the topmost
+/// one drawn, if it can be selected (still there, on the page, visible and unlocked).
+pub fn label_at(doc: &Document, page: NodeId, labels: &[(NodeId, [Point; 4])], p: Point) -> Option<NodeId> {
+    labels
+        .iter()
+        .rev()
+        .find(|(id, q)| in_quad(q, p) && doc.page_of(*id) == Some(page) && doc.node(*id).is_some_and(|n| n.visible && !n.locked))
+        .map(|(id, _)| *id)
+}
+
+/// Whether `p` is inside the convex quadrilateral `q` (either winding; edges included).
+pub(super) fn in_quad(q: &[Point; 4], p: Point) -> bool {
+    let (mut left, mut right) = (false, false);
+    for (a, b) in q.iter().zip(q.iter().cycle().skip(1)) {
+        let side = (*b - *a).cross(p - *a);
+        if !side.is_finite() {
+            return false;
+        }
+        left |= side < 0.0;
+        right |= side > 0.0;
+    }
+    // On one side of every edge (a point can't be on all four edges of a quad with an area).
+    left != right
+}
+
+/// An anchor name (`tl`, `t`, `tr`, `l`, `c`, `r`, `bl`, `b`, `br`) as column and row (0 start,
+/// 1 middle, 2 end).
+pub fn anchor_of(name: &str) -> Option<(u8, u8)> {
+    ANCHORS.iter().position(|a| a.eq_ignore_ascii_case(name.trim())).map(|i| ((i % 3) as u8, (i / 3) as u8))
+}
+
+/// The name of anchor `(column, row)`.
+pub fn anchor_name(a: (u8, u8)) -> &'static str {
+    ANCHORS.get(usize::from(a.1.min(2)) * 3 + usize::from(a.0.min(2))).copied().unwrap_or("tl")
+}
+
+/// The fill new text takes to be readable where it is drawn, in `parent`: white on a dark
+/// background (None: the model's default, black). The background is the nearest layer from `parent`
+/// out whose top visible fill is a mostly opaque solid colour, else the page (#362). For text made
+/// in the app: by the Text tool, or by a command that names no fill while the interface is up.
+pub(crate) fn readable_text_fills(doc: &Document, parent: NodeId) -> Option<Vec<figcraft_color::Paint>> {
+    let dark = std::iter::once(parent).chain(doc.ancestors(parent)).filter_map(|id| doc.node(id)).find_map(|n| match &n.kind {
+        NodeKind::Page { background, .. } => Some(background.is_dark()),
+        _ => n.fills.iter().rev().find(|p| p.visible).and_then(|p| p.solid_color()).filter(|c| c.a >= 0.5).map(|c| c.is_dark()),
+    });
+    dark.unwrap_or(false).then(|| vec![figcraft_color::Paint::solid(figcraft_color::Color::WHITE)])
+}
+
+const ANCHORS: [&str; 9] = ["tl", "t", "tr", "l", "c", "r", "bl", "b", "br"];
+
+const HANDLE_PX: f64 = 5.0;
+
+const ROTATE_PX: f64 = 18.0;
+
+/// Snap distance in screen pixels.
+pub(crate) const SNAP_PX: f64 = 5.0;
+
+/// Screen pixels the pointer travels after a press before a move or resize starts: a click or a
+/// double-click made with an unsteady hand doesn't drag what it lands on.
+pub(super) const DRAG_SLOP_PX: f64 = 3.0;
+
+/// Screen pixels from a path within which the Text on a path tool takes it.
+pub(super) const PATH_REACH_PX: f64 = 6.0;
+
+/// The visible layers under `id` whose box, grown by `reach` (page units), holds `p`, front-most
+/// first: what the Text on a path tool measures its distance to. Content a clipping frame or a
+/// mask hides at `p` and the operands of boolean groups are left out.
+pub(super) fn path_candidates(doc: &Document, id: NodeId, p: Point, reach: f64, depth: usize, out: &mut Vec<NodeId>) {
+    let Some(n) = doc.node(id) else { return };
+    if !n.visible || depth > 512 || matches!(n.kind, NodeKind::BooleanOp { .. }) {
+        return;
+    }
+    if n.clip && n.kind.is_frame_like() && !n.local_rect().contains(doc.world_transform(id).inverse() * p) {
+        return;
+    }
+    for c in n.paint_order().rev() {
+        let before = out.len();
+        path_candidates(doc, c, p, reach, depth + 1, out);
+        if out.len() > before && figcraft_doc::geometry::masked_out(doc, n, c, p) {
+            out.truncate(before);
+        }
+    }
+    if n.children.is_empty() && !n.is_mask && doc.world_bounds(id).is_some_and(|b| b.inflate(reach, reach).contains(p)) {
+        out.push(id);
+    }
+}
+
+/// Corners of the selection's handle box in page coordinates (tl, tr, br, bl).
+pub fn selection_box(doc: &Document, sel: &[NodeId]) -> Option<[Point; 4]> {
+    let (f, w, h) = selection_frame(doc, sel)?;
+    Some([f * Point::ZERO, f * Point::new(w, 0.0), f * Point::new(w, h), f * Point::new(0.0, h)])
+}
+
+/// The selection's handle box: the page transform of its top-left corner (axes along the box) and
+/// its size. One layer: its own box; several sharing a rotation: a box turned with them;
+/// otherwise the page-aligned bounds.
+pub fn selection_frame(doc: &Document, sel: &[NodeId]) -> Option<(Affine, f64, f64)> {
+    let ids = roots(doc, sel);
+    if let [id] = ids.as_slice() {
+        let n = doc.node(*id)?;
+        return Some((doc.world_transform(*id), n.width, n.height));
+    }
+    let Some(angle) = shared_rotation(doc, &ids) else {
+        let b = doc.bounds_of(&ids)?;
+        return Some((Affine::translate((b.x0, b.y0)), b.width(), b.height()));
+    };
+    let rot = Affine::rotate(angle);
+    let inv = rot.inverse();
+    let b = ids
+        .iter()
+        .filter_map(|i| Some(figcraft_geom::transform_rect_bbox(inv * doc.world_transform(*i), doc.node(*i)?.local_rect())))
+        .reduce(|a, b| a.union(b))?;
+    Some((rot * Affine::translate((b.x0, b.y0)), b.width(), b.height()))
+}
+
+/// The rotation (radians) every layer in `ids` shares, unless it's a multiple of 90 degrees (the
+/// page-aligned box is then the same box). Flipped layers count by their axis, not its direction.
+fn shared_rotation(doc: &Document, ids: &[NodeId]) -> Option<f64> {
+    use std::f64::consts::{FRAC_PI_2, PI};
+    const EPS: f64 = 1e-4;
+    let mut angles = ids.iter().map(|i| {
+        let c = doc.world_transform(*i).as_coeffs();
+        c[1].atan2(c[0])
+    });
+    let a = angles.next()?;
+    let same = |b: f64| {
+        let d = (b - a).rem_euclid(PI);
+        d.min(PI - d) < EPS
+    };
+    let axis_aligned = (a - (a / FRAC_PI_2).round() * FRAC_PI_2).abs() < EPS;
+    (a.is_finite() && !axis_aligned && angles.all(same)).then_some(a)
+}
+
+/// Whether layer `id` is locked or inside a locked layer: it can be selected in the layers panel
+/// but not moved or resized on the canvas.
+pub fn locked_in(doc: &Document, id: NodeId) -> bool {
+    std::iter::once(id).chain(doc.ancestors(id)).any(|a| doc.node(a).is_some_and(|n| n.locked))
+}
+
+/// Whether layer `t` paints below layer `s`: it holds `s`, or it is behind `s` in the stack of the
+/// nearest layer holding both.
+pub(super) fn paints_below(doc: &Document, t: NodeId, s: NodeId) -> bool {
+    let chain = |id: NodeId| {
+        let mut c: Vec<NodeId> = std::iter::once(id).chain(doc.ancestors(id)).collect();
+        c.reverse();
+        c
+    };
+    let (ct, cs) = (chain(t), chain(s));
+    let shared = ct.iter().zip(&cs).take_while(|(a, b)| a == b).count();
+    match (ct.get(shared), cs.get(shared)) {
+        (None, Some(_)) => true,
+        (Some(a), Some(b)) => shared.checked_sub(1).and_then(|i| ct.get(i)).and_then(|p| doc.node(*p)).is_some_and(|p| {
+            let order: Vec<NodeId> = p.paint_order().collect();
+            order.iter().position(|c| c == a) < order.iter().position(|c| c == b)
+        }),
+        _ => false,
+    }
+}
+
+/// Which handle (if any) is under `p`. A selection with a locked layer has none.
+pub fn handle_at(doc: &Document, sel: &[NodeId], p: Point, zoom: f64) -> Option<Handle> {
+    if sel.is_empty() || sel.iter().any(|i| locked_in(doc, *i)) {
+        return None;
+    }
+    // A connector's handles are its ends (see `board::end_handle_at`): no box to resize or turn.
+    if crate::board::selected_connector_ends(doc, sel).is_some() {
+        return None;
+    }
+    let corners = selection_box(doc, sel)?;
+    // Lines (zero height) only get end handles.
+    let is_line = sel.len() == 1 && sel.first().and_then(|i| doc.node(*i)).is_some_and(|n| matches!(n.kind, NodeKind::Line));
+    handle_at_corners(&corners, p, zoom, is_line)
+}
+
+/// Half the side of the square the canvas draws on each corner of the handle box (screen pixels,
+/// upright whatever the box's rotation).
+const CORNER_SQUARE_PX: f64 = 4.0;
+
+/// Whether `p` is on a corner square of the selection's handle box as drawn: there the corner
+/// resizes, although a corner-radius handle 10 px in reaches that far too.
+pub(super) fn on_corner_square(doc: &Document, sel: &[NodeId], p: Point, zoom: f64) -> bool {
+    let reach = CORNER_SQUARE_PX / zoom.max(1e-6);
+    matches!(handle_at(doc, sel, p, zoom), Some(Handle::Corner(_)))
+        && selection_box(doc, sel).is_some_and(|c| c.iter().any(|c| (c.x - p.x).abs() <= reach && (c.y - p.y).abs() <= reach))
+}
+
+/// A box whose sides are both shorter than this on screen (pixels) would be covered by its
+/// handles: the canvas draws just its outline (the handles still answer just outside it).
+pub const SMALL_BOX_PX: f64 = 16.0;
+
+/// The stroke the Pencil draws: its colour and weight (the canvas previews it the same).
+pub const PENCIL_STROKE: (figcraft_color::Color, f64) = (figcraft_color::Color::BLACK, 2.0);
+
+/// The shorter and longer sides, in screen pixels, of the box with `corners` (tl, tr, br, bl).
+pub fn box_sides_px(corners: &[Point; 4], zoom: f64) -> (f64, f64) {
+    let [a, b, _, d] = corners;
+    let (w, h) = ((*b - *a).hypot() * zoom, (*d - *a).hypot() * zoom);
+    (w.min(h), w.max(h))
+}
+
+/// Which handle of the box with `corners` (tl, tr, br, bl in page coordinates) is under `p`;
+/// `is_line` keeps only the two end handles.
+pub fn handle_at_corners(corners: &[Point; 4], p: Point, zoom: f64, is_line: bool) -> Option<Handle> {
+    let tol = HANDLE_PX / zoom.max(1e-6);
+    // Inside the box, handles reach in at most a quarter of its shorter side, so that a press in
+    // the middle of a small layer moves it; outside it they reach as far as ever.
+    let inner = if !is_line && in_quad(corners, p) { box_sides_px(corners, zoom).0 / 4.0 / zoom.max(1e-6) } else { f64::INFINITY };
+    let (corner_reach, edge_reach) = ((tol * 1.6).min(inner), tol.min(inner));
+    // The nearest corner, then the nearest edge, in reach (a small box's reaches overlap).
+    let nearest = |hits: &mut dyn Iterator<Item = (f64, Handle)>| hits.min_by(|a, b| a.0.total_cmp(&b.0)).map(|(_, h)| h);
+    let corner = nearest(
+        &mut corners
+            .iter()
+            .enumerate()
+            .filter(|(i, _)| !(is_line && *i >= 2))
+            .map(|(i, c)| ((*c - p).hypot(), Handle::Corner(i as u8)))
+            .filter(|(d, _)| *d <= corner_reach),
+    );
+    if corner.is_some() {
+        return corner;
+    }
+    if !is_line {
+        use figcraft_geom::kurbo::ParamCurveNearest;
+        let edge = nearest(&mut (0..4).filter_map(|i| {
+            let (a, b) = (corners.get(i)?, corners.get((i + 1) % 4)?);
+            let near = figcraft_geom::kurbo::Line::new(*a, *b).nearest(p, 0.001);
+            let d = near.distance_sq.sqrt();
+            (d <= edge_reach && near.t > 0.05 && near.t < 0.95).then_some((d, Handle::Edge(i as u8)))
+        }));
+        if edge.is_some() {
+            return edge;
+        }
+    }
+    // Rotation zones: just outside each corner.
+    let center = Point::new(corners.iter().map(|c| c.x).sum::<f64>() / 4.0, corners.iter().map(|c| c.y).sum::<f64>() / 4.0);
+    let rot = ROTATE_PX / zoom.max(1e-6);
+    for (i, c) in corners.iter().enumerate() {
+        let d = (*c - p).hypot();
+        let outward = (p - *c).dot(*c - center) > 0.0;
+        if d <= rot && d > tol && outward {
+            return Some(Handle::Rotate(i as u8));
+        }
+    }
+    None
+}
+
+pub(super) fn resize_cursor(doc: &Document, sel: &[NodeId], h: Handle) -> Cursor {
+    selection_box(doc, sel).map_or(Cursor::Default, |c| handle_cursor(&c, h))
+}
+
+/// The cursor over handle `h` of the box with corners `c`.
+pub(crate) fn handle_cursor(c: &[Point; 4], h: Handle) -> Cursor {
+    let angle = |a: Point, b: Point| (b - a).atan2().to_degrees();
+    match h {
+        Handle::Corner(i) => {
+            let a = c.get(i as usize).copied().unwrap_or_default();
+            let b = c.get((i as usize + 2) % 4).copied().unwrap_or_default();
+            // Along the box's own axes at 45°, not the diagonal, so wide or tall boxes still get a
+            // diagonal cursor. A box with no width or height falls back to the diagonal.
+            let unit = |v: figcraft_geom::kurbo::Vec2| {
+                let len = v.hypot();
+                (len.is_finite() && len > 1e-9).then(|| v / len)
+            };
+            let next = c.get((i as usize + 1) % 4).copied().unwrap_or_default();
+            let prev = c.get((i as usize + 3) % 4).copied().unwrap_or_default();
+            match (unit(next - a), unit(prev - a)) {
+                (Some(u), Some(v)) => Cursor::Resize((u + v).atan2().to_degrees()),
+                _ => Cursor::Resize(angle(a, b)),
+            }
+        }
+        Handle::Edge(i) => {
+            let a = c.get(i as usize).copied().unwrap_or_default();
+            let b = c.get((i as usize + 1) % 4).copied().unwrap_or_default();
+            Cursor::Resize(angle(a, b) + 90.0)
+        }
+        Handle::Rotate(i) => {
+            let centre = Point::new(c.iter().map(|p| p.x).sum::<f64>() / 4.0, c.iter().map(|p| p.y).sum::<f64>() / 4.0);
+            Cursor::Rotate(angle(centre, c.get(i as usize).copied().unwrap_or_default()))
+        }
+    }
+}
+
+/// The box (x0, y0, x1, y1) a `w0`×`h0` handle box becomes when `handle` is dragged to `q`, all in
+/// the box's own axes: `keep` constrains proportions, `from_center` resizes about the centre (the
+/// opposite side mirrors the dragged one). Edges that cross over come back reversed (x1 < x0 or
+/// y1 < y0: a flip).
+pub(crate) fn resized_box(handle: Handle, q: Point, w0: f64, h0: f64, keep: bool, from_center: bool) -> (f64, f64, f64, f64) {
+    let (mut x0, mut y0, mut x1, mut y1) = (0.0, 0.0, w0, h0);
+    // The dragged sides: x0 or x1 (`Some(false)` / `Some(true)`), y0 or y1.
+    let (sx, sy) = match handle {
+        Handle::Corner(0) => (Some(false), Some(false)),
+        Handle::Corner(1) => (Some(true), Some(false)),
+        Handle::Corner(2) => (Some(true), Some(true)),
+        Handle::Corner(_) => (Some(false), Some(true)),
+        Handle::Edge(0) => (None, Some(false)),
+        Handle::Edge(1) => (Some(true), None),
+        Handle::Edge(2) => (None, Some(true)),
+        Handle::Edge(_) => (Some(false), None),
+        Handle::Rotate(_) => (None, None),
+    };
+    match sx {
+        Some(false) => (x0, x1) = (q.x, if from_center { w0 - q.x } else { w0 }),
+        Some(true) => (x0, x1) = (if from_center { w0 - q.x } else { 0.0 }, q.x),
+        None => {}
+    }
+    match sy {
+        Some(false) => (y0, y1) = (q.y, if from_center { h0 - q.y } else { h0 }),
+        Some(true) => (y0, y1) = (if from_center { h0 - q.y } else { 0.0 }, q.y),
+        None => {}
+    }
+    if keep && w0 > 1e-9 && h0 > 1e-9 && !matches!(handle, Handle::Rotate(_)) {
+        // One factor for both axes: the dragged axis's (a corner: the one that moved the most),
+        // about the point that stays put (the opposite handle, or the centre).
+        let (kx, ky) = ((x1 - x0) / w0, (y1 - y0) / h0);
+        let k = match (sx, sy) {
+            (None, _) => ky,
+            (_, None) => kx,
+            _ if kx.abs() > ky.abs() => kx,
+            _ => ky,
+        };
+        let pivot = if from_center { Point::new(w0 / 2.0, h0 / 2.0) } else { handle_point(opposite(handle), w0, h0) };
+        (x0, x1) = (pivot.x * (1.0 - k), pivot.x + (w0 - pivot.x) * k);
+        (y0, y1) = (pivot.y * (1.0 - k), pivot.y + (h0 - pivot.y) * k);
+    }
+    (x0, y0, x1, y1)
+}
+
+/// A handle's point in its box's axes (`w0`×`h0`): a corner or an edge's middle.
+fn handle_point(h: Handle, w0: f64, h0: f64) -> Point {
+    match h {
+        Handle::Corner(0) | Handle::Rotate(0) => Point::new(0.0, 0.0),
+        Handle::Corner(1) | Handle::Rotate(1) => Point::new(w0, 0.0),
+        Handle::Corner(2) | Handle::Rotate(2) => Point::new(w0, h0),
+        Handle::Corner(_) | Handle::Rotate(_) => Point::new(0.0, h0),
+        Handle::Edge(0) => Point::new(w0 / 2.0, 0.0),
+        Handle::Edge(1) => Point::new(w0, h0 / 2.0),
+        Handle::Edge(2) => Point::new(w0 / 2.0, h0),
+        Handle::Edge(_) => Point::new(0.0, h0 / 2.0),
+    }
+}
+
+/// Anchor `(column, row)` of a `w`×`h` box, in its axes.
+fn anchor_in_box(anchor: (u8, u8), w: f64, h: f64) -> Point {
+    Point::new(w * f64::from(anchor.0.min(2)) / 2.0, h * f64::from(anchor.1.min(2)) / 2.0)
+}
+
+/// The Scale tool's anchor point on the selection's handle box, in page coordinates.
+pub fn scale_anchor_point(doc: &Document, sel: &[NodeId], anchor: (u8, u8)) -> Option<Point> {
+    let (f, w, h) = selection_frame(doc, sel)?;
+    Some(f * anchor_in_box(anchor, w, h))
+}
+
+/// The handle across the box from `h`.
+fn opposite(h: Handle) -> Handle {
+    match h {
+        Handle::Corner(i) => Handle::Corner((i + 2) % 4),
+        Handle::Edge(i) => Handle::Edge((i + 2) % 4),
+        Handle::Rotate(i) => Handle::Rotate((i + 2) % 4),
+    }
+}
+
+/// The Scale tool's factor and pivot (in the box's axes) for dragging `handle` of a `w0`×`h0` box
+/// to `q`. The pivot is the anchor point (`anchor`: column, row), or the opposite handle when the
+/// anchor lies on the side being dragged, or the centre (`from_center`). Corners follow the axis
+/// that moved the most; a negative factor flips. None when the box has no size to scale by.
+pub(crate) fn scale_factor(handle: Handle, q: Point, w0: f64, h0: f64, anchor: (u8, u8), from_center: bool) -> Option<(f64, Point)> {
+    const EPS: f64 = 1e-9;
+    if !(q.x.is_finite() && q.y.is_finite() && w0.is_finite() && h0.is_finite()) || matches!(handle, Handle::Rotate(_)) {
+        return None;
+    }
+    let h = handle_point(handle, w0, h0);
+    let anchor_pt = anchor_in_box(anchor, w0, h0);
+    // The axes the handle moves along.
+    let (ax_x, ax_y) = match handle {
+        Handle::Edge(0) | Handle::Edge(2) => (false, true),
+        Handle::Edge(_) => (true, false),
+        _ => (true, true),
+    };
+    let on_side = (ax_x && (anchor_pt.x - h.x).abs() < EPS) || (ax_y && (anchor_pt.y - h.y).abs() < EPS);
+    let pivot = if from_center {
+        Point::new(w0 / 2.0, h0 / 2.0)
+    } else if on_side {
+        handle_point(opposite(handle), w0, h0)
+    } else {
+        anchor_pt
+    };
+    let ratio = |on: bool, to: f64, from: f64, p: f64| (on && (from - p).abs() > EPS).then(|| (to - p) / (from - p));
+    let kx = ratio(ax_x, q.x, h.x, pivot.x);
+    let ky = ratio(ax_y, q.y, h.y, pivot.y);
+    let k = match (kx, ky) {
+        (Some(a), Some(b)) => {
+            if a.abs() > b.abs() {
+                a
+            } else {
+                b
+            }
+        }
+        (Some(a), None) | (None, Some(a)) => a,
+        (None, None) => return None,
+    };
+    if !k.is_finite() {
+        return None;
+    }
+    // Never collapse to nothing (or blow up past a usable size); 0 counts as positive.
+    Some((k.signum() * k.abs().clamp(0.01, 1000.0), pivot))
+}
+
+/// The readout of a shape handle drag on `id`.
+pub(super) fn shape_hint(doc: &Document, id: NodeId, handle: ShapeHandle, zoom: f64) -> Option<ShapeHint> {
+    Some(ShapeHint { handle, value: crate::shape_handles::value(doc, id, handle)?, at: crate::shape_handles::handle_at(doc, id, handle, zoom)? })
+}
+
+#[allow(dead_code)]
+fn unused(_: BTreeMap<u8, u8>) {}
+
+/// An end point of a selected open vector within `tol` of page point `p`: (layer, point).
+pub(super) fn selected_end_at(doc: &Document, sel: &[NodeId], p: Point, tol: f64) -> Option<(NodeId, usize)> {
+    sel.iter().find_map(|id| {
+        let net = crate::vectoredit::network(doc, *id)?;
+        let w = doc.world_transform(*id);
+        let near = |v: &usize| net.vertices.get(*v).is_some_and(|x| (w * x.point() - p).hypot() <= tol);
+        (0..net.vertices.len()).filter(near).find(|v| net.incident(*v).len() == 1).map(|v| (*id, v))
+    })
+}
diff --git a/crates/engine/src/canvas/tools/keys.rs b/crates/engine/src/canvas/tools/keys.rs
new file mode 100644
index 00000000..591f1479
--- /dev/null
+++ b/crates/engine/src/canvas/tools/keys.rs
@@ -0,0 +1,174 @@
+use super::*;
+
+impl Session {
+    /// Keys the current mode handles before menu shortcuts (vector edit mode's tools and point
+    /// keys, Enter to finish the shape builder). Returns whether the key was used.
+    pub fn tool_key(&mut self, name: &str, shift: bool, alt: bool, cmd: bool) -> Result<bool> {
+        // Dev Mode edits nothing: keys go to the commands (which it refuses in the app).
+        if self.tool.dev_mode {
+            return Ok(false);
+        }
+        if self.ds().is_ok_and(|d| d.vector_edit.is_some()) {
+            return crate::vectoredit::key(self, name, shift, alt, cmd);
+        }
+        if !alt && !cmd && self.guide_key(name, shift)? {
+            return Ok(true);
+        }
+        crate::shapebuilder::key(self, name)
+    }
+
+    /// Keys for a selected ruler guide: Delete removes it, arrows across it nudge it (Shift: the big
+    /// nudge), Escape deselects it.
+    fn guide_key(&mut self, name: &str, shift: bool) -> Result<bool> {
+        let Some((owner, index)) = self.ds()?.selected_guide() else { return Ok(false) };
+        // Backspace is Delete, `Left` is `ArrowLeft`, and so on.
+        let name = crate::keymap::normalize(name).map_or(name, |(k, _)| k);
+        let page = self.page()?;
+        let at = |mut p: serde_json::Value| {
+            if owner != page {
+                p["frame"] = json!(owner);
+            }
+            p
+        };
+        let Some(g) = self.doc()?.node(owner).and_then(|n| n.guides().get(index).cloned()) else { return Ok(false) };
+        let step = if shift { self.prefs.nudge_big } else { self.prefs.nudge_small };
+        let d = match (name, g.vertical) {
+            ("Delete", _) => {
+                self.execute("guide.remove", &at(json!({"index": index})))?;
+                return Ok(true);
+            }
+            ("Escape", _) => {
+                self.execute("guide.select", &json!({}))?;
+                return Ok(true);
+            }
+            ("ArrowLeft", true) | ("ArrowUp", false) => -step,
+            ("ArrowRight", true) | ("ArrowDown", false) => step,
+            _ => return Ok(false),
+        };
+        self.execute("guide.move", &at(json!({"index": index, "offset": g.offset + d})))?;
+        Ok(true)
+    }
+
+    /// The layer under `p` for a click: the topmost on `page`, or in the focus view the focused
+    /// frame's. Boolean groups are hit by their results ([`crate::booleans::result_outline`]); in
+    /// outline mode shapes only on their outlines.
+    pub fn hit(&self, doc: &Document, page: NodeId, p: Point, tol: f64) -> Option<NodeId> {
+        let sel = self.selection();
+        let result = crate::booleans::result_outline(doc, &sel);
+        let focus = self.ds().ok().and_then(crate::DocState::focused);
+        // Outline mode draws no fills: shapes are clicked on their outlines, reaching what's behind.
+        if let Some(v) = self.ds().ok().map(|d| &d.view).filter(|v| v.outlines) {
+            // What it draws besides the shapes can be clicked too.
+            let also = figcraft_doc::geometry::OutlineHits { hidden: v.outline_hidden, bounds: v.outline_bounds };
+            return figcraft_doc::geometry::hit_outlines(doc, focus.unwrap_or(page), p, tol, Some(&result), also);
+        }
+        match focus {
+            Some(f) => figcraft_doc::geometry::hit_in(doc, f, p, tol, Some(&result)),
+            None => doc.hit_test(page, p, tol, Some(&result)),
+        }
+    }
+
+    /// Enter with a shape or frame tool (`tool.place`): what a click with it makes, centred on `at`
+    /// (default the middle of the view) and selected.
+    pub fn place(&mut self, at: Option<Point>) -> Result<()> {
+        let tool = self.tool.tool;
+        let refuse = |why: &str| Err(crate::EngineError::Disabled("tool.place".into(), why.into()));
+        if !tool.draws_shape() {
+            return refuse("choose a shape or frame tool first");
+        }
+        if self.tool.busy() {
+            return refuse("finish the drag first");
+        }
+        let v = &self.ds()?.view;
+        let (c, zoom) = (at.unwrap_or(Point::new(v.cx, v.cy)), v.zoom);
+        let (w, h) = tool.click_size();
+        let ev = |kind| PointerEvent::at(kind, c.x - w / 2.0, c.y - h / 2.0, zoom);
+        let r = self.pointer(&ev(PointerKind::Down)).and_then(|()| self.pointer(&ev(PointerKind::Up)));
+        if r.is_err() {
+            self.tool.gesture = Gesture::None;
+            let _ = self.cancel_interaction();
+        }
+        r
+    }
+
+    /// Keyboard Escape: cancel gestures, finish pens, leave text editing, then deselect (in the
+    /// focus view, once the focused frame or nothing is selected, it ends the focus view).
+    pub fn escape(&mut self) -> Result<()> {
+        // Following someone in a live session: Escape stops that first.
+        if self.live_unfollow() {
+            return Ok(());
+        }
+        if self.tool.pen.is_some() {
+            return self.pen_end();
+        }
+        if self.tool.busy() {
+            self.tool.gesture = Gesture::None;
+            self.tool.overlay = Overlay::default();
+            return self.cancel_interaction();
+        }
+        if self.end_origin_edit() {
+            return Ok(());
+        }
+        if self.ds()?.text_edit.is_some() {
+            return textedit::end(self);
+        }
+        if self.ds()?.vector_edit.is_some() {
+            return crate::vectoredit::escape(self);
+        }
+        if self.tool.tool != ToolId::Move {
+            self.set_tool(ToolId::Move);
+            return Ok(());
+        }
+        let sel = self.selection();
+        if let Some(f) = self.ds()?.focused()
+            && (sel.is_empty() || sel == [f])
+        {
+            self.ds_mut()?.focus = None;
+            return Ok(());
+        }
+        // Escape selects the parent, then nothing.
+        let doc = self.doc()?;
+        let parents: Vec<NodeId> =
+            sel.iter().filter_map(|i| doc.node(*i).and_then(|n| n.parent)).filter(|p| !doc.node(*p).is_some_and(Node::is_page)).collect();
+        if !parents.is_empty() {
+            let mut uniq = Vec::new();
+            for p in parents {
+                if !uniq.contains(&p) {
+                    uniq.push(p);
+                }
+            }
+            self.set_selection(uniq);
+        } else {
+            self.set_selection(vec![]);
+        }
+        Ok(())
+    }
+
+    /// Whether the Move tool shows arc and shape handles now (not while another gesture runs, nor
+    /// in vector or text edit mode).
+    pub(super) fn arc_handles_shown(&self) -> bool {
+        let arc_drag = matches!(self.tool.gesture, Gesture::Arc { .. } | Gesture::Shape { .. });
+        self.tool.tool == ToolId::Move
+            && !self.tool.dev_mode
+            && (arc_drag || !self.tool.busy())
+            && self.ds().is_ok_and(|ds| ds.vector_edit.is_none() && ds.text_edit.is_none())
+    }
+
+    /// The selected ellipse's arc handles as the canvas shows them at the current zoom.
+    pub fn arc_handles(&self) -> Option<crate::arc_handles::ArcHandles> {
+        let ds = self.ds().ok()?;
+        self.arc_handles_shown().then(|| crate::arc_handles::handles(&ds.doc, &ds.selection, ds.view.zoom)).flatten()
+    }
+
+    /// The selected shape's corner radius and star ratio handles as the canvas shows them now.
+    pub fn shape_handles(&self) -> Vec<(ShapeHandle, [f64; 2])> {
+        let Ok(ds) = self.ds() else { return vec![] };
+        if self.arc_handles_shown() { crate::shape_handles::handles(&ds.doc, &ds.selection, ds.view.zoom) } else { vec![] }
+    }
+
+    /// Snapshot of tool state for the UI / inspect.
+    pub fn tool_info(&self) -> serde_json::Value {
+        let shapes: Vec<serde_json::Value> = self.shape_handles().into_iter().map(|(h, at)| json!({"handle": h, "at": at})).collect();
+        json!({"tool": self.tool.tool.id(), "busy": self.tool.busy(), "overlay": self.tool.overlay, "arcHandles": self.arc_handles(), "shapeHandles": shapes})
+    }
+}
diff --git a/crates/engine/src/canvas/tools/pen.rs b/crates/engine/src/canvas/tools/pen.rs
new file mode 100644
index 00000000..319c11b7
--- /dev/null
+++ b/crates/engine/src/canvas/tools/pen.rs
@@ -0,0 +1,276 @@
+use super::handles::{PENCIL_STROKE, selected_end_at};
+use super::*;
+
+/// Pen pressure along drawn samples as width profile points `[t, scale]`: `t` by length, at most
+/// 32 points, medium pressure (0.5) at the stroke weight, from a tenth to twice it. `None` when no
+/// sample has pressure.
+pub(crate) fn pressure_profile(points: &[Point], pressure: &[Option<f32>]) -> Option<Vec<[f64; 2]>> {
+    if pressure.iter().all(Option::is_none) {
+        return None;
+    }
+    let mut lengths = vec![0.0];
+    for w in points.windows(2) {
+        let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
+        lengths.push(lengths.last().copied().unwrap_or(0.0) + (*b - *a).hypot());
+    }
+    let total = lengths.last().copied().unwrap_or(0.0);
+    if !(total.is_finite() && total > 0.0) {
+        return None;
+    }
+    let at = |i: usize| f64::from(pressure.get(i).copied().flatten().filter(|p| p.is_finite()).unwrap_or(0.5).clamp(0.0, 1.0));
+    let n = points.len().clamp(2, 32);
+    let profile = (0..n).map(|k| {
+        let t = k as f64 / (n - 1) as f64;
+        let s = t * total;
+        let i = lengths.partition_point(|l| *l < s).min(lengths.len().saturating_sub(1));
+        let p = match (i.checked_sub(1).and_then(|j| lengths.get(j)), lengths.get(i)) {
+            (Some(a), Some(b)) if b > a => at(i - 1) + (at(i) - at(i - 1)) * ((s - a) / (b - a)),
+            _ => at(i),
+        };
+        [t, (p / 0.5).clamp(0.1, 2.0)]
+    });
+    Some(profile.collect())
+}
+
+/// A frame or section drawn around layers takes those of its siblings that lie fully inside it
+/// (visible and unlocked ones, in their order; a frame never takes a section). Not in auto layout,
+/// where the new frame is one more item of the flow.
+pub(super) fn take_enclosed(doc: &mut Document, drawn: NodeId) -> Result<()> {
+    let Some(n) = doc.node(drawn) else { return Ok(()) };
+    let section = matches!(n.kind, NodeKind::Section { .. });
+    let (Some(parent), Some(area)) = (n.parent.and_then(|p| doc.node(p)), doc.world_bounds(drawn)) else { return Ok(()) };
+    if parent.layout.is_some() {
+        return Ok(());
+    }
+    let inside: Vec<NodeId> = parent
+        .children
+        .iter()
+        .copied()
+        .filter(|c| *c != drawn && doc.node(*c).is_some_and(|k| k.visible && !k.locked && (section || !matches!(k.kind, NodeKind::Section { .. }))))
+        .filter(|c| doc.world_bounds(*c).is_some_and(|b| area.contains(b.origin()) && area.contains(Point::new(b.x1, b.y1))))
+        .collect();
+    for c in inside {
+        doc.reparent(c, drawn, None)?;
+    }
+    Ok(())
+}
+
+impl Session {
+    /// The pen tool's snapped position for `ev`: its path's vector (or, before it has one, its first
+    /// point) counts among the targets.
+    pub(super) fn snap_pen_tool(&mut self, ev: &PointerEvent) -> Result<(Point, Vec<Guide>)> {
+        let (id, extra) = match &self.tool.pen {
+            Some(pen) if pen.id.is_some() => (pen.id, Vec::new()),
+            Some(pen) => (None, pen.points.iter().map(|(p, _, _)| *p).collect()),
+            None => (None, Vec::new()),
+        };
+        self.snap_pen(ev, id, &extra)
+    }
+
+    pub(super) fn pen_down(&mut self, ev: &PointerEvent) -> Result<()> {
+        self.tool.overlay.guides.clear();
+        // The segment being placed shows as itself while the press lasts.
+        self.tool.overlay.rubber = None;
+        self.tool.overlay.rubber_handle = None;
+        let p = if ev.shift { ev.p() } else { self.snap_pen_tool(ev)?.0 };
+        let (doc, page) = {
+            let ds = self.ds()?;
+            (ds.doc.clone(), ds.page)
+        };
+        // With an open path selected, a click on one of its end points continues it in edit mode.
+        if self.tool.pen.is_none()
+            && let Some((id, v)) = selected_end_at(&doc, &self.selection(), ev.p(), 8.0 / ev.zoom.max(1e-6))
+        {
+            return self.pen_edit(id, Some(v));
+        }
+        let pen = self.tool.pen.get_or_insert_with(PenPath::default);
+        // Clicking the first anchor closes the path.
+        if pen.points.len() > 2
+            && let Some((first, _, _)) = pen.points.first()
+            && (*first - p).hypot() * ev.zoom < 8.0
+        {
+            pen.closed = true;
+            self.pen_update()?;
+            return self.pen_finish();
+        }
+        // Clicking another of its own anchors (not the last) connects there and ends the path.
+        let near = |q: &Point| (*q - p).hypot() * ev.zoom < 8.0;
+        if let Some(k) = (1..pen.points.len().saturating_sub(1)).find(|k| pen.points.get(*k).is_some_and(|(q, _, _)| near(q))) {
+            pen.join = Some(k);
+            self.pen_update()?;
+            return self.pen_finish();
+        }
+        if pen.parent.is_none() {
+            pen.parent = Some(frame_at(&doc, page, p, &[]).unwrap_or(page));
+        }
+        let mut p = p;
+        if ev.shift
+            && let Some((last, _, _)) = pen.points.last()
+        {
+            p = at_45_degrees(*last, p);
+        }
+        pen.points.push((p, Vec2::ZERO, Vec2::ZERO));
+        self.tool.gesture = Gesture::PenDrag { anchor: p };
+        self.pen_update()
+    }
+
+    /// Rebuild the pen's vector node from its anchors.
+    pub(super) fn pen_update(&mut self) -> Result<()> {
+        let Some(pen) = self.tool.pen.clone() else { return Ok(()) };
+        self.tool.overlay.pen = pen.points.iter().map(|(p, _, _)| [p.x, p.y]).collect();
+        self.tool.overlay.pen_handles = pen_handles(&pen.points);
+        if pen.points.len() < 2 {
+            if let Ok(ds) = self.ds_mut() {
+                ds.revision += 1;
+            }
+            return Ok(());
+        }
+        let page = self.page()?;
+        let parent = pen.parent.unwrap_or(page);
+        if pen.id.is_none() {
+            self.begin_interaction("Pen")?;
+        }
+        let ds = self.ds_mut()?;
+        let doc = ds.doc_mut();
+        let pw = doc.world_transform(parent);
+        let inv = pw.inverse();
+        // Anchors and handles into the parent's space.
+        let pts: Vec<(Point, Point, Point)> = pen.points.iter().map(|(p, i, o)| (inv * *p, inv * (*p + *i), inv * (*p + *o))).collect();
+        let mut path = figcraft_geom::BezPath::new();
+        for (k, (p, _, _)) in pts.iter().enumerate() {
+            if k == 0 {
+                path.move_to(*p);
+            } else if let (Some(prev), Some(cur)) = (pts.get(k - 1), pts.get(k)) {
+                path.curve_to(prev.2, cur.1, *p);
+            }
+        }
+        if pen.closed
+            && let (Some(last), Some(first)) = (pts.last(), pts.first())
+        {
+            path.curve_to(last.2, first.1, first.0);
+            path.close_path();
+        }
+        use figcraft_geom::Shape;
+        let bb = path.bounding_box();
+        path.apply_affine(Affine::translate((-bb.x0, -bb.y0)));
+        let mut net = VectorNetwork::from_path(&path);
+        // Straight segments stay straight.
+        for s in &mut net.segments {
+            if (s.ta.0.abs() + s.ta.1.abs()) < 1e-9 && (s.tb.0.abs() + s.tb.1.abs()) < 1e-9 {
+                s.ta = (0.0, 0.0);
+                s.tb = (0.0, 0.0);
+            }
+        }
+        if !pen.closed {
+            net.regions.clear();
+        }
+        // Anchor k is vertex k of the open path.
+        if let (Some(k), Some((last, _, out))) = (pen.join, pts.last()) {
+            let from = pts.len() - 1;
+            crate::vectoredit::ops::connect(&mut net, from, k, (out.x - last.x, out.y - last.y), (0.0, 0.0));
+        }
+        let id = match pen.id {
+            Some(id) if doc.contains(id) => id,
+            _ => {
+                let id = doc.alloc_id();
+                let mut n = Node::new(id, NodeKind::Vector { network: VectorNetwork::default() }, "Vector", 0.0, 0.0);
+                n.fills.clear();
+                n.strokes = vec![figcraft_color::Paint::solid(figcraft_color::Color::BLACK)];
+                n.stroke.align = StrokeAlign::Center;
+                doc.insert(n, parent, None)?;
+                id
+            }
+        };
+        let n = doc.get_mut(id)?;
+        n.kind = NodeKind::Vector { network: net };
+        n.width = bb.width();
+        n.height = bb.height();
+        n.transform = Affine::translate((bb.x0, bb.y0));
+        if pen.closed && n.fills.is_empty() {
+            n.fills = vec![figcraft_color::Paint::solid(figcraft_color::Color::DEFAULT_SHAPE)];
+        }
+        ds.selection = vec![id];
+        ds.revision += 1;
+        if let Some(p) = self.tool.pen.as_mut() {
+            p.id = Some(id);
+        }
+        Ok(())
+    }
+
+    /// Edit `id` as a vector with the pen, going on from point `anchor` (or, without one, starting
+    /// a new path in the same layer at the next click).
+    fn pen_edit(&mut self, id: NodeId, anchor: Option<usize>) -> Result<()> {
+        self.set_tool(ToolId::Move);
+        crate::vectoredit::begin(self, id)?;
+        crate::vectoredit::set_tool(self, crate::vectoredit::VTool::Pen)?;
+        crate::vectoredit::set_state(self, |e| {
+            e.anchor = anchor;
+            e.vertices = anchor.into_iter().collect();
+        })
+    }
+
+    /// Enter/Escape while the pen draws: the path ends but its layer stays in edit mode with the
+    /// pen, so the next path joins the same vector (another Escape leaves edit mode).
+    pub fn pen_end(&mut self) -> Result<()> {
+        let id = self.tool.pen.as_ref().and_then(|p| p.id);
+        self.pen_finish()?;
+        match id {
+            Some(id) if self.doc()?.contains(id) => self.pen_edit(id, None),
+            _ => Ok(()),
+        }
+    }
+
+    /// Finish the pen path (and keep the pen tool: double-click, Delete, a tool switch).
+    pub fn pen_finish(&mut self) -> Result<()> {
+        let pen = self.tool.pen.take();
+        self.tool.overlay.pen.clear();
+        self.tool.overlay.pen_handles.clear();
+        self.tool.overlay.rubber = None;
+        self.tool.overlay.rubber_handle = None;
+        self.tool.gesture = Gesture::None;
+        if pen.as_ref().is_some_and(|p| p.id.is_some()) {
+            self.commit_interaction()?;
+        }
+        Ok(())
+    }
+
+    pub(super) fn pencil_finish(&mut self, points: &[Point], pressure: &[Option<f32>]) -> Result<()> {
+        if points.len() < 2 {
+            return Ok(());
+        }
+        // Smooth: fit a curve through the samples.
+        let mut poly = figcraft_geom::BezPath::new();
+        for (k, p) in points.iter().enumerate() {
+            if k == 0 {
+                poly.move_to(*p);
+            } else {
+                poly.line_to(*p);
+            }
+        }
+        let fitted = figcraft_geom::kurbo::simplify::simplify_bezpath(poly.iter(), 0.75, &Default::default());
+        let d = fitted.to_svg();
+        if matches!(self.tool.tool, ToolId::Marker | ToolId::Highlighter) {
+            return self.ink_finish(&d);
+        }
+        let page = self.page()?;
+        let parent = frame_at(self.doc()?, page, points.first().copied().unwrap_or_default(), &[]).unwrap_or(page);
+        let pw = self.doc()?.world_transform(parent);
+        let mut local = fitted.clone();
+        local.apply_affine(pw.inverse());
+        let _ = d;
+        let (color, weight) = PENCIL_STROKE;
+        let mut props = json!({"fills": [], "strokes": [color.to_css_hex()], "strokeWeight": weight, "strokeCap": "round", "strokeJoin": "round", "strokeAlign": "center"});
+        // Pen pressure becomes the stroke's width profile (brushes follow it too).
+        if let Some(points) = pressure_profile(points, pressure) {
+            props["widthProfile"] = json!(points);
+        }
+        if let Some(b) = &self.tool.pencil_brush {
+            props["brush"] = serde_json::to_value(b).unwrap_or_default();
+        }
+        self.execute(
+            "node.create",
+            &json!({"type": "vector", "path": local.to_svg(), "closed": false, "parent": parent, "name": "Vector", "props": props}),
+        )?;
+        Ok(())
+    }
+}
diff --git a/crates/engine/src/canvas/tools/pointer.rs b/crates/engine/src/canvas/tools/pointer.rs
new file mode 100644
index 00000000..985e3326
--- /dev/null
+++ b/crates/engine/src/canvas/tools/pointer.rs
@@ -0,0 +1,292 @@
+use super::handles::{handle_at, label_at, locked_in, on_corner_square, resize_cursor, selected_end_at};
+use super::*;
+
+impl Session {
+    /// The pointer left the canvas: what hovering there showed goes (the distances Alt or Dev Mode
+    /// measured and the box measured to, a vector region's highlight), unless a gesture holds it.
+    pub fn pointer_left(&mut self) {
+        if !self.tool.busy() {
+            self.tool.overlay.guides.clear();
+            self.tool.overlay.measure_box = None;
+        }
+        self.vector_pointer_left();
+    }
+
+    /// What a marquee starting at page point `p` selects inside: the top-level frame it starts in
+    /// (its children), or the focus view's frame.
+    pub(crate) fn marquee_within(&self, p: Point) -> Result<Option<NodeId>> {
+        let (doc, page) = (self.doc()?, self.page()?);
+        let within = frame_at(doc, page, p, &[]).filter(|f| doc.node(*f).is_some_and(|n| n.parent == Some(page)));
+        let within = within.filter(|f| doc.world_bounds(*f).is_some_and(|b| b.contains(p)));
+        Ok(self.ds()?.focused().or(within))
+    }
+
+    /// The selection a marquee over page rect `r` makes from `base` (what was selected before):
+    /// the layers it touches (`deep`: nested ones too); `additive` (Shift) toggles them.
+    pub(crate) fn marquee_selection(&self, r: Rect, within: Option<NodeId>, deep: bool, base: &[NodeId], additive: bool) -> Result<Vec<NodeId>> {
+        let (doc, page) = (self.doc()?, self.page()?);
+        let mut hits =
+            if deep { figcraft_doc::geometry::marquee_deep(doc, page, r) } else { figcraft_doc::geometry::marquee_select(doc, page, r, within) };
+        if let Some(f) = self.ds()?.focused() {
+            hits.retain(|h| *h != f && doc.is_ancestor(f, *h));
+        }
+        // A marquee over a frame from outside selects the frame only when it covers it fully.
+        if within.is_none() && !deep {
+            hits.retain(|h| {
+                let full = doc.world_bounds(*h).is_some_and(|b| r.contains(b.origin()) && r.contains(Point::new(b.x1, b.y1)));
+                full || !doc.node(*h).is_some_and(|n| n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. }))
+            });
+        }
+        // Shift toggles: what was selected and is touched again comes out.
+        let mut sel: Vec<NodeId> = base.iter().copied().filter(|b| !(additive && hits.contains(b))).collect();
+        for h in hits {
+            if !base.contains(&h) && !sel.contains(&h) {
+                sel.push(h);
+            }
+        }
+        Ok(sel)
+    }
+
+    pub fn set_tool(&mut self, t: ToolId) {
+        if self.tool.tool == ToolId::Pen && t != ToolId::Pen {
+            let _ = self.pen_finish();
+        }
+        if !matches!(t, ToolId::Move | ToolId::Scale | ToolId::Hand) && self.ds().is_ok_and(|d| d.vector_edit.is_some()) {
+            let _ = crate::vectoredit::end(self);
+        }
+        self.tool.tool = t;
+        self.tool.gesture = Gesture::None;
+        self.tool.pick_only = false;
+        // The tool's cursor shows before the pointer moves.
+        self.tool.overlay =
+            Overlay { builder_remove: self.tool.builder_remove && t == ToolId::ShapeBuilder, cursor: t.cursor(), ..Overlay::default() };
+        self.tool.shape_builder = None;
+        if t == ToolId::ShapeBuilder {
+            // Regions show straight away, before the pointer moves.
+            let sel = self.selection();
+            let _ = crate::shapebuilder::arrangement(self, &sel);
+        }
+        if let Ok(ds) = self.ds_mut() {
+            if !matches!(t, ToolId::Text | ToolId::TextOnPath | ToolId::Move) {
+                ds.text_edit = None;
+            }
+            ds.revision += 1;
+        }
+    }
+
+    /// The tool pointer events go to: in Dev Mode every tool but the hand and comments selects.
+    fn acting_tool(&self) -> ToolId {
+        match self.tool.tool {
+            t if self.tool.dev_mode && !matches!(t, ToolId::Hand | ToolId::Comment) => ToolId::Move,
+            t => t,
+        }
+    }
+
+    /// Drop the gesture under way (a drag, a resize, a shape being drawn), restoring the document
+    /// as Escape does; the UI calls it when Dev Mode starts, where nothing may move.
+    pub fn drop_gesture(&mut self) -> Result<()> {
+        self.tool.gesture = Gesture::None;
+        self.cancel_interaction()
+    }
+
+    /// Feed one pointer event to the current tool.
+    pub fn pointer(&mut self, ev: &PointerEvent) -> Result<()> {
+        // A held button sends the same move every frame: running the gesture again would only
+        // rebuild the same preview (a new document, and a canvas render, every frame).
+        if ev.kind != PointerKind::Move {
+            self.tool.last_move = None;
+        } else if self.tool.busy() {
+            if self.tool.last_move.as_ref() == Some(ev) {
+                return Ok(());
+            }
+            self.tool.last_move = Some(ev.clone());
+        }
+        let tool = self.acting_tool();
+        let edits = matches!(tool, ToolId::Move | ToolId::Scale) && !self.tool.dev_mode;
+        if edits && self.origin_pointer(ev)? {
+            return Ok(());
+        }
+        if edits && self.ds().is_ok_and(|d| d.vector_edit.is_some()) && self.vector_pointer(ev)? {
+            return Ok(());
+        }
+        if tool == ToolId::ShapeBuilder {
+            return self.shape_builder_pointer(ev);
+        }
+        match ev.kind {
+            PointerKind::Hover => self.hover(ev),
+            PointerKind::Down => match tool {
+                ToolId::Move | ToolId::Scale => {
+                    // While a board's vote runs, a click on an object votes.
+                    if tool == ToolId::Move && !self.tool.dev_mode && self.vote_down(ev)? {
+                        return Ok(());
+                    }
+                    // A click on the canvas deselects a ruler guide (the UI selects guides itself).
+                    self.ds_mut()?.guide = None;
+                    self.move_down(ev)
+                }
+                ToolId::Hand => {
+                    let v = &self.ds()?.view;
+                    self.tool.gesture = Gesture::Pan { sx: ev.sx, sy: ev.sy, cx: v.cx, cy: v.cy };
+                    self.tool.overlay.cursor = Cursor::Grabbing;
+                    Ok(())
+                }
+                ToolId::Text => self.text_down(ev),
+                ToolId::TextOnPath => self.text_on_path_down(ev),
+                ToolId::Pen => self.pen_down(ev),
+                ToolId::Pencil => {
+                    self.tool.gesture = Gesture::Pencil { points: vec![ev.p()], pressure: vec![ev.pressure] };
+                    Ok(())
+                }
+                ToolId::Comment => {
+                    self.request_ui("comment.new", json!({"x": ev.x, "y": ev.y}));
+                    Ok(())
+                }
+                ToolId::Eyedropper => self.eyedrop(ev),
+                t if t.on_boards() => self.board_down(ev),
+                t if t.draws_shape() => self.draw_down(ev),
+                _ => Ok(()),
+            },
+            PointerKind::Move => self.drag(ev),
+            PointerKind::Up => self.up(ev),
+            PointerKind::DoubleClick => self.double_click(ev),
+        }
+    }
+
+    /// The rotation origin handle while it shows: a press drags it, a double-click puts it back
+    /// at the centre. True when the event was the handle's.
+    fn origin_pointer(&mut self, ev: &PointerEvent) -> Result<bool> {
+        let dragging = matches!(self.tool.gesture, Gesture::Origin);
+        if !dragging && !self.ds()?.on_origin_handle(ev.p(), ev.zoom) {
+            return Ok(false);
+        }
+        match ev.kind {
+            PointerKind::Down if !dragging => self.tool.gesture = Gesture::Origin,
+            PointerKind::Move if dragging => self.drag_origin_to(ev.p(), ev.zoom)?,
+            PointerKind::Up if dragging => self.tool.gesture = Gesture::None,
+            PointerKind::DoubleClick => self.set_rotation_origin(None)?,
+            PointerKind::Hover => {}
+            _ => return Ok(false),
+        }
+        self.tool.overlay.cursor = Cursor::Move;
+        Ok(true)
+    }
+
+    pub(super) fn hover(&mut self, ev: &PointerEvent) -> Result<()> {
+        let tool = self.acting_tool();
+        let ds = self.ds()?;
+        let (doc, sel, page) = (ds.doc.clone(), ds.selection.clone(), ds.page);
+        let mut cursor = tool.cursor();
+        // The text being edited, and with the Text tool any text, takes the I-beam: a click there
+        // puts the caret.
+        let on_edited = ds
+            .text_edit
+            .as_ref()
+            .is_some_and(|te| doc.world_bounds(te.id).is_some_and(|b| b.inflate(ev.tol() * 4.0, ev.tol() * 4.0).contains(ev.p())));
+        let on_text =
+            |s: &Self| s.hit(&doc, page, ev.p(), ev.tol() * 2.0).and_then(|l| doc.node(l)).is_some_and(|n| matches!(n.kind, NodeKind::Text(_)));
+        if tool == ToolId::Text && (on_edited || on_text(self)) {
+            cursor = Cursor::Text;
+        }
+        if tool == ToolId::TextOnPath && (on_edited || self.path_at(&doc, page, ev).is_some()) {
+            cursor = Cursor::Text;
+        }
+        let mut hover = None;
+        let mut guides = Vec::new();
+        let mut measure_box = None;
+        let arc_hover = if self.arc_handles_shown() { crate::arc_handles::hit(&doc, &sel, ev.p(), ev.zoom).map(|(_, h)| h) } else { None };
+        self.tool.overlay.arc_hover = arc_hover;
+        let shape_hover = if self.arc_handles_shown() && !on_corner_square(&doc, &sel, ev.p(), ev.zoom) {
+            crate::shape_handles::hit(&doc, &sel, ev.p(), ev.zoom).map(|(_, h)| h)
+        } else {
+            None
+        };
+        self.tool.overlay.shape_hover = shape_hover;
+        if matches!(tool, ToolId::Move | ToolId::Scale) && on_edited {
+            cursor = Cursor::Text;
+        } else if matches!(tool, ToolId::Move | ToolId::Scale) && arc_hover.is_none() && shape_hover.is_none() {
+            if let Some(h) = handle_at(&doc, &sel, ev.p(), ev.zoom).filter(|_| !self.tool.dev_mode) {
+                cursor = resize_cursor(&doc, &sel, h);
+            } else {
+                let leaf = self.hit(&doc, page, ev.p(), ev.tol() * 2.0);
+                if leaf.and_then(|l| crate::widgets::target_at(&doc, l, ev.p())).is_some() {
+                    cursor = Cursor::Pointer;
+                }
+                hover = label_at(&doc, page, &self.tool.labels, ev.p()).or_else(|| leaf.map(|leaf| select_target(&doc, leaf, &sel, ev.cmd)));
+                // Alt over a selected layer: a drag from here duplicates it.
+                if ev.alt && !self.tool.dev_mode && tool == ToolId::Move && hover.is_some_and(|h| sel.contains(&h) && !locked_in(&doc, h)) {
+                    cursor = Cursor::Copy;
+                }
+                if ev.alt || self.tool.dev_mode {
+                    use crate::distance::{Hover, guide_at, hover_lines, padding_frame, parent_of};
+                    // Shift+Alt over an auto layout frame: its padding and gaps. Otherwise from the
+                    // selection to a ruler guide, the hovered layer or (over empty canvas) the parent.
+                    let around: Vec<NodeId> = sel.iter().copied().chain(hover).collect();
+                    let what = hover.filter(|_| ev.alt && ev.shift).and_then(|t| padding_frame(&doc, t)).map(Hover::Padding).or_else(|| {
+                        if sel.is_empty() {
+                            return None;
+                        }
+                        let guide = guide_at(&doc, page, &around, ev.p(), ev.tol() * 4.0).map(|(vertical, at)| Hover::Guide { vertical, at });
+                        guide.or_else(|| hover.or_else(|| parent_of(&doc, page, &sel)).map(Hover::Layer))
+                    });
+                    if let Some(what) = what {
+                        let (g, b) = hover_lines(&doc, page, &sel, what);
+                        guides = g;
+                        measure_box = b.map(|b| [b.x0, b.y0, b.x1, b.y1]);
+                    }
+                }
+            }
+        }
+        if tool == ToolId::Move && !self.tool.dev_mode && crate::board::end_handle_at(&doc, &sel, ev.p(), ev.zoom).is_some() {
+            cursor = Cursor::Grab;
+        }
+        self.tool.overlay.measure_box = measure_box;
+        self.tool.overlay.cursor = cursor;
+        if tool == ToolId::Pen {
+            // Where a click would land (snapped), with its guides.
+            let (to, g) = if ev.shift { (ev.p(), Vec::new()) } else { self.snap_pen_tool(ev)? };
+            guides = g;
+            self.tool.overlay.cursor = Cursor::Pen(self.pen_cursor(&doc, &sel, to, ev.zoom));
+            if let Some((last, _, out)) = self.tool.pen.as_ref().and_then(|pen| pen.points.last()) {
+                // With Shift the band ends where a click puts the point (#970).
+                let to = if ev.shift { at_45_degrees(*last, to) } else { to };
+                self.tool.overlay.rubber = Some([last.x, last.y, to.x, to.y]);
+                self.tool.overlay.rubber_handle = (out.hypot() > 0.0).then_some([last.x + out.x, last.y + out.y]);
+            }
+        }
+        self.tool.overlay.guides = guides;
+        let ds = self.ds_mut()?;
+        if ds.hover != hover {
+            ds.hover = hover;
+            ds.revision += 1;
+        }
+        Ok(())
+    }
+
+    /// What a click with the Pen tool at `p` (where it snaps) would do: close the path on its first
+    /// point, connect to another of its points, go on from a selected open path's end, or add a
+    /// new point (the same tests as [`Self::pen_down`]).
+    fn pen_cursor(&self, doc: &Document, sel: &[NodeId], p: Point, zoom: f64) -> PenCursor {
+        let near = |q: &Point| (*q - p).hypot() * zoom < 8.0;
+        let on_point = match &self.tool.pen {
+            None => selected_end_at(doc, sel, p, 8.0 / zoom.max(1e-6)).is_some(),
+            Some(pen) => {
+                let n = pen.points.len();
+                (n > 2 && pen.points.first().is_some_and(|(q, _, _)| near(q)))
+                    || (1..n.saturating_sub(1)).any(|k| pen.points.get(k).is_some_and(|(q, _, _)| near(q)))
+            }
+        };
+        if on_point { PenCursor::Close } else { PenCursor::New }
+    }
+
+    /// Whether what the gesture did to `ids` so far is an edit only a main component can make
+    /// (`moved`: their place among the layers counts too): it is undone when the gesture ends.
+    pub(super) fn refused(&self, ids: &[NodeId], moved: bool) -> bool {
+        let Ok(ds) = self.ds() else { return false };
+        ds.interaction.as_ref().is_some_and(|it| {
+            ids.iter().any(|m| {
+                (moved && !crate::components::move_allowed(&it.doc, &ds.doc, *m))
+                    || crate::components::refused_override(&it.doc, &ds.doc, *m).is_some()
+            })
+        })
+    }
+}

From 0bc49705bdd0ba17f4e60bdf5c3dc731ceb5cd4e Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:20:45 +0000
Subject: [PATCH 25/67] refactor(engine): split assets/components.rs into
 components/

---
 crates/engine/src/assets/components.rs        | 2078 +----------------
 crates/engine/src/assets/components/diff.rs   |  218 ++
 crates/engine/src/assets/components/guard.rs  |  135 ++
 .../engine/src/assets/components/instances.rs |  342 +++
 crates/engine/src/assets/components/patch.rs  |  528 +++++
 crates/engine/src/assets/components/rebase.rs |  249 ++
 crates/engine/src/assets/components/sync.rs   |  459 ++++
 .../engine/src/assets/components/variants.rs  |  147 ++
 8 files changed, 2099 insertions(+), 2057 deletions(-)
 create mode 100644 crates/engine/src/assets/components/diff.rs
 create mode 100644 crates/engine/src/assets/components/guard.rs
 create mode 100644 crates/engine/src/assets/components/instances.rs
 create mode 100644 crates/engine/src/assets/components/patch.rs
 create mode 100644 crates/engine/src/assets/components/rebase.rs
 create mode 100644 crates/engine/src/assets/components/sync.rs
 create mode 100644 crates/engine/src/assets/components/variants.rs

diff --git a/crates/engine/src/assets/components.rs b/crates/engine/src/assets/components.rs
index c85c6b8b..07389419 100644
--- a/crates/engine/src/assets/components.rs
+++ b/crates/engine/src/assets/components.rs
@@ -37,6 +37,27 @@ use figcraft_doc::*;
 use figcraft_geom::Affine;
 use serde_json::Value;
 
+mod diff;
+mod guard;
+mod instances;
+mod patch;
+mod rebase;
+mod sync;
+mod variants;
+
+pub use diff::{diff_groups, property_owners, set_boolean_default, variable_groups};
+pub use guard::{check_override_edit, check_structure_edit, refused_override, unlink_layers};
+pub(crate) use instances::copy_group;
+pub use instances::{PROP_BINDING, copy_in_file, create_instance, create_instance_at, sync_instance};
+pub use patch::sync_after_edit;
+#[cfg(test)]
+pub(crate) use patch::{FULL_REBUILD, PATCHED};
+#[cfg(test)]
+use rebase::RebaseSources;
+pub use rebase::rebase_instance;
+pub use sync::keep_text_overrides;
+pub use variants::{default_variant, exposed_copies, find_variant, mirror_issues, variant_conflicts, variant_name, variant_options, variant_props};
+
 /// Nesting limit for instances inside instances.
 const MAX_DEPTH: usize = 16;
 /// The override group (and `prop_refs` field) of slots.
@@ -273,2067 +294,10 @@ pub fn prop_default_value(d: &PropDef) -> Value {
     }
 }
 
-/// Create an instance of `component` under `parent` at `(x, y)` (parent space).
-pub fn create_instance(doc: &mut Document, component: NodeId, parent: NodeId, x: f64, y: f64) -> Result<NodeId, DocError> {
-    create_instance_at(doc, component, parent, x, y, None)
-}
-
-/// [`create_instance`] at child `index` of `parent` (None: on top).
-pub fn create_instance_at(doc: &mut Document, component: NodeId, parent: NodeId, x: f64, y: f64, index: Option<usize>) -> Result<NodeId, DocError> {
-    let comp = doc.get(component)?.clone();
-    if !matches!(comp.kind, NodeKind::Component { .. }) {
-        return Err(DocError::Invalid(format!("{component} is not a component")));
-    }
-    if doc.is_ancestor(component, parent) {
-        return Err(DocError::Invalid("an instance can't be placed inside its own main component".into()));
-    }
-    let id = doc.alloc_id();
-    let mut root = comp.clone();
-    root.id = id;
-    root.name = default_instance_name(doc, component);
-    root.kind = NodeKind::Instance { component, props: default_props(&comp) };
-    root.children.clear();
-    root.parent = None;
-    root.source = Some(component);
-    root.overrides.clear();
-    root.transform = Affine::translate((x, y));
-    root.prop_refs.clear();
-    root.annotations.clear();
-    root.code_links.clear();
-    // The main's dev resources show on its instances without being copied.
-    root.dev_resources.clear();
-    // Measurements belong to the layer they were placed on.
-    root.measurements.clear();
-    // The main's interactions play on its instances in prototypes; the instance's own start empty.
-    root.interactions.clear();
-    // So do the variable modes the main sets (see `Document::inherited_modes`).
-    root.var_modes.clear();
-    doc.insert(root, parent, index)?;
-    sync_instance(doc, id);
-    Ok(id)
-}
-
-/// Copy `id` within its own file under `parent` (at `index`), keeping its local transform. A file
-/// has one main per component, so a main component's copy is an instance of it; a variant copied
-/// into its set stays a new variant, and every other layer is deep-copied.
-pub fn copy_in_file(doc: &mut Document, id: NodeId, parent: NodeId, index: Option<usize>) -> Result<NodeId, DocError> {
-    let n = doc.get(id)?;
-    let in_set = doc.node(parent).is_some_and(|p| matches!(p.kind, NodeKind::ComponentSet { .. }));
-    if !matches!(n.kind, NodeKind::Component { .. }) || in_set {
-        return doc.duplicate_into(id, parent, index);
-    }
-    let transform = n.transform;
-    let instance = create_instance_at(doc, id, parent, 0.0, 0.0, index)?;
-    doc.get_mut(instance)?.transform = transform;
-    Ok(instance)
-}
-
-/// Which part of the carried overrides to apply.
-#[derive(Clone, Copy, PartialEq)]
-enum Carry {
-    /// Paint, text, visibility, … (everything but geometry).
-    Values,
-    /// Values plus size (instance roots: their size decides how children follow constraints).
-    Root,
-    /// Size and position (children, after constraints ran).
-    Geometry,
-}
-
-/// Copy the overridden property groups of `from` onto `to`.
-fn carry_overrides(from: &Node, to: &mut Node, what: Carry) {
-    for g in &from.overrides {
-        let geo = matches!(g.as_str(), "size" | "position");
-        match what {
-            Carry::Values if geo => continue,
-            Carry::Root if g == "position" => continue,
-            Carry::Geometry if !geo => continue,
-            _ => {}
-        }
-        copy_group(from, to, g);
-    }
-    if what != Carry::Geometry {
-        to.overrides = from.overrides.clone();
-    }
-}
-
-/// An instance switched from variant `was` to `new`: its resizing (sizing and min / max per axis)
-/// that is still `was`'s follows `new`; what the instance set itself stays in `own`.
-fn follow_variant_resizing(own: &mut ChildLayout, was: &ChildLayout, new: &ChildLayout) {
-    if own.sizing_h == was.sizing_h {
-        own.sizing_h = new.sizing_h;
-    }
-    if own.sizing_v == was.sizing_v {
-        own.sizing_v = new.sizing_v;
-    }
-    for (o, w, n) in [
-        (&mut own.min_w, was.min_w, new.min_w),
-        (&mut own.max_w, was.max_w, new.max_w),
-        (&mut own.min_h, was.min_h, new.min_h),
-        (&mut own.max_h, was.max_h, new.max_h),
-    ] {
-        if *o == w {
-            *o = n;
-        }
-    }
-}
-
-/// Copy the values of property group `g` of `from` onto `to`, with the variables bound to them.
-pub(crate) fn copy_group(from: &Node, to: &mut Node, g: &str) {
-    if from.bound.iter().chain(to.bound.iter()).any(|(k, _)| binding_group(k) == Some(g)) {
-        to.bound.retain(|k, _| binding_group(k) != Some(g));
-        to.bound.extend(bindings_of(from, g).map(|(k, v)| (k.clone(), v.clone())));
-    }
-    match g {
-        "fills" => {
-            to.fills = from.fills.clone();
-            to.styles.fill = from.styles.fill.clone();
-        }
-        "strokes" => {
-            to.strokes = from.strokes.clone();
-            to.stroke = from.stroke.clone();
-            to.styles.stroke = from.styles.stroke.clone();
-        }
-        "effects" => {
-            to.effects = from.effects.clone();
-            to.styles.effect = from.styles.effect.clone();
-        }
-        "opacity" => {
-            to.opacity = from.opacity;
-            to.blend = from.blend;
-        }
-        "visible" => to.visible = from.visible,
-        "name" => to.name = from.name.clone(),
-        "corners" => to.corners = from.corners,
-        "characters" => {
-            if let (NodeKind::Text(a), NodeKind::Text(b)) = (&from.kind, &mut to.kind) {
-                b.characters = a.characters.clone();
-                b.runs = a.runs.clone();
-                b.paragraphs = a.paragraphs.clone();
-            }
-        }
-        "textStyle" => {
-            if let (NodeKind::Text(a), NodeKind::Text(b)) = (&from.kind, &mut to.kind) {
-                b.style = a.style.clone();
-                b.runs = a.runs.clone();
-                b.auto_resize = a.auto_resize;
-                b.align_h = a.align_h;
-                b.align_v = a.align_v;
-                b.paragraph_spacing = a.paragraph_spacing;
-                b.paragraph_indent = a.paragraph_indent;
-                b.list = a.list;
-                b.paragraphs = a.paragraphs.clone();
-                b.list_spacing = a.list_spacing;
-                b.hanging_punctuation = a.hanging_punctuation;
-                b.hanging_list = a.hanging_list;
-                b.max_lines = a.max_lines;
-                b.features = a.features.clone();
-            }
-            to.styles.text = from.styles.text.clone();
-        }
-        "padding" | "gap" | "alignment" => {
-            if let (Some(a), Some(b)) = (&from.layout, &mut to.layout) {
-                match g {
-                    "padding" => b.padding = a.padding,
-                    "gap" => (b.gap, b.cross_gap) = (a.gap, a.cross_gap),
-                    _ => (b.main_align, b.cross_align, b.content_align) = (a.main_align, a.cross_align, a.content_align),
-                }
-            }
-        }
-        "grids" => {
-            to.grids = from.grids.clone();
-            to.styles.grid = from.styles.grid.clone();
-        }
-        "exports" => to.exports = from.exports.clone(),
-        "interactions" => to.interactions = from.interactions.clone(),
-        "size" => {
-            to.width = from.width;
-            to.height = from.height;
-            if let (NodeKind::Text(a), NodeKind::Text(b)) = (&from.kind, &mut to.kind) {
-                b.auto_resize = a.auto_resize;
-            }
-        }
-        "resizing" => {
-            let (a, b) = (&from.child_layout, &mut to.child_layout);
-            (b.sizing_h, b.sizing_v, b.min_w, b.max_w, b.min_h, b.max_h) = (a.sizing_h, a.sizing_v, a.min_w, a.max_w, a.min_h, a.max_h);
-        }
-        "position" => to.transform = from.transform,
-        "modes" => to.var_modes = from.var_modes.clone(),
-        "component" => {
-            if let (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) = (&from.kind, &mut to.kind) {
-                *b = *a;
-            }
-        }
-        "props" => {
-            if let (NodeKind::Instance { props: a, .. }, NodeKind::Instance { props: b, .. }) = (&from.kind, &mut to.kind) {
-                *b = a.clone();
-            }
-            carry_prop_bindings(from, to);
-        }
-        _ => {}
-    }
-}
-
-/// Layer name paths below `root` ("Frame/Label", with `#n` for same-named siblings). With
-/// `src_names` (an instance's layers), layers are named after the main layer they mirror (renames
-/// don't break matching), and the content of slots holding the instance's own is left out.
-fn path_map(doc: &Document, root: NodeId, src_names: bool) -> BTreeMap<NodeId, String> {
-    let mut out = BTreeMap::new();
-    let mut stack = vec![(root, String::new())];
-    while let Some((id, prefix)) = stack.pop() {
-        let Some(n) = doc.node(id) else { continue };
-        let mut seen: BTreeMap<&str, usize> = BTreeMap::new();
-        for c in &n.children {
-            let Some(cn) = doc.node(*c) else { continue };
-            // A nested instance linked only to its own component so far (an imported one) mirrors no
-            // layer yet: it goes by its own name, like the main's layer it will be matched with.
-            let unplaced = matches!(&cn.kind, NodeKind::Instance { component, .. } if cn.source == Some(*component));
-            let mirrored = cn.source.filter(|_| src_names && !unplaced).and_then(|s| doc.node(s));
-            let name = mirrored.map_or(cn.name.as_str(), |s| s.name.as_str());
-            let k = seen.entry(name).or_insert(0);
-            let seg = if *k == 0 { name.to_string() } else { format!("{name}#{k}") };
-            *k += 1;
-            let path = if prefix.is_empty() { seg } else { format!("{prefix}/{seg}") };
-            out.insert(*c, path.clone());
-            if out.len() > 1_000_000 {
-                return out;
-            }
-            if !(src_names && holds_content(cn)) {
-                stack.push((*c, path));
-            }
-        }
-    }
-    out
-}
-
-/// The binding key prefix of an instance's component property value
-/// (`componentProperties/<name>`): a boolean property takes a boolean variable, a text property a
-/// string variable.
-pub const PROP_BINDING: &str = "componentProperties/";
-
-/// Give `to` the component property bindings of instance `from` (they go with its property
-/// values, which an instance keeps across rebuilds).
-fn carry_prop_bindings(from: &Node, to: &mut Node) {
-    to.bound.retain(|k, _| !k.starts_with(PROP_BINDING));
-    to.bound.extend(from.bound.iter().filter(|(k, _)| k.starts_with(PROP_BINDING)).map(|(k, v)| (k.clone(), v.clone())));
-}
-
-/// The override group a property-bound field belongs to.
-fn field_group(field: &str) -> &'static str {
-    match field {
-        "visible" => "visible",
-        "characters" => "characters",
-        "mainComponent" => "component",
-        _ => "",
-    }
-}
-
-/// Apply one component-property value to a layer.
-fn apply_prop(doc: &Document, n: &mut Node, field: &str, val: &Value) {
-    match field {
-        "visible" => {
-            if let Some(b) = val.as_bool() {
-                n.visible = b;
-            }
-        }
-        "characters" => {
-            if let (NodeKind::Text(t), Some(sv)) = (&mut n.kind, val.as_str().map(crate::cmd::props::normalize_line_endings))
-                && t.characters != sv
-            {
-                let len = t.char_count();
-                t.replace_range(0, len, &sv);
-            }
-        }
-        "mainComponent" => {
-            if let (NodeKind::Instance { component: c, .. }, Some(v)) = (&mut n.kind, crate::params::id_of(val))
-                && doc.node(v).is_some_and(|m| matches!(m.kind, NodeKind::Component { .. }))
-            {
-                *c = v;
-            }
-        }
-        _ => {}
-    }
-}
-
-/// Rebuild instance `inst` from its main component, keeping ids, overrides and the content of its
-/// slots. An instance whose main component was deleted keeps its layers as they are.
-pub fn sync_instance(doc: &mut Document, inst: NodeId) {
-    // Layers the rebuild leaves as they were keep their shared snapshot (and aren't edits).
-    let old: Vec<(std::sync::Arc<Node>, bool)> =
-        doc.subtree(inst).into_iter().filter_map(|i| doc.node_arc(i).map(|a| (a.clone(), doc.dirty().contains(&i)))).collect();
-    let kept = slot_content(doc, inst);
-    sync_instance_depth(doc, inst, 0, BTreeMap::new());
-    restore_slot_content(doc, kept);
-    for (a, was_dirty) in old {
-        doc.keep_if_unchanged(a, was_dirty);
-    }
-}
-
-/// The slots in instance `inst` (nested instances included) holding the instance's own content:
-/// each with its content (the subtrees of its children, pre-order).
-fn slot_content(doc: &Document, inst: NodeId) -> Vec<(NodeId, Vec<Node>)> {
-    let mut out = Vec::new();
-    let mut stack: Vec<NodeId> = doc.node(inst).map(|n| n.children.clone()).unwrap_or_default();
-    while let Some(c) = stack.pop() {
-        let Some(n) = doc.node(c) else { continue };
-        if holds_content(n) {
-            let nodes = n.children.iter().flat_map(|k| doc.subtree(*k)).filter_map(|d| doc.node(d).cloned()).collect();
-            out.push((c, nodes));
-        } else {
-            stack.extend(n.children.iter().copied());
-        }
-    }
-    out
-}
-
-/// Put slot content back after a rebuild, into the slots that still hold the instance's own
-/// content (a slot the main no longer has, or no longer marks as a slot, loses it). Constraints
-/// and geometry overrides ran before, so the content keeps its place.
-fn restore_slot_content(doc: &mut Document, kept: Vec<(NodeId, Vec<Node>)>) {
-    for (slot, nodes) in kept {
-        let keep = slot_edited(doc, slot) && is_slot(doc, slot) && nodes.iter().all(|n| !doc.contains(n.id));
-        if !keep {
-            continue;
-        }
-        let ids: Vec<NodeId> = nodes.iter().map(|n| n.id).collect();
-        for n in nodes {
-            // Pre-order: every parent is back before its children.
-            let _ = insert_linked(doc, n);
-        }
-        // Never leave links to a layer that couldn't come back.
-        for id in ids.into_iter().chain([slot]) {
-            let dangling = doc.node(id).is_some_and(|n| n.children.iter().any(|c| !doc.contains(*c)));
-            if dangling {
-                let live: Vec<NodeId> = doc.node(id).map(|n| n.children.iter().copied().filter(|c| doc.contains(*c)).collect()).unwrap_or_default();
-                if let Some(n) = doc.node_mut(id) {
-                    n.children = live;
-                }
-            }
-        }
-    }
-}
-
-/// `spare`: layers the outer rebuild didn't reuse that were below `inst` (a swapped nested
-/// instance): its layers the outer main doesn't have, matched here so they keep ids and overrides.
-fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize, spare: BTreeMap<NodeId, std::sync::Arc<Node>>) {
-    if depth > MAX_DEPTH {
-        return;
-    }
-    let Some(mut root) = doc.node(inst).cloned() else { return };
-    let NodeKind::Instance { component, props: root_props } = &root.kind else { return };
-    let component = *component;
-    let Some(comp) = doc.node(component).cloned() else { return };
-    if !matches!(comp.kind, NodeKind::Component { .. }) || doc.is_ancestor(inst, component) || doc.is_ancestor(component, inst) {
-        // A missing main, or an instance inside its own main (would recurse forever).
-        return;
-    }
-    let mut eff_props = default_props(&comp);
-    for (k, v) in root_props {
-        if eff_props.contains_key(k) {
-            eff_props.insert(k.clone(), v.clone());
-        }
-    }
-    // Old layers (kept alive for their overrides), by (parent, source), by source alone (when only
-    // one layer mirrors it) and, only when those don't match, by name path.
-    let mut old_ids = old_layers(doc, inst);
-    old_ids.extend(spare.keys().copied());
-    old_ids.sort();
-    old_ids.dedup();
-    let mut old: BTreeMap<NodeId, std::sync::Arc<Node>> = spare;
-    let mut by_source: BTreeMap<(NodeId, NodeId), NodeId> = BTreeMap::new();
-    let mut by_src: BTreeMap<NodeId, Option<NodeId>> = BTreeMap::new();
-    for i in &old_ids {
-        let Some(n) = doc.node_arc(*i).or_else(|| old.get(i)).cloned() else { continue };
-        if let Some(s) = n.source {
-            if let Some(p) = n.parent {
-                by_source.entry((p, s)).or_insert(*i);
-            }
-            by_src.entry(s).and_modify(|e| *e = None).or_insert(Some(*i));
-        }
-        old.insert(*i, n);
-    }
-    let mut by_path: Option<BTreeMap<String, NodeId>> = None;
-    let mut main_paths: Option<BTreeMap<NodeId, String>> = None;
-    // Ids for the copies: reuse the matching old layer's id (a layer the main moved to another
-    // parent keeps its id and overrides).
-    let src: Vec<NodeId> = doc.subtree(component).into_iter().filter(|i| *i != component).collect();
-    let mut map: BTreeMap<NodeId, NodeId> = BTreeMap::new();
-    map.insert(component, inst);
-    let mut used: BTreeSet<NodeId> = BTreeSet::new();
-    // Slots holding the instance's own content (new ids), and main layers not copied: the
-    // default content of those slots.
-    let mut edited: BTreeSet<NodeId> = BTreeSet::new();
-    let mut skipped: BTreeSet<NodeId> = BTreeSet::new();
-    let mut fresh_ids = Vec::new();
-    for s in &src {
-        let Some(sn) = doc.node(*s) else { continue };
-        if sn.parent.is_some_and(|p| skipped.contains(&p) || map.get(&p).is_some_and(|pn| edited.contains(pn))) {
-            skipped.insert(*s);
-            continue;
-        }
-        let parent_new = sn.parent.and_then(|p| map.get(&p).copied());
-        let mut found = parent_new.and_then(|pn| by_source.get(&(pn, *s)).copied()).or_else(|| by_src.get(s).copied().flatten());
-        if found.is_none() {
-            let paths = by_path.get_or_insert_with(|| path_map(doc, inst, true).into_iter().map(|(k, v)| (v, k)).collect());
-            let mains = main_paths.get_or_insert_with(|| path_map(doc, component, false));
-            found = mains.get(s).and_then(|p| paths.get(p)).copied();
-        }
-        let nid = match found {
-            Some(o) if used.insert(o) => o,
-            _ => {
-                fresh_ids.push(*s);
-                continue;
-            }
-        };
-        if let Some(m) = old.get(&nid).and_then(|o| variant_kept(doc, o, *s)) {
-            old.insert(nid, std::sync::Arc::new(m));
-        }
-        if old.get(&nid).is_some_and(|o| holds_content(o)) && is_slot(doc, *s) {
-            edited.insert(nid);
-        }
-        map.insert(*s, nid);
-    }
-    for c in root.children.clone() {
-        let _ = doc.remove(c);
-    }
-    for s in fresh_ids {
-        let nid = doc.alloc_id();
-        map.insert(s, nid);
-    }
-    // Build the copies (pre-order: parents first).
-    let mut enclosing: BTreeMap<NodeId, Vec<NodeId>> = BTreeMap::new();
-    enclosing.insert(inst, vec![inst]);
-    let mut inst_props: BTreeMap<NodeId, BTreeMap<String, Value>> = BTreeMap::new();
-    inst_props.insert(inst, eff_props);
-    let mut nested = Vec::new();
-    let mut new_nodes = Vec::new();
-    // Text layers showing other text or style than their main layer (to re-measure).
-    let mut remeasure = Vec::new();
-    for s in &src {
-        let Some(orig) = doc.node(*s) else { continue };
-        let Some(&nid) = map.get(s) else { continue };
-        let Some(parent) = orig.parent.and_then(|p| map.get(&p).copied()) else { continue };
-        let mut n = orig.clone();
-        n.id = nid;
-        n.parent = Some(parent);
-        n.children = orig.children.iter().filter_map(|c| map.get(c).copied()).collect();
-        n.source = Some(*s);
-        n.overrides.clear();
-        n.prop_refs.clear();
-        let prev = old.get(&nid);
-        // Annotations belong to the layer they were added to, not to its copies.
-        n.annotations = prev.map(|o| o.annotations.clone()).unwrap_or_default();
-        n.measurements = prev.map(|o| o.measurements.clone()).unwrap_or_default();
-        if let Some(o) = prev {
-            carry_overrides(o, &mut n, Carry::Values);
-            keep_laid_out(doc, orig, o, &mut n);
-        }
-        if !edited.contains(&nid) {
-            // No longer a slot in the main: it mirrors the main again.
-            n.overrides.remove(SLOT);
-        }
-        // Component properties: the main layer's bindings use this instance's values; layers of
-        // nested instances use the nested instance's values (one level per source hop).
-        let enc = enclosing.get(&parent).cloned().unwrap_or_default();
-        let mut chain: Vec<&Node> = vec![orig];
-        while chain.len() < enc.len() {
-            let Some(next) = chain.last().and_then(|c| c.source).and_then(|x| doc.node(x)) else { break };
-            chain.push(next);
-        }
-        for (j, level) in chain.iter().enumerate().rev() {
-            let Some(props) = enc.get(j).and_then(|e| inst_props.get(e)) else { continue };
-            for (field, prop) in &level.prop_refs {
-                let g = field_group(field);
-                if n.overrides.contains(g) || (j > 0 && orig.overrides.contains(g)) {
-                    continue;
-                }
-                if let Some(val) = props.get(prop) {
-                    apply_prop(doc, &mut n, field, val);
-                }
-            }
-        }
-        if let NodeKind::Instance { component: c, props } = &n.kind {
-            inst_props.insert(nid, props.clone());
-            let mut e = enc;
-            e.push(nid);
-            enclosing.insert(nid, e);
-            if !matches!(orig.kind, NodeKind::Instance { component: oc, .. } if oc == *c) {
-                nested.push(nid);
-            }
-        } else {
-            enclosing.insert(nid, enc);
-        }
-        if let (NodeKind::Text(a), NodeKind::Text(b)) = (&orig.kind, &n.kind)
-            && a != b
-        {
-            remeasure.push(nid);
-        }
-        new_nodes.push(n);
-    }
-    for n in new_nodes {
-        let (id, parent) = (n.id, n.parent);
-        if insert_linked(doc, n).is_err()
-            && let Some(p) = parent.and_then(|p| doc.node_mut(p))
-        {
-            p.children.retain(|c| *c != id);
-        }
-    }
-    // Root: follows the main except its own placement, name, size and overrides.
-    let order: Vec<NodeId> = comp.children.iter().filter_map(|c| map.get(c).copied()).filter(|c| doc.contains(*c)).collect();
-    let mut fresh = comp.clone();
-    fresh.id = inst;
-    fresh.parent = root.parent;
-    fresh.children = order;
-    fresh.transform = root.transform;
-    fresh.kind = root.kind.clone();
-    carry_prop_bindings(&root, &mut fresh);
-    // A nested instance keeps mirroring its layer of the outer main.
-    let nested_copy = inside_instance(doc, inst);
-    fresh.source = if nested_copy { root.source } else { Some(component) };
-    fresh.constraints = root.constraints;
-    fresh.child_layout = root.child_layout.clone();
-    fresh.interactions = root.interactions.clone();
-    fresh.exports = root.exports.clone();
-    fresh.prop_refs = root.prop_refs.clone();
-    fresh.plugin_data = root.plugin_data.clone();
-    fresh.annotations = root.annotations.clone();
-    // Code links belong to the main component; instances read them from it.
-    fresh.code_links.clear();
-    // An instance's own dev resources (its main's are listed with them, not copied).
-    fresh.dev_resources = root.dev_resources.clone();
-    fresh.measurements = root.measurements.clone();
-    fresh.locked = root.locked;
-    fresh.visible = root.visible;
-    fresh.var_modes = root.var_modes.clone();
-    fresh.is_mask = root.is_mask;
-    fresh.exposed = root.exposed;
-    fresh.guides = root.guides.clone();
-    fresh.dev_status = root.dev_status;
-    fresh.dev_changed = root.dev_changed;
-    fresh.dev_note = root.dev_note.clone();
-    fresh.constrain_proportions = root.constrain_proportions;
-    // How the instance combines in a boolean group it sits in is its own.
-    fresh.bool_op = root.bool_op;
-    // A swapped nested instance keeps the name its layer was given in the outer main.
-    let renamed = nested_copy
-        && root.source.and_then(|s| doc.node(s)).is_some_and(|s| match &s.kind {
-            NodeKind::Instance { component: c, .. } => s.name != default_instance_name(doc, *c),
-            _ => false,
-        });
-    fresh.name = if renamed { root.name.clone() } else { default_instance_name(doc, component) };
-    // Switched to another variant: its own overrides stay where both variants agreed.
-    if let Some(prev) = root.source.and_then(|p| doc.node(p)).filter(|p| sibling_variants(doc, p.id, component)) {
-        let differs = diff_groups(prev, &comp);
-        root.overrides.retain(|g| g == "name" || !differs.contains(&g.as_str()));
-        follow_variant_resizing(&mut fresh.child_layout, &prev.child_layout, &comp.child_layout);
-    }
-    carry_overrides(&root, &mut fresh, Carry::Root);
-    if let Some(r) = doc.node_mut(inst) {
-        *r = fresh;
-    }
-    // A resized instance: children follow their constraints (auto layout re-flows later).
-    let (iw, ih) = doc.node(inst).map(|n| (n.width, n.height)).unwrap_or((comp.width, comp.height));
-    if (iw - comp.width).abs() > 1e-9 || (ih - comp.height).abs() > 1e-9 {
-        figcraft_layout::apply_constraints(doc, inst, comp.width, comp.height);
-        remeasure = map.values().copied().collect();
-    }
-    // Geometry overrides of children win over constraints.
-    for s in &src {
-        let Some(nid) = map.get(s).copied() else { continue };
-        let Some(o) = old.get(&nid) else { continue };
-        // A frame that kept the size its own resizing gave it: its layers (copied at their main
-        // layers' places) follow their constraints from its main layer's size.
-        if o.overrides.contains("resizing")
-            && !o.overrides.contains("size")
-            && doc.node(nid).is_some_and(|n| n.kind.is_frame_like() && n.layout.is_none())
-            && let Some((mw, mh)) = doc.node(*s).map(|m| (m.width, m.height))
-        {
-            figcraft_layout::apply_constraints(doc, nid, mw, mh);
-        }
-        if !o.overrides.contains("size") && !o.overrides.contains("position") {
-            continue;
-        }
-        remeasure.push(nid);
-        let Some((ow, oh)) = doc.node(nid).map(|n| (n.width, n.height)) else { continue };
-        if o.overrides.contains("size") {
-            // Through set_size so vector networks scale with the box.
-            figcraft_layout::set_size(doc, nid, o.width, o.height);
-            if doc.node(nid).is_some_and(|n| n.kind.is_frame_like() && n.layout.is_none()) {
-                figcraft_layout::apply_constraints(doc, nid, ow, oh);
-            }
-        }
-        if let Some(n) = doc.node_mut(nid) {
-            carry_overrides(o, n, Carry::Geometry);
-        }
-    }
-    // Text whose characters or style differ from the main re-measures.
-    for nid in remeasure {
-        if let Some(n) = doc.node(nid)
-            && let Some((w, h)) = figcraft_text::auto_size(n)
-            && ((w - n.width).abs() > 1e-6 || (h - n.height).abs() > 1e-6)
-        {
-            figcraft_layout::set_size(doc, nid, w, h);
-        }
-    }
-    // Nested instances showing another main than the main's copy (swapped): rebuild from it,
-    // with the old layers below them this rebuild didn't reuse.
-    let unused: BTreeMap<NodeId, std::sync::Arc<Node>> =
-        old.iter().filter(|(i, _)| !used.contains(*i) && !doc.contains(**i)).map(|(i, x)| (*i, x.clone())).collect();
-    for n in nested {
-        let mut below: BTreeMap<NodeId, std::sync::Arc<Node>> = unused
-            .iter()
-            .filter(|(_, x)| {
-                let mut cur = x.parent;
-                for _ in 0..=MAX_DEPTH * 4 {
-                    match cur {
-                        Some(p) if p == n => return true,
-                        Some(p) => cur = unused.get(&p).and_then(|a| a.parent),
-                        None => return false,
-                    }
-                }
-                false
-            })
-            .map(|(i, x)| (*i, x.clone()))
-            .collect();
-        take_placing_overrides(doc, n, &old, &mut below);
-        sync_instance_depth(doc, n, depth + 1, below);
-    }
-}
-
-/// Before swapped nested instance `n` is rebuilt from its new main: each of its old layers (the
-/// copies just made of the outer main's, and `below`) takes the overrides held along the source
-/// chain it had before this rebuild (`before`), through layers inside instances in the mains that
-/// place `n`. Matched by name, they carry onto the new main's layers as the instance's own, so a
-/// swap takes what the outer main set once: later rebuilds find layers mirroring the new main.
-/// Geometry and slot content follow the new main; groups the layer overrides itself keep its value.
-fn take_placing_overrides(
-    doc: &mut Document,
-    n: NodeId,
-    before: &BTreeMap<NodeId, std::sync::Arc<Node>>,
-    below: &mut BTreeMap<NodeId, std::sync::Arc<Node>>,
-) {
-    let placing = placing_mains(doc, n);
-    for id in doc.subtree(n).into_iter().filter(|i| *i != n) {
-        let held = before.get(&id).map(|b| held_along(doc, b, &placing)).unwrap_or_default();
-        if let Some(layer) = doc.node_mut(id) {
-            take(layer, &held);
-        }
-    }
-    for layer in below.values_mut() {
-        let held = held_along(doc, layer, &placing);
-        if !held.is_empty() {
-            take(std::sync::Arc::make_mut(layer), &held);
-        }
-    }
-}
-
-/// The mains placing nested instance `n`: those of the layers it mirrors, outward.
-fn placing_mains(doc: &Document, n: NodeId) -> BTreeSet<NodeId> {
-    let mut out = BTreeSet::new();
-    let mut cur = doc.node(n).and_then(|x| x.source);
-    for _ in 0..=MAX_DEPTH {
-        let Some(s) = cur.and_then(|c| doc.node(c)).filter(|s| !matches!(s.kind, NodeKind::Component { .. })) else { break };
-        out.extend(owning_component(doc, s.id));
-        cur = s.source;
-    }
-    out
-}
-
-/// The overrides but geometry and slot content held along `layer`'s source chain while it runs
-/// through layers inside instances in `placing` mains, each with the nearest layer holding it.
-fn held_along(doc: &Document, layer: &Node, placing: &BTreeSet<NodeId>) -> BTreeMap<String, std::sync::Arc<Node>> {
-    let mut out = BTreeMap::new();
-    let mut cur = layer.source;
-    for _ in 0..=MAX_DEPTH {
-        let Some(s) = cur.and_then(|c| doc.node_arc(c)) else { break };
-        if !inside_instance(doc, s.id) || !owning_component(doc, s.id).is_some_and(|m| placing.contains(&m)) {
-            break;
-        }
-        for g in s.overrides.iter().filter(|g| !matches!(g.as_str(), "size" | "position" | SLOT)) {
-            out.entry(g.clone()).or_insert_with(|| s.clone());
-        }
-        cur = s.source;
-    }
-    out
-}
-
-/// Give `layer` the `held` groups it has no override of its own for.
-fn take(layer: &mut Node, held: &BTreeMap<String, std::sync::Arc<Node>>) {
-    for (g, from) in held {
-        if layer.overrides.insert(g.clone()) {
-            copy_group(from, layer, g);
-        }
-    }
-}
-
-/// Whether main components `a` and `b` are two variants of one set.
-fn sibling_variants(doc: &Document, a: NodeId, b: NodeId) -> bool {
-    a != b && variant_set(doc, a).is_some_and(|s| variant_set(doc, b) == Some(s))
-}
-
-/// Old copy `o` matched by name to main layer `s` of another variant (the instance switched
-/// variants): `o` without the overrides of properties the two variants' layers differ in (`None`
-/// when it keeps them all). Text layers keep every override.
-fn variant_kept(doc: &Document, o: &Node, s: NodeId) -> Option<Node> {
-    let from = o.source.filter(|f| *f != s).and_then(|f| doc.node(f))?;
-    if o.overrides.is_empty() || matches!(o.kind, NodeKind::Text(_)) {
-        return None;
-    }
-    if !sibling_variants(doc, owning_component(doc, from.id)?, owning_component(doc, s)?) {
-        return None;
-    }
-    let differs = diff_groups(from, doc.node(s)?);
-    let mut m = o.clone();
-    m.overrides.retain(|g| !differs.contains(&g.as_str()));
-    (m.overrides.len() != o.overrides.len()).then_some(m)
-}
-
-/// Drop the overrides of instance `inst` but its text layers' (and its own size and the content of
-/// its slots): what swapping it from the Assets panel keeps.
-pub fn keep_text_overrides(doc: &mut Document, inst: NodeId) {
-    for d in old_layers(doc, inst).into_iter().chain([inst]) {
-        let Some(n) = doc.node(d) else { continue };
-        let text = matches!(n.kind, NodeKind::Text(_));
-        let keep = |g: &String| text || g == SLOT || (d == inst && g == "size");
-        if !n.overrides.iter().all(keep)
-            && let Some(m) = doc.node_mut(d)
-        {
-            m.overrides.retain(keep);
-        }
-    }
-}
-
-/// Where auto layout places and sizes a rebuilt copy `n` of main layer `orig`, keep the old
-/// copy's `o` values (an instance's auto layout re-flows from its own content, so they usually
-/// differ from the main's): unchanged layers then stay unchanged, and auto layout re-flows wherever
-/// something that sizes or places layers did change.
-fn keep_laid_out(doc: &Document, orig: &Node, o: &Node, n: &mut Node) {
-    if o.parent != n.parent || o.overrides.contains("size") || o.overrides.contains("position") {
-        return;
-    }
-    let flows = !n.child_layout.absolute && orig.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some());
-    if flows {
-        // The main's rotation and skew, the old place.
-        let [a, b, c, d, _, _] = n.transform.as_coeffs();
-        let [.., e, f] = o.transform.as_coeffs();
-        n.transform = Affine::new([a, b, c, d, e, f]);
-    }
-    // Only layers whose shape is their box (a vector's points scale with it).
-    let boxed = n.kind.is_frame_like() || matches!(n.kind, NodeKind::Text(_) | NodeKind::Rectangle | NodeKind::Ellipse { .. });
-    let derived = |s: Sizing| boxed && ((s == Sizing::Hug && n.layout.is_some()) || (s == Sizing::Fill && flows));
-    if derived(n.child_layout.sizing_h) {
-        n.width = o.width;
-    }
-    if derived(n.child_layout.sizing_v) {
-        n.height = o.height;
-    }
-}
-
-/// The layers of instance `inst` a rebuild matches against (every layer below it but the content
-/// of slots holding its own), ascending.
-fn old_layers(doc: &Document, inst: NodeId) -> Vec<NodeId> {
-    let mut out = Vec::new();
-    let mut stack = vec![inst];
-    while let Some(id) = stack.pop() {
-        let Some(n) = doc.node(id) else { continue };
-        for c in &n.children {
-            out.push(*c);
-            if out.len() > 1_000_000 {
-                break;
-            }
-            if doc.node(*c).is_some_and(|cn| !holds_content(cn)) {
-                stack.push(*c);
-            }
-        }
-    }
-    out.sort();
-    out.dedup();
-    out
-}
-
-/// Insert a node whose parent/children links are already set (used when rebuilding instances).
-fn insert_linked(doc: &mut Document, n: Node) -> Result<(), DocError> {
-    let parent = n.parent.ok_or_else(|| DocError::Invalid("no parent".into()))?;
-    let id = n.id;
-    let mut n = n;
-    let kids = std::mem::take(&mut n.children);
-    doc.insert(n, parent, None)?;
-    if let Some(m) = doc.node_mut(id) {
-        m.children = kids;
-    }
-    // The parent may already list us (its children were copied with ids): keep the first.
-    if let Some(p) = doc.node_mut(parent) {
-        let mut seen = BTreeSet::new();
-        p.children.retain(|c| seen.insert(*c));
-    }
-    Ok(())
-}
-
-/// The property groups whose value layer `n` takes from the same variables as its main layer
-/// `src` (they differ only where the two resolve in different variable modes).
-pub fn variable_groups(n: &Node, src: &Node) -> Vec<&'static str> {
-    let mut out = Vec::new();
-    for (k, v) in &n.bound {
-        let Some(g) = binding_group(k) else { continue };
-        if src.bound.get(k) == Some(v) && !out.contains(&g) {
-            out.push(g);
-        }
-    }
-    out
-}
-
-/// The override group a variable binding key feeds (`None` for component property and layout
-/// grid bindings, which follow other rules).
-fn binding_group(key: &str) -> Option<&'static str> {
-    use crate::cmd::lists::{BoundList, list_binding};
-    if key.starts_with(PROP_BINDING) {
-        return None;
-    }
-    match list_binding(key).map(|(l, _, _)| l) {
-        Some(BoundList::Fills) => Some("fills"),
-        Some(BoundList::Strokes) => Some("strokes"),
-        Some(BoundList::Effects) => Some("effects"),
-        Some(BoundList::Grids) => None,
-        None => Some(crate::cmd::props::override_group(key)).filter(|g| *g != "other"),
-    }
-}
-
-/// The variable bindings of `n` that feed group `g`.
-fn bindings_of<'a>(n: &'a Node, g: &'a str) -> impl Iterator<Item = (&'a String, &'a String)> + 'a {
-    n.bound.iter().filter(move |(k, _)| binding_group(k) == Some(g))
-}
-
-/// Property groups that differ between two versions of a node.
-pub fn diff_groups(a: &Node, b: &Node) -> Vec<&'static str> {
-    let mut out = Vec::new();
-    if a.fills != b.fills {
-        out.push("fills");
-    }
-    if a.strokes != b.strokes || a.stroke != b.stroke {
-        out.push("strokes");
-    }
-    if a.effects != b.effects {
-        out.push("effects");
-    }
-    if a.opacity != b.opacity || a.blend != b.blend {
-        out.push("opacity");
-    }
-    if a.visible != b.visible {
-        out.push("visible");
-    }
-    if a.name != b.name {
-        out.push("name");
-    }
-    if a.corners != b.corners {
-        out.push("corners");
-    }
-    if (a.width - b.width).abs() > 1e-6 || (a.height - b.height).abs() > 1e-6 {
-        out.push("size");
-    }
-    if resizing(a) != resizing(b) {
-        out.push("resizing");
-    }
-    if a.transform != b.transform {
-        out.push("position");
-    }
-    if let (NodeKind::Text(x), NodeKind::Text(y)) = (&a.kind, &b.kind) {
-        if x.characters != y.characters {
-            out.push("characters");
-        }
-        if text_style_differs(x, y) {
-            out.push("textStyle");
-        }
-    }
-    if let (Some(x), Some(y)) = (&a.layout, &b.layout) {
-        if x.padding != y.padding {
-            out.push("padding");
-        }
-        if x.gap != y.gap || x.cross_gap != y.cross_gap {
-            out.push("gap");
-        }
-        if x.main_align != y.main_align || x.cross_align != y.cross_align || x.content_align != y.content_align {
-            out.push("alignment");
-        }
-    }
-    if a.grids != b.grids || a.styles.grid != b.styles.grid {
-        out.push("grids");
-    }
-    if a.exports != b.exports {
-        out.push("exports");
-    }
-    if a.interactions != b.interactions {
-        out.push("interactions");
-    }
-    if a.var_modes != b.var_modes {
-        out.push("modes");
-    }
-    if let (NodeKind::Instance { component: x, props: px }, NodeKind::Instance { component: y, props: py }) = (&a.kind, &b.kind) {
-        if x != y {
-            out.push("component");
-        }
-        if px != py {
-            out.push("props");
-        }
-    }
-    out
-}
-
-/// The `resizing` group of a layer: how it sizes on each axis, and its min and max sizes.
-fn resizing(n: &Node) -> (Sizing, Sizing, [Option<f64>; 4]) {
-    let c = &n.child_layout;
-    (c.sizing_h, c.sizing_v, [c.min_w, c.max_w, c.min_h, c.max_h])
-}
-
-/// Whether two texts differ in anything but their characters (the `textStyle` group).
-fn text_style_differs(x: &TextData, y: &TextData) -> bool {
-    x.style != y.style
-        || x.runs != y.runs
-        || x.auto_resize != y.auto_resize
-        || x.align_h != y.align_h
-        || x.align_v != y.align_v
-        || x.paragraph_spacing != y.paragraph_spacing
-        || x.paragraph_indent != y.paragraph_indent
-        || x.list != y.list
-        || x.paragraphs != y.paragraphs
-        || x.list_spacing != y.list_spacing
-        || x.hanging_punctuation != y.hanging_punctuation
-        || x.hanging_list != y.hanging_list
-        || x.max_lines != y.max_lines
-        || x.features != y.features
-}
-
-/// Whether a geometry change of `id` comes from layout rather than the user: an ancestor was
-/// resized in the same edit (constraints), the parent is an auto layout frame, or auto-sized text.
-fn geometry_derived(doc: &Document, before: &Document, id: NodeId, group: &str) -> bool {
-    for a in doc.ancestors(id) {
-        let (Some(x), Some(y)) = (doc.node(a), before.node(a)) else { continue };
-        if (x.width - y.width).abs() > 1e-6 || (x.height - y.height).abs() > 1e-6 {
-            return true;
-        }
-    }
-    let Some(n) = doc.node(id) else { return true };
-    if group == "position" && n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some()) && !n.child_layout.absolute {
-        return true;
-    }
-    if group == "size"
-        && let NodeKind::Text(t) = &n.kind
-    {
-        let wchanged = before.node(id).is_some_and(|b| (b.width - n.width).abs() > 1e-6);
-        return match t.auto_resize {
-            TextAutoResize::WidthAndHeight => true,
-            TextAutoResize::Height => !wchanged,
-            _ => false,
-        };
-    }
-    false
-}
-
-/// The components sharing the properties of component `c`: the variants of its set, or `c` alone.
-pub fn property_owners(doc: &Document, c: NodeId) -> Vec<NodeId> {
-    match variant_set(doc, c).and_then(|s| doc.node(s)) {
-        Some(set) => set.children.iter().copied().filter(|v| doc.node(*v).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. }))).collect(),
-        None => vec![c],
-    }
-}
-
-/// Make `value` the default of boolean property `name` on components `comps`, showing or hiding
-/// their layers bound to it: on a main component, a boolean property's value is the visibility of
-/// its layers. Returns the components and layers it changed.
-pub fn set_boolean_default(doc: &mut Document, comps: &[NodeId], name: &str, value: bool) -> Vec<NodeId> {
-    let mut out = Vec::new();
-    for &c in comps {
-        let Some(NodeKind::Component { props, .. }) = doc.node(c).map(|n| &n.kind) else { continue };
-        let Some(PropDef::Boolean { default }) = props.get(name) else { continue };
-        if *default != value
-            && let Some(NodeKind::Component { props, .. }) = doc.node_mut(c).map(|n| &mut n.kind)
-        {
-            props.insert(name.to_string(), PropDef::Boolean { default: value });
-            out.push(c);
-        }
-        // The main's own layers (not those of instances nested in it, which follow their mains).
-        let layers: Vec<NodeId> = doc
-            .subtree(c)
-            .into_iter()
-            .filter(|d| *d != c && !inside_instance(doc, *d))
-            .filter(|d| doc.node(*d).is_some_and(|n| n.visible != value && n.prop_refs.get("visible").map(String::as_str) == Some(name)))
-            .collect();
-        for d in layers {
-            if let Some(n) = doc.node_mut(d) {
-                n.visible = value;
-                out.push(d);
-            }
-        }
-    }
-    out
-}
-
-/// A main component's layer bound to a boolean property was shown or hidden: that is the
-/// property's new default, which its other bound layers (in every variant) take too. Returns the
-/// components and layers that changed as a result.
-fn follow_boolean_defaults(doc: &mut Document, before: &Document, changed: &[NodeId]) -> Vec<NodeId> {
-    let mut out = Vec::new();
-    for &id in changed {
-        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
-        if n.visible == b.visible || inside_instance(doc, id) {
-            continue;
-        }
-        let Some(name) = n.prop_refs.get("visible").cloned() else { continue };
-        let visible = n.visible;
-        let Some(c) = owning_component(doc, id).filter(|c| *c != id) else { continue };
-        out.extend(set_boolean_default(doc, &property_owners(doc, c), &name, visible));
-    }
-    out
-}
-
-/// After an edit: record overrides inside instances, then rebuild instances whose main changed,
-/// whose properties or main were switched, or whose overrides were reset.
-pub fn sync_after_edit(doc: &mut Document, before: &Document, changed: &[NodeId], touched: &BTreeSet<NodeId>) {
-    let mut changed = changed.to_vec();
-    for id in follow_boolean_defaults(doc, before, &changed) {
-        if !changed.contains(&id) {
-            changed.push(id);
-        }
-    }
-    let changed = changed.as_slice();
-    // 0. A slot whose layers were added, removed or reordered holds the instance's own content
-    //    from now on; copies of instance layers placed elsewhere stop mirroring their main.
-    for &id in changed {
-        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
-        if n.children == b.children || owning_instance(doc, id).is_none() {
-            continue;
-        }
-        if let Some(slot) = slot_scope(doc, id)
-            && !slot_edited(doc, slot)
-        {
-            own_slot_content(doc, slot);
-        }
-    }
-    for &id in changed {
-        if !before.contains(id) {
-            relink_copy(doc, id);
-        }
-    }
-    let mut resync: BTreeSet<NodeId> = BTreeSet::new();
-    // 1. Overrides for layers edited inside instances.
-    for &id in changed {
-        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
-        let Some(inst) = owning_instance(doc, id) else { continue };
-        let top_root = inst == id && !inside_instance(doc, id);
-        if top_root
-            && let (NodeKind::Instance { component: c1, props: p1 }, NodeKind::Instance { component: c2, props: p2 }) = (&n.kind, &b.kind)
-            && (c1 != c2 || p1 != p2)
-        {
-            // Switching the main or a property value of an instance isn't an override.
-            resync.insert(id);
-        }
-        let raw = diff_groups(b, n);
-        let mut groups = raw.clone();
-        // An instance's own place, resizing, export settings, interactions and variable modes are
-        // its own, not overrides.
-        if top_root {
-            groups.retain(|g| !matches!(*g, "component" | "props" | "position" | "resizing" | "exports" | "interactions" | "modes"));
-        }
-        if groups.iter().any(|g| matches!(*g, "size" | "position")) {
-            groups.retain(|g| !matches!(*g, "size" | "position") || !geometry_derived(doc, before, id, g));
-        }
-        // A value equal to the main's isn't an override (setting it back clears the override).
-        let mut cleared = Vec::new();
-        if let Some(src) = n.source.and_then(|s| doc.node(s)) {
-            let mut differs = diff_groups(src, n);
-            if inst == id {
-                differs.retain(|g| *g != "name");
-                if n.name != default_instance_name(doc, src.id) {
-                    differs.push("name");
-                }
-            }
-            // A value from the same variable as the main's (resolved in this layer's modes) isn't an
-            // override either.
-            let from_variables = variable_groups(n, src);
-            groups.retain(|g| differs.contains(g) && !from_variables.contains(g));
-            // Binding another variable (or none) where the main binds one is an override.
-            for (k, _) in b.bound.iter().chain(n.bound.iter()) {
-                let Some(g) = binding_group(k) else { continue };
-                let rebound = b.bound.get(k) != n.bound.get(k) && !bindings_of(n, g).eq(bindings_of(src, g));
-                if rebound && !groups.contains(&g) {
-                    groups.push(g);
-                }
-            }
-            cleared =
-                raw.iter().filter(|g| !matches!(**g, "size" | "position") && !differs.contains(g) && n.overrides.contains(**g)).copied().collect();
-            if top_root {
-                cleared.retain(|g| !matches!(*g, "component" | "props"));
-            }
-        }
-        let lost = b.overrides.iter().any(|g| !n.overrides.contains(g));
-        let nested_switch = !top_root && raw.iter().any(|g| matches!(*g, "component" | "props"));
-        if (!groups.is_empty() || !cleared.is_empty())
-            && let Some(m) = doc.node_mut(id)
-        {
-            for g in groups {
-                m.overrides.insert(g.to_string());
-            }
-            for g in cleared {
-                m.overrides.remove(g);
-            }
-        }
-        if (lost || nested_switch)
-            && let Some(r) = root_instance(doc, id)
-        {
-            resync.insert(r);
-        }
-    }
-    // 2. Components whose layers changed, were added or removed. Value-only edits (paint, text,
-    //    visibility, …) are carried to the copies directly; anything else rebuilds the instances.
-    let mut comps: BTreeSet<NodeId> = BTreeSet::new();
-    let mut patches: Vec<(NodeId, Vec<&'static str>)> = Vec::new();
-    // Main layers that only gained new layers or lost some: their copies take the same change.
-    let mut restructured: Vec<NodeId> = Vec::new();
-    let mut covered: BTreeSet<NodeId> = BTreeSet::new();
-    for &id in changed {
-        if let (Some(b), Some(n)) = (before.node(id), doc.node(id))
-            && b.children != n.children
-            && owning_instance(doc, id).is_none()
-            && owning_component(doc, id).is_some()
-            && let Some(layers) = restructurable(doc, before, b, n)
-        {
-            restructured.push(id);
-            covered.extend(layers);
-        }
-    }
-    for &id in changed {
-        if covered.contains(&id) || restructured.contains(&id) {
-            continue;
-        }
-        let Some(c) = owning_component(doc, id) else { continue };
-        let (Some(b), Some(n)) = (before.node(id), doc.node(id)) else {
-            comps.insert(c);
-            continue;
-        };
-        if b == n {
-            continue;
-        }
-        match patchable(doc, b, n) {
-            Some(groups) => patches.push((id, groups)),
-            None => {
-                comps.insert(c);
-            }
-        }
-    }
-    for &id in touched {
-        if !doc.contains(id)
-            && !covered.contains(&id)
-            && let Some(c) = owning_component(before, id)
-            && doc.contains(c)
-        {
-            comps.insert(c);
-        }
-    }
-    for r in resync {
-        if doc.contains(r) {
-            sync_instance(doc, r);
-            if let Some(c) = owning_component(doc, r) {
-                comps.insert(c);
-            }
-        }
-    }
-    // A copy the patch can't follow exactly rebuilds instead (as does any other change).
-    let patched = comps.is_empty()
-        && !full_rebuild()
-        && (restructured.is_empty() || patch_structure(doc, before, &restructured))
-        && (patches.is_empty() || patch_copies(doc, &patches));
-    #[cfg(test)]
-    if patched && (!restructured.is_empty() || !patches.is_empty()) {
-        PATCHED.with(|c| c.set(c.get() + 1));
-    }
-    if !patched {
-        comps.extend(patches.iter().map(|(id, _)| *id).chain(restructured.iter().copied()).filter_map(|id| owning_component(doc, id)));
-    }
-    // 3. Instances of changed components follow; an instance inside another component makes that
-    //    one change too.
-    rebuild_instances(doc, &comps);
-}
-
-#[cfg(test)]
-thread_local! {
-    /// Tests: rebuild instances even for edits that could be patched (to compare both ways).
-    pub(crate) static FULL_REBUILD: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
-    /// Tests: edits carried to the copies without rebuilding instances.
-    pub(crate) static PATCHED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
-}
-
-#[cfg(test)]
-fn full_rebuild() -> bool {
-    FULL_REBUILD.with(std::cell::Cell::get)
-}
-
-#[cfg(not(test))]
-fn full_rebuild() -> bool {
-    false
-}
-
-/// The property groups of a main-component layer edited from `b` to `n` when the edit changed
-/// values only (paint, text, visibility, size, position, …) that copies take as they are: carried to them without
-/// rebuilding the instances ([`patch_copies`]). `None` when anything else changed.
-fn patchable(doc: &Document, b: &Node, n: &Node) -> Option<Vec<&'static str>> {
-    const VALUES: [&str; 17] = [
-        "fills",
-        "strokes",
-        "effects",
-        "opacity",
-        "visible",
-        "name",
-        "corners",
-        "characters",
-        "textStyle",
-        "padding",
-        "gap",
-        "alignment",
-        "grids",
-        "exports",
-        "interactions",
-        "size",
-        "position",
-    ];
-    if b.children != n.children || b.parent != n.parent || b.kind.type_name() != n.kind.type_name() {
-        return None;
-    }
-    let groups = diff_groups(b, n);
-    if groups.is_empty() || groups.iter().any(|g| !VALUES.contains(g)) {
-        return None;
-    }
-    // Exactly those groups (and the layer's own overrides) changed.
-    let mut probe = n.clone();
-    for g in &groups {
-        copy_group(b, &mut probe, g);
-    }
-    probe.overrides = b.overrides.clone();
-    if probe != *b {
-        return None;
-    }
-    // Values a component property sets (on this layer or a main it mirrors) come from instances.
-    let mut cur = Some(n);
-    for _ in 0..=MAX_DEPTH {
-        let Some(x) = cur else { break };
-        if x.prop_refs.keys().any(|f| groups.contains(&field_group(f))) {
-            return None;
-        }
-        cur = x.source.and_then(|s| doc.node(s));
-    }
-    Some(groups)
-}
-
-/// Copies by the layer they mirror; nested instances swapped to a main also follow it.
-fn copies_index(doc: &Document) -> BTreeMap<NodeId, Vec<NodeId>> {
-    let mut copies: BTreeMap<NodeId, Vec<NodeId>> = BTreeMap::new();
-    for n in doc.nodes() {
-        let Some(s) = n.source else { continue };
-        copies.entry(s).or_default().push(n.id);
-        if let (NodeKind::Instance { component, .. }, Some(NodeKind::Instance { component: other, .. })) = (&n.kind, doc.node(s).map(|x| &x.kind))
-            && component != other
-        {
-            copies.entry(*component).or_default().push(n.id);
-        }
-    }
-    copies
-}
-
-/// When main layer `b` → `n` only gained new plain layers (created in this edit: no instances,
-/// components or property bindings in them) or lost layers that were deleted: those layers, which
-/// [`patch_structure`] carries to the copies. `None` for anything else.
-fn restructurable(doc: &Document, before: &Document, b: &Node, n: &Node) -> Option<Vec<NodeId>> {
-    let mut probe = n.clone();
-    probe.children = b.children.clone();
-    probe.overrides = b.overrides.clone();
-    if probe != *b {
-        return None;
-    }
-    let mut layers = Vec::new();
-    for c in n.children.iter().filter(|c| !b.children.contains(c)) {
-        for d in doc.subtree(*c) {
-            let x = doc.node(d)?;
-            let plain = !matches!(x.kind, NodeKind::Instance { .. } | NodeKind::Component { .. } | NodeKind::ComponentSet { .. });
-            if before.contains(d) || !plain || !x.prop_refs.is_empty() {
-                return None;
-            }
-            layers.push(d);
-        }
-    }
-    for c in b.children.iter().filter(|c| !n.children.contains(c)) {
-        if doc.contains(*c) {
-            return None;
-        }
-        layers.extend(before.subtree(*c));
-    }
-    Some(layers)
-}
-
-/// Carry the new and deleted layers of main layers `seeds` ([`restructurable`]) to every copy,
-/// through copies of copies (slots holding an instance's own content keep it). Returns false
-/// (leaving a partial patch for the caller to rebuild over) when a copy can't follow exactly.
-fn patch_structure(doc: &mut Document, before: &Document, seeds: &[NodeId]) -> bool {
-    let copies = copies_index(doc);
-    let mut work: Vec<NodeId> = seeds.to_vec();
-    let mut steps = 0usize;
-    while let Some(p) = work.pop() {
-        steps += 1;
-        if steps > 10_000_000 {
-            return false;
-        }
-        let Some(pn) = doc.node(p).cloned() else { continue };
-        for c in copies.get(&p).cloned().unwrap_or_default() {
-            let Some(cn) = doc.node(c).cloned() else { continue };
-            if holds_content(&cn) {
-                continue;
-            }
-            if let (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) = (&pn.kind, &cn.kind)
-                && a != b
-            {
-                continue;
-            }
-            // The copy's layers by the layer of `p` they mirror.
-            let mut mirrors: BTreeMap<NodeId, NodeId> = BTreeMap::new();
-            for k in &cn.children {
-                let Some(src) = doc.node(*k).and_then(|x| x.source) else { return false };
-                if mirrors.insert(src, *k).is_some() {
-                    return false;
-                }
-            }
-            let mut order = Vec::with_capacity(pn.children.len());
-            for pc in &pn.children {
-                if let Some(k) = mirrors.remove(pc) {
-                    order.push(k);
-                    continue;
-                }
-                // A layer the copy lacks must be new in this edit, placed as in the main.
-                let absolute = doc.node(*pc).is_some_and(|x| x.child_layout.absolute);
-                if before.contains(*pc) || !child_follows_main(doc, c, absolute) {
-                    return false;
-                }
-                match copy_layers(doc, *pc, c) {
-                    Some(k) => order.push(k),
-                    None => return false,
-                }
-            }
-            // Copies of layers the main lost.
-            for (src, k) in mirrors {
-                if doc.contains(src) || doc.remove(k).is_err() {
-                    return false;
-                }
-            }
-            if doc.node(c).is_some_and(|x| x.children != order)
-                && let Some(m) = doc.node_mut(c)
-            {
-                m.children = order;
-            }
-            work.push(c);
-        }
-    }
-    true
-}
-
-/// Whether a layer placed in copy `parent` (absolutely positioned or not) takes its main layer's
-/// place and size: nothing on the way up applies constraints ([`follows_main_geometry`]).
-fn child_follows_main(doc: &Document, parent: NodeId, absolute: bool) -> bool {
-    let Some(p) = doc.node(parent) else { return false };
-    let constrains = p.layout.is_none() || absolute;
-    let resized = sized_own(p)
-        || match &p.kind {
-            NodeKind::Instance { component, .. } => {
-                doc.node(*component).is_none_or(|m| (m.width - p.width).abs() > 1e-9 || (m.height - p.height).abs() > 1e-9)
-            }
-            _ => false,
-        };
-    !(constrains && resized) && follows_main_geometry(doc, parent)
-}
-
-/// Copy main layer `src` (with its layers) into copy `parent` as layers mirroring them; returns the
-/// new copy (the caller places it among `parent`'s layers).
-fn copy_layers(doc: &mut Document, src: NodeId, parent: NodeId) -> Option<NodeId> {
-    let sub = doc.subtree(src);
-    let map: BTreeMap<NodeId, NodeId> = sub.iter().map(|d| (*d, doc.alloc_id())).collect();
-    for d in &sub {
-        let mut n = doc.node(*d)?.clone();
-        n.id = *map.get(d)?;
-        n.parent = if *d == src { Some(parent) } else { n.parent.and_then(|x| map.get(&x).copied()) };
-        n.children = n.children.iter().filter_map(|k| map.get(k).copied()).collect();
-        n.source = Some(*d);
-        n.overrides.clear();
-        n.prop_refs.clear();
-        n.annotations.clear();
-        n.measurements.clear();
-        insert_linked(doc, n).ok()?;
-    }
-    map.get(&src).copied()
-}
-
-/// Carry value-only edits of main-component layers (`seeds`: layer, groups) to every copy, through
-/// copies of copies, except where a copy overrides the group. Returns false (leaving a partial
-/// patch for the caller to rebuild over) when a copy can't follow exactly.
-fn patch_copies(doc: &mut Document, seeds: &[(NodeId, Vec<&'static str>)]) -> bool {
-    let copies = copies_index(doc);
-    let text = |g: &str| matches!(g, "characters" | "textStyle");
-    let mut work: Vec<(NodeId, Vec<&'static str>)> = seeds.to_vec();
-    let mut steps = 0usize;
-    while let Some((p, groups)) = work.pop() {
-        steps += 1;
-        if steps > 10_000_000 {
-            return false;
-        }
-        let Some(pn) = doc.node(p).cloned() else { continue };
-        for c in copies.get(&p).cloned().unwrap_or_default() {
-            let Some(cn) = doc.node(c) else { continue };
-            // A swapped nested instance shows its own main, not the layer it stands in for.
-            if let (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) = (&pn.kind, &cn.kind)
-                && a != b
-            {
-                continue;
-            }
-            // An instance keeps its own visibility, place, export settings and interactions; its
-            // name follows the main's unless renamed; a resized one lays its layers out against
-            // the main's size.
-            let root = matches!(pn.kind, NodeKind::Component { .. });
-            if root && ((groups.contains(&"name") && !cn.overrides.contains("name")) || (groups.contains(&"size") && cn.overrides.contains("size"))) {
-                return false;
-            }
-            let gs: Vec<&'static str> = groups
-                .iter()
-                .copied()
-                .filter(|g| !(cn.overrides.contains(*g) || root && matches!(*g, "visible" | "name" | "position" | "exports" | "interactions")))
-                .collect();
-            if gs.is_empty() {
-                continue;
-            }
-            let geometry = gs.iter().any(|g| matches!(*g, "size" | "position"));
-            if geometry && !follows_main_geometry(doc, c) {
-                return false;
-            }
-            // Text content and style share their runs: a copy overriding one keeps its runs when the
-            // other follows the main (as a rebuild carries them).
-            let runs = match &cn.kind {
-                NodeKind::Text(t) if gs.iter().any(|g| text(g)) && cn.overrides.iter().any(|g| text(g)) => Some(t.runs.clone()),
-                _ => None,
-            };
-            if let Some(m) = doc.node_mut(c) {
-                for g in &gs {
-                    copy_group(&pn, m, g);
-                }
-                if let (Some(r), NodeKind::Text(t)) = (runs, &mut m.kind) {
-                    t.runs = r;
-                }
-            }
-            if (geometry || gs.iter().any(|g| text(g)))
-                && let Some((w, h)) = doc.node(c).and_then(figcraft_text::auto_size)
-                && doc.node(c).is_some_and(|n| (n.width - w).abs() > 1e-6 || (n.height - h).abs() > 1e-6)
-            {
-                figcraft_layout::set_size(doc, c, w, h);
-            }
-            work.push((c, gs));
-        }
-    }
-    true
-}
-
-/// Whether a copy's size and place are its main layer's: no layer around it inside its instances
-/// applies constraints on the way down to it (a resized instance or frame without auto layout, or
-/// a resized auto layout instance holding it absolutely positioned). Auto layout re-flows the rest.
-fn follows_main_geometry(doc: &Document, id: NodeId) -> bool {
-    let chain = scope(doc, id);
-    chain.windows(2).all(|w| {
-        let (Some(below), Some(a)) = (w.first().and_then(|i| doc.node(*i)), w.get(1).and_then(|i| doc.node(*i))) else { return false };
-        let constrains = a.layout.is_none() || below.child_layout.absolute;
-        if sized_own(a) && constrains {
-            return false;
-        }
-        match &a.kind {
-            NodeKind::Instance { component, .. } => {
-                !constrains || doc.node(*component).is_some_and(|m| (m.width - a.width).abs() <= 1e-9 && (m.height - a.height).abs() <= 1e-9)
-            }
-            _ => true,
-        }
-    })
-}
-
-/// Whether a layer inside an instance overrides its size or resizing: it may not have its main
-/// layer's size, so the layers in it can't take their main layers' places as they are.
-fn sized_own(n: &Node) -> bool {
-    n.overrides.contains("size") || n.overrides.contains("resizing")
-}
-
-/// Rebuild every instance of `comps` (and of the components that hold those instances, and so on
-/// outwards), each outermost instance once, inner components first.
-fn rebuild_instances(doc: &mut Document, comps: &BTreeSet<NodeId>) {
-    if comps.is_empty() {
-        return;
-    }
-    // Outermost instances by the components their layers instantiate.
-    let mut roots_of: BTreeMap<NodeId, BTreeSet<NodeId>> = BTreeMap::new();
-    for n in doc.nodes() {
-        if let NodeKind::Instance { component, .. } = &n.kind {
-            roots_of.entry(*component).or_default().insert(root_instance(doc, n.id).unwrap_or(n.id));
-        }
-    }
-    // Affected components, with how deep their dependencies go (an instance inside component X of
-    // component Y: X follows Y).
-    let mut level: BTreeMap<NodeId, usize> = comps.iter().map(|c| (*c, 0)).collect();
-    let mut outer: BTreeMap<NodeId, Option<NodeId>> = BTreeMap::new();
-    let mut frontier: Vec<NodeId> = comps.iter().copied().collect();
-    let mut rounds = 0;
-    while !frontier.is_empty() && rounds < 64 {
-        rounds += 1;
-        let mut next = Vec::new();
-        for c in frontier {
-            let lc = level.get(&c).copied().unwrap_or(0);
-            for r in roots_of.get(&c).into_iter().flatten() {
-                let o = *outer.entry(*r).or_insert_with(|| owning_component(doc, *r));
-                if let Some(x) = o
-                    && x != c
-                {
-                    let lx = level.entry(x).or_insert(0);
-                    if *lx < lc + 1 {
-                        *lx = lc + 1;
-                        next.push(x);
-                    }
-                }
-            }
-        }
-        frontier = next;
-    }
-    // Instances inside components by level, then the rest (each once).
-    let mut order: Vec<(usize, NodeId)> = outer.iter().map(|(r, o)| (o.and_then(|x| level.get(&x).copied()).unwrap_or(usize::MAX), *r)).collect();
-    order.sort();
-    for (_, r) in order {
-        if doc.contains(r) {
-            sync_instance(doc, r);
-        }
-    }
-}
-
-/// Slot `slot` (inside an instance) takes the instance's own content: the layers it shows (the
-/// main's default content until now) stop mirroring the main, and instances among them stand
-/// alone, linked to their own mains.
-fn own_slot_content(doc: &mut Document, slot: NodeId) {
-    if let Some(n) = doc.node_mut(slot) {
-        n.overrides.insert(SLOT.into());
-    }
-    for nested in unlink_layers(doc, slot, None) {
-        rebase_instance(doc, nested);
-    }
-}
-
-/// Unlink the layers below `top` that are layers of `owner` (an instance, or `None` for the
-/// content of a slot): plain layers forget the main layer they mirrored and their property
-/// bindings. The instances among them are returned, to re-link to their own mains (with
-/// [`rebase_instance`]) once the caller is done.
-pub fn unlink_layers(doc: &mut Document, top: NodeId, owner: Option<NodeId>) -> Vec<NodeId> {
-    let picked: Vec<(NodeId, bool)> =
-        doc.subtree(top).into_iter().filter(|d| *d != top && enclosing_instance(doc, *d) == owner).map(|d| (d, is_instance(doc, d))).collect();
-    let mut nested = Vec::new();
-    for (d, instance) in picked {
-        let Some(n) = doc.node_mut(d) else { continue };
-        n.prop_refs.clear();
-        if instance {
-            nested.push(d);
-        } else {
-            n.source = None;
-            n.overrides.clear();
-        }
-    }
-    nested
-}
-
-/// A new layer copied from inside an instance (pasted, duplicated) to where no instance owns it
-/// stops mirroring the main; a copied nested instance is re-linked to its own main (its look kept).
-fn relink_copy(doc: &mut Document, id: NodeId) {
-    let Some(n) = doc.node(id) else { return };
-    match &n.kind {
-        NodeKind::Instance { component, .. } => {
-            let main_ok = doc.node(*component).is_some_and(|m| matches!(m.kind, NodeKind::Component { .. }));
-            if main_ok && !inside_instance(doc, id) && (n.source != Some(*component) || !instance_issues(doc, id).is_empty()) {
-                rebase_instance(doc, id);
-            }
-        }
-        _ => {
-            if (n.source.is_some() || !n.overrides.is_empty())
-                && owning_instance(doc, id).is_none()
-                && let Some(m) = doc.node_mut(id)
-            {
-                m.source = None;
-                m.overrides.clear();
-            }
-        }
-    }
-}
-
-/// Refuse edits that add, remove or reorder layers inside an instance (only its main can), outside
-/// its slots.
-pub fn check_structure_edit(before: &Document, after: &Document) -> Result<(), String> {
-    for &id in after.dirty() {
-        let (Some(n), Some(b)) = (after.node(id), before.node(id)) else { continue };
-        // Library copies change only through library updates (and are read-only otherwise).
-        if n.children == b.children || after.is_remote(id) {
-            continue;
-        }
-        if structure_locked(before, id) && structure_locked(after, id) {
-            let name = owning_instance(after, id).and_then(|i| after.node(i)).map(|i| i.name.clone()).unwrap_or_default();
-            return Err(format!(
-                "layers can't be added, removed or reordered inside the instance \"{name}\": edit its main component, or detach the instance first"
-            ));
-        }
-    }
-    Ok(())
-}
-
-/// Refuse edits an instance doesn't take as overrides ([`refused_override`]); the edit is rolled
-/// back.
-pub fn check_override_edit(before: &Document, after: &Document) -> Result<(), String> {
-    match after.dirty().iter().find_map(|id| refused_override(before, after, *id)) {
-        Some(what) => Err(format!("{what} comes from the main component in an instance: edit the main component, or detach the instance")),
-        None => Ok(()),
-    }
-}
-
-/// What about layer `id` an edit from `before` to `after` changed that only its main can: the
-/// auto layout of an instance or a layer in one but its padding, gap and alignment, or the
-/// position (rotation too), constraints or place in auto layout (absolute, grid cell) of a layer
-/// inside an instance (its size and resizing are overrides). `None` when the edit is fine, also
-/// when the main changed the same way in this edit (a library update).
-pub fn refused_override(before: &Document, after: &Document, id: NodeId) -> Option<&'static str> {
-    let (n, b) = (after.node(id)?, before.node(id)?);
-    if after.is_remote(id) || n.source != b.source || owning_instance(before, id).is_none() || owning_instance(after, id).is_none() {
-        return None;
-    }
-    let (mb, ma) = (before.node(n.source?)?, after.node(n.source?)?);
-    let mode = |x: &Node| x.layout.as_ref().map(|l| l.mode);
-    // Auto layout settings other than the overridable ones.
-    let settings = |x: &Node| {
-        x.layout.clone().map(|mut l| {
-            (l.gap, l.cross_gap, l.padding, l.main_align, l.cross_align) = (0.0, 0.0, [0.0; 4], MainAlign::Min, CrossAlign::Min);
-            l.content_align = ContentAlign::Auto;
-            l
-        })
-    };
-    // Child layout settings other than the resizing ones.
-    let placing = |x: &Node| {
-        let mut c = x.child_layout.clone();
-        (c.sizing_h, c.sizing_v, c.min_w, c.max_w, c.min_h, c.max_h) = (Sizing::Fixed, Sizing::Fixed, None, None, None, None);
-        c
-    };
-    if mode(n) != mode(b) && mode(ma) == mode(mb) {
-        return Some("The auto layout direction");
-    }
-    if settings(n) != settings(b) && settings(ma) == settings(mb) {
-        return Some("This auto layout setting");
-    }
-    if !inside_instance(after, id) || !inside_instance(before, id) {
-        return None;
-    }
-    if n.transform != b.transform && ma.transform == mb.transform && !geometry_derived(after, before, id, "position") {
-        return Some("A layer's position");
-    }
-    if n.constraints != b.constraints && ma.constraints == mb.constraints {
-        return Some("A layer's constraints");
-    }
-    if placing(n) != placing(b) && placing(ma) == placing(mb) {
-        return Some("A layer's place in auto layout");
-    }
-    None
-}
-
-/// Bounded source and parent lookups while a rebase reads an unchanged document.
-struct RebaseSources<'a> {
-    doc: &'a Document,
-    chains: BTreeMap<NodeId, Option<Vec<NodeId>>>,
-    parents: BTreeMap<(NodeId, NodeId), Option<bool>>,
-    main_changes: BTreeMap<NodeId, bool>,
-}
-
-impl<'a> RebaseSources<'a> {
-    const PARENTS: usize = 512;
-    const CACHE: usize = 8192;
-
-    fn new(doc: &'a Document) -> Self {
-        Self { doc, chains: BTreeMap::new(), parents: BTreeMap::new(), main_changes: BTreeMap::new() }
-    }
-
-    fn chain(&mut self, source: NodeId) -> Option<Vec<NodeId>> {
-        if let Some(chain) = self.chains.get(&source) {
-            return chain.clone();
-        }
-        let read = || {
-            let mut chain = Vec::new();
-            let mut seen = BTreeSet::new();
-            let mut current = Some(source);
-            for _ in 0..MAX_DEPTH {
-                let Some(id) = current else { return Some(chain) };
-                if !seen.insert(id) {
-                    return None;
-                }
-                let n = self.doc.node(id)?;
-                chain.push(id);
-                current = n.source;
-            }
-            current.is_none().then_some(chain)
-        };
-        let chain = read();
-        if self.chains.len() < Self::CACHE {
-            self.chains.insert(source, chain.clone());
-        }
-        chain
-    }
-
-    /// Validate the complete parent chain, even if `main` was found before a cycle.
-    fn in_main(&mut self, id: NodeId, main: NodeId) -> Option<bool> {
-        if let Some(found) = self.parents.get(&(id, main)) {
-            return *found;
-        }
-        let read = || {
-            let mut current = Some(id);
-            let mut seen = BTreeSet::new();
-            let mut found = false;
-            for _ in 0..Self::PARENTS {
-                let Some(id) = current else { return Some(found) };
-                if !seen.insert(id) {
-                    return None;
-                }
-                found |= id == main;
-                current = self.doc.node(id)?.parent;
-            }
-            current.is_none().then_some(found)
-        };
-        let found = read();
-        if self.parents.len() < Self::CACHE {
-            self.parents.insert((id, main), found);
-        }
-        found
-    }
-
-    fn member(&mut self, source: NodeId, main: NodeId, target: NodeId) -> Option<NodeId> {
-        let chain = self.chain(source)?;
-        if chain.contains(&target) {
-            return None;
-        }
-        let mut member = None;
-        for id in chain {
-            if self.in_main(id, main)? && id != main && member.is_none() {
-                member = Some(id);
-            }
-        }
-        member
-    }
-
-    /// Nearest enclosing instances and their current mains. Slots with own content end scope.
-    fn owners(&self, id: NodeId) -> Option<Vec<(NodeId, NodeId)>> {
-        let mut owners = Vec::new();
-        let mut current = self.doc.node(id)?.parent;
-        let mut seen = BTreeSet::from([id]);
-        for _ in 0..Self::PARENTS {
-            let Some(id) = current else { return Some(owners) };
-            if !seen.insert(id) {
-                return None;
-            }
-            let n = self.doc.node(id)?;
-            if holds_content(n) {
-                return Some(owners);
-            }
-            if let NodeKind::Instance { component, .. } = &n.kind {
-                owners.push((id, *component));
-            }
-            current = n.parent;
-        }
-        current.is_none().then_some(owners)
-    }
-
-    fn contextual(&mut self, source: NodeId, owners: &[(NodeId, NodeId)]) -> bool {
-        owners.iter().any(|(_, main)| self.in_main(source, *main) == Some(true) && source != *main)
-    }
-
-    /// A contextual child belongs to the same placed slot as its enclosing instance.
-    fn valid(&mut self, source: NodeId, target: NodeId, owners: &[(NodeId, NodeId)]) -> bool {
-        let Some((owner, main)) = owners.first() else { return false };
-        if self.member(source, *main, target).is_none() {
-            return false;
-        }
-        if self.in_main(source, *main) == Some(true) {
-            return true;
-        }
-        let Some(source_owner) = self.doc.node(*owner).and_then(|n| n.source) else { return false };
-        matches!(self.doc.node(source_owner).map(|n| &n.kind), Some(NodeKind::Instance { component, .. }) if component == main)
-            && self.owners(source).and_then(|owners| owners.first().copied()).is_some_and(|(id, _)| id == source_owner)
-    }
-
-    fn placed(&mut self, id: NodeId, owners: &[(NodeId, NodeId)]) -> Option<NodeId> {
-        let source = self.doc.node(id)?.source?;
-        if !matches!(self.doc.node(source)?.kind, NodeKind::Instance { .. } | NodeKind::Frame)
-            || !self.valid(source, id, owners)
-            || !self.contextual(source, owners)
-        {
-            return None;
-        }
-        Some(source)
-    }
-
-    fn beneath_swap(&mut self, owners: &[(NodeId, NodeId)], stop: NodeId) -> bool {
-        for (index, (id, main)) in owners.iter().enumerate() {
-            if *id == stop {
-                break;
-            }
-            let changed = if let Some(changed) = self.main_changes.get(id) {
-                *changed
-            } else {
-                let changed = self.placed(*id, &owners[index + 1..]).is_some_and(|source| match self.doc.node(source).map(|n| &n.kind) {
-                    Some(NodeKind::Instance { component, .. }) => component != main,
-                    Some(NodeKind::Frame) => true,
-                    _ => false,
-                });
-                if self.main_changes.len() < Self::CACHE {
-                    self.main_changes.insert(*id, changed);
-                }
-                changed
-            };
-            if changed {
-                return true;
-            }
-        }
-        false
-    }
-}
-
-/// Re-derive `source` links and overrides of instance `inst` against its own main by comparing
-/// values (after detaching an outer instance, restoring a main, or copying a nested instance out):
-/// the look is kept exactly. Values a component property sets aren't overrides.
-pub fn rebase_instance(doc: &mut Document, inst: NodeId) {
-    let Some(NodeKind::Instance { component, .. }) = doc.node(inst).map(|n| n.kind.clone()) else { return };
-    let mine = path_map(doc, inst, true);
-    let theirs: BTreeMap<String, NodeId> =
-        if doc.contains(component) { path_map(doc, component, false).into_iter().map(|(k, v)| (v, k)).collect() } else { BTreeMap::new() };
-    let value_groups = |a: &Node, b: &Node| -> Vec<String> {
-        diff_groups(a, b).into_iter().filter(|g| !matches!(*g, "size" | "position")).map(str::to_string).collect()
-    };
-    let mut updates = Vec::new();
-    let mut sources = RebaseSources::new(doc);
-    let root_owners = sources.owners(inst).unwrap_or_default();
-    let placed_source = sources.placed(inst, &root_owners);
-    let mut contexts = vec![(inst, component)];
-    contexts.extend_from_slice(&root_owners);
-    for (id, path) in &mine {
-        let Some(n) = doc.node(*id) else { continue };
-        let owners = sources.owners(*id).unwrap_or_default();
-        let nearest_main = owners.first().map(|(_, main)| *main);
-        let valid_source = n.source.filter(|source| sources.valid(*source, *id, &owners));
-        let mut main = valid_source.and_then(|source| sources.member(source, component, *id));
-        // A swapped or Frame-to-Instance subtree is compared to its current main by the inner
-        // rebase. An outer name path must not rebind those children to the old expanded copies.
-        if main.is_none() && valid_source.is_some() && sources.beneath_swap(&owners, inst) {
-            updates.push((*id, valid_source, n.overrides.clone()));
-            continue;
-        }
-        main = main
-            .or_else(|| theirs.get(path).copied().filter(|source| nearest_main.is_some_and(|scope| sources.member(*source, scope, *id).is_some())));
-        let source = valid_source.filter(|source| sources.contextual(*source, &contexts)).filter(|_| main.is_some()).or(main);
-        let mut overrides: BTreeSet<String> = n.overrides.iter().filter(|g| !matches!(g.as_str(), "component" | "props")).cloned().collect();
-        if let Some(m) = source.and_then(|source| doc.node(source)) {
-            let mut bound: Vec<&str> = m.prop_refs.keys().map(|f| field_group(f)).collect();
-            bound.extend(variable_groups(n, m));
-            overrides.extend(value_groups(m, n).into_iter().filter(|g| !bound.contains(&g.as_str())));
-            if matches!((&m.kind, &n.kind), (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) if a != b) {
-                overrides.insert("component".into());
-            }
-        }
-        updates.push((*id, source, overrides));
-    }
-    // A placed nested root compares to its actual slot. A detached root compares to its own main.
-    let root_base = placed_source.or_else(|| {
-        let chain = sources.chain(component)?;
-        (!chain.contains(&inst) && sources.in_main(component, inst) == Some(false)).then_some(component)
-    });
-    let root_groups = match (root_base.and_then(|source| doc.node(source)), doc.node(inst)) {
-        (Some(m), Some(n)) => {
-            let from_variables = variable_groups(n, m);
-            let mut groups: Vec<String> = value_groups(m, n)
-                .into_iter()
-                .filter(|g| !matches!(g.as_str(), "name" | "exports" | "interactions") && !from_variables.contains(&g.as_str()))
-                .filter(|g| placed_source.is_some() || !matches!(g.as_str(), "resizing" | "modes"))
-                .collect();
-            let named = if placed_source.is_some() { n.name != m.name } else { n.name != default_instance_name(doc, component) };
-            if named {
-                groups.push("name".into());
-            }
-            if placed_source.is_some()
-                && matches!((&m.kind, &n.kind), (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) if a != b)
-            {
-                groups.push("component".into());
-            }
-            groups
-        }
-        _ => Vec::new(),
-    };
-    drop(sources);
-    for (id, main, overrides) in updates {
-        if let Some(n) = doc.node_mut(id) {
-            n.source = main;
-            n.overrides = if main.is_some() { overrides } else { BTreeSet::new() };
-        }
-    }
-    if let Some(n) = doc.node_mut(inst) {
-        n.source = root_base;
-        // A top-level instance's resizing and modes are its own (a nested one's override its main
-        // layer's).
-        n.overrides.retain(|g| {
-            !matches!(g.as_str(), "component" | "props" | "position") && (placed_source.is_some() || !matches!(g.as_str(), "resizing" | "modes"))
-        });
-        n.overrides.extend(root_groups);
-    }
-}
-
 #[cfg(test)]
 #[path = "components_rebase_source_tests.rs"]
 mod rebase_source_tests;
 
-/// A set's default variant: the one in its top-left corner (nearest to it, then the top-most, then
-/// the left-most).
-pub fn default_variant(doc: &Document, set: NodeId) -> Option<NodeId> {
-    let corner = |c: &NodeId| {
-        doc.node(*c).filter(|n| matches!(n.kind, NodeKind::Component { .. })).map(|n| n.transform.as_coeffs()).map(|[.., x, y]| (x + y, y, x))
-    };
-    let kids = &doc.node(set)?.children;
-    kids.iter()
-        .copied()
-        .filter_map(|c| corner(&c).map(|k| (k, c)))
-        .min_by(|(a, _), (b, _)| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
-        .map(|(_, c)| c)
-}
-
-/// Variants of a set sharing one combination of property values (each group two or more, in
-/// layer order): a conflict to resolve by giving each a unique combination.
-pub fn variant_conflicts(doc: &Document, set: NodeId) -> Vec<Vec<NodeId>> {
-    let mut by: BTreeMap<BTreeMap<String, String>, Vec<NodeId>> = BTreeMap::new();
-    for c in doc.node(set).map(|s| s.children.clone()).unwrap_or_default() {
-        if let Some(n) = doc.node(c).filter(|n| matches!(n.kind, NodeKind::Component { .. })) {
-            by.entry(variant_props(&n.name)).or_default().push(c);
-        }
-    }
-    by.into_values().filter(|v| v.len() > 1).collect()
-}
-
-/// Parse a variant name "Size=Large, State=Hover" into pairs.
-pub fn variant_props(name: &str) -> BTreeMap<String, String> {
-    name.split(',')
-        .filter_map(|kv| {
-            let (k, v) = kv.split_once('=')?;
-            Some((k.trim().to_string(), v.trim().to_string()))
-        })
-        .collect()
-}
-
-/// Format variant pairs as a layer name, in the given property order (others after, sorted).
-pub fn variant_name(pairs: &BTreeMap<String, String>, order: &[String]) -> String {
-    let mut keys: Vec<&String> = order.iter().filter(|k| pairs.contains_key(*k)).collect();
-    keys.extend(pairs.keys().filter(|k| !order.contains(k)));
-    keys.iter().filter_map(|k| pairs.get(*k).map(|v| format!("{k}={v}"))).collect::<Vec<_>>().join(", ")
-}
-
-/// Variant properties of a set: property → values, in first-seen order.
-pub fn variant_options(doc: &Document, set: NodeId) -> Vec<(String, Vec<String>)> {
-    let mut out: Vec<(String, Vec<String>)> = Vec::new();
-    for c in doc.node(set).map(|s| s.children.clone()).unwrap_or_default() {
-        let Some(cn) = doc.node(c) else { continue };
-        for kv in cn.name.split(',') {
-            let Some((k, v)) = kv.split_once('=') else { continue };
-            let (k, v) = (k.trim().to_string(), v.trim().to_string());
-            match out.iter_mut().find(|(p, _)| *p == k) {
-                Some((_, vals)) => {
-                    if !vals.contains(&v) {
-                        vals.push(v);
-                    }
-                }
-                None => out.push((k, vec![v])),
-            }
-        }
-    }
-    out
-}
-
-/// The variant in `set` matching `wanted` best: all given properties equal, or else the most.
-pub fn find_variant(doc: &Document, set: NodeId, wanted: &BTreeMap<String, String>) -> Option<NodeId> {
-    let s = doc.node(set)?;
-    let score = |c: &NodeId| doc.node(*c).map(|n| variant_props(&n.name)).map(|p| wanted.iter().filter(|(k, v)| p.get(*k) == Some(*v)).count());
-    if let Some(exact) = s.children.iter().copied().find(|c| score(c) == Some(wanted.len())) {
-        return Some(exact);
-    }
-    s.children.iter().copied().filter(|c| score(c).is_some()).max_by_key(|c| score(c).unwrap_or(0))
-}
-
-/// Check that every instance mirrors its main's layer structure (tests and diagnostics): each
-/// layer's `source` is the main layer at the same place, swapped nested instances mirror their
-/// own main, slots holding the instance's own content aren't compared. Returns the problems found.
-pub fn mirror_issues(doc: &Document) -> Vec<String> {
-    doc.nodes()
-        .filter(|n| matches!(n.kind, NodeKind::Instance { .. }) && !inside_instance(doc, n.id))
-        .flat_map(|n| instance_issues(doc, n.id))
-        .collect()
-}
-
-/// [`mirror_issues`] for one instance.
-fn instance_issues(doc: &Document, id: NodeId) -> Vec<String> {
-    fn walk(doc: &Document, inst: &Node, main: &Node, depth: usize, out: &mut Vec<String>) {
-        if depth > MAX_DEPTH || holds_content(inst) {
-            return;
-        }
-        if inst.children.len() != main.children.len() {
-            out.push(format!("{} has {} layers, its main {} has {}", inst.id, inst.children.len(), main.id, main.children.len()));
-            return;
-        }
-        for (a, b) in inst.children.iter().zip(&main.children) {
-            let (Some(an), Some(bn)) = (doc.node(*a), doc.node(*b)) else { continue };
-            if an.source != Some(bn.id) {
-                out.push(format!("{} mirrors {:?}, expected {}", an.id, an.source, bn.id));
-                continue;
-            }
-            match (&an.kind, &bn.kind) {
-                (NodeKind::Instance { component: x, .. }, NodeKind::Instance { component: y, .. }) if x != y => {
-                    if let Some(m) = doc.node(*x) {
-                        walk(doc, an, m, depth + 1, out);
-                    }
-                }
-                _ => walk(doc, an, bn, depth + 1, out),
-            }
-        }
-    }
-    let mut out = Vec::new();
-    if let Some(n) = doc.node(id)
-        && let NodeKind::Instance { component, .. } = &n.kind
-        && let Some(m) = doc.node(*component)
-    {
-        walk(doc, n, m, 0, &mut out);
-    }
-    out
-}
-
 #[cfg(test)]
 #[path = "components_tests.rs"]
 pub(crate) mod tests;
-
-/// The nested instance copies inside instance `id` whose main-component counterpart is exposed
-/// (top-most first; an exposed instance's own exposed nested instances follow it).
-pub fn exposed_copies(doc: &Document, id: NodeId) -> Vec<NodeId> {
-    let mut out = Vec::new();
-    let mut stack: Vec<NodeId> = doc.node(id).map(|n| n.children.iter().rev().copied().collect()).unwrap_or_default();
-    let mut seen = 0usize;
-    while let Some(c) = stack.pop() {
-        seen += 1;
-        if seen > 100_000 {
-            break;
-        }
-        let Some(n) = doc.node(c) else { continue };
-        // A hidden exposed instance hides its properties too.
-        let exposed =
-            n.visible && matches!(n.kind, NodeKind::Instance { .. }) && n.source.and_then(|src| doc.node(src)).is_some_and(|src| src.exposed);
-        if exposed {
-            out.push(c);
-        }
-        // Only exposed nested instances pass their own exposed instances up.
-        if !matches!(n.kind, NodeKind::Instance { .. }) || exposed {
-            stack.extend(n.children.iter().rev().copied());
-        }
-    }
-    out
-}
diff --git a/crates/engine/src/assets/components/diff.rs b/crates/engine/src/assets/components/diff.rs
new file mode 100644
index 00000000..bf742fed
--- /dev/null
+++ b/crates/engine/src/assets/components/diff.rs
@@ -0,0 +1,218 @@
+use super::instances::PROP_BINDING;
+use super::*;
+
+/// The property groups whose value layer `n` takes from the same variables as its main layer
+/// `src` (they differ only where the two resolve in different variable modes).
+pub fn variable_groups(n: &Node, src: &Node) -> Vec<&'static str> {
+    let mut out = Vec::new();
+    for (k, v) in &n.bound {
+        let Some(g) = binding_group(k) else { continue };
+        if src.bound.get(k) == Some(v) && !out.contains(&g) {
+            out.push(g);
+        }
+    }
+    out
+}
+
+/// The override group a variable binding key feeds (`None` for component property and layout
+/// grid bindings, which follow other rules).
+pub(super) fn binding_group(key: &str) -> Option<&'static str> {
+    use crate::cmd::lists::{BoundList, list_binding};
+    if key.starts_with(PROP_BINDING) {
+        return None;
+    }
+    match list_binding(key).map(|(l, _, _)| l) {
+        Some(BoundList::Fills) => Some("fills"),
+        Some(BoundList::Strokes) => Some("strokes"),
+        Some(BoundList::Effects) => Some("effects"),
+        Some(BoundList::Grids) => None,
+        None => Some(crate::cmd::props::override_group(key)).filter(|g| *g != "other"),
+    }
+}
+
+/// The variable bindings of `n` that feed group `g`.
+pub(super) fn bindings_of<'a>(n: &'a Node, g: &'a str) -> impl Iterator<Item = (&'a String, &'a String)> + 'a {
+    n.bound.iter().filter(move |(k, _)| binding_group(k) == Some(g))
+}
+
+/// Property groups that differ between two versions of a node.
+pub fn diff_groups(a: &Node, b: &Node) -> Vec<&'static str> {
+    let mut out = Vec::new();
+    if a.fills != b.fills {
+        out.push("fills");
+    }
+    if a.strokes != b.strokes || a.stroke != b.stroke {
+        out.push("strokes");
+    }
+    if a.effects != b.effects {
+        out.push("effects");
+    }
+    if a.opacity != b.opacity || a.blend != b.blend {
+        out.push("opacity");
+    }
+    if a.visible != b.visible {
+        out.push("visible");
+    }
+    if a.name != b.name {
+        out.push("name");
+    }
+    if a.corners != b.corners {
+        out.push("corners");
+    }
+    if (a.width - b.width).abs() > 1e-6 || (a.height - b.height).abs() > 1e-6 {
+        out.push("size");
+    }
+    if resizing(a) != resizing(b) {
+        out.push("resizing");
+    }
+    if a.transform != b.transform {
+        out.push("position");
+    }
+    if let (NodeKind::Text(x), NodeKind::Text(y)) = (&a.kind, &b.kind) {
+        if x.characters != y.characters {
+            out.push("characters");
+        }
+        if text_style_differs(x, y) {
+            out.push("textStyle");
+        }
+    }
+    if let (Some(x), Some(y)) = (&a.layout, &b.layout) {
+        if x.padding != y.padding {
+            out.push("padding");
+        }
+        if x.gap != y.gap || x.cross_gap != y.cross_gap {
+            out.push("gap");
+        }
+        if x.main_align != y.main_align || x.cross_align != y.cross_align || x.content_align != y.content_align {
+            out.push("alignment");
+        }
+    }
+    if a.grids != b.grids || a.styles.grid != b.styles.grid {
+        out.push("grids");
+    }
+    if a.exports != b.exports {
+        out.push("exports");
+    }
+    if a.interactions != b.interactions {
+        out.push("interactions");
+    }
+    if a.var_modes != b.var_modes {
+        out.push("modes");
+    }
+    if let (NodeKind::Instance { component: x, props: px }, NodeKind::Instance { component: y, props: py }) = (&a.kind, &b.kind) {
+        if x != y {
+            out.push("component");
+        }
+        if px != py {
+            out.push("props");
+        }
+    }
+    out
+}
+
+/// The `resizing` group of a layer: how it sizes on each axis, and its min and max sizes.
+fn resizing(n: &Node) -> (Sizing, Sizing, [Option<f64>; 4]) {
+    let c = &n.child_layout;
+    (c.sizing_h, c.sizing_v, [c.min_w, c.max_w, c.min_h, c.max_h])
+}
+
+/// Whether two texts differ in anything but their characters (the `textStyle` group).
+fn text_style_differs(x: &TextData, y: &TextData) -> bool {
+    x.style != y.style
+        || x.runs != y.runs
+        || x.auto_resize != y.auto_resize
+        || x.align_h != y.align_h
+        || x.align_v != y.align_v
+        || x.paragraph_spacing != y.paragraph_spacing
+        || x.paragraph_indent != y.paragraph_indent
+        || x.list != y.list
+        || x.paragraphs != y.paragraphs
+        || x.list_spacing != y.list_spacing
+        || x.hanging_punctuation != y.hanging_punctuation
+        || x.hanging_list != y.hanging_list
+        || x.max_lines != y.max_lines
+        || x.features != y.features
+}
+
+/// Whether a geometry change of `id` comes from layout rather than the user: an ancestor was
+/// resized in the same edit (constraints), the parent is an auto layout frame, or auto-sized text.
+pub(super) fn geometry_derived(doc: &Document, before: &Document, id: NodeId, group: &str) -> bool {
+    for a in doc.ancestors(id) {
+        let (Some(x), Some(y)) = (doc.node(a), before.node(a)) else { continue };
+        if (x.width - y.width).abs() > 1e-6 || (x.height - y.height).abs() > 1e-6 {
+            return true;
+        }
+    }
+    let Some(n) = doc.node(id) else { return true };
+    if group == "position" && n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some()) && !n.child_layout.absolute {
+        return true;
+    }
+    if group == "size"
+        && let NodeKind::Text(t) = &n.kind
+    {
+        let wchanged = before.node(id).is_some_and(|b| (b.width - n.width).abs() > 1e-6);
+        return match t.auto_resize {
+            TextAutoResize::WidthAndHeight => true,
+            TextAutoResize::Height => !wchanged,
+            _ => false,
+        };
+    }
+    false
+}
+
+/// The components sharing the properties of component `c`: the variants of its set, or `c` alone.
+pub fn property_owners(doc: &Document, c: NodeId) -> Vec<NodeId> {
+    match variant_set(doc, c).and_then(|s| doc.node(s)) {
+        Some(set) => set.children.iter().copied().filter(|v| doc.node(*v).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. }))).collect(),
+        None => vec![c],
+    }
+}
+
+/// Make `value` the default of boolean property `name` on components `comps`, showing or hiding
+/// their layers bound to it: on a main component, a boolean property's value is the visibility of
+/// its layers. Returns the components and layers it changed.
+pub fn set_boolean_default(doc: &mut Document, comps: &[NodeId], name: &str, value: bool) -> Vec<NodeId> {
+    let mut out = Vec::new();
+    for &c in comps {
+        let Some(NodeKind::Component { props, .. }) = doc.node(c).map(|n| &n.kind) else { continue };
+        let Some(PropDef::Boolean { default }) = props.get(name) else { continue };
+        if *default != value
+            && let Some(NodeKind::Component { props, .. }) = doc.node_mut(c).map(|n| &mut n.kind)
+        {
+            props.insert(name.to_string(), PropDef::Boolean { default: value });
+            out.push(c);
+        }
+        // The main's own layers (not those of instances nested in it, which follow their mains).
+        let layers: Vec<NodeId> = doc
+            .subtree(c)
+            .into_iter()
+            .filter(|d| *d != c && !inside_instance(doc, *d))
+            .filter(|d| doc.node(*d).is_some_and(|n| n.visible != value && n.prop_refs.get("visible").map(String::as_str) == Some(name)))
+            .collect();
+        for d in layers {
+            if let Some(n) = doc.node_mut(d) {
+                n.visible = value;
+                out.push(d);
+            }
+        }
+    }
+    out
+}
+
+/// A main component's layer bound to a boolean property was shown or hidden: that is the
+/// property's new default, which its other bound layers (in every variant) take too. Returns the
+/// components and layers that changed as a result.
+pub(super) fn follow_boolean_defaults(doc: &mut Document, before: &Document, changed: &[NodeId]) -> Vec<NodeId> {
+    let mut out = Vec::new();
+    for &id in changed {
+        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
+        if n.visible == b.visible || inside_instance(doc, id) {
+            continue;
+        }
+        let Some(name) = n.prop_refs.get("visible").cloned() else { continue };
+        let visible = n.visible;
+        let Some(c) = owning_component(doc, id).filter(|c| *c != id) else { continue };
+        out.extend(set_boolean_default(doc, &property_owners(doc, c), &name, visible));
+    }
+    out
+}
diff --git a/crates/engine/src/assets/components/guard.rs b/crates/engine/src/assets/components/guard.rs
new file mode 100644
index 00000000..b320b7c4
--- /dev/null
+++ b/crates/engine/src/assets/components/guard.rs
@@ -0,0 +1,135 @@
+use super::diff::geometry_derived;
+use super::rebase::rebase_instance;
+use super::variants::instance_issues;
+use super::*;
+
+/// Slot `slot` (inside an instance) takes the instance's own content: the layers it shows (the
+/// main's default content until now) stop mirroring the main, and instances among them stand
+/// alone, linked to their own mains.
+pub(super) fn own_slot_content(doc: &mut Document, slot: NodeId) {
+    if let Some(n) = doc.node_mut(slot) {
+        n.overrides.insert(SLOT.into());
+    }
+    for nested in unlink_layers(doc, slot, None) {
+        rebase_instance(doc, nested);
+    }
+}
+
+/// Unlink the layers below `top` that are layers of `owner` (an instance, or `None` for the
+/// content of a slot): plain layers forget the main layer they mirrored and their property
+/// bindings. The instances among them are returned, to re-link to their own mains (with
+/// [`rebase_instance`]) once the caller is done.
+pub fn unlink_layers(doc: &mut Document, top: NodeId, owner: Option<NodeId>) -> Vec<NodeId> {
+    let picked: Vec<(NodeId, bool)> =
+        doc.subtree(top).into_iter().filter(|d| *d != top && enclosing_instance(doc, *d) == owner).map(|d| (d, is_instance(doc, d))).collect();
+    let mut nested = Vec::new();
+    for (d, instance) in picked {
+        let Some(n) = doc.node_mut(d) else { continue };
+        n.prop_refs.clear();
+        if instance {
+            nested.push(d);
+        } else {
+            n.source = None;
+            n.overrides.clear();
+        }
+    }
+    nested
+}
+
+/// A new layer copied from inside an instance (pasted, duplicated) to where no instance owns it
+/// stops mirroring the main; a copied nested instance is re-linked to its own main (its look kept).
+pub(super) fn relink_copy(doc: &mut Document, id: NodeId) {
+    let Some(n) = doc.node(id) else { return };
+    match &n.kind {
+        NodeKind::Instance { component, .. } => {
+            let main_ok = doc.node(*component).is_some_and(|m| matches!(m.kind, NodeKind::Component { .. }));
+            if main_ok && !inside_instance(doc, id) && (n.source != Some(*component) || !instance_issues(doc, id).is_empty()) {
+                rebase_instance(doc, id);
+            }
+        }
+        _ => {
+            if (n.source.is_some() || !n.overrides.is_empty())
+                && owning_instance(doc, id).is_none()
+                && let Some(m) = doc.node_mut(id)
+            {
+                m.source = None;
+                m.overrides.clear();
+            }
+        }
+    }
+}
+
+/// Refuse edits that add, remove or reorder layers inside an instance (only its main can), outside
+/// its slots.
+pub fn check_structure_edit(before: &Document, after: &Document) -> Result<(), String> {
+    for &id in after.dirty() {
+        let (Some(n), Some(b)) = (after.node(id), before.node(id)) else { continue };
+        // Library copies change only through library updates (and are read-only otherwise).
+        if n.children == b.children || after.is_remote(id) {
+            continue;
+        }
+        if structure_locked(before, id) && structure_locked(after, id) {
+            let name = owning_instance(after, id).and_then(|i| after.node(i)).map(|i| i.name.clone()).unwrap_or_default();
+            return Err(format!(
+                "layers can't be added, removed or reordered inside the instance \"{name}\": edit its main component, or detach the instance first"
+            ));
+        }
+    }
+    Ok(())
+}
+
+/// Refuse edits an instance doesn't take as overrides ([`refused_override`]); the edit is rolled
+/// back.
+pub fn check_override_edit(before: &Document, after: &Document) -> Result<(), String> {
+    match after.dirty().iter().find_map(|id| refused_override(before, after, *id)) {
+        Some(what) => Err(format!("{what} comes from the main component in an instance: edit the main component, or detach the instance")),
+        None => Ok(()),
+    }
+}
+
+/// What about layer `id` an edit from `before` to `after` changed that only its main can: the
+/// auto layout of an instance or a layer in one but its padding, gap and alignment, or the
+/// position (rotation too), constraints or place in auto layout (absolute, grid cell) of a layer
+/// inside an instance (its size and resizing are overrides). `None` when the edit is fine, also
+/// when the main changed the same way in this edit (a library update).
+pub fn refused_override(before: &Document, after: &Document, id: NodeId) -> Option<&'static str> {
+    let (n, b) = (after.node(id)?, before.node(id)?);
+    if after.is_remote(id) || n.source != b.source || owning_instance(before, id).is_none() || owning_instance(after, id).is_none() {
+        return None;
+    }
+    let (mb, ma) = (before.node(n.source?)?, after.node(n.source?)?);
+    let mode = |x: &Node| x.layout.as_ref().map(|l| l.mode);
+    // Auto layout settings other than the overridable ones.
+    let settings = |x: &Node| {
+        x.layout.clone().map(|mut l| {
+            (l.gap, l.cross_gap, l.padding, l.main_align, l.cross_align) = (0.0, 0.0, [0.0; 4], MainAlign::Min, CrossAlign::Min);
+            l.content_align = ContentAlign::Auto;
+            l
+        })
+    };
+    // Child layout settings other than the resizing ones.
+    let placing = |x: &Node| {
+        let mut c = x.child_layout.clone();
+        (c.sizing_h, c.sizing_v, c.min_w, c.max_w, c.min_h, c.max_h) = (Sizing::Fixed, Sizing::Fixed, None, None, None, None);
+        c
+    };
+    if mode(n) != mode(b) && mode(ma) == mode(mb) {
+        return Some("The auto layout direction");
+    }
+    if settings(n) != settings(b) && settings(ma) == settings(mb) {
+        return Some("This auto layout setting");
+    }
+    if !inside_instance(after, id) || !inside_instance(before, id) {
+        return None;
+    }
+    if n.transform != b.transform && ma.transform == mb.transform && !geometry_derived(after, before, id, "position") {
+        return Some("A layer's position");
+    }
+    if n.constraints != b.constraints && ma.constraints == mb.constraints {
+        return Some("A layer's constraints");
+    }
+    if placing(n) != placing(b) && placing(ma) == placing(mb) {
+        return Some("A layer's place in auto layout");
+    }
+    None
+}
diff --git a/crates/engine/src/assets/components/instances.rs b/crates/engine/src/assets/components/instances.rs
new file mode 100644
index 00000000..9fd4e2c2
--- /dev/null
+++ b/crates/engine/src/assets/components/instances.rs
@@ -0,0 +1,342 @@
+use super::diff::{binding_group, bindings_of};
+use super::sync::{insert_linked, sync_instance_depth};
+use super::*;
+
+/// Create an instance of `component` under `parent` at `(x, y)` (parent space).
+pub fn create_instance(doc: &mut Document, component: NodeId, parent: NodeId, x: f64, y: f64) -> Result<NodeId, DocError> {
+    create_instance_at(doc, component, parent, x, y, None)
+}
+
+/// [`create_instance`] at child `index` of `parent` (None: on top).
+pub fn create_instance_at(doc: &mut Document, component: NodeId, parent: NodeId, x: f64, y: f64, index: Option<usize>) -> Result<NodeId, DocError> {
+    let comp = doc.get(component)?.clone();
+    if !matches!(comp.kind, NodeKind::Component { .. }) {
+        return Err(DocError::Invalid(format!("{component} is not a component")));
+    }
+    if doc.is_ancestor(component, parent) {
+        return Err(DocError::Invalid("an instance can't be placed inside its own main component".into()));
+    }
+    let id = doc.alloc_id();
+    let mut root = comp.clone();
+    root.id = id;
+    root.name = default_instance_name(doc, component);
+    root.kind = NodeKind::Instance { component, props: default_props(&comp) };
+    root.children.clear();
+    root.parent = None;
+    root.source = Some(component);
+    root.overrides.clear();
+    root.transform = Affine::translate((x, y));
+    root.prop_refs.clear();
+    root.annotations.clear();
+    root.code_links.clear();
+    // The main's dev resources show on its instances without being copied.
+    root.dev_resources.clear();
+    // Measurements belong to the layer they were placed on.
+    root.measurements.clear();
+    // The main's interactions play on its instances in prototypes; the instance's own start empty.
+    root.interactions.clear();
+    // So do the variable modes the main sets (see `Document::inherited_modes`).
+    root.var_modes.clear();
+    doc.insert(root, parent, index)?;
+    sync_instance(doc, id);
+    Ok(id)
+}
+
+/// Copy `id` within its own file under `parent` (at `index`), keeping its local transform. A file
+/// has one main per component, so a main component's copy is an instance of it; a variant copied
+/// into its set stays a new variant, and every other layer is deep-copied.
+pub fn copy_in_file(doc: &mut Document, id: NodeId, parent: NodeId, index: Option<usize>) -> Result<NodeId, DocError> {
+    let n = doc.get(id)?;
+    let in_set = doc.node(parent).is_some_and(|p| matches!(p.kind, NodeKind::ComponentSet { .. }));
+    if !matches!(n.kind, NodeKind::Component { .. }) || in_set {
+        return doc.duplicate_into(id, parent, index);
+    }
+    let transform = n.transform;
+    let instance = create_instance_at(doc, id, parent, 0.0, 0.0, index)?;
+    doc.get_mut(instance)?.transform = transform;
+    Ok(instance)
+}
+
+/// Which part of the carried overrides to apply.
+#[derive(Clone, Copy, PartialEq)]
+pub(super) enum Carry {
+    /// Paint, text, visibility, … (everything but geometry).
+    Values,
+    /// Values plus size (instance roots: their size decides how children follow constraints).
+    Root,
+    /// Size and position (children, after constraints ran).
+    Geometry,
+}
+
+/// Copy the overridden property groups of `from` onto `to`.
+pub(super) fn carry_overrides(from: &Node, to: &mut Node, what: Carry) {
+    for g in &from.overrides {
+        let geo = matches!(g.as_str(), "size" | "position");
+        match what {
+            Carry::Values if geo => continue,
+            Carry::Root if g == "position" => continue,
+            Carry::Geometry if !geo => continue,
+            _ => {}
+        }
+        copy_group(from, to, g);
+    }
+    if what != Carry::Geometry {
+        to.overrides = from.overrides.clone();
+    }
+}
+
+/// An instance switched from variant `was` to `new`: its resizing (sizing and min / max per axis)
+/// that is still `was`'s follows `new`; what the instance set itself stays in `own`.
+pub(super) fn follow_variant_resizing(own: &mut ChildLayout, was: &ChildLayout, new: &ChildLayout) {
+    if own.sizing_h == was.sizing_h {
+        own.sizing_h = new.sizing_h;
+    }
+    if own.sizing_v == was.sizing_v {
+        own.sizing_v = new.sizing_v;
+    }
+    for (o, w, n) in [
+        (&mut own.min_w, was.min_w, new.min_w),
+        (&mut own.max_w, was.max_w, new.max_w),
+        (&mut own.min_h, was.min_h, new.min_h),
+        (&mut own.max_h, was.max_h, new.max_h),
+    ] {
+        if *o == w {
+            *o = n;
+        }
+    }
+}
+
+/// Copy the values of property group `g` of `from` onto `to`, with the variables bound to them.
+pub(crate) fn copy_group(from: &Node, to: &mut Node, g: &str) {
+    if from.bound.iter().chain(to.bound.iter()).any(|(k, _)| binding_group(k) == Some(g)) {
+        to.bound.retain(|k, _| binding_group(k) != Some(g));
+        to.bound.extend(bindings_of(from, g).map(|(k, v)| (k.clone(), v.clone())));
+    }
+    match g {
+        "fills" => {
+            to.fills = from.fills.clone();
+            to.styles.fill = from.styles.fill.clone();
+        }
+        "strokes" => {
+            to.strokes = from.strokes.clone();
+            to.stroke = from.stroke.clone();
+            to.styles.stroke = from.styles.stroke.clone();
+        }
+        "effects" => {
+            to.effects = from.effects.clone();
+            to.styles.effect = from.styles.effect.clone();
+        }
+        "opacity" => {
+            to.opacity = from.opacity;
+            to.blend = from.blend;
+        }
+        "visible" => to.visible = from.visible,
+        "name" => to.name = from.name.clone(),
+        "corners" => to.corners = from.corners,
+        "characters" => {
+            if let (NodeKind::Text(a), NodeKind::Text(b)) = (&from.kind, &mut to.kind) {
+                b.characters = a.characters.clone();
+                b.runs = a.runs.clone();
+                b.paragraphs = a.paragraphs.clone();
+            }
+        }
+        "textStyle" => {
+            if let (NodeKind::Text(a), NodeKind::Text(b)) = (&from.kind, &mut to.kind) {
+                b.style = a.style.clone();
+                b.runs = a.runs.clone();
+                b.auto_resize = a.auto_resize;
+                b.align_h = a.align_h;
+                b.align_v = a.align_v;
+                b.paragraph_spacing = a.paragraph_spacing;
+                b.paragraph_indent = a.paragraph_indent;
+                b.list = a.list;
+                b.paragraphs = a.paragraphs.clone();
+                b.list_spacing = a.list_spacing;
+                b.hanging_punctuation = a.hanging_punctuation;
+                b.hanging_list = a.hanging_list;
+                b.max_lines = a.max_lines;
+                b.features = a.features.clone();
+            }
+            to.styles.text = from.styles.text.clone();
+        }
+        "padding" | "gap" | "alignment" => {
+            if let (Some(a), Some(b)) = (&from.layout, &mut to.layout) {
+                match g {
+                    "padding" => b.padding = a.padding,
+                    "gap" => (b.gap, b.cross_gap) = (a.gap, a.cross_gap),
+                    _ => (b.main_align, b.cross_align, b.content_align) = (a.main_align, a.cross_align, a.content_align),
+                }
+            }
+        }
+        "grids" => {
+            to.grids = from.grids.clone();
+            to.styles.grid = from.styles.grid.clone();
+        }
+        "exports" => to.exports = from.exports.clone(),
+        "interactions" => to.interactions = from.interactions.clone(),
+        "size" => {
+            to.width = from.width;
+            to.height = from.height;
+            if let (NodeKind::Text(a), NodeKind::Text(b)) = (&from.kind, &mut to.kind) {
+                b.auto_resize = a.auto_resize;
+            }
+        }
+        "resizing" => {
+            let (a, b) = (&from.child_layout, &mut to.child_layout);
+            (b.sizing_h, b.sizing_v, b.min_w, b.max_w, b.min_h, b.max_h) = (a.sizing_h, a.sizing_v, a.min_w, a.max_w, a.min_h, a.max_h);
+        }
+        "position" => to.transform = from.transform,
+        "modes" => to.var_modes = from.var_modes.clone(),
+        "component" => {
+            if let (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) = (&from.kind, &mut to.kind) {
+                *b = *a;
+            }
+        }
+        "props" => {
+            if let (NodeKind::Instance { props: a, .. }, NodeKind::Instance { props: b, .. }) = (&from.kind, &mut to.kind) {
+                *b = a.clone();
+            }
+            carry_prop_bindings(from, to);
+        }
+        _ => {}
+    }
+}
+
+/// Layer name paths below `root` ("Frame/Label", with `#n` for same-named siblings). With
+/// `src_names` (an instance's layers), layers are named after the main layer they mirror (renames
+/// don't break matching), and the content of slots holding the instance's own is left out.
+pub(super) fn path_map(doc: &Document, root: NodeId, src_names: bool) -> BTreeMap<NodeId, String> {
+    let mut out = BTreeMap::new();
+    let mut stack = vec![(root, String::new())];
+    while let Some((id, prefix)) = stack.pop() {
+        let Some(n) = doc.node(id) else { continue };
+        let mut seen: BTreeMap<&str, usize> = BTreeMap::new();
+        for c in &n.children {
+            let Some(cn) = doc.node(*c) else { continue };
+            // A nested instance linked only to its own component so far (an imported one) mirrors no
+            // layer yet: it goes by its own name, like the main's layer it will be matched with.
+            let unplaced = matches!(&cn.kind, NodeKind::Instance { component, .. } if cn.source == Some(*component));
+            let mirrored = cn.source.filter(|_| src_names && !unplaced).and_then(|s| doc.node(s));
+            let name = mirrored.map_or(cn.name.as_str(), |s| s.name.as_str());
+            let k = seen.entry(name).or_insert(0);
+            let seg = if *k == 0 { name.to_string() } else { format!("{name}#{k}") };
+            *k += 1;
+            let path = if prefix.is_empty() { seg } else { format!("{prefix}/{seg}") };
+            out.insert(*c, path.clone());
+            if out.len() > 1_000_000 {
+                return out;
+            }
+            if !(src_names && holds_content(cn)) {
+                stack.push((*c, path));
+            }
+        }
+    }
+    out
+}
+
+/// The binding key prefix of an instance's component property value
+/// (`componentProperties/<name>`): a boolean property takes a boolean variable, a text property a
+/// string variable.
+pub const PROP_BINDING: &str = "componentProperties/";
+
+/// Give `to` the component property bindings of instance `from` (they go with its property
+/// values, which an instance keeps across rebuilds).
+pub(super) fn carry_prop_bindings(from: &Node, to: &mut Node) {
+    to.bound.retain(|k, _| !k.starts_with(PROP_BINDING));
+    to.bound.extend(from.bound.iter().filter(|(k, _)| k.starts_with(PROP_BINDING)).map(|(k, v)| (k.clone(), v.clone())));
+}
+
+/// The override group a property-bound field belongs to.
+pub(super) fn field_group(field: &str) -> &'static str {
+    match field {
+        "visible" => "visible",
+        "characters" => "characters",
+        "mainComponent" => "component",
+        _ => "",
+    }
+}
+
+/// Apply one component-property value to a layer.
+pub(super) fn apply_prop(doc: &Document, n: &mut Node, field: &str, val: &Value) {
+    match field {
+        "visible" => {
+            if let Some(b) = val.as_bool() {
+                n.visible = b;
+            }
+        }
+        "characters" => {
+            if let (NodeKind::Text(t), Some(sv)) = (&mut n.kind, val.as_str().map(crate::cmd::props::normalize_line_endings))
+                && t.characters != sv
+            {
+                let len = t.char_count();
+                t.replace_range(0, len, &sv);
+            }
+        }
+        "mainComponent" => {
+            if let (NodeKind::Instance { component: c, .. }, Some(v)) = (&mut n.kind, crate::params::id_of(val))
+                && doc.node(v).is_some_and(|m| matches!(m.kind, NodeKind::Component { .. }))
+            {
+                *c = v;
+            }
+        }
+        _ => {}
+    }
+}
+
+/// Rebuild instance `inst` from its main component, keeping ids, overrides and the content of its
+/// slots. An instance whose main component was deleted keeps its layers as they are.
+pub fn sync_instance(doc: &mut Document, inst: NodeId) {
+    // Layers the rebuild leaves as they were keep their shared snapshot (and aren't edits).
+    let old: Vec<(std::sync::Arc<Node>, bool)> =
+        doc.subtree(inst).into_iter().filter_map(|i| doc.node_arc(i).map(|a| (a.clone(), doc.dirty().contains(&i)))).collect();
+    let kept = slot_content(doc, inst);
+    sync_instance_depth(doc, inst, 0, BTreeMap::new());
+    restore_slot_content(doc, kept);
+    for (a, was_dirty) in old {
+        doc.keep_if_unchanged(a, was_dirty);
+    }
+}
+
+/// The slots in instance `inst` (nested instances included) holding the instance's own content:
+/// each with its content (the subtrees of its children, pre-order).
+fn slot_content(doc: &Document, inst: NodeId) -> Vec<(NodeId, Vec<Node>)> {
+    let mut out = Vec::new();
+    let mut stack: Vec<NodeId> = doc.node(inst).map(|n| n.children.clone()).unwrap_or_default();
+    while let Some(c) = stack.pop() {
+        let Some(n) = doc.node(c) else { continue };
+        if holds_content(n) {
+            let nodes = n.children.iter().flat_map(|k| doc.subtree(*k)).filter_map(|d| doc.node(d).cloned()).collect();
+            out.push((c, nodes));
+        } else {
+            stack.extend(n.children.iter().copied());
+        }
+    }
+    out
+}
+
+/// Put slot content back after a rebuild, into the slots that still hold the instance's own
+/// content (a slot the main no longer has, or no longer marks as a slot, loses it). Constraints
+/// and geometry overrides ran before, so the content keeps its place.
+fn restore_slot_content(doc: &mut Document, kept: Vec<(NodeId, Vec<Node>)>) {
+    for (slot, nodes) in kept {
+        let keep = slot_edited(doc, slot) && is_slot(doc, slot) && nodes.iter().all(|n| !doc.contains(n.id));
+        if !keep {
+            continue;
+        }
+        let ids: Vec<NodeId> = nodes.iter().map(|n| n.id).collect();
+        for n in nodes {
+            // Pre-order: every parent is back before its children.
+            let _ = insert_linked(doc, n);
+        }
+        // Never leave links to a layer that couldn't come back.
+        for id in ids.into_iter().chain([slot]) {
+            let dangling = doc.node(id).is_some_and(|n| n.children.iter().any(|c| !doc.contains(*c)));
+            if dangling {
+                let live: Vec<NodeId> = doc.node(id).map(|n| n.children.iter().copied().filter(|c| doc.contains(*c)).collect()).unwrap_or_default();
+                if let Some(n) = doc.node_mut(id) {
+                    n.children = live;
+                }
+            }
+        }
+    }
+}
diff --git a/crates/engine/src/assets/components/patch.rs b/crates/engine/src/assets/components/patch.rs
new file mode 100644
index 00000000..8c61f0b8
--- /dev/null
+++ b/crates/engine/src/assets/components/patch.rs
@@ -0,0 +1,528 @@
+use super::diff::{binding_group, bindings_of, diff_groups, follow_boolean_defaults, geometry_derived, variable_groups};
+use super::guard::{own_slot_content, relink_copy};
+use super::instances::{copy_group, field_group, sync_instance};
+use super::sync::insert_linked;
+use super::*;
+
+/// After an edit: record overrides inside instances, then rebuild instances whose main changed,
+/// whose properties or main were switched, or whose overrides were reset.
+pub fn sync_after_edit(doc: &mut Document, before: &Document, changed: &[NodeId], touched: &BTreeSet<NodeId>) {
+    let mut changed = changed.to_vec();
+    for id in follow_boolean_defaults(doc, before, &changed) {
+        if !changed.contains(&id) {
+            changed.push(id);
+        }
+    }
+    let changed = changed.as_slice();
+    // 0. A slot whose layers were added, removed or reordered holds the instance's own content
+    //    from now on; copies of instance layers placed elsewhere stop mirroring their main.
+    for &id in changed {
+        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
+        if n.children == b.children || owning_instance(doc, id).is_none() {
+            continue;
+        }
+        if let Some(slot) = slot_scope(doc, id)
+            && !slot_edited(doc, slot)
+        {
+            own_slot_content(doc, slot);
+        }
+    }
+    for &id in changed {
+        if !before.contains(id) {
+            relink_copy(doc, id);
+        }
+    }
+    let mut resync: BTreeSet<NodeId> = BTreeSet::new();
+    // 1. Overrides for layers edited inside instances.
+    for &id in changed {
+        let (Some(n), Some(b)) = (doc.node(id), before.node(id)) else { continue };
+        let Some(inst) = owning_instance(doc, id) else { continue };
+        let top_root = inst == id && !inside_instance(doc, id);
+        if top_root
+            && let (NodeKind::Instance { component: c1, props: p1 }, NodeKind::Instance { component: c2, props: p2 }) = (&n.kind, &b.kind)
+            && (c1 != c2 || p1 != p2)
+        {
+            // Switching the main or a property value of an instance isn't an override.
+            resync.insert(id);
+        }
+        let raw = diff_groups(b, n);
+        let mut groups = raw.clone();
+        // An instance's own place, resizing, export settings, interactions and variable modes are
+        // its own, not overrides.
+        if top_root {
+            groups.retain(|g| !matches!(*g, "component" | "props" | "position" | "resizing" | "exports" | "interactions" | "modes"));
+        }
+        if groups.iter().any(|g| matches!(*g, "size" | "position")) {
+            groups.retain(|g| !matches!(*g, "size" | "position") || !geometry_derived(doc, before, id, g));
+        }
+        // A value equal to the main's isn't an override (setting it back clears the override).
+        let mut cleared = Vec::new();
+        if let Some(src) = n.source.and_then(|s| doc.node(s)) {
+            let mut differs = diff_groups(src, n);
+            if inst == id {
+                differs.retain(|g| *g != "name");
+                if n.name != default_instance_name(doc, src.id) {
+                    differs.push("name");
+                }
+            }
+            // A value from the same variable as the main's (resolved in this layer's modes) isn't an
+            // override either.
+            let from_variables = variable_groups(n, src);
+            groups.retain(|g| differs.contains(g) && !from_variables.contains(g));
+            // Binding another variable (or none) where the main binds one is an override.
+            for (k, _) in b.bound.iter().chain(n.bound.iter()) {
+                let Some(g) = binding_group(k) else { continue };
+                let rebound = b.bound.get(k) != n.bound.get(k) && !bindings_of(n, g).eq(bindings_of(src, g));
+                if rebound && !groups.contains(&g) {
+                    groups.push(g);
+                }
+            }
+            cleared =
+                raw.iter().filter(|g| !matches!(**g, "size" | "position") && !differs.contains(g) && n.overrides.contains(**g)).copied().collect();
+            if top_root {
+                cleared.retain(|g| !matches!(*g, "component" | "props"));
+            }
+        }
+        let lost = b.overrides.iter().any(|g| !n.overrides.contains(g));
+        let nested_switch = !top_root && raw.iter().any(|g| matches!(*g, "component" | "props"));
+        if (!groups.is_empty() || !cleared.is_empty())
+            && let Some(m) = doc.node_mut(id)
+        {
+            for g in groups {
+                m.overrides.insert(g.to_string());
+            }
+            for g in cleared {
+                m.overrides.remove(g);
+            }
+        }
+        if (lost || nested_switch)
+            && let Some(r) = root_instance(doc, id)
+        {
+            resync.insert(r);
+        }
+    }
+    // 2. Components whose layers changed, were added or removed. Value-only edits (paint, text,
+    //    visibility, …) are carried to the copies directly; anything else rebuilds the instances.
+    let mut comps: BTreeSet<NodeId> = BTreeSet::new();
+    let mut patches: Vec<(NodeId, Vec<&'static str>)> = Vec::new();
+    // Main layers that only gained new layers or lost some: their copies take the same change.
+    let mut restructured: Vec<NodeId> = Vec::new();
+    let mut covered: BTreeSet<NodeId> = BTreeSet::new();
+    for &id in changed {
+        if let (Some(b), Some(n)) = (before.node(id), doc.node(id))
+            && b.children != n.children
+            && owning_instance(doc, id).is_none()
+            && owning_component(doc, id).is_some()
+            && let Some(layers) = restructurable(doc, before, b, n)
+        {
+            restructured.push(id);
+            covered.extend(layers);
+        }
+    }
+    for &id in changed {
+        if covered.contains(&id) || restructured.contains(&id) {
+            continue;
+        }
+        let Some(c) = owning_component(doc, id) else { continue };
+        let (Some(b), Some(n)) = (before.node(id), doc.node(id)) else {
+            comps.insert(c);
+            continue;
+        };
+        if b == n {
+            continue;
+        }
+        match patchable(doc, b, n) {
+            Some(groups) => patches.push((id, groups)),
+            None => {
+                comps.insert(c);
+            }
+        }
+    }
+    for &id in touched {
+        if !doc.contains(id)
+            && !covered.contains(&id)
+            && let Some(c) = owning_component(before, id)
+            && doc.contains(c)
+        {
+            comps.insert(c);
+        }
+    }
+    for r in resync {
+        if doc.contains(r) {
+            sync_instance(doc, r);
+            if let Some(c) = owning_component(doc, r) {
+                comps.insert(c);
+            }
+        }
+    }
+    // A copy the patch can't follow exactly rebuilds instead (as does any other change).
+    let patched = comps.is_empty()
+        && !full_rebuild()
+        && (restructured.is_empty() || patch_structure(doc, before, &restructured))
+        && (patches.is_empty() || patch_copies(doc, &patches));
+    #[cfg(test)]
+    if patched && (!restructured.is_empty() || !patches.is_empty()) {
+        PATCHED.with(|c| c.set(c.get() + 1));
+    }
+    if !patched {
+        comps.extend(patches.iter().map(|(id, _)| *id).chain(restructured.iter().copied()).filter_map(|id| owning_component(doc, id)));
+    }
+    // 3. Instances of changed components follow; an instance inside another component makes that
+    //    one change too.
+    rebuild_instances(doc, &comps);
+}
+
+#[cfg(test)]
+thread_local! {
+    /// Tests: rebuild instances even for edits that could be patched (to compare both ways).
+    pub(crate) static FULL_REBUILD: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+    /// Tests: edits carried to the copies without rebuilding instances.
+    pub(crate) static PATCHED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+#[cfg(test)]
+fn full_rebuild() -> bool {
+    FULL_REBUILD.with(std::cell::Cell::get)
+}
+
+#[cfg(not(test))]
+fn full_rebuild() -> bool {
+    false
+}
+
+/// The property groups of a main-component layer edited from `b` to `n` when the edit changed
+/// values only (paint, text, visibility, size, position, …) that copies take as they are: carried to them without
+/// rebuilding the instances ([`patch_copies`]). `None` when anything else changed.
+fn patchable(doc: &Document, b: &Node, n: &Node) -> Option<Vec<&'static str>> {
+    const VALUES: [&str; 17] = [
+        "fills",
+        "strokes",
+        "effects",
+        "opacity",
+        "visible",
+        "name",
+        "corners",
+        "characters",
+        "textStyle",
+        "padding",
+        "gap",
+        "alignment",
+        "grids",
+        "exports",
+        "interactions",
+        "size",
+        "position",
+    ];
+    if b.children != n.children || b.parent != n.parent || b.kind.type_name() != n.kind.type_name() {
+        return None;
+    }
+    let groups = diff_groups(b, n);
+    if groups.is_empty() || groups.iter().any(|g| !VALUES.contains(g)) {
+        return None;
+    }
+    // Exactly those groups (and the layer's own overrides) changed.
+    let mut probe = n.clone();
+    for g in &groups {
+        copy_group(b, &mut probe, g);
+    }
+    probe.overrides = b.overrides.clone();
+    if probe != *b {
+        return None;
+    }
+    // Values a component property sets (on this layer or a main it mirrors) come from instances.
+    let mut cur = Some(n);
+    for _ in 0..=MAX_DEPTH {
+        let Some(x) = cur else { break };
+        if x.prop_refs.keys().any(|f| groups.contains(&field_group(f))) {
+            return None;
+        }
+        cur = x.source.and_then(|s| doc.node(s));
+    }
+    Some(groups)
+}
+
+/// Copies by the layer they mirror; nested instances swapped to a main also follow it.
+fn copies_index(doc: &Document) -> BTreeMap<NodeId, Vec<NodeId>> {
+    let mut copies: BTreeMap<NodeId, Vec<NodeId>> = BTreeMap::new();
+    for n in doc.nodes() {
+        let Some(s) = n.source else { continue };
+        copies.entry(s).or_default().push(n.id);
+        if let (NodeKind::Instance { component, .. }, Some(NodeKind::Instance { component: other, .. })) = (&n.kind, doc.node(s).map(|x| &x.kind))
+            && component != other
+        {
+            copies.entry(*component).or_default().push(n.id);
+        }
+    }
+    copies
+}
+
+/// When main layer `b` → `n` only gained new plain layers (created in this edit: no instances,
+/// components or property bindings in them) or lost layers that were deleted: those layers, which
+/// [`patch_structure`] carries to the copies. `None` for anything else.
+fn restructurable(doc: &Document, before: &Document, b: &Node, n: &Node) -> Option<Vec<NodeId>> {
+    let mut probe = n.clone();
+    probe.children = b.children.clone();
+    probe.overrides = b.overrides.clone();
+    if probe != *b {
+        return None;
+    }
+    let mut layers = Vec::new();
+    for c in n.children.iter().filter(|c| !b.children.contains(c)) {
+        for d in doc.subtree(*c) {
+            let x = doc.node(d)?;
+            let plain = !matches!(x.kind, NodeKind::Instance { .. } | NodeKind::Component { .. } | NodeKind::ComponentSet { .. });
+            if before.contains(d) || !plain || !x.prop_refs.is_empty() {
+                return None;
+            }
+            layers.push(d);
+        }
+    }
+    for c in b.children.iter().filter(|c| !n.children.contains(c)) {
+        if doc.contains(*c) {
+            return None;
+        }
+        layers.extend(before.subtree(*c));
+    }
+    Some(layers)
+}
+
+/// Carry the new and deleted layers of main layers `seeds` ([`restructurable`]) to every copy,
+/// through copies of copies (slots holding an instance's own content keep it). Returns false
+/// (leaving a partial patch for the caller to rebuild over) when a copy can't follow exactly.
+fn patch_structure(doc: &mut Document, before: &Document, seeds: &[NodeId]) -> bool {
+    let copies = copies_index(doc);
+    let mut work: Vec<NodeId> = seeds.to_vec();
+    let mut steps = 0usize;
+    while let Some(p) = work.pop() {
+        steps += 1;
+        if steps > 10_000_000 {
+            return false;
+        }
+        let Some(pn) = doc.node(p).cloned() else { continue };
+        for c in copies.get(&p).cloned().unwrap_or_default() {
+            let Some(cn) = doc.node(c).cloned() else { continue };
+            if holds_content(&cn) {
+                continue;
+            }
+            if let (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) = (&pn.kind, &cn.kind)
+                && a != b
+            {
+                continue;
+            }
+            // The copy's layers by the layer of `p` they mirror.
+            let mut mirrors: BTreeMap<NodeId, NodeId> = BTreeMap::new();
+            for k in &cn.children {
+                let Some(src) = doc.node(*k).and_then(|x| x.source) else { return false };
+                if mirrors.insert(src, *k).is_some() {
+                    return false;
+                }
+            }
+            let mut order = Vec::with_capacity(pn.children.len());
+            for pc in &pn.children {
+                if let Some(k) = mirrors.remove(pc) {
+                    order.push(k);
+                    continue;
+                }
+                // A layer the copy lacks must be new in this edit, placed as in the main.
+                let absolute = doc.node(*pc).is_some_and(|x| x.child_layout.absolute);
+                if before.contains(*pc) || !child_follows_main(doc, c, absolute) {
+                    return false;
+                }
+                match copy_layers(doc, *pc, c) {
+                    Some(k) => order.push(k),
+                    None => return false,
+                }
+            }
+            // Copies of layers the main lost.
+            for (src, k) in mirrors {
+                if doc.contains(src) || doc.remove(k).is_err() {
+                    return false;
+                }
+            }
+            if doc.node(c).is_some_and(|x| x.children != order)
+                && let Some(m) = doc.node_mut(c)
+            {
+                m.children = order;
+            }
+            work.push(c);
+        }
+    }
+    true
+}
+
+/// Whether a layer placed in copy `parent` (absolutely positioned or not) takes its main layer's
+/// place and size: nothing on the way up applies constraints ([`follows_main_geometry`]).
+fn child_follows_main(doc: &Document, parent: NodeId, absolute: bool) -> bool {
+    let Some(p) = doc.node(parent) else { return false };
+    let constrains = p.layout.is_none() || absolute;
+    let resized = sized_own(p)
+        || match &p.kind {
+            NodeKind::Instance { component, .. } => {
+                doc.node(*component).is_none_or(|m| (m.width - p.width).abs() > 1e-9 || (m.height - p.height).abs() > 1e-9)
+            }
+            _ => false,
+        };
+    !(constrains && resized) && follows_main_geometry(doc, parent)
+}
+
+/// Copy main layer `src` (with its layers) into copy `parent` as layers mirroring them; returns the
+/// new copy (the caller places it among `parent`'s layers).
+fn copy_layers(doc: &mut Document, src: NodeId, parent: NodeId) -> Option<NodeId> {
+    let sub = doc.subtree(src);
+    let map: BTreeMap<NodeId, NodeId> = sub.iter().map(|d| (*d, doc.alloc_id())).collect();
+    for d in &sub {
+        let mut n = doc.node(*d)?.clone();
+        n.id = *map.get(d)?;
+        n.parent = if *d == src { Some(parent) } else { n.parent.and_then(|x| map.get(&x).copied()) };
+        n.children = n.children.iter().filter_map(|k| map.get(k).copied()).collect();
+        n.source = Some(*d);
+        n.overrides.clear();
+        n.prop_refs.clear();
+        n.annotations.clear();
+        n.measurements.clear();
+        insert_linked(doc, n).ok()?;
+    }
+    map.get(&src).copied()
+}
+
+/// Carry value-only edits of main-component layers (`seeds`: layer, groups) to every copy, through
+/// copies of copies, except where a copy overrides the group. Returns false (leaving a partial
+/// patch for the caller to rebuild over) when a copy can't follow exactly.
+fn patch_copies(doc: &mut Document, seeds: &[(NodeId, Vec<&'static str>)]) -> bool {
+    let copies = copies_index(doc);
+    let text = |g: &str| matches!(g, "characters" | "textStyle");
+    let mut work: Vec<(NodeId, Vec<&'static str>)> = seeds.to_vec();
+    let mut steps = 0usize;
+    while let Some((p, groups)) = work.pop() {
+        steps += 1;
+        if steps > 10_000_000 {
+            return false;
+        }
+        let Some(pn) = doc.node(p).cloned() else { continue };
+        for c in copies.get(&p).cloned().unwrap_or_default() {
+            let Some(cn) = doc.node(c) else { continue };
+            // A swapped nested instance shows its own main, not the layer it stands in for.
+            if let (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) = (&pn.kind, &cn.kind)
+                && a != b
+            {
+                continue;
+            }
+            // An instance keeps its own visibility, place, export settings and interactions; its
+            // name follows the main's unless renamed; a resized one lays its layers out against
+            // the main's size.
+            let root = matches!(pn.kind, NodeKind::Component { .. });
+            if root && ((groups.contains(&"name") && !cn.overrides.contains("name")) || (groups.contains(&"size") && cn.overrides.contains("size"))) {
+                return false;
+            }
+            let gs: Vec<&'static str> = groups
+                .iter()
+                .copied()
+                .filter(|g| !(cn.overrides.contains(*g) || root && matches!(*g, "visible" | "name" | "position" | "exports" | "interactions")))
+                .collect();
+            if gs.is_empty() {
+                continue;
+            }
+            let geometry = gs.iter().any(|g| matches!(*g, "size" | "position"));
+            if geometry && !follows_main_geometry(doc, c) {
+                return false;
+            }
+            // Text content and style share their runs: a copy overriding one keeps its runs when the
+            // other follows the main (as a rebuild carries them).
+            let runs = match &cn.kind {
+                NodeKind::Text(t) if gs.iter().any(|g| text(g)) && cn.overrides.iter().any(|g| text(g)) => Some(t.runs.clone()),
+                _ => None,
+            };
+            if let Some(m) = doc.node_mut(c) {
+                for g in &gs {
+                    copy_group(&pn, m, g);
+                }
+                if let (Some(r), NodeKind::Text(t)) = (runs, &mut m.kind) {
+                    t.runs = r;
+                }
+            }
+            if (geometry || gs.iter().any(|g| text(g)))
+                && let Some((w, h)) = doc.node(c).and_then(figcraft_text::auto_size)
+                && doc.node(c).is_some_and(|n| (n.width - w).abs() > 1e-6 || (n.height - h).abs() > 1e-6)
+            {
+                figcraft_layout::set_size(doc, c, w, h);
+            }
+            work.push((c, gs));
+        }
+    }
+    true
+}
+
+/// Whether a copy's size and place are its main layer's: no layer around it inside its instances
+/// applies constraints on the way down to it (a resized instance or frame without auto layout, or
+/// a resized auto layout instance holding it absolutely positioned). Auto layout re-flows the rest.
+fn follows_main_geometry(doc: &Document, id: NodeId) -> bool {
+    let chain = scope(doc, id);
+    chain.windows(2).all(|w| {
+        let (Some(below), Some(a)) = (w.first().and_then(|i| doc.node(*i)), w.get(1).and_then(|i| doc.node(*i))) else { return false };
+        let constrains = a.layout.is_none() || below.child_layout.absolute;
+        if sized_own(a) && constrains {
+            return false;
+        }
+        match &a.kind {
+            NodeKind::Instance { component, .. } => {
+                !constrains || doc.node(*component).is_some_and(|m| (m.width - a.width).abs() <= 1e-9 && (m.height - a.height).abs() <= 1e-9)
+            }
+            _ => true,
+        }
+    })
+}
+
+/// Whether a layer inside an instance overrides its size or resizing: it may not have its main
+/// layer's size, so the layers in it can't take their main layers' places as they are.
+fn sized_own(n: &Node) -> bool {
+    n.overrides.contains("size") || n.overrides.contains("resizing")
+}
+
+/// Rebuild every instance of `comps` (and of the components that hold those instances, and so on
+/// outwards), each outermost instance once, inner components first.
+fn rebuild_instances(doc: &mut Document, comps: &BTreeSet<NodeId>) {
+    if comps.is_empty() {
+        return;
+    }
+    // Outermost instances by the components their layers instantiate.
+    let mut roots_of: BTreeMap<NodeId, BTreeSet<NodeId>> = BTreeMap::new();
+    for n in doc.nodes() {
+        if let NodeKind::Instance { component, .. } = &n.kind {
+            roots_of.entry(*component).or_default().insert(root_instance(doc, n.id).unwrap_or(n.id));
+        }
+    }
+    // Affected components, with how deep their dependencies go (an instance inside component X of
+    // component Y: X follows Y).
+    let mut level: BTreeMap<NodeId, usize> = comps.iter().map(|c| (*c, 0)).collect();
+    let mut outer: BTreeMap<NodeId, Option<NodeId>> = BTreeMap::new();
+    let mut frontier: Vec<NodeId> = comps.iter().copied().collect();
+    let mut rounds = 0;
+    while !frontier.is_empty() && rounds < 64 {
+        rounds += 1;
+        let mut next = Vec::new();
+        for c in frontier {
+            let lc = level.get(&c).copied().unwrap_or(0);
+            for r in roots_of.get(&c).into_iter().flatten() {
+                let o = *outer.entry(*r).or_insert_with(|| owning_component(doc, *r));
+                if let Some(x) = o
+                    && x != c
+                {
+                    let lx = level.entry(x).or_insert(0);
+                    if *lx < lc + 1 {
+                        *lx = lc + 1;
+                        next.push(x);
+                    }
+                }
+            }
+        }
+        frontier = next;
+    }
+    // Instances inside components by level, then the rest (each once).
+    let mut order: Vec<(usize, NodeId)> = outer.iter().map(|(r, o)| (o.and_then(|x| level.get(&x).copied()).unwrap_or(usize::MAX), *r)).collect();
+    order.sort();
+    for (_, r) in order {
+        if doc.contains(r) {
+            sync_instance(doc, r);
+        }
+    }
+}
diff --git a/crates/engine/src/assets/components/rebase.rs b/crates/engine/src/assets/components/rebase.rs
new file mode 100644
index 00000000..748a99d3
--- /dev/null
+++ b/crates/engine/src/assets/components/rebase.rs
@@ -0,0 +1,249 @@
+use super::diff::{diff_groups, variable_groups};
+use super::instances::{field_group, path_map};
+use super::*;
+
+/// Bounded source and parent lookups while a rebase reads an unchanged document.
+pub(super) struct RebaseSources<'a> {
+    doc: &'a Document,
+    chains: BTreeMap<NodeId, Option<Vec<NodeId>>>,
+    parents: BTreeMap<(NodeId, NodeId), Option<bool>>,
+    main_changes: BTreeMap<NodeId, bool>,
+}
+
+impl<'a> RebaseSources<'a> {
+    const PARENTS: usize = 512;
+    const CACHE: usize = 8192;
+
+    pub(super) fn new(doc: &'a Document) -> Self {
+        Self { doc, chains: BTreeMap::new(), parents: BTreeMap::new(), main_changes: BTreeMap::new() }
+    }
+
+    fn chain(&mut self, source: NodeId) -> Option<Vec<NodeId>> {
+        if let Some(chain) = self.chains.get(&source) {
+            return chain.clone();
+        }
+        let read = || {
+            let mut chain = Vec::new();
+            let mut seen = BTreeSet::new();
+            let mut current = Some(source);
+            for _ in 0..MAX_DEPTH {
+                let Some(id) = current else { return Some(chain) };
+                if !seen.insert(id) {
+                    return None;
+                }
+                let n = self.doc.node(id)?;
+                chain.push(id);
+                current = n.source;
+            }
+            current.is_none().then_some(chain)
+        };
+        let chain = read();
+        if self.chains.len() < Self::CACHE {
+            self.chains.insert(source, chain.clone());
+        }
+        chain
+    }
+
+    /// Validate the complete parent chain, even if `main` was found before a cycle.
+    fn in_main(&mut self, id: NodeId, main: NodeId) -> Option<bool> {
+        if let Some(found) = self.parents.get(&(id, main)) {
+            return *found;
+        }
+        let read = || {
+            let mut current = Some(id);
+            let mut seen = BTreeSet::new();
+            let mut found = false;
+            for _ in 0..Self::PARENTS {
+                let Some(id) = current else { return Some(found) };
+                if !seen.insert(id) {
+                    return None;
+                }
+                found |= id == main;
+                current = self.doc.node(id)?.parent;
+            }
+            current.is_none().then_some(found)
+        };
+        let found = read();
+        if self.parents.len() < Self::CACHE {
+            self.parents.insert((id, main), found);
+        }
+        found
+    }
+
+    fn member(&mut self, source: NodeId, main: NodeId, target: NodeId) -> Option<NodeId> {
+        let chain = self.chain(source)?;
+        if chain.contains(&target) {
+            return None;
+        }
+        let mut member = None;
+        for id in chain {
+            if self.in_main(id, main)? && id != main && member.is_none() {
+                member = Some(id);
+            }
+        }
+        member
+    }
+
+    /// Nearest enclosing instances and their current mains. Slots with own content end scope.
+    pub(super) fn owners(&self, id: NodeId) -> Option<Vec<(NodeId, NodeId)>> {
+        let mut owners = Vec::new();
+        let mut current = self.doc.node(id)?.parent;
+        let mut seen = BTreeSet::from([id]);
+        for _ in 0..Self::PARENTS {
+            let Some(id) = current else { return Some(owners) };
+            if !seen.insert(id) {
+                return None;
+            }
+            let n = self.doc.node(id)?;
+            if holds_content(n) {
+                return Some(owners);
+            }
+            if let NodeKind::Instance { component, .. } = &n.kind {
+                owners.push((id, *component));
+            }
+            current = n.parent;
+        }
+        current.is_none().then_some(owners)
+    }
+
+    fn contextual(&mut self, source: NodeId, owners: &[(NodeId, NodeId)]) -> bool {
+        owners.iter().any(|(_, main)| self.in_main(source, *main) == Some(true) && source != *main)
+    }
+
+    /// A contextual child belongs to the same placed slot as its enclosing instance.
+    fn valid(&mut self, source: NodeId, target: NodeId, owners: &[(NodeId, NodeId)]) -> bool {
+        let Some((owner, main)) = owners.first() else { return false };
+        if self.member(source, *main, target).is_none() {
+            return false;
+        }
+        if self.in_main(source, *main) == Some(true) {
+            return true;
+        }
+        let Some(source_owner) = self.doc.node(*owner).and_then(|n| n.source) else { return false };
+        matches!(self.doc.node(source_owner).map(|n| &n.kind), Some(NodeKind::Instance { component, .. }) if component == main)
+            && self.owners(source).and_then(|owners| owners.first().copied()).is_some_and(|(id, _)| id == source_owner)
+    }
+
+    fn placed(&mut self, id: NodeId, owners: &[(NodeId, NodeId)]) -> Option<NodeId> {
+        let source = self.doc.node(id)?.source?;
+        if !matches!(self.doc.node(source)?.kind, NodeKind::Instance { .. } | NodeKind::Frame)
+            || !self.valid(source, id, owners)
+            || !self.contextual(source, owners)
+        {
+            return None;
+        }
+        Some(source)
+    }
+
+    fn beneath_swap(&mut self, owners: &[(NodeId, NodeId)], stop: NodeId) -> bool {
+        for (index, (id, main)) in owners.iter().enumerate() {
+            if *id == stop {
+                break;
+            }
+            let changed = if let Some(changed) = self.main_changes.get(id) {
+                *changed
+            } else {
+                let changed = self.placed(*id, &owners[index + 1..]).is_some_and(|source| match self.doc.node(source).map(|n| &n.kind) {
+                    Some(NodeKind::Instance { component, .. }) => component != main,
+                    Some(NodeKind::Frame) => true,
+                    _ => false,
+                });
+                if self.main_changes.len() < Self::CACHE {
+                    self.main_changes.insert(*id, changed);
+                }
+                changed
+            };
+            if changed {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+/// Re-derive `source` links and overrides of instance `inst` against its own main by comparing
+/// values (after detaching an outer instance, restoring a main, or copying a nested instance out):
+/// the look is kept exactly. Values a component property sets aren't overrides.
+pub fn rebase_instance(doc: &mut Document, inst: NodeId) {
+    let Some(NodeKind::Instance { component, .. }) = doc.node(inst).map(|n| n.kind.clone()) else { return };
+    let mine = path_map(doc, inst, true);
+    let theirs: BTreeMap<String, NodeId> =
+        if doc.contains(component) { path_map(doc, component, false).into_iter().map(|(k, v)| (v, k)).collect() } else { BTreeMap::new() };
+    let value_groups = |a: &Node, b: &Node| -> Vec<String> {
+        diff_groups(a, b).into_iter().filter(|g| !matches!(*g, "size" | "position")).map(str::to_string).collect()
+    };
+    let mut updates = Vec::new();
+    let mut sources = RebaseSources::new(doc);
+    let root_owners = sources.owners(inst).unwrap_or_default();
+    let placed_source = sources.placed(inst, &root_owners);
+    let mut contexts = vec![(inst, component)];
+    contexts.extend_from_slice(&root_owners);
+    for (id, path) in &mine {
+        let Some(n) = doc.node(*id) else { continue };
+        let owners = sources.owners(*id).unwrap_or_default();
+        let nearest_main = owners.first().map(|(_, main)| *main);
+        let valid_source = n.source.filter(|source| sources.valid(*source, *id, &owners));
+        let mut main = valid_source.and_then(|source| sources.member(source, component, *id));
+        // A swapped or Frame-to-Instance subtree is compared to its current main by the inner
+        // rebase. An outer name path must not rebind those children to the old expanded copies.
+        if main.is_none() && valid_source.is_some() && sources.beneath_swap(&owners, inst) {
+            updates.push((*id, valid_source, n.overrides.clone()));
+            continue;
+        }
+        main = main
+            .or_else(|| theirs.get(path).copied().filter(|source| nearest_main.is_some_and(|scope| sources.member(*source, scope, *id).is_some())));
+        let source = valid_source.filter(|source| sources.contextual(*source, &contexts)).filter(|_| main.is_some()).or(main);
+        let mut overrides: BTreeSet<String> = n.overrides.iter().filter(|g| !matches!(g.as_str(), "component" | "props")).cloned().collect();
+        if let Some(m) = source.and_then(|source| doc.node(source)) {
+            let mut bound: Vec<&str> = m.prop_refs.keys().map(|f| field_group(f)).collect();
+            bound.extend(variable_groups(n, m));
+            overrides.extend(value_groups(m, n).into_iter().filter(|g| !bound.contains(&g.as_str())));
+            if matches!((&m.kind, &n.kind), (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) if a != b) {
+                overrides.insert("component".into());
+            }
+        }
+        updates.push((*id, source, overrides));
+    }
+    // A placed nested root compares to its actual slot. A detached root compares to its own main.
+    let root_base = placed_source.or_else(|| {
+        let chain = sources.chain(component)?;
+        (!chain.contains(&inst) && sources.in_main(component, inst) == Some(false)).then_some(component)
+    });
+    let root_groups = match (root_base.and_then(|source| doc.node(source)), doc.node(inst)) {
+        (Some(m), Some(n)) => {
+            let from_variables = variable_groups(n, m);
+            let mut groups: Vec<String> = value_groups(m, n)
+                .into_iter()
+                .filter(|g| !matches!(g.as_str(), "name" | "exports" | "interactions") && !from_variables.contains(&g.as_str()))
+                .filter(|g| placed_source.is_some() || !matches!(g.as_str(), "resizing" | "modes"))
+                .collect();
+            let named = if placed_source.is_some() { n.name != m.name } else { n.name != default_instance_name(doc, component) };
+            if named {
+                groups.push("name".into());
+            }
+            if placed_source.is_some()
+                && matches!((&m.kind, &n.kind), (NodeKind::Instance { component: a, .. }, NodeKind::Instance { component: b, .. }) if a != b)
+            {
+                groups.push("component".into());
+            }
+            groups
+        }
+        _ => Vec::new(),
+    };
+    drop(sources);
+    for (id, main, overrides) in updates {
+        if let Some(n) = doc.node_mut(id) {
+            n.source = main;
+            n.overrides = if main.is_some() { overrides } else { BTreeSet::new() };
+        }
+    }
+    if let Some(n) = doc.node_mut(inst) {
+        n.source = root_base;
+        // A top-level instance's resizing and modes are its own (a nested one's override its main
+        // layer's).
+        n.overrides.retain(|g| {
+            !matches!(g.as_str(), "component" | "props" | "position") && (placed_source.is_some() || !matches!(g.as_str(), "resizing" | "modes"))
+        });
+        n.overrides.extend(root_groups);
+    }
+}
diff --git a/crates/engine/src/assets/components/sync.rs b/crates/engine/src/assets/components/sync.rs
new file mode 100644
index 00000000..c502322d
--- /dev/null
+++ b/crates/engine/src/assets/components/sync.rs
@@ -0,0 +1,459 @@
+use super::diff::diff_groups;
+use super::instances::{Carry, apply_prop, carry_overrides, carry_prop_bindings, copy_group, field_group, follow_variant_resizing, path_map};
+use super::*;
+
+/// `spare`: layers the outer rebuild didn't reuse that were below `inst` (a swapped nested
+/// instance): its layers the outer main doesn't have, matched here so they keep ids and overrides.
+pub(super) fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize, spare: BTreeMap<NodeId, std::sync::Arc<Node>>) {
+    if depth > MAX_DEPTH {
+        return;
+    }
+    let Some(mut root) = doc.node(inst).cloned() else { return };
+    let NodeKind::Instance { component, props: root_props } = &root.kind else { return };
+    let component = *component;
+    let Some(comp) = doc.node(component).cloned() else { return };
+    if !matches!(comp.kind, NodeKind::Component { .. }) || doc.is_ancestor(inst, component) || doc.is_ancestor(component, inst) {
+        // A missing main, or an instance inside its own main (would recurse forever).
+        return;
+    }
+    let mut eff_props = default_props(&comp);
+    for (k, v) in root_props {
+        if eff_props.contains_key(k) {
+            eff_props.insert(k.clone(), v.clone());
+        }
+    }
+    // Old layers (kept alive for their overrides), by (parent, source), by source alone (when only
+    // one layer mirrors it) and, only when those don't match, by name path.
+    let mut old_ids = old_layers(doc, inst);
+    old_ids.extend(spare.keys().copied());
+    old_ids.sort();
+    old_ids.dedup();
+    let mut old: BTreeMap<NodeId, std::sync::Arc<Node>> = spare;
+    let mut by_source: BTreeMap<(NodeId, NodeId), NodeId> = BTreeMap::new();
+    let mut by_src: BTreeMap<NodeId, Option<NodeId>> = BTreeMap::new();
+    for i in &old_ids {
+        let Some(n) = doc.node_arc(*i).or_else(|| old.get(i)).cloned() else { continue };
+        if let Some(s) = n.source {
+            if let Some(p) = n.parent {
+                by_source.entry((p, s)).or_insert(*i);
+            }
+            by_src.entry(s).and_modify(|e| *e = None).or_insert(Some(*i));
+        }
+        old.insert(*i, n);
+    }
+    let mut by_path: Option<BTreeMap<String, NodeId>> = None;
+    let mut main_paths: Option<BTreeMap<NodeId, String>> = None;
+    // Ids for the copies: reuse the matching old layer's id (a layer the main moved to another
+    // parent keeps its id and overrides).
+    let src: Vec<NodeId> = doc.subtree(component).into_iter().filter(|i| *i != component).collect();
+    let mut map: BTreeMap<NodeId, NodeId> = BTreeMap::new();
+    map.insert(component, inst);
+    let mut used: BTreeSet<NodeId> = BTreeSet::new();
+    // Slots holding the instance's own content (new ids), and main layers not copied: the
+    // default content of those slots.
+    let mut edited: BTreeSet<NodeId> = BTreeSet::new();
+    let mut skipped: BTreeSet<NodeId> = BTreeSet::new();
+    let mut fresh_ids = Vec::new();
+    for s in &src {
+        let Some(sn) = doc.node(*s) else { continue };
+        if sn.parent.is_some_and(|p| skipped.contains(&p) || map.get(&p).is_some_and(|pn| edited.contains(pn))) {
+            skipped.insert(*s);
+            continue;
+        }
+        let parent_new = sn.parent.and_then(|p| map.get(&p).copied());
+        let mut found = parent_new.and_then(|pn| by_source.get(&(pn, *s)).copied()).or_else(|| by_src.get(s).copied().flatten());
+        if found.is_none() {
+            let paths = by_path.get_or_insert_with(|| path_map(doc, inst, true).into_iter().map(|(k, v)| (v, k)).collect());
+            let mains = main_paths.get_or_insert_with(|| path_map(doc, component, false));
+            found = mains.get(s).and_then(|p| paths.get(p)).copied();
+        }
+        let nid = match found {
+            Some(o) if used.insert(o) => o,
+            _ => {
+                fresh_ids.push(*s);
+                continue;
+            }
+        };
+        if let Some(m) = old.get(&nid).and_then(|o| variant_kept(doc, o, *s)) {
+            old.insert(nid, std::sync::Arc::new(m));
+        }
+        if old.get(&nid).is_some_and(|o| holds_content(o)) && is_slot(doc, *s) {
+            edited.insert(nid);
+        }
+        map.insert(*s, nid);
+    }
+    for c in root.children.clone() {
+        let _ = doc.remove(c);
+    }
+    for s in fresh_ids {
+        let nid = doc.alloc_id();
+        map.insert(s, nid);
+    }
+    // Build the copies (pre-order: parents first).
+    let mut enclosing: BTreeMap<NodeId, Vec<NodeId>> = BTreeMap::new();
+    enclosing.insert(inst, vec![inst]);
+    let mut inst_props: BTreeMap<NodeId, BTreeMap<String, Value>> = BTreeMap::new();
+    inst_props.insert(inst, eff_props);
+    let mut nested = Vec::new();
+    let mut new_nodes = Vec::new();
+    // Text layers showing other text or style than their main layer (to re-measure).
+    let mut remeasure = Vec::new();
+    for s in &src {
+        let Some(orig) = doc.node(*s) else { continue };
+        let Some(&nid) = map.get(s) else { continue };
+        let Some(parent) = orig.parent.and_then(|p| map.get(&p).copied()) else { continue };
+        let mut n = orig.clone();
+        n.id = nid;
+        n.parent = Some(parent);
+        n.children = orig.children.iter().filter_map(|c| map.get(c).copied()).collect();
+        n.source = Some(*s);
+        n.overrides.clear();
+        n.prop_refs.clear();
+        let prev = old.get(&nid);
+        // Annotations belong to the layer they were added to, not to its copies.
+        n.annotations = prev.map(|o| o.annotations.clone()).unwrap_or_default();
+        n.measurements = prev.map(|o| o.measurements.clone()).unwrap_or_default();
+        if let Some(o) = prev {
+            carry_overrides(o, &mut n, Carry::Values);
+            keep_laid_out(doc, orig, o, &mut n);
+        }
+        if !edited.contains(&nid) {
+            // No longer a slot in the main: it mirrors the main again.
+            n.overrides.remove(SLOT);
+        }
+        // Component properties: the main layer's bindings use this instance's values; layers of
+        // nested instances use the nested instance's values (one level per source hop).
+        let enc = enclosing.get(&parent).cloned().unwrap_or_default();
+        let mut chain: Vec<&Node> = vec![orig];
+        while chain.len() < enc.len() {
+            let Some(next) = chain.last().and_then(|c| c.source).and_then(|x| doc.node(x)) else { break };
+            chain.push(next);
+        }
+        for (j, level) in chain.iter().enumerate().rev() {
+            let Some(props) = enc.get(j).and_then(|e| inst_props.get(e)) else { continue };
+            for (field, prop) in &level.prop_refs {
+                let g = field_group(field);
+                if n.overrides.contains(g) || (j > 0 && orig.overrides.contains(g)) {
+                    continue;
+                }
+                if let Some(val) = props.get(prop) {
+                    apply_prop(doc, &mut n, field, val);
+                }
+            }
+        }
+        if let NodeKind::Instance { component: c, props } = &n.kind {
+            inst_props.insert(nid, props.clone());
+            let mut e = enc;
+            e.push(nid);
+            enclosing.insert(nid, e);
+            if !matches!(orig.kind, NodeKind::Instance { component: oc, .. } if oc == *c) {
+                nested.push(nid);
+            }
+        } else {
+            enclosing.insert(nid, enc);
+        }
+        if let (NodeKind::Text(a), NodeKind::Text(b)) = (&orig.kind, &n.kind)
+            && a != b
+        {
+            remeasure.push(nid);
+        }
+        new_nodes.push(n);
+    }
+    for n in new_nodes {
+        let (id, parent) = (n.id, n.parent);
+        if insert_linked(doc, n).is_err()
+            && let Some(p) = parent.and_then(|p| doc.node_mut(p))
+        {
+            p.children.retain(|c| *c != id);
+        }
+    }
+    // Root: follows the main except its own placement, name, size and overrides.
+    let order: Vec<NodeId> = comp.children.iter().filter_map(|c| map.get(c).copied()).filter(|c| doc.contains(*c)).collect();
+    let mut fresh = comp.clone();
+    fresh.id = inst;
+    fresh.parent = root.parent;
+    fresh.children = order;
+    fresh.transform = root.transform;
+    fresh.kind = root.kind.clone();
+    carry_prop_bindings(&root, &mut fresh);
+    // A nested instance keeps mirroring its layer of the outer main.
+    let nested_copy = inside_instance(doc, inst);
+    fresh.source = if nested_copy { root.source } else { Some(component) };
+    fresh.constraints = root.constraints;
+    fresh.child_layout = root.child_layout.clone();
+    fresh.interactions = root.interactions.clone();
+    fresh.exports = root.exports.clone();
+    fresh.prop_refs = root.prop_refs.clone();
+    fresh.plugin_data = root.plugin_data.clone();
+    fresh.annotations = root.annotations.clone();
+    // Code links belong to the main component; instances read them from it.
+    fresh.code_links.clear();
+    // An instance's own dev resources (its main's are listed with them, not copied).
+    fresh.dev_resources = root.dev_resources.clone();
+    fresh.measurements = root.measurements.clone();
+    fresh.locked = root.locked;
+    fresh.visible = root.visible;
+    fresh.var_modes = root.var_modes.clone();
+    fresh.is_mask = root.is_mask;
+    fresh.exposed = root.exposed;
+    fresh.guides = root.guides.clone();
+    fresh.dev_status = root.dev_status;
+    fresh.dev_changed = root.dev_changed;
+    fresh.dev_note = root.dev_note.clone();
+    fresh.constrain_proportions = root.constrain_proportions;
+    // How the instance combines in a boolean group it sits in is its own.
+    fresh.bool_op = root.bool_op;
+    // A swapped nested instance keeps the name its layer was given in the outer main.
+    let renamed = nested_copy
+        && root.source.and_then(|s| doc.node(s)).is_some_and(|s| match &s.kind {
+            NodeKind::Instance { component: c, .. } => s.name != default_instance_name(doc, *c),
+            _ => false,
+        });
+    fresh.name = if renamed { root.name.clone() } else { default_instance_name(doc, component) };
+    // Switched to another variant: its own overrides stay where both variants agreed.
+    if let Some(prev) = root.source.and_then(|p| doc.node(p)).filter(|p| sibling_variants(doc, p.id, component)) {
+        let differs = diff_groups(prev, &comp);
+        root.overrides.retain(|g| g == "name" || !differs.contains(&g.as_str()));
+        follow_variant_resizing(&mut fresh.child_layout, &prev.child_layout, &comp.child_layout);
+    }
+    carry_overrides(&root, &mut fresh, Carry::Root);
+    if let Some(r) = doc.node_mut(inst) {
+        *r = fresh;
+    }
+    // A resized instance: children follow their constraints (auto layout re-flows later).
+    let (iw, ih) = doc.node(inst).map(|n| (n.width, n.height)).unwrap_or((comp.width, comp.height));
+    if (iw - comp.width).abs() > 1e-9 || (ih - comp.height).abs() > 1e-9 {
+        figcraft_layout::apply_constraints(doc, inst, comp.width, comp.height);
+        remeasure = map.values().copied().collect();
+    }
+    // Geometry overrides of children win over constraints.
+    for s in &src {
+        let Some(nid) = map.get(s).copied() else { continue };
+        let Some(o) = old.get(&nid) else { continue };
+        // A frame that kept the size its own resizing gave it: its layers (copied at their main
+        // layers' places) follow their constraints from its main layer's size.
+        if o.overrides.contains("resizing")
+            && !o.overrides.contains("size")
+            && doc.node(nid).is_some_and(|n| n.kind.is_frame_like() && n.layout.is_none())
+            && let Some((mw, mh)) = doc.node(*s).map(|m| (m.width, m.height))
+        {
+            figcraft_layout::apply_constraints(doc, nid, mw, mh);
+        }
+        if !o.overrides.contains("size") && !o.overrides.contains("position") {
+            continue;
+        }
+        remeasure.push(nid);
+        let Some((ow, oh)) = doc.node(nid).map(|n| (n.width, n.height)) else { continue };
+        if o.overrides.contains("size") {
+            // Through set_size so vector networks scale with the box.
+            figcraft_layout::set_size(doc, nid, o.width, o.height);
+            if doc.node(nid).is_some_and(|n| n.kind.is_frame_like() && n.layout.is_none()) {
+                figcraft_layout::apply_constraints(doc, nid, ow, oh);
+            }
+        }
+        if let Some(n) = doc.node_mut(nid) {
+            carry_overrides(o, n, Carry::Geometry);
+        }
+    }
+    // Text whose characters or style differ from the main re-measures.
+    for nid in remeasure {
+        if let Some(n) = doc.node(nid)
+            && let Some((w, h)) = figcraft_text::auto_size(n)
+            && ((w - n.width).abs() > 1e-6 || (h - n.height).abs() > 1e-6)
+        {
+            figcraft_layout::set_size(doc, nid, w, h);
+        }
+    }
+    // Nested instances showing another main than the main's copy (swapped): rebuild from it,
+    // with the old layers below them this rebuild didn't reuse.
+    let unused: BTreeMap<NodeId, std::sync::Arc<Node>> =
+        old.iter().filter(|(i, _)| !used.contains(*i) && !doc.contains(**i)).map(|(i, x)| (*i, x.clone())).collect();
+    for n in nested {
+        let mut below: BTreeMap<NodeId, std::sync::Arc<Node>> = unused
+            .iter()
+            .filter(|(_, x)| {
+                let mut cur = x.parent;
+                for _ in 0..=MAX_DEPTH * 4 {
+                    match cur {
+                        Some(p) if p == n => return true,
+                        Some(p) => cur = unused.get(&p).and_then(|a| a.parent),
+                        None => return false,
+                    }
+                }
+                false
+            })
+            .map(|(i, x)| (*i, x.clone()))
+            .collect();
+        take_placing_overrides(doc, n, &old, &mut below);
+        sync_instance_depth(doc, n, depth + 1, below);
+    }
+}
+
+/// Before swapped nested instance `n` is rebuilt from its new main: each of its old layers (the
+/// copies just made of the outer main's, and `below`) takes the overrides held along the source
+/// chain it had before this rebuild (`before`), through layers inside instances in the mains that
+/// place `n`. Matched by name, they carry onto the new main's layers as the instance's own, so a
+/// swap takes what the outer main set once: later rebuilds find layers mirroring the new main.
+/// Geometry and slot content follow the new main; groups the layer overrides itself keep its value.
+fn take_placing_overrides(
+    doc: &mut Document,
+    n: NodeId,
+    before: &BTreeMap<NodeId, std::sync::Arc<Node>>,
+    below: &mut BTreeMap<NodeId, std::sync::Arc<Node>>,
+) {
+    let placing = placing_mains(doc, n);
+    for id in doc.subtree(n).into_iter().filter(|i| *i != n) {
+        let held = before.get(&id).map(|b| held_along(doc, b, &placing)).unwrap_or_default();
+        if let Some(layer) = doc.node_mut(id) {
+            take(layer, &held);
+        }
+    }
+    for layer in below.values_mut() {
+        let held = held_along(doc, layer, &placing);
+        if !held.is_empty() {
+            take(std::sync::Arc::make_mut(layer), &held);
+        }
+    }
+}
+
+/// The mains placing nested instance `n`: those of the layers it mirrors, outward.
+fn placing_mains(doc: &Document, n: NodeId) -> BTreeSet<NodeId> {
+    let mut out = BTreeSet::new();
+    let mut cur = doc.node(n).and_then(|x| x.source);
+    for _ in 0..=MAX_DEPTH {
+        let Some(s) = cur.and_then(|c| doc.node(c)).filter(|s| !matches!(s.kind, NodeKind::Component { .. })) else { break };
+        out.extend(owning_component(doc, s.id));
+        cur = s.source;
+    }
+    out
+}
+
+/// The overrides but geometry and slot content held along `layer`'s source chain while it runs
+/// through layers inside instances in `placing` mains, each with the nearest layer holding it.
+fn held_along(doc: &Document, layer: &Node, placing: &BTreeSet<NodeId>) -> BTreeMap<String, std::sync::Arc<Node>> {
+    let mut out = BTreeMap::new();
+    let mut cur = layer.source;
+    for _ in 0..=MAX_DEPTH {
+        let Some(s) = cur.and_then(|c| doc.node_arc(c)) else { break };
+        if !inside_instance(doc, s.id) || !owning_component(doc, s.id).is_some_and(|m| placing.contains(&m)) {
+            break;
+        }
+        for g in s.overrides.iter().filter(|g| !matches!(g.as_str(), "size" | "position" | SLOT)) {
+            out.entry(g.clone()).or_insert_with(|| s.clone());
+        }
+        cur = s.source;
+    }
+    out
+}
+
+/// Give `layer` the `held` groups it has no override of its own for.
+fn take(layer: &mut Node, held: &BTreeMap<String, std::sync::Arc<Node>>) {
+    for (g, from) in held {
+        if layer.overrides.insert(g.clone()) {
+            copy_group(from, layer, g);
+        }
+    }
+}
+
+/// Whether main components `a` and `b` are two variants of one set.
+fn sibling_variants(doc: &Document, a: NodeId, b: NodeId) -> bool {
+    a != b && variant_set(doc, a).is_some_and(|s| variant_set(doc, b) == Some(s))
+}
+
+/// Old copy `o` matched by name to main layer `s` of another variant (the instance switched
+/// variants): `o` without the overrides of properties the two variants' layers differ in (`None`
+/// when it keeps them all). Text layers keep every override.
+fn variant_kept(doc: &Document, o: &Node, s: NodeId) -> Option<Node> {
+    let from = o.source.filter(|f| *f != s).and_then(|f| doc.node(f))?;
+    if o.overrides.is_empty() || matches!(o.kind, NodeKind::Text(_)) {
+        return None;
+    }
+    if !sibling_variants(doc, owning_component(doc, from.id)?, owning_component(doc, s)?) {
+        return None;
+    }
+    let differs = diff_groups(from, doc.node(s)?);
+    let mut m = o.clone();
+    m.overrides.retain(|g| !differs.contains(&g.as_str()));
+    (m.overrides.len() != o.overrides.len()).then_some(m)
+}
+
+/// Drop the overrides of instance `inst` but its text layers' (and its own size and the content of
+/// its slots): what swapping it from the Assets panel keeps.
+pub fn keep_text_overrides(doc: &mut Document, inst: NodeId) {
+    for d in old_layers(doc, inst).into_iter().chain([inst]) {
+        let Some(n) = doc.node(d) else { continue };
+        let text = matches!(n.kind, NodeKind::Text(_));
+        let keep = |g: &String| text || g == SLOT || (d == inst && g == "size");
+        if !n.overrides.iter().all(keep)
+            && let Some(m) = doc.node_mut(d)
+        {
+            m.overrides.retain(keep);
+        }
+    }
+}
+
+/// Where auto layout places and sizes a rebuilt copy `n` of main layer `orig`, keep the old
+/// copy's `o` values (an instance's auto layout re-flows from its own content, so they usually
+/// differ from the main's): unchanged layers then stay unchanged, and auto layout re-flows wherever
+/// something that sizes or places layers did change.
+fn keep_laid_out(doc: &Document, orig: &Node, o: &Node, n: &mut Node) {
+    if o.parent != n.parent || o.overrides.contains("size") || o.overrides.contains("position") {
+        return;
+    }
+    let flows = !n.child_layout.absolute && orig.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some());
+    if flows {
+        // The main's rotation and skew, the old place.
+        let [a, b, c, d, _, _] = n.transform.as_coeffs();
+        let [.., e, f] = o.transform.as_coeffs();
+        n.transform = Affine::new([a, b, c, d, e, f]);
+    }
+    // Only layers whose shape is their box (a vector's points scale with it).
+    let boxed = n.kind.is_frame_like() || matches!(n.kind, NodeKind::Text(_) | NodeKind::Rectangle | NodeKind::Ellipse { .. });
+    let derived = |s: Sizing| boxed && ((s == Sizing::Hug && n.layout.is_some()) || (s == Sizing::Fill && flows));
+    if derived(n.child_layout.sizing_h) {
+        n.width = o.width;
+    }
+    if derived(n.child_layout.sizing_v) {
+        n.height = o.height;
+    }
+}
+
+/// The layers of instance `inst` a rebuild matches against (every layer below it but the content
+/// of slots holding its own), ascending.
+fn old_layers(doc: &Document, inst: NodeId) -> Vec<NodeId> {
+    let mut out = Vec::new();
+    let mut stack = vec![inst];
+    while let Some(id) = stack.pop() {
+        let Some(n) = doc.node(id) else { continue };
+        for c in &n.children {
+            out.push(*c);
+            if out.len() > 1_000_000 {
+                break;
+            }
+            if doc.node(*c).is_some_and(|cn| !holds_content(cn)) {
+                stack.push(*c);
+            }
+        }
+    }
+    out.sort();
+    out.dedup();
+    out
+}
+
+/// Insert a node whose parent/children links are already set (used when rebuilding instances).
+pub(super) fn insert_linked(doc: &mut Document, n: Node) -> Result<(), DocError> {
+    let parent = n.parent.ok_or_else(|| DocError::Invalid("no parent".into()))?;
+    let id = n.id;
+    let mut n = n;
+    let kids = std::mem::take(&mut n.children);
+    doc.insert(n, parent, None)?;
+    if let Some(m) = doc.node_mut(id) {
+        m.children = kids;
+    }
+    // The parent may already list us (its children were copied with ids): keep the first.
+    if let Some(p) = doc.node_mut(parent) {
+        let mut seen = BTreeSet::new();
+        p.children.retain(|c| seen.insert(*c));
+    }
+    Ok(())
+}
diff --git a/crates/engine/src/assets/components/variants.rs b/crates/engine/src/assets/components/variants.rs
new file mode 100644
index 00000000..40ac23ea
--- /dev/null
+++ b/crates/engine/src/assets/components/variants.rs
@@ -0,0 +1,147 @@
+use super::*;
+
+/// A set's default variant: the one in its top-left corner (nearest to it, then the top-most, then
+/// the left-most).
+pub fn default_variant(doc: &Document, set: NodeId) -> Option<NodeId> {
+    let corner = |c: &NodeId| {
+        doc.node(*c).filter(|n| matches!(n.kind, NodeKind::Component { .. })).map(|n| n.transform.as_coeffs()).map(|[.., x, y]| (x + y, y, x))
+    };
+    let kids = &doc.node(set)?.children;
+    kids.iter()
+        .copied()
+        .filter_map(|c| corner(&c).map(|k| (k, c)))
+        .min_by(|(a, _), (b, _)| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+        .map(|(_, c)| c)
+}
+
+/// Variants of a set sharing one combination of property values (each group two or more, in
+/// layer order): a conflict to resolve by giving each a unique combination.
+pub fn variant_conflicts(doc: &Document, set: NodeId) -> Vec<Vec<NodeId>> {
+    let mut by: BTreeMap<BTreeMap<String, String>, Vec<NodeId>> = BTreeMap::new();
+    for c in doc.node(set).map(|s| s.children.clone()).unwrap_or_default() {
+        if let Some(n) = doc.node(c).filter(|n| matches!(n.kind, NodeKind::Component { .. })) {
+            by.entry(variant_props(&n.name)).or_default().push(c);
+        }
+    }
+    by.into_values().filter(|v| v.len() > 1).collect()
+}
+
+/// Parse a variant name "Size=Large, State=Hover" into pairs.
+pub fn variant_props(name: &str) -> BTreeMap<String, String> {
+    name.split(',')
+        .filter_map(|kv| {
+            let (k, v) = kv.split_once('=')?;
+            Some((k.trim().to_string(), v.trim().to_string()))
+        })
+        .collect()
+}
+
+/// Format variant pairs as a layer name, in the given property order (others after, sorted).
+pub fn variant_name(pairs: &BTreeMap<String, String>, order: &[String]) -> String {
+    let mut keys: Vec<&String> = order.iter().filter(|k| pairs.contains_key(*k)).collect();
+    keys.extend(pairs.keys().filter(|k| !order.contains(k)));
+    keys.iter().filter_map(|k| pairs.get(*k).map(|v| format!("{k}={v}"))).collect::<Vec<_>>().join(", ")
+}
+
+/// Variant properties of a set: property → values, in first-seen order.
+pub fn variant_options(doc: &Document, set: NodeId) -> Vec<(String, Vec<String>)> {
+    let mut out: Vec<(String, Vec<String>)> = Vec::new();
+    for c in doc.node(set).map(|s| s.children.clone()).unwrap_or_default() {
+        let Some(cn) = doc.node(c) else { continue };
+        for kv in cn.name.split(',') {
+            let Some((k, v)) = kv.split_once('=') else { continue };
+            let (k, v) = (k.trim().to_string(), v.trim().to_string());
+            match out.iter_mut().find(|(p, _)| *p == k) {
+                Some((_, vals)) => {
+                    if !vals.contains(&v) {
+                        vals.push(v);
+                    }
+                }
+                None => out.push((k, vec![v])),
+            }
+        }
+    }
+    out
+}
+
+/// The variant in `set` matching `wanted` best: all given properties equal, or else the most.
+pub fn find_variant(doc: &Document, set: NodeId, wanted: &BTreeMap<String, String>) -> Option<NodeId> {
+    let s = doc.node(set)?;
+    let score = |c: &NodeId| doc.node(*c).map(|n| variant_props(&n.name)).map(|p| wanted.iter().filter(|(k, v)| p.get(*k) == Some(*v)).count());
+    if let Some(exact) = s.children.iter().copied().find(|c| score(c) == Some(wanted.len())) {
+        return Some(exact);
+    }
+    s.children.iter().copied().filter(|c| score(c).is_some()).max_by_key(|c| score(c).unwrap_or(0))
+}
+
+/// Check that every instance mirrors its main's layer structure (tests and diagnostics): each
+/// layer's `source` is the main layer at the same place, swapped nested instances mirror their
+/// own main, slots holding the instance's own content aren't compared. Returns the problems found.
+pub fn mirror_issues(doc: &Document) -> Vec<String> {
+    doc.nodes()
+        .filter(|n| matches!(n.kind, NodeKind::Instance { .. }) && !inside_instance(doc, n.id))
+        .flat_map(|n| instance_issues(doc, n.id))
+        .collect()
+}
+
+/// [`mirror_issues`] for one instance.
+pub(super) fn instance_issues(doc: &Document, id: NodeId) -> Vec<String> {
+    fn walk(doc: &Document, inst: &Node, main: &Node, depth: usize, out: &mut Vec<String>) {
+        if depth > MAX_DEPTH || holds_content(inst) {
+            return;
+        }
+        if inst.children.len() != main.children.len() {
+            out.push(format!("{} has {} layers, its main {} has {}", inst.id, inst.children.len(), main.id, main.children.len()));
+            return;
+        }
+        for (a, b) in inst.children.iter().zip(&main.children) {
+            let (Some(an), Some(bn)) = (doc.node(*a), doc.node(*b)) else { continue };
+            if an.source != Some(bn.id) {
+                out.push(format!("{} mirrors {:?}, expected {}", an.id, an.source, bn.id));
+                continue;
+            }
+            match (&an.kind, &bn.kind) {
+                (NodeKind::Instance { component: x, .. }, NodeKind::Instance { component: y, .. }) if x != y => {
+                    if let Some(m) = doc.node(*x) {
+                        walk(doc, an, m, depth + 1, out);
+                    }
+                }
+                _ => walk(doc, an, bn, depth + 1, out),
+            }
+        }
+    }
+    let mut out = Vec::new();
+    if let Some(n) = doc.node(id)
+        && let NodeKind::Instance { component, .. } = &n.kind
+        && let Some(m) = doc.node(*component)
+    {
+        walk(doc, n, m, 0, &mut out);
+    }
+    out
+}
+
+/// The nested instance copies inside instance `id` whose main-component counterpart is exposed
+/// (top-most first; an exposed instance's own exposed nested instances follow it).
+pub fn exposed_copies(doc: &Document, id: NodeId) -> Vec<NodeId> {
+    let mut out = Vec::new();
+    let mut stack: Vec<NodeId> = doc.node(id).map(|n| n.children.iter().rev().copied().collect()).unwrap_or_default();
+    let mut seen = 0usize;
+    while let Some(c) = stack.pop() {
+        seen += 1;
+        if seen > 100_000 {
+            break;
+        }
+        let Some(n) = doc.node(c) else { continue };
+        // A hidden exposed instance hides its properties too.
+        let exposed =
+            n.visible && matches!(n.kind, NodeKind::Instance { .. }) && n.source.and_then(|src| doc.node(src)).is_some_and(|src| src.exposed);
+        if exposed {
+            out.push(c);
+        }
+        // Only exposed nested instances pass their own exposed instances up.
+        if !matches!(n.kind, NodeKind::Instance { .. }) || exposed {
+            stack.extend(n.children.iter().rev().copied());
+        }
+    }
+    out
+}

From c631450b0cd13fcc333398079b9a2da9ac90a6ea Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:20:45 +0000
Subject: [PATCH 26/67] refactor(engine): split sharing/live.rs into live/

---
 crates/engine/src/sharing/live.rs        | 1758 +---------------------
 crates/engine/src/sharing/live/events.rs |  408 +++++
 crates/engine/src/sharing/live/host.rs   |  272 ++++
 crates/engine/src/sharing/live/join.rs   |  259 ++++
 crates/engine/src/sharing/live/sync.rs   |  347 +++++
 crates/engine/src/sharing/live/types.rs  |  482 ++++++
 6 files changed, 1783 insertions(+), 1743 deletions(-)
 create mode 100644 crates/engine/src/sharing/live/events.rs
 create mode 100644 crates/engine/src/sharing/live/host.rs
 create mode 100644 crates/engine/src/sharing/live/join.rs
 create mode 100644 crates/engine/src/sharing/live/sync.rs
 create mode 100644 crates/engine/src/sharing/live/types.rs

diff --git a/crates/engine/src/sharing/live.rs b/crates/engine/src/sharing/live.rs
index f33abd1c..a469b28e 100644
--- a/crates/engine/src/sharing/live.rs
+++ b/crates/engine/src/sharing/live.rs
@@ -59,485 +59,23 @@ use crate::params::{get, num, req_string, string};
 use crate::tools::ToolId;
 use crate::{DocState, EngineError, Result, Session, TextEdit, ViewState, bad, spec};
 
-/// The server files are shared through online unless Preferences name another: the only place
-/// its address is written.
-///
-/// A build can ship another one, or none: set `FIGCRAFT_DEFAULT_SERVER` when compiling to a
-/// server's address (`wss://host/`), or to nothing (`FIGCRAFT_DEFAULT_SERVER=`) for a build whose
-/// online sharing stays off until the user enters a server in Preferences.
-pub const DEFAULT_SERVER: &str = match option_env!("FIGCRAFT_DEFAULT_SERVER") {
-    Some(server) => server,
-    None => "wss://collab.craftapps.dev/",
+mod events;
+mod host;
+mod join;
+mod sync;
+mod types;
+
+use host::unavailable;
+pub use host::{MAX_REPORT, hosting_json};
+pub(crate) use host::{clean_shared, share_answer};
+pub(crate) use join::start_join;
+pub use join::{can_remove_people, specs};
+pub use types::{
+    Bind, DEFAULT_SERVER, Event, HostOptions, LiveLink, MAX_NAME, MAX_SELECTION, NO_HOSTING, NO_SESSION, NetReply, NetRequest, ONLINE_OFF, PEOPLE,
+    PageInfo, PublishOptions, Published, Role, SessionId, SessionInfo, Share, Shared, SharedLink, Status, TOO_LARGE_TO_JOIN, Via, join_target,
+    parse_color,
 };
 
-/// Most selected ids one presence update carries (the rest aren't shown to others).
-pub const MAX_SELECTION: usize = 10_000;
-/// Longest name shown to others (characters).
-pub const MAX_NAME: usize = 64;
-
-/// The colours people get in a session, in the order the host hands them out (`#RRGGBB`, white
-/// text reads on each).
-pub const PEOPLE: [&str; 8] = ["#0D99FF", "#9747FF", "#14AE5C", "#F24822", "#D9730D", "#E83E8C", "#00A3A3", "#665CE0"];
-
-/// `#RRGGBB` → (r, g, b); `None` for anything else.
-pub fn parse_color(s: &str) -> Option<(u8, u8, u8)> {
-    let hex = s.strip_prefix('#').filter(|h| h.len() == 6 && h.bytes().all(|b| b.is_ascii_hexdigit()))?;
-    let byte = |i: usize| hex.get(i..i + 2).and_then(|b| u8::from_str_radix(b, 16).ok());
-    Some((byte(0)?, byte(2)?, byte(4)?))
-}
-
-/// Why a join failed when a message from the host is over this app's size limit (`{mb}`: the
-/// limit in MB). The UI translates it.
-pub const TOO_LARGE_TO_JOIN: &str = "This file is too large to join here (up to {mb} MB)";
-
-/// The connection to a live session.
-#[derive(Clone, Debug, Default, PartialEq, Serialize)]
-#[serde(rename_all = "camelCase", tag = "state")]
-pub enum Status {
-    /// Not in a session.
-    #[default]
-    Off,
-    /// Joining (connecting to the host, waiting for its welcome).
-    Connecting,
-    /// In the session.
-    Live,
-    /// The connection dropped; trying again (`attempt` from 1).
-    Reconnecting { attempt: u32 },
-    /// Couldn't join, or the connection was lost for good.
-    Failed { reason: String },
-}
-
-impl Status {
-    pub fn id(&self) -> &'static str {
-        match self {
-            Status::Off => "off",
-            Status::Connecting => "connecting",
-            Status::Live => "live",
-            Status::Reconnecting { .. } => "reconnecting",
-            Status::Failed { .. } => "failed",
-        }
-    }
-
-    /// In a session or on the way into one.
-    pub fn active(&self) -> bool {
-        matches!(self, Status::Connecting | Status::Live | Status::Reconnecting { .. })
-    }
-
-    /// What the Share popover says about it.
-    pub fn label(&self) -> String {
-        match self {
-            Status::Off => "Not in a live session".into(),
-            Status::Connecting => "Joining…".into(),
-            Status::Live => "Live".into(),
-            Status::Reconnecting { attempt } => format!("Connection lost, reconnecting (attempt {attempt})…"),
-            Status::Failed { reason } => reason.clone(),
-        }
-    }
-}
-
-/// Your part in the session.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub enum Role {
-    Host,
-    Guest,
-}
-
-/// A page of the shared file.
-#[derive(Clone, Debug, PartialEq, Serialize)]
-pub struct PageInfo {
-    pub id: u64,
-    pub name: String,
-}
-
-/// The session you're in.
-#[derive(Clone, Debug, PartialEq, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SessionInfo {
-    pub role: Role,
-    /// Your client id, name and colour as the others see them.
-    pub me: u32,
-    pub name: String,
-    pub color: String,
-    /// The shared file's name and pages (the host's).
-    pub file_name: String,
-    pub pages: Vec<PageInfo>,
-    /// The invite link (`figcraft://join?host=…&file=…&token=…`) and the same as a plain
-    /// WebSocket URL. Both carry the session's secret token: share them only with people you
-    /// invite.
-    pub link: String,
-    pub url: String,
-    /// `ip:port` the session listens on (host) or connects to (guest); a server's URL when it
-    /// isn't plain `ws://` at `/`.
-    pub address: String,
-    /// Reachable from other machines (the host listens on a network address, not loopback).
-    pub network: bool,
-    /// What you may do: edit, or only view (a server's view link).
-    pub access: Access,
-}
-
-/// A file you published to a server: where, and its first share links (they carry their tokens:
-/// share them like passwords; the server keeps only hashes).
-#[derive(Clone, Debug, PartialEq, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Published {
-    /// The server's address.
-    pub server: String,
-    /// The file's id and name on the server.
-    pub file: String,
-    pub name: String,
-    /// The link that lets people edit, and the one that lets them only view.
-    pub edit: String,
-    pub view: String,
-    /// Published without the server's key: the owner token that revokes links, renames or removes
-    /// the file (shown this once; the server keeps only its hash).
-    pub owner: Option<String>,
-    /// When the server deletes the file if nobody opens it (seconds since 1970).
-    pub expires: Option<u64>,
-}
-
-/// How a file is shared with a join code.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub enum Via {
-    /// Through a server: the file is kept there and the server hands out the codes.
-    Online,
-    /// From this app, to people on the same network.
-    Local,
-}
-
-/// One way into a shared file: an invite link, and the join code that stands for it.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, serde::Deserialize)]
-#[serde(default)]
-pub struct SharedLink {
-    /// The link's id on its server (what revokes it; empty for a session this app hosts).
-    pub id: String,
-    /// The invite link (it carries its secret).
-    pub link: String,
-    /// Its join code's symbols. `None`: there is none (a server from before join codes, a host
-    /// without an IPv4 address): the link is shared instead.
-    pub code: Option<String>,
-}
-
-/// What others join a shared file with: to edit it and, on a server, to only view it.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, serde::Deserialize)]
-#[serde(default)]
-pub struct Shared {
-    pub edit: SharedLink,
-    pub view: Option<SharedLink>,
-}
-
-/// A file shared with a join code (`collab.share`). Online, the file is its owner's on the
-/// server: sharing gives others links (and codes) of their own, and stopping takes those away
-/// while the owner stays in the file.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Share {
-    pub via: Via,
-    /// Online: the server's address as it was given (it may carry the server's key: never shown).
-    pub server: String,
-    /// What the code shown lets people do.
-    pub access: Access,
-    /// What others join with now. `None`: on its way, or (online) not shared at the moment: the
-    /// file is on the server, open only to its owner.
-    pub links: Option<Shared>,
-}
-
-impl Share {
-    /// The way in to show: the one for [`access`](Self::access).
-    fn shown(&self) -> Option<&SharedLink> {
-        let links = self.links.as_ref()?;
-        if self.access == Access::View { links.view.as_ref() } else { Some(&links.edit) }
-    }
-
-    /// The code to show, grouped (`K7M-2QX-9TD`).
-    pub fn code(&self) -> Option<String> {
-        self.shown()?.code.as_deref().map(code::grouped)
-    }
-
-    /// The invite link to give with (or in place of) the code.
-    pub fn link(&self) -> Option<&str> {
-        self.shown().map(|l| l.link.as_str())
-    }
-}
-
-/// What someone typed to join, as what the link joins: an invite link as it is, a local network
-/// code as the link it stands for, an online code with `server` to ask about it.
-pub fn join_target(server: &str, typed: &str) -> std::result::Result<String, String> {
-    let typed = typed.trim();
-    if typed.contains("://") || typed.contains('?') {
-        return Ok(typed.to_string());
-    }
-    match code::parse(typed)? {
-        Code::Local(local) => Ok(local.link()),
-        Code::Online(_) if server.trim().is_empty() => Err(format!("that is an online join code, and {ONLINE_OFF}")),
-        Code::Online(code) => Ok(format!("figcraft://join?server={}&code={code}", server.trim())),
-    }
-}
-
-/// Why nothing can be shared or joined online.
-pub const ONLINE_OFF: &str = "online sharing is off: choose a server in Preferences (or share on the local network)";
-
-/// A session's number on the link: the engine picks it (from 1) when it starts the session.
-pub type SessionId = u64;
-/// The [`SessionId`] of events that aren't about a session (answers to background requests).
-pub const NO_SESSION: SessionId = 0;
-
-/// What happened in a session since the last [`LiveLink::poll`].
-#[derive(Clone, Debug, PartialEq)]
-pub enum Event {
-    Status(Status),
-    /// Joined, or joined again after a reconnect: who you are and who else is here.
-    Welcome {
-        info: SessionInfo,
-        peers: Vec<Peer>,
-    },
-    PeerJoined(Peer),
-    PeerLeft(u32),
-    Presence(u32, Presence),
-    /// Someone's cursor chat or spotlight, or (about you) the host's [`Signal::READY`].
-    Signal(u32, Signal),
-    /// For the document sync client: the welcome (with the whole document), or a batch of
-    /// changes the server ordered, or the rejection of one of yours.
-    Sync(ServerMsg),
-    /// The host ended the session.
-    Ended {
-        reason: String,
-    },
-    /// The document is on the server (`collab.publish`); joining it follows.
-    Published(Published),
-    /// The published file is shared (`collab.share`): the links and codes others join with, or
-    /// why the server made none.
-    Shared(std::result::Result<Shared, String>),
-    /// What the server says about its hosting (operator, terms, this file's expiry).
-    Hosting(HostInfo),
-    /// The server's answer to `collab.report`: kept, or why not.
-    Reported(Option<String>),
-    /// The answer to a team library request sent in the background
-    /// ([`LiveLink::library_background`]) about the file behind share link `link`.
-    Library {
-        link: String,
-        reply: std::result::Result<LibraryReply, String>,
-    },
-    /// The answer to request `job` sent in the background ([`LiveLink::background`]).
-    Net {
-        job: u64,
-        reply: Box<NetReply>,
-    },
-}
-
-/// A request to a server outside a live session: its plugin directory, a team library, or keeping
-/// a file there.
-#[derive(Clone, Debug)]
-pub enum NetRequest {
-    /// To the plugin directory of the server at `server` (`ws://host:port/`, with `?key=…` to
-    /// publish).
-    Plugins { server: String, req: PluginReq },
-    /// About the team library of the file behind share link `link`.
-    Library { link: String, req: LibraryReq },
-    /// Keep a file on a server without joining it ([`LiveLink::upload`]).
-    Upload(PublishOptions),
-    /// Change who else gets into `file` on the server at `server` (its address, with `?key=…`, or
-    /// the file's `owner` token): revoke the links with these ids, then, to `create`, make a new
-    /// edit link and view link with their join codes ([`LiveLink::share`]).
-    Share { server: String, file: String, owner: String, revoke: Vec<String>, create: bool },
-    /// Ask the server at `server` about its hosting and, with a file's owner token, manage that
-    /// file ([`LiveLink::hosting`]).
-    Hosting { server: String, file: String, owner: String, req: Option<Admin> },
-}
-
-impl NetRequest {
-    /// What a session without the network says.
-    pub(crate) fn unavailable(&self) -> &'static str {
-        match self {
-            NetRequest::Plugins { .. } => crate::plugin_directory::NO_DIRECTORY,
-            NetRequest::Library { .. } | NetRequest::Upload(_) => NO_TEAM_LIBRARIES,
-            NetRequest::Hosting { .. } | NetRequest::Share { .. } => NO_HOSTING,
-        }
-    }
-
-    /// How to answer that this request failed (and why).
-    pub fn failure(&self) -> fn(String) -> NetReply {
-        match self {
-            NetRequest::Plugins { .. } => |why| NetReply::Plugins(Err(why)),
-            NetRequest::Library { .. } => |why| NetReply::Library(Err(why)),
-            NetRequest::Upload(_) => |why| NetReply::Upload(Err(why)),
-            NetRequest::Hosting { .. } => |why| NetReply::Hosting(Err(why)),
-            NetRequest::Share { .. } => |why| NetReply::Share(Err(why)),
-        }
-    }
-
-    /// The answer to this request stands for `other` when a command runs again: the same kind of
-    /// request to the same place (what it carries may differ: a usage report, a fresh timestamp).
-    pub(crate) fn stands_for(&self, other: &NetRequest) -> bool {
-        use std::mem::discriminant;
-        match (self, other) {
-            (NetRequest::Plugins { server: a, req: x }, NetRequest::Plugins { server: b, req: y }) => a == b && discriminant(x) == discriminant(y),
-            (NetRequest::Library { link: a, req: x }, NetRequest::Library { link: b, req: y }) => a == b && discriminant(x) == discriminant(y),
-            (NetRequest::Upload(a), NetRequest::Upload(b)) => a.server == b.server,
-            (NetRequest::Hosting { server: a, file: f, req: x, .. }, NetRequest::Hosting { server: b, file: g, req: y, .. }) => {
-                a == b && f == g && x.as_ref().map(discriminant) == y.as_ref().map(discriminant)
-            }
-            (NetRequest::Share { server: a, file: f, create: x, .. }, NetRequest::Share { server: b, file: g, create: y, .. }) => {
-                a == b && f == g && x == y
-            }
-            _ => false,
-        }
-    }
-}
-
-/// The answer to a [`NetRequest`] (an error: the server couldn't be reached or refused).
-#[derive(Clone, Debug, PartialEq)]
-pub enum NetReply {
-    Plugins(std::result::Result<PluginReply, String>),
-    Library(std::result::Result<LibraryReply, String>),
-    /// The new links, when some were asked for.
-    Share(std::result::Result<Option<Shared>, String>),
-    Upload(std::result::Result<Published, String>),
-    /// What the server says about its hosting, and its answer to the request, if one was sent.
-    Hosting(std::result::Result<(HostInfo, Option<AdminReply>), String>),
-}
-
-/// What a session without the network says about servers' hosting.
-pub const NO_HOSTING: &str = "publishing to a server needs the desktop app or the MCP server";
-
-/// Which network interface a hosted session listens on.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Bind {
-    /// This machine only (127.0.0.1): the default.
-    Local,
-    /// The machine's address on the local network (only when the user chooses to share there).
-    Lan,
-    /// A given interface address (e.g. a VPN's).
-    Addr(IpAddr),
-}
-
-/// What [`LiveLink::host`] needs to start a session for the open file.
-#[derive(Clone, Debug)]
-pub struct HostOptions {
-    /// `None`: the default port, or any free one when it's taken.
-    pub port: Option<u16>,
-    pub bind: Bind,
-    /// Your name (empty: the host picks one).
-    pub name: String,
-    /// The shared file (the session's authoritative copy starts from it).
-    pub doc: Arc<Document>,
-    /// Shared with a join code (`collab.share`): the session's secret is short enough to type.
-    pub short: bool,
-}
-
-/// What [`LiveLink::publish`] needs to put the open file on a server.
-#[derive(Clone, Debug)]
-pub struct PublishOptions {
-    /// The server's address (`ws://host:port/`, `wss://host/path/`), which may carry its key
-    /// (`?key=…`).
-    pub server: String,
-    /// The server's key, when the address doesn't carry it. Without one the file is published
-    /// as anyone may, on a server open to the public (with an owner token).
-    pub key: Option<String>,
-    /// The file's name on the server.
-    pub name: String,
-    /// Your name in the session (empty: the server picks one).
-    pub me: String,
-    pub doc: Arc<Document>,
-    /// Share the file once it is there: links and join codes for others ([`Event::Shared`];
-    /// `collab.share`).
-    pub share: bool,
-}
-
-/// The networking behind live sessions, installed by the app ([`Lives::install`]). It carries
-/// any number of sessions at once, each under the [`SessionId`] it was started with. Calls return
-/// at once; what happens later arrives through [`poll`](Self::poll).
-pub trait LiveLink: Send {
-    /// Sessions can be hosted here (the browser build can only join).
-    fn can_host(&self) -> bool {
-        true
-    }
-    /// Start hosting session `session` for `opts.doc`.
-    fn host(&mut self, session: SessionId, opts: HostOptions) -> std::result::Result<SessionInfo, String>;
-    /// Start joining the session behind an invite link, as session `session`. Errors are for
-    /// links that can't be used; they never echo the link (it holds the token).
-    fn join(&mut self, session: SessionId, link: &str, name: &str) -> std::result::Result<(), String>;
-    /// [`join`](Self::join) as the client `resume` names, when the server still knows it (an app
-    /// that starts over after a crash keeps its id, so what it made before is its own to send).
-    /// A link that can't resume joins as someone new.
-    fn join_resuming(&mut self, session: SessionId, link: &str, name: &str, _resume: Option<Resume>) -> std::result::Result<(), String> {
-        self.join(session, link, name)
-    }
-    /// Start uploading `opts.doc` to a server as a new file, then join it with its edit link, as
-    /// session `session`: [`Event::Published`] with its links, then the welcome. Errors are for
-    /// addresses that can't be used; they never echo the key.
-    fn publish(&mut self, _session: SessionId, _opts: PublishOptions) -> std::result::Result<(), String> {
-        Err("publishing to a server needs the desktop app or the MCP server".into())
-    }
-    /// Keep `opts.doc` on a server as a new file without joining it: where, and its links
-    /// (`library.publishToServer` with the server's key). Waits for the server. Errors never echo
-    /// the key.
-    fn upload(&mut self, _opts: PublishOptions) -> std::result::Result<Published, String> {
-        Err(NO_TEAM_LIBRARIES.into())
-    }
-    /// One request about the team library of the file behind share link `link`; waits for the
-    /// server's answer (a few seconds at most when it can't be reached). Errors never echo the
-    /// link.
-    fn library(&mut self, _link: &str, _req: LibraryReq) -> std::result::Result<LibraryReply, String> {
-        Err(NO_TEAM_LIBRARIES.into())
-    }
-    /// Send library requests `(link, request)` in the background, in order; each answer arrives as
-    /// [`Event::Library`]. Ignored while an earlier call's requests are still out.
-    fn library_background(&mut self, _jobs: Vec<(String, LibraryReq)>) {}
-    /// One request to the plugin directory of the server at `server` (`ws://host:port/`, with
-    /// `?key=…` to publish); waits for the answer (a few seconds at most when it can't be
-    /// reached). Errors never echo the key.
-    fn plugins(&mut self, _server: &str, _req: PluginReq) -> std::result::Result<PluginReply, String> {
-        Err(crate::plugin_directory::NO_DIRECTORY.into())
-    }
-    /// What the server at `server` says about its hosting, and with a file's owner token
-    /// (`file` and `owner`) its answer to `req` about that file; waits for the server. Errors
-    /// never echo the token.
-    fn hosting(
-        &mut self,
-        _server: &str,
-        _file: &str,
-        _owner: &str,
-        _req: Option<Admin>,
-    ) -> std::result::Result<(HostInfo, Option<AdminReply>), String> {
-        Err(NO_HOSTING.into())
-    }
-    /// See [`NetRequest::Share`]; waits for the server. Errors never echo the key or the token.
-    fn share(&mut self, _server: &str, _file: &str, _owner: &str, _revoke: &[String], _create: bool) -> std::result::Result<Option<Shared>, String> {
-        Err(NO_HOSTING.into())
-    }
-    /// Send `req` and wait for the answer (through the methods above).
-    fn request(&mut self, req: NetRequest) -> NetReply {
-        match req {
-            NetRequest::Share { server, file, owner, revoke, create } => NetReply::Share(self.share(&server, &file, &owner, &revoke, create)),
-            NetRequest::Plugins { server, req } => NetReply::Plugins(self.plugins(&server, req)),
-            NetRequest::Library { link, req } => NetReply::Library(self.library(&link, req)),
-            NetRequest::Upload(o) => NetReply::Upload(self.upload(o)),
-            NetRequest::Hosting { server, file, owner, req } => NetReply::Hosting(self.hosting(&server, &file, &owner, req)),
-        }
-    }
-    /// Send `req` on a thread of its own and return at once: the answer arrives as [`Event::Net`]
-    /// with `job` (a failure to send too). False when this link can't, and nothing was sent.
-    fn background(&mut self, _job: u64, _req: NetRequest) -> bool {
-        false
-    }
-    /// Remove client `client` from session `session`, which this link hosts: they are
-    /// disconnected and can't join again from their address while it runs. Returns at once.
-    fn remove(&mut self, _session: SessionId, _client: u32) -> std::result::Result<(), String> {
-        Err("removing people needs the desktop app or the MCP server".into())
-    }
-    /// End session `session` (stop hosting or leave); the others go on. Nothing for a session
-    /// that is over already.
-    fn leave(&mut self, session: SessionId);
-    /// Your latest presence in `session` (the link throttles and coalesces).
-    fn presence(&mut self, session: SessionId, p: &Presence);
-    /// A message for `session`'s server (document changes), sent in order.
-    fn send(&mut self, session: SessionId, msg: ClientMsg);
-    /// Events since the last call, each with its session ([`NO_SESSION`] for answers to
-    /// background requests); never blocks.
-    fn poll(&mut self) -> Vec<(SessionId, Event)>;
-}
-
 /// The view a follow last applied: any other view means the user moved.
 #[derive(Clone, Copy, Debug, PartialEq)]
 struct FollowedView {
@@ -849,1269 +387,3 @@ pub const PUBLISHING: &str = "The file is being published: you can edit it again
 fn busy(ds: &DocState) -> bool {
     ds.interaction.is_some() || ds.preview.is_some() || ds.text_preview.is_some()
 }
-
-impl Session {
-    /// The active document (`None`: no document is open).
-    fn tab(&self) -> Option<u64> {
-        self.ds().ok().map(|d| d.uid)
-    }
-
-    /// The active document's live session (status off when it isn't in one). Everything the
-    /// window shows and the `collab.*` commands act on is this one.
-    pub fn live(&self) -> &Live {
-        self.live.on(self.tab())
-    }
-
-    /// The active document's live session, when it has one (running, on its way or failed).
-    pub fn live_mut(&mut self) -> Option<&mut Live> {
-        let id = self.live.shown(self.tab())?;
-        self.live.sessions.get_mut(&id)
-    }
-
-    /// Document `uid`'s live session (status off when it isn't in one).
-    pub fn live_of(&self, uid: u64) -> &Live {
-        self.live.on(Some(uid))
-    }
-
-    /// The active document is its session's synced document: page and layer ids in others'
-    /// presence refer to it.
-    pub fn live_shared(&self) -> bool {
-        self.tab().is_some_and(|uid| self.live_doc(uid))
-    }
-
-    /// Install a document that came from the session (others' edits): the selection, page and view
-    /// stay where they can, and the undo history isn't touched.
-    pub fn apply_remote(&mut self, uid: u64, doc: Arc<Document>) {
-        let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) else { return };
-        ds.doc = doc;
-        if !ds.doc.pages.contains(&ds.page) {
-            ds.page = ds.doc.first_page().unwrap_or(ds.page);
-        }
-        if ds.text_edit.as_ref().is_some_and(|t| !ds.doc.contains(t.id)) {
-            ds.text_edit = None;
-        }
-        if ds.vector_edit.as_ref().is_some_and(|v| !ds.doc.contains(v.id)) {
-            ds.vector_edit = None;
-        }
-        ds.clean_selection();
-        ds.revision += 1;
-    }
-
-    /// Your presence in the active document's session now: its page, selection, viewport and
-    /// edited text, and the pointer.
-    pub fn live_presence(&self) -> Presence {
-        self.presence_in(self.live())
-    }
-
-    /// Your presence in `live` (nothing while another document than its own is in front).
-    fn presence_in(&self, live: &Live) -> Presence {
-        let Some(ds) = self.ds().ok().filter(|ds| live.tab == Some(ds.uid)) else { return Presence::default() };
-        let (x0, y0) = ds.view.origin();
-        let z = ds.view.zoom.max(1e-9);
-        sanitize(Presence {
-            cursor: live.cursor.map(|(x, y)| (ds.page, x, y)),
-            selection: Some(ds.selection.clone()),
-            viewport: Some((ds.page, x0, y0, ds.view.vw / z, ds.view.vh / z)),
-            editing_text: ds.text_edit.as_ref().map(|t| Box::new(editing_of(t))),
-        })
-    }
-
-    /// The others typing in text layer `id` of the active document, in its session.
-    pub fn live_text_editors(&self, id: NodeId) -> Vec<&Peer> {
-        if !self.live_shared() {
-            return Vec::new();
-        }
-        let live = self.live();
-        live.presence.iter().filter(|(_, p)| p.editing_text.as_ref().is_some_and(|e| e.node == id)).filter_map(|(c, _)| live.peers.get(c)).collect()
-    }
-
-    /// You started typing in text layer `id`: say so when someone else is typing in it too (both
-    /// edits sync when they finish; the one finished last wins).
-    pub(crate) fn live_text_notice(&mut self, id: NodeId) {
-        let names: Vec<&str> = self.live_text_editors(id).iter().map(|p| p.name.as_str()).collect();
-        if let Some(hint) = editing_hint(&names) {
-            self.message = Some(format!("{hint} too: the version finished last is kept"));
-        }
-    }
-
-    /// Take in what happened in every session (the UI calls it every frame; the network wakes the
-    /// UI when something arrives). Returns whether anything changed.
-    pub fn live_poll(&mut self) -> bool {
-        let Some(link) = self.live.link.as_mut() else { return false };
-        let events = link.poll();
-        if events.is_empty() {
-            return false;
-        }
-        for (id, e) in events {
-            self.live_event(id, e);
-        }
-        self.live_closed();
-        for id in self.live.sessions.keys().copied().collect::<Vec<_>>() {
-            self.live_deferred(id);
-            self.live_follow_apply(id);
-        }
-        self.online_recoveries();
-        true
-    }
-
-    fn live_event(&mut self, id: SessionId, e: Event) {
-        let e = match e {
-            Event::Library { link, reply } => return self.library_answer(&link, reply),
-            Event::Net { job, reply } => return self.background_answer(job, *reply),
-            e => e,
-        };
-        // A session left meanwhile: what was still on its way is dropped.
-        let front = self.tab();
-        let Some(live) = self.live.sessions.get_mut(&id) else { return };
-        // What happens in a file that isn't in front says which file (by its tab's name).
-        let open = self.docs.iter().find(|d| Some(d.uid) == live.doc_uid).map(|d| d.doc.name.as_str());
-        let behind = open.or(live.file_name()).filter(|_| live.tab != front).map(|n| format!(" {n}")).unwrap_or_default();
-        match e {
-            Event::Status(Status::Failed { reason }) => self.live_fail(id, reason),
-            Event::Status(Status::Off) => {
-                self.live.end(id);
-            }
-            Event::Status(st) => {
-                // Who's here comes again with the next welcome; edits wait for it.
-                if let Status::Reconnecting { .. } = st {
-                    live.peers.clear();
-                    live.presence.clear();
-                    live.sent = None;
-                    // Until the host says it reads them again (a spotlight of yours goes out
-                    // again then).
-                    live.signals = false;
-                    live.chats.clear();
-                    live.chat.clear();
-                    live.spotlight = None;
-                    if let Some(c) = live.client.as_mut() {
-                        c.disconnect();
-                    }
-                }
-                live.status = st;
-            }
-            Event::Welcome { mut info, peers } => {
-                // The shared file's name and pages come with the document (the sync welcome).
-                if let Some(old) = live.info.as_ref().filter(|_| info.file_name.is_empty()) {
-                    info.file_name = old.file_name.clone();
-                    info.pages = old.pages.clone();
-                }
-                live.status = Status::Live;
-                live.info = Some(info);
-                live.peers = peers.into_iter().map(|p| (p.client_id, p)).collect();
-                live.presence.retain(|id, _| live.peers.contains_key(id));
-                if live.follow.is_some_and(|f| !live.peers.contains_key(&f)) {
-                    live.unfollow();
-                }
-                // Others need your presence again.
-                live.sent = None;
-            }
-            Event::PeerJoined(p) => {
-                self.message = Some(format!("{} joined{behind}", p.name));
-                live.peers.insert(p.client_id, p);
-            }
-            Event::PeerLeft(peer) => {
-                live.presence.remove(&peer);
-                live.chats.remove(&peer);
-                if live.spotlight == Some(peer) {
-                    live.spotlight = None;
-                }
-                if let Some(p) = live.peers.remove(&peer) {
-                    self.message = Some(format!("{} left{behind}", p.name));
-                }
-                if live.follow == Some(peer) {
-                    live.unfollow();
-                }
-            }
-            Event::Presence(peer, p) => {
-                if live.peers.contains_key(&peer) {
-                    live.presence.insert(peer, p);
-                }
-            }
-            Event::Signal(peer, sig) => self.live_signal_in(id, peer, sig),
-            Event::Sync(welcome @ ServerMsg::Welcome { .. }) if live.client.is_none() => self.live_welcome(id, welcome),
-            // Batches, and the welcome back after a dropped connection: the client catches up in
-            // order.
-            Event::Sync(msg) => live.deferred.push(msg),
-            Event::Ended { reason } => {
-                self.message = Some(if behind.is_empty() { reason } else { format!("{}: {reason}", behind.trim_start()) });
-                self.live.end(id);
-            }
-            Event::Published(p) => {
-                // Shared with a code: the popover shows it, nothing more to say.
-                if live.share.is_none() {
-                    self.message = Some(format!("Published {} to the server", p.name));
-                }
-                let server = live.server.clone();
-                live.published = Some(p.clone());
-                self.online_published(&server, &p);
-            }
-            Event::Shared(Ok(links)) => {
-                let links = clean_shared(links);
-                match live.server_file() {
-                    Some((server, file)) => self.online_shared(&server, &file, Some(links)),
-                    None => {
-                        if let Some(share) = live.share.as_mut() {
-                            share.links = Some(links);
-                        }
-                    }
-                }
-            }
-            Event::Shared(Err(why)) => self.message = Some(format!("The file is on the server, but couldn't be shared: {why}")),
-            Event::Hosting(info) => live.hosting = Some(clean_hosting(info)),
-            Event::Reported(error) => {
-                self.message =
-                    Some(error.map_or_else(|| "Your report was sent to the server's operator".into(), |e| format!("The report wasn't sent: {e}")));
-            }
-            // Answered above.
-            Event::Library { .. } | Event::Net { .. } => {}
-        }
-    }
-
-    /// Someone's cursor chat or spotlight in session `id` (checked again: the host is untrusted
-    /// too), or the host saying it reads them.
-    fn live_signal_in(&mut self, id: SessionId, peer: u32, sig: Signal) {
-        let Some(sig) = sig.clean() else { return };
-        let Some(live) = self.live.sessions.get_mut(&id) else { return };
-        let name = live.peers.get(&peer).map(|p| p.name.clone());
-        match (sig.kind.as_str(), name) {
-            (Signal::READY, _) if live.info.as_ref().is_some_and(|i| i.me == peer) => {
-                live.signals = true;
-                if live.spotlighting {
-                    self.live.send(id, [ClientMsg::Signal(Signal::spotlight(true))]);
-                }
-            }
-            (Signal::CHAT, Some(_)) if sig.text.is_empty() => {
-                live.chats.remove(&peer);
-            }
-            (Signal::CHAT, Some(_)) => {
-                live.chats.insert(peer, sig.text);
-            }
-            (Signal::SPOTLIGHT, Some(name)) if sig.on() => {
-                // Theirs takes over from yours or anyone else's.
-                live.spotlight = Some(peer);
-                live.spotlighting = false;
-                live.follow = Some(peer);
-                live.followed = None;
-                self.message = Some(format!("{name} is spotlighting: you follow their view (move it to stop)"));
-            }
-            (Signal::SPOTLIGHT, Some(name)) if live.spotlight == Some(peer) => {
-                live.spotlight = None;
-                if live.follow == Some(peer) {
-                    live.unfollow();
-                }
-                self.message = Some(format!("{name} stopped spotlighting"));
-            }
-            _ => {}
-        }
-    }
-
-    /// Why cursor chat or a spotlight can't go out now, if it can't.
-    fn signal_blocker(&self) -> Option<&'static str> {
-        let live = self.live();
-        if live.status != Status::Live {
-            Some("cursor chat and spotlight need a live session")
-        } else if !live.signals {
-            Some("the session's host runs an older version without cursor chat and spotlight")
-        } else {
-            None
-        }
-    }
-
-    /// Show `text` next to your pointer for everyone (empty closes it); returns it as sent
-    /// (control characters out, at most [`Signal::MAX_CHAT`] characters).
-    pub fn live_chat(&mut self, text: &str) -> Result<String> {
-        let sig = Signal::chat(text).clean().unwrap_or_default();
-        if sig.text.is_empty() && self.live().chat.is_empty() {
-            return Ok(String::new());
-        }
-        if let Some(why) = self.signal_blocker() {
-            return Err(EngineError::Disabled("collab.cursorChat".into(), why.into()));
-        }
-        let Some(live) = self.live_mut() else { return Ok(String::new()) };
-        if sig.text != live.chat {
-            live.chat.clone_from(&sig.text);
-            let id = live.id;
-            self.live.send(id, [ClientMsg::Signal(sig.clone())]);
-        }
-        Ok(sig.text)
-    }
-
-    /// Start (`on`) or stop asking everyone to follow your view.
-    pub fn live_spotlight(&mut self, on: bool) -> Result<()> {
-        if on == self.live().spotlighting {
-            return Ok(());
-        }
-        if on && let Some(why) = self.signal_blocker() {
-            return Err(EngineError::Disabled("collab.spotlight".into(), why.into()));
-        }
-        let Some(live) = self.live_mut() else { return Ok(()) };
-        if on {
-            live.unfollow();
-            live.spotlight = None;
-        }
-        live.spotlighting = on;
-        let id = live.id;
-        self.live.send(id, [ClientMsg::Signal(Signal::spotlight(on))]);
-        Ok(())
-    }
-
-    /// Session `id`'s welcome: start the sync client; the host keeps editing the document it
-    /// shared, a guest opens the host's file as a new tab (or gets it again in that tab after a
-    /// reconnect).
-    fn live_welcome(&mut self, id: SessionId, welcome: ServerMsg) {
-        let client = match Client::join(welcome) {
-            Ok(c) => c,
-            Err(e) => return self.live_fail(id, format!("Couldn't open the shared file: {e}")),
-        };
-        let Some(live) = self.live.sessions.get(&id) else { return };
-        let existing = live.doc_uid.filter(|u| self.docs.iter().any(|d| d.uid == *u));
-        let (uid, synced) = match (live.role(), existing) {
-            (Some(Role::Host), Some(uid)) => {
-                if let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) {
-                    let was_dirty = ds.is_dirty();
-                    // Undo is per user from now on: earlier whole-document steps would revert
-                    // others' edits.
-                    ds.history.undo.clear();
-                    ds.history.redo.clear();
-                    ds.doc_mut().set_client_id(client.id());
-                    if !was_dirty {
-                        ds.mark_saved();
-                    }
-                }
-                // Edits made since hosting started go out with the first sync.
-                (uid, None)
-            }
-            (Some(Role::Guest), Some(uid)) => {
-                // Joining again in this tab, or the file you published arriving from the server.
-                let doc = Arc::new(client.document().clone());
-                let was_dirty = self.docs.iter().find(|d| d.uid == uid).is_some_and(DocState::is_dirty);
-                self.apply_remote(uid, doc.clone());
-                if let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) {
-                    // Undo is per user from now on: earlier whole-document steps would revert
-                    // others' edits.
-                    ds.history.undo.clear();
-                    ds.history.redo.clear();
-                    if !was_dirty {
-                        ds.mark_saved();
-                    }
-                }
-                (uid, Some(doc))
-            }
-            (Some(Role::Guest), None) => {
-                // The session's file gets a tab of its own, in front.
-                let ds = DocState::new(client.document().clone(), None);
-                self.message = Some(format!("Joined {}", ds.doc.name));
-                let opened = (ds.uid, Some(ds.doc.clone()));
-                self.active = self.docs.len();
-                self.docs.push(ds);
-                opened
-            }
-            _ => return,
-        };
-        // A view link: the editing tools are off.
-        if client.access() == Access::View && self.tab() == Some(uid) && !matches!(self.tool.tool, ToolId::Move | ToolId::Hand) {
-            self.set_tool(ToolId::Move);
-        }
-        let Some(live) = self.live.sessions.get_mut(&id) else { return };
-        let doc = client.document();
-        if let Some(info) = live.info.as_mut() {
-            info.file_name = doc.name.clone();
-            info.pages = doc.pages.iter().map(|p| PageInfo { id: p.0, name: doc.node(*p).map(|n| n.name.clone()).unwrap_or_default() }).collect();
-        }
-        live.doc_uid = Some(uid);
-        live.tab = Some(uid);
-        live.synced = synced;
-        live.client = Some(client);
-        live.deferred.clear();
-    }
-
-    /// Session `id` is over with a message: it couldn't be joined, the connection was lost for
-    /// good or sync broke. Its tab shows why.
-    fn live_fail(&mut self, id: SessionId, reason: String) {
-        log::warn!("live session: {reason}");
-        self.live.leave(id);
-        if let Some(live) = self.live.sessions.get_mut(&id) {
-            live.reset();
-            live.status = Status::Failed { reason: reason.clone() };
-        }
-        self.message = Some(reason);
-    }
-
-    /// Why document `uid` can't be edited now, if it can't: you may only view it in its session,
-    /// or it is on its way to a server.
-    pub fn live_read_only(&self, uid: u64) -> Option<&'static str> {
-        let live = self.live.doc(uid)?;
-        match &live.client {
-            Some(c) if c.access() == Access::View => Some(VIEW_ONLY),
-            Some(_) => None,
-            None if live.status.active() && live.role() != Some(Role::Host) => Some(PUBLISHING),
-            None => None,
-        }
-    }
-
-    /// The active document can't be edited now (see [`live_read_only`](Self::live_read_only)).
-    pub fn active_read_only(&self) -> Option<&'static str> {
-        self.tab().and_then(|uid| self.live_read_only(uid))
-    }
-
-    /// Your client id in document `uid`'s live session (`None`: it isn't in one). Refused for
-    /// `cmd` while the session is on its way: there is no id yet.
-    pub(crate) fn live_client_id(&self, cmd: &str, uid: u64) -> Result<Option<u32>> {
-        let Some(live) = self.live.doc(uid) else { return Ok(None) };
-        match &live.client {
-            Some(c) => Ok(Some(c.id())),
-            None if live.status.active() => Err(EngineError::Disabled(cmd.into(), "wait until the file's live session has started".into())),
-            None => Ok(None),
-        }
-    }
-
-    /// Branch `id` of document `uid` got its base from the session document just now.
-    pub(crate) fn live_branch_base(&mut self, uid: u64, id: &str) {
-        if let Some(live) = self.live.doc_mut(uid).filter(|l| l.syncing()) {
-            live.branch_bases.insert(id.to_string());
-        }
-    }
-
-    /// Whether branch `id` of document `uid` got its base in the live session it is in now.
-    pub(crate) fn live_branch_in_session(&self, uid: u64, id: &str) -> bool {
-        self.live.doc(uid).is_some_and(|l| l.syncing() && l.branch_bases.contains(id))
-    }
-
-    /// Whether document `uid` is a live session's synced document: its edits sync and its undo
-    /// history is the user's own.
-    pub fn live_doc(&self, uid: u64) -> bool {
-        self.live.doc(uid).is_some_and(Live::syncing)
-    }
-
-    /// Sync the edits of session document `uid` as one batch: one step of the user's undo history
-    /// called `label`, or not undoable (`None`: also what changed it outside a command). Nothing
-    /// while a gesture or preview shows, or inside a group (it syncs when the group ends).
-    pub(crate) fn live_edit(&mut self, uid: u64, label: Option<&str>) {
-        let Some(ds) = self.docs.iter().find(|d| d.uid == uid) else { return };
-        let Some(live) = self.live.doc(uid) else { return };
-        if live.hold > 0 || busy(ds) || live.synced.as_ref().is_some_and(|s| Arc::ptr_eq(s, &ds.doc)) {
-            return;
-        }
-        let (id, doc, synced) = (live.id, ds.doc.clone(), live.synced.clone());
-        if self.live_read_only(uid).is_some() {
-            // Nothing goes out: what changed outside a command is put back.
-            if let Some(s) = synced {
-                self.apply_remote(uid, s);
-            }
-            return;
-        }
-        let Some(live) = self.live.sessions.get_mut(&id) else { return };
-        let Some(client) = live.client.as_mut() else { return };
-        match client.edit_with(&doc, label) {
-            Ok(msg) => {
-                live.synced = Some(doc);
-                self.live.send(id, msg);
-            }
-            Err(e) => self.live_fail(id, format!("Couldn't sync an edit: {e}")),
-        }
-    }
-
-    /// A group of commands on document `uid` starts (`on`) or ends: in between its edits don't
-    /// sync on their own.
-    pub(crate) fn live_hold(&mut self, uid: u64, on: bool) {
-        if let Some(live) = self.live.doc_mut(uid).filter(|l| l.syncing()) {
-            live.hold = if on { live.hold.saturating_add(1) } else { live.hold.saturating_sub(1) };
-        }
-    }
-
-    /// Undo (`back`) or redo the user's own last step on the active document, in its session:
-    /// what it wrote goes back where nobody else wrote since. Returns whether there was a step to
-    /// take back.
-    pub(crate) fn live_travel(&mut self, back: bool) -> bool {
-        let Some(uid) = self.tab() else { return false };
-        // Edits not synced yet go first.
-        self.live_edit(uid, None);
-        let Some(live) = self.live.doc_mut(uid) else { return false };
-        let Some(client) = live.client.as_mut() else { return false };
-        let (undo, redo) = client.history_len();
-        let msgs = match if back { client.undo(&EngineRecompute) } else { client.redo(&EngineRecompute) } {
-            Ok(m) => m,
-            Err(e) => {
-                log::warn!("live session: {} failed: {e}", if back { "undo" } else { "redo" });
-                return false;
-            }
-        };
-        let (u, r) = client.history_len();
-        let did = if back { r > redo } else { u > undo };
-        let doc = Arc::new(client.document().clone());
-        if did {
-            live.synced = Some(doc.clone());
-        }
-        let id = live.id;
-        self.live.send(id, msgs);
-        if did {
-            self.apply_remote(uid, doc);
-        }
-        did
-    }
-
-    /// Apply the server's batches that waited in session `id` (none while a gesture or preview
-    /// shows on its document).
-    fn live_deferred(&mut self, id: SessionId) {
-        let Some(live) = self.live.sessions.get(&id).filter(|l| !l.deferred.is_empty() && l.syncing()) else { return };
-        let Some(uid) = live.doc_uid else { return };
-        if self.docs.iter().find(|d| d.uid == uid).is_none_or(busy) {
-            return;
-        }
-        // Your own edits first: the client replays them over what others did.
-        self.live_edit(uid, None);
-        let Some(live) = self.live.sessions.get_mut(&id) else { return };
-        let Some(client) = live.client.as_mut() else { return };
-        let mut out = Vec::new();
-        for m in std::mem::take(&mut live.deferred) {
-            match client.receive(m, &EngineRecompute) {
-                Ok(more) => out.extend(more),
-                Err(e) => return self.live_fail(id, format!("The live session got out of step ({e}); join again")),
-            }
-        }
-        let doc = Arc::new(client.document().clone());
-        // Edits the server refused were rolled back: say why (the UI's toast).
-        let notices: Vec<String> = client.take_notices().iter().map(figcraft_collab::Notice::message).collect();
-        live.synced = Some(doc.clone());
-        if !notices.is_empty() {
-            self.message = Some(notices.join("; "));
-        }
-        self.live.send(id, out);
-        self.apply_remote(uid, doc);
-    }
-
-    /// Show the peer followed in session `id`: their viewport (and their page, in the session's
-    /// document) on the session's tab.
-    fn live_follow_apply(&mut self, id: SessionId) {
-        let Some(live) = self.live.sessions.get_mut(&id) else { return };
-        let Some(peer) = live.follow else { return };
-        if !live.peers.contains_key(&peer) {
-            live.unfollow();
-            return;
-        }
-        let Some((page, x, y, w, h)) = live.presence.get(&peer).and_then(|p| p.viewport) else { return };
-        let Some(ds) = self.docs.iter_mut().find(|d| Some(d.uid) == live.tab) else { return };
-        if live.syncing() && page != ds.page && ds.doc.pages.contains(&page) {
-            ds.page = page;
-            ds.selection.clear();
-            ds.text_edit = None;
-        }
-        if !(w > 0.0 && h > 0.0 && x.is_finite() && y.is_finite()) {
-            return;
-        }
-        ds.view.cx = x + w / 2.0;
-        ds.view.cy = y + h / 2.0;
-        let zoom = (ds.view.vw / w).min(ds.view.vh / h);
-        if zoom.is_finite() {
-            ds.view.zoom = zoom.clamp(ViewState::MIN_ZOOM, ViewState::MAX_ZOOM);
-        }
-        ds.revision += 1;
-        live.followed = Some(FollowedView { page: ds.page, cx: ds.view.cx, cy: ds.view.cy, zoom: ds.view.zoom });
-    }
-
-    /// Sessions whose tab was closed end (hosts stop hosting, guests leave); the others go on. A
-    /// join still on its way from a closed tab shows on the one in front.
-    fn live_closed(&mut self) {
-        let (docs, tab) = (&self.docs, self.tab());
-        let mut gone = Vec::new();
-        for l in self.live.sessions.values_mut().filter(|l| l.tab != tab && !docs.iter().any(|d| Some(d.uid) == l.tab)) {
-            if l.doc_uid.is_none() && l.status.active() {
-                l.tab = tab;
-            } else {
-                gone.push((l.id, l.status == Status::Live));
-            }
-        }
-        for (id, was_live) in gone {
-            self.live.end(id);
-            if was_live {
-                self.message = Some("The live session's file was closed, so you left the session".into());
-            }
-        }
-    }
-
-    /// Send your edits and presence in every session when they changed (headless sessions call
-    /// it after each command). A view you moved yourself stops following.
-    pub fn live_sync(&mut self) {
-        self.live_sync_in(|_| true);
-    }
-
-    /// [`live_sync`](Self::live_sync) for the sessions whose document (`None`: a join on its way)
-    /// `mine` picks: a window calls it every frame it draws, after input, for the documents it
-    /// holds.
-    pub fn live_sync_in(&mut self, mine: impl Fn(Option<u64>) -> bool) {
-        // A recovery copy whose session was left has its outcome too.
-        if !self.live.recovering.is_empty() {
-            self.online_recoveries();
-        }
-        if self.live.sessions.is_empty() {
-            return;
-        }
-        self.live_closed();
-        let ids: Vec<SessionId> = self.live.sessions.values().filter(|l| l.status == Status::Live && mine(l.doc_uid)).map(|l| l.id).collect();
-        for id in ids {
-            self.live_deferred(id);
-            if let Some(uid) = self.live.get(id).and_then(|l| l.doc_uid) {
-                self.live_edit(uid, None);
-            }
-            self.live_present(id);
-        }
-    }
-
-    /// Hand your presence in session `id` to the link when it changed.
-    fn live_present(&mut self, id: SessionId) {
-        let Some(live) = self.live.get(id).filter(|l| l.status == Status::Live) else { return };
-        let moved = live.followed.is_some_and(|f| {
-            self.docs
-                .iter()
-                .find(|d| Some(d.uid) == live.tab)
-                .is_some_and(|ds| ds.page != f.page || !close(ds.view.cx, f.cx) || !close(ds.view.cy, f.cy) || !close(ds.view.zoom, f.zoom))
-        });
-        let p = self.presence_in(live);
-        let changed = live.sent.as_ref() != Some(&p);
-        let Some(live) = self.live.sessions.get_mut(&id) else { return };
-        if moved {
-            live.unfollow();
-        }
-        if changed {
-            if let Some(link) = self.live.link.as_mut() {
-                link.presence(id, &p);
-            }
-            live.sent = Some(p);
-        }
-    }
-
-    /// Stop following in the active document's session (Escape, `collab.follow {}`). False when
-    /// you weren't following anyone.
-    pub fn live_unfollow(&mut self) -> bool {
-        self.live_mut().is_some_and(Live::unfollow)
-    }
-
-    /// Follow `peer`'s viewport in the active document's session (shown at once when known).
-    pub fn live_follow(&mut self, peer: u32) -> Result<()> {
-        let Some(live) = self.live_mut().filter(|l| l.peers.contains_key(&peer)) else {
-            return Err(bad("collab.follow", format!("nobody with client id {peer} is in the session")));
-        };
-        live.follow = Some(peer);
-        live.followed = None;
-        let id = live.id;
-        self.live_follow_apply(id);
-        Ok(())
-    }
-
-    /// The active document's session as JSON (`collab.peers`), with every session in brief.
-    pub fn live_summary(&self) -> Value {
-        self.summary(self.live())
-    }
-
-    /// The index of the open document session `l` syncs.
-    fn live_index(&self, l: &Live) -> Option<usize> {
-        l.doc_uid.and_then(|u| self.docs.iter().position(|d| d.uid == u))
-    }
-
-    fn summary(&self, l: &Live) -> Value {
-        let info = l.info.as_ref();
-        let reason = |l: &Live| match &l.status {
-            Status::Failed { reason } => Some(reason.clone()),
-            _ => None,
-        };
-        let synced = self.live_index(l).and_then(|i| self.docs.get(i));
-        // Who types in which layer of the session document.
-        let editing = |e: &EditingText| {
-            let layer = synced.and_then(|d| d.doc.node(e.node)).map(|n| n.name.as_str());
-            json!({"node": e.node, "layer": layer, "caret": e.caret, "selection": e.selection})
-        };
-        let peers: Vec<Value> = l
-            .peers
-            .values()
-            .map(|p| {
-                let presence = l.presence.get(&p.client_id);
-                let typing = presence.and_then(|pr| pr.editing_text.as_deref()).map(editing);
-                let chat = l.chats.get(&p.client_id);
-                json!({"id": p.client_id, "name": p.name, "color": p.color, "editing": typing, "chat": chat, "presence": presence})
-            })
-            .collect();
-        let mine = synced.and_then(|d| d.text_edit.as_ref()).map(|t| editing(&editing_of(t)));
-        let sessions: Vec<Value> = self
-            .live
-            .iter()
-            .map(|o| {
-                let info = o.info.as_ref();
-                json!({
-                    "session": o.id,
-                    "document": self.live_index(o),
-                    "status": o.status.id(),
-                    "reason": reason(o),
-                    "role": o.role(),
-                    "fileName": info.map(|i| i.file_name.as_str()),
-                    "link": info.map(|i| i.link.as_str()),
-                    "peers": o.peers.len(),
-                })
-            })
-            .collect();
-        json!({
-            "available": self.live.available(),
-            "canHost": self.live.can_host(),
-            "session": (l.id != NO_SESSION).then_some(l.id),
-            "status": l.status.id(),
-            "reason": reason(l),
-            "attempt": match l.status { Status::Reconnecting { attempt } => Some(attempt), _ => None },
-            "role": info.map(|i| i.role),
-            "me": info.map(|i| i.me),
-            "name": info.map(|i| i.name.as_str()),
-            "color": info.map(|i| i.color.as_str()),
-            "fileName": info.map(|i| i.file_name.as_str()),
-            "pages": info.map(|i| &i.pages),
-            "link": info.map(|i| i.link.as_str()),
-            "url": info.map(|i| i.url.as_str()),
-            "address": info.map(|i| i.address.as_str()),
-            "network": info.map(|i| i.network),
-            "access": l.client.as_ref().map(Client::access).or(info.map(|i| i.access)),
-            "readOnly": l.doc_uid.is_some_and(|u| self.live_read_only(u).is_some()),
-            "published": l.published,
-            "code": l.share.as_ref().and_then(Share::code),
-            "share": l.share.as_ref().map(|sh| {
-                let (edit, view) = (sh.links.as_ref().map(|s| &s.edit), sh.links.as_ref().and_then(|s| s.view.as_ref()));
-                let code = |l: Option<&SharedLink>| l.and_then(|l| l.code.as_deref()).map(code::grouped);
-                json!({
-                    "via": sh.via,
-                    "access": sh.access.id(),
-                    "shared": sh.links.is_some(),
-                    "editCode": code(edit),
-                    "viewCode": code(view),
-                    "editLink": edit.map(|l| l.link.as_str()),
-                    "viewLink": view.map(|l| l.link.as_str()),
-                })
-            }),
-            "hosting": l.hosting.as_ref().map(hosting_json),
-            "follow": l.follow,
-            "signals": l.signals,
-            "chat": l.chat,
-            "spotlight": l.spotlight,
-            "spotlighting": l.spotlighting,
-            "syncing": l.syncing(),
-            "document": self.live_index(l),
-            "editing": mine,
-            "peers": peers,
-            "sessions": sessions,
-        })
-    }
-}
-
-/// What a server says about its hosting, made safe to show: no control characters, short, and a
-/// terms address only when it is a web page (`http(s)://`).
-fn clean_hosting(mut info: HostInfo) -> HostInfo {
-    let clean = |s: &str, n: usize| s.trim().chars().filter(|c| !c.is_control()).take(n).collect::<String>();
-    info.operator = clean(&info.operator, 120);
-    info.terms = clean(&info.terms, 500);
-    let web = info.terms.starts_with("https://") || info.terms.starts_with("http://");
-    if !web || info.terms.contains(char::is_whitespace) {
-        info.terms.clear();
-    }
-    info
-}
-
-/// A server's hosting as JSON (`collab.peers`, `collab.serverInfo`).
-pub fn hosting_json(h: &HostInfo) -> Value {
-    json!({
-        "open": h.open,
-        "operator": h.operator,
-        "terms": h.terms,
-        "idleDays": (h.idle_secs > 0).then(|| (h.idle_secs as f64 / 86_400.0 * 100.0).round() / 100.0),
-        "maxFileMb": h.max_file_mb,
-        "expires": h.expires,
-    })
-}
-
-fn unavailable(cmd: &str) -> EngineError {
-    EngineError::Disabled(
-        cmd.to_string(),
-        "live sessions aren't available here (the desktop app and the MCP server host and join them; the web build joins)".into(),
-    )
-}
-
-fn host(s: &mut Session, p: &Value) -> Result<Value> {
-    start_host(s, "collab.host", p, Bind::Local, false)?;
-    Ok(s.live_summary())
-}
-
-/// Start hosting the open file for command `cmd` (on `bind` unless `p` says where; `short`: with
-/// a secret a join code can carry): the new session.
-fn start_host(s: &mut Session, cmd: &str, p: &Value, bind: Bind, short: bool) -> Result<SessionId> {
-    let port = match get(p, "port") {
-        None => None,
-        Some(v) => Some(v.as_u64().and_then(|n| u16::try_from(n).ok()).ok_or_else(|| bad(cmd, "`port` must be a whole number from 0 to 65535"))?),
-    };
-    let bind = match string(p, "bind").as_deref().map(str::trim) {
-        None => bind,
-        Some("local") => Bind::Local,
-        Some("lan") => Bind::Lan,
-        Some(other) => other.parse::<IpAddr>().map(Bind::Addr).map_err(|_| bad(cmd, "`bind` must be \"local\", \"lan\" or an IP address"))?,
-    };
-    let (doc, uid) = s.ds().map(|ds| (ds.doc.clone(), ds.uid))?;
-    let opts = HostOptions { port, bind, name: display_name(&s.prefs), doc, short };
-    let (id, info) = s.live.start(cmd, |l, id| l.host(id, opts).map_err(|e| EngineError::Other(format!("couldn't start the live session: {e}"))))?;
-    s.live.open(Live { id, status: Status::Live, info: Some(info), doc_uid: Some(uid), tab: Some(uid), ..Live::default() });
-    Ok(id)
-}
-
-fn publish(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "collab.publish";
-    let server = req_string(CMD, p, "server")?;
-    start_publish(s, CMD, &server, p, false)?;
-    Ok(s.live_summary())
-}
-
-/// Start publishing the open file to `server` for command `cmd` (`share`: with links and join
-/// codes for others too): the new session.
-fn start_publish(s: &mut Session, cmd: &str, server: &str, p: &Value, share: bool) -> Result<SessionId> {
-    let key = string(p, "key").map(|k| k.trim().to_string()).filter(|k| !k.is_empty());
-    let (doc, uid) = s.ds().map(|ds| (ds.doc.clone(), ds.uid))?;
-    let name = string(p, "name").map(|n| n.trim().chars().filter(|c| !c.is_control()).take(256).collect::<String>()).filter(|n| !n.is_empty());
-    let me = display_name(&s.prefs);
-    let opts = PublishOptions { server: server.trim().to_string(), key, name: name.unwrap_or_else(|| doc.name.clone()), me, doc, share };
-    let (id, ()) = s.live.start(cmd, |l, id| l.publish(id, opts).map_err(|e| bad(cmd, e)))?;
-    // This tab becomes the server file's synced document once it is there.
-    s.live.open(Live { id, status: Status::Connecting, doc_uid: Some(uid), tab: Some(uid), server: server.trim().to_string(), ..Live::default() });
-    Ok(id)
-}
-
-/// Why a local network share has no view-only code.
-const LOCAL_EDITS: &str = "everyone who joins a file shared on the local network can edit it: share it online for a view-only code";
-
-fn share(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "collab.share";
-    let via = match string(p, "via").as_deref().map(str::trim) {
-        None | Some("online") => Via::Online,
-        Some("local") => Via::Local,
-        Some(_) => return Err(bad(CMD, "`via` must be \"online\" or \"local\"")),
-    };
-    let access = match string(p, "access") {
-        None => None,
-        Some(a) => Some(Access::parse(&a).ok_or_else(|| bad(CMD, "`access` must be \"edit\" or \"view\""))?),
-    };
-    // A share of this file is there already: only which code is shown changes, or (the file is
-    // on the server, not shared at the moment) it gets new links and codes. Nothing is published
-    // twice.
-    if let Some(shared) = s.live().share.as_ref().filter(|_| s.live().status.active()).map(|sh| sh.via) {
-        if get(p, "via").is_some() && shared != via {
-            return Err(bad(
-                CMD,
-                "this file is shared the other way already: stop sharing it first (collab.stop), or leave its session (collab.leave)",
-            ));
-        }
-        if access == Some(Access::View) && shared == Via::Local {
-            return Err(bad(CMD, LOCAL_EDITS));
-        }
-        if let Some(req) = share_request(s, Vec::new(), true).filter(|_| s.live().share.as_ref().is_some_and(|sh| sh.links.is_none())) {
-            let links = share_answer(s, req)?.ok_or_else(|| EngineError::Other("the server made no links".into()))?;
-            shared_now(s, Some(clean_shared(links)));
-        }
-        if let (Some(a), Some(sh)) = (access, s.live_mut().and_then(|l| l.share.as_mut())) {
-            sh.access = a;
-        }
-        return Ok(s.live_summary());
-    }
-    let access = access.unwrap_or_default();
-    let mut server = String::new();
-    let id = match via {
-        Via::Local if access == Access::View => return Err(bad(CMD, LOCAL_EDITS)),
-        Via::Local => start_host(s, CMD, p, Bind::Lan, true)?,
-        Via::Online => {
-            server = string(p, "server").unwrap_or_else(|| s.prefs.publish_server.clone()).trim().to_string();
-            if server.is_empty() {
-                return Err(EngineError::Disabled(CMD.into(), ONLINE_OFF.into()));
-            }
-            start_publish(s, CMD, &server, p, true)?
-        }
-    };
-    if let Some(live) = s.live.sessions.get_mut(&id) {
-        // On the local network the session's own link is what others join with, and the code says
-        // what the link says: where the session is and its secret. (Online they arrive with the file.)
-        let links = live.info.as_ref().filter(|_| via == Via::Local).map(|i| {
-            let code = code::Local::from_link(&i.link).map(|l| l.code());
-            Shared { edit: SharedLink { id: String::new(), link: i.link.clone(), code }, view: None }
-        });
-        live.share = Some(Share { via, server, access, links });
-    }
-    Ok(s.live_summary())
-}
-
-/// What others join the open file's server file with changed: in its session and its record.
-fn shared_now(s: &mut Session, links: Option<Shared>) {
-    if let Some((server, file)) = s.live().server_file() {
-        s.online_shared(&server, &file, links);
-    }
-}
-
-/// Links and codes as a server gave them, with only codes that are codes (nine symbols).
-pub(crate) fn clean_shared(mut links: Shared) -> Shared {
-    let clean = |l: &mut SharedLink| l.code = l.code.take().and_then(|c| code::normalize(&c).ok()).filter(|c| c.len() == code::ONLINE_LEN);
-    clean(&mut links.edit);
-    links.view.as_mut().map(clean);
-    links
-}
-
-/// The request that changes who else gets into the server file the open file's session is its
-/// owner's session of (`None`: it isn't one, or the file isn't there yet).
-fn share_request(s: &Session, revoke: Vec<String>, create: bool) -> Option<NetRequest> {
-    let live = s.live();
-    let (share, published) = (live.share.as_ref().filter(|s| s.via == Via::Online)?, live.published.as_ref()?);
-    if live.status != Status::Live {
-        return None;
-    }
-    // The token this session got when it published the file, else the recorded one.
-    let owner = published.owner.clone().or_else(|| s.online_owner(&share.server, &published.file)).unwrap_or_default();
-    Some(NetRequest::Share { server: share.server.clone(), file: published.file.clone(), owner, revoke, create })
-}
-
-/// Send `req` ([`NetRequest::Share`]): the new links, if it made any.
-pub(crate) fn share_answer(s: &mut Session, req: NetRequest) -> Result<Option<Shared>> {
-    match s.net(req)?.0 {
-        NetReply::Share(Ok(links)) => Ok(links),
-        NetReply::Share(Err(why)) => Err(EngineError::Other(why)),
-        _ => Err(EngineError::Other("the server answered something else".into())),
-    }
-}
-
-/// What the server at `server` says about its hosting, and its answer to `req` about `file` with
-/// its owner token (`collab.serverInfo`, `collab.manageFile`).
-fn hosting_request(s: &mut Session, cmd: &str, server: &str, file: &str, owner: &str, req: Option<Admin>) -> Result<(HostInfo, Option<AdminReply>)> {
-    let req = NetRequest::Hosting { server: server.to_string(), file: file.to_string(), owner: owner.to_string(), req };
-    match s.net(req)?.0 {
-        // The server's refusals say why themselves.
-        NetReply::Hosting(Ok((_, Some(AdminReply::Failed { reason })))) | NetReply::Hosting(Err(reason)) => Err(EngineError::Other(reason)),
-        NetReply::Hosting(Ok((info, reply))) => Ok((clean_hosting(info), reply)),
-        _ => Err(EngineError::Other(format!("{cmd}: the server answered something else"))),
-    }
-}
-
-fn server_info(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "collab.serverInfo";
-    let server = req_string(CMD, p, "server")?;
-    let (info, _) = hosting_request(s, CMD, server.trim(), "", "", None)?;
-    Ok(hosting_json(&info))
-}
-
-fn manage_file(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "collab.manageFile";
-    let file = req_string(CMD, p, "file")?.trim().to_string();
-    let (server, owner) = crate::online::manager(s, CMD, p, &file)?;
-    let action = req_string(CMD, p, "action")?;
-    let mut renamed = None;
-    let req = match action.trim() {
-        "share" => return crate::online::set_shared(s, CMD, &server, &file, &owner, true),
-        "unshare" => return crate::online::set_shared(s, CMD, &server, &file, &owner, false),
-        "links" => Admin::Links { file: file.clone() },
-        "createLink" => {
-            let access = match string(p, "access").as_deref().map(str::trim) {
-                None | Some("view") => Access::View,
-                Some("edit") => Access::Edit,
-                Some(_) => return Err(bad(CMD, "`access` must be \"edit\" or \"view\"")),
-            };
-            Admin::CreateLink { file: file.clone(), access, label: string(p, "label").unwrap_or_default() }
-        }
-        "revoke" => Admin::Revoke { file: file.clone(), link: req_string(CMD, p, "link")?.trim().to_string() },
-        "rename" => {
-            let name = req_string(CMD, p, "name")?;
-            renamed = Some(name.clone());
-            Admin::Rename { file: file.clone(), name }
-        }
-        "remove" => Admin::Remove { file: file.clone() },
-        _ => return Err(bad(CMD, "`action` must be links, createLink, revoke, share, unshare, rename or remove")),
-    };
-    let changes = matches!(req, Admin::Rename { .. } | Admin::Remove { .. });
-    let reply = hosting_request(s, CMD, &server, &file, &owner, Some(req))?.1;
-    // The record follows what the server did.
-    if changes && reply == Some(AdminReply::Done) {
-        crate::online::managed(s, &server, &file, renamed.as_deref());
-        if renamed.is_none() {
-            crate::online::removed(s, &server, &file);
-        }
-    }
-    match reply {
-        Some(AdminReply::Links(links)) => Ok(json!({"links": links.iter().map(|l| json!({
-            "id": l.id, "access": l.access.id(), "label": l.label, "created": l.created
-        })).collect::<Vec<_>>()})),
-        // The link layer gives the new link whole in place of its token.
-        Some(AdminReply::Link(l)) => Ok(json!({"id": l.link.id, "access": l.link.access.id(), "link": l.token})),
-        Some(AdminReply::Done) => Ok(json!({"done": true})),
-        _ => Err(bad(CMD, "the server answered something else")),
-    }
-}
-
-fn report(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "collab.report";
-    let reason: String = req_string(CMD, p, "reason")?.trim().chars().map(|c| if c.is_control() { ' ' } else { c }).take(MAX_REPORT).collect();
-    if reason.is_empty() {
-        return Err(bad(CMD, "say in a few words what is wrong with the file (`reason`)"));
-    }
-    let live = s.live();
-    if live.status != Status::Live || live.role() != Some(Role::Guest) {
-        return Err(bad(CMD, "join a file on a FigCraft server first: reports go to that server's operator"));
-    }
-    if live.hosting.is_none() {
-        return Err(bad(CMD, "this server doesn't take reports (it is older than this app); contact its operator another way"));
-    }
-    let id = live.id;
-    s.live.send(id, [ClientMsg::Report { reason }]);
-    Ok(json!({"sent": true}))
-}
-
-/// Longest report sent (characters).
-pub const MAX_REPORT: usize = 500;
-
-fn join(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "collab.join";
-    let typed = match string(p, "code") {
-        Some(code) => code,
-        None => req_string(CMD, p, "link").map_err(|_| bad(CMD, "give the join `code` you were told, or the invite `link`"))?,
-    };
-    let link = join_target(&s.prefs.publish_server, &typed).map_err(|e| bad(CMD, e))?;
-    let id = start_join(s, CMD, &link, None, None, None)?;
-    Ok(s.live.get(id).map_or(Value::Null, |l| s.summary(l)))
-}
-
-/// Start joining the session behind `link` for command `cmd`: the new session. `published` and
-/// `share`: the file is yours on a server (`collab.openFile`), with what others join it with;
-/// `resume`: as the client you were there.
-pub(crate) fn start_join(
-    s: &mut Session,
-    cmd: &str,
-    link: &str,
-    published: Option<Published>,
-    share: Option<Share>,
-    resume: Option<Resume>,
-) -> Result<SessionId> {
-    let (name, tab) = (display_name(&s.prefs), s.tab());
-    let (id, ()) = s.live.start(cmd, |l, id| l.join_resuming(id, link, &name, resume).map_err(|e| bad(cmd, e)))?;
-    let server = share.as_ref().map(|s| s.server.clone()).unwrap_or_default();
-    // The session's file opens in a tab of its own; until then the join shows on this one.
-    s.live.open(Live { id, status: Status::Connecting, tab, server, published, share, ..Live::default() });
-    Ok(id)
-}
-
-fn leave(s: &mut Session, _: &Value) -> Result<Value> {
-    let ended = s.live.shown(s.tab()).and_then(|id| s.live.end(id));
-    if ended.as_ref().is_some_and(|l| l.syncing() && l.role() == Some(Role::Guest)) {
-        s.message = Some("You left the session; your copy stays open here".into());
-    }
-    Ok(json!({"ended": ended.is_some_and(|l| l.status.active())}))
-}
-
-fn stop(s: &mut Session, p: &Value) -> Result<Value> {
-    // A file shared online stays its owner's on the server: stopping takes the others' links (and
-    // their codes) away, which disconnects whoever joined with them, and the owner stays in the
-    // file. Anything else (a session this app hosts, one it joined, a file not shared now) ends.
-    let shared = s.live().share.as_ref().and_then(|sh| sh.links.as_ref());
-    let ids: Vec<String> = shared.into_iter().flat_map(|l| [Some(&l.edit), l.view.as_ref()]).flatten().map(|l| l.id.clone()).collect();
-    let Some(req) = share_request(s, ids, false).filter(|_| shared.is_some()) else { return leave(s, p) };
-    share_answer(s, req).map_err(|e| EngineError::Other(format!("couldn't stop sharing (the others can still get in): {e}")))?;
-    shared_now(s, None);
-    s.message = Some("Sharing stopped: the file stays on the server, open only to you".into());
-    Ok(json!({"ended": false, "shared": false}))
-}
-
-fn follow(s: &mut Session, p: &Value) -> Result<Value> {
-    match get(p, "client") {
-        None => {
-            s.live_unfollow();
-        }
-        Some(v) => {
-            let id = v.as_u64().and_then(|n| u32::try_from(n).ok()).ok_or_else(|| bad("collab.follow", "`client` must be a client id"))?;
-            s.live_follow(id)?;
-        }
-    }
-    Ok(json!({"follow": s.live().follow}))
-}
-
-/// Remove someone from the open file's session: in a session this app hosts, the hub drops them;
-/// in a file of yours on a server, the server does (with the file's owner token). They are told
-/// the session is over for them, keep their copy, and can't join again from their address while
-/// the session (or the server) runs.
-fn remove_person(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "collab.removePerson";
-    let client =
-        get(p, "client").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok()).ok_or_else(|| bad(CMD, "`client` must be a client id"))?;
-    let live = s.live();
-    if live.status != Status::Live {
-        return Err(bad(CMD, "the open file isn't in a live session"));
-    }
-    let name =
-        live.peers.get(&client).map(|p| p.name.clone()).ok_or_else(|| bad(CMD, format!("nobody with client id {client} is in the session")))?;
-    let (id, role, server_file) = (live.id, live.role(), live.server_file());
-    match (role, server_file) {
-        (Some(Role::Host), _) => {
-            let link = s.live.link.as_deref_mut().ok_or_else(|| unavailable(CMD))?;
-            link.remove(id, client).map_err(EngineError::Other)?;
-        }
-        (Some(Role::Guest), Some((server, file))) => {
-            let owner =
-                s.live().published.as_ref().and_then(|p| p.owner.clone()).or_else(|| s.online_owner(&server, &file)).filter(|o| !o.is_empty());
-            let owner = owner.ok_or_else(|| bad(CMD, "only the file's owner can remove people from it"))?;
-            let req = Some(Admin::RemovePeer { file: file.clone(), client });
-            match hosting_request(s, CMD, &server, &file, &owner, req) {
-                Ok((_, Some(AdminReply::Done))) => {}
-                Ok(_) => return Err(EngineError::Other(format!("couldn't remove {name}: the server answered something else"))),
-                // A server older than this request can't read it.
-                Err(e) => return Err(EngineError::Other(format!("couldn't remove {name}: {e} (the server may be older than removing people)"))),
-            }
-        }
-        _ => return Err(bad(CMD, "only the person hosting the session, or the file's owner, can remove people")),
-    }
-    s.message = Some(format!("{name} was removed from the session"));
-    Ok(json!({"removed": client, "name": name}))
-}
-
-/// You may remove others from the open file's session: you host it, or it is your file on a
-/// server.
-pub fn can_remove_people(s: &Session) -> bool {
-    let live = s.live();
-    live.status == Status::Live
-        && match live.role() {
-            Some(Role::Host) => true,
-            Some(Role::Guest) => live.server_file().is_some_and(|(server, file)| {
-                live.published.as_ref().and_then(|p| p.owner.as_deref()).is_some_and(|o| !o.is_empty())
-                    || s.online_owner(&server, &file).is_some_and(|o| !o.is_empty())
-            }),
-            None => false,
-        }
-}
-
-fn cursor(s: &mut Session, p: &Value) -> Result<Value> {
-    let at = match (num(p, "x"), num(p, "y")) {
-        (Some(x), Some(y)) => Some((x, y)),
-        (None, None) => None,
-        _ => return Err(bad("collab.cursor", "give both `x` and `y` (page coordinates), or neither to hide the cursor")),
-    };
-    if let Some(l) = s.live_mut() {
-        l.cursor = at;
-    }
-    s.live_sync();
-    Ok(json!({"cursor": s.live().cursor.map(|(x, y)| [x, y])}))
-}
-
-fn cursor_chat(s: &mut Session, p: &Value) -> Result<Value> {
-    let Some(v) = get(p, "text") else {
-        // The app's chat box (programmatic calls never open dialogs).
-        let open = s.signal_blocker().is_none();
-        if open {
-            s.request_ui("dialog.cursorChat", json!({}));
-        }
-        return Ok(json!({"open": open, "chat": s.live().chat}));
-    };
-    let text = v.as_str().ok_or_else(|| bad("collab.cursorChat", "`text` must be a string (empty closes the chat)"))?;
-    Ok(json!({"chat": s.live_chat(text)?}))
-}
-
-fn spotlight(s: &mut Session, p: &Value) -> Result<Value> {
-    let on = match get(p, "on") {
-        None => !s.live().spotlighting,
-        Some(v) => v.as_bool().ok_or_else(|| bad("collab.spotlight", "`on` must be true or false"))?,
-    };
-    s.live_spotlight(on)?;
-    Ok(json!({"spotlighting": s.live().spotlighting}))
-}
-
-pub fn specs() -> Vec<CommandSpec> {
-    vec![
-        spec!(
-            "collab.host",
-            "Start live session",
-            "{port? (default 47900, else any free port), bind?: \"local\" (this machine, default) | \"lan\" (the local network) | an IP address} → the open file's session: {session, link, url (invites: they carry the secret token), address, …}; sessions are per file, so other files' sessions go on (a session this file was in ends)",
-            false,
-            host
-        ),
-        spec!(
-            "collab.share",
-            "Share with a join code",
-            "{via?: \"online\" (default: the open file is kept on the server in Preferences, `pref.publishServer`, and the server hands out the codes) | \"local\" (this app hosts it for people on the same network; no server), access?: \"edit\" (default) | \"view\" (online only: which code `code` is), server? (online: another server's address, with ?key=… when it needs its key), name? (online: the file's name there), port?, bind?: \"lan\" (default) | \"local\" (this machine only) | an IP address (local)} → the open file's session as `collab.peers` gives it: `code` is what others type to join (`collab.join {code}`, the Join field), `link` an invite link. Local: at once, the code carries the host's IPv4 address, port and secret (K7M2Q-…, 20 symbols). Online: status \"connecting\" first; once live `code` is the server's (K7M-2QX-9TD) and `share` is {via, access, shared, editCode, viewCode, editLink, viewLink}: links made for others (the file's own links in `published` stay yours); `code` stays null when the server is older than join codes (give `share.editLink` / `share.viewLink` instead). Called again while shared: only switches which code `code` is (`access`). Called after `collab.stop` on a file that is still on the server: new links and codes for that same file (nothing is published twice). `collab.stop` stops sharing",
-            false,
-            share
-        ),
-        spec!(
-            "collab.stop",
-            "Stop live session",
-            "{} → {ended}: the open file's session ends (a session this app hosts stops for everyone; a joined one is left). A file shared online with `collab.share` is different: its sharing stops → {ended: false, shared: false}: the links and codes others got are revoked on the server, whoever joined with them is disconnected at once (they keep their copy), and you stay in the file, which stays on the server, open only to you (`collab.share` shares it again with new codes; `collab.leave` leaves it there; `collab.manageFile {action: \"remove\"}` with its owner token takes it off the server)",
-            false,
-            stop
-        ),
-        spec!(
-            "collab.join",
-            "Join live session",
-            "{code: a join code (K7M-2QX-9TD from a server, asked at the server in Preferences; a longer one for the local network; spaces, dashes and case don't matter, O reads as 0 and I or L as 1) | link: figcraft://join?host=…&file=…&token=…, figcraft://join?server=ws(s)://…&file=…&token=… or ws(s)://host:port/?file=…&token=… (a session an app hosts, or a server's share link; a code here works too)} → the new session: {session, status: \"connecting\", …}; its file opens in a tab of its own (other files' sessions go on) and `collab.peers` tells when it's live (`sessions` lists it until then, and if it fails)",
-            false,
-            join
-        ),
-        spec!(
-            "collab.leave",
-            "Leave live session",
-            "{} (the open file's session; the synced file stays open as a local copy) → {ended}",
-            false,
-            leave
-        ),
-        spec!(
-            "collab.publish",
-            "Publish to server",
-            "{server: ws://host:port/?key=… or wss://host/path/?key=… (the server's address with its key; `figcraft-server key` prints it; without a key on a server open to the public), key? (when the address has none), name? (default: the file's name)} → status \"connecting\": the open file is uploaded as a new file and this tab syncs through the server; `collab.peers` then has `published: {server, file, name, edit, view, owner (published without a key: the owner token, shown once), expires (seconds since 1970, or null)}` and `hosting` (the server's operator, terms and idle expiry)",
-            false,
-            publish
-        ),
-        spec!(
-            "collab.serverInfo",
-            "Server info",
-            "{server: ws://host:port/ or wss://host/path/} → {open (anyone may publish without the key), operator, terms (a web address), idleDays (files published without the key are deleted after this many days unopened; null: kept), maxFileMb, expires}",
-            false,
-            server_info
-        ),
-        spec!(
-            "collab.manageFile",
-            "Manage published file",
-            "{file (its id), server?, owner? (the server's address and the owner token you got when you published the file without the key; each defaults to what is recorded for one of your online files, see `collab.files`), action: links | createLink {access?: view (default) | edit, label?} | revoke {link (a link's id)} | share (others get new links and join codes) | unshare (the links and codes others got are revoked; the file stays yours on the server) | rename {name} | remove (the file is deleted from the server and leaves your online files)} → {links: [{id, access, label, created}]} | {id, access, link (a new share link, shown once)} | {shared, code, viewCode, editLink, viewLink} | {done}",
-            false,
-            manage_file
-        ),
-        spec!(
-            "collab.report",
-            "Report file to server operator",
-            "{reason (a few words, at most 500 characters)} → {sent}: the file you joined on a server is reported to its operator; the session's message says when the server kept it (servers older than this app don't take reports)",
-            false,
-            report
-        ),
-        spec!(
-            "collab.peers",
-            "People in this file",
-            "{} → the open file's session (each open file has its own or none): {available, canHost (false in the browser: it can only join), session (its id; null: this file isn't in a session), status: off|connecting|live|reconnecting|failed, reason?, role, me, name, color, fileName, pages, link, url, address, network, access: edit|view (view: a server's view link; edits are refused), readOnly (the open file can't be edited now: view only, or being published), published (a file you published: {server, file, name, edit, view}), code (the join code to give others, when the file was shared with `collab.share`; null otherwise or while it is on its way), share ({via: online|local, access, shared (false: a file of yours on a server that nobody else gets into now), editCode, viewCode, editLink, viewLink (what others join with; null when not shared)} or null), follow, syncing, document (index of the synced open document), editing (the text layer you type in: {node, layer, caret, selection}), peers: [{id, name, color, editing (theirs, same shape, or null), presence: {cursor: [page, x, y], selection, viewport: [page, x, y, w, h], editing_text}}], sessions: [{session, document (index of its open document; null for a join on its way), status, reason, role, fileName, link, peers (how many others)}] (every session of the app)}",
-            false,
-            |s, _| Ok(s.live_summary())
-        ),
-        spec!("collab.follow", "Follow", "{client? (a peer's id; omit to stop following)} → {follow}", false, follow),
-        spec!(
-            "collab.removePerson",
-            "Remove from session",
-            "{client (a peer's id)} → {removed, name}: they are disconnected (they keep their copy) and can't join again from their address while the session runs; only the person hosting, or the owner of a file on a server, can do it",
-            false,
-            remove_person
-        ),
-        spec!(
-            "collab.cursor",
-            "Show cursor at",
-            "{x?, y? (page coordinates on the current page; omit both to hide)} → {cursor} (agents; in the app the pointer drives it): your pointer in the open file's session (null when the file isn't in one)",
-            false,
-            cursor
-        ),
-        spec!(
-            "collab.cursorChat",
-            "Cursor chat",
-            "{text? (shown next to your cursor for everyone, at most 100 characters; empty closes it; omit to open the chat box in the app)} → {chat} (or {open}); others see it fade after 5 s without changes",
-            false,
-            cursor_chat
-        ),
-        spec!(
-            "collab.spotlight",
-            "Spotlight me",
-            "{on? (default: toggle)} → {spotlighting}: everyone in the session follows your view and page until they move theirs",
-            false,
-            spotlight
-        ),
-    ]
-}
diff --git a/crates/engine/src/sharing/live/events.rs b/crates/engine/src/sharing/live/events.rs
new file mode 100644
index 00000000..5b6008f8
--- /dev/null
+++ b/crates/engine/src/sharing/live/events.rs
@@ -0,0 +1,408 @@
+use super::host::{clean_hosting, clean_shared};
+use super::types::{Event, PageInfo, Role, SessionId, Status};
+use super::*;
+
+impl Session {
+    /// The active document (`None`: no document is open).
+    pub(super) fn tab(&self) -> Option<u64> {
+        self.ds().ok().map(|d| d.uid)
+    }
+
+    /// The active document's live session (status off when it isn't in one). Everything the
+    /// window shows and the `collab.*` commands act on is this one.
+    pub fn live(&self) -> &Live {
+        self.live.on(self.tab())
+    }
+
+    /// The active document's live session, when it has one (running, on its way or failed).
+    pub fn live_mut(&mut self) -> Option<&mut Live> {
+        let id = self.live.shown(self.tab())?;
+        self.live.sessions.get_mut(&id)
+    }
+
+    /// Document `uid`'s live session (status off when it isn't in one).
+    pub fn live_of(&self, uid: u64) -> &Live {
+        self.live.on(Some(uid))
+    }
+
+    /// The active document is its session's synced document: page and layer ids in others'
+    /// presence refer to it.
+    pub fn live_shared(&self) -> bool {
+        self.tab().is_some_and(|uid| self.live_doc(uid))
+    }
+
+    /// Install a document that came from the session (others' edits): the selection, page and view
+    /// stay where they can, and the undo history isn't touched.
+    pub fn apply_remote(&mut self, uid: u64, doc: Arc<Document>) {
+        let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) else { return };
+        ds.doc = doc;
+        if !ds.doc.pages.contains(&ds.page) {
+            ds.page = ds.doc.first_page().unwrap_or(ds.page);
+        }
+        if ds.text_edit.as_ref().is_some_and(|t| !ds.doc.contains(t.id)) {
+            ds.text_edit = None;
+        }
+        if ds.vector_edit.as_ref().is_some_and(|v| !ds.doc.contains(v.id)) {
+            ds.vector_edit = None;
+        }
+        ds.clean_selection();
+        ds.revision += 1;
+    }
+
+    /// Your presence in the active document's session now: its page, selection, viewport and
+    /// edited text, and the pointer.
+    pub fn live_presence(&self) -> Presence {
+        self.presence_in(self.live())
+    }
+
+    /// Your presence in `live` (nothing while another document than its own is in front).
+    pub(super) fn presence_in(&self, live: &Live) -> Presence {
+        let Some(ds) = self.ds().ok().filter(|ds| live.tab == Some(ds.uid)) else { return Presence::default() };
+        let (x0, y0) = ds.view.origin();
+        let z = ds.view.zoom.max(1e-9);
+        sanitize(Presence {
+            cursor: live.cursor.map(|(x, y)| (ds.page, x, y)),
+            selection: Some(ds.selection.clone()),
+            viewport: Some((ds.page, x0, y0, ds.view.vw / z, ds.view.vh / z)),
+            editing_text: ds.text_edit.as_ref().map(|t| Box::new(editing_of(t))),
+        })
+    }
+
+    /// The others typing in text layer `id` of the active document, in its session.
+    pub fn live_text_editors(&self, id: NodeId) -> Vec<&Peer> {
+        if !self.live_shared() {
+            return Vec::new();
+        }
+        let live = self.live();
+        live.presence.iter().filter(|(_, p)| p.editing_text.as_ref().is_some_and(|e| e.node == id)).filter_map(|(c, _)| live.peers.get(c)).collect()
+    }
+
+    /// You started typing in text layer `id`: say so when someone else is typing in it too (both
+    /// edits sync when they finish; the one finished last wins).
+    pub(crate) fn live_text_notice(&mut self, id: NodeId) {
+        let names: Vec<&str> = self.live_text_editors(id).iter().map(|p| p.name.as_str()).collect();
+        if let Some(hint) = editing_hint(&names) {
+            self.message = Some(format!("{hint} too: the version finished last is kept"));
+        }
+    }
+
+    /// Take in what happened in every session (the UI calls it every frame; the network wakes the
+    /// UI when something arrives). Returns whether anything changed.
+    pub fn live_poll(&mut self) -> bool {
+        let Some(link) = self.live.link.as_mut() else { return false };
+        let events = link.poll();
+        if events.is_empty() {
+            return false;
+        }
+        for (id, e) in events {
+            self.live_event(id, e);
+        }
+        self.live_closed();
+        for id in self.live.sessions.keys().copied().collect::<Vec<_>>() {
+            self.live_deferred(id);
+            self.live_follow_apply(id);
+        }
+        self.online_recoveries();
+        true
+    }
+
+    fn live_event(&mut self, id: SessionId, e: Event) {
+        let e = match e {
+            Event::Library { link, reply } => return self.library_answer(&link, reply),
+            Event::Net { job, reply } => return self.background_answer(job, *reply),
+            e => e,
+        };
+        // A session left meanwhile: what was still on its way is dropped.
+        let front = self.tab();
+        let Some(live) = self.live.sessions.get_mut(&id) else { return };
+        // What happens in a file that isn't in front says which file (by its tab's name).
+        let open = self.docs.iter().find(|d| Some(d.uid) == live.doc_uid).map(|d| d.doc.name.as_str());
+        let behind = open.or(live.file_name()).filter(|_| live.tab != front).map(|n| format!(" {n}")).unwrap_or_default();
+        match e {
+            Event::Status(Status::Failed { reason }) => self.live_fail(id, reason),
+            Event::Status(Status::Off) => {
+                self.live.end(id);
+            }
+            Event::Status(st) => {
+                // Who's here comes again with the next welcome; edits wait for it.
+                if let Status::Reconnecting { .. } = st {
+                    live.peers.clear();
+                    live.presence.clear();
+                    live.sent = None;
+                    // Until the host says it reads them again (a spotlight of yours goes out
+                    // again then).
+                    live.signals = false;
+                    live.chats.clear();
+                    live.chat.clear();
+                    live.spotlight = None;
+                    if let Some(c) = live.client.as_mut() {
+                        c.disconnect();
+                    }
+                }
+                live.status = st;
+            }
+            Event::Welcome { mut info, peers } => {
+                // The shared file's name and pages come with the document (the sync welcome).
+                if let Some(old) = live.info.as_ref().filter(|_| info.file_name.is_empty()) {
+                    info.file_name = old.file_name.clone();
+                    info.pages = old.pages.clone();
+                }
+                live.status = Status::Live;
+                live.info = Some(info);
+                live.peers = peers.into_iter().map(|p| (p.client_id, p)).collect();
+                live.presence.retain(|id, _| live.peers.contains_key(id));
+                if live.follow.is_some_and(|f| !live.peers.contains_key(&f)) {
+                    live.unfollow();
+                }
+                // Others need your presence again.
+                live.sent = None;
+            }
+            Event::PeerJoined(p) => {
+                self.message = Some(format!("{} joined{behind}", p.name));
+                live.peers.insert(p.client_id, p);
+            }
+            Event::PeerLeft(peer) => {
+                live.presence.remove(&peer);
+                live.chats.remove(&peer);
+                if live.spotlight == Some(peer) {
+                    live.spotlight = None;
+                }
+                if let Some(p) = live.peers.remove(&peer) {
+                    self.message = Some(format!("{} left{behind}", p.name));
+                }
+                if live.follow == Some(peer) {
+                    live.unfollow();
+                }
+            }
+            Event::Presence(peer, p) => {
+                if live.peers.contains_key(&peer) {
+                    live.presence.insert(peer, p);
+                }
+            }
+            Event::Signal(peer, sig) => self.live_signal_in(id, peer, sig),
+            Event::Sync(welcome @ ServerMsg::Welcome { .. }) if live.client.is_none() => self.live_welcome(id, welcome),
+            // Batches, and the welcome back after a dropped connection: the client catches up in
+            // order.
+            Event::Sync(msg) => live.deferred.push(msg),
+            Event::Ended { reason } => {
+                self.message = Some(if behind.is_empty() { reason } else { format!("{}: {reason}", behind.trim_start()) });
+                self.live.end(id);
+            }
+            Event::Published(p) => {
+                // Shared with a code: the popover shows it, nothing more to say.
+                if live.share.is_none() {
+                    self.message = Some(format!("Published {} to the server", p.name));
+                }
+                let server = live.server.clone();
+                live.published = Some(p.clone());
+                self.online_published(&server, &p);
+            }
+            Event::Shared(Ok(links)) => {
+                let links = clean_shared(links);
+                match live.server_file() {
+                    Some((server, file)) => self.online_shared(&server, &file, Some(links)),
+                    None => {
+                        if let Some(share) = live.share.as_mut() {
+                            share.links = Some(links);
+                        }
+                    }
+                }
+            }
+            Event::Shared(Err(why)) => self.message = Some(format!("The file is on the server, but couldn't be shared: {why}")),
+            Event::Hosting(info) => live.hosting = Some(clean_hosting(info)),
+            Event::Reported(error) => {
+                self.message =
+                    Some(error.map_or_else(|| "Your report was sent to the server's operator".into(), |e| format!("The report wasn't sent: {e}")));
+            }
+            // Answered above.
+            Event::Library { .. } | Event::Net { .. } => {}
+        }
+    }
+
+    /// Someone's cursor chat or spotlight in session `id` (checked again: the host is untrusted
+    /// too), or the host saying it reads them.
+    fn live_signal_in(&mut self, id: SessionId, peer: u32, sig: Signal) {
+        let Some(sig) = sig.clean() else { return };
+        let Some(live) = self.live.sessions.get_mut(&id) else { return };
+        let name = live.peers.get(&peer).map(|p| p.name.clone());
+        match (sig.kind.as_str(), name) {
+            (Signal::READY, _) if live.info.as_ref().is_some_and(|i| i.me == peer) => {
+                live.signals = true;
+                if live.spotlighting {
+                    self.live.send(id, [ClientMsg::Signal(Signal::spotlight(true))]);
+                }
+            }
+            (Signal::CHAT, Some(_)) if sig.text.is_empty() => {
+                live.chats.remove(&peer);
+            }
+            (Signal::CHAT, Some(_)) => {
+                live.chats.insert(peer, sig.text);
+            }
+            (Signal::SPOTLIGHT, Some(name)) if sig.on() => {
+                // Theirs takes over from yours or anyone else's.
+                live.spotlight = Some(peer);
+                live.spotlighting = false;
+                live.follow = Some(peer);
+                live.followed = None;
+                self.message = Some(format!("{name} is spotlighting: you follow their view (move it to stop)"));
+            }
+            (Signal::SPOTLIGHT, Some(name)) if live.spotlight == Some(peer) => {
+                live.spotlight = None;
+                if live.follow == Some(peer) {
+                    live.unfollow();
+                }
+                self.message = Some(format!("{name} stopped spotlighting"));
+            }
+            _ => {}
+        }
+    }
+
+    /// Why cursor chat or a spotlight can't go out now, if it can't.
+    pub(super) fn signal_blocker(&self) -> Option<&'static str> {
+        let live = self.live();
+        if live.status != Status::Live {
+            Some("cursor chat and spotlight need a live session")
+        } else if !live.signals {
+            Some("the session's host runs an older version without cursor chat and spotlight")
+        } else {
+            None
+        }
+    }
+
+    /// Show `text` next to your pointer for everyone (empty closes it); returns it as sent
+    /// (control characters out, at most [`Signal::MAX_CHAT`] characters).
+    pub fn live_chat(&mut self, text: &str) -> Result<String> {
+        let sig = Signal::chat(text).clean().unwrap_or_default();
+        if sig.text.is_empty() && self.live().chat.is_empty() {
+            return Ok(String::new());
+        }
+        if let Some(why) = self.signal_blocker() {
+            return Err(EngineError::Disabled("collab.cursorChat".into(), why.into()));
+        }
+        let Some(live) = self.live_mut() else { return Ok(String::new()) };
+        if sig.text != live.chat {
+            live.chat.clone_from(&sig.text);
+            let id = live.id;
+            self.live.send(id, [ClientMsg::Signal(sig.clone())]);
+        }
+        Ok(sig.text)
+    }
+
+    /// Start (`on`) or stop asking everyone to follow your view.
+    pub fn live_spotlight(&mut self, on: bool) -> Result<()> {
+        if on == self.live().spotlighting {
+            return Ok(());
+        }
+        if on && let Some(why) = self.signal_blocker() {
+            return Err(EngineError::Disabled("collab.spotlight".into(), why.into()));
+        }
+        let Some(live) = self.live_mut() else { return Ok(()) };
+        if on {
+            live.unfollow();
+            live.spotlight = None;
+        }
+        live.spotlighting = on;
+        let id = live.id;
+        self.live.send(id, [ClientMsg::Signal(Signal::spotlight(on))]);
+        Ok(())
+    }
+
+    /// Session `id`'s welcome: start the sync client; the host keeps editing the document it
+    /// shared, a guest opens the host's file as a new tab (or gets it again in that tab after a
+    /// reconnect).
+    fn live_welcome(&mut self, id: SessionId, welcome: ServerMsg) {
+        let client = match Client::join(welcome) {
+            Ok(c) => c,
+            Err(e) => return self.live_fail(id, format!("Couldn't open the shared file: {e}")),
+        };
+        let Some(live) = self.live.sessions.get(&id) else { return };
+        let existing = live.doc_uid.filter(|u| self.docs.iter().any(|d| d.uid == *u));
+        let (uid, synced) = match (live.role(), existing) {
+            (Some(Role::Host), Some(uid)) => {
+                if let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) {
+                    let was_dirty = ds.is_dirty();
+                    // Undo is per user from now on: earlier whole-document steps would revert
+                    // others' edits.
+                    ds.history.undo.clear();
+                    ds.history.redo.clear();
+                    ds.doc_mut().set_client_id(client.id());
+                    if !was_dirty {
+                        ds.mark_saved();
+                    }
+                }
+                // Edits made since hosting started go out with the first sync.
+                (uid, None)
+            }
+            (Some(Role::Guest), Some(uid)) => {
+                // Joining again in this tab, or the file you published arriving from the server.
+                let doc = Arc::new(client.document().clone());
+                let was_dirty = self.docs.iter().find(|d| d.uid == uid).is_some_and(DocState::is_dirty);
+                self.apply_remote(uid, doc.clone());
+                if let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) {
+                    // Undo is per user from now on: earlier whole-document steps would revert
+                    // others' edits.
+                    ds.history.undo.clear();
+                    ds.history.redo.clear();
+                    if !was_dirty {
+                        ds.mark_saved();
+                    }
+                }
+                (uid, Some(doc))
+            }
+            (Some(Role::Guest), None) => {
+                // The session's file gets a tab of its own, in front.
+                let ds = DocState::new(client.document().clone(), None);
+                self.message = Some(format!("Joined {}", ds.doc.name));
+                let opened = (ds.uid, Some(ds.doc.clone()));
+                self.active = self.docs.len();
+                self.docs.push(ds);
+                opened
+            }
+            _ => return,
+        };
+        // A view link: the editing tools are off.
+        if client.access() == Access::View && self.tab() == Some(uid) && !matches!(self.tool.tool, ToolId::Move | ToolId::Hand) {
+            self.set_tool(ToolId::Move);
+        }
+        let Some(live) = self.live.sessions.get_mut(&id) else { return };
+        let doc = client.document();
+        if let Some(info) = live.info.as_mut() {
+            info.file_name = doc.name.clone();
+            info.pages = doc.pages.iter().map(|p| PageInfo { id: p.0, name: doc.node(*p).map(|n| n.name.clone()).unwrap_or_default() }).collect();
+        }
+        live.doc_uid = Some(uid);
+        live.tab = Some(uid);
+        live.synced = synced;
+        live.client = Some(client);
+        live.deferred.clear();
+    }
+
+    /// Session `id` is over with a message: it couldn't be joined, the connection was lost for
+    /// good or sync broke. Its tab shows why.
+    pub(super) fn live_fail(&mut self, id: SessionId, reason: String) {
+        log::warn!("live session: {reason}");
+        self.live.leave(id);
+        if let Some(live) = self.live.sessions.get_mut(&id) {
+            live.reset();
+            live.status = Status::Failed { reason: reason.clone() };
+        }
+        self.message = Some(reason);
+    }
+
+    /// Why document `uid` can't be edited now, if it can't: you may only view it in its session,
+    /// or it is on its way to a server.
+    pub fn live_read_only(&self, uid: u64) -> Option<&'static str> {
+        let live = self.live.doc(uid)?;
+        match &live.client {
+            Some(c) if c.access() == Access::View => Some(VIEW_ONLY),
+            Some(_) => None,
+            None if live.status.active() && live.role() != Some(Role::Host) => Some(PUBLISHING),
+            None => None,
+        }
+    }
+
+    /// The active document can't be edited now (see [`live_read_only`](Self::live_read_only)).
+    pub fn active_read_only(&self) -> Option<&'static str> {
+        self.tab().and_then(|uid| self.live_read_only(uid))
+    }
+}
diff --git a/crates/engine/src/sharing/live/host.rs b/crates/engine/src/sharing/live/host.rs
new file mode 100644
index 00000000..685ab5c0
--- /dev/null
+++ b/crates/engine/src/sharing/live/host.rs
@@ -0,0 +1,272 @@
+use super::types::{Bind, HostOptions, NetReply, NetRequest, ONLINE_OFF, PublishOptions, Role, SessionId, Share, Shared, SharedLink, Status, Via};
+use super::*;
+
+/// What a server says about its hosting, made safe to show: no control characters, short, and a
+/// terms address only when it is a web page (`http(s)://`).
+pub(super) fn clean_hosting(mut info: HostInfo) -> HostInfo {
+    let clean = |s: &str, n: usize| s.trim().chars().filter(|c| !c.is_control()).take(n).collect::<String>();
+    info.operator = clean(&info.operator, 120);
+    info.terms = clean(&info.terms, 500);
+    let web = info.terms.starts_with("https://") || info.terms.starts_with("http://");
+    if !web || info.terms.contains(char::is_whitespace) {
+        info.terms.clear();
+    }
+    info
+}
+
+/// A server's hosting as JSON (`collab.peers`, `collab.serverInfo`).
+pub fn hosting_json(h: &HostInfo) -> Value {
+    json!({
+        "open": h.open,
+        "operator": h.operator,
+        "terms": h.terms,
+        "idleDays": (h.idle_secs > 0).then(|| (h.idle_secs as f64 / 86_400.0 * 100.0).round() / 100.0),
+        "maxFileMb": h.max_file_mb,
+        "expires": h.expires,
+    })
+}
+
+pub(super) fn unavailable(cmd: &str) -> EngineError {
+    EngineError::Disabled(
+        cmd.to_string(),
+        "live sessions aren't available here (the desktop app and the MCP server host and join them; the web build joins)".into(),
+    )
+}
+
+pub(super) fn host(s: &mut Session, p: &Value) -> Result<Value> {
+    start_host(s, "collab.host", p, Bind::Local, false)?;
+    Ok(s.live_summary())
+}
+
+/// Start hosting the open file for command `cmd` (on `bind` unless `p` says where; `short`: with
+/// a secret a join code can carry): the new session.
+fn start_host(s: &mut Session, cmd: &str, p: &Value, bind: Bind, short: bool) -> Result<SessionId> {
+    let port = match get(p, "port") {
+        None => None,
+        Some(v) => Some(v.as_u64().and_then(|n| u16::try_from(n).ok()).ok_or_else(|| bad(cmd, "`port` must be a whole number from 0 to 65535"))?),
+    };
+    let bind = match string(p, "bind").as_deref().map(str::trim) {
+        None => bind,
+        Some("local") => Bind::Local,
+        Some("lan") => Bind::Lan,
+        Some(other) => other.parse::<IpAddr>().map(Bind::Addr).map_err(|_| bad(cmd, "`bind` must be \"local\", \"lan\" or an IP address"))?,
+    };
+    let (doc, uid) = s.ds().map(|ds| (ds.doc.clone(), ds.uid))?;
+    let opts = HostOptions { port, bind, name: display_name(&s.prefs), doc, short };
+    let (id, info) = s.live.start(cmd, |l, id| l.host(id, opts).map_err(|e| EngineError::Other(format!("couldn't start the live session: {e}"))))?;
+    s.live.open(Live { id, status: Status::Live, info: Some(info), doc_uid: Some(uid), tab: Some(uid), ..Live::default() });
+    Ok(id)
+}
+
+pub(super) fn publish(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "collab.publish";
+    let server = req_string(CMD, p, "server")?;
+    start_publish(s, CMD, &server, p, false)?;
+    Ok(s.live_summary())
+}
+
+/// Start publishing the open file to `server` for command `cmd` (`share`: with links and join
+/// codes for others too): the new session.
+fn start_publish(s: &mut Session, cmd: &str, server: &str, p: &Value, share: bool) -> Result<SessionId> {
+    let key = string(p, "key").map(|k| k.trim().to_string()).filter(|k| !k.is_empty());
+    let (doc, uid) = s.ds().map(|ds| (ds.doc.clone(), ds.uid))?;
+    let name = string(p, "name").map(|n| n.trim().chars().filter(|c| !c.is_control()).take(256).collect::<String>()).filter(|n| !n.is_empty());
+    let me = display_name(&s.prefs);
+    let opts = PublishOptions { server: server.trim().to_string(), key, name: name.unwrap_or_else(|| doc.name.clone()), me, doc, share };
+    let (id, ()) = s.live.start(cmd, |l, id| l.publish(id, opts).map_err(|e| bad(cmd, e)))?;
+    // This tab becomes the server file's synced document once it is there.
+    s.live.open(Live { id, status: Status::Connecting, doc_uid: Some(uid), tab: Some(uid), server: server.trim().to_string(), ..Live::default() });
+    Ok(id)
+}
+
+/// Why a local network share has no view-only code.
+const LOCAL_EDITS: &str = "everyone who joins a file shared on the local network can edit it: share it online for a view-only code";
+
+pub(super) fn share(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "collab.share";
+    let via = match string(p, "via").as_deref().map(str::trim) {
+        None | Some("online") => Via::Online,
+        Some("local") => Via::Local,
+        Some(_) => return Err(bad(CMD, "`via` must be \"online\" or \"local\"")),
+    };
+    let access = match string(p, "access") {
+        None => None,
+        Some(a) => Some(Access::parse(&a).ok_or_else(|| bad(CMD, "`access` must be \"edit\" or \"view\""))?),
+    };
+    // A share of this file is there already: only which code is shown changes, or (the file is
+    // on the server, not shared at the moment) it gets new links and codes. Nothing is published
+    // twice.
+    if let Some(shared) = s.live().share.as_ref().filter(|_| s.live().status.active()).map(|sh| sh.via) {
+        if get(p, "via").is_some() && shared != via {
+            return Err(bad(
+                CMD,
+                "this file is shared the other way already: stop sharing it first (collab.stop), or leave its session (collab.leave)",
+            ));
+        }
+        if access == Some(Access::View) && shared == Via::Local {
+            return Err(bad(CMD, LOCAL_EDITS));
+        }
+        if let Some(req) = share_request(s, Vec::new(), true).filter(|_| s.live().share.as_ref().is_some_and(|sh| sh.links.is_none())) {
+            let links = share_answer(s, req)?.ok_or_else(|| EngineError::Other("the server made no links".into()))?;
+            shared_now(s, Some(clean_shared(links)));
+        }
+        if let (Some(a), Some(sh)) = (access, s.live_mut().and_then(|l| l.share.as_mut())) {
+            sh.access = a;
+        }
+        return Ok(s.live_summary());
+    }
+    let access = access.unwrap_or_default();
+    let mut server = String::new();
+    let id = match via {
+        Via::Local if access == Access::View => return Err(bad(CMD, LOCAL_EDITS)),
+        Via::Local => start_host(s, CMD, p, Bind::Lan, true)?,
+        Via::Online => {
+            server = string(p, "server").unwrap_or_else(|| s.prefs.publish_server.clone()).trim().to_string();
+            if server.is_empty() {
+                return Err(EngineError::Disabled(CMD.into(), ONLINE_OFF.into()));
+            }
+            start_publish(s, CMD, &server, p, true)?
+        }
+    };
+    if let Some(live) = s.live.sessions.get_mut(&id) {
+        // On the local network the session's own link is what others join with, and the code says
+        // what the link says: where the session is and its secret. (Online they arrive with the file.)
+        let links = live.info.as_ref().filter(|_| via == Via::Local).map(|i| {
+            let code = code::Local::from_link(&i.link).map(|l| l.code());
+            Shared { edit: SharedLink { id: String::new(), link: i.link.clone(), code }, view: None }
+        });
+        live.share = Some(Share { via, server, access, links });
+    }
+    Ok(s.live_summary())
+}
+
+/// What others join the open file's server file with changed: in its session and its record.
+pub(super) fn shared_now(s: &mut Session, links: Option<Shared>) {
+    if let Some((server, file)) = s.live().server_file() {
+        s.online_shared(&server, &file, links);
+    }
+}
+
+/// Links and codes as a server gave them, with only codes that are codes (nine symbols).
+pub(crate) fn clean_shared(mut links: Shared) -> Shared {
+    let clean = |l: &mut SharedLink| l.code = l.code.take().and_then(|c| code::normalize(&c).ok()).filter(|c| c.len() == code::ONLINE_LEN);
+    clean(&mut links.edit);
+    links.view.as_mut().map(clean);
+    links
+}
+
+/// The request that changes who else gets into the server file the open file's session is its
+/// owner's session of (`None`: it isn't one, or the file isn't there yet).
+pub(super) fn share_request(s: &Session, revoke: Vec<String>, create: bool) -> Option<NetRequest> {
+    let live = s.live();
+    let (share, published) = (live.share.as_ref().filter(|s| s.via == Via::Online)?, live.published.as_ref()?);
+    if live.status != Status::Live {
+        return None;
+    }
+    // The token this session got when it published the file, else the recorded one.
+    let owner = published.owner.clone().or_else(|| s.online_owner(&share.server, &published.file)).unwrap_or_default();
+    Some(NetRequest::Share { server: share.server.clone(), file: published.file.clone(), owner, revoke, create })
+}
+
+/// Send `req` ([`NetRequest::Share`]): the new links, if it made any.
+pub(crate) fn share_answer(s: &mut Session, req: NetRequest) -> Result<Option<Shared>> {
+    match s.net(req)?.0 {
+        NetReply::Share(Ok(links)) => Ok(links),
+        NetReply::Share(Err(why)) => Err(EngineError::Other(why)),
+        _ => Err(EngineError::Other("the server answered something else".into())),
+    }
+}
+
+/// What the server at `server` says about its hosting, and its answer to `req` about `file` with
+/// its owner token (`collab.serverInfo`, `collab.manageFile`).
+pub(super) fn hosting_request(
+    s: &mut Session,
+    cmd: &str,
+    server: &str,
+    file: &str,
+    owner: &str,
+    req: Option<Admin>,
+) -> Result<(HostInfo, Option<AdminReply>)> {
+    let req = NetRequest::Hosting { server: server.to_string(), file: file.to_string(), owner: owner.to_string(), req };
+    match s.net(req)?.0 {
+        // The server's refusals say why themselves.
+        NetReply::Hosting(Ok((_, Some(AdminReply::Failed { reason })))) | NetReply::Hosting(Err(reason)) => Err(EngineError::Other(reason)),
+        NetReply::Hosting(Ok((info, reply))) => Ok((clean_hosting(info), reply)),
+        _ => Err(EngineError::Other(format!("{cmd}: the server answered something else"))),
+    }
+}
+
+pub(super) fn server_info(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "collab.serverInfo";
+    let server = req_string(CMD, p, "server")?;
+    let (info, _) = hosting_request(s, CMD, server.trim(), "", "", None)?;
+    Ok(hosting_json(&info))
+}
+
+pub(super) fn manage_file(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "collab.manageFile";
+    let file = req_string(CMD, p, "file")?.trim().to_string();
+    let (server, owner) = crate::online::manager(s, CMD, p, &file)?;
+    let action = req_string(CMD, p, "action")?;
+    let mut renamed = None;
+    let req = match action.trim() {
+        "share" => return crate::online::set_shared(s, CMD, &server, &file, &owner, true),
+        "unshare" => return crate::online::set_shared(s, CMD, &server, &file, &owner, false),
+        "links" => Admin::Links { file: file.clone() },
+        "createLink" => {
+            let access = match string(p, "access").as_deref().map(str::trim) {
+                None | Some("view") => Access::View,
+                Some("edit") => Access::Edit,
+                Some(_) => return Err(bad(CMD, "`access` must be \"edit\" or \"view\"")),
+            };
+            Admin::CreateLink { file: file.clone(), access, label: string(p, "label").unwrap_or_default() }
+        }
+        "revoke" => Admin::Revoke { file: file.clone(), link: req_string(CMD, p, "link")?.trim().to_string() },
+        "rename" => {
+            let name = req_string(CMD, p, "name")?;
+            renamed = Some(name.clone());
+            Admin::Rename { file: file.clone(), name }
+        }
+        "remove" => Admin::Remove { file: file.clone() },
+        _ => return Err(bad(CMD, "`action` must be links, createLink, revoke, share, unshare, rename or remove")),
+    };
+    let changes = matches!(req, Admin::Rename { .. } | Admin::Remove { .. });
+    let reply = hosting_request(s, CMD, &server, &file, &owner, Some(req))?.1;
+    // The record follows what the server did.
+    if changes && reply == Some(AdminReply::Done) {
+        crate::online::managed(s, &server, &file, renamed.as_deref());
+        if renamed.is_none() {
+            crate::online::removed(s, &server, &file);
+        }
+    }
+    match reply {
+        Some(AdminReply::Links(links)) => Ok(json!({"links": links.iter().map(|l| json!({
+            "id": l.id, "access": l.access.id(), "label": l.label, "created": l.created
+        })).collect::<Vec<_>>()})),
+        // The link layer gives the new link whole in place of its token.
+        Some(AdminReply::Link(l)) => Ok(json!({"id": l.link.id, "access": l.link.access.id(), "link": l.token})),
+        Some(AdminReply::Done) => Ok(json!({"done": true})),
+        _ => Err(bad(CMD, "the server answered something else")),
+    }
+}
+
+pub(super) fn report(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "collab.report";
+    let reason: String = req_string(CMD, p, "reason")?.trim().chars().map(|c| if c.is_control() { ' ' } else { c }).take(MAX_REPORT).collect();
+    if reason.is_empty() {
+        return Err(bad(CMD, "say in a few words what is wrong with the file (`reason`)"));
+    }
+    let live = s.live();
+    if live.status != Status::Live || live.role() != Some(Role::Guest) {
+        return Err(bad(CMD, "join a file on a FigCraft server first: reports go to that server's operator"));
+    }
+    if live.hosting.is_none() {
+        return Err(bad(CMD, "this server doesn't take reports (it is older than this app); contact its operator another way"));
+    }
+    let id = live.id;
+    s.live.send(id, [ClientMsg::Report { reason }]);
+    Ok(json!({"sent": true}))
+}
+
+/// Longest report sent (characters).
+pub const MAX_REPORT: usize = 500;
diff --git a/crates/engine/src/sharing/live/join.rs b/crates/engine/src/sharing/live/join.rs
new file mode 100644
index 00000000..972198ef
--- /dev/null
+++ b/crates/engine/src/sharing/live/join.rs
@@ -0,0 +1,259 @@
+use super::host::{host, hosting_request, manage_file, publish, report, server_info, share, share_answer, share_request, shared_now, unavailable};
+use super::types::{Published, Role, SessionId, Share, Status, join_target};
+use super::*;
+
+fn join(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "collab.join";
+    let typed = match string(p, "code") {
+        Some(code) => code,
+        None => req_string(CMD, p, "link").map_err(|_| bad(CMD, "give the join `code` you were told, or the invite `link`"))?,
+    };
+    let link = join_target(&s.prefs.publish_server, &typed).map_err(|e| bad(CMD, e))?;
+    let id = start_join(s, CMD, &link, None, None, None)?;
+    Ok(s.live.get(id).map_or(Value::Null, |l| s.summary(l)))
+}
+
+/// Start joining the session behind `link` for command `cmd`: the new session. `published` and
+/// `share`: the file is yours on a server (`collab.openFile`), with what others join it with;
+/// `resume`: as the client you were there.
+pub(crate) fn start_join(
+    s: &mut Session,
+    cmd: &str,
+    link: &str,
+    published: Option<Published>,
+    share: Option<Share>,
+    resume: Option<Resume>,
+) -> Result<SessionId> {
+    let (name, tab) = (display_name(&s.prefs), s.tab());
+    let (id, ()) = s.live.start(cmd, |l, id| l.join_resuming(id, link, &name, resume).map_err(|e| bad(cmd, e)))?;
+    let server = share.as_ref().map(|s| s.server.clone()).unwrap_or_default();
+    // The session's file opens in a tab of its own; until then the join shows on this one.
+    s.live.open(Live { id, status: Status::Connecting, tab, server, published, share, ..Live::default() });
+    Ok(id)
+}
+
+fn leave(s: &mut Session, _: &Value) -> Result<Value> {
+    let ended = s.live.shown(s.tab()).and_then(|id| s.live.end(id));
+    if ended.as_ref().is_some_and(|l| l.syncing() && l.role() == Some(Role::Guest)) {
+        s.message = Some("You left the session; your copy stays open here".into());
+    }
+    Ok(json!({"ended": ended.is_some_and(|l| l.status.active())}))
+}
+
+fn stop(s: &mut Session, p: &Value) -> Result<Value> {
+    // A file shared online stays its owner's on the server: stopping takes the others' links (and
+    // their codes) away, which disconnects whoever joined with them, and the owner stays in the
+    // file. Anything else (a session this app hosts, one it joined, a file not shared now) ends.
+    let shared = s.live().share.as_ref().and_then(|sh| sh.links.as_ref());
+    let ids: Vec<String> = shared.into_iter().flat_map(|l| [Some(&l.edit), l.view.as_ref()]).flatten().map(|l| l.id.clone()).collect();
+    let Some(req) = share_request(s, ids, false).filter(|_| shared.is_some()) else { return leave(s, p) };
+    share_answer(s, req).map_err(|e| EngineError::Other(format!("couldn't stop sharing (the others can still get in): {e}")))?;
+    shared_now(s, None);
+    s.message = Some("Sharing stopped: the file stays on the server, open only to you".into());
+    Ok(json!({"ended": false, "shared": false}))
+}
+
+fn follow(s: &mut Session, p: &Value) -> Result<Value> {
+    match get(p, "client") {
+        None => {
+            s.live_unfollow();
+        }
+        Some(v) => {
+            let id = v.as_u64().and_then(|n| u32::try_from(n).ok()).ok_or_else(|| bad("collab.follow", "`client` must be a client id"))?;
+            s.live_follow(id)?;
+        }
+    }
+    Ok(json!({"follow": s.live().follow}))
+}
+
+/// Remove someone from the open file's session: in a session this app hosts, the hub drops them;
+/// in a file of yours on a server, the server does (with the file's owner token). They are told
+/// the session is over for them, keep their copy, and can't join again from their address while
+/// the session (or the server) runs.
+fn remove_person(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "collab.removePerson";
+    let client =
+        get(p, "client").and_then(Value::as_u64).and_then(|n| u32::try_from(n).ok()).ok_or_else(|| bad(CMD, "`client` must be a client id"))?;
+    let live = s.live();
+    if live.status != Status::Live {
+        return Err(bad(CMD, "the open file isn't in a live session"));
+    }
+    let name =
+        live.peers.get(&client).map(|p| p.name.clone()).ok_or_else(|| bad(CMD, format!("nobody with client id {client} is in the session")))?;
+    let (id, role, server_file) = (live.id, live.role(), live.server_file());
+    match (role, server_file) {
+        (Some(Role::Host), _) => {
+            let link = s.live.link.as_deref_mut().ok_or_else(|| unavailable(CMD))?;
+            link.remove(id, client).map_err(EngineError::Other)?;
+        }
+        (Some(Role::Guest), Some((server, file))) => {
+            let owner =
+                s.live().published.as_ref().and_then(|p| p.owner.clone()).or_else(|| s.online_owner(&server, &file)).filter(|o| !o.is_empty());
+            let owner = owner.ok_or_else(|| bad(CMD, "only the file's owner can remove people from it"))?;
+            let req = Some(Admin::RemovePeer { file: file.clone(), client });
+            match hosting_request(s, CMD, &server, &file, &owner, req) {
+                Ok((_, Some(AdminReply::Done))) => {}
+                Ok(_) => return Err(EngineError::Other(format!("couldn't remove {name}: the server answered something else"))),
+                // A server older than this request can't read it.
+                Err(e) => return Err(EngineError::Other(format!("couldn't remove {name}: {e} (the server may be older than removing people)"))),
+            }
+        }
+        _ => return Err(bad(CMD, "only the person hosting the session, or the file's owner, can remove people")),
+    }
+    s.message = Some(format!("{name} was removed from the session"));
+    Ok(json!({"removed": client, "name": name}))
+}
+
+/// You may remove others from the open file's session: you host it, or it is your file on a
+/// server.
+pub fn can_remove_people(s: &Session) -> bool {
+    let live = s.live();
+    live.status == Status::Live
+        && match live.role() {
+            Some(Role::Host) => true,
+            Some(Role::Guest) => live.server_file().is_some_and(|(server, file)| {
+                live.published.as_ref().and_then(|p| p.owner.as_deref()).is_some_and(|o| !o.is_empty())
+                    || s.online_owner(&server, &file).is_some_and(|o| !o.is_empty())
+            }),
+            None => false,
+        }
+}
+
+fn cursor(s: &mut Session, p: &Value) -> Result<Value> {
+    let at = match (num(p, "x"), num(p, "y")) {
+        (Some(x), Some(y)) => Some((x, y)),
+        (None, None) => None,
+        _ => return Err(bad("collab.cursor", "give both `x` and `y` (page coordinates), or neither to hide the cursor")),
+    };
+    if let Some(l) = s.live_mut() {
+        l.cursor = at;
+    }
+    s.live_sync();
+    Ok(json!({"cursor": s.live().cursor.map(|(x, y)| [x, y])}))
+}
+
+fn cursor_chat(s: &mut Session, p: &Value) -> Result<Value> {
+    let Some(v) = get(p, "text") else {
+        // The app's chat box (programmatic calls never open dialogs).
+        let open = s.signal_blocker().is_none();
+        if open {
+            s.request_ui("dialog.cursorChat", json!({}));
+        }
+        return Ok(json!({"open": open, "chat": s.live().chat}));
+    };
+    let text = v.as_str().ok_or_else(|| bad("collab.cursorChat", "`text` must be a string (empty closes the chat)"))?;
+    Ok(json!({"chat": s.live_chat(text)?}))
+}
+
+fn spotlight(s: &mut Session, p: &Value) -> Result<Value> {
+    let on = match get(p, "on") {
+        None => !s.live().spotlighting,
+        Some(v) => v.as_bool().ok_or_else(|| bad("collab.spotlight", "`on` must be true or false"))?,
+    };
+    s.live_spotlight(on)?;
+    Ok(json!({"spotlighting": s.live().spotlighting}))
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        spec!(
+            "collab.host",
+            "Start live session",
+            "{port? (default 47900, else any free port), bind?: \"local\" (this machine, default) | \"lan\" (the local network) | an IP address} → the open file's session: {session, link, url (invites: they carry the secret token), address, …}; sessions are per file, so other files' sessions go on (a session this file was in ends)",
+            false,
+            host
+        ),
+        spec!(
+            "collab.share",
+            "Share with a join code",
+            "{via?: \"online\" (default: the open file is kept on the server in Preferences, `pref.publishServer`, and the server hands out the codes) | \"local\" (this app hosts it for people on the same network; no server), access?: \"edit\" (default) | \"view\" (online only: which code `code` is), server? (online: another server's address, with ?key=… when it needs its key), name? (online: the file's name there), port?, bind?: \"lan\" (default) | \"local\" (this machine only) | an IP address (local)} → the open file's session as `collab.peers` gives it: `code` is what others type to join (`collab.join {code}`, the Join field), `link` an invite link. Local: at once, the code carries the host's IPv4 address, port and secret (K7M2Q-…, 20 symbols). Online: status \"connecting\" first; once live `code` is the server's (K7M-2QX-9TD) and `share` is {via, access, shared, editCode, viewCode, editLink, viewLink}: links made for others (the file's own links in `published` stay yours); `code` stays null when the server is older than join codes (give `share.editLink` / `share.viewLink` instead). Called again while shared: only switches which code `code` is (`access`). Called after `collab.stop` on a file that is still on the server: new links and codes for that same file (nothing is published twice). `collab.stop` stops sharing",
+            false,
+            share
+        ),
+        spec!(
+            "collab.stop",
+            "Stop live session",
+            "{} → {ended}: the open file's session ends (a session this app hosts stops for everyone; a joined one is left). A file shared online with `collab.share` is different: its sharing stops → {ended: false, shared: false}: the links and codes others got are revoked on the server, whoever joined with them is disconnected at once (they keep their copy), and you stay in the file, which stays on the server, open only to you (`collab.share` shares it again with new codes; `collab.leave` leaves it there; `collab.manageFile {action: \"remove\"}` with its owner token takes it off the server)",
+            false,
+            stop
+        ),
+        spec!(
+            "collab.join",
+            "Join live session",
+            "{code: a join code (K7M-2QX-9TD from a server, asked at the server in Preferences; a longer one for the local network; spaces, dashes and case don't matter, O reads as 0 and I or L as 1) | link: figcraft://join?host=…&file=…&token=…, figcraft://join?server=ws(s)://…&file=…&token=… or ws(s)://host:port/?file=…&token=… (a session an app hosts, or a server's share link; a code here works too)} → the new session: {session, status: \"connecting\", …}; its file opens in a tab of its own (other files' sessions go on) and `collab.peers` tells when it's live (`sessions` lists it until then, and if it fails)",
+            false,
+            join
+        ),
+        spec!(
+            "collab.leave",
+            "Leave live session",
+            "{} (the open file's session; the synced file stays open as a local copy) → {ended}",
+            false,
+            leave
+        ),
+        spec!(
+            "collab.publish",
+            "Publish to server",
+            "{server: ws://host:port/?key=… or wss://host/path/?key=… (the server's address with its key; `figcraft-server key` prints it; without a key on a server open to the public), key? (when the address has none), name? (default: the file's name)} → status \"connecting\": the open file is uploaded as a new file and this tab syncs through the server; `collab.peers` then has `published: {server, file, name, edit, view, owner (published without a key: the owner token, shown once), expires (seconds since 1970, or null)}` and `hosting` (the server's operator, terms and idle expiry)",
+            false,
+            publish
+        ),
+        spec!(
+            "collab.serverInfo",
+            "Server info",
+            "{server: ws://host:port/ or wss://host/path/} → {open (anyone may publish without the key), operator, terms (a web address), idleDays (files published without the key are deleted after this many days unopened; null: kept), maxFileMb, expires}",
+            false,
+            server_info
+        ),
+        spec!(
+            "collab.manageFile",
+            "Manage published file",
+            "{file (its id), server?, owner? (the server's address and the owner token you got when you published the file without the key; each defaults to what is recorded for one of your online files, see `collab.files`), action: links | createLink {access?: view (default) | edit, label?} | revoke {link (a link's id)} | share (others get new links and join codes) | unshare (the links and codes others got are revoked; the file stays yours on the server) | rename {name} | remove (the file is deleted from the server and leaves your online files)} → {links: [{id, access, label, created}]} | {id, access, link (a new share link, shown once)} | {shared, code, viewCode, editLink, viewLink} | {done}",
+            false,
+            manage_file
+        ),
+        spec!(
+            "collab.report",
+            "Report file to server operator",
+            "{reason (a few words, at most 500 characters)} → {sent}: the file you joined on a server is reported to its operator; the session's message says when the server kept it (servers older than this app don't take reports)",
+            false,
+            report
+        ),
+        spec!(
+            "collab.peers",
+            "People in this file",
+            "{} → the open file's session (each open file has its own or none): {available, canHost (false in the browser: it can only join), session (its id; null: this file isn't in a session), status: off|connecting|live|reconnecting|failed, reason?, role, me, name, color, fileName, pages, link, url, address, network, access: edit|view (view: a server's view link; edits are refused), readOnly (the open file can't be edited now: view only, or being published), published (a file you published: {server, file, name, edit, view}), code (the join code to give others, when the file was shared with `collab.share`; null otherwise or while it is on its way), share ({via: online|local, access, shared (false: a file of yours on a server that nobody else gets into now), editCode, viewCode, editLink, viewLink (what others join with; null when not shared)} or null), follow, syncing, document (index of the synced open document), editing (the text layer you type in: {node, layer, caret, selection}), peers: [{id, name, color, editing (theirs, same shape, or null), presence: {cursor: [page, x, y], selection, viewport: [page, x, y, w, h], editing_text}}], sessions: [{session, document (index of its open document; null for a join on its way), status, reason, role, fileName, link, peers (how many others)}] (every session of the app)}",
+            false,
+            |s, _| Ok(s.live_summary())
+        ),
+        spec!("collab.follow", "Follow", "{client? (a peer's id; omit to stop following)} → {follow}", false, follow),
+        spec!(
+            "collab.removePerson",
+            "Remove from session",
+            "{client (a peer's id)} → {removed, name}: they are disconnected (they keep their copy) and can't join again from their address while the session runs; only the person hosting, or the owner of a file on a server, can do it",
+            false,
+            remove_person
+        ),
+        spec!(
+            "collab.cursor",
+            "Show cursor at",
+            "{x?, y? (page coordinates on the current page; omit both to hide)} → {cursor} (agents; in the app the pointer drives it): your pointer in the open file's session (null when the file isn't in one)",
+            false,
+            cursor
+        ),
+        spec!(
+            "collab.cursorChat",
+            "Cursor chat",
+            "{text? (shown next to your cursor for everyone, at most 100 characters; empty closes it; omit to open the chat box in the app)} → {chat} (or {open}); others see it fade after 5 s without changes",
+            false,
+            cursor_chat
+        ),
+        spec!(
+            "collab.spotlight",
+            "Spotlight me",
+            "{on? (default: toggle)} → {spotlighting}: everyone in the session follows your view and page until they move theirs",
+            false,
+            spotlight
+        ),
+    ]
+}
diff --git a/crates/engine/src/sharing/live/sync.rs b/crates/engine/src/sharing/live/sync.rs
new file mode 100644
index 00000000..f2fd3c54
--- /dev/null
+++ b/crates/engine/src/sharing/live/sync.rs
@@ -0,0 +1,347 @@
+use super::host::hosting_json;
+use super::types::{NO_SESSION, SessionId, Share, SharedLink, Status};
+use super::*;
+
+impl Session {
+    /// Your client id in document `uid`'s live session (`None`: it isn't in one). Refused for
+    /// `cmd` while the session is on its way: there is no id yet.
+    pub(crate) fn live_client_id(&self, cmd: &str, uid: u64) -> Result<Option<u32>> {
+        let Some(live) = self.live.doc(uid) else { return Ok(None) };
+        match &live.client {
+            Some(c) => Ok(Some(c.id())),
+            None if live.status.active() => Err(EngineError::Disabled(cmd.into(), "wait until the file's live session has started".into())),
+            None => Ok(None),
+        }
+    }
+
+    /// Branch `id` of document `uid` got its base from the session document just now.
+    pub(crate) fn live_branch_base(&mut self, uid: u64, id: &str) {
+        if let Some(live) = self.live.doc_mut(uid).filter(|l| l.syncing()) {
+            live.branch_bases.insert(id.to_string());
+        }
+    }
+
+    /// Whether branch `id` of document `uid` got its base in the live session it is in now.
+    pub(crate) fn live_branch_in_session(&self, uid: u64, id: &str) -> bool {
+        self.live.doc(uid).is_some_and(|l| l.syncing() && l.branch_bases.contains(id))
+    }
+
+    /// Whether document `uid` is a live session's synced document: its edits sync and its undo
+    /// history is the user's own.
+    pub fn live_doc(&self, uid: u64) -> bool {
+        self.live.doc(uid).is_some_and(Live::syncing)
+    }
+
+    /// Sync the edits of session document `uid` as one batch: one step of the user's undo history
+    /// called `label`, or not undoable (`None`: also what changed it outside a command). Nothing
+    /// while a gesture or preview shows, or inside a group (it syncs when the group ends).
+    pub(crate) fn live_edit(&mut self, uid: u64, label: Option<&str>) {
+        let Some(ds) = self.docs.iter().find(|d| d.uid == uid) else { return };
+        let Some(live) = self.live.doc(uid) else { return };
+        if live.hold > 0 || busy(ds) || live.synced.as_ref().is_some_and(|s| Arc::ptr_eq(s, &ds.doc)) {
+            return;
+        }
+        let (id, doc, synced) = (live.id, ds.doc.clone(), live.synced.clone());
+        if self.live_read_only(uid).is_some() {
+            // Nothing goes out: what changed outside a command is put back.
+            if let Some(s) = synced {
+                self.apply_remote(uid, s);
+            }
+            return;
+        }
+        let Some(live) = self.live.sessions.get_mut(&id) else { return };
+        let Some(client) = live.client.as_mut() else { return };
+        match client.edit_with(&doc, label) {
+            Ok(msg) => {
+                live.synced = Some(doc);
+                self.live.send(id, msg);
+            }
+            Err(e) => self.live_fail(id, format!("Couldn't sync an edit: {e}")),
+        }
+    }
+
+    /// A group of commands on document `uid` starts (`on`) or ends: in between its edits don't
+    /// sync on their own.
+    pub(crate) fn live_hold(&mut self, uid: u64, on: bool) {
+        if let Some(live) = self.live.doc_mut(uid).filter(|l| l.syncing()) {
+            live.hold = if on { live.hold.saturating_add(1) } else { live.hold.saturating_sub(1) };
+        }
+    }
+
+    /// Undo (`back`) or redo the user's own last step on the active document, in its session:
+    /// what it wrote goes back where nobody else wrote since. Returns whether there was a step to
+    /// take back.
+    pub(crate) fn live_travel(&mut self, back: bool) -> bool {
+        let Some(uid) = self.tab() else { return false };
+        // Edits not synced yet go first.
+        self.live_edit(uid, None);
+        let Some(live) = self.live.doc_mut(uid) else { return false };
+        let Some(client) = live.client.as_mut() else { return false };
+        let (undo, redo) = client.history_len();
+        let msgs = match if back { client.undo(&EngineRecompute) } else { client.redo(&EngineRecompute) } {
+            Ok(m) => m,
+            Err(e) => {
+                log::warn!("live session: {} failed: {e}", if back { "undo" } else { "redo" });
+                return false;
+            }
+        };
+        let (u, r) = client.history_len();
+        let did = if back { r > redo } else { u > undo };
+        let doc = Arc::new(client.document().clone());
+        if did {
+            live.synced = Some(doc.clone());
+        }
+        let id = live.id;
+        self.live.send(id, msgs);
+        if did {
+            self.apply_remote(uid, doc);
+        }
+        did
+    }
+
+    /// Apply the server's batches that waited in session `id` (none while a gesture or preview
+    /// shows on its document).
+    pub(super) fn live_deferred(&mut self, id: SessionId) {
+        let Some(live) = self.live.sessions.get(&id).filter(|l| !l.deferred.is_empty() && l.syncing()) else { return };
+        let Some(uid) = live.doc_uid else { return };
+        if self.docs.iter().find(|d| d.uid == uid).is_none_or(busy) {
+            return;
+        }
+        // Your own edits first: the client replays them over what others did.
+        self.live_edit(uid, None);
+        let Some(live) = self.live.sessions.get_mut(&id) else { return };
+        let Some(client) = live.client.as_mut() else { return };
+        let mut out = Vec::new();
+        for m in std::mem::take(&mut live.deferred) {
+            match client.receive(m, &EngineRecompute) {
+                Ok(more) => out.extend(more),
+                Err(e) => return self.live_fail(id, format!("The live session got out of step ({e}); join again")),
+            }
+        }
+        let doc = Arc::new(client.document().clone());
+        // Edits the server refused were rolled back: say why (the UI's toast).
+        let notices: Vec<String> = client.take_notices().iter().map(figcraft_collab::Notice::message).collect();
+        live.synced = Some(doc.clone());
+        if !notices.is_empty() {
+            self.message = Some(notices.join("; "));
+        }
+        self.live.send(id, out);
+        self.apply_remote(uid, doc);
+    }
+
+    /// Show the peer followed in session `id`: their viewport (and their page, in the session's
+    /// document) on the session's tab.
+    pub(super) fn live_follow_apply(&mut self, id: SessionId) {
+        let Some(live) = self.live.sessions.get_mut(&id) else { return };
+        let Some(peer) = live.follow else { return };
+        if !live.peers.contains_key(&peer) {
+            live.unfollow();
+            return;
+        }
+        let Some((page, x, y, w, h)) = live.presence.get(&peer).and_then(|p| p.viewport) else { return };
+        let Some(ds) = self.docs.iter_mut().find(|d| Some(d.uid) == live.tab) else { return };
+        if live.syncing() && page != ds.page && ds.doc.pages.contains(&page) {
+            ds.page = page;
+            ds.selection.clear();
+            ds.text_edit = None;
+        }
+        if !(w > 0.0 && h > 0.0 && x.is_finite() && y.is_finite()) {
+            return;
+        }
+        ds.view.cx = x + w / 2.0;
+        ds.view.cy = y + h / 2.0;
+        let zoom = (ds.view.vw / w).min(ds.view.vh / h);
+        if zoom.is_finite() {
+            ds.view.zoom = zoom.clamp(ViewState::MIN_ZOOM, ViewState::MAX_ZOOM);
+        }
+        ds.revision += 1;
+        live.followed = Some(FollowedView { page: ds.page, cx: ds.view.cx, cy: ds.view.cy, zoom: ds.view.zoom });
+    }
+
+    /// Sessions whose tab was closed end (hosts stop hosting, guests leave); the others go on. A
+    /// join still on its way from a closed tab shows on the one in front.
+    pub(super) fn live_closed(&mut self) {
+        let (docs, tab) = (&self.docs, self.tab());
+        let mut gone = Vec::new();
+        for l in self.live.sessions.values_mut().filter(|l| l.tab != tab && !docs.iter().any(|d| Some(d.uid) == l.tab)) {
+            if l.doc_uid.is_none() && l.status.active() {
+                l.tab = tab;
+            } else {
+                gone.push((l.id, l.status == Status::Live));
+            }
+        }
+        for (id, was_live) in gone {
+            self.live.end(id);
+            if was_live {
+                self.message = Some("The live session's file was closed, so you left the session".into());
+            }
+        }
+    }
+
+    /// Send your edits and presence in every session when they changed (headless sessions call
+    /// it after each command). A view you moved yourself stops following.
+    pub fn live_sync(&mut self) {
+        self.live_sync_in(|_| true);
+    }
+
+    /// [`live_sync`](Self::live_sync) for the sessions whose document (`None`: a join on its way)
+    /// `mine` picks: a window calls it every frame it draws, after input, for the documents it
+    /// holds.
+    pub fn live_sync_in(&mut self, mine: impl Fn(Option<u64>) -> bool) {
+        // A recovery copy whose session was left has its outcome too.
+        if !self.live.recovering.is_empty() {
+            self.online_recoveries();
+        }
+        if self.live.sessions.is_empty() {
+            return;
+        }
+        self.live_closed();
+        let ids: Vec<SessionId> = self.live.sessions.values().filter(|l| l.status == Status::Live && mine(l.doc_uid)).map(|l| l.id).collect();
+        for id in ids {
+            self.live_deferred(id);
+            if let Some(uid) = self.live.get(id).and_then(|l| l.doc_uid) {
+                self.live_edit(uid, None);
+            }
+            self.live_present(id);
+        }
+    }
+
+    /// Hand your presence in session `id` to the link when it changed.
+    fn live_present(&mut self, id: SessionId) {
+        let Some(live) = self.live.get(id).filter(|l| l.status == Status::Live) else { return };
+        let moved = live.followed.is_some_and(|f| {
+            self.docs
+                .iter()
+                .find(|d| Some(d.uid) == live.tab)
+                .is_some_and(|ds| ds.page != f.page || !close(ds.view.cx, f.cx) || !close(ds.view.cy, f.cy) || !close(ds.view.zoom, f.zoom))
+        });
+        let p = self.presence_in(live);
+        let changed = live.sent.as_ref() != Some(&p);
+        let Some(live) = self.live.sessions.get_mut(&id) else { return };
+        if moved {
+            live.unfollow();
+        }
+        if changed {
+            if let Some(link) = self.live.link.as_mut() {
+                link.presence(id, &p);
+            }
+            live.sent = Some(p);
+        }
+    }
+
+    /// Stop following in the active document's session (Escape, `collab.follow {}`). False when
+    /// you weren't following anyone.
+    pub fn live_unfollow(&mut self) -> bool {
+        self.live_mut().is_some_and(Live::unfollow)
+    }
+
+    /// Follow `peer`'s viewport in the active document's session (shown at once when known).
+    pub fn live_follow(&mut self, peer: u32) -> Result<()> {
+        let Some(live) = self.live_mut().filter(|l| l.peers.contains_key(&peer)) else {
+            return Err(bad("collab.follow", format!("nobody with client id {peer} is in the session")));
+        };
+        live.follow = Some(peer);
+        live.followed = None;
+        let id = live.id;
+        self.live_follow_apply(id);
+        Ok(())
+    }
+
+    /// The active document's session as JSON (`collab.peers`), with every session in brief.
+    pub fn live_summary(&self) -> Value {
+        self.summary(self.live())
+    }
+
+    /// The index of the open document session `l` syncs.
+    fn live_index(&self, l: &Live) -> Option<usize> {
+        l.doc_uid.and_then(|u| self.docs.iter().position(|d| d.uid == u))
+    }
+
+    pub(super) fn summary(&self, l: &Live) -> Value {
+        let info = l.info.as_ref();
+        let reason = |l: &Live| match &l.status {
+            Status::Failed { reason } => Some(reason.clone()),
+            _ => None,
+        };
+        let synced = self.live_index(l).and_then(|i| self.docs.get(i));
+        // Who types in which layer of the session document.
+        let editing = |e: &EditingText| {
+            let layer = synced.and_then(|d| d.doc.node(e.node)).map(|n| n.name.as_str());
+            json!({"node": e.node, "layer": layer, "caret": e.caret, "selection": e.selection})
+        };
+        let peers: Vec<Value> = l
+            .peers
+            .values()
+            .map(|p| {
+                let presence = l.presence.get(&p.client_id);
+                let typing = presence.and_then(|pr| pr.editing_text.as_deref()).map(editing);
+                let chat = l.chats.get(&p.client_id);
+                json!({"id": p.client_id, "name": p.name, "color": p.color, "editing": typing, "chat": chat, "presence": presence})
+            })
+            .collect();
+        let mine = synced.and_then(|d| d.text_edit.as_ref()).map(|t| editing(&editing_of(t)));
+        let sessions: Vec<Value> = self
+            .live
+            .iter()
+            .map(|o| {
+                let info = o.info.as_ref();
+                json!({
+                    "session": o.id,
+                    "document": self.live_index(o),
+                    "status": o.status.id(),
+                    "reason": reason(o),
+                    "role": o.role(),
+                    "fileName": info.map(|i| i.file_name.as_str()),
+                    "link": info.map(|i| i.link.as_str()),
+                    "peers": o.peers.len(),
+                })
+            })
+            .collect();
+        json!({
+            "available": self.live.available(),
+            "canHost": self.live.can_host(),
+            "session": (l.id != NO_SESSION).then_some(l.id),
+            "status": l.status.id(),
+            "reason": reason(l),
+            "attempt": match l.status { Status::Reconnecting { attempt } => Some(attempt), _ => None },
+            "role": info.map(|i| i.role),
+            "me": info.map(|i| i.me),
+            "name": info.map(|i| i.name.as_str()),
+            "color": info.map(|i| i.color.as_str()),
+            "fileName": info.map(|i| i.file_name.as_str()),
+            "pages": info.map(|i| &i.pages),
+            "link": info.map(|i| i.link.as_str()),
+            "url": info.map(|i| i.url.as_str()),
+            "address": info.map(|i| i.address.as_str()),
+            "network": info.map(|i| i.network),
+            "access": l.client.as_ref().map(Client::access).or(info.map(|i| i.access)),
+            "readOnly": l.doc_uid.is_some_and(|u| self.live_read_only(u).is_some()),
+            "published": l.published,
+            "code": l.share.as_ref().and_then(Share::code),
+            "share": l.share.as_ref().map(|sh| {
+                let (edit, view) = (sh.links.as_ref().map(|s| &s.edit), sh.links.as_ref().and_then(|s| s.view.as_ref()));
+                let code = |l: Option<&SharedLink>| l.and_then(|l| l.code.as_deref()).map(code::grouped);
+                json!({
+                    "via": sh.via,
+                    "access": sh.access.id(),
+                    "shared": sh.links.is_some(),
+                    "editCode": code(edit),
+                    "viewCode": code(view),
+                    "editLink": edit.map(|l| l.link.as_str()),
+                    "viewLink": view.map(|l| l.link.as_str()),
+                })
+            }),
+            "hosting": l.hosting.as_ref().map(hosting_json),
+            "follow": l.follow,
+            "signals": l.signals,
+            "chat": l.chat,
+            "spotlight": l.spotlight,
+            "spotlighting": l.spotlighting,
+            "syncing": l.syncing(),
+            "document": self.live_index(l),
+            "editing": mine,
+            "peers": peers,
+            "sessions": sessions,
+        })
+    }
+}
diff --git a/crates/engine/src/sharing/live/types.rs b/crates/engine/src/sharing/live/types.rs
new file mode 100644
index 00000000..16a237d5
--- /dev/null
+++ b/crates/engine/src/sharing/live/types.rs
@@ -0,0 +1,482 @@
+use super::*;
+
+/// The server files are shared through online unless Preferences name another: the only place
+/// its address is written.
+///
+/// A build can ship another one, or none: set `FIGCRAFT_DEFAULT_SERVER` when compiling to a
+/// server's address (`wss://host/`), or to nothing (`FIGCRAFT_DEFAULT_SERVER=`) for a build whose
+/// online sharing stays off until the user enters a server in Preferences.
+pub const DEFAULT_SERVER: &str = match option_env!("FIGCRAFT_DEFAULT_SERVER") {
+    Some(server) => server,
+    None => "wss://collab.craftapps.dev/",
+};
+
+/// Most selected ids one presence update carries (the rest aren't shown to others).
+pub const MAX_SELECTION: usize = 10_000;
+
+/// Longest name shown to others (characters).
+pub const MAX_NAME: usize = 64;
+
+/// The colours people get in a session, in the order the host hands them out (`#RRGGBB`, white
+/// text reads on each).
+pub const PEOPLE: [&str; 8] = ["#0D99FF", "#9747FF", "#14AE5C", "#F24822", "#D9730D", "#E83E8C", "#00A3A3", "#665CE0"];
+
+/// `#RRGGBB` → (r, g, b); `None` for anything else.
+pub fn parse_color(s: &str) -> Option<(u8, u8, u8)> {
+    let hex = s.strip_prefix('#').filter(|h| h.len() == 6 && h.bytes().all(|b| b.is_ascii_hexdigit()))?;
+    let byte = |i: usize| hex.get(i..i + 2).and_then(|b| u8::from_str_radix(b, 16).ok());
+    Some((byte(0)?, byte(2)?, byte(4)?))
+}
+
+/// Why a join failed when a message from the host is over this app's size limit (`{mb}`: the
+/// limit in MB). The UI translates it.
+pub const TOO_LARGE_TO_JOIN: &str = "This file is too large to join here (up to {mb} MB)";
+
+/// The connection to a live session.
+#[derive(Clone, Debug, Default, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase", tag = "state")]
+pub enum Status {
+    /// Not in a session.
+    #[default]
+    Off,
+    /// Joining (connecting to the host, waiting for its welcome).
+    Connecting,
+    /// In the session.
+    Live,
+    /// The connection dropped; trying again (`attempt` from 1).
+    Reconnecting { attempt: u32 },
+    /// Couldn't join, or the connection was lost for good.
+    Failed { reason: String },
+}
+
+impl Status {
+    pub fn id(&self) -> &'static str {
+        match self {
+            Status::Off => "off",
+            Status::Connecting => "connecting",
+            Status::Live => "live",
+            Status::Reconnecting { .. } => "reconnecting",
+            Status::Failed { .. } => "failed",
+        }
+    }
+
+    /// In a session or on the way into one.
+    pub fn active(&self) -> bool {
+        matches!(self, Status::Connecting | Status::Live | Status::Reconnecting { .. })
+    }
+
+    /// What the Share popover says about it.
+    pub fn label(&self) -> String {
+        match self {
+            Status::Off => "Not in a live session".into(),
+            Status::Connecting => "Joining…".into(),
+            Status::Live => "Live".into(),
+            Status::Reconnecting { attempt } => format!("Connection lost, reconnecting (attempt {attempt})…"),
+            Status::Failed { reason } => reason.clone(),
+        }
+    }
+}
+
+/// Your part in the session.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Role {
+    Host,
+    Guest,
+}
+
+/// A page of the shared file.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct PageInfo {
+    pub id: u64,
+    pub name: String,
+}
+
+/// The session you're in.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SessionInfo {
+    pub role: Role,
+    /// Your client id, name and colour as the others see them.
+    pub me: u32,
+    pub name: String,
+    pub color: String,
+    /// The shared file's name and pages (the host's).
+    pub file_name: String,
+    pub pages: Vec<PageInfo>,
+    /// The invite link (`figcraft://join?host=…&file=…&token=…`) and the same as a plain
+    /// WebSocket URL. Both carry the session's secret token: share them only with people you
+    /// invite.
+    pub link: String,
+    pub url: String,
+    /// `ip:port` the session listens on (host) or connects to (guest); a server's URL when it
+    /// isn't plain `ws://` at `/`.
+    pub address: String,
+    /// Reachable from other machines (the host listens on a network address, not loopback).
+    pub network: bool,
+    /// What you may do: edit, or only view (a server's view link).
+    pub access: Access,
+}
+
+/// A file you published to a server: where, and its first share links (they carry their tokens:
+/// share them like passwords; the server keeps only hashes).
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Published {
+    /// The server's address.
+    pub server: String,
+    /// The file's id and name on the server.
+    pub file: String,
+    pub name: String,
+    /// The link that lets people edit, and the one that lets them only view.
+    pub edit: String,
+    pub view: String,
+    /// Published without the server's key: the owner token that revokes links, renames or removes
+    /// the file (shown this once; the server keeps only its hash).
+    pub owner: Option<String>,
+    /// When the server deletes the file if nobody opens it (seconds since 1970).
+    pub expires: Option<u64>,
+}
+
+/// How a file is shared with a join code.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Via {
+    /// Through a server: the file is kept there and the server hands out the codes.
+    Online,
+    /// From this app, to people on the same network.
+    Local,
+}
+
+/// One way into a shared file: an invite link, and the join code that stands for it.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, serde::Deserialize)]
+#[serde(default)]
+pub struct SharedLink {
+    /// The link's id on its server (what revokes it; empty for a session this app hosts).
+    pub id: String,
+    /// The invite link (it carries its secret).
+    pub link: String,
+    /// Its join code's symbols. `None`: there is none (a server from before join codes, a host
+    /// without an IPv4 address): the link is shared instead.
+    pub code: Option<String>,
+}
+
+/// What others join a shared file with: to edit it and, on a server, to only view it.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, serde::Deserialize)]
+#[serde(default)]
+pub struct Shared {
+    pub edit: SharedLink,
+    pub view: Option<SharedLink>,
+}
+
+/// A file shared with a join code (`collab.share`). Online, the file is its owner's on the
+/// server: sharing gives others links (and codes) of their own, and stopping takes those away
+/// while the owner stays in the file.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Share {
+    pub via: Via,
+    /// Online: the server's address as it was given (it may carry the server's key: never shown).
+    pub server: String,
+    /// What the code shown lets people do.
+    pub access: Access,
+    /// What others join with now. `None`: on its way, or (online) not shared at the moment: the
+    /// file is on the server, open only to its owner.
+    pub links: Option<Shared>,
+}
+
+impl Share {
+    /// The way in to show: the one for [`access`](Self::access).
+    fn shown(&self) -> Option<&SharedLink> {
+        let links = self.links.as_ref()?;
+        if self.access == Access::View { links.view.as_ref() } else { Some(&links.edit) }
+    }
+
+    /// The code to show, grouped (`K7M-2QX-9TD`).
+    pub fn code(&self) -> Option<String> {
+        self.shown()?.code.as_deref().map(code::grouped)
+    }
+
+    /// The invite link to give with (or in place of) the code.
+    pub fn link(&self) -> Option<&str> {
+        self.shown().map(|l| l.link.as_str())
+    }
+}
+
+/// What someone typed to join, as what the link joins: an invite link as it is, a local network
+/// code as the link it stands for, an online code with `server` to ask about it.
+pub fn join_target(server: &str, typed: &str) -> std::result::Result<String, String> {
+    let typed = typed.trim();
+    if typed.contains("://") || typed.contains('?') {
+        return Ok(typed.to_string());
+    }
+    match code::parse(typed)? {
+        Code::Local(local) => Ok(local.link()),
+        Code::Online(_) if server.trim().is_empty() => Err(format!("that is an online join code, and {ONLINE_OFF}")),
+        Code::Online(code) => Ok(format!("figcraft://join?server={}&code={code}", server.trim())),
+    }
+}
+
+/// Why nothing can be shared or joined online.
+pub const ONLINE_OFF: &str = "online sharing is off: choose a server in Preferences (or share on the local network)";
+
+/// A session's number on the link: the engine picks it (from 1) when it starts the session.
+pub type SessionId = u64;
+
+/// The [`SessionId`] of events that aren't about a session (answers to background requests).
+pub const NO_SESSION: SessionId = 0;
+
+/// What happened in a session since the last [`LiveLink::poll`].
+#[derive(Clone, Debug, PartialEq)]
+pub enum Event {
+    Status(Status),
+    /// Joined, or joined again after a reconnect: who you are and who else is here.
+    Welcome {
+        info: SessionInfo,
+        peers: Vec<Peer>,
+    },
+    PeerJoined(Peer),
+    PeerLeft(u32),
+    Presence(u32, Presence),
+    /// Someone's cursor chat or spotlight, or (about you) the host's [`Signal::READY`].
+    Signal(u32, Signal),
+    /// For the document sync client: the welcome (with the whole document), or a batch of
+    /// changes the server ordered, or the rejection of one of yours.
+    Sync(ServerMsg),
+    /// The host ended the session.
+    Ended {
+        reason: String,
+    },
+    /// The document is on the server (`collab.publish`); joining it follows.
+    Published(Published),
+    /// The published file is shared (`collab.share`): the links and codes others join with, or
+    /// why the server made none.
+    Shared(std::result::Result<Shared, String>),
+    /// What the server says about its hosting (operator, terms, this file's expiry).
+    Hosting(HostInfo),
+    /// The server's answer to `collab.report`: kept, or why not.
+    Reported(Option<String>),
+    /// The answer to a team library request sent in the background
+    /// ([`LiveLink::library_background`]) about the file behind share link `link`.
+    Library {
+        link: String,
+        reply: std::result::Result<LibraryReply, String>,
+    },
+    /// The answer to request `job` sent in the background ([`LiveLink::background`]).
+    Net {
+        job: u64,
+        reply: Box<NetReply>,
+    },
+}
+
+/// A request to a server outside a live session: its plugin directory, a team library, or keeping
+/// a file there.
+#[derive(Clone, Debug)]
+pub enum NetRequest {
+    /// To the plugin directory of the server at `server` (`ws://host:port/`, with `?key=…` to
+    /// publish).
+    Plugins { server: String, req: PluginReq },
+    /// About the team library of the file behind share link `link`.
+    Library { link: String, req: LibraryReq },
+    /// Keep a file on a server without joining it ([`LiveLink::upload`]).
+    Upload(PublishOptions),
+    /// Change who else gets into `file` on the server at `server` (its address, with `?key=…`, or
+    /// the file's `owner` token): revoke the links with these ids, then, to `create`, make a new
+    /// edit link and view link with their join codes ([`LiveLink::share`]).
+    Share { server: String, file: String, owner: String, revoke: Vec<String>, create: bool },
+    /// Ask the server at `server` about its hosting and, with a file's owner token, manage that
+    /// file ([`LiveLink::hosting`]).
+    Hosting { server: String, file: String, owner: String, req: Option<Admin> },
+}
+
+impl NetRequest {
+    /// What a session without the network says.
+    pub(crate) fn unavailable(&self) -> &'static str {
+        match self {
+            NetRequest::Plugins { .. } => crate::plugin_directory::NO_DIRECTORY,
+            NetRequest::Library { .. } | NetRequest::Upload(_) => NO_TEAM_LIBRARIES,
+            NetRequest::Hosting { .. } | NetRequest::Share { .. } => NO_HOSTING,
+        }
+    }
+
+    /// How to answer that this request failed (and why).
+    pub fn failure(&self) -> fn(String) -> NetReply {
+        match self {
+            NetRequest::Plugins { .. } => |why| NetReply::Plugins(Err(why)),
+            NetRequest::Library { .. } => |why| NetReply::Library(Err(why)),
+            NetRequest::Upload(_) => |why| NetReply::Upload(Err(why)),
+            NetRequest::Hosting { .. } => |why| NetReply::Hosting(Err(why)),
+            NetRequest::Share { .. } => |why| NetReply::Share(Err(why)),
+        }
+    }
+
+    /// The answer to this request stands for `other` when a command runs again: the same kind of
+    /// request to the same place (what it carries may differ: a usage report, a fresh timestamp).
+    pub(crate) fn stands_for(&self, other: &NetRequest) -> bool {
+        use std::mem::discriminant;
+        match (self, other) {
+            (NetRequest::Plugins { server: a, req: x }, NetRequest::Plugins { server: b, req: y }) => a == b && discriminant(x) == discriminant(y),
+            (NetRequest::Library { link: a, req: x }, NetRequest::Library { link: b, req: y }) => a == b && discriminant(x) == discriminant(y),
+            (NetRequest::Upload(a), NetRequest::Upload(b)) => a.server == b.server,
+            (NetRequest::Hosting { server: a, file: f, req: x, .. }, NetRequest::Hosting { server: b, file: g, req: y, .. }) => {
+                a == b && f == g && x.as_ref().map(discriminant) == y.as_ref().map(discriminant)
+            }
+            (NetRequest::Share { server: a, file: f, create: x, .. }, NetRequest::Share { server: b, file: g, create: y, .. }) => {
+                a == b && f == g && x == y
+            }
+            _ => false,
+        }
+    }
+}
+
+/// The answer to a [`NetRequest`] (an error: the server couldn't be reached or refused).
+#[derive(Clone, Debug, PartialEq)]
+pub enum NetReply {
+    Plugins(std::result::Result<PluginReply, String>),
+    Library(std::result::Result<LibraryReply, String>),
+    /// The new links, when some were asked for.
+    Share(std::result::Result<Option<Shared>, String>),
+    Upload(std::result::Result<Published, String>),
+    /// What the server says about its hosting, and its answer to the request, if one was sent.
+    Hosting(std::result::Result<(HostInfo, Option<AdminReply>), String>),
+}
+
+/// What a session without the network says about servers' hosting.
+pub const NO_HOSTING: &str = "publishing to a server needs the desktop app or the MCP server";
+
+/// Which network interface a hosted session listens on.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Bind {
+    /// This machine only (127.0.0.1): the default.
+    Local,
+    /// The machine's address on the local network (only when the user chooses to share there).
+    Lan,
+    /// A given interface address (e.g. a VPN's).
+    Addr(IpAddr),
+}
+
+/// What [`LiveLink::host`] needs to start a session for the open file.
+#[derive(Clone, Debug)]
+pub struct HostOptions {
+    /// `None`: the default port, or any free one when it's taken.
+    pub port: Option<u16>,
+    pub bind: Bind,
+    /// Your name (empty: the host picks one).
+    pub name: String,
+    /// The shared file (the session's authoritative copy starts from it).
+    pub doc: Arc<Document>,
+    /// Shared with a join code (`collab.share`): the session's secret is short enough to type.
+    pub short: bool,
+}
+
+/// What [`LiveLink::publish`] needs to put the open file on a server.
+#[derive(Clone, Debug)]
+pub struct PublishOptions {
+    /// The server's address (`ws://host:port/`, `wss://host/path/`), which may carry its key
+    /// (`?key=…`).
+    pub server: String,
+    /// The server's key, when the address doesn't carry it. Without one the file is published
+    /// as anyone may, on a server open to the public (with an owner token).
+    pub key: Option<String>,
+    /// The file's name on the server.
+    pub name: String,
+    /// Your name in the session (empty: the server picks one).
+    pub me: String,
+    pub doc: Arc<Document>,
+    /// Share the file once it is there: links and join codes for others ([`Event::Shared`];
+    /// `collab.share`).
+    pub share: bool,
+}
+
+/// The networking behind live sessions, installed by the app ([`Lives::install`]). It carries
+/// any number of sessions at once, each under the [`SessionId`] it was started with. Calls return
+/// at once; what happens later arrives through [`poll`](Self::poll).
+pub trait LiveLink: Send {
+    /// Sessions can be hosted here (the browser build can only join).
+    fn can_host(&self) -> bool {
+        true
+    }
+    /// Start hosting session `session` for `opts.doc`.
+    fn host(&mut self, session: SessionId, opts: HostOptions) -> std::result::Result<SessionInfo, String>;
+    /// Start joining the session behind an invite link, as session `session`. Errors are for
+    /// links that can't be used; they never echo the link (it holds the token).
+    fn join(&mut self, session: SessionId, link: &str, name: &str) -> std::result::Result<(), String>;
+    /// [`join`](Self::join) as the client `resume` names, when the server still knows it (an app
+    /// that starts over after a crash keeps its id, so what it made before is its own to send).
+    /// A link that can't resume joins as someone new.
+    fn join_resuming(&mut self, session: SessionId, link: &str, name: &str, _resume: Option<Resume>) -> std::result::Result<(), String> {
+        self.join(session, link, name)
+    }
+    /// Start uploading `opts.doc` to a server as a new file, then join it with its edit link, as
+    /// session `session`: [`Event::Published`] with its links, then the welcome. Errors are for
+    /// addresses that can't be used; they never echo the key.
+    fn publish(&mut self, _session: SessionId, _opts: PublishOptions) -> std::result::Result<(), String> {
+        Err("publishing to a server needs the desktop app or the MCP server".into())
+    }
+    /// Keep `opts.doc` on a server as a new file without joining it: where, and its links
+    /// (`library.publishToServer` with the server's key). Waits for the server. Errors never echo
+    /// the key.
+    fn upload(&mut self, _opts: PublishOptions) -> std::result::Result<Published, String> {
+        Err(NO_TEAM_LIBRARIES.into())
+    }
+    /// One request about the team library of the file behind share link `link`; waits for the
+    /// server's answer (a few seconds at most when it can't be reached). Errors never echo the
+    /// link.
+    fn library(&mut self, _link: &str, _req: LibraryReq) -> std::result::Result<LibraryReply, String> {
+        Err(NO_TEAM_LIBRARIES.into())
+    }
+    /// Send library requests `(link, request)` in the background, in order; each answer arrives as
+    /// [`Event::Library`]. Ignored while an earlier call's requests are still out.
+    fn library_background(&mut self, _jobs: Vec<(String, LibraryReq)>) {}
+    /// One request to the plugin directory of the server at `server` (`ws://host:port/`, with
+    /// `?key=…` to publish); waits for the answer (a few seconds at most when it can't be
+    /// reached). Errors never echo the key.
+    fn plugins(&mut self, _server: &str, _req: PluginReq) -> std::result::Result<PluginReply, String> {
+        Err(crate::plugin_directory::NO_DIRECTORY.into())
+    }
+    /// What the server at `server` says about its hosting, and with a file's owner token
+    /// (`file` and `owner`) its answer to `req` about that file; waits for the server. Errors
+    /// never echo the token.
+    fn hosting(
+        &mut self,
+        _server: &str,
+        _file: &str,
+        _owner: &str,
+        _req: Option<Admin>,
+    ) -> std::result::Result<(HostInfo, Option<AdminReply>), String> {
+        Err(NO_HOSTING.into())
+    }
+    /// See [`NetRequest::Share`]; waits for the server. Errors never echo the key or the token.
+    fn share(&mut self, _server: &str, _file: &str, _owner: &str, _revoke: &[String], _create: bool) -> std::result::Result<Option<Shared>, String> {
+        Err(NO_HOSTING.into())
+    }
+    /// Send `req` and wait for the answer (through the methods above).
+    fn request(&mut self, req: NetRequest) -> NetReply {
+        match req {
+            NetRequest::Share { server, file, owner, revoke, create } => NetReply::Share(self.share(&server, &file, &owner, &revoke, create)),
+            NetRequest::Plugins { server, req } => NetReply::Plugins(self.plugins(&server, req)),
+            NetRequest::Library { link, req } => NetReply::Library(self.library(&link, req)),
+            NetRequest::Upload(o) => NetReply::Upload(self.upload(o)),
+            NetRequest::Hosting { server, file, owner, req } => NetReply::Hosting(self.hosting(&server, &file, &owner, req)),
+        }
+    }
+    /// Send `req` on a thread of its own and return at once: the answer arrives as [`Event::Net`]
+    /// with `job` (a failure to send too). False when this link can't, and nothing was sent.
+    fn background(&mut self, _job: u64, _req: NetRequest) -> bool {
+        false
+    }
+    /// Remove client `client` from session `session`, which this link hosts: they are
+    /// disconnected and can't join again from their address while it runs. Returns at once.
+    fn remove(&mut self, _session: SessionId, _client: u32) -> std::result::Result<(), String> {
+        Err("removing people needs the desktop app or the MCP server".into())
+    }
+    /// End session `session` (stop hosting or leave); the others go on. Nothing for a session
+    /// that is over already.
+    fn leave(&mut self, session: SessionId);
+    /// Your latest presence in `session` (the link throttles and coalesces).
+    fn presence(&mut self, session: SessionId, p: &Presence);
+    /// A message for `session`'s server (document changes), sent in order.
+    fn send(&mut self, session: SessionId, msg: ClientMsg);
+    /// Events since the last call, each with its session ([`NO_SESSION`] for answers to
+    /// background requests); never blocks.
+    fn poll(&mut self) -> Vec<(SessionId, Event)>;
+}

From ad4ba1ae9b800fa082561ba6c341c85c49064c83 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:20:45 +0000
Subject: [PATCH 27/67] refactor(engine): split dev/codegen.rs into codegen/

---
 crates/engine/src/dev/codegen.rs         | 1214 +---------------------
 crates/engine/src/dev/codegen/arkui.rs   |  228 ++++
 crates/engine/src/dev/codegen/compose.rs |  131 +++
 crates/engine/src/dev/codegen/css.rs     |  288 +++++
 crates/engine/src/dev/codegen/html.rs    |  390 +++++++
 crates/engine/src/dev/codegen/swift.rs   |  168 +++
 6 files changed, 1222 insertions(+), 1197 deletions(-)
 create mode 100644 crates/engine/src/dev/codegen/arkui.rs
 create mode 100644 crates/engine/src/dev/codegen/compose.rs
 create mode 100644 crates/engine/src/dev/codegen/css.rs
 create mode 100644 crates/engine/src/dev/codegen/html.rs
 create mode 100644 crates/engine/src/dev/codegen/swift.rs

diff --git a/crates/engine/src/dev/codegen.rs b/crates/engine/src/dev/codegen.rs
index 5064c64f..093a8fd9 100644
--- a/crates/engine/src/dev/codegen.rs
+++ b/crates/engine/src/dev/codegen.rs
@@ -14,6 +14,23 @@ use crate::component_codegen::{Component, Param};
 use crate::params::*;
 use crate::{bad, spec};
 
+mod arkui;
+mod compose;
+mod css;
+mod html;
+mod swift;
+
+pub(crate) use arkui::arkui;
+pub(crate) use compose::{compose, kotlin_color};
+pub(crate) use css::Tokens;
+#[cfg(test)]
+pub(crate) use css::css_decls;
+use css::{css, tok};
+pub use css::{css_var_name, css_var_of};
+use html::html;
+pub(crate) use html::{Markup, class_name};
+pub(crate) use swift::swift;
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![spec!(
         "inspect.code",
@@ -363,354 +380,6 @@ pub(crate) fn indent(depth: usize) -> String {
     "    ".repeat(depth)
 }
 
-// ------------------------------------------------------------------ CSS
-
-/// The CSS custom properties generated code uses: name → fallback value, in first-use order.
-#[derive(Default)]
-pub(crate) struct Tokens {
-    vars: Vec<(String, String)>,
-    /// Name variables as Tailwind theme variables (`--color-accent`), not by their CSS name.
-    pub tailwind: bool,
-    /// The file's theme names (computed on first use).
-    theme: Option<crate::tailwind::Theme>,
-}
-
-impl Tokens {
-    /// `var(--name, value)`, remembering the variable.
-    fn var(&mut self, doc: &Document, variable: &Variable, value: String) -> String {
-        let name =
-            if self.tailwind { self.theme.get_or_insert_with(|| crate::tailwind::Theme::new(doc)).name(variable) } else { css_var_of(variable) };
-        let out = format!("var({name}, {value})");
-        if !self.vars.iter().any(|(n, _)| *n == name) {
-            self.vars.push((name, value));
-        }
-        out
-    }
-
-    /// A `:root` rule declaring the variables (empty without any).
-    pub fn root_rule(&self) -> String {
-        if self.vars.is_empty() {
-            return String::new();
-        }
-        let decls: String = self.vars.iter().map(|(n, v)| format!("  {n}: {v};\n")).collect();
-        format!(":root {{\n{decls}}}\n")
-    }
-}
-
-/// A variable's CSS custom property name: "Colors/Brand 500" → `--colors-brand-500`.
-pub fn css_var_name(variable: &str) -> String {
-    let mut out = String::from("--");
-    for c in variable.chars().flat_map(char::to_lowercase).take(80) {
-        if c.is_alphanumeric() || c == '_' {
-            out.push(c);
-        } else if !out.ends_with('-') {
-            out.push('-');
-        }
-    }
-    let trimmed = out.trim_end_matches('-');
-    if trimmed.len() <= 2 { "--variable".into() } else { trimmed.to_string() }
-}
-
-/// A variable's CSS custom property: its Web code syntax (`var(--x)` or `--x`) when it has one,
-/// else made from its name.
-pub fn css_var_of(v: &Variable) -> String {
-    let Some(web) = v.code_syntax.get("WEB").map(|w| w.trim()) else { return css_var_name(&v.name) };
-    let inner = web.strip_prefix("var(").map_or(web, |r| r.split([',', ')']).next().unwrap_or("").trim());
-    let valid = inner.len() > 2 && inner.starts_with("--") && inner.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_');
-    if valid { inner.chars().take(80).collect() } else { css_var_name(inner) }
-}
-
-/// `value`, or a reference to the variable bound to the first of `fields` that has one.
-fn tok(doc: &Document, n: &Node, fields: &[&str], value: String, t: &mut Tokens) -> String {
-    match fields.iter().find_map(|f| crate::devinspect::bound_variable(doc, n, f)) {
-        Some(v) => t.var(doc, v, value),
-        None => value,
-    }
-}
-
-fn css(doc: &Document, id: NodeId) -> String {
-    let Some(n) = doc.node(id) else { return String::new() };
-    let mut t = Tokens::default();
-    let decls = css_decls(doc, n, &mut t, (false, false));
-    format!("/* {} */\n{decls}", n.name.replace("*/", "* /"))
-}
-
-/// The CSS declarations for `n`'s own look and size, one per line; `hug` leaves out the width
-/// and/or height (they follow the content). Bound variables become `var(--name, value)`.
-pub(crate) fn css_decls(doc: &Document, n: &Node, t: &mut Tokens, hug: (bool, bool)) -> String {
-    let px = |v: f64| format!("{}px", num(v));
-    let mut out = String::new();
-    let mut put = |key: &str, value: String| out.push_str(&format!("{key}: {value};\n"));
-    if !hug.0 {
-        put("width", tok(doc, n, &["width"], px(n.width), t));
-    }
-    if !hug.1 {
-        put("height", tok(doc, n, &["height"], px(n.height), t));
-    }
-    if let Some(l) = &n.layout {
-        put("display", "flex".into());
-        put("flex-direction", if l.mode == LayoutMode::Vertical { "column" } else { "row" }.into());
-        if l.wrap {
-            put("flex-wrap", "wrap".into());
-        }
-        put("gap", tok(doc, n, &["gap"], px(l.gap), t));
-        let [pt, pr, pb, pl] = l.padding;
-        let sides = [
-            tok(doc, n, &["paddingTop", "paddingVertical", "padding"], px(pt), t),
-            tok(doc, n, &["paddingRight", "paddingHorizontal", "padding"], px(pr), t),
-            tok(doc, n, &["paddingBottom", "paddingVertical", "padding"], px(pb), t),
-            tok(doc, n, &["paddingLeft", "paddingHorizontal", "padding"], px(pl), t),
-        ];
-        put("padding", sides.join(" "));
-        let justify = match l.main_align {
-            MainAlign::Min => "flex-start",
-            MainAlign::Center => "center",
-            MainAlign::Max => "flex-end",
-            MainAlign::SpaceBetween => "space-between",
-            MainAlign::SpaceAround => "space-around",
-            MainAlign::SpaceEvenly => "space-evenly",
-        };
-        put("justify-content", justify.into());
-        let align = match l.cross_align {
-            CrossAlign::Min => "flex-start",
-            CrossAlign::Center => "center",
-            CrossAlign::Max => "flex-end",
-            CrossAlign::Baseline => "baseline",
-        };
-        put("align-items", align.into());
-        if l.wrap {
-            // The lines: spread, or packed where the items align (baseline: at the start).
-            let spread = l.content_align == ContentAlign::SpaceBetween;
-            put(
-                "align-content",
-                if spread {
-                    "space-between"
-                } else if align == "baseline" {
-                    "flex-start"
-                } else {
-                    align
-                }
-                .into(),
-            );
-        }
-    }
-    if matches!(n.kind, NodeKind::Ellipse { .. }) {
-        put("border-radius", "50%".into());
-    } else if let Some(r) = n.corners.uniform().filter(|r| *r > 0.0) {
-        put("border-radius", tok(doc, n, &["cornerRadius"], px(r), t));
-    } else if n.corners.radii.iter().any(|r| *r > 0.0) {
-        let fields = ["topLeftRadius", "topRightRadius", "bottomRightRadius", "bottomLeftRadius"];
-        let corners: Vec<String> = n.corners.radii.iter().zip(fields).map(|(r, f)| tok(doc, n, &[f, "cornerRadius"], px(*r), t)).collect();
-        put("border-radius", corners.join(" "));
-    }
-    if n.opacity < 1.0 {
-        put("opacity", tok(doc, n, &["opacity"], num(f64::from(n.opacity)), t));
-    }
-    if !matches!(n.blend, figcraft_color::BlendMode::Normal | figcraft_color::BlendMode::PassThrough) {
-        put("mix-blend-mode", n.blend.css().into());
-    }
-    // Rotation turns counter-clockwise about the top-left corner (the position given); CSS
-    // rotate turns clockwise.
-    let rot = figcraft_geom::rotation_degrees(n.transform);
-    if rot.abs() > 0.01 && rot.is_finite() {
-        put("transform", format!("rotate({}deg)", num(-rot)));
-        put("transform-origin", "top left".into());
-    }
-    for (i, p) in n.fills.iter().enumerate().filter(|(_, p)| p.visible) {
-        match &p.kind {
-            PaintKind::Solid { color } => {
-                let key = if matches!(n.kind, NodeKind::Text(_)) { "color" } else { "background" };
-                let c = color.with_alpha(color.a * p.opacity).to_css();
-                // A variable binds the first paint's colour.
-                put(key, if i == 0 { tok(doc, n, &["fill"], c, t) } else { c });
-            }
-            PaintKind::Gradient(g) => put("background", css_gradient(g, n.width, n.height)),
-            PaintKind::Image(_) => put("background", "url(image.png) center / cover".into()),
-            PaintKind::Pattern(_) => put("background", "url(pattern.png) repeat".into()),
-        }
-    }
-    for (key, value) in css_borders(doc, n, t) {
-        put(&key, value);
-    }
-    let shadows: Vec<String> = n
-        .effects
-        .iter()
-        .filter(|e| e.visible)
-        .filter_map(|e| match &e.kind {
-            EffectKind::DropShadow(s) => {
-                Some(format!("{}px {}px {}px {}px {}", num(s.offset.0), num(s.offset.1), num(s.radius), num(s.spread), s.color.to_css()))
-            }
-            EffectKind::InnerShadow(s) => {
-                Some(format!("inset {}px {}px {}px {}px {}", num(s.offset.0), num(s.offset.1), num(s.radius), num(s.spread), s.color.to_css()))
-            }
-            _ => None,
-        })
-        .collect();
-    if !shadows.is_empty() {
-        put("box-shadow", shadows.join(", "));
-    }
-    for e in n.effects.iter().filter(|e| e.visible) {
-        match e.kind {
-            // CSS blurs are uniform: a progressive blur has no CSS equivalent and is left out.
-            EffectKind::LayerBlur(ref b) if !b.is_progressive() => put("filter", format!("blur({}px)", num(b.radius / 2.0))),
-            EffectKind::BackgroundBlur(ref b) if !b.is_progressive() => put("backdrop-filter", format!("blur({}px)", num(b.radius / 2.0))),
-            // CSS has no refraction: the frost is the nearest.
-            EffectKind::Glass(ref g) => put("backdrop-filter", format!("blur({}px)", num(g.sanitized().frost / 2.0))),
-            _ => {}
-        }
-    }
-    if let NodeKind::Text(tx) = &n.kind {
-        let s = &tx.style;
-        put("font-family", tok(doc, n, &["fontFamily"], format!("\"{}\"", s.font_family.replace('"', "'")), t));
-        put("font-size", tok(doc, n, &["fontSize"], px(s.font_size), t));
-        put("font-weight", s.weight().to_string());
-        if s.italic() {
-            put("font-style", "italic".into());
-        }
-        match s.line_height {
-            LineHeight::Pixels(v) => put("line-height", tok(doc, n, &["lineHeight"], px(v), t)),
-            LineHeight::Percent(p) => put("line-height", format!("{}%", num(p))),
-            LineHeight::Auto => {}
-        }
-        match s.letter_spacing {
-            LetterSpacing::Pixels(v) if v != 0.0 => put("letter-spacing", tok(doc, n, &["letterSpacing"], px(v), t)),
-            LetterSpacing::Percent(p) if p != 0.0 => put("letter-spacing", format!("{}em", num(p / 100.0))),
-            _ => {}
-        }
-        match tx.align_h {
-            TextAlignH::Left => {}
-            TextAlignH::Center => put("text-align", "center".into()),
-            TextAlignH::Right => put("text-align", "right".into()),
-            TextAlignH::Justified => put("text-align", "justify".into()),
-        }
-        match s.case {
-            TextCase::Original => {}
-            TextCase::Upper => put("text-transform", "uppercase".into()),
-            TextCase::Lower => put("text-transform", "lowercase".into()),
-            TextCase::Title => put("text-transform", "capitalize".into()),
-            TextCase::SmallCaps => put("font-variant", "small-caps".into()),
-        }
-        match s.decoration {
-            TextDecoration::None => {}
-            TextDecoration::Underline => put("text-decoration", "underline".into()),
-            TextDecoration::Strikethrough => put("text-decoration", "line-through".into()),
-        }
-        if s.decoration != TextDecoration::None {
-            let l = s.look();
-            let len = |m: LineHeight| match m {
-                LineHeight::Auto => None,
-                LineHeight::Pixels(v) => Some(px(v)),
-                LineHeight::Percent(p) => Some(format!("{}%", num(p))),
-            };
-            match l.style {
-                figcraft_doc::DecorationStyle::Solid => {}
-                figcraft_doc::DecorationStyle::Dotted => put("text-decoration-style", "dotted".into()),
-                figcraft_doc::DecorationStyle::Wavy => put("text-decoration-style", "wavy".into()),
-            }
-            if let Some(v) = len(l.thickness) {
-                put("text-decoration-thickness", v);
-            }
-            if let Some(c) = l.color {
-                put("text-decoration-color", c.to_css());
-            }
-            if s.decoration == TextDecoration::Underline {
-                if let Some(v) = len(l.offset) {
-                    put("text-underline-offset", v);
-                }
-                // Browsers skip ink by default; the canvas only when asked.
-                if !l.skip_ink {
-                    put("text-decoration-skip-ink", "none".into());
-                }
-            }
-        }
-        if tx.leading_trim == figcraft_doc::LeadingTrim::CapHeight {
-            put("text-box", "trim-both cap alphabetic".into());
-        }
-    }
-    out
-}
-
-/// A gradient fill on a `w`×`h` box as a CSS background: linear along its handles' direction
-/// (CSS angles: 0deg up, 90deg right), radial with its handles' radii, angular as a conic
-/// gradient from its start direction.
-fn css_gradient(g: &figcraft_color::Gradient, w: f64, h: f64) -> String {
-    let stops = g.sorted_stops().iter().map(|s| format!("{} {}%", s.color.to_css(), (s.position * 100.0).round())).collect::<Vec<_>>().join(", ");
-    let (dx, dy) = ((g.to.0 - g.from.0) * w, (g.to.1 - g.from.1) * h);
-    let angle = if dx == 0.0 && dy == 0.0 { 180.0 } else { dx.atan2(-dy).to_degrees().rem_euclid(360.0) };
-    let pct = |v: f64| format!("{}%", num(v * 100.0));
-    let at = format!("at {} {}", pct(g.from.0), pct(g.from.1));
-    match g.kind {
-        figcraft_color::GradientKind::Linear => format!("linear-gradient({}deg, {stops})", num(angle)),
-        figcraft_color::GradientKind::Radial | figcraft_color::GradientKind::Diamond => {
-            let (rx, ry) = (((g.width.0 - g.from.0) * w).hypot((g.width.1 - g.from.1) * h), dx.hypot(dy));
-            let rel = |r: f64, side: f64| if side > 0.0 { pct(r / side) } else { "50%".into() };
-            format!("radial-gradient({} {} {at}, {stops})", rel(rx, w), rel(ry, h))
-        }
-        figcraft_color::GradientKind::Angular => format!("conic-gradient(from {}deg {at}, {stops})", num(angle)),
-    }
-}
-
-// ------------------------------------------------------------------ HTML and React markup
-
-/// A word for the node's kind, naming layers whose name transliterates to nothing ("###" →
-/// `.text`, `.frame`), instead of the anonymous `layer-`.
-fn kind_word(n: &Node) -> &str {
-    match &n.kind {
-        NodeKind::Page { .. } => "page",
-        NodeKind::Frame => "frame",
-        NodeKind::Group => "group",
-        NodeKind::Section { .. } => "section",
-        NodeKind::Rectangle => "rectangle",
-        NodeKind::Ellipse { .. } => "ellipse",
-        NodeKind::Polygon { .. } => "polygon",
-        NodeKind::Star { .. } => "star",
-        NodeKind::Line => "line",
-        NodeKind::Vector { .. } => "vector",
-        NodeKind::Text(_) => "text",
-        NodeKind::BooleanOp { .. } => "boolean",
-        NodeKind::Component { .. } | NodeKind::ComponentSet { .. } => "component",
-        NodeKind::Instance { .. } => "instance",
-        NodeKind::Slice => "slice",
-    }
-}
-
-/// A CSS class name from a layer name ("Card / Title" → "card-title"), unique in `used`. The name
-/// is transliterated to ASCII first, so non-Latin names stay readable: 로그인 화면 →
-/// `rogeuin-hwamyeon`, кнопка → `knopka`, über → `uber` (per-codepoint transliteration, the slug
-/// libraries' way); a name left with nothing (symbols only) takes `kind`, and one starting with a
-/// digit keeps the `layer-` prefix.
-pub(crate) fn class_name(name: &str, kind: &str, used: &mut Vec<String>) -> String {
-    let mut base = String::new();
-    for c in deunicode::deunicode(name).chars().flat_map(char::to_lowercase) {
-        if c.is_ascii_alphanumeric() {
-            base.push(c);
-        } else if !base.ends_with('-') && !base.is_empty() {
-            base.push('-');
-        }
-    }
-    // The 40-character cut lands on a word boundary when there is one past the first word.
-    let base = if base.chars().count() > 40 {
-        let cut: String = base.chars().take(40).collect();
-        match cut.rfind('-') {
-            Some(i) if i > 0 => cut[..i].to_string(),
-            _ => cut,
-        }
-    } else {
-        base
-    };
-    let base = base.trim_end_matches('-');
-    let base = if base.is_empty() {
-        kind.to_string()
-    } else if base.starts_with(|c: char| c.is_ascii_digit()) {
-        format!("layer-{base}")
-    } else {
-        base.to_string()
-    };
-    let name = (1..).map(|k| if k == 1 { base.clone() } else { format!("{base}-{k}") }).find(|n| !used.contains(n)).unwrap_or(base);
-    used.push(name.clone());
-    name
-}
-
 /// The index of `markup`'s first tag-closing `>`, skipping `>` inside quoted attribute values.
 fn tag_end(markup: &str) -> Option<usize> {
     let mut quote = None;
@@ -740,855 +409,6 @@ fn with_v_if(markup: &str, guard: Option<&str>) -> String {
     format!("{} v-if=\"{guard}\"{}", &markup[..at], &markup[at..])
 }
 
-fn html_escape(s: &str) -> String {
-    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('\n', "<br>")
-}
-
-/// Text as JSX children: HTML escapes, braces as expressions, line breaks as `<br />`.
-fn jsx_text(s: &str) -> String {
-    let mut out = String::new();
-    for c in s.chars().take(10_000) {
-        match c {
-            '&' => out.push_str("&amp;"),
-            '<' => out.push_str("&lt;"),
-            '>' => out.push_str("&gt;"),
-            '{' => out.push_str("{\"{\"}"),
-            '}' => out.push_str("{\"}\"}"),
-            '\n' => out.push_str("<br />"),
-            '\r' => {}
-            c => out.push(c),
-        }
-    }
-    out
-}
-
-/// The whole tree under `id` as nested HTML with a stylesheet: auto layout frames become
-/// flexboxes, other children are placed absolutely in their parent, text becomes paragraphs.
-fn html(doc: &Document, id: NodeId) -> String {
-    let ctx = Ctx::new(doc, id);
-    let mut out = Markup::new(&ctx, CodeLang::Html);
-    out.node(id, None, 0, "");
-    format!("{}\n<style>\n{}{}</style>\n", out.markup, out.tokens.root_rule(), out.styles)
-}
-
-/// Markup being built for a layer tree: HTML (`class`), React JSX (`className`), Vue
-/// (`{{ }}` interpolation, `v-if`, `:attr` bindings) or Leptos `view!` markup (text as Rust
-/// string literals); the last three with component parameters and instances as calls. With its
-/// stylesheet.
-pub(crate) struct Markup<'c, 'a> {
-    ctx: &'c Ctx<'a>,
-    /// Html, React, Vue or Leptos.
-    lang: CodeLang,
-    used: Vec<String>,
-    pub markup: String,
-    pub styles: String,
-    pub tokens: Tokens,
-    /// The root's class (default: from its name) and extra JSX attributes.
-    pub root_class: Option<String>,
-    pub root_attrs: String,
-    /// A Vue `v-if` guard for the element about to be written: Vue templates can't wrap an
-    /// element in an expression, so a boolean parameter's layer carries the condition itself.
-    v_if: Option<String>,
-    /// A prefix for every generated class name (slot content joins the caller's stylesheet, where
-    /// two slots' layer names may repeat).
-    pub class_prefix: Option<String>,
-    /// Each layer's path in the tree (names with sibling counts), class and declarations, so
-    /// variants can be compared layer by layer.
-    pub rules: Vec<(String, String, String)>,
-    /// Instances as their own (overridden) layers instead of component calls, except those
-    /// connected to code (page code).
-    pub inline: bool,
-    /// Auto layout frames and text as fluid boxes (`width: 100%` up to their width) for pages.
-    pub fluid: bool,
-    /// With `fluid`, other layers at least this share of the root's width are fluid too (a
-    /// divider, a banner image); smaller ones (icons) keep their size. Default: none.
-    pub fluid_leaves: f64,
-}
-
-impl<'c, 'a> Markup<'c, 'a> {
-    pub fn new(ctx: &'c Ctx<'a>, lang: CodeLang) -> Self {
-        Markup {
-            ctx,
-            lang,
-            used: Vec::new(),
-            markup: String::new(),
-            styles: String::new(),
-            tokens: Tokens::default(),
-            root_class: None,
-            root_attrs: String::new(),
-            v_if: None,
-            class_prefix: None,
-            rules: Vec::new(),
-            inline: false,
-            fluid: false,
-            fluid_leaves: f64::INFINITY,
-        }
-    }
-
-    /// JSX and Vue templates indent by two spaces, HTML and Leptos by four.
-    fn pad(&self, depth: usize) -> String {
-        if matches!(self.lang, CodeLang::React | CodeLang::Vue) { "  ".repeat(depth) } else { indent(depth) }
-    }
-
-    /// Component code (React or Leptos): parameters and instances as calls.
-    fn code(&self) -> bool {
-        self.lang != CodeLang::Html
-    }
-
-    /// A parameter's name in the generated code.
-    fn ident(&self, p: &Param) -> String {
-        if self.lang == CodeLang::Leptos { crate::component_codegen::rust_ident(&p.ident) } else { p.ident.clone() }
-    }
-
-    /// A layer, shown only while its boolean parameter is on (component code).
-    pub fn node(&mut self, id: NodeId, parent: Option<&Node>, depth: usize, path: &str) {
-        let Some(n) = self.ctx.doc.node(id) else { return };
-        if self.code()
-            && id != self.ctx.root
-            && let Some(p) = self.ctx.param(n, "visible")
-        {
-            // A Vue template holds no arbitrary expressions, so the guard rides on the element.
-            if self.lang == CodeLang::Vue {
-                self.v_if = Some(self.ident(p));
-                self.element(n, parent, depth, path);
-                self.v_if = None;
-                return;
-            }
-            let (pad, p) = (self.pad(depth), self.ident(p));
-            let (open, close) =
-                if self.lang == CodeLang::Leptos { (format!("{{{p}.then(|| view! {{"), "})}") } else { (format!("{{{p} && ("), ")}") };
-            self.markup.push_str(&format!("{pad}{open}\n"));
-            self.element(n, parent, depth + 1, path);
-            self.markup.push_str(&format!("{pad}{close}\n"));
-            return;
-        }
-        self.element(n, parent, depth, path);
-    }
-
-    fn rule(&mut self, path: &str, class: &str, decls: String) {
-        self.styles.push_str(&format!(".{class} {{\n"));
-        for line in decls.lines() {
-            self.styles.push_str(&format!("  {line}\n"));
-        }
-        self.styles.push_str("}\n");
-        self.rules.push((path.to_string(), class.to_string(), decls));
-    }
-
-    fn element(&mut self, n: &Node, parent: Option<&Node>, depth: usize, path: &str) {
-        let doc = self.ctx.doc;
-        let root = n.id == self.ctx.root;
-        let class = match self.root_class.take().filter(|_| root) {
-            Some(c) => {
-                self.used.push(c.clone());
-                c
-            }
-            None => {
-                let class = class_name(&n.name, kind_word(n), &mut self.used);
-                match &self.class_prefix {
-                    Some(prefix) => format!("{prefix}{class}"),
-                    None => class,
-                }
-            }
-        };
-        let pad = self.pad(depth);
-        let attr = if self.lang == CodeLang::React { "className" } else { "class" };
-        // How it sits in its parent: in the flex flow, or placed at its position.
-        let mut decls = String::new();
-        let in_flow = parent.is_some_and(|p| p.layout.is_some()) && !n.child_layout.absolute;
-        if root {
-            decls.push_str("position: relative;\n");
-        } else if in_flow {
-            let vertical = parent.and_then(|p| p.layout.as_ref()).is_some_and(|l| l.mode == LayoutMode::Vertical);
-            let (main, cross) =
-                if vertical { (n.child_layout.sizing_v, n.child_layout.sizing_h) } else { (n.child_layout.sizing_h, n.child_layout.sizing_v) };
-            if main == Sizing::Fill {
-                decls.push_str("flex: 1 1 0;\n");
-            }
-            if cross == Sizing::Fill {
-                decls.push_str("align-self: stretch;\n");
-            }
-        } else {
-            let c = n.transform.as_coeffs();
-            decls.push_str(&format!("position: absolute;\nleft: {}px;\ntop: {}px;\n", num(c[4]), num(c[5])));
-            let rot = figcraft_geom::rotation_degrees(n.transform);
-            if rot.abs() > 0.01 {
-                decls.push_str(&format!("transform: rotate({}deg);\ntransform-origin: 0 0;\n", num(-rot)));
-            }
-        }
-        // Nested instances are calls (component code), in a wrapper that places them when needed.
-        // Page code inlines instances, except those connected to code (codeConnect.set): their
-        // snippet, e.g. a design-system `<Button>`.
-        let connected = self.inline && crate::code_connect::link(doc, n.id, CodeLang::React).is_some();
-        if self.code() && (!self.inline || connected) && !root && matches!(n.kind, NodeKind::Instance { .. }) {
-            let at = depth + usize::from(!decls.is_empty());
-            let run = if self.lang == CodeLang::Leptos { ".run()" } else { "" };
-            let (inner, css) = match self.ctx.param(n, "mainComponent") {
-                Some(p) if self.lang == CodeLang::Vue => (Some(format!("{}<component :is=\"{}\" />\n", self.pad(at), self.ident(p))), String::new()),
-                Some(p) => (Some(format!("{}{{{}{run}}}\n", self.pad(at), self.ident(p))), String::new()),
-                None => self.ctx.call(n, self.lang, at).map_or((None, String::new()), |(code, css)| (Some(code), css)),
-            };
-            self.styles.push_str(&css);
-            if let Some(inner) = inner {
-                // A Vue guard set by `node` rides on the call when there is no wrapper.
-                let guard = if self.lang == CodeLang::Vue { self.v_if.take() } else { None };
-                if decls.is_empty() {
-                    self.markup.push_str(&with_v_if(&inner, guard.as_deref()));
-                } else {
-                    let guard = guard.map(|g| format!(" v-if=\"{g}\"")).unwrap_or_default();
-                    self.markup.push_str(&format!("{pad}<div {attr}=\"{class}\"{guard}>\n{inner}{pad}</div>\n"));
-                    self.rule(path, &class, decls);
-                }
-                return;
-            }
-        }
-        let hugs = n.layout.is_some() || matches!(n.kind, NodeKind::Text(_));
-        let hug = (hugs && n.child_layout.sizing_h == Sizing::Hug, hugs && n.child_layout.sizing_v == Sizing::Hug);
-        let mut own = css_decls(doc, n, &mut self.tokens, hug);
-        let page = self.ctx.doc.node(self.ctx.root).map_or(f64::INFINITY, |r| r.width);
-        if self.fluid && (n.layout.is_some() || matches!(n.kind, NodeKind::Text(_)) || (!root && n.width >= page * self.fluid_leaves)) {
-            // Full width, or sized by the flex row (`flex: 1`): no cap needed.
-            own = fluid(&own, n.width >= page - 0.5 || decls.contains("flex: 1 1 0;"), n.layout.is_some());
-        }
-        if n.layout.is_none() && !n.children.is_empty() && !root && in_flow {
-            own.push_str("position: relative;\n");
-        }
-        decls.push_str(&own);
-        self.rule(path, &class, decls);
-        // The root's variant attributes, and a Vue `v-if` guard, ride on the open tag.
-        let mut attrs = if root { self.root_attrs.clone() } else { String::new() };
-        if self.lang == CodeLang::Vue
-            && let Some(guard) = self.v_if.take()
-        {
-            attrs.push_str(&format!(" v-if=\"{guard}\""));
-        }
-        let open = |tag: &str| format!("{pad}<{tag} {attr}=\"{class}\"{attrs}>");
-        match &n.kind {
-            NodeKind::Text(t) => {
-                let body = match (self.ctx.param(n, "characters").filter(|_| self.code()), self.lang) {
-                    (Some(p), CodeLang::Leptos) => format!("{{{}.clone()}}", self.ident(p)),
-                    (Some(p), CodeLang::Vue) => format!("{{{{ {} }}}}", self.ident(p)),
-                    (Some(p), _) => format!("{{{}}}", p.ident),
-                    (None, CodeLang::React) => jsx_text(&t.characters),
-                    // `view!` takes text as string literals and void elements self-closed.
-                    (None, CodeLang::Leptos) => {
-                        t.characters.chars().take(10_000).collect::<String>().lines().map(|l| format!("{l:?}")).collect::<Vec<_>>().join("<br/>")
-                    }
-                    // A Vue template reads `{{ }}` as interpolation, so braces are escaped.
-                    (None, CodeLang::Vue) => html_escape(&t.characters).replace('{', "&#123;").replace('}', "&#125;"),
-                    (None, _) => html_escape(&t.characters),
-                };
-                self.markup.push_str(&format!("{}{body}</p>\n", open("p")));
-            }
-            _ => {
-                let kids = self.ctx.kids(n);
-                let slot = self.ctx.param(n, "slot").filter(|_| self.code());
-                let vue = self.lang == CodeLang::Vue;
-                let leptos = self.lang == CodeLang::Leptos;
-                let open = open("div");
-                let slot_ident = slot.map(|p| match self.ctx.comp {
-                    Some(c) => crate::component_codegen::slot_name(c, p),
-                    None => class_name(&p.ident, "slot", &mut Vec::new()),
-                });
-                if let Some(p) = slot.filter(|_| kids.is_empty()) {
-                    let content = if leptos {
-                        format!("{{{}}}.as_ref().map(|c| c.run())", self.ident(p))
-                    } else if vue {
-                        // Vue's own slot element, named so an instance's content lands in the right one.
-                        match slot_ident.clone() {
-                            Some(name) => format!("<slot name=\"{name}\" />"),
-                            None => "<slot />".into(),
-                        }
-                    } else {
-                        format!("{{{}}}", p.ident)
-                    };
-                    self.markup.push_str(&format!("{open}{content}</div>\n"));
-                } else if kids.is_empty() || self.ctx.too_deep(depth) {
-                    self.markup.push_str(&format!("{open}</div>\n"));
-                } else {
-                    self.markup.push_str(&format!("{open}\n"));
-                    // A slot shows the instance's content, or else the main's.
-                    let (p1, p2) = (self.pad(depth + 1), self.pad(depth + 2));
-                    let inner = match slot {
-                        Some(_) if vue => {
-                            let name = slot_ident.clone().map(|n| format!(" name=\"{n}\"")).unwrap_or_default();
-                            self.markup.push_str(&format!("{p1}<slot{name}>\n"));
-                            depth + 2
-                        }
-                        Some(p) if leptos => {
-                            self.markup.push_str(&format!("{p1}{{match &{} {{ Some(c) => c.run(), None => view! {{\n", self.ident(p)));
-                            depth + 2
-                        }
-                        Some(p) => {
-                            self.markup.push_str(&format!("{p1}{{{} ?? (\n{p2}<>\n", p.ident));
-                            depth + 3
-                        }
-                        None => depth + 1,
-                    };
-                    let mut seen: Vec<&str> = Vec::new();
-                    // Bottom layer first: later elements paint on top, like the layer order.
-                    for k in kids {
-                        let Some(kn) = doc.node(k) else { continue };
-                        let count = seen.iter().filter(|s| **s == kn.name).count();
-                        seen.push(&kn.name);
-                        self.node(k, Some(n), inner, &format!("{path}/{}#{count}", kn.name));
-                    }
-                    match slot {
-                        Some(_) if vue => self.markup.push_str(&format!("{p1}</slot>\n")),
-                        Some(_) if leptos => self.markup.push_str(&format!("{p1}}}.into_any() }}}}\n")),
-                        Some(_) => self.markup.push_str(&format!("{p2}</>\n{p1})}}\n")),
-                        None => {}
-                    }
-                    self.markup.push_str(&format!("{pad}</div>\n"));
-                }
-            }
-        }
-    }
-}
-
-/// `decls` for a box that follows the page: a fixed width becomes `width: 100%` capped at that
-/// width (or just the full width for boxes as wide as the page), and a frame's fixed height a
-/// minimum, so content can wrap and grow.
-// ponytail: width-based heuristic; fixed-size leaves (icons, images, shapes) keep their pixels.
-fn fluid(decls: &str, full: bool, frame: bool) -> String {
-    let mut out = String::with_capacity(decls.len() + 32);
-    for line in decls.lines() {
-        if let Some(w) = line.strip_prefix("width: ") {
-            out.push_str("width: 100%;\n");
-            if !full {
-                out.push_str(&format!("max-width: {w}\n"));
-            }
-        } else if let Some(h) = line.strip_prefix("height: ").filter(|_| frame) {
-            out.push_str(&format!("min-height: {h}\n"));
-        } else {
-            out.push_str(line);
-            out.push('\n');
-        }
-    }
-    out
-}
-
-// ------------------------------------------------------------------ SwiftUI
-
-fn swift_color(c: Color) -> String {
-    format!("Color(red: {}, green: {}, blue: {}, opacity: {})", num(f64::from(c.r)), num(f64::from(c.g)), num(f64::from(c.b)), num(f64::from(c.a)))
-}
-
-fn swift_weight(w: u16) -> &'static str {
-    match w {
-        0..=150 => ".thin",
-        151..=250 => ".ultraLight",
-        251..=350 => ".light",
-        351..=450 => ".regular",
-        451..=550 => ".medium",
-        551..=650 => ".semibold",
-        651..=750 => ".bold",
-        751..=850 => ".heavy",
-        _ => ".black",
-    }
-}
-
-/// SwiftUI for a layer and its subtree at `depth`; `extra` modifiers go last (a free child's
-/// offset). A layer a boolean parameter shows sits in an `if`.
-pub(crate) fn swift(ctx: &Ctx, id: NodeId, depth: usize, out: &mut String, extra: &[String]) {
-    let Some(n) = ctx.doc.node(id) else { return };
-    if id != ctx.root
-        && let Some(p) = ctx.param(n, "visible")
-    {
-        let pad = indent(depth);
-        out.push_str(&format!("{pad}if {} {{\n", p.ident));
-        swift_layer(ctx, n, depth + 1, out, extra);
-        out.push_str(&format!("{pad}}}\n"));
-        return;
-    }
-    swift_layer(ctx, n, depth, out, extra);
-}
-
-/// A layer name safe for a single-line `//` comment: line breaks become spaces.
-fn one_line(name: &str) -> String {
-    name.replace(['\n', '\r', '\u{85}', '\u{2028}', '\u{2029}'], " ")
-}
-
-fn swift_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String, extra: &[String]) {
-    let doc = ctx.doc;
-    let pad = indent(depth);
-    if ctx.too_deep(depth) {
-        out.push_str(&format!("{pad}// {} …\n", one_line(&n.name)));
-        return;
-    }
-    // Nested instances are calls; an instance swap parameter is a view.
-    let call = match ctx.param(n, "mainComponent").filter(|_| n.id != ctx.root) {
-        Some(p) => Some(format!("{pad}{}\n", p.ident)),
-        None => ctx.call(n, CodeLang::SwiftUi, depth).map(|(code, _)| code),
-    };
-    if let Some(call) = call {
-        out.push_str(&call);
-        for m in extra {
-            out.push_str(&format!("{pad}    {m}\n"));
-        }
-        return;
-    }
-    let mut mods: Vec<String> = Vec::new();
-    match &n.kind {
-        NodeKind::Text(t) => {
-            let text = ctx.param(n, "characters").map_or_else(|| literal(&t.characters, false), |p| p.ident.clone());
-            out.push_str(&format!("{pad}Text({text})\n"));
-            mods.push(format!(
-                ".font(.custom({}, size: {}).weight({}))",
-                literal(&t.style.font_family, false),
-                num(t.style.font_size),
-                swift_weight(t.style.weight())
-            ));
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".foregroundColor({})", swift_color(c)));
-            }
-        }
-        NodeKind::Ellipse { .. } => {
-            out.push_str(&format!("{pad}Ellipse()\n"));
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".fill({})", swift_color(c)));
-            }
-            mods.push(format!(".frame(width: {}, height: {})", num(n.width), num(n.height)));
-        }
-        NodeKind::Rectangle => {
-            out.push_str(&format!("{pad}RoundedRectangle(cornerRadius: {})\n", num(radius(n))));
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".fill({})", swift_color(c)));
-            }
-            mods.push(format!(".frame(width: {}, height: {})", num(n.width), num(n.height)));
-        }
-        k if k.is_frame_like() || matches!(k, NodeKind::Group) => {
-            let children = ctx.kids(n);
-            let open = match n.layout.as_ref().map(|l| (l.mode, l)) {
-                Some((LayoutMode::Vertical, l)) => format!("VStack(alignment: .leading, spacing: {}) {{", num(l.gap)),
-                Some((_, l)) => format!("HStack(alignment: .center, spacing: {}) {{", num(l.gap)),
-                None => "ZStack(alignment: .topLeading) {".to_string(),
-            };
-            out.push_str(&format!("{pad}{open}\n"));
-            // A slot shows the instance's content, or else the main's.
-            let slot = ctx.param(n, "slot");
-            let inner = match slot {
-                Some(p) => {
-                    out.push_str(&format!("{pad}    if let {0} {{\n{pad}        {0}\n{pad}    }} else {{\n", p.ident));
-                    depth + 2
-                }
-                None => depth + 1,
-            };
-            for c in &children {
-                // Free children sit at their offset inside a ZStack.
-                let offset: Vec<String> = match doc.node(*c).filter(|_| n.layout.is_none()) {
-                    Some(cn) => {
-                        let [_, _, _, _, x, y] = cn.transform.as_coeffs();
-                        vec![format!(".offset(x: {}, y: {})", num(x), num(y))]
-                    }
-                    None => Vec::new(),
-                };
-                swift(ctx, *c, inner, out, &offset);
-            }
-            if slot.is_some() {
-                out.push_str(&format!("{pad}    }}\n"));
-            }
-            out.push_str(&format!("{pad}}}\n"));
-            if let Some(l) = &n.layout {
-                let [t, r, b, lft] = l.padding;
-                if [t, r, b, lft].iter().any(|v| *v > 0.0) {
-                    mods.push(format!(".padding(EdgeInsets(top: {}, leading: {}, bottom: {}, trailing: {}))", num(t), num(lft), num(b), num(r)));
-                }
-            }
-            mods.push(format!(".frame(width: {}, height: {}, alignment: .topLeading)", num(n.width), num(n.height)));
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".background({})", swift_color(c)));
-            }
-            if radius(n) > 0.0 {
-                mods.push(format!(".clipShape(RoundedRectangle(cornerRadius: {}))", num(radius(n))));
-            }
-        }
-        _ => {
-            out.push_str(&format!("{pad}// {}: export as an image asset\n{pad}Image({})\n", n.kind.label(), literal(&n.name, false)));
-            mods.push(".resizable()".into());
-            mods.push(format!(".frame(width: {}, height: {})", num(n.width), num(n.height)));
-        }
-    }
-    if let Some(c) = stroke_color(n) {
-        mods.push(format!(
-            ".overlay(RoundedRectangle(cornerRadius: {}).stroke({}, lineWidth: {}))",
-            num(radius(n)),
-            swift_color(c),
-            num(n.stroke.weight)
-        ));
-    }
-    if let Some(s) = drop_shadow(n) {
-        mods.push(format!(
-            ".shadow(color: {}, radius: {}, x: {}, y: {})",
-            swift_color(s.color),
-            num(s.radius / 2.0),
-            num(s.offset.0),
-            num(s.offset.1)
-        ));
-    }
-    if n.opacity < 1.0 {
-        mods.push(format!(".opacity({})", num(f64::from(n.opacity))));
-    }
-    mods.extend(extra.iter().cloned());
-    for m in mods {
-        out.push_str(&format!("{pad}    {m}\n"));
-    }
-}
-
-// ------------------------------------------------------------------ Jetpack Compose
-
-/// `Color(0xAARRGGBB)`, as Compose and Flutter both write a colour.
-pub(crate) fn kotlin_color(c: Color) -> String {
-    let [r, g, b, a] = c.to_rgba8();
-    format!("Color(0x{a:02X}{r:02X}{g:02X}{b:02X})")
-}
-
-/// The Modifier chain for a layer (size, shadow, background, border, alpha, padding).
-fn modifier(n: &Node, shape: &str, padding: bool) -> String {
-    let mut m = format!("Modifier.size({}.dp, {}.dp)", num(n.width), num(n.height));
-    if let Some(s) = drop_shadow(n) {
-        m.push_str(&format!(".shadow({}.dp, {shape})", num(s.radius / 2.0)));
-    }
-    if let Some(c) = first_fill(n) {
-        m.push_str(&format!(".background({}, {shape})", kotlin_color(c)));
-    }
-    if let Some(c) = stroke_color(n) {
-        m.push_str(&format!(".border({}.dp, {}, {shape})", num(n.stroke.weight), kotlin_color(c)));
-    }
-    if n.opacity < 1.0 {
-        m.push_str(&format!(".alpha({}f)", num(f64::from(n.opacity))));
-    }
-    if padding && let Some(l) = &n.layout {
-        let [t, r, b, lft] = l.padding;
-        if [t, r, b, lft].iter().any(|v| *v > 0.0) {
-            m.push_str(&format!(".padding(start = {}.dp, top = {}.dp, end = {}.dp, bottom = {}.dp)", num(lft), num(t), num(r), num(b)));
-        }
-    }
-    m
-}
-
-/// Jetpack Compose for a layer and its subtree at `depth`. A layer a boolean parameter shows sits
-/// in an `if`.
-pub(crate) fn compose(ctx: &Ctx, id: NodeId, depth: usize, out: &mut String) {
-    let Some(n) = ctx.doc.node(id) else { return };
-    if id != ctx.root
-        && let Some(p) = ctx.param(n, "visible")
-    {
-        let pad = indent(depth);
-        out.push_str(&format!("{pad}if ({}) {{\n", p.ident));
-        compose_layer(ctx, n, depth + 1, out);
-        out.push_str(&format!("{pad}}}\n"));
-        return;
-    }
-    compose_layer(ctx, n, depth, out);
-}
-
-fn compose_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String) {
-    let doc = ctx.doc;
-    let pad = indent(depth);
-    if ctx.too_deep(depth) {
-        out.push_str(&format!("{pad}// {} …\n", one_line(&n.name)));
-        return;
-    }
-    // Nested instances are calls; an instance swap parameter is a composable.
-    let call = match ctx.param(n, "mainComponent").filter(|_| n.id != ctx.root) {
-        Some(p) => Some(format!("{pad}{}()\n", p.ident)),
-        None => ctx.call(n, CodeLang::Compose, depth).map(|(code, _)| code),
-    };
-    if let Some(call) = call {
-        out.push_str(&call);
-        return;
-    }
-    let shape = if radius(n) > 0.0 { format!("RoundedCornerShape({}.dp)", num(radius(n))) } else { "RectangleShape".to_string() };
-    match &n.kind {
-        NodeKind::Text(t) => {
-            let color = first_fill(n).map(kotlin_color).unwrap_or_else(|| "Color.Unspecified".into());
-            let text = ctx.param(n, "characters").map_or_else(|| literal(&t.characters, true), |p| p.ident.clone());
-            out.push_str(&format!(
-                "{pad}Text(\n{pad}    text = {text},\n{pad}    fontSize = {}.sp,\n{pad}    fontWeight = FontWeight.W{},\n{pad}    color = {color},\n{pad})\n",
-                num(t.style.font_size),
-                (t.style.weight().clamp(100, 900) / 100) * 100
-            ));
-        }
-        NodeKind::Ellipse { .. } => out.push_str(&format!("{pad}Box(modifier = {})\n", modifier(n, "CircleShape", false))),
-        NodeKind::Rectangle => out.push_str(&format!("{pad}Box(modifier = {})\n", modifier(n, &shape, false))),
-        k if k.is_frame_like() || matches!(k, NodeKind::Group) => {
-            let children = ctx.kids(n);
-            let open = match n.layout.as_ref().map(|l| (l.mode, l)) {
-                Some((LayoutMode::Vertical, l)) => format!(
-                    "Column(\n{pad}    modifier = {},\n{pad}    verticalArrangement = Arrangement.spacedBy({}.dp),\n{pad}) {{",
-                    modifier(n, &shape, true),
-                    num(l.gap)
-                ),
-                Some((_, l)) => format!(
-                    "Row(\n{pad}    modifier = {},\n{pad}    horizontalArrangement = Arrangement.spacedBy({}.dp),\n{pad}    verticalAlignment = Alignment.CenterVertically,\n{pad}) {{",
-                    modifier(n, &shape, true),
-                    num(l.gap)
-                ),
-                None => format!("Box(modifier = {}) {{", modifier(n, &shape, false)),
-            };
-            out.push_str(&format!("{pad}{open}\n"));
-            // A slot shows the instance's content, or else the main's.
-            let slot = ctx.param(n, "slot");
-            let base = match slot {
-                Some(p) => {
-                    out.push_str(&format!("{pad}    if ({0} != null) {{\n{pad}        {0}()\n{pad}    }} else {{\n", p.ident));
-                    depth + 1
-                }
-                None => depth,
-            };
-            for c in &children {
-                if n.layout.is_none()
-                    && let Some(cn) = doc.node(*c)
-                {
-                    let [_, _, _, _, x, y] = cn.transform.as_coeffs();
-                    out.push_str(&format!("{}Box(modifier = Modifier.offset({}.dp, {}.dp)) {{\n", indent(base + 1), num(x), num(y)));
-                    compose(ctx, *c, base + 2, out);
-                    out.push_str(&format!("{}}}\n", indent(base + 1)));
-                } else {
-                    compose(ctx, *c, base + 1, out);
-                }
-            }
-            if slot.is_some() {
-                out.push_str(&format!("{pad}    }}\n"));
-            }
-            out.push_str(&format!("{pad}}}\n"));
-        }
-        _ => out.push_str(&format!(
-            "{pad}// {}: export as an image asset\n{pad}Image(painter = painterResource(R.drawable.asset), contentDescription = {}, modifier = Modifier.size({}.dp, {}.dp))\n",
-            n.kind.label(),
-            literal(&n.name, true),
-            num(n.width),
-            num(n.height)
-        )),
-    }
-}
-
-// ------------------------------------------------------------------ ArkUI (ArkTS)
-
-/// A colour as ArkUI writes it: `'#RRGGBB'`, or `'#AARRGGBB'` with transparency.
-fn ark_color(c: Color) -> String {
-    let [r, g, b, a] = c.to_rgba8();
-    if a == 255 { format!("'#{r:02X}{g:02X}{b:02X}'") } else { format!("'#{a:02X}{r:02X}{g:02X}{b:02X}'") }
-}
-
-/// A layer's corner radii as `.borderRadius(...)` (uniform or per corner).
-fn ark_radius(n: &Node, mods: &mut Vec<String>) {
-    if let Some(r) = n.corners.uniform() {
-        if r > 0.0 {
-            mods.push(format!(".borderRadius({})", num(r)));
-        }
-    } else if n.corners.radii.iter().any(|r| *r > 0.0) {
-        let [tl, tr, br, bl] = n.corners.radii;
-        mods.push(format!(".borderRadius({{ topLeft: {}, topRight: {}, bottomRight: {}, bottomLeft: {} }})", num(tl), num(tr), num(br), num(bl)));
-    }
-}
-
-/// ArkUI for a layer and its subtree at `depth`; `extra` attributes go last (a free child's
-/// position). A layer a boolean parameter shows sits in an `if`.
-pub(crate) fn arkui(ctx: &Ctx, id: NodeId, depth: usize, out: &mut String, extra: &[String]) {
-    let Some(n) = ctx.doc.node(id) else { return };
-    if id != ctx.root
-        && let Some(p) = ctx.param(n, "visible")
-    {
-        let pad = indent(depth);
-        out.push_str(&format!("{pad}if (this.{}) {{\n", p.ident));
-        arkui_layer(ctx, n, depth + 1, out, extra);
-        out.push_str(&format!("{pad}}}\n"));
-        return;
-    }
-    arkui_layer(ctx, n, depth, out, extra);
-}
-
-fn arkui_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String, extra: &[String]) {
-    let doc = ctx.doc;
-    let pad = indent(depth);
-    if ctx.too_deep(depth) {
-        out.push_str(&format!("{pad}// {} …\n", one_line(&n.name)));
-        return;
-    }
-    // Nested instances are calls; an instance swap parameter is a builder.
-    let swap = ctx.param(n, "mainComponent").filter(|_| n.id != ctx.root);
-    let call = match swap {
-        Some(p) => Some(format!("{pad}this.{}()\n", p.ident)),
-        None => ctx.call(n, CodeLang::ArkUi, depth).map(|(code, _)| code),
-    };
-    if let Some(call) = call {
-        if let Some(p) = swap.filter(|_| !extra.is_empty()) {
-            // The builder returns nothing, so a position goes on a container around the call.
-            out.push_str(&format!("{pad}Stack() {{\n{pad}    this.{}()\n{pad}}}\n", p.ident));
-            for m in extra {
-                out.push_str(&format!("{pad}{m}\n"));
-            }
-            return;
-        }
-        out.push_str(&call);
-        for m in extra {
-            out.push_str(&format!("{pad}    {m}\n"));
-        }
-        return;
-    }
-    let mut mods: Vec<String> = Vec::new();
-    match &n.kind {
-        NodeKind::Text(t) => {
-            let text = ctx.param(n, "characters").map_or_else(|| literal(&t.characters, false), |p| format!("this.{}", p.ident));
-            out.push_str(&format!("{pad}Text({text})\n"));
-            let s = &t.style;
-            mods.push(format!(".fontSize({})", num(s.font_size)));
-            mods.push(format!(".fontWeight({})", s.weight().clamp(100, 900)));
-            mods.push(format!(".fontFamily({})", literal(&s.font_family, false)));
-            if s.italic() {
-                mods.push(".fontStyle(FontStyle.Italic)".into());
-            }
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".fontColor({})", ark_color(c)));
-            }
-            match s.line_height {
-                LineHeight::Pixels(v) => mods.push(format!(".lineHeight({})", num(v))),
-                LineHeight::Percent(p) => mods.push(format!(".lineHeight('{}%')", num(p))),
-                LineHeight::Auto => {}
-            }
-            match s.letter_spacing {
-                LetterSpacing::Pixels(v) if v != 0.0 => mods.push(format!(".letterSpacing({})", num(v))),
-                LetterSpacing::Percent(p) if p != 0.0 => mods.push(format!(".letterSpacing('{}%')", num(p))),
-                _ => {}
-            }
-            match t.align_h {
-                TextAlignH::Left => {}
-                TextAlignH::Center => mods.push(".textAlign(TextAlign.Center)".into()),
-                TextAlignH::Right => mods.push(".textAlign(TextAlign.End)".into()),
-                TextAlignH::Justified => mods.push(".textAlign(TextAlign.JUSTIFY)".into()),
-            }
-            // Aligning needs a box to align in: the text layer's own width.
-            if !matches!(t.align_h, TextAlignH::Left) {
-                mods.push(format!(".width({})", num(n.width)));
-            }
-            match s.case {
-                TextCase::Upper => mods.push(".textCase(TextCase.UpperCase)".into()),
-                TextCase::Lower => mods.push(".textCase(TextCase.LowerCase)".into()),
-                _ => {}
-            }
-            match s.decoration {
-                TextDecoration::Underline => mods.push(".decoration({ type: TextDecorationType.Underline })".into()),
-                TextDecoration::Strikethrough => mods.push(".decoration({ type: TextDecorationType.LineThrough })".into()),
-                TextDecoration::None => {}
-            }
-        }
-        NodeKind::Ellipse { .. } => {
-            out.push_str(&format!("{pad}Ellipse({{ width: {}, height: {} }})\n", num(n.width), num(n.height)));
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".fill({})", ark_color(c)));
-            }
-            if let Some(c) = stroke_color(n) {
-                mods.push(format!(".stroke({})", ark_color(c)));
-                mods.push(format!(".strokeWidth({})", num(n.stroke.weight)));
-            }
-        }
-        NodeKind::Rectangle => {
-            out.push_str(&format!("{pad}Column()\n"));
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".backgroundColor({})", ark_color(c)));
-            }
-            ark_radius(n, &mut mods);
-            mods.push(format!(".width({})", num(n.width)));
-            mods.push(format!(".height({})", num(n.height)));
-        }
-        k if k.is_frame_like() || matches!(k, NodeKind::Group) => {
-            let open = match n.layout.as_ref().map(|l| (l.mode, l)) {
-                Some((LayoutMode::Vertical, l)) => format!("Column({{ space: {} }})", num(l.gap)),
-                Some((_, l)) => format!("Row({{ space: {} }})", num(l.gap)),
-                None => "Stack({ alignContent: Alignment.TopStart })".to_string(),
-            };
-            out.push_str(&format!("{pad}{open} {{\n"));
-            match ctx.param(n, "slot") {
-                // A slot shows the instance's content, or else the main's (its default builder).
-                Some(p) => out.push_str(&format!("{pad}    this.{}()\n", p.ident)),
-                None => {
-                    for c in ctx.kids(n) {
-                        // Free children sit at their position inside a Stack, and so does a child
-                        // that ignores its auto layout parent.
-                        let pos: Vec<String> = match doc.node(c).filter(|cn| n.layout.is_none() || cn.child_layout.absolute) {
-                            Some(cn) => {
-                                let [_, _, _, _, x, y] = cn.transform.as_coeffs();
-                                vec![format!(".position({{ x: {}, y: {} }})", num(x), num(y))]
-                            }
-                            None => Vec::new(),
-                        };
-                        arkui(ctx, c, depth + 1, out, &pos);
-                    }
-                }
-            }
-            out.push_str(&format!("{pad}}}\n"));
-            if let Some(l) = &n.layout {
-                let [t, r, b, lft] = l.padding;
-                if [t, r, b, lft].iter().any(|v| *v > 0.0) {
-                    mods.push(format!(".padding({{ top: {}, right: {}, bottom: {}, left: {} }})", num(t), num(r), num(b), num(lft)));
-                }
-                let justify = match l.main_align {
-                    MainAlign::Min => None,
-                    MainAlign::Center => Some("FlexAlign.Center"),
-                    MainAlign::Max => Some("FlexAlign.End"),
-                    MainAlign::SpaceBetween => Some("FlexAlign.SpaceBetween"),
-                    MainAlign::SpaceAround => Some("FlexAlign.SpaceAround"),
-                    MainAlign::SpaceEvenly => Some("FlexAlign.SpaceEvenly"),
-                };
-                if let Some(j) = justify {
-                    mods.push(format!(".justifyContent({j})"));
-                }
-                let cross = match l.cross_align {
-                    CrossAlign::Min => None,
-                    CrossAlign::Center => Some("Center"),
-                    CrossAlign::Max => Some(if l.mode == LayoutMode::Vertical { "End" } else { "Bottom" }),
-                    CrossAlign::Baseline => None,
-                };
-                if let Some(c) = cross {
-                    let ty = if l.mode == LayoutMode::Vertical { "HorizontalAlign" } else { "VerticalAlign" };
-                    mods.push(format!(".alignItems({ty}.{c})"));
-                }
-            }
-            mods.push(format!(".width({})", num(n.width)));
-            mods.push(format!(".height({})", num(n.height)));
-            if let Some(c) = first_fill(n) {
-                mods.push(format!(".backgroundColor({})", ark_color(c)));
-            }
-            if radius(n) > 0.0 {
-                mods.push(".clip(true)".into());
-            }
-            ark_radius(n, &mut mods);
-        }
-        _ => {
-            out.push_str(&format!("{pad}// {}: export as an image asset\n{pad}Image($r('app.media.asset'))\n", n.kind.label()));
-            mods.push(format!(".width({})", num(n.width)));
-            mods.push(format!(".height({})", num(n.height)));
-        }
-    }
-    // Ellipses take their stroke as a shape attribute (above).
-    if !matches!(n.kind, NodeKind::Ellipse { .. })
-        && let Some(c) = stroke_color(n)
-    {
-        mods.push(format!(".border({{ width: {}, color: {} }})", num(n.stroke.weight), ark_color(c)));
-    }
-    if let Some(s) = drop_shadow(n) {
-        mods.push(format!(
-            ".shadow({{ radius: {}, color: {}, offsetX: {}, offsetY: {} }})",
-            num(s.radius / 2.0),
-            ark_color(s.color),
-            num(s.offset.0),
-            num(s.offset.1)
-        ));
-    }
-    if n.opacity < 1.0 {
-        mods.push(format!(".opacity({})", num(f64::from(n.opacity))));
-    }
-    let rot = figcraft_geom::rotation_degrees(n.transform);
-    if rot.abs() > 0.01 && rot.is_finite() {
-        mods.push(format!(".rotate({{ angle: {} }})", num(-rot)));
-    }
-    mods.extend(extra.iter().cloned());
-    for m in mods {
-        out.push_str(&format!("{pad}    {m}\n"));
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/engine/src/dev/codegen/arkui.rs b/crates/engine/src/dev/codegen/arkui.rs
new file mode 100644
index 00000000..1d9816f6
--- /dev/null
+++ b/crates/engine/src/dev/codegen/arkui.rs
@@ -0,0 +1,228 @@
+use super::swift::one_line;
+use super::*;
+
+// ------------------------------------------------------------------ ArkUI (ArkTS)
+
+/// A colour as ArkUI writes it: `'#RRGGBB'`, or `'#AARRGGBB'` with transparency.
+fn ark_color(c: Color) -> String {
+    let [r, g, b, a] = c.to_rgba8();
+    if a == 255 { format!("'#{r:02X}{g:02X}{b:02X}'") } else { format!("'#{a:02X}{r:02X}{g:02X}{b:02X}'") }
+}
+
+/// A layer's corner radii as `.borderRadius(...)` (uniform or per corner).
+fn ark_radius(n: &Node, mods: &mut Vec<String>) {
+    if let Some(r) = n.corners.uniform() {
+        if r > 0.0 {
+            mods.push(format!(".borderRadius({})", num(r)));
+        }
+    } else if n.corners.radii.iter().any(|r| *r > 0.0) {
+        let [tl, tr, br, bl] = n.corners.radii;
+        mods.push(format!(".borderRadius({{ topLeft: {}, topRight: {}, bottomRight: {}, bottomLeft: {} }})", num(tl), num(tr), num(br), num(bl)));
+    }
+}
+
+/// ArkUI for a layer and its subtree at `depth`; `extra` attributes go last (a free child's
+/// position). A layer a boolean parameter shows sits in an `if`.
+pub(crate) fn arkui(ctx: &Ctx, id: NodeId, depth: usize, out: &mut String, extra: &[String]) {
+    let Some(n) = ctx.doc.node(id) else { return };
+    if id != ctx.root
+        && let Some(p) = ctx.param(n, "visible")
+    {
+        let pad = indent(depth);
+        out.push_str(&format!("{pad}if (this.{}) {{\n", p.ident));
+        arkui_layer(ctx, n, depth + 1, out, extra);
+        out.push_str(&format!("{pad}}}\n"));
+        return;
+    }
+    arkui_layer(ctx, n, depth, out, extra);
+}
+
+fn arkui_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String, extra: &[String]) {
+    let doc = ctx.doc;
+    let pad = indent(depth);
+    if ctx.too_deep(depth) {
+        out.push_str(&format!("{pad}// {} …\n", one_line(&n.name)));
+        return;
+    }
+    // Nested instances are calls; an instance swap parameter is a builder.
+    let swap = ctx.param(n, "mainComponent").filter(|_| n.id != ctx.root);
+    let call = match swap {
+        Some(p) => Some(format!("{pad}this.{}()\n", p.ident)),
+        None => ctx.call(n, CodeLang::ArkUi, depth).map(|(code, _)| code),
+    };
+    if let Some(call) = call {
+        if let Some(p) = swap.filter(|_| !extra.is_empty()) {
+            // The builder returns nothing, so a position goes on a container around the call.
+            out.push_str(&format!("{pad}Stack() {{\n{pad}    this.{}()\n{pad}}}\n", p.ident));
+            for m in extra {
+                out.push_str(&format!("{pad}{m}\n"));
+            }
+            return;
+        }
+        out.push_str(&call);
+        for m in extra {
+            out.push_str(&format!("{pad}    {m}\n"));
+        }
+        return;
+    }
+    let mut mods: Vec<String> = Vec::new();
+    match &n.kind {
+        NodeKind::Text(t) => {
+            let text = ctx.param(n, "characters").map_or_else(|| literal(&t.characters, false), |p| format!("this.{}", p.ident));
+            out.push_str(&format!("{pad}Text({text})\n"));
+            let s = &t.style;
+            mods.push(format!(".fontSize({})", num(s.font_size)));
+            mods.push(format!(".fontWeight({})", s.weight().clamp(100, 900)));
+            mods.push(format!(".fontFamily({})", literal(&s.font_family, false)));
+            if s.italic() {
+                mods.push(".fontStyle(FontStyle.Italic)".into());
+            }
+            if let Some(c) = first_fill(n) {
+                mods.push(format!(".fontColor({})", ark_color(c)));
+            }
+            match s.line_height {
+                LineHeight::Pixels(v) => mods.push(format!(".lineHeight({})", num(v))),
+                LineHeight::Percent(p) => mods.push(format!(".lineHeight('{}%')", num(p))),
+                LineHeight::Auto => {}
+            }
+            match s.letter_spacing {
+                LetterSpacing::Pixels(v) if v != 0.0 => mods.push(format!(".letterSpacing({})", num(v))),
+                LetterSpacing::Percent(p) if p != 0.0 => mods.push(format!(".letterSpacing('{}%')", num(p))),
+                _ => {}
+            }
+            match t.align_h {
+                TextAlignH::Left => {}
+                TextAlignH::Center => mods.push(".textAlign(TextAlign.Center)".into()),
+                TextAlignH::Right => mods.push(".textAlign(TextAlign.End)".into()),
+                TextAlignH::Justified => mods.push(".textAlign(TextAlign.JUSTIFY)".into()),
+            }
+            // Aligning needs a box to align in: the text layer's own width.
+            if !matches!(t.align_h, TextAlignH::Left) {
+                mods.push(format!(".width({})", num(n.width)));
+            }
+            match s.case {
+                TextCase::Upper => mods.push(".textCase(TextCase.UpperCase)".into()),
+                TextCase::Lower => mods.push(".textCase(TextCase.LowerCase)".into()),
+                _ => {}
+            }
+            match s.decoration {
+                TextDecoration::Underline => mods.push(".decoration({ type: TextDecorationType.Underline })".into()),
+                TextDecoration::Strikethrough => mods.push(".decoration({ type: TextDecorationType.LineThrough })".into()),
+                TextDecoration::None => {}
+            }
+        }
+        NodeKind::Ellipse { .. } => {
+            out.push_str(&format!("{pad}Ellipse({{ width: {}, height: {} }})\n", num(n.width), num(n.height)));
+            if let Some(c) = first_fill(n) {
+                mods.push(format!(".fill({})", ark_color(c)));
+            }
+            if let Some(c) = stroke_color(n) {
+                mods.push(format!(".stroke({})", ark_color(c)));
+                mods.push(format!(".strokeWidth({})", num(n.stroke.weight)));
+            }
+        }
+        NodeKind::Rectangle => {
+            out.push_str(&format!("{pad}Column()\n"));
+            if let Some(c) = first_fill(n) {
+                mods.push(format!(".backgroundColor({})", ark_color(c)));
+            }
+            ark_radius(n, &mut mods);
+            mods.push(format!(".width({})", num(n.width)));
+            mods.push(format!(".height({})", num(n.height)));
+        }
+        k if k.is_frame_like() || matches!(k, NodeKind::Group) => {
+            let open = match n.layout.as_ref().map(|l| (l.mode, l)) {
+                Some((LayoutMode::Vertical, l)) => format!("Column({{ space: {} }})", num(l.gap)),
+                Some((_, l)) => format!("Row({{ space: {} }})", num(l.gap)),
+                None => "Stack({ alignContent: Alignment.TopStart })".to_string(),
+            };
+            out.push_str(&format!("{pad}{open} {{\n"));
+            match ctx.param(n, "slot") {
+                // A slot shows the instance's content, or else the main's (its default builder).
+                Some(p) => out.push_str(&format!("{pad}    this.{}()\n", p.ident)),
+                None => {
+                    for c in ctx.kids(n) {
+                        // Free children sit at their position inside a Stack, and so does a child
+                        // that ignores its auto layout parent.
+                        let pos: Vec<String> = match doc.node(c).filter(|cn| n.layout.is_none() || cn.child_layout.absolute) {
+                            Some(cn) => {
+                                let [_, _, _, _, x, y] = cn.transform.as_coeffs();
+                                vec![format!(".position({{ x: {}, y: {} }})", num(x), num(y))]
+                            }
+                            None => Vec::new(),
+                        };
+                        arkui(ctx, c, depth + 1, out, &pos);
+                    }
+                }
+            }
+            out.push_str(&format!("{pad}}}\n"));
+            if let Some(l) = &n.layout {
+                let [t, r, b, lft] = l.padding;
+                if [t, r, b, lft].iter().any(|v| *v > 0.0) {
+                    mods.push(format!(".padding({{ top: {}, right: {}, bottom: {}, left: {} }})", num(t), num(r), num(b), num(lft)));
+                }
+                let justify = match l.main_align {
+                    MainAlign::Min => None,
+                    MainAlign::Center => Some("FlexAlign.Center"),
+                    MainAlign::Max => Some("FlexAlign.End"),
+                    MainAlign::SpaceBetween => Some("FlexAlign.SpaceBetween"),
+                    MainAlign::SpaceAround => Some("FlexAlign.SpaceAround"),
+                    MainAlign::SpaceEvenly => Some("FlexAlign.SpaceEvenly"),
+                };
+                if let Some(j) = justify {
+                    mods.push(format!(".justifyContent({j})"));
+                }
+                let cross = match l.cross_align {
+                    CrossAlign::Min => None,
+                    CrossAlign::Center => Some("Center"),
+                    CrossAlign::Max => Some(if l.mode == LayoutMode::Vertical { "End" } else { "Bottom" }),
+                    CrossAlign::Baseline => None,
+                };
+                if let Some(c) = cross {
+                    let ty = if l.mode == LayoutMode::Vertical { "HorizontalAlign" } else { "VerticalAlign" };
+                    mods.push(format!(".alignItems({ty}.{c})"));
+                }
+            }
+            mods.push(format!(".width({})", num(n.width)));
+            mods.push(format!(".height({})", num(n.height)));
+            if let Some(c) = first_fill(n) {
+                mods.push(format!(".backgroundColor({})", ark_color(c)));
+            }
+            if radius(n) > 0.0 {
+                mods.push(".clip(true)".into());
+            }
+            ark_radius(n, &mut mods);
+        }
+        _ => {
+            out.push_str(&format!("{pad}// {}: export as an image asset\n{pad}Image($r('app.media.asset'))\n", n.kind.label()));
+            mods.push(format!(".width({})", num(n.width)));
+            mods.push(format!(".height({})", num(n.height)));
+        }
+    }
+    // Ellipses take their stroke as a shape attribute (above).
+    if !matches!(n.kind, NodeKind::Ellipse { .. })
+        && let Some(c) = stroke_color(n)
+    {
+        mods.push(format!(".border({{ width: {}, color: {} }})", num(n.stroke.weight), ark_color(c)));
+    }
+    if let Some(s) = drop_shadow(n) {
+        mods.push(format!(
+            ".shadow({{ radius: {}, color: {}, offsetX: {}, offsetY: {} }})",
+            num(s.radius / 2.0),
+            ark_color(s.color),
+            num(s.offset.0),
+            num(s.offset.1)
+        ));
+    }
+    if n.opacity < 1.0 {
+        mods.push(format!(".opacity({})", num(f64::from(n.opacity))));
+    }
+    let rot = figcraft_geom::rotation_degrees(n.transform);
+    if rot.abs() > 0.01 && rot.is_finite() {
+        mods.push(format!(".rotate({{ angle: {} }})", num(-rot)));
+    }
+    mods.extend(extra.iter().cloned());
+    for m in mods {
+        out.push_str(&format!("{pad}    {m}\n"));
+    }
+}
diff --git a/crates/engine/src/dev/codegen/compose.rs b/crates/engine/src/dev/codegen/compose.rs
new file mode 100644
index 00000000..5915ca9b
--- /dev/null
+++ b/crates/engine/src/dev/codegen/compose.rs
@@ -0,0 +1,131 @@
+use super::swift::one_line;
+use super::*;
+
+// ------------------------------------------------------------------ Jetpack Compose
+
+/// `Color(0xAARRGGBB)`, as Compose and Flutter both write a colour.
+pub(crate) fn kotlin_color(c: Color) -> String {
+    let [r, g, b, a] = c.to_rgba8();
+    format!("Color(0x{a:02X}{r:02X}{g:02X}{b:02X})")
+}
+
+/// The Modifier chain for a layer (size, shadow, background, border, alpha, padding).
+fn modifier(n: &Node, shape: &str, padding: bool) -> String {
+    let mut m = format!("Modifier.size({}.dp, {}.dp)", num(n.width), num(n.height));
+    if let Some(s) = drop_shadow(n) {
+        m.push_str(&format!(".shadow({}.dp, {shape})", num(s.radius / 2.0)));
+    }
+    if let Some(c) = first_fill(n) {
+        m.push_str(&format!(".background({}, {shape})", kotlin_color(c)));
+    }
+    if let Some(c) = stroke_color(n) {
+        m.push_str(&format!(".border({}.dp, {}, {shape})", num(n.stroke.weight), kotlin_color(c)));
+    }
+    if n.opacity < 1.0 {
+        m.push_str(&format!(".alpha({}f)", num(f64::from(n.opacity))));
+    }
+    if padding && let Some(l) = &n.layout {
+        let [t, r, b, lft] = l.padding;
+        if [t, r, b, lft].iter().any(|v| *v > 0.0) {
+            m.push_str(&format!(".padding(start = {}.dp, top = {}.dp, end = {}.dp, bottom = {}.dp)", num(lft), num(t), num(r), num(b)));
+        }
+    }
+    m
+}
+
+/// Jetpack Compose for a layer and its subtree at `depth`. A layer a boolean parameter shows sits
+/// in an `if`.
+pub(crate) fn compose(ctx: &Ctx, id: NodeId, depth: usize, out: &mut String) {
+    let Some(n) = ctx.doc.node(id) else { return };
+    if id != ctx.root
+        && let Some(p) = ctx.param(n, "visible")
+    {
+        let pad = indent(depth);
+        out.push_str(&format!("{pad}if ({}) {{\n", p.ident));
+        compose_layer(ctx, n, depth + 1, out);
+        out.push_str(&format!("{pad}}}\n"));
+        return;
+    }
+    compose_layer(ctx, n, depth, out);
+}
+
+fn compose_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String) {
+    let doc = ctx.doc;
+    let pad = indent(depth);
+    if ctx.too_deep(depth) {
+        out.push_str(&format!("{pad}// {} …\n", one_line(&n.name)));
+        return;
+    }
+    // Nested instances are calls; an instance swap parameter is a composable.
+    let call = match ctx.param(n, "mainComponent").filter(|_| n.id != ctx.root) {
+        Some(p) => Some(format!("{pad}{}()\n", p.ident)),
+        None => ctx.call(n, CodeLang::Compose, depth).map(|(code, _)| code),
+    };
+    if let Some(call) = call {
+        out.push_str(&call);
+        return;
+    }
+    let shape = if radius(n) > 0.0 { format!("RoundedCornerShape({}.dp)", num(radius(n))) } else { "RectangleShape".to_string() };
+    match &n.kind {
+        NodeKind::Text(t) => {
+            let color = first_fill(n).map(kotlin_color).unwrap_or_else(|| "Color.Unspecified".into());
+            let text = ctx.param(n, "characters").map_or_else(|| literal(&t.characters, true), |p| p.ident.clone());
+            out.push_str(&format!(
+                "{pad}Text(\n{pad}    text = {text},\n{pad}    fontSize = {}.sp,\n{pad}    fontWeight = FontWeight.W{},\n{pad}    color = {color},\n{pad})\n",
+                num(t.style.font_size),
+                (t.style.weight().clamp(100, 900) / 100) * 100
+            ));
+        }
+        NodeKind::Ellipse { .. } => out.push_str(&format!("{pad}Box(modifier = {})\n", modifier(n, "CircleShape", false))),
+        NodeKind::Rectangle => out.push_str(&format!("{pad}Box(modifier = {})\n", modifier(n, &shape, false))),
+        k if k.is_frame_like() || matches!(k, NodeKind::Group) => {
+            let children = ctx.kids(n);
+            let open = match n.layout.as_ref().map(|l| (l.mode, l)) {
+                Some((LayoutMode::Vertical, l)) => format!(
+                    "Column(\n{pad}    modifier = {},\n{pad}    verticalArrangement = Arrangement.spacedBy({}.dp),\n{pad}) {{",
+                    modifier(n, &shape, true),
+                    num(l.gap)
+                ),
+                Some((_, l)) => format!(
+                    "Row(\n{pad}    modifier = {},\n{pad}    horizontalArrangement = Arrangement.spacedBy({}.dp),\n{pad}    verticalAlignment = Alignment.CenterVertically,\n{pad}) {{",
+                    modifier(n, &shape, true),
+                    num(l.gap)
+                ),
+                None => format!("Box(modifier = {}) {{", modifier(n, &shape, false)),
+            };
+            out.push_str(&format!("{pad}{open}\n"));
+            // A slot shows the instance's content, or else the main's.
+            let slot = ctx.param(n, "slot");
+            let base = match slot {
+                Some(p) => {
+                    out.push_str(&format!("{pad}    if ({0} != null) {{\n{pad}        {0}()\n{pad}    }} else {{\n", p.ident));
+                    depth + 1
+                }
+                None => depth,
+            };
+            for c in &children {
+                if n.layout.is_none()
+                    && let Some(cn) = doc.node(*c)
+                {
+                    let [_, _, _, _, x, y] = cn.transform.as_coeffs();
+                    out.push_str(&format!("{}Box(modifier = Modifier.offset({}.dp, {}.dp)) {{\n", indent(base + 1), num(x), num(y)));
+                    compose(ctx, *c, base + 2, out);
+                    out.push_str(&format!("{}}}\n", indent(base + 1)));
+                } else {
+                    compose(ctx, *c, base + 1, out);
+                }
+            }
+            if slot.is_some() {
+                out.push_str(&format!("{pad}    }}\n"));
+            }
+            out.push_str(&format!("{pad}}}\n"));
+        }
+        _ => out.push_str(&format!(
+            "{pad}// {}: export as an image asset\n{pad}Image(painter = painterResource(R.drawable.asset), contentDescription = {}, modifier = Modifier.size({}.dp, {}.dp))\n",
+            n.kind.label(),
+            literal(&n.name, true),
+            num(n.width),
+            num(n.height)
+        )),
+    }
+}
diff --git a/crates/engine/src/dev/codegen/css.rs b/crates/engine/src/dev/codegen/css.rs
new file mode 100644
index 00000000..c7982652
--- /dev/null
+++ b/crates/engine/src/dev/codegen/css.rs
@@ -0,0 +1,288 @@
+use super::*;
+
+// ------------------------------------------------------------------ CSS
+
+/// The CSS custom properties generated code uses: name → fallback value, in first-use order.
+#[derive(Default)]
+pub(crate) struct Tokens {
+    vars: Vec<(String, String)>,
+    /// Name variables as Tailwind theme variables (`--color-accent`), not by their CSS name.
+    pub tailwind: bool,
+    /// The file's theme names (computed on first use).
+    theme: Option<crate::tailwind::Theme>,
+}
+
+impl Tokens {
+    /// `var(--name, value)`, remembering the variable.
+    fn var(&mut self, doc: &Document, variable: &Variable, value: String) -> String {
+        let name =
+            if self.tailwind { self.theme.get_or_insert_with(|| crate::tailwind::Theme::new(doc)).name(variable) } else { css_var_of(variable) };
+        let out = format!("var({name}, {value})");
+        if !self.vars.iter().any(|(n, _)| *n == name) {
+            self.vars.push((name, value));
+        }
+        out
+    }
+
+    /// A `:root` rule declaring the variables (empty without any).
+    pub fn root_rule(&self) -> String {
+        if self.vars.is_empty() {
+            return String::new();
+        }
+        let decls: String = self.vars.iter().map(|(n, v)| format!("  {n}: {v};\n")).collect();
+        format!(":root {{\n{decls}}}\n")
+    }
+}
+
+/// A variable's CSS custom property name: "Colors/Brand 500" → `--colors-brand-500`.
+pub fn css_var_name(variable: &str) -> String {
+    let mut out = String::from("--");
+    for c in variable.chars().flat_map(char::to_lowercase).take(80) {
+        if c.is_alphanumeric() || c == '_' {
+            out.push(c);
+        } else if !out.ends_with('-') {
+            out.push('-');
+        }
+    }
+    let trimmed = out.trim_end_matches('-');
+    if trimmed.len() <= 2 { "--variable".into() } else { trimmed.to_string() }
+}
+
+/// A variable's CSS custom property: its Web code syntax (`var(--x)` or `--x`) when it has one,
+/// else made from its name.
+pub fn css_var_of(v: &Variable) -> String {
+    let Some(web) = v.code_syntax.get("WEB").map(|w| w.trim()) else { return css_var_name(&v.name) };
+    let inner = web.strip_prefix("var(").map_or(web, |r| r.split([',', ')']).next().unwrap_or("").trim());
+    let valid = inner.len() > 2 && inner.starts_with("--") && inner.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_');
+    if valid { inner.chars().take(80).collect() } else { css_var_name(inner) }
+}
+
+/// `value`, or a reference to the variable bound to the first of `fields` that has one.
+pub(super) fn tok(doc: &Document, n: &Node, fields: &[&str], value: String, t: &mut Tokens) -> String {
+    match fields.iter().find_map(|f| crate::devinspect::bound_variable(doc, n, f)) {
+        Some(v) => t.var(doc, v, value),
+        None => value,
+    }
+}
+
+pub(super) fn css(doc: &Document, id: NodeId) -> String {
+    let Some(n) = doc.node(id) else { return String::new() };
+    let mut t = Tokens::default();
+    let decls = css_decls(doc, n, &mut t, (false, false));
+    format!("/* {} */\n{decls}", n.name.replace("*/", "* /"))
+}
+
+/// The CSS declarations for `n`'s own look and size, one per line; `hug` leaves out the width
+/// and/or height (they follow the content). Bound variables become `var(--name, value)`.
+pub(crate) fn css_decls(doc: &Document, n: &Node, t: &mut Tokens, hug: (bool, bool)) -> String {
+    let px = |v: f64| format!("{}px", num(v));
+    let mut out = String::new();
+    let mut put = |key: &str, value: String| out.push_str(&format!("{key}: {value};\n"));
+    if !hug.0 {
+        put("width", tok(doc, n, &["width"], px(n.width), t));
+    }
+    if !hug.1 {
+        put("height", tok(doc, n, &["height"], px(n.height), t));
+    }
+    if let Some(l) = &n.layout {
+        put("display", "flex".into());
+        put("flex-direction", if l.mode == LayoutMode::Vertical { "column" } else { "row" }.into());
+        if l.wrap {
+            put("flex-wrap", "wrap".into());
+        }
+        put("gap", tok(doc, n, &["gap"], px(l.gap), t));
+        let [pt, pr, pb, pl] = l.padding;
+        let sides = [
+            tok(doc, n, &["paddingTop", "paddingVertical", "padding"], px(pt), t),
+            tok(doc, n, &["paddingRight", "paddingHorizontal", "padding"], px(pr), t),
+            tok(doc, n, &["paddingBottom", "paddingVertical", "padding"], px(pb), t),
+            tok(doc, n, &["paddingLeft", "paddingHorizontal", "padding"], px(pl), t),
+        ];
+        put("padding", sides.join(" "));
+        let justify = match l.main_align {
+            MainAlign::Min => "flex-start",
+            MainAlign::Center => "center",
+            MainAlign::Max => "flex-end",
+            MainAlign::SpaceBetween => "space-between",
+            MainAlign::SpaceAround => "space-around",
+            MainAlign::SpaceEvenly => "space-evenly",
+        };
+        put("justify-content", justify.into());
+        let align = match l.cross_align {
+            CrossAlign::Min => "flex-start",
+            CrossAlign::Center => "center",
+            CrossAlign::Max => "flex-end",
+            CrossAlign::Baseline => "baseline",
+        };
+        put("align-items", align.into());
+        if l.wrap {
+            // The lines: spread, or packed where the items align (baseline: at the start).
+            let spread = l.content_align == ContentAlign::SpaceBetween;
+            put(
+                "align-content",
+                if spread {
+                    "space-between"
+                } else if align == "baseline" {
+                    "flex-start"
+                } else {
+                    align
+                }
+                .into(),
+            );
+        }
+    }
+    if matches!(n.kind, NodeKind::Ellipse { .. }) {
+        put("border-radius", "50%".into());
+    } else if let Some(r) = n.corners.uniform().filter(|r| *r > 0.0) {
+        put("border-radius", tok(doc, n, &["cornerRadius"], px(r), t));
+    } else if n.corners.radii.iter().any(|r| *r > 0.0) {
+        let fields = ["topLeftRadius", "topRightRadius", "bottomRightRadius", "bottomLeftRadius"];
+        let corners: Vec<String> = n.corners.radii.iter().zip(fields).map(|(r, f)| tok(doc, n, &[f, "cornerRadius"], px(*r), t)).collect();
+        put("border-radius", corners.join(" "));
+    }
+    if n.opacity < 1.0 {
+        put("opacity", tok(doc, n, &["opacity"], num(f64::from(n.opacity)), t));
+    }
+    if !matches!(n.blend, figcraft_color::BlendMode::Normal | figcraft_color::BlendMode::PassThrough) {
+        put("mix-blend-mode", n.blend.css().into());
+    }
+    // Rotation turns counter-clockwise about the top-left corner (the position given); CSS
+    // rotate turns clockwise.
+    let rot = figcraft_geom::rotation_degrees(n.transform);
+    if rot.abs() > 0.01 && rot.is_finite() {
+        put("transform", format!("rotate({}deg)", num(-rot)));
+        put("transform-origin", "top left".into());
+    }
+    for (i, p) in n.fills.iter().enumerate().filter(|(_, p)| p.visible) {
+        match &p.kind {
+            PaintKind::Solid { color } => {
+                let key = if matches!(n.kind, NodeKind::Text(_)) { "color" } else { "background" };
+                let c = color.with_alpha(color.a * p.opacity).to_css();
+                // A variable binds the first paint's colour.
+                put(key, if i == 0 { tok(doc, n, &["fill"], c, t) } else { c });
+            }
+            PaintKind::Gradient(g) => put("background", css_gradient(g, n.width, n.height)),
+            PaintKind::Image(_) => put("background", "url(image.png) center / cover".into()),
+            PaintKind::Pattern(_) => put("background", "url(pattern.png) repeat".into()),
+        }
+    }
+    for (key, value) in css_borders(doc, n, t) {
+        put(&key, value);
+    }
+    let shadows: Vec<String> = n
+        .effects
+        .iter()
+        .filter(|e| e.visible)
+        .filter_map(|e| match &e.kind {
+            EffectKind::DropShadow(s) => {
+                Some(format!("{}px {}px {}px {}px {}", num(s.offset.0), num(s.offset.1), num(s.radius), num(s.spread), s.color.to_css()))
+            }
+            EffectKind::InnerShadow(s) => {
+                Some(format!("inset {}px {}px {}px {}px {}", num(s.offset.0), num(s.offset.1), num(s.radius), num(s.spread), s.color.to_css()))
+            }
+            _ => None,
+        })
+        .collect();
+    if !shadows.is_empty() {
+        put("box-shadow", shadows.join(", "));
+    }
+    for e in n.effects.iter().filter(|e| e.visible) {
+        match e.kind {
+            // CSS blurs are uniform: a progressive blur has no CSS equivalent and is left out.
+            EffectKind::LayerBlur(ref b) if !b.is_progressive() => put("filter", format!("blur({}px)", num(b.radius / 2.0))),
+            EffectKind::BackgroundBlur(ref b) if !b.is_progressive() => put("backdrop-filter", format!("blur({}px)", num(b.radius / 2.0))),
+            // CSS has no refraction: the frost is the nearest.
+            EffectKind::Glass(ref g) => put("backdrop-filter", format!("blur({}px)", num(g.sanitized().frost / 2.0))),
+            _ => {}
+        }
+    }
+    if let NodeKind::Text(tx) = &n.kind {
+        let s = &tx.style;
+        put("font-family", tok(doc, n, &["fontFamily"], format!("\"{}\"", s.font_family.replace('"', "'")), t));
+        put("font-size", tok(doc, n, &["fontSize"], px(s.font_size), t));
+        put("font-weight", s.weight().to_string());
+        if s.italic() {
+            put("font-style", "italic".into());
+        }
+        match s.line_height {
+            LineHeight::Pixels(v) => put("line-height", tok(doc, n, &["lineHeight"], px(v), t)),
+            LineHeight::Percent(p) => put("line-height", format!("{}%", num(p))),
+            LineHeight::Auto => {}
+        }
+        match s.letter_spacing {
+            LetterSpacing::Pixels(v) if v != 0.0 => put("letter-spacing", tok(doc, n, &["letterSpacing"], px(v), t)),
+            LetterSpacing::Percent(p) if p != 0.0 => put("letter-spacing", format!("{}em", num(p / 100.0))),
+            _ => {}
+        }
+        match tx.align_h {
+            TextAlignH::Left => {}
+            TextAlignH::Center => put("text-align", "center".into()),
+            TextAlignH::Right => put("text-align", "right".into()),
+            TextAlignH::Justified => put("text-align", "justify".into()),
+        }
+        match s.case {
+            TextCase::Original => {}
+            TextCase::Upper => put("text-transform", "uppercase".into()),
+            TextCase::Lower => put("text-transform", "lowercase".into()),
+            TextCase::Title => put("text-transform", "capitalize".into()),
+            TextCase::SmallCaps => put("font-variant", "small-caps".into()),
+        }
+        match s.decoration {
+            TextDecoration::None => {}
+            TextDecoration::Underline => put("text-decoration", "underline".into()),
+            TextDecoration::Strikethrough => put("text-decoration", "line-through".into()),
+        }
+        if s.decoration != TextDecoration::None {
+            let l = s.look();
+            let len = |m: LineHeight| match m {
+                LineHeight::Auto => None,
+                LineHeight::Pixels(v) => Some(px(v)),
+                LineHeight::Percent(p) => Some(format!("{}%", num(p))),
+            };
+            match l.style {
+                figcraft_doc::DecorationStyle::Solid => {}
+                figcraft_doc::DecorationStyle::Dotted => put("text-decoration-style", "dotted".into()),
+                figcraft_doc::DecorationStyle::Wavy => put("text-decoration-style", "wavy".into()),
+            }
+            if let Some(v) = len(l.thickness) {
+                put("text-decoration-thickness", v);
+            }
+            if let Some(c) = l.color {
+                put("text-decoration-color", c.to_css());
+            }
+            if s.decoration == TextDecoration::Underline {
+                if let Some(v) = len(l.offset) {
+                    put("text-underline-offset", v);
+                }
+                // Browsers skip ink by default; the canvas only when asked.
+                if !l.skip_ink {
+                    put("text-decoration-skip-ink", "none".into());
+                }
+            }
+        }
+        if tx.leading_trim == figcraft_doc::LeadingTrim::CapHeight {
+            put("text-box", "trim-both cap alphabetic".into());
+        }
+    }
+    out
+}
+
+/// A gradient fill on a `w`×`h` box as a CSS background: linear along its handles' direction
+/// (CSS angles: 0deg up, 90deg right), radial with its handles' radii, angular as a conic
+/// gradient from its start direction.
+fn css_gradient(g: &figcraft_color::Gradient, w: f64, h: f64) -> String {
+    let stops = g.sorted_stops().iter().map(|s| format!("{} {}%", s.color.to_css(), (s.position * 100.0).round())).collect::<Vec<_>>().join(", ");
+    let (dx, dy) = ((g.to.0 - g.from.0) * w, (g.to.1 - g.from.1) * h);
+    let angle = if dx == 0.0 && dy == 0.0 { 180.0 } else { dx.atan2(-dy).to_degrees().rem_euclid(360.0) };
+    let pct = |v: f64| format!("{}%", num(v * 100.0));
+    let at = format!("at {} {}", pct(g.from.0), pct(g.from.1));
+    match g.kind {
+        figcraft_color::GradientKind::Linear => format!("linear-gradient({}deg, {stops})", num(angle)),
+        figcraft_color::GradientKind::Radial | figcraft_color::GradientKind::Diamond => {
+            let (rx, ry) = (((g.width.0 - g.from.0) * w).hypot((g.width.1 - g.from.1) * h), dx.hypot(dy));
+            let rel = |r: f64, side: f64| if side > 0.0 { pct(r / side) } else { "50%".into() };
+            format!("radial-gradient({} {} {at}, {stops})", rel(rx, w), rel(ry, h))
+        }
+        figcraft_color::GradientKind::Angular => format!("conic-gradient(from {}deg {at}, {stops})", num(angle)),
+    }
+}
diff --git a/crates/engine/src/dev/codegen/html.rs b/crates/engine/src/dev/codegen/html.rs
new file mode 100644
index 00000000..3ae746f1
--- /dev/null
+++ b/crates/engine/src/dev/codegen/html.rs
@@ -0,0 +1,390 @@
+use super::css::{Tokens, css_decls};
+use super::*;
+
+// ------------------------------------------------------------------ HTML and React markup
+
+/// A word for the node's kind, naming layers whose name transliterates to nothing ("###" →
+/// `.text`, `.frame`), instead of the anonymous `layer-`.
+fn kind_word(n: &Node) -> &str {
+    match &n.kind {
+        NodeKind::Page { .. } => "page",
+        NodeKind::Frame => "frame",
+        NodeKind::Group => "group",
+        NodeKind::Section { .. } => "section",
+        NodeKind::Rectangle => "rectangle",
+        NodeKind::Ellipse { .. } => "ellipse",
+        NodeKind::Polygon { .. } => "polygon",
+        NodeKind::Star { .. } => "star",
+        NodeKind::Line => "line",
+        NodeKind::Vector { .. } => "vector",
+        NodeKind::Text(_) => "text",
+        NodeKind::BooleanOp { .. } => "boolean",
+        NodeKind::Component { .. } | NodeKind::ComponentSet { .. } => "component",
+        NodeKind::Instance { .. } => "instance",
+        NodeKind::Slice => "slice",
+    }
+}
+
+/// A CSS class name from a layer name ("Card / Title" → "card-title"), unique in `used`. The name
+/// is transliterated to ASCII first, so non-Latin names stay readable: 로그인 화면 →
+/// `rogeuin-hwamyeon`, кнопка → `knopka`, über → `uber` (per-codepoint transliteration, the slug
+/// libraries' way); a name left with nothing (symbols only) takes `kind`, and one starting with a
+/// digit keeps the `layer-` prefix.
+pub(crate) fn class_name(name: &str, kind: &str, used: &mut Vec<String>) -> String {
+    let mut base = String::new();
+    for c in deunicode::deunicode(name).chars().flat_map(char::to_lowercase) {
+        if c.is_ascii_alphanumeric() {
+            base.push(c);
+        } else if !base.ends_with('-') && !base.is_empty() {
+            base.push('-');
+        }
+    }
+    // The 40-character cut lands on a word boundary when there is one past the first word.
+    let base = if base.chars().count() > 40 {
+        let cut: String = base.chars().take(40).collect();
+        match cut.rfind('-') {
+            Some(i) if i > 0 => cut[..i].to_string(),
+            _ => cut,
+        }
+    } else {
+        base
+    };
+    let base = base.trim_end_matches('-');
+    let base = if base.is_empty() {
+        kind.to_string()
+    } else if base.starts_with(|c: char| c.is_ascii_digit()) {
+        format!("layer-{base}")
+    } else {
+        base.to_string()
+    };
+    let name = (1..).map(|k| if k == 1 { base.clone() } else { format!("{base}-{k}") }).find(|n| !used.contains(n)).unwrap_or(base);
+    used.push(name.clone());
+    name
+}
+
+fn html_escape(s: &str) -> String {
+    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('\n', "<br>")
+}
+
+/// Text as JSX children: HTML escapes, braces as expressions, line breaks as `<br />`.
+fn jsx_text(s: &str) -> String {
+    let mut out = String::new();
+    for c in s.chars().take(10_000) {
+        match c {
+            '&' => out.push_str("&amp;"),
+            '<' => out.push_str("&lt;"),
+            '>' => out.push_str("&gt;"),
+            '{' => out.push_str("{\"{\"}"),
+            '}' => out.push_str("{\"}\"}"),
+            '\n' => out.push_str("<br />"),
+            '\r' => {}
+            c => out.push(c),
+        }
+    }
+    out
+}
+
+/// The whole tree under `id` as nested HTML with a stylesheet: auto layout frames become
+/// flexboxes, other children are placed absolutely in their parent, text becomes paragraphs.
+pub(super) fn html(doc: &Document, id: NodeId) -> String {
+    let ctx = Ctx::new(doc, id);
+    let mut out = Markup::new(&ctx, CodeLang::Html);
+    out.node(id, None, 0, "");
+    format!("{}\n<style>\n{}{}</style>\n", out.markup, out.tokens.root_rule(), out.styles)
+}
+
+/// Markup being built for a layer tree: HTML (`class`), React JSX (`className`), Vue
+/// (`{{ }}` interpolation, `v-if`, `:attr` bindings) or Leptos `view!` markup (text as Rust
+/// string literals); the last three with component parameters and instances as calls. With its
+/// stylesheet.
+pub(crate) struct Markup<'c, 'a> {
+    ctx: &'c Ctx<'a>,
+    /// Html, React, Vue or Leptos.
+    lang: CodeLang,
+    used: Vec<String>,
+    pub markup: String,
+    pub styles: String,
+    pub tokens: Tokens,
+    /// The root's class (default: from its name) and extra JSX attributes.
+    pub root_class: Option<String>,
+    pub root_attrs: String,
+    /// A Vue `v-if` guard for the element about to be written: Vue templates can't wrap an
+    /// element in an expression, so a boolean parameter's layer carries the condition itself.
+    v_if: Option<String>,
+    /// A prefix for every generated class name (slot content joins the caller's stylesheet, where
+    /// two slots' layer names may repeat).
+    pub class_prefix: Option<String>,
+    /// Each layer's path in the tree (names with sibling counts), class and declarations, so
+    /// variants can be compared layer by layer.
+    pub rules: Vec<(String, String, String)>,
+    /// Instances as their own (overridden) layers instead of component calls, except those
+    /// connected to code (page code).
+    pub inline: bool,
+    /// Auto layout frames and text as fluid boxes (`width: 100%` up to their width) for pages.
+    pub fluid: bool,
+    /// With `fluid`, other layers at least this share of the root's width are fluid too (a
+    /// divider, a banner image); smaller ones (icons) keep their size. Default: none.
+    pub fluid_leaves: f64,
+}
+
+impl<'c, 'a> Markup<'c, 'a> {
+    pub fn new(ctx: &'c Ctx<'a>, lang: CodeLang) -> Self {
+        Markup {
+            ctx,
+            lang,
+            used: Vec::new(),
+            markup: String::new(),
+            styles: String::new(),
+            tokens: Tokens::default(),
+            root_class: None,
+            root_attrs: String::new(),
+            v_if: None,
+            class_prefix: None,
+            rules: Vec::new(),
+            inline: false,
+            fluid: false,
+            fluid_leaves: f64::INFINITY,
+        }
+    }
+
+    /// JSX and Vue templates indent by two spaces, HTML and Leptos by four.
+    fn pad(&self, depth: usize) -> String {
+        if matches!(self.lang, CodeLang::React | CodeLang::Vue) { "  ".repeat(depth) } else { indent(depth) }
+    }
+
+    /// Component code (React or Leptos): parameters and instances as calls.
+    fn code(&self) -> bool {
+        self.lang != CodeLang::Html
+    }
+
+    /// A parameter's name in the generated code.
+    fn ident(&self, p: &Param) -> String {
+        if self.lang == CodeLang::Leptos { crate::component_codegen::rust_ident(&p.ident) } else { p.ident.clone() }
+    }
+
+    /// A layer, shown only while its boolean parameter is on (component code).
+    pub fn node(&mut self, id: NodeId, parent: Option<&Node>, depth: usize, path: &str) {
+        let Some(n) = self.ctx.doc.node(id) else { return };
+        if self.code()
+            && id != self.ctx.root
+            && let Some(p) = self.ctx.param(n, "visible")
+        {
+            // A Vue template holds no arbitrary expressions, so the guard rides on the element.
+            if self.lang == CodeLang::Vue {
+                self.v_if = Some(self.ident(p));
+                self.element(n, parent, depth, path);
+                self.v_if = None;
+                return;
+            }
+            let (pad, p) = (self.pad(depth), self.ident(p));
+            let (open, close) =
+                if self.lang == CodeLang::Leptos { (format!("{{{p}.then(|| view! {{"), "})}") } else { (format!("{{{p} && ("), ")}") };
+            self.markup.push_str(&format!("{pad}{open}\n"));
+            self.element(n, parent, depth + 1, path);
+            self.markup.push_str(&format!("{pad}{close}\n"));
+            return;
+        }
+        self.element(n, parent, depth, path);
+    }
+
+    fn rule(&mut self, path: &str, class: &str, decls: String) {
+        self.styles.push_str(&format!(".{class} {{\n"));
+        for line in decls.lines() {
+            self.styles.push_str(&format!("  {line}\n"));
+        }
+        self.styles.push_str("}\n");
+        self.rules.push((path.to_string(), class.to_string(), decls));
+    }
+
+    fn element(&mut self, n: &Node, parent: Option<&Node>, depth: usize, path: &str) {
+        let doc = self.ctx.doc;
+        let root = n.id == self.ctx.root;
+        let class = match self.root_class.take().filter(|_| root) {
+            Some(c) => {
+                self.used.push(c.clone());
+                c
+            }
+            None => {
+                let class = class_name(&n.name, kind_word(n), &mut self.used);
+                match &self.class_prefix {
+                    Some(prefix) => format!("{prefix}{class}"),
+                    None => class,
+                }
+            }
+        };
+        let pad = self.pad(depth);
+        let attr = if self.lang == CodeLang::React { "className" } else { "class" };
+        // How it sits in its parent: in the flex flow, or placed at its position.
+        let mut decls = String::new();
+        let in_flow = parent.is_some_and(|p| p.layout.is_some()) && !n.child_layout.absolute;
+        if root {
+            decls.push_str("position: relative;\n");
+        } else if in_flow {
+            let vertical = parent.and_then(|p| p.layout.as_ref()).is_some_and(|l| l.mode == LayoutMode::Vertical);
+            let (main, cross) =
+                if vertical { (n.child_layout.sizing_v, n.child_layout.sizing_h) } else { (n.child_layout.sizing_h, n.child_layout.sizing_v) };
+            if main == Sizing::Fill {
+                decls.push_str("flex: 1 1 0;\n");
+            }
+            if cross == Sizing::Fill {
+                decls.push_str("align-self: stretch;\n");
+            }
+        } else {
+            let c = n.transform.as_coeffs();
+            decls.push_str(&format!("position: absolute;\nleft: {}px;\ntop: {}px;\n", num(c[4]), num(c[5])));
+            let rot = figcraft_geom::rotation_degrees(n.transform);
+            if rot.abs() > 0.01 {
+                decls.push_str(&format!("transform: rotate({}deg);\ntransform-origin: 0 0;\n", num(-rot)));
+            }
+        }
+        // Nested instances are calls (component code), in a wrapper that places them when needed.
+        // Page code inlines instances, except those connected to code (codeConnect.set): their
+        // snippet, e.g. a design-system `<Button>`.
+        let connected = self.inline && crate::code_connect::link(doc, n.id, CodeLang::React).is_some();
+        if self.code() && (!self.inline || connected) && !root && matches!(n.kind, NodeKind::Instance { .. }) {
+            let at = depth + usize::from(!decls.is_empty());
+            let run = if self.lang == CodeLang::Leptos { ".run()" } else { "" };
+            let (inner, css) = match self.ctx.param(n, "mainComponent") {
+                Some(p) if self.lang == CodeLang::Vue => (Some(format!("{}<component :is=\"{}\" />\n", self.pad(at), self.ident(p))), String::new()),
+                Some(p) => (Some(format!("{}{{{}{run}}}\n", self.pad(at), self.ident(p))), String::new()),
+                None => self.ctx.call(n, self.lang, at).map_or((None, String::new()), |(code, css)| (Some(code), css)),
+            };
+            self.styles.push_str(&css);
+            if let Some(inner) = inner {
+                // A Vue guard set by `node` rides on the call when there is no wrapper.
+                let guard = if self.lang == CodeLang::Vue { self.v_if.take() } else { None };
+                if decls.is_empty() {
+                    self.markup.push_str(&with_v_if(&inner, guard.as_deref()));
+                } else {
+                    let guard = guard.map(|g| format!(" v-if=\"{g}\"")).unwrap_or_default();
+                    self.markup.push_str(&format!("{pad}<div {attr}=\"{class}\"{guard}>\n{inner}{pad}</div>\n"));
+                    self.rule(path, &class, decls);
+                }
+                return;
+            }
+        }
+        let hugs = n.layout.is_some() || matches!(n.kind, NodeKind::Text(_));
+        let hug = (hugs && n.child_layout.sizing_h == Sizing::Hug, hugs && n.child_layout.sizing_v == Sizing::Hug);
+        let mut own = css_decls(doc, n, &mut self.tokens, hug);
+        let page = self.ctx.doc.node(self.ctx.root).map_or(f64::INFINITY, |r| r.width);
+        if self.fluid && (n.layout.is_some() || matches!(n.kind, NodeKind::Text(_)) || (!root && n.width >= page * self.fluid_leaves)) {
+            // Full width, or sized by the flex row (`flex: 1`): no cap needed.
+            own = fluid(&own, n.width >= page - 0.5 || decls.contains("flex: 1 1 0;"), n.layout.is_some());
+        }
+        if n.layout.is_none() && !n.children.is_empty() && !root && in_flow {
+            own.push_str("position: relative;\n");
+        }
+        decls.push_str(&own);
+        self.rule(path, &class, decls);
+        // The root's variant attributes, and a Vue `v-if` guard, ride on the open tag.
+        let mut attrs = if root { self.root_attrs.clone() } else { String::new() };
+        if self.lang == CodeLang::Vue
+            && let Some(guard) = self.v_if.take()
+        {
+            attrs.push_str(&format!(" v-if=\"{guard}\""));
+        }
+        let open = |tag: &str| format!("{pad}<{tag} {attr}=\"{class}\"{attrs}>");
+        match &n.kind {
+            NodeKind::Text(t) => {
+                let body = match (self.ctx.param(n, "characters").filter(|_| self.code()), self.lang) {
+                    (Some(p), CodeLang::Leptos) => format!("{{{}.clone()}}", self.ident(p)),
+                    (Some(p), CodeLang::Vue) => format!("{{{{ {} }}}}", self.ident(p)),
+                    (Some(p), _) => format!("{{{}}}", p.ident),
+                    (None, CodeLang::React) => jsx_text(&t.characters),
+                    // `view!` takes text as string literals and void elements self-closed.
+                    (None, CodeLang::Leptos) => {
+                        t.characters.chars().take(10_000).collect::<String>().lines().map(|l| format!("{l:?}")).collect::<Vec<_>>().join("<br/>")
+                    }
+                    // A Vue template reads `{{ }}` as interpolation, so braces are escaped.
+                    (None, CodeLang::Vue) => html_escape(&t.characters).replace('{', "&#123;").replace('}', "&#125;"),
+                    (None, _) => html_escape(&t.characters),
+                };
+                self.markup.push_str(&format!("{}{body}</p>\n", open("p")));
+            }
+            _ => {
+                let kids = self.ctx.kids(n);
+                let slot = self.ctx.param(n, "slot").filter(|_| self.code());
+                let vue = self.lang == CodeLang::Vue;
+                let leptos = self.lang == CodeLang::Leptos;
+                let open = open("div");
+                let slot_ident = slot.map(|p| match self.ctx.comp {
+                    Some(c) => crate::component_codegen::slot_name(c, p),
+                    None => class_name(&p.ident, "slot", &mut Vec::new()),
+                });
+                if let Some(p) = slot.filter(|_| kids.is_empty()) {
+                    let content = if leptos {
+                        format!("{{{}}}.as_ref().map(|c| c.run())", self.ident(p))
+                    } else if vue {
+                        // Vue's own slot element, named so an instance's content lands in the right one.
+                        match slot_ident.clone() {
+                            Some(name) => format!("<slot name=\"{name}\" />"),
+                            None => "<slot />".into(),
+                        }
+                    } else {
+                        format!("{{{}}}", p.ident)
+                    };
+                    self.markup.push_str(&format!("{open}{content}</div>\n"));
+                } else if kids.is_empty() || self.ctx.too_deep(depth) {
+                    self.markup.push_str(&format!("{open}</div>\n"));
+                } else {
+                    self.markup.push_str(&format!("{open}\n"));
+                    // A slot shows the instance's content, or else the main's.
+                    let (p1, p2) = (self.pad(depth + 1), self.pad(depth + 2));
+                    let inner = match slot {
+                        Some(_) if vue => {
+                            let name = slot_ident.clone().map(|n| format!(" name=\"{n}\"")).unwrap_or_default();
+                            self.markup.push_str(&format!("{p1}<slot{name}>\n"));
+                            depth + 2
+                        }
+                        Some(p) if leptos => {
+                            self.markup.push_str(&format!("{p1}{{match &{} {{ Some(c) => c.run(), None => view! {{\n", self.ident(p)));
+                            depth + 2
+                        }
+                        Some(p) => {
+                            self.markup.push_str(&format!("{p1}{{{} ?? (\n{p2}<>\n", p.ident));
+                            depth + 3
+                        }
+                        None => depth + 1,
+                    };
+                    let mut seen: Vec<&str> = Vec::new();
+                    // Bottom layer first: later elements paint on top, like the layer order.
+                    for k in kids {
+                        let Some(kn) = doc.node(k) else { continue };
+                        let count = seen.iter().filter(|s| **s == kn.name).count();
+                        seen.push(&kn.name);
+                        self.node(k, Some(n), inner, &format!("{path}/{}#{count}", kn.name));
+                    }
+                    match slot {
+                        Some(_) if vue => self.markup.push_str(&format!("{p1}</slot>\n")),
+                        Some(_) if leptos => self.markup.push_str(&format!("{p1}}}.into_any() }}}}\n")),
+                        Some(_) => self.markup.push_str(&format!("{p2}</>\n{p1})}}\n")),
+                        None => {}
+                    }
+                    self.markup.push_str(&format!("{pad}</div>\n"));
+                }
+            }
+        }
+    }
+}
+
+/// `decls` for a box that follows the page: a fixed width becomes `width: 100%` capped at that
+/// width (or just the full width for boxes as wide as the page), and a frame's fixed height a
+/// minimum, so content can wrap and grow.
+// ponytail: width-based heuristic; fixed-size leaves (icons, images, shapes) keep their pixels.
+fn fluid(decls: &str, full: bool, frame: bool) -> String {
+    let mut out = String::with_capacity(decls.len() + 32);
+    for line in decls.lines() {
+        if let Some(w) = line.strip_prefix("width: ") {
+            out.push_str("width: 100%;\n");
+            if !full {
+                out.push_str(&format!("max-width: {w}\n"));
+            }
+        } else if let Some(h) = line.strip_prefix("height: ").filter(|_| frame) {
+            out.push_str(&format!("min-height: {h}\n"));
+        } else {
+            out.push_str(line);
+            out.push('\n');
+        }
+    }
+    out
+}
diff --git a/crates/engine/src/dev/codegen/swift.rs b/crates/engine/src/dev/codegen/swift.rs
new file mode 100644
index 00000000..a9f8eaaa
--- /dev/null
+++ b/crates/engine/src/dev/codegen/swift.rs
@@ -0,0 +1,168 @@
+use super::*;
+
+// ------------------------------------------------------------------ SwiftUI
+
+fn swift_color(c: Color) -> String {
+    format!("Color(red: {}, green: {}, blue: {}, opacity: {})", num(f64::from(c.r)), num(f64::from(c.g)), num(f64::from(c.b)), num(f64::from(c.a)))
+}
+
+fn swift_weight(w: u16) -> &'static str {
+    match w {
+        0..=150 => ".thin",
+        151..=250 => ".ultraLight",
+        251..=350 => ".light",
+        351..=450 => ".regular",
+        451..=550 => ".medium",
+        551..=650 => ".semibold",
+        651..=750 => ".bold",
+        751..=850 => ".heavy",
+        _ => ".black",
+    }
+}
+
+/// SwiftUI for a layer and its subtree at `depth`; `extra` modifiers go last (a free child's
+/// offset). A layer a boolean parameter shows sits in an `if`.
+pub(crate) fn swift(ctx: &Ctx, id: NodeId, depth: usize, out: &mut String, extra: &[String]) {
+    let Some(n) = ctx.doc.node(id) else { return };
+    if id != ctx.root
+        && let Some(p) = ctx.param(n, "visible")
+    {
+        let pad = indent(depth);
+        out.push_str(&format!("{pad}if {} {{\n", p.ident));
+        swift_layer(ctx, n, depth + 1, out, extra);
+        out.push_str(&format!("{pad}}}\n"));
+        return;
+    }
+    swift_layer(ctx, n, depth, out, extra);
+}
+
+/// A layer name safe for a single-line `//` comment: line breaks become spaces.
+pub(super) fn one_line(name: &str) -> String {
+    name.replace(['\n', '\r', '\u{85}', '\u{2028}', '\u{2029}'], " ")
+}
+
+fn swift_layer(ctx: &Ctx, n: &Node, depth: usize, out: &mut String, extra: &[String]) {
+    let doc = ctx.doc;
+    let pad = indent(depth);
+    if ctx.too_deep(depth) {
+        out.push_str(&format!("{pad}// {} …\n", one_line(&n.name)));
+        return;
+    }
+    // Nested instances are calls; an instance swap parameter is a view.
+    let call = match ctx.param(n, "mainComponent").filter(|_| n.id != ctx.root) {
+        Some(p) => Some(format!("{pad}{}\n", p.ident)),
+        None => ctx.call(n, CodeLang::SwiftUi, depth).map(|(code, _)| code),
+    };
+    if let Some(call) = call {
+        out.push_str(&call);
+        for m in extra {
+            out.push_str(&format!("{pad}    {m}\n"));
+        }
+        return;
+    }
+    let mut mods: Vec<String> = Vec::new();
+    match &n.kind {
+        NodeKind::Text(t) => {
+            let text = ctx.param(n, "characters").map_or_else(|| literal(&t.characters, false), |p| p.ident.clone());
+            out.push_str(&format!("{pad}Text({text})\n"));
+            mods.push(format!(
+                ".font(.custom({}, size: {}).weight({}))",
+                literal(&t.style.font_family, false),
+                num(t.style.font_size),
+                swift_weight(t.style.weight())
+            ));
+            if let Some(c) = first_fill(n) {
+                mods.push(format!(".foregroundColor({})", swift_color(c)));
+            }
+        }
+        NodeKind::Ellipse { .. } => {
+            out.push_str(&format!("{pad}Ellipse()\n"));
+            if let Some(c) = first_fill(n) {
+                mods.push(format!(".fill({})", swift_color(c)));
+            }
+            mods.push(format!(".frame(width: {}, height: {})", num(n.width), num(n.height)));
+        }
+        NodeKind::Rectangle => {
+            out.push_str(&format!("{pad}RoundedRectangle(cornerRadius: {})\n", num(radius(n))));
+            if let Some(c) = first_fill(n) {
+                mods.push(format!(".fill({})", swift_color(c)));
+            }
+            mods.push(format!(".frame(width: {}, height: {})", num(n.width), num(n.height)));
+        }
+        k if k.is_frame_like() || matches!(k, NodeKind::Group) => {
+            let children = ctx.kids(n);
+            let open = match n.layout.as_ref().map(|l| (l.mode, l)) {
+                Some((LayoutMode::Vertical, l)) => format!("VStack(alignment: .leading, spacing: {}) {{", num(l.gap)),
+                Some((_, l)) => format!("HStack(alignment: .center, spacing: {}) {{", num(l.gap)),
+                None => "ZStack(alignment: .topLeading) {".to_string(),
+            };
+            out.push_str(&format!("{pad}{open}\n"));
+            // A slot shows the instance's content, or else the main's.
+            let slot = ctx.param(n, "slot");
+            let inner = match slot {
+                Some(p) => {
+                    out.push_str(&format!("{pad}    if let {0} {{\n{pad}        {0}\n{pad}    }} else {{\n", p.ident));
+                    depth + 2
+                }
+                None => depth + 1,
+            };
+            for c in &children {
+                // Free children sit at their offset inside a ZStack.
+                let offset: Vec<String> = match doc.node(*c).filter(|_| n.layout.is_none()) {
+                    Some(cn) => {
+                        let [_, _, _, _, x, y] = cn.transform.as_coeffs();
+                        vec![format!(".offset(x: {}, y: {})", num(x), num(y))]
+                    }
+                    None => Vec::new(),
+                };
+                swift(ctx, *c, inner, out, &offset);
+            }
+            if slot.is_some() {
+                out.push_str(&format!("{pad}    }}\n"));
+            }
+            out.push_str(&format!("{pad}}}\n"));
+            if let Some(l) = &n.layout {
+                let [t, r, b, lft] = l.padding;
+                if [t, r, b, lft].iter().any(|v| *v > 0.0) {
+                    mods.push(format!(".padding(EdgeInsets(top: {}, leading: {}, bottom: {}, trailing: {}))", num(t), num(lft), num(b), num(r)));
+                }
+            }
+            mods.push(format!(".frame(width: {}, height: {}, alignment: .topLeading)", num(n.width), num(n.height)));
+            if let Some(c) = first_fill(n) {
+                mods.push(format!(".background({})", swift_color(c)));
+            }
+            if radius(n) > 0.0 {
+                mods.push(format!(".clipShape(RoundedRectangle(cornerRadius: {}))", num(radius(n))));
+            }
+        }
+        _ => {
+            out.push_str(&format!("{pad}// {}: export as an image asset\n{pad}Image({})\n", n.kind.label(), literal(&n.name, false)));
+            mods.push(".resizable()".into());
+            mods.push(format!(".frame(width: {}, height: {})", num(n.width), num(n.height)));
+        }
+    }
+    if let Some(c) = stroke_color(n) {
+        mods.push(format!(
+            ".overlay(RoundedRectangle(cornerRadius: {}).stroke({}, lineWidth: {}))",
+            num(radius(n)),
+            swift_color(c),
+            num(n.stroke.weight)
+        ));
+    }
+    if let Some(s) = drop_shadow(n) {
+        mods.push(format!(
+            ".shadow(color: {}, radius: {}, x: {}, y: {})",
+            swift_color(s.color),
+            num(s.radius / 2.0),
+            num(s.offset.0),
+            num(s.offset.1)
+        ));
+    }
+    if n.opacity < 1.0 {
+        mods.push(format!(".opacity({})", num(f64::from(n.opacity))));
+    }
+    mods.extend(extra.iter().cloned());
+    for m in mods {
+        out.push_str(&format!("{pad}    {m}\n"));
+    }
+}

From 688eeccc7a832583f7d41b3ab89819dd2fee18e0 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:20:45 +0000
Subject: [PATCH 28/67] refactor(engine): split boards/board.rs into board/

---
 crates/engine/src/boards/board.rs            | 1254 +-----------------
 crates/engine/src/boards/board/connectors.rs |  147 ++
 crates/engine/src/boards/board/derived.rs    |  339 +++++
 crates/engine/src/boards/board/edit.rs       |  260 ++++
 crates/engine/src/boards/board/items.rs      |  297 +++++
 crates/engine/src/boards/board/tools.rs      |  210 +++
 6 files changed, 1271 insertions(+), 1236 deletions(-)
 create mode 100644 crates/engine/src/boards/board/connectors.rs
 create mode 100644 crates/engine/src/boards/board/derived.rs
 create mode 100644 crates/engine/src/boards/board/edit.rs
 create mode 100644 crates/engine/src/boards/board/items.rs
 create mode 100644 crates/engine/src/boards/board/tools.rs

diff --git a/crates/engine/src/boards/board.rs b/crates/engine/src/boards/board.rs
index 5408c6c9..b40bcc7d 100644
--- a/crates/engine/src/boards/board.rs
+++ b/crates/engine/src/boards/board.rs
@@ -21,6 +21,24 @@ use crate::params::{boolean, color_of, get, id, id_of, num, num_or, opt_id, req_
 use crate::tools::{Gesture, PointerEvent, ToolId};
 use crate::{EngineError, Result, Session, bad, spec, textedit};
 
+mod connectors;
+mod derived;
+mod edit;
+mod items;
+mod tools;
+
+pub(crate) use connectors::end_handle_at;
+pub use connectors::{END_HANDLE_PX, selected_connector_ends};
+use connectors::{connector_cmd, reattach};
+pub use derived::route;
+pub(crate) use derived::{settle_routes, settle_text};
+pub use edit::label_of;
+pub(crate) use edit::{copied_items, copy_map, rejoin};
+use edit::{label_cmd, set_color, set_style};
+pub(crate) use items::add_text;
+pub use items::{edit_text, owner_of_text, sticky_font_size, text_of};
+use items::{ink_cmd, next_sticky, shape_cmd, stamp_cmd, sticky_cmd};
+
 /// Why a board command refuses on a design file.
 pub const NEEDS_BOARD: &str = "this is for boards: make one with File ▸ New board";
 /// Why prototyping and Dev Mode refuse on a board.
@@ -257,1239 +275,3 @@ fn parent_of(cmd: &str, s: &Session, p: &Value) -> Result<NodeId> {
     }
     Ok(parent)
 }
-
-/// A new layer at the top of `parent`, at `at` in it, made by `f`.
-fn add(
-    doc: &mut Document,
-    parent: NodeId,
-    kind: NodeKind,
-    name: &str,
-    at: (f64, f64),
-    size: (f64, f64),
-    f: impl FnOnce(&mut Node),
-) -> Result<NodeId> {
-    let id = doc.alloc_id();
-    let mut n = Node::new(id, kind, name, size.0, size.1);
-    n.transform = Affine::translate(at);
-    f(&mut n);
-    doc.insert(n, parent, None)?;
-    Ok(id)
-}
-
-/// A soft shadow under stickies and stamps.
-fn soft_shadow() -> Effect {
-    Effect {
-        kind: EffectKind::DropShadow(Shadow { color: Color::new(0.0, 0.0, 0.0, 0.16), offset: (0.0, 2.0), radius: 6.0, ..Shadow::default() }),
-        visible: true,
-    }
-}
-
-/// A text layer filling its frame's width (the frame's auto layout places it).
-pub(crate) fn add_text(doc: &mut Document, parent: NodeId, text: &str, size: f64, color: Color, align: TextAlignH, width: f64) -> Result<NodeId> {
-    let first: String = text.lines().next().unwrap_or("").chars().take(64).collect();
-    let name = if first.trim().is_empty() { "Text" } else { first.as_str() };
-    let mut td = TextData {
-        characters: crate::cmd::props::normalize_line_endings(text),
-        auto_resize: TextAutoResize::Height,
-        align_h: align,
-        ..TextData::default()
-    };
-    td.style.font_size = size;
-    let id = add(doc, parent, NodeKind::Text(td), name, (0.0, 0.0), (width.max(1.0), size * 1.4), |n| {
-        n.fills = vec![Paint::solid(color)];
-        n.child_layout.sizing_h = Sizing::Fill;
-    })?;
-    if let Some(n) = doc.node(id)
-        && let Some((w, h)) = figcraft_text::auto_size(n)
-        && let Some(n) = doc.node_mut(id)
-    {
-        (n.width, n.height) = (w, h);
-    }
-    Ok(id)
-}
-
-/// The text size a sticky's note gets: smaller the more it holds (by characters and lines, so
-/// every copy of the file picks the same size whatever fonts it has).
-pub fn sticky_font_size(text: &str) -> f64 {
-    let weight = text.chars().count() + 24 * text.matches('\n').count();
-    match weight {
-        0..=24 => 24.0,
-        25..=64 => 20.0,
-        65..=140 => 16.0,
-        141..=280 => 13.0,
-        _ => 11.0,
-    }
-}
-
-/// A sticky note's layers: the frame, the note and (when known) its author.
-fn make_sticky(doc: &mut Document, parent: NodeId, at: (f64, f64), text: &str, color: Color, author: &str) -> Result<(NodeId, NodeId)> {
-    let id = add(doc, parent, NodeKind::Frame, "Sticky", at, (STICKY, STICKY), |n| {
-        n.fills = vec![Paint::solid(color)];
-        n.corners.radii = [2.0; 4];
-        n.effects = vec![soft_shadow()];
-        n.clip = false;
-        n.layout = Some(AutoLayout {
-            mode: LayoutMode::Vertical,
-            gap: 8.0,
-            padding: [STICKY_PAD; 4],
-            main_align: MainAlign::SpaceBetween,
-            ..AutoLayout::default()
-        });
-        n.child_layout.sizing_v = Sizing::Hug;
-        n.child_layout.min_h = Some(STICKY);
-        n.board = Some(BoardItem::Sticky { author: author.to_string() });
-    })?;
-    let inner = STICKY - 2.0 * STICKY_PAD;
-    let note = add_text(doc, id, text, sticky_font_size(text), INK, TextAlignH::Left, inner)?;
-    if !author.is_empty() {
-        let a = add_text(doc, id, author, 10.0, AUTHOR_INK, TextAlignH::Left, inner)?;
-        if let Some(n) = doc.node_mut(a) {
-            n.name = "Author".into();
-        }
-    }
-    Ok((id, note))
-}
-
-fn sticky_cmd(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.sticky";
-    require(s, cmd)?;
-    let color = color_param(cmd, p)?.unwrap_or(s.tool.board.sticky);
-    let author = match get(p, "author") {
-        Some(Value::String(a)) => a.trim().chars().filter(|c| !c.is_control()).take(64).collect(),
-        Some(Value::Bool(false)) => String::new(),
-        _ => author(s),
-    };
-    let parent = parent_of(cmd, s, p)?;
-    let text = string(p, "text").unwrap_or_default();
-    let at = (num_or(p, "x", 0.0), num_or(p, "y", 0.0));
-    let (id, note) = make_sticky(s.doc_mut()?, parent, at, &text, color, &author)?;
-    s.set_selection(vec![id]);
-    Ok(json!({"id": id, "text": note}))
-}
-
-/// The first text layer inside board object `id` (its note or label).
-pub fn text_of(doc: &Document, id: NodeId) -> Option<NodeId> {
-    let n = doc.node(id)?;
-    n.board.as_ref().filter(|b| b.has_text())?;
-    n.children.iter().copied().find(|c| doc.node(*c).is_some_and(|k| matches!(k.kind, NodeKind::Text(_))))
-}
-
-/// The board object whose text `text` is, if any.
-pub fn owner_of_text(doc: &Document, text: NodeId) -> Option<NodeId> {
-    let p = doc.node(text)?.parent?;
-    (text_of(doc, p) == Some(text)).then_some(p)
-}
-
-/// Start typing in board object `id`'s text (all of it selected). False when it has none.
-pub fn edit_text(s: &mut Session, id: NodeId) -> Result<bool> {
-    let Some(t) = s.doc().ok().and_then(|d| text_of(d, id)) else { return Ok(false) };
-    textedit::begin(s, t, None, false)?;
-    textedit::key(s, "SelectAll", false, false, false)?;
-    Ok(true)
-}
-
-fn next_sticky(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.nextSticky";
-    require(s, cmd)?;
-    let editing = s.ds()?.text_edit.as_ref().map(|t| t.id);
-    let doc = s.doc()?;
-    let from = id(p, "id")
-        .or_else(|| editing.and_then(|t| owner_of_text(doc, t)))
-        .or_else(|| s.selection().first().copied().map(|i| owner_of_text(doc, i).unwrap_or(i)))
-        .ok_or_else(|| EngineError::Disabled(cmd.into(), "select a sticky first".into()))?;
-    let n = doc.get(from)?;
-    if !matches!(n.board, Some(BoardItem::Sticky { .. })) {
-        return Err(bad(cmd, "that isn't a sticky"));
-    }
-    let color = n.fills.iter().find_map(Paint::solid_color).unwrap_or(s.tool.board.sticky);
-    let parent = n.parent.ok_or_else(|| bad(cmd, "that sticky has no parent"))?;
-    let at = n.transform.translation();
-    let (dx, dy) = match string(p, "side").as_deref().unwrap_or("right") {
-        "right" => (n.width + STICKY_GAP, 0.0),
-        "left" => (-(STICKY + STICKY_GAP), 0.0),
-        "below" => (0.0, n.height + STICKY_GAP),
-        "above" => (0.0, -(STICKY + STICKY_GAP)),
-        other => return Err(bad(cmd, format!("`side` is right, below, left or above, not `{other}`"))),
-    };
-    let author = author(s);
-    if editing.is_some() {
-        textedit::end(s)?;
-    }
-    let (id, note) = make_sticky(s.doc_mut()?, parent, (at.x + dx, at.y + dy), "", color, &author)?;
-    s.set_selection(vec![id]);
-    if boolean(p, "edit") == Some(true) {
-        // Typing goes on in the new sticky once this step is recorded.
-        s.request_ui("board.editText", json!({"id": id}));
-    }
-    Ok(json!({"id": id, "text": note}))
-}
-
-/// A shape with text's layers: the frame, its outline and its text.
-fn make_shape(
-    doc: &mut Document,
-    parent: NodeId,
-    at: (f64, f64),
-    size: (f64, f64),
-    shape: BoardShape,
-    text: &str,
-    color: Color,
-) -> Result<(NodeId, NodeId)> {
-    let (w, h) = size;
-    let id = add(doc, parent, NodeKind::Frame, shape.label(), at, size, |n| {
-        n.fills.clear();
-        n.clip = false;
-        n.layout = Some(AutoLayout {
-            mode: LayoutMode::Vertical,
-            padding: shape_padding(shape, w, h),
-            main_align: MainAlign::Center,
-            cross_align: CrossAlign::Center,
-            ..AutoLayout::default()
-        });
-        n.board = Some(BoardItem::Shape { shape });
-    })?;
-    add(doc, id, NodeKind::Vector { network: VectorNetwork::from_path(&shape.path(w, h)) }, "Outline", (0.0, 0.0), size, |n| {
-        n.fills = vec![Paint::solid(color)];
-        n.strokes = vec![Paint::solid(line_shade(color))];
-        n.stroke.weight = 1.5;
-        n.stroke.align = StrokeAlign::Inside;
-        n.child_layout.absolute = true;
-        n.constraints = Constraints { horizontal: HConstraint::Scale, vertical: VConstraint::Scale };
-    })?;
-    let [_, r, _, l] = shape_padding(shape, w, h);
-    let label = add_text(doc, id, text, 16.0, INK, TextAlignH::Center, (w - l - r).max(1.0))?;
-    Ok((id, label))
-}
-
-fn shape_padding(shape: BoardShape, w: f64, h: f64) -> [f64; 4] {
-    let [t, r, b, l] = shape.text_insets();
-    [t * h, r * w, b * h, l * w]
-}
-
-fn shape_cmd(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.shape";
-    require(s, cmd)?;
-    let shape = match string(p, "shape") {
-        Some(v) => shape_of(cmd, &v)?,
-        None => s.tool.board.shape,
-    };
-    let size = |k| {
-        num(p, k)
-            .map_or(Ok(SHAPE), |v| if (1.0..=100_000.0).contains(&v) { Ok(v) } else { Err(bad(cmd, format!("`{k}` is a size from 1 to 100000"))) })
-    };
-    let (w, h) = (size("width")?, size("height")?);
-    let color = color_param(cmd, p)?.unwrap_or(s.tool.board.sticky);
-    let parent = parent_of(cmd, s, p)?;
-    let text = string(p, "text").unwrap_or_default();
-    let at = (num_or(p, "x", 0.0), num_or(p, "y", 0.0));
-    let (id, label) = make_shape(s.doc_mut()?, parent, at, (w, h), shape, &text, color)?;
-    s.set_selection(vec![id]);
-    Ok(json!({"id": id, "text": label}))
-}
-
-fn stamp_cmd(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.stamp";
-    require(s, cmd)?;
-    let stamp = match string(p, "stamp") {
-        Some(v) => stamp_of(cmd, &v)?,
-        None => s.tool.board.stamp,
-    };
-    let (x, y) = (req_num(cmd, p, "x")?, req_num(cmd, p, "y")?);
-    let author = author(s);
-    let page = s.page()?;
-    let half = STAMP_SIZE / 2.0;
-    let doc = s.doc_mut()?;
-    let id = add(doc, page, NodeKind::Frame, stamp.label(), (x - half, y - half), (STAMP_SIZE, STAMP_SIZE), |n| {
-        n.fills = vec![Paint::solid(stamp.color())];
-        n.corners.radii = [half; 4];
-        n.effects = vec![soft_shadow()];
-        n.clip = false;
-        n.board = Some(BoardItem::Stamp { stamp, author });
-    })?;
-    for part in stamp.mark() {
-        let path = figcraft_geom::BezPath::from_svg(part.d).map_err(|e| EngineError::Other(format!("stamp mark: {e}")))?;
-        add(doc, id, NodeKind::Vector { network: VectorNetwork::from_path(&path) }, "Mark", (0.0, 0.0), (STAMP_SIZE, STAMP_SIZE), |n| {
-            if part.filled {
-                n.fills = vec![Paint::solid(Color::WHITE)];
-            } else {
-                n.fills.clear();
-                n.strokes = vec![Paint::solid(Color::WHITE)];
-                n.stroke.weight = 3.0;
-                (n.stroke.cap_start, n.stroke.cap_end) = (StrokeCap::Round, StrokeCap::Round);
-                n.stroke.join = StrokeJoin::Round;
-                n.stroke.align = StrokeAlign::Center;
-            }
-        })?;
-    }
-    s.set_selection(vec![id]);
-    Ok(json!({"id": id}))
-}
-
-fn ink_cmd(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.ink";
-    require(s, cmd)?;
-    let high = boolean(p, "highlighter").unwrap_or(false);
-    let color = color_param(cmd, p)?.unwrap_or(if high { s.tool.board.highlighter } else { s.tool.board.marker });
-    let (weight, opacity) = if high { HIGHLIGHTER } else { MARKER };
-    if get(p, "path").is_none() && get(p, "points").is_none() {
-        return Err(bad(cmd, "`path` or `points` is required"));
-    }
-    let page = s.page()?;
-    let select = boolean(p, "select").unwrap_or(true);
-    let mut q = json!({"type": "vector", "parent": page, "closed": false, "select": select, "name": if high { "Highlight" } else { "Ink" }, "props": {
-        "fills": [], "strokes": [color.to_css_hex()], "strokeWeight": weight, "strokeCap": "round", "strokeJoin": "round", "strokeAlign": "center",
-    }});
-    for k in ["path", "points"] {
-        if let (Some(v), Some(o)) = (get(p, k), q.as_object_mut()) {
-            o.insert(k.into(), v.clone());
-        }
-    }
-    let made = crate::cmd::create::create(s, &q)?;
-    let id = made.get("id").and_then(id_of).ok_or_else(|| EngineError::Other("no stroke made".into()))?;
-    let n = s.doc_mut()?.get_mut(id)?;
-    n.opacity = opacity;
-    if high {
-        n.blend = BlendMode::Multiply;
-    }
-    n.board = Some(BoardItem::Ink);
-    Ok(json!({"id": id}))
-}
-
-/// One connector end from the params: a layer on this page, or a point.
-fn end_param(cmd: &str, s: &Session, p: &Value, key: &str, side_key: &str) -> Result<End> {
-    let side = match string(p, side_key) {
-        Some(v) => Side::from_id(&v).ok_or_else(|| bad(cmd, format!("`{side_key}` is auto, top, right, bottom or left")))?,
-        None => Side::Auto,
-    };
-    match get(p, key) {
-        Some(Value::Object(o)) if o.contains_key("x") => {
-            let (x, y) = (num(&Value::Object(o.clone()), "x"), num(&Value::Object(o.clone()), "y"));
-            match (x, y) {
-                (Some(x), Some(y)) if x.is_finite() && y.is_finite() => Ok(End::Point { x, y }),
-                _ => Err(bad(cmd, format!("`{key}` needs finite x and y"))),
-            }
-        }
-        Some(v) => {
-            let node = id_of(v).ok_or_else(|| bad(cmd, format!("`{key}` is a layer id or {{x, y}}")))?;
-            let doc = s.doc()?;
-            let n = doc.get(node)?;
-            if n.is_page() || doc.page_of(node) != Some(s.page()?) {
-                return Err(bad(cmd, format!("`{key}` must be a layer on this page")));
-            }
-            if matches!(n.board, Some(BoardItem::Connector(_))) {
-                return Err(bad(cmd, format!("`{key}` can't be another connector")));
-            }
-            Ok(End::Node { node, side })
-        }
-        None => Err(bad(cmd, format!("`{key}` is required"))),
-    }
-}
-
-fn connector_cmd(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.connector";
-    require(s, cmd)?;
-    let from = end_param(cmd, s, p, "from", "fromSide")?;
-    let to = end_param(cmd, s, p, "to", "toSide")?;
-    if from.node().is_some() && from.node() == to.node() {
-        return Err(bad(cmd, "connect two different layers"));
-    }
-    let routing = match string(p, "style") {
-        Some(v) => routing_of(cmd, &v)?,
-        None => s.tool.board.routing,
-    };
-    let start = cap_of(cmd, p, "startCap")?.unwrap_or(StrokeCap::None);
-    let end = cap_of(cmd, p, "endCap")?.unwrap_or(StrokeCap::TriangleArrow);
-    let c = Connector { from, to, routing };
-    let page = s.page()?;
-    let doc = s.doc_mut()?;
-    let pts = route(doc, &c).ok_or_else(|| bad(cmd, "the ends can't be placed"))?;
-    if pts.windows(2).all(|w| w.first() == w.get(1)) {
-        return Err(bad(cmd, "the ends are in the same place"));
-    }
-    let id = add(doc, page, NodeKind::Vector { network: VectorNetwork::default() }, "Connector", (0.0, 0.0), (0.0, 0.0), |n| {
-        n.fills.clear();
-        n.strokes = vec![Paint::solid(LINE)];
-        n.stroke.weight = LINE_WEIGHT;
-        n.stroke.join = StrokeJoin::Round;
-        n.stroke.cap_start = start;
-        n.stroke.cap_end = end;
-        n.board = Some(BoardItem::Connector(c));
-    })?;
-    place_route(doc, id, &pts, routing);
-    let mut out = json!({"id": id});
-    if let Some(text) = string(p, "label").filter(|t| !t.trim().is_empty()) {
-        out["label"] = json!(set_label(doc, id, &text)?);
-    }
-    s.set_selection(vec![id]);
-    Ok(out)
-}
-
-/// The connector `id` names: a connector, or the label on one.
-fn connector_of(cmd: &str, doc: &Document, id: NodeId) -> Result<(NodeId, Connector)> {
-    match doc.get(id)?.board.clone() {
-        Some(BoardItem::Connector(c)) => Ok((id, c)),
-        Some(BoardItem::Label { connector }) => match doc.get(connector)?.board.clone() {
-            Some(BoardItem::Connector(c)) => Ok((connector, c)),
-            _ => Err(bad(cmd, "that isn't a connector")),
-        },
-        _ => Err(bad(cmd, "that isn't a connector")),
-    }
-}
-
-fn reattach(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.reattach";
-    require(s, cmd)?;
-    let id = req_targets(cmd, s, p)?.first().copied().ok_or_else(|| bad(cmd, "select a connector"))?;
-    let (id, mut c) = connector_of(cmd, s.doc()?, id)?;
-    let from = match string(p, "end").as_deref() {
-        Some("from") => true,
-        Some("to") => false,
-        _ => return Err(bad(cmd, "`end` is from or to")),
-    };
-    let end = end_param(cmd, s, p, "target", "side")?;
-    let other = if from { c.to } else { c.from };
-    if end.node().is_some() && end.node() == other.node() {
-        return Err(bad(cmd, "connect two different layers"));
-    }
-    *(if from { &mut c.from } else { &mut c.to }) = end;
-    let doc = s.doc_mut()?;
-    let pts = route(doc, &c).ok_or_else(|| bad(cmd, "the ends can't be placed"))?;
-    if pts.windows(2).all(|w| w.first() == w.get(1)) {
-        return Err(bad(cmd, "the ends are in the same place"));
-    }
-    doc.get_mut(id)?.board = Some(BoardItem::Connector(c));
-    place_route(doc, id, &pts, c.routing);
-    Ok(json!({"id": id}))
-}
-
-/// A connector end as `board.connector` and `board.reattach` take it.
-fn end_json(e: End) -> Value {
-    match e {
-        End::Node { node, .. } => json!(node),
-        End::Point { x, y } => json!({"x": x, "y": y}),
-    }
-}
-
-/// The end of connector `id` that stays while its other one (`from`: its start) is dragged.
-fn other_end(doc: &Document, id: NodeId, from: bool) -> Option<End> {
-    match &doc.node(id)?.board {
-        Some(BoardItem::Connector(c)) => Some(if from { c.to } else { c.from }),
-        _ => None,
-    }
-}
-
-/// The selected connector (one, alone and unlocked) and its two ends on the page as drawn.
-pub fn selected_connector_ends(doc: &Document, sel: &[NodeId]) -> Option<(NodeId, [Point; 2])> {
-    let [id] = sel else { return None };
-    if !matches!(doc.node(*id)?.board, Some(BoardItem::Connector(_))) || crate::tools::locked_in(doc, *id) {
-        return None;
-    }
-    let (a, b) = ends_now(doc, *id)?;
-    Some((*id, [a, b]))
-}
-
-/// How near (screen pixels) a press must be to a selected connector's end to drag it.
-pub const END_HANDLE_PX: f64 = 8.0;
-
-/// The selected connector's end under `p` at `zoom`, nearest first (`true`: its start).
-pub(crate) fn end_handle_at(doc: &Document, sel: &[NodeId], p: Point, zoom: f64) -> Option<(NodeId, bool)> {
-    let (id, [a, b]) = selected_connector_ends(doc, sel)?;
-    let (da, db) = ((a - p).hypot(), (b - p).hypot());
-    (da.min(db) * zoom.max(1e-6) <= END_HANDLE_PX).then_some((id, da <= db))
-}
-
-/// The label of connector `id`, if it has one.
-pub fn label_of(doc: &Document, id: NodeId) -> Option<NodeId> {
-    let parent = doc.node(id)?.parent?;
-    doc.node(parent)?.children.iter().copied().find(|c| doc.node(*c).is_some_and(|n| n.board == Some(BoardItem::Label { connector: id })))
-}
-
-/// Give connector `id` the label `text` (empty removes it); the label's id.
-fn set_label(doc: &mut Document, id: NodeId, text: &str) -> Result<Option<NodeId>> {
-    let existing = label_of(doc, id);
-    if text.trim().is_empty() {
-        if let Some(l) = existing {
-            doc.remove(l)?;
-        }
-        return Ok(None);
-    }
-    if let Some(l) = existing {
-        if let Some(t) = text_of(doc, l)
-            && let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|n| &mut n.kind)
-        {
-            let len = td.char_count();
-            td.replace_range(0, len, text);
-        }
-        return Ok(Some(l));
-    }
-    let parent = doc.node(id).and_then(|n| n.parent).ok_or(DocError::NoNode(id))?;
-    let l = add(doc, parent, NodeKind::Frame, "Label", (0.0, 0.0), (40.0, 24.0), |n| {
-        n.fills = vec![Paint::solid(Color::WHITE)];
-        n.corners.radii = [4.0; 4];
-        n.clip = false;
-        n.layout = Some(AutoLayout { padding: [3.0, 6.0, 3.0, 6.0], ..AutoLayout::default() });
-        n.child_layout.sizing_h = Sizing::Hug;
-        n.child_layout.sizing_v = Sizing::Hug;
-        n.board = Some(BoardItem::Label { connector: id });
-    })?;
-    let t = add_text(doc, l, text, 12.0, INK, TextAlignH::Center, 40.0)?;
-    if let Some(n) = doc.node_mut(t)
-        && let NodeKind::Text(td) = &mut n.kind
-    {
-        // The label hugs its text: one line per paragraph.
-        td.auto_resize = TextAutoResize::WidthAndHeight;
-        n.child_layout.sizing_h = Sizing::Hug;
-    }
-    Ok(Some(l))
-}
-
-fn label_cmd(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.label";
-    require(s, cmd)?;
-    let id = req_targets(cmd, s, p)?.first().copied().ok_or_else(|| bad(cmd, "select a connector"))?;
-    let (id, _) = connector_of(cmd, s.doc()?, id)?;
-    let text = req_string(cmd, p, "text")?;
-    let label = set_label(s.doc_mut()?, id, &text)?;
-    Ok(json!({"id": id, "label": label}))
-}
-
-/// The board objects among `ids`, each with its item (a label counts as its connector's text).
-fn items(doc: &Document, ids: &[NodeId]) -> Vec<(NodeId, BoardItem)> {
-    ids.iter().filter_map(|i| doc.node(*i).and_then(|n| n.board.clone()).map(|b| (*i, b))).collect()
-}
-
-fn set_color(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.setColor";
-    require(s, cmd)?;
-    let ids = req_targets(cmd, s, p)?;
-    let color = color_param(cmd, p)?.ok_or_else(|| bad(cmd, "`color` is required"))?;
-    let doc = s.doc_mut()?;
-    let mut changed = Vec::new();
-    for (id, item) in items(doc, &ids) {
-        match item {
-            BoardItem::Sticky { .. } => doc.get_mut(id)?.fills = vec![Paint::solid(color)],
-            BoardItem::Shape { .. } => {
-                let Some(outline) = doc.get(id)?.children.first().copied() else { continue };
-                let n = doc.get_mut(outline)?;
-                n.fills = vec![Paint::solid(color)];
-                n.strokes = vec![Paint::solid(line_shade(color))];
-            }
-            BoardItem::Connector(_) | BoardItem::Ink => doc.get_mut(id)?.strokes = vec![Paint::solid(line_shade(color))],
-            BoardItem::Label { .. } | BoardItem::Stamp { .. } | BoardItem::Table => continue,
-        }
-        changed.push(id);
-    }
-    if changed.is_empty() {
-        return Err(bad(cmd, "select stickies, shapes, connectors or ink"));
-    }
-    Ok(json!({"ids": changed}))
-}
-
-/// What `board.setStyle` changes (each `None` leaves it).
-struct Restyle {
-    shape: Option<BoardShape>,
-    routing: Option<Routing>,
-    size: Option<f64>,
-    start: Option<StrokeCap>,
-    end: Option<StrokeCap>,
-}
-
-impl Restyle {
-    fn of(cmd: &str, p: &Value) -> Result<Restyle> {
-        let size = num(p, "fontSize")
-            .map(|v| if v.is_finite() && (1.0..=1000.0).contains(&v) { Ok(v) } else { Err(bad(cmd, "`fontSize` is from 1 to 1000")) })
-            .transpose()?;
-        Ok(Restyle {
-            shape: string(p, "shape").map(|v| shape_of(cmd, &v)).transpose()?,
-            routing: string(p, "style").map(|v| routing_of(cmd, &v)).transpose()?,
-            size,
-            start: cap_of(cmd, p, "startCap")?,
-            end: cap_of(cmd, p, "endCap")?,
-        })
-    }
-
-    /// Restyle board object `id` (`item`); whether anything about it changed.
-    fn apply(&self, doc: &mut Document, id: NodeId, item: BoardItem) -> Result<bool> {
-        let changed = match item {
-            BoardItem::Shape { shape } => match self.shape.filter(|n| *n != shape) {
-                Some(new) => {
-                    reshape(doc, id, new)?;
-                    true
-                }
-                None => false,
-            },
-            BoardItem::Connector(c) => self.restyle_connector(doc, id, c)?,
-            _ => false,
-        };
-        // Text sizes: shapes' and labels' text (stickies size theirs to fit).
-        let sized = match (self.size, &item) {
-            (Some(size), BoardItem::Shape { .. } | BoardItem::Label { .. }) => resize_text(doc, id, size),
-            _ => false,
-        };
-        Ok(changed || sized)
-    }
-
-    fn restyle_connector(&self, doc: &mut Document, id: NodeId, mut c: Connector) -> Result<bool> {
-        let n = doc.get_mut(id)?;
-        if let Some(r) = self.routing {
-            c.routing = r;
-            n.board = Some(BoardItem::Connector(c));
-        }
-        if let Some(cap) = self.start {
-            n.stroke.cap_start = cap;
-        }
-        if let Some(cap) = self.end {
-            n.stroke.cap_end = cap;
-        }
-        Ok(self.routing.is_some() || self.start.is_some() || self.end.is_some())
-    }
-}
-
-/// Shape with text `id` takes outline `new` (its text room too).
-fn reshape(doc: &mut Document, id: NodeId, new: BoardShape) -> Result<()> {
-    let n = doc.get_mut(id)?;
-    n.board = Some(BoardItem::Shape { shape: new });
-    n.name = new.label().into();
-    let (w, h) = (n.width, n.height);
-    if let Some(l) = n.layout.as_mut() {
-        l.padding = shape_padding(new, w, h);
-    }
-    if let Some(o) = doc.get(id)?.children.first().copied()
-        && let Some(on) = doc.node_mut(o)
-    {
-        on.kind = NodeKind::Vector { network: VectorNetwork::from_path(&new.path(w, h)) };
-        (on.width, on.height, on.transform) = (w, h, Affine::IDENTITY);
-    }
-    Ok(())
-}
-
-/// Board object `id`'s text at `size`; whether it has text.
-fn resize_text(doc: &mut Document, id: NodeId, size: f64) -> bool {
-    let Some(t) = text_of(doc, id) else { return false };
-    if let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|n| &mut n.kind) {
-        set_font_size(td, size);
-        return true;
-    }
-    false
-}
-
-fn set_style(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "board.setStyle";
-    require(s, cmd)?;
-    let ids = req_targets(cmd, s, p)?;
-    let restyle = Restyle::of(cmd, p)?;
-    let doc = s.doc_mut()?;
-    let mut changed = Vec::new();
-    for (id, item) in items(doc, &ids) {
-        if restyle.apply(doc, id, item)? {
-            changed.push(id);
-        }
-    }
-    if changed.is_empty() {
-        return Err(bad(cmd, "nothing selected takes these (shapes with text, connectors, labels)"));
-    }
-    Ok(json!({"ids": changed}))
-}
-
-fn set_font_size(td: &mut TextData, size: f64) {
-    td.style.font_size = size;
-    for r in &mut td.runs {
-        r.style.font_size = size;
-    }
-}
-
-/// Each layer of `sources` (copied one by one, in order, as `copies`) and its copy: the whole
-/// subtrees pair up when they have the same shape (an instance made of a main component may not;
-/// then only the roots do).
-pub(crate) fn copy_map(doc: &Document, sources: &[NodeId], copies: &[NodeId]) -> BTreeMap<NodeId, NodeId> {
-    let mut map = BTreeMap::new();
-    for (s, c) in sources.iter().zip(copies) {
-        let (a, b) = (doc.subtree(*s), doc.subtree(*c));
-        if a.len() == b.len() {
-            map.extend(a.into_iter().zip(b));
-        } else {
-            map.insert(*s, *c);
-        }
-    }
-    map
-}
-
-/// The connectors and labels among copied layers, as `(copy, the original's board item)`, from the
-/// originals in `doc` (`map`: original → copy).
-pub(crate) fn copied_items(doc: &Document, map: &BTreeMap<NodeId, NodeId>) -> Vec<(NodeId, BoardItem)> {
-    map.iter().filter_map(|(o, c)| doc.node(*o).and_then(|n| n.board.clone()).map(|b| (*c, b))).collect()
-}
-
-/// After a copy (`map`: each copied original → its copy; `originals`: the copies' items as the
-/// originals had them), copied connectors join the copies of what they joined and labels follow
-/// the copies of their connectors. From another file (`foreign`), what wasn't copied isn't here: a
-/// connector's end there stays where it is drawn, as a point, and a label without its connector
-/// goes.
-pub(crate) fn rejoin(doc: &mut Document, originals: &[(NodeId, BoardItem)], map: &BTreeMap<NodeId, NodeId>, foreign: bool) {
-    for (copy, item) in originals {
-        let mut item = item.clone();
-        let copied = |n: NodeId| map.contains_key(&n);
-        match &mut item {
-            BoardItem::Connector(c) if foreign => {
-                let ends = ends_now(doc, *copy);
-                for (end, at) in [(&mut c.from, ends.map(|e| e.0)), (&mut c.to, ends.map(|e| e.1))] {
-                    if let (End::Node { node, .. }, Some(p)) = (*end, at)
-                        && !copied(node)
-                    {
-                        *end = End::Point { x: p.x, y: p.y };
-                    }
-                }
-            }
-            BoardItem::Label { connector } if foreign && !copied(*connector) => {
-                let _ = doc.remove(*copy);
-                continue;
-            }
-            BoardItem::Connector(_) | BoardItem::Label { .. } => {}
-            _ => continue,
-        }
-        item.remap(map);
-        if let Some(n) = doc.node_mut(*copy) {
-            n.board = Some(item);
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------------------------
-// Derived data (the normalize pass).
-
-/// Before text is measured: a sticky's note takes the size its length calls for, and a resized
-/// shape keeps its text inside its outline.
-pub(crate) fn settle_text(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
-    if !is_board(doc) {
-        return;
-    }
-    for &id in touched {
-        let Some(n) = doc.node(id) else { continue };
-        if let Some(owner) =
-            owner_of_text(doc, id).or(Some(id)).filter(|o| doc.node(*o).is_some_and(|k| matches!(k.board, Some(BoardItem::Sticky { .. }))))
-            && let Some(t) = text_of(doc, owner)
-            && let Some(NodeKind::Text(td)) = doc.node(t).map(|k| &k.kind)
-        {
-            let size = sticky_font_size(&td.characters);
-            let off = td.style.font_size != size || td.runs.iter().any(|r| r.style.font_size != size);
-            if off && let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|k| &mut k.kind) {
-                set_font_size(td, size);
-            }
-            continue;
-        }
-        if let Some(BoardItem::Shape { shape }) = n.board
-            && before.node(id).is_none_or(|b| (b.width, b.height) != (n.width, n.height))
-        {
-            let pad = shape_padding(shape, n.width, n.height);
-            if n.layout.as_ref().is_some_and(|l| l.padding != pad)
-                && let Some(l) = doc.node_mut(id).and_then(|k| k.layout.as_mut())
-            {
-                l.padding = pad;
-            }
-        }
-    }
-}
-
-/// After layout: connectors run between their ends again (an end whose layer is gone stays where
-/// it was), one moved on its own takes its free ends along, and labels sit at their middles. Only
-/// the connectors and labels an edit can have moved are looked at: touched themselves, or with a
-/// touched (or gone) end, connector or layer around them.
-pub(crate) fn settle_routes(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
-    if !is_board(doc) || touched.is_empty() {
-        return;
-    }
-    let hit = |doc: &Document, id: NodeId| touched.contains(&id) || doc.ancestors(id).iter().any(|a| touched.contains(a));
-    let (mut connectors, mut labels) = (Vec::new(), Vec::new());
-    for n in doc.nodes() {
-        match &n.board {
-            Some(BoardItem::Connector(c)) => {
-                let ends = [c.from.node(), c.to.node()].into_iter().flatten();
-                if hit(doc, n.id) || ends.into_iter().any(|e| !doc.contains(e) || hit(doc, e)) {
-                    connectors.push((n.id, *c));
-                }
-            }
-            Some(BoardItem::Label { connector }) => labels.push((n.id, *connector)),
-            _ => {}
-        }
-    }
-    let rerouted: BTreeSet<NodeId> = connectors.iter().map(|(id, _)| *id).collect();
-    for (id, mut c) in connectors {
-        let changed = detach_gone_ends(doc, id, &mut c) | carry_free_ends(doc, before, touched, id, &mut c);
-        if changed && let Some(n) = doc.node_mut(id) {
-            n.board = Some(BoardItem::Connector(c));
-        }
-        if let Some(pts) = route(doc, &c) {
-            place_route(doc, id, &pts, c.routing);
-        }
-    }
-    for (label, connector) in labels {
-        if rerouted.contains(&connector) || touched.contains(&connector) || hit(doc, label) {
-            place_label(doc, label, connector);
-        }
-    }
-}
-
-/// The ends of connector `id` (as `c`) whose layer is gone or on another page stay where they are
-/// drawn, as points. Whether any did.
-fn detach_gone_ends(doc: &Document, id: NodeId, c: &mut Connector) -> bool {
-    let (page, ends) = (doc.page_of(id), ends_now(doc, id));
-    let mut detached = false;
-    for (end, at) in [(&mut c.from, ends.map(|e| e.0)), (&mut c.to, ends.map(|e| e.1))] {
-        if let (End::Node { node, .. }, Some(p)) = (*end, at)
-            && (!doc.contains(node) || doc.page_of(node) != page)
-        {
-            *end = End::Point { x: p.x, y: p.y };
-            detached = true;
-        }
-    }
-    detached
-}
-
-/// Connector `id` (as `c`) moved by itself (a drag, a nudge: its place changed but not what it
-/// joins): its free ends move with it. Whether they did.
-fn carry_free_ends(doc: &Document, before: &Document, touched: &BTreeSet<NodeId>, id: NodeId, c: &mut Connector) -> bool {
-    let (Some(b), Some(n)) = (before.node(id), doc.node(id)) else { return false };
-    if !touched.contains(&id) || b.transform == n.transform || b.board != n.board {
-        return false;
-    }
-    let Some(expected) = route(doc, c).and_then(|pts| finite_box(&route_path(&pts, c.routing))).map(|b| b.origin()) else { return false };
-    let d = (doc.world_transform(id) * Point::ZERO) - expected;
-    if d.hypot() <= 1e-9 {
-        return false;
-    }
-    let mut moved = false;
-    for end in [&mut c.from, &mut c.to] {
-        if let End::Point { x, y } = end {
-            (*x, *y) = (*x + d.x, *y + d.y);
-            moved = true;
-        }
-    }
-    moved
-}
-
-/// Label `label` at the middle of connector `connector`; gone with it when it is gone.
-fn place_label(doc: &mut Document, label: NodeId, connector: NodeId) {
-    let Some(mid) = doc.node(connector).and_then(|_| route_mid(doc, connector)) else {
-        let _ = doc.remove(label);
-        return;
-    };
-    let Some(n) = doc.node(label) else { return };
-    let pw = n.parent.map_or(Affine::IDENTITY, |p| doc.world_transform(p));
-    let local = pw.inverse() * mid;
-    let t = Affine::translate((local.x - n.width / 2.0, local.y - n.height / 2.0));
-    if n.transform != t
-        && let Some(n) = doc.node_mut(label)
-    {
-        n.transform = t;
-    }
-}
-
-/// Connector `id`'s first and last points on the page as it is drawn now.
-fn ends_now(doc: &Document, id: NodeId) -> Option<(Point, Point)> {
-    let NodeKind::Vector { network } = &doc.node(id)?.kind else { return None };
-    let w = doc.world_transform(id);
-    Some((w * network.vertices.first()?.point(), w * network.vertices.last()?.point()))
-}
-
-/// The middle of connector `id`'s route by length, on the page.
-fn route_mid(doc: &Document, id: NodeId) -> Option<Point> {
-    let NodeKind::Vector { network } = &doc.node(id)?.kind else { return None };
-    let w = doc.world_transform(id);
-    let mut pts: Vec<Point> = Vec::new();
-    figcraft_geom::kurbo::flatten(network.stroke_path().iter(), 0.25, |el| {
-        if let PathEl::MoveTo(p) | PathEl::LineTo(p) = el {
-            pts.push(w * p);
-        }
-    });
-    let total: f64 = pts.windows(2).map(|s| (s[1] - s[0]).hypot()).sum();
-    let mut left = total / 2.0;
-    for s in pts.windows(2) {
-        let (a, b) = (s[0], s[1]);
-        let l = (b - a).hypot();
-        if l >= left && l > 0.0 {
-            return Some(a.lerp(b, left / l));
-        }
-        left -= l;
-    }
-    pts.first().copied()
-}
-
-/// The path through a route's page points `pts` (see [`route`]): one curve for a curved
-/// connector, straight runs otherwise.
-fn route_path(pts: &[Point], routing: Routing) -> BezPath {
-    let mut path = BezPath::new();
-    match (routing, pts) {
-        (Routing::Curved, [p0, c0, c1, p1]) => {
-            path.move_to(*p0);
-            path.curve_to(*c0, *c1, *p1);
-        }
-        _ => {
-            for (i, p) in pts.iter().enumerate() {
-                if i == 0 { path.move_to(*p) } else { path.line_to(*p) }
-            }
-        }
-    }
-    path
-}
-
-/// The box a path is drawn in, when it is finite.
-fn finite_box(path: &BezPath) -> Option<Rect> {
-    let b = path.bounding_box();
-    (b.x0.is_finite() && b.y0.is_finite() && b.x1.is_finite() && b.y1.is_finite()).then_some(b)
-}
-
-/// Write the route `pts` (page points, see [`route`]) into connector `id`: its box, place and
-/// path. Untouched when it already runs there, so a connector that didn't move isn't an edit.
-fn place_route(doc: &mut Document, id: NodeId, pts: &[Point], routing: Routing) {
-    let Some(n) = doc.node(id) else { return };
-    let pw = n.parent.map_or(Affine::IDENTITY, |p| doc.world_transform(p));
-    let local = pw.inverse() * route_path(pts, routing);
-    let Some(b) = finite_box(&local) else { return };
-    let rel = Affine::translate((-b.x0, -b.y0)) * local;
-    let network = match routing {
-        Routing::Curved => VectorNetwork::from_path(&rel),
-        _ => VectorNetwork::from_points(&rel.elements().iter().filter_map(PathEl::end_point).collect::<Vec<_>>(), false),
-    };
-    let t = Affine::translate((b.x0, b.y0));
-    let same =
-        n.transform == t && n.width == b.width() && n.height == b.height() && matches!(&n.kind, NodeKind::Vector { network: old } if *old == network);
-    if same {
-        return;
-    }
-    if let Some(n) = doc.node_mut(id) {
-        n.kind = NodeKind::Vector { network };
-        n.transform = t;
-        (n.width, n.height) = (b.width(), b.height());
-    }
-}
-
-/// How far an elbow connector going around the objects it joins keeps from them.
-const ROOM: f64 = 24.0;
-
-/// The page points connector `c` runs through: from the middle of the side of each attached layer
-/// facing the other end (or the side it names), straight, in right angles, or (curved) its two
-/// ends with the curve's two control points between them.
-pub fn route(doc: &Document, c: &Connector) -> Option<Vec<Point>> {
-    let bounds = |e: &End| e.node().and_then(|n| doc.world_bounds(n));
-    let centre = |e: &End, b: Option<Rect>| match e {
-        End::Point { x, y } => Some(Point::new(*x, *y)),
-        End::Node { .. } => b.map(|b| b.center()),
-    };
-    let (fb, tb) = (bounds(&c.from), bounds(&c.to));
-    let (fc, tc) = (centre(&c.from, fb)?, centre(&c.to, tb)?);
-    let (p0, s0) = attach(&c.from, fb, tc)?;
-    let (p1, s1) = attach(&c.to, tb, fc)?;
-    let pts = match c.routing {
-        Routing::Straight => tidy(vec![p0, p1]),
-        Routing::Elbow => elbow(p0, s0, p1, s1, &[fb, tb].into_iter().flatten().collect::<Vec<_>>()),
-        Routing::Curved => curve(p0, s0, p1, s1),
-    };
-    pts.iter().all(|p| p.x.is_finite() && p.y.is_finite()).then_some(pts)
-}
-
-/// `pts` without repeats or turns that don't turn (three in a line across or down).
-fn tidy(pts: Vec<Point>) -> Vec<Point> {
-    let mut out: Vec<Point> = Vec::with_capacity(pts.len());
-    for p in pts {
-        if out.last() == Some(&p) {
-            continue;
-        }
-        if let [.., a, b] = out.as_slice()
-            && ((a.x == b.x && b.x == p.x) || (a.y == b.y && b.y == p.y))
-        {
-            out.pop();
-        }
-        out.push(p);
-    }
-    out
-}
-
-/// Where end `e` attaches (its point, or the middle of its layer's side facing `other`) and that
-/// side (`None`: a free point).
-fn attach(e: &End, b: Option<Rect>, other: Point) -> Option<(Point, Option<Side>)> {
-    match e {
-        End::Point { x, y } => Some((Point::new(*x, *y), None)),
-        End::Node { side, .. } => {
-            let b = b?;
-            let side = match side {
-                Side::Auto => {
-                    let d = other - b.center();
-                    // Compare against the box's proportions: a wide box takes the sides more.
-                    if d.x.abs() * b.height().max(1e-9) >= d.y.abs() * b.width().max(1e-9) {
-                        if d.x >= 0.0 { Side::Right } else { Side::Left }
-                    } else if d.y >= 0.0 {
-                        Side::Bottom
-                    } else {
-                        Side::Top
-                    }
-                }
-                s => *s,
-            };
-            Some((side.point(b), Some(side)))
-        }
-    }
-}
-
-/// A curve from `p0` to `p1` leaving and arriving along the sides' normals (a free end pulls no
-/// way): the ends and the two control points between them.
-fn curve(p0: Point, s0: Option<Side>, p1: Point, s1: Option<Side>) -> Vec<Point> {
-    let reach = (p1 - p0).hypot() / 2.0;
-    let pull = |p: Point, s: Option<Side>| p + s.map_or(Vec2::ZERO, |s| s.normal() * reach);
-    vec![p0, pull(p0, s0), pull(p1, s1), p1]
-}
-
-/// A right-angled route from `p0` to `p1`, leaving and arriving along the sides' normals (`s`; a
-/// free end follows the other): the short way when it keeps out of the attached objects' `boxes`,
-/// else the cheapest of a few ways around them (by length, and turns).
-fn elbow(p0: Point, s0: Option<Side>, p1: Point, s1: Option<Side>, boxes: &[Rect]) -> Vec<Point> {
-    let direct = tidy(short_elbow(p0, s0.map(Side::horizontal), p1, s1.map(Side::horizontal)));
-    let Some(all) = boxes.iter().copied().reduce(|a, b| a.union(b)) else { return direct };
-    if !crosses(&direct, boxes) {
-        return direct;
-    }
-    // Out of each end by ROOM, then across on one of a few lines: halfway, or clear of the objects.
-    let out = |p: Point, s: Option<Side>| p + s.map_or(Vec2::ZERO, |s| s.normal() * ROOM);
-    let (a, b) = (out(p0, s0), out(p1, s1));
-    let mut ways = vec![vec![p0, a, Point::new(b.x, a.y), b, p1], vec![p0, a, Point::new(a.x, b.y), b, p1]];
-    for x in [(a.x + b.x) / 2.0, all.x0 - ROOM, all.x1 + ROOM] {
-        ways.push(vec![p0, a, Point::new(x, a.y), Point::new(x, b.y), b, p1]);
-    }
-    for y in [(a.y + b.y) / 2.0, all.y0 - ROOM, all.y1 + ROOM] {
-        ways.push(vec![p0, a, Point::new(a.x, y), Point::new(b.x, y), b, p1]);
-    }
-    let cost = |r: &Vec<Point>| r.windows(2).map(|s| (s[1] - s[0]).hypot()).sum::<f64>() + ROOM * r.len() as f64;
-    ways.into_iter().map(tidy).filter(|r| !crosses(r, boxes)).min_by(|x, y| cost(x).total_cmp(&cost(y))).unwrap_or(direct)
-}
-
-/// Whether the right-angled route `pts` runs through the inside of any of `boxes` (along an edge,
-/// or out of one, is outside).
-fn crosses(pts: &[Point], boxes: &[Rect]) -> bool {
-    const EDGE: f64 = 0.5;
-    pts.windows(2).any(|s| {
-        let (a, b) = (s[0], s[1]);
-        boxes.iter().any(|r| a.x.min(b.x) < r.x1 - EDGE && a.x.max(b.x) > r.x0 + EDGE && a.y.min(b.y) < r.y1 - EDGE && a.y.max(b.y) > r.y0 + EDGE)
-    })
-}
-
-/// The short right-angled route from `p0` to `p1` (`h`: the side faces sideways; a free end
-/// follows the other): halfway across between two sides facing the same way, one turn otherwise.
-fn short_elbow(p0: Point, h0: Option<bool>, p1: Point, h1: Option<bool>) -> Vec<Point> {
-    let h0 = h0.or(h1).unwrap_or((p1.x - p0.x).abs() >= (p1.y - p0.y).abs());
-    let h1 = h1.unwrap_or(h0);
-    match (h0, h1) {
-        (true, true) => {
-            let mx = (p0.x + p1.x) / 2.0;
-            vec![p0, Point::new(mx, p0.y), Point::new(mx, p1.y), p1]
-        }
-        (false, false) => {
-            let my = (p0.y + p1.y) / 2.0;
-            vec![p0, Point::new(p0.x, my), Point::new(p1.x, my), p1]
-        }
-        (true, false) => vec![p0, Point::new(p1.x, p0.y), p1],
-        (false, true) => vec![p0, Point::new(p0.x, p1.y), p1],
-    }
-}
-
-// ---------------------------------------------------------------------------------------------
-// The board tools.
-
-impl Session {
-    /// A press with a board tool: place a sticky, shape or stamp, start a connector or a stroke,
-    /// or start erasing.
-    pub(crate) fn board_down(&mut self, ev: &PointerEvent) -> Result<()> {
-        // A board tool kept while a design file came to the front: back to Move for this press.
-        if !is_board(self.doc()?) {
-            self.tool.tool = ToolId::Move;
-            return self.pointer(ev);
-        }
-        // A sticky still being typed in ends first, so the next object is an undo step of its own.
-        if self.ds()?.text_edit.is_some() {
-            crate::textedit::end(self)?;
-        }
-        match self.tool.tool {
-            ToolId::Sticky => {
-                let half = STICKY / 2.0;
-                let r = self.execute("board.sticky", &json!({"x": ev.x - half, "y": ev.y - half}))?;
-                self.board_placed();
-                if let Some(id) = r.get("id").and_then(id_of) {
-                    edit_text(self, id)?;
-                }
-                Ok(())
-            }
-            ToolId::BoardShape => {
-                let half = SHAPE / 2.0;
-                self.execute("board.shape", &json!({"x": ev.x - half, "y": ev.y - half}))?;
-                self.board_placed();
-                Ok(())
-            }
-            ToolId::Stamp => {
-                // Stamps go on one after another: the tool stays.
-                self.execute("board.stamp", &json!({"x": ev.x, "y": ev.y}))?;
-                Ok(())
-            }
-            ToolId::Marker | ToolId::Highlighter => {
-                self.tool.gesture = Gesture::Pencil { points: vec![ev.p()], pressure: vec![ev.pressure] };
-                Ok(())
-            }
-            ToolId::Connector => {
-                let from = self.end_at(ev);
-                self.tool.gesture = Gesture::Connect { from, start: ev.p() };
-                Ok(())
-            }
-            ToolId::Eraser => {
-                self.begin_interaction("Erase")?;
-                self.tool.gesture = Gesture::Erase { gone: Vec::new() };
-                self.erase_at(ev)
-            }
-            _ => Ok(()),
-        }
-    }
-
-    /// After placing an object: back to the Move tool unless tools stay on.
-    fn board_placed(&mut self) {
-        if !self.prefs.keep_tool {
-            self.set_tool(ToolId::Move);
-        }
-    }
-
-    /// What a connector end at the pointer attaches to: the object there, or the point.
-    fn end_at(&self, ev: &PointerEvent) -> End {
-        let hit = (|| {
-            let doc = self.doc().ok()?;
-            let leaf = self.hit(doc, self.page().ok()?, ev.p(), 2.0 / ev.zoom.max(1e-6))?;
-            let t = figcraft_doc::geometry::select_target(doc, leaf, &[], false);
-            let n = doc.node(t)?;
-            (!matches!(n.board, Some(BoardItem::Connector(_)) | Some(BoardItem::Label { .. }) | Some(BoardItem::Ink))).then_some(t)
-        })();
-        match hit {
-            Some(node) => End::Node { node, side: Side::Auto },
-            None => End::Point { x: ev.x, y: ev.y },
-        }
-    }
-
-    pub(crate) fn connect_drag(&mut self, ev: &PointerEvent, from: End, start: Point) {
-        let a = match from {
-            End::Point { x, y } => Point::new(x, y),
-            End::Node { .. } => start,
-        };
-        self.tool.overlay.rubber = Some([a.x, a.y, ev.x, ev.y]);
-        self.tool.overlay.drop_target = from.node();
-        self.tool.gesture = Gesture::Connect { from, start };
-        if let Ok(ds) = self.ds_mut() {
-            ds.revision += 1;
-        }
-    }
-
-    pub(crate) fn connect_up(&mut self, ev: &PointerEvent, from: End, start: Point) -> Result<()> {
-        self.tool.overlay.rubber = None;
-        self.tool.overlay.drop_target = None;
-        // A click, not a drag: nothing to join.
-        if (ev.p() - start).hypot() * ev.zoom.max(1e-6) < 4.0 {
-            return Ok(());
-        }
-        let to = self.end_at(ev);
-        if to.node().is_some() && to.node() == from.node() {
-            return Ok(());
-        }
-        let style = self.tool.board.routing.id();
-        self.execute("board.connector", &json!({"from": end_json(from), "to": end_json(to), "style": style}))?;
-        self.board_placed();
-        Ok(())
-    }
-
-    /// Dragging the selected connector `id`'s end (`from`: its start): a line from its other end
-    /// to the pointer, and the object it would attach to outlined.
-    pub(crate) fn reattach_drag(&mut self, ev: &PointerEvent, id: NodeId, from: bool, start: Point) {
-        self.tool.gesture = Gesture::Reattach { id, from, start };
-        let Ok(doc) = self.doc() else { return };
-        let fixed = ends_now(doc, id).map(|(a, b)| if from { b } else { a });
-        let other = other_end(doc, id, from).and_then(|e| e.node());
-        self.tool.overlay.rubber = fixed.map(|f| [f.x, f.y, ev.x, ev.y]);
-        self.tool.overlay.drop_target = self.end_at(ev).node().filter(|n| Some(*n) != other);
-        if let Ok(ds) = self.ds_mut() {
-            ds.revision += 1;
-        }
-    }
-
-    /// The end let go: attached to the object under the pointer, or free there (`board.reattach`).
-    /// A click, or a drop on the object the other end is on, changes nothing.
-    pub(crate) fn reattach_up(&mut self, ev: &PointerEvent, id: NodeId, from: bool, start: Point) -> Result<()> {
-        self.tool.overlay.rubber = None;
-        if (ev.p() - start).hypot() * ev.zoom.max(1e-6) < 4.0 {
-            return Ok(());
-        }
-        let target = self.end_at(ev);
-        let other = other_end(self.doc()?, id, from).and_then(|e| e.node());
-        if target.node().is_some() && target.node() == other {
-            return Ok(());
-        }
-        self.execute("board.reattach", &json!({"id": id, "end": if from { "from" } else { "to" }, "target": end_json(target)}))?;
-        Ok(())
-    }
-
-    /// The eraser at the pointer: the marker and highlighter strokes it touches go (until the
-    /// gesture ends, which is one undo step).
-    pub(crate) fn erase_at(&mut self, ev: &PointerEvent) -> Result<()> {
-        let Gesture::Erase { mut gone } = std::mem::take(&mut self.tool.gesture) else { return Ok(()) };
-        let tol = ERASER_PX / ev.zoom.max(1e-6);
-        self.tool.overlay.brush = Some([ev.x, ev.y, tol]);
-        let (doc, page) = (self.doc()?.clone(), self.page()?);
-        if let Some(hit) =
-            doc.hit_test(page, ev.p(), tol, None).filter(|h| doc.node(*h).is_some_and(|n| n.board == Some(BoardItem::Ink)) && !gone.contains(h))
-        {
-            gone.push(hit);
-            let ids = gone.clone();
-            self.preview(|d, sel| {
-                for i in &ids {
-                    let _ = d.remove(*i);
-                }
-                sel.retain(|s| !ids.contains(s));
-                Ok(())
-            })?;
-        }
-        self.tool.gesture = Gesture::Erase { gone };
-        if let Ok(ds) = self.ds_mut() {
-            ds.revision += 1;
-        }
-        Ok(())
-    }
-
-    pub(crate) fn erase_up(&mut self) -> Result<()> {
-        self.tool.overlay.brush = None;
-        self.commit_interaction()
-    }
-
-    /// A finished marker or highlighter stroke (page points).
-    pub(crate) fn ink_finish(&mut self, path: &str) -> Result<()> {
-        let high = self.tool.tool == ToolId::Highlighter;
-        self.execute("board.ink", &json!({"path": path, "highlighter": high, "select": false}))?;
-        // Strokes come one after another: the selection stays as it was.
-        Ok(())
-    }
-}
-
-impl Session {
-    /// A double-click with the Move tool on a board object: type in its text (a connector gets a
-    /// label to type in). True when it was one.
-    pub(crate) fn board_double_click(&mut self, doc: &Document, leaf: NodeId, sel: &[NodeId]) -> Result<bool> {
-        let whole = figcraft_doc::geometry::select_target(doc, leaf, sel, false);
-        let editing = self.ds()?.text_edit.as_ref().is_some_and(|te| doc.is_ancestor(whole, te.id));
-        let Some(item) = doc.node(whole).and_then(|n| n.board.clone()).filter(|_| !editing) else { return Ok(false) };
-        self.tool.gesture = Gesture::None;
-        self.cancel_interaction()?;
-        match item {
-            BoardItem::Connector(_) => {
-                let label = match label_of(doc, whole) {
-                    Some(l) => l,
-                    None => {
-                        let r = self.execute("board.label", &json!({"id": whole, "text": "Label"}))?;
-                        r.get("label").and_then(id_of).ok_or_else(|| EngineError::Other("no label made".into()))?
-                    }
-                };
-                edit_text(self, label)
-            }
-            BoardItem::Table => crate::board_table::edit_cell(self, doc, leaf),
-            b if b.has_text() => edit_text(self, whole),
-            _ => Ok(false),
-        }
-    }
-}
diff --git a/crates/engine/src/boards/board/connectors.rs b/crates/engine/src/boards/board/connectors.rs
new file mode 100644
index 00000000..753550e5
--- /dev/null
+++ b/crates/engine/src/boards/board/connectors.rs
@@ -0,0 +1,147 @@
+use super::derived::{ends_now, place_route, route};
+use super::edit::set_label;
+use super::items::add;
+use super::*;
+
+/// One connector end from the params: a layer on this page, or a point.
+fn end_param(cmd: &str, s: &Session, p: &Value, key: &str, side_key: &str) -> Result<End> {
+    let side = match string(p, side_key) {
+        Some(v) => Side::from_id(&v).ok_or_else(|| bad(cmd, format!("`{side_key}` is auto, top, right, bottom or left")))?,
+        None => Side::Auto,
+    };
+    match get(p, key) {
+        Some(Value::Object(o)) if o.contains_key("x") => {
+            let (x, y) = (num(&Value::Object(o.clone()), "x"), num(&Value::Object(o.clone()), "y"));
+            match (x, y) {
+                (Some(x), Some(y)) if x.is_finite() && y.is_finite() => Ok(End::Point { x, y }),
+                _ => Err(bad(cmd, format!("`{key}` needs finite x and y"))),
+            }
+        }
+        Some(v) => {
+            let node = id_of(v).ok_or_else(|| bad(cmd, format!("`{key}` is a layer id or {{x, y}}")))?;
+            let doc = s.doc()?;
+            let n = doc.get(node)?;
+            if n.is_page() || doc.page_of(node) != Some(s.page()?) {
+                return Err(bad(cmd, format!("`{key}` must be a layer on this page")));
+            }
+            if matches!(n.board, Some(BoardItem::Connector(_))) {
+                return Err(bad(cmd, format!("`{key}` can't be another connector")));
+            }
+            Ok(End::Node { node, side })
+        }
+        None => Err(bad(cmd, format!("`{key}` is required"))),
+    }
+}
+
+pub(super) fn connector_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.connector";
+    require(s, cmd)?;
+    let from = end_param(cmd, s, p, "from", "fromSide")?;
+    let to = end_param(cmd, s, p, "to", "toSide")?;
+    if from.node().is_some() && from.node() == to.node() {
+        return Err(bad(cmd, "connect two different layers"));
+    }
+    let routing = match string(p, "style") {
+        Some(v) => routing_of(cmd, &v)?,
+        None => s.tool.board.routing,
+    };
+    let start = cap_of(cmd, p, "startCap")?.unwrap_or(StrokeCap::None);
+    let end = cap_of(cmd, p, "endCap")?.unwrap_or(StrokeCap::TriangleArrow);
+    let c = Connector { from, to, routing };
+    let page = s.page()?;
+    let doc = s.doc_mut()?;
+    let pts = route(doc, &c).ok_or_else(|| bad(cmd, "the ends can't be placed"))?;
+    if pts.windows(2).all(|w| w.first() == w.get(1)) {
+        return Err(bad(cmd, "the ends are in the same place"));
+    }
+    let id = add(doc, page, NodeKind::Vector { network: VectorNetwork::default() }, "Connector", (0.0, 0.0), (0.0, 0.0), |n| {
+        n.fills.clear();
+        n.strokes = vec![Paint::solid(LINE)];
+        n.stroke.weight = LINE_WEIGHT;
+        n.stroke.join = StrokeJoin::Round;
+        n.stroke.cap_start = start;
+        n.stroke.cap_end = end;
+        n.board = Some(BoardItem::Connector(c));
+    })?;
+    place_route(doc, id, &pts, routing);
+    let mut out = json!({"id": id});
+    if let Some(text) = string(p, "label").filter(|t| !t.trim().is_empty()) {
+        out["label"] = json!(set_label(doc, id, &text)?);
+    }
+    s.set_selection(vec![id]);
+    Ok(out)
+}
+
+/// The connector `id` names: a connector, or the label on one.
+pub(super) fn connector_of(cmd: &str, doc: &Document, id: NodeId) -> Result<(NodeId, Connector)> {
+    match doc.get(id)?.board.clone() {
+        Some(BoardItem::Connector(c)) => Ok((id, c)),
+        Some(BoardItem::Label { connector }) => match doc.get(connector)?.board.clone() {
+            Some(BoardItem::Connector(c)) => Ok((connector, c)),
+            _ => Err(bad(cmd, "that isn't a connector")),
+        },
+        _ => Err(bad(cmd, "that isn't a connector")),
+    }
+}
+
+pub(super) fn reattach(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.reattach";
+    require(s, cmd)?;
+    let id = req_targets(cmd, s, p)?.first().copied().ok_or_else(|| bad(cmd, "select a connector"))?;
+    let (id, mut c) = connector_of(cmd, s.doc()?, id)?;
+    let from = match string(p, "end").as_deref() {
+        Some("from") => true,
+        Some("to") => false,
+        _ => return Err(bad(cmd, "`end` is from or to")),
+    };
+    let end = end_param(cmd, s, p, "target", "side")?;
+    let other = if from { c.to } else { c.from };
+    if end.node().is_some() && end.node() == other.node() {
+        return Err(bad(cmd, "connect two different layers"));
+    }
+    *(if from { &mut c.from } else { &mut c.to }) = end;
+    let doc = s.doc_mut()?;
+    let pts = route(doc, &c).ok_or_else(|| bad(cmd, "the ends can't be placed"))?;
+    if pts.windows(2).all(|w| w.first() == w.get(1)) {
+        return Err(bad(cmd, "the ends are in the same place"));
+    }
+    doc.get_mut(id)?.board = Some(BoardItem::Connector(c));
+    place_route(doc, id, &pts, c.routing);
+    Ok(json!({"id": id}))
+}
+
+/// A connector end as `board.connector` and `board.reattach` take it.
+pub(super) fn end_json(e: End) -> Value {
+    match e {
+        End::Node { node, .. } => json!(node),
+        End::Point { x, y } => json!({"x": x, "y": y}),
+    }
+}
+
+/// The end of connector `id` that stays while its other one (`from`: its start) is dragged.
+pub(super) fn other_end(doc: &Document, id: NodeId, from: bool) -> Option<End> {
+    match &doc.node(id)?.board {
+        Some(BoardItem::Connector(c)) => Some(if from { c.to } else { c.from }),
+        _ => None,
+    }
+}
+
+/// The selected connector (one, alone and unlocked) and its two ends on the page as drawn.
+pub fn selected_connector_ends(doc: &Document, sel: &[NodeId]) -> Option<(NodeId, [Point; 2])> {
+    let [id] = sel else { return None };
+    if !matches!(doc.node(*id)?.board, Some(BoardItem::Connector(_))) || crate::tools::locked_in(doc, *id) {
+        return None;
+    }
+    let (a, b) = ends_now(doc, *id)?;
+    Some((*id, [a, b]))
+}
+
+/// How near (screen pixels) a press must be to a selected connector's end to drag it.
+pub const END_HANDLE_PX: f64 = 8.0;
+
+/// The selected connector's end under `p` at `zoom`, nearest first (`true`: its start).
+pub(crate) fn end_handle_at(doc: &Document, sel: &[NodeId], p: Point, zoom: f64) -> Option<(NodeId, bool)> {
+    let (id, [a, b]) = selected_connector_ends(doc, sel)?;
+    let (da, db) = ((a - p).hypot(), (b - p).hypot());
+    (da.min(db) * zoom.max(1e-6) <= END_HANDLE_PX).then_some((id, da <= db))
+}
diff --git a/crates/engine/src/boards/board/derived.rs b/crates/engine/src/boards/board/derived.rs
new file mode 100644
index 00000000..ac73df1e
--- /dev/null
+++ b/crates/engine/src/boards/board/derived.rs
@@ -0,0 +1,339 @@
+use super::edit::set_font_size;
+use super::items::{owner_of_text, shape_padding, sticky_font_size, text_of};
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Derived data (the normalize pass).
+
+/// Before text is measured: a sticky's note takes the size its length calls for, and a resized
+/// shape keeps its text inside its outline.
+pub(crate) fn settle_text(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
+    if !is_board(doc) {
+        return;
+    }
+    for &id in touched {
+        let Some(n) = doc.node(id) else { continue };
+        if let Some(owner) =
+            owner_of_text(doc, id).or(Some(id)).filter(|o| doc.node(*o).is_some_and(|k| matches!(k.board, Some(BoardItem::Sticky { .. }))))
+            && let Some(t) = text_of(doc, owner)
+            && let Some(NodeKind::Text(td)) = doc.node(t).map(|k| &k.kind)
+        {
+            let size = sticky_font_size(&td.characters);
+            let off = td.style.font_size != size || td.runs.iter().any(|r| r.style.font_size != size);
+            if off && let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|k| &mut k.kind) {
+                set_font_size(td, size);
+            }
+            continue;
+        }
+        if let Some(BoardItem::Shape { shape }) = n.board
+            && before.node(id).is_none_or(|b| (b.width, b.height) != (n.width, n.height))
+        {
+            let pad = shape_padding(shape, n.width, n.height);
+            if n.layout.as_ref().is_some_and(|l| l.padding != pad)
+                && let Some(l) = doc.node_mut(id).and_then(|k| k.layout.as_mut())
+            {
+                l.padding = pad;
+            }
+        }
+    }
+}
+
+/// After layout: connectors run between their ends again (an end whose layer is gone stays where
+/// it was), one moved on its own takes its free ends along, and labels sit at their middles. Only
+/// the connectors and labels an edit can have moved are looked at: touched themselves, or with a
+/// touched (or gone) end, connector or layer around them.
+pub(crate) fn settle_routes(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
+    if !is_board(doc) || touched.is_empty() {
+        return;
+    }
+    let hit = |doc: &Document, id: NodeId| touched.contains(&id) || doc.ancestors(id).iter().any(|a| touched.contains(a));
+    let (mut connectors, mut labels) = (Vec::new(), Vec::new());
+    for n in doc.nodes() {
+        match &n.board {
+            Some(BoardItem::Connector(c)) => {
+                let ends = [c.from.node(), c.to.node()].into_iter().flatten();
+                if hit(doc, n.id) || ends.into_iter().any(|e| !doc.contains(e) || hit(doc, e)) {
+                    connectors.push((n.id, *c));
+                }
+            }
+            Some(BoardItem::Label { connector }) => labels.push((n.id, *connector)),
+            _ => {}
+        }
+    }
+    let rerouted: BTreeSet<NodeId> = connectors.iter().map(|(id, _)| *id).collect();
+    for (id, mut c) in connectors {
+        let changed = detach_gone_ends(doc, id, &mut c) | carry_free_ends(doc, before, touched, id, &mut c);
+        if changed && let Some(n) = doc.node_mut(id) {
+            n.board = Some(BoardItem::Connector(c));
+        }
+        if let Some(pts) = route(doc, &c) {
+            place_route(doc, id, &pts, c.routing);
+        }
+    }
+    for (label, connector) in labels {
+        if rerouted.contains(&connector) || touched.contains(&connector) || hit(doc, label) {
+            place_label(doc, label, connector);
+        }
+    }
+}
+
+/// The ends of connector `id` (as `c`) whose layer is gone or on another page stay where they are
+/// drawn, as points. Whether any did.
+fn detach_gone_ends(doc: &Document, id: NodeId, c: &mut Connector) -> bool {
+    let (page, ends) = (doc.page_of(id), ends_now(doc, id));
+    let mut detached = false;
+    for (end, at) in [(&mut c.from, ends.map(|e| e.0)), (&mut c.to, ends.map(|e| e.1))] {
+        if let (End::Node { node, .. }, Some(p)) = (*end, at)
+            && (!doc.contains(node) || doc.page_of(node) != page)
+        {
+            *end = End::Point { x: p.x, y: p.y };
+            detached = true;
+        }
+    }
+    detached
+}
+
+/// Connector `id` (as `c`) moved by itself (a drag, a nudge: its place changed but not what it
+/// joins): its free ends move with it. Whether they did.
+fn carry_free_ends(doc: &Document, before: &Document, touched: &BTreeSet<NodeId>, id: NodeId, c: &mut Connector) -> bool {
+    let (Some(b), Some(n)) = (before.node(id), doc.node(id)) else { return false };
+    if !touched.contains(&id) || b.transform == n.transform || b.board != n.board {
+        return false;
+    }
+    let Some(expected) = route(doc, c).and_then(|pts| finite_box(&route_path(&pts, c.routing))).map(|b| b.origin()) else { return false };
+    let d = (doc.world_transform(id) * Point::ZERO) - expected;
+    if d.hypot() <= 1e-9 {
+        return false;
+    }
+    let mut moved = false;
+    for end in [&mut c.from, &mut c.to] {
+        if let End::Point { x, y } = end {
+            (*x, *y) = (*x + d.x, *y + d.y);
+            moved = true;
+        }
+    }
+    moved
+}
+
+/// Label `label` at the middle of connector `connector`; gone with it when it is gone.
+fn place_label(doc: &mut Document, label: NodeId, connector: NodeId) {
+    let Some(mid) = doc.node(connector).and_then(|_| route_mid(doc, connector)) else {
+        let _ = doc.remove(label);
+        return;
+    };
+    let Some(n) = doc.node(label) else { return };
+    let pw = n.parent.map_or(Affine::IDENTITY, |p| doc.world_transform(p));
+    let local = pw.inverse() * mid;
+    let t = Affine::translate((local.x - n.width / 2.0, local.y - n.height / 2.0));
+    if n.transform != t
+        && let Some(n) = doc.node_mut(label)
+    {
+        n.transform = t;
+    }
+}
+
+/// Connector `id`'s first and last points on the page as it is drawn now.
+pub(super) fn ends_now(doc: &Document, id: NodeId) -> Option<(Point, Point)> {
+    let NodeKind::Vector { network } = &doc.node(id)?.kind else { return None };
+    let w = doc.world_transform(id);
+    Some((w * network.vertices.first()?.point(), w * network.vertices.last()?.point()))
+}
+
+/// The middle of connector `id`'s route by length, on the page.
+fn route_mid(doc: &Document, id: NodeId) -> Option<Point> {
+    let NodeKind::Vector { network } = &doc.node(id)?.kind else { return None };
+    let w = doc.world_transform(id);
+    let mut pts: Vec<Point> = Vec::new();
+    figcraft_geom::kurbo::flatten(network.stroke_path().iter(), 0.25, |el| {
+        if let PathEl::MoveTo(p) | PathEl::LineTo(p) = el {
+            pts.push(w * p);
+        }
+    });
+    let total: f64 = pts.windows(2).map(|s| (s[1] - s[0]).hypot()).sum();
+    let mut left = total / 2.0;
+    for s in pts.windows(2) {
+        let (a, b) = (s[0], s[1]);
+        let l = (b - a).hypot();
+        if l >= left && l > 0.0 {
+            return Some(a.lerp(b, left / l));
+        }
+        left -= l;
+    }
+    pts.first().copied()
+}
+
+/// The path through a route's page points `pts` (see [`route`]): one curve for a curved
+/// connector, straight runs otherwise.
+fn route_path(pts: &[Point], routing: Routing) -> BezPath {
+    let mut path = BezPath::new();
+    match (routing, pts) {
+        (Routing::Curved, [p0, c0, c1, p1]) => {
+            path.move_to(*p0);
+            path.curve_to(*c0, *c1, *p1);
+        }
+        _ => {
+            for (i, p) in pts.iter().enumerate() {
+                if i == 0 { path.move_to(*p) } else { path.line_to(*p) }
+            }
+        }
+    }
+    path
+}
+
+/// The box a path is drawn in, when it is finite.
+fn finite_box(path: &BezPath) -> Option<Rect> {
+    let b = path.bounding_box();
+    (b.x0.is_finite() && b.y0.is_finite() && b.x1.is_finite() && b.y1.is_finite()).then_some(b)
+}
+
+/// Write the route `pts` (page points, see [`route`]) into connector `id`: its box, place and
+/// path. Untouched when it already runs there, so a connector that didn't move isn't an edit.
+pub(super) fn place_route(doc: &mut Document, id: NodeId, pts: &[Point], routing: Routing) {
+    let Some(n) = doc.node(id) else { return };
+    let pw = n.parent.map_or(Affine::IDENTITY, |p| doc.world_transform(p));
+    let local = pw.inverse() * route_path(pts, routing);
+    let Some(b) = finite_box(&local) else { return };
+    let rel = Affine::translate((-b.x0, -b.y0)) * local;
+    let network = match routing {
+        Routing::Curved => VectorNetwork::from_path(&rel),
+        _ => VectorNetwork::from_points(&rel.elements().iter().filter_map(PathEl::end_point).collect::<Vec<_>>(), false),
+    };
+    let t = Affine::translate((b.x0, b.y0));
+    let same =
+        n.transform == t && n.width == b.width() && n.height == b.height() && matches!(&n.kind, NodeKind::Vector { network: old } if *old == network);
+    if same {
+        return;
+    }
+    if let Some(n) = doc.node_mut(id) {
+        n.kind = NodeKind::Vector { network };
+        n.transform = t;
+        (n.width, n.height) = (b.width(), b.height());
+    }
+}
+
+/// How far an elbow connector going around the objects it joins keeps from them.
+const ROOM: f64 = 24.0;
+
+/// The page points connector `c` runs through: from the middle of the side of each attached layer
+/// facing the other end (or the side it names), straight, in right angles, or (curved) its two
+/// ends with the curve's two control points between them.
+pub fn route(doc: &Document, c: &Connector) -> Option<Vec<Point>> {
+    let bounds = |e: &End| e.node().and_then(|n| doc.world_bounds(n));
+    let centre = |e: &End, b: Option<Rect>| match e {
+        End::Point { x, y } => Some(Point::new(*x, *y)),
+        End::Node { .. } => b.map(|b| b.center()),
+    };
+    let (fb, tb) = (bounds(&c.from), bounds(&c.to));
+    let (fc, tc) = (centre(&c.from, fb)?, centre(&c.to, tb)?);
+    let (p0, s0) = attach(&c.from, fb, tc)?;
+    let (p1, s1) = attach(&c.to, tb, fc)?;
+    let pts = match c.routing {
+        Routing::Straight => tidy(vec![p0, p1]),
+        Routing::Elbow => elbow(p0, s0, p1, s1, &[fb, tb].into_iter().flatten().collect::<Vec<_>>()),
+        Routing::Curved => curve(p0, s0, p1, s1),
+    };
+    pts.iter().all(|p| p.x.is_finite() && p.y.is_finite()).then_some(pts)
+}
+
+/// `pts` without repeats or turns that don't turn (three in a line across or down).
+fn tidy(pts: Vec<Point>) -> Vec<Point> {
+    let mut out: Vec<Point> = Vec::with_capacity(pts.len());
+    for p in pts {
+        if out.last() == Some(&p) {
+            continue;
+        }
+        if let [.., a, b] = out.as_slice()
+            && ((a.x == b.x && b.x == p.x) || (a.y == b.y && b.y == p.y))
+        {
+            out.pop();
+        }
+        out.push(p);
+    }
+    out
+}
+
+/// Where end `e` attaches (its point, or the middle of its layer's side facing `other`) and that
+/// side (`None`: a free point).
+fn attach(e: &End, b: Option<Rect>, other: Point) -> Option<(Point, Option<Side>)> {
+    match e {
+        End::Point { x, y } => Some((Point::new(*x, *y), None)),
+        End::Node { side, .. } => {
+            let b = b?;
+            let side = match side {
+                Side::Auto => {
+                    let d = other - b.center();
+                    // Compare against the box's proportions: a wide box takes the sides more.
+                    if d.x.abs() * b.height().max(1e-9) >= d.y.abs() * b.width().max(1e-9) {
+                        if d.x >= 0.0 { Side::Right } else { Side::Left }
+                    } else if d.y >= 0.0 {
+                        Side::Bottom
+                    } else {
+                        Side::Top
+                    }
+                }
+                s => *s,
+            };
+            Some((side.point(b), Some(side)))
+        }
+    }
+}
+
+/// A curve from `p0` to `p1` leaving and arriving along the sides' normals (a free end pulls no
+/// way): the ends and the two control points between them.
+fn curve(p0: Point, s0: Option<Side>, p1: Point, s1: Option<Side>) -> Vec<Point> {
+    let reach = (p1 - p0).hypot() / 2.0;
+    let pull = |p: Point, s: Option<Side>| p + s.map_or(Vec2::ZERO, |s| s.normal() * reach);
+    vec![p0, pull(p0, s0), pull(p1, s1), p1]
+}
+
+/// A right-angled route from `p0` to `p1`, leaving and arriving along the sides' normals (`s`; a
+/// free end follows the other): the short way when it keeps out of the attached objects' `boxes`,
+/// else the cheapest of a few ways around them (by length, and turns).
+fn elbow(p0: Point, s0: Option<Side>, p1: Point, s1: Option<Side>, boxes: &[Rect]) -> Vec<Point> {
+    let direct = tidy(short_elbow(p0, s0.map(Side::horizontal), p1, s1.map(Side::horizontal)));
+    let Some(all) = boxes.iter().copied().reduce(|a, b| a.union(b)) else { return direct };
+    if !crosses(&direct, boxes) {
+        return direct;
+    }
+    // Out of each end by ROOM, then across on one of a few lines: halfway, or clear of the objects.
+    let out = |p: Point, s: Option<Side>| p + s.map_or(Vec2::ZERO, |s| s.normal() * ROOM);
+    let (a, b) = (out(p0, s0), out(p1, s1));
+    let mut ways = vec![vec![p0, a, Point::new(b.x, a.y), b, p1], vec![p0, a, Point::new(a.x, b.y), b, p1]];
+    for x in [(a.x + b.x) / 2.0, all.x0 - ROOM, all.x1 + ROOM] {
+        ways.push(vec![p0, a, Point::new(x, a.y), Point::new(x, b.y), b, p1]);
+    }
+    for y in [(a.y + b.y) / 2.0, all.y0 - ROOM, all.y1 + ROOM] {
+        ways.push(vec![p0, a, Point::new(a.x, y), Point::new(b.x, y), b, p1]);
+    }
+    let cost = |r: &Vec<Point>| r.windows(2).map(|s| (s[1] - s[0]).hypot()).sum::<f64>() + ROOM * r.len() as f64;
+    ways.into_iter().map(tidy).filter(|r| !crosses(r, boxes)).min_by(|x, y| cost(x).total_cmp(&cost(y))).unwrap_or(direct)
+}
+
+/// Whether the right-angled route `pts` runs through the inside of any of `boxes` (along an edge,
+/// or out of one, is outside).
+fn crosses(pts: &[Point], boxes: &[Rect]) -> bool {
+    const EDGE: f64 = 0.5;
+    pts.windows(2).any(|s| {
+        let (a, b) = (s[0], s[1]);
+        boxes.iter().any(|r| a.x.min(b.x) < r.x1 - EDGE && a.x.max(b.x) > r.x0 + EDGE && a.y.min(b.y) < r.y1 - EDGE && a.y.max(b.y) > r.y0 + EDGE)
+    })
+}
+
+/// The short right-angled route from `p0` to `p1` (`h`: the side faces sideways; a free end
+/// follows the other): halfway across between two sides facing the same way, one turn otherwise.
+fn short_elbow(p0: Point, h0: Option<bool>, p1: Point, h1: Option<bool>) -> Vec<Point> {
+    let h0 = h0.or(h1).unwrap_or((p1.x - p0.x).abs() >= (p1.y - p0.y).abs());
+    let h1 = h1.unwrap_or(h0);
+    match (h0, h1) {
+        (true, true) => {
+            let mx = (p0.x + p1.x) / 2.0;
+            vec![p0, Point::new(mx, p0.y), Point::new(mx, p1.y), p1]
+        }
+        (false, false) => {
+            let my = (p0.y + p1.y) / 2.0;
+            vec![p0, Point::new(p0.x, my), Point::new(p1.x, my), p1]
+        }
+        (true, false) => vec![p0, Point::new(p1.x, p0.y), p1],
+        (false, true) => vec![p0, Point::new(p0.x, p1.y), p1],
+    }
+}
diff --git a/crates/engine/src/boards/board/edit.rs b/crates/engine/src/boards/board/edit.rs
new file mode 100644
index 00000000..1770852c
--- /dev/null
+++ b/crates/engine/src/boards/board/edit.rs
@@ -0,0 +1,260 @@
+use super::connectors::connector_of;
+use super::derived::ends_now;
+use super::items::{add, add_text, shape_padding, text_of};
+use super::*;
+
+/// The label of connector `id`, if it has one.
+pub fn label_of(doc: &Document, id: NodeId) -> Option<NodeId> {
+    let parent = doc.node(id)?.parent?;
+    doc.node(parent)?.children.iter().copied().find(|c| doc.node(*c).is_some_and(|n| n.board == Some(BoardItem::Label { connector: id })))
+}
+
+/// Give connector `id` the label `text` (empty removes it); the label's id.
+pub(super) fn set_label(doc: &mut Document, id: NodeId, text: &str) -> Result<Option<NodeId>> {
+    let existing = label_of(doc, id);
+    if text.trim().is_empty() {
+        if let Some(l) = existing {
+            doc.remove(l)?;
+        }
+        return Ok(None);
+    }
+    if let Some(l) = existing {
+        if let Some(t) = text_of(doc, l)
+            && let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|n| &mut n.kind)
+        {
+            let len = td.char_count();
+            td.replace_range(0, len, text);
+        }
+        return Ok(Some(l));
+    }
+    let parent = doc.node(id).and_then(|n| n.parent).ok_or(DocError::NoNode(id))?;
+    let l = add(doc, parent, NodeKind::Frame, "Label", (0.0, 0.0), (40.0, 24.0), |n| {
+        n.fills = vec![Paint::solid(Color::WHITE)];
+        n.corners.radii = [4.0; 4];
+        n.clip = false;
+        n.layout = Some(AutoLayout { padding: [3.0, 6.0, 3.0, 6.0], ..AutoLayout::default() });
+        n.child_layout.sizing_h = Sizing::Hug;
+        n.child_layout.sizing_v = Sizing::Hug;
+        n.board = Some(BoardItem::Label { connector: id });
+    })?;
+    let t = add_text(doc, l, text, 12.0, INK, TextAlignH::Center, 40.0)?;
+    if let Some(n) = doc.node_mut(t)
+        && let NodeKind::Text(td) = &mut n.kind
+    {
+        // The label hugs its text: one line per paragraph.
+        td.auto_resize = TextAutoResize::WidthAndHeight;
+        n.child_layout.sizing_h = Sizing::Hug;
+    }
+    Ok(Some(l))
+}
+
+pub(super) fn label_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.label";
+    require(s, cmd)?;
+    let id = req_targets(cmd, s, p)?.first().copied().ok_or_else(|| bad(cmd, "select a connector"))?;
+    let (id, _) = connector_of(cmd, s.doc()?, id)?;
+    let text = req_string(cmd, p, "text")?;
+    let label = set_label(s.doc_mut()?, id, &text)?;
+    Ok(json!({"id": id, "label": label}))
+}
+
+/// The board objects among `ids`, each with its item (a label counts as its connector's text).
+fn items(doc: &Document, ids: &[NodeId]) -> Vec<(NodeId, BoardItem)> {
+    ids.iter().filter_map(|i| doc.node(*i).and_then(|n| n.board.clone()).map(|b| (*i, b))).collect()
+}
+
+pub(super) fn set_color(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.setColor";
+    require(s, cmd)?;
+    let ids = req_targets(cmd, s, p)?;
+    let color = color_param(cmd, p)?.ok_or_else(|| bad(cmd, "`color` is required"))?;
+    let doc = s.doc_mut()?;
+    let mut changed = Vec::new();
+    for (id, item) in items(doc, &ids) {
+        match item {
+            BoardItem::Sticky { .. } => doc.get_mut(id)?.fills = vec![Paint::solid(color)],
+            BoardItem::Shape { .. } => {
+                let Some(outline) = doc.get(id)?.children.first().copied() else { continue };
+                let n = doc.get_mut(outline)?;
+                n.fills = vec![Paint::solid(color)];
+                n.strokes = vec![Paint::solid(line_shade(color))];
+            }
+            BoardItem::Connector(_) | BoardItem::Ink => doc.get_mut(id)?.strokes = vec![Paint::solid(line_shade(color))],
+            BoardItem::Label { .. } | BoardItem::Stamp { .. } | BoardItem::Table => continue,
+        }
+        changed.push(id);
+    }
+    if changed.is_empty() {
+        return Err(bad(cmd, "select stickies, shapes, connectors or ink"));
+    }
+    Ok(json!({"ids": changed}))
+}
+
+/// What `board.setStyle` changes (each `None` leaves it).
+struct Restyle {
+    shape: Option<BoardShape>,
+    routing: Option<Routing>,
+    size: Option<f64>,
+    start: Option<StrokeCap>,
+    end: Option<StrokeCap>,
+}
+
+impl Restyle {
+    fn of(cmd: &str, p: &Value) -> Result<Restyle> {
+        let size = num(p, "fontSize")
+            .map(|v| if v.is_finite() && (1.0..=1000.0).contains(&v) { Ok(v) } else { Err(bad(cmd, "`fontSize` is from 1 to 1000")) })
+            .transpose()?;
+        Ok(Restyle {
+            shape: string(p, "shape").map(|v| shape_of(cmd, &v)).transpose()?,
+            routing: string(p, "style").map(|v| routing_of(cmd, &v)).transpose()?,
+            size,
+            start: cap_of(cmd, p, "startCap")?,
+            end: cap_of(cmd, p, "endCap")?,
+        })
+    }
+
+    /// Restyle board object `id` (`item`); whether anything about it changed.
+    fn apply(&self, doc: &mut Document, id: NodeId, item: BoardItem) -> Result<bool> {
+        let changed = match item {
+            BoardItem::Shape { shape } => match self.shape.filter(|n| *n != shape) {
+                Some(new) => {
+                    reshape(doc, id, new)?;
+                    true
+                }
+                None => false,
+            },
+            BoardItem::Connector(c) => self.restyle_connector(doc, id, c)?,
+            _ => false,
+        };
+        // Text sizes: shapes' and labels' text (stickies size theirs to fit).
+        let sized = match (self.size, &item) {
+            (Some(size), BoardItem::Shape { .. } | BoardItem::Label { .. }) => resize_text(doc, id, size),
+            _ => false,
+        };
+        Ok(changed || sized)
+    }
+
+    fn restyle_connector(&self, doc: &mut Document, id: NodeId, mut c: Connector) -> Result<bool> {
+        let n = doc.get_mut(id)?;
+        if let Some(r) = self.routing {
+            c.routing = r;
+            n.board = Some(BoardItem::Connector(c));
+        }
+        if let Some(cap) = self.start {
+            n.stroke.cap_start = cap;
+        }
+        if let Some(cap) = self.end {
+            n.stroke.cap_end = cap;
+        }
+        Ok(self.routing.is_some() || self.start.is_some() || self.end.is_some())
+    }
+}
+
+/// Shape with text `id` takes outline `new` (its text room too).
+fn reshape(doc: &mut Document, id: NodeId, new: BoardShape) -> Result<()> {
+    let n = doc.get_mut(id)?;
+    n.board = Some(BoardItem::Shape { shape: new });
+    n.name = new.label().into();
+    let (w, h) = (n.width, n.height);
+    if let Some(l) = n.layout.as_mut() {
+        l.padding = shape_padding(new, w, h);
+    }
+    if let Some(o) = doc.get(id)?.children.first().copied()
+        && let Some(on) = doc.node_mut(o)
+    {
+        on.kind = NodeKind::Vector { network: VectorNetwork::from_path(&new.path(w, h)) };
+        (on.width, on.height, on.transform) = (w, h, Affine::IDENTITY);
+    }
+    Ok(())
+}
+
+/// Board object `id`'s text at `size`; whether it has text.
+fn resize_text(doc: &mut Document, id: NodeId, size: f64) -> bool {
+    let Some(t) = text_of(doc, id) else { return false };
+    if let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|n| &mut n.kind) {
+        set_font_size(td, size);
+        return true;
+    }
+    false
+}
+
+pub(super) fn set_style(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.setStyle";
+    require(s, cmd)?;
+    let ids = req_targets(cmd, s, p)?;
+    let restyle = Restyle::of(cmd, p)?;
+    let doc = s.doc_mut()?;
+    let mut changed = Vec::new();
+    for (id, item) in items(doc, &ids) {
+        if restyle.apply(doc, id, item)? {
+            changed.push(id);
+        }
+    }
+    if changed.is_empty() {
+        return Err(bad(cmd, "nothing selected takes these (shapes with text, connectors, labels)"));
+    }
+    Ok(json!({"ids": changed}))
+}
+
+pub(super) fn set_font_size(td: &mut TextData, size: f64) {
+    td.style.font_size = size;
+    for r in &mut td.runs {
+        r.style.font_size = size;
+    }
+}
+
+/// Each layer of `sources` (copied one by one, in order, as `copies`) and its copy: the whole
+/// subtrees pair up when they have the same shape (an instance made of a main component may not;
+/// then only the roots do).
+pub(crate) fn copy_map(doc: &Document, sources: &[NodeId], copies: &[NodeId]) -> BTreeMap<NodeId, NodeId> {
+    let mut map = BTreeMap::new();
+    for (s, c) in sources.iter().zip(copies) {
+        let (a, b) = (doc.subtree(*s), doc.subtree(*c));
+        if a.len() == b.len() {
+            map.extend(a.into_iter().zip(b));
+        } else {
+            map.insert(*s, *c);
+        }
+    }
+    map
+}
+
+/// The connectors and labels among copied layers, as `(copy, the original's board item)`, from the
+/// originals in `doc` (`map`: original → copy).
+pub(crate) fn copied_items(doc: &Document, map: &BTreeMap<NodeId, NodeId>) -> Vec<(NodeId, BoardItem)> {
+    map.iter().filter_map(|(o, c)| doc.node(*o).and_then(|n| n.board.clone()).map(|b| (*c, b))).collect()
+}
+
+/// After a copy (`map`: each copied original → its copy; `originals`: the copies' items as the
+/// originals had them), copied connectors join the copies of what they joined and labels follow
+/// the copies of their connectors. From another file (`foreign`), what wasn't copied isn't here: a
+/// connector's end there stays where it is drawn, as a point, and a label without its connector
+/// goes.
+pub(crate) fn rejoin(doc: &mut Document, originals: &[(NodeId, BoardItem)], map: &BTreeMap<NodeId, NodeId>, foreign: bool) {
+    for (copy, item) in originals {
+        let mut item = item.clone();
+        let copied = |n: NodeId| map.contains_key(&n);
+        match &mut item {
+            BoardItem::Connector(c) if foreign => {
+                let ends = ends_now(doc, *copy);
+                for (end, at) in [(&mut c.from, ends.map(|e| e.0)), (&mut c.to, ends.map(|e| e.1))] {
+                    if let (End::Node { node, .. }, Some(p)) = (*end, at)
+                        && !copied(node)
+                    {
+                        *end = End::Point { x: p.x, y: p.y };
+                    }
+                }
+            }
+            BoardItem::Label { connector } if foreign && !copied(*connector) => {
+                let _ = doc.remove(*copy);
+                continue;
+            }
+            BoardItem::Connector(_) | BoardItem::Label { .. } => {}
+            _ => continue,
+        }
+        item.remap(map);
+        if let Some(n) = doc.node_mut(*copy) {
+            n.board = Some(item);
+        }
+    }
+}
diff --git a/crates/engine/src/boards/board/items.rs b/crates/engine/src/boards/board/items.rs
new file mode 100644
index 00000000..6d96d34b
--- /dev/null
+++ b/crates/engine/src/boards/board/items.rs
@@ -0,0 +1,297 @@
+use super::*;
+
+/// A new layer at the top of `parent`, at `at` in it, made by `f`.
+pub(super) fn add(
+    doc: &mut Document,
+    parent: NodeId,
+    kind: NodeKind,
+    name: &str,
+    at: (f64, f64),
+    size: (f64, f64),
+    f: impl FnOnce(&mut Node),
+) -> Result<NodeId> {
+    let id = doc.alloc_id();
+    let mut n = Node::new(id, kind, name, size.0, size.1);
+    n.transform = Affine::translate(at);
+    f(&mut n);
+    doc.insert(n, parent, None)?;
+    Ok(id)
+}
+
+/// A soft shadow under stickies and stamps.
+fn soft_shadow() -> Effect {
+    Effect {
+        kind: EffectKind::DropShadow(Shadow { color: Color::new(0.0, 0.0, 0.0, 0.16), offset: (0.0, 2.0), radius: 6.0, ..Shadow::default() }),
+        visible: true,
+    }
+}
+
+/// A text layer filling its frame's width (the frame's auto layout places it).
+pub(crate) fn add_text(doc: &mut Document, parent: NodeId, text: &str, size: f64, color: Color, align: TextAlignH, width: f64) -> Result<NodeId> {
+    let first: String = text.lines().next().unwrap_or("").chars().take(64).collect();
+    let name = if first.trim().is_empty() { "Text" } else { first.as_str() };
+    let mut td = TextData {
+        characters: crate::cmd::props::normalize_line_endings(text),
+        auto_resize: TextAutoResize::Height,
+        align_h: align,
+        ..TextData::default()
+    };
+    td.style.font_size = size;
+    let id = add(doc, parent, NodeKind::Text(td), name, (0.0, 0.0), (width.max(1.0), size * 1.4), |n| {
+        n.fills = vec![Paint::solid(color)];
+        n.child_layout.sizing_h = Sizing::Fill;
+    })?;
+    if let Some(n) = doc.node(id)
+        && let Some((w, h)) = figcraft_text::auto_size(n)
+        && let Some(n) = doc.node_mut(id)
+    {
+        (n.width, n.height) = (w, h);
+    }
+    Ok(id)
+}
+
+/// The text size a sticky's note gets: smaller the more it holds (by characters and lines, so
+/// every copy of the file picks the same size whatever fonts it has).
+pub fn sticky_font_size(text: &str) -> f64 {
+    let weight = text.chars().count() + 24 * text.matches('\n').count();
+    match weight {
+        0..=24 => 24.0,
+        25..=64 => 20.0,
+        65..=140 => 16.0,
+        141..=280 => 13.0,
+        _ => 11.0,
+    }
+}
+
+/// A sticky note's layers: the frame, the note and (when known) its author.
+fn make_sticky(doc: &mut Document, parent: NodeId, at: (f64, f64), text: &str, color: Color, author: &str) -> Result<(NodeId, NodeId)> {
+    let id = add(doc, parent, NodeKind::Frame, "Sticky", at, (STICKY, STICKY), |n| {
+        n.fills = vec![Paint::solid(color)];
+        n.corners.radii = [2.0; 4];
+        n.effects = vec![soft_shadow()];
+        n.clip = false;
+        n.layout = Some(AutoLayout {
+            mode: LayoutMode::Vertical,
+            gap: 8.0,
+            padding: [STICKY_PAD; 4],
+            main_align: MainAlign::SpaceBetween,
+            ..AutoLayout::default()
+        });
+        n.child_layout.sizing_v = Sizing::Hug;
+        n.child_layout.min_h = Some(STICKY);
+        n.board = Some(BoardItem::Sticky { author: author.to_string() });
+    })?;
+    let inner = STICKY - 2.0 * STICKY_PAD;
+    let note = add_text(doc, id, text, sticky_font_size(text), INK, TextAlignH::Left, inner)?;
+    if !author.is_empty() {
+        let a = add_text(doc, id, author, 10.0, AUTHOR_INK, TextAlignH::Left, inner)?;
+        if let Some(n) = doc.node_mut(a) {
+            n.name = "Author".into();
+        }
+    }
+    Ok((id, note))
+}
+
+pub(super) fn sticky_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.sticky";
+    require(s, cmd)?;
+    let color = color_param(cmd, p)?.unwrap_or(s.tool.board.sticky);
+    let author = match get(p, "author") {
+        Some(Value::String(a)) => a.trim().chars().filter(|c| !c.is_control()).take(64).collect(),
+        Some(Value::Bool(false)) => String::new(),
+        _ => author(s),
+    };
+    let parent = parent_of(cmd, s, p)?;
+    let text = string(p, "text").unwrap_or_default();
+    let at = (num_or(p, "x", 0.0), num_or(p, "y", 0.0));
+    let (id, note) = make_sticky(s.doc_mut()?, parent, at, &text, color, &author)?;
+    s.set_selection(vec![id]);
+    Ok(json!({"id": id, "text": note}))
+}
+
+/// The first text layer inside board object `id` (its note or label).
+pub fn text_of(doc: &Document, id: NodeId) -> Option<NodeId> {
+    let n = doc.node(id)?;
+    n.board.as_ref().filter(|b| b.has_text())?;
+    n.children.iter().copied().find(|c| doc.node(*c).is_some_and(|k| matches!(k.kind, NodeKind::Text(_))))
+}
+
+/// The board object whose text `text` is, if any.
+pub fn owner_of_text(doc: &Document, text: NodeId) -> Option<NodeId> {
+    let p = doc.node(text)?.parent?;
+    (text_of(doc, p) == Some(text)).then_some(p)
+}
+
+/// Start typing in board object `id`'s text (all of it selected). False when it has none.
+pub fn edit_text(s: &mut Session, id: NodeId) -> Result<bool> {
+    let Some(t) = s.doc().ok().and_then(|d| text_of(d, id)) else { return Ok(false) };
+    textedit::begin(s, t, None, false)?;
+    textedit::key(s, "SelectAll", false, false, false)?;
+    Ok(true)
+}
+
+pub(super) fn next_sticky(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.nextSticky";
+    require(s, cmd)?;
+    let editing = s.ds()?.text_edit.as_ref().map(|t| t.id);
+    let doc = s.doc()?;
+    let from = id(p, "id")
+        .or_else(|| editing.and_then(|t| owner_of_text(doc, t)))
+        .or_else(|| s.selection().first().copied().map(|i| owner_of_text(doc, i).unwrap_or(i)))
+        .ok_or_else(|| EngineError::Disabled(cmd.into(), "select a sticky first".into()))?;
+    let n = doc.get(from)?;
+    if !matches!(n.board, Some(BoardItem::Sticky { .. })) {
+        return Err(bad(cmd, "that isn't a sticky"));
+    }
+    let color = n.fills.iter().find_map(Paint::solid_color).unwrap_or(s.tool.board.sticky);
+    let parent = n.parent.ok_or_else(|| bad(cmd, "that sticky has no parent"))?;
+    let at = n.transform.translation();
+    let (dx, dy) = match string(p, "side").as_deref().unwrap_or("right") {
+        "right" => (n.width + STICKY_GAP, 0.0),
+        "left" => (-(STICKY + STICKY_GAP), 0.0),
+        "below" => (0.0, n.height + STICKY_GAP),
+        "above" => (0.0, -(STICKY + STICKY_GAP)),
+        other => return Err(bad(cmd, format!("`side` is right, below, left or above, not `{other}`"))),
+    };
+    let author = author(s);
+    if editing.is_some() {
+        textedit::end(s)?;
+    }
+    let (id, note) = make_sticky(s.doc_mut()?, parent, (at.x + dx, at.y + dy), "", color, &author)?;
+    s.set_selection(vec![id]);
+    if boolean(p, "edit") == Some(true) {
+        // Typing goes on in the new sticky once this step is recorded.
+        s.request_ui("board.editText", json!({"id": id}));
+    }
+    Ok(json!({"id": id, "text": note}))
+}
+
+/// A shape with text's layers: the frame, its outline and its text.
+fn make_shape(
+    doc: &mut Document,
+    parent: NodeId,
+    at: (f64, f64),
+    size: (f64, f64),
+    shape: BoardShape,
+    text: &str,
+    color: Color,
+) -> Result<(NodeId, NodeId)> {
+    let (w, h) = size;
+    let id = add(doc, parent, NodeKind::Frame, shape.label(), at, size, |n| {
+        n.fills.clear();
+        n.clip = false;
+        n.layout = Some(AutoLayout {
+            mode: LayoutMode::Vertical,
+            padding: shape_padding(shape, w, h),
+            main_align: MainAlign::Center,
+            cross_align: CrossAlign::Center,
+            ..AutoLayout::default()
+        });
+        n.board = Some(BoardItem::Shape { shape });
+    })?;
+    add(doc, id, NodeKind::Vector { network: VectorNetwork::from_path(&shape.path(w, h)) }, "Outline", (0.0, 0.0), size, |n| {
+        n.fills = vec![Paint::solid(color)];
+        n.strokes = vec![Paint::solid(line_shade(color))];
+        n.stroke.weight = 1.5;
+        n.stroke.align = StrokeAlign::Inside;
+        n.child_layout.absolute = true;
+        n.constraints = Constraints { horizontal: HConstraint::Scale, vertical: VConstraint::Scale };
+    })?;
+    let [_, r, _, l] = shape_padding(shape, w, h);
+    let label = add_text(doc, id, text, 16.0, INK, TextAlignH::Center, (w - l - r).max(1.0))?;
+    Ok((id, label))
+}
+
+pub(super) fn shape_padding(shape: BoardShape, w: f64, h: f64) -> [f64; 4] {
+    let [t, r, b, l] = shape.text_insets();
+    [t * h, r * w, b * h, l * w]
+}
+
+pub(super) fn shape_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.shape";
+    require(s, cmd)?;
+    let shape = match string(p, "shape") {
+        Some(v) => shape_of(cmd, &v)?,
+        None => s.tool.board.shape,
+    };
+    let size = |k| {
+        num(p, k)
+            .map_or(Ok(SHAPE), |v| if (1.0..=100_000.0).contains(&v) { Ok(v) } else { Err(bad(cmd, format!("`{k}` is a size from 1 to 100000"))) })
+    };
+    let (w, h) = (size("width")?, size("height")?);
+    let color = color_param(cmd, p)?.unwrap_or(s.tool.board.sticky);
+    let parent = parent_of(cmd, s, p)?;
+    let text = string(p, "text").unwrap_or_default();
+    let at = (num_or(p, "x", 0.0), num_or(p, "y", 0.0));
+    let (id, label) = make_shape(s.doc_mut()?, parent, at, (w, h), shape, &text, color)?;
+    s.set_selection(vec![id]);
+    Ok(json!({"id": id, "text": label}))
+}
+
+pub(super) fn stamp_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.stamp";
+    require(s, cmd)?;
+    let stamp = match string(p, "stamp") {
+        Some(v) => stamp_of(cmd, &v)?,
+        None => s.tool.board.stamp,
+    };
+    let (x, y) = (req_num(cmd, p, "x")?, req_num(cmd, p, "y")?);
+    let author = author(s);
+    let page = s.page()?;
+    let half = STAMP_SIZE / 2.0;
+    let doc = s.doc_mut()?;
+    let id = add(doc, page, NodeKind::Frame, stamp.label(), (x - half, y - half), (STAMP_SIZE, STAMP_SIZE), |n| {
+        n.fills = vec![Paint::solid(stamp.color())];
+        n.corners.radii = [half; 4];
+        n.effects = vec![soft_shadow()];
+        n.clip = false;
+        n.board = Some(BoardItem::Stamp { stamp, author });
+    })?;
+    for part in stamp.mark() {
+        let path = figcraft_geom::BezPath::from_svg(part.d).map_err(|e| EngineError::Other(format!("stamp mark: {e}")))?;
+        add(doc, id, NodeKind::Vector { network: VectorNetwork::from_path(&path) }, "Mark", (0.0, 0.0), (STAMP_SIZE, STAMP_SIZE), |n| {
+            if part.filled {
+                n.fills = vec![Paint::solid(Color::WHITE)];
+            } else {
+                n.fills.clear();
+                n.strokes = vec![Paint::solid(Color::WHITE)];
+                n.stroke.weight = 3.0;
+                (n.stroke.cap_start, n.stroke.cap_end) = (StrokeCap::Round, StrokeCap::Round);
+                n.stroke.join = StrokeJoin::Round;
+                n.stroke.align = StrokeAlign::Center;
+            }
+        })?;
+    }
+    s.set_selection(vec![id]);
+    Ok(json!({"id": id}))
+}
+
+pub(super) fn ink_cmd(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "board.ink";
+    require(s, cmd)?;
+    let high = boolean(p, "highlighter").unwrap_or(false);
+    let color = color_param(cmd, p)?.unwrap_or(if high { s.tool.board.highlighter } else { s.tool.board.marker });
+    let (weight, opacity) = if high { HIGHLIGHTER } else { MARKER };
+    if get(p, "path").is_none() && get(p, "points").is_none() {
+        return Err(bad(cmd, "`path` or `points` is required"));
+    }
+    let page = s.page()?;
+    let select = boolean(p, "select").unwrap_or(true);
+    let mut q = json!({"type": "vector", "parent": page, "closed": false, "select": select, "name": if high { "Highlight" } else { "Ink" }, "props": {
+        "fills": [], "strokes": [color.to_css_hex()], "strokeWeight": weight, "strokeCap": "round", "strokeJoin": "round", "strokeAlign": "center",
+    }});
+    for k in ["path", "points"] {
+        if let (Some(v), Some(o)) = (get(p, k), q.as_object_mut()) {
+            o.insert(k.into(), v.clone());
+        }
+    }
+    let made = crate::cmd::create::create(s, &q)?;
+    let id = made.get("id").and_then(id_of).ok_or_else(|| EngineError::Other("no stroke made".into()))?;
+    let n = s.doc_mut()?.get_mut(id)?;
+    n.opacity = opacity;
+    if high {
+        n.blend = BlendMode::Multiply;
+    }
+    n.board = Some(BoardItem::Ink);
+    Ok(json!({"id": id}))
+}
diff --git a/crates/engine/src/boards/board/tools.rs b/crates/engine/src/boards/board/tools.rs
new file mode 100644
index 00000000..2dc904c9
--- /dev/null
+++ b/crates/engine/src/boards/board/tools.rs
@@ -0,0 +1,210 @@
+use super::connectors::{end_json, other_end};
+use super::derived::ends_now;
+use super::edit::label_of;
+use super::items::edit_text;
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// The board tools.
+
+impl Session {
+    /// A press with a board tool: place a sticky, shape or stamp, start a connector or a stroke,
+    /// or start erasing.
+    pub(crate) fn board_down(&mut self, ev: &PointerEvent) -> Result<()> {
+        // A board tool kept while a design file came to the front: back to Move for this press.
+        if !is_board(self.doc()?) {
+            self.tool.tool = ToolId::Move;
+            return self.pointer(ev);
+        }
+        // A sticky still being typed in ends first, so the next object is an undo step of its own.
+        if self.ds()?.text_edit.is_some() {
+            crate::textedit::end(self)?;
+        }
+        match self.tool.tool {
+            ToolId::Sticky => {
+                let half = STICKY / 2.0;
+                let r = self.execute("board.sticky", &json!({"x": ev.x - half, "y": ev.y - half}))?;
+                self.board_placed();
+                if let Some(id) = r.get("id").and_then(id_of) {
+                    edit_text(self, id)?;
+                }
+                Ok(())
+            }
+            ToolId::BoardShape => {
+                let half = SHAPE / 2.0;
+                self.execute("board.shape", &json!({"x": ev.x - half, "y": ev.y - half}))?;
+                self.board_placed();
+                Ok(())
+            }
+            ToolId::Stamp => {
+                // Stamps go on one after another: the tool stays.
+                self.execute("board.stamp", &json!({"x": ev.x, "y": ev.y}))?;
+                Ok(())
+            }
+            ToolId::Marker | ToolId::Highlighter => {
+                self.tool.gesture = Gesture::Pencil { points: vec![ev.p()], pressure: vec![ev.pressure] };
+                Ok(())
+            }
+            ToolId::Connector => {
+                let from = self.end_at(ev);
+                self.tool.gesture = Gesture::Connect { from, start: ev.p() };
+                Ok(())
+            }
+            ToolId::Eraser => {
+                self.begin_interaction("Erase")?;
+                self.tool.gesture = Gesture::Erase { gone: Vec::new() };
+                self.erase_at(ev)
+            }
+            _ => Ok(()),
+        }
+    }
+
+    /// After placing an object: back to the Move tool unless tools stay on.
+    fn board_placed(&mut self) {
+        if !self.prefs.keep_tool {
+            self.set_tool(ToolId::Move);
+        }
+    }
+
+    /// What a connector end at the pointer attaches to: the object there, or the point.
+    fn end_at(&self, ev: &PointerEvent) -> End {
+        let hit = (|| {
+            let doc = self.doc().ok()?;
+            let leaf = self.hit(doc, self.page().ok()?, ev.p(), 2.0 / ev.zoom.max(1e-6))?;
+            let t = figcraft_doc::geometry::select_target(doc, leaf, &[], false);
+            let n = doc.node(t)?;
+            (!matches!(n.board, Some(BoardItem::Connector(_)) | Some(BoardItem::Label { .. }) | Some(BoardItem::Ink))).then_some(t)
+        })();
+        match hit {
+            Some(node) => End::Node { node, side: Side::Auto },
+            None => End::Point { x: ev.x, y: ev.y },
+        }
+    }
+
+    pub(crate) fn connect_drag(&mut self, ev: &PointerEvent, from: End, start: Point) {
+        let a = match from {
+            End::Point { x, y } => Point::new(x, y),
+            End::Node { .. } => start,
+        };
+        self.tool.overlay.rubber = Some([a.x, a.y, ev.x, ev.y]);
+        self.tool.overlay.drop_target = from.node();
+        self.tool.gesture = Gesture::Connect { from, start };
+        if let Ok(ds) = self.ds_mut() {
+            ds.revision += 1;
+        }
+    }
+
+    pub(crate) fn connect_up(&mut self, ev: &PointerEvent, from: End, start: Point) -> Result<()> {
+        self.tool.overlay.rubber = None;
+        self.tool.overlay.drop_target = None;
+        // A click, not a drag: nothing to join.
+        if (ev.p() - start).hypot() * ev.zoom.max(1e-6) < 4.0 {
+            return Ok(());
+        }
+        let to = self.end_at(ev);
+        if to.node().is_some() && to.node() == from.node() {
+            return Ok(());
+        }
+        let style = self.tool.board.routing.id();
+        self.execute("board.connector", &json!({"from": end_json(from), "to": end_json(to), "style": style}))?;
+        self.board_placed();
+        Ok(())
+    }
+
+    /// Dragging the selected connector `id`'s end (`from`: its start): a line from its other end
+    /// to the pointer, and the object it would attach to outlined.
+    pub(crate) fn reattach_drag(&mut self, ev: &PointerEvent, id: NodeId, from: bool, start: Point) {
+        self.tool.gesture = Gesture::Reattach { id, from, start };
+        let Ok(doc) = self.doc() else { return };
+        let fixed = ends_now(doc, id).map(|(a, b)| if from { b } else { a });
+        let other = other_end(doc, id, from).and_then(|e| e.node());
+        self.tool.overlay.rubber = fixed.map(|f| [f.x, f.y, ev.x, ev.y]);
+        self.tool.overlay.drop_target = self.end_at(ev).node().filter(|n| Some(*n) != other);
+        if let Ok(ds) = self.ds_mut() {
+            ds.revision += 1;
+        }
+    }
+
+    /// The end let go: attached to the object under the pointer, or free there (`board.reattach`).
+    /// A click, or a drop on the object the other end is on, changes nothing.
+    pub(crate) fn reattach_up(&mut self, ev: &PointerEvent, id: NodeId, from: bool, start: Point) -> Result<()> {
+        self.tool.overlay.rubber = None;
+        if (ev.p() - start).hypot() * ev.zoom.max(1e-6) < 4.0 {
+            return Ok(());
+        }
+        let target = self.end_at(ev);
+        let other = other_end(self.doc()?, id, from).and_then(|e| e.node());
+        if target.node().is_some() && target.node() == other {
+            return Ok(());
+        }
+        self.execute("board.reattach", &json!({"id": id, "end": if from { "from" } else { "to" }, "target": end_json(target)}))?;
+        Ok(())
+    }
+
+    /// The eraser at the pointer: the marker and highlighter strokes it touches go (until the
+    /// gesture ends, which is one undo step).
+    pub(crate) fn erase_at(&mut self, ev: &PointerEvent) -> Result<()> {
+        let Gesture::Erase { mut gone } = std::mem::take(&mut self.tool.gesture) else { return Ok(()) };
+        let tol = ERASER_PX / ev.zoom.max(1e-6);
+        self.tool.overlay.brush = Some([ev.x, ev.y, tol]);
+        let (doc, page) = (self.doc()?.clone(), self.page()?);
+        if let Some(hit) =
+            doc.hit_test(page, ev.p(), tol, None).filter(|h| doc.node(*h).is_some_and(|n| n.board == Some(BoardItem::Ink)) && !gone.contains(h))
+        {
+            gone.push(hit);
+            let ids = gone.clone();
+            self.preview(|d, sel| {
+                for i in &ids {
+                    let _ = d.remove(*i);
+                }
+                sel.retain(|s| !ids.contains(s));
+                Ok(())
+            })?;
+        }
+        self.tool.gesture = Gesture::Erase { gone };
+        if let Ok(ds) = self.ds_mut() {
+            ds.revision += 1;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn erase_up(&mut self) -> Result<()> {
+        self.tool.overlay.brush = None;
+        self.commit_interaction()
+    }
+
+    /// A finished marker or highlighter stroke (page points).
+    pub(crate) fn ink_finish(&mut self, path: &str) -> Result<()> {
+        let high = self.tool.tool == ToolId::Highlighter;
+        self.execute("board.ink", &json!({"path": path, "highlighter": high, "select": false}))?;
+        // Strokes come one after another: the selection stays as it was.
+        Ok(())
+    }
+}
+
+impl Session {
+    /// A double-click with the Move tool on a board object: type in its text (a connector gets a
+    /// label to type in). True when it was one.
+    pub(crate) fn board_double_click(&mut self, doc: &Document, leaf: NodeId, sel: &[NodeId]) -> Result<bool> {
+        let whole = figcraft_doc::geometry::select_target(doc, leaf, sel, false);
+        let editing = self.ds()?.text_edit.as_ref().is_some_and(|te| doc.is_ancestor(whole, te.id));
+        let Some(item) = doc.node(whole).and_then(|n| n.board.clone()).filter(|_| !editing) else { return Ok(false) };
+        self.tool.gesture = Gesture::None;
+        self.cancel_interaction()?;
+        match item {
+            BoardItem::Connector(_) => {
+                let label = match label_of(doc, whole) {
+                    Some(l) => l,
+                    None => {
+                        let r = self.execute("board.label", &json!({"id": whole, "text": "Label"}))?;
+                        r.get("label").and_then(id_of).ok_or_else(|| EngineError::Other("no label made".into()))?
+                    }
+                };
+                edit_text(self, label)
+            }
+            BoardItem::Table => crate::board_table::edit_cell(self, doc, leaf),
+            b if b.has_text() => edit_text(self, whole),
+            _ => Ok(false),
+        }
+    }
+}

From cea90cf935adfbfd9c4b304b4f9d228098fe8943 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:20:45 +0000
Subject: [PATCH 29/67] refactor(engine): split cmd/edit.rs into edit/

---
 crates/engine/src/cmd/edit.rs           | 1067 +----------------------
 crates/engine/src/cmd/edit/clipboard.rs |  332 +++++++
 crates/engine/src/cmd/edit/props.rs     |  458 ++++++++++
 crates/engine/src/cmd/edit/select.rs    |  267 ++++++
 4 files changed, 1073 insertions(+), 1051 deletions(-)
 create mode 100644 crates/engine/src/cmd/edit/clipboard.rs
 create mode 100644 crates/engine/src/cmd/edit/props.rs
 create mode 100644 crates/engine/src/cmd/edit/select.rs

diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index 60077efd..7ec63c69 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -10,6 +10,22 @@ use super::{CommandSpec, ok};
 use crate::params::*;
 use crate::{BatchStep, EngineError, Result, Session, bad, spec};
 
+mod clipboard;
+mod props;
+mod select;
+
+pub use clipboard::{CLIP_CLOSE, CLIP_OPEN, copy_to_clipboard, design_clipboard_buffer, paste_into};
+use clipboard::{copy, copy_props, copy_props_of, cut, paste, paste_design_layers, paste_over, paste_props, paste_replace};
+use props::{
+    batch_rename, effect_add, effect_copy, effect_paste, find_replace, paint_copy, paint_list, paint_paste, paint_set, pattern_fill, reparent, set,
+    stroke_brush, width_profile,
+};
+pub use select::opacity_from_digits;
+use select::{
+    hide_others, layers_at, nudge, nudge_size, opacity_keys, select_all, select_area, select_children, select_inverse, select_matching,
+    select_parent, select_same, select_sibling, toggle,
+};
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         spec!("edit.undo", "Undo", "{}", false, |s, _| Ok(json!({"undone": s.undo()?}))),
@@ -536,1054 +552,3 @@ fn bump_name(n: &str) -> String {
     }
     format!("{n} 2")
 }
-
-/// The copied form of the selection.
-pub fn copy_to_clipboard(s: &mut Session, cmd: &str, ids: &[NodeId]) -> Result<()> {
-    let ds = s.ds()?;
-    // Pages are not layers: they can't be pasted anywhere.
-    let layers: Vec<NodeId> = ids.iter().copied().filter(|i| !ds.doc.node(*i).is_some_and(Node::is_page)).collect();
-    if layers.is_empty() && !ids.is_empty() {
-        return Err(EngineError::Disabled(cmd.into(), "pages can't be copied; use page.duplicate".into()));
-    }
-    let (nodes, images, bounds) = copied(&ds.doc, &layers);
-    let (source, source_path, uid) = (ds.doc.clone(), ds.path.clone(), ds.uid);
-    s.clipboard.source = Some(source);
-    s.clipboard.source_path = source_path;
-    s.clipboard.source_doc = uid;
-    s.clipboard.copied_components = nodes
-        .iter()
-        .filter(|(_, sub)| {
-            cmd == "edit.copy" && sub.first().is_some_and(|n| matches!(n.kind, NodeKind::Component { .. } | NodeKind::ComponentSet { .. }))
-        })
-        .map(|(root, _)| *root)
-        .collect();
-    s.clipboard.nodes = nodes;
-    s.clipboard.images = images;
-    s.clipboard.bounds = bounds;
-    s.clipboard.layers_generation = s.clipboard.layers_generation.wrapping_add(1);
-    Ok(())
-}
-
-type Copied = (Vec<(NodeId, Vec<Node>)>, BTreeMap<String, ImageData>, Option<figcraft_geom::Rect>);
-
-fn copied(doc: &Document, ids: &[NodeId]) -> Copied {
-    let ids = z_sorted(doc, &roots(doc, ids));
-    let mut nodes = Vec::new();
-    let mut images = BTreeMap::new();
-    for i in &ids {
-        let world = doc.world_transform(*i);
-        let mut sub: Vec<Node> = doc.subtree(*i).into_iter().filter_map(|x| doc.node(x).cloned()).collect();
-        // Store the root's transform in page space so pastes land where it was.
-        if let Some(r) = sub.first_mut() {
-            r.transform = world;
-        }
-        for n in &sub {
-            for p in n.fills.iter().chain(n.strokes.iter()) {
-                if let figcraft_color::PaintKind::Image(img) = &p.kind
-                    && let Some(d) = doc.images.get(&img.image)
-                {
-                    images.insert(img.image.clone(), d.clone());
-                }
-            }
-        }
-        nodes.push((*i, sub));
-    }
-    let bounds = doc.bounds_of(&ids);
-    (nodes, images, bounds)
-}
-
-/// The markers around the copied layers in the clipboard's HTML, spelt as that format spells them.
-pub const CLIP_OPEN: &str = "(figma)";
-pub const CLIP_CLOSE: &str = "(/figma)";
-/// Largest design data read from the clipboard: the `.fig` import's own canvas cap (256 MB). Its
-/// base64 is checked first, so neither the text nor the decoded bytes can pass it.
-const MAX_CLIP_DATA: usize = 256 * 1024 * 1024;
-const MAX_CLIP_BASE64: usize = MAX_CLIP_DATA.div_ceil(3) * 4;
-
-/// Base64 `text` (whitespace ignored, padding optional) when it fits [`MAX_CLIP_DATA`].
-fn clip_base64(text: &str) -> Option<Vec<u8>> {
-    use base64::Engine as _;
-    if text.bytes().filter(|b| !b.is_ascii_whitespace()).count() > MAX_CLIP_BASE64 {
-        return None;
-    }
-    let b64: String = text.chars().filter(|c| !c.is_ascii_whitespace()).collect();
-    base64::engine::general_purpose::STANDARD.decode(&b64).or_else(|_| base64::engine::general_purpose::STANDARD_NO_PAD.decode(&b64)).ok()
-}
-
-/// Layers copied from another design app travel in the clipboard's HTML as a `.fig` canvas in
-/// base64 between [`CLIP_OPEN`] and [`CLIP_CLOSE`]. This gives those bytes, or `None` when the HTML
-/// holds no readable design data (it may just mention the marker).
-pub fn design_clipboard_buffer(html: &str) -> Option<Vec<u8>> {
-    let start = html.find(CLIP_OPEN)? + CLIP_OPEN.len();
-    let len = html.get(start..)?.find(CLIP_CLOSE)?;
-    let bytes = clip_base64(html.get(start..start + len)?)?;
-    figcraft_format::fig::is_fig(&bytes).then_some(bytes)
-}
-
-/// Paste design layers from clipboard HTML or base64 `data`: decode and reject missing,
-/// invalid or oversized data, load a temporary `.fig`, take its top-level page layers,
-/// store them as a foreign-file clipboard source with a bumped layers generation, then
-/// delegate to `paste` and append import warnings.
-fn paste_design_layers(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "edit.pasteDesignLayers";
-    let bytes = match (string(p, "html"), string(p, "data")) {
-        (Some(html), _) => design_clipboard_buffer(&html).ok_or_else(|| bad(CMD, "the HTML holds no copied design layers"))?,
-        (None, Some(d)) => clip_base64(&d).ok_or_else(|| bad(CMD, "`data` is not base64 of at most 256 MB"))?,
-        (None, None) => return Err(bad(CMD, "pass `html` or `data`")),
-    };
-    let other = super::file::load_fig(&bytes, "Pasted layers").ok_or_else(|| bad(CMD, "the data is not copied design layers"))??;
-    let doc = std::sync::Arc::new(other.doc);
-    let tops: Vec<NodeId> = doc.pages.iter().filter_map(|pg| doc.node(*pg)).flat_map(|pg| pg.children.iter().copied()).collect();
-    if tops.is_empty() {
-        return Err(EngineError::Disabled(CMD.into(), "the copied layers came in empty".into()));
-    }
-    let (nodes, images, bounds) = copied(&doc, &tops);
-    // A design-app paste replaces the copied layers, not the copied rows: a `fill.copy` before it
-    // still pastes afterwards.
-    let props = s.clipboard.props.take();
-    let paint = s.clipboard.paint.take();
-    let stroke = s.clipboard.stroke.take();
-    let effect = s.clipboard.effect.take();
-    // No open file has id 0. So paste treats this copy as a copy from a different file.
-    let layers_generation = s.clipboard.layers_generation.wrapping_add(1);
-    s.clipboard = crate::Clipboard {
-        nodes,
-        images,
-        props,
-        paint,
-        stroke,
-        effect,
-        bounds,
-        source_doc: 0,
-        source: Some(doc),
-        source_path: None,
-        copied_components: BTreeSet::new(),
-        layers_generation,
-    };
-    let mut out = paste(s, p)?;
-    if !other.issues.is_empty() {
-        out["warnings"] = json!(other.issues);
-    }
-    Ok(out)
-}
-
-fn copy(s: &mut Session, p: &Value) -> Result<Value> {
-    let ids = req_targets("edit.copy", s, p)?;
-    copy_to_clipboard(s, "edit.copy", &ids)?;
-    Ok(json!({"copied": s.clipboard.nodes.len()}))
-}
-
-fn cut(s: &mut Session, p: &Value) -> Result<Value> {
-    let ids = req_targets("edit.cut", s, p)?;
-    copy_to_clipboard(s, "edit.cut", &ids)?;
-    let doc = s.doc()?;
-    let layers: Vec<NodeId> = ids.into_iter().filter(|i| !doc.node(*i).is_some_and(Node::is_page)).collect();
-    delete(s, &json!({"ids": layers}))
-}
-
-/// Paste the clipboard under `parent` with the copied top-left moved to `at` (page coords).
-pub fn paste_into(s: &mut Session, parent: NodeId, at: Option<(f64, f64)>) -> Result<Vec<NodeId>> {
-    let clip = s.clipboard.clone();
-    if clip.nodes.is_empty() {
-        return Err(EngineError::Disabled("edit.paste".into(), "the clipboard is empty".into()));
-    }
-    // From another file: its instances follow the mains this file can have.
-    let foreign = clip.source.as_ref().filter(|_| s.ds().is_ok_and(|d| d.uid != clip.source_doc));
-    let copy_local = s.ds()?.uid == clip.source_doc;
-    let doc = s.doc_mut()?;
-    for (k, v) in &clip.images {
-        doc.images.entry(k.clone()).or_insert_with(|| v.clone());
-    }
-    // Sections go on the page (or in sections), never in the frame being pasted into.
-    let page = doc.page_of(parent).unwrap_or(parent);
-    let shift = match (at, clip.bounds) {
-        (Some((x, y)), Some(b)) => Affine::translate((x - b.x0, y - b.y0)),
-        _ => Affine::IDENTITY,
-    };
-    let mut out = Vec::new();
-    let mut all = BTreeMap::new();
-    for (root, nodes) in &clip.nodes {
-        if copy_local
-            && clip.copied_components.contains(root)
-            && let Some(n) = nodes.first().filter(|n| matches!(n.kind, NodeKind::Component { .. }))
-            && doc.node(*root).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. }))
-        {
-            let instance = crate::components::create_instance(doc, *root, parent, 0.0, 0.0)?;
-            doc.get_mut(instance)?.transform = doc.world_transform(parent).inverse() * shift * n.transform;
-            out.push(instance);
-            continue;
-        }
-        let mut map = BTreeMap::new();
-        for n in nodes {
-            map.insert(n.id, doc.alloc_id());
-        }
-        let mut nodes = nodes.clone();
-        let section = nodes.first().is_some_and(|r| matches!(r.kind, NodeKind::Section { .. }));
-        let into = if section && !doc.takes_sections(parent) { page } else { parent };
-        if let Some(r) = nodes.first_mut() {
-            r.transform = doc.world_transform(into).inverse() * shift * r.transform;
-        }
-        out.push(doc.paste_nodes(&nodes, &map, *root, into, None)?);
-        all.extend(map);
-    }
-    // Board connectors pasted with what they join join the pasted copies.
-    let originals: Vec<(NodeId, figcraft_doc::BoardItem)> =
-        clip.nodes.iter().flat_map(|(_, nodes)| nodes).filter_map(|n| Some((*all.get(&n.id)?, n.board.clone()?))).collect();
-    crate::board::rejoin(doc, &originals, &all, !copy_local);
-    if let Some(src) = foreign {
-        crate::library::adopt_pasted(doc, src, clip.source_path.as_deref(), &all)?;
-    }
-    Ok(out)
-}
-
-fn paste(s: &mut Session, p: &Value) -> Result<Value> {
-    let page = s.page()?;
-    // Figma pastes into the selected frame (if one is selected), at the same position when it fits,
-    // else in the frame's centre; otherwise in place on the page (or the viewport centre).
-    let sel = s.selection();
-    let doc = s.doc()?;
-    let copy_local = s.ds()?.uid == s.clipboard.source_doc;
-    let target = id(p, "parent").or_else(|| {
-        sel.first()
-            .copied()
-            .filter(|i| {
-                sel.len() == 1
-                    && doc.node(*i).is_some_and(|n| n.kind.is_frame_like() && !matches!(n.kind, NodeKind::Instance { .. }) && !n.is_board_atom())
-            })
-            .filter(|i| !copy_local || !s.clipboard.copied_components.iter().any(|root| doc.is_ancestor(*root, *i)))
-    });
-    let parent = target.unwrap_or(page);
-    let at = match (num(p, "x"), num(p, "y")) {
-        (Some(x), Some(y)) => Some((x, y)),
-        _ => {
-            let b = s.clipboard.bounds;
-            match (target, b) {
-                (Some(t), Some(b)) => {
-                    let tb = doc.world_bounds(t);
-                    match tb {
-                        Some(tb) if tb.contains(b.origin()) && tb.contains(figcraft_geom::Point::new(b.x1, b.y1)) => None,
-                        Some(tb) => Some((tb.center().x - b.width() / 2.0, tb.center().y - b.height() / 2.0)),
-                        None => None,
-                    }
-                }
-                (None, Some(b)) => {
-                    // Off-screen originals paste at the viewport centre.
-                    let v = &s.ds()?.view;
-                    let (ox, oy) = v.origin();
-                    let vr = figcraft_geom::Rect::new(ox, oy, ox + v.vw / v.zoom.max(1e-9), oy + v.vh / v.zoom.max(1e-9));
-                    if vr.intersect(b).is_zero_area() { Some((v.cx - b.width() / 2.0, v.cy - b.height() / 2.0)) } else { None }
-                }
-                _ => None,
-            }
-        }
-    };
-    let ids = paste_into(s, parent, at)?;
-    s.set_selection(ids.clone());
-    Ok(json!({"ids": ids}))
-}
-
-fn paste_over(s: &mut Session, _p: &Value) -> Result<Value> {
-    let sel = s.selection();
-    let page = s.page()?;
-    let doc = s.doc()?;
-    let (parent, at) = match sel.first() {
-        Some(i) => {
-            let parent = doc.node(*i).and_then(|n| n.parent).unwrap_or(page);
-            (parent, doc.world_bounds(*i).map(|b| (b.x0, b.y0)))
-        }
-        None => (page, None),
-    };
-    let ids = paste_into(s, parent, at)?;
-    s.set_selection(ids.clone());
-    Ok(json!({"ids": ids}))
-}
-
-fn paste_replace(s: &mut Session, p: &Value) -> Result<Value> {
-    let targets = req_targets("edit.pasteReplace", s, p)?;
-    let mut out = Vec::new();
-    for t in targets {
-        let doc = s.doc()?;
-        let Some(n) = doc.node(t) else { continue };
-        let parent = n.parent.ok_or_else(|| bad("edit.pasteReplace", "can't replace a page"))?;
-        let idx = doc.index_in_parent(t);
-        let at = doc.world_bounds(t).map(|b| (b.x0, b.y0));
-        let ids = paste_into(s, parent, at)?;
-        let doc = s.doc_mut()?;
-        for (k, i) in ids.iter().enumerate() {
-            if let Some(ix) = idx {
-                let _ = doc.reorder(*i, ix + k);
-            }
-        }
-        doc.remove(t)?;
-        out.extend(ids);
-    }
-    s.set_selection(out.clone());
-    Ok(json!({"ids": out}))
-}
-
-fn copy_props_of(doc: &Document, id: NodeId) -> Value {
-    let Some(n) = doc.node(id) else { return Value::Null };
-    let mut v = json!({
-        "fills": n.fills, "strokes": n.strokes, "strokeWeight": n.stroke.weight, "strokeAlign": n.stroke.align,
-        "effects": n.effects, "opacity": n.opacity, "blend": n.blend, "cornerRadius": n.corners.radii,
-        "cornerSmoothing": n.corners.smoothing,
-    });
-    if let NodeKind::Text(t) = &n.kind {
-        v["fontFamily"] = json!(t.style.font_family);
-        v["fontStyle"] = json!(t.style.font_style);
-        v["fontSize"] = json!(t.style.font_size);
-        v["fontVariations"] = json!(t.style.variations);
-        v["lineHeight"] = serde_json::to_value(t.style.line_height).unwrap_or(Value::Null);
-        v["letterSpacing"] = serde_json::to_value(t.style.letter_spacing).unwrap_or(Value::Null);
-    }
-    v
-}
-
-fn copy_props(s: &mut Session, p: &Value) -> Result<Value> {
-    let id = targets(s, p).first().copied().ok_or_else(|| bad("edit.copyProperties", "select one layer"))?;
-    let v = copy_props_of(s.doc()?, id);
-    s.clipboard.props = Some(v.clone());
-    Ok(v)
-}
-
-fn paste_props(s: &mut Session, p: &Value) -> Result<Value> {
-    let props = s.clipboard.props.clone().ok_or_else(|| EngineError::Disabled("edit.pasteProperties".into(), "no copied properties".into()))?;
-    let ids = req_targets("edit.pasteProperties", s, p)?;
-    let doc = s.doc_mut()?;
-    for i in ids {
-        let mut m = props.as_object().cloned().unwrap_or_default();
-        let is_text = matches!(doc.get(i)?.kind, NodeKind::Text(_));
-        if !is_text {
-            m.retain(|k, _| !k.starts_with("font") && k != "lineHeight" && k != "letterSpacing");
-        }
-        if !doc.get(i)?.kind.has_corner_radius() {
-            m.remove("cornerRadius");
-            m.remove("cornerSmoothing");
-        }
-        super::props::apply("edit.pasteProperties", doc, i, &m)?;
-    }
-    ok()
-}
-
-fn layers_at(s: &mut Session, p: &Value) -> Result<Value> {
-    let (x, y) = (req_num("select.layersAt", p, "x")?, req_num("select.layersAt", p, "y")?);
-    let doc = s.doc()?;
-    let zoom = s.ds()?.view.zoom.max(1e-6);
-    let sel = s.selection();
-    let result = crate::booleans::result_outline(doc, &sel);
-    let layers: Vec<Value> = figcraft_doc::geometry::layers_at(doc, s.page()?, figcraft_geom::Point::new(x, y), 2.0 / zoom, Some(&result))
-        .into_iter()
-        .filter_map(|(id, depth)| doc.node(id).map(|n| json!({"id": id, "name": n.name, "type": n.kind.type_name(), "depth": depth})))
-        .collect();
-    Ok(json!({"layers": layers}))
-}
-
-fn select_all(s: &mut Session, _p: &Value) -> Result<Value> {
-    let doc = s.doc()?;
-    let sel = s.selection();
-    // Select all siblings of the current selection, else the page's top level.
-    let parent = sel.first().and_then(|i| doc.node(*i)).and_then(|n| n.parent).unwrap_or(s.page()?);
-    let ids: Vec<NodeId> = doc.get(parent)?.children.iter().copied().filter(|c| doc.node(*c).is_some_and(|n| n.visible && !n.locked)).collect();
-    s.set_selection(ids.clone());
-    Ok(json!({"selection": ids}))
-}
-
-/// What Select all would select, less the selection (hidden and locked layers neither).
-fn select_inverse(s: &mut Session, _p: &Value) -> Result<Value> {
-    let doc = s.doc()?;
-    let sel = s.selection();
-    let parent = sel.first().and_then(|i| doc.node(*i)).and_then(|n| n.parent).unwrap_or(s.page()?);
-    let ids: Vec<NodeId> =
-        doc.get(parent)?.children.iter().copied().filter(|c| !sel.contains(c) && doc.node(*c).is_some_and(|n| n.visible && !n.locked)).collect();
-    s.set_selection(ids.clone());
-    Ok(json!({"selection": ids}))
-}
-
-/// `select.area`: what a marquee from (x, y) over the box selects; no box asks the app for one.
-fn select_area(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "select.area";
-    let keys = ["x", "y", "width", "height"];
-    if keys.iter().all(|k| p.get(*k).is_none()) {
-        s.request_ui("selectArea", json!({}));
-        return ok();
-    }
-    let [x, y, w, h] = keys.map(|k| num(p, k));
-    let (Some(x), Some(y), Some(w), Some(h)) = (x, y, w, h) else { return Err(bad(cmd, "pass x, y, width and height (numbers)")) };
-    if ![x, y, w, h].iter().all(|v| v.is_finite() && v.abs() < 1e9) {
-        return Err(bad(cmd, "the box is out of range"));
-    }
-    let start = figcraft_geom::Point::new(x, y);
-    let r = figcraft_geom::Rect::from_points(start, figcraft_geom::Point::new(x + w, y + h));
-    let add = boolean(p, "add") == Some(true);
-    let base = if add { s.selection() } else { Vec::new() };
-    let within = s.marquee_within(start)?;
-    let sel = s.marquee_selection(r, within, boolean(p, "deep") == Some(true), &base, add)?;
-    s.set_selection(sel.clone());
-    Ok(json!({"selection": sel}))
-}
-
-fn select_children(s: &mut Session, _p: &Value) -> Result<Value> {
-    let doc = s.doc()?;
-    let mut ids = Vec::new();
-    for i in s.selection() {
-        if let Some(n) = doc.node(i) {
-            ids.extend(n.children.iter().copied());
-        }
-    }
-    if ids.is_empty() {
-        return Ok(json!({"selection": s.selection()}));
-    }
-    s.set_selection(ids.clone());
-    Ok(json!({"selection": ids}))
-}
-
-fn select_parent(s: &mut Session, _p: &Value) -> Result<Value> {
-    let doc = s.doc()?;
-    let mut ids: Vec<NodeId> = Vec::new();
-    for i in s.selection() {
-        if let Some(p) = doc.node(i).and_then(|n| n.parent)
-            && !doc.node(p).is_some_and(Node::is_page)
-            && !ids.contains(&p)
-        {
-            ids.push(p);
-        }
-    }
-    if ids.is_empty() {
-        return Ok(json!({"selection": s.selection()}));
-    }
-    s.set_selection(ids.clone());
-    Ok(json!({"selection": ids}))
-}
-
-fn select_sibling(s: &mut Session, dir: i64) -> Result<Value> {
-    let doc = s.doc()?;
-    let sel = s.selection();
-    let Some(cur) = sel.last().copied() else {
-        let first = doc.get(s.page()?)?.children.last().copied();
-        s.set_selection(first.into_iter().collect());
-        return Ok(json!({"selection": s.selection()}));
-    };
-    let parent = doc.get(cur)?.parent.ok_or_else(|| bad("select.next", "no parent"))?;
-    let kids = &doc.get(parent)?.children;
-    let idx = kids.iter().position(|c| *c == cur).unwrap_or(0) as i64;
-    let n = kids.len() as i64;
-    // Layers panel order is reversed (top of the list = last child): Tab goes down the list.
-    let next = (idx - dir).rem_euclid(n.max(1)) as usize;
-    let id = kids.get(next).copied().unwrap_or(cur);
-    s.set_selection(vec![id]);
-    Ok(json!({"selection": [id]}))
-}
-
-fn select_matching(s: &mut Session, _p: &Value) -> Result<Value> {
-    let doc = s.doc()?;
-    let sel = s.selection();
-    let Some(first) = sel.first().and_then(|i| doc.node(*i)) else { return Ok(json!({"selection": []})) };
-    let (name, ty) = (first.name.clone(), first.kind.type_name());
-    let page = s.page()?;
-    let ids: Vec<NodeId> =
-        doc.subtree(page).into_iter().filter(|i| doc.node(*i).is_some_and(|n| n.name == name && n.kind.type_name() == ty)).collect();
-    s.set_selection(ids.clone());
-    Ok(json!({"selection": ids}))
-}
-
-fn select_same(s: &mut Session, same: impl Fn(&Node, &Node) -> bool) -> Result<Value> {
-    let doc = s.doc()?;
-    let sel = s.selection();
-    let Some(first) = sel.first().and_then(|i| doc.node(*i)).cloned() else { return Ok(json!({"selection": []})) };
-    let page = s.page()?;
-    let ids: Vec<NodeId> = doc.subtree(page).into_iter().filter(|i| *i != page && doc.node(*i).is_some_and(|n| same(&first, n))).collect();
-    s.set_selection(ids.clone());
-    Ok(json!({"selection": ids}))
-}
-
-/// The opacity number keys give: one digit is tens of percent (0 is 100%), two digits typed in
-/// quick succession the exact percentage.
-pub fn opacity_from_digits(digits: &str) -> Option<f32> {
-    let mut n = 0u32;
-    let mut count = 0;
-    for c in digits.chars() {
-        // Input-derived: a number that outgrows `u32` stops the scan (None); it never wraps.
-        n = n.checked_mul(10)?.checked_add(c.to_digit(10)?)?;
-        count += 1;
-    }
-    match count {
-        1 if n == 0 => Some(1.0),
-        1 => Some(n as f32 / 10.0),
-        2 => Some(n as f32 / 100.0),
-        _ => None,
-    }
-}
-
-fn opacity_keys(s: &mut Session, p: &Value) -> Result<Value> {
-    let digits = req_string("object.opacityKeys", p, "digits")?;
-    let o = opacity_from_digits(&digits).ok_or_else(|| bad("object.opacityKeys", "`digits` must be one or two digits"))?;
-    let ids = req_targets("object.opacityKeys", s, p)?;
-    let doc = s.doc_mut()?;
-    let before = super::styles::bound_before(doc, &ids);
-    for i in ids {
-        doc.get_mut(i)?.opacity = o;
-    }
-    super::styles::detach_edited(doc, &before);
-    Ok(json!({"opacity": o}))
-}
-
-fn nudge(s: &mut Session, p: &Value) -> Result<Value> {
-    let big = boolean(p, "big").unwrap_or(false);
-    let k = if big { s.prefs.nudge_big } else { s.prefs.nudge_small };
-    let (ux, uy) = (num_or(p, "dx", 0.0), num_or(p, "dy", 0.0));
-    let (dx, dy) = (ux * k, uy * k);
-    let ids = req_targets("transform.nudge", s, p)?;
-    // Edit a copy and keep it only if something moved, so an arrow that can't move anything adds
-    // no undo step.
-    let mut work = s.doc()?.clone();
-    let doc = &mut work;
-    let ids = roots(doc, &ids);
-    let mut changed = false;
-    // Children in an auto layout flow move one place instead (see `al_keys`).
-    for i in &ids {
-        if crate::al_keys::flowing_parent(doc, *i).is_none() && (dx, dy) != (0.0, 0.0) {
-            let n = doc.get_mut(*i)?;
-            n.transform = Affine::translate((dx, dy)) * n.transform;
-            changed = true;
-        }
-    }
-    for dir in crate::al_keys::Dir::from_units(ux, uy) {
-        // Grouped per arrow: a move into a neighbouring frame changes the parent.
-        let mut groups: BTreeMap<NodeId, Vec<NodeId>> = BTreeMap::new();
-        for i in &ids {
-            if let Some(parent) = crate::al_keys::flowing_parent(doc, *i) {
-                groups.entry(parent).or_default().push(*i);
-            }
-        }
-        for (parent, block) in groups {
-            changed |= crate::al_keys::arrow_move(doc, parent, &block, dir)?;
-        }
-    }
-    if changed {
-        s.ds_mut()?.doc = std::sync::Arc::new(work);
-    }
-    ok()
-}
-
-fn nudge_size(s: &mut Session, p: &Value) -> Result<Value> {
-    let big = boolean(p, "big").unwrap_or(false);
-    let k = if big { s.prefs.nudge_big } else { s.prefs.nudge_small };
-    let (dw, dh) = (num_or(p, "dw", 0.0) * k, num_or(p, "dh", 0.0) * k);
-    let ids = req_targets("transform.nudgeSize", s, p)?;
-    let ids = roots(s.doc()?, &ids);
-    for i in ids {
-        let Some((w, h)) = s.doc()?.node(i).map(|n| (n.width, n.height)) else { continue };
-        let mut q = serde_json::Map::new();
-        q.insert("ids".into(), json!([i]));
-        // Only the axis that changes becomes fixed.
-        if dw != 0.0 {
-            q.insert("width".into(), json!((w + dw).max(0.0)));
-        }
-        if dh != 0.0 {
-            q.insert("height".into(), json!((h + dh).max(0.0)));
-        }
-        super::arrange::resize_cmd(s, &Value::Object(q))?;
-    }
-    ok()
-}
-
-fn toggle(s: &mut Session, p: &Value, what: &str) -> Result<Value> {
-    let ids = req_targets("object.toggle", s, p)?;
-    let doc = s.doc_mut()?;
-    let explicit = boolean(p, what);
-    // Figma: if any is visible, hide all (and vice versa).
-    let value = explicit.unwrap_or_else(|| match what {
-        "visible" => !ids.iter().all(|i| doc.node(*i).is_some_and(|n| n.visible)),
-        _ => !ids.iter().all(|i| doc.node(*i).is_some_and(|n| n.locked)),
-    });
-    for i in &ids {
-        let n = doc.get_mut(*i)?;
-        if what == "visible" {
-            n.visible = value;
-        } else {
-            n.locked = value;
-        }
-    }
-    if what == "locked" && value {
-        s.set_selection(vec![]);
-    }
-    Ok(json!({what: value}))
-}
-
-fn hide_others(s: &mut Session, _p: &Value) -> Result<Value> {
-    let sel = s.selection();
-    let page = s.page()?;
-    let doc = s.doc_mut()?;
-    let keep: BTreeSet<NodeId> = sel
-        .iter()
-        .flat_map(|i| {
-            let mut v = doc.ancestors(*i);
-            v.push(*i);
-            v
-        })
-        .collect();
-    let tops: Vec<NodeId> = doc.get(page)?.children.clone();
-    for t in tops {
-        if !keep.contains(&t) {
-            doc.get_mut(t)?.visible = false;
-        }
-    }
-    ok()
-}
-
-fn batch_rename(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "object.batchRename";
-    let ids = req_targets(cmd, s, p)?;
-    let find = string(p, "find");
-    let replace = string(p, "replace").unwrap_or_default();
-    let pattern = string(p, "name");
-    let rename =
-        crate::rename::BatchRename::new(find.as_deref(), boolean(p, "regex").unwrap_or(false), &replace, pattern.as_deref(), num(p, "start"))
-            .map_err(|e| bad(cmd, e))?;
-    let doc = s.doc_mut()?;
-    let names = rename.plan(doc, &ids);
-    for (i, name) in &names {
-        doc.get_mut(*i)?.name = name.clone();
-    }
-    Ok(json!({"names": names.iter().map(|(i, n)| json!({"id": i, "name": n})).collect::<Vec<_>>()}))
-}
-
-/// Char index of the first case-insensitive occurrence of `needle` in `hay` at or after `from`.
-/// Works on char indices (what `replace_range` takes), so lowercasing never shifts offsets.
-fn find_ci(hay: &[char], needle: &[char], from: usize) -> Option<usize> {
-    if needle.is_empty() {
-        return None;
-    }
-    (from..hay.len())
-        .find(|&i| hay.get(i..i + needle.len()).is_some_and(|w| w.iter().zip(needle).all(|(a, b)| a == b || a.to_lowercase().eq(b.to_lowercase()))))
-}
-
-fn find_replace(s: &mut Session, p: &Value) -> Result<Value> {
-    let find = req_string("edit.findReplace", p, "find")?;
-    if find.is_empty() {
-        return Err(bad("edit.findReplace", "`find` is empty"));
-    }
-    // Line breaks stored as the editor stores them (CRLF, CR, U+2028 and U+2029 become LF).
-    let replace = string(p, "replace").map(|r| super::props::normalize_line_endings(&r));
-    let names = boolean(p, "layerNames").unwrap_or(false);
-    let page = s.page()?;
-    let doc = s.doc_mut()?;
-    let mut hits = Vec::new();
-    let needle: Vec<char> = find.chars().collect();
-    let r_chars: Vec<char> = replace.as_deref().map(|r| r.chars().collect()).unwrap_or_default();
-    for i in doc.subtree(page) {
-        let Some(n) = doc.node(i) else { continue };
-        let text: Option<Vec<char>> = match &n.kind {
-            NodeKind::Text(t) => Some(t.characters.chars().collect()),
-            _ => None,
-        };
-        let text_hit = text.as_deref().is_some_and(|c| find_ci(c, &needle, 0).is_some());
-        let name_hit = names && find_ci(&n.name.chars().collect::<Vec<_>>(), &needle, 0).is_some();
-        if !(text_hit || name_hit) || n.is_page() {
-            continue;
-        }
-        hits.push(i);
-        if let Some(r) = &replace {
-            let n = doc.get_mut(i)?;
-            if names && name_hit {
-                let chars: Vec<char> = n.name.chars().collect();
-                let mut out = String::new();
-                let mut at = 0;
-                while let Some(pos) = find_ci(&chars, &needle, at) {
-                    out.extend(chars.get(at..pos).unwrap_or_default());
-                    out.push_str(r);
-                    at = pos + needle.len();
-                }
-                out.extend(chars.get(at..).unwrap_or_default());
-                n.name = out;
-            }
-            if let (NodeKind::Text(t), Some(mut chars)) = (&mut n.kind, text) {
-                // Replace occurrence by occurrence so styles shift correctly. The search resumes
-                // after each inserted replacement, so a replacement that matches `find` (in any
-                // case) neither loops forever nor stops the other occurrences.
-                let mut cursor = 0;
-                for _ in 0..10_000 {
-                    let Some(start) = find_ci(&chars, &needle, cursor) else { break };
-                    t.replace_range(start, start + needle.len(), r);
-                    chars.splice(start..start + needle.len(), r_chars.iter().copied());
-                    cursor = start + r_chars.len();
-                }
-            }
-        }
-    }
-    if boolean(p, "select").unwrap_or(true) {
-        s.set_selection(hits.clone());
-    }
-    Ok(json!({"matches": hits}))
-}
-
-/// Keys only some layer types take, the test for those layers, and why the others skip them.
-type TypedKeys<'a> = (&'a [&'a str], &'a dyn Fn(&Node) -> bool, &'a str);
-
-fn set(s: &mut Session, p: &Value) -> Result<Value> {
-    let ids = req_targets("node.set", s, p)?;
-    let props = match get(p, "props") {
-        Some(Value::Object(m)) => m.clone(),
-        _ => {
-            // Allow flat params: {"id": 3, "fill": "#f00"}.
-            let mut m = p.as_object().cloned().unwrap_or_default();
-            m.remove("id");
-            m.remove("ids");
-            m
-        }
-    };
-    if props.is_empty() {
-        return Err(bad("node.set", "no properties given"));
-    }
-    // A new rotation for the selection turns it about its moved rotation origin: each layer's
-    // point under the origin stays put.
-    let ds = s.ds()?;
-    let pivot =
-        ds.moved_origin().filter(|_| props.contains_key("rotation") && !props.contains_key("x") && !props.contains_key("y") && ds.selection == ids);
-    let pinned: Vec<(NodeId, figcraft_geom::Point)> = match pivot {
-        Some(o) => roots(&ds.doc, &ids)
-            .into_iter()
-            .map(|i| (i, ds.doc.world_transform(i)))
-            .filter(|(_, w)| w.determinant().abs() > 1e-12)
-            .map(|(i, w)| (i, w.inverse() * o))
-            .collect(),
-        None => Vec::new(),
-    };
-    let mut warnings = font_style_warnings(&s.ds()?.doc, &ids, &props);
-    // Type-specific keys go to the layers that take them and are skipped, with a warning, on the
-    // others: auto layout keys to frame-like layers, `path` to vectors. With none among the targets
-    // that take them, the first refuses them (`props::layout_mut`, `props::apply`).
-    let doc = &s.ds()?.doc;
-    let layout_keys: Vec<&str> = props.keys().map(String::as_str).filter(|k| super::props::LAYOUT_KEYS.contains(k)).collect();
-    let path_keys: Vec<&str> = props.keys().map(String::as_str).filter(|k| *k == "path").collect();
-    let frame_like = |n: &Node| n.kind.is_frame_like();
-    let vector = |n: &Node| matches!(n.kind, NodeKind::Vector { .. });
-    let typed: [TypedKeys; 2] = [
-        (&layout_keys, &frame_like, "only frames, components and instances have auto layout"),
-        (&path_keys, &vector, "only vector layers have a path"),
-    ];
-    let mut skipped: BTreeMap<NodeId, Map<String, Value>> = BTreeMap::new();
-    for (keys, takes, why) in typed {
-        let takes = |i: &NodeId| doc.node(*i).is_some_and(takes);
-        if keys.is_empty() || !ids.iter().any(takes) {
-            continue;
-        }
-        let others: Vec<NodeId> = ids.iter().copied().filter(|i| !takes(i)).collect();
-        if others.is_empty() {
-            continue;
-        }
-        for i in &others {
-            skipped.entry(*i).or_insert_with(|| props.clone()).retain(|k, _| !keys.contains(&k.as_str()));
-        }
-        let names: Vec<String> =
-            others.iter().take(10).filter_map(|i| doc.node(*i)).map(|n| format!("{} “{}” ({})", n.id, n.name, n.kind.type_name())).collect();
-        let more = if others.len() > names.len() { format!(" and {} more", others.len() - names.len()) } else { String::new() };
-        warnings.push(format!(
-            "{} skipped on {}{more}: {why}",
-            keys.iter().map(|k| format!("`{k}`")).collect::<Vec<_>>().join(", "),
-            names.join(", ")
-        ));
-    }
-    let doc = s.doc_mut()?;
-    let before = super::styles::bound_before(doc, &ids);
-    for i in ids {
-        super::props::apply("node.set", doc, i, skipped.get(&i).unwrap_or(&props))?;
-    }
-    super::styles::detach_edited(doc, &before);
-    if let Some(o) = pivot {
-        for (i, q) in pinned {
-            let d = o - doc.world_transform(i) * q;
-            if d.hypot().is_finite() {
-                super::arrange::move_world(doc, i, d.x, d.y)?;
-            }
-        }
-    }
-    if warnings.is_empty() { ok() } else { Ok(json!({"ok": true, "warnings": warnings})) }
-}
-
-/// A `fontStyle` draws in the family's face nearest to it, as a text layer resolves it. When that
-/// face has another weight or slant than the name asks for ("Black" on a family whose heaviest is
-/// Bold), say which face it is. Families that aren't installed, and names that match a style or a
-/// named instance (spelled any way: "SemiBold", "Semi Bold"), say nothing.
-fn font_style_warnings(doc: &figcraft_doc::Document, ids: &[NodeId], props: &serde_json::Map<String, Value>) -> Vec<String> {
-    let Some(style) = props.get("fontStyle").and_then(Value::as_str) else { return Vec::new() };
-    let mut families: Vec<String> = match props.get("fontFamily").and_then(Value::as_str) {
-        Some(f) => vec![f.to_string()],
-        None => ids
-            .iter()
-            .filter_map(|i| doc.node(*i))
-            .filter_map(|n| n.kind.text())
-            .flat_map(|t| t.spans().into_iter().map(|(_, _, st)| st.font_family.clone()).collect::<Vec<_>>())
-            .collect(),
-    };
-    families.sort();
-    families.dedup();
-    let norm = |s: &str| s.to_lowercase().replace([' ', '-', '_'], "");
-    let (want_w, want_i) = (i32::from(figcraft_doc::style_weight(style)), style.to_lowercase().contains("italic"));
-    families
-        .into_iter()
-        .filter_map(|family| {
-            let styles = figcraft_text::family_styles(&family);
-            if styles.is_empty() || styles.iter().any(|x| norm(x) == norm(style)) {
-                return None;
-            }
-            let face = figcraft_text::find_face(&family, style).filter(|f| f.family.eq_ignore_ascii_case(&family))?;
-            let w = face.axis("wght").map_or(i32::from(face.weight), |a| a.clamp(f64::from(want_w)).round() as i32);
-            if face.instance(style).is_some() || (w == want_w && face.italic == want_i) {
-                return None;
-            }
-            Some(format!("{family} has no `{style}` style: it draws in {}, the nearest (it has: {})", face.style, styles.join(", ")))
-        })
-        .collect()
-}
-
-/// `stroke.widthProfile`: a preset or points (through `node.set`'s `widthProfile`, so instances
-/// record the override).
-fn width_profile(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "stroke.widthProfile";
-    let v = get(p, "preset").or_else(|| get(p, "points")).cloned().unwrap_or(Value::Null);
-    let ids = req_targets(cmd, s, p)?;
-    let props = serde_json::Map::from_iter([("widthProfile".to_string(), v)]);
-    let doc = s.doc_mut()?;
-    for i in ids {
-        super::props::apply(cmd, doc, i, &props)?;
-    }
-    ok()
-}
-
-fn stroke_brush(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "stroke.brush";
-    let v = if get(p, "preset").is_none_or(Value::is_null) { Value::Null } else { p.clone() };
-    let brush = super::props::brush_of(&v).ok_or_else(|| bad(cmd, super::props::BRUSH_HELP))?;
-    let ids = req_targets(cmd, s, p)?;
-    let doc = s.doc_mut()?;
-    for i in ids {
-        let n = doc.get_mut(i)?;
-        if brush.is_some() && n.strokes.is_empty() {
-            n.strokes.push(figcraft_color::Paint::solid(figcraft_color::Color::BLACK));
-        }
-        n.stroke.brush = brush.clone();
-    }
-    ok()
-}
-
-fn reparent(s: &mut Session, p: &Value) -> Result<Value> {
-    let ids = req_targets("node.reparent", s, p)?;
-    let parent = req_id("node.reparent", p, "parent")?;
-    let index = num(p, "index").map(|i| i.max(0.0) as usize);
-    let doc = s.doc_mut()?;
-    let ids = z_sorted(doc, &roots(doc, &ids));
-    // `index` is where the first moved layer ends up among the parent's children (bottom first),
-    // counted after the move, the way `node.reorder` counts it. The layers land together, keeping
-    // their order, under the sibling that stays put and ends up just after them (none: on top).
-    let above = index.and_then(|at| doc.get(parent).ok()?.children.iter().filter(|c| !ids.contains(c)).nth(at).copied());
-    for i in &ids {
-        // Counted with the layer still in place, as `reparent` expects.
-        let at = above.and_then(|a| doc.node(parent)?.children.iter().position(|c| *c == a));
-        doc.reparent(*i, parent, at)?;
-    }
-    ok()
-}
-
-fn paint_list(s: &mut Session, p: &Value, fills: bool, add: bool) -> Result<Value> {
-    let cmd = if fills { "fill" } else { "stroke" };
-    let ids = req_targets(cmd, s, p)?;
-    let index = if add || get(p, "index").is_none() { None } else { Some(req_index(cmd, p, "index")?) };
-    let doc = s.doc_mut()?;
-    for i in ids {
-        let n = doc.get_mut(i)?;
-        let frameish = n.kind.is_frame_like();
-        let list = if fills { &mut n.fills } else { &mut n.strokes };
-        if add {
-            let paint = match get(p, "paint").or_else(|| get(p, "color")) {
-                Some(v) => paint_of(v).ok_or_else(|| bad(cmd, "invalid paint"))?,
-                None if fills && frameish => figcraft_color::Paint::solid(figcraft_color::Color::WHITE),
-                None if fills => figcraft_color::Paint::solid(figcraft_color::Color::DEFAULT_SHAPE),
-                None => figcraft_color::Paint::solid(figcraft_color::Color::BLACK),
-            };
-            list.push(paint);
-        } else {
-            let idx = index.unwrap_or(list.len().saturating_sub(1));
-            // The paint's colour binding goes with it; later paints' move down one.
-            super::lists::remove_item(n, if fills { super::lists::BoundList::Fills } else { super::lists::BoundList::Strokes }, idx);
-        }
-    }
-    ok()
-}
-
-fn paint_set(s: &mut Session, p: &Value, fills: bool) -> Result<Value> {
-    let cmd = if fills { "fill.set" } else { "stroke.set" };
-    let ids = req_targets(cmd, s, p)?;
-    let idx = opt_index(cmd, p, "index")?;
-    let new_paint = match get(p, "paint") {
-        Some(v) => Some(paint_of(v).ok_or_else(|| bad(cmd, "invalid paint"))?),
-        None => None,
-    };
-    let col = color(p, "color");
-    let doc = s.doc_mut()?;
-    for i in ids {
-        let n = doc.get_mut(i)?;
-        let list = if fills { &mut n.fills } else { &mut n.strokes };
-        let at = idx.unwrap_or(list.len().saturating_sub(1));
-        if list.is_empty() {
-            list.push(figcraft_color::Paint::solid(if fills { figcraft_color::Color::DEFAULT_SHAPE } else { figcraft_color::Color::BLACK }));
-        }
-        let Some(slot) = list.get_mut(at) else { return Err(bad(cmd, format!("no paint at index {at}"))) };
-        let old = slot.clone();
-        if let Some(np) = &new_paint {
-            *slot = np.clone();
-        }
-        if let Some(c) = col {
-            slot.kind = figcraft_color::PaintKind::Solid { color: c.with_alpha(1.0) };
-            if c.a < 1.0 {
-                slot.opacity = c.a;
-                slot.color_alpha = c.a;
-            }
-        }
-        if let Some(o) = num(p, "opacity") {
-            slot.opacity = (if o > 1.0 { o / 100.0 } else { o }).clamp(0.0, 1.0) as f32;
-            slot.color_alpha = 1.0;
-        }
-        if let Some(v) = boolean(p, "visible") {
-            slot.visible = v;
-        }
-        if let Some(b) = blend(p, "blend") {
-            slot.blend = b;
-        }
-        super::lists::rebind_edited_paint(n, fills, at, &old);
-        if fills {
-            n.styles.fill = None;
-        } else {
-            n.styles.stroke = None;
-        }
-    }
-    ok()
-}
-
-/// Copy paint `index` (the top one by default) of the first target into the clipboard. A stroke
-/// takes its node-wide settings (weight, alignment, sides, caps, joins, dashes) along.
-fn paint_copy(s: &mut Session, p: &Value, fills: bool) -> Result<Value> {
-    let cmd = if fills { "fill.copy" } else { "stroke.copy" };
-    let id = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a layer"))?;
-    let at = opt_index(cmd, p, "index")?;
-    let (paint, stroke) = {
-        let doc = s.doc()?;
-        let n = doc.get(id)?;
-        let list = if fills { &n.fills } else { &n.strokes };
-        let at = at.unwrap_or(list.len().saturating_sub(1));
-        let paint = list.get(at).cloned().ok_or_else(|| bad(cmd, format!("no {} at index {at}", if fills { "fill" } else { "stroke" })))?;
-        (paint, (!fills).then(|| n.stroke.clone()))
-    };
-    s.clipboard.paint = Some((fills, paint.clone()));
-    s.clipboard.stroke = stroke;
-    serde_json::to_value(&paint).map_err(|e| bad(cmd, e.to_string()))
-}
-
-/// Paste the copied paint onto the targets: replacing paint `index` there, or adding one. A
-/// stroke's copied settings go onto each target too.
-fn paint_paste(s: &mut Session, p: &Value, fills: bool) -> Result<Value> {
-    let cmd = if fills { "fill.paste" } else { "stroke.paste" };
-    let Some((copied_fills, paint)) = s.clipboard.paint.clone() else {
-        return Err(EngineError::Disabled(cmd.into(), "no copied fill or stroke".into()));
-    };
-    if copied_fills != fills {
-        let what = if fills { "stroke" } else { "fill" };
-        return Err(EngineError::Disabled(cmd.into(), format!("the copied paint is a {what}")));
-    }
-    let ids = req_targets(cmd, s, p)?;
-    // A copied pattern pointing at a target or a layer inside it would make the layer pattern
-    // itself; `fill.pattern` refuses the same, and the renderer would drop the pattern.
-    if let figcraft_color::PaintKind::Pattern(pt) = &paint.kind {
-        let doc = s.doc()?;
-        if ids.iter().any(|t| doc.is_ancestor(*t, NodeId(pt.source))) {
-            return Err(bad(cmd, "a layer can't be filled with itself or a layer inside it"));
-        }
-    }
-    let mut q = json!({"ids": ids, "paint": serde_json::to_value(paint).map_err(|e| bad(cmd, e.to_string()))?});
-    let out = match opt_index(cmd, p, "index")? {
-        Some(at) => {
-            q["index"] = json!(at);
-            paint_set(s, &q, fills)?
-        }
-        None => paint_list(s, &q, fills, true)?,
-    };
-    if let Some(stroke) = s.clipboard.stroke.clone().filter(|_| !fills) {
-        for id in ids {
-            s.doc_mut()?.get_mut(id)?.stroke = stroke.clone();
-        }
-    }
-    Ok(out)
-}
-
-fn pattern_fill(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "fill.pattern";
-    let src = req_id(CMD, p, "source")?;
-    let doc = s.doc()?;
-    if doc.node(src).is_none_or(|n| n.is_page()) {
-        return Err(bad(CMD, "`source` must be a layer"));
-    }
-    if req_targets(CMD, s, p)?.iter().any(|t| doc.is_ancestor(*t, src)) {
-        return Err(bad(CMD, "a layer can't be filled with itself or a layer inside it"));
-    }
-    let mut pt = figcraft_color::PatternPaint::new(src.0);
-    pt.tile = parse(CMD, p, "tile")?.unwrap_or_default();
-    pt.align = parse(CMD, p, "align")?.unwrap_or_default();
-    pt.spacing = parse(CMD, p, "spacing")?.unwrap_or_default();
-    let (lo, hi) = figcraft_color::PatternPaint::SCALE_RANGE;
-    pt.scale = num(p, "scale").filter(|v| v.is_finite()).unwrap_or(1.0).clamp(lo, hi);
-    let mut q = if p.is_object() { p.clone() } else { json!({}) };
-    q["paint"] =
-        serde_json::to_value(figcraft_color::Paint { kind: figcraft_color::PaintKind::Pattern(pt), ..figcraft_color::Paint::pattern(src.0) })
-            .map_err(|e| bad(CMD, e.to_string()))?;
-    paint_set(s, &q, true)
-}
-
-fn effect_add(s: &mut Session, p: &Value) -> Result<Value> {
-    let e: Effect = match super::props::effect_from("effect.add", p, "effect")? {
-        Some(e) => e,
-        None => {
-            let ty = string(p, "type").unwrap_or_else(|| "dropShadow".into());
-            Effect::of_type(&ty).ok_or_else(|| bad("effect.add", format!("unknown effect type `{ty}`")))?
-        }
-    };
-    for i in req_targets("effect.add", s, p)? {
-        s.doc_mut()?.get_mut(i)?.effects.push(e.clone());
-    }
-    ok()
-}
-
-/// Copy effect `index` (the top one by default) of the first target into the clipboard.
-fn effect_copy(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "effect.copy";
-    let id = targets(s, p).first().copied().ok_or_else(|| bad(CMD, "select a layer"))?;
-    let at = opt_index(CMD, p, "index")?;
-    let e = {
-        let doc = s.doc()?;
-        let list = &doc.get(id)?.effects;
-        let at = at.unwrap_or(list.len().saturating_sub(1));
-        list.get(at).cloned().ok_or_else(|| bad(CMD, format!("no effect at index {at}")))?
-    };
-    s.clipboard.effect = Some(e.clone());
-    serde_json::to_value(&e).map_err(|err| bad(CMD, err.to_string()))
-}
-
-/// Paste the copied effect onto the targets: replacing effect `index` there, or adding one.
-fn effect_paste(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "effect.paste";
-    let Some(e) = s.clipboard.effect.clone() else {
-        return Err(EngineError::Disabled(CMD.into(), "no copied effect".into()));
-    };
-    let at = opt_index(CMD, p, "index")?;
-    for id in req_targets(CMD, s, p)? {
-        let n = s.doc_mut()?.get_mut(id)?;
-        match at {
-            Some(i) => {
-                if let Some(slot) = n.effects.get_mut(i) {
-                    *slot = e.clone();
-                }
-            }
-            None => n.effects.push(e.clone()),
-        }
-    }
-    ok()
-}
diff --git a/crates/engine/src/cmd/edit/clipboard.rs b/crates/engine/src/cmd/edit/clipboard.rs
new file mode 100644
index 00000000..d0e7b2dc
--- /dev/null
+++ b/crates/engine/src/cmd/edit/clipboard.rs
@@ -0,0 +1,332 @@
+use super::*;
+
+/// The copied form of the selection.
+pub fn copy_to_clipboard(s: &mut Session, cmd: &str, ids: &[NodeId]) -> Result<()> {
+    let ds = s.ds()?;
+    // Pages are not layers: they can't be pasted anywhere.
+    let layers: Vec<NodeId> = ids.iter().copied().filter(|i| !ds.doc.node(*i).is_some_and(Node::is_page)).collect();
+    if layers.is_empty() && !ids.is_empty() {
+        return Err(EngineError::Disabled(cmd.into(), "pages can't be copied; use page.duplicate".into()));
+    }
+    let (nodes, images, bounds) = copied(&ds.doc, &layers);
+    let (source, source_path, uid) = (ds.doc.clone(), ds.path.clone(), ds.uid);
+    s.clipboard.source = Some(source);
+    s.clipboard.source_path = source_path;
+    s.clipboard.source_doc = uid;
+    s.clipboard.copied_components = nodes
+        .iter()
+        .filter(|(_, sub)| {
+            cmd == "edit.copy" && sub.first().is_some_and(|n| matches!(n.kind, NodeKind::Component { .. } | NodeKind::ComponentSet { .. }))
+        })
+        .map(|(root, _)| *root)
+        .collect();
+    s.clipboard.nodes = nodes;
+    s.clipboard.images = images;
+    s.clipboard.bounds = bounds;
+    s.clipboard.layers_generation = s.clipboard.layers_generation.wrapping_add(1);
+    Ok(())
+}
+
+type Copied = (Vec<(NodeId, Vec<Node>)>, BTreeMap<String, ImageData>, Option<figcraft_geom::Rect>);
+
+fn copied(doc: &Document, ids: &[NodeId]) -> Copied {
+    let ids = z_sorted(doc, &roots(doc, ids));
+    let mut nodes = Vec::new();
+    let mut images = BTreeMap::new();
+    for i in &ids {
+        let world = doc.world_transform(*i);
+        let mut sub: Vec<Node> = doc.subtree(*i).into_iter().filter_map(|x| doc.node(x).cloned()).collect();
+        // Store the root's transform in page space so pastes land where it was.
+        if let Some(r) = sub.first_mut() {
+            r.transform = world;
+        }
+        for n in &sub {
+            for p in n.fills.iter().chain(n.strokes.iter()) {
+                if let figcraft_color::PaintKind::Image(img) = &p.kind
+                    && let Some(d) = doc.images.get(&img.image)
+                {
+                    images.insert(img.image.clone(), d.clone());
+                }
+            }
+        }
+        nodes.push((*i, sub));
+    }
+    let bounds = doc.bounds_of(&ids);
+    (nodes, images, bounds)
+}
+
+/// The markers around the copied layers in the clipboard's HTML, spelt as that format spells them.
+pub const CLIP_OPEN: &str = "(figma)";
+
+pub const CLIP_CLOSE: &str = "(/figma)";
+
+/// Largest design data read from the clipboard: the `.fig` import's own canvas cap (256 MB). Its
+/// base64 is checked first, so neither the text nor the decoded bytes can pass it.
+const MAX_CLIP_DATA: usize = 256 * 1024 * 1024;
+
+const MAX_CLIP_BASE64: usize = MAX_CLIP_DATA.div_ceil(3) * 4;
+
+/// Base64 `text` (whitespace ignored, padding optional) when it fits [`MAX_CLIP_DATA`].
+fn clip_base64(text: &str) -> Option<Vec<u8>> {
+    use base64::Engine as _;
+    if text.bytes().filter(|b| !b.is_ascii_whitespace()).count() > MAX_CLIP_BASE64 {
+        return None;
+    }
+    let b64: String = text.chars().filter(|c| !c.is_ascii_whitespace()).collect();
+    base64::engine::general_purpose::STANDARD.decode(&b64).or_else(|_| base64::engine::general_purpose::STANDARD_NO_PAD.decode(&b64)).ok()
+}
+
+/// Layers copied from another design app travel in the clipboard's HTML as a `.fig` canvas in
+/// base64 between [`CLIP_OPEN`] and [`CLIP_CLOSE`]. This gives those bytes, or `None` when the HTML
+/// holds no readable design data (it may just mention the marker).
+pub fn design_clipboard_buffer(html: &str) -> Option<Vec<u8>> {
+    let start = html.find(CLIP_OPEN)? + CLIP_OPEN.len();
+    let len = html.get(start..)?.find(CLIP_CLOSE)?;
+    let bytes = clip_base64(html.get(start..start + len)?)?;
+    figcraft_format::fig::is_fig(&bytes).then_some(bytes)
+}
+
+/// Paste design layers from clipboard HTML or base64 `data`: decode and reject missing,
+/// invalid or oversized data, load a temporary `.fig`, take its top-level page layers,
+/// store them as a foreign-file clipboard source with a bumped layers generation, then
+/// delegate to `paste` and append import warnings.
+pub(super) fn paste_design_layers(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "edit.pasteDesignLayers";
+    let bytes = match (string(p, "html"), string(p, "data")) {
+        (Some(html), _) => design_clipboard_buffer(&html).ok_or_else(|| bad(CMD, "the HTML holds no copied design layers"))?,
+        (None, Some(d)) => clip_base64(&d).ok_or_else(|| bad(CMD, "`data` is not base64 of at most 256 MB"))?,
+        (None, None) => return Err(bad(CMD, "pass `html` or `data`")),
+    };
+    let other = crate::cmd::file::load_fig(&bytes, "Pasted layers").ok_or_else(|| bad(CMD, "the data is not copied design layers"))??;
+    let doc = std::sync::Arc::new(other.doc);
+    let tops: Vec<NodeId> = doc.pages.iter().filter_map(|pg| doc.node(*pg)).flat_map(|pg| pg.children.iter().copied()).collect();
+    if tops.is_empty() {
+        return Err(EngineError::Disabled(CMD.into(), "the copied layers came in empty".into()));
+    }
+    let (nodes, images, bounds) = copied(&doc, &tops);
+    // A design-app paste replaces the copied layers, not the copied rows: a `fill.copy` before it
+    // still pastes afterwards.
+    let props = s.clipboard.props.take();
+    let paint = s.clipboard.paint.take();
+    let stroke = s.clipboard.stroke.take();
+    let effect = s.clipboard.effect.take();
+    // No open file has id 0. So paste treats this copy as a copy from a different file.
+    let layers_generation = s.clipboard.layers_generation.wrapping_add(1);
+    s.clipboard = crate::Clipboard {
+        nodes,
+        images,
+        props,
+        paint,
+        stroke,
+        effect,
+        bounds,
+        source_doc: 0,
+        source: Some(doc),
+        source_path: None,
+        copied_components: BTreeSet::new(),
+        layers_generation,
+    };
+    let mut out = paste(s, p)?;
+    if !other.issues.is_empty() {
+        out["warnings"] = json!(other.issues);
+    }
+    Ok(out)
+}
+
+pub(super) fn copy(s: &mut Session, p: &Value) -> Result<Value> {
+    let ids = req_targets("edit.copy", s, p)?;
+    copy_to_clipboard(s, "edit.copy", &ids)?;
+    Ok(json!({"copied": s.clipboard.nodes.len()}))
+}
+
+pub(super) fn cut(s: &mut Session, p: &Value) -> Result<Value> {
+    let ids = req_targets("edit.cut", s, p)?;
+    copy_to_clipboard(s, "edit.cut", &ids)?;
+    let doc = s.doc()?;
+    let layers: Vec<NodeId> = ids.into_iter().filter(|i| !doc.node(*i).is_some_and(Node::is_page)).collect();
+    delete(s, &json!({"ids": layers}))
+}
+
+/// Paste the clipboard under `parent` with the copied top-left moved to `at` (page coords).
+pub fn paste_into(s: &mut Session, parent: NodeId, at: Option<(f64, f64)>) -> Result<Vec<NodeId>> {
+    let clip = s.clipboard.clone();
+    if clip.nodes.is_empty() {
+        return Err(EngineError::Disabled("edit.paste".into(), "the clipboard is empty".into()));
+    }
+    // From another file: its instances follow the mains this file can have.
+    let foreign = clip.source.as_ref().filter(|_| s.ds().is_ok_and(|d| d.uid != clip.source_doc));
+    let copy_local = s.ds()?.uid == clip.source_doc;
+    let doc = s.doc_mut()?;
+    for (k, v) in &clip.images {
+        doc.images.entry(k.clone()).or_insert_with(|| v.clone());
+    }
+    // Sections go on the page (or in sections), never in the frame being pasted into.
+    let page = doc.page_of(parent).unwrap_or(parent);
+    let shift = match (at, clip.bounds) {
+        (Some((x, y)), Some(b)) => Affine::translate((x - b.x0, y - b.y0)),
+        _ => Affine::IDENTITY,
+    };
+    let mut out = Vec::new();
+    let mut all = BTreeMap::new();
+    for (root, nodes) in &clip.nodes {
+        if copy_local
+            && clip.copied_components.contains(root)
+            && let Some(n) = nodes.first().filter(|n| matches!(n.kind, NodeKind::Component { .. }))
+            && doc.node(*root).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. }))
+        {
+            let instance = crate::components::create_instance(doc, *root, parent, 0.0, 0.0)?;
+            doc.get_mut(instance)?.transform = doc.world_transform(parent).inverse() * shift * n.transform;
+            out.push(instance);
+            continue;
+        }
+        let mut map = BTreeMap::new();
+        for n in nodes {
+            map.insert(n.id, doc.alloc_id());
+        }
+        let mut nodes = nodes.clone();
+        let section = nodes.first().is_some_and(|r| matches!(r.kind, NodeKind::Section { .. }));
+        let into = if section && !doc.takes_sections(parent) { page } else { parent };
+        if let Some(r) = nodes.first_mut() {
+            r.transform = doc.world_transform(into).inverse() * shift * r.transform;
+        }
+        out.push(doc.paste_nodes(&nodes, &map, *root, into, None)?);
+        all.extend(map);
+    }
+    // Board connectors pasted with what they join join the pasted copies.
+    let originals: Vec<(NodeId, figcraft_doc::BoardItem)> =
+        clip.nodes.iter().flat_map(|(_, nodes)| nodes).filter_map(|n| Some((*all.get(&n.id)?, n.board.clone()?))).collect();
+    crate::board::rejoin(doc, &originals, &all, !copy_local);
+    if let Some(src) = foreign {
+        crate::library::adopt_pasted(doc, src, clip.source_path.as_deref(), &all)?;
+    }
+    Ok(out)
+}
+
+pub(super) fn paste(s: &mut Session, p: &Value) -> Result<Value> {
+    let page = s.page()?;
+    // Figma pastes into the selected frame (if one is selected), at the same position when it fits,
+    // else in the frame's centre; otherwise in place on the page (or the viewport centre).
+    let sel = s.selection();
+    let doc = s.doc()?;
+    let copy_local = s.ds()?.uid == s.clipboard.source_doc;
+    let target = id(p, "parent").or_else(|| {
+        sel.first()
+            .copied()
+            .filter(|i| {
+                sel.len() == 1
+                    && doc.node(*i).is_some_and(|n| n.kind.is_frame_like() && !matches!(n.kind, NodeKind::Instance { .. }) && !n.is_board_atom())
+            })
+            .filter(|i| !copy_local || !s.clipboard.copied_components.iter().any(|root| doc.is_ancestor(*root, *i)))
+    });
+    let parent = target.unwrap_or(page);
+    let at = match (num(p, "x"), num(p, "y")) {
+        (Some(x), Some(y)) => Some((x, y)),
+        _ => {
+            let b = s.clipboard.bounds;
+            match (target, b) {
+                (Some(t), Some(b)) => {
+                    let tb = doc.world_bounds(t);
+                    match tb {
+                        Some(tb) if tb.contains(b.origin()) && tb.contains(figcraft_geom::Point::new(b.x1, b.y1)) => None,
+                        Some(tb) => Some((tb.center().x - b.width() / 2.0, tb.center().y - b.height() / 2.0)),
+                        None => None,
+                    }
+                }
+                (None, Some(b)) => {
+                    // Off-screen originals paste at the viewport centre.
+                    let v = &s.ds()?.view;
+                    let (ox, oy) = v.origin();
+                    let vr = figcraft_geom::Rect::new(ox, oy, ox + v.vw / v.zoom.max(1e-9), oy + v.vh / v.zoom.max(1e-9));
+                    if vr.intersect(b).is_zero_area() { Some((v.cx - b.width() / 2.0, v.cy - b.height() / 2.0)) } else { None }
+                }
+                _ => None,
+            }
+        }
+    };
+    let ids = paste_into(s, parent, at)?;
+    s.set_selection(ids.clone());
+    Ok(json!({"ids": ids}))
+}
+
+pub(super) fn paste_over(s: &mut Session, _p: &Value) -> Result<Value> {
+    let sel = s.selection();
+    let page = s.page()?;
+    let doc = s.doc()?;
+    let (parent, at) = match sel.first() {
+        Some(i) => {
+            let parent = doc.node(*i).and_then(|n| n.parent).unwrap_or(page);
+            (parent, doc.world_bounds(*i).map(|b| (b.x0, b.y0)))
+        }
+        None => (page, None),
+    };
+    let ids = paste_into(s, parent, at)?;
+    s.set_selection(ids.clone());
+    Ok(json!({"ids": ids}))
+}
+
+pub(super) fn paste_replace(s: &mut Session, p: &Value) -> Result<Value> {
+    let targets = req_targets("edit.pasteReplace", s, p)?;
+    let mut out = Vec::new();
+    for t in targets {
+        let doc = s.doc()?;
+        let Some(n) = doc.node(t) else { continue };
+        let parent = n.parent.ok_or_else(|| bad("edit.pasteReplace", "can't replace a page"))?;
+        let idx = doc.index_in_parent(t);
+        let at = doc.world_bounds(t).map(|b| (b.x0, b.y0));
+        let ids = paste_into(s, parent, at)?;
+        let doc = s.doc_mut()?;
+        for (k, i) in ids.iter().enumerate() {
+            if let Some(ix) = idx {
+                let _ = doc.reorder(*i, ix + k);
+            }
+        }
+        doc.remove(t)?;
+        out.extend(ids);
+    }
+    s.set_selection(out.clone());
+    Ok(json!({"ids": out}))
+}
+
+pub(super) fn copy_props_of(doc: &Document, id: NodeId) -> Value {
+    let Some(n) = doc.node(id) else { return Value::Null };
+    let mut v = json!({
+        "fills": n.fills, "strokes": n.strokes, "strokeWeight": n.stroke.weight, "strokeAlign": n.stroke.align,
+        "effects": n.effects, "opacity": n.opacity, "blend": n.blend, "cornerRadius": n.corners.radii,
+        "cornerSmoothing": n.corners.smoothing,
+    });
+    if let NodeKind::Text(t) = &n.kind {
+        v["fontFamily"] = json!(t.style.font_family);
+        v["fontStyle"] = json!(t.style.font_style);
+        v["fontSize"] = json!(t.style.font_size);
+        v["fontVariations"] = json!(t.style.variations);
+        v["lineHeight"] = serde_json::to_value(t.style.line_height).unwrap_or(Value::Null);
+        v["letterSpacing"] = serde_json::to_value(t.style.letter_spacing).unwrap_or(Value::Null);
+    }
+    v
+}
+
+pub(super) fn copy_props(s: &mut Session, p: &Value) -> Result<Value> {
+    let id = targets(s, p).first().copied().ok_or_else(|| bad("edit.copyProperties", "select one layer"))?;
+    let v = copy_props_of(s.doc()?, id);
+    s.clipboard.props = Some(v.clone());
+    Ok(v)
+}
+
+pub(super) fn paste_props(s: &mut Session, p: &Value) -> Result<Value> {
+    let props = s.clipboard.props.clone().ok_or_else(|| EngineError::Disabled("edit.pasteProperties".into(), "no copied properties".into()))?;
+    let ids = req_targets("edit.pasteProperties", s, p)?;
+    let doc = s.doc_mut()?;
+    for i in ids {
+        let mut m = props.as_object().cloned().unwrap_or_default();
+        let is_text = matches!(doc.get(i)?.kind, NodeKind::Text(_));
+        if !is_text {
+            m.retain(|k, _| !k.starts_with("font") && k != "lineHeight" && k != "letterSpacing");
+        }
+        if !doc.get(i)?.kind.has_corner_radius() {
+            m.remove("cornerRadius");
+            m.remove("cornerSmoothing");
+        }
+        crate::cmd::props::apply("edit.pasteProperties", doc, i, &m)?;
+    }
+    ok()
+}
diff --git a/crates/engine/src/cmd/edit/props.rs b/crates/engine/src/cmd/edit/props.rs
new file mode 100644
index 00000000..f793b50c
--- /dev/null
+++ b/crates/engine/src/cmd/edit/props.rs
@@ -0,0 +1,458 @@
+use super::*;
+
+pub(super) fn batch_rename(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "object.batchRename";
+    let ids = req_targets(cmd, s, p)?;
+    let find = string(p, "find");
+    let replace = string(p, "replace").unwrap_or_default();
+    let pattern = string(p, "name");
+    let rename =
+        crate::rename::BatchRename::new(find.as_deref(), boolean(p, "regex").unwrap_or(false), &replace, pattern.as_deref(), num(p, "start"))
+            .map_err(|e| bad(cmd, e))?;
+    let doc = s.doc_mut()?;
+    let names = rename.plan(doc, &ids);
+    for (i, name) in &names {
+        doc.get_mut(*i)?.name = name.clone();
+    }
+    Ok(json!({"names": names.iter().map(|(i, n)| json!({"id": i, "name": n})).collect::<Vec<_>>()}))
+}
+
+/// Char index of the first case-insensitive occurrence of `needle` in `hay` at or after `from`.
+/// Works on char indices (what `replace_range` takes), so lowercasing never shifts offsets.
+fn find_ci(hay: &[char], needle: &[char], from: usize) -> Option<usize> {
+    if needle.is_empty() {
+        return None;
+    }
+    (from..hay.len())
+        .find(|&i| hay.get(i..i + needle.len()).is_some_and(|w| w.iter().zip(needle).all(|(a, b)| a == b || a.to_lowercase().eq(b.to_lowercase()))))
+}
+
+pub(super) fn find_replace(s: &mut Session, p: &Value) -> Result<Value> {
+    let find = req_string("edit.findReplace", p, "find")?;
+    if find.is_empty() {
+        return Err(bad("edit.findReplace", "`find` is empty"));
+    }
+    // Line breaks stored as the editor stores them (CRLF, CR, U+2028 and U+2029 become LF).
+    let replace = string(p, "replace").map(|r| crate::cmd::props::normalize_line_endings(&r));
+    let names = boolean(p, "layerNames").unwrap_or(false);
+    let page = s.page()?;
+    let doc = s.doc_mut()?;
+    let mut hits = Vec::new();
+    let needle: Vec<char> = find.chars().collect();
+    let r_chars: Vec<char> = replace.as_deref().map(|r| r.chars().collect()).unwrap_or_default();
+    for i in doc.subtree(page) {
+        let Some(n) = doc.node(i) else { continue };
+        let text: Option<Vec<char>> = match &n.kind {
+            NodeKind::Text(t) => Some(t.characters.chars().collect()),
+            _ => None,
+        };
+        let text_hit = text.as_deref().is_some_and(|c| find_ci(c, &needle, 0).is_some());
+        let name_hit = names && find_ci(&n.name.chars().collect::<Vec<_>>(), &needle, 0).is_some();
+        if !(text_hit || name_hit) || n.is_page() {
+            continue;
+        }
+        hits.push(i);
+        if let Some(r) = &replace {
+            let n = doc.get_mut(i)?;
+            if names && name_hit {
+                let chars: Vec<char> = n.name.chars().collect();
+                let mut out = String::new();
+                let mut at = 0;
+                while let Some(pos) = find_ci(&chars, &needle, at) {
+                    out.extend(chars.get(at..pos).unwrap_or_default());
+                    out.push_str(r);
+                    at = pos + needle.len();
+                }
+                out.extend(chars.get(at..).unwrap_or_default());
+                n.name = out;
+            }
+            if let (NodeKind::Text(t), Some(mut chars)) = (&mut n.kind, text) {
+                // Replace occurrence by occurrence so styles shift correctly. The search resumes
+                // after each inserted replacement, so a replacement that matches `find` (in any
+                // case) neither loops forever nor stops the other occurrences.
+                let mut cursor = 0;
+                for _ in 0..10_000 {
+                    let Some(start) = find_ci(&chars, &needle, cursor) else { break };
+                    t.replace_range(start, start + needle.len(), r);
+                    chars.splice(start..start + needle.len(), r_chars.iter().copied());
+                    cursor = start + r_chars.len();
+                }
+            }
+        }
+    }
+    if boolean(p, "select").unwrap_or(true) {
+        s.set_selection(hits.clone());
+    }
+    Ok(json!({"matches": hits}))
+}
+
+/// Keys only some layer types take, the test for those layers, and why the others skip them.
+type TypedKeys<'a> = (&'a [&'a str], &'a dyn Fn(&Node) -> bool, &'a str);
+
+pub(super) fn set(s: &mut Session, p: &Value) -> Result<Value> {
+    let ids = req_targets("node.set", s, p)?;
+    let props = match get(p, "props") {
+        Some(Value::Object(m)) => m.clone(),
+        _ => {
+            // Allow flat params: {"id": 3, "fill": "#f00"}.
+            let mut m = p.as_object().cloned().unwrap_or_default();
+            m.remove("id");
+            m.remove("ids");
+            m
+        }
+    };
+    if props.is_empty() {
+        return Err(bad("node.set", "no properties given"));
+    }
+    // A new rotation for the selection turns it about its moved rotation origin: each layer's
+    // point under the origin stays put.
+    let ds = s.ds()?;
+    let pivot =
+        ds.moved_origin().filter(|_| props.contains_key("rotation") && !props.contains_key("x") && !props.contains_key("y") && ds.selection == ids);
+    let pinned: Vec<(NodeId, figcraft_geom::Point)> = match pivot {
+        Some(o) => roots(&ds.doc, &ids)
+            .into_iter()
+            .map(|i| (i, ds.doc.world_transform(i)))
+            .filter(|(_, w)| w.determinant().abs() > 1e-12)
+            .map(|(i, w)| (i, w.inverse() * o))
+            .collect(),
+        None => Vec::new(),
+    };
+    let mut warnings = font_style_warnings(&s.ds()?.doc, &ids, &props);
+    // Type-specific keys go to the layers that take them and are skipped, with a warning, on the
+    // others: auto layout keys to frame-like layers, `path` to vectors. With none among the targets
+    // that take them, the first refuses them (`props::layout_mut`, `props::apply`).
+    let doc = &s.ds()?.doc;
+    let layout_keys: Vec<&str> = props.keys().map(String::as_str).filter(|k| crate::cmd::props::LAYOUT_KEYS.contains(k)).collect();
+    let path_keys: Vec<&str> = props.keys().map(String::as_str).filter(|k| *k == "path").collect();
+    let frame_like = |n: &Node| n.kind.is_frame_like();
+    let vector = |n: &Node| matches!(n.kind, NodeKind::Vector { .. });
+    let typed: [TypedKeys; 2] = [
+        (&layout_keys, &frame_like, "only frames, components and instances have auto layout"),
+        (&path_keys, &vector, "only vector layers have a path"),
+    ];
+    let mut skipped: BTreeMap<NodeId, Map<String, Value>> = BTreeMap::new();
+    for (keys, takes, why) in typed {
+        let takes = |i: &NodeId| doc.node(*i).is_some_and(takes);
+        if keys.is_empty() || !ids.iter().any(takes) {
+            continue;
+        }
+        let others: Vec<NodeId> = ids.iter().copied().filter(|i| !takes(i)).collect();
+        if others.is_empty() {
+            continue;
+        }
+        for i in &others {
+            skipped.entry(*i).or_insert_with(|| props.clone()).retain(|k, _| !keys.contains(&k.as_str()));
+        }
+        let names: Vec<String> =
+            others.iter().take(10).filter_map(|i| doc.node(*i)).map(|n| format!("{} “{}” ({})", n.id, n.name, n.kind.type_name())).collect();
+        let more = if others.len() > names.len() { format!(" and {} more", others.len() - names.len()) } else { String::new() };
+        warnings.push(format!(
+            "{} skipped on {}{more}: {why}",
+            keys.iter().map(|k| format!("`{k}`")).collect::<Vec<_>>().join(", "),
+            names.join(", ")
+        ));
+    }
+    let doc = s.doc_mut()?;
+    let before = crate::cmd::styles::bound_before(doc, &ids);
+    for i in ids {
+        crate::cmd::props::apply("node.set", doc, i, skipped.get(&i).unwrap_or(&props))?;
+    }
+    crate::cmd::styles::detach_edited(doc, &before);
+    if let Some(o) = pivot {
+        for (i, q) in pinned {
+            let d = o - doc.world_transform(i) * q;
+            if d.hypot().is_finite() {
+                crate::cmd::arrange::move_world(doc, i, d.x, d.y)?;
+            }
+        }
+    }
+    if warnings.is_empty() { ok() } else { Ok(json!({"ok": true, "warnings": warnings})) }
+}
+
+/// A `fontStyle` draws in the family's face nearest to it, as a text layer resolves it. When that
+/// face has another weight or slant than the name asks for ("Black" on a family whose heaviest is
+/// Bold), say which face it is. Families that aren't installed, and names that match a style or a
+/// named instance (spelled any way: "SemiBold", "Semi Bold"), say nothing.
+fn font_style_warnings(doc: &figcraft_doc::Document, ids: &[NodeId], props: &serde_json::Map<String, Value>) -> Vec<String> {
+    let Some(style) = props.get("fontStyle").and_then(Value::as_str) else { return Vec::new() };
+    let mut families: Vec<String> = match props.get("fontFamily").and_then(Value::as_str) {
+        Some(f) => vec![f.to_string()],
+        None => ids
+            .iter()
+            .filter_map(|i| doc.node(*i))
+            .filter_map(|n| n.kind.text())
+            .flat_map(|t| t.spans().into_iter().map(|(_, _, st)| st.font_family.clone()).collect::<Vec<_>>())
+            .collect(),
+    };
+    families.sort();
+    families.dedup();
+    let norm = |s: &str| s.to_lowercase().replace([' ', '-', '_'], "");
+    let (want_w, want_i) = (i32::from(figcraft_doc::style_weight(style)), style.to_lowercase().contains("italic"));
+    families
+        .into_iter()
+        .filter_map(|family| {
+            let styles = figcraft_text::family_styles(&family);
+            if styles.is_empty() || styles.iter().any(|x| norm(x) == norm(style)) {
+                return None;
+            }
+            let face = figcraft_text::find_face(&family, style).filter(|f| f.family.eq_ignore_ascii_case(&family))?;
+            let w = face.axis("wght").map_or(i32::from(face.weight), |a| a.clamp(f64::from(want_w)).round() as i32);
+            if face.instance(style).is_some() || (w == want_w && face.italic == want_i) {
+                return None;
+            }
+            Some(format!("{family} has no `{style}` style: it draws in {}, the nearest (it has: {})", face.style, styles.join(", ")))
+        })
+        .collect()
+}
+
+/// `stroke.widthProfile`: a preset or points (through `node.set`'s `widthProfile`, so instances
+/// record the override).
+pub(super) fn width_profile(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "stroke.widthProfile";
+    let v = get(p, "preset").or_else(|| get(p, "points")).cloned().unwrap_or(Value::Null);
+    let ids = req_targets(cmd, s, p)?;
+    let props = serde_json::Map::from_iter([("widthProfile".to_string(), v)]);
+    let doc = s.doc_mut()?;
+    for i in ids {
+        crate::cmd::props::apply(cmd, doc, i, &props)?;
+    }
+    ok()
+}
+
+pub(super) fn stroke_brush(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "stroke.brush";
+    let v = if get(p, "preset").is_none_or(Value::is_null) { Value::Null } else { p.clone() };
+    let brush = crate::cmd::props::brush_of(&v).ok_or_else(|| bad(cmd, crate::cmd::props::BRUSH_HELP))?;
+    let ids = req_targets(cmd, s, p)?;
+    let doc = s.doc_mut()?;
+    for i in ids {
+        let n = doc.get_mut(i)?;
+        if brush.is_some() && n.strokes.is_empty() {
+            n.strokes.push(figcraft_color::Paint::solid(figcraft_color::Color::BLACK));
+        }
+        n.stroke.brush = brush.clone();
+    }
+    ok()
+}
+
+pub(super) fn reparent(s: &mut Session, p: &Value) -> Result<Value> {
+    let ids = req_targets("node.reparent", s, p)?;
+    let parent = req_id("node.reparent", p, "parent")?;
+    let index = num(p, "index").map(|i| i.max(0.0) as usize);
+    let doc = s.doc_mut()?;
+    let ids = z_sorted(doc, &roots(doc, &ids));
+    // `index` is where the first moved layer ends up among the parent's children (bottom first),
+    // counted after the move, the way `node.reorder` counts it. The layers land together, keeping
+    // their order, under the sibling that stays put and ends up just after them (none: on top).
+    let above = index.and_then(|at| doc.get(parent).ok()?.children.iter().filter(|c| !ids.contains(c)).nth(at).copied());
+    for i in &ids {
+        // Counted with the layer still in place, as `reparent` expects.
+        let at = above.and_then(|a| doc.node(parent)?.children.iter().position(|c| *c == a));
+        doc.reparent(*i, parent, at)?;
+    }
+    ok()
+}
+
+pub(super) fn paint_list(s: &mut Session, p: &Value, fills: bool, add: bool) -> Result<Value> {
+    let cmd = if fills { "fill" } else { "stroke" };
+    let ids = req_targets(cmd, s, p)?;
+    let index = if add || get(p, "index").is_none() { None } else { Some(req_index(cmd, p, "index")?) };
+    let doc = s.doc_mut()?;
+    for i in ids {
+        let n = doc.get_mut(i)?;
+        let frameish = n.kind.is_frame_like();
+        let list = if fills { &mut n.fills } else { &mut n.strokes };
+        if add {
+            let paint = match get(p, "paint").or_else(|| get(p, "color")) {
+                Some(v) => paint_of(v).ok_or_else(|| bad(cmd, "invalid paint"))?,
+                None if fills && frameish => figcraft_color::Paint::solid(figcraft_color::Color::WHITE),
+                None if fills => figcraft_color::Paint::solid(figcraft_color::Color::DEFAULT_SHAPE),
+                None => figcraft_color::Paint::solid(figcraft_color::Color::BLACK),
+            };
+            list.push(paint);
+        } else {
+            let idx = index.unwrap_or(list.len().saturating_sub(1));
+            // The paint's colour binding goes with it; later paints' move down one.
+            crate::cmd::lists::remove_item(n, if fills { crate::cmd::lists::BoundList::Fills } else { crate::cmd::lists::BoundList::Strokes }, idx);
+        }
+    }
+    ok()
+}
+
+pub(super) fn paint_set(s: &mut Session, p: &Value, fills: bool) -> Result<Value> {
+    let cmd = if fills { "fill.set" } else { "stroke.set" };
+    let ids = req_targets(cmd, s, p)?;
+    let idx = opt_index(cmd, p, "index")?;
+    let new_paint = match get(p, "paint") {
+        Some(v) => Some(paint_of(v).ok_or_else(|| bad(cmd, "invalid paint"))?),
+        None => None,
+    };
+    let col = color(p, "color");
+    let doc = s.doc_mut()?;
+    for i in ids {
+        let n = doc.get_mut(i)?;
+        let list = if fills { &mut n.fills } else { &mut n.strokes };
+        let at = idx.unwrap_or(list.len().saturating_sub(1));
+        if list.is_empty() {
+            list.push(figcraft_color::Paint::solid(if fills { figcraft_color::Color::DEFAULT_SHAPE } else { figcraft_color::Color::BLACK }));
+        }
+        let Some(slot) = list.get_mut(at) else { return Err(bad(cmd, format!("no paint at index {at}"))) };
+        let old = slot.clone();
+        if let Some(np) = &new_paint {
+            *slot = np.clone();
+        }
+        if let Some(c) = col {
+            slot.kind = figcraft_color::PaintKind::Solid { color: c.with_alpha(1.0) };
+            if c.a < 1.0 {
+                slot.opacity = c.a;
+                slot.color_alpha = c.a;
+            }
+        }
+        if let Some(o) = num(p, "opacity") {
+            slot.opacity = (if o > 1.0 { o / 100.0 } else { o }).clamp(0.0, 1.0) as f32;
+            slot.color_alpha = 1.0;
+        }
+        if let Some(v) = boolean(p, "visible") {
+            slot.visible = v;
+        }
+        if let Some(b) = blend(p, "blend") {
+            slot.blend = b;
+        }
+        crate::cmd::lists::rebind_edited_paint(n, fills, at, &old);
+        if fills {
+            n.styles.fill = None;
+        } else {
+            n.styles.stroke = None;
+        }
+    }
+    ok()
+}
+
+/// Copy paint `index` (the top one by default) of the first target into the clipboard. A stroke
+/// takes its node-wide settings (weight, alignment, sides, caps, joins, dashes) along.
+pub(super) fn paint_copy(s: &mut Session, p: &Value, fills: bool) -> Result<Value> {
+    let cmd = if fills { "fill.copy" } else { "stroke.copy" };
+    let id = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a layer"))?;
+    let at = opt_index(cmd, p, "index")?;
+    let (paint, stroke) = {
+        let doc = s.doc()?;
+        let n = doc.get(id)?;
+        let list = if fills { &n.fills } else { &n.strokes };
+        let at = at.unwrap_or(list.len().saturating_sub(1));
+        let paint = list.get(at).cloned().ok_or_else(|| bad(cmd, format!("no {} at index {at}", if fills { "fill" } else { "stroke" })))?;
+        (paint, (!fills).then(|| n.stroke.clone()))
+    };
+    s.clipboard.paint = Some((fills, paint.clone()));
+    s.clipboard.stroke = stroke;
+    serde_json::to_value(&paint).map_err(|e| bad(cmd, e.to_string()))
+}
+
+/// Paste the copied paint onto the targets: replacing paint `index` there, or adding one. A
+/// stroke's copied settings go onto each target too.
+pub(super) fn paint_paste(s: &mut Session, p: &Value, fills: bool) -> Result<Value> {
+    let cmd = if fills { "fill.paste" } else { "stroke.paste" };
+    let Some((copied_fills, paint)) = s.clipboard.paint.clone() else {
+        return Err(EngineError::Disabled(cmd.into(), "no copied fill or stroke".into()));
+    };
+    if copied_fills != fills {
+        let what = if fills { "stroke" } else { "fill" };
+        return Err(EngineError::Disabled(cmd.into(), format!("the copied paint is a {what}")));
+    }
+    let ids = req_targets(cmd, s, p)?;
+    // A copied pattern pointing at a target or a layer inside it would make the layer pattern
+    // itself; `fill.pattern` refuses the same, and the renderer would drop the pattern.
+    if let figcraft_color::PaintKind::Pattern(pt) = &paint.kind {
+        let doc = s.doc()?;
+        if ids.iter().any(|t| doc.is_ancestor(*t, NodeId(pt.source))) {
+            return Err(bad(cmd, "a layer can't be filled with itself or a layer inside it"));
+        }
+    }
+    let mut q = json!({"ids": ids, "paint": serde_json::to_value(paint).map_err(|e| bad(cmd, e.to_string()))?});
+    let out = match opt_index(cmd, p, "index")? {
+        Some(at) => {
+            q["index"] = json!(at);
+            paint_set(s, &q, fills)?
+        }
+        None => paint_list(s, &q, fills, true)?,
+    };
+    if let Some(stroke) = s.clipboard.stroke.clone().filter(|_| !fills) {
+        for id in ids {
+            s.doc_mut()?.get_mut(id)?.stroke = stroke.clone();
+        }
+    }
+    Ok(out)
+}
+
+pub(super) fn pattern_fill(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "fill.pattern";
+    let src = req_id(CMD, p, "source")?;
+    let doc = s.doc()?;
+    if doc.node(src).is_none_or(|n| n.is_page()) {
+        return Err(bad(CMD, "`source` must be a layer"));
+    }
+    if req_targets(CMD, s, p)?.iter().any(|t| doc.is_ancestor(*t, src)) {
+        return Err(bad(CMD, "a layer can't be filled with itself or a layer inside it"));
+    }
+    let mut pt = figcraft_color::PatternPaint::new(src.0);
+    pt.tile = parse(CMD, p, "tile")?.unwrap_or_default();
+    pt.align = parse(CMD, p, "align")?.unwrap_or_default();
+    pt.spacing = parse(CMD, p, "spacing")?.unwrap_or_default();
+    let (lo, hi) = figcraft_color::PatternPaint::SCALE_RANGE;
+    pt.scale = num(p, "scale").filter(|v| v.is_finite()).unwrap_or(1.0).clamp(lo, hi);
+    let mut q = if p.is_object() { p.clone() } else { json!({}) };
+    q["paint"] =
+        serde_json::to_value(figcraft_color::Paint { kind: figcraft_color::PaintKind::Pattern(pt), ..figcraft_color::Paint::pattern(src.0) })
+            .map_err(|e| bad(CMD, e.to_string()))?;
+    paint_set(s, &q, true)
+}
+
+pub(super) fn effect_add(s: &mut Session, p: &Value) -> Result<Value> {
+    let e: Effect = match crate::cmd::props::effect_from("effect.add", p, "effect")? {
+        Some(e) => e,
+        None => {
+            let ty = string(p, "type").unwrap_or_else(|| "dropShadow".into());
+            Effect::of_type(&ty).ok_or_else(|| bad("effect.add", format!("unknown effect type `{ty}`")))?
+        }
+    };
+    for i in req_targets("effect.add", s, p)? {
+        s.doc_mut()?.get_mut(i)?.effects.push(e.clone());
+    }
+    ok()
+}
+
+/// Copy effect `index` (the top one by default) of the first target into the clipboard.
+pub(super) fn effect_copy(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "effect.copy";
+    let id = targets(s, p).first().copied().ok_or_else(|| bad(CMD, "select a layer"))?;
+    let at = opt_index(CMD, p, "index")?;
+    let e = {
+        let doc = s.doc()?;
+        let list = &doc.get(id)?.effects;
+        let at = at.unwrap_or(list.len().saturating_sub(1));
+        list.get(at).cloned().ok_or_else(|| bad(CMD, format!("no effect at index {at}")))?
+    };
+    s.clipboard.effect = Some(e.clone());
+    serde_json::to_value(&e).map_err(|err| bad(CMD, err.to_string()))
+}
+
+/// Paste the copied effect onto the targets: replacing effect `index` there, or adding one.
+pub(super) fn effect_paste(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "effect.paste";
+    let Some(e) = s.clipboard.effect.clone() else {
+        return Err(EngineError::Disabled(CMD.into(), "no copied effect".into()));
+    };
+    let at = opt_index(CMD, p, "index")?;
+    for id in req_targets(CMD, s, p)? {
+        let n = s.doc_mut()?.get_mut(id)?;
+        match at {
+            Some(i) => {
+                if let Some(slot) = n.effects.get_mut(i) {
+                    *slot = e.clone();
+                }
+            }
+            None => n.effects.push(e.clone()),
+        }
+    }
+    ok()
+}
diff --git a/crates/engine/src/cmd/edit/select.rs b/crates/engine/src/cmd/edit/select.rs
new file mode 100644
index 00000000..03bba890
--- /dev/null
+++ b/crates/engine/src/cmd/edit/select.rs
@@ -0,0 +1,267 @@
+use super::*;
+
+pub(super) fn layers_at(s: &mut Session, p: &Value) -> Result<Value> {
+    let (x, y) = (req_num("select.layersAt", p, "x")?, req_num("select.layersAt", p, "y")?);
+    let doc = s.doc()?;
+    let zoom = s.ds()?.view.zoom.max(1e-6);
+    let sel = s.selection();
+    let result = crate::booleans::result_outline(doc, &sel);
+    let layers: Vec<Value> = figcraft_doc::geometry::layers_at(doc, s.page()?, figcraft_geom::Point::new(x, y), 2.0 / zoom, Some(&result))
+        .into_iter()
+        .filter_map(|(id, depth)| doc.node(id).map(|n| json!({"id": id, "name": n.name, "type": n.kind.type_name(), "depth": depth})))
+        .collect();
+    Ok(json!({"layers": layers}))
+}
+
+pub(super) fn select_all(s: &mut Session, _p: &Value) -> Result<Value> {
+    let doc = s.doc()?;
+    let sel = s.selection();
+    // Select all siblings of the current selection, else the page's top level.
+    let parent = sel.first().and_then(|i| doc.node(*i)).and_then(|n| n.parent).unwrap_or(s.page()?);
+    let ids: Vec<NodeId> = doc.get(parent)?.children.iter().copied().filter(|c| doc.node(*c).is_some_and(|n| n.visible && !n.locked)).collect();
+    s.set_selection(ids.clone());
+    Ok(json!({"selection": ids}))
+}
+
+/// What Select all would select, less the selection (hidden and locked layers neither).
+pub(super) fn select_inverse(s: &mut Session, _p: &Value) -> Result<Value> {
+    let doc = s.doc()?;
+    let sel = s.selection();
+    let parent = sel.first().and_then(|i| doc.node(*i)).and_then(|n| n.parent).unwrap_or(s.page()?);
+    let ids: Vec<NodeId> =
+        doc.get(parent)?.children.iter().copied().filter(|c| !sel.contains(c) && doc.node(*c).is_some_and(|n| n.visible && !n.locked)).collect();
+    s.set_selection(ids.clone());
+    Ok(json!({"selection": ids}))
+}
+
+/// `select.area`: what a marquee from (x, y) over the box selects; no box asks the app for one.
+pub(super) fn select_area(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "select.area";
+    let keys = ["x", "y", "width", "height"];
+    if keys.iter().all(|k| p.get(*k).is_none()) {
+        s.request_ui("selectArea", json!({}));
+        return ok();
+    }
+    let [x, y, w, h] = keys.map(|k| num(p, k));
+    let (Some(x), Some(y), Some(w), Some(h)) = (x, y, w, h) else { return Err(bad(cmd, "pass x, y, width and height (numbers)")) };
+    if ![x, y, w, h].iter().all(|v| v.is_finite() && v.abs() < 1e9) {
+        return Err(bad(cmd, "the box is out of range"));
+    }
+    let start = figcraft_geom::Point::new(x, y);
+    let r = figcraft_geom::Rect::from_points(start, figcraft_geom::Point::new(x + w, y + h));
+    let add = boolean(p, "add") == Some(true);
+    let base = if add { s.selection() } else { Vec::new() };
+    let within = s.marquee_within(start)?;
+    let sel = s.marquee_selection(r, within, boolean(p, "deep") == Some(true), &base, add)?;
+    s.set_selection(sel.clone());
+    Ok(json!({"selection": sel}))
+}
+
+pub(super) fn select_children(s: &mut Session, _p: &Value) -> Result<Value> {
+    let doc = s.doc()?;
+    let mut ids = Vec::new();
+    for i in s.selection() {
+        if let Some(n) = doc.node(i) {
+            ids.extend(n.children.iter().copied());
+        }
+    }
+    if ids.is_empty() {
+        return Ok(json!({"selection": s.selection()}));
+    }
+    s.set_selection(ids.clone());
+    Ok(json!({"selection": ids}))
+}
+
+pub(super) fn select_parent(s: &mut Session, _p: &Value) -> Result<Value> {
+    let doc = s.doc()?;
+    let mut ids: Vec<NodeId> = Vec::new();
+    for i in s.selection() {
+        if let Some(p) = doc.node(i).and_then(|n| n.parent)
+            && !doc.node(p).is_some_and(Node::is_page)
+            && !ids.contains(&p)
+        {
+            ids.push(p);
+        }
+    }
+    if ids.is_empty() {
+        return Ok(json!({"selection": s.selection()}));
+    }
+    s.set_selection(ids.clone());
+    Ok(json!({"selection": ids}))
+}
+
+pub(super) fn select_sibling(s: &mut Session, dir: i64) -> Result<Value> {
+    let doc = s.doc()?;
+    let sel = s.selection();
+    let Some(cur) = sel.last().copied() else {
+        let first = doc.get(s.page()?)?.children.last().copied();
+        s.set_selection(first.into_iter().collect());
+        return Ok(json!({"selection": s.selection()}));
+    };
+    let parent = doc.get(cur)?.parent.ok_or_else(|| bad("select.next", "no parent"))?;
+    let kids = &doc.get(parent)?.children;
+    let idx = kids.iter().position(|c| *c == cur).unwrap_or(0) as i64;
+    let n = kids.len() as i64;
+    // Layers panel order is reversed (top of the list = last child): Tab goes down the list.
+    let next = (idx - dir).rem_euclid(n.max(1)) as usize;
+    let id = kids.get(next).copied().unwrap_or(cur);
+    s.set_selection(vec![id]);
+    Ok(json!({"selection": [id]}))
+}
+
+pub(super) fn select_matching(s: &mut Session, _p: &Value) -> Result<Value> {
+    let doc = s.doc()?;
+    let sel = s.selection();
+    let Some(first) = sel.first().and_then(|i| doc.node(*i)) else { return Ok(json!({"selection": []})) };
+    let (name, ty) = (first.name.clone(), first.kind.type_name());
+    let page = s.page()?;
+    let ids: Vec<NodeId> =
+        doc.subtree(page).into_iter().filter(|i| doc.node(*i).is_some_and(|n| n.name == name && n.kind.type_name() == ty)).collect();
+    s.set_selection(ids.clone());
+    Ok(json!({"selection": ids}))
+}
+
+pub(super) fn select_same(s: &mut Session, same: impl Fn(&Node, &Node) -> bool) -> Result<Value> {
+    let doc = s.doc()?;
+    let sel = s.selection();
+    let Some(first) = sel.first().and_then(|i| doc.node(*i)).cloned() else { return Ok(json!({"selection": []})) };
+    let page = s.page()?;
+    let ids: Vec<NodeId> = doc.subtree(page).into_iter().filter(|i| *i != page && doc.node(*i).is_some_and(|n| same(&first, n))).collect();
+    s.set_selection(ids.clone());
+    Ok(json!({"selection": ids}))
+}
+
+/// The opacity number keys give: one digit is tens of percent (0 is 100%), two digits typed in
+/// quick succession the exact percentage.
+pub fn opacity_from_digits(digits: &str) -> Option<f32> {
+    let mut n = 0u32;
+    let mut count = 0;
+    for c in digits.chars() {
+        // Input-derived: a number that outgrows `u32` stops the scan (None); it never wraps.
+        n = n.checked_mul(10)?.checked_add(c.to_digit(10)?)?;
+        count += 1;
+    }
+    match count {
+        1 if n == 0 => Some(1.0),
+        1 => Some(n as f32 / 10.0),
+        2 => Some(n as f32 / 100.0),
+        _ => None,
+    }
+}
+
+pub(super) fn opacity_keys(s: &mut Session, p: &Value) -> Result<Value> {
+    let digits = req_string("object.opacityKeys", p, "digits")?;
+    let o = opacity_from_digits(&digits).ok_or_else(|| bad("object.opacityKeys", "`digits` must be one or two digits"))?;
+    let ids = req_targets("object.opacityKeys", s, p)?;
+    let doc = s.doc_mut()?;
+    let before = crate::cmd::styles::bound_before(doc, &ids);
+    for i in ids {
+        doc.get_mut(i)?.opacity = o;
+    }
+    crate::cmd::styles::detach_edited(doc, &before);
+    Ok(json!({"opacity": o}))
+}
+
+pub(super) fn nudge(s: &mut Session, p: &Value) -> Result<Value> {
+    let big = boolean(p, "big").unwrap_or(false);
+    let k = if big { s.prefs.nudge_big } else { s.prefs.nudge_small };
+    let (ux, uy) = (num_or(p, "dx", 0.0), num_or(p, "dy", 0.0));
+    let (dx, dy) = (ux * k, uy * k);
+    let ids = req_targets("transform.nudge", s, p)?;
+    // Edit a copy and keep it only if something moved, so an arrow that can't move anything adds
+    // no undo step.
+    let mut work = s.doc()?.clone();
+    let doc = &mut work;
+    let ids = roots(doc, &ids);
+    let mut changed = false;
+    // Children in an auto layout flow move one place instead (see `al_keys`).
+    for i in &ids {
+        if crate::al_keys::flowing_parent(doc, *i).is_none() && (dx, dy) != (0.0, 0.0) {
+            let n = doc.get_mut(*i)?;
+            n.transform = Affine::translate((dx, dy)) * n.transform;
+            changed = true;
+        }
+    }
+    for dir in crate::al_keys::Dir::from_units(ux, uy) {
+        // Grouped per arrow: a move into a neighbouring frame changes the parent.
+        let mut groups: BTreeMap<NodeId, Vec<NodeId>> = BTreeMap::new();
+        for i in &ids {
+            if let Some(parent) = crate::al_keys::flowing_parent(doc, *i) {
+                groups.entry(parent).or_default().push(*i);
+            }
+        }
+        for (parent, block) in groups {
+            changed |= crate::al_keys::arrow_move(doc, parent, &block, dir)?;
+        }
+    }
+    if changed {
+        s.ds_mut()?.doc = std::sync::Arc::new(work);
+    }
+    ok()
+}
+
+pub(super) fn nudge_size(s: &mut Session, p: &Value) -> Result<Value> {
+    let big = boolean(p, "big").unwrap_or(false);
+    let k = if big { s.prefs.nudge_big } else { s.prefs.nudge_small };
+    let (dw, dh) = (num_or(p, "dw", 0.0) * k, num_or(p, "dh", 0.0) * k);
+    let ids = req_targets("transform.nudgeSize", s, p)?;
+    let ids = roots(s.doc()?, &ids);
+    for i in ids {
+        let Some((w, h)) = s.doc()?.node(i).map(|n| (n.width, n.height)) else { continue };
+        let mut q = serde_json::Map::new();
+        q.insert("ids".into(), json!([i]));
+        // Only the axis that changes becomes fixed.
+        if dw != 0.0 {
+            q.insert("width".into(), json!((w + dw).max(0.0)));
+        }
+        if dh != 0.0 {
+            q.insert("height".into(), json!((h + dh).max(0.0)));
+        }
+        crate::cmd::arrange::resize_cmd(s, &Value::Object(q))?;
+    }
+    ok()
+}
+
+pub(super) fn toggle(s: &mut Session, p: &Value, what: &str) -> Result<Value> {
+    let ids = req_targets("object.toggle", s, p)?;
+    let doc = s.doc_mut()?;
+    let explicit = boolean(p, what);
+    // Figma: if any is visible, hide all (and vice versa).
+    let value = explicit.unwrap_or_else(|| match what {
+        "visible" => !ids.iter().all(|i| doc.node(*i).is_some_and(|n| n.visible)),
+        _ => !ids.iter().all(|i| doc.node(*i).is_some_and(|n| n.locked)),
+    });
+    for i in &ids {
+        let n = doc.get_mut(*i)?;
+        if what == "visible" {
+            n.visible = value;
+        } else {
+            n.locked = value;
+        }
+    }
+    if what == "locked" && value {
+        s.set_selection(vec![]);
+    }
+    Ok(json!({what: value}))
+}
+
+pub(super) fn hide_others(s: &mut Session, _p: &Value) -> Result<Value> {
+    let sel = s.selection();
+    let page = s.page()?;
+    let doc = s.doc_mut()?;
+    let keep: BTreeSet<NodeId> = sel
+        .iter()
+        .flat_map(|i| {
+            let mut v = doc.ancestors(*i);
+            v.push(*i);
+            v
+        })
+        .collect();
+    let tops: Vec<NodeId> = doc.get(page)?.children.clone();
+    for t in tops {
+        if !keep.contains(&t) {
+            doc.get_mut(t)?.visible = false;
+        }
+    }
+    ok()
+}

From 0b9fcb7f4e4519efc9ff2761ff8497428cd17bd6 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:20:45 +0000
Subject: [PATCH 30/67] refactor(engine): split cmd/component.rs into
 component/

---
 crates/engine/src/cmd/component.rs          | 1193 +------------------
 crates/engine/src/cmd/component/instance.rs |  404 +++++++
 crates/engine/src/cmd/component/props.rs    |  609 ++++++++++
 crates/engine/src/cmd/component/variants.rs |  175 +++
 4 files changed, 1199 insertions(+), 1182 deletions(-)
 create mode 100644 crates/engine/src/cmd/component/instance.rs
 create mode 100644 crates/engine/src/cmd/component/props.rs
 create mode 100644 crates/engine/src/cmd/component/variants.rs

diff --git a/crates/engine/src/cmd/component.rs b/crates/engine/src/cmd/component.rs
index 428738d1..5abe79b8 100644
--- a/crates/engine/src/cmd/component.rs
+++ b/crates/engine/src/cmd/component.rs
@@ -11,6 +11,17 @@ use crate::components::*;
 use crate::params::*;
 use crate::{EngineError, Result, Session, bad, spec};
 
+mod instance;
+mod props;
+mod variants;
+
+use instance::{detach, make_slot, push_changes, remove_slot, reset_instance, reset_override, reset_slot, restore_main, slot_insert, swap};
+pub(crate) use instance::{swap_at, swap_instance};
+use props::{add_prop, bind_prop, delete_prop, edit_prop, set_props};
+pub(crate) use props::{apply_prop_bindings, check_prop_binding, describe_props};
+use variants::{add_variant, combine};
+pub use variants::{can_add_variant, can_combine_variants};
+
 /// `component.hideWhenPublishing`: the leading `.` of the names of this file's components and
 /// sets (those `ids` are or are in), put on or taken off.
 fn hide_when_publishing(s: &mut Session, p: &Value) -> Result<Value> {
@@ -343,1185 +354,3 @@ fn set_name_from(variant: &str) -> Option<String> {
     let base = variant.rsplit_once('/').map_or(variant, |(path, _)| path).trim();
     (!base.is_empty() && !base.contains('=')).then(|| base.to_string())
 }
-
-/// Wrap components in a new component set (named after the first) placed around them.
-fn wrap_in_set(cmd: &str, doc: &mut Document, ids: &[NodeId]) -> Result<NodeId> {
-    let top = *ids.last().ok_or_else(|| bad(cmd, "nothing selected"))?;
-    let parent = doc.get(top)?.parent.ok_or_else(|| bad(cmd, "page"))?;
-    if inside_instance(doc, top) || owning_instance(doc, parent).is_some() {
-        return Err(EngineError::Disabled(cmd.into(), INSIDE_INSTANCE.into()));
-    }
-    let bounds = doc.bounds_of(ids).unwrap_or_default();
-    let pw = doc.world_transform(parent);
-    let local = figcraft_geom::transform_rect_bbox(pw.inverse(), bounds.inflate(20.0, 20.0));
-    let base = ids.first().and_then(|i| doc.node(*i)).and_then(|n| set_name_from(&n.name)).unwrap_or_else(|| doc.next_name("Component"));
-    let set = doc.alloc_id();
-    let mut n = Node::new(set, NodeKind::ComponentSet { description: String::new() }, base, local.width(), local.height());
-    n.transform = figcraft_geom::Affine::translate((local.x0, local.y0));
-    n.fills.clear();
-    doc.insert(n, parent, doc.index_in_parent(top).map(|i| i + 1))?;
-    for i in ids {
-        doc.reparent(*i, set, None)?;
-    }
-    Ok(set)
-}
-
-const INSIDE_INSTANCE: &str = "components inside an instance can't become variants";
-
-/// Why `ids` (distinct) can't become the variants of a new component set, or `None` when they
-/// can: anything but main components, components that are variants already (combining them would
-/// put a set in a set), library copies, components inside an instance, and a component inside
-/// another one of `ids`.
-fn combine_refusal(doc: &Document, ids: &[NodeId]) -> Option<&'static str> {
-    if !ids.iter().all(|i| doc.node(*i).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. }))) {
-        Some("select components only")
-    } else if ids.iter().any(|i| variant_set(doc, *i).is_some()) {
-        Some("components that are variants already can't be combined again")
-    } else if ids.iter().any(|i| doc.is_remote(*i)) {
-        Some(crate::library::READ_ONLY)
-    } else if ids.iter().any(|i| inside_instance(doc, *i)) {
-        Some(INSIDE_INSTANCE)
-    } else if roots(doc, ids).len() != ids.len() {
-        Some("a component can't be combined with one inside it")
-    } else {
-        None
-    }
-}
-
-/// Whether "Combine as variants" is on offer for `ids` (menus and the Design panel): two or more
-/// main components that [`combine_refusal`] lets through.
-pub fn can_combine_variants(doc: &Document, ids: &[NodeId]) -> bool {
-    ids.len() >= 2 && combine_refusal(doc, ids).is_none() && ids.iter().collect::<BTreeSet<_>>().len() == ids.len()
-}
-
-/// Whether "Add variant" is on offer for `id`: a component set with variants, a variant, or a main
-/// component not in a set yet (it becomes one); never a library copy or inside an instance.
-pub fn can_add_variant(doc: &Document, id: NodeId) -> bool {
-    let Some(n) = doc.node(id) else { return false };
-    let local = !doc.is_remote(id) && !inside_instance(doc, id);
-    match n.kind {
-        NodeKind::ComponentSet { .. } => {
-            local && n.children.iter().any(|c| doc.node(*c).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })))
-        }
-        NodeKind::Component { .. } => local,
-        _ => false,
-    }
-}
-
-/// Wrap `ids` (z-sorted main components) in a new component set, naming them "Property 1=Default",
-/// "Property 1=VariantN" unless already in prop=value form. Returns the set.
-fn make_variant_set(cmd: &str, doc: &mut Document, ids: &[NodeId]) -> Result<NodeId> {
-    let set = wrap_in_set(cmd, doc, ids)?;
-    for (k, i) in ids.iter().enumerate() {
-        let node = doc.get_mut(*i)?;
-        if !node.name.contains('=') {
-            node.name = format!("Property 1={}", if k == 0 { "Default".to_string() } else { format!("Variant{}", k + 1) });
-        }
-    }
-    Ok(set)
-}
-
-fn combine(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.combineVariants";
-    let mut seen = BTreeSet::new();
-    let ids: Vec<NodeId> = req_targets(cmd, s, p)?.into_iter().filter(|i| seen.insert(*i)).collect();
-    let doc = s.doc_mut()?;
-    if let Some(why) = combine_refusal(doc, &ids) {
-        return Err(EngineError::Disabled(cmd.into(), why.into()));
-    }
-    let ids = z_sorted(doc, &ids);
-    let set = make_variant_set(cmd, doc, &ids)?;
-    s.set_selection(vec![set]);
-    Ok(json!({"id": set}))
-}
-
-/// Grow a component set so it wraps its variants with 20 px of padding (right and bottom).
-fn fit_set(doc: &mut Document, set: NodeId) {
-    let Some(kids) = doc.node(set).map(|n| n.children.clone()) else { return };
-    let (mut w, mut h) = (0.0f64, 0.0f64);
-    for c in kids {
-        if let Some(n) = doc.node(c) {
-            let b = figcraft_geom::transform_rect_bbox(n.transform, n.local_rect());
-            w = w.max(b.x1 + 20.0);
-            h = h.max(b.y1 + 20.0);
-        }
-    }
-    if let Some(n) = doc.node_mut(set) {
-        n.width = n.width.max(w);
-        n.height = n.height.max(h);
-    }
-}
-
-fn add_variant(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.addVariant";
-    let t = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component set or component"))?;
-    let doc = s.doc_mut()?;
-    let (set, base) = match doc.get(t)?.kind {
-        NodeKind::ComponentSet { .. } => {
-            let last = doc.get(t)?.children.last().copied().ok_or_else(|| bad(cmd, "the component set is empty"))?;
-            (t, last)
-        }
-        NodeKind::Component { .. } => match variant_set(doc, t) {
-            Some(set) => (set, t),
-            // A main component on its own becomes a set of itself, then gains the new variant.
-            None => (make_variant_set(cmd, doc, &[t])?, t),
-        },
-        _ => return Err(bad(cmd, "select a component set or component")),
-    };
-    let options = variant_options(doc, set);
-    let mut pairs = variant_props(&doc.get(base)?.name);
-    let order: Vec<String> = options.iter().map(|(k, _)| k.clone()).collect();
-    let existing: BTreeSet<BTreeMap<String, String>> =
-        doc.get(set)?.children.iter().filter_map(|c| doc.node(*c)).map(|n| variant_props(&n.name)).collect();
-    match (string(p, "property"), string(p, "value")) {
-        (Some(prop), Some(value)) => {
-            let (prop, value) = (prop.trim().to_string(), value.trim().to_string());
-            if !options.iter().any(|(k, _)| *k == prop) {
-                return Err(bad(cmd, format!("unknown variant property `{prop}`")));
-            }
-            if value.is_empty() || value.contains([',', '=']) {
-                return Err(bad(cmd, "`value` must be non-empty without ',' or '='"));
-            }
-            pairs.insert(prop, value);
-            if existing.contains(&pairs) {
-                return Err(bad(cmd, "that variant already exists"));
-            }
-        }
-        (Some(_), None) => return Err(bad(cmd, "`value` is required with `property`")),
-        _ => {
-            let prop = order.first().cloned().unwrap_or_else(|| "Property 1".into());
-            let mut k = existing.len() + 1;
-            loop {
-                pairs.insert(prop.clone(), format!("Variant{k}"));
-                if !existing.contains(&pairs) || k > 10_000 {
-                    break;
-                }
-                k += 1;
-            }
-        }
-    }
-    let name = variant_name(&pairs, &order);
-    let bottom = doc
-        .get(set)?
-        .children
-        .iter()
-        .filter_map(|c| doc.node(*c))
-        .map(|n| figcraft_geom::transform_rect_bbox(n.transform, n.local_rect()).y1)
-        .fold(0.0f64, f64::max);
-    let dup = doc.duplicate_into(base, set, None)?;
-    let n = doc.get_mut(dup)?;
-    n.name = name;
-    let c = n.transform.as_coeffs();
-    n.transform = figcraft_geom::Affine::new([c[0], c[1], c[2], c[3], c[4], bottom + 20.0]);
-    fit_set(doc, set);
-    s.set_selection(vec![dup]);
-    Ok(json!({"id": dup}))
-}
-
-fn detach(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.detach";
-    let ids = req_targets(cmd, s, p)?;
-    let doc = s.doc_mut()?;
-    let mut out = Vec::new();
-    for i in ids {
-        if !matches!(doc.get(i)?.kind, NodeKind::Instance { .. }) {
-            continue;
-        }
-        if inside_instance(doc, i) {
-            return Err(EngineError::Disabled(cmd.into(), "a nested instance can't be detached on its own: detach the outer instance first".into()));
-        }
-        // Own layers lose their link (slot content stays as it is); nested instances stay
-        // instances of their own mains.
-        let nested = unlink_layers(doc, i, Some(i));
-        keep_main_modes(doc, i)?;
-        let n = doc.get_mut(i)?;
-        n.kind = NodeKind::Frame;
-        n.source = None;
-        n.overrides.clear();
-        n.prop_refs.remove("mainComponent");
-        // No properties left to drive.
-        n.bound.retain(|k, _| !k.starts_with(PROP_BINDING));
-        for nn in nested {
-            rebase_instance(doc, nn);
-        }
-        out.push(i);
-    }
-    if out.is_empty() {
-        return Err(EngineError::Disabled(cmd.into(), "select an instance".into()));
-    }
-    s.set_selection(out.clone());
-    Ok(json!({"ids": out}))
-}
-
-/// Make the variable modes instance `i` takes from its main its own (it's being detached).
-fn keep_main_modes(doc: &mut Document, i: NodeId) -> Result<()> {
-    let modes = match doc.get(i)?.kind {
-        NodeKind::Instance { component, .. } => doc.node(component).map(|m| m.var_modes.clone()).unwrap_or_default(),
-        _ => return Ok(()),
-    };
-    let own = &mut doc.get_mut(i)?.var_modes;
-    for (c, m) in modes {
-        own.entry(c).or_insert(m);
-    }
-    Ok(())
-}
-
-fn reset_instance(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.resetInstance";
-    let ids = req_targets(cmd, s, p)?;
-    let doc = s.doc_mut()?;
-    let mut done = Vec::new();
-    for i in ids {
-        let Some(inst) = owning_instance(doc, i) else { continue };
-        let top = !inside_instance(doc, inst);
-        for d in doc.subtree(inst) {
-            let keep: Vec<&str> = if d == inst && top { vec!["size"] } else { vec![] };
-            if let Some(n) = doc.node(d)
-                && n.overrides.iter().any(|g| !keep.contains(&g.as_str()))
-                && let Some(n) = doc.node_mut(d)
-            {
-                n.overrides.retain(|g| keep.contains(&g.as_str()));
-            }
-        }
-        // Property values go back to the defaults.
-        if top
-            && let Some(NodeKind::Instance { component, props }) = doc.node(inst).map(|n| n.kind.clone())
-            && let Some(defaults) = doc.node(component).map(default_props)
-            && props != defaults
-            && let NodeKind::Instance { props, .. } = &mut doc.get_mut(inst)?.kind
-        {
-            *props = defaults;
-        }
-        // ...and stop following variables.
-        if top && doc.node(inst).is_some_and(|n| n.bound.keys().any(|k| k.starts_with(PROP_BINDING))) {
-            doc.get_mut(inst)?.bound.retain(|k, _| !k.starts_with(PROP_BINDING));
-        }
-        done.push(inst);
-    }
-    if done.is_empty() {
-        return Err(EngineError::Disabled(cmd.into(), "select an instance".into()));
-    }
-    Ok(json!({"ids": done}))
-}
-
-fn reset_override(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.resetOverride";
-    let i = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a layer inside an instance"))?;
-    let group = string(p, "group");
-    if let Some(g) = &group
-        && !OVERRIDE_GROUPS.contains(&g.as_str())
-    {
-        return Err(bad(cmd, format!("unknown group `{g}` (known: {})", OVERRIDE_GROUPS.join(", "))));
-    }
-    let doc = s.doc_mut()?;
-    if owning_instance(doc, i).is_none() || doc.get(i)?.source.is_none() {
-        return Err(bad(cmd, "not a layer of an instance"));
-    }
-    let top_root = matches!(doc.get(i)?.kind, NodeKind::Instance { .. }) && !inside_instance(doc, i);
-    let had = doc.get(i)?.overrides.clone();
-    let n = doc.get_mut(i)?;
-    match &group {
-        Some(g) => {
-            n.overrides.remove(g);
-        }
-        None => n.overrides.clear(),
-    }
-    let mut changed = had != doc.get(i)?.overrides;
-    // The instance's own property values reset with `props`.
-    if top_root
-        && group.as_deref().is_none_or(|g| g == "props")
-        && let Some(NodeKind::Instance { component, props }) = doc.node(i).map(|n| n.kind.clone())
-        && let Some(defaults) = doc.node(component).map(default_props)
-        && props != defaults
-        && let NodeKind::Instance { props, .. } = &mut doc.get_mut(i)?.kind
-    {
-        *props = defaults;
-        changed = true;
-    }
-    Ok(json!({"changed": changed}))
-}
-
-/// A property name for `owner` based on `base` (a layer name): valid and not taken yet.
-fn fresh_prop_name(doc: &Document, owner: &Owner, base: &str) -> String {
-    let base: String = base.chars().filter(|c| !matches!(c, ',' | '=')).take(100).collect::<String>().trim().to_string();
-    let base = if base.is_empty() { "Slot".to_string() } else { base };
-    let taken = |n: &str| {
-        owner.components(doc).iter().any(|c| prop_defs(doc, *c).contains_key(n))
-            || matches!(owner, Owner::Set(s) if variant_options(doc, *s).iter().any(|(k, _)| k == n))
-    };
-    (1..10_000).map(|k| if k == 1 { base.clone() } else { format!("{base} {k}") }).find(|n| !taken(n)).unwrap_or(base)
-}
-
-/// The `preferred` components of a slot property: component or component set ids.
-fn preferred_arg(cmd: &str, doc: &Document, p: &Value) -> Result<Vec<NodeId>> {
-    let Some(v) = get(p, "preferred").filter(|v| !v.is_null()) else { return Ok(Vec::new()) };
-    let list = v.as_array().ok_or_else(|| bad(cmd, "`preferred`: an array of component ids"))?;
-    let mut out = Vec::new();
-    for x in list.iter().take(500) {
-        let c = id_of(x)
-            .filter(|c| doc.node(*c).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. } | NodeKind::ComponentSet { .. })))
-            .ok_or_else(|| bad(cmd, format!("`preferred`: {x} is not a component or component set")))?;
-        if !out.contains(&c) {
-            out.push(c);
-        }
-    }
-    Ok(out)
-}
-
-fn make_slot(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.makeSlot";
-    let id = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a frame inside a main component"))?;
-    let doc = s.doc()?;
-    let n = doc.get(id)?;
-    let inside_main = owning_component(doc, id).is_some_and(|c| c != id) && owning_instance(doc, id).is_none();
-    if !matches!(n.kind, NodeKind::Frame) || !inside_main {
-        return Err(bad(cmd, "only a frame inside a main component (not inside an instance) can become a slot"));
-    }
-    if is_slot(doc, id) {
-        return Err(EngineError::Disabled(cmd.into(), format!("\"{}\" is already a slot", n.name)));
-    }
-    let owner = Owner::resolve(doc, id).ok_or_else(|| bad(cmd, "the frame isn't inside a component"))?;
-    let name = string(p, "name").unwrap_or_else(|| fresh_prop_name(doc, &owner, &n.name));
-    let preferred = get(p, "preferred").cloned().unwrap_or(Value::Null);
-    add_prop_for(cmd, s, &json!({"id": id, "layer": id, "name": name, "type": "slot", "preferred": preferred}))
-}
-
-fn remove_slot(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.removeSlot";
-    let id = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a slot frame of a main component"))?;
-    let doc = s.doc()?;
-    if owning_instance(doc, id).is_some() {
-        return Err(EngineError::Disabled(cmd.into(), "slots are removed on the main component".into()));
-    }
-    let name = slot_name(doc, id).ok_or_else(|| bad(cmd, "not a slot frame of a main component"))?;
-    delete_prop(s, &json!({"id": id, "name": name}))?;
-    Ok(json!({"id": id, "name": name}))
-}
-
-/// The slot inside an instance a command acts on: `id` itself, or instance `id`'s slot `name`.
-fn instance_slot(cmd: &str, doc: &Document, id: NodeId, name: Option<&str>) -> Result<NodeId> {
-    let slot = match name {
-        Some(nm) => slots_of(doc, id).into_iter().find(|(_, n)| n == nm).map(|(l, _)| l).ok_or_else(|| bad(cmd, format!("no slot named `{nm}`")))?,
-        None => id,
-    };
-    if !is_slot(doc, slot) || owning_instance(doc, slot).is_none() {
-        return Err(bad(cmd, "not a slot of an instance (a main component's slot takes layers like any frame)"));
-    }
-    Ok(slot)
-}
-
-fn slot_insert(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "instance.slotInsert";
-    let c = req_id(cmd, p, "component")?;
-    let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a slot inside an instance"))?;
-    let index = match get(p, "index").filter(|v| !v.is_null()) {
-        None => None,
-        Some(v) => Some(v.as_u64().and_then(|i| usize::try_from(i).ok()).ok_or_else(|| bad(cmd, "`index`: a child index (0 = bottom)"))?),
-    };
-    let doc = s.doc_mut()?;
-    let slot = instance_slot(cmd, doc, target, string(p, "slot").as_deref())?;
-    let c = main_of(doc, c).ok_or_else(|| bad(cmd, "`component` must be a component or component set"))?;
-    if boolean(p, "replace").unwrap_or(false) {
-        for k in doc.get(slot)?.children.clone() {
-            doc.remove(k)?;
-        }
-    }
-    let i = create_instance_at(doc, c, slot, 0.0, 0.0, index)?;
-    s.set_selection(vec![i]);
-    Ok(json!({"id": i, "slot": slot}))
-}
-
-fn reset_slot(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "instance.resetSlot";
-    let id = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a slot inside an instance"))?;
-    let doc = s.doc_mut()?;
-    let slot = instance_slot(cmd, doc, id, string(p, "slot").as_deref())?;
-    let changed = slot_edited(doc, slot);
-    if changed {
-        doc.get_mut(slot)?.overrides.remove(SLOT);
-    }
-    Ok(json!({"id": slot, "changed": changed}))
-}
-
-fn push_changes(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.pushChanges";
-    let i = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select an instance"))?;
-    let doc = s.doc_mut()?;
-    // Changes go to the outer instance's main (never into a nested instance's own main).
-    let inst = root_instance(doc, i).ok_or_else(|| bad(cmd, "not an instance"))?;
-    let Some(NodeKind::Instance { component, .. }) = doc.node(inst).map(|n| n.kind.clone()) else { return ok() };
-    if !doc.contains(component) {
-        return Err(EngineError::Disabled(cmd.into(), "the main component was deleted (use component.restoreMain)".into()));
-    }
-    // Copy every overridden layer's values to its source in the main (geometry, resizing, swaps,
-    // property values and slot content stay with the instance).
-    let mut pushed = 0;
-    for d in doc.subtree(inst) {
-        let Some(n) = doc.node(d).cloned() else { continue };
-        let Some(src) = (if d == inst { Some(component) } else { n.source }) else { continue };
-        if n.overrides.is_empty() || !doc.contains(src) || !doc.is_ancestor(component, src) {
-            continue;
-        }
-        let Some(mut target) = doc.node(src).cloned() else { continue };
-        let groups: BTreeSet<String> = n
-            .overrides
-            .iter()
-            .filter(|g| !(matches!(g.as_str(), "size" | "resizing" | "position" | "component" | "props" | SLOT) || d == inst && g.as_str() == "name"))
-            .cloned()
-            .collect();
-        for g in &groups {
-            copy_group(&n, &mut target, g);
-        }
-        if groups.is_empty() {
-            continue;
-        }
-        pushed += 1;
-        if let Some(slot) = doc.node_mut(src) {
-            *slot = target;
-        }
-        if let Some(m) = doc.node_mut(d) {
-            m.overrides.retain(|g| !groups.contains(g));
-        }
-    }
-    Ok(json!({"layers": pushed}))
-}
-
-fn restore_prop_defs(doc: &Document, props: &BTreeMap<String, Value>) -> BTreeMap<String, PropDef> {
-    let mut defs = BTreeMap::new();
-    for (k, v) in props {
-        let def = match v {
-            Value::Bool(b) => PropDef::Boolean { default: *b },
-            Value::String(t) => PropDef::Text { default: t.clone() },
-            other => match id_of(other) {
-                Some(c) if doc.contains(c) => PropDef::InstanceSwap { default: c, preferred: Vec::new() },
-                _ => continue,
-            },
-        };
-        defs.insert(k.clone(), def);
-    }
-    defs
-}
-
-fn restore_id_map(doc: &mut Document, i: NodeId, component: NodeId, sub: &[NodeId]) -> BTreeMap<NodeId, NodeId> {
-    let mut map: BTreeMap<NodeId, NodeId> = BTreeMap::new();
-    let mut used: BTreeSet<NodeId> = BTreeSet::new();
-    map.insert(i, component);
-    used.insert(component);
-    for d in sub.iter().filter(|d| **d != i) {
-        let src = doc.node(*d).and_then(|n| n.source);
-        let nid = match src {
-            Some(s) if !doc.contains(s) && used.insert(s) => s,
-            _ => doc.alloc_id(),
-        };
-        map.insert(*d, nid);
-    }
-    map
-}
-
-fn restore_main(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.restoreMain";
-    let i = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select an instance"))?;
-    let doc = s.doc_mut()?;
-    let Some(NodeKind::Instance { component, props }) = doc.node(i).map(|n| n.kind.clone()) else {
-        return Err(bad(cmd, "select an instance"));
-    };
-    if doc.contains(component) {
-        return Err(EngineError::Disabled(cmd.into(), "the main component still exists".into()));
-    }
-    if inside_instance(doc, i) {
-        return Err(EngineError::Disabled(cmd.into(), "select the outer instance".into()));
-    }
-    let parent = doc.get(i)?.parent.ok_or_else(|| bad(cmd, "no parent"))?;
-    let index = doc.index_in_parent(i);
-    // The main comes back with its old id (other instances point to it) and its layers with the
-    // ids their copies mirror, so every instance re-links by source.
-    let sub = doc.subtree(i);
-    let map = restore_id_map(doc, i, component, &sub);
-    let mut nodes = Vec::new();
-    let mut nested = Vec::new();
-    for d in &sub {
-        let Some(mut n) = doc.node(*d).cloned() else { continue };
-        if *d == i {
-            let defs = restore_prop_defs(doc, &props);
-            n.kind = NodeKind::Component { description: String::new(), props: defs };
-            n.source = None;
-            n.overrides.clear();
-            n.prop_refs.clear();
-        } else {
-            let parent_inst = n.parent.and_then(|p| owning_instance(doc, p));
-            if parent_inst != Some(i) {
-                nodes.push(n);
-                continue;
-            }
-            if matches!(n.kind, NodeKind::Instance { .. }) {
-                nested.push(*d);
-            } else {
-                n.source = None;
-                n.overrides.clear();
-            }
-        }
-        nodes.push(n);
-    }
-    doc.remove(i)?;
-    doc.paste_nodes(&nodes, &map, i, parent, index)?;
-    for nn in nested {
-        if let Some(m) = map.get(&nn).copied() {
-            rebase_instance(doc, m);
-        }
-    }
-    s.set_selection(vec![component]);
-    Ok(json!({"id": component}))
-}
-
-fn swap(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "instance.swap";
-    let c = req_id(cmd, p, "component")?;
-    let ids = req_targets(cmd, s, p)?;
-    let doc = s.doc_mut()?;
-    let c = main_of(doc, c).ok_or_else(|| bad(cmd, "`component` must be a component or component set"))?;
-    for i in ids {
-        swap_instance(doc, i, c).map_err(|m| bad(cmd, m))?;
-    }
-    ok()
-}
-
-/// Make instance `i` show main component `c`, keeping the values of properties with the same names
-/// (the layers' overrides follow by name when the instance is rebuilt).
-pub(crate) fn swap_instance(doc: &mut Document, i: NodeId, c: NodeId) -> std::result::Result<(), String> {
-    if doc.is_ancestor(c, i) {
-        return Err("an instance can't show the component it is inside".into());
-    }
-    let defaults = doc.node(c).map(default_props).unwrap_or_default();
-    match doc.get_mut(i).map(|n| &mut n.kind) {
-        Ok(NodeKind::Instance { component, props }) => {
-            *component = c;
-            let old = std::mem::take(props);
-            *props = defaults.iter().map(|(k, d)| (k.clone(), old.get(k).cloned().unwrap_or_else(|| d.clone()))).collect();
-            Ok(())
-        }
-        _ => Err(format!("{i} is not an instance")),
-    }
-}
-
-/// Swap the instance under a page point to a component (`instance.swapAt`).
-pub(crate) fn swap_at(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "instance.swapAt";
-    let c = req_id(cmd, p, "component")?;
-    let pt = figcraft_geom::Point::new(req_num(cmd, p, "x")?, req_num(cmd, p, "y")?);
-    let page = s.page()?;
-    let doc = s.doc()?;
-    let c = main_of(doc, c).ok_or_else(|| bad(cmd, "`component` must be a component or component set"))?;
-    let family = crate::drop::swap_family(doc, c);
-    let target = crate::drop::swap_target(doc, page, pt, family.as_deref(), Some(c))
-        .ok_or_else(|| EngineError::Disabled(cmd.into(), "there is no instance at that point to swap".into()))?;
-    keep_text_overrides(s.doc_mut()?, target);
-    swap(s, &json!({"ids": [target], "component": c}))?;
-    s.set_selection(vec![target]);
-    Ok(json!({"id": target, "component": c}))
-}
-
-/// Whether instance `id` has a component property `name` that a `kind` variable can drive (a
-/// boolean property takes a boolean variable, a text or variant property a string one).
-pub(crate) fn check_prop_binding(doc: &Document, id: NodeId, name: &str, kind: VariableType) -> std::result::Result<(), String> {
-    let Some(NodeKind::Instance { component, .. }) = doc.node(id).map(|n| &n.kind) else {
-        return Err(format!("{id} is not an instance (component properties are bound on instances)"));
-    };
-    if variant_set(doc, *component).is_some_and(|set| variant_options(doc, set).iter().any(|(o, _)| o == name)) {
-        return if kind == VariableType::String { Ok(()) } else { Err(format!("`{name}` is a variant property: bind a string variable")) };
-    }
-    match (prop_defs(doc, *component).get(name), kind) {
-        (Some(PropDef::Boolean { .. }), VariableType::Boolean) | (Some(PropDef::Text { .. }), VariableType::String) => Ok(()),
-        (Some(PropDef::Boolean { .. }), _) => Err(format!("`{name}` is a boolean property: bind a boolean variable")),
-        (Some(PropDef::Text { .. }), _) => Err(format!("`{name}` is a text property: bind a string variable")),
-        (Some(_), _) => Err(format!("`{name}`: only boolean and text properties can be bound to variables")),
-        (None, _) => Err(format!("the instance has no property named `{name}`")),
-    }
-}
-
-/// Write bound variable values into instance `id`'s boolean and text property values, and switch
-/// it to the variant its bound variant properties name (only what changed; the instance then
-/// follows like after `instance.setProperties`). A value that names no variant changes nothing.
-pub(crate) fn apply_prop_bindings(doc: &mut Document, id: NodeId, sets: &[(String, VariableValue)]) {
-    let Some(NodeKind::Instance { component, .. }) = doc.node(id).map(|n| &n.kind) else { return };
-    let component = *component;
-    if let Some(set) = variant_set(doc, component) {
-        let options = variant_options(doc, set);
-        let current = doc.node(component).map(|c| variant_props(&c.name)).unwrap_or_default();
-        let mut wanted = current.clone();
-        for (name, val) in sets {
-            if let VariableValue::String(t) = val
-                && options.iter().any(|(o, vals)| o == name && vals.contains(t))
-            {
-                wanted.insert(name.clone(), t.clone());
-            }
-        }
-        if wanted != current
-            && let Some(target) = find_variant(doc, set, &wanted)
-            && let Ok(n) = doc.get_mut(id)
-            && let NodeKind::Instance { component: c, .. } = &mut n.kind
-        {
-            *c = target;
-        }
-    }
-    let Some(NodeKind::Instance { component, props }) = doc.node(id).map(|n| &n.kind) else { return };
-    let Some(NodeKind::Component { props: defs, .. }) = doc.node(*component).map(|c| &c.kind) else { return };
-    let mut next = props.clone();
-    for (name, val) in sets {
-        let v = match (defs.get(name), val) {
-            (Some(PropDef::Boolean { .. }), VariableValue::Boolean(b)) => json!(b),
-            (Some(PropDef::Text { .. }), VariableValue::String(t)) => json!(t),
-            _ => continue,
-        };
-        next.insert(name.clone(), v);
-    }
-    if next != *props
-        && let Ok(n) = doc.get_mut(id)
-        && let NodeKind::Instance { props, .. } = &mut n.kind
-    {
-        *props = next;
-    }
-}
-
-/// Coerce a property value to the definition's type.
-fn coerce(cmd: &str, doc: &Document, name: &str, def: &PropDef, v: &Value) -> Result<Value> {
-    match def {
-        PropDef::Boolean { .. } => match v {
-            Value::Bool(b) => Ok(json!(b)),
-            Value::String(t) if t == "true" || t == "false" => Ok(json!(t == "true")),
-            _ => Err(bad(cmd, format!("`{name}` is a boolean property"))),
-        },
-        PropDef::Text { .. } => match v {
-            Value::String(t) => Ok(json!(t)),
-            Value::Number(n) => Ok(json!(n.to_string())),
-            _ => Err(bad(cmd, format!("`{name}` is a text property"))),
-        },
-        PropDef::InstanceSwap { .. } => match id_of(v).and_then(|c| main_of(doc, c)) {
-            Some(c) => Ok(json!(c.0)),
-            None => Err(bad(cmd, format!("`{name}` takes a component id"))),
-        },
-        PropDef::Variant { options, .. } => {
-            let t = v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string());
-            if options.is_empty() || options.contains(&t) { Ok(json!(t)) } else { Err(bad(cmd, format!("`{name}` must be one of {options:?}"))) }
-        }
-        PropDef::Slot { .. } => Err(bad(cmd, format!("`{name}` is a slot: fill it with instance.slotInsert or by adding layers to it"))),
-    }
-}
-
-fn set_props(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "instance.setProperties";
-    let ids = req_targets(cmd, s, p)?;
-    let props = get(p, "properties").and_then(Value::as_object).cloned().ok_or_else(|| bad(cmd, "`properties` object required"))?;
-    let doc = s.doc_mut()?;
-    for i in ids {
-        let Some(NodeKind::Instance { component, .. }) = doc.node(i).map(|n| n.kind.clone()) else {
-            return Err(bad(cmd, format!("{i} is not an instance")));
-        };
-        // Variant properties: switch to the matching sibling variant.
-        let set = variant_set(doc, component);
-        let options = set.map(|s| variant_options(doc, s)).unwrap_or_default();
-        let mut wanted = doc.node(component).map(|c| variant_props(&c.name)).unwrap_or_default();
-        let mut target = component;
-        let mut rest = Vec::new();
-        for (k, v) in &props {
-            if let Some((_, vals)) = options.iter().find(|(o, _)| o == k) {
-                let val = v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string());
-                if !vals.contains(&val) {
-                    return Err(bad(cmd, format!("`{k}` must be one of {vals:?}")));
-                }
-                wanted.insert(k.clone(), val);
-            } else {
-                rest.push((k.clone(), v.clone()));
-            }
-        }
-        if let Some(set) = set
-            && wanted != doc.node(component).map(|c| variant_props(&c.name)).unwrap_or_default()
-        {
-            target = find_variant(doc, set, &wanted).unwrap_or(component);
-        }
-        let defs = match doc.node(target).map(|n| &n.kind) {
-            Some(NodeKind::Component { props, .. }) => props.clone(),
-            _ => BTreeMap::new(),
-        };
-        let mut values = Vec::new();
-        for (k, v) in rest {
-            let def = defs.get(&k).ok_or_else(|| {
-                let known: Vec<&str> = defs.keys().map(String::as_str).chain(options.iter().map(|(o, _)| o.as_str())).collect();
-                bad(cmd, format!("unknown property `{k}` (known: {})", known.join(", ")))
-            })?;
-            values.push((k.clone(), coerce(cmd, doc, &k, def, &v)?));
-        }
-        if let NodeKind::Instance { component: c, props: ip } = &mut doc.get_mut(i)?.kind {
-            *c = target;
-            for (k, v) in values {
-                ip.insert(k, v);
-            }
-            for (k, d) in defs.iter().filter(|(_, d)| takes_value(d)) {
-                ip.entry(k.clone()).or_insert_with(|| prop_default_value(d));
-            }
-        }
-    }
-    ok()
-}
-
-/// Where component properties live: a set (its variants share them) or a lone component.
-enum Owner {
-    Set(NodeId),
-    Comp(NodeId),
-}
-
-impl Owner {
-    fn resolve(doc: &Document, id: NodeId) -> Option<Owner> {
-        let n = doc.node(id)?;
-        match n.kind {
-            NodeKind::ComponentSet { .. } => Some(Owner::Set(id)),
-            _ => {
-                let c = owning_component(doc, id)?;
-                Some(match variant_set(doc, c) {
-                    Some(s) => Owner::Set(s),
-                    None => Owner::Comp(c),
-                })
-            }
-        }
-    }
-
-    fn components(&self, doc: &Document) -> Vec<NodeId> {
-        match self {
-            Owner::Comp(c) => vec![*c],
-            Owner::Set(s) => doc
-                .node(*s)
-                .map(|n| n.children.iter().copied().filter(|c| doc.node(*c).is_some_and(|x| matches!(x.kind, NodeKind::Component { .. }))).collect())
-                .unwrap_or_default(),
-        }
-    }
-
-    fn id(&self) -> NodeId {
-        match self {
-            Owner::Set(s) | Owner::Comp(s) => *s,
-        }
-    }
-}
-
-fn prop_defs(doc: &Document, c: NodeId) -> BTreeMap<String, PropDef> {
-    match doc.node(c).map(|n| &n.kind) {
-        Some(NodeKind::Component { props, .. }) => props.clone(),
-        _ => BTreeMap::new(),
-    }
-}
-
-fn set_prop_defs(doc: &mut Document, c: NodeId, f: impl FnOnce(&mut BTreeMap<String, PropDef>)) -> Result<()> {
-    if let NodeKind::Component { props, .. } = &mut doc.get_mut(c)?.kind {
-        f(props);
-    }
-    Ok(())
-}
-
-fn valid_prop_name(cmd: &str, name: &str) -> Result<String> {
-    let name = name.trim();
-    if name.is_empty() || name.contains([',', '=']) || name.chars().count() > 200 {
-        return Err(bad(cmd, "property names must be non-empty, without ',' or '='"));
-    }
-    Ok(name.to_string())
-}
-
-fn add_prop(s: &mut Session, p: &Value) -> Result<Value> {
-    add_prop_for("component.addProperty", s, p)
-}
-
-/// Add a component property for command `cmd`, which errors name (`component.makeSlot` adds its
-/// slot property here).
-fn add_prop_for(cmd: &str, s: &mut Session, p: &Value) -> Result<Value> {
-    let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component"))?;
-    let name = valid_prop_name(cmd, &req_string(cmd, p, "name")?)?;
-    let t = req_string(cmd, p, "type")?;
-    let doc = s.doc_mut()?;
-    if inside_instance(doc, target) {
-        return Err(bad(cmd, "select a component, not a layer of an instance"));
-    }
-    let owner = Owner::resolve(doc, target).ok_or_else(|| bad(cmd, "select a component, a component set or a layer inside a component"))?;
-    // A layer selected inside the component gets bound to the new property.
-    let layer = id(p, "layer")
-        .or_else(|| (target != owner.id() && !matches!(doc.node(target).map(|n| &n.kind), Some(NodeKind::Component { .. }))).then_some(target));
-    let comps = owner.components(doc);
-    let variants = match &owner {
-        Owner::Set(s) => variant_options(doc, *s),
-        Owner::Comp(_) => Vec::new(),
-    };
-    if variants.iter().any(|(k, _)| *k == name) || comps.iter().any(|c| prop_defs(doc, *c).contains_key(&name)) {
-        return Err(bad(cmd, format!("a property named `{name}` already exists")));
-    }
-    let layer_node = layer.and_then(|l| doc.node(l)).cloned();
-    let def = match t.to_ascii_lowercase().as_str() {
-        // Without a default, a bound layer keeps showing as it does: its visibility is the default.
-        "boolean" | "bool" => PropDef::Boolean { default: boolean(p, "default").or_else(|| layer_node.as_ref().map(|n| n.visible)).unwrap_or(true) },
-        "text" => PropDef::Text {
-            default: string(p, "default")
-                .or_else(|| layer_node.as_ref().and_then(|n| n.kind.text()).map(|t| t.characters.clone()))
-                .unwrap_or_else(|| name.clone()),
-        },
-        "instanceswap" | "instance_swap" | "instance" => {
-            let d = id(p, "default")
-                .or_else(|| match layer_node.as_ref().map(|n| &n.kind) {
-                    Some(NodeKind::Instance { component, .. }) => Some(*component),
-                    _ => None,
-                })
-                .and_then(|c| main_of(doc, c))
-                .ok_or_else(|| bad(cmd, "default: a component id"))?;
-            PropDef::InstanceSwap { default: d, preferred: preferred_arg(cmd, doc, p)? }
-        }
-        "variant" => {
-            let dv = string(p, "default")
-                .map(|d| d.trim().to_string())
-                .filter(|d| !d.is_empty() && !d.contains([',', '=']))
-                .unwrap_or_else(|| "Default".into());
-            let set = match owner {
-                Owner::Set(s) => s,
-                Owner::Comp(c) => wrap_in_set(cmd, doc, &[c])?,
-            };
-            for c in Owner::Set(set).components(doc) {
-                let cn = doc.get_mut(c)?;
-                cn.name = if cn.name.contains('=') { format!("{}, {name}={dv}", cn.name) } else { format!("{name}={dv}") };
-            }
-            s.set_selection(vec![set]);
-            return Ok(json!({"id": set}));
-        }
-        "slot" => {
-            if !layer_node.as_ref().is_some_and(|n| matches!(n.kind, NodeKind::Frame)) {
-                return Err(bad(cmd, "a slot is a frame inside the component: select one (or pass `layer`)"));
-            }
-            PropDef::Slot { preferred: preferred_arg(cmd, doc, p)? }
-        }
-        _ => return Err(bad(cmd, "type: boolean|text|instanceSwap|variant|slot")),
-    };
-    for c in &comps {
-        set_prop_defs(doc, *c, |m| {
-            m.insert(name.clone(), def.clone());
-        })?;
-        // Existing instances get the default.
-        if !takes_value(&def) {
-            continue;
-        }
-        for inst in instances_of(doc, *c) {
-            if let NodeKind::Instance { props, .. } = &mut doc.get_mut(inst)?.kind {
-                props.entry(name.clone()).or_insert_with(|| prop_default_value(&def));
-            }
-        }
-    }
-    if let Some(l) = layer {
-        bind(cmd, doc, l, Some(&name), None)?;
-    }
-    Ok(json!({"id": owner.id(), "name": name}))
-}
-
-/// Bind (or with `property: None` unbind) a layer's field to a property of its component.
-fn bind(cmd: &str, doc: &mut Document, layer: NodeId, property: Option<&str>, field: Option<&str>) -> Result<()> {
-    let n = doc.get(layer)?.clone();
-    if inside_instance(doc, layer) {
-        return Err(bad(cmd, "layers inside an instance can't be bound (bind the nested instance itself, or edit its main)"));
-    }
-    let comp = owning_component(doc, layer).ok_or_else(|| bad(cmd, "the layer isn't inside a component"))?;
-    let Some(property) = property.filter(|p| !p.is_empty()) else {
-        let n = doc.get_mut(layer)?;
-        match field {
-            Some(f) => {
-                n.prop_refs.remove(f);
-            }
-            None => n.prop_refs.clear(),
-        }
-        return Ok(());
-    };
-    let defs = prop_defs(doc, comp);
-    let def = defs.get(property).ok_or_else(|| bad(cmd, format!("the component has no property `{property}`")))?;
-    let expected = match def {
-        PropDef::Boolean { .. } => "visible",
-        PropDef::Text { .. } => "characters",
-        PropDef::InstanceSwap { .. } => "mainComponent",
-        PropDef::Variant { .. } => return Err(bad(cmd, "variant properties pick a variant; they can't be bound to a layer")),
-        PropDef::Slot { .. } => SLOT,
-    };
-    let field = field.unwrap_or(expected);
-    if field != expected {
-        return Err(bad(cmd, format!("`{property}` can only control `{expected}`")));
-    }
-    match field {
-        "characters" if n.kind.text().is_none() => return Err(bad(cmd, "text properties bind to text layers")),
-        "mainComponent" if !matches!(n.kind, NodeKind::Instance { .. }) => return Err(bad(cmd, "instance swap properties bind to instances")),
-        "visible" if layer == comp => return Err(bad(cmd, "the component itself can't be hidden by its own property")),
-        SLOT if !matches!(n.kind, NodeKind::Frame) => return Err(bad(cmd, "slot properties bind to frames inside the component")),
-        SLOT if doc
-            .subtree(comp)
-            .into_iter()
-            .any(|d| d != layer && doc.node(d).is_some_and(|x| x.prop_refs.get(SLOT).map(String::as_str) == Some(property))) =>
-        {
-            return Err(bad(cmd, format!("another frame of the component is already the slot `{property}`")));
-        }
-        _ => {}
-    }
-    let n = doc.get_mut(layer)?;
-    n.prop_refs.insert(field.to_string(), property.to_string());
-    // On the main, a boolean property's value is the visibility of the layers it controls.
-    if let PropDef::Boolean { default } = def {
-        n.visible = *default;
-    }
-    Ok(())
-}
-
-fn bind_prop(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.bindProperty";
-    let layer = id(p, "layer").or_else(|| targets(s, p).first().copied()).ok_or_else(|| bad(cmd, "`layer` required"))?;
-    let property = string(p, "property");
-    let field = string(p, "field");
-    if let Some(f) = &field
-        && !matches!(f.as_str(), "visible" | "characters" | "mainComponent" | SLOT)
-    {
-        return Err(bad(cmd, "field: visible|characters|mainComponent|slot"));
-    }
-    let doc = s.doc_mut()?;
-    bind(cmd, doc, layer, property.as_deref(), field.as_deref())?;
-    ok()
-}
-
-/// Rename `old` → `new` in the bindings of a component's layers and in its instances' values.
-fn rename_prop_refs(doc: &mut Document, comp: NodeId, old: &str, new: Option<&str>) -> Result<()> {
-    for d in doc.subtree(comp) {
-        let refs = doc.node(d).map(|n| n.prop_refs.clone()).unwrap_or_default();
-        if refs.values().any(|v| v == old)
-            && let Some(n) = doc.node_mut(d)
-        {
-            match new {
-                Some(nw) => n.prop_refs.values_mut().filter(|v| *v == old).for_each(|v| *v = nw.to_string()),
-                None => n.prop_refs.retain(|_, v| v != old),
-            }
-        }
-    }
-    // Instances' values and the variables bound to them follow (a deleted property drops both).
-    let old_key = format!("{PROP_BINDING}{old}");
-    for inst in instances_of(doc, comp) {
-        let n = doc.get_mut(inst)?;
-        if let NodeKind::Instance { props, .. } = &mut n.kind
-            && let Some(v) = props.remove(old)
-            && let Some(nw) = new
-        {
-            props.insert(nw.to_string(), v);
-        }
-        if let Some(var) = n.bound.remove(&old_key)
-            && let Some(nw) = new
-        {
-            n.bound.insert(format!("{PROP_BINDING}{nw}"), var);
-        }
-    }
-    Ok(())
-}
-
-fn edit_prop(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.editProperty";
-    let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component"))?;
-    let name = req_string(cmd, p, "name")?;
-    let new_name = string(p, "newName").map(|n| valid_prop_name(cmd, &n)).transpose()?.filter(|n| *n != name);
-    let doc = s.doc_mut()?;
-    let owner = Owner::resolve(doc, target).ok_or_else(|| bad(cmd, "select a component or component set"))?;
-    let comps = owner.components(doc);
-    if let Some(nn) = &new_name {
-        let taken = comps.iter().any(|c| prop_defs(doc, *c).contains_key(nn))
-            || matches!(owner, Owner::Set(s) if variant_options(doc, s).iter().any(|(k, _)| k == nn));
-        if taken {
-            return Err(bad(cmd, format!("a property named `{nn}` already exists")));
-        }
-    }
-    // Variant property of a set.
-    if let Owner::Set(set) = owner
-        && let Some((_, values)) = variant_options(doc, set).into_iter().find(|(k, _)| *k == name)
-    {
-        let order: Vec<String> = variant_options(doc, set).into_iter().map(|(k, _)| k).collect();
-        let rename_value = match (string(p, "value"), string(p, "newValue")) {
-            (Some(v), Some(nv)) => {
-                let nv = nv.trim().to_string();
-                if !values.contains(&v) {
-                    return Err(bad(cmd, format!("`{name}` has no value `{v}`")));
-                }
-                if nv.is_empty() || nv.contains([',', '=']) {
-                    return Err(bad(cmd, "`newValue` must be non-empty, without ',' or '='"));
-                }
-                Some((v, nv))
-            }
-            _ => None,
-        };
-        let mut order: Vec<String> = order.into_iter().map(|k| if k == name { new_name.clone().unwrap_or(k) } else { k }).collect();
-        // Reordered: every variant's name lists the properties in the new order.
-        if let Some(to) = get(p, "index").filter(|v| !v.is_null()) {
-            let to = to.as_u64().and_then(|i| usize::try_from(i).ok()).ok_or_else(|| bad(cmd, "`index`: a property place (0 = first)"))?;
-            let key = new_name.clone().unwrap_or(name.clone());
-            order.retain(|k| *k != key);
-            order.insert(to.min(order.len()), key);
-        }
-        for c in &comps {
-            let mut pairs = variant_props(&doc.get(*c)?.name);
-            if let Some((v, nv)) = &rename_value
-                && pairs.get(&name) == Some(v)
-            {
-                pairs.insert(name.clone(), nv.clone());
-            }
-            if let Some(nn) = &new_name
-                && let Some(v) = pairs.remove(&name)
-            {
-                pairs.insert(nn.clone(), v);
-            }
-            doc.get_mut(*c)?.name = variant_name(&pairs, &order);
-        }
-        // The default variant is the top-left one: the variant with that value (and the default's
-        // other values, when there is one) trades places with it.
-        if let Some(dv) = string(p, "default") {
-            let key = new_name.clone().unwrap_or(name.clone());
-            let current = default_variant(doc, set);
-            let mut wanted = current.and_then(|d| doc.node(d)).map(|n| variant_props(&n.name)).unwrap_or_default();
-            wanted.insert(key.clone(), dv.clone());
-            let props_of = |c: &NodeId| doc.node(*c).map(|n| variant_props(&n.name)).unwrap_or_default();
-            let pick =
-                comps.iter().copied().find(|c| props_of(c) == wanted).or_else(|| comps.iter().copied().find(|c| props_of(c).get(&key) == Some(&dv)));
-            let (Some(f), Some(d)) = (pick, current) else { return Err(bad(cmd, format!("no variant has {key}={dv}"))) };
-            if f != d {
-                let place = |doc: &Document, c: NodeId| doc.node(c).map(|n| n.transform.as_coeffs()).map(|[.., x, y]| (x, y)).unwrap_or_default();
-                let (fp, dp) = (place(doc, f), place(doc, d));
-                for (c, (x, y)) in [(f, dp), (d, fp)] {
-                    let n = doc.get_mut(c)?;
-                    let [a, b, cc, dd, ..] = n.transform.as_coeffs();
-                    n.transform = figcraft_geom::Affine::new([a, b, cc, dd, x, y]);
-                }
-                fit_set(doc, set);
-            }
-        }
-        return ok();
-    }
-    let def = comps.iter().find_map(|c| prop_defs(doc, *c).get(&name).cloned()).ok_or_else(|| bad(cmd, format!("no property named `{name}`")))?;
-    let preferred = if get(p, "preferred").is_some() {
-        if !matches!(def, PropDef::Slot { .. } | PropDef::InstanceSwap { .. }) {
-            return Err(bad(cmd, "`preferred` is for instance swap and slot properties"));
-        }
-        Some(preferred_arg(cmd, doc, p)?)
-    } else {
-        None
-    };
-    let mut new_def = match get(p, "default") {
-        Some(v) => match coerce(cmd, doc, &name, &def, v)? {
-            Value::Bool(b) => PropDef::Boolean { default: b },
-            Value::String(t) if matches!(def, PropDef::Text { .. }) => PropDef::Text { default: t },
-            other => match (&def, id_of(&other)) {
-                (PropDef::InstanceSwap { preferred, .. }, Some(c)) => PropDef::InstanceSwap { default: c, preferred: preferred.clone() },
-                _ => def.clone(),
-            },
-        },
-        None => def.clone(),
-    };
-    if let (Some(list), PropDef::Slot { preferred } | PropDef::InstanceSwap { preferred, .. }) = (preferred, &mut new_def) {
-        *preferred = list;
-    }
-    for c in &comps {
-        let had = prop_defs(doc, *c).contains_key(&name);
-        if !had {
-            continue;
-        }
-        let key = new_name.clone().unwrap_or(name.clone());
-        let nd = new_def.clone();
-        let old = name.clone();
-        set_prop_defs(doc, *c, move |m| {
-            m.remove(&old);
-            m.insert(key, nd);
-        })?;
-        if let Some(nn) = &new_name {
-            rename_prop_refs(doc, *c, &name, Some(nn))?;
-        }
-    }
-    // The main's bound layers show the new default.
-    if let PropDef::Boolean { default } = new_def {
-        set_boolean_default(doc, &comps, new_name.as_deref().unwrap_or(&name), default);
-    }
-    ok()
-}
-
-fn delete_prop(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "component.deleteProperty";
-    let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component"))?;
-    let name = req_string(cmd, p, "name")?;
-    let doc = s.doc_mut()?;
-    let owner = Owner::resolve(doc, target).ok_or_else(|| bad(cmd, "select a component or component set"))?;
-    let comps = owner.components(doc);
-    if let Owner::Set(set) = owner
-        && variant_options(doc, set).iter().any(|(k, _)| *k == name)
-    {
-        let order: Vec<String> = variant_options(doc, set).into_iter().map(|(k, _)| k).collect();
-        for c in &comps {
-            let mut pairs = variant_props(&doc.get(*c)?.name);
-            pairs.remove(&name);
-            let n = doc.get_mut(*c)?;
-            n.name = if pairs.is_empty() { "Default".into() } else { variant_name(&pairs, &order) };
-        }
-        return ok();
-    }
-    let mut found = false;
-    for c in &comps {
-        if prop_defs(doc, *c).contains_key(&name) {
-            found = true;
-            set_prop_defs(doc, *c, |m| {
-                m.remove(&name);
-            })?;
-            rename_prop_refs(doc, *c, &name, None)?;
-        }
-    }
-    if !found {
-        return Err(bad(cmd, format!("no property named `{name}`")));
-    }
-    ok()
-}
-
-fn def_json(name: &str, d: &PropDef) -> Value {
-    match d {
-        PropDef::Boolean { default } => json!({"name": name, "type": "boolean", "default": default}),
-        PropDef::Text { default } => json!({"name": name, "type": "text", "default": default}),
-        PropDef::InstanceSwap { default, preferred } => json!({"name": name, "type": "instanceSwap", "default": default, "preferred": preferred}),
-        PropDef::Variant { options, default } => json!({"name": name, "type": "variant", "default": default, "options": options}),
-        PropDef::Slot { preferred } => json!({"name": name, "type": "slot", "preferred": preferred}),
-    }
-}
-
-/// Properties of a component, set or instance as JSON (`component.properties`).
-pub(crate) fn describe_props(doc: &Document, id: NodeId) -> Value {
-    let Some(n) = doc.node(id) else { return Value::Null };
-    let (owner_comp, values) = match &n.kind {
-        NodeKind::Instance { component, props } => (Some(*component), Some(props.clone())),
-        _ => (main_of(doc, id).or_else(|| owning_component(doc, id)), None),
-    };
-    let Some(comp) = owner_comp else { return json!({"properties": []}) };
-    let mut list: Vec<Value> = Vec::new();
-    if let Some(set) = variant_set(doc, comp) {
-        let current = doc.node(comp).map(|c| variant_props(&c.name)).unwrap_or_default();
-        let defaults = default_variant(doc, set).and_then(|d| doc.node(d)).map(|n| variant_props(&n.name)).unwrap_or_default();
-        for (k, vals) in variant_options(doc, set) {
-            let mut v = json!({"name": k, "type": "variant", "options": vals, "default": defaults.get(&k).or(vals.first())});
-            if values.is_some() {
-                v["value"] = json!(current.get(&k));
-            }
-            list.push(v);
-        }
-    }
-    // Slots: the frames (on a main) or this instance's copy, with whether it holds its own content.
-    let slots = slots_of(doc, if values.is_some() { id } else { variant_set(doc, comp).unwrap_or(comp) });
-    for (k, d) in prop_defs(doc, comp) {
-        let mut v = def_json(&k, &d);
-        if !takes_value(&d) {
-            let layers: Vec<NodeId> = slots.iter().filter(|(_, n)| *n == k).map(|(l, _)| *l).collect();
-            if values.is_some() {
-                v["value"] = layers.first().map_or(Value::Null, |l| {
-                    let count = doc.node(*l).map_or(0, |n| n.children.len());
-                    json!({"layer": l, "edited": slot_edited(doc, *l), "layers": count})
-                });
-            } else {
-                v["layers"] = json!(layers);
-            }
-        } else if let Some(vals) = &values {
-            v["value"] = vals.get(&k).cloned().unwrap_or_else(|| prop_default_value(&d));
-        }
-        list.push(v);
-    }
-    let set = variant_set(doc, comp);
-    let conflicts = set.map(|s| variant_conflicts(doc, s)).unwrap_or_default();
-    json!({"component": comp, "set": set, "properties": list, "conflicts": conflicts})
-}
diff --git a/crates/engine/src/cmd/component/instance.rs b/crates/engine/src/cmd/component/instance.rs
new file mode 100644
index 00000000..ffc5ec1c
--- /dev/null
+++ b/crates/engine/src/cmd/component/instance.rs
@@ -0,0 +1,404 @@
+use super::props::{Owner, add_prop_for, delete_prop, prop_defs};
+use super::*;
+
+pub(super) fn detach(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.detach";
+    let ids = req_targets(cmd, s, p)?;
+    let doc = s.doc_mut()?;
+    let mut out = Vec::new();
+    for i in ids {
+        if !matches!(doc.get(i)?.kind, NodeKind::Instance { .. }) {
+            continue;
+        }
+        if inside_instance(doc, i) {
+            return Err(EngineError::Disabled(cmd.into(), "a nested instance can't be detached on its own: detach the outer instance first".into()));
+        }
+        // Own layers lose their link (slot content stays as it is); nested instances stay
+        // instances of their own mains.
+        let nested = unlink_layers(doc, i, Some(i));
+        keep_main_modes(doc, i)?;
+        let n = doc.get_mut(i)?;
+        n.kind = NodeKind::Frame;
+        n.source = None;
+        n.overrides.clear();
+        n.prop_refs.remove("mainComponent");
+        // No properties left to drive.
+        n.bound.retain(|k, _| !k.starts_with(PROP_BINDING));
+        for nn in nested {
+            rebase_instance(doc, nn);
+        }
+        out.push(i);
+    }
+    if out.is_empty() {
+        return Err(EngineError::Disabled(cmd.into(), "select an instance".into()));
+    }
+    s.set_selection(out.clone());
+    Ok(json!({"ids": out}))
+}
+
+/// Make the variable modes instance `i` takes from its main its own (it's being detached).
+fn keep_main_modes(doc: &mut Document, i: NodeId) -> Result<()> {
+    let modes = match doc.get(i)?.kind {
+        NodeKind::Instance { component, .. } => doc.node(component).map(|m| m.var_modes.clone()).unwrap_or_default(),
+        _ => return Ok(()),
+    };
+    let own = &mut doc.get_mut(i)?.var_modes;
+    for (c, m) in modes {
+        own.entry(c).or_insert(m);
+    }
+    Ok(())
+}
+
+pub(super) fn reset_instance(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.resetInstance";
+    let ids = req_targets(cmd, s, p)?;
+    let doc = s.doc_mut()?;
+    let mut done = Vec::new();
+    for i in ids {
+        let Some(inst) = owning_instance(doc, i) else { continue };
+        let top = !inside_instance(doc, inst);
+        for d in doc.subtree(inst) {
+            let keep: Vec<&str> = if d == inst && top { vec!["size"] } else { vec![] };
+            if let Some(n) = doc.node(d)
+                && n.overrides.iter().any(|g| !keep.contains(&g.as_str()))
+                && let Some(n) = doc.node_mut(d)
+            {
+                n.overrides.retain(|g| keep.contains(&g.as_str()));
+            }
+        }
+        // Property values go back to the defaults.
+        if top
+            && let Some(NodeKind::Instance { component, props }) = doc.node(inst).map(|n| n.kind.clone())
+            && let Some(defaults) = doc.node(component).map(default_props)
+            && props != defaults
+            && let NodeKind::Instance { props, .. } = &mut doc.get_mut(inst)?.kind
+        {
+            *props = defaults;
+        }
+        // ...and stop following variables.
+        if top && doc.node(inst).is_some_and(|n| n.bound.keys().any(|k| k.starts_with(PROP_BINDING))) {
+            doc.get_mut(inst)?.bound.retain(|k, _| !k.starts_with(PROP_BINDING));
+        }
+        done.push(inst);
+    }
+    if done.is_empty() {
+        return Err(EngineError::Disabled(cmd.into(), "select an instance".into()));
+    }
+    Ok(json!({"ids": done}))
+}
+
+pub(super) fn reset_override(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.resetOverride";
+    let i = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a layer inside an instance"))?;
+    let group = string(p, "group");
+    if let Some(g) = &group
+        && !OVERRIDE_GROUPS.contains(&g.as_str())
+    {
+        return Err(bad(cmd, format!("unknown group `{g}` (known: {})", OVERRIDE_GROUPS.join(", "))));
+    }
+    let doc = s.doc_mut()?;
+    if owning_instance(doc, i).is_none() || doc.get(i)?.source.is_none() {
+        return Err(bad(cmd, "not a layer of an instance"));
+    }
+    let top_root = matches!(doc.get(i)?.kind, NodeKind::Instance { .. }) && !inside_instance(doc, i);
+    let had = doc.get(i)?.overrides.clone();
+    let n = doc.get_mut(i)?;
+    match &group {
+        Some(g) => {
+            n.overrides.remove(g);
+        }
+        None => n.overrides.clear(),
+    }
+    let mut changed = had != doc.get(i)?.overrides;
+    // The instance's own property values reset with `props`.
+    if top_root
+        && group.as_deref().is_none_or(|g| g == "props")
+        && let Some(NodeKind::Instance { component, props }) = doc.node(i).map(|n| n.kind.clone())
+        && let Some(defaults) = doc.node(component).map(default_props)
+        && props != defaults
+        && let NodeKind::Instance { props, .. } = &mut doc.get_mut(i)?.kind
+    {
+        *props = defaults;
+        changed = true;
+    }
+    Ok(json!({"changed": changed}))
+}
+
+/// A property name for `owner` based on `base` (a layer name): valid and not taken yet.
+fn fresh_prop_name(doc: &Document, owner: &Owner, base: &str) -> String {
+    let base: String = base.chars().filter(|c| !matches!(c, ',' | '=')).take(100).collect::<String>().trim().to_string();
+    let base = if base.is_empty() { "Slot".to_string() } else { base };
+    let taken = |n: &str| {
+        owner.components(doc).iter().any(|c| prop_defs(doc, *c).contains_key(n))
+            || matches!(owner, Owner::Set(s) if variant_options(doc, *s).iter().any(|(k, _)| k == n))
+    };
+    (1..10_000).map(|k| if k == 1 { base.clone() } else { format!("{base} {k}") }).find(|n| !taken(n)).unwrap_or(base)
+}
+
+/// The `preferred` components of a slot property: component or component set ids.
+pub(super) fn preferred_arg(cmd: &str, doc: &Document, p: &Value) -> Result<Vec<NodeId>> {
+    let Some(v) = get(p, "preferred").filter(|v| !v.is_null()) else { return Ok(Vec::new()) };
+    let list = v.as_array().ok_or_else(|| bad(cmd, "`preferred`: an array of component ids"))?;
+    let mut out = Vec::new();
+    for x in list.iter().take(500) {
+        let c = id_of(x)
+            .filter(|c| doc.node(*c).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. } | NodeKind::ComponentSet { .. })))
+            .ok_or_else(|| bad(cmd, format!("`preferred`: {x} is not a component or component set")))?;
+        if !out.contains(&c) {
+            out.push(c);
+        }
+    }
+    Ok(out)
+}
+
+pub(super) fn make_slot(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.makeSlot";
+    let id = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a frame inside a main component"))?;
+    let doc = s.doc()?;
+    let n = doc.get(id)?;
+    let inside_main = owning_component(doc, id).is_some_and(|c| c != id) && owning_instance(doc, id).is_none();
+    if !matches!(n.kind, NodeKind::Frame) || !inside_main {
+        return Err(bad(cmd, "only a frame inside a main component (not inside an instance) can become a slot"));
+    }
+    if is_slot(doc, id) {
+        return Err(EngineError::Disabled(cmd.into(), format!("\"{}\" is already a slot", n.name)));
+    }
+    let owner = Owner::resolve(doc, id).ok_or_else(|| bad(cmd, "the frame isn't inside a component"))?;
+    let name = string(p, "name").unwrap_or_else(|| fresh_prop_name(doc, &owner, &n.name));
+    let preferred = get(p, "preferred").cloned().unwrap_or(Value::Null);
+    add_prop_for(cmd, s, &json!({"id": id, "layer": id, "name": name, "type": "slot", "preferred": preferred}))
+}
+
+pub(super) fn remove_slot(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.removeSlot";
+    let id = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a slot frame of a main component"))?;
+    let doc = s.doc()?;
+    if owning_instance(doc, id).is_some() {
+        return Err(EngineError::Disabled(cmd.into(), "slots are removed on the main component".into()));
+    }
+    let name = slot_name(doc, id).ok_or_else(|| bad(cmd, "not a slot frame of a main component"))?;
+    delete_prop(s, &json!({"id": id, "name": name}))?;
+    Ok(json!({"id": id, "name": name}))
+}
+
+/// The slot inside an instance a command acts on: `id` itself, or instance `id`'s slot `name`.
+fn instance_slot(cmd: &str, doc: &Document, id: NodeId, name: Option<&str>) -> Result<NodeId> {
+    let slot = match name {
+        Some(nm) => slots_of(doc, id).into_iter().find(|(_, n)| n == nm).map(|(l, _)| l).ok_or_else(|| bad(cmd, format!("no slot named `{nm}`")))?,
+        None => id,
+    };
+    if !is_slot(doc, slot) || owning_instance(doc, slot).is_none() {
+        return Err(bad(cmd, "not a slot of an instance (a main component's slot takes layers like any frame)"));
+    }
+    Ok(slot)
+}
+
+pub(super) fn slot_insert(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "instance.slotInsert";
+    let c = req_id(cmd, p, "component")?;
+    let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a slot inside an instance"))?;
+    let index = match get(p, "index").filter(|v| !v.is_null()) {
+        None => None,
+        Some(v) => Some(v.as_u64().and_then(|i| usize::try_from(i).ok()).ok_or_else(|| bad(cmd, "`index`: a child index (0 = bottom)"))?),
+    };
+    let doc = s.doc_mut()?;
+    let slot = instance_slot(cmd, doc, target, string(p, "slot").as_deref())?;
+    let c = main_of(doc, c).ok_or_else(|| bad(cmd, "`component` must be a component or component set"))?;
+    if boolean(p, "replace").unwrap_or(false) {
+        for k in doc.get(slot)?.children.clone() {
+            doc.remove(k)?;
+        }
+    }
+    let i = create_instance_at(doc, c, slot, 0.0, 0.0, index)?;
+    s.set_selection(vec![i]);
+    Ok(json!({"id": i, "slot": slot}))
+}
+
+pub(super) fn reset_slot(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "instance.resetSlot";
+    let id = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a slot inside an instance"))?;
+    let doc = s.doc_mut()?;
+    let slot = instance_slot(cmd, doc, id, string(p, "slot").as_deref())?;
+    let changed = slot_edited(doc, slot);
+    if changed {
+        doc.get_mut(slot)?.overrides.remove(SLOT);
+    }
+    Ok(json!({"id": slot, "changed": changed}))
+}
+
+pub(super) fn push_changes(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.pushChanges";
+    let i = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select an instance"))?;
+    let doc = s.doc_mut()?;
+    // Changes go to the outer instance's main (never into a nested instance's own main).
+    let inst = root_instance(doc, i).ok_or_else(|| bad(cmd, "not an instance"))?;
+    let Some(NodeKind::Instance { component, .. }) = doc.node(inst).map(|n| n.kind.clone()) else { return ok() };
+    if !doc.contains(component) {
+        return Err(EngineError::Disabled(cmd.into(), "the main component was deleted (use component.restoreMain)".into()));
+    }
+    // Copy every overridden layer's values to its source in the main (geometry, resizing, swaps,
+    // property values and slot content stay with the instance).
+    let mut pushed = 0;
+    for d in doc.subtree(inst) {
+        let Some(n) = doc.node(d).cloned() else { continue };
+        let Some(src) = (if d == inst { Some(component) } else { n.source }) else { continue };
+        if n.overrides.is_empty() || !doc.contains(src) || !doc.is_ancestor(component, src) {
+            continue;
+        }
+        let Some(mut target) = doc.node(src).cloned() else { continue };
+        let groups: BTreeSet<String> = n
+            .overrides
+            .iter()
+            .filter(|g| !(matches!(g.as_str(), "size" | "resizing" | "position" | "component" | "props" | SLOT) || d == inst && g.as_str() == "name"))
+            .cloned()
+            .collect();
+        for g in &groups {
+            copy_group(&n, &mut target, g);
+        }
+        if groups.is_empty() {
+            continue;
+        }
+        pushed += 1;
+        if let Some(slot) = doc.node_mut(src) {
+            *slot = target;
+        }
+        if let Some(m) = doc.node_mut(d) {
+            m.overrides.retain(|g| !groups.contains(g));
+        }
+    }
+    Ok(json!({"layers": pushed}))
+}
+
+fn restore_prop_defs(doc: &Document, props: &BTreeMap<String, Value>) -> BTreeMap<String, PropDef> {
+    let mut defs = BTreeMap::new();
+    for (k, v) in props {
+        let def = match v {
+            Value::Bool(b) => PropDef::Boolean { default: *b },
+            Value::String(t) => PropDef::Text { default: t.clone() },
+            other => match id_of(other) {
+                Some(c) if doc.contains(c) => PropDef::InstanceSwap { default: c, preferred: Vec::new() },
+                _ => continue,
+            },
+        };
+        defs.insert(k.clone(), def);
+    }
+    defs
+}
+
+fn restore_id_map(doc: &mut Document, i: NodeId, component: NodeId, sub: &[NodeId]) -> BTreeMap<NodeId, NodeId> {
+    let mut map: BTreeMap<NodeId, NodeId> = BTreeMap::new();
+    let mut used: BTreeSet<NodeId> = BTreeSet::new();
+    map.insert(i, component);
+    used.insert(component);
+    for d in sub.iter().filter(|d| **d != i) {
+        let src = doc.node(*d).and_then(|n| n.source);
+        let nid = match src {
+            Some(s) if !doc.contains(s) && used.insert(s) => s,
+            _ => doc.alloc_id(),
+        };
+        map.insert(*d, nid);
+    }
+    map
+}
+
+pub(super) fn restore_main(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.restoreMain";
+    let i = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select an instance"))?;
+    let doc = s.doc_mut()?;
+    let Some(NodeKind::Instance { component, props }) = doc.node(i).map(|n| n.kind.clone()) else {
+        return Err(bad(cmd, "select an instance"));
+    };
+    if doc.contains(component) {
+        return Err(EngineError::Disabled(cmd.into(), "the main component still exists".into()));
+    }
+    if inside_instance(doc, i) {
+        return Err(EngineError::Disabled(cmd.into(), "select the outer instance".into()));
+    }
+    let parent = doc.get(i)?.parent.ok_or_else(|| bad(cmd, "no parent"))?;
+    let index = doc.index_in_parent(i);
+    // The main comes back with its old id (other instances point to it) and its layers with the
+    // ids their copies mirror, so every instance re-links by source.
+    let sub = doc.subtree(i);
+    let map = restore_id_map(doc, i, component, &sub);
+    let mut nodes = Vec::new();
+    let mut nested = Vec::new();
+    for d in &sub {
+        let Some(mut n) = doc.node(*d).cloned() else { continue };
+        if *d == i {
+            let defs = restore_prop_defs(doc, &props);
+            n.kind = NodeKind::Component { description: String::new(), props: defs };
+            n.source = None;
+            n.overrides.clear();
+            n.prop_refs.clear();
+        } else {
+            let parent_inst = n.parent.and_then(|p| owning_instance(doc, p));
+            if parent_inst != Some(i) {
+                nodes.push(n);
+                continue;
+            }
+            if matches!(n.kind, NodeKind::Instance { .. }) {
+                nested.push(*d);
+            } else {
+                n.source = None;
+                n.overrides.clear();
+            }
+        }
+        nodes.push(n);
+    }
+    doc.remove(i)?;
+    doc.paste_nodes(&nodes, &map, i, parent, index)?;
+    for nn in nested {
+        if let Some(m) = map.get(&nn).copied() {
+            rebase_instance(doc, m);
+        }
+    }
+    s.set_selection(vec![component]);
+    Ok(json!({"id": component}))
+}
+
+pub(super) fn swap(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "instance.swap";
+    let c = req_id(cmd, p, "component")?;
+    let ids = req_targets(cmd, s, p)?;
+    let doc = s.doc_mut()?;
+    let c = main_of(doc, c).ok_or_else(|| bad(cmd, "`component` must be a component or component set"))?;
+    for i in ids {
+        swap_instance(doc, i, c).map_err(|m| bad(cmd, m))?;
+    }
+    ok()
+}
+
+/// Make instance `i` show main component `c`, keeping the values of properties with the same names
+/// (the layers' overrides follow by name when the instance is rebuilt).
+pub(crate) fn swap_instance(doc: &mut Document, i: NodeId, c: NodeId) -> std::result::Result<(), String> {
+    if doc.is_ancestor(c, i) {
+        return Err("an instance can't show the component it is inside".into());
+    }
+    let defaults = doc.node(c).map(default_props).unwrap_or_default();
+    match doc.get_mut(i).map(|n| &mut n.kind) {
+        Ok(NodeKind::Instance { component, props }) => {
+            *component = c;
+            let old = std::mem::take(props);
+            *props = defaults.iter().map(|(k, d)| (k.clone(), old.get(k).cloned().unwrap_or_else(|| d.clone()))).collect();
+            Ok(())
+        }
+        _ => Err(format!("{i} is not an instance")),
+    }
+}
+
+/// Swap the instance under a page point to a component (`instance.swapAt`).
+pub(crate) fn swap_at(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "instance.swapAt";
+    let c = req_id(cmd, p, "component")?;
+    let pt = figcraft_geom::Point::new(req_num(cmd, p, "x")?, req_num(cmd, p, "y")?);
+    let page = s.page()?;
+    let doc = s.doc()?;
+    let c = main_of(doc, c).ok_or_else(|| bad(cmd, "`component` must be a component or component set"))?;
+    let family = crate::drop::swap_family(doc, c);
+    let target = crate::drop::swap_target(doc, page, pt, family.as_deref(), Some(c))
+        .ok_or_else(|| EngineError::Disabled(cmd.into(), "there is no instance at that point to swap".into()))?;
+    keep_text_overrides(s.doc_mut()?, target);
+    swap(s, &json!({"ids": [target], "component": c}))?;
+    s.set_selection(vec![target]);
+    Ok(json!({"id": target, "component": c}))
+}
diff --git a/crates/engine/src/cmd/component/props.rs b/crates/engine/src/cmd/component/props.rs
new file mode 100644
index 00000000..3f2d7002
--- /dev/null
+++ b/crates/engine/src/cmd/component/props.rs
@@ -0,0 +1,609 @@
+use super::instance::preferred_arg;
+use super::variants::{fit_set, wrap_in_set};
+use super::*;
+
+/// Whether instance `id` has a component property `name` that a `kind` variable can drive (a
+/// boolean property takes a boolean variable, a text or variant property a string one).
+pub(crate) fn check_prop_binding(doc: &Document, id: NodeId, name: &str, kind: VariableType) -> std::result::Result<(), String> {
+    let Some(NodeKind::Instance { component, .. }) = doc.node(id).map(|n| &n.kind) else {
+        return Err(format!("{id} is not an instance (component properties are bound on instances)"));
+    };
+    if variant_set(doc, *component).is_some_and(|set| variant_options(doc, set).iter().any(|(o, _)| o == name)) {
+        return if kind == VariableType::String { Ok(()) } else { Err(format!("`{name}` is a variant property: bind a string variable")) };
+    }
+    match (prop_defs(doc, *component).get(name), kind) {
+        (Some(PropDef::Boolean { .. }), VariableType::Boolean) | (Some(PropDef::Text { .. }), VariableType::String) => Ok(()),
+        (Some(PropDef::Boolean { .. }), _) => Err(format!("`{name}` is a boolean property: bind a boolean variable")),
+        (Some(PropDef::Text { .. }), _) => Err(format!("`{name}` is a text property: bind a string variable")),
+        (Some(_), _) => Err(format!("`{name}`: only boolean and text properties can be bound to variables")),
+        (None, _) => Err(format!("the instance has no property named `{name}`")),
+    }
+}
+
+/// Write bound variable values into instance `id`'s boolean and text property values, and switch
+/// it to the variant its bound variant properties name (only what changed; the instance then
+/// follows like after `instance.setProperties`). A value that names no variant changes nothing.
+pub(crate) fn apply_prop_bindings(doc: &mut Document, id: NodeId, sets: &[(String, VariableValue)]) {
+    let Some(NodeKind::Instance { component, .. }) = doc.node(id).map(|n| &n.kind) else { return };
+    let component = *component;
+    if let Some(set) = variant_set(doc, component) {
+        let options = variant_options(doc, set);
+        let current = doc.node(component).map(|c| variant_props(&c.name)).unwrap_or_default();
+        let mut wanted = current.clone();
+        for (name, val) in sets {
+            if let VariableValue::String(t) = val
+                && options.iter().any(|(o, vals)| o == name && vals.contains(t))
+            {
+                wanted.insert(name.clone(), t.clone());
+            }
+        }
+        if wanted != current
+            && let Some(target) = find_variant(doc, set, &wanted)
+            && let Ok(n) = doc.get_mut(id)
+            && let NodeKind::Instance { component: c, .. } = &mut n.kind
+        {
+            *c = target;
+        }
+    }
+    let Some(NodeKind::Instance { component, props }) = doc.node(id).map(|n| &n.kind) else { return };
+    let Some(NodeKind::Component { props: defs, .. }) = doc.node(*component).map(|c| &c.kind) else { return };
+    let mut next = props.clone();
+    for (name, val) in sets {
+        let v = match (defs.get(name), val) {
+            (Some(PropDef::Boolean { .. }), VariableValue::Boolean(b)) => json!(b),
+            (Some(PropDef::Text { .. }), VariableValue::String(t)) => json!(t),
+            _ => continue,
+        };
+        next.insert(name.clone(), v);
+    }
+    if next != *props
+        && let Ok(n) = doc.get_mut(id)
+        && let NodeKind::Instance { props, .. } = &mut n.kind
+    {
+        *props = next;
+    }
+}
+
+/// Coerce a property value to the definition's type.
+fn coerce(cmd: &str, doc: &Document, name: &str, def: &PropDef, v: &Value) -> Result<Value> {
+    match def {
+        PropDef::Boolean { .. } => match v {
+            Value::Bool(b) => Ok(json!(b)),
+            Value::String(t) if t == "true" || t == "false" => Ok(json!(t == "true")),
+            _ => Err(bad(cmd, format!("`{name}` is a boolean property"))),
+        },
+        PropDef::Text { .. } => match v {
+            Value::String(t) => Ok(json!(t)),
+            Value::Number(n) => Ok(json!(n.to_string())),
+            _ => Err(bad(cmd, format!("`{name}` is a text property"))),
+        },
+        PropDef::InstanceSwap { .. } => match id_of(v).and_then(|c| main_of(doc, c)) {
+            Some(c) => Ok(json!(c.0)),
+            None => Err(bad(cmd, format!("`{name}` takes a component id"))),
+        },
+        PropDef::Variant { options, .. } => {
+            let t = v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string());
+            if options.is_empty() || options.contains(&t) { Ok(json!(t)) } else { Err(bad(cmd, format!("`{name}` must be one of {options:?}"))) }
+        }
+        PropDef::Slot { .. } => Err(bad(cmd, format!("`{name}` is a slot: fill it with instance.slotInsert or by adding layers to it"))),
+    }
+}
+
+pub(super) fn set_props(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "instance.setProperties";
+    let ids = req_targets(cmd, s, p)?;
+    let props = get(p, "properties").and_then(Value::as_object).cloned().ok_or_else(|| bad(cmd, "`properties` object required"))?;
+    let doc = s.doc_mut()?;
+    for i in ids {
+        let Some(NodeKind::Instance { component, .. }) = doc.node(i).map(|n| n.kind.clone()) else {
+            return Err(bad(cmd, format!("{i} is not an instance")));
+        };
+        // Variant properties: switch to the matching sibling variant.
+        let set = variant_set(doc, component);
+        let options = set.map(|s| variant_options(doc, s)).unwrap_or_default();
+        let mut wanted = doc.node(component).map(|c| variant_props(&c.name)).unwrap_or_default();
+        let mut target = component;
+        let mut rest = Vec::new();
+        for (k, v) in &props {
+            if let Some((_, vals)) = options.iter().find(|(o, _)| o == k) {
+                let val = v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string());
+                if !vals.contains(&val) {
+                    return Err(bad(cmd, format!("`{k}` must be one of {vals:?}")));
+                }
+                wanted.insert(k.clone(), val);
+            } else {
+                rest.push((k.clone(), v.clone()));
+            }
+        }
+        if let Some(set) = set
+            && wanted != doc.node(component).map(|c| variant_props(&c.name)).unwrap_or_default()
+        {
+            target = find_variant(doc, set, &wanted).unwrap_or(component);
+        }
+        let defs = match doc.node(target).map(|n| &n.kind) {
+            Some(NodeKind::Component { props, .. }) => props.clone(),
+            _ => BTreeMap::new(),
+        };
+        let mut values = Vec::new();
+        for (k, v) in rest {
+            let def = defs.get(&k).ok_or_else(|| {
+                let known: Vec<&str> = defs.keys().map(String::as_str).chain(options.iter().map(|(o, _)| o.as_str())).collect();
+                bad(cmd, format!("unknown property `{k}` (known: {})", known.join(", ")))
+            })?;
+            values.push((k.clone(), coerce(cmd, doc, &k, def, &v)?));
+        }
+        if let NodeKind::Instance { component: c, props: ip } = &mut doc.get_mut(i)?.kind {
+            *c = target;
+            for (k, v) in values {
+                ip.insert(k, v);
+            }
+            for (k, d) in defs.iter().filter(|(_, d)| takes_value(d)) {
+                ip.entry(k.clone()).or_insert_with(|| prop_default_value(d));
+            }
+        }
+    }
+    ok()
+}
+
+/// Where component properties live: a set (its variants share them) or a lone component.
+pub(super) enum Owner {
+    Set(NodeId),
+    Comp(NodeId),
+}
+
+impl Owner {
+    pub(super) fn resolve(doc: &Document, id: NodeId) -> Option<Owner> {
+        let n = doc.node(id)?;
+        match n.kind {
+            NodeKind::ComponentSet { .. } => Some(Owner::Set(id)),
+            _ => {
+                let c = owning_component(doc, id)?;
+                Some(match variant_set(doc, c) {
+                    Some(s) => Owner::Set(s),
+                    None => Owner::Comp(c),
+                })
+            }
+        }
+    }
+
+    pub(super) fn components(&self, doc: &Document) -> Vec<NodeId> {
+        match self {
+            Owner::Comp(c) => vec![*c],
+            Owner::Set(s) => doc
+                .node(*s)
+                .map(|n| n.children.iter().copied().filter(|c| doc.node(*c).is_some_and(|x| matches!(x.kind, NodeKind::Component { .. }))).collect())
+                .unwrap_or_default(),
+        }
+    }
+
+    fn id(&self) -> NodeId {
+        match self {
+            Owner::Set(s) | Owner::Comp(s) => *s,
+        }
+    }
+}
+
+pub(super) fn prop_defs(doc: &Document, c: NodeId) -> BTreeMap<String, PropDef> {
+    match doc.node(c).map(|n| &n.kind) {
+        Some(NodeKind::Component { props, .. }) => props.clone(),
+        _ => BTreeMap::new(),
+    }
+}
+
+fn set_prop_defs(doc: &mut Document, c: NodeId, f: impl FnOnce(&mut BTreeMap<String, PropDef>)) -> Result<()> {
+    if let NodeKind::Component { props, .. } = &mut doc.get_mut(c)?.kind {
+        f(props);
+    }
+    Ok(())
+}
+
+fn valid_prop_name(cmd: &str, name: &str) -> Result<String> {
+    let name = name.trim();
+    if name.is_empty() || name.contains([',', '=']) || name.chars().count() > 200 {
+        return Err(bad(cmd, "property names must be non-empty, without ',' or '='"));
+    }
+    Ok(name.to_string())
+}
+
+pub(super) fn add_prop(s: &mut Session, p: &Value) -> Result<Value> {
+    add_prop_for("component.addProperty", s, p)
+}
+
+/// Add a component property for command `cmd`, which errors name (`component.makeSlot` adds its
+/// slot property here).
+pub(super) fn add_prop_for(cmd: &str, s: &mut Session, p: &Value) -> Result<Value> {
+    let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component"))?;
+    let name = valid_prop_name(cmd, &req_string(cmd, p, "name")?)?;
+    let t = req_string(cmd, p, "type")?;
+    let doc = s.doc_mut()?;
+    if inside_instance(doc, target) {
+        return Err(bad(cmd, "select a component, not a layer of an instance"));
+    }
+    let owner = Owner::resolve(doc, target).ok_or_else(|| bad(cmd, "select a component, a component set or a layer inside a component"))?;
+    // A layer selected inside the component gets bound to the new property.
+    let layer = id(p, "layer")
+        .or_else(|| (target != owner.id() && !matches!(doc.node(target).map(|n| &n.kind), Some(NodeKind::Component { .. }))).then_some(target));
+    let comps = owner.components(doc);
+    let variants = match &owner {
+        Owner::Set(s) => variant_options(doc, *s),
+        Owner::Comp(_) => Vec::new(),
+    };
+    if variants.iter().any(|(k, _)| *k == name) || comps.iter().any(|c| prop_defs(doc, *c).contains_key(&name)) {
+        return Err(bad(cmd, format!("a property named `{name}` already exists")));
+    }
+    let layer_node = layer.and_then(|l| doc.node(l)).cloned();
+    let def = match t.to_ascii_lowercase().as_str() {
+        // Without a default, a bound layer keeps showing as it does: its visibility is the default.
+        "boolean" | "bool" => PropDef::Boolean { default: boolean(p, "default").or_else(|| layer_node.as_ref().map(|n| n.visible)).unwrap_or(true) },
+        "text" => PropDef::Text {
+            default: string(p, "default")
+                .or_else(|| layer_node.as_ref().and_then(|n| n.kind.text()).map(|t| t.characters.clone()))
+                .unwrap_or_else(|| name.clone()),
+        },
+        "instanceswap" | "instance_swap" | "instance" => {
+            let d = id(p, "default")
+                .or_else(|| match layer_node.as_ref().map(|n| &n.kind) {
+                    Some(NodeKind::Instance { component, .. }) => Some(*component),
+                    _ => None,
+                })
+                .and_then(|c| main_of(doc, c))
+                .ok_or_else(|| bad(cmd, "default: a component id"))?;
+            PropDef::InstanceSwap { default: d, preferred: preferred_arg(cmd, doc, p)? }
+        }
+        "variant" => {
+            let dv = string(p, "default")
+                .map(|d| d.trim().to_string())
+                .filter(|d| !d.is_empty() && !d.contains([',', '=']))
+                .unwrap_or_else(|| "Default".into());
+            let set = match owner {
+                Owner::Set(s) => s,
+                Owner::Comp(c) => wrap_in_set(cmd, doc, &[c])?,
+            };
+            for c in Owner::Set(set).components(doc) {
+                let cn = doc.get_mut(c)?;
+                cn.name = if cn.name.contains('=') { format!("{}, {name}={dv}", cn.name) } else { format!("{name}={dv}") };
+            }
+            s.set_selection(vec![set]);
+            return Ok(json!({"id": set}));
+        }
+        "slot" => {
+            if !layer_node.as_ref().is_some_and(|n| matches!(n.kind, NodeKind::Frame)) {
+                return Err(bad(cmd, "a slot is a frame inside the component: select one (or pass `layer`)"));
+            }
+            PropDef::Slot { preferred: preferred_arg(cmd, doc, p)? }
+        }
+        _ => return Err(bad(cmd, "type: boolean|text|instanceSwap|variant|slot")),
+    };
+    for c in &comps {
+        set_prop_defs(doc, *c, |m| {
+            m.insert(name.clone(), def.clone());
+        })?;
+        // Existing instances get the default.
+        if !takes_value(&def) {
+            continue;
+        }
+        for inst in instances_of(doc, *c) {
+            if let NodeKind::Instance { props, .. } = &mut doc.get_mut(inst)?.kind {
+                props.entry(name.clone()).or_insert_with(|| prop_default_value(&def));
+            }
+        }
+    }
+    if let Some(l) = layer {
+        bind(cmd, doc, l, Some(&name), None)?;
+    }
+    Ok(json!({"id": owner.id(), "name": name}))
+}
+
+/// Bind (or with `property: None` unbind) a layer's field to a property of its component.
+fn bind(cmd: &str, doc: &mut Document, layer: NodeId, property: Option<&str>, field: Option<&str>) -> Result<()> {
+    let n = doc.get(layer)?.clone();
+    if inside_instance(doc, layer) {
+        return Err(bad(cmd, "layers inside an instance can't be bound (bind the nested instance itself, or edit its main)"));
+    }
+    let comp = owning_component(doc, layer).ok_or_else(|| bad(cmd, "the layer isn't inside a component"))?;
+    let Some(property) = property.filter(|p| !p.is_empty()) else {
+        let n = doc.get_mut(layer)?;
+        match field {
+            Some(f) => {
+                n.prop_refs.remove(f);
+            }
+            None => n.prop_refs.clear(),
+        }
+        return Ok(());
+    };
+    let defs = prop_defs(doc, comp);
+    let def = defs.get(property).ok_or_else(|| bad(cmd, format!("the component has no property `{property}`")))?;
+    let expected = match def {
+        PropDef::Boolean { .. } => "visible",
+        PropDef::Text { .. } => "characters",
+        PropDef::InstanceSwap { .. } => "mainComponent",
+        PropDef::Variant { .. } => return Err(bad(cmd, "variant properties pick a variant; they can't be bound to a layer")),
+        PropDef::Slot { .. } => SLOT,
+    };
+    let field = field.unwrap_or(expected);
+    if field != expected {
+        return Err(bad(cmd, format!("`{property}` can only control `{expected}`")));
+    }
+    match field {
+        "characters" if n.kind.text().is_none() => return Err(bad(cmd, "text properties bind to text layers")),
+        "mainComponent" if !matches!(n.kind, NodeKind::Instance { .. }) => return Err(bad(cmd, "instance swap properties bind to instances")),
+        "visible" if layer == comp => return Err(bad(cmd, "the component itself can't be hidden by its own property")),
+        SLOT if !matches!(n.kind, NodeKind::Frame) => return Err(bad(cmd, "slot properties bind to frames inside the component")),
+        SLOT if doc
+            .subtree(comp)
+            .into_iter()
+            .any(|d| d != layer && doc.node(d).is_some_and(|x| x.prop_refs.get(SLOT).map(String::as_str) == Some(property))) =>
+        {
+            return Err(bad(cmd, format!("another frame of the component is already the slot `{property}`")));
+        }
+        _ => {}
+    }
+    let n = doc.get_mut(layer)?;
+    n.prop_refs.insert(field.to_string(), property.to_string());
+    // On the main, a boolean property's value is the visibility of the layers it controls.
+    if let PropDef::Boolean { default } = def {
+        n.visible = *default;
+    }
+    Ok(())
+}
+
+pub(super) fn bind_prop(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.bindProperty";
+    let layer = id(p, "layer").or_else(|| targets(s, p).first().copied()).ok_or_else(|| bad(cmd, "`layer` required"))?;
+    let property = string(p, "property");
+    let field = string(p, "field");
+    if let Some(f) = &field
+        && !matches!(f.as_str(), "visible" | "characters" | "mainComponent" | SLOT)
+    {
+        return Err(bad(cmd, "field: visible|characters|mainComponent|slot"));
+    }
+    let doc = s.doc_mut()?;
+    bind(cmd, doc, layer, property.as_deref(), field.as_deref())?;
+    ok()
+}
+
+/// Rename `old` → `new` in the bindings of a component's layers and in its instances' values.
+fn rename_prop_refs(doc: &mut Document, comp: NodeId, old: &str, new: Option<&str>) -> Result<()> {
+    for d in doc.subtree(comp) {
+        let refs = doc.node(d).map(|n| n.prop_refs.clone()).unwrap_or_default();
+        if refs.values().any(|v| v == old)
+            && let Some(n) = doc.node_mut(d)
+        {
+            match new {
+                Some(nw) => n.prop_refs.values_mut().filter(|v| *v == old).for_each(|v| *v = nw.to_string()),
+                None => n.prop_refs.retain(|_, v| v != old),
+            }
+        }
+    }
+    // Instances' values and the variables bound to them follow (a deleted property drops both).
+    let old_key = format!("{PROP_BINDING}{old}");
+    for inst in instances_of(doc, comp) {
+        let n = doc.get_mut(inst)?;
+        if let NodeKind::Instance { props, .. } = &mut n.kind
+            && let Some(v) = props.remove(old)
+            && let Some(nw) = new
+        {
+            props.insert(nw.to_string(), v);
+        }
+        if let Some(var) = n.bound.remove(&old_key)
+            && let Some(nw) = new
+        {
+            n.bound.insert(format!("{PROP_BINDING}{nw}"), var);
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn edit_prop(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.editProperty";
+    let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component"))?;
+    let name = req_string(cmd, p, "name")?;
+    let new_name = string(p, "newName").map(|n| valid_prop_name(cmd, &n)).transpose()?.filter(|n| *n != name);
+    let doc = s.doc_mut()?;
+    let owner = Owner::resolve(doc, target).ok_or_else(|| bad(cmd, "select a component or component set"))?;
+    let comps = owner.components(doc);
+    if let Some(nn) = &new_name {
+        let taken = comps.iter().any(|c| prop_defs(doc, *c).contains_key(nn))
+            || matches!(owner, Owner::Set(s) if variant_options(doc, s).iter().any(|(k, _)| k == nn));
+        if taken {
+            return Err(bad(cmd, format!("a property named `{nn}` already exists")));
+        }
+    }
+    // Variant property of a set.
+    if let Owner::Set(set) = owner
+        && let Some((_, values)) = variant_options(doc, set).into_iter().find(|(k, _)| *k == name)
+    {
+        let order: Vec<String> = variant_options(doc, set).into_iter().map(|(k, _)| k).collect();
+        let rename_value = match (string(p, "value"), string(p, "newValue")) {
+            (Some(v), Some(nv)) => {
+                let nv = nv.trim().to_string();
+                if !values.contains(&v) {
+                    return Err(bad(cmd, format!("`{name}` has no value `{v}`")));
+                }
+                if nv.is_empty() || nv.contains([',', '=']) {
+                    return Err(bad(cmd, "`newValue` must be non-empty, without ',' or '='"));
+                }
+                Some((v, nv))
+            }
+            _ => None,
+        };
+        let mut order: Vec<String> = order.into_iter().map(|k| if k == name { new_name.clone().unwrap_or(k) } else { k }).collect();
+        // Reordered: every variant's name lists the properties in the new order.
+        if let Some(to) = get(p, "index").filter(|v| !v.is_null()) {
+            let to = to.as_u64().and_then(|i| usize::try_from(i).ok()).ok_or_else(|| bad(cmd, "`index`: a property place (0 = first)"))?;
+            let key = new_name.clone().unwrap_or(name.clone());
+            order.retain(|k| *k != key);
+            order.insert(to.min(order.len()), key);
+        }
+        for c in &comps {
+            let mut pairs = variant_props(&doc.get(*c)?.name);
+            if let Some((v, nv)) = &rename_value
+                && pairs.get(&name) == Some(v)
+            {
+                pairs.insert(name.clone(), nv.clone());
+            }
+            if let Some(nn) = &new_name
+                && let Some(v) = pairs.remove(&name)
+            {
+                pairs.insert(nn.clone(), v);
+            }
+            doc.get_mut(*c)?.name = variant_name(&pairs, &order);
+        }
+        // The default variant is the top-left one: the variant with that value (and the default's
+        // other values, when there is one) trades places with it.
+        if let Some(dv) = string(p, "default") {
+            let key = new_name.clone().unwrap_or(name.clone());
+            let current = default_variant(doc, set);
+            let mut wanted = current.and_then(|d| doc.node(d)).map(|n| variant_props(&n.name)).unwrap_or_default();
+            wanted.insert(key.clone(), dv.clone());
+            let props_of = |c: &NodeId| doc.node(*c).map(|n| variant_props(&n.name)).unwrap_or_default();
+            let pick =
+                comps.iter().copied().find(|c| props_of(c) == wanted).or_else(|| comps.iter().copied().find(|c| props_of(c).get(&key) == Some(&dv)));
+            let (Some(f), Some(d)) = (pick, current) else { return Err(bad(cmd, format!("no variant has {key}={dv}"))) };
+            if f != d {
+                let place = |doc: &Document, c: NodeId| doc.node(c).map(|n| n.transform.as_coeffs()).map(|[.., x, y]| (x, y)).unwrap_or_default();
+                let (fp, dp) = (place(doc, f), place(doc, d));
+                for (c, (x, y)) in [(f, dp), (d, fp)] {
+                    let n = doc.get_mut(c)?;
+                    let [a, b, cc, dd, ..] = n.transform.as_coeffs();
+                    n.transform = figcraft_geom::Affine::new([a, b, cc, dd, x, y]);
+                }
+                fit_set(doc, set);
+            }
+        }
+        return ok();
+    }
+    let def = comps.iter().find_map(|c| prop_defs(doc, *c).get(&name).cloned()).ok_or_else(|| bad(cmd, format!("no property named `{name}`")))?;
+    let preferred = if get(p, "preferred").is_some() {
+        if !matches!(def, PropDef::Slot { .. } | PropDef::InstanceSwap { .. }) {
+            return Err(bad(cmd, "`preferred` is for instance swap and slot properties"));
+        }
+        Some(preferred_arg(cmd, doc, p)?)
+    } else {
+        None
+    };
+    let mut new_def = match get(p, "default") {
+        Some(v) => match coerce(cmd, doc, &name, &def, v)? {
+            Value::Bool(b) => PropDef::Boolean { default: b },
+            Value::String(t) if matches!(def, PropDef::Text { .. }) => PropDef::Text { default: t },
+            other => match (&def, id_of(&other)) {
+                (PropDef::InstanceSwap { preferred, .. }, Some(c)) => PropDef::InstanceSwap { default: c, preferred: preferred.clone() },
+                _ => def.clone(),
+            },
+        },
+        None => def.clone(),
+    };
+    if let (Some(list), PropDef::Slot { preferred } | PropDef::InstanceSwap { preferred, .. }) = (preferred, &mut new_def) {
+        *preferred = list;
+    }
+    for c in &comps {
+        let had = prop_defs(doc, *c).contains_key(&name);
+        if !had {
+            continue;
+        }
+        let key = new_name.clone().unwrap_or(name.clone());
+        let nd = new_def.clone();
+        let old = name.clone();
+        set_prop_defs(doc, *c, move |m| {
+            m.remove(&old);
+            m.insert(key, nd);
+        })?;
+        if let Some(nn) = &new_name {
+            rename_prop_refs(doc, *c, &name, Some(nn))?;
+        }
+    }
+    // The main's bound layers show the new default.
+    if let PropDef::Boolean { default } = new_def {
+        set_boolean_default(doc, &comps, new_name.as_deref().unwrap_or(&name), default);
+    }
+    ok()
+}
+
+pub(super) fn delete_prop(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.deleteProperty";
+    let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component"))?;
+    let name = req_string(cmd, p, "name")?;
+    let doc = s.doc_mut()?;
+    let owner = Owner::resolve(doc, target).ok_or_else(|| bad(cmd, "select a component or component set"))?;
+    let comps = owner.components(doc);
+    if let Owner::Set(set) = owner
+        && variant_options(doc, set).iter().any(|(k, _)| *k == name)
+    {
+        let order: Vec<String> = variant_options(doc, set).into_iter().map(|(k, _)| k).collect();
+        for c in &comps {
+            let mut pairs = variant_props(&doc.get(*c)?.name);
+            pairs.remove(&name);
+            let n = doc.get_mut(*c)?;
+            n.name = if pairs.is_empty() { "Default".into() } else { variant_name(&pairs, &order) };
+        }
+        return ok();
+    }
+    let mut found = false;
+    for c in &comps {
+        if prop_defs(doc, *c).contains_key(&name) {
+            found = true;
+            set_prop_defs(doc, *c, |m| {
+                m.remove(&name);
+            })?;
+            rename_prop_refs(doc, *c, &name, None)?;
+        }
+    }
+    if !found {
+        return Err(bad(cmd, format!("no property named `{name}`")));
+    }
+    ok()
+}
+
+fn def_json(name: &str, d: &PropDef) -> Value {
+    match d {
+        PropDef::Boolean { default } => json!({"name": name, "type": "boolean", "default": default}),
+        PropDef::Text { default } => json!({"name": name, "type": "text", "default": default}),
+        PropDef::InstanceSwap { default, preferred } => json!({"name": name, "type": "instanceSwap", "default": default, "preferred": preferred}),
+        PropDef::Variant { options, default } => json!({"name": name, "type": "variant", "default": default, "options": options}),
+        PropDef::Slot { preferred } => json!({"name": name, "type": "slot", "preferred": preferred}),
+    }
+}
+
+/// Properties of a component, set or instance as JSON (`component.properties`).
+pub(crate) fn describe_props(doc: &Document, id: NodeId) -> Value {
+    let Some(n) = doc.node(id) else { return Value::Null };
+    let (owner_comp, values) = match &n.kind {
+        NodeKind::Instance { component, props } => (Some(*component), Some(props.clone())),
+        _ => (main_of(doc, id).or_else(|| owning_component(doc, id)), None),
+    };
+    let Some(comp) = owner_comp else { return json!({"properties": []}) };
+    let mut list: Vec<Value> = Vec::new();
+    if let Some(set) = variant_set(doc, comp) {
+        let current = doc.node(comp).map(|c| variant_props(&c.name)).unwrap_or_default();
+        let defaults = default_variant(doc, set).and_then(|d| doc.node(d)).map(|n| variant_props(&n.name)).unwrap_or_default();
+        for (k, vals) in variant_options(doc, set) {
+            let mut v = json!({"name": k, "type": "variant", "options": vals, "default": defaults.get(&k).or(vals.first())});
+            if values.is_some() {
+                v["value"] = json!(current.get(&k));
+            }
+            list.push(v);
+        }
+    }
+    // Slots: the frames (on a main) or this instance's copy, with whether it holds its own content.
+    let slots = slots_of(doc, if values.is_some() { id } else { variant_set(doc, comp).unwrap_or(comp) });
+    for (k, d) in prop_defs(doc, comp) {
+        let mut v = def_json(&k, &d);
+        if !takes_value(&d) {
+            let layers: Vec<NodeId> = slots.iter().filter(|(_, n)| *n == k).map(|(l, _)| *l).collect();
+            if values.is_some() {
+                v["value"] = layers.first().map_or(Value::Null, |l| {
+                    let count = doc.node(*l).map_or(0, |n| n.children.len());
+                    json!({"layer": l, "edited": slot_edited(doc, *l), "layers": count})
+                });
+            } else {
+                v["layers"] = json!(layers);
+            }
+        } else if let Some(vals) = &values {
+            v["value"] = vals.get(&k).cloned().unwrap_or_else(|| prop_default_value(&d));
+        }
+        list.push(v);
+    }
+    let set = variant_set(doc, comp);
+    let conflicts = set.map(|s| variant_conflicts(doc, s)).unwrap_or_default();
+    json!({"component": comp, "set": set, "properties": list, "conflicts": conflicts})
+}
diff --git a/crates/engine/src/cmd/component/variants.rs b/crates/engine/src/cmd/component/variants.rs
new file mode 100644
index 00000000..f6e7ac6c
--- /dev/null
+++ b/crates/engine/src/cmd/component/variants.rs
@@ -0,0 +1,175 @@
+use super::*;
+
+/// Wrap components in a new component set (named after the first) placed around them.
+pub(super) fn wrap_in_set(cmd: &str, doc: &mut Document, ids: &[NodeId]) -> Result<NodeId> {
+    let top = *ids.last().ok_or_else(|| bad(cmd, "nothing selected"))?;
+    let parent = doc.get(top)?.parent.ok_or_else(|| bad(cmd, "page"))?;
+    if inside_instance(doc, top) || owning_instance(doc, parent).is_some() {
+        return Err(EngineError::Disabled(cmd.into(), INSIDE_INSTANCE.into()));
+    }
+    let bounds = doc.bounds_of(ids).unwrap_or_default();
+    let pw = doc.world_transform(parent);
+    let local = figcraft_geom::transform_rect_bbox(pw.inverse(), bounds.inflate(20.0, 20.0));
+    let base = ids.first().and_then(|i| doc.node(*i)).and_then(|n| set_name_from(&n.name)).unwrap_or_else(|| doc.next_name("Component"));
+    let set = doc.alloc_id();
+    let mut n = Node::new(set, NodeKind::ComponentSet { description: String::new() }, base, local.width(), local.height());
+    n.transform = figcraft_geom::Affine::translate((local.x0, local.y0));
+    n.fills.clear();
+    doc.insert(n, parent, doc.index_in_parent(top).map(|i| i + 1))?;
+    for i in ids {
+        doc.reparent(*i, set, None)?;
+    }
+    Ok(set)
+}
+
+const INSIDE_INSTANCE: &str = "components inside an instance can't become variants";
+
+/// Why `ids` (distinct) can't become the variants of a new component set, or `None` when they
+/// can: anything but main components, components that are variants already (combining them would
+/// put a set in a set), library copies, components inside an instance, and a component inside
+/// another one of `ids`.
+fn combine_refusal(doc: &Document, ids: &[NodeId]) -> Option<&'static str> {
+    if !ids.iter().all(|i| doc.node(*i).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. }))) {
+        Some("select components only")
+    } else if ids.iter().any(|i| variant_set(doc, *i).is_some()) {
+        Some("components that are variants already can't be combined again")
+    } else if ids.iter().any(|i| doc.is_remote(*i)) {
+        Some(crate::library::READ_ONLY)
+    } else if ids.iter().any(|i| inside_instance(doc, *i)) {
+        Some(INSIDE_INSTANCE)
+    } else if roots(doc, ids).len() != ids.len() {
+        Some("a component can't be combined with one inside it")
+    } else {
+        None
+    }
+}
+
+/// Whether "Combine as variants" is on offer for `ids` (menus and the Design panel): two or more
+/// main components that [`combine_refusal`] lets through.
+pub fn can_combine_variants(doc: &Document, ids: &[NodeId]) -> bool {
+    ids.len() >= 2 && combine_refusal(doc, ids).is_none() && ids.iter().collect::<BTreeSet<_>>().len() == ids.len()
+}
+
+/// Whether "Add variant" is on offer for `id`: a component set with variants, a variant, or a main
+/// component not in a set yet (it becomes one); never a library copy or inside an instance.
+pub fn can_add_variant(doc: &Document, id: NodeId) -> bool {
+    let Some(n) = doc.node(id) else { return false };
+    let local = !doc.is_remote(id) && !inside_instance(doc, id);
+    match n.kind {
+        NodeKind::ComponentSet { .. } => {
+            local && n.children.iter().any(|c| doc.node(*c).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })))
+        }
+        NodeKind::Component { .. } => local,
+        _ => false,
+    }
+}
+
+/// Wrap `ids` (z-sorted main components) in a new component set, naming them "Property 1=Default",
+/// "Property 1=VariantN" unless already in prop=value form. Returns the set.
+fn make_variant_set(cmd: &str, doc: &mut Document, ids: &[NodeId]) -> Result<NodeId> {
+    let set = wrap_in_set(cmd, doc, ids)?;
+    for (k, i) in ids.iter().enumerate() {
+        let node = doc.get_mut(*i)?;
+        if !node.name.contains('=') {
+            node.name = format!("Property 1={}", if k == 0 { "Default".to_string() } else { format!("Variant{}", k + 1) });
+        }
+    }
+    Ok(set)
+}
+
+pub(super) fn combine(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.combineVariants";
+    let mut seen = BTreeSet::new();
+    let ids: Vec<NodeId> = req_targets(cmd, s, p)?.into_iter().filter(|i| seen.insert(*i)).collect();
+    let doc = s.doc_mut()?;
+    if let Some(why) = combine_refusal(doc, &ids) {
+        return Err(EngineError::Disabled(cmd.into(), why.into()));
+    }
+    let ids = z_sorted(doc, &ids);
+    let set = make_variant_set(cmd, doc, &ids)?;
+    s.set_selection(vec![set]);
+    Ok(json!({"id": set}))
+}
+
+/// Grow a component set so it wraps its variants with 20 px of padding (right and bottom).
+pub(super) fn fit_set(doc: &mut Document, set: NodeId) {
+    let Some(kids) = doc.node(set).map(|n| n.children.clone()) else { return };
+    let (mut w, mut h) = (0.0f64, 0.0f64);
+    for c in kids {
+        if let Some(n) = doc.node(c) {
+            let b = figcraft_geom::transform_rect_bbox(n.transform, n.local_rect());
+            w = w.max(b.x1 + 20.0);
+            h = h.max(b.y1 + 20.0);
+        }
+    }
+    if let Some(n) = doc.node_mut(set) {
+        n.width = n.width.max(w);
+        n.height = n.height.max(h);
+    }
+}
+
+pub(super) fn add_variant(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "component.addVariant";
+    let t = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component set or component"))?;
+    let doc = s.doc_mut()?;
+    let (set, base) = match doc.get(t)?.kind {
+        NodeKind::ComponentSet { .. } => {
+            let last = doc.get(t)?.children.last().copied().ok_or_else(|| bad(cmd, "the component set is empty"))?;
+            (t, last)
+        }
+        NodeKind::Component { .. } => match variant_set(doc, t) {
+            Some(set) => (set, t),
+            // A main component on its own becomes a set of itself, then gains the new variant.
+            None => (make_variant_set(cmd, doc, &[t])?, t),
+        },
+        _ => return Err(bad(cmd, "select a component set or component")),
+    };
+    let options = variant_options(doc, set);
+    let mut pairs = variant_props(&doc.get(base)?.name);
+    let order: Vec<String> = options.iter().map(|(k, _)| k.clone()).collect();
+    let existing: BTreeSet<BTreeMap<String, String>> =
+        doc.get(set)?.children.iter().filter_map(|c| doc.node(*c)).map(|n| variant_props(&n.name)).collect();
+    match (string(p, "property"), string(p, "value")) {
+        (Some(prop), Some(value)) => {
+            let (prop, value) = (prop.trim().to_string(), value.trim().to_string());
+            if !options.iter().any(|(k, _)| *k == prop) {
+                return Err(bad(cmd, format!("unknown variant property `{prop}`")));
+            }
+            if value.is_empty() || value.contains([',', '=']) {
+                return Err(bad(cmd, "`value` must be non-empty without ',' or '='"));
+            }
+            pairs.insert(prop, value);
+            if existing.contains(&pairs) {
+                return Err(bad(cmd, "that variant already exists"));
+            }
+        }
+        (Some(_), None) => return Err(bad(cmd, "`value` is required with `property`")),
+        _ => {
+            let prop = order.first().cloned().unwrap_or_else(|| "Property 1".into());
+            let mut k = existing.len() + 1;
+            loop {
+                pairs.insert(prop.clone(), format!("Variant{k}"));
+                if !existing.contains(&pairs) || k > 10_000 {
+                    break;
+                }
+                k += 1;
+            }
+        }
+    }
+    let name = variant_name(&pairs, &order);
+    let bottom = doc
+        .get(set)?
+        .children
+        .iter()
+        .filter_map(|c| doc.node(*c))
+        .map(|n| figcraft_geom::transform_rect_bbox(n.transform, n.local_rect()).y1)
+        .fold(0.0f64, f64::max);
+    let dup = doc.duplicate_into(base, set, None)?;
+    let n = doc.get_mut(dup)?;
+    n.name = name;
+    let c = n.transform.as_coeffs();
+    n.transform = figcraft_geom::Affine::new([c[0], c[1], c[2], c[3], c[4], bottom + 20.0]);
+    fit_set(doc, set);
+    s.set_selection(vec![dup]);
+    Ok(json!({"id": dup}))
+}

From c4bd0dd542bc15a44f560448cd4d512ee7f66a6a Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:20:45 +0000
Subject: [PATCH 31/67] refactor(engine): move Session state, prefs, errors and
 methods out of lib.rs

---
 crates/engine/src/derived.rs    |  236 +++++
 crates/engine/src/doc_state.rs  |  348 +++++++
 crates/engine/src/error.rs      |   51 +
 crates/engine/src/lib.rs        | 1532 +------------------------------
 crates/engine/src/prefs.rs      |  181 ++++
 crates/engine/src/session.rs    |  583 ++++++++++++
 crates/engine/src/view_state.rs |  136 +++
 7 files changed, 1546 insertions(+), 1521 deletions(-)
 create mode 100644 crates/engine/src/derived.rs
 create mode 100644 crates/engine/src/doc_state.rs
 create mode 100644 crates/engine/src/error.rs
 create mode 100644 crates/engine/src/prefs.rs
 create mode 100644 crates/engine/src/session.rs
 create mode 100644 crates/engine/src/view_state.rs

diff --git a/crates/engine/src/derived.rs b/crates/engine/src/derived.rs
new file mode 100644
index 00000000..765e3be5
--- /dev/null
+++ b/crates/engine/src/derived.rs
@@ -0,0 +1,236 @@
+use super::*;
+
+/// Nodes whose `Arc` differs from `before` (new or edited).
+pub fn changed_nodes(doc: &Document, before: &Document) -> Vec<NodeId> {
+    doc.ids()
+        .filter(|id| match (doc.node_arc(*id), before.node_arc(*id)) {
+            (Some(a), Some(b)) => !Arc::ptr_eq(a, b),
+            _ => true,
+        })
+        .collect()
+}
+
+/// Keep derived state consistent after edits: text boxes resize to their content, groups wrap
+/// their children, instances follow their main components, auto layout re-flows.
+pub fn normalize(doc: &mut Document, before: &Document) {
+    // Only what was touched since the last normalisation (edited, added or removed).
+    let mut touched: BTreeSet<NodeId> = doc.take_dirty();
+    // A variable or style edit changes no layer directly, but bound and linked layers must follow it.
+    if touched.is_empty() && doc.variables == before.variables && doc.styles == before.styles {
+        return;
+    }
+    let m = measure::TextMeasure;
+    // 0. Variable bindings and style links feed node values.
+    let scope = binding_scope(doc, before, &touched);
+    if doc.variables != before.variables || doc.styles != before.styles {
+        style_vars::settle(doc);
+    }
+    cmd::styles::apply_bindings_to(doc, scope.as_ref());
+    style_vars::refresh(doc, Some(before), scope.as_ref());
+    if doc.styles != before.styles {
+        let changed_styles: Vec<String> = doc.styles.iter().filter(|s| !before.styles.contains(s)).map(|s| s.id.clone()).collect();
+        for sid in changed_styles {
+            cmd::styles::propagate_style(doc, &sid);
+        }
+    }
+    touched.extend(doc.take_dirty());
+    // Lists and text chars edited away from their style unlink from it.
+    let live_now: Vec<NodeId> = touched.iter().copied().filter(|i| doc.contains(*i)).collect();
+    cmd::styles::sync_list_styles(doc, before, &live_now);
+    cmd::styles::sync_text_styles(doc, &live_now);
+    touched.extend(doc.take_dirty());
+    let live = |doc: &Document, t: &BTreeSet<NodeId>| -> Vec<NodeId> { t.iter().copied().filter(|i| doc.contains(*i)).collect() };
+    // 0b. Fill and hug only where they can apply (a layer moved out of auto layout, a parent that
+    // started to hug or lost auto layout): the rest becomes fixed at its current size.
+    for id in live(doc, &touched) {
+        figcraft_layout::coherent_sizing(doc, id);
+    }
+    touched.extend(doc.take_dirty());
+    // 1. Text auto-size (a sticky's note first takes the size its length calls for).
+    board::settle_text(doc, before, &touched);
+    touched.extend(doc.take_dirty());
+    for id in live(doc, &touched) {
+        let Some(n) = doc.node(id) else { continue };
+        if let Some((w, h)) = figcraft_text::auto_size(n)
+            && ((w - n.width).abs() > 1e-6 || (h - n.height).abs() > 1e-6)
+        {
+            figcraft_layout::set_size(doc, id, w, h);
+        }
+    }
+    touched.extend(doc.take_dirty());
+    // 2. Instances follow edited main components (and record overrides inside instances).
+    let changed = live(doc, &touched);
+    components::sync_after_edit(doc, before, &changed, &touched);
+    // Rebuilt copies took their mains' values: their bindings resolve in their own modes.
+    let synced = doc.take_dirty();
+    if !synced.is_empty() {
+        cmd::styles::apply_bindings_to(doc, Some(&synced));
+        style_vars::refresh(doc, Some(before), Some(&synced));
+        touched.extend(synced);
+    }
+    touched.extend(doc.take_dirty());
+    // Parents of removed nodes (as they were before) count as touched.
+    let removed_parents: Vec<NodeId> =
+        touched.iter().filter(|i| !doc.contains(**i)).filter_map(|i| before.node(*i).and_then(|n| n.parent)).filter(|p| doc.contains(*p)).collect();
+    // 3. Groups / booleans wrap their children.
+    let mut fit: BTreeSet<NodeId> = BTreeSet::new();
+    for id in live(doc, &touched).into_iter().chain(removed_parents.iter().copied()) {
+        if doc.node(id).is_some_and(|n| n.kind.bounds_follow_children()) {
+            fit.insert(id);
+        }
+        for a in doc.ancestors(id) {
+            if doc.node(a).is_some_and(|n| n.kind.bounds_follow_children()) {
+                fit.insert(a);
+            } else {
+                break;
+            }
+        }
+    }
+    let mut fit: Vec<NodeId> = fit.into_iter().collect();
+    fit.sort_by_key(|id| std::cmp::Reverse(doc.ancestors(*id).len()));
+    for id in fit {
+        if doc.node(id).is_some_and(|n| n.children.is_empty()) {
+            // Empty groups disappear, like the incumbent.
+            let _ = doc.remove(id);
+        } else {
+            let _ = doc.fit_to_children(id);
+        }
+    }
+    touched.extend(doc.take_dirty());
+    // 4. Auto layout for frames where something that sizes or places layers changed.
+    let mut frames: BTreeSet<NodeId> = BTreeSet::new();
+    let moved = live(doc, &touched).into_iter().filter(|id| affects_layout(before, doc, *id));
+    for id in moved.chain(removed_parents) {
+        if !doc.contains(id) {
+            continue;
+        }
+        let mut chain = vec![id];
+        chain.extend(doc.ancestors(id));
+        for c in chain {
+            if doc.node(c).is_some_and(|n| n.layout.is_some()) {
+                frames.insert(c);
+            }
+        }
+    }
+    let mut frames: Vec<NodeId> = frames.into_iter().collect();
+    frames.sort_by_key(|id| std::cmp::Reverse(doc.ancestors(*id).len()));
+    for f in frames {
+        // Layers the layout leaves where they were stay untouched.
+        let kept: Vec<(Arc<Node>, bool)> = doc
+            .node(f)
+            .map(|n| std::iter::once(f).chain(n.children.iter().copied()).collect::<Vec<_>>())
+            .unwrap_or_default()
+            .into_iter()
+            .filter_map(|i| doc.node_arc(i).map(|a| (a.clone(), doc.dirty().contains(&i))))
+            .collect();
+        figcraft_layout::layout_frame(doc, f, &m);
+        for (a, was_dirty) in kept {
+            doc.keep_if_unchanged(a, was_dirty);
+        }
+    }
+    touched.extend(doc.take_dirty());
+    // 4b. Board connectors follow the layers they join; their labels sit at their middles.
+    board::settle_routes(doc, before, &touched);
+    touched.extend(doc.take_dirty());
+    // 5. Ready-for-dev layers whose contents changed show "Changed".
+    mark_dev_changes(doc, before, &touched);
+    doc.take_dirty();
+    // 5. Comment pins follow their layers to other pages and stay put when the layers are deleted.
+    cmd::comment::follow_anchors(doc, before);
+}
+
+/// Whether layer `id` changed (since `before`) in a way that can move or resize layers in an auto
+/// layout frame around it: new, resized, moved, shown or hidden, restructured, other text or
+/// layout settings.
+fn affects_layout(before: &Document, doc: &Document, id: NodeId) -> bool {
+    let (Some(a), Some(b)) = (before.node(id), doc.node(id)) else { return true };
+    a.width != b.width
+        || a.height != b.height
+        || a.transform != b.transform
+        || a.visible != b.visible
+        || a.parent != b.parent
+        || a.children != b.children
+        || a.layout != b.layout
+        || a.child_layout != b.child_layout
+        || a.stroke != b.stroke
+        || a.strokes.len() != b.strokes.len()
+        || a.kind != b.kind
+}
+
+/// The layers whose variable bindings an edit may have changed: every bound layer when a variable
+/// changed, else the touched layers and everything below those that moved, are new, chose
+/// another variable mode or became an instance of another main (modes are inherited, an
+/// instance's from its main too), and the instances of a main that chose another mode.
+fn binding_scope(doc: &Document, before: &Document, touched: &BTreeSet<NodeId>) -> Option<BTreeSet<NodeId>> {
+    if doc.variables != before.variables {
+        return None;
+    }
+    let main = |n: &Node| match n.kind {
+        figcraft_doc::NodeKind::Instance { component, .. } => Some(component),
+        _ => None,
+    };
+    let mut out = BTreeSet::new();
+    for &id in touched {
+        let Some(n) = doc.node(id) else { continue };
+        let Some(b) = before.node(id) else {
+            out.extend(doc.subtree(id));
+            continue;
+        };
+        let modes = b.var_modes != n.var_modes;
+        if modes || b.parent != n.parent || main(b) != main(n) {
+            out.extend(doc.subtree(id));
+        } else {
+            out.insert(id);
+        }
+        if modes && matches!(n.kind, figcraft_doc::NodeKind::Component { .. }) {
+            for i in components::instances_of(doc, id) {
+                out.extend(doc.subtree(i));
+            }
+        }
+    }
+    Some(out)
+}
+
+/// Flag the frames and sections marked ready for dev (before this edit) that contain a layer whose
+/// design `touched` changed (added, removed or edited; the handoff status itself and hiding a
+/// section's contents don't count).
+fn mark_dev_changes(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
+    let ready = |d: &Document, id: NodeId| d.node(id).is_some_and(|n| n.dev_status == figcraft_doc::DevStatus::ReadyForDev);
+    let mut changed: BTreeSet<NodeId> = BTreeSet::new();
+    for &id in touched {
+        // Ready-for-dev frames around it first (the cheap test).
+        let mut chain = vec![id];
+        chain.extend(if doc.contains(id) { doc.ancestors(id) } else { before.ancestors(id) });
+        chain.retain(|m| ready(before, *m) && ready(doc, *m));
+        if chain.is_empty() {
+            continue;
+        }
+        let differs = match (before.node(id), doc.node(id)) {
+            (Some(a), Some(b)) => !a.same_design(b),
+            (None, None) => false,
+            _ => true,
+        };
+        if differs {
+            changed.extend(chain);
+        }
+    }
+    for m in changed {
+        if doc.node(m).is_some_and(|n| !n.dev_changed) {
+            // Its first change since it was marked: keep what it looked like (for Compare changes).
+            if let Some(snap) = before.snapshot_subtree(m) {
+                doc.dev_snapshots.insert(m, Arc::new(snap));
+            }
+            if let Some(n) = doc.node_mut(m) {
+                n.dev_changed = true;
+            }
+        }
+    }
+    // Snapshots last until the change is resolved, the layer is marked again or it's deleted.
+    if !doc.dev_snapshots.is_empty() {
+        let keep = |d: &Document, id: NodeId| d.node(id).is_some_and(|n| n.dev_status == figcraft_doc::DevStatus::ReadyForDev && n.dev_changed);
+        let stale: Vec<NodeId> = doc.dev_snapshots.keys().copied().filter(|id| !keep(doc, *id)).collect();
+        for id in stale {
+            doc.dev_snapshots.remove(&id);
+        }
+    }
+}
diff --git a/crates/engine/src/doc_state.rs b/crates/engine/src/doc_state.rs
new file mode 100644
index 00000000..4f9509a7
--- /dev/null
+++ b/crates/engine/src/doc_state.rs
@@ -0,0 +1,348 @@
+use super::view_state::ViewState;
+use super::*;
+
+/// One undo step.
+#[derive(Clone, Debug)]
+pub struct HistoryEntry {
+    pub label: String,
+    pub doc: Arc<Document>,
+    pub selection: Vec<NodeId>,
+    pub page: NodeId,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct History {
+    pub undo: Vec<HistoryEntry>,
+    pub redo: Vec<HistoryEntry>,
+    pub limit: usize,
+}
+
+/// An in-progress gesture: the document before it started, so previews re-apply from scratch.
+#[derive(Clone, Debug)]
+pub struct Interaction {
+    pub label: String,
+    pub doc: Arc<Document>,
+    pub selection: Vec<NodeId>,
+}
+
+/// The text being edited on the canvas.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TextEdit {
+    pub id: NodeId,
+    /// Caret position and selection anchor (char indices).
+    pub caret: usize,
+    pub anchor: usize,
+    /// The node was created by this edit (deleted if left empty).
+    pub created: bool,
+    /// Identity of this editing session (`textedit::begin` assigns a fresh one).
+    ///
+    /// The IME owner is `(document uid, node)`, which stays the same through ordinary edits
+    /// and caret moves; this token changes only when editing is started again, so an IME
+    /// context is never silently inherited by a replaced target that reuses the same node.
+    ///
+    /// It is deliberately not serialized: current consumers only inspect a live session. A
+    /// serialized `TextEdit` restored from data would get zero here, so it must not be restored
+    /// into a live editor without minting (or otherwise invalidating) a new session.
+    #[serde(default, skip_serializing)]
+    pub editing_session: u64,
+    /// An IME composition in progress, shown inline at the caret; the document gets it on commit.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub preedit: Option<Preedit>,
+}
+
+/// IME composition text (not yet in the document) and the IME's cursor inside it (chars).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Preedit {
+    pub text: String,
+    pub cursor: usize,
+}
+
+/// Per-document editing state.
+#[derive(Clone, Debug)]
+pub struct DocState {
+    pub doc: Arc<Document>,
+    pub selection: Vec<NodeId>,
+    pub page: NodeId,
+    pub history: History,
+    pub(crate) saved_doc: Arc<Document>,
+    pub path: Option<String>,
+    pub revision: u64,
+    pub view: ViewState,
+    pub interaction: Option<Interaction>,
+    pub text_edit: Option<TextEdit>,
+    /// Hovered node (canvas hover outline).
+    pub hover: Option<NodeId>,
+    /// Vector edit mode: the vector being edited, its selected points and the edit tool.
+    pub vector_edit: Option<vectoredit::VectorEdit>,
+    pub uid: u64,
+    /// The file's version history, oldest first (saved in the `.figcraft` file; not undoable).
+    pub versions: Vec<figcraft_format::Version>,
+    /// The file's branches (saved in the `.figcraft` file; not undoable).
+    pub branches: Vec<figcraft_format::Branch>,
+    /// This tab shows a branch: the `uid` of its main file's tab and the branch id. Its edits go
+    /// into the main file's branch (and are saved with the main file).
+    pub branch_of: Option<(u64, String)>,
+    /// The version history or the branches changed since the last save.
+    pub(crate) versions_changed: bool,
+    /// A version shown in place of the document (read-only).
+    pub preview: Option<VersionPreview>,
+    /// The document under a live text preview (a hovered font family or style, text style or
+    /// font instance, a dragged axis slider): `doc` shows the preview until [`textpreview::end`] puts this back.
+    pub text_preview: Option<Arc<Document>>,
+    /// The document as of the last version saved or restored (none yet): autosaves, restores and
+    /// merges only add a checkpoint for changes since.
+    checkpoint: Option<Arc<Document>>,
+    /// Dev Mode focus view: the frame or section shown alone on the canvas (see [`Self::focused`]).
+    pub focus: Option<NodeId>,
+    /// The ruler guide clicked last: its page or frame and index (see [`Self::selected_guide`]).
+    pub guide: Option<(NodeId, usize)>,
+    /// The selection's rotation origin, when moved or shown (see [`rotation_origin`]; not saved).
+    pub(crate) rotation_origin: Option<rotation_origin::RotationOrigin>,
+    /// The View toggles the preferences keep were applied ([`Session::apply_view_prefs`]).
+    pub(crate) view_from_prefs: bool,
+    /// The last duplicate while its copies are the selection: Duplicate repeats its offset (see
+    /// [`cmd::edit::Duplicated`]; not saved).
+    pub(crate) last_duplicate: Option<cmd::edit::Duplicated>,
+    images_left_in_file: Option<(String, usize)>,
+    /// The file on disk as this tab last read or wrote it: a save refuses to replace what another
+    /// app (figcraft-cli, say) wrote to it since (#1330).
+    pub(crate) on_disk: Option<library::Stamp>,
+}
+
+/// A version shown on the canvas in place of the document: read-only until it's restored or the
+/// preview ends, which puts the document back as it was.
+#[derive(Clone, Debug)]
+pub struct VersionPreview {
+    pub id: String,
+    pub name: String,
+    /// When the version was saved (Unix seconds).
+    pub time: u64,
+    pub(crate) doc: Arc<Document>,
+    pub(crate) selection: Vec<NodeId>,
+    pub(crate) page: NodeId,
+}
+
+/// Why edits are refused while a version is shown.
+pub const PREVIEW_READ_ONLY: &str = "you're viewing an earlier version: restore it or go back to the current version to edit";
+
+/// Commands that first end a version preview: they act on the document itself. Saving does so
+/// only with a native destination; export copies and pending format choices keep the preview.
+pub(crate) const ENDS_PREVIEW: &[&str] =
+    &["file.save", "file.saveAs", "file.markSaved", "file.close", "file.revert", "file.saveVersion", "file.duplicate", "version.restore"];
+
+static NEXT_UID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+
+impl DocState {
+    pub fn new(mut doc: Document, path: Option<String>) -> Self {
+        if doc.pages.is_empty() {
+            doc.repair();
+        }
+        doc.link_layer_text_styles();
+        cmd::styles::apply_paint_bindings_on_load(&mut doc);
+        components::mark_layer_modes(&mut doc);
+        // Initial import settlement belongs to the saved baseline, not the user's first edit.
+        let page = doc.current_page.filter(|p| doc.pages.contains(p)).or_else(|| doc.first_page()).unwrap_or(NodeId(0));
+        let doc = Arc::new(doc);
+        let mut st = Self {
+            checkpoint: None,
+            saved_doc: doc.clone(),
+            doc,
+            selection: Vec::new(),
+            page,
+            history: History { limit: 1000, ..Default::default() },
+            path,
+            revision: 1,
+            view: ViewState::default(),
+            interaction: None,
+            text_edit: None,
+            hover: None,
+            vector_edit: None,
+            uid: NEXT_UID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
+            versions: Vec::new(),
+            branches: Vec::new(),
+            branch_of: None,
+            versions_changed: false,
+            preview: None,
+            text_preview: None,
+            focus: None,
+            guide: None,
+            rotation_origin: None,
+            view_from_prefs: false,
+            last_duplicate: None,
+            images_left_in_file: None,
+            on_disk: None,
+        };
+        st.zoom_to_fit();
+        st
+    }
+
+    pub fn with_images_left_in_file(mut self, path: &str, count: usize) -> Self {
+        self.images_left_in_file = (count > 0).then(|| (path.to_string(), count));
+        self
+    }
+
+    /// The tab's file now holds what this tab read or wrote.
+    pub(crate) fn note_on_disk(&mut self) {
+        self.on_disk = self.path.as_deref().and_then(|p| library::stat(p).ok());
+    }
+
+    pub fn images_lost_saving_to(&self, path: &str) -> Option<usize> {
+        self.images_left_in_file.as_ref().filter(|(file, _)| file_access::same_file(file, path)).map(|(_, count)| *count)
+    }
+
+    /// The selected ruler guide (its owner and index): it counts while no layer is selected and it
+    /// is still there on this page.
+    pub fn selected_guide(&self) -> Option<(NodeId, usize)> {
+        let (owner, i) = self.guide.filter(|_| self.selection.is_empty())?;
+        let on_page = owner == self.page || self.doc.top_level_frame(owner).is_some_and(|f| self.doc.ancestors(f).contains(&self.page));
+        (on_page && guides::keeps_guides(&self.doc, owner) && self.doc.node(owner).is_some_and(|n| i < n.guides().len())).then_some((owner, i))
+    }
+
+    /// With the version history read from its file.
+    pub fn with_versions(mut self, versions: Vec<figcraft_format::Version>) -> Self {
+        self.versions = versions;
+        self
+    }
+
+    /// With the branches read from its file.
+    pub fn with_branches(mut self, branches: Vec<figcraft_format::Branch>) -> Self {
+        self.branches = branches;
+        self
+    }
+
+    /// The branches, for editing (the file then has unsaved changes).
+    pub fn branches_mut(&mut self) -> &mut Vec<figcraft_format::Branch> {
+        self.versions_changed = true;
+        &mut self.branches
+    }
+
+    /// The document itself, not a version or live text preview shown in its place.
+    pub fn document_itself(&self) -> &Arc<Document> {
+        self.preview.as_ref().map(|p| &p.doc).or(self.text_preview.as_ref()).unwrap_or(&self.doc)
+    }
+
+    /// The version history, for editing (the file then has unsaved changes).
+    pub fn versions_mut(&mut self) -> &mut Vec<figcraft_format::Version> {
+        self.versions_changed = true;
+        &mut self.versions
+    }
+
+    /// The document changed since the last version was saved or restored (always, before one).
+    pub fn changed_since_checkpoint(&self) -> bool {
+        let doc = self.preview.as_ref().map_or(&self.doc, |p| &p.doc);
+        // Normalising after a command can copy a document without changing it: compare contents then.
+        self.checkpoint.as_ref().is_none_or(|c| !Arc::ptr_eq(doc, c) && **doc != **c)
+    }
+
+    /// Note that a version of the current document was just saved (or restored).
+    pub(crate) fn mark_checkpoint(&mut self) {
+        self.checkpoint = Some(self.doc.clone());
+    }
+
+    /// Push a snapshot undo step: the document was `before` (shown with `selection` on `page`).
+    pub(crate) fn push_undo(&mut self, label: &str, before: Arc<Document>, selection: Vec<NodeId>, page: NodeId) {
+        self.history.undo.push(HistoryEntry { label: label.to_string(), doc: before, selection, page });
+        if self.history.undo.len() > self.history.limit.max(1) {
+            self.history.undo.remove(0);
+        }
+        self.history.redo.clear();
+    }
+
+    pub fn is_dirty(&self) -> bool {
+        !Arc::ptr_eq(self.document_itself(), &self.saved_doc) || self.versions_changed
+    }
+
+    /// Show `version` in place of the document (or switch to it from another preview).
+    pub fn start_preview(&mut self, id: &str, name: &str, time: u64, doc: Arc<Document>) {
+        self.end_preview();
+        self.preview = Some(VersionPreview {
+            id: id.to_string(),
+            name: name.to_string(),
+            time,
+            doc: std::mem::replace(&mut self.doc, doc),
+            selection: std::mem::take(&mut self.selection),
+            page: self.page,
+        });
+        self.page = Some(self.page)
+            .filter(|pg| self.doc.pages.contains(pg))
+            .or_else(|| self.doc.current_page.filter(|pg| self.doc.pages.contains(pg)))
+            .or_else(|| self.doc.first_page())
+            .unwrap_or(self.page);
+        self.text_edit = None;
+        self.vector_edit = None;
+        self.interaction = None;
+        self.revision += 1;
+    }
+
+    /// End a version preview, putting the document, selection and page back. False when none.
+    pub fn end_preview(&mut self) -> bool {
+        let Some(p) = self.preview.take() else { return false };
+        self.doc = p.doc;
+        self.selection = p.selection;
+        self.page = p.page;
+        self.text_edit = None;
+        self.vector_edit = None;
+        self.interaction = None;
+        self.clean_selection();
+        self.revision += 1;
+        true
+    }
+
+    /// Shown as having unsaved changes until it is saved (a document recovered after a crash).
+    pub fn unsaved(mut self) -> Self {
+        self.saved_doc = Arc::new(Document::new(self.doc.name.clone()));
+        self
+    }
+
+    pub fn mark_saved(&mut self) {
+        self.saved_doc = self.doc.clone();
+        self.versions_changed = false;
+    }
+
+    pub fn doc_mut(&mut self) -> &mut Document {
+        Arc::make_mut(&mut self.doc)
+    }
+
+    /// Fit the current page's content (or centre on the origin when empty).
+    pub fn zoom_to_fit(&mut self) {
+        match self.doc.page_content_bounds(self.page) {
+            Some(b) => self.view.fit(b, 1.0),
+            None => {
+                self.view.zoom = 1.0;
+                self.view.cx = self.view.vw / 2.0 - 100.0;
+                self.view.cy = self.view.vh / 2.0 - 100.0;
+            }
+        }
+    }
+
+    /// The layer the focus view shows, while it exists on the current page.
+    pub fn focused(&self) -> Option<NodeId> {
+        self.focus.filter(|f| self.doc.page_of(*f) == Some(self.page))
+    }
+
+    /// Drop selected ids that no longer exist or aren't on the current page.
+    pub fn clean_selection(&mut self) {
+        let doc = self.doc.clone();
+        let page = self.page;
+        self.selection.retain(|id| doc.contains(*id) && doc.page_of(*id) == Some(page) && *id != page);
+        let mut seen = BTreeSet::new();
+        self.selection.retain(|id| seen.insert(*id));
+        if let Some(te) = &self.text_edit
+            && !doc.contains(te.id)
+        {
+            self.text_edit = None;
+        }
+        // Vector edit mode ends when its layer is gone (or no longer a vector, e.g. undone).
+        if self.vector_edit.as_mut().is_some_and(|ve| doc.page_of(ve.id) != Some(page) || !ve.clamp_doc(&doc)) {
+            self.vector_edit = None;
+        }
+        // A moved rotation origin lasts as long as its selection.
+        if self.rotation_origin.as_ref().is_some_and(|o| o.ids != self.selection) {
+            self.rotation_origin = None;
+        }
+        // So does the last duplicate (undo reuses ids: a new layer could take a copy's).
+        if self.last_duplicate.as_ref().is_some_and(|d| !d.is_selection(&self.selection)) {
+            self.last_duplicate = None;
+        }
+    }
+}
diff --git a/crates/engine/src/error.rs b/crates/engine/src/error.rs
new file mode 100644
index 00000000..7f2ab1d4
--- /dev/null
+++ b/crates/engine/src/error.rs
@@ -0,0 +1,51 @@
+use super::*;
+
+#[derive(Debug, thiserror::Error)]
+pub enum EngineError {
+    #[error("unknown command `{0}`")]
+    UnknownCommand(String),
+    #[error("command `{0}` is not available right now: {1}")]
+    Disabled(String, String),
+    #[error("invalid parameters for `{cmd}`: {msg}")]
+    BadParams { cmd: String, msg: String },
+    #[error("no open document")]
+    NoDocument,
+    #[error("no such node {0}")]
+    NoNode(NodeId),
+    #[error("{0}")]
+    Other(String),
+    /// A command run in the background sent a request to a server and runs again with the answer
+    /// ([`background`]); never returned to other callers.
+    #[error("waiting for the server")]
+    Waiting,
+    /// A bug: the command panicked. The document was rolled back.
+    #[error("internal error in `{cmd}`: {msg} (the document was left as it was before; please report this bug)")]
+    Internal { cmd: String, msg: String },
+}
+
+impl From<figcraft_doc::DocError> for EngineError {
+    fn from(e: figcraft_doc::DocError) -> Self {
+        match e {
+            figcraft_doc::DocError::NoNode(id) => EngineError::NoNode(id),
+            other => EngineError::Other(other.to_string()),
+        }
+    }
+}
+
+impl EngineError {
+    /// This error from step `step` of a batch, saying so in its message; the kind stays (errors
+    /// without a message stay as they are).
+    pub(crate) fn at_step(self, step: usize) -> Self {
+        match self {
+            EngineError::BadParams { cmd, msg } => EngineError::BadParams { cmd, msg: format!("step {step}: {msg}") },
+            EngineError::Other(msg) => EngineError::Other(format!("step {step}: {msg}")),
+            e => e,
+        }
+    }
+}
+
+pub type Result<T> = std::result::Result<T, EngineError>;
+
+pub fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
+    EngineError::BadParams { cmd: cmd.to_string(), msg: msg.into() }
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 9910e027..60f240cb 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -96,715 +96,18 @@ use figcraft_doc::{Document, Node, NodeId};
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 
-#[derive(Debug, thiserror::Error)]
-pub enum EngineError {
-    #[error("unknown command `{0}`")]
-    UnknownCommand(String),
-    #[error("command `{0}` is not available right now: {1}")]
-    Disabled(String, String),
-    #[error("invalid parameters for `{cmd}`: {msg}")]
-    BadParams { cmd: String, msg: String },
-    #[error("no open document")]
-    NoDocument,
-    #[error("no such node {0}")]
-    NoNode(NodeId),
-    #[error("{0}")]
-    Other(String),
-    /// A command run in the background sent a request to a server and runs again with the answer
-    /// ([`background`]); never returned to other callers.
-    #[error("waiting for the server")]
-    Waiting,
-    /// A bug: the command panicked. The document was rolled back.
-    #[error("internal error in `{cmd}`: {msg} (the document was left as it was before; please report this bug)")]
-    Internal { cmd: String, msg: String },
-}
+mod derived;
+mod doc_state;
+mod error;
+mod prefs;
+mod session;
+mod view_state;
 
-impl From<figcraft_doc::DocError> for EngineError {
-    fn from(e: figcraft_doc::DocError) -> Self {
-        match e {
-            figcraft_doc::DocError::NoNode(id) => EngineError::NoNode(id),
-            other => EngineError::Other(other.to_string()),
-        }
-    }
-}
-
-impl EngineError {
-    /// This error from step `step` of a batch, saying so in its message; the kind stays (errors
-    /// without a message stay as they are).
-    fn at_step(self, step: usize) -> Self {
-        match self {
-            EngineError::BadParams { cmd, msg } => EngineError::BadParams { cmd, msg: format!("step {step}: {msg}") },
-            EngineError::Other(msg) => EngineError::Other(format!("step {step}: {msg}")),
-            e => e,
-        }
-    }
-}
-
-pub type Result<T> = std::result::Result<T, EngineError>;
-
-pub fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
-    EngineError::BadParams { cmd: cmd.to_string(), msg: msg.into() }
-}
-
-/// One undo step.
-#[derive(Clone, Debug)]
-pub struct HistoryEntry {
-    pub label: String,
-    pub doc: Arc<Document>,
-    pub selection: Vec<NodeId>,
-    pub page: NodeId,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct History {
-    pub undo: Vec<HistoryEntry>,
-    pub redo: Vec<HistoryEntry>,
-    pub limit: usize,
-}
-
-/// The canvas view of a document: what's at the centre of the viewport and the zoom.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(default)]
-pub struct ViewState {
-    /// Page coordinate at the viewport centre.
-    pub cx: f64,
-    pub cy: f64,
-    /// Zoom (1 = 100%).
-    pub zoom: f64,
-    /// Viewport size in logical pixels (set by the UI; used by zoom-to-fit).
-    pub vw: f64,
-    pub vh: f64,
-    pub pixel_grid: bool,
-    pub layout_grids: bool,
-    pub rulers: bool,
-    pub outlines: bool,
-    /// Outline mode for the selected layers only (the rest draws normally).
-    pub outlines_selection: bool,
-    /// Outline mode also outlines hidden layers (View ▸ Outlines ▸ Include hidden layers).
-    pub outline_hidden: bool,
-    /// Outline mode also draws every layer's box (View ▸ Outlines ▸ Include object bounds).
-    pub outline_bounds: bool,
-    /// Outline the masks (they don't draw themselves).
-    pub mask_outlines: bool,
-    pub pixel_preview: bool,
-    /// Pixel preview resolution: rendered pixels per page pixel (1 or 2).
-    pub pixel_scale: u8,
-    pub show_slices: bool,
-    pub comments: bool,
-    /// Others' cursors in a live session (View ▸ Multiplayer cursors).
-    pub multiplayer_cursors: bool,
-    pub frame_outlines: bool,
-    /// Soft-proof sRGB: the canvas marks the colours of a Display P3 file that sRGB can't show.
-    pub proof_srgb: bool,
-    pub snap_geometry: bool,
-    pub snap_objects: bool,
-    pub snap_pixel: bool,
-    pub ui_hidden: bool,
-}
-
-impl Default for ViewState {
-    fn default() -> Self {
-        Self {
-            cx: 0.0,
-            cy: 0.0,
-            zoom: 1.0,
-            vw: 1200.0,
-            vh: 800.0,
-            pixel_grid: true,
-            layout_grids: true,
-            rulers: false,
-            outlines: false,
-            outlines_selection: false,
-            outline_hidden: false,
-            outline_bounds: false,
-            mask_outlines: false,
-            pixel_preview: false,
-            pixel_scale: 1,
-            show_slices: false,
-            comments: true,
-            multiplayer_cursors: true,
-            frame_outlines: false,
-            proof_srgb: false,
-            snap_geometry: true,
-            snap_objects: true,
-            snap_pixel: true,
-            ui_hidden: false,
-        }
-    }
-}
-
-impl ViewState {
-    pub const MIN_ZOOM: f64 = 0.02;
-    pub const MAX_ZOOM: f64 = 256.0;
-    /// Page coordinate at the viewport's top-left.
-    pub fn origin(&self) -> (f64, f64) {
-        let z = self.zoom.max(1e-9);
-        (self.cx - self.vw / 2.0 / z, self.cy - self.vh / 2.0 / z)
-    }
-    pub fn set_zoom_at(&mut self, zoom: f64, anchor: (f64, f64)) {
-        let z = if zoom.is_finite() { zoom.clamp(Self::MIN_ZOOM, Self::MAX_ZOOM) } else { self.zoom };
-        let old = self.zoom.max(1e-9);
-        // Keep the page point under `anchor` fixed.
-        self.cx = anchor.0 + (self.cx - anchor.0) * old / z;
-        self.cy = anchor.1 + (self.cy - anchor.1) * old / z;
-        self.zoom = z;
-    }
-    /// Fit a page rectangle into the viewport with margin.
-    pub fn fit(&mut self, r: figcraft_geom::Rect, max_zoom: f64) {
-        if !(r.width() > 0.0 || r.height() > 0.0) || !r.x0.is_finite() {
-            self.cx = r.center().x;
-            self.cy = r.center().y;
-            return;
-        }
-        let margin = 64.0;
-        let zx = (self.vw - margin * 2.0).max(50.0) / r.width().max(1e-6);
-        let zy = (self.vh - margin * 2.0).max(50.0) / r.height().max(1e-6);
-        self.zoom = zx.min(zy).clamp(Self::MIN_ZOOM, max_zoom);
-        self.cx = r.center().x;
-        self.cy = r.center().y;
-    }
-    /// The zoom from which the pixel grid shows (400%).
-    pub const PIXEL_GRID_ZOOM: f64 = 4.0;
-    /// Whether the pixel grid draws: it's on and the canvas is zoomed in to 400% or more.
-    pub fn pixel_grid_shown(&self) -> bool {
-        self.pixel_grid && self.zoom >= Self::PIXEL_GRID_ZOOM - 1e-9
-    }
-    /// Pixel preview's resolution (rendered pixels per page pixel) when it's on and zoomed in past
-    /// it; below that the canvas is already coarser than the preview.
-    pub fn pixel_preview_scale(&self) -> Option<f64> {
-        let k = f64::from(self.pixel_scale.clamp(1, 2));
-        (self.pixel_preview && self.zoom > k).then_some(k)
-    }
-    /// A wheel or trackpad scroll of (`dx`, `dy`) screen points: the canvas pans with it (content
-    /// follows the fingers); with Shift a plain vertical wheel pans sideways.
-    pub fn scroll(&mut self, dx: f64, dy: f64, shift: bool) {
-        let (dx, dy) = if shift && dx == 0.0 { (dy, 0.0) } else { (dx, dy) };
-        if !(dx.is_finite() && dy.is_finite()) {
-            return;
-        }
-        let z = self.zoom.max(1e-6);
-        self.cx -= dx / z;
-        self.cy -= dy / z;
-    }
-    pub fn page_to_screen(&self, x: f64, y: f64) -> (f64, f64) {
-        let (ox, oy) = self.origin();
-        ((x - ox) * self.zoom, (y - oy) * self.zoom)
-    }
-    pub fn screen_to_page(&self, x: f64, y: f64) -> (f64, f64) {
-        let (ox, oy) = self.origin();
-        let z = self.zoom.max(1e-9);
-        (ox + x / z, oy + y / z)
-    }
-}
-
-/// An in-progress gesture: the document before it started, so previews re-apply from scratch.
-#[derive(Clone, Debug)]
-pub struct Interaction {
-    pub label: String,
-    pub doc: Arc<Document>,
-    pub selection: Vec<NodeId>,
-}
-
-/// The text being edited on the canvas.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct TextEdit {
-    pub id: NodeId,
-    /// Caret position and selection anchor (char indices).
-    pub caret: usize,
-    pub anchor: usize,
-    /// The node was created by this edit (deleted if left empty).
-    pub created: bool,
-    /// Identity of this editing session (`textedit::begin` assigns a fresh one).
-    ///
-    /// The IME owner is `(document uid, node)`, which stays the same through ordinary edits
-    /// and caret moves; this token changes only when editing is started again, so an IME
-    /// context is never silently inherited by a replaced target that reuses the same node.
-    ///
-    /// It is deliberately not serialized: current consumers only inspect a live session. A
-    /// serialized `TextEdit` restored from data would get zero here, so it must not be restored
-    /// into a live editor without minting (or otherwise invalidating) a new session.
-    #[serde(default, skip_serializing)]
-    pub editing_session: u64,
-    /// An IME composition in progress, shown inline at the caret; the document gets it on commit.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub preedit: Option<Preedit>,
-}
-
-/// IME composition text (not yet in the document) and the IME's cursor inside it (chars).
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Preedit {
-    pub text: String,
-    pub cursor: usize,
-}
-
-/// Per-document editing state.
-#[derive(Clone, Debug)]
-pub struct DocState {
-    pub doc: Arc<Document>,
-    pub selection: Vec<NodeId>,
-    pub page: NodeId,
-    pub history: History,
-    saved_doc: Arc<Document>,
-    pub path: Option<String>,
-    pub revision: u64,
-    pub view: ViewState,
-    pub interaction: Option<Interaction>,
-    pub text_edit: Option<TextEdit>,
-    /// Hovered node (canvas hover outline).
-    pub hover: Option<NodeId>,
-    /// Vector edit mode: the vector being edited, its selected points and the edit tool.
-    pub vector_edit: Option<vectoredit::VectorEdit>,
-    pub uid: u64,
-    /// The file's version history, oldest first (saved in the `.figcraft` file; not undoable).
-    pub versions: Vec<figcraft_format::Version>,
-    /// The file's branches (saved in the `.figcraft` file; not undoable).
-    pub branches: Vec<figcraft_format::Branch>,
-    /// This tab shows a branch: the `uid` of its main file's tab and the branch id. Its edits go
-    /// into the main file's branch (and are saved with the main file).
-    pub branch_of: Option<(u64, String)>,
-    /// The version history or the branches changed since the last save.
-    versions_changed: bool,
-    /// A version shown in place of the document (read-only).
-    pub preview: Option<VersionPreview>,
-    /// The document under a live text preview (a hovered font family or style, text style or
-    /// font instance, a dragged axis slider): `doc` shows the preview until [`textpreview::end`] puts this back.
-    pub text_preview: Option<Arc<Document>>,
-    /// The document as of the last version saved or restored (none yet): autosaves, restores and
-    /// merges only add a checkpoint for changes since.
-    checkpoint: Option<Arc<Document>>,
-    /// Dev Mode focus view: the frame or section shown alone on the canvas (see [`Self::focused`]).
-    pub focus: Option<NodeId>,
-    /// The ruler guide clicked last: its page or frame and index (see [`Self::selected_guide`]).
-    pub guide: Option<(NodeId, usize)>,
-    /// The selection's rotation origin, when moved or shown (see [`rotation_origin`]; not saved).
-    pub(crate) rotation_origin: Option<rotation_origin::RotationOrigin>,
-    /// The View toggles the preferences keep were applied ([`Session::apply_view_prefs`]).
-    view_from_prefs: bool,
-    /// The last duplicate while its copies are the selection: Duplicate repeats its offset (see
-    /// [`cmd::edit::Duplicated`]; not saved).
-    pub(crate) last_duplicate: Option<cmd::edit::Duplicated>,
-    images_left_in_file: Option<(String, usize)>,
-    /// The file on disk as this tab last read or wrote it: a save refuses to replace what another
-    /// app (figcraft-cli, say) wrote to it since (#1330).
-    on_disk: Option<library::Stamp>,
-}
-
-/// A version shown on the canvas in place of the document: read-only until it's restored or the
-/// preview ends, which puts the document back as it was.
-#[derive(Clone, Debug)]
-pub struct VersionPreview {
-    pub id: String,
-    pub name: String,
-    /// When the version was saved (Unix seconds).
-    pub time: u64,
-    doc: Arc<Document>,
-    selection: Vec<NodeId>,
-    page: NodeId,
-}
-
-/// Why edits are refused while a version is shown.
-pub const PREVIEW_READ_ONLY: &str = "you're viewing an earlier version: restore it or go back to the current version to edit";
-
-/// Commands that first end a version preview: they act on the document itself. Saving does so
-/// only with a native destination; export copies and pending format choices keep the preview.
-const ENDS_PREVIEW: &[&str] =
-    &["file.save", "file.saveAs", "file.markSaved", "file.close", "file.revert", "file.saveVersion", "file.duplicate", "version.restore"];
-
-static NEXT_UID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
-
-impl DocState {
-    pub fn new(mut doc: Document, path: Option<String>) -> Self {
-        if doc.pages.is_empty() {
-            doc.repair();
-        }
-        doc.link_layer_text_styles();
-        cmd::styles::apply_paint_bindings_on_load(&mut doc);
-        components::mark_layer_modes(&mut doc);
-        // Initial import settlement belongs to the saved baseline, not the user's first edit.
-        let page = doc.current_page.filter(|p| doc.pages.contains(p)).or_else(|| doc.first_page()).unwrap_or(NodeId(0));
-        let doc = Arc::new(doc);
-        let mut st = Self {
-            checkpoint: None,
-            saved_doc: doc.clone(),
-            doc,
-            selection: Vec::new(),
-            page,
-            history: History { limit: 1000, ..Default::default() },
-            path,
-            revision: 1,
-            view: ViewState::default(),
-            interaction: None,
-            text_edit: None,
-            hover: None,
-            vector_edit: None,
-            uid: NEXT_UID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
-            versions: Vec::new(),
-            branches: Vec::new(),
-            branch_of: None,
-            versions_changed: false,
-            preview: None,
-            text_preview: None,
-            focus: None,
-            guide: None,
-            rotation_origin: None,
-            view_from_prefs: false,
-            last_duplicate: None,
-            images_left_in_file: None,
-            on_disk: None,
-        };
-        st.zoom_to_fit();
-        st
-    }
-
-    pub fn with_images_left_in_file(mut self, path: &str, count: usize) -> Self {
-        self.images_left_in_file = (count > 0).then(|| (path.to_string(), count));
-        self
-    }
-
-    /// The tab's file now holds what this tab read or wrote.
-    pub(crate) fn note_on_disk(&mut self) {
-        self.on_disk = self.path.as_deref().and_then(|p| library::stat(p).ok());
-    }
-
-    pub fn images_lost_saving_to(&self, path: &str) -> Option<usize> {
-        self.images_left_in_file.as_ref().filter(|(file, _)| file_access::same_file(file, path)).map(|(_, count)| *count)
-    }
-
-    /// The selected ruler guide (its owner and index): it counts while no layer is selected and it
-    /// is still there on this page.
-    pub fn selected_guide(&self) -> Option<(NodeId, usize)> {
-        let (owner, i) = self.guide.filter(|_| self.selection.is_empty())?;
-        let on_page = owner == self.page || self.doc.top_level_frame(owner).is_some_and(|f| self.doc.ancestors(f).contains(&self.page));
-        (on_page && guides::keeps_guides(&self.doc, owner) && self.doc.node(owner).is_some_and(|n| i < n.guides().len())).then_some((owner, i))
-    }
-
-    /// With the version history read from its file.
-    pub fn with_versions(mut self, versions: Vec<figcraft_format::Version>) -> Self {
-        self.versions = versions;
-        self
-    }
-
-    /// With the branches read from its file.
-    pub fn with_branches(mut self, branches: Vec<figcraft_format::Branch>) -> Self {
-        self.branches = branches;
-        self
-    }
-
-    /// The branches, for editing (the file then has unsaved changes).
-    pub fn branches_mut(&mut self) -> &mut Vec<figcraft_format::Branch> {
-        self.versions_changed = true;
-        &mut self.branches
-    }
-
-    /// The document itself, not a version or live text preview shown in its place.
-    pub fn document_itself(&self) -> &Arc<Document> {
-        self.preview.as_ref().map(|p| &p.doc).or(self.text_preview.as_ref()).unwrap_or(&self.doc)
-    }
-
-    /// The version history, for editing (the file then has unsaved changes).
-    pub fn versions_mut(&mut self) -> &mut Vec<figcraft_format::Version> {
-        self.versions_changed = true;
-        &mut self.versions
-    }
-
-    /// The document changed since the last version was saved or restored (always, before one).
-    pub fn changed_since_checkpoint(&self) -> bool {
-        let doc = self.preview.as_ref().map_or(&self.doc, |p| &p.doc);
-        // Normalising after a command can copy a document without changing it: compare contents then.
-        self.checkpoint.as_ref().is_none_or(|c| !Arc::ptr_eq(doc, c) && **doc != **c)
-    }
-
-    /// Note that a version of the current document was just saved (or restored).
-    pub(crate) fn mark_checkpoint(&mut self) {
-        self.checkpoint = Some(self.doc.clone());
-    }
-
-    /// Push a snapshot undo step: the document was `before` (shown with `selection` on `page`).
-    pub(crate) fn push_undo(&mut self, label: &str, before: Arc<Document>, selection: Vec<NodeId>, page: NodeId) {
-        self.history.undo.push(HistoryEntry { label: label.to_string(), doc: before, selection, page });
-        if self.history.undo.len() > self.history.limit.max(1) {
-            self.history.undo.remove(0);
-        }
-        self.history.redo.clear();
-    }
-
-    pub fn is_dirty(&self) -> bool {
-        !Arc::ptr_eq(self.document_itself(), &self.saved_doc) || self.versions_changed
-    }
-
-    /// Show `version` in place of the document (or switch to it from another preview).
-    pub fn start_preview(&mut self, id: &str, name: &str, time: u64, doc: Arc<Document>) {
-        self.end_preview();
-        self.preview = Some(VersionPreview {
-            id: id.to_string(),
-            name: name.to_string(),
-            time,
-            doc: std::mem::replace(&mut self.doc, doc),
-            selection: std::mem::take(&mut self.selection),
-            page: self.page,
-        });
-        self.page = Some(self.page)
-            .filter(|pg| self.doc.pages.contains(pg))
-            .or_else(|| self.doc.current_page.filter(|pg| self.doc.pages.contains(pg)))
-            .or_else(|| self.doc.first_page())
-            .unwrap_or(self.page);
-        self.text_edit = None;
-        self.vector_edit = None;
-        self.interaction = None;
-        self.revision += 1;
-    }
-
-    /// End a version preview, putting the document, selection and page back. False when none.
-    pub fn end_preview(&mut self) -> bool {
-        let Some(p) = self.preview.take() else { return false };
-        self.doc = p.doc;
-        self.selection = p.selection;
-        self.page = p.page;
-        self.text_edit = None;
-        self.vector_edit = None;
-        self.interaction = None;
-        self.clean_selection();
-        self.revision += 1;
-        true
-    }
-
-    /// Shown as having unsaved changes until it is saved (a document recovered after a crash).
-    pub fn unsaved(mut self) -> Self {
-        self.saved_doc = Arc::new(Document::new(self.doc.name.clone()));
-        self
-    }
-
-    pub fn mark_saved(&mut self) {
-        self.saved_doc = self.doc.clone();
-        self.versions_changed = false;
-    }
-
-    pub fn doc_mut(&mut self) -> &mut Document {
-        Arc::make_mut(&mut self.doc)
-    }
-
-    /// Fit the current page's content (or centre on the origin when empty).
-    pub fn zoom_to_fit(&mut self) {
-        match self.doc.page_content_bounds(self.page) {
-            Some(b) => self.view.fit(b, 1.0),
-            None => {
-                self.view.zoom = 1.0;
-                self.view.cx = self.view.vw / 2.0 - 100.0;
-                self.view.cy = self.view.vh / 2.0 - 100.0;
-            }
-        }
-    }
-
-    /// The layer the focus view shows, while it exists on the current page.
-    pub fn focused(&self) -> Option<NodeId> {
-        self.focus.filter(|f| self.doc.page_of(*f) == Some(self.page))
-    }
-
-    /// Drop selected ids that no longer exist or aren't on the current page.
-    pub fn clean_selection(&mut self) {
-        let doc = self.doc.clone();
-        let page = self.page;
-        self.selection.retain(|id| doc.contains(*id) && doc.page_of(*id) == Some(page) && *id != page);
-        let mut seen = BTreeSet::new();
-        self.selection.retain(|id| seen.insert(*id));
-        if let Some(te) = &self.text_edit
-            && !doc.contains(te.id)
-        {
-            self.text_edit = None;
-        }
-        // Vector edit mode ends when its layer is gone (or no longer a vector, e.g. undone).
-        if self.vector_edit.as_mut().is_some_and(|ve| doc.page_of(ve.id) != Some(page) || !ve.clamp_doc(&doc)) {
-            self.vector_edit = None;
-        }
-        // A moved rotation origin lasts as long as its selection.
-        if self.rotation_origin.as_ref().is_some_and(|o| o.ids != self.selection) {
-            self.rotation_origin = None;
-        }
-        // So does the last duplicate (undo reuses ids: a new layer could take a copy's).
-        if self.last_duplicate.as_ref().is_some_and(|d| !d.is_selection(&self.selection)) {
-            self.last_duplicate = None;
-        }
-    }
-}
-
-/// The smallest and largest interface size, relative to the system's display scale (1.0 is the
-/// system's own size).
-pub const UI_SCALE_MIN: f64 = 0.75;
-pub const UI_SCALE_MAX: f64 = 3.0;
-
-/// `scale` kept between [`UI_SCALE_MIN`] and [`UI_SCALE_MAX`]; not a finite number: `None`.
-pub fn clamp_ui_scale(scale: f64) -> Option<f64> {
-    scale.is_finite().then(|| scale.clamp(UI_SCALE_MIN, UI_SCALE_MAX))
-}
-
-/// Reads the saved interface size. Anything but a number reads as 1 (the system's size) and a
-/// number out of range is clamped, so a settings file edited by hand never costs the other
-/// preferences.
-fn read_ui_scale<'de, D: serde::Deserializer<'de>>(d: D) -> std::result::Result<f64, D::Error> {
-    Ok(Value::deserialize(d)?.as_f64().and_then(clamp_ui_scale).unwrap_or(1.0))
-}
-
-/// App-wide preferences that commands read (nudge amounts, behaviours).
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(default)]
-pub struct Prefs {
-    pub nudge_small: f64,
-    pub nudge_big: f64,
-    pub keep_tool: bool,
-    pub rename_duplicates: bool,
-    pub highlight_on_hover: bool,
-    pub number_keys_opacity: bool,
-    pub show_dimensions: bool,
-    /// "system" by default; an explicit "light" or "dark" choice stays saved.
-    pub theme: String,
-    /// The widths of the main window's left and right panels (the interface keeps them within its
-    /// limits; other windows have their own while they are open).
-    pub panel_widths: (f32, f32),
-    /// The height asked for the main window's pages list, dragged at its lower edge (`None`: a
-    /// share of the panel; the interface keeps it within its limits).
-    pub pages_height: Option<f32>,
-    /// The interface language: a language code ("en", "es", "pt-BR") or "system" (the OS or browser
-    /// language). Languages without a catalog show English.
-    pub language: String,
-    /// The name comments are signed with (and whose comments count as yours).
-    pub user_name: String,
-    /// Reduce motion: the interface's own animations are off (the system's setting turns them off
-    /// too). Prototype transitions still play.
-    pub reduce_motion: bool,
-    /// How large the whole interface is drawn, relative to the system's display scale: 1.0 is the
-    /// system's own size, 1.25 a quarter larger (kept between [`UI_SCALE_MIN`] and
-    /// [`UI_SCALE_MAX`]). The canvas zoom is separate.
-    #[serde(deserialize_with = "read_ui_scale")]
-    pub ui_scale: f64,
-    /// Files that have a path are saved by themselves a few seconds after they change (the app's
-    /// timer; off: only File ▸ Save writes them).
-    pub auto_save: bool,
-    /// The desktop app starts on the Home screen instead of in a new file.
-    pub start_on_home: bool,
-    /// `figcraft://` invite links open this app (`collab.registerLinks`); `None`: on for installed
-    /// builds, off for development builds.
-    pub invite_links: Option<bool>,
-    /// Installed plugins (Plugins menu), in menu order.
-    #[serde(serialize_with = "plugins::persisted")]
-    pub plugins: Vec<plugins::InstalledPlugin>,
-    /// Plugins' own settings (`setting_set`), by plugin id, then key: JSON values, capped per
-    /// plugin.
-    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
-    pub plugin_settings: BTreeMap<String, BTreeMap<String, Value>>,
-    /// The plugin directory browsed last (`ws://host:port/`, never with a key).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub plugin_directory: Option<String>,
-    /// The server files are shared through online (Share ▸ Online, join codes; Publish to server
-    /// suggests it too): `wss://host/`, never with a key. [`live::DEFAULT_SERVER`] unless the user
-    /// chose another; empty: online sharing is off (saved as empty, so it stays off).
-    pub publish_server: String,
-    /// Recently opened or saved files, newest first (File ▸ Open recent; at most
-    /// [`cmd::file::MAX_RECENT`]).
-    pub recent_files: Vec<String>,
-    /// The files you put on a server without its key, with their owner tokens (passwords: see
-    /// [`online`]), most recently opened first, at most [`online::MAX_ONLINE_FILES`].
-    #[serde(skip_serializing_if = "Vec::is_empty", deserialize_with = "online::read")]
-    pub online_files: Vec<online::OnlineFile>,
-    /// The Getting started tips on the home screen were closed (Help ▸ Getting started shows them
-    /// again).
-    pub getting_started_dismissed: bool,
-    /// A prototype's Open link goes to a website without first telling the viewer that it leaves
-    /// the prototype (the notice's "Don't show this again"; `proto.linkNotice` shows it again).
-    pub link_notice_skipped: bool,
-    /// How each home screen section shows its files, by section id (`"recents"`): `"grid"` (cards
-    /// with the picture each file carries) or `"list"` (a table). Missing: the grid.
-    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
-    pub home_views: BTreeMap<String, String>,
-    /// What the home screen's recent files are ordered by: `"modified"`, `"name"` or `"created"`.
-    pub home_sort: String,
-    /// Which way: `"desc"` (newest first, Z to A) or `"asc"`.
-    pub home_order: String,
-    /// The View menu's toggles turned on or off (rulers, pixel grid, snapping…), by command id:
-    /// files opened or made later start with them. Missing: the toggle's default.
-    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
-    pub view: BTreeMap<String, bool>,
-    /// Recently run actions (the Actions palette's Recents), newest first, at most
-    /// [`MAX_RECENT_ACTIONS`]. Entries are `command:<id>`, `plugin:<plugin>/<command>` or
-    /// `widget:<plugin>`.
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub recent_actions: Vec<String>,
-}
-
-/// Recently run actions kept for the Actions palette (newest first).
-pub const MAX_RECENT_ACTIONS: usize = 5;
-
-impl Default for Prefs {
-    fn default() -> Self {
-        Self {
-            nudge_small: 1.0,
-            nudge_big: 10.0,
-            keep_tool: false,
-            rename_duplicates: false,
-            highlight_on_hover: true,
-            number_keys_opacity: true,
-            show_dimensions: true,
-            theme: "system".into(),
-            panel_widths: (240.0, 240.0),
-            pages_height: None,
-            language: "system".into(),
-            user_name: cmd::comment::DEFAULT_AUTHOR.into(),
-            reduce_motion: false,
-            ui_scale: 1.0,
-            auto_save: false,
-            start_on_home: false,
-            invite_links: None,
-            plugins: Vec::new(),
-            plugin_settings: BTreeMap::new(),
-            plugin_directory: None,
-            publish_server: live::DEFAULT_SERVER.into(),
-            recent_files: Vec::new(),
-            online_files: Vec::new(),
-            getting_started_dismissed: false,
-            link_notice_skipped: false,
-            home_views: BTreeMap::new(),
-            home_sort: "modified".into(),
-            home_order: "desc".into(),
-            view: BTreeMap::new(),
-            recent_actions: Vec::new(),
-        }
-    }
-}
-
-/// A request from a command to the UI (open a dialog or panel, show a message). Programmatic
-/// callers ignore them.
-#[derive(Clone, Debug, PartialEq, Serialize)]
-pub struct UiRequest {
-    pub kind: String,
-    pub data: Value,
-}
-
-/// Clipboard contents (internal; the UI mirrors to the system clipboard).
-#[derive(Clone, Debug, Default)]
-pub struct Clipboard {
-    /// Copied subtrees: (root, nodes) in z-order.
-    pub nodes: Vec<(NodeId, Vec<figcraft_doc::Node>)>,
-    pub images: std::collections::BTreeMap<String, figcraft_doc::ImageData>,
-    /// Copied properties (Copy properties / Paste properties).
-    pub props: Option<Value>,
-    /// A copied fill or stroke row (`fill.copy`, `stroke.copy`): whether it's a fill, and the paint.
-    pub paint: Option<(bool, figcraft_color::Paint)>,
-    /// The stroke settings (`weight`, alignment, sides…) copied with a stroke's paint.
-    pub stroke: Option<figcraft_doc::StrokeProps>,
-    /// A copied effect row (`effect.copy`).
-    pub effect: Option<figcraft_doc::Effect>,
-    /// The page-space bounds of the copied selection.
-    pub bounds: Option<figcraft_geom::Rect>,
-    pub source_doc: u64,
-    /// Copied component/set roots, excluding cuts and originals discarded by undo (ids are reused).
-    pub copied_components: std::collections::BTreeSet<NodeId>,
-    /// Monotonic generation of the copied layers (contents, images, bounds and source). A UI
-    /// clipboard mirror records it, so a later programmatic copy that never touched the system
-    /// clipboard is not mistaken for the user's own copy just because the text still matches.
-    pub layers_generation: u64,
-    /// The document copied from (pastes into other files follow its mains) and its file path.
-    pub source: Option<Arc<Document>>,
-    pub source_path: Option<String>,
-}
+pub use derived::{changed_nodes, normalize};
+pub use doc_state::{DocState, History, HistoryEntry, Interaction, PREVIEW_READ_ONLY, Preedit, TextEdit, VersionPreview};
+pub use error::{EngineError, Result, bad};
+pub use prefs::{Clipboard, MAX_RECENT_ACTIONS, Prefs, UI_SCALE_MAX, UI_SCALE_MIN, UiRequest, clamp_ui_scale};
+pub use view_state::ViewState;
 
 /// The editing session: open documents, the current tool, clipboard and prefs.
 pub struct Session {
@@ -848,819 +151,6 @@ impl Default for Session {
     }
 }
 
-/// Whether a command, or a batch wrapping one, imports a file passed as Base64 `data`.
-fn command_carries_import_bytes(id: &str, params: &Value) -> bool {
-    match id {
-        "file.import" => params::get(params, "data").is_some(),
-        "command.batch" => params.get("commands").and_then(Value::as_array).is_some_and(|commands| {
-            commands.iter().any(|c| {
-                c.get("command").and_then(Value::as_str).zip(c.get("params")).is_some_and(|(id, params)| command_carries_import_bytes(id, params))
-            })
-        }),
-        _ => false,
-    }
-}
-
-impl Session {
-    /// A session with one new document.
-    pub fn new() -> Self {
-        let mut s = Self::empty();
-        s.docs.push(DocState::new(Document::new("Untitled"), None));
-        s
-    }
-
-    /// A session with no documents (the home screen).
-    pub fn empty() -> Self {
-        Self {
-            docs: Vec::new(),
-            active: 0,
-            clipboard: Clipboard::default(),
-            prefs: Prefs::default(),
-            tool: tools::ToolState::default(),
-            ui_requests: Vec::new(),
-            ui_dark: None,
-            journal: Vec::new(),
-            group_depth: 0,
-            closed_in_group: Vec::new(),
-            recent_colors: Vec::new(),
-            last_command: None,
-            message: None,
-            libraries: library::Cache::default(),
-            plugins: plugins::Runtime::default(),
-            live: live::Lives::default(),
-            background: background::Background::default(),
-        }
-    }
-
-    /// The background a new file's page gets: the dark page colour while the interface is dark.
-    pub fn new_page_background(&self) -> figcraft_color::Color {
-        if self.ui_dark == Some(true) { figcraft_color::Color::DARK_PAGE } else { figcraft_color::Color::DEFAULT_PAGE }
-    }
-
-    /// Tell the engine the interface's theme (the UI does, every frame). The first time, a new
-    /// file nothing was done to yet (the one the app opened with, made before the theme was
-    /// known) takes the theme's page colour; later changes of theme leave existing pages alone.
-    pub fn set_ui_dark(&mut self, dark: bool) {
-        if self.ui_dark.replace(dark).is_some() || !dark {
-            return;
-        }
-        for ds in &mut self.docs {
-            let untouched = ds.path.is_none() && ds.history.undo.is_empty() && ds.history.redo.is_empty() && !ds.is_dirty() && ds.versions.is_empty();
-            let pages = ds.doc.pages.clone();
-            let blank = pages.iter().all(|p| {
-                ds.doc.node(*p).is_some_and(|n| {
-                    n.children.is_empty()
-                        && matches!(n.kind, figcraft_doc::NodeKind::Page { background, .. } if background == figcraft_color::Color::DEFAULT_PAGE)
-                })
-            });
-            if !(untouched && blank) {
-                continue;
-            }
-            let mut doc = (*ds.doc).clone();
-            for p in pages {
-                if let Some(figcraft_doc::NodeKind::Page { background, .. }) = doc.node_mut(p).map(|n| &mut n.kind) {
-                    *background = figcraft_color::Color::DARK_PAGE;
-                }
-            }
-            // Still a file without changes.
-            ds.doc = Arc::new(doc);
-            ds.saved_doc = ds.doc.clone();
-            ds.revision += 1;
-        }
-    }
-
-    pub fn with_document(doc: Document) -> Self {
-        let mut s = Self::empty();
-        s.docs.push(DocState::new(doc, None));
-        s
-    }
-
-    /// Files new to the session start with the View toggles the preferences keep.
-    pub fn apply_view_prefs(&mut self) {
-        for ds in self.docs.iter_mut().filter(|d| !d.view_from_prefs) {
-            cmd::view::apply_kept(&self.prefs, &mut ds.view);
-            ds.view_from_prefs = true;
-        }
-    }
-
-    pub fn ds(&self) -> Result<&DocState> {
-        self.docs.get(self.active).ok_or(EngineError::NoDocument)
-    }
-
-    pub fn ds_mut(&mut self) -> Result<&mut DocState> {
-        self.docs.get_mut(self.active).ok_or(EngineError::NoDocument)
-    }
-
-    pub fn doc(&self) -> Result<&Document> {
-        Ok(self.ds()?.doc.as_ref())
-    }
-
-    pub fn doc_mut(&mut self) -> Result<&mut Document> {
-        Ok(self.ds_mut()?.doc_mut())
-    }
-
-    pub fn selection(&self) -> Vec<NodeId> {
-        self.ds().map(|d| d.selection.clone()).unwrap_or_default()
-    }
-
-    pub fn set_selection(&mut self, ids: Vec<NodeId>) {
-        if let Ok(ds) = self.ds_mut() {
-            ds.selection = ids;
-            ds.clean_selection();
-            ds.revision += 1;
-        }
-    }
-
-    pub fn page(&self) -> Result<NodeId> {
-        Ok(self.ds()?.page)
-    }
-
-    /// Run a command by id. Mutations become one undo step; a failure or panic leaves the document
-    /// as it was.
-    pub fn execute(&mut self, id: &str, params: &Value) -> Result<Value> {
-        let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
-        board::refuse_on_board(self, id)?;
-        // Revert replaces the document's uid: refuse before ending previews or syncing branches.
-        if id == "file.revert" && self.live().doc_uid.is_some() {
-            return Err(EngineError::Disabled(id.into(), "leave the live session before reverting to the saved file".into()));
-        }
-        branches::sync(self);
-        self.apply_view_prefs();
-        if textpreview::COMMANDS.contains(&id) {
-            // A live preview is no edit: no undo step, normalisation or rollback here.
-            let r = guard::run(id, || (spec.run)(self, params));
-            if r.is_err() {
-                textpreview::end(self);
-            }
-            return r;
-        }
-        // Every other command acts on the document itself, not on a live text preview.
-        textpreview::end(self);
-        if ENDS_PREVIEW.contains(&id)
-            && (!matches!(id, "file.save" | "file.saveAs") || cmd::file::save_ends_preview(self, id, params))
-            && let Ok(ds) = self.ds_mut()
-        {
-            ds.end_preview();
-        }
-        let before = self.ds().ok().map(|d| (d.doc.clone(), d.selection.clone(), d.page, d.uid));
-        // Cut and copy write the clipboard before a later check can refuse the command.
-        let clipboard_before = self.clipboard.clone();
-        let result = guard::run(id, || (spec.run)(self, params))
-            .and_then(|v| self.check_instance_structure(id, &before).map(|()| v))
-            .and_then(|v| self.check_preview(id, &before).map(|()| v))
-            .and_then(|v| self.check_live_access(id, &before).map(|()| v))
-            .and_then(|v| self.check_finite_geometry(id, &before).map(|()| v));
-        match &result {
-            Ok(_) => {
-                self.after_command(spec, before);
-                self.apply_view_prefs();
-                if spec.history && id != "edit.repeat" {
-                    self.last_command = Some((id.to_string(), params.clone()));
-                }
-                // Imported bytes already live in the document: a Base64 copy in the log would stay
-                // for the whole session.
-                if !command_carries_import_bytes(id, params) {
-                    self.journal.push((id.to_string(), params.clone()));
-                    if self.journal.len() > 5000 {
-                        self.journal.drain(..1000);
-                    }
-                }
-            }
-            Err(_) => {
-                // Roll back any partial edit — also during an interaction, where `before` is the
-                // interaction's last valid preview: restore it and leave the gesture itself (its
-                // own snapshot) alone.
-                if let Some((doc, sel, page, uid)) = before
-                    && let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid)
-                {
-                    ds.doc = doc;
-                    ds.selection = sel;
-                    ds.page = page;
-                }
-                self.clipboard = clipboard_before;
-            }
-        }
-        result
-    }
-
-    /// A version shown in place of the document is read-only: refuse an edit (it is rolled back).
-    fn check_preview(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
-        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
-        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
-        if ds.preview.is_none() || Arc::ptr_eq(&ds.doc, bdoc) || id == "version.preview" {
-            return Ok(());
-        }
-        Err(EngineError::Disabled(id.to_string(), PREVIEW_READ_ONLY.into()))
-    }
-
-    /// A layer's position and size stay finite: infinity and NaN are written as `null`, so a file
-    /// holding them saves but can't be reopened. Refuse such an edit (it is rolled back).
-    fn check_finite_geometry(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
-        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
-        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
-        if Arc::ptr_eq(&ds.doc, bdoc) {
-            return Ok(());
-        }
-        let broken = |n: &Node| !(n.transform.as_coeffs().iter().all(|c| c.is_finite()) && n.width.is_finite() && n.height.is_finite());
-        let untouched = |n: &Node| bdoc.node_arc(n.id).zip(ds.doc.node_arc(n.id)).is_some_and(|(a, b)| Arc::ptr_eq(a, b));
-        match ds.doc.nodes().find(|n| broken(n) && !untouched(n)) {
-            Some(n) => Err(bad(id, format!("\"{}\" would get a position or size beyond the number range", n.name))),
-            None => Ok(()),
-        }
-    }
-
-    /// A live session's document you may only view (or that is on its way to a server) is
-    /// read-only: refuse an edit (it is rolled back).
-    fn check_live_access(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
-        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
-        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
-        match self.live_read_only(*uid) {
-            Some(why) if !Arc::ptr_eq(&ds.doc, bdoc) => Err(EngineError::Disabled(id.to_string(), why.into())),
-            _ => Ok(()),
-        }
-    }
-
-    /// Instances can't gain, lose or reorder layers, nor move, resize or re-constrain the layers in
-    /// them, and library copies are read-only: refuse such an edit (it is rolled back).
-    fn check_instance_structure(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
-        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
-        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
-        if Arc::ptr_eq(&ds.doc, bdoc) {
-            return Ok(());
-        }
-        // "Repeat" runs the repeated command.
-        let effective = match (&self.last_command, id) {
-            (Some((last, _)), "edit.repeat") => last.as_str(),
-            _ => id,
-        };
-        library::check_read_only(effective, bdoc, &ds.doc)
-            .and_then(|()| components::check_structure_edit(bdoc, &ds.doc))
-            .and_then(|()| components::check_override_edit(bdoc, &ds.doc))
-            .map_err(|m| EngineError::Disabled(id.to_string(), m))
-    }
-
-    /// Bookkeeping after a successful command: normalise what changed, push undo, bump revision.
-    fn after_command(&mut self, spec: &CommandSpec, before: Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) {
-        let Some((bdoc, bsel, bpage, uid)) = before else {
-            if let Ok(ds) = self.ds_mut() {
-                ds.revision += 1;
-            }
-            return;
-        };
-        let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) else { return };
-        let changed = !Arc::ptr_eq(&ds.doc, &bdoc);
-        // Saving may adopt the chosen filename as the document title. The encoded snapshot is
-        // already final; normalising it again would detach it from the saved baseline.
-        if changed && !matches!(spec.id, "file.save" | "file.saveAs") {
-            normalize(ds.doc_mut(), &bdoc);
-        }
-        let edit = changed && ds.interaction.is_none();
-        ds.clean_selection();
-        ds.revision += 1;
-        if edit {
-            self.record(uid, spec.history.then_some(spec.label), bdoc, bsel, bpage);
-        }
-    }
-
-    /// Record an edit of document `uid` (it was `before`, shown with `selection` on `page`) as one
-    /// undo step called `label` (`None`: not undoable). On a live session's document the edit is
-    /// synced and the step is the user's own ([`live`]); otherwise it is a snapshot of `before`.
-    pub(crate) fn record(&mut self, uid: u64, label: Option<&str>, before: Arc<Document>, selection: Vec<NodeId>, page: NodeId) {
-        if self.live_doc(uid) {
-            return self.live_edit(uid, label);
-        }
-        if let (Some(label), Some(ds)) = (label, self.docs.iter_mut().find(|d| d.uid == uid)) {
-            ds.push_undo(label, before, selection, page);
-        }
-    }
-
-    /// How many undo and redo steps the active document has (the user's own in a live session).
-    pub fn undo_depth(&self) -> (usize, usize) {
-        match self.ds() {
-            Ok(ds) if self.live_doc(ds.uid) => self.live().client().map_or((0, 0), figcraft_collab::Client::history_len),
-            Ok(ds) => (ds.history.undo.len(), ds.history.redo.len()),
-            Err(_) => (0, 0),
-        }
-    }
-
-    /// The labels of the active document's last `n` undo steps, the next one first.
-    pub fn undo_labels(&self, n: usize) -> Vec<String> {
-        match self.ds() {
-            Ok(ds) if self.live_doc(ds.uid) => {
-                self.live().client().map(|c| c.undo_labels().rev().take(n).map(str::to_string).collect()).unwrap_or_default()
-            }
-            Ok(ds) => ds.history.undo.iter().rev().take(n).map(|h| h.label.clone()).collect(),
-            Err(_) => Vec::new(),
-        }
-    }
-
-    /// Start a gesture: later [`preview`](Self::preview) calls re-apply edits to this snapshot.
-    pub fn begin_interaction(&mut self, label: &str) -> Result<()> {
-        textpreview::end(self);
-        if let Some(why) = self.active_read_only() {
-            return Err(EngineError::Disabled(label.to_string(), why.into()));
-        }
-        let ds = self.ds_mut()?;
-        if ds.preview.is_some() {
-            return Err(EngineError::Disabled(label.to_string(), PREVIEW_READ_ONLY.into()));
-        }
-        if ds.interaction.is_none() {
-            ds.interaction = Some(Interaction { label: label.to_string(), doc: ds.doc.clone(), selection: ds.selection.clone() });
-        }
-        Ok(())
-    }
-
-    /// Replace the document with `f(snapshot)` for a live preview during a gesture.
-    pub fn preview(&mut self, f: impl FnOnce(&mut Document, &mut Vec<NodeId>) -> Result<()>) -> Result<()> {
-        let ds = self.ds_mut()?;
-        let Some(it) = ds.interaction.clone() else { return Err(EngineError::Other("no gesture in progress".into())) };
-        let mut doc = (*it.doc).clone();
-        let mut sel = it.selection.clone();
-        // What the gesture changes on the selected layers is an explicit edit.
-        let before = cmd::styles::bound_before(&doc, &it.selection);
-        let res = f(&mut doc, &mut sel);
-        if res.is_ok() {
-            cmd::styles::detach_edited(&mut doc, &before);
-            normalize(&mut doc, &it.doc);
-            // The same preview again (a handle held still) keeps the document: a new one would
-            // re-render the canvas for nothing.
-            if doc == *ds.doc && sel == ds.selection {
-                return res;
-            }
-            ds.doc = Arc::new(doc);
-            ds.selection = sel;
-            ds.clean_selection();
-            ds.revision += 1;
-        }
-        res
-    }
-
-    /// Finish a gesture as one undo step (no step if nothing changed).
-    pub fn commit_interaction(&mut self) -> Result<()> {
-        let ds = self.ds_mut()?;
-        let Some(it) = ds.interaction.take() else { return Ok(()) };
-        let (uid, page) = (ds.uid, ds.page);
-        ds.revision += 1;
-        if !Arc::ptr_eq(&it.doc, &ds.doc) && *it.doc != *ds.doc {
-            self.record(uid, Some(&it.label), it.doc, it.selection, page);
-        } else {
-            ds.doc = it.doc;
-        }
-        Ok(())
-    }
-
-    /// Abandon a gesture, restoring the document.
-    pub fn cancel_interaction(&mut self) -> Result<()> {
-        let ds = self.ds_mut()?;
-        if let Some(it) = ds.interaction.take() {
-            ds.doc = it.doc;
-            ds.selection = it.selection;
-            ds.revision += 1;
-        }
-        Ok(())
-    }
-
-    pub fn undo(&mut self) -> Result<bool> {
-        textpreview::end(self);
-        let live = self.ds().is_ok_and(|d| self.live_doc(d.uid));
-        let ds = self.ds_mut()?;
-        if ds.preview.is_some() {
-            return Err(EngineError::Disabled("edit.undo".into(), PREVIEW_READ_ONLY.into()));
-        }
-        if let Some(it) = ds.interaction.take()
-            && live
-        {
-            // The gesture in progress is dropped (it was never synced).
-            ds.doc = it.doc;
-        }
-        ds.text_edit = None;
-        if live {
-            return Ok(self.live_travel(true));
-        }
-        let Some(e) = ds.history.undo.pop() else { return Ok(false) };
-        let redo = HistoryEntry { label: e.label.clone(), doc: ds.doc.clone(), selection: ds.selection.clone(), page: ds.page };
-        ds.doc = e.doc;
-        cmd::facilitate::keep(&redo.doc, &mut ds.doc);
-        ds.history.redo.push(redo);
-        ds.selection = e.selection;
-        if ds.doc.pages.contains(&e.page) {
-            ds.page = e.page;
-        }
-        ds.clean_selection();
-        ds.revision += 1;
-        let (uid, doc) = (ds.uid, ds.doc.clone());
-        if self.clipboard.source_doc == uid {
-            self.clipboard.copied_components.retain(|id| {
-                doc.node(*id)
-                    .is_some_and(|n| matches!(n.kind, figcraft_doc::NodeKind::Component { .. } | figcraft_doc::NodeKind::ComponentSet { .. }))
-            });
-        }
-        Ok(true)
-    }
-
-    pub fn redo(&mut self) -> Result<bool> {
-        textpreview::end(self);
-        let live = self.ds().is_ok_and(|d| self.live_doc(d.uid));
-        let ds = self.ds_mut()?;
-        if ds.preview.is_some() {
-            return Err(EngineError::Disabled("edit.redo".into(), PREVIEW_READ_ONLY.into()));
-        }
-        if let Some(it) = ds.interaction.take()
-            && live
-        {
-            ds.doc = it.doc;
-        }
-        ds.text_edit = None;
-        if live {
-            return Ok(self.live_travel(false));
-        }
-        let Some(e) = ds.history.redo.pop() else { return Ok(false) };
-        let undo = HistoryEntry { label: e.label.clone(), doc: ds.doc.clone(), selection: ds.selection.clone(), page: ds.page };
-        ds.doc = e.doc;
-        cmd::facilitate::keep(&undo.doc, &mut ds.doc);
-        ds.history.undo.push(undo);
-        ds.selection = e.selection;
-        if ds.doc.pages.contains(&e.page) {
-            ds.page = e.page;
-        }
-        ds.clean_selection();
-        ds.revision += 1;
-        Ok(true)
-    }
-
-    /// Queue a UI request (dialogs etc.).
-    pub fn request_ui(&mut self, kind: &str, data: Value) {
-        self.ui_requests.push(UiRequest { kind: kind.to_string(), data });
-    }
-
-    /// Run several commands as one undo step. A param value `{"$step": n}` is replaced by the `id`
-    /// in the result of the earlier step `n`, and `{"$ref": "name"}` by the `id` in the result of
-    /// the earlier step whose `as` is `name`; either takes a `field`, a key or slash path (`ids/0`)
-    /// into that result. So a step can target a layer that an earlier step of the same batch
-    /// created. Any object with a `$step` or `$ref` key in a step's params is such a reference,
-    /// except inside a nested `command.batch` step: its references are to its own steps.
-    pub fn batch(&mut self, label: &str, steps: &[BatchStep]) -> Result<Vec<Value>> {
-        let mut scope = BatchScope::new(steps)?;
-        self.grouped(label, |s| {
-            for step in steps {
-                s.batch_step(&mut scope, &step.command, &step.params)?;
-            }
-            Ok(scope.into_results())
-        })
-    }
-
-    /// The next step of a batch: the references in `params` resolve against `scope` (the steps
-    /// before it), the command runs and its result joins `scope`. [`Session::batch`] runs a list
-    /// of these as one undo step; a caller with its own list — the CLI's script runner — uses this
-    /// so its steps resolve references the same way, inside its own [`Session::grouped`].
-    pub fn batch_step(&mut self, scope: &mut BatchScope, cmd: &str, params: &Value) -> Result<()> {
-        let p = if cmd == "command.batch" { params.clone() } else { scope.resolve(params)? };
-        // Say which step failed; a nested batch names its own steps.
-        let v = self.execute(cmd, &p).map_err(|e| if cmd == "command.batch" { e } else { e.at_step(scope.next_step()) })?;
-        scope.push(v);
-        Ok(())
-    }
-
-    /// Take the tabs `pred` matches out of `docs`; inside a group they are kept so that a failed
-    /// group can reopen them.
-    pub(crate) fn remove_tabs(&mut self, mut pred: impl FnMut(&DocState) -> bool) {
-        let (gone, keep): (Vec<_>, Vec<_>) = std::mem::take(&mut self.docs).into_iter().partition(|d| pred(d));
-        self.docs = keep;
-        if self.group_depth > 0 {
-            self.closed_in_group.extend(gone);
-        }
-    }
-
-    /// Run `f` as one undo step called `label`: the commands it executes push no steps of their
-    /// own, and when it fails the documents stay at their group-start state.
-    pub fn grouped<T>(&mut self, label: &str, f: impl FnOnce(&mut Self) -> Result<T>) -> Result<T> {
-        self.ds()?;
-        let before: Vec<_> =
-            self.docs.iter().map(|ds| (ds.uid, ds.doc.clone(), ds.selection.clone(), ds.page, ds.history.undo.len(), ds.history.limit)).collect();
-        // An edit inside clears the redo steps; a failed group has to bring them back.
-        let redo_before: Vec<_> = self.docs.iter().map(|ds| ds.history.redo.clone()).collect();
-        let active = self.active;
-        let journal_len = self.journal.len();
-
-        // The steps inside are dropped again below, so they mustn't push the oldest ones out.
-        for ds in &mut self.docs {
-            ds.history.limit = usize::MAX;
-        }
-        for (uid, _, _, _, _, _) in &before {
-            self.live_hold(*uid, true);
-        }
-        self.group_depth += 1;
-        let result = f(self);
-        self.group_depth -= 1;
-        for (uid, _, _, _, _, _) in &before {
-            self.live_hold(*uid, false);
-        }
-
-        if result.is_err() {
-            // Tabs the group closed come back from the stash, and the group-start order returns.
-            let mut current = std::mem::take(&mut self.docs);
-            for (uid, ..) in &before {
-                let tab = match current.iter().position(|d| d.uid == *uid) {
-                    Some(i) => Some(current.swap_remove(i)),
-                    None => self.closed_in_group.iter().position(|d| d.uid == *uid).map(|i| self.closed_in_group.swap_remove(i)),
-                };
-                self.docs.extend(tab);
-            }
-            for ((uid, doc, selection, page, undo_len, limit), redo) in before.iter().zip(redo_before) {
-                if let Some(ds) = self.docs.iter_mut().find(|ds| ds.uid == *uid) {
-                    ds.history.redo = redo;
-                    ds.doc = doc.clone();
-                    ds.selection = selection.clone();
-                    ds.page = *page;
-                    ds.history.undo.truncate(*undo_len);
-                    ds.history.limit = *limit;
-                }
-            }
-            self.active = active;
-            self.journal.truncate(journal_len);
-            if self.group_depth == 0 {
-                self.closed_in_group.clear();
-            }
-            return result;
-        }
-        if self.group_depth == 0 {
-            self.closed_in_group.clear();
-        }
-
-        let changed: Vec<_> = before
-            .iter()
-            .filter_map(|(uid, doc, selection, page, _, _)| {
-                let ds = self.docs.iter().find(|d| d.uid == *uid)?;
-                (!Arc::ptr_eq(doc, &ds.doc) && ds.interaction.is_none()).then(|| (*uid, doc.clone(), selection.clone(), *page))
-            })
-            .collect();
-        for ds in &mut self.docs {
-            if let Some((_, _, _, _, undo_len, limit)) = before.iter().find(|before| before.0 == ds.uid) {
-                ds.history.limit = *limit;
-                ds.history.undo.truncate(*undo_len);
-            }
-        }
-        for (uid, doc, selection, page) in changed {
-            self.record(uid, Some(label), doc, selection, page);
-        }
-        result
-    }
-
-    /// A summary for status displays.
-    pub fn status(&self) -> Value {
-        match self.ds() {
-            Ok(ds) => json!({
-                "document": ds.doc.name,
-                "path": ds.path,
-                "dirty": ds.is_dirty(),
-                "page": ds.page,
-                "selection": ds.selection,
-                "tool": self.tool.tool.id(),
-                "zoom": ds.view.zoom,
-                "undo": self.undo_depth().0,
-                "redo": self.undo_depth().1,
-                "documents": self.docs.len(),
-            }),
-            Err(_) => json!({"documents": 0}),
-        }
-    }
-}
-
-/// Nodes whose `Arc` differs from `before` (new or edited).
-pub fn changed_nodes(doc: &Document, before: &Document) -> Vec<NodeId> {
-    doc.ids()
-        .filter(|id| match (doc.node_arc(*id), before.node_arc(*id)) {
-            (Some(a), Some(b)) => !Arc::ptr_eq(a, b),
-            _ => true,
-        })
-        .collect()
-}
-
-/// Keep derived state consistent after edits: text boxes resize to their content, groups wrap
-/// their children, instances follow their main components, auto layout re-flows.
-pub fn normalize(doc: &mut Document, before: &Document) {
-    // Only what was touched since the last normalisation (edited, added or removed).
-    let mut touched: BTreeSet<NodeId> = doc.take_dirty();
-    // A variable or style edit changes no layer directly, but bound and linked layers must follow it.
-    if touched.is_empty() && doc.variables == before.variables && doc.styles == before.styles {
-        return;
-    }
-    let m = measure::TextMeasure;
-    // 0. Variable bindings and style links feed node values.
-    let scope = binding_scope(doc, before, &touched);
-    if doc.variables != before.variables || doc.styles != before.styles {
-        style_vars::settle(doc);
-    }
-    cmd::styles::apply_bindings_to(doc, scope.as_ref());
-    style_vars::refresh(doc, Some(before), scope.as_ref());
-    if doc.styles != before.styles {
-        let changed_styles: Vec<String> = doc.styles.iter().filter(|s| !before.styles.contains(s)).map(|s| s.id.clone()).collect();
-        for sid in changed_styles {
-            cmd::styles::propagate_style(doc, &sid);
-        }
-    }
-    touched.extend(doc.take_dirty());
-    // Lists and text chars edited away from their style unlink from it.
-    let live_now: Vec<NodeId> = touched.iter().copied().filter(|i| doc.contains(*i)).collect();
-    cmd::styles::sync_list_styles(doc, before, &live_now);
-    cmd::styles::sync_text_styles(doc, &live_now);
-    touched.extend(doc.take_dirty());
-    let live = |doc: &Document, t: &BTreeSet<NodeId>| -> Vec<NodeId> { t.iter().copied().filter(|i| doc.contains(*i)).collect() };
-    // 0b. Fill and hug only where they can apply (a layer moved out of auto layout, a parent that
-    // started to hug or lost auto layout): the rest becomes fixed at its current size.
-    for id in live(doc, &touched) {
-        figcraft_layout::coherent_sizing(doc, id);
-    }
-    touched.extend(doc.take_dirty());
-    // 1. Text auto-size (a sticky's note first takes the size its length calls for).
-    board::settle_text(doc, before, &touched);
-    touched.extend(doc.take_dirty());
-    for id in live(doc, &touched) {
-        let Some(n) = doc.node(id) else { continue };
-        if let Some((w, h)) = figcraft_text::auto_size(n)
-            && ((w - n.width).abs() > 1e-6 || (h - n.height).abs() > 1e-6)
-        {
-            figcraft_layout::set_size(doc, id, w, h);
-        }
-    }
-    touched.extend(doc.take_dirty());
-    // 2. Instances follow edited main components (and record overrides inside instances).
-    let changed = live(doc, &touched);
-    components::sync_after_edit(doc, before, &changed, &touched);
-    // Rebuilt copies took their mains' values: their bindings resolve in their own modes.
-    let synced = doc.take_dirty();
-    if !synced.is_empty() {
-        cmd::styles::apply_bindings_to(doc, Some(&synced));
-        style_vars::refresh(doc, Some(before), Some(&synced));
-        touched.extend(synced);
-    }
-    touched.extend(doc.take_dirty());
-    // Parents of removed nodes (as they were before) count as touched.
-    let removed_parents: Vec<NodeId> =
-        touched.iter().filter(|i| !doc.contains(**i)).filter_map(|i| before.node(*i).and_then(|n| n.parent)).filter(|p| doc.contains(*p)).collect();
-    // 3. Groups / booleans wrap their children.
-    let mut fit: BTreeSet<NodeId> = BTreeSet::new();
-    for id in live(doc, &touched).into_iter().chain(removed_parents.iter().copied()) {
-        if doc.node(id).is_some_and(|n| n.kind.bounds_follow_children()) {
-            fit.insert(id);
-        }
-        for a in doc.ancestors(id) {
-            if doc.node(a).is_some_and(|n| n.kind.bounds_follow_children()) {
-                fit.insert(a);
-            } else {
-                break;
-            }
-        }
-    }
-    let mut fit: Vec<NodeId> = fit.into_iter().collect();
-    fit.sort_by_key(|id| std::cmp::Reverse(doc.ancestors(*id).len()));
-    for id in fit {
-        if doc.node(id).is_some_and(|n| n.children.is_empty()) {
-            // Empty groups disappear, like the incumbent.
-            let _ = doc.remove(id);
-        } else {
-            let _ = doc.fit_to_children(id);
-        }
-    }
-    touched.extend(doc.take_dirty());
-    // 4. Auto layout for frames where something that sizes or places layers changed.
-    let mut frames: BTreeSet<NodeId> = BTreeSet::new();
-    let moved = live(doc, &touched).into_iter().filter(|id| affects_layout(before, doc, *id));
-    for id in moved.chain(removed_parents) {
-        if !doc.contains(id) {
-            continue;
-        }
-        let mut chain = vec![id];
-        chain.extend(doc.ancestors(id));
-        for c in chain {
-            if doc.node(c).is_some_and(|n| n.layout.is_some()) {
-                frames.insert(c);
-            }
-        }
-    }
-    let mut frames: Vec<NodeId> = frames.into_iter().collect();
-    frames.sort_by_key(|id| std::cmp::Reverse(doc.ancestors(*id).len()));
-    for f in frames {
-        // Layers the layout leaves where they were stay untouched.
-        let kept: Vec<(Arc<Node>, bool)> = doc
-            .node(f)
-            .map(|n| std::iter::once(f).chain(n.children.iter().copied()).collect::<Vec<_>>())
-            .unwrap_or_default()
-            .into_iter()
-            .filter_map(|i| doc.node_arc(i).map(|a| (a.clone(), doc.dirty().contains(&i))))
-            .collect();
-        figcraft_layout::layout_frame(doc, f, &m);
-        for (a, was_dirty) in kept {
-            doc.keep_if_unchanged(a, was_dirty);
-        }
-    }
-    touched.extend(doc.take_dirty());
-    // 4b. Board connectors follow the layers they join; their labels sit at their middles.
-    board::settle_routes(doc, before, &touched);
-    touched.extend(doc.take_dirty());
-    // 5. Ready-for-dev layers whose contents changed show "Changed".
-    mark_dev_changes(doc, before, &touched);
-    doc.take_dirty();
-    // 5. Comment pins follow their layers to other pages and stay put when the layers are deleted.
-    cmd::comment::follow_anchors(doc, before);
-}
-
-/// Whether layer `id` changed (since `before`) in a way that can move or resize layers in an auto
-/// layout frame around it: new, resized, moved, shown or hidden, restructured, other text or
-/// layout settings.
-fn affects_layout(before: &Document, doc: &Document, id: NodeId) -> bool {
-    let (Some(a), Some(b)) = (before.node(id), doc.node(id)) else { return true };
-    a.width != b.width
-        || a.height != b.height
-        || a.transform != b.transform
-        || a.visible != b.visible
-        || a.parent != b.parent
-        || a.children != b.children
-        || a.layout != b.layout
-        || a.child_layout != b.child_layout
-        || a.stroke != b.stroke
-        || a.strokes.len() != b.strokes.len()
-        || a.kind != b.kind
-}
-
-/// The layers whose variable bindings an edit may have changed: every bound layer when a variable
-/// changed, else the touched layers and everything below those that moved, are new, chose
-/// another variable mode or became an instance of another main (modes are inherited, an
-/// instance's from its main too), and the instances of a main that chose another mode.
-fn binding_scope(doc: &Document, before: &Document, touched: &BTreeSet<NodeId>) -> Option<BTreeSet<NodeId>> {
-    if doc.variables != before.variables {
-        return None;
-    }
-    let main = |n: &Node| match n.kind {
-        figcraft_doc::NodeKind::Instance { component, .. } => Some(component),
-        _ => None,
-    };
-    let mut out = BTreeSet::new();
-    for &id in touched {
-        let Some(n) = doc.node(id) else { continue };
-        let Some(b) = before.node(id) else {
-            out.extend(doc.subtree(id));
-            continue;
-        };
-        let modes = b.var_modes != n.var_modes;
-        if modes || b.parent != n.parent || main(b) != main(n) {
-            out.extend(doc.subtree(id));
-        } else {
-            out.insert(id);
-        }
-        if modes && matches!(n.kind, figcraft_doc::NodeKind::Component { .. }) {
-            for i in components::instances_of(doc, id) {
-                out.extend(doc.subtree(i));
-            }
-        }
-    }
-    Some(out)
-}
-
-/// Flag the frames and sections marked ready for dev (before this edit) that contain a layer whose
-/// design `touched` changed (added, removed or edited; the handoff status itself and hiding a
-/// section's contents don't count).
-fn mark_dev_changes(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
-    let ready = |d: &Document, id: NodeId| d.node(id).is_some_and(|n| n.dev_status == figcraft_doc::DevStatus::ReadyForDev);
-    let mut changed: BTreeSet<NodeId> = BTreeSet::new();
-    for &id in touched {
-        // Ready-for-dev frames around it first (the cheap test).
-        let mut chain = vec![id];
-        chain.extend(if doc.contains(id) { doc.ancestors(id) } else { before.ancestors(id) });
-        chain.retain(|m| ready(before, *m) && ready(doc, *m));
-        if chain.is_empty() {
-            continue;
-        }
-        let differs = match (before.node(id), doc.node(id)) {
-            (Some(a), Some(b)) => !a.same_design(b),
-            (None, None) => false,
-            _ => true,
-        };
-        if differs {
-            changed.extend(chain);
-        }
-    }
-    for m in changed {
-        if doc.node(m).is_some_and(|n| !n.dev_changed) {
-            // Its first change since it was marked: keep what it looked like (for Compare changes).
-            if let Some(snap) = before.snapshot_subtree(m) {
-                doc.dev_snapshots.insert(m, Arc::new(snap));
-            }
-            if let Some(n) = doc.node_mut(m) {
-                n.dev_changed = true;
-            }
-        }
-    }
-    // Snapshots last until the change is resolved, the layer is marked again or it's deleted.
-    if !doc.dev_snapshots.is_empty() {
-        let keep = |d: &Document, id: NodeId| d.node(id).is_some_and(|n| n.dev_status == figcraft_doc::DevStatus::ReadyForDev && n.dev_changed);
-        let stale: Vec<NodeId> = doc.dev_snapshots.keys().copied().filter(|id| !keep(doc, *id)).collect();
-        for id in stale {
-            doc.dev_snapshots.remove(&id);
-        }
-    }
-}
-
 #[cfg(test)]
 mod a11y_keys_tests;
 #[cfg(test)]
diff --git a/crates/engine/src/prefs.rs b/crates/engine/src/prefs.rs
new file mode 100644
index 00000000..6bfedcba
--- /dev/null
+++ b/crates/engine/src/prefs.rs
@@ -0,0 +1,181 @@
+use super::*;
+
+/// The smallest and largest interface size, relative to the system's display scale (1.0 is the
+/// system's own size).
+pub const UI_SCALE_MIN: f64 = 0.75;
+
+pub const UI_SCALE_MAX: f64 = 3.0;
+
+/// `scale` kept between [`UI_SCALE_MIN`] and [`UI_SCALE_MAX`]; not a finite number: `None`.
+pub fn clamp_ui_scale(scale: f64) -> Option<f64> {
+    scale.is_finite().then(|| scale.clamp(UI_SCALE_MIN, UI_SCALE_MAX))
+}
+
+/// Reads the saved interface size. Anything but a number reads as 1 (the system's size) and a
+/// number out of range is clamped, so a settings file edited by hand never costs the other
+/// preferences.
+fn read_ui_scale<'de, D: serde::Deserializer<'de>>(d: D) -> std::result::Result<f64, D::Error> {
+    Ok(Value::deserialize(d)?.as_f64().and_then(clamp_ui_scale).unwrap_or(1.0))
+}
+
+/// App-wide preferences that commands read (nudge amounts, behaviours).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct Prefs {
+    pub nudge_small: f64,
+    pub nudge_big: f64,
+    pub keep_tool: bool,
+    pub rename_duplicates: bool,
+    pub highlight_on_hover: bool,
+    pub number_keys_opacity: bool,
+    pub show_dimensions: bool,
+    /// "system" by default; an explicit "light" or "dark" choice stays saved.
+    pub theme: String,
+    /// The widths of the main window's left and right panels (the interface keeps them within its
+    /// limits; other windows have their own while they are open).
+    pub panel_widths: (f32, f32),
+    /// The height asked for the main window's pages list, dragged at its lower edge (`None`: a
+    /// share of the panel; the interface keeps it within its limits).
+    pub pages_height: Option<f32>,
+    /// The interface language: a language code ("en", "es", "pt-BR") or "system" (the OS or browser
+    /// language). Languages without a catalog show English.
+    pub language: String,
+    /// The name comments are signed with (and whose comments count as yours).
+    pub user_name: String,
+    /// Reduce motion: the interface's own animations are off (the system's setting turns them off
+    /// too). Prototype transitions still play.
+    pub reduce_motion: bool,
+    /// How large the whole interface is drawn, relative to the system's display scale: 1.0 is the
+    /// system's own size, 1.25 a quarter larger (kept between [`UI_SCALE_MIN`] and
+    /// [`UI_SCALE_MAX`]). The canvas zoom is separate.
+    #[serde(deserialize_with = "read_ui_scale")]
+    pub ui_scale: f64,
+    /// Files that have a path are saved by themselves a few seconds after they change (the app's
+    /// timer; off: only File ▸ Save writes them).
+    pub auto_save: bool,
+    /// The desktop app starts on the Home screen instead of in a new file.
+    pub start_on_home: bool,
+    /// `figcraft://` invite links open this app (`collab.registerLinks`); `None`: on for installed
+    /// builds, off for development builds.
+    pub invite_links: Option<bool>,
+    /// Installed plugins (Plugins menu), in menu order.
+    #[serde(serialize_with = "plugins::persisted")]
+    pub plugins: Vec<plugins::InstalledPlugin>,
+    /// Plugins' own settings (`setting_set`), by plugin id, then key: JSON values, capped per
+    /// plugin.
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub plugin_settings: BTreeMap<String, BTreeMap<String, Value>>,
+    /// The plugin directory browsed last (`ws://host:port/`, never with a key).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub plugin_directory: Option<String>,
+    /// The server files are shared through online (Share ▸ Online, join codes; Publish to server
+    /// suggests it too): `wss://host/`, never with a key. [`live::DEFAULT_SERVER`] unless the user
+    /// chose another; empty: online sharing is off (saved as empty, so it stays off).
+    pub publish_server: String,
+    /// Recently opened or saved files, newest first (File ▸ Open recent; at most
+    /// [`cmd::file::MAX_RECENT`]).
+    pub recent_files: Vec<String>,
+    /// The files you put on a server without its key, with their owner tokens (passwords: see
+    /// [`online`]), most recently opened first, at most [`online::MAX_ONLINE_FILES`].
+    #[serde(skip_serializing_if = "Vec::is_empty", deserialize_with = "online::read")]
+    pub online_files: Vec<online::OnlineFile>,
+    /// The Getting started tips on the home screen were closed (Help ▸ Getting started shows them
+    /// again).
+    pub getting_started_dismissed: bool,
+    /// A prototype's Open link goes to a website without first telling the viewer that it leaves
+    /// the prototype (the notice's "Don't show this again"; `proto.linkNotice` shows it again).
+    pub link_notice_skipped: bool,
+    /// How each home screen section shows its files, by section id (`"recents"`): `"grid"` (cards
+    /// with the picture each file carries) or `"list"` (a table). Missing: the grid.
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub home_views: BTreeMap<String, String>,
+    /// What the home screen's recent files are ordered by: `"modified"`, `"name"` or `"created"`.
+    pub home_sort: String,
+    /// Which way: `"desc"` (newest first, Z to A) or `"asc"`.
+    pub home_order: String,
+    /// The View menu's toggles turned on or off (rulers, pixel grid, snapping…), by command id:
+    /// files opened or made later start with them. Missing: the toggle's default.
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub view: BTreeMap<String, bool>,
+    /// Recently run actions (the Actions palette's Recents), newest first, at most
+    /// [`MAX_RECENT_ACTIONS`]. Entries are `command:<id>`, `plugin:<plugin>/<command>` or
+    /// `widget:<plugin>`.
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub recent_actions: Vec<String>,
+}
+
+/// Recently run actions kept for the Actions palette (newest first).
+pub const MAX_RECENT_ACTIONS: usize = 5;
+
+impl Default for Prefs {
+    fn default() -> Self {
+        Self {
+            nudge_small: 1.0,
+            nudge_big: 10.0,
+            keep_tool: false,
+            rename_duplicates: false,
+            highlight_on_hover: true,
+            number_keys_opacity: true,
+            show_dimensions: true,
+            theme: "system".into(),
+            panel_widths: (240.0, 240.0),
+            pages_height: None,
+            language: "system".into(),
+            user_name: cmd::comment::DEFAULT_AUTHOR.into(),
+            reduce_motion: false,
+            ui_scale: 1.0,
+            auto_save: false,
+            start_on_home: false,
+            invite_links: None,
+            plugins: Vec::new(),
+            plugin_settings: BTreeMap::new(),
+            plugin_directory: None,
+            publish_server: live::DEFAULT_SERVER.into(),
+            recent_files: Vec::new(),
+            online_files: Vec::new(),
+            getting_started_dismissed: false,
+            link_notice_skipped: false,
+            home_views: BTreeMap::new(),
+            home_sort: "modified".into(),
+            home_order: "desc".into(),
+            view: BTreeMap::new(),
+            recent_actions: Vec::new(),
+        }
+    }
+}
+
+/// A request from a command to the UI (open a dialog or panel, show a message). Programmatic
+/// callers ignore them.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct UiRequest {
+    pub kind: String,
+    pub data: Value,
+}
+
+/// Clipboard contents (internal; the UI mirrors to the system clipboard).
+#[derive(Clone, Debug, Default)]
+pub struct Clipboard {
+    /// Copied subtrees: (root, nodes) in z-order.
+    pub nodes: Vec<(NodeId, Vec<figcraft_doc::Node>)>,
+    pub images: std::collections::BTreeMap<String, figcraft_doc::ImageData>,
+    /// Copied properties (Copy properties / Paste properties).
+    pub props: Option<Value>,
+    /// A copied fill or stroke row (`fill.copy`, `stroke.copy`): whether it's a fill, and the paint.
+    pub paint: Option<(bool, figcraft_color::Paint)>,
+    /// The stroke settings (`weight`, alignment, sides…) copied with a stroke's paint.
+    pub stroke: Option<figcraft_doc::StrokeProps>,
+    /// A copied effect row (`effect.copy`).
+    pub effect: Option<figcraft_doc::Effect>,
+    /// The page-space bounds of the copied selection.
+    pub bounds: Option<figcraft_geom::Rect>,
+    pub source_doc: u64,
+    /// Copied component/set roots, excluding cuts and originals discarded by undo (ids are reused).
+    pub copied_components: std::collections::BTreeSet<NodeId>,
+    /// Monotonic generation of the copied layers (contents, images, bounds and source). A UI
+    /// clipboard mirror records it, so a later programmatic copy that never touched the system
+    /// clipboard is not mistaken for the user's own copy just because the text still matches.
+    pub layers_generation: u64,
+    /// The document copied from (pastes into other files follow its mains) and its file path.
+    pub source: Option<Arc<Document>>,
+    pub source_path: Option<String>,
+}
diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs
new file mode 100644
index 00000000..b073b36a
--- /dev/null
+++ b/crates/engine/src/session.rs
@@ -0,0 +1,583 @@
+use super::derived::normalize;
+use super::doc_state::{DocState, ENDS_PREVIEW, HistoryEntry, Interaction, PREVIEW_READ_ONLY};
+use super::error::{EngineError, Result, bad};
+use super::prefs::{Clipboard, Prefs, UiRequest};
+use super::*;
+
+/// Whether a command, or a batch wrapping one, imports a file passed as Base64 `data`.
+fn command_carries_import_bytes(id: &str, params: &Value) -> bool {
+    match id {
+        "file.import" => params::get(params, "data").is_some(),
+        "command.batch" => params.get("commands").and_then(Value::as_array).is_some_and(|commands| {
+            commands.iter().any(|c| {
+                c.get("command").and_then(Value::as_str).zip(c.get("params")).is_some_and(|(id, params)| command_carries_import_bytes(id, params))
+            })
+        }),
+        _ => false,
+    }
+}
+
+impl Session {
+    /// A session with one new document.
+    pub fn new() -> Self {
+        let mut s = Self::empty();
+        s.docs.push(DocState::new(Document::new("Untitled"), None));
+        s
+    }
+
+    /// A session with no documents (the home screen).
+    pub fn empty() -> Self {
+        Self {
+            docs: Vec::new(),
+            active: 0,
+            clipboard: Clipboard::default(),
+            prefs: Prefs::default(),
+            tool: tools::ToolState::default(),
+            ui_requests: Vec::new(),
+            ui_dark: None,
+            journal: Vec::new(),
+            group_depth: 0,
+            closed_in_group: Vec::new(),
+            recent_colors: Vec::new(),
+            last_command: None,
+            message: None,
+            libraries: library::Cache::default(),
+            plugins: plugins::Runtime::default(),
+            live: live::Lives::default(),
+            background: background::Background::default(),
+        }
+    }
+
+    /// The background a new file's page gets: the dark page colour while the interface is dark.
+    pub fn new_page_background(&self) -> figcraft_color::Color {
+        if self.ui_dark == Some(true) { figcraft_color::Color::DARK_PAGE } else { figcraft_color::Color::DEFAULT_PAGE }
+    }
+
+    /// Tell the engine the interface's theme (the UI does, every frame). The first time, a new
+    /// file nothing was done to yet (the one the app opened with, made before the theme was
+    /// known) takes the theme's page colour; later changes of theme leave existing pages alone.
+    pub fn set_ui_dark(&mut self, dark: bool) {
+        if self.ui_dark.replace(dark).is_some() || !dark {
+            return;
+        }
+        for ds in &mut self.docs {
+            let untouched = ds.path.is_none() && ds.history.undo.is_empty() && ds.history.redo.is_empty() && !ds.is_dirty() && ds.versions.is_empty();
+            let pages = ds.doc.pages.clone();
+            let blank = pages.iter().all(|p| {
+                ds.doc.node(*p).is_some_and(|n| {
+                    n.children.is_empty()
+                        && matches!(n.kind, figcraft_doc::NodeKind::Page { background, .. } if background == figcraft_color::Color::DEFAULT_PAGE)
+                })
+            });
+            if !(untouched && blank) {
+                continue;
+            }
+            let mut doc = (*ds.doc).clone();
+            for p in pages {
+                if let Some(figcraft_doc::NodeKind::Page { background, .. }) = doc.node_mut(p).map(|n| &mut n.kind) {
+                    *background = figcraft_color::Color::DARK_PAGE;
+                }
+            }
+            // Still a file without changes.
+            ds.doc = Arc::new(doc);
+            ds.saved_doc = ds.doc.clone();
+            ds.revision += 1;
+        }
+    }
+
+    pub fn with_document(doc: Document) -> Self {
+        let mut s = Self::empty();
+        s.docs.push(DocState::new(doc, None));
+        s
+    }
+
+    /// Files new to the session start with the View toggles the preferences keep.
+    pub fn apply_view_prefs(&mut self) {
+        for ds in self.docs.iter_mut().filter(|d| !d.view_from_prefs) {
+            cmd::view::apply_kept(&self.prefs, &mut ds.view);
+            ds.view_from_prefs = true;
+        }
+    }
+
+    pub fn ds(&self) -> Result<&DocState> {
+        self.docs.get(self.active).ok_or(EngineError::NoDocument)
+    }
+
+    pub fn ds_mut(&mut self) -> Result<&mut DocState> {
+        self.docs.get_mut(self.active).ok_or(EngineError::NoDocument)
+    }
+
+    pub fn doc(&self) -> Result<&Document> {
+        Ok(self.ds()?.doc.as_ref())
+    }
+
+    pub fn doc_mut(&mut self) -> Result<&mut Document> {
+        Ok(self.ds_mut()?.doc_mut())
+    }
+
+    pub fn selection(&self) -> Vec<NodeId> {
+        self.ds().map(|d| d.selection.clone()).unwrap_or_default()
+    }
+
+    pub fn set_selection(&mut self, ids: Vec<NodeId>) {
+        if let Ok(ds) = self.ds_mut() {
+            ds.selection = ids;
+            ds.clean_selection();
+            ds.revision += 1;
+        }
+    }
+
+    pub fn page(&self) -> Result<NodeId> {
+        Ok(self.ds()?.page)
+    }
+
+    /// Run a command by id. Mutations become one undo step; a failure or panic leaves the document
+    /// as it was.
+    pub fn execute(&mut self, id: &str, params: &Value) -> Result<Value> {
+        let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
+        board::refuse_on_board(self, id)?;
+        // Revert replaces the document's uid: refuse before ending previews or syncing branches.
+        if id == "file.revert" && self.live().doc_uid.is_some() {
+            return Err(EngineError::Disabled(id.into(), "leave the live session before reverting to the saved file".into()));
+        }
+        branches::sync(self);
+        self.apply_view_prefs();
+        if textpreview::COMMANDS.contains(&id) {
+            // A live preview is no edit: no undo step, normalisation or rollback here.
+            let r = guard::run(id, || (spec.run)(self, params));
+            if r.is_err() {
+                textpreview::end(self);
+            }
+            return r;
+        }
+        // Every other command acts on the document itself, not on a live text preview.
+        textpreview::end(self);
+        if ENDS_PREVIEW.contains(&id)
+            && (!matches!(id, "file.save" | "file.saveAs") || cmd::file::save_ends_preview(self, id, params))
+            && let Ok(ds) = self.ds_mut()
+        {
+            ds.end_preview();
+        }
+        let before = self.ds().ok().map(|d| (d.doc.clone(), d.selection.clone(), d.page, d.uid));
+        // Cut and copy write the clipboard before a later check can refuse the command.
+        let clipboard_before = self.clipboard.clone();
+        let result = guard::run(id, || (spec.run)(self, params))
+            .and_then(|v| self.check_instance_structure(id, &before).map(|()| v))
+            .and_then(|v| self.check_preview(id, &before).map(|()| v))
+            .and_then(|v| self.check_live_access(id, &before).map(|()| v))
+            .and_then(|v| self.check_finite_geometry(id, &before).map(|()| v));
+        match &result {
+            Ok(_) => {
+                self.after_command(spec, before);
+                self.apply_view_prefs();
+                if spec.history && id != "edit.repeat" {
+                    self.last_command = Some((id.to_string(), params.clone()));
+                }
+                // Imported bytes already live in the document: a Base64 copy in the log would stay
+                // for the whole session.
+                if !command_carries_import_bytes(id, params) {
+                    self.journal.push((id.to_string(), params.clone()));
+                    if self.journal.len() > 5000 {
+                        self.journal.drain(..1000);
+                    }
+                }
+            }
+            Err(_) => {
+                // Roll back any partial edit — also during an interaction, where `before` is the
+                // interaction's last valid preview: restore it and leave the gesture itself (its
+                // own snapshot) alone.
+                if let Some((doc, sel, page, uid)) = before
+                    && let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid)
+                {
+                    ds.doc = doc;
+                    ds.selection = sel;
+                    ds.page = page;
+                }
+                self.clipboard = clipboard_before;
+            }
+        }
+        result
+    }
+
+    /// A version shown in place of the document is read-only: refuse an edit (it is rolled back).
+    fn check_preview(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
+        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
+        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
+        if ds.preview.is_none() || Arc::ptr_eq(&ds.doc, bdoc) || id == "version.preview" {
+            return Ok(());
+        }
+        Err(EngineError::Disabled(id.to_string(), PREVIEW_READ_ONLY.into()))
+    }
+
+    /// A layer's position and size stay finite: infinity and NaN are written as `null`, so a file
+    /// holding them saves but can't be reopened. Refuse such an edit (it is rolled back).
+    fn check_finite_geometry(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
+        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
+        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
+        if Arc::ptr_eq(&ds.doc, bdoc) {
+            return Ok(());
+        }
+        let broken = |n: &Node| !(n.transform.as_coeffs().iter().all(|c| c.is_finite()) && n.width.is_finite() && n.height.is_finite());
+        let untouched = |n: &Node| bdoc.node_arc(n.id).zip(ds.doc.node_arc(n.id)).is_some_and(|(a, b)| Arc::ptr_eq(a, b));
+        match ds.doc.nodes().find(|n| broken(n) && !untouched(n)) {
+            Some(n) => Err(bad(id, format!("\"{}\" would get a position or size beyond the number range", n.name))),
+            None => Ok(()),
+        }
+    }
+
+    /// A live session's document you may only view (or that is on its way to a server) is
+    /// read-only: refuse an edit (it is rolled back).
+    fn check_live_access(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
+        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
+        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
+        match self.live_read_only(*uid) {
+            Some(why) if !Arc::ptr_eq(&ds.doc, bdoc) => Err(EngineError::Disabled(id.to_string(), why.into())),
+            _ => Ok(()),
+        }
+    }
+
+    /// Instances can't gain, lose or reorder layers, nor move, resize or re-constrain the layers in
+    /// them, and library copies are read-only: refuse such an edit (it is rolled back).
+    pub(crate) fn check_instance_structure(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
+        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
+        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
+        if Arc::ptr_eq(&ds.doc, bdoc) {
+            return Ok(());
+        }
+        // "Repeat" runs the repeated command.
+        let effective = match (&self.last_command, id) {
+            (Some((last, _)), "edit.repeat") => last.as_str(),
+            _ => id,
+        };
+        library::check_read_only(effective, bdoc, &ds.doc)
+            .and_then(|()| components::check_structure_edit(bdoc, &ds.doc))
+            .and_then(|()| components::check_override_edit(bdoc, &ds.doc))
+            .map_err(|m| EngineError::Disabled(id.to_string(), m))
+    }
+
+    /// Bookkeeping after a successful command: normalise what changed, push undo, bump revision.
+    fn after_command(&mut self, spec: &CommandSpec, before: Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) {
+        let Some((bdoc, bsel, bpage, uid)) = before else {
+            if let Ok(ds) = self.ds_mut() {
+                ds.revision += 1;
+            }
+            return;
+        };
+        let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) else { return };
+        let changed = !Arc::ptr_eq(&ds.doc, &bdoc);
+        // Saving may adopt the chosen filename as the document title. The encoded snapshot is
+        // already final; normalising it again would detach it from the saved baseline.
+        if changed && !matches!(spec.id, "file.save" | "file.saveAs") {
+            normalize(ds.doc_mut(), &bdoc);
+        }
+        let edit = changed && ds.interaction.is_none();
+        ds.clean_selection();
+        ds.revision += 1;
+        if edit {
+            self.record(uid, spec.history.then_some(spec.label), bdoc, bsel, bpage);
+        }
+    }
+
+    /// Record an edit of document `uid` (it was `before`, shown with `selection` on `page`) as one
+    /// undo step called `label` (`None`: not undoable). On a live session's document the edit is
+    /// synced and the step is the user's own ([`live`]); otherwise it is a snapshot of `before`.
+    pub(crate) fn record(&mut self, uid: u64, label: Option<&str>, before: Arc<Document>, selection: Vec<NodeId>, page: NodeId) {
+        if self.live_doc(uid) {
+            return self.live_edit(uid, label);
+        }
+        if let (Some(label), Some(ds)) = (label, self.docs.iter_mut().find(|d| d.uid == uid)) {
+            ds.push_undo(label, before, selection, page);
+        }
+    }
+
+    /// How many undo and redo steps the active document has (the user's own in a live session).
+    pub fn undo_depth(&self) -> (usize, usize) {
+        match self.ds() {
+            Ok(ds) if self.live_doc(ds.uid) => self.live().client().map_or((0, 0), figcraft_collab::Client::history_len),
+            Ok(ds) => (ds.history.undo.len(), ds.history.redo.len()),
+            Err(_) => (0, 0),
+        }
+    }
+
+    /// The labels of the active document's last `n` undo steps, the next one first.
+    pub fn undo_labels(&self, n: usize) -> Vec<String> {
+        match self.ds() {
+            Ok(ds) if self.live_doc(ds.uid) => {
+                self.live().client().map(|c| c.undo_labels().rev().take(n).map(str::to_string).collect()).unwrap_or_default()
+            }
+            Ok(ds) => ds.history.undo.iter().rev().take(n).map(|h| h.label.clone()).collect(),
+            Err(_) => Vec::new(),
+        }
+    }
+
+    /// Start a gesture: later [`preview`](Self::preview) calls re-apply edits to this snapshot.
+    pub fn begin_interaction(&mut self, label: &str) -> Result<()> {
+        textpreview::end(self);
+        if let Some(why) = self.active_read_only() {
+            return Err(EngineError::Disabled(label.to_string(), why.into()));
+        }
+        let ds = self.ds_mut()?;
+        if ds.preview.is_some() {
+            return Err(EngineError::Disabled(label.to_string(), PREVIEW_READ_ONLY.into()));
+        }
+        if ds.interaction.is_none() {
+            ds.interaction = Some(Interaction { label: label.to_string(), doc: ds.doc.clone(), selection: ds.selection.clone() });
+        }
+        Ok(())
+    }
+
+    /// Replace the document with `f(snapshot)` for a live preview during a gesture.
+    pub fn preview(&mut self, f: impl FnOnce(&mut Document, &mut Vec<NodeId>) -> Result<()>) -> Result<()> {
+        let ds = self.ds_mut()?;
+        let Some(it) = ds.interaction.clone() else { return Err(EngineError::Other("no gesture in progress".into())) };
+        let mut doc = (*it.doc).clone();
+        let mut sel = it.selection.clone();
+        // What the gesture changes on the selected layers is an explicit edit.
+        let before = cmd::styles::bound_before(&doc, &it.selection);
+        let res = f(&mut doc, &mut sel);
+        if res.is_ok() {
+            cmd::styles::detach_edited(&mut doc, &before);
+            normalize(&mut doc, &it.doc);
+            // The same preview again (a handle held still) keeps the document: a new one would
+            // re-render the canvas for nothing.
+            if doc == *ds.doc && sel == ds.selection {
+                return res;
+            }
+            ds.doc = Arc::new(doc);
+            ds.selection = sel;
+            ds.clean_selection();
+            ds.revision += 1;
+        }
+        res
+    }
+
+    /// Finish a gesture as one undo step (no step if nothing changed).
+    pub fn commit_interaction(&mut self) -> Result<()> {
+        let ds = self.ds_mut()?;
+        let Some(it) = ds.interaction.take() else { return Ok(()) };
+        let (uid, page) = (ds.uid, ds.page);
+        ds.revision += 1;
+        if !Arc::ptr_eq(&it.doc, &ds.doc) && *it.doc != *ds.doc {
+            self.record(uid, Some(&it.label), it.doc, it.selection, page);
+        } else {
+            ds.doc = it.doc;
+        }
+        Ok(())
+    }
+
+    /// Abandon a gesture, restoring the document.
+    pub fn cancel_interaction(&mut self) -> Result<()> {
+        let ds = self.ds_mut()?;
+        if let Some(it) = ds.interaction.take() {
+            ds.doc = it.doc;
+            ds.selection = it.selection;
+            ds.revision += 1;
+        }
+        Ok(())
+    }
+
+    pub fn undo(&mut self) -> Result<bool> {
+        textpreview::end(self);
+        let live = self.ds().is_ok_and(|d| self.live_doc(d.uid));
+        let ds = self.ds_mut()?;
+        if ds.preview.is_some() {
+            return Err(EngineError::Disabled("edit.undo".into(), PREVIEW_READ_ONLY.into()));
+        }
+        if let Some(it) = ds.interaction.take()
+            && live
+        {
+            // The gesture in progress is dropped (it was never synced).
+            ds.doc = it.doc;
+        }
+        ds.text_edit = None;
+        if live {
+            return Ok(self.live_travel(true));
+        }
+        let Some(e) = ds.history.undo.pop() else { return Ok(false) };
+        let redo = HistoryEntry { label: e.label.clone(), doc: ds.doc.clone(), selection: ds.selection.clone(), page: ds.page };
+        ds.doc = e.doc;
+        cmd::facilitate::keep(&redo.doc, &mut ds.doc);
+        ds.history.redo.push(redo);
+        ds.selection = e.selection;
+        if ds.doc.pages.contains(&e.page) {
+            ds.page = e.page;
+        }
+        ds.clean_selection();
+        ds.revision += 1;
+        let (uid, doc) = (ds.uid, ds.doc.clone());
+        if self.clipboard.source_doc == uid {
+            self.clipboard.copied_components.retain(|id| {
+                doc.node(*id)
+                    .is_some_and(|n| matches!(n.kind, figcraft_doc::NodeKind::Component { .. } | figcraft_doc::NodeKind::ComponentSet { .. }))
+            });
+        }
+        Ok(true)
+    }
+
+    pub fn redo(&mut self) -> Result<bool> {
+        textpreview::end(self);
+        let live = self.ds().is_ok_and(|d| self.live_doc(d.uid));
+        let ds = self.ds_mut()?;
+        if ds.preview.is_some() {
+            return Err(EngineError::Disabled("edit.redo".into(), PREVIEW_READ_ONLY.into()));
+        }
+        if let Some(it) = ds.interaction.take()
+            && live
+        {
+            ds.doc = it.doc;
+        }
+        ds.text_edit = None;
+        if live {
+            return Ok(self.live_travel(false));
+        }
+        let Some(e) = ds.history.redo.pop() else { return Ok(false) };
+        let undo = HistoryEntry { label: e.label.clone(), doc: ds.doc.clone(), selection: ds.selection.clone(), page: ds.page };
+        ds.doc = e.doc;
+        cmd::facilitate::keep(&undo.doc, &mut ds.doc);
+        ds.history.undo.push(undo);
+        ds.selection = e.selection;
+        if ds.doc.pages.contains(&e.page) {
+            ds.page = e.page;
+        }
+        ds.clean_selection();
+        ds.revision += 1;
+        Ok(true)
+    }
+
+    /// Queue a UI request (dialogs etc.).
+    pub fn request_ui(&mut self, kind: &str, data: Value) {
+        self.ui_requests.push(UiRequest { kind: kind.to_string(), data });
+    }
+
+    /// Run several commands as one undo step. A param value `{"$step": n}` is replaced by the `id`
+    /// in the result of the earlier step `n`, and `{"$ref": "name"}` by the `id` in the result of
+    /// the earlier step whose `as` is `name`; either takes a `field`, a key or slash path (`ids/0`)
+    /// into that result. So a step can target a layer that an earlier step of the same batch
+    /// created. Any object with a `$step` or `$ref` key in a step's params is such a reference,
+    /// except inside a nested `command.batch` step: its references are to its own steps.
+    pub fn batch(&mut self, label: &str, steps: &[BatchStep]) -> Result<Vec<Value>> {
+        let mut scope = BatchScope::new(steps)?;
+        self.grouped(label, |s| {
+            for step in steps {
+                s.batch_step(&mut scope, &step.command, &step.params)?;
+            }
+            Ok(scope.into_results())
+        })
+    }
+
+    /// The next step of a batch: the references in `params` resolve against `scope` (the steps
+    /// before it), the command runs and its result joins `scope`. [`Session::batch`] runs a list
+    /// of these as one undo step; a caller with its own list — the CLI's script runner — uses this
+    /// so its steps resolve references the same way, inside its own [`Session::grouped`].
+    pub fn batch_step(&mut self, scope: &mut BatchScope, cmd: &str, params: &Value) -> Result<()> {
+        let p = if cmd == "command.batch" { params.clone() } else { scope.resolve(params)? };
+        // Say which step failed; a nested batch names its own steps.
+        let v = self.execute(cmd, &p).map_err(|e| if cmd == "command.batch" { e } else { e.at_step(scope.next_step()) })?;
+        scope.push(v);
+        Ok(())
+    }
+
+    /// Take the tabs `pred` matches out of `docs`; inside a group they are kept so that a failed
+    /// group can reopen them.
+    pub(crate) fn remove_tabs(&mut self, mut pred: impl FnMut(&DocState) -> bool) {
+        let (gone, keep): (Vec<_>, Vec<_>) = std::mem::take(&mut self.docs).into_iter().partition(|d| pred(d));
+        self.docs = keep;
+        if self.group_depth > 0 {
+            self.closed_in_group.extend(gone);
+        }
+    }
+
+    /// Run `f` as one undo step called `label`: the commands it executes push no steps of their
+    /// own, and when it fails the documents stay at their group-start state.
+    pub fn grouped<T>(&mut self, label: &str, f: impl FnOnce(&mut Self) -> Result<T>) -> Result<T> {
+        self.ds()?;
+        let before: Vec<_> =
+            self.docs.iter().map(|ds| (ds.uid, ds.doc.clone(), ds.selection.clone(), ds.page, ds.history.undo.len(), ds.history.limit)).collect();
+        // An edit inside clears the redo steps; a failed group has to bring them back.
+        let redo_before: Vec<_> = self.docs.iter().map(|ds| ds.history.redo.clone()).collect();
+        let active = self.active;
+        let journal_len = self.journal.len();
+
+        // The steps inside are dropped again below, so they mustn't push the oldest ones out.
+        for ds in &mut self.docs {
+            ds.history.limit = usize::MAX;
+        }
+        for (uid, _, _, _, _, _) in &before {
+            self.live_hold(*uid, true);
+        }
+        self.group_depth += 1;
+        let result = f(self);
+        self.group_depth -= 1;
+        for (uid, _, _, _, _, _) in &before {
+            self.live_hold(*uid, false);
+        }
+
+        if result.is_err() {
+            // Tabs the group closed come back from the stash, and the group-start order returns.
+            let mut current = std::mem::take(&mut self.docs);
+            for (uid, ..) in &before {
+                let tab = match current.iter().position(|d| d.uid == *uid) {
+                    Some(i) => Some(current.swap_remove(i)),
+                    None => self.closed_in_group.iter().position(|d| d.uid == *uid).map(|i| self.closed_in_group.swap_remove(i)),
+                };
+                self.docs.extend(tab);
+            }
+            for ((uid, doc, selection, page, undo_len, limit), redo) in before.iter().zip(redo_before) {
+                if let Some(ds) = self.docs.iter_mut().find(|ds| ds.uid == *uid) {
+                    ds.history.redo = redo;
+                    ds.doc = doc.clone();
+                    ds.selection = selection.clone();
+                    ds.page = *page;
+                    ds.history.undo.truncate(*undo_len);
+                    ds.history.limit = *limit;
+                }
+            }
+            self.active = active;
+            self.journal.truncate(journal_len);
+            if self.group_depth == 0 {
+                self.closed_in_group.clear();
+            }
+            return result;
+        }
+        if self.group_depth == 0 {
+            self.closed_in_group.clear();
+        }
+
+        let changed: Vec<_> = before
+            .iter()
+            .filter_map(|(uid, doc, selection, page, _, _)| {
+                let ds = self.docs.iter().find(|d| d.uid == *uid)?;
+                (!Arc::ptr_eq(doc, &ds.doc) && ds.interaction.is_none()).then(|| (*uid, doc.clone(), selection.clone(), *page))
+            })
+            .collect();
+        for ds in &mut self.docs {
+            if let Some((_, _, _, _, undo_len, limit)) = before.iter().find(|before| before.0 == ds.uid) {
+                ds.history.limit = *limit;
+                ds.history.undo.truncate(*undo_len);
+            }
+        }
+        for (uid, doc, selection, page) in changed {
+            self.record(uid, Some(label), doc, selection, page);
+        }
+        result
+    }
+
+    /// A summary for status displays.
+    pub fn status(&self) -> Value {
+        match self.ds() {
+            Ok(ds) => json!({
+                "document": ds.doc.name,
+                "path": ds.path,
+                "dirty": ds.is_dirty(),
+                "page": ds.page,
+                "selection": ds.selection,
+                "tool": self.tool.tool.id(),
+                "zoom": ds.view.zoom,
+                "undo": self.undo_depth().0,
+                "redo": self.undo_depth().1,
+                "documents": self.docs.len(),
+            }),
+            Err(_) => json!({"documents": 0}),
+        }
+    }
+}
diff --git a/crates/engine/src/view_state.rs b/crates/engine/src/view_state.rs
new file mode 100644
index 00000000..e162f039
--- /dev/null
+++ b/crates/engine/src/view_state.rs
@@ -0,0 +1,136 @@
+use super::*;
+
+/// The canvas view of a document: what's at the centre of the viewport and the zoom.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct ViewState {
+    /// Page coordinate at the viewport centre.
+    pub cx: f64,
+    pub cy: f64,
+    /// Zoom (1 = 100%).
+    pub zoom: f64,
+    /// Viewport size in logical pixels (set by the UI; used by zoom-to-fit).
+    pub vw: f64,
+    pub vh: f64,
+    pub pixel_grid: bool,
+    pub layout_grids: bool,
+    pub rulers: bool,
+    pub outlines: bool,
+    /// Outline mode for the selected layers only (the rest draws normally).
+    pub outlines_selection: bool,
+    /// Outline mode also outlines hidden layers (View ▸ Outlines ▸ Include hidden layers).
+    pub outline_hidden: bool,
+    /// Outline mode also draws every layer's box (View ▸ Outlines ▸ Include object bounds).
+    pub outline_bounds: bool,
+    /// Outline the masks (they don't draw themselves).
+    pub mask_outlines: bool,
+    pub pixel_preview: bool,
+    /// Pixel preview resolution: rendered pixels per page pixel (1 or 2).
+    pub pixel_scale: u8,
+    pub show_slices: bool,
+    pub comments: bool,
+    /// Others' cursors in a live session (View ▸ Multiplayer cursors).
+    pub multiplayer_cursors: bool,
+    pub frame_outlines: bool,
+    /// Soft-proof sRGB: the canvas marks the colours of a Display P3 file that sRGB can't show.
+    pub proof_srgb: bool,
+    pub snap_geometry: bool,
+    pub snap_objects: bool,
+    pub snap_pixel: bool,
+    pub ui_hidden: bool,
+}
+
+impl Default for ViewState {
+    fn default() -> Self {
+        Self {
+            cx: 0.0,
+            cy: 0.0,
+            zoom: 1.0,
+            vw: 1200.0,
+            vh: 800.0,
+            pixel_grid: true,
+            layout_grids: true,
+            rulers: false,
+            outlines: false,
+            outlines_selection: false,
+            outline_hidden: false,
+            outline_bounds: false,
+            mask_outlines: false,
+            pixel_preview: false,
+            pixel_scale: 1,
+            show_slices: false,
+            comments: true,
+            multiplayer_cursors: true,
+            frame_outlines: false,
+            proof_srgb: false,
+            snap_geometry: true,
+            snap_objects: true,
+            snap_pixel: true,
+            ui_hidden: false,
+        }
+    }
+}
+
+impl ViewState {
+    pub const MIN_ZOOM: f64 = 0.02;
+    pub const MAX_ZOOM: f64 = 256.0;
+    /// Page coordinate at the viewport's top-left.
+    pub fn origin(&self) -> (f64, f64) {
+        let z = self.zoom.max(1e-9);
+        (self.cx - self.vw / 2.0 / z, self.cy - self.vh / 2.0 / z)
+    }
+    pub fn set_zoom_at(&mut self, zoom: f64, anchor: (f64, f64)) {
+        let z = if zoom.is_finite() { zoom.clamp(Self::MIN_ZOOM, Self::MAX_ZOOM) } else { self.zoom };
+        let old = self.zoom.max(1e-9);
+        // Keep the page point under `anchor` fixed.
+        self.cx = anchor.0 + (self.cx - anchor.0) * old / z;
+        self.cy = anchor.1 + (self.cy - anchor.1) * old / z;
+        self.zoom = z;
+    }
+    /// Fit a page rectangle into the viewport with margin.
+    pub fn fit(&mut self, r: figcraft_geom::Rect, max_zoom: f64) {
+        if !(r.width() > 0.0 || r.height() > 0.0) || !r.x0.is_finite() {
+            self.cx = r.center().x;
+            self.cy = r.center().y;
+            return;
+        }
+        let margin = 64.0;
+        let zx = (self.vw - margin * 2.0).max(50.0) / r.width().max(1e-6);
+        let zy = (self.vh - margin * 2.0).max(50.0) / r.height().max(1e-6);
+        self.zoom = zx.min(zy).clamp(Self::MIN_ZOOM, max_zoom);
+        self.cx = r.center().x;
+        self.cy = r.center().y;
+    }
+    /// The zoom from which the pixel grid shows (400%).
+    pub const PIXEL_GRID_ZOOM: f64 = 4.0;
+    /// Whether the pixel grid draws: it's on and the canvas is zoomed in to 400% or more.
+    pub fn pixel_grid_shown(&self) -> bool {
+        self.pixel_grid && self.zoom >= Self::PIXEL_GRID_ZOOM - 1e-9
+    }
+    /// Pixel preview's resolution (rendered pixels per page pixel) when it's on and zoomed in past
+    /// it; below that the canvas is already coarser than the preview.
+    pub fn pixel_preview_scale(&self) -> Option<f64> {
+        let k = f64::from(self.pixel_scale.clamp(1, 2));
+        (self.pixel_preview && self.zoom > k).then_some(k)
+    }
+    /// A wheel or trackpad scroll of (`dx`, `dy`) screen points: the canvas pans with it (content
+    /// follows the fingers); with Shift a plain vertical wheel pans sideways.
+    pub fn scroll(&mut self, dx: f64, dy: f64, shift: bool) {
+        let (dx, dy) = if shift && dx == 0.0 { (dy, 0.0) } else { (dx, dy) };
+        if !(dx.is_finite() && dy.is_finite()) {
+            return;
+        }
+        let z = self.zoom.max(1e-6);
+        self.cx -= dx / z;
+        self.cy -= dy / z;
+    }
+    pub fn page_to_screen(&self, x: f64, y: f64) -> (f64, f64) {
+        let (ox, oy) = self.origin();
+        ((x - ox) * self.zoom, (y - oy) * self.zoom)
+    }
+    pub fn screen_to_page(&self, x: f64, y: f64) -> (f64, f64) {
+        let (ox, oy) = self.origin();
+        let z = self.zoom.max(1e-9);
+        (ox + x / z, oy + y / z)
+    }
+}

From 1e9e0a4e759f4462d1cf6d2b4516c9ef7d01b9c5 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:26:07 +0000
Subject: [PATCH 32/67] refactor(engine): split session.rs into session/

---
 crates/engine/src/session.rs        | 581 +---------------------------
 crates/engine/src/session/access.rs |  54 +++
 crates/engine/src/session/exec.rs   | 175 +++++++++
 crates/engine/src/session/new.rs    |  84 ++++
 crates/engine/src/session/undo.rs   | 275 +++++++++++++
 5 files changed, 592 insertions(+), 577 deletions(-)
 create mode 100644 crates/engine/src/session/access.rs
 create mode 100644 crates/engine/src/session/exec.rs
 create mode 100644 crates/engine/src/session/new.rs
 create mode 100644 crates/engine/src/session/undo.rs

diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs
index b073b36a..acafd229 100644
--- a/crates/engine/src/session.rs
+++ b/crates/engine/src/session.rs
@@ -4,580 +4,7 @@ use super::error::{EngineError, Result, bad};
 use super::prefs::{Clipboard, Prefs, UiRequest};
 use super::*;
 
-/// Whether a command, or a batch wrapping one, imports a file passed as Base64 `data`.
-fn command_carries_import_bytes(id: &str, params: &Value) -> bool {
-    match id {
-        "file.import" => params::get(params, "data").is_some(),
-        "command.batch" => params.get("commands").and_then(Value::as_array).is_some_and(|commands| {
-            commands.iter().any(|c| {
-                c.get("command").and_then(Value::as_str).zip(c.get("params")).is_some_and(|(id, params)| command_carries_import_bytes(id, params))
-            })
-        }),
-        _ => false,
-    }
-}
-
-impl Session {
-    /// A session with one new document.
-    pub fn new() -> Self {
-        let mut s = Self::empty();
-        s.docs.push(DocState::new(Document::new("Untitled"), None));
-        s
-    }
-
-    /// A session with no documents (the home screen).
-    pub fn empty() -> Self {
-        Self {
-            docs: Vec::new(),
-            active: 0,
-            clipboard: Clipboard::default(),
-            prefs: Prefs::default(),
-            tool: tools::ToolState::default(),
-            ui_requests: Vec::new(),
-            ui_dark: None,
-            journal: Vec::new(),
-            group_depth: 0,
-            closed_in_group: Vec::new(),
-            recent_colors: Vec::new(),
-            last_command: None,
-            message: None,
-            libraries: library::Cache::default(),
-            plugins: plugins::Runtime::default(),
-            live: live::Lives::default(),
-            background: background::Background::default(),
-        }
-    }
-
-    /// The background a new file's page gets: the dark page colour while the interface is dark.
-    pub fn new_page_background(&self) -> figcraft_color::Color {
-        if self.ui_dark == Some(true) { figcraft_color::Color::DARK_PAGE } else { figcraft_color::Color::DEFAULT_PAGE }
-    }
-
-    /// Tell the engine the interface's theme (the UI does, every frame). The first time, a new
-    /// file nothing was done to yet (the one the app opened with, made before the theme was
-    /// known) takes the theme's page colour; later changes of theme leave existing pages alone.
-    pub fn set_ui_dark(&mut self, dark: bool) {
-        if self.ui_dark.replace(dark).is_some() || !dark {
-            return;
-        }
-        for ds in &mut self.docs {
-            let untouched = ds.path.is_none() && ds.history.undo.is_empty() && ds.history.redo.is_empty() && !ds.is_dirty() && ds.versions.is_empty();
-            let pages = ds.doc.pages.clone();
-            let blank = pages.iter().all(|p| {
-                ds.doc.node(*p).is_some_and(|n| {
-                    n.children.is_empty()
-                        && matches!(n.kind, figcraft_doc::NodeKind::Page { background, .. } if background == figcraft_color::Color::DEFAULT_PAGE)
-                })
-            });
-            if !(untouched && blank) {
-                continue;
-            }
-            let mut doc = (*ds.doc).clone();
-            for p in pages {
-                if let Some(figcraft_doc::NodeKind::Page { background, .. }) = doc.node_mut(p).map(|n| &mut n.kind) {
-                    *background = figcraft_color::Color::DARK_PAGE;
-                }
-            }
-            // Still a file without changes.
-            ds.doc = Arc::new(doc);
-            ds.saved_doc = ds.doc.clone();
-            ds.revision += 1;
-        }
-    }
-
-    pub fn with_document(doc: Document) -> Self {
-        let mut s = Self::empty();
-        s.docs.push(DocState::new(doc, None));
-        s
-    }
-
-    /// Files new to the session start with the View toggles the preferences keep.
-    pub fn apply_view_prefs(&mut self) {
-        for ds in self.docs.iter_mut().filter(|d| !d.view_from_prefs) {
-            cmd::view::apply_kept(&self.prefs, &mut ds.view);
-            ds.view_from_prefs = true;
-        }
-    }
-
-    pub fn ds(&self) -> Result<&DocState> {
-        self.docs.get(self.active).ok_or(EngineError::NoDocument)
-    }
-
-    pub fn ds_mut(&mut self) -> Result<&mut DocState> {
-        self.docs.get_mut(self.active).ok_or(EngineError::NoDocument)
-    }
-
-    pub fn doc(&self) -> Result<&Document> {
-        Ok(self.ds()?.doc.as_ref())
-    }
-
-    pub fn doc_mut(&mut self) -> Result<&mut Document> {
-        Ok(self.ds_mut()?.doc_mut())
-    }
-
-    pub fn selection(&self) -> Vec<NodeId> {
-        self.ds().map(|d| d.selection.clone()).unwrap_or_default()
-    }
-
-    pub fn set_selection(&mut self, ids: Vec<NodeId>) {
-        if let Ok(ds) = self.ds_mut() {
-            ds.selection = ids;
-            ds.clean_selection();
-            ds.revision += 1;
-        }
-    }
-
-    pub fn page(&self) -> Result<NodeId> {
-        Ok(self.ds()?.page)
-    }
-
-    /// Run a command by id. Mutations become one undo step; a failure or panic leaves the document
-    /// as it was.
-    pub fn execute(&mut self, id: &str, params: &Value) -> Result<Value> {
-        let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
-        board::refuse_on_board(self, id)?;
-        // Revert replaces the document's uid: refuse before ending previews or syncing branches.
-        if id == "file.revert" && self.live().doc_uid.is_some() {
-            return Err(EngineError::Disabled(id.into(), "leave the live session before reverting to the saved file".into()));
-        }
-        branches::sync(self);
-        self.apply_view_prefs();
-        if textpreview::COMMANDS.contains(&id) {
-            // A live preview is no edit: no undo step, normalisation or rollback here.
-            let r = guard::run(id, || (spec.run)(self, params));
-            if r.is_err() {
-                textpreview::end(self);
-            }
-            return r;
-        }
-        // Every other command acts on the document itself, not on a live text preview.
-        textpreview::end(self);
-        if ENDS_PREVIEW.contains(&id)
-            && (!matches!(id, "file.save" | "file.saveAs") || cmd::file::save_ends_preview(self, id, params))
-            && let Ok(ds) = self.ds_mut()
-        {
-            ds.end_preview();
-        }
-        let before = self.ds().ok().map(|d| (d.doc.clone(), d.selection.clone(), d.page, d.uid));
-        // Cut and copy write the clipboard before a later check can refuse the command.
-        let clipboard_before = self.clipboard.clone();
-        let result = guard::run(id, || (spec.run)(self, params))
-            .and_then(|v| self.check_instance_structure(id, &before).map(|()| v))
-            .and_then(|v| self.check_preview(id, &before).map(|()| v))
-            .and_then(|v| self.check_live_access(id, &before).map(|()| v))
-            .and_then(|v| self.check_finite_geometry(id, &before).map(|()| v));
-        match &result {
-            Ok(_) => {
-                self.after_command(spec, before);
-                self.apply_view_prefs();
-                if spec.history && id != "edit.repeat" {
-                    self.last_command = Some((id.to_string(), params.clone()));
-                }
-                // Imported bytes already live in the document: a Base64 copy in the log would stay
-                // for the whole session.
-                if !command_carries_import_bytes(id, params) {
-                    self.journal.push((id.to_string(), params.clone()));
-                    if self.journal.len() > 5000 {
-                        self.journal.drain(..1000);
-                    }
-                }
-            }
-            Err(_) => {
-                // Roll back any partial edit — also during an interaction, where `before` is the
-                // interaction's last valid preview: restore it and leave the gesture itself (its
-                // own snapshot) alone.
-                if let Some((doc, sel, page, uid)) = before
-                    && let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid)
-                {
-                    ds.doc = doc;
-                    ds.selection = sel;
-                    ds.page = page;
-                }
-                self.clipboard = clipboard_before;
-            }
-        }
-        result
-    }
-
-    /// A version shown in place of the document is read-only: refuse an edit (it is rolled back).
-    fn check_preview(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
-        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
-        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
-        if ds.preview.is_none() || Arc::ptr_eq(&ds.doc, bdoc) || id == "version.preview" {
-            return Ok(());
-        }
-        Err(EngineError::Disabled(id.to_string(), PREVIEW_READ_ONLY.into()))
-    }
-
-    /// A layer's position and size stay finite: infinity and NaN are written as `null`, so a file
-    /// holding them saves but can't be reopened. Refuse such an edit (it is rolled back).
-    fn check_finite_geometry(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
-        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
-        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
-        if Arc::ptr_eq(&ds.doc, bdoc) {
-            return Ok(());
-        }
-        let broken = |n: &Node| !(n.transform.as_coeffs().iter().all(|c| c.is_finite()) && n.width.is_finite() && n.height.is_finite());
-        let untouched = |n: &Node| bdoc.node_arc(n.id).zip(ds.doc.node_arc(n.id)).is_some_and(|(a, b)| Arc::ptr_eq(a, b));
-        match ds.doc.nodes().find(|n| broken(n) && !untouched(n)) {
-            Some(n) => Err(bad(id, format!("\"{}\" would get a position or size beyond the number range", n.name))),
-            None => Ok(()),
-        }
-    }
-
-    /// A live session's document you may only view (or that is on its way to a server) is
-    /// read-only: refuse an edit (it is rolled back).
-    fn check_live_access(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
-        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
-        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
-        match self.live_read_only(*uid) {
-            Some(why) if !Arc::ptr_eq(&ds.doc, bdoc) => Err(EngineError::Disabled(id.to_string(), why.into())),
-            _ => Ok(()),
-        }
-    }
-
-    /// Instances can't gain, lose or reorder layers, nor move, resize or re-constrain the layers in
-    /// them, and library copies are read-only: refuse such an edit (it is rolled back).
-    pub(crate) fn check_instance_structure(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
-        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
-        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
-        if Arc::ptr_eq(&ds.doc, bdoc) {
-            return Ok(());
-        }
-        // "Repeat" runs the repeated command.
-        let effective = match (&self.last_command, id) {
-            (Some((last, _)), "edit.repeat") => last.as_str(),
-            _ => id,
-        };
-        library::check_read_only(effective, bdoc, &ds.doc)
-            .and_then(|()| components::check_structure_edit(bdoc, &ds.doc))
-            .and_then(|()| components::check_override_edit(bdoc, &ds.doc))
-            .map_err(|m| EngineError::Disabled(id.to_string(), m))
-    }
-
-    /// Bookkeeping after a successful command: normalise what changed, push undo, bump revision.
-    fn after_command(&mut self, spec: &CommandSpec, before: Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) {
-        let Some((bdoc, bsel, bpage, uid)) = before else {
-            if let Ok(ds) = self.ds_mut() {
-                ds.revision += 1;
-            }
-            return;
-        };
-        let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) else { return };
-        let changed = !Arc::ptr_eq(&ds.doc, &bdoc);
-        // Saving may adopt the chosen filename as the document title. The encoded snapshot is
-        // already final; normalising it again would detach it from the saved baseline.
-        if changed && !matches!(spec.id, "file.save" | "file.saveAs") {
-            normalize(ds.doc_mut(), &bdoc);
-        }
-        let edit = changed && ds.interaction.is_none();
-        ds.clean_selection();
-        ds.revision += 1;
-        if edit {
-            self.record(uid, spec.history.then_some(spec.label), bdoc, bsel, bpage);
-        }
-    }
-
-    /// Record an edit of document `uid` (it was `before`, shown with `selection` on `page`) as one
-    /// undo step called `label` (`None`: not undoable). On a live session's document the edit is
-    /// synced and the step is the user's own ([`live`]); otherwise it is a snapshot of `before`.
-    pub(crate) fn record(&mut self, uid: u64, label: Option<&str>, before: Arc<Document>, selection: Vec<NodeId>, page: NodeId) {
-        if self.live_doc(uid) {
-            return self.live_edit(uid, label);
-        }
-        if let (Some(label), Some(ds)) = (label, self.docs.iter_mut().find(|d| d.uid == uid)) {
-            ds.push_undo(label, before, selection, page);
-        }
-    }
-
-    /// How many undo and redo steps the active document has (the user's own in a live session).
-    pub fn undo_depth(&self) -> (usize, usize) {
-        match self.ds() {
-            Ok(ds) if self.live_doc(ds.uid) => self.live().client().map_or((0, 0), figcraft_collab::Client::history_len),
-            Ok(ds) => (ds.history.undo.len(), ds.history.redo.len()),
-            Err(_) => (0, 0),
-        }
-    }
-
-    /// The labels of the active document's last `n` undo steps, the next one first.
-    pub fn undo_labels(&self, n: usize) -> Vec<String> {
-        match self.ds() {
-            Ok(ds) if self.live_doc(ds.uid) => {
-                self.live().client().map(|c| c.undo_labels().rev().take(n).map(str::to_string).collect()).unwrap_or_default()
-            }
-            Ok(ds) => ds.history.undo.iter().rev().take(n).map(|h| h.label.clone()).collect(),
-            Err(_) => Vec::new(),
-        }
-    }
-
-    /// Start a gesture: later [`preview`](Self::preview) calls re-apply edits to this snapshot.
-    pub fn begin_interaction(&mut self, label: &str) -> Result<()> {
-        textpreview::end(self);
-        if let Some(why) = self.active_read_only() {
-            return Err(EngineError::Disabled(label.to_string(), why.into()));
-        }
-        let ds = self.ds_mut()?;
-        if ds.preview.is_some() {
-            return Err(EngineError::Disabled(label.to_string(), PREVIEW_READ_ONLY.into()));
-        }
-        if ds.interaction.is_none() {
-            ds.interaction = Some(Interaction { label: label.to_string(), doc: ds.doc.clone(), selection: ds.selection.clone() });
-        }
-        Ok(())
-    }
-
-    /// Replace the document with `f(snapshot)` for a live preview during a gesture.
-    pub fn preview(&mut self, f: impl FnOnce(&mut Document, &mut Vec<NodeId>) -> Result<()>) -> Result<()> {
-        let ds = self.ds_mut()?;
-        let Some(it) = ds.interaction.clone() else { return Err(EngineError::Other("no gesture in progress".into())) };
-        let mut doc = (*it.doc).clone();
-        let mut sel = it.selection.clone();
-        // What the gesture changes on the selected layers is an explicit edit.
-        let before = cmd::styles::bound_before(&doc, &it.selection);
-        let res = f(&mut doc, &mut sel);
-        if res.is_ok() {
-            cmd::styles::detach_edited(&mut doc, &before);
-            normalize(&mut doc, &it.doc);
-            // The same preview again (a handle held still) keeps the document: a new one would
-            // re-render the canvas for nothing.
-            if doc == *ds.doc && sel == ds.selection {
-                return res;
-            }
-            ds.doc = Arc::new(doc);
-            ds.selection = sel;
-            ds.clean_selection();
-            ds.revision += 1;
-        }
-        res
-    }
-
-    /// Finish a gesture as one undo step (no step if nothing changed).
-    pub fn commit_interaction(&mut self) -> Result<()> {
-        let ds = self.ds_mut()?;
-        let Some(it) = ds.interaction.take() else { return Ok(()) };
-        let (uid, page) = (ds.uid, ds.page);
-        ds.revision += 1;
-        if !Arc::ptr_eq(&it.doc, &ds.doc) && *it.doc != *ds.doc {
-            self.record(uid, Some(&it.label), it.doc, it.selection, page);
-        } else {
-            ds.doc = it.doc;
-        }
-        Ok(())
-    }
-
-    /// Abandon a gesture, restoring the document.
-    pub fn cancel_interaction(&mut self) -> Result<()> {
-        let ds = self.ds_mut()?;
-        if let Some(it) = ds.interaction.take() {
-            ds.doc = it.doc;
-            ds.selection = it.selection;
-            ds.revision += 1;
-        }
-        Ok(())
-    }
-
-    pub fn undo(&mut self) -> Result<bool> {
-        textpreview::end(self);
-        let live = self.ds().is_ok_and(|d| self.live_doc(d.uid));
-        let ds = self.ds_mut()?;
-        if ds.preview.is_some() {
-            return Err(EngineError::Disabled("edit.undo".into(), PREVIEW_READ_ONLY.into()));
-        }
-        if let Some(it) = ds.interaction.take()
-            && live
-        {
-            // The gesture in progress is dropped (it was never synced).
-            ds.doc = it.doc;
-        }
-        ds.text_edit = None;
-        if live {
-            return Ok(self.live_travel(true));
-        }
-        let Some(e) = ds.history.undo.pop() else { return Ok(false) };
-        let redo = HistoryEntry { label: e.label.clone(), doc: ds.doc.clone(), selection: ds.selection.clone(), page: ds.page };
-        ds.doc = e.doc;
-        cmd::facilitate::keep(&redo.doc, &mut ds.doc);
-        ds.history.redo.push(redo);
-        ds.selection = e.selection;
-        if ds.doc.pages.contains(&e.page) {
-            ds.page = e.page;
-        }
-        ds.clean_selection();
-        ds.revision += 1;
-        let (uid, doc) = (ds.uid, ds.doc.clone());
-        if self.clipboard.source_doc == uid {
-            self.clipboard.copied_components.retain(|id| {
-                doc.node(*id)
-                    .is_some_and(|n| matches!(n.kind, figcraft_doc::NodeKind::Component { .. } | figcraft_doc::NodeKind::ComponentSet { .. }))
-            });
-        }
-        Ok(true)
-    }
-
-    pub fn redo(&mut self) -> Result<bool> {
-        textpreview::end(self);
-        let live = self.ds().is_ok_and(|d| self.live_doc(d.uid));
-        let ds = self.ds_mut()?;
-        if ds.preview.is_some() {
-            return Err(EngineError::Disabled("edit.redo".into(), PREVIEW_READ_ONLY.into()));
-        }
-        if let Some(it) = ds.interaction.take()
-            && live
-        {
-            ds.doc = it.doc;
-        }
-        ds.text_edit = None;
-        if live {
-            return Ok(self.live_travel(false));
-        }
-        let Some(e) = ds.history.redo.pop() else { return Ok(false) };
-        let undo = HistoryEntry { label: e.label.clone(), doc: ds.doc.clone(), selection: ds.selection.clone(), page: ds.page };
-        ds.doc = e.doc;
-        cmd::facilitate::keep(&undo.doc, &mut ds.doc);
-        ds.history.undo.push(undo);
-        ds.selection = e.selection;
-        if ds.doc.pages.contains(&e.page) {
-            ds.page = e.page;
-        }
-        ds.clean_selection();
-        ds.revision += 1;
-        Ok(true)
-    }
-
-    /// Queue a UI request (dialogs etc.).
-    pub fn request_ui(&mut self, kind: &str, data: Value) {
-        self.ui_requests.push(UiRequest { kind: kind.to_string(), data });
-    }
-
-    /// Run several commands as one undo step. A param value `{"$step": n}` is replaced by the `id`
-    /// in the result of the earlier step `n`, and `{"$ref": "name"}` by the `id` in the result of
-    /// the earlier step whose `as` is `name`; either takes a `field`, a key or slash path (`ids/0`)
-    /// into that result. So a step can target a layer that an earlier step of the same batch
-    /// created. Any object with a `$step` or `$ref` key in a step's params is such a reference,
-    /// except inside a nested `command.batch` step: its references are to its own steps.
-    pub fn batch(&mut self, label: &str, steps: &[BatchStep]) -> Result<Vec<Value>> {
-        let mut scope = BatchScope::new(steps)?;
-        self.grouped(label, |s| {
-            for step in steps {
-                s.batch_step(&mut scope, &step.command, &step.params)?;
-            }
-            Ok(scope.into_results())
-        })
-    }
-
-    /// The next step of a batch: the references in `params` resolve against `scope` (the steps
-    /// before it), the command runs and its result joins `scope`. [`Session::batch`] runs a list
-    /// of these as one undo step; a caller with its own list — the CLI's script runner — uses this
-    /// so its steps resolve references the same way, inside its own [`Session::grouped`].
-    pub fn batch_step(&mut self, scope: &mut BatchScope, cmd: &str, params: &Value) -> Result<()> {
-        let p = if cmd == "command.batch" { params.clone() } else { scope.resolve(params)? };
-        // Say which step failed; a nested batch names its own steps.
-        let v = self.execute(cmd, &p).map_err(|e| if cmd == "command.batch" { e } else { e.at_step(scope.next_step()) })?;
-        scope.push(v);
-        Ok(())
-    }
-
-    /// Take the tabs `pred` matches out of `docs`; inside a group they are kept so that a failed
-    /// group can reopen them.
-    pub(crate) fn remove_tabs(&mut self, mut pred: impl FnMut(&DocState) -> bool) {
-        let (gone, keep): (Vec<_>, Vec<_>) = std::mem::take(&mut self.docs).into_iter().partition(|d| pred(d));
-        self.docs = keep;
-        if self.group_depth > 0 {
-            self.closed_in_group.extend(gone);
-        }
-    }
-
-    /// Run `f` as one undo step called `label`: the commands it executes push no steps of their
-    /// own, and when it fails the documents stay at their group-start state.
-    pub fn grouped<T>(&mut self, label: &str, f: impl FnOnce(&mut Self) -> Result<T>) -> Result<T> {
-        self.ds()?;
-        let before: Vec<_> =
-            self.docs.iter().map(|ds| (ds.uid, ds.doc.clone(), ds.selection.clone(), ds.page, ds.history.undo.len(), ds.history.limit)).collect();
-        // An edit inside clears the redo steps; a failed group has to bring them back.
-        let redo_before: Vec<_> = self.docs.iter().map(|ds| ds.history.redo.clone()).collect();
-        let active = self.active;
-        let journal_len = self.journal.len();
-
-        // The steps inside are dropped again below, so they mustn't push the oldest ones out.
-        for ds in &mut self.docs {
-            ds.history.limit = usize::MAX;
-        }
-        for (uid, _, _, _, _, _) in &before {
-            self.live_hold(*uid, true);
-        }
-        self.group_depth += 1;
-        let result = f(self);
-        self.group_depth -= 1;
-        for (uid, _, _, _, _, _) in &before {
-            self.live_hold(*uid, false);
-        }
-
-        if result.is_err() {
-            // Tabs the group closed come back from the stash, and the group-start order returns.
-            let mut current = std::mem::take(&mut self.docs);
-            for (uid, ..) in &before {
-                let tab = match current.iter().position(|d| d.uid == *uid) {
-                    Some(i) => Some(current.swap_remove(i)),
-                    None => self.closed_in_group.iter().position(|d| d.uid == *uid).map(|i| self.closed_in_group.swap_remove(i)),
-                };
-                self.docs.extend(tab);
-            }
-            for ((uid, doc, selection, page, undo_len, limit), redo) in before.iter().zip(redo_before) {
-                if let Some(ds) = self.docs.iter_mut().find(|ds| ds.uid == *uid) {
-                    ds.history.redo = redo;
-                    ds.doc = doc.clone();
-                    ds.selection = selection.clone();
-                    ds.page = *page;
-                    ds.history.undo.truncate(*undo_len);
-                    ds.history.limit = *limit;
-                }
-            }
-            self.active = active;
-            self.journal.truncate(journal_len);
-            if self.group_depth == 0 {
-                self.closed_in_group.clear();
-            }
-            return result;
-        }
-        if self.group_depth == 0 {
-            self.closed_in_group.clear();
-        }
-
-        let changed: Vec<_> = before
-            .iter()
-            .filter_map(|(uid, doc, selection, page, _, _)| {
-                let ds = self.docs.iter().find(|d| d.uid == *uid)?;
-                (!Arc::ptr_eq(doc, &ds.doc) && ds.interaction.is_none()).then(|| (*uid, doc.clone(), selection.clone(), *page))
-            })
-            .collect();
-        for ds in &mut self.docs {
-            if let Some((_, _, _, _, undo_len, limit)) = before.iter().find(|before| before.0 == ds.uid) {
-                ds.history.limit = *limit;
-                ds.history.undo.truncate(*undo_len);
-            }
-        }
-        for (uid, doc, selection, page) in changed {
-            self.record(uid, Some(label), doc, selection, page);
-        }
-        result
-    }
-
-    /// A summary for status displays.
-    pub fn status(&self) -> Value {
-        match self.ds() {
-            Ok(ds) => json!({
-                "document": ds.doc.name,
-                "path": ds.path,
-                "dirty": ds.is_dirty(),
-                "page": ds.page,
-                "selection": ds.selection,
-                "tool": self.tool.tool.id(),
-                "zoom": ds.view.zoom,
-                "undo": self.undo_depth().0,
-                "redo": self.undo_depth().1,
-                "documents": self.docs.len(),
-            }),
-            Err(_) => json!({"documents": 0}),
-        }
-    }
-}
+mod access;
+mod exec;
+mod new;
+mod undo;
diff --git a/crates/engine/src/session/access.rs b/crates/engine/src/session/access.rs
new file mode 100644
index 00000000..af9fd7f5
--- /dev/null
+++ b/crates/engine/src/session/access.rs
@@ -0,0 +1,54 @@
+use super::*;
+
+impl Session {
+    pub fn ds(&self) -> Result<&DocState> {
+        self.docs.get(self.active).ok_or(EngineError::NoDocument)
+    }
+
+    pub fn ds_mut(&mut self) -> Result<&mut DocState> {
+        self.docs.get_mut(self.active).ok_or(EngineError::NoDocument)
+    }
+
+    pub fn doc(&self) -> Result<&Document> {
+        Ok(self.ds()?.doc.as_ref())
+    }
+
+    pub fn doc_mut(&mut self) -> Result<&mut Document> {
+        Ok(self.ds_mut()?.doc_mut())
+    }
+
+    pub fn selection(&self) -> Vec<NodeId> {
+        self.ds().map(|d| d.selection.clone()).unwrap_or_default()
+    }
+
+    pub fn set_selection(&mut self, ids: Vec<NodeId>) {
+        if let Ok(ds) = self.ds_mut() {
+            ds.selection = ids;
+            ds.clean_selection();
+            ds.revision += 1;
+        }
+    }
+
+    pub fn page(&self) -> Result<NodeId> {
+        Ok(self.ds()?.page)
+    }
+
+    /// A summary for status displays.
+    pub fn status(&self) -> Value {
+        match self.ds() {
+            Ok(ds) => json!({
+                "document": ds.doc.name,
+                "path": ds.path,
+                "dirty": ds.is_dirty(),
+                "page": ds.page,
+                "selection": ds.selection,
+                "tool": self.tool.tool.id(),
+                "zoom": ds.view.zoom,
+                "undo": self.undo_depth().0,
+                "redo": self.undo_depth().1,
+                "documents": self.docs.len(),
+            }),
+            Err(_) => json!({"documents": 0}),
+        }
+    }
+}
diff --git a/crates/engine/src/session/exec.rs b/crates/engine/src/session/exec.rs
new file mode 100644
index 00000000..add12ac5
--- /dev/null
+++ b/crates/engine/src/session/exec.rs
@@ -0,0 +1,175 @@
+use super::*;
+
+/// Whether a command, or a batch wrapping one, imports a file passed as Base64 `data`.
+fn command_carries_import_bytes(id: &str, params: &Value) -> bool {
+    match id {
+        "file.import" => params::get(params, "data").is_some(),
+        "command.batch" => params.get("commands").and_then(Value::as_array).is_some_and(|commands| {
+            commands.iter().any(|c| {
+                c.get("command").and_then(Value::as_str).zip(c.get("params")).is_some_and(|(id, params)| command_carries_import_bytes(id, params))
+            })
+        }),
+        _ => false,
+    }
+}
+
+impl Session {
+    /// Run a command by id. Mutations become one undo step; a failure or panic leaves the document
+    /// as it was.
+    pub fn execute(&mut self, id: &str, params: &Value) -> Result<Value> {
+        let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
+        board::refuse_on_board(self, id)?;
+        // Revert replaces the document's uid: refuse before ending previews or syncing branches.
+        if id == "file.revert" && self.live().doc_uid.is_some() {
+            return Err(EngineError::Disabled(id.into(), "leave the live session before reverting to the saved file".into()));
+        }
+        branches::sync(self);
+        self.apply_view_prefs();
+        if textpreview::COMMANDS.contains(&id) {
+            // A live preview is no edit: no undo step, normalisation or rollback here.
+            let r = guard::run(id, || (spec.run)(self, params));
+            if r.is_err() {
+                textpreview::end(self);
+            }
+            return r;
+        }
+        // Every other command acts on the document itself, not on a live text preview.
+        textpreview::end(self);
+        if ENDS_PREVIEW.contains(&id)
+            && (!matches!(id, "file.save" | "file.saveAs") || cmd::file::save_ends_preview(self, id, params))
+            && let Ok(ds) = self.ds_mut()
+        {
+            ds.end_preview();
+        }
+        let before = self.ds().ok().map(|d| (d.doc.clone(), d.selection.clone(), d.page, d.uid));
+        // Cut and copy write the clipboard before a later check can refuse the command.
+        let clipboard_before = self.clipboard.clone();
+        let result = guard::run(id, || (spec.run)(self, params))
+            .and_then(|v| self.check_instance_structure(id, &before).map(|()| v))
+            .and_then(|v| self.check_preview(id, &before).map(|()| v))
+            .and_then(|v| self.check_live_access(id, &before).map(|()| v))
+            .and_then(|v| self.check_finite_geometry(id, &before).map(|()| v));
+        match &result {
+            Ok(_) => {
+                self.after_command(spec, before);
+                self.apply_view_prefs();
+                if spec.history && id != "edit.repeat" {
+                    self.last_command = Some((id.to_string(), params.clone()));
+                }
+                // Imported bytes already live in the document: a Base64 copy in the log would stay
+                // for the whole session.
+                if !command_carries_import_bytes(id, params) {
+                    self.journal.push((id.to_string(), params.clone()));
+                    if self.journal.len() > 5000 {
+                        self.journal.drain(..1000);
+                    }
+                }
+            }
+            Err(_) => {
+                // Roll back any partial edit — also during an interaction, where `before` is the
+                // interaction's last valid preview: restore it and leave the gesture itself (its
+                // own snapshot) alone.
+                if let Some((doc, sel, page, uid)) = before
+                    && let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid)
+                {
+                    ds.doc = doc;
+                    ds.selection = sel;
+                    ds.page = page;
+                }
+                self.clipboard = clipboard_before;
+            }
+        }
+        result
+    }
+
+    /// A version shown in place of the document is read-only: refuse an edit (it is rolled back).
+    fn check_preview(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
+        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
+        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
+        if ds.preview.is_none() || Arc::ptr_eq(&ds.doc, bdoc) || id == "version.preview" {
+            return Ok(());
+        }
+        Err(EngineError::Disabled(id.to_string(), PREVIEW_READ_ONLY.into()))
+    }
+
+    /// A layer's position and size stay finite: infinity and NaN are written as `null`, so a file
+    /// holding them saves but can't be reopened. Refuse such an edit (it is rolled back).
+    fn check_finite_geometry(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
+        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
+        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
+        if Arc::ptr_eq(&ds.doc, bdoc) {
+            return Ok(());
+        }
+        let broken = |n: &Node| !(n.transform.as_coeffs().iter().all(|c| c.is_finite()) && n.width.is_finite() && n.height.is_finite());
+        let untouched = |n: &Node| bdoc.node_arc(n.id).zip(ds.doc.node_arc(n.id)).is_some_and(|(a, b)| Arc::ptr_eq(a, b));
+        match ds.doc.nodes().find(|n| broken(n) && !untouched(n)) {
+            Some(n) => Err(bad(id, format!("\"{}\" would get a position or size beyond the number range", n.name))),
+            None => Ok(()),
+        }
+    }
+
+    /// A live session's document you may only view (or that is on its way to a server) is
+    /// read-only: refuse an edit (it is rolled back).
+    fn check_live_access(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
+        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
+        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
+        match self.live_read_only(*uid) {
+            Some(why) if !Arc::ptr_eq(&ds.doc, bdoc) => Err(EngineError::Disabled(id.to_string(), why.into())),
+            _ => Ok(()),
+        }
+    }
+
+    /// Instances can't gain, lose or reorder layers, nor move, resize or re-constrain the layers in
+    /// them, and library copies are read-only: refuse such an edit (it is rolled back).
+    pub(crate) fn check_instance_structure(&self, id: &str, before: &Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) -> Result<()> {
+        let Some((bdoc, _, _, uid)) = before else { return Ok(()) };
+        let Some(ds) = self.docs.iter().find(|d| d.uid == *uid) else { return Ok(()) };
+        if Arc::ptr_eq(&ds.doc, bdoc) {
+            return Ok(());
+        }
+        // "Repeat" runs the repeated command.
+        let effective = match (&self.last_command, id) {
+            (Some((last, _)), "edit.repeat") => last.as_str(),
+            _ => id,
+        };
+        library::check_read_only(effective, bdoc, &ds.doc)
+            .and_then(|()| components::check_structure_edit(bdoc, &ds.doc))
+            .and_then(|()| components::check_override_edit(bdoc, &ds.doc))
+            .map_err(|m| EngineError::Disabled(id.to_string(), m))
+    }
+
+    /// Bookkeeping after a successful command: normalise what changed, push undo, bump revision.
+    fn after_command(&mut self, spec: &CommandSpec, before: Option<(Arc<Document>, Vec<NodeId>, NodeId, u64)>) {
+        let Some((bdoc, bsel, bpage, uid)) = before else {
+            if let Ok(ds) = self.ds_mut() {
+                ds.revision += 1;
+            }
+            return;
+        };
+        let Some(ds) = self.docs.iter_mut().find(|d| d.uid == uid) else { return };
+        let changed = !Arc::ptr_eq(&ds.doc, &bdoc);
+        // Saving may adopt the chosen filename as the document title. The encoded snapshot is
+        // already final; normalising it again would detach it from the saved baseline.
+        if changed && !matches!(spec.id, "file.save" | "file.saveAs") {
+            normalize(ds.doc_mut(), &bdoc);
+        }
+        let edit = changed && ds.interaction.is_none();
+        ds.clean_selection();
+        ds.revision += 1;
+        if edit {
+            self.record(uid, spec.history.then_some(spec.label), bdoc, bsel, bpage);
+        }
+    }
+
+    /// Record an edit of document `uid` (it was `before`, shown with `selection` on `page`) as one
+    /// undo step called `label` (`None`: not undoable). On a live session's document the edit is
+    /// synced and the step is the user's own ([`live`]); otherwise it is a snapshot of `before`.
+    pub(crate) fn record(&mut self, uid: u64, label: Option<&str>, before: Arc<Document>, selection: Vec<NodeId>, page: NodeId) {
+        if self.live_doc(uid) {
+            return self.live_edit(uid, label);
+        }
+        if let (Some(label), Some(ds)) = (label, self.docs.iter_mut().find(|d| d.uid == uid)) {
+            ds.push_undo(label, before, selection, page);
+        }
+    }
+}
diff --git a/crates/engine/src/session/new.rs b/crates/engine/src/session/new.rs
new file mode 100644
index 00000000..8790c83b
--- /dev/null
+++ b/crates/engine/src/session/new.rs
@@ -0,0 +1,84 @@
+use super::*;
+
+impl Session {
+    /// A session with one new document.
+    pub fn new() -> Self {
+        let mut s = Self::empty();
+        s.docs.push(DocState::new(Document::new("Untitled"), None));
+        s
+    }
+
+    /// A session with no documents (the home screen).
+    pub fn empty() -> Self {
+        Self {
+            docs: Vec::new(),
+            active: 0,
+            clipboard: Clipboard::default(),
+            prefs: Prefs::default(),
+            tool: tools::ToolState::default(),
+            ui_requests: Vec::new(),
+            ui_dark: None,
+            journal: Vec::new(),
+            group_depth: 0,
+            closed_in_group: Vec::new(),
+            recent_colors: Vec::new(),
+            last_command: None,
+            message: None,
+            libraries: library::Cache::default(),
+            plugins: plugins::Runtime::default(),
+            live: live::Lives::default(),
+            background: background::Background::default(),
+        }
+    }
+
+    /// The background a new file's page gets: the dark page colour while the interface is dark.
+    pub fn new_page_background(&self) -> figcraft_color::Color {
+        if self.ui_dark == Some(true) { figcraft_color::Color::DARK_PAGE } else { figcraft_color::Color::DEFAULT_PAGE }
+    }
+
+    /// Tell the engine the interface's theme (the UI does, every frame). The first time, a new
+    /// file nothing was done to yet (the one the app opened with, made before the theme was
+    /// known) takes the theme's page colour; later changes of theme leave existing pages alone.
+    pub fn set_ui_dark(&mut self, dark: bool) {
+        if self.ui_dark.replace(dark).is_some() || !dark {
+            return;
+        }
+        for ds in &mut self.docs {
+            let untouched = ds.path.is_none() && ds.history.undo.is_empty() && ds.history.redo.is_empty() && !ds.is_dirty() && ds.versions.is_empty();
+            let pages = ds.doc.pages.clone();
+            let blank = pages.iter().all(|p| {
+                ds.doc.node(*p).is_some_and(|n| {
+                    n.children.is_empty()
+                        && matches!(n.kind, figcraft_doc::NodeKind::Page { background, .. } if background == figcraft_color::Color::DEFAULT_PAGE)
+                })
+            });
+            if !(untouched && blank) {
+                continue;
+            }
+            let mut doc = (*ds.doc).clone();
+            for p in pages {
+                if let Some(figcraft_doc::NodeKind::Page { background, .. }) = doc.node_mut(p).map(|n| &mut n.kind) {
+                    *background = figcraft_color::Color::DARK_PAGE;
+                }
+            }
+            // Still a file without changes.
+            ds.doc = Arc::new(doc);
+            ds.saved_doc = ds.doc.clone();
+            ds.revision += 1;
+        }
+    }
+
+    pub fn with_document(doc: Document) -> Self {
+        let mut s = Self::empty();
+        s.docs.push(DocState::new(doc, None));
+        s
+    }
+
+    /// Files new to the session start with the View toggles the preferences keep.
+    pub fn apply_view_prefs(&mut self) {
+        for ds in self.docs.iter_mut().filter(|d| !d.view_from_prefs) {
+            cmd::view::apply_kept(&self.prefs, &mut ds.view);
+            ds.view_from_prefs = true;
+        }
+    }
+}
diff --git a/crates/engine/src/session/undo.rs b/crates/engine/src/session/undo.rs
new file mode 100644
index 00000000..a354ea27
--- /dev/null
+++ b/crates/engine/src/session/undo.rs
@@ -0,0 +1,275 @@
+use super::*;
+
+impl Session {
+    /// How many undo and redo steps the active document has (the user's own in a live session).
+    pub fn undo_depth(&self) -> (usize, usize) {
+        match self.ds() {
+            Ok(ds) if self.live_doc(ds.uid) => self.live().client().map_or((0, 0), figcraft_collab::Client::history_len),
+            Ok(ds) => (ds.history.undo.len(), ds.history.redo.len()),
+            Err(_) => (0, 0),
+        }
+    }
+
+    /// The labels of the active document's last `n` undo steps, the next one first.
+    pub fn undo_labels(&self, n: usize) -> Vec<String> {
+        match self.ds() {
+            Ok(ds) if self.live_doc(ds.uid) => {
+                self.live().client().map(|c| c.undo_labels().rev().take(n).map(str::to_string).collect()).unwrap_or_default()
+            }
+            Ok(ds) => ds.history.undo.iter().rev().take(n).map(|h| h.label.clone()).collect(),
+            Err(_) => Vec::new(),
+        }
+    }
+
+    /// Start a gesture: later [`preview`](Self::preview) calls re-apply edits to this snapshot.
+    pub fn begin_interaction(&mut self, label: &str) -> Result<()> {
+        textpreview::end(self);
+        if let Some(why) = self.active_read_only() {
+            return Err(EngineError::Disabled(label.to_string(), why.into()));
+        }
+        let ds = self.ds_mut()?;
+        if ds.preview.is_some() {
+            return Err(EngineError::Disabled(label.to_string(), PREVIEW_READ_ONLY.into()));
+        }
+        if ds.interaction.is_none() {
+            ds.interaction = Some(Interaction { label: label.to_string(), doc: ds.doc.clone(), selection: ds.selection.clone() });
+        }
+        Ok(())
+    }
+
+    /// Replace the document with `f(snapshot)` for a live preview during a gesture.
+    pub fn preview(&mut self, f: impl FnOnce(&mut Document, &mut Vec<NodeId>) -> Result<()>) -> Result<()> {
+        let ds = self.ds_mut()?;
+        let Some(it) = ds.interaction.clone() else { return Err(EngineError::Other("no gesture in progress".into())) };
+        let mut doc = (*it.doc).clone();
+        let mut sel = it.selection.clone();
+        // What the gesture changes on the selected layers is an explicit edit.
+        let before = cmd::styles::bound_before(&doc, &it.selection);
+        let res = f(&mut doc, &mut sel);
+        if res.is_ok() {
+            cmd::styles::detach_edited(&mut doc, &before);
+            normalize(&mut doc, &it.doc);
+            // The same preview again (a handle held still) keeps the document: a new one would
+            // re-render the canvas for nothing.
+            if doc == *ds.doc && sel == ds.selection {
+                return res;
+            }
+            ds.doc = Arc::new(doc);
+            ds.selection = sel;
+            ds.clean_selection();
+            ds.revision += 1;
+        }
+        res
+    }
+
+    /// Finish a gesture as one undo step (no step if nothing changed).
+    pub fn commit_interaction(&mut self) -> Result<()> {
+        let ds = self.ds_mut()?;
+        let Some(it) = ds.interaction.take() else { return Ok(()) };
+        let (uid, page) = (ds.uid, ds.page);
+        ds.revision += 1;
+        if !Arc::ptr_eq(&it.doc, &ds.doc) && *it.doc != *ds.doc {
+            self.record(uid, Some(&it.label), it.doc, it.selection, page);
+        } else {
+            ds.doc = it.doc;
+        }
+        Ok(())
+    }
+
+    /// Abandon a gesture, restoring the document.
+    pub fn cancel_interaction(&mut self) -> Result<()> {
+        let ds = self.ds_mut()?;
+        if let Some(it) = ds.interaction.take() {
+            ds.doc = it.doc;
+            ds.selection = it.selection;
+            ds.revision += 1;
+        }
+        Ok(())
+    }
+
+    pub fn undo(&mut self) -> Result<bool> {
+        textpreview::end(self);
+        let live = self.ds().is_ok_and(|d| self.live_doc(d.uid));
+        let ds = self.ds_mut()?;
+        if ds.preview.is_some() {
+            return Err(EngineError::Disabled("edit.undo".into(), PREVIEW_READ_ONLY.into()));
+        }
+        if let Some(it) = ds.interaction.take()
+            && live
+        {
+            // The gesture in progress is dropped (it was never synced).
+            ds.doc = it.doc;
+        }
+        ds.text_edit = None;
+        if live {
+            return Ok(self.live_travel(true));
+        }
+        let Some(e) = ds.history.undo.pop() else { return Ok(false) };
+        let redo = HistoryEntry { label: e.label.clone(), doc: ds.doc.clone(), selection: ds.selection.clone(), page: ds.page };
+        ds.doc = e.doc;
+        cmd::facilitate::keep(&redo.doc, &mut ds.doc);
+        ds.history.redo.push(redo);
+        ds.selection = e.selection;
+        if ds.doc.pages.contains(&e.page) {
+            ds.page = e.page;
+        }
+        ds.clean_selection();
+        ds.revision += 1;
+        let (uid, doc) = (ds.uid, ds.doc.clone());
+        if self.clipboard.source_doc == uid {
+            self.clipboard.copied_components.retain(|id| {
+                doc.node(*id)
+                    .is_some_and(|n| matches!(n.kind, figcraft_doc::NodeKind::Component { .. } | figcraft_doc::NodeKind::ComponentSet { .. }))
+            });
+        }
+        Ok(true)
+    }
+
+    pub fn redo(&mut self) -> Result<bool> {
+        textpreview::end(self);
+        let live = self.ds().is_ok_and(|d| self.live_doc(d.uid));
+        let ds = self.ds_mut()?;
+        if ds.preview.is_some() {
+            return Err(EngineError::Disabled("edit.redo".into(), PREVIEW_READ_ONLY.into()));
+        }
+        if let Some(it) = ds.interaction.take()
+            && live
+        {
+            ds.doc = it.doc;
+        }
+        ds.text_edit = None;
+        if live {
+            return Ok(self.live_travel(false));
+        }
+        let Some(e) = ds.history.redo.pop() else { return Ok(false) };
+        let undo = HistoryEntry { label: e.label.clone(), doc: ds.doc.clone(), selection: ds.selection.clone(), page: ds.page };
+        ds.doc = e.doc;
+        cmd::facilitate::keep(&undo.doc, &mut ds.doc);
+        ds.history.undo.push(undo);
+        ds.selection = e.selection;
+        if ds.doc.pages.contains(&e.page) {
+            ds.page = e.page;
+        }
+        ds.clean_selection();
+        ds.revision += 1;
+        Ok(true)
+    }
+
+    /// Queue a UI request (dialogs etc.).
+    pub fn request_ui(&mut self, kind: &str, data: Value) {
+        self.ui_requests.push(UiRequest { kind: kind.to_string(), data });
+    }
+
+    /// Run several commands as one undo step. A param value `{"$step": n}` is replaced by the `id`
+    /// in the result of the earlier step `n`, and `{"$ref": "name"}` by the `id` in the result of
+    /// the earlier step whose `as` is `name`; either takes a `field`, a key or slash path (`ids/0`)
+    /// into that result. So a step can target a layer that an earlier step of the same batch
+    /// created. Any object with a `$step` or `$ref` key in a step's params is such a reference,
+    /// except inside a nested `command.batch` step: its references are to its own steps.
+    pub fn batch(&mut self, label: &str, steps: &[BatchStep]) -> Result<Vec<Value>> {
+        let mut scope = BatchScope::new(steps)?;
+        self.grouped(label, |s| {
+            for step in steps {
+                s.batch_step(&mut scope, &step.command, &step.params)?;
+            }
+            Ok(scope.into_results())
+        })
+    }
+
+    /// The next step of a batch: the references in `params` resolve against `scope` (the steps
+    /// before it), the command runs and its result joins `scope`. [`Session::batch`] runs a list
+    /// of these as one undo step; a caller with its own list — the CLI's script runner — uses this
+    /// so its steps resolve references the same way, inside its own [`Session::grouped`].
+    pub fn batch_step(&mut self, scope: &mut BatchScope, cmd: &str, params: &Value) -> Result<()> {
+        let p = if cmd == "command.batch" { params.clone() } else { scope.resolve(params)? };
+        // Say which step failed; a nested batch names its own steps.
+        let v = self.execute(cmd, &p).map_err(|e| if cmd == "command.batch" { e } else { e.at_step(scope.next_step()) })?;
+        scope.push(v);
+        Ok(())
+    }
+
+    /// Take the tabs `pred` matches out of `docs`; inside a group they are kept so that a failed
+    /// group can reopen them.
+    pub(crate) fn remove_tabs(&mut self, mut pred: impl FnMut(&DocState) -> bool) {
+        let (gone, keep): (Vec<_>, Vec<_>) = std::mem::take(&mut self.docs).into_iter().partition(|d| pred(d));
+        self.docs = keep;
+        if self.group_depth > 0 {
+            self.closed_in_group.extend(gone);
+        }
+    }
+
+    /// Run `f` as one undo step called `label`: the commands it executes push no steps of their
+    /// own, and when it fails the documents stay at their group-start state.
+    pub fn grouped<T>(&mut self, label: &str, f: impl FnOnce(&mut Self) -> Result<T>) -> Result<T> {
+        self.ds()?;
+        let before: Vec<_> =
+            self.docs.iter().map(|ds| (ds.uid, ds.doc.clone(), ds.selection.clone(), ds.page, ds.history.undo.len(), ds.history.limit)).collect();
+        // An edit inside clears the redo steps; a failed group has to bring them back.
+        let redo_before: Vec<_> = self.docs.iter().map(|ds| ds.history.redo.clone()).collect();
+        let active = self.active;
+        let journal_len = self.journal.len();
+
+        // The steps inside are dropped again below, so they mustn't push the oldest ones out.
+        for ds in &mut self.docs {
+            ds.history.limit = usize::MAX;
+        }
+        for (uid, _, _, _, _, _) in &before {
+            self.live_hold(*uid, true);
+        }
+        self.group_depth += 1;
+        let result = f(self);
+        self.group_depth -= 1;
+        for (uid, _, _, _, _, _) in &before {
+            self.live_hold(*uid, false);
+        }
+
+        if result.is_err() {
+            // Tabs the group closed come back from the stash, and the group-start order returns.
+            let mut current = std::mem::take(&mut self.docs);
+            for (uid, ..) in &before {
+                let tab = match current.iter().position(|d| d.uid == *uid) {
+                    Some(i) => Some(current.swap_remove(i)),
+                    None => self.closed_in_group.iter().position(|d| d.uid == *uid).map(|i| self.closed_in_group.swap_remove(i)),
+                };
+                self.docs.extend(tab);
+            }
+            for ((uid, doc, selection, page, undo_len, limit), redo) in before.iter().zip(redo_before) {
+                if let Some(ds) = self.docs.iter_mut().find(|ds| ds.uid == *uid) {
+                    ds.history.redo = redo;
+                    ds.doc = doc.clone();
+                    ds.selection = selection.clone();
+                    ds.page = *page;
+                    ds.history.undo.truncate(*undo_len);
+                    ds.history.limit = *limit;
+                }
+            }
+            self.active = active;
+            self.journal.truncate(journal_len);
+            if self.group_depth == 0 {
+                self.closed_in_group.clear();
+            }
+            return result;
+        }
+        if self.group_depth == 0 {
+            self.closed_in_group.clear();
+        }
+
+        let changed: Vec<_> = before
+            .iter()
+            .filter_map(|(uid, doc, selection, page, _, _)| {
+                let ds = self.docs.iter().find(|d| d.uid == *uid)?;
+                (!Arc::ptr_eq(doc, &ds.doc) && ds.interaction.is_none()).then(|| (*uid, doc.clone(), selection.clone(), *page))
+            })
+            .collect();
+        for ds in &mut self.docs {
+            if let Some((_, _, _, _, undo_len, limit)) = before.iter().find(|before| before.0 == ds.uid) {
+                ds.history.limit = *limit;
+                ds.history.undo.truncate(*undo_len);
+            }
+        }
+        for (uid, doc, selection, page) in changed {
+            self.record(uid, Some(label), doc, selection, page);
+        }
+        result
+    }
+}

From f0f1c2003dfbe32b605fce3ee26ee3a79a8c9b7f Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:26:07 +0000
Subject: [PATCH 33/67] refactor(engine): move cmd/file.rs tab_order_tests to
 file/tab_order_tests.rs

---
 crates/engine/src/cmd/file.rs                 | 21 +------------------
 crates/engine/src/cmd/file/tab_order_tests.rs | 18 ++++++++++++++++
 2 files changed, 19 insertions(+), 20 deletions(-)
 create mode 100644 crates/engine/src/cmd/file/tab_order_tests.rs

diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 13eb21d6..9ebd3ca6 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -1807,26 +1807,7 @@ fn close(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 #[cfg(test)]
-mod tab_order_tests {
-    use super::*;
-
-    #[test]
-    fn moving_and_closing_inactive_tabs_preserves_the_active_document() {
-        let mut session = Session::new();
-        for name in ["Two", "Three", "Four"] {
-            session.execute("file.new", &json!({"name": name})).unwrap();
-        }
-        session.execute("doc.switch", &json!({"index": 2})).unwrap();
-        let active_uid = session.docs[session.active].uid;
-        let moved_uid = session.docs[0].uid;
-        session.execute("file.moveTab", &json!({"from": 0, "to": 2})).unwrap();
-        assert_eq!(session.docs[2].uid, moved_uid);
-        assert_eq!(session.docs[session.active].uid, active_uid);
-        session.execute("file.close", &json!({"index": 0})).unwrap();
-        assert_eq!(session.docs[session.active].uid, active_uid);
-        assert!(session.execute("file.moveTab", &json!({"from": 0, "to": 99})).is_err());
-    }
-}
+mod tab_order_tests;
 
 /// Ctrl+Tab / Ctrl+Shift+Tab: the next or previous open document, wrapping around.
 fn cycle_doc(s: &mut Session, dir: i64) -> Result<Value> {
diff --git a/crates/engine/src/cmd/file/tab_order_tests.rs b/crates/engine/src/cmd/file/tab_order_tests.rs
new file mode 100644
index 00000000..f884ee42
--- /dev/null
+++ b/crates/engine/src/cmd/file/tab_order_tests.rs
@@ -0,0 +1,18 @@
+use super::*;
+
+#[test]
+fn moving_and_closing_inactive_tabs_preserves_the_active_document() {
+    let mut session = Session::new();
+    for name in ["Two", "Three", "Four"] {
+        session.execute("file.new", &json!({"name": name})).unwrap();
+    }
+    session.execute("doc.switch", &json!({"index": 2})).unwrap();
+    let active_uid = session.docs[session.active].uid;
+    let moved_uid = session.docs[0].uid;
+    session.execute("file.moveTab", &json!({"from": 0, "to": 2})).unwrap();
+    assert_eq!(session.docs[2].uid, moved_uid);
+    assert_eq!(session.docs[session.active].uid, active_uid);
+    session.execute("file.close", &json!({"index": 0})).unwrap();
+    assert_eq!(session.docs[session.active].uid, active_uid);
+    assert!(session.execute("file.moveTab", &json!({"from": 0, "to": 99})).is_err());
+}

From 47c807f209cb8e46986f4e25026cb9b5bc41dbc1 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:26:08 +0000
Subject: [PATCH 34/67] refactor(engine): move cmd/file.rs rest_import_tests to
 file/rest_import_tests.rs

---
 crates/engine/src/cmd/file.rs                 | 191 +-----------------
 .../engine/src/cmd/file/rest_import_tests.rs  | 187 +++++++++++++++++
 2 files changed, 188 insertions(+), 190 deletions(-)
 create mode 100644 crates/engine/src/cmd/file/rest_import_tests.rs

diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 9ebd3ca6..3f575135 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -1820,196 +1820,7 @@ fn cycle_doc(s: &mut Session, dir: i64) -> Result<Value> {
 }
 
 #[cfg(test)]
-mod rest_import_tests {
-    use super::*;
-
-    /// A synthetic REST API file JSON: a component with a text layer, an instance of it whose text
-    /// is overridden, and an image fill.
-    fn kit() -> Value {
-        let at = |x: f64, y: f64| json!([[1, 0, x], [0, 1, y]]);
-        let label = |id: &str, text: &str| {
-            json!({"id": id, "name": "Label", "type": "TEXT", "relativeTransform": at(8.0, 8.0), "size": {"x": 40, "y": 20}, "characters": text,
-                   "style": {"fontFamily": "Inter", "fontSize": 14}, "fills": [{"type": "SOLID", "color": {"r": 0, "g": 0, "b": 0, "a": 1}}]})
-        };
-        json!({"name": "Kit", "document": {"id": "0:0", "type": "DOCUMENT", "children": [
-            {"id": "0:1", "name": "Main", "type": "CANVAS", "backgroundColor": {"r": 0.9, "g": 0.9, "b": 0.9, "a": 1}, "children": [
-                {"id": "1:1", "name": "Button", "type": "COMPONENT", "relativeTransform": at(0.0, 0.0), "size": {"x": 100, "y": 40},
-                 "fills": [{"type": "SOLID", "color": {"r": 0.2, "g": 0.4, "b": 1, "a": 1}}], "children": [label("1:2", "OK")]},
-                {"id": "2:1", "name": "Button", "type": "INSTANCE", "componentId": "1:1", "relativeTransform": at(0.0, 100.0), "size": {"x": 100, "y": 40},
-                 "fills": [{"type": "SOLID", "color": {"r": 0.2, "g": 0.4, "b": 1, "a": 1}}], "children": [label("I2:1;1:2", "Go")]},
-                {"id": "3:1", "name": "Photo", "type": "RECTANGLE", "relativeTransform": at(200.0, 0.0), "size": {"x": 30, "y": 20},
-                 "fills": [{"type": "IMAGE", "imageRef": "photo1", "scaleMode": "FILL"}]}
-            ]}
-        ]}, "components": {"1:1": {"key": "k", "name": "Button", "description": ""}}, "styles": {}})
-    }
-
-    fn instance(doc: &Document) -> &Node {
-        doc.nodes().find(|n| matches!(n.kind, NodeKind::Instance { .. })).unwrap()
-    }
-
-    /// What a .fig import with a cached library component leaves: the main in the hidden store, a
-    /// visible instance of it and a layer linked to the main's layer.
-    fn cached_import() -> Document {
-        let mut doc = Document::new("Cached");
-        let page = doc.first_page().unwrap();
-        let store = doc.ensure_library_store();
-        let main = doc
-            .create(store, NodeKind::Component { description: String::new(), props: Default::default() }, "Cached main", 0.0, 0.0, 20.0, 20.0)
-            .unwrap();
-        let body = doc.create(main, NodeKind::Rectangle, "Body", 0.0, 0.0, 20.0, 20.0).unwrap();
-        let inst =
-            doc.create(page, NodeKind::Instance { component: main, props: Default::default() }, "Cached instance", 0.0, 0.0, 20.0, 20.0).unwrap();
-        let mut copy = doc.node(body).unwrap().clone();
-        copy.id = doc.alloc_id();
-        copy.parent = None;
-        copy.source = Some(body);
-        let copy_id = copy.id;
-        doc.insert(copy, inst, None).unwrap();
-        assert!(doc.is_remote(main) && doc.node(copy_id).unwrap().source == Some(body));
-        doc
-    }
-
-    /// Pasting layers that use a cached main into another document leaves the main behind, as it
-    /// does for other mains that are not published: no link points at a layer of the target.
-    #[test]
-    fn pasting_instances_of_cached_components_leaves_no_dangling_links() {
-        let src = cached_import();
-        let mut doc = Document::new("Target");
-        let page = doc.first_page().unwrap();
-        for i in 0..8 {
-            doc.create(page, NodeKind::Rectangle, &format!("Filler {i}"), 0.0, 0.0, 5.0, 5.0).unwrap();
-        }
-        let inst = src.nodes().find(|n| n.name == "Cached instance").unwrap().id;
-        let ids = src.subtree(inst);
-        let map: std::collections::BTreeMap<NodeId, NodeId> = ids.iter().map(|i| (*i, doc.alloc_id())).collect();
-        let nodes: Vec<Node> = ids.iter().filter_map(|i| src.node(*i).cloned()).collect();
-        doc.paste_nodes(&nodes, &map, inst, page, None).unwrap();
-        crate::library::adopt_pasted(&mut doc, &src, None, &map).unwrap();
-        let pasted = doc.node(map[&inst]).unwrap();
-        let NodeKind::Instance { component, .. } = pasted.kind else { panic!() };
-        assert!(!doc.contains(component), "the main stays behind: {component:?}");
-        assert!(doc.node(pasted.children[0]).unwrap().source.is_none_or(|s| !doc.contains(s)));
-    }
-
-    #[test]
-    fn appending_pages_with_cached_library_components_brings_the_components() {
-        let other = cached_import();
-        let mut doc = Document::new("Target");
-        let page = doc.first_page().unwrap();
-        // Ids of the target that would collide with the other document's store.
-        for i in 0..8 {
-            doc.create(page, NodeKind::Rectangle, &format!("Filler {i}"), 0.0, 0.0, 5.0, 5.0).unwrap();
-        }
-        append_pages(&mut doc, &other).unwrap();
-        assert!(doc.validate().is_empty(), "{:?}", doc.validate());
-        assert!(crate::components::mirror_issues(&doc).is_empty(), "{:?}", crate::components::mirror_issues(&doc));
-        let inst = doc.nodes().find(|n| n.name == "Cached instance").unwrap();
-        let NodeKind::Instance { component, .. } = inst.kind else { panic!() };
-        assert_eq!(doc.node(component).unwrap().name, "Cached main");
-        assert!(doc.is_remote(component), "the main comes along into the store");
-        let layer = doc.node(inst.children[0]).unwrap();
-        assert_eq!(layer.source, doc.node(component).unwrap().children.first().copied());
-    }
-
-    #[test]
-    fn rest_json_loads_with_linked_instances() {
-        let bytes = serde_json::to_vec(&kit()).unwrap();
-        let (doc, warnings) = load_bytes(&bytes, "kit.json").unwrap();
-        assert_eq!(doc.name, "Kit");
-        assert!(warnings.iter().any(|w| w.contains("placeholder")), "{warnings:?}");
-        let inst = instance(&doc);
-        let NodeKind::Instance { component, .. } = inst.kind else { panic!() };
-        assert_eq!(inst.source, Some(component));
-        let main_label = doc.node(component).unwrap().children[0];
-        let label = doc.node(inst.children[0]).unwrap();
-        assert_eq!(label.source, Some(main_label));
-        assert!(label.overrides.contains("characters"), "{:?}", label.overrides);
-        assert!(crate::components::mirror_issues(&doc).is_empty());
-        assert!(thumbnail(&doc).is_some());
-    }
-
-    #[test]
-    fn open_takes_data_and_a_name_as_a_new_unsaved_document() {
-        let mut saved = Session::new();
-        saved.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
-        let bytes = file_bytes(saved.ds().unwrap()).unwrap();
-        let data = base64::engine::general_purpose::STANDARD.encode(&bytes);
-        let mut s = Session::new();
-        let recent = s.prefs.recent_files.clone();
-        let r = s.execute("file.open", &json!({"data": data, "name": "Dropped.figcraft"})).unwrap();
-        let open = s.docs.len();
-        assert_eq!(r["index"], open - 1, "a document of its own, made active");
-        assert_eq!(s.ds().unwrap().path, None, "no path to save over");
-        assert!(s.doc().unwrap().nodes().any(|n| matches!(n.kind, NodeKind::Rectangle)));
-        assert_eq!(s.prefs.recent_files, recent, "nothing on disk to remember");
-        assert!(s.execute("file.open", &json!({"data": data})).is_err(), "the name tells the format");
-        assert!(s.execute("file.open", &json!({"data": "not base64!", "name": "x.svg"})).is_err());
-        assert_eq!(s.docs.len(), open, "a refused open adds nothing");
-    }
-
-    #[test]
-    fn save_as_data_hands_back_the_file_and_marks_it_saved_once_delivered() {
-        // The browser has no paths: Save as returns the file for a download (#969).
-        let mut s = Session::new();
-        s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
-        assert!(s.execute("file.saveAs", &json!({})).is_err(), "no path and no data: still asks for a path");
-        let recent = s.prefs.recent_files.clone();
-        let r = s.execute("file.saveAs", &json!({"data": true})).unwrap();
-        assert_eq!(r["name"], "Untitled.figcraft");
-        assert!(s.ds().unwrap().is_dirty(), "not delivered yet: a refused download must not lose the edits");
-        s.execute("file.markSaved", &json!({})).unwrap();
-        assert!(!s.ds().unwrap().is_dirty());
-        assert_eq!(s.ds().unwrap().path, None, "still no path to save over");
-        assert_eq!(s.prefs.recent_files, recent, "nothing on disk to remember");
-        let mut t = Session::new();
-        t.execute("file.open", &json!({"data": r["data"], "name": r["name"]})).unwrap();
-        assert!(t.doc().unwrap().nodes().any(|n| matches!(n.kind, NodeKind::Rectangle)), "the bytes reopen");
-    }
-
-    #[test]
-    fn open_and_import_rest_json() {
-        let dir = std::env::temp_dir().join(format!("figcraft-rest-{}", std::process::id()));
-        std::fs::create_dir_all(dir.join("images")).unwrap();
-        let png = {
-            let mut d = Document::new("x");
-            let p = d.first_page().unwrap();
-            let id = d.create(p, NodeKind::Rectangle, "R", 0.0, 0.0, 3.0, 2.0).unwrap();
-            export_bytes(&d, &[id], ExportFormat::Png, 1.0).unwrap()
-        };
-        std::fs::write(dir.join("images").join("photo1.png"), &png).unwrap();
-        let path = dir.join("kit.json");
-        std::fs::write(&path, serde_json::to_vec(&kit()).unwrap()).unwrap();
-        let path = path.to_string_lossy().to_string();
-
-        let mut s = Session::new();
-        let r = s.execute("file.open", &json!({"path": path})).unwrap();
-        assert!(r["warnings"].as_array().is_some_and(|w| w.iter().all(|w| !w.as_str().unwrap_or("").contains("placeholder"))), "{r}");
-        assert!(r.get("repairs").is_none());
-        assert_eq!(s.ds().unwrap().path, None, "an import is never saved over its JSON");
-        let doc = s.doc().unwrap();
-        let photo = doc.nodes().find(|n| n.name == "Photo").unwrap();
-        let figcraft_color::PaintKind::Image(img) = &photo.fills[0].kind else { panic!() };
-        assert_eq!(doc.images.get(&img.image).map(|i| (i.width, i.height)), Some((3, 2)), "read from images/ next to the file");
-
-        // Import into another document: pages are appended and references follow the new ids.
-        let mut s = Session::new();
-        let data = base64::engine::general_purpose::STANDARD.encode(serde_json::to_vec(&kit()).unwrap());
-        let r = s.execute("file.import", &json!({"data": data, "name": "kit.json"})).unwrap();
-        assert_eq!(r["pages"].as_array().map(Vec::len), Some(1));
-        assert!(r["warnings"].is_array(), "{r}");
-        let doc = s.doc().unwrap();
-        assert_eq!(doc.pages.len(), 2);
-        let page = doc.node(doc.pages[1]).unwrap();
-        assert!(matches!(page.kind, NodeKind::Page { background, .. } if (background.r - 0.9).abs() < 1e-6));
-        let inst = instance(doc);
-        let NodeKind::Instance { component, .. } = inst.kind else { panic!() };
-        assert!(doc.node(component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })));
-        let label = doc.node(inst.children[0]).unwrap();
-        assert!(label.source.is_some_and(|src| doc.is_ancestor(component, src)));
-        assert!(crate::components::mirror_issues(doc).is_empty());
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-}
+mod rest_import_tests;
 
 #[cfg(test)]
 mod staging_write_tests {
diff --git a/crates/engine/src/cmd/file/rest_import_tests.rs b/crates/engine/src/cmd/file/rest_import_tests.rs
new file mode 100644
index 00000000..189edc60
--- /dev/null
+++ b/crates/engine/src/cmd/file/rest_import_tests.rs
@@ -0,0 +1,187 @@
+use super::*;
+
+/// A synthetic REST API file JSON: a component with a text layer, an instance of it whose text
+/// is overridden, and an image fill.
+fn kit() -> Value {
+    let at = |x: f64, y: f64| json!([[1, 0, x], [0, 1, y]]);
+    let label = |id: &str, text: &str| {
+        json!({"id": id, "name": "Label", "type": "TEXT", "relativeTransform": at(8.0, 8.0), "size": {"x": 40, "y": 20}, "characters": text,
+               "style": {"fontFamily": "Inter", "fontSize": 14}, "fills": [{"type": "SOLID", "color": {"r": 0, "g": 0, "b": 0, "a": 1}}]})
+    };
+    json!({"name": "Kit", "document": {"id": "0:0", "type": "DOCUMENT", "children": [
+        {"id": "0:1", "name": "Main", "type": "CANVAS", "backgroundColor": {"r": 0.9, "g": 0.9, "b": 0.9, "a": 1}, "children": [
+            {"id": "1:1", "name": "Button", "type": "COMPONENT", "relativeTransform": at(0.0, 0.0), "size": {"x": 100, "y": 40},
+             "fills": [{"type": "SOLID", "color": {"r": 0.2, "g": 0.4, "b": 1, "a": 1}}], "children": [label("1:2", "OK")]},
+            {"id": "2:1", "name": "Button", "type": "INSTANCE", "componentId": "1:1", "relativeTransform": at(0.0, 100.0), "size": {"x": 100, "y": 40},
+             "fills": [{"type": "SOLID", "color": {"r": 0.2, "g": 0.4, "b": 1, "a": 1}}], "children": [label("I2:1;1:2", "Go")]},
+            {"id": "3:1", "name": "Photo", "type": "RECTANGLE", "relativeTransform": at(200.0, 0.0), "size": {"x": 30, "y": 20},
+             "fills": [{"type": "IMAGE", "imageRef": "photo1", "scaleMode": "FILL"}]}
+        ]}
+    ]}, "components": {"1:1": {"key": "k", "name": "Button", "description": ""}}, "styles": {}})
+}
+
+fn instance(doc: &Document) -> &Node {
+    doc.nodes().find(|n| matches!(n.kind, NodeKind::Instance { .. })).unwrap()
+}
+
+/// What a .fig import with a cached library component leaves: the main in the hidden store, a
+/// visible instance of it and a layer linked to the main's layer.
+fn cached_import() -> Document {
+    let mut doc = Document::new("Cached");
+    let page = doc.first_page().unwrap();
+    let store = doc.ensure_library_store();
+    let main = doc
+        .create(store, NodeKind::Component { description: String::new(), props: Default::default() }, "Cached main", 0.0, 0.0, 20.0, 20.0)
+        .unwrap();
+    let body = doc.create(main, NodeKind::Rectangle, "Body", 0.0, 0.0, 20.0, 20.0).unwrap();
+    let inst = doc.create(page, NodeKind::Instance { component: main, props: Default::default() }, "Cached instance", 0.0, 0.0, 20.0, 20.0).unwrap();
+    let mut copy = doc.node(body).unwrap().clone();
+    copy.id = doc.alloc_id();
+    copy.parent = None;
+    copy.source = Some(body);
+    let copy_id = copy.id;
+    doc.insert(copy, inst, None).unwrap();
+    assert!(doc.is_remote(main) && doc.node(copy_id).unwrap().source == Some(body));
+    doc
+}
+
+/// Pasting layers that use a cached main into another document leaves the main behind, as it
+/// does for other mains that are not published: no link points at a layer of the target.
+#[test]
+fn pasting_instances_of_cached_components_leaves_no_dangling_links() {
+    let src = cached_import();
+    let mut doc = Document::new("Target");
+    let page = doc.first_page().unwrap();
+    for i in 0..8 {
+        doc.create(page, NodeKind::Rectangle, &format!("Filler {i}"), 0.0, 0.0, 5.0, 5.0).unwrap();
+    }
+    let inst = src.nodes().find(|n| n.name == "Cached instance").unwrap().id;
+    let ids = src.subtree(inst);
+    let map: std::collections::BTreeMap<NodeId, NodeId> = ids.iter().map(|i| (*i, doc.alloc_id())).collect();
+    let nodes: Vec<Node> = ids.iter().filter_map(|i| src.node(*i).cloned()).collect();
+    doc.paste_nodes(&nodes, &map, inst, page, None).unwrap();
+    crate::library::adopt_pasted(&mut doc, &src, None, &map).unwrap();
+    let pasted = doc.node(map[&inst]).unwrap();
+    let NodeKind::Instance { component, .. } = pasted.kind else { panic!() };
+    assert!(!doc.contains(component), "the main stays behind: {component:?}");
+    assert!(doc.node(pasted.children[0]).unwrap().source.is_none_or(|s| !doc.contains(s)));
+}
+
+#[test]
+fn appending_pages_with_cached_library_components_brings_the_components() {
+    let other = cached_import();
+    let mut doc = Document::new("Target");
+    let page = doc.first_page().unwrap();
+    // Ids of the target that would collide with the other document's store.
+    for i in 0..8 {
+        doc.create(page, NodeKind::Rectangle, &format!("Filler {i}"), 0.0, 0.0, 5.0, 5.0).unwrap();
+    }
+    append_pages(&mut doc, &other).unwrap();
+    assert!(doc.validate().is_empty(), "{:?}", doc.validate());
+    assert!(crate::components::mirror_issues(&doc).is_empty(), "{:?}", crate::components::mirror_issues(&doc));
+    let inst = doc.nodes().find(|n| n.name == "Cached instance").unwrap();
+    let NodeKind::Instance { component, .. } = inst.kind else { panic!() };
+    assert_eq!(doc.node(component).unwrap().name, "Cached main");
+    assert!(doc.is_remote(component), "the main comes along into the store");
+    let layer = doc.node(inst.children[0]).unwrap();
+    assert_eq!(layer.source, doc.node(component).unwrap().children.first().copied());
+}
+
+#[test]
+fn rest_json_loads_with_linked_instances() {
+    let bytes = serde_json::to_vec(&kit()).unwrap();
+    let (doc, warnings) = load_bytes(&bytes, "kit.json").unwrap();
+    assert_eq!(doc.name, "Kit");
+    assert!(warnings.iter().any(|w| w.contains("placeholder")), "{warnings:?}");
+    let inst = instance(&doc);
+    let NodeKind::Instance { component, .. } = inst.kind else { panic!() };
+    assert_eq!(inst.source, Some(component));
+    let main_label = doc.node(component).unwrap().children[0];
+    let label = doc.node(inst.children[0]).unwrap();
+    assert_eq!(label.source, Some(main_label));
+    assert!(label.overrides.contains("characters"), "{:?}", label.overrides);
+    assert!(crate::components::mirror_issues(&doc).is_empty());
+    assert!(thumbnail(&doc).is_some());
+}
+
+#[test]
+fn open_takes_data_and_a_name_as_a_new_unsaved_document() {
+    let mut saved = Session::new();
+    saved.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
+    let bytes = file_bytes(saved.ds().unwrap()).unwrap();
+    let data = base64::engine::general_purpose::STANDARD.encode(&bytes);
+    let mut s = Session::new();
+    let recent = s.prefs.recent_files.clone();
+    let r = s.execute("file.open", &json!({"data": data, "name": "Dropped.figcraft"})).unwrap();
+    let open = s.docs.len();
+    assert_eq!(r["index"], open - 1, "a document of its own, made active");
+    assert_eq!(s.ds().unwrap().path, None, "no path to save over");
+    assert!(s.doc().unwrap().nodes().any(|n| matches!(n.kind, NodeKind::Rectangle)));
+    assert_eq!(s.prefs.recent_files, recent, "nothing on disk to remember");
+    assert!(s.execute("file.open", &json!({"data": data})).is_err(), "the name tells the format");
+    assert!(s.execute("file.open", &json!({"data": "not base64!", "name": "x.svg"})).is_err());
+    assert_eq!(s.docs.len(), open, "a refused open adds nothing");
+}
+
+#[test]
+fn save_as_data_hands_back_the_file_and_marks_it_saved_once_delivered() {
+    // The browser has no paths: Save as returns the file for a download (#969).
+    let mut s = Session::new();
+    s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
+    assert!(s.execute("file.saveAs", &json!({})).is_err(), "no path and no data: still asks for a path");
+    let recent = s.prefs.recent_files.clone();
+    let r = s.execute("file.saveAs", &json!({"data": true})).unwrap();
+    assert_eq!(r["name"], "Untitled.figcraft");
+    assert!(s.ds().unwrap().is_dirty(), "not delivered yet: a refused download must not lose the edits");
+    s.execute("file.markSaved", &json!({})).unwrap();
+    assert!(!s.ds().unwrap().is_dirty());
+    assert_eq!(s.ds().unwrap().path, None, "still no path to save over");
+    assert_eq!(s.prefs.recent_files, recent, "nothing on disk to remember");
+    let mut t = Session::new();
+    t.execute("file.open", &json!({"data": r["data"], "name": r["name"]})).unwrap();
+    assert!(t.doc().unwrap().nodes().any(|n| matches!(n.kind, NodeKind::Rectangle)), "the bytes reopen");
+}
+
+#[test]
+fn open_and_import_rest_json() {
+    let dir = std::env::temp_dir().join(format!("figcraft-rest-{}", std::process::id()));
+    std::fs::create_dir_all(dir.join("images")).unwrap();
+    let png = {
+        let mut d = Document::new("x");
+        let p = d.first_page().unwrap();
+        let id = d.create(p, NodeKind::Rectangle, "R", 0.0, 0.0, 3.0, 2.0).unwrap();
+        export_bytes(&d, &[id], ExportFormat::Png, 1.0).unwrap()
+    };
+    std::fs::write(dir.join("images").join("photo1.png"), &png).unwrap();
+    let path = dir.join("kit.json");
+    std::fs::write(&path, serde_json::to_vec(&kit()).unwrap()).unwrap();
+    let path = path.to_string_lossy().to_string();
+
+    let mut s = Session::new();
+    let r = s.execute("file.open", &json!({"path": path})).unwrap();
+    assert!(r["warnings"].as_array().is_some_and(|w| w.iter().all(|w| !w.as_str().unwrap_or("").contains("placeholder"))), "{r}");
+    assert!(r.get("repairs").is_none());
+    assert_eq!(s.ds().unwrap().path, None, "an import is never saved over its JSON");
+    let doc = s.doc().unwrap();
+    let photo = doc.nodes().find(|n| n.name == "Photo").unwrap();
+    let figcraft_color::PaintKind::Image(img) = &photo.fills[0].kind else { panic!() };
+    assert_eq!(doc.images.get(&img.image).map(|i| (i.width, i.height)), Some((3, 2)), "read from images/ next to the file");
+
+    // Import into another document: pages are appended and references follow the new ids.
+    let mut s = Session::new();
+    let data = base64::engine::general_purpose::STANDARD.encode(serde_json::to_vec(&kit()).unwrap());
+    let r = s.execute("file.import", &json!({"data": data, "name": "kit.json"})).unwrap();
+    assert_eq!(r["pages"].as_array().map(Vec::len), Some(1));
+    assert!(r["warnings"].is_array(), "{r}");
+    let doc = s.doc().unwrap();
+    assert_eq!(doc.pages.len(), 2);
+    let page = doc.node(doc.pages[1]).unwrap();
+    assert!(matches!(page.kind, NodeKind::Page { background, .. } if (background.r - 0.9).abs() < 1e-6));
+    let inst = instance(doc);
+    let NodeKind::Instance { component, .. } = inst.kind else { panic!() };
+    assert!(doc.node(component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })));
+    let label = doc.node(inst.children[0]).unwrap();
+    assert!(label.source.is_some_and(|src| doc.is_ancestor(component, src)));
+    assert!(crate::components::mirror_issues(doc).is_empty());
+    let _ = std::fs::remove_dir_all(&dir);
+}

From 13855cfabe2cf1f4c1b2c0ed604353fcb324f0df Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:26:08 +0000
Subject: [PATCH 35/67] refactor(engine): move cmd/file.rs staging_write_tests
 to file/staging_write_tests.rs

---
 crates/engine/src/cmd/file.rs                 | 122 +-----------------
 .../src/cmd/file/staging_write_tests.rs       | 119 +++++++++++++++++
 2 files changed, 120 insertions(+), 121 deletions(-)
 create mode 100644 crates/engine/src/cmd/file/staging_write_tests.rs

diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 3f575135..89cfe66f 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -1823,127 +1823,7 @@ fn cycle_doc(s: &mut Session, dir: i64) -> Result<Value> {
 mod rest_import_tests;
 
 #[cfg(test)]
-mod staging_write_tests {
-    use super::*;
-
-    fn dir(name: &str) -> std::path::PathBuf {
-        let d = std::env::temp_dir().join(format!("figcraft-engine-staging-{name}-{}", std::process::id()));
-        std::fs::create_dir_all(&d).unwrap();
-        d
-    }
-
-    /// A symlink `from` → `to`; false when the platform won't make one (Windows needs privileges).
-    #[cfg(unix)]
-    fn symlink(from: &std::path::Path, to: &std::path::Path) -> bool {
-        std::os::unix::fs::symlink(to, from).is_ok()
-    }
-
-    #[cfg(windows)]
-    fn symlink(from: &std::path::Path, to: &std::path::Path) -> bool {
-        std::os::windows::fs::symlink_file(to, from).is_ok()
-    }
-
-    #[test]
-    fn an_existing_staging_file_is_never_written_through() {
-        let d = dir("existing");
-        let path = d.join("shot.svg");
-        // The old deterministic staging name, held by an unrelated file: the write must pick its
-        // own staging name instead of truncating this one.
-        let old = d.join("shot.svg.tmp-figcraft");
-        std::fs::write(&old, b"not yours").unwrap();
-        write(&path.to_string_lossy(), b"<svg/>").unwrap();
-        assert_eq!(std::fs::read(&path).unwrap(), b"<svg/>");
-        assert_eq!(std::fs::read(&old).unwrap(), b"not yours", "an unrelated file at a staging name is untouched");
-        // Just the file and the untouched staging file: no new staging leftovers.
-        assert_eq!(std::fs::read_dir(&d).unwrap().count(), 2);
-        let _ = std::fs::remove_dir_all(&d);
-    }
-
-    #[test]
-    fn a_staging_symlink_is_never_followed() {
-        let d = dir("symlink");
-        let path = d.join("shot.svg");
-        let victim = d.join("victim.txt");
-        std::fs::write(&victim, b"innocent").unwrap();
-        let old = d.join("shot.svg.tmp-figcraft");
-        if !symlink(&old, &victim) {
-            return; // Making a symlink needs privileges on some Windows setups.
-        }
-        write(&path.to_string_lossy(), b"<svg/>").unwrap();
-        assert_eq!(std::fs::read(&victim).unwrap(), b"innocent", "the symlink was never written through");
-        assert_eq!(std::fs::read(&path).unwrap(), b"<svg/>");
-        let _ = std::fs::remove_dir_all(&d);
-    }
-
-    #[test]
-    fn concurrent_writers_of_one_file_never_interleave() {
-        let d = dir("concurrent");
-        let path = d.join("shot.svg");
-        for round in 0..5u8 {
-            let mut handles = Vec::new();
-            for w in 0u8..4 {
-                let (path, bytes) = (path.clone(), vec![b'0' + w; 8192]);
-                handles.push(std::thread::spawn(move || write(&path.to_string_lossy(), &bytes)));
-            }
-            let mut wins = 0;
-            for h in handles {
-                // On Windows a rename over a file another writer just replaced can lose the race.
-                if h.join().unwrap().is_ok() {
-                    wins += 1;
-                }
-            }
-            assert!(wins > 0, "round {round}: every writer lost");
-            // Whatever landed is one writer's complete payload, never a mix.
-            let got = std::fs::read(&path).unwrap();
-            assert_eq!(got.len(), 8192, "round {round}: a complete payload landed");
-            assert!(got.windows(2).all(|w| w[0] == w[1]), "round {round}: one writer's payload, not a mix");
-        }
-        // No staging file was left stuck (a failed writer removes its own).
-        let left = std::fs::read_dir(&d).unwrap().count();
-        assert!(left <= if cfg!(windows) { 5 } else { 1 }, "{left} files left in the staging directory");
-        let _ = std::fs::remove_dir_all(&d);
-    }
-
-    #[test]
-    fn a_failed_write_leaves_the_destination_alone_and_cleans_up() {
-        let d = dir("failure");
-        // The destination is a directory: the rename fails, our staging file is removed and the
-        // directory is untouched.
-        let taken = d.join("over-a-directory");
-        std::fs::create_dir_all(&taken).unwrap();
-        assert!(write(&taken.to_string_lossy(), b"payload").is_err());
-        assert!(taken.is_dir());
-        assert_eq!(std::fs::read_dir(&d).unwrap().count(), 1, "no staging file left behind");
-        // A missing parent directory fails without creating anything anywhere.
-        assert!(write(&d.join("no").join("such.svg").to_string_lossy(), b"payload").is_err());
-        assert!(!d.join("no").exists());
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::PermissionsExt;
-            // A read-only directory refuses the staging file, and the old destination stays.
-            let ro = d.join("read-only");
-            std::fs::create_dir_all(&ro).unwrap();
-            let dest = ro.join("keep.svg");
-            std::fs::write(&dest, b"keep").unwrap();
-            let mut perms = std::fs::metadata(&ro).unwrap().permissions();
-            perms.set_mode(0o500);
-            std::fs::set_permissions(&ro, perms).unwrap();
-            // Running as root would defeat the read-only directory: skip instead of failing.
-            let probe = ro.join(".probe");
-            if std::fs::write(&probe, b"").is_ok() {
-                let _ = std::fs::remove_file(&probe);
-            } else {
-                assert!(write(&dest.to_string_lossy(), b"payload").is_err());
-                assert_eq!(std::fs::read(&dest).unwrap(), b"keep");
-                assert_eq!(std::fs::read_dir(&ro).unwrap().count(), 1, "no staging file left behind");
-            }
-            let mut perms = std::fs::metadata(&ro).unwrap().permissions();
-            perms.set_mode(0o700);
-            std::fs::set_permissions(&ro, perms).unwrap();
-        }
-        let _ = std::fs::remove_dir_all(&d);
-    }
-}
+mod staging_write_tests;
 
 #[cfg(test)]
 mod zip_cap_tests {
diff --git a/crates/engine/src/cmd/file/staging_write_tests.rs b/crates/engine/src/cmd/file/staging_write_tests.rs
new file mode 100644
index 00000000..5653ce78
--- /dev/null
+++ b/crates/engine/src/cmd/file/staging_write_tests.rs
@@ -0,0 +1,119 @@
+use super::*;
+
+fn dir(name: &str) -> std::path::PathBuf {
+    let d = std::env::temp_dir().join(format!("figcraft-engine-staging-{name}-{}", std::process::id()));
+    std::fs::create_dir_all(&d).unwrap();
+    d
+}
+
+/// A symlink `from` → `to`; false when the platform won't make one (Windows needs privileges).
+#[cfg(unix)]
+fn symlink(from: &std::path::Path, to: &std::path::Path) -> bool {
+    std::os::unix::fs::symlink(to, from).is_ok()
+}
+
+#[cfg(windows)]
+fn symlink(from: &std::path::Path, to: &std::path::Path) -> bool {
+    std::os::windows::fs::symlink_file(to, from).is_ok()
+}
+
+#[test]
+fn an_existing_staging_file_is_never_written_through() {
+    let d = dir("existing");
+    let path = d.join("shot.svg");
+    // The old deterministic staging name, held by an unrelated file: the write must pick its
+    // own staging name instead of truncating this one.
+    let old = d.join("shot.svg.tmp-figcraft");
+    std::fs::write(&old, b"not yours").unwrap();
+    write(&path.to_string_lossy(), b"<svg/>").unwrap();
+    assert_eq!(std::fs::read(&path).unwrap(), b"<svg/>");
+    assert_eq!(std::fs::read(&old).unwrap(), b"not yours", "an unrelated file at a staging name is untouched");
+    // Just the file and the untouched staging file: no new staging leftovers.
+    assert_eq!(std::fs::read_dir(&d).unwrap().count(), 2);
+    let _ = std::fs::remove_dir_all(&d);
+}
+
+#[test]
+fn a_staging_symlink_is_never_followed() {
+    let d = dir("symlink");
+    let path = d.join("shot.svg");
+    let victim = d.join("victim.txt");
+    std::fs::write(&victim, b"innocent").unwrap();
+    let old = d.join("shot.svg.tmp-figcraft");
+    if !symlink(&old, &victim) {
+        return; // Making a symlink needs privileges on some Windows setups.
+    }
+    write(&path.to_string_lossy(), b"<svg/>").unwrap();
+    assert_eq!(std::fs::read(&victim).unwrap(), b"innocent", "the symlink was never written through");
+    assert_eq!(std::fs::read(&path).unwrap(), b"<svg/>");
+    let _ = std::fs::remove_dir_all(&d);
+}
+
+#[test]
+fn concurrent_writers_of_one_file_never_interleave() {
+    let d = dir("concurrent");
+    let path = d.join("shot.svg");
+    for round in 0..5u8 {
+        let mut handles = Vec::new();
+        for w in 0u8..4 {
+            let (path, bytes) = (path.clone(), vec![b'0' + w; 8192]);
+            handles.push(std::thread::spawn(move || write(&path.to_string_lossy(), &bytes)));
+        }
+        let mut wins = 0;
+        for h in handles {
+            // On Windows a rename over a file another writer just replaced can lose the race.
+            if h.join().unwrap().is_ok() {
+                wins += 1;
+            }
+        }
+        assert!(wins > 0, "round {round}: every writer lost");
+        // Whatever landed is one writer's complete payload, never a mix.
+        let got = std::fs::read(&path).unwrap();
+        assert_eq!(got.len(), 8192, "round {round}: a complete payload landed");
+        assert!(got.windows(2).all(|w| w[0] == w[1]), "round {round}: one writer's payload, not a mix");
+    }
+    // No staging file was left stuck (a failed writer removes its own).
+    let left = std::fs::read_dir(&d).unwrap().count();
+    assert!(left <= if cfg!(windows) { 5 } else { 1 }, "{left} files left in the staging directory");
+    let _ = std::fs::remove_dir_all(&d);
+}
+
+#[test]
+fn a_failed_write_leaves_the_destination_alone_and_cleans_up() {
+    let d = dir("failure");
+    // The destination is a directory: the rename fails, our staging file is removed and the
+    // directory is untouched.
+    let taken = d.join("over-a-directory");
+    std::fs::create_dir_all(&taken).unwrap();
+    assert!(write(&taken.to_string_lossy(), b"payload").is_err());
+    assert!(taken.is_dir());
+    assert_eq!(std::fs::read_dir(&d).unwrap().count(), 1, "no staging file left behind");
+    // A missing parent directory fails without creating anything anywhere.
+    assert!(write(&d.join("no").join("such.svg").to_string_lossy(), b"payload").is_err());
+    assert!(!d.join("no").exists());
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        // A read-only directory refuses the staging file, and the old destination stays.
+        let ro = d.join("read-only");
+        std::fs::create_dir_all(&ro).unwrap();
+        let dest = ro.join("keep.svg");
+        std::fs::write(&dest, b"keep").unwrap();
+        let mut perms = std::fs::metadata(&ro).unwrap().permissions();
+        perms.set_mode(0o500);
+        std::fs::set_permissions(&ro, perms).unwrap();
+        // Running as root would defeat the read-only directory: skip instead of failing.
+        let probe = ro.join(".probe");
+        if std::fs::write(&probe, b"").is_ok() {
+            let _ = std::fs::remove_file(&probe);
+        } else {
+            assert!(write(&dest.to_string_lossy(), b"payload").is_err());
+            assert_eq!(std::fs::read(&dest).unwrap(), b"keep");
+            assert_eq!(std::fs::read_dir(&ro).unwrap().count(), 1, "no staging file left behind");
+        }
+        let mut perms = std::fs::metadata(&ro).unwrap().permissions();
+        perms.set_mode(0o700);
+        std::fs::set_permissions(&ro, perms).unwrap();
+    }
+    let _ = std::fs::remove_dir_all(&d);
+}

From 96423f5a6e75ed41f513d281f0c15b44677dd6c5 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:26:09 +0000
Subject: [PATCH 36/67] refactor(engine): move cmd/file.rs zip_cap_tests to
 file/zip_cap_tests.rs

---
 crates/engine/src/cmd/file.rs               | 14 +-------------
 crates/engine/src/cmd/file/zip_cap_tests.rs | 11 +++++++++++
 2 files changed, 12 insertions(+), 13 deletions(-)
 create mode 100644 crates/engine/src/cmd/file/zip_cap_tests.rs

diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 89cfe66f..887e6c9f 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -1826,16 +1826,4 @@ mod rest_import_tests;
 mod staging_write_tests;
 
 #[cfg(test)]
-mod zip_cap_tests {
-    use super::add_member;
-
-    #[test]
-    fn zip_members_stop_at_the_limit_and_keep_what_fit() {
-        let mut members = Vec::new();
-        add_member(&mut members, "a.png", vec![0; 6], 10).unwrap();
-        add_member(&mut members, "b.png", vec![0; 4], 10).unwrap();
-        let err = add_member(&mut members, "c.png", vec![0; 1], 10).unwrap_err().to_string();
-        assert!(err.contains("as one zip"), "{err}");
-        assert_eq!(members.iter().map(|(n, _)| *n).collect::<Vec<_>>(), ["a.png", "b.png"]);
-    }
-}
+mod zip_cap_tests;
diff --git a/crates/engine/src/cmd/file/zip_cap_tests.rs b/crates/engine/src/cmd/file/zip_cap_tests.rs
new file mode 100644
index 00000000..ee3e461b
--- /dev/null
+++ b/crates/engine/src/cmd/file/zip_cap_tests.rs
@@ -0,0 +1,11 @@
+use super::add_member;
+
+#[test]
+fn zip_members_stop_at_the_limit_and_keep_what_fit() {
+    let mut members = Vec::new();
+    add_member(&mut members, "a.png", vec![0; 6], 10).unwrap();
+    add_member(&mut members, "b.png", vec![0; 4], 10).unwrap();
+    let err = add_member(&mut members, "c.png", vec![0; 1], 10).unwrap_err().to_string();
+    assert!(err.contains("as one zip"), "{err}");
+    assert_eq!(members.iter().map(|(n, _)| *n).collect::<Vec<_>>(), ["a.png", "b.png"]);
+}

From a9d93f8310873d83b19542affa10658e6b3b6f59 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:37:33 +0000
Subject: [PATCH 37/67] refactor(engine): split cmd/file.rs into file/

---
 crates/engine/src/cmd/file.rs         | 1456 +------------------------
 crates/engine/src/cmd/file/export.rs  |  383 +++++++
 crates/engine/src/cmd/file/load.rs    |  416 +++++++
 crates/engine/src/cmd/file/open.rs    |  245 +++++
 crates/engine/src/cmd/file/save.rs    |  225 ++++
 crates/engine/src/cmd/file/version.rs |  172 +++
 6 files changed, 1471 insertions(+), 1426 deletions(-)
 create mode 100644 crates/engine/src/cmd/file/export.rs
 create mode 100644 crates/engine/src/cmd/file/load.rs
 create mode 100644 crates/engine/src/cmd/file/open.rs
 create mode 100644 crates/engine/src/cmd/file/save.rs
 create mode 100644 crates/engine/src/cmd/file/version.rs

diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 887e6c9f..fed4bff1 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -11,6 +11,36 @@ use super::{CommandSpec, ok};
 use crate::params::*;
 use crate::{DocState, EngineError, Result, Session, bad, spec};
 
+mod export;
+mod load;
+mod open;
+mod save;
+mod version;
+
+pub(crate) use export::FORBIDDEN_FILE_NAME_CHARS;
+#[cfg(test)]
+use export::add_member;
+pub(super) use export::export_setting;
+pub use export::{
+    ExportJob, copy_png, drawn_layers, export_area, export_bytes, export_bytes_with, export_jobs, export_scale, exportable_layers, fig_bytes,
+    frames_pdf, jobs_for, safe_file_name,
+};
+use export::{export, export_frames_pdf, export_layers, pdf_bytes};
+#[cfg(test)]
+pub(crate) use load::{installed_family, sketch_line};
+pub use load::{load, load_bytes, load_path};
+pub(crate) use load::{load_fig, read_capped, recovered, variables_param, write};
+pub use open::MAX_RECENT;
+#[cfg(test)]
+use open::append_pages;
+use open::{import, open, open_recent};
+pub(crate) use save::save_ends_preview;
+pub use save::{FileSnapshot, file_bytes, thumbnail};
+use save::{color_profile, mark_saved, save, save_as};
+pub use version::MAX_AUTOSAVES;
+pub(crate) use version::{add_version, keep_in_history, read_version, unique_id};
+use version::{autosave, restore_version, save_version, version_index, version_json, version_list};
+
 /// A new file of `kind` in a tab of its own.
 fn new_file(s: &mut Session, p: &Value, kind: FileKind) -> Result<Value> {
     let name = string(p, "name").unwrap_or_else(|| if kind == FileKind::Board { "Untitled board" } else { "Untitled" }.into());
@@ -295,987 +325,6 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
-fn version_json(index: usize, v: &Version) -> Value {
-    let mut j = json!({"id": v.id, "index": index, "name": v.name, "description": v.description, "time": v.time});
-    if v.auto {
-        j["auto"] = json!(true);
-    }
-    j
-}
-
-/// Autosaves kept per file; older ones make room for new ones.
-pub const MAX_AUTOSAVES: usize = 20;
-
-/// `version.autosave`: a checkpoint of a document with unsaved changes since the last version.
-fn autosave(s: &mut Session, _: &Value) -> Result<Value> {
-    let auto_save = s.prefs.auto_save;
-    let ds = s.ds_mut()?;
-    // A file that saves itself is rarely unsaved: edits since it was opened count then.
-    let edited = ds.is_dirty() || (auto_save && !ds.history.undo.is_empty());
-    if ds.preview.is_some() || !edited || !ds.changed_since_checkpoint() {
-        return Ok(json!({"saved": false}));
-    }
-    Ok(match add_version(ds, AUTOSAVE, "", true) {
-        Some(v) => json!({"saved": true, "version": v}),
-        None => json!({"saved": false}),
-    })
-}
-
-/// What checkpoints are called.
-const AUTOSAVE: &str = "Autosave";
-
-/// Add a version of `ds`'s document as it is now (`auto`: a checkpoint) and return it. The oldest
-/// autosave makes room when the autosaves or the history are full; versions the user named are
-/// never dropped, so a history full of them takes nothing (None).
-pub(crate) fn add_version(ds: &mut DocState, name: &str, description: &str, auto: bool) -> Option<Value> {
-    let autos = ds.versions.iter().filter(|v| v.auto).count();
-    if ((auto && autos >= MAX_AUTOSAVES) || ds.versions.len() >= figcraft_format::MAX_VERSIONS)
-        && let Some(oldest) = ds.versions.iter().position(|v| v.auto)
-    {
-        ds.versions_mut().remove(oldest);
-    }
-    if ds.versions.len() >= figcraft_format::MAX_VERSIONS {
-        return None;
-    }
-    let mut v = snapshot_version(ds, name, description);
-    v.auto = auto;
-    let out = version_json(ds.versions.len(), &v);
-    ds.versions_mut().push(v);
-    ds.mark_checkpoint();
-    Some(out)
-}
-
-/// Before the document is replaced (a restore, a merge): keep it in the history as it is, unless
-/// it is what the last version saved or restored holds.
-pub(crate) fn keep_in_history(ds: &mut DocState) {
-    if ds.branch_of.is_none() && ds.changed_since_checkpoint() {
-        add_version(ds, AUTOSAVE, "", true);
-    }
-}
-
-/// A version of `ds`'s document as it is now, opening on the page shown.
-fn snapshot_version(ds: &DocState, name: &str, description: &str) -> Version {
-    let mut snap = ds.doc.clone();
-    if snap.current_page != Some(ds.page) {
-        Arc::make_mut(&mut snap).current_page = Some(ds.page);
-    }
-    Version::new(unique_id(|id| ds.versions.iter().any(|v| v.id == id)), name, description, super::comment::now_secs(), snap)
-}
-
-fn version_list(ds: &DocState) -> Value {
-    let previewing = ds.preview.as_ref().map(|p| p.id.as_str());
-    Value::Array(
-        ds.versions
-            .iter()
-            .enumerate()
-            .map(|(i, v)| {
-                let mut j = version_json(i, v);
-                if previewing == Some(v.id.as_str()) {
-                    j["previewing"] = json!(true);
-                }
-                j
-            })
-            .collect(),
-    )
-}
-
-/// The version named by `id`, else by `index` (validated: never negative, never past the end).
-fn version_index(cmd: &str, ds: &DocState, p: &Value) -> Result<usize> {
-    if let Some(id) = string(p, "id") {
-        return ds.versions.iter().position(|v| v.id == id).ok_or_else(|| bad(cmd, format!("no version `{id}`")));
-    }
-    if get(p, "index").is_none() {
-        return Err(bad(cmd, "pass the version's `id` or `index`"));
-    }
-    let i = req_index(cmd, p, "index")?;
-    if i < ds.versions.len() { Ok(i) } else { Err(bad(cmd, format!("no version at index {i}"))) }
-}
-
-pub(crate) fn read_version(v: &Version) -> Result<Arc<Document>> {
-    v.document().map_err(|e| EngineError::Other(format!("version “{}” can't be read: {e}", v.name)))
-}
-
-/// A new version or branch id: the time in milliseconds (hex), not `taken`.
-pub(crate) fn unique_id(taken: impl Fn(&str) -> bool) -> String {
-    let mut n = web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0);
-    loop {
-        let id = format!("{n:x}");
-        if !taken(&id) {
-            return id;
-        }
-        n = n.wrapping_add(1);
-    }
-}
-
-/// `file.saveVersion`; on a branch tab the version goes into the branch's own history.
-fn save_version(s: &mut Session, p: &Value) -> Result<Value> {
-    let ds = s.ds_mut()?;
-    if ds.versions.len() >= figcraft_format::MAX_VERSIONS {
-        return Err(EngineError::Disabled(
-            "file.saveVersion".into(),
-            format!("the version history is full ({} versions): delete old versions first", figcraft_format::MAX_VERSIONS),
-        ));
-    }
-    let name =
-        string(p, "name").map(|n| n.trim().to_string()).filter(|n| !n.is_empty()).unwrap_or_else(|| format!("Version {}", ds.versions.len() + 1));
-    let description = string(p, "description").unwrap_or_default();
-    // The version opens on the page shown when it was saved.
-    add_version(ds, &name, description.trim(), false).ok_or_else(|| {
-        EngineError::Disabled(
-            "file.saveVersion".into(),
-            format!("the version history is full ({} versions): delete old versions first", figcraft_format::MAX_VERSIONS),
-        )
-    })
-}
-
-fn restore_version(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "version.restore";
-    // Refused before anything goes into the history.
-    if let Some(why) = s.live_read_only(s.ds()?.uid) {
-        return Err(EngineError::Disabled(CMD.into(), why.into()));
-    }
-    let ds = s.ds_mut()?;
-    let i = version_index(CMD, ds, p)?;
-    let v = ds.versions.get(i).ok_or_else(|| bad(CMD, "no such version"))?;
-    let (id, mut doc) = (v.id.clone(), read_version(v)?);
-    // Restoring never loses work: the document as it is goes into the history first.
-    keep_in_history(ds);
-    let out = ds.versions.iter().enumerate().find(|(_, v)| v.id == id).map_or(Value::Null, |(i, v)| version_json(i, v));
-    let d = Arc::make_mut(&mut doc);
-    d.name = ds.doc.name.clone();
-    // What the file published belongs to the file, not to the version.
-    d.published = ds.doc.published.clone();
-    // Comments are a conversation about the file, kept apart from its design history: they stay,
-    // and those on layers the version doesn't have stay where they were.
-    d.comments = ds.doc.comments.clone();
-    super::comment::follow_anchors(d, &ds.doc);
-    // The snapshot is already consistent: nothing to re-normalise.
-    d.take_dirty();
-    // Stay on the current page when the version has it.
-    ds.page = Some(ds.page)
-        .filter(|pg| d.pages.contains(pg))
-        .or_else(|| d.current_page.filter(|pg| d.pages.contains(pg)))
-        .or_else(|| d.first_page())
-        .unwrap_or(ds.page);
-    ds.doc = doc;
-    ds.selection.clear();
-    ds.text_edit = None;
-    ds.vector_edit = None;
-    // The restored design is in the history already: restoring it again keeps nothing new.
-    ds.mark_checkpoint();
-    Ok(out)
-}
-
-/// The recovery copy at `path` as a document with unsaved changes and no path.
-pub(crate) fn recovered(path: &str) -> Result<DocState> {
-    let loaded = read(path).and_then(|b| figcraft_format::load_bytes_with_versions(&b).map_err(|e| EngineError::Other(e.to_string())))?;
-    Ok(DocState::new(loaded.doc, None).with_versions(loaded.versions).with_branches(loaded.branches).unsaved())
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-fn read(path: &str) -> Result<Vec<u8>> {
-    crate::file_access::read(path)
-}
-
-#[cfg(target_arch = "wasm32")]
-fn read(path: &str) -> Result<Vec<u8>> {
-    Err(EngineError::Other(format!("{path}: no file system in the browser")))
-}
-
-/// The bytes of file `path`, refused when it's larger than `max`.
-pub(crate) fn read_capped(path: &str, max: u64) -> Result<Vec<u8>> {
-    crate::file_access::read_capped(path, max)
-}
-
-/// Write `bytes` to `path` through a uniquely named, exclusively created staging file and one
-/// atomic rename (see [`figcraft_format::write_file_atomic`]): a failed or interrupted write never
-/// truncates `path`, and no file or symlink at a staging name is ever written through.
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn write(path: &str, bytes: &[u8]) -> Result<()> {
-    crate::file_access::write(path, bytes)
-}
-
-#[cfg(target_arch = "wasm32")]
-pub(crate) fn write(path: &str, _bytes: &[u8]) -> Result<()> {
-    Err(EngineError::Other(format!("{path}: no file system in the browser")))
-}
-
-fn ext(path: &str) -> String {
-    std::path::Path::new(path).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("").to_ascii_lowercase()
-}
-
-fn file_stem(path: &str) -> String {
-    std::path::Path::new(path).file_stem().and_then(std::ffi::OsStr::to_str).unwrap_or("Untitled").to_string()
-}
-
-/// The counts the import report shows for a freshly loaded document.
-fn import_summary(doc: &Document) -> Value {
-    json!({"name": doc.name, "pages": doc.pages.len(), "layers": doc.nodes().filter(|n| !n.is_page()).count(), "images": doc.images.len()})
-}
-
-/// Load a document from any supported file (REST API file JSON images come from an `images`
-/// folder next to the file).
-pub fn load(path: &str) -> Result<(Document, Vec<String>)> {
-    load_path(path, None).map(|(l, _)| (l.doc, l.issues))
-}
-
-pub fn load_bytes(bytes: &[u8], name_hint: &str) -> Result<(Document, Vec<String>)> {
-    load_with(bytes, name_hint, None, &figcraft_format::rest::no_images).map(|(l, _)| (l.doc, l.issues))
-}
-
-/// [`load`] with the version history, also telling whether the file was REST API file JSON. A REST
-/// import reads its variables from `variables`, else from a variables JSON next to the file.
-pub fn load_path(path: &str, variables: Option<&Value>) -> Result<(figcraft_format::Loaded, bool)> {
-    let bytes = read(path)?;
-    let sibling = if variables.is_none() { sibling_variables(path) } else { None };
-    load_with(&bytes, path, variables.or(sibling.as_ref()), &rest_images(path))
-}
-
-/// Load from bytes. Returns the document with its notes (repairs of a native file, or import
-/// warnings) and version history, and whether it was imported from REST API file JSON or a `.fig`
-/// file (such a file is never saved over). `variables`: the local variables JSON for a REST API file JSON.
-fn load_with(
-    bytes: &[u8],
-    name_hint: &str,
-    variables: Option<&Value>,
-    images: figcraft_format::rest::ImageResolver,
-) -> Result<(figcraft_format::Loaded, bool)> {
-    match ext(name_hint).as_str() {
-        "svg" => {
-            let mut doc = Document::new(file_stem(name_hint));
-            let page = doc.first_page().ok_or(EngineError::NoDocument)?;
-            let notes = figcraft_svg::import_svg_with_notes(&mut doc, bytes, page, 0.0, 0.0, &file_stem(name_hint))
-                .map_err(|e| EngineError::Other(e.to_string()))?
-                .notes;
-            Ok((figcraft_format::Loaded { issues: notes, ..doc.into() }, false))
-        }
-        "png" | "jpg" | "jpeg" | "gif" | "webp" | "bmp" | "tif" | "tiff" => {
-            let mut doc = Document::new(file_stem(name_hint));
-            let page = doc.first_page().ok_or(EngineError::NoDocument)?;
-            let (hash, w, h) = figcraft_format::add_image(&mut doc, bytes.to_vec()).map_err(|e| EngineError::Other(e.to_string()))?;
-            let id = doc.create(page, NodeKind::Rectangle, &file_stem(name_hint), 0.0, 0.0, f64::from(w), f64::from(h))?;
-            doc.get_mut(id)?.fills = vec![figcraft_color::Paint::image(hash, figcraft_color::ImageScaleMode::Fill)];
-            Ok((doc.into(), false))
-        }
-        _ => {
-            if let Some(r) = load_fig(bytes, &file_stem(name_hint)) {
-                return Ok((r?, true));
-            }
-            if let Some(r) = load_sketch(bytes, &file_stem(name_hint)) {
-                return Ok((r?, true));
-            }
-            if let Some(r) = figcraft_format::rest::try_import_with(bytes, variables, images) {
-                let (mut doc, warnings) = r.map_err(|e| EngineError::Other(e.to_string()))?;
-                link_instances(&mut doc);
-                return Ok((figcraft_format::Loaded { issues: warnings, ..doc.into() }, true));
-            }
-            let mut loaded = figcraft_format::load_bytes_with_versions(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
-            // Older files saved an untouched default title even after the user chose a filename.
-            if loaded.doc.name.is_empty() || loaded.doc.name == "Untitled" {
-                loaded.doc.name = file_stem(name_hint);
-            }
-            Ok((loaded, false))
-        }
-    }
-}
-
-/// Gives `None` when `bytes` are not a `.sketch` file. Then other readers can try.
-fn load_sketch(bytes: &[u8], name: &str) -> Option<Result<figcraft_format::Loaded>> {
-    if !figcraft_format::sketch::is_sketch(bytes) {
-        return None;
-    }
-    // The import and what follows read the installed fonts: the system's must be known first (the
-    // desktop app scans them in the background; this waits for that scan).
-    figcraft_text::fontdb::scan_system_fonts();
-    let fonts: figcraft_format::sketch::FontLookup = Box::new(figcraft_text::fontdb::postscript_face);
-    let r = figcraft_format::sketch::try_import_with_fonts(bytes, name, Some(fonts))?;
-    Some(r.map_err(|e| EngineError::Other(e.to_string())).map(|(mut doc, warnings)| {
-        match_font_families(&mut doc);
-        platform_tracking(&mut doc);
-        sketch_line_heights(&mut doc);
-        link_instances(&mut doc);
-        reflow_overridden_text(&mut doc);
-        figcraft_format::Loaded { issues: warnings, ..doc.into() }
-    }))
-}
-
-/// Instances of a stack sized apart from their main are laid out at their size, and texts in
-/// instances whose string an override changed are measured again with the auto layout around them
-/// re-flowing (Sketch saves layouts measured with the master's string). The rest keeps the layout
-/// Sketch saved.
-fn reflow_overridden_text(doc: &mut Document) {
-    let changed: Vec<NodeId> = doc
-        .nodes()
-        .filter(|n| match (&n.kind, n.source.and_then(|s| doc.node(s)).map(|s| &s.kind)) {
-            (NodeKind::Text(t), Some(NodeKind::Text(main))) => t.characters != main.characters,
-            _ => false,
-        })
-        .map(|n| n.id)
-        .collect();
-    let m = crate::measure::TextMeasure;
-    // Instances of a stack at another size than their main: the stack at their size, innermost first.
-    let mut resized: Vec<(usize, NodeId)> = doc
-        .nodes()
-        .filter(|n| n.layout.is_some())
-        .filter(|n| match &n.kind {
-            NodeKind::Instance { component, .. } => {
-                doc.node(*component).is_some_and(|c| (c.width - n.width).abs() > 1e-6 || (c.height - n.height).abs() > 1e-6)
-            }
-            _ => false,
-        })
-        .map(|n| (doc.ancestors(n.id).len(), n.id))
-        .collect();
-    resized.sort_by_key(|r| std::cmp::Reverse(r.0));
-    for (_, id) in resized {
-        figcraft_layout::layout_frame(doc, id, &m);
-    }
-    for id in changed {
-        if let Some((w, h)) = doc.node(id).and_then(figcraft_text::auto_size) {
-            figcraft_layout::set_size(doc, id, w, h);
-        }
-        figcraft_layout::layout_up(doc, id, &m);
-    }
-}
-
-/// Font families a `.sketch` import guessed from PostScript names ("Ping Fang SC" from
-/// "PingFangSC-Semibold") take the installed family's name when they differ only in spaces and
-/// case.
-fn match_font_families(doc: &mut Document) {
-    let installed = figcraft_text::fontdb::family_names();
-    let mut cache: std::collections::BTreeMap<String, Option<String>> = std::collections::BTreeMap::new();
-    let mut fix = |style: &mut figcraft_doc::TextStyle| {
-        let found = cache.entry(style.font_family.clone()).or_insert_with(|| installed_family(&style.font_family, &installed));
-        if let Some(f) = found {
-            style.font_family = f.clone();
-        }
-    };
-    let ids: Vec<NodeId> = doc.nodes().filter(|n| matches!(n.kind, NodeKind::Text(_))).map(|n| n.id).collect();
-    for id in ids {
-        if let Some(NodeKind::Text(td)) = doc.node_mut(id).map(|n| &mut n.kind) {
-            fix(&mut td.style);
-            for r in &mut td.runs {
-                fix(&mut r.style);
-            }
-        }
-    }
-    // Shared text styles too, so they stay like the layers linked to them.
-    for st in &mut doc.styles {
-        if let StyleKind::Text { style } = &mut st.kind {
-            fix(style);
-        }
-    }
-}
-
-/// Sketch draws text with the tracking a font's `trak` table gives at its size (Apple's text engine
-/// adds it; FigCraft's, like Figma's, doesn't): the imported text keeps it as letter spacing, so
-/// lines measure and break as they did there. A named style's optical size follows the text size
-/// there too (FigCraft keeps the instance's), so the imported text carries it as an `opsz` value.
-fn platform_tracking(doc: &mut Document) {
-    let mut cache: std::collections::BTreeMap<(String, String), Option<std::sync::Arc<figcraft_text::fontdb::Face>>> =
-        std::collections::BTreeMap::new();
-    let mut face = |style: &figcraft_doc::TextStyle| {
-        cache
-            .entry((style.font_family.clone(), style.font_style.clone()))
-            .or_insert_with(|| {
-                figcraft_text::fontdb::has_family(&style.font_family)
-                    .then(|| figcraft_text::fontdb::find_face(&style.font_family, &style.font_style))
-                    .flatten()
-            })
-            .clone()
-    };
-    let mut track = |style: &mut figcraft_doc::TextStyle| {
-        let Some(f) = face(style) else { return };
-        let t = f.tracking(style.font_size);
-        if t != 0.0 && t.is_finite() {
-            let px = style.letter_spacing.resolve(style.font_size);
-            style.letter_spacing = figcraft_doc::LetterSpacing::Pixels(px + t);
-        }
-        if f.axis("opsz").is_some() && f.instance(&style.font_style).is_some() && style.font_size.is_finite() {
-            style.variations.entry("opsz".into()).or_insert(style.font_size);
-        }
-    };
-    let ids: Vec<NodeId> = doc.nodes().filter(|n| matches!(n.kind, NodeKind::Text(_))).map(|n| n.id).collect();
-    for id in ids {
-        if let Some(NodeKind::Text(td)) = doc.node_mut(id).map(|n| &mut n.kind) {
-            track(&mut td.style);
-            for r in &mut td.runs {
-                track(&mut r.style);
-            }
-        }
-    }
-    for st in &mut doc.styles {
-        if let StyleKind::Text { style } = &mut st.kind {
-            track(style);
-        }
-    }
-}
-
-/// Families Sketch (Apple's text system) gives a fifth more than their ascent and descent as their
-/// natural line: classic Mac fonts, found on `sketchtool` renders. Other fonts show none of this.
-const TALL_LINE_FAMILIES: [&str; 11] =
-    ["Academy Engraved LET", "Courier", "Helvetica", "Hoefler Text", "Palatino", "Sathu", "Silom", "Skia", "Times", "Webdings", "Zapf Dingbats"];
-
-/// Sketch's natural line for a font of `ascent` and `descent` in `upem` units at `size` px: its
-/// height in px and how far down the text moves so its baseline sits where Sketch puts it. Sketch
-/// rounds the ascent and descent to whole pixels each and leaves the font's line gap out (a fifth
-/// more for [`TALL_LINE_FAMILIES`]), with the baseline above the rounded descent; FigCraft centres
-/// the font's own ascent and descent in the line. `(0, 0)` without metrics.
-pub(crate) fn sketch_line(ascent: f64, descent: f64, upem: f64, family: &str, size: f64) -> (f64, f64) {
-    let k = size / upem;
-    let (a, d) = (ascent * k, descent * k);
-    if !(a.is_finite() && d.is_finite()) || a + d <= 0.0 {
-        return (0.0, 0.0);
-    }
-    let natural = a.round() + d.round();
-    let line = if TALL_LINE_FAMILIES.iter().any(|f| f.eq_ignore_ascii_case(family)) { (natural * 1.2).round() } else { natural };
-    let sketch_baseline = line - d.round();
-    let figcraft_baseline = (line - (a + d)) / 2.0 + a;
-    (line, sketch_baseline - figcraft_baseline)
-}
-
-/// Text without a fixed line height takes the line Sketch drew it with (FigCraft's natural line,
-/// like Figma's, counts the font's line gap and centres the font in it; Sketch's doesn't), as a
-/// share of its size so it still follows the size, and moves to Sketch's baseline. Shared text
-/// styles take the line too.
-fn sketch_line_heights(doc: &mut Document) {
-    // Per family and style: the face's ascent, descent and units per em.
-    type Metrics = Option<(f64, f64, f64)>;
-    let mut cache: std::collections::BTreeMap<(String, String), Metrics> = std::collections::BTreeMap::new();
-    let mut set = |style: &mut TextStyle| -> f64 {
-        if style.line_height != LineHeight::Auto || !style.font_size.is_finite() || style.font_size <= 0.0 {
-            return 0.0;
-        }
-        let m = *cache.entry((style.font_family.clone(), style.font_style.clone())).or_insert_with(|| {
-            figcraft_text::fontdb::has_family(&style.font_family)
-                .then(|| figcraft_text::fontdb::find_face(&style.font_family, &style.font_style))
-                .flatten()
-                .map(|f| (f.ascent, f.descent, f.upem))
-        });
-        let Some((a, d, upem)) = m else { return 0.0 };
-        let (line, down) = sketch_line(a, d, upem, &style.font_family, style.font_size);
-        if line > 0.0 {
-            style.line_height = LineHeight::Percent(line / style.font_size * 100.0);
-        }
-        down
-    };
-    let ids: Vec<NodeId> = doc.nodes().filter(|n| matches!(n.kind, NodeKind::Text(_))).map(|n| n.id).collect();
-    for id in ids {
-        // An auto layout places its texts itself (its next pass would take a move back).
-        let laid_out =
-            doc.node(id).is_some_and(|n| !n.child_layout.absolute && n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some()));
-        let Some(n) = doc.node_mut(id) else { continue };
-        let NodeKind::Text(td) = &mut n.kind else { continue };
-        let down = set(&mut td.style);
-        for r in &mut td.runs {
-            set(&mut r.style);
-        }
-        // Down in the layer's own frame (a rotated text moves along its own axis).
-        if !laid_out && down.is_finite() && down != 0.0 {
-            n.transform *= figcraft_doc::geom::Affine::translate((0.0, down));
-        }
-    }
-    for st in &mut doc.styles {
-        if let StyleKind::Text { style } = &mut st.kind {
-            set(style);
-        }
-    }
-}
-
-/// The installed family `family` means when it isn't installed under that exact name: the one
-/// whose name is the same without spaces, ignoring case.
-pub(crate) fn installed_family(family: &str, installed: &[String]) -> Option<String> {
-    let key = |s: &str| s.chars().filter(|c| !c.is_whitespace()).flat_map(char::to_lowercase).collect::<String>();
-    if installed.iter().any(|f| f.eq_ignore_ascii_case(family)) {
-        return None;
-    }
-    let want = key(family);
-    installed.iter().find(|f| key(f) == want).cloned()
-}
-
-/// Gives `None` when `bytes` are not a `.fig` file. Then other readers can try.
-pub(crate) fn load_fig(bytes: &[u8], name: &str) -> Option<Result<figcraft_format::Loaded>> {
-    let r = figcraft_format::fig::try_import(bytes, name)?;
-    Some(r.map_err(|e| EngineError::Other(e.to_string())).map(|(mut doc, warnings)| {
-        link_instances(&mut doc);
-        figcraft_format::Loaded { issues: warnings, ..doc.into() }
-    }))
-}
-
-/// Link imported instances to their mains (layer sources, overrides found by comparing values),
-/// innermost first so outer instances settle last.
-fn link_instances(doc: &mut Document) {
-    super::styles::unfold_imported_bound_alpha(doc);
-    crate::style_vars::after_load(doc);
-    super::styles::apply_paint_bindings_on_load(doc);
-    let mut insts: Vec<(usize, NodeId)> =
-        doc.nodes().filter(|n| matches!(n.kind, NodeKind::Instance { .. })).map(|n| (doc.ancestors(n.id).len(), n.id)).collect();
-    insts.sort_by_key(|a| std::cmp::Reverse(a.0));
-    for (_, i) in insts {
-        crate::components::rebase_instance(doc, i);
-    }
-}
-
-/// Largest image file read for a REST API file JSON import.
-#[cfg(not(target_arch = "wasm32"))]
-const MAX_IMAGE_FILE: u64 = 256 * 1024 * 1024;
-
-/// Image bytes for a REST API file JSON's `imageRef`: `images/<imageRef>[.png|.jpg|…]` next to
-/// the file.
-#[cfg(not(target_arch = "wasm32"))]
-fn rest_images(path: &str) -> impl Fn(&str) -> Option<Vec<u8>> {
-    let dir = std::path::Path::new(path).parent().map(|d| d.join("images"));
-    move |r: &str| {
-        // Image refs are content hashes; anything else never becomes a path.
-        if r.is_empty() || r.len() > 128 || !r.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_') {
-            return None;
-        }
-        let dir = dir.as_ref()?;
-        ["", ".png", ".jpg", ".jpeg", ".gif", ".webp"]
-            .iter()
-            .find_map(|e| crate::file_access::read_capped(dir.join(format!("{r}{e}")), MAX_IMAGE_FILE).ok())
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-fn rest_images(_path: &str) -> impl Fn(&str) -> Option<Vec<u8>> {
-    figcraft_format::rest::no_images
-}
-
-/// Largest variables JSON read from disk.
-#[cfg(not(target_arch = "wasm32"))]
-const MAX_VARIABLES_FILE: u64 = 256 * 1024 * 1024;
-
-/// A local variables JSON next to a REST API file JSON: `<name>.variables.json`, else
-/// `variables.json`.
-#[cfg(not(target_arch = "wasm32"))]
-fn sibling_variables(path: &str) -> Option<Value> {
-    if ext(path) != "json" {
-        return None;
-    }
-    let file = std::path::Path::new(path);
-    let dir = file.parent()?;
-    [format!("{}.variables.json", file_stem(path)), "variables.json".to_string()].iter().map(|n| dir.join(n)).filter(|c| c != file).find_map(|c| {
-        let v: Value = serde_json::from_slice(&crate::file_access::read_capped(c, MAX_VARIABLES_FILE).ok()?).ok()?;
-        figcraft_format::rest::is_variables_json(&v).then_some(v)
-    })
-}
-
-#[cfg(target_arch = "wasm32")]
-fn sibling_variables(_path: &str) -> Option<Value> {
-    None
-}
-
-/// The local variables JSON a command passes as `variables`: an object, JSON text or a file path.
-pub(crate) fn variables_param(cmd: &str, p: &Value) -> Result<Option<Value>> {
-    let parse = |text: &[u8]| serde_json::from_slice::<Value>(text).map_err(|e| bad(cmd, format!("variables: {e}")));
-    let v = match get(p, "variables") {
-        None | Some(Value::Null) => return Ok(None),
-        Some(v @ Value::Object(_)) => v.clone(),
-        Some(Value::String(s)) if s.trim_start().starts_with('{') => parse(s.as_bytes())?,
-        Some(Value::String(path)) => parse(&read(path)?)?,
-        Some(_) => return Err(bad(cmd, "variables: the local variables JSON (an object, JSON text or a path)")),
-    };
-    if !figcraft_format::rest::is_variables_json(&v) {
-        return Err(bad(cmd, "variables: expected the local variables JSON (`meta.variableCollections` and `meta.variables`)"));
-    }
-    Ok(Some(v))
-}
-
-/// How many files File ▸ Open recent keeps.
-pub const MAX_RECENT: usize = 20;
-
-/// Put `path` at the top of the recent files.
-fn remember(s: &mut Session, path: &str) {
-    let r = &mut s.prefs.recent_files;
-    r.retain(|p| p != path);
-    r.insert(0, path.to_string());
-    r.truncate(MAX_RECENT);
-}
-
-fn open_recent(s: &mut Session, p: &Value) -> Result<Value> {
-    use crate::file_access::{Access, allow, allowed};
-    const CMD: &str = "file.openRecent";
-    // Confined to automation roots, the recent files outside them are never listed, opened, removed
-    // or named: `index` counts the files listed.
-    let listed = |r: &String| allowed(r, Access::Read);
-    if p.get("clear").and_then(Value::as_bool) == Some(true) {
-        s.prefs.recent_files.retain(|r| !listed(r));
-    }
-    if let Some(gone) = string(p, "remove") {
-        s.prefs.recent_files.retain(|r| *r != gone || !listed(r));
-    }
-    let path = match (string(p, "path"), num(p, "index")) {
-        (Some(path), _) => {
-            allow(&path, Access::Read)?;
-            Some(path)
-        }
-        (None, Some(i)) => {
-            Some(s.prefs.recent_files.iter().filter(|r| listed(r)).nth(i.max(0.0) as usize).cloned().ok_or_else(|| bad(CMD, "no such recent file"))?)
-        }
-        _ => None,
-    };
-    if let Some(path) = path {
-        if !crate::file_access::exists(&path) {
-            s.prefs.recent_files.retain(|r| *r != path);
-            return Err(bad(CMD, format!("{path} no longer exists")));
-        }
-        return open(s, &json!({"path": path}));
-    }
-    let files: Vec<Value> = s
-        .prefs
-        .recent_files
-        .iter()
-        .filter(|r| listed(r))
-        .map(|r| {
-            let name = std::path::Path::new(r).file_name().map_or_else(|| r.clone(), |f| f.to_string_lossy().into_owned());
-            json!({"path": r, "name": name, "exists": crate::file_access::exists(r)})
-        })
-        .collect();
-    Ok(json!({"files": files}))
-}
-
-fn open(s: &mut Session, p: &Value) -> Result<Value> {
-    let variables = variables_param("file.open", p)?;
-    if string(p, "path").is_none()
-        && let Some(d) = string(p, "data")
-    {
-        return open_data(s, &d, p, variables.as_ref());
-    }
-    let path = req_string("file.open", p, "path")?;
-    // Already open: switch to it.
-    if let Some(i) = s.docs.iter().position(|d| d.path.as_deref() == Some(path.as_str())) {
-        s.active = i;
-        remember(s, &path);
-        return Ok(json!({"index": i}));
-    }
-    // Stamped before reading: a change made during the read makes the next save refuse.
-    let on_disk = crate::library::stat(&path).ok();
-    let (loaded, rest) = load_path(&path, variables.as_ref())?;
-    remember(s, &path);
-    let native = !rest && matches!(ext(&path).as_str(), "figcraft" | "json");
-    let warnings = rest || ext(&path) == "svg";
-    // A native file that lost something (a damaged image, say): the app says so, not only the result.
-    if native && !loaded.issues.is_empty() {
-        s.message = Some(match loaded.issues.as_slice() {
-            [one] => format!("{}: {one}", file_stem(&path)),
-            more => format!("{}: {} problems were repaired or left out while opening it, e.g. {}", file_stem(&path), more.len(), more[0]),
-        });
-    }
-    let summary = import_summary(&loaded.doc);
-    let images_left_out = if native { loaded.images_past_budget } else { 0 };
-    let mut ds = DocState::new(loaded.doc, native.then(|| path.clone()))
-        .with_versions(loaded.versions)
-        .with_branches(loaded.branches)
-        .with_images_left_in_file(&path, images_left_out);
-    ds.on_disk = on_disk.filter(|_| native);
-    s.docs.push(ds);
-    s.active = s.docs.len() - 1;
-    let mut out = json!({"index": s.active, "summary": summary});
-    out[if warnings { "warnings" } else { "repairs" }] = json!(loaded.issues);
-    Ok(out)
-}
-
-/// [`open`] for a file given as base64 `data` (a file dropped without a path on disk): `name` tells
-/// the format. It opens as a new document with no path, so the first save asks where to put it.
-fn open_data(s: &mut Session, data: &str, p: &Value, variables: Option<&Value>) -> Result<Value> {
-    let name = req_string("file.open", p, "name")?;
-    let data = data.split_once(',').map_or(data, |(_, b)| b);
-    let bytes = base64::engine::general_purpose::STANDARD.decode(data.trim()).map_err(|e| bad("file.open", e.to_string()))?;
-    let (loaded, rest) = load_with(&bytes, &name, variables, &figcraft_format::rest::no_images)?;
-    let warnings = rest || ext(&name) == "svg";
-    let summary = import_summary(&loaded.doc);
-    s.docs.push(DocState::new(loaded.doc, None).with_versions(loaded.versions).with_branches(loaded.branches));
-    s.active = s.docs.len() - 1;
-    let mut out = json!({"index": s.active, "summary": summary});
-    out[if warnings { "warnings" } else { "repairs" }] = json!(loaded.issues);
-    Ok(out)
-}
-
-/// Thumbnail PNG of the first page's content (for file browsers / the home screen).
-pub fn thumbnail(doc: &Document) -> Option<Vec<u8>> {
-    let page = doc.first_page()?;
-    let b = doc.page_content_bounds(page)?;
-    let scale = (400.0 / b.width().max(b.height()).max(1.0)).min(2.0);
-    let view = figcraft_render::View {
-        origin: (b.x0, b.y0),
-        scale,
-        width: (b.width() * scale).ceil().max(1.0) as u32,
-        height: (b.height() * scale).ceil().max(1.0) as u32,
-    };
-    let pix = figcraft_render::render_view(doc, page, &view, &Default::default())?;
-    figcraft_render::encode_png(&pix).ok()
-}
-
-/// The `.figcraft` file for a document: content, thumbnail and version history.
-pub fn file_bytes(ds: &DocState) -> Result<Vec<u8>> {
-    FileSnapshot::of(ds).encode()
-}
-
-/// A document's file as it is at one moment, so the slow part of saving it (the thumbnail and the
-/// encoding) can run on another thread while editing goes on: [`encode`](Self::encode) there, then
-/// [`save`](Self::save) the bytes back on the session's thread.
-pub struct FileSnapshot {
-    uid: u64,
-    path: Option<String>,
-    revision: u64,
-    doc: Arc<Document>,
-    /// The document as last saved when the snapshot was taken: another save since makes it stale.
-    saved: Arc<Document>,
-    page: NodeId,
-    versions: Vec<Version>,
-    branches: Vec<figcraft_format::Branch>,
-}
-
-impl FileSnapshot {
-    pub fn of(ds: &DocState) -> Self {
-        Self {
-            uid: ds.uid,
-            path: ds.path.clone(),
-            revision: ds.revision,
-            doc: ds.doc.clone(),
-            saved: ds.saved_doc.clone(),
-            page: ds.page,
-            versions: ds.versions.clone(),
-            branches: ds.branches.clone(),
-        }
-    }
-
-    /// The file's bytes: content, thumbnail and version history.
-    pub fn encode(&self) -> Result<Vec<u8>> {
-        let mut doc = (*self.doc).clone();
-        doc.current_page = Some(self.page);
-        let thumb = thumbnail(&doc);
-        figcraft_format::save_bytes_with_history(&doc, thumb.as_deref(), &self.versions, &self.branches)
-            .map_err(|e| EngineError::Other(e.to_string()))
-    }
-
-    /// Write `bytes` (this snapshot's [`encode`](Self::encode)) to the document's file: it is saved
-    /// as of the snapshot, and edits since stay unsaved. False (nothing written) when the document
-    /// was closed, saved, reverted or given another path since: the bytes are out of date.
-    pub fn save(self, s: &mut Session, bytes: &[u8]) -> Result<bool> {
-        let Some(ds) = s.docs.iter_mut().find(|d| d.uid == self.uid && d.path == self.path && Arc::ptr_eq(&d.saved_doc, &self.saved)) else {
-            return Ok(false);
-        };
-        let path = self.path.as_deref().ok_or(EngineError::NoDocument)?;
-        refuse_dropping_images(ds, path)?;
-        refuse_overwriting_changes(ds, path)?;
-        write(path, bytes)?;
-        ds.note_on_disk();
-        // The history or branches may have changed since: then they still count as unsaved.
-        if ds.revision == self.revision {
-            ds.versions_changed = false;
-        }
-        ds.saved_doc = self.doc;
-        ds.revision += 1;
-        branch_tabs_saved(s, self.uid);
-        Ok(true)
-    }
-}
-
-fn refuse_dropping_images(ds: &DocState, path: &str) -> Result<()> {
-    match ds.images_lost_saving_to(path) {
-        Some(count) => Err(EngineError::Other(format!(
-            "{} wasn't saved: {count} of its images weren't loaded (together they pass what FigCraft reads from one file), and saving over it would delete them. Save it under another name; this file keeps them.",
-            file_stem(path)
-        ))),
-        None => Ok(()),
-    }
-}
-
-/// Saving over the tab's own file would lose what another app wrote to it since (#1330).
-fn refuse_overwriting_changes(ds: &DocState, path: &str) -> Result<()> {
-    match (&ds.on_disk, crate::library::stat(path)) {
-        (Some(was), Ok(now)) if now != *was => Err(EngineError::Other(format!(
-            "{} wasn't saved: the file changed on disk since it was opened or saved here (another app or figcraft-cli wrote to it), and saving would replace those changes. Revert to saved to load them, or Save as to keep this version as well.",
-            file_stem(path)
-        ))),
-        _ => Ok(()),
-    }
-}
-
-/// The branch tabs of the file in tab `uid` were saved with it.
-fn branch_tabs_saved(s: &mut Session, uid: u64) {
-    for tab in s.docs.iter_mut().filter(|d| d.branch_of.as_ref().is_some_and(|(m, _)| *m == uid)) {
-        tab.mark_saved();
-    }
-}
-
-fn color_profile(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "file.colorProfile";
-    let Some(name) = string(p, "profile") else {
-        s.request_ui("dialog.colorProfile", json!({}));
-        return Ok(json!({"profile": s.doc()?.color_profile.id(), "changed": false}));
-    };
-    let profile = figcraft_color::ColorProfile::parse(&name).ok_or_else(|| bad(cmd, "profile: srgb or displayP3"))?;
-    let convert = boolean(p, "convert").unwrap_or(true);
-    let changed = s.doc()?.color_profile != profile && s.doc_mut()?.set_color_profile(profile, convert);
-    Ok(json!({"profile": profile.id(), "changed": changed}))
-}
-
-/// Native saves act on the current document; a `.fig` copy exports the version shown, and a
-/// pending Save As choice must leave it shown until its destination is known.
-pub(crate) fn save_ends_preview(s: &Session, cmd: &str, p: &Value) -> bool {
-    let path =
-        string(p, "path").or_else(|| if cmd == "file.save" { s.docs.get(crate::branches::file_tab(s)).and_then(|ds| ds.path.clone()) } else { None });
-    path.is_some_and(|path| ext(&path) != "fig") || (cmd == "file.saveAs" && wants_data(p))
-}
-
-/// `file.saveAs` asked for the file's bytes instead of a path to write (the browser's download).
-fn wants_data(p: &Value) -> bool {
-    p.get("data").and_then(Value::as_bool) == Some(true)
-}
-
-/// Save the file of the active tab (the main file for a branch tab, with its branches), or export
-/// the active document as an experimental `.fig` copy without changing its native save state.
-/// Without a path the file comes back as base64 `data` for the caller to deliver (#969).
-fn save_to(s: &mut Session, path: Option<String>) -> Result<Value> {
-    if let Some(path) = path.as_deref().filter(|p| ext(p) == "fig") {
-        return export_fig(s, &json!({"path": path}));
-    }
-    let i = crate::branches::file_tab(s);
-    let ds = s.docs.get_mut(i).ok_or(EngineError::NoDocument)?;
-    // A download (no path) writes over no file.
-    if let Some(path) = path.as_deref() {
-        refuse_dropping_images(ds, path)?;
-    }
-    let mut snapshot = FileSnapshot::of(ds);
-    let follows_path = ds.path.as_deref().map_or(ds.doc.name == "Untitled", |old| ds.doc.name == file_stem(old));
-    if let Some(path) = path.as_deref()
-        && follows_path
-        && ds.path.as_deref() != Some(path)
-    {
-        Arc::make_mut(&mut snapshot.doc).name = file_stem(path);
-    }
-    let bytes = snapshot.encode()?;
-    let Some(path) = path else {
-        // The download can still be refused: the caller marks the file saved once it was delivered.
-        let name = format!("{}.figcraft", ds.doc.name);
-        return Ok(json!({"name": name, "bytes": bytes.len(), "data": base64::engine::general_purpose::STANDARD.encode(&bytes)}));
-    };
-    write(&path, &bytes)?;
-    ds.doc = snapshot.doc;
-    ds.path = Some(path.clone());
-    ds.note_on_disk();
-    mark_saved(s, &json!({}))?;
-    remember(s, &path);
-    Ok(json!({"path": path, "bytes": bytes.len()}))
-}
-
-/// The file of the active tab (with its branch tabs) now matches what was written or delivered.
-fn mark_saved(s: &mut Session, _: &Value) -> Result<Value> {
-    let i = crate::branches::file_tab(s);
-    let ds = s.docs.get_mut(i).ok_or(EngineError::NoDocument)?;
-    ds.mark_saved();
-    ds.revision += 1;
-    let uid = ds.uid;
-    branch_tabs_saved(s, uid);
-    Ok(json!({"saved": true}))
-}
-
-fn save(s: &mut Session, p: &Value) -> Result<Value> {
-    if let Some(path) = string(p, "path") {
-        return save_to(s, Some(path));
-    }
-    let ds = s.docs.get(crate::branches::file_tab(s)).ok_or(EngineError::NoDocument)?;
-    match ds.path.clone() {
-        // Earlier builds wrote native data under a .fig name: never overwrite that file with an export.
-        Some(path) if ext(&path) == "fig" => {
-            s.request_ui("dialog.saveAs", json!({}));
-            Err(EngineError::Disabled("file.save".into(), "the saved path ends in .fig: choose Save as or pass `path`".into()))
-        }
-        Some(path) => {
-            if p.get("overwrite").and_then(Value::as_bool) != Some(true) {
-                refuse_overwriting_changes(ds, &path)?;
-            }
-            save_to(s, Some(path))
-        }
-        None => {
-            s.request_ui("dialog.saveAs", json!({}));
-            Err(EngineError::Disabled("file.save".into(), "the file has no path yet: pass `path`".into()))
-        }
-    }
-}
-
-fn save_as(s: &mut Session, p: &Value) -> Result<Value> {
-    match string(p, "path") {
-        Some(mut path) => {
-            if ext(&path).is_empty() {
-                path.push_str(".figcraft");
-            }
-            save_to(s, Some(path))
-        }
-        None if wants_data(p) => save_to(s, None),
-        None => {
-            s.request_ui("dialog.saveAs", json!({}));
-            Err(EngineError::Disabled("file.saveAs".into(), "pass `path`".into()))
-        }
-    }
-}
-
-/// Encode `ids` (or the page) in `format` at `scale`.
-pub fn export_bytes(doc: &Document, ids: &[NodeId], format: ExportFormat, scale: f64) -> Result<Vec<u8>> {
-    export_bytes_with(doc, ids, &ExportSetting { format, ..Default::default() }, scale)
-}
-
-/// The page area exporting `ids` with `setting` covers: what they paint (a clipping frame's own
-/// area), or their boxes with "include bounding box" and for slices. Hidden layers paint nothing,
-/// so they take no room next to visible ones (a hidden-only export keeps its own area).
-pub fn export_area(doc: &Document, ids: &[NodeId], setting: &ExportSetting) -> Option<figcraft_geom::Rect> {
-    let any_visible = ids.iter().any(|i| doc.node(*i).is_some_and(|n| n.visible));
-    ids.iter()
-        .filter_map(|i| {
-            let node = doc.node(*i);
-            let slice = node.is_some_and(|n| matches!(n.kind, NodeKind::Slice));
-            if setting.include_bounding_box || slice {
-                doc.world_bounds(*i)
-            } else if any_visible && node.is_some_and(|n| !n.visible) {
-                None
-            } else {
-                figcraft_render::export_bounds(doc, *i)
-            }
-        })
-        .reduce(|a, b| a.union(b))
-}
-
-/// What an export of `ids` draws, bottom to top: the layers themselves, or (contents only off)
-/// every top-level layer of their page, so whatever shows in the area is in. A slice paints nothing
-/// itself: with contents only on, a slice inside a frame or group draws that frame or group, and a
-/// slice anywhere else draws every top-level layer of its page.
-pub fn drawn_layers(doc: &Document, ids: &[NodeId], setting: &ExportSetting) -> Vec<NodeId> {
-    let Some(page) = ids.first().and_then(|i| doc.page_of(*i)).and_then(|p| doc.node(p)) else {
-        return super::edit::z_sorted(doc, ids);
-    };
-    if !setting.contents_only {
-        return page.children.clone();
-    }
-    let mut own = Vec::with_capacity(ids.len());
-    for &i in ids {
-        if !doc.node(i).is_some_and(|n| matches!(n.kind, NodeKind::Slice)) {
-            own.push(i);
-            continue;
-        }
-        match slice_container(doc, i) {
-            Some(c) => own.push(c),
-            None => return page.children.clone(),
-        }
-    }
-    own.sort_unstable();
-    own.dedup();
-    super::edit::z_sorted(doc, &super::edit::roots(doc, &own))
-}
-
-/// The frame or group a slice sits in: None on the page or in a section.
-fn slice_container(doc: &Document, slice: NodeId) -> Option<NodeId> {
-    let parent = doc.node(slice)?.parent?;
-    doc.node(parent).is_some_and(|p| p.kind.is_frame_like() || matches!(p.kind, NodeKind::Group)).then_some(parent)
-}
-
-/// [`export_bytes`] with an export setting's format and options (its size is `scale`: see
-/// [`export_scale`]): contents only, include bounding box, the SVG, PDF and Vector Drawable options.
-pub fn export_bytes_with(doc: &Document, ids: &[NodeId], setting: &ExportSetting, scale: f64) -> Result<Vec<u8>> {
-    export_file(doc, ids, setting, scale).map(|(bytes, _)| bytes)
-}
-
 /// [`export_bytes_with`] and what the export changed or left out (Android Vector Drawable only;
 /// empty for the other formats).
 pub fn export_file(doc: &Document, ids: &[NodeId], setting: &ExportSetting, scale: f64) -> Result<(Vec<u8>, Vec<String>)> {
@@ -1336,112 +385,6 @@ pub fn export_file(doc: &Document, ids: &[NodeId], setting: &ExportSetting, scal
     }
 }
 
-/// What Copy as PNG puts on the clipboard: the layers together, at 2x (in the document's colour
-/// profile; the clipboard wants sRGB).
-pub fn copy_png(doc: &Document, ids: &[NodeId]) -> Option<figcraft_render::Pixmap> {
-    let area = export_area(doc, ids, &ExportSetting::default())?;
-    figcraft_render::render_area(doc, &super::edit::z_sorted(doc, ids), area, 2.0)
-}
-
-fn export(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "file.export";
-    let fig = match string(p, "format") {
-        Some(f) => f.eq_ignore_ascii_case("fig"),
-        None => string(p, "path").is_some_and(|pp| ext(&pp) == "fig"),
-    };
-    if fig {
-        return export_fig(s, p);
-    }
-    let doc = s.doc()?;
-    let mut ids = targets(s, p);
-    if ids.is_empty() {
-        ids = doc.get(s.page()?)?.children.clone();
-    }
-    let mut setting = export_setting(cmd, ExportSetting::default(), p)?;
-    if string(p, "format").is_none()
-        && let Some(f) = string(p, "path").and_then(|pp| ExportFormat::from_ext(&ext(&pp)))
-    {
-        setting.format = f;
-    }
-    let scale = match size_param(cmd, p)? {
-        Some(_) => export_scale(doc, &ids, &setting),
-        None => num_or(p, "scale", 1.0).clamp(0.01, ExportSize::MAX_SCALE),
-    };
-    let format = setting.format;
-    let (bytes, warnings) = export_file(doc, &ids, &setting, scale)?;
-    let mut out = match string(p, "path") {
-        Some(path) => {
-            write(&path, &bytes)?;
-            json!({"path": path, "bytes": bytes.len(), "format": format.ext()})
-        }
-        None => json!({"format": format.ext(), "data": base64::engine::general_purpose::STANDARD.encode(&bytes)}),
-    };
-    // Android Vector Drawables say what they changed or left out (an empty list when nothing).
-    if format == ExportFormat::VectorDrawable {
-        out["warnings"] = json!(warnings);
-    }
-    Ok(out)
-}
-
-/// The whole document as a `.fig` file (experimental: only round trips through our own importer
-/// are verified), with the warnings about what was left out.
-fn export_fig(s: &mut Session, p: &Value) -> Result<Value> {
-    let doc = s.doc()?;
-    let (bytes, warnings) = fig_bytes(doc)?;
-    match string(p, "path") {
-        Some(path) => {
-            write(&path, &bytes)?;
-            Ok(json!({"path": path, "bytes": bytes.len(), "format": "fig", "warnings": warnings}))
-        }
-        None => Ok(json!({"format": "fig", "data": base64::engine::general_purpose::STANDARD.encode(&bytes), "warnings": warnings})),
-    }
-}
-
-/// `doc` as a `.fig` file (with a thumbnail) and the warnings about what was left out.
-pub fn fig_bytes(doc: &Document) -> Result<(Vec<u8>, Vec<String>)> {
-    figcraft_format::fig::export(doc, thumbnail(doc).as_deref()).map_err(|e| EngineError::Other(e.to_string()))
-}
-
-/// The scale that gives `ids` (their export area together) `setting`'s export size.
-pub fn export_scale(doc: &Document, ids: &[NodeId], setting: &ExportSetting) -> f64 {
-    // Size-based exports ask for bounds before encoding. Let encoding report the depth error
-    // without entering a recursive bounds walk here; SVG/PDF do not use this raster scale.
-    if setting.format.is_vector() && figcraft_render::check_export_depth(doc, ids).is_err() {
-        return 1.0;
-    }
-    export_area(doc, ids, setting).map_or(1.0, |b| setting.size.scale_for(b.width(), b.height()))
-}
-
-/// `e` with the `size` ("2x", "512w", "512h" or `{by, value}`), `suffix` and `format` that `p` sets.
-pub(super) fn export_setting(cmd: &str, mut e: ExportSetting, p: &Value) -> Result<ExportSetting> {
-    if let Some(size) = size_param(cmd, p)? {
-        e.size = size;
-    }
-    if let Some(s) = string(p, "suffix") {
-        e.suffix = s.chars().filter(|c| !c.is_control()).take(200).collect();
-    }
-    if let Some(f) = string(p, "format") {
-        e.format = ExportFormat::from_ext(&f).ok_or_else(|| bad(cmd, "format: png|jpg|svg|pdf|webp|xml"))?;
-    }
-    if let Some(c) = vd_compat_param(cmd, p)? {
-        e.vd_compat = c;
-    }
-    e.print = print_param(cmd, p, e.print)?;
-    for (key, slot) in [
-        ("contentsOnly", &mut e.contents_only),
-        ("includeBoundingBox", &mut e.include_bounding_box),
-        ("svgOutlineText", &mut e.svg_outline_text),
-        ("svgIdAttribute", &mut e.svg_id_attribute),
-        ("svgSimplifyStroke", &mut e.svg_simplify_stroke),
-    ] {
-        match get(p, key) {
-            None | Some(Value::Null) => {}
-            Some(v) => *slot = bool_of(v).ok_or_else(|| bad(cmd, format!("{key}: true or false")))?,
-        }
-    }
-    Ok(e)
-}
-
 /// The `vdCompat` `p` passes: bestEffort, exact or ignore (anything else is an error).
 fn vd_compat_param(cmd: &str, p: &Value) -> Result<Option<VdCompat>> {
     match get(p, "vdCompat") {
@@ -1450,345 +393,6 @@ fn vd_compat_param(cmd: &str, p: &Value) -> Result<Option<VdCompat>> {
     }
 }
 
-/// Whether `p` sets any PDF print option.
-fn has_print_param(p: &Value) -> bool {
-    ["bleed", "cropMarks", "bleedMarks", "cmyk"].iter().any(|k| get(p, k).is_some_and(|v| !v.is_null()))
-}
-
-/// `base` with the PDF print options `p` sets: `bleed` (points, or a length like "3mm" or
-/// "0.125in"), `cropMarks`, `bleedMarks`, `cmyk`.
-pub(super) fn print_param(cmd: &str, p: &Value, mut base: PrintSettings) -> Result<PrintSettings> {
-    match get(p, "bleed") {
-        None | Some(Value::Null) => {}
-        Some(v) => {
-            let pt = match v {
-                Value::String(s) => PrintSettings::parse_length(s),
-                v => v.as_f64().filter(|n| n.is_finite() && *n >= 0.0),
-            };
-            base.bleed = pt
-                .filter(|b| *b <= PrintSettings::MAX_BLEED)
-                .ok_or_else(|| bad(cmd, "bleed: points, or a length like \"3mm\" or \"0.125in\" (up to 144 pt, 2 in)"))?;
-        }
-    }
-    for (key, slot) in [("cropMarks", &mut base.crop_marks), ("bleedMarks", &mut base.bleed_marks), ("cmyk", &mut base.cmyk)] {
-        match get(p, key) {
-            None | Some(Value::Null) => {}
-            Some(v) => *slot = bool_of(v).ok_or_else(|| bad(cmd, format!("{key}: true or false")))?,
-        }
-    }
-    Ok(base)
-}
-
-/// An export size passed as `size`: "2x", "512w", "512h", a number (scale) or `{by, value}`.
-fn size_param(cmd: &str, p: &Value) -> Result<Option<ExportSize>> {
-    let size = match get(p, "size") {
-        None | Some(Value::Null) => return Ok(None),
-        Some(Value::String(s)) => ExportSize::parse(s),
-        Some(Value::Number(n)) => n.as_f64().and_then(|value| ExportSize::Scale { value }.checked()),
-        Some(v) => serde_json::from_value::<ExportSize>(v.clone()).ok().and_then(ExportSize::checked),
-    };
-    size.map(Some).ok_or_else(|| bad(cmd, "size: 2x, 512w or 512h (or {by: scale|width|height, value})"))
-}
-
-/// Most files one `file.exportLayers` writes.
-const MAX_EXPORT_FILES: usize = 1000;
-/// Most bytes the files of one zip export add up to: the files, the archive and its base64 copy
-/// are all in memory at once (in the browser too).
-const MAX_ZIP_BYTES: usize = 256 << 20;
-
-/// Keep `bytes` as zip member `name`, unless the members would pass `limit` bytes together.
-fn add_member<'a>(members: &mut Vec<(&'a str, Vec<u8>)>, name: &'a str, bytes: Vec<u8>, limit: usize) -> Result<()> {
-    let total = members.iter().map(|(_, b)| b.len()).sum::<usize>().saturating_add(bytes.len());
-    if total > limit {
-        let mb = limit >> 20;
-        return Err(bad("file.exportLayers", format!("the files would pass {mb} MB as one zip: export fewer layers at a time, or to a folder")));
-    }
-    members.push((name, bytes));
-    Ok(())
-}
-
-/// One file of a layer export: the layer, its setting and the file name.
-pub struct ExportJob {
-    pub id: NodeId,
-    pub setting: ExportSetting,
-    pub file: String,
-}
-
-/// The files exporting `ids` with their export settings makes, with unique names (repeats get
-/// " 2", " 3"…). Layers without settings make none.
-pub fn export_jobs(doc: &Document, ids: &[NodeId]) -> Vec<ExportJob> {
-    jobs_for(ids.iter().filter_map(|i| Some((*i, doc.node(*i)?.exports.clone()))), doc)
-}
-
-/// The files exporting each layer with the settings beside it makes (see [`export_jobs`]).
-pub fn jobs_for(items: impl IntoIterator<Item = (NodeId, Vec<ExportSetting>)>, doc: &Document) -> Vec<ExportJob> {
-    let mut used = std::collections::BTreeSet::new();
-    let mut out = Vec::new();
-    for (id, settings) in items {
-        let Some(n) = doc.node(id) else { continue };
-        let base = export_path(&n.name);
-        for e in settings {
-            if out.len() >= MAX_EXPORT_FILES {
-                return out;
-            }
-            let stem = format!("{base}{}", safe_file_name(&e.file_suffix()));
-            let ext = e.format.ext();
-            let file =
-                (1..).map(|k| if k == 1 { format!("{stem}.{ext}") } else { format!("{stem} {k}.{ext}") }).find(|f| used.insert(f.to_lowercase()));
-            if let Some(file) = file {
-                out.push(ExportJob { id, setting: e, file });
-            }
-        }
-    }
-    out
-}
-
-/// The file path a layer name exports to, without extension: each `/` makes a folder; `.` and
-/// `..` segments are dropped, so it stays inside the export folder.
-fn export_path(name: &str) -> String {
-    let parts: Vec<String> =
-        name.split('/').map(|seg| safe_file_name(seg).trim().trim_end_matches('.').to_string()).filter(|seg| !seg.is_empty()).take(32).collect();
-    if parts.is_empty() { "Untitled".into() } else { parts.join("/") }
-}
-
-/// Characters no file name may contain (path separators and ones file systems reject).
-pub(crate) const FORBIDDEN_FILE_NAME_CHARS: &str = "/\\:*?\"<>|";
-
-/// `name` without path separators and characters file systems reject (`/ \ : * ? " < > |` and
-/// control characters become `_`); everything else is kept, up to the first 200 characters.
-/// `figcraft-cli export` names its files by this rule too (and keeps at most 100 characters before
-/// the number and extension it adds).
-pub fn safe_file_name(name: &str) -> String {
-    name.chars().take(200).map(|c| if c.is_control() || FORBIDDEN_FILE_NAME_CHARS.contains(c) { '_' } else { c }).collect()
-}
-
-/// Layers on `page` that have export settings (document order).
-pub fn exportable_layers(doc: &Document, page: NodeId) -> Vec<NodeId> {
-    doc.subtree(page).into_iter().skip(1).filter(|i| doc.node(*i).is_some_and(|n| !n.exports.is_empty())).collect()
-}
-
-fn export_layers(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "file.exportLayers";
-    let doc = s.doc()?;
-    let assets = boolean(p, "assets").unwrap_or(false);
-    let mut ids = targets(s, p);
-    if ids.is_empty() {
-        ids = if assets { vec![s.page()?] } else { exportable_layers(doc, s.page()?) };
-    }
-    let jobs = if assets { crate::devinspect::asset_jobs(doc, &ids) } else { export_jobs(doc, &ids) };
-    if jobs.is_empty() {
-        return Err(EngineError::Disabled(cmd.into(), "no export settings (add one with export.add)".into()));
-    }
-    let dir = string(p, "dir");
-    // The browser saves one download at a time: several files go as one zip (#969).
-    let zip = dir.is_none() && boolean(p, "zip").unwrap_or(false);
-    let mut members = Vec::new();
-    // Print options passed here stand in for every PDF setting's own.
-    let print = has_print_param(p).then(|| print_param(cmd, p, PrintSettings::default())).transpose()?;
-    // And a compatibility mode for every Android Vector Drawable.
-    let compat = vd_compat_param(cmd, p)?;
-    let mut files = Vec::with_capacity(jobs.len());
-    for job in &jobs {
-        let setting =
-            ExportSetting { print: print.unwrap_or(job.setting.print), vd_compat: compat.unwrap_or(job.setting.vd_compat), ..job.setting.clone() };
-        let scale = export_scale(doc, &[job.id], &setting);
-        let (bytes, warnings) = export_file(doc, &[job.id], &setting, scale)?;
-        let mut f = json!({"name": job.file, "id": job.id, "bytes": bytes.len()});
-        if setting.format == ExportFormat::VectorDrawable {
-            f["warnings"] = json!(warnings);
-        }
-        match &dir {
-            Some(d) => {
-                let path = std::path::Path::new(d).join(&job.file);
-                // A layer name with slashes exports into folders.
-                if let Some(parent) = path.parent() {
-                    let _ = crate::file_access::create_dir_all(parent);
-                }
-                let path = path.to_string_lossy().to_string();
-                write(&path, &bytes)?;
-                f["path"] = json!(path);
-            }
-            None if zip => add_member(&mut members, job.file.as_str(), bytes, MAX_ZIP_BYTES)?,
-            None => f["data"] = json!(base64::engine::general_purpose::STANDARD.encode(&bytes)),
-        }
-        files.push(f);
-    }
-    let with_settings: std::collections::BTreeSet<NodeId> = jobs.iter().map(|j| j.id).collect();
-    let mut r = json!({"files": files, "skipped": ids.len().saturating_sub(with_settings.len())});
-    if zip {
-        let archive = figcraft_format::zip_files(members.iter().map(|(n, b)| (*n, b.as_slice()))).map_err(|e| EngineError::Other(e.to_string()))?;
-        r["data"] = json!(base64::engine::general_purpose::STANDARD.encode(&archive));
-    }
-    Ok(r)
-}
-
-/// A PDF with one page per group of layers (an sRGB document), titled after the file; `area`
-/// sizes a single page to that page area instead of the layers' bounds.
-fn pdf_bytes(doc: &Document, groups: &[Vec<NodeId>], print: &PrintSettings, area: Option<figcraft_geom::Rect>) -> Result<Vec<u8>> {
-    let opts = figcraft_pdf::PdfOptions { title: Some(doc.name.clone()), print: *print, area, ..Default::default() };
-    figcraft_pdf::export_groups(doc, groups, &opts).map_err(|e| EngineError::Other(e.to_string()))
-}
-
-/// Every top-level frame of `page` (reading order) as one PDF page each, and the page count.
-pub fn frames_pdf(doc: &Document, page: NodeId, print: &PrintSettings) -> Result<(Vec<u8>, usize)> {
-    let mut frames = doc.top_frames(page);
-    frames.retain(|f| doc.node(*f).is_some_and(|n| n.visible));
-    if frames.is_empty() {
-        return Err(EngineError::Disabled("file.exportFramesPdf".into(), "the page has no visible frames".into()));
-    }
-    let groups: Vec<Vec<NodeId>> = frames.iter().map(|f| vec![*f]).collect();
-    Ok((pdf_bytes(&doc.in_srgb(), &groups, print, None)?, frames.len()))
-}
-
-/// Every top-level frame of a page (reading order), one PDF page each.
-fn export_frames_pdf(s: &mut Session, p: &Value) -> Result<Value> {
-    let doc = s.doc()?;
-    let page = match id(p, "page") {
-        Some(pg) if doc.node(pg).is_some_and(Node::is_page) => pg,
-        Some(_) => return Err(bad("file.exportFramesPdf", "`page` is not a page")),
-        None => s.page()?,
-    };
-    let print = print_param("file.exportFramesPdf", p, PrintSettings::default())?;
-    let (bytes, pages) = frames_pdf(doc, page, &print)?;
-    match string(p, "path") {
-        Some(path) => {
-            write(&path, &bytes)?;
-            Ok(json!({"path": path, "bytes": bytes.len(), "pages": pages}))
-        }
-        None => Ok(json!({"format": "pdf", "pages": pages, "data": base64::engine::general_purpose::STANDARD.encode(&bytes)})),
-    }
-}
-
-fn import(s: &mut Session, p: &Value) -> Result<Value> {
-    let path = string(p, "path");
-    let variables = variables_param("file.import", p)?;
-    let (bytes, name) = if let Some(path) = &path {
-        (read(path)?, path.clone())
-    } else if let Some(d) = string(p, "data") {
-        let d = d.split_once(',').map(|(_, b)| b.to_string()).unwrap_or(d);
-        (
-            base64::engine::general_purpose::STANDARD.decode(d.trim()).map_err(|e| bad("file.import", e.to_string()))?,
-            string(p, "name").unwrap_or_else(|| "import.png".into()),
-        )
-    } else {
-        return Err(bad("file.import", "pass `path` or `data`"));
-    };
-    let page = s.page()?;
-    let (x, y) = (num(p, "x"), num(p, "y"));
-    let center = s.ds().map(|d| (d.view.cx, d.view.cy)).unwrap_or((0.0, 0.0));
-    match ext(&name).as_str() {
-        "svg" => {
-            let doc = s.doc_mut()?;
-            let (x, y) = (x.unwrap_or(center.0), y.unwrap_or(center.1));
-            let imported =
-                figcraft_svg::import_svg_with_notes(doc, &bytes, page, x, y, &file_stem(&name)).map_err(|e| EngineError::Other(e.to_string()))?;
-            let id = imported.frame;
-            // Centred on the point (a paste lands in the middle of the view).
-            if boolean(p, "center").unwrap_or(false)
-                && let Some(n) = doc.node_mut(id)
-            {
-                n.transform = figcraft_geom::Affine::translate(((x - n.width / 2.0).round(), (y - n.height / 2.0).round()));
-            }
-            s.set_selection(vec![id]);
-            let mut out = json!({"id": id});
-            if !imported.notes.is_empty() {
-                out["warnings"] = json!(imported.notes);
-            }
-            Ok(out)
-        }
-        "figcraft" | "json" | "fig" | "sketch" => {
-            let resolver = path.as_deref().map(rest_images);
-            let images: figcraft_format::rest::ImageResolver = match &resolver {
-                Some(r) => r,
-                None => &figcraft_format::rest::no_images,
-            };
-            let sibling = if variables.is_none() { path.as_deref().and_then(sibling_variables) } else { None };
-            let (other, rest) = load_with(&bytes, &name, variables.as_ref().or(sibling.as_ref()), images)?;
-            let summary = import_summary(&other.doc);
-            let pages = append_pages(s.doc_mut()?, &other.doc)?;
-            let mut out = json!({"pages": pages, "summary": summary});
-            if rest {
-                out["warnings"] = json!(other.issues);
-            }
-            Ok(out)
-        }
-        _ => {
-            let b64 = base64::engine::general_purpose::STANDARD.encode(&bytes);
-            super::create::place_image(s, &json!({"data": b64, "x": x.unwrap_or(center.0), "y": y.unwrap_or(center.1), "name": file_stem(&name)}))
-        }
-    }
-}
-
-/// Append `other`'s pages (with their settings and flows, its images, styles and variables) to
-/// `doc`. Ids are remapped across all pages at once, so instances keep their main, instance layers
-/// their source and interactions and flows their targets wherever those are. Styles, variables and
-/// collections whose id the document already has are kept as they are.
-fn append_pages(doc: &mut Document, other: &Document) -> Result<Vec<NodeId>> {
-    for (k, v) in &other.images {
-        doc.images.entry(k.clone()).or_insert_with(|| v.clone());
-    }
-    for st in &other.styles {
-        if !doc.styles.iter().any(|s| s.id == st.id) {
-            doc.styles.push(st.clone());
-        }
-    }
-    let have: std::collections::BTreeSet<String> = doc.variables.collections.iter().map(|c| c.id.clone()).collect();
-    doc.variables.collections.extend(other.variables.collections.iter().filter(|c| !have.contains(&c.id)).cloned());
-    let have: std::collections::BTreeSet<String> = doc.variables.variables.iter().map(|v| v.id.clone()).collect();
-    doc.variables.variables.extend(other.variables.variables.iter().filter(|v| !have.contains(&v.id)).cloned());
-    let mut map = std::collections::BTreeMap::new();
-    for pg in &other.pages {
-        for id in other.subtree(*pg).into_iter().skip(1) {
-            map.insert(id, doc.alloc_id());
-        }
-    }
-    // Library copies a .fig import keeps (cached definitions) have no library record to follow:
-    // the layers of its store come along into the store of `doc`. Recorded copies are left to
-    // `merge_store`, which shares them with copies `doc` already has.
-    let cached: Vec<NodeId> = other
-        .library_store()
-        .and_then(|s| other.node(s))
-        .map(|s| s.children.iter().copied().filter(|root| other.libraries.import_of(*root).is_none()).collect())
-        .unwrap_or_default();
-    for root in &cached {
-        for id in other.subtree(*root) {
-            map.insert(id, doc.alloc_id());
-        }
-    }
-    let mut new_pages = Vec::new();
-    for pg in &other.pages {
-        let Some(pn) = other.node(*pg) else { continue };
-        let np = doc.add_page(&pn.name);
-        let mut kind = pn.kind.clone();
-        if let NodeKind::Page { flows, .. } = &mut kind {
-            flows.retain_mut(|f| map.get(&f.start).map(|n| f.start = *n).is_some());
-        }
-        if let Some(n) = doc.node_mut(np) {
-            n.kind = kind;
-        }
-        for c in &pn.children {
-            let nodes: Vec<Node> = other.subtree(*c).into_iter().filter_map(|i| other.node(i).cloned()).collect();
-            doc.paste_nodes(&nodes, &map, *c, np, None)?;
-        }
-        new_pages.push(np);
-    }
-    if !cached.is_empty() {
-        let store = doc.ensure_library_store();
-        for root in &cached {
-            let nodes: Vec<Node> = other.subtree(*root).into_iter().filter_map(|i| other.node(i).cloned()).collect();
-            doc.paste_nodes(&nodes, &map, *root, store, None)?;
-        }
-    }
-    for new in map.values() {
-        let src = doc.node(*new).and_then(|n| n.source).and_then(|s| map.get(&s).copied());
-        if let (Some(src), Some(n)) = (src, doc.node_mut(*new)) {
-            n.source = Some(src);
-        }
-    }
-    crate::library::merge_store(doc, other, &map)?;
-    Ok(new_pages)
-}
-
 fn close(s: &mut Session, p: &Value) -> Result<Value> {
     let i = if get(p, "index").is_none() { s.active } else { req_index("file.close", p, "index")? };
     let Some(ds) = s.docs.get(i) else { return Err(bad("file.close", "no such document")) };
diff --git a/crates/engine/src/cmd/file/export.rs b/crates/engine/src/cmd/file/export.rs
new file mode 100644
index 00000000..005afe6f
--- /dev/null
+++ b/crates/engine/src/cmd/file/export.rs
@@ -0,0 +1,383 @@
+use super::load::{ext, write};
+use super::save::thumbnail;
+use super::*;
+
+/// Encode `ids` (or the page) in `format` at `scale`.
+pub fn export_bytes(doc: &Document, ids: &[NodeId], format: ExportFormat, scale: f64) -> Result<Vec<u8>> {
+    export_bytes_with(doc, ids, &ExportSetting { format, ..Default::default() }, scale)
+}
+
+/// The page area exporting `ids` with `setting` covers: what they paint (a clipping frame's own
+/// area), or their boxes with "include bounding box" and for slices. Hidden layers paint nothing,
+/// so they take no room next to visible ones (a hidden-only export keeps its own area).
+pub fn export_area(doc: &Document, ids: &[NodeId], setting: &ExportSetting) -> Option<figcraft_geom::Rect> {
+    let any_visible = ids.iter().any(|i| doc.node(*i).is_some_and(|n| n.visible));
+    ids.iter()
+        .filter_map(|i| {
+            let node = doc.node(*i);
+            let slice = node.is_some_and(|n| matches!(n.kind, NodeKind::Slice));
+            if setting.include_bounding_box || slice {
+                doc.world_bounds(*i)
+            } else if any_visible && node.is_some_and(|n| !n.visible) {
+                None
+            } else {
+                figcraft_render::export_bounds(doc, *i)
+            }
+        })
+        .reduce(|a, b| a.union(b))
+}
+
+/// What an export of `ids` draws, bottom to top: the layers themselves, or (contents only off)
+/// every top-level layer of their page, so whatever shows in the area is in. A slice paints nothing
+/// itself: with contents only on, a slice inside a frame or group draws that frame or group, and a
+/// slice anywhere else draws every top-level layer of its page.
+pub fn drawn_layers(doc: &Document, ids: &[NodeId], setting: &ExportSetting) -> Vec<NodeId> {
+    let Some(page) = ids.first().and_then(|i| doc.page_of(*i)).and_then(|p| doc.node(p)) else {
+        return crate::cmd::edit::z_sorted(doc, ids);
+    };
+    if !setting.contents_only {
+        return page.children.clone();
+    }
+    let mut own = Vec::with_capacity(ids.len());
+    for &i in ids {
+        if !doc.node(i).is_some_and(|n| matches!(n.kind, NodeKind::Slice)) {
+            own.push(i);
+            continue;
+        }
+        match slice_container(doc, i) {
+            Some(c) => own.push(c),
+            None => return page.children.clone(),
+        }
+    }
+    own.sort_unstable();
+    own.dedup();
+    crate::cmd::edit::z_sorted(doc, &crate::cmd::edit::roots(doc, &own))
+}
+
+/// The frame or group a slice sits in: None on the page or in a section.
+fn slice_container(doc: &Document, slice: NodeId) -> Option<NodeId> {
+    let parent = doc.node(slice)?.parent?;
+    doc.node(parent).is_some_and(|p| p.kind.is_frame_like() || matches!(p.kind, NodeKind::Group)).then_some(parent)
+}
+
+/// [`export_bytes`] with an export setting's format and options (its size is `scale`: see
+/// [`export_scale`]): contents only, include bounding box, the SVG, PDF and Vector Drawable options.
+pub fn export_bytes_with(doc: &Document, ids: &[NodeId], setting: &ExportSetting, scale: f64) -> Result<Vec<u8>> {
+    export_file(doc, ids, setting, scale).map(|(bytes, _)| bytes)
+}
+
+/// What Copy as PNG puts on the clipboard: the layers together, at 2x (in the document's colour
+/// profile; the clipboard wants sRGB).
+pub fn copy_png(doc: &Document, ids: &[NodeId]) -> Option<figcraft_render::Pixmap> {
+    let area = export_area(doc, ids, &ExportSetting::default())?;
+    figcraft_render::render_area(doc, &crate::cmd::edit::z_sorted(doc, ids), area, 2.0)
+}
+
+pub(super) fn export(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "file.export";
+    let fig = match string(p, "format") {
+        Some(f) => f.eq_ignore_ascii_case("fig"),
+        None => string(p, "path").is_some_and(|pp| ext(&pp) == "fig"),
+    };
+    if fig {
+        return export_fig(s, p);
+    }
+    let doc = s.doc()?;
+    let mut ids = targets(s, p);
+    if ids.is_empty() {
+        ids = doc.get(s.page()?)?.children.clone();
+    }
+    let mut setting = export_setting(cmd, ExportSetting::default(), p)?;
+    if string(p, "format").is_none()
+        && let Some(f) = string(p, "path").and_then(|pp| ExportFormat::from_ext(&ext(&pp)))
+    {
+        setting.format = f;
+    }
+    let scale = match size_param(cmd, p)? {
+        Some(_) => export_scale(doc, &ids, &setting),
+        None => num_or(p, "scale", 1.0).clamp(0.01, ExportSize::MAX_SCALE),
+    };
+    let format = setting.format;
+    let (bytes, warnings) = export_file(doc, &ids, &setting, scale)?;
+    let mut out = match string(p, "path") {
+        Some(path) => {
+            write(&path, &bytes)?;
+            json!({"path": path, "bytes": bytes.len(), "format": format.ext()})
+        }
+        None => json!({"format": format.ext(), "data": base64::engine::general_purpose::STANDARD.encode(&bytes)}),
+    };
+    // Android Vector Drawables say what they changed or left out (an empty list when nothing).
+    if format == ExportFormat::VectorDrawable {
+        out["warnings"] = json!(warnings);
+    }
+    Ok(out)
+}
+
+/// The whole document as a `.fig` file (experimental: only round trips through our own importer
+/// are verified), with the warnings about what was left out.
+pub(super) fn export_fig(s: &mut Session, p: &Value) -> Result<Value> {
+    let doc = s.doc()?;
+    let (bytes, warnings) = fig_bytes(doc)?;
+    match string(p, "path") {
+        Some(path) => {
+            write(&path, &bytes)?;
+            Ok(json!({"path": path, "bytes": bytes.len(), "format": "fig", "warnings": warnings}))
+        }
+        None => Ok(json!({"format": "fig", "data": base64::engine::general_purpose::STANDARD.encode(&bytes), "warnings": warnings})),
+    }
+}
+
+/// `doc` as a `.fig` file (with a thumbnail) and the warnings about what was left out.
+pub fn fig_bytes(doc: &Document) -> Result<(Vec<u8>, Vec<String>)> {
+    figcraft_format::fig::export(doc, thumbnail(doc).as_deref()).map_err(|e| EngineError::Other(e.to_string()))
+}
+
+/// The scale that gives `ids` (their export area together) `setting`'s export size.
+pub fn export_scale(doc: &Document, ids: &[NodeId], setting: &ExportSetting) -> f64 {
+    // Size-based exports ask for bounds before encoding. Let encoding report the depth error
+    // without entering a recursive bounds walk here; SVG/PDF do not use this raster scale.
+    if setting.format.is_vector() && figcraft_render::check_export_depth(doc, ids).is_err() {
+        return 1.0;
+    }
+    export_area(doc, ids, setting).map_or(1.0, |b| setting.size.scale_for(b.width(), b.height()))
+}
+
+/// `e` with the `size` ("2x", "512w", "512h" or `{by, value}`), `suffix` and `format` that `p` sets.
+pub(in crate::cmd) fn export_setting(cmd: &str, mut e: ExportSetting, p: &Value) -> Result<ExportSetting> {
+    if let Some(size) = size_param(cmd, p)? {
+        e.size = size;
+    }
+    if let Some(s) = string(p, "suffix") {
+        e.suffix = s.chars().filter(|c| !c.is_control()).take(200).collect();
+    }
+    if let Some(f) = string(p, "format") {
+        e.format = ExportFormat::from_ext(&f).ok_or_else(|| bad(cmd, "format: png|jpg|svg|pdf|webp|xml"))?;
+    }
+    if let Some(c) = vd_compat_param(cmd, p)? {
+        e.vd_compat = c;
+    }
+    e.print = print_param(cmd, p, e.print)?;
+    for (key, slot) in [
+        ("contentsOnly", &mut e.contents_only),
+        ("includeBoundingBox", &mut e.include_bounding_box),
+        ("svgOutlineText", &mut e.svg_outline_text),
+        ("svgIdAttribute", &mut e.svg_id_attribute),
+        ("svgSimplifyStroke", &mut e.svg_simplify_stroke),
+    ] {
+        match get(p, key) {
+            None | Some(Value::Null) => {}
+            Some(v) => *slot = bool_of(v).ok_or_else(|| bad(cmd, format!("{key}: true or false")))?,
+        }
+    }
+    Ok(e)
+}
+
+/// Whether `p` sets any PDF print option.
+fn has_print_param(p: &Value) -> bool {
+    ["bleed", "cropMarks", "bleedMarks", "cmyk"].iter().any(|k| get(p, k).is_some_and(|v| !v.is_null()))
+}
+
+/// `base` with the PDF print options `p` sets: `bleed` (points, or a length like "3mm" or
+/// "0.125in"), `cropMarks`, `bleedMarks`, `cmyk`.
+pub(in crate::cmd) fn print_param(cmd: &str, p: &Value, mut base: PrintSettings) -> Result<PrintSettings> {
+    match get(p, "bleed") {
+        None | Some(Value::Null) => {}
+        Some(v) => {
+            let pt = match v {
+                Value::String(s) => PrintSettings::parse_length(s),
+                v => v.as_f64().filter(|n| n.is_finite() && *n >= 0.0),
+            };
+            base.bleed = pt
+                .filter(|b| *b <= PrintSettings::MAX_BLEED)
+                .ok_or_else(|| bad(cmd, "bleed: points, or a length like \"3mm\" or \"0.125in\" (up to 144 pt, 2 in)"))?;
+        }
+    }
+    for (key, slot) in [("cropMarks", &mut base.crop_marks), ("bleedMarks", &mut base.bleed_marks), ("cmyk", &mut base.cmyk)] {
+        match get(p, key) {
+            None | Some(Value::Null) => {}
+            Some(v) => *slot = bool_of(v).ok_or_else(|| bad(cmd, format!("{key}: true or false")))?,
+        }
+    }
+    Ok(base)
+}
+
+/// An export size passed as `size`: "2x", "512w", "512h", a number (scale) or `{by, value}`.
+fn size_param(cmd: &str, p: &Value) -> Result<Option<ExportSize>> {
+    let size = match get(p, "size") {
+        None | Some(Value::Null) => return Ok(None),
+        Some(Value::String(s)) => ExportSize::parse(s),
+        Some(Value::Number(n)) => n.as_f64().and_then(|value| ExportSize::Scale { value }.checked()),
+        Some(v) => serde_json::from_value::<ExportSize>(v.clone()).ok().and_then(ExportSize::checked),
+    };
+    size.map(Some).ok_or_else(|| bad(cmd, "size: 2x, 512w or 512h (or {by: scale|width|height, value})"))
+}
+
+/// Most files one `file.exportLayers` writes.
+const MAX_EXPORT_FILES: usize = 1000;
+
+/// Most bytes the files of one zip export add up to: the files, the archive and its base64 copy
+/// are all in memory at once (in the browser too).
+const MAX_ZIP_BYTES: usize = 256 << 20;
+
+/// Keep `bytes` as zip member `name`, unless the members would pass `limit` bytes together.
+pub(super) fn add_member<'a>(members: &mut Vec<(&'a str, Vec<u8>)>, name: &'a str, bytes: Vec<u8>, limit: usize) -> Result<()> {
+    let total = members.iter().map(|(_, b)| b.len()).sum::<usize>().saturating_add(bytes.len());
+    if total > limit {
+        let mb = limit >> 20;
+        return Err(bad("file.exportLayers", format!("the files would pass {mb} MB as one zip: export fewer layers at a time, or to a folder")));
+    }
+    members.push((name, bytes));
+    Ok(())
+}
+
+/// One file of a layer export: the layer, its setting and the file name.
+pub struct ExportJob {
+    pub id: NodeId,
+    pub setting: ExportSetting,
+    pub file: String,
+}
+
+/// The files exporting `ids` with their export settings makes, with unique names (repeats get
+/// " 2", " 3"…). Layers without settings make none.
+pub fn export_jobs(doc: &Document, ids: &[NodeId]) -> Vec<ExportJob> {
+    jobs_for(ids.iter().filter_map(|i| Some((*i, doc.node(*i)?.exports.clone()))), doc)
+}
+
+/// The files exporting each layer with the settings beside it makes (see [`export_jobs`]).
+pub fn jobs_for(items: impl IntoIterator<Item = (NodeId, Vec<ExportSetting>)>, doc: &Document) -> Vec<ExportJob> {
+    let mut used = std::collections::BTreeSet::new();
+    let mut out = Vec::new();
+    for (id, settings) in items {
+        let Some(n) = doc.node(id) else { continue };
+        let base = export_path(&n.name);
+        for e in settings {
+            if out.len() >= MAX_EXPORT_FILES {
+                return out;
+            }
+            let stem = format!("{base}{}", safe_file_name(&e.file_suffix()));
+            let ext = e.format.ext();
+            let file =
+                (1..).map(|k| if k == 1 { format!("{stem}.{ext}") } else { format!("{stem} {k}.{ext}") }).find(|f| used.insert(f.to_lowercase()));
+            if let Some(file) = file {
+                out.push(ExportJob { id, setting: e, file });
+            }
+        }
+    }
+    out
+}
+
+/// The file path a layer name exports to, without extension: each `/` makes a folder; `.` and
+/// `..` segments are dropped, so it stays inside the export folder.
+fn export_path(name: &str) -> String {
+    let parts: Vec<String> =
+        name.split('/').map(|seg| safe_file_name(seg).trim().trim_end_matches('.').to_string()).filter(|seg| !seg.is_empty()).take(32).collect();
+    if parts.is_empty() { "Untitled".into() } else { parts.join("/") }
+}
+
+/// Characters no file name may contain (path separators and ones file systems reject).
+pub(crate) const FORBIDDEN_FILE_NAME_CHARS: &str = "/\\:*?\"<>|";
+
+/// `name` without path separators and characters file systems reject (`/ \ : * ? " < > |` and
+/// control characters become `_`); everything else is kept, up to the first 200 characters.
+/// `figcraft-cli export` names its files by this rule too (and keeps at most 100 characters before
+/// the number and extension it adds).
+pub fn safe_file_name(name: &str) -> String {
+    name.chars().take(200).map(|c| if c.is_control() || FORBIDDEN_FILE_NAME_CHARS.contains(c) { '_' } else { c }).collect()
+}
+
+/// Layers on `page` that have export settings (document order).
+pub fn exportable_layers(doc: &Document, page: NodeId) -> Vec<NodeId> {
+    doc.subtree(page).into_iter().skip(1).filter(|i| doc.node(*i).is_some_and(|n| !n.exports.is_empty())).collect()
+}
+
+pub(super) fn export_layers(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "file.exportLayers";
+    let doc = s.doc()?;
+    let assets = boolean(p, "assets").unwrap_or(false);
+    let mut ids = targets(s, p);
+    if ids.is_empty() {
+        ids = if assets { vec![s.page()?] } else { exportable_layers(doc, s.page()?) };
+    }
+    let jobs = if assets { crate::devinspect::asset_jobs(doc, &ids) } else { export_jobs(doc, &ids) };
+    if jobs.is_empty() {
+        return Err(EngineError::Disabled(cmd.into(), "no export settings (add one with export.add)".into()));
+    }
+    let dir = string(p, "dir");
+    // The browser saves one download at a time: several files go as one zip (#969).
+    let zip = dir.is_none() && boolean(p, "zip").unwrap_or(false);
+    let mut members = Vec::new();
+    // Print options passed here stand in for every PDF setting's own.
+    let print = has_print_param(p).then(|| print_param(cmd, p, PrintSettings::default())).transpose()?;
+    // And a compatibility mode for every Android Vector Drawable.
+    let compat = vd_compat_param(cmd, p)?;
+    let mut files = Vec::with_capacity(jobs.len());
+    for job in &jobs {
+        let setting =
+            ExportSetting { print: print.unwrap_or(job.setting.print), vd_compat: compat.unwrap_or(job.setting.vd_compat), ..job.setting.clone() };
+        let scale = export_scale(doc, &[job.id], &setting);
+        let (bytes, warnings) = export_file(doc, &[job.id], &setting, scale)?;
+        let mut f = json!({"name": job.file, "id": job.id, "bytes": bytes.len()});
+        if setting.format == ExportFormat::VectorDrawable {
+            f["warnings"] = json!(warnings);
+        }
+        match &dir {
+            Some(d) => {
+                let path = std::path::Path::new(d).join(&job.file);
+                // A layer name with slashes exports into folders.
+                if let Some(parent) = path.parent() {
+                    let _ = crate::file_access::create_dir_all(parent);
+                }
+                let path = path.to_string_lossy().to_string();
+                write(&path, &bytes)?;
+                f["path"] = json!(path);
+            }
+            None if zip => add_member(&mut members, job.file.as_str(), bytes, MAX_ZIP_BYTES)?,
+            None => f["data"] = json!(base64::engine::general_purpose::STANDARD.encode(&bytes)),
+        }
+        files.push(f);
+    }
+    let with_settings: std::collections::BTreeSet<NodeId> = jobs.iter().map(|j| j.id).collect();
+    let mut r = json!({"files": files, "skipped": ids.len().saturating_sub(with_settings.len())});
+    if zip {
+        let archive = figcraft_format::zip_files(members.iter().map(|(n, b)| (*n, b.as_slice()))).map_err(|e| EngineError::Other(e.to_string()))?;
+        r["data"] = json!(base64::engine::general_purpose::STANDARD.encode(&archive));
+    }
+    Ok(r)
+}
+
+/// A PDF with one page per group of layers (an sRGB document), titled after the file; `area`
+/// sizes a single page to that page area instead of the layers' bounds.
+pub(super) fn pdf_bytes(doc: &Document, groups: &[Vec<NodeId>], print: &PrintSettings, area: Option<figcraft_geom::Rect>) -> Result<Vec<u8>> {
+    let opts = figcraft_pdf::PdfOptions { title: Some(doc.name.clone()), print: *print, area, ..Default::default() };
+    figcraft_pdf::export_groups(doc, groups, &opts).map_err(|e| EngineError::Other(e.to_string()))
+}
+
+/// Every top-level frame of `page` (reading order) as one PDF page each, and the page count.
+pub fn frames_pdf(doc: &Document, page: NodeId, print: &PrintSettings) -> Result<(Vec<u8>, usize)> {
+    let mut frames = doc.top_frames(page);
+    frames.retain(|f| doc.node(*f).is_some_and(|n| n.visible));
+    if frames.is_empty() {
+        return Err(EngineError::Disabled("file.exportFramesPdf".into(), "the page has no visible frames".into()));
+    }
+    let groups: Vec<Vec<NodeId>> = frames.iter().map(|f| vec![*f]).collect();
+    Ok((pdf_bytes(&doc.in_srgb(), &groups, print, None)?, frames.len()))
+}
+
+/// Every top-level frame of a page (reading order), one PDF page each.
+pub(super) fn export_frames_pdf(s: &mut Session, p: &Value) -> Result<Value> {
+    let doc = s.doc()?;
+    let page = match id(p, "page") {
+        Some(pg) if doc.node(pg).is_some_and(Node::is_page) => pg,
+        Some(_) => return Err(bad("file.exportFramesPdf", "`page` is not a page")),
+        None => s.page()?,
+    };
+    let print = print_param("file.exportFramesPdf", p, PrintSettings::default())?;
+    let (bytes, pages) = frames_pdf(doc, page, &print)?;
+    match string(p, "path") {
+        Some(path) => {
+            write(&path, &bytes)?;
+            Ok(json!({"path": path, "bytes": bytes.len(), "pages": pages}))
+        }
+        None => Ok(json!({"format": "pdf", "pages": pages, "data": base64::engine::general_purpose::STANDARD.encode(&bytes)})),
+    }
+}
diff --git a/crates/engine/src/cmd/file/load.rs b/crates/engine/src/cmd/file/load.rs
new file mode 100644
index 00000000..071c651e
--- /dev/null
+++ b/crates/engine/src/cmd/file/load.rs
@@ -0,0 +1,416 @@
+use super::*;
+
+/// The recovery copy at `path` as a document with unsaved changes and no path.
+pub(crate) fn recovered(path: &str) -> Result<DocState> {
+    let loaded = read(path).and_then(|b| figcraft_format::load_bytes_with_versions(&b).map_err(|e| EngineError::Other(e.to_string())))?;
+    Ok(DocState::new(loaded.doc, None).with_versions(loaded.versions).with_branches(loaded.branches).unsaved())
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn read(path: &str) -> Result<Vec<u8>> {
+    crate::file_access::read(path)
+}
+
+#[cfg(target_arch = "wasm32")]
+pub(super) fn read(path: &str) -> Result<Vec<u8>> {
+    Err(EngineError::Other(format!("{path}: no file system in the browser")))
+}
+
+/// The bytes of file `path`, refused when it's larger than `max`.
+pub(crate) fn read_capped(path: &str, max: u64) -> Result<Vec<u8>> {
+    crate::file_access::read_capped(path, max)
+}
+
+/// Write `bytes` to `path` through a uniquely named, exclusively created staging file and one
+/// atomic rename (see [`figcraft_format::write_file_atomic`]): a failed or interrupted write never
+/// truncates `path`, and no file or symlink at a staging name is ever written through.
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) fn write(path: &str, bytes: &[u8]) -> Result<()> {
+    crate::file_access::write(path, bytes)
+}
+
+#[cfg(target_arch = "wasm32")]
+pub(crate) fn write(path: &str, _bytes: &[u8]) -> Result<()> {
+    Err(EngineError::Other(format!("{path}: no file system in the browser")))
+}
+
+pub(super) fn ext(path: &str) -> String {
+    std::path::Path::new(path).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("").to_ascii_lowercase()
+}
+
+pub(super) fn file_stem(path: &str) -> String {
+    std::path::Path::new(path).file_stem().and_then(std::ffi::OsStr::to_str).unwrap_or("Untitled").to_string()
+}
+
+/// The counts the import report shows for a freshly loaded document.
+pub(super) fn import_summary(doc: &Document) -> Value {
+    json!({"name": doc.name, "pages": doc.pages.len(), "layers": doc.nodes().filter(|n| !n.is_page()).count(), "images": doc.images.len()})
+}
+
+/// Load a document from any supported file (REST API file JSON images come from an `images`
+/// folder next to the file).
+pub fn load(path: &str) -> Result<(Document, Vec<String>)> {
+    load_path(path, None).map(|(l, _)| (l.doc, l.issues))
+}
+
+pub fn load_bytes(bytes: &[u8], name_hint: &str) -> Result<(Document, Vec<String>)> {
+    load_with(bytes, name_hint, None, &figcraft_format::rest::no_images).map(|(l, _)| (l.doc, l.issues))
+}
+
+/// [`load`] with the version history, also telling whether the file was REST API file JSON. A REST
+/// import reads its variables from `variables`, else from a variables JSON next to the file.
+pub fn load_path(path: &str, variables: Option<&Value>) -> Result<(figcraft_format::Loaded, bool)> {
+    let bytes = read(path)?;
+    let sibling = if variables.is_none() { sibling_variables(path) } else { None };
+    load_with(&bytes, path, variables.or(sibling.as_ref()), &rest_images(path))
+}
+
+/// Load from bytes. Returns the document with its notes (repairs of a native file, or import
+/// warnings) and version history, and whether it was imported from REST API file JSON or a `.fig`
+/// file (such a file is never saved over). `variables`: the local variables JSON for a REST API file JSON.
+pub(super) fn load_with(
+    bytes: &[u8],
+    name_hint: &str,
+    variables: Option<&Value>,
+    images: figcraft_format::rest::ImageResolver,
+) -> Result<(figcraft_format::Loaded, bool)> {
+    match ext(name_hint).as_str() {
+        "svg" => {
+            let mut doc = Document::new(file_stem(name_hint));
+            let page = doc.first_page().ok_or(EngineError::NoDocument)?;
+            let notes = figcraft_svg::import_svg_with_notes(&mut doc, bytes, page, 0.0, 0.0, &file_stem(name_hint))
+                .map_err(|e| EngineError::Other(e.to_string()))?
+                .notes;
+            Ok((figcraft_format::Loaded { issues: notes, ..doc.into() }, false))
+        }
+        "png" | "jpg" | "jpeg" | "gif" | "webp" | "bmp" | "tif" | "tiff" => {
+            let mut doc = Document::new(file_stem(name_hint));
+            let page = doc.first_page().ok_or(EngineError::NoDocument)?;
+            let (hash, w, h) = figcraft_format::add_image(&mut doc, bytes.to_vec()).map_err(|e| EngineError::Other(e.to_string()))?;
+            let id = doc.create(page, NodeKind::Rectangle, &file_stem(name_hint), 0.0, 0.0, f64::from(w), f64::from(h))?;
+            doc.get_mut(id)?.fills = vec![figcraft_color::Paint::image(hash, figcraft_color::ImageScaleMode::Fill)];
+            Ok((doc.into(), false))
+        }
+        _ => {
+            if let Some(r) = load_fig(bytes, &file_stem(name_hint)) {
+                return Ok((r?, true));
+            }
+            if let Some(r) = load_sketch(bytes, &file_stem(name_hint)) {
+                return Ok((r?, true));
+            }
+            if let Some(r) = figcraft_format::rest::try_import_with(bytes, variables, images) {
+                let (mut doc, warnings) = r.map_err(|e| EngineError::Other(e.to_string()))?;
+                link_instances(&mut doc);
+                return Ok((figcraft_format::Loaded { issues: warnings, ..doc.into() }, true));
+            }
+            let mut loaded = figcraft_format::load_bytes_with_versions(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
+            // Older files saved an untouched default title even after the user chose a filename.
+            if loaded.doc.name.is_empty() || loaded.doc.name == "Untitled" {
+                loaded.doc.name = file_stem(name_hint);
+            }
+            Ok((loaded, false))
+        }
+    }
+}
+
+/// Gives `None` when `bytes` are not a `.sketch` file. Then other readers can try.
+fn load_sketch(bytes: &[u8], name: &str) -> Option<Result<figcraft_format::Loaded>> {
+    if !figcraft_format::sketch::is_sketch(bytes) {
+        return None;
+    }
+    // The import and what follows read the installed fonts: the system's must be known first (the
+    // desktop app scans them in the background; this waits for that scan).
+    figcraft_text::fontdb::scan_system_fonts();
+    let fonts: figcraft_format::sketch::FontLookup = Box::new(figcraft_text::fontdb::postscript_face);
+    let r = figcraft_format::sketch::try_import_with_fonts(bytes, name, Some(fonts))?;
+    Some(r.map_err(|e| EngineError::Other(e.to_string())).map(|(mut doc, warnings)| {
+        match_font_families(&mut doc);
+        platform_tracking(&mut doc);
+        sketch_line_heights(&mut doc);
+        link_instances(&mut doc);
+        reflow_overridden_text(&mut doc);
+        figcraft_format::Loaded { issues: warnings, ..doc.into() }
+    }))
+}
+
+/// Instances of a stack sized apart from their main are laid out at their size, and texts in
+/// instances whose string an override changed are measured again with the auto layout around them
+/// re-flowing (Sketch saves layouts measured with the master's string). The rest keeps the layout
+/// Sketch saved.
+fn reflow_overridden_text(doc: &mut Document) {
+    let changed: Vec<NodeId> = doc
+        .nodes()
+        .filter(|n| match (&n.kind, n.source.and_then(|s| doc.node(s)).map(|s| &s.kind)) {
+            (NodeKind::Text(t), Some(NodeKind::Text(main))) => t.characters != main.characters,
+            _ => false,
+        })
+        .map(|n| n.id)
+        .collect();
+    let m = crate::measure::TextMeasure;
+    // Instances of a stack at another size than their main: the stack at their size, innermost first.
+    let mut resized: Vec<(usize, NodeId)> = doc
+        .nodes()
+        .filter(|n| n.layout.is_some())
+        .filter(|n| match &n.kind {
+            NodeKind::Instance { component, .. } => {
+                doc.node(*component).is_some_and(|c| (c.width - n.width).abs() > 1e-6 || (c.height - n.height).abs() > 1e-6)
+            }
+            _ => false,
+        })
+        .map(|n| (doc.ancestors(n.id).len(), n.id))
+        .collect();
+    resized.sort_by_key(|r| std::cmp::Reverse(r.0));
+    for (_, id) in resized {
+        figcraft_layout::layout_frame(doc, id, &m);
+    }
+    for id in changed {
+        if let Some((w, h)) = doc.node(id).and_then(figcraft_text::auto_size) {
+            figcraft_layout::set_size(doc, id, w, h);
+        }
+        figcraft_layout::layout_up(doc, id, &m);
+    }
+}
+
+/// Font families a `.sketch` import guessed from PostScript names ("Ping Fang SC" from
+/// "PingFangSC-Semibold") take the installed family's name when they differ only in spaces and
+/// case.
+fn match_font_families(doc: &mut Document) {
+    let installed = figcraft_text::fontdb::family_names();
+    let mut cache: std::collections::BTreeMap<String, Option<String>> = std::collections::BTreeMap::new();
+    let mut fix = |style: &mut figcraft_doc::TextStyle| {
+        let found = cache.entry(style.font_family.clone()).or_insert_with(|| installed_family(&style.font_family, &installed));
+        if let Some(f) = found {
+            style.font_family = f.clone();
+        }
+    };
+    let ids: Vec<NodeId> = doc.nodes().filter(|n| matches!(n.kind, NodeKind::Text(_))).map(|n| n.id).collect();
+    for id in ids {
+        if let Some(NodeKind::Text(td)) = doc.node_mut(id).map(|n| &mut n.kind) {
+            fix(&mut td.style);
+            for r in &mut td.runs {
+                fix(&mut r.style);
+            }
+        }
+    }
+    // Shared text styles too, so they stay like the layers linked to them.
+    for st in &mut doc.styles {
+        if let StyleKind::Text { style } = &mut st.kind {
+            fix(style);
+        }
+    }
+}
+
+/// Sketch draws text with the tracking a font's `trak` table gives at its size (Apple's text engine
+/// adds it; FigCraft's, like Figma's, doesn't): the imported text keeps it as letter spacing, so
+/// lines measure and break as they did there. A named style's optical size follows the text size
+/// there too (FigCraft keeps the instance's), so the imported text carries it as an `opsz` value.
+fn platform_tracking(doc: &mut Document) {
+    let mut cache: std::collections::BTreeMap<(String, String), Option<std::sync::Arc<figcraft_text::fontdb::Face>>> =
+        std::collections::BTreeMap::new();
+    let mut face = |style: &figcraft_doc::TextStyle| {
+        cache
+            .entry((style.font_family.clone(), style.font_style.clone()))
+            .or_insert_with(|| {
+                figcraft_text::fontdb::has_family(&style.font_family)
+                    .then(|| figcraft_text::fontdb::find_face(&style.font_family, &style.font_style))
+                    .flatten()
+            })
+            .clone()
+    };
+    let mut track = |style: &mut figcraft_doc::TextStyle| {
+        let Some(f) = face(style) else { return };
+        let t = f.tracking(style.font_size);
+        if t != 0.0 && t.is_finite() {
+            let px = style.letter_spacing.resolve(style.font_size);
+            style.letter_spacing = figcraft_doc::LetterSpacing::Pixels(px + t);
+        }
+        if f.axis("opsz").is_some() && f.instance(&style.font_style).is_some() && style.font_size.is_finite() {
+            style.variations.entry("opsz".into()).or_insert(style.font_size);
+        }
+    };
+    let ids: Vec<NodeId> = doc.nodes().filter(|n| matches!(n.kind, NodeKind::Text(_))).map(|n| n.id).collect();
+    for id in ids {
+        if let Some(NodeKind::Text(td)) = doc.node_mut(id).map(|n| &mut n.kind) {
+            track(&mut td.style);
+            for r in &mut td.runs {
+                track(&mut r.style);
+            }
+        }
+    }
+    for st in &mut doc.styles {
+        if let StyleKind::Text { style } = &mut st.kind {
+            track(style);
+        }
+    }
+}
+
+/// Families Sketch (Apple's text system) gives a fifth more than their ascent and descent as their
+/// natural line: classic Mac fonts, found on `sketchtool` renders. Other fonts show none of this.
+const TALL_LINE_FAMILIES: [&str; 11] =
+    ["Academy Engraved LET", "Courier", "Helvetica", "Hoefler Text", "Palatino", "Sathu", "Silom", "Skia", "Times", "Webdings", "Zapf Dingbats"];
+
+/// Sketch's natural line for a font of `ascent` and `descent` in `upem` units at `size` px: its
+/// height in px and how far down the text moves so its baseline sits where Sketch puts it. Sketch
+/// rounds the ascent and descent to whole pixels each and leaves the font's line gap out (a fifth
+/// more for [`TALL_LINE_FAMILIES`]), with the baseline above the rounded descent; FigCraft centres
+/// the font's own ascent and descent in the line. `(0, 0)` without metrics.
+pub(crate) fn sketch_line(ascent: f64, descent: f64, upem: f64, family: &str, size: f64) -> (f64, f64) {
+    let k = size / upem;
+    let (a, d) = (ascent * k, descent * k);
+    if !(a.is_finite() && d.is_finite()) || a + d <= 0.0 {
+        return (0.0, 0.0);
+    }
+    let natural = a.round() + d.round();
+    let line = if TALL_LINE_FAMILIES.iter().any(|f| f.eq_ignore_ascii_case(family)) { (natural * 1.2).round() } else { natural };
+    let sketch_baseline = line - d.round();
+    let figcraft_baseline = (line - (a + d)) / 2.0 + a;
+    (line, sketch_baseline - figcraft_baseline)
+}
+
+/// Text without a fixed line height takes the line Sketch drew it with (FigCraft's natural line,
+/// like Figma's, counts the font's line gap and centres the font in it; Sketch's doesn't), as a
+/// share of its size so it still follows the size, and moves to Sketch's baseline. Shared text
+/// styles take the line too.
+fn sketch_line_heights(doc: &mut Document) {
+    // Per family and style: the face's ascent, descent and units per em.
+    type Metrics = Option<(f64, f64, f64)>;
+    let mut cache: std::collections::BTreeMap<(String, String), Metrics> = std::collections::BTreeMap::new();
+    let mut set = |style: &mut TextStyle| -> f64 {
+        if style.line_height != LineHeight::Auto || !style.font_size.is_finite() || style.font_size <= 0.0 {
+            return 0.0;
+        }
+        let m = *cache.entry((style.font_family.clone(), style.font_style.clone())).or_insert_with(|| {
+            figcraft_text::fontdb::has_family(&style.font_family)
+                .then(|| figcraft_text::fontdb::find_face(&style.font_family, &style.font_style))
+                .flatten()
+                .map(|f| (f.ascent, f.descent, f.upem))
+        });
+        let Some((a, d, upem)) = m else { return 0.0 };
+        let (line, down) = sketch_line(a, d, upem, &style.font_family, style.font_size);
+        if line > 0.0 {
+            style.line_height = LineHeight::Percent(line / style.font_size * 100.0);
+        }
+        down
+    };
+    let ids: Vec<NodeId> = doc.nodes().filter(|n| matches!(n.kind, NodeKind::Text(_))).map(|n| n.id).collect();
+    for id in ids {
+        // An auto layout places its texts itself (its next pass would take a move back).
+        let laid_out =
+            doc.node(id).is_some_and(|n| !n.child_layout.absolute && n.parent.and_then(|p| doc.node(p)).is_some_and(|p| p.layout.is_some()));
+        let Some(n) = doc.node_mut(id) else { continue };
+        let NodeKind::Text(td) = &mut n.kind else { continue };
+        let down = set(&mut td.style);
+        for r in &mut td.runs {
+            set(&mut r.style);
+        }
+        // Down in the layer's own frame (a rotated text moves along its own axis).
+        if !laid_out && down.is_finite() && down != 0.0 {
+            n.transform *= figcraft_doc::geom::Affine::translate((0.0, down));
+        }
+    }
+    for st in &mut doc.styles {
+        if let StyleKind::Text { style } = &mut st.kind {
+            set(style);
+        }
+    }
+}
+
+/// The installed family `family` means when it isn't installed under that exact name: the one
+/// whose name is the same without spaces, ignoring case.
+pub(crate) fn installed_family(family: &str, installed: &[String]) -> Option<String> {
+    let key = |s: &str| s.chars().filter(|c| !c.is_whitespace()).flat_map(char::to_lowercase).collect::<String>();
+    if installed.iter().any(|f| f.eq_ignore_ascii_case(family)) {
+        return None;
+    }
+    let want = key(family);
+    installed.iter().find(|f| key(f) == want).cloned()
+}
+
+/// Gives `None` when `bytes` are not a `.fig` file. Then other readers can try.
+pub(crate) fn load_fig(bytes: &[u8], name: &str) -> Option<Result<figcraft_format::Loaded>> {
+    let r = figcraft_format::fig::try_import(bytes, name)?;
+    Some(r.map_err(|e| EngineError::Other(e.to_string())).map(|(mut doc, warnings)| {
+        link_instances(&mut doc);
+        figcraft_format::Loaded { issues: warnings, ..doc.into() }
+    }))
+}
+
+/// Link imported instances to their mains (layer sources, overrides found by comparing values),
+/// innermost first so outer instances settle last.
+fn link_instances(doc: &mut Document) {
+    crate::cmd::styles::unfold_imported_bound_alpha(doc);
+    crate::style_vars::after_load(doc);
+    crate::cmd::styles::apply_paint_bindings_on_load(doc);
+    let mut insts: Vec<(usize, NodeId)> =
+        doc.nodes().filter(|n| matches!(n.kind, NodeKind::Instance { .. })).map(|n| (doc.ancestors(n.id).len(), n.id)).collect();
+    insts.sort_by_key(|a| std::cmp::Reverse(a.0));
+    for (_, i) in insts {
+        crate::components::rebase_instance(doc, i);
+    }
+}
+
+/// Largest image file read for a REST API file JSON import.
+#[cfg(not(target_arch = "wasm32"))]
+const MAX_IMAGE_FILE: u64 = 256 * 1024 * 1024;
+
+/// Image bytes for a REST API file JSON's `imageRef`: `images/<imageRef>[.png|.jpg|…]` next to
+/// the file.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn rest_images(path: &str) -> impl Fn(&str) -> Option<Vec<u8>> {
+    let dir = std::path::Path::new(path).parent().map(|d| d.join("images"));
+    move |r: &str| {
+        // Image refs are content hashes; anything else never becomes a path.
+        if r.is_empty() || r.len() > 128 || !r.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_') {
+            return None;
+        }
+        let dir = dir.as_ref()?;
+        ["", ".png", ".jpg", ".jpeg", ".gif", ".webp"]
+            .iter()
+            .find_map(|e| crate::file_access::read_capped(dir.join(format!("{r}{e}")), MAX_IMAGE_FILE).ok())
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+pub(super) fn rest_images(_path: &str) -> impl Fn(&str) -> Option<Vec<u8>> {
+    figcraft_format::rest::no_images
+}
+
+/// Largest variables JSON read from disk.
+#[cfg(not(target_arch = "wasm32"))]
+const MAX_VARIABLES_FILE: u64 = 256 * 1024 * 1024;
+
+/// A local variables JSON next to a REST API file JSON: `<name>.variables.json`, else
+/// `variables.json`.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn sibling_variables(path: &str) -> Option<Value> {
+    if ext(path) != "json" {
+        return None;
+    }
+    let file = std::path::Path::new(path);
+    let dir = file.parent()?;
+    [format!("{}.variables.json", file_stem(path)), "variables.json".to_string()].iter().map(|n| dir.join(n)).filter(|c| c != file).find_map(|c| {
+        let v: Value = serde_json::from_slice(&crate::file_access::read_capped(c, MAX_VARIABLES_FILE).ok()?).ok()?;
+        figcraft_format::rest::is_variables_json(&v).then_some(v)
+    })
+}
+
+#[cfg(target_arch = "wasm32")]
+pub(super) fn sibling_variables(_path: &str) -> Option<Value> {
+    None
+}
+
+/// The local variables JSON a command passes as `variables`: an object, JSON text or a file path.
+pub(crate) fn variables_param(cmd: &str, p: &Value) -> Result<Option<Value>> {
+    let parse = |text: &[u8]| serde_json::from_slice::<Value>(text).map_err(|e| bad(cmd, format!("variables: {e}")));
+    let v = match get(p, "variables") {
+        None | Some(Value::Null) => return Ok(None),
+        Some(v @ Value::Object(_)) => v.clone(),
+        Some(Value::String(s)) if s.trim_start().starts_with('{') => parse(s.as_bytes())?,
+        Some(Value::String(path)) => parse(&read(path)?)?,
+        Some(_) => return Err(bad(cmd, "variables: the local variables JSON (an object, JSON text or a path)")),
+    };
+    if !figcraft_format::rest::is_variables_json(&v) {
+        return Err(bad(cmd, "variables: expected the local variables JSON (`meta.variableCollections` and `meta.variables`)"));
+    }
+    Ok(Some(v))
+}
diff --git a/crates/engine/src/cmd/file/open.rs b/crates/engine/src/cmd/file/open.rs
new file mode 100644
index 00000000..6b724ced
--- /dev/null
+++ b/crates/engine/src/cmd/file/open.rs
@@ -0,0 +1,245 @@
+use super::load::{ext, file_stem, import_summary, load_path, load_with, read, rest_images, sibling_variables, variables_param};
+use super::*;
+
+/// How many files File ▸ Open recent keeps.
+pub const MAX_RECENT: usize = 20;
+
+/// Put `path` at the top of the recent files.
+pub(super) fn remember(s: &mut Session, path: &str) {
+    let r = &mut s.prefs.recent_files;
+    r.retain(|p| p != path);
+    r.insert(0, path.to_string());
+    r.truncate(MAX_RECENT);
+}
+
+pub(super) fn open_recent(s: &mut Session, p: &Value) -> Result<Value> {
+    use crate::file_access::{Access, allow, allowed};
+    const CMD: &str = "file.openRecent";
+    // Confined to automation roots, the recent files outside them are never listed, opened, removed
+    // or named: `index` counts the files listed.
+    let listed = |r: &String| allowed(r, Access::Read);
+    if p.get("clear").and_then(Value::as_bool) == Some(true) {
+        s.prefs.recent_files.retain(|r| !listed(r));
+    }
+    if let Some(gone) = string(p, "remove") {
+        s.prefs.recent_files.retain(|r| *r != gone || !listed(r));
+    }
+    let path = match (string(p, "path"), num(p, "index")) {
+        (Some(path), _) => {
+            allow(&path, Access::Read)?;
+            Some(path)
+        }
+        (None, Some(i)) => {
+            Some(s.prefs.recent_files.iter().filter(|r| listed(r)).nth(i.max(0.0) as usize).cloned().ok_or_else(|| bad(CMD, "no such recent file"))?)
+        }
+        _ => None,
+    };
+    if let Some(path) = path {
+        if !crate::file_access::exists(&path) {
+            s.prefs.recent_files.retain(|r| *r != path);
+            return Err(bad(CMD, format!("{path} no longer exists")));
+        }
+        return open(s, &json!({"path": path}));
+    }
+    let files: Vec<Value> = s
+        .prefs
+        .recent_files
+        .iter()
+        .filter(|r| listed(r))
+        .map(|r| {
+            let name = std::path::Path::new(r).file_name().map_or_else(|| r.clone(), |f| f.to_string_lossy().into_owned());
+            json!({"path": r, "name": name, "exists": crate::file_access::exists(r)})
+        })
+        .collect();
+    Ok(json!({"files": files}))
+}
+
+pub(super) fn open(s: &mut Session, p: &Value) -> Result<Value> {
+    let variables = variables_param("file.open", p)?;
+    if string(p, "path").is_none()
+        && let Some(d) = string(p, "data")
+    {
+        return open_data(s, &d, p, variables.as_ref());
+    }
+    let path = req_string("file.open", p, "path")?;
+    // Already open: switch to it.
+    if let Some(i) = s.docs.iter().position(|d| d.path.as_deref() == Some(path.as_str())) {
+        s.active = i;
+        remember(s, &path);
+        return Ok(json!({"index": i}));
+    }
+    // Stamped before reading: a change made during the read makes the next save refuse.
+    let on_disk = crate::library::stat(&path).ok();
+    let (loaded, rest) = load_path(&path, variables.as_ref())?;
+    remember(s, &path);
+    let native = !rest && matches!(ext(&path).as_str(), "figcraft" | "json");
+    let warnings = rest || ext(&path) == "svg";
+    // A native file that lost something (a damaged image, say): the app says so, not only the result.
+    if native && !loaded.issues.is_empty() {
+        s.message = Some(match loaded.issues.as_slice() {
+            [one] => format!("{}: {one}", file_stem(&path)),
+            more => format!("{}: {} problems were repaired or left out while opening it, e.g. {}", file_stem(&path), more.len(), more[0]),
+        });
+    }
+    let summary = import_summary(&loaded.doc);
+    let images_left_out = if native { loaded.images_past_budget } else { 0 };
+    let mut ds = DocState::new(loaded.doc, native.then(|| path.clone()))
+        .with_versions(loaded.versions)
+        .with_branches(loaded.branches)
+        .with_images_left_in_file(&path, images_left_out);
+    ds.on_disk = on_disk.filter(|_| native);
+    s.docs.push(ds);
+    s.active = s.docs.len() - 1;
+    let mut out = json!({"index": s.active, "summary": summary});
+    out[if warnings { "warnings" } else { "repairs" }] = json!(loaded.issues);
+    Ok(out)
+}
+
+/// [`open`] for a file given as base64 `data` (a file dropped without a path on disk): `name` tells
+/// the format. It opens as a new document with no path, so the first save asks where to put it.
+fn open_data(s: &mut Session, data: &str, p: &Value, variables: Option<&Value>) -> Result<Value> {
+    let name = req_string("file.open", p, "name")?;
+    let data = data.split_once(',').map_or(data, |(_, b)| b);
+    let bytes = base64::engine::general_purpose::STANDARD.decode(data.trim()).map_err(|e| bad("file.open", e.to_string()))?;
+    let (loaded, rest) = load_with(&bytes, &name, variables, &figcraft_format::rest::no_images)?;
+    let warnings = rest || ext(&name) == "svg";
+    let summary = import_summary(&loaded.doc);
+    s.docs.push(DocState::new(loaded.doc, None).with_versions(loaded.versions).with_branches(loaded.branches));
+    s.active = s.docs.len() - 1;
+    let mut out = json!({"index": s.active, "summary": summary});
+    out[if warnings { "warnings" } else { "repairs" }] = json!(loaded.issues);
+    Ok(out)
+}
+
+pub(super) fn import(s: &mut Session, p: &Value) -> Result<Value> {
+    let path = string(p, "path");
+    let variables = variables_param("file.import", p)?;
+    let (bytes, name) = if let Some(path) = &path {
+        (read(path)?, path.clone())
+    } else if let Some(d) = string(p, "data") {
+        let d = d.split_once(',').map(|(_, b)| b.to_string()).unwrap_or(d);
+        (
+            base64::engine::general_purpose::STANDARD.decode(d.trim()).map_err(|e| bad("file.import", e.to_string()))?,
+            string(p, "name").unwrap_or_else(|| "import.png".into()),
+        )
+    } else {
+        return Err(bad("file.import", "pass `path` or `data`"));
+    };
+    let page = s.page()?;
+    let (x, y) = (num(p, "x"), num(p, "y"));
+    let center = s.ds().map(|d| (d.view.cx, d.view.cy)).unwrap_or((0.0, 0.0));
+    match ext(&name).as_str() {
+        "svg" => {
+            let doc = s.doc_mut()?;
+            let (x, y) = (x.unwrap_or(center.0), y.unwrap_or(center.1));
+            let imported =
+                figcraft_svg::import_svg_with_notes(doc, &bytes, page, x, y, &file_stem(&name)).map_err(|e| EngineError::Other(e.to_string()))?;
+            let id = imported.frame;
+            // Centred on the point (a paste lands in the middle of the view).
+            if boolean(p, "center").unwrap_or(false)
+                && let Some(n) = doc.node_mut(id)
+            {
+                n.transform = figcraft_geom::Affine::translate(((x - n.width / 2.0).round(), (y - n.height / 2.0).round()));
+            }
+            s.set_selection(vec![id]);
+            let mut out = json!({"id": id});
+            if !imported.notes.is_empty() {
+                out["warnings"] = json!(imported.notes);
+            }
+            Ok(out)
+        }
+        "figcraft" | "json" | "fig" | "sketch" => {
+            let resolver = path.as_deref().map(rest_images);
+            let images: figcraft_format::rest::ImageResolver = match &resolver {
+                Some(r) => r,
+                None => &figcraft_format::rest::no_images,
+            };
+            let sibling = if variables.is_none() { path.as_deref().and_then(sibling_variables) } else { None };
+            let (other, rest) = load_with(&bytes, &name, variables.as_ref().or(sibling.as_ref()), images)?;
+            let summary = import_summary(&other.doc);
+            let pages = append_pages(s.doc_mut()?, &other.doc)?;
+            let mut out = json!({"pages": pages, "summary": summary});
+            if rest {
+                out["warnings"] = json!(other.issues);
+            }
+            Ok(out)
+        }
+        _ => {
+            let b64 = base64::engine::general_purpose::STANDARD.encode(&bytes);
+            crate::cmd::create::place_image(
+                s,
+                &json!({"data": b64, "x": x.unwrap_or(center.0), "y": y.unwrap_or(center.1), "name": file_stem(&name)}),
+            )
+        }
+    }
+}
+
+/// Append `other`'s pages (with their settings and flows, its images, styles and variables) to
+/// `doc`. Ids are remapped across all pages at once, so instances keep their main, instance layers
+/// their source and interactions and flows their targets wherever those are. Styles, variables and
+/// collections whose id the document already has are kept as they are.
+pub(super) fn append_pages(doc: &mut Document, other: &Document) -> Result<Vec<NodeId>> {
+    for (k, v) in &other.images {
+        doc.images.entry(k.clone()).or_insert_with(|| v.clone());
+    }
+    for st in &other.styles {
+        if !doc.styles.iter().any(|s| s.id == st.id) {
+            doc.styles.push(st.clone());
+        }
+    }
+    let have: std::collections::BTreeSet<String> = doc.variables.collections.iter().map(|c| c.id.clone()).collect();
+    doc.variables.collections.extend(other.variables.collections.iter().filter(|c| !have.contains(&c.id)).cloned());
+    let have: std::collections::BTreeSet<String> = doc.variables.variables.iter().map(|v| v.id.clone()).collect();
+    doc.variables.variables.extend(other.variables.variables.iter().filter(|v| !have.contains(&v.id)).cloned());
+    let mut map = std::collections::BTreeMap::new();
+    for pg in &other.pages {
+        for id in other.subtree(*pg).into_iter().skip(1) {
+            map.insert(id, doc.alloc_id());
+        }
+    }
+    // Library copies a .fig import keeps (cached definitions) have no library record to follow:
+    // the layers of its store come along into the store of `doc`. Recorded copies are left to
+    // `merge_store`, which shares them with copies `doc` already has.
+    let cached: Vec<NodeId> = other
+        .library_store()
+        .and_then(|s| other.node(s))
+        .map(|s| s.children.iter().copied().filter(|root| other.libraries.import_of(*root).is_none()).collect())
+        .unwrap_or_default();
+    for root in &cached {
+        for id in other.subtree(*root) {
+            map.insert(id, doc.alloc_id());
+        }
+    }
+    let mut new_pages = Vec::new();
+    for pg in &other.pages {
+        let Some(pn) = other.node(*pg) else { continue };
+        let np = doc.add_page(&pn.name);
+        let mut kind = pn.kind.clone();
+        if let NodeKind::Page { flows, .. } = &mut kind {
+            flows.retain_mut(|f| map.get(&f.start).map(|n| f.start = *n).is_some());
+        }
+        if let Some(n) = doc.node_mut(np) {
+            n.kind = kind;
+        }
+        for c in &pn.children {
+            let nodes: Vec<Node> = other.subtree(*c).into_iter().filter_map(|i| other.node(i).cloned()).collect();
+            doc.paste_nodes(&nodes, &map, *c, np, None)?;
+        }
+        new_pages.push(np);
+    }
+    if !cached.is_empty() {
+        let store = doc.ensure_library_store();
+        for root in &cached {
+            let nodes: Vec<Node> = other.subtree(*root).into_iter().filter_map(|i| other.node(i).cloned()).collect();
+            doc.paste_nodes(&nodes, &map, *root, store, None)?;
+        }
+    }
+    for new in map.values() {
+        let src = doc.node(*new).and_then(|n| n.source).and_then(|s| map.get(&s).copied());
+        if let (Some(src), Some(n)) = (src, doc.node_mut(*new)) {
+            n.source = Some(src);
+        }
+    }
+    crate::library::merge_store(doc, other, &map)?;
+    Ok(new_pages)
+}
diff --git a/crates/engine/src/cmd/file/save.rs b/crates/engine/src/cmd/file/save.rs
new file mode 100644
index 00000000..593c4c21
--- /dev/null
+++ b/crates/engine/src/cmd/file/save.rs
@@ -0,0 +1,225 @@
+use super::export::export_fig;
+use super::load::{ext, file_stem, write};
+use super::open::remember;
+use super::*;
+
+/// Thumbnail PNG of the first page's content (for file browsers / the home screen).
+pub fn thumbnail(doc: &Document) -> Option<Vec<u8>> {
+    let page = doc.first_page()?;
+    let b = doc.page_content_bounds(page)?;
+    let scale = (400.0 / b.width().max(b.height()).max(1.0)).min(2.0);
+    let view = figcraft_render::View {
+        origin: (b.x0, b.y0),
+        scale,
+        width: (b.width() * scale).ceil().max(1.0) as u32,
+        height: (b.height() * scale).ceil().max(1.0) as u32,
+    };
+    let pix = figcraft_render::render_view(doc, page, &view, &Default::default())?;
+    figcraft_render::encode_png(&pix).ok()
+}
+
+/// The `.figcraft` file for a document: content, thumbnail and version history.
+pub fn file_bytes(ds: &DocState) -> Result<Vec<u8>> {
+    FileSnapshot::of(ds).encode()
+}
+
+/// A document's file as it is at one moment, so the slow part of saving it (the thumbnail and the
+/// encoding) can run on another thread while editing goes on: [`encode`](Self::encode) there, then
+/// [`save`](Self::save) the bytes back on the session's thread.
+pub struct FileSnapshot {
+    uid: u64,
+    path: Option<String>,
+    revision: u64,
+    doc: Arc<Document>,
+    /// The document as last saved when the snapshot was taken: another save since makes it stale.
+    saved: Arc<Document>,
+    page: NodeId,
+    versions: Vec<Version>,
+    branches: Vec<figcraft_format::Branch>,
+}
+
+impl FileSnapshot {
+    pub fn of(ds: &DocState) -> Self {
+        Self {
+            uid: ds.uid,
+            path: ds.path.clone(),
+            revision: ds.revision,
+            doc: ds.doc.clone(),
+            saved: ds.saved_doc.clone(),
+            page: ds.page,
+            versions: ds.versions.clone(),
+            branches: ds.branches.clone(),
+        }
+    }
+
+    /// The file's bytes: content, thumbnail and version history.
+    pub fn encode(&self) -> Result<Vec<u8>> {
+        let mut doc = (*self.doc).clone();
+        doc.current_page = Some(self.page);
+        let thumb = thumbnail(&doc);
+        figcraft_format::save_bytes_with_history(&doc, thumb.as_deref(), &self.versions, &self.branches)
+            .map_err(|e| EngineError::Other(e.to_string()))
+    }
+
+    /// Write `bytes` (this snapshot's [`encode`](Self::encode)) to the document's file: it is saved
+    /// as of the snapshot, and edits since stay unsaved. False (nothing written) when the document
+    /// was closed, saved, reverted or given another path since: the bytes are out of date.
+    pub fn save(self, s: &mut Session, bytes: &[u8]) -> Result<bool> {
+        let Some(ds) = s.docs.iter_mut().find(|d| d.uid == self.uid && d.path == self.path && Arc::ptr_eq(&d.saved_doc, &self.saved)) else {
+            return Ok(false);
+        };
+        let path = self.path.as_deref().ok_or(EngineError::NoDocument)?;
+        refuse_dropping_images(ds, path)?;
+        refuse_overwriting_changes(ds, path)?;
+        write(path, bytes)?;
+        ds.note_on_disk();
+        // The history or branches may have changed since: then they still count as unsaved.
+        if ds.revision == self.revision {
+            ds.versions_changed = false;
+        }
+        ds.saved_doc = self.doc;
+        ds.revision += 1;
+        branch_tabs_saved(s, self.uid);
+        Ok(true)
+    }
+}
+
+fn refuse_dropping_images(ds: &DocState, path: &str) -> Result<()> {
+    match ds.images_lost_saving_to(path) {
+        Some(count) => Err(EngineError::Other(format!(
+            "{} wasn't saved: {count} of its images weren't loaded (together they pass what FigCraft reads from one file), and saving over it would delete them. Save it under another name; this file keeps them.",
+            file_stem(path)
+        ))),
+        None => Ok(()),
+    }
+}
+
+/// Saving over the tab's own file would lose what another app wrote to it since (#1330).
+fn refuse_overwriting_changes(ds: &DocState, path: &str) -> Result<()> {
+    match (&ds.on_disk, crate::library::stat(path)) {
+        (Some(was), Ok(now)) if now != *was => Err(EngineError::Other(format!(
+            "{} wasn't saved: the file changed on disk since it was opened or saved here (another app or figcraft-cli wrote to it), and saving would replace those changes. Revert to saved to load them, or Save as to keep this version as well.",
+            file_stem(path)
+        ))),
+        _ => Ok(()),
+    }
+}
+
+/// The branch tabs of the file in tab `uid` were saved with it.
+fn branch_tabs_saved(s: &mut Session, uid: u64) {
+    for tab in s.docs.iter_mut().filter(|d| d.branch_of.as_ref().is_some_and(|(m, _)| *m == uid)) {
+        tab.mark_saved();
+    }
+}
+
+pub(super) fn color_profile(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "file.colorProfile";
+    let Some(name) = string(p, "profile") else {
+        s.request_ui("dialog.colorProfile", json!({}));
+        return Ok(json!({"profile": s.doc()?.color_profile.id(), "changed": false}));
+    };
+    let profile = figcraft_color::ColorProfile::parse(&name).ok_or_else(|| bad(cmd, "profile: srgb or displayP3"))?;
+    let convert = boolean(p, "convert").unwrap_or(true);
+    let changed = s.doc()?.color_profile != profile && s.doc_mut()?.set_color_profile(profile, convert);
+    Ok(json!({"profile": profile.id(), "changed": changed}))
+}
+
+/// Native saves act on the current document; a `.fig` copy exports the version shown, and a
+/// pending Save As choice must leave it shown until its destination is known.
+pub(crate) fn save_ends_preview(s: &Session, cmd: &str, p: &Value) -> bool {
+    let path =
+        string(p, "path").or_else(|| if cmd == "file.save" { s.docs.get(crate::branches::file_tab(s)).and_then(|ds| ds.path.clone()) } else { None });
+    path.is_some_and(|path| ext(&path) != "fig") || (cmd == "file.saveAs" && wants_data(p))
+}
+
+/// `file.saveAs` asked for the file's bytes instead of a path to write (the browser's download).
+fn wants_data(p: &Value) -> bool {
+    p.get("data").and_then(Value::as_bool) == Some(true)
+}
+
+/// Save the file of the active tab (the main file for a branch tab, with its branches), or export
+/// the active document as an experimental `.fig` copy without changing its native save state.
+/// Without a path the file comes back as base64 `data` for the caller to deliver (#969).
+fn save_to(s: &mut Session, path: Option<String>) -> Result<Value> {
+    if let Some(path) = path.as_deref().filter(|p| ext(p) == "fig") {
+        return export_fig(s, &json!({"path": path}));
+    }
+    let i = crate::branches::file_tab(s);
+    let ds = s.docs.get_mut(i).ok_or(EngineError::NoDocument)?;
+    // A download (no path) writes over no file.
+    if let Some(path) = path.as_deref() {
+        refuse_dropping_images(ds, path)?;
+    }
+    let mut snapshot = FileSnapshot::of(ds);
+    let follows_path = ds.path.as_deref().map_or(ds.doc.name == "Untitled", |old| ds.doc.name == file_stem(old));
+    if let Some(path) = path.as_deref()
+        && follows_path
+        && ds.path.as_deref() != Some(path)
+    {
+        Arc::make_mut(&mut snapshot.doc).name = file_stem(path);
+    }
+    let bytes = snapshot.encode()?;
+    let Some(path) = path else {
+        // The download can still be refused: the caller marks the file saved once it was delivered.
+        let name = format!("{}.figcraft", ds.doc.name);
+        return Ok(json!({"name": name, "bytes": bytes.len(), "data": base64::engine::general_purpose::STANDARD.encode(&bytes)}));
+    };
+    write(&path, &bytes)?;
+    ds.doc = snapshot.doc;
+    ds.path = Some(path.clone());
+    ds.note_on_disk();
+    mark_saved(s, &json!({}))?;
+    remember(s, &path);
+    Ok(json!({"path": path, "bytes": bytes.len()}))
+}
+
+/// The file of the active tab (with its branch tabs) now matches what was written or delivered.
+pub(super) fn mark_saved(s: &mut Session, _: &Value) -> Result<Value> {
+    let i = crate::branches::file_tab(s);
+    let ds = s.docs.get_mut(i).ok_or(EngineError::NoDocument)?;
+    ds.mark_saved();
+    ds.revision += 1;
+    let uid = ds.uid;
+    branch_tabs_saved(s, uid);
+    Ok(json!({"saved": true}))
+}
+
+pub(super) fn save(s: &mut Session, p: &Value) -> Result<Value> {
+    if let Some(path) = string(p, "path") {
+        return save_to(s, Some(path));
+    }
+    let ds = s.docs.get(crate::branches::file_tab(s)).ok_or(EngineError::NoDocument)?;
+    match ds.path.clone() {
+        // Earlier builds wrote native data under a .fig name: never overwrite that file with an export.
+        Some(path) if ext(&path) == "fig" => {
+            s.request_ui("dialog.saveAs", json!({}));
+            Err(EngineError::Disabled("file.save".into(), "the saved path ends in .fig: choose Save as or pass `path`".into()))
+        }
+        Some(path) => {
+            if p.get("overwrite").and_then(Value::as_bool) != Some(true) {
+                refuse_overwriting_changes(ds, &path)?;
+            }
+            save_to(s, Some(path))
+        }
+        None => {
+            s.request_ui("dialog.saveAs", json!({}));
+            Err(EngineError::Disabled("file.save".into(), "the file has no path yet: pass `path`".into()))
+        }
+    }
+}
+
+pub(super) fn save_as(s: &mut Session, p: &Value) -> Result<Value> {
+    match string(p, "path") {
+        Some(mut path) => {
+            if ext(&path).is_empty() {
+                path.push_str(".figcraft");
+            }
+            save_to(s, Some(path))
+        }
+        None if wants_data(p) => save_to(s, None),
+        None => {
+            s.request_ui("dialog.saveAs", json!({}));
+            Err(EngineError::Disabled("file.saveAs".into(), "pass `path`".into()))
+        }
+    }
+}
diff --git a/crates/engine/src/cmd/file/version.rs b/crates/engine/src/cmd/file/version.rs
new file mode 100644
index 00000000..3d311a44
--- /dev/null
+++ b/crates/engine/src/cmd/file/version.rs
@@ -0,0 +1,172 @@
+use super::*;
+
+pub(super) fn version_json(index: usize, v: &Version) -> Value {
+    let mut j = json!({"id": v.id, "index": index, "name": v.name, "description": v.description, "time": v.time});
+    if v.auto {
+        j["auto"] = json!(true);
+    }
+    j
+}
+
+/// Autosaves kept per file; older ones make room for new ones.
+pub const MAX_AUTOSAVES: usize = 20;
+
+/// `version.autosave`: a checkpoint of a document with unsaved changes since the last version.
+pub(super) fn autosave(s: &mut Session, _: &Value) -> Result<Value> {
+    let auto_save = s.prefs.auto_save;
+    let ds = s.ds_mut()?;
+    // A file that saves itself is rarely unsaved: edits since it was opened count then.
+    let edited = ds.is_dirty() || (auto_save && !ds.history.undo.is_empty());
+    if ds.preview.is_some() || !edited || !ds.changed_since_checkpoint() {
+        return Ok(json!({"saved": false}));
+    }
+    Ok(match add_version(ds, AUTOSAVE, "", true) {
+        Some(v) => json!({"saved": true, "version": v}),
+        None => json!({"saved": false}),
+    })
+}
+
+/// What checkpoints are called.
+const AUTOSAVE: &str = "Autosave";
+
+/// Add a version of `ds`'s document as it is now (`auto`: a checkpoint) and return it. The oldest
+/// autosave makes room when the autosaves or the history are full; versions the user named are
+/// never dropped, so a history full of them takes nothing (None).
+pub(crate) fn add_version(ds: &mut DocState, name: &str, description: &str, auto: bool) -> Option<Value> {
+    let autos = ds.versions.iter().filter(|v| v.auto).count();
+    if ((auto && autos >= MAX_AUTOSAVES) || ds.versions.len() >= figcraft_format::MAX_VERSIONS)
+        && let Some(oldest) = ds.versions.iter().position(|v| v.auto)
+    {
+        ds.versions_mut().remove(oldest);
+    }
+    if ds.versions.len() >= figcraft_format::MAX_VERSIONS {
+        return None;
+    }
+    let mut v = snapshot_version(ds, name, description);
+    v.auto = auto;
+    let out = version_json(ds.versions.len(), &v);
+    ds.versions_mut().push(v);
+    ds.mark_checkpoint();
+    Some(out)
+}
+
+/// Before the document is replaced (a restore, a merge): keep it in the history as it is, unless
+/// it is what the last version saved or restored holds.
+pub(crate) fn keep_in_history(ds: &mut DocState) {
+    if ds.branch_of.is_none() && ds.changed_since_checkpoint() {
+        add_version(ds, AUTOSAVE, "", true);
+    }
+}
+
+/// A version of `ds`'s document as it is now, opening on the page shown.
+fn snapshot_version(ds: &DocState, name: &str, description: &str) -> Version {
+    let mut snap = ds.doc.clone();
+    if snap.current_page != Some(ds.page) {
+        Arc::make_mut(&mut snap).current_page = Some(ds.page);
+    }
+    Version::new(unique_id(|id| ds.versions.iter().any(|v| v.id == id)), name, description, crate::cmd::comment::now_secs(), snap)
+}
+
+pub(super) fn version_list(ds: &DocState) -> Value {
+    let previewing = ds.preview.as_ref().map(|p| p.id.as_str());
+    Value::Array(
+        ds.versions
+            .iter()
+            .enumerate()
+            .map(|(i, v)| {
+                let mut j = version_json(i, v);
+                if previewing == Some(v.id.as_str()) {
+                    j["previewing"] = json!(true);
+                }
+                j
+            })
+            .collect(),
+    )
+}
+
+/// The version named by `id`, else by `index` (validated: never negative, never past the end).
+pub(super) fn version_index(cmd: &str, ds: &DocState, p: &Value) -> Result<usize> {
+    if let Some(id) = string(p, "id") {
+        return ds.versions.iter().position(|v| v.id == id).ok_or_else(|| bad(cmd, format!("no version `{id}`")));
+    }
+    if get(p, "index").is_none() {
+        return Err(bad(cmd, "pass the version's `id` or `index`"));
+    }
+    let i = req_index(cmd, p, "index")?;
+    if i < ds.versions.len() { Ok(i) } else { Err(bad(cmd, format!("no version at index {i}"))) }
+}
+
+pub(crate) fn read_version(v: &Version) -> Result<Arc<Document>> {
+    v.document().map_err(|e| EngineError::Other(format!("version “{}” can't be read: {e}", v.name)))
+}
+
+/// A new version or branch id: the time in milliseconds (hex), not `taken`.
+pub(crate) fn unique_id(taken: impl Fn(&str) -> bool) -> String {
+    let mut n = web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0);
+    loop {
+        let id = format!("{n:x}");
+        if !taken(&id) {
+            return id;
+        }
+        n = n.wrapping_add(1);
+    }
+}
+
+/// `file.saveVersion`; on a branch tab the version goes into the branch's own history.
+pub(super) fn save_version(s: &mut Session, p: &Value) -> Result<Value> {
+    let ds = s.ds_mut()?;
+    if ds.versions.len() >= figcraft_format::MAX_VERSIONS {
+        return Err(EngineError::Disabled(
+            "file.saveVersion".into(),
+            format!("the version history is full ({} versions): delete old versions first", figcraft_format::MAX_VERSIONS),
+        ));
+    }
+    let name =
+        string(p, "name").map(|n| n.trim().to_string()).filter(|n| !n.is_empty()).unwrap_or_else(|| format!("Version {}", ds.versions.len() + 1));
+    let description = string(p, "description").unwrap_or_default();
+    // The version opens on the page shown when it was saved.
+    add_version(ds, &name, description.trim(), false).ok_or_else(|| {
+        EngineError::Disabled(
+            "file.saveVersion".into(),
+            format!("the version history is full ({} versions): delete old versions first", figcraft_format::MAX_VERSIONS),
+        )
+    })
+}
+
+pub(super) fn restore_version(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "version.restore";
+    // Refused before anything goes into the history.
+    if let Some(why) = s.live_read_only(s.ds()?.uid) {
+        return Err(EngineError::Disabled(CMD.into(), why.into()));
+    }
+    let ds = s.ds_mut()?;
+    let i = version_index(CMD, ds, p)?;
+    let v = ds.versions.get(i).ok_or_else(|| bad(CMD, "no such version"))?;
+    let (id, mut doc) = (v.id.clone(), read_version(v)?);
+    // Restoring never loses work: the document as it is goes into the history first.
+    keep_in_history(ds);
+    let out = ds.versions.iter().enumerate().find(|(_, v)| v.id == id).map_or(Value::Null, |(i, v)| version_json(i, v));
+    let d = Arc::make_mut(&mut doc);
+    d.name = ds.doc.name.clone();
+    // What the file published belongs to the file, not to the version.
+    d.published = ds.doc.published.clone();
+    // Comments are a conversation about the file, kept apart from its design history: they stay,
+    // and those on layers the version doesn't have stay where they were.
+    d.comments = ds.doc.comments.clone();
+    crate::cmd::comment::follow_anchors(d, &ds.doc);
+    // The snapshot is already consistent: nothing to re-normalise.
+    d.take_dirty();
+    // Stay on the current page when the version has it.
+    ds.page = Some(ds.page)
+        .filter(|pg| d.pages.contains(pg))
+        .or_else(|| d.current_page.filter(|pg| d.pages.contains(pg)))
+        .or_else(|| d.first_page())
+        .unwrap_or(ds.page);
+    ds.doc = doc;
+    ds.selection.clear();
+    ds.text_edit = None;
+    ds.vector_edit = None;
+    // The restored design is in the history already: restoring it again keeps nothing new.
+    ds.mark_checkpoint();
+    Ok(out)
+}

From d8de0fdea7cd0c728db4558bb41732de07a0a7dc Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:56:10 +0000
Subject: [PATCH 38/67] refactor(ui-egui): split dialogs.rs into dialogs/

---
 crates/ui-egui/src/dialogs.rs               | 419 +-------------------
 crates/ui-egui/src/dialogs/batch_rename.rs  | 113 ++++++
 crates/ui-egui/src/dialogs/color_profile.rs |  59 +++
 crates/ui-egui/src/dialogs/export.rs        | 160 ++++++++
 crates/ui-egui/src/dialogs/menu_input.rs    |  75 ++++
 5 files changed, 423 insertions(+), 403 deletions(-)
 create mode 100644 crates/ui-egui/src/dialogs/batch_rename.rs
 create mode 100644 crates/ui-egui/src/dialogs/color_profile.rs
 create mode 100644 crates/ui-egui/src/dialogs/export.rs
 create mode 100644 crates/ui-egui/src/dialogs/menu_input.rs

diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index f10e008a..b3e1461a 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -13,6 +13,22 @@ use crate::FigApp;
 use crate::export_panel::{export_layers, save_one, suggested_name};
 use crate::i18n::{self, tr, tr_noop, trf, trn};
 use crate::theme::{Tokens, regular, semibold};
+
+mod batch_rename;
+mod color_profile;
+mod export;
+mod menu_input;
+
+pub use batch_rename::BatchRenameUi;
+use batch_rename::batch_rename_dialog;
+#[cfg(test)]
+pub(crate) use batch_rename::batch_rename_params;
+pub(crate) use batch_rename::open_batch_rename;
+use color_profile::color_profile_dialog;
+use export::export_dialog;
+pub(crate) use export::file_saved;
+pub use menu_input::MenuInput;
+use menu_input::menu_input_dialog;
 pub mod branch_ui;
 pub mod credits;
 pub mod import_report;
@@ -79,14 +95,6 @@ pub enum AboutTab {
     Models,
 }
 
-/// Values collected by a menu or Actions command before dispatching it to the engine.
-#[derive(Clone, Debug, PartialEq)]
-pub enum MenuInput {
-    Link(String),
-    Offset(f64),
-    MoveToPage,
-}
-
 impl AboutTab {
     pub const ALL: [AboutTab; 3] = [AboutTab::About, AboutTab::Contributors, AboutTab::Models];
 
@@ -390,108 +398,6 @@ pub fn show(app: &mut FigApp, ctx: &Context) {
     crate::windows::confirm_close(app, ctx);
 }
 
-/// Menus and Actions cannot pass a value themselves. Gather it here, then run the regular
-/// command so the same validation and undo behaviour apply as for programmatic callers.
-fn menu_input_dialog(app: &mut FigApp, ctx: &Context) {
-    let Some(mut input) = app.ui.menu_input.take() else { return };
-    let t = Tokens::get(ctx);
-    let title = match &input {
-        MenuInput::Link(_) => i18n::command("text.link", "Create link"),
-        MenuInput::Offset(_) => i18n::command("vector.offset", "Offset path"),
-        MenuInput::MoveToPage => i18n::command("object.moveToPage", "Move to page"),
-    };
-    let mut open = true;
-    let mut action: Option<(&str, serde_json::Value)> = None;
-    window(&title, ctx).open(&mut open).show(ctx, |ui| {
-        ui.set_width(320.0);
-        match &mut input {
-            MenuInput::Link(url) => {
-                ui.horizontal(|ui| {
-                    let field = crate::widgets::text_input(ui, egui::Id::unique("menu_input_link"), url, 250.0, "https://");
-                    let enter = field.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
-                    let ok = !url.trim().is_empty();
-                    if (crate::widgets::button(ui, tr("Done"), true, ok).clicked() || enter) && ok {
-                        action = Some(("text.link", json!({"url": url.trim()})));
-                    }
-                });
-            }
-            MenuInput::Offset(offset) => {
-                ui.horizontal(|ui| {
-                    let id = egui::Id::unique("menu_input_offset");
-                    if let Some(crate::widgets::FieldEdit::Set(v) | crate::widgets::FieldEdit::Scrub(v, _)) =
-                        crate::widgets::number_field(ui, id, crate::widgets::Lead::None, Some(*offset), "", 120.0, 1.0)
-                    {
-                        *offset = v.clamp(-100_000.0, 100_000.0);
-                    }
-                    if crate::widgets::button(ui, tr("Offset"), true, true).clicked() {
-                        action = Some(("vector.offset", json!({"offset": *offset})));
-                    }
-                });
-            }
-            MenuInput::MoveToPage => {
-                let mut choices = 0;
-                if let Ok(ds) = app.session.ds() {
-                    for &page in &ds.doc.pages {
-                        if page == ds.page || ds.doc.is_divider(page) {
-                            continue;
-                        }
-                        if let Some(node) = ds.doc.node(page)
-                            && crate::widgets::button(ui, &node.name, false, true).clicked()
-                        {
-                            action = Some(("object.moveToPage", json!({"page": page})));
-                        }
-                        choices += 1;
-                    }
-                }
-                if choices == 0 {
-                    crate::widgets::label(ui, tr("No other pages"), t.text_secondary);
-                }
-            }
-        }
-    });
-    if let Some((id, params)) = action {
-        app.run(id, params);
-    } else if open {
-        app.ui.menu_input = Some(input);
-    }
-}
-
-/// The Rename layers dialog's fields.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct BatchRenameUi {
-    /// The layers, in stacking order (bottom first), as numbered.
-    pub ids: Vec<NodeId>,
-    /// Match: empty renames the whole name.
-    pub find: String,
-    pub regex: bool,
-    /// Rename to.
-    pub to: String,
-    /// Where up numbers start and down numbers stop.
-    pub start: u32,
-}
-
-/// Layers whose new names the dialog previews.
-const PREVIEW_ROWS: usize = 5;
-
-/// Open the Rename layers dialog for `ids` (several layers: Cmd/Ctrl+R, F2, the context menu).
-pub(crate) fn open_batch_rename(app: &mut FigApp, ids: &[NodeId]) {
-    let Ok(doc) = app.session.doc() else { return };
-    let ids = figcraft_engine::cmd::edit::z_sorted(doc, ids);
-    app.ui.batch_rename = Some(BatchRenameUi { ids, start: 1, ..Default::default() });
-}
-
-/// The rename the fields describe: a match replaced, or (no match) the whole name.
-pub(crate) fn batch_rename_params(b: &BatchRenameUi) -> serde_json::Value {
-    let mut p = json!({"ids": b.ids, "regex": b.regex, "start": b.start});
-    if b.find.is_empty() {
-        p["name"] = json!(b.to);
-    } else {
-        p["find"] = json!(b.find);
-        p["replace"] = json!(b.to);
-    }
-    p
-}
-
 /// Preferences ▸ Interface size: a size relative to the system's display scale (100 % is the
 /// system's own), as a drop-down that takes effect at once. The browser has its own zoom, so there
 /// the row only says so.
@@ -561,296 +467,3 @@ fn interface_size(app: &mut FigApp, ui: &mut egui::Ui, chosen: f64) {
         crate::widgets::label(ui, &note, t.text_secondary);
     }
 }
-
-/// Rename layers: Match, Rename to with buttons for the current name and numbers, where numbers
-/// start, a preview of the first new names, then one `object.batchRename`.
-fn batch_rename_dialog(app: &mut FigApp, ctx: &Context) {
-    let Some(mut b) = app.ui.batch_rename.clone() else { return };
-    let t = Tokens::get(ctx);
-    let find = (!b.find.is_empty()).then_some(b.find.as_str());
-    let rename = figcraft_engine::rename::BatchRename::new(find, b.regex, &b.to, find.is_none().then_some(b.to.as_str()), Some(f64::from(b.start)));
-    let n = b.ids.len();
-    let ready = rename.is_ok() && !(b.find.is_empty() && b.to.is_empty());
-    let preview: Vec<(String, String)> = match (&rename, app.session.doc()) {
-        (Ok(r), Ok(doc)) if ready => b
-            .ids
-            .iter()
-            .enumerate()
-            .take(PREVIEW_ROWS)
-            .filter_map(|(k, i)| doc.node(*i).map(|node| (node.name.clone(), r.apply(&node.name, k, n))))
-            .collect(),
-        _ => Vec::new(),
-    };
-    let mut open = true;
-    let mut cancel = false;
-    let mut apply = false;
-    window(tr("Rename layers"), ctx).id(egui::Id::unique("Rename layers")).open(&mut open).show(ctx, |ui| {
-        ui.set_width(320.0);
-        ui.label(RichText::new(trn("{n} layers", n, &[])).color(t.text_secondary));
-        ui.add_space(6.0);
-        let r = ui.add(egui::TextEdit::singleline(&mut b.find).hint_text(tr("Match (empty: the whole name)")).desired_width(300.0));
-        crate::widgets::select_all_on_focus(ui, &r, &b.find);
-        if crate::widgets::checkbox(ui, b.regex, tr("Regular expression")) {
-            b.regex = !b.regex;
-        }
-        let to = ui.add(egui::TextEdit::singleline(&mut b.to).hint_text(tr("Rename to")).desired_width(300.0));
-        crate::widgets::select_all_on_focus(ui, &to, &b.to);
-        ui.horizontal(|ui| {
-            for (label, code) in [(tr("Current name"), "$&"), (tr("Number ↑"), "$n"), (tr("Number ↓"), "$N")] {
-                if ui.button(label).clicked() {
-                    b.to.push_str(code);
-                    to.request_focus();
-                }
-            }
-        });
-        ui.horizontal(|ui| {
-            ui.label(tr("Start ascending from / stop descending at"));
-            ui.add(egui::DragValue::new(&mut b.start).range(0..=1_000_000));
-        });
-        ui.add_space(8.0);
-        match &rename {
-            Err(e) => {
-                ui.label(RichText::new(e).color(t.danger));
-            }
-            Ok(_) => {
-                for (old, new) in &preview {
-                    ui.horizontal(|ui| {
-                        ui.label(RichText::new(old).color(t.text_secondary));
-                        ui.label("→");
-                        ui.label(new);
-                    });
-                }
-                if ready && n > PREVIEW_ROWS {
-                    ui.label(RichText::new(trn("and {n} more", n - PREVIEW_ROWS, &[])).color(t.text_secondary));
-                }
-            }
-        }
-        ui.add_space(8.0);
-        ui.horizontal(|ui| {
-            cancel = crate::widgets::button(ui, tr("Cancel"), false, true).clicked();
-            let enter = to.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
-            apply = (crate::widgets::button(ui, tr("Rename"), true, ready).clicked() || enter) && ready;
-        });
-    });
-    if apply {
-        app.run("object.batchRename", batch_rename_params(&b));
-    }
-    app.ui.batch_rename = (open && !cancel && !apply).then_some(b);
-}
-
-/// File ▸ Color profile: pick sRGB or Display P3, then keep the colours' appearance (convert the
-/// values) or keep the values (reinterpret them in the new space).
-fn color_profile_dialog(app: &mut FigApp, ctx: &Context) {
-    let Some(mut chosen) = app.ui.color_profile else { return };
-    let Ok(current) = app.session.doc().map(|d| d.color_profile) else {
-        app.ui.color_profile = None;
-        return;
-    };
-    let t = Tokens::get(ctx);
-    let mut open = true;
-    let mut apply = None;
-    window(tr("Color profile"), ctx).open(&mut open).show(ctx, |ui| {
-        ui.set_width(340.0);
-        ui.label(RichText::new(tr("Color values in this file are in this color space.")).color(t.text_secondary).font(regular(11.0)));
-        ui.add_space(8.0);
-        for p in ColorProfile::ALL {
-            let label = if p == current { trf("{profile} (current)", &[("profile", &p.label())]) } else { p.label().to_string() };
-            if crate::widgets::radio(ui, chosen == p, &label) {
-                chosen = p;
-            }
-        }
-        ui.add_space(8.0);
-        if chosen == current {
-            ui.label(RichText::new(tr("Choose another profile to change it.")).color(t.text_secondary).font(regular(11.0)));
-            return;
-        }
-        ui.label(
-            RichText::new(trf(
-                "Keep appearance converts every color value to {profile} so colors look the same. Keep values leaves the numbers as they are, so colors shift.",
-                &[("profile", &chosen.label())],
-            ))
-            .font(regular(11.0)),
-        );
-        if !chosen.is_srgb() {
-            ui.add_space(4.0);
-            ui.label(
-                RichText::new(tr("The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3."))
-                    .color(t.text_secondary)
-                    .font(regular(11.0)),
-            );
-        }
-        ui.add_space(12.0);
-        ui.horizontal(|ui| {
-            if crate::widgets::button(ui, tr("Keep appearance"), true, true).clicked() {
-                apply = Some(true);
-            }
-            if crate::widgets::button(ui, tr("Keep values"), false, true).clicked() {
-                apply = Some(false);
-            }
-        });
-    });
-    app.ui.color_profile = open.then_some(chosen);
-    if let Some(convert) = apply {
-        app.run("file.colorProfile", json!({"profile": chosen.id(), "convert": convert}));
-        app.ui.color_profile = None;
-    }
-}
-
-/// A `.fig` Save as result is an export; only native saves report that the document was saved.
-pub(crate) fn file_saved(app: &mut FigApp, result: &Value) {
-    if result["format"] == "fig" {
-        fig_exported(app, result);
-    } else {
-        app.toast(trf("Saved {name}", &[("name", &result_file_name(result))]));
-    }
-}
-
-fn result_file_name(result: &Value) -> String {
-    match result["path"].as_str() {
-        Some(p) => Path::new(p).file_name().map(|f| f.to_string_lossy().into_owned()).unwrap_or_default(),
-        // A download (#969).
-        None => result["name"].as_str().unwrap_or_default().to_owned(),
-    }
-}
-
-/// The `.fig` result stays an export: native save state is unchanged, and omissions are reported.
-pub(crate) fn fig_exported(app: &mut FigApp, result: &Value) {
-    let file = result_file_name(result);
-    let left_out = result["warnings"].as_array().map_or(0, Vec::len);
-    app.toast(match left_out {
-        0 => trf("Exported {name}", &[("name", &file)]),
-        n => trn("Exported {name}; {n} kinds of content were left out", n, &[("name", &file)]),
-    });
-}
-
-/// Save the whole file as `.fig`; the toast says how much was left out.
-fn save_fig(app: &mut FigApp, name: &str) {
-    let filename = format!("{name}.fig");
-    if app.services.downloads() {
-        if let Some(mut r) = app.run("file.export", json!({"format": "fig"}))
-            && app.download(&filename, &r)
-        {
-            r["name"] = json!(filename);
-            fig_exported(app, &r);
-        }
-        return;
-    }
-    app.pick_save(tr("Export"), &filename, &["fig"], |app, p| {
-        if let Some(r) = app.run("file.export", json!({"format": "fig", "path": p.to_string_lossy()})) {
-            fig_exported(app, &r);
-        }
-    });
-}
-
-/// What the Export dialog was asked to do.
-enum ExportChoice {
-    /// Every layer with export settings, with those settings.
-    Layers,
-    /// The layers together as one file.
-    Once(ExportSetting),
-    /// The whole file as `.fig` (experimental).
-    Fig,
-}
-
-/// The Export dialog: the layers' own export settings when they have some, and one-off presets for
-/// the selection (or the page) as one file.
-fn export_dialog(app: &mut FigApp, ctx: &Context) {
-    let t = Tokens::get(ctx);
-    let mut open = true;
-    let sel = app.session.selection();
-    let Ok(ds) = app.session.ds() else {
-        app.ui.export_preview = false;
-        return;
-    };
-    let (doc, page) = (ds.doc.clone(), ds.page);
-    let ids = if sel.is_empty() { doc.node(page).map(|p| p.children.clone()).unwrap_or_default() } else { sel.clone() };
-    // With nothing selected, every layer on the page that has export settings.
-    let with_settings = if sel.is_empty() { exportable_layers(&doc, page) } else { sel };
-    let jobs = export_jobs(&doc, &with_settings);
-    let print = app.ui.pdf_print;
-    let preset = |size: f64, format| ExportSetting { size: ExportSize::Scale { value: size }, format, print, ..Default::default() };
-    let presets = [
-        preset(1.0, ExportFormat::Png),
-        preset(2.0, ExportFormat::Png),
-        preset(3.0, ExportFormat::Png),
-        preset(2.0, ExportFormat::Jpg),
-        preset(2.0, ExportFormat::Webp),
-        preset(1.0, ExportFormat::Svg),
-        preset(1.0, ExportFormat::Pdf),
-        preset(1.0, ExportFormat::VectorDrawable),
-    ];
-    let mut choice = None;
-    window(tr("Export"), ctx).open(&mut open).show(ctx, |ui| {
-        ui.set_width(320.0);
-        let caption = |ui: &mut egui::Ui, s: &str| {
-            ui.label(RichText::new(s).font(regular(11.0)).color(t.text_secondary));
-        };
-        let divider = |ui: &mut egui::Ui| {
-            ui.add_space(10.0);
-            let (r, _) = ui.allocate_exact_size(vec2(320.0, 1.0), Sense::hover());
-            ui.painter().line_segment([r.left_center(), r.right_center()], Stroke::new(1.0, t.border));
-            ui.add_space(10.0);
-        };
-        let row_tip = |ui: &mut egui::Ui, label: &str, tip: Option<&str>| {
-            let (r, resp) = ui.allocate_exact_size(vec2(320.0, 30.0), Sense::click());
-            if resp.hovered() {
-                ui.painter().rect_filled(r, CornerRadius::same(5), t.hover);
-            }
-            ui.painter().text(r.left_center() + vec2(10.0, 0.0), Align2::LEFT_CENTER, label, regular(12.0), t.text);
-            match tip {
-                Some(tip) => resp.on_hover_text(tip).clicked(),
-                None => resp.clicked(),
-            }
-        };
-        let row = |ui: &mut egui::Ui, label: &str| row_tip(ui, label, None);
-        if !jobs.is_empty() {
-            caption(ui, tr("With the layers' export settings"));
-            const SHOWN: usize = 6;
-            for j in jobs.iter().take(SHOWN) {
-                ui.label(RichText::new(&j.file).font(regular(12.0)).color(t.text));
-            }
-            if jobs.len() > SHOWN {
-                caption(ui, &trn("and {n} more", jobs.len() - SHOWN, &[]));
-            }
-            ui.add_space(6.0);
-            let layers = jobs.iter().map(|j| j.id).collect::<std::collections::BTreeSet<_>>().len();
-            let label = trn("Export {n} layers", layers, &[]);
-            if crate::widgets::button(ui, &label, true, true).clicked() {
-                choice = Some(ExportChoice::Layers);
-            }
-            divider(ui);
-        }
-        caption(ui, &trn("{n} layers as one file", ids.len(), &[]));
-        ui.add_space(4.0);
-        for p in &presets {
-            let label = if p.format.is_raster() { format!("{} @{}", p.format.label(), p.size.label()) } else { p.format.label().to_string() };
-            if row_tip(ui, &label, crate::export_panel::format_tip(p.format)) {
-                choice = Some(ExportChoice::Once(p.clone()));
-            }
-        }
-        // The PDF preset's print options.
-        ui.add_space(6.0);
-        caption(ui, tr("PDF print options"));
-        if let Some(next) = crate::export_panel::print_options(ui, egui::Id::unique("export_dialog_print"), &print) {
-            app.ui.pdf_print = next;
-        }
-        divider(ui);
-        caption(ui, tr("The whole file"));
-        ui.add_space(4.0);
-        if row(ui, tr(".fig (experimental)")) {
-            choice = Some(ExportChoice::Fig);
-        }
-        caption(ui, tr("Other apps may not open every .fig file exported here."));
-    });
-    let close = choice.is_some() || !open;
-    match choice {
-        Some(ExportChoice::Layers) => export_layers(app, &with_settings, false),
-        Some(ExportChoice::Once(s)) if !ids.is_empty() => save_one(app, &ids, &s, &suggested_name(&doc, &ids, &s, "Export")),
-        Some(ExportChoice::Once(_)) => app.toast(tr("Nothing to export")),
-        Some(ExportChoice::Fig) => save_fig(app, &doc.name),
-        None => {}
-    }
-    if close {
-        app.ui.export_preview = false;
-    }
-}
diff --git a/crates/ui-egui/src/dialogs/batch_rename.rs b/crates/ui-egui/src/dialogs/batch_rename.rs
new file mode 100644
index 00000000..b28055f2
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/batch_rename.rs
@@ -0,0 +1,113 @@
+use super::*;
+
+/// The Rename layers dialog's fields.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct BatchRenameUi {
+    /// The layers, in stacking order (bottom first), as numbered.
+    pub ids: Vec<NodeId>,
+    /// Match: empty renames the whole name.
+    pub find: String,
+    pub regex: bool,
+    /// Rename to.
+    pub to: String,
+    /// Where up numbers start and down numbers stop.
+    pub start: u32,
+}
+
+/// Layers whose new names the dialog previews.
+const PREVIEW_ROWS: usize = 5;
+
+/// Open the Rename layers dialog for `ids` (several layers: Cmd/Ctrl+R, F2, the context menu).
+pub(crate) fn open_batch_rename(app: &mut FigApp, ids: &[NodeId]) {
+    let Ok(doc) = app.session.doc() else { return };
+    let ids = figcraft_engine::cmd::edit::z_sorted(doc, ids);
+    app.ui.batch_rename = Some(BatchRenameUi { ids, start: 1, ..Default::default() });
+}
+
+/// The rename the fields describe: a match replaced, or (no match) the whole name.
+pub(crate) fn batch_rename_params(b: &BatchRenameUi) -> serde_json::Value {
+    let mut p = json!({"ids": b.ids, "regex": b.regex, "start": b.start});
+    if b.find.is_empty() {
+        p["name"] = json!(b.to);
+    } else {
+        p["find"] = json!(b.find);
+        p["replace"] = json!(b.to);
+    }
+    p
+}
+
+/// Rename layers: Match, Rename to with buttons for the current name and numbers, where numbers
+/// start, a preview of the first new names, then one `object.batchRename`.
+pub(super) fn batch_rename_dialog(app: &mut FigApp, ctx: &Context) {
+    let Some(mut b) = app.ui.batch_rename.clone() else { return };
+    let t = Tokens::get(ctx);
+    let find = (!b.find.is_empty()).then_some(b.find.as_str());
+    let rename = figcraft_engine::rename::BatchRename::new(find, b.regex, &b.to, find.is_none().then_some(b.to.as_str()), Some(f64::from(b.start)));
+    let n = b.ids.len();
+    let ready = rename.is_ok() && !(b.find.is_empty() && b.to.is_empty());
+    let preview: Vec<(String, String)> = match (&rename, app.session.doc()) {
+        (Ok(r), Ok(doc)) if ready => b
+            .ids
+            .iter()
+            .enumerate()
+            .take(PREVIEW_ROWS)
+            .filter_map(|(k, i)| doc.node(*i).map(|node| (node.name.clone(), r.apply(&node.name, k, n))))
+            .collect(),
+        _ => Vec::new(),
+    };
+    let mut open = true;
+    let mut cancel = false;
+    let mut apply = false;
+    window(tr("Rename layers"), ctx).id(egui::Id::unique("Rename layers")).open(&mut open).show(ctx, |ui| {
+        ui.set_width(320.0);
+        ui.label(RichText::new(trn("{n} layers", n, &[])).color(t.text_secondary));
+        ui.add_space(6.0);
+        let r = ui.add(egui::TextEdit::singleline(&mut b.find).hint_text(tr("Match (empty: the whole name)")).desired_width(300.0));
+        crate::widgets::select_all_on_focus(ui, &r, &b.find);
+        if crate::widgets::checkbox(ui, b.regex, tr("Regular expression")) {
+            b.regex = !b.regex;
+        }
+        let to = ui.add(egui::TextEdit::singleline(&mut b.to).hint_text(tr("Rename to")).desired_width(300.0));
+        crate::widgets::select_all_on_focus(ui, &to, &b.to);
+        ui.horizontal(|ui| {
+            for (label, code) in [(tr("Current name"), "$&"), (tr("Number ↑"), "$n"), (tr("Number ↓"), "$N")] {
+                if ui.button(label).clicked() {
+                    b.to.push_str(code);
+                    to.request_focus();
+                }
+            }
+        });
+        ui.horizontal(|ui| {
+            ui.label(tr("Start ascending from / stop descending at"));
+            ui.add(egui::DragValue::new(&mut b.start).range(0..=1_000_000));
+        });
+        ui.add_space(8.0);
+        match &rename {
+            Err(e) => {
+                ui.label(RichText::new(e).color(t.danger));
+            }
+            Ok(_) => {
+                for (old, new) in &preview {
+                    ui.horizontal(|ui| {
+                        ui.label(RichText::new(old).color(t.text_secondary));
+                        ui.label("→");
+                        ui.label(new);
+                    });
+                }
+                if ready && n > PREVIEW_ROWS {
+                    ui.label(RichText::new(trn("and {n} more", n - PREVIEW_ROWS, &[])).color(t.text_secondary));
+                }
+            }
+        }
+        ui.add_space(8.0);
+        ui.horizontal(|ui| {
+            cancel = crate::widgets::button(ui, tr("Cancel"), false, true).clicked();
+            let enter = to.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
+            apply = (crate::widgets::button(ui, tr("Rename"), true, ready).clicked() || enter) && ready;
+        });
+    });
+    if apply {
+        app.run("object.batchRename", batch_rename_params(&b));
+    }
+    app.ui.batch_rename = (open && !cancel && !apply).then_some(b);
+}
diff --git a/crates/ui-egui/src/dialogs/color_profile.rs b/crates/ui-egui/src/dialogs/color_profile.rs
new file mode 100644
index 00000000..f818c50d
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/color_profile.rs
@@ -0,0 +1,59 @@
+use super::*;
+
+/// File ▸ Color profile: pick sRGB or Display P3, then keep the colours' appearance (convert the
+/// values) or keep the values (reinterpret them in the new space).
+pub(super) fn color_profile_dialog(app: &mut FigApp, ctx: &Context) {
+    let Some(mut chosen) = app.ui.color_profile else { return };
+    let Ok(current) = app.session.doc().map(|d| d.color_profile) else {
+        app.ui.color_profile = None;
+        return;
+    };
+    let t = Tokens::get(ctx);
+    let mut open = true;
+    let mut apply = None;
+    window(tr("Color profile"), ctx).open(&mut open).show(ctx, |ui| {
+        ui.set_width(340.0);
+        ui.label(RichText::new(tr("Color values in this file are in this color space.")).color(t.text_secondary).font(regular(11.0)));
+        ui.add_space(8.0);
+        for p in ColorProfile::ALL {
+            let label = if p == current { trf("{profile} (current)", &[("profile", &p.label())]) } else { p.label().to_string() };
+            if crate::widgets::radio(ui, chosen == p, &label) {
+                chosen = p;
+            }
+        }
+        ui.add_space(8.0);
+        if chosen == current {
+            ui.label(RichText::new(tr("Choose another profile to change it.")).color(t.text_secondary).font(regular(11.0)));
+            return;
+        }
+        ui.label(
+            RichText::new(trf(
+                "Keep appearance converts every color value to {profile} so colors look the same. Keep values leaves the numbers as they are, so colors shift.",
+                &[("profile", &chosen.label())],
+            ))
+            .font(regular(11.0)),
+        );
+        if !chosen.is_srgb() {
+            ui.add_space(4.0);
+            ui.label(
+                RichText::new(tr("The canvas previews colors in sRGB; exported PNG, JPG and WebP files are tagged Display P3."))
+                    .color(t.text_secondary)
+                    .font(regular(11.0)),
+            );
+        }
+        ui.add_space(12.0);
+        ui.horizontal(|ui| {
+            if crate::widgets::button(ui, tr("Keep appearance"), true, true).clicked() {
+                apply = Some(true);
+            }
+            if crate::widgets::button(ui, tr("Keep values"), false, true).clicked() {
+                apply = Some(false);
+            }
+        });
+    });
+    app.ui.color_profile = open.then_some(chosen);
+    if let Some(convert) = apply {
+        app.run("file.colorProfile", json!({"profile": chosen.id(), "convert": convert}));
+        app.ui.color_profile = None;
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/export.rs b/crates/ui-egui/src/dialogs/export.rs
new file mode 100644
index 00000000..e3a96e59
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/export.rs
@@ -0,0 +1,160 @@
+use super::*;
+
+/// A `.fig` Save as result is an export; only native saves report that the document was saved.
+pub(crate) fn file_saved(app: &mut FigApp, result: &Value) {
+    if result["format"] == "fig" {
+        fig_exported(app, result);
+    } else {
+        app.toast(trf("Saved {name}", &[("name", &result_file_name(result))]));
+    }
+}
+
+fn result_file_name(result: &Value) -> String {
+    match result["path"].as_str() {
+        Some(p) => Path::new(p).file_name().map(|f| f.to_string_lossy().into_owned()).unwrap_or_default(),
+        // A download (#969).
+        None => result["name"].as_str().unwrap_or_default().to_owned(),
+    }
+}
+
+/// The `.fig` result stays an export: native save state is unchanged, and omissions are reported.
+pub(crate) fn fig_exported(app: &mut FigApp, result: &Value) {
+    let file = result_file_name(result);
+    let left_out = result["warnings"].as_array().map_or(0, Vec::len);
+    app.toast(match left_out {
+        0 => trf("Exported {name}", &[("name", &file)]),
+        n => trn("Exported {name}; {n} kinds of content were left out", n, &[("name", &file)]),
+    });
+}
+
+/// Save the whole file as `.fig`; the toast says how much was left out.
+fn save_fig(app: &mut FigApp, name: &str) {
+    let filename = format!("{name}.fig");
+    if app.services.downloads() {
+        if let Some(mut r) = app.run("file.export", json!({"format": "fig"}))
+            && app.download(&filename, &r)
+        {
+            r["name"] = json!(filename);
+            fig_exported(app, &r);
+        }
+        return;
+    }
+    app.pick_save(tr("Export"), &filename, &["fig"], |app, p| {
+        if let Some(r) = app.run("file.export", json!({"format": "fig", "path": p.to_string_lossy()})) {
+            fig_exported(app, &r);
+        }
+    });
+}
+
+/// What the Export dialog was asked to do.
+enum ExportChoice {
+    /// Every layer with export settings, with those settings.
+    Layers,
+    /// The layers together as one file.
+    Once(ExportSetting),
+    /// The whole file as `.fig` (experimental).
+    Fig,
+}
+
+/// The Export dialog: the layers' own export settings when they have some, and one-off presets for
+/// the selection (or the page) as one file.
+pub(super) fn export_dialog(app: &mut FigApp, ctx: &Context) {
+    let t = Tokens::get(ctx);
+    let mut open = true;
+    let sel = app.session.selection();
+    let Ok(ds) = app.session.ds() else {
+        app.ui.export_preview = false;
+        return;
+    };
+    let (doc, page) = (ds.doc.clone(), ds.page);
+    let ids = if sel.is_empty() { doc.node(page).map(|p| p.children.clone()).unwrap_or_default() } else { sel.clone() };
+    // With nothing selected, every layer on the page that has export settings.
+    let with_settings = if sel.is_empty() { exportable_layers(&doc, page) } else { sel };
+    let jobs = export_jobs(&doc, &with_settings);
+    let print = app.ui.pdf_print;
+    let preset = |size: f64, format| ExportSetting { size: ExportSize::Scale { value: size }, format, print, ..Default::default() };
+    let presets = [
+        preset(1.0, ExportFormat::Png),
+        preset(2.0, ExportFormat::Png),
+        preset(3.0, ExportFormat::Png),
+        preset(2.0, ExportFormat::Jpg),
+        preset(2.0, ExportFormat::Webp),
+        preset(1.0, ExportFormat::Svg),
+        preset(1.0, ExportFormat::Pdf),
+        preset(1.0, ExportFormat::VectorDrawable),
+    ];
+    let mut choice = None;
+    window(tr("Export"), ctx).open(&mut open).show(ctx, |ui| {
+        ui.set_width(320.0);
+        let caption = |ui: &mut egui::Ui, s: &str| {
+            ui.label(RichText::new(s).font(regular(11.0)).color(t.text_secondary));
+        };
+        let divider = |ui: &mut egui::Ui| {
+            ui.add_space(10.0);
+            let (r, _) = ui.allocate_exact_size(vec2(320.0, 1.0), Sense::hover());
+            ui.painter().line_segment([r.left_center(), r.right_center()], Stroke::new(1.0, t.border));
+            ui.add_space(10.0);
+        };
+        let row_tip = |ui: &mut egui::Ui, label: &str, tip: Option<&str>| {
+            let (r, resp) = ui.allocate_exact_size(vec2(320.0, 30.0), Sense::click());
+            if resp.hovered() {
+                ui.painter().rect_filled(r, CornerRadius::same(5), t.hover);
+            }
+            ui.painter().text(r.left_center() + vec2(10.0, 0.0), Align2::LEFT_CENTER, label, regular(12.0), t.text);
+            match tip {
+                Some(tip) => resp.on_hover_text(tip).clicked(),
+                None => resp.clicked(),
+            }
+        };
+        let row = |ui: &mut egui::Ui, label: &str| row_tip(ui, label, None);
+        if !jobs.is_empty() {
+            caption(ui, tr("With the layers' export settings"));
+            const SHOWN: usize = 6;
+            for j in jobs.iter().take(SHOWN) {
+                ui.label(RichText::new(&j.file).font(regular(12.0)).color(t.text));
+            }
+            if jobs.len() > SHOWN {
+                caption(ui, &trn("and {n} more", jobs.len() - SHOWN, &[]));
+            }
+            ui.add_space(6.0);
+            let layers = jobs.iter().map(|j| j.id).collect::<std::collections::BTreeSet<_>>().len();
+            let label = trn("Export {n} layers", layers, &[]);
+            if crate::widgets::button(ui, &label, true, true).clicked() {
+                choice = Some(ExportChoice::Layers);
+            }
+            divider(ui);
+        }
+        caption(ui, &trn("{n} layers as one file", ids.len(), &[]));
+        ui.add_space(4.0);
+        for p in &presets {
+            let label = if p.format.is_raster() { format!("{} @{}", p.format.label(), p.size.label()) } else { p.format.label().to_string() };
+            if row_tip(ui, &label, crate::export_panel::format_tip(p.format)) {
+                choice = Some(ExportChoice::Once(p.clone()));
+            }
+        }
+        // The PDF preset's print options.
+        ui.add_space(6.0);
+        caption(ui, tr("PDF print options"));
+        if let Some(next) = crate::export_panel::print_options(ui, egui::Id::unique("export_dialog_print"), &print) {
+            app.ui.pdf_print = next;
+        }
+        divider(ui);
+        caption(ui, tr("The whole file"));
+        ui.add_space(4.0);
+        if row(ui, tr(".fig (experimental)")) {
+            choice = Some(ExportChoice::Fig);
+        }
+        caption(ui, tr("Other apps may not open every .fig file exported here."));
+    });
+    let close = choice.is_some() || !open;
+    match choice {
+        Some(ExportChoice::Layers) => export_layers(app, &with_settings, false),
+        Some(ExportChoice::Once(s)) if !ids.is_empty() => save_one(app, &ids, &s, &suggested_name(&doc, &ids, &s, "Export")),
+        Some(ExportChoice::Once(_)) => app.toast(tr("Nothing to export")),
+        Some(ExportChoice::Fig) => save_fig(app, &doc.name),
+        None => {}
+    }
+    if close {
+        app.ui.export_preview = false;
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/menu_input.rs b/crates/ui-egui/src/dialogs/menu_input.rs
new file mode 100644
index 00000000..e815c532
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/menu_input.rs
@@ -0,0 +1,75 @@
+use super::*;
+
+/// Values collected by a menu or Actions command before dispatching it to the engine.
+#[derive(Clone, Debug, PartialEq)]
+pub enum MenuInput {
+    Link(String),
+    Offset(f64),
+    MoveToPage,
+}
+
+/// Menus and Actions cannot pass a value themselves. Gather it here, then run the regular
+/// command so the same validation and undo behaviour apply as for programmatic callers.
+pub(super) fn menu_input_dialog(app: &mut FigApp, ctx: &Context) {
+    let Some(mut input) = app.ui.menu_input.take() else { return };
+    let t = Tokens::get(ctx);
+    let title = match &input {
+        MenuInput::Link(_) => i18n::command("text.link", "Create link"),
+        MenuInput::Offset(_) => i18n::command("vector.offset", "Offset path"),
+        MenuInput::MoveToPage => i18n::command("object.moveToPage", "Move to page"),
+    };
+    let mut open = true;
+    let mut action: Option<(&str, serde_json::Value)> = None;
+    window(&title, ctx).open(&mut open).show(ctx, |ui| {
+        ui.set_width(320.0);
+        match &mut input {
+            MenuInput::Link(url) => {
+                ui.horizontal(|ui| {
+                    let field = crate::widgets::text_input(ui, egui::Id::unique("menu_input_link"), url, 250.0, "https://");
+                    let enter = field.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
+                    let ok = !url.trim().is_empty();
+                    if (crate::widgets::button(ui, tr("Done"), true, ok).clicked() || enter) && ok {
+                        action = Some(("text.link", json!({"url": url.trim()})));
+                    }
+                });
+            }
+            MenuInput::Offset(offset) => {
+                ui.horizontal(|ui| {
+                    let id = egui::Id::unique("menu_input_offset");
+                    if let Some(crate::widgets::FieldEdit::Set(v) | crate::widgets::FieldEdit::Scrub(v, _)) =
+                        crate::widgets::number_field(ui, id, crate::widgets::Lead::None, Some(*offset), "", 120.0, 1.0)
+                    {
+                        *offset = v.clamp(-100_000.0, 100_000.0);
+                    }
+                    if crate::widgets::button(ui, tr("Offset"), true, true).clicked() {
+                        action = Some(("vector.offset", json!({"offset": *offset})));
+                    }
+                });
+            }
+            MenuInput::MoveToPage => {
+                let mut choices = 0;
+                if let Ok(ds) = app.session.ds() {
+                    for &page in &ds.doc.pages {
+                        if page == ds.page || ds.doc.is_divider(page) {
+                            continue;
+                        }
+                        if let Some(node) = ds.doc.node(page)
+                            && crate::widgets::button(ui, &node.name, false, true).clicked()
+                        {
+                            action = Some(("object.moveToPage", json!({"page": page})));
+                        }
+                        choices += 1;
+                    }
+                }
+                if choices == 0 {
+                    crate::widgets::label(ui, tr("No other pages"), t.text_secondary);
+                }
+            }
+        }
+    });
+    if let Some((id, params)) = action {
+        app.run(id, params);
+    } else if open {
+        app.ui.menu_input = Some(input);
+    }
+}

From 65443020dbb7f84276e30adab0cab67c52f59338 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:56:10 +0000
Subject: [PATCH 39/67] refactor(ui-egui): split menus.rs into menus/

---
 crates/ui-egui/src/menus.rs              | 981 +----------------------
 crates/ui-egui/src/menus/clipboard.rs    | 122 +++
 crates/ui-egui/src/menus/palette.rs      | 410 ++++++++++
 crates/ui-egui/src/menus/select_layer.rs |  55 ++
 crates/ui-egui/src/menus/tree.rs         | 384 +++++++++
 5 files changed, 989 insertions(+), 963 deletions(-)
 create mode 100644 crates/ui-egui/src/menus/clipboard.rs
 create mode 100644 crates/ui-egui/src/menus/palette.rs
 create mode 100644 crates/ui-egui/src/menus/select_layer.rs
 create mode 100644 crates/ui-egui/src/menus/tree.rs

diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index af6de8c2..549a55c0 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -12,6 +12,24 @@ use crate::icons::{self, Icon};
 use crate::theme::{Tokens, regular};
 use crate::toolbar::pretty_shortcut;
 
+mod clipboard;
+mod palette;
+mod select_layer;
+mod tree;
+
+pub use clipboard::paste;
+use clipboard::{figcraft_svg_export, text_layers_text};
+use palette::palette;
+#[cfg(test)]
+pub(crate) use palette::{ActionRow, command_sections, palette_sections, recent_row, run_action};
+pub use palette::{PaletteTab, set_palette, toggle_palette};
+pub use select_layer::open_select_layer;
+use select_layer::{SELECT_LAYER, select_layer_ask_id, select_layer_menu};
+#[cfg(test)]
+pub(crate) use tree::{AIM_REST, HOVER_DELAY, heading_for, in_triangle};
+use tree::{At, menu_frame, plain_row_hover, set_open, submenu_at};
+pub(crate) use tree::{forget_tree, item, separator, submenu};
+
 /// Commands the UI layer implements itself (dialogs and platform actions).
 pub const UI_COMMANDS: &[&str] = &[
     "plugin.import",
@@ -29,114 +47,6 @@ pub const UI_COMMANDS: &[&str] = &[
     "edit.copyLink",
 ];
 
-/// Run a menu item: some open dialogs or use platform services, the rest go to the engine.
-/// Paste: the system clipboard wins when it holds something newer than our own copy (layers copied
-/// from another design app, an image, SVG or text from another app); otherwise our copied layers.
-/// `event_text` is the text the platform handed over with the paste event (the browser has no
-/// other way to read it). `at`: the page point to paste at (Paste here); `None` pastes in the
-/// middle of the view.
-/// In Dev Mode only a comment's link pastes (it opens the thread); everything else would edit.
-pub fn paste(app: &mut FigApp, event_text: Option<&str>, at: Option<(f64, f64)>) {
-    // A gesture injected through the control channel pastes only our own copied layers: it must not
-    // read (and so expose) the user's system clipboard.
-    if app.control_synthetic {
-        // Synthetic input is user-like: Dev Mode refuses the paste here too, and only the engine's
-        // own copied layers are pasted (the system clipboard is never read).
-        if !dev_mode_refuses(app, "edit.paste") {
-            app.run("edit.paste", at.map_or(json!({}), |(x, y)| json!({"x": x, "y": y})));
-        }
-        return;
-    }
-    // Only HTML that holds readable design data takes this path; other HTML pastes as before.
-    if let Some(html) = app.services.clipboard_get_html().filter(|h| figcraft_engine::cmd::edit::design_clipboard_buffer(h).is_some()) {
-        if dev_mode_refuses(app, "edit.paste") {
-            return;
-        }
-        let mut params = json!({"html": html});
-        if let Some((x, y)) = at {
-            params["x"] = json!(x);
-            params["y"] = json!(y);
-        }
-        if let Some(r) = app.run("edit.pasteDesignLayers", params) {
-            // The pasted layers are now our copy: text another app puts on the clipboard later is newer.
-            app.ui.last_copy = Some(app.services.clipboard_get_text().unwrap_or_default());
-            app.ui.last_copy_generation = app.session.clipboard.layers_generation;
-            let left_out = r["warnings"].as_array().map_or(0, Vec::len);
-            if left_out > 0 {
-                app.toast(trn("Pasted design layers; {n} kinds of content were left out", left_out, &[]));
-            }
-        }
-        return;
-    }
-    let sys_text = app.services.clipboard_get_text().or_else(|| event_text.map(str::to_string)).filter(|t| !t.is_empty());
-    // The text matching `last_copy` means the system clipboard still holds what we mirrored only
-    // while the engine clipboard is the one we mirrored. A control-channel copy changes the engine
-    // clipboard without writing the system clipboard, so its generation no longer matches and the
-    // user's own text is pasted instead of the programmatic selection.
-    let ours = sys_text.is_some() && sys_text == app.ui.last_copy && app.ui.last_copy_generation == app.session.clipboard.layers_generation;
-    let (cx, cy) = at.or_else(|| app.session.ds().ok().map(|d| (d.view.cx, d.view.cy))).unwrap_or((0.0, 0.0));
-    if !ours {
-        if let Some((png, w, h)) = clipboard_png(app) {
-            if dev_mode_refuses(app, "edit.paste") {
-                return;
-            }
-            use base64::Engine as _;
-            let b64 = base64::engine::general_purpose::STANDARD.encode(png);
-            // One selected layer that can have fills takes the image as its top fill.
-            if let [target] = app.session.selection()[..]
-                && at.is_none()
-                && app.session.doc().ok().and_then(|d| d.node(target)).is_some_and(|n| figcraft_engine::cmd::create::accepts_image_fill(&n.kind))
-            {
-                app.run("image.place", json!({"data": b64, "target": target}));
-                return;
-            }
-            // Centred in the view; Paste here puts its top-left at the point, as it does layers.
-            let (x, y) = if at.is_some() { (cx, cy) } else { ((cx - f64::from(w) / 2.0).round(), (cy - f64::from(h) / 2.0).round()) };
-            app.run("file.import", json!({"data": b64, "name": "Pasted image.png", "x": x, "y": y}));
-            return;
-        }
-        // Not ours: any other text is newer (another app's text, SVG, a comment link) and wins.
-        // Our own marker for copied layers without a text/SVG mirror is never a text paste; when
-        // the engine copy moved on it falls through to `edit.paste` (the only layers we still have).
-        if let Some(text) = sys_text.filter(|t| !is_clipboard_marker(t)) {
-            return paste_text(app, &text, (cx, cy), at.is_none());
-        }
-    }
-    if !dev_mode_refuses(app, "edit.paste") {
-        app.run("edit.paste", at.map_or(json!({}), |(x, y)| json!({"x": x, "y": y})));
-    }
-}
-
-/// The marker FigCraft puts on the system clipboard for copied layers with no text/SVG mirror.
-fn is_clipboard_marker(text: &str) -> bool {
-    text.starts_with("figcraft://clipboard/")
-}
-
-/// Paste text from another app at `(cx, cy)` (`center`: centred there): a comment's link opens its
-/// thread, SVG imports, anything else becomes a text layer.
-fn paste_text(app: &mut FigApp, text: &str, (cx, cy): (f64, f64), center: bool) {
-    if text.trim().starts_with("figcraft://comment/") {
-        app.run("comment.open", json!({"link": text.trim()}));
-    } else if dev_mode_refuses(app, "edit.paste") {
-        // Dev Mode: the note says why nothing was pasted.
-    } else if figcraft_engine::looks_like_svg(text) {
-        use base64::Engine as _;
-        let b64 = base64::engine::general_purpose::STANDARD.encode(text.as_bytes());
-        app.run_user("file.import", json!({"data": b64, "name": "Pasted SVG.svg", "x": cx, "y": cy, "center": center}));
-    } else {
-        app.run("text.create", json!({"text": text, "x": cx, "y": cy}));
-    }
-}
-
-/// The system clipboard's image as PNG bytes, with its size.
-fn clipboard_png(app: &mut FigApp) -> Option<(Vec<u8>, u32, u32)> {
-    let (w, h, rgba) = app.services.clipboard_get_image()?;
-    let img = image::RgbaImage::from_raw(w, h, rgba)?;
-    let mut out = std::io::Cursor::new(Vec::new());
-    img.write_to(&mut out, image::ImageFormat::Png).ok()?;
-    Some((out.into_inner(), w, h))
-}
-
 /// Dev Mode (the Inspect tab) refuses command `id` from the menus, shortcuts, clipboard, the
 /// Pages list, the layers panel, files dropped on the canvas and the Assets panel: it edits the
 /// design ([`figcraft_engine::devinspect::dev_mode_allows`]). Says so when it does.
@@ -148,15 +58,6 @@ pub fn dev_mode_refuses(app: &mut FigApp, id: &str) -> bool {
     refused
 }
 
-/// The Actions palette's tab.
-#[derive(Clone, Copy, PartialEq, Eq, Default)]
-pub enum PaletteTab {
-    #[default]
-    All,
-    Assets,
-    Plugins,
-}
-
 /// Remember an action run from the palette for its Recents (newest first, capped).
 pub fn record_recent(app: &mut FigApp, key: &str) {
     let r = &mut app.session.prefs.recent_actions;
@@ -337,19 +238,6 @@ fn export_frames_pdf(app: &mut FigApp) {
     });
 }
 
-/// The text of a selection made only of text layers, one layer per line (None for any other
-/// selection, or when there is no text).
-fn text_layers_text(doc: &figcraft_doc::Document, ids: &[figcraft_doc::NodeId]) -> Option<String> {
-    let texts: Option<Vec<&str>> = ids.iter().map(|i| doc.node(*i).and_then(|n| n.kind.text()).map(|t| t.characters.as_str())).collect();
-    texts.map(|t| t.join("\n")).filter(|t| !t.is_empty())
-}
-
-/// The layers as SVG text for other apps (None when the export fails).
-fn figcraft_svg_export(doc: &figcraft_doc::Document, ids: &[figcraft_doc::NodeId]) -> Option<String> {
-    let bytes = figcraft_engine::cmd::file::export_bytes(doc, ids, figcraft_doc::ExportFormat::Svg, 1.0).ok()?;
-    String::from_utf8(bytes).ok()
-}
-
 /// Whether a menu id is available (registered in the engine or handled by the UI).
 pub fn available(id: &str) -> bool {
     !id.is_empty() && (figcraft_engine::find_command(id).is_some() || UI_COMMANDS.contains(&id))
@@ -436,386 +324,6 @@ fn recent_menu(app: &mut FigApp, ui: &mut Ui, prefix: &str, key: &str, label: &s
     true
 }
 
-/// A submenu row `label` in the menu being drawn; while it's open, `add` draws its items beside
-/// it. `key` names the submenu (its menu path, unique in its menu tree). Returns what `add`
-/// returned.
-pub(crate) fn submenu<R>(ui: &mut Ui, key: &str, label: &str, t: &Tokens, add: impl FnOnce(&mut Ui) -> Option<R>) -> Option<R> {
-    submenu_at(ui, Id::unique(("submenu", key)), key, label, 4.0, false, t, add)
-}
-
-// ---------------------------------------------------------------------------------------------
-// Which submenu is open: hover intent with a safe triangle.
-//
-// Every menu tree (the main menu, the context menu) keeps, per level, which of its submenus is
-// open. Hovering another row closes the open submenu at once; resting on a submenu row for
-// `HOVER_DELAY` opens it (sweeping across rows doesn't flash every submenu on the way). Except while the
-// pointer is on its way from the open submenu's row to the submenu: while each move lands inside
-// the triangle between where it was and the submenu's near edge (it keeps getting nearer), rows
-// it crosses don't take over and the submenu's row stays highlighted. Resting (`AIM_REST`) or
-// turning away ends that, and the row under the pointer takes over. Leaving the menus keeps the
-// last submenu open.
-// Closing a menu tree forgets all of it, so it reopens with no submenu open.
-
-/// How long the pointer stays on a submenu row before its submenu opens.
-pub(crate) const HOVER_DELAY: f64 = 0.15;
-/// How long the pointer may rest inside the safe triangle before the row under it takes over.
-pub(crate) const AIM_REST: f64 = 0.3;
-/// A pointer that moved less than this is resting.
-const AIM_STILL: f32 = 1.0;
-/// The triangle reaches this far above and below the submenu.
-const AIM_EDGE_SLOP: f32 = 8.0;
-
-/// The hover state of one menu level.
-#[derive(Clone, Default, Debug)]
-struct Level {
-    /// The open submenu's key.
-    open: Option<String>,
-    /// The open submenu's row and where its panel was drawn (last frame).
-    row: Option<Rect>,
-    panel: Option<Rect>,
-    /// The pointer's last position counted as heading for the panel, and when it got there.
-    apex: Option<egui::Pos2>,
-    moved_at: f64,
-    /// This pass's verdict: the pointer is aiming at the panel.
-    pass: Option<u64>,
-    aiming: bool,
-    /// The row the pointer is on, waiting to take over (a submenu's key, or `None`: a plain row),
-    /// and since when; whether a row asked this pass (unasked, it lapses).
-    pending: Option<(Option<String>, f64)>,
-    asked: bool,
-    /// When the pointer came to rest in the triangle, if that's what ended aiming this pass.
-    rested_at: Option<f64>,
-}
-
-/// One menu tree's levels, by menu path ("" for the top).
-#[derive(Clone, Default, Debug)]
-struct Tree {
-    levels: std::collections::HashMap<String, Level>,
-}
-
-/// The menu level a menu frame's ui draws: its tree's root and its path.
-#[derive(Clone, Debug)]
-struct At {
-    root: Id,
-    path: String,
-}
-
-/// Scoped egui id for the current menu level.
-fn at_key(ui: &Ui) -> Id {
-    ui.scope_id().with("menu_level")
-}
-
-/// Return the current menu root/path, defaulting to the main menu root.
-fn level_at(ui: &Ui) -> At {
-    ui.data(|d| d.get_temp::<At>(at_key(ui))).unwrap_or(At { root: Id::unique("menus"), path: String::new() })
-}
-
-fn with_level<R>(ctx: &egui::Context, at: &At, f: impl FnOnce(&mut Level) -> R) -> R {
-    ctx.data_mut(|d| f(d.get_temp_mut_or_default::<Tree>(at.root).levels.entry(at.path.clone()).or_default()))
-}
-
-/// Forget everything a menu tree remembers (it closed or opened anew).
-pub(crate) fn forget_tree(ctx: &egui::Context, root: Id) {
-    ctx.data_mut(|d| d.remove::<Tree>(root));
-}
-
-/// Open (`Some(key)`) or close (`None`) a submenu of `root`'s level `path`; the levels below the
-/// one it replaces are forgotten (they reopen closed).
-fn set_open(ctx: &egui::Context, root: Id, path: &str, key: Option<&str>) {
-    ctx.data_mut(|d| {
-        let tree = d.get_temp_mut_or_default::<Tree>(root);
-        let level = tree.levels.entry(path.to_string()).or_default();
-        if level.open.as_deref() == key {
-            return;
-        }
-        let old = std::mem::replace(&mut level.open, key.map(str::to_string));
-        level.row = None;
-        level.panel = None;
-        level.apex = None;
-        level.pending = None;
-        if let Some(old) = old {
-            let below = format!("{old}/");
-            tree.levels.retain(|p, _| *p != old && !p.starts_with(&below));
-        }
-    });
-}
-
-/// Whether `p` is in the triangle `a`, `b`, `c` (either winding, edges included).
-pub(crate) fn in_triangle(p: egui::Pos2, a: egui::Pos2, b: egui::Pos2, c: egui::Pos2) -> bool {
-    let side = |u: egui::Pos2, v: egui::Pos2| (v.x - u.x) * (p.y - u.y) - (v.y - u.y) * (p.x - u.x);
-    let (d1, d2, d3) = (side(a, b), side(b, c), side(c, a));
-    let neg = d1 < 0.0 || d2 < 0.0 || d3 < 0.0;
-    let pos = d1 > 0.0 || d2 > 0.0 || d3 > 0.0;
-    !(neg && pos)
-}
-
-/// Whether a pointer that moved from `from` to `p` is heading for `panel`: `p` is inside the
-/// triangle from `from` to the panel's near edge, so it got nearer the panel without leaving the
-/// rows' way to it. Straight up or down (or away) isn't.
-pub(crate) fn heading_for(from: egui::Pos2, p: egui::Pos2, panel: Rect) -> bool {
-    if ![from.x, from.y, p.x, p.y].iter().all(|v| v.is_finite()) {
-        return false;
-    }
-    let edge = if panel.min.x >= from.x {
-        panel.min.x
-    } else if panel.max.x <= from.x {
-        panel.max.x
-    } else {
-        return false;
-    };
-    in_triangle(p, from, pos2(edge, panel.min.y - AIM_EDGE_SLOP), pos2(edge, panel.max.y + AIM_EDGE_SLOP))
-}
-
-/// Whether the pointer is on its way to this level's open submenu (rows it crosses don't take
-/// over). Worked out once per pass per level.
-fn aiming(ui: &Ui) -> bool {
-    let at = level_at(ui);
-    let ctx = ui.ctx();
-    let pass = ctx.cumulative_pass_nr();
-    let (p, now) = ctx.input(|i| (i.pointer.hover_pos(), i.time));
-    let (aiming, wait) = with_level(ctx, &at, |l| {
-        if l.pass == Some(pass) {
-            return (l.aiming, None);
-        }
-        l.pass = Some(pass);
-        l.aiming = false;
-        l.rested_at = None;
-        if !l.asked {
-            l.pending = None;
-        }
-        l.asked = false;
-        let (Some(p), Some(_), Some(panel)) = (p, l.open.as_ref(), l.panel) else {
-            l.apex = None;
-            return (false, None);
-        };
-        if panel.contains(p) {
-            l.apex = None;
-            return (false, None);
-        }
-        // On the row (its bottom edge is the next row's).
-        if l.row.is_some_and(|r| (r.min.x..r.max.x).contains(&p.x) && (r.min.y..r.max.y).contains(&p.y)) {
-            l.apex = Some(p);
-            l.moved_at = now;
-            return (false, None);
-        }
-        let Some(from) = l.apex else { return (false, None) };
-        if (p - from).length() <= AIM_STILL {
-            // Resting: the submenu holds a moment longer.
-            if !(0.0..AIM_REST).contains(&(now - l.moved_at)) {
-                l.apex = None;
-                // It has rested long enough: the row under it needn't wait again.
-                l.rested_at = Some(l.moved_at);
-                return (false, None);
-            }
-        } else if heading_for(from, p, panel) {
-            l.apex = Some(p);
-            l.moved_at = now;
-        } else {
-            l.apex = None;
-            return (false, None);
-        }
-        l.aiming = true;
-        (true, Some(AIM_REST - (now - l.moved_at)))
-    });
-    // Wake up when the rest runs out, so the row under a still pointer takes over.
-    if let Some(w) = wait.filter(|w| w.is_finite() && *w > 0.0) {
-        ctx.request_repaint_after(std::time::Duration::from_secs_f64(w));
-    }
-    aiming
-}
-
-/// The pointer is on a row of level `at` (`target`: the row's submenu, or `None` for a plain
-/// row): another open submenu closes at once, and `target` opens once the pointer has stayed
-/// there `HOVER_DELAY`.
-fn hover_request(ctx: &egui::Context, at: &At, target: Option<&str>) {
-    let now = ctx.input(|i| i.time);
-    if with_level(ctx, at, |l| l.open.is_some() && l.open.as_deref() != target) {
-        set_open(ctx, at.root, &at.path, None);
-    }
-    let left = with_level(ctx, at, |l| {
-        l.asked = true;
-        if l.open.as_deref() == target {
-            l.pending = None;
-            return None;
-        }
-        let since = match &l.pending {
-            Some((t, since)) if t.as_deref() == target => *since,
-            _ => {
-                let since = l.rested_at.unwrap_or(now);
-                l.pending = Some((target.map(str::to_string), since));
-                since
-            }
-        };
-        Some(HOVER_DELAY - (now - since))
-    });
-    match left {
-        Some(left) if left <= 0.0 => set_open(ctx, at.root, &at.path, target),
-        // Wake up when it's due, so a still pointer gets there.
-        Some(left) => ctx.request_repaint_after(std::time::Duration::from_secs_f64(left.min(HOVER_DELAY))),
-        None => {}
-    }
-}
-
-/// Whether the pointer is on a row of level `at` other than the open submenu's (it shows as
-/// hovered instead).
-fn pending_elsewhere(ctx: &egui::Context, at: &At) -> bool {
-    with_level(ctx, at, |l| l.pending.as_ref().is_some_and(|(t, _)| *t != l.open))
-}
-
-/// A plain row of the level being drawn: hovering it (not while aiming at a submenu) closes the
-/// level's open submenu. Returns whether it shows as hovered.
-fn plain_row_hover(ui: &Ui, resp: &egui::Response) -> bool {
-    let hovered = resp.hovered() && !aiming(ui);
-    if hovered {
-        hover_request(ui.ctx(), &level_at(ui), None);
-    }
-    hovered || resp.has_focus()
-}
-
-/// A submenu row whose panel (area `area`, `gap` right of the row) shows while it's open.
-#[allow(clippy::too_many_arguments)]
-fn submenu_at<R>(
-    ui: &mut Ui,
-    area: Id,
-    key: &str,
-    label: &str,
-    gap: f32,
-    constrain: bool,
-    t: &Tokens,
-    add: impl FnOnce(&mut Ui) -> Option<R>,
-) -> Option<R> {
-    let at = level_at(ui);
-    let aim = aiming(ui);
-    let w = ui.available_width();
-    let (r, resp) = ui.allocate_exact_size(vec2(w, 28.0), Sense::click());
-    // The keyboard and clicks open it at once; hovering after a moment.
-    if resp.has_focus() || resp.clicked() {
-        set_open(ui.ctx(), at.root, &at.path, Some(key));
-    } else if resp.hovered() && !aim {
-        hover_request(ui.ctx(), &at, Some(key));
-    }
-    let open = with_level(ui.ctx(), &at, |l| {
-        let open = l.open.as_deref() == Some(key);
-        if open {
-            l.row = Some(r);
-        }
-        open
-    });
-    a11y::submenu(&resp, label, open);
-    a11y::own_focus(&resp);
-    // The open submenu's row stays highlighted while the pointer is in the submenu (not while it
-    // rests on another row of this menu).
-    let keep = open && !pending_elsewhere(ui.ctx(), &at);
-    paint_submenu_row(ui, r, label, keep || (resp.hovered() && !aim) || resp.has_focus(), t);
-    if !open {
-        return None;
-    }
-    let mut pos = pos2(r.max.x + gap, r.min.y - 8.0);
-    // No room beside the row (a phone): the submenu covers its parent instead of running off screen.
-    let screen = ui.ctx().content_rect();
-    let cramped = pos.x + MENU_W > screen.max.x;
-    if cramped {
-        pos.x = (screen.max.x - MENU_W - 8.0).max(screen.min.x + 4.0);
-    }
-    let child = At { root: at.root, path: key.to_string() };
-    let shown = egui::Area::new(area)
-        .fixed_pos(pos)
-        .order(egui::Order::Foreground)
-        .constrain(constrain || cramped)
-        .show(ui.ctx(), |ui| menu_frame(ui, t, child, add));
-    let panel = shown.response.rect;
-    with_level(ui.ctx(), &at, |l| l.panel = Some(panel));
-    shown.inner
-}
-
-/// A thin line between groups of menu items.
-pub(crate) fn separator(ui: &mut Ui) {
-    ui.add_space(4.0);
-    let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), 1.0), Sense::hover());
-    ui.painter().line_segment([r.left_center(), r.right_center()], Stroke::new(1.0, Color32::from_white_alpha(30)));
-    ui.add_space(4.0);
-}
-
-/// A menu panel drawing menu level `at`.
-fn menu_frame<R>(ui: &mut Ui, t: &Tokens, at: At, add: impl FnOnce(&mut Ui) -> R) -> R {
-    egui::Frame::NONE
-        .fill(t.menu)
-        .corner_radius(CornerRadius::same(13))
-        .inner_margin(egui::Margin::same(8))
-        .shadow(egui::Shadow { offset: [0, 4], blur: 16, spread: 0, color: Color32::from_black_alpha(60) })
-        .show(ui, |ui| {
-            // As wide as its widest row asked for (labels run longer in some languages).
-            let w = ui.data(|d| d.get_temp::<f32>(width_key(ui))).unwrap_or(0.0).max(MENU_W);
-            ui.set_width(w);
-            ui.spacing_mut().item_spacing = vec2(0.0, 0.0);
-            let key = at_key(ui);
-            ui.data_mut(|d| d.insert_temp(key, at));
-            add(ui)
-        })
-        .inner
-}
-
-/// A menu's narrowest width.
-const MENU_W: f32 = 240.0;
-
-/// Where a menu remembers the width its rows need (its frame's ui), per language.
-fn width_key(ui: &Ui) -> Id {
-    ui.scope_id().with(("menu_w", i18n::current().map(|l| l.code)))
-}
-
-/// A row needs `w`: the menu widens to it from the next frame on.
-fn need_width(ui: &Ui, w: f32) {
-    let key = width_key(ui);
-    if ui.data(|d| d.get_temp::<f32>(key)).unwrap_or(0.0) < w {
-        ui.data_mut(|d| d.insert_temp(key, w));
-        ui.ctx().request_repaint();
-    }
-}
-
-pub(crate) fn item(ui: &mut Ui, label: &str, shortcut: &str, enabled: bool, checked: bool, t: &Tokens) -> bool {
-    indented_item(ui, label, shortcut, enabled, checked, 0.0, t)
-}
-
-/// A menu row whose label starts `indent` pixels further in (nested layers).
-fn indented_item(ui: &mut Ui, label: &str, shortcut: &str, enabled: bool, checked: bool, indent: f32, t: &Tokens) -> bool {
-    let w = ui.available_width();
-    let (r, resp) = ui.allocate_exact_size(vec2(w, 28.0), Sense::click());
-    a11y::menu_item(&resp, label, shortcut, checked.then_some(true));
-    if !enabled {
-        a11y::disabled(&resp);
-    }
-    // The keyboard's item is highlighted like the hovered one.
-    a11y::own_focus(&resp);
-    let hov = plain_row_hover(ui, &resp) && enabled;
-    if hov {
-        ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
-    }
-    let col = if enabled { t.menu_text } else { t.menu_dim };
-    if checked {
-        icons::paint(ui.painter(), Rect::from_center_size(pos2(r.min.x + 12.0, r.center().y), vec2(12.0, 12.0)), Icon::Check, col);
-    }
-    let galley = ui.painter().layout_no_wrap(label.to_string(), regular(12.0), col);
-    let keys = (!shortcut.is_empty())
-        .then(|| ui.painter().layout_no_wrap(pretty_shortcut(shortcut), regular(12.0), if hov { t.menu_text } else { t.menu_dim }));
-    need_width(ui, 28.0 + indent + galley.size().x + keys.as_ref().map_or(8.0, |k| 16.0 + k.size().x + 10.0));
-    let text_rect = Rect::from_min_max(pos2(r.min.x + 28.0 + indent, r.min.y), pos2(r.max.x - 8.0, r.max.y));
-    ui.painter().with_clip_rect(text_rect).galley(pos2(text_rect.min.x, r.center().y - galley.size().y / 2.0), galley, col);
-    if let Some(k) = keys {
-        ui.painter().galley(pos2(r.max.x - 10.0 - k.size().x, r.center().y - k.size().y / 2.0), k, col);
-    }
-    resp.clicked()
-}
-
-fn paint_submenu_row(ui: &mut Ui, r: Rect, label: &str, highlight: bool, t: &Tokens) {
-    if highlight {
-        ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
-    }
-    let galley = ui.painter().layout_no_wrap(label.to_string(), regular(12.0), t.menu_text);
-    need_width(ui, 28.0 + galley.size().x + 28.0);
-    ui.painter().galley(pos2(r.min.x + 28.0, r.center().y - galley.size().y / 2.0), galley, t.menu_text);
-    icons::paint(ui.painter(), Rect::from_center_size(pos2(r.max.x - 12.0, r.center().y), vec2(12.0, 12.0)), Icon::ChevronRight, t.menu_text);
-}
-
 /// Open the main menu at top-level menu `top` (control channel).
 pub fn open_main_menu(ctx: &egui::Context, top: &str) {
     set_open(ctx, main_menu_id(), "", Some(top));
@@ -1089,458 +597,5 @@ pub fn popups(app: &mut FigApp, ctx: &egui::Context) {
     palette(app, ctx);
 }
 
-/// The context menu's Select layer submenu (its key in the context menu's tree).
-const SELECT_LAYER: &str = "Select layer";
-
 /// The context menu's Copy as submenu: its key in the tree, and the marker row in the entries.
 const COPY_AS: &str = "Copy as";
-
-/// Stable egui id for the context menu's pending Select-layer open request.
-fn select_layer_ask_id() -> Id {
-    Id::unique("ctx_select_layer_ask")
-}
-
-/// Open (or close) the context menu's Select layer submenu (applied when the menu next draws).
-pub fn open_select_layer(ctx: &egui::Context, open: bool) {
-    ctx.data_mut(|d| d.insert_temp(select_layer_ask_id(), open));
-}
-
-/// The context menu's "Select layer" submenu (right-click on the canvas): every layer under the
-/// click, nested ones indented, the selected ones checked. Returns whether one was picked.
-fn select_layer_menu(app: &mut FigApp, ui: &mut Ui, pos: egui::Pos2, t: &Tokens) -> bool {
-    if !app.canvas.rect.contains(pos) {
-        return false;
-    }
-    let p = app.to_page(pos);
-    let Ok(ds) = app.session.ds() else { return false };
-    let tol = 2.0 / ds.view.zoom.max(1e-6);
-    let layers: Vec<(figcraft_doc::NodeId, usize, String)> =
-        figcraft_doc::geometry::layers_at(&ds.doc, ds.page, p, tol, Some(&figcraft_engine::booleans::result_outline(&ds.doc, &ds.selection)))
-            .into_iter()
-            .take(40)
-            .filter_map(|(id, depth)| {
-                ds.doc.node(id).map(|n| (id, depth, if n.name.is_empty() { n.kind.type_name().to_lowercase() } else { n.name.clone() }))
-            })
-            .collect();
-    if layers.is_empty() {
-        return false;
-    }
-    let sel = ds.selection.clone();
-    let picked = submenu_at(ui, Id::unique("ctx_select_layer"), SELECT_LAYER, tr("Select layer"), 4.0, true, t, |ui| {
-        let mut picked = None;
-        for (id, depth, name) in &layers {
-            if indented_item(ui, name, "", true, sel.contains(id), 12.0 * (*depth).min(8) as f32, t) {
-                picked = Some(*id);
-            }
-        }
-        picked
-    });
-    separator(ui);
-    match picked {
-        Some(id) => {
-            app.run("select.set", json!({"ids": [id]}));
-            true
-        }
-        None => false,
-    }
-}
-
-/// The Actions palette's content height (the frame adds its own 8 px margins).
-const PALETTE_H: f32 = 450.0;
-
-/// Open the Actions palette afresh (empty search, All tab, first row highlighted), or close it.
-pub fn set_palette(ui: &mut crate::UiState, open: bool) {
-    ui.palette = open.then(String::new);
-    ui.palette_tab = PaletteTab::All;
-    ui.palette_hi = 0;
-    ui.palette_armed = open;
-}
-
-/// Open the Actions palette afresh, or close it when it's open (⌘K, the toolbar's Actions button).
-pub fn toggle_palette(ui: &mut crate::UiState) {
-    let open = ui.palette.is_none();
-    set_palette(ui, open);
-}
-
-/// The Actions palette: search over commands, assets and plugins, with tabs, recents and grouped
-/// sections, floating above the toolbar. Rows run on click; Up and Down move the highlight and
-/// Enter runs the highlighted row.
-fn palette(app: &mut FigApp, ctx: &egui::Context) {
-    let Some(mut q) = app.ui.palette.clone() else { return };
-    let t = Tokens::get(ctx);
-    // Same centre and width as the toolbar pill (it centres on the canvas, not the window),
-    // floating 8 px above it. Fixed size: switching tabs never resizes the panel.
-    let bar_w = crate::toolbar::bar_width(app);
-    let bar = crate::toolbar::pill_rect(app.canvas.rect, bar_w);
-    let area = Rect::from_min_max(pos2(bar.min.x, bar.min.y - 8.0 - (PALETTE_H + 16.0)), pos2(bar.max.x, bar.min.y - 8.0));
-    let mut run: Option<String> = None;
-    let mut close = false;
-    // A press anywhere outside closes the panel. The opening press is spared once, and the
-    // spare expires the first frame without a press (so the next outside press always closes).
-    let pressed = ctx.input(|i| i.pointer.any_pressed());
-    if pressed && !std::mem::replace(&mut app.ui.palette_armed, false) {
-        let on_toggle = app.ui.actions_rect.is_some_and(|b| ctx.input(|i| i.pointer.hover_pos().is_some_and(|p| b.contains(p))));
-        let outside = !on_toggle && ctx.input(|i| i.pointer.hover_pos().map(|p| !area.contains(p)).unwrap_or(false));
-        if outside {
-            close = true;
-        }
-    } else if !pressed {
-        app.ui.palette_armed = false;
-    }
-    // Taken before the search field sees them (it would move its cursor).
-    let step = ctx.input_mut(|i| {
-        i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowDown) as i64
-            - i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowUp) as i64
-    });
-    egui::Area::new(Id::unique("palette")).fixed_pos(area.min).order(egui::Order::Foreground).show(ctx, |ui| {
-        egui::Frame::NONE
-            .fill(t.panel)
-            .corner_radius(CornerRadius::same(13))
-            .stroke(Stroke::new(1.0, t.border))
-            .shadow(egui::Shadow { offset: [0, 8], blur: 32, spread: 0, color: t.shadow })
-            .inner_margin(egui::Margin::same(8))
-            .show(ui, |ui| {
-                // Same outer width as the toolbar pill, and a fixed height: switching tabs
-                // never resizes the panel.
-                let inner = bar_w - 16.0;
-                ui.set_width(inner);
-                ui.set_height(PALETTE_H);
-                let r = ui.add(
-                    egui::TextEdit::singleline(&mut q)
-                        .hint_text(tr("Search actions, layers and tools"))
-                        .desired_width(inner - 16.0)
-                        .font(regular(14.0))
-                        .frame(egui::Frame::NONE.inner_margin(egui::Margin::same(8))),
-                );
-                r.request_focus();
-                crate::widgets::select_all_on_focus(ui, &r, &q);
-                // A new search starts again at the first row.
-                if r.changed() {
-                    app.ui.palette_hi = 0;
-                }
-                ui.add_space(4.0);
-                // Tabs: All, Assets, Plugins & widgets.
-                let tabs = [(PaletteTab::All, tr("All")), (PaletteTab::Assets, tr("Assets")), (PaletteTab::Plugins, tr("Plugins & widgets"))];
-                ui.horizontal(|ui| {
-                    ui.spacing_mut().item_spacing = vec2(4.0, 0.0);
-                    for (tab, label) in tabs {
-                        let active = app.ui.palette_tab == tab;
-                        // The frame stays on for every tab (transparent when idle) so the
-                        // active pill never moves its neighbours.
-                        let resp = ui.add(
-                            egui::Button::new(egui::RichText::new(label).size(12.0).color(if active { t.text } else { t.text_secondary }))
-                                .frame(true)
-                                .fill(if active { t.hover } else { Color32::TRANSPARENT })
-                                .corner_radius(CornerRadius::same(6)),
-                        );
-                        if resp.clicked() {
-                            app.ui.palette_tab = tab;
-                            app.ui.palette_hi = 0;
-                        }
-                    }
-                });
-                ui.add_space(4.0);
-                let sections = palette_sections(app, &q, app.ui.palette_tab);
-                let count = sections.iter().map(|(_, rows)| rows.len()).sum::<usize>();
-                // At either end it stays where it was.
-                let hi = (app.ui.palette_hi as i64 + step).clamp(0, count.saturating_sub(1) as i64) as usize;
-                app.ui.palette_hi = hi;
-                // The pointer moving over a row moves the highlight there.
-                let pointer_moved = ui.input(|i| i.pointer.delta() != egui::Vec2::ZERO);
-                egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
-                    let mut i = 0;
-                    for (name, rows) in &sections {
-                        section(ui, &t, name, |ui| {
-                            for row in rows {
-                                let resp = draw_row(ui, &t, row, i == hi);
-                                if resp.clicked() {
-                                    run = Some(row.key.clone());
-                                }
-                                if pointer_moved && resp.hovered() && i != hi {
-                                    app.ui.palette_hi = i;
-                                    // Drawn there on the next frame, even if the pointer stops now.
-                                    ui.ctx().request_repaint();
-                                }
-                                if step != 0 && i == hi {
-                                    resp.scroll_to_me(None);
-                                }
-                                i += 1;
-                            }
-                        });
-                    }
-                });
-                if run.is_none() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
-                    run = sections.iter().flat_map(|(_, rows)| rows).nth(hi).map(|row| row.key.clone());
-                }
-            });
-    });
-    if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
-        close = true;
-    }
-    if let Some(key) = run {
-        app.ui.palette = None;
-        run_action(app, &key);
-        return;
-    }
-    app.ui.palette = if close { None } else { Some(q) };
-    let _ = StrokeKind::Inside;
-}
-
-/// The rows a palette tab shows for the query, by section: All has Recents, the commands by menu,
-/// then plugins and widgets; Assets this file's components and styles; Plugins & widgets those.
-pub(crate) fn palette_sections(app: &FigApp, q: &str, tab: PaletteTab) -> Vec<(String, Vec<ActionRow>)> {
-    let mut out = match tab {
-        PaletteTab::All => {
-            let recents = app.session.prefs.recent_actions.iter().filter_map(|key| recent_row(app, key, q)).collect();
-            let mut out = vec![(tr("Recents").to_string(), recents)];
-            out.extend(command_sections(q));
-            out
-        }
-        PaletteTab::Assets => asset_sections(app, q),
-        PaletteTab::Plugins => Vec::new(),
-    };
-    if tab != PaletteTab::Assets {
-        out.push((tr("Plugins").to_string(), plugin_rows(app, q)));
-        out.push((tr("Widgets").to_string(), widget_rows(app, q)));
-    }
-    out.retain(|(_, rows)| !rows.is_empty());
-    out
-}
-
-/// Run a palette row: `command:<id>`, `plugin:<plugin>/<command>`, `widget:<plugin>`,
-/// `component:<node>` or `style:<id>`.
-pub(crate) fn run_action(app: &mut FigApp, key: &str) {
-    if let Some(id) = key.strip_prefix("command:") {
-        record_recent(app, key);
-        invoke(app, id);
-    } else if let Some(rest) = key.strip_prefix("plugin:") {
-        if let Some((plugin, command)) = rest.split_once('/') {
-            record_recent(app, key);
-            crate::plugins_ui::start(app, plugin, command);
-        }
-    } else if let Some(plugin) = key.strip_prefix("widget:") {
-        record_recent(app, key);
-        app.run("widget.insert", json!({ "plugin": plugin }));
-    } else if let Some(node) = key.strip_prefix("component:") {
-        if let Ok(n) = node.parse::<u64>() {
-            let (cx, cy) = app.session.ds().map(|d| (d.view.cx, d.view.cy)).unwrap_or((0.0, 0.0));
-            app.run("instance.place", json!({ "component": n, "x": cx, "y": cy }));
-        }
-    } else if let Some(style) = key.strip_prefix("style:") {
-        if app.session.selection().is_empty() {
-            app.toast(tr("Select layers to apply the style to"));
-        } else {
-            app.run("style.apply", json!({ "style": style }));
-        }
-    }
-}
-
-/// One pickable palette row.
-pub(crate) struct ActionRow {
-    pub(crate) key: String,
-    pub(crate) label: String,
-    hint: String,
-    /// A letter tile instead of an icon (plugins carry no artwork).
-    tile: Option<char>,
-}
-
-/// A section header with its rows.
-fn section(ui: &mut Ui, t: &Tokens, name: &str, rows: impl FnOnce(&mut Ui)) {
-    ui.add_space(10.0);
-    ui.painter().text(pos2(ui.min_rect().min.x + 10.0, ui.cursor().min.y + 8.0), Align2::LEFT_TOP, name, regular(12.5), t.text_secondary);
-    ui.add_space(22.0);
-    rows(ui);
-}
-
-/// Draw one row (a letter tile for plugins, else just the label) with its right-side hint,
-/// `highlighted` when Enter runs it.
-fn draw_row(ui: &mut Ui, t: &Tokens, row: &ActionRow, highlighted: bool) -> egui::Response {
-    let w = ui.available_width();
-    let (r, resp) = ui.allocate_exact_size(vec2(w, 34.0), Sense::click());
-    // The highlight pill stays inside the row: it never touches the panel's edges.
-    let pill = r.shrink2(vec2(4.0, 1.0));
-    if highlighted {
-        ui.painter().rect_filled(pill, CornerRadius::same(6), t.hover);
-    }
-    let mut label_x = r.min.x + 10.0;
-    if let Some(letter) = row.tile {
-        let tile = Rect::from_center_size(pos2(r.min.x + 20.0, r.center().y), vec2(18.0, 18.0));
-        ui.painter().rect_filled(tile, CornerRadius::same(5), t.hover);
-        ui.painter().text(tile.center(), Align2::CENTER_CENTER, letter.to_string(), regular(11.0), t.text);
-        label_x = r.min.x + 38.0;
-    }
-    ui.painter().text(pos2(label_x, r.center().y), Align2::LEFT_CENTER, &row.label, regular(13.0), t.text);
-    ui.painter().text(pos2(r.max.x - 10.0, r.center().y), Align2::RIGHT_CENTER, &row.hint, regular(11.0), t.text_secondary);
-    resp
-}
-
-/// Whether `label` (or `extra`) matches the query, in any case.
-fn matches(q: &str, label: &str, extra: &str) -> bool {
-    q.is_empty() || label.to_lowercase().contains(q) || extra.to_lowercase().contains(q)
-}
-
-/// A command's row: its label, and its shortcut as the hint.
-fn command_row(id: &str, label: String) -> ActionRow {
-    ActionRow { key: format!("command:{id}"), label, hint: crate::shortcuts::shortcut(id).map(pretty_shortcut).unwrap_or_default(), tile: None }
-}
-
-/// Most rows a search shows (the best matches).
-const MAX_HITS: usize = 60;
-
-/// Commands grouped by top-level menu, filtered by the query. Without one, the menus' items in
-/// catalog order; a search covers every command (the engine's and the UI's own, "Other" for those
-/// no menu lists), best matches first (labels starting with the query, then the shortest), each
-/// group placed by its best row. Labels match in the UI language and in English. The Plugins
-/// menu's items come with the plugins ([`plugin_rows`]).
-pub(crate) fn command_sections(q: &str) -> Vec<(String, Vec<ActionRow>)> {
-    let ql = q.trim().to_lowercase();
-    let mut menu_of = std::collections::HashMap::new();
-    for m in MENU.iter().filter(|m| m.label != SEP) {
-        menu_of.entry(m.id).or_insert(m);
-    }
-    let menu_items = MENU.iter().filter(|m| m.label != SEP).map(|m| (m.id, m.label));
-    let engine = figcraft_engine::all_commands().iter().map(|c| (c.id, c.label));
-    let candidates: Box<dyn Iterator<Item = (&str, &str)>> = if ql.is_empty() { Box::new(menu_items) } else { Box::new(menu_items.chain(engine)) };
-    let mut seen = std::collections::HashSet::new();
-    // By top-level menu; `None`: no menu lists it.
-    let mut hits: Vec<(Option<&str>, ActionRow)> = Vec::new();
-    for (id, english) in candidates {
-        if !available(id) || !seen.insert(id) {
-            continue;
-        }
-        let menu = menu_of.get(id);
-        let group = menu.map(|m| m.menu.split('/').next().unwrap_or(m.menu));
-        if group == Some("Plugins") {
-            continue;
-        }
-        let label = match menu {
-            Some(m) => i18n::menu_item(id, m.label),
-            None => i18n::command(id, english),
-        };
-        if matches(&ql, &label, &format!("{english} {id}")) {
-            hits.push((group, command_row(id, label.into_owned())));
-        }
-    }
-    if !ql.is_empty() {
-        hits.sort_by_cached_key(|(_, row)| (!row.label.to_lowercase().starts_with(&ql), row.label.chars().count()));
-        hits.truncate(MAX_HITS);
-    }
-    let mut groups: Vec<(String, Vec<ActionRow>)> = Vec::new();
-    for (group, row) in hits {
-        let group = group.map_or_else(|| tr("Other"), tr).to_string();
-        match groups.iter_mut().find(|(g, _)| *g == group) {
-            Some((_, rows)) => rows.push(row),
-            None => groups.push((group, vec![row])),
-        }
-    }
-    groups
-}
-
-/// Installed plugins' commands, filtered by the query.
-fn plugin_rows(app: &FigApp, q: &str) -> Vec<ActionRow> {
-    let ql = q.to_lowercase();
-    let mut rows = Vec::new();
-    for p in &app.session.prefs.plugins {
-        let m = &p.manifest;
-        for c in &m.commands {
-            let label = if m.commands.len() == 1 { m.name.clone() } else { format!("{} — {}", m.name, c.label) };
-            if !matches(&ql, &label, &m.id) {
-                continue;
-            }
-            rows.push(ActionRow {
-                key: format!("plugin:{}/{}", m.id, c.id),
-                label,
-                hint: if c.params.is_empty() { tr("Plugin").to_string() } else { c.label.clone() },
-                tile: m.name.chars().next(),
-            });
-        }
-    }
-    // The Plugins menu's own items (run last, manage, import).
-    for m in MENU.iter().filter(|m| m.label != SEP && m.menu.split('/').next() == Some("Plugins") && available(m.id)) {
-        let label = i18n::menu_item(m.id, m.label);
-        if matches(&ql, &label, &format!("{} {}", m.label, m.id)) {
-            rows.push(command_row(m.id, label.into_owned()));
-        }
-    }
-    rows
-}
-
-/// Installed widgets, filtered by the query.
-fn widget_rows(app: &FigApp, q: &str) -> Vec<ActionRow> {
-    let ql = q.to_lowercase();
-    app.session
-        .prefs
-        .plugins
-        .iter()
-        .filter(|p| p.manifest.widget)
-        .filter(|p| matches(&ql, &p.manifest.name, &p.manifest.id))
-        .map(|p| ActionRow {
-            key: format!("widget:{}", p.manifest.id),
-            label: p.manifest.name.clone(),
-            hint: tr("Widget").to_string(),
-            tile: p.manifest.name.chars().next(),
-        })
-        .collect()
-}
-
-/// This file's components and styles, filtered by the query.
-fn asset_sections(app: &FigApp, q: &str) -> Vec<(String, Vec<ActionRow>)> {
-    let ql = q.to_lowercase();
-    let Ok(doc) = app.session.doc() else { return Vec::new() };
-    let components: Vec<ActionRow> = figcraft_engine::library::local_components(doc)
-        .iter()
-        .filter_map(|id| doc.node(*id))
-        .filter(|n| matches(&ql, &n.name, ""))
-        .map(|n| ActionRow { key: format!("component:{}", n.id.0), label: n.name.clone(), hint: tr("Component").to_string(), tile: None })
-        .collect();
-    let styles: Vec<ActionRow> = figcraft_engine::library::local_styles(doc)
-        .filter(|s| matches(&ql, &s.name, ""))
-        .map(|s| ActionRow { key: format!("style:{}", s.id), label: s.name.clone(), hint: tr("Style").to_string(), tile: None })
-        .collect();
-    let mut out = Vec::new();
-    if !components.is_empty() {
-        out.push((tr("Components").to_string(), components));
-    }
-    if !styles.is_empty() {
-        out.push((tr("Styles").to_string(), styles));
-    }
-    out
-}
-
-/// A recent action back as a row (gone commands, plugins or assets drop out).
-pub(crate) fn recent_row(app: &FigApp, key: &str, q: &str) -> Option<ActionRow> {
-    let ql = q.to_lowercase();
-    if let Some(id) = key.strip_prefix("command:") {
-        let spec = figcraft_engine::find_command(id);
-        let menu_label = figcraft_engine::catalog::MENU.iter().find(|m| m.id == id);
-        let english = menu_label.map(|m| m.label).or_else(|| spec.map(|s| s.label)).unwrap_or(id);
-        let label = i18n::command(id, english);
-        if !available(id) || !matches(&ql, &label, &format!("{english} {id}")) {
-            return None;
-        }
-        return Some(command_row(id, label.into_owned()));
-    }
-    if let Some(rest) = key.strip_prefix("plugin:") {
-        let (pid, cid) = rest.split_once('/')?;
-        let p = app.session.prefs.plugins.iter().find(|p| p.manifest.id == pid)?;
-        let c = p.manifest.commands.iter().find(|c| c.id == cid)?;
-        let label = if p.manifest.commands.len() == 1 { p.manifest.name.clone() } else { format!("{} — {}", p.manifest.name, c.label) };
-        if !matches(&ql, &label, pid) {
-            return None;
-        }
-        return Some(ActionRow { key: key.to_string(), label, hint: tr("Plugin").to_string(), tile: p.manifest.name.chars().next() });
-    }
-    if let Some(pid) = key.strip_prefix("widget:") {
-        let p = app.session.prefs.plugins.iter().find(|p| p.manifest.id == pid && p.manifest.widget)?;
-        if !matches(&ql, &p.manifest.name, pid) {
-            return None;
-        }
-        return Some(ActionRow {
-            key: key.to_string(),
-            label: p.manifest.name.clone(),
-            hint: tr("Widget").to_string(),
-            tile: p.manifest.name.chars().next(),
-        });
-    }
-    None
-}
diff --git a/crates/ui-egui/src/menus/clipboard.rs b/crates/ui-egui/src/menus/clipboard.rs
new file mode 100644
index 00000000..dd775297
--- /dev/null
+++ b/crates/ui-egui/src/menus/clipboard.rs
@@ -0,0 +1,122 @@
+use super::*;
+
+/// Run a menu item: some open dialogs or use platform services, the rest go to the engine.
+/// Paste: the system clipboard wins when it holds something newer than our own copy (layers copied
+/// from another design app, an image, SVG or text from another app); otherwise our copied layers.
+/// `event_text` is the text the platform handed over with the paste event (the browser has no
+/// other way to read it). `at`: the page point to paste at (Paste here); `None` pastes in the
+/// middle of the view.
+/// In Dev Mode only a comment's link pastes (it opens the thread); everything else would edit.
+pub fn paste(app: &mut FigApp, event_text: Option<&str>, at: Option<(f64, f64)>) {
+    // A gesture injected through the control channel pastes only our own copied layers: it must not
+    // read (and so expose) the user's system clipboard.
+    if app.control_synthetic {
+        // Synthetic input is user-like: Dev Mode refuses the paste here too, and only the engine's
+        // own copied layers are pasted (the system clipboard is never read).
+        if !dev_mode_refuses(app, "edit.paste") {
+            app.run("edit.paste", at.map_or(json!({}), |(x, y)| json!({"x": x, "y": y})));
+        }
+        return;
+    }
+    // Only HTML that holds readable design data takes this path; other HTML pastes as before.
+    if let Some(html) = app.services.clipboard_get_html().filter(|h| figcraft_engine::cmd::edit::design_clipboard_buffer(h).is_some()) {
+        if dev_mode_refuses(app, "edit.paste") {
+            return;
+        }
+        let mut params = json!({"html": html});
+        if let Some((x, y)) = at {
+            params["x"] = json!(x);
+            params["y"] = json!(y);
+        }
+        if let Some(r) = app.run("edit.pasteDesignLayers", params) {
+            // The pasted layers are now our copy: text another app puts on the clipboard later is newer.
+            app.ui.last_copy = Some(app.services.clipboard_get_text().unwrap_or_default());
+            app.ui.last_copy_generation = app.session.clipboard.layers_generation;
+            let left_out = r["warnings"].as_array().map_or(0, Vec::len);
+            if left_out > 0 {
+                app.toast(trn("Pasted design layers; {n} kinds of content were left out", left_out, &[]));
+            }
+        }
+        return;
+    }
+    let sys_text = app.services.clipboard_get_text().or_else(|| event_text.map(str::to_string)).filter(|t| !t.is_empty());
+    // The text matching `last_copy` means the system clipboard still holds what we mirrored only
+    // while the engine clipboard is the one we mirrored. A control-channel copy changes the engine
+    // clipboard without writing the system clipboard, so its generation no longer matches and the
+    // user's own text is pasted instead of the programmatic selection.
+    let ours = sys_text.is_some() && sys_text == app.ui.last_copy && app.ui.last_copy_generation == app.session.clipboard.layers_generation;
+    let (cx, cy) = at.or_else(|| app.session.ds().ok().map(|d| (d.view.cx, d.view.cy))).unwrap_or((0.0, 0.0));
+    if !ours {
+        if let Some((png, w, h)) = clipboard_png(app) {
+            if dev_mode_refuses(app, "edit.paste") {
+                return;
+            }
+            use base64::Engine as _;
+            let b64 = base64::engine::general_purpose::STANDARD.encode(png);
+            // One selected layer that can have fills takes the image as its top fill.
+            if let [target] = app.session.selection()[..]
+                && at.is_none()
+                && app.session.doc().ok().and_then(|d| d.node(target)).is_some_and(|n| figcraft_engine::cmd::create::accepts_image_fill(&n.kind))
+            {
+                app.run("image.place", json!({"data": b64, "target": target}));
+                return;
+            }
+            // Centred in the view; Paste here puts its top-left at the point, as it does layers.
+            let (x, y) = if at.is_some() { (cx, cy) } else { ((cx - f64::from(w) / 2.0).round(), (cy - f64::from(h) / 2.0).round()) };
+            app.run("file.import", json!({"data": b64, "name": "Pasted image.png", "x": x, "y": y}));
+            return;
+        }
+        // Not ours: any other text is newer (another app's text, SVG, a comment link) and wins.
+        // Our own marker for copied layers without a text/SVG mirror is never a text paste; when
+        // the engine copy moved on it falls through to `edit.paste` (the only layers we still have).
+        if let Some(text) = sys_text.filter(|t| !is_clipboard_marker(t)) {
+            return paste_text(app, &text, (cx, cy), at.is_none());
+        }
+    }
+    if !dev_mode_refuses(app, "edit.paste") {
+        app.run("edit.paste", at.map_or(json!({}), |(x, y)| json!({"x": x, "y": y})));
+    }
+}
+
+/// The marker FigCraft puts on the system clipboard for copied layers with no text/SVG mirror.
+fn is_clipboard_marker(text: &str) -> bool {
+    text.starts_with("figcraft://clipboard/")
+}
+
+/// Paste text from another app at `(cx, cy)` (`center`: centred there): a comment's link opens its
+/// thread, SVG imports, anything else becomes a text layer.
+fn paste_text(app: &mut FigApp, text: &str, (cx, cy): (f64, f64), center: bool) {
+    if text.trim().starts_with("figcraft://comment/") {
+        app.run("comment.open", json!({"link": text.trim()}));
+    } else if dev_mode_refuses(app, "edit.paste") {
+        // Dev Mode: the note says why nothing was pasted.
+    } else if figcraft_engine::looks_like_svg(text) {
+        use base64::Engine as _;
+        let b64 = base64::engine::general_purpose::STANDARD.encode(text.as_bytes());
+        app.run_user("file.import", json!({"data": b64, "name": "Pasted SVG.svg", "x": cx, "y": cy, "center": center}));
+    } else {
+        app.run("text.create", json!({"text": text, "x": cx, "y": cy}));
+    }
+}
+
+/// The system clipboard's image as PNG bytes, with its size.
+fn clipboard_png(app: &mut FigApp) -> Option<(Vec<u8>, u32, u32)> {
+    let (w, h, rgba) = app.services.clipboard_get_image()?;
+    let img = image::RgbaImage::from_raw(w, h, rgba)?;
+    let mut out = std::io::Cursor::new(Vec::new());
+    img.write_to(&mut out, image::ImageFormat::Png).ok()?;
+    Some((out.into_inner(), w, h))
+}
+
+/// The text of a selection made only of text layers, one layer per line (None for any other
+/// selection, or when there is no text).
+pub(super) fn text_layers_text(doc: &figcraft_doc::Document, ids: &[figcraft_doc::NodeId]) -> Option<String> {
+    let texts: Option<Vec<&str>> = ids.iter().map(|i| doc.node(*i).and_then(|n| n.kind.text()).map(|t| t.characters.as_str())).collect();
+    texts.map(|t| t.join("\n")).filter(|t| !t.is_empty())
+}
+
+/// The layers as SVG text for other apps (None when the export fails).
+pub(super) fn figcraft_svg_export(doc: &figcraft_doc::Document, ids: &[figcraft_doc::NodeId]) -> Option<String> {
+    let bytes = figcraft_engine::cmd::file::export_bytes(doc, ids, figcraft_doc::ExportFormat::Svg, 1.0).ok()?;
+    String::from_utf8(bytes).ok()
+}
diff --git a/crates/ui-egui/src/menus/palette.rs b/crates/ui-egui/src/menus/palette.rs
new file mode 100644
index 00000000..4890f8ad
--- /dev/null
+++ b/crates/ui-egui/src/menus/palette.rs
@@ -0,0 +1,410 @@
+use super::*;
+
+/// The Actions palette's tab.
+#[derive(Clone, Copy, PartialEq, Eq, Default)]
+pub enum PaletteTab {
+    #[default]
+    All,
+    Assets,
+    Plugins,
+}
+
+/// The Actions palette's content height (the frame adds its own 8 px margins).
+const PALETTE_H: f32 = 450.0;
+
+/// Open the Actions palette afresh (empty search, All tab, first row highlighted), or close it.
+pub fn set_palette(ui: &mut crate::UiState, open: bool) {
+    ui.palette = open.then(String::new);
+    ui.palette_tab = PaletteTab::All;
+    ui.palette_hi = 0;
+    ui.palette_armed = open;
+}
+
+/// Open the Actions palette afresh, or close it when it's open (⌘K, the toolbar's Actions button).
+pub fn toggle_palette(ui: &mut crate::UiState) {
+    let open = ui.palette.is_none();
+    set_palette(ui, open);
+}
+
+/// The Actions palette: search over commands, assets and plugins, with tabs, recents and grouped
+/// sections, floating above the toolbar. Rows run on click; Up and Down move the highlight and
+/// Enter runs the highlighted row.
+pub(super) fn palette(app: &mut FigApp, ctx: &egui::Context) {
+    let Some(mut q) = app.ui.palette.clone() else { return };
+    let t = Tokens::get(ctx);
+    // Same centre and width as the toolbar pill (it centres on the canvas, not the window),
+    // floating 8 px above it. Fixed size: switching tabs never resizes the panel.
+    let bar_w = crate::toolbar::bar_width(app);
+    let bar = crate::toolbar::pill_rect(app.canvas.rect, bar_w);
+    let area = Rect::from_min_max(pos2(bar.min.x, bar.min.y - 8.0 - (PALETTE_H + 16.0)), pos2(bar.max.x, bar.min.y - 8.0));
+    let mut run: Option<String> = None;
+    let mut close = false;
+    // A press anywhere outside closes the panel. The opening press is spared once, and the
+    // spare expires the first frame without a press (so the next outside press always closes).
+    let pressed = ctx.input(|i| i.pointer.any_pressed());
+    if pressed && !std::mem::replace(&mut app.ui.palette_armed, false) {
+        let on_toggle = app.ui.actions_rect.is_some_and(|b| ctx.input(|i| i.pointer.hover_pos().is_some_and(|p| b.contains(p))));
+        let outside = !on_toggle && ctx.input(|i| i.pointer.hover_pos().map(|p| !area.contains(p)).unwrap_or(false));
+        if outside {
+            close = true;
+        }
+    } else if !pressed {
+        app.ui.palette_armed = false;
+    }
+    // Taken before the search field sees them (it would move its cursor).
+    let step = ctx.input_mut(|i| {
+        i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowDown) as i64
+            - i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowUp) as i64
+    });
+    egui::Area::new(Id::unique("palette")).fixed_pos(area.min).order(egui::Order::Foreground).show(ctx, |ui| {
+        egui::Frame::NONE
+            .fill(t.panel)
+            .corner_radius(CornerRadius::same(13))
+            .stroke(Stroke::new(1.0, t.border))
+            .shadow(egui::Shadow { offset: [0, 8], blur: 32, spread: 0, color: t.shadow })
+            .inner_margin(egui::Margin::same(8))
+            .show(ui, |ui| {
+                // Same outer width as the toolbar pill, and a fixed height: switching tabs
+                // never resizes the panel.
+                let inner = bar_w - 16.0;
+                ui.set_width(inner);
+                ui.set_height(PALETTE_H);
+                let r = ui.add(
+                    egui::TextEdit::singleline(&mut q)
+                        .hint_text(tr("Search actions, layers and tools"))
+                        .desired_width(inner - 16.0)
+                        .font(regular(14.0))
+                        .frame(egui::Frame::NONE.inner_margin(egui::Margin::same(8))),
+                );
+                r.request_focus();
+                crate::widgets::select_all_on_focus(ui, &r, &q);
+                // A new search starts again at the first row.
+                if r.changed() {
+                    app.ui.palette_hi = 0;
+                }
+                ui.add_space(4.0);
+                // Tabs: All, Assets, Plugins & widgets.
+                let tabs = [(PaletteTab::All, tr("All")), (PaletteTab::Assets, tr("Assets")), (PaletteTab::Plugins, tr("Plugins & widgets"))];
+                ui.horizontal(|ui| {
+                    ui.spacing_mut().item_spacing = vec2(4.0, 0.0);
+                    for (tab, label) in tabs {
+                        let active = app.ui.palette_tab == tab;
+                        // The frame stays on for every tab (transparent when idle) so the
+                        // active pill never moves its neighbours.
+                        let resp = ui.add(
+                            egui::Button::new(egui::RichText::new(label).size(12.0).color(if active { t.text } else { t.text_secondary }))
+                                .frame(true)
+                                .fill(if active { t.hover } else { Color32::TRANSPARENT })
+                                .corner_radius(CornerRadius::same(6)),
+                        );
+                        if resp.clicked() {
+                            app.ui.palette_tab = tab;
+                            app.ui.palette_hi = 0;
+                        }
+                    }
+                });
+                ui.add_space(4.0);
+                let sections = palette_sections(app, &q, app.ui.palette_tab);
+                let count = sections.iter().map(|(_, rows)| rows.len()).sum::<usize>();
+                // At either end it stays where it was.
+                let hi = (app.ui.palette_hi as i64 + step).clamp(0, count.saturating_sub(1) as i64) as usize;
+                app.ui.palette_hi = hi;
+                // The pointer moving over a row moves the highlight there.
+                let pointer_moved = ui.input(|i| i.pointer.delta() != egui::Vec2::ZERO);
+                egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
+                    let mut i = 0;
+                    for (name, rows) in &sections {
+                        section(ui, &t, name, |ui| {
+                            for row in rows {
+                                let resp = draw_row(ui, &t, row, i == hi);
+                                if resp.clicked() {
+                                    run = Some(row.key.clone());
+                                }
+                                if pointer_moved && resp.hovered() && i != hi {
+                                    app.ui.palette_hi = i;
+                                    // Drawn there on the next frame, even if the pointer stops now.
+                                    ui.ctx().request_repaint();
+                                }
+                                if step != 0 && i == hi {
+                                    resp.scroll_to_me(None);
+                                }
+                                i += 1;
+                            }
+                        });
+                    }
+                });
+                if run.is_none() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+                    run = sections.iter().flat_map(|(_, rows)| rows).nth(hi).map(|row| row.key.clone());
+                }
+            });
+    });
+    if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
+        close = true;
+    }
+    if let Some(key) = run {
+        app.ui.palette = None;
+        run_action(app, &key);
+        return;
+    }
+    app.ui.palette = if close { None } else { Some(q) };
+    let _ = StrokeKind::Inside;
+}
+
+/// The rows a palette tab shows for the query, by section: All has Recents, the commands by menu,
+/// then plugins and widgets; Assets this file's components and styles; Plugins & widgets those.
+pub(crate) fn palette_sections(app: &FigApp, q: &str, tab: PaletteTab) -> Vec<(String, Vec<ActionRow>)> {
+    let mut out = match tab {
+        PaletteTab::All => {
+            let recents = app.session.prefs.recent_actions.iter().filter_map(|key| recent_row(app, key, q)).collect();
+            let mut out = vec![(tr("Recents").to_string(), recents)];
+            out.extend(command_sections(q));
+            out
+        }
+        PaletteTab::Assets => asset_sections(app, q),
+        PaletteTab::Plugins => Vec::new(),
+    };
+    if tab != PaletteTab::Assets {
+        out.push((tr("Plugins").to_string(), plugin_rows(app, q)));
+        out.push((tr("Widgets").to_string(), widget_rows(app, q)));
+    }
+    out.retain(|(_, rows)| !rows.is_empty());
+    out
+}
+
+/// Run a palette row: `command:<id>`, `plugin:<plugin>/<command>`, `widget:<plugin>`,
+/// `component:<node>` or `style:<id>`.
+pub(crate) fn run_action(app: &mut FigApp, key: &str) {
+    if let Some(id) = key.strip_prefix("command:") {
+        record_recent(app, key);
+        invoke(app, id);
+    } else if let Some(rest) = key.strip_prefix("plugin:") {
+        if let Some((plugin, command)) = rest.split_once('/') {
+            record_recent(app, key);
+            crate::plugins_ui::start(app, plugin, command);
+        }
+    } else if let Some(plugin) = key.strip_prefix("widget:") {
+        record_recent(app, key);
+        app.run("widget.insert", json!({ "plugin": plugin }));
+    } else if let Some(node) = key.strip_prefix("component:") {
+        if let Ok(n) = node.parse::<u64>() {
+            let (cx, cy) = app.session.ds().map(|d| (d.view.cx, d.view.cy)).unwrap_or((0.0, 0.0));
+            app.run("instance.place", json!({ "component": n, "x": cx, "y": cy }));
+        }
+    } else if let Some(style) = key.strip_prefix("style:") {
+        if app.session.selection().is_empty() {
+            app.toast(tr("Select layers to apply the style to"));
+        } else {
+            app.run("style.apply", json!({ "style": style }));
+        }
+    }
+}
+
+/// One pickable palette row.
+pub(crate) struct ActionRow {
+    pub(crate) key: String,
+    pub(crate) label: String,
+    hint: String,
+    /// A letter tile instead of an icon (plugins carry no artwork).
+    tile: Option<char>,
+}
+
+/// A section header with its rows.
+fn section(ui: &mut Ui, t: &Tokens, name: &str, rows: impl FnOnce(&mut Ui)) {
+    ui.add_space(10.0);
+    ui.painter().text(pos2(ui.min_rect().min.x + 10.0, ui.cursor().min.y + 8.0), Align2::LEFT_TOP, name, regular(12.5), t.text_secondary);
+    ui.add_space(22.0);
+    rows(ui);
+}
+
+/// Draw one row (a letter tile for plugins, else just the label) with its right-side hint,
+/// `highlighted` when Enter runs it.
+fn draw_row(ui: &mut Ui, t: &Tokens, row: &ActionRow, highlighted: bool) -> egui::Response {
+    let w = ui.available_width();
+    let (r, resp) = ui.allocate_exact_size(vec2(w, 34.0), Sense::click());
+    // The highlight pill stays inside the row: it never touches the panel's edges.
+    let pill = r.shrink2(vec2(4.0, 1.0));
+    if highlighted {
+        ui.painter().rect_filled(pill, CornerRadius::same(6), t.hover);
+    }
+    let mut label_x = r.min.x + 10.0;
+    if let Some(letter) = row.tile {
+        let tile = Rect::from_center_size(pos2(r.min.x + 20.0, r.center().y), vec2(18.0, 18.0));
+        ui.painter().rect_filled(tile, CornerRadius::same(5), t.hover);
+        ui.painter().text(tile.center(), Align2::CENTER_CENTER, letter.to_string(), regular(11.0), t.text);
+        label_x = r.min.x + 38.0;
+    }
+    ui.painter().text(pos2(label_x, r.center().y), Align2::LEFT_CENTER, &row.label, regular(13.0), t.text);
+    ui.painter().text(pos2(r.max.x - 10.0, r.center().y), Align2::RIGHT_CENTER, &row.hint, regular(11.0), t.text_secondary);
+    resp
+}
+
+/// Whether `label` (or `extra`) matches the query, in any case.
+fn matches(q: &str, label: &str, extra: &str) -> bool {
+    q.is_empty() || label.to_lowercase().contains(q) || extra.to_lowercase().contains(q)
+}
+
+/// A command's row: its label, and its shortcut as the hint.
+fn command_row(id: &str, label: String) -> ActionRow {
+    ActionRow { key: format!("command:{id}"), label, hint: crate::shortcuts::shortcut(id).map(pretty_shortcut).unwrap_or_default(), tile: None }
+}
+
+/// Most rows a search shows (the best matches).
+const MAX_HITS: usize = 60;
+
+/// Commands grouped by top-level menu, filtered by the query. Without one, the menus' items in
+/// catalog order; a search covers every command (the engine's and the UI's own, "Other" for those
+/// no menu lists), best matches first (labels starting with the query, then the shortest), each
+/// group placed by its best row. Labels match in the UI language and in English. The Plugins
+/// menu's items come with the plugins ([`plugin_rows`]).
+pub(crate) fn command_sections(q: &str) -> Vec<(String, Vec<ActionRow>)> {
+    let ql = q.trim().to_lowercase();
+    let mut menu_of = std::collections::HashMap::new();
+    for m in MENU.iter().filter(|m| m.label != SEP) {
+        menu_of.entry(m.id).or_insert(m);
+    }
+    let menu_items = MENU.iter().filter(|m| m.label != SEP).map(|m| (m.id, m.label));
+    let engine = figcraft_engine::all_commands().iter().map(|c| (c.id, c.label));
+    let candidates: Box<dyn Iterator<Item = (&str, &str)>> = if ql.is_empty() { Box::new(menu_items) } else { Box::new(menu_items.chain(engine)) };
+    let mut seen = std::collections::HashSet::new();
+    // By top-level menu; `None`: no menu lists it.
+    let mut hits: Vec<(Option<&str>, ActionRow)> = Vec::new();
+    for (id, english) in candidates {
+        if !available(id) || !seen.insert(id) {
+            continue;
+        }
+        let menu = menu_of.get(id);
+        let group = menu.map(|m| m.menu.split('/').next().unwrap_or(m.menu));
+        if group == Some("Plugins") {
+            continue;
+        }
+        let label = match menu {
+            Some(m) => i18n::menu_item(id, m.label),
+            None => i18n::command(id, english),
+        };
+        if matches(&ql, &label, &format!("{english} {id}")) {
+            hits.push((group, command_row(id, label.into_owned())));
+        }
+    }
+    if !ql.is_empty() {
+        hits.sort_by_cached_key(|(_, row)| (!row.label.to_lowercase().starts_with(&ql), row.label.chars().count()));
+        hits.truncate(MAX_HITS);
+    }
+    let mut groups: Vec<(String, Vec<ActionRow>)> = Vec::new();
+    for (group, row) in hits {
+        let group = group.map_or_else(|| tr("Other"), tr).to_string();
+        match groups.iter_mut().find(|(g, _)| *g == group) {
+            Some((_, rows)) => rows.push(row),
+            None => groups.push((group, vec![row])),
+        }
+    }
+    groups
+}
+
+/// Installed plugins' commands, filtered by the query.
+fn plugin_rows(app: &FigApp, q: &str) -> Vec<ActionRow> {
+    let ql = q.to_lowercase();
+    let mut rows = Vec::new();
+    for p in &app.session.prefs.plugins {
+        let m = &p.manifest;
+        for c in &m.commands {
+            let label = if m.commands.len() == 1 { m.name.clone() } else { format!("{} — {}", m.name, c.label) };
+            if !matches(&ql, &label, &m.id) {
+                continue;
+            }
+            rows.push(ActionRow {
+                key: format!("plugin:{}/{}", m.id, c.id),
+                label,
+                hint: if c.params.is_empty() { tr("Plugin").to_string() } else { c.label.clone() },
+                tile: m.name.chars().next(),
+            });
+        }
+    }
+    // The Plugins menu's own items (run last, manage, import).
+    for m in MENU.iter().filter(|m| m.label != SEP && m.menu.split('/').next() == Some("Plugins") && available(m.id)) {
+        let label = i18n::menu_item(m.id, m.label);
+        if matches(&ql, &label, &format!("{} {}", m.label, m.id)) {
+            rows.push(command_row(m.id, label.into_owned()));
+        }
+    }
+    rows
+}
+
+/// Installed widgets, filtered by the query.
+fn widget_rows(app: &FigApp, q: &str) -> Vec<ActionRow> {
+    let ql = q.to_lowercase();
+    app.session
+        .prefs
+        .plugins
+        .iter()
+        .filter(|p| p.manifest.widget)
+        .filter(|p| matches(&ql, &p.manifest.name, &p.manifest.id))
+        .map(|p| ActionRow {
+            key: format!("widget:{}", p.manifest.id),
+            label: p.manifest.name.clone(),
+            hint: tr("Widget").to_string(),
+            tile: p.manifest.name.chars().next(),
+        })
+        .collect()
+}
+
+/// This file's components and styles, filtered by the query.
+fn asset_sections(app: &FigApp, q: &str) -> Vec<(String, Vec<ActionRow>)> {
+    let ql = q.to_lowercase();
+    let Ok(doc) = app.session.doc() else { return Vec::new() };
+    let components: Vec<ActionRow> = figcraft_engine::library::local_components(doc)
+        .iter()
+        .filter_map(|id| doc.node(*id))
+        .filter(|n| matches(&ql, &n.name, ""))
+        .map(|n| ActionRow { key: format!("component:{}", n.id.0), label: n.name.clone(), hint: tr("Component").to_string(), tile: None })
+        .collect();
+    let styles: Vec<ActionRow> = figcraft_engine::library::local_styles(doc)
+        .filter(|s| matches(&ql, &s.name, ""))
+        .map(|s| ActionRow { key: format!("style:{}", s.id), label: s.name.clone(), hint: tr("Style").to_string(), tile: None })
+        .collect();
+    let mut out = Vec::new();
+    if !components.is_empty() {
+        out.push((tr("Components").to_string(), components));
+    }
+    if !styles.is_empty() {
+        out.push((tr("Styles").to_string(), styles));
+    }
+    out
+}
+
+/// A recent action back as a row (gone commands, plugins or assets drop out).
+pub(crate) fn recent_row(app: &FigApp, key: &str, q: &str) -> Option<ActionRow> {
+    let ql = q.to_lowercase();
+    if let Some(id) = key.strip_prefix("command:") {
+        let spec = figcraft_engine::find_command(id);
+        let menu_label = figcraft_engine::catalog::MENU.iter().find(|m| m.id == id);
+        let english = menu_label.map(|m| m.label).or_else(|| spec.map(|s| s.label)).unwrap_or(id);
+        let label = i18n::command(id, english);
+        if !available(id) || !matches(&ql, &label, &format!("{english} {id}")) {
+            return None;
+        }
+        return Some(command_row(id, label.into_owned()));
+    }
+    if let Some(rest) = key.strip_prefix("plugin:") {
+        let (pid, cid) = rest.split_once('/')?;
+        let p = app.session.prefs.plugins.iter().find(|p| p.manifest.id == pid)?;
+        let c = p.manifest.commands.iter().find(|c| c.id == cid)?;
+        let label = if p.manifest.commands.len() == 1 { p.manifest.name.clone() } else { format!("{} — {}", p.manifest.name, c.label) };
+        if !matches(&ql, &label, pid) {
+            return None;
+        }
+        return Some(ActionRow { key: key.to_string(), label, hint: tr("Plugin").to_string(), tile: p.manifest.name.chars().next() });
+    }
+    if let Some(pid) = key.strip_prefix("widget:") {
+        let p = app.session.prefs.plugins.iter().find(|p| p.manifest.id == pid && p.manifest.widget)?;
+        if !matches(&ql, &p.manifest.name, pid) {
+            return None;
+        }
+        return Some(ActionRow {
+            key: key.to_string(),
+            label: p.manifest.name.clone(),
+            hint: tr("Widget").to_string(),
+            tile: p.manifest.name.chars().next(),
+        });
+    }
+    None
+}
diff --git a/crates/ui-egui/src/menus/select_layer.rs b/crates/ui-egui/src/menus/select_layer.rs
new file mode 100644
index 00000000..59389c41
--- /dev/null
+++ b/crates/ui-egui/src/menus/select_layer.rs
@@ -0,0 +1,55 @@
+use super::tree::{indented_item, separator, submenu_at};
+use super::*;
+
+/// The context menu's Select layer submenu (its key in the context menu's tree).
+pub(super) const SELECT_LAYER: &str = "Select layer";
+
+/// Stable egui id for the context menu's pending Select-layer open request.
+pub(super) fn select_layer_ask_id() -> Id {
+    Id::unique("ctx_select_layer_ask")
+}
+
+/// Open (or close) the context menu's Select layer submenu (applied when the menu next draws).
+pub fn open_select_layer(ctx: &egui::Context, open: bool) {
+    ctx.data_mut(|d| d.insert_temp(select_layer_ask_id(), open));
+}
+
+/// The context menu's "Select layer" submenu (right-click on the canvas): every layer under the
+/// click, nested ones indented, the selected ones checked. Returns whether one was picked.
+pub(super) fn select_layer_menu(app: &mut FigApp, ui: &mut Ui, pos: egui::Pos2, t: &Tokens) -> bool {
+    if !app.canvas.rect.contains(pos) {
+        return false;
+    }
+    let p = app.to_page(pos);
+    let Ok(ds) = app.session.ds() else { return false };
+    let tol = 2.0 / ds.view.zoom.max(1e-6);
+    let layers: Vec<(figcraft_doc::NodeId, usize, String)> =
+        figcraft_doc::geometry::layers_at(&ds.doc, ds.page, p, tol, Some(&figcraft_engine::booleans::result_outline(&ds.doc, &ds.selection)))
+            .into_iter()
+            .take(40)
+            .filter_map(|(id, depth)| {
+                ds.doc.node(id).map(|n| (id, depth, if n.name.is_empty() { n.kind.type_name().to_lowercase() } else { n.name.clone() }))
+            })
+            .collect();
+    if layers.is_empty() {
+        return false;
+    }
+    let sel = ds.selection.clone();
+    let picked = submenu_at(ui, Id::unique("ctx_select_layer"), SELECT_LAYER, tr("Select layer"), 4.0, true, t, |ui| {
+        let mut picked = None;
+        for (id, depth, name) in &layers {
+            if indented_item(ui, name, "", true, sel.contains(id), 12.0 * (*depth).min(8) as f32, t) {
+                picked = Some(*id);
+            }
+        }
+        picked
+    });
+    separator(ui);
+    match picked {
+        Some(id) => {
+            app.run("select.set", json!({"ids": [id]}));
+            true
+        }
+        None => false,
+    }
+}
diff --git a/crates/ui-egui/src/menus/tree.rs b/crates/ui-egui/src/menus/tree.rs
new file mode 100644
index 00000000..4f181b3f
--- /dev/null
+++ b/crates/ui-egui/src/menus/tree.rs
@@ -0,0 +1,384 @@
+use super::*;
+
+/// A submenu row `label` in the menu being drawn; while it's open, `add` draws its items beside
+/// it. `key` names the submenu (its menu path, unique in its menu tree). Returns what `add`
+/// returned.
+pub(crate) fn submenu<R>(ui: &mut Ui, key: &str, label: &str, t: &Tokens, add: impl FnOnce(&mut Ui) -> Option<R>) -> Option<R> {
+    submenu_at(ui, Id::unique(("submenu", key)), key, label, 4.0, false, t, add)
+}
+
+// ---------------------------------------------------------------------------------------------
+// Which submenu is open: hover intent with a safe triangle.
+//
+// Every menu tree (the main menu, the context menu) keeps, per level, which of its submenus is
+// open. Hovering another row closes the open submenu at once; resting on a submenu row for
+// `HOVER_DELAY` opens it (sweeping across rows doesn't flash every submenu on the way). Except while the
+// pointer is on its way from the open submenu's row to the submenu: while each move lands inside
+// the triangle between where it was and the submenu's near edge (it keeps getting nearer), rows
+// it crosses don't take over and the submenu's row stays highlighted. Resting (`AIM_REST`) or
+// turning away ends that, and the row under the pointer takes over. Leaving the menus keeps the
+// last submenu open.
+// Closing a menu tree forgets all of it, so it reopens with no submenu open.
+
+/// How long the pointer stays on a submenu row before its submenu opens.
+pub(crate) const HOVER_DELAY: f64 = 0.15;
+
+/// How long the pointer may rest inside the safe triangle before the row under it takes over.
+pub(crate) const AIM_REST: f64 = 0.3;
+
+/// A pointer that moved less than this is resting.
+const AIM_STILL: f32 = 1.0;
+
+/// The triangle reaches this far above and below the submenu.
+const AIM_EDGE_SLOP: f32 = 8.0;
+
+/// The hover state of one menu level.
+#[derive(Clone, Default, Debug)]
+struct Level {
+    /// The open submenu's key.
+    open: Option<String>,
+    /// The open submenu's row and where its panel was drawn (last frame).
+    row: Option<Rect>,
+    panel: Option<Rect>,
+    /// The pointer's last position counted as heading for the panel, and when it got there.
+    apex: Option<egui::Pos2>,
+    moved_at: f64,
+    /// This pass's verdict: the pointer is aiming at the panel.
+    pass: Option<u64>,
+    aiming: bool,
+    /// The row the pointer is on, waiting to take over (a submenu's key, or `None`: a plain row),
+    /// and since when; whether a row asked this pass (unasked, it lapses).
+    pending: Option<(Option<String>, f64)>,
+    asked: bool,
+    /// When the pointer came to rest in the triangle, if that's what ended aiming this pass.
+    rested_at: Option<f64>,
+}
+
+/// One menu tree's levels, by menu path ("" for the top).
+#[derive(Clone, Default, Debug)]
+struct Tree {
+    levels: std::collections::HashMap<String, Level>,
+}
+
+/// The menu level a menu frame's ui draws: its tree's root and its path.
+#[derive(Clone, Debug)]
+pub(super) struct At {
+    pub(super) root: Id,
+    pub(super) path: String,
+}
+
+/// Scoped egui id for the current menu level.
+fn at_key(ui: &Ui) -> Id {
+    ui.scope_id().with("menu_level")
+}
+
+/// Return the current menu root/path, defaulting to the main menu root.
+fn level_at(ui: &Ui) -> At {
+    ui.data(|d| d.get_temp::<At>(at_key(ui))).unwrap_or(At { root: Id::unique("menus"), path: String::new() })
+}
+
+fn with_level<R>(ctx: &egui::Context, at: &At, f: impl FnOnce(&mut Level) -> R) -> R {
+    ctx.data_mut(|d| f(d.get_temp_mut_or_default::<Tree>(at.root).levels.entry(at.path.clone()).or_default()))
+}
+
+/// Forget everything a menu tree remembers (it closed or opened anew).
+pub(crate) fn forget_tree(ctx: &egui::Context, root: Id) {
+    ctx.data_mut(|d| d.remove::<Tree>(root));
+}
+
+/// Open (`Some(key)`) or close (`None`) a submenu of `root`'s level `path`; the levels below the
+/// one it replaces are forgotten (they reopen closed).
+pub(super) fn set_open(ctx: &egui::Context, root: Id, path: &str, key: Option<&str>) {
+    ctx.data_mut(|d| {
+        let tree = d.get_temp_mut_or_default::<Tree>(root);
+        let level = tree.levels.entry(path.to_string()).or_default();
+        if level.open.as_deref() == key {
+            return;
+        }
+        let old = std::mem::replace(&mut level.open, key.map(str::to_string));
+        level.row = None;
+        level.panel = None;
+        level.apex = None;
+        level.pending = None;
+        if let Some(old) = old {
+            let below = format!("{old}/");
+            tree.levels.retain(|p, _| *p != old && !p.starts_with(&below));
+        }
+    });
+}
+
+/// Whether `p` is in the triangle `a`, `b`, `c` (either winding, edges included).
+pub(crate) fn in_triangle(p: egui::Pos2, a: egui::Pos2, b: egui::Pos2, c: egui::Pos2) -> bool {
+    let side = |u: egui::Pos2, v: egui::Pos2| (v.x - u.x) * (p.y - u.y) - (v.y - u.y) * (p.x - u.x);
+    let (d1, d2, d3) = (side(a, b), side(b, c), side(c, a));
+    let neg = d1 < 0.0 || d2 < 0.0 || d3 < 0.0;
+    let pos = d1 > 0.0 || d2 > 0.0 || d3 > 0.0;
+    !(neg && pos)
+}
+
+/// Whether a pointer that moved from `from` to `p` is heading for `panel`: `p` is inside the
+/// triangle from `from` to the panel's near edge, so it got nearer the panel without leaving the
+/// rows' way to it. Straight up or down (or away) isn't.
+pub(crate) fn heading_for(from: egui::Pos2, p: egui::Pos2, panel: Rect) -> bool {
+    if ![from.x, from.y, p.x, p.y].iter().all(|v| v.is_finite()) {
+        return false;
+    }
+    let edge = if panel.min.x >= from.x {
+        panel.min.x
+    } else if panel.max.x <= from.x {
+        panel.max.x
+    } else {
+        return false;
+    };
+    in_triangle(p, from, pos2(edge, panel.min.y - AIM_EDGE_SLOP), pos2(edge, panel.max.y + AIM_EDGE_SLOP))
+}
+
+/// Whether the pointer is on its way to this level's open submenu (rows it crosses don't take
+/// over). Worked out once per pass per level.
+fn aiming(ui: &Ui) -> bool {
+    let at = level_at(ui);
+    let ctx = ui.ctx();
+    let pass = ctx.cumulative_pass_nr();
+    let (p, now) = ctx.input(|i| (i.pointer.hover_pos(), i.time));
+    let (aiming, wait) = with_level(ctx, &at, |l| {
+        if l.pass == Some(pass) {
+            return (l.aiming, None);
+        }
+        l.pass = Some(pass);
+        l.aiming = false;
+        l.rested_at = None;
+        if !l.asked {
+            l.pending = None;
+        }
+        l.asked = false;
+        let (Some(p), Some(_), Some(panel)) = (p, l.open.as_ref(), l.panel) else {
+            l.apex = None;
+            return (false, None);
+        };
+        if panel.contains(p) {
+            l.apex = None;
+            return (false, None);
+        }
+        // On the row (its bottom edge is the next row's).
+        if l.row.is_some_and(|r| (r.min.x..r.max.x).contains(&p.x) && (r.min.y..r.max.y).contains(&p.y)) {
+            l.apex = Some(p);
+            l.moved_at = now;
+            return (false, None);
+        }
+        let Some(from) = l.apex else { return (false, None) };
+        if (p - from).length() <= AIM_STILL {
+            // Resting: the submenu holds a moment longer.
+            if !(0.0..AIM_REST).contains(&(now - l.moved_at)) {
+                l.apex = None;
+                // It has rested long enough: the row under it needn't wait again.
+                l.rested_at = Some(l.moved_at);
+                return (false, None);
+            }
+        } else if heading_for(from, p, panel) {
+            l.apex = Some(p);
+            l.moved_at = now;
+        } else {
+            l.apex = None;
+            return (false, None);
+        }
+        l.aiming = true;
+        (true, Some(AIM_REST - (now - l.moved_at)))
+    });
+    // Wake up when the rest runs out, so the row under a still pointer takes over.
+    if let Some(w) = wait.filter(|w| w.is_finite() && *w > 0.0) {
+        ctx.request_repaint_after(std::time::Duration::from_secs_f64(w));
+    }
+    aiming
+}
+
+/// The pointer is on a row of level `at` (`target`: the row's submenu, or `None` for a plain
+/// row): another open submenu closes at once, and `target` opens once the pointer has stayed
+/// there `HOVER_DELAY`.
+fn hover_request(ctx: &egui::Context, at: &At, target: Option<&str>) {
+    let now = ctx.input(|i| i.time);
+    if with_level(ctx, at, |l| l.open.is_some() && l.open.as_deref() != target) {
+        set_open(ctx, at.root, &at.path, None);
+    }
+    let left = with_level(ctx, at, |l| {
+        l.asked = true;
+        if l.open.as_deref() == target {
+            l.pending = None;
+            return None;
+        }
+        let since = match &l.pending {
+            Some((t, since)) if t.as_deref() == target => *since,
+            _ => {
+                let since = l.rested_at.unwrap_or(now);
+                l.pending = Some((target.map(str::to_string), since));
+                since
+            }
+        };
+        Some(HOVER_DELAY - (now - since))
+    });
+    match left {
+        Some(left) if left <= 0.0 => set_open(ctx, at.root, &at.path, target),
+        // Wake up when it's due, so a still pointer gets there.
+        Some(left) => ctx.request_repaint_after(std::time::Duration::from_secs_f64(left.min(HOVER_DELAY))),
+        None => {}
+    }
+}
+
+/// Whether the pointer is on a row of level `at` other than the open submenu's (it shows as
+/// hovered instead).
+fn pending_elsewhere(ctx: &egui::Context, at: &At) -> bool {
+    with_level(ctx, at, |l| l.pending.as_ref().is_some_and(|(t, _)| *t != l.open))
+}
+
+/// A plain row of the level being drawn: hovering it (not while aiming at a submenu) closes the
+/// level's open submenu. Returns whether it shows as hovered.
+pub(super) fn plain_row_hover(ui: &Ui, resp: &egui::Response) -> bool {
+    let hovered = resp.hovered() && !aiming(ui);
+    if hovered {
+        hover_request(ui.ctx(), &level_at(ui), None);
+    }
+    hovered || resp.has_focus()
+}
+
+/// A submenu row whose panel (area `area`, `gap` right of the row) shows while it's open.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn submenu_at<R>(
+    ui: &mut Ui,
+    area: Id,
+    key: &str,
+    label: &str,
+    gap: f32,
+    constrain: bool,
+    t: &Tokens,
+    add: impl FnOnce(&mut Ui) -> Option<R>,
+) -> Option<R> {
+    let at = level_at(ui);
+    let aim = aiming(ui);
+    let w = ui.available_width();
+    let (r, resp) = ui.allocate_exact_size(vec2(w, 28.0), Sense::click());
+    // The keyboard and clicks open it at once; hovering after a moment.
+    if resp.has_focus() || resp.clicked() {
+        set_open(ui.ctx(), at.root, &at.path, Some(key));
+    } else if resp.hovered() && !aim {
+        hover_request(ui.ctx(), &at, Some(key));
+    }
+    let open = with_level(ui.ctx(), &at, |l| {
+        let open = l.open.as_deref() == Some(key);
+        if open {
+            l.row = Some(r);
+        }
+        open
+    });
+    a11y::submenu(&resp, label, open);
+    a11y::own_focus(&resp);
+    // The open submenu's row stays highlighted while the pointer is in the submenu (not while it
+    // rests on another row of this menu).
+    let keep = open && !pending_elsewhere(ui.ctx(), &at);
+    paint_submenu_row(ui, r, label, keep || (resp.hovered() && !aim) || resp.has_focus(), t);
+    if !open {
+        return None;
+    }
+    let mut pos = pos2(r.max.x + gap, r.min.y - 8.0);
+    // No room beside the row (a phone): the submenu covers its parent instead of running off screen.
+    let screen = ui.ctx().content_rect();
+    let cramped = pos.x + MENU_W > screen.max.x;
+    if cramped {
+        pos.x = (screen.max.x - MENU_W - 8.0).max(screen.min.x + 4.0);
+    }
+    let child = At { root: at.root, path: key.to_string() };
+    let shown = egui::Area::new(area)
+        .fixed_pos(pos)
+        .order(egui::Order::Foreground)
+        .constrain(constrain || cramped)
+        .show(ui.ctx(), |ui| menu_frame(ui, t, child, add));
+    let panel = shown.response.rect;
+    with_level(ui.ctx(), &at, |l| l.panel = Some(panel));
+    shown.inner
+}
+
+/// A thin line between groups of menu items.
+pub(crate) fn separator(ui: &mut Ui) {
+    ui.add_space(4.0);
+    let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), 1.0), Sense::hover());
+    ui.painter().line_segment([r.left_center(), r.right_center()], Stroke::new(1.0, Color32::from_white_alpha(30)));
+    ui.add_space(4.0);
+}
+
+/// A menu panel drawing menu level `at`.
+pub(super) fn menu_frame<R>(ui: &mut Ui, t: &Tokens, at: At, add: impl FnOnce(&mut Ui) -> R) -> R {
+    egui::Frame::NONE
+        .fill(t.menu)
+        .corner_radius(CornerRadius::same(13))
+        .inner_margin(egui::Margin::same(8))
+        .shadow(egui::Shadow { offset: [0, 4], blur: 16, spread: 0, color: Color32::from_black_alpha(60) })
+        .show(ui, |ui| {
+            // As wide as its widest row asked for (labels run longer in some languages).
+            let w = ui.data(|d| d.get_temp::<f32>(width_key(ui))).unwrap_or(0.0).max(MENU_W);
+            ui.set_width(w);
+            ui.spacing_mut().item_spacing = vec2(0.0, 0.0);
+            let key = at_key(ui);
+            ui.data_mut(|d| d.insert_temp(key, at));
+            add(ui)
+        })
+        .inner
+}
+
+/// A menu's narrowest width.
+const MENU_W: f32 = 240.0;
+
+/// Where a menu remembers the width its rows need (its frame's ui), per language.
+fn width_key(ui: &Ui) -> Id {
+    ui.scope_id().with(("menu_w", i18n::current().map(|l| l.code)))
+}
+
+/// A row needs `w`: the menu widens to it from the next frame on.
+fn need_width(ui: &Ui, w: f32) {
+    let key = width_key(ui);
+    if ui.data(|d| d.get_temp::<f32>(key)).unwrap_or(0.0) < w {
+        ui.data_mut(|d| d.insert_temp(key, w));
+        ui.ctx().request_repaint();
+    }
+}
+
+pub(crate) fn item(ui: &mut Ui, label: &str, shortcut: &str, enabled: bool, checked: bool, t: &Tokens) -> bool {
+    indented_item(ui, label, shortcut, enabled, checked, 0.0, t)
+}
+
+/// A menu row whose label starts `indent` pixels further in (nested layers).
+pub(super) fn indented_item(ui: &mut Ui, label: &str, shortcut: &str, enabled: bool, checked: bool, indent: f32, t: &Tokens) -> bool {
+    let w = ui.available_width();
+    let (r, resp) = ui.allocate_exact_size(vec2(w, 28.0), Sense::click());
+    a11y::menu_item(&resp, label, shortcut, checked.then_some(true));
+    if !enabled {
+        a11y::disabled(&resp);
+    }
+    // The keyboard's item is highlighted like the hovered one.
+    a11y::own_focus(&resp);
+    let hov = plain_row_hover(ui, &resp) && enabled;
+    if hov {
+        ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
+    }
+    let col = if enabled { t.menu_text } else { t.menu_dim };
+    if checked {
+        icons::paint(ui.painter(), Rect::from_center_size(pos2(r.min.x + 12.0, r.center().y), vec2(12.0, 12.0)), Icon::Check, col);
+    }
+    let galley = ui.painter().layout_no_wrap(label.to_string(), regular(12.0), col);
+    let keys = (!shortcut.is_empty())
+        .then(|| ui.painter().layout_no_wrap(pretty_shortcut(shortcut), regular(12.0), if hov { t.menu_text } else { t.menu_dim }));
+    need_width(ui, 28.0 + indent + galley.size().x + keys.as_ref().map_or(8.0, |k| 16.0 + k.size().x + 10.0));
+    let text_rect = Rect::from_min_max(pos2(r.min.x + 28.0 + indent, r.min.y), pos2(r.max.x - 8.0, r.max.y));
+    ui.painter().with_clip_rect(text_rect).galley(pos2(text_rect.min.x, r.center().y - galley.size().y / 2.0), galley, col);
+    if let Some(k) = keys {
+        ui.painter().galley(pos2(r.max.x - 10.0 - k.size().x, r.center().y - k.size().y / 2.0), k, col);
+    }
+    resp.clicked()
+}
+
+fn paint_submenu_row(ui: &mut Ui, r: Rect, label: &str, highlight: bool, t: &Tokens) {
+    if highlight {
+        ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
+    }
+    let galley = ui.painter().layout_no_wrap(label.to_string(), regular(12.0), t.menu_text);
+    need_width(ui, 28.0 + galley.size().x + 28.0);
+    ui.painter().galley(pos2(r.min.x + 28.0, r.center().y - galley.size().y / 2.0), galley, t.menu_text);
+    icons::paint(ui.painter(), Rect::from_center_size(pos2(r.max.x - 12.0, r.center().y), vec2(12.0, 12.0)), Icon::ChevronRight, t.menu_text);
+}

From 2fded280289549c1447fe70a80b9c02d4e448a4f Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:56:10 +0000
Subject: [PATCH 40/67] refactor(ui-egui): split lib.rs into app.rs,
 services.rs, state.rs, clock.rs and open.rs

---
 crates/ui-egui/src/app.rs      | 1345 +++++++++++++++++++++++++
 crates/ui-egui/src/clock.rs    |   63 ++
 crates/ui-egui/src/lib.rs      | 1679 +-------------------------------
 crates/ui-egui/src/open.rs     |   56 ++
 crates/ui-egui/src/services.rs |  159 +++
 crates/ui-egui/src/state.rs    |   65 ++
 6 files changed, 1701 insertions(+), 1666 deletions(-)
 create mode 100644 crates/ui-egui/src/app.rs
 create mode 100644 crates/ui-egui/src/clock.rs
 create mode 100644 crates/ui-egui/src/open.rs
 create mode 100644 crates/ui-egui/src/services.rs
 create mode 100644 crates/ui-egui/src/state.rs

diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
new file mode 100644
index 00000000..da975074
--- /dev/null
+++ b/crates/ui-egui/src/app.rs
@@ -0,0 +1,1345 @@
+use super::clock::{AUTO_SAVE_RETRY_SECS, AUTO_SAVE_SECS, AUTOSAVE_SECS, CJK_CHANGES, FrameClock, TOAST_SECS, ToastClock, repaint_in};
+use super::open::OPEN_EXTENSIONS;
+use super::services::{DialogFuture, PickFuture, Picked, RepaintWaker, Services};
+use super::state::{LEFT_PANEL, LeftTab, MOBILE_STRIP, MobilePanel, NARROW_WIDTH, PANEL_DEFAULT, RIGHT_PANEL, RightTab, TitleBar, fit_panels};
+use super::*;
+
+impl FigApp {
+    /// Construct `FigApp` from a session and services, taking panel widths and pages height
+    /// from preferences and initializing UI, canvas, clocks, capture/IME and transient channel
+    /// state.
+    pub fn new(session: Session, services: Box<dyn Services>) -> Self {
+        // The main window's panels open as wide as they were left.
+        let (left_width, right_width) = session.prefs.panel_widths;
+        let pages_height = session.prefs.pages_height;
+        Self {
+            ui: UiState { left_width, right_width, pages_height, ..UiState::default() },
+            session,
+            canvas: canvas::CanvasState::default(),
+            services,
+            worker: None,
+            fonts_installed: false,
+            script_fonts: None,
+            cjk_checked: None,
+            language: None,
+            field_focus: false,
+            panels_unsaved: false,
+            control_queue: Vec::new(),
+            control_input: Vec::new(),
+            frame_stats: frame_stats::FrameStats::default(),
+            windows: windows::Windows::default(),
+            window_requests: Vec::new(),
+            waiting: Vec::new(),
+            pending_dialog: None,
+            ui_context: None,
+            automation_roots: None,
+            control_input_doc: None,
+            control_synthetic: false,
+            input_acks: Vec::new(),
+            applied_acks: Vec::new(),
+            applied_input: None,
+            control_input_queued: false,
+            applied_frame: None,
+            clock: FrameClock::default(),
+            capture: control::CaptureState::default(),
+            logic_ticked: false,
+            ui_frame_stamp: None,
+            ime: egui::ime_context::ImeContextTracker::new(),
+            updates_rt: updates_ui::Runtime::default(),
+            #[cfg(test)]
+            ime_observations: 0,
+        }
+    }
+
+    /// Dismiss the composer after a successful switch away from the Comment tool.
+    pub(crate) fn clear_comment_draft_after_tool_set(&mut self, id: &str, succeeded: bool) {
+        if id == "tool.set" && succeeded && self.session.tool.tool != figcraft_engine::tools::ToolId::Comment {
+            self.ui.comments.draft = None;
+        }
+    }
+
+    /// Run a command, surfacing errors as a toast. Returns the result.
+    pub fn run(&mut self, id: &str, params: Value) -> Option<Value> {
+        let layers_generation = self.session.clipboard.layers_generation;
+        let r = self.session.execute(id, &params);
+        self.clear_comment_draft_after_tool_set(id, r.is_ok());
+        self.handle_ui_requests();
+        self.invalidate_synthetic_copy(layers_generation);
+        // A command may change the file the window shows (`doc.switch`, `doc.nextTab`,
+        // `file.open`/`file.close`). Record that presentation before returning, so an in-flight
+        // screenshot admitted on the old file cannot accept pixels from the new one.
+        self.observe_presentation();
+        r.map_err(|e| self.failed(id, &e)).ok()
+    }
+
+    /// A programmatic command that changed the engine clipboard never wrote the system clipboard:
+    /// forget the old system mirror so a later user paste does not trust it as our own copy.
+    /// `before` is the layers generation captured before the command ran.
+    pub(crate) fn invalidate_synthetic_copy(&mut self, before: u64) {
+        if self.control_synthetic && self.session.clipboard.layers_generation != before {
+            self.ui.last_copy = None;
+        }
+    }
+
+    /// Record the file the window drawing now shows, with a monotonic generation that changes on
+    /// every switch (an A→B→A switch is two generations, never the admitted one again).
+    pub(crate) fn observe_presentation(&mut self) {
+        let window = self.windows.current;
+        self.windows.presentation(&self.session, window);
+    }
+
+    /// [`run`](Self::run) for something the user did (a dialog, a drop, a paste, a recent file):
+    /// a file it imports shows its import report. Programmatic calls use `run` and never open one.
+    pub fn run_user(&mut self, id: &str, params: Value) -> Option<Value> {
+        let result = self.run(id, params.clone());
+        if let Some(result) = &result {
+            import_report::capture(self, id, &params, result);
+        }
+        missing_fonts::check_later(self, id, result.as_ref());
+        result
+    }
+
+    /// Show command `id`'s error.
+    pub(crate) fn failed(&mut self, id: &str, e: &figcraft_engine::EngineError) {
+        let msg = e.to_string();
+        log::warn!("{id}: {msg}");
+        self.show_error(msg);
+    }
+
+    /// Show an error as a toast, kept as the last error.
+    pub(crate) fn show_error(&mut self, msg: String) {
+        self.toast(msg.clone());
+        self.ui.last_error = Some(msg);
+    }
+
+    /// Run a command that may talk to a server without waiting for it (the engine's
+    /// [`start_background`](Session::start_background)): `done` gets the result, at once or when
+    /// the answer arrives (the network wakes the window then); errors show as with [`run`](Self::run).
+    /// [`Session::waiting_for`] tells the panels to show that it's on its way.
+    pub fn run_background(&mut self, ctx: &egui::Context, id: &str, params: Value, done: Done) {
+        self.waiting.retain(|(c, _)| c != id);
+        let r = self.session.start_background(id, params);
+        self.handle_ui_requests();
+        match r {
+            Ok(Some(v)) => done(self, ctx, v),
+            Ok(None) => self.waiting.push((id.to_string(), done)),
+            Err(e) => self.failed(id, &e),
+        }
+    }
+
+    /// Stop waiting for command `id` (Cancel, or its window closed): its answer is dropped.
+    pub fn cancel_background(&mut self, id: &str) {
+        self.session.cancel_background(id);
+        self.waiting.retain(|(c, _)| c != id);
+    }
+
+    /// Hand the results of background commands that finished to what's waiting for them.
+    fn background_done(&mut self, ctx: &egui::Context) {
+        while let Some((id, r)) = self.session.take_background_done() {
+            self.handle_ui_requests();
+            let done = self.waiting.iter().position(|(c, _)| *c == id).map(|i| self.waiting.remove(i).1);
+            match (r, done) {
+                (Ok(v), Some(done)) => done(self, ctx, v),
+                (Ok(_), None) => {}
+                (Err(e), _) => self.failed(&id, &e),
+            }
+        }
+    }
+
+    /// Show what `command params` would do on the canvas as a live preview (`text.preview`) while
+    /// a font family, font style, text style, named instance or axis slider is hovered or dragged. Call it every frame
+    /// the preview should stay: it ends on the first frame nothing asks for it.
+    pub fn preview_text(&mut self, ctx: &egui::Context, command: &str, params: Value) {
+        self.ui.text_preview_wanted = true;
+        let revision = self.session.ds().map_or(0, |d| d.revision);
+        if let Some((c, p, rev)) = &self.ui.text_preview
+            && c == command
+            && *p == params
+            && (*rev == revision || figcraft_engine::textpreview::active(&self.session))
+        {
+            return;
+        }
+        let shown = self.session.execute("text.preview", &json!({"command": command, "params": params})).is_ok();
+        let revision = self.session.ds().map_or(0, |d| d.revision);
+        self.ui.text_preview = shown.then(|| (command.to_string(), params, revision));
+        // The canvas drew before the panels: show the preview next frame.
+        ctx.request_repaint();
+    }
+
+    /// End the live text preview the panels show (Escape, or nothing hovered any more).
+    pub fn end_text_preview(&mut self, ctx: &egui::Context) {
+        if self.ui.text_preview.take().is_some() {
+            let _ = self.session.execute("text.endPreview", &json!({}));
+            ctx.request_repaint();
+        }
+    }
+
+    /// Dev Mode (the Inspect tab): the canvas measures on hover without Alt and edits nothing;
+    /// entering it ends editing text or vectors.
+    fn sync_dev_mode(&mut self) {
+        let dev = self.ui.right_tab == RightTab::Inspect;
+        if dev && !self.session.tool.dev_mode {
+            let _ = self.session.drop_gesture();
+            let editing = self.session.ds().map(|d| (d.text_edit.is_some(), d.vector_edit.is_some())).unwrap_or_default();
+            for (on, cmd) in [(editing.0, "text.edit.end"), (editing.1, "vector.edit.end")] {
+                if on {
+                    self.run(cmd, json!({}));
+                }
+            }
+        }
+        self.session.tool.dev_mode = dev;
+    }
+
+    /// Leaving Design ends a pen path as Escape does and goes back to Move: Prototype and Inspect
+    /// don't draw (#307). Checked as the frame starts (the control channel) and after the panels
+    /// and shortcuts (the mode switcher, the tabs, Shift+E/Shift+D), before the canvas sees more.
+    fn end_pen_outside_design(&mut self) {
+        if self.ui.right_tab == self.ui.last_right_tab {
+            return;
+        }
+        self.ui.last_right_tab = self.ui.right_tab;
+        if self.ui.right_tab != RightTab::Design && self.session.tool.tool == figcraft_engine::tools::ToolId::Pen {
+            self.run("tool.set", json!({"tool": "move"}));
+        }
+    }
+
+    /// Once a frame, after the panels: a preview nothing asked for this frame ends.
+    fn end_unwanted_text_preview(&mut self, ctx: &egui::Context) {
+        if !std::mem::take(&mut self.ui.text_preview_wanted) {
+            self.end_text_preview(ctx);
+        }
+    }
+
+    /// Finish the frame that applies an injected batch: acknowledge it once the pass is presented,
+    /// and stop fencing the system clipboard. Only the viewport whose batch this frame took acts.
+    pub(crate) fn end_input_frame(&mut self, ctx: &egui::Context) {
+        if self.applied_frame != Some(ctx.viewport_id()) {
+            return;
+        }
+        self.applied_input = None;
+        if ctx.will_discard() {
+            // Keep `applied_frame`/`applied_acks`: the rerun pass must present (and acknowledge)
+            // the same frame without replaying the input.
+            return;
+        }
+        self.applied_frame = None;
+        for ack in self.applied_acks.drain(..) {
+            let _ = ack.tx.send(ack.reply);
+        }
+        self.control_synthetic = false;
+    }
+
+    /// The app's monotonic clock in seconds, also usable from logic-only callbacks (recovery,
+    /// control deadlines). Never `ctx.input(i.time)`, which is stale there.
+    pub fn now_secs(&self) -> f64 {
+        self.clock.now()
+    }
+
+    /// Queue raw input injected through the control channel for the window drawing next, tagged
+    /// with the document it belongs to (a batch is dropped if another file is active by then).
+    pub(crate) fn push_control_input(&mut self, events: Vec<egui::Event>) -> bool {
+        if events.is_empty() {
+            return false;
+        }
+        let doc = self.session.docs.get(self.session.active).map(|d| d.uid);
+        if !self.control_input.is_empty() && self.control_input_doc != doc {
+            // A queued batch belongs to the file that was open when it was injected; it cannot be
+            // merged with one for the file showing now. Its acknowledgement says so.
+            self.control_input.clear();
+            let viewport = crate::windows::viewport(self.windows.current);
+            crate::windows::fail_input_acks(self, viewport);
+        }
+        // Always the live pane vector: while a child window draws, `windows::enter` has swapped
+        // its pane into the app, and `leave` swaps these events back into that pane.
+        self.control_input.extend(events);
+        self.control_input_doc = doc;
+        self.control_synthetic = true;
+        true
+    }
+
+    /// The acknowledgements waiting for `viewport`'s input batch (other windows keep theirs).
+    pub(crate) fn take_input_acks(&mut self, viewport: egui::ViewportId) -> Vec<PendingAck> {
+        let mut mine = Vec::new();
+        for ack in std::mem::take(&mut self.input_acks) {
+            if ack.viewport == viewport {
+                mine.push(ack);
+            } else {
+                self.input_acks.push(ack);
+            }
+        }
+        mine
+    }
+
+    /// Put `text` on the system clipboard. Input injected through the control channel never
+    /// replaces what the user copied: this is the one write path every copy command goes through.
+    pub(crate) fn clipboard_set_text(&mut self, text: &str) {
+        if self.control_synthetic {
+            return;
+        }
+        self.services.clipboard_set_text(text);
+    }
+
+    /// [`Self::clipboard_set_text`] for an image (straight RGBA).
+    pub(crate) fn clipboard_set_png(&mut self, width: u32, height: u32, rgba: &[u8]) {
+        if self.control_synthetic {
+            return;
+        }
+        self.services.clipboard_set_png(width, height, rgba);
+    }
+
+    pub fn toast(&mut self, msg: impl Into<String>) {
+        self.ui.toast = Some((msg.into(), ToastClock::Raised));
+    }
+
+    /// Say that `n` documents left unsaved by a crash were opened again from recovery copies.
+    pub fn note_recovered(&mut self, n: usize) {
+        if n > 0 {
+            self.toast(i18n::trn("Recovered {n} unsaved files after the app quit unexpectedly: save them to keep them", n, &[]));
+        }
+    }
+
+    /// Act on UI requests queued by commands (dialogs, panels).
+    pub fn handle_ui_requests(&mut self) {
+        let reqs = std::mem::take(&mut self.session.ui_requests);
+        for r in reqs {
+            match r.kind.as_str() {
+                "dialog.about" => {
+                    self.ui.about = true;
+                    self.ui.about_tab = dialogs::AboutTab::About;
+                }
+                "dialog.preferences" => self.ui.preferences = true,
+                "dialog.missingFonts" => missing_fonts::request(self),
+                "panel.shortcuts" => self.ui.shortcuts_panel = !self.ui.shortcuts_panel,
+                "palette.actions" => menus::toggle_palette(&mut self.ui),
+                "panel.design" if self.session.doc().is_ok_and(figcraft_engine::board::is_board) => self.ui.board_panel = !self.ui.board_panel,
+                "panel.design" => self.ui.right_tab = RightTab::Design,
+                "board.editText" => {
+                    if let Some(id) = r.data.get("id").and_then(figcraft_engine::params::id_of)
+                        && let Err(e) = figcraft_engine::board::edit_text(&mut self.session, id)
+                    {
+                        self.toast(e.to_string());
+                    }
+                }
+                "panel.prototype" => self.ui.right_tab = RightTab::Prototype,
+                "panel.designPrototype" => {
+                    self.ui.right_tab = if self.ui.right_tab == RightTab::Prototype { RightTab::Design } else { RightTab::Prototype };
+                }
+                "panel.devMode" => {
+                    self.ui.right_tab = if self.ui.right_tab == RightTab::Inspect { RightTab::Design } else { RightTab::Inspect };
+                }
+                "panel.leftSidebar" => {
+                    let shown = if self.ui.narrow { self.ui.mobile_panel == Some(MobilePanel::Left) } else { !self.ui.left_collapsed };
+                    if shown {
+                        self.ui.close_left_panel();
+                    } else {
+                        self.ui.open_left_panel();
+                    }
+                }
+                "panel.widths" => {
+                    let width = |k: &str| r.data.get(k).and_then(Value::as_f64).map(|w| w as f32);
+                    let (left, right) = (width("left"), width("right"));
+                    let reset = left.is_none() && right.is_none();
+                    self.set_panel_widths(
+                        left.unwrap_or(if reset { PANEL_DEFAULT } else { self.ui.left_width }),
+                        right.unwrap_or(if reset { PANEL_DEFAULT } else { self.ui.right_width }),
+                    );
+                    self.services.save_prefs(&self.session.prefs);
+                }
+                "focus.region" => self.ui.nav.step(r.data.get("step").and_then(Value::as_i64).unwrap_or(1).clamp(-4, 4) as i32),
+                "panel.layers" => self.ui.left_tab = LeftTab::File,
+                "panel.assets" => {
+                    self.ui.left_tab = LeftTab::Assets;
+                    self.ui.open_left_panel();
+                    self.ui.versions = Default::default();
+                }
+                "panel.versionHistory" => versions::open(self),
+                "view.devCompare" => {
+                    self.ui.dev.compare = dev_compare::CompareView::requested(&r.data);
+                }
+                "panel.libraries" => {
+                    self.ui.left_tab = LeftTab::Assets;
+                    self.ui.open_left_panel();
+                    self.ui.libraries = true;
+                }
+                "home" => self.ui.home = true,
+                "home.templates" => {
+                    self.ui.home = true;
+                    self.ui.home_view.section = home::Section::Templates;
+                }
+                "home.gettingStarted" => {
+                    self.ui.home = true;
+                    self.ui.home_view.section = home::Section::Recents;
+                    self.services.save_prefs(&self.session.prefs);
+                }
+                "dialog.saveAs" => self.save_as_dialog(),
+                "dialog.colorProfile" => self.ui.color_profile = self.session.doc().ok().map(|d| d.color_profile),
+                "present" => {
+                    if let Some(start) = r.data.get("start").and_then(figcraft_engine::params::id_of) {
+                        tabs::open_present(self, start);
+                    }
+                }
+                "present.options" => {
+                    let v = &mut self.ui.present_view;
+                    if let Some(s) = r.data.get("scale").and_then(|s| s.as_str()).and_then(present::PresentScale::parse) {
+                        v.scale = s;
+                    }
+                    if let Some(f) = r.data.get("deviceFrame").and_then(|f| f.as_bool()) {
+                        v.device_frame = f;
+                    }
+                    if let Some(h) = r.data.get("hotspotHints").and_then(|h| h.as_bool()) {
+                        v.hotspot_hints = h;
+                    }
+                    if let Some(i) = r.data.get("inspect").and_then(|i| i.as_bool()) {
+                        v.inspect = i;
+                    }
+                    if let Some(p) = self.ui.present.as_mut() {
+                        p.view.device_frame = v.device_frame;
+                        p.view.hotspot_hints = v.hotspot_hints;
+                        p.view.inspect = v.inspect;
+                        p.set_scale(v.scale);
+                    }
+                }
+                "preview" => {
+                    if let Some(start) = r.data.get("start").and_then(figcraft_engine::params::id_of) {
+                        self.ui.preview = Some(present::Pane::new(start, &self.session));
+                    }
+                }
+                "preview.close" => self.ui.preview = None,
+                "open.help" => self.services.open_url("https://getartcraft.com/apps/figcraft"),
+                "layers.collapseAll" => layers::collapse_all(self),
+                "contextMenu" => self.ui.key_menu = true,
+                "selectArea" => self.start_key_box(),
+                "canvas.renameLabel" => {
+                    self.ui.rename_label = r.data.get("id").and_then(figcraft_engine::params::id_of).map(|id| layers::Rename { id, start: true });
+                }
+                "layers.rename" => {
+                    let ids: Vec<NodeId> =
+                        r.data.get("ids").and_then(Value::as_array).into_iter().flatten().filter_map(figcraft_engine::params::id_of).collect();
+                    if ids.len() > 1 {
+                        dialogs::open_batch_rename(self, &ids);
+                    } else {
+                        layers::start_rename(self, &ids);
+                    }
+                }
+                "comment.open" => {
+                    if let Some(id) = r.data.get("id").and_then(Value::as_u64) {
+                        self.ui.comments.show(id);
+                    }
+                }
+                "comment.new" => {
+                    let x = r.data.get("x").and_then(|v| v.as_f64()).unwrap_or(0.0);
+                    let y = r.data.get("y").and_then(|v| v.as_f64()).unwrap_or(0.0);
+                    comments::start_draft(self, x, y);
+                }
+                "dialog.unsaved" => self.toast(i18n::tr("This file has unsaved changes")),
+                "dialog.plugins" => self.ui.plugins_window = true,
+                "dialog.pluginSave" => plugins_ui::save_file(self, &r.data),
+                "dialog.cursorChat" => live::open_chat(self),
+                "window.new" | "window.focus" | "window.fullscreen" => self.window_requests.push(r),
+                _ => {}
+            }
+        }
+        if let Some(m) = self.session.message.take() {
+            self.toast(m);
+        }
+    }
+
+    /// Set the widths asked for this window's side panels (within their limits); the main
+    /// window's are kept in the preferences.
+    pub fn set_panel_widths(&mut self, left: f32, right: f32) {
+        let within = |w: f32, range: std::ops::RangeInclusive<f32>| if w.is_finite() { w.clamp(*range.start(), *range.end()) } else { PANEL_DEFAULT };
+        (self.ui.left_width, self.ui.right_width) = (within(left, LEFT_PANEL), within(right, RIGHT_PANEL));
+        if self.windows.current == 0 {
+            self.session.prefs.panel_widths = (self.ui.left_width, self.ui.right_width);
+        }
+    }
+
+    /// The edge between a side panel and the canvas, at `x` down `rows`: dragging it sizes the
+    /// panel (`grows`: +1 for the left panel, whose edge is on its right, −1 for the right one), a
+    /// double-click puts back the default width. Returns the width asked for, when it changed.
+    fn panel_edge(ui: &mut egui::Ui, name: &str, x: f32, rows: egui::Rangef, width: f32, grows: f32) -> Option<f32> {
+        let grab = ui.style().interaction.resize_grab_radius_side;
+        let rect = egui::Rect::from_x_y_ranges(x - grab..=x + grab, rows);
+        let id = egui::Id::unique(("panel_edge", name));
+        // Not focusable: an edge is a pointer target, so it must not take Tab/F6 focus from the
+        // panels' controls (see `a11y::focusables`).
+        let resp = ui.interact(rect, id, egui::Sense::CLICK | egui::Sense::DRAG);
+        if resp.hovered() || resp.dragged() {
+            ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
+            ui.painter().vline(x, rows, egui::Stroke::new(2.0, theme::ACCENT));
+        }
+        if resp.double_clicked() {
+            return Some(PANEL_DEFAULT);
+        }
+        // The edge stays under the pointer where it was grabbed (also back from past a limit).
+        let at = resp.interact_pointer_pos().filter(|_| resp.dragged())?;
+        if resp.drag_started() {
+            let pressed = ui.input(|i| i.pointer.press_origin()).unwrap_or(at);
+            ui.data_mut(|d| d.insert_temp(id, pressed.x - x));
+        }
+        let grabbed: f32 = ui.data(|d| d.get_temp(id)).unwrap_or(0.0);
+        let w = width + (at.x - grabbed - x) * grows;
+        (w != width).then_some(w)
+    }
+
+    pub fn save_as_dialog(&mut self) {
+        if self.services.downloads() {
+            if let Some(r) = self.run("file.saveAs", json!({"data": true}))
+                && self.download(r["name"].as_str().unwrap_or_default(), &r)
+            {
+                self.run("file.markSaved", json!({}));
+                dialogs::file_saved(self, &r);
+            }
+            return;
+        }
+        let Ok(name) = self.session.doc().map(|d| d.name.clone()) else { return };
+        self.pick_save(i18n::tr("Save as"), &format!("{name}.figcraft"), &["figcraft", "fig"], |app, mut p| {
+            if p.extension().is_none_or(OsStr::is_empty) {
+                if !p.set_extension("figcraft") {
+                    app.toast(i18n::tr("Use the .figcraft or .fig extension."));
+                    return;
+                }
+                // This name wasn't confirmed by the system dialog: don't replace an existing file.
+                match p.try_exists() {
+                    Ok(false) => {}
+                    Ok(true) => {
+                        app.toast(i18n::tr("A .figcraft file with this name already exists. Choose its full name to confirm replacement."));
+                        return;
+                    }
+                    Err(e) => {
+                        app.toast(e.to_string());
+                        return;
+                    }
+                }
+            } else if !p.extension().and_then(OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("figcraft") || e.eq_ignore_ascii_case("fig")) {
+                app.toast(i18n::tr("Use the .figcraft or .fig extension."));
+                return;
+            }
+            if let Some(r) = app.run("file.saveAs", json!({"path": p.to_string_lossy()})) {
+                dialogs::file_saved(app, &r);
+            }
+        });
+    }
+
+    pub fn save(&mut self) {
+        // A branch tab saves its main file.
+        let tab = figcraft_engine::branches::file_tab(&self.session);
+        // A path ending in .fig is never saved over silently: a .fig destination is an export copy.
+        let native_path = self
+            .session
+            .docs
+            .get(tab)
+            .and_then(|d| d.path.as_deref())
+            .is_some_and(|path| !Path::new(path).extension().and_then(OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("fig")));
+        if native_path {
+            if self.run("file.save", json!({})).is_some() {
+                self.toast(i18n::tr("Saved"));
+            }
+        } else {
+            self.save_as_dialog();
+        }
+    }
+
+    pub fn open_dialog(&mut self) {
+        // Opening needs no file in front: it goes ahead even if that file closed meanwhile.
+        self.pick_file(i18n::tr("Open"), OPEN_EXTENSIONS, false, |app, file| {
+            if app.run_user("file.open", file).is_some() {
+                app.ui.home = false;
+            }
+        });
+    }
+
+    pub fn import_dialog(&mut self, place: bool) {
+        let exts: &[&str] = if place {
+            &["png", "jpg", "jpeg", "webp", "gif", "tif", "tiff"]
+        } else {
+            &["svg", "png", "jpg", "jpeg", "webp", "gif", "tif", "tiff", "figcraft", "fig", "sketch"]
+        };
+        let title = if place { i18n::tr("Place image") } else { i18n::tr("Import") };
+        self.pick_file(title, exts, true, |app, file| {
+            app.run_user("file.import", file);
+        });
+    }
+
+    /// Pick a file to open or import; `done` gets it as `file.open` and `file.import` take it (a
+    /// path, or the name and contents where the platform has no paths). `pin`: as
+    /// [`FigApp::pick_open`]'s file in front.
+    fn pick_file(&mut self, title: &str, exts: &[&str], pin: bool, done: impl FnOnce(&mut FigApp, Value) + 'static) {
+        self.start_pick(
+            |services| -> PickFuture {
+                match services.pick_open_contents(title, exts) {
+                    Some(read) => {
+                        Box::pin(async move { read.await.map(|r| r.map_or_else(Picked::Unreadable, |(name, bytes)| Picked::Contents(name, bytes))) })
+                    }
+                    None => {
+                        let pick = services.pick_open(title, exts);
+                        Box::pin(async move { pick.await.map(Picked::Path) })
+                    }
+                }
+            },
+            pin,
+            move |app, picked| match picked.file_params() {
+                Ok(file) => done(app, file),
+                Err(why) => app.show_error(why),
+            },
+        );
+    }
+
+    /// Pick a file to open. `done` runs with the file in front now back in front (and not at all
+    /// if that file closed meanwhile).
+    pub fn pick_open(&mut self, title: &str, exts: &[&str], done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
+        self.start_dialog(|services| services.pick_open(title, exts), true, done);
+    }
+
+    /// Pick where to save; `done` runs as [`FigApp::pick_open`]'s does.
+    pub fn pick_save(&mut self, title: &str, name: &str, exts: &[&str], done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
+        self.start_dialog(|services| services.pick_save(title, name, exts), true, done);
+    }
+
+    /// Hand a command result's base64 `data` over as a download named `name`, where the platform
+    /// saves by downloads rather than save dialogs (the browser, #969). Says so when nothing arrived.
+    pub(crate) fn download(&mut self, name: &str, result: &Value) -> bool {
+        use base64::Engine as _;
+        let bytes = result["data"].as_str().and_then(|d| base64::engine::general_purpose::STANDARD.decode(d).ok());
+        if bytes.is_some_and(|b| self.services.download(name, &b)) {
+            return true;
+        }
+        self.toast(i18n::trf("Couldn't download {name}", &[("name", &name)]));
+        false
+    }
+
+    /// Pick a folder; `done` runs as [`FigApp::pick_open`]'s does.
+    pub fn pick_folder(&mut self, title: &str, done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
+        self.start_dialog(|services| services.pick_folder(title), true, done);
+    }
+
+    /// Open a native dialog from the window drawing now, for the file in front (`pin`).
+    fn start_dialog(&mut self, start: impl FnOnce(&mut dyn Services) -> DialogFuture, pin: bool, done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
+        self.start_pick(
+            |services| -> PickFuture {
+                let pick = start(services);
+                Box::pin(async move { pick.await.map(Picked::Path) })
+            },
+            pin,
+            move |app, picked| {
+                if let Picked::Path(p) = picked {
+                    done(app, p);
+                }
+            },
+        );
+    }
+
+    /// [`FigApp::start_dialog`] for any kind of pick.
+    fn start_pick(&mut self, start: impl FnOnce(&mut dyn Services) -> PickFuture, pin: bool, done: impl FnOnce(&mut FigApp, Picked) + 'static) {
+        if self.pending_dialog.is_some() {
+            return;
+        }
+        let doc = if pin { self.session.ds().ok().filter(|d| self.shows(d.uid)).map(|d| d.uid) } else { None };
+        let future = start(self.services.as_mut());
+        self.pending_dialog = Some(PendingDialog { future, picked: None, done: Box::new(done), doc, window: self.windows.current });
+        if let Some(ctx) = &self.ui_context {
+            ctx.request_repaint();
+        }
+    }
+
+    /// Once the dialog has a path, its continuation runs in the window that holds its file, with
+    /// that file in front; then the tab in front before comes back (unless the dialog opened a file).
+    pub(crate) fn poll_dialog(&mut self, ctx: &egui::Context) {
+        let Some(d) = &mut self.pending_dialog else { return };
+        if d.picked.is_none() {
+            let waker = Waker::from(Arc::new(RepaintWaker(ctx.clone())));
+            let Poll::Ready(picked) = d.future.as_mut().poll(&mut TaskContext::from_waker(&waker)) else { return };
+            d.picked = picked;
+        }
+        let (doc, origin, picked) = (d.doc, d.window, d.picked.is_some());
+        let index = doc.map(|u| self.session.docs.iter().position(|ds| ds.uid == u));
+        // Cancelled, or its file closed meanwhile.
+        if !picked || index == Some(None) {
+            self.pending_dialog = None;
+            return;
+        }
+        let window = match doc {
+            Some(u) => self.windows.of(u),
+            None if self.windows.exists(origin) => origin,
+            None => 0,
+        };
+        if window != self.windows.current {
+            ctx.request_repaint_of(windows::viewport(window));
+            return;
+        }
+        let Some(PendingDialog { picked: Some(picked), done, .. }) = self.pending_dialog.take() else { return };
+        let before = self.session.ds().ok().map(|d| d.uid);
+        if let Some(Some(i)) = index {
+            self.session.active = i;
+        }
+        done(self, picked);
+        if doc.is_some()
+            && self.session.ds().ok().map(|d| d.uid) == doc
+            && let Some(i) = before.and_then(|u| self.session.docs.iter().position(|d| d.uid == u))
+        {
+            self.session.active = i;
+        }
+    }
+
+    /// Reduced motion: the preference or the system's setting.
+    pub fn reduce_motion(&self) -> bool {
+        self.session.prefs.reduce_motion || self.services.reduce_motion()
+    }
+
+    /// The CJK, Bengali and Thai scripts the UI shows: the language's, the language picker's (Preferences open),
+    /// typed text's, and those in the open file's names and comments (read when it changes, not
+    /// mid-drag). Nothing is checked once every script has a face.
+    pub(crate) fn cjk_needed(&mut self, ctx: &egui::Context, installed: u8) -> u8 {
+        if installed == cjk::ALL {
+            return installed;
+        }
+        let mut need = i18n::current().map_or(0, |l| cjk::language(l.code));
+        if self.ui.preferences {
+            need |= i18n::languages().iter().filter(|l| cjk::can_show(l.code)).fold(0, |m, l| m | cjk::language(l.code));
+        }
+        need |= ctx.input(|i| {
+            i.events.iter().fold(0, |m, e| match e {
+                egui::Event::Text(t) | egui::Event::Ime(egui::ImeEvent::Preedit { text: t, .. } | egui::ImeEvent::Commit(t)) => m | cjk::scripts(t),
+                _ => m,
+            })
+        });
+        let dragging = ctx.input(|i| i.pointer.any_down());
+        // Pans and zooms change the revision too: only a new version of the document is looked
+        // at, and only the layers it changed (a large file has hundreds of thousands of names).
+        let current = self.session.docs.get(self.session.active).filter(|_| !dragging).map(|d| (d.uid, d.doc.clone()));
+        if let Some((uid, doc)) = current {
+            let before = self.cjk_checked.take().filter(|(u, _)| *u == uid).map(|(_, b)| b);
+            if !before.as_ref().is_some_and(|b| Arc::ptr_eq(b, &doc)) {
+                let mut scan = |s: &str| need |= cjk::scripts(s);
+                scan(&doc.name);
+                match before.as_ref().and_then(|b| doc.changed_ids(b, CJK_CHANGES)) {
+                    Some(ids) => ids.into_iter().filter_map(|id| doc.node(id)).for_each(|n| scan(&n.name)),
+                    None => doc.nodes().for_each(|n| scan(&n.name)),
+                }
+                doc.comments.iter().flat_map(|c| std::iter::once(&c.first).chain(&c.replies)).for_each(|m| {
+                    scan(&m.author);
+                    scan(&m.text);
+                });
+            }
+            self.cjk_checked = Some((uid, doc));
+        }
+        need
+    }
+
+    /// Work safe from a logic-only callback (`App::logic`, which also runs while hidden) and from
+    /// a normal UI pass: consumed control work, live polling, background completions, autosave and
+    /// recovery deadlines. It never reads UI input, so it must not scan events, run shortcuts or
+    /// lay out anything.
+    pub fn background_tick(&mut self, ctx: &egui::Context) {
+        control::background(self, ctx);
+        // What happened in a live session (the network woke us for it).
+        if self.session.live_poll() {
+            if let Some(m) = self.session.message.take() {
+                self.toast(live::failure_text(&m));
+            }
+            self.background_done(ctx);
+        }
+        // Files that arrived without a command (joined, recovered) take the kept View toggles too.
+        self.session.apply_view_prefs();
+        let now = self.clock.now();
+        self.autosave_tick(ctx, now);
+        self.auto_save_tick(ctx, now);
+        updates_ui::tick(self, ctx);
+        self.logic_ticked = true;
+    }
+
+    /// UI-phase setup that needs a real current `Ui`: fonts/language/theme, interface zoom and the
+    /// render worker. Runs once per frame (pass 0) for the main window, and once per frame for
+    /// every child window (`windows::draw`), never on a logic-only tick.
+    fn ui_setup(&mut self, ctx: &egui::Context) {
+        self.viewport_setup(ctx);
+    }
+
+    /// The app-global part of [`Self::ui_setup`] that every window's frame needs: language, fonts,
+    /// theme and `ui.dark`, the render worker, and the interface zoom plan. eframe only calls
+    /// `App::ui` for the root window, so a child must run this itself before it draws; a child that
+    /// only runs while the root is minimised still gets theme switches, CJK faces for its own
+    /// document, and the right `ui.dark` for its tabs and dialogs.
+    pub(crate) fn viewport_setup(&mut self, ctx: &egui::Context) {
+        if self.language.as_ref() != Some(&self.session.prefs.language) {
+            i18n::set(&self.session.prefs.language, self.services.system_language().as_deref());
+            self.language = Some(self.session.prefs.language.clone());
+        }
+        // Screen-reader and bidi language of the UI (fork E17).
+        ctx.set_language(i18n::current().map(|l| l.code.to_string()));
+        if !self.fonts_installed {
+            // Cmd/Ctrl+= / - / 0 zoom the canvas (view.zoomIn, view.zoomOut, view.zoom100): egui's
+            // own keyboard zoom would scale the whole interface on the same keys.
+            ctx.options_mut(|o| o.zoom_with_keyboard = false);
+            // A double-click's window is the platform's (0.5 s, Windows' default), not egui's
+            // stricter 0.3 s: a double-click the OS takes must enter a shape's points too.
+            ctx.memory_mut(|m| m.options.input_options.max_double_click_delay = 0.5);
+            theme::install_fonts(ctx, false, 0);
+            self.fonts_installed = true;
+            // Installed fonts apply from the next frame; a child window draws on here, so ask for
+            // that frame (the root draws nothing on the frame it installs them).
+            ctx.request_repaint();
+        } else if figcraft_text::system_fonts_scanned() {
+            // Once the system fonts are indexed: faces for names in scripts the UI fonts lack, and
+            // for each CJK script once something shows it.
+            let installed = self.script_fonts.map_or(0, |(s, _)| s);
+            let cjk = installed | self.cjk_needed(ctx, installed);
+            // The UI language's script leads the CJK faces, so another language lays them out again.
+            let lang = i18n::current().map_or("en", |l| l.code);
+            if self.script_fonts != Some((cjk, lang)) {
+                self.script_fonts = Some((cjk, lang));
+                theme::install_fonts(ctx, true, cjk);
+            }
+        }
+        // egui's zoom is for the whole app and multiplies each window's own system scale, so the
+        // size is the same relative to every screen; the main window, whose size can hold a size
+        // back, sets it. The browser keeps its own zoom. Every window records its own plan (the
+        // Preferences warning and `ui.inspect` read it), from its own size.
+        {
+            let window_px = ctx.content_rect().size() * ctx.pixels_per_point();
+            let size = if cfg!(target_arch = "wasm32") { 1.0 } else { self.session.prefs.ui_scale };
+            let plan = ui_scale::plan(size, ctx.native_pixels_per_point(), Some((window_px.x, window_px.y)));
+            if ctx.viewport_id() == egui::ViewportId::ROOT {
+                ctx.set_zoom_factor(plan.zoom);
+            }
+            self.ui.ui_scale = plan;
+        }
+        let dark = match self.session.prefs.theme.as_str() {
+            "dark" => true,
+            // The active visuals were set by us last frame (possibly for a manual theme). Read the
+            // integration's OS theme; winit reports none on Linux and the BSDs, where the platform
+            // services' colour scheme answers instead. Without either, keep the light fallback.
+            "system" => ctx.system_theme().map(|t| t == egui::Theme::Dark).or_else(|| self.services.system_dark()).unwrap_or(false),
+            _ => false,
+        };
+        self.ui.dark = dark;
+        // New files take the theme's page colour (existing pages keep theirs).
+        self.session.set_ui_dark(dark);
+        theme::apply_with(ctx, if dark { theme::Tokens::dark() } else { theme::Tokens::light() }, self.reduce_motion());
+        if self.worker.is_none() {
+            self.worker = Some(render_worker::Worker::new(ctx.clone()));
+        }
+    }
+
+    /// Every [`AUTOSAVE_SECS`], each open document with unsaved changes since its last version
+    /// gets an autosave checkpoint in its version history.
+    fn autosave_tick(&mut self, ctx: &egui::Context, now: f64) {
+        if now < self.ui.next_autosave {
+            // Wake up for it even if nothing else draws a frame by then.
+            repaint_in(ctx, self.ui.next_autosave - now);
+            return;
+        }
+        if self.ui.next_autosave > 0.0 {
+            let active = self.session.active;
+            for i in 0..self.session.docs.len() {
+                self.session.active = i;
+                let _ = self.session.execute("version.autosave", &json!({}));
+            }
+            self.session.active = active;
+        }
+        self.ui.next_autosave = now + AUTOSAVE_SECS;
+        repaint_in(ctx, AUTOSAVE_SECS);
+    }
+
+    /// With auto-save on, files that have a path are saved [`AUTO_SAVE_SECS`] after they last
+    /// changed (not during a gesture, a live preview or while a version is shown). The file is
+    /// encoded on a thread of its own, so a big one doesn't hold up the window, and written here.
+    fn auto_save_tick(&mut self, ctx: &egui::Context, now: f64) {
+        let mut failed = self.auto_save_done();
+        // The browser has no files to save to.
+        let on = !cfg!(target_arch = "wasm32") && self.session.prefs.auto_save;
+        let saving = &self.ui.auto_saving;
+        let due = |d: &&figcraft_engine::DocState| {
+            d.path.as_deref().is_some_and(|p| d.images_lost_saving_to(p).is_none())
+                && d.branch_of.is_none()
+                && d.preview.is_none()
+                && d.is_dirty()
+                && !saving.iter().any(|(uid, _)| *uid == d.uid)
+        };
+        let changes = if on { self.session.docs.iter().filter(due).map(|d| d.revision).reduce(u64::wrapping_add) } else { None };
+        match changes {
+            None => self.ui.auto_save_at = None,
+            Some(changes) => {
+                let at = match self.ui.auto_save_at {
+                    Some((at, c)) if c == changes && failed.is_none() => at,
+                    _ => now + if failed.is_some() { AUTO_SAVE_RETRY_SECS } else { AUTO_SAVE_SECS },
+                };
+                self.ui.auto_save_at = Some((at, changes));
+                if now < at || self.session.docs.iter().any(|d| d.interaction.is_some() || d.text_preview.is_some()) {
+                    // Due but busy: look again in a second.
+                    repaint_in(ctx, if now < at { at - now } else { 1.0 });
+                } else {
+                    self.ui.auto_save_at = None;
+                    let files: Vec<_> =
+                        self.session.docs.iter().filter(due).map(|d| (d.uid, figcraft_engine::cmd::file::FileSnapshot::of(d))).collect();
+                    for (uid, file) in files {
+                        let encode = move || {
+                            let bytes = file.encode();
+                            (file, bytes)
+                        };
+                        match std::thread::Builder::new().name("figcraft-save".into()).spawn(encode) {
+                            Ok(h) => self.ui.auto_saving.push((uid, h)),
+                            Err(e) => {
+                                failed.get_or_insert(e.to_string());
+                                self.ui.auto_save_at = Some((now + AUTO_SAVE_RETRY_SECS, changes));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if !self.ui.auto_saving.is_empty() {
+            // Look again shortly for the files being encoded.
+            repaint_in(ctx, 0.1);
+        }
+        if let Some(e) = failed {
+            self.toast(i18n::trf("Couldn't save automatically: {error}", &[("error", &e)]));
+        }
+    }
+
+    /// Write the files whose auto-save encoding finished; the first error, if one failed.
+    fn auto_save_done(&mut self) -> Option<String> {
+        if self.ui.auto_saving.is_empty() {
+            return None;
+        }
+        let mut failed = None;
+        let done: Vec<_> = self.ui.auto_saving.extract_if(.., |(_, h)| h.is_finished()).collect();
+        for (_, h) in done {
+            let saved = match h.join() {
+                Ok((snapshot, Ok(bytes))) => snapshot.save(&mut self.session, &bytes).map(|_| ()).map_err(|e| e.to_string()),
+                Ok((_, Err(e))) => Err(e.to_string()),
+                Err(_) => Err("the file couldn't be encoded".to_string()),
+            };
+            if let Err(e) = saved {
+                failed.get_or_insert(e);
+            }
+        }
+        failed
+    }
+
+    /// Draw the whole UI: the main window (the other windows draw themselves).
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        #[cfg(not(target_arch = "wasm32"))]
+        let t0 = std::time::Instant::now();
+        let ctx = ui.ctx().clone();
+        self.ui_context = Some(ctx.clone());
+        // `App::logic` already ticked this pass; direct harnesses do not call it. The marker only
+        // covers the tick that shares this pass: clearing it here keeps a direct `App::ui` harness
+        // ticking on every frame (it used to tick every other frame).
+        if !std::mem::take(&mut self.logic_ticked) {
+            self.background_tick(&ctx);
+            self.logic_ticked = false;
+        }
+        // Setup once per frame (pass 0), not once per pass and never on a logic-only tick.
+        let stamp = (ctx.viewport_id(), ctx.cumulative_frame_nr());
+        let first = !self.fonts_installed;
+        if ctx.current_pass_index() == 0 && self.ui_frame_stamp != Some(stamp) {
+            self.ui_frame_stamp = Some(stamp);
+            self.frame_stats.record(&ctx);
+            self.ui_setup(&ctx);
+        }
+        if first && self.fonts_installed {
+            // New fonts apply from the next frame; draw nothing until then. Anything taken into
+            // this frame's (undrawn) input waits for the first drawn frame.
+            ctx.request_repaint();
+            if let Some(events) = self.applied_input.take() {
+                self.push_control_input(events);
+            }
+            self.input_acks.append(&mut self.applied_acks);
+            self.applied_frame = None;
+            self.control_synthetic = false;
+            // The next (drawn) frame ticks for itself in a direct harness.
+            self.logic_ticked = false;
+            self.observe_ime(&ctx, false);
+            return;
+        }
+        windows::begin(self, &ctx);
+        let (files, prefs) = (self.session.docs.len(), self.session.prefs.clone());
+        self.frame(ui);
+        windows::settle(self, &ctx, files);
+        if self.session.prefs != prefs {
+            windows::repaint_others(self, &ctx);
+        }
+        windows::show(self, &ctx);
+        // The injected batch was applied by the frame that took it. A discarded sizing pass keeps
+        // its acknowledgement for the presented pass but never replays the input (its side effects
+        // already happened and would otherwise duplicate).
+        self.end_input_frame(&ctx);
+        // Plugins installed, removed or set up are kept at once: a crash doesn't lose them.
+        // So are the owner tokens of files put online.
+        if std::mem::take(&mut self.session.plugins.unsaved) | std::mem::take(&mut self.session.live.unsaved) {
+            self.services.save_prefs(&self.session.prefs);
+        }
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            self.ui.frame_ms = t0.elapsed().as_secs_f64() * 1000.0;
+        }
+    }
+
+    /// Whether the right panel shows: never with the UI `hidden`; always on a design file; on a
+    /// board, which has no prototypes or Dev Mode (its tab stays Design), only when asked for.
+    fn right_panel_shown(&mut self, hidden: bool) -> bool {
+        let board = self.session.doc().is_ok_and(figcraft_engine::board::is_board);
+        if board {
+            self.ui.right_tab = RightTab::Design;
+        }
+        !hidden && (!board || self.ui.board_panel)
+    }
+
+    /// A narrow window's two buttons for the side panels (touch-sized); the open one closes again.
+    fn mobile_buttons(&mut self, ctx: &egui::Context, at: egui::Pos2) {
+        use a11y::Tip as _;
+        let t = theme::Tokens::get(ctx);
+        egui::Area::new(egui::Id::unique("mobile_panel_buttons")).order(egui::Order::Foreground).fixed_pos(at).show(ctx, |ui| {
+            for (side, icon, name) in
+                [(MobilePanel::Left, icons::Icon::Layers, i18n::tr("Layers")), (MobilePanel::Right, icons::Icon::Panels, i18n::tr("Design"))]
+            {
+                let open = self.ui.mobile_panel == Some(side);
+                let (r, resp) = ui.allocate_exact_size(egui::vec2(40.0, 40.0), egui::Sense::click());
+                let resp = resp.tip(name);
+                let fill = if open { t.accent } else { t.panel };
+                ui.painter().rect(r, 8.0, fill, egui::Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
+                icons::paint(ui.painter(), r.shrink(10.0), icon, if open { t.accent_on } else { t.icon });
+                if resp.clicked() {
+                    if side == MobilePanel::Left && !open {
+                        self.ui.open_left_panel();
+                    } else {
+                        self.ui.mobile_panel = if open { None } else { Some(side) };
+                    }
+                }
+                ui.add_space(4.0);
+            }
+        });
+    }
+
+    /// One frame of the window drawing now.
+    pub(crate) fn frame(&mut self, ui: &mut egui::Ui) {
+        let ctx = ui.ctx().clone();
+        // Bind this input batch before controls or pointer input can replace its composing
+        // target/caret. Outgoing IME receipts run after mutation and cannot authorize it.
+        let ime_input = shortcuts::ImeInputBaseline::capture(self);
+        let t = theme::Tokens::get(&ctx);
+        // A field that had the keyboard when the frame began keeps its keys from the shortcuts
+        // even if it lets go during the frame (Enter commits it), or as it began (egui drops the
+        // focus on Escape before the frame, which cancels the field's edit and nothing else).
+        let typing = std::mem::take(&mut self.field_focus) || a11y::field_focused(&ctx);
+        // Bind the originating field/file before tabs can switch. Its widget commits only after
+        // processing this batch; delivery remains deferred until the following frame.
+        let field_save = shortcuts::prepare_field_save(self, &ctx);
+        let swallowed = shortcuts::swallowed_paste(self, &ctx);
+        // A dialog that closed acts first, in the window it was opened from.
+        self.poll_dialog(&ctx);
+        // Control requests run first so their results reflect this frame.
+        control::drain(self, &ctx);
+        windows::requests(self, &ctx);
+        selection_spacing::sync(self, &ctx);
+        // Before any widget: the navigation keys (F6, Tab, arrows, Escape) move the keyboard.
+        a11y::begin(self, &ctx, ui.scope_id());
+        if self.ui.title_bar == TitleBar::Custom {
+            tabs::resize_edges(&ctx);
+        }
+        if self.ui.icon_gallery {
+            icons::gallery(&ctx);
+        }
+        theme::set_doc_profile(&ctx, self.session.doc().map_or(figcraft_color::ColorProfile::Srgb, |d| d.color_profile));
+        widgets::set_nudge(&ctx, self.session.prefs.nudge_small, self.session.prefs.nudge_big);
+        self.sync_dev_mode();
+        self.end_pen_outside_design();
+        tabs::relink_presents(self);
+        tabs::tab_bar(self, ui);
+        // Control/window work and this pass's physical tab click may have replaced the owner.
+        // A shared field ID in that replacement must never consume the old commit marker.
+        let field_save = shortcuts::revalidate_field_save(self, &ctx, field_save);
+        if self.ui.present.is_some() {
+            // A close request can arrive while the presenter fills the window. Let its unsaved
+            // changes dialog take Escape and draw above the player just as it does in the editor.
+            dialogs::keys(self, &ctx);
+            present::show(self, ui);
+            dialogs::show(self, &ctx);
+            updates_ui::show(self, &ctx);
+            // What went wrong while presenting (a widget's plugin failing) shows over it.
+            self.toast_ui(&ctx);
+            windows::requests(self, &ctx);
+            shortcuts::clear_field_save_marker(&ctx);
+            self.observe_ime(&ctx, false);
+            return;
+        }
+        if !self.has_files() || self.ui.home {
+            home::show(self, ui);
+            // The shortcuts panel belongs to the canvas; it doesn't hang over the home screen
+            // (cleared after the home widgets, which may have just asked for it).
+            self.ui.shortcuts_panel = false;
+            dialogs::keys(self, &ctx);
+            dialogs::show(self, &ctx);
+            updates_ui::show(self, &ctx);
+            self.toast_ui(&ctx);
+            windows::requests(self, &ctx);
+            shortcuts::clear_field_save_marker(&ctx);
+            self.observe_ime(&ctx, false);
+            return;
+        }
+        let hidden = self.session.ds().map(|d| d.view.ui_hidden).unwrap_or(false);
+        let narrow = !hidden && ui.available_width() < NARROW_WIDTH;
+        let mobile = self.ui.mobile_panel.filter(|_| narrow);
+        self.ui.narrow = narrow;
+        // A narrow window shows the right panel when its button asks for it, a board's too.
+        let right_open = (self.right_panel_shown(hidden) && !narrow) || mobile == Some(MobilePanel::Right);
+        if !hidden && (!narrow || mobile == Some(MobilePanel::Left)) {
+            egui::Panel::left("left_rail")
+                .exact_size(56.0)
+                .resizable(false)
+                .frame(egui::Frame::NONE.fill(t.panel).stroke(egui::Stroke::new(1.0, t.border)))
+                .show(ui, |ui| {
+                    a11y::region(&mut self.ui.nav, ui, a11y::Region::Layers, egui::accesskit::Role::Navigation, i18n::tr("Sidebar"));
+                    layers::rail(self, ui)
+                });
+        }
+        // The panels are as wide as asked, less in a window too small for them and the canvas.
+        let left_open = !hidden && if narrow { mobile == Some(MobilePanel::Left) } else { !self.ui.left_collapsed };
+        let (left_w, right_w) = if narrow {
+            let w = (ui.available_width() - MOBILE_STRIP).max(0.0);
+            (if left_open { w } else { 0.0 }, w)
+        } else {
+            fit_panels(ui.available_width(), left_open.then_some(self.ui.left_width), right_open.then_some(self.ui.right_width))
+        };
+        let rows = ui.available_rect_before_wrap().y_range();
+        let mut edges: Vec<(&str, f32, f32, f32)> = Vec::new();
+        if left_open {
+            if !narrow {
+                edges.push(("left", ui.available_rect_before_wrap().min.x + left_w, left_w, 1.0));
+            }
+            egui::Panel::left("left_panel")
+                .resizable(false)
+                .exact_size(left_w)
+                .frame(egui::Frame::NONE.fill(t.panel).stroke(egui::Stroke::new(1.0, t.border)))
+                .show(ui, |ui| {
+                    let label = match self.ui.left_tab {
+                        _ if self.ui.versions.open => i18n::tr("Version history"),
+                        LeftTab::File => i18n::tr("Layers"),
+                        LeftTab::Assets => i18n::tr("Assets"),
+                    };
+                    a11y::region(&mut self.ui.nav, ui, a11y::Region::Layers, egui::accesskit::Role::Pane, label);
+                    layers::left_panel(self, ui)
+                });
+        }
+        if right_open {
+            if !narrow {
+                edges.push(("right", ui.available_rect_before_wrap().max.x - right_w, right_w, -1.0));
+            }
+            egui::Panel::right("right_panel")
+                .resizable(false)
+                .exact_size(right_w)
+                .frame(egui::Frame::NONE.fill(t.panel).stroke(egui::Stroke::new(1.0, t.border)))
+                .show(ui, |ui| {
+                    let label = match self.ui.right_tab {
+                        RightTab::Design => i18n::tr("Design"),
+                        RightTab::Prototype => i18n::tr("Prototype"),
+                        RightTab::Inspect => i18n::tr("Dev Mode"),
+                    };
+                    a11y::region(&mut self.ui.nav, ui, a11y::Region::Properties, egui::accesskit::Role::Pane, label);
+                    right::right_panel(self, ui)
+                });
+        }
+        egui::CentralPanel::default().frame(egui::Frame::NONE.fill(t.canvas)).show(ui, |ui| {
+            let worker = self.worker.take();
+            let mut worker = worker.unwrap_or_else(|| render_worker::Worker::new(ctx.clone()));
+            canvas::show(self, ui, &mut worker);
+            self.worker = Some(worker);
+            if !hidden && mobile.is_none() {
+                ui.scope_builder(egui::UiBuilder::new().id_salt("toolbar"), |ui| {
+                    a11y::container(ui, egui::accesskit::Role::Toolbar, i18n::tr("Tools"));
+                    toolbar::show(self, ui);
+                });
+            }
+        });
+        if narrow {
+            let x = if mobile == Some(MobilePanel::Left) { ctx.content_rect().max.x - MOBILE_STRIP + 4.0 } else { ctx.content_rect().min.x + 4.0 };
+            self.mobile_buttons(&ctx, egui::pos2(x, rows.min + 8.0));
+        }
+        // The panels' edges, over the canvas and the panels (drawn after them: they take the press).
+        for (name, x, shown, grows) in edges {
+            if let Some(w) = Self::panel_edge(ui, name, x, rows, shown, grows) {
+                let (l, r) = if name == "left" { (w, self.ui.right_width) } else { (self.ui.left_width, w) };
+                self.set_panel_widths(l, r);
+                self.panels_unsaved = true;
+            }
+        }
+        // Kept once the drag is over (not on every pointer move).
+        if self.panels_unsaved && !ctx.input(|i| i.pointer.any_down()) {
+            self.panels_unsaved = false;
+            self.services.save_prefs(&self.session.prefs);
+        }
+        // Before the shortcuts: keys the hovered pane's prototype uses don't reach the editor, and
+        // the arrows step through comment threads with the Comment tool.
+        present::show_pane(self, &ctx);
+        comments::keys(self, &ctx);
+        dev_compare::keys(self, &ctx);
+        branch_ui::keys(self, &ctx);
+        live::dialog_keys(self, &ctx);
+        dialogs::keys(self, &ctx);
+        shortcuts::handle_input(self, &ctx, typing, swallowed, ime_input, field_save);
+        menus::popups(self, &ctx);
+        variable_ui::picker(self, &ctx);
+        style_picker::show(self, &ctx);
+        self.end_unwanted_text_preview(&ctx);
+        self.end_pen_outside_design();
+        dialogs::show(self, &ctx);
+        updates_ui::show(self, &ctx);
+        self.toast_ui(&ctx);
+        // A rename started after the layers panel drew (Cmd/Ctrl+R, a double-click) opens its field
+        // next frame.
+        if self.ui.rename.is_some_and(|r| r.start) && !hidden && !self.ui.left_collapsed && self.ui.left_tab == LeftTab::File {
+            ctx.request_repaint();
+        }
+        a11y::end(self, &ctx);
+        self.field_focus = a11y::field_focused(&ctx);
+        windows::requests(self, &ctx);
+        // Your pointer, selection and view to the others in each live session (when they
+        // changed), from the window with its file.
+        let windows = &self.windows;
+        self.session.live_sync_in(|uid| uid.map_or(0, |u| windows.of(u)) == windows.current);
+        // The canvas editor's IME context is observed exactly once per pass, after every command
+        // this pass ran (shortcuts, menus, dialogs, window requests and live sync). A focused panel
+        // field or an open palette owns the platform IME instead; the early `home`/present paths
+        // above make the same single idle observation.
+        self.observe_ime(&ctx, !typing && !self.field_focus && self.ui.palette.is_none());
+    }
+
+    /// The pass's one IME observation: the focused on-canvas editor, or an explicit idle.
+    ///
+    /// Calling `ImeContextTracker::observe` more than once in a pass would treat an idle followed
+    /// by a focused observation as a context change (dropping the frame's receipts) and bump the
+    /// generation. Keeping this in one place makes the fork contract structural.
+    fn observe_ime(&mut self, ctx: &egui::Context, focused: bool) {
+        #[cfg(test)]
+        {
+            self.ime_observations = self.ime_observations.saturating_add(1);
+        }
+        if focused {
+            shortcuts::ime_output(self, ctx);
+        } else {
+            let _ = self.ime.observe(ctx.viewport_id(), None);
+        }
+    }
+
+    /// Draw the toast: start its lifetime on the frame **after** the first drawn frame, request
+    /// that frame and the frame that hides it, expire and remove it at the deadline, and place it
+    /// at the bottom centre.
+    fn toast_ui(&mut self, ctx: &egui::Context) {
+        let Some((msg, clock)) = &mut self.ui.toast else { return };
+        let now = ctx.input(|i| i.time);
+        // The clock starts on the frame after the one that first draws the toast: that frame's
+        // time was taken before whatever raised it ran (a file dialog, a long open), and would
+        // count that wait against it, so a failed open's message expired before it was seen.
+        let left = match *clock {
+            ToastClock::Raised => {
+                *clock = ToastClock::Drawn;
+                ctx.request_repaint();
+                TOAST_SECS
+            }
+            ToastClock::Drawn => {
+                *clock = ToastClock::Since(now);
+                TOAST_SECS
+            }
+            ToastClock::Since(t) => TOAST_SECS - (now - t),
+        };
+        if left <= 0.0 {
+            self.ui.toast = None;
+            return;
+        }
+        let msg = msg.clone();
+        // Nothing moves while it shows: the next frame it needs is the one that hides it.
+        if matches!(clock, ToastClock::Since(_)) {
+            repaint_in(ctx, left);
+        }
+        let screen = ctx.content_rect();
+        egui::Area::new(egui::Id::unique("toast"))
+            .fixed_pos(egui::pos2(screen.center().x, screen.max.y - 96.0))
+            .pivot(egui::Align2::CENTER_BOTTOM)
+            .order(egui::Order::Tooltip)
+            .show(ctx, |ui| {
+                egui::Frame::NONE
+                    .fill(egui::Color32::from_rgb(0x1E, 0x1E, 0x1E))
+                    .corner_radius(egui::CornerRadius::same(8))
+                    .inner_margin(egui::Margin::symmetric(14, 10))
+                    .show(ui, |ui| {
+                        // Wrapped at a readable width (the area alone would wrap at a sliver).
+                        let width = (screen.width() - 64.0).clamp(120.0, 480.0);
+                        let galley = ui.painter().layout(msg, theme::regular(12.0), egui::Color32::WHITE, width);
+                        ui.label(galley);
+                    });
+            });
+    }
+
+    /// UI state as JSON (control channel `ui.inspect`).
+    pub fn inspect(&self) -> Value {
+        let mut state = json!({
+            "rightTab": self.ui.right_tab,
+            "leftTab": self.ui.left_tab,
+            "home": self.ui.home,
+            "online": online::inspect(self),
+            "tabs": self.session.docs.iter().map(|d| json!({"name": d.doc.name, "live": tabs::live_mark(self, d.uid).map(|shared| if shared { "shared" } else { "private" })})).collect::<Vec<_>>(),
+            "homeSection": self.ui.home_view.section.id(),
+            "homeRecents": home_recents::inspect(self),
+            "dark": self.ui.dark,
+            "focus": {"region": self.ui.nav.region.id(), "keyboard": self.ui.nav.keyboard},
+            "reduceMotion": self.reduce_motion(),
+            "presenting": self.ui.present.is_some(),
+            "presenter": tabs::shown_or_paused(self).map(present::Presenter::inspect),
+            "presentOptions": {"scale": self.ui.present_view.scale.id(), "deviceFrame": self.ui.present_view.device_frame, "comments": self.ui.present_view.comments, "hotspotHints": self.ui.present_view.hotspot_hints, "inspect": self.ui.present_view.inspect},
+            "preview": self.ui.preview.as_ref().map(|p| p.player.inspect()),
+            "mainMenu": self.ui.main_menu,
+            "palette": self.ui.palette.is_some(),
+            "variables": self.ui.variables.is_some(),
+            "versionHistory": self.ui.versions.open,
+            "branchReview": self.ui.branch_review.as_ref().map(|r| json!({"id": r.id, "picks": r.picks, "mode": if r.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }})),
+            "devCompare": self.ui.dev.compare.as_ref().map(|c| json!({"id": c.id, "mode": if c.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }, "split": c.split, "version": c.version})),
+            "devFocus": self.session.ds().ok().and_then(figcraft_engine::DocState::focused),
+            "annotationFilter": self.ui.dev.categories.id(),
+            "colorProfileDialog": self.ui.color_profile.map(|p| p.id()),
+            "stylePicker": self.ui.style_picker.as_ref().map(|p| p.slot().key()),
+            "stylePickerView": if self.ui.style_grid { "grid" } else { "list" },
+            "textPreview": figcraft_engine::textpreview::active(&self.session),
+            "comments": {
+                "open": self.ui.comments.open,
+                "draft": self.ui.comments.draft.as_ref().map(|d| [d.0, d.1]),
+                "filter": self.ui.comments.filter.id(),
+                "sort": self.ui.comments.sort.id(),
+                "search": self.ui.comments.search,
+                "editing": self.ui.comments.editing.as_ref().map(|e| [e.0, e.1 as u64]),
+                "mentions": self.ui.comments.mention.names(),
+            },
+            "frameMs": self.ui.frame_ms,
+            "renderMs": self.ui.render_ms,
+            "framesDrawn": self.frame_stats.frames,
+            "repaintCauses": self.frame_stats.causes(),
+            "canvas": {
+                "rect": [self.canvas.rect.min.x, self.canvas.rect.min.y, self.canvas.rect.max.x, self.canvas.rect.max.y],
+                "renderWork": self.canvas.render_work.map(|w| match w {
+                    figcraft_render::Work::Reused => json!({"kind": "reused"}),
+                    figcraft_render::Work::Partial { pixels } => json!({"kind": "partial", "pixels": pixels}),
+                    figcraft_render::Work::Full => json!({"kind": "full"}),
+                }),
+                "quality": if self.canvas.tex_coarse { "preview" } else { "refined" },
+                "previewLatencyMs": self.canvas.preview_latency_ms,
+                "refineLatencyMs": self.canvas.refine_latency_ms,
+            },
+            "live": live::inspect(self),
+            "window": self.windows.current,
+            "windows": windows::list(self),
+            "tool": self.session.tool_info(),
+            "cursor": self.canvas.cursor.map(cursors::Shown::name),
+            "panels": {"left": self.ui.left_width, "right": self.ui.right_width, "leftCollapsed": self.ui.left_collapsed},
+            "status": self.session.status(),
+            "lastError": self.ui.last_error,
+            "importReport": self.ui.import_report.as_ref().map(import_report::Report::inspect),
+        });
+        state["homeSearch"] = json!(self.ui.home_view.file_query);
+        // Set apart from the literal above, which is at the macro recursion limit.
+        state["uiScale"] = json!({"choice": self.session.prefs.ui_scale, "zoom": self.ui.ui_scale.zoom, "drawn": self.ui.ui_scale.drawn, "limited": self.ui.ui_scale.limited});
+        state["pendingOpens"] = json!(self.ui.pending_opens.len());
+        state["missingFonts"] = json!(self.ui.missing_fonts.as_ref().map(missing_fonts::Shown::inspect));
+        state["presentTabs"] = tabs::present_tabs_inspect(self);
+        state
+    }
+}
diff --git a/crates/ui-egui/src/clock.rs b/crates/ui-egui/src/clock.rs
new file mode 100644
index 00000000..cca9c12a
--- /dev/null
+++ b/crates/ui-egui/src/clock.rs
@@ -0,0 +1,63 @@
+/// How often open documents get an autosave checkpoint (seconds).
+pub const AUTOSAVE_SECS: f64 = 30.0 * 60.0;
+
+/// Most changed layers whose names are checked for CJK scripts one by one (beyond: all of them).
+pub(crate) const CJK_CHANGES: usize = 10_000;
+
+/// With auto-save on: how long after a file last changed it is saved, and how long a failed save
+/// waits before trying again (seconds).
+pub const AUTO_SAVE_SECS: f64 = 3.0;
+
+pub(crate) const AUTO_SAVE_RETRY_SECS: f64 = 60.0;
+
+/// How long a toast shows (seconds).
+pub(crate) const TOAST_SECS: f64 = 3.0;
+
+/// How long a toast has been showing ([`UiState::toast`]).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ToastClock {
+    /// Raised, not drawn yet.
+    Raised,
+    /// Drawn once; the next frame starts the clock.
+    Drawn,
+    /// Showing since this time (UI clock, seconds).
+    Since(f64),
+}
+
+/// Draw another frame `secs` from now (nothing else needs drawing until then: an idle window draws
+/// no frames).
+#[track_caller]
+pub(crate) fn repaint_in(ctx: &egui::Context, secs: f64) {
+    if secs.is_finite() {
+        ctx.request_repaint_after(std::time::Duration::from_secs_f64(secs.max(0.0)));
+    }
+}
+
+/// A monotonic clock for background work (autosave, recovery, capture deadlines).
+///
+/// `Context::input(|i| i.time)` is the UI pass's time and is stale in `run_logic`; wall-clock time
+/// can jump. `web_time::Instant` is monotonic on native and in the browser. Tests drive deadlines
+/// directly with [`FrameClock::set_test_now`].
+pub struct FrameClock {
+    origin: web_time::Instant,
+    test_now: Option<f64>,
+}
+
+impl Default for FrameClock {
+    /// Start the frame clock at the current web time with no injected test time.
+    fn default() -> Self {
+        Self { origin: web_time::Instant::now(), test_now: None }
+    }
+}
+
+impl FrameClock {
+    /// Seconds since the app started (or the injected test time).
+    pub fn now(&self) -> f64 {
+        self.test_now.unwrap_or_else(|| self.origin.elapsed().as_secs_f64())
+    }
+
+    /// Set a fake monotonic time (tests); `None` returns to the real clock.
+    pub fn set_test_now(&mut self, secs: Option<f64>) {
+        self.test_now = secs;
+    }
+}
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 1e89a3e7..1eb714e9 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -275,125 +275,20 @@ use serde_json::{Value, json};
 
 pub use control::{ControlReply, ControlRequest, RequestGate, RequestState};
 
-/// Platform services the app crate provides (file dialogs, clipboard, URLs).
-pub trait Services {
-    fn pick_open(&mut self, _title: &str, _exts: &[&str]) -> DialogFuture {
-        Box::pin(std::future::ready(None))
-    }
-    /// Pick a file and read it, where the platform hands over a file's name and contents rather
-    /// than a path to it (the browser). `None`: the platform picks paths ([`Services::pick_open`]).
-    fn pick_open_contents(&mut self, _title: &str, _exts: &[&str]) -> Option<ContentsFuture> {
-        None
-    }
-    fn pick_save(&mut self, _title: &str, _name: &str, _exts: &[&str]) -> DialogFuture {
-        Box::pin(std::future::ready(None))
-    }
-    /// The platform saves files by handing them over as downloads (the browser), not through
-    /// save dialogs.
-    fn downloads(&self) -> bool {
-        false
-    }
-    /// Hand `bytes` over as a download named `name`; false when nothing was delivered.
-    fn download(&mut self, _name: &str, _bytes: &[u8]) -> bool {
-        false
-    }
-    /// A folder to write several files into.
-    fn pick_folder(&mut self, _title: &str) -> DialogFuture {
-        Box::pin(std::future::ready(None))
-    }
-    fn clipboard_set_text(&mut self, _s: &str) {}
-    /// Give native services access to the window context for platform clipboard output.
-    fn set_egui_context(&mut self, _ctx: &egui::Context) {}
-    fn clipboard_get_text(&mut self) -> Option<String> {
-        None
-    }
-    fn clipboard_get_html(&mut self) -> Option<String> {
-        None
-    }
-    fn clipboard_set_png(&mut self, _w: u32, _h: u32, _rgba: &[u8]) {}
-    /// An image on the system clipboard as (width, height, straight RGBA).
-    fn clipboard_get_image(&mut self) -> Option<(u32, u32, Vec<u8>)> {
-        None
-    }
-    fn open_url(&mut self, _url: &str) {}
-    /// Show the file at `path` in the platform's file manager (Finder, Explorer), selected where the
-    /// platform can.
-    fn reveal_path(&mut self, _path: &std::path::Path) {}
-    /// The system asks for reduced motion (its accessibility setting).
-    fn reduce_motion(&self) -> bool {
-        false
-    }
-    /// The system asks for the dark interface (the freedesktop colour scheme): for platforms whose
-    /// windowing stack doesn't report a theme (winit gives none on Linux and the BSDs).
-    fn system_dark(&self) -> Option<bool> {
-        None
-    }
-    /// After a panic in a frame: keep recovery copies of unsaved files.
-    fn emergency_save(&mut self, _session: &Session) {}
-    /// Keep the preferences now (the installed plugins or their settings changed), as the app
-    /// does when it quits.
-    fn save_prefs(&mut self, _prefs: &figcraft_engine::Prefs) {}
-    /// The OS or browser language as a tag ("es-ES"), for the "system" language preference.
-    fn system_language(&self) -> Option<String> {
-        None
-    }
-    /// The controller buttons held now on any controller: bit i is standard gamepad layout index i
-    /// (0 the bottom face button … 16 home; `figcraft_doc::proto::GAMEPAD_BUTTONS`). The prototype
-    /// player asks every frame while its prototype has gamepad triggers.
-    fn gamepad_held(&mut self) -> u32 {
-        0
-    }
-}
+mod app;
+mod clock;
+mod open;
+mod services;
+mod state;
 
-pub type DialogFuture = Pin<Box<dyn Future<Output = Option<PathBuf>>>>;
-/// A picked file's name and contents ([`Services::pick_open_contents`]); `None` when the picker
-/// was cancelled, `Err` with what to tell the user when the file couldn't be read.
-pub type ContentsFuture = Pin<Box<dyn Future<Output = Option<Result<(String, Vec<u8>), String>>>>>;
-/// A dropped file's contents, read once they arrive (`Err`: what to tell the user when they
-/// couldn't be read).
-pub type ReadFuture = Pin<Box<dyn Future<Output = Result<Vec<u8>, String>>>>;
-type PickFuture = Pin<Box<dyn Future<Output = Option<Picked>>>>;
-type DialogDone = Box<dyn FnOnce(&mut FigApp, Picked)>;
-
-/// What a dialog picked: a path, or a file's name and contents where there are no paths, or why
-/// the picked file couldn't be read.
-enum Picked {
-    Path(PathBuf),
-    Contents(String, Vec<u8>),
-    Unreadable(String),
-}
-
-impl Picked {
-    /// The file as `file.open` and `file.import` take it (`Err`: what to tell the user instead).
-    fn file_params(self) -> Result<Value, String> {
-        match self {
-            Picked::Path(p) => Ok(json!({"path": p.to_string_lossy()})),
-            Picked::Contents(name, bytes) => {
-                use base64::Engine as _;
-                Ok(json!({"data": base64::engine::general_purpose::STANDARD.encode(&bytes), "name": name}))
-            }
-            Picked::Unreadable(why) => Err(why),
-        }
-    }
-}
-
-/// What the user is told about a file whose contents couldn't be read.
-pub fn unreadable(name: &str) -> String {
-    i18n::trf("Couldn't read {name}.", &[("name", &name)])
-}
-
-/// The largest file read in the browser: wasm has at most 4 GiB of memory, and a file's contents
-/// are held about three times on their way to `file.open` (the bytes, base64, decoded again).
-/// As large as one member of a `.figcraft` file may be.
-const MAX_BROWSER_FILE: f64 = (512u64 << 20) as f64;
-
-/// Checks a file of `size` bytes before the browser reads it (`Err`: what to tell the user).
-pub fn browser_can_read(name: &str, size: f64) -> Result<(), String> {
-    if size.is_nan() || size > MAX_BROWSER_FILE {
-        return Err(i18n::trf("{name} is too large to open in the browser (over 512 MB).", &[("name", &name)]));
-    }
-    Ok(())
-}
+pub(crate) use clock::repaint_in;
+pub use clock::{AUTO_SAVE_SECS, AUTOSAVE_SECS, FrameClock, ToastClock};
+pub(crate) use open::{drop_overlay, dropped_bytes, is_document, opens};
+pub use services::{ContentsFuture, DialogFuture, NoServices, ReadFuture, Services, browser_can_read, egui_copy_png, egui_copy_text, unreadable};
+use services::{DialogDone, PickFuture, Picked, RepaintWaker};
+pub use state::{
+    AutoSaveEncoding, CANVAS_MIN, LEFT_PANEL, LeftTab, MobilePanel, NARROW_WIDTH, PANEL_DEFAULT, RIGHT_PANEL, RightTab, TitleBar, fit_panels,
+};
 
 /// A native dialog in flight. The app keeps working while it is open, so its result goes to the
 /// file and window it was opened for, not to whichever is in front when it closes.
@@ -408,147 +303,6 @@ struct PendingDialog {
     window: u64,
 }
 
-/// Wakes the main window, which hands the result on to the window it belongs to.
-struct RepaintWaker(egui::Context);
-impl Wake for RepaintWaker {
-    fn wake(self: Arc<Self>) {
-        self.0.request_repaint_of(egui::ViewportId::ROOT);
-    }
-
-    fn wake_by_ref(self: &Arc<Self>) {
-        self.0.request_repaint_of(egui::ViewportId::ROOT);
-    }
-}
-
-/// No-op services (tests, headless screenshots).
-pub struct NoServices;
-impl Services for NoServices {}
-
-/// Put `text` on the system clipboard through egui's platform output. Native integrations handle
-/// it directly; the browser shell writes it while handling the copy event.
-pub fn egui_copy_text(ctx: &egui::Context, text: &str) {
-    ctx.copy_text(text.to_string());
-}
-
-/// Put a straight-RGBA image on the system clipboard through egui's output (see
-/// [`egui_copy_text`]); a buffer that doesn't match its size is dropped.
-pub fn egui_copy_png(ctx: &egui::Context, w: u32, h: u32, rgba: &[u8]) {
-    let (w, h) = (w as usize, h as usize);
-    if w.checked_mul(h).and_then(|n| n.checked_mul(4)) != Some(rgba.len()) {
-        return;
-    }
-    ctx.copy_image(egui::ColorImage::from_rgba_unmultiplied([w, h], rgba));
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
-pub enum RightTab {
-    Design,
-    Prototype,
-    Inspect,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
-pub enum LeftTab {
-    File,
-    Assets,
-}
-
-/// The window's title bar.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
-pub enum TitleBar {
-    /// The system draws it (and the browser): the tab strip sits below.
-    #[default]
-    Native,
-    /// A frameless window: the tab strip is the title bar, with our own window buttons and edges.
-    Custom,
-    /// macOS: the system's window buttons inset at the left of the tab strip.
-    Inset,
-}
-
-/// How often open documents get an autosave checkpoint (seconds).
-pub const AUTOSAVE_SECS: f64 = 30.0 * 60.0;
-
-/// Most changed layers whose names are checked for CJK scripts one by one (beyond: all of them).
-const CJK_CHANGES: usize = 10_000;
-
-/// With auto-save on: how long after a file last changed it is saved, and how long a failed save
-/// waits before trying again (seconds).
-pub const AUTO_SAVE_SECS: f64 = 3.0;
-const AUTO_SAVE_RETRY_SECS: f64 = 60.0;
-
-/// A file being encoded for auto-save: its snapshot and, once done, its bytes.
-pub type AutoSaveEncoding = std::thread::JoinHandle<(figcraft_engine::cmd::file::FileSnapshot, figcraft_engine::Result<Vec<u8>>)>;
-
-/// How long a toast shows (seconds).
-const TOAST_SECS: f64 = 3.0;
-
-/// How long a toast has been showing ([`UiState::toast`]).
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum ToastClock {
-    /// Raised, not drawn yet.
-    Raised,
-    /// Drawn once; the next frame starts the clock.
-    Drawn,
-    /// Showing since this time (UI clock, seconds).
-    Since(f64),
-}
-
-/// Draw another frame `secs` from now (nothing else needs drawing until then: an idle window draws
-/// no frames).
-#[track_caller]
-pub(crate) fn repaint_in(ctx: &egui::Context, secs: f64) {
-    if secs.is_finite() {
-        ctx.request_repaint_after(std::time::Duration::from_secs_f64(secs.max(0.0)));
-    }
-}
-
-/// A monotonic clock for background work (autosave, recovery, capture deadlines).
-///
-/// `Context::input(|i| i.time)` is the UI pass's time and is stale in `run_logic`; wall-clock time
-/// can jump. `web_time::Instant` is monotonic on native and in the browser. Tests drive deadlines
-/// directly with [`FrameClock::set_test_now`].
-pub struct FrameClock {
-    origin: web_time::Instant,
-    test_now: Option<f64>,
-}
-
-impl Default for FrameClock {
-    /// Start the frame clock at the current web time with no injected test time.
-    fn default() -> Self {
-        Self { origin: web_time::Instant::now(), test_now: None }
-    }
-}
-
-impl FrameClock {
-    /// Seconds since the app started (or the injected test time).
-    pub fn now(&self) -> f64 {
-        self.test_now.unwrap_or_else(|| self.origin.elapsed().as_secs_f64())
-    }
-
-    /// Set a fake monotonic time (tests); `None` returns to the real clock.
-    pub fn set_test_now(&mut self, secs: Option<f64>) {
-        self.test_now = secs;
-    }
-}
-
-/// The side panels' widths: the least and most a drag of their edge gives, what a double-click on
-/// the edge puts back, and how much of the window they leave the canvas.
-pub const LEFT_PANEL: std::ops::RangeInclusive<f32> = 200.0..=480.0;
-pub const RIGHT_PANEL: std::ops::RangeInclusive<f32> = 240.0..=480.0;
-pub const PANEL_DEFAULT: f32 = 240.0;
-/// Windows narrower than this (logical points: phones, portrait tablets) show one side panel at a
-/// time over the canvas, opened from two buttons, instead of both beside it.
-pub const NARROW_WIDTH: f32 = 760.0;
-/// What an open side panel leaves of a narrow window: the column of panel buttons.
-const MOBILE_STRIP: f32 = 48.0;
-
-/// The side panel a narrow window shows.
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum MobilePanel {
-    Left,
-    Right,
-}
-
 impl UiState {
     /// Opens the left panel; a narrow window shows it in place of the right one.
     pub fn open_left_panel(&mut self) {
@@ -564,21 +318,6 @@ impl UiState {
         }
     }
 }
-pub const CANVAS_MIN: f32 = 160.0;
-
-/// The widths the side panels are drawn at in `avail` points (the window less the icon rail), from
-/// the widths asked for (none while a panel is closed, which takes no room): each within its
-/// limits, and narrower in a small window so the canvas keeps [`CANVAS_MIN`] (the right panel
-/// gives way last).
-pub fn fit_panels(avail: f32, left: Option<f32>, right: Option<f32>) -> (f32, f32) {
-    let fit = |w: f32, range: &std::ops::RangeInclusive<f32>, room: f32| {
-        let w = if w.is_finite() { w } else { PANEL_DEFAULT };
-        w.clamp(*range.start(), room.clamp(*range.start(), *range.end()))
-    };
-    let left_min = left.map_or(0.0, |_| *LEFT_PANEL.start());
-    let right = right.map_or(0.0, |r| fit(r, &RIGHT_PANEL, avail - left_min - CANVAS_MIN));
-    (left.map_or(0.0, |l| fit(l, &LEFT_PANEL, avail - right - CANVAS_MIN)), right)
-}
 
 /// UI-only state (serialisable for `ui.inspect`).
 pub struct UiState {
@@ -982,1398 +721,6 @@ pub struct FigApp {
 /// What to do with the result of a command run in the background.
 pub type Done = Box<dyn FnOnce(&mut FigApp, &egui::Context, Value)>;
 
-impl FigApp {
-    /// Construct `FigApp` from a session and services, taking panel widths and pages height
-    /// from preferences and initializing UI, canvas, clocks, capture/IME and transient channel
-    /// state.
-    pub fn new(session: Session, services: Box<dyn Services>) -> Self {
-        // The main window's panels open as wide as they were left.
-        let (left_width, right_width) = session.prefs.panel_widths;
-        let pages_height = session.prefs.pages_height;
-        Self {
-            ui: UiState { left_width, right_width, pages_height, ..UiState::default() },
-            session,
-            canvas: canvas::CanvasState::default(),
-            services,
-            worker: None,
-            fonts_installed: false,
-            script_fonts: None,
-            cjk_checked: None,
-            language: None,
-            field_focus: false,
-            panels_unsaved: false,
-            control_queue: Vec::new(),
-            control_input: Vec::new(),
-            frame_stats: frame_stats::FrameStats::default(),
-            windows: windows::Windows::default(),
-            window_requests: Vec::new(),
-            waiting: Vec::new(),
-            pending_dialog: None,
-            ui_context: None,
-            automation_roots: None,
-            control_input_doc: None,
-            control_synthetic: false,
-            input_acks: Vec::new(),
-            applied_acks: Vec::new(),
-            applied_input: None,
-            control_input_queued: false,
-            applied_frame: None,
-            clock: FrameClock::default(),
-            capture: control::CaptureState::default(),
-            logic_ticked: false,
-            ui_frame_stamp: None,
-            ime: egui::ime_context::ImeContextTracker::new(),
-            updates_rt: updates_ui::Runtime::default(),
-            #[cfg(test)]
-            ime_observations: 0,
-        }
-    }
-
-    /// Dismiss the composer after a successful switch away from the Comment tool.
-    pub(crate) fn clear_comment_draft_after_tool_set(&mut self, id: &str, succeeded: bool) {
-        if id == "tool.set" && succeeded && self.session.tool.tool != figcraft_engine::tools::ToolId::Comment {
-            self.ui.comments.draft = None;
-        }
-    }
-
-    /// Run a command, surfacing errors as a toast. Returns the result.
-    pub fn run(&mut self, id: &str, params: Value) -> Option<Value> {
-        let layers_generation = self.session.clipboard.layers_generation;
-        let r = self.session.execute(id, &params);
-        self.clear_comment_draft_after_tool_set(id, r.is_ok());
-        self.handle_ui_requests();
-        self.invalidate_synthetic_copy(layers_generation);
-        // A command may change the file the window shows (`doc.switch`, `doc.nextTab`,
-        // `file.open`/`file.close`). Record that presentation before returning, so an in-flight
-        // screenshot admitted on the old file cannot accept pixels from the new one.
-        self.observe_presentation();
-        r.map_err(|e| self.failed(id, &e)).ok()
-    }
-
-    /// A programmatic command that changed the engine clipboard never wrote the system clipboard:
-    /// forget the old system mirror so a later user paste does not trust it as our own copy.
-    /// `before` is the layers generation captured before the command ran.
-    pub(crate) fn invalidate_synthetic_copy(&mut self, before: u64) {
-        if self.control_synthetic && self.session.clipboard.layers_generation != before {
-            self.ui.last_copy = None;
-        }
-    }
-
-    /// Record the file the window drawing now shows, with a monotonic generation that changes on
-    /// every switch (an A→B→A switch is two generations, never the admitted one again).
-    pub(crate) fn observe_presentation(&mut self) {
-        let window = self.windows.current;
-        self.windows.presentation(&self.session, window);
-    }
-
-    /// [`run`](Self::run) for something the user did (a dialog, a drop, a paste, a recent file):
-    /// a file it imports shows its import report. Programmatic calls use `run` and never open one.
-    pub fn run_user(&mut self, id: &str, params: Value) -> Option<Value> {
-        let result = self.run(id, params.clone());
-        if let Some(result) = &result {
-            import_report::capture(self, id, &params, result);
-        }
-        missing_fonts::check_later(self, id, result.as_ref());
-        result
-    }
-
-    /// Show command `id`'s error.
-    fn failed(&mut self, id: &str, e: &figcraft_engine::EngineError) {
-        let msg = e.to_string();
-        log::warn!("{id}: {msg}");
-        self.show_error(msg);
-    }
-
-    /// Show an error as a toast, kept as the last error.
-    pub(crate) fn show_error(&mut self, msg: String) {
-        self.toast(msg.clone());
-        self.ui.last_error = Some(msg);
-    }
-
-    /// Run a command that may talk to a server without waiting for it (the engine's
-    /// [`start_background`](Session::start_background)): `done` gets the result, at once or when
-    /// the answer arrives (the network wakes the window then); errors show as with [`run`](Self::run).
-    /// [`Session::waiting_for`] tells the panels to show that it's on its way.
-    pub fn run_background(&mut self, ctx: &egui::Context, id: &str, params: Value, done: Done) {
-        self.waiting.retain(|(c, _)| c != id);
-        let r = self.session.start_background(id, params);
-        self.handle_ui_requests();
-        match r {
-            Ok(Some(v)) => done(self, ctx, v),
-            Ok(None) => self.waiting.push((id.to_string(), done)),
-            Err(e) => self.failed(id, &e),
-        }
-    }
-
-    /// Stop waiting for command `id` (Cancel, or its window closed): its answer is dropped.
-    pub fn cancel_background(&mut self, id: &str) {
-        self.session.cancel_background(id);
-        self.waiting.retain(|(c, _)| c != id);
-    }
-
-    /// Hand the results of background commands that finished to what's waiting for them.
-    fn background_done(&mut self, ctx: &egui::Context) {
-        while let Some((id, r)) = self.session.take_background_done() {
-            self.handle_ui_requests();
-            let done = self.waiting.iter().position(|(c, _)| *c == id).map(|i| self.waiting.remove(i).1);
-            match (r, done) {
-                (Ok(v), Some(done)) => done(self, ctx, v),
-                (Ok(_), None) => {}
-                (Err(e), _) => self.failed(&id, &e),
-            }
-        }
-    }
-
-    /// Show what `command params` would do on the canvas as a live preview (`text.preview`) while
-    /// a font family, font style, text style, named instance or axis slider is hovered or dragged. Call it every frame
-    /// the preview should stay: it ends on the first frame nothing asks for it.
-    pub fn preview_text(&mut self, ctx: &egui::Context, command: &str, params: Value) {
-        self.ui.text_preview_wanted = true;
-        let revision = self.session.ds().map_or(0, |d| d.revision);
-        if let Some((c, p, rev)) = &self.ui.text_preview
-            && c == command
-            && *p == params
-            && (*rev == revision || figcraft_engine::textpreview::active(&self.session))
-        {
-            return;
-        }
-        let shown = self.session.execute("text.preview", &json!({"command": command, "params": params})).is_ok();
-        let revision = self.session.ds().map_or(0, |d| d.revision);
-        self.ui.text_preview = shown.then(|| (command.to_string(), params, revision));
-        // The canvas drew before the panels: show the preview next frame.
-        ctx.request_repaint();
-    }
-
-    /// End the live text preview the panels show (Escape, or nothing hovered any more).
-    pub fn end_text_preview(&mut self, ctx: &egui::Context) {
-        if self.ui.text_preview.take().is_some() {
-            let _ = self.session.execute("text.endPreview", &json!({}));
-            ctx.request_repaint();
-        }
-    }
-
-    /// Dev Mode (the Inspect tab): the canvas measures on hover without Alt and edits nothing;
-    /// entering it ends editing text or vectors.
-    fn sync_dev_mode(&mut self) {
-        let dev = self.ui.right_tab == RightTab::Inspect;
-        if dev && !self.session.tool.dev_mode {
-            let _ = self.session.drop_gesture();
-            let editing = self.session.ds().map(|d| (d.text_edit.is_some(), d.vector_edit.is_some())).unwrap_or_default();
-            for (on, cmd) in [(editing.0, "text.edit.end"), (editing.1, "vector.edit.end")] {
-                if on {
-                    self.run(cmd, json!({}));
-                }
-            }
-        }
-        self.session.tool.dev_mode = dev;
-    }
-
-    /// Leaving Design ends a pen path as Escape does and goes back to Move: Prototype and Inspect
-    /// don't draw (#307). Checked as the frame starts (the control channel) and after the panels
-    /// and shortcuts (the mode switcher, the tabs, Shift+E/Shift+D), before the canvas sees more.
-    fn end_pen_outside_design(&mut self) {
-        if self.ui.right_tab == self.ui.last_right_tab {
-            return;
-        }
-        self.ui.last_right_tab = self.ui.right_tab;
-        if self.ui.right_tab != RightTab::Design && self.session.tool.tool == figcraft_engine::tools::ToolId::Pen {
-            self.run("tool.set", json!({"tool": "move"}));
-        }
-    }
-
-    /// Once a frame, after the panels: a preview nothing asked for this frame ends.
-    fn end_unwanted_text_preview(&mut self, ctx: &egui::Context) {
-        if !std::mem::take(&mut self.ui.text_preview_wanted) {
-            self.end_text_preview(ctx);
-        }
-    }
-
-    /// Finish the frame that applies an injected batch: acknowledge it once the pass is presented,
-    /// and stop fencing the system clipboard. Only the viewport whose batch this frame took acts.
-    pub(crate) fn end_input_frame(&mut self, ctx: &egui::Context) {
-        if self.applied_frame != Some(ctx.viewport_id()) {
-            return;
-        }
-        self.applied_input = None;
-        if ctx.will_discard() {
-            // Keep `applied_frame`/`applied_acks`: the rerun pass must present (and acknowledge)
-            // the same frame without replaying the input.
-            return;
-        }
-        self.applied_frame = None;
-        for ack in self.applied_acks.drain(..) {
-            let _ = ack.tx.send(ack.reply);
-        }
-        self.control_synthetic = false;
-    }
-
-    /// The app's monotonic clock in seconds, also usable from logic-only callbacks (recovery,
-    /// control deadlines). Never `ctx.input(i.time)`, which is stale there.
-    pub fn now_secs(&self) -> f64 {
-        self.clock.now()
-    }
-
-    /// Queue raw input injected through the control channel for the window drawing next, tagged
-    /// with the document it belongs to (a batch is dropped if another file is active by then).
-    pub(crate) fn push_control_input(&mut self, events: Vec<egui::Event>) -> bool {
-        if events.is_empty() {
-            return false;
-        }
-        let doc = self.session.docs.get(self.session.active).map(|d| d.uid);
-        if !self.control_input.is_empty() && self.control_input_doc != doc {
-            // A queued batch belongs to the file that was open when it was injected; it cannot be
-            // merged with one for the file showing now. Its acknowledgement says so.
-            self.control_input.clear();
-            let viewport = crate::windows::viewport(self.windows.current);
-            crate::windows::fail_input_acks(self, viewport);
-        }
-        // Always the live pane vector: while a child window draws, `windows::enter` has swapped
-        // its pane into the app, and `leave` swaps these events back into that pane.
-        self.control_input.extend(events);
-        self.control_input_doc = doc;
-        self.control_synthetic = true;
-        true
-    }
-
-    /// The acknowledgements waiting for `viewport`'s input batch (other windows keep theirs).
-    pub(crate) fn take_input_acks(&mut self, viewport: egui::ViewportId) -> Vec<PendingAck> {
-        let mut mine = Vec::new();
-        for ack in std::mem::take(&mut self.input_acks) {
-            if ack.viewport == viewport {
-                mine.push(ack);
-            } else {
-                self.input_acks.push(ack);
-            }
-        }
-        mine
-    }
-
-    /// Put `text` on the system clipboard. Input injected through the control channel never
-    /// replaces what the user copied: this is the one write path every copy command goes through.
-    pub(crate) fn clipboard_set_text(&mut self, text: &str) {
-        if self.control_synthetic {
-            return;
-        }
-        self.services.clipboard_set_text(text);
-    }
-
-    /// [`Self::clipboard_set_text`] for an image (straight RGBA).
-    pub(crate) fn clipboard_set_png(&mut self, width: u32, height: u32, rgba: &[u8]) {
-        if self.control_synthetic {
-            return;
-        }
-        self.services.clipboard_set_png(width, height, rgba);
-    }
-
-    pub fn toast(&mut self, msg: impl Into<String>) {
-        self.ui.toast = Some((msg.into(), ToastClock::Raised));
-    }
-
-    /// Say that `n` documents left unsaved by a crash were opened again from recovery copies.
-    pub fn note_recovered(&mut self, n: usize) {
-        if n > 0 {
-            self.toast(i18n::trn("Recovered {n} unsaved files after the app quit unexpectedly: save them to keep them", n, &[]));
-        }
-    }
-
-    /// Act on UI requests queued by commands (dialogs, panels).
-    pub fn handle_ui_requests(&mut self) {
-        let reqs = std::mem::take(&mut self.session.ui_requests);
-        for r in reqs {
-            match r.kind.as_str() {
-                "dialog.about" => {
-                    self.ui.about = true;
-                    self.ui.about_tab = dialogs::AboutTab::About;
-                }
-                "dialog.preferences" => self.ui.preferences = true,
-                "dialog.missingFonts" => missing_fonts::request(self),
-                "panel.shortcuts" => self.ui.shortcuts_panel = !self.ui.shortcuts_panel,
-                "palette.actions" => menus::toggle_palette(&mut self.ui),
-                "panel.design" if self.session.doc().is_ok_and(figcraft_engine::board::is_board) => self.ui.board_panel = !self.ui.board_panel,
-                "panel.design" => self.ui.right_tab = RightTab::Design,
-                "board.editText" => {
-                    if let Some(id) = r.data.get("id").and_then(figcraft_engine::params::id_of)
-                        && let Err(e) = figcraft_engine::board::edit_text(&mut self.session, id)
-                    {
-                        self.toast(e.to_string());
-                    }
-                }
-                "panel.prototype" => self.ui.right_tab = RightTab::Prototype,
-                "panel.designPrototype" => {
-                    self.ui.right_tab = if self.ui.right_tab == RightTab::Prototype { RightTab::Design } else { RightTab::Prototype };
-                }
-                "panel.devMode" => {
-                    self.ui.right_tab = if self.ui.right_tab == RightTab::Inspect { RightTab::Design } else { RightTab::Inspect };
-                }
-                "panel.leftSidebar" => {
-                    let shown = if self.ui.narrow { self.ui.mobile_panel == Some(MobilePanel::Left) } else { !self.ui.left_collapsed };
-                    if shown {
-                        self.ui.close_left_panel();
-                    } else {
-                        self.ui.open_left_panel();
-                    }
-                }
-                "panel.widths" => {
-                    let width = |k: &str| r.data.get(k).and_then(Value::as_f64).map(|w| w as f32);
-                    let (left, right) = (width("left"), width("right"));
-                    let reset = left.is_none() && right.is_none();
-                    self.set_panel_widths(
-                        left.unwrap_or(if reset { PANEL_DEFAULT } else { self.ui.left_width }),
-                        right.unwrap_or(if reset { PANEL_DEFAULT } else { self.ui.right_width }),
-                    );
-                    self.services.save_prefs(&self.session.prefs);
-                }
-                "focus.region" => self.ui.nav.step(r.data.get("step").and_then(Value::as_i64).unwrap_or(1).clamp(-4, 4) as i32),
-                "panel.layers" => self.ui.left_tab = LeftTab::File,
-                "panel.assets" => {
-                    self.ui.left_tab = LeftTab::Assets;
-                    self.ui.open_left_panel();
-                    self.ui.versions = Default::default();
-                }
-                "panel.versionHistory" => versions::open(self),
-                "view.devCompare" => {
-                    self.ui.dev.compare = dev_compare::CompareView::requested(&r.data);
-                }
-                "panel.libraries" => {
-                    self.ui.left_tab = LeftTab::Assets;
-                    self.ui.open_left_panel();
-                    self.ui.libraries = true;
-                }
-                "home" => self.ui.home = true,
-                "home.templates" => {
-                    self.ui.home = true;
-                    self.ui.home_view.section = home::Section::Templates;
-                }
-                "home.gettingStarted" => {
-                    self.ui.home = true;
-                    self.ui.home_view.section = home::Section::Recents;
-                    self.services.save_prefs(&self.session.prefs);
-                }
-                "dialog.saveAs" => self.save_as_dialog(),
-                "dialog.colorProfile" => self.ui.color_profile = self.session.doc().ok().map(|d| d.color_profile),
-                "present" => {
-                    if let Some(start) = r.data.get("start").and_then(figcraft_engine::params::id_of) {
-                        tabs::open_present(self, start);
-                    }
-                }
-                "present.options" => {
-                    let v = &mut self.ui.present_view;
-                    if let Some(s) = r.data.get("scale").and_then(|s| s.as_str()).and_then(present::PresentScale::parse) {
-                        v.scale = s;
-                    }
-                    if let Some(f) = r.data.get("deviceFrame").and_then(|f| f.as_bool()) {
-                        v.device_frame = f;
-                    }
-                    if let Some(h) = r.data.get("hotspotHints").and_then(|h| h.as_bool()) {
-                        v.hotspot_hints = h;
-                    }
-                    if let Some(i) = r.data.get("inspect").and_then(|i| i.as_bool()) {
-                        v.inspect = i;
-                    }
-                    if let Some(p) = self.ui.present.as_mut() {
-                        p.view.device_frame = v.device_frame;
-                        p.view.hotspot_hints = v.hotspot_hints;
-                        p.view.inspect = v.inspect;
-                        p.set_scale(v.scale);
-                    }
-                }
-                "preview" => {
-                    if let Some(start) = r.data.get("start").and_then(figcraft_engine::params::id_of) {
-                        self.ui.preview = Some(present::Pane::new(start, &self.session));
-                    }
-                }
-                "preview.close" => self.ui.preview = None,
-                "open.help" => self.services.open_url("https://getartcraft.com/apps/figcraft"),
-                "layers.collapseAll" => layers::collapse_all(self),
-                "contextMenu" => self.ui.key_menu = true,
-                "selectArea" => self.start_key_box(),
-                "canvas.renameLabel" => {
-                    self.ui.rename_label = r.data.get("id").and_then(figcraft_engine::params::id_of).map(|id| layers::Rename { id, start: true });
-                }
-                "layers.rename" => {
-                    let ids: Vec<NodeId> =
-                        r.data.get("ids").and_then(Value::as_array).into_iter().flatten().filter_map(figcraft_engine::params::id_of).collect();
-                    if ids.len() > 1 {
-                        dialogs::open_batch_rename(self, &ids);
-                    } else {
-                        layers::start_rename(self, &ids);
-                    }
-                }
-                "comment.open" => {
-                    if let Some(id) = r.data.get("id").and_then(Value::as_u64) {
-                        self.ui.comments.show(id);
-                    }
-                }
-                "comment.new" => {
-                    let x = r.data.get("x").and_then(|v| v.as_f64()).unwrap_or(0.0);
-                    let y = r.data.get("y").and_then(|v| v.as_f64()).unwrap_or(0.0);
-                    comments::start_draft(self, x, y);
-                }
-                "dialog.unsaved" => self.toast(i18n::tr("This file has unsaved changes")),
-                "dialog.plugins" => self.ui.plugins_window = true,
-                "dialog.pluginSave" => plugins_ui::save_file(self, &r.data),
-                "dialog.cursorChat" => live::open_chat(self),
-                "window.new" | "window.focus" | "window.fullscreen" => self.window_requests.push(r),
-                _ => {}
-            }
-        }
-        if let Some(m) = self.session.message.take() {
-            self.toast(m);
-        }
-    }
-
-    /// Set the widths asked for this window's side panels (within their limits); the main
-    /// window's are kept in the preferences.
-    pub fn set_panel_widths(&mut self, left: f32, right: f32) {
-        let within = |w: f32, range: std::ops::RangeInclusive<f32>| if w.is_finite() { w.clamp(*range.start(), *range.end()) } else { PANEL_DEFAULT };
-        (self.ui.left_width, self.ui.right_width) = (within(left, LEFT_PANEL), within(right, RIGHT_PANEL));
-        if self.windows.current == 0 {
-            self.session.prefs.panel_widths = (self.ui.left_width, self.ui.right_width);
-        }
-    }
-
-    /// The edge between a side panel and the canvas, at `x` down `rows`: dragging it sizes the
-    /// panel (`grows`: +1 for the left panel, whose edge is on its right, −1 for the right one), a
-    /// double-click puts back the default width. Returns the width asked for, when it changed.
-    fn panel_edge(ui: &mut egui::Ui, name: &str, x: f32, rows: egui::Rangef, width: f32, grows: f32) -> Option<f32> {
-        let grab = ui.style().interaction.resize_grab_radius_side;
-        let rect = egui::Rect::from_x_y_ranges(x - grab..=x + grab, rows);
-        let id = egui::Id::unique(("panel_edge", name));
-        // Not focusable: an edge is a pointer target, so it must not take Tab/F6 focus from the
-        // panels' controls (see `a11y::focusables`).
-        let resp = ui.interact(rect, id, egui::Sense::CLICK | egui::Sense::DRAG);
-        if resp.hovered() || resp.dragged() {
-            ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
-            ui.painter().vline(x, rows, egui::Stroke::new(2.0, theme::ACCENT));
-        }
-        if resp.double_clicked() {
-            return Some(PANEL_DEFAULT);
-        }
-        // The edge stays under the pointer where it was grabbed (also back from past a limit).
-        let at = resp.interact_pointer_pos().filter(|_| resp.dragged())?;
-        if resp.drag_started() {
-            let pressed = ui.input(|i| i.pointer.press_origin()).unwrap_or(at);
-            ui.data_mut(|d| d.insert_temp(id, pressed.x - x));
-        }
-        let grabbed: f32 = ui.data(|d| d.get_temp(id)).unwrap_or(0.0);
-        let w = width + (at.x - grabbed - x) * grows;
-        (w != width).then_some(w)
-    }
-
-    pub fn save_as_dialog(&mut self) {
-        if self.services.downloads() {
-            if let Some(r) = self.run("file.saveAs", json!({"data": true}))
-                && self.download(r["name"].as_str().unwrap_or_default(), &r)
-            {
-                self.run("file.markSaved", json!({}));
-                dialogs::file_saved(self, &r);
-            }
-            return;
-        }
-        let Ok(name) = self.session.doc().map(|d| d.name.clone()) else { return };
-        self.pick_save(i18n::tr("Save as"), &format!("{name}.figcraft"), &["figcraft", "fig"], |app, mut p| {
-            if p.extension().is_none_or(OsStr::is_empty) {
-                if !p.set_extension("figcraft") {
-                    app.toast(i18n::tr("Use the .figcraft or .fig extension."));
-                    return;
-                }
-                // This name wasn't confirmed by the system dialog: don't replace an existing file.
-                match p.try_exists() {
-                    Ok(false) => {}
-                    Ok(true) => {
-                        app.toast(i18n::tr("A .figcraft file with this name already exists. Choose its full name to confirm replacement."));
-                        return;
-                    }
-                    Err(e) => {
-                        app.toast(e.to_string());
-                        return;
-                    }
-                }
-            } else if !p.extension().and_then(OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("figcraft") || e.eq_ignore_ascii_case("fig")) {
-                app.toast(i18n::tr("Use the .figcraft or .fig extension."));
-                return;
-            }
-            if let Some(r) = app.run("file.saveAs", json!({"path": p.to_string_lossy()})) {
-                dialogs::file_saved(app, &r);
-            }
-        });
-    }
-
-    pub fn save(&mut self) {
-        // A branch tab saves its main file.
-        let tab = figcraft_engine::branches::file_tab(&self.session);
-        // A path ending in .fig is never saved over silently: a .fig destination is an export copy.
-        let native_path = self
-            .session
-            .docs
-            .get(tab)
-            .and_then(|d| d.path.as_deref())
-            .is_some_and(|path| !Path::new(path).extension().and_then(OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("fig")));
-        if native_path {
-            if self.run("file.save", json!({})).is_some() {
-                self.toast(i18n::tr("Saved"));
-            }
-        } else {
-            self.save_as_dialog();
-        }
-    }
-
-    pub fn open_dialog(&mut self) {
-        // Opening needs no file in front: it goes ahead even if that file closed meanwhile.
-        self.pick_file(i18n::tr("Open"), OPEN_EXTENSIONS, false, |app, file| {
-            if app.run_user("file.open", file).is_some() {
-                app.ui.home = false;
-            }
-        });
-    }
-
-    pub fn import_dialog(&mut self, place: bool) {
-        let exts: &[&str] = if place {
-            &["png", "jpg", "jpeg", "webp", "gif", "tif", "tiff"]
-        } else {
-            &["svg", "png", "jpg", "jpeg", "webp", "gif", "tif", "tiff", "figcraft", "fig", "sketch"]
-        };
-        let title = if place { i18n::tr("Place image") } else { i18n::tr("Import") };
-        self.pick_file(title, exts, true, |app, file| {
-            app.run_user("file.import", file);
-        });
-    }
-
-    /// Pick a file to open or import; `done` gets it as `file.open` and `file.import` take it (a
-    /// path, or the name and contents where the platform has no paths). `pin`: as
-    /// [`FigApp::pick_open`]'s file in front.
-    fn pick_file(&mut self, title: &str, exts: &[&str], pin: bool, done: impl FnOnce(&mut FigApp, Value) + 'static) {
-        self.start_pick(
-            |services| -> PickFuture {
-                match services.pick_open_contents(title, exts) {
-                    Some(read) => {
-                        Box::pin(async move { read.await.map(|r| r.map_or_else(Picked::Unreadable, |(name, bytes)| Picked::Contents(name, bytes))) })
-                    }
-                    None => {
-                        let pick = services.pick_open(title, exts);
-                        Box::pin(async move { pick.await.map(Picked::Path) })
-                    }
-                }
-            },
-            pin,
-            move |app, picked| match picked.file_params() {
-                Ok(file) => done(app, file),
-                Err(why) => app.show_error(why),
-            },
-        );
-    }
-
-    /// Pick a file to open. `done` runs with the file in front now back in front (and not at all
-    /// if that file closed meanwhile).
-    pub fn pick_open(&mut self, title: &str, exts: &[&str], done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
-        self.start_dialog(|services| services.pick_open(title, exts), true, done);
-    }
-
-    /// Pick where to save; `done` runs as [`FigApp::pick_open`]'s does.
-    pub fn pick_save(&mut self, title: &str, name: &str, exts: &[&str], done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
-        self.start_dialog(|services| services.pick_save(title, name, exts), true, done);
-    }
-
-    /// Hand a command result's base64 `data` over as a download named `name`, where the platform
-    /// saves by downloads rather than save dialogs (the browser, #969). Says so when nothing arrived.
-    pub(crate) fn download(&mut self, name: &str, result: &Value) -> bool {
-        use base64::Engine as _;
-        let bytes = result["data"].as_str().and_then(|d| base64::engine::general_purpose::STANDARD.decode(d).ok());
-        if bytes.is_some_and(|b| self.services.download(name, &b)) {
-            return true;
-        }
-        self.toast(i18n::trf("Couldn't download {name}", &[("name", &name)]));
-        false
-    }
-
-    /// Pick a folder; `done` runs as [`FigApp::pick_open`]'s does.
-    pub fn pick_folder(&mut self, title: &str, done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
-        self.start_dialog(|services| services.pick_folder(title), true, done);
-    }
-
-    /// Open a native dialog from the window drawing now, for the file in front (`pin`).
-    fn start_dialog(&mut self, start: impl FnOnce(&mut dyn Services) -> DialogFuture, pin: bool, done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
-        self.start_pick(
-            |services| -> PickFuture {
-                let pick = start(services);
-                Box::pin(async move { pick.await.map(Picked::Path) })
-            },
-            pin,
-            move |app, picked| {
-                if let Picked::Path(p) = picked {
-                    done(app, p);
-                }
-            },
-        );
-    }
-
-    /// [`FigApp::start_dialog`] for any kind of pick.
-    fn start_pick(&mut self, start: impl FnOnce(&mut dyn Services) -> PickFuture, pin: bool, done: impl FnOnce(&mut FigApp, Picked) + 'static) {
-        if self.pending_dialog.is_some() {
-            return;
-        }
-        let doc = if pin { self.session.ds().ok().filter(|d| self.shows(d.uid)).map(|d| d.uid) } else { None };
-        let future = start(self.services.as_mut());
-        self.pending_dialog = Some(PendingDialog { future, picked: None, done: Box::new(done), doc, window: self.windows.current });
-        if let Some(ctx) = &self.ui_context {
-            ctx.request_repaint();
-        }
-    }
-
-    /// Once the dialog has a path, its continuation runs in the window that holds its file, with
-    /// that file in front; then the tab in front before comes back (unless the dialog opened a file).
-    fn poll_dialog(&mut self, ctx: &egui::Context) {
-        let Some(d) = &mut self.pending_dialog else { return };
-        if d.picked.is_none() {
-            let waker = Waker::from(Arc::new(RepaintWaker(ctx.clone())));
-            let Poll::Ready(picked) = d.future.as_mut().poll(&mut TaskContext::from_waker(&waker)) else { return };
-            d.picked = picked;
-        }
-        let (doc, origin, picked) = (d.doc, d.window, d.picked.is_some());
-        let index = doc.map(|u| self.session.docs.iter().position(|ds| ds.uid == u));
-        // Cancelled, or its file closed meanwhile.
-        if !picked || index == Some(None) {
-            self.pending_dialog = None;
-            return;
-        }
-        let window = match doc {
-            Some(u) => self.windows.of(u),
-            None if self.windows.exists(origin) => origin,
-            None => 0,
-        };
-        if window != self.windows.current {
-            ctx.request_repaint_of(windows::viewport(window));
-            return;
-        }
-        let Some(PendingDialog { picked: Some(picked), done, .. }) = self.pending_dialog.take() else { return };
-        let before = self.session.ds().ok().map(|d| d.uid);
-        if let Some(Some(i)) = index {
-            self.session.active = i;
-        }
-        done(self, picked);
-        if doc.is_some()
-            && self.session.ds().ok().map(|d| d.uid) == doc
-            && let Some(i) = before.and_then(|u| self.session.docs.iter().position(|d| d.uid == u))
-        {
-            self.session.active = i;
-        }
-    }
-
-    /// Reduced motion: the preference or the system's setting.
-    pub fn reduce_motion(&self) -> bool {
-        self.session.prefs.reduce_motion || self.services.reduce_motion()
-    }
-
-    /// The CJK, Bengali and Thai scripts the UI shows: the language's, the language picker's (Preferences open),
-    /// typed text's, and those in the open file's names and comments (read when it changes, not
-    /// mid-drag). Nothing is checked once every script has a face.
-    fn cjk_needed(&mut self, ctx: &egui::Context, installed: u8) -> u8 {
-        if installed == cjk::ALL {
-            return installed;
-        }
-        let mut need = i18n::current().map_or(0, |l| cjk::language(l.code));
-        if self.ui.preferences {
-            need |= i18n::languages().iter().filter(|l| cjk::can_show(l.code)).fold(0, |m, l| m | cjk::language(l.code));
-        }
-        need |= ctx.input(|i| {
-            i.events.iter().fold(0, |m, e| match e {
-                egui::Event::Text(t) | egui::Event::Ime(egui::ImeEvent::Preedit { text: t, .. } | egui::ImeEvent::Commit(t)) => m | cjk::scripts(t),
-                _ => m,
-            })
-        });
-        let dragging = ctx.input(|i| i.pointer.any_down());
-        // Pans and zooms change the revision too: only a new version of the document is looked
-        // at, and only the layers it changed (a large file has hundreds of thousands of names).
-        let current = self.session.docs.get(self.session.active).filter(|_| !dragging).map(|d| (d.uid, d.doc.clone()));
-        if let Some((uid, doc)) = current {
-            let before = self.cjk_checked.take().filter(|(u, _)| *u == uid).map(|(_, b)| b);
-            if !before.as_ref().is_some_and(|b| Arc::ptr_eq(b, &doc)) {
-                let mut scan = |s: &str| need |= cjk::scripts(s);
-                scan(&doc.name);
-                match before.as_ref().and_then(|b| doc.changed_ids(b, CJK_CHANGES)) {
-                    Some(ids) => ids.into_iter().filter_map(|id| doc.node(id)).for_each(|n| scan(&n.name)),
-                    None => doc.nodes().for_each(|n| scan(&n.name)),
-                }
-                doc.comments.iter().flat_map(|c| std::iter::once(&c.first).chain(&c.replies)).for_each(|m| {
-                    scan(&m.author);
-                    scan(&m.text);
-                });
-            }
-            self.cjk_checked = Some((uid, doc));
-        }
-        need
-    }
-
-    /// Work safe from a logic-only callback (`App::logic`, which also runs while hidden) and from
-    /// a normal UI pass: consumed control work, live polling, background completions, autosave and
-    /// recovery deadlines. It never reads UI input, so it must not scan events, run shortcuts or
-    /// lay out anything.
-    pub fn background_tick(&mut self, ctx: &egui::Context) {
-        control::background(self, ctx);
-        // What happened in a live session (the network woke us for it).
-        if self.session.live_poll() {
-            if let Some(m) = self.session.message.take() {
-                self.toast(live::failure_text(&m));
-            }
-            self.background_done(ctx);
-        }
-        // Files that arrived without a command (joined, recovered) take the kept View toggles too.
-        self.session.apply_view_prefs();
-        let now = self.clock.now();
-        self.autosave_tick(ctx, now);
-        self.auto_save_tick(ctx, now);
-        updates_ui::tick(self, ctx);
-        self.logic_ticked = true;
-    }
-
-    /// UI-phase setup that needs a real current `Ui`: fonts/language/theme, interface zoom and the
-    /// render worker. Runs once per frame (pass 0) for the main window, and once per frame for
-    /// every child window (`windows::draw`), never on a logic-only tick.
-    fn ui_setup(&mut self, ctx: &egui::Context) {
-        self.viewport_setup(ctx);
-    }
-
-    /// The app-global part of [`Self::ui_setup`] that every window's frame needs: language, fonts,
-    /// theme and `ui.dark`, the render worker, and the interface zoom plan. eframe only calls
-    /// `App::ui` for the root window, so a child must run this itself before it draws; a child that
-    /// only runs while the root is minimised still gets theme switches, CJK faces for its own
-    /// document, and the right `ui.dark` for its tabs and dialogs.
-    pub(crate) fn viewport_setup(&mut self, ctx: &egui::Context) {
-        if self.language.as_ref() != Some(&self.session.prefs.language) {
-            i18n::set(&self.session.prefs.language, self.services.system_language().as_deref());
-            self.language = Some(self.session.prefs.language.clone());
-        }
-        // Screen-reader and bidi language of the UI (fork E17).
-        ctx.set_language(i18n::current().map(|l| l.code.to_string()));
-        if !self.fonts_installed {
-            // Cmd/Ctrl+= / - / 0 zoom the canvas (view.zoomIn, view.zoomOut, view.zoom100): egui's
-            // own keyboard zoom would scale the whole interface on the same keys.
-            ctx.options_mut(|o| o.zoom_with_keyboard = false);
-            // A double-click's window is the platform's (0.5 s, Windows' default), not egui's
-            // stricter 0.3 s: a double-click the OS takes must enter a shape's points too.
-            ctx.memory_mut(|m| m.options.input_options.max_double_click_delay = 0.5);
-            theme::install_fonts(ctx, false, 0);
-            self.fonts_installed = true;
-            // Installed fonts apply from the next frame; a child window draws on here, so ask for
-            // that frame (the root draws nothing on the frame it installs them).
-            ctx.request_repaint();
-        } else if figcraft_text::system_fonts_scanned() {
-            // Once the system fonts are indexed: faces for names in scripts the UI fonts lack, and
-            // for each CJK script once something shows it.
-            let installed = self.script_fonts.map_or(0, |(s, _)| s);
-            let cjk = installed | self.cjk_needed(ctx, installed);
-            // The UI language's script leads the CJK faces, so another language lays them out again.
-            let lang = i18n::current().map_or("en", |l| l.code);
-            if self.script_fonts != Some((cjk, lang)) {
-                self.script_fonts = Some((cjk, lang));
-                theme::install_fonts(ctx, true, cjk);
-            }
-        }
-        // egui's zoom is for the whole app and multiplies each window's own system scale, so the
-        // size is the same relative to every screen; the main window, whose size can hold a size
-        // back, sets it. The browser keeps its own zoom. Every window records its own plan (the
-        // Preferences warning and `ui.inspect` read it), from its own size.
-        {
-            let window_px = ctx.content_rect().size() * ctx.pixels_per_point();
-            let size = if cfg!(target_arch = "wasm32") { 1.0 } else { self.session.prefs.ui_scale };
-            let plan = ui_scale::plan(size, ctx.native_pixels_per_point(), Some((window_px.x, window_px.y)));
-            if ctx.viewport_id() == egui::ViewportId::ROOT {
-                ctx.set_zoom_factor(plan.zoom);
-            }
-            self.ui.ui_scale = plan;
-        }
-        let dark = match self.session.prefs.theme.as_str() {
-            "dark" => true,
-            // The active visuals were set by us last frame (possibly for a manual theme). Read the
-            // integration's OS theme; winit reports none on Linux and the BSDs, where the platform
-            // services' colour scheme answers instead. Without either, keep the light fallback.
-            "system" => ctx.system_theme().map(|t| t == egui::Theme::Dark).or_else(|| self.services.system_dark()).unwrap_or(false),
-            _ => false,
-        };
-        self.ui.dark = dark;
-        // New files take the theme's page colour (existing pages keep theirs).
-        self.session.set_ui_dark(dark);
-        theme::apply_with(ctx, if dark { theme::Tokens::dark() } else { theme::Tokens::light() }, self.reduce_motion());
-        if self.worker.is_none() {
-            self.worker = Some(render_worker::Worker::new(ctx.clone()));
-        }
-    }
-
-    /// Every [`AUTOSAVE_SECS`], each open document with unsaved changes since its last version
-    /// gets an autosave checkpoint in its version history.
-    fn autosave_tick(&mut self, ctx: &egui::Context, now: f64) {
-        if now < self.ui.next_autosave {
-            // Wake up for it even if nothing else draws a frame by then.
-            repaint_in(ctx, self.ui.next_autosave - now);
-            return;
-        }
-        if self.ui.next_autosave > 0.0 {
-            let active = self.session.active;
-            for i in 0..self.session.docs.len() {
-                self.session.active = i;
-                let _ = self.session.execute("version.autosave", &json!({}));
-            }
-            self.session.active = active;
-        }
-        self.ui.next_autosave = now + AUTOSAVE_SECS;
-        repaint_in(ctx, AUTOSAVE_SECS);
-    }
-
-    /// With auto-save on, files that have a path are saved [`AUTO_SAVE_SECS`] after they last
-    /// changed (not during a gesture, a live preview or while a version is shown). The file is
-    /// encoded on a thread of its own, so a big one doesn't hold up the window, and written here.
-    fn auto_save_tick(&mut self, ctx: &egui::Context, now: f64) {
-        let mut failed = self.auto_save_done();
-        // The browser has no files to save to.
-        let on = !cfg!(target_arch = "wasm32") && self.session.prefs.auto_save;
-        let saving = &self.ui.auto_saving;
-        let due = |d: &&figcraft_engine::DocState| {
-            d.path.as_deref().is_some_and(|p| d.images_lost_saving_to(p).is_none())
-                && d.branch_of.is_none()
-                && d.preview.is_none()
-                && d.is_dirty()
-                && !saving.iter().any(|(uid, _)| *uid == d.uid)
-        };
-        let changes = if on { self.session.docs.iter().filter(due).map(|d| d.revision).reduce(u64::wrapping_add) } else { None };
-        match changes {
-            None => self.ui.auto_save_at = None,
-            Some(changes) => {
-                let at = match self.ui.auto_save_at {
-                    Some((at, c)) if c == changes && failed.is_none() => at,
-                    _ => now + if failed.is_some() { AUTO_SAVE_RETRY_SECS } else { AUTO_SAVE_SECS },
-                };
-                self.ui.auto_save_at = Some((at, changes));
-                if now < at || self.session.docs.iter().any(|d| d.interaction.is_some() || d.text_preview.is_some()) {
-                    // Due but busy: look again in a second.
-                    repaint_in(ctx, if now < at { at - now } else { 1.0 });
-                } else {
-                    self.ui.auto_save_at = None;
-                    let files: Vec<_> =
-                        self.session.docs.iter().filter(due).map(|d| (d.uid, figcraft_engine::cmd::file::FileSnapshot::of(d))).collect();
-                    for (uid, file) in files {
-                        let encode = move || {
-                            let bytes = file.encode();
-                            (file, bytes)
-                        };
-                        match std::thread::Builder::new().name("figcraft-save".into()).spawn(encode) {
-                            Ok(h) => self.ui.auto_saving.push((uid, h)),
-                            Err(e) => {
-                                failed.get_or_insert(e.to_string());
-                                self.ui.auto_save_at = Some((now + AUTO_SAVE_RETRY_SECS, changes));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if !self.ui.auto_saving.is_empty() {
-            // Look again shortly for the files being encoded.
-            repaint_in(ctx, 0.1);
-        }
-        if let Some(e) = failed {
-            self.toast(i18n::trf("Couldn't save automatically: {error}", &[("error", &e)]));
-        }
-    }
-
-    /// Write the files whose auto-save encoding finished; the first error, if one failed.
-    fn auto_save_done(&mut self) -> Option<String> {
-        if self.ui.auto_saving.is_empty() {
-            return None;
-        }
-        let mut failed = None;
-        let done: Vec<_> = self.ui.auto_saving.extract_if(.., |(_, h)| h.is_finished()).collect();
-        for (_, h) in done {
-            let saved = match h.join() {
-                Ok((snapshot, Ok(bytes))) => snapshot.save(&mut self.session, &bytes).map(|_| ()).map_err(|e| e.to_string()),
-                Ok((_, Err(e))) => Err(e.to_string()),
-                Err(_) => Err("the file couldn't be encoded".to_string()),
-            };
-            if let Err(e) = saved {
-                failed.get_or_insert(e);
-            }
-        }
-        failed
-    }
-
-    /// Draw the whole UI: the main window (the other windows draw themselves).
-    pub fn ui(&mut self, ui: &mut egui::Ui) {
-        #[cfg(not(target_arch = "wasm32"))]
-        let t0 = std::time::Instant::now();
-        let ctx = ui.ctx().clone();
-        self.ui_context = Some(ctx.clone());
-        // `App::logic` already ticked this pass; direct harnesses do not call it. The marker only
-        // covers the tick that shares this pass: clearing it here keeps a direct `App::ui` harness
-        // ticking on every frame (it used to tick every other frame).
-        if !std::mem::take(&mut self.logic_ticked) {
-            self.background_tick(&ctx);
-            self.logic_ticked = false;
-        }
-        // Setup once per frame (pass 0), not once per pass and never on a logic-only tick.
-        let stamp = (ctx.viewport_id(), ctx.cumulative_frame_nr());
-        let first = !self.fonts_installed;
-        if ctx.current_pass_index() == 0 && self.ui_frame_stamp != Some(stamp) {
-            self.ui_frame_stamp = Some(stamp);
-            self.frame_stats.record(&ctx);
-            self.ui_setup(&ctx);
-        }
-        if first && self.fonts_installed {
-            // New fonts apply from the next frame; draw nothing until then. Anything taken into
-            // this frame's (undrawn) input waits for the first drawn frame.
-            ctx.request_repaint();
-            if let Some(events) = self.applied_input.take() {
-                self.push_control_input(events);
-            }
-            self.input_acks.append(&mut self.applied_acks);
-            self.applied_frame = None;
-            self.control_synthetic = false;
-            // The next (drawn) frame ticks for itself in a direct harness.
-            self.logic_ticked = false;
-            self.observe_ime(&ctx, false);
-            return;
-        }
-        windows::begin(self, &ctx);
-        let (files, prefs) = (self.session.docs.len(), self.session.prefs.clone());
-        self.frame(ui);
-        windows::settle(self, &ctx, files);
-        if self.session.prefs != prefs {
-            windows::repaint_others(self, &ctx);
-        }
-        windows::show(self, &ctx);
-        // The injected batch was applied by the frame that took it. A discarded sizing pass keeps
-        // its acknowledgement for the presented pass but never replays the input (its side effects
-        // already happened and would otherwise duplicate).
-        self.end_input_frame(&ctx);
-        // Plugins installed, removed or set up are kept at once: a crash doesn't lose them.
-        // So are the owner tokens of files put online.
-        if std::mem::take(&mut self.session.plugins.unsaved) | std::mem::take(&mut self.session.live.unsaved) {
-            self.services.save_prefs(&self.session.prefs);
-        }
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            self.ui.frame_ms = t0.elapsed().as_secs_f64() * 1000.0;
-        }
-    }
-
-    /// Whether the right panel shows: never with the UI `hidden`; always on a design file; on a
-    /// board, which has no prototypes or Dev Mode (its tab stays Design), only when asked for.
-    fn right_panel_shown(&mut self, hidden: bool) -> bool {
-        let board = self.session.doc().is_ok_and(figcraft_engine::board::is_board);
-        if board {
-            self.ui.right_tab = RightTab::Design;
-        }
-        !hidden && (!board || self.ui.board_panel)
-    }
-
-    /// A narrow window's two buttons for the side panels (touch-sized); the open one closes again.
-    fn mobile_buttons(&mut self, ctx: &egui::Context, at: egui::Pos2) {
-        use a11y::Tip as _;
-        let t = theme::Tokens::get(ctx);
-        egui::Area::new(egui::Id::unique("mobile_panel_buttons")).order(egui::Order::Foreground).fixed_pos(at).show(ctx, |ui| {
-            for (side, icon, name) in
-                [(MobilePanel::Left, icons::Icon::Layers, i18n::tr("Layers")), (MobilePanel::Right, icons::Icon::Panels, i18n::tr("Design"))]
-            {
-                let open = self.ui.mobile_panel == Some(side);
-                let (r, resp) = ui.allocate_exact_size(egui::vec2(40.0, 40.0), egui::Sense::click());
-                let resp = resp.tip(name);
-                let fill = if open { t.accent } else { t.panel };
-                ui.painter().rect(r, 8.0, fill, egui::Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
-                icons::paint(ui.painter(), r.shrink(10.0), icon, if open { t.accent_on } else { t.icon });
-                if resp.clicked() {
-                    if side == MobilePanel::Left && !open {
-                        self.ui.open_left_panel();
-                    } else {
-                        self.ui.mobile_panel = if open { None } else { Some(side) };
-                    }
-                }
-                ui.add_space(4.0);
-            }
-        });
-    }
-
-    /// One frame of the window drawing now.
-    pub(crate) fn frame(&mut self, ui: &mut egui::Ui) {
-        let ctx = ui.ctx().clone();
-        // Bind this input batch before controls or pointer input can replace its composing
-        // target/caret. Outgoing IME receipts run after mutation and cannot authorize it.
-        let ime_input = shortcuts::ImeInputBaseline::capture(self);
-        let t = theme::Tokens::get(&ctx);
-        // A field that had the keyboard when the frame began keeps its keys from the shortcuts
-        // even if it lets go during the frame (Enter commits it), or as it began (egui drops the
-        // focus on Escape before the frame, which cancels the field's edit and nothing else).
-        let typing = std::mem::take(&mut self.field_focus) || a11y::field_focused(&ctx);
-        // Bind the originating field/file before tabs can switch. Its widget commits only after
-        // processing this batch; delivery remains deferred until the following frame.
-        let field_save = shortcuts::prepare_field_save(self, &ctx);
-        let swallowed = shortcuts::swallowed_paste(self, &ctx);
-        // A dialog that closed acts first, in the window it was opened from.
-        self.poll_dialog(&ctx);
-        // Control requests run first so their results reflect this frame.
-        control::drain(self, &ctx);
-        windows::requests(self, &ctx);
-        selection_spacing::sync(self, &ctx);
-        // Before any widget: the navigation keys (F6, Tab, arrows, Escape) move the keyboard.
-        a11y::begin(self, &ctx, ui.scope_id());
-        if self.ui.title_bar == TitleBar::Custom {
-            tabs::resize_edges(&ctx);
-        }
-        if self.ui.icon_gallery {
-            icons::gallery(&ctx);
-        }
-        theme::set_doc_profile(&ctx, self.session.doc().map_or(figcraft_color::ColorProfile::Srgb, |d| d.color_profile));
-        widgets::set_nudge(&ctx, self.session.prefs.nudge_small, self.session.prefs.nudge_big);
-        self.sync_dev_mode();
-        self.end_pen_outside_design();
-        tabs::relink_presents(self);
-        tabs::tab_bar(self, ui);
-        // Control/window work and this pass's physical tab click may have replaced the owner.
-        // A shared field ID in that replacement must never consume the old commit marker.
-        let field_save = shortcuts::revalidate_field_save(self, &ctx, field_save);
-        if self.ui.present.is_some() {
-            // A close request can arrive while the presenter fills the window. Let its unsaved
-            // changes dialog take Escape and draw above the player just as it does in the editor.
-            dialogs::keys(self, &ctx);
-            present::show(self, ui);
-            dialogs::show(self, &ctx);
-            updates_ui::show(self, &ctx);
-            // What went wrong while presenting (a widget's plugin failing) shows over it.
-            self.toast_ui(&ctx);
-            windows::requests(self, &ctx);
-            shortcuts::clear_field_save_marker(&ctx);
-            self.observe_ime(&ctx, false);
-            return;
-        }
-        if !self.has_files() || self.ui.home {
-            home::show(self, ui);
-            // The shortcuts panel belongs to the canvas; it doesn't hang over the home screen
-            // (cleared after the home widgets, which may have just asked for it).
-            self.ui.shortcuts_panel = false;
-            dialogs::keys(self, &ctx);
-            dialogs::show(self, &ctx);
-            updates_ui::show(self, &ctx);
-            self.toast_ui(&ctx);
-            windows::requests(self, &ctx);
-            shortcuts::clear_field_save_marker(&ctx);
-            self.observe_ime(&ctx, false);
-            return;
-        }
-        let hidden = self.session.ds().map(|d| d.view.ui_hidden).unwrap_or(false);
-        let narrow = !hidden && ui.available_width() < NARROW_WIDTH;
-        let mobile = self.ui.mobile_panel.filter(|_| narrow);
-        self.ui.narrow = narrow;
-        // A narrow window shows the right panel when its button asks for it, a board's too.
-        let right_open = (self.right_panel_shown(hidden) && !narrow) || mobile == Some(MobilePanel::Right);
-        if !hidden && (!narrow || mobile == Some(MobilePanel::Left)) {
-            egui::Panel::left("left_rail")
-                .exact_size(56.0)
-                .resizable(false)
-                .frame(egui::Frame::NONE.fill(t.panel).stroke(egui::Stroke::new(1.0, t.border)))
-                .show(ui, |ui| {
-                    a11y::region(&mut self.ui.nav, ui, a11y::Region::Layers, egui::accesskit::Role::Navigation, i18n::tr("Sidebar"));
-                    layers::rail(self, ui)
-                });
-        }
-        // The panels are as wide as asked, less in a window too small for them and the canvas.
-        let left_open = !hidden && if narrow { mobile == Some(MobilePanel::Left) } else { !self.ui.left_collapsed };
-        let (left_w, right_w) = if narrow {
-            let w = (ui.available_width() - MOBILE_STRIP).max(0.0);
-            (if left_open { w } else { 0.0 }, w)
-        } else {
-            fit_panels(ui.available_width(), left_open.then_some(self.ui.left_width), right_open.then_some(self.ui.right_width))
-        };
-        let rows = ui.available_rect_before_wrap().y_range();
-        let mut edges: Vec<(&str, f32, f32, f32)> = Vec::new();
-        if left_open {
-            if !narrow {
-                edges.push(("left", ui.available_rect_before_wrap().min.x + left_w, left_w, 1.0));
-            }
-            egui::Panel::left("left_panel")
-                .resizable(false)
-                .exact_size(left_w)
-                .frame(egui::Frame::NONE.fill(t.panel).stroke(egui::Stroke::new(1.0, t.border)))
-                .show(ui, |ui| {
-                    let label = match self.ui.left_tab {
-                        _ if self.ui.versions.open => i18n::tr("Version history"),
-                        LeftTab::File => i18n::tr("Layers"),
-                        LeftTab::Assets => i18n::tr("Assets"),
-                    };
-                    a11y::region(&mut self.ui.nav, ui, a11y::Region::Layers, egui::accesskit::Role::Pane, label);
-                    layers::left_panel(self, ui)
-                });
-        }
-        if right_open {
-            if !narrow {
-                edges.push(("right", ui.available_rect_before_wrap().max.x - right_w, right_w, -1.0));
-            }
-            egui::Panel::right("right_panel")
-                .resizable(false)
-                .exact_size(right_w)
-                .frame(egui::Frame::NONE.fill(t.panel).stroke(egui::Stroke::new(1.0, t.border)))
-                .show(ui, |ui| {
-                    let label = match self.ui.right_tab {
-                        RightTab::Design => i18n::tr("Design"),
-                        RightTab::Prototype => i18n::tr("Prototype"),
-                        RightTab::Inspect => i18n::tr("Dev Mode"),
-                    };
-                    a11y::region(&mut self.ui.nav, ui, a11y::Region::Properties, egui::accesskit::Role::Pane, label);
-                    right::right_panel(self, ui)
-                });
-        }
-        egui::CentralPanel::default().frame(egui::Frame::NONE.fill(t.canvas)).show(ui, |ui| {
-            let worker = self.worker.take();
-            let mut worker = worker.unwrap_or_else(|| render_worker::Worker::new(ctx.clone()));
-            canvas::show(self, ui, &mut worker);
-            self.worker = Some(worker);
-            if !hidden && mobile.is_none() {
-                ui.scope_builder(egui::UiBuilder::new().id_salt("toolbar"), |ui| {
-                    a11y::container(ui, egui::accesskit::Role::Toolbar, i18n::tr("Tools"));
-                    toolbar::show(self, ui);
-                });
-            }
-        });
-        if narrow {
-            let x = if mobile == Some(MobilePanel::Left) { ctx.content_rect().max.x - MOBILE_STRIP + 4.0 } else { ctx.content_rect().min.x + 4.0 };
-            self.mobile_buttons(&ctx, egui::pos2(x, rows.min + 8.0));
-        }
-        // The panels' edges, over the canvas and the panels (drawn after them: they take the press).
-        for (name, x, shown, grows) in edges {
-            if let Some(w) = Self::panel_edge(ui, name, x, rows, shown, grows) {
-                let (l, r) = if name == "left" { (w, self.ui.right_width) } else { (self.ui.left_width, w) };
-                self.set_panel_widths(l, r);
-                self.panels_unsaved = true;
-            }
-        }
-        // Kept once the drag is over (not on every pointer move).
-        if self.panels_unsaved && !ctx.input(|i| i.pointer.any_down()) {
-            self.panels_unsaved = false;
-            self.services.save_prefs(&self.session.prefs);
-        }
-        // Before the shortcuts: keys the hovered pane's prototype uses don't reach the editor, and
-        // the arrows step through comment threads with the Comment tool.
-        present::show_pane(self, &ctx);
-        comments::keys(self, &ctx);
-        dev_compare::keys(self, &ctx);
-        branch_ui::keys(self, &ctx);
-        live::dialog_keys(self, &ctx);
-        dialogs::keys(self, &ctx);
-        shortcuts::handle_input(self, &ctx, typing, swallowed, ime_input, field_save);
-        menus::popups(self, &ctx);
-        variable_ui::picker(self, &ctx);
-        style_picker::show(self, &ctx);
-        self.end_unwanted_text_preview(&ctx);
-        self.end_pen_outside_design();
-        dialogs::show(self, &ctx);
-        updates_ui::show(self, &ctx);
-        self.toast_ui(&ctx);
-        // A rename started after the layers panel drew (Cmd/Ctrl+R, a double-click) opens its field
-        // next frame.
-        if self.ui.rename.is_some_and(|r| r.start) && !hidden && !self.ui.left_collapsed && self.ui.left_tab == LeftTab::File {
-            ctx.request_repaint();
-        }
-        a11y::end(self, &ctx);
-        self.field_focus = a11y::field_focused(&ctx);
-        windows::requests(self, &ctx);
-        // Your pointer, selection and view to the others in each live session (when they
-        // changed), from the window with its file.
-        let windows = &self.windows;
-        self.session.live_sync_in(|uid| uid.map_or(0, |u| windows.of(u)) == windows.current);
-        // The canvas editor's IME context is observed exactly once per pass, after every command
-        // this pass ran (shortcuts, menus, dialogs, window requests and live sync). A focused panel
-        // field or an open palette owns the platform IME instead; the early `home`/present paths
-        // above make the same single idle observation.
-        self.observe_ime(&ctx, !typing && !self.field_focus && self.ui.palette.is_none());
-    }
-
-    /// The pass's one IME observation: the focused on-canvas editor, or an explicit idle.
-    ///
-    /// Calling `ImeContextTracker::observe` more than once in a pass would treat an idle followed
-    /// by a focused observation as a context change (dropping the frame's receipts) and bump the
-    /// generation. Keeping this in one place makes the fork contract structural.
-    fn observe_ime(&mut self, ctx: &egui::Context, focused: bool) {
-        #[cfg(test)]
-        {
-            self.ime_observations = self.ime_observations.saturating_add(1);
-        }
-        if focused {
-            shortcuts::ime_output(self, ctx);
-        } else {
-            let _ = self.ime.observe(ctx.viewport_id(), None);
-        }
-    }
-
-    /// Draw the toast: start its lifetime on the frame **after** the first drawn frame, request
-    /// that frame and the frame that hides it, expire and remove it at the deadline, and place it
-    /// at the bottom centre.
-    fn toast_ui(&mut self, ctx: &egui::Context) {
-        let Some((msg, clock)) = &mut self.ui.toast else { return };
-        let now = ctx.input(|i| i.time);
-        // The clock starts on the frame after the one that first draws the toast: that frame's
-        // time was taken before whatever raised it ran (a file dialog, a long open), and would
-        // count that wait against it, so a failed open's message expired before it was seen.
-        let left = match *clock {
-            ToastClock::Raised => {
-                *clock = ToastClock::Drawn;
-                ctx.request_repaint();
-                TOAST_SECS
-            }
-            ToastClock::Drawn => {
-                *clock = ToastClock::Since(now);
-                TOAST_SECS
-            }
-            ToastClock::Since(t) => TOAST_SECS - (now - t),
-        };
-        if left <= 0.0 {
-            self.ui.toast = None;
-            return;
-        }
-        let msg = msg.clone();
-        // Nothing moves while it shows: the next frame it needs is the one that hides it.
-        if matches!(clock, ToastClock::Since(_)) {
-            repaint_in(ctx, left);
-        }
-        let screen = ctx.content_rect();
-        egui::Area::new(egui::Id::unique("toast"))
-            .fixed_pos(egui::pos2(screen.center().x, screen.max.y - 96.0))
-            .pivot(egui::Align2::CENTER_BOTTOM)
-            .order(egui::Order::Tooltip)
-            .show(ctx, |ui| {
-                egui::Frame::NONE
-                    .fill(egui::Color32::from_rgb(0x1E, 0x1E, 0x1E))
-                    .corner_radius(egui::CornerRadius::same(8))
-                    .inner_margin(egui::Margin::symmetric(14, 10))
-                    .show(ui, |ui| {
-                        // Wrapped at a readable width (the area alone would wrap at a sliver).
-                        let width = (screen.width() - 64.0).clamp(120.0, 480.0);
-                        let galley = ui.painter().layout(msg, theme::regular(12.0), egui::Color32::WHITE, width);
-                        ui.label(galley);
-                    });
-            });
-    }
-
-    /// UI state as JSON (control channel `ui.inspect`).
-    pub fn inspect(&self) -> Value {
-        let mut state = json!({
-            "rightTab": self.ui.right_tab,
-            "leftTab": self.ui.left_tab,
-            "home": self.ui.home,
-            "online": online::inspect(self),
-            "tabs": self.session.docs.iter().map(|d| json!({"name": d.doc.name, "live": tabs::live_mark(self, d.uid).map(|shared| if shared { "shared" } else { "private" })})).collect::<Vec<_>>(),
-            "homeSection": self.ui.home_view.section.id(),
-            "homeRecents": home_recents::inspect(self),
-            "dark": self.ui.dark,
-            "focus": {"region": self.ui.nav.region.id(), "keyboard": self.ui.nav.keyboard},
-            "reduceMotion": self.reduce_motion(),
-            "presenting": self.ui.present.is_some(),
-            "presenter": tabs::shown_or_paused(self).map(present::Presenter::inspect),
-            "presentOptions": {"scale": self.ui.present_view.scale.id(), "deviceFrame": self.ui.present_view.device_frame, "comments": self.ui.present_view.comments, "hotspotHints": self.ui.present_view.hotspot_hints, "inspect": self.ui.present_view.inspect},
-            "preview": self.ui.preview.as_ref().map(|p| p.player.inspect()),
-            "mainMenu": self.ui.main_menu,
-            "palette": self.ui.palette.is_some(),
-            "variables": self.ui.variables.is_some(),
-            "versionHistory": self.ui.versions.open,
-            "branchReview": self.ui.branch_review.as_ref().map(|r| json!({"id": r.id, "picks": r.picks, "mode": if r.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }})),
-            "devCompare": self.ui.dev.compare.as_ref().map(|c| json!({"id": c.id, "mode": if c.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }, "split": c.split, "version": c.version})),
-            "devFocus": self.session.ds().ok().and_then(figcraft_engine::DocState::focused),
-            "annotationFilter": self.ui.dev.categories.id(),
-            "colorProfileDialog": self.ui.color_profile.map(|p| p.id()),
-            "stylePicker": self.ui.style_picker.as_ref().map(|p| p.slot().key()),
-            "stylePickerView": if self.ui.style_grid { "grid" } else { "list" },
-            "textPreview": figcraft_engine::textpreview::active(&self.session),
-            "comments": {
-                "open": self.ui.comments.open,
-                "draft": self.ui.comments.draft.as_ref().map(|d| [d.0, d.1]),
-                "filter": self.ui.comments.filter.id(),
-                "sort": self.ui.comments.sort.id(),
-                "search": self.ui.comments.search,
-                "editing": self.ui.comments.editing.as_ref().map(|e| [e.0, e.1 as u64]),
-                "mentions": self.ui.comments.mention.names(),
-            },
-            "frameMs": self.ui.frame_ms,
-            "renderMs": self.ui.render_ms,
-            "framesDrawn": self.frame_stats.frames,
-            "repaintCauses": self.frame_stats.causes(),
-            "canvas": {
-                "rect": [self.canvas.rect.min.x, self.canvas.rect.min.y, self.canvas.rect.max.x, self.canvas.rect.max.y],
-                "renderWork": self.canvas.render_work.map(|w| match w {
-                    figcraft_render::Work::Reused => json!({"kind": "reused"}),
-                    figcraft_render::Work::Partial { pixels } => json!({"kind": "partial", "pixels": pixels}),
-                    figcraft_render::Work::Full => json!({"kind": "full"}),
-                }),
-                "quality": if self.canvas.tex_coarse { "preview" } else { "refined" },
-                "previewLatencyMs": self.canvas.preview_latency_ms,
-                "refineLatencyMs": self.canvas.refine_latency_ms,
-            },
-            "live": live::inspect(self),
-            "window": self.windows.current,
-            "windows": windows::list(self),
-            "tool": self.session.tool_info(),
-            "cursor": self.canvas.cursor.map(cursors::Shown::name),
-            "panels": {"left": self.ui.left_width, "right": self.ui.right_width, "leftCollapsed": self.ui.left_collapsed},
-            "status": self.session.status(),
-            "lastError": self.ui.last_error,
-            "importReport": self.ui.import_report.as_ref().map(import_report::Report::inspect),
-        });
-        state["homeSearch"] = json!(self.ui.home_view.file_query);
-        // Set apart from the literal above, which is at the macro recursion limit.
-        state["uiScale"] = json!({"choice": self.session.prefs.ui_scale, "zoom": self.ui.ui_scale.zoom, "drawn": self.ui.ui_scale.drawn, "limited": self.ui.ui_scale.limited});
-        state["pendingOpens"] = json!(self.ui.pending_opens.len());
-        state["missingFonts"] = json!(self.ui.missing_fonts.as_ref().map(missing_fonts::Shown::inspect));
-        state["presentTabs"] = tabs::present_tabs_inspect(self);
-        state
-    }
-}
-
-/// The file types File ▸ Open and a drop on the home screen open.
-pub(crate) const OPEN_EXTENSIONS: &[&str] = &["figcraft", "fig", "sketch", "json", "svg", "png", "jpg", "jpeg", "webp", "gif", "tif", "tiff"];
-
-/// Whether `path` names a file type that opens as a document (the extension, in any case).
-pub(crate) fn opens(path: &Path) -> bool {
-    path.extension().and_then(OsStr::to_str).is_some_and(|e| OPEN_EXTENSIONS.iter().any(|x| x.eq_ignore_ascii_case(e)))
-}
-
-/// Whether `path` is a whole document (`.figcraft`, `.fig`, `.sketch`, file JSON) rather than an image or SVG:
-/// dropped on the canvas it opens as a file of its own instead of adding its pages to the open one.
-pub(crate) fn is_document(path: &Path) -> bool {
-    path.extension().and_then(OsStr::to_str).is_some_and(|e| ["figcraft", "fig", "sketch", "json"].iter().any(|x| x.eq_ignore_ascii_case(e)))
-}
-
-/// Reads the contents of dropped file `name` that has no file on disk to read by path.
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn dropped_bytes(f: &egui::DroppedFileHandle, name: &str) -> ReadFuture {
-    Box::pin(std::future::ready(f.bytes().map_err(|_| unreadable(name))))
-}
-
-/// Reads the contents of dropped file `name`; the browser hands them over asynchronously.
-#[cfg(target_arch = "wasm32")]
-pub(crate) fn dropped_bytes(f: &egui::DroppedFileHandle, name: &str) -> ReadFuture {
-    let (f, name) = (f.clone(), name.to_string());
-    Box::pin(async move {
-        if let Some(file) = f.web_file() {
-            browser_can_read(&name, file.size())?;
-        }
-        f.bytes_async().await.map_err(|_| unreadable(&name))
-    })
-}
-
-/// While files are dragged over the window: a tinted, outlined `rect` with `label` in its middle,
-/// over everything else, saying what a drop does there.
-pub(crate) fn drop_overlay(ctx: &egui::Context, rect: egui::Rect, label: &str) {
-    if ctx.input(|i| i.raw.hovered_files.is_empty()) {
-        return;
-    }
-    let t = theme::Tokens::get(ctx);
-    let painter = ctx.layer_painter(egui::LayerId::new(egui::Order::Foreground, egui::Id::unique("drop_overlay")));
-    let area = rect.shrink(4.0);
-    painter.rect_filled(area, egui::CornerRadius::same(8), t.accent.gamma_multiply(0.12));
-    painter.rect_stroke(area, egui::CornerRadius::same(8), egui::Stroke::new(2.0, theme::ACCENT), egui::StrokeKind::Inside);
-    let galley = painter.layout_no_wrap(label.to_owned(), theme::semibold(14.0), t.text);
-    let pill = egui::Rect::from_center_size(area.center(), galley.size() + egui::vec2(32.0, 16.0));
-    painter.rect_filled(pill, egui::CornerRadius::same(8), t.panel);
-    painter.rect_stroke(pill, egui::CornerRadius::same(8), egui::Stroke::new(1.0, theme::ACCENT), egui::StrokeKind::Inside);
-    painter.galley(pill.center() - galley.size() / 2.0, galley, t.text);
-    // Hovering sends no pointer events on every platform: keep the overlay current.
-    ctx.request_repaint();
-}
-
 #[cfg(test)]
 mod selection_spacing_tests;
 
diff --git a/crates/ui-egui/src/open.rs b/crates/ui-egui/src/open.rs
new file mode 100644
index 00000000..4fe8b9bd
--- /dev/null
+++ b/crates/ui-egui/src/open.rs
@@ -0,0 +1,56 @@
+#[cfg(target_arch = "wasm32")]
+use super::services::browser_can_read;
+use super::services::{ReadFuture, unreadable};
+use super::*;
+
+/// The file types File ▸ Open and a drop on the home screen open.
+pub(crate) const OPEN_EXTENSIONS: &[&str] = &["figcraft", "fig", "sketch", "json", "svg", "png", "jpg", "jpeg", "webp", "gif", "tif", "tiff"];
+
+/// Whether `path` names a file type that opens as a document (the extension, in any case).
+pub(crate) fn opens(path: &Path) -> bool {
+    path.extension().and_then(OsStr::to_str).is_some_and(|e| OPEN_EXTENSIONS.iter().any(|x| x.eq_ignore_ascii_case(e)))
+}
+
+/// Whether `path` is a whole document (`.figcraft`, `.fig`, `.sketch`, file JSON) rather than an image or SVG:
+/// dropped on the canvas it opens as a file of its own instead of adding its pages to the open one.
+pub(crate) fn is_document(path: &Path) -> bool {
+    path.extension().and_then(OsStr::to_str).is_some_and(|e| ["figcraft", "fig", "sketch", "json"].iter().any(|x| x.eq_ignore_ascii_case(e)))
+}
+
+/// Reads the contents of dropped file `name` that has no file on disk to read by path.
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) fn dropped_bytes(f: &egui::DroppedFileHandle, name: &str) -> ReadFuture {
+    Box::pin(std::future::ready(f.bytes().map_err(|_| unreadable(name))))
+}
+
+/// Reads the contents of dropped file `name`; the browser hands them over asynchronously.
+#[cfg(target_arch = "wasm32")]
+pub(crate) fn dropped_bytes(f: &egui::DroppedFileHandle, name: &str) -> ReadFuture {
+    let (f, name) = (f.clone(), name.to_string());
+    Box::pin(async move {
+        if let Some(file) = f.web_file() {
+            browser_can_read(&name, file.size())?;
+        }
+        f.bytes_async().await.map_err(|_| unreadable(&name))
+    })
+}
+
+/// While files are dragged over the window: a tinted, outlined `rect` with `label` in its middle,
+/// over everything else, saying what a drop does there.
+pub(crate) fn drop_overlay(ctx: &egui::Context, rect: egui::Rect, label: &str) {
+    if ctx.input(|i| i.raw.hovered_files.is_empty()) {
+        return;
+    }
+    let t = theme::Tokens::get(ctx);
+    let painter = ctx.layer_painter(egui::LayerId::new(egui::Order::Foreground, egui::Id::unique("drop_overlay")));
+    let area = rect.shrink(4.0);
+    painter.rect_filled(area, egui::CornerRadius::same(8), t.accent.gamma_multiply(0.12));
+    painter.rect_stroke(area, egui::CornerRadius::same(8), egui::Stroke::new(2.0, theme::ACCENT), egui::StrokeKind::Inside);
+    let galley = painter.layout_no_wrap(label.to_owned(), theme::semibold(14.0), t.text);
+    let pill = egui::Rect::from_center_size(area.center(), galley.size() + egui::vec2(32.0, 16.0));
+    painter.rect_filled(pill, egui::CornerRadius::same(8), t.panel);
+    painter.rect_stroke(pill, egui::CornerRadius::same(8), egui::Stroke::new(1.0, theme::ACCENT), egui::StrokeKind::Inside);
+    painter.galley(pill.center() - galley.size() / 2.0, galley, t.text);
+    // Hovering sends no pointer events on every platform: keep the overlay current.
+    ctx.request_repaint();
+}
diff --git a/crates/ui-egui/src/services.rs b/crates/ui-egui/src/services.rs
new file mode 100644
index 00000000..d7490de4
--- /dev/null
+++ b/crates/ui-egui/src/services.rs
@@ -0,0 +1,159 @@
+use super::*;
+
+/// Platform services the app crate provides (file dialogs, clipboard, URLs).
+pub trait Services {
+    fn pick_open(&mut self, _title: &str, _exts: &[&str]) -> DialogFuture {
+        Box::pin(std::future::ready(None))
+    }
+    /// Pick a file and read it, where the platform hands over a file's name and contents rather
+    /// than a path to it (the browser). `None`: the platform picks paths ([`Services::pick_open`]).
+    fn pick_open_contents(&mut self, _title: &str, _exts: &[&str]) -> Option<ContentsFuture> {
+        None
+    }
+    fn pick_save(&mut self, _title: &str, _name: &str, _exts: &[&str]) -> DialogFuture {
+        Box::pin(std::future::ready(None))
+    }
+    /// The platform saves files by handing them over as downloads (the browser), not through
+    /// save dialogs.
+    fn downloads(&self) -> bool {
+        false
+    }
+    /// Hand `bytes` over as a download named `name`; false when nothing was delivered.
+    fn download(&mut self, _name: &str, _bytes: &[u8]) -> bool {
+        false
+    }
+    /// A folder to write several files into.
+    fn pick_folder(&mut self, _title: &str) -> DialogFuture {
+        Box::pin(std::future::ready(None))
+    }
+    fn clipboard_set_text(&mut self, _s: &str) {}
+    /// Give native services access to the window context for platform clipboard output.
+    fn set_egui_context(&mut self, _ctx: &egui::Context) {}
+    fn clipboard_get_text(&mut self) -> Option<String> {
+        None
+    }
+    fn clipboard_get_html(&mut self) -> Option<String> {
+        None
+    }
+    fn clipboard_set_png(&mut self, _w: u32, _h: u32, _rgba: &[u8]) {}
+    /// An image on the system clipboard as (width, height, straight RGBA).
+    fn clipboard_get_image(&mut self) -> Option<(u32, u32, Vec<u8>)> {
+        None
+    }
+    fn open_url(&mut self, _url: &str) {}
+    /// Show the file at `path` in the platform's file manager (Finder, Explorer), selected where the
+    /// platform can.
+    fn reveal_path(&mut self, _path: &std::path::Path) {}
+    /// The system asks for reduced motion (its accessibility setting).
+    fn reduce_motion(&self) -> bool {
+        false
+    }
+    /// The system asks for the dark interface (the freedesktop colour scheme): for platforms whose
+    /// windowing stack doesn't report a theme (winit gives none on Linux and the BSDs).
+    fn system_dark(&self) -> Option<bool> {
+        None
+    }
+    /// After a panic in a frame: keep recovery copies of unsaved files.
+    fn emergency_save(&mut self, _session: &Session) {}
+    /// Keep the preferences now (the installed plugins or their settings changed), as the app
+    /// does when it quits.
+    fn save_prefs(&mut self, _prefs: &figcraft_engine::Prefs) {}
+    /// The OS or browser language as a tag ("es-ES"), for the "system" language preference.
+    fn system_language(&self) -> Option<String> {
+        None
+    }
+    /// The controller buttons held now on any controller: bit i is standard gamepad layout index i
+    /// (0 the bottom face button … 16 home; `figcraft_doc::proto::GAMEPAD_BUTTONS`). The prototype
+    /// player asks every frame while its prototype has gamepad triggers.
+    fn gamepad_held(&mut self) -> u32 {
+        0
+    }
+}
+
+pub type DialogFuture = Pin<Box<dyn Future<Output = Option<PathBuf>>>>;
+
+/// A picked file's name and contents ([`Services::pick_open_contents`]); `None` when the picker
+/// was cancelled, `Err` with what to tell the user when the file couldn't be read.
+pub type ContentsFuture = Pin<Box<dyn Future<Output = Option<Result<(String, Vec<u8>), String>>>>>;
+
+/// A dropped file's contents, read once they arrive (`Err`: what to tell the user when they
+/// couldn't be read).
+pub type ReadFuture = Pin<Box<dyn Future<Output = Result<Vec<u8>, String>>>>;
+
+pub(crate) type PickFuture = Pin<Box<dyn Future<Output = Option<Picked>>>>;
+
+pub(crate) type DialogDone = Box<dyn FnOnce(&mut FigApp, Picked)>;
+
+/// What a dialog picked: a path, or a file's name and contents where there are no paths, or why
+/// the picked file couldn't be read.
+pub(crate) enum Picked {
+    Path(PathBuf),
+    Contents(String, Vec<u8>),
+    Unreadable(String),
+}
+
+impl Picked {
+    /// The file as `file.open` and `file.import` take it (`Err`: what to tell the user instead).
+    pub(crate) fn file_params(self) -> Result<Value, String> {
+        match self {
+            Picked::Path(p) => Ok(json!({"path": p.to_string_lossy()})),
+            Picked::Contents(name, bytes) => {
+                use base64::Engine as _;
+                Ok(json!({"data": base64::engine::general_purpose::STANDARD.encode(&bytes), "name": name}))
+            }
+            Picked::Unreadable(why) => Err(why),
+        }
+    }
+}
+
+/// What the user is told about a file whose contents couldn't be read.
+pub fn unreadable(name: &str) -> String {
+    i18n::trf("Couldn't read {name}.", &[("name", &name)])
+}
+
+/// The largest file read in the browser: wasm has at most 4 GiB of memory, and a file's contents
+/// are held about three times on their way to `file.open` (the bytes, base64, decoded again).
+/// As large as one member of a `.figcraft` file may be.
+const MAX_BROWSER_FILE: f64 = (512u64 << 20) as f64;
+
+/// Checks a file of `size` bytes before the browser reads it (`Err`: what to tell the user).
+pub fn browser_can_read(name: &str, size: f64) -> Result<(), String> {
+    if size.is_nan() || size > MAX_BROWSER_FILE {
+        return Err(i18n::trf("{name} is too large to open in the browser (over 512 MB).", &[("name", &name)]));
+    }
+    Ok(())
+}
+
+/// Wakes the main window, which hands the result on to the window it belongs to.
+pub(crate) struct RepaintWaker(pub(crate) egui::Context);
+
+impl Wake for RepaintWaker {
+    fn wake(self: Arc<Self>) {
+        self.0.request_repaint_of(egui::ViewportId::ROOT);
+    }
+
+    fn wake_by_ref(self: &Arc<Self>) {
+        self.0.request_repaint_of(egui::ViewportId::ROOT);
+    }
+}
+
+/// No-op services (tests, headless screenshots).
+pub struct NoServices;
+
+impl Services for NoServices {}
+
+/// Put `text` on the system clipboard through egui's platform output. Native integrations handle
+/// it directly; the browser shell writes it while handling the copy event.
+pub fn egui_copy_text(ctx: &egui::Context, text: &str) {
+    ctx.copy_text(text.to_string());
+}
+
+/// Put a straight-RGBA image on the system clipboard through egui's output (see
+/// [`egui_copy_text`]); a buffer that doesn't match its size is dropped.
+pub fn egui_copy_png(ctx: &egui::Context, w: u32, h: u32, rgba: &[u8]) {
+    let (w, h) = (w as usize, h as usize);
+    if w.checked_mul(h).and_then(|n| n.checked_mul(4)) != Some(rgba.len()) {
+        return;
+    }
+    ctx.copy_image(egui::ColorImage::from_rgba_unmultiplied([w, h], rgba));
+}
diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs
new file mode 100644
index 00000000..6480983f
--- /dev/null
+++ b/crates/ui-egui/src/state.rs
@@ -0,0 +1,65 @@
+#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
+pub enum RightTab {
+    Design,
+    Prototype,
+    Inspect,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
+pub enum LeftTab {
+    File,
+    Assets,
+}
+
+/// The window's title bar.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum TitleBar {
+    /// The system draws it (and the browser): the tab strip sits below.
+    #[default]
+    Native,
+    /// A frameless window: the tab strip is the title bar, with our own window buttons and edges.
+    Custom,
+    /// macOS: the system's window buttons inset at the left of the tab strip.
+    Inset,
+}
+
+/// A file being encoded for auto-save: its snapshot and, once done, its bytes.
+pub type AutoSaveEncoding = std::thread::JoinHandle<(figcraft_engine::cmd::file::FileSnapshot, figcraft_engine::Result<Vec<u8>>)>;
+
+/// The side panels' widths: the least and most a drag of their edge gives, what a double-click on
+/// the edge puts back, and how much of the window they leave the canvas.
+pub const LEFT_PANEL: std::ops::RangeInclusive<f32> = 200.0..=480.0;
+
+pub const RIGHT_PANEL: std::ops::RangeInclusive<f32> = 240.0..=480.0;
+
+pub const PANEL_DEFAULT: f32 = 240.0;
+
+/// Windows narrower than this (logical points: phones, portrait tablets) show one side panel at a
+/// time over the canvas, opened from two buttons, instead of both beside it.
+pub const NARROW_WIDTH: f32 = 760.0;
+
+/// What an open side panel leaves of a narrow window: the column of panel buttons.
+pub(crate) const MOBILE_STRIP: f32 = 48.0;
+
+/// The side panel a narrow window shows.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum MobilePanel {
+    Left,
+    Right,
+}
+
+pub const CANVAS_MIN: f32 = 160.0;
+
+/// The widths the side panels are drawn at in `avail` points (the window less the icon rail), from
+/// the widths asked for (none while a panel is closed, which takes no room): each within its
+/// limits, and narrower in a small window so the canvas keeps [`CANVAS_MIN`] (the right panel
+/// gives way last).
+pub fn fit_panels(avail: f32, left: Option<f32>, right: Option<f32>) -> (f32, f32) {
+    let fit = |w: f32, range: &std::ops::RangeInclusive<f32>, room: f32| {
+        let w = if w.is_finite() { w } else { PANEL_DEFAULT };
+        w.clamp(*range.start(), room.clamp(*range.start(), *range.end()))
+    };
+    let left_min = left.map_or(0.0, |_| *LEFT_PANEL.start());
+    let right = right.map_or(0.0, |r| fit(r, &RIGHT_PANEL, avail - left_min - CANVAS_MIN));
+    (left.map_or(0.0, |l| fit(l, &LEFT_PANEL, avail - right - CANVAS_MIN)), right)
+}

From 6167d19e52c5d3b4707c4a733416d14486ae4679 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:56:10 +0000
Subject: [PATCH 41/67] refactor(ui-egui): split present.rs into present/

---
 crates/ui-egui/src/present.rs            | 2562 +---------------------
 crates/ui-egui/src/present/actions.rs    |  265 +++
 crates/ui-egui/src/present/chrome.rs     |  408 ++++
 crates/ui-egui/src/present/device.rs     |  124 ++
 crates/ui-egui/src/present/draw.rs       |  123 ++
 crates/ui-egui/src/present/input.rs      |  334 +++
 crates/ui-egui/src/present/layout.rs     |  186 ++
 crates/ui-egui/src/present/navigate.rs   |  255 +++
 crates/ui-egui/src/present/player.rs     |  285 +++
 crates/ui-egui/src/present/scroll.rs     |  354 +++
 crates/ui-egui/src/present/transition.rs |  251 +++
 11 files changed, 2607 insertions(+), 2540 deletions(-)
 create mode 100644 crates/ui-egui/src/present/actions.rs
 create mode 100644 crates/ui-egui/src/present/chrome.rs
 create mode 100644 crates/ui-egui/src/present/device.rs
 create mode 100644 crates/ui-egui/src/present/draw.rs
 create mode 100644 crates/ui-egui/src/present/input.rs
 create mode 100644 crates/ui-egui/src/present/layout.rs
 create mode 100644 crates/ui-egui/src/present/navigate.rs
 create mode 100644 crates/ui-egui/src/present/player.rs
 create mode 100644 crates/ui-egui/src/present/scroll.rs
 create mode 100644 crates/ui-egui/src/present/transition.rs

diff --git a/crates/ui-egui/src/present.rs b/crates/ui-egui/src/present.rs
index b5469e6e..20e22cb1 100644
--- a/crates/ui-egui/src/present.rs
+++ b/crates/ui-egui/src/present.rs
@@ -40,6 +40,28 @@ use crate::icons::{self, Icon};
 use crate::theme::{ACCENT, Tokens, regular, semibold};
 use crate::widgets;
 
+mod actions;
+mod chrome;
+mod device;
+mod draw;
+mod input;
+mod layout;
+mod navigate;
+mod player;
+mod scroll;
+mod transition;
+
+#[cfg(test)]
+use chrome::choose_device;
+pub use chrome::{Pane, PresentTab, pane_id, show, show_pane};
+pub use layout::Place;
+#[cfg(test)]
+use layout::{FULL, layout};
+#[cfg(test)]
+use navigate::next_delay;
+pub use scroll::{apply_scroll, fit_viewport, fling_axis, page_settings, raise_fixed, rubber_band, scroll_range, scroll_range_in, viewport};
+pub use transition::{FramePlacement, direction_vec, lerp_transform, match_layers, name_path, overlay_rect, smart_interpolate, transition_frames};
+
 /// A mouse trigger waiting out its delay: interaction `k` of `node`, hit at `rect` while `root`
 /// (the screen or the top overlay) showed; due at `due` on the player's clock.
 #[derive(Clone, Copy, Debug)]
@@ -124,19 +146,6 @@ struct Fling {
     at: f64,
 }
 
-/// How quickly a fling slows down after a drag (1/s; it travels its speed / decay).
-const DECAY_DRAG: f64 = 2.5;
-/// How quickly the wheel's coast slows down (1/s).
-const DECAY_WHEEL: f64 = 8.0;
-/// Stiffness of the spring that pulls an overscroll back (1/s, critically damped).
-const SPRING: f64 = 16.0;
-/// A fling inside its range stops below this speed (units/s).
-const FLING_STOP: f64 = 6.0;
-/// The wheel coasts on when it was faster than this as it stopped (screen points/s).
-const COAST_MIN: f64 = 40.0;
-/// How far a drag past the end can stretch the content at most (screen points).
-const RUBBER_PTS: f64 = 240.0;
-
 /// How the full-window presenter sizes the prototype.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum PresentScale {
@@ -325,18 +334,6 @@ pub struct Presenter {
 }
 
 impl Presenter {
-    /// Close the top overlay; it animates out with its opening transition reversed.
-    fn close_overlay(&mut self, now: f64) -> bool {
-        let Some(o) = self.overlays.pop() else { return false };
-        if !matches!(o.transition, Transition::Instant) && o.dur > 0.0 {
-            // An overlay closed mid-opening reverses from where it got to.
-            let shown = ((now - o.opened) / o.dur).clamp(0.0, 1.0);
-            self.closing.push((now - (1.0 - shown) * o.dur, o));
-        }
-        self.hovered.clear();
-        true
-    }
-
     /// The frame the presentation started from (Restart goes back there).
     pub fn start(&self) -> NodeId {
         self.start
@@ -418,1071 +415,12 @@ impl Presenter {
         self.rev += 1;
     }
 
-    /// The current offset of `t` (a frame's scroll, else the view's pan).
-    fn offset(&self, t: Scroller) -> (f64, f64) {
-        match t {
-            Scroller::Frame(f) => self.scroll.get(&f).copied().unwrap_or((0.0, 0.0)),
-            Scroller::View => self.pan.unwrap_or((self.pan_range.0 / 2.0, 0.0)),
-        }
-    }
-
-    /// How far `t` scrolls (`base`: the player's document without scroll offsets).
-    fn limits(&self, base: &Document, t: Scroller) -> (f64, f64) {
-        match t {
-            Scroller::Frame(f) => self.range(base, f),
-            Scroller::View => self.pan_range,
-        }
-    }
-
-    fn set_offset(&mut self, t: Scroller, v: (f64, f64)) {
-        if !v.0.is_finite() || !v.1.is_finite() {
-            return;
-        }
-        match t {
-            Scroller::Frame(f) => {
-                if self.scroll.get(&f) != Some(&v) {
-                    self.scroll.insert(f, v);
-                    self.rev += 1;
-                }
-            }
-            Scroller::View => self.pan = Some(v),
-        }
-    }
-
-    /// Move a fling on to `now`; true while it is still moving.
-    fn step_fling(&mut self, now: f64) -> bool {
-        let Some(mut f) = self.fling.take() else { return false };
-        let Some(base) = self.doc.as_ref() else { return false };
-        let r = self.limits(base, f.target);
-        let x = self.offset(f.target);
-        let dt = (now - f.at).clamp(0.0, 0.25);
-        f.at = now;
-        let (nx, vx, done_x) = fling_axis(x.0, f.vel.0, r.0, dt, f.decay, f.bounce);
-        let (ny, vy, done_y) = fling_axis(x.1, f.vel.1, r.1, dt, f.decay, f.bounce);
-        self.set_offset(f.target, (nx, ny));
-        f.vel = (vx, vy);
-        if done_x && done_y {
-            return false;
-        }
-        self.fling = Some(f);
-        true
-    }
-
-    /// Follow the editor's document: copy it the first time and whenever it changed, keeping the
-    /// screen, the overlays and the scroll offsets that still exist (a deleted screen goes back to
-    /// the start). Runtime state (variables set, variants changed) starts over from the edit.
-    pub fn sync(&mut self, doc: &Arc<Document>, now: f64) {
-        if self.source.as_ref().is_some_and(|s| Arc::ptr_eq(s, doc)) {
-            return;
-        }
-        let first = self.source.is_none();
-        self.source = Some(doc.clone());
-        let copy = Document::clone(doc);
-        self.original = Some(copy.clone());
-        self.design = Some(copy);
-        self.relayout();
-        if first {
-            self.arrived = now;
-            return;
-        }
-        if !doc.contains(self.current) {
-            if doc.contains(self.start) {
-                self.restart(self.start, now);
-            }
-            return;
-        }
-        self.history.retain(|v| doc.contains(v.frame));
-        self.overlays.retain(|o| doc.contains(o.id));
-        self.closing.retain(|(_, o)| doc.contains(o.id));
-        // These hold states of the document before the edit.
-        self.temp = None;
-        self.anim = None;
-        self.scroll_anim = None;
-        self.stop_scrolling();
-        self.scroll.retain(|f, _| doc.contains(*f));
-        if let Some(laid) = self.doc.as_ref() {
-            let clamped: Vec<(NodeId, (f64, f64))> = self.scroll.iter().map(|(f, s)| (*f, clamp_scroll(*s, self.range(laid, *f)))).collect();
-            self.scroll.extend(clamped);
-        }
-        self.rev += 1;
-    }
-
-    /// Lay the document out for the screen: `design` with the presented frame resized to `fit`
-    /// when the prototype is responsive (its constraints and auto layout respond), instances
-    /// playing their variants' interactions and fixed layers on top.
-    fn relayout(&mut self) {
-        let mut d = self.design.clone();
-        if let Some(d) = d.as_mut() {
-            if let Some(size) = self.fit {
-                figcraft_engine::cmd::proto::respond(d, self.current, size);
-            }
-            figcraft_engine::proto_run::play_interactions(d);
-            raise_fixed(d);
-        }
-        self.uses_pads = d.as_ref().is_some_and(figcraft_doc::proto::uses_gamepad);
-        self.doc = d;
-        self.rev += 1;
-    }
-
-    /// After an action changed layers of `design` (since `before`): text resizes to what it shows,
-    /// instances follow and auto layout reflows, as after an edit on the canvas; then
-    /// [`relayout`](Self::relayout).
-    fn settle(&mut self, before: &Document) {
-        if let Some(d) = self.design.as_mut() {
-            figcraft_engine::normalize(d, before);
-        }
-        self.relayout();
-    }
-
-    /// Responsive prototypes: resize the presented frame to a screen of `size` (None: frames
-    /// keep their size). Lays out again only when it changes.
-    fn respond_to(&mut self, size: Option<(f64, f64)>) {
-        if self.fit != size {
-            self.fit = size;
-            self.relayout();
-        }
-    }
-
-    /// The player's document with scroll offsets applied and the presented frame sized to the
-    /// device's screen (cached per revision).
-    fn display(&mut self) -> Option<Document> {
-        if let Some((r, d)) = &self.display
-            && *r == self.rev
-        {
-            return Some(d.clone());
-        }
-        let doc = self.doc.as_ref()?;
-        let mut d = apply_scroll(doc, &self.scroll);
-        if let Some(vp) = viewport(doc, self.current) {
-            fit_viewport(&mut d, self.current, vp);
-        }
-        self.display = Some((self.rev, d.clone()));
-        Some(d)
-    }
-
-    /// How far `frame` scrolls (in `doc`, without scroll offsets): the presented frame within the
-    /// device's screen, other frames within themselves.
-    fn range(&self, doc: &Document, frame: NodeId) -> (f64, f64) {
-        let vp = if frame == self.current { viewport(doc, frame) } else { None };
-        scroll_range_in(doc, frame, vp)
-    }
-
-    /// What "Scroll to" `dest` moves: every scrolling frame around it, innermost first, brings the
-    /// layer (then the frame holding it) to its top-left as far as it can scroll, the innermost
-    /// `offset` short of it. Each entry is (frame, offset now, offset after).
-    fn scroll_to_layer(&self, doc: &Document, dest: NodeId, offset: [f64; 2]) -> Vec<ScrollMove> {
-        let mut out = Vec::new();
-        let mut target = dest;
-        // The innermost scrolling frame leaves `offset` before the layer.
-        let mut off = offset.map(|v| if v.is_finite() { v } else { 0.0 });
-        for f in doc.ancestors(dest) {
-            let (rx, ry) = self.range(doc, f);
-            let Some(tn) = doc.node(target) else { break };
-            if rx <= 0.0 && ry <= 0.0 {
-                continue;
-            }
-            let rel = doc.world_transform(f).inverse() * doc.world_transform(target);
-            let b = figcraft_geom::transform_rect_bbox(rel, tn.local_rect());
-            let from = self.scroll.get(&f).copied().unwrap_or((0.0, 0.0));
-            let to = clamp_scroll((if rx > 0.0 { b.x0 - off[0] } else { from.0 }, if ry > 0.0 { b.y0 - off[1] } else { from.1 }), (rx, ry));
-            out.push((f, from, to));
-            target = f;
-            off = [0.0, 0.0];
-        }
-        out
-    }
-
-    /// Scroll the presented frame to `(x, y)` (page units, clamped to what it can scroll).
-    pub fn scroll_to(&mut self, x: f64, y: f64) {
-        let Some(doc) = self.doc.as_ref() else { return };
-        if !x.is_finite() || !y.is_finite() {
-            return;
-        }
-        let to = clamp_scroll((x, y), self.range(doc, self.current));
-        self.scroll.insert(self.current, to);
-        self.scroll_anim = None;
-        self.stop_scrolling();
-        self.rev += 1;
-    }
-
-    /// The player's state for `ui.inspect`.
-    pub fn inspect(&self) -> Value {
-        let doc = self.doc.as_ref();
-        let pan = self.offset(Scroller::View);
-        json!({
-            "current": self.current,
-            "name": doc.and_then(|d| d.node(self.current)).map(|n| n.name.as_str()),
-            "start": self.start,
-            "history": self.history.iter().map(|v| v.frame).collect::<Vec<_>>(),
-            "overlays": self.overlays.iter().map(|o| o.id).collect::<Vec<_>>(),
-            "scroll": self.scroll.get(&self.current).map_or([0.0, 0.0], |s| [s.0, s.1]),
-            "scrollRange": doc.map(|d| { let r = self.range(d, self.current); [r.0, r.1] }),
-            "device": doc.and_then(|d| page_settings(d, self.current).device()).map(|d| d.name),
-            "landscape": doc.is_some_and(|d| page_settings(d, self.current).landscape()),
-            "viewport": doc.and_then(|d| viewport(d, self.current)).map(|v| [v.0, v.1]),
-            "scale": self.view.scale.id(),
-            "deviceFrame": self.view.device_frame,
-            "comments": self.view.comments,
-            "hotspotHints": self.view.hotspot_hints,
-            "hotspots": self.hot.iter().map(|(id, r)| json!({"id": id, "rect": [r.min.x, r.min.y, r.max.x, r.max.y]})).collect::<Vec<_>>(),
-            "hotspotFlash": self.flash_until > self.clock,
-            "waiting": self.waiting.len(),
-            "inspect": self.view.inspect,
-            "inspected": self.inspected,
-            "deviceColor": doc.and_then(|d| page_settings(d, self.current).device_color()).map(|c| c.name),
-            "responsive": self.fit.map(|f| [f.0, f.1]),
-            "frameSize": doc.and_then(|d| d.node(self.current)).map(|n| [n.width, n.height]),
-            "pan": [pan.0, pan.1],
-            "panRange": [self.pan_range.0, self.pan_range.1],
-            "zoom": self.zoom,
-            "flinging": self.fling.is_some(),
-            "gamepad": self.uses_pads,
-            "linkNotice": self.link_notice.as_ref().map(|(url, _)| url),
-        })
-    }
-
-    fn snapshot(&self) -> Option<Snapshot> {
-        Some(Snapshot {
-            current: self.current,
-            doc: self.design.clone()?,
-            overlays: self.overlays.clone(),
-            history: self.history.clone(),
-            scroll: self.scroll.clone(),
-        })
-    }
-
-    /// Start a transition from the state as it is now; call before changing the state.
-    fn begin(&mut self, transition: Transition, dur: f64, easing: Easing, now: f64) {
-        let Some(from_doc) = self.display() else { return };
-        let from_tex = self.textures.get(&self.current).cloned();
-        self.anim = if matches!(transition, Transition::Instant) || dur <= 0.0 {
-            None
-        } else {
-            Some(Anim { from_doc, from_frame: self.current, from_tex, transition, start: now, dur, easing, follow: None })
-        };
-    }
-
-    fn arrive(&mut self, now: f64) {
-        if let Some(doc) = self.doc.as_ref() {
-            figcraft_engine::proto_run::remember_sections(doc, self.current, &mut self.sections);
-        }
-        self.arrived = now;
-        self.delays_fired.clear();
-        self.waiting.clear();
-        self.hovered.clear();
-        self.rev += 1;
-    }
-
-    /// Show `frame`. It starts scrolled to the top unless `preserve` keeps the scroll position of
-    /// the frame being left (as far as `frame` can scroll).
-    fn go(&mut self, frame: NodeId, transition: Transition, dur: f64, easing: Easing, now: f64, remember: bool, preserve: bool) {
-        self.begin(transition, dur, easing, now);
-        if remember {
-            self.history.push(Visit { frame: self.current, transition, dur, easing });
-        }
-        let kept = self.scroll.get(&self.current).copied().filter(|_| preserve);
-        self.overlays.clear();
-        self.scroll.clear();
-        self.scroll_anim = None;
-        self.stop_scrolling();
-        self.pan = None;
-        self.temp = None;
-        self.current = frame;
-        self.relayout();
-        if let Some(s) = kept
-            && let Some(doc) = self.doc.as_ref()
-        {
-            let to = clamp_scroll(s, self.range(doc, frame));
-            self.scroll.insert(frame, to);
-        }
-        self.arrive(now);
-    }
-
-    /// Start over at `start` with the document as the editor has it.
-    pub fn restart(&mut self, start: NodeId, now: f64) {
-        self.start = start;
-        self.current = start;
-        self.sections.clear();
-        self.history.clear();
-        self.overlays.clear();
-        self.scroll.clear();
-        self.scroll_anim = None;
-        self.stop_scrolling();
-        self.pan = None;
-        self.anim = None;
-        self.temp = None;
-        self.design = self.original.clone();
-        self.relayout();
-        self.arrive(now);
-    }
-
-    fn revert(&mut self, now: f64) {
-        let Some(t) = self.temp.take() else { return };
-        self.begin(t.transition.reversed(), t.dur, t.easing, now);
-        self.current = t.snap.current;
-        self.design = Some(t.snap.doc);
-        self.relayout();
-        self.overlays = t.snap.overlays;
-        self.history = t.snap.history;
-        self.scroll = t.snap.scroll;
-        self.stop_scrolling();
-        self.hovered.clear();
-        self.rev += 1;
-    }
-
-    /// A mouse enter, leave, down or up on `node` (shown on `root`) met its interaction `k`: its
-    /// actions run now, or after its delay while `root` is still what shows (again once only
-    /// while it waits).
-    fn gesture(&mut self, node: NodeId, k: usize, rect: Option<Rect>, now: f64, root: NodeId) -> bool {
-        let delay = self.doc.as_ref().and_then(|d| d.node(node)).and_then(|n| n.interactions.get(k)).map_or(0.0, |it| it.delay_secs());
-        if delay <= 0.0 {
-            return self.fire(node, k, rect, now);
-        }
-        if !self.waiting.iter().any(|w| (w.node, w.k) == (node, k)) {
-            self.waiting.push(Waiting { node, k, rect, root, due: now + delay });
-        }
-        false
-    }
-
-    /// Run the delayed mouse triggers that are due (those whose screen or overlay went away are
-    /// dropped). True when one changed what shows.
-    fn fire_waiting(&mut self, root: NodeId, now: f64) -> bool {
-        let (due, later): (Vec<Waiting>, Vec<Waiting>) = std::mem::take(&mut self.waiting).into_iter().partition(|w| w.due <= now);
-        self.waiting = later;
-        self.waiting.retain(|w| w.root == root);
-        let mut did = false;
-        for w in due.into_iter().filter(|w| w.root == root) {
-            // An earlier one may have left the screen: the rest are dropped with it.
-            did = did || self.fire(w.node, w.k, w.rect, now);
-        }
-        did
-    }
-
-    /// Run the actions of interaction `k` on `node`. `rect` is the layer's screen rect.
-    fn fire(&mut self, node: NodeId, k: usize, rect: Option<Rect>, now: f64) -> bool {
-        let Some(it) = self.doc.as_ref().and_then(|d| d.node(node)).and_then(|n| n.interactions.get(k)).cloned() else { return false };
-        let dur = it.easing.seconds(it.duration_ms);
-        let temp = match it.trigger {
-            Trigger::OnHover => Some(false),
-            Trigger::OnPress => Some(true),
-            _ => None,
-        };
-        let snap = if temp.is_some() && self.temp.is_none() { self.snapshot() } else { None };
-        let mut did = false;
-        for a in &it.actions {
-            did |= self.perform(a, node, it.transition, dur, it.easing, rect, now);
-        }
-        if did && let (Some(press), Some(snap), Some(rect)) = (temp, snap, rect) {
-            self.temp = Some(Temp { rect, press, snap, transition: it.transition, dur, easing: it.easing });
-        }
-        did
-    }
-
-    /// Run the widget clicks the player took: each calls its plugin back on the player's copy (the
-    /// prototype's own state of the widget), as on the canvas but without touching the file.
-    /// Returns what went wrong, for a toast.
-    pub fn click_widgets(&mut self, s: &figcraft_engine::Session) -> Option<String> {
-        let mut error = None;
-        for (id, target) in std::mem::take(&mut self.widget_clicks) {
-            let Some(doc) = self.design.clone() else { break };
-            match figcraft_engine::widgets::click_on(s, doc, id, &target) {
-                Ok((d, _)) => {
-                    self.design = Some(d);
-                    self.relayout();
-                }
-                Err(e) => error = Some(e.to_string()),
-            }
-        }
-        error
-    }
-
     /// Screen rect `r` in page units of the frame shown last.
     fn page_rect(&self, r: Option<Rect>) -> Option<figcraft_geom::Rect> {
         let (r, (_, place, _)) = (r?, self.shown?);
         let (a, b) = (place.page(r.min), place.page(r.max));
         Some(figcraft_geom::Rect::new(a.x, a.y, b.x, b.y))
     }
-
-    fn perform(&mut self, a: &Action, node: NodeId, tr: Transition, dur: f64, easing: Easing, rect: Option<Rect>, now: f64) -> bool {
-        self.perform_at(a, node, tr, dur, easing, rect, now, 0)
-    }
-
-    /// One action; `depth` counts the conditional actions it is inside.
-    #[allow(clippy::too_many_arguments)]
-    fn perform_at(&mut self, a: &Action, node: NodeId, tr: Transition, dur: f64, easing: Easing, rect: Option<Rect>, now: f64, depth: usize) -> bool {
-        let Some(doc) = self.doc.clone() else { return false };
-        match a {
-            Action::Navigate { dest, preserve_scroll } => {
-                let Some(top) = figcraft_engine::proto_run::navigate_target(&doc, *dest, &self.sections) else { return false };
-                if !doc.contains(top) || (top == self.current && self.overlays.is_empty()) {
-                    return false;
-                }
-                self.go(top, tr, dur, easing, now, true, *preserve_scroll);
-                true
-            }
-            Action::Back => {
-                if self.close_overlay(now) {
-                    return true;
-                }
-                match self.history.pop() {
-                    Some(v) => {
-                        self.go(v.frame, v.transition.reversed(), v.dur, v.easing, now, false, false);
-                        true
-                    }
-                    None => false,
-                }
-            }
-            Action::ScrollTo { dest, offset } => {
-                let frames = self.scroll_to_layer(&doc, *dest, *offset);
-                if frames.is_empty() {
-                    return false;
-                }
-                if matches!(tr, Transition::Instant) || dur <= 0.0 {
-                    self.scroll.extend(frames.iter().map(|(f, _, to)| (*f, *to)));
-                    self.rev += 1;
-                } else {
-                    self.scroll_anim = Some(ScrollAnim { frames, start: now, dur, easing });
-                }
-                true
-            }
-            Action::OpenOverlay { dest, position, close_on_outside, background, offset, anchor } => {
-                let at = self.page_rect(rect);
-                if !doc.contains(*dest) {
-                    return false;
-                }
-                self.delays_fired.retain(|(id, _)| !doc.is_ancestor(*dest, *id));
-                self.overlays.push(OverlayState {
-                    id: *dest,
-                    position: *position,
-                    close_on_outside: *close_on_outside,
-                    background: *background,
-                    anchor: at,
-                    offset: *offset,
-                    anchor_to: *anchor,
-                    opened: now,
-                    transition: tr,
-                    dur,
-                    easing,
-                });
-                self.hovered.clear();
-                true
-            }
-            Action::SwapOverlay { dest } => {
-                let at = self.page_rect(rect);
-                if !doc.contains(*dest) {
-                    return false;
-                }
-                self.delays_fired.retain(|(id, _)| !doc.is_ancestor(*dest, *id));
-                match self.overlays.last_mut() {
-                    Some(o) => {
-                        o.id = *dest;
-                        o.opened = now;
-                        o.transition = tr;
-                        o.dur = dur;
-                        o.easing = easing;
-                    }
-                    None => self.overlays.push(OverlayState {
-                        id: *dest,
-                        position: OverlayPosition::Center,
-                        close_on_outside: true,
-                        background: None,
-                        anchor: at,
-                        offset: None,
-                        anchor_to: OverlayAnchor::Screen,
-                        opened: now,
-                        transition: tr,
-                        dur,
-                        easing,
-                    }),
-                }
-                self.hovered.clear();
-                true
-            }
-            Action::CloseOverlay => self.close_overlay(now),
-            Action::OpenUrl { url } => {
-                // The URL comes from the document and this action fires from whatever trigger the
-                // prototype sets, including a delay, so no click is implied: only a web link opens.
-                if figcraft_engine::doc_urls::openable(url) {
-                    self.urls.push(url.clone());
-                }
-                true
-            }
-            Action::ChangeTo { dest } => {
-                let Some(inst) = figcraft_engine::proto_run::change_to_target(&doc, node, *dest) else { return false };
-                if !doc.contains(*dest) {
-                    return false;
-                }
-                self.begin(tr, dur, easing, now);
-                let Some(d) = self.design.as_mut() else { return false };
-                let before = d.clone();
-                if let Some(n) = d.node_mut(inst)
-                    && let NodeKind::Instance { component, .. } = &mut n.kind
-                {
-                    *component = *dest;
-                }
-                figcraft_engine::components::sync_instance(d, inst);
-                self.settle(&before);
-                true
-            }
-            Action::SetVariable { variable, value, expr } => {
-                let Some(d) = self.design.as_mut() else { return false };
-                let before = d.clone();
-                let set = figcraft_engine::proto_run::set_variable(d, node, variable, value, expr.as_ref());
-                if set {
-                    self.settle(&before);
-                }
-                set
-            }
-            Action::SetVariableMode { collection, mode } => {
-                let Some(d) = self.design.as_mut() else { return false };
-                let before = d.clone();
-                let set = figcraft_engine::proto_run::set_mode(d, self.current, collection, mode);
-                if set {
-                    self.settle(&before);
-                }
-                set
-            }
-            Action::Conditional { blocks } => {
-                if depth >= figcraft_doc::proto::MAX_ACTION_DEPTH {
-                    return false;
-                }
-                // Evaluated now: earlier actions of the interaction may have changed variables.
-                let mut did = false;
-                for inner in figcraft_engine::proto_run::branch(&doc, node, blocks) {
-                    did |= self.perform_at(&inner, node, tr, dur, easing, rect, now, depth + 1);
-                }
-                did
-            }
-        }
-    }
-
-    fn texture(&mut self, ctx: &egui::Context, doc: &Document, id: NodeId, px_scale: f64, now: f64) -> Option<FrameTex> {
-        // Animated GIFs play from when the frame arrived: a new texture when one of them moves on,
-        // and a wake-up for that moment (nothing else draws frames while it shows). egui wakes a
-        // display frame before the time asked for, a little earlier still at times: ask that much
-        // later, and count a frame due within a few milliseconds as due.
-        let t = (now - self.arrived).max(0.0) + 0.005;
-        let clock = figcraft_render::images::animation_clock(doc, id, t);
-        if let Some((_, next)) = clock {
-            crate::repaint_in(ctx, next + f64::from(ctx.input(|i| i.predicted_dt)));
-        }
-        let key = (self.rev, px_scale.to_bits(), clock.map_or(0, |c| c.0));
-        if let Some(t) = self.textures.get(&id)
-            && t.key == key
-        {
-            return Some(t.clone());
-        }
-        let bounds = figcraft_render::export_bounds(doc, id)?;
-        let pix = figcraft_render::render_node_at(doc, id, texture_scale(ctx, bounds, px_scale), t)?;
-        let img = crate::render_worker::screen_image(&pix, doc.color_profile);
-        let tex = ctx.load_texture(format!("present-{}", id.0), img, egui::TextureOptions::LINEAR);
-        let ft = FrameTex { key, tex, bounds };
-        self.textures.insert(id, ft.clone());
-        Some(ft)
-    }
-}
-
-/// The most pixels a presented frame's texture holds (bigger prototypes, at 100% or filling the
-/// window, are drawn from a smaller texture scaled up).
-const MAX_TEXTURE_PIXELS: f64 = 16_777_216.0;
-
-/// The pixel scale, at most `px`, at which `bounds` makes a texture the GPU takes (no side past
-/// its limit) of at most [`MAX_TEXTURE_PIXELS`].
-fn texture_scale(ctx: &egui::Context, bounds: figcraft_geom::Rect, px: f64) -> f64 {
-    let side = ctx.input(|i| i.max_texture_side) as f64 - 2.0;
-    let (w, h) = (bounds.width().max(1.0), bounds.height().max(1.0));
-    let s = px.min(side / w.max(h)).min((MAX_TEXTURE_PIXELS / (w * h)).sqrt());
-    if s.is_finite() && s > 0.0 { s } else { 1e-3 }
-}
-
-/// Page → screen mapping for one presented frame.
-#[derive(Clone, Copy, Debug)]
-pub struct Place {
-    pub page_min: (f64, f64),
-    pub origin: Pos2,
-    pub scale: f64,
-}
-
-impl Place {
-    fn centered(fb: figcraft_geom::Rect, center: Pos2, scale: f64) -> Self {
-        let size = vec2((fb.width() * scale) as f32, (fb.height() * scale) as f32);
-        Place { page_min: (fb.x0, fb.y0), origin: center - size / 2.0, scale }
-    }
-    pub fn pt(&self, x: f64, y: f64) -> Pos2 {
-        pos2(self.origin.x + ((x - self.page_min.0) * self.scale) as f32, self.origin.y + ((y - self.page_min.1) * self.scale) as f32)
-    }
-    pub fn rect(&self, r: figcraft_geom::Rect) -> Rect {
-        Rect::from_min_max(self.pt(r.x0, r.y0), self.pt(r.x1, r.y1))
-    }
-    /// The page point under screen point `q`.
-    pub fn page(&self, q: Pos2) -> Point {
-        Point::new(self.page_min.0 + f64::from(q.x - self.origin.x) / self.scale, self.page_min.1 + f64::from(q.y - self.origin.y) / self.scale)
-    }
-}
-
-// ---------------------------------------------------------------------------------------------
-// Pure prototype logic (tested below).
-
-/// Layer names from below `root` down to `id`, joined (the smart-animate matching key).
-pub fn name_path(doc: &Document, root: NodeId, id: NodeId) -> Option<String> {
-    let mut parts: Vec<&str> = Vec::new();
-    let mut cur = id;
-    for _ in 0..1024 {
-        if cur == root {
-            parts.reverse();
-            return Some(parts.join("\u{1f}"));
-        }
-        let n = doc.node(cur)?;
-        parts.push(n.name.as_str());
-        cur = n.parent?;
-    }
-    None
-}
-
-/// Smart-animate pairs `(from layer, to layer)`: same name path below the two roots; repeated
-/// paths pair up in layer order.
-pub fn match_layers(from: &Document, from_root: NodeId, to: &Document, to_root: NodeId) -> Vec<(NodeId, NodeId)> {
-    let mut pool: HashMap<String, VecDeque<NodeId>> = HashMap::new();
-    for id in from.subtree(from_root).into_iter().skip(1) {
-        if let Some(p) = name_path(from, from_root, id) {
-            pool.entry(p).or_default().push_back(id);
-        }
-    }
-    let mut out = Vec::new();
-    for id in to.subtree(to_root).into_iter().skip(1) {
-        if let Some(p) = name_path(to, to_root, id)
-            && let Some(q) = pool.get_mut(&p)
-            && let Some(f) = q.pop_front()
-        {
-            out.push((f, id));
-        }
-    }
-    out
-}
-
-fn lerp(a: f64, b: f64, t: f64) -> f64 {
-    a + (b - a) * t
-}
-
-/// Centre, rotation and scale of a node box `(w, h)` placed by `m`.
-fn decompose(m: Affine, (w, h): (f64, f64)) -> Option<[f64; 5]> {
-    let [a, b, c, d, _, _] = m.as_coeffs();
-    let sx = a.hypot(b);
-    if !sx.is_finite() || sx < 1e-9 {
-        return None;
-    }
-    let sy = (a * d - b * c) / sx;
-    let ctr = m * Point::new(w / 2.0, h / 2.0);
-    Some([ctr.x, ctr.y, b.atan2(a), sx, sy])
-}
-
-/// Interpolate two placements of a box: centre, rotation (shortest way round) and scale; the box
-/// size is `size` (already interpolated).
-pub fn lerp_transform(a: Affine, sa: (f64, f64), b: Affine, sb: (f64, f64), size: (f64, f64), t: f64) -> Affine {
-    match (decompose(a, sa), decompose(b, sb)) {
-        (Some(x), Some(y)) if (x[4] < 0.0) == (y[4] < 0.0) => {
-            let mut da = y[2] - x[2];
-            while da > std::f64::consts::PI {
-                da -= std::f64::consts::TAU;
-            }
-            while da < -std::f64::consts::PI {
-                da += std::f64::consts::TAU;
-            }
-            let (cx, cy) = (lerp(x[0], y[0], t), lerp(x[1], y[1], t));
-            let ang = x[2] + da * t;
-            let (sx, sy) = (lerp(x[3], y[3], t), lerp(x[4], y[4], t));
-            Affine::translate((cx, cy)) * Affine::rotate(ang) * Affine::scale_non_uniform(sx, sy) * Affine::translate((-size.0 / 2.0, -size.1 / 2.0))
-        }
-        _ => {
-            if t < 0.5 {
-                a
-            } else {
-                b
-            }
-        }
-    }
-}
-
-fn lerp_paints(from: &[Paint], to: &mut [Paint], t: f64) {
-    for (f, p) in from.iter().zip(to.iter_mut()) {
-        if let (PaintKind::Solid { color: fc }, PaintKind::Solid { color: tc }) = (&f.kind, &mut p.kind) {
-            *tc = fc.lerp(*tc, t.clamp(0.0, 1.0) as f32);
-            p.opacity = lerp(f64::from(f.opacity), f64::from(p.opacity), t.clamp(0.0, 1.0)) as f32;
-        }
-    }
-}
-
-/// The document as it looks at eased progress `t` of a smart-animate transition from
-/// `from_root` (in `from`) to `to_root` (in `to`): matched layers tween position, size, rotation,
-/// opacity, corner radius and solid fill colours; layers only in the destination fade in and
-/// layers only in the source are copied in and fade out. Render `to_root` of the result.
-pub fn smart_interpolate(from: &Document, from_root: NodeId, to: &Document, to_root: NodeId, t: f64) -> Document {
-    let mut out = to.clone();
-    // Springs and back easings go past 1 before they settle: matched layers overshoot too.
-    if !t.is_finite() || t == 1.0 {
-        return out;
-    }
-    let t = t.max(-1.0);
-    let fade = t.clamp(0.0, 1.0);
-    let pairs = match_layers(from, from_root, to, to_root);
-    let src_of: HashMap<NodeId, NodeId> = pairs.iter().map(|(f, d)| (*d, *f)).collect();
-    let dst_of: HashMap<NodeId, NodeId> = pairs.iter().copied().collect();
-    let fw_inv = from.world_transform(from_root).inverse();
-    let tw_inv = to.world_transform(to_root).inverse();
-    if let (Some(fr), Some(m)) = (from.node(from_root), out.node_mut(to_root)) {
-        lerp_paints(&fr.fills, &mut m.fills, t);
-    }
-    let mut interp: HashMap<NodeId, Affine> = HashMap::new();
-    interp.insert(to_root, Affine::IDENTITY);
-    let mut faded: HashSet<NodeId> = HashSet::new();
-    for id in to.subtree(to_root).into_iter().skip(1) {
-        let Some(n) = to.node(id) else { continue };
-        let parent = n.parent.unwrap_or(to_root);
-        let p_interp = interp.get(&parent).copied().unwrap_or(Affine::IDENTITY);
-        match src_of.get(&id).and_then(|s| from.node(*s).map(|sn| (*s, sn))) {
-            Some((s, sn)) => {
-                let rel_s = fw_inv * from.world_transform(s);
-                let rel_d = tw_inv * to.world_transform(id);
-                let (w, h) = (lerp(sn.width, n.width, t).max(0.0), lerp(sn.height, n.height, t).max(0.0));
-                let xf = lerp_transform(rel_s, (sn.width, sn.height), rel_d, (n.width, n.height), (w, h), t);
-                interp.insert(id, xf);
-                if let Some(m) = out.node_mut(id) {
-                    m.width = w;
-                    m.height = h;
-                    m.transform = p_interp.inverse() * xf;
-                    m.opacity = lerp(f64::from(sn.opacity), f64::from(n.opacity), fade) as f32;
-                    for (r, (a, b)) in m.corners.radii.iter_mut().zip(sn.corners.radii.iter().zip(n.corners.radii.iter())) {
-                        *r = lerp(*a, *b, t).max(0.0);
-                    }
-                    lerp_paints(&sn.fills, &mut m.fills, t);
-                    lerp_paints(&sn.strokes, &mut m.strokes, t);
-                }
-            }
-            None => {
-                interp.insert(id, p_interp * n.transform);
-                if !faded.contains(&parent)
-                    && let Some(m) = out.node_mut(id)
-                {
-                    m.opacity *= fade as f32;
-                }
-                faded.insert(id);
-            }
-        }
-    }
-    // Layers only in the source: copy the top-most ones in, fading out.
-    let tops: Vec<NodeId> = from
-        .subtree(from_root)
-        .into_iter()
-        .skip(1)
-        .filter(|id| !dst_of.contains_key(id))
-        .filter(|id| from.node(*id).and_then(|n| n.parent).is_some_and(|p| p == from_root || dst_of.contains_key(&p)))
-        .collect();
-    for id in tops {
-        let Some(n) = from.node(id) else { continue };
-        let pf = n.parent.unwrap_or(from_root);
-        let matched_parent = dst_of.get(&pf).copied().filter(|p| out.node(*p).is_some_and(|pn| pn.kind.is_container()));
-        let (parent, local) = match matched_parent {
-            Some(p) if pf != from_root => (p, n.transform),
-            _ => (to_root, fw_inv * from.world_transform(id)),
-        };
-        let nodes: Vec<Node> = from.subtree(id).into_iter().filter_map(|i| from.node(i).cloned()).collect();
-        let mut map = BTreeMap::new();
-        for nn in &nodes {
-            map.insert(nn.id, out.alloc_id());
-        }
-        let index = from.index_in_parent(id);
-        if let Ok(new) = out.paste_nodes(&nodes, &map, id, parent, index)
-            && let Some(m) = out.node_mut(new)
-        {
-            m.transform = local;
-            m.opacity *= (1.0 - fade) as f32;
-        }
-    }
-    out
-}
-
-/// How far `frame`'s content can scroll `(x, y)` (0 when it doesn't overflow or doesn't scroll).
-pub fn scroll_range(doc: &Document, frame: NodeId) -> (f64, f64) {
-    scroll_range_in(doc, frame, None)
-}
-
-/// How far `frame`'s content can scroll when `viewport` (page units, from its top-left) of it
-/// shows, as a device's screen shows a top-level frame: the frame itself is content then, so a
-/// frame bigger than the screen scrolls through its whole size whatever its overflow (as in
-/// Figma, a top-level frame needs no overflow setting for that). Without a viewport the frame
-/// shows at its own size and what overflows it scrolls. Content past the frame's own edges
-/// scrolls only on the axes its overflow allows.
-pub fn scroll_range_in(doc: &Document, frame: NodeId, viewport: Option<(f64, f64)>) -> (f64, f64) {
-    let Some(n) = doc.node(frame) else { return (0.0, 0.0) };
-    if n.overflow == Overflow::None && viewport.is_none() {
-        return (0.0, 0.0);
-    }
-    let (mut x1, mut y1) = (0.0f64, 0.0f64);
-    for c in &n.children {
-        let Some(cn) = doc.node(*c) else { continue };
-        if !cn.visible || cn.scroll_position == ScrollPosition::Fixed {
-            continue;
-        }
-        let b = figcraft_geom::transform_rect_bbox(cn.transform, cn.local_rect());
-        x1 = x1.max(b.x1);
-        y1 = y1.max(b.y1);
-    }
-    if let Some(l) = &n.layout {
-        x1 += l.padding[1];
-        y1 += l.padding[2];
-    }
-    // Axes the overflow doesn't scroll clip what lies past the frame's edges.
-    if !matches!(n.overflow, Overflow::Horizontal | Overflow::Both) {
-        x1 = 0.0;
-    }
-    if !matches!(n.overflow, Overflow::Vertical | Overflow::Both) {
-        y1 = 0.0;
-    }
-    let (vw, vh) = match viewport {
-        Some(v) => {
-            x1 = x1.max(n.width);
-            y1 = y1.max(n.height);
-            v
-        }
-        None => (n.width, n.height),
-    };
-    let (rx, ry) = ((x1 - vw).max(0.0), (y1 - vh).max(0.0));
-    (if rx.is_finite() { rx } else { 0.0 }, if ry.is_finite() { ry } else { 0.0 })
-}
-
-/// `(x, y)` kept within `0..=range` on each axis (0 for non-finite values).
-fn clamp_scroll((x, y): (f64, f64), (rx, ry): (f64, f64)) -> (f64, f64) {
-    let c = |v: f64, r: f64| if v.is_finite() && r.is_finite() { v.clamp(0.0, r.max(0.0)) } else { 0.0 };
-    (c(x, rx), c(y, ry))
-}
-
-/// One axis of a fling after `dt` seconds: from offset `x` moving at `v` (units/s) in a range
-/// `0..=r`. Inside the range it slows down exponentially (`decay`, 1/s: it travels `v / decay`);
-/// past an end it either stops there or, with `bounce`, a critically damped spring pulls it back.
-/// Both are solved exactly over short sub-steps, so the motion doesn't depend on the frame rate.
-/// Returns the new offset and speed, and whether it has come to rest.
-pub fn fling_axis(x: f64, v: f64, r: f64, dt: f64, decay: f64, bounce: bool) -> (f64, f64, bool) {
-    if !(x.is_finite() && v.is_finite() && r.is_finite() && dt.is_finite() && decay > 0.0) || r <= 0.0 {
-        return (if r.is_finite() && x.is_finite() { x.clamp(0.0, r.max(0.0)) } else { 0.0 }, 0.0, true);
-    }
-    // A frame is never longer than a second, nor a fling faster than a million units a second.
-    let dt = dt.clamp(0.0, 1.0);
-    let steps = (dt * 240.0).ceil().clamp(1.0, 64.0);
-    let h = dt / steps;
-    let (mut x, mut v) = (x, v.clamp(-1e6, 1e6));
-    for _ in 0..steps as usize {
-        if (0.0..=r).contains(&x) {
-            let e = (-decay * h).exp();
-            x += v * (1.0 - e) / decay;
-            v *= e;
-            if !bounce && !(0.0..=r).contains(&x) {
-                x = x.clamp(0.0, r);
-                v = 0.0;
-            }
-        } else {
-            let end = x.clamp(0.0, r);
-            let (d, e) = (x - end, (-SPRING * h).exp());
-            let c = v + SPRING * d;
-            x = end + (d + c * h) * e;
-            v = (v - SPRING * c * h) * e;
-        }
-    }
-    if !x.is_finite() || !v.is_finite() {
-        return (0.0, 0.0, true);
-    }
-    let end = x.clamp(0.0, r);
-    if x == end && v.abs() < FLING_STOP {
-        return (x, 0.0, true);
-    }
-    if x != end && (x - end).abs() < 0.5 && v.abs() < FLING_STOP * 4.0 {
-        return (end, 0.0, true);
-    }
-    (x, v, false)
-}
-
-/// Where a drag to offset `x` shows in a range `0..=r`: past an end it stretches less the further
-/// it goes, never more than `limit` past.
-pub fn rubber_band(x: f64, r: f64, limit: f64) -> f64 {
-    if !x.is_finite() || !r.is_finite() || r <= 0.0 || !limit.is_finite() || limit <= 0.0 {
-        return if x.is_finite() && r.is_finite() { x.clamp(0.0, r.max(0.0)) } else { 0.0 };
-    }
-    let band = |over: f64| limit * (1.0 - 1.0 / (over * 0.55 / limit + 1.0));
-    if x < 0.0 {
-        -band(-x)
-    } else if x > r {
-        r + band(x - r)
-    } else {
-        x
-    }
-}
-
-/// The prototype settings of the page holding `id` (defaults when there's none).
-pub fn page_settings(doc: &Document, id: NodeId) -> PrototypeSettings {
-    doc.page_of(id)
-        .and_then(|pg| doc.node(pg))
-        .and_then(|n| match &n.kind {
-            NodeKind::Page { prototype, .. } => Some(prototype.clone()),
-            _ => None,
-        })
-        .unwrap_or_default()
-}
-
-/// The part of top-level `frame` its page's device shows (page units): the frame clipped to the
-/// device's screen. None without a device: the frame then shows whole.
-pub fn viewport(doc: &Document, frame: NodeId) -> Option<(f64, f64)> {
-    let d = page_settings(doc, frame).device()?;
-    let n = doc.node(frame)?;
-    Some((n.width.min(d.width), n.height.min(d.height)))
-}
-
-/// Size `frame` to the `(w, h)` of it a screen shows. The content keeps its place (what doesn't
-/// fit is clipped or scrolls); fixed layers follow their constraints to the screen's edges, so a
-/// tab bar pinned to the frame's bottom sits at the bottom of the screen (stretching constraints
-/// keep the layer's size).
-pub fn fit_viewport(doc: &mut Document, frame: NodeId, (w, h): (f64, f64)) {
-    let Some(n) = doc.node(frame) else { return };
-    let (dw, dh) = (w - n.width, h - n.height);
-    if !dw.is_finite() || !dh.is_finite() || (dw == 0.0 && dh == 0.0) {
-        return;
-    }
-    let fixed: Vec<NodeId> =
-        n.children.iter().copied().filter(|c| doc.node(*c).is_some_and(|c| c.scroll_position == ScrollPosition::Fixed)).collect();
-    for c in fixed {
-        if let Some(m) = doc.node_mut(c) {
-            let dx = match m.constraints.horizontal {
-                HConstraint::Right => dw,
-                HConstraint::Center => dw / 2.0,
-                _ => 0.0,
-            };
-            let dy = match m.constraints.vertical {
-                VConstraint::Bottom => dh,
-                VConstraint::Center => dh / 2.0,
-                _ => 0.0,
-            };
-            m.transform = Affine::translate((dx, dy)) * m.transform;
-        }
-    }
-    if let Some(m) = doc.node_mut(frame) {
-        m.width = w;
-        m.height = h;
-    }
-}
-
-/// Shift scrolling frames' children by their scroll offsets. Fixed children stay put; sticky
-/// children scroll until they reach the frame's top/left edge, then stay there.
-pub fn apply_scroll(doc: &Document, scroll: &HashMap<NodeId, (f64, f64)>) -> Document {
-    let mut out = doc.clone();
-    let sticky = |pos: f64, s: f64| if pos >= 0.0 && pos - s < 0.0 { -pos } else { -s };
-    for (&frame, &(sx, sy)) in scroll {
-        if !sx.is_finite() || !sy.is_finite() || (sx == 0.0 && sy == 0.0) {
-            continue;
-        }
-        let Some(n) = doc.node(frame) else { continue };
-        for &c in &n.children {
-            let Some(cn) = doc.node(c) else { continue };
-            let (dx, dy) = match cn.scroll_position {
-                ScrollPosition::Fixed => continue,
-                ScrollPosition::Scrolls => (-sx, -sy),
-                ScrollPosition::Sticky => {
-                    let b = figcraft_geom::transform_rect_bbox(cn.transform, cn.local_rect());
-                    (sticky(b.x0, sx), sticky(b.y0, sy))
-                }
-            };
-            if let Some(m) = out.node_mut(c) {
-                m.transform = Affine::translate((dx, dy)) * m.transform;
-            }
-        }
-    }
-    out
-}
-
-/// Fixed layers draw (and take clicks) above the content that scrolls under them: each frame's
-/// fixed children move to the top of its children, keeping their order (for the player's copy).
-pub fn raise_fixed(doc: &mut Document) {
-    let fixed = |c: &NodeId| doc.node(*c).is_some_and(|c| c.scroll_position == ScrollPosition::Fixed);
-    let moves: Vec<(NodeId, Vec<NodeId>)> = doc
-        .nodes()
-        .filter(|n| !matches!(n.kind, NodeKind::Page { .. }) && n.children.iter().any(fixed))
-        .filter_map(|n| {
-            let (top, mut order): (Vec<NodeId>, Vec<NodeId>) = n.children.iter().partition(|c| fixed(c));
-            order.extend(top);
-            (order != n.children).then_some((n.id, order))
-        })
-        .collect();
-    for (id, order) in moves {
-        if let Some(n) = doc.node_mut(id) {
-            n.children = order;
-        }
-    }
-}
-
-/// Where the outgoing and incoming frames are drawn at eased progress `t`.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct FramePlacement {
-    /// Offsets as fractions of each frame's size.
-    pub from_off: (f32, f32),
-    pub from_alpha: f32,
-    pub to_off: (f32, f32),
-    pub to_alpha: f32,
-    pub from_on_top: bool,
-}
-
-/// The unit vector a direction moves along (screen space, y down).
-pub fn direction_vec(d: Direction) -> (f32, f32) {
-    match d {
-        Direction::Left => (-1.0, 0.0),
-        Direction::Right => (1.0, 0.0),
-        Direction::Top => (0.0, -1.0),
-        Direction::Bottom => (0.0, 1.0),
-    }
-}
-
-/// Frame offsets/opacities for a transition. Directions name where things move: "Move in, left"
-/// brings the new frame in from the right edge moving left.
-pub fn transition_frames(tr: Transition, t: f32) -> FramePlacement {
-    let mul = |(x, y): (f32, f32), k: f32| (x * k, y * k);
-    let base = FramePlacement { from_off: (0.0, 0.0), from_alpha: 1.0, to_off: (0.0, 0.0), to_alpha: 1.0, from_on_top: false };
-    match tr {
-        Transition::Instant => FramePlacement { from_alpha: 0.0, ..base },
-        Transition::Dissolve | Transition::SmartAnimate => FramePlacement { to_alpha: t.clamp(0.0, 1.0), ..base },
-        Transition::MoveIn { direction } => FramePlacement { to_off: mul(direction_vec(direction), -(1.0 - t)), ..base },
-        Transition::MoveOut { direction } => FramePlacement { from_off: mul(direction_vec(direction), t), from_on_top: true, ..base },
-        Transition::Push { direction } => {
-            let d = direction_vec(direction);
-            FramePlacement { from_off: mul(d, t), to_off: mul(d, -(1.0 - t)), ..base }
-        }
-        Transition::SlideIn { direction } => {
-            let d = direction_vec(direction);
-            FramePlacement { from_off: mul(d, 0.3 * t), to_off: mul(d, -(1.0 - t)), ..base }
-        }
-        Transition::SlideOut { direction } => {
-            let d = direction_vec(direction);
-            FramePlacement { from_off: mul(d, t), to_off: mul(d, -0.3 * (1.0 - t)), from_on_top: true, ..base }
-        }
-    }
-}
-
-/// Screen rect of an overlay of `size` over the frame drawn at `base`. A manual one sits `offset`
-/// (screen points) from the top-left of `anchor`, the layer that opened it; without an offset,
-/// right below it.
-pub fn overlay_rect(pos: OverlayPosition, base: Rect, size: Vec2, anchor: Option<Rect>, offset: Option<Vec2>) -> Rect {
-    let cx = base.center().x - size.x / 2.0;
-    let cy = base.center().y - size.y / 2.0;
-    let (x, y) = match pos {
-        OverlayPosition::Center => (cx, cy),
-        OverlayPosition::TopLeft => (base.min.x, base.min.y),
-        OverlayPosition::TopCenter => (cx, base.min.y),
-        OverlayPosition::TopRight => (base.max.x - size.x, base.min.y),
-        OverlayPosition::BottomLeft => (base.min.x, base.max.y - size.y),
-        OverlayPosition::BottomCenter => (cx, base.max.y - size.y),
-        OverlayPosition::BottomRight => (base.max.x - size.x, base.max.y - size.y),
-        OverlayPosition::Manual => match (anchor, offset) {
-            (Some(a), Some(o)) => (a.min.x + o.x, a.min.y + o.y),
-            (Some(a), None) => (a.min.x, a.max.y),
-            (None, _) => (cx, cy),
-        },
-    };
-    Rect::from_min_size(pos2(x, y), size)
 }
 
 /// If no layer on the screen opened the overlay, the screen places it.
@@ -1502,1462 +440,6 @@ pub fn anchored_overlay_rect(
     }
 }
 
-/// The hotspots of the screen `root` (its visible layers with interactions, bottom-most first)
-/// placed on screen and clipped by `screen`.
-fn hotspots(doc: &Document, root: NodeId, place: &Place, screen: Rect) -> Vec<(NodeId, Rect)> {
-    figcraft_engine::proto_run::hotspots(doc, root)
-        .into_iter()
-        .map(|(id, b)| (id, place.rect(b).intersect(screen)))
-        .filter(|(_, r)| r.is_positive())
-        .collect()
-}
-
-/// The first interaction index on `id` whose trigger satisfies `want`.
-fn find_trigger(doc: &Document, id: NodeId, want: impl Fn(&Trigger) -> bool) -> Option<usize> {
-    doc.node(id)?.interactions.iter().position(|it| want(&it.trigger))
-}
-
-// ---------------------------------------------------------------------------------------------
-// The player UI, shared by the full-window presenter and the preview pane.
-
-struct Layout {
-    disp: Document,
-    scale: f64,
-    place: Place,
-    /// What shows the prototype: the device's screen, else the presented frame itself.
-    screen: Rect,
-    /// What the presented frame may draw into: the device's screen, else the whole area (shadows
-    /// and overflowing content show around a frame presented without a device).
-    clip: Rect,
-    device: Option<Device>,
-    /// The device is turned to landscape.
-    landscape: bool,
-    /// The colour of the device's body, when it is drawn around its screen.
-    color: Option<DeviceColor>,
-    overlays: Vec<(NodeId, Place, Rect)>,
-    /// Overlays animating out (same order as `Presenter::closing`).
-    closing: Vec<(NodeId, Place, Rect)>,
-}
-
-impl Layout {
-    /// The active layer (the top overlay, else the presented frame `current`), where it's placed
-    /// and what it may draw into.
-    fn active(&self, current: NodeId) -> (NodeId, Place, Rect) {
-        match self.overlays.last() {
-            Some((id, pl, _)) => (*id, *pl, self.screen),
-            None => (current, self.place, self.clip),
-        }
-    }
-}
-
-/// The soonest "after delay" interaction in `root`'s subtree that hasn't fired yet, and the seconds
-/// until it's due (zero or less: due now). Timers start when the screen arrives, an overlay's when
-/// it opens.
-fn next_delay(p: &Presenter, doc: &Document, root: NodeId, now: f64) -> Option<((NodeId, usize), f64)> {
-    let since = p.overlays.last().filter(|o| o.id == root).map_or(p.arrived, |o| o.opened);
-    let mut next: Option<((NodeId, usize), f64)> = None;
-    for id in doc.subtree(root) {
-        let Some(n) = doc.node(id) else { continue };
-        for (k, it) in n.interactions.iter().enumerate() {
-            if let Trigger::AfterDelay { ms } = it.trigger
-                && !p.delays_fired.contains(&(id, k))
-            {
-                let due = since + f64::from(ms) / 1000.0 - now;
-                if next.is_none_or(|(_, d)| due < d) {
-                    next = Some(((id, k), due));
-                }
-            }
-        }
-    }
-    next
-}
-
-/// The width of a device's screen of `size` held upright (its short side when turned).
-fn upright_w(size: Vec2, landscape: bool) -> f32 {
-    if landscape { size.y } else { size.x }
-}
-
-/// Bezel width around a device's screen of upright width `w`, and the screen's corner radius.
-fn bezel(device: &str, w: f32) -> (f32, f32) {
-    match device {
-        "MacBook Air" => ((w * 0.025).max(6.0), 0.0),
-        "Desktop" => ((w * 0.02).max(6.0), 0.0),
-        d if d.starts_with("iPad") => ((w * 0.05).max(8.0), w * 0.04),
-        _ => ((w * 0.06).max(6.0), w * 0.13),
-    }
-}
-
-/// How far a device's body reaches past its screen of `size`: (each side, top, bottom). A phone
-/// turned to landscape has its side buttons above and below.
-fn body_outset(device: &str, size: Vec2, landscape: bool) -> (f32, f32, f32) {
-    let w = upright_w(size, landscape);
-    let (b, _) = bezel(device, w);
-    match device {
-        "MacBook Air" => (b + w * 0.08, b, b + (w * 0.022).max(6.0)),
-        "Desktop" => (b, b, b + w * 0.08 + 6.0),
-        _ if landscape => (b, b + 3.0, b + 3.0),
-        _ => (b + 3.0, b, b),
-    }
-}
-
-/// Place the presented frame in `area`: on its device's screen (the whole device sized by the
-/// view's scale option), else the frame itself. Fit and 100% keep the chrome's padding from the
-/// edges; Fit never goes above 100%. What doesn't fit the window pans (`Presenter::pan`). The
-/// preview pane always fits. A responsive prototype's frame is first resized to the device's
-/// screen, or without a device to the whole area (shown at 100%).
-fn layout(p: &mut Presenter, area: Rect, chrome: Chrome) -> Option<Layout> {
-    let settings = page_settings(p.doc.as_ref()?, p.current);
-    let (device, landscape) = (settings.device(), settings.landscape());
-    let fills = settings.responsive && device.is_none();
-    let whole_area = (f64::from(area.width().round()), f64::from(area.height().round()));
-    p.respond_to(settings.responsive.then(|| device.map_or(whole_area, |d| (d.width, d.height))));
-    let disp = p.display()?;
-    let fb = disp.world_bounds(p.current)?;
-    let view = if chrome.pane { PresentView::default() } else { p.view };
-    // Custom sizes are just a screen: no body.
-    let body = device.filter(|d| view.device_frame && !d.colors.is_empty());
-    let pad = if !fills && matches!(view.scale, PresentScale::Fit | PresentScale::Actual) { chrome.pad } else { 0.0 };
-    let avail = area.shrink(pad);
-    let (sw, sh) = device.map_or((fb.width(), fb.height()), |d| (d.width, d.height));
-    // The screen at `scale`, the body's outsets around it and the whole size.
-    let outer = |scale: f64| {
-        let size = vec2((sw * scale) as f32, (sh * scale) as f32);
-        let (x, top, bottom) = body.map_or((0.0, 0.0, 0.0), |d| body_outset(d.name, size, landscape));
-        (size, x, top, vec2(size.x + 2.0 * x, size.y + top + bottom))
-    };
-    // The factor that makes something of size `o` fit, fill… the available space.
-    let factor = |o: Vec2| {
-        let (kx, ky) = (avail.width() / o.x.max(1.0), avail.height() / o.y.max(1.0));
-        f64::from(match view.scale {
-            PresentScale::Fit => kx.min(ky),
-            PresentScale::FitWidth => kx,
-            PresentScale::Fill => kx.max(ky),
-            PresentScale::Actual => 1.0,
-        })
-    };
-    let mut scale = if fills { 1.0 } else { factor(vec2(sw as f32, sh as f32)) };
-    // The body doesn't scale exactly with the screen (its edges have a minimum): size it once more.
-    if body.is_some() {
-        scale *= factor(outer(scale).3);
-    }
-    let max = if view.scale == PresentScale::Fit { 1.0 } else { 16.0 };
-    let scale = if scale.is_finite() { scale.clamp(0.01, max) } else { 0.01 };
-    let (size, x, top, whole) = outer(scale);
-    p.zoom = scale;
-    // What's bigger than the window pans: starting centred across and at the top.
-    let over = |d: f32| if d > 0.5 { d } else { 0.0 };
-    let excess = vec2(over(whole.x - avail.width()), over(whole.y - avail.height()));
-    p.pan_range = (f64::from(excess.x), f64::from(excess.y));
-    // While a drag or fling moves the view it may stretch past the ends; otherwise it stays in range.
-    let live = matches!(p.drag_scroll, Some((Scroller::View, _))) || p.fling.is_some_and(|f| f.target == Scroller::View);
-    if !live {
-        p.pan = p.pan.map(|v| clamp_scroll(v, p.pan_range));
-    }
-    let pan = p.offset(Scroller::View);
-    let along = |excess: f32, min: f32, centre: f32, len: f32, pan: f64| if excess > 0.0 { min - pan as f32 } else { centre - len / 2.0 };
-    let min = pos2(along(excess.x, avail.min.x, area.center().x, whole.x, pan.0), along(excess.y, avail.min.y, area.center().y, whole.y, pan.1));
-    let screen = Rect::from_min_size(min + vec2(x, top), size);
-    let place = Place::centered(fb, screen.center(), scale);
-    let place_overlay = |o: &OverlayState| {
-        let ob = disp.world_bounds(o.id)?;
-        let size = vec2((ob.width() * scale) as f32, (ob.height() * scale) as f32);
-        let offset = o.offset.map(|[x, y]| vec2((x * scale) as f32, (y * scale) as f32));
-        let r = anchored_overlay_rect(o.position, o.anchor_to, screen, size, o.anchor.map(|a| place.rect(a)), offset);
-        Some((o.id, Place { page_min: (ob.x0, ob.y0), origin: r.min, scale }, r))
-    };
-    let overlays = p.overlays.iter().filter_map(place_overlay).collect();
-    let closing = p.closing.iter().filter_map(|(_, o)| place_overlay(o)).collect();
-    let clip = if device.is_some() { screen } else { area };
-    let color = body.and(settings.device_color());
-    Some(Layout { disp, scale, place, screen, clip, device, landscape, color, overlays, closing })
-}
-
-/// Where the player sits: the whole window or the preview pane.
-#[derive(Clone, Copy, Debug, PartialEq)]
-struct Chrome {
-    pane: bool,
-    bar_h: f32,
-    /// Space kept around the device or frame.
-    pad: f32,
-    /// Corner radius of the window around the player (the pane's).
-    round: u8,
-    /// The player may take keys (the pane only while hovered, and never while the editor is
-    /// typing: text on the canvas or in a field).
-    keys: bool,
-}
-
-const FULL: Chrome = Chrome { pane: false, bar_h: 40.0, pad: 32.0, round: 0, keys: true };
-
-/// What the player's top bar asked for.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum BarAction {
-    Close,
-    Restart,
-    /// Present full-window (from the pane).
-    Present,
-    /// The full-window presenter's options menu (handled in the bar).
-    Options,
-    /// Turn responsive presentation on or off (saved in the file: `proto.settings`).
-    Responsive(bool),
-    /// Show or hide the comments on the presented frame.
-    Comments,
-    /// Show or hide the Inspect panel.
-    Inspect,
-}
-
-pub struct PresentTab {
-    pub id: u64,
-    /// Empty while the tab is on screen: then the player is in `app.ui.present`.
-    pub pres: Option<Presenter>,
-    pub doc_uid: u64,
-    pub path: Option<String>,
-    pub page: NodeId,
-    pub file: String,
-    pub page_name: String,
-}
-
-/// The full-window presenter (while `app.ui.present` is set). Escape or Close ends it.
-pub fn show(app: &mut FigApp, ui: &mut Ui) {
-    let ctx = ui.ctx().clone();
-    let now = ctx.input(|i| i.time);
-    let Some(mut pres) = app.ui.present.take() else { return };
-    // A tab can play a file that is closed or not in front. Then it must not read or change
-    // the file in front.
-    let live = crate::tabs::present_owner_active(app);
-    if live && let Ok(ds) = app.session.ds() {
-        pres.sync(&ds.doc, now);
-    }
-    poll_pads(app, &mut pres, &ctx);
-    let mut action = None;
-    // Typing a reply to a comment keeps the keys from the prototype, and so does the link notice
-    // while it shows; Shift+C shows the comments.
-    let typing = ctx.egui_wants_keyboard_input() || pres.link_notice.is_some();
-    if !typing && ctx.input_mut(|i| i.consume_key(egui::Modifiers::SHIFT, egui::Key::C)) {
-        action = Some(BarAction::Comments);
-    }
-    if pres.view.inspect {
-        let t = Tokens::get(&ctx);
-        egui::Panel::right("present_inspect")
-            .resizable(false)
-            .exact_size(INSPECT_W)
-            .frame(egui::Frame::NONE.fill(t.panel).stroke(Stroke::new(1.0, t.border)))
-            .show(ui, |ui| inspect_panel(app, ui, &pres));
-    }
-    egui::CentralPanel::default().frame(egui::Frame::NONE).show(ui, |ui| {
-        action = player(&mut pres, ui, ui.max_rect(), now, Chrome { keys: !typing, ..FULL }).or(action);
-    });
-    let picked_device = navigation_bar(&mut pres, &ctx, now);
-    // Keys the prototype left alone: C shows the comments, F fills the screen.
-    if !typing {
-        if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::C)) {
-            action = Some(BarAction::Comments);
-        }
-        if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::F)) {
-            let full = ctx.input(|i| i.viewport().fullscreen.unwrap_or(false));
-            ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(!full));
-        }
-    }
-    match action {
-        Some(BarAction::Comments) => pres.view.comments = !pres.view.comments,
-        Some(BarAction::Inspect) => pres.view.inspect = !pres.view.inspect,
-        _ => {}
-    }
-    if live
-        && pres.view.comments
-        && let Some((frame, place, clip)) = pres.shown
-    {
-        crate::comments::presenter(app, &ctx, frame, place, clip);
-    } else if app.ui.comments.open.is_some() {
-        app.ui.comments.close();
-    }
-    finish(app, &mut pres);
-    link_notice(app, &mut pres, &ctx, Id::unique("present_link_notice"));
-    // The options carry over to the next presentation.
-    app.ui.present_view = pres.view;
-    if live && let Some(BarAction::Responsive(on)) = action {
-        app.run("proto.settings", json!({"responsive": on}));
-    }
-    if live && let Some(device) = picked_device {
-        choose_device(app, &mut pres, &device);
-    }
-    app.ui.present = Some(pres);
-    if action == Some(BarAction::Close) || ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
-        if let Some(id) = app.ui.present_active {
-            crate::tabs::close_present(app, id);
-        } else {
-            app.ui.present = None;
-        }
-    }
-}
-
-/// Device choices in the presenter use the screen's real dimensions and reflow a copy of the
-/// design through constraints and auto layout. "No device" returns to the original frame size.
-fn choose_device(app: &mut FigApp, p: &mut Presenter, device: &str) {
-    let responsive = device != "None";
-    if app.run("proto.settings", json!({"device": device, "responsive": responsive})).is_some() {
-        p.reset_for_device();
-    }
-}
-
-/// Controls that stay in reach while viewing a prototype, including screen stepping, device and
-/// scale. The selected device is returned to the caller so it can go through the normal document
-/// command (and undo/save) rather than changing only the player's copy.
-fn navigation_bar(p: &mut Presenter, ctx: &egui::Context, now: f64) -> Option<String> {
-    let t = Tokens::get(ctx);
-    let doc = p.doc.as_ref()?;
-    let frames = doc.top_frames(doc.page_of(p.current).unwrap_or(p.current));
-    let index = frames.iter().position(|id| *id == p.current);
-    let settings = page_settings(doc, p.current);
-    let mut navigate = None;
-    let mut device_choice = None;
-    egui::Area::new(Id::unique("present_navigation")).anchor(Align2::CENTER_BOTTOM, vec2(0.0, -18.0)).order(egui::Order::Foreground).show(
-        ctx,
-        |ui| {
-            egui::Frame::NONE
-                .fill(t.panel)
-                .stroke(Stroke::new(1.0, t.border))
-                .corner_radius(CornerRadius::same(9))
-                .inner_margin(egui::Margin::symmetric(8, 5))
-                .show(ui, |ui| {
-                    ui.horizontal(|ui| {
-                        let prev = index.and_then(|i| i.checked_sub(1)).and_then(|i| frames.get(i)).copied();
-                        let next = index.and_then(|i| frames.get(i + 1)).copied();
-                        let previous =
-                            ui.add_enabled(prev.is_some(), egui::Button::new("").min_size(vec2(26.0, 24.0))).on_hover_text(tr("Previous frame"));
-                        icons::paint(
-                            ui.painter(),
-                            Rect::from_center_size(previous.rect.center(), vec2(21.0, 21.0)),
-                            Icon::ChevronLeft,
-                            if prev.is_some() { t.icon } else { t.icon_secondary },
-                        );
-                        if previous.clicked() {
-                            navigate = prev;
-                        }
-                        ui.label(egui::RichText::new(format!("{} / {}", index.map_or(0, |i| i + 1), frames.len())).color(t.text));
-                        let following =
-                            ui.add_enabled(next.is_some(), egui::Button::new("").min_size(vec2(26.0, 24.0))).on_hover_text(tr("Next frame"));
-                        icons::paint(
-                            ui.painter(),
-                            Rect::from_center_size(following.rect.center(), vec2(21.0, 21.0)),
-                            Icon::ChevronRight,
-                            if next.is_some() { t.icon } else { t.icon_secondary },
-                        );
-                        if following.clicked() {
-                            navigate = next;
-                        }
-                        ui.separator();
-                        let model = if settings.device.is_empty() || settings.device == "None" { tr("No device") } else { &settings.device };
-                        let device_menu = ui.menu_button(format!("{model}    "), |ui| {
-                            navigation_menu(ui, |ui| {
-                                egui::ScrollArea::vertical().max_height(410.0).show(ui, |ui| {
-                                    if ui.selectable_label(settings.device.is_empty() || settings.device == "None", tr("No device")).clicked() {
-                                        device_choice = Some("None".to_owned());
-                                        ui.close();
-                                    }
-                                    ui.separator();
-                                    for device in PrototypeSettings::DEVICES {
-                                        let label = format!("{}  {}×{}", device.name, device.width as u32, device.height as u32);
-                                        if ui.selectable_label(settings.device == device.name, label).clicked() {
-                                            device_choice = Some(device.name.to_owned());
-                                            ui.close();
-                                        }
-                                    }
-                                    ui.separator();
-                                    if ui.selectable_label(settings.device == PrototypeSettings::CUSTOM_DEVICE, tr("Custom size")).clicked() {
-                                        device_choice = Some(PrototypeSettings::CUSTOM_DEVICE.to_owned());
-                                        ui.close();
-                                    }
-                                });
-                            });
-                        });
-                        paint_menu_chevron(ui.painter(), device_menu.response.rect, t.icon_secondary);
-                        let scale_menu = ui.menu_button(format!("{}    ", tr(p.view.scale.label(settings.device().is_some()))), |ui| {
-                            navigation_menu(ui, |ui| {
-                                for scale in PresentScale::options(settings.device().is_some()) {
-                                    if ui.selectable_label(p.view.scale == *scale, tr(scale.label(settings.device().is_some()))).clicked() {
-                                        p.set_scale(*scale);
-                                        ui.close();
-                                    }
-                                }
-                            });
-                        });
-                        paint_menu_chevron(ui.painter(), scale_menu.response.rect, t.icon_secondary);
-                    });
-                });
-        },
-    );
-    if let Some(id) = navigate {
-        p.go(id, Transition::Instant, 0.0, Easing::Linear, now, true, false);
-    }
-    device_choice
-}
-
-fn paint_menu_chevron(painter: &egui::Painter, button: Rect, color: Color32) {
-    let icon = Rect::from_center_size(pos2(button.right() - 11.0, button.center().y), vec2(17.0, 17.0));
-    icons::paint(painter, icon, Icon::Chevron, color);
-}
-
-fn navigation_menu(ui: &mut Ui, add: impl FnOnce(&mut Ui)) {
-    ui.set_min_width(212.0);
-    add(ui);
-}
-
-/// How often the player polls the controllers while its prototype has gamepad triggers (seconds).
-const PAD_POLL_SECS: f64 = 1.0 / 30.0;
-
-/// Before a player's frame: the controller buttons pressed since the last one, polled only while
-/// the prototype has gamepad triggers and the window has the focus (systems and browsers report
-/// controllers to the focused window only; focus coming back draws a frame, which polls again).
-fn poll_pads(app: &mut FigApp, p: &mut Presenter, ctx: &egui::Context) {
-    if !p.uses_pads || !ctx.input(|i| i.focused) {
-        return;
-    }
-    let held = app.services.gamepad_held();
-    let down = held & !p.pads_held;
-    p.pads_held = held;
-    // Each press once, in layout order.
-    let pressed = (0..u32::BITS as usize).filter(|i| down & (1 << i) != 0).filter_map(figcraft_doc::proto::gamepad_button);
-    p.pads.extend(pressed.map(str::to_string));
-    crate::repaint_in(ctx, PAD_POLL_SECS);
-}
-
-/// After a player's frame: the links it opens and the widget clicks it took. A link to a website
-/// waits in [`link_notice`] unless the viewer chose to skip the notice; a second link to a website
-/// that fires while the notice shows is dropped.
-fn finish(app: &mut FigApp, p: &mut Presenter) {
-    for u in p.urls.drain(..) {
-        if app.session.prefs.link_notice_skipped || !goes_to_a_website(&u) {
-            app.services.open_url(&u);
-        } else if p.link_notice.is_none() {
-            p.link_notice = Some((u, false));
-        }
-    }
-    if let Some(e) = p.click_widgets(&app.session) {
-        app.toast(e);
-    }
-}
-
-/// Whether `url` is an `http` or `https` link (a `mailto:` link opens the mail app instead).
-fn goes_to_a_website(url: &str) -> bool {
-    url.trim().split_once(':').is_some_and(|(scheme, _)| scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https"))
-}
-
-/// The notice before a link leaves the prototype for a website: the link, "Don't show this
-/// again" (saved with the preferences when Open link is pressed), Open link and Cancel. Escape or
-/// the close button cancels.
-fn link_notice(app: &mut FigApp, p: &mut Presenter, ctx: &egui::Context, id: Id) {
-    let Some((url, skip)) = p.link_notice.as_mut() else { return };
-    let t = Tokens::get(ctx);
-    let (mut open, mut go, mut cancel) = (true, false, false);
-    crate::dialogs::window(tr("Leaving the prototype"), ctx).id(id).open(&mut open).show(ctx, |ui| {
-        ui.set_width(340.0);
-        widgets::label(ui, tr("This link opens a website outside the prototype:"), t.text);
-        ui.add(egui::Label::new(egui::RichText::new(url.as_str()).font(regular(11.0)).color(t.text_secondary)).wrap());
-        ui.add_space(8.0);
-        if widgets::checkbox(ui, *skip, tr("Don't show this again")) {
-            *skip = !*skip;
-        }
-        ui.add_space(12.0);
-        ui.horizontal(|ui| {
-            go = widgets::button(ui, tr("Open link"), true, true).clicked();
-            cancel = widgets::button(ui, tr("Cancel"), false, true).clicked();
-        });
-    });
-    cancel |= !open || ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape));
-    if go {
-        let Some((url, skip)) = p.link_notice.take() else { return };
-        if skip {
-            app.run("proto.linkNotice", json!({"show": false}));
-            app.services.save_prefs(&app.session.prefs);
-        }
-        app.services.open_url(&url);
-    } else if cancel {
-        p.link_notice = None;
-    }
-}
-
-/// The width of the presenter's Inspect panel.
-const INSPECT_W: f32 = 280.0;
-
-/// The presenter's Inspect panel: the inspected layer's properties, as in the Inspect tab.
-fn inspect_panel(app: &mut FigApp, ui: &mut Ui, pres: &Presenter) {
-    let t = Tokens::get(ui.ctx());
-    let found = pres.inspected.zip(pres.doc.as_ref()).and_then(|(id, doc)| doc.node(id).map(|n| (id, doc, n.name.clone())));
-    egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
-        let Some((id, doc, name)) = found else {
-            widgets::section_header(ui, tr("Inspect"), &[], false);
-            widgets::note(ui, tr("Hover a layer to see its properties"), t.text_secondary);
-            return;
-        };
-        widgets::section_header(ui, &name, &[], false);
-        for section in figcraft_engine::devinspect::properties(doc, id) {
-            crate::right::inspect_section(app, ui, &section);
-        }
-    });
-}
-
-/// The top-most visible layer of `root` (it included) under the screen point `q`.
-fn layer_at(doc: &Document, root: NodeId, place: &Place, q: Pos2) -> Option<NodeId> {
-    let mut hidden: HashSet<NodeId> = HashSet::new();
-    let mut hit = None;
-    for id in doc.subtree(root) {
-        let Some(n) = doc.node(id) else { continue };
-        if !n.visible || n.parent.is_some_and(|p| hidden.contains(&p)) {
-            hidden.insert(id);
-            continue;
-        }
-        if doc.world_bounds(id).is_some_and(|b| place.rect(b).contains(q)) {
-            hit = Some(id);
-        }
-    }
-    hit
-}
-
-/// The prototype preview pane: the player in a floating, resizable window over the canvas. It
-/// follows edits live, and selecting another top-level frame in the editor shows that frame.
-pub struct Pane {
-    pub player: Presenter,
-    /// The open file it previews (another tab closes it).
-    doc_uid: u64,
-    /// The top-level frame last selected in the editor.
-    selected: Option<NodeId>,
-}
-
-/// The top-level frame of the editor's first selected layer.
-fn selected_frame(ds: &figcraft_engine::DocState) -> Option<NodeId> {
-    ds.selection.first().and_then(|i| ds.doc.top_level_frame(*i))
-}
-
-impl Pane {
-    pub fn new(start: NodeId, session: &figcraft_engine::Session) -> Self {
-        let (doc_uid, selected) = session.ds().map(|ds| (ds.uid, selected_frame(ds))).unwrap_or((0, None));
-        Pane { player: Presenter::new(start), doc_uid, selected }
-    }
-}
-
-/// The preview pane's window id (its position and size persist under it).
-pub fn pane_id() -> Id {
-    Id::unique("proto_preview_pane")
-}
-
-/// Show the preview pane while `app.ui.preview` is set (call once per frame, before shortcuts:
-/// keys a hovered pane's prototype uses don't reach the editor).
-pub fn show_pane(app: &mut FigApp, ctx: &egui::Context) {
-    let Some(mut pane) = app.ui.preview.take() else { return };
-    let Ok(ds) = app.session.ds() else { return };
-    if ds.uid != pane.doc_uid {
-        return;
-    }
-    let now = ctx.input(|i| i.time);
-    let (doc, selected) = (ds.doc.clone(), selected_frame(ds));
-    pane.player.sync(&doc, now);
-    // Deselecting and coming back to the same frame keeps the preview where it got to.
-    if selected.is_some() && selected != pane.selected {
-        pane.selected = selected;
-        if let Some(f) = selected.filter(|f| *f != pane.player.current) {
-            pane.player.restart(f, now);
-        }
-    }
-    let t = Tokens::get(ctx);
-    let canvas = app.canvas.rect;
-    let style = ctx.global_style();
-    let typing = ds.text_edit.is_some() || crate::a11y::field_focused(ctx);
-    let chrome = Chrome { pane: true, bar_h: 36.0, pad: 12.0, round: style.visuals.window_corner_radius.nw, keys: !typing };
-    poll_pads(app, &mut pane.player, ctx);
-    let mut action = None;
-    egui::Window::new(tr("Prototype preview"))
-        .id(pane_id())
-        .title_bar(false)
-        .collapsible(false)
-        .resizable(true)
-        .default_size(vec2(320.0, 600.0))
-        .min_size(vec2(220.0, 260.0))
-        .default_pos(pos2(canvas.max.x - 336.0, canvas.min.y + 16.0))
-        .constrain_to(ctx.content_rect())
-        .frame(egui::Frame::window(&style).fill(t.panel).inner_margin(egui::Margin::same(0)))
-        .show(ctx, |ui| {
-            let (rect, _) = ui.allocate_exact_size(ui.available_size(), Sense::hover());
-            action = player(&mut pane.player, ui, rect, now, chrome);
-        });
-    finish(app, &mut pane.player);
-    link_notice(app, &mut pane.player, ctx, pane_id().with("link_notice"));
-    match action {
-        Some(BarAction::Close) => {}
-        Some(BarAction::Present) => {
-            let start = pane.player.current;
-            app.ui.preview = Some(pane);
-            app.run("proto.present", json!({"start": start}));
-        }
-        _ => app.ui.preview = Some(pane),
-    }
-}
-
-/// The black glass around a device's screen.
-const GLASS: Color32 = Color32::from_rgb(0x16, 0x16, 0x18);
-
-/// A device colour lighter (`k` > 0, towards white) or darker (`k` < 0, towards black).
-fn shade([r, g, b]: [u8; 3], k: f32) -> Color32 {
-    let k = k.clamp(-1.0, 1.0);
-    let f = |c: u8| {
-        let c = f32::from(c);
-        (if k >= 0.0 { c + (255.0 - c) * k } else { c * (1.0 + k) }).round().clamp(0.0, 255.0) as u8
-    };
-    Color32::from_rgb(f(r), f(g), f(b))
-}
-
-/// The width of the coloured band round a device's glass (upright screen width `w`, bezel `b`).
-fn rim(w: f32, b: f32) -> f32 {
-    (w * 0.016).clamp(1.5, (b * 0.5).max(1.5))
-}
-
-/// Body of the presentation device behind the screen `s` (drawn in code: rounded slabs in the
-/// device's colour with black glass round the screen). Turned to landscape (a quarter turn
-/// counter-clockwise), a phone's left side is at the bottom.
-fn device_body(p: &egui::Painter, device: &str, s: Rect, landscape: bool, color: DeviceColor) {
-    let (body, edge, metal) = (shade(color.rgb, 0.0), shade(color.rgb, -0.3), shade(color.rgb, 0.12));
-    let w = upright_w(s.size(), landscape);
-    let (b, screen_r) = bezel(device, w);
-    let band = rim(w, b);
-    let radius = |r: f32| CornerRadius::same(r.clamp(0.0, 255.0) as u8);
-    match device {
-        "MacBook Air" => {
-            // The lid's coloured edge round black glass, then the base: a thin slab wider than
-            // the lid, with a finger notch.
-            let lid = s.expand(b);
-            p.rect_filled(lid, radius(b * 1.2), body);
-            p.rect_filled(lid.shrink(band), radius(b * 1.2 - band), GLASS);
-            let base = Rect::from_min_max(pos2(lid.min.x - w * 0.08, lid.max.y), pos2(lid.max.x + w * 0.08, lid.max.y + (w * 0.022).max(6.0)));
-            p.rect_filled(base, CornerRadius { nw: 2, ne: 2, sw: 10, se: 10 }, metal);
-            let notch = Rect::from_center_size(pos2(base.center().x, base.min.y + 1.5), vec2(w * 0.12, 3.0));
-            p.rect_filled(notch, CornerRadius::same(2), edge);
-        }
-        "Desktop" => {
-            let screen = s.expand(b);
-            p.rect_filled(screen, CornerRadius::same(8), body);
-            p.rect_filled(screen.shrink(band), radius(8.0 - band), GLASS);
-            let neck =
-                Rect::from_min_max(pos2(screen.center().x - w * 0.06, screen.max.y), pos2(screen.center().x + w * 0.06, screen.max.y + w * 0.08));
-            p.rect_filled(neck, CornerRadius::ZERO, metal);
-            let foot = Rect::from_min_max(pos2(neck.min.x - w * 0.06, neck.max.y), pos2(neck.max.x + w * 0.06, neck.max.y + 6.0));
-            p.rect_filled(foot, CornerRadius::same(3), edge);
-        }
-        _ => {
-            // Phones and tablets: a rounded slab (phones with side buttons).
-            let slab = s.expand(b);
-            if !device.starts_with("iPad") {
-                // (on the left side, from the top, length) as fractions of the upright side.
-                for (left, f0, h) in [(true, 0.18, 0.06), (true, 0.27, 0.1), (false, 0.24, 0.13)] {
-                    let btn = if landscape {
-                        let y = if left { slab.max.y - 0.5 } else { slab.min.y - 2.5 };
-                        Rect::from_min_size(pos2(slab.min.x + slab.width() * f0, y), vec2(slab.width() * h, 2.5))
-                    } else {
-                        let x = if left { slab.min.x - 2.0 } else { slab.max.x };
-                        Rect::from_min_size(pos2(x, slab.min.y + slab.height() * f0), vec2(2.5, slab.height() * h))
-                    };
-                    p.rect_filled(btn, CornerRadius::same(1), edge);
-                }
-            }
-            p.rect_filled(slab, radius(screen_r + b), body);
-            p.rect_stroke(slab, radius(screen_r + b), Stroke::new(1.0, edge), StrokeKind::Inside);
-            // The glass reaches round the screen's square corners (masked by `device_glass`).
-            let glass = b - band;
-            p.rect_filled(slab.shrink(band), radius((screen_r + glass).min(glass * 3.4)), GLASS);
-        }
-    }
-}
-
-/// What sits on top of the screen: rounded screen corners (glass masks the frame's square
-/// corners) and a phone's camera pill (at the left when turned to landscape).
-fn device_glass(p: &egui::Painter, device: &str, s: Rect, landscape: bool) {
-    let w = upright_w(s.size(), landscape);
-    let (_, screen_r) = bezel(device, w);
-    if screen_r <= 0.0 {
-        return;
-    }
-    p.add(corner_masks(s, screen_r.min(s.width() / 2.0).min(s.height() / 2.0), GLASS));
-    if device.starts_with("iPhone") {
-        let pill = if landscape {
-            Rect::from_center_size(pos2(s.min.x + w * 0.045, s.center().y), vec2(w * 0.085, w * 0.3))
-        } else {
-            Rect::from_center_size(pos2(s.center().x, s.min.y + w * 0.045), vec2(w * 0.3, w * 0.085))
-        };
-        p.rect_filled(pill, CornerRadius::same((w * 0.0425).min(255.0) as u8), Color32::BLACK);
-    }
-}
-
-/// Fill what lies between each corner of `s` and its rounding of radius `r` (fans of triangles
-/// from the corner to the arc).
-fn corner_masks(s: Rect, r: f32, color: Color32) -> egui::Shape {
-    const SEGMENTS: usize = 12;
-    if !(r.is_finite() && r > 0.0) {
-        return egui::Shape::Noop;
-    }
-    let mut mesh = egui::Mesh::default();
-    // (corner, centre of its arc, angle the arc starts at).
-    let corners = [
-        (s.left_top(), s.left_top() + vec2(r, r), std::f32::consts::PI),
-        (s.right_top(), s.right_top() + vec2(-r, r), std::f32::consts::FRAC_PI_2 * 3.0),
-        (s.right_bottom(), s.right_bottom() + vec2(-r, -r), 0.0),
-        (s.left_bottom(), s.left_bottom() + vec2(r, -r), std::f32::consts::FRAC_PI_2),
-    ];
-    for (corner, centre, start) in corners {
-        let base = mesh.vertices.len() as u32;
-        mesh.colored_vertex(corner, color);
-        for k in 0..=SEGMENTS {
-            let a = start + std::f32::consts::FRAC_PI_2 * k as f32 / SEGMENTS as f32;
-            mesh.colored_vertex(centre + r * vec2(a.cos(), a.sin()), color);
-        }
-        for k in 0..SEGMENTS as u32 {
-            mesh.add_triangle(base, base + 1 + k, base + 2 + k);
-        }
-    }
-    egui::Shape::mesh(mesh)
-}
-
-/// One frame of the player in `rect`: the top bar, then the prototype (on its device) below.
-/// Returns what the bar asked for (restarting is done here).
-fn player(p: &mut Presenter, ui: &mut Ui, rect: Rect, now: f64, chrome: Chrome) -> Option<BarAction> {
-    let ctx = ui.ctx().clone();
-    p.clock = now;
-    let bar = Rect::from_min_size(rect.min, vec2(rect.width(), chrome.bar_h));
-    let area = Rect::from_min_max(pos2(rect.min.x, bar.max.y), rect.max);
-    let bg = crate::theme::doc_c32(ui.ctx(), p.doc.as_ref().map(|d| page_settings(d, p.current)).unwrap_or_default().background);
-    let r = chrome.round;
-    ui.painter().rect_filled(area, CornerRadius { nw: 0, ne: 0, sw: r, se: r }, bg);
-    let action = top_bar(p, ui, bar, now, chrome);
-    if action == Some(BarAction::Restart) {
-        p.restart(p.start, now);
-    }
-    if p.doc.as_ref().is_none_or(|d| !d.contains(p.current)) {
-        // Controller buttons pressed with no frame to show are dropped, as they are while a link
-        // notice shows.
-        p.pads.clear();
-        if !chrome.pane {
-            return Some(BarAction::Close);
-        }
-        ui.painter().text(area.center(), Align2::CENTER_CENTER, tr("Select a frame to preview it"), regular(12.0), Color32::from_gray(170));
-        return action;
-    }
-    // Scroll animation (Scroll to).
-    if let Some(sa) = &p.scroll_anim {
-        let raw = ((now - sa.start) / sa.dur.max(1e-3)).clamp(0.0, 1.0);
-        let e = sa.easing.eval(raw);
-        for (f, from, to) in &sa.frames {
-            p.scroll.insert(*f, (lerp(from.0, to.0, e), lerp(from.1, to.1, e)));
-        }
-        p.rev += 1;
-        if raw >= 1.0 {
-            p.scroll_anim = None;
-        }
-        ctx.request_repaint();
-    }
-    // Scrolling that carries on after the input let go (repaints only while it moves).
-    if p.step_fling(now) {
-        ctx.request_repaint();
-    }
-    let resp = ui.interact(area, ui.scope_id().with("present_area"), Sense::click_and_drag());
-    let over = resp.contains_pointer();
-    if let Some(l) = layout(p, area, chrome) {
-        // The pane only takes the keyboard while the pointer is over it. While a link notice shows
-        // the prototype takes neither keys nor the pointer (Escape there cancels the notice).
-        let keys = chrome.keys && p.link_notice.is_none() && (!chrome.pane || over);
-        input(p, &ctx, &l, over && p.link_notice.is_none(), keys, chrome.pane, now);
-    } else {
-        p.pads.clear();
-    }
-    let Some(l) = layout(p, area, chrome) else { return action };
-    p.shown = Some((p.current, l.place, l.clip.intersect(area)));
-    let painter = ui.painter_at(area);
-    let body = l.device.zip(l.color);
-    if l.device.is_some() {
-        if let Some((d, c)) = body {
-            device_body(&painter, d.name, l.screen, l.landscape, c);
-        }
-        painter.rect_filled(l.screen, CornerRadius::ZERO, bg);
-    }
-    draw(p, &painter, &ctx, &l, now);
-    if p.view.inspect && !chrome.pane {
-        inspect_hover(p, &painter, &ctx, &l, area);
-    }
-    if let Some((d, _)) = body {
-        device_glass(&painter, d.name, l.screen, l.landscape);
-    }
-    // Timers: wake up for the soonest pending "after delay" of the layer that can fire it (they
-    // wait while a transition plays, which draws every frame anyway).
-    if p.anim.is_none()
-        && let Some((_, due)) = next_delay(p, &l.disp, l.active(p.current).0, now)
-    {
-        crate::repaint_in(&ctx, due.min(60.0));
-    }
-    // And for the soonest mouse trigger waiting out its delay.
-    if let Some(due) = p.waiting.iter().map(|w| w.due - now).reduce(f64::min) {
-        crate::repaint_in(&ctx, due.clamp(0.0, 60.0));
-    }
-    action
-}
-
-/// Inspecting: the layer under the pointer becomes the inspected one; it is outlined.
-fn inspect_hover(p: &mut Presenter, painter: &egui::Painter, ctx: &egui::Context, l: &Layout, area: Rect) {
-    let (root, place, clip) = l.active(p.current);
-    if let Some(q) = ctx.pointer_hover_pos().filter(|q| area.contains(*q) && clip.contains(*q))
-        && let Some(id) = layer_at(&l.disp, root, &place, q)
-    {
-        p.inspected = Some(id);
-    }
-    if let Some(id) = p.inspected.filter(|id| *id == root || l.disp.is_ancestor(root, *id))
-        && let Some(b) = l.disp.world_bounds(id)
-    {
-        painter.with_clip_rect(clip).rect_stroke(place.rect(b), CornerRadius::ZERO, Stroke::new(1.5, ACCENT), StrokeKind::Outside);
-    }
-}
-
-/// The bar above the prototype: the flow picker and the frame's name on the left, the buttons on
-/// the right (text on the dark full-window bar, icons in the pane, which follows the theme).
-fn top_bar(p: &mut Presenter, ui: &mut Ui, bar: Rect, now: f64, chrome: Chrome) -> Option<BarAction> {
-    let t = Tokens::get(ui.ctx());
-    let (fill, text, dim, hover) = (t.panel, t.text, t.text_secondary, t.hover);
-    let r = chrome.round;
-    ui.painter().rect_filled(bar, CornerRadius { nw: r, ne: r, sw: 0, se: 0 }, fill);
-    if chrome.pane {
-        ui.painter().line_segment([bar.left_bottom(), bar.right_bottom()], Stroke::new(1.0, t.border));
-    }
-    let source_key = p.source.as_ref().map_or(0, |s| Arc::as_ptr(s) as usize);
-    if !chrome.pane && p.bar_thumb.as_ref().is_none_or(|(id, source, _)| *id != p.current || *source != source_key) {
-        p.bar_thumb =
-            p.source.as_ref().and_then(|d| crate::assets_panel::thumbnail(ui.ctx(), d, p.current, 38.0)).map(|tex| (p.current, source_key, tex));
-    }
-    let doc = p.doc.as_ref()?;
-    let name = doc.node(p.current).map(|n| n.name.clone()).unwrap_or_default();
-    let flows = match doc.page_of(p.start).and_then(|pg| doc.node(pg)).map(|n| &n.kind) {
-        Some(NodeKind::Page { flows, .. }) => flows.clone(),
-        _ => vec![],
-    };
-    let settings = page_settings(doc, p.current);
-    let device = settings.device();
-    let mut action = None;
-    // Right: the buttons, right to left (English labels key their ids; shown translated).
-    let buttons: &[(BarAction, &str, Icon)] = if chrome.pane {
-        &[
-            (BarAction::Close, tr_noop("Close preview"), Icon::Close),
-            (BarAction::Present, tr_noop("Present"), Icon::Play),
-            (BarAction::Restart, tr_noop("Restart"), Icon::Reset),
-        ]
-    } else {
-        &[
-            (BarAction::Close, tr_noop("Close"), Icon::Close),
-            (BarAction::Restart, tr_noop("Restart"), Icon::Reset),
-            (BarAction::Options, tr_noop("Options"), Icon::Dots),
-            (BarAction::Comments, tr_noop("Comments"), Icon::Comment),
-            (BarAction::Inspect, tr_noop("Inspect"), Icon::Code),
-        ]
-    };
-    let mut x = bar.max.x - if chrome.pane { 6.0 } else { 8.0 };
-    for (act, label, icon) in buttons {
-        let shown = tr(label);
-        let w = if chrome.pane { 24.0 } else { ui.painter().layout_no_wrap(shown.to_string(), regular(11.5), text).size().x + 16.0 };
-        let br = Rect::from_min_size(pos2(x - w, bar.center().y - 12.0), vec2(w, 24.0));
-        x = br.min.x - if chrome.pane { 2.0 } else { 4.0 };
-        let mut resp = ui.interact(br, ui.scope_id().with(("pbar", *label)), Sense::click());
-        if chrome.pane {
-            resp = resp.tip(shown);
-        }
-        let on = (*act == BarAction::Comments && p.view.comments) || (*act == BarAction::Inspect && p.view.inspect);
-        if on {
-            ui.painter().rect_filled(br, CornerRadius::same(5), t.accent);
-        } else if resp.hovered() {
-            ui.painter().rect_filled(br, CornerRadius::same(5), hover);
-        }
-        if *act == BarAction::Comments {
-            resp = resp.tip(tr("Show comments (Shift+C)"));
-        }
-        if *act == BarAction::Inspect {
-            resp = resp.tip(tr("Inspect the layer under the pointer: size, colours, typography"));
-        }
-        if chrome.pane {
-            icons::paint(ui.painter(), br.shrink(5.0), *icon, if on { t.accent_on } else { t.icon });
-        } else {
-            ui.painter().text(br.center(), Align2::CENTER_CENTER, shown, regular(11.5), if on { t.accent_on } else { text });
-        }
-        if *act == BarAction::Options {
-            let menu = crate::right::menu_popup(&resp).width(220.0).show(|ui| options_menu(p, ui, device, settings.responsive, now));
-            action = action.or(menu.and_then(|m| m.inner));
-        } else if resp.clicked() {
-            action = Some(*act);
-        }
-    }
-    // Left: the flow picker and the frame's name, clipped before the buttons.
-    let left = ui.painter().with_clip_rect(Rect::from_min_max(bar.min, pos2(x, bar.max.y)));
-    let mut lx = bar.min.x + if chrome.pane { 8.0 } else { 12.0 };
-    if !chrome.pane {
-        let thumb = Rect::from_center_size(pos2(lx + 15.0, bar.center().y), vec2(28.0, 28.0));
-        left.rect_filled(thumb, CornerRadius::same(4), t.field);
-        if let Some((_, _, tex)) = &p.bar_thumb {
-            let size = tex.size_vec2();
-            if size.x > 0.0 && size.y > 0.0 {
-                let scaled = size * (26.0 / size.x.max(size.y));
-                let dst = Rect::from_center_size(thumb.center(), scaled);
-                left.image(tex.id(), dst, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
-            }
-        }
-        lx += 38.0;
-    }
-    // The flow playing: its name on the picker, its description on hover; the menu lists each
-    // flow with its description.
-    let playing = flows.iter().find(|f| f.start == p.start);
-    if !flows.is_empty() {
-        let label = playing.map_or(tr("Flows"), |f| f.name.as_str()).to_owned();
-        let tip = playing.map(|f| f.description.trim()).filter(|d| !d.is_empty()).unwrap_or(tr("Flows")).to_string();
-        let galley = left.layout_no_wrap(label, semibold(11.5), text);
-        let fr = Rect::from_min_size(pos2(lx, bar.center().y - 12.0), vec2(galley.size().x + 30.0, 24.0));
-        let resp = ui.interact(fr.intersect(left.clip_rect()), ui.scope_id().with("pflows"), Sense::click()).tip(tip);
-        if resp.hovered() {
-            left.rect_filled(fr, CornerRadius::same(5), hover);
-        }
-        left.galley(pos2(fr.min.x + 8.0, fr.center().y - galley.size().y / 2.0), galley, text);
-        paint_menu_chevron(&left, fr, t.icon_secondary);
-        crate::right::menu_popup(&resp).width(240.0).show(|ui| {
-            let t = Tokens::get(ui.ctx());
-            for f in &flows {
-                if crate::right::menu_check(ui, f.start == p.start, &f.name, "") {
-                    p.restart(f.start, now);
-                    ui.close();
-                }
-                let d = f.description.trim();
-                if !d.is_empty() {
-                    egui::Frame::NONE.inner_margin(egui::Margin { left: 26, right: 8, top: 0, bottom: 4 }).show(ui, |ui| {
-                        ui.add(egui::Label::new(egui::RichText::new(d).font(regular(10.5)).color(t.text_secondary)).wrap());
-                    });
-                }
-            }
-        });
-        lx = fr.max.x + 8.0;
-        left.text(pos2(lx, bar.center().y), Align2::LEFT_CENTER, "/", regular(11.5), dim);
-        lx += 14.0;
-    }
-    left.text(pos2(lx, bar.center().y), Align2::LEFT_CENTER, name, regular(11.5), text);
-    action
-}
-
-/// The full-window presenter's options menu: how the prototype is sized (Z cycles them), whether
-/// the frame is responsive (a file setting: the frame takes the window's size, or on a device the
-/// screen's, instead of being scaled or shown at a fixed size), the device's body, hotspot hints,
-/// restart (R).
-fn options_menu(p: &mut Presenter, ui: &mut Ui, device: Option<Device>, responsive: bool, now: f64) -> Option<BarAction> {
-    use crate::right::menu_check;
-    let mut action = None;
-    let on_device = device.is_some();
-    // Without a device, responsive is one of the sizes: the frame fills the window at 100%.
-    if !on_device && menu_check(ui, responsive, tr("Responsive"), "") {
-        action = Some(BarAction::Responsive(true));
-        ui.close();
-    }
-    for s in PresentScale::options(on_device) {
-        if menu_check(ui, p.view.scale == *s && (on_device || !responsive), s.label(on_device), "") {
-            p.set_scale(*s);
-            if !on_device && responsive {
-                action = Some(BarAction::Responsive(false));
-            }
-            ui.close();
-        }
-    }
-    if (on_device || !responsive) && menu_check(ui, false, tr("Next size option"), "Z") {
-        p.set_scale(p.view.scale.next(on_device));
-        ui.close();
-    }
-    ui.separator();
-    // On a device: the frame takes the screen's size, or keeps its own (clipped or scrolling).
-    if on_device {
-        for (on, label) in [(true, tr("Responsive")), (false, tr("Fixed size"))] {
-            if menu_check(ui, responsive == on, label, "") {
-                action = (responsive != on).then_some(BarAction::Responsive(on));
-                ui.close();
-            }
-        }
-        ui.separator();
-    }
-    if device.is_some_and(|d| !d.colors.is_empty()) && menu_check(ui, p.view.device_frame, tr("Show device frame"), "") {
-        p.view.device_frame = !p.view.device_frame;
-        ui.close();
-    }
-    if menu_check(ui, p.view.hotspot_hints, tr("Show hotspot hints"), "") {
-        p.view.hotspot_hints = !p.view.hotspot_hints;
-        ui.close();
-    }
-    if menu_check(ui, false, tr("Restart"), "R") {
-        p.restart(p.start, now);
-        ui.close();
-    }
-    action
-}
-
-/// Scrolling frames under the screen point `q`, innermost first: those of `root` (in the display
-/// document `disp`) that can scroll (`base` is the player's document without scroll offsets).
-fn scrollers_at(p: &Presenter, base: &Document, disp: &Document, root: NodeId, place: &Place, q: Pos2) -> Vec<NodeId> {
-    let mut out: Vec<NodeId> = disp
-        .subtree(root)
-        .into_iter()
-        .filter(|f| disp.node(*f).is_some_and(|n| n.visible && (n.overflow != Overflow::None || *f == root)))
-        .filter(|f| disp.world_bounds(*f).is_some_and(|b| place.rect(b).contains(q)))
-        .filter(|f| p.range(base, *f) != (0.0, 0.0))
-        .collect();
-    out.reverse();
-    out
-}
-
-/// Keep a key the prototype used from reaching the editor's shortcuts.
-fn consume_key(ctx: &egui::Context, key: egui::Key) {
-    ctx.input_mut(|i| i.events.retain(|e| !matches!(e, egui::Event::Key { key: k, .. } if *k == key)));
-}
-
-/// Screen points → `t`'s units (page units for frames, points for the view).
-fn units_per_point(t: Scroller, scale: f64) -> f64 {
-    match t {
-        Scroller::Frame(_) => 1.0 / scale.max(1e-6),
-        Scroller::View => 1.0,
-    }
-}
-
-/// Pointer, wheel, keys and timers. `over_area`: the pointer is over the player; `keys_on`: the
-/// player takes the keyboard; `pane`: it plays in the preview pane (which always fits).
-#[allow(clippy::too_many_arguments)]
-fn input(p: &mut Presenter, ctx: &egui::Context, l: &Layout, over_area: bool, keys_on: bool, pane: bool, now: f64) {
-    let (pos, pressed, released, down, wheel, velocity, dt, keys) = ctx.input(|i| {
-        let keys: Vec<(egui::Key, egui::Modifiers)> = i
-            .events
-            .iter()
-            .filter_map(|e| match e {
-                egui::Event::Key { key, pressed: true, repeat: false, modifiers, .. } => Some((*key, *modifiers)),
-                _ => None,
-            })
-            .collect();
-        (
-            i.pointer.hover_pos(),
-            i.pointer.button_pressed(egui::PointerButton::Primary),
-            i.pointer.button_released(egui::PointerButton::Primary),
-            i.pointer.primary_down(),
-            i.smooth_scroll_delta,
-            i.pointer.velocity(),
-            f64::from(i.unstable_dt).clamp(1.0 / 500.0, 0.1),
-            keys,
-        )
-    });
-    let keys = if keys_on { keys } else { Vec::new() };
-    // Controller buttons pressed while a link notice shows are dropped, as keys are.
-    let pads = std::mem::take(&mut p.pads);
-    let pads = if p.link_notice.is_none() { pads } else { Vec::new() };
-    // A transition a drag started follows the pointer while it stays down, then plays on from there.
-    if let Some(a) = p.anim.as_mut()
-        && let Some((from, dir, len)) = a.follow
-    {
-        match pos.filter(|_| down) {
-            Some(q) => a.start = now - f64::from(((q - from).dot(dir) / len).clamp(0.0, 1.0)) * a.dur,
-            None => a.follow = None,
-        }
-    }
-    let pos = pos.filter(|_| over_area || p.press.is_some());
-    // A drag that scrolled lets go: it carries on at the pointer's speed (and springs back from
-    // past the ends).
-    if !down && let Some((t, _)) = p.drag_scroll.take() {
-        let u = units_per_point(t, l.scale);
-        let r = p.doc.as_ref().map_or((0.0, 0.0), |b| p.limits(b, t));
-        let along = |v: f32, r: f64| if r > 0.0 { -f64::from(v) * u } else { 0.0 };
-        p.fling = Some(Fling { target: t, vel: (along(velocity.x, r.0), along(velocity.y, r.1)), decay: DECAY_DRAG, bounce: true, at: now });
-    }
-    // The active layer: the top overlay, else the frame.
-    let (root, place, clip) = l.active(p.current);
-    let doc = &l.disp;
-    let hot = hotspots(doc, root, &place, clip);
-    p.hot.clone_from(&hot);
-    if p.fire_waiting(root, now) {
-        return;
-    }
-    // "While hovering / pressing" reverts.
-    if let Some(tmp) = &p.temp {
-        let leave = if tmp.press { released || !down } else { pos.is_none_or(|q| !tmp.rect.contains(q)) };
-        if leave {
-            p.revert(now);
-            return;
-        }
-    }
-    // The wheel scrolls the innermost frame under the pointer that can still move that way, else
-    // pans a view bigger than the window. When it stops it coasts on, slowing down.
-    if wheel != Vec2::ZERO
-        && let Some(q) = pos
-        && let Some(base) = p.doc.clone()
-    {
-        let mut targets: Vec<Scroller> = scrollers_at(p, &base, doc, root, &place, q).into_iter().map(Scroller::Frame).collect();
-        if p.pan_range != (0.0, 0.0) {
-            targets.push(Scroller::View);
-        }
-        let mut moved = None;
-        for t in targets {
-            let u = units_per_point(t, l.scale);
-            let cur = p.offset(t);
-            let next = clamp_scroll((cur.0 - f64::from(wheel.x) * u, cur.1 - f64::from(wheel.y) * u), p.limits(&base, t));
-            if (next.0 - cur.0).abs() > 1e-6 || (next.1 - cur.1).abs() > 1e-6 {
-                p.set_offset(t, next);
-                p.scroll_anim = None;
-                p.fling = None;
-                moved = Some((t, ((next.0 - cur.0) / dt, (next.1 - cur.1) / dt)));
-                break;
-            }
-        }
-        // The wheel's speed, smoothed over ~50 ms whatever the frame rate.
-        p.wheel = moved.map(|(t, inst)| {
-            let prev = p.wheel.filter(|w| w.0 == t).map_or(inst, |w| w.1);
-            let a = 1.0 - (-dt / 0.05).exp();
-            (t, (lerp(prev.0, inst.0, a), lerp(prev.1, inst.1, a)))
-        });
-    } else if wheel == Vec2::ZERO
-        && let Some((t, v)) = p.wheel.take()
-        && v.0.hypot(v.1) > COAST_MIN * units_per_point(t, l.scale)
-    {
-        p.fling = Some(Fling { target: t, vel: v, decay: DECAY_WHEEL, bounce: false, at: now });
-    }
-    let hits: Vec<(NodeId, Rect)> = hot.iter().rev().filter(|(_, r)| pos.is_some_and(|q| r.contains(q))).copied().collect();
-    if !hits.is_empty() {
-        ctx.set_cursor_icon(egui::CursorIcon::PointingHand);
-    }
-    // First (top-most) hit that has a matching trigger.
-    let pick = |want: &dyn Fn(&Trigger) -> bool| -> Option<(NodeId, usize, Rect)> {
-        hits.iter().find_map(|(id, r)| find_trigger(doc, *id, want).map(|k| (*id, k, *r)))
-    };
-    // Enter / leave.
-    let ids: Vec<NodeId> = hits.iter().map(|h| h.0).collect();
-    let entered: Vec<(NodeId, Rect)> = hits.iter().filter(|(id, _)| !p.hovered.contains(id)).copied().collect();
-    let left: Vec<NodeId> = p.hovered.iter().filter(|id| !ids.contains(id)).copied().collect();
-    p.hovered = ids;
-    for id in left {
-        if let Some(k) = find_trigger(doc, id, |t| *t == Trigger::MouseLeave)
-            && p.gesture(id, k, None, now, root)
-        {
-            return;
-        }
-    }
-    for (id, r) in &entered {
-        if let Some(k) = find_trigger(doc, *id, |t| *t == Trigger::MouseEnter)
-            && p.gesture(*id, k, Some(*r), now, root)
-        {
-            return;
-        }
-    }
-    if p.temp.is_none()
-        && !entered.is_empty()
-        && let Some((id, k, r)) = pick(&|t| *t == Trigger::OnHover)
-        && entered.iter().any(|e| e.0 == id)
-        && p.fire(id, k, Some(r), now)
-    {
-        return;
-    }
-    // Press / drag / release.
-    if pressed && pos.is_some() && over_area {
-        p.press = pos;
-        p.dragged = false;
-        // Pressing catches a fling (one springing back from past an end carries on).
-        let overscrolled = |f: &Fling| p.doc.as_ref().is_some_and(|b| clamp_scroll(p.offset(f.target), p.limits(b, f.target)) != p.offset(f.target));
-        p.fling = p.fling.filter(overscrolled);
-        p.wheel = None;
-        if let (Some((_, _, orect)), Some(o), Some(q)) = (l.overlays.last(), p.overlays.last(), pos)
-            && !orect.contains(q)
-        {
-            if o.close_on_outside {
-                p.close_overlay(now);
-                p.press = None;
-                p.hovered.clear();
-            }
-            return;
-        }
-        if let Some((id, k, r)) = pick(&|t| *t == Trigger::MouseDown)
-            && p.gesture(id, k, Some(r), now, root)
-        {
-            return;
-        }
-        if let Some((id, k, r)) = pick(&|t| *t == Trigger::OnPress)
-            && p.fire(id, k, Some(r), now)
-        {
-            return;
-        }
-    }
-    if down
-        && !p.dragged
-        && let (Some(start), Some(q)) = (p.press, pos)
-        && start.distance(q) > 6.0
-    {
-        p.dragged = true;
-        let at_start: Vec<(NodeId, Rect)> = hot.iter().rev().filter(|(_, r)| r.contains(start)).copied().collect();
-        // A directional transition starts only on a drag its way (else the drag may scroll).
-        let d = q - start;
-        let drags =
-            |id: NodeId| doc.node(id)?.interactions.iter().position(|it| it.trigger == Trigger::OnDrag && it.transition.accepts_drag(d.x, d.y));
-        if let Some((id, k, r)) = at_start.iter().find_map(|(id, r)| drags(*id).map(|k| (*id, k, *r)))
-            && p.fire(id, k, Some(r), now)
-        {
-            p.press = None;
-            // The transition it started follows the pointer: along its direction, else the drag's
-            // main axis, completing over the screen's size that way.
-            if let Some(a) = p.anim.as_mut().filter(|a| a.start == now) {
-                let (x, y) = a
-                    .transition
-                    .direction()
-                    .map_or_else(|| if d.x.abs() >= d.y.abs() { (d.x.signum(), 0.0) } else { (0.0, d.y.signum()) }, direction_vec);
-                let len = if x != 0.0 { l.screen.width() } else { l.screen.height() };
-                a.follow = Some((start, vec2(x, y), len.max(1.0)));
-            }
-            return;
-        }
-        // A drag begun inside a mobile screen moves its content, even if the pointer leaves the
-        // screen. The device body stays in place even when the drag begins outside its screen.
-        // Panning the whole view remains available only without a mobile device.
-        if let Some(base) = p.doc.clone() {
-            let horizontal = d.x.abs() >= d.y.abs();
-            let scrolls = scrollers_at(p, &base, doc, root, &place, start);
-            let on_axis = |range: (f64, f64)| if horizontal { range.0 > 0.0 } else { range.1 > 0.0 };
-            let mobile = page_settings(&base, root).device().is_some_and(|device| device.rotates);
-            let target = scrolls
-                .iter()
-                .copied()
-                .find(|f| on_axis(p.range(&base, *f)))
-                .or_else(|| scrolls.first().copied())
-                .map(Scroller::Frame)
-                .or((!mobile && p.pan_range != (0.0, 0.0)).then_some(Scroller::View));
-            if let Some(t) = target {
-                p.fling = None;
-                p.drag_scroll = Some((t, clamp_scroll(p.offset(t), p.limits(&base, t))));
-            }
-        }
-    }
-    // Dragging scrolls with the pointer; past the ends it stretches.
-    if down
-        && let (Some((t, from)), Some(start), Some(q)) = (p.drag_scroll, p.press, pos)
-        && let Some(base) = p.doc.as_ref()
-    {
-        let (d, u) = (q - start, units_per_point(t, l.scale));
-        let r = p.limits(base, t);
-        let limit = RUBBER_PTS * u;
-        let to = (rubber_band(from.0 - f64::from(d.x) * u, r.0, limit), rubber_band(from.1 - f64::from(d.y) * u, r.1, limit));
-        p.set_offset(t, to);
-        p.scroll_anim = None;
-        ctx.set_cursor_icon(egui::CursorIcon::Grabbing);
-    }
-    if released && p.press.is_some() {
-        let dragged = p.dragged;
-        p.press = None;
-        p.dragged = false;
-        p.drag_scroll = None;
-        if let Some((id, k, r)) = pick(&|t| *t == Trigger::MouseUp)
-            && p.gesture(id, k, Some(r), now, root)
-        {
-            return;
-        }
-        if !dragged {
-            if let Some((id, k, r)) = pick(&|t| *t == Trigger::OnClick)
-                && p.fire(id, k, Some(r), now)
-            {
-                return;
-            }
-            // A widget's clickable part calls its plugin back (after the frame, with the session).
-            if let Some(q) = pos
-                && let Some(t) = layer_at(doc, root, &place, q).and_then(|hit| figcraft_engine::widgets::target_at(doc, hit, place.page(q)))
-            {
-                p.widget_clicks.push(t);
-                return;
-            }
-            // Clicking where nothing reacts flashes the hotspots.
-            if p.view.hotspot_hints {
-                p.flash_until = now + FLASH_SECS;
-            }
-        }
-    }
-    // Controller buttons: pressed alone, anywhere on the screen, like keys.
-    for name in &pads {
-        let found = doc.subtree(root).into_iter().find_map(|id| find_trigger(doc, id, |t| t.fires_on_key(name, KeyMods::default())).map(|k| (id, k)));
-        if let Some((id, k)) = found
-            && p.fire(id, k, None, now)
-        {
-            return;
-        }
-    }
-    // Keys.
-    for (key, mods) in &keys {
-        let (name, held) = (key.name(), KeyMods { ctrl: mods.ctrl, alt: mods.alt, shift: mods.shift, cmd: mods.mac_cmd });
-        let found = doc.subtree(root).into_iter().find_map(|id| find_trigger(doc, id, |t| t.fires_on_key(name, held)).map(|k| (id, k)));
-        if let Some((id, k)) = found {
-            if p.fire(id, k, None, now) {
-                consume_key(ctx, *key);
-                return;
-            }
-            continue;
-        }
-        // The player's own keys, when the prototype doesn't use them: R restarts, Z cycles the
-        // full-window presenter's size options.
-        if mods.is_none() {
-            match key {
-                egui::Key::R => {
-                    p.restart(p.start, now);
-                    consume_key(ctx, *key);
-                    return;
-                }
-                // (A responsive frame filling the window has no size options.)
-                egui::Key::Z if !pane && (l.device.is_some() || p.fit.is_none()) => {
-                    p.set_scale(p.view.scale.next(l.device.is_some()));
-                    consume_key(ctx, *key);
-                    return;
-                }
-                _ => {}
-            }
-        }
-        // The arrows (and Space or N forward) step through top-level frames when nothing else
-        // uses them.
-        let forward = match key {
-            egui::Key::ArrowRight => Some(true),
-            egui::Key::Space | egui::Key::N if mods.is_none() => Some(true),
-            egui::Key::ArrowLeft => Some(false),
-            _ => None,
-        };
-        if let Some(forward) = forward
-            && p.overlays.is_empty()
-            && let Some(base) = p.doc.as_ref()
-        {
-            let frames = base.top_frames(base.page_of(p.current).unwrap_or(p.current));
-            if let Some(i) = frames.iter().position(|f| *f == p.current) {
-                let next = if forward { frames.get(i + 1) } else { i.checked_sub(1).and_then(|j| frames.get(j)) };
-                if let Some(n) = next.copied() {
-                    p.go(n, Transition::Instant, 0.0, Easing::Linear, now, true, false);
-                    consume_key(ctx, *key);
-                    return;
-                }
-            }
-        }
-    }
-    // After delay (timers start when the frame appears; not while animating).
-    if p.anim.is_none()
-        && let Some(((id, k), due)) = next_delay(p, doc, root, now)
-        && due <= 0.0
-    {
-        p.delays_fired.insert((id, k));
-        p.fire(id, k, None, now);
-    }
-}
-
-fn draw(p: &mut Presenter, painter: &egui::Painter, ctx: &egui::Context, l: &Layout, now: f64) {
-    let ppp = f64::from(ctx.pixels_per_point());
-    let px = l.scale * ppp;
-    let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
-    let to_tex = p.texture(ctx, &l.disp, p.current, px, now);
-    // Transition progress.
-    let mut drawn = false;
-    if let Some(a) = &p.anim {
-        let raw = ((now - a.start) / a.dur.max(1e-3)).clamp(0.0, 1.0);
-        if raw >= 1.0 {
-            p.anim = None;
-        } else {
-            ctx.request_repaint();
-            let e = a.easing.eval(raw);
-            let from_place = a.from_doc.world_bounds(a.from_frame).map(|fb| Place::centered(fb, l.screen.center(), l.scale));
-            if matches!(a.transition, Transition::SmartAnimate) {
-                #[cfg(not(target_arch = "wasm32"))]
-                let t0 = std::time::Instant::now();
-                let tmp = smart_interpolate(&a.from_doc, a.from_frame, &l.disp, p.current, e);
-                let bounds = figcraft_render::export_bounds(&tmp, p.current);
-                if let Some(b) = bounds
-                    && let Some(pix) = figcraft_render::render_node(&tmp, p.current, texture_scale(ctx, b, px))
-                {
-                    let img = crate::render_worker::screen_image(&pix, tmp.color_profile);
-                    let tex = match &mut p.anim_tex {
-                        Some(t) => {
-                            t.set(img, egui::TextureOptions::LINEAR);
-                            t.clone()
-                        }
-                        None => {
-                            let t = ctx.load_texture("present-anim", img, egui::TextureOptions::LINEAR);
-                            p.anim_tex = Some(t.clone());
-                            t
-                        }
-                    };
-                    painter.with_clip_rect(l.screen).image(tex.id(), l.place.rect(b), uv, Color32::WHITE);
-                    drawn = true;
-                }
-                #[cfg(not(target_arch = "wasm32"))]
-                {
-                    p.render_ms = t0.elapsed().as_secs_f64() * 1000.0;
-                }
-            } else if let (Some(ft), Some(to), Some(fp)) = (&a.from_tex, &to_tex, from_place) {
-                let f = transition_frames(a.transition, e as f32);
-                let from_rect = fp.rect(ft.bounds);
-                let from_frame_rect = a.from_doc.world_bounds(a.from_frame).map(|b| fp.rect(b)).unwrap_or(from_rect);
-                let to_rect = l.place.rect(to.bounds);
-                let off = |r: Rect, o: (f32, f32)| vec2(r.width() * o.0, r.height() * o.1);
-                // Without a device a dissolve shows both frames whole; on one, the screen clips.
-                let dissolve_both = l.device.is_none() && matches!(a.transition, Transition::Dissolve);
-                let clip = painter.with_clip_rect(if dissolve_both { l.screen.union(from_frame_rect) } else { l.screen });
-                let draw_from = |p: &egui::Painter| {
-                    if f.from_alpha > 0.0 {
-                        p.image(ft.tex.id(), from_rect.translate(off(from_frame_rect, f.from_off)), uv, Color32::WHITE.gamma_multiply(f.from_alpha));
-                    }
-                };
-                let draw_to = |p: &egui::Painter| {
-                    p.image(to.tex.id(), to_rect.translate(off(l.screen, f.to_off)), uv, Color32::WHITE.gamma_multiply(f.to_alpha));
-                };
-                if f.from_on_top {
-                    draw_to(&clip);
-                    draw_from(&clip);
-                } else {
-                    draw_from(&clip);
-                    draw_to(&clip);
-                }
-                drawn = true;
-            }
-        }
-    }
-    if !drawn && let Some(to) = &to_tex {
-        painter.with_clip_rect(l.clip).image(to.tex.id(), l.place.rect(to.bounds), uv, Color32::WHITE);
-    }
-    // Overlays (each with its background and opening transition); closing ones run it backwards.
-    let mut ovs: Vec<(f64, OverlayState)> =
-        p.overlays.iter().map(|o| (if o.dur > 0.0 { ((now - o.opened) / o.dur).clamp(0.0, 1.0) } else { 1.0 }, o.clone())).collect();
-    let mut placed: Vec<(NodeId, Place, Rect)> = l.overlays.clone();
-    for ((at, o), pl) in p.closing.iter().zip(l.closing.iter()) {
-        if now - at >= o.dur {
-            continue;
-        }
-        ovs.insert(0, (1.0 - ((now - at) / o.dur.max(1e-3)).clamp(0.0, 1.0), o.clone()));
-        placed.insert(0, *pl);
-    }
-    let on_screen = painter.with_clip_rect(l.screen);
-    for ((raw, o), (id, place, orect)) in ovs.iter().zip(placed.iter()) {
-        let raw = *raw;
-        if raw < 1.0 {
-            ctx.request_repaint();
-        }
-        let e = o.easing.eval(raw) as f32;
-        let f = if matches!(o.transition, Transition::Instant) {
-            transition_frames(Transition::Dissolve, 1.0)
-        } else {
-            transition_frames(o.transition, e)
-        };
-        if let Some(bgc) = o.background {
-            let c = crate::theme::doc_c32(ctx, bgc);
-            on_screen.rect_filled(l.screen, CornerRadius::ZERO, c.gamma_multiply(raw as f32));
-        }
-        if let Some(tex) = p.texture(ctx, &l.disp, *id, px, now) {
-            let r = place.rect(tex.bounds).translate(vec2(orect.width() * f.to_off.0, orect.height() * f.to_off.1));
-            on_screen.image(tex.tex.id(), r, uv, Color32::WHITE.gamma_multiply(f.to_alpha));
-        }
-    }
-    // Finished closing animations go (after drawing, so they stayed paired with the layout).
-    p.closing.retain(|(at, o)| now - at < o.dur);
-    // Hotspot flash after a click on nothing.
-    if now < p.flash_until {
-        let (root, place, clip) = l.active(p.current);
-        let a = ((p.flash_until - now) / FLASH_SECS) as f32;
-        for (_, r) in hotspots(&l.disp, root, &place, clip) {
-            painter.rect_filled(r, CornerRadius::same(4), ACCENT.gamma_multiply(0.25 * a));
-            painter.rect_stroke(r, CornerRadius::same(4), Stroke::new(1.5, ACCENT.gamma_multiply(a)), StrokeKind::Outside);
-        }
-        ctx.request_repaint();
-    }
-}
-
 #[cfg(test)]
 #[path = "present_variables_tests.rs"]
 mod variables_tests;
diff --git a/crates/ui-egui/src/present/actions.rs b/crates/ui-egui/src/present/actions.rs
new file mode 100644
index 00000000..97f94eeb
--- /dev/null
+++ b/crates/ui-egui/src/present/actions.rs
@@ -0,0 +1,265 @@
+use super::*;
+
+impl Presenter {
+    /// A mouse enter, leave, down or up on `node` (shown on `root`) met its interaction `k`: its
+    /// actions run now, or after its delay while `root` is still what shows (again once only
+    /// while it waits).
+    pub(super) fn gesture(&mut self, node: NodeId, k: usize, rect: Option<Rect>, now: f64, root: NodeId) -> bool {
+        let delay = self.doc.as_ref().and_then(|d| d.node(node)).and_then(|n| n.interactions.get(k)).map_or(0.0, |it| it.delay_secs());
+        if delay <= 0.0 {
+            return self.fire(node, k, rect, now);
+        }
+        if !self.waiting.iter().any(|w| (w.node, w.k) == (node, k)) {
+            self.waiting.push(Waiting { node, k, rect, root, due: now + delay });
+        }
+        false
+    }
+
+    /// Run the delayed mouse triggers that are due (those whose screen or overlay went away are
+    /// dropped). True when one changed what shows.
+    pub(super) fn fire_waiting(&mut self, root: NodeId, now: f64) -> bool {
+        let (due, later): (Vec<Waiting>, Vec<Waiting>) = std::mem::take(&mut self.waiting).into_iter().partition(|w| w.due <= now);
+        self.waiting = later;
+        self.waiting.retain(|w| w.root == root);
+        let mut did = false;
+        for w in due.into_iter().filter(|w| w.root == root) {
+            // An earlier one may have left the screen: the rest are dropped with it.
+            did = did || self.fire(w.node, w.k, w.rect, now);
+        }
+        did
+    }
+
+    /// Run the actions of interaction `k` on `node`. `rect` is the layer's screen rect.
+    pub(crate) fn fire(&mut self, node: NodeId, k: usize, rect: Option<Rect>, now: f64) -> bool {
+        let Some(it) = self.doc.as_ref().and_then(|d| d.node(node)).and_then(|n| n.interactions.get(k)).cloned() else { return false };
+        let dur = it.easing.seconds(it.duration_ms);
+        let temp = match it.trigger {
+            Trigger::OnHover => Some(false),
+            Trigger::OnPress => Some(true),
+            _ => None,
+        };
+        let snap = if temp.is_some() && self.temp.is_none() { self.snapshot() } else { None };
+        let mut did = false;
+        for a in &it.actions {
+            did |= self.perform(a, node, it.transition, dur, it.easing, rect, now);
+        }
+        if did && let (Some(press), Some(snap), Some(rect)) = (temp, snap, rect) {
+            self.temp = Some(Temp { rect, press, snap, transition: it.transition, dur, easing: it.easing });
+        }
+        did
+    }
+
+    /// Run the widget clicks the player took: each calls its plugin back on the player's copy (the
+    /// prototype's own state of the widget), as on the canvas but without touching the file.
+    /// Returns what went wrong, for a toast.
+    pub fn click_widgets(&mut self, s: &figcraft_engine::Session) -> Option<String> {
+        let mut error = None;
+        for (id, target) in std::mem::take(&mut self.widget_clicks) {
+            let Some(doc) = self.design.clone() else { break };
+            match figcraft_engine::widgets::click_on(s, doc, id, &target) {
+                Ok((d, _)) => {
+                    self.design = Some(d);
+                    self.relayout();
+                }
+                Err(e) => error = Some(e.to_string()),
+            }
+        }
+        error
+    }
+
+    pub(crate) fn perform(&mut self, a: &Action, node: NodeId, tr: Transition, dur: f64, easing: Easing, rect: Option<Rect>, now: f64) -> bool {
+        self.perform_at(a, node, tr, dur, easing, rect, now, 0)
+    }
+
+    /// One action; `depth` counts the conditional actions it is inside.
+    #[allow(clippy::too_many_arguments)]
+    fn perform_at(&mut self, a: &Action, node: NodeId, tr: Transition, dur: f64, easing: Easing, rect: Option<Rect>, now: f64, depth: usize) -> bool {
+        let Some(doc) = self.doc.clone() else { return false };
+        match a {
+            Action::Navigate { dest, preserve_scroll } => {
+                let Some(top) = figcraft_engine::proto_run::navigate_target(&doc, *dest, &self.sections) else { return false };
+                if !doc.contains(top) || (top == self.current && self.overlays.is_empty()) {
+                    return false;
+                }
+                self.go(top, tr, dur, easing, now, true, *preserve_scroll);
+                true
+            }
+            Action::Back => {
+                if self.close_overlay(now) {
+                    return true;
+                }
+                match self.history.pop() {
+                    Some(v) => {
+                        self.go(v.frame, v.transition.reversed(), v.dur, v.easing, now, false, false);
+                        true
+                    }
+                    None => false,
+                }
+            }
+            Action::ScrollTo { dest, offset } => {
+                let frames = self.scroll_to_layer(&doc, *dest, *offset);
+                if frames.is_empty() {
+                    return false;
+                }
+                if matches!(tr, Transition::Instant) || dur <= 0.0 {
+                    self.scroll.extend(frames.iter().map(|(f, _, to)| (*f, *to)));
+                    self.rev += 1;
+                } else {
+                    self.scroll_anim = Some(ScrollAnim { frames, start: now, dur, easing });
+                }
+                true
+            }
+            Action::OpenOverlay { dest, position, close_on_outside, background, offset, anchor } => {
+                let at = self.page_rect(rect);
+                if !doc.contains(*dest) {
+                    return false;
+                }
+                self.delays_fired.retain(|(id, _)| !doc.is_ancestor(*dest, *id));
+                self.overlays.push(OverlayState {
+                    id: *dest,
+                    position: *position,
+                    close_on_outside: *close_on_outside,
+                    background: *background,
+                    anchor: at,
+                    offset: *offset,
+                    anchor_to: *anchor,
+                    opened: now,
+                    transition: tr,
+                    dur,
+                    easing,
+                });
+                self.hovered.clear();
+                true
+            }
+            Action::SwapOverlay { dest } => {
+                let at = self.page_rect(rect);
+                if !doc.contains(*dest) {
+                    return false;
+                }
+                self.delays_fired.retain(|(id, _)| !doc.is_ancestor(*dest, *id));
+                match self.overlays.last_mut() {
+                    Some(o) => {
+                        o.id = *dest;
+                        o.opened = now;
+                        o.transition = tr;
+                        o.dur = dur;
+                        o.easing = easing;
+                    }
+                    None => self.overlays.push(OverlayState {
+                        id: *dest,
+                        position: OverlayPosition::Center,
+                        close_on_outside: true,
+                        background: None,
+                        anchor: at,
+                        offset: None,
+                        anchor_to: OverlayAnchor::Screen,
+                        opened: now,
+                        transition: tr,
+                        dur,
+                        easing,
+                    }),
+                }
+                self.hovered.clear();
+                true
+            }
+            Action::CloseOverlay => self.close_overlay(now),
+            Action::OpenUrl { url } => {
+                // The URL comes from the document and this action fires from whatever trigger the
+                // prototype sets, including a delay, so no click is implied: only a web link opens.
+                if figcraft_engine::doc_urls::openable(url) {
+                    self.urls.push(url.clone());
+                }
+                true
+            }
+            Action::ChangeTo { dest } => {
+                let Some(inst) = figcraft_engine::proto_run::change_to_target(&doc, node, *dest) else { return false };
+                if !doc.contains(*dest) {
+                    return false;
+                }
+                self.begin(tr, dur, easing, now);
+                let Some(d) = self.design.as_mut() else { return false };
+                let before = d.clone();
+                if let Some(n) = d.node_mut(inst)
+                    && let NodeKind::Instance { component, .. } = &mut n.kind
+                {
+                    *component = *dest;
+                }
+                figcraft_engine::components::sync_instance(d, inst);
+                self.settle(&before);
+                true
+            }
+            Action::SetVariable { variable, value, expr } => {
+                let Some(d) = self.design.as_mut() else { return false };
+                let before = d.clone();
+                let set = figcraft_engine::proto_run::set_variable(d, node, variable, value, expr.as_ref());
+                if set {
+                    self.settle(&before);
+                }
+                set
+            }
+            Action::SetVariableMode { collection, mode } => {
+                let Some(d) = self.design.as_mut() else { return false };
+                let before = d.clone();
+                let set = figcraft_engine::proto_run::set_mode(d, self.current, collection, mode);
+                if set {
+                    self.settle(&before);
+                }
+                set
+            }
+            Action::Conditional { blocks } => {
+                if depth >= figcraft_doc::proto::MAX_ACTION_DEPTH {
+                    return false;
+                }
+                // Evaluated now: earlier actions of the interaction may have changed variables.
+                let mut did = false;
+                for inner in figcraft_engine::proto_run::branch(&doc, node, blocks) {
+                    did |= self.perform_at(&inner, node, tr, dur, easing, rect, now, depth + 1);
+                }
+                did
+            }
+        }
+    }
+
+    pub(super) fn texture(&mut self, ctx: &egui::Context, doc: &Document, id: NodeId, px_scale: f64, now: f64) -> Option<FrameTex> {
+        // Animated GIFs play from when the frame arrived: a new texture when one of them moves on,
+        // and a wake-up for that moment (nothing else draws frames while it shows). egui wakes a
+        // display frame before the time asked for, a little earlier still at times: ask that much
+        // later, and count a frame due within a few milliseconds as due.
+        let t = (now - self.arrived).max(0.0) + 0.005;
+        let clock = figcraft_render::images::animation_clock(doc, id, t);
+        if let Some((_, next)) = clock {
+            crate::repaint_in(ctx, next + f64::from(ctx.input(|i| i.predicted_dt)));
+        }
+        let key = (self.rev, px_scale.to_bits(), clock.map_or(0, |c| c.0));
+        if let Some(t) = self.textures.get(&id)
+            && t.key == key
+        {
+            return Some(t.clone());
+        }
+        let bounds = figcraft_render::export_bounds(doc, id)?;
+        let pix = figcraft_render::render_node_at(doc, id, texture_scale(ctx, bounds, px_scale), t)?;
+        let img = crate::render_worker::screen_image(&pix, doc.color_profile);
+        let tex = ctx.load_texture(format!("present-{}", id.0), img, egui::TextureOptions::LINEAR);
+        let ft = FrameTex { key, tex, bounds };
+        self.textures.insert(id, ft.clone());
+        Some(ft)
+    }
+}
+
+/// The most pixels a presented frame's texture holds (bigger prototypes, at 100% or filling the
+/// window, are drawn from a smaller texture scaled up).
+const MAX_TEXTURE_PIXELS: f64 = 16_777_216.0;
+
+/// The pixel scale, at most `px`, at which `bounds` makes a texture the GPU takes (no side past
+/// its limit) of at most [`MAX_TEXTURE_PIXELS`].
+pub(super) fn texture_scale(ctx: &egui::Context, bounds: figcraft_geom::Rect, px: f64) -> f64 {
+    let side = ctx.input(|i| i.max_texture_side) as f64 - 2.0;
+    let (w, h) = (bounds.width().max(1.0), bounds.height().max(1.0));
+    let s = px.min(side / w.max(h)).min((MAX_TEXTURE_PIXELS / (w * h)).sqrt());
+    if s.is_finite() && s > 0.0 { s } else { 1e-3 }
+}
+
+/// The first interaction index on `id` whose trigger satisfies `want`.
+pub(super) fn find_trigger(doc: &Document, id: NodeId, want: impl Fn(&Trigger) -> bool) -> Option<usize> {
+    doc.node(id)?.interactions.iter().position(|it| want(&it.trigger))
+}
diff --git a/crates/ui-egui/src/present/chrome.rs b/crates/ui-egui/src/present/chrome.rs
new file mode 100644
index 00000000..80386eb7
--- /dev/null
+++ b/crates/ui-egui/src/present/chrome.rs
@@ -0,0 +1,408 @@
+use super::layout::{Chrome, FULL, Place};
+use super::player::player;
+use super::scroll::page_settings;
+use super::*;
+
+/// What the player's top bar asked for.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum BarAction {
+    Close,
+    Restart,
+    /// Present full-window (from the pane).
+    Present,
+    /// The full-window presenter's options menu (handled in the bar).
+    Options,
+    /// Turn responsive presentation on or off (saved in the file: `proto.settings`).
+    Responsive(bool),
+    /// Show or hide the comments on the presented frame.
+    Comments,
+    /// Show or hide the Inspect panel.
+    Inspect,
+}
+
+pub struct PresentTab {
+    pub id: u64,
+    /// Empty while the tab is on screen: then the player is in `app.ui.present`.
+    pub pres: Option<Presenter>,
+    pub doc_uid: u64,
+    pub path: Option<String>,
+    pub page: NodeId,
+    pub file: String,
+    pub page_name: String,
+}
+
+/// The full-window presenter (while `app.ui.present` is set). Escape or Close ends it.
+pub fn show(app: &mut FigApp, ui: &mut Ui) {
+    let ctx = ui.ctx().clone();
+    let now = ctx.input(|i| i.time);
+    let Some(mut pres) = app.ui.present.take() else { return };
+    // A tab can play a file that is closed or not in front. Then it must not read or change
+    // the file in front.
+    let live = crate::tabs::present_owner_active(app);
+    if live && let Ok(ds) = app.session.ds() {
+        pres.sync(&ds.doc, now);
+    }
+    poll_pads(app, &mut pres, &ctx);
+    let mut action = None;
+    // Typing a reply to a comment keeps the keys from the prototype, and so does the link notice
+    // while it shows; Shift+C shows the comments.
+    let typing = ctx.egui_wants_keyboard_input() || pres.link_notice.is_some();
+    if !typing && ctx.input_mut(|i| i.consume_key(egui::Modifiers::SHIFT, egui::Key::C)) {
+        action = Some(BarAction::Comments);
+    }
+    if pres.view.inspect {
+        let t = Tokens::get(&ctx);
+        egui::Panel::right("present_inspect")
+            .resizable(false)
+            .exact_size(INSPECT_W)
+            .frame(egui::Frame::NONE.fill(t.panel).stroke(Stroke::new(1.0, t.border)))
+            .show(ui, |ui| inspect_panel(app, ui, &pres));
+    }
+    egui::CentralPanel::default().frame(egui::Frame::NONE).show(ui, |ui| {
+        action = player(&mut pres, ui, ui.max_rect(), now, Chrome { keys: !typing, ..FULL }).or(action);
+    });
+    let picked_device = navigation_bar(&mut pres, &ctx, now);
+    // Keys the prototype left alone: C shows the comments, F fills the screen.
+    if !typing {
+        if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::C)) {
+            action = Some(BarAction::Comments);
+        }
+        if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::F)) {
+            let full = ctx.input(|i| i.viewport().fullscreen.unwrap_or(false));
+            ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(!full));
+        }
+    }
+    match action {
+        Some(BarAction::Comments) => pres.view.comments = !pres.view.comments,
+        Some(BarAction::Inspect) => pres.view.inspect = !pres.view.inspect,
+        _ => {}
+    }
+    if live
+        && pres.view.comments
+        && let Some((frame, place, clip)) = pres.shown
+    {
+        crate::comments::presenter(app, &ctx, frame, place, clip);
+    } else if app.ui.comments.open.is_some() {
+        app.ui.comments.close();
+    }
+    finish(app, &mut pres);
+    link_notice(app, &mut pres, &ctx, Id::unique("present_link_notice"));
+    // The options carry over to the next presentation.
+    app.ui.present_view = pres.view;
+    if live && let Some(BarAction::Responsive(on)) = action {
+        app.run("proto.settings", json!({"responsive": on}));
+    }
+    if live && let Some(device) = picked_device {
+        choose_device(app, &mut pres, &device);
+    }
+    app.ui.present = Some(pres);
+    if action == Some(BarAction::Close) || ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
+        if let Some(id) = app.ui.present_active {
+            crate::tabs::close_present(app, id);
+        } else {
+            app.ui.present = None;
+        }
+    }
+}
+
+/// Device choices in the presenter use the screen's real dimensions and reflow a copy of the
+/// design through constraints and auto layout. "No device" returns to the original frame size.
+pub(super) fn choose_device(app: &mut FigApp, p: &mut Presenter, device: &str) {
+    let responsive = device != "None";
+    if app.run("proto.settings", json!({"device": device, "responsive": responsive})).is_some() {
+        p.reset_for_device();
+    }
+}
+
+/// Controls that stay in reach while viewing a prototype, including screen stepping, device and
+/// scale. The selected device is returned to the caller so it can go through the normal document
+/// command (and undo/save) rather than changing only the player's copy.
+fn navigation_bar(p: &mut Presenter, ctx: &egui::Context, now: f64) -> Option<String> {
+    let t = Tokens::get(ctx);
+    let doc = p.doc.as_ref()?;
+    let frames = doc.top_frames(doc.page_of(p.current).unwrap_or(p.current));
+    let index = frames.iter().position(|id| *id == p.current);
+    let settings = page_settings(doc, p.current);
+    let mut navigate = None;
+    let mut device_choice = None;
+    egui::Area::new(Id::unique("present_navigation")).anchor(Align2::CENTER_BOTTOM, vec2(0.0, -18.0)).order(egui::Order::Foreground).show(
+        ctx,
+        |ui| {
+            egui::Frame::NONE
+                .fill(t.panel)
+                .stroke(Stroke::new(1.0, t.border))
+                .corner_radius(CornerRadius::same(9))
+                .inner_margin(egui::Margin::symmetric(8, 5))
+                .show(ui, |ui| {
+                    ui.horizontal(|ui| {
+                        let prev = index.and_then(|i| i.checked_sub(1)).and_then(|i| frames.get(i)).copied();
+                        let next = index.and_then(|i| frames.get(i + 1)).copied();
+                        let previous =
+                            ui.add_enabled(prev.is_some(), egui::Button::new("").min_size(vec2(26.0, 24.0))).on_hover_text(tr("Previous frame"));
+                        icons::paint(
+                            ui.painter(),
+                            Rect::from_center_size(previous.rect.center(), vec2(21.0, 21.0)),
+                            Icon::ChevronLeft,
+                            if prev.is_some() { t.icon } else { t.icon_secondary },
+                        );
+                        if previous.clicked() {
+                            navigate = prev;
+                        }
+                        ui.label(egui::RichText::new(format!("{} / {}", index.map_or(0, |i| i + 1), frames.len())).color(t.text));
+                        let following =
+                            ui.add_enabled(next.is_some(), egui::Button::new("").min_size(vec2(26.0, 24.0))).on_hover_text(tr("Next frame"));
+                        icons::paint(
+                            ui.painter(),
+                            Rect::from_center_size(following.rect.center(), vec2(21.0, 21.0)),
+                            Icon::ChevronRight,
+                            if next.is_some() { t.icon } else { t.icon_secondary },
+                        );
+                        if following.clicked() {
+                            navigate = next;
+                        }
+                        ui.separator();
+                        let model = if settings.device.is_empty() || settings.device == "None" { tr("No device") } else { &settings.device };
+                        let device_menu = ui.menu_button(format!("{model}    "), |ui| {
+                            navigation_menu(ui, |ui| {
+                                egui::ScrollArea::vertical().max_height(410.0).show(ui, |ui| {
+                                    if ui.selectable_label(settings.device.is_empty() || settings.device == "None", tr("No device")).clicked() {
+                                        device_choice = Some("None".to_owned());
+                                        ui.close();
+                                    }
+                                    ui.separator();
+                                    for device in PrototypeSettings::DEVICES {
+                                        let label = format!("{}  {}×{}", device.name, device.width as u32, device.height as u32);
+                                        if ui.selectable_label(settings.device == device.name, label).clicked() {
+                                            device_choice = Some(device.name.to_owned());
+                                            ui.close();
+                                        }
+                                    }
+                                    ui.separator();
+                                    if ui.selectable_label(settings.device == PrototypeSettings::CUSTOM_DEVICE, tr("Custom size")).clicked() {
+                                        device_choice = Some(PrototypeSettings::CUSTOM_DEVICE.to_owned());
+                                        ui.close();
+                                    }
+                                });
+                            });
+                        });
+                        paint_menu_chevron(ui.painter(), device_menu.response.rect, t.icon_secondary);
+                        let scale_menu = ui.menu_button(format!("{}    ", tr(p.view.scale.label(settings.device().is_some()))), |ui| {
+                            navigation_menu(ui, |ui| {
+                                for scale in PresentScale::options(settings.device().is_some()) {
+                                    if ui.selectable_label(p.view.scale == *scale, tr(scale.label(settings.device().is_some()))).clicked() {
+                                        p.set_scale(*scale);
+                                        ui.close();
+                                    }
+                                }
+                            });
+                        });
+                        paint_menu_chevron(ui.painter(), scale_menu.response.rect, t.icon_secondary);
+                    });
+                });
+        },
+    );
+    if let Some(id) = navigate {
+        p.go(id, Transition::Instant, 0.0, Easing::Linear, now, true, false);
+    }
+    device_choice
+}
+
+pub(super) fn paint_menu_chevron(painter: &egui::Painter, button: Rect, color: Color32) {
+    let icon = Rect::from_center_size(pos2(button.right() - 11.0, button.center().y), vec2(17.0, 17.0));
+    icons::paint(painter, icon, Icon::Chevron, color);
+}
+
+fn navigation_menu(ui: &mut Ui, add: impl FnOnce(&mut Ui)) {
+    ui.set_min_width(212.0);
+    add(ui);
+}
+
+/// How often the player polls the controllers while its prototype has gamepad triggers (seconds).
+const PAD_POLL_SECS: f64 = 1.0 / 30.0;
+
+/// Before a player's frame: the controller buttons pressed since the last one, polled only while
+/// the prototype has gamepad triggers and the window has the focus (systems and browsers report
+/// controllers to the focused window only; focus coming back draws a frame, which polls again).
+fn poll_pads(app: &mut FigApp, p: &mut Presenter, ctx: &egui::Context) {
+    if !p.uses_pads || !ctx.input(|i| i.focused) {
+        return;
+    }
+    let held = app.services.gamepad_held();
+    let down = held & !p.pads_held;
+    p.pads_held = held;
+    // Each press once, in layout order.
+    let pressed = (0..u32::BITS as usize).filter(|i| down & (1 << i) != 0).filter_map(figcraft_doc::proto::gamepad_button);
+    p.pads.extend(pressed.map(str::to_string));
+    crate::repaint_in(ctx, PAD_POLL_SECS);
+}
+
+/// After a player's frame: the links it opens and the widget clicks it took. A link to a website
+/// waits in [`link_notice`] unless the viewer chose to skip the notice; a second link to a website
+/// that fires while the notice shows is dropped.
+fn finish(app: &mut FigApp, p: &mut Presenter) {
+    for u in p.urls.drain(..) {
+        if app.session.prefs.link_notice_skipped || !goes_to_a_website(&u) {
+            app.services.open_url(&u);
+        } else if p.link_notice.is_none() {
+            p.link_notice = Some((u, false));
+        }
+    }
+    if let Some(e) = p.click_widgets(&app.session) {
+        app.toast(e);
+    }
+}
+
+/// Whether `url` is an `http` or `https` link (a `mailto:` link opens the mail app instead).
+fn goes_to_a_website(url: &str) -> bool {
+    url.trim().split_once(':').is_some_and(|(scheme, _)| scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https"))
+}
+
+/// The notice before a link leaves the prototype for a website: the link, "Don't show this
+/// again" (saved with the preferences when Open link is pressed), Open link and Cancel. Escape or
+/// the close button cancels.
+fn link_notice(app: &mut FigApp, p: &mut Presenter, ctx: &egui::Context, id: Id) {
+    let Some((url, skip)) = p.link_notice.as_mut() else { return };
+    let t = Tokens::get(ctx);
+    let (mut open, mut go, mut cancel) = (true, false, false);
+    crate::dialogs::window(tr("Leaving the prototype"), ctx).id(id).open(&mut open).show(ctx, |ui| {
+        ui.set_width(340.0);
+        widgets::label(ui, tr("This link opens a website outside the prototype:"), t.text);
+        ui.add(egui::Label::new(egui::RichText::new(url.as_str()).font(regular(11.0)).color(t.text_secondary)).wrap());
+        ui.add_space(8.0);
+        if widgets::checkbox(ui, *skip, tr("Don't show this again")) {
+            *skip = !*skip;
+        }
+        ui.add_space(12.0);
+        ui.horizontal(|ui| {
+            go = widgets::button(ui, tr("Open link"), true, true).clicked();
+            cancel = widgets::button(ui, tr("Cancel"), false, true).clicked();
+        });
+    });
+    cancel |= !open || ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape));
+    if go {
+        let Some((url, skip)) = p.link_notice.take() else { return };
+        if skip {
+            app.run("proto.linkNotice", json!({"show": false}));
+            app.services.save_prefs(&app.session.prefs);
+        }
+        app.services.open_url(&url);
+    } else if cancel {
+        p.link_notice = None;
+    }
+}
+
+/// The width of the presenter's Inspect panel.
+const INSPECT_W: f32 = 280.0;
+
+/// The presenter's Inspect panel: the inspected layer's properties, as in the Inspect tab.
+fn inspect_panel(app: &mut FigApp, ui: &mut Ui, pres: &Presenter) {
+    let t = Tokens::get(ui.ctx());
+    let found = pres.inspected.zip(pres.doc.as_ref()).and_then(|(id, doc)| doc.node(id).map(|n| (id, doc, n.name.clone())));
+    egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
+        let Some((id, doc, name)) = found else {
+            widgets::section_header(ui, tr("Inspect"), &[], false);
+            widgets::note(ui, tr("Hover a layer to see its properties"), t.text_secondary);
+            return;
+        };
+        widgets::section_header(ui, &name, &[], false);
+        for section in figcraft_engine::devinspect::properties(doc, id) {
+            crate::right::inspect_section(app, ui, &section);
+        }
+    });
+}
+
+/// The top-most visible layer of `root` (it included) under the screen point `q`.
+pub(super) fn layer_at(doc: &Document, root: NodeId, place: &Place, q: Pos2) -> Option<NodeId> {
+    let mut hidden: HashSet<NodeId> = HashSet::new();
+    let mut hit = None;
+    for id in doc.subtree(root) {
+        let Some(n) = doc.node(id) else { continue };
+        if !n.visible || n.parent.is_some_and(|p| hidden.contains(&p)) {
+            hidden.insert(id);
+            continue;
+        }
+        if doc.world_bounds(id).is_some_and(|b| place.rect(b).contains(q)) {
+            hit = Some(id);
+        }
+    }
+    hit
+}
+
+/// The prototype preview pane: the player in a floating, resizable window over the canvas. It
+/// follows edits live, and selecting another top-level frame in the editor shows that frame.
+pub struct Pane {
+    pub player: Presenter,
+    /// The open file it previews (another tab closes it).
+    doc_uid: u64,
+    /// The top-level frame last selected in the editor.
+    selected: Option<NodeId>,
+}
+
+/// The top-level frame of the editor's first selected layer.
+fn selected_frame(ds: &figcraft_engine::DocState) -> Option<NodeId> {
+    ds.selection.first().and_then(|i| ds.doc.top_level_frame(*i))
+}
+
+impl Pane {
+    pub fn new(start: NodeId, session: &figcraft_engine::Session) -> Self {
+        let (doc_uid, selected) = session.ds().map(|ds| (ds.uid, selected_frame(ds))).unwrap_or((0, None));
+        Pane { player: Presenter::new(start), doc_uid, selected }
+    }
+}
+
+/// The preview pane's window id (its position and size persist under it).
+pub fn pane_id() -> Id {
+    Id::unique("proto_preview_pane")
+}
+
+/// Show the preview pane while `app.ui.preview` is set (call once per frame, before shortcuts:
+/// keys a hovered pane's prototype uses don't reach the editor).
+pub fn show_pane(app: &mut FigApp, ctx: &egui::Context) {
+    let Some(mut pane) = app.ui.preview.take() else { return };
+    let Ok(ds) = app.session.ds() else { return };
+    if ds.uid != pane.doc_uid {
+        return;
+    }
+    let now = ctx.input(|i| i.time);
+    let (doc, selected) = (ds.doc.clone(), selected_frame(ds));
+    pane.player.sync(&doc, now);
+    // Deselecting and coming back to the same frame keeps the preview where it got to.
+    if selected.is_some() && selected != pane.selected {
+        pane.selected = selected;
+        if let Some(f) = selected.filter(|f| *f != pane.player.current) {
+            pane.player.restart(f, now);
+        }
+    }
+    let t = Tokens::get(ctx);
+    let canvas = app.canvas.rect;
+    let style = ctx.global_style();
+    let typing = ds.text_edit.is_some() || crate::a11y::field_focused(ctx);
+    let chrome = Chrome { pane: true, bar_h: 36.0, pad: 12.0, round: style.visuals.window_corner_radius.nw, keys: !typing };
+    poll_pads(app, &mut pane.player, ctx);
+    let mut action = None;
+    egui::Window::new(tr("Prototype preview"))
+        .id(pane_id())
+        .title_bar(false)
+        .collapsible(false)
+        .resizable(true)
+        .default_size(vec2(320.0, 600.0))
+        .min_size(vec2(220.0, 260.0))
+        .default_pos(pos2(canvas.max.x - 336.0, canvas.min.y + 16.0))
+        .constrain_to(ctx.content_rect())
+        .frame(egui::Frame::window(&style).fill(t.panel).inner_margin(egui::Margin::same(0)))
+        .show(ctx, |ui| {
+            let (rect, _) = ui.allocate_exact_size(ui.available_size(), Sense::hover());
+            action = player(&mut pane.player, ui, rect, now, chrome);
+        });
+    finish(app, &mut pane.player);
+    link_notice(app, &mut pane.player, ctx, pane_id().with("link_notice"));
+    match action {
+        Some(BarAction::Close) => {}
+        Some(BarAction::Present) => {
+            let start = pane.player.current;
+            app.ui.preview = Some(pane);
+            app.run("proto.present", json!({"start": start}));
+        }
+        _ => app.ui.preview = Some(pane),
+    }
+}
diff --git a/crates/ui-egui/src/present/device.rs b/crates/ui-egui/src/present/device.rs
new file mode 100644
index 00000000..327fdd66
--- /dev/null
+++ b/crates/ui-egui/src/present/device.rs
@@ -0,0 +1,124 @@
+use super::layout::{bezel, upright_w};
+use super::*;
+
+/// The black glass around a device's screen.
+const GLASS: Color32 = Color32::from_rgb(0x16, 0x16, 0x18);
+
+/// A device colour lighter (`k` > 0, towards white) or darker (`k` < 0, towards black).
+fn shade([r, g, b]: [u8; 3], k: f32) -> Color32 {
+    let k = k.clamp(-1.0, 1.0);
+    let f = |c: u8| {
+        let c = f32::from(c);
+        (if k >= 0.0 { c + (255.0 - c) * k } else { c * (1.0 + k) }).round().clamp(0.0, 255.0) as u8
+    };
+    Color32::from_rgb(f(r), f(g), f(b))
+}
+
+/// The width of the coloured band round a device's glass (upright screen width `w`, bezel `b`).
+fn rim(w: f32, b: f32) -> f32 {
+    (w * 0.016).clamp(1.5, (b * 0.5).max(1.5))
+}
+
+/// Body of the presentation device behind the screen `s` (drawn in code: rounded slabs in the
+/// device's colour with black glass round the screen). Turned to landscape (a quarter turn
+/// counter-clockwise), a phone's left side is at the bottom.
+pub(super) fn device_body(p: &egui::Painter, device: &str, s: Rect, landscape: bool, color: DeviceColor) {
+    let (body, edge, metal) = (shade(color.rgb, 0.0), shade(color.rgb, -0.3), shade(color.rgb, 0.12));
+    let w = upright_w(s.size(), landscape);
+    let (b, screen_r) = bezel(device, w);
+    let band = rim(w, b);
+    let radius = |r: f32| CornerRadius::same(r.clamp(0.0, 255.0) as u8);
+    match device {
+        "MacBook Air" => {
+            // The lid's coloured edge round black glass, then the base: a thin slab wider than
+            // the lid, with a finger notch.
+            let lid = s.expand(b);
+            p.rect_filled(lid, radius(b * 1.2), body);
+            p.rect_filled(lid.shrink(band), radius(b * 1.2 - band), GLASS);
+            let base = Rect::from_min_max(pos2(lid.min.x - w * 0.08, lid.max.y), pos2(lid.max.x + w * 0.08, lid.max.y + (w * 0.022).max(6.0)));
+            p.rect_filled(base, CornerRadius { nw: 2, ne: 2, sw: 10, se: 10 }, metal);
+            let notch = Rect::from_center_size(pos2(base.center().x, base.min.y + 1.5), vec2(w * 0.12, 3.0));
+            p.rect_filled(notch, CornerRadius::same(2), edge);
+        }
+        "Desktop" => {
+            let screen = s.expand(b);
+            p.rect_filled(screen, CornerRadius::same(8), body);
+            p.rect_filled(screen.shrink(band), radius(8.0 - band), GLASS);
+            let neck =
+                Rect::from_min_max(pos2(screen.center().x - w * 0.06, screen.max.y), pos2(screen.center().x + w * 0.06, screen.max.y + w * 0.08));
+            p.rect_filled(neck, CornerRadius::ZERO, metal);
+            let foot = Rect::from_min_max(pos2(neck.min.x - w * 0.06, neck.max.y), pos2(neck.max.x + w * 0.06, neck.max.y + 6.0));
+            p.rect_filled(foot, CornerRadius::same(3), edge);
+        }
+        _ => {
+            // Phones and tablets: a rounded slab (phones with side buttons).
+            let slab = s.expand(b);
+            if !device.starts_with("iPad") {
+                // (on the left side, from the top, length) as fractions of the upright side.
+                for (left, f0, h) in [(true, 0.18, 0.06), (true, 0.27, 0.1), (false, 0.24, 0.13)] {
+                    let btn = if landscape {
+                        let y = if left { slab.max.y - 0.5 } else { slab.min.y - 2.5 };
+                        Rect::from_min_size(pos2(slab.min.x + slab.width() * f0, y), vec2(slab.width() * h, 2.5))
+                    } else {
+                        let x = if left { slab.min.x - 2.0 } else { slab.max.x };
+                        Rect::from_min_size(pos2(x, slab.min.y + slab.height() * f0), vec2(2.5, slab.height() * h))
+                    };
+                    p.rect_filled(btn, CornerRadius::same(1), edge);
+                }
+            }
+            p.rect_filled(slab, radius(screen_r + b), body);
+            p.rect_stroke(slab, radius(screen_r + b), Stroke::new(1.0, edge), StrokeKind::Inside);
+            // The glass reaches round the screen's square corners (masked by `device_glass`).
+            let glass = b - band;
+            p.rect_filled(slab.shrink(band), radius((screen_r + glass).min(glass * 3.4)), GLASS);
+        }
+    }
+}
+
+/// What sits on top of the screen: rounded screen corners (glass masks the frame's square
+/// corners) and a phone's camera pill (at the left when turned to landscape).
+pub(super) fn device_glass(p: &egui::Painter, device: &str, s: Rect, landscape: bool) {
+    let w = upright_w(s.size(), landscape);
+    let (_, screen_r) = bezel(device, w);
+    if screen_r <= 0.0 {
+        return;
+    }
+    p.add(corner_masks(s, screen_r.min(s.width() / 2.0).min(s.height() / 2.0), GLASS));
+    if device.starts_with("iPhone") {
+        let pill = if landscape {
+            Rect::from_center_size(pos2(s.min.x + w * 0.045, s.center().y), vec2(w * 0.085, w * 0.3))
+        } else {
+            Rect::from_center_size(pos2(s.center().x, s.min.y + w * 0.045), vec2(w * 0.3, w * 0.085))
+        };
+        p.rect_filled(pill, CornerRadius::same((w * 0.0425).min(255.0) as u8), Color32::BLACK);
+    }
+}
+
+/// Fill what lies between each corner of `s` and its rounding of radius `r` (fans of triangles
+/// from the corner to the arc).
+fn corner_masks(s: Rect, r: f32, color: Color32) -> egui::Shape {
+    const SEGMENTS: usize = 12;
+    if !(r.is_finite() && r > 0.0) {
+        return egui::Shape::Noop;
+    }
+    let mut mesh = egui::Mesh::default();
+    // (corner, centre of its arc, angle the arc starts at).
+    let corners = [
+        (s.left_top(), s.left_top() + vec2(r, r), std::f32::consts::PI),
+        (s.right_top(), s.right_top() + vec2(-r, r), std::f32::consts::FRAC_PI_2 * 3.0),
+        (s.right_bottom(), s.right_bottom() + vec2(-r, -r), 0.0),
+        (s.left_bottom(), s.left_bottom() + vec2(r, -r), std::f32::consts::FRAC_PI_2),
+    ];
+    for (corner, centre, start) in corners {
+        let base = mesh.vertices.len() as u32;
+        mesh.colored_vertex(corner, color);
+        for k in 0..=SEGMENTS {
+            let a = start + std::f32::consts::FRAC_PI_2 * k as f32 / SEGMENTS as f32;
+            mesh.colored_vertex(centre + r * vec2(a.cos(), a.sin()), color);
+        }
+        for k in 0..SEGMENTS as u32 {
+            mesh.add_triangle(base, base + 1 + k, base + 2 + k);
+        }
+    }
+    egui::Shape::mesh(mesh)
+}
diff --git a/crates/ui-egui/src/present/draw.rs b/crates/ui-egui/src/present/draw.rs
new file mode 100644
index 00000000..271f8af7
--- /dev/null
+++ b/crates/ui-egui/src/present/draw.rs
@@ -0,0 +1,123 @@
+use super::actions::texture_scale;
+use super::layout::{Layout, Place, hotspots};
+use super::transition::{smart_interpolate, transition_frames};
+use super::*;
+
+pub(super) fn draw(p: &mut Presenter, painter: &egui::Painter, ctx: &egui::Context, l: &Layout, now: f64) {
+    let ppp = f64::from(ctx.pixels_per_point());
+    let px = l.scale * ppp;
+    let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
+    let to_tex = p.texture(ctx, &l.disp, p.current, px, now);
+    // Transition progress.
+    let mut drawn = false;
+    if let Some(a) = &p.anim {
+        let raw = ((now - a.start) / a.dur.max(1e-3)).clamp(0.0, 1.0);
+        if raw >= 1.0 {
+            p.anim = None;
+        } else {
+            ctx.request_repaint();
+            let e = a.easing.eval(raw);
+            let from_place = a.from_doc.world_bounds(a.from_frame).map(|fb| Place::centered(fb, l.screen.center(), l.scale));
+            if matches!(a.transition, Transition::SmartAnimate) {
+                #[cfg(not(target_arch = "wasm32"))]
+                let t0 = std::time::Instant::now();
+                let tmp = smart_interpolate(&a.from_doc, a.from_frame, &l.disp, p.current, e);
+                let bounds = figcraft_render::export_bounds(&tmp, p.current);
+                if let Some(b) = bounds
+                    && let Some(pix) = figcraft_render::render_node(&tmp, p.current, texture_scale(ctx, b, px))
+                {
+                    let img = crate::render_worker::screen_image(&pix, tmp.color_profile);
+                    let tex = match &mut p.anim_tex {
+                        Some(t) => {
+                            t.set(img, egui::TextureOptions::LINEAR);
+                            t.clone()
+                        }
+                        None => {
+                            let t = ctx.load_texture("present-anim", img, egui::TextureOptions::LINEAR);
+                            p.anim_tex = Some(t.clone());
+                            t
+                        }
+                    };
+                    painter.with_clip_rect(l.screen).image(tex.id(), l.place.rect(b), uv, Color32::WHITE);
+                    drawn = true;
+                }
+                #[cfg(not(target_arch = "wasm32"))]
+                {
+                    p.render_ms = t0.elapsed().as_secs_f64() * 1000.0;
+                }
+            } else if let (Some(ft), Some(to), Some(fp)) = (&a.from_tex, &to_tex, from_place) {
+                let f = transition_frames(a.transition, e as f32);
+                let from_rect = fp.rect(ft.bounds);
+                let from_frame_rect = a.from_doc.world_bounds(a.from_frame).map(|b| fp.rect(b)).unwrap_or(from_rect);
+                let to_rect = l.place.rect(to.bounds);
+                let off = |r: Rect, o: (f32, f32)| vec2(r.width() * o.0, r.height() * o.1);
+                // Without a device a dissolve shows both frames whole; on one, the screen clips.
+                let dissolve_both = l.device.is_none() && matches!(a.transition, Transition::Dissolve);
+                let clip = painter.with_clip_rect(if dissolve_both { l.screen.union(from_frame_rect) } else { l.screen });
+                let draw_from = |p: &egui::Painter| {
+                    if f.from_alpha > 0.0 {
+                        p.image(ft.tex.id(), from_rect.translate(off(from_frame_rect, f.from_off)), uv, Color32::WHITE.gamma_multiply(f.from_alpha));
+                    }
+                };
+                let draw_to = |p: &egui::Painter| {
+                    p.image(to.tex.id(), to_rect.translate(off(l.screen, f.to_off)), uv, Color32::WHITE.gamma_multiply(f.to_alpha));
+                };
+                if f.from_on_top {
+                    draw_to(&clip);
+                    draw_from(&clip);
+                } else {
+                    draw_from(&clip);
+                    draw_to(&clip);
+                }
+                drawn = true;
+            }
+        }
+    }
+    if !drawn && let Some(to) = &to_tex {
+        painter.with_clip_rect(l.clip).image(to.tex.id(), l.place.rect(to.bounds), uv, Color32::WHITE);
+    }
+    // Overlays (each with its background and opening transition); closing ones run it backwards.
+    let mut ovs: Vec<(f64, OverlayState)> =
+        p.overlays.iter().map(|o| (if o.dur > 0.0 { ((now - o.opened) / o.dur).clamp(0.0, 1.0) } else { 1.0 }, o.clone())).collect();
+    let mut placed: Vec<(NodeId, Place, Rect)> = l.overlays.clone();
+    for ((at, o), pl) in p.closing.iter().zip(l.closing.iter()) {
+        if now - at >= o.dur {
+            continue;
+        }
+        ovs.insert(0, (1.0 - ((now - at) / o.dur.max(1e-3)).clamp(0.0, 1.0), o.clone()));
+        placed.insert(0, *pl);
+    }
+    let on_screen = painter.with_clip_rect(l.screen);
+    for ((raw, o), (id, place, orect)) in ovs.iter().zip(placed.iter()) {
+        let raw = *raw;
+        if raw < 1.0 {
+            ctx.request_repaint();
+        }
+        let e = o.easing.eval(raw) as f32;
+        let f = if matches!(o.transition, Transition::Instant) {
+            transition_frames(Transition::Dissolve, 1.0)
+        } else {
+            transition_frames(o.transition, e)
+        };
+        if let Some(bgc) = o.background {
+            let c = crate::theme::doc_c32(ctx, bgc);
+            on_screen.rect_filled(l.screen, CornerRadius::ZERO, c.gamma_multiply(raw as f32));
+        }
+        if let Some(tex) = p.texture(ctx, &l.disp, *id, px, now) {
+            let r = place.rect(tex.bounds).translate(vec2(orect.width() * f.to_off.0, orect.height() * f.to_off.1));
+            on_screen.image(tex.tex.id(), r, uv, Color32::WHITE.gamma_multiply(f.to_alpha));
+        }
+    }
+    // Finished closing animations go (after drawing, so they stayed paired with the layout).
+    p.closing.retain(|(at, o)| now - at < o.dur);
+    // Hotspot flash after a click on nothing.
+    if now < p.flash_until {
+        let (root, place, clip) = l.active(p.current);
+        let a = ((p.flash_until - now) / FLASH_SECS) as f32;
+        for (_, r) in hotspots(&l.disp, root, &place, clip) {
+            painter.rect_filled(r, CornerRadius::same(4), ACCENT.gamma_multiply(0.25 * a));
+            painter.rect_stroke(r, CornerRadius::same(4), Stroke::new(1.5, ACCENT.gamma_multiply(a)), StrokeKind::Outside);
+        }
+        ctx.request_repaint();
+    }
+}
diff --git a/crates/ui-egui/src/present/input.rs b/crates/ui-egui/src/present/input.rs
new file mode 100644
index 00000000..42df2286
--- /dev/null
+++ b/crates/ui-egui/src/present/input.rs
@@ -0,0 +1,334 @@
+use super::actions::find_trigger;
+use super::chrome::layer_at;
+use super::layout::{Layout, hotspots};
+use super::navigate::next_delay;
+use super::scroll::{COAST_MIN, DECAY_DRAG, DECAY_WHEEL, RUBBER_PTS, clamp_scroll, page_settings, rubber_band, scrollers_at, units_per_point};
+use super::transition::{direction_vec, lerp};
+use super::*;
+
+/// Keep a key the prototype used from reaching the editor's shortcuts.
+fn consume_key(ctx: &egui::Context, key: egui::Key) {
+    ctx.input_mut(|i| i.events.retain(|e| !matches!(e, egui::Event::Key { key: k, .. } if *k == key)));
+}
+
+/// Pointer, wheel, keys and timers. `over_area`: the pointer is over the player; `keys_on`: the
+/// player takes the keyboard; `pane`: it plays in the preview pane (which always fits).
+#[allow(clippy::too_many_arguments)]
+pub(super) fn input(p: &mut Presenter, ctx: &egui::Context, l: &Layout, over_area: bool, keys_on: bool, pane: bool, now: f64) {
+    let (pos, pressed, released, down, wheel, velocity, dt, keys) = ctx.input(|i| {
+        let keys: Vec<(egui::Key, egui::Modifiers)> = i
+            .events
+            .iter()
+            .filter_map(|e| match e {
+                egui::Event::Key { key, pressed: true, repeat: false, modifiers, .. } => Some((*key, *modifiers)),
+                _ => None,
+            })
+            .collect();
+        (
+            i.pointer.hover_pos(),
+            i.pointer.button_pressed(egui::PointerButton::Primary),
+            i.pointer.button_released(egui::PointerButton::Primary),
+            i.pointer.primary_down(),
+            i.smooth_scroll_delta,
+            i.pointer.velocity(),
+            f64::from(i.unstable_dt).clamp(1.0 / 500.0, 0.1),
+            keys,
+        )
+    });
+    let keys = if keys_on { keys } else { Vec::new() };
+    // Controller buttons pressed while a link notice shows are dropped, as keys are.
+    let pads = std::mem::take(&mut p.pads);
+    let pads = if p.link_notice.is_none() { pads } else { Vec::new() };
+    // A transition a drag started follows the pointer while it stays down, then plays on from there.
+    if let Some(a) = p.anim.as_mut()
+        && let Some((from, dir, len)) = a.follow
+    {
+        match pos.filter(|_| down) {
+            Some(q) => a.start = now - f64::from(((q - from).dot(dir) / len).clamp(0.0, 1.0)) * a.dur,
+            None => a.follow = None,
+        }
+    }
+    let pos = pos.filter(|_| over_area || p.press.is_some());
+    // A drag that scrolled lets go: it carries on at the pointer's speed (and springs back from
+    // past the ends).
+    if !down && let Some((t, _)) = p.drag_scroll.take() {
+        let u = units_per_point(t, l.scale);
+        let r = p.doc.as_ref().map_or((0.0, 0.0), |b| p.limits(b, t));
+        let along = |v: f32, r: f64| if r > 0.0 { -f64::from(v) * u } else { 0.0 };
+        p.fling = Some(Fling { target: t, vel: (along(velocity.x, r.0), along(velocity.y, r.1)), decay: DECAY_DRAG, bounce: true, at: now });
+    }
+    // The active layer: the top overlay, else the frame.
+    let (root, place, clip) = l.active(p.current);
+    let doc = &l.disp;
+    let hot = hotspots(doc, root, &place, clip);
+    p.hot.clone_from(&hot);
+    if p.fire_waiting(root, now) {
+        return;
+    }
+    // "While hovering / pressing" reverts.
+    if let Some(tmp) = &p.temp {
+        let leave = if tmp.press { released || !down } else { pos.is_none_or(|q| !tmp.rect.contains(q)) };
+        if leave {
+            p.revert(now);
+            return;
+        }
+    }
+    // The wheel scrolls the innermost frame under the pointer that can still move that way, else
+    // pans a view bigger than the window. When it stops it coasts on, slowing down.
+    if wheel != Vec2::ZERO
+        && let Some(q) = pos
+        && let Some(base) = p.doc.clone()
+    {
+        let mut targets: Vec<Scroller> = scrollers_at(p, &base, doc, root, &place, q).into_iter().map(Scroller::Frame).collect();
+        if p.pan_range != (0.0, 0.0) {
+            targets.push(Scroller::View);
+        }
+        let mut moved = None;
+        for t in targets {
+            let u = units_per_point(t, l.scale);
+            let cur = p.offset(t);
+            let next = clamp_scroll((cur.0 - f64::from(wheel.x) * u, cur.1 - f64::from(wheel.y) * u), p.limits(&base, t));
+            if (next.0 - cur.0).abs() > 1e-6 || (next.1 - cur.1).abs() > 1e-6 {
+                p.set_offset(t, next);
+                p.scroll_anim = None;
+                p.fling = None;
+                moved = Some((t, ((next.0 - cur.0) / dt, (next.1 - cur.1) / dt)));
+                break;
+            }
+        }
+        // The wheel's speed, smoothed over ~50 ms whatever the frame rate.
+        p.wheel = moved.map(|(t, inst)| {
+            let prev = p.wheel.filter(|w| w.0 == t).map_or(inst, |w| w.1);
+            let a = 1.0 - (-dt / 0.05).exp();
+            (t, (lerp(prev.0, inst.0, a), lerp(prev.1, inst.1, a)))
+        });
+    } else if wheel == Vec2::ZERO
+        && let Some((t, v)) = p.wheel.take()
+        && v.0.hypot(v.1) > COAST_MIN * units_per_point(t, l.scale)
+    {
+        p.fling = Some(Fling { target: t, vel: v, decay: DECAY_WHEEL, bounce: false, at: now });
+    }
+    let hits: Vec<(NodeId, Rect)> = hot.iter().rev().filter(|(_, r)| pos.is_some_and(|q| r.contains(q))).copied().collect();
+    if !hits.is_empty() {
+        ctx.set_cursor_icon(egui::CursorIcon::PointingHand);
+    }
+    // First (top-most) hit that has a matching trigger.
+    let pick = |want: &dyn Fn(&Trigger) -> bool| -> Option<(NodeId, usize, Rect)> {
+        hits.iter().find_map(|(id, r)| find_trigger(doc, *id, want).map(|k| (*id, k, *r)))
+    };
+    // Enter / leave.
+    let ids: Vec<NodeId> = hits.iter().map(|h| h.0).collect();
+    let entered: Vec<(NodeId, Rect)> = hits.iter().filter(|(id, _)| !p.hovered.contains(id)).copied().collect();
+    let left: Vec<NodeId> = p.hovered.iter().filter(|id| !ids.contains(id)).copied().collect();
+    p.hovered = ids;
+    for id in left {
+        if let Some(k) = find_trigger(doc, id, |t| *t == Trigger::MouseLeave)
+            && p.gesture(id, k, None, now, root)
+        {
+            return;
+        }
+    }
+    for (id, r) in &entered {
+        if let Some(k) = find_trigger(doc, *id, |t| *t == Trigger::MouseEnter)
+            && p.gesture(*id, k, Some(*r), now, root)
+        {
+            return;
+        }
+    }
+    if p.temp.is_none()
+        && !entered.is_empty()
+        && let Some((id, k, r)) = pick(&|t| *t == Trigger::OnHover)
+        && entered.iter().any(|e| e.0 == id)
+        && p.fire(id, k, Some(r), now)
+    {
+        return;
+    }
+    // Press / drag / release.
+    if pressed && pos.is_some() && over_area {
+        p.press = pos;
+        p.dragged = false;
+        // Pressing catches a fling (one springing back from past an end carries on).
+        let overscrolled = |f: &Fling| p.doc.as_ref().is_some_and(|b| clamp_scroll(p.offset(f.target), p.limits(b, f.target)) != p.offset(f.target));
+        p.fling = p.fling.filter(overscrolled);
+        p.wheel = None;
+        if let (Some((_, _, orect)), Some(o), Some(q)) = (l.overlays.last(), p.overlays.last(), pos)
+            && !orect.contains(q)
+        {
+            if o.close_on_outside {
+                p.close_overlay(now);
+                p.press = None;
+                p.hovered.clear();
+            }
+            return;
+        }
+        if let Some((id, k, r)) = pick(&|t| *t == Trigger::MouseDown)
+            && p.gesture(id, k, Some(r), now, root)
+        {
+            return;
+        }
+        if let Some((id, k, r)) = pick(&|t| *t == Trigger::OnPress)
+            && p.fire(id, k, Some(r), now)
+        {
+            return;
+        }
+    }
+    if down
+        && !p.dragged
+        && let (Some(start), Some(q)) = (p.press, pos)
+        && start.distance(q) > 6.0
+    {
+        p.dragged = true;
+        let at_start: Vec<(NodeId, Rect)> = hot.iter().rev().filter(|(_, r)| r.contains(start)).copied().collect();
+        // A directional transition starts only on a drag its way (else the drag may scroll).
+        let d = q - start;
+        let drags =
+            |id: NodeId| doc.node(id)?.interactions.iter().position(|it| it.trigger == Trigger::OnDrag && it.transition.accepts_drag(d.x, d.y));
+        if let Some((id, k, r)) = at_start.iter().find_map(|(id, r)| drags(*id).map(|k| (*id, k, *r)))
+            && p.fire(id, k, Some(r), now)
+        {
+            p.press = None;
+            // The transition it started follows the pointer: along its direction, else the drag's
+            // main axis, completing over the screen's size that way.
+            if let Some(a) = p.anim.as_mut().filter(|a| a.start == now) {
+                let (x, y) = a
+                    .transition
+                    .direction()
+                    .map_or_else(|| if d.x.abs() >= d.y.abs() { (d.x.signum(), 0.0) } else { (0.0, d.y.signum()) }, direction_vec);
+                let len = if x != 0.0 { l.screen.width() } else { l.screen.height() };
+                a.follow = Some((start, vec2(x, y), len.max(1.0)));
+            }
+            return;
+        }
+        // A drag begun inside a mobile screen moves its content, even if the pointer leaves the
+        // screen. The device body stays in place even when the drag begins outside its screen.
+        // Panning the whole view remains available only without a mobile device.
+        if let Some(base) = p.doc.clone() {
+            let horizontal = d.x.abs() >= d.y.abs();
+            let scrolls = scrollers_at(p, &base, doc, root, &place, start);
+            let on_axis = |range: (f64, f64)| if horizontal { range.0 > 0.0 } else { range.1 > 0.0 };
+            let mobile = page_settings(&base, root).device().is_some_and(|device| device.rotates);
+            let target = scrolls
+                .iter()
+                .copied()
+                .find(|f| on_axis(p.range(&base, *f)))
+                .or_else(|| scrolls.first().copied())
+                .map(Scroller::Frame)
+                .or((!mobile && p.pan_range != (0.0, 0.0)).then_some(Scroller::View));
+            if let Some(t) = target {
+                p.fling = None;
+                p.drag_scroll = Some((t, clamp_scroll(p.offset(t), p.limits(&base, t))));
+            }
+        }
+    }
+    // Dragging scrolls with the pointer; past the ends it stretches.
+    if down
+        && let (Some((t, from)), Some(start), Some(q)) = (p.drag_scroll, p.press, pos)
+        && let Some(base) = p.doc.as_ref()
+    {
+        let (d, u) = (q - start, units_per_point(t, l.scale));
+        let r = p.limits(base, t);
+        let limit = RUBBER_PTS * u;
+        let to = (rubber_band(from.0 - f64::from(d.x) * u, r.0, limit), rubber_band(from.1 - f64::from(d.y) * u, r.1, limit));
+        p.set_offset(t, to);
+        p.scroll_anim = None;
+        ctx.set_cursor_icon(egui::CursorIcon::Grabbing);
+    }
+    if released && p.press.is_some() {
+        let dragged = p.dragged;
+        p.press = None;
+        p.dragged = false;
+        p.drag_scroll = None;
+        if let Some((id, k, r)) = pick(&|t| *t == Trigger::MouseUp)
+            && p.gesture(id, k, Some(r), now, root)
+        {
+            return;
+        }
+        if !dragged {
+            if let Some((id, k, r)) = pick(&|t| *t == Trigger::OnClick)
+                && p.fire(id, k, Some(r), now)
+            {
+                return;
+            }
+            // A widget's clickable part calls its plugin back (after the frame, with the session).
+            if let Some(q) = pos
+                && let Some(t) = layer_at(doc, root, &place, q).and_then(|hit| figcraft_engine::widgets::target_at(doc, hit, place.page(q)))
+            {
+                p.widget_clicks.push(t);
+                return;
+            }
+            // Clicking where nothing reacts flashes the hotspots.
+            if p.view.hotspot_hints {
+                p.flash_until = now + FLASH_SECS;
+            }
+        }
+    }
+    // Controller buttons: pressed alone, anywhere on the screen, like keys.
+    for name in &pads {
+        let found = doc.subtree(root).into_iter().find_map(|id| find_trigger(doc, id, |t| t.fires_on_key(name, KeyMods::default())).map(|k| (id, k)));
+        if let Some((id, k)) = found
+            && p.fire(id, k, None, now)
+        {
+            return;
+        }
+    }
+    // Keys.
+    for (key, mods) in &keys {
+        let (name, held) = (key.name(), KeyMods { ctrl: mods.ctrl, alt: mods.alt, shift: mods.shift, cmd: mods.mac_cmd });
+        let found = doc.subtree(root).into_iter().find_map(|id| find_trigger(doc, id, |t| t.fires_on_key(name, held)).map(|k| (id, k)));
+        if let Some((id, k)) = found {
+            if p.fire(id, k, None, now) {
+                consume_key(ctx, *key);
+                return;
+            }
+            continue;
+        }
+        // The player's own keys, when the prototype doesn't use them: R restarts, Z cycles the
+        // full-window presenter's size options.
+        if mods.is_none() {
+            match key {
+                egui::Key::R => {
+                    p.restart(p.start, now);
+                    consume_key(ctx, *key);
+                    return;
+                }
+                // (A responsive frame filling the window has no size options.)
+                egui::Key::Z if !pane && (l.device.is_some() || p.fit.is_none()) => {
+                    p.set_scale(p.view.scale.next(l.device.is_some()));
+                    consume_key(ctx, *key);
+                    return;
+                }
+                _ => {}
+            }
+        }
+        // The arrows (and Space or N forward) step through top-level frames when nothing else
+        // uses them.
+        let forward = match key {
+            egui::Key::ArrowRight => Some(true),
+            egui::Key::Space | egui::Key::N if mods.is_none() => Some(true),
+            egui::Key::ArrowLeft => Some(false),
+            _ => None,
+        };
+        if let Some(forward) = forward
+            && p.overlays.is_empty()
+            && let Some(base) = p.doc.as_ref()
+        {
+            let frames = base.top_frames(base.page_of(p.current).unwrap_or(p.current));
+            if let Some(i) = frames.iter().position(|f| *f == p.current) {
+                let next = if forward { frames.get(i + 1) } else { i.checked_sub(1).and_then(|j| frames.get(j)) };
+                if let Some(n) = next.copied() {
+                    p.go(n, Transition::Instant, 0.0, Easing::Linear, now, true, false);
+                    consume_key(ctx, *key);
+                    return;
+                }
+            }
+        }
+    }
+    // After delay (timers start when the frame appears; not while animating).
+    if p.anim.is_none()
+        && let Some(((id, k), due)) = next_delay(p, doc, root, now)
+        && due <= 0.0
+    {
+        p.delays_fired.insert((id, k));
+        p.fire(id, k, None, now);
+    }
+}
diff --git a/crates/ui-egui/src/present/layout.rs b/crates/ui-egui/src/present/layout.rs
new file mode 100644
index 00000000..9584fc81
--- /dev/null
+++ b/crates/ui-egui/src/present/layout.rs
@@ -0,0 +1,186 @@
+use super::scroll::{clamp_scroll, page_settings};
+use super::*;
+
+/// Page → screen mapping for one presented frame.
+#[derive(Clone, Copy, Debug)]
+pub struct Place {
+    pub page_min: (f64, f64),
+    pub origin: Pos2,
+    pub scale: f64,
+}
+
+impl Place {
+    pub(super) fn centered(fb: figcraft_geom::Rect, center: Pos2, scale: f64) -> Self {
+        let size = vec2((fb.width() * scale) as f32, (fb.height() * scale) as f32);
+        Place { page_min: (fb.x0, fb.y0), origin: center - size / 2.0, scale }
+    }
+    pub fn pt(&self, x: f64, y: f64) -> Pos2 {
+        pos2(self.origin.x + ((x - self.page_min.0) * self.scale) as f32, self.origin.y + ((y - self.page_min.1) * self.scale) as f32)
+    }
+    pub fn rect(&self, r: figcraft_geom::Rect) -> Rect {
+        Rect::from_min_max(self.pt(r.x0, r.y0), self.pt(r.x1, r.y1))
+    }
+    /// The page point under screen point `q`.
+    pub fn page(&self, q: Pos2) -> Point {
+        Point::new(self.page_min.0 + f64::from(q.x - self.origin.x) / self.scale, self.page_min.1 + f64::from(q.y - self.origin.y) / self.scale)
+    }
+}
+
+/// The hotspots of the screen `root` (its visible layers with interactions, bottom-most first)
+/// placed on screen and clipped by `screen`.
+pub(super) fn hotspots(doc: &Document, root: NodeId, place: &Place, screen: Rect) -> Vec<(NodeId, Rect)> {
+    figcraft_engine::proto_run::hotspots(doc, root)
+        .into_iter()
+        .map(|(id, b)| (id, place.rect(b).intersect(screen)))
+        .filter(|(_, r)| r.is_positive())
+        .collect()
+}
+
+// ---------------------------------------------------------------------------------------------
+// The player UI, shared by the full-window presenter and the preview pane.
+
+pub(super) struct Layout {
+    pub(super) disp: Document,
+    pub(super) scale: f64,
+    pub(super) place: Place,
+    /// What shows the prototype: the device's screen, else the presented frame itself.
+    pub(super) screen: Rect,
+    /// What the presented frame may draw into: the device's screen, else the whole area (shadows
+    /// and overflowing content show around a frame presented without a device).
+    pub(super) clip: Rect,
+    pub(super) device: Option<Device>,
+    /// The device is turned to landscape.
+    pub(super) landscape: bool,
+    /// The colour of the device's body, when it is drawn around its screen.
+    pub(super) color: Option<DeviceColor>,
+    pub(super) overlays: Vec<(NodeId, Place, Rect)>,
+    /// Overlays animating out (same order as `Presenter::closing`).
+    pub(super) closing: Vec<(NodeId, Place, Rect)>,
+}
+
+impl Layout {
+    /// The active layer (the top overlay, else the presented frame `current`), where it's placed
+    /// and what it may draw into.
+    pub(super) fn active(&self, current: NodeId) -> (NodeId, Place, Rect) {
+        match self.overlays.last() {
+            Some((id, pl, _)) => (*id, *pl, self.screen),
+            None => (current, self.place, self.clip),
+        }
+    }
+}
+
+/// The width of a device's screen of `size` held upright (its short side when turned).
+pub(super) fn upright_w(size: Vec2, landscape: bool) -> f32 {
+    if landscape { size.y } else { size.x }
+}
+
+/// Bezel width around a device's screen of upright width `w`, and the screen's corner radius.
+pub(super) fn bezel(device: &str, w: f32) -> (f32, f32) {
+    match device {
+        "MacBook Air" => ((w * 0.025).max(6.0), 0.0),
+        "Desktop" => ((w * 0.02).max(6.0), 0.0),
+        d if d.starts_with("iPad") => ((w * 0.05).max(8.0), w * 0.04),
+        _ => ((w * 0.06).max(6.0), w * 0.13),
+    }
+}
+
+/// How far a device's body reaches past its screen of `size`: (each side, top, bottom). A phone
+/// turned to landscape has its side buttons above and below.
+fn body_outset(device: &str, size: Vec2, landscape: bool) -> (f32, f32, f32) {
+    let w = upright_w(size, landscape);
+    let (b, _) = bezel(device, w);
+    match device {
+        "MacBook Air" => (b + w * 0.08, b, b + (w * 0.022).max(6.0)),
+        "Desktop" => (b, b, b + w * 0.08 + 6.0),
+        _ if landscape => (b, b + 3.0, b + 3.0),
+        _ => (b + 3.0, b, b),
+    }
+}
+
+/// Place the presented frame in `area`: on its device's screen (the whole device sized by the
+/// view's scale option), else the frame itself. Fit and 100% keep the chrome's padding from the
+/// edges; Fit never goes above 100%. What doesn't fit the window pans (`Presenter::pan`). The
+/// preview pane always fits. A responsive prototype's frame is first resized to the device's
+/// screen, or without a device to the whole area (shown at 100%).
+pub(super) fn layout(p: &mut Presenter, area: Rect, chrome: Chrome) -> Option<Layout> {
+    let settings = page_settings(p.doc.as_ref()?, p.current);
+    let (device, landscape) = (settings.device(), settings.landscape());
+    let fills = settings.responsive && device.is_none();
+    let whole_area = (f64::from(area.width().round()), f64::from(area.height().round()));
+    p.respond_to(settings.responsive.then(|| device.map_or(whole_area, |d| (d.width, d.height))));
+    let disp = p.display()?;
+    let fb = disp.world_bounds(p.current)?;
+    let view = if chrome.pane { PresentView::default() } else { p.view };
+    // Custom sizes are just a screen: no body.
+    let body = device.filter(|d| view.device_frame && !d.colors.is_empty());
+    let pad = if !fills && matches!(view.scale, PresentScale::Fit | PresentScale::Actual) { chrome.pad } else { 0.0 };
+    let avail = area.shrink(pad);
+    let (sw, sh) = device.map_or((fb.width(), fb.height()), |d| (d.width, d.height));
+    // The screen at `scale`, the body's outsets around it and the whole size.
+    let outer = |scale: f64| {
+        let size = vec2((sw * scale) as f32, (sh * scale) as f32);
+        let (x, top, bottom) = body.map_or((0.0, 0.0, 0.0), |d| body_outset(d.name, size, landscape));
+        (size, x, top, vec2(size.x + 2.0 * x, size.y + top + bottom))
+    };
+    // The factor that makes something of size `o` fit, fill… the available space.
+    let factor = |o: Vec2| {
+        let (kx, ky) = (avail.width() / o.x.max(1.0), avail.height() / o.y.max(1.0));
+        f64::from(match view.scale {
+            PresentScale::Fit => kx.min(ky),
+            PresentScale::FitWidth => kx,
+            PresentScale::Fill => kx.max(ky),
+            PresentScale::Actual => 1.0,
+        })
+    };
+    let mut scale = if fills { 1.0 } else { factor(vec2(sw as f32, sh as f32)) };
+    // The body doesn't scale exactly with the screen (its edges have a minimum): size it once more.
+    if body.is_some() {
+        scale *= factor(outer(scale).3);
+    }
+    let max = if view.scale == PresentScale::Fit { 1.0 } else { 16.0 };
+    let scale = if scale.is_finite() { scale.clamp(0.01, max) } else { 0.01 };
+    let (size, x, top, whole) = outer(scale);
+    p.zoom = scale;
+    // What's bigger than the window pans: starting centred across and at the top.
+    let over = |d: f32| if d > 0.5 { d } else { 0.0 };
+    let excess = vec2(over(whole.x - avail.width()), over(whole.y - avail.height()));
+    p.pan_range = (f64::from(excess.x), f64::from(excess.y));
+    // While a drag or fling moves the view it may stretch past the ends; otherwise it stays in range.
+    let live = matches!(p.drag_scroll, Some((Scroller::View, _))) || p.fling.is_some_and(|f| f.target == Scroller::View);
+    if !live {
+        p.pan = p.pan.map(|v| clamp_scroll(v, p.pan_range));
+    }
+    let pan = p.offset(Scroller::View);
+    let along = |excess: f32, min: f32, centre: f32, len: f32, pan: f64| if excess > 0.0 { min - pan as f32 } else { centre - len / 2.0 };
+    let min = pos2(along(excess.x, avail.min.x, area.center().x, whole.x, pan.0), along(excess.y, avail.min.y, area.center().y, whole.y, pan.1));
+    let screen = Rect::from_min_size(min + vec2(x, top), size);
+    let place = Place::centered(fb, screen.center(), scale);
+    let place_overlay = |o: &OverlayState| {
+        let ob = disp.world_bounds(o.id)?;
+        let size = vec2((ob.width() * scale) as f32, (ob.height() * scale) as f32);
+        let offset = o.offset.map(|[x, y]| vec2((x * scale) as f32, (y * scale) as f32));
+        let r = anchored_overlay_rect(o.position, o.anchor_to, screen, size, o.anchor.map(|a| place.rect(a)), offset);
+        Some((o.id, Place { page_min: (ob.x0, ob.y0), origin: r.min, scale }, r))
+    };
+    let overlays = p.overlays.iter().filter_map(place_overlay).collect();
+    let closing = p.closing.iter().filter_map(|(_, o)| place_overlay(o)).collect();
+    let clip = if device.is_some() { screen } else { area };
+    let color = body.and(settings.device_color());
+    Some(Layout { disp, scale, place, screen, clip, device, landscape, color, overlays, closing })
+}
+
+/// Where the player sits: the whole window or the preview pane.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) struct Chrome {
+    pub(super) pane: bool,
+    pub(super) bar_h: f32,
+    /// Space kept around the device or frame.
+    pub(super) pad: f32,
+    /// Corner radius of the window around the player (the pane's).
+    pub(super) round: u8,
+    /// The player may take keys (the pane only while hovered, and never while the editor is
+    /// typing: text on the canvas or in a field).
+    pub(super) keys: bool,
+}
+
+pub(super) const FULL: Chrome = Chrome { pane: false, bar_h: 40.0, pad: 32.0, round: 0, keys: true };
diff --git a/crates/ui-egui/src/present/navigate.rs b/crates/ui-egui/src/present/navigate.rs
new file mode 100644
index 00000000..a320e80d
--- /dev/null
+++ b/crates/ui-egui/src/present/navigate.rs
@@ -0,0 +1,255 @@
+use super::scroll::{apply_scroll, clamp_scroll, fit_viewport, page_settings, raise_fixed, viewport};
+use super::*;
+
+impl Presenter {
+    /// Close the top overlay; it animates out with its opening transition reversed.
+    pub(super) fn close_overlay(&mut self, now: f64) -> bool {
+        let Some(o) = self.overlays.pop() else { return false };
+        if !matches!(o.transition, Transition::Instant) && o.dur > 0.0 {
+            // An overlay closed mid-opening reverses from where it got to.
+            let shown = ((now - o.opened) / o.dur).clamp(0.0, 1.0);
+            self.closing.push((now - (1.0 - shown) * o.dur, o));
+        }
+        self.hovered.clear();
+        true
+    }
+
+    /// Follow the editor's document: copy it the first time and whenever it changed, keeping the
+    /// screen, the overlays and the scroll offsets that still exist (a deleted screen goes back to
+    /// the start). Runtime state (variables set, variants changed) starts over from the edit.
+    pub fn sync(&mut self, doc: &Arc<Document>, now: f64) {
+        if self.source.as_ref().is_some_and(|s| Arc::ptr_eq(s, doc)) {
+            return;
+        }
+        let first = self.source.is_none();
+        self.source = Some(doc.clone());
+        let copy = Document::clone(doc);
+        self.original = Some(copy.clone());
+        self.design = Some(copy);
+        self.relayout();
+        if first {
+            self.arrived = now;
+            return;
+        }
+        if !doc.contains(self.current) {
+            if doc.contains(self.start) {
+                self.restart(self.start, now);
+            }
+            return;
+        }
+        self.history.retain(|v| doc.contains(v.frame));
+        self.overlays.retain(|o| doc.contains(o.id));
+        self.closing.retain(|(_, o)| doc.contains(o.id));
+        // These hold states of the document before the edit.
+        self.temp = None;
+        self.anim = None;
+        self.scroll_anim = None;
+        self.stop_scrolling();
+        self.scroll.retain(|f, _| doc.contains(*f));
+        if let Some(laid) = self.doc.as_ref() {
+            let clamped: Vec<(NodeId, (f64, f64))> = self.scroll.iter().map(|(f, s)| (*f, clamp_scroll(*s, self.range(laid, *f)))).collect();
+            self.scroll.extend(clamped);
+        }
+        self.rev += 1;
+    }
+
+    /// Lay the document out for the screen: `design` with the presented frame resized to `fit`
+    /// when the prototype is responsive (its constraints and auto layout respond), instances
+    /// playing their variants' interactions and fixed layers on top.
+    pub(super) fn relayout(&mut self) {
+        let mut d = self.design.clone();
+        if let Some(d) = d.as_mut() {
+            if let Some(size) = self.fit {
+                figcraft_engine::cmd::proto::respond(d, self.current, size);
+            }
+            figcraft_engine::proto_run::play_interactions(d);
+            raise_fixed(d);
+        }
+        self.uses_pads = d.as_ref().is_some_and(figcraft_doc::proto::uses_gamepad);
+        self.doc = d;
+        self.rev += 1;
+    }
+
+    /// After an action changed layers of `design` (since `before`): text resizes to what it shows,
+    /// instances follow and auto layout reflows, as after an edit on the canvas; then
+    /// [`relayout`](Self::relayout).
+    pub(super) fn settle(&mut self, before: &Document) {
+        if let Some(d) = self.design.as_mut() {
+            figcraft_engine::normalize(d, before);
+        }
+        self.relayout();
+    }
+
+    /// Responsive prototypes: resize the presented frame to a screen of `size` (None: frames
+    /// keep their size). Lays out again only when it changes.
+    pub(super) fn respond_to(&mut self, size: Option<(f64, f64)>) {
+        if self.fit != size {
+            self.fit = size;
+            self.relayout();
+        }
+    }
+
+    /// The player's document with scroll offsets applied and the presented frame sized to the
+    /// device's screen (cached per revision).
+    pub(crate) fn display(&mut self) -> Option<Document> {
+        if let Some((r, d)) = &self.display
+            && *r == self.rev
+        {
+            return Some(d.clone());
+        }
+        let doc = self.doc.as_ref()?;
+        let mut d = apply_scroll(doc, &self.scroll);
+        if let Some(vp) = viewport(doc, self.current) {
+            fit_viewport(&mut d, self.current, vp);
+        }
+        self.display = Some((self.rev, d.clone()));
+        Some(d)
+    }
+
+    /// The player's state for `ui.inspect`.
+    pub fn inspect(&self) -> Value {
+        let doc = self.doc.as_ref();
+        let pan = self.offset(Scroller::View);
+        json!({
+            "current": self.current,
+            "name": doc.and_then(|d| d.node(self.current)).map(|n| n.name.as_str()),
+            "start": self.start,
+            "history": self.history.iter().map(|v| v.frame).collect::<Vec<_>>(),
+            "overlays": self.overlays.iter().map(|o| o.id).collect::<Vec<_>>(),
+            "scroll": self.scroll.get(&self.current).map_or([0.0, 0.0], |s| [s.0, s.1]),
+            "scrollRange": doc.map(|d| { let r = self.range(d, self.current); [r.0, r.1] }),
+            "device": doc.and_then(|d| page_settings(d, self.current).device()).map(|d| d.name),
+            "landscape": doc.is_some_and(|d| page_settings(d, self.current).landscape()),
+            "viewport": doc.and_then(|d| viewport(d, self.current)).map(|v| [v.0, v.1]),
+            "scale": self.view.scale.id(),
+            "deviceFrame": self.view.device_frame,
+            "comments": self.view.comments,
+            "hotspotHints": self.view.hotspot_hints,
+            "hotspots": self.hot.iter().map(|(id, r)| json!({"id": id, "rect": [r.min.x, r.min.y, r.max.x, r.max.y]})).collect::<Vec<_>>(),
+            "hotspotFlash": self.flash_until > self.clock,
+            "waiting": self.waiting.len(),
+            "inspect": self.view.inspect,
+            "inspected": self.inspected,
+            "deviceColor": doc.and_then(|d| page_settings(d, self.current).device_color()).map(|c| c.name),
+            "responsive": self.fit.map(|f| [f.0, f.1]),
+            "frameSize": doc.and_then(|d| d.node(self.current)).map(|n| [n.width, n.height]),
+            "pan": [pan.0, pan.1],
+            "panRange": [self.pan_range.0, self.pan_range.1],
+            "zoom": self.zoom,
+            "flinging": self.fling.is_some(),
+            "gamepad": self.uses_pads,
+            "linkNotice": self.link_notice.as_ref().map(|(url, _)| url),
+        })
+    }
+
+    pub(super) fn snapshot(&self) -> Option<Snapshot> {
+        Some(Snapshot {
+            current: self.current,
+            doc: self.design.clone()?,
+            overlays: self.overlays.clone(),
+            history: self.history.clone(),
+            scroll: self.scroll.clone(),
+        })
+    }
+
+    /// Start a transition from the state as it is now; call before changing the state.
+    pub(super) fn begin(&mut self, transition: Transition, dur: f64, easing: Easing, now: f64) {
+        let Some(from_doc) = self.display() else { return };
+        let from_tex = self.textures.get(&self.current).cloned();
+        self.anim = if matches!(transition, Transition::Instant) || dur <= 0.0 {
+            None
+        } else {
+            Some(Anim { from_doc, from_frame: self.current, from_tex, transition, start: now, dur, easing, follow: None })
+        };
+    }
+
+    fn arrive(&mut self, now: f64) {
+        if let Some(doc) = self.doc.as_ref() {
+            figcraft_engine::proto_run::remember_sections(doc, self.current, &mut self.sections);
+        }
+        self.arrived = now;
+        self.delays_fired.clear();
+        self.waiting.clear();
+        self.hovered.clear();
+        self.rev += 1;
+    }
+
+    /// Show `frame`. It starts scrolled to the top unless `preserve` keeps the scroll position of
+    /// the frame being left (as far as `frame` can scroll).
+    pub(super) fn go(&mut self, frame: NodeId, transition: Transition, dur: f64, easing: Easing, now: f64, remember: bool, preserve: bool) {
+        self.begin(transition, dur, easing, now);
+        if remember {
+            self.history.push(Visit { frame: self.current, transition, dur, easing });
+        }
+        let kept = self.scroll.get(&self.current).copied().filter(|_| preserve);
+        self.overlays.clear();
+        self.scroll.clear();
+        self.scroll_anim = None;
+        self.stop_scrolling();
+        self.pan = None;
+        self.temp = None;
+        self.current = frame;
+        self.relayout();
+        if let Some(s) = kept
+            && let Some(doc) = self.doc.as_ref()
+        {
+            let to = clamp_scroll(s, self.range(doc, frame));
+            self.scroll.insert(frame, to);
+        }
+        self.arrive(now);
+    }
+
+    /// Start over at `start` with the document as the editor has it.
+    pub fn restart(&mut self, start: NodeId, now: f64) {
+        self.start = start;
+        self.current = start;
+        self.sections.clear();
+        self.history.clear();
+        self.overlays.clear();
+        self.scroll.clear();
+        self.scroll_anim = None;
+        self.stop_scrolling();
+        self.pan = None;
+        self.anim = None;
+        self.temp = None;
+        self.design = self.original.clone();
+        self.relayout();
+        self.arrive(now);
+    }
+
+    pub(super) fn revert(&mut self, now: f64) {
+        let Some(t) = self.temp.take() else { return };
+        self.begin(t.transition.reversed(), t.dur, t.easing, now);
+        self.current = t.snap.current;
+        self.design = Some(t.snap.doc);
+        self.relayout();
+        self.overlays = t.snap.overlays;
+        self.history = t.snap.history;
+        self.scroll = t.snap.scroll;
+        self.stop_scrolling();
+        self.hovered.clear();
+        self.rev += 1;
+    }
+}
+
+/// The soonest "after delay" interaction in `root`'s subtree that hasn't fired yet, and the seconds
+/// until it's due (zero or less: due now). Timers start when the screen arrives, an overlay's when
+/// it opens.
+pub(crate) fn next_delay(p: &Presenter, doc: &Document, root: NodeId, now: f64) -> Option<((NodeId, usize), f64)> {
+    let since = p.overlays.last().filter(|o| o.id == root).map_or(p.arrived, |o| o.opened);
+    let mut next: Option<((NodeId, usize), f64)> = None;
+    for id in doc.subtree(root) {
+        let Some(n) = doc.node(id) else { continue };
+        for (k, it) in n.interactions.iter().enumerate() {
+            if let Trigger::AfterDelay { ms } = it.trigger
+                && !p.delays_fired.contains(&(id, k))
+            {
+                let due = since + f64::from(ms) / 1000.0 - now;
+                if next.is_none_or(|(_, d)| due < d) {
+                    next = Some(((id, k), due));
+                }
+            }
+        }
+    }
+    next
+}
diff --git a/crates/ui-egui/src/present/player.rs b/crates/ui-egui/src/present/player.rs
new file mode 100644
index 00000000..dc47baa7
--- /dev/null
+++ b/crates/ui-egui/src/present/player.rs
@@ -0,0 +1,285 @@
+use super::chrome::{BarAction, layer_at, paint_menu_chevron};
+use super::device::{device_body, device_glass};
+use super::draw::draw;
+use super::input::input;
+use super::layout::{Chrome, Layout, layout};
+use super::navigate::next_delay;
+use super::scroll::page_settings;
+use super::transition::lerp;
+use super::*;
+
+/// One frame of the player in `rect`: the top bar, then the prototype (on its device) below.
+/// Returns what the bar asked for (restarting is done here).
+pub(super) fn player(p: &mut Presenter, ui: &mut Ui, rect: Rect, now: f64, chrome: Chrome) -> Option<BarAction> {
+    let ctx = ui.ctx().clone();
+    p.clock = now;
+    let bar = Rect::from_min_size(rect.min, vec2(rect.width(), chrome.bar_h));
+    let area = Rect::from_min_max(pos2(rect.min.x, bar.max.y), rect.max);
+    let bg = crate::theme::doc_c32(ui.ctx(), p.doc.as_ref().map(|d| page_settings(d, p.current)).unwrap_or_default().background);
+    let r = chrome.round;
+    ui.painter().rect_filled(area, CornerRadius { nw: 0, ne: 0, sw: r, se: r }, bg);
+    let action = top_bar(p, ui, bar, now, chrome);
+    if action == Some(BarAction::Restart) {
+        p.restart(p.start, now);
+    }
+    if p.doc.as_ref().is_none_or(|d| !d.contains(p.current)) {
+        // Controller buttons pressed with no frame to show are dropped, as they are while a link
+        // notice shows.
+        p.pads.clear();
+        if !chrome.pane {
+            return Some(BarAction::Close);
+        }
+        ui.painter().text(area.center(), Align2::CENTER_CENTER, tr("Select a frame to preview it"), regular(12.0), Color32::from_gray(170));
+        return action;
+    }
+    // Scroll animation (Scroll to).
+    if let Some(sa) = &p.scroll_anim {
+        let raw = ((now - sa.start) / sa.dur.max(1e-3)).clamp(0.0, 1.0);
+        let e = sa.easing.eval(raw);
+        for (f, from, to) in &sa.frames {
+            p.scroll.insert(*f, (lerp(from.0, to.0, e), lerp(from.1, to.1, e)));
+        }
+        p.rev += 1;
+        if raw >= 1.0 {
+            p.scroll_anim = None;
+        }
+        ctx.request_repaint();
+    }
+    // Scrolling that carries on after the input let go (repaints only while it moves).
+    if p.step_fling(now) {
+        ctx.request_repaint();
+    }
+    let resp = ui.interact(area, ui.scope_id().with("present_area"), Sense::click_and_drag());
+    let over = resp.contains_pointer();
+    if let Some(l) = layout(p, area, chrome) {
+        // The pane only takes the keyboard while the pointer is over it. While a link notice shows
+        // the prototype takes neither keys nor the pointer (Escape there cancels the notice).
+        let keys = chrome.keys && p.link_notice.is_none() && (!chrome.pane || over);
+        input(p, &ctx, &l, over && p.link_notice.is_none(), keys, chrome.pane, now);
+    } else {
+        p.pads.clear();
+    }
+    let Some(l) = layout(p, area, chrome) else { return action };
+    p.shown = Some((p.current, l.place, l.clip.intersect(area)));
+    let painter = ui.painter_at(area);
+    let body = l.device.zip(l.color);
+    if l.device.is_some() {
+        if let Some((d, c)) = body {
+            device_body(&painter, d.name, l.screen, l.landscape, c);
+        }
+        painter.rect_filled(l.screen, CornerRadius::ZERO, bg);
+    }
+    draw(p, &painter, &ctx, &l, now);
+    if p.view.inspect && !chrome.pane {
+        inspect_hover(p, &painter, &ctx, &l, area);
+    }
+    if let Some((d, _)) = body {
+        device_glass(&painter, d.name, l.screen, l.landscape);
+    }
+    // Timers: wake up for the soonest pending "after delay" of the layer that can fire it (they
+    // wait while a transition plays, which draws every frame anyway).
+    if p.anim.is_none()
+        && let Some((_, due)) = next_delay(p, &l.disp, l.active(p.current).0, now)
+    {
+        crate::repaint_in(&ctx, due.min(60.0));
+    }
+    // And for the soonest mouse trigger waiting out its delay.
+    if let Some(due) = p.waiting.iter().map(|w| w.due - now).reduce(f64::min) {
+        crate::repaint_in(&ctx, due.clamp(0.0, 60.0));
+    }
+    action
+}
+
+/// Inspecting: the layer under the pointer becomes the inspected one; it is outlined.
+fn inspect_hover(p: &mut Presenter, painter: &egui::Painter, ctx: &egui::Context, l: &Layout, area: Rect) {
+    let (root, place, clip) = l.active(p.current);
+    if let Some(q) = ctx.pointer_hover_pos().filter(|q| area.contains(*q) && clip.contains(*q))
+        && let Some(id) = layer_at(&l.disp, root, &place, q)
+    {
+        p.inspected = Some(id);
+    }
+    if let Some(id) = p.inspected.filter(|id| *id == root || l.disp.is_ancestor(root, *id))
+        && let Some(b) = l.disp.world_bounds(id)
+    {
+        painter.with_clip_rect(clip).rect_stroke(place.rect(b), CornerRadius::ZERO, Stroke::new(1.5, ACCENT), StrokeKind::Outside);
+    }
+}
+
+/// The bar above the prototype: the flow picker and the frame's name on the left, the buttons on
+/// the right (text on the dark full-window bar, icons in the pane, which follows the theme).
+fn top_bar(p: &mut Presenter, ui: &mut Ui, bar: Rect, now: f64, chrome: Chrome) -> Option<BarAction> {
+    let t = Tokens::get(ui.ctx());
+    let (fill, text, dim, hover) = (t.panel, t.text, t.text_secondary, t.hover);
+    let r = chrome.round;
+    ui.painter().rect_filled(bar, CornerRadius { nw: r, ne: r, sw: 0, se: 0 }, fill);
+    if chrome.pane {
+        ui.painter().line_segment([bar.left_bottom(), bar.right_bottom()], Stroke::new(1.0, t.border));
+    }
+    let source_key = p.source.as_ref().map_or(0, |s| Arc::as_ptr(s) as usize);
+    if !chrome.pane && p.bar_thumb.as_ref().is_none_or(|(id, source, _)| *id != p.current || *source != source_key) {
+        p.bar_thumb =
+            p.source.as_ref().and_then(|d| crate::assets_panel::thumbnail(ui.ctx(), d, p.current, 38.0)).map(|tex| (p.current, source_key, tex));
+    }
+    let doc = p.doc.as_ref()?;
+    let name = doc.node(p.current).map(|n| n.name.clone()).unwrap_or_default();
+    let flows = match doc.page_of(p.start).and_then(|pg| doc.node(pg)).map(|n| &n.kind) {
+        Some(NodeKind::Page { flows, .. }) => flows.clone(),
+        _ => vec![],
+    };
+    let settings = page_settings(doc, p.current);
+    let device = settings.device();
+    let mut action = None;
+    // Right: the buttons, right to left (English labels key their ids; shown translated).
+    let buttons: &[(BarAction, &str, Icon)] = if chrome.pane {
+        &[
+            (BarAction::Close, tr_noop("Close preview"), Icon::Close),
+            (BarAction::Present, tr_noop("Present"), Icon::Play),
+            (BarAction::Restart, tr_noop("Restart"), Icon::Reset),
+        ]
+    } else {
+        &[
+            (BarAction::Close, tr_noop("Close"), Icon::Close),
+            (BarAction::Restart, tr_noop("Restart"), Icon::Reset),
+            (BarAction::Options, tr_noop("Options"), Icon::Dots),
+            (BarAction::Comments, tr_noop("Comments"), Icon::Comment),
+            (BarAction::Inspect, tr_noop("Inspect"), Icon::Code),
+        ]
+    };
+    let mut x = bar.max.x - if chrome.pane { 6.0 } else { 8.0 };
+    for (act, label, icon) in buttons {
+        let shown = tr(label);
+        let w = if chrome.pane { 24.0 } else { ui.painter().layout_no_wrap(shown.to_string(), regular(11.5), text).size().x + 16.0 };
+        let br = Rect::from_min_size(pos2(x - w, bar.center().y - 12.0), vec2(w, 24.0));
+        x = br.min.x - if chrome.pane { 2.0 } else { 4.0 };
+        let mut resp = ui.interact(br, ui.scope_id().with(("pbar", *label)), Sense::click());
+        if chrome.pane {
+            resp = resp.tip(shown);
+        }
+        let on = (*act == BarAction::Comments && p.view.comments) || (*act == BarAction::Inspect && p.view.inspect);
+        if on {
+            ui.painter().rect_filled(br, CornerRadius::same(5), t.accent);
+        } else if resp.hovered() {
+            ui.painter().rect_filled(br, CornerRadius::same(5), hover);
+        }
+        if *act == BarAction::Comments {
+            resp = resp.tip(tr("Show comments (Shift+C)"));
+        }
+        if *act == BarAction::Inspect {
+            resp = resp.tip(tr("Inspect the layer under the pointer: size, colours, typography"));
+        }
+        if chrome.pane {
+            icons::paint(ui.painter(), br.shrink(5.0), *icon, if on { t.accent_on } else { t.icon });
+        } else {
+            ui.painter().text(br.center(), Align2::CENTER_CENTER, shown, regular(11.5), if on { t.accent_on } else { text });
+        }
+        if *act == BarAction::Options {
+            let menu = crate::right::menu_popup(&resp).width(220.0).show(|ui| options_menu(p, ui, device, settings.responsive, now));
+            action = action.or(menu.and_then(|m| m.inner));
+        } else if resp.clicked() {
+            action = Some(*act);
+        }
+    }
+    // Left: the flow picker and the frame's name, clipped before the buttons.
+    let left = ui.painter().with_clip_rect(Rect::from_min_max(bar.min, pos2(x, bar.max.y)));
+    let mut lx = bar.min.x + if chrome.pane { 8.0 } else { 12.0 };
+    if !chrome.pane {
+        let thumb = Rect::from_center_size(pos2(lx + 15.0, bar.center().y), vec2(28.0, 28.0));
+        left.rect_filled(thumb, CornerRadius::same(4), t.field);
+        if let Some((_, _, tex)) = &p.bar_thumb {
+            let size = tex.size_vec2();
+            if size.x > 0.0 && size.y > 0.0 {
+                let scaled = size * (26.0 / size.x.max(size.y));
+                let dst = Rect::from_center_size(thumb.center(), scaled);
+                left.image(tex.id(), dst, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+            }
+        }
+        lx += 38.0;
+    }
+    // The flow playing: its name on the picker, its description on hover; the menu lists each
+    // flow with its description.
+    let playing = flows.iter().find(|f| f.start == p.start);
+    if !flows.is_empty() {
+        let label = playing.map_or(tr("Flows"), |f| f.name.as_str()).to_owned();
+        let tip = playing.map(|f| f.description.trim()).filter(|d| !d.is_empty()).unwrap_or(tr("Flows")).to_string();
+        let galley = left.layout_no_wrap(label, semibold(11.5), text);
+        let fr = Rect::from_min_size(pos2(lx, bar.center().y - 12.0), vec2(galley.size().x + 30.0, 24.0));
+        let resp = ui.interact(fr.intersect(left.clip_rect()), ui.scope_id().with("pflows"), Sense::click()).tip(tip);
+        if resp.hovered() {
+            left.rect_filled(fr, CornerRadius::same(5), hover);
+        }
+        left.galley(pos2(fr.min.x + 8.0, fr.center().y - galley.size().y / 2.0), galley, text);
+        paint_menu_chevron(&left, fr, t.icon_secondary);
+        crate::right::menu_popup(&resp).width(240.0).show(|ui| {
+            let t = Tokens::get(ui.ctx());
+            for f in &flows {
+                if crate::right::menu_check(ui, f.start == p.start, &f.name, "") {
+                    p.restart(f.start, now);
+                    ui.close();
+                }
+                let d = f.description.trim();
+                if !d.is_empty() {
+                    egui::Frame::NONE.inner_margin(egui::Margin { left: 26, right: 8, top: 0, bottom: 4 }).show(ui, |ui| {
+                        ui.add(egui::Label::new(egui::RichText::new(d).font(regular(10.5)).color(t.text_secondary)).wrap());
+                    });
+                }
+            }
+        });
+        lx = fr.max.x + 8.0;
+        left.text(pos2(lx, bar.center().y), Align2::LEFT_CENTER, "/", regular(11.5), dim);
+        lx += 14.0;
+    }
+    left.text(pos2(lx, bar.center().y), Align2::LEFT_CENTER, name, regular(11.5), text);
+    action
+}
+
+/// The full-window presenter's options menu: how the prototype is sized (Z cycles them), whether
+/// the frame is responsive (a file setting: the frame takes the window's size, or on a device the
+/// screen's, instead of being scaled or shown at a fixed size), the device's body, hotspot hints,
+/// restart (R).
+fn options_menu(p: &mut Presenter, ui: &mut Ui, device: Option<Device>, responsive: bool, now: f64) -> Option<BarAction> {
+    use crate::right::menu_check;
+    let mut action = None;
+    let on_device = device.is_some();
+    // Without a device, responsive is one of the sizes: the frame fills the window at 100%.
+    if !on_device && menu_check(ui, responsive, tr("Responsive"), "") {
+        action = Some(BarAction::Responsive(true));
+        ui.close();
+    }
+    for s in PresentScale::options(on_device) {
+        if menu_check(ui, p.view.scale == *s && (on_device || !responsive), s.label(on_device), "") {
+            p.set_scale(*s);
+            if !on_device && responsive {
+                action = Some(BarAction::Responsive(false));
+            }
+            ui.close();
+        }
+    }
+    if (on_device || !responsive) && menu_check(ui, false, tr("Next size option"), "Z") {
+        p.set_scale(p.view.scale.next(on_device));
+        ui.close();
+    }
+    ui.separator();
+    // On a device: the frame takes the screen's size, or keeps its own (clipped or scrolling).
+    if on_device {
+        for (on, label) in [(true, tr("Responsive")), (false, tr("Fixed size"))] {
+            if menu_check(ui, responsive == on, label, "") {
+                action = (responsive != on).then_some(BarAction::Responsive(on));
+                ui.close();
+            }
+        }
+        ui.separator();
+    }
+    if device.is_some_and(|d| !d.colors.is_empty()) && menu_check(ui, p.view.device_frame, tr("Show device frame"), "") {
+        p.view.device_frame = !p.view.device_frame;
+        ui.close();
+    }
+    if menu_check(ui, p.view.hotspot_hints, tr("Show hotspot hints"), "") {
+        p.view.hotspot_hints = !p.view.hotspot_hints;
+        ui.close();
+    }
+    if menu_check(ui, false, tr("Restart"), "R") {
+        p.restart(p.start, now);
+        ui.close();
+    }
+    action
+}
diff --git a/crates/ui-egui/src/present/scroll.rs b/crates/ui-egui/src/present/scroll.rs
new file mode 100644
index 00000000..12c682cc
--- /dev/null
+++ b/crates/ui-egui/src/present/scroll.rs
@@ -0,0 +1,354 @@
+use super::layout::Place;
+use super::*;
+
+/// How quickly a fling slows down after a drag (1/s; it travels its speed / decay).
+pub(super) const DECAY_DRAG: f64 = 2.5;
+
+/// How quickly the wheel's coast slows down (1/s).
+pub(super) const DECAY_WHEEL: f64 = 8.0;
+
+/// Stiffness of the spring that pulls an overscroll back (1/s, critically damped).
+const SPRING: f64 = 16.0;
+
+/// A fling inside its range stops below this speed (units/s).
+const FLING_STOP: f64 = 6.0;
+
+/// The wheel coasts on when it was faster than this as it stopped (screen points/s).
+pub(super) const COAST_MIN: f64 = 40.0;
+
+/// How far a drag past the end can stretch the content at most (screen points).
+pub(super) const RUBBER_PTS: f64 = 240.0;
+
+impl Presenter {
+    /// The current offset of `t` (a frame's scroll, else the view's pan).
+    pub(super) fn offset(&self, t: Scroller) -> (f64, f64) {
+        match t {
+            Scroller::Frame(f) => self.scroll.get(&f).copied().unwrap_or((0.0, 0.0)),
+            Scroller::View => self.pan.unwrap_or((self.pan_range.0 / 2.0, 0.0)),
+        }
+    }
+
+    /// How far `t` scrolls (`base`: the player's document without scroll offsets).
+    pub(super) fn limits(&self, base: &Document, t: Scroller) -> (f64, f64) {
+        match t {
+            Scroller::Frame(f) => self.range(base, f),
+            Scroller::View => self.pan_range,
+        }
+    }
+
+    pub(super) fn set_offset(&mut self, t: Scroller, v: (f64, f64)) {
+        if !v.0.is_finite() || !v.1.is_finite() {
+            return;
+        }
+        match t {
+            Scroller::Frame(f) => {
+                if self.scroll.get(&f) != Some(&v) {
+                    self.scroll.insert(f, v);
+                    self.rev += 1;
+                }
+            }
+            Scroller::View => self.pan = Some(v),
+        }
+    }
+
+    /// Move a fling on to `now`; true while it is still moving.
+    pub(super) fn step_fling(&mut self, now: f64) -> bool {
+        let Some(mut f) = self.fling.take() else { return false };
+        let Some(base) = self.doc.as_ref() else { return false };
+        let r = self.limits(base, f.target);
+        let x = self.offset(f.target);
+        let dt = (now - f.at).clamp(0.0, 0.25);
+        f.at = now;
+        let (nx, vx, done_x) = fling_axis(x.0, f.vel.0, r.0, dt, f.decay, f.bounce);
+        let (ny, vy, done_y) = fling_axis(x.1, f.vel.1, r.1, dt, f.decay, f.bounce);
+        self.set_offset(f.target, (nx, ny));
+        f.vel = (vx, vy);
+        if done_x && done_y {
+            return false;
+        }
+        self.fling = Some(f);
+        true
+    }
+
+    /// How far `frame` scrolls (in `doc`, without scroll offsets): the presented frame within the
+    /// device's screen, other frames within themselves.
+    pub(super) fn range(&self, doc: &Document, frame: NodeId) -> (f64, f64) {
+        let vp = if frame == self.current { viewport(doc, frame) } else { None };
+        scroll_range_in(doc, frame, vp)
+    }
+
+    /// What "Scroll to" `dest` moves: every scrolling frame around it, innermost first, brings the
+    /// layer (then the frame holding it) to its top-left as far as it can scroll, the innermost
+    /// `offset` short of it. Each entry is (frame, offset now, offset after).
+    pub(super) fn scroll_to_layer(&self, doc: &Document, dest: NodeId, offset: [f64; 2]) -> Vec<ScrollMove> {
+        let mut out = Vec::new();
+        let mut target = dest;
+        // The innermost scrolling frame leaves `offset` before the layer.
+        let mut off = offset.map(|v| if v.is_finite() { v } else { 0.0 });
+        for f in doc.ancestors(dest) {
+            let (rx, ry) = self.range(doc, f);
+            let Some(tn) = doc.node(target) else { break };
+            if rx <= 0.0 && ry <= 0.0 {
+                continue;
+            }
+            let rel = doc.world_transform(f).inverse() * doc.world_transform(target);
+            let b = figcraft_geom::transform_rect_bbox(rel, tn.local_rect());
+            let from = self.scroll.get(&f).copied().unwrap_or((0.0, 0.0));
+            let to = clamp_scroll((if rx > 0.0 { b.x0 - off[0] } else { from.0 }, if ry > 0.0 { b.y0 - off[1] } else { from.1 }), (rx, ry));
+            out.push((f, from, to));
+            target = f;
+            off = [0.0, 0.0];
+        }
+        out
+    }
+
+    /// Scroll the presented frame to `(x, y)` (page units, clamped to what it can scroll).
+    pub fn scroll_to(&mut self, x: f64, y: f64) {
+        let Some(doc) = self.doc.as_ref() else { return };
+        if !x.is_finite() || !y.is_finite() {
+            return;
+        }
+        let to = clamp_scroll((x, y), self.range(doc, self.current));
+        self.scroll.insert(self.current, to);
+        self.scroll_anim = None;
+        self.stop_scrolling();
+        self.rev += 1;
+    }
+}
+
+/// How far `frame`'s content can scroll `(x, y)` (0 when it doesn't overflow or doesn't scroll).
+pub fn scroll_range(doc: &Document, frame: NodeId) -> (f64, f64) {
+    scroll_range_in(doc, frame, None)
+}
+
+/// How far `frame`'s content can scroll when `viewport` (page units, from its top-left) of it
+/// shows, as a device's screen shows a top-level frame: the frame itself is content then, so a
+/// frame bigger than the screen scrolls through its whole size whatever its overflow (as in
+/// Figma, a top-level frame needs no overflow setting for that). Without a viewport the frame
+/// shows at its own size and what overflows it scrolls. Content past the frame's own edges
+/// scrolls only on the axes its overflow allows.
+pub fn scroll_range_in(doc: &Document, frame: NodeId, viewport: Option<(f64, f64)>) -> (f64, f64) {
+    let Some(n) = doc.node(frame) else { return (0.0, 0.0) };
+    if n.overflow == Overflow::None && viewport.is_none() {
+        return (0.0, 0.0);
+    }
+    let (mut x1, mut y1) = (0.0f64, 0.0f64);
+    for c in &n.children {
+        let Some(cn) = doc.node(*c) else { continue };
+        if !cn.visible || cn.scroll_position == ScrollPosition::Fixed {
+            continue;
+        }
+        let b = figcraft_geom::transform_rect_bbox(cn.transform, cn.local_rect());
+        x1 = x1.max(b.x1);
+        y1 = y1.max(b.y1);
+    }
+    if let Some(l) = &n.layout {
+        x1 += l.padding[1];
+        y1 += l.padding[2];
+    }
+    // Axes the overflow doesn't scroll clip what lies past the frame's edges.
+    if !matches!(n.overflow, Overflow::Horizontal | Overflow::Both) {
+        x1 = 0.0;
+    }
+    if !matches!(n.overflow, Overflow::Vertical | Overflow::Both) {
+        y1 = 0.0;
+    }
+    let (vw, vh) = match viewport {
+        Some(v) => {
+            x1 = x1.max(n.width);
+            y1 = y1.max(n.height);
+            v
+        }
+        None => (n.width, n.height),
+    };
+    let (rx, ry) = ((x1 - vw).max(0.0), (y1 - vh).max(0.0));
+    (if rx.is_finite() { rx } else { 0.0 }, if ry.is_finite() { ry } else { 0.0 })
+}
+
+/// `(x, y)` kept within `0..=range` on each axis (0 for non-finite values).
+pub(super) fn clamp_scroll((x, y): (f64, f64), (rx, ry): (f64, f64)) -> (f64, f64) {
+    let c = |v: f64, r: f64| if v.is_finite() && r.is_finite() { v.clamp(0.0, r.max(0.0)) } else { 0.0 };
+    (c(x, rx), c(y, ry))
+}
+
+/// One axis of a fling after `dt` seconds: from offset `x` moving at `v` (units/s) in a range
+/// `0..=r`. Inside the range it slows down exponentially (`decay`, 1/s: it travels `v / decay`);
+/// past an end it either stops there or, with `bounce`, a critically damped spring pulls it back.
+/// Both are solved exactly over short sub-steps, so the motion doesn't depend on the frame rate.
+/// Returns the new offset and speed, and whether it has come to rest.
+pub fn fling_axis(x: f64, v: f64, r: f64, dt: f64, decay: f64, bounce: bool) -> (f64, f64, bool) {
+    if !(x.is_finite() && v.is_finite() && r.is_finite() && dt.is_finite() && decay > 0.0) || r <= 0.0 {
+        return (if r.is_finite() && x.is_finite() { x.clamp(0.0, r.max(0.0)) } else { 0.0 }, 0.0, true);
+    }
+    // A frame is never longer than a second, nor a fling faster than a million units a second.
+    let dt = dt.clamp(0.0, 1.0);
+    let steps = (dt * 240.0).ceil().clamp(1.0, 64.0);
+    let h = dt / steps;
+    let (mut x, mut v) = (x, v.clamp(-1e6, 1e6));
+    for _ in 0..steps as usize {
+        if (0.0..=r).contains(&x) {
+            let e = (-decay * h).exp();
+            x += v * (1.0 - e) / decay;
+            v *= e;
+            if !bounce && !(0.0..=r).contains(&x) {
+                x = x.clamp(0.0, r);
+                v = 0.0;
+            }
+        } else {
+            let end = x.clamp(0.0, r);
+            let (d, e) = (x - end, (-SPRING * h).exp());
+            let c = v + SPRING * d;
+            x = end + (d + c * h) * e;
+            v = (v - SPRING * c * h) * e;
+        }
+    }
+    if !x.is_finite() || !v.is_finite() {
+        return (0.0, 0.0, true);
+    }
+    let end = x.clamp(0.0, r);
+    if x == end && v.abs() < FLING_STOP {
+        return (x, 0.0, true);
+    }
+    if x != end && (x - end).abs() < 0.5 && v.abs() < FLING_STOP * 4.0 {
+        return (end, 0.0, true);
+    }
+    (x, v, false)
+}
+
+/// Where a drag to offset `x` shows in a range `0..=r`: past an end it stretches less the further
+/// it goes, never more than `limit` past.
+pub fn rubber_band(x: f64, r: f64, limit: f64) -> f64 {
+    if !x.is_finite() || !r.is_finite() || r <= 0.0 || !limit.is_finite() || limit <= 0.0 {
+        return if x.is_finite() && r.is_finite() { x.clamp(0.0, r.max(0.0)) } else { 0.0 };
+    }
+    let band = |over: f64| limit * (1.0 - 1.0 / (over * 0.55 / limit + 1.0));
+    if x < 0.0 {
+        -band(-x)
+    } else if x > r {
+        r + band(x - r)
+    } else {
+        x
+    }
+}
+
+/// The prototype settings of the page holding `id` (defaults when there's none).
+pub fn page_settings(doc: &Document, id: NodeId) -> PrototypeSettings {
+    doc.page_of(id)
+        .and_then(|pg| doc.node(pg))
+        .and_then(|n| match &n.kind {
+            NodeKind::Page { prototype, .. } => Some(prototype.clone()),
+            _ => None,
+        })
+        .unwrap_or_default()
+}
+
+/// The part of top-level `frame` its page's device shows (page units): the frame clipped to the
+/// device's screen. None without a device: the frame then shows whole.
+pub fn viewport(doc: &Document, frame: NodeId) -> Option<(f64, f64)> {
+    let d = page_settings(doc, frame).device()?;
+    let n = doc.node(frame)?;
+    Some((n.width.min(d.width), n.height.min(d.height)))
+}
+
+/// Size `frame` to the `(w, h)` of it a screen shows. The content keeps its place (what doesn't
+/// fit is clipped or scrolls); fixed layers follow their constraints to the screen's edges, so a
+/// tab bar pinned to the frame's bottom sits at the bottom of the screen (stretching constraints
+/// keep the layer's size).
+pub fn fit_viewport(doc: &mut Document, frame: NodeId, (w, h): (f64, f64)) {
+    let Some(n) = doc.node(frame) else { return };
+    let (dw, dh) = (w - n.width, h - n.height);
+    if !dw.is_finite() || !dh.is_finite() || (dw == 0.0 && dh == 0.0) {
+        return;
+    }
+    let fixed: Vec<NodeId> =
+        n.children.iter().copied().filter(|c| doc.node(*c).is_some_and(|c| c.scroll_position == ScrollPosition::Fixed)).collect();
+    for c in fixed {
+        if let Some(m) = doc.node_mut(c) {
+            let dx = match m.constraints.horizontal {
+                HConstraint::Right => dw,
+                HConstraint::Center => dw / 2.0,
+                _ => 0.0,
+            };
+            let dy = match m.constraints.vertical {
+                VConstraint::Bottom => dh,
+                VConstraint::Center => dh / 2.0,
+                _ => 0.0,
+            };
+            m.transform = Affine::translate((dx, dy)) * m.transform;
+        }
+    }
+    if let Some(m) = doc.node_mut(frame) {
+        m.width = w;
+        m.height = h;
+    }
+}
+
+/// Shift scrolling frames' children by their scroll offsets. Fixed children stay put; sticky
+/// children scroll until they reach the frame's top/left edge, then stay there.
+pub fn apply_scroll(doc: &Document, scroll: &HashMap<NodeId, (f64, f64)>) -> Document {
+    let mut out = doc.clone();
+    let sticky = |pos: f64, s: f64| if pos >= 0.0 && pos - s < 0.0 { -pos } else { -s };
+    for (&frame, &(sx, sy)) in scroll {
+        if !sx.is_finite() || !sy.is_finite() || (sx == 0.0 && sy == 0.0) {
+            continue;
+        }
+        let Some(n) = doc.node(frame) else { continue };
+        for &c in &n.children {
+            let Some(cn) = doc.node(c) else { continue };
+            let (dx, dy) = match cn.scroll_position {
+                ScrollPosition::Fixed => continue,
+                ScrollPosition::Scrolls => (-sx, -sy),
+                ScrollPosition::Sticky => {
+                    let b = figcraft_geom::transform_rect_bbox(cn.transform, cn.local_rect());
+                    (sticky(b.x0, sx), sticky(b.y0, sy))
+                }
+            };
+            if let Some(m) = out.node_mut(c) {
+                m.transform = Affine::translate((dx, dy)) * m.transform;
+            }
+        }
+    }
+    out
+}
+
+/// Fixed layers draw (and take clicks) above the content that scrolls under them: each frame's
+/// fixed children move to the top of its children, keeping their order (for the player's copy).
+pub fn raise_fixed(doc: &mut Document) {
+    let fixed = |c: &NodeId| doc.node(*c).is_some_and(|c| c.scroll_position == ScrollPosition::Fixed);
+    let moves: Vec<(NodeId, Vec<NodeId>)> = doc
+        .nodes()
+        .filter(|n| !matches!(n.kind, NodeKind::Page { .. }) && n.children.iter().any(fixed))
+        .filter_map(|n| {
+            let (top, mut order): (Vec<NodeId>, Vec<NodeId>) = n.children.iter().partition(|c| fixed(c));
+            order.extend(top);
+            (order != n.children).then_some((n.id, order))
+        })
+        .collect();
+    for (id, order) in moves {
+        if let Some(n) = doc.node_mut(id) {
+            n.children = order;
+        }
+    }
+}
+
+/// Scrolling frames under the screen point `q`, innermost first: those of `root` (in the display
+/// document `disp`) that can scroll (`base` is the player's document without scroll offsets).
+pub(super) fn scrollers_at(p: &Presenter, base: &Document, disp: &Document, root: NodeId, place: &Place, q: Pos2) -> Vec<NodeId> {
+    let mut out: Vec<NodeId> = disp
+        .subtree(root)
+        .into_iter()
+        .filter(|f| disp.node(*f).is_some_and(|n| n.visible && (n.overflow != Overflow::None || *f == root)))
+        .filter(|f| disp.world_bounds(*f).is_some_and(|b| place.rect(b).contains(q)))
+        .filter(|f| p.range(base, *f) != (0.0, 0.0))
+        .collect();
+    out.reverse();
+    out
+}
+
+/// Screen points → `t`'s units (page units for frames, points for the view).
+pub(super) fn units_per_point(t: Scroller, scale: f64) -> f64 {
+    match t {
+        Scroller::Frame(_) => 1.0 / scale.max(1e-6),
+        Scroller::View => 1.0,
+    }
+}
diff --git a/crates/ui-egui/src/present/transition.rs b/crates/ui-egui/src/present/transition.rs
new file mode 100644
index 00000000..e31078d2
--- /dev/null
+++ b/crates/ui-egui/src/present/transition.rs
@@ -0,0 +1,251 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Pure prototype logic (tested below).
+
+/// Layer names from below `root` down to `id`, joined (the smart-animate matching key).
+pub fn name_path(doc: &Document, root: NodeId, id: NodeId) -> Option<String> {
+    let mut parts: Vec<&str> = Vec::new();
+    let mut cur = id;
+    for _ in 0..1024 {
+        if cur == root {
+            parts.reverse();
+            return Some(parts.join("\u{1f}"));
+        }
+        let n = doc.node(cur)?;
+        parts.push(n.name.as_str());
+        cur = n.parent?;
+    }
+    None
+}
+
+/// Smart-animate pairs `(from layer, to layer)`: same name path below the two roots; repeated
+/// paths pair up in layer order.
+pub fn match_layers(from: &Document, from_root: NodeId, to: &Document, to_root: NodeId) -> Vec<(NodeId, NodeId)> {
+    let mut pool: HashMap<String, VecDeque<NodeId>> = HashMap::new();
+    for id in from.subtree(from_root).into_iter().skip(1) {
+        if let Some(p) = name_path(from, from_root, id) {
+            pool.entry(p).or_default().push_back(id);
+        }
+    }
+    let mut out = Vec::new();
+    for id in to.subtree(to_root).into_iter().skip(1) {
+        if let Some(p) = name_path(to, to_root, id)
+            && let Some(q) = pool.get_mut(&p)
+            && let Some(f) = q.pop_front()
+        {
+            out.push((f, id));
+        }
+    }
+    out
+}
+
+pub(super) fn lerp(a: f64, b: f64, t: f64) -> f64 {
+    a + (b - a) * t
+}
+
+/// Centre, rotation and scale of a node box `(w, h)` placed by `m`.
+fn decompose(m: Affine, (w, h): (f64, f64)) -> Option<[f64; 5]> {
+    let [a, b, c, d, _, _] = m.as_coeffs();
+    let sx = a.hypot(b);
+    if !sx.is_finite() || sx < 1e-9 {
+        return None;
+    }
+    let sy = (a * d - b * c) / sx;
+    let ctr = m * Point::new(w / 2.0, h / 2.0);
+    Some([ctr.x, ctr.y, b.atan2(a), sx, sy])
+}
+
+/// Interpolate two placements of a box: centre, rotation (shortest way round) and scale; the box
+/// size is `size` (already interpolated).
+pub fn lerp_transform(a: Affine, sa: (f64, f64), b: Affine, sb: (f64, f64), size: (f64, f64), t: f64) -> Affine {
+    match (decompose(a, sa), decompose(b, sb)) {
+        (Some(x), Some(y)) if (x[4] < 0.0) == (y[4] < 0.0) => {
+            let mut da = y[2] - x[2];
+            while da > std::f64::consts::PI {
+                da -= std::f64::consts::TAU;
+            }
+            while da < -std::f64::consts::PI {
+                da += std::f64::consts::TAU;
+            }
+            let (cx, cy) = (lerp(x[0], y[0], t), lerp(x[1], y[1], t));
+            let ang = x[2] + da * t;
+            let (sx, sy) = (lerp(x[3], y[3], t), lerp(x[4], y[4], t));
+            Affine::translate((cx, cy)) * Affine::rotate(ang) * Affine::scale_non_uniform(sx, sy) * Affine::translate((-size.0 / 2.0, -size.1 / 2.0))
+        }
+        _ => {
+            if t < 0.5 {
+                a
+            } else {
+                b
+            }
+        }
+    }
+}
+
+fn lerp_paints(from: &[Paint], to: &mut [Paint], t: f64) {
+    for (f, p) in from.iter().zip(to.iter_mut()) {
+        if let (PaintKind::Solid { color: fc }, PaintKind::Solid { color: tc }) = (&f.kind, &mut p.kind) {
+            *tc = fc.lerp(*tc, t.clamp(0.0, 1.0) as f32);
+            p.opacity = lerp(f64::from(f.opacity), f64::from(p.opacity), t.clamp(0.0, 1.0)) as f32;
+        }
+    }
+}
+
+/// The document as it looks at eased progress `t` of a smart-animate transition from
+/// `from_root` (in `from`) to `to_root` (in `to`): matched layers tween position, size, rotation,
+/// opacity, corner radius and solid fill colours; layers only in the destination fade in and
+/// layers only in the source are copied in and fade out. Render `to_root` of the result.
+pub fn smart_interpolate(from: &Document, from_root: NodeId, to: &Document, to_root: NodeId, t: f64) -> Document {
+    let mut out = to.clone();
+    // Springs and back easings go past 1 before they settle: matched layers overshoot too.
+    if !t.is_finite() || t == 1.0 {
+        return out;
+    }
+    let t = t.max(-1.0);
+    let fade = t.clamp(0.0, 1.0);
+    let pairs = match_layers(from, from_root, to, to_root);
+    let src_of: HashMap<NodeId, NodeId> = pairs.iter().map(|(f, d)| (*d, *f)).collect();
+    let dst_of: HashMap<NodeId, NodeId> = pairs.iter().copied().collect();
+    let fw_inv = from.world_transform(from_root).inverse();
+    let tw_inv = to.world_transform(to_root).inverse();
+    if let (Some(fr), Some(m)) = (from.node(from_root), out.node_mut(to_root)) {
+        lerp_paints(&fr.fills, &mut m.fills, t);
+    }
+    let mut interp: HashMap<NodeId, Affine> = HashMap::new();
+    interp.insert(to_root, Affine::IDENTITY);
+    let mut faded: HashSet<NodeId> = HashSet::new();
+    for id in to.subtree(to_root).into_iter().skip(1) {
+        let Some(n) = to.node(id) else { continue };
+        let parent = n.parent.unwrap_or(to_root);
+        let p_interp = interp.get(&parent).copied().unwrap_or(Affine::IDENTITY);
+        match src_of.get(&id).and_then(|s| from.node(*s).map(|sn| (*s, sn))) {
+            Some((s, sn)) => {
+                let rel_s = fw_inv * from.world_transform(s);
+                let rel_d = tw_inv * to.world_transform(id);
+                let (w, h) = (lerp(sn.width, n.width, t).max(0.0), lerp(sn.height, n.height, t).max(0.0));
+                let xf = lerp_transform(rel_s, (sn.width, sn.height), rel_d, (n.width, n.height), (w, h), t);
+                interp.insert(id, xf);
+                if let Some(m) = out.node_mut(id) {
+                    m.width = w;
+                    m.height = h;
+                    m.transform = p_interp.inverse() * xf;
+                    m.opacity = lerp(f64::from(sn.opacity), f64::from(n.opacity), fade) as f32;
+                    for (r, (a, b)) in m.corners.radii.iter_mut().zip(sn.corners.radii.iter().zip(n.corners.radii.iter())) {
+                        *r = lerp(*a, *b, t).max(0.0);
+                    }
+                    lerp_paints(&sn.fills, &mut m.fills, t);
+                    lerp_paints(&sn.strokes, &mut m.strokes, t);
+                }
+            }
+            None => {
+                interp.insert(id, p_interp * n.transform);
+                if !faded.contains(&parent)
+                    && let Some(m) = out.node_mut(id)
+                {
+                    m.opacity *= fade as f32;
+                }
+                faded.insert(id);
+            }
+        }
+    }
+    // Layers only in the source: copy the top-most ones in, fading out.
+    let tops: Vec<NodeId> = from
+        .subtree(from_root)
+        .into_iter()
+        .skip(1)
+        .filter(|id| !dst_of.contains_key(id))
+        .filter(|id| from.node(*id).and_then(|n| n.parent).is_some_and(|p| p == from_root || dst_of.contains_key(&p)))
+        .collect();
+    for id in tops {
+        let Some(n) = from.node(id) else { continue };
+        let pf = n.parent.unwrap_or(from_root);
+        let matched_parent = dst_of.get(&pf).copied().filter(|p| out.node(*p).is_some_and(|pn| pn.kind.is_container()));
+        let (parent, local) = match matched_parent {
+            Some(p) if pf != from_root => (p, n.transform),
+            _ => (to_root, fw_inv * from.world_transform(id)),
+        };
+        let nodes: Vec<Node> = from.subtree(id).into_iter().filter_map(|i| from.node(i).cloned()).collect();
+        let mut map = BTreeMap::new();
+        for nn in &nodes {
+            map.insert(nn.id, out.alloc_id());
+        }
+        let index = from.index_in_parent(id);
+        if let Ok(new) = out.paste_nodes(&nodes, &map, id, parent, index)
+            && let Some(m) = out.node_mut(new)
+        {
+            m.transform = local;
+            m.opacity *= (1.0 - fade) as f32;
+        }
+    }
+    out
+}
+
+/// Where the outgoing and incoming frames are drawn at eased progress `t`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct FramePlacement {
+    /// Offsets as fractions of each frame's size.
+    pub from_off: (f32, f32),
+    pub from_alpha: f32,
+    pub to_off: (f32, f32),
+    pub to_alpha: f32,
+    pub from_on_top: bool,
+}
+
+/// The unit vector a direction moves along (screen space, y down).
+pub fn direction_vec(d: Direction) -> (f32, f32) {
+    match d {
+        Direction::Left => (-1.0, 0.0),
+        Direction::Right => (1.0, 0.0),
+        Direction::Top => (0.0, -1.0),
+        Direction::Bottom => (0.0, 1.0),
+    }
+}
+
+/// Frame offsets/opacities for a transition. Directions name where things move: "Move in, left"
+/// brings the new frame in from the right edge moving left.
+pub fn transition_frames(tr: Transition, t: f32) -> FramePlacement {
+    let mul = |(x, y): (f32, f32), k: f32| (x * k, y * k);
+    let base = FramePlacement { from_off: (0.0, 0.0), from_alpha: 1.0, to_off: (0.0, 0.0), to_alpha: 1.0, from_on_top: false };
+    match tr {
+        Transition::Instant => FramePlacement { from_alpha: 0.0, ..base },
+        Transition::Dissolve | Transition::SmartAnimate => FramePlacement { to_alpha: t.clamp(0.0, 1.0), ..base },
+        Transition::MoveIn { direction } => FramePlacement { to_off: mul(direction_vec(direction), -(1.0 - t)), ..base },
+        Transition::MoveOut { direction } => FramePlacement { from_off: mul(direction_vec(direction), t), from_on_top: true, ..base },
+        Transition::Push { direction } => {
+            let d = direction_vec(direction);
+            FramePlacement { from_off: mul(d, t), to_off: mul(d, -(1.0 - t)), ..base }
+        }
+        Transition::SlideIn { direction } => {
+            let d = direction_vec(direction);
+            FramePlacement { from_off: mul(d, 0.3 * t), to_off: mul(d, -(1.0 - t)), ..base }
+        }
+        Transition::SlideOut { direction } => {
+            let d = direction_vec(direction);
+            FramePlacement { from_off: mul(d, t), to_off: mul(d, -0.3 * (1.0 - t)), from_on_top: true, ..base }
+        }
+    }
+}
+
+/// Screen rect of an overlay of `size` over the frame drawn at `base`. A manual one sits `offset`
+/// (screen points) from the top-left of `anchor`, the layer that opened it; without an offset,
+/// right below it.
+pub fn overlay_rect(pos: OverlayPosition, base: Rect, size: Vec2, anchor: Option<Rect>, offset: Option<Vec2>) -> Rect {
+    let cx = base.center().x - size.x / 2.0;
+    let cy = base.center().y - size.y / 2.0;
+    let (x, y) = match pos {
+        OverlayPosition::Center => (cx, cy),
+        OverlayPosition::TopLeft => (base.min.x, base.min.y),
+        OverlayPosition::TopCenter => (cx, base.min.y),
+        OverlayPosition::TopRight => (base.max.x - size.x, base.min.y),
+        OverlayPosition::BottomLeft => (base.min.x, base.max.y - size.y),
+        OverlayPosition::BottomCenter => (cx, base.max.y - size.y),
+        OverlayPosition::BottomRight => (base.max.x - size.x, base.max.y - size.y),
+        OverlayPosition::Manual => match (anchor, offset) {
+            (Some(a), Some(o)) => (a.min.x + o.x, a.min.y + o.y),
+            (Some(a), None) => (a.min.x, a.max.y),
+            (None, _) => (cx, cy),
+        },
+    };
+    Rect::from_min_size(pos2(x, y), size)
+}

From 99edc6c8156b077ba96c1fc17bd5f2a04a2e47a1 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:56:10 +0000
Subject: [PATCH 42/67] refactor(ui-egui): split panels/right.rs into right/

---
 crates/ui-egui/src/panels/right.rs         | 1815 +-------------------
 crates/ui-egui/src/panels/right/effects.rs |  541 ++++++
 crates/ui-egui/src/panels/right/inspect.rs |  269 +++
 crates/ui-egui/src/panels/right/menu.rs    |  135 ++
 crates/ui-egui/src/panels/right/paints.rs  |  553 ++++++
 crates/ui-egui/src/panels/right/stroke.rs  |  313 ++++
 6 files changed, 1828 insertions(+), 1798 deletions(-)
 create mode 100644 crates/ui-egui/src/panels/right/effects.rs
 create mode 100644 crates/ui-egui/src/panels/right/inspect.rs
 create mode 100644 crates/ui-egui/src/panels/right/menu.rs
 create mode 100644 crates/ui-egui/src/panels/right/paints.rs
 create mode 100644 crates/ui-egui/src/panels/right/stroke.rs

diff --git a/crates/ui-egui/src/panels/right.rs b/crates/ui-egui/src/panels/right.rs
index cbdf6f84..f00a5821 100644
--- a/crates/ui-egui/src/panels/right.rs
+++ b/crates/ui-egui/src/panels/right.rs
@@ -15,6 +15,23 @@ use crate::theme::{Tokens, regular, semibold};
 use crate::widgets::{self, Edit, FIELD_H, FieldEdit, Lead, PAD};
 use crate::{FigApp, RightTab};
 
+mod effects;
+mod inspect;
+mod menu;
+mod paints;
+mod stroke;
+
+pub(crate) use effects::effect_open;
+use effects::{effects, grids};
+use inspect::inspect;
+pub(crate) use inspect::{inspect_section, prop_row};
+#[cfg(test)]
+pub(crate) use menu::menu_row_width;
+pub use menu::{blend_menu, context_popup, menu_check, menu_item, menu_item_beside_checks, menu_item_with, menu_popup, menu_row};
+pub(crate) use menu::{block, menu_style, row, row_rect};
+use paints::{appearance, paints, variable_modes};
+pub(crate) use stroke::{CAP_ART_W, cap_art, join_label};
+
 /// Common value of `f` across `ids` (None when mixed or empty).
 pub(crate) fn common<T: PartialEq + Clone>(doc: &Document, ids: &[NodeId], f: impl Fn(&Node) -> T) -> Option<T> {
     let mut it = ids.iter().filter_map(|i| doc.node(*i));
@@ -214,138 +231,6 @@ pub fn right_panel(app: &mut FigApp, ui: &mut Ui) {
     });
 }
 
-/// The smallest width a popup menu is measured in (see [`menu_popup`]).
-const MENU_MIN_W: f32 = 48.0;
-/// A menu row's inset either side, and the gap between its label and its shortcut or art.
-const MENU_PAD: f32 = 8.0;
-const MENU_GAP: f32 = 24.0;
-
-/// The style of popup menus: egui's, with text kept on one line (a menu grows to its widest item).
-pub(crate) fn menu_style(s: &mut egui::Style) {
-    egui::containers::menu::menu_style(s);
-    s.wrap_mode = Some(egui::TextWrapMode::Extend);
-}
-
-/// The menu a dropdown or button opens: as wide as its widest row and at least as wide as
-/// `anchor`. egui measures a popup in a first, invisible pass as wide as the width it is given
-/// (else its 600 px default area width) and keeps the size measured; rows ([`menu_row`]) take the
-/// larger of that width and their content, so the menu fits its content. Chain `.width(w)` for a
-/// menu at least `w` wide.
-/// The blend modes as menu items in groups (pass-through only for layers); the one picked.
-pub fn blend_menu(ui: &mut Ui, with_pass_through: bool) -> Option<BlendMode> {
-    let mut picked = None;
-    for b in BlendMode::ALL.into_iter().filter(|b| with_pass_through || *b != BlendMode::PassThrough) {
-        if menu_item(ui, tr(b.label()), "") {
-            picked = Some(b);
-            ui.close();
-        }
-        if matches!(b, BlendMode::Normal | BlendMode::ColorBurn | BlendMode::ColorDodge | BlendMode::HardLight | BlendMode::Exclusion) {
-            ui.separator();
-        }
-    }
-    picked
-}
-
-pub fn menu_popup(anchor: &egui::Response) -> egui::Popup<'static> {
-    egui::Popup::menu(anchor).width(anchor.rect.width().max(MENU_MIN_W)).style(menu_style)
-}
-
-/// A context menu (secondary click on `resp`) sized like [`menu_popup`].
-pub fn context_popup(resp: &egui::Response) -> egui::Popup<'static> {
-    egui::Popup::context_menu(resp).width(MENU_MIN_W).style(menu_style)
-}
-
-/// A context menu for a property row: a secondary click anywhere over `rect` opens it, even over
-/// the row's fields (which would otherwise take the click), like the incumbent's row menus.
-fn row_context_menu(ui: &Ui, rect: Rect, id: Id) -> egui::Popup<'static> {
-    let resp = ui.interact(rect, id, Sense::hover());
-    let open = ui.rect_contains_pointer(rect) && ui.input(|i| i.pointer.secondary_clicked());
-    let at_pointer = egui::Popup::menu(&resp).width(MENU_MIN_W).style(menu_style).at_pointer_fixed();
-    at_pointer.open_memory(open.then_some(egui::SetOpenCommand::Bool(true)))
-}
-
-pub fn menu_item(ui: &mut Ui, label: &str, shortcut: &str) -> bool {
-    menu_row(ui, label, shortcut, 0.0, |_, _, _| {}).clicked()
-}
-
-/// A menu row with art drawn into it after the label (`art(painter, row rect, text colour)`),
-/// taking `art_w` from the row's right edge.
-pub fn menu_item_with(ui: &mut Ui, label: &str, shortcut: &str, art_w: f32, art: impl FnOnce(&egui::Painter, Rect, Color32)) -> bool {
-    menu_row(ui, label, shortcut, art_w, art).clicked()
-}
-
-/// The width a menu row needs for a label `label_w` wide and, at its right end, a shortcut or
-/// art `trail` wide (0 for neither).
-pub(crate) fn menu_row_width(label_w: f32, trail: f32) -> f32 {
-    MENU_PAD + label_w + if trail > 0.0 { MENU_GAP + trail } else { MENU_PAD }
-}
-
-/// A menu row (see [`menu_item_with`]); its response tells hovering too. It spans the menu and
-/// is at least as wide as its label, shortcut and art.
-pub fn menu_row(ui: &mut Ui, label: &str, shortcut: &str, art_w: f32, art: impl FnOnce(&egui::Painter, Rect, Color32)) -> egui::Response {
-    let t = Tokens::get(ui.ctx());
-    let text = ui.painter().layout_no_wrap(label.to_owned(), regular(11.5), Color32::PLACEHOLDER);
-    let keys =
-        (!shortcut.is_empty()).then(|| ui.painter().layout_no_wrap(crate::toolbar::pretty_shortcut(shortcut), regular(11.0), Color32::PLACEHOLDER));
-    let trail = keys.as_ref().map_or(0.0, |k| k.size().x + MENU_PAD).max(art_w);
-    let w = ui.available_width().max(menu_row_width(text.size().x, trail).ceil());
-    let (r, resp) = ui.allocate_exact_size(vec2(w, 26.0), Sense::click());
-    a11y::menu_item(&resp, label, shortcut, None);
-    // The keyboard's item is highlighted like the hovered one.
-    a11y::own_focus(&resp);
-    let hovered = resp.hovered() || resp.has_focus();
-    if hovered {
-        ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
-    }
-    // These menus sit on the theme's popup fill (white in the light theme), not on the dark
-    // `t.menu` of the menu bar: the theme's text, white only on the green highlight (#972).
-    let col = if hovered { t.menu_text } else { t.text };
-    ui.painter().galley(pos2(r.min.x + MENU_PAD, r.center().y - text.size().y / 2.0), text, col);
-    if let Some(k) = keys {
-        let at = pos2(r.max.x - MENU_PAD - k.size().x, r.center().y - k.size().y / 2.0);
-        ui.painter().galley(at, k, if hovered { t.menu_text } else { t.text_secondary });
-    }
-    art(ui.painter(), r, col);
-    resp
-}
-
-/// A menu item with a check mark when `on` (the unchecked ones line up with it).
-pub fn menu_check(ui: &mut Ui, on: bool, label: &str, shortcut: &str) -> bool {
-    marked_row(ui, Some(on), label, shortcut)
-}
-
-/// A plain menu item lined up with the check items above or below it.
-pub fn menu_item_beside_checks(ui: &mut Ui, label: &str, shortcut: &str) -> bool {
-    marked_row(ui, None, label, shortcut)
-}
-
-fn marked_row(ui: &mut Ui, on: Option<bool>, label: &str, shortcut: &str) -> bool {
-    let resp = menu_row(ui, &format!("{}{label}", if on == Some(true) { "✓ " } else { "    " }), shortcut, 0.0, |_, _, _| {});
-    a11y::menu_item(&resp, label, shortcut, on);
-    resp.clicked()
-}
-
-pub(crate) fn row(ui: &mut Ui, h: f32, add: impl FnOnce(&mut Ui)) {
-    row_rect(ui, h, add);
-}
-
-/// [`row`], returning the area the row takes.
-pub(crate) fn row_rect(ui: &mut Ui, h: f32, add: impl FnOnce(&mut Ui)) -> Rect {
-    block(ui, h, (h - FIELD_H) / 2.0, add)
-}
-
-/// A panel row `h` tall whose content is inset `inset_y` from its top and bottom (for content
-/// taller than one field); returns the area the row takes.
-pub(crate) fn block(ui: &mut Ui, h: f32, inset_y: f32, add: impl FnOnce(&mut Ui)) -> Rect {
-    let w = ui.available_width();
-    let (r, _) = ui.allocate_exact_size(vec2(w, h), Sense::hover());
-    let mut child =
-        ui.new_child(egui::UiBuilder::new().max_rect(r.shrink2(vec2(PAD, inset_y))).layout(egui::Layout::left_to_right(egui::Align::Center)));
-    child.spacing_mut().item_spacing = vec2(8.0, 0.0);
-    add(&mut child);
-    r
-}
-
 fn design(app: &mut FigApp, ui: &mut Ui) {
     let Ok(ds) = app.session.ds() else { return };
     // The panel shows the document itself, not a live text preview over it.
@@ -823,1669 +708,3 @@ fn pretty(s: &str) -> String {
         other => other.to_string(),
     }
 }
-
-/// Draw visibility/blend/mask, opacity, uniform or per-corner radius, corner smoothing and
-/// the blend-mode row.
-fn appearance(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
-    let ids = sel.to_vec();
-    let visible = common(doc, sel, |n| n.visible).unwrap_or(true);
-    let hdr = widgets::section_header(
-        ui,
-        tr("Appearance"),
-        &[
-            (if visible { Icon::Eye } else { Icon::EyeOff }, crate::shortcuts::tip(tr("Show/Hide"), "object.toggleVisible")),
-            (Icon::Variable, tr("Apply variable to visibility")),
-            (Icon::Blend, tr("Blend mode")),
-        ],
-        false,
-    );
-    if hdr == Some(0) {
-        app.run("object.toggleVisible", json!({"ids": ids}));
-    }
-    if hdr == Some(1) {
-        crate::variable_ui::open_at_pointer(ui, &ids, "visible", VariableType::Boolean);
-    }
-    if hdr == Some(2) {
-        ui.data_mut(|d| d.insert_temp(Id::unique("blend_open"), !d.get_temp::<bool>(Id::unique("blend_open")).unwrap_or(false)));
-    }
-    let col = widgets::col_width(ui.available_width());
-    crate::variable_ui::bound_row(app, ui, &ids, "visible", VariableType::Boolean, Lead::Icon(Icon::Eye, tr("Visible")), col * 2.0 + 8.0);
-    // Masks: how they mask.
-    if sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.is_mask)) {
-        let mt = common(doc, sel, |n| n.mask_type);
-        widgets::sublabels(ui, tr("Mask"), None);
-        row(ui, 32.0, |ui| {
-            let resp = widgets::dropdown(ui, mt.map(|m| tr(m.label())).unwrap_or(tr("Mixed")), col * 2.0 + 8.0, Some(Icon::Mask));
-            menu_popup(&resp).show(|ui| {
-                for m in MaskType::ALL {
-                    if menu_item(ui, tr(m.label()), "") {
-                        app.set_props(&ids, json!({"maskType": m.id()}));
-                        ui.close();
-                    }
-                }
-            });
-        });
-    }
-    let op_of = |n: &Node| (f64::from(n.opacity) * 100.0).round();
-    let op = common(doc, sel, op_of);
-    let radius_ok = sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.has_corner_radius()));
-    // Only rectangles and frames round each corner on its own.
-    let indep_ok = radius_ok && sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.has_independent_corners()));
-    // For polygons and stars the same panel holds only the Corner smoothing row.
-    let smooth_ok = radius_ok && sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.has_corner_smoothing()));
-    let r = common(doc, sel, |n| n.corners.uniform().map(|r| (r * 100.0).round() / 100.0));
-    widgets::sublabels(ui, tr("Opacity"), radius_ok.then_some(tr("Corner radius")));
-    row(ui, 32.0, |ui| {
-        let lead = Lead::Icon(Icon::Opacity, tr("Opacity"));
-        let e = crate::variable_ui::number_field_mixed(app, ui, &ids, "opacity", Id::unique("ap_op"), lead, op, "%", col);
-        app.field_of(&ids, "opacity", e, op_of, |v| json!((v / 100.0).clamp(0.0, 1.0)));
-        if radius_ok {
-            let e = crate::variable_ui::number_field_mixed(
-                app,
-                ui,
-                &ids,
-                "cornerRadius",
-                Id::unique("ap_rad"),
-                Lead::Icon(Icon::CornerRadius, tr("Corner radius")),
-                r.flatten(),
-                "",
-                col,
-            );
-            // A layer with corners of its own starts from its largest.
-            let radius_of = |n: &Node| n.corners.uniform().unwrap_or_else(|| n.corners.radii.iter().copied().fold(0.0, f64::max));
-            app.field_of(&ids, "cornerRadius", e, radius_of, |v| json!(v.max(0.0)));
-            let open = ui.data(|d| d.get_temp::<bool>(Id::unique("indep_corners"))).unwrap_or(false);
-            // Polygons and stars have no corners of their own: the button opens only Corner smoothing.
-            let tip = if indep_ok { tr("Individual corners") } else { tr("Corner smoothing") };
-            if smooth_ok && icons::button(ui, Icon::IndependentCorners, 24.0, open, tip).clicked() {
-                ui.data_mut(|d| d.insert_temp(Id::unique("indep_corners"), !open));
-            }
-        }
-    });
-    if smooth_ok && ui.data(|d| d.get_temp::<bool>(Id::unique("indep_corners"))).unwrap_or(false) {
-        let radii = common(doc, sel, |n| n.corners.radii);
-        // `k` indexes `radii` ([top left, top right, bottom right, bottom left]); the fields sit
-        // where their corners are: top left, top right / bottom left, bottom right.
-        let corners = [
-            ("topLeftRadius", tr("Top left radius"), Icon::CornerTopLeft, 0),
-            ("topRightRadius", tr("Top right radius"), Icon::CornerTopRight, 1),
-            ("bottomLeftRadius", tr("Bottom left radius"), Icon::CornerBottomLeft, 3),
-            ("bottomRightRadius", tr("Bottom right radius"), Icon::CornerBottomRight, 2),
-        ];
-        // Polygons and stars have one radius, so no field per corner.
-        for pair in corners.chunks(2).filter(|_| indep_ok) {
-            row(ui, 32.0, |ui| {
-                for (key, name, icon, k) in pair {
-                    let e = crate::variable_ui::number_field(
-                        app,
-                        ui,
-                        &ids,
-                        key,
-                        Id::unique(("corner", *k)),
-                        Lead::Icon(*icon, name),
-                        radii.map(|r| r[*k]),
-                        "",
-                        col,
-                    );
-                    app.field(&ids, key, e, |v| json!(v.max(0.0)));
-                }
-            });
-        }
-        let sm = common(doc, sel, |n| (n.corners.smoothing * 100.0).round());
-        widgets::sublabels(ui, tr("Corner smoothing"), None);
-        row(ui, 32.0, |ui| {
-            let e = widgets::number_field(ui, Id::unique("smoothing"), Lead::None, sm, "%", col, 1.0);
-            app.field(&ids, "cornerSmoothing", e, |v| json!((v / 100.0).clamp(0.0, 1.0)));
-            if widgets::button(ui, tr("iOS"), false, true).on_hover_text(tr("Set corner smoothing to 60%")).clicked() {
-                app.set_props(&ids, json!({"cornerSmoothing": 0.6}));
-            }
-        });
-    }
-    let blend = common(doc, sel, |n| n.blend);
-    let show_blend = ui.data(|d| d.get_temp::<bool>(Id::unique("blend_open"))).unwrap_or(false)
-        || blend.is_some_and(|b| !matches!(b, BlendMode::Normal | BlendMode::PassThrough));
-    if show_blend {
-        widgets::sublabels(ui, tr("Blend mode"), None);
-        row(ui, 32.0, |ui| {
-            let label = blend.map(|b| tr(b.label())).unwrap_or(tr("Mixed"));
-            let resp = widgets::dropdown(ui, label, col * 2.0 + 8.0, Some(Icon::Blend));
-            menu_popup(&resp).width(200.0).show(|ui| {
-                if let Some(b) = blend_menu(ui, true) {
-                    app.set_props(&ids, json!({"blend": b.label()}));
-                }
-            });
-        });
-    }
-    ui.add_space(8.0);
-}
-
-/// The variable modes of the selected frames (sections, components, instances): a row per
-/// collection with more than one mode, Auto (the mode the layer inherits from its parent) or a mode
-/// of its own (`variable.setMode`). Collections from enabled libraries follow under their
-/// library's name (`library.setVariableMode` copies the collection in). Returns whether it showed.
-fn variable_modes(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) -> bool {
-    if !sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.is_frame_like())) {
-        return false;
-    }
-    let libs = crate::variable_ui::libraries(app, doc);
-    let rows = crate::variable_ui::mode_rows(doc, &libs);
-    if rows.is_empty() {
-        return false;
-    }
-    let t = Tokens::get(ui.ctx());
-    widgets::section_header(ui, tr("Variable modes"), &[], false);
-    // The collection's name, then a wider mode picker ("Auto (Light)") across both field columns.
-    let col = widgets::col_width(ui.available_width());
-    let (name_w, pick_w) = ((col * 0.7).round(), (col * 1.3).round());
-    // Auto resolves as for the first selected layer: from its parent, or an instance's main.
-    let parent_modes = sel.first().map(|i| doc.inherited_modes(*i)).unwrap_or_default();
-    let mut group = None;
-    for r in &rows {
-        let c = r.coll;
-        // Library collections under their library's name.
-        if r.library != group {
-            group = r.library;
-            if let Some((_, lib)) = r.library {
-                widgets::sublabels(ui, lib, None);
-            }
-        }
-        let name_of = |m: &str| c.modes.iter().find(|x| x.id == m).map_or("", |x| x.name.as_str());
-        // Each layer's own mode (None: Auto); None overall when they differ.
-        let own = match r.local {
-            Some(l) => common(doc, sel, |n| n.var_modes.get(l).cloned()),
-            None => Some(None),
-        };
-        let inherited = r.local.and_then(|l| parent_modes.get(l)).or(c.default_mode()).map_or("", |m| name_of(m));
-        let auto = trf("Auto ({mode})", &[("mode", &inherited)]);
-        let label = match &own {
-            Some(Some(m)) => name_of(m).to_string(),
-            Some(None) => auto.clone(),
-            None => tr("Mixed").into(),
-        };
-        let hover = match r.library {
-            Some((_, lib)) => trf("{name} (from {library})", &[("name", &c.name), ("library", &lib)]),
-            None => c.name.clone(),
-        };
-        row(ui, 32.0, |ui| {
-            let (rect, _) = ui.allocate_exact_size(vec2(name_w, FIELD_H), Sense::hover());
-            let name = widgets::elide(ui, &c.name, name_w);
-            ui.painter().text(pos2(rect.min.x, rect.center().y), Align2::LEFT_CENTER, &name, regular(11.0), t.text);
-            if name != c.name || r.library.is_some() {
-                ui.interact(rect, Id::unique(("var_mode_name", &c.id)), Sense::hover()).on_hover_text(&hover);
-            }
-            let resp = widgets::dropdown(ui, &label, pick_w, None);
-            menu_popup(&resp).width(180.0).show(|ui| {
-                let mut pick = None;
-                if menu_check(ui, own == Some(None), &auto, "") {
-                    pick = Some(Value::Null);
-                }
-                ui.separator();
-                for m in &c.modes {
-                    if menu_check(ui, own.as_ref().is_some_and(|o| o.as_ref() == Some(&m.id)), &m.name, "") {
-                        pick = Some(json!(m.id));
-                    }
-                }
-                if let Some(mode) = pick {
-                    set_variable_mode(app, sel, r, mode);
-                    ui.close();
-                }
-            });
-        });
-    }
-    ui.add_space(8.0);
-    true
-}
-
-/// Set `sel`'s mode of the collection of `row` (`mode` null: Auto). A library collection goes
-/// through `library.setVariableMode` (copying it in); Auto on one never used here is already so.
-fn set_variable_mode(app: &mut FigApp, sel: &[NodeId], row: &crate::variable_ui::ModeRow, mode: Value) {
-    match (row.library, row.key, row.local) {
-        (Some((lib, _)), Some(key), _) if !mode.is_null() => {
-            app.run("library.setVariableMode", json!({"library": lib, "collection": key, "ids": sel, "mode": mode}));
-        }
-        (_, _, Some(local)) => {
-            app.run("variable.setMode", json!({"ids": sel, "collection": local, "mode": mode}));
-        }
-        _ => {}
-    }
-}
-
-/// While a range of text is selected, the Fill section edits that range's colour.
-fn range_fill(app: &mut FigApp, ui: &mut Ui, doc: &Document, id: NodeId, start: usize, end: usize) {
-    let t = Tokens::get(ui.ctx());
-    widgets::section_header(ui, tr("Fill"), &[], false);
-    // The fills over the range, if every character shares them.
-    let fills: Option<Vec<Paint>> = doc.node(id).and_then(|n| n.kind.text().map(|tx| (n, tx))).and_then(|(n, tx)| {
-        let mut it =
-            tx.spans().into_iter().filter(|(s, e, _)| *s < end && *e > start).map(|(_, _, st)| st.fills.clone().unwrap_or_else(|| n.fills.clone()));
-        let first = it.next()?;
-        it.all(|f| f == first).then_some(first)
-    });
-    row(ui, 32.0, |ui| {
-        let w = ui.available_width() - 28.0;
-        let (r, _) = ui.allocate_exact_size(vec2(w, FIELD_H), Sense::hover());
-        ui.painter().rect_filled(r, CornerRadius::same(5), t.field);
-        let sw = Rect::from_min_size(pos2(r.min.x + 4.0, r.center().y - 8.0), vec2(16.0, 16.0));
-        let text_r = Rect::from_min_max(pos2(sw.max.x + 8.0, r.min.y), pos2(r.max.x - 4.0, r.max.y));
-        match fills.as_ref().and_then(|f| f.first()) {
-            Some(p) => {
-                widgets::paint_swatch(ui.painter(), sw, p);
-                if ui.interact(sw.expand(2.0), Id::unique("range_swatch"), Sense::click()).clicked() {
-                    app.ui.picker = Some(crate::colorpicker::PickerTarget::TextRange { id, start, end });
-                }
-                if let Some(c) = p.solid_color() {
-                    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(text_r));
-                    if let Some(h) =
-                        widgets::text_field_inline(&mut child, Id::unique("range_hex"), &c.to_hex(), text_r.shrink2(vec2(0.0, 4.0)), regular(11.0))
-                        && let Some(nc) = figcraft_color::Color::from_hex_or_name(&h)
-                    {
-                        app.run("text.style", json!({"id": id, "start": start, "end": end, "textFills": [nc.to_css_hex()]}));
-                    }
-                } else {
-                    ui.painter().text(pos2(text_r.min.x, r.center().y), Align2::LEFT_CENTER, tr("Gradient"), regular(11.0), t.text);
-                }
-            }
-            None => {
-                ui.painter().text(pos2(text_r.min.x, r.center().y), Align2::LEFT_CENTER, tr("Mixed"), regular(11.0), t.text_secondary);
-                if ui.interact(r, Id::unique("range_mixed"), Sense::click()).clicked() {
-                    app.ui.picker = Some(crate::colorpicker::PickerTarget::TextRange { id, start, end });
-                }
-            }
-        }
-        // Back to the layer's fill.
-        if icons::button(ui, Icon::Detach, 24.0, false, tr("Use the layer's fill")).clicked() {
-            app.run("text.style", json!({"id": id, "start": start, "end": end, "textFills": null}));
-        }
-    });
-}
-
-/// Draw a selected-text range fill, or the fill/stroke paint rows with add, style, reorder,
-/// stroke align/weight, per-side weights and advanced stroke settings.
-fn paints(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId], fills: bool) {
-    if fills
-        && let Some((id, a, b)) = figcraft_engine::textedit::selected_range(&app.session)
-        && a < b
-        && sel.contains(&id)
-    {
-        range_fill(app, ui, doc, id, a, b);
-        return;
-    }
-    let t = Tokens::get(ui.ctx());
-    let ids = sel.to_vec();
-    let list = common(doc, sel, |n| if fills { n.fills.clone() } else { n.strokes.clone() });
-    let title = if fills { tr("Fill") } else { tr("Stroke") };
-    let empty = list.as_ref().is_none_or(|l| l.is_empty());
-    let slot = if fills { StyleSlot::Fill } else { StyleSlot::Stroke };
-    // The section's right-click menu adds the copied paint (`fill.paste` / `stroke.paste`).
-    let paste = if fills { tr("Paste fill") } else { tr("Paste stroke") };
-    let (clicked, header) = widgets::section_header_resp(
-        ui,
-        title,
-        &[(Icon::Styles, tr("Styles")), (Icon::Plus, if fills { tr("Add fill") } else { tr("Add stroke") })],
-        empty,
-    );
-    if let Some(i) = clicked {
-        if i == 1 {
-            // The new paint goes on top; open its picker. A mixed selection has no one index to edit.
-            if app.run(if fills { "fill.add" } else { "stroke.add" }, json!({"ids": ids})).is_some()
-                && let Some(l) = &list
-            {
-                app.ui.picker = Some(crate::colorpicker::PickerTarget::Paint { fills, index: l.len(), ids: ids.clone() });
-            }
-        } else {
-            style_picker::open(app, ui, &ids, slot);
-        }
-    }
-    context_popup(&header).show(|ui| {
-        if app.session.clipboard.paint.as_ref().is_some_and(|(f, _)| *f == fills) && menu_item(ui, paste, "") {
-            app.run(if fills { "fill.paste" } else { "stroke.paste" }, json!({"ids": ids}));
-            ui.close();
-        }
-    });
-    style_picker::chip(app, ui, doc, &ids, slot);
-    match &list {
-        None => widgets::note(ui, tr("Click + to replace mixed content"), t.text_secondary),
-        Some(l) => {
-            // The last paint is on top: shown first. Rows drag to reorder.
-            let mut drag = ListDrag::new(ui, if fills { "fills" } else { "strokes" });
-            for (i, p) in l.iter().enumerate().rev() {
-                let r = paint_row(app, ui, &ids, i, p, fills);
-                drag.row(ui, i, r, r, || paint_label(p));
-            }
-            if let Some((from, to)) = drag.finish(ui) {
-                app.run(if fills { "fill.move" } else { "stroke.move" }, json!({"ids": ids, "from": from, "to": to}));
-                // An open colour picker keeps editing the paint it was on.
-                if let Some(crate::colorpicker::PickerTarget::Paint { fills: f, index, .. }) = &mut app.ui.picker
-                    && *f == fills
-                {
-                    *index = moved_index(*index, from, to);
-                }
-            }
-        }
-    }
-    if !fills && !empty {
-        let weight = common(doc, sel, |n| n.stroke.weight);
-        let align = common(doc, sel, |n| n.stroke.align);
-        let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
-        row(ui, 32.0, |ui| {
-            let resp = widgets::dropdown(
-                ui,
-                match align {
-                    Some(StrokeAlign::Inside) => tr("Inside"),
-                    Some(StrokeAlign::Center) => tr("Center"),
-                    Some(StrokeAlign::Outside) => tr("Outside"),
-                    None => tr("Mixed"),
-                },
-                half,
-                None,
-            );
-            menu_popup(&resp).show(|ui| {
-                for (l, v) in [(tr("Inside"), "inside"), (tr("Center"), "center"), (tr("Outside"), "outside")] {
-                    if menu_item(ui, l, "") {
-                        app.set_props(&ids, json!({"strokeAlign": v}));
-                        ui.close();
-                    }
-                }
-            });
-            let sided = sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.is_frame_like() || matches!(n.kind, NodeKind::Rectangle)));
-            let weight_w = half - if sided { 60.0 } else { 32.0 };
-            let e = crate::variable_ui::number_field_mixed(
-                app,
-                ui,
-                &ids,
-                "strokeWeight",
-                Id::unique("stroke_w"),
-                Lead::Icon(Icon::Menu, tr("Stroke weight")),
-                weight,
-                "",
-                weight_w,
-            );
-            app.field_of(&ids, "strokeWeight", e, |n| n.stroke.weight, |v| json!(v.max(0.0)));
-            if sided {
-                let sides_btn = icons::button(ui, Icon::IndependentCorners, 24.0, false, tr("Individual strokes"));
-                menu_popup(&sides_btn).show(|ui| {
-                    let w = weight.unwrap_or(1.0);
-                    for (l, v) in [
-                        (tr("All"), Value::Null),
-                        (tr("Top"), json!([w, 0.0, 0.0, 0.0])),
-                        (tr("Right"), json!([0.0, w, 0.0, 0.0])),
-                        (tr("Bottom"), json!([0.0, 0.0, w, 0.0])),
-                        (tr("Left"), json!([0.0, 0.0, 0.0, w])),
-                        (tr("Custom"), json!([w, w, w, w])),
-                    ] {
-                        if menu_item(ui, l, "") {
-                            app.set_props(&ids, json!({"strokeSides": v}));
-                            ui.close();
-                        }
-                    }
-                });
-            }
-            let adv_id = Id::unique("stroke_adv");
-            let open = ui.data(|d| d.get_temp::<bool>(adv_id)).unwrap_or(false);
-            if icons::button(ui, Icon::Dots, 24.0, open, tr("Advanced stroke")).clicked() {
-                ui.data_mut(|d| d.insert_temp(adv_id, !open));
-            }
-        });
-        // Per-side weights, two to a row (like the corner radii) so a bound variable's name fits:
-        // each side binds to a number variable on its own.
-        if let Some(sides) = common(doc, sel, |n| n.stroke.sides).flatten() {
-            let col = widgets::col_width(ui.available_width());
-            let fields = ["T", "R", "B", "L"].into_iter().zip(figcraft_engine::cmd::props::STROKE_SIDES);
-            for first in [0, 2] {
-                row(ui, 32.0, |ui| {
-                    for (k, (label, field)) in fields.clone().enumerate().skip(first).take(2) {
-                        let v = sides.get(k).copied();
-                        let e = crate::variable_ui::number_field(app, ui, &ids, field, Id::unique(("stroke_side", k)), Lead::Text(label), v, "", col);
-                        app.field(&ids, field, e, |x| json!(x.max(0.0)));
-                    }
-                });
-            }
-        }
-        if ui.data(|d| d.get_temp::<bool>(Id::unique("stroke_adv"))).unwrap_or(false) {
-            stroke_settings(app, ui, doc, sel);
-        }
-    }
-}
-
-/// A width profile drawn as a filled band across `rect` (thickest point = full height); `None`
-/// draws a uniform stroke.
-pub(crate) fn profile_art(painter: &egui::Painter, rect: Rect, profile: Option<&WidthProfile>, col: Color32) {
-    const STEPS: u32 = 40;
-    let max = profile.map_or(1.0, WidthProfile::max_scale).max(1e-6);
-    let (cy, half) = (rect.center().y, rect.height() / 2.0);
-    let mut mesh = egui::Mesh::default();
-    let (mut top, mut bottom) = (Vec::new(), Vec::new());
-    for i in 0..=STEPS {
-        let t = f64::from(i) / f64::from(STEPS);
-        // The path runs left to right: its left side is drawn on top.
-        let (l, r) = profile.map_or((0.5, 0.5), |p| {
-            let (l, r) = p.sides_at(t);
-            (l / max, r / max)
-        });
-        let x = rect.min.x + rect.width() * t as f32;
-        let (hl, hr) = (((l as f32) * half).max(0.5), ((r as f32) * half).max(0.5));
-        top.push(pos2(x, cy - hl));
-        bottom.push(pos2(x, cy + hr));
-        mesh.colored_vertex(pos2(x, cy - hl), col);
-        mesh.colored_vertex(pos2(x, cy + hr), col);
-    }
-    for i in 0..STEPS {
-        let k = 2 * i;
-        mesh.add_triangle(k, k + 1, k + 2);
-        mesh.add_triangle(k + 1, k + 3, k + 2);
-    }
-    painter.add(egui::Shape::mesh(mesh));
-    // The mesh isn't anti-aliased: smooth its edges with hairlines.
-    for edge in [top, bottom] {
-        painter.add(egui::Shape::line(edge, Stroke::new(0.75, col)));
-    }
-}
-
-/// Stroke settings ▸ Width profile: the presets (each with its shape) and a flip.
-fn width_profile_row(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], profile: Option<Option<WidthProfile>>, half: f32) {
-    let t = Tokens::get(ui.ctx());
-    widgets::sublabels(ui, tr("Width profile"), None);
-    row(ui, 32.0, |ui| {
-        let label = match &profile {
-            None => tr("Mixed"),
-            Some(None) => tr(WidthPreset::Uniform.label()),
-            Some(Some(p)) => p.preset().map_or(tr("Custom"), |w| tr(w.label())),
-        };
-        let resp = widgets::dropdown(ui, label, half * 2.0 + 8.0 - 32.0, None);
-        if let Some(p) = &profile {
-            let r = resp.rect;
-            let art = Rect::from_min_max(pos2(r.max.x - 22.0 - 56.0, r.center().y - 5.0), pos2(r.max.x - 22.0, r.center().y + 5.0));
-            profile_art(ui.painter(), art, p.as_ref(), t.icon_secondary);
-        }
-        menu_popup(&resp).show(|ui| {
-            for preset in WidthPreset::ALL {
-                let prof = preset.profile();
-                let art = |pt: &egui::Painter, r: Rect, col: Color32| {
-                    let a = Rect::from_min_max(pos2(r.max.x - 8.0 - 64.0, r.center().y - 5.0), pos2(r.max.x - 8.0, r.center().y + 5.0));
-                    profile_art(pt, a, prof.as_ref(), col);
-                };
-                if menu_item_with(ui, tr(preset.label()), "", 8.0 + 64.0, art) {
-                    app.run("stroke.widthProfile", json!({"ids": ids, "preset": preset.id()}));
-                    ui.close();
-                }
-            }
-        });
-        // Flip: the profile runs from the other end of the path.
-        let custom = profile.clone().flatten();
-        let flip = icons::button(ui, Icon::FlipH, 24.0, false, tr("Flip width profile"));
-        if flip.clicked()
-            && let Some(p) = custom
-        {
-            let pts: Vec<Value> =
-                p.points.iter().rev().map(|q| figcraft_engine::cmd::props::width_point_json(&WidthPoint { t: 1.0 - q.t, ..*q })).collect();
-            app.run("stroke.widthProfile", json!({"ids": ids, "points": pts}));
-        }
-    });
-}
-
-/// A brush drawn along a short line across `rect`, as outlines (egui fills only convex shapes).
-pub(crate) fn brush_art(painter: &egui::Painter, rect: Rect, preset: &str, col: Color32) {
-    use figcraft_geom::kurbo::{self, PathEl};
-    let mut line = figcraft_geom::BezPath::new();
-    line.move_to((0.0, 0.0));
-    line.line_to((f64::from(rect.width()), 0.0));
-    let brush = Brush::new(preset);
-    let props = StrokeProps { weight: f64::from(rect.height()), align: StrokeAlign::Center, brush: Some(brush.clone()), ..Default::default() };
-    let Some(out) = figcraft_pathops::brush::outline(&line, props.weight, &props, &brush) else { return };
-    for sub in figcraft_geom::split_subpaths(&out) {
-        let mut pts = Vec::new();
-        kurbo::flatten(sub.iter(), 0.25, |el| {
-            if let PathEl::MoveTo(p) | PathEl::LineTo(p) = el {
-                pts.push(pos2(rect.min.x + p.x as f32, rect.center().y + p.y as f32));
-            }
-        });
-        painter.add(egui::Shape::closed_line(pts, Stroke::new(1.0, col)));
-    }
-}
-
-/// Stroke settings ▸ Brush: a plain stroke, a stretch brush or a scatter brush, each with its look.
-fn brush_row(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], brush: Option<Option<Brush>>, width: f32) {
-    use figcraft_pathops::brush::{PRESETS, preset};
-    let t = Tokens::get(ui.ctx());
-    widgets::sublabels(ui, tr("Brush"), None);
-    row(ui, 32.0, |ui| {
-        let label = match &brush {
-            None => tr("Mixed"),
-            Some(b) => b.as_ref().and_then(|b| preset(&b.preset)).map_or(tr("None"), |p| tr(p.label)),
-        };
-        let resp = widgets::dropdown(ui, label, width, None);
-        a11y::combo(&resp, tr("Brush"), label, a11y::menu_open(&resp));
-        if let Some(Some(b)) = &brush {
-            let r = resp.rect;
-            brush_art(
-                ui.painter(),
-                Rect::from_min_max(pos2(r.max.x - 22.0 - 56.0, r.center().y - 5.0), pos2(r.max.x - 22.0, r.center().y + 5.0)),
-                &b.preset,
-                t.icon_secondary,
-            );
-        }
-        menu_popup(&resp).show(|ui| {
-            if menu_item(ui, tr("None"), "") {
-                app.run("stroke.brush", json!({"ids": ids, "preset": null}));
-                ui.close();
-            }
-            for p in PRESETS {
-                let art = |pt: &egui::Painter, r: Rect, col: Color32| {
-                    brush_art(
-                        pt,
-                        Rect::from_min_max(pos2(r.max.x - 8.0 - 64.0, r.center().y - 5.0), pos2(r.max.x - 8.0, r.center().y + 5.0)),
-                        p.id,
-                        col,
-                    );
-                };
-                if menu_item_with(ui, tr(p.label), "", 8.0 + 64.0, art) {
-                    app.run("stroke.brush", json!({"ids": ids, "preset": p.id}));
-                    ui.close();
-                }
-            }
-        });
-    });
-    // A scatter brush's spacing and jitter.
-    let Some(Some(b)) =
-        brush.filter(|b| b.as_ref().and_then(|b| preset(&b.preset)).is_some_and(|p| p.kind == figcraft_pathops::brush::BrushKind::Scatter))
-    else {
-        return;
-    };
-    let half = (width - 8.0) / 2.0;
-    let with = |f: &dyn Fn(&mut Brush)| {
-        let mut nb = b.clone();
-        f(&mut nb);
-        serde_json::to_value(nb.sanitized()).unwrap_or_default()
-    };
-    widgets::sublabels(ui, tr("Spacing"), Some(tr("Scatter")));
-    row(ui, 32.0, |ui| {
-        let e = widgets::number_field(ui, Id::unique("brush_spacing"), Lead::Icon(Icon::Gap, tr("Brush spacing")), Some(b.spacing), "×", half, 0.1);
-        app.field(ids, "brush", e, |v| with(&|nb| nb.spacing = v));
-        let e = widgets::number_field(ui, Id::unique("brush_scatter"), Lead::Icon(Icon::Dots, tr("Brush scatter")), Some(b.scatter), "×", half, 0.1);
-        app.field(ids, "brush", e, |v| with(&|nb| nb.scatter = v));
-    });
-    widgets::sublabels(ui, tr("Size jitter"), Some(tr("Rotation jitter")));
-    row(ui, 32.0, |ui| {
-        let e = widgets::number_field(
-            ui,
-            Id::unique("brush_size_jitter"),
-            Lead::Icon(Icon::Scale, tr("Brush size jitter")),
-            Some(b.size_jitter * 100.0),
-            "%",
-            half,
-            1.0,
-        );
-        app.field(ids, "brush", e, |v| with(&|nb| nb.size_jitter = v / 100.0));
-        let e = widgets::number_field(
-            ui,
-            Id::unique("brush_rotation_jitter"),
-            Lead::Icon(Icon::Rotate, tr("Brush rotation jitter")),
-            Some(b.rotation_jitter * 100.0),
-            "%",
-            half,
-            1.0,
-        );
-        app.field(ids, "brush", e, |v| with(&|nb| nb.rotation_jitter = v / 100.0));
-    });
-}
-
-/// Advanced stroke settings: dash pattern, width profile, join and the end points of open paths.
-fn stroke_settings(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
-    let ids = sel.to_vec();
-    let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
-    let st = common(doc, sel, |n| n.stroke.clone());
-    let dashes = st.as_ref().map(|s| s.dashes.clone());
-    let weight = st.as_ref().map(|s| s.weight).unwrap_or(1.0).max(1.0);
-    widgets::sublabels(ui, tr("Stroke style"), None);
-    row(ui, 32.0, |ui| {
-        let dashed = dashes.as_ref().is_some_and(|d| !d.is_empty());
-        let resp = widgets::dropdown(ui, if dashed { tr("Dash") } else { tr("Solid") }, half, None);
-        menu_popup(&resp).show(|ui| {
-            if menu_item(ui, tr("Solid"), "") {
-                app.set_props(&ids, json!({"dashes": []}));
-                ui.close();
-            }
-            if menu_item(ui, tr("Dash"), "") {
-                app.set_props(&ids, json!({"dashes": [weight * 4.0, weight * 4.0]}));
-                ui.close();
-            }
-        });
-    });
-    if let Some(d) = dashes.filter(|d| !d.is_empty()) {
-        let (dash, gap) = (d.first().copied().unwrap_or(4.0), d.get(1).copied().unwrap_or_else(|| d.first().copied().unwrap_or(4.0)));
-        widgets::sublabels(ui, tr("Dash"), Some(tr("Gap")));
-        row(ui, 32.0, |ui| {
-            let e = widgets::number_field(ui, Id::unique("stroke_dash"), Lead::None, Some(dash), "", half, 1.0);
-            app.field(&ids, "dashes", e, |v| json!([v.max(0.0), gap]));
-            let e = widgets::number_field(ui, Id::unique("stroke_gap"), Lead::None, Some(gap), "", half, 1.0);
-            app.field(&ids, "dashes", e, |v| json!([dash, v.max(0.0)]));
-        });
-    }
-    width_profile_row(app, ui, &ids, st.as_ref().map(|s| s.profile().cloned()), half);
-    brush_row(app, ui, &ids, st.as_ref().map(|s| s.brush.clone()), half * 2.0 + 8.0);
-    let join = st.as_ref().map(|s| s.join);
-    widgets::sublabels(ui, tr("Join|stroke"), (join == Some(StrokeJoin::Miter)).then_some(tr("Miter angle")));
-    row(ui, 32.0, |ui| {
-        let resp = widgets::dropdown(ui, join.map(join_label).unwrap_or(tr("Mixed")), half, None);
-        menu_popup(&resp).show(|ui| {
-            for j in StrokeJoin::ALL {
-                if menu_item(ui, join_label(j), "") {
-                    app.set_props(&ids, json!({"strokeJoin": j}));
-                    ui.close();
-                }
-            }
-        });
-        if join == Some(StrokeJoin::Miter) {
-            let angle = st.as_ref().map(|s| (s.miter_angle() * 100.0).round() / 100.0);
-            let e = widgets::number_field(ui, Id::unique("stroke_miter"), Lead::None, angle, "°", half, 1.0);
-            app.field(&ids, "miterAngle", e, |v| json!(v));
-        }
-    });
-    // End points only mean something on open paths.
-    let open_paths = sel.iter().all(|i| doc.node(*i).is_some_and(|n| matches!(n.kind, NodeKind::Line | NodeKind::Vector { .. })));
-    if open_paths {
-        widgets::sublabels(ui, tr("Start point"), Some(tr("End point")));
-        row(ui, 32.0, |ui| {
-            for (key, cap) in [("startCap", st.as_ref().map(|s| s.cap_start)), ("endCap", st.as_ref().map(|s| s.cap_end))] {
-                let resp = widgets::dropdown(ui, cap.map(|c| tr(c.label())).unwrap_or(tr("Mixed")), half, None);
-                menu_popup(&resp).show(|ui| {
-                    for c in StrokeCap::ALL {
-                        if menu_item_with(ui, tr(c.label()), "", CAP_ART_W, |p, r, col| cap_art(p, r, col, c, key == "startCap")) {
-                            app.set_props(&ids, json!({key: format!("{c:?}")}));
-                            ui.close();
-                        }
-                    }
-                });
-            }
-        });
-    }
-    ui.add_space(4.0);
-}
-
-/// A stroke join's name in the interface.
-pub(crate) fn join_label(j: StrokeJoin) -> &'static str {
-    match j {
-        StrokeJoin::Miter => tr("Miter"),
-        StrokeJoin::Bevel => tr("Bevel"),
-        StrokeJoin::Round => tr("Round"),
-    }
-}
-
-/// The width [`cap_art`] takes at the right of a menu row (its arrows reach past the line's ends).
-pub(crate) const CAP_ART_W: f32 = 64.0;
-
-/// A short stroke ending in `cap` (on its left end for a start point), drawn at the right of a menu
-/// row.
-pub(crate) fn cap_art(p: &egui::Painter, r: Rect, col: Color32, cap: StrokeCap, start: bool) {
-    let y = r.center().y;
-    let (left, right) = (r.max.x - 58.0, r.max.x - 14.0);
-    // The capped end, the plain end, and the direction from the stroke into its cap.
-    let (tip, tail, d) = if start { (left, right, -1.0) } else { (right, left, 1.0) };
-    let at = |back: f32, dy: f32| pos2(tip - d * back, y + dy);
-    let line = |to: Pos2, w: f32| {
-        p.line_segment([pos2(tail, y), to], Stroke::new(w, col));
-    };
-    let fill = |pts: Vec<Pos2>| {
-        p.add(egui::Shape::convex_polygon(pts, col, Stroke::NONE));
-    };
-    match cap {
-        StrokeCap::None => line(at(0.0, 0.0), 4.0),
-        StrokeCap::Round => {
-            line(at(2.0, 0.0), 4.0);
-            p.circle_filled(at(2.0, 0.0), 2.0, col);
-        }
-        StrokeCap::Square => line(at(-2.0, 0.0), 4.0),
-        StrokeCap::LineArrow => {
-            line(at(0.0, 0.0), 1.5);
-            p.add(egui::Shape::line(vec![at(5.5, -5.5), at(0.0, 0.0), at(5.5, 5.5)], Stroke::new(1.5, col)));
-        }
-        StrokeCap::TriangleArrow => {
-            line(at(7.0, 0.0), 1.5);
-            fill(vec![at(0.0, 0.0), at(8.0, -4.5), at(8.0, 4.5)]);
-        }
-        StrokeCap::ReversedTriangle => {
-            line(at(8.0, 0.0), 1.5);
-            fill(vec![at(8.0, 0.0), at(0.0, -4.5), at(0.0, 4.5)]);
-        }
-        StrokeCap::CircleFilled => {
-            line(at(4.0, 0.0), 1.5);
-            p.circle_filled(at(4.0, 0.0), 4.0, col);
-        }
-        StrokeCap::DiamondFilled => {
-            line(at(5.0, 0.0), 1.5);
-            fill(vec![at(0.0, 0.0), at(5.0, -5.0), at(10.0, 0.0), at(5.0, 5.0)]);
-        }
-    }
-}
-
-/// Paint `i`'s row (swatch, colour or kind, opacity, visibility, remove); returns its area.
-fn paint_row(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, p: &Paint, fills: bool) -> Rect {
-    let t = Tokens::get(ui.ctx());
-    let ids = ids.to_vec();
-    let cmd = if fills { "fill.set" } else { "stroke.set" };
-    let r = row_rect(ui, 32.0, |ui| {
-        let w = ui.available_width() - 56.0;
-        let (r, _) = ui.allocate_exact_size(vec2(w, FIELD_H), Sense::hover());
-        ui.painter().rect_filled(r, CornerRadius::same(5), t.field);
-        let sw = Rect::from_min_size(pos2(r.min.x + 4.0, r.center().y - 8.0), vec2(16.0, 16.0));
-        widgets::paint_swatch(ui.painter(), sw, p);
-        let sresp = ui.interact(sw.expand(2.0), Id::unique(("swatch", fills, i)), Sense::click());
-        if sresp.clicked() {
-            app.ui.picker = Some(crate::colorpicker::PickerTarget::Paint { fills, index: i, ids: ids.clone() });
-        }
-        let text_r = Rect::from_min_max(pos2(sw.max.x + 8.0, r.min.y), pos2(r.max.x - 52.0, r.max.y));
-        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(text_r));
-        // The variable bound to this paint's colour (its key on the layers: `fill` or `fills/<i>/color`).
-        let bound = app.session.doc().ok().and_then(|d| {
-            let key = ids.first().and_then(|id| d.node(*id)).and_then(|n| figcraft_engine::cmd::lists::paint_binding_key(n, fills, i))?;
-            Some((key.to_string(), crate::variable_ui::bound_name(d, &ids, key)?))
-        });
-        match &p.kind {
-            PaintKind::Solid { .. } if bound.is_some() => {
-                let (key, name) = bound.clone().unwrap_or_default();
-                let chip = Rect::from_min_max(pos2(text_r.min.x - 2.0, r.min.y + 3.0), pos2(text_r.max.x - 20.0, r.max.y - 3.0));
-                child.painter().rect_filled(chip, CornerRadius::same(4), t.hover);
-                child.painter().rect_stroke(chip, CornerRadius::same(4), Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
-                let short = name.rsplit('/').next().unwrap_or(&name).to_string();
-                child.painter().with_clip_rect(chip.shrink2(vec2(5.0, 0.0))).text(
-                    pos2(chip.min.x + 5.0, r.center().y),
-                    Align2::LEFT_CENTER,
-                    short,
-                    regular(11.0),
-                    t.text,
-                );
-                let _ = ui.interact(chip, Id::unique(("bound_paint", fills, i)), Sense::hover()).on_hover_text(&name);
-                let dr = Rect::from_center_size(pos2(text_r.max.x - 9.0, r.center().y), vec2(18.0, 18.0));
-                let dresp = ui.interact(dr, Id::unique(("detach_paint", fills, i)), Sense::click()).tip(tr("Detach variable"));
-                icons::paint(ui.painter(), dr.shrink(3.0), Icon::Detach, t.icon_secondary);
-                if dresp.clicked() {
-                    app.run("variable.bind", json!({"ids": ids, "field": key, "variable": null}));
-                }
-            }
-            PaintKind::Solid { color } => {
-                if let Some(h) = widgets::text_field_inline(
-                    &mut child,
-                    Id::unique(("hex", fills, i)),
-                    &color.to_hex(),
-                    text_r.shrink2(vec2(0.0, 4.0)),
-                    regular(11.0),
-                ) && let Some(c) = figcraft_color::Color::from_hex_or_name(&h)
-                {
-                    app.run(cmd, json!({"ids": ids, "index": i, "color": c.to_css_hex()}));
-                }
-            }
-            _ => {
-                child.painter().text(pos2(text_r.min.x, r.center().y), Align2::LEFT_CENTER, paint_label(p), regular(11.0), t.text);
-            }
-        }
-        let op_r = Rect::from_min_max(pos2(r.max.x - 48.0, r.min.y), r.max);
-        ui.painter().line_segment([pos2(op_r.min.x, r.min.y + 4.0), pos2(op_r.min.x, r.max.y - 4.0)], Stroke::new(1.0, t.panel));
-        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(op_r));
-        let e = widgets::number_field(
-            &mut child,
-            Id::unique(("pop", fills, i)),
-            Lead::None,
-            Some((f64::from(p.opacity) * 100.0).round()),
-            "%",
-            48.0,
-            1.0,
-        );
-        match e {
-            Some(FieldEdit::Set(v)) => {
-                app.run(cmd, json!({"ids": ids, "index": i, "opacity": (v / 100.0).clamp(0.0, 1.0)}));
-            }
-            Some(FieldEdit::Scrub(v, done)) => {
-                let _ = app.session.begin_interaction("Opacity");
-                let _ = app.session.execute(cmd, &json!({"ids": ids, "index": i, "opacity": (v / 100.0).clamp(0.0, 1.0)}));
-                if done {
-                    let _ = app.session.commit_interaction();
-                }
-            }
-            None => {}
-        }
-        if icons::button(ui, if p.visible { Icon::Eye } else { Icon::EyeOff }, 24.0, false, tr("Toggle visibility")).clicked() {
-            app.run(cmd, json!({"ids": ids, "index": i, "visible": !p.visible}));
-        }
-        if icons::button(ui, Icon::Minus, 24.0, false, tr("Remove")).clicked()
-            && app.run(if fills { "fill.remove" } else { "stroke.remove" }, json!({"ids": ids, "index": i})).is_some()
-            && let Some(crate::colorpicker::PickerTarget::Paint { fills: f, index, .. }) = &mut app.ui.picker
-            && *f == fills
-        {
-            // An open colour picker keeps editing the paint it was on, or closes with it.
-            match removed_index(*index, i) {
-                Some(k) => *index = k,
-                None => app.ui.picker = None,
-            }
-        }
-    });
-    let copy = if fills { tr("Copy fill") } else { tr("Copy stroke") };
-    let paste = if fills { tr("Paste fill") } else { tr("Paste stroke") };
-    let can_paste = app.session.clipboard.paint.as_ref().is_some_and(|(f, _)| *f == fills);
-    row_context_menu(ui, r, Id::unique(("paint_menu", fills, i))).show(|ui| {
-        if menu_item(ui, copy, "") {
-            app.run(if fills { "fill.copy" } else { "stroke.copy" }, json!({"ids": ids, "index": i}));
-            ui.close();
-        }
-        if can_paste && menu_item(ui, paste, "") {
-            app.run(if fills { "fill.paste" } else { "stroke.paste" }, json!({"ids": ids, "index": i}));
-            ui.close();
-        }
-    });
-    r
-}
-
-/// A paint row's label (also what a drag of it carries): its colour, gradient kind or "Image".
-fn paint_label(p: &Paint) -> String {
-    match &p.kind {
-        PaintKind::Solid { color } => color.to_hex(),
-        // The gradient kind's name ("Linear") is a key of its own.
-        PaintKind::Gradient(g) => tr(&format!("{:?}", g.kind)).to_string(),
-        PaintKind::Image(_) => tr("Image").into(),
-        PaintKind::Pattern(_) => tr("Pattern").into(),
-    }
-}
-
-/// Draw the effect list with add/style/type/toggle/remove/reorder, open settings, and keep an
-/// open picker and settings flags aligned when rows move or are removed.
-fn effects(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
-    let ids = sel.to_vec();
-    let list = common(doc, sel, |n| n.effects.clone());
-    let empty = list.as_ref().is_none_or(|l| l.is_empty());
-    let (clicked, header) = widgets::section_header_resp(ui, tr("Effects"), &[(Icon::Styles, tr("Styles")), (Icon::Plus, tr("Add effect"))], empty);
-    if let Some(i) = clicked {
-        if i == 1 {
-            app.run("effect.add", json!({"ids": ids, "type": "dropShadow"}));
-        } else {
-            style_picker::open(app, ui, &ids, StyleSlot::Effect);
-        }
-    }
-    context_popup(&header).show(|ui| {
-        if app.session.clipboard.effect.is_some() && menu_item(ui, tr("Paste effect"), "") {
-            app.run("effect.paste", json!({"ids": ids}));
-            ui.close();
-        }
-    });
-    style_picker::chip(app, ui, doc, &ids, StyleSlot::Effect);
-    let Some(list) = list else { return };
-    let mut drag = ListDrag::new(ui, "effects");
-    let mut removed = None;
-    for (i, e) in list.iter().enumerate().rev() {
-        let mut open = effect_open(ui.ctx(), i);
-        let header = row_rect(ui, 32.0, |ui| {
-            if icons::button(ui, Icon::Effects, 24.0, open, tr("Effect settings")).clicked() {
-                open = !open;
-                ui.data_mut(|d| d.insert_temp(Id::unique((FX_OPEN, i)), open));
-            }
-            let w = ui.available_width() - 56.0;
-            let resp = widgets::dropdown(ui, tr(e.label()), w, None);
-            menu_popup(&resp).show(|ui| {
-                for (l, ty) in Effect::TYPES {
-                    if menu_item(ui, tr(l), "")
-                        && let Some(ne) = Effect::of_type(ty)
-                    {
-                        app.run("effect.set", json!({"ids": ids, "index": i, "effect": ne}));
-                        ui.close();
-                    }
-                }
-            });
-            if icons::button(ui, if e.visible { Icon::Eye } else { Icon::EyeOff }, 24.0, false, tr("Toggle")).clicked() {
-                let mut e2 = e.clone();
-                e2.visible = !e2.visible;
-                app.run("effect.set", json!({"ids": ids, "index": i, "effect": e2}));
-            }
-            if icons::button(ui, Icon::Minus, 24.0, false, tr("Remove")).clicked()
-                && app.run("effect.remove", json!({"ids": ids, "index": i})).is_some()
-            {
-                removed = Some(i);
-            }
-        });
-        let can_paste = app.session.clipboard.effect.is_some();
-        row_context_menu(ui, header, Id::unique(("effect_menu", i))).show(|ui| {
-            if menu_item(ui, tr("Copy effect"), "") {
-                app.run("effect.copy", json!({"ids": ids, "index": i}));
-                ui.close();
-            }
-            if can_paste && menu_item(ui, tr("Paste effect"), "") {
-                app.run("effect.paste", json!({"ids": ids, "index": i}));
-                ui.close();
-            }
-        });
-        if open {
-            effect_settings(app, ui, &ids, i, e);
-        }
-        drag.row(ui, i, header, header.with_max_y(ui.cursor().min.y.max(header.max.y)), || tr(e.label()).to_string());
-    }
-    if let Some((from, to)) = drag.finish(ui) {
-        app.run("effect.move", json!({"ids": ids, "from": from, "to": to}));
-        move_flags(ui, FX_OPEN, list.len(), from, to);
-        if let Some(crate::colorpicker::PickerTarget::Effect { index, .. }) = &mut app.ui.picker {
-            *index = moved_index(*index, from, to);
-        }
-    }
-    // Open settings and an open colour picker stay with their effects, or go with theirs.
-    if let Some(i) = removed {
-        remove_flags(ui, FX_OPEN, list.len(), i);
-        if let Some(crate::colorpicker::PickerTarget::Effect { index, .. }) = &mut app.ui.picker {
-            match removed_index(*index, i) {
-                Some(k) => *index = k,
-                None => app.ui.picker = None,
-            }
-        }
-    }
-}
-
-/// Salt of the flags that keep effect rows' settings open.
-const FX_OPEN: &str = "fx_open";
-
-/// Whether effect `i`'s settings are open in the Design panel.
-pub(crate) fn effect_open(ctx: &egui::Context, i: usize) -> bool {
-    ctx.data(|d| d.get_temp::<bool>(Id::unique((FX_OPEN, i)))).unwrap_or(false)
-}
-
-/// A number field of effect `i` that can be bound to a variable (`effects/<i>/<prop>`).
-fn fx_field(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, prop: &str, lead: Lead, value: f64, width: f32) -> Option<FieldEdit> {
-    crate::variable_ui::number_field(app, ui, ids, &format!("effects/{i}/{prop}"), Id::unique(("fx", prop, i)), lead, Some(value), "", width)
-}
-
-/// Draw type-specific effect fields for shadows, blurs, noise, texture and glass, using live
-/// scrub edits that stay one undo step and bindable colour fields.
-fn effect_settings(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, e: &Effect) {
-    let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
-    let set = |app: &mut FigApp, e2: Effect, scrub: Option<bool>| {
-        let p = json!({"ids": ids, "index": i, "effect": e2});
-        match scrub {
-            None => {
-                app.run("effect.set", p);
-            }
-            Some(done) => {
-                let _ = app.session.begin_interaction("Effect");
-                let _ = app.session.execute("effect.set", &p);
-                if done {
-                    let _ = app.session.commit_interaction();
-                }
-            }
-        }
-    };
-    let edit = |app: &mut FigApp, ed: Option<FieldEdit>, f: &dyn Fn(f64) -> Effect| match ed {
-        Some(FieldEdit::Set(v)) => set(app, f(v), None),
-        Some(FieldEdit::Scrub(v, d)) => set(app, f(v), Some(d)),
-        None => {}
-    };
-    // A new colour for the effect (`secondary`: a duo noise's second colour).
-    let edit_color = |app: &mut FigApp, secondary: bool, c: figcraft_color::Color, scrub: Option<bool>| {
-        let mut e2 = e.clone();
-        if let Some(slot) = e2.color_mut(secondary) {
-            *slot = c;
-        }
-        set(app, e2, scrub);
-    };
-    match &e.kind {
-        EffectKind::DropShadow(s) | EffectKind::InnerShadow(s) => {
-            let inner = matches!(e.kind, EffectKind::InnerShadow(_));
-            let mk = |s2: Shadow| Effect { kind: if inner { EffectKind::InnerShadow(s2) } else { EffectKind::DropShadow(s2) }, visible: e.visible };
-            row(ui, 32.0, |ui| {
-                let ed = fx_field(app, ui, ids, i, "offsetX", Lead::Text("X"), s.offset.0, half);
-                edit(app, ed, &|v| mk(Shadow { offset: (v, s.offset.1), ..s.clone() }));
-                let ed = fx_field(app, ui, ids, i, "offsetY", Lead::Text("Y"), s.offset.1, half);
-                edit(app, ed, &|v| mk(Shadow { offset: (s.offset.0, v), ..s.clone() }));
-            });
-            row(ui, 32.0, |ui| {
-                let ed = fx_field(app, ui, ids, i, "radius", Lead::Text(tr("Blur")), s.radius, half);
-                edit(app, ed, &|v| mk(Shadow { radius: v.max(0.0), ..s.clone() }));
-                let ed = fx_field(app, ui, ids, i, "spread", Lead::Text(tr("Spread")), s.spread, half);
-                edit(app, ed, &|v| mk(Shadow { spread: v, ..s.clone() }));
-            });
-            // The colour: a bound variable's chip, else swatch, hex and alpha with a variable button.
-            let color_field = format!("effects/{i}/color");
-            row(ui, 32.0, |ui| {
-                crate::variable_ui::bindable(app, ui, ids, &color_field, VariableType::Color, half * 2.0 + 8.0, |app, ui| {
-                    fx_color(app, ui, ids, i, e, false, &edit_color)
-                });
-            });
-            if !inner {
-                row(ui, 32.0, |ui| {
-                    if widgets::checkbox(ui, s.show_behind, tr("Show behind transparent areas")) {
-                        set(app, mk(Shadow { show_behind: !s.show_behind, ..s.clone() }), None);
-                    }
-                });
-            }
-        }
-        EffectKind::LayerBlur(b) | EffectKind::BackgroundBlur(b) => {
-            let with = |f: &dyn Fn(&mut Blur)| {
-                let mut e2 = e.clone();
-                if let Some(b2) = e2.blur_mut() {
-                    f(b2);
-                }
-                e2
-            };
-            row(ui, 32.0, |ui| {
-                let resp = widgets::dropdown(ui, tr(b.blur_type.label()), half * 2.0 + 8.0, None);
-                menu_popup(&resp).show(|ui| {
-                    for t in BlurType::ALL {
-                        if menu_item(ui, tr(t.label()), "") {
-                            set(app, with(&|b2| b2.blur_type = t), None);
-                            ui.close();
-                        }
-                    }
-                });
-            });
-            row(ui, 32.0, |ui| {
-                if b.is_progressive() {
-                    // The ramp's start and end points are dragged on the canvas.
-                    let ed = fx_field(app, ui, ids, i, "startRadius", Lead::Text(tr("Start")), b.start_radius, half);
-                    edit(app, ed, &|v| with(&|b2| b2.start_radius = v.clamp(0.0, MAX_BLUR_RADIUS)));
-                    let ed = fx_field(app, ui, ids, i, "radius", Lead::Text(tr("End")), b.radius, half);
-                    edit(app, ed, &|v| with(&|b2| b2.radius = v.clamp(0.0, MAX_BLUR_RADIUS)));
-                } else {
-                    let ed = fx_field(app, ui, ids, i, "radius", Lead::Text(tr("Blur")), b.radius, half * 2.0 + 8.0);
-                    edit(app, ed, &|v| with(&|b2| b2.radius = v.clamp(0.0, MAX_BLUR_RADIUS)));
-                }
-            });
-        }
-        EffectKind::Noise(nz) => {
-            let with = |f: &dyn Fn(&mut Noise)| {
-                tweaked(e, |k| {
-                    if let EffectKind::Noise(n) = k {
-                        f(n);
-                    }
-                })
-            };
-            row(ui, 32.0, |ui| {
-                let resp = widgets::dropdown(ui, tr(nz.mode.label()), half * 2.0 + 8.0, None);
-                menu_popup(&resp).show(|ui| {
-                    for m in NoiseMode::ALL {
-                        if menu_item(ui, tr(m.label()), "") {
-                            set(app, with(&|n| n.mode = m), None);
-                            ui.close();
-                        }
-                    }
-                });
-            });
-            row(ui, 32.0, |ui| {
-                let ed = widgets::number_field(ui, Id::unique(("fx_ns", i)), Lead::Text(tr("Size")), Some(nz.size), "", half, 0.1);
-                edit(app, ed, &|v| {
-                    with(&|n| {
-                        n.size = v.clamp(0.01, 1000.0);
-                        n.size_y = None;
-                    })
-                });
-                let ed = widgets::number_field(
-                    ui,
-                    Id::unique(("fx_nd", i)),
-                    Lead::Text(tr("Density")),
-                    Some((nz.density * 100.0).round()),
-                    "%",
-                    half,
-                    1.0,
-                );
-                edit(app, ed, &|v| with(&|n| n.density = (v / 100.0).clamp(0.0, 1.0)));
-            });
-            match nz.mode {
-                NoiseMode::Mono => row(ui, 32.0, |ui| fx_color(app, ui, ids, i, e, false, &edit_color)),
-                NoiseMode::Duo => {
-                    row(ui, 32.0, |ui| fx_color(app, ui, ids, i, e, false, &edit_color));
-                    row(ui, 32.0, |ui| fx_color(app, ui, ids, i, e, true, &edit_color));
-                }
-                NoiseMode::Multi => row(ui, 32.0, |ui| {
-                    let op = Some((f64::from(nz.opacity) * 100.0).round());
-                    let ed = widgets::number_field(ui, Id::unique(("fx_no", i)), Lead::Text(tr("Opacity")), op, "%", half, 1.0);
-                    edit(app, ed, &|v| with(&|n| n.opacity = (v / 100.0).clamp(0.0, 1.0) as f32));
-                }),
-            }
-        }
-        EffectKind::Texture(tx) => {
-            let with = |f: &dyn Fn(&mut Texture)| {
-                tweaked(e, |k| {
-                    if let EffectKind::Texture(t) = k {
-                        f(t);
-                    }
-                })
-            };
-            row(ui, 32.0, |ui| {
-                let ed = widgets::number_field(ui, Id::unique(("fx_ts", i)), Lead::Text(tr("Size")), Some(tx.size), "", half, 0.1);
-                edit(app, ed, &|v| {
-                    with(&|t| {
-                        t.size = v.clamp(0.01, 1000.0);
-                        t.size_y = None;
-                    })
-                });
-                let ed = widgets::number_field(ui, Id::unique(("fx_tr", i)), Lead::Text(tr("Radius")), Some(tx.radius), "", half, 1.0);
-                edit(app, ed, &|v| with(&|t| t.radius = v.max(0.0)));
-            });
-            row(ui, 32.0, |ui| {
-                if widgets::checkbox(ui, tx.clip_to_shape, tr("Clip to shape")) {
-                    set(app, with(&|t| t.clip_to_shape = !tx.clip_to_shape), None);
-                }
-            });
-        }
-        EffectKind::Glass(g) => {
-            let with = |f: &dyn Fn(&mut Glass)| {
-                tweaked(e, |k| {
-                    if let EffectKind::Glass(gl) = k {
-                        f(gl);
-                    }
-                })
-            };
-            let pct = |v: f64| Some((v * 100.0).round());
-            let unit = |v: f64| (v / 100.0).clamp(0.0, 1.0);
-            row(ui, 32.0, |ui| {
-                let ed =
-                    widgets::number_field(ui, Id::unique(("fx_gl", i)), Lead::Text(tr("Light|glass")), Some(g.light_angle.round()), "°", half, 1.0);
-                edit(app, ed, &|v| with(&|gl| gl.light_angle = v.clamp(-180.0, 180.0)));
-                let ed = widgets::number_field(ui, Id::unique(("fx_gi", i)), Lead::Text(tr("Intensity")), pct(g.light_intensity), "%", half, 1.0);
-                edit(app, ed, &|v| with(&|gl| gl.light_intensity = unit(v)));
-            });
-            row(ui, 32.0, |ui| {
-                let ed = widgets::number_field(ui, Id::unique(("fx_gr", i)), Lead::Text(tr("Refraction")), pct(g.refraction), "%", half, 1.0);
-                edit(app, ed, &|v| with(&|gl| gl.refraction = unit(v)));
-                let ed = widgets::number_field(ui, Id::unique(("fx_gd", i)), Lead::Text(tr("Depth")), Some(g.depth), "", half, 1.0);
-                edit(app, ed, &|v| with(&|gl| gl.depth = v.clamp(1.0, 1000.0)));
-            });
-            row(ui, 32.0, |ui| {
-                let ed = widgets::number_field(ui, Id::unique(("fx_gs", i)), Lead::Text(tr("Dispersion")), pct(g.dispersion), "%", half, 1.0);
-                edit(app, ed, &|v| with(&|gl| gl.dispersion = unit(v)));
-                let ed = widgets::number_field(ui, Id::unique(("fx_gf", i)), Lead::Text(tr("Frost")), Some(g.frost), "", half, 1.0);
-                edit(app, ed, &|v| with(&|gl| gl.frost = v.clamp(0.0, 1000.0)));
-            });
-            row(ui, 32.0, |ui| {
-                let ed = widgets::number_field(ui, Id::unique(("fx_gp", i)), Lead::Text(tr("Splay")), pct(g.splay), "%", half, 1.0);
-                edit(app, ed, &|v| with(&|gl| gl.splay = unit(v)));
-            });
-        }
-    }
-}
-
-/// Applies a new colour to an effect: (app, secondary colour, colour, scrubbing: `Some(done)`).
-type ColorEdit<'a> = dyn Fn(&mut FigApp, bool, figcraft_color::Color, Option<bool>) + 'a;
-
-/// `e` with `f` applied to its kind.
-fn tweaked(e: &Effect, f: impl FnOnce(&mut EffectKind)) -> Effect {
-    let mut e2 = e.clone();
-    f(&mut e2.kind);
-    e2
-}
-
-/// The swatch (opens the colour picker), hex and opacity of effect `i`'s colour (`secondary`: a
-/// duo noise's second colour), in the current row; `edit` applies a new one.
-fn fx_color(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, e: &Effect, secondary: bool, edit: &ColorEdit<'_>) {
-    let Some(c) = e.color(secondary) else { return };
-    if widgets::swatch(ui, &Paint::solid(c), 16.0).clicked() {
-        app.ui.picker = Some(crate::colorpicker::PickerTarget::Effect { ids: ids.to_vec(), index: i, secondary });
-    }
-    if let Some(h) = widgets::text_field(ui, Id::unique(("fx_c", i, secondary)), &c.to_hex(), 80.0, "")
-        && let Some(nc) = figcraft_color::Color::from_hex_or_name(&h)
-    {
-        edit(app, secondary, nc.with_alpha(c.a), None);
-    }
-    let alpha = |v: f64| c.with_alpha((v / 100.0).clamp(0.0, 1.0) as f32);
-    match widgets::number_field(ui, Id::unique(("fx_a", i, secondary)), Lead::None, Some((f64::from(c.a) * 100.0).round()), "%", 56.0, 1.0) {
-        Some(FieldEdit::Set(v)) => edit(app, secondary, alpha(v), None),
-        Some(FieldEdit::Scrub(v, done)) => edit(app, secondary, alpha(v), Some(done)),
-        None => {}
-    }
-}
-
-/// Draw the layout-grid list with add/style/type/toggle/remove/reorder, per-grid settings,
-/// and keep open-settings flags aligned when rows move or are removed.
-fn grids(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
-    let ids = sel.to_vec();
-    let list = common(doc, sel, |n| n.grids.clone());
-    let empty = list.as_ref().is_none_or(|l| l.is_empty());
-    if let Some(i) = widgets::section_header(ui, tr("Layout grid"), &[(Icon::Styles, tr("Styles")), (Icon::Plus, tr("Add layout grid"))], empty) {
-        if i == 1 {
-            app.run("grid.add", json!({"ids": ids}));
-        } else {
-            style_picker::open(app, ui, &ids, StyleSlot::Grid);
-        }
-    }
-    style_picker::chip(app, ui, doc, &ids, StyleSlot::Grid);
-    let Some(list) = list else { return };
-    // The last grid first, like paints and effects; rows drag to reorder.
-    let mut drag = ListDrag::new(ui, "grids");
-    let mut removed = None;
-    for (i, g) in list.iter().enumerate().rev() {
-        let open_id = Id::unique(("grid_open", i));
-        let mut open = ui.data(|d| d.get_temp::<bool>(open_id)).unwrap_or(false);
-        let header = row_rect(ui, 32.0, |ui| {
-            if icons::button(ui, Icon::Grid, 24.0, open, tr("Layout grid settings")).clicked() {
-                open = !open;
-                ui.data_mut(|d| d.insert_temp(open_id, open));
-            }
-            let w = ui.available_width() - 56.0;
-            let resp = widgets::dropdown(ui, &grid_label(g), w, None);
-            menu_popup(&resp).width(220.0).show(|ui| {
-                for (l, kind) in [(tr("Grid"), GridKind::Grid), (tr("Columns"), GridKind::Columns), (tr("Rows"), GridKind::Rows)] {
-                    if menu_item(ui, l, "") {
-                        let fresh = match kind {
-                            GridKind::Grid => LayoutGrid::default(),
-                            GridKind::Columns => LayoutGrid::columns(),
-                            GridKind::Rows => LayoutGrid::rows(),
-                        };
-                        app.set_props(&ids, json!({"grids": grids_with(&list, i, |x| *x = fresh)}));
-                        ui.close();
-                    }
-                }
-            });
-            if icons::button(ui, if g.visible { Icon::Eye } else { Icon::EyeOff }, 24.0, false, tr("Toggle")).clicked() {
-                app.set_props(&ids, json!({"grids": grids_with(&list, i, |x| x.visible = !x.visible)}));
-            }
-            if icons::button(ui, Icon::Minus, 24.0, false, tr("Remove")).clicked()
-                && app.run("grid.remove", json!({"ids": ids, "index": i})).is_some()
-            {
-                removed = Some(i);
-            }
-        });
-        if open {
-            grid_settings(app, ui, &ids, &list, i, g);
-        }
-        drag.row(ui, i, header, header.with_max_y(ui.cursor().min.y.max(header.max.y)), || grid_label(g));
-    }
-    if let Some((from, to)) = drag.finish(ui) {
-        app.run("grid.move", json!({"ids": ids, "from": from, "to": to}));
-        move_flags(ui, "grid_open", list.len(), from, to);
-    }
-    // Open settings stay with their grids, or go with theirs.
-    if let Some(i) = removed {
-        remove_flags(ui, "grid_open", list.len(), i);
-    }
-}
-
-/// A layout grid's name in its row ("Grid (10)", "5 columns").
-fn grid_label(g: &LayoutGrid) -> String {
-    match g.kind {
-        GridKind::Grid => trf("Grid ({size})", &[("size", &g.size)]),
-        GridKind::Columns if auto_count(g) => tr("Auto columns").to_string(),
-        GridKind::Rows if auto_count(g) => tr("Auto rows").to_string(),
-        GridKind::Columns => trn("{n} columns", g.count.max(1) as usize, &[]),
-        GridKind::Rows => trn("{n} rows", g.count.max(1) as usize, &[]),
-    }
-}
-
-/// Fixed-size columns or rows counted Auto: as many as fit.
-fn auto_count(g: &LayoutGrid) -> bool {
-    g.count == 0 && g.align != GridAlign::Stretch
-}
-
-/// `list` with grid `i` changed by `f`.
-fn grids_with(list: &[LayoutGrid], i: usize, f: impl FnOnce(&mut LayoutGrid)) -> Vec<LayoutGrid> {
-    let mut gs = list.to_vec();
-    if let Some(g) = gs.get_mut(i) {
-        f(g);
-    }
-    gs
-}
-
-/// Layout grid `i`'s settings: size (grids); count, type, width or height, margin or offset and
-/// gutter (columns and rows); colour. The numbers can be bound to number variables
-/// (`layoutGrids/<i>/<size|count|gutter|offset>`).
-fn grid_settings(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], list: &[LayoutGrid], i: usize, g: &LayoutGrid) {
-    let col = widgets::col_width(ui.available_width());
-    let set = |f: &dyn Fn(&mut LayoutGrid)| json!({"ids": ids, "props": {"grids": grids_with(list, i, f)}});
-    // One bindable number field, applied with `apply` (a scrub is one undo step).
-    let field = |app: &mut FigApp, ui: &mut Ui, name: &str, value: f64, apply: &dyn Fn(&mut LayoutGrid, f64)| {
-        let key = format!("layoutGrids/{i}/{name}");
-        let e = crate::variable_ui::number_field(app, ui, ids, &key, Id::unique(("grid_field", name, i)), Lead::None, Some(value), "", col);
-        app.field_run(e, "node.set", |v| set(&|x| apply(x, v)));
-    };
-    let size = |x: &mut LayoutGrid, v: f64| x.size = v.max(1.0);
-    let offset = |x: &mut LayoutGrid, v: f64| x.offset = v.max(0.0);
-    let gutter = |x: &mut LayoutGrid, v: f64| x.gutter = v.max(0.0);
-    if g.kind == GridKind::Grid {
-        widgets::sublabels(ui, tr("Size"), None);
-        row(ui, 32.0, |ui| field(app, ui, "size", g.size, &size));
-    } else {
-        let cols = g.kind == GridKind::Columns;
-        widgets::sublabels(ui, tr("Count"), Some(tr("Type")));
-        row(ui, 32.0, |ui| {
-            // 0 is Auto for fixed-size columns (rows); a stretched grid has at least one.
-            let count = (!auto_count(g)).then(|| f64::from(g.count.max(1)));
-            let key = format!("layoutGrids/{i}/count");
-            let id = Id::unique(("grid_field", "count", i));
-            // A stretched grid has at least one band, so 0 (Auto) isn't a count it can take.
-            let e = if g.align == GridAlign::Stretch {
-                crate::variable_ui::number_field_or(app, ui, ids, &key, id, count, col, "", Lead::None, "")
-            } else {
-                crate::variable_ui::number_field_auto(app, ui, ids, &key, id, count, col, Lead::None, "")
-            };
-            app.field_run(e, "node.set", |v| {
-                set(&|x| x.count = if x.align == GridAlign::Stretch { v.round().clamp(1.0, 1000.0) } else { v.round().clamp(0.0, 1000.0) } as u32)
-            });
-            let names =
-                if cols { [tr("Stretch"), tr("Left"), tr("Center"), tr("Right")] } else { [tr("Stretch"), tr("Top"), tr("Center"), tr("Bottom")] };
-            let aligns = [GridAlign::Stretch, GridAlign::Min, GridAlign::Center, GridAlign::Max];
-            let cur = aligns.iter().position(|a| *a == g.align).unwrap_or(0);
-            let resp = widgets::dropdown(ui, names.get(cur).copied().unwrap_or_default(), col, None);
-            menu_popup(&resp).show(|ui| {
-                for (k, (name, a)) in names.iter().zip(aligns).enumerate() {
-                    if menu_check(ui, k == cur, name, "") {
-                        // Fixed-size columns need a size of their own.
-                        app.run(
-                            "node.set",
-                            set(&|x| {
-                                x.align = a;
-                                if a != GridAlign::Stretch && !(x.size.is_finite() && x.size > 0.0) {
-                                    x.size = 60.0;
-                                }
-                                if a == GridAlign::Stretch {
-                                    x.count = x.count.max(1);
-                                }
-                            }),
-                        );
-                        ui.close();
-                    }
-                }
-            });
-        });
-        let span = if cols { tr("Width") } else { tr("Height") };
-        match g.align {
-            GridAlign::Stretch => {
-                widgets::sublabels(ui, span, Some(tr("Margin")));
-                row(ui, 32.0, |ui| {
-                    // The frame, divided by the count: shown as Auto and not editable.
-                    ui.add_enabled_ui(false, |ui| {
-                        let auto = widgets::Empty::Text(tr("Auto"));
-                        widgets::number_field_bindable(ui, Id::unique(("grid_field", "size", i)), Lead::Named(span), None, "", col, 1.0, None, auto)
-                    });
-                    field(app, ui, "offset", g.offset, &offset);
-                });
-                widgets::sublabels(ui, tr("Gutter"), None);
-                row(ui, 32.0, |ui| field(app, ui, "gutter", g.gutter, &gutter));
-            }
-            GridAlign::Center => {
-                widgets::sublabels(ui, span, Some(tr("Gutter")));
-                row(ui, 32.0, |ui| {
-                    field(app, ui, "size", g.size, &size);
-                    field(app, ui, "gutter", g.gutter, &gutter);
-                });
-            }
-            GridAlign::Min | GridAlign::Max => {
-                widgets::sublabels(ui, span, Some(tr("Offset")));
-                row(ui, 32.0, |ui| {
-                    field(app, ui, "size", g.size, &size);
-                    field(app, ui, "offset", g.offset, &offset);
-                });
-                widgets::sublabels(ui, tr("Gutter"), None);
-                row(ui, 32.0, |ui| field(app, ui, "gutter", g.gutter, &gutter));
-            }
-        }
-    }
-    // The colour: swatch, hex and alpha.
-    widgets::sublabels(ui, tr("Color"), None);
-    row(ui, 32.0, |ui| {
-        let (sw, _) = ui.allocate_exact_size(vec2(16.0, 16.0), Sense::hover());
-        widgets::paint_swatch(ui.painter(), sw, &Paint::solid(g.color));
-        if let Some(h) = widgets::text_field(ui, Id::unique(("grid_hex", i)), &g.color.to_hex(), 80.0, "")
-            && let Some(c) = figcraft_color::Color::from_hex_or_name(&h)
-        {
-            app.run("node.set", set(&|x| x.color = c.with_alpha(x.color.a)));
-        }
-        let e = widgets::number_field(ui, Id::unique(("grid_alpha", i)), Lead::None, Some((f64::from(g.color.a) * 100.0).round()), "%", 56.0, 1.0);
-        app.field_run(e, "node.set", |v| set(&|x| x.color = x.color.with_alpha((v / 100.0).clamp(0.0, 1.0) as f32)));
-    });
-}
-
-/// One group of inspected properties: label, value (with a swatch for colours) and the style or
-/// variable it comes from. Clicking a row copies its value.
-pub(crate) fn inspect_section(app: &mut FigApp, ui: &mut Ui, s: &figcraft_engine::devinspect::Section) {
-    let t = Tokens::get(ui.ctx());
-    widgets::separator(ui);
-    let (hr, _) = ui.allocate_exact_size(vec2(ui.available_width(), 32.0), Sense::hover());
-    ui.painter().text(pos2(hr.min.x + PAD, hr.center().y), Align2::LEFT_CENTER, tr(s.title), semibold(11.0), t.text);
-    for p in &s.rows {
-        prop_row(app, ui, p);
-    }
-    ui.add_space(4.0);
-}
-
-/// An inspected property row: label, value (with a swatch for colours) and the style or variable
-/// it comes from as a chip. Clicking it copies the value.
-pub(crate) fn prop_row(app: &mut FigApp, ui: &mut Ui, p: &figcraft_engine::devinspect::Prop) {
-    let t = Tokens::get(ui.ctx());
-    let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 26.0), Sense::click());
-    let resp = resp.tip(trf("Copy {value}", &[("value", &p.value)]));
-    if resp.hovered() {
-        ui.painter().rect_filled(r.shrink2(vec2(8.0, 0.0)), CornerRadius::same(5), t.hover);
-    }
-    let painter = ui.painter();
-    // The engine's property labels ("Width") are keys of their own.
-    let label = tr(&p.label);
-    // Elided before the value column (some languages' labels run longer).
-    painter.text(
-        pos2(r.min.x + PAD, r.center().y),
-        Align2::LEFT_CENTER,
-        widgets::elide(ui, label, 96.0 - PAD - 6.0),
-        regular(11.0),
-        t.text_secondary,
-    );
-    // The style or variable, right-aligned as a chip.
-    let mut right = r.max.x - PAD;
-    if let Some(token) = &p.token {
-        let galley = painter.layout_no_wrap(token.clone(), regular(10.0), t.text_secondary);
-        let chip =
-            Rect::from_min_max(pos2((right - galley.size().x - 12.0).max(r.min.x + 196.0), r.center().y - 9.0), pos2(right, r.center().y + 9.0));
-        painter.rect_filled(chip, CornerRadius::same(4), t.field);
-        painter.with_clip_rect(chip.shrink2(vec2(6.0, 0.0))).galley(
-            pos2(chip.min.x + 6.0, chip.center().y - galley.size().y / 2.0),
-            galley,
-            t.text_secondary,
-        );
-        right = chip.min.x - 6.0;
-    }
-    let mut x = r.min.x + 96.0;
-    if let Some(c) = p.color.as_deref().and_then(figcraft_color::Color::from_hex) {
-        let sw = Rect::from_min_size(pos2(x, r.center().y - 6.0), vec2(12.0, 12.0));
-        widgets::paint_swatch(painter, sw, &Paint::solid(c));
-        x += 18.0;
-    }
-    let value_r = Rect::from_min_max(pos2(x, r.min.y), pos2(right.max(x + 10.0), r.max.y));
-    painter.with_clip_rect(value_r).text(pos2(x, r.center().y), Align2::LEFT_CENTER, &p.value, regular(11.0), t.text);
-    if resp.clicked() {
-        app.clipboard_set_text(&p.value);
-        app.toast(trf("Copied {value}", &[("value", &label.to_lowercase())]));
-    }
-}
-
-/// The thumbnails and chosen export formats of the Inspect tab's assets, kept between frames: the
-/// thumbnails until the document changes, the formats for the session.
-#[derive(Clone, Default)]
-struct AssetUi {
-    revision: u64,
-    thumbs: std::collections::HashMap<NodeId, Option<egui::TextureHandle>>,
-    formats: std::collections::HashMap<NodeId, usize>,
-}
-
-/// An asset row's height and its preview's side.
-const ASSET_ROW_H: f32 = 56.0;
-const ASSET_THUMB: f32 = 40.0;
-
-/// The selection's assets (layers with export settings, icons, images) as a list of a preview, a
-/// name and a format: click one to export it in that format, or export them all with their own
-/// export settings.
-fn inspect_assets(app: &mut FigApp, ui: &mut Ui, doc: &Document, assets: &[figcraft_engine::devinspect::Asset]) {
-    let t = Tokens::get(ui.ctx());
-    widgets::separator(ui);
-    let export_all = [(Icon::Export, tr("Export all"))];
-    let all = widgets::section_header(ui, tr("Assets"), if assets.is_empty() { &[] } else { &export_all }, false).is_some();
-    if assets.is_empty() {
-        widgets::note(ui, tr("No assets: no export settings, icons or images. Add export settings in the Design tab."), t.text_secondary);
-        return;
-    }
-    let mut export_all_ids: Option<Vec<NodeId>> = all.then(|| assets.iter().map(|a| a.id).collect());
-    let mut export_one: Option<(NodeId, ExportSetting, String)> = None;
-    let revision = app.session.ds().map(|d| d.revision).unwrap_or(0);
-    let cache_id = Id::unique("inspect_asset_ui");
-    let mut state: AssetUi = ui.data(|d| d.get_temp(cache_id)).unwrap_or_default();
-    if state.revision != revision {
-        state.revision = revision;
-        state.thumbs.clear();
-    }
-    let px = ASSET_THUMB * ui.ctx().pixels_per_point();
-    for a in assets {
-        let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), ASSET_ROW_H), Sense::click());
-        let resp = resp.tip(trf("Export {name}", &[("name", &a.name)]));
-        if resp.hovered() {
-            ui.painter().rect_filled(r.shrink2(vec2(8.0, 1.0)), CornerRadius::same(6), t.hover);
-            icons::paint(ui.painter(), Rect::from_center_size(pos2(r.max.x - PAD - 6.0, r.center().y), vec2(12.0, 12.0)), Icon::Export, t.icon);
-        }
-        // The preview, as exporting it paints it (a slice shows the page under it). Rows scrolled
-        // out of view draw nothing, so they don't pay for a thumbnail either.
-        let thumb = Rect::from_min_size(pos2(r.min.x + PAD, r.center().y - ASSET_THUMB / 2.0), vec2(ASSET_THUMB, ASSET_THUMB));
-        ui.painter().rect_filled(thumb, CornerRadius::same(4), t.field);
-        let tex = if ui.is_rect_visible(r) {
-            state.thumbs.entry(a.id).or_insert_with(|| crate::assets_panel::thumbnail(ui.ctx(), doc, a.id, px)).clone()
-        } else {
-            None
-        };
-        if let Some(tex) = tex {
-            let size = tex.size_vec2();
-            let inner = thumb.shrink(3.0);
-            // Never past 1:1 physical pixels, so small assets stay crisp.
-            let k = (inner.width() / size.x).min(inner.height() / size.y).min(1.0 / ui.ctx().pixels_per_point()).max(0.0);
-            let img = Rect::from_center_size(thumb.center(), size * k);
-            ui.painter().with_clip_rect(inner).image(tex.id(), img, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
-        }
-        ui.painter().rect_stroke(thumb, CornerRadius::same(4), Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
-        // The name, and the format to export it as (its first export setting's, until chosen).
-        let x = thumb.max.x + 10.0;
-        let name_r = Rect::from_min_max(pos2(x, r.min.y + 5.0), pos2(r.max.x - PAD, r.min.y + 27.0));
-        let name = widgets::elide(ui, &a.name, name_r.width());
-        ui.painter().with_clip_rect(name_r).text(pos2(name_r.min.x, name_r.center().y), Align2::LEFT_CENTER, &name, regular(11.0), t.text);
-        let idx = state
-            .formats
-            .get(&a.id)
-            .copied()
-            .filter(|i| *i < ExportFormat::ALL.len())
-            .unwrap_or_else(|| ExportFormat::ALL.iter().position(|f| Some(*f) == a.settings.first().map(|s| s.format)).unwrap_or(0));
-        let fmt = ExportFormat::ALL[idx];
-        let btn = Rect::from_min_size(pos2(x, r.min.y + 31.0), vec2(74.0, 20.0));
-        let btn_resp = ui.interact(btn, Id::unique(("inspect_asset_format", a.id)), Sense::click());
-        a11y::combo(&btn_resp, tr("Format"), fmt.label(), a11y::menu_open(&btn_resp));
-        if btn_resp.hovered() {
-            ui.painter().rect_filled(btn, CornerRadius::same(5), t.field);
-            ui.painter().rect_stroke(btn, CornerRadius::same(5), Stroke::new(1.0, t.field_hover_border), egui::StrokeKind::Inside);
-        } else {
-            ui.painter().rect_filled(btn, CornerRadius::same(5), t.field);
-        }
-        ui.painter().text(pos2(btn.min.x + 8.0, btn.center().y), Align2::LEFT_CENTER, fmt.label(), regular(11.0), t.text);
-        icons::paint(ui.painter(), Rect::from_center_size(pos2(btn.max.x - 9.0, btn.center().y), vec2(10.0, 10.0)), Icon::Chevron, t.icon_secondary);
-        menu_popup(&btn_resp).show(|ui| {
-            for (i, f) in ExportFormat::ALL.iter().enumerate() {
-                if menu_item(ui, f.label(), "") {
-                    state.formats.insert(a.id, i);
-                    ui.close();
-                }
-            }
-        });
-        if resp.clicked() && !btn_resp.hovered() {
-            let mut setting = a.settings.first().cloned().unwrap_or_default();
-            setting.format = fmt;
-            let file = format!("{}{}.{}", a.name.rsplit('/').next().unwrap_or(&a.name), setting.file_suffix(), fmt.ext());
-            export_one = Some((a.id, setting, file));
-        }
-    }
-    ui.data_mut(|d| d.insert_temp(cache_id, state));
-    if let Some(ids) = export_all_ids.take() {
-        crate::export_panel::export_layers(app, &ids, true);
-    } else if let Some((id, setting, file)) = export_one {
-        crate::export_panel::save_one(app, &[id], &setting, &file);
-    }
-    ui.add_space(4.0);
-}
-
-/// The Inspect tab (Dev Mode): the handoff status, annotations, properties, assets and code of
-/// the selected layer, or the list of what's ready for dev.
-fn inspect(app: &mut FigApp, ui: &mut Ui) {
-    let t = Tokens::get(ui.ctx());
-    let Ok(ds) = app.session.ds() else { return };
-    let doc = ds.doc.clone();
-    let sel = ds.selection.clone();
-    let Some(first) = sel.first().copied() else {
-        widgets::section_header(ui, tr("Inspect"), &[], false);
-        widgets::note(ui, tr("Select a layer to see its properties and code"), t.text_secondary);
-        widgets::note(ui, tr("Hover other layers to measure the distance"), t.text_secondary);
-        crate::dev_mode::ready_list(app, ui);
-        crate::dev_mode::categories_section(app, ui);
-        crate::dev_mode::measurements_section(app, ui, &doc, &sel);
-        crate::dev_mode::plugins_section(app, ui);
-        return;
-    };
-    let name = doc.node(first).map(|n| n.name.clone()).unwrap_or_default();
-    widgets::section_header(ui, &name, &[], false);
-    crate::dev_mode::status(app, ui, &doc, &sel);
-    crate::dev_mode::annotations_section(app, ui, &doc, first);
-    crate::dev_mode::dev_resources_section(app, ui, &doc, first);
-    crate::dev_mode::measurements_section(app, ui, &doc, &sel);
-    use figcraft_engine::devinspect::ColorFormat;
-    let fmt_id = Id::unique("inspect_color_format");
-    let fmt = ui.data(|d| d.get_temp::<usize>(fmt_id)).and_then(|i| ColorFormat::ALL.get(i).copied()).unwrap_or_default();
-    row(ui, 32.0, |ui| {
-        widgets::label(ui, tr("Color format"), t.text_secondary);
-        let resp = widgets::dropdown(ui, fmt.label(), 72.0, None);
-        menu_popup(&resp).show(|ui| {
-            for (i, f) in ColorFormat::ALL.iter().enumerate() {
-                if menu_item(ui, f.label(), "") {
-                    ui.data_mut(|d| d.insert_temp(fmt_id, i));
-                    ui.close();
-                }
-            }
-        });
-    });
-    for s in figcraft_engine::devinspect::properties_with(&doc, first, fmt) {
-        inspect_section(app, ui, &s);
-    }
-    inspect_assets(app, ui, &doc, &figcraft_engine::devinspect::assets(&doc, &sel));
-    use figcraft_engine::codegen::CodeLang;
-    let lang_id = Id::unique("inspect_lang");
-    let lang = ui.data(|d| d.get_temp::<usize>(lang_id)).and_then(|i| CodeLang::ALL.get(i).copied()).unwrap_or_default();
-    // A component tried with other property values: its code replaces the layer's below.
-    let played = crate::dev_mode::playground_section(app, ui, &doc, first, lang);
-    widgets::separator(ui);
-    let copy = widgets::section_header(ui, tr("Code"), &[(Icon::Export, tr("Copy"))], false).is_some();
-    // Pixels or rem (of a 16 px root) for the web languages.
-    let rem_id = Id::unique("inspect_rem");
-    let web = lang.is_web();
-    let rem = web && ui.data(|d| d.get_temp::<bool>(rem_id)).unwrap_or(false);
-    row(ui, 32.0, |ui| {
-        let resp = widgets::dropdown(ui, lang.label(), 120.0, Some(Icon::Code));
-        menu_popup(&resp).show(|ui| {
-            for (i, l) in CodeLang::ALL.iter().enumerate() {
-                if menu_item(ui, l.label(), "") {
-                    ui.data_mut(|d| d.insert_temp(lang_id, i));
-                    ui.close();
-                }
-            }
-        });
-        if web {
-            let resp = widgets::dropdown(ui, if rem { "rem" } else { "px" }, 56.0, None);
-            menu_popup(&resp).show(|ui| {
-                for (on, label) in [(false, "px"), (true, "rem")] {
-                    if menu_item(ui, label, "") {
-                        ui.data_mut(|d| d.insert_temp(rem_id, on));
-                        ui.close();
-                    }
-                }
-            });
-        }
-    });
-    let code = played.unwrap_or_else(|| crate::dev_mode::code(app, ui, first, lang));
-    let code = if rem { figcraft_engine::codegen::px_to_rem(&code, 16.0) } else { code };
-    egui::Frame::NONE
-        .fill(t.field)
-        .corner_radius(CornerRadius::same(6))
-        .inner_margin(egui::Margin::same(10))
-        .outer_margin(egui::Margin::symmetric(16, 0))
-        .show(ui, |ui| {
-            ui.label(egui::RichText::new(&code).monospace().color(t.text));
-        });
-    ui.add_space(8.0);
-    let mut copy_clicked = copy;
-    row(ui, 32.0, |ui| {
-        copy_clicked |= ui.button(trf("Copy {value}", &[("value", &lang.label())])).clicked();
-    });
-    if copy_clicked {
-        app.clipboard_set_text(&code);
-        app.toast(trf("Copied {value}", &[("value", &lang.label())]));
-    }
-    crate::dev_mode::connect_section(app, ui, &doc, first, lang);
-    crate::dev_mode::plugins_section(app, ui);
-}
diff --git a/crates/ui-egui/src/panels/right/effects.rs b/crates/ui-egui/src/panels/right/effects.rs
new file mode 100644
index 00000000..ef62bbbc
--- /dev/null
+++ b/crates/ui-egui/src/panels/right/effects.rs
@@ -0,0 +1,541 @@
+use super::menu::{context_popup, menu_check, menu_item, menu_popup, row, row_context_menu, row_rect};
+use super::*;
+
+/// Draw the effect list with add/style/type/toggle/remove/reorder, open settings, and keep an
+/// open picker and settings flags aligned when rows move or are removed.
+pub(super) fn effects(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
+    let ids = sel.to_vec();
+    let list = common(doc, sel, |n| n.effects.clone());
+    let empty = list.as_ref().is_none_or(|l| l.is_empty());
+    let (clicked, header) = widgets::section_header_resp(ui, tr("Effects"), &[(Icon::Styles, tr("Styles")), (Icon::Plus, tr("Add effect"))], empty);
+    if let Some(i) = clicked {
+        if i == 1 {
+            app.run("effect.add", json!({"ids": ids, "type": "dropShadow"}));
+        } else {
+            style_picker::open(app, ui, &ids, StyleSlot::Effect);
+        }
+    }
+    context_popup(&header).show(|ui| {
+        if app.session.clipboard.effect.is_some() && menu_item(ui, tr("Paste effect"), "") {
+            app.run("effect.paste", json!({"ids": ids}));
+            ui.close();
+        }
+    });
+    style_picker::chip(app, ui, doc, &ids, StyleSlot::Effect);
+    let Some(list) = list else { return };
+    let mut drag = ListDrag::new(ui, "effects");
+    let mut removed = None;
+    for (i, e) in list.iter().enumerate().rev() {
+        let mut open = effect_open(ui.ctx(), i);
+        let header = row_rect(ui, 32.0, |ui| {
+            if icons::button(ui, Icon::Effects, 24.0, open, tr("Effect settings")).clicked() {
+                open = !open;
+                ui.data_mut(|d| d.insert_temp(Id::unique((FX_OPEN, i)), open));
+            }
+            let w = ui.available_width() - 56.0;
+            let resp = widgets::dropdown(ui, tr(e.label()), w, None);
+            menu_popup(&resp).show(|ui| {
+                for (l, ty) in Effect::TYPES {
+                    if menu_item(ui, tr(l), "")
+                        && let Some(ne) = Effect::of_type(ty)
+                    {
+                        app.run("effect.set", json!({"ids": ids, "index": i, "effect": ne}));
+                        ui.close();
+                    }
+                }
+            });
+            if icons::button(ui, if e.visible { Icon::Eye } else { Icon::EyeOff }, 24.0, false, tr("Toggle")).clicked() {
+                let mut e2 = e.clone();
+                e2.visible = !e2.visible;
+                app.run("effect.set", json!({"ids": ids, "index": i, "effect": e2}));
+            }
+            if icons::button(ui, Icon::Minus, 24.0, false, tr("Remove")).clicked()
+                && app.run("effect.remove", json!({"ids": ids, "index": i})).is_some()
+            {
+                removed = Some(i);
+            }
+        });
+        let can_paste = app.session.clipboard.effect.is_some();
+        row_context_menu(ui, header, Id::unique(("effect_menu", i))).show(|ui| {
+            if menu_item(ui, tr("Copy effect"), "") {
+                app.run("effect.copy", json!({"ids": ids, "index": i}));
+                ui.close();
+            }
+            if can_paste && menu_item(ui, tr("Paste effect"), "") {
+                app.run("effect.paste", json!({"ids": ids, "index": i}));
+                ui.close();
+            }
+        });
+        if open {
+            effect_settings(app, ui, &ids, i, e);
+        }
+        drag.row(ui, i, header, header.with_max_y(ui.cursor().min.y.max(header.max.y)), || tr(e.label()).to_string());
+    }
+    if let Some((from, to)) = drag.finish(ui) {
+        app.run("effect.move", json!({"ids": ids, "from": from, "to": to}));
+        move_flags(ui, FX_OPEN, list.len(), from, to);
+        if let Some(crate::colorpicker::PickerTarget::Effect { index, .. }) = &mut app.ui.picker {
+            *index = moved_index(*index, from, to);
+        }
+    }
+    // Open settings and an open colour picker stay with their effects, or go with theirs.
+    if let Some(i) = removed {
+        remove_flags(ui, FX_OPEN, list.len(), i);
+        if let Some(crate::colorpicker::PickerTarget::Effect { index, .. }) = &mut app.ui.picker {
+            match removed_index(*index, i) {
+                Some(k) => *index = k,
+                None => app.ui.picker = None,
+            }
+        }
+    }
+}
+
+/// Salt of the flags that keep effect rows' settings open.
+const FX_OPEN: &str = "fx_open";
+
+/// Whether effect `i`'s settings are open in the Design panel.
+pub(crate) fn effect_open(ctx: &egui::Context, i: usize) -> bool {
+    ctx.data(|d| d.get_temp::<bool>(Id::unique((FX_OPEN, i)))).unwrap_or(false)
+}
+
+/// A number field of effect `i` that can be bound to a variable (`effects/<i>/<prop>`).
+fn fx_field(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, prop: &str, lead: Lead, value: f64, width: f32) -> Option<FieldEdit> {
+    crate::variable_ui::number_field(app, ui, ids, &format!("effects/{i}/{prop}"), Id::unique(("fx", prop, i)), lead, Some(value), "", width)
+}
+
+/// Draw type-specific effect fields for shadows, blurs, noise, texture and glass, using live
+/// scrub edits that stay one undo step and bindable colour fields.
+fn effect_settings(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, e: &Effect) {
+    let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
+    let set = |app: &mut FigApp, e2: Effect, scrub: Option<bool>| {
+        let p = json!({"ids": ids, "index": i, "effect": e2});
+        match scrub {
+            None => {
+                app.run("effect.set", p);
+            }
+            Some(done) => {
+                let _ = app.session.begin_interaction("Effect");
+                let _ = app.session.execute("effect.set", &p);
+                if done {
+                    let _ = app.session.commit_interaction();
+                }
+            }
+        }
+    };
+    let edit = |app: &mut FigApp, ed: Option<FieldEdit>, f: &dyn Fn(f64) -> Effect| match ed {
+        Some(FieldEdit::Set(v)) => set(app, f(v), None),
+        Some(FieldEdit::Scrub(v, d)) => set(app, f(v), Some(d)),
+        None => {}
+    };
+    // A new colour for the effect (`secondary`: a duo noise's second colour).
+    let edit_color = |app: &mut FigApp, secondary: bool, c: figcraft_color::Color, scrub: Option<bool>| {
+        let mut e2 = e.clone();
+        if let Some(slot) = e2.color_mut(secondary) {
+            *slot = c;
+        }
+        set(app, e2, scrub);
+    };
+    match &e.kind {
+        EffectKind::DropShadow(s) | EffectKind::InnerShadow(s) => {
+            let inner = matches!(e.kind, EffectKind::InnerShadow(_));
+            let mk = |s2: Shadow| Effect { kind: if inner { EffectKind::InnerShadow(s2) } else { EffectKind::DropShadow(s2) }, visible: e.visible };
+            row(ui, 32.0, |ui| {
+                let ed = fx_field(app, ui, ids, i, "offsetX", Lead::Text("X"), s.offset.0, half);
+                edit(app, ed, &|v| mk(Shadow { offset: (v, s.offset.1), ..s.clone() }));
+                let ed = fx_field(app, ui, ids, i, "offsetY", Lead::Text("Y"), s.offset.1, half);
+                edit(app, ed, &|v| mk(Shadow { offset: (s.offset.0, v), ..s.clone() }));
+            });
+            row(ui, 32.0, |ui| {
+                let ed = fx_field(app, ui, ids, i, "radius", Lead::Text(tr("Blur")), s.radius, half);
+                edit(app, ed, &|v| mk(Shadow { radius: v.max(0.0), ..s.clone() }));
+                let ed = fx_field(app, ui, ids, i, "spread", Lead::Text(tr("Spread")), s.spread, half);
+                edit(app, ed, &|v| mk(Shadow { spread: v, ..s.clone() }));
+            });
+            // The colour: a bound variable's chip, else swatch, hex and alpha with a variable button.
+            let color_field = format!("effects/{i}/color");
+            row(ui, 32.0, |ui| {
+                crate::variable_ui::bindable(app, ui, ids, &color_field, VariableType::Color, half * 2.0 + 8.0, |app, ui| {
+                    fx_color(app, ui, ids, i, e, false, &edit_color)
+                });
+            });
+            if !inner {
+                row(ui, 32.0, |ui| {
+                    if widgets::checkbox(ui, s.show_behind, tr("Show behind transparent areas")) {
+                        set(app, mk(Shadow { show_behind: !s.show_behind, ..s.clone() }), None);
+                    }
+                });
+            }
+        }
+        EffectKind::LayerBlur(b) | EffectKind::BackgroundBlur(b) => {
+            let with = |f: &dyn Fn(&mut Blur)| {
+                let mut e2 = e.clone();
+                if let Some(b2) = e2.blur_mut() {
+                    f(b2);
+                }
+                e2
+            };
+            row(ui, 32.0, |ui| {
+                let resp = widgets::dropdown(ui, tr(b.blur_type.label()), half * 2.0 + 8.0, None);
+                menu_popup(&resp).show(|ui| {
+                    for t in BlurType::ALL {
+                        if menu_item(ui, tr(t.label()), "") {
+                            set(app, with(&|b2| b2.blur_type = t), None);
+                            ui.close();
+                        }
+                    }
+                });
+            });
+            row(ui, 32.0, |ui| {
+                if b.is_progressive() {
+                    // The ramp's start and end points are dragged on the canvas.
+                    let ed = fx_field(app, ui, ids, i, "startRadius", Lead::Text(tr("Start")), b.start_radius, half);
+                    edit(app, ed, &|v| with(&|b2| b2.start_radius = v.clamp(0.0, MAX_BLUR_RADIUS)));
+                    let ed = fx_field(app, ui, ids, i, "radius", Lead::Text(tr("End")), b.radius, half);
+                    edit(app, ed, &|v| with(&|b2| b2.radius = v.clamp(0.0, MAX_BLUR_RADIUS)));
+                } else {
+                    let ed = fx_field(app, ui, ids, i, "radius", Lead::Text(tr("Blur")), b.radius, half * 2.0 + 8.0);
+                    edit(app, ed, &|v| with(&|b2| b2.radius = v.clamp(0.0, MAX_BLUR_RADIUS)));
+                }
+            });
+        }
+        EffectKind::Noise(nz) => {
+            let with = |f: &dyn Fn(&mut Noise)| {
+                tweaked(e, |k| {
+                    if let EffectKind::Noise(n) = k {
+                        f(n);
+                    }
+                })
+            };
+            row(ui, 32.0, |ui| {
+                let resp = widgets::dropdown(ui, tr(nz.mode.label()), half * 2.0 + 8.0, None);
+                menu_popup(&resp).show(|ui| {
+                    for m in NoiseMode::ALL {
+                        if menu_item(ui, tr(m.label()), "") {
+                            set(app, with(&|n| n.mode = m), None);
+                            ui.close();
+                        }
+                    }
+                });
+            });
+            row(ui, 32.0, |ui| {
+                let ed = widgets::number_field(ui, Id::unique(("fx_ns", i)), Lead::Text(tr("Size")), Some(nz.size), "", half, 0.1);
+                edit(app, ed, &|v| {
+                    with(&|n| {
+                        n.size = v.clamp(0.01, 1000.0);
+                        n.size_y = None;
+                    })
+                });
+                let ed = widgets::number_field(
+                    ui,
+                    Id::unique(("fx_nd", i)),
+                    Lead::Text(tr("Density")),
+                    Some((nz.density * 100.0).round()),
+                    "%",
+                    half,
+                    1.0,
+                );
+                edit(app, ed, &|v| with(&|n| n.density = (v / 100.0).clamp(0.0, 1.0)));
+            });
+            match nz.mode {
+                NoiseMode::Mono => row(ui, 32.0, |ui| fx_color(app, ui, ids, i, e, false, &edit_color)),
+                NoiseMode::Duo => {
+                    row(ui, 32.0, |ui| fx_color(app, ui, ids, i, e, false, &edit_color));
+                    row(ui, 32.0, |ui| fx_color(app, ui, ids, i, e, true, &edit_color));
+                }
+                NoiseMode::Multi => row(ui, 32.0, |ui| {
+                    let op = Some((f64::from(nz.opacity) * 100.0).round());
+                    let ed = widgets::number_field(ui, Id::unique(("fx_no", i)), Lead::Text(tr("Opacity")), op, "%", half, 1.0);
+                    edit(app, ed, &|v| with(&|n| n.opacity = (v / 100.0).clamp(0.0, 1.0) as f32));
+                }),
+            }
+        }
+        EffectKind::Texture(tx) => {
+            let with = |f: &dyn Fn(&mut Texture)| {
+                tweaked(e, |k| {
+                    if let EffectKind::Texture(t) = k {
+                        f(t);
+                    }
+                })
+            };
+            row(ui, 32.0, |ui| {
+                let ed = widgets::number_field(ui, Id::unique(("fx_ts", i)), Lead::Text(tr("Size")), Some(tx.size), "", half, 0.1);
+                edit(app, ed, &|v| {
+                    with(&|t| {
+                        t.size = v.clamp(0.01, 1000.0);
+                        t.size_y = None;
+                    })
+                });
+                let ed = widgets::number_field(ui, Id::unique(("fx_tr", i)), Lead::Text(tr("Radius")), Some(tx.radius), "", half, 1.0);
+                edit(app, ed, &|v| with(&|t| t.radius = v.max(0.0)));
+            });
+            row(ui, 32.0, |ui| {
+                if widgets::checkbox(ui, tx.clip_to_shape, tr("Clip to shape")) {
+                    set(app, with(&|t| t.clip_to_shape = !tx.clip_to_shape), None);
+                }
+            });
+        }
+        EffectKind::Glass(g) => {
+            let with = |f: &dyn Fn(&mut Glass)| {
+                tweaked(e, |k| {
+                    if let EffectKind::Glass(gl) = k {
+                        f(gl);
+                    }
+                })
+            };
+            let pct = |v: f64| Some((v * 100.0).round());
+            let unit = |v: f64| (v / 100.0).clamp(0.0, 1.0);
+            row(ui, 32.0, |ui| {
+                let ed =
+                    widgets::number_field(ui, Id::unique(("fx_gl", i)), Lead::Text(tr("Light|glass")), Some(g.light_angle.round()), "°", half, 1.0);
+                edit(app, ed, &|v| with(&|gl| gl.light_angle = v.clamp(-180.0, 180.0)));
+                let ed = widgets::number_field(ui, Id::unique(("fx_gi", i)), Lead::Text(tr("Intensity")), pct(g.light_intensity), "%", half, 1.0);
+                edit(app, ed, &|v| with(&|gl| gl.light_intensity = unit(v)));
+            });
+            row(ui, 32.0, |ui| {
+                let ed = widgets::number_field(ui, Id::unique(("fx_gr", i)), Lead::Text(tr("Refraction")), pct(g.refraction), "%", half, 1.0);
+                edit(app, ed, &|v| with(&|gl| gl.refraction = unit(v)));
+                let ed = widgets::number_field(ui, Id::unique(("fx_gd", i)), Lead::Text(tr("Depth")), Some(g.depth), "", half, 1.0);
+                edit(app, ed, &|v| with(&|gl| gl.depth = v.clamp(1.0, 1000.0)));
+            });
+            row(ui, 32.0, |ui| {
+                let ed = widgets::number_field(ui, Id::unique(("fx_gs", i)), Lead::Text(tr("Dispersion")), pct(g.dispersion), "%", half, 1.0);
+                edit(app, ed, &|v| with(&|gl| gl.dispersion = unit(v)));
+                let ed = widgets::number_field(ui, Id::unique(("fx_gf", i)), Lead::Text(tr("Frost")), Some(g.frost), "", half, 1.0);
+                edit(app, ed, &|v| with(&|gl| gl.frost = v.clamp(0.0, 1000.0)));
+            });
+            row(ui, 32.0, |ui| {
+                let ed = widgets::number_field(ui, Id::unique(("fx_gp", i)), Lead::Text(tr("Splay")), pct(g.splay), "%", half, 1.0);
+                edit(app, ed, &|v| with(&|gl| gl.splay = unit(v)));
+            });
+        }
+    }
+}
+
+/// Applies a new colour to an effect: (app, secondary colour, colour, scrubbing: `Some(done)`).
+type ColorEdit<'a> = dyn Fn(&mut FigApp, bool, figcraft_color::Color, Option<bool>) + 'a;
+
+/// `e` with `f` applied to its kind.
+fn tweaked(e: &Effect, f: impl FnOnce(&mut EffectKind)) -> Effect {
+    let mut e2 = e.clone();
+    f(&mut e2.kind);
+    e2
+}
+
+/// The swatch (opens the colour picker), hex and opacity of effect `i`'s colour (`secondary`: a
+/// duo noise's second colour), in the current row; `edit` applies a new one.
+fn fx_color(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, e: &Effect, secondary: bool, edit: &ColorEdit<'_>) {
+    let Some(c) = e.color(secondary) else { return };
+    if widgets::swatch(ui, &Paint::solid(c), 16.0).clicked() {
+        app.ui.picker = Some(crate::colorpicker::PickerTarget::Effect { ids: ids.to_vec(), index: i, secondary });
+    }
+    if let Some(h) = widgets::text_field(ui, Id::unique(("fx_c", i, secondary)), &c.to_hex(), 80.0, "")
+        && let Some(nc) = figcraft_color::Color::from_hex_or_name(&h)
+    {
+        edit(app, secondary, nc.with_alpha(c.a), None);
+    }
+    let alpha = |v: f64| c.with_alpha((v / 100.0).clamp(0.0, 1.0) as f32);
+    match widgets::number_field(ui, Id::unique(("fx_a", i, secondary)), Lead::None, Some((f64::from(c.a) * 100.0).round()), "%", 56.0, 1.0) {
+        Some(FieldEdit::Set(v)) => edit(app, secondary, alpha(v), None),
+        Some(FieldEdit::Scrub(v, done)) => edit(app, secondary, alpha(v), Some(done)),
+        None => {}
+    }
+}
+
+/// Draw the layout-grid list with add/style/type/toggle/remove/reorder, per-grid settings,
+/// and keep open-settings flags aligned when rows move or are removed.
+pub(super) fn grids(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
+    let ids = sel.to_vec();
+    let list = common(doc, sel, |n| n.grids.clone());
+    let empty = list.as_ref().is_none_or(|l| l.is_empty());
+    if let Some(i) = widgets::section_header(ui, tr("Layout grid"), &[(Icon::Styles, tr("Styles")), (Icon::Plus, tr("Add layout grid"))], empty) {
+        if i == 1 {
+            app.run("grid.add", json!({"ids": ids}));
+        } else {
+            style_picker::open(app, ui, &ids, StyleSlot::Grid);
+        }
+    }
+    style_picker::chip(app, ui, doc, &ids, StyleSlot::Grid);
+    let Some(list) = list else { return };
+    // The last grid first, like paints and effects; rows drag to reorder.
+    let mut drag = ListDrag::new(ui, "grids");
+    let mut removed = None;
+    for (i, g) in list.iter().enumerate().rev() {
+        let open_id = Id::unique(("grid_open", i));
+        let mut open = ui.data(|d| d.get_temp::<bool>(open_id)).unwrap_or(false);
+        let header = row_rect(ui, 32.0, |ui| {
+            if icons::button(ui, Icon::Grid, 24.0, open, tr("Layout grid settings")).clicked() {
+                open = !open;
+                ui.data_mut(|d| d.insert_temp(open_id, open));
+            }
+            let w = ui.available_width() - 56.0;
+            let resp = widgets::dropdown(ui, &grid_label(g), w, None);
+            menu_popup(&resp).width(220.0).show(|ui| {
+                for (l, kind) in [(tr("Grid"), GridKind::Grid), (tr("Columns"), GridKind::Columns), (tr("Rows"), GridKind::Rows)] {
+                    if menu_item(ui, l, "") {
+                        let fresh = match kind {
+                            GridKind::Grid => LayoutGrid::default(),
+                            GridKind::Columns => LayoutGrid::columns(),
+                            GridKind::Rows => LayoutGrid::rows(),
+                        };
+                        app.set_props(&ids, json!({"grids": grids_with(&list, i, |x| *x = fresh)}));
+                        ui.close();
+                    }
+                }
+            });
+            if icons::button(ui, if g.visible { Icon::Eye } else { Icon::EyeOff }, 24.0, false, tr("Toggle")).clicked() {
+                app.set_props(&ids, json!({"grids": grids_with(&list, i, |x| x.visible = !x.visible)}));
+            }
+            if icons::button(ui, Icon::Minus, 24.0, false, tr("Remove")).clicked()
+                && app.run("grid.remove", json!({"ids": ids, "index": i})).is_some()
+            {
+                removed = Some(i);
+            }
+        });
+        if open {
+            grid_settings(app, ui, &ids, &list, i, g);
+        }
+        drag.row(ui, i, header, header.with_max_y(ui.cursor().min.y.max(header.max.y)), || grid_label(g));
+    }
+    if let Some((from, to)) = drag.finish(ui) {
+        app.run("grid.move", json!({"ids": ids, "from": from, "to": to}));
+        move_flags(ui, "grid_open", list.len(), from, to);
+    }
+    // Open settings stay with their grids, or go with theirs.
+    if let Some(i) = removed {
+        remove_flags(ui, "grid_open", list.len(), i);
+    }
+}
+
+/// A layout grid's name in its row ("Grid (10)", "5 columns").
+fn grid_label(g: &LayoutGrid) -> String {
+    match g.kind {
+        GridKind::Grid => trf("Grid ({size})", &[("size", &g.size)]),
+        GridKind::Columns if auto_count(g) => tr("Auto columns").to_string(),
+        GridKind::Rows if auto_count(g) => tr("Auto rows").to_string(),
+        GridKind::Columns => trn("{n} columns", g.count.max(1) as usize, &[]),
+        GridKind::Rows => trn("{n} rows", g.count.max(1) as usize, &[]),
+    }
+}
+
+/// Fixed-size columns or rows counted Auto: as many as fit.
+fn auto_count(g: &LayoutGrid) -> bool {
+    g.count == 0 && g.align != GridAlign::Stretch
+}
+
+/// `list` with grid `i` changed by `f`.
+fn grids_with(list: &[LayoutGrid], i: usize, f: impl FnOnce(&mut LayoutGrid)) -> Vec<LayoutGrid> {
+    let mut gs = list.to_vec();
+    if let Some(g) = gs.get_mut(i) {
+        f(g);
+    }
+    gs
+}
+
+/// Layout grid `i`'s settings: size (grids); count, type, width or height, margin or offset and
+/// gutter (columns and rows); colour. The numbers can be bound to number variables
+/// (`layoutGrids/<i>/<size|count|gutter|offset>`).
+fn grid_settings(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], list: &[LayoutGrid], i: usize, g: &LayoutGrid) {
+    let col = widgets::col_width(ui.available_width());
+    let set = |f: &dyn Fn(&mut LayoutGrid)| json!({"ids": ids, "props": {"grids": grids_with(list, i, f)}});
+    // One bindable number field, applied with `apply` (a scrub is one undo step).
+    let field = |app: &mut FigApp, ui: &mut Ui, name: &str, value: f64, apply: &dyn Fn(&mut LayoutGrid, f64)| {
+        let key = format!("layoutGrids/{i}/{name}");
+        let e = crate::variable_ui::number_field(app, ui, ids, &key, Id::unique(("grid_field", name, i)), Lead::None, Some(value), "", col);
+        app.field_run(e, "node.set", |v| set(&|x| apply(x, v)));
+    };
+    let size = |x: &mut LayoutGrid, v: f64| x.size = v.max(1.0);
+    let offset = |x: &mut LayoutGrid, v: f64| x.offset = v.max(0.0);
+    let gutter = |x: &mut LayoutGrid, v: f64| x.gutter = v.max(0.0);
+    if g.kind == GridKind::Grid {
+        widgets::sublabels(ui, tr("Size"), None);
+        row(ui, 32.0, |ui| field(app, ui, "size", g.size, &size));
+    } else {
+        let cols = g.kind == GridKind::Columns;
+        widgets::sublabels(ui, tr("Count"), Some(tr("Type")));
+        row(ui, 32.0, |ui| {
+            // 0 is Auto for fixed-size columns (rows); a stretched grid has at least one.
+            let count = (!auto_count(g)).then(|| f64::from(g.count.max(1)));
+            let key = format!("layoutGrids/{i}/count");
+            let id = Id::unique(("grid_field", "count", i));
+            // A stretched grid has at least one band, so 0 (Auto) isn't a count it can take.
+            let e = if g.align == GridAlign::Stretch {
+                crate::variable_ui::number_field_or(app, ui, ids, &key, id, count, col, "", Lead::None, "")
+            } else {
+                crate::variable_ui::number_field_auto(app, ui, ids, &key, id, count, col, Lead::None, "")
+            };
+            app.field_run(e, "node.set", |v| {
+                set(&|x| x.count = if x.align == GridAlign::Stretch { v.round().clamp(1.0, 1000.0) } else { v.round().clamp(0.0, 1000.0) } as u32)
+            });
+            let names =
+                if cols { [tr("Stretch"), tr("Left"), tr("Center"), tr("Right")] } else { [tr("Stretch"), tr("Top"), tr("Center"), tr("Bottom")] };
+            let aligns = [GridAlign::Stretch, GridAlign::Min, GridAlign::Center, GridAlign::Max];
+            let cur = aligns.iter().position(|a| *a == g.align).unwrap_or(0);
+            let resp = widgets::dropdown(ui, names.get(cur).copied().unwrap_or_default(), col, None);
+            menu_popup(&resp).show(|ui| {
+                for (k, (name, a)) in names.iter().zip(aligns).enumerate() {
+                    if menu_check(ui, k == cur, name, "") {
+                        // Fixed-size columns need a size of their own.
+                        app.run(
+                            "node.set",
+                            set(&|x| {
+                                x.align = a;
+                                if a != GridAlign::Stretch && !(x.size.is_finite() && x.size > 0.0) {
+                                    x.size = 60.0;
+                                }
+                                if a == GridAlign::Stretch {
+                                    x.count = x.count.max(1);
+                                }
+                            }),
+                        );
+                        ui.close();
+                    }
+                }
+            });
+        });
+        let span = if cols { tr("Width") } else { tr("Height") };
+        match g.align {
+            GridAlign::Stretch => {
+                widgets::sublabels(ui, span, Some(tr("Margin")));
+                row(ui, 32.0, |ui| {
+                    // The frame, divided by the count: shown as Auto and not editable.
+                    ui.add_enabled_ui(false, |ui| {
+                        let auto = widgets::Empty::Text(tr("Auto"));
+                        widgets::number_field_bindable(ui, Id::unique(("grid_field", "size", i)), Lead::Named(span), None, "", col, 1.0, None, auto)
+                    });
+                    field(app, ui, "offset", g.offset, &offset);
+                });
+                widgets::sublabels(ui, tr("Gutter"), None);
+                row(ui, 32.0, |ui| field(app, ui, "gutter", g.gutter, &gutter));
+            }
+            GridAlign::Center => {
+                widgets::sublabels(ui, span, Some(tr("Gutter")));
+                row(ui, 32.0, |ui| {
+                    field(app, ui, "size", g.size, &size);
+                    field(app, ui, "gutter", g.gutter, &gutter);
+                });
+            }
+            GridAlign::Min | GridAlign::Max => {
+                widgets::sublabels(ui, span, Some(tr("Offset")));
+                row(ui, 32.0, |ui| {
+                    field(app, ui, "size", g.size, &size);
+                    field(app, ui, "offset", g.offset, &offset);
+                });
+                widgets::sublabels(ui, tr("Gutter"), None);
+                row(ui, 32.0, |ui| field(app, ui, "gutter", g.gutter, &gutter));
+            }
+        }
+    }
+    // The colour: swatch, hex and alpha.
+    widgets::sublabels(ui, tr("Color"), None);
+    row(ui, 32.0, |ui| {
+        let (sw, _) = ui.allocate_exact_size(vec2(16.0, 16.0), Sense::hover());
+        widgets::paint_swatch(ui.painter(), sw, &Paint::solid(g.color));
+        if let Some(h) = widgets::text_field(ui, Id::unique(("grid_hex", i)), &g.color.to_hex(), 80.0, "")
+            && let Some(c) = figcraft_color::Color::from_hex_or_name(&h)
+        {
+            app.run("node.set", set(&|x| x.color = c.with_alpha(x.color.a)));
+        }
+        let e = widgets::number_field(ui, Id::unique(("grid_alpha", i)), Lead::None, Some((f64::from(g.color.a) * 100.0).round()), "%", 56.0, 1.0);
+        app.field_run(e, "node.set", |v| set(&|x| x.color = x.color.with_alpha((v / 100.0).clamp(0.0, 1.0) as f32)));
+    });
+}
diff --git a/crates/ui-egui/src/panels/right/inspect.rs b/crates/ui-egui/src/panels/right/inspect.rs
new file mode 100644
index 00000000..658028f9
--- /dev/null
+++ b/crates/ui-egui/src/panels/right/inspect.rs
@@ -0,0 +1,269 @@
+use super::menu::{menu_item, menu_popup, row};
+use super::*;
+
+/// One group of inspected properties: label, value (with a swatch for colours) and the style or
+/// variable it comes from. Clicking a row copies its value.
+pub(crate) fn inspect_section(app: &mut FigApp, ui: &mut Ui, s: &figcraft_engine::devinspect::Section) {
+    let t = Tokens::get(ui.ctx());
+    widgets::separator(ui);
+    let (hr, _) = ui.allocate_exact_size(vec2(ui.available_width(), 32.0), Sense::hover());
+    ui.painter().text(pos2(hr.min.x + PAD, hr.center().y), Align2::LEFT_CENTER, tr(s.title), semibold(11.0), t.text);
+    for p in &s.rows {
+        prop_row(app, ui, p);
+    }
+    ui.add_space(4.0);
+}
+
+/// An inspected property row: label, value (with a swatch for colours) and the style or variable
+/// it comes from as a chip. Clicking it copies the value.
+pub(crate) fn prop_row(app: &mut FigApp, ui: &mut Ui, p: &figcraft_engine::devinspect::Prop) {
+    let t = Tokens::get(ui.ctx());
+    let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 26.0), Sense::click());
+    let resp = resp.tip(trf("Copy {value}", &[("value", &p.value)]));
+    if resp.hovered() {
+        ui.painter().rect_filled(r.shrink2(vec2(8.0, 0.0)), CornerRadius::same(5), t.hover);
+    }
+    let painter = ui.painter();
+    // The engine's property labels ("Width") are keys of their own.
+    let label = tr(&p.label);
+    // Elided before the value column (some languages' labels run longer).
+    painter.text(
+        pos2(r.min.x + PAD, r.center().y),
+        Align2::LEFT_CENTER,
+        widgets::elide(ui, label, 96.0 - PAD - 6.0),
+        regular(11.0),
+        t.text_secondary,
+    );
+    // The style or variable, right-aligned as a chip.
+    let mut right = r.max.x - PAD;
+    if let Some(token) = &p.token {
+        let galley = painter.layout_no_wrap(token.clone(), regular(10.0), t.text_secondary);
+        let chip =
+            Rect::from_min_max(pos2((right - galley.size().x - 12.0).max(r.min.x + 196.0), r.center().y - 9.0), pos2(right, r.center().y + 9.0));
+        painter.rect_filled(chip, CornerRadius::same(4), t.field);
+        painter.with_clip_rect(chip.shrink2(vec2(6.0, 0.0))).galley(
+            pos2(chip.min.x + 6.0, chip.center().y - galley.size().y / 2.0),
+            galley,
+            t.text_secondary,
+        );
+        right = chip.min.x - 6.0;
+    }
+    let mut x = r.min.x + 96.0;
+    if let Some(c) = p.color.as_deref().and_then(figcraft_color::Color::from_hex) {
+        let sw = Rect::from_min_size(pos2(x, r.center().y - 6.0), vec2(12.0, 12.0));
+        widgets::paint_swatch(painter, sw, &Paint::solid(c));
+        x += 18.0;
+    }
+    let value_r = Rect::from_min_max(pos2(x, r.min.y), pos2(right.max(x + 10.0), r.max.y));
+    painter.with_clip_rect(value_r).text(pos2(x, r.center().y), Align2::LEFT_CENTER, &p.value, regular(11.0), t.text);
+    if resp.clicked() {
+        app.clipboard_set_text(&p.value);
+        app.toast(trf("Copied {value}", &[("value", &label.to_lowercase())]));
+    }
+}
+
+/// The thumbnails and chosen export formats of the Inspect tab's assets, kept between frames: the
+/// thumbnails until the document changes, the formats for the session.
+#[derive(Clone, Default)]
+struct AssetUi {
+    revision: u64,
+    thumbs: std::collections::HashMap<NodeId, Option<egui::TextureHandle>>,
+    formats: std::collections::HashMap<NodeId, usize>,
+}
+
+/// An asset row's height and its preview's side.
+const ASSET_ROW_H: f32 = 56.0;
+
+const ASSET_THUMB: f32 = 40.0;
+
+/// The selection's assets (layers with export settings, icons, images) as a list of a preview, a
+/// name and a format: click one to export it in that format, or export them all with their own
+/// export settings.
+fn inspect_assets(app: &mut FigApp, ui: &mut Ui, doc: &Document, assets: &[figcraft_engine::devinspect::Asset]) {
+    let t = Tokens::get(ui.ctx());
+    widgets::separator(ui);
+    let export_all = [(Icon::Export, tr("Export all"))];
+    let all = widgets::section_header(ui, tr("Assets"), if assets.is_empty() { &[] } else { &export_all }, false).is_some();
+    if assets.is_empty() {
+        widgets::note(ui, tr("No assets: no export settings, icons or images. Add export settings in the Design tab."), t.text_secondary);
+        return;
+    }
+    let mut export_all_ids: Option<Vec<NodeId>> = all.then(|| assets.iter().map(|a| a.id).collect());
+    let mut export_one: Option<(NodeId, ExportSetting, String)> = None;
+    let revision = app.session.ds().map(|d| d.revision).unwrap_or(0);
+    let cache_id = Id::unique("inspect_asset_ui");
+    let mut state: AssetUi = ui.data(|d| d.get_temp(cache_id)).unwrap_or_default();
+    if state.revision != revision {
+        state.revision = revision;
+        state.thumbs.clear();
+    }
+    let px = ASSET_THUMB * ui.ctx().pixels_per_point();
+    for a in assets {
+        let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), ASSET_ROW_H), Sense::click());
+        let resp = resp.tip(trf("Export {name}", &[("name", &a.name)]));
+        if resp.hovered() {
+            ui.painter().rect_filled(r.shrink2(vec2(8.0, 1.0)), CornerRadius::same(6), t.hover);
+            icons::paint(ui.painter(), Rect::from_center_size(pos2(r.max.x - PAD - 6.0, r.center().y), vec2(12.0, 12.0)), Icon::Export, t.icon);
+        }
+        // The preview, as exporting it paints it (a slice shows the page under it). Rows scrolled
+        // out of view draw nothing, so they don't pay for a thumbnail either.
+        let thumb = Rect::from_min_size(pos2(r.min.x + PAD, r.center().y - ASSET_THUMB / 2.0), vec2(ASSET_THUMB, ASSET_THUMB));
+        ui.painter().rect_filled(thumb, CornerRadius::same(4), t.field);
+        let tex = if ui.is_rect_visible(r) {
+            state.thumbs.entry(a.id).or_insert_with(|| crate::assets_panel::thumbnail(ui.ctx(), doc, a.id, px)).clone()
+        } else {
+            None
+        };
+        if let Some(tex) = tex {
+            let size = tex.size_vec2();
+            let inner = thumb.shrink(3.0);
+            // Never past 1:1 physical pixels, so small assets stay crisp.
+            let k = (inner.width() / size.x).min(inner.height() / size.y).min(1.0 / ui.ctx().pixels_per_point()).max(0.0);
+            let img = Rect::from_center_size(thumb.center(), size * k);
+            ui.painter().with_clip_rect(inner).image(tex.id(), img, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+        }
+        ui.painter().rect_stroke(thumb, CornerRadius::same(4), Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
+        // The name, and the format to export it as (its first export setting's, until chosen).
+        let x = thumb.max.x + 10.0;
+        let name_r = Rect::from_min_max(pos2(x, r.min.y + 5.0), pos2(r.max.x - PAD, r.min.y + 27.0));
+        let name = widgets::elide(ui, &a.name, name_r.width());
+        ui.painter().with_clip_rect(name_r).text(pos2(name_r.min.x, name_r.center().y), Align2::LEFT_CENTER, &name, regular(11.0), t.text);
+        let idx = state
+            .formats
+            .get(&a.id)
+            .copied()
+            .filter(|i| *i < ExportFormat::ALL.len())
+            .unwrap_or_else(|| ExportFormat::ALL.iter().position(|f| Some(*f) == a.settings.first().map(|s| s.format)).unwrap_or(0));
+        let fmt = ExportFormat::ALL[idx];
+        let btn = Rect::from_min_size(pos2(x, r.min.y + 31.0), vec2(74.0, 20.0));
+        let btn_resp = ui.interact(btn, Id::unique(("inspect_asset_format", a.id)), Sense::click());
+        a11y::combo(&btn_resp, tr("Format"), fmt.label(), a11y::menu_open(&btn_resp));
+        if btn_resp.hovered() {
+            ui.painter().rect_filled(btn, CornerRadius::same(5), t.field);
+            ui.painter().rect_stroke(btn, CornerRadius::same(5), Stroke::new(1.0, t.field_hover_border), egui::StrokeKind::Inside);
+        } else {
+            ui.painter().rect_filled(btn, CornerRadius::same(5), t.field);
+        }
+        ui.painter().text(pos2(btn.min.x + 8.0, btn.center().y), Align2::LEFT_CENTER, fmt.label(), regular(11.0), t.text);
+        icons::paint(ui.painter(), Rect::from_center_size(pos2(btn.max.x - 9.0, btn.center().y), vec2(10.0, 10.0)), Icon::Chevron, t.icon_secondary);
+        menu_popup(&btn_resp).show(|ui| {
+            for (i, f) in ExportFormat::ALL.iter().enumerate() {
+                if menu_item(ui, f.label(), "") {
+                    state.formats.insert(a.id, i);
+                    ui.close();
+                }
+            }
+        });
+        if resp.clicked() && !btn_resp.hovered() {
+            let mut setting = a.settings.first().cloned().unwrap_or_default();
+            setting.format = fmt;
+            let file = format!("{}{}.{}", a.name.rsplit('/').next().unwrap_or(&a.name), setting.file_suffix(), fmt.ext());
+            export_one = Some((a.id, setting, file));
+        }
+    }
+    ui.data_mut(|d| d.insert_temp(cache_id, state));
+    if let Some(ids) = export_all_ids.take() {
+        crate::export_panel::export_layers(app, &ids, true);
+    } else if let Some((id, setting, file)) = export_one {
+        crate::export_panel::save_one(app, &[id], &setting, &file);
+    }
+    ui.add_space(4.0);
+}
+
+/// The Inspect tab (Dev Mode): the handoff status, annotations, properties, assets and code of
+/// the selected layer, or the list of what's ready for dev.
+pub(super) fn inspect(app: &mut FigApp, ui: &mut Ui) {
+    let t = Tokens::get(ui.ctx());
+    let Ok(ds) = app.session.ds() else { return };
+    let doc = ds.doc.clone();
+    let sel = ds.selection.clone();
+    let Some(first) = sel.first().copied() else {
+        widgets::section_header(ui, tr("Inspect"), &[], false);
+        widgets::note(ui, tr("Select a layer to see its properties and code"), t.text_secondary);
+        widgets::note(ui, tr("Hover other layers to measure the distance"), t.text_secondary);
+        crate::dev_mode::ready_list(app, ui);
+        crate::dev_mode::categories_section(app, ui);
+        crate::dev_mode::measurements_section(app, ui, &doc, &sel);
+        crate::dev_mode::plugins_section(app, ui);
+        return;
+    };
+    let name = doc.node(first).map(|n| n.name.clone()).unwrap_or_default();
+    widgets::section_header(ui, &name, &[], false);
+    crate::dev_mode::status(app, ui, &doc, &sel);
+    crate::dev_mode::annotations_section(app, ui, &doc, first);
+    crate::dev_mode::dev_resources_section(app, ui, &doc, first);
+    crate::dev_mode::measurements_section(app, ui, &doc, &sel);
+    use figcraft_engine::devinspect::ColorFormat;
+    let fmt_id = Id::unique("inspect_color_format");
+    let fmt = ui.data(|d| d.get_temp::<usize>(fmt_id)).and_then(|i| ColorFormat::ALL.get(i).copied()).unwrap_or_default();
+    row(ui, 32.0, |ui| {
+        widgets::label(ui, tr("Color format"), t.text_secondary);
+        let resp = widgets::dropdown(ui, fmt.label(), 72.0, None);
+        menu_popup(&resp).show(|ui| {
+            for (i, f) in ColorFormat::ALL.iter().enumerate() {
+                if menu_item(ui, f.label(), "") {
+                    ui.data_mut(|d| d.insert_temp(fmt_id, i));
+                    ui.close();
+                }
+            }
+        });
+    });
+    for s in figcraft_engine::devinspect::properties_with(&doc, first, fmt) {
+        inspect_section(app, ui, &s);
+    }
+    inspect_assets(app, ui, &doc, &figcraft_engine::devinspect::assets(&doc, &sel));
+    use figcraft_engine::codegen::CodeLang;
+    let lang_id = Id::unique("inspect_lang");
+    let lang = ui.data(|d| d.get_temp::<usize>(lang_id)).and_then(|i| CodeLang::ALL.get(i).copied()).unwrap_or_default();
+    // A component tried with other property values: its code replaces the layer's below.
+    let played = crate::dev_mode::playground_section(app, ui, &doc, first, lang);
+    widgets::separator(ui);
+    let copy = widgets::section_header(ui, tr("Code"), &[(Icon::Export, tr("Copy"))], false).is_some();
+    // Pixels or rem (of a 16 px root) for the web languages.
+    let rem_id = Id::unique("inspect_rem");
+    let web = lang.is_web();
+    let rem = web && ui.data(|d| d.get_temp::<bool>(rem_id)).unwrap_or(false);
+    row(ui, 32.0, |ui| {
+        let resp = widgets::dropdown(ui, lang.label(), 120.0, Some(Icon::Code));
+        menu_popup(&resp).show(|ui| {
+            for (i, l) in CodeLang::ALL.iter().enumerate() {
+                if menu_item(ui, l.label(), "") {
+                    ui.data_mut(|d| d.insert_temp(lang_id, i));
+                    ui.close();
+                }
+            }
+        });
+        if web {
+            let resp = widgets::dropdown(ui, if rem { "rem" } else { "px" }, 56.0, None);
+            menu_popup(&resp).show(|ui| {
+                for (on, label) in [(false, "px"), (true, "rem")] {
+                    if menu_item(ui, label, "") {
+                        ui.data_mut(|d| d.insert_temp(rem_id, on));
+                        ui.close();
+                    }
+                }
+            });
+        }
+    });
+    let code = played.unwrap_or_else(|| crate::dev_mode::code(app, ui, first, lang));
+    let code = if rem { figcraft_engine::codegen::px_to_rem(&code, 16.0) } else { code };
+    egui::Frame::NONE
+        .fill(t.field)
+        .corner_radius(CornerRadius::same(6))
+        .inner_margin(egui::Margin::same(10))
+        .outer_margin(egui::Margin::symmetric(16, 0))
+        .show(ui, |ui| {
+            ui.label(egui::RichText::new(&code).monospace().color(t.text));
+        });
+    ui.add_space(8.0);
+    let mut copy_clicked = copy;
+    row(ui, 32.0, |ui| {
+        copy_clicked |= ui.button(trf("Copy {value}", &[("value", &lang.label())])).clicked();
+    });
+    if copy_clicked {
+        app.clipboard_set_text(&code);
+        app.toast(trf("Copied {value}", &[("value", &lang.label())]));
+    }
+    crate::dev_mode::connect_section(app, ui, &doc, first, lang);
+    crate::dev_mode::plugins_section(app, ui);
+}
diff --git a/crates/ui-egui/src/panels/right/menu.rs b/crates/ui-egui/src/panels/right/menu.rs
new file mode 100644
index 00000000..fed4a960
--- /dev/null
+++ b/crates/ui-egui/src/panels/right/menu.rs
@@ -0,0 +1,135 @@
+use super::*;
+
+/// The smallest width a popup menu is measured in (see [`menu_popup`]).
+const MENU_MIN_W: f32 = 48.0;
+
+/// A menu row's inset either side, and the gap between its label and its shortcut or art.
+const MENU_PAD: f32 = 8.0;
+
+const MENU_GAP: f32 = 24.0;
+
+/// The style of popup menus: egui's, with text kept on one line (a menu grows to its widest item).
+pub(crate) fn menu_style(s: &mut egui::Style) {
+    egui::containers::menu::menu_style(s);
+    s.wrap_mode = Some(egui::TextWrapMode::Extend);
+}
+
+/// The menu a dropdown or button opens: as wide as its widest row and at least as wide as
+/// `anchor`. egui measures a popup in a first, invisible pass as wide as the width it is given
+/// (else its 600 px default area width) and keeps the size measured; rows ([`menu_row`]) take the
+/// larger of that width and their content, so the menu fits its content. Chain `.width(w)` for a
+/// menu at least `w` wide.
+/// The blend modes as menu items in groups (pass-through only for layers); the one picked.
+pub fn blend_menu(ui: &mut Ui, with_pass_through: bool) -> Option<BlendMode> {
+    let mut picked = None;
+    for b in BlendMode::ALL.into_iter().filter(|b| with_pass_through || *b != BlendMode::PassThrough) {
+        if menu_item(ui, tr(b.label()), "") {
+            picked = Some(b);
+            ui.close();
+        }
+        if matches!(b, BlendMode::Normal | BlendMode::ColorBurn | BlendMode::ColorDodge | BlendMode::HardLight | BlendMode::Exclusion) {
+            ui.separator();
+        }
+    }
+    picked
+}
+
+pub fn menu_popup(anchor: &egui::Response) -> egui::Popup<'static> {
+    egui::Popup::menu(anchor).width(anchor.rect.width().max(MENU_MIN_W)).style(menu_style)
+}
+
+/// A context menu (secondary click on `resp`) sized like [`menu_popup`].
+pub fn context_popup(resp: &egui::Response) -> egui::Popup<'static> {
+    egui::Popup::context_menu(resp).width(MENU_MIN_W).style(menu_style)
+}
+
+/// A context menu for a property row: a secondary click anywhere over `rect` opens it, even over
+/// the row's fields (which would otherwise take the click), like the incumbent's row menus.
+pub(super) fn row_context_menu(ui: &Ui, rect: Rect, id: Id) -> egui::Popup<'static> {
+    let resp = ui.interact(rect, id, Sense::hover());
+    let open = ui.rect_contains_pointer(rect) && ui.input(|i| i.pointer.secondary_clicked());
+    let at_pointer = egui::Popup::menu(&resp).width(MENU_MIN_W).style(menu_style).at_pointer_fixed();
+    at_pointer.open_memory(open.then_some(egui::SetOpenCommand::Bool(true)))
+}
+
+pub fn menu_item(ui: &mut Ui, label: &str, shortcut: &str) -> bool {
+    menu_row(ui, label, shortcut, 0.0, |_, _, _| {}).clicked()
+}
+
+/// A menu row with art drawn into it after the label (`art(painter, row rect, text colour)`),
+/// taking `art_w` from the row's right edge.
+pub fn menu_item_with(ui: &mut Ui, label: &str, shortcut: &str, art_w: f32, art: impl FnOnce(&egui::Painter, Rect, Color32)) -> bool {
+    menu_row(ui, label, shortcut, art_w, art).clicked()
+}
+
+/// The width a menu row needs for a label `label_w` wide and, at its right end, a shortcut or
+/// art `trail` wide (0 for neither).
+pub(crate) fn menu_row_width(label_w: f32, trail: f32) -> f32 {
+    MENU_PAD + label_w + if trail > 0.0 { MENU_GAP + trail } else { MENU_PAD }
+}
+
+/// A menu row (see [`menu_item_with`]); its response tells hovering too. It spans the menu and
+/// is at least as wide as its label, shortcut and art.
+pub fn menu_row(ui: &mut Ui, label: &str, shortcut: &str, art_w: f32, art: impl FnOnce(&egui::Painter, Rect, Color32)) -> egui::Response {
+    let t = Tokens::get(ui.ctx());
+    let text = ui.painter().layout_no_wrap(label.to_owned(), regular(11.5), Color32::PLACEHOLDER);
+    let keys =
+        (!shortcut.is_empty()).then(|| ui.painter().layout_no_wrap(crate::toolbar::pretty_shortcut(shortcut), regular(11.0), Color32::PLACEHOLDER));
+    let trail = keys.as_ref().map_or(0.0, |k| k.size().x + MENU_PAD).max(art_w);
+    let w = ui.available_width().max(menu_row_width(text.size().x, trail).ceil());
+    let (r, resp) = ui.allocate_exact_size(vec2(w, 26.0), Sense::click());
+    a11y::menu_item(&resp, label, shortcut, None);
+    // The keyboard's item is highlighted like the hovered one.
+    a11y::own_focus(&resp);
+    let hovered = resp.hovered() || resp.has_focus();
+    if hovered {
+        ui.painter().rect_filled(r, CornerRadius::same(5), t.menu_hover);
+    }
+    // These menus sit on the theme's popup fill (white in the light theme), not on the dark
+    // `t.menu` of the menu bar: the theme's text, white only on the green highlight (#972).
+    let col = if hovered { t.menu_text } else { t.text };
+    ui.painter().galley(pos2(r.min.x + MENU_PAD, r.center().y - text.size().y / 2.0), text, col);
+    if let Some(k) = keys {
+        let at = pos2(r.max.x - MENU_PAD - k.size().x, r.center().y - k.size().y / 2.0);
+        ui.painter().galley(at, k, if hovered { t.menu_text } else { t.text_secondary });
+    }
+    art(ui.painter(), r, col);
+    resp
+}
+
+/// A menu item with a check mark when `on` (the unchecked ones line up with it).
+pub fn menu_check(ui: &mut Ui, on: bool, label: &str, shortcut: &str) -> bool {
+    marked_row(ui, Some(on), label, shortcut)
+}
+
+/// A plain menu item lined up with the check items above or below it.
+pub fn menu_item_beside_checks(ui: &mut Ui, label: &str, shortcut: &str) -> bool {
+    marked_row(ui, None, label, shortcut)
+}
+
+fn marked_row(ui: &mut Ui, on: Option<bool>, label: &str, shortcut: &str) -> bool {
+    let resp = menu_row(ui, &format!("{}{label}", if on == Some(true) { "✓ " } else { "    " }), shortcut, 0.0, |_, _, _| {});
+    a11y::menu_item(&resp, label, shortcut, on);
+    resp.clicked()
+}
+
+pub(crate) fn row(ui: &mut Ui, h: f32, add: impl FnOnce(&mut Ui)) {
+    row_rect(ui, h, add);
+}
+
+/// [`row`], returning the area the row takes.
+pub(crate) fn row_rect(ui: &mut Ui, h: f32, add: impl FnOnce(&mut Ui)) -> Rect {
+    block(ui, h, (h - FIELD_H) / 2.0, add)
+}
+
+/// A panel row `h` tall whose content is inset `inset_y` from its top and bottom (for content
+/// taller than one field); returns the area the row takes.
+pub(crate) fn block(ui: &mut Ui, h: f32, inset_y: f32, add: impl FnOnce(&mut Ui)) -> Rect {
+    let w = ui.available_width();
+    let (r, _) = ui.allocate_exact_size(vec2(w, h), Sense::hover());
+    let mut child =
+        ui.new_child(egui::UiBuilder::new().max_rect(r.shrink2(vec2(PAD, inset_y))).layout(egui::Layout::left_to_right(egui::Align::Center)));
+    child.spacing_mut().item_spacing = vec2(8.0, 0.0);
+    add(&mut child);
+    r
+}
diff --git a/crates/ui-egui/src/panels/right/paints.rs b/crates/ui-egui/src/panels/right/paints.rs
new file mode 100644
index 00000000..66db55dd
--- /dev/null
+++ b/crates/ui-egui/src/panels/right/paints.rs
@@ -0,0 +1,553 @@
+use super::menu::{blend_menu, context_popup, menu_check, menu_item, menu_popup, row, row_context_menu, row_rect};
+use super::stroke::stroke_settings;
+use super::*;
+
+/// Draw visibility/blend/mask, opacity, uniform or per-corner radius, corner smoothing and
+/// the blend-mode row.
+pub(super) fn appearance(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
+    let ids = sel.to_vec();
+    let visible = common(doc, sel, |n| n.visible).unwrap_or(true);
+    let hdr = widgets::section_header(
+        ui,
+        tr("Appearance"),
+        &[
+            (if visible { Icon::Eye } else { Icon::EyeOff }, crate::shortcuts::tip(tr("Show/Hide"), "object.toggleVisible")),
+            (Icon::Variable, tr("Apply variable to visibility")),
+            (Icon::Blend, tr("Blend mode")),
+        ],
+        false,
+    );
+    if hdr == Some(0) {
+        app.run("object.toggleVisible", json!({"ids": ids}));
+    }
+    if hdr == Some(1) {
+        crate::variable_ui::open_at_pointer(ui, &ids, "visible", VariableType::Boolean);
+    }
+    if hdr == Some(2) {
+        ui.data_mut(|d| d.insert_temp(Id::unique("blend_open"), !d.get_temp::<bool>(Id::unique("blend_open")).unwrap_or(false)));
+    }
+    let col = widgets::col_width(ui.available_width());
+    crate::variable_ui::bound_row(app, ui, &ids, "visible", VariableType::Boolean, Lead::Icon(Icon::Eye, tr("Visible")), col * 2.0 + 8.0);
+    // Masks: how they mask.
+    if sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.is_mask)) {
+        let mt = common(doc, sel, |n| n.mask_type);
+        widgets::sublabels(ui, tr("Mask"), None);
+        row(ui, 32.0, |ui| {
+            let resp = widgets::dropdown(ui, mt.map(|m| tr(m.label())).unwrap_or(tr("Mixed")), col * 2.0 + 8.0, Some(Icon::Mask));
+            menu_popup(&resp).show(|ui| {
+                for m in MaskType::ALL {
+                    if menu_item(ui, tr(m.label()), "") {
+                        app.set_props(&ids, json!({"maskType": m.id()}));
+                        ui.close();
+                    }
+                }
+            });
+        });
+    }
+    let op_of = |n: &Node| (f64::from(n.opacity) * 100.0).round();
+    let op = common(doc, sel, op_of);
+    let radius_ok = sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.has_corner_radius()));
+    // Only rectangles and frames round each corner on its own.
+    let indep_ok = radius_ok && sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.has_independent_corners()));
+    // For polygons and stars the same panel holds only the Corner smoothing row.
+    let smooth_ok = radius_ok && sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.has_corner_smoothing()));
+    let r = common(doc, sel, |n| n.corners.uniform().map(|r| (r * 100.0).round() / 100.0));
+    widgets::sublabels(ui, tr("Opacity"), radius_ok.then_some(tr("Corner radius")));
+    row(ui, 32.0, |ui| {
+        let lead = Lead::Icon(Icon::Opacity, tr("Opacity"));
+        let e = crate::variable_ui::number_field_mixed(app, ui, &ids, "opacity", Id::unique("ap_op"), lead, op, "%", col);
+        app.field_of(&ids, "opacity", e, op_of, |v| json!((v / 100.0).clamp(0.0, 1.0)));
+        if radius_ok {
+            let e = crate::variable_ui::number_field_mixed(
+                app,
+                ui,
+                &ids,
+                "cornerRadius",
+                Id::unique("ap_rad"),
+                Lead::Icon(Icon::CornerRadius, tr("Corner radius")),
+                r.flatten(),
+                "",
+                col,
+            );
+            // A layer with corners of its own starts from its largest.
+            let radius_of = |n: &Node| n.corners.uniform().unwrap_or_else(|| n.corners.radii.iter().copied().fold(0.0, f64::max));
+            app.field_of(&ids, "cornerRadius", e, radius_of, |v| json!(v.max(0.0)));
+            let open = ui.data(|d| d.get_temp::<bool>(Id::unique("indep_corners"))).unwrap_or(false);
+            // Polygons and stars have no corners of their own: the button opens only Corner smoothing.
+            let tip = if indep_ok { tr("Individual corners") } else { tr("Corner smoothing") };
+            if smooth_ok && icons::button(ui, Icon::IndependentCorners, 24.0, open, tip).clicked() {
+                ui.data_mut(|d| d.insert_temp(Id::unique("indep_corners"), !open));
+            }
+        }
+    });
+    if smooth_ok && ui.data(|d| d.get_temp::<bool>(Id::unique("indep_corners"))).unwrap_or(false) {
+        let radii = common(doc, sel, |n| n.corners.radii);
+        // `k` indexes `radii` ([top left, top right, bottom right, bottom left]); the fields sit
+        // where their corners are: top left, top right / bottom left, bottom right.
+        let corners = [
+            ("topLeftRadius", tr("Top left radius"), Icon::CornerTopLeft, 0),
+            ("topRightRadius", tr("Top right radius"), Icon::CornerTopRight, 1),
+            ("bottomLeftRadius", tr("Bottom left radius"), Icon::CornerBottomLeft, 3),
+            ("bottomRightRadius", tr("Bottom right radius"), Icon::CornerBottomRight, 2),
+        ];
+        // Polygons and stars have one radius, so no field per corner.
+        for pair in corners.chunks(2).filter(|_| indep_ok) {
+            row(ui, 32.0, |ui| {
+                for (key, name, icon, k) in pair {
+                    let e = crate::variable_ui::number_field(
+                        app,
+                        ui,
+                        &ids,
+                        key,
+                        Id::unique(("corner", *k)),
+                        Lead::Icon(*icon, name),
+                        radii.map(|r| r[*k]),
+                        "",
+                        col,
+                    );
+                    app.field(&ids, key, e, |v| json!(v.max(0.0)));
+                }
+            });
+        }
+        let sm = common(doc, sel, |n| (n.corners.smoothing * 100.0).round());
+        widgets::sublabels(ui, tr("Corner smoothing"), None);
+        row(ui, 32.0, |ui| {
+            let e = widgets::number_field(ui, Id::unique("smoothing"), Lead::None, sm, "%", col, 1.0);
+            app.field(&ids, "cornerSmoothing", e, |v| json!((v / 100.0).clamp(0.0, 1.0)));
+            if widgets::button(ui, tr("iOS"), false, true).on_hover_text(tr("Set corner smoothing to 60%")).clicked() {
+                app.set_props(&ids, json!({"cornerSmoothing": 0.6}));
+            }
+        });
+    }
+    let blend = common(doc, sel, |n| n.blend);
+    let show_blend = ui.data(|d| d.get_temp::<bool>(Id::unique("blend_open"))).unwrap_or(false)
+        || blend.is_some_and(|b| !matches!(b, BlendMode::Normal | BlendMode::PassThrough));
+    if show_blend {
+        widgets::sublabels(ui, tr("Blend mode"), None);
+        row(ui, 32.0, |ui| {
+            let label = blend.map(|b| tr(b.label())).unwrap_or(tr("Mixed"));
+            let resp = widgets::dropdown(ui, label, col * 2.0 + 8.0, Some(Icon::Blend));
+            menu_popup(&resp).width(200.0).show(|ui| {
+                if let Some(b) = blend_menu(ui, true) {
+                    app.set_props(&ids, json!({"blend": b.label()}));
+                }
+            });
+        });
+    }
+    ui.add_space(8.0);
+}
+
+/// The variable modes of the selected frames (sections, components, instances): a row per
+/// collection with more than one mode, Auto (the mode the layer inherits from its parent) or a mode
+/// of its own (`variable.setMode`). Collections from enabled libraries follow under their
+/// library's name (`library.setVariableMode` copies the collection in). Returns whether it showed.
+pub(super) fn variable_modes(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) -> bool {
+    if !sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.is_frame_like())) {
+        return false;
+    }
+    let libs = crate::variable_ui::libraries(app, doc);
+    let rows = crate::variable_ui::mode_rows(doc, &libs);
+    if rows.is_empty() {
+        return false;
+    }
+    let t = Tokens::get(ui.ctx());
+    widgets::section_header(ui, tr("Variable modes"), &[], false);
+    // The collection's name, then a wider mode picker ("Auto (Light)") across both field columns.
+    let col = widgets::col_width(ui.available_width());
+    let (name_w, pick_w) = ((col * 0.7).round(), (col * 1.3).round());
+    // Auto resolves as for the first selected layer: from its parent, or an instance's main.
+    let parent_modes = sel.first().map(|i| doc.inherited_modes(*i)).unwrap_or_default();
+    let mut group = None;
+    for r in &rows {
+        let c = r.coll;
+        // Library collections under their library's name.
+        if r.library != group {
+            group = r.library;
+            if let Some((_, lib)) = r.library {
+                widgets::sublabels(ui, lib, None);
+            }
+        }
+        let name_of = |m: &str| c.modes.iter().find(|x| x.id == m).map_or("", |x| x.name.as_str());
+        // Each layer's own mode (None: Auto); None overall when they differ.
+        let own = match r.local {
+            Some(l) => common(doc, sel, |n| n.var_modes.get(l).cloned()),
+            None => Some(None),
+        };
+        let inherited = r.local.and_then(|l| parent_modes.get(l)).or(c.default_mode()).map_or("", |m| name_of(m));
+        let auto = trf("Auto ({mode})", &[("mode", &inherited)]);
+        let label = match &own {
+            Some(Some(m)) => name_of(m).to_string(),
+            Some(None) => auto.clone(),
+            None => tr("Mixed").into(),
+        };
+        let hover = match r.library {
+            Some((_, lib)) => trf("{name} (from {library})", &[("name", &c.name), ("library", &lib)]),
+            None => c.name.clone(),
+        };
+        row(ui, 32.0, |ui| {
+            let (rect, _) = ui.allocate_exact_size(vec2(name_w, FIELD_H), Sense::hover());
+            let name = widgets::elide(ui, &c.name, name_w);
+            ui.painter().text(pos2(rect.min.x, rect.center().y), Align2::LEFT_CENTER, &name, regular(11.0), t.text);
+            if name != c.name || r.library.is_some() {
+                ui.interact(rect, Id::unique(("var_mode_name", &c.id)), Sense::hover()).on_hover_text(&hover);
+            }
+            let resp = widgets::dropdown(ui, &label, pick_w, None);
+            menu_popup(&resp).width(180.0).show(|ui| {
+                let mut pick = None;
+                if menu_check(ui, own == Some(None), &auto, "") {
+                    pick = Some(Value::Null);
+                }
+                ui.separator();
+                for m in &c.modes {
+                    if menu_check(ui, own.as_ref().is_some_and(|o| o.as_ref() == Some(&m.id)), &m.name, "") {
+                        pick = Some(json!(m.id));
+                    }
+                }
+                if let Some(mode) = pick {
+                    set_variable_mode(app, sel, r, mode);
+                    ui.close();
+                }
+            });
+        });
+    }
+    ui.add_space(8.0);
+    true
+}
+
+/// Set `sel`'s mode of the collection of `row` (`mode` null: Auto). A library collection goes
+/// through `library.setVariableMode` (copying it in); Auto on one never used here is already so.
+fn set_variable_mode(app: &mut FigApp, sel: &[NodeId], row: &crate::variable_ui::ModeRow, mode: Value) {
+    match (row.library, row.key, row.local) {
+        (Some((lib, _)), Some(key), _) if !mode.is_null() => {
+            app.run("library.setVariableMode", json!({"library": lib, "collection": key, "ids": sel, "mode": mode}));
+        }
+        (_, _, Some(local)) => {
+            app.run("variable.setMode", json!({"ids": sel, "collection": local, "mode": mode}));
+        }
+        _ => {}
+    }
+}
+
+/// While a range of text is selected, the Fill section edits that range's colour.
+fn range_fill(app: &mut FigApp, ui: &mut Ui, doc: &Document, id: NodeId, start: usize, end: usize) {
+    let t = Tokens::get(ui.ctx());
+    widgets::section_header(ui, tr("Fill"), &[], false);
+    // The fills over the range, if every character shares them.
+    let fills: Option<Vec<Paint>> = doc.node(id).and_then(|n| n.kind.text().map(|tx| (n, tx))).and_then(|(n, tx)| {
+        let mut it =
+            tx.spans().into_iter().filter(|(s, e, _)| *s < end && *e > start).map(|(_, _, st)| st.fills.clone().unwrap_or_else(|| n.fills.clone()));
+        let first = it.next()?;
+        it.all(|f| f == first).then_some(first)
+    });
+    row(ui, 32.0, |ui| {
+        let w = ui.available_width() - 28.0;
+        let (r, _) = ui.allocate_exact_size(vec2(w, FIELD_H), Sense::hover());
+        ui.painter().rect_filled(r, CornerRadius::same(5), t.field);
+        let sw = Rect::from_min_size(pos2(r.min.x + 4.0, r.center().y - 8.0), vec2(16.0, 16.0));
+        let text_r = Rect::from_min_max(pos2(sw.max.x + 8.0, r.min.y), pos2(r.max.x - 4.0, r.max.y));
+        match fills.as_ref().and_then(|f| f.first()) {
+            Some(p) => {
+                widgets::paint_swatch(ui.painter(), sw, p);
+                if ui.interact(sw.expand(2.0), Id::unique("range_swatch"), Sense::click()).clicked() {
+                    app.ui.picker = Some(crate::colorpicker::PickerTarget::TextRange { id, start, end });
+                }
+                if let Some(c) = p.solid_color() {
+                    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(text_r));
+                    if let Some(h) =
+                        widgets::text_field_inline(&mut child, Id::unique("range_hex"), &c.to_hex(), text_r.shrink2(vec2(0.0, 4.0)), regular(11.0))
+                        && let Some(nc) = figcraft_color::Color::from_hex_or_name(&h)
+                    {
+                        app.run("text.style", json!({"id": id, "start": start, "end": end, "textFills": [nc.to_css_hex()]}));
+                    }
+                } else {
+                    ui.painter().text(pos2(text_r.min.x, r.center().y), Align2::LEFT_CENTER, tr("Gradient"), regular(11.0), t.text);
+                }
+            }
+            None => {
+                ui.painter().text(pos2(text_r.min.x, r.center().y), Align2::LEFT_CENTER, tr("Mixed"), regular(11.0), t.text_secondary);
+                if ui.interact(r, Id::unique("range_mixed"), Sense::click()).clicked() {
+                    app.ui.picker = Some(crate::colorpicker::PickerTarget::TextRange { id, start, end });
+                }
+            }
+        }
+        // Back to the layer's fill.
+        if icons::button(ui, Icon::Detach, 24.0, false, tr("Use the layer's fill")).clicked() {
+            app.run("text.style", json!({"id": id, "start": start, "end": end, "textFills": null}));
+        }
+    });
+}
+
+/// Draw a selected-text range fill, or the fill/stroke paint rows with add, style, reorder,
+/// stroke align/weight, per-side weights and advanced stroke settings.
+pub(super) fn paints(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId], fills: bool) {
+    if fills
+        && let Some((id, a, b)) = figcraft_engine::textedit::selected_range(&app.session)
+        && a < b
+        && sel.contains(&id)
+    {
+        range_fill(app, ui, doc, id, a, b);
+        return;
+    }
+    let t = Tokens::get(ui.ctx());
+    let ids = sel.to_vec();
+    let list = common(doc, sel, |n| if fills { n.fills.clone() } else { n.strokes.clone() });
+    let title = if fills { tr("Fill") } else { tr("Stroke") };
+    let empty = list.as_ref().is_none_or(|l| l.is_empty());
+    let slot = if fills { StyleSlot::Fill } else { StyleSlot::Stroke };
+    // The section's right-click menu adds the copied paint (`fill.paste` / `stroke.paste`).
+    let paste = if fills { tr("Paste fill") } else { tr("Paste stroke") };
+    let (clicked, header) = widgets::section_header_resp(
+        ui,
+        title,
+        &[(Icon::Styles, tr("Styles")), (Icon::Plus, if fills { tr("Add fill") } else { tr("Add stroke") })],
+        empty,
+    );
+    if let Some(i) = clicked {
+        if i == 1 {
+            // The new paint goes on top; open its picker. A mixed selection has no one index to edit.
+            if app.run(if fills { "fill.add" } else { "stroke.add" }, json!({"ids": ids})).is_some()
+                && let Some(l) = &list
+            {
+                app.ui.picker = Some(crate::colorpicker::PickerTarget::Paint { fills, index: l.len(), ids: ids.clone() });
+            }
+        } else {
+            style_picker::open(app, ui, &ids, slot);
+        }
+    }
+    context_popup(&header).show(|ui| {
+        if app.session.clipboard.paint.as_ref().is_some_and(|(f, _)| *f == fills) && menu_item(ui, paste, "") {
+            app.run(if fills { "fill.paste" } else { "stroke.paste" }, json!({"ids": ids}));
+            ui.close();
+        }
+    });
+    style_picker::chip(app, ui, doc, &ids, slot);
+    match &list {
+        None => widgets::note(ui, tr("Click + to replace mixed content"), t.text_secondary),
+        Some(l) => {
+            // The last paint is on top: shown first. Rows drag to reorder.
+            let mut drag = ListDrag::new(ui, if fills { "fills" } else { "strokes" });
+            for (i, p) in l.iter().enumerate().rev() {
+                let r = paint_row(app, ui, &ids, i, p, fills);
+                drag.row(ui, i, r, r, || paint_label(p));
+            }
+            if let Some((from, to)) = drag.finish(ui) {
+                app.run(if fills { "fill.move" } else { "stroke.move" }, json!({"ids": ids, "from": from, "to": to}));
+                // An open colour picker keeps editing the paint it was on.
+                if let Some(crate::colorpicker::PickerTarget::Paint { fills: f, index, .. }) = &mut app.ui.picker
+                    && *f == fills
+                {
+                    *index = moved_index(*index, from, to);
+                }
+            }
+        }
+    }
+    if !fills && !empty {
+        let weight = common(doc, sel, |n| n.stroke.weight);
+        let align = common(doc, sel, |n| n.stroke.align);
+        let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
+        row(ui, 32.0, |ui| {
+            let resp = widgets::dropdown(
+                ui,
+                match align {
+                    Some(StrokeAlign::Inside) => tr("Inside"),
+                    Some(StrokeAlign::Center) => tr("Center"),
+                    Some(StrokeAlign::Outside) => tr("Outside"),
+                    None => tr("Mixed"),
+                },
+                half,
+                None,
+            );
+            menu_popup(&resp).show(|ui| {
+                for (l, v) in [(tr("Inside"), "inside"), (tr("Center"), "center"), (tr("Outside"), "outside")] {
+                    if menu_item(ui, l, "") {
+                        app.set_props(&ids, json!({"strokeAlign": v}));
+                        ui.close();
+                    }
+                }
+            });
+            let sided = sel.iter().all(|i| doc.node(*i).is_some_and(|n| n.kind.is_frame_like() || matches!(n.kind, NodeKind::Rectangle)));
+            let weight_w = half - if sided { 60.0 } else { 32.0 };
+            let e = crate::variable_ui::number_field_mixed(
+                app,
+                ui,
+                &ids,
+                "strokeWeight",
+                Id::unique("stroke_w"),
+                Lead::Icon(Icon::Menu, tr("Stroke weight")),
+                weight,
+                "",
+                weight_w,
+            );
+            app.field_of(&ids, "strokeWeight", e, |n| n.stroke.weight, |v| json!(v.max(0.0)));
+            if sided {
+                let sides_btn = icons::button(ui, Icon::IndependentCorners, 24.0, false, tr("Individual strokes"));
+                menu_popup(&sides_btn).show(|ui| {
+                    let w = weight.unwrap_or(1.0);
+                    for (l, v) in [
+                        (tr("All"), Value::Null),
+                        (tr("Top"), json!([w, 0.0, 0.0, 0.0])),
+                        (tr("Right"), json!([0.0, w, 0.0, 0.0])),
+                        (tr("Bottom"), json!([0.0, 0.0, w, 0.0])),
+                        (tr("Left"), json!([0.0, 0.0, 0.0, w])),
+                        (tr("Custom"), json!([w, w, w, w])),
+                    ] {
+                        if menu_item(ui, l, "") {
+                            app.set_props(&ids, json!({"strokeSides": v}));
+                            ui.close();
+                        }
+                    }
+                });
+            }
+            let adv_id = Id::unique("stroke_adv");
+            let open = ui.data(|d| d.get_temp::<bool>(adv_id)).unwrap_or(false);
+            if icons::button(ui, Icon::Dots, 24.0, open, tr("Advanced stroke")).clicked() {
+                ui.data_mut(|d| d.insert_temp(adv_id, !open));
+            }
+        });
+        // Per-side weights, two to a row (like the corner radii) so a bound variable's name fits:
+        // each side binds to a number variable on its own.
+        if let Some(sides) = common(doc, sel, |n| n.stroke.sides).flatten() {
+            let col = widgets::col_width(ui.available_width());
+            let fields = ["T", "R", "B", "L"].into_iter().zip(figcraft_engine::cmd::props::STROKE_SIDES);
+            for first in [0, 2] {
+                row(ui, 32.0, |ui| {
+                    for (k, (label, field)) in fields.clone().enumerate().skip(first).take(2) {
+                        let v = sides.get(k).copied();
+                        let e = crate::variable_ui::number_field(app, ui, &ids, field, Id::unique(("stroke_side", k)), Lead::Text(label), v, "", col);
+                        app.field(&ids, field, e, |x| json!(x.max(0.0)));
+                    }
+                });
+            }
+        }
+        if ui.data(|d| d.get_temp::<bool>(Id::unique("stroke_adv"))).unwrap_or(false) {
+            stroke_settings(app, ui, doc, sel);
+        }
+    }
+}
+
+/// Paint `i`'s row (swatch, colour or kind, opacity, visibility, remove); returns its area.
+fn paint_row(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], i: usize, p: &Paint, fills: bool) -> Rect {
+    let t = Tokens::get(ui.ctx());
+    let ids = ids.to_vec();
+    let cmd = if fills { "fill.set" } else { "stroke.set" };
+    let r = row_rect(ui, 32.0, |ui| {
+        let w = ui.available_width() - 56.0;
+        let (r, _) = ui.allocate_exact_size(vec2(w, FIELD_H), Sense::hover());
+        ui.painter().rect_filled(r, CornerRadius::same(5), t.field);
+        let sw = Rect::from_min_size(pos2(r.min.x + 4.0, r.center().y - 8.0), vec2(16.0, 16.0));
+        widgets::paint_swatch(ui.painter(), sw, p);
+        let sresp = ui.interact(sw.expand(2.0), Id::unique(("swatch", fills, i)), Sense::click());
+        if sresp.clicked() {
+            app.ui.picker = Some(crate::colorpicker::PickerTarget::Paint { fills, index: i, ids: ids.clone() });
+        }
+        let text_r = Rect::from_min_max(pos2(sw.max.x + 8.0, r.min.y), pos2(r.max.x - 52.0, r.max.y));
+        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(text_r));
+        // The variable bound to this paint's colour (its key on the layers: `fill` or `fills/<i>/color`).
+        let bound = app.session.doc().ok().and_then(|d| {
+            let key = ids.first().and_then(|id| d.node(*id)).and_then(|n| figcraft_engine::cmd::lists::paint_binding_key(n, fills, i))?;
+            Some((key.to_string(), crate::variable_ui::bound_name(d, &ids, key)?))
+        });
+        match &p.kind {
+            PaintKind::Solid { .. } if bound.is_some() => {
+                let (key, name) = bound.clone().unwrap_or_default();
+                let chip = Rect::from_min_max(pos2(text_r.min.x - 2.0, r.min.y + 3.0), pos2(text_r.max.x - 20.0, r.max.y - 3.0));
+                child.painter().rect_filled(chip, CornerRadius::same(4), t.hover);
+                child.painter().rect_stroke(chip, CornerRadius::same(4), Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
+                let short = name.rsplit('/').next().unwrap_or(&name).to_string();
+                child.painter().with_clip_rect(chip.shrink2(vec2(5.0, 0.0))).text(
+                    pos2(chip.min.x + 5.0, r.center().y),
+                    Align2::LEFT_CENTER,
+                    short,
+                    regular(11.0),
+                    t.text,
+                );
+                let _ = ui.interact(chip, Id::unique(("bound_paint", fills, i)), Sense::hover()).on_hover_text(&name);
+                let dr = Rect::from_center_size(pos2(text_r.max.x - 9.0, r.center().y), vec2(18.0, 18.0));
+                let dresp = ui.interact(dr, Id::unique(("detach_paint", fills, i)), Sense::click()).tip(tr("Detach variable"));
+                icons::paint(ui.painter(), dr.shrink(3.0), Icon::Detach, t.icon_secondary);
+                if dresp.clicked() {
+                    app.run("variable.bind", json!({"ids": ids, "field": key, "variable": null}));
+                }
+            }
+            PaintKind::Solid { color } => {
+                if let Some(h) = widgets::text_field_inline(
+                    &mut child,
+                    Id::unique(("hex", fills, i)),
+                    &color.to_hex(),
+                    text_r.shrink2(vec2(0.0, 4.0)),
+                    regular(11.0),
+                ) && let Some(c) = figcraft_color::Color::from_hex_or_name(&h)
+                {
+                    app.run(cmd, json!({"ids": ids, "index": i, "color": c.to_css_hex()}));
+                }
+            }
+            _ => {
+                child.painter().text(pos2(text_r.min.x, r.center().y), Align2::LEFT_CENTER, paint_label(p), regular(11.0), t.text);
+            }
+        }
+        let op_r = Rect::from_min_max(pos2(r.max.x - 48.0, r.min.y), r.max);
+        ui.painter().line_segment([pos2(op_r.min.x, r.min.y + 4.0), pos2(op_r.min.x, r.max.y - 4.0)], Stroke::new(1.0, t.panel));
+        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(op_r));
+        let e = widgets::number_field(
+            &mut child,
+            Id::unique(("pop", fills, i)),
+            Lead::None,
+            Some((f64::from(p.opacity) * 100.0).round()),
+            "%",
+            48.0,
+            1.0,
+        );
+        match e {
+            Some(FieldEdit::Set(v)) => {
+                app.run(cmd, json!({"ids": ids, "index": i, "opacity": (v / 100.0).clamp(0.0, 1.0)}));
+            }
+            Some(FieldEdit::Scrub(v, done)) => {
+                let _ = app.session.begin_interaction("Opacity");
+                let _ = app.session.execute(cmd, &json!({"ids": ids, "index": i, "opacity": (v / 100.0).clamp(0.0, 1.0)}));
+                if done {
+                    let _ = app.session.commit_interaction();
+                }
+            }
+            None => {}
+        }
+        if icons::button(ui, if p.visible { Icon::Eye } else { Icon::EyeOff }, 24.0, false, tr("Toggle visibility")).clicked() {
+            app.run(cmd, json!({"ids": ids, "index": i, "visible": !p.visible}));
+        }
+        if icons::button(ui, Icon::Minus, 24.0, false, tr("Remove")).clicked()
+            && app.run(if fills { "fill.remove" } else { "stroke.remove" }, json!({"ids": ids, "index": i})).is_some()
+            && let Some(crate::colorpicker::PickerTarget::Paint { fills: f, index, .. }) = &mut app.ui.picker
+            && *f == fills
+        {
+            // An open colour picker keeps editing the paint it was on, or closes with it.
+            match removed_index(*index, i) {
+                Some(k) => *index = k,
+                None => app.ui.picker = None,
+            }
+        }
+    });
+    let copy = if fills { tr("Copy fill") } else { tr("Copy stroke") };
+    let paste = if fills { tr("Paste fill") } else { tr("Paste stroke") };
+    let can_paste = app.session.clipboard.paint.as_ref().is_some_and(|(f, _)| *f == fills);
+    row_context_menu(ui, r, Id::unique(("paint_menu", fills, i))).show(|ui| {
+        if menu_item(ui, copy, "") {
+            app.run(if fills { "fill.copy" } else { "stroke.copy" }, json!({"ids": ids, "index": i}));
+            ui.close();
+        }
+        if can_paste && menu_item(ui, paste, "") {
+            app.run(if fills { "fill.paste" } else { "stroke.paste" }, json!({"ids": ids, "index": i}));
+            ui.close();
+        }
+    });
+    r
+}
+
+/// A paint row's label (also what a drag of it carries): its colour, gradient kind or "Image".
+fn paint_label(p: &Paint) -> String {
+    match &p.kind {
+        PaintKind::Solid { color } => color.to_hex(),
+        // The gradient kind's name ("Linear") is a key of its own.
+        PaintKind::Gradient(g) => tr(&format!("{:?}", g.kind)).to_string(),
+        PaintKind::Image(_) => tr("Image").into(),
+        PaintKind::Pattern(_) => tr("Pattern").into(),
+    }
+}
diff --git a/crates/ui-egui/src/panels/right/stroke.rs b/crates/ui-egui/src/panels/right/stroke.rs
new file mode 100644
index 00000000..c3bc8642
--- /dev/null
+++ b/crates/ui-egui/src/panels/right/stroke.rs
@@ -0,0 +1,313 @@
+use super::menu::{menu_item, menu_item_with, menu_popup, row};
+use super::*;
+
+/// A width profile drawn as a filled band across `rect` (thickest point = full height); `None`
+/// draws a uniform stroke.
+pub(crate) fn profile_art(painter: &egui::Painter, rect: Rect, profile: Option<&WidthProfile>, col: Color32) {
+    const STEPS: u32 = 40;
+    let max = profile.map_or(1.0, WidthProfile::max_scale).max(1e-6);
+    let (cy, half) = (rect.center().y, rect.height() / 2.0);
+    let mut mesh = egui::Mesh::default();
+    let (mut top, mut bottom) = (Vec::new(), Vec::new());
+    for i in 0..=STEPS {
+        let t = f64::from(i) / f64::from(STEPS);
+        // The path runs left to right: its left side is drawn on top.
+        let (l, r) = profile.map_or((0.5, 0.5), |p| {
+            let (l, r) = p.sides_at(t);
+            (l / max, r / max)
+        });
+        let x = rect.min.x + rect.width() * t as f32;
+        let (hl, hr) = (((l as f32) * half).max(0.5), ((r as f32) * half).max(0.5));
+        top.push(pos2(x, cy - hl));
+        bottom.push(pos2(x, cy + hr));
+        mesh.colored_vertex(pos2(x, cy - hl), col);
+        mesh.colored_vertex(pos2(x, cy + hr), col);
+    }
+    for i in 0..STEPS {
+        let k = 2 * i;
+        mesh.add_triangle(k, k + 1, k + 2);
+        mesh.add_triangle(k + 1, k + 3, k + 2);
+    }
+    painter.add(egui::Shape::mesh(mesh));
+    // The mesh isn't anti-aliased: smooth its edges with hairlines.
+    for edge in [top, bottom] {
+        painter.add(egui::Shape::line(edge, Stroke::new(0.75, col)));
+    }
+}
+
+/// Stroke settings ▸ Width profile: the presets (each with its shape) and a flip.
+fn width_profile_row(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], profile: Option<Option<WidthProfile>>, half: f32) {
+    let t = Tokens::get(ui.ctx());
+    widgets::sublabels(ui, tr("Width profile"), None);
+    row(ui, 32.0, |ui| {
+        let label = match &profile {
+            None => tr("Mixed"),
+            Some(None) => tr(WidthPreset::Uniform.label()),
+            Some(Some(p)) => p.preset().map_or(tr("Custom"), |w| tr(w.label())),
+        };
+        let resp = widgets::dropdown(ui, label, half * 2.0 + 8.0 - 32.0, None);
+        if let Some(p) = &profile {
+            let r = resp.rect;
+            let art = Rect::from_min_max(pos2(r.max.x - 22.0 - 56.0, r.center().y - 5.0), pos2(r.max.x - 22.0, r.center().y + 5.0));
+            profile_art(ui.painter(), art, p.as_ref(), t.icon_secondary);
+        }
+        menu_popup(&resp).show(|ui| {
+            for preset in WidthPreset::ALL {
+                let prof = preset.profile();
+                let art = |pt: &egui::Painter, r: Rect, col: Color32| {
+                    let a = Rect::from_min_max(pos2(r.max.x - 8.0 - 64.0, r.center().y - 5.0), pos2(r.max.x - 8.0, r.center().y + 5.0));
+                    profile_art(pt, a, prof.as_ref(), col);
+                };
+                if menu_item_with(ui, tr(preset.label()), "", 8.0 + 64.0, art) {
+                    app.run("stroke.widthProfile", json!({"ids": ids, "preset": preset.id()}));
+                    ui.close();
+                }
+            }
+        });
+        // Flip: the profile runs from the other end of the path.
+        let custom = profile.clone().flatten();
+        let flip = icons::button(ui, Icon::FlipH, 24.0, false, tr("Flip width profile"));
+        if flip.clicked()
+            && let Some(p) = custom
+        {
+            let pts: Vec<Value> =
+                p.points.iter().rev().map(|q| figcraft_engine::cmd::props::width_point_json(&WidthPoint { t: 1.0 - q.t, ..*q })).collect();
+            app.run("stroke.widthProfile", json!({"ids": ids, "points": pts}));
+        }
+    });
+}
+
+/// A brush drawn along a short line across `rect`, as outlines (egui fills only convex shapes).
+pub(crate) fn brush_art(painter: &egui::Painter, rect: Rect, preset: &str, col: Color32) {
+    use figcraft_geom::kurbo::{self, PathEl};
+    let mut line = figcraft_geom::BezPath::new();
+    line.move_to((0.0, 0.0));
+    line.line_to((f64::from(rect.width()), 0.0));
+    let brush = Brush::new(preset);
+    let props = StrokeProps { weight: f64::from(rect.height()), align: StrokeAlign::Center, brush: Some(brush.clone()), ..Default::default() };
+    let Some(out) = figcraft_pathops::brush::outline(&line, props.weight, &props, &brush) else { return };
+    for sub in figcraft_geom::split_subpaths(&out) {
+        let mut pts = Vec::new();
+        kurbo::flatten(sub.iter(), 0.25, |el| {
+            if let PathEl::MoveTo(p) | PathEl::LineTo(p) = el {
+                pts.push(pos2(rect.min.x + p.x as f32, rect.center().y + p.y as f32));
+            }
+        });
+        painter.add(egui::Shape::closed_line(pts, Stroke::new(1.0, col)));
+    }
+}
+
+/// Stroke settings ▸ Brush: a plain stroke, a stretch brush or a scatter brush, each with its look.
+fn brush_row(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], brush: Option<Option<Brush>>, width: f32) {
+    use figcraft_pathops::brush::{PRESETS, preset};
+    let t = Tokens::get(ui.ctx());
+    widgets::sublabels(ui, tr("Brush"), None);
+    row(ui, 32.0, |ui| {
+        let label = match &brush {
+            None => tr("Mixed"),
+            Some(b) => b.as_ref().and_then(|b| preset(&b.preset)).map_or(tr("None"), |p| tr(p.label)),
+        };
+        let resp = widgets::dropdown(ui, label, width, None);
+        a11y::combo(&resp, tr("Brush"), label, a11y::menu_open(&resp));
+        if let Some(Some(b)) = &brush {
+            let r = resp.rect;
+            brush_art(
+                ui.painter(),
+                Rect::from_min_max(pos2(r.max.x - 22.0 - 56.0, r.center().y - 5.0), pos2(r.max.x - 22.0, r.center().y + 5.0)),
+                &b.preset,
+                t.icon_secondary,
+            );
+        }
+        menu_popup(&resp).show(|ui| {
+            if menu_item(ui, tr("None"), "") {
+                app.run("stroke.brush", json!({"ids": ids, "preset": null}));
+                ui.close();
+            }
+            for p in PRESETS {
+                let art = |pt: &egui::Painter, r: Rect, col: Color32| {
+                    brush_art(
+                        pt,
+                        Rect::from_min_max(pos2(r.max.x - 8.0 - 64.0, r.center().y - 5.0), pos2(r.max.x - 8.0, r.center().y + 5.0)),
+                        p.id,
+                        col,
+                    );
+                };
+                if menu_item_with(ui, tr(p.label), "", 8.0 + 64.0, art) {
+                    app.run("stroke.brush", json!({"ids": ids, "preset": p.id}));
+                    ui.close();
+                }
+            }
+        });
+    });
+    // A scatter brush's spacing and jitter.
+    let Some(Some(b)) =
+        brush.filter(|b| b.as_ref().and_then(|b| preset(&b.preset)).is_some_and(|p| p.kind == figcraft_pathops::brush::BrushKind::Scatter))
+    else {
+        return;
+    };
+    let half = (width - 8.0) / 2.0;
+    let with = |f: &dyn Fn(&mut Brush)| {
+        let mut nb = b.clone();
+        f(&mut nb);
+        serde_json::to_value(nb.sanitized()).unwrap_or_default()
+    };
+    widgets::sublabels(ui, tr("Spacing"), Some(tr("Scatter")));
+    row(ui, 32.0, |ui| {
+        let e = widgets::number_field(ui, Id::unique("brush_spacing"), Lead::Icon(Icon::Gap, tr("Brush spacing")), Some(b.spacing), "×", half, 0.1);
+        app.field(ids, "brush", e, |v| with(&|nb| nb.spacing = v));
+        let e = widgets::number_field(ui, Id::unique("brush_scatter"), Lead::Icon(Icon::Dots, tr("Brush scatter")), Some(b.scatter), "×", half, 0.1);
+        app.field(ids, "brush", e, |v| with(&|nb| nb.scatter = v));
+    });
+    widgets::sublabels(ui, tr("Size jitter"), Some(tr("Rotation jitter")));
+    row(ui, 32.0, |ui| {
+        let e = widgets::number_field(
+            ui,
+            Id::unique("brush_size_jitter"),
+            Lead::Icon(Icon::Scale, tr("Brush size jitter")),
+            Some(b.size_jitter * 100.0),
+            "%",
+            half,
+            1.0,
+        );
+        app.field(ids, "brush", e, |v| with(&|nb| nb.size_jitter = v / 100.0));
+        let e = widgets::number_field(
+            ui,
+            Id::unique("brush_rotation_jitter"),
+            Lead::Icon(Icon::Rotate, tr("Brush rotation jitter")),
+            Some(b.rotation_jitter * 100.0),
+            "%",
+            half,
+            1.0,
+        );
+        app.field(ids, "brush", e, |v| with(&|nb| nb.rotation_jitter = v / 100.0));
+    });
+}
+
+/// Advanced stroke settings: dash pattern, width profile, join and the end points of open paths.
+pub(super) fn stroke_settings(app: &mut FigApp, ui: &mut Ui, doc: &Document, sel: &[NodeId]) {
+    let ids = sel.to_vec();
+    let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
+    let st = common(doc, sel, |n| n.stroke.clone());
+    let dashes = st.as_ref().map(|s| s.dashes.clone());
+    let weight = st.as_ref().map(|s| s.weight).unwrap_or(1.0).max(1.0);
+    widgets::sublabels(ui, tr("Stroke style"), None);
+    row(ui, 32.0, |ui| {
+        let dashed = dashes.as_ref().is_some_and(|d| !d.is_empty());
+        let resp = widgets::dropdown(ui, if dashed { tr("Dash") } else { tr("Solid") }, half, None);
+        menu_popup(&resp).show(|ui| {
+            if menu_item(ui, tr("Solid"), "") {
+                app.set_props(&ids, json!({"dashes": []}));
+                ui.close();
+            }
+            if menu_item(ui, tr("Dash"), "") {
+                app.set_props(&ids, json!({"dashes": [weight * 4.0, weight * 4.0]}));
+                ui.close();
+            }
+        });
+    });
+    if let Some(d) = dashes.filter(|d| !d.is_empty()) {
+        let (dash, gap) = (d.first().copied().unwrap_or(4.0), d.get(1).copied().unwrap_or_else(|| d.first().copied().unwrap_or(4.0)));
+        widgets::sublabels(ui, tr("Dash"), Some(tr("Gap")));
+        row(ui, 32.0, |ui| {
+            let e = widgets::number_field(ui, Id::unique("stroke_dash"), Lead::None, Some(dash), "", half, 1.0);
+            app.field(&ids, "dashes", e, |v| json!([v.max(0.0), gap]));
+            let e = widgets::number_field(ui, Id::unique("stroke_gap"), Lead::None, Some(gap), "", half, 1.0);
+            app.field(&ids, "dashes", e, |v| json!([dash, v.max(0.0)]));
+        });
+    }
+    width_profile_row(app, ui, &ids, st.as_ref().map(|s| s.profile().cloned()), half);
+    brush_row(app, ui, &ids, st.as_ref().map(|s| s.brush.clone()), half * 2.0 + 8.0);
+    let join = st.as_ref().map(|s| s.join);
+    widgets::sublabels(ui, tr("Join|stroke"), (join == Some(StrokeJoin::Miter)).then_some(tr("Miter angle")));
+    row(ui, 32.0, |ui| {
+        let resp = widgets::dropdown(ui, join.map(join_label).unwrap_or(tr("Mixed")), half, None);
+        menu_popup(&resp).show(|ui| {
+            for j in StrokeJoin::ALL {
+                if menu_item(ui, join_label(j), "") {
+                    app.set_props(&ids, json!({"strokeJoin": j}));
+                    ui.close();
+                }
+            }
+        });
+        if join == Some(StrokeJoin::Miter) {
+            let angle = st.as_ref().map(|s| (s.miter_angle() * 100.0).round() / 100.0);
+            let e = widgets::number_field(ui, Id::unique("stroke_miter"), Lead::None, angle, "°", half, 1.0);
+            app.field(&ids, "miterAngle", e, |v| json!(v));
+        }
+    });
+    // End points only mean something on open paths.
+    let open_paths = sel.iter().all(|i| doc.node(*i).is_some_and(|n| matches!(n.kind, NodeKind::Line | NodeKind::Vector { .. })));
+    if open_paths {
+        widgets::sublabels(ui, tr("Start point"), Some(tr("End point")));
+        row(ui, 32.0, |ui| {
+            for (key, cap) in [("startCap", st.as_ref().map(|s| s.cap_start)), ("endCap", st.as_ref().map(|s| s.cap_end))] {
+                let resp = widgets::dropdown(ui, cap.map(|c| tr(c.label())).unwrap_or(tr("Mixed")), half, None);
+                menu_popup(&resp).show(|ui| {
+                    for c in StrokeCap::ALL {
+                        if menu_item_with(ui, tr(c.label()), "", CAP_ART_W, |p, r, col| cap_art(p, r, col, c, key == "startCap")) {
+                            app.set_props(&ids, json!({key: format!("{c:?}")}));
+                            ui.close();
+                        }
+                    }
+                });
+            }
+        });
+    }
+    ui.add_space(4.0);
+}
+
+/// A stroke join's name in the interface.
+pub(crate) fn join_label(j: StrokeJoin) -> &'static str {
+    match j {
+        StrokeJoin::Miter => tr("Miter"),
+        StrokeJoin::Bevel => tr("Bevel"),
+        StrokeJoin::Round => tr("Round"),
+    }
+}
+
+/// The width [`cap_art`] takes at the right of a menu row (its arrows reach past the line's ends).
+pub(crate) const CAP_ART_W: f32 = 64.0;
+
+/// A short stroke ending in `cap` (on its left end for a start point), drawn at the right of a menu
+/// row.
+pub(crate) fn cap_art(p: &egui::Painter, r: Rect, col: Color32, cap: StrokeCap, start: bool) {
+    let y = r.center().y;
+    let (left, right) = (r.max.x - 58.0, r.max.x - 14.0);
+    // The capped end, the plain end, and the direction from the stroke into its cap.
+    let (tip, tail, d) = if start { (left, right, -1.0) } else { (right, left, 1.0) };
+    let at = |back: f32, dy: f32| pos2(tip - d * back, y + dy);
+    let line = |to: Pos2, w: f32| {
+        p.line_segment([pos2(tail, y), to], Stroke::new(w, col));
+    };
+    let fill = |pts: Vec<Pos2>| {
+        p.add(egui::Shape::convex_polygon(pts, col, Stroke::NONE));
+    };
+    match cap {
+        StrokeCap::None => line(at(0.0, 0.0), 4.0),
+        StrokeCap::Round => {
+            line(at(2.0, 0.0), 4.0);
+            p.circle_filled(at(2.0, 0.0), 2.0, col);
+        }
+        StrokeCap::Square => line(at(-2.0, 0.0), 4.0),
+        StrokeCap::LineArrow => {
+            line(at(0.0, 0.0), 1.5);
+            p.add(egui::Shape::line(vec![at(5.5, -5.5), at(0.0, 0.0), at(5.5, 5.5)], Stroke::new(1.5, col)));
+        }
+        StrokeCap::TriangleArrow => {
+            line(at(7.0, 0.0), 1.5);
+            fill(vec![at(0.0, 0.0), at(8.0, -4.5), at(8.0, 4.5)]);
+        }
+        StrokeCap::ReversedTriangle => {
+            line(at(8.0, 0.0), 1.5);
+            fill(vec![at(8.0, 0.0), at(0.0, -4.5), at(0.0, 4.5)]);
+        }
+        StrokeCap::CircleFilled => {
+            line(at(4.0, 0.0), 1.5);
+            p.circle_filled(at(4.0, 0.0), 4.0, col);
+        }
+        StrokeCap::DiamondFilled => {
+            line(at(5.0, 0.0), 1.5);
+            fill(vec![at(0.0, 0.0), at(5.0, -5.0), at(10.0, 0.0), at(5.0, 5.0)]);
+        }
+    }
+}

From f61032b3c97bba93f5e44d448ba6eb4eefeb4c03 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:56:10 +0000
Subject: [PATCH 43/67] refactor(ui-egui): split canvas.rs into canvas/

---
 crates/ui-egui/src/canvas.rs          | 1385 +------------------------
 crates/ui-egui/src/canvas/builder.rs  |  121 +++
 crates/ui-egui/src/canvas/input.rs    |  260 +++++
 crates/ui-egui/src/canvas/outline.rs  |  196 ++++
 crates/ui-egui/src/canvas/overlays.rs |  545 ++++++++++
 crates/ui-egui/src/canvas/render.rs   |  166 +++
 crates/ui-egui/src/canvas/rulers.rs   |   93 ++
 7 files changed, 1398 insertions(+), 1368 deletions(-)
 create mode 100644 crates/ui-egui/src/canvas/builder.rs
 create mode 100644 crates/ui-egui/src/canvas/input.rs
 create mode 100644 crates/ui-egui/src/canvas/outline.rs
 create mode 100644 crates/ui-egui/src/canvas/overlays.rs
 create mode 100644 crates/ui-egui/src/canvas/render.rs
 create mode 100644 crates/ui-egui/src/canvas/rulers.rs

diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index 724b441e..9ef65cba 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -13,6 +13,23 @@ use crate::FigApp;
 use crate::i18n::{tr, trf, trn};
 use crate::render_worker::{Done, Job, Worker};
 use crate::theme::{COMPONENT, Tokens, doc_c32, regular, semibold};
+
+mod builder;
+mod input;
+mod outline;
+mod overlays;
+mod render;
+mod rulers;
+
+#[cfg(test)]
+use builder::clean_poly;
+use input::input;
+pub use input::open_context_menu;
+pub(crate) use outline::{TextOnScreen, node_quad};
+use overlays::{accent, overlays};
+use render::{JobKey, request_render, shows};
+pub use rulers::fmt;
+pub(crate) use rulers::{status_badge, status_label};
 pub mod board_bar;
 pub mod board_facilitate;
 pub mod comments;
@@ -131,24 +148,6 @@ impl FigApp {
     }
 }
 
-#[derive(Clone, PartialEq)]
-struct JobKey {
-    doc: usize,
-    page: NodeId,
-    origin: (i64, i64),
-    scale: i64,
-    size: (u32, u32),
-    outline: bool,
-    outline_extras: figcraft_render::Outline,
-    outlined: Vec<NodeId>,
-    skip: Vec<NodeId>,
-    solo: Option<NodeId>,
-    /// Text lays out anew when fonts arrive (system fonts load in the background).
-    fonts: u64,
-    proof: bool,
-    dots: Option<figcraft_render::Dots>,
-}
-
 impl FigApp {
     /// Page → screen (logical points).
     pub fn to_screen(&self, x: f64, y: f64) -> Pos2 {
@@ -360,1351 +359,6 @@ fn describe_box([x0, y0, x1, y1]: [f64; 4]) -> String {
     )
 }
 
-/// Whether a finished render goes on screen: an image of the file and page shown (`shown`), and
-/// not a coarse preview over a refined image of the same or a newer request, or one that already
-/// shows the whole view asked for at its zoom (the same zoom elsewhere on the page is no such
-/// image).
-fn shows(c: &CanvasState, done: &Done, shown: Option<(u64, NodeId)>) -> bool {
-    if shown != Some((done.uid, done.page)) {
-        return false;
-    }
-    let refined = !c.tex_coarse && c.tex_of == shown;
-    if done.coarse && refined && done.seq <= c.tex_seq {
-        return false;
-    }
-    let refined_here = refined
-        && c.tex_view
-            .as_ref()
-            .zip(c.want_view.as_ref())
-            .is_some_and(|(have, want)| have.scale.to_bits() == want.scale.to_bits() && covers(have, want));
-    !(done.coarse && refined_here)
-}
-
-/// Whether `outer` shows all of the page that `inner` does.
-fn covers(outer: &figcraft_render::View, inner: &figcraft_render::View) -> bool {
-    let (o, i) = (outer.page_rect(), inner.page_rect());
-    // Rounding in the snapped origin, well under a device pixel.
-    let eps = 1e-6 / inner.scale.max(1e-9);
-    o.x0 <= i.x0 + eps && o.y0 <= i.y0 + eps && o.x1 >= i.x1 - eps && o.y1 >= i.y1 - eps
-}
-
-fn request_render(app: &mut FigApp, worker: &mut Worker, ppp: f32, max_texture_side: u32, dots: Option<figcraft_render::Dots>) {
-    let Ok(ds) = app.session.ds() else { return };
-    let rect = app.canvas.rect;
-    let (mut ox, mut oy) = ds.view.origin();
-    let (scale, visible_w, visible_h) = if let Some(k) = ds.view.pixel_preview_scale() {
-        // Pixel preview: render `k` pixels per page unit from a whole-pixel origin, shown magnified
-        // without smoothing.
-        (ox, oy) = ((ox * k).floor() / k, (oy * k).floor() / k);
-        let z = ds.view.zoom.max(1e-9) / k;
-        (k, (f64::from(rect.width()) / z).ceil() as u32 + 2, (f64::from(rect.height()) / z).ceil() as u32 + 2)
-    } else {
-        (ds.view.zoom * f64::from(ppp), (rect.width() * ppp).ceil().max(1.0) as u32, (rect.height() * ppp).ceil().max(1.0) as u32)
-    };
-    // The edited text is drawn live (an IME composition included); the caret is an overlay.
-    let doc = app.preedit_view().map(|p| p.doc.clone()).unwrap_or_else(|| ds.doc.clone());
-    let outlined = if ds.view.outlines_selection { ds.selection.clone() } else { vec![] };
-    let proof = ds.view.proof_srgb && !doc.color_profile.is_srgb();
-    let outline_extras = figcraft_render::Outline { hidden: ds.view.outline_hidden, bounds: ds.view.outline_bounds, light: false };
-    // Render beyond the visible viewport. During a pan the previous texture then still covers
-    // the screen while the worker renders newly exposed content. Request a new buffer before the
-    // visible area reaches its edge, rather than exposing an empty strip each pointer move.
-    let margin = overscan_margin(visible_w, visible_h, max_texture_side);
-    let origin = (ox, oy);
-    let visible = (visible_w, visible_h);
-    let requested = (ox - f64::from(margin) / scale, oy - f64::from(margin) / scale);
-    let size = (visible_w.saturating_add(margin * 2).min(max_texture_side), visible_h.saturating_add(margin * 2).min(max_texture_side));
-    let key = JobKey {
-        doc: Arc::as_ptr(&doc) as usize,
-        page: ds.page,
-        origin: ((requested.0 * 1000.0) as i64, (requested.1 * 1000.0) as i64),
-        scale: (scale * 10000.0) as i64,
-        size,
-        outline: ds.view.outlines,
-        outline_extras,
-        outlined: outlined.clone(),
-        skip: vec![],
-        solo: ds.focused(),
-        fonts: figcraft_text::layout_generation(),
-        proof,
-        dots,
-    };
-    if let Some(previous) = &app.canvas.submitted {
-        let previous_origin = (previous.origin.0 as f64 / 1000.0, previous.origin.1 as f64 / 1000.0);
-        let same_content = JobKey { origin: previous.origin, size: previous.size, ..key.clone() } == *previous;
-        let covers = cached_render_covers(previous_origin, previous.size, origin, visible, scale);
-        if same_content && covers {
-            return;
-        }
-    }
-    if app.canvas.submitted.as_ref() == Some(&key) {
-        return;
-    }
-    let job = Job {
-        doc,
-        page: ds.page,
-        view: figcraft_render::View { origin: requested, scale, width: size.0, height: size.1 },
-        outline: ds.view.outlines,
-        outline_extras,
-        outlined,
-        skip: vec![],
-        solo: key.solo,
-        proof,
-        dots,
-        uid: ds.uid,
-        zoom_preview: ds.view.pixel_preview_scale().is_none(),
-        at: web_time::Instant::now(),
-    };
-    app.canvas.want_view = Some(job.view.clone());
-    worker.submit(job);
-    app.canvas.submitted = Some(key);
-}
-
-/// Leave a 96-pixel reserve so the next render starts before a pan reaches a cached edge.
-fn cached_render_covers(buffer_origin: (f64, f64), buffer_size: (u32, u32), view_origin: (f64, f64), view_size: (u32, u32), scale: f64) -> bool {
-    if !scale.is_finite() || scale <= 0.0 {
-        return false;
-    }
-    let guard_x = 96.0_f64.min(f64::from(buffer_size.0.saturating_sub(view_size.0)) / 4.0) / scale;
-    let guard_y = 96.0_f64.min(f64::from(buffer_size.1.saturating_sub(view_size.1)) / 4.0) / scale;
-    view_origin.0 >= buffer_origin.0 + guard_x
-        && view_origin.1 >= buffer_origin.1 + guard_y
-        && view_origin.0 + f64::from(view_size.0) / scale <= buffer_origin.0 + f64::from(buffer_size.0) / scale - guard_x
-        && view_origin.1 + f64::from(view_size.1) / scale <= buffer_origin.1 + f64::from(buffer_size.1) / scale - guard_y
-}
-
-/// Bound the extra rendered area to about 1.6 times the visible area. A fixed large margin can
-/// multiply the pixel count several-fold on a narrow or small viewport.
-fn overscan_margin(width: u32, height: u32, max_texture_side: u32) -> u32 {
-    width.min(height).saturating_div(8).min(128).min(max_texture_side.saturating_sub(width.max(height)) / 2)
-}
-
-#[cfg(test)]
-#[test]
-fn pan_uses_cached_pixels_until_the_refill_boundary() {
-    let margin = overscan_margin(1000, 800, 16_383);
-    assert_eq!(margin, 100);
-    let buffer = (-f64::from(margin), -f64::from(margin));
-    let size = (1000 + 2 * margin, 800 + 2 * margin);
-    assert!(cached_render_covers(buffer, size, (0.0, 0.0), (1000, 800), 1.0));
-    assert!(cached_render_covers(buffer, size, (50.0, 0.0), (1000, 800), 1.0));
-    assert!(!cached_render_covers(buffer, size, (80.0, 0.0), (1000, 800), 1.0));
-    assert!(!cached_render_covers(buffer, size, (-80.0, 0.0), (1000, 800), 1.0));
-    assert!(cached_render_covers((-24.0, -24.0), (1048, 848), (10.0, 0.0), (1000, 800), 1.0));
-    assert!(!cached_render_covers((-24.0, -24.0), (1048, 848), (19.0, 0.0), (1000, 800), 1.0));
-}
-
-#[cfg(test)]
-#[test]
-fn overscan_stays_within_texture_and_pixel_budget() {
-    for (width, height, limit) in [(1000, 800, 16_383), (390, 844, 16_383), (2560, 1440, 16_383), (1000, 800, 1060)] {
-        let margin = overscan_margin(width, height, limit);
-        assert!(width + 2 * margin <= limit || width > limit);
-        assert!(height + 2 * margin <= limit || height > limit);
-        let rendered = u64::from(width + 2 * margin) * u64::from(height + 2 * margin);
-        let visible = u64::from(width) * u64::from(height);
-        assert!(rendered * 5 <= visible * 8); // At most 1.6× the visible pixels.
-    }
-}
-
-/// The zoom tool while Z is held (Alt: zoom out): a click zooms a step about the pointer, a drag
-/// zooms to the dragged area. Takes the pointer from the other tools while it's active.
-fn zoom_tool(app: &mut FigApp, ui: &Ui, resp: &egui::Response, pos: Pos2, mods: egui::Modifiers, typing: bool) -> bool {
-    let held = !typing && !mods.command && ui.input(|i| i.key_down(egui::Key::Z));
-    app.canvas.zoom_tool = held.then_some(mods.alt);
-    let Some(start) = app.canvas.zoom_drag.or_else(|| (held && resp.hovered() && ui.input(|i| i.pointer.primary_pressed())).then_some(pos)) else {
-        return held;
-    };
-    app.canvas.zoom_drag = Some(start);
-    let area = Rect::from_two_pos(start, pos);
-    if ui.input(|i| i.pointer.primary_down()) {
-        return true;
-    }
-    app.canvas.zoom_drag = None;
-    let (a, b) = (app.to_page(area.min), app.to_page(area.max));
-    let params = if area.width() > 4.0 && area.height() > 4.0 {
-        json!({"x": a.x, "y": a.y, "width": b.x - a.x, "height": b.y - a.y})
-    } else {
-        let p = app.to_page(pos);
-        json!({"x": p.x, "y": p.y, "out": mods.alt})
-    };
-    app.run("view.zoomAt", params);
-    true
-}
-
-/// The pointer and keys on the canvas. False when something on it with a cursor of its own has
-/// the pointer (a comment pin, a ruler guide, a gradient or padding handle): the tool's cursor
-/// then doesn't show.
-fn input(app: &mut FigApp, ui: &mut Ui, resp: &egui::Response) -> bool {
-    if crate::proto_canvas::input(app, ui, resp) {
-        // A prototype gesture is a press on the canvas too: the Pages list gives up the keyboard.
-        app.ui.pages_focus = None;
-        return true;
-    }
-    let ctx = ui.ctx().clone();
-    // Two fingers pan as well as pinch (a touch screen has no scroll wheel).
-    let (mods, scroll, zoom_delta, hover_pos, space) = ctx.input(|i| {
-        let pan = i.multi_touch().map_or(egui::Vec2::ZERO, |m| m.translation_delta);
-        (i.modifiers, i.smooth_scroll_delta + pan, i.zoom_delta(), i.pointer.hover_pos(), i.key_down(egui::Key::Space))
-    });
-    let editing_text = app.session.ds().map(|d| d.text_edit.is_some()).unwrap_or(false);
-    let typing_elsewhere = crate::a11y::field_focused(&ctx);
-    app.canvas.space_pan = space && !editing_text && !typing_elsewhere;
-    if !app.canvas.dragging && crate::selection_spacing::input(app, &ctx, hover_pos, resp.hovered(), app.canvas.space_pan) {
-        return false;
-    }
-    // Dropped files import onto the canvas, behind a card while they do ([`crate::pending_open`]);
-    // a dropped document opens as a file of its own, as on the home screen. Dev Mode imports
-    // nothing into the design, and says so once for the whole drop.
-    let dropped = ctx.input(|i| i.raw.dropped_files.clone());
-    let mut refused = false;
-    for f in dropped {
-        let path = f.path().to_path_buf();
-        if crate::is_document(&path) {
-            crate::pending_open::open_dropped(app, &f);
-            continue;
-        }
-        if refused || crate::menus::dev_mode_refuses(app, "file.import") {
-            refused = true;
-            continue;
-        }
-        let pt = hover_pos.map(|h| app.to_page(h)).unwrap_or_default();
-        let name = path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "dropped.png".into());
-        let (params, read) = if path.exists() {
-            (json!({"path": path.to_string_lossy(), "x": pt.x, "y": pt.y}), None)
-        } else {
-            (json!({"name": name, "x": pt.x, "y": pt.y}), Some(crate::dropped_bytes(&f, &name)))
-        };
-        let Some(target) =
-            app.session.ds().ok().map(|doc| crate::pending_open::ImportTarget { uid: doc.uid, page: doc.page, name: doc.doc.name.clone() })
-        else {
-            continue;
-        };
-        app.ui.pending_opens.push(crate::pending_open::PendingOpen { label: name, params, command: "file.import", target: Some(target), read });
-    }
-    let Some(pos) = hover_pos.filter(|p| app.canvas.rect.contains(*p)) else {
-        // A drag released off the canvas, or off the window, ends where the pointer was last seen.
-        if app.canvas.dragging && !ctx.input(|i| i.pointer.primary_down()) {
-            app.canvas.dragging = false;
-            if let Some(at) = hover_pos.or_else(|| app.canvas.last_pointer.map(|p| app.to_screen(p.x, p.y))) {
-                send(app, PointerKind::Up, at, &mods);
-            }
-        }
-        // Leaving the canvas: nothing is hovered there any more.
-        if !app.canvas.dragging && std::mem::take(&mut app.canvas.hovering) {
-            app.session.pointer_left();
-        }
-        // A pan whose button was released off the canvas is over.
-        if !ctx.input(|i| i.pointer.button_down(egui::PointerButton::Middle) || i.pointer.primary_down()) {
-            app.canvas.middle_pan = None;
-        }
-        return true;
-    };
-    // A press on the canvas gives the keyboard back to it (arrows nudge again).
-    if resp.hovered() && ctx.input(|i| i.pointer.any_pressed()) {
-        app.ui.layers_focus = false;
-        app.ui.pages_focus = None;
-        app.ui.key_box = None;
-    }
-    // Zoom (pinch, Cmd/Ctrl+scroll) about the pointer; plain scroll pans.
-    if resp.hovered() {
-        if (zoom_delta - 1.0).abs() > 1e-4 {
-            let anchor = app.to_page(pos);
-            if let Ok(ds) = app.session.ds_mut() {
-                let z = ds.view.zoom * f64::from(zoom_delta);
-                ds.view.set_zoom_at(z, (anchor.x, anchor.y));
-                ds.revision += 1;
-            }
-        } else if scroll != egui::Vec2::ZERO
-            && let Ok(ds) = app.session.ds_mut()
-        {
-            ds.view.scroll(f64::from(scroll.x), f64::from(scroll.y), mods.shift);
-            ds.revision += 1;
-        }
-    }
-    if zoom_tool(app, ui, resp, pos, mods, editing_text || typing_elsewhere) {
-        return true;
-    }
-    // Middle-button / space panning.
-    let middle_down = ctx.input(|i| i.pointer.button_down(egui::PointerButton::Middle));
-    if (middle_down || (app.canvas.space_pan && ctx.input(|i| i.pointer.primary_down()))) && resp.hovered() || app.canvas.middle_pan.is_some() {
-        if let Ok(ds) = app.session.ds_mut() {
-            match app.canvas.middle_pan {
-                None => app.canvas.middle_pan = Some((pos, ds.view.cx, ds.view.cy)),
-                Some((p0, cx, cy)) => {
-                    let z = ds.view.zoom.max(1e-6);
-                    ds.view.cx = cx - f64::from(pos.x - p0.x) / z;
-                    ds.view.cy = cy - f64::from(pos.y - p0.y) / z;
-                    ds.revision += 1;
-                }
-            }
-        }
-        if !middle_down && !ctx.input(|i| i.pointer.primary_down()) {
-            app.canvas.middle_pan = None;
-        }
-        return true;
-    }
-    if !app.canvas.dragging && (resp.hovered() || app.ui.comments.dragging()) && crate::comments::input(app, &ctx, pos) {
-        return false;
-    }
-    if !app.canvas.dragging && resp.hovered() && crate::guides::input(app, &ctx, pos) {
-        return false;
-    }
-    if !app.canvas.dragging && resp.hovered() && crate::handles::input(app, &ctx, pos) {
-        return false;
-    }
-    if resp.secondary_clicked() {
-        open_context_menu(app, pos, mods.command);
-        return true;
-    }
-    // A third quick click is counted as a triple, not a double (a click elsewhere in between still
-    // leaves its time in the sequence): it means the same here — edit, enter, open — unless a
-    // vector or text is being edited, where a triple already has its own meaning. A triple on
-    // empty canvas still means a double in vector edit mode: the double-click that entered edit
-    // mode counts on, so leaving it right away would otherwise take a fourth click or a pause.
-    let ds = app.session.ds().ok();
-    let editing = ds.is_some_and(|d| d.vector_edit.is_some() || d.text_edit.is_some());
-    // Only a triple click asks (it walks the parts' render bounds).
-    let empty_canvas = || {
-        ds.is_some_and(|d| {
-            let Some(ve) = d.vector_edit.as_ref().filter(|v| v.anchor.is_none() && d.text_edit.is_none()) else {
-                return false;
-            };
-            let p = app.to_page(pos);
-            let tol = 6.0 / d.view.zoom.max(1e-6);
-            ve.parts().iter().all(|part| d.doc.world_render_bounds(part.id).is_none_or(|b| !b.inflate(tol * 4.0, tol * 4.0).contains(p)))
-        })
-    };
-    if resp.double_clicked() || (resp.triple_clicked() && (!editing || empty_canvas())) {
-        let ev = pointer_event(app, PointerKind::DoubleClick, pos, &mods);
-        if let Err(e) = app.session.pointer(&ev) {
-            app.toast(e.to_string());
-        }
-        app.canvas.dragging = false;
-        return true;
-    }
-    let primary_pressed = ctx.input(|i| i.pointer.button_pressed(egui::PointerButton::Primary));
-    let primary_down = ctx.input(|i| i.pointer.primary_down());
-    let primary_released = ctx.input(|i| i.pointer.button_released(egui::PointerButton::Primary));
-    let kind = if primary_pressed && resp.hovered() {
-        app.canvas.dragging = true;
-        app.ui.context_menu = None;
-        app.ui.tool_flyout = None;
-        // Clicking the canvas takes focus from panel fields.
-        ctx.memory_mut(|m| {
-            if let Some(f) = m.focused() {
-                m.surrender_focus(f);
-            }
-        });
-        Some(PointerKind::Down)
-    } else if app.canvas.dragging && primary_released {
-        app.canvas.dragging = false;
-        Some(PointerKind::Up)
-    } else if app.canvas.dragging && primary_down {
-        Some(PointerKind::Move)
-    } else if resp.hovered() {
-        app.canvas.hovering = true;
-        Some(PointerKind::Hover)
-    } else {
-        // Something over the canvas took the pointer.
-        if std::mem::take(&mut app.canvas.hovering) {
-            app.session.pointer_left();
-        }
-        None
-    };
-    // Pen pressure comes with touch events (a pen on Windows, a stylus in a browser); a mouse,
-    // macOS and Linux tablets report none and draw at the stroke weight.
-    let force = ctx.input(|i| {
-        i.events.iter().rev().find_map(|e| match e {
-            egui::Event::Touch { force: Some(f), .. } if f.is_finite() && *f > 0.0 => Some(f.clamp(0.0, 1.0)),
-            _ => None,
-        })
-    });
-    if force.is_some() {
-        app.canvas.pressure = force;
-    }
-    if let Some(k) = kind {
-        send(app, k, pos, &mods);
-        // The pointer also let go within this frame (a quick click, or a slow frame): the tools get
-        // the release too, so the press's gesture ends — a quick click with a shape tool still
-        // draws and returns to Move, and a double-click right after drawing finds the Move tool.
-        if matches!(k, PointerKind::Down) && primary_released {
-            app.canvas.dragging = false;
-            send(app, PointerKind::Up, pos, &mods);
-        }
-    }
-    true
-}
-
-/// Pointer event `kind` at screen point `pos`, to the tools.
-fn send(app: &mut FigApp, kind: PointerKind, pos: Pos2, m: &egui::Modifiers) {
-    let ev = pointer_event(app, kind, pos, m);
-    if kind == PointerKind::Up {
-        app.canvas.pressure = None;
-    }
-    app.canvas.last_pointer = Some(Point::new(ev.x, ev.y));
-    if let Err(e) = app.session.pointer(&ev) {
-        app.toast(e.to_string());
-    }
-    app.handle_ui_requests();
-}
-
-/// Right-click at screen `pos`: select what's under the pointer (`deep`: the nested layer), then
-/// open the context menu there.
-pub fn open_context_menu(app: &mut FigApp, pos: Pos2, deep: bool) {
-    let p = app.to_page(pos);
-    if let Ok(ds) = app.session.ds() {
-        let (doc, page, sel, zoom) = (ds.doc.clone(), ds.page, ds.selection.clone(), ds.view.zoom.max(1e-6));
-        if let Some(leaf) = app.session.hit(&doc, page, p, 2.0 / zoom) {
-            let target = figcraft_doc::geometry::select_target(&doc, leaf, &sel, deep);
-            if !sel.contains(&target) {
-                app.session.set_selection(vec![target]);
-            }
-        }
-    }
-    app.ui.context_menu = Some((pos, app.session.selection()));
-    app.ui.context_menu_shown = false;
-}
-
-fn stroke(c: Color32, w: f32) -> Stroke {
-    Stroke::new(w, c)
-}
-
-/// A text layer's layout placed on the canvas: where carets and selected characters show (yours
-/// and other people's in a live session).
-pub(crate) struct TextOnScreen {
-    pub layout: Arc<figcraft_text::TextLayout>,
-    /// How many characters the text has.
-    pub chars: usize,
-    /// The layout's vertical offset in the box (vertical alignment).
-    dy: f64,
-    world: figcraft_geom::Affine,
-}
-
-impl TextOnScreen {
-    /// Text layer `id` of `doc` (`None`: not a text layer).
-    pub(crate) fn of(doc: &Document, id: NodeId) -> Option<Self> {
-        let n = doc.node(id)?;
-        let NodeKind::Text(t) = &n.kind else { return None };
-        let (layout, dy) = figcraft_text::layout_node(n)?;
-        Some(Self { layout, chars: t.char_count(), dy, world: doc.world_transform(id) })
-    }
-
-    /// Layout point `(x, y)` on screen (on the path, for text on a path).
-    pub(crate) fn at(&self, app: &FigApp, x: f64, y: f64) -> Pos2 {
-        let q = self.layout.warp_point(x, y);
-        let p = self.world * Point::new(q.x, q.y + self.dy);
-        app.to_screen(p.x, p.y)
-    }
-
-    /// The highlight of characters `a..b`, one screen quad per line.
-    pub(crate) fn selection(&self, app: &FigApp, a: usize, b: usize) -> Vec<[Pos2; 4]> {
-        let rects = self.layout.selection_rects(a, b);
-        rects.iter().map(|r| [self.at(app, r.x0, r.y0), self.at(app, r.x1, r.y0), self.at(app, r.x1, r.y1), self.at(app, r.x0, r.y1)]).collect()
-    }
-
-    /// The caret before character `index`: its top and bottom on screen (an empty layer: a line
-    /// of default height at its origin).
-    pub(crate) fn caret(&self, app: &FigApp, index: usize, zoom: f64) -> [Pos2; 2] {
-        let (cx, li) = self.layout.caret(index);
-        match self.layout.lines.get(li).or(self.layout.lines.last()) {
-            Some(line) => [self.at(app, cx, line.top), self.at(app, cx, line.top + line.height)],
-            None => {
-                let p = self.at(app, 0.0, 0.0);
-                [p, p + vec2(0.0, 14.0 * zoom as f32)]
-            }
-        }
-    }
-}
-
-/// A node's oriented outline in screen space.
-pub(crate) fn node_quad(app: &FigApp, doc: &Document, id: NodeId) -> Option<[Pos2; 4]> {
-    let n = doc.node(id)?;
-    let w = doc.world_transform(id);
-    let corners = [Point::new(0.0, 0.0), Point::new(n.width, 0.0), Point::new(n.width, n.height), Point::new(0.0, n.height)];
-    Some(corners.map(|c| {
-        let p = w * c;
-        app.to_screen(p.x, p.y)
-    }))
-}
-
-fn quad(painter: &egui::Painter, q: [Pos2; 4], s: Stroke) {
-    painter.add(Shape::closed_line(q.to_vec(), s));
-}
-
-/// The slots of the selected components and instances (and a slot being dropped onto): a dashed
-/// outline and the slot's name above its top-left corner, like a frame label (never over the
-/// content).
-fn slot_badges(app: &FigApp, painter: &egui::Painter, doc: &Document, sel: &[NodeId], drop: Option<NodeId>) {
-    use figcraft_engine::components::{owning_component, owning_instance, slot_name, slots_of};
-    let mut roots: Vec<NodeId> = Vec::new();
-    for id in sel {
-        let root = match doc.node(*id).map(|n| &n.kind) {
-            Some(NodeKind::Instance { .. } | NodeKind::Component { .. } | NodeKind::ComponentSet { .. }) => Some(*id),
-            _ => owning_instance(doc, *id).or_else(|| owning_component(doc, *id)),
-        };
-        if let Some(r) = root.filter(|r| !roots.contains(r)) {
-            roots.push(r);
-        }
-    }
-    let mut slots: Vec<(NodeId, String)> = roots.iter().flat_map(|r| slots_of(doc, *r)).collect();
-    if let Some(d) = drop
-        && !slots.iter().any(|(s, _)| *s == d)
-        && let Some(name) = slot_name(doc, d)
-    {
-        slots.push((d, name));
-    }
-    for (id, name) in slots {
-        let Some(q) = node_quad(app, doc, id) else { continue };
-        if !Rect::from_points(&q).intersects(app.canvas.rect) {
-            continue;
-        }
-        painter.extend(Shape::dashed_line(&[q[0], q[1], q[2], q[3], q[0]], stroke(COMPONENT, 1.0), 4.0, 3.0));
-        // The label, when the slot is wide enough on screen to hold it.
-        let galley = painter.layout_no_wrap(name, regular(10.0), COMPONENT);
-        let (w, h) = (galley.size().x + 14.0, galley.size().y.max(11.0));
-        if (q[1] - q[0]).length() < w {
-            continue;
-        }
-        let at = q[0] - vec2(0.0, h + 2.0);
-        crate::icons::paint(painter, Rect::from_min_size(pos2(at.x, at.y + (h - 11.0) / 2.0), vec2(11.0, 11.0)), crate::icons::Icon::Slot, COMPONENT);
-        painter.galley(pos2(at.x + 14.0, at.y + (h - galley.size().y) / 2.0), galley, COMPONENT);
-    }
-}
-
-/// The instance an Alt-drop of a component from the Assets panel swaps: tinted and outlined in
-/// the component colour, with a "Swap instance" label above its top-left corner.
-fn swap_highlight(app: &FigApp, painter: &egui::Painter, doc: &Document, id: NodeId) {
-    let Some(q) = node_quad(app, doc, id) else { return };
-    // White on the component colour, in both themes (like the canvas's selection labels).
-    let ink = Color32::WHITE;
-    painter.add(Shape::convex_polygon(q.to_vec(), COMPONENT.gamma_multiply(0.12), Stroke::NONE));
-    quad(painter, q, stroke(COMPONENT, 2.0));
-    let galley = painter.layout_no_wrap(tr("Swap instance").to_string(), semibold(10.0), ink);
-    let size = vec2(galley.size().x + 26.0, 18.0);
-    let top = Rect::from_points(&q).min;
-    let pill = Rect::from_min_size(pos2(top.x, top.y - size.y - 4.0), size);
-    painter.rect_filled(pill, CornerRadius::same(4), COMPONENT);
-    crate::icons::paint(
-        painter,
-        Rect::from_center_size(pos2(pill.min.x + 11.0, pill.center().y), vec2(10.0, 10.0)),
-        crate::icons::Icon::Instance,
-        ink,
-    );
-    painter.galley(pos2(pill.min.x + 20.0, pill.center().y - galley.size().y / 2.0), galley, ink);
-}
-
-/// The outline colour for a layer: purple for components, sets and instances and every layer in
-/// them, the page's overlay `green` otherwise.
-fn outline_colour(doc: &Document, id: NodeId, green: Color32) -> Color32 {
-    use figcraft_engine::components::{owning_component, owning_instance};
-    let set = matches!(doc.node(id).map(|n| &n.kind), Some(NodeKind::ComponentSet { .. }));
-    if set || owning_component(doc, id).is_some() || owning_instance(doc, id).is_some() { COMPONENT } else { green }
-}
-
-/// The outline path of shapes (ellipses, vectors) for hover/selection outlines.
-fn outline_shape(app: &FigApp, doc: &Document, id: NodeId) -> Option<Vec<Vec<Pos2>>> {
-    let n = doc.node(id)?;
-    if !matches!(
-        n.kind,
-        NodeKind::Ellipse { .. } | NodeKind::Vector { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. } | NodeKind::BooleanOp { .. }
-    ) {
-        return None;
-    }
-    let (path, _) = figcraft_render::node_outline(doc, n)?;
-    let w = doc.world_transform(id);
-    let mut out = Vec::new();
-    let mut cur: Vec<Pos2> = Vec::new();
-    figcraft_geom::kurbo::flatten(path.iter(), 0.5 / app.session.ds().map(|d| d.view.zoom).unwrap_or(1.0), |el| {
-        use figcraft_geom::kurbo::PathEl::*;
-        match el {
-            MoveTo(p) => {
-                if cur.len() > 1 {
-                    out.push(std::mem::take(&mut cur));
-                }
-                cur.clear();
-                let q = w * p;
-                cur.push(app.to_screen(q.x, q.y));
-            }
-            LineTo(p) => {
-                let q = w * p;
-                cur.push(app.to_screen(q.x, q.y));
-            }
-            ClosePath => {
-                if let Some(f) = cur.first().copied() {
-                    cur.push(f);
-                }
-            }
-            _ => {}
-        }
-    });
-    if cur.len() > 1 {
-        out.push(cur);
-    }
-    Some(out)
-}
-
-/// A layer's outline on the canvas: its shape for ellipses, vectors, polygons, stars and boolean
-/// groups, its box otherwise.
-fn draw_outline(app: &FigApp, painter: &egui::Painter, doc: &Document, id: NodeId, s: Stroke) {
-    match outline_shape(app, doc, id) {
-        Some(lines) => {
-            for l in lines {
-                painter.add(Shape::line(l, s));
-            }
-        }
-        None => {
-            if let Some(q) = node_quad(app, doc, id) {
-                quad(painter, q, s);
-            }
-        }
-    }
-}
-
-/// Everything drawn over the rendered page; returns the frame labels drawn (frame, corners on the
-/// page) for the engine to hit-test.
-fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [Point; 4])> {
-    let mut labels = Vec::new();
-    let Ok(ds) = app.session.ds() else { return labels };
-    let doc = ds.doc.clone();
-    let page = ds.page;
-    let sel = ds.selection.clone();
-    let zoom = ds.view.zoom;
-    let view = ds.view.clone();
-    // Pixel grid at high zoom.
-    if view.pixel_grid_shown() {
-        let r = app.canvas.rect;
-        let p0 = app.to_page(r.min);
-        let p1 = app.to_page(r.max);
-        let col = Color32::from_black_alpha(18);
-        let mut x = p0.x.floor();
-        while x <= p1.x {
-            let s = app.to_screen(x, 0.0).x;
-            painter.line_segment([pos2(s, r.min.y), pos2(s, r.max.y)], stroke(col, 1.0));
-            x += 1.0;
-        }
-        let mut y = p0.y.floor();
-        while y <= p1.y {
-            let s = app.to_screen(0.0, y).y;
-            painter.line_segment([pos2(r.min.x, s), pos2(r.max.x, s)], stroke(col, 1.0));
-            y += 1.0;
-        }
-    }
-    // Layout grids and frame labels for top-level frames (also those in sections); the focus view
-    // labels only its frame.
-    let focus = ds.focused();
-    for c in boards(&doc, page).iter().filter(|c| focus.is_none_or(|f| f == **c)) {
-        let Some(n) = doc.node(*c) else { continue };
-        let Some(b) = doc.world_bounds(*c) else { continue };
-        // Off-screen frames draw neither grids nor a label (labels sit just outside the frame).
-        let on_screen = Rect::from_two_pos(app.to_screen(b.x0, b.y0), app.to_screen(b.x1, b.y1)).expand(20.0);
-        if !on_screen.intersects(app.canvas.rect) {
-            continue;
-        }
-        if view.layout_grids && !n.grids.is_empty() && figcraft_layout::grids_shown(&doc, *c) {
-            let w = doc.world_transform(*c);
-            for g in n.grids.iter().filter(|g| g.visible) {
-                let col = doc_c32(painter.ctx(), g.color);
-                for r in figcraft_layout::grid_lines(g, n.width, n.height) {
-                    let a = w * Point::new(r.x0, r.y0);
-                    let b = w * Point::new(r.x1, r.y1);
-                    let (sa, sb) = (app.to_screen(a.x, a.y), app.to_screen(b.x, b.y));
-                    if g.kind == figcraft_doc::GridKind::Grid {
-                        painter.line_segment([sa, sb], stroke(col, 1.0));
-                    } else {
-                        painter.rect_filled(Rect::from_two_pos(sa, sb), CornerRadius::ZERO, col);
-                    }
-                }
-            }
-        }
-        // The focus view's bar names its frame.
-        // Board objects (stickies, shapes with text, stamps) are frames without a name label.
-        let labelled = focus.is_none() && (n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. })) && !n.is_board_atom();
-        if labelled && let Some(q) = crate::frame_labels::draw(app, painter, t, &doc, *c, sel.contains(c), ds.hover == Some(*c)) {
-            labels.push((*c, q.map(|p| app.to_page(p))));
-        }
-    }
-    // Prototype connections.
-    crate::proto_canvas::draw(app, painter);
-    // Hover outline (measuring outlines the measured box in red instead).
-    if let Some(h) = ds.hover
-        && !sel.contains(&h)
-        && matches!(app.session.tool.tool, ToolId::Move | ToolId::Scale)
-        && app.session.prefs.highlight_on_hover
-        && app.session.tool.overlay.measure_box.is_none()
-    {
-        draw_outline(app, painter, &doc, h, stroke(outline_colour(&doc, h, accent(painter)), 1.5));
-    }
-    // Inside a boolean group (an operand selected or in vector edit mode): every operand's outline,
-    // so the shapes making the live result stay visible while one of them changes.
-    let operands = figcraft_engine::booleans::outlined_operands(&doc, &sel, ds.vector_edit.as_ref().map(|ve| ve.id));
-    for id in operands.iter().filter(|o| !sel.contains(o)) {
-        draw_outline(app, painter, &doc, *id, stroke(outline_colour(&doc, *id, accent(painter)).gamma_multiply(0.6), 1.0));
-    }
-    // Mask outlines (a mask doesn't draw itself), frame outlines and slices, as the View menu shows.
-    if view.mask_outlines || view.frame_outlines || view.show_slices {
-        for id in doc.subtree(page) {
-            let Some(n) = doc.node(id).filter(|n| n.visible) else { continue };
-            if view.mask_outlines && n.is_mask {
-                draw_outline(app, painter, &doc, id, stroke(accent(painter), 1.0));
-            } else if view.frame_outlines && n.kind.is_frame_like() {
-                draw_outline(app, painter, &doc, id, stroke(t.text_secondary, 1.0));
-            } else if view.show_slices
-                && matches!(n.kind, NodeKind::Slice)
-                && let Some(q) = node_quad(app, &doc, id)
-            {
-                painter.extend(Shape::dashed_line(&[q[0], q[1], q[2], q[3], q[0]], stroke(t.text_secondary, 1.0), 4.0, 3.0));
-            }
-        }
-    }
-    // Drop target / insertion indicator.
-    let ov = &app.session.tool.overlay;
-    if let Some(d) = ov.drop_target
-        && let Some(q) = node_quad(app, &doc, d)
-    {
-        quad(painter, q, stroke(if figcraft_engine::components::is_slot(&doc, d) { COMPONENT } else { accent(painter) }, 1.0));
-    }
-    slot_badges(app, painter, &doc, &sel, ov.drop_target);
-    if let Some(t) = ov.swap_target {
-        swap_highlight(app, painter, &doc, t);
-    }
-    if let Some([x0, y0, x1, y1]) = ov.insert_line {
-        painter.line_segment([app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(accent(painter), 2.0));
-    }
-    if let Some([x0, y0, x1, y1]) = ov.drop_cell {
-        let r = Rect::from_two_pos(app.to_screen(x0, y0), app.to_screen(x1, y1));
-        painter.rect_filled(r, CornerRadius::same(2), accent(painter).gamma_multiply(0.12));
-        let pts = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.left_top()];
-        painter.add(Shape::dashed_line(&pts, stroke(accent(painter), 1.5), 4.0, 3.0));
-    }
-    // Vector edit mode, with the transform box around several selected points.
-    // The selection's size label, which measurement labels keep clear of.
-    let mut size_label = None;
-    if let Some(ve) = ds.vector_edit.clone()
-        && let Some(o) = figcraft_engine::vectoredit::overlay(&doc, &ve)
-    {
-        // The Variable width tool shows width points in place of the path's points.
-        let width_tool = ve.tool == figcraft_engine::vectoredit::VTool::Width;
-        // Other layers edited at once go under the active one; the hover shows on its own layer.
-        let ov = &app.session.tool.overlay;
-        let hover_on = |id| ov.vector_hover.filter(|_| ov.vector_hover_on.unwrap_or(ve.id) == id);
-        for part in &ve.others {
-            if let Some(po) = figcraft_engine::vectoredit::overlay(&doc, &ve.view(part)) {
-                vector_overlay(app, painter, &po, !width_tool, hover_on(part.id), false, None);
-            }
-        }
-        vector_overlay(app, painter, &o, !width_tool, hover_on(ve.id), true, ov.vector_add);
-        if width_tool {
-            width_overlay(app, painter, &doc, &ve, zoom);
-        } else if let Some(c) = app.session.vector_edit_box() {
-            // The box around several selected points draws no corner handles: they would read as
-            // points. Its corners and edges still scale the points when dragged.
-            let label = format!("{} × {}", fmt((c[1] - c[0]).hypot()), fmt((c[3] - c[0]).hypot()));
-            size_label = transform_box(app, painter, c.map(|p| app.to_screen(p.x, p.y)), accent(painter), true, 0, Some(label));
-        }
-    }
-    // Selection.
-    let editing = ds.text_edit.clone();
-    if !sel.is_empty() && editing.is_none() && ds.vector_edit.is_none() {
-        let col = if sel.iter().any(|i| outline_colour(&doc, *i, accent(painter)) == COMPONENT) { COMPONENT } else { accent(painter) };
-        for id in &sel {
-            draw_outline(app, painter, &doc, *id, stroke(col, 1.0));
-        }
-        // The shape builder reshapes by regions: no transform box.
-        if app.session.tool.tool != ToolId::ShapeBuilder
-            && let Some(b) = selection_box(&doc, &sel)
-            && let Some((_, w, h)) = selection_frame(&doc, &sel)
-        {
-            let is_line = sel.len() == 1 && matches!(sel.first().and_then(|i| doc.node(*i)).map(|n| &n.kind), Some(NodeKind::Line));
-            // A selected connector's handles are its two ends (drag one onto another object).
-            let connector = figcraft_engine::board::selected_connector_ends(&doc, &sel).map(|(_, ends)| ends);
-            let mut label = if is_line { fmt(w) } else { format!("{} × {}", fmt(w), fmt(h)) };
-            let scale = app.session.tool.overlay.scale;
-            if let Some(hint) = scale {
-                label = format!("{label} · {}x", fmt(hint.factor.abs()));
-            }
-            // A layer smaller than its handles on screen shows just its outline (they still answer
-            // just outside it).
-            let tiny = figcraft_engine::tools::box_sides_px(&b, zoom).1 < figcraft_engine::tools::SMALL_BOX_PX;
-            // Measuring to another layer (Alt held) shows just the outlines: no handles or size.
-            let measuring = app.session.tool.overlay.measure_box.is_some();
-            // Locked layers (selected in the layers panel) can't be resized, nor anything in Dev
-            // Mode: no handles either.
-            let handles =
-                if measuring || app.session.tool.dev_mode || connector.is_some() || sel.iter().any(|i| figcraft_engine::tools::locked_in(&doc, *i)) {
-                    0
-                } else if is_line {
-                    2
-                } else if tiny {
-                    0
-                } else {
-                    4
-                };
-            size_label = transform_box(
-                app,
-                painter,
-                b.map(|p| app.to_screen(p.x, p.y)),
-                col,
-                sel.len() > 1,
-                handles,
-                (!measuring && connector.is_none()).then_some(label),
-            );
-            for end in connector.into_iter().flatten().filter(|_| !app.session.tool.dev_mode) {
-                let c = app.to_screen(end.x, end.y);
-                painter.circle_filled(c, 5.0, Color32::WHITE);
-                painter.circle_stroke(c, 5.0, stroke(col, 1.5));
-            }
-            if !measuring {
-                arc_overlay(app, painter, col);
-                shape_overlay(app, painter, col);
-            }
-            if app.session.tool.tool == ToolId::Scale {
-                // The point that stays put: the dragged pivot, else the anchor.
-                let pivot = scale
-                    .map(|h| Point::new(h.pivot[0], h.pivot[1]))
-                    .or_else(|| figcraft_engine::tools::scale_anchor_point(&doc, &sel, app.session.tool.scale_anchor));
-                if let Some(p) = pivot {
-                    let c = app.to_screen(p.x, p.y);
-                    painter.circle_filled(c, 4.0, Color32::WHITE);
-                    painter.circle_stroke(c, 4.0, stroke(col, 1.5));
-                    painter.circle_filled(c, 1.5, col);
-                }
-            }
-            // The rotation origin while it shows (Alt+R): a ring with a cross through it.
-            if let Some(o) = ds.origin_handle() {
-                let c = app.to_screen(o.x, o.y);
-                painter.circle_filled(c, 5.0, Color32::WHITE);
-                painter.circle_stroke(c, 5.0, stroke(col, 1.5));
-                for d in [vec2(1.0, 0.0), vec2(0.0, 1.0)] {
-                    painter.line_segment([c - d * 10.0, c - d * 5.0], stroke(col, 1.5));
-                    painter.line_segment([c + d * 5.0, c + d * 10.0], stroke(col, 1.5));
-                }
-                painter.circle_filled(c, 1.5, col);
-            }
-        }
-    }
-    if app.session.tool.tool == ToolId::ShapeBuilder
-        && let Some(arr) = figcraft_engine::shapebuilder::current(&app.session)
-    {
-        builder_overlay(app, painter, t, &arr);
-    }
-    // Text editing: caret and selection, or the IME composition underlined at the caret.
-    let preedit = app.preedit_view();
-    let edoc: &Document = preedit.map(|p| &*p.doc).unwrap_or(&doc);
-    if let Some(te) = editing
-        && let Some(text) = TextOnScreen::of(edoc, te.id)
-    {
-        let layout = &text.layout;
-        if let Some(q) = node_quad(app, edoc, te.id) {
-            quad(painter, q, stroke(accent(painter), 1.0));
-        }
-        let (a, b) = (te.caret.min(te.anchor), te.caret.max(te.anchor));
-        if a != b && preedit.is_none() {
-            for q in text.selection(app, a, b) {
-                painter.add(Shape::convex_polygon(q.to_vec(), accent(painter).gamma_multiply(0.3), Stroke::NONE));
-            }
-        }
-        if let Some(p) = preedit {
-            for r in layout.selection_rects(p.range.0, p.range.1) {
-                // Underline just below the baseline, across the composed chars only.
-                let Some(line) = layout.lines.iter().find(|l| (l.top - r.y0).abs() < 1e-6) else { continue };
-                let x1 = layout
-                    .glyphs
-                    .get(line.glyph_start..line.glyph_end)
-                    .unwrap_or(&[])
-                    .iter()
-                    .filter(|g| g.char_end > g.char_start && g.char_start >= p.range.0 && g.char_end <= p.range.1)
-                    .map(|g| g.x + g.advance)
-                    .fold(r.x0, f64::max);
-                let y = line.baseline + (line.top + line.height - line.baseline) * 0.35;
-                painter.line_segment([text.at(app, r.x0, y), text.at(app, x1, y)], stroke(t.text, 1.0));
-            }
-        }
-        let caret = preedit.map(|p| p.cursor).unwrap_or(te.caret);
-        let blink = (painter.ctx().input(|i| i.time) * 2.0) as i64 % 2 == 0;
-        if blink || a != b {
-            painter.line_segment(text.caret(app, caret, zoom), stroke(t.text, 1.0));
-        }
-        painter.ctx().request_repaint_after(std::time::Duration::from_millis(500));
-    }
-    // Smart guides and measurements (their labels kept clear of the size label).
-    crate::measure_overlay::draw(app, painter, t, size_label);
-    // Marquee.
-    if let Some([x0, y0, x1, y1]) = ov.marquee.or(app.ui.key_box) {
-        let r = Rect::from_two_pos(app.to_screen(x0, y0), app.to_screen(x1, y1));
-        painter.rect_filled(r, CornerRadius::ZERO, accent(painter).gamma_multiply(0.1));
-        painter.rect_stroke(r, CornerRadius::ZERO, stroke(accent(painter), 1.0), StrokeKind::Inside);
-    }
-    // Pen path.
-    if !ov.pen.is_empty() {
-        let pts: Vec<Pos2> = ov.pen.iter().map(|[x, y]| app.to_screen(*x, *y)).collect();
-        if app.session.tool.tool == ToolId::Pencil {
-            // The stroke it will make, in its colour and weight (at least a point when zoomed out).
-            let (color, weight) = figcraft_engine::tools::PENCIL_STROKE;
-            painter.add(Shape::line(pts, stroke(doc_c32(painter.ctx(), color), ((weight * zoom) as f32).max(1.0))));
-        } else {
-            for [x0, y0, x1, y1] in &ov.pen_handles {
-                bezier_handle(painter, app.to_screen(*x0, *y0), app.to_screen(*x1, *y1), 3.5, Color32::WHITE);
-            }
-            for p in &pts {
-                painter.circle_filled(*p, 3.5, Color32::WHITE);
-                painter.circle_stroke(*p, 3.5, stroke(accent(painter), 1.0));
-            }
-            if let Some([x0, y0, x1, y1]) = ov.rubber {
-                let (a, b) = (app.to_screen(x0, y0), app.to_screen(x1, y1));
-                // The segment a click would make: along the last anchor's out handle, if it has one.
-                match ov.rubber_handle {
-                    Some([hx, hy]) => {
-                        let h = app.to_screen(hx, hy);
-                        painter.add(egui::epaint::CubicBezierShape::from_points_stroke(
-                            [a, h, b, b],
-                            false,
-                            Color32::TRANSPARENT,
-                            stroke(accent(painter), 1.0),
-                        ));
-                    }
-                    None => {
-                        painter.line_segment([a, b], stroke(accent(painter), 1.0));
-                    }
-                }
-            }
-        }
-    } else if let Some([x0, y0, x1, y1]) = ov.rubber {
-        // A connector being drawn, or one of its ends dragged: from where it starts to the pointer.
-        painter.line_segment([app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(accent(painter), 1.5));
-    }
-    // Eraser brush (vector edit mode).
-    if let Some([x, y, r]) = ov.brush {
-        let c = app.to_screen(x, y);
-        let rs = (r * app.session.ds().map(|d| d.view.zoom).unwrap_or(1.0)) as f32;
-        painter.circle_stroke(c, rs, stroke(Color32::WHITE, 3.0));
-        painter.circle_stroke(c, rs, stroke(accent(painter), 1.5));
-    }
-    // Lasso (vector edit mode).
-    if ov.lasso.len() > 1 {
-        let mut pts: Vec<Pos2> = ov.lasso.iter().map(|[x, y]| app.to_screen(*x, *y)).collect();
-        if let Some(first) = pts.first().copied() {
-            pts.push(first);
-        }
-        painter.add(Shape::dashed_line(&pts, stroke(accent(painter), 1.0), 4.0, 3.0));
-    }
-    // Guides (under the rulers).
-    crate::guides::draw(app, painter);
-    // Rulers.
-    if view.rulers {
-        rulers(app, painter, t, &doc, &sel);
-    }
-    labels
-}
-
-/// A transform box (screen corners tl, tr, br, bl): its outline when `outline`, the first `handles`
-/// corner handles and, when dimensions are shown, the size `label` (if any) under it (its box returned).
-fn transform_box(
-    app: &FigApp,
-    painter: &egui::Painter,
-    q: [Pos2; 4],
-    col: Color32,
-    outline: bool,
-    handles: usize,
-    label: Option<String>,
-) -> Option<Rect> {
-    if outline {
-        quad(painter, q, stroke(col, 1.0));
-    }
-    for c in q.iter().take(handles) {
-        let r = Rect::from_center_size(*c, vec2(8.0, 8.0));
-        painter.rect_filled(r, CornerRadius::same(1), Color32::WHITE);
-        painter.rect_stroke(r, CornerRadius::same(1), stroke(col, 1.0), StrokeKind::Inside);
-    }
-    if let Some(label) = label.filter(|_| app.session.prefs.show_dimensions) {
-        let bottom = q.iter().map(|p| p.y).fold(f32::MIN, f32::max);
-        let cx = q.iter().map(|p| p.x).sum::<f32>() / 4.0;
-        return Some(pill(painter, pos2(cx, bottom + 9.0), Align2::CENTER_TOP, label, col));
-    }
-    None
-}
-
-/// A canvas readout: white `text` on a `col` pill placed at `at` by `align` (its box returned).
-fn pill(painter: &egui::Painter, at: Pos2, align: Align2, text: String, col: Color32) -> Rect {
-    let galley = painter.layout_no_wrap(text, semibold(11.0), Color32::WHITE);
-    let r = align.anchor_size(at, galley.size() + vec2(8.0, 4.0));
-    painter.rect_filled(r, CornerRadius::same(3), crate::theme::under_white(col));
-    painter.galley(r.min + vec2(4.0, 2.0), galley, Color32::WHITE);
-    r
-}
-
-/// The selected ellipse's arc handles (the hovered or dragged one larger, Start with a dot inside)
-/// and, while one is dragged, its readout beside it.
-fn arc_overlay(app: &FigApp, painter: &egui::Painter, col: Color32) {
-    use figcraft_engine::arc_handles::ArcHandle;
-    let Some(hs) = app.session.arc_handles() else { return };
-    let ov = &app.session.tool.overlay;
-    for h in [ArcHandle::Ratio, ArcHandle::Start, ArcHandle::Sweep] {
-        let Some([x, y]) = hs.at(h) else { continue };
-        let c = app.to_screen(x, y);
-        let r = if ov.arc_hover == Some(h) { 5.0 } else { 4.0 };
-        painter.circle_filled(c, r, Color32::WHITE);
-        painter.circle_stroke(c, r, stroke(col, 1.0));
-        if h == ArcHandle::Start {
-            painter.circle_filled(c, 1.5, col);
-        }
-    }
-    if let Some(hint) = &ov.arc {
-        let c = app.to_screen(hint.at[0], hint.at[1]);
-        pill(painter, c + vec2(12.0, 12.0), Align2::LEFT_TOP, hint.label.clone(), col);
-    }
-}
-
-/// The selected shape's corner radius handles and a star's ratio handle (the hovered or dragged
-/// one larger) and, while one is dragged, its value beside it.
-fn shape_overlay(app: &FigApp, painter: &egui::Painter, col: Color32) {
-    use figcraft_engine::shape_handles::ShapeHandle;
-    let ov = &app.session.tool.overlay;
-    for (h, [x, y]) in app.session.shape_handles() {
-        let r = if ov.shape_hover == Some(h) { 4.5 } else { 3.5 };
-        let c = app.to_screen(x, y);
-        painter.circle_filled(c, r, Color32::WHITE);
-        painter.circle_stroke(c, r, stroke(col, 1.0));
-    }
-    if let Some(hint) = &ov.shape {
-        let c = app.to_screen(hint.at[0], hint.at[1]);
-        let text = match hint.handle {
-            ShapeHandle::Radius { .. } => format!("{} {}", tr("Radius"), hint.value),
-            ShapeHandle::Ratio => format!("{} {}%", tr("Ratio"), hint.value),
-        };
-        pill(painter, c + vec2(12.0, 12.0), Align2::LEFT_TOP, text, col);
-    }
-}
-
-/// Variable width tool: each width point on the path with a bar across the stroke to its two
-/// width handles (the selected point filled), and a faint preview where a drag would add one.
-fn width_overlay(app: &FigApp, painter: &egui::Painter, doc: &Document, ve: &figcraft_engine::vectoredit::VectorEdit, zoom: f64) {
-    use figcraft_doc::WidthSide;
-    use figcraft_engine::vectoredit::{WHit, width_handles, width_preview};
-    let hover = app.session.tool.overlay.width_hover;
-    let sp = |p: &[f64; 2]| app.to_screen(p[0], p[1]);
-    let draw = |h: &figcraft_engine::vectoredit::WidthHandle, ghost: bool| {
-        let (c, a, b) = (sp(&h.at), sp(&h.sides[0]), sp(&h.sides[1]));
-        let col = if ghost { accent(painter).gamma_multiply(0.5) } else { accent(painter) };
-        painter.line_segment([a, b], stroke(Color32::from_white_alpha(160), 3.0));
-        painter.line_segment([a, b], stroke(col, 1.0));
-        for (e, side) in [(a, WidthSide::Right), (b, WidthSide::Left)] {
-            let grab = !ghost && hover == Some(WHit::Handle { index: h.index, side });
-            let r = if grab { 4.5 } else { 3.5 };
-            painter.circle_filled(e, r, Color32::WHITE);
-            painter.circle_stroke(e, r, stroke(col, 1.0));
-        }
-        let on = !ghost && ve.width_point == Some(h.index);
-        let hovered = !ghost && hover == Some(WHit::Point { index: h.index });
-        let r = if hovered { 5.0 } else { 4.0 };
-        painter.circle_filled(c, r, if on { accent(painter) } else { Color32::WHITE });
-        painter.circle_stroke(c, r, stroke(col, 1.0));
-    };
-    for h in width_handles(doc, ve, zoom) {
-        draw(&h, false);
-    }
-    if let Some(WHit::Path { t, .. }) = hover {
-        for h in width_preview(doc, ve, t, zoom) {
-            draw(&h, true);
-        }
-    }
-}
-
-/// A bezier handle from its anchor `v` to its end `e` (screen points): the line, and a dot of
-/// radius `r` filled with `fill` (vector edit mode and the Pen draw them alike).
-fn bezier_handle(painter: &egui::Painter, v: Pos2, e: Pos2, r: f32, fill: Color32) {
-    painter.line_segment([v, e], stroke(accent(painter), 1.0));
-    painter.circle_filled(e, r, fill);
-    painter.circle_stroke(e, r, stroke(accent(painter), 1.0));
-}
-
-/// Vector edit mode: a layer's segments, handles and points (`points`) with its `hover`ed part, the
-/// `add` point a press would put on the outline, and for the `active` layer the closed area under
-/// the paint bucket and the pen's rubber band.
-fn vector_overlay(
-    app: &FigApp,
-    painter: &egui::Painter,
-    o: &figcraft_engine::vectoredit::EditOverlay,
-    points: bool,
-    hover: Option<figcraft_engine::vectoredit::VHit>,
-    active: bool,
-    add: Option<figcraft_engine::tools::VectorAdd>,
-) {
-    use figcraft_engine::vectoredit::VHit;
-    let ov = &app.session.tool.overlay;
-    let sp = |p: &[f64; 2]| app.to_screen(p[0], p[1]);
-    // Paint bucket target: hatched like a fill to come.
-    if active && !ov.face.is_empty() {
-        let polys: Vec<Vec<Pos2>> = ov.face.iter().map(|poly| poly.iter().map(sp).collect()).collect();
-        hatched(painter, &polys, accent(painter));
-    }
-    if active {
-        region_hatch(app, painter);
-    }
-    let hover_seg = match hover {
-        Some(VHit::Segment { seg, .. }) => Some(seg),
-        _ => None,
-    };
-    for (i, seg) in o.segments.iter().enumerate() {
-        let [a, b, c, d] = [sp(&seg[0]), sp(&seg[1]), sp(&seg[2]), sp(&seg[3])];
-        let w = if o.selected_segments.contains(&i) {
-            3.0
-        } else if hover_seg == Some(i) {
-            2.5
-        } else {
-            1.5
-        };
-        painter.add(egui::epaint::CubicBezierShape::from_points_stroke([a, b, c, d], false, Color32::TRANSPARENT, stroke(accent(painter), w)));
-    }
-    if !points {
-        return;
-    }
-    for h in &o.handles {
-        let hovered = hover == Some(VHit::Handle { seg: h.seg, start: h.start });
-        let on = o.selected_handles.contains(&(h.seg, h.start));
-        bezier_handle(painter, sp(&h.vertex), sp(&h.handle), if hovered { 4.5 } else { 3.5 }, if on { accent(painter) } else { Color32::WHITE });
-    }
-    for (i, v) in o.vertices.iter().enumerate() {
-        let p = sp(v);
-        let hovered = matches!(hover, Some(VHit::Vertex { index }) if index == i);
-        let size = if hovered { 9.0 } else { 7.0 };
-        let r = Rect::from_center_size(p, vec2(size, size));
-        let on = o.selected_vertices.contains(&i);
-        painter.rect_filled(r, CornerRadius::same(5), if on { accent(painter) } else { Color32::WHITE });
-        painter.rect_stroke(r, CornerRadius::same(5), stroke(accent(painter), 1.0), StrokeKind::Inside);
-        if o.anchor == Some(i) {
-            painter.circle_stroke(p, 7.5, stroke(accent(painter), 1.0));
-        }
-    }
-    // The point a press would add to the outline: the pen's ghost anchor where it is over a
-    // segment, or a segment's midpoint under the Move tool (which grows and fills once the pointer
-    // is on it, when a press adds it).
-    if let Some(a) = add {
-        let p = app.to_screen(a.at[0], a.at[1]);
-        let col = accent(painter);
-        if a.midpoint {
-            let (r, fill) = if a.on { (5.5, col) } else { (3.5, Color32::from_white_alpha(190)) };
-            painter.circle_filled(p, r, fill);
-            painter.circle_stroke(p, r, stroke(if a.on { Color32::WHITE } else { col.gamma_multiply(0.7) }, 1.2));
-        } else {
-            let r = Rect::from_center_size(p, vec2(7.0, 7.0));
-            painter.rect_filled(r, CornerRadius::same(5), Color32::from_white_alpha(160));
-            painter.rect_stroke(r, CornerRadius::same(5), stroke(col.gamma_multiply(0.8), 1.0), StrokeKind::Inside);
-        }
-    }
-    if let Some([x0, y0, x1, y1]) = ov.rubber.filter(|_| active) {
-        painter.add(Shape::dashed_line(&[app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(accent(painter), 1.0), 4.0, 3.0));
-    }
-}
-
-/// Width of the lines hatching the hovered and selected regions in vector edit mode (screen px).
-const REGION_HATCH_WIDTH: f32 = 1.4;
-
-/// Vector edit mode: the selected regions and the hovered one hatched in the selection colour,
-/// under the segments and points (the engine lays out and clips the lines).
-fn region_hatch(app: &FigApp, painter: &egui::Painter) {
-    let Ok(ds) = app.session.ds() else { return };
-    let (ox, oy) = ds.view.page_to_screen(0.0, 0.0);
-    let (z, min) = (ds.view.zoom, app.canvas.rect.min);
-    let view = figcraft_geom::Affine::new([z, 0.0, 0.0, z, f64::from(min.x) + ox, f64::from(min.y) + oy]);
-    let r = painter.clip_rect();
-    let clip = figcraft_geom::Rect::new(f64::from(r.min.x), f64::from(r.min.y), f64::from(r.max.x), f64::from(r.max.y));
-    for [a, b] in app.session.vector_region_hatch(view, Some(clip)) {
-        painter.line_segment([pos2(a.x as f32, a.y as f32), pos2(b.x as f32, b.y as f32)], stroke(accent(painter), REGION_HATCH_WIDTH));
-    }
-}
-
-/// Shape builder: every region's edges, and the hovered or collected regions hatched (in the
-/// danger colour when releasing removes them).
-fn builder_overlay(app: &FigApp, painter: &egui::Painter, t: &Tokens, arr: &figcraft_engine::shapebuilder::Arrangement) {
-    let ov = &app.session.tool.overlay;
-    let screen = |r: &figcraft_engine::shapebuilder::Region| -> Vec<Vec<Pos2>> {
-        r.polys.iter().filter_map(|poly| clean_poly(poly.iter().map(|p| app.to_screen(p.x, p.y)))).collect()
-    };
-    // Edges read on any fill: a light halo under a thin accent line.
-    for r in &arr.regions {
-        for poly in screen(r) {
-            for seg in segments(&poly) {
-                painter.add(Shape::line(seg.to_vec(), stroke(Color32::from_white_alpha(150), 2.5)));
-                painter.add(Shape::line(seg.to_vec(), stroke(accent(painter), 1.0)));
-            }
-        }
-    }
-    let col = if ov.builder_remove { t.danger } else { accent(painter) };
-    for r in ov.builder_regions.iter().filter_map(|i| arr.regions.get(*i)) {
-        hatched(painter, &screen(r), col);
-    }
-}
-
-/// A region contour in screen space, ready to draw: non-finite and repeated points dropped (the
-/// last point back at the first, the points a sliver doubles back on) and sub-pixel slivers left
-/// out, since they're invisible anyway.
-fn clean_poly(points: impl IntoIterator<Item = Pos2>) -> Option<Vec<Pos2>> {
-    let mut out: Vec<Pos2> = Vec::new();
-    for q in points {
-        if !(q.x.is_finite() && q.y.is_finite()) || out.last().is_some_and(|l| l.distance(q) < 0.01) {
-            continue;
-        }
-        out.push(q);
-    }
-    if out.len() > 1 && out.first().is_some_and(|f| f.distance(*out.last().unwrap_or(f)) < 0.01) {
-        out.pop();
-    }
-    let n = out.len();
-    let twice_area: f32 = (0..n).map(|k| out[k].x * out[(k + 1) % n].y - out[(k + 1) % n].x * out[k].y).sum();
-    (n > 2 && twice_area.abs() > 0.4).then_some(out)
-}
-
-/// A closed polygon as its segments. Drawn segment by segment rather than as one closed path: a
-/// joined path asks the tessellator for a mitre at every hairpin a region's sliver doubles back on,
-/// and a zero-length segment there divides by a zero normal, which draws a spike across the canvas.
-fn segments(poly: &[Pos2]) -> impl Iterator<Item = [Pos2; 2]> + '_ {
-    let n = poly.len();
-    (0..n).map(move |k| [poly[k], poly[(k + 1) % n]])
-}
-
-/// Polygons hatched and outlined in `col` (an area about to be filled, merged or removed), each
-/// line on a light halo so it reads on any fill, even one in `col`.
-fn hatched(painter: &egui::Painter, polys: &[Vec<Pos2>], col: Color32) {
-    let halo = Color32::from_white_alpha(200);
-    for l in hatch(polys, 6.0) {
-        painter.line_segment(l, stroke(halo, 3.0));
-        painter.line_segment(l, stroke(col, 1.25));
-    }
-    for poly in polys {
-        for seg in segments(poly) {
-            painter.add(Shape::line(seg.to_vec(), stroke(halo, 4.0)));
-            painter.add(Shape::line(seg.to_vec(), stroke(col, 2.0)));
-        }
-    }
-}
-
-/// 45° hatch lines `gap` apart inside polygons (even-odd), in screen space.
-fn hatch(polys: &[Vec<Pos2>], gap: f32) -> Vec<[Pos2; 2]> {
-    // Rotate so the hatch is horizontal, scan, rotate back.
-    let rot = |p: Pos2| pos2((p.x + p.y) * std::f32::consts::FRAC_1_SQRT_2, (p.y - p.x) * std::f32::consts::FRAC_1_SQRT_2);
-    let back = |x: f32, y: f32| pos2((x - y) * std::f32::consts::FRAC_1_SQRT_2, (x + y) * std::f32::consts::FRAC_1_SQRT_2);
-    let edges: Vec<(Pos2, Pos2)> = polys
-        .iter()
-        .flat_map(|poly| {
-            let pts: Vec<Pos2> = poly.iter().map(|p| rot(*p)).collect();
-            let n = pts.len();
-            (0..n).filter_map(move |k| Some((*pts.get(k)?, *pts.get((k + 1) % n)?)))
-        })
-        .collect();
-    let (y0, y1) = edges.iter().fold((f32::INFINITY, f32::NEG_INFINITY), |(lo, hi), (a, b)| (lo.min(a.y).min(b.y), hi.max(a.y).max(b.y)));
-    let mut out = Vec::new();
-    if !(y0.is_finite() && y1.is_finite()) || (y1 - y0) / gap > 4000.0 {
-        return out;
-    }
-    let mut y = (y0 / gap).ceil() * gap;
-    while y < y1 {
-        let mut xs: Vec<f32> = edges
-            .iter()
-            .filter(|(a, b)| (a.y <= y && y < b.y) || (b.y <= y && y < a.y))
-            .map(|(a, b)| a.x + (y - a.y) * (b.x - a.x) / (b.y - a.y))
-            .collect();
-        xs.sort_by(f32::total_cmp);
-        for pair in xs.chunks_exact(2) {
-            if let [a, b] = pair {
-                out.push([back(*a, y), back(*b, y)]);
-            }
-        }
-        y += gap;
-    }
-    out
-}
-
-/// The layers that get canvas labels and layout grids, in z-order: the page's visible top-level
-/// layers and, inside sections whose contents show, their visible children (sections nest). A
-/// section comes after its children, so its title pill draws over (and takes clicks from) the
-/// labels of frames near its top-left (#1150).
-fn boards(doc: &Document, page: NodeId) -> Vec<NodeId> {
-    fn walk(doc: &Document, id: NodeId, depth: usize, out: &mut Vec<NodeId>) {
-        let Some(n) = doc.node(id) else { return };
-        for c in &n.children {
-            let Some(cn) = doc.node(*c) else { continue };
-            if !cn.visible {
-                continue;
-            }
-            if matches!(cn.kind, NodeKind::Section { contents_hidden: false }) && depth < 32 {
-                walk(doc, *c, depth + 1, out);
-            }
-            out.push(*c);
-        }
-    }
-    let mut out = Vec::new();
-    walk(doc, page, 0, &mut out);
-    out
-}
-
-/// A frame's or section's handoff status as its badge says it, with the badge colour ("Changed"
-/// once a ready-for-dev layer was edited; `None` without a status).
-pub(crate) fn status_label(n: &figcraft_doc::Node) -> Option<(&'static str, Color32)> {
-    match n.dev_status {
-        figcraft_doc::DevStatus::None => None,
-        figcraft_doc::DevStatus::ReadyForDev if n.dev_changed => Some((tr("Changed"), crate::theme::DEV_CHANGED)),
-        figcraft_doc::DevStatus::ReadyForDev => Some((tr("Ready for dev"), crate::theme::DEV_READY)),
-        figcraft_doc::DevStatus::Completed => Some((tr("Completed"), crate::theme::DEV_COMPLETED)),
-    }
-}
-
-/// A frame's or section's handoff status as a small pill left-centred on `at`; the pill's area.
-pub(crate) fn status_badge(painter: &egui::Painter, n: &figcraft_doc::Node, at: Pos2) -> Option<Rect> {
-    let (label, fill) = status_label(n)?;
-    let galley = painter.layout_no_wrap(label.to_string(), semibold(10.0), Color32::WHITE);
-    let r = Rect::from_min_size(pos2(at.x, at.y - galley.size().y / 2.0 - 2.0), galley.size() + vec2(10.0, 4.0));
-    painter.rect_filled(r, CornerRadius::same(4), fill);
-    painter.galley(r.min + vec2(5.0, 2.0), galley, Color32::WHITE);
-    Some(r)
-}
-
-fn rulers(app: &FigApp, painter: &egui::Painter, t: &Tokens, doc: &Document, sel: &[NodeId]) {
-    let r = app.canvas.rect;
-    let size = 20.0;
-    painter.rect_filled(Rect::from_min_size(r.min, vec2(r.width(), size)), CornerRadius::ZERO, t.panel);
-    painter.rect_filled(Rect::from_min_size(r.min, vec2(size, r.height())), CornerRadius::ZERO, t.panel);
-    let zoom = app.session.ds().map(|d| d.view.zoom).unwrap_or(1.0);
-    let step = figcraft_engine::guides::ruler_step(zoom);
-    let p0 = app.to_page(r.min);
-    let p1 = app.to_page(r.max);
-    // Highlight the selection's span.
-    if let Some(b) = doc.bounds_of(sel) {
-        let (a, bb) = (app.to_screen(b.x0, b.y0), app.to_screen(b.x1, b.y1));
-        painter.rect_filled(
-            Rect::from_min_max(pos2(a.x, r.min.y), pos2(bb.x, r.min.y + size)),
-            CornerRadius::ZERO,
-            accent(painter).gamma_multiply(0.15),
-        );
-        painter.rect_filled(
-            Rect::from_min_max(pos2(r.min.x, a.y), pos2(r.min.x + size, bb.y)),
-            CornerRadius::ZERO,
-            accent(painter).gamma_multiply(0.15),
-        );
-    }
-    let mut x = (p0.x / step).floor() * step;
-    while x <= p1.x {
-        let s = app.to_screen(x, 0.0).x;
-        painter.line_segment([pos2(s, r.min.y + size - 6.0), pos2(s, r.min.y + size)], stroke(t.text_tertiary, 1.0));
-        painter.text(pos2(s + 2.0, r.min.y + 3.0), Align2::LEFT_TOP, fmt(x), regular(9.0), t.text_secondary);
-        x += step;
-    }
-    let mut y = (p0.y / step).floor() * step;
-    while y <= p1.y {
-        let s = app.to_screen(0.0, y).y;
-        painter.line_segment([pos2(r.min.x + size - 6.0, s), pos2(r.min.x + size, s)], stroke(t.text_tertiary, 1.0));
-        painter.text(pos2(r.min.x + 3.0, s + 2.0), Align2::LEFT_TOP, fmt(y), regular(9.0), t.text_secondary);
-        y += step;
-    }
-    painter.line_segment([pos2(r.min.x, r.min.y + size), pos2(r.max.x, r.min.y + size)], stroke(t.border, 1.0));
-    painter.line_segment([pos2(r.min.x + size, r.min.y), pos2(r.min.x + size, r.max.y)], stroke(t.border, 1.0));
-}
-
-pub fn fmt(v: f64) -> String {
-    let r = (v * 100.0).round() / 100.0;
-    if (r - r.round()).abs() < 1e-9 { format!("{}", r.round() as i64) } else { format!("{r}") }
-}
-
 #[cfg(test)]
 #[path = "builder_poly_tests.rs"]
 mod builder_poly_tests;
@@ -1712,8 +366,3 @@ mod builder_poly_tests;
 #[cfg(test)]
 #[path = "zoom_preview_tests.rs"]
 mod zoom_preview_tests;
-
-/// The overlay green for the page this painter draws on ([`crate::theme::canvas_accent`]).
-fn accent(p: &egui::Painter) -> Color32 {
-    crate::theme::canvas_accent(p.ctx())
-}
diff --git a/crates/ui-egui/src/canvas/builder.rs b/crates/ui-egui/src/canvas/builder.rs
new file mode 100644
index 00000000..bc2360da
--- /dev/null
+++ b/crates/ui-egui/src/canvas/builder.rs
@@ -0,0 +1,121 @@
+use super::outline::stroke;
+use super::overlays::accent;
+use super::*;
+
+/// Width of the lines hatching the hovered and selected regions in vector edit mode (screen px).
+const REGION_HATCH_WIDTH: f32 = 1.4;
+
+/// Vector edit mode: the selected regions and the hovered one hatched in the selection colour,
+/// under the segments and points (the engine lays out and clips the lines).
+pub(super) fn region_hatch(app: &FigApp, painter: &egui::Painter) {
+    let Ok(ds) = app.session.ds() else { return };
+    let (ox, oy) = ds.view.page_to_screen(0.0, 0.0);
+    let (z, min) = (ds.view.zoom, app.canvas.rect.min);
+    let view = figcraft_geom::Affine::new([z, 0.0, 0.0, z, f64::from(min.x) + ox, f64::from(min.y) + oy]);
+    let r = painter.clip_rect();
+    let clip = figcraft_geom::Rect::new(f64::from(r.min.x), f64::from(r.min.y), f64::from(r.max.x), f64::from(r.max.y));
+    for [a, b] in app.session.vector_region_hatch(view, Some(clip)) {
+        painter.line_segment([pos2(a.x as f32, a.y as f32), pos2(b.x as f32, b.y as f32)], stroke(accent(painter), REGION_HATCH_WIDTH));
+    }
+}
+
+/// Shape builder: every region's edges, and the hovered or collected regions hatched (in the
+/// danger colour when releasing removes them).
+pub(super) fn builder_overlay(app: &FigApp, painter: &egui::Painter, t: &Tokens, arr: &figcraft_engine::shapebuilder::Arrangement) {
+    let ov = &app.session.tool.overlay;
+    let screen = |r: &figcraft_engine::shapebuilder::Region| -> Vec<Vec<Pos2>> {
+        r.polys.iter().filter_map(|poly| clean_poly(poly.iter().map(|p| app.to_screen(p.x, p.y)))).collect()
+    };
+    // Edges read on any fill: a light halo under a thin accent line.
+    for r in &arr.regions {
+        for poly in screen(r) {
+            for seg in segments(&poly) {
+                painter.add(Shape::line(seg.to_vec(), stroke(Color32::from_white_alpha(150), 2.5)));
+                painter.add(Shape::line(seg.to_vec(), stroke(accent(painter), 1.0)));
+            }
+        }
+    }
+    let col = if ov.builder_remove { t.danger } else { accent(painter) };
+    for r in ov.builder_regions.iter().filter_map(|i| arr.regions.get(*i)) {
+        hatched(painter, &screen(r), col);
+    }
+}
+
+/// A region contour in screen space, ready to draw: non-finite and repeated points dropped (the
+/// last point back at the first, the points a sliver doubles back on) and sub-pixel slivers left
+/// out, since they're invisible anyway.
+pub(crate) fn clean_poly(points: impl IntoIterator<Item = Pos2>) -> Option<Vec<Pos2>> {
+    let mut out: Vec<Pos2> = Vec::new();
+    for q in points {
+        if !(q.x.is_finite() && q.y.is_finite()) || out.last().is_some_and(|l| l.distance(q) < 0.01) {
+            continue;
+        }
+        out.push(q);
+    }
+    if out.len() > 1 && out.first().is_some_and(|f| f.distance(*out.last().unwrap_or(f)) < 0.01) {
+        out.pop();
+    }
+    let n = out.len();
+    let twice_area: f32 = (0..n).map(|k| out[k].x * out[(k + 1) % n].y - out[(k + 1) % n].x * out[k].y).sum();
+    (n > 2 && twice_area.abs() > 0.4).then_some(out)
+}
+
+/// A closed polygon as its segments. Drawn segment by segment rather than as one closed path: a
+/// joined path asks the tessellator for a mitre at every hairpin a region's sliver doubles back on,
+/// and a zero-length segment there divides by a zero normal, which draws a spike across the canvas.
+fn segments(poly: &[Pos2]) -> impl Iterator<Item = [Pos2; 2]> + '_ {
+    let n = poly.len();
+    (0..n).map(move |k| [poly[k], poly[(k + 1) % n]])
+}
+
+/// Polygons hatched and outlined in `col` (an area about to be filled, merged or removed), each
+/// line on a light halo so it reads on any fill, even one in `col`.
+pub(super) fn hatched(painter: &egui::Painter, polys: &[Vec<Pos2>], col: Color32) {
+    let halo = Color32::from_white_alpha(200);
+    for l in hatch(polys, 6.0) {
+        painter.line_segment(l, stroke(halo, 3.0));
+        painter.line_segment(l, stroke(col, 1.25));
+    }
+    for poly in polys {
+        for seg in segments(poly) {
+            painter.add(Shape::line(seg.to_vec(), stroke(halo, 4.0)));
+            painter.add(Shape::line(seg.to_vec(), stroke(col, 2.0)));
+        }
+    }
+}
+
+/// 45° hatch lines `gap` apart inside polygons (even-odd), in screen space.
+fn hatch(polys: &[Vec<Pos2>], gap: f32) -> Vec<[Pos2; 2]> {
+    // Rotate so the hatch is horizontal, scan, rotate back.
+    let rot = |p: Pos2| pos2((p.x + p.y) * std::f32::consts::FRAC_1_SQRT_2, (p.y - p.x) * std::f32::consts::FRAC_1_SQRT_2);
+    let back = |x: f32, y: f32| pos2((x - y) * std::f32::consts::FRAC_1_SQRT_2, (x + y) * std::f32::consts::FRAC_1_SQRT_2);
+    let edges: Vec<(Pos2, Pos2)> = polys
+        .iter()
+        .flat_map(|poly| {
+            let pts: Vec<Pos2> = poly.iter().map(|p| rot(*p)).collect();
+            let n = pts.len();
+            (0..n).filter_map(move |k| Some((*pts.get(k)?, *pts.get((k + 1) % n)?)))
+        })
+        .collect();
+    let (y0, y1) = edges.iter().fold((f32::INFINITY, f32::NEG_INFINITY), |(lo, hi), (a, b)| (lo.min(a.y).min(b.y), hi.max(a.y).max(b.y)));
+    let mut out = Vec::new();
+    if !(y0.is_finite() && y1.is_finite()) || (y1 - y0) / gap > 4000.0 {
+        return out;
+    }
+    let mut y = (y0 / gap).ceil() * gap;
+    while y < y1 {
+        let mut xs: Vec<f32> = edges
+            .iter()
+            .filter(|(a, b)| (a.y <= y && y < b.y) || (b.y <= y && y < a.y))
+            .map(|(a, b)| a.x + (y - a.y) * (b.x - a.x) / (b.y - a.y))
+            .collect();
+        xs.sort_by(f32::total_cmp);
+        for pair in xs.chunks_exact(2) {
+            if let [a, b] = pair {
+                out.push([back(*a, y), back(*b, y)]);
+            }
+        }
+        y += gap;
+    }
+    out
+}
diff --git a/crates/ui-egui/src/canvas/input.rs b/crates/ui-egui/src/canvas/input.rs
new file mode 100644
index 00000000..fc518d2f
--- /dev/null
+++ b/crates/ui-egui/src/canvas/input.rs
@@ -0,0 +1,260 @@
+use super::*;
+
+/// The zoom tool while Z is held (Alt: zoom out): a click zooms a step about the pointer, a drag
+/// zooms to the dragged area. Takes the pointer from the other tools while it's active.
+fn zoom_tool(app: &mut FigApp, ui: &Ui, resp: &egui::Response, pos: Pos2, mods: egui::Modifiers, typing: bool) -> bool {
+    let held = !typing && !mods.command && ui.input(|i| i.key_down(egui::Key::Z));
+    app.canvas.zoom_tool = held.then_some(mods.alt);
+    let Some(start) = app.canvas.zoom_drag.or_else(|| (held && resp.hovered() && ui.input(|i| i.pointer.primary_pressed())).then_some(pos)) else {
+        return held;
+    };
+    app.canvas.zoom_drag = Some(start);
+    let area = Rect::from_two_pos(start, pos);
+    if ui.input(|i| i.pointer.primary_down()) {
+        return true;
+    }
+    app.canvas.zoom_drag = None;
+    let (a, b) = (app.to_page(area.min), app.to_page(area.max));
+    let params = if area.width() > 4.0 && area.height() > 4.0 {
+        json!({"x": a.x, "y": a.y, "width": b.x - a.x, "height": b.y - a.y})
+    } else {
+        let p = app.to_page(pos);
+        json!({"x": p.x, "y": p.y, "out": mods.alt})
+    };
+    app.run("view.zoomAt", params);
+    true
+}
+
+/// The pointer and keys on the canvas. False when something on it with a cursor of its own has
+/// the pointer (a comment pin, a ruler guide, a gradient or padding handle): the tool's cursor
+/// then doesn't show.
+pub(super) fn input(app: &mut FigApp, ui: &mut Ui, resp: &egui::Response) -> bool {
+    if crate::proto_canvas::input(app, ui, resp) {
+        // A prototype gesture is a press on the canvas too: the Pages list gives up the keyboard.
+        app.ui.pages_focus = None;
+        return true;
+    }
+    let ctx = ui.ctx().clone();
+    // Two fingers pan as well as pinch (a touch screen has no scroll wheel).
+    let (mods, scroll, zoom_delta, hover_pos, space) = ctx.input(|i| {
+        let pan = i.multi_touch().map_or(egui::Vec2::ZERO, |m| m.translation_delta);
+        (i.modifiers, i.smooth_scroll_delta + pan, i.zoom_delta(), i.pointer.hover_pos(), i.key_down(egui::Key::Space))
+    });
+    let editing_text = app.session.ds().map(|d| d.text_edit.is_some()).unwrap_or(false);
+    let typing_elsewhere = crate::a11y::field_focused(&ctx);
+    app.canvas.space_pan = space && !editing_text && !typing_elsewhere;
+    if !app.canvas.dragging && crate::selection_spacing::input(app, &ctx, hover_pos, resp.hovered(), app.canvas.space_pan) {
+        return false;
+    }
+    // Dropped files import onto the canvas, behind a card while they do ([`crate::pending_open`]);
+    // a dropped document opens as a file of its own, as on the home screen. Dev Mode imports
+    // nothing into the design, and says so once for the whole drop.
+    let dropped = ctx.input(|i| i.raw.dropped_files.clone());
+    let mut refused = false;
+    for f in dropped {
+        let path = f.path().to_path_buf();
+        if crate::is_document(&path) {
+            crate::pending_open::open_dropped(app, &f);
+            continue;
+        }
+        if refused || crate::menus::dev_mode_refuses(app, "file.import") {
+            refused = true;
+            continue;
+        }
+        let pt = hover_pos.map(|h| app.to_page(h)).unwrap_or_default();
+        let name = path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "dropped.png".into());
+        let (params, read) = if path.exists() {
+            (json!({"path": path.to_string_lossy(), "x": pt.x, "y": pt.y}), None)
+        } else {
+            (json!({"name": name, "x": pt.x, "y": pt.y}), Some(crate::dropped_bytes(&f, &name)))
+        };
+        let Some(target) =
+            app.session.ds().ok().map(|doc| crate::pending_open::ImportTarget { uid: doc.uid, page: doc.page, name: doc.doc.name.clone() })
+        else {
+            continue;
+        };
+        app.ui.pending_opens.push(crate::pending_open::PendingOpen { label: name, params, command: "file.import", target: Some(target), read });
+    }
+    let Some(pos) = hover_pos.filter(|p| app.canvas.rect.contains(*p)) else {
+        // A drag released off the canvas, or off the window, ends where the pointer was last seen.
+        if app.canvas.dragging && !ctx.input(|i| i.pointer.primary_down()) {
+            app.canvas.dragging = false;
+            if let Some(at) = hover_pos.or_else(|| app.canvas.last_pointer.map(|p| app.to_screen(p.x, p.y))) {
+                send(app, PointerKind::Up, at, &mods);
+            }
+        }
+        // Leaving the canvas: nothing is hovered there any more.
+        if !app.canvas.dragging && std::mem::take(&mut app.canvas.hovering) {
+            app.session.pointer_left();
+        }
+        // A pan whose button was released off the canvas is over.
+        if !ctx.input(|i| i.pointer.button_down(egui::PointerButton::Middle) || i.pointer.primary_down()) {
+            app.canvas.middle_pan = None;
+        }
+        return true;
+    };
+    // A press on the canvas gives the keyboard back to it (arrows nudge again).
+    if resp.hovered() && ctx.input(|i| i.pointer.any_pressed()) {
+        app.ui.layers_focus = false;
+        app.ui.pages_focus = None;
+        app.ui.key_box = None;
+    }
+    // Zoom (pinch, Cmd/Ctrl+scroll) about the pointer; plain scroll pans.
+    if resp.hovered() {
+        if (zoom_delta - 1.0).abs() > 1e-4 {
+            let anchor = app.to_page(pos);
+            if let Ok(ds) = app.session.ds_mut() {
+                let z = ds.view.zoom * f64::from(zoom_delta);
+                ds.view.set_zoom_at(z, (anchor.x, anchor.y));
+                ds.revision += 1;
+            }
+        } else if scroll != egui::Vec2::ZERO
+            && let Ok(ds) = app.session.ds_mut()
+        {
+            ds.view.scroll(f64::from(scroll.x), f64::from(scroll.y), mods.shift);
+            ds.revision += 1;
+        }
+    }
+    if zoom_tool(app, ui, resp, pos, mods, editing_text || typing_elsewhere) {
+        return true;
+    }
+    // Middle-button / space panning.
+    let middle_down = ctx.input(|i| i.pointer.button_down(egui::PointerButton::Middle));
+    if (middle_down || (app.canvas.space_pan && ctx.input(|i| i.pointer.primary_down()))) && resp.hovered() || app.canvas.middle_pan.is_some() {
+        if let Ok(ds) = app.session.ds_mut() {
+            match app.canvas.middle_pan {
+                None => app.canvas.middle_pan = Some((pos, ds.view.cx, ds.view.cy)),
+                Some((p0, cx, cy)) => {
+                    let z = ds.view.zoom.max(1e-6);
+                    ds.view.cx = cx - f64::from(pos.x - p0.x) / z;
+                    ds.view.cy = cy - f64::from(pos.y - p0.y) / z;
+                    ds.revision += 1;
+                }
+            }
+        }
+        if !middle_down && !ctx.input(|i| i.pointer.primary_down()) {
+            app.canvas.middle_pan = None;
+        }
+        return true;
+    }
+    if !app.canvas.dragging && (resp.hovered() || app.ui.comments.dragging()) && crate::comments::input(app, &ctx, pos) {
+        return false;
+    }
+    if !app.canvas.dragging && resp.hovered() && crate::guides::input(app, &ctx, pos) {
+        return false;
+    }
+    if !app.canvas.dragging && resp.hovered() && crate::handles::input(app, &ctx, pos) {
+        return false;
+    }
+    if resp.secondary_clicked() {
+        open_context_menu(app, pos, mods.command);
+        return true;
+    }
+    // A third quick click is counted as a triple, not a double (a click elsewhere in between still
+    // leaves its time in the sequence): it means the same here — edit, enter, open — unless a
+    // vector or text is being edited, where a triple already has its own meaning. A triple on
+    // empty canvas still means a double in vector edit mode: the double-click that entered edit
+    // mode counts on, so leaving it right away would otherwise take a fourth click or a pause.
+    let ds = app.session.ds().ok();
+    let editing = ds.is_some_and(|d| d.vector_edit.is_some() || d.text_edit.is_some());
+    // Only a triple click asks (it walks the parts' render bounds).
+    let empty_canvas = || {
+        ds.is_some_and(|d| {
+            let Some(ve) = d.vector_edit.as_ref().filter(|v| v.anchor.is_none() && d.text_edit.is_none()) else {
+                return false;
+            };
+            let p = app.to_page(pos);
+            let tol = 6.0 / d.view.zoom.max(1e-6);
+            ve.parts().iter().all(|part| d.doc.world_render_bounds(part.id).is_none_or(|b| !b.inflate(tol * 4.0, tol * 4.0).contains(p)))
+        })
+    };
+    if resp.double_clicked() || (resp.triple_clicked() && (!editing || empty_canvas())) {
+        let ev = pointer_event(app, PointerKind::DoubleClick, pos, &mods);
+        if let Err(e) = app.session.pointer(&ev) {
+            app.toast(e.to_string());
+        }
+        app.canvas.dragging = false;
+        return true;
+    }
+    let primary_pressed = ctx.input(|i| i.pointer.button_pressed(egui::PointerButton::Primary));
+    let primary_down = ctx.input(|i| i.pointer.primary_down());
+    let primary_released = ctx.input(|i| i.pointer.button_released(egui::PointerButton::Primary));
+    let kind = if primary_pressed && resp.hovered() {
+        app.canvas.dragging = true;
+        app.ui.context_menu = None;
+        app.ui.tool_flyout = None;
+        // Clicking the canvas takes focus from panel fields.
+        ctx.memory_mut(|m| {
+            if let Some(f) = m.focused() {
+                m.surrender_focus(f);
+            }
+        });
+        Some(PointerKind::Down)
+    } else if app.canvas.dragging && primary_released {
+        app.canvas.dragging = false;
+        Some(PointerKind::Up)
+    } else if app.canvas.dragging && primary_down {
+        Some(PointerKind::Move)
+    } else if resp.hovered() {
+        app.canvas.hovering = true;
+        Some(PointerKind::Hover)
+    } else {
+        // Something over the canvas took the pointer.
+        if std::mem::take(&mut app.canvas.hovering) {
+            app.session.pointer_left();
+        }
+        None
+    };
+    // Pen pressure comes with touch events (a pen on Windows, a stylus in a browser); a mouse,
+    // macOS and Linux tablets report none and draw at the stroke weight.
+    let force = ctx.input(|i| {
+        i.events.iter().rev().find_map(|e| match e {
+            egui::Event::Touch { force: Some(f), .. } if f.is_finite() && *f > 0.0 => Some(f.clamp(0.0, 1.0)),
+            _ => None,
+        })
+    });
+    if force.is_some() {
+        app.canvas.pressure = force;
+    }
+    if let Some(k) = kind {
+        send(app, k, pos, &mods);
+        // The pointer also let go within this frame (a quick click, or a slow frame): the tools get
+        // the release too, so the press's gesture ends — a quick click with a shape tool still
+        // draws and returns to Move, and a double-click right after drawing finds the Move tool.
+        if matches!(k, PointerKind::Down) && primary_released {
+            app.canvas.dragging = false;
+            send(app, PointerKind::Up, pos, &mods);
+        }
+    }
+    true
+}
+
+/// Pointer event `kind` at screen point `pos`, to the tools.
+fn send(app: &mut FigApp, kind: PointerKind, pos: Pos2, m: &egui::Modifiers) {
+    let ev = pointer_event(app, kind, pos, m);
+    if kind == PointerKind::Up {
+        app.canvas.pressure = None;
+    }
+    app.canvas.last_pointer = Some(Point::new(ev.x, ev.y));
+    if let Err(e) = app.session.pointer(&ev) {
+        app.toast(e.to_string());
+    }
+    app.handle_ui_requests();
+}
+
+/// Right-click at screen `pos`: select what's under the pointer (`deep`: the nested layer), then
+/// open the context menu there.
+pub fn open_context_menu(app: &mut FigApp, pos: Pos2, deep: bool) {
+    let p = app.to_page(pos);
+    if let Ok(ds) = app.session.ds() {
+        let (doc, page, sel, zoom) = (ds.doc.clone(), ds.page, ds.selection.clone(), ds.view.zoom.max(1e-6));
+        if let Some(leaf) = app.session.hit(&doc, page, p, 2.0 / zoom) {
+            let target = figcraft_doc::geometry::select_target(&doc, leaf, &sel, deep);
+            if !sel.contains(&target) {
+                app.session.set_selection(vec![target]);
+            }
+        }
+    }
+    app.ui.context_menu = Some((pos, app.session.selection()));
+    app.ui.context_menu_shown = false;
+}
diff --git a/crates/ui-egui/src/canvas/outline.rs b/crates/ui-egui/src/canvas/outline.rs
new file mode 100644
index 00000000..58f5fd20
--- /dev/null
+++ b/crates/ui-egui/src/canvas/outline.rs
@@ -0,0 +1,196 @@
+use super::*;
+
+pub(super) fn stroke(c: Color32, w: f32) -> Stroke {
+    Stroke::new(w, c)
+}
+
+/// A text layer's layout placed on the canvas: where carets and selected characters show (yours
+/// and other people's in a live session).
+pub(crate) struct TextOnScreen {
+    pub layout: Arc<figcraft_text::TextLayout>,
+    /// How many characters the text has.
+    pub chars: usize,
+    /// The layout's vertical offset in the box (vertical alignment).
+    dy: f64,
+    world: figcraft_geom::Affine,
+}
+
+impl TextOnScreen {
+    /// Text layer `id` of `doc` (`None`: not a text layer).
+    pub(crate) fn of(doc: &Document, id: NodeId) -> Option<Self> {
+        let n = doc.node(id)?;
+        let NodeKind::Text(t) = &n.kind else { return None };
+        let (layout, dy) = figcraft_text::layout_node(n)?;
+        Some(Self { layout, chars: t.char_count(), dy, world: doc.world_transform(id) })
+    }
+
+    /// Layout point `(x, y)` on screen (on the path, for text on a path).
+    pub(crate) fn at(&self, app: &FigApp, x: f64, y: f64) -> Pos2 {
+        let q = self.layout.warp_point(x, y);
+        let p = self.world * Point::new(q.x, q.y + self.dy);
+        app.to_screen(p.x, p.y)
+    }
+
+    /// The highlight of characters `a..b`, one screen quad per line.
+    pub(crate) fn selection(&self, app: &FigApp, a: usize, b: usize) -> Vec<[Pos2; 4]> {
+        let rects = self.layout.selection_rects(a, b);
+        rects.iter().map(|r| [self.at(app, r.x0, r.y0), self.at(app, r.x1, r.y0), self.at(app, r.x1, r.y1), self.at(app, r.x0, r.y1)]).collect()
+    }
+
+    /// The caret before character `index`: its top and bottom on screen (an empty layer: a line
+    /// of default height at its origin).
+    pub(crate) fn caret(&self, app: &FigApp, index: usize, zoom: f64) -> [Pos2; 2] {
+        let (cx, li) = self.layout.caret(index);
+        match self.layout.lines.get(li).or(self.layout.lines.last()) {
+            Some(line) => [self.at(app, cx, line.top), self.at(app, cx, line.top + line.height)],
+            None => {
+                let p = self.at(app, 0.0, 0.0);
+                [p, p + vec2(0.0, 14.0 * zoom as f32)]
+            }
+        }
+    }
+}
+
+/// A node's oriented outline in screen space.
+pub(crate) fn node_quad(app: &FigApp, doc: &Document, id: NodeId) -> Option<[Pos2; 4]> {
+    let n = doc.node(id)?;
+    let w = doc.world_transform(id);
+    let corners = [Point::new(0.0, 0.0), Point::new(n.width, 0.0), Point::new(n.width, n.height), Point::new(0.0, n.height)];
+    Some(corners.map(|c| {
+        let p = w * c;
+        app.to_screen(p.x, p.y)
+    }))
+}
+
+pub(super) fn quad(painter: &egui::Painter, q: [Pos2; 4], s: Stroke) {
+    painter.add(Shape::closed_line(q.to_vec(), s));
+}
+
+/// The slots of the selected components and instances (and a slot being dropped onto): a dashed
+/// outline and the slot's name above its top-left corner, like a frame label (never over the
+/// content).
+pub(super) fn slot_badges(app: &FigApp, painter: &egui::Painter, doc: &Document, sel: &[NodeId], drop: Option<NodeId>) {
+    use figcraft_engine::components::{owning_component, owning_instance, slot_name, slots_of};
+    let mut roots: Vec<NodeId> = Vec::new();
+    for id in sel {
+        let root = match doc.node(*id).map(|n| &n.kind) {
+            Some(NodeKind::Instance { .. } | NodeKind::Component { .. } | NodeKind::ComponentSet { .. }) => Some(*id),
+            _ => owning_instance(doc, *id).or_else(|| owning_component(doc, *id)),
+        };
+        if let Some(r) = root.filter(|r| !roots.contains(r)) {
+            roots.push(r);
+        }
+    }
+    let mut slots: Vec<(NodeId, String)> = roots.iter().flat_map(|r| slots_of(doc, *r)).collect();
+    if let Some(d) = drop
+        && !slots.iter().any(|(s, _)| *s == d)
+        && let Some(name) = slot_name(doc, d)
+    {
+        slots.push((d, name));
+    }
+    for (id, name) in slots {
+        let Some(q) = node_quad(app, doc, id) else { continue };
+        if !Rect::from_points(&q).intersects(app.canvas.rect) {
+            continue;
+        }
+        painter.extend(Shape::dashed_line(&[q[0], q[1], q[2], q[3], q[0]], stroke(COMPONENT, 1.0), 4.0, 3.0));
+        // The label, when the slot is wide enough on screen to hold it.
+        let galley = painter.layout_no_wrap(name, regular(10.0), COMPONENT);
+        let (w, h) = (galley.size().x + 14.0, galley.size().y.max(11.0));
+        if (q[1] - q[0]).length() < w {
+            continue;
+        }
+        let at = q[0] - vec2(0.0, h + 2.0);
+        crate::icons::paint(painter, Rect::from_min_size(pos2(at.x, at.y + (h - 11.0) / 2.0), vec2(11.0, 11.0)), crate::icons::Icon::Slot, COMPONENT);
+        painter.galley(pos2(at.x + 14.0, at.y + (h - galley.size().y) / 2.0), galley, COMPONENT);
+    }
+}
+
+/// The instance an Alt-drop of a component from the Assets panel swaps: tinted and outlined in
+/// the component colour, with a "Swap instance" label above its top-left corner.
+pub(super) fn swap_highlight(app: &FigApp, painter: &egui::Painter, doc: &Document, id: NodeId) {
+    let Some(q) = node_quad(app, doc, id) else { return };
+    // White on the component colour, in both themes (like the canvas's selection labels).
+    let ink = Color32::WHITE;
+    painter.add(Shape::convex_polygon(q.to_vec(), COMPONENT.gamma_multiply(0.12), Stroke::NONE));
+    quad(painter, q, stroke(COMPONENT, 2.0));
+    let galley = painter.layout_no_wrap(tr("Swap instance").to_string(), semibold(10.0), ink);
+    let size = vec2(galley.size().x + 26.0, 18.0);
+    let top = Rect::from_points(&q).min;
+    let pill = Rect::from_min_size(pos2(top.x, top.y - size.y - 4.0), size);
+    painter.rect_filled(pill, CornerRadius::same(4), COMPONENT);
+    crate::icons::paint(
+        painter,
+        Rect::from_center_size(pos2(pill.min.x + 11.0, pill.center().y), vec2(10.0, 10.0)),
+        crate::icons::Icon::Instance,
+        ink,
+    );
+    painter.galley(pos2(pill.min.x + 20.0, pill.center().y - galley.size().y / 2.0), galley, ink);
+}
+
+/// The outline colour for a layer: purple for components, sets and instances and every layer in
+/// them, the page's overlay `green` otherwise.
+pub(super) fn outline_colour(doc: &Document, id: NodeId, green: Color32) -> Color32 {
+    use figcraft_engine::components::{owning_component, owning_instance};
+    let set = matches!(doc.node(id).map(|n| &n.kind), Some(NodeKind::ComponentSet { .. }));
+    if set || owning_component(doc, id).is_some() || owning_instance(doc, id).is_some() { COMPONENT } else { green }
+}
+
+/// The outline path of shapes (ellipses, vectors) for hover/selection outlines.
+fn outline_shape(app: &FigApp, doc: &Document, id: NodeId) -> Option<Vec<Vec<Pos2>>> {
+    let n = doc.node(id)?;
+    if !matches!(
+        n.kind,
+        NodeKind::Ellipse { .. } | NodeKind::Vector { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. } | NodeKind::BooleanOp { .. }
+    ) {
+        return None;
+    }
+    let (path, _) = figcraft_render::node_outline(doc, n)?;
+    let w = doc.world_transform(id);
+    let mut out = Vec::new();
+    let mut cur: Vec<Pos2> = Vec::new();
+    figcraft_geom::kurbo::flatten(path.iter(), 0.5 / app.session.ds().map(|d| d.view.zoom).unwrap_or(1.0), |el| {
+        use figcraft_geom::kurbo::PathEl::*;
+        match el {
+            MoveTo(p) => {
+                if cur.len() > 1 {
+                    out.push(std::mem::take(&mut cur));
+                }
+                cur.clear();
+                let q = w * p;
+                cur.push(app.to_screen(q.x, q.y));
+            }
+            LineTo(p) => {
+                let q = w * p;
+                cur.push(app.to_screen(q.x, q.y));
+            }
+            ClosePath => {
+                if let Some(f) = cur.first().copied() {
+                    cur.push(f);
+                }
+            }
+            _ => {}
+        }
+    });
+    if cur.len() > 1 {
+        out.push(cur);
+    }
+    Some(out)
+}
+
+/// A layer's outline on the canvas: its shape for ellipses, vectors, polygons, stars and boolean
+/// groups, its box otherwise.
+pub(super) fn draw_outline(app: &FigApp, painter: &egui::Painter, doc: &Document, id: NodeId, s: Stroke) {
+    match outline_shape(app, doc, id) {
+        Some(lines) => {
+            for l in lines {
+                painter.add(Shape::line(l, s));
+            }
+        }
+        None => {
+            if let Some(q) = node_quad(app, doc, id) {
+                quad(painter, q, s);
+            }
+        }
+    }
+}
diff --git a/crates/ui-egui/src/canvas/overlays.rs b/crates/ui-egui/src/canvas/overlays.rs
new file mode 100644
index 00000000..675427c1
--- /dev/null
+++ b/crates/ui-egui/src/canvas/overlays.rs
@@ -0,0 +1,545 @@
+use super::builder::{builder_overlay, hatched, region_hatch};
+use super::outline::{TextOnScreen, draw_outline, node_quad, outline_colour, quad, slot_badges, stroke, swap_highlight};
+use super::rulers::{boards, fmt, rulers};
+use super::*;
+
+/// Everything drawn over the rendered page; returns the frame labels drawn (frame, corners on the
+/// page) for the engine to hit-test.
+pub(super) fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) -> Vec<(NodeId, [Point; 4])> {
+    let mut labels = Vec::new();
+    let Ok(ds) = app.session.ds() else { return labels };
+    let doc = ds.doc.clone();
+    let page = ds.page;
+    let sel = ds.selection.clone();
+    let zoom = ds.view.zoom;
+    let view = ds.view.clone();
+    // Pixel grid at high zoom.
+    if view.pixel_grid_shown() {
+        let r = app.canvas.rect;
+        let p0 = app.to_page(r.min);
+        let p1 = app.to_page(r.max);
+        let col = Color32::from_black_alpha(18);
+        let mut x = p0.x.floor();
+        while x <= p1.x {
+            let s = app.to_screen(x, 0.0).x;
+            painter.line_segment([pos2(s, r.min.y), pos2(s, r.max.y)], stroke(col, 1.0));
+            x += 1.0;
+        }
+        let mut y = p0.y.floor();
+        while y <= p1.y {
+            let s = app.to_screen(0.0, y).y;
+            painter.line_segment([pos2(r.min.x, s), pos2(r.max.x, s)], stroke(col, 1.0));
+            y += 1.0;
+        }
+    }
+    // Layout grids and frame labels for top-level frames (also those in sections); the focus view
+    // labels only its frame.
+    let focus = ds.focused();
+    for c in boards(&doc, page).iter().filter(|c| focus.is_none_or(|f| f == **c)) {
+        let Some(n) = doc.node(*c) else { continue };
+        let Some(b) = doc.world_bounds(*c) else { continue };
+        // Off-screen frames draw neither grids nor a label (labels sit just outside the frame).
+        let on_screen = Rect::from_two_pos(app.to_screen(b.x0, b.y0), app.to_screen(b.x1, b.y1)).expand(20.0);
+        if !on_screen.intersects(app.canvas.rect) {
+            continue;
+        }
+        if view.layout_grids && !n.grids.is_empty() && figcraft_layout::grids_shown(&doc, *c) {
+            let w = doc.world_transform(*c);
+            for g in n.grids.iter().filter(|g| g.visible) {
+                let col = doc_c32(painter.ctx(), g.color);
+                for r in figcraft_layout::grid_lines(g, n.width, n.height) {
+                    let a = w * Point::new(r.x0, r.y0);
+                    let b = w * Point::new(r.x1, r.y1);
+                    let (sa, sb) = (app.to_screen(a.x, a.y), app.to_screen(b.x, b.y));
+                    if g.kind == figcraft_doc::GridKind::Grid {
+                        painter.line_segment([sa, sb], stroke(col, 1.0));
+                    } else {
+                        painter.rect_filled(Rect::from_two_pos(sa, sb), CornerRadius::ZERO, col);
+                    }
+                }
+            }
+        }
+        // The focus view's bar names its frame.
+        // Board objects (stickies, shapes with text, stamps) are frames without a name label.
+        let labelled = focus.is_none() && (n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. })) && !n.is_board_atom();
+        if labelled && let Some(q) = crate::frame_labels::draw(app, painter, t, &doc, *c, sel.contains(c), ds.hover == Some(*c)) {
+            labels.push((*c, q.map(|p| app.to_page(p))));
+        }
+    }
+    // Prototype connections.
+    crate::proto_canvas::draw(app, painter);
+    // Hover outline (measuring outlines the measured box in red instead).
+    if let Some(h) = ds.hover
+        && !sel.contains(&h)
+        && matches!(app.session.tool.tool, ToolId::Move | ToolId::Scale)
+        && app.session.prefs.highlight_on_hover
+        && app.session.tool.overlay.measure_box.is_none()
+    {
+        draw_outline(app, painter, &doc, h, stroke(outline_colour(&doc, h, accent(painter)), 1.5));
+    }
+    // Inside a boolean group (an operand selected or in vector edit mode): every operand's outline,
+    // so the shapes making the live result stay visible while one of them changes.
+    let operands = figcraft_engine::booleans::outlined_operands(&doc, &sel, ds.vector_edit.as_ref().map(|ve| ve.id));
+    for id in operands.iter().filter(|o| !sel.contains(o)) {
+        draw_outline(app, painter, &doc, *id, stroke(outline_colour(&doc, *id, accent(painter)).gamma_multiply(0.6), 1.0));
+    }
+    // Mask outlines (a mask doesn't draw itself), frame outlines and slices, as the View menu shows.
+    if view.mask_outlines || view.frame_outlines || view.show_slices {
+        for id in doc.subtree(page) {
+            let Some(n) = doc.node(id).filter(|n| n.visible) else { continue };
+            if view.mask_outlines && n.is_mask {
+                draw_outline(app, painter, &doc, id, stroke(accent(painter), 1.0));
+            } else if view.frame_outlines && n.kind.is_frame_like() {
+                draw_outline(app, painter, &doc, id, stroke(t.text_secondary, 1.0));
+            } else if view.show_slices
+                && matches!(n.kind, NodeKind::Slice)
+                && let Some(q) = node_quad(app, &doc, id)
+            {
+                painter.extend(Shape::dashed_line(&[q[0], q[1], q[2], q[3], q[0]], stroke(t.text_secondary, 1.0), 4.0, 3.0));
+            }
+        }
+    }
+    // Drop target / insertion indicator.
+    let ov = &app.session.tool.overlay;
+    if let Some(d) = ov.drop_target
+        && let Some(q) = node_quad(app, &doc, d)
+    {
+        quad(painter, q, stroke(if figcraft_engine::components::is_slot(&doc, d) { COMPONENT } else { accent(painter) }, 1.0));
+    }
+    slot_badges(app, painter, &doc, &sel, ov.drop_target);
+    if let Some(t) = ov.swap_target {
+        swap_highlight(app, painter, &doc, t);
+    }
+    if let Some([x0, y0, x1, y1]) = ov.insert_line {
+        painter.line_segment([app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(accent(painter), 2.0));
+    }
+    if let Some([x0, y0, x1, y1]) = ov.drop_cell {
+        let r = Rect::from_two_pos(app.to_screen(x0, y0), app.to_screen(x1, y1));
+        painter.rect_filled(r, CornerRadius::same(2), accent(painter).gamma_multiply(0.12));
+        let pts = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.left_top()];
+        painter.add(Shape::dashed_line(&pts, stroke(accent(painter), 1.5), 4.0, 3.0));
+    }
+    // Vector edit mode, with the transform box around several selected points.
+    // The selection's size label, which measurement labels keep clear of.
+    let mut size_label = None;
+    if let Some(ve) = ds.vector_edit.clone()
+        && let Some(o) = figcraft_engine::vectoredit::overlay(&doc, &ve)
+    {
+        // The Variable width tool shows width points in place of the path's points.
+        let width_tool = ve.tool == figcraft_engine::vectoredit::VTool::Width;
+        // Other layers edited at once go under the active one; the hover shows on its own layer.
+        let ov = &app.session.tool.overlay;
+        let hover_on = |id| ov.vector_hover.filter(|_| ov.vector_hover_on.unwrap_or(ve.id) == id);
+        for part in &ve.others {
+            if let Some(po) = figcraft_engine::vectoredit::overlay(&doc, &ve.view(part)) {
+                vector_overlay(app, painter, &po, !width_tool, hover_on(part.id), false, None);
+            }
+        }
+        vector_overlay(app, painter, &o, !width_tool, hover_on(ve.id), true, ov.vector_add);
+        if width_tool {
+            width_overlay(app, painter, &doc, &ve, zoom);
+        } else if let Some(c) = app.session.vector_edit_box() {
+            // The box around several selected points draws no corner handles: they would read as
+            // points. Its corners and edges still scale the points when dragged.
+            let label = format!("{} × {}", fmt((c[1] - c[0]).hypot()), fmt((c[3] - c[0]).hypot()));
+            size_label = transform_box(app, painter, c.map(|p| app.to_screen(p.x, p.y)), accent(painter), true, 0, Some(label));
+        }
+    }
+    // Selection.
+    let editing = ds.text_edit.clone();
+    if !sel.is_empty() && editing.is_none() && ds.vector_edit.is_none() {
+        let col = if sel.iter().any(|i| outline_colour(&doc, *i, accent(painter)) == COMPONENT) { COMPONENT } else { accent(painter) };
+        for id in &sel {
+            draw_outline(app, painter, &doc, *id, stroke(col, 1.0));
+        }
+        // The shape builder reshapes by regions: no transform box.
+        if app.session.tool.tool != ToolId::ShapeBuilder
+            && let Some(b) = selection_box(&doc, &sel)
+            && let Some((_, w, h)) = selection_frame(&doc, &sel)
+        {
+            let is_line = sel.len() == 1 && matches!(sel.first().and_then(|i| doc.node(*i)).map(|n| &n.kind), Some(NodeKind::Line));
+            // A selected connector's handles are its two ends (drag one onto another object).
+            let connector = figcraft_engine::board::selected_connector_ends(&doc, &sel).map(|(_, ends)| ends);
+            let mut label = if is_line { fmt(w) } else { format!("{} × {}", fmt(w), fmt(h)) };
+            let scale = app.session.tool.overlay.scale;
+            if let Some(hint) = scale {
+                label = format!("{label} · {}x", fmt(hint.factor.abs()));
+            }
+            // A layer smaller than its handles on screen shows just its outline (they still answer
+            // just outside it).
+            let tiny = figcraft_engine::tools::box_sides_px(&b, zoom).1 < figcraft_engine::tools::SMALL_BOX_PX;
+            // Measuring to another layer (Alt held) shows just the outlines: no handles or size.
+            let measuring = app.session.tool.overlay.measure_box.is_some();
+            // Locked layers (selected in the layers panel) can't be resized, nor anything in Dev
+            // Mode: no handles either.
+            let handles =
+                if measuring || app.session.tool.dev_mode || connector.is_some() || sel.iter().any(|i| figcraft_engine::tools::locked_in(&doc, *i)) {
+                    0
+                } else if is_line {
+                    2
+                } else if tiny {
+                    0
+                } else {
+                    4
+                };
+            size_label = transform_box(
+                app,
+                painter,
+                b.map(|p| app.to_screen(p.x, p.y)),
+                col,
+                sel.len() > 1,
+                handles,
+                (!measuring && connector.is_none()).then_some(label),
+            );
+            for end in connector.into_iter().flatten().filter(|_| !app.session.tool.dev_mode) {
+                let c = app.to_screen(end.x, end.y);
+                painter.circle_filled(c, 5.0, Color32::WHITE);
+                painter.circle_stroke(c, 5.0, stroke(col, 1.5));
+            }
+            if !measuring {
+                arc_overlay(app, painter, col);
+                shape_overlay(app, painter, col);
+            }
+            if app.session.tool.tool == ToolId::Scale {
+                // The point that stays put: the dragged pivot, else the anchor.
+                let pivot = scale
+                    .map(|h| Point::new(h.pivot[0], h.pivot[1]))
+                    .or_else(|| figcraft_engine::tools::scale_anchor_point(&doc, &sel, app.session.tool.scale_anchor));
+                if let Some(p) = pivot {
+                    let c = app.to_screen(p.x, p.y);
+                    painter.circle_filled(c, 4.0, Color32::WHITE);
+                    painter.circle_stroke(c, 4.0, stroke(col, 1.5));
+                    painter.circle_filled(c, 1.5, col);
+                }
+            }
+            // The rotation origin while it shows (Alt+R): a ring with a cross through it.
+            if let Some(o) = ds.origin_handle() {
+                let c = app.to_screen(o.x, o.y);
+                painter.circle_filled(c, 5.0, Color32::WHITE);
+                painter.circle_stroke(c, 5.0, stroke(col, 1.5));
+                for d in [vec2(1.0, 0.0), vec2(0.0, 1.0)] {
+                    painter.line_segment([c - d * 10.0, c - d * 5.0], stroke(col, 1.5));
+                    painter.line_segment([c + d * 5.0, c + d * 10.0], stroke(col, 1.5));
+                }
+                painter.circle_filled(c, 1.5, col);
+            }
+        }
+    }
+    if app.session.tool.tool == ToolId::ShapeBuilder
+        && let Some(arr) = figcraft_engine::shapebuilder::current(&app.session)
+    {
+        builder_overlay(app, painter, t, &arr);
+    }
+    // Text editing: caret and selection, or the IME composition underlined at the caret.
+    let preedit = app.preedit_view();
+    let edoc: &Document = preedit.map(|p| &*p.doc).unwrap_or(&doc);
+    if let Some(te) = editing
+        && let Some(text) = TextOnScreen::of(edoc, te.id)
+    {
+        let layout = &text.layout;
+        if let Some(q) = node_quad(app, edoc, te.id) {
+            quad(painter, q, stroke(accent(painter), 1.0));
+        }
+        let (a, b) = (te.caret.min(te.anchor), te.caret.max(te.anchor));
+        if a != b && preedit.is_none() {
+            for q in text.selection(app, a, b) {
+                painter.add(Shape::convex_polygon(q.to_vec(), accent(painter).gamma_multiply(0.3), Stroke::NONE));
+            }
+        }
+        if let Some(p) = preedit {
+            for r in layout.selection_rects(p.range.0, p.range.1) {
+                // Underline just below the baseline, across the composed chars only.
+                let Some(line) = layout.lines.iter().find(|l| (l.top - r.y0).abs() < 1e-6) else { continue };
+                let x1 = layout
+                    .glyphs
+                    .get(line.glyph_start..line.glyph_end)
+                    .unwrap_or(&[])
+                    .iter()
+                    .filter(|g| g.char_end > g.char_start && g.char_start >= p.range.0 && g.char_end <= p.range.1)
+                    .map(|g| g.x + g.advance)
+                    .fold(r.x0, f64::max);
+                let y = line.baseline + (line.top + line.height - line.baseline) * 0.35;
+                painter.line_segment([text.at(app, r.x0, y), text.at(app, x1, y)], stroke(t.text, 1.0));
+            }
+        }
+        let caret = preedit.map(|p| p.cursor).unwrap_or(te.caret);
+        let blink = (painter.ctx().input(|i| i.time) * 2.0) as i64 % 2 == 0;
+        if blink || a != b {
+            painter.line_segment(text.caret(app, caret, zoom), stroke(t.text, 1.0));
+        }
+        painter.ctx().request_repaint_after(std::time::Duration::from_millis(500));
+    }
+    // Smart guides and measurements (their labels kept clear of the size label).
+    crate::measure_overlay::draw(app, painter, t, size_label);
+    // Marquee.
+    if let Some([x0, y0, x1, y1]) = ov.marquee.or(app.ui.key_box) {
+        let r = Rect::from_two_pos(app.to_screen(x0, y0), app.to_screen(x1, y1));
+        painter.rect_filled(r, CornerRadius::ZERO, accent(painter).gamma_multiply(0.1));
+        painter.rect_stroke(r, CornerRadius::ZERO, stroke(accent(painter), 1.0), StrokeKind::Inside);
+    }
+    // Pen path.
+    if !ov.pen.is_empty() {
+        let pts: Vec<Pos2> = ov.pen.iter().map(|[x, y]| app.to_screen(*x, *y)).collect();
+        if app.session.tool.tool == ToolId::Pencil {
+            // The stroke it will make, in its colour and weight (at least a point when zoomed out).
+            let (color, weight) = figcraft_engine::tools::PENCIL_STROKE;
+            painter.add(Shape::line(pts, stroke(doc_c32(painter.ctx(), color), ((weight * zoom) as f32).max(1.0))));
+        } else {
+            for [x0, y0, x1, y1] in &ov.pen_handles {
+                bezier_handle(painter, app.to_screen(*x0, *y0), app.to_screen(*x1, *y1), 3.5, Color32::WHITE);
+            }
+            for p in &pts {
+                painter.circle_filled(*p, 3.5, Color32::WHITE);
+                painter.circle_stroke(*p, 3.5, stroke(accent(painter), 1.0));
+            }
+            if let Some([x0, y0, x1, y1]) = ov.rubber {
+                let (a, b) = (app.to_screen(x0, y0), app.to_screen(x1, y1));
+                // The segment a click would make: along the last anchor's out handle, if it has one.
+                match ov.rubber_handle {
+                    Some([hx, hy]) => {
+                        let h = app.to_screen(hx, hy);
+                        painter.add(egui::epaint::CubicBezierShape::from_points_stroke(
+                            [a, h, b, b],
+                            false,
+                            Color32::TRANSPARENT,
+                            stroke(accent(painter), 1.0),
+                        ));
+                    }
+                    None => {
+                        painter.line_segment([a, b], stroke(accent(painter), 1.0));
+                    }
+                }
+            }
+        }
+    } else if let Some([x0, y0, x1, y1]) = ov.rubber {
+        // A connector being drawn, or one of its ends dragged: from where it starts to the pointer.
+        painter.line_segment([app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(accent(painter), 1.5));
+    }
+    // Eraser brush (vector edit mode).
+    if let Some([x, y, r]) = ov.brush {
+        let c = app.to_screen(x, y);
+        let rs = (r * app.session.ds().map(|d| d.view.zoom).unwrap_or(1.0)) as f32;
+        painter.circle_stroke(c, rs, stroke(Color32::WHITE, 3.0));
+        painter.circle_stroke(c, rs, stroke(accent(painter), 1.5));
+    }
+    // Lasso (vector edit mode).
+    if ov.lasso.len() > 1 {
+        let mut pts: Vec<Pos2> = ov.lasso.iter().map(|[x, y]| app.to_screen(*x, *y)).collect();
+        if let Some(first) = pts.first().copied() {
+            pts.push(first);
+        }
+        painter.add(Shape::dashed_line(&pts, stroke(accent(painter), 1.0), 4.0, 3.0));
+    }
+    // Guides (under the rulers).
+    crate::guides::draw(app, painter);
+    // Rulers.
+    if view.rulers {
+        rulers(app, painter, t, &doc, &sel);
+    }
+    labels
+}
+
+/// A transform box (screen corners tl, tr, br, bl): its outline when `outline`, the first `handles`
+/// corner handles and, when dimensions are shown, the size `label` (if any) under it (its box returned).
+fn transform_box(
+    app: &FigApp,
+    painter: &egui::Painter,
+    q: [Pos2; 4],
+    col: Color32,
+    outline: bool,
+    handles: usize,
+    label: Option<String>,
+) -> Option<Rect> {
+    if outline {
+        quad(painter, q, stroke(col, 1.0));
+    }
+    for c in q.iter().take(handles) {
+        let r = Rect::from_center_size(*c, vec2(8.0, 8.0));
+        painter.rect_filled(r, CornerRadius::same(1), Color32::WHITE);
+        painter.rect_stroke(r, CornerRadius::same(1), stroke(col, 1.0), StrokeKind::Inside);
+    }
+    if let Some(label) = label.filter(|_| app.session.prefs.show_dimensions) {
+        let bottom = q.iter().map(|p| p.y).fold(f32::MIN, f32::max);
+        let cx = q.iter().map(|p| p.x).sum::<f32>() / 4.0;
+        return Some(pill(painter, pos2(cx, bottom + 9.0), Align2::CENTER_TOP, label, col));
+    }
+    None
+}
+
+/// A canvas readout: white `text` on a `col` pill placed at `at` by `align` (its box returned).
+fn pill(painter: &egui::Painter, at: Pos2, align: Align2, text: String, col: Color32) -> Rect {
+    let galley = painter.layout_no_wrap(text, semibold(11.0), Color32::WHITE);
+    let r = align.anchor_size(at, galley.size() + vec2(8.0, 4.0));
+    painter.rect_filled(r, CornerRadius::same(3), crate::theme::under_white(col));
+    painter.galley(r.min + vec2(4.0, 2.0), galley, Color32::WHITE);
+    r
+}
+
+/// The selected ellipse's arc handles (the hovered or dragged one larger, Start with a dot inside)
+/// and, while one is dragged, its readout beside it.
+fn arc_overlay(app: &FigApp, painter: &egui::Painter, col: Color32) {
+    use figcraft_engine::arc_handles::ArcHandle;
+    let Some(hs) = app.session.arc_handles() else { return };
+    let ov = &app.session.tool.overlay;
+    for h in [ArcHandle::Ratio, ArcHandle::Start, ArcHandle::Sweep] {
+        let Some([x, y]) = hs.at(h) else { continue };
+        let c = app.to_screen(x, y);
+        let r = if ov.arc_hover == Some(h) { 5.0 } else { 4.0 };
+        painter.circle_filled(c, r, Color32::WHITE);
+        painter.circle_stroke(c, r, stroke(col, 1.0));
+        if h == ArcHandle::Start {
+            painter.circle_filled(c, 1.5, col);
+        }
+    }
+    if let Some(hint) = &ov.arc {
+        let c = app.to_screen(hint.at[0], hint.at[1]);
+        pill(painter, c + vec2(12.0, 12.0), Align2::LEFT_TOP, hint.label.clone(), col);
+    }
+}
+
+/// The selected shape's corner radius handles and a star's ratio handle (the hovered or dragged
+/// one larger) and, while one is dragged, its value beside it.
+fn shape_overlay(app: &FigApp, painter: &egui::Painter, col: Color32) {
+    use figcraft_engine::shape_handles::ShapeHandle;
+    let ov = &app.session.tool.overlay;
+    for (h, [x, y]) in app.session.shape_handles() {
+        let r = if ov.shape_hover == Some(h) { 4.5 } else { 3.5 };
+        let c = app.to_screen(x, y);
+        painter.circle_filled(c, r, Color32::WHITE);
+        painter.circle_stroke(c, r, stroke(col, 1.0));
+    }
+    if let Some(hint) = &ov.shape {
+        let c = app.to_screen(hint.at[0], hint.at[1]);
+        let text = match hint.handle {
+            ShapeHandle::Radius { .. } => format!("{} {}", tr("Radius"), hint.value),
+            ShapeHandle::Ratio => format!("{} {}%", tr("Ratio"), hint.value),
+        };
+        pill(painter, c + vec2(12.0, 12.0), Align2::LEFT_TOP, text, col);
+    }
+}
+
+/// Variable width tool: each width point on the path with a bar across the stroke to its two
+/// width handles (the selected point filled), and a faint preview where a drag would add one.
+fn width_overlay(app: &FigApp, painter: &egui::Painter, doc: &Document, ve: &figcraft_engine::vectoredit::VectorEdit, zoom: f64) {
+    use figcraft_doc::WidthSide;
+    use figcraft_engine::vectoredit::{WHit, width_handles, width_preview};
+    let hover = app.session.tool.overlay.width_hover;
+    let sp = |p: &[f64; 2]| app.to_screen(p[0], p[1]);
+    let draw = |h: &figcraft_engine::vectoredit::WidthHandle, ghost: bool| {
+        let (c, a, b) = (sp(&h.at), sp(&h.sides[0]), sp(&h.sides[1]));
+        let col = if ghost { accent(painter).gamma_multiply(0.5) } else { accent(painter) };
+        painter.line_segment([a, b], stroke(Color32::from_white_alpha(160), 3.0));
+        painter.line_segment([a, b], stroke(col, 1.0));
+        for (e, side) in [(a, WidthSide::Right), (b, WidthSide::Left)] {
+            let grab = !ghost && hover == Some(WHit::Handle { index: h.index, side });
+            let r = if grab { 4.5 } else { 3.5 };
+            painter.circle_filled(e, r, Color32::WHITE);
+            painter.circle_stroke(e, r, stroke(col, 1.0));
+        }
+        let on = !ghost && ve.width_point == Some(h.index);
+        let hovered = !ghost && hover == Some(WHit::Point { index: h.index });
+        let r = if hovered { 5.0 } else { 4.0 };
+        painter.circle_filled(c, r, if on { accent(painter) } else { Color32::WHITE });
+        painter.circle_stroke(c, r, stroke(col, 1.0));
+    };
+    for h in width_handles(doc, ve, zoom) {
+        draw(&h, false);
+    }
+    if let Some(WHit::Path { t, .. }) = hover {
+        for h in width_preview(doc, ve, t, zoom) {
+            draw(&h, true);
+        }
+    }
+}
+
+/// A bezier handle from its anchor `v` to its end `e` (screen points): the line, and a dot of
+/// radius `r` filled with `fill` (vector edit mode and the Pen draw them alike).
+fn bezier_handle(painter: &egui::Painter, v: Pos2, e: Pos2, r: f32, fill: Color32) {
+    painter.line_segment([v, e], stroke(accent(painter), 1.0));
+    painter.circle_filled(e, r, fill);
+    painter.circle_stroke(e, r, stroke(accent(painter), 1.0));
+}
+
+/// Vector edit mode: a layer's segments, handles and points (`points`) with its `hover`ed part, the
+/// `add` point a press would put on the outline, and for the `active` layer the closed area under
+/// the paint bucket and the pen's rubber band.
+fn vector_overlay(
+    app: &FigApp,
+    painter: &egui::Painter,
+    o: &figcraft_engine::vectoredit::EditOverlay,
+    points: bool,
+    hover: Option<figcraft_engine::vectoredit::VHit>,
+    active: bool,
+    add: Option<figcraft_engine::tools::VectorAdd>,
+) {
+    use figcraft_engine::vectoredit::VHit;
+    let ov = &app.session.tool.overlay;
+    let sp = |p: &[f64; 2]| app.to_screen(p[0], p[1]);
+    // Paint bucket target: hatched like a fill to come.
+    if active && !ov.face.is_empty() {
+        let polys: Vec<Vec<Pos2>> = ov.face.iter().map(|poly| poly.iter().map(sp).collect()).collect();
+        hatched(painter, &polys, accent(painter));
+    }
+    if active {
+        region_hatch(app, painter);
+    }
+    let hover_seg = match hover {
+        Some(VHit::Segment { seg, .. }) => Some(seg),
+        _ => None,
+    };
+    for (i, seg) in o.segments.iter().enumerate() {
+        let [a, b, c, d] = [sp(&seg[0]), sp(&seg[1]), sp(&seg[2]), sp(&seg[3])];
+        let w = if o.selected_segments.contains(&i) {
+            3.0
+        } else if hover_seg == Some(i) {
+            2.5
+        } else {
+            1.5
+        };
+        painter.add(egui::epaint::CubicBezierShape::from_points_stroke([a, b, c, d], false, Color32::TRANSPARENT, stroke(accent(painter), w)));
+    }
+    if !points {
+        return;
+    }
+    for h in &o.handles {
+        let hovered = hover == Some(VHit::Handle { seg: h.seg, start: h.start });
+        let on = o.selected_handles.contains(&(h.seg, h.start));
+        bezier_handle(painter, sp(&h.vertex), sp(&h.handle), if hovered { 4.5 } else { 3.5 }, if on { accent(painter) } else { Color32::WHITE });
+    }
+    for (i, v) in o.vertices.iter().enumerate() {
+        let p = sp(v);
+        let hovered = matches!(hover, Some(VHit::Vertex { index }) if index == i);
+        let size = if hovered { 9.0 } else { 7.0 };
+        let r = Rect::from_center_size(p, vec2(size, size));
+        let on = o.selected_vertices.contains(&i);
+        painter.rect_filled(r, CornerRadius::same(5), if on { accent(painter) } else { Color32::WHITE });
+        painter.rect_stroke(r, CornerRadius::same(5), stroke(accent(painter), 1.0), StrokeKind::Inside);
+        if o.anchor == Some(i) {
+            painter.circle_stroke(p, 7.5, stroke(accent(painter), 1.0));
+        }
+    }
+    // The point a press would add to the outline: the pen's ghost anchor where it is over a
+    // segment, or a segment's midpoint under the Move tool (which grows and fills once the pointer
+    // is on it, when a press adds it).
+    if let Some(a) = add {
+        let p = app.to_screen(a.at[0], a.at[1]);
+        let col = accent(painter);
+        if a.midpoint {
+            let (r, fill) = if a.on { (5.5, col) } else { (3.5, Color32::from_white_alpha(190)) };
+            painter.circle_filled(p, r, fill);
+            painter.circle_stroke(p, r, stroke(if a.on { Color32::WHITE } else { col.gamma_multiply(0.7) }, 1.2));
+        } else {
+            let r = Rect::from_center_size(p, vec2(7.0, 7.0));
+            painter.rect_filled(r, CornerRadius::same(5), Color32::from_white_alpha(160));
+            painter.rect_stroke(r, CornerRadius::same(5), stroke(col.gamma_multiply(0.8), 1.0), StrokeKind::Inside);
+        }
+    }
+    if let Some([x0, y0, x1, y1]) = ov.rubber.filter(|_| active) {
+        painter.add(Shape::dashed_line(&[app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(accent(painter), 1.0), 4.0, 3.0));
+    }
+}
+
+/// The overlay green for the page this painter draws on ([`crate::theme::canvas_accent`]).
+pub(super) fn accent(p: &egui::Painter) -> Color32 {
+    crate::theme::canvas_accent(p.ctx())
+}
diff --git a/crates/ui-egui/src/canvas/render.rs b/crates/ui-egui/src/canvas/render.rs
new file mode 100644
index 00000000..915e8ea5
--- /dev/null
+++ b/crates/ui-egui/src/canvas/render.rs
@@ -0,0 +1,166 @@
+use super::*;
+
+#[derive(Clone, PartialEq)]
+pub(super) struct JobKey {
+    doc: usize,
+    page: NodeId,
+    origin: (i64, i64),
+    scale: i64,
+    size: (u32, u32),
+    outline: bool,
+    outline_extras: figcraft_render::Outline,
+    outlined: Vec<NodeId>,
+    skip: Vec<NodeId>,
+    solo: Option<NodeId>,
+    /// Text lays out anew when fonts arrive (system fonts load in the background).
+    fonts: u64,
+    proof: bool,
+    dots: Option<figcraft_render::Dots>,
+}
+
+/// Whether a finished render goes on screen: an image of the file and page shown (`shown`), and
+/// not a coarse preview over a refined image of the same or a newer request, or one that already
+/// shows the whole view asked for at its zoom (the same zoom elsewhere on the page is no such
+/// image).
+pub(crate) fn shows(c: &CanvasState, done: &Done, shown: Option<(u64, NodeId)>) -> bool {
+    if shown != Some((done.uid, done.page)) {
+        return false;
+    }
+    let refined = !c.tex_coarse && c.tex_of == shown;
+    if done.coarse && refined && done.seq <= c.tex_seq {
+        return false;
+    }
+    let refined_here = refined
+        && c.tex_view
+            .as_ref()
+            .zip(c.want_view.as_ref())
+            .is_some_and(|(have, want)| have.scale.to_bits() == want.scale.to_bits() && covers(have, want));
+    !(done.coarse && refined_here)
+}
+
+/// Whether `outer` shows all of the page that `inner` does.
+fn covers(outer: &figcraft_render::View, inner: &figcraft_render::View) -> bool {
+    let (o, i) = (outer.page_rect(), inner.page_rect());
+    // Rounding in the snapped origin, well under a device pixel.
+    let eps = 1e-6 / inner.scale.max(1e-9);
+    o.x0 <= i.x0 + eps && o.y0 <= i.y0 + eps && o.x1 >= i.x1 - eps && o.y1 >= i.y1 - eps
+}
+
+pub(super) fn request_render(app: &mut FigApp, worker: &mut Worker, ppp: f32, max_texture_side: u32, dots: Option<figcraft_render::Dots>) {
+    let Ok(ds) = app.session.ds() else { return };
+    let rect = app.canvas.rect;
+    let (mut ox, mut oy) = ds.view.origin();
+    let (scale, visible_w, visible_h) = if let Some(k) = ds.view.pixel_preview_scale() {
+        // Pixel preview: render `k` pixels per page unit from a whole-pixel origin, shown magnified
+        // without smoothing.
+        (ox, oy) = ((ox * k).floor() / k, (oy * k).floor() / k);
+        let z = ds.view.zoom.max(1e-9) / k;
+        (k, (f64::from(rect.width()) / z).ceil() as u32 + 2, (f64::from(rect.height()) / z).ceil() as u32 + 2)
+    } else {
+        (ds.view.zoom * f64::from(ppp), (rect.width() * ppp).ceil().max(1.0) as u32, (rect.height() * ppp).ceil().max(1.0) as u32)
+    };
+    // The edited text is drawn live (an IME composition included); the caret is an overlay.
+    let doc = app.preedit_view().map(|p| p.doc.clone()).unwrap_or_else(|| ds.doc.clone());
+    let outlined = if ds.view.outlines_selection { ds.selection.clone() } else { vec![] };
+    let proof = ds.view.proof_srgb && !doc.color_profile.is_srgb();
+    let outline_extras = figcraft_render::Outline { hidden: ds.view.outline_hidden, bounds: ds.view.outline_bounds, light: false };
+    // Render beyond the visible viewport. During a pan the previous texture then still covers
+    // the screen while the worker renders newly exposed content. Request a new buffer before the
+    // visible area reaches its edge, rather than exposing an empty strip each pointer move.
+    let margin = overscan_margin(visible_w, visible_h, max_texture_side);
+    let origin = (ox, oy);
+    let visible = (visible_w, visible_h);
+    let requested = (ox - f64::from(margin) / scale, oy - f64::from(margin) / scale);
+    let size = (visible_w.saturating_add(margin * 2).min(max_texture_side), visible_h.saturating_add(margin * 2).min(max_texture_side));
+    let key = JobKey {
+        doc: Arc::as_ptr(&doc) as usize,
+        page: ds.page,
+        origin: ((requested.0 * 1000.0) as i64, (requested.1 * 1000.0) as i64),
+        scale: (scale * 10000.0) as i64,
+        size,
+        outline: ds.view.outlines,
+        outline_extras,
+        outlined: outlined.clone(),
+        skip: vec![],
+        solo: ds.focused(),
+        fonts: figcraft_text::layout_generation(),
+        proof,
+        dots,
+    };
+    if let Some(previous) = &app.canvas.submitted {
+        let previous_origin = (previous.origin.0 as f64 / 1000.0, previous.origin.1 as f64 / 1000.0);
+        let same_content = JobKey { origin: previous.origin, size: previous.size, ..key.clone() } == *previous;
+        let covers = cached_render_covers(previous_origin, previous.size, origin, visible, scale);
+        if same_content && covers {
+            return;
+        }
+    }
+    if app.canvas.submitted.as_ref() == Some(&key) {
+        return;
+    }
+    let job = Job {
+        doc,
+        page: ds.page,
+        view: figcraft_render::View { origin: requested, scale, width: size.0, height: size.1 },
+        outline: ds.view.outlines,
+        outline_extras,
+        outlined,
+        skip: vec![],
+        solo: key.solo,
+        proof,
+        dots,
+        uid: ds.uid,
+        zoom_preview: ds.view.pixel_preview_scale().is_none(),
+        at: web_time::Instant::now(),
+    };
+    app.canvas.want_view = Some(job.view.clone());
+    worker.submit(job);
+    app.canvas.submitted = Some(key);
+}
+
+/// Leave a 96-pixel reserve so the next render starts before a pan reaches a cached edge.
+fn cached_render_covers(buffer_origin: (f64, f64), buffer_size: (u32, u32), view_origin: (f64, f64), view_size: (u32, u32), scale: f64) -> bool {
+    if !scale.is_finite() || scale <= 0.0 {
+        return false;
+    }
+    let guard_x = 96.0_f64.min(f64::from(buffer_size.0.saturating_sub(view_size.0)) / 4.0) / scale;
+    let guard_y = 96.0_f64.min(f64::from(buffer_size.1.saturating_sub(view_size.1)) / 4.0) / scale;
+    view_origin.0 >= buffer_origin.0 + guard_x
+        && view_origin.1 >= buffer_origin.1 + guard_y
+        && view_origin.0 + f64::from(view_size.0) / scale <= buffer_origin.0 + f64::from(buffer_size.0) / scale - guard_x
+        && view_origin.1 + f64::from(view_size.1) / scale <= buffer_origin.1 + f64::from(buffer_size.1) / scale - guard_y
+}
+
+/// Bound the extra rendered area to about 1.6 times the visible area. A fixed large margin can
+/// multiply the pixel count several-fold on a narrow or small viewport.
+fn overscan_margin(width: u32, height: u32, max_texture_side: u32) -> u32 {
+    width.min(height).saturating_div(8).min(128).min(max_texture_side.saturating_sub(width.max(height)) / 2)
+}
+
+#[cfg(test)]
+#[test]
+fn pan_uses_cached_pixels_until_the_refill_boundary() {
+    let margin = overscan_margin(1000, 800, 16_383);
+    assert_eq!(margin, 100);
+    let buffer = (-f64::from(margin), -f64::from(margin));
+    let size = (1000 + 2 * margin, 800 + 2 * margin);
+    assert!(cached_render_covers(buffer, size, (0.0, 0.0), (1000, 800), 1.0));
+    assert!(cached_render_covers(buffer, size, (50.0, 0.0), (1000, 800), 1.0));
+    assert!(!cached_render_covers(buffer, size, (80.0, 0.0), (1000, 800), 1.0));
+    assert!(!cached_render_covers(buffer, size, (-80.0, 0.0), (1000, 800), 1.0));
+    assert!(cached_render_covers((-24.0, -24.0), (1048, 848), (10.0, 0.0), (1000, 800), 1.0));
+    assert!(!cached_render_covers((-24.0, -24.0), (1048, 848), (19.0, 0.0), (1000, 800), 1.0));
+}
+
+#[cfg(test)]
+#[test]
+fn overscan_stays_within_texture_and_pixel_budget() {
+    for (width, height, limit) in [(1000, 800, 16_383), (390, 844, 16_383), (2560, 1440, 16_383), (1000, 800, 1060)] {
+        let margin = overscan_margin(width, height, limit);
+        assert!(width + 2 * margin <= limit || width > limit);
+        assert!(height + 2 * margin <= limit || height > limit);
+        let rendered = u64::from(width + 2 * margin) * u64::from(height + 2 * margin);
+        let visible = u64::from(width) * u64::from(height);
+        assert!(rendered * 5 <= visible * 8); // At most 1.6× the visible pixels.
+    }
+}
diff --git a/crates/ui-egui/src/canvas/rulers.rs b/crates/ui-egui/src/canvas/rulers.rs
new file mode 100644
index 00000000..a394ca7c
--- /dev/null
+++ b/crates/ui-egui/src/canvas/rulers.rs
@@ -0,0 +1,93 @@
+use super::outline::stroke;
+use super::overlays::accent;
+use super::*;
+
+/// The layers that get canvas labels and layout grids, in z-order: the page's visible top-level
+/// layers and, inside sections whose contents show, their visible children (sections nest). A
+/// section comes after its children, so its title pill draws over (and takes clicks from) the
+/// labels of frames near its top-left (#1150).
+pub(super) fn boards(doc: &Document, page: NodeId) -> Vec<NodeId> {
+    fn walk(doc: &Document, id: NodeId, depth: usize, out: &mut Vec<NodeId>) {
+        let Some(n) = doc.node(id) else { return };
+        for c in &n.children {
+            let Some(cn) = doc.node(*c) else { continue };
+            if !cn.visible {
+                continue;
+            }
+            if matches!(cn.kind, NodeKind::Section { contents_hidden: false }) && depth < 32 {
+                walk(doc, *c, depth + 1, out);
+            }
+            out.push(*c);
+        }
+    }
+    let mut out = Vec::new();
+    walk(doc, page, 0, &mut out);
+    out
+}
+
+/// A frame's or section's handoff status as its badge says it, with the badge colour ("Changed"
+/// once a ready-for-dev layer was edited; `None` without a status).
+pub(crate) fn status_label(n: &figcraft_doc::Node) -> Option<(&'static str, Color32)> {
+    match n.dev_status {
+        figcraft_doc::DevStatus::None => None,
+        figcraft_doc::DevStatus::ReadyForDev if n.dev_changed => Some((tr("Changed"), crate::theme::DEV_CHANGED)),
+        figcraft_doc::DevStatus::ReadyForDev => Some((tr("Ready for dev"), crate::theme::DEV_READY)),
+        figcraft_doc::DevStatus::Completed => Some((tr("Completed"), crate::theme::DEV_COMPLETED)),
+    }
+}
+
+/// A frame's or section's handoff status as a small pill left-centred on `at`; the pill's area.
+pub(crate) fn status_badge(painter: &egui::Painter, n: &figcraft_doc::Node, at: Pos2) -> Option<Rect> {
+    let (label, fill) = status_label(n)?;
+    let galley = painter.layout_no_wrap(label.to_string(), semibold(10.0), Color32::WHITE);
+    let r = Rect::from_min_size(pos2(at.x, at.y - galley.size().y / 2.0 - 2.0), galley.size() + vec2(10.0, 4.0));
+    painter.rect_filled(r, CornerRadius::same(4), fill);
+    painter.galley(r.min + vec2(5.0, 2.0), galley, Color32::WHITE);
+    Some(r)
+}
+
+pub(super) fn rulers(app: &FigApp, painter: &egui::Painter, t: &Tokens, doc: &Document, sel: &[NodeId]) {
+    let r = app.canvas.rect;
+    let size = 20.0;
+    painter.rect_filled(Rect::from_min_size(r.min, vec2(r.width(), size)), CornerRadius::ZERO, t.panel);
+    painter.rect_filled(Rect::from_min_size(r.min, vec2(size, r.height())), CornerRadius::ZERO, t.panel);
+    let zoom = app.session.ds().map(|d| d.view.zoom).unwrap_or(1.0);
+    let step = figcraft_engine::guides::ruler_step(zoom);
+    let p0 = app.to_page(r.min);
+    let p1 = app.to_page(r.max);
+    // Highlight the selection's span.
+    if let Some(b) = doc.bounds_of(sel) {
+        let (a, bb) = (app.to_screen(b.x0, b.y0), app.to_screen(b.x1, b.y1));
+        painter.rect_filled(
+            Rect::from_min_max(pos2(a.x, r.min.y), pos2(bb.x, r.min.y + size)),
+            CornerRadius::ZERO,
+            accent(painter).gamma_multiply(0.15),
+        );
+        painter.rect_filled(
+            Rect::from_min_max(pos2(r.min.x, a.y), pos2(r.min.x + size, bb.y)),
+            CornerRadius::ZERO,
+            accent(painter).gamma_multiply(0.15),
+        );
+    }
+    let mut x = (p0.x / step).floor() * step;
+    while x <= p1.x {
+        let s = app.to_screen(x, 0.0).x;
+        painter.line_segment([pos2(s, r.min.y + size - 6.0), pos2(s, r.min.y + size)], stroke(t.text_tertiary, 1.0));
+        painter.text(pos2(s + 2.0, r.min.y + 3.0), Align2::LEFT_TOP, fmt(x), regular(9.0), t.text_secondary);
+        x += step;
+    }
+    let mut y = (p0.y / step).floor() * step;
+    while y <= p1.y {
+        let s = app.to_screen(0.0, y).y;
+        painter.line_segment([pos2(r.min.x + size - 6.0, s), pos2(r.min.x + size, s)], stroke(t.text_tertiary, 1.0));
+        painter.text(pos2(r.min.x + 3.0, s + 2.0), Align2::LEFT_TOP, fmt(y), regular(9.0), t.text_secondary);
+        y += step;
+    }
+    painter.line_segment([pos2(r.min.x, r.min.y + size), pos2(r.max.x, r.min.y + size)], stroke(t.border, 1.0));
+    painter.line_segment([pos2(r.min.x + size, r.min.y), pos2(r.min.x + size, r.max.y)], stroke(t.border, 1.0));
+}
+
+pub fn fmt(v: f64) -> String {
+    let r = (v * 100.0).round() / 100.0;
+    if (r - r.round()).abs() < 1e-9 { format!("{}", r.round() as i64) } else { format!("{r}") }
+}

From 1d892d2e7bb1e6c7bd51f61e1e7632e7197165bc Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:56:10 +0000
Subject: [PATCH 44/67] refactor(ui-egui): split panels/typography.rs into
 typography/

---
 crates/ui-egui/src/panels/typography.rs       | 1285 +----------------
 crates/ui-egui/src/panels/typography/axes.rs  |  187 +++
 .../ui-egui/src/panels/typography/fields.rs   |  481 ++++++
 .../ui-egui/src/panels/typography/glyphs.rs   |  257 ++++
 .../ui-egui/src/panels/typography/picker.rs   |  189 +++
 .../ui-egui/src/panels/typography/spacing.rs  |  202 +++
 6 files changed, 1326 insertions(+), 1275 deletions(-)
 create mode 100644 crates/ui-egui/src/panels/typography/axes.rs
 create mode 100644 crates/ui-egui/src/panels/typography/fields.rs
 create mode 100644 crates/ui-egui/src/panels/typography/glyphs.rs
 create mode 100644 crates/ui-egui/src/panels/typography/picker.rs
 create mode 100644 crates/ui-egui/src/panels/typography/spacing.rs

diff --git a/crates/ui-egui/src/panels/typography.rs b/crates/ui-egui/src/panels/typography.rs
index 13b5785f..046428f7 100644
--- a/crates/ui-egui/src/panels/typography.rs
+++ b/crates/ui-egui/src/panels/typography.rs
@@ -18,6 +18,16 @@ use crate::right::{common, menu_item, menu_popup, row};
 use crate::theme::{Tokens, regular, semibold};
 use crate::widgets::{self, FIELD_H, FieldEdit, Lead, PAD};
 
+mod axes;
+mod fields;
+mod glyphs;
+mod picker;
+mod spacing;
+
+use fields::{font_rows, paragraph_rows};
+pub(crate) use picker::font_picker;
+pub(crate) use spacing::{letter_spacing_of, line_height_of, parse_letter_spacing, parse_line_height};
+
 /// Font sizes offered by the size dropdown.
 const SIZES: [f64; 15] = [10.0, 11.0, 12.0, 13.0, 14.0, 16.0, 20.0, 24.0, 32.0, 36.0, 40.0, 48.0, 64.0, 96.0, 128.0];
 
@@ -169,226 +179,6 @@ fn text_style_params(ids: &[NodeId], range: Option<(NodeId, usize, usize)>, mut
     props
 }
 
-/// The font rows: family, style and size, line height and letter spacing.
-fn font_rows(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], styles: &[TextStyle], editing: bool, apply_style: &dyn Fn(&mut FigApp, &str, Value)) {
-    let t = Tokens::get(ui.ctx());
-    let range = figcraft_engine::textedit::selected_range(&app.session);
-
-    // Font family.
-    let family = uniform(styles, |s| s.font_family.clone());
-    let fstyle = uniform(styles, |s| s.font_style.clone());
-    row(ui, 32.0, |ui| {
-        let w = ui.available_width();
-        let resp = font_dropdown(app, ui, ids, "fontFamily", family.as_deref(), w, editing);
-        menu_popup(&resp).width(w.max(240.0)).close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside).show(|ui| {
-            if !editing && apply_variable_item(ui, ids, "fontFamily", &resp) {
-                return;
-            }
-            let pick = font_picker(ui, family.as_deref(), resp.clicked());
-            if let Some(f) = pick.picked {
-                remember_family(ui.ctx(), &f);
-                apply_style(app, "fontFamily", json!(f));
-                ui.close();
-            } else if let Some(h) = pick.hovered.or(pick.highlighted) {
-                // The canvas shows the hovered family (or the one the arrow keys are on);
-                // closing without picking ends the preview.
-                app.preview_text(ui.ctx(), "text.style", text_style_params(ids, range, json!({"fontFamily": h})));
-            }
-        });
-    });
-
-    // Style + size.
-    let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
-    row(ui, 32.0, |ui| {
-        let resp = font_dropdown(app, ui, ids, "fontStyle", fstyle.as_deref(), half, editing);
-        let fam = family.clone();
-        menu_popup(&resp).width(200.0).show(|ui| {
-            if !editing && apply_variable_item(ui, ids, "fontStyle", &resp) {
-                return;
-            }
-            match &fam {
-                Some(fam) => {
-                    let list = figcraft_text::family_styles(fam);
-                    if list.is_empty() {
-                        widgets::label(ui, tr("Font not installed"), t.text_tertiary);
-                    }
-                    egui::ScrollArea::vertical().max_height(320.0).show(ui, |ui| {
-                        for s in list {
-                            let mark = if fstyle.as_deref() == Some(s.as_str()) { "✓ " } else { "   " };
-                            let (clicked, hovered) = menu_item_hover(ui, &format!("{mark}{s}"));
-                            if clicked {
-                                apply_style(app, "fontStyle", json!(s));
-                                ui.close();
-                            } else if hovered {
-                                // The canvas shows the style (a variable font's named instance too).
-                                app.preview_text(ui.ctx(), "text.style", text_style_params(ids, range, json!({"fontStyle": s})));
-                            }
-                        }
-                    });
-                }
-                None => widgets::label(ui, tr("Pick one font family first"), t.text_tertiary),
-            }
-        });
-        let size = uniform(styles, |s| s.font_size);
-        ui.spacing_mut().item_spacing.x = 0.0;
-        // The whole layer's size can follow a variable; a selected range just takes a value.
-        let e = if editing {
-            widgets::number_field(ui, Id::unique("ty_size"), Lead::None, size, "", half - 20.0, 1.0)
-        } else {
-            crate::variable_ui::number_field(app, ui, ids, "fontSize", Id::unique("ty_size"), Lead::None, size, "", half - 20.0)
-        };
-        match e {
-            Some(FieldEdit::Set(v)) => apply_style(app, "fontSize", json!(v.clamp(1.0, 5000.0))),
-            // The text editing session already groups undo; just apply.
-            Some(FieldEdit::Scrub(v, _)) if editing => apply_style(app, "fontSize", json!(v.clamp(1.0, 5000.0))),
-            Some(FieldEdit::Scrub(v, done)) => {
-                live(app, "Font size", "node.set", json!({"ids": ids, "props": {"fontSize": v.clamp(1.0, 5000.0)}}), done)
-            }
-            None => {}
-        }
-        let more = icons::button(ui, Icon::Chevron, 20.0, false, tr("Font size"));
-        menu_popup(&more).width(90.0).show(|ui| {
-            egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
-                for v in SIZES {
-                    let mark = if size == Some(v) { "✓ " } else { "   " };
-                    if menu_item(ui, &format!("{mark}{}", trim_num(v)), "") {
-                        apply_style(app, "fontSize", json!(v));
-                        ui.close();
-                    }
-                }
-            });
-        });
-    });
-
-    // Line height + letter spacing.
-    row(ui, 32.0, |ui| {
-        let lh = uniform(styles, |s| s.line_height);
-        let lh_label = lh.map(|l| l.label()).unwrap_or_else(|| tr(MIXED).into());
-        let field = SpacingField { field: "lineHeight", id: Id::unique("ty_lh"), glyph: LeadGlyph::LineHeight, tip: tr("Line height") };
-        if let Some(edit) = spacing_field(app, ui, ids, &field, &lh_label, half, editing)
-            && let Some(v) = parse_line_height(&edit.text(), lh)
-        {
-            commit_spacing(app, ids, range, &field, &edit, v);
-        }
-        let ls = uniform(styles, |s| s.letter_spacing);
-        let ls_label = ls.map(|l| l.label()).unwrap_or_else(|| tr(MIXED).into());
-        let field = SpacingField { field: "letterSpacing", id: Id::unique("ty_ls"), glyph: LeadGlyph::LetterSpacing, tip: tr("Letter spacing") };
-        if let Some(edit) = spacing_field(app, ui, ids, &field, &ls_label, half, editing)
-            && let Some(v) = parse_letter_spacing(&edit.text(), ls)
-        {
-            commit_spacing(app, ids, range, &field, &edit, v);
-        }
-    });
-}
-
-/// Paragraph spacing, resizing, alignment and the Type settings popover.
-fn paragraph_rows(
-    app: &mut FigApp,
-    ui: &mut Ui,
-    doc: &Document,
-    ids: &[NodeId],
-    styles: &[TextStyle],
-    apply_style: &dyn Fn(&mut FigApp, &str, Value),
-) {
-    let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
-    // Paragraph spacing + resizing.
-    let ps = common(doc, ids, |n| n.kind.text().map(|t| t.paragraph_spacing.to_bits())).flatten().map(f64::from_bits);
-    let resize = common(doc, ids, |n| n.kind.text().map(|t| t.auto_resize)).flatten();
-    row(ui, 32.0, |ui| {
-        let ps_label = ps.map(trim_num).unwrap_or_else(|| tr(MIXED).into());
-        let field =
-            SpacingField { field: "paragraphSpacing", id: Id::unique("ty_ps"), glyph: LeadGlyph::ParagraphSpacing, tip: tr("Paragraph spacing") };
-        if let Some(edit) = spacing_input(ui, &field, &ps_label, half)
-            && let Some(v) = widgets::eval(&edit.text(), ps)
-        {
-            commit_spacing(app, ids, None, &field, &edit, json!(v.clamp(0.0, 10_000.0)));
-        }
-        let items =
-            [(Icon::Hug, tr("Auto width")), (Icon::LayoutV, tr("Auto height")), (Icon::Fixed, tr("Fixed size")), (Icon::Dots, tr("Truncate text"))];
-        let active = resize.map(|r| match r {
-            TextAutoResize::WidthAndHeight => 0,
-            TextAutoResize::Height => 1,
-            TextAutoResize::None => 2,
-            TextAutoResize::Truncate => 3,
-        });
-        if let Some(i) = widgets::segmented(ui, &items, active, (half / 4.0).floor()) {
-            let v = ["widthAndHeight", "height", "none", "truncate"].get(i).copied().unwrap_or("none");
-            app.set_props(ids, json!({"textAutoResize": v}));
-        }
-    });
-
-    // Alignment + Type settings.
-    let align = common(doc, ids, |n| n.kind.text().map(|t| (t.align_h, t.align_v))).flatten();
-    row(ui, 32.0, |ui| {
-        let items = [
-            (Icon::TextAlignLeft, tr("Align left")),
-            (Icon::TextAlignCenter, tr("Align center")),
-            (Icon::TextAlignRight, tr("Align right")),
-            (Icon::TextAlignJustify, tr("Justify")),
-        ];
-        let active = align.map(|(h, _)| match h {
-            TextAlignH::Left => 0,
-            TextAlignH::Center => 1,
-            TextAlignH::Right => 2,
-            TextAlignH::Justified => 3,
-        });
-        if let Some(i) = widgets::segmented(ui, &items, active, 24.0) {
-            let v = ["left", "center", "right", "justified"].get(i).copied().unwrap_or("left");
-            app.set_props(ids, json!({"textAlign": v}));
-        }
-        let items = [(Icon::TextTop, tr("Align top")), (Icon::TextMiddle, tr("Align middle")), (Icon::TextBottom, tr("Align bottom"))];
-        let active = align.map(|(_, v)| match v {
-            TextAlignV::Top => 0,
-            TextAlignV::Middle => 1,
-            TextAlignV::Bottom => 2,
-        });
-        if let Some(i) = widgets::segmented(ui, &items, active, 24.0) {
-            let v = ["top", "middle", "bottom"].get(i).copied().unwrap_or("top");
-            app.set_props(ids, json!({"textAlignVertical": v}));
-        }
-        let open_id = Id::unique("ty_settings_open");
-        let open = egui::Popup::is_id_open(ui.ctx(), open_id);
-        let more = icons::button(ui, Icon::Dots, 24.0, open, tr("Type settings"));
-        egui::Popup::from_toggle_button_response(&more)
-            .id(open_id)
-            .width(264.0)
-            .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
-            .show(|ui| type_settings(app, ui, doc, ids, styles, apply_style));
-    });
-}
-
-/// A menu item that also reports the pointer being over it: (clicked, hovered).
-fn menu_item_hover(ui: &mut Ui, label: &str) -> (bool, bool) {
-    let r = crate::right::menu_row(ui, label, "", 0.0, |_, _, _| {});
-    (r.clicked(), r.hovered())
-}
-
-/// The font family or font style dropdown for `field`, `width` wide, showing `shown` (Mixed when
-/// None). While whole layers are edited and `field` is bound to the same variable on every one of
-/// `ids`, the variable's chip is drawn in place of the dropdown (a click picks another variable,
-/// its detach button unbinds it), and the returned response opens no menu.
-fn font_dropdown(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], field: &str, shown: Option<&str>, width: f32, editing: bool) -> egui::Response {
-    if !editing && app.session.doc().ok().and_then(|d| crate::variable_ui::bound_name(d, ids, field)).is_some() {
-        let (rect, resp) = ui.allocate_exact_size(vec2(width, FIELD_H), Sense::hover());
-        crate::variable_ui::bound_chip(app, ui, ids, field, VariableType::String, rect);
-        return resp;
-    }
-    widgets::dropdown(ui, shown.unwrap_or(tr(MIXED)), width, None)
-}
-
-/// Apply variable at the top of the font family or font style menu opened from `anchor`: a click
-/// opens the variable picker on string variables for `field` of `ids` and closes the menu (true).
-fn apply_variable_item(ui: &mut Ui, ids: &[NodeId], field: &str, anchor: &egui::Response) -> bool {
-    let picked = menu_item(ui, tr("Apply variable"), "");
-    if picked {
-        crate::variable_ui::open(ui, ids, field, VariableType::String, anchor.rect.left_bottom());
-        ui.close();
-    } else {
-        ui.separator();
-    }
-    picked
-}
-
 /// Run `cmd` as a live preview while scrubbing; the gesture becomes one undo step when `done`.
 /// (While text is edited, run commands directly: the editing session already groups undo.)
 pub(crate) fn live(app: &mut FigApp, label: &str, cmd: &str, params: Value, done: bool) {
@@ -401,186 +191,6 @@ pub(crate) fn live(app: &mut FigApp, label: &str, cmd: &str, params: Value, done
     }
 }
 
-/// The variable font the shown styles use (one family, one variable face), if any.
-fn variable_face(styles: &[TextStyle]) -> Option<Arc<figcraft_text::Face>> {
-    let family = uniform(styles, |s| s.font_family.clone())?;
-    let face = figcraft_text::find_face(&family, &styles.first()?.font_style)?;
-    (face.is_variable() && face.family.eq_ignore_ascii_case(&family)).then_some(face)
-}
-
-/// The Type settings popover: Basics (decoration, case, list, indent, truncation), Details
-/// (OpenType features) and, for variable fonts, Variable (axis sliders).
-fn type_settings(
-    app: &mut FigApp,
-    ui: &mut Ui,
-    doc: &Document,
-    ids: &[NodeId],
-    styles: &[TextStyle],
-    apply_style: &dyn Fn(&mut FigApp, &str, Value),
-) {
-    let t = Tokens::get(ui.ctx());
-    let tab_id = Id::unique("ty_settings_tab");
-    let vf = variable_face(styles);
-    let tabs = &TABS[..if vf.is_some() { 3 } else { 2 }];
-    let mut tab: usize = ui.data(|d| d.get_temp(tab_id)).filter(|i| *i < tabs.len()).unwrap_or(0);
-    ui.horizontal(|ui| {
-        for (i, l) in tabs.iter().enumerate() {
-            let col = if tab == i { t.text } else { t.text_secondary };
-            let r = ui.add(egui::Label::new(egui::RichText::new(tr(l)).font(semibold(11.5)).color(col)).sense(Sense::click()));
-            if r.clicked() {
-                tab = i;
-            }
-        }
-    });
-    ui.data_mut(|d| d.insert_temp(tab_id, tab));
-    ui.add_space(4.0);
-    let w = ui.available_width();
-    if tab == 0 {
-        let deco = uniform(styles, |s| s.decoration);
-        caption(ui, tr("Decoration"));
-        let active = deco.map(|d| match d {
-            TextDecoration::None => 0,
-            TextDecoration::Underline => 1,
-            TextDecoration::Strikethrough => 2,
-        });
-        let items = [("—", tr_noop("None")), ("U", tr_noop("Underline")), ("S", tr_noop("Strikethrough"))];
-        if let Some(i) = text_seg(ui, "deco", &items, active, w) {
-            apply_style(app, "textDecoration", json!((["none", "underline", "strikethrough"].get(i).copied().unwrap_or("none"))));
-        }
-        if let Some(d @ (TextDecoration::Underline | TextDecoration::Strikethrough)) = deco {
-            decoration_details(app, ui, styles, apply_style, d == TextDecoration::Underline, w);
-        }
-        caption(ui, tr("Letter case"));
-        let case = uniform(styles, |s| s.case);
-        let active = case.map(|c| match c {
-            TextCase::Original => 0,
-            TextCase::Upper => 1,
-            TextCase::Lower => 2,
-            TextCase::Title => 3,
-            TextCase::SmallCaps => 4,
-        });
-        let items = [
-            ("—", tr_noop("As typed")),
-            ("AG", tr_noop("Uppercase")),
-            ("ag", tr_noop("Lowercase")),
-            ("Ag", tr_noop("Title case")),
-            ("Aɢ", tr_noop("Small caps")),
-        ];
-        if let Some(i) = text_seg(ui, "case", &items, active, w) {
-            apply_style(app, "textCase", json!((["original", "upper", "lower", "title", "smallCaps"].get(i).copied().unwrap_or("original"))));
-        }
-        caption(ui, tr("List style"));
-        // While editing: the selected paragraphs' list.
-        let range = figcraft_engine::textedit::selected_range(&app.session);
-        let list = common(doc, ids, |n| {
-            n.kind.text().and_then(|t| {
-                let (a, b) = range.filter(|r| r.0 == n.id).map_or((0, t.char_count()), |(_, a, b)| (a, b));
-                t.common_para_list(a, b).map(|p| p.list)
-            })
-        })
-        .flatten();
-        let active = list.map(|l| match l {
-            ListStyle::None => 0,
-            ListStyle::Bulleted => 1,
-            ListStyle::Numbered => 2,
-        });
-        let items = [("—", tr_noop("No list")), ("•", tr_noop("Bulleted list")), ("1.", tr_noop("Numbered list"))];
-        if let Some(i) = text_seg(ui, "list", &items, active, w) {
-            app.run("text.listStyle", json!({"ids": ids, "style": (["none", "bulleted", "numbered"].get(i).copied().unwrap_or("none"))}));
-        }
-        ui.add_space(6.0);
-        let spacing = common(doc, ids, |n| n.kind.text().map(|t| t.list_spacing.to_bits())).flatten().map(f64::from_bits);
-        field_row(ui, tr("List spacing"), |ui, fw| {
-            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) =
-                widgets::number_field(ui, Id::unique("ty_list_spacing"), Lead::None, spacing, "", fw, 1.0)
-            {
-                app.set_props(ids, json!({"listSpacing": v.clamp(0.0, 10_000.0)}));
-            }
-        });
-        ui.add_space(4.0);
-        let indent = common(doc, ids, |n| n.kind.text().map(|t| t.paragraph_indent.to_bits())).flatten().map(f64::from_bits);
-        // Indent applies to start-aligned text only; elsewhere the field stays visible but off.
-        let start_aligned =
-            common(doc, ids, |n| n.kind.text().map(|t| t.align_h != TextAlignH::Center && t.align_h != TextAlignH::Justified)).flatten();
-        ui.add_enabled_ui(start_aligned != Some(false), |ui| {
-            let field =
-                field_row(ui, tr("Paragraph indent"), |ui, fw| widgets::number_field(ui, Id::unique("ty_indent"), Lead::None, indent, "", fw, 1.0));
-            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) = field {
-                app.set_props(ids, json!({"paragraphIndent": v.clamp(0.0, 10_000.0)}));
-            }
-        })
-        .response
-        .on_disabled_hover_text(tr("Paragraph indent applies to left-aligned text"));
-        ui.add_space(4.0);
-        for (key, label) in [("hangingPunctuation", tr("Hanging punctuation")), ("hangingList", tr("Hanging list"))] {
-            let all_on = ids.iter().all(|i| {
-                doc.node(*i).and_then(|n| n.kind.text()).is_some_and(|t| if key == "hangingList" { t.hanging_list } else { t.hanging_punctuation })
-            });
-            if widgets::checkbox(ui, all_on, label) {
-                app.set_props(ids, json!({ key: !all_on }));
-            }
-        }
-        caption(ui, tr("Vertical trim"));
-        let trim = common(doc, ids, |n| n.kind.text().map(|t| usize::from(t.leading_trim == LeadingTrim::CapHeight))).flatten();
-        let items = [(tr("Standard"), tr_noop("Standard")), ("Ag", tr_noop("Cap height to baseline"))];
-        if let Some(i) = text_seg(ui, "trim", &items, trim, w) {
-            app.set_props(ids, json!({"leadingTrim": if i == 1 { "capHeight" } else { "none" }}));
-        }
-        let resize = common(doc, ids, |n| n.kind.text().map(|t| t.auto_resize)).flatten();
-        // Auto-height text with a line limit truncates too.
-        let truncating = common(doc, ids, |n| n.kind.text().map(TextData::truncates)).flatten();
-        caption(ui, tr("Truncate text"));
-        match text_seg(
-            ui,
-            "trunc",
-            &[(tr("Off"), tr_noop("Don't truncate")), ("…", tr_noop("Truncate with an ellipsis"))],
-            truncating.map(usize::from),
-            w,
-        ) {
-            Some(1) if truncating != Some(true) => app.set_props(ids, json!({"textAutoResize": "truncate"})),
-            Some(0) if resize == Some(TextAutoResize::Height) => {
-                if truncating == Some(true) {
-                    app.set_props(ids, json!({"maxLines": 0}));
-                }
-            }
-            Some(0) if resize != Some(TextAutoResize::WidthAndHeight) => app.set_props(ids, json!({"textAutoResize": "none"})),
-            _ => {}
-        }
-        // Max lines only matter while truncating; no limit shows "Auto".
-        if truncating == Some(true) {
-            let max = common(doc, ids, |n| n.kind.text().map(|t| t.max_lines)).flatten();
-            ui.add_space(4.0);
-            let shown = max.map(f64::from).filter(|m| *m > 0.0);
-            let empty = if max.is_some() { tr("Auto") } else { tr(MIXED) };
-            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) =
-                field_row(ui, tr("Max lines"), |ui, fw| widgets::number_field_or(ui, Id::unique("ty_maxlines"), shown, empty, fw, 1.0))
-            {
-                app.run("text.maxLines", json!({"ids": ids, "lines": v.round().clamp(0.0, 10_000.0)}));
-            }
-        }
-    } else if let (2, Some(face)) = (tab, &vf) {
-        variable_axes(app, ui, ids, styles, face);
-    } else {
-        // Which features the font has (first style shown).
-        let face = uniform(styles, |s| (s.font_family.clone(), s.font_style.clone())).and_then(|(f, s)| figcraft_text::find_face(&f, &s));
-        let face_name = face.as_ref().map(|f| format!("{} {}", f.family, f.style)).unwrap_or_else(|| tr("Mixed fonts").into());
-        widgets::label(ui, &face_name, t.text_secondary);
-        egui::ScrollArea::vertical().max_height(320.0).show(ui, |ui| {
-            for (tag, label, default_on) in FEATURES {
-                let state = common(doc, ids, |n| n.kind.text().map(|t| t.features.get(tag).copied())).flatten();
-                let on = state.map(|s| s.unwrap_or(default_on));
-                let supported = face.as_ref().is_none_or(|f| f.has_feature(tag.as_bytes().try_into().unwrap_or(b"    ")));
-                if feature_row(ui, tag, tr(label), on, supported) {
-                    let want = !on.unwrap_or(false);
-                    // Back to the font's default clears the override.
-                    let v = if want == default_on { Value::Null } else { json!(want) };
-                    app.run("text.setFeatures", json!({"ids": ids, "features": {tag: v}}));
-                }
-            }
-        });
-    }
-}
-
 /// A Type settings row: a label, then `add` with the rest of the width. A label wider than its
 /// column (French, say) narrows the field rather than the row outgrowing the popover, which then
 /// widened every frame (#1029).
@@ -593,881 +203,6 @@ pub(crate) fn field_row<R>(ui: &mut Ui, label: &str, add: impl FnOnce(&mut Ui, f
     .inner
 }
 
-/// How the decoration looks: style, thickness, (underlines) offset and skip ink, and colour.
-fn decoration_details(app: &mut FigApp, ui: &mut Ui, styles: &[TextStyle], apply_style: &dyn Fn(&mut FigApp, &str, Value), underline: bool, w: f32) {
-    caption(ui, tr("Decoration style"));
-    let active = uniform(styles, |s| s.look().style as usize);
-    let items = [(tr("Solid"), tr_noop("Solid")), (tr("Dotted"), tr_noop("Dotted")), (tr("Wavy"), tr_noop("Wavy"))];
-    if let Some(i) = text_seg(ui, "deco_style", &items, active, w) {
-        apply_style(app, "textDecorationStyle", json!((["solid", "dotted", "wavy"].get(i).copied().unwrap_or("solid"))));
-    }
-    ui.add_space(4.0);
-    let mut lengths = vec![("textDecorationThickness", tr("Thickness"), uniform(styles, |s| s.look().thickness))];
-    if underline {
-        lengths.push(("textDecorationOffset", tr("Offset"), uniform(styles, |s| s.look().offset)));
-    }
-    for (key, label, value) in lengths {
-        field_row(ui, label, |ui, fw| {
-            let (shown, empty) = match value {
-                Some(DecorationLength::Pixels(v)) => (Some(v), String::new()),
-                Some(DecorationLength::Percent(p)) => (None, format!("{}%", trim_num(p))),
-                Some(DecorationLength::Auto) => (None, tr("Auto").to_string()),
-                None => (None, tr(MIXED).to_string()),
-            };
-            let auto = value == Some(DecorationLength::Auto);
-            let field_w = if auto { fw } else { fw - 36.0 };
-            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) =
-                widgets::number_field_or(ui, Id::unique(("ty_deco", key)), shown, &empty, field_w, 0.5)
-            {
-                // A thickness of 0 or less goes back to the font's.
-                let v = if key == "textDecorationThickness" && v <= 0.0 { json!("auto") } else { json!(v.clamp(-1000.0, 1000.0)) };
-                apply_style(app, key, v);
-            }
-            let tip = tr("Back to the font's value");
-            if !auto
-                && ui
-                    .add(
-                        egui::Label::new(egui::RichText::new(tr("Auto")).font(regular(11.0)).color(Tokens::get(ui.ctx()).accent_text))
-                            .sense(Sense::click()),
-                    )
-                    .on_hover_text(tip)
-                    .clicked()
-            {
-                apply_style(app, key, json!("auto"));
-            }
-        });
-    }
-    if underline {
-        let skip = uniform(styles, |s| s.look().skip_ink);
-        if widgets::checkbox(ui, skip == Some(true), tr("Skip ink")) {
-            apply_style(app, "textDecorationSkipInk", json!(skip != Some(true)));
-        }
-    }
-    let color = uniform(styles, |s| s.look().color.map(|c| format!("#{}", c.to_hex())));
-    field_row(ui, tr("Colour"), |ui, fw| {
-        let (value, hint) = match &color {
-            Some(c) => (c.clone().unwrap_or_default(), tr("Auto")),
-            None => (String::new(), tr(MIXED)),
-        };
-        if let Some(s) = widgets::text_field(ui, Id::unique("ty_deco_color"), &value, fw, hint) {
-            let s = s.trim();
-            if s.is_empty() || s.eq_ignore_ascii_case("auto") {
-                apply_style(app, "textDecorationColor", json!("auto"));
-            } else if let Some(c) = figcraft_color::Color::parse_css(s).or_else(|| figcraft_color::Color::from_hex(s)) {
-                apply_style(app, "textDecorationColor", json!(format!("#{}", c.to_hex())));
-            } else {
-                app.toast(trf("{value} isn't a colour", &[("value", &s)]));
-            }
-        }
-    });
-}
-
-/// Type settings ▸ Variable: the font's named instances, then a slider and a field per visible
-/// axis (values the style name implies show until changed; "Mixed" when the shown styles differ).
-/// The canvas previews a hovered instance and a dragged slider or field live; letting go commits
-/// one undo step, Escape cancels.
-fn variable_axes(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], styles: &[TextStyle], face: &figcraft_text::Face) {
-    let t = Tokens::get(ui.ctx());
-    let range = figcraft_engine::textedit::selected_range(&app.session);
-    widgets::label(ui, &face.family, t.text_secondary);
-    named_instances(app, ui, ids, range, styles, face);
-    // Each style's axis values; a style drawn by another face (e.g. a separate italic file) is mixed.
-    let per_style: Vec<Option<Vec<f64>>> = styles
-        .iter()
-        .map(|s| figcraft_text::find_face(&s.font_family, &s.font_style).filter(|f| f.id == face.id).map(|_| face.axis_values(s)))
-        .collect();
-    let w = ui.available_width();
-    let field_w = 52.0;
-    let label_w = 84.0;
-    let slider_w = (w - label_w - field_w - 12.0).max(40.0);
-    let cancel_id = Id::unique("ty_axis_cancelled");
-    // A cancelled gesture ends when the pointer is let go.
-    if !ui.input(|i| i.pointer.any_down()) {
-        ui.data_mut(|d| d.remove::<bool>(cancel_id));
-    }
-    for (i, axis) in face.axes.iter().enumerate().filter(|(_, a)| !a.hidden) {
-        let first = per_style.first().cloned().flatten().and_then(|v| v.get(i).copied());
-        let value = first.filter(|v0| per_style.iter().all(|vs| vs.as_ref().and_then(|v| v.get(i)).is_some_and(|v| (v - v0).abs() < 1e-9)));
-        // While a drag previews, the controls show the dragged value (the panel shows the document).
-        let live_id = Id::unique(("ty_axis_live", &axis.tag));
-        if app.ui.text_preview.is_none() {
-            ui.data_mut(|d| d.remove::<f64>(live_id));
-        }
-        let shown = ui.data(|d| d.get_temp::<f64>(live_id)).or(value).map(|v| round_axis(axis, v));
-        // (value, gesture ended)
-        let mut set: Option<(Value, bool)> = None;
-        ui.add_space(2.0);
-        ui.horizontal(|ui| {
-            ui.spacing_mut().item_spacing.x = 6.0;
-            let (lr, _) = ui.allocate_exact_size(vec2(label_w, FIELD_H), Sense::hover());
-            let name = ui.painter().layout(axis.name.clone(), regular(11.0), t.text, label_w);
-            let tip = trf(
-                "{name} ({tag}): {min} – {max}, default {default}. Double-click the slider to go back to the style's value; Escape while dragging cancels.",
-                &[
-                    ("name", &axis.name),
-                    ("tag", &axis.tag),
-                    ("min", &trim_num(axis.min)),
-                    ("max", &trim_num(axis.max)),
-                    ("default", &trim_num(axis.default)),
-                ],
-            );
-            ui.interact(lr, Id::unique(("ty_axis_label", &axis.tag)), Sense::hover()).on_hover_text(tip);
-            ui.painter().galley(pos2(lr.min.x, lr.center().y - name.size().y / 2.0), name, t.text);
-            match axis_slider(ui, Id::unique(("ty_axis_slider", &axis.tag)), axis, shown, slider_w) {
-                Some((Some(v), done)) => set = Some((json!(round_axis(axis, v)), done)),
-                Some((None, _)) => set = Some((Value::Null, true)),
-                None => {}
-            }
-            let step = if axis.max - axis.min > 20.0 { 1.0 } else { 0.1 };
-            match widgets::number_field(ui, Id::unique(("ty_axis_field", &axis.tag)), Lead::None, shown, "", field_w, step) {
-                Some(FieldEdit::Set(v)) => set = Some((json!(axis.clamp(round_axis(axis, v))), true)),
-                Some(FieldEdit::Scrub(v, done)) => set = Some((json!(axis.clamp(round_axis(axis, v))), done)),
-                None => {}
-            }
-        });
-        let Some((v, done)) = set else { continue };
-        // Escape cancels a previewing gesture (egui may end the drag on it too): the preview ends
-        // and the rest of the gesture is ignored until the pointer is let go.
-        let previewing = ui.data(|d| d.get_temp::<f64>(live_id)).is_some();
-        if previewing && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
-            ui.data_mut(|d| {
-                d.insert_temp(cancel_id, true);
-                d.remove::<f64>(live_id);
-            });
-            app.end_text_preview(ui.ctx());
-            continue;
-        }
-        if ui.data(|d| d.get_temp::<bool>(cancel_id)).unwrap_or(false) {
-            continue;
-        }
-        let params = json!({"ids": ids, "variations": {axis.tag.clone(): v}});
-        if done {
-            ui.data_mut(|d| d.remove::<f64>(live_id));
-            app.run("text.setVariations", params);
-        } else {
-            if let Some(x) = v.as_f64() {
-                ui.data_mut(|d| d.insert_temp(live_id, x));
-            }
-            app.preview_text(ui.ctx(), "text.setVariations", params);
-        }
-    }
-    if styles.iter().any(|s| !s.variations.is_empty()) {
-        ui.add_space(8.0);
-        let r = ui.add(egui::Label::new(egui::RichText::new(tr("Reset to style")).font(regular(11.0)).color(t.accent_text)).sense(Sense::click()));
-        if r.on_hover_text(tr("Back to the values the font style implies")).clicked() {
-            app.run("text.setVariations", json!({"ids": ids, "variations": {}, "replace": true}));
-        }
-    }
-}
-
-/// The variable font's named instances as a menu: the one the text shows ("Custom" once an axis
-/// moved), hovering one previews it on the canvas, clicking applies it (its custom axis values go).
-fn named_instances(
-    app: &mut FigApp,
-    ui: &mut Ui,
-    ids: &[NodeId],
-    range: Option<(NodeId, usize, usize)>,
-    styles: &[TextStyle],
-    face: &figcraft_text::Face,
-) {
-    if face.instances.is_empty() {
-        return;
-    }
-    let current = uniform(styles, |s| (s.variations.is_empty(), s.font_style.clone()));
-    let label = match &current {
-        Some((true, st)) if face.instance(st).is_some() => st.clone(),
-        Some(_) => tr("Custom").to_string(),
-        None => tr(MIXED).to_string(),
-    };
-    ui.add_space(4.0);
-    // An inline list (a menu would close the Type settings popover it opens from).
-    let open_id = Id::unique("ty_instances_open");
-    let mut open = ui.data(|d| d.get_temp::<bool>(open_id)).unwrap_or(false);
-    if widgets::dropdown(ui, &label, ui.available_width(), None).on_hover_text(tr("Named instance")).clicked() {
-        open = !open;
-    }
-    if open {
-        ui.add_space(2.0);
-        egui::ScrollArea::vertical().id_salt("ty_instances").max_height(220.0).show(ui, |ui| {
-            for inst in &face.instances {
-                let mark = if label == inst.name { "✓ " } else { "   " };
-                let (clicked, hovered) = menu_item_hover(ui, &format!("{mark}{}", inst.name));
-                let props = json!({"fontStyle": inst.name, "fontVariations": null});
-                if clicked {
-                    commit_text(app, ids, range, props);
-                    open = false;
-                } else if hovered {
-                    app.preview_text(ui.ctx(), "text.style", text_style_params(ids, range, props));
-                }
-            }
-        });
-    }
-    ui.data_mut(|d| d.insert_temp(open_id, open));
-    ui.add_space(2.0);
-}
-
-/// Axis values snap to whole numbers on wide axes (weight, width…) and tenths on narrow ones.
-fn round_axis(axis: &figcraft_text::Axis, v: f64) -> f64 {
-    if axis.max - axis.min > 20.0 { v.round() } else { (v * 10.0).round() / 10.0 }
-}
-
-/// A horizontal slider over an axis's range with a tick at its default. `value` None = mixed.
-/// Returns the new value (None = double-click: back to the style's value) and whether the
-/// gesture ended.
-fn axis_slider(ui: &mut Ui, id: Id, axis: &figcraft_text::Axis, value: Option<f64>, width: f32) -> Option<(Option<f64>, bool)> {
-    let t = Tokens::get(ui.ctx());
-    let (rect, _) = ui.allocate_exact_size(vec2(width, FIELD_H), Sense::hover());
-    let resp = ui.interact(rect, id, Sense::click_and_drag());
-    let track = Rect::from_center_size(rect.center(), vec2(width - 12.0, 4.0));
-    let span = (axis.max - axis.min).max(1e-9);
-    let x_of = |v: f64| track.min.x + ((v - axis.min) / span).clamp(0.0, 1.0) as f32 * track.width();
-    let p = ui.painter();
-    p.rect_filled(track, CornerRadius::same(2), t.border);
-    let dx = x_of(axis.default);
-    p.line_segment([pos2(dx, track.min.y - 3.0), pos2(dx, track.max.y + 3.0)], Stroke::new(1.0, t.border_strong));
-    if let Some(v) = value {
-        let x = x_of(v);
-        p.rect_filled(Rect::from_min_max(track.min, pos2(x, track.max.y)), CornerRadius::same(2), t.accent);
-        p.circle_filled(pos2(x, track.center().y), 6.0, Color32::WHITE);
-        let ring = if resp.hovered() || resp.dragged() { crate::theme::ACCENT } else { t.border_strong };
-        p.circle_stroke(pos2(x, track.center().y), 6.0, Stroke::new(1.0, ring));
-    }
-    if resp.double_clicked() {
-        return Some((None, true));
-    }
-    if (resp.dragged() || resp.clicked() || resp.drag_started())
-        && let Some(pos) = resp.interact_pointer_pos()
-    {
-        let f = f64::from(((pos.x - track.min.x) / track.width().max(1.0)).clamp(0.0, 1.0));
-        return Some((Some(axis.min + f * span), resp.drag_stopped() || resp.clicked()));
-    }
-    if resp.drag_stopped() {
-        return value.map(|v| (Some(v), true));
-    }
-    None
-}
-
-fn caption(ui: &mut Ui, s: &str) {
-    let t = Tokens::get(ui.ctx());
-    ui.add_space(6.0);
-    ui.label(egui::RichText::new(s).font(regular(10.5)).color(t.text_secondary));
-}
-
-/// A segmented control with short text labels (decoration, case, list…); `tip`s are English keys
-/// (matched below), translated where shown. Returns the clicked index.
-fn text_seg(ui: &mut Ui, salt: &str, items: &[(&str, &str)], active: Option<usize>, width: f32) -> Option<usize> {
-    let t = Tokens::get(ui.ctx());
-    let (rect, _) = ui.allocate_exact_size(vec2(width, FIELD_H), Sense::hover());
-    ui.painter().rect_filled(rect, CornerRadius::same(5), t.field);
-    let cell = width / items.len().max(1) as f32;
-    let mut out = None;
-    for (i, (label, tip)) in items.iter().enumerate() {
-        let r = Rect::from_min_size(pos2(rect.min.x + i as f32 * cell, rect.min.y), vec2(cell, FIELD_H));
-        let resp = ui.interact(r, Id::unique(("ty_seg", salt, i)), Sense::click()).on_hover_text(tr(tip));
-        crate::a11y::toggle(&resp, tr(tip), active == Some(i));
-        if active == Some(i) {
-            ui.painter().rect_filled(r.shrink(2.0), CornerRadius::same(4), t.panel);
-            ui.painter().rect_stroke(r.shrink(2.0), CornerRadius::same(4), Stroke::new(1.0, t.border), StrokeKind::Inside);
-        } else if resp.hovered() {
-            ui.painter().rect_filled(r.shrink(2.0), CornerRadius::same(4), t.hover);
-        }
-        let col = if active == Some(i) { t.text } else { t.text_secondary };
-        let galley = if *tip == "Small caps" {
-            small_caps_sample(ui, label, col)
-        } else {
-            ui.painter().layout_no_wrap((*label).to_string(), regular(11.5), col)
-        };
-        let gr = Rect::from_center_size(r.center(), galley.size());
-        let size = galley.size();
-        ui.painter().galley(gr.min, galley, col);
-        // Draw the decoration on its own sample letter.
-        match *tip {
-            "Underline" => {
-                let y = gr.max.y - 1.5;
-                ui.painter().line_segment([pos2(gr.min.x, y), pos2(gr.min.x + size.x, y)], Stroke::new(1.0, col));
-            }
-            "Strikethrough" => {
-                let y = gr.center().y + 0.5;
-                ui.painter().line_segment([pos2(gr.min.x - 1.0, y), pos2(gr.min.x + size.x + 1.0, y)], Stroke::new(1.0, col));
-            }
-            _ => {}
-        }
-        if resp.clicked() {
-            out = Some(i);
-        }
-    }
-    out
-}
-
-/// The Small caps sample: a capital, then its other letters as smaller capitals. Drawn from
-/// ordinary capitals because the small-capital letters (`ɢ`, U+0262) are missing from many UI
-/// fonts, egui's defaults among them, where they showed as a box.
-fn small_caps_sample(ui: &Ui, label: &str, col: Color32) -> Arc<egui::Galley> {
-    let mut job = egui::text::LayoutJob::default();
-    let mut chars = label.chars();
-    let first: String = chars.next().into_iter().collect();
-    let rest: String = chars.map(small_capital_to_capital).collect::<String>().to_uppercase();
-    job.append(&first, 0.0, egui::TextFormat { font_id: regular(11.5), color: col, valign: egui::Align::BOTTOM, ..Default::default() });
-    job.append(&rest, 0.0, egui::TextFormat { font_id: regular(8.5), color: col, valign: egui::Align::BOTTOM, ..Default::default() });
-    ui.painter().layout_job(job)
-}
-
-/// The capital a small-capital letter stands for (the ones a sample uses), else the letter.
-fn small_capital_to_capital(c: char) -> char {
-    match c {
-        'ɢ' => 'G',
-        'ʜ' => 'H',
-        'ɪ' => 'I',
-        'ʟ' => 'L',
-        'ɴ' => 'N',
-        'ʀ' => 'R',
-        'ʏ' => 'Y',
-        c => c,
-    }
-}
-
-/// One OpenType feature toggle; `on` None = mixed. Returns true when clicked.
-fn feature_row(ui: &mut Ui, tag: &str, label: &str, on: Option<bool>, supported: bool) -> bool {
-    let t = Tokens::get(ui.ctx());
-    let w = ui.available_width();
-    let (rect, resp) = ui.allocate_exact_size(vec2(w, 24.0), Sense::click());
-    let resp = if supported { resp } else { resp.on_hover_text(tr("Not in this font")) };
-    if resp.hovered() {
-        ui.painter().rect_filled(rect, CornerRadius::same(4), t.hover);
-    }
-    let b = Rect::from_min_size(pos2(rect.min.x + 4.0, rect.center().y - 7.0), vec2(14.0, 14.0));
-    match on {
-        Some(true) => {
-            ui.painter().rect_filled(b, CornerRadius::same(3), t.accent);
-            icons::paint(ui.painter(), b.shrink(1.5), Icon::Check, t.accent_on);
-        }
-        Some(false) => {
-            ui.painter().rect_stroke(b, CornerRadius::same(3), Stroke::new(1.0, t.border_strong), StrokeKind::Inside);
-        }
-        None => {
-            ui.painter().rect_filled(b, CornerRadius::same(3), t.accent);
-            ui.painter().line_segment([pos2(b.min.x + 3.5, b.center().y), pos2(b.max.x - 3.5, b.center().y)], Stroke::new(1.5, t.accent_on));
-        }
-    }
-    let col = if supported { t.text } else { t.text_tertiary };
-    ui.painter().text(pos2(b.max.x + 8.0, rect.center().y), Align2::LEFT_CENTER, label, regular(11.0), col);
-    ui.painter().text(pos2(rect.max.x - 6.0, rect.center().y), Align2::RIGHT_CENTER, tag, regular(10.0), t.text_tertiary);
-    resp.clicked()
-}
-
-#[derive(Clone, Copy)]
-enum LeadGlyph {
-    LineHeight,
-    LetterSpacing,
-    ParagraphSpacing,
-}
-
-/// Paint a small original glyph for a typography field's lead.
-fn paint_lead(p: &egui::Painter, r: Rect, g: LeadGlyph, col: Color32) {
-    let c = r.center();
-    let s = Stroke::new(1.0, col);
-    match g {
-        LeadGlyph::LineHeight => {
-            p.line_segment([pos2(c.x - 5.0, c.y - 6.0), pos2(c.x + 5.0, c.y - 6.0)], s);
-            p.line_segment([pos2(c.x - 5.0, c.y + 6.0), pos2(c.x + 5.0, c.y + 6.0)], s);
-            p.text(c, Align2::CENTER_CENTER, "A", regular(9.5), col);
-        }
-        LeadGlyph::LetterSpacing => {
-            p.line_segment([pos2(c.x - 6.0, c.y - 5.0), pos2(c.x - 6.0, c.y + 5.0)], s);
-            p.line_segment([pos2(c.x + 6.0, c.y - 5.0), pos2(c.x + 6.0, c.y + 5.0)], s);
-            p.text(c, Align2::CENTER_CENTER, "A", regular(9.5), col);
-        }
-        LeadGlyph::ParagraphSpacing => {
-            for dy in [-5.0, -2.5, 2.5, 5.0] {
-                p.line_segment([pos2(c.x - 5.0, c.y + dy), pos2(c.x + 5.0, c.y + dy)], s);
-            }
-        }
-    }
-}
-
-/// Line height, letter spacing or paragraph spacing: property, field id, glyph and tooltip.
-struct SpacingField {
-    field: &'static str,
-    id: Id,
-    glyph: LeadGlyph,
-    tip: &'static str,
-}
-
-enum SpacingEdit {
-    Typed(String),
-    Scrub(f64, bool),
-}
-
-impl SpacingEdit {
-    fn text(&self) -> String {
-        match self {
-            Self::Typed(text) => text.clone(),
-            Self::Scrub(value, _) => trim_num(*value),
-        }
-    }
-}
-
-/// Keep typed unit parsing and character-range targeting; only a scrub outside a text-editing
-/// session needs its own interaction. The editing session already owns its undo step.
-fn commit_spacing(app: &mut FigApp, ids: &[NodeId], range: Option<(NodeId, usize, usize)>, field: &SpacingField, edit: &SpacingEdit, value: Value) {
-    let props = json!({field.field: value});
-    match edit {
-        SpacingEdit::Scrub(_, done) if figcraft_engine::textedit::selected_range(&app.session).is_none() => {
-            live(app, field.tip, "node.set", json!({"ids": ids, "props": props}), *done);
-        }
-        _ => commit_text(app, ids, range, props),
-    }
-}
-
-/// The original text editor plus the same leading-icon scrub gesture as ordinary number fields.
-/// Auto and Mixed have no numeric starting value and remain unchanged by dragging.
-fn spacing_input(ui: &mut Ui, field: &SpacingField, value: &str, width: f32) -> Option<SpacingEdit> {
-    let rect = Rect::from_min_size(ui.cursor().min, vec2(24.0, FIELD_H));
-    let typed = lead_field(ui, field.id, field.glyph, value, width, field.tip);
-    if ui.data(|d| d.get_temp::<String>(field.id.with("editing")).is_some()) {
-        return typed.map(SpacingEdit::Typed);
-    }
-    let response = ui.interact(rect, field.id.with("lead"), Sense::drag());
-    if response.hovered() || response.dragged() {
-        ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
-    }
-    let numeric = value.trim_end_matches('%').parse::<f64>().ok();
-    match widgets::scrub(ui, field.id, &response, numeric, 1.0) {
-        Some(FieldEdit::Scrub(v, done)) => Some(SpacingEdit::Scrub(v, done)),
-        _ => typed.map(SpacingEdit::Typed),
-    }
-}
-
-/// A spacing field that whole layers can bind to a number variable (in pixels): the variable's
-/// chip when bound, else the editable field with a variable button on hover. While a text range is
-/// selected it only takes values. Returns a typed commit or a live scrub.
-fn spacing_field(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], f: &SpacingField, value: &str, width: f32, range: bool) -> Option<SpacingEdit> {
-    let rect = Rect::from_min_size(ui.cursor().min, vec2(width, FIELD_H));
-    if !range && crate::variable_ui::bound_chip(app, ui, ids, f.field, VariableType::Number, rect) {
-        ui.allocate_rect(rect, Sense::hover());
-        return None;
-    }
-    let out = spacing_input(ui, f, value, width);
-    if !range && ui.data(|d| d.get_temp::<String>(f.id.with("editing")).is_none()) {
-        crate::variable_ui::bind_button(ui, rect, ids, f.field, VariableType::Number);
-    }
-    out
-}
-
-fn lead_field(ui: &mut Ui, id: Id, glyph: LeadGlyph, value: &str, width: f32, tip: &str) -> Option<String> {
-    let t = Tokens::get(ui.ctx());
-    let (rect, _) = ui.allocate_exact_size(vec2(width, FIELD_H), Sense::hover());
-    let lead = Rect::from_min_size(rect.min, vec2(24.0, FIELD_H));
-    let text_rect = Rect::from_min_max(pos2(lead.max.x, rect.min.y), rect.max);
-    let editing_id = id.with("editing");
-    let mut editing: Option<String> = ui.data(|d| d.get_temp(editing_id));
-    let resp = ui.interact(rect, id.with("click"), Sense::click()).on_hover_text(tip);
-    crate::a11y::text(&resp, tip, value);
-    ui.painter().rect_filled(rect, CornerRadius::same(5), t.field);
-    if editing.is_some() {
-        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, crate::theme::ACCENT), StrokeKind::Inside);
-    } else if resp.hovered() {
-        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.field_hover_border), StrokeKind::Inside);
-    }
-    paint_lead(ui.painter(), lead, glyph, t.icon_secondary);
-    let started = editing.is_none() && resp.clicked();
-    if started {
-        editing = Some(if value == tr(MIXED) { String::new() } else { value.to_string() });
-        ui.memory_mut(|m| m.request_focus(id.with("te")));
-    }
-    let mut out = None;
-    match editing {
-        Some(mut text) => {
-            let mut child = ui.new_child(egui::UiBuilder::new().max_rect(text_rect.shrink2(vec2(2.0, 4.0))));
-            let r = child.add(
-                egui::TextEdit::singleline(&mut text)
-                    .id(id.with("te"))
-                    .frame(egui::Frame::NONE)
-                    .font(regular(11.0))
-                    .desired_width(text_rect.width() - 6.0),
-            );
-            crate::a11y::own_focus(&r);
-            crate::widgets::select_all_on_focus(ui, &r, &text);
-            // The Enter that started the edit (from the keyboard) doesn't end it.
-            let enter = !started && ui.input(|i| i.key_pressed(egui::Key::Enter));
-            let esc = ui.input(|i| i.key_pressed(egui::Key::Escape));
-            if esc {
-                ui.data_mut(|d| d.remove::<String>(editing_id));
-            } else if r.lost_focus() || enter {
-                out = Some(text);
-                ui.data_mut(|d| d.remove::<String>(editing_id));
-            } else {
-                ui.data_mut(|d| d.insert_temp(editing_id, text));
-            }
-        }
-        None => {
-            let col = if value == tr(MIXED) { t.text_tertiary } else { t.text };
-            ui.painter().text(pos2(text_rect.min.x + 2.0, rect.center().y), Align2::LEFT_CENTER, value, regular(11.0), col);
-        }
-    }
-    out
-}
-
-/// "Auto", "24", "150%" → the `lineHeight` value. A bare number keeps the current unit when it is
-/// a percentage, else means pixels. Empty text means Auto, except on a Mixed field (`cur` is
-/// `None`), where nothing typed is an untouched field and commits nothing.
-pub(crate) fn parse_line_height(s: &str, cur: Option<LineHeight>) -> Option<Value> {
-    let s = s.trim();
-    if s.is_empty() && cur.is_none() {
-        return None;
-    }
-    if s.is_empty() || s.eq_ignore_ascii_case("auto") {
-        return Some(json!("auto"));
-    }
-    if let Some(p) = s.strip_suffix('%') {
-        let cur_pct = match cur {
-            Some(LineHeight::Percent(p)) => Some(p),
-            _ => None,
-        };
-        return widgets::eval(p.trim(), cur_pct).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v.max(0.0)))));
-    }
-    if let Some(px) = s.strip_suffix("px") {
-        return widgets::eval(px.trim(), None).filter(|v| v.is_finite()).map(|v| json!(v.max(0.0)));
-    }
-    match cur {
-        Some(LineHeight::Percent(p)) => widgets::eval(s, Some(p)).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v.max(0.0))))),
-        Some(LineHeight::Pixels(px)) => widgets::eval(s, Some(px)).filter(|v| v.is_finite()).map(|v| json!(v.max(0.0))),
-        _ => widgets::eval(s, None).filter(|v| v.is_finite()).map(|v| json!(v.max(0.0))),
-    }
-}
-
-/// "2%", "1.5px", "-0.5" → the `letterSpacing` value. A bare number keeps the current unit
-/// (percent by default).
-pub(crate) fn parse_letter_spacing(s: &str, cur: Option<LetterSpacing>) -> Option<Value> {
-    let s = s.trim();
-    if let Some(p) = s.strip_suffix('%') {
-        return widgets::eval(p.trim(), None).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v))));
-    }
-    if let Some(p) = s.strip_suffix("px") {
-        return widgets::eval(p.trim(), None).filter(|v| v.is_finite()).map(|v| json!(v));
-    }
-    match cur {
-        Some(LetterSpacing::Pixels(px)) => widgets::eval(s, Some(px)).filter(|v| v.is_finite()).map(|v| json!(v)),
-        Some(LetterSpacing::Percent(p)) => widgets::eval(s, Some(p)).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v)))),
-        None => widgets::eval(s, None).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v)))),
-    }
-}
-
-/// A [`parse_line_height`] value as a [`LineHeight`]: "auto", "150%" or a number of pixels.
-pub(crate) fn line_height_of(v: &Value) -> Option<LineHeight> {
-    match v {
-        Value::String(s) if s.eq_ignore_ascii_case("auto") => Some(LineHeight::Auto),
-        Value::String(s) => s.strip_suffix('%')?.trim().parse().ok().filter(|p: &f64| p.is_finite()).map(LineHeight::Percent),
-        other => other.as_f64().filter(|v| v.is_finite()).map(LineHeight::Pixels),
-    }
-}
-
-/// A [`parse_letter_spacing`] value as a [`LetterSpacing`]: "2%" or a number of pixels.
-pub(crate) fn letter_spacing_of(v: &Value) -> Option<LetterSpacing> {
-    match v {
-        Value::String(s) => s.strip_suffix('%')?.trim().parse().ok().filter(|p: &f64| p.is_finite()).map(LetterSpacing::Percent),
-        other => other.as_f64().filter(|v| v.is_finite()).map(LetterSpacing::Pixels),
-    }
-}
-
-// ---- Font picker ----
-
-const RECENT_KEY: &str = "figcraft_recent_fonts";
-const ROW: f32 = 26.0;
-/// The font list's tallest (it scrolls past that).
-const LIST_HEIGHT: f32 = 380.0;
-
-/// Return the persisted list of recently used font families.
-fn recent_families(ctx: &egui::Context) -> Vec<String> {
-    ctx.data_mut(|d| d.get_persisted::<Vec<String>>(Id::unique(RECENT_KEY))).unwrap_or_default()
-}
-
-/// Remember a font family at the front of the recent list, removing an earlier
-/// case-insensitive match and keeping at most eight entries.
-fn remember_family(ctx: &egui::Context, family: &str) {
-    ctx.data_mut(|d| {
-        let v = d.get_persisted_mut_or_default::<Vec<String>>(Id::unique(RECENT_KEY));
-        v.retain(|f| !f.eq_ignore_ascii_case(family));
-        v.insert(0, family.to_string());
-        v.truncate(8);
-    });
-}
-
-enum PickRow {
-    Header(&'static str),
-    Family(String),
-}
-
-/// What the family list did this frame.
-#[derive(Default)]
-pub(crate) struct FontPick {
-    /// The family clicked, or the one Enter picked.
-    pub picked: Option<String>,
-    /// The family Up and Down are on (Enter picks it).
-    pub highlighted: Option<String>,
-    /// The family the pointer is over (the caller previews it on the canvas).
-    pub hovered: Option<String>,
-}
-
-/// The searchable family list: click a family, or step through it with Up and Down and press Enter.
-/// Hovering a family previews it on the canvas (closing without picking restores the original).
-pub(crate) fn font_picker(ui: &mut Ui, current: Option<&str>, just_opened: bool) -> FontPick {
-    let t = Tokens::get(ui.ctx());
-    let q_id = Id::unique("font_query");
-    // The row Up and Down are on, and the search it is a row of.
-    let hi_id = Id::unique("font_highlight");
-    let mut q: String = ui.data(|d| d.get_temp(q_id)).unwrap_or_default();
-    if just_opened {
-        q.clear();
-        ui.data_mut(|d| d.remove::<(String, usize)>(hi_id));
-    }
-    // Taken before the search field sees them (it would move its cursor).
-    let step = ui.input_mut(|i| {
-        i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowDown) as i64
-            - i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowUp) as i64
-    });
-    let search = ui.add(egui::TextEdit::singleline(&mut q).hint_text(tr("Search fonts")).desired_width(ui.available_width()).font(regular(11.5)));
-    crate::widgets::select_all_on_focus(ui, &search, &q);
-    if just_opened {
-        search.request_focus();
-    }
-    ui.data_mut(|d| d.insert_temp(q_id, q.clone()));
-    let ql = q.trim().to_lowercase();
-    let all = figcraft_text::family_names();
-    let matches: Vec<String> = all.iter().filter(|f| ql.is_empty() || f.to_lowercase().contains(&ql)).cloned().collect();
-    let mut rows: Vec<PickRow> = Vec::new();
-    if ql.is_empty() {
-        let recent: Vec<String> = recent_families(ui.ctx()).into_iter().filter(|f| all.iter().any(|a| a.eq_ignore_ascii_case(f))).collect();
-        if !recent.is_empty() {
-            rows.push(PickRow::Header(tr("Recent")));
-            rows.extend(recent.into_iter().map(PickRow::Family));
-            rows.push(PickRow::Header(tr("All fonts")));
-        }
-    }
-    if matches.is_empty() {
-        widgets::label(ui, tr("No fonts match"), t.text_tertiary);
-        return FontPick::default();
-    }
-    rows.extend(matches.into_iter().map(PickRow::Family));
-    let family = |i: usize| match rows.get(i) {
-        Some(PickRow::Family(f)) => Some(f.clone()),
-        _ => None,
-    };
-    // A new search starts again; the first step starts from the current family.
-    let mut hi = ui.data(|d| d.get_temp::<(String, usize)>(hi_id)).filter(|(hq, _)| *hq == q).map(|(_, i)| i);
-    let stride = ROW + ui.spacing().item_spacing.y;
-    let mut offset = None;
-    if step != 0 {
-        let next = |i: usize| if step > 0 { i.checked_add(1) } else { i.checked_sub(1) };
-        let mut from =
-            hi.or_else(|| rows.iter().rposition(|r| matches!(r, PickRow::Family(f) if current.is_some_and(|c| c.eq_ignore_ascii_case(f)))));
-        for _ in 0..step.unsigned_abs() {
-            let mut at = match from {
-                Some(i) => next(i),
-                None if step > 0 => Some(0),
-                None => rows.len().checked_sub(1),
-            };
-            // Past the headers; at either end it stays where it was.
-            while let Some(i) = at.filter(|i| *i < rows.len() && family(*i).is_none()) {
-                at = next(i);
-            }
-            if let Some(i) = at.filter(|i| family(*i).is_some()) {
-                from = Some(i);
-                hi = Some(i);
-            }
-        }
-        if let Some(i) = hi {
-            // Scrolled just enough to show it (the list is shorter than its tallest where the
-            // window has less room).
-            let (seen, height): (f32, f32) = ui.data(|d| d.get_temp(hi_id.with("view"))).unwrap_or((0.0, LIST_HEIGHT));
-            let top = i as f32 * stride;
-            offset = Some(seen.max(top + stride - height).min(top));
-        }
-    }
-    match hi {
-        Some(i) => ui.data_mut(|d| {
-            d.insert_temp(hi_id, (q.clone(), i));
-        }),
-        None => ui.data_mut(|d| d.remove::<(String, usize)>(hi_id)),
-    }
-    if search.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
-        let first = rows.iter().find_map(|r| match r {
-            PickRow::Family(f) => Some(f.clone()),
-            PickRow::Header(_) => None,
-        });
-        return FontPick { picked: hi.and_then(family).or(first), highlighted: None, hovered: None };
-    }
-    let mut budget = 4;
-    let mut picked = None;
-    let mut hovered_family = None;
-    let mut area = egui::ScrollArea::vertical().max_height(LIST_HEIGHT).auto_shrink([false, true]);
-    if let Some(y) = offset {
-        area = area.vertical_scroll_offset(y);
-    }
-    let shown = area.show_rows(ui, ROW, rows.len(), |ui, range| {
-        for (i, r) in rows.iter().enumerate().skip(range.start).take(range.len()) {
-            let w = ui.available_width();
-            let (rect, resp) = ui.allocate_exact_size(vec2(w, ROW), if matches!(r, PickRow::Family(_)) { Sense::click() } else { Sense::hover() });
-            match r {
-                PickRow::Header(h) => {
-                    ui.painter().text(pos2(rect.min.x + 8.0, rect.center().y), Align2::LEFT_CENTER, *h, semibold(10.5), t.text_secondary);
-                }
-                PickRow::Family(f) => {
-                    let hovered = resp.hovered() || hi == Some(i);
-                    if hovered {
-                        ui.painter().rect_filled(rect, CornerRadius::same(5), t.accent);
-                    }
-                    let col = if hovered { t.accent_on } else { t.text };
-                    if current.is_some_and(|c| c.eq_ignore_ascii_case(f)) {
-                        icons::paint(
-                            ui.painter(),
-                            Rect::from_center_size(pos2(rect.min.x + 10.0, rect.center().y), vec2(12.0, 12.0)),
-                            Icon::Check,
-                            col,
-                        );
-                    }
-                    let text_min = pos2(rect.min.x + 22.0, rect.min.y);
-                    match crate::font_preview::family(ui.ctx(), f, 13.0, &mut budget) {
-                        Some(tex) => {
-                            crate::font_preview::paint(
-                                ui.painter(),
-                                &tex,
-                                pos2(text_min.x, rect.center().y),
-                                rect.max.x - text_min.x - 6.0,
-                                ROW,
-                                col,
-                            );
-                        }
-                        None => {
-                            ui.painter().text(pos2(text_min.x, rect.center().y), Align2::LEFT_CENTER, f, regular(12.0), col);
-                        }
-                    }
-                    if resp.clicked() {
-                        picked = Some(f.clone());
-                    }
-                    if resp.hovered() {
-                        hovered_family = Some(f.clone());
-                    }
-                }
-            }
-        }
-    });
-    ui.data_mut(|d| d.insert_temp(hi_id.with("view"), (shown.state.clamped_offset().y, shown.inner_rect.height())));
-    FontPick { highlighted: hi.and_then(family), picked, hovered: hovered_family }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn small_caps_sample_draws_only_letters_the_ui_font_has() {
-        let ctx = egui::Context::default();
-        crate::theme::install_fonts(&ctx, false, 0);
-        let mut shown = None;
-        let input = egui::RawInput { screen_rect: Some(Rect::from_min_size(pos2(0.0, 0.0), vec2(400.0, 300.0))), ..Default::default() };
-        let mut out = ctx.run_ui(input, |ui| {
-            shown = Some(small_caps_sample(ui, "Aɢ", Color32::WHITE));
-        });
-        out.textures_delta.clear();
-        let g = shown.expect("drawn");
-        assert_eq!(g.job.text, "AG");
-        let [a, rest] = g.job.sections.as_slice() else { panic!("two sections: {:?}", g.job.sections) };
-        assert!(rest.format.font_id.size < a.format.font_id.size, "the other letters are smaller capitals");
-        ctx.fonts_mut(|f| {
-            for sec in &g.job.sections {
-                assert!(f.has_glyphs(&sec.format.font_id, &g.job.text), "UI font draws {:?}", g.job.text);
-            }
-        });
-        assert_eq!(small_capital_to_capital('ʀ'), 'R');
-        assert_eq!(small_capital_to_capital('x'), 'x');
-    }
-
-    #[test]
-    fn parses_line_height_and_letter_spacing() {
-        assert_eq!(parse_line_height("Auto", None), Some(json!("auto")));
-        assert_eq!(parse_line_height("", Some(LineHeight::Pixels(20.0))), Some(json!("auto")));
-        assert_eq!(parse_line_height("150%", Some(LineHeight::Auto)), Some(json!("150%")));
-        assert_eq!(parse_line_height("24", Some(LineHeight::Auto)), Some(json!(24.0)));
-        assert_eq!(parse_line_height("24px", Some(LineHeight::Percent(120.0))), Some(json!(24.0)));
-        assert_eq!(parse_line_height("130", Some(LineHeight::Percent(120.0))), Some(json!("130%")));
-        assert_eq!(parse_line_height("-5", Some(LineHeight::Pixels(10.0))), Some(json!(0.0)));
-        assert_eq!(parse_line_height("abc", None), None);
-        // Enter on an untouched Mixed field commits nothing; typing Auto still does.
-        assert_eq!(parse_line_height("", None), None);
-        assert_eq!(parse_line_height("  ", None), None);
-        assert_eq!(parse_letter_spacing("2%", None), Some(json!("2%")));
-        assert_eq!(parse_letter_spacing("1.5px", None), Some(json!(1.5)));
-        assert_eq!(parse_letter_spacing("-1", None), Some(json!("-1%")));
-        assert_eq!(parse_letter_spacing("3", Some(LetterSpacing::Pixels(1.0))), Some(json!(3.0)));
-        assert_eq!(parse_letter_spacing("x", Some(LetterSpacing::Percent(0.0))), None);
-    }
-
-    /// One frame of the font picker with `events`.
-    fn pick(ctx: &egui::Context, current: &str, opened: bool, events: Vec<egui::Event>) -> FontPick {
-        let mut out = FontPick::default();
-        let mut shown = ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| out = font_picker(ui, Some(current), opened));
-        shown.textures_delta.clear();
-        out
-    }
-
-    fn key(key: egui::Key) -> egui::Event {
-        egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }
-    }
-
-    #[test]
-    fn arrow_keys_step_through_the_families_and_enter_picks() {
-        // #345
-        figcraft_text::scan_system_fonts();
-        let all = figcraft_text::family_names();
-        if all.len() < 3 {
-            eprintln!("fewer than three font families; skipping");
-            return;
-        }
-        let ctx = egui::Context::default();
-        let current = all[1].as_str();
-        assert!(pick(&ctx, current, true, vec![]).highlighted.is_none());
-        // The first step starts from the current family; each press is one step.
-        let down = pick(&ctx, current, false, vec![key(egui::Key::ArrowDown)]);
-        assert_eq!(down.highlighted.as_deref(), Some(all[2].as_str()));
-        let up = pick(&ctx, current, false, vec![key(egui::Key::ArrowUp), key(egui::Key::ArrowUp)]);
-        assert_eq!(up.highlighted.as_deref(), Some(all[0].as_str()));
-        // At the top it stays; Enter picks the family it is on, not the first.
-        assert_eq!(pick(&ctx, current, false, vec![key(egui::Key::ArrowUp)]).highlighted.as_deref(), Some(all[0].as_str()));
-        pick(&ctx, current, false, vec![key(egui::Key::ArrowDown)]);
-        let enter = pick(&ctx, current, false, vec![key(egui::Key::Enter)]);
-        assert_eq!(enter.picked.as_deref(), Some(all[1].as_str()));
-    }
-
-    #[test]
-    fn axis_values_round_by_axis_width() {
-        let axis = |min: f64, max: f64| figcraft_text::Axis { tag: "test".into(), name: "Test".into(), min, default: min, max, hidden: false };
-        assert_eq!(round_axis(&axis(100.0, 900.0), 456.6), 457.0);
-        assert_eq!(round_axis(&axis(-10.0, 0.0), -4.26), -4.3);
-        assert_eq!(round_axis(&axis(0.0, 1.0), 0.04), 0.0);
-    }
-
-    #[test]
-    fn uniform_reports_mixed() {
-        let a = TextStyle::default();
-        let b = TextStyle { font_size: 30.0, ..Default::default() };
-        assert_eq!(uniform(&[a.clone(), b.clone()], |s| s.font_family.clone()), Some("Inter".to_string()));
-        assert_eq!(uniform(&[a.clone(), b], |s| s.font_size), None);
-        assert_eq!(uniform(&[], |s: &TextStyle| s.font_size), None);
-        // Ranges pick only the spans they touch.
-        let mut doc = Document::new("t");
-        let page = doc.first_page().unwrap();
-        let id = doc.alloc_id();
-        let mut td = TextData::new("Hello world");
-        td.restyle(6, 11, |s| s.font_size = 40.0);
-        doc.insert(Node::new(id, NodeKind::Text(td), "t", 10.0, 10.0), page, None).unwrap();
-        assert_eq!(target_styles(&doc, &[id], Some((id, 0, 5))).len(), 1);
-        assert_eq!(target_styles(&doc, &[id], Some((id, 4, 8))).len(), 2);
-        assert_eq!(target_styles(&doc, &[id], Some((id, 3, 3))).len(), 2);
-        assert_eq!(target_styles(&doc, &[id], None).len(), 2);
-    }
-}
-
 #[cfg(test)]
 mod variable_tests {
     use egui::{Event, Modifiers, PointerButton, Pos2, RawInput};
diff --git a/crates/ui-egui/src/panels/typography/axes.rs b/crates/ui-egui/src/panels/typography/axes.rs
new file mode 100644
index 00000000..6c042dec
--- /dev/null
+++ b/crates/ui-egui/src/panels/typography/axes.rs
@@ -0,0 +1,187 @@
+use super::fields::menu_item_hover;
+use super::*;
+
+/// Type settings ▸ Variable: the font's named instances, then a slider and a field per visible
+/// axis (values the style name implies show until changed; "Mixed" when the shown styles differ).
+/// The canvas previews a hovered instance and a dragged slider or field live; letting go commits
+/// one undo step, Escape cancels.
+pub(super) fn variable_axes(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], styles: &[TextStyle], face: &figcraft_text::Face) {
+    let t = Tokens::get(ui.ctx());
+    let range = figcraft_engine::textedit::selected_range(&app.session);
+    widgets::label(ui, &face.family, t.text_secondary);
+    named_instances(app, ui, ids, range, styles, face);
+    // Each style's axis values; a style drawn by another face (e.g. a separate italic file) is mixed.
+    let per_style: Vec<Option<Vec<f64>>> = styles
+        .iter()
+        .map(|s| figcraft_text::find_face(&s.font_family, &s.font_style).filter(|f| f.id == face.id).map(|_| face.axis_values(s)))
+        .collect();
+    let w = ui.available_width();
+    let field_w = 52.0;
+    let label_w = 84.0;
+    let slider_w = (w - label_w - field_w - 12.0).max(40.0);
+    let cancel_id = Id::unique("ty_axis_cancelled");
+    // A cancelled gesture ends when the pointer is let go.
+    if !ui.input(|i| i.pointer.any_down()) {
+        ui.data_mut(|d| d.remove::<bool>(cancel_id));
+    }
+    for (i, axis) in face.axes.iter().enumerate().filter(|(_, a)| !a.hidden) {
+        let first = per_style.first().cloned().flatten().and_then(|v| v.get(i).copied());
+        let value = first.filter(|v0| per_style.iter().all(|vs| vs.as_ref().and_then(|v| v.get(i)).is_some_and(|v| (v - v0).abs() < 1e-9)));
+        // While a drag previews, the controls show the dragged value (the panel shows the document).
+        let live_id = Id::unique(("ty_axis_live", &axis.tag));
+        if app.ui.text_preview.is_none() {
+            ui.data_mut(|d| d.remove::<f64>(live_id));
+        }
+        let shown = ui.data(|d| d.get_temp::<f64>(live_id)).or(value).map(|v| round_axis(axis, v));
+        // (value, gesture ended)
+        let mut set: Option<(Value, bool)> = None;
+        ui.add_space(2.0);
+        ui.horizontal(|ui| {
+            ui.spacing_mut().item_spacing.x = 6.0;
+            let (lr, _) = ui.allocate_exact_size(vec2(label_w, FIELD_H), Sense::hover());
+            let name = ui.painter().layout(axis.name.clone(), regular(11.0), t.text, label_w);
+            let tip = trf(
+                "{name} ({tag}): {min} – {max}, default {default}. Double-click the slider to go back to the style's value; Escape while dragging cancels.",
+                &[
+                    ("name", &axis.name),
+                    ("tag", &axis.tag),
+                    ("min", &trim_num(axis.min)),
+                    ("max", &trim_num(axis.max)),
+                    ("default", &trim_num(axis.default)),
+                ],
+            );
+            ui.interact(lr, Id::unique(("ty_axis_label", &axis.tag)), Sense::hover()).on_hover_text(tip);
+            ui.painter().galley(pos2(lr.min.x, lr.center().y - name.size().y / 2.0), name, t.text);
+            match axis_slider(ui, Id::unique(("ty_axis_slider", &axis.tag)), axis, shown, slider_w) {
+                Some((Some(v), done)) => set = Some((json!(round_axis(axis, v)), done)),
+                Some((None, _)) => set = Some((Value::Null, true)),
+                None => {}
+            }
+            let step = if axis.max - axis.min > 20.0 { 1.0 } else { 0.1 };
+            match widgets::number_field(ui, Id::unique(("ty_axis_field", &axis.tag)), Lead::None, shown, "", field_w, step) {
+                Some(FieldEdit::Set(v)) => set = Some((json!(axis.clamp(round_axis(axis, v))), true)),
+                Some(FieldEdit::Scrub(v, done)) => set = Some((json!(axis.clamp(round_axis(axis, v))), done)),
+                None => {}
+            }
+        });
+        let Some((v, done)) = set else { continue };
+        // Escape cancels a previewing gesture (egui may end the drag on it too): the preview ends
+        // and the rest of the gesture is ignored until the pointer is let go.
+        let previewing = ui.data(|d| d.get_temp::<f64>(live_id)).is_some();
+        if previewing && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
+            ui.data_mut(|d| {
+                d.insert_temp(cancel_id, true);
+                d.remove::<f64>(live_id);
+            });
+            app.end_text_preview(ui.ctx());
+            continue;
+        }
+        if ui.data(|d| d.get_temp::<bool>(cancel_id)).unwrap_or(false) {
+            continue;
+        }
+        let params = json!({"ids": ids, "variations": {axis.tag.clone(): v}});
+        if done {
+            ui.data_mut(|d| d.remove::<f64>(live_id));
+            app.run("text.setVariations", params);
+        } else {
+            if let Some(x) = v.as_f64() {
+                ui.data_mut(|d| d.insert_temp(live_id, x));
+            }
+            app.preview_text(ui.ctx(), "text.setVariations", params);
+        }
+    }
+    if styles.iter().any(|s| !s.variations.is_empty()) {
+        ui.add_space(8.0);
+        let r = ui.add(egui::Label::new(egui::RichText::new(tr("Reset to style")).font(regular(11.0)).color(t.accent_text)).sense(Sense::click()));
+        if r.on_hover_text(tr("Back to the values the font style implies")).clicked() {
+            app.run("text.setVariations", json!({"ids": ids, "variations": {}, "replace": true}));
+        }
+    }
+}
+
+/// The variable font's named instances as a menu: the one the text shows ("Custom" once an axis
+/// moved), hovering one previews it on the canvas, clicking applies it (its custom axis values go).
+fn named_instances(
+    app: &mut FigApp,
+    ui: &mut Ui,
+    ids: &[NodeId],
+    range: Option<(NodeId, usize, usize)>,
+    styles: &[TextStyle],
+    face: &figcraft_text::Face,
+) {
+    if face.instances.is_empty() {
+        return;
+    }
+    let current = uniform(styles, |s| (s.variations.is_empty(), s.font_style.clone()));
+    let label = match &current {
+        Some((true, st)) if face.instance(st).is_some() => st.clone(),
+        Some(_) => tr("Custom").to_string(),
+        None => tr(MIXED).to_string(),
+    };
+    ui.add_space(4.0);
+    // An inline list (a menu would close the Type settings popover it opens from).
+    let open_id = Id::unique("ty_instances_open");
+    let mut open = ui.data(|d| d.get_temp::<bool>(open_id)).unwrap_or(false);
+    if widgets::dropdown(ui, &label, ui.available_width(), None).on_hover_text(tr("Named instance")).clicked() {
+        open = !open;
+    }
+    if open {
+        ui.add_space(2.0);
+        egui::ScrollArea::vertical().id_salt("ty_instances").max_height(220.0).show(ui, |ui| {
+            for inst in &face.instances {
+                let mark = if label == inst.name { "✓ " } else { "   " };
+                let (clicked, hovered) = menu_item_hover(ui, &format!("{mark}{}", inst.name));
+                let props = json!({"fontStyle": inst.name, "fontVariations": null});
+                if clicked {
+                    commit_text(app, ids, range, props);
+                    open = false;
+                } else if hovered {
+                    app.preview_text(ui.ctx(), "text.style", text_style_params(ids, range, props));
+                }
+            }
+        });
+    }
+    ui.data_mut(|d| d.insert_temp(open_id, open));
+    ui.add_space(2.0);
+}
+
+/// Axis values snap to whole numbers on wide axes (weight, width…) and tenths on narrow ones.
+pub(super) fn round_axis(axis: &figcraft_text::Axis, v: f64) -> f64 {
+    if axis.max - axis.min > 20.0 { v.round() } else { (v * 10.0).round() / 10.0 }
+}
+
+/// A horizontal slider over an axis's range with a tick at its default. `value` None = mixed.
+/// Returns the new value (None = double-click: back to the style's value) and whether the
+/// gesture ended.
+fn axis_slider(ui: &mut Ui, id: Id, axis: &figcraft_text::Axis, value: Option<f64>, width: f32) -> Option<(Option<f64>, bool)> {
+    let t = Tokens::get(ui.ctx());
+    let (rect, _) = ui.allocate_exact_size(vec2(width, FIELD_H), Sense::hover());
+    let resp = ui.interact(rect, id, Sense::click_and_drag());
+    let track = Rect::from_center_size(rect.center(), vec2(width - 12.0, 4.0));
+    let span = (axis.max - axis.min).max(1e-9);
+    let x_of = |v: f64| track.min.x + ((v - axis.min) / span).clamp(0.0, 1.0) as f32 * track.width();
+    let p = ui.painter();
+    p.rect_filled(track, CornerRadius::same(2), t.border);
+    let dx = x_of(axis.default);
+    p.line_segment([pos2(dx, track.min.y - 3.0), pos2(dx, track.max.y + 3.0)], Stroke::new(1.0, t.border_strong));
+    if let Some(v) = value {
+        let x = x_of(v);
+        p.rect_filled(Rect::from_min_max(track.min, pos2(x, track.max.y)), CornerRadius::same(2), t.accent);
+        p.circle_filled(pos2(x, track.center().y), 6.0, Color32::WHITE);
+        let ring = if resp.hovered() || resp.dragged() { crate::theme::ACCENT } else { t.border_strong };
+        p.circle_stroke(pos2(x, track.center().y), 6.0, Stroke::new(1.0, ring));
+    }
+    if resp.double_clicked() {
+        return Some((None, true));
+    }
+    if (resp.dragged() || resp.clicked() || resp.drag_started())
+        && let Some(pos) = resp.interact_pointer_pos()
+    {
+        let f = f64::from(((pos.x - track.min.x) / track.width().max(1.0)).clamp(0.0, 1.0));
+        return Some((Some(axis.min + f * span), resp.drag_stopped() || resp.clicked()));
+    }
+    if resp.drag_stopped() {
+        return value.map(|v| (Some(v), true));
+    }
+    None
+}
diff --git a/crates/ui-egui/src/panels/typography/fields.rs b/crates/ui-egui/src/panels/typography/fields.rs
new file mode 100644
index 00000000..fb5d7ad8
--- /dev/null
+++ b/crates/ui-egui/src/panels/typography/fields.rs
@@ -0,0 +1,481 @@
+use super::axes::variable_axes;
+use super::glyphs::{LeadGlyph, caption, feature_row, text_seg};
+use super::picker::{font_picker, remember_family};
+use super::spacing::{SpacingField, commit_spacing, parse_letter_spacing, parse_line_height, spacing_field, spacing_input};
+use super::*;
+
+/// The font rows: family, style and size, line height and letter spacing.
+pub(super) fn font_rows(
+    app: &mut FigApp,
+    ui: &mut Ui,
+    ids: &[NodeId],
+    styles: &[TextStyle],
+    editing: bool,
+    apply_style: &dyn Fn(&mut FigApp, &str, Value),
+) {
+    let t = Tokens::get(ui.ctx());
+    let range = figcraft_engine::textedit::selected_range(&app.session);
+
+    // Font family.
+    let family = uniform(styles, |s| s.font_family.clone());
+    let fstyle = uniform(styles, |s| s.font_style.clone());
+    row(ui, 32.0, |ui| {
+        let w = ui.available_width();
+        let resp = font_dropdown(app, ui, ids, "fontFamily", family.as_deref(), w, editing);
+        menu_popup(&resp).width(w.max(240.0)).close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside).show(|ui| {
+            if !editing && apply_variable_item(ui, ids, "fontFamily", &resp) {
+                return;
+            }
+            let pick = font_picker(ui, family.as_deref(), resp.clicked());
+            if let Some(f) = pick.picked {
+                remember_family(ui.ctx(), &f);
+                apply_style(app, "fontFamily", json!(f));
+                ui.close();
+            } else if let Some(h) = pick.hovered.or(pick.highlighted) {
+                // The canvas shows the hovered family (or the one the arrow keys are on);
+                // closing without picking ends the preview.
+                app.preview_text(ui.ctx(), "text.style", text_style_params(ids, range, json!({"fontFamily": h})));
+            }
+        });
+    });
+
+    // Style + size.
+    let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
+    row(ui, 32.0, |ui| {
+        let resp = font_dropdown(app, ui, ids, "fontStyle", fstyle.as_deref(), half, editing);
+        let fam = family.clone();
+        menu_popup(&resp).width(200.0).show(|ui| {
+            if !editing && apply_variable_item(ui, ids, "fontStyle", &resp) {
+                return;
+            }
+            match &fam {
+                Some(fam) => {
+                    let list = figcraft_text::family_styles(fam);
+                    if list.is_empty() {
+                        widgets::label(ui, tr("Font not installed"), t.text_tertiary);
+                    }
+                    egui::ScrollArea::vertical().max_height(320.0).show(ui, |ui| {
+                        for s in list {
+                            let mark = if fstyle.as_deref() == Some(s.as_str()) { "✓ " } else { "   " };
+                            let (clicked, hovered) = menu_item_hover(ui, &format!("{mark}{s}"));
+                            if clicked {
+                                apply_style(app, "fontStyle", json!(s));
+                                ui.close();
+                            } else if hovered {
+                                // The canvas shows the style (a variable font's named instance too).
+                                app.preview_text(ui.ctx(), "text.style", text_style_params(ids, range, json!({"fontStyle": s})));
+                            }
+                        }
+                    });
+                }
+                None => widgets::label(ui, tr("Pick one font family first"), t.text_tertiary),
+            }
+        });
+        let size = uniform(styles, |s| s.font_size);
+        ui.spacing_mut().item_spacing.x = 0.0;
+        // The whole layer's size can follow a variable; a selected range just takes a value.
+        let e = if editing {
+            widgets::number_field(ui, Id::unique("ty_size"), Lead::None, size, "", half - 20.0, 1.0)
+        } else {
+            crate::variable_ui::number_field(app, ui, ids, "fontSize", Id::unique("ty_size"), Lead::None, size, "", half - 20.0)
+        };
+        match e {
+            Some(FieldEdit::Set(v)) => apply_style(app, "fontSize", json!(v.clamp(1.0, 5000.0))),
+            // The text editing session already groups undo; just apply.
+            Some(FieldEdit::Scrub(v, _)) if editing => apply_style(app, "fontSize", json!(v.clamp(1.0, 5000.0))),
+            Some(FieldEdit::Scrub(v, done)) => {
+                live(app, "Font size", "node.set", json!({"ids": ids, "props": {"fontSize": v.clamp(1.0, 5000.0)}}), done)
+            }
+            None => {}
+        }
+        let more = icons::button(ui, Icon::Chevron, 20.0, false, tr("Font size"));
+        menu_popup(&more).width(90.0).show(|ui| {
+            egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
+                for v in SIZES {
+                    let mark = if size == Some(v) { "✓ " } else { "   " };
+                    if menu_item(ui, &format!("{mark}{}", trim_num(v)), "") {
+                        apply_style(app, "fontSize", json!(v));
+                        ui.close();
+                    }
+                }
+            });
+        });
+    });
+
+    // Line height + letter spacing.
+    row(ui, 32.0, |ui| {
+        let lh = uniform(styles, |s| s.line_height);
+        let lh_label = lh.map(|l| l.label()).unwrap_or_else(|| tr(MIXED).into());
+        let field = SpacingField { field: "lineHeight", id: Id::unique("ty_lh"), glyph: LeadGlyph::LineHeight, tip: tr("Line height") };
+        if let Some(edit) = spacing_field(app, ui, ids, &field, &lh_label, half, editing)
+            && let Some(v) = parse_line_height(&edit.text(), lh)
+        {
+            commit_spacing(app, ids, range, &field, &edit, v);
+        }
+        let ls = uniform(styles, |s| s.letter_spacing);
+        let ls_label = ls.map(|l| l.label()).unwrap_or_else(|| tr(MIXED).into());
+        let field = SpacingField { field: "letterSpacing", id: Id::unique("ty_ls"), glyph: LeadGlyph::LetterSpacing, tip: tr("Letter spacing") };
+        if let Some(edit) = spacing_field(app, ui, ids, &field, &ls_label, half, editing)
+            && let Some(v) = parse_letter_spacing(&edit.text(), ls)
+        {
+            commit_spacing(app, ids, range, &field, &edit, v);
+        }
+    });
+}
+
+/// Paragraph spacing, resizing, alignment and the Type settings popover.
+pub(super) fn paragraph_rows(
+    app: &mut FigApp,
+    ui: &mut Ui,
+    doc: &Document,
+    ids: &[NodeId],
+    styles: &[TextStyle],
+    apply_style: &dyn Fn(&mut FigApp, &str, Value),
+) {
+    let half = (ui.available_width() - PAD * 2.0 - 8.0) / 2.0;
+    // Paragraph spacing + resizing.
+    let ps = common(doc, ids, |n| n.kind.text().map(|t| t.paragraph_spacing.to_bits())).flatten().map(f64::from_bits);
+    let resize = common(doc, ids, |n| n.kind.text().map(|t| t.auto_resize)).flatten();
+    row(ui, 32.0, |ui| {
+        let ps_label = ps.map(trim_num).unwrap_or_else(|| tr(MIXED).into());
+        let field =
+            SpacingField { field: "paragraphSpacing", id: Id::unique("ty_ps"), glyph: LeadGlyph::ParagraphSpacing, tip: tr("Paragraph spacing") };
+        if let Some(edit) = spacing_input(ui, &field, &ps_label, half)
+            && let Some(v) = widgets::eval(&edit.text(), ps)
+        {
+            commit_spacing(app, ids, None, &field, &edit, json!(v.clamp(0.0, 10_000.0)));
+        }
+        let items =
+            [(Icon::Hug, tr("Auto width")), (Icon::LayoutV, tr("Auto height")), (Icon::Fixed, tr("Fixed size")), (Icon::Dots, tr("Truncate text"))];
+        let active = resize.map(|r| match r {
+            TextAutoResize::WidthAndHeight => 0,
+            TextAutoResize::Height => 1,
+            TextAutoResize::None => 2,
+            TextAutoResize::Truncate => 3,
+        });
+        if let Some(i) = widgets::segmented(ui, &items, active, (half / 4.0).floor()) {
+            let v = ["widthAndHeight", "height", "none", "truncate"].get(i).copied().unwrap_or("none");
+            app.set_props(ids, json!({"textAutoResize": v}));
+        }
+    });
+
+    // Alignment + Type settings.
+    let align = common(doc, ids, |n| n.kind.text().map(|t| (t.align_h, t.align_v))).flatten();
+    row(ui, 32.0, |ui| {
+        let items = [
+            (Icon::TextAlignLeft, tr("Align left")),
+            (Icon::TextAlignCenter, tr("Align center")),
+            (Icon::TextAlignRight, tr("Align right")),
+            (Icon::TextAlignJustify, tr("Justify")),
+        ];
+        let active = align.map(|(h, _)| match h {
+            TextAlignH::Left => 0,
+            TextAlignH::Center => 1,
+            TextAlignH::Right => 2,
+            TextAlignH::Justified => 3,
+        });
+        if let Some(i) = widgets::segmented(ui, &items, active, 24.0) {
+            let v = ["left", "center", "right", "justified"].get(i).copied().unwrap_or("left");
+            app.set_props(ids, json!({"textAlign": v}));
+        }
+        let items = [(Icon::TextTop, tr("Align top")), (Icon::TextMiddle, tr("Align middle")), (Icon::TextBottom, tr("Align bottom"))];
+        let active = align.map(|(_, v)| match v {
+            TextAlignV::Top => 0,
+            TextAlignV::Middle => 1,
+            TextAlignV::Bottom => 2,
+        });
+        if let Some(i) = widgets::segmented(ui, &items, active, 24.0) {
+            let v = ["top", "middle", "bottom"].get(i).copied().unwrap_or("top");
+            app.set_props(ids, json!({"textAlignVertical": v}));
+        }
+        let open_id = Id::unique("ty_settings_open");
+        let open = egui::Popup::is_id_open(ui.ctx(), open_id);
+        let more = icons::button(ui, Icon::Dots, 24.0, open, tr("Type settings"));
+        egui::Popup::from_toggle_button_response(&more)
+            .id(open_id)
+            .width(264.0)
+            .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
+            .show(|ui| type_settings(app, ui, doc, ids, styles, apply_style));
+    });
+}
+
+/// A menu item that also reports the pointer being over it: (clicked, hovered).
+pub(super) fn menu_item_hover(ui: &mut Ui, label: &str) -> (bool, bool) {
+    let r = crate::right::menu_row(ui, label, "", 0.0, |_, _, _| {});
+    (r.clicked(), r.hovered())
+}
+
+/// The font family or font style dropdown for `field`, `width` wide, showing `shown` (Mixed when
+/// None). While whole layers are edited and `field` is bound to the same variable on every one of
+/// `ids`, the variable's chip is drawn in place of the dropdown (a click picks another variable,
+/// its detach button unbinds it), and the returned response opens no menu.
+fn font_dropdown(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId], field: &str, shown: Option<&str>, width: f32, editing: bool) -> egui::Response {
+    if !editing && app.session.doc().ok().and_then(|d| crate::variable_ui::bound_name(d, ids, field)).is_some() {
+        let (rect, resp) = ui.allocate_exact_size(vec2(width, FIELD_H), Sense::hover());
+        crate::variable_ui::bound_chip(app, ui, ids, field, VariableType::String, rect);
+        return resp;
+    }
+    widgets::dropdown(ui, shown.unwrap_or(tr(MIXED)), width, None)
+}
+
+/// Apply variable at the top of the font family or font style menu opened from `anchor`: a click
+/// opens the variable picker on string variables for `field` of `ids` and closes the menu (true).
+fn apply_variable_item(ui: &mut Ui, ids: &[NodeId], field: &str, anchor: &egui::Response) -> bool {
+    let picked = menu_item(ui, tr("Apply variable"), "");
+    if picked {
+        crate::variable_ui::open(ui, ids, field, VariableType::String, anchor.rect.left_bottom());
+        ui.close();
+    } else {
+        ui.separator();
+    }
+    picked
+}
+
+/// The variable font the shown styles use (one family, one variable face), if any.
+fn variable_face(styles: &[TextStyle]) -> Option<Arc<figcraft_text::Face>> {
+    let family = uniform(styles, |s| s.font_family.clone())?;
+    let face = figcraft_text::find_face(&family, &styles.first()?.font_style)?;
+    (face.is_variable() && face.family.eq_ignore_ascii_case(&family)).then_some(face)
+}
+
+/// The Type settings popover: Basics (decoration, case, list, indent, truncation), Details
+/// (OpenType features) and, for variable fonts, Variable (axis sliders).
+fn type_settings(
+    app: &mut FigApp,
+    ui: &mut Ui,
+    doc: &Document,
+    ids: &[NodeId],
+    styles: &[TextStyle],
+    apply_style: &dyn Fn(&mut FigApp, &str, Value),
+) {
+    let t = Tokens::get(ui.ctx());
+    let tab_id = Id::unique("ty_settings_tab");
+    let vf = variable_face(styles);
+    let tabs = &TABS[..if vf.is_some() { 3 } else { 2 }];
+    let mut tab: usize = ui.data(|d| d.get_temp(tab_id)).filter(|i| *i < tabs.len()).unwrap_or(0);
+    ui.horizontal(|ui| {
+        for (i, l) in tabs.iter().enumerate() {
+            let col = if tab == i { t.text } else { t.text_secondary };
+            let r = ui.add(egui::Label::new(egui::RichText::new(tr(l)).font(semibold(11.5)).color(col)).sense(Sense::click()));
+            if r.clicked() {
+                tab = i;
+            }
+        }
+    });
+    ui.data_mut(|d| d.insert_temp(tab_id, tab));
+    ui.add_space(4.0);
+    let w = ui.available_width();
+    if tab == 0 {
+        let deco = uniform(styles, |s| s.decoration);
+        caption(ui, tr("Decoration"));
+        let active = deco.map(|d| match d {
+            TextDecoration::None => 0,
+            TextDecoration::Underline => 1,
+            TextDecoration::Strikethrough => 2,
+        });
+        let items = [("—", tr_noop("None")), ("U", tr_noop("Underline")), ("S", tr_noop("Strikethrough"))];
+        if let Some(i) = text_seg(ui, "deco", &items, active, w) {
+            apply_style(app, "textDecoration", json!((["none", "underline", "strikethrough"].get(i).copied().unwrap_or("none"))));
+        }
+        if let Some(d @ (TextDecoration::Underline | TextDecoration::Strikethrough)) = deco {
+            decoration_details(app, ui, styles, apply_style, d == TextDecoration::Underline, w);
+        }
+        caption(ui, tr("Letter case"));
+        let case = uniform(styles, |s| s.case);
+        let active = case.map(|c| match c {
+            TextCase::Original => 0,
+            TextCase::Upper => 1,
+            TextCase::Lower => 2,
+            TextCase::Title => 3,
+            TextCase::SmallCaps => 4,
+        });
+        let items = [
+            ("—", tr_noop("As typed")),
+            ("AG", tr_noop("Uppercase")),
+            ("ag", tr_noop("Lowercase")),
+            ("Ag", tr_noop("Title case")),
+            ("Aɢ", tr_noop("Small caps")),
+        ];
+        if let Some(i) = text_seg(ui, "case", &items, active, w) {
+            apply_style(app, "textCase", json!((["original", "upper", "lower", "title", "smallCaps"].get(i).copied().unwrap_or("original"))));
+        }
+        caption(ui, tr("List style"));
+        // While editing: the selected paragraphs' list.
+        let range = figcraft_engine::textedit::selected_range(&app.session);
+        let list = common(doc, ids, |n| {
+            n.kind.text().and_then(|t| {
+                let (a, b) = range.filter(|r| r.0 == n.id).map_or((0, t.char_count()), |(_, a, b)| (a, b));
+                t.common_para_list(a, b).map(|p| p.list)
+            })
+        })
+        .flatten();
+        let active = list.map(|l| match l {
+            ListStyle::None => 0,
+            ListStyle::Bulleted => 1,
+            ListStyle::Numbered => 2,
+        });
+        let items = [("—", tr_noop("No list")), ("•", tr_noop("Bulleted list")), ("1.", tr_noop("Numbered list"))];
+        if let Some(i) = text_seg(ui, "list", &items, active, w) {
+            app.run("text.listStyle", json!({"ids": ids, "style": (["none", "bulleted", "numbered"].get(i).copied().unwrap_or("none"))}));
+        }
+        ui.add_space(6.0);
+        let spacing = common(doc, ids, |n| n.kind.text().map(|t| t.list_spacing.to_bits())).flatten().map(f64::from_bits);
+        field_row(ui, tr("List spacing"), |ui, fw| {
+            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) =
+                widgets::number_field(ui, Id::unique("ty_list_spacing"), Lead::None, spacing, "", fw, 1.0)
+            {
+                app.set_props(ids, json!({"listSpacing": v.clamp(0.0, 10_000.0)}));
+            }
+        });
+        ui.add_space(4.0);
+        let indent = common(doc, ids, |n| n.kind.text().map(|t| t.paragraph_indent.to_bits())).flatten().map(f64::from_bits);
+        // Indent applies to start-aligned text only; elsewhere the field stays visible but off.
+        let start_aligned =
+            common(doc, ids, |n| n.kind.text().map(|t| t.align_h != TextAlignH::Center && t.align_h != TextAlignH::Justified)).flatten();
+        ui.add_enabled_ui(start_aligned != Some(false), |ui| {
+            let field =
+                field_row(ui, tr("Paragraph indent"), |ui, fw| widgets::number_field(ui, Id::unique("ty_indent"), Lead::None, indent, "", fw, 1.0));
+            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) = field {
+                app.set_props(ids, json!({"paragraphIndent": v.clamp(0.0, 10_000.0)}));
+            }
+        })
+        .response
+        .on_disabled_hover_text(tr("Paragraph indent applies to left-aligned text"));
+        ui.add_space(4.0);
+        for (key, label) in [("hangingPunctuation", tr("Hanging punctuation")), ("hangingList", tr("Hanging list"))] {
+            let all_on = ids.iter().all(|i| {
+                doc.node(*i).and_then(|n| n.kind.text()).is_some_and(|t| if key == "hangingList" { t.hanging_list } else { t.hanging_punctuation })
+            });
+            if widgets::checkbox(ui, all_on, label) {
+                app.set_props(ids, json!({ key: !all_on }));
+            }
+        }
+        caption(ui, tr("Vertical trim"));
+        let trim = common(doc, ids, |n| n.kind.text().map(|t| usize::from(t.leading_trim == LeadingTrim::CapHeight))).flatten();
+        let items = [(tr("Standard"), tr_noop("Standard")), ("Ag", tr_noop("Cap height to baseline"))];
+        if let Some(i) = text_seg(ui, "trim", &items, trim, w) {
+            app.set_props(ids, json!({"leadingTrim": if i == 1 { "capHeight" } else { "none" }}));
+        }
+        let resize = common(doc, ids, |n| n.kind.text().map(|t| t.auto_resize)).flatten();
+        // Auto-height text with a line limit truncates too.
+        let truncating = common(doc, ids, |n| n.kind.text().map(TextData::truncates)).flatten();
+        caption(ui, tr("Truncate text"));
+        match text_seg(
+            ui,
+            "trunc",
+            &[(tr("Off"), tr_noop("Don't truncate")), ("…", tr_noop("Truncate with an ellipsis"))],
+            truncating.map(usize::from),
+            w,
+        ) {
+            Some(1) if truncating != Some(true) => app.set_props(ids, json!({"textAutoResize": "truncate"})),
+            Some(0) if resize == Some(TextAutoResize::Height) => {
+                if truncating == Some(true) {
+                    app.set_props(ids, json!({"maxLines": 0}));
+                }
+            }
+            Some(0) if resize != Some(TextAutoResize::WidthAndHeight) => app.set_props(ids, json!({"textAutoResize": "none"})),
+            _ => {}
+        }
+        // Max lines only matter while truncating; no limit shows "Auto".
+        if truncating == Some(true) {
+            let max = common(doc, ids, |n| n.kind.text().map(|t| t.max_lines)).flatten();
+            ui.add_space(4.0);
+            let shown = max.map(f64::from).filter(|m| *m > 0.0);
+            let empty = if max.is_some() { tr("Auto") } else { tr(MIXED) };
+            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) =
+                field_row(ui, tr("Max lines"), |ui, fw| widgets::number_field_or(ui, Id::unique("ty_maxlines"), shown, empty, fw, 1.0))
+            {
+                app.run("text.maxLines", json!({"ids": ids, "lines": v.round().clamp(0.0, 10_000.0)}));
+            }
+        }
+    } else if let (2, Some(face)) = (tab, &vf) {
+        variable_axes(app, ui, ids, styles, face);
+    } else {
+        // Which features the font has (first style shown).
+        let face = uniform(styles, |s| (s.font_family.clone(), s.font_style.clone())).and_then(|(f, s)| figcraft_text::find_face(&f, &s));
+        let face_name = face.as_ref().map(|f| format!("{} {}", f.family, f.style)).unwrap_or_else(|| tr("Mixed fonts").into());
+        widgets::label(ui, &face_name, t.text_secondary);
+        egui::ScrollArea::vertical().max_height(320.0).show(ui, |ui| {
+            for (tag, label, default_on) in FEATURES {
+                let state = common(doc, ids, |n| n.kind.text().map(|t| t.features.get(tag).copied())).flatten();
+                let on = state.map(|s| s.unwrap_or(default_on));
+                let supported = face.as_ref().is_none_or(|f| f.has_feature(tag.as_bytes().try_into().unwrap_or(b"    ")));
+                if feature_row(ui, tag, tr(label), on, supported) {
+                    let want = !on.unwrap_or(false);
+                    // Back to the font's default clears the override.
+                    let v = if want == default_on { Value::Null } else { json!(want) };
+                    app.run("text.setFeatures", json!({"ids": ids, "features": {tag: v}}));
+                }
+            }
+        });
+    }
+}
+
+/// How the decoration looks: style, thickness, (underlines) offset and skip ink, and colour.
+fn decoration_details(app: &mut FigApp, ui: &mut Ui, styles: &[TextStyle], apply_style: &dyn Fn(&mut FigApp, &str, Value), underline: bool, w: f32) {
+    caption(ui, tr("Decoration style"));
+    let active = uniform(styles, |s| s.look().style as usize);
+    let items = [(tr("Solid"), tr_noop("Solid")), (tr("Dotted"), tr_noop("Dotted")), (tr("Wavy"), tr_noop("Wavy"))];
+    if let Some(i) = text_seg(ui, "deco_style", &items, active, w) {
+        apply_style(app, "textDecorationStyle", json!((["solid", "dotted", "wavy"].get(i).copied().unwrap_or("solid"))));
+    }
+    ui.add_space(4.0);
+    let mut lengths = vec![("textDecorationThickness", tr("Thickness"), uniform(styles, |s| s.look().thickness))];
+    if underline {
+        lengths.push(("textDecorationOffset", tr("Offset"), uniform(styles, |s| s.look().offset)));
+    }
+    for (key, label, value) in lengths {
+        field_row(ui, label, |ui, fw| {
+            let (shown, empty) = match value {
+                Some(DecorationLength::Pixels(v)) => (Some(v), String::new()),
+                Some(DecorationLength::Percent(p)) => (None, format!("{}%", trim_num(p))),
+                Some(DecorationLength::Auto) => (None, tr("Auto").to_string()),
+                None => (None, tr(MIXED).to_string()),
+            };
+            let auto = value == Some(DecorationLength::Auto);
+            let field_w = if auto { fw } else { fw - 36.0 };
+            if let Some(FieldEdit::Set(v) | FieldEdit::Scrub(v, true)) =
+                widgets::number_field_or(ui, Id::unique(("ty_deco", key)), shown, &empty, field_w, 0.5)
+            {
+                // A thickness of 0 or less goes back to the font's.
+                let v = if key == "textDecorationThickness" && v <= 0.0 { json!("auto") } else { json!(v.clamp(-1000.0, 1000.0)) };
+                apply_style(app, key, v);
+            }
+            let tip = tr("Back to the font's value");
+            if !auto
+                && ui
+                    .add(
+                        egui::Label::new(egui::RichText::new(tr("Auto")).font(regular(11.0)).color(Tokens::get(ui.ctx()).accent_text))
+                            .sense(Sense::click()),
+                    )
+                    .on_hover_text(tip)
+                    .clicked()
+            {
+                apply_style(app, key, json!("auto"));
+            }
+        });
+    }
+    if underline {
+        let skip = uniform(styles, |s| s.look().skip_ink);
+        if widgets::checkbox(ui, skip == Some(true), tr("Skip ink")) {
+            apply_style(app, "textDecorationSkipInk", json!(skip != Some(true)));
+        }
+    }
+    let color = uniform(styles, |s| s.look().color.map(|c| format!("#{}", c.to_hex())));
+    field_row(ui, tr("Colour"), |ui, fw| {
+        let (value, hint) = match &color {
+            Some(c) => (c.clone().unwrap_or_default(), tr("Auto")),
+            None => (String::new(), tr(MIXED)),
+        };
+        if let Some(s) = widgets::text_field(ui, Id::unique("ty_deco_color"), &value, fw, hint) {
+            let s = s.trim();
+            if s.is_empty() || s.eq_ignore_ascii_case("auto") {
+                apply_style(app, "textDecorationColor", json!("auto"));
+            } else if let Some(c) = figcraft_color::Color::parse_css(s).or_else(|| figcraft_color::Color::from_hex(s)) {
+                apply_style(app, "textDecorationColor", json!(format!("#{}", c.to_hex())));
+            } else {
+                app.toast(trf("{value} isn't a colour", &[("value", &s)]));
+            }
+        }
+    });
+}
diff --git a/crates/ui-egui/src/panels/typography/glyphs.rs b/crates/ui-egui/src/panels/typography/glyphs.rs
new file mode 100644
index 00000000..13e0f6ef
--- /dev/null
+++ b/crates/ui-egui/src/panels/typography/glyphs.rs
@@ -0,0 +1,257 @@
+#[cfg(test)]
+use super::axes::round_axis;
+#[cfg(test)]
+use super::picker::{FontPick, font_picker};
+#[cfg(test)]
+use super::spacing::{parse_letter_spacing, parse_line_height};
+use super::*;
+
+pub(super) fn caption(ui: &mut Ui, s: &str) {
+    let t = Tokens::get(ui.ctx());
+    ui.add_space(6.0);
+    ui.label(egui::RichText::new(s).font(regular(10.5)).color(t.text_secondary));
+}
+
+/// A segmented control with short text labels (decoration, case, list…); `tip`s are English keys
+/// (matched below), translated where shown. Returns the clicked index.
+pub(super) fn text_seg(ui: &mut Ui, salt: &str, items: &[(&str, &str)], active: Option<usize>, width: f32) -> Option<usize> {
+    let t = Tokens::get(ui.ctx());
+    let (rect, _) = ui.allocate_exact_size(vec2(width, FIELD_H), Sense::hover());
+    ui.painter().rect_filled(rect, CornerRadius::same(5), t.field);
+    let cell = width / items.len().max(1) as f32;
+    let mut out = None;
+    for (i, (label, tip)) in items.iter().enumerate() {
+        let r = Rect::from_min_size(pos2(rect.min.x + i as f32 * cell, rect.min.y), vec2(cell, FIELD_H));
+        let resp = ui.interact(r, Id::unique(("ty_seg", salt, i)), Sense::click()).on_hover_text(tr(tip));
+        crate::a11y::toggle(&resp, tr(tip), active == Some(i));
+        if active == Some(i) {
+            ui.painter().rect_filled(r.shrink(2.0), CornerRadius::same(4), t.panel);
+            ui.painter().rect_stroke(r.shrink(2.0), CornerRadius::same(4), Stroke::new(1.0, t.border), StrokeKind::Inside);
+        } else if resp.hovered() {
+            ui.painter().rect_filled(r.shrink(2.0), CornerRadius::same(4), t.hover);
+        }
+        let col = if active == Some(i) { t.text } else { t.text_secondary };
+        let galley = if *tip == "Small caps" {
+            small_caps_sample(ui, label, col)
+        } else {
+            ui.painter().layout_no_wrap((*label).to_string(), regular(11.5), col)
+        };
+        let gr = Rect::from_center_size(r.center(), galley.size());
+        let size = galley.size();
+        ui.painter().galley(gr.min, galley, col);
+        // Draw the decoration on its own sample letter.
+        match *tip {
+            "Underline" => {
+                let y = gr.max.y - 1.5;
+                ui.painter().line_segment([pos2(gr.min.x, y), pos2(gr.min.x + size.x, y)], Stroke::new(1.0, col));
+            }
+            "Strikethrough" => {
+                let y = gr.center().y + 0.5;
+                ui.painter().line_segment([pos2(gr.min.x - 1.0, y), pos2(gr.min.x + size.x + 1.0, y)], Stroke::new(1.0, col));
+            }
+            _ => {}
+        }
+        if resp.clicked() {
+            out = Some(i);
+        }
+    }
+    out
+}
+
+/// The Small caps sample: a capital, then its other letters as smaller capitals. Drawn from
+/// ordinary capitals because the small-capital letters (`ɢ`, U+0262) are missing from many UI
+/// fonts, egui's defaults among them, where they showed as a box.
+fn small_caps_sample(ui: &Ui, label: &str, col: Color32) -> Arc<egui::Galley> {
+    let mut job = egui::text::LayoutJob::default();
+    let mut chars = label.chars();
+    let first: String = chars.next().into_iter().collect();
+    let rest: String = chars.map(small_capital_to_capital).collect::<String>().to_uppercase();
+    job.append(&first, 0.0, egui::TextFormat { font_id: regular(11.5), color: col, valign: egui::Align::BOTTOM, ..Default::default() });
+    job.append(&rest, 0.0, egui::TextFormat { font_id: regular(8.5), color: col, valign: egui::Align::BOTTOM, ..Default::default() });
+    ui.painter().layout_job(job)
+}
+
+/// The capital a small-capital letter stands for (the ones a sample uses), else the letter.
+fn small_capital_to_capital(c: char) -> char {
+    match c {
+        'ɢ' => 'G',
+        'ʜ' => 'H',
+        'ɪ' => 'I',
+        'ʟ' => 'L',
+        'ɴ' => 'N',
+        'ʀ' => 'R',
+        'ʏ' => 'Y',
+        c => c,
+    }
+}
+
+/// One OpenType feature toggle; `on` None = mixed. Returns true when clicked.
+pub(super) fn feature_row(ui: &mut Ui, tag: &str, label: &str, on: Option<bool>, supported: bool) -> bool {
+    let t = Tokens::get(ui.ctx());
+    let w = ui.available_width();
+    let (rect, resp) = ui.allocate_exact_size(vec2(w, 24.0), Sense::click());
+    let resp = if supported { resp } else { resp.on_hover_text(tr("Not in this font")) };
+    if resp.hovered() {
+        ui.painter().rect_filled(rect, CornerRadius::same(4), t.hover);
+    }
+    let b = Rect::from_min_size(pos2(rect.min.x + 4.0, rect.center().y - 7.0), vec2(14.0, 14.0));
+    match on {
+        Some(true) => {
+            ui.painter().rect_filled(b, CornerRadius::same(3), t.accent);
+            icons::paint(ui.painter(), b.shrink(1.5), Icon::Check, t.accent_on);
+        }
+        Some(false) => {
+            ui.painter().rect_stroke(b, CornerRadius::same(3), Stroke::new(1.0, t.border_strong), StrokeKind::Inside);
+        }
+        None => {
+            ui.painter().rect_filled(b, CornerRadius::same(3), t.accent);
+            ui.painter().line_segment([pos2(b.min.x + 3.5, b.center().y), pos2(b.max.x - 3.5, b.center().y)], Stroke::new(1.5, t.accent_on));
+        }
+    }
+    let col = if supported { t.text } else { t.text_tertiary };
+    ui.painter().text(pos2(b.max.x + 8.0, rect.center().y), Align2::LEFT_CENTER, label, regular(11.0), col);
+    ui.painter().text(pos2(rect.max.x - 6.0, rect.center().y), Align2::RIGHT_CENTER, tag, regular(10.0), t.text_tertiary);
+    resp.clicked()
+}
+
+#[derive(Clone, Copy)]
+pub(super) enum LeadGlyph {
+    LineHeight,
+    LetterSpacing,
+    ParagraphSpacing,
+}
+
+/// Paint a small original glyph for a typography field's lead.
+pub(super) fn paint_lead(p: &egui::Painter, r: Rect, g: LeadGlyph, col: Color32) {
+    let c = r.center();
+    let s = Stroke::new(1.0, col);
+    match g {
+        LeadGlyph::LineHeight => {
+            p.line_segment([pos2(c.x - 5.0, c.y - 6.0), pos2(c.x + 5.0, c.y - 6.0)], s);
+            p.line_segment([pos2(c.x - 5.0, c.y + 6.0), pos2(c.x + 5.0, c.y + 6.0)], s);
+            p.text(c, Align2::CENTER_CENTER, "A", regular(9.5), col);
+        }
+        LeadGlyph::LetterSpacing => {
+            p.line_segment([pos2(c.x - 6.0, c.y - 5.0), pos2(c.x - 6.0, c.y + 5.0)], s);
+            p.line_segment([pos2(c.x + 6.0, c.y - 5.0), pos2(c.x + 6.0, c.y + 5.0)], s);
+            p.text(c, Align2::CENTER_CENTER, "A", regular(9.5), col);
+        }
+        LeadGlyph::ParagraphSpacing => {
+            for dy in [-5.0, -2.5, 2.5, 5.0] {
+                p.line_segment([pos2(c.x - 5.0, c.y + dy), pos2(c.x + 5.0, c.y + dy)], s);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn small_caps_sample_draws_only_letters_the_ui_font_has() {
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx, false, 0);
+        let mut shown = None;
+        let input = egui::RawInput { screen_rect: Some(Rect::from_min_size(pos2(0.0, 0.0), vec2(400.0, 300.0))), ..Default::default() };
+        let mut out = ctx.run_ui(input, |ui| {
+            shown = Some(small_caps_sample(ui, "Aɢ", Color32::WHITE));
+        });
+        out.textures_delta.clear();
+        let g = shown.expect("drawn");
+        assert_eq!(g.job.text, "AG");
+        let [a, rest] = g.job.sections.as_slice() else { panic!("two sections: {:?}", g.job.sections) };
+        assert!(rest.format.font_id.size < a.format.font_id.size, "the other letters are smaller capitals");
+        ctx.fonts_mut(|f| {
+            for sec in &g.job.sections {
+                assert!(f.has_glyphs(&sec.format.font_id, &g.job.text), "UI font draws {:?}", g.job.text);
+            }
+        });
+        assert_eq!(small_capital_to_capital('ʀ'), 'R');
+        assert_eq!(small_capital_to_capital('x'), 'x');
+    }
+
+    #[test]
+    fn parses_line_height_and_letter_spacing() {
+        assert_eq!(parse_line_height("Auto", None), Some(json!("auto")));
+        assert_eq!(parse_line_height("", Some(LineHeight::Pixels(20.0))), Some(json!("auto")));
+        assert_eq!(parse_line_height("150%", Some(LineHeight::Auto)), Some(json!("150%")));
+        assert_eq!(parse_line_height("24", Some(LineHeight::Auto)), Some(json!(24.0)));
+        assert_eq!(parse_line_height("24px", Some(LineHeight::Percent(120.0))), Some(json!(24.0)));
+        assert_eq!(parse_line_height("130", Some(LineHeight::Percent(120.0))), Some(json!("130%")));
+        assert_eq!(parse_line_height("-5", Some(LineHeight::Pixels(10.0))), Some(json!(0.0)));
+        assert_eq!(parse_line_height("abc", None), None);
+        // Enter on an untouched Mixed field commits nothing; typing Auto still does.
+        assert_eq!(parse_line_height("", None), None);
+        assert_eq!(parse_line_height("  ", None), None);
+        assert_eq!(parse_letter_spacing("2%", None), Some(json!("2%")));
+        assert_eq!(parse_letter_spacing("1.5px", None), Some(json!(1.5)));
+        assert_eq!(parse_letter_spacing("-1", None), Some(json!("-1%")));
+        assert_eq!(parse_letter_spacing("3", Some(LetterSpacing::Pixels(1.0))), Some(json!(3.0)));
+        assert_eq!(parse_letter_spacing("x", Some(LetterSpacing::Percent(0.0))), None);
+    }
+
+    /// One frame of the font picker with `events`.
+    fn pick(ctx: &egui::Context, current: &str, opened: bool, events: Vec<egui::Event>) -> FontPick {
+        let mut out = FontPick::default();
+        let mut shown = ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| out = font_picker(ui, Some(current), opened));
+        shown.textures_delta.clear();
+        out
+    }
+
+    fn key(key: egui::Key) -> egui::Event {
+        egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }
+    }
+
+    #[test]
+    fn arrow_keys_step_through_the_families_and_enter_picks() {
+        // #345
+        figcraft_text::scan_system_fonts();
+        let all = figcraft_text::family_names();
+        if all.len() < 3 {
+            eprintln!("fewer than three font families; skipping");
+            return;
+        }
+        let ctx = egui::Context::default();
+        let current = all[1].as_str();
+        assert!(pick(&ctx, current, true, vec![]).highlighted.is_none());
+        // The first step starts from the current family; each press is one step.
+        let down = pick(&ctx, current, false, vec![key(egui::Key::ArrowDown)]);
+        assert_eq!(down.highlighted.as_deref(), Some(all[2].as_str()));
+        let up = pick(&ctx, current, false, vec![key(egui::Key::ArrowUp), key(egui::Key::ArrowUp)]);
+        assert_eq!(up.highlighted.as_deref(), Some(all[0].as_str()));
+        // At the top it stays; Enter picks the family it is on, not the first.
+        assert_eq!(pick(&ctx, current, false, vec![key(egui::Key::ArrowUp)]).highlighted.as_deref(), Some(all[0].as_str()));
+        pick(&ctx, current, false, vec![key(egui::Key::ArrowDown)]);
+        let enter = pick(&ctx, current, false, vec![key(egui::Key::Enter)]);
+        assert_eq!(enter.picked.as_deref(), Some(all[1].as_str()));
+    }
+
+    #[test]
+    fn axis_values_round_by_axis_width() {
+        let axis = |min: f64, max: f64| figcraft_text::Axis { tag: "test".into(), name: "Test".into(), min, default: min, max, hidden: false };
+        assert_eq!(round_axis(&axis(100.0, 900.0), 456.6), 457.0);
+        assert_eq!(round_axis(&axis(-10.0, 0.0), -4.26), -4.3);
+        assert_eq!(round_axis(&axis(0.0, 1.0), 0.04), 0.0);
+    }
+
+    #[test]
+    fn uniform_reports_mixed() {
+        let a = TextStyle::default();
+        let b = TextStyle { font_size: 30.0, ..Default::default() };
+        assert_eq!(uniform(&[a.clone(), b.clone()], |s| s.font_family.clone()), Some("Inter".to_string()));
+        assert_eq!(uniform(&[a.clone(), b], |s| s.font_size), None);
+        assert_eq!(uniform(&[], |s: &TextStyle| s.font_size), None);
+        // Ranges pick only the spans they touch.
+        let mut doc = Document::new("t");
+        let page = doc.first_page().unwrap();
+        let id = doc.alloc_id();
+        let mut td = TextData::new("Hello world");
+        td.restyle(6, 11, |s| s.font_size = 40.0);
+        doc.insert(Node::new(id, NodeKind::Text(td), "t", 10.0, 10.0), page, None).unwrap();
+        assert_eq!(target_styles(&doc, &[id], Some((id, 0, 5))).len(), 1);
+        assert_eq!(target_styles(&doc, &[id], Some((id, 4, 8))).len(), 2);
+        assert_eq!(target_styles(&doc, &[id], Some((id, 3, 3))).len(), 2);
+        assert_eq!(target_styles(&doc, &[id], None).len(), 2);
+    }
+}
diff --git a/crates/ui-egui/src/panels/typography/picker.rs b/crates/ui-egui/src/panels/typography/picker.rs
new file mode 100644
index 00000000..824fc43e
--- /dev/null
+++ b/crates/ui-egui/src/panels/typography/picker.rs
@@ -0,0 +1,189 @@
+use super::*;
+
+// ---- Font picker ----
+
+const RECENT_KEY: &str = "figcraft_recent_fonts";
+
+const ROW: f32 = 26.0;
+
+/// The font list's tallest (it scrolls past that).
+const LIST_HEIGHT: f32 = 380.0;
+
+/// Return the persisted list of recently used font families.
+fn recent_families(ctx: &egui::Context) -> Vec<String> {
+    ctx.data_mut(|d| d.get_persisted::<Vec<String>>(Id::unique(RECENT_KEY))).unwrap_or_default()
+}
+
+/// Remember a font family at the front of the recent list, removing an earlier
+/// case-insensitive match and keeping at most eight entries.
+pub(super) fn remember_family(ctx: &egui::Context, family: &str) {
+    ctx.data_mut(|d| {
+        let v = d.get_persisted_mut_or_default::<Vec<String>>(Id::unique(RECENT_KEY));
+        v.retain(|f| !f.eq_ignore_ascii_case(family));
+        v.insert(0, family.to_string());
+        v.truncate(8);
+    });
+}
+
+enum PickRow {
+    Header(&'static str),
+    Family(String),
+}
+
+/// What the family list did this frame.
+#[derive(Default)]
+pub(crate) struct FontPick {
+    /// The family clicked, or the one Enter picked.
+    pub picked: Option<String>,
+    /// The family Up and Down are on (Enter picks it).
+    pub highlighted: Option<String>,
+    /// The family the pointer is over (the caller previews it on the canvas).
+    pub hovered: Option<String>,
+}
+
+/// The searchable family list: click a family, or step through it with Up and Down and press Enter.
+/// Hovering a family previews it on the canvas (closing without picking restores the original).
+pub(crate) fn font_picker(ui: &mut Ui, current: Option<&str>, just_opened: bool) -> FontPick {
+    let t = Tokens::get(ui.ctx());
+    let q_id = Id::unique("font_query");
+    // The row Up and Down are on, and the search it is a row of.
+    let hi_id = Id::unique("font_highlight");
+    let mut q: String = ui.data(|d| d.get_temp(q_id)).unwrap_or_default();
+    if just_opened {
+        q.clear();
+        ui.data_mut(|d| d.remove::<(String, usize)>(hi_id));
+    }
+    // Taken before the search field sees them (it would move its cursor).
+    let step = ui.input_mut(|i| {
+        i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowDown) as i64
+            - i.count_and_consume_key(egui::Modifiers::NONE, egui::Key::ArrowUp) as i64
+    });
+    let search = ui.add(egui::TextEdit::singleline(&mut q).hint_text(tr("Search fonts")).desired_width(ui.available_width()).font(regular(11.5)));
+    crate::widgets::select_all_on_focus(ui, &search, &q);
+    if just_opened {
+        search.request_focus();
+    }
+    ui.data_mut(|d| d.insert_temp(q_id, q.clone()));
+    let ql = q.trim().to_lowercase();
+    let all = figcraft_text::family_names();
+    let matches: Vec<String> = all.iter().filter(|f| ql.is_empty() || f.to_lowercase().contains(&ql)).cloned().collect();
+    let mut rows: Vec<PickRow> = Vec::new();
+    if ql.is_empty() {
+        let recent: Vec<String> = recent_families(ui.ctx()).into_iter().filter(|f| all.iter().any(|a| a.eq_ignore_ascii_case(f))).collect();
+        if !recent.is_empty() {
+            rows.push(PickRow::Header(tr("Recent")));
+            rows.extend(recent.into_iter().map(PickRow::Family));
+            rows.push(PickRow::Header(tr("All fonts")));
+        }
+    }
+    if matches.is_empty() {
+        widgets::label(ui, tr("No fonts match"), t.text_tertiary);
+        return FontPick::default();
+    }
+    rows.extend(matches.into_iter().map(PickRow::Family));
+    let family = |i: usize| match rows.get(i) {
+        Some(PickRow::Family(f)) => Some(f.clone()),
+        _ => None,
+    };
+    // A new search starts again; the first step starts from the current family.
+    let mut hi = ui.data(|d| d.get_temp::<(String, usize)>(hi_id)).filter(|(hq, _)| *hq == q).map(|(_, i)| i);
+    let stride = ROW + ui.spacing().item_spacing.y;
+    let mut offset = None;
+    if step != 0 {
+        let next = |i: usize| if step > 0 { i.checked_add(1) } else { i.checked_sub(1) };
+        let mut from =
+            hi.or_else(|| rows.iter().rposition(|r| matches!(r, PickRow::Family(f) if current.is_some_and(|c| c.eq_ignore_ascii_case(f)))));
+        for _ in 0..step.unsigned_abs() {
+            let mut at = match from {
+                Some(i) => next(i),
+                None if step > 0 => Some(0),
+                None => rows.len().checked_sub(1),
+            };
+            // Past the headers; at either end it stays where it was.
+            while let Some(i) = at.filter(|i| *i < rows.len() && family(*i).is_none()) {
+                at = next(i);
+            }
+            if let Some(i) = at.filter(|i| family(*i).is_some()) {
+                from = Some(i);
+                hi = Some(i);
+            }
+        }
+        if let Some(i) = hi {
+            // Scrolled just enough to show it (the list is shorter than its tallest where the
+            // window has less room).
+            let (seen, height): (f32, f32) = ui.data(|d| d.get_temp(hi_id.with("view"))).unwrap_or((0.0, LIST_HEIGHT));
+            let top = i as f32 * stride;
+            offset = Some(seen.max(top + stride - height).min(top));
+        }
+    }
+    match hi {
+        Some(i) => ui.data_mut(|d| {
+            d.insert_temp(hi_id, (q.clone(), i));
+        }),
+        None => ui.data_mut(|d| d.remove::<(String, usize)>(hi_id)),
+    }
+    if search.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+        let first = rows.iter().find_map(|r| match r {
+            PickRow::Family(f) => Some(f.clone()),
+            PickRow::Header(_) => None,
+        });
+        return FontPick { picked: hi.and_then(family).or(first), highlighted: None, hovered: None };
+    }
+    let mut budget = 4;
+    let mut picked = None;
+    let mut hovered_family = None;
+    let mut area = egui::ScrollArea::vertical().max_height(LIST_HEIGHT).auto_shrink([false, true]);
+    if let Some(y) = offset {
+        area = area.vertical_scroll_offset(y);
+    }
+    let shown = area.show_rows(ui, ROW, rows.len(), |ui, range| {
+        for (i, r) in rows.iter().enumerate().skip(range.start).take(range.len()) {
+            let w = ui.available_width();
+            let (rect, resp) = ui.allocate_exact_size(vec2(w, ROW), if matches!(r, PickRow::Family(_)) { Sense::click() } else { Sense::hover() });
+            match r {
+                PickRow::Header(h) => {
+                    ui.painter().text(pos2(rect.min.x + 8.0, rect.center().y), Align2::LEFT_CENTER, *h, semibold(10.5), t.text_secondary);
+                }
+                PickRow::Family(f) => {
+                    let hovered = resp.hovered() || hi == Some(i);
+                    if hovered {
+                        ui.painter().rect_filled(rect, CornerRadius::same(5), t.accent);
+                    }
+                    let col = if hovered { t.accent_on } else { t.text };
+                    if current.is_some_and(|c| c.eq_ignore_ascii_case(f)) {
+                        icons::paint(
+                            ui.painter(),
+                            Rect::from_center_size(pos2(rect.min.x + 10.0, rect.center().y), vec2(12.0, 12.0)),
+                            Icon::Check,
+                            col,
+                        );
+                    }
+                    let text_min = pos2(rect.min.x + 22.0, rect.min.y);
+                    match crate::font_preview::family(ui.ctx(), f, 13.0, &mut budget) {
+                        Some(tex) => {
+                            crate::font_preview::paint(
+                                ui.painter(),
+                                &tex,
+                                pos2(text_min.x, rect.center().y),
+                                rect.max.x - text_min.x - 6.0,
+                                ROW,
+                                col,
+                            );
+                        }
+                        None => {
+                            ui.painter().text(pos2(text_min.x, rect.center().y), Align2::LEFT_CENTER, f, regular(12.0), col);
+                        }
+                    }
+                    if resp.clicked() {
+                        picked = Some(f.clone());
+                    }
+                    if resp.hovered() {
+                        hovered_family = Some(f.clone());
+                    }
+                }
+            }
+        }
+    });
+    ui.data_mut(|d| d.insert_temp(hi_id.with("view"), (shown.state.clamped_offset().y, shown.inner_rect.height())));
+    FontPick { highlighted: hi.and_then(family), picked, hovered: hovered_family }
+}
diff --git a/crates/ui-egui/src/panels/typography/spacing.rs b/crates/ui-egui/src/panels/typography/spacing.rs
new file mode 100644
index 00000000..971a3c0f
--- /dev/null
+++ b/crates/ui-egui/src/panels/typography/spacing.rs
@@ -0,0 +1,202 @@
+use super::glyphs::{LeadGlyph, paint_lead};
+use super::*;
+
+/// Line height, letter spacing or paragraph spacing: property, field id, glyph and tooltip.
+pub(super) struct SpacingField {
+    pub(super) field: &'static str,
+    pub(super) id: Id,
+    pub(super) glyph: LeadGlyph,
+    pub(super) tip: &'static str,
+}
+
+pub(super) enum SpacingEdit {
+    Typed(String),
+    Scrub(f64, bool),
+}
+
+impl SpacingEdit {
+    pub(super) fn text(&self) -> String {
+        match self {
+            Self::Typed(text) => text.clone(),
+            Self::Scrub(value, _) => trim_num(*value),
+        }
+    }
+}
+
+/// Keep typed unit parsing and character-range targeting; only a scrub outside a text-editing
+/// session needs its own interaction. The editing session already owns its undo step.
+pub(super) fn commit_spacing(
+    app: &mut FigApp,
+    ids: &[NodeId],
+    range: Option<(NodeId, usize, usize)>,
+    field: &SpacingField,
+    edit: &SpacingEdit,
+    value: Value,
+) {
+    let props = json!({field.field: value});
+    match edit {
+        SpacingEdit::Scrub(_, done) if figcraft_engine::textedit::selected_range(&app.session).is_none() => {
+            live(app, field.tip, "node.set", json!({"ids": ids, "props": props}), *done);
+        }
+        _ => commit_text(app, ids, range, props),
+    }
+}
+
+/// The original text editor plus the same leading-icon scrub gesture as ordinary number fields.
+/// Auto and Mixed have no numeric starting value and remain unchanged by dragging.
+pub(super) fn spacing_input(ui: &mut Ui, field: &SpacingField, value: &str, width: f32) -> Option<SpacingEdit> {
+    let rect = Rect::from_min_size(ui.cursor().min, vec2(24.0, FIELD_H));
+    let typed = lead_field(ui, field.id, field.glyph, value, width, field.tip);
+    if ui.data(|d| d.get_temp::<String>(field.id.with("editing")).is_some()) {
+        return typed.map(SpacingEdit::Typed);
+    }
+    let response = ui.interact(rect, field.id.with("lead"), Sense::drag());
+    if response.hovered() || response.dragged() {
+        ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
+    }
+    let numeric = value.trim_end_matches('%').parse::<f64>().ok();
+    match widgets::scrub(ui, field.id, &response, numeric, 1.0) {
+        Some(FieldEdit::Scrub(v, done)) => Some(SpacingEdit::Scrub(v, done)),
+        _ => typed.map(SpacingEdit::Typed),
+    }
+}
+
+/// A spacing field that whole layers can bind to a number variable (in pixels): the variable's
+/// chip when bound, else the editable field with a variable button on hover. While a text range is
+/// selected it only takes values. Returns a typed commit or a live scrub.
+pub(super) fn spacing_field(
+    app: &mut FigApp,
+    ui: &mut Ui,
+    ids: &[NodeId],
+    f: &SpacingField,
+    value: &str,
+    width: f32,
+    range: bool,
+) -> Option<SpacingEdit> {
+    let rect = Rect::from_min_size(ui.cursor().min, vec2(width, FIELD_H));
+    if !range && crate::variable_ui::bound_chip(app, ui, ids, f.field, VariableType::Number, rect) {
+        ui.allocate_rect(rect, Sense::hover());
+        return None;
+    }
+    let out = spacing_input(ui, f, value, width);
+    if !range && ui.data(|d| d.get_temp::<String>(f.id.with("editing")).is_none()) {
+        crate::variable_ui::bind_button(ui, rect, ids, f.field, VariableType::Number);
+    }
+    out
+}
+
+fn lead_field(ui: &mut Ui, id: Id, glyph: LeadGlyph, value: &str, width: f32, tip: &str) -> Option<String> {
+    let t = Tokens::get(ui.ctx());
+    let (rect, _) = ui.allocate_exact_size(vec2(width, FIELD_H), Sense::hover());
+    let lead = Rect::from_min_size(rect.min, vec2(24.0, FIELD_H));
+    let text_rect = Rect::from_min_max(pos2(lead.max.x, rect.min.y), rect.max);
+    let editing_id = id.with("editing");
+    let mut editing: Option<String> = ui.data(|d| d.get_temp(editing_id));
+    let resp = ui.interact(rect, id.with("click"), Sense::click()).on_hover_text(tip);
+    crate::a11y::text(&resp, tip, value);
+    ui.painter().rect_filled(rect, CornerRadius::same(5), t.field);
+    if editing.is_some() {
+        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, crate::theme::ACCENT), StrokeKind::Inside);
+    } else if resp.hovered() {
+        ui.painter().rect_stroke(rect, CornerRadius::same(5), Stroke::new(1.0, t.field_hover_border), StrokeKind::Inside);
+    }
+    paint_lead(ui.painter(), lead, glyph, t.icon_secondary);
+    let started = editing.is_none() && resp.clicked();
+    if started {
+        editing = Some(if value == tr(MIXED) { String::new() } else { value.to_string() });
+        ui.memory_mut(|m| m.request_focus(id.with("te")));
+    }
+    let mut out = None;
+    match editing {
+        Some(mut text) => {
+            let mut child = ui.new_child(egui::UiBuilder::new().max_rect(text_rect.shrink2(vec2(2.0, 4.0))));
+            let r = child.add(
+                egui::TextEdit::singleline(&mut text)
+                    .id(id.with("te"))
+                    .frame(egui::Frame::NONE)
+                    .font(regular(11.0))
+                    .desired_width(text_rect.width() - 6.0),
+            );
+            crate::a11y::own_focus(&r);
+            crate::widgets::select_all_on_focus(ui, &r, &text);
+            // The Enter that started the edit (from the keyboard) doesn't end it.
+            let enter = !started && ui.input(|i| i.key_pressed(egui::Key::Enter));
+            let esc = ui.input(|i| i.key_pressed(egui::Key::Escape));
+            if esc {
+                ui.data_mut(|d| d.remove::<String>(editing_id));
+            } else if r.lost_focus() || enter {
+                out = Some(text);
+                ui.data_mut(|d| d.remove::<String>(editing_id));
+            } else {
+                ui.data_mut(|d| d.insert_temp(editing_id, text));
+            }
+        }
+        None => {
+            let col = if value == tr(MIXED) { t.text_tertiary } else { t.text };
+            ui.painter().text(pos2(text_rect.min.x + 2.0, rect.center().y), Align2::LEFT_CENTER, value, regular(11.0), col);
+        }
+    }
+    out
+}
+
+/// "Auto", "24", "150%" → the `lineHeight` value. A bare number keeps the current unit when it is
+/// a percentage, else means pixels. Empty text means Auto, except on a Mixed field (`cur` is
+/// `None`), where nothing typed is an untouched field and commits nothing.
+pub(crate) fn parse_line_height(s: &str, cur: Option<LineHeight>) -> Option<Value> {
+    let s = s.trim();
+    if s.is_empty() && cur.is_none() {
+        return None;
+    }
+    if s.is_empty() || s.eq_ignore_ascii_case("auto") {
+        return Some(json!("auto"));
+    }
+    if let Some(p) = s.strip_suffix('%') {
+        let cur_pct = match cur {
+            Some(LineHeight::Percent(p)) => Some(p),
+            _ => None,
+        };
+        return widgets::eval(p.trim(), cur_pct).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v.max(0.0)))));
+    }
+    if let Some(px) = s.strip_suffix("px") {
+        return widgets::eval(px.trim(), None).filter(|v| v.is_finite()).map(|v| json!(v.max(0.0)));
+    }
+    match cur {
+        Some(LineHeight::Percent(p)) => widgets::eval(s, Some(p)).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v.max(0.0))))),
+        Some(LineHeight::Pixels(px)) => widgets::eval(s, Some(px)).filter(|v| v.is_finite()).map(|v| json!(v.max(0.0))),
+        _ => widgets::eval(s, None).filter(|v| v.is_finite()).map(|v| json!(v.max(0.0))),
+    }
+}
+
+/// "2%", "1.5px", "-0.5" → the `letterSpacing` value. A bare number keeps the current unit
+/// (percent by default).
+pub(crate) fn parse_letter_spacing(s: &str, cur: Option<LetterSpacing>) -> Option<Value> {
+    let s = s.trim();
+    if let Some(p) = s.strip_suffix('%') {
+        return widgets::eval(p.trim(), None).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v))));
+    }
+    if let Some(p) = s.strip_suffix("px") {
+        return widgets::eval(p.trim(), None).filter(|v| v.is_finite()).map(|v| json!(v));
+    }
+    match cur {
+        Some(LetterSpacing::Pixels(px)) => widgets::eval(s, Some(px)).filter(|v| v.is_finite()).map(|v| json!(v)),
+        Some(LetterSpacing::Percent(p)) => widgets::eval(s, Some(p)).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v)))),
+        None => widgets::eval(s, None).filter(|v| v.is_finite()).map(|v| json!(format!("{}%", trim_num(v)))),
+    }
+}
+
+/// A [`parse_line_height`] value as a [`LineHeight`]: "auto", "150%" or a number of pixels.
+pub(crate) fn line_height_of(v: &Value) -> Option<LineHeight> {
+    match v {
+        Value::String(s) if s.eq_ignore_ascii_case("auto") => Some(LineHeight::Auto),
+        Value::String(s) => s.strip_suffix('%')?.trim().parse().ok().filter(|p: &f64| p.is_finite()).map(LineHeight::Percent),
+        other => other.as_f64().filter(|v| v.is_finite()).map(LineHeight::Pixels),
+    }
+}
+
+/// A [`parse_letter_spacing`] value as a [`LetterSpacing`]: "2%" or a number of pixels.
+pub(crate) fn letter_spacing_of(v: &Value) -> Option<LetterSpacing> {
+    match v {
+        Value::String(s) => s.strip_suffix('%')?.trim().parse().ok().filter(|p: &f64| p.is_finite()).map(LetterSpacing::Percent),
+        other => other.as_f64().filter(|v| v.is_finite()).map(LetterSpacing::Pixels),
+    }
+}

From 5c29d184f437f58e9ea5412843561ed81286f8aa Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:56:10 +0000
Subject: [PATCH 45/67] refactor(ui-egui): split icons.rs into icons/

---
 crates/ui-egui/src/icons.rs      | 1041 +-----------------------------
 crates/ui-egui/src/icons/draw.rs | 1038 +++++++++++++++++++++++++++++
 2 files changed, 1042 insertions(+), 1037 deletions(-)
 create mode 100644 crates/ui-egui/src/icons/draw.rs

diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs
index c8ee27e3..219fe85a 100644
--- a/crates/ui-egui/src/icons.rs
+++ b/crates/ui-egui/src/icons.rs
@@ -23,6 +23,10 @@ macro_rules! icons {
     };
 }
 
+mod draw;
+
+pub use draw::{paint, paint_outlines};
+
 icons! {
     Move,
     Scale,
@@ -272,1012 +276,6 @@ fn triangulate(v: &[Pos2]) -> Vec<u32> {
     out
 }
 
-struct P<'a> {
-    painter: &'a Painter,
-    o: Pos2,
-    s: f32,
-    /// One physical pixel, in points.
-    px: f32,
-    stroke: Stroke,
-    color: Color32,
-}
-
-impl P<'_> {
-    fn raw(&self, x: f32, y: f32) -> Pos2 {
-        pos2(self.o.x + x * self.s, self.o.y + y * self.s)
-    }
-    /// A stroke coordinate on the pixel grid: centred on a pixel for odd widths, on an edge for even.
-    fn snap_c(&self, v: f32) -> f32 {
-        let odd = (self.stroke.width / self.px).round() as i32 % 2 == 1;
-        let off = if odd { 0.5 } else { 0.0 };
-        ((v / self.px - off).round() + off) * self.px
-    }
-    /// A fill edge on the pixel grid.
-    fn snap_e(&self, v: f32) -> f32 {
-        (v / self.px).round() * self.px
-    }
-    /// A hinted stroke vertex.
-    fn sp(&self, x: f32, y: f32) -> Pos2 {
-        let q = self.raw(x, y);
-        pos2(self.snap_c(q.x), self.snap_c(q.y))
-    }
-    /// A straight stroke; axis-aligned ones are hinted (crossways onto pixel centres, lengthways
-    /// onto pixel edges so they end sharp).
-    fn line(&self, x0: f32, y0: f32, x1: f32, y1: f32) {
-        let (a, b) = (self.raw(x0, y0), self.raw(x1, y1));
-        let (a, b) = if y0 == y1 {
-            let y = self.snap_c(a.y);
-            (pos2(self.snap_e(a.x), y), pos2(self.snap_e(b.x), y))
-        } else if x0 == x1 {
-            let x = self.snap_c(a.x);
-            (pos2(x, self.snap_e(a.y)), pos2(x, self.snap_e(b.y)))
-        } else {
-            (a, b)
-        };
-        self.painter.line_segment([a, b], self.stroke);
-    }
-    /// A polyline of straight segments through hinted vertices.
-    fn poly(&self, pts: &[(f32, f32)], closed: bool) {
-        let v: Vec<Pos2> = pts.iter().map(|&(x, y)| self.sp(x, y)).collect();
-        self.stroke_pts(v, closed);
-    }
-    /// A path with curves (arcs, capsules): drawn as given, unhinted.
-    fn path(&self, pts: &[(f32, f32)], closed: bool) {
-        let v: Vec<Pos2> = pts.iter().map(|&(x, y)| self.raw(x, y)).collect();
-        self.stroke_pts(v, closed);
-    }
-    fn stroke_pts(&self, v: Vec<Pos2>, closed: bool) {
-        if closed {
-            self.painter.add(Shape::closed_line(v, self.stroke));
-        } else {
-            self.painter.add(Shape::line(v, self.stroke));
-        }
-    }
-    /// A filled polygon, convex or not.
-    fn fill(&self, pts: &[(f32, f32)]) {
-        let v: Vec<Pos2> = pts.iter().map(|&(x, y)| self.raw(x, y)).collect();
-        let n = v.len();
-        let turn = |i: usize| {
-            let (a, b, c) = (v[i], v[(i + 1) % n], v[(i + 2) % n]);
-            (b - a).x * (c - b).y - (b - a).y * (c - b).x
-        };
-        let convex = n >= 3 && ((0..n).all(|i| turn(i) >= 0.0) || (0..n).all(|i| turn(i) <= 0.0));
-        if convex {
-            self.painter.add(Shape::convex_polygon(v, self.color, Stroke::NONE));
-            return;
-        }
-        let indices = triangulate(&v);
-        if !indices.is_empty() {
-            let mut mesh = Mesh::default();
-            for p in &v {
-                mesh.colored_vertex(*p, self.color);
-            }
-            mesh.indices = indices;
-            self.painter.add(Shape::mesh(mesh));
-        }
-        // A hairline around the mesh gives it the same soft edge as the convex fills.
-        self.painter.add(Shape::closed_line(v, Stroke::new(self.px, self.color)));
-    }
-    /// Triangles `tris` over `verts` (x, y, alpha): the colour fades between the vertices.
-    fn shade(&self, verts: &[(f32, f32, f32)], tris: &[u32]) {
-        let mut mesh = Mesh::default();
-        for &(x, y, a) in verts {
-            mesh.colored_vertex(self.raw(x, y), self.color.gamma_multiply(a));
-        }
-        mesh.indices = tris.to_vec();
-        self.painter.add(Shape::mesh(mesh));
-    }
-    /// A disc of radius `r` at the centre, as a fan from the top, clockwise: each slice's rim
-    /// alphas from `rim` and its centre's from `centre`, both of how far round it is (0..1).
-    fn shade_fan(&self, r: f32, centre: impl Fn(f32) -> f32, rim: impl Fn(f32) -> f32) {
-        const SLICES: u32 = 32;
-        let at = |t: f32| {
-            let a = -FRAC_PI_2 + t * TAU;
-            (8.0 + r * a.cos(), 8.0 + r * a.sin())
-        };
-        let mut verts = Vec::new();
-        for i in 0..SLICES {
-            let (t0, t1) = (i as f32 / SLICES as f32, (i + 1) as f32 / SLICES as f32);
-            let ((x0, y0), (x1, y1)) = (at(t0), at(t1));
-            verts.extend([(8.0, 8.0, centre((t0 + t1) / 2.0)), (x0, y0, rim(t0)), (x1, y1, rim(t1))]);
-        }
-        let tris: Vec<u32> = (0..SLICES * 3).collect();
-        self.shade(&verts, &tris);
-    }
-    fn rect(&self, x0: f32, y0: f32, x1: f32, y1: f32, r: f32) {
-        let rr = Rect::from_min_max(self.sp(x0, y0), self.sp(x1, y1));
-        self.painter.rect_stroke(rr, egui::CornerRadius::same((r * self.s).round() as u8), self.stroke, egui::StrokeKind::Middle);
-    }
-    fn fill_rect(&self, x0: f32, y0: f32, x1: f32, y1: f32, r: f32) {
-        let (a, b) = (self.raw(x0, y0), self.raw(x1, y1));
-        let rr = Rect::from_min_max(pos2(self.snap_e(a.x), self.snap_e(a.y)), pos2(self.snap_e(b.x), self.snap_e(b.y)));
-        self.painter.rect_filled(rr, egui::CornerRadius::same((r * self.s).round() as u8), self.color);
-    }
-    fn circle(&self, x: f32, y: f32, r: f32) {
-        self.painter.circle_stroke(self.raw(x, y), r * self.s, self.stroke);
-    }
-    fn dot(&self, x: f32, y: f32, r: f32) {
-        self.painter.circle_filled(self.raw(x, y), r * self.s, self.color);
-    }
-    fn arc(&self, cx: f32, cy: f32, r: f32, a0: f32, a1: f32) {
-        self.path(&arc_pts(cx, cy, r, a0, a1).collect::<Vec<_>>(), false);
-    }
-    /// An open arrowhead at `tip` pointing along angle `dir`, arms `len` long.
-    fn head(&self, tip: (f32, f32), dir: f32, len: f32) {
-        let arm = |a: f32| (tip.0 + len * a.cos(), tip.1 + len * a.sin());
-        self.path(&[arm(dir + PI - FRAC_PI_4), tip, arm(dir + PI + FRAC_PI_4)], false);
-    }
-    /// An arc with an arrowhead at its end, pointing the way it runs.
-    fn arc_arrow(&self, cx: f32, cy: f32, r: f32, a0: f32, a1: f32) {
-        self.arc(cx, cy, r, a0, a1);
-        let tip = (cx + r * a1.cos(), cy + r * a1.sin());
-        let dir = a1 + if a1 > a0 { FRAC_PI_2 } else { -FRAC_PI_2 };
-        self.head(tip, dir, 2.6);
-    }
-    /// A rounded corner mark: an L at (`x`, `y`) opening towards (`dx`, `dy`), `len` long.
-    fn corner(&self, x: f32, y: f32, dx: f32, dy: f32, len: f32, r: f32) {
-        let a0 = 0.0f32.atan2(-dx);
-        let mut a1 = (-dy).atan2(0.0);
-        if a1 - a0 > PI {
-            a1 -= TAU;
-        } else if a0 - a1 > PI {
-            a1 += TAU;
-        }
-        let mut c = vec![(x, y + len * dy)];
-        c.extend(arc_pts(x + r * dx, y + r * dy, r, a0, a1));
-        c.push((x + len * dx, y));
-        self.path(&c, false);
-    }
-    /// Short dashes along the outline of a box (`n` per side).
-    fn dashed_box(&self, x0: f32, y0: f32, x1: f32, y1: f32, n: usize) {
-        let seg = |a: f32, b: f32, i: usize| {
-            let step = (b - a) / (2 * n - 1) as f32;
-            (a + 2.0 * i as f32 * step, a + (2 * i + 1) as f32 * step)
-        };
-        for i in 0..n {
-            let (a, b) = seg(x0 - 0.5, x1 + 0.5, i);
-            self.line(a, y0, b, y0);
-            self.line(a, y1, b, y1);
-            let (a, b) = seg(y0 - 0.5, y1 + 0.5, i);
-            self.line(x0, a, x0, b);
-            self.line(x1, a, x1, b);
-        }
-    }
-}
-
-/// Paint `icon` centred in `rect` (a 16-unit glyph scaled to fit) in `color`.
-pub fn paint(painter: &Painter, rect: Rect, icon: Icon, color: Color32) {
-    let ppp = painter.ctx().pixels_per_point();
-    let px = 1.0 / ppp;
-    // Physical pixels per grid unit: whole steps from 16 px up (quarter steps on fractional
-    // display scales), the exact fit below.
-    let k = rect.width().min(rect.height()) * ppp / 16.0;
-    let k = if k >= 1.0 { (k * 4.0).floor() / 4.0 } else { k };
-    let s = k * px;
-    let snap = |v: f32| (v * ppp).round() * px;
-    let o = rect.center() - vec2(8.0 * s, 8.0 * s);
-    let o = pos2(snap(o.x), snap(o.y));
-    let w = (k * 0.9).round().max(1.0) * px;
-    let p = P { painter, o, s, px, stroke: Stroke::new(w, color), color };
-    draw(&p, icon);
-}
-
-/// Draw `icon` on the 16-unit grid through `p`, which maps grid units to the target box.
-fn draw(p: &P, icon: Icon) {
-    use Icon::*;
-    match icon {
-        Move => p.fill(&[(4.0, 2.0), (4.0, 13.6), (6.9, 10.9), (8.8, 14.8), (10.6, 14.0), (8.7, 10.2), (12.6, 10.2)]),
-        Scale => {
-            p.rect(2.5, 7.5, 8.5, 13.5, 0.0);
-            p.line(6.0, 10.0, 13.0, 3.0);
-            p.poly(&[(9.5, 2.5), (13.5, 2.5), (13.5, 6.5)], false);
-        }
-        Hand => {
-            // An open hand: four fingers (the middle one tallest), then the palm and the thumb.
-            for (x, top) in [(4.5, 5.0), (6.5, 3.5), (8.5, 4.0), (10.5, 5.5)] {
-                let mut f = vec![(x, 8.0)];
-                f.extend(arc_pts(x + 1.0, top, 1.0, PI, TAU));
-                f.push((x + 2.0, 8.0));
-                p.path(&f, false);
-            }
-            let mut h = vec![(12.5, 8.0), (12.5, 10.0)];
-            h.extend(arc_pts(9.5, 10.0, 3.0, 0.0, FRAC_PI_2));
-            h.extend([(8.0, 13.0), (3.0, 9.4)]);
-            h.extend(arc_pts(3.6, 8.6, 1.0, 2.2, 5.3));
-            h.push((4.5, 8.5));
-            p.path(&h, false);
-        }
-        Frame => {
-            // Inset a unit from the box: four long hinted strokes read heavier than the
-            // anti-aliased outlines beside them at full size (#737).
-            p.line(5.5, 3.0, 5.5, 13.0);
-            p.line(10.5, 3.0, 10.5, 13.0);
-            p.line(3.0, 5.5, 13.0, 5.5);
-            p.line(3.0, 10.5, 13.0, 10.5);
-        }
-        Section | Section2 => {
-            p.rect(2.5, 5.5, 13.5, 13.5, 1.0);
-            p.fill_rect(2.0, 2.0, 9.0, 6.0, 1.0);
-        }
-        Slice => {
-            // A knife, one silhouette (#739): a slim blade to the top right, outlined like the
-            // rest of the row, and a solid handle whose end overlaps the blade's base so the two
-            // join at every size.
-            p.poly(&[(13.5, 2.5), (5.0, 8.0), (8.0, 11.0)], true);
-            p.fill(&capsule((2.8, 13.2), (5.9, 10.1), 1.3));
-        }
-        Bend => {
-            // A curve with a smooth point and its handle line.
-            let pts: Vec<(f32, f32)> = (0..=16)
-                .map(|i| {
-                    let t = i as f32 / 16.0;
-                    let u = 1.0 - t;
-                    (u * u * 2.5 + 2.0 * u * t * 8.0 + t * t * 13.5, u * u * 13.5 + 2.0 * u * t * 1.5 + t * t * 13.5)
-                })
-                .collect();
-            p.path(&pts, false);
-            p.line(3.0, 7.5, 13.0, 7.5);
-            p.dot(3.0, 7.5, 1.3);
-            p.dot(13.0, 7.5, 1.3);
-            p.fill_rect(7.0, 6.0, 9.0, 9.0, 0.0);
-        }
-        PaintBucket => {
-            p.poly(&[(2.5, 8.0), (7.5, 3.0), (12.5, 8.0), (7.5, 13.0)], true);
-            p.fill(&[(2.5, 8.0), (12.5, 8.0), (7.5, 13.0)]);
-            p.line(7.5, 3.0, 5.0, 0.5);
-            p.dot(13.5, 11.5, 1.5);
-        }
-        Lasso => {
-            p.path(&arc_pts(8.5, 6.5, 5.0, 0.0, TAU).map(|(x, y)| (x, 6.5 + (y - 6.5) * 0.7)).collect::<Vec<_>>(), true);
-            p.path(&[(5.0, 9.3), (4.5, 11.5), (6.0, 12.5), (4.5, 14.5)], false);
-        }
-        Cut => {
-            p.circle(4.5, 11.5, 2.0);
-            p.circle(11.5, 11.5, 2.0);
-            p.line(6.0, 10.0, 11.5, 2.5);
-            p.line(10.0, 10.0, 4.5, 2.5);
-        }
-        Rectangle => p.rect(2.5, 2.5, 13.5, 13.5, 1.0),
-        Line => p.line(2.5, 13.5, 13.5, 2.5),
-        Arrow => {
-            p.line(2.5, 13.5, 13.0, 3.0);
-            p.poly(&[(7.5, 2.5), (13.5, 2.5), (13.5, 8.5)], false);
-        }
-        Ellipse => p.circle(8.0, 8.0, 5.5),
-        Polygon => p.poly(&[(8.0, 2.5), (13.5, 12.5), (2.5, 12.5)], true),
-        Star => {
-            let pts: Vec<(f32, f32)> = (0..10)
-                .map(|i| {
-                    let a = -FRAC_PI_2 + PI * i as f32 / 5.0;
-                    let r = if i % 2 == 0 { 6.0 } else { 2.7 };
-                    (8.0 + r * a.cos(), 8.6 + r * a.sin())
-                })
-                .collect();
-            p.path(&pts, true);
-        }
-        Image => {
-            p.rect(2.5, 3.5, 13.5, 12.5, 1.0);
-            p.poly(&[(2.5, 11.5), (6.0, 8.0), (9.0, 11.0), (10.5, 9.5), (13.5, 12.5)], false);
-            p.dot(10.5, 6.5, 1.1);
-        }
-        Pen => {
-            p.poly(&[(8.0, 2.0), (12.5, 8.5), (10.5, 13.5), (5.5, 13.5), (3.5, 8.5)], true);
-            p.line(8.0, 2.0, 8.0, 7.0);
-            p.dot(8.0, 8.8, 1.2);
-        }
-        Pencil => {
-            p.poly(&[(2.5, 13.5), (3.2, 10.3), (10.5, 3.0), (13.0, 5.5), (5.7, 12.8)], true);
-            p.line(9.0, 4.5, 11.5, 7.0);
-        }
-        Text => {
-            // Inset like the Frame mark, so its long strokes don't outweigh the outlines (#737).
-            p.line(3.0, 3.5, 12.0, 3.5);
-            p.line(7.5, 3.0, 7.5, 12.5);
-            p.line(3.5, 3.0, 3.5, 5.5);
-            p.line(11.5, 3.0, 11.5, 5.5);
-            p.line(5.5, 12.5, 9.5, 12.5);
-        }
-        TextOnPath => {
-            // A small T above the curve it follows.
-            p.line(4.5, 3.0, 11.5, 3.0);
-            p.line(8.0, 3.0, 8.0, 8.5);
-            p.poly(&[(2.0, 13.5), (5.0, 11.5), (8.0, 10.8), (11.0, 11.5), (14.0, 13.5)], false);
-        }
-        Comment => {
-            let mut b: Vec<(f32, f32)> = arc_pts(8.5, 7.5, 5.0, 2.75, TAU + 1.95).collect();
-            b.push((2.5, 13.5));
-            p.path(&b, true);
-        }
-        Actions => p.poly(&[(9.0, 2.0), (3.5, 9.0), (7.5, 9.0), (6.5, 14.0), (12.5, 7.0), (8.5, 7.0)], true),
-        Chevron => p.poly(&[(4.5, 6.0), (8.0, 9.5), (11.5, 6.0)], false),
-        ChevronUp => p.poly(&[(4.5, 10.0), (8.0, 6.5), (11.5, 10.0)], false),
-        ChevronRight => p.poly(&[(6.0, 4.5), (9.5, 8.0), (6.0, 11.5)], false),
-        ChevronLeft => p.poly(&[(10.0, 4.5), (6.5, 8.0), (10.0, 11.5)], false),
-        Plus => {
-            p.line(7.5, 2.0, 7.5, 13.0);
-            p.line(2.0, 7.5, 13.0, 7.5);
-        }
-        Minus => p.line(2.0, 7.5, 13.0, 7.5),
-        Eye | EyeOff => {
-            // An almond (two arcs meeting at the corners) with the pupil.
-            let (r, cy, half) = (7.0f32, 7.5f32, 5.5f32);
-            let a = (half / r).asin();
-            let d = r * a.cos();
-            let mut e: Vec<(f32, f32)> = arc_pts(8.0, cy + d, r, -FRAC_PI_2 - a, -FRAC_PI_2 + a).collect();
-            e.extend(arc_pts(8.0, cy - d, r, FRAC_PI_2 - a, FRAC_PI_2 + a));
-            p.path(&e, true);
-            if icon == Eye {
-                p.circle(8.0, cy, 2.0);
-            } else {
-                p.line(3.0, 13.0, 13.0, 2.0);
-            }
-        }
-        Lock | Unlock => {
-            p.rect(3.5, 7.5, 12.5, 13.5, 1.0);
-            p.dot(8.0, 10.5, 1.0);
-            if icon == Lock {
-                p.line(5.5, 7.5, 5.5, 5.5);
-                p.line(10.5, 7.5, 10.5, 5.5);
-                p.arc(8.0, 5.5, 2.5, PI, TAU);
-            } else {
-                p.line(10.5, 7.5, 10.5, 4.5);
-                p.arc(13.0, 4.5, 2.5, PI, TAU);
-            }
-        }
-        Component => {
-            for (cx, cy) in [(8.0, 4.2), (11.8, 8.0), (8.0, 11.8), (4.2, 8.0)] {
-                p.fill(&[(cx, cy - 2.5), (cx + 2.5, cy), (cx, cy + 2.5), (cx - 2.5, cy)]);
-            }
-        }
-        ComponentSet => {
-            for (cx, cy) in [(8.0, 4.3), (11.7, 8.0), (8.0, 11.7), (4.3, 8.0)] {
-                p.path(&[(cx, cy - 2.2), (cx + 2.2, cy), (cx, cy + 2.2), (cx - 2.2, cy)], true);
-            }
-        }
-        Instance => p.path(&[(8.0, 2.0), (14.0, 8.0), (8.0, 14.0), (2.0, 8.0)], true),
-        Group => {
-            for (x, y, dx, dy) in [(2.5, 2.5, 1.0, 1.0), (13.5, 2.5, -1.0, 1.0), (2.5, 13.5, 1.0, -1.0), (13.5, 13.5, -1.0, -1.0)] {
-                p.poly(&[(x + 3.5 * dx, y), (x, y), (x, y + 3.5 * dy)], false);
-            }
-        }
-        Vector => {
-            p.path(&[(3.0, 12.5), (6.0, 4.0), (10.0, 12.0), (13.0, 3.5)], false);
-            p.fill_rect(1.5, 11.0, 4.5, 14.0, 0.0);
-            p.fill_rect(11.5, 2.0, 14.5, 5.0, 0.0);
-        }
-        Boolean | Union => {
-            p.rect(2.5, 2.5, 9.5, 9.5, 0.0);
-            p.rect(6.5, 6.5, 13.5, 13.5, 0.0);
-        }
-        Subtract => {
-            p.fill_rect(2.0, 2.0, 10.0, 10.0, 0.0);
-            p.rect(6.5, 6.5, 13.5, 13.5, 0.0);
-        }
-        Intersect => {
-            p.rect(2.5, 2.5, 9.5, 9.5, 0.0);
-            p.rect(6.5, 6.5, 13.5, 13.5, 0.0);
-            p.fill_rect(6.0, 6.0, 10.0, 10.0, 0.0);
-        }
-        Exclude => {
-            p.fill_rect(2.0, 2.0, 10.0, 6.0, 0.0);
-            p.fill_rect(2.0, 6.0, 6.0, 10.0, 0.0);
-            p.fill_rect(10.0, 6.0, 14.0, 14.0, 0.0);
-            p.fill_rect(6.0, 10.0, 10.0, 14.0, 0.0);
-            p.rect(6.5, 6.5, 9.5, 9.5, 0.0);
-        }
-        Page => {
-            p.poly(&[(3.5, 2.5), (9.5, 2.5), (12.5, 5.5), (12.5, 13.5), (3.5, 13.5)], true);
-            p.poly(&[(9.5, 2.5), (9.5, 5.5), (12.5, 5.5)], false);
-        }
-        Check => p.poly(&[(3.0, 8.5), (6.5, 12.0), (13.0, 4.5)], false),
-        Close => {
-            p.line(4.0, 4.0, 12.0, 12.0);
-            p.line(12.0, 4.0, 4.0, 12.0);
-        }
-        WinMinimize => p.line(3.0, 8.5, 13.0, 8.5),
-        WinMaximize => p.rect(3.5, 3.5, 12.5, 12.5, 0.0),
-        WinRestore => {
-            // A window in front of another.
-            p.rect(3.5, 5.5, 10.5, 12.5, 0.0);
-            p.poly(&[(5.5, 5.5), (5.5, 3.5), (12.5, 3.5), (12.5, 10.5), (10.5, 10.5)], false);
-        }
-        Search => {
-            p.circle(7.0, 7.0, 4.5);
-            p.line(10.5, 10.5, 14.0, 14.0);
-        }
-        Grid | LayoutGrid => {
-            for i in [2.5, 6.5, 10.5] {
-                for j in [2.5, 6.5, 10.5] {
-                    p.rect(i, j, i + 3.0, j + 3.0, 0.0);
-                }
-            }
-        }
-        AlignLeft => {
-            p.line(2.5, 2.0, 2.5, 14.0);
-            p.fill_rect(4.0, 4.0, 13.0, 7.0, 0.0);
-            p.fill_rect(4.0, 9.0, 9.0, 12.0, 0.0);
-        }
-        AlignHCenter => {
-            p.line(7.5, 2.0, 7.5, 14.0);
-            p.fill_rect(2.0, 4.0, 13.0, 7.0, 0.0);
-            p.fill_rect(4.0, 9.0, 11.0, 12.0, 0.0);
-        }
-        AlignRight => {
-            p.line(13.5, 2.0, 13.5, 14.0);
-            p.fill_rect(3.0, 4.0, 12.0, 7.0, 0.0);
-            p.fill_rect(7.0, 9.0, 12.0, 12.0, 0.0);
-        }
-        AlignTop => {
-            p.line(2.0, 2.5, 14.0, 2.5);
-            p.fill_rect(4.0, 4.0, 7.0, 13.0, 0.0);
-            p.fill_rect(9.0, 4.0, 12.0, 9.0, 0.0);
-        }
-        AlignVCenter => {
-            p.line(2.0, 7.5, 14.0, 7.5);
-            p.fill_rect(4.0, 2.0, 7.0, 13.0, 0.0);
-            p.fill_rect(9.0, 4.0, 12.0, 11.0, 0.0);
-        }
-        AlignBottom => {
-            p.line(2.0, 13.5, 14.0, 13.5);
-            p.fill_rect(4.0, 3.0, 7.0, 12.0, 0.0);
-            p.fill_rect(9.0, 7.0, 12.0, 12.0, 0.0);
-        }
-        DistributeH | Gap => {
-            p.line(2.5, 2.0, 2.5, 14.0);
-            p.line(13.5, 2.0, 13.5, 14.0);
-            p.fill_rect(6.0, 4.0, 10.0, 12.0, 0.0);
-        }
-        DistributeV => {
-            p.line(2.0, 2.5, 14.0, 2.5);
-            p.line(2.0, 13.5, 14.0, 13.5);
-            p.fill_rect(4.0, 6.0, 12.0, 10.0, 0.0);
-        }
-        Rotate => p.arc_arrow(8.0, 8.5, 5.0, -PI * 0.55, PI * 1.25),
-        Reset => p.arc_arrow(8.0, 8.5, 5.0, -PI * 0.45, -PI * 2.25),
-        FlipH => {
-            for y in [1.0, 5.0, 9.0, 13.0] {
-                p.line(7.5, y, 7.5, y + 2.0);
-            }
-            p.poly(&[(5.5, 3.5), (5.5, 12.5), (1.5, 12.5)], true);
-            p.fill(&[(9.0, 3.0), (14.0, 13.0), (9.0, 13.0)]);
-        }
-        FlipV => {
-            for x in [1.0, 5.0, 9.0, 13.0] {
-                p.line(x, 7.5, x + 2.0, 7.5);
-            }
-            p.poly(&[(3.5, 5.5), (12.5, 5.5), (12.5, 1.5)], true);
-            p.fill(&[(3.0, 9.0), (13.0, 9.0), (13.0, 14.0)]);
-        }
-        CornerRadius | CornerTopLeft => p.corner(2.5, 2.5, 1.0, 1.0, 11.5, 6.0),
-        CornerTopRight => p.corner(13.5, 2.5, -1.0, 1.0, 11.5, 6.0),
-        CornerBottomRight => p.corner(13.5, 13.5, -1.0, -1.0, 11.5, 6.0),
-        CornerBottomLeft => p.corner(2.5, 13.5, 1.0, -1.0, 11.5, 6.0),
-        Angle => {
-            // Two rays from a vertex, the arc between them marking the angle (all unhinted, so
-            // the arc meets the rays at every size).
-            p.path(&[(13.5, 13.0), (2.5, 13.0), (10.5, 3.0)], false);
-            p.path(&arc_pts(2.5, 13.0, 6.0, (-10.0f32).atan2(8.0), 0.0).collect::<Vec<_>>(), false);
-        }
-        IndependentCorners => {
-            for (x, y, dx, dy) in [(2.5, 2.5, 1.0, 1.0), (13.5, 2.5, -1.0, 1.0), (2.5, 13.5, 1.0, -1.0), (13.5, 13.5, -1.0, -1.0)] {
-                p.corner(x, y, dx, dy, 4.0, 2.0);
-            }
-        }
-        IndependentPadding => {
-            // A frame outline with one inward tick per side: each side's padding, set alone.
-            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
-            p.line(8.0, 2.5, 8.0, 5.0);
-            p.line(13.5, 8.0, 11.0, 8.0);
-            p.line(8.0, 13.5, 8.0, 11.0);
-            p.line(2.5, 8.0, 5.0, 8.0);
-        }
-        LinkOn | Link => {
-            p.path(&capsule((4.0, 12.0), (6.5, 9.5), 2.4), true);
-            p.path(&capsule((9.5, 6.5), (12.0, 4.0), 2.4), true);
-            p.line(6.2, 9.8, 9.8, 6.2);
-        }
-        LinkOff => {
-            p.path(&capsule((3.5, 12.5), (5.5, 10.5), 2.2), true);
-            p.path(&capsule((10.5, 5.5), (12.5, 3.5), 2.2), true);
-            p.line(9.5, 12.0, 9.5, 14.0);
-            p.line(12.0, 9.5, 14.0, 9.5);
-            p.line(2.0, 6.5, 4.0, 6.5);
-            p.line(6.5, 2.0, 6.5, 4.0);
-        }
-        LayoutH => {
-            p.fill_rect(2.0, 3.0, 7.0, 13.0, 1.0);
-            p.fill_rect(9.0, 3.0, 14.0, 13.0, 1.0);
-        }
-        LayoutV => {
-            p.fill_rect(3.0, 2.0, 13.0, 7.0, 1.0);
-            p.fill_rect(3.0, 9.0, 13.0, 14.0, 1.0);
-        }
-        LayoutWrap => {
-            let mut w = vec![(2.0, 4.5), (10.5, 4.5)];
-            w.extend(arc_pts(10.5, 7.5, 3.0, -FRAC_PI_2, FRAC_PI_2));
-            w.push((4.0, 10.5));
-            p.path(&w, false);
-            p.head((3.5, 10.5), PI, 2.8);
-        }
-        AutoLayout => {
-            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
-            p.fill_rect(5.0, 5.0, 7.0, 11.0, 0.0);
-            p.fill_rect(9.0, 5.0, 11.0, 11.0, 0.0);
-        }
-        ClipContent => {
-            p.rect(4.5, 4.5, 13.5, 13.5, 0.0);
-            p.line(2.5, 1.0, 2.5, 11.0);
-            p.line(1.0, 2.5, 11.0, 2.5);
-        }
-        Effects | Sun => {
-            p.circle(8.0, 8.0, if icon == Sun { 2.5 } else { 3.0 });
-            for i in 0..8 {
-                let a = i as f32 * FRAC_PI_4;
-                let (r0, r1) = if i % 2 == 0 { (4.8, 6.6) } else { (4.6, 5.8) };
-                p.line(8.0 + r0 * a.cos(), 8.0 + r0 * a.sin(), 8.0 + r1 * a.cos(), 8.0 + r1 * a.sin());
-            }
-        }
-        Styles => {
-            for (x, y) in [(5.0, 5.0), (11.0, 5.0), (5.0, 11.0), (11.0, 11.0)] {
-                p.dot(x, y, 2.2);
-            }
-        }
-        Menu => {
-            for y in [3.5, 7.5, 11.5] {
-                p.line(2.0, y, 14.0, y);
-            }
-        }
-        Play => p.fill(&[(4.5, 2.5), (13.5, 8.0), (4.5, 13.5)]),
-        Home => {
-            // Unhinted so the roof's peak stays centred; the floor stops at the door.
-            p.path(&[(6.5, 13.5), (3.5, 13.5), (3.5, 7.0), (8.0, 2.8), (12.5, 7.0), (12.5, 13.5), (9.5, 13.5)], false);
-            p.poly(&[(6.5, 13.5), (6.5, 9.5), (9.5, 9.5), (9.5, 13.5)], false);
-        }
-        Bell => {
-            let mut b = vec![(2.5, 11.5), (4.0, 10.0), (4.0, 7.0)];
-            b.extend(arc_pts(8.0, 7.0, 4.0, PI, TAU));
-            b.extend([(12.0, 10.0), (13.5, 11.5)]);
-            p.path(&b, true);
-            p.arc(8.0, 12.0, 1.8, 0.0, PI);
-        }
-        Panels => {
-            p.rect(2.5, 3.5, 13.5, 12.5, 1.0);
-            p.line(5.5, 4.0, 5.5, 12.0);
-            p.line(10.5, 4.0, 10.5, 12.0);
-        }
-        Help => {
-            p.circle(8.0, 8.0, 6.0);
-            p.arc(8.0, 6.4, 2.0, PI * 1.05, TAU + 0.7);
-            p.path(&[(9.5, 7.7), (8.0, 8.8), (8.0, 9.8)], false);
-            p.dot(8.0, 11.6, 0.9);
-        }
-        Dots => {
-            for x in [3.5, 8.0, 12.5] {
-                p.dot(x, 8.0, 1.25);
-            }
-        }
-        Mask | Opacity => {
-            p.circle(8.0, 8.0, 5.5);
-            let side = if icon == Mask { -FRAC_PI_2 } else { FRAC_PI_2 };
-            p.fill(&arc_pts(8.0, 8.0, 5.5, side, side + PI).collect::<Vec<_>>());
-        }
-        TextAlignLeft => {
-            for (y, x1) in [(3.5, 14.0), (6.5, 10.0), (9.5, 14.0), (12.5, 9.0)] {
-                p.line(2.0, y, x1, y);
-            }
-        }
-        TextAlignCenter => {
-            for (y, h) in [(3.5, 6.0), (6.5, 4.0), (9.5, 6.0), (12.5, 3.0)] {
-                p.line(8.0 - h, y, 8.0 + h, y);
-            }
-        }
-        TextAlignRight => {
-            for (y, x0) in [(3.5, 2.0), (6.5, 6.0), (9.5, 2.0), (12.5, 7.0)] {
-                p.line(x0, y, 14.0, y);
-            }
-        }
-        TextAlignJustify => {
-            for y in [3.5, 6.5, 9.5, 12.5] {
-                p.line(2.0, y, 14.0, y);
-            }
-        }
-        TextTop => {
-            p.line(2.0, 2.5, 14.0, 2.5);
-            p.line(7.5, 5.0, 7.5, 14.0);
-            p.head((7.5, 5.0), -FRAC_PI_2, 3.2);
-        }
-        TextMiddle => {
-            p.line(2.0, 7.5, 14.0, 7.5);
-            p.line(7.5, 1.0, 7.5, 5.0);
-            p.head((7.5, 5.0), FRAC_PI_2, 2.6);
-            p.line(7.5, 10.0, 7.5, 14.0);
-            p.head((7.5, 10.0), -FRAC_PI_2, 2.6);
-        }
-        TextBottom => {
-            p.line(2.0, 13.5, 14.0, 13.5);
-            p.line(7.5, 2.0, 7.5, 11.0);
-            p.head((7.5, 11.0), FRAC_PI_2, 3.2);
-        }
-        Eyedropper => {
-            p.poly(&[(2.5, 13.5), (3.0, 11.0), (8.5, 5.5), (10.5, 7.5), (5.0, 13.0)], true);
-            p.path(&capsule((10.5, 5.5), (12.0, 4.0), 1.6), true);
-            p.line(7.5, 4.5, 11.5, 8.5);
-        }
-        Code => {
-            p.poly(&[(5.5, 4.0), (2.0, 8.0), (5.5, 12.0)], false);
-            p.poly(&[(10.5, 4.0), (14.0, 8.0), (10.5, 12.0)], false);
-            p.line(9.0, 3.0, 7.0, 13.0);
-        }
-        Assets => {
-            p.path(&[(5.0, 2.0), (8.0, 5.0), (5.0, 8.0), (2.0, 5.0)], true);
-            p.circle(11.0, 5.0, 2.5);
-            p.rect(2.5, 9.5, 7.5, 13.5, 0.0);
-            p.poly(&[(11.0, 9.0), (13.5, 13.5), (8.5, 13.5)], true);
-        }
-        Library => {
-            p.poly(&[(7.5, 4.5), (5.5, 3.5), (1.5, 3.5), (1.5, 12.5), (5.5, 12.5), (7.5, 13.5)], false);
-            p.poly(&[(8.5, 4.5), (10.5, 3.5), (14.5, 3.5), (14.5, 12.5), (10.5, 12.5), (8.5, 13.5)], false);
-            p.line(7.5, 4.5, 7.5, 13.5);
-            p.line(8.5, 4.5, 8.5, 13.5);
-        }
-        Layers => {
-            p.poly(&[(8.0, 2.5), (14.0, 5.5), (8.0, 8.5), (2.0, 5.5)], true);
-            p.poly(&[(2.0, 8.0), (8.0, 11.0), (14.0, 8.0)], false);
-            p.poly(&[(2.0, 10.5), (8.0, 13.5), (14.0, 10.5)], false);
-        }
-        Blend => {
-            p.circle(6.0, 8.0, 4.0);
-            p.circle(10.0, 8.0, 4.0);
-        }
-        Export => {
-            p.line(7.5, 2.0, 7.5, 10.0);
-            p.head((7.5, 2.0), -FRAC_PI_2, 3.5);
-            p.poly(&[(2.5, 8.5), (2.5, 13.5), (12.5, 13.5), (12.5, 8.5)], false);
-        }
-        StrokeIcon => p.rect(2.5, 2.5, 13.5, 13.5, 2.0),
-        Fill => p.fill_rect(2.0, 2.0, 14.0, 14.0, 2.0),
-        GradientLinear => {
-            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
-            p.shade(&[(4.0, 4.0, 1.0), (12.0, 4.0, 0.0), (12.0, 12.0, 0.0), (4.0, 12.0, 1.0)], &[0, 1, 2, 0, 2, 3]);
-        }
-        GradientRadial => {
-            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
-            p.shade_fan(5.5, |_| 1.0, |_| 0.0);
-        }
-        GradientAngular => {
-            // Once round from the top: the seam shows where the sweep starts.
-            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
-            p.shade_fan(4.0, |t| 1.0 - t, |t| 1.0 - t);
-        }
-        GradientDiamond => {
-            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
-            let v = [(8.0, 8.0, 1.0), (8.0, 2.5, 0.0), (13.5, 8.0, 0.0), (8.0, 13.5, 0.0), (2.5, 8.0, 0.0)];
-            p.shade(&v, &[0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 1]);
-        }
-        Moon => {
-            // A crescent: the outer rim, then the shadowing circle's edge back. Both arcs stop short
-            // of where the circles meet, so each tip is two blunt joins (a single cusp join folds).
-            let mut m: Vec<(f32, f32)> = arc_pts(8.0, 8.0, 5.5, 0.166 + 0.12, TAU - 1.737 - 0.12).collect();
-            m.extend(arc_pts(11.0, 5.0, 4.6, -2.586 - 0.18, 1.016 - TAU + 0.18));
-            p.path(&m, true);
-        }
-        Undo | Redo => {
-            // A U-turn arrow: back along the top, round, and out along the bottom.
-            let undo = icon == Undo;
-            let f = |x: f32| if undo { x } else { 16.0 - x };
-            let mut u = vec![(f(3.0), 5.5), (f(9.5), 5.5)];
-            let a1 = if undo { FRAC_PI_2 } else { -3.0 * FRAC_PI_2 };
-            u.extend(arc_pts(f(9.5), 9.0, 3.5, -FRAC_PI_2, a1));
-            u.push((f(6.0), 12.5));
-            p.path(&u, false);
-            p.head((f(3.0), 5.5), if undo { PI } else { 0.0 }, 3.0);
-        }
-        Hug => {
-            p.poly(&[(2.5, 4.5), (5.5, 7.5), (2.5, 10.5)], false);
-            p.poly(&[(13.5, 4.5), (10.5, 7.5), (13.5, 10.5)], false);
-            p.line(6.0, 7.5, 10.0, 7.5);
-        }
-        FillContainer => {
-            p.poly(&[(5.0, 4.5), (2.0, 7.5), (5.0, 10.5)], false);
-            p.poly(&[(11.0, 4.5), (14.0, 7.5), (11.0, 10.5)], false);
-            p.line(2.0, 7.5, 14.0, 7.5);
-        }
-        Fixed => {
-            p.line(2.5, 4.0, 2.5, 11.0);
-            p.line(13.5, 4.0, 13.5, 11.0);
-            p.line(3.0, 7.5, 13.0, 7.5);
-        }
-        PaddingH => {
-            // Horizontal padding: bars down the padded left and right sides in their frame.
-            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
-            p.fill_rect(2.5, 2.5, 5.5, 13.5, 1.0);
-            p.fill_rect(10.5, 2.5, 13.5, 13.5, 1.0);
-        }
-        PaddingV => {
-            // Vertical padding: bars across the padded top and bottom in their frame.
-            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
-            p.fill_rect(2.5, 2.5, 13.5, 5.5, 1.0);
-            p.fill_rect(2.5, 10.5, 13.5, 13.5, 1.0);
-        }
-        PaddingTop => {
-            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
-            p.fill_rect(2.5, 2.5, 13.5, 5.5, 1.0);
-        }
-        PaddingRight => {
-            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
-            p.fill_rect(10.5, 2.5, 13.5, 13.5, 1.0);
-        }
-        PaddingBottom => {
-            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
-            p.fill_rect(2.5, 10.5, 13.5, 13.5, 1.0);
-        }
-        PaddingLeft => {
-            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
-            p.fill_rect(2.5, 2.5, 5.5, 13.5, 1.0);
-        }
-        Online => {
-            p.circle(8.0, 8.0, 5.5);
-            p.line(2.5, 8.0, 13.5, 8.0);
-            let meridian: Vec<(f32, f32)> = arc_pts(0.0, 0.0, 1.0, 0.0, TAU).map(|(x, y)| (8.0 + 2.4 * x, 8.0 + 5.5 * y)).collect();
-            p.path(&meridian, true);
-        }
-        LiveShared => {
-            p.dot(8.0, 8.0, 1.6);
-            for r in [3.6, 6.0] {
-                p.arc(8.0, 8.0, r, -FRAC_PI_4, FRAC_PI_4);
-                p.arc(8.0, 8.0, r, PI - FRAC_PI_4, PI + FRAC_PI_4);
-            }
-        }
-        LivePrivate => {
-            p.dot(8.0, 8.0, 1.6);
-            p.circle(8.0, 8.0, 5.0);
-        }
-        Clock => {
-            p.circle(7.5, 7.5, 5.5);
-            p.line(7.5, 4.0, 7.5, 8.0);
-            p.line(7.5, 7.5, 10.0, 10.0);
-        }
-        ShapeBuilder | ShapeBuilderRemove => {
-            // Two overlapping rings; their shared lens filled (merge) or crossed out (remove).
-            let (r, d) = (4.5f32, 2.0f32);
-            let a = (d / r).acos();
-            p.circle(8.0 - d, 8.0, r);
-            p.circle(8.0 + d, 8.0, r);
-            if icon == ShapeBuilder {
-                let lens: Vec<(f32, f32)> = arc_pts(8.0 - d, 8.0, r, -a, a).chain(arc_pts(8.0 + d, 8.0, r, PI - a, PI + a)).collect();
-                p.fill(&lens);
-            } else {
-                p.line(6.2, 9.8, 9.8, 6.2);
-            }
-        }
-        Eraser => {
-            // A tilted block with a band near its tip, over a short trace line.
-            p.poly(&[(2.5, 10.0), (9.5, 3.0), (13.5, 7.0), (7.0, 13.5), (6.0, 13.5)], true);
-            p.line(5.5, 7.0, 9.5, 11.0);
-            p.line(7.0, 13.5, 14.0, 13.5);
-        }
-        VariableWidth => {
-            // A lens-shaped stroke, thin at both ends, and a width handle on either side of its
-            // widest point.
-            let edge = |i: i32, side: f32| {
-                let f = i as f32 / 12.0;
-                (2.0 + 11.0 * f, 7.5 + side * 3.0 * (PI * f).sin())
-            };
-            let lens: Vec<(f32, f32)> = (0..=12).map(|i| edge(i, -1.0)).chain((0..=12).rev().map(|i| edge(i, 1.0))).collect();
-            p.fill(&lens);
-            p.line(7.5, 2.0, 7.5, 13.0);
-            p.dot(7.5, 2.0, 1.5);
-            p.dot(7.5, 13.0, 1.5);
-        }
-        Variable => {
-            // A hexagon with a dot: an original mark for "bind a value".
-            let pts: Vec<(f32, f32)> = (0..6)
-                .map(|i| {
-                    let a = std::f32::consts::FRAC_PI_3 * i as f32 + std::f32::consts::FRAC_PI_6;
-                    (8.0 + 6.0 * a.cos(), 8.0 + 6.0 * a.sin())
-                })
-                .collect();
-            p.path(&pts, true);
-            p.dot(8.0, 8.0, 1.7);
-        }
-        Detach => {
-            p.path(&[(8.0, 2.0), (14.0, 8.0), (8.0, 14.0), (2.0, 8.0)], true);
-            p.line(3.0, 13.0, 13.0, 3.0);
-        }
-        Swap => {
-            p.line(2.0, 4.5, 13.0, 4.5);
-            p.head((13.0, 4.5), 0.0, 2.8);
-            p.line(3.0, 11.5, 14.0, 11.5);
-            p.head((3.0, 11.5), PI, 2.8);
-        }
-        Prototype => {
-            p.circle(4.5, 11.5, 2.0);
-            p.line(6.0, 10.0, 13.0, 3.0);
-            p.poly(&[(8.5, 2.5), (13.5, 2.5), (13.5, 7.5)], false);
-        }
-        Preview => {
-            // A window with a title strip and a play triangle in it.
-            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
-            p.line(3.0, 5.5, 13.0, 5.5);
-            p.fill(&[(6.5, 7.5), (10.5, 10.0), (6.5, 12.5)]);
-        }
-        AbsolutePosition => {
-            // The frame, a small layer near its top-right corner, and the two offsets pinning it.
-            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
-            p.fill_rect(6.0, 6.0, 10.0, 10.0, 0.0);
-            p.line(10.0, 7.5, 13.0, 7.5);
-            p.line(7.5, 3.0, 7.5, 6.0);
-        }
-        Slot => {
-            p.dashed_box(2.5, 2.5, 12.5, 12.5, 3);
-            p.line(7.5, 5.0, 7.5, 10.0);
-            p.line(5.0, 7.5, 10.0, 7.5);
-        }
-        Adjust => {
-            p.line(2.0, 4.5, 14.0, 4.5);
-            p.line(2.0, 11.5, 14.0, 11.5);
-            p.dot(10.5, 4.5, 2.2);
-            p.dot(5.5, 11.5, 2.2);
-        }
-        ViewList => {
-            for y in [2.0, 6.0, 10.0] {
-                p.fill_rect(2.0, y, 5.0, y + 3.0, 0.0);
-                p.line(7.0, y + 1.5, 14.0, y + 1.5);
-            }
-        }
-        Reaction => {
-            p.circle(8.0, 8.0, 5.5);
-            p.dot(6.0, 6.5, 0.9);
-            p.dot(10.0, 6.5, 0.9);
-            p.arc(8.0, 8.5, 3.0, 0.6, PI - 0.6);
-        }
-        DragHandle => {
-            for y in [4.0, 8.0, 12.0] {
-                p.dot(6.0, y, 1.1);
-                p.dot(10.0, y, 1.1);
-            }
-        }
-        ViewGrid => {
-            for (x, y) in [(2.5, 2.5), (9.5, 2.5), (2.5, 9.5), (9.5, 9.5)] {
-                p.rect(x, y, x + 4.0, y + 4.0, 1.0);
-            }
-        }
-        ArcStart => {
-            p.circle(8.0, 8.0, 5.5);
-            p.line(8.0, 8.0, 13.5, 8.0);
-            p.dot(13.5, 8.0, 1.6);
-        }
-        ArcSweep => {
-            let mut wedge = vec![(8.0, 8.0)];
-            wedge.extend(arc_pts(8.0, 8.0, 5.5, 0.0, 1.5 * PI));
-            p.path(&wedge, true);
-        }
-        ArcRatio => {
-            p.circle(8.0, 8.0, 5.5);
-            p.circle(8.0, 8.0, 2.5);
-        }
-        GamutWarning => {
-            p.poly(&[(8.0, 2.0), (14.5, 13.5), (1.5, 13.5)], true);
-            p.line(8.0, 6.0, 8.0, 9.5);
-            p.dot(8.0, 11.5, 0.9);
-        }
-        PenNib => {
-            // Drawn pointing down, then leant 35° to the left about the middle.
-            let (sin, cos) = (0.61f32, 0.79f32);
-            let at = |x: f32, y: f32| (8.0 + x * cos - y * sin, 8.0 + x * sin + y * cos);
-            let nib: Vec<(f32, f32)> = [(0.0, 6.5), (3.4, 1.0), (2.4, -2.5), (-2.4, -2.5), (-3.4, 1.0)].iter().map(|&(x, y)| at(x, y)).collect();
-            p.path(&nib, true);
-            let (a, b) = (at(0.0, 6.5), at(0.0, 2.0));
-            p.path(&[a, b], false);
-            let (dx, dy) = at(0.0, 0.6);
-            p.dot(dx, dy, 1.0);
-            let grip: Vec<(f32, f32)> = [(-2.4, -3.4), (2.4, -3.4), (2.4, -5.6), (-2.4, -5.6)].iter().map(|&(x, y)| at(x, y)).collect();
-            p.fill(&grip);
-        }
-        Board => {
-            p.poly(&[(2.5, 2.5), (13.5, 2.5), (13.5, 9.5), (9.5, 13.5), (2.5, 13.5)], true);
-            p.fill(&[(9.5, 13.5), (9.5, 9.5), (13.5, 9.5)]);
-            p.line(5.0, 6.5, 11.0, 6.5);
-            p.line(5.0, 9.5, 8.0, 9.5);
-        }
-        Templates => {
-            p.rect(1.5, 2.5, 14.5, 13.5, 1.5);
-            p.fill_rect(3.5, 4.5, 7.5, 8.5, 0.5);
-            p.line(9.5, 5.5, 12.5, 5.5);
-            p.line(9.5, 7.5, 12.5, 7.5);
-            p.line(3.5, 11.0, 12.5, 11.0);
-        }
-        Table => {
-            p.rect(1.5, 2.5, 14.5, 13.5, 1.0);
-            p.line(1.5, 6.5, 14.5, 6.5);
-            p.line(1.5, 10.0, 14.5, 10.0);
-            p.line(6.0, 2.5, 6.0, 13.5);
-            p.line(10.0, 2.5, 10.0, 13.5);
-        }
-        AddRow | RemoveRow => {
-            p.rect(1.5, 2.5, 14.5, 8.5, 1.0);
-            p.line(8.0, 2.5, 8.0, 8.5);
-            p.line(5.5, 12.5, 10.5, 12.5);
-            if icon == AddRow {
-                p.line(8.0, 10.0, 8.0, 15.0);
-            }
-        }
-        AddColumn | RemoveColumn => {
-            p.rect(2.5, 1.5, 8.5, 14.5, 1.0);
-            p.line(2.5, 8.0, 8.5, 8.0);
-            p.line(10.0, 8.0, 15.0, 8.0);
-            if icon == AddColumn {
-                p.line(12.5, 5.5, 12.5, 10.5);
-            }
-        }
-        Marker => {
-            p.poly(&[(3.0, 13.0), (3.0, 10.5), (10.0, 3.5), (12.5, 6.0), (5.5, 13.0)], true);
-            p.line(8.5, 5.0, 11.0, 7.5);
-            p.fill(&[(2.0, 14.0), (2.0, 11.5), (4.5, 14.0)]);
-        }
-        Highlighter => {
-            p.poly(&[(4.0, 10.0), (10.5, 3.5), (13.5, 6.5), (7.0, 13.0)], true);
-            p.poly(&[(4.0, 10.0), (2.5, 12.5), (4.5, 12.5), (7.0, 13.0)], false);
-            p.fill_rect(1.0, 14.0, 15.0, 15.5, 0.0);
-        }
-        Connector => {
-            p.rect(1.5, 1.5, 6.5, 6.5, 1.0);
-            p.rect(9.5, 9.5, 14.5, 14.5, 1.0);
-            p.poly(&[(6.5, 4.0), (12.0, 4.0), (12.0, 9.0)], false);
-            p.head((12.0, 9.0), FRAC_PI_2, 2.4);
-        }
-        CurvedConnector => {
-            p.rect(1.5, 1.5, 6.5, 6.5, 1.0);
-            p.rect(9.5, 9.5, 14.5, 14.5, 1.0);
-            p.arc(6.5, 9.0, 5.5, -FRAC_PI_2, 0.0);
-            p.head((12.0, 9.0), FRAC_PI_2, 2.4);
-        }
-        Shapes => {
-            p.rect(1.5, 5.5, 9.5, 13.5, 1.0);
-            p.circle(10.5, 5.5, 4.0);
-        }
-        Stamp => {
-            p.circle(8.0, 8.0, 6.0);
-            p.poly(&[(5.0, 8.3), (7.2, 10.5), (11.0, 6.0)], false);
-        }
-        Timer => {
-            p.circle(8.0, 9.0, 5.5);
-            p.line(8.0, 9.0, 8.0, 6.0);
-            p.line(6.0, 1.5, 10.0, 1.5);
-            p.line(8.0, 1.5, 8.0, 3.5);
-            p.line(12.0, 4.0, 13.5, 2.5);
-        }
-        Pause => {
-            p.fill_rect(4.0, 3.0, 6.5, 13.0, 0.5);
-            p.fill_rect(9.5, 3.0, 12.0, 13.0, 0.5);
-        }
-        Vote => {
-            p.rect(2.5, 8.5, 13.5, 13.5, 1.0);
-            p.poly(&[(5.5, 8.5), (5.5, 2.5), (10.5, 2.5), (10.5, 8.5)], false);
-            p.poly(&[(6.6, 5.6), (7.7, 6.7), (9.4, 4.6)], false);
-        }
-        Measure => {
-            p.line(2.5, 4.0, 2.5, 12.0);
-            p.line(13.5, 4.0, 13.5, 12.0);
-            p.line(3.0, 8.0, 13.0, 8.0);
-            p.poly(&[(5.5, 5.5), (3.0, 8.0), (5.5, 10.5)], false);
-            p.poly(&[(10.5, 5.5), (13.0, 8.0), (10.5, 10.5)], false);
-        }
-        Logo => {
-            // FigCraft's own mark: the curled tail of the chameleon on the app icon. One bold
-            // stroke: a shaft along the bottom, then three half turns, each tighter than the last.
-            let mut tail = vec![(13.75, 13.0)];
-            tail.extend(arc_pts(7.25, 8.0, 5.0, FRAC_PI_2, 3.0 * FRAC_PI_2));
-            tail.extend(arc_pts(7.25, 6.5, 3.5, 3.0 * FRAC_PI_2, 5.0 * FRAC_PI_2));
-            tail.extend(arc_pts(7.25, 8.25, 1.75, FRAC_PI_2, 3.0 * FRAC_PI_2));
-            let v: Vec<Pos2> = tail.iter().map(|&(x, y)| p.raw(x, y)).collect();
-            p.painter.add(Shape::line(v, Stroke::new(1.7 * p.s, p.color)));
-            p.dot(13.75, 13.0, 0.85);
-            p.dot(7.25, 6.5, 0.85);
-        }
-    }
-}
-
 /// Allocate a square icon button; returns the response. `active` paints the selected look.
 pub fn button(ui: &mut egui::Ui, icon: Icon, size: f32, active: bool, tooltip: &str) -> egui::Response {
     let t = crate::theme::Tokens::get(ui.ctx());
@@ -1316,37 +314,6 @@ pub fn file_mark(kind: figcraft_doc::FileKind) -> Icon {
     }
 }
 
-/// SVG path data outlines on a `size`-unit box, painted into `rect`: each part filled, or
-/// stroked `width` box units wide. Board shapes and stamp marks are drawn this way in the UI from
-/// the same outlines the canvas has.
-pub fn paint_outlines(painter: &Painter, rect: Rect, size: f64, parts: &[(&figcraft_geom::BezPath, bool)], color: Color32, width: f32) {
-    let s = rect.width().min(rect.height()) / size as f32;
-    let px = 1.0 / painter.ctx().pixels_per_point();
-    let o = rect.center() - Vec2::splat(size as f32 * s / 2.0);
-    let p = P { painter, o, s, px, stroke: Stroke::new((width * s).max(px), color), color };
-    for (path, filled) in parts {
-        let mut sub: Vec<(f32, f32)> = Vec::new();
-        let flush = |sub: &mut Vec<(f32, f32)>, closed: bool| {
-            if sub.len() >= 2 {
-                if *filled { p.fill(sub) } else { p.path(sub, closed) }
-            }
-            sub.clear();
-        };
-        let mut closed = false;
-        figcraft_geom::kurbo::flatten(path.iter(), 0.25, |el| match el {
-            figcraft_geom::kurbo::PathEl::MoveTo(q) => {
-                flush(&mut sub, closed);
-                closed = false;
-                sub.push((q.x as f32, q.y as f32));
-            }
-            figcraft_geom::kurbo::PathEl::LineTo(q) => sub.push((q.x as f32, q.y as f32)),
-            figcraft_geom::kurbo::PathEl::ClosePath => closed = true,
-            _ => {}
-        });
-        flush(&mut sub, closed);
-    }
-}
-
 /// Every icon at the sizes the UI uses, labelled: for reviewing the set (`ui.set {iconGallery}`).
 pub fn gallery(ctx: &egui::Context) {
     let t = crate::theme::Tokens::get(ctx);
diff --git a/crates/ui-egui/src/icons/draw.rs b/crates/ui-egui/src/icons/draw.rs
new file mode 100644
index 00000000..1d088c91
--- /dev/null
+++ b/crates/ui-egui/src/icons/draw.rs
@@ -0,0 +1,1038 @@
+use super::*;
+
+struct P<'a> {
+    painter: &'a Painter,
+    o: Pos2,
+    s: f32,
+    /// One physical pixel, in points.
+    px: f32,
+    stroke: Stroke,
+    color: Color32,
+}
+
+impl P<'_> {
+    fn raw(&self, x: f32, y: f32) -> Pos2 {
+        pos2(self.o.x + x * self.s, self.o.y + y * self.s)
+    }
+    /// A stroke coordinate on the pixel grid: centred on a pixel for odd widths, on an edge for even.
+    fn snap_c(&self, v: f32) -> f32 {
+        let odd = (self.stroke.width / self.px).round() as i32 % 2 == 1;
+        let off = if odd { 0.5 } else { 0.0 };
+        ((v / self.px - off).round() + off) * self.px
+    }
+    /// A fill edge on the pixel grid.
+    fn snap_e(&self, v: f32) -> f32 {
+        (v / self.px).round() * self.px
+    }
+    /// A hinted stroke vertex.
+    fn sp(&self, x: f32, y: f32) -> Pos2 {
+        let q = self.raw(x, y);
+        pos2(self.snap_c(q.x), self.snap_c(q.y))
+    }
+    /// A straight stroke; axis-aligned ones are hinted (crossways onto pixel centres, lengthways
+    /// onto pixel edges so they end sharp).
+    fn line(&self, x0: f32, y0: f32, x1: f32, y1: f32) {
+        let (a, b) = (self.raw(x0, y0), self.raw(x1, y1));
+        let (a, b) = if y0 == y1 {
+            let y = self.snap_c(a.y);
+            (pos2(self.snap_e(a.x), y), pos2(self.snap_e(b.x), y))
+        } else if x0 == x1 {
+            let x = self.snap_c(a.x);
+            (pos2(x, self.snap_e(a.y)), pos2(x, self.snap_e(b.y)))
+        } else {
+            (a, b)
+        };
+        self.painter.line_segment([a, b], self.stroke);
+    }
+    /// A polyline of straight segments through hinted vertices.
+    fn poly(&self, pts: &[(f32, f32)], closed: bool) {
+        let v: Vec<Pos2> = pts.iter().map(|&(x, y)| self.sp(x, y)).collect();
+        self.stroke_pts(v, closed);
+    }
+    /// A path with curves (arcs, capsules): drawn as given, unhinted.
+    fn path(&self, pts: &[(f32, f32)], closed: bool) {
+        let v: Vec<Pos2> = pts.iter().map(|&(x, y)| self.raw(x, y)).collect();
+        self.stroke_pts(v, closed);
+    }
+    fn stroke_pts(&self, v: Vec<Pos2>, closed: bool) {
+        if closed {
+            self.painter.add(Shape::closed_line(v, self.stroke));
+        } else {
+            self.painter.add(Shape::line(v, self.stroke));
+        }
+    }
+    /// A filled polygon, convex or not.
+    fn fill(&self, pts: &[(f32, f32)]) {
+        let v: Vec<Pos2> = pts.iter().map(|&(x, y)| self.raw(x, y)).collect();
+        let n = v.len();
+        let turn = |i: usize| {
+            let (a, b, c) = (v[i], v[(i + 1) % n], v[(i + 2) % n]);
+            (b - a).x * (c - b).y - (b - a).y * (c - b).x
+        };
+        let convex = n >= 3 && ((0..n).all(|i| turn(i) >= 0.0) || (0..n).all(|i| turn(i) <= 0.0));
+        if convex {
+            self.painter.add(Shape::convex_polygon(v, self.color, Stroke::NONE));
+            return;
+        }
+        let indices = triangulate(&v);
+        if !indices.is_empty() {
+            let mut mesh = Mesh::default();
+            for p in &v {
+                mesh.colored_vertex(*p, self.color);
+            }
+            mesh.indices = indices;
+            self.painter.add(Shape::mesh(mesh));
+        }
+        // A hairline around the mesh gives it the same soft edge as the convex fills.
+        self.painter.add(Shape::closed_line(v, Stroke::new(self.px, self.color)));
+    }
+    /// Triangles `tris` over `verts` (x, y, alpha): the colour fades between the vertices.
+    fn shade(&self, verts: &[(f32, f32, f32)], tris: &[u32]) {
+        let mut mesh = Mesh::default();
+        for &(x, y, a) in verts {
+            mesh.colored_vertex(self.raw(x, y), self.color.gamma_multiply(a));
+        }
+        mesh.indices = tris.to_vec();
+        self.painter.add(Shape::mesh(mesh));
+    }
+    /// A disc of radius `r` at the centre, as a fan from the top, clockwise: each slice's rim
+    /// alphas from `rim` and its centre's from `centre`, both of how far round it is (0..1).
+    fn shade_fan(&self, r: f32, centre: impl Fn(f32) -> f32, rim: impl Fn(f32) -> f32) {
+        const SLICES: u32 = 32;
+        let at = |t: f32| {
+            let a = -FRAC_PI_2 + t * TAU;
+            (8.0 + r * a.cos(), 8.0 + r * a.sin())
+        };
+        let mut verts = Vec::new();
+        for i in 0..SLICES {
+            let (t0, t1) = (i as f32 / SLICES as f32, (i + 1) as f32 / SLICES as f32);
+            let ((x0, y0), (x1, y1)) = (at(t0), at(t1));
+            verts.extend([(8.0, 8.0, centre((t0 + t1) / 2.0)), (x0, y0, rim(t0)), (x1, y1, rim(t1))]);
+        }
+        let tris: Vec<u32> = (0..SLICES * 3).collect();
+        self.shade(&verts, &tris);
+    }
+    fn rect(&self, x0: f32, y0: f32, x1: f32, y1: f32, r: f32) {
+        let rr = Rect::from_min_max(self.sp(x0, y0), self.sp(x1, y1));
+        self.painter.rect_stroke(rr, egui::CornerRadius::same((r * self.s).round() as u8), self.stroke, egui::StrokeKind::Middle);
+    }
+    fn fill_rect(&self, x0: f32, y0: f32, x1: f32, y1: f32, r: f32) {
+        let (a, b) = (self.raw(x0, y0), self.raw(x1, y1));
+        let rr = Rect::from_min_max(pos2(self.snap_e(a.x), self.snap_e(a.y)), pos2(self.snap_e(b.x), self.snap_e(b.y)));
+        self.painter.rect_filled(rr, egui::CornerRadius::same((r * self.s).round() as u8), self.color);
+    }
+    fn circle(&self, x: f32, y: f32, r: f32) {
+        self.painter.circle_stroke(self.raw(x, y), r * self.s, self.stroke);
+    }
+    fn dot(&self, x: f32, y: f32, r: f32) {
+        self.painter.circle_filled(self.raw(x, y), r * self.s, self.color);
+    }
+    fn arc(&self, cx: f32, cy: f32, r: f32, a0: f32, a1: f32) {
+        self.path(&arc_pts(cx, cy, r, a0, a1).collect::<Vec<_>>(), false);
+    }
+    /// An open arrowhead at `tip` pointing along angle `dir`, arms `len` long.
+    fn head(&self, tip: (f32, f32), dir: f32, len: f32) {
+        let arm = |a: f32| (tip.0 + len * a.cos(), tip.1 + len * a.sin());
+        self.path(&[arm(dir + PI - FRAC_PI_4), tip, arm(dir + PI + FRAC_PI_4)], false);
+    }
+    /// An arc with an arrowhead at its end, pointing the way it runs.
+    fn arc_arrow(&self, cx: f32, cy: f32, r: f32, a0: f32, a1: f32) {
+        self.arc(cx, cy, r, a0, a1);
+        let tip = (cx + r * a1.cos(), cy + r * a1.sin());
+        let dir = a1 + if a1 > a0 { FRAC_PI_2 } else { -FRAC_PI_2 };
+        self.head(tip, dir, 2.6);
+    }
+    /// A rounded corner mark: an L at (`x`, `y`) opening towards (`dx`, `dy`), `len` long.
+    fn corner(&self, x: f32, y: f32, dx: f32, dy: f32, len: f32, r: f32) {
+        let a0 = 0.0f32.atan2(-dx);
+        let mut a1 = (-dy).atan2(0.0);
+        if a1 - a0 > PI {
+            a1 -= TAU;
+        } else if a0 - a1 > PI {
+            a1 += TAU;
+        }
+        let mut c = vec![(x, y + len * dy)];
+        c.extend(arc_pts(x + r * dx, y + r * dy, r, a0, a1));
+        c.push((x + len * dx, y));
+        self.path(&c, false);
+    }
+    /// Short dashes along the outline of a box (`n` per side).
+    fn dashed_box(&self, x0: f32, y0: f32, x1: f32, y1: f32, n: usize) {
+        let seg = |a: f32, b: f32, i: usize| {
+            let step = (b - a) / (2 * n - 1) as f32;
+            (a + 2.0 * i as f32 * step, a + (2 * i + 1) as f32 * step)
+        };
+        for i in 0..n {
+            let (a, b) = seg(x0 - 0.5, x1 + 0.5, i);
+            self.line(a, y0, b, y0);
+            self.line(a, y1, b, y1);
+            let (a, b) = seg(y0 - 0.5, y1 + 0.5, i);
+            self.line(x0, a, x0, b);
+            self.line(x1, a, x1, b);
+        }
+    }
+}
+
+/// Paint `icon` centred in `rect` (a 16-unit glyph scaled to fit) in `color`.
+pub fn paint(painter: &Painter, rect: Rect, icon: Icon, color: Color32) {
+    let ppp = painter.ctx().pixels_per_point();
+    let px = 1.0 / ppp;
+    // Physical pixels per grid unit: whole steps from 16 px up (quarter steps on fractional
+    // display scales), the exact fit below.
+    let k = rect.width().min(rect.height()) * ppp / 16.0;
+    let k = if k >= 1.0 { (k * 4.0).floor() / 4.0 } else { k };
+    let s = k * px;
+    let snap = |v: f32| (v * ppp).round() * px;
+    let o = rect.center() - vec2(8.0 * s, 8.0 * s);
+    let o = pos2(snap(o.x), snap(o.y));
+    let w = (k * 0.9).round().max(1.0) * px;
+    let p = P { painter, o, s, px, stroke: Stroke::new(w, color), color };
+    draw(&p, icon);
+}
+
+/// Draw `icon` on the 16-unit grid through `p`, which maps grid units to the target box.
+fn draw(p: &P, icon: Icon) {
+    use Icon::*;
+    match icon {
+        Move => p.fill(&[(4.0, 2.0), (4.0, 13.6), (6.9, 10.9), (8.8, 14.8), (10.6, 14.0), (8.7, 10.2), (12.6, 10.2)]),
+        Scale => {
+            p.rect(2.5, 7.5, 8.5, 13.5, 0.0);
+            p.line(6.0, 10.0, 13.0, 3.0);
+            p.poly(&[(9.5, 2.5), (13.5, 2.5), (13.5, 6.5)], false);
+        }
+        Hand => {
+            // An open hand: four fingers (the middle one tallest), then the palm and the thumb.
+            for (x, top) in [(4.5, 5.0), (6.5, 3.5), (8.5, 4.0), (10.5, 5.5)] {
+                let mut f = vec![(x, 8.0)];
+                f.extend(arc_pts(x + 1.0, top, 1.0, PI, TAU));
+                f.push((x + 2.0, 8.0));
+                p.path(&f, false);
+            }
+            let mut h = vec![(12.5, 8.0), (12.5, 10.0)];
+            h.extend(arc_pts(9.5, 10.0, 3.0, 0.0, FRAC_PI_2));
+            h.extend([(8.0, 13.0), (3.0, 9.4)]);
+            h.extend(arc_pts(3.6, 8.6, 1.0, 2.2, 5.3));
+            h.push((4.5, 8.5));
+            p.path(&h, false);
+        }
+        Frame => {
+            // Inset a unit from the box: four long hinted strokes read heavier than the
+            // anti-aliased outlines beside them at full size (#737).
+            p.line(5.5, 3.0, 5.5, 13.0);
+            p.line(10.5, 3.0, 10.5, 13.0);
+            p.line(3.0, 5.5, 13.0, 5.5);
+            p.line(3.0, 10.5, 13.0, 10.5);
+        }
+        Section | Section2 => {
+            p.rect(2.5, 5.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.0, 2.0, 9.0, 6.0, 1.0);
+        }
+        Slice => {
+            // A knife, one silhouette (#739): a slim blade to the top right, outlined like the
+            // rest of the row, and a solid handle whose end overlaps the blade's base so the two
+            // join at every size.
+            p.poly(&[(13.5, 2.5), (5.0, 8.0), (8.0, 11.0)], true);
+            p.fill(&capsule((2.8, 13.2), (5.9, 10.1), 1.3));
+        }
+        Bend => {
+            // A curve with a smooth point and its handle line.
+            let pts: Vec<(f32, f32)> = (0..=16)
+                .map(|i| {
+                    let t = i as f32 / 16.0;
+                    let u = 1.0 - t;
+                    (u * u * 2.5 + 2.0 * u * t * 8.0 + t * t * 13.5, u * u * 13.5 + 2.0 * u * t * 1.5 + t * t * 13.5)
+                })
+                .collect();
+            p.path(&pts, false);
+            p.line(3.0, 7.5, 13.0, 7.5);
+            p.dot(3.0, 7.5, 1.3);
+            p.dot(13.0, 7.5, 1.3);
+            p.fill_rect(7.0, 6.0, 9.0, 9.0, 0.0);
+        }
+        PaintBucket => {
+            p.poly(&[(2.5, 8.0), (7.5, 3.0), (12.5, 8.0), (7.5, 13.0)], true);
+            p.fill(&[(2.5, 8.0), (12.5, 8.0), (7.5, 13.0)]);
+            p.line(7.5, 3.0, 5.0, 0.5);
+            p.dot(13.5, 11.5, 1.5);
+        }
+        Lasso => {
+            p.path(&arc_pts(8.5, 6.5, 5.0, 0.0, TAU).map(|(x, y)| (x, 6.5 + (y - 6.5) * 0.7)).collect::<Vec<_>>(), true);
+            p.path(&[(5.0, 9.3), (4.5, 11.5), (6.0, 12.5), (4.5, 14.5)], false);
+        }
+        Cut => {
+            p.circle(4.5, 11.5, 2.0);
+            p.circle(11.5, 11.5, 2.0);
+            p.line(6.0, 10.0, 11.5, 2.5);
+            p.line(10.0, 10.0, 4.5, 2.5);
+        }
+        Rectangle => p.rect(2.5, 2.5, 13.5, 13.5, 1.0),
+        Line => p.line(2.5, 13.5, 13.5, 2.5),
+        Arrow => {
+            p.line(2.5, 13.5, 13.0, 3.0);
+            p.poly(&[(7.5, 2.5), (13.5, 2.5), (13.5, 8.5)], false);
+        }
+        Ellipse => p.circle(8.0, 8.0, 5.5),
+        Polygon => p.poly(&[(8.0, 2.5), (13.5, 12.5), (2.5, 12.5)], true),
+        Star => {
+            let pts: Vec<(f32, f32)> = (0..10)
+                .map(|i| {
+                    let a = -FRAC_PI_2 + PI * i as f32 / 5.0;
+                    let r = if i % 2 == 0 { 6.0 } else { 2.7 };
+                    (8.0 + r * a.cos(), 8.6 + r * a.sin())
+                })
+                .collect();
+            p.path(&pts, true);
+        }
+        Image => {
+            p.rect(2.5, 3.5, 13.5, 12.5, 1.0);
+            p.poly(&[(2.5, 11.5), (6.0, 8.0), (9.0, 11.0), (10.5, 9.5), (13.5, 12.5)], false);
+            p.dot(10.5, 6.5, 1.1);
+        }
+        Pen => {
+            p.poly(&[(8.0, 2.0), (12.5, 8.5), (10.5, 13.5), (5.5, 13.5), (3.5, 8.5)], true);
+            p.line(8.0, 2.0, 8.0, 7.0);
+            p.dot(8.0, 8.8, 1.2);
+        }
+        Pencil => {
+            p.poly(&[(2.5, 13.5), (3.2, 10.3), (10.5, 3.0), (13.0, 5.5), (5.7, 12.8)], true);
+            p.line(9.0, 4.5, 11.5, 7.0);
+        }
+        Text => {
+            // Inset like the Frame mark, so its long strokes don't outweigh the outlines (#737).
+            p.line(3.0, 3.5, 12.0, 3.5);
+            p.line(7.5, 3.0, 7.5, 12.5);
+            p.line(3.5, 3.0, 3.5, 5.5);
+            p.line(11.5, 3.0, 11.5, 5.5);
+            p.line(5.5, 12.5, 9.5, 12.5);
+        }
+        TextOnPath => {
+            // A small T above the curve it follows.
+            p.line(4.5, 3.0, 11.5, 3.0);
+            p.line(8.0, 3.0, 8.0, 8.5);
+            p.poly(&[(2.0, 13.5), (5.0, 11.5), (8.0, 10.8), (11.0, 11.5), (14.0, 13.5)], false);
+        }
+        Comment => {
+            let mut b: Vec<(f32, f32)> = arc_pts(8.5, 7.5, 5.0, 2.75, TAU + 1.95).collect();
+            b.push((2.5, 13.5));
+            p.path(&b, true);
+        }
+        Actions => p.poly(&[(9.0, 2.0), (3.5, 9.0), (7.5, 9.0), (6.5, 14.0), (12.5, 7.0), (8.5, 7.0)], true),
+        Chevron => p.poly(&[(4.5, 6.0), (8.0, 9.5), (11.5, 6.0)], false),
+        ChevronUp => p.poly(&[(4.5, 10.0), (8.0, 6.5), (11.5, 10.0)], false),
+        ChevronRight => p.poly(&[(6.0, 4.5), (9.5, 8.0), (6.0, 11.5)], false),
+        ChevronLeft => p.poly(&[(10.0, 4.5), (6.5, 8.0), (10.0, 11.5)], false),
+        Plus => {
+            p.line(7.5, 2.0, 7.5, 13.0);
+            p.line(2.0, 7.5, 13.0, 7.5);
+        }
+        Minus => p.line(2.0, 7.5, 13.0, 7.5),
+        Eye | EyeOff => {
+            // An almond (two arcs meeting at the corners) with the pupil.
+            let (r, cy, half) = (7.0f32, 7.5f32, 5.5f32);
+            let a = (half / r).asin();
+            let d = r * a.cos();
+            let mut e: Vec<(f32, f32)> = arc_pts(8.0, cy + d, r, -FRAC_PI_2 - a, -FRAC_PI_2 + a).collect();
+            e.extend(arc_pts(8.0, cy - d, r, FRAC_PI_2 - a, FRAC_PI_2 + a));
+            p.path(&e, true);
+            if icon == Eye {
+                p.circle(8.0, cy, 2.0);
+            } else {
+                p.line(3.0, 13.0, 13.0, 2.0);
+            }
+        }
+        Lock | Unlock => {
+            p.rect(3.5, 7.5, 12.5, 13.5, 1.0);
+            p.dot(8.0, 10.5, 1.0);
+            if icon == Lock {
+                p.line(5.5, 7.5, 5.5, 5.5);
+                p.line(10.5, 7.5, 10.5, 5.5);
+                p.arc(8.0, 5.5, 2.5, PI, TAU);
+            } else {
+                p.line(10.5, 7.5, 10.5, 4.5);
+                p.arc(13.0, 4.5, 2.5, PI, TAU);
+            }
+        }
+        Component => {
+            for (cx, cy) in [(8.0, 4.2), (11.8, 8.0), (8.0, 11.8), (4.2, 8.0)] {
+                p.fill(&[(cx, cy - 2.5), (cx + 2.5, cy), (cx, cy + 2.5), (cx - 2.5, cy)]);
+            }
+        }
+        ComponentSet => {
+            for (cx, cy) in [(8.0, 4.3), (11.7, 8.0), (8.0, 11.7), (4.3, 8.0)] {
+                p.path(&[(cx, cy - 2.2), (cx + 2.2, cy), (cx, cy + 2.2), (cx - 2.2, cy)], true);
+            }
+        }
+        Instance => p.path(&[(8.0, 2.0), (14.0, 8.0), (8.0, 14.0), (2.0, 8.0)], true),
+        Group => {
+            for (x, y, dx, dy) in [(2.5, 2.5, 1.0, 1.0), (13.5, 2.5, -1.0, 1.0), (2.5, 13.5, 1.0, -1.0), (13.5, 13.5, -1.0, -1.0)] {
+                p.poly(&[(x + 3.5 * dx, y), (x, y), (x, y + 3.5 * dy)], false);
+            }
+        }
+        Vector => {
+            p.path(&[(3.0, 12.5), (6.0, 4.0), (10.0, 12.0), (13.0, 3.5)], false);
+            p.fill_rect(1.5, 11.0, 4.5, 14.0, 0.0);
+            p.fill_rect(11.5, 2.0, 14.5, 5.0, 0.0);
+        }
+        Boolean | Union => {
+            p.rect(2.5, 2.5, 9.5, 9.5, 0.0);
+            p.rect(6.5, 6.5, 13.5, 13.5, 0.0);
+        }
+        Subtract => {
+            p.fill_rect(2.0, 2.0, 10.0, 10.0, 0.0);
+            p.rect(6.5, 6.5, 13.5, 13.5, 0.0);
+        }
+        Intersect => {
+            p.rect(2.5, 2.5, 9.5, 9.5, 0.0);
+            p.rect(6.5, 6.5, 13.5, 13.5, 0.0);
+            p.fill_rect(6.0, 6.0, 10.0, 10.0, 0.0);
+        }
+        Exclude => {
+            p.fill_rect(2.0, 2.0, 10.0, 6.0, 0.0);
+            p.fill_rect(2.0, 6.0, 6.0, 10.0, 0.0);
+            p.fill_rect(10.0, 6.0, 14.0, 14.0, 0.0);
+            p.fill_rect(6.0, 10.0, 10.0, 14.0, 0.0);
+            p.rect(6.5, 6.5, 9.5, 9.5, 0.0);
+        }
+        Page => {
+            p.poly(&[(3.5, 2.5), (9.5, 2.5), (12.5, 5.5), (12.5, 13.5), (3.5, 13.5)], true);
+            p.poly(&[(9.5, 2.5), (9.5, 5.5), (12.5, 5.5)], false);
+        }
+        Check => p.poly(&[(3.0, 8.5), (6.5, 12.0), (13.0, 4.5)], false),
+        Close => {
+            p.line(4.0, 4.0, 12.0, 12.0);
+            p.line(12.0, 4.0, 4.0, 12.0);
+        }
+        WinMinimize => p.line(3.0, 8.5, 13.0, 8.5),
+        WinMaximize => p.rect(3.5, 3.5, 12.5, 12.5, 0.0),
+        WinRestore => {
+            // A window in front of another.
+            p.rect(3.5, 5.5, 10.5, 12.5, 0.0);
+            p.poly(&[(5.5, 5.5), (5.5, 3.5), (12.5, 3.5), (12.5, 10.5), (10.5, 10.5)], false);
+        }
+        Search => {
+            p.circle(7.0, 7.0, 4.5);
+            p.line(10.5, 10.5, 14.0, 14.0);
+        }
+        Grid | LayoutGrid => {
+            for i in [2.5, 6.5, 10.5] {
+                for j in [2.5, 6.5, 10.5] {
+                    p.rect(i, j, i + 3.0, j + 3.0, 0.0);
+                }
+            }
+        }
+        AlignLeft => {
+            p.line(2.5, 2.0, 2.5, 14.0);
+            p.fill_rect(4.0, 4.0, 13.0, 7.0, 0.0);
+            p.fill_rect(4.0, 9.0, 9.0, 12.0, 0.0);
+        }
+        AlignHCenter => {
+            p.line(7.5, 2.0, 7.5, 14.0);
+            p.fill_rect(2.0, 4.0, 13.0, 7.0, 0.0);
+            p.fill_rect(4.0, 9.0, 11.0, 12.0, 0.0);
+        }
+        AlignRight => {
+            p.line(13.5, 2.0, 13.5, 14.0);
+            p.fill_rect(3.0, 4.0, 12.0, 7.0, 0.0);
+            p.fill_rect(7.0, 9.0, 12.0, 12.0, 0.0);
+        }
+        AlignTop => {
+            p.line(2.0, 2.5, 14.0, 2.5);
+            p.fill_rect(4.0, 4.0, 7.0, 13.0, 0.0);
+            p.fill_rect(9.0, 4.0, 12.0, 9.0, 0.0);
+        }
+        AlignVCenter => {
+            p.line(2.0, 7.5, 14.0, 7.5);
+            p.fill_rect(4.0, 2.0, 7.0, 13.0, 0.0);
+            p.fill_rect(9.0, 4.0, 12.0, 11.0, 0.0);
+        }
+        AlignBottom => {
+            p.line(2.0, 13.5, 14.0, 13.5);
+            p.fill_rect(4.0, 3.0, 7.0, 12.0, 0.0);
+            p.fill_rect(9.0, 7.0, 12.0, 12.0, 0.0);
+        }
+        DistributeH | Gap => {
+            p.line(2.5, 2.0, 2.5, 14.0);
+            p.line(13.5, 2.0, 13.5, 14.0);
+            p.fill_rect(6.0, 4.0, 10.0, 12.0, 0.0);
+        }
+        DistributeV => {
+            p.line(2.0, 2.5, 14.0, 2.5);
+            p.line(2.0, 13.5, 14.0, 13.5);
+            p.fill_rect(4.0, 6.0, 12.0, 10.0, 0.0);
+        }
+        Rotate => p.arc_arrow(8.0, 8.5, 5.0, -PI * 0.55, PI * 1.25),
+        Reset => p.arc_arrow(8.0, 8.5, 5.0, -PI * 0.45, -PI * 2.25),
+        FlipH => {
+            for y in [1.0, 5.0, 9.0, 13.0] {
+                p.line(7.5, y, 7.5, y + 2.0);
+            }
+            p.poly(&[(5.5, 3.5), (5.5, 12.5), (1.5, 12.5)], true);
+            p.fill(&[(9.0, 3.0), (14.0, 13.0), (9.0, 13.0)]);
+        }
+        FlipV => {
+            for x in [1.0, 5.0, 9.0, 13.0] {
+                p.line(x, 7.5, x + 2.0, 7.5);
+            }
+            p.poly(&[(3.5, 5.5), (12.5, 5.5), (12.5, 1.5)], true);
+            p.fill(&[(3.0, 9.0), (13.0, 9.0), (13.0, 14.0)]);
+        }
+        CornerRadius | CornerTopLeft => p.corner(2.5, 2.5, 1.0, 1.0, 11.5, 6.0),
+        CornerTopRight => p.corner(13.5, 2.5, -1.0, 1.0, 11.5, 6.0),
+        CornerBottomRight => p.corner(13.5, 13.5, -1.0, -1.0, 11.5, 6.0),
+        CornerBottomLeft => p.corner(2.5, 13.5, 1.0, -1.0, 11.5, 6.0),
+        Angle => {
+            // Two rays from a vertex, the arc between them marking the angle (all unhinted, so
+            // the arc meets the rays at every size).
+            p.path(&[(13.5, 13.0), (2.5, 13.0), (10.5, 3.0)], false);
+            p.path(&arc_pts(2.5, 13.0, 6.0, (-10.0f32).atan2(8.0), 0.0).collect::<Vec<_>>(), false);
+        }
+        IndependentCorners => {
+            for (x, y, dx, dy) in [(2.5, 2.5, 1.0, 1.0), (13.5, 2.5, -1.0, 1.0), (2.5, 13.5, 1.0, -1.0), (13.5, 13.5, -1.0, -1.0)] {
+                p.corner(x, y, dx, dy, 4.0, 2.0);
+            }
+        }
+        IndependentPadding => {
+            // A frame outline with one inward tick per side: each side's padding, set alone.
+            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
+            p.line(8.0, 2.5, 8.0, 5.0);
+            p.line(13.5, 8.0, 11.0, 8.0);
+            p.line(8.0, 13.5, 8.0, 11.0);
+            p.line(2.5, 8.0, 5.0, 8.0);
+        }
+        LinkOn | Link => {
+            p.path(&capsule((4.0, 12.0), (6.5, 9.5), 2.4), true);
+            p.path(&capsule((9.5, 6.5), (12.0, 4.0), 2.4), true);
+            p.line(6.2, 9.8, 9.8, 6.2);
+        }
+        LinkOff => {
+            p.path(&capsule((3.5, 12.5), (5.5, 10.5), 2.2), true);
+            p.path(&capsule((10.5, 5.5), (12.5, 3.5), 2.2), true);
+            p.line(9.5, 12.0, 9.5, 14.0);
+            p.line(12.0, 9.5, 14.0, 9.5);
+            p.line(2.0, 6.5, 4.0, 6.5);
+            p.line(6.5, 2.0, 6.5, 4.0);
+        }
+        LayoutH => {
+            p.fill_rect(2.0, 3.0, 7.0, 13.0, 1.0);
+            p.fill_rect(9.0, 3.0, 14.0, 13.0, 1.0);
+        }
+        LayoutV => {
+            p.fill_rect(3.0, 2.0, 13.0, 7.0, 1.0);
+            p.fill_rect(3.0, 9.0, 13.0, 14.0, 1.0);
+        }
+        LayoutWrap => {
+            let mut w = vec![(2.0, 4.5), (10.5, 4.5)];
+            w.extend(arc_pts(10.5, 7.5, 3.0, -FRAC_PI_2, FRAC_PI_2));
+            w.push((4.0, 10.5));
+            p.path(&w, false);
+            p.head((3.5, 10.5), PI, 2.8);
+        }
+        AutoLayout => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
+            p.fill_rect(5.0, 5.0, 7.0, 11.0, 0.0);
+            p.fill_rect(9.0, 5.0, 11.0, 11.0, 0.0);
+        }
+        ClipContent => {
+            p.rect(4.5, 4.5, 13.5, 13.5, 0.0);
+            p.line(2.5, 1.0, 2.5, 11.0);
+            p.line(1.0, 2.5, 11.0, 2.5);
+        }
+        Effects | Sun => {
+            p.circle(8.0, 8.0, if icon == Sun { 2.5 } else { 3.0 });
+            for i in 0..8 {
+                let a = i as f32 * FRAC_PI_4;
+                let (r0, r1) = if i % 2 == 0 { (4.8, 6.6) } else { (4.6, 5.8) };
+                p.line(8.0 + r0 * a.cos(), 8.0 + r0 * a.sin(), 8.0 + r1 * a.cos(), 8.0 + r1 * a.sin());
+            }
+        }
+        Styles => {
+            for (x, y) in [(5.0, 5.0), (11.0, 5.0), (5.0, 11.0), (11.0, 11.0)] {
+                p.dot(x, y, 2.2);
+            }
+        }
+        Menu => {
+            for y in [3.5, 7.5, 11.5] {
+                p.line(2.0, y, 14.0, y);
+            }
+        }
+        Play => p.fill(&[(4.5, 2.5), (13.5, 8.0), (4.5, 13.5)]),
+        Home => {
+            // Unhinted so the roof's peak stays centred; the floor stops at the door.
+            p.path(&[(6.5, 13.5), (3.5, 13.5), (3.5, 7.0), (8.0, 2.8), (12.5, 7.0), (12.5, 13.5), (9.5, 13.5)], false);
+            p.poly(&[(6.5, 13.5), (6.5, 9.5), (9.5, 9.5), (9.5, 13.5)], false);
+        }
+        Bell => {
+            let mut b = vec![(2.5, 11.5), (4.0, 10.0), (4.0, 7.0)];
+            b.extend(arc_pts(8.0, 7.0, 4.0, PI, TAU));
+            b.extend([(12.0, 10.0), (13.5, 11.5)]);
+            p.path(&b, true);
+            p.arc(8.0, 12.0, 1.8, 0.0, PI);
+        }
+        Panels => {
+            p.rect(2.5, 3.5, 13.5, 12.5, 1.0);
+            p.line(5.5, 4.0, 5.5, 12.0);
+            p.line(10.5, 4.0, 10.5, 12.0);
+        }
+        Help => {
+            p.circle(8.0, 8.0, 6.0);
+            p.arc(8.0, 6.4, 2.0, PI * 1.05, TAU + 0.7);
+            p.path(&[(9.5, 7.7), (8.0, 8.8), (8.0, 9.8)], false);
+            p.dot(8.0, 11.6, 0.9);
+        }
+        Dots => {
+            for x in [3.5, 8.0, 12.5] {
+                p.dot(x, 8.0, 1.25);
+            }
+        }
+        Mask | Opacity => {
+            p.circle(8.0, 8.0, 5.5);
+            let side = if icon == Mask { -FRAC_PI_2 } else { FRAC_PI_2 };
+            p.fill(&arc_pts(8.0, 8.0, 5.5, side, side + PI).collect::<Vec<_>>());
+        }
+        TextAlignLeft => {
+            for (y, x1) in [(3.5, 14.0), (6.5, 10.0), (9.5, 14.0), (12.5, 9.0)] {
+                p.line(2.0, y, x1, y);
+            }
+        }
+        TextAlignCenter => {
+            for (y, h) in [(3.5, 6.0), (6.5, 4.0), (9.5, 6.0), (12.5, 3.0)] {
+                p.line(8.0 - h, y, 8.0 + h, y);
+            }
+        }
+        TextAlignRight => {
+            for (y, x0) in [(3.5, 2.0), (6.5, 6.0), (9.5, 2.0), (12.5, 7.0)] {
+                p.line(x0, y, 14.0, y);
+            }
+        }
+        TextAlignJustify => {
+            for y in [3.5, 6.5, 9.5, 12.5] {
+                p.line(2.0, y, 14.0, y);
+            }
+        }
+        TextTop => {
+            p.line(2.0, 2.5, 14.0, 2.5);
+            p.line(7.5, 5.0, 7.5, 14.0);
+            p.head((7.5, 5.0), -FRAC_PI_2, 3.2);
+        }
+        TextMiddle => {
+            p.line(2.0, 7.5, 14.0, 7.5);
+            p.line(7.5, 1.0, 7.5, 5.0);
+            p.head((7.5, 5.0), FRAC_PI_2, 2.6);
+            p.line(7.5, 10.0, 7.5, 14.0);
+            p.head((7.5, 10.0), -FRAC_PI_2, 2.6);
+        }
+        TextBottom => {
+            p.line(2.0, 13.5, 14.0, 13.5);
+            p.line(7.5, 2.0, 7.5, 11.0);
+            p.head((7.5, 11.0), FRAC_PI_2, 3.2);
+        }
+        Eyedropper => {
+            p.poly(&[(2.5, 13.5), (3.0, 11.0), (8.5, 5.5), (10.5, 7.5), (5.0, 13.0)], true);
+            p.path(&capsule((10.5, 5.5), (12.0, 4.0), 1.6), true);
+            p.line(7.5, 4.5, 11.5, 8.5);
+        }
+        Code => {
+            p.poly(&[(5.5, 4.0), (2.0, 8.0), (5.5, 12.0)], false);
+            p.poly(&[(10.5, 4.0), (14.0, 8.0), (10.5, 12.0)], false);
+            p.line(9.0, 3.0, 7.0, 13.0);
+        }
+        Assets => {
+            p.path(&[(5.0, 2.0), (8.0, 5.0), (5.0, 8.0), (2.0, 5.0)], true);
+            p.circle(11.0, 5.0, 2.5);
+            p.rect(2.5, 9.5, 7.5, 13.5, 0.0);
+            p.poly(&[(11.0, 9.0), (13.5, 13.5), (8.5, 13.5)], true);
+        }
+        Library => {
+            p.poly(&[(7.5, 4.5), (5.5, 3.5), (1.5, 3.5), (1.5, 12.5), (5.5, 12.5), (7.5, 13.5)], false);
+            p.poly(&[(8.5, 4.5), (10.5, 3.5), (14.5, 3.5), (14.5, 12.5), (10.5, 12.5), (8.5, 13.5)], false);
+            p.line(7.5, 4.5, 7.5, 13.5);
+            p.line(8.5, 4.5, 8.5, 13.5);
+        }
+        Layers => {
+            p.poly(&[(8.0, 2.5), (14.0, 5.5), (8.0, 8.5), (2.0, 5.5)], true);
+            p.poly(&[(2.0, 8.0), (8.0, 11.0), (14.0, 8.0)], false);
+            p.poly(&[(2.0, 10.5), (8.0, 13.5), (14.0, 10.5)], false);
+        }
+        Blend => {
+            p.circle(6.0, 8.0, 4.0);
+            p.circle(10.0, 8.0, 4.0);
+        }
+        Export => {
+            p.line(7.5, 2.0, 7.5, 10.0);
+            p.head((7.5, 2.0), -FRAC_PI_2, 3.5);
+            p.poly(&[(2.5, 8.5), (2.5, 13.5), (12.5, 13.5), (12.5, 8.5)], false);
+        }
+        StrokeIcon => p.rect(2.5, 2.5, 13.5, 13.5, 2.0),
+        Fill => p.fill_rect(2.0, 2.0, 14.0, 14.0, 2.0),
+        GradientLinear => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
+            p.shade(&[(4.0, 4.0, 1.0), (12.0, 4.0, 0.0), (12.0, 12.0, 0.0), (4.0, 12.0, 1.0)], &[0, 1, 2, 0, 2, 3]);
+        }
+        GradientRadial => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
+            p.shade_fan(5.5, |_| 1.0, |_| 0.0);
+        }
+        GradientAngular => {
+            // Once round from the top: the seam shows where the sweep starts.
+            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
+            p.shade_fan(4.0, |t| 1.0 - t, |t| 1.0 - t);
+        }
+        GradientDiamond => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 2.0);
+            let v = [(8.0, 8.0, 1.0), (8.0, 2.5, 0.0), (13.5, 8.0, 0.0), (8.0, 13.5, 0.0), (2.5, 8.0, 0.0)];
+            p.shade(&v, &[0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 1]);
+        }
+        Moon => {
+            // A crescent: the outer rim, then the shadowing circle's edge back. Both arcs stop short
+            // of where the circles meet, so each tip is two blunt joins (a single cusp join folds).
+            let mut m: Vec<(f32, f32)> = arc_pts(8.0, 8.0, 5.5, 0.166 + 0.12, TAU - 1.737 - 0.12).collect();
+            m.extend(arc_pts(11.0, 5.0, 4.6, -2.586 - 0.18, 1.016 - TAU + 0.18));
+            p.path(&m, true);
+        }
+        Undo | Redo => {
+            // A U-turn arrow: back along the top, round, and out along the bottom.
+            let undo = icon == Undo;
+            let f = |x: f32| if undo { x } else { 16.0 - x };
+            let mut u = vec![(f(3.0), 5.5), (f(9.5), 5.5)];
+            let a1 = if undo { FRAC_PI_2 } else { -3.0 * FRAC_PI_2 };
+            u.extend(arc_pts(f(9.5), 9.0, 3.5, -FRAC_PI_2, a1));
+            u.push((f(6.0), 12.5));
+            p.path(&u, false);
+            p.head((f(3.0), 5.5), if undo { PI } else { 0.0 }, 3.0);
+        }
+        Hug => {
+            p.poly(&[(2.5, 4.5), (5.5, 7.5), (2.5, 10.5)], false);
+            p.poly(&[(13.5, 4.5), (10.5, 7.5), (13.5, 10.5)], false);
+            p.line(6.0, 7.5, 10.0, 7.5);
+        }
+        FillContainer => {
+            p.poly(&[(5.0, 4.5), (2.0, 7.5), (5.0, 10.5)], false);
+            p.poly(&[(11.0, 4.5), (14.0, 7.5), (11.0, 10.5)], false);
+            p.line(2.0, 7.5, 14.0, 7.5);
+        }
+        Fixed => {
+            p.line(2.5, 4.0, 2.5, 11.0);
+            p.line(13.5, 4.0, 13.5, 11.0);
+            p.line(3.0, 7.5, 13.0, 7.5);
+        }
+        PaddingH => {
+            // Horizontal padding: bars down the padded left and right sides in their frame.
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 2.5, 5.5, 13.5, 1.0);
+            p.fill_rect(10.5, 2.5, 13.5, 13.5, 1.0);
+        }
+        PaddingV => {
+            // Vertical padding: bars across the padded top and bottom in their frame.
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 2.5, 13.5, 5.5, 1.0);
+            p.fill_rect(2.5, 10.5, 13.5, 13.5, 1.0);
+        }
+        PaddingTop => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 2.5, 13.5, 5.5, 1.0);
+        }
+        PaddingRight => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(10.5, 2.5, 13.5, 13.5, 1.0);
+        }
+        PaddingBottom => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 10.5, 13.5, 13.5, 1.0);
+        }
+        PaddingLeft => {
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(2.5, 2.5, 5.5, 13.5, 1.0);
+        }
+        Online => {
+            p.circle(8.0, 8.0, 5.5);
+            p.line(2.5, 8.0, 13.5, 8.0);
+            let meridian: Vec<(f32, f32)> = arc_pts(0.0, 0.0, 1.0, 0.0, TAU).map(|(x, y)| (8.0 + 2.4 * x, 8.0 + 5.5 * y)).collect();
+            p.path(&meridian, true);
+        }
+        LiveShared => {
+            p.dot(8.0, 8.0, 1.6);
+            for r in [3.6, 6.0] {
+                p.arc(8.0, 8.0, r, -FRAC_PI_4, FRAC_PI_4);
+                p.arc(8.0, 8.0, r, PI - FRAC_PI_4, PI + FRAC_PI_4);
+            }
+        }
+        LivePrivate => {
+            p.dot(8.0, 8.0, 1.6);
+            p.circle(8.0, 8.0, 5.0);
+        }
+        Clock => {
+            p.circle(7.5, 7.5, 5.5);
+            p.line(7.5, 4.0, 7.5, 8.0);
+            p.line(7.5, 7.5, 10.0, 10.0);
+        }
+        ShapeBuilder | ShapeBuilderRemove => {
+            // Two overlapping rings; their shared lens filled (merge) or crossed out (remove).
+            let (r, d) = (4.5f32, 2.0f32);
+            let a = (d / r).acos();
+            p.circle(8.0 - d, 8.0, r);
+            p.circle(8.0 + d, 8.0, r);
+            if icon == ShapeBuilder {
+                let lens: Vec<(f32, f32)> = arc_pts(8.0 - d, 8.0, r, -a, a).chain(arc_pts(8.0 + d, 8.0, r, PI - a, PI + a)).collect();
+                p.fill(&lens);
+            } else {
+                p.line(6.2, 9.8, 9.8, 6.2);
+            }
+        }
+        Eraser => {
+            // A tilted block with a band near its tip, over a short trace line.
+            p.poly(&[(2.5, 10.0), (9.5, 3.0), (13.5, 7.0), (7.0, 13.5), (6.0, 13.5)], true);
+            p.line(5.5, 7.0, 9.5, 11.0);
+            p.line(7.0, 13.5, 14.0, 13.5);
+        }
+        VariableWidth => {
+            // A lens-shaped stroke, thin at both ends, and a width handle on either side of its
+            // widest point.
+            let edge = |i: i32, side: f32| {
+                let f = i as f32 / 12.0;
+                (2.0 + 11.0 * f, 7.5 + side * 3.0 * (PI * f).sin())
+            };
+            let lens: Vec<(f32, f32)> = (0..=12).map(|i| edge(i, -1.0)).chain((0..=12).rev().map(|i| edge(i, 1.0))).collect();
+            p.fill(&lens);
+            p.line(7.5, 2.0, 7.5, 13.0);
+            p.dot(7.5, 2.0, 1.5);
+            p.dot(7.5, 13.0, 1.5);
+        }
+        Variable => {
+            // A hexagon with a dot: an original mark for "bind a value".
+            let pts: Vec<(f32, f32)> = (0..6)
+                .map(|i| {
+                    let a = std::f32::consts::FRAC_PI_3 * i as f32 + std::f32::consts::FRAC_PI_6;
+                    (8.0 + 6.0 * a.cos(), 8.0 + 6.0 * a.sin())
+                })
+                .collect();
+            p.path(&pts, true);
+            p.dot(8.0, 8.0, 1.7);
+        }
+        Detach => {
+            p.path(&[(8.0, 2.0), (14.0, 8.0), (8.0, 14.0), (2.0, 8.0)], true);
+            p.line(3.0, 13.0, 13.0, 3.0);
+        }
+        Swap => {
+            p.line(2.0, 4.5, 13.0, 4.5);
+            p.head((13.0, 4.5), 0.0, 2.8);
+            p.line(3.0, 11.5, 14.0, 11.5);
+            p.head((3.0, 11.5), PI, 2.8);
+        }
+        Prototype => {
+            p.circle(4.5, 11.5, 2.0);
+            p.line(6.0, 10.0, 13.0, 3.0);
+            p.poly(&[(8.5, 2.5), (13.5, 2.5), (13.5, 7.5)], false);
+        }
+        Preview => {
+            // A window with a title strip and a play triangle in it.
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.line(3.0, 5.5, 13.0, 5.5);
+            p.fill(&[(6.5, 7.5), (10.5, 10.0), (6.5, 12.5)]);
+        }
+        AbsolutePosition => {
+            // The frame, a small layer near its top-right corner, and the two offsets pinning it.
+            p.rect(2.5, 2.5, 13.5, 13.5, 1.0);
+            p.fill_rect(6.0, 6.0, 10.0, 10.0, 0.0);
+            p.line(10.0, 7.5, 13.0, 7.5);
+            p.line(7.5, 3.0, 7.5, 6.0);
+        }
+        Slot => {
+            p.dashed_box(2.5, 2.5, 12.5, 12.5, 3);
+            p.line(7.5, 5.0, 7.5, 10.0);
+            p.line(5.0, 7.5, 10.0, 7.5);
+        }
+        Adjust => {
+            p.line(2.0, 4.5, 14.0, 4.5);
+            p.line(2.0, 11.5, 14.0, 11.5);
+            p.dot(10.5, 4.5, 2.2);
+            p.dot(5.5, 11.5, 2.2);
+        }
+        ViewList => {
+            for y in [2.0, 6.0, 10.0] {
+                p.fill_rect(2.0, y, 5.0, y + 3.0, 0.0);
+                p.line(7.0, y + 1.5, 14.0, y + 1.5);
+            }
+        }
+        Reaction => {
+            p.circle(8.0, 8.0, 5.5);
+            p.dot(6.0, 6.5, 0.9);
+            p.dot(10.0, 6.5, 0.9);
+            p.arc(8.0, 8.5, 3.0, 0.6, PI - 0.6);
+        }
+        DragHandle => {
+            for y in [4.0, 8.0, 12.0] {
+                p.dot(6.0, y, 1.1);
+                p.dot(10.0, y, 1.1);
+            }
+        }
+        ViewGrid => {
+            for (x, y) in [(2.5, 2.5), (9.5, 2.5), (2.5, 9.5), (9.5, 9.5)] {
+                p.rect(x, y, x + 4.0, y + 4.0, 1.0);
+            }
+        }
+        ArcStart => {
+            p.circle(8.0, 8.0, 5.5);
+            p.line(8.0, 8.0, 13.5, 8.0);
+            p.dot(13.5, 8.0, 1.6);
+        }
+        ArcSweep => {
+            let mut wedge = vec![(8.0, 8.0)];
+            wedge.extend(arc_pts(8.0, 8.0, 5.5, 0.0, 1.5 * PI));
+            p.path(&wedge, true);
+        }
+        ArcRatio => {
+            p.circle(8.0, 8.0, 5.5);
+            p.circle(8.0, 8.0, 2.5);
+        }
+        GamutWarning => {
+            p.poly(&[(8.0, 2.0), (14.5, 13.5), (1.5, 13.5)], true);
+            p.line(8.0, 6.0, 8.0, 9.5);
+            p.dot(8.0, 11.5, 0.9);
+        }
+        PenNib => {
+            // Drawn pointing down, then leant 35° to the left about the middle.
+            let (sin, cos) = (0.61f32, 0.79f32);
+            let at = |x: f32, y: f32| (8.0 + x * cos - y * sin, 8.0 + x * sin + y * cos);
+            let nib: Vec<(f32, f32)> = [(0.0, 6.5), (3.4, 1.0), (2.4, -2.5), (-2.4, -2.5), (-3.4, 1.0)].iter().map(|&(x, y)| at(x, y)).collect();
+            p.path(&nib, true);
+            let (a, b) = (at(0.0, 6.5), at(0.0, 2.0));
+            p.path(&[a, b], false);
+            let (dx, dy) = at(0.0, 0.6);
+            p.dot(dx, dy, 1.0);
+            let grip: Vec<(f32, f32)> = [(-2.4, -3.4), (2.4, -3.4), (2.4, -5.6), (-2.4, -5.6)].iter().map(|&(x, y)| at(x, y)).collect();
+            p.fill(&grip);
+        }
+        Board => {
+            p.poly(&[(2.5, 2.5), (13.5, 2.5), (13.5, 9.5), (9.5, 13.5), (2.5, 13.5)], true);
+            p.fill(&[(9.5, 13.5), (9.5, 9.5), (13.5, 9.5)]);
+            p.line(5.0, 6.5, 11.0, 6.5);
+            p.line(5.0, 9.5, 8.0, 9.5);
+        }
+        Templates => {
+            p.rect(1.5, 2.5, 14.5, 13.5, 1.5);
+            p.fill_rect(3.5, 4.5, 7.5, 8.5, 0.5);
+            p.line(9.5, 5.5, 12.5, 5.5);
+            p.line(9.5, 7.5, 12.5, 7.5);
+            p.line(3.5, 11.0, 12.5, 11.0);
+        }
+        Table => {
+            p.rect(1.5, 2.5, 14.5, 13.5, 1.0);
+            p.line(1.5, 6.5, 14.5, 6.5);
+            p.line(1.5, 10.0, 14.5, 10.0);
+            p.line(6.0, 2.5, 6.0, 13.5);
+            p.line(10.0, 2.5, 10.0, 13.5);
+        }
+        AddRow | RemoveRow => {
+            p.rect(1.5, 2.5, 14.5, 8.5, 1.0);
+            p.line(8.0, 2.5, 8.0, 8.5);
+            p.line(5.5, 12.5, 10.5, 12.5);
+            if icon == AddRow {
+                p.line(8.0, 10.0, 8.0, 15.0);
+            }
+        }
+        AddColumn | RemoveColumn => {
+            p.rect(2.5, 1.5, 8.5, 14.5, 1.0);
+            p.line(2.5, 8.0, 8.5, 8.0);
+            p.line(10.0, 8.0, 15.0, 8.0);
+            if icon == AddColumn {
+                p.line(12.5, 5.5, 12.5, 10.5);
+            }
+        }
+        Marker => {
+            p.poly(&[(3.0, 13.0), (3.0, 10.5), (10.0, 3.5), (12.5, 6.0), (5.5, 13.0)], true);
+            p.line(8.5, 5.0, 11.0, 7.5);
+            p.fill(&[(2.0, 14.0), (2.0, 11.5), (4.5, 14.0)]);
+        }
+        Highlighter => {
+            p.poly(&[(4.0, 10.0), (10.5, 3.5), (13.5, 6.5), (7.0, 13.0)], true);
+            p.poly(&[(4.0, 10.0), (2.5, 12.5), (4.5, 12.5), (7.0, 13.0)], false);
+            p.fill_rect(1.0, 14.0, 15.0, 15.5, 0.0);
+        }
+        Connector => {
+            p.rect(1.5, 1.5, 6.5, 6.5, 1.0);
+            p.rect(9.5, 9.5, 14.5, 14.5, 1.0);
+            p.poly(&[(6.5, 4.0), (12.0, 4.0), (12.0, 9.0)], false);
+            p.head((12.0, 9.0), FRAC_PI_2, 2.4);
+        }
+        CurvedConnector => {
+            p.rect(1.5, 1.5, 6.5, 6.5, 1.0);
+            p.rect(9.5, 9.5, 14.5, 14.5, 1.0);
+            p.arc(6.5, 9.0, 5.5, -FRAC_PI_2, 0.0);
+            p.head((12.0, 9.0), FRAC_PI_2, 2.4);
+        }
+        Shapes => {
+            p.rect(1.5, 5.5, 9.5, 13.5, 1.0);
+            p.circle(10.5, 5.5, 4.0);
+        }
+        Stamp => {
+            p.circle(8.0, 8.0, 6.0);
+            p.poly(&[(5.0, 8.3), (7.2, 10.5), (11.0, 6.0)], false);
+        }
+        Timer => {
+            p.circle(8.0, 9.0, 5.5);
+            p.line(8.0, 9.0, 8.0, 6.0);
+            p.line(6.0, 1.5, 10.0, 1.5);
+            p.line(8.0, 1.5, 8.0, 3.5);
+            p.line(12.0, 4.0, 13.5, 2.5);
+        }
+        Pause => {
+            p.fill_rect(4.0, 3.0, 6.5, 13.0, 0.5);
+            p.fill_rect(9.5, 3.0, 12.0, 13.0, 0.5);
+        }
+        Vote => {
+            p.rect(2.5, 8.5, 13.5, 13.5, 1.0);
+            p.poly(&[(5.5, 8.5), (5.5, 2.5), (10.5, 2.5), (10.5, 8.5)], false);
+            p.poly(&[(6.6, 5.6), (7.7, 6.7), (9.4, 4.6)], false);
+        }
+        Measure => {
+            p.line(2.5, 4.0, 2.5, 12.0);
+            p.line(13.5, 4.0, 13.5, 12.0);
+            p.line(3.0, 8.0, 13.0, 8.0);
+            p.poly(&[(5.5, 5.5), (3.0, 8.0), (5.5, 10.5)], false);
+            p.poly(&[(10.5, 5.5), (13.0, 8.0), (10.5, 10.5)], false);
+        }
+        Logo => {
+            // FigCraft's own mark: the curled tail of the chameleon on the app icon. One bold
+            // stroke: a shaft along the bottom, then three half turns, each tighter than the last.
+            let mut tail = vec![(13.75, 13.0)];
+            tail.extend(arc_pts(7.25, 8.0, 5.0, FRAC_PI_2, 3.0 * FRAC_PI_2));
+            tail.extend(arc_pts(7.25, 6.5, 3.5, 3.0 * FRAC_PI_2, 5.0 * FRAC_PI_2));
+            tail.extend(arc_pts(7.25, 8.25, 1.75, FRAC_PI_2, 3.0 * FRAC_PI_2));
+            let v: Vec<Pos2> = tail.iter().map(|&(x, y)| p.raw(x, y)).collect();
+            p.painter.add(Shape::line(v, Stroke::new(1.7 * p.s, p.color)));
+            p.dot(13.75, 13.0, 0.85);
+            p.dot(7.25, 6.5, 0.85);
+        }
+    }
+}
+
+/// SVG path data outlines on a `size`-unit box, painted into `rect`: each part filled, or
+/// stroked `width` box units wide. Board shapes and stamp marks are drawn this way in the UI from
+/// the same outlines the canvas has.
+pub fn paint_outlines(painter: &Painter, rect: Rect, size: f64, parts: &[(&figcraft_geom::BezPath, bool)], color: Color32, width: f32) {
+    let s = rect.width().min(rect.height()) / size as f32;
+    let px = 1.0 / painter.ctx().pixels_per_point();
+    let o = rect.center() - Vec2::splat(size as f32 * s / 2.0);
+    let p = P { painter, o, s, px, stroke: Stroke::new((width * s).max(px), color), color };
+    for (path, filled) in parts {
+        let mut sub: Vec<(f32, f32)> = Vec::new();
+        let flush = |sub: &mut Vec<(f32, f32)>, closed: bool| {
+            if sub.len() >= 2 {
+                if *filled { p.fill(sub) } else { p.path(sub, closed) }
+            }
+            sub.clear();
+        };
+        let mut closed = false;
+        figcraft_geom::kurbo::flatten(path.iter(), 0.25, |el| match el {
+            figcraft_geom::kurbo::PathEl::MoveTo(q) => {
+                flush(&mut sub, closed);
+                closed = false;
+                sub.push((q.x as f32, q.y as f32));
+            }
+            figcraft_geom::kurbo::PathEl::LineTo(q) => sub.push((q.x as f32, q.y as f32)),
+            figcraft_geom::kurbo::PathEl::ClosePath => closed = true,
+            _ => {}
+        });
+        flush(&mut sub, closed);
+    }
+}

From 3b56a856be58ae1c364553ddc091d17e76181ad9 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:59:10 +0000
Subject: [PATCH 46/67] refactor(ui-egui): split app.rs into app/

---
 crates/ui-egui/src/app.rs           | 978 +---------------------------
 crates/ui-egui/src/app/clipboard.rs |  20 +
 crates/ui-egui/src/app/commands.rs  | 282 ++++++++
 crates/ui-egui/src/app/control.rs   | 110 ++++
 crates/ui-egui/src/app/files.rs     | 298 +++++++++
 crates/ui-egui/src/app/frame.rs     | 255 ++++++++
 crates/ui-egui/src/app/ime.rs       |  20 +
 7 files changed, 994 insertions(+), 969 deletions(-)
 create mode 100644 crates/ui-egui/src/app/clipboard.rs
 create mode 100644 crates/ui-egui/src/app/commands.rs
 create mode 100644 crates/ui-egui/src/app/control.rs
 create mode 100644 crates/ui-egui/src/app/files.rs
 create mode 100644 crates/ui-egui/src/app/frame.rs
 create mode 100644 crates/ui-egui/src/app/ime.rs

diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
index da975074..c10b402c 100644
--- a/crates/ui-egui/src/app.rs
+++ b/crates/ui-egui/src/app.rs
@@ -4,6 +4,13 @@ use super::services::{DialogFuture, PickFuture, Picked, RepaintWaker, Services};
 use super::state::{LEFT_PANEL, LeftTab, MOBILE_STRIP, MobilePanel, NARROW_WIDTH, PANEL_DEFAULT, RIGHT_PANEL, RightTab, TitleBar, fit_panels};
 use super::*;
 
+mod clipboard;
+mod commands;
+mod control;
+mod files;
+mod frame;
+mod ime;
+
 impl FigApp {
     /// Construct `FigApp` from a session and services, taking panel widths and pages height
     /// from preferences and initializing UI, canvas, clocks, capture/IME and transient channel
@@ -41,7 +48,7 @@ impl FigApp {
             control_input_queued: false,
             applied_frame: None,
             clock: FrameClock::default(),
-            capture: control::CaptureState::default(),
+            capture: crate::control::CaptureState::default(),
             logic_ticked: false,
             ui_frame_stamp: None,
             ime: egui::ime_context::ImeContextTracker::new(),
@@ -51,703 +58,6 @@ impl FigApp {
         }
     }
 
-    /// Dismiss the composer after a successful switch away from the Comment tool.
-    pub(crate) fn clear_comment_draft_after_tool_set(&mut self, id: &str, succeeded: bool) {
-        if id == "tool.set" && succeeded && self.session.tool.tool != figcraft_engine::tools::ToolId::Comment {
-            self.ui.comments.draft = None;
-        }
-    }
-
-    /// Run a command, surfacing errors as a toast. Returns the result.
-    pub fn run(&mut self, id: &str, params: Value) -> Option<Value> {
-        let layers_generation = self.session.clipboard.layers_generation;
-        let r = self.session.execute(id, &params);
-        self.clear_comment_draft_after_tool_set(id, r.is_ok());
-        self.handle_ui_requests();
-        self.invalidate_synthetic_copy(layers_generation);
-        // A command may change the file the window shows (`doc.switch`, `doc.nextTab`,
-        // `file.open`/`file.close`). Record that presentation before returning, so an in-flight
-        // screenshot admitted on the old file cannot accept pixels from the new one.
-        self.observe_presentation();
-        r.map_err(|e| self.failed(id, &e)).ok()
-    }
-
-    /// A programmatic command that changed the engine clipboard never wrote the system clipboard:
-    /// forget the old system mirror so a later user paste does not trust it as our own copy.
-    /// `before` is the layers generation captured before the command ran.
-    pub(crate) fn invalidate_synthetic_copy(&mut self, before: u64) {
-        if self.control_synthetic && self.session.clipboard.layers_generation != before {
-            self.ui.last_copy = None;
-        }
-    }
-
-    /// Record the file the window drawing now shows, with a monotonic generation that changes on
-    /// every switch (an A→B→A switch is two generations, never the admitted one again).
-    pub(crate) fn observe_presentation(&mut self) {
-        let window = self.windows.current;
-        self.windows.presentation(&self.session, window);
-    }
-
-    /// [`run`](Self::run) for something the user did (a dialog, a drop, a paste, a recent file):
-    /// a file it imports shows its import report. Programmatic calls use `run` and never open one.
-    pub fn run_user(&mut self, id: &str, params: Value) -> Option<Value> {
-        let result = self.run(id, params.clone());
-        if let Some(result) = &result {
-            import_report::capture(self, id, &params, result);
-        }
-        missing_fonts::check_later(self, id, result.as_ref());
-        result
-    }
-
-    /// Show command `id`'s error.
-    pub(crate) fn failed(&mut self, id: &str, e: &figcraft_engine::EngineError) {
-        let msg = e.to_string();
-        log::warn!("{id}: {msg}");
-        self.show_error(msg);
-    }
-
-    /// Show an error as a toast, kept as the last error.
-    pub(crate) fn show_error(&mut self, msg: String) {
-        self.toast(msg.clone());
-        self.ui.last_error = Some(msg);
-    }
-
-    /// Run a command that may talk to a server without waiting for it (the engine's
-    /// [`start_background`](Session::start_background)): `done` gets the result, at once or when
-    /// the answer arrives (the network wakes the window then); errors show as with [`run`](Self::run).
-    /// [`Session::waiting_for`] tells the panels to show that it's on its way.
-    pub fn run_background(&mut self, ctx: &egui::Context, id: &str, params: Value, done: Done) {
-        self.waiting.retain(|(c, _)| c != id);
-        let r = self.session.start_background(id, params);
-        self.handle_ui_requests();
-        match r {
-            Ok(Some(v)) => done(self, ctx, v),
-            Ok(None) => self.waiting.push((id.to_string(), done)),
-            Err(e) => self.failed(id, &e),
-        }
-    }
-
-    /// Stop waiting for command `id` (Cancel, or its window closed): its answer is dropped.
-    pub fn cancel_background(&mut self, id: &str) {
-        self.session.cancel_background(id);
-        self.waiting.retain(|(c, _)| c != id);
-    }
-
-    /// Hand the results of background commands that finished to what's waiting for them.
-    fn background_done(&mut self, ctx: &egui::Context) {
-        while let Some((id, r)) = self.session.take_background_done() {
-            self.handle_ui_requests();
-            let done = self.waiting.iter().position(|(c, _)| *c == id).map(|i| self.waiting.remove(i).1);
-            match (r, done) {
-                (Ok(v), Some(done)) => done(self, ctx, v),
-                (Ok(_), None) => {}
-                (Err(e), _) => self.failed(&id, &e),
-            }
-        }
-    }
-
-    /// Show what `command params` would do on the canvas as a live preview (`text.preview`) while
-    /// a font family, font style, text style, named instance or axis slider is hovered or dragged. Call it every frame
-    /// the preview should stay: it ends on the first frame nothing asks for it.
-    pub fn preview_text(&mut self, ctx: &egui::Context, command: &str, params: Value) {
-        self.ui.text_preview_wanted = true;
-        let revision = self.session.ds().map_or(0, |d| d.revision);
-        if let Some((c, p, rev)) = &self.ui.text_preview
-            && c == command
-            && *p == params
-            && (*rev == revision || figcraft_engine::textpreview::active(&self.session))
-        {
-            return;
-        }
-        let shown = self.session.execute("text.preview", &json!({"command": command, "params": params})).is_ok();
-        let revision = self.session.ds().map_or(0, |d| d.revision);
-        self.ui.text_preview = shown.then(|| (command.to_string(), params, revision));
-        // The canvas drew before the panels: show the preview next frame.
-        ctx.request_repaint();
-    }
-
-    /// End the live text preview the panels show (Escape, or nothing hovered any more).
-    pub fn end_text_preview(&mut self, ctx: &egui::Context) {
-        if self.ui.text_preview.take().is_some() {
-            let _ = self.session.execute("text.endPreview", &json!({}));
-            ctx.request_repaint();
-        }
-    }
-
-    /// Dev Mode (the Inspect tab): the canvas measures on hover without Alt and edits nothing;
-    /// entering it ends editing text or vectors.
-    fn sync_dev_mode(&mut self) {
-        let dev = self.ui.right_tab == RightTab::Inspect;
-        if dev && !self.session.tool.dev_mode {
-            let _ = self.session.drop_gesture();
-            let editing = self.session.ds().map(|d| (d.text_edit.is_some(), d.vector_edit.is_some())).unwrap_or_default();
-            for (on, cmd) in [(editing.0, "text.edit.end"), (editing.1, "vector.edit.end")] {
-                if on {
-                    self.run(cmd, json!({}));
-                }
-            }
-        }
-        self.session.tool.dev_mode = dev;
-    }
-
-    /// Leaving Design ends a pen path as Escape does and goes back to Move: Prototype and Inspect
-    /// don't draw (#307). Checked as the frame starts (the control channel) and after the panels
-    /// and shortcuts (the mode switcher, the tabs, Shift+E/Shift+D), before the canvas sees more.
-    fn end_pen_outside_design(&mut self) {
-        if self.ui.right_tab == self.ui.last_right_tab {
-            return;
-        }
-        self.ui.last_right_tab = self.ui.right_tab;
-        if self.ui.right_tab != RightTab::Design && self.session.tool.tool == figcraft_engine::tools::ToolId::Pen {
-            self.run("tool.set", json!({"tool": "move"}));
-        }
-    }
-
-    /// Once a frame, after the panels: a preview nothing asked for this frame ends.
-    fn end_unwanted_text_preview(&mut self, ctx: &egui::Context) {
-        if !std::mem::take(&mut self.ui.text_preview_wanted) {
-            self.end_text_preview(ctx);
-        }
-    }
-
-    /// Finish the frame that applies an injected batch: acknowledge it once the pass is presented,
-    /// and stop fencing the system clipboard. Only the viewport whose batch this frame took acts.
-    pub(crate) fn end_input_frame(&mut self, ctx: &egui::Context) {
-        if self.applied_frame != Some(ctx.viewport_id()) {
-            return;
-        }
-        self.applied_input = None;
-        if ctx.will_discard() {
-            // Keep `applied_frame`/`applied_acks`: the rerun pass must present (and acknowledge)
-            // the same frame without replaying the input.
-            return;
-        }
-        self.applied_frame = None;
-        for ack in self.applied_acks.drain(..) {
-            let _ = ack.tx.send(ack.reply);
-        }
-        self.control_synthetic = false;
-    }
-
-    /// The app's monotonic clock in seconds, also usable from logic-only callbacks (recovery,
-    /// control deadlines). Never `ctx.input(i.time)`, which is stale there.
-    pub fn now_secs(&self) -> f64 {
-        self.clock.now()
-    }
-
-    /// Queue raw input injected through the control channel for the window drawing next, tagged
-    /// with the document it belongs to (a batch is dropped if another file is active by then).
-    pub(crate) fn push_control_input(&mut self, events: Vec<egui::Event>) -> bool {
-        if events.is_empty() {
-            return false;
-        }
-        let doc = self.session.docs.get(self.session.active).map(|d| d.uid);
-        if !self.control_input.is_empty() && self.control_input_doc != doc {
-            // A queued batch belongs to the file that was open when it was injected; it cannot be
-            // merged with one for the file showing now. Its acknowledgement says so.
-            self.control_input.clear();
-            let viewport = crate::windows::viewport(self.windows.current);
-            crate::windows::fail_input_acks(self, viewport);
-        }
-        // Always the live pane vector: while a child window draws, `windows::enter` has swapped
-        // its pane into the app, and `leave` swaps these events back into that pane.
-        self.control_input.extend(events);
-        self.control_input_doc = doc;
-        self.control_synthetic = true;
-        true
-    }
-
-    /// The acknowledgements waiting for `viewport`'s input batch (other windows keep theirs).
-    pub(crate) fn take_input_acks(&mut self, viewport: egui::ViewportId) -> Vec<PendingAck> {
-        let mut mine = Vec::new();
-        for ack in std::mem::take(&mut self.input_acks) {
-            if ack.viewport == viewport {
-                mine.push(ack);
-            } else {
-                self.input_acks.push(ack);
-            }
-        }
-        mine
-    }
-
-    /// Put `text` on the system clipboard. Input injected through the control channel never
-    /// replaces what the user copied: this is the one write path every copy command goes through.
-    pub(crate) fn clipboard_set_text(&mut self, text: &str) {
-        if self.control_synthetic {
-            return;
-        }
-        self.services.clipboard_set_text(text);
-    }
-
-    /// [`Self::clipboard_set_text`] for an image (straight RGBA).
-    pub(crate) fn clipboard_set_png(&mut self, width: u32, height: u32, rgba: &[u8]) {
-        if self.control_synthetic {
-            return;
-        }
-        self.services.clipboard_set_png(width, height, rgba);
-    }
-
-    pub fn toast(&mut self, msg: impl Into<String>) {
-        self.ui.toast = Some((msg.into(), ToastClock::Raised));
-    }
-
-    /// Say that `n` documents left unsaved by a crash were opened again from recovery copies.
-    pub fn note_recovered(&mut self, n: usize) {
-        if n > 0 {
-            self.toast(i18n::trn("Recovered {n} unsaved files after the app quit unexpectedly: save them to keep them", n, &[]));
-        }
-    }
-
-    /// Act on UI requests queued by commands (dialogs, panels).
-    pub fn handle_ui_requests(&mut self) {
-        let reqs = std::mem::take(&mut self.session.ui_requests);
-        for r in reqs {
-            match r.kind.as_str() {
-                "dialog.about" => {
-                    self.ui.about = true;
-                    self.ui.about_tab = dialogs::AboutTab::About;
-                }
-                "dialog.preferences" => self.ui.preferences = true,
-                "dialog.missingFonts" => missing_fonts::request(self),
-                "panel.shortcuts" => self.ui.shortcuts_panel = !self.ui.shortcuts_panel,
-                "palette.actions" => menus::toggle_palette(&mut self.ui),
-                "panel.design" if self.session.doc().is_ok_and(figcraft_engine::board::is_board) => self.ui.board_panel = !self.ui.board_panel,
-                "panel.design" => self.ui.right_tab = RightTab::Design,
-                "board.editText" => {
-                    if let Some(id) = r.data.get("id").and_then(figcraft_engine::params::id_of)
-                        && let Err(e) = figcraft_engine::board::edit_text(&mut self.session, id)
-                    {
-                        self.toast(e.to_string());
-                    }
-                }
-                "panel.prototype" => self.ui.right_tab = RightTab::Prototype,
-                "panel.designPrototype" => {
-                    self.ui.right_tab = if self.ui.right_tab == RightTab::Prototype { RightTab::Design } else { RightTab::Prototype };
-                }
-                "panel.devMode" => {
-                    self.ui.right_tab = if self.ui.right_tab == RightTab::Inspect { RightTab::Design } else { RightTab::Inspect };
-                }
-                "panel.leftSidebar" => {
-                    let shown = if self.ui.narrow { self.ui.mobile_panel == Some(MobilePanel::Left) } else { !self.ui.left_collapsed };
-                    if shown {
-                        self.ui.close_left_panel();
-                    } else {
-                        self.ui.open_left_panel();
-                    }
-                }
-                "panel.widths" => {
-                    let width = |k: &str| r.data.get(k).and_then(Value::as_f64).map(|w| w as f32);
-                    let (left, right) = (width("left"), width("right"));
-                    let reset = left.is_none() && right.is_none();
-                    self.set_panel_widths(
-                        left.unwrap_or(if reset { PANEL_DEFAULT } else { self.ui.left_width }),
-                        right.unwrap_or(if reset { PANEL_DEFAULT } else { self.ui.right_width }),
-                    );
-                    self.services.save_prefs(&self.session.prefs);
-                }
-                "focus.region" => self.ui.nav.step(r.data.get("step").and_then(Value::as_i64).unwrap_or(1).clamp(-4, 4) as i32),
-                "panel.layers" => self.ui.left_tab = LeftTab::File,
-                "panel.assets" => {
-                    self.ui.left_tab = LeftTab::Assets;
-                    self.ui.open_left_panel();
-                    self.ui.versions = Default::default();
-                }
-                "panel.versionHistory" => versions::open(self),
-                "view.devCompare" => {
-                    self.ui.dev.compare = dev_compare::CompareView::requested(&r.data);
-                }
-                "panel.libraries" => {
-                    self.ui.left_tab = LeftTab::Assets;
-                    self.ui.open_left_panel();
-                    self.ui.libraries = true;
-                }
-                "home" => self.ui.home = true,
-                "home.templates" => {
-                    self.ui.home = true;
-                    self.ui.home_view.section = home::Section::Templates;
-                }
-                "home.gettingStarted" => {
-                    self.ui.home = true;
-                    self.ui.home_view.section = home::Section::Recents;
-                    self.services.save_prefs(&self.session.prefs);
-                }
-                "dialog.saveAs" => self.save_as_dialog(),
-                "dialog.colorProfile" => self.ui.color_profile = self.session.doc().ok().map(|d| d.color_profile),
-                "present" => {
-                    if let Some(start) = r.data.get("start").and_then(figcraft_engine::params::id_of) {
-                        tabs::open_present(self, start);
-                    }
-                }
-                "present.options" => {
-                    let v = &mut self.ui.present_view;
-                    if let Some(s) = r.data.get("scale").and_then(|s| s.as_str()).and_then(present::PresentScale::parse) {
-                        v.scale = s;
-                    }
-                    if let Some(f) = r.data.get("deviceFrame").and_then(|f| f.as_bool()) {
-                        v.device_frame = f;
-                    }
-                    if let Some(h) = r.data.get("hotspotHints").and_then(|h| h.as_bool()) {
-                        v.hotspot_hints = h;
-                    }
-                    if let Some(i) = r.data.get("inspect").and_then(|i| i.as_bool()) {
-                        v.inspect = i;
-                    }
-                    if let Some(p) = self.ui.present.as_mut() {
-                        p.view.device_frame = v.device_frame;
-                        p.view.hotspot_hints = v.hotspot_hints;
-                        p.view.inspect = v.inspect;
-                        p.set_scale(v.scale);
-                    }
-                }
-                "preview" => {
-                    if let Some(start) = r.data.get("start").and_then(figcraft_engine::params::id_of) {
-                        self.ui.preview = Some(present::Pane::new(start, &self.session));
-                    }
-                }
-                "preview.close" => self.ui.preview = None,
-                "open.help" => self.services.open_url("https://getartcraft.com/apps/figcraft"),
-                "layers.collapseAll" => layers::collapse_all(self),
-                "contextMenu" => self.ui.key_menu = true,
-                "selectArea" => self.start_key_box(),
-                "canvas.renameLabel" => {
-                    self.ui.rename_label = r.data.get("id").and_then(figcraft_engine::params::id_of).map(|id| layers::Rename { id, start: true });
-                }
-                "layers.rename" => {
-                    let ids: Vec<NodeId> =
-                        r.data.get("ids").and_then(Value::as_array).into_iter().flatten().filter_map(figcraft_engine::params::id_of).collect();
-                    if ids.len() > 1 {
-                        dialogs::open_batch_rename(self, &ids);
-                    } else {
-                        layers::start_rename(self, &ids);
-                    }
-                }
-                "comment.open" => {
-                    if let Some(id) = r.data.get("id").and_then(Value::as_u64) {
-                        self.ui.comments.show(id);
-                    }
-                }
-                "comment.new" => {
-                    let x = r.data.get("x").and_then(|v| v.as_f64()).unwrap_or(0.0);
-                    let y = r.data.get("y").and_then(|v| v.as_f64()).unwrap_or(0.0);
-                    comments::start_draft(self, x, y);
-                }
-                "dialog.unsaved" => self.toast(i18n::tr("This file has unsaved changes")),
-                "dialog.plugins" => self.ui.plugins_window = true,
-                "dialog.pluginSave" => plugins_ui::save_file(self, &r.data),
-                "dialog.cursorChat" => live::open_chat(self),
-                "window.new" | "window.focus" | "window.fullscreen" => self.window_requests.push(r),
-                _ => {}
-            }
-        }
-        if let Some(m) = self.session.message.take() {
-            self.toast(m);
-        }
-    }
-
-    /// Set the widths asked for this window's side panels (within their limits); the main
-    /// window's are kept in the preferences.
-    pub fn set_panel_widths(&mut self, left: f32, right: f32) {
-        let within = |w: f32, range: std::ops::RangeInclusive<f32>| if w.is_finite() { w.clamp(*range.start(), *range.end()) } else { PANEL_DEFAULT };
-        (self.ui.left_width, self.ui.right_width) = (within(left, LEFT_PANEL), within(right, RIGHT_PANEL));
-        if self.windows.current == 0 {
-            self.session.prefs.panel_widths = (self.ui.left_width, self.ui.right_width);
-        }
-    }
-
-    /// The edge between a side panel and the canvas, at `x` down `rows`: dragging it sizes the
-    /// panel (`grows`: +1 for the left panel, whose edge is on its right, −1 for the right one), a
-    /// double-click puts back the default width. Returns the width asked for, when it changed.
-    fn panel_edge(ui: &mut egui::Ui, name: &str, x: f32, rows: egui::Rangef, width: f32, grows: f32) -> Option<f32> {
-        let grab = ui.style().interaction.resize_grab_radius_side;
-        let rect = egui::Rect::from_x_y_ranges(x - grab..=x + grab, rows);
-        let id = egui::Id::unique(("panel_edge", name));
-        // Not focusable: an edge is a pointer target, so it must not take Tab/F6 focus from the
-        // panels' controls (see `a11y::focusables`).
-        let resp = ui.interact(rect, id, egui::Sense::CLICK | egui::Sense::DRAG);
-        if resp.hovered() || resp.dragged() {
-            ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
-            ui.painter().vline(x, rows, egui::Stroke::new(2.0, theme::ACCENT));
-        }
-        if resp.double_clicked() {
-            return Some(PANEL_DEFAULT);
-        }
-        // The edge stays under the pointer where it was grabbed (also back from past a limit).
-        let at = resp.interact_pointer_pos().filter(|_| resp.dragged())?;
-        if resp.drag_started() {
-            let pressed = ui.input(|i| i.pointer.press_origin()).unwrap_or(at);
-            ui.data_mut(|d| d.insert_temp(id, pressed.x - x));
-        }
-        let grabbed: f32 = ui.data(|d| d.get_temp(id)).unwrap_or(0.0);
-        let w = width + (at.x - grabbed - x) * grows;
-        (w != width).then_some(w)
-    }
-
-    pub fn save_as_dialog(&mut self) {
-        if self.services.downloads() {
-            if let Some(r) = self.run("file.saveAs", json!({"data": true}))
-                && self.download(r["name"].as_str().unwrap_or_default(), &r)
-            {
-                self.run("file.markSaved", json!({}));
-                dialogs::file_saved(self, &r);
-            }
-            return;
-        }
-        let Ok(name) = self.session.doc().map(|d| d.name.clone()) else { return };
-        self.pick_save(i18n::tr("Save as"), &format!("{name}.figcraft"), &["figcraft", "fig"], |app, mut p| {
-            if p.extension().is_none_or(OsStr::is_empty) {
-                if !p.set_extension("figcraft") {
-                    app.toast(i18n::tr("Use the .figcraft or .fig extension."));
-                    return;
-                }
-                // This name wasn't confirmed by the system dialog: don't replace an existing file.
-                match p.try_exists() {
-                    Ok(false) => {}
-                    Ok(true) => {
-                        app.toast(i18n::tr("A .figcraft file with this name already exists. Choose its full name to confirm replacement."));
-                        return;
-                    }
-                    Err(e) => {
-                        app.toast(e.to_string());
-                        return;
-                    }
-                }
-            } else if !p.extension().and_then(OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("figcraft") || e.eq_ignore_ascii_case("fig")) {
-                app.toast(i18n::tr("Use the .figcraft or .fig extension."));
-                return;
-            }
-            if let Some(r) = app.run("file.saveAs", json!({"path": p.to_string_lossy()})) {
-                dialogs::file_saved(app, &r);
-            }
-        });
-    }
-
-    pub fn save(&mut self) {
-        // A branch tab saves its main file.
-        let tab = figcraft_engine::branches::file_tab(&self.session);
-        // A path ending in .fig is never saved over silently: a .fig destination is an export copy.
-        let native_path = self
-            .session
-            .docs
-            .get(tab)
-            .and_then(|d| d.path.as_deref())
-            .is_some_and(|path| !Path::new(path).extension().and_then(OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("fig")));
-        if native_path {
-            if self.run("file.save", json!({})).is_some() {
-                self.toast(i18n::tr("Saved"));
-            }
-        } else {
-            self.save_as_dialog();
-        }
-    }
-
-    pub fn open_dialog(&mut self) {
-        // Opening needs no file in front: it goes ahead even if that file closed meanwhile.
-        self.pick_file(i18n::tr("Open"), OPEN_EXTENSIONS, false, |app, file| {
-            if app.run_user("file.open", file).is_some() {
-                app.ui.home = false;
-            }
-        });
-    }
-
-    pub fn import_dialog(&mut self, place: bool) {
-        let exts: &[&str] = if place {
-            &["png", "jpg", "jpeg", "webp", "gif", "tif", "tiff"]
-        } else {
-            &["svg", "png", "jpg", "jpeg", "webp", "gif", "tif", "tiff", "figcraft", "fig", "sketch"]
-        };
-        let title = if place { i18n::tr("Place image") } else { i18n::tr("Import") };
-        self.pick_file(title, exts, true, |app, file| {
-            app.run_user("file.import", file);
-        });
-    }
-
-    /// Pick a file to open or import; `done` gets it as `file.open` and `file.import` take it (a
-    /// path, or the name and contents where the platform has no paths). `pin`: as
-    /// [`FigApp::pick_open`]'s file in front.
-    fn pick_file(&mut self, title: &str, exts: &[&str], pin: bool, done: impl FnOnce(&mut FigApp, Value) + 'static) {
-        self.start_pick(
-            |services| -> PickFuture {
-                match services.pick_open_contents(title, exts) {
-                    Some(read) => {
-                        Box::pin(async move { read.await.map(|r| r.map_or_else(Picked::Unreadable, |(name, bytes)| Picked::Contents(name, bytes))) })
-                    }
-                    None => {
-                        let pick = services.pick_open(title, exts);
-                        Box::pin(async move { pick.await.map(Picked::Path) })
-                    }
-                }
-            },
-            pin,
-            move |app, picked| match picked.file_params() {
-                Ok(file) => done(app, file),
-                Err(why) => app.show_error(why),
-            },
-        );
-    }
-
-    /// Pick a file to open. `done` runs with the file in front now back in front (and not at all
-    /// if that file closed meanwhile).
-    pub fn pick_open(&mut self, title: &str, exts: &[&str], done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
-        self.start_dialog(|services| services.pick_open(title, exts), true, done);
-    }
-
-    /// Pick where to save; `done` runs as [`FigApp::pick_open`]'s does.
-    pub fn pick_save(&mut self, title: &str, name: &str, exts: &[&str], done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
-        self.start_dialog(|services| services.pick_save(title, name, exts), true, done);
-    }
-
-    /// Hand a command result's base64 `data` over as a download named `name`, where the platform
-    /// saves by downloads rather than save dialogs (the browser, #969). Says so when nothing arrived.
-    pub(crate) fn download(&mut self, name: &str, result: &Value) -> bool {
-        use base64::Engine as _;
-        let bytes = result["data"].as_str().and_then(|d| base64::engine::general_purpose::STANDARD.decode(d).ok());
-        if bytes.is_some_and(|b| self.services.download(name, &b)) {
-            return true;
-        }
-        self.toast(i18n::trf("Couldn't download {name}", &[("name", &name)]));
-        false
-    }
-
-    /// Pick a folder; `done` runs as [`FigApp::pick_open`]'s does.
-    pub fn pick_folder(&mut self, title: &str, done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
-        self.start_dialog(|services| services.pick_folder(title), true, done);
-    }
-
-    /// Open a native dialog from the window drawing now, for the file in front (`pin`).
-    fn start_dialog(&mut self, start: impl FnOnce(&mut dyn Services) -> DialogFuture, pin: bool, done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
-        self.start_pick(
-            |services| -> PickFuture {
-                let pick = start(services);
-                Box::pin(async move { pick.await.map(Picked::Path) })
-            },
-            pin,
-            move |app, picked| {
-                if let Picked::Path(p) = picked {
-                    done(app, p);
-                }
-            },
-        );
-    }
-
-    /// [`FigApp::start_dialog`] for any kind of pick.
-    fn start_pick(&mut self, start: impl FnOnce(&mut dyn Services) -> PickFuture, pin: bool, done: impl FnOnce(&mut FigApp, Picked) + 'static) {
-        if self.pending_dialog.is_some() {
-            return;
-        }
-        let doc = if pin { self.session.ds().ok().filter(|d| self.shows(d.uid)).map(|d| d.uid) } else { None };
-        let future = start(self.services.as_mut());
-        self.pending_dialog = Some(PendingDialog { future, picked: None, done: Box::new(done), doc, window: self.windows.current });
-        if let Some(ctx) = &self.ui_context {
-            ctx.request_repaint();
-        }
-    }
-
-    /// Once the dialog has a path, its continuation runs in the window that holds its file, with
-    /// that file in front; then the tab in front before comes back (unless the dialog opened a file).
-    pub(crate) fn poll_dialog(&mut self, ctx: &egui::Context) {
-        let Some(d) = &mut self.pending_dialog else { return };
-        if d.picked.is_none() {
-            let waker = Waker::from(Arc::new(RepaintWaker(ctx.clone())));
-            let Poll::Ready(picked) = d.future.as_mut().poll(&mut TaskContext::from_waker(&waker)) else { return };
-            d.picked = picked;
-        }
-        let (doc, origin, picked) = (d.doc, d.window, d.picked.is_some());
-        let index = doc.map(|u| self.session.docs.iter().position(|ds| ds.uid == u));
-        // Cancelled, or its file closed meanwhile.
-        if !picked || index == Some(None) {
-            self.pending_dialog = None;
-            return;
-        }
-        let window = match doc {
-            Some(u) => self.windows.of(u),
-            None if self.windows.exists(origin) => origin,
-            None => 0,
-        };
-        if window != self.windows.current {
-            ctx.request_repaint_of(windows::viewport(window));
-            return;
-        }
-        let Some(PendingDialog { picked: Some(picked), done, .. }) = self.pending_dialog.take() else { return };
-        let before = self.session.ds().ok().map(|d| d.uid);
-        if let Some(Some(i)) = index {
-            self.session.active = i;
-        }
-        done(self, picked);
-        if doc.is_some()
-            && self.session.ds().ok().map(|d| d.uid) == doc
-            && let Some(i) = before.and_then(|u| self.session.docs.iter().position(|d| d.uid == u))
-        {
-            self.session.active = i;
-        }
-    }
-
-    /// Reduced motion: the preference or the system's setting.
-    pub fn reduce_motion(&self) -> bool {
-        self.session.prefs.reduce_motion || self.services.reduce_motion()
-    }
-
-    /// The CJK, Bengali and Thai scripts the UI shows: the language's, the language picker's (Preferences open),
-    /// typed text's, and those in the open file's names and comments (read when it changes, not
-    /// mid-drag). Nothing is checked once every script has a face.
-    pub(crate) fn cjk_needed(&mut self, ctx: &egui::Context, installed: u8) -> u8 {
-        if installed == cjk::ALL {
-            return installed;
-        }
-        let mut need = i18n::current().map_or(0, |l| cjk::language(l.code));
-        if self.ui.preferences {
-            need |= i18n::languages().iter().filter(|l| cjk::can_show(l.code)).fold(0, |m, l| m | cjk::language(l.code));
-        }
-        need |= ctx.input(|i| {
-            i.events.iter().fold(0, |m, e| match e {
-                egui::Event::Text(t) | egui::Event::Ime(egui::ImeEvent::Preedit { text: t, .. } | egui::ImeEvent::Commit(t)) => m | cjk::scripts(t),
-                _ => m,
-            })
-        });
-        let dragging = ctx.input(|i| i.pointer.any_down());
-        // Pans and zooms change the revision too: only a new version of the document is looked
-        // at, and only the layers it changed (a large file has hundreds of thousands of names).
-        let current = self.session.docs.get(self.session.active).filter(|_| !dragging).map(|d| (d.uid, d.doc.clone()));
-        if let Some((uid, doc)) = current {
-            let before = self.cjk_checked.take().filter(|(u, _)| *u == uid).map(|(_, b)| b);
-            if !before.as_ref().is_some_and(|b| Arc::ptr_eq(b, &doc)) {
-                let mut scan = |s: &str| need |= cjk::scripts(s);
-                scan(&doc.name);
-                match before.as_ref().and_then(|b| doc.changed_ids(b, CJK_CHANGES)) {
-                    Some(ids) => ids.into_iter().filter_map(|id| doc.node(id)).for_each(|n| scan(&n.name)),
-                    None => doc.nodes().for_each(|n| scan(&n.name)),
-                }
-                doc.comments.iter().flat_map(|c| std::iter::once(&c.first).chain(&c.replies)).for_each(|m| {
-                    scan(&m.author);
-                    scan(&m.text);
-                });
-            }
-            self.cjk_checked = Some((uid, doc));
-        }
-        need
-    }
-
-    /// Work safe from a logic-only callback (`App::logic`, which also runs while hidden) and from
-    /// a normal UI pass: consumed control work, live polling, background completions, autosave and
-    /// recovery deadlines. It never reads UI input, so it must not scan events, run shortcuts or
-    /// lay out anything.
-    pub fn background_tick(&mut self, ctx: &egui::Context) {
-        control::background(self, ctx);
-        // What happened in a live session (the network woke us for it).
-        if self.session.live_poll() {
-            if let Some(m) = self.session.message.take() {
-                self.toast(live::failure_text(&m));
-            }
-            self.background_done(ctx);
-        }
-        // Files that arrived without a command (joined, recovered) take the kept View toggles too.
-        self.session.apply_view_prefs();
-        let now = self.clock.now();
-        self.autosave_tick(ctx, now);
-        self.auto_save_tick(ctx, now);
-        updates_ui::tick(self, ctx);
-        self.logic_ticked = true;
-    }
-
     /// UI-phase setup that needs a real current `Ui`: fonts/language/theme, interface zoom and the
     /// render worker. Runs once per frame (pass 0) for the main window, and once per frame for
     /// every child window (`windows::draw`), never on a logic-only tick.
@@ -821,102 +131,6 @@ impl FigApp {
         }
     }
 
-    /// Every [`AUTOSAVE_SECS`], each open document with unsaved changes since its last version
-    /// gets an autosave checkpoint in its version history.
-    fn autosave_tick(&mut self, ctx: &egui::Context, now: f64) {
-        if now < self.ui.next_autosave {
-            // Wake up for it even if nothing else draws a frame by then.
-            repaint_in(ctx, self.ui.next_autosave - now);
-            return;
-        }
-        if self.ui.next_autosave > 0.0 {
-            let active = self.session.active;
-            for i in 0..self.session.docs.len() {
-                self.session.active = i;
-                let _ = self.session.execute("version.autosave", &json!({}));
-            }
-            self.session.active = active;
-        }
-        self.ui.next_autosave = now + AUTOSAVE_SECS;
-        repaint_in(ctx, AUTOSAVE_SECS);
-    }
-
-    /// With auto-save on, files that have a path are saved [`AUTO_SAVE_SECS`] after they last
-    /// changed (not during a gesture, a live preview or while a version is shown). The file is
-    /// encoded on a thread of its own, so a big one doesn't hold up the window, and written here.
-    fn auto_save_tick(&mut self, ctx: &egui::Context, now: f64) {
-        let mut failed = self.auto_save_done();
-        // The browser has no files to save to.
-        let on = !cfg!(target_arch = "wasm32") && self.session.prefs.auto_save;
-        let saving = &self.ui.auto_saving;
-        let due = |d: &&figcraft_engine::DocState| {
-            d.path.as_deref().is_some_and(|p| d.images_lost_saving_to(p).is_none())
-                && d.branch_of.is_none()
-                && d.preview.is_none()
-                && d.is_dirty()
-                && !saving.iter().any(|(uid, _)| *uid == d.uid)
-        };
-        let changes = if on { self.session.docs.iter().filter(due).map(|d| d.revision).reduce(u64::wrapping_add) } else { None };
-        match changes {
-            None => self.ui.auto_save_at = None,
-            Some(changes) => {
-                let at = match self.ui.auto_save_at {
-                    Some((at, c)) if c == changes && failed.is_none() => at,
-                    _ => now + if failed.is_some() { AUTO_SAVE_RETRY_SECS } else { AUTO_SAVE_SECS },
-                };
-                self.ui.auto_save_at = Some((at, changes));
-                if now < at || self.session.docs.iter().any(|d| d.interaction.is_some() || d.text_preview.is_some()) {
-                    // Due but busy: look again in a second.
-                    repaint_in(ctx, if now < at { at - now } else { 1.0 });
-                } else {
-                    self.ui.auto_save_at = None;
-                    let files: Vec<_> =
-                        self.session.docs.iter().filter(due).map(|d| (d.uid, figcraft_engine::cmd::file::FileSnapshot::of(d))).collect();
-                    for (uid, file) in files {
-                        let encode = move || {
-                            let bytes = file.encode();
-                            (file, bytes)
-                        };
-                        match std::thread::Builder::new().name("figcraft-save".into()).spawn(encode) {
-                            Ok(h) => self.ui.auto_saving.push((uid, h)),
-                            Err(e) => {
-                                failed.get_or_insert(e.to_string());
-                                self.ui.auto_save_at = Some((now + AUTO_SAVE_RETRY_SECS, changes));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if !self.ui.auto_saving.is_empty() {
-            // Look again shortly for the files being encoded.
-            repaint_in(ctx, 0.1);
-        }
-        if let Some(e) = failed {
-            self.toast(i18n::trf("Couldn't save automatically: {error}", &[("error", &e)]));
-        }
-    }
-
-    /// Write the files whose auto-save encoding finished; the first error, if one failed.
-    fn auto_save_done(&mut self) -> Option<String> {
-        if self.ui.auto_saving.is_empty() {
-            return None;
-        }
-        let mut failed = None;
-        let done: Vec<_> = self.ui.auto_saving.extract_if(.., |(_, h)| h.is_finished()).collect();
-        for (_, h) in done {
-            let saved = match h.join() {
-                Ok((snapshot, Ok(bytes))) => snapshot.save(&mut self.session, &bytes).map(|_| ()).map_err(|e| e.to_string()),
-                Ok((_, Err(e))) => Err(e.to_string()),
-                Err(_) => Err("the file couldn't be encoded".to_string()),
-            };
-            if let Err(e) = saved {
-                failed.get_or_insert(e);
-            }
-        }
-        failed
-    }
-
     /// Draw the whole UI: the main window (the other windows draw themselves).
     pub fn ui(&mut self, ui: &mut egui::Ui) {
         #[cfg(not(target_arch = "wasm32"))]
@@ -976,42 +190,6 @@ impl FigApp {
         }
     }
 
-    /// Whether the right panel shows: never with the UI `hidden`; always on a design file; on a
-    /// board, which has no prototypes or Dev Mode (its tab stays Design), only when asked for.
-    fn right_panel_shown(&mut self, hidden: bool) -> bool {
-        let board = self.session.doc().is_ok_and(figcraft_engine::board::is_board);
-        if board {
-            self.ui.right_tab = RightTab::Design;
-        }
-        !hidden && (!board || self.ui.board_panel)
-    }
-
-    /// A narrow window's two buttons for the side panels (touch-sized); the open one closes again.
-    fn mobile_buttons(&mut self, ctx: &egui::Context, at: egui::Pos2) {
-        use a11y::Tip as _;
-        let t = theme::Tokens::get(ctx);
-        egui::Area::new(egui::Id::unique("mobile_panel_buttons")).order(egui::Order::Foreground).fixed_pos(at).show(ctx, |ui| {
-            for (side, icon, name) in
-                [(MobilePanel::Left, icons::Icon::Layers, i18n::tr("Layers")), (MobilePanel::Right, icons::Icon::Panels, i18n::tr("Design"))]
-            {
-                let open = self.ui.mobile_panel == Some(side);
-                let (r, resp) = ui.allocate_exact_size(egui::vec2(40.0, 40.0), egui::Sense::click());
-                let resp = resp.tip(name);
-                let fill = if open { t.accent } else { t.panel };
-                ui.painter().rect(r, 8.0, fill, egui::Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
-                icons::paint(ui.painter(), r.shrink(10.0), icon, if open { t.accent_on } else { t.icon });
-                if resp.clicked() {
-                    if side == MobilePanel::Left && !open {
-                        self.ui.open_left_panel();
-                    } else {
-                        self.ui.mobile_panel = if open { None } else { Some(side) };
-                    }
-                }
-                ui.add_space(4.0);
-            }
-        });
-    }
-
     /// One frame of the window drawing now.
     pub(crate) fn frame(&mut self, ui: &mut egui::Ui) {
         let ctx = ui.ctx().clone();
@@ -1030,7 +208,7 @@ impl FigApp {
         // A dialog that closed acts first, in the window it was opened from.
         self.poll_dialog(&ctx);
         // Control requests run first so their results reflect this frame.
-        control::drain(self, &ctx);
+        crate::control::drain(self, &ctx);
         windows::requests(self, &ctx);
         selection_spacing::sync(self, &ctx);
         // Before any widget: the navigation keys (F6, Tab, arrows, Escape) move the keyboard.
@@ -1204,142 +382,4 @@ impl FigApp {
         // above make the same single idle observation.
         self.observe_ime(&ctx, !typing && !self.field_focus && self.ui.palette.is_none());
     }
-
-    /// The pass's one IME observation: the focused on-canvas editor, or an explicit idle.
-    ///
-    /// Calling `ImeContextTracker::observe` more than once in a pass would treat an idle followed
-    /// by a focused observation as a context change (dropping the frame's receipts) and bump the
-    /// generation. Keeping this in one place makes the fork contract structural.
-    fn observe_ime(&mut self, ctx: &egui::Context, focused: bool) {
-        #[cfg(test)]
-        {
-            self.ime_observations = self.ime_observations.saturating_add(1);
-        }
-        if focused {
-            shortcuts::ime_output(self, ctx);
-        } else {
-            let _ = self.ime.observe(ctx.viewport_id(), None);
-        }
-    }
-
-    /// Draw the toast: start its lifetime on the frame **after** the first drawn frame, request
-    /// that frame and the frame that hides it, expire and remove it at the deadline, and place it
-    /// at the bottom centre.
-    fn toast_ui(&mut self, ctx: &egui::Context) {
-        let Some((msg, clock)) = &mut self.ui.toast else { return };
-        let now = ctx.input(|i| i.time);
-        // The clock starts on the frame after the one that first draws the toast: that frame's
-        // time was taken before whatever raised it ran (a file dialog, a long open), and would
-        // count that wait against it, so a failed open's message expired before it was seen.
-        let left = match *clock {
-            ToastClock::Raised => {
-                *clock = ToastClock::Drawn;
-                ctx.request_repaint();
-                TOAST_SECS
-            }
-            ToastClock::Drawn => {
-                *clock = ToastClock::Since(now);
-                TOAST_SECS
-            }
-            ToastClock::Since(t) => TOAST_SECS - (now - t),
-        };
-        if left <= 0.0 {
-            self.ui.toast = None;
-            return;
-        }
-        let msg = msg.clone();
-        // Nothing moves while it shows: the next frame it needs is the one that hides it.
-        if matches!(clock, ToastClock::Since(_)) {
-            repaint_in(ctx, left);
-        }
-        let screen = ctx.content_rect();
-        egui::Area::new(egui::Id::unique("toast"))
-            .fixed_pos(egui::pos2(screen.center().x, screen.max.y - 96.0))
-            .pivot(egui::Align2::CENTER_BOTTOM)
-            .order(egui::Order::Tooltip)
-            .show(ctx, |ui| {
-                egui::Frame::NONE
-                    .fill(egui::Color32::from_rgb(0x1E, 0x1E, 0x1E))
-                    .corner_radius(egui::CornerRadius::same(8))
-                    .inner_margin(egui::Margin::symmetric(14, 10))
-                    .show(ui, |ui| {
-                        // Wrapped at a readable width (the area alone would wrap at a sliver).
-                        let width = (screen.width() - 64.0).clamp(120.0, 480.0);
-                        let galley = ui.painter().layout(msg, theme::regular(12.0), egui::Color32::WHITE, width);
-                        ui.label(galley);
-                    });
-            });
-    }
-
-    /// UI state as JSON (control channel `ui.inspect`).
-    pub fn inspect(&self) -> Value {
-        let mut state = json!({
-            "rightTab": self.ui.right_tab,
-            "leftTab": self.ui.left_tab,
-            "home": self.ui.home,
-            "online": online::inspect(self),
-            "tabs": self.session.docs.iter().map(|d| json!({"name": d.doc.name, "live": tabs::live_mark(self, d.uid).map(|shared| if shared { "shared" } else { "private" })})).collect::<Vec<_>>(),
-            "homeSection": self.ui.home_view.section.id(),
-            "homeRecents": home_recents::inspect(self),
-            "dark": self.ui.dark,
-            "focus": {"region": self.ui.nav.region.id(), "keyboard": self.ui.nav.keyboard},
-            "reduceMotion": self.reduce_motion(),
-            "presenting": self.ui.present.is_some(),
-            "presenter": tabs::shown_or_paused(self).map(present::Presenter::inspect),
-            "presentOptions": {"scale": self.ui.present_view.scale.id(), "deviceFrame": self.ui.present_view.device_frame, "comments": self.ui.present_view.comments, "hotspotHints": self.ui.present_view.hotspot_hints, "inspect": self.ui.present_view.inspect},
-            "preview": self.ui.preview.as_ref().map(|p| p.player.inspect()),
-            "mainMenu": self.ui.main_menu,
-            "palette": self.ui.palette.is_some(),
-            "variables": self.ui.variables.is_some(),
-            "versionHistory": self.ui.versions.open,
-            "branchReview": self.ui.branch_review.as_ref().map(|r| json!({"id": r.id, "picks": r.picks, "mode": if r.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }})),
-            "devCompare": self.ui.dev.compare.as_ref().map(|c| json!({"id": c.id, "mode": if c.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }, "split": c.split, "version": c.version})),
-            "devFocus": self.session.ds().ok().and_then(figcraft_engine::DocState::focused),
-            "annotationFilter": self.ui.dev.categories.id(),
-            "colorProfileDialog": self.ui.color_profile.map(|p| p.id()),
-            "stylePicker": self.ui.style_picker.as_ref().map(|p| p.slot().key()),
-            "stylePickerView": if self.ui.style_grid { "grid" } else { "list" },
-            "textPreview": figcraft_engine::textpreview::active(&self.session),
-            "comments": {
-                "open": self.ui.comments.open,
-                "draft": self.ui.comments.draft.as_ref().map(|d| [d.0, d.1]),
-                "filter": self.ui.comments.filter.id(),
-                "sort": self.ui.comments.sort.id(),
-                "search": self.ui.comments.search,
-                "editing": self.ui.comments.editing.as_ref().map(|e| [e.0, e.1 as u64]),
-                "mentions": self.ui.comments.mention.names(),
-            },
-            "frameMs": self.ui.frame_ms,
-            "renderMs": self.ui.render_ms,
-            "framesDrawn": self.frame_stats.frames,
-            "repaintCauses": self.frame_stats.causes(),
-            "canvas": {
-                "rect": [self.canvas.rect.min.x, self.canvas.rect.min.y, self.canvas.rect.max.x, self.canvas.rect.max.y],
-                "renderWork": self.canvas.render_work.map(|w| match w {
-                    figcraft_render::Work::Reused => json!({"kind": "reused"}),
-                    figcraft_render::Work::Partial { pixels } => json!({"kind": "partial", "pixels": pixels}),
-                    figcraft_render::Work::Full => json!({"kind": "full"}),
-                }),
-                "quality": if self.canvas.tex_coarse { "preview" } else { "refined" },
-                "previewLatencyMs": self.canvas.preview_latency_ms,
-                "refineLatencyMs": self.canvas.refine_latency_ms,
-            },
-            "live": live::inspect(self),
-            "window": self.windows.current,
-            "windows": windows::list(self),
-            "tool": self.session.tool_info(),
-            "cursor": self.canvas.cursor.map(cursors::Shown::name),
-            "panels": {"left": self.ui.left_width, "right": self.ui.right_width, "leftCollapsed": self.ui.left_collapsed},
-            "status": self.session.status(),
-            "lastError": self.ui.last_error,
-            "importReport": self.ui.import_report.as_ref().map(import_report::Report::inspect),
-        });
-        state["homeSearch"] = json!(self.ui.home_view.file_query);
-        // Set apart from the literal above, which is at the macro recursion limit.
-        state["uiScale"] = json!({"choice": self.session.prefs.ui_scale, "zoom": self.ui.ui_scale.zoom, "drawn": self.ui.ui_scale.drawn, "limited": self.ui.ui_scale.limited});
-        state["pendingOpens"] = json!(self.ui.pending_opens.len());
-        state["missingFonts"] = json!(self.ui.missing_fonts.as_ref().map(missing_fonts::Shown::inspect));
-        state["presentTabs"] = tabs::present_tabs_inspect(self);
-        state
-    }
 }
diff --git a/crates/ui-egui/src/app/clipboard.rs b/crates/ui-egui/src/app/clipboard.rs
new file mode 100644
index 00000000..2280f9a1
--- /dev/null
+++ b/crates/ui-egui/src/app/clipboard.rs
@@ -0,0 +1,20 @@
+use super::*;
+
+impl FigApp {
+    /// Put `text` on the system clipboard. Input injected through the control channel never
+    /// replaces what the user copied: this is the one write path every copy command goes through.
+    pub(crate) fn clipboard_set_text(&mut self, text: &str) {
+        if self.control_synthetic {
+            return;
+        }
+        self.services.clipboard_set_text(text);
+    }
+
+    /// [`Self::clipboard_set_text`] for an image (straight RGBA).
+    pub(crate) fn clipboard_set_png(&mut self, width: u32, height: u32, rgba: &[u8]) {
+        if self.control_synthetic {
+            return;
+        }
+        self.services.clipboard_set_png(width, height, rgba);
+    }
+}
diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs
new file mode 100644
index 00000000..38adf660
--- /dev/null
+++ b/crates/ui-egui/src/app/commands.rs
@@ -0,0 +1,282 @@
+use super::*;
+
+impl FigApp {
+    /// Dismiss the composer after a successful switch away from the Comment tool.
+    pub(crate) fn clear_comment_draft_after_tool_set(&mut self, id: &str, succeeded: bool) {
+        if id == "tool.set" && succeeded && self.session.tool.tool != figcraft_engine::tools::ToolId::Comment {
+            self.ui.comments.draft = None;
+        }
+    }
+
+    /// Run a command, surfacing errors as a toast. Returns the result.
+    pub fn run(&mut self, id: &str, params: Value) -> Option<Value> {
+        let layers_generation = self.session.clipboard.layers_generation;
+        let r = self.session.execute(id, &params);
+        self.clear_comment_draft_after_tool_set(id, r.is_ok());
+        self.handle_ui_requests();
+        self.invalidate_synthetic_copy(layers_generation);
+        // A command may change the file the window shows (`doc.switch`, `doc.nextTab`,
+        // `file.open`/`file.close`). Record that presentation before returning, so an in-flight
+        // screenshot admitted on the old file cannot accept pixels from the new one.
+        self.observe_presentation();
+        r.map_err(|e| self.failed(id, &e)).ok()
+    }
+
+    /// A programmatic command that changed the engine clipboard never wrote the system clipboard:
+    /// forget the old system mirror so a later user paste does not trust it as our own copy.
+    /// `before` is the layers generation captured before the command ran.
+    pub(crate) fn invalidate_synthetic_copy(&mut self, before: u64) {
+        if self.control_synthetic && self.session.clipboard.layers_generation != before {
+            self.ui.last_copy = None;
+        }
+    }
+
+    /// Record the file the window drawing now shows, with a monotonic generation that changes on
+    /// every switch (an A→B→A switch is two generations, never the admitted one again).
+    pub(crate) fn observe_presentation(&mut self) {
+        let window = self.windows.current;
+        self.windows.presentation(&self.session, window);
+    }
+
+    /// [`run`](Self::run) for something the user did (a dialog, a drop, a paste, a recent file):
+    /// a file it imports shows its import report. Programmatic calls use `run` and never open one.
+    pub fn run_user(&mut self, id: &str, params: Value) -> Option<Value> {
+        let result = self.run(id, params.clone());
+        if let Some(result) = &result {
+            import_report::capture(self, id, &params, result);
+        }
+        missing_fonts::check_later(self, id, result.as_ref());
+        result
+    }
+
+    /// Show command `id`'s error.
+    pub(crate) fn failed(&mut self, id: &str, e: &figcraft_engine::EngineError) {
+        let msg = e.to_string();
+        log::warn!("{id}: {msg}");
+        self.show_error(msg);
+    }
+
+    /// Show an error as a toast, kept as the last error.
+    pub(crate) fn show_error(&mut self, msg: String) {
+        self.toast(msg.clone());
+        self.ui.last_error = Some(msg);
+    }
+
+    /// Run a command that may talk to a server without waiting for it (the engine's
+    /// [`start_background`](Session::start_background)): `done` gets the result, at once or when
+    /// the answer arrives (the network wakes the window then); errors show as with [`run`](Self::run).
+    /// [`Session::waiting_for`] tells the panels to show that it's on its way.
+    pub fn run_background(&mut self, ctx: &egui::Context, id: &str, params: Value, done: Done) {
+        self.waiting.retain(|(c, _)| c != id);
+        let r = self.session.start_background(id, params);
+        self.handle_ui_requests();
+        match r {
+            Ok(Some(v)) => done(self, ctx, v),
+            Ok(None) => self.waiting.push((id.to_string(), done)),
+            Err(e) => self.failed(id, &e),
+        }
+    }
+
+    /// Stop waiting for command `id` (Cancel, or its window closed): its answer is dropped.
+    pub fn cancel_background(&mut self, id: &str) {
+        self.session.cancel_background(id);
+        self.waiting.retain(|(c, _)| c != id);
+    }
+
+    /// Hand the results of background commands that finished to what's waiting for them.
+    fn background_done(&mut self, ctx: &egui::Context) {
+        while let Some((id, r)) = self.session.take_background_done() {
+            self.handle_ui_requests();
+            let done = self.waiting.iter().position(|(c, _)| *c == id).map(|i| self.waiting.remove(i).1);
+            match (r, done) {
+                (Ok(v), Some(done)) => done(self, ctx, v),
+                (Ok(_), None) => {}
+                (Err(e), _) => self.failed(&id, &e),
+            }
+        }
+    }
+
+    /// Dev Mode (the Inspect tab): the canvas measures on hover without Alt and edits nothing;
+    /// entering it ends editing text or vectors.
+    pub(super) fn sync_dev_mode(&mut self) {
+        let dev = self.ui.right_tab == RightTab::Inspect;
+        if dev && !self.session.tool.dev_mode {
+            let _ = self.session.drop_gesture();
+            let editing = self.session.ds().map(|d| (d.text_edit.is_some(), d.vector_edit.is_some())).unwrap_or_default();
+            for (on, cmd) in [(editing.0, "text.edit.end"), (editing.1, "vector.edit.end")] {
+                if on {
+                    self.run(cmd, json!({}));
+                }
+            }
+        }
+        self.session.tool.dev_mode = dev;
+    }
+
+    /// Act on UI requests queued by commands (dialogs, panels).
+    pub fn handle_ui_requests(&mut self) {
+        let reqs = std::mem::take(&mut self.session.ui_requests);
+        for r in reqs {
+            match r.kind.as_str() {
+                "dialog.about" => {
+                    self.ui.about = true;
+                    self.ui.about_tab = dialogs::AboutTab::About;
+                }
+                "dialog.preferences" => self.ui.preferences = true,
+                "dialog.missingFonts" => missing_fonts::request(self),
+                "panel.shortcuts" => self.ui.shortcuts_panel = !self.ui.shortcuts_panel,
+                "palette.actions" => menus::toggle_palette(&mut self.ui),
+                "panel.design" if self.session.doc().is_ok_and(figcraft_engine::board::is_board) => self.ui.board_panel = !self.ui.board_panel,
+                "panel.design" => self.ui.right_tab = RightTab::Design,
+                "board.editText" => {
+                    if let Some(id) = r.data.get("id").and_then(figcraft_engine::params::id_of)
+                        && let Err(e) = figcraft_engine::board::edit_text(&mut self.session, id)
+                    {
+                        self.toast(e.to_string());
+                    }
+                }
+                "panel.prototype" => self.ui.right_tab = RightTab::Prototype,
+                "panel.designPrototype" => {
+                    self.ui.right_tab = if self.ui.right_tab == RightTab::Prototype { RightTab::Design } else { RightTab::Prototype };
+                }
+                "panel.devMode" => {
+                    self.ui.right_tab = if self.ui.right_tab == RightTab::Inspect { RightTab::Design } else { RightTab::Inspect };
+                }
+                "panel.leftSidebar" => {
+                    let shown = if self.ui.narrow { self.ui.mobile_panel == Some(MobilePanel::Left) } else { !self.ui.left_collapsed };
+                    if shown {
+                        self.ui.close_left_panel();
+                    } else {
+                        self.ui.open_left_panel();
+                    }
+                }
+                "panel.widths" => {
+                    let width = |k: &str| r.data.get(k).and_then(Value::as_f64).map(|w| w as f32);
+                    let (left, right) = (width("left"), width("right"));
+                    let reset = left.is_none() && right.is_none();
+                    self.set_panel_widths(
+                        left.unwrap_or(if reset { PANEL_DEFAULT } else { self.ui.left_width }),
+                        right.unwrap_or(if reset { PANEL_DEFAULT } else { self.ui.right_width }),
+                    );
+                    self.services.save_prefs(&self.session.prefs);
+                }
+                "focus.region" => self.ui.nav.step(r.data.get("step").and_then(Value::as_i64).unwrap_or(1).clamp(-4, 4) as i32),
+                "panel.layers" => self.ui.left_tab = LeftTab::File,
+                "panel.assets" => {
+                    self.ui.left_tab = LeftTab::Assets;
+                    self.ui.open_left_panel();
+                    self.ui.versions = Default::default();
+                }
+                "panel.versionHistory" => versions::open(self),
+                "view.devCompare" => {
+                    self.ui.dev.compare = dev_compare::CompareView::requested(&r.data);
+                }
+                "panel.libraries" => {
+                    self.ui.left_tab = LeftTab::Assets;
+                    self.ui.open_left_panel();
+                    self.ui.libraries = true;
+                }
+                "home" => self.ui.home = true,
+                "home.templates" => {
+                    self.ui.home = true;
+                    self.ui.home_view.section = home::Section::Templates;
+                }
+                "home.gettingStarted" => {
+                    self.ui.home = true;
+                    self.ui.home_view.section = home::Section::Recents;
+                    self.services.save_prefs(&self.session.prefs);
+                }
+                "dialog.saveAs" => self.save_as_dialog(),
+                "dialog.colorProfile" => self.ui.color_profile = self.session.doc().ok().map(|d| d.color_profile),
+                "present" => {
+                    if let Some(start) = r.data.get("start").and_then(figcraft_engine::params::id_of) {
+                        tabs::open_present(self, start);
+                    }
+                }
+                "present.options" => {
+                    let v = &mut self.ui.present_view;
+                    if let Some(s) = r.data.get("scale").and_then(|s| s.as_str()).and_then(present::PresentScale::parse) {
+                        v.scale = s;
+                    }
+                    if let Some(f) = r.data.get("deviceFrame").and_then(|f| f.as_bool()) {
+                        v.device_frame = f;
+                    }
+                    if let Some(h) = r.data.get("hotspotHints").and_then(|h| h.as_bool()) {
+                        v.hotspot_hints = h;
+                    }
+                    if let Some(i) = r.data.get("inspect").and_then(|i| i.as_bool()) {
+                        v.inspect = i;
+                    }
+                    if let Some(p) = self.ui.present.as_mut() {
+                        p.view.device_frame = v.device_frame;
+                        p.view.hotspot_hints = v.hotspot_hints;
+                        p.view.inspect = v.inspect;
+                        p.set_scale(v.scale);
+                    }
+                }
+                "preview" => {
+                    if let Some(start) = r.data.get("start").and_then(figcraft_engine::params::id_of) {
+                        self.ui.preview = Some(present::Pane::new(start, &self.session));
+                    }
+                }
+                "preview.close" => self.ui.preview = None,
+                "open.help" => self.services.open_url("https://getartcraft.com/apps/figcraft"),
+                "layers.collapseAll" => layers::collapse_all(self),
+                "contextMenu" => self.ui.key_menu = true,
+                "selectArea" => self.start_key_box(),
+                "canvas.renameLabel" => {
+                    self.ui.rename_label = r.data.get("id").and_then(figcraft_engine::params::id_of).map(|id| layers::Rename { id, start: true });
+                }
+                "layers.rename" => {
+                    let ids: Vec<NodeId> =
+                        r.data.get("ids").and_then(Value::as_array).into_iter().flatten().filter_map(figcraft_engine::params::id_of).collect();
+                    if ids.len() > 1 {
+                        dialogs::open_batch_rename(self, &ids);
+                    } else {
+                        layers::start_rename(self, &ids);
+                    }
+                }
+                "comment.open" => {
+                    if let Some(id) = r.data.get("id").and_then(Value::as_u64) {
+                        self.ui.comments.show(id);
+                    }
+                }
+                "comment.new" => {
+                    let x = r.data.get("x").and_then(|v| v.as_f64()).unwrap_or(0.0);
+                    let y = r.data.get("y").and_then(|v| v.as_f64()).unwrap_or(0.0);
+                    comments::start_draft(self, x, y);
+                }
+                "dialog.unsaved" => self.toast(i18n::tr("This file has unsaved changes")),
+                "dialog.plugins" => self.ui.plugins_window = true,
+                "dialog.pluginSave" => plugins_ui::save_file(self, &r.data),
+                "dialog.cursorChat" => live::open_chat(self),
+                "window.new" | "window.focus" | "window.fullscreen" => self.window_requests.push(r),
+                _ => {}
+            }
+        }
+        if let Some(m) = self.session.message.take() {
+            self.toast(m);
+        }
+    }
+
+    /// Work safe from a logic-only callback (`App::logic`, which also runs while hidden) and from
+    /// a normal UI pass: consumed control work, live polling, background completions, autosave and
+    /// recovery deadlines. It never reads UI input, so it must not scan events, run shortcuts or
+    /// lay out anything.
+    pub fn background_tick(&mut self, ctx: &egui::Context) {
+        crate::control::background(self, ctx);
+        // What happened in a live session (the network woke us for it).
+        if self.session.live_poll() {
+            if let Some(m) = self.session.message.take() {
+                self.toast(live::failure_text(&m));
+            }
+            self.background_done(ctx);
+        }
+        // Files that arrived without a command (joined, recovered) take the kept View toggles too.
+        self.session.apply_view_prefs();
+        let now = self.clock.now();
+        self.autosave_tick(ctx, now);
+        self.auto_save_tick(ctx, now);
+        updates_ui::tick(self, ctx);
+        self.logic_ticked = true;
+    }
+}
diff --git a/crates/ui-egui/src/app/control.rs b/crates/ui-egui/src/app/control.rs
new file mode 100644
index 00000000..bbbe9c61
--- /dev/null
+++ b/crates/ui-egui/src/app/control.rs
@@ -0,0 +1,110 @@
+use super::*;
+
+impl FigApp {
+    /// Queue raw input injected through the control channel for the window drawing next, tagged
+    /// with the document it belongs to (a batch is dropped if another file is active by then).
+    pub(crate) fn push_control_input(&mut self, events: Vec<egui::Event>) -> bool {
+        if events.is_empty() {
+            return false;
+        }
+        let doc = self.session.docs.get(self.session.active).map(|d| d.uid);
+        if !self.control_input.is_empty() && self.control_input_doc != doc {
+            // A queued batch belongs to the file that was open when it was injected; it cannot be
+            // merged with one for the file showing now. Its acknowledgement says so.
+            self.control_input.clear();
+            let viewport = crate::windows::viewport(self.windows.current);
+            crate::windows::fail_input_acks(self, viewport);
+        }
+        // Always the live pane vector: while a child window draws, `windows::enter` has swapped
+        // its pane into the app, and `leave` swaps these events back into that pane.
+        self.control_input.extend(events);
+        self.control_input_doc = doc;
+        self.control_synthetic = true;
+        true
+    }
+
+    /// The acknowledgements waiting for `viewport`'s input batch (other windows keep theirs).
+    pub(crate) fn take_input_acks(&mut self, viewport: egui::ViewportId) -> Vec<PendingAck> {
+        let mut mine = Vec::new();
+        for ack in std::mem::take(&mut self.input_acks) {
+            if ack.viewport == viewport {
+                mine.push(ack);
+            } else {
+                self.input_acks.push(ack);
+            }
+        }
+        mine
+    }
+
+    /// UI state as JSON (control channel `ui.inspect`).
+    pub fn inspect(&self) -> Value {
+        let mut state = json!({
+            "rightTab": self.ui.right_tab,
+            "leftTab": self.ui.left_tab,
+            "home": self.ui.home,
+            "online": online::inspect(self),
+            "tabs": self.session.docs.iter().map(|d| json!({"name": d.doc.name, "live": tabs::live_mark(self, d.uid).map(|shared| if shared { "shared" } else { "private" })})).collect::<Vec<_>>(),
+            "homeSection": self.ui.home_view.section.id(),
+            "homeRecents": home_recents::inspect(self),
+            "dark": self.ui.dark,
+            "focus": {"region": self.ui.nav.region.id(), "keyboard": self.ui.nav.keyboard},
+            "reduceMotion": self.reduce_motion(),
+            "presenting": self.ui.present.is_some(),
+            "presenter": tabs::shown_or_paused(self).map(present::Presenter::inspect),
+            "presentOptions": {"scale": self.ui.present_view.scale.id(), "deviceFrame": self.ui.present_view.device_frame, "comments": self.ui.present_view.comments, "hotspotHints": self.ui.present_view.hotspot_hints, "inspect": self.ui.present_view.inspect},
+            "preview": self.ui.preview.as_ref().map(|p| p.player.inspect()),
+            "mainMenu": self.ui.main_menu,
+            "palette": self.ui.palette.is_some(),
+            "variables": self.ui.variables.is_some(),
+            "versionHistory": self.ui.versions.open,
+            "branchReview": self.ui.branch_review.as_ref().map(|r| json!({"id": r.id, "picks": r.picks, "mode": if r.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }})),
+            "devCompare": self.ui.dev.compare.as_ref().map(|c| json!({"id": c.id, "mode": if c.mode == dev_compare::Mode::Overlay { "overlay" } else { "sideBySide" }, "split": c.split, "version": c.version})),
+            "devFocus": self.session.ds().ok().and_then(figcraft_engine::DocState::focused),
+            "annotationFilter": self.ui.dev.categories.id(),
+            "colorProfileDialog": self.ui.color_profile.map(|p| p.id()),
+            "stylePicker": self.ui.style_picker.as_ref().map(|p| p.slot().key()),
+            "stylePickerView": if self.ui.style_grid { "grid" } else { "list" },
+            "textPreview": figcraft_engine::textpreview::active(&self.session),
+            "comments": {
+                "open": self.ui.comments.open,
+                "draft": self.ui.comments.draft.as_ref().map(|d| [d.0, d.1]),
+                "filter": self.ui.comments.filter.id(),
+                "sort": self.ui.comments.sort.id(),
+                "search": self.ui.comments.search,
+                "editing": self.ui.comments.editing.as_ref().map(|e| [e.0, e.1 as u64]),
+                "mentions": self.ui.comments.mention.names(),
+            },
+            "frameMs": self.ui.frame_ms,
+            "renderMs": self.ui.render_ms,
+            "framesDrawn": self.frame_stats.frames,
+            "repaintCauses": self.frame_stats.causes(),
+            "canvas": {
+                "rect": [self.canvas.rect.min.x, self.canvas.rect.min.y, self.canvas.rect.max.x, self.canvas.rect.max.y],
+                "renderWork": self.canvas.render_work.map(|w| match w {
+                    figcraft_render::Work::Reused => json!({"kind": "reused"}),
+                    figcraft_render::Work::Partial { pixels } => json!({"kind": "partial", "pixels": pixels}),
+                    figcraft_render::Work::Full => json!({"kind": "full"}),
+                }),
+                "quality": if self.canvas.tex_coarse { "preview" } else { "refined" },
+                "previewLatencyMs": self.canvas.preview_latency_ms,
+                "refineLatencyMs": self.canvas.refine_latency_ms,
+            },
+            "live": live::inspect(self),
+            "window": self.windows.current,
+            "windows": windows::list(self),
+            "tool": self.session.tool_info(),
+            "cursor": self.canvas.cursor.map(cursors::Shown::name),
+            "panels": {"left": self.ui.left_width, "right": self.ui.right_width, "leftCollapsed": self.ui.left_collapsed},
+            "status": self.session.status(),
+            "lastError": self.ui.last_error,
+            "importReport": self.ui.import_report.as_ref().map(import_report::Report::inspect),
+        });
+        state["homeSearch"] = json!(self.ui.home_view.file_query);
+        // Set apart from the literal above, which is at the macro recursion limit.
+        state["uiScale"] = json!({"choice": self.session.prefs.ui_scale, "zoom": self.ui.ui_scale.zoom, "drawn": self.ui.ui_scale.drawn, "limited": self.ui.ui_scale.limited});
+        state["pendingOpens"] = json!(self.ui.pending_opens.len());
+        state["missingFonts"] = json!(self.ui.missing_fonts.as_ref().map(missing_fonts::Shown::inspect));
+        state["presentTabs"] = tabs::present_tabs_inspect(self);
+        state
+    }
+}
diff --git a/crates/ui-egui/src/app/files.rs b/crates/ui-egui/src/app/files.rs
new file mode 100644
index 00000000..ae17b7bc
--- /dev/null
+++ b/crates/ui-egui/src/app/files.rs
@@ -0,0 +1,298 @@
+use super::*;
+
+impl FigApp {
+    pub fn save_as_dialog(&mut self) {
+        if self.services.downloads() {
+            if let Some(r) = self.run("file.saveAs", json!({"data": true}))
+                && self.download(r["name"].as_str().unwrap_or_default(), &r)
+            {
+                self.run("file.markSaved", json!({}));
+                dialogs::file_saved(self, &r);
+            }
+            return;
+        }
+        let Ok(name) = self.session.doc().map(|d| d.name.clone()) else { return };
+        self.pick_save(i18n::tr("Save as"), &format!("{name}.figcraft"), &["figcraft", "fig"], |app, mut p| {
+            if p.extension().is_none_or(OsStr::is_empty) {
+                if !p.set_extension("figcraft") {
+                    app.toast(i18n::tr("Use the .figcraft or .fig extension."));
+                    return;
+                }
+                // This name wasn't confirmed by the system dialog: don't replace an existing file.
+                match p.try_exists() {
+                    Ok(false) => {}
+                    Ok(true) => {
+                        app.toast(i18n::tr("A .figcraft file with this name already exists. Choose its full name to confirm replacement."));
+                        return;
+                    }
+                    Err(e) => {
+                        app.toast(e.to_string());
+                        return;
+                    }
+                }
+            } else if !p.extension().and_then(OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("figcraft") || e.eq_ignore_ascii_case("fig")) {
+                app.toast(i18n::tr("Use the .figcraft or .fig extension."));
+                return;
+            }
+            if let Some(r) = app.run("file.saveAs", json!({"path": p.to_string_lossy()})) {
+                dialogs::file_saved(app, &r);
+            }
+        });
+    }
+
+    pub fn save(&mut self) {
+        // A branch tab saves its main file.
+        let tab = figcraft_engine::branches::file_tab(&self.session);
+        // A path ending in .fig is never saved over silently: a .fig destination is an export copy.
+        let native_path = self
+            .session
+            .docs
+            .get(tab)
+            .and_then(|d| d.path.as_deref())
+            .is_some_and(|path| !Path::new(path).extension().and_then(OsStr::to_str).is_some_and(|e| e.eq_ignore_ascii_case("fig")));
+        if native_path {
+            if self.run("file.save", json!({})).is_some() {
+                self.toast(i18n::tr("Saved"));
+            }
+        } else {
+            self.save_as_dialog();
+        }
+    }
+
+    pub fn open_dialog(&mut self) {
+        // Opening needs no file in front: it goes ahead even if that file closed meanwhile.
+        self.pick_file(i18n::tr("Open"), OPEN_EXTENSIONS, false, |app, file| {
+            if app.run_user("file.open", file).is_some() {
+                app.ui.home = false;
+            }
+        });
+    }
+
+    pub fn import_dialog(&mut self, place: bool) {
+        let exts: &[&str] = if place {
+            &["png", "jpg", "jpeg", "webp", "gif", "tif", "tiff"]
+        } else {
+            &["svg", "png", "jpg", "jpeg", "webp", "gif", "tif", "tiff", "figcraft", "fig", "sketch"]
+        };
+        let title = if place { i18n::tr("Place image") } else { i18n::tr("Import") };
+        self.pick_file(title, exts, true, |app, file| {
+            app.run_user("file.import", file);
+        });
+    }
+
+    /// Pick a file to open or import; `done` gets it as `file.open` and `file.import` take it (a
+    /// path, or the name and contents where the platform has no paths). `pin`: as
+    /// [`FigApp::pick_open`]'s file in front.
+    fn pick_file(&mut self, title: &str, exts: &[&str], pin: bool, done: impl FnOnce(&mut FigApp, Value) + 'static) {
+        self.start_pick(
+            |services| -> PickFuture {
+                match services.pick_open_contents(title, exts) {
+                    Some(read) => {
+                        Box::pin(async move { read.await.map(|r| r.map_or_else(Picked::Unreadable, |(name, bytes)| Picked::Contents(name, bytes))) })
+                    }
+                    None => {
+                        let pick = services.pick_open(title, exts);
+                        Box::pin(async move { pick.await.map(Picked::Path) })
+                    }
+                }
+            },
+            pin,
+            move |app, picked| match picked.file_params() {
+                Ok(file) => done(app, file),
+                Err(why) => app.show_error(why),
+            },
+        );
+    }
+
+    /// Pick a file to open. `done` runs with the file in front now back in front (and not at all
+    /// if that file closed meanwhile).
+    pub fn pick_open(&mut self, title: &str, exts: &[&str], done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
+        self.start_dialog(|services| services.pick_open(title, exts), true, done);
+    }
+
+    /// Pick where to save; `done` runs as [`FigApp::pick_open`]'s does.
+    pub fn pick_save(&mut self, title: &str, name: &str, exts: &[&str], done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
+        self.start_dialog(|services| services.pick_save(title, name, exts), true, done);
+    }
+
+    /// Hand a command result's base64 `data` over as a download named `name`, where the platform
+    /// saves by downloads rather than save dialogs (the browser, #969). Says so when nothing arrived.
+    pub(crate) fn download(&mut self, name: &str, result: &Value) -> bool {
+        use base64::Engine as _;
+        let bytes = result["data"].as_str().and_then(|d| base64::engine::general_purpose::STANDARD.decode(d).ok());
+        if bytes.is_some_and(|b| self.services.download(name, &b)) {
+            return true;
+        }
+        self.toast(i18n::trf("Couldn't download {name}", &[("name", &name)]));
+        false
+    }
+
+    /// Pick a folder; `done` runs as [`FigApp::pick_open`]'s does.
+    pub fn pick_folder(&mut self, title: &str, done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
+        self.start_dialog(|services| services.pick_folder(title), true, done);
+    }
+
+    /// Open a native dialog from the window drawing now, for the file in front (`pin`).
+    fn start_dialog(&mut self, start: impl FnOnce(&mut dyn Services) -> DialogFuture, pin: bool, done: impl FnOnce(&mut FigApp, PathBuf) + 'static) {
+        self.start_pick(
+            |services| -> PickFuture {
+                let pick = start(services);
+                Box::pin(async move { pick.await.map(Picked::Path) })
+            },
+            pin,
+            move |app, picked| {
+                if let Picked::Path(p) = picked {
+                    done(app, p);
+                }
+            },
+        );
+    }
+
+    /// [`FigApp::start_dialog`] for any kind of pick.
+    fn start_pick(&mut self, start: impl FnOnce(&mut dyn Services) -> PickFuture, pin: bool, done: impl FnOnce(&mut FigApp, Picked) + 'static) {
+        if self.pending_dialog.is_some() {
+            return;
+        }
+        let doc = if pin { self.session.ds().ok().filter(|d| self.shows(d.uid)).map(|d| d.uid) } else { None };
+        let future = start(self.services.as_mut());
+        self.pending_dialog = Some(PendingDialog { future, picked: None, done: Box::new(done), doc, window: self.windows.current });
+        if let Some(ctx) = &self.ui_context {
+            ctx.request_repaint();
+        }
+    }
+
+    /// Once the dialog has a path, its continuation runs in the window that holds its file, with
+    /// that file in front; then the tab in front before comes back (unless the dialog opened a file).
+    pub(crate) fn poll_dialog(&mut self, ctx: &egui::Context) {
+        let Some(d) = &mut self.pending_dialog else { return };
+        if d.picked.is_none() {
+            let waker = Waker::from(Arc::new(RepaintWaker(ctx.clone())));
+            let Poll::Ready(picked) = d.future.as_mut().poll(&mut TaskContext::from_waker(&waker)) else { return };
+            d.picked = picked;
+        }
+        let (doc, origin, picked) = (d.doc, d.window, d.picked.is_some());
+        let index = doc.map(|u| self.session.docs.iter().position(|ds| ds.uid == u));
+        // Cancelled, or its file closed meanwhile.
+        if !picked || index == Some(None) {
+            self.pending_dialog = None;
+            return;
+        }
+        let window = match doc {
+            Some(u) => self.windows.of(u),
+            None if self.windows.exists(origin) => origin,
+            None => 0,
+        };
+        if window != self.windows.current {
+            ctx.request_repaint_of(windows::viewport(window));
+            return;
+        }
+        let Some(PendingDialog { picked: Some(picked), done, .. }) = self.pending_dialog.take() else { return };
+        let before = self.session.ds().ok().map(|d| d.uid);
+        if let Some(Some(i)) = index {
+            self.session.active = i;
+        }
+        done(self, picked);
+        if doc.is_some()
+            && self.session.ds().ok().map(|d| d.uid) == doc
+            && let Some(i) = before.and_then(|u| self.session.docs.iter().position(|d| d.uid == u))
+        {
+            self.session.active = i;
+        }
+    }
+
+    /// Every [`AUTOSAVE_SECS`], each open document with unsaved changes since its last version
+    /// gets an autosave checkpoint in its version history.
+    pub(super) fn autosave_tick(&mut self, ctx: &egui::Context, now: f64) {
+        if now < self.ui.next_autosave {
+            // Wake up for it even if nothing else draws a frame by then.
+            repaint_in(ctx, self.ui.next_autosave - now);
+            return;
+        }
+        if self.ui.next_autosave > 0.0 {
+            let active = self.session.active;
+            for i in 0..self.session.docs.len() {
+                self.session.active = i;
+                let _ = self.session.execute("version.autosave", &json!({}));
+            }
+            self.session.active = active;
+        }
+        self.ui.next_autosave = now + AUTOSAVE_SECS;
+        repaint_in(ctx, AUTOSAVE_SECS);
+    }
+
+    /// With auto-save on, files that have a path are saved [`AUTO_SAVE_SECS`] after they last
+    /// changed (not during a gesture, a live preview or while a version is shown). The file is
+    /// encoded on a thread of its own, so a big one doesn't hold up the window, and written here.
+    pub(super) fn auto_save_tick(&mut self, ctx: &egui::Context, now: f64) {
+        let mut failed = self.auto_save_done();
+        // The browser has no files to save to.
+        let on = !cfg!(target_arch = "wasm32") && self.session.prefs.auto_save;
+        let saving = &self.ui.auto_saving;
+        let due = |d: &&figcraft_engine::DocState| {
+            d.path.as_deref().is_some_and(|p| d.images_lost_saving_to(p).is_none())
+                && d.branch_of.is_none()
+                && d.preview.is_none()
+                && d.is_dirty()
+                && !saving.iter().any(|(uid, _)| *uid == d.uid)
+        };
+        let changes = if on { self.session.docs.iter().filter(due).map(|d| d.revision).reduce(u64::wrapping_add) } else { None };
+        match changes {
+            None => self.ui.auto_save_at = None,
+            Some(changes) => {
+                let at = match self.ui.auto_save_at {
+                    Some((at, c)) if c == changes && failed.is_none() => at,
+                    _ => now + if failed.is_some() { AUTO_SAVE_RETRY_SECS } else { AUTO_SAVE_SECS },
+                };
+                self.ui.auto_save_at = Some((at, changes));
+                if now < at || self.session.docs.iter().any(|d| d.interaction.is_some() || d.text_preview.is_some()) {
+                    // Due but busy: look again in a second.
+                    repaint_in(ctx, if now < at { at - now } else { 1.0 });
+                } else {
+                    self.ui.auto_save_at = None;
+                    let files: Vec<_> =
+                        self.session.docs.iter().filter(due).map(|d| (d.uid, figcraft_engine::cmd::file::FileSnapshot::of(d))).collect();
+                    for (uid, file) in files {
+                        let encode = move || {
+                            let bytes = file.encode();
+                            (file, bytes)
+                        };
+                        match std::thread::Builder::new().name("figcraft-save".into()).spawn(encode) {
+                            Ok(h) => self.ui.auto_saving.push((uid, h)),
+                            Err(e) => {
+                                failed.get_or_insert(e.to_string());
+                                self.ui.auto_save_at = Some((now + AUTO_SAVE_RETRY_SECS, changes));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if !self.ui.auto_saving.is_empty() {
+            // Look again shortly for the files being encoded.
+            repaint_in(ctx, 0.1);
+        }
+        if let Some(e) = failed {
+            self.toast(i18n::trf("Couldn't save automatically: {error}", &[("error", &e)]));
+        }
+    }
+
+    /// Write the files whose auto-save encoding finished; the first error, if one failed.
+    fn auto_save_done(&mut self) -> Option<String> {
+        if self.ui.auto_saving.is_empty() {
+            return None;
+        }
+        let mut failed = None;
+        let done: Vec<_> = self.ui.auto_saving.extract_if(.., |(_, h)| h.is_finished()).collect();
+        for (_, h) in done {
+            let saved = match h.join() {
+                Ok((snapshot, Ok(bytes))) => snapshot.save(&mut self.session, &bytes).map(|_| ()).map_err(|e| e.to_string()),
+                Ok((_, Err(e))) => Err(e.to_string()),
+                Err(_) => Err("the file couldn't be encoded".to_string()),
+            };
+            if let Err(e) = saved {
+                failed.get_or_insert(e);
+            }
+        }
+        failed
+    }
+}
diff --git a/crates/ui-egui/src/app/frame.rs b/crates/ui-egui/src/app/frame.rs
new file mode 100644
index 00000000..96225f20
--- /dev/null
+++ b/crates/ui-egui/src/app/frame.rs
@@ -0,0 +1,255 @@
+use super::*;
+
+impl FigApp {
+    /// Show what `command params` would do on the canvas as a live preview (`text.preview`) while
+    /// a font family, font style, text style, named instance or axis slider is hovered or dragged. Call it every frame
+    /// the preview should stay: it ends on the first frame nothing asks for it.
+    pub fn preview_text(&mut self, ctx: &egui::Context, command: &str, params: Value) {
+        self.ui.text_preview_wanted = true;
+        let revision = self.session.ds().map_or(0, |d| d.revision);
+        if let Some((c, p, rev)) = &self.ui.text_preview
+            && c == command
+            && *p == params
+            && (*rev == revision || figcraft_engine::textpreview::active(&self.session))
+        {
+            return;
+        }
+        let shown = self.session.execute("text.preview", &json!({"command": command, "params": params})).is_ok();
+        let revision = self.session.ds().map_or(0, |d| d.revision);
+        self.ui.text_preview = shown.then(|| (command.to_string(), params, revision));
+        // The canvas drew before the panels: show the preview next frame.
+        ctx.request_repaint();
+    }
+
+    /// End the live text preview the panels show (Escape, or nothing hovered any more).
+    pub fn end_text_preview(&mut self, ctx: &egui::Context) {
+        if self.ui.text_preview.take().is_some() {
+            let _ = self.session.execute("text.endPreview", &json!({}));
+            ctx.request_repaint();
+        }
+    }
+
+    /// Leaving Design ends a pen path as Escape does and goes back to Move: Prototype and Inspect
+    /// don't draw (#307). Checked as the frame starts (the control channel) and after the panels
+    /// and shortcuts (the mode switcher, the tabs, Shift+E/Shift+D), before the canvas sees more.
+    pub(super) fn end_pen_outside_design(&mut self) {
+        if self.ui.right_tab == self.ui.last_right_tab {
+            return;
+        }
+        self.ui.last_right_tab = self.ui.right_tab;
+        if self.ui.right_tab != RightTab::Design && self.session.tool.tool == figcraft_engine::tools::ToolId::Pen {
+            self.run("tool.set", json!({"tool": "move"}));
+        }
+    }
+
+    /// Once a frame, after the panels: a preview nothing asked for this frame ends.
+    pub(super) fn end_unwanted_text_preview(&mut self, ctx: &egui::Context) {
+        if !std::mem::take(&mut self.ui.text_preview_wanted) {
+            self.end_text_preview(ctx);
+        }
+    }
+
+    /// Finish the frame that applies an injected batch: acknowledge it once the pass is presented,
+    /// and stop fencing the system clipboard. Only the viewport whose batch this frame took acts.
+    pub(crate) fn end_input_frame(&mut self, ctx: &egui::Context) {
+        if self.applied_frame != Some(ctx.viewport_id()) {
+            return;
+        }
+        self.applied_input = None;
+        if ctx.will_discard() {
+            // Keep `applied_frame`/`applied_acks`: the rerun pass must present (and acknowledge)
+            // the same frame without replaying the input.
+            return;
+        }
+        self.applied_frame = None;
+        for ack in self.applied_acks.drain(..) {
+            let _ = ack.tx.send(ack.reply);
+        }
+        self.control_synthetic = false;
+    }
+
+    /// The app's monotonic clock in seconds, also usable from logic-only callbacks (recovery,
+    /// control deadlines). Never `ctx.input(i.time)`, which is stale there.
+    pub fn now_secs(&self) -> f64 {
+        self.clock.now()
+    }
+
+    pub fn toast(&mut self, msg: impl Into<String>) {
+        self.ui.toast = Some((msg.into(), ToastClock::Raised));
+    }
+
+    /// Say that `n` documents left unsaved by a crash were opened again from recovery copies.
+    pub fn note_recovered(&mut self, n: usize) {
+        if n > 0 {
+            self.toast(i18n::trn("Recovered {n} unsaved files after the app quit unexpectedly: save them to keep them", n, &[]));
+        }
+    }
+
+    /// Set the widths asked for this window's side panels (within their limits); the main
+    /// window's are kept in the preferences.
+    pub fn set_panel_widths(&mut self, left: f32, right: f32) {
+        let within = |w: f32, range: std::ops::RangeInclusive<f32>| if w.is_finite() { w.clamp(*range.start(), *range.end()) } else { PANEL_DEFAULT };
+        (self.ui.left_width, self.ui.right_width) = (within(left, LEFT_PANEL), within(right, RIGHT_PANEL));
+        if self.windows.current == 0 {
+            self.session.prefs.panel_widths = (self.ui.left_width, self.ui.right_width);
+        }
+    }
+
+    /// The edge between a side panel and the canvas, at `x` down `rows`: dragging it sizes the
+    /// panel (`grows`: +1 for the left panel, whose edge is on its right, −1 for the right one), a
+    /// double-click puts back the default width. Returns the width asked for, when it changed.
+    pub(super) fn panel_edge(ui: &mut egui::Ui, name: &str, x: f32, rows: egui::Rangef, width: f32, grows: f32) -> Option<f32> {
+        let grab = ui.style().interaction.resize_grab_radius_side;
+        let rect = egui::Rect::from_x_y_ranges(x - grab..=x + grab, rows);
+        let id = egui::Id::unique(("panel_edge", name));
+        // Not focusable: an edge is a pointer target, so it must not take Tab/F6 focus from the
+        // panels' controls (see `a11y::focusables`).
+        let resp = ui.interact(rect, id, egui::Sense::CLICK | egui::Sense::DRAG);
+        if resp.hovered() || resp.dragged() {
+            ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
+            ui.painter().vline(x, rows, egui::Stroke::new(2.0, theme::ACCENT));
+        }
+        if resp.double_clicked() {
+            return Some(PANEL_DEFAULT);
+        }
+        // The edge stays under the pointer where it was grabbed (also back from past a limit).
+        let at = resp.interact_pointer_pos().filter(|_| resp.dragged())?;
+        if resp.drag_started() {
+            let pressed = ui.input(|i| i.pointer.press_origin()).unwrap_or(at);
+            ui.data_mut(|d| d.insert_temp(id, pressed.x - x));
+        }
+        let grabbed: f32 = ui.data(|d| d.get_temp(id)).unwrap_or(0.0);
+        let w = width + (at.x - grabbed - x) * grows;
+        (w != width).then_some(w)
+    }
+
+    /// Reduced motion: the preference or the system's setting.
+    pub fn reduce_motion(&self) -> bool {
+        self.session.prefs.reduce_motion || self.services.reduce_motion()
+    }
+
+    /// The CJK, Bengali and Thai scripts the UI shows: the language's, the language picker's (Preferences open),
+    /// typed text's, and those in the open file's names and comments (read when it changes, not
+    /// mid-drag). Nothing is checked once every script has a face.
+    pub(crate) fn cjk_needed(&mut self, ctx: &egui::Context, installed: u8) -> u8 {
+        if installed == cjk::ALL {
+            return installed;
+        }
+        let mut need = i18n::current().map_or(0, |l| cjk::language(l.code));
+        if self.ui.preferences {
+            need |= i18n::languages().iter().filter(|l| cjk::can_show(l.code)).fold(0, |m, l| m | cjk::language(l.code));
+        }
+        need |= ctx.input(|i| {
+            i.events.iter().fold(0, |m, e| match e {
+                egui::Event::Text(t) | egui::Event::Ime(egui::ImeEvent::Preedit { text: t, .. } | egui::ImeEvent::Commit(t)) => m | cjk::scripts(t),
+                _ => m,
+            })
+        });
+        let dragging = ctx.input(|i| i.pointer.any_down());
+        // Pans and zooms change the revision too: only a new version of the document is looked
+        // at, and only the layers it changed (a large file has hundreds of thousands of names).
+        let current = self.session.docs.get(self.session.active).filter(|_| !dragging).map(|d| (d.uid, d.doc.clone()));
+        if let Some((uid, doc)) = current {
+            let before = self.cjk_checked.take().filter(|(u, _)| *u == uid).map(|(_, b)| b);
+            if !before.as_ref().is_some_and(|b| Arc::ptr_eq(b, &doc)) {
+                let mut scan = |s: &str| need |= cjk::scripts(s);
+                scan(&doc.name);
+                match before.as_ref().and_then(|b| doc.changed_ids(b, CJK_CHANGES)) {
+                    Some(ids) => ids.into_iter().filter_map(|id| doc.node(id)).for_each(|n| scan(&n.name)),
+                    None => doc.nodes().for_each(|n| scan(&n.name)),
+                }
+                doc.comments.iter().flat_map(|c| std::iter::once(&c.first).chain(&c.replies)).for_each(|m| {
+                    scan(&m.author);
+                    scan(&m.text);
+                });
+            }
+            self.cjk_checked = Some((uid, doc));
+        }
+        need
+    }
+
+    /// Whether the right panel shows: never with the UI `hidden`; always on a design file; on a
+    /// board, which has no prototypes or Dev Mode (its tab stays Design), only when asked for.
+    pub(super) fn right_panel_shown(&mut self, hidden: bool) -> bool {
+        let board = self.session.doc().is_ok_and(figcraft_engine::board::is_board);
+        if board {
+            self.ui.right_tab = RightTab::Design;
+        }
+        !hidden && (!board || self.ui.board_panel)
+    }
+
+    /// A narrow window's two buttons for the side panels (touch-sized); the open one closes again.
+    pub(super) fn mobile_buttons(&mut self, ctx: &egui::Context, at: egui::Pos2) {
+        use a11y::Tip as _;
+        let t = theme::Tokens::get(ctx);
+        egui::Area::new(egui::Id::unique("mobile_panel_buttons")).order(egui::Order::Foreground).fixed_pos(at).show(ctx, |ui| {
+            for (side, icon, name) in
+                [(MobilePanel::Left, icons::Icon::Layers, i18n::tr("Layers")), (MobilePanel::Right, icons::Icon::Panels, i18n::tr("Design"))]
+            {
+                let open = self.ui.mobile_panel == Some(side);
+                let (r, resp) = ui.allocate_exact_size(egui::vec2(40.0, 40.0), egui::Sense::click());
+                let resp = resp.tip(name);
+                let fill = if open { t.accent } else { t.panel };
+                ui.painter().rect(r, 8.0, fill, egui::Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
+                icons::paint(ui.painter(), r.shrink(10.0), icon, if open { t.accent_on } else { t.icon });
+                if resp.clicked() {
+                    if side == MobilePanel::Left && !open {
+                        self.ui.open_left_panel();
+                    } else {
+                        self.ui.mobile_panel = if open { None } else { Some(side) };
+                    }
+                }
+                ui.add_space(4.0);
+            }
+        });
+    }
+
+    /// Draw the toast: start its lifetime on the frame **after** the first drawn frame, request
+    /// that frame and the frame that hides it, expire and remove it at the deadline, and place it
+    /// at the bottom centre.
+    pub(super) fn toast_ui(&mut self, ctx: &egui::Context) {
+        let Some((msg, clock)) = &mut self.ui.toast else { return };
+        let now = ctx.input(|i| i.time);
+        // The clock starts on the frame after the one that first draws the toast: that frame's
+        // time was taken before whatever raised it ran (a file dialog, a long open), and would
+        // count that wait against it, so a failed open's message expired before it was seen.
+        let left = match *clock {
+            ToastClock::Raised => {
+                *clock = ToastClock::Drawn;
+                ctx.request_repaint();
+                TOAST_SECS
+            }
+            ToastClock::Drawn => {
+                *clock = ToastClock::Since(now);
+                TOAST_SECS
+            }
+            ToastClock::Since(t) => TOAST_SECS - (now - t),
+        };
+        if left <= 0.0 {
+            self.ui.toast = None;
+            return;
+        }
+        let msg = msg.clone();
+        // Nothing moves while it shows: the next frame it needs is the one that hides it.
+        if matches!(clock, ToastClock::Since(_)) {
+            repaint_in(ctx, left);
+        }
+        let screen = ctx.content_rect();
+        egui::Area::new(egui::Id::unique("toast"))
+            .fixed_pos(egui::pos2(screen.center().x, screen.max.y - 96.0))
+            .pivot(egui::Align2::CENTER_BOTTOM)
+            .order(egui::Order::Tooltip)
+            .show(ctx, |ui| {
+                egui::Frame::NONE
+                    .fill(egui::Color32::from_rgb(0x1E, 0x1E, 0x1E))
+                    .corner_radius(egui::CornerRadius::same(8))
+                    .inner_margin(egui::Margin::symmetric(14, 10))
+                    .show(ui, |ui| {
+                        // Wrapped at a readable width (the area alone would wrap at a sliver).
+                        let width = (screen.width() - 64.0).clamp(120.0, 480.0);
+                        let galley = ui.painter().layout(msg, theme::regular(12.0), egui::Color32::WHITE, width);
+                        ui.label(galley);
+                    });
+            });
+    }
+}
diff --git a/crates/ui-egui/src/app/ime.rs b/crates/ui-egui/src/app/ime.rs
new file mode 100644
index 00000000..df0a7fd2
--- /dev/null
+++ b/crates/ui-egui/src/app/ime.rs
@@ -0,0 +1,20 @@
+use super::*;
+
+impl FigApp {
+    /// The pass's one IME observation: the focused on-canvas editor, or an explicit idle.
+    ///
+    /// Calling `ImeContextTracker::observe` more than once in a pass would treat an idle followed
+    /// by a focused observation as a context change (dropping the frame's receipts) and bump the
+    /// generation. Keeping this in one place makes the fork contract structural.
+    pub(super) fn observe_ime(&mut self, ctx: &egui::Context, focused: bool) {
+        #[cfg(test)]
+        {
+            self.ime_observations = self.ime_observations.saturating_add(1);
+        }
+        if focused {
+            shortcuts::ime_output(self, ctx);
+        } else {
+            let _ = self.ime.observe(ctx.viewport_id(), None);
+        }
+    }
+}

From 450675919f0d940e8e370c17c6982ac2d52e2427 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:03:41 +0000
Subject: [PATCH 47/67] refactor(format): split fig/map.rs into map/

---
 crates/format/src/fig/map.rs           | 2781 +-----------------------
 crates/format/src/fig/map/component.rs |  441 ++++
 crates/format/src/fig/map/connector.rs |  271 +++
 crates/format/src/fig/map/document.rs  |  308 +++
 crates/format/src/fig/map/layer.rs     |  699 ++++++
 crates/format/src/fig/map/layout.rs    |  188 ++
 crates/format/src/fig/map/paint.rs     |  291 +++
 crates/format/src/fig/map/proto.rs     |  179 ++
 crates/format/src/fig/map/text.rs      |  270 +++
 crates/format/src/fig/map/variables.rs |  164 ++
 10 files changed, 2825 insertions(+), 2767 deletions(-)
 create mode 100644 crates/format/src/fig/map/component.rs
 create mode 100644 crates/format/src/fig/map/connector.rs
 create mode 100644 crates/format/src/fig/map/document.rs
 create mode 100644 crates/format/src/fig/map/layer.rs
 create mode 100644 crates/format/src/fig/map/layout.rs
 create mode 100644 crates/format/src/fig/map/paint.rs
 create mode 100644 crates/format/src/fig/map/proto.rs
 create mode 100644 crates/format/src/fig/map/text.rs
 create mode 100644 crates/format/src/fig/map/variables.rs

diff --git a/crates/format/src/fig/map.rs b/crates/format/src/fig/map.rs
index 3ad61edb..5f82cb9f 100644
--- a/crates/format/src/fig/map.rs
+++ b/crates/format/src/fig/map.rs
@@ -17,6 +17,20 @@ use serde_json::{Map, Value, json};
 use super::kiwi::Kv;
 use super::network;
 
+mod component;
+mod connector;
+mod document;
+mod layer;
+mod layout;
+mod paint;
+mod proto;
+mod text;
+mod variables;
+
+use component::OverrideScope;
+#[cfg(test)]
+use paint::paint;
+
 type Obj = Map<String, Value>;
 
 /// Deepest nesting followed.
@@ -91,33 +105,10 @@ fn num(n: &Kv, k: &str) -> Option<f64> {
     n.get(k).and_then(Kv::f64)
 }
 
-fn filter_number(value: &Kv) -> Option<f64> {
-    let number = match value {
-        Kv::Float(value) => f64::from(*value),
-        Kv::Int(value) => *value as f64,
-        Kv::Uint(value) => *value as f64,
-        _ => return None,
-    };
-    number.is_finite().then_some(number)
-}
-
 fn guid(v: &Kv) -> Option<String> {
     Some(format!("{}:{}", num(v, "sessionID")? as u64, num(v, "localID")? as u64))
 }
 
-/// An override row names a layer of the main by its current GUID or by the `overrideKey` the
-/// layer had when the row was written: the key becomes the current GUID, unless the layer is
-/// current already or the key is ambiguous.
-fn normalize_override_segment(path: &mut [String], index: usize, scope: &OverrideScope) {
-    let Some(segment) = path.get(index) else { return };
-    if scope.current.contains(segment) {
-        return;
-    }
-    if let Some(Some(current)) = scope.aliases.get(segment) {
-        path[index] = current.clone();
-    }
-}
-
 #[cfg(test)]
 #[path = "map_connector_snapshot_budget_tests.rs"]
 mod connector_snapshot_budget_tests;
@@ -127,20 +118,6 @@ fn ref_guid(v: &Kv) -> Option<String> {
     v.get("guid").and_then(guid).filter(|g| g != NO_STYLE)
 }
 
-/// The style a layer links in `key`, or in the older `legacy` field when `key` names none. An
-/// explicit NO_STYLE in `key` is a detach and wins over the legacy field.
-fn style_link(v: &View, key: &str, legacy: &str) -> Option<String> {
-    match v.get(key).and_then(|r| r.get("guid")).and_then(guid) {
-        Some(id) => Some(id).filter(|g| g != NO_STYLE),
-        None => v.get(legacy).and_then(guid).filter(|g| g != NO_STYLE),
-    }
-}
-
-fn color(c: &Kv) -> Value {
-    let ch = |k: &str| num(c, k).unwrap_or(0.0);
-    json!({"r": ch("r"), "g": ch("g"), "b": ch("b"), "a": num(c, "a").unwrap_or(1.0)})
-}
-
 fn vec2(v: &Kv) -> Option<Value> {
     Some(json!({"x": num(v, "x")?, "y": num(v, "y")?}))
 }
@@ -172,41 +149,6 @@ fn copy_str(o: &mut Obj, n: &View, from: &str, to: &str) {
     }
 }
 
-/// The value from the last override layer holding a valid one for an optional text setting; invalid instance rows fall through.
-fn text_num(v: &View, key: &str) -> Option<f64> {
-    v.layers.iter().rev().find_map(|layer| {
-        layer.get(key).and_then(|value| match value {
-            Kv::Bool(_) => None,
-            _ => value.f64(),
-        })
-    })
-}
-
-fn text_flag(v: &View, key: &str) -> Option<bool> {
-    v.layers.iter().rev().find_map(|layer| layer.get(key).and_then(Kv::bool))
-}
-
-fn insert_text_options(style: &mut Obj, v: &View) {
-    if let Some(value) = text_num(v, "listSpacing") {
-        style.insert("listSpacing".into(), json!(value));
-    }
-    for k in ["hangingList", "hangingPunctuation"] {
-        if let Some(value) = text_flag(v, k) {
-            style.insert(k.into(), json!(value));
-        }
-    }
-    if let Some(value) = leading_trim(v) {
-        style.insert("leadingTrim".into(), json!(value));
-    }
-}
-
-fn leading_trim<'a>(v: &View<'a>) -> Option<&'a str> {
-    v.layers.iter().rev().find_map(|layer| match layer.get("leadingTrim").and_then(Kv::str) {
-        Some(value @ ("NONE" | "CAP_HEIGHT")) => Some(value),
-        _ => None,
-    })
-}
-
 /// A node seen through override layers: the last layer with a field wins.
 #[derive(Clone)]
 struct View<'a> {
@@ -265,111 +207,6 @@ impl<'a> View<'a> {
     }
 }
 
-/// How the layers of a resized container follow it when the file gives no derived layout for
-/// them: a frame's by their constraints, from its main's size to its own; a group's scale with it.
-#[derive(Clone, Copy)]
-enum Fit {
-    Frame { from: (f64, f64), to: (f64, f64) },
-    Scale(f64, f64),
-}
-
-impl Fit {
-    fn frame(from: Option<(f64, f64)>, to: Option<(f64, f64)>) -> Option<Self> {
-        let (from, to) = (from?, to?);
-        ((from.0 - to.0).abs() > 1e-9 || (from.1 - to.1).abs() > 1e-9).then_some(Fit::Frame { from, to })
-    }
-
-    fn scale(from: Option<(f64, f64)>, to: Option<(f64, f64)>) -> Option<Self> {
-        let (from, to) = (from?, to?);
-        let k = |a: f64, b: f64| if a > 1e-9 { b / a } else { 1.0 };
-        let (kx, ky) = (k(from.0, to.0), k(from.1, to.1));
-        ((kx - 1.0).abs() > 1e-9 || (ky - 1.0).abs() > 1e-9).then_some(Fit::Scale(kx, ky))
-    }
-
-    /// The size and transform (in the parent's coordinates) of a `w` × `h` layer at `t` with
-    /// constraints `h_con`, `v_con`. Like the editor's constraint solver, a layer keeps its
-    /// rotation and flip and stretches along its own axes.
-    fn apply(self, w: f64, h: f64, t: Affine, h_con: Option<&str>, v_con: Option<&str>) -> ((f64, f64), Affine) {
-        let [a, b, c, d, _, _] = t.as_coeffs();
-        let lin = Affine::new([a, b, c, d, 0.0, 0.0]);
-        let bb = figcraft_doc::geom::transform_rect_bbox(t, figcraft_doc::geom::Rect::new(0.0, 0.0, w, h));
-        // Where the new box goes: its top-left (constraints) or its centre (a group's scale).
-        let (kx, ky, x0, y0, centred) = match self {
-            Fit::Frame { from, to } => {
-                let axis = |con: Option<&str>, lo: f64, hi: f64, old: f64, new: f64| match con {
-                    Some("MAX" | "FIXED_MAX") => (lo + new - old, hi + new - old),
-                    Some("STRETCH") => (lo, hi + new - old),
-                    Some("CENTER") => (lo + (new - old) / 2.0, hi + (new - old) / 2.0),
-                    Some("SCALE") if old > 1e-9 => (lo * new / old, hi * new / old),
-                    _ => (lo, hi),
-                };
-                let (x0, x1) = axis(h_con, bb.x0, bb.x1, from.0, to.0);
-                let (y0, y1) = axis(v_con, bb.y0, bb.y1, from.1, to.1);
-                let k = |new: f64, old: f64| if old > 1e-9 { (new / old).max(0.0) } else { 1.0 };
-                (k(x1 - x0, bb.width()), k(y1 - y0, bb.height()), x0, y0, false)
-            }
-            Fit::Scale(kx, ky) => (kx, ky, bb.center().x * kx, bb.center().y * ky, true),
-        };
-        let along = |x: f64, y: f64, fallback: f64| {
-            let len = x.hypot(y);
-            let k = (kx * x).hypot(ky * y) / len;
-            if len > 1e-12 && k.is_finite() { k } else { fallback }
-        };
-        let size = (w * along(a, b, kx), h * along(c, d, ky));
-        let nb = figcraft_doc::geom::transform_rect_bbox(lin, figcraft_doc::geom::Rect::new(0.0, 0.0, size.0, size.1));
-        let at = if centred { nb.center() } else { figcraft_doc::geom::Point::new(nb.x0, nb.y0) };
-        (size, Affine::translate((x0 - at.x, y0 - at.y)) * lin)
-    }
-}
-
-/// Overrides and derived layout by id path.
-type Overrides<'a> = BTreeMap<Vec<String>, Vec<OverrideRow<'a>>>;
-
-/// Where an override entry comes from.
-#[derive(Clone, Copy, PartialEq)]
-enum Entry {
-    Override,
-    Derived,
-    /// Derived layout of a nested instance for a size it no longer has: its size and place no
-    /// longer hold, the rest (resolved colours, text) still does.
-    Stale,
-}
-
-/// One override or derived-layout row addressed to a layer.
-#[derive(Clone)]
-struct OverrideRow<'a> {
-    row: &'a Kv<'a>,
-    entry: Entry,
-    /// How many mains are being expanded around the instance that wrote the row: the rows of
-    /// the enclosing (outer) instances win over those of the inner ones.
-    source_depth: usize,
-    /// Position among the rows of the instance that wrote it; later rows win.
-    ordinal: usize,
-}
-
-/// The layers of a main by current GUID, and the old `overrideKey` of each that has one
-/// (`None` when two layers claim the same key).
-struct OverrideScope {
-    current: BTreeSet<String>,
-    aliases: BTreeMap<String, Option<String>>,
-}
-
-/// Where an instance's expanded layers are: the overrides and derived layout of the outermost
-/// instance (by id path), the path of the instance being expanded, and the property values.
-#[derive(Clone)]
-struct Inst<'a> {
-    root: String,
-    path: Vec<String>,
-    overrides: Rc<Overrides<'a>>,
-    props: Rc<BTreeMap<String, &'a Kv<'a>>>,
-    /// Slot property GUID → private slot-content node GUID.
-    slot_contents: Rc<BTreeMap<String, String>>,
-    /// Layers imported from a slot's independent content subtree.
-    slot_content: bool,
-    /// Mains being expanded (an instance inside its own main stops there).
-    symbols: Vec<String>,
-}
-
 struct Mapper<'a> {
     nodes: BTreeMap<String, &'a Kv<'a>>,
     kids: BTreeMap<String, Vec<(&'a str, String)>>,
@@ -525,2598 +362,8 @@ impl<'a> Mapper<'a> {
         self.kids.get(id).map(|k| k.iter().map(|(_, c)| c.clone()).collect()).unwrap_or_default()
     }
 
-    /// The layers of main `main` by current GUID and by `overrideKey`. An instance nested in the
-    /// main is not entered: its layers belong to another main.
-    fn override_scope(&mut self, main: &str) -> Rc<OverrideScope> {
-        if let Some(scope) = self.override_scopes.get(main) {
-            return Rc::clone(scope);
-        }
-        let mut current = BTreeSet::new();
-        let mut aliases: BTreeMap<String, Option<String>> = BTreeMap::new();
-        let mut visited = BTreeSet::new();
-        let mut pending: Vec<(String, usize)> = self.children(main).into_iter().map(|id| (id, 1)).collect();
-        let mut complete = true;
-        while let Some((id, depth)) = pending.pop() {
-            if depth > MAX_DEPTH || visited.len() >= self.max_nodes {
-                complete = false;
-                break;
-            }
-            if !visited.insert(id.clone()) {
-                continue;
-            }
-            let Some(node) = self.nodes.get(&id) else { continue };
-            current.insert(id.clone());
-            if let Some(alias) = node.get("overrideKey").and_then(guid) {
-                let target = aliases.entry(alias).or_insert_with(|| Some(id.clone()));
-                if target.as_deref().is_some_and(|target| target != id) {
-                    *target = None;
-                }
-            }
-            if node.get("type").and_then(Kv::str) != Some("INSTANCE") {
-                pending.extend(self.children(&id).into_iter().map(|child| (child, depth + 1)));
-            }
-        }
-        // A scope cut short could name the wrong layer for a key: use none of the keys.
-        if !complete {
-            aliases.clear();
-        }
-        let scope = Rc::new(OverrideScope { current, aliases });
-        let cost = scope.current.len() + scope.aliases.len();
-        if cost <= self.max_nodes.saturating_sub(self.override_scope_entries) {
-            self.override_scope_entries += cost;
-            self.override_scopes.insert(main.to_string(), Rc::clone(&scope));
-        }
-        scope
-    }
-
     /// How many layers may be produced now: the cap, less what is kept for the visible pages.
     fn budget(&self) -> usize {
         self.max_nodes.saturating_sub(self.reserved)
     }
-
-    /// The DOCUMENT with its pages.
-    fn document(&mut self) -> Value {
-        let doc_id = self.nodes.iter().find(|(_, n)| n.get("type").and_then(Kv::str) == Some("DOCUMENT")).map(|(id, _)| id.clone());
-        let pages: Vec<String> = match &doc_id {
-            Some(d) => self.children(d),
-            None => self.nodes.iter().filter(|(_, n)| n.get("type").and_then(Kv::str) == Some("CANVAS")).map(|(id, _)| id.clone()).collect(),
-        };
-        let mut internal = Vec::new();
-        let mut visible = Vec::new();
-        for p in pages {
-            let Some(&n) = self.nodes.get(&p) else { continue };
-            if n.get("type").and_then(Kv::str) != Some("CANVAS") {
-                self.warn("document children other than pages were skipped");
-                continue;
-            }
-            // The hidden page that holds styles, variables and library copies.
-            if n.get("internalOnly").and_then(Kv::bool) == Some(true) {
-                internal.push((p, n));
-            } else {
-                visible.push((p, n));
-            }
-        }
-        // The library copies the pages use come first: in a file past the layer cap, the pages'
-        // last layers are skipped rather than the mains every instance of them needs (#981).
-        let visible_pages: Vec<String> = visible.iter().map(|(p, _)| p.clone()).collect();
-        let required_mains = self.referenced_component_mains(&visible_pages);
-        // The pages and their top-level layers, up to half the cap, stay for the pages.
-        let top: usize = visible_pages.iter().map(|p| 1 + self.children(p).len()).sum();
-        self.reserved = top.min(self.max_nodes / 2);
-        for (id, canvas) in internal {
-            if let Some(context) = self.library_context(&id, canvas, &required_mains) {
-                self.library_contexts.push(context);
-            }
-        }
-        self.reserved = 0;
-        let out: Vec<Value> = visible.into_iter().map(|(p, n)| self.page(&p, n)).collect();
-        if out.is_empty() {
-            self.warn("the file has no pages");
-        }
-        let mut doc = json!({"id": doc_id.unwrap_or_else(|| "0:0".into()), "type": "DOCUMENT"});
-        doc["children"] = Value::Array(out);
-        doc
-    }
-
-    /// The ids of the components the visible pages use, directly or through the components they
-    /// use in turn (nested instances, swap targets, overrides naming another main).
-    fn referenced_component_mains(&mut self, visible_pages: &[String]) -> BTreeSet<String> {
-        let mut mains = BTreeSet::new();
-        let mut visited = BTreeSet::new();
-        let mut pending: Vec<(String, usize)> = visible_pages.iter().flat_map(|page| self.children(page)).map(|id| (id, 1)).collect();
-        while let Some((id, depth)) = pending.pop() {
-            if depth > MAX_DEPTH {
-                self.warn(format!("component references below {MAX_DEPTH} layer levels were skipped"));
-                continue;
-            }
-            if !visited.insert(id.clone()) {
-                continue;
-            }
-            if visited.len() > self.max_nodes {
-                let max = self.max_nodes;
-                self.warn(format!("the component reference scan reached the {max}-layer limit"));
-                break;
-            }
-            let Some(node) = self.nodes.get(&id) else { continue };
-            for target in self.component_main_targets(node) {
-                if mains.insert(target.clone()) {
-                    pending.push((target, 1));
-                }
-            }
-            pending.extend(self.children(&id).into_iter().map(|child| (child, depth + 1)));
-        }
-        mains
-    }
-
-    /// The mains a layer names: an instance's own, the ones its overrides swap in, the instance-swap
-    /// defaults and values of component properties.
-    fn component_main_targets(&self, node: &Kv<'a>) -> Vec<String> {
-        let mut targets: Vec<String> = node
-            .get("componentPropDefs")
-            .map(Kv::list)
-            .unwrap_or_default()
-            .iter()
-            .filter_map(|definition| {
-                self.is_instance_swap(definition.get("id")?)?;
-                definition.get("initialValue")?.get("guidValue").and_then(guid)
-            })
-            .collect();
-        if node.get("type").and_then(Kv::str) != Some("INSTANCE") {
-            return targets;
-        }
-        // The instance and the override rows below it (rows carry the same fields, nested).
-        let mut pending: Vec<(&Kv<'a>, usize)> = vec![(node, 0)];
-        let mut rows = 0usize;
-        while let Some((row, depth)) = pending.pop() {
-            rows += 1;
-            if depth > MAX_DEPTH || rows > self.max_nodes {
-                break;
-            }
-            let data = row.get("symbolData");
-            targets.extend(row.get("overriddenSymbolID").and_then(guid));
-            targets.extend(data.and_then(|d| d.get("symbolID")).and_then(guid));
-            for assignment in row.get("componentPropAssignments").map(Kv::list).unwrap_or_default() {
-                if assignment.get("defID").is_some_and(|def| self.is_instance_swap(def).is_some()) {
-                    targets.extend(assigned(assignment).and_then(prop_guid));
-                }
-            }
-            let overrides = data.and_then(|d| d.get("symbolOverrides")).map(Kv::list).unwrap_or_default();
-            let derived = row.get("derivedSymbolData").map(Kv::list).unwrap_or_default();
-            pending.extend(overrides.iter().chain(derived).map(|row| (row, depth + 1)));
-        }
-        targets
-    }
-
-    fn is_instance_swap(&self, def: &Kv) -> Option<()> {
-        matches!(self.prop_def(&guid(def)?), Some((_, "INSTANCE_SWAP"))).then_some(())
-    }
-
-    /// The definition a copy of it was made from, followed to the original: the values an instance
-    /// sets are kept under it, since an assignment and the layers that read it may name different
-    /// copies of one definition.
-    fn prop_root(&self, def: &str) -> String {
-        let mut def = def;
-        for _ in 0..=MAX_DEPTH {
-            let Some(parent) = self.prop_parents.get(def) else { break };
-            def = parent;
-        }
-        def.to_string()
-    }
-
-    /// The definition `def` names: its own, or the set's for a variant's copy of it.
-    fn prop_def(&self, def: &str) -> Option<&(String, &'a str)> {
-        let mut def = def;
-        for _ in 0..=MAX_DEPTH {
-            if let Some(found) = self.prop_defs.get(def) {
-                return Some(found);
-            }
-            def = self.prop_parents.get(def)?;
-        }
-        None
-    }
-
-    /// The branches of the internal canvas `id` that hold the `required_mains` (with the frames
-    /// they sit in), as a frame of its own: the cached definitions of components that come from a
-    /// library. `None` when it holds none.
-    fn library_context(&mut self, id: &str, canvas: &'a Kv<'a>, required_mains: &BTreeSet<String>) -> Option<Value> {
-        let mut included = BTreeSet::new();
-        let mut parents: BTreeMap<String, String> = BTreeMap::new();
-        // The canvas itself is never a layer of the walk, whatever the parent links say.
-        let mut visited = BTreeSet::from([id.to_string()]);
-        // Each entry: layer, depth, inside a required definition.
-        let mut pending: Vec<(String, usize, bool)> = self.children(id).into_iter().map(|child| (child, 1, false)).collect();
-        while let Some((node_id, depth, in_definition)) = pending.pop() {
-            if depth > MAX_DEPTH {
-                self.warn(format!("internal library branches deeper than {MAX_DEPTH} levels were skipped"));
-                continue;
-            }
-            if !visited.insert(node_id.clone()) {
-                continue;
-            }
-            self.library_scan_count += 1;
-            if self.library_scan_count > self.max_nodes {
-                let max = self.max_nodes;
-                self.warn(format!("the internal library scan reached the {max}-layer limit; the remaining branches were skipped"));
-                break;
-            }
-            let Some(node) = self.nodes.get(&node_id) else { continue };
-            let kind = node.get("type").and_then(Kv::str);
-            let definition = (kind == Some("SYMBOL") || (kind == Some("FRAME") && node.get("isStateGroup").and_then(Kv::bool) == Some(true)))
-                && required_mains.contains(&node_id);
-            let in_definition = in_definition || definition;
-            if in_definition {
-                included.insert(node_id.clone());
-            }
-            if definition {
-                // The frames around it keep the path its layers are addressed by.
-                let mut ancestor = parents.get(&node_id);
-                for _ in 0..=MAX_DEPTH {
-                    let Some(parent) = ancestor else { break };
-                    if !included.insert(parent.clone()) {
-                        break;
-                    }
-                    ancestor = parents.get(parent);
-                }
-            }
-            for child in self.children(&node_id).into_iter().rev() {
-                // A layer reached again keeps the parent it was first reached by, so the parents
-                // lead back to the canvas.
-                if visited.contains(&child) {
-                    continue;
-                }
-                parents.entry(child.clone()).or_insert_with(|| node_id.clone());
-                pending.push((child, depth + 1, in_definition));
-            }
-        }
-        if included.is_empty() {
-            return None;
-        }
-        let mut context = Obj::new();
-        context.insert("id".into(), json!(id));
-        context.insert("type".into(), json!("FRAME"));
-        copy_str(&mut context, &View::of(canvas), "name", "name");
-        context.insert("size".into(), json!({"x": 0.0, "y": 0.0}));
-        context.insert("relativeTransform".into(), rows(Affine::IDENTITY));
-        context.insert(crate::rest::FIG_SOURCE_FIELD.into(), json!({"origin": id, "expanded": false, "wireFrame": true, "wireInstance": false}));
-        self.variable_bindings(&mut context, &View::of(canvas));
-        let mut children = Vec::new();
-        for child in self.children(id) {
-            children.extend(self.layer_filtered(&child, None, Affine::IDENTITY, None, None, 0, Some(&included)));
-        }
-        if !children.is_empty() {
-            context.insert("children".into(), Value::Array(children));
-        }
-        Some(Value::Object(context))
-    }
-
-    fn page(&mut self, id: &str, n: &'a Kv<'a>) -> Value {
-        let v = View::of(n);
-        let mut o = Obj::new();
-        o.insert("id".into(), json!(id));
-        o.insert("type".into(), json!("CANVAS"));
-        copy_str(&mut o, &v, "name", "name");
-        if let Some(c) = v.get("backgroundColor") {
-            o.insert("backgroundColor".into(), color(c));
-        }
-        if let Some(c) = v.get("prototypeBackgroundColor") {
-            o.insert("prototypeBackgrounds".into(), json!([color(c)]));
-        }
-        self.variable_bindings(&mut o, &v);
-        let mut flows: Vec<(&str, Value)> = Vec::new();
-        let mut kids = Vec::new();
-        for c in self.children(id) {
-            if let Some(sp) = self.nodes.get(&c).and_then(|k| k.get("prototypeStartingPoint")) {
-                let name = sp.get("name").and_then(Kv::str).filter(|s| !s.is_empty()).unwrap_or("Flow");
-                flows.push((sp.get("position").and_then(Kv::str).unwrap_or(""), json!({"nodeId": c, "name": name})));
-            }
-            kids.extend(self.layer(&c, None, Affine::IDENTITY, None, None, 0));
-        }
-        flows.sort_by(|a, b| a.0.cmp(b.0));
-        if !flows.is_empty() {
-            o.insert("flowStartingPoints".into(), Value::Array(flows.into_iter().map(|f| f.1).collect()));
-        }
-        o.insert("children".into(), Value::Array(kids));
-        Value::Object(o)
-    }
-
-    /// Layer `id` (inside instance `inst` when expanding one) and its subtree. `space`: from the
-    /// parent's coordinates to the enclosing frame's (groups and booleans place their children in
-    /// the frame's space, like the REST JSON). `parent`: the parent's view (grid tracks).
-    fn layer(
-        &mut self,
-        id: &str,
-        inst: Option<&Inst<'a>>,
-        space: Affine,
-        parent: Option<&View<'a>>,
-        fit: Option<Fit>,
-        depth: usize,
-    ) -> Option<Value> {
-        self.layer_filtered(id, inst, space, parent, fit, depth, None)
-    }
-
-    /// [`Self::layer`], keeping only the layers in `included` (all when `None`) below the
-    /// top-level one: the cached library definitions of an internal canvas.
-    fn layer_filtered(
-        &mut self,
-        id: &str,
-        inst: Option<&Inst<'a>>,
-        space: Affine,
-        parent: Option<&View<'a>>,
-        fit: Option<Fit>,
-        depth: usize,
-        included: Option<&BTreeSet<String>>,
-    ) -> Option<Value> {
-        if included.is_some_and(|ids| !ids.contains(id)) {
-            return None;
-        }
-        if depth > MAX_DEPTH {
-            self.warn(format!("layers nested deeper than {MAX_DEPTH} levels were skipped"));
-            return None;
-        }
-        if self.count >= self.budget() {
-            let max = self.max_nodes;
-            self.warn(format!("the file has more than {max} layers; the rest were skipped"));
-            return None;
-        }
-        let base = *self.nodes.get(id)?;
-        let path = inst.map(|i| [i.path.as_slice(), &[id.to_string()]].concat());
-        let entries: &[OverrideRow<'a>] = match (inst, &path) {
-            (Some(i), Some(p)) => i.overrides.get(p).map(Vec::as_slice).unwrap_or_default(),
-            _ => &[],
-        };
-        let mut view = View::of(base).with(entries.iter().map(|e| e.row));
-        // A layer of a resized instance the file gives no derived layout for follows its
-        // constraints from the main's geometry, then takes the size and place overridden on it
-        // (auto layout places the others, as in the editor).
-        let derived = entries.iter().any(|e| e.entry == Entry::Derived && (e.row.get("size").is_some() || e.row.get("transform").is_some()));
-        let stacked = parent.and_then(|p| p.str("stackMode")).is_some_and(|m| matches!(m, "HORIZONTAL" | "VERTICAL" | "GRID"))
-            && view.str("stackPositioning") != Some("ABSOLUTE");
-        let main = View::of(base);
-        let set = |k: &str| entries.iter().rev().filter(|e| e.entry != Entry::Stale).find_map(|e| e.row.get(k));
-        if let (Some(f), false, false, Some((w, h))) = (fit, derived, stacked, main.size()) {
-            let t = main.transform().unwrap_or_default();
-            let (fw, ft) = f.apply(w, h, t, view.str("horizontalConstraint"), view.str("verticalConstraint"));
-            view.fitted = Some((set("size").and_then(size).unwrap_or(fw), set("transform").and_then(matrix).unwrap_or(ft)));
-        } else if entries.iter().any(|e| e.entry == Entry::Stale && (e.row.get("size").is_some() || e.row.get("transform").is_some()))
-            && let Some(s) = set("size").and_then(size).or_else(|| main.size())
-        {
-            view.fitted = Some((s, set("transform").and_then(matrix).or_else(|| main.transform()).unwrap_or_default()));
-        }
-        let rest_id = match (inst, &path) {
-            (Some(i), Some(p)) => format!("I{};{}", i.root, p.join(";")),
-            _ => id.to_string(),
-        };
-        let own = view.str("type").unwrap_or("");
-        let connector_snapshot = own == "CONNECTOR" && self.connector_snapshot_supported(&view);
-        // Only a connector with a saved label needs the frame wrapper; an unlabelled one stays a single vector.
-        let connector_terminal =
-            connector_snapshot && (!connector_has_saved_label(&view) || depth >= MAX_DEPTH || self.count.saturating_add(1) >= self.budget());
-        // A supported connector snapshot has its own note below instead of the generic stand-in one.
-        let stand = stand_in(own).filter(|_| !connector_snapshot);
-        let ty = match own {
-            "ROUNDED_RECTANGLE" => "RECTANGLE",
-            "SYMBOL" => "COMPONENT",
-            "FRAME" if view.flag("isStateGroup") == Some(true) => "COMPONENT_SET",
-            "FRAME" if view.flag("resizeToFit") == Some(true) => "GROUP",
-            "VARIABLE" | "VARIABLE_SET" => return None,
-            "CONNECTOR" if connector_snapshot && connector_terminal => "VECTOR",
-            "CONNECTOR" if connector_snapshot => "FRAME",
-            t => stand.map_or(t, |s| s.0),
-        };
-        if let Some((_, what)) = stand.filter(|_| own != "TEXT_PATH") {
-            self.warn(format!("{} layers import as {what}", own.to_ascii_lowercase().replace('_', " ")));
-        }
-        if connector_snapshot {
-            self.warn("connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained");
-        }
-        self.count += 1;
-        if own == "SYMBOL" && inst.is_none() {
-            self.mapped_mains.insert(id.to_string());
-        }
-        let mut o = Obj::new();
-        o.insert("id".into(), json!(rest_id));
-        // Private provenance for the .fig importer; ordinary REST import ignores it.
-        o.insert(
-            crate::rest::FIG_SOURCE_FIELD.into(),
-            json!({
-                "origin": id,
-                "expanded": inst.is_some(),
-                "wireFrame": own == "FRAME",
-                "wireInstance": own == "INSTANCE",
-                "slotContent": inst.is_some_and(|i| i.slot_content),
-                // A size the instance gives this layer itself (kept when the instance relays out).
-                "sizeOverride": entries.iter().any(|e| e.entry == Entry::Override && e.row.get("size").is_some()),
-            }),
-        );
-        o.insert("type".into(), json!(ty));
-        copy_str(&mut o, &view, "name", "name");
-        self.common(&mut o, &view, ty, space, parent);
-        match ty {
-            "TEXT" => {
-                self.text(&mut o, &view);
-                if own == "TEXT_PATH" {
-                    self.text_path(&mut o, &view);
-                }
-            }
-            "VECTOR" | "STAR" | "REGULAR_POLYGON" => self.geometry(&mut o, &view),
-            "ELLIPSE" => {
-                if let Some(a) = view.get("arcData") {
-                    let arc: Obj =
-                        ["startingAngle", "endingAngle", "innerRadius"].iter().filter_map(|k| Some((k.to_string(), json!(num(a, k)?)))).collect();
-                    o.insert("arcData".into(), Value::Object(arc));
-                }
-            }
-            "BOOLEAN_OPERATION" => {
-                if let Some(op) = view.str("booleanOperation") {
-                    o.insert("booleanOperation".into(), json!(if op == "XOR" { "EXCLUDE" } else { op }));
-                }
-            }
-            _ => {}
-        }
-        if own == "CONNECTOR" && connector_snapshot {
-            if connector_terminal {
-                self.connector_snapshot_flatten(&mut o, &view, &rest_id, space);
-            } else {
-                o.insert("fills".into(), json!([]));
-                o.insert("strokes".into(), json!([]));
-                for key in ["styles", "strokeWeight", "strokeAlign", "strokeJoin", "strokeDashes", "strokeCap"] {
-                    o.remove(key);
-                }
-                o.insert("clipsContent".into(), json!(false));
-            }
-        } else if own == "CONNECTOR" {
-            self.connector(&mut o, &view, space);
-        }
-        if ty == "COMPONENT" || ty == "COMPONENT_SET" {
-            self.component(&mut o, &view, &rest_id);
-        }
-        self.prop_refs(&mut o, &view, inst);
-        let slot_content = if own == "FRAME" {
-            prop_ref(&view, "SLOT_CONTENT_ID").and_then(|def| inst.and_then(|i| i.slot_contents.get(&self.prop_root(&def)).cloned()))
-        } else {
-            None
-        };
-        if slot_content.is_some()
-            && let Some(source) = o.get_mut(crate::rest::FIG_SOURCE_FIELD).and_then(Value::as_object_mut)
-        {
-            source.insert("slotOverride".into(), json!(true));
-        }
-        let child_space = if matches!(ty, "GROUP" | "BOOLEAN_OPERATION") { space * view.transform().unwrap_or_default() } else { Affine::IDENTITY };
-        let mut kids = if connector_snapshot && !connector_terminal { self.connector_snapshot_children(&view, &rest_id) } else { Vec::new() };
-        if connector_terminal {
-            // The saved vector is flattened into the connector node when no child slot remains.
-        } else if ty == "INSTANCE" {
-            if let Some((sub, sym)) = self.instance(&mut o, &view, id, inst, &rest_id) {
-                let main = self.nodes.get(&sym).map(|m| View::of(m));
-                let fit = Fit::frame(main.as_ref().and_then(View::size), view.size());
-                // An instance that records no auto layout of its own has its main's.
-                let view = match main {
-                    Some(m) if view.get("stackMode").is_none() && m.get("stackMode").is_some() => {
-                        let layered = View { fitted: view.fitted, ..m.with(view.layers.iter().copied()) };
-                        self.auto_layout(&mut o, &layered);
-                        layered
-                    }
-                    _ => view.clone(),
-                };
-                for c in self.children(&sym) {
-                    // The main's branch can live outside the cached context being mapped.
-                    kids.extend(self.layer_filtered(&c, Some(&sub), child_space, Some(&view), fit, depth + 1, None));
-                }
-            }
-        } else if let Some(content) = slot_content {
-            let mut content_inst = inst.cloned();
-            if let Some(content_inst) = &mut content_inst {
-                content_inst.slot_content = true;
-            }
-            for c in self.children(&content) {
-                kids.extend(self.layer_filtered(&c, content_inst.as_ref(), child_space, Some(&view), None, depth + 1, included));
-            }
-        } else {
-            // Inside an instance a layer's children are its main's: they follow it from the main's
-            // size to its own.
-            let fit = match (inst, ty) {
-                (None, _) => None,
-                (Some(_), "GROUP" | "BOOLEAN_OPERATION") => Fit::scale(View::of(base).size(), view.size()),
-                (Some(_), _) => Fit::frame(View::of(base).size(), view.size()),
-            };
-            for c in self.children(id) {
-                kids.extend(self.layer_filtered(&c, inst, child_space, Some(&view), fit, depth + 1, included));
-            }
-        }
-        if stand.is_some_and(|s| s.0 == "FRAME") {
-            kids.splice(0..0, self.shape_with_text(&mut o, &view, own, &rest_id));
-            kids.extend(self.inner_text(&o, &view, &rest_id, own == "STICKY"));
-        }
-        if !kids.is_empty() {
-            o.insert("children".into(), Value::Array(kids));
-        }
-        Some(Value::Object(o))
-    }
-
-    /// A non-rectangular shape-with-text's shape, as a vector under its frame (which gives up its
-    /// paints to it).
-    fn shape_with_text(&mut self, o: &mut Obj, v: &View<'a>, own: &str, rest_id: &str) -> Option<Value> {
-        let shape = v.str("shapeWithTextType").unwrap_or("SQUARE");
-        let outlined = !v.list("fillGeometry").is_empty() || !v.list("strokeGeometry").is_empty();
-        if own != "SHAPE_WITH_TEXT" || matches!(shape, "SQUARE" | "ROUNDED_RECTANGLE") || !outlined || self.count >= self.budget() {
-            return None;
-        }
-        let mut s = Obj::new();
-        s.insert("id".into(), json!(format!("{rest_id};shape")));
-        s.insert("type".into(), json!("VECTOR"));
-        s.insert("name".into(), json!(shape.to_ascii_lowercase().replace('_', " ")));
-        for k in ["size", "strokeWeight", "strokeAlign", "strokeJoin", "strokeDashes"] {
-            if let Some(x) = o.get(k) {
-                s.insert(k.into(), x.clone());
-            }
-        }
-        for k in ["fills", "strokes"] {
-            s.insert(k.into(), o.insert(k.into(), json!([])).unwrap_or_else(|| json!([])));
-        }
-        s.insert("relativeTransform".into(), rows(Affine::IDENTITY));
-        self.geometry(&mut s, v);
-        if !s.contains_key("fillGeometry") && !s.contains_key("strokeGeometry") {
-            // Damaged outlines: the frame keeps its paints and box.
-            for k in ["fills", "strokes"] {
-                o.insert(k.into(), s.remove(k).unwrap_or_else(|| json!([])));
-            }
-            return None;
-        }
-        self.count += 1;
-        Some(Value::Object(s))
-    }
-
-    /// The text a stand-in frame holds (a sticky note's, a shape's, a table cell's) as a text
-    /// layer filling it, inset a little; centred unless it's a note.
-    fn inner_text(&mut self, o: &Obj, v: &View<'a>, rest_id: &str, note: bool) -> Option<Value> {
-        let chars = own_text(v)?;
-        if self.count >= self.budget() {
-            return None;
-        }
-        self.count += 1;
-        let size = |k: &str| o.get("size").and_then(|s| s.get(k)).and_then(Value::as_f64).unwrap_or(0.0);
-        let (w, h) = (size("x"), size("y"));
-        let pad = (w.min(h) / 4.0).clamp(0.0, 16.0);
-        let mut t = Obj::new();
-        t.insert("id".into(), json!(format!("{rest_id};text")));
-        t.insert("type".into(), json!("TEXT"));
-        t.insert("name".into(), json!(chars.chars().take(40).collect::<String>()));
-        t.insert("size".into(), json!({"x": (w - 2.0 * pad).max(1.0), "y": (h - 2.0 * pad).max(1.0)}));
-        t.insert("relativeTransform".into(), rows(Affine::translate((pad, pad))));
-        self.text(&mut t, v);
-        if let Some(Value::Object(st)) = t.get_mut("style") {
-            let (hor, ver) = if note { ("LEFT", "TOP") } else { ("CENTER", "CENTER") };
-            st.entry("textAlignHorizontal").or_insert_with(|| json!(hor));
-            st.entry("textAlignVertical").or_insert_with(|| json!(ver));
-            st.insert("textAutoResize".into(), json!("NONE"));
-        }
-        Some(Value::Object(t))
-    }
-
-    /// A connector's end caps, and when it has no saved outline or network a straight line
-    /// between its ends: free points, or a point (the centre unless given) of a sibling layer.
-    fn connector(&mut self, o: &mut Obj, v: &View<'a>, space: Affine) {
-        for (from, to) in [("connectorStartCap", "strokeCapStart"), ("connectorEndCap", "strokeCapEnd")] {
-            if let Some(c) = v.str(from) {
-                o.insert(to.into(), json!(cap_name(c)));
-            }
-        }
-        if connector_has_saved_label(v) {
-            self.warn("connector labels were skipped");
-        }
-        if ["vectorNetwork", "vectorNetworkRef", "fillGeometry", "strokeGeometry"].iter().any(|k| o.contains_key(*k)) {
-            return;
-        }
-        let parent = v.get("parentIndex").and_then(|p| p.get("guid")).and_then(guid);
-        let end = |k: &str| -> Option<Point> {
-            let e = v.get(k)?;
-            let p = match e.get("endpointNodeID").and_then(guid).filter(|g| g != NO_STYLE) {
-                Some(id) => {
-                    let n = *self.nodes.get(&id)?;
-                    // Only siblings share the connector's coordinates.
-                    if n.get("parentIndex").and_then(|p| p.get("guid")).and_then(guid) != parent {
-                        return None;
-                    }
-                    let (w, h) = n.get("size").map_or((0.0, 0.0), |s| (num(s, "x").unwrap_or(0.0), num(s, "y").unwrap_or(0.0)));
-                    let (rx, ry) = e.get("relativePosition").and_then(|r| Some((num(r, "x")?, num(r, "y")?))).unwrap_or((0.5, 0.5));
-                    n.get("transform").and_then(matrix).unwrap_or_default() * Point::new(w * rx, h * ry)
-                }
-                None => e.get("position").and_then(|p| Some(Point::new(num(p, "x")?, num(p, "y")?)))?,
-            };
-            (p.x.is_finite() && p.y.is_finite()).then_some(p)
-        };
-        let (Some(a), Some(b)) = (end("connectorStart"), end("connectorEnd")) else {
-            self.warn("connectors whose ends can't be placed are empty");
-            return;
-        };
-        if v.str("connectorLineStyle").is_some_and(|s| s != "STRAIGHT") {
-            self.warn("elbowed and curved connectors without a saved path import as straight lines");
-        }
-        let (x0, y0) = (a.x.min(b.x), a.y.min(b.y));
-        o.insert("relativeTransform".into(), rows(space * Affine::translate((x0, y0))));
-        o.insert("size".into(), json!({"x": (a.x - b.x).abs(), "y": (a.y - b.y).abs()}));
-        o.insert(
-            "vectorNetwork".into(),
-            json!({"vertices": [{"x": a.x - x0, "y": a.y - y0}, {"x": b.x - x0, "y": b.y - y0}], "segments": [{"a": 0, "b": 1}]}),
-        );
-    }
-
-    fn connector_snapshot_supported(&self, v: &View<'a>) -> bool {
-        if v.str("connectorType") != Some("MANUAL")
-            || v.get("connectorVersion").and_then(Kv::f64) != Some(1.0)
-            || v.str("connectorLineStyle") != Some("STRAIGHT")
-            || v.get("derivedImmutableFrameData").and_then(|data| data.get("version")).and_then(Kv::f64) != Some(1.0)
-        {
-            return false;
-        }
-        let Some(line) = connector_record(v, "derivedImmutableFrameData", 0) else { return false };
-        if line.get("transform").and_then(matrix).is_none() || valid_size(line.get("size")).is_none() {
-            return false;
-        }
-        let geometry = ["fillGeometry", "strokeGeometry"].iter().any(|key| {
-            line.get(key).map(Kv::list).unwrap_or_default().iter().any(|path| {
-                num(path, "commandsBlob")
-                    .and_then(|index| self.blobs.get(index as usize))
-                    .and_then(|blob| svg_path(blob))
-                    .is_some_and(|data| !data.is_empty())
-            })
-        });
-        let network = line
-            .get("vectorData")
-            .and_then(|data| num(data, "vectorNetworkBlob"))
-            .and_then(|index| self.blobs.get(index as usize))
-            .and_then(|blob| network::decode(blob))
-            .is_some_and(|network| !network.segments.is_empty());
-        (geometry || network) && connector_record(v, "nodeGenerationData", 0).is_some()
-    }
-
-    fn connector_snapshot_flatten(&mut self, out: &mut Obj, v: &View<'a>, rest_id: &str, space: Affine) {
-        let parent = space * v.get("transform").and_then(matrix).unwrap_or_default();
-        let Some(vector) = self.connector_snapshot_vector(v, rest_id, parent, false) else {
-            self.warn("connector snapshot vector data is missing; connector was left empty");
-            return;
-        };
-        for key in [
-            "size",
-            "relativeTransform",
-            "fills",
-            "strokes",
-            "strokeWeight",
-            "strokeAlign",
-            "strokeJoin",
-            "strokeDashes",
-            "strokeCap",
-            "strokeCapStart",
-            "strokeCapEnd",
-            "styles",
-            "fillGeometry",
-            "strokeGeometry",
-            "vectorNetwork",
-        ] {
-            if let Some(value) = vector.get(key) {
-                out.insert(key.to_string(), value.clone());
-            }
-        }
-        if vector.get("visible").and_then(Value::as_bool) == Some(false) {
-            out.insert("visible".into(), json!(false));
-        }
-        if let Some(line_opacity) = vector.get("opacity").and_then(Value::as_f64) {
-            let root_opacity = out.get("opacity").and_then(Value::as_f64).unwrap_or(1.0);
-            out.insert("opacity".into(), json!(root_opacity * line_opacity));
-        }
-        if connector_has_saved_label(v) {
-            let reason = if self.count >= self.budget() { "node budget" } else { "depth limit" };
-            self.warn(format!("connector label was skipped: {reason} prevents nested snapshot children"));
-        }
-    }
-
-    /// Build the saved vector child or flattened terminal connector from the same child-only view.
-    fn connector_snapshot_vector(&mut self, v: &View<'a>, rest_id: &str, space: Affine, nested: bool) -> Option<Obj> {
-        let (Some(line), Some(line_style)) = (connector_record(v, "derivedImmutableFrameData", 0), connector_record(v, "nodeGenerationData", 0))
-        else {
-            return None;
-        };
-        let mut vector = Obj::new();
-        vector.insert("id".into(), json!(if nested { format!("{rest_id};vector") } else { rest_id.to_string() }));
-        vector.insert("type".into(), json!("VECTOR"));
-        if let Some(name) = v.str("name") {
-            vector.insert("name".into(), json!(if nested { format!("{name} vector") } else { name.to_string() }));
-        }
-        let line_view = View::of(line).with([line_style]);
-        self.common(&mut vector, &line_view, "VECTOR", space, None);
-        self.geometry(&mut vector, &line_view);
-        for (from, to) in [("connectorStartCap", "strokeCapStart"), ("connectorEndCap", "strokeCapEnd")] {
-            if let Some(cap) = v.str(from) {
-                vector.entry(to).or_insert_with(|| json!(cap_name(cap)));
-            }
-        }
-        Some(vector)
-    }
-
-    /// Snapshot the straight, manual connector contract carried by its generated children.
-    fn connector_snapshot_children(&mut self, v: &View<'a>, rest_id: &str) -> Vec<Value> {
-        if self.count >= self.budget() {
-            self.warn(format!("the file has more than {} layers; connector snapshot children were skipped", self.max_nodes));
-            return Vec::new();
-        }
-        let Some(vector) = self.connector_snapshot_vector(v, rest_id, Affine::IDENTITY, true) else {
-            self.warn("connector snapshot vector data is missing; connector was left empty");
-            return Vec::new();
-        };
-        let mut children = Vec::new();
-        children.push(Value::Object(vector));
-        self.count += 1;
-
-        let Some(text_frame) = connector_record(v, "derivedImmutableFrameData", 1) else {
-            if connector_has_saved_label(v) {
-                self.warn("connector label was skipped: derived text bounds are missing");
-            }
-            return children;
-        };
-        let Some(background) = connector_record(v, "derivedImmutableFrameData", 2) else {
-            if connector_has_saved_label(v) || valid_size(text_frame.get("size")).is_some_and(|(w, h)| w > 0.0 && h > 0.0) {
-                self.warn("connector label was skipped: derived background bounds are missing");
-            }
-            return children;
-        };
-        let Some(text_style) = connector_record(v, "nodeGenerationData", 1) else {
-            if valid_size(text_frame.get("size")).is_some_and(|(w, h)| w > 0.0 && h > 0.0) {
-                self.warn("connector label was skipped: text style data is missing");
-            }
-            return children;
-        };
-        let text_view = View::of(text_frame).with([text_style]);
-        let Some(characters) = text_view.get("textData").and_then(|d| d.get("characters")).and_then(Kv::str).filter(|s| !s.trim().is_empty()) else {
-            return children;
-        };
-        let Some(text_transform) = text_frame.get("transform").and_then(matrix) else {
-            self.warn("connector label was skipped: text transform is invalid");
-            return children;
-        };
-        let Some(background_transform) = background.get("transform").and_then(matrix) else {
-            self.warn("connector label was skipped: background transform is invalid");
-            return children;
-        };
-        let Some(text_size) = valid_size(text_frame.get("size")) else {
-            self.warn("connector label was skipped: text bounds are invalid");
-            return children;
-        };
-        let Some(background_size) = valid_size(background.get("size")) else {
-            self.warn("connector label was skipped: background bounds are invalid");
-            return children;
-        };
-        let composed_text_transform = background_transform * text_transform;
-        if !composed_text_transform.as_coeffs().iter().all(|coefficient| coefficient.is_finite()) {
-            self.warn("connector label was skipped: composed text transform is invalid");
-            return children;
-        }
-
-        let Some(background_style) = connector_record(v, "nodeGenerationData", 2) else {
-            self.warn("connector label background was skipped: style data is missing");
-            self.add_connector_text(&mut children, rest_id, characters, text_size, composed_text_transform, &text_view);
-            return children;
-        };
-        let background_view = View::of(background).with([background_style]);
-        if !background_view.list("fillPaints").is_empty() {
-            if self.count >= self.budget() {
-                self.warn(format!("the file has more than {} layers; connector label background was skipped", self.max_nodes));
-            } else {
-                let mut rect = Obj::new();
-                rect.insert("id".into(), json!(format!("{rest_id};label-background")));
-                rect.insert("type".into(), json!("RECTANGLE"));
-                rect.insert("name".into(), json!("connector label background"));
-                self.common(&mut rect, &background_view, "RECTANGLE", Affine::IDENTITY, None);
-                rect.insert("size".into(), json!({"x": background_size.0, "y": background_size.1}));
-                rect.insert("relativeTransform".into(), rows(background_transform));
-                rect.insert("clipsContent".into(), json!(false));
-                children.push(Value::Object(rect));
-                self.count += 1;
-            }
-        }
-        self.add_connector_text(&mut children, rest_id, characters, text_size, composed_text_transform, &text_view);
-        children
-    }
-
-    fn add_connector_text(
-        &mut self,
-        children: &mut Vec<Value>,
-        rest_id: &str,
-        characters: &str,
-        size: (f64, f64),
-        transform: Affine,
-        view: &View<'a>,
-    ) {
-        if self.count >= self.budget() {
-            self.warn(format!("the file has more than {} layers; connector label was skipped", self.max_nodes));
-            return;
-        }
-        let mut text = Obj::new();
-        text.insert("id".into(), json!(format!("{rest_id};label-text")));
-        text.insert("type".into(), json!("TEXT"));
-        text.insert("name".into(), json!(characters));
-        text.insert("size".into(), json!({"x": size.0, "y": size.1}));
-        self.common(&mut text, view, "TEXT", Affine::IDENTITY, None);
-        text.insert("relativeTransform".into(), rows(transform));
-        self.text(&mut text, view);
-        children.push(Value::Object(text));
-        self.count += 1;
-    }
-
-    /// Fields every layer type shares.
-    fn common(&mut self, o: &mut Obj, v: &View<'a>, ty: &str, space: Affine, parent: Option<&View<'a>>) {
-        for (from, to) in [("visible", "visible"), ("locked", "locked"), ("mask", "isMask")] {
-            if let Some(b) = v.flag(from) {
-                o.insert(to.into(), json!(b));
-            }
-        }
-        if let Some(m) = v.str("maskType") {
-            o.insert("maskType".into(), json!(if m == "OUTLINE" { "VECTOR" } else { m }));
-        }
-        copy_num(o, v, "opacity", "opacity");
-        if let Some(b) = v.str("blendMode").filter(|b| *b != "UNSET") {
-            o.insert("blendMode".into(), json!(b));
-        }
-        if let Some((x, y)) = v.size() {
-            o.insert("size".into(), json!({"x": x, "y": y}));
-        }
-        let t = v.transform().unwrap_or_default();
-        o.insert("relativeTransform".into(), rows(space * t));
-        // Paints, from the shared style when one is linked (the layer's own copy can be stale),
-        // unless the layer's own paints are bound to variables: those bindings must not be lost.
-        let mut styles = Obj::new();
-        let own = |k: &str| Some(v.list(k)).filter(|l| l.iter().any(paint_bound));
-        let fill_style = self.style(v, "styleIdForFill", "inheritFillStyleID", "fill", &mut styles);
-        let fills = own("fillPaints")
-            .unwrap_or_else(|| fill_style.map_or_else(|| v.list("fillPaints"), |s| s.get("fillPaints").map(Kv::list).unwrap_or_default()));
-        o.insert("fills".into(), Value::Array(fills.iter().filter_map(|p| paint(p, &mut |w| self.warn(w))).collect()));
-        let stroke_style = self.style(v, "styleIdForStrokeFill", "inheritFillStyleIDForStroke", "stroke", &mut styles);
-        let strokes = own("strokePaints")
-            .unwrap_or_else(|| stroke_style.map_or_else(|| v.list("strokePaints"), |s| s.get("fillPaints").map(Kv::list).unwrap_or_default()));
-        o.insert("strokes".into(), Value::Array(strokes.iter().filter_map(|p| paint(p, &mut |w| self.warn(w))).collect()));
-        let effect_style = self.style(v, "styleIdForEffect", "inheritEffectStyleID", "effect", &mut styles);
-        let effects = effect_style.map_or_else(|| v.list("effects"), |s| s.get("effects").map(Kv::list).unwrap_or_default());
-        if !effects.is_empty() {
-            o.insert("effects".into(), Value::Array(effects.iter().filter_map(effect).collect()));
-        }
-        let grid_style = self.style(v, "styleIdForGrid", "inheritGridStyleID", "grid", &mut styles);
-        let grids = grid_style.map_or_else(|| v.list("layoutGrids"), |s| s.get("layoutGrids").map(Kv::list).unwrap_or_default());
-        if !grids.is_empty() {
-            o.insert("layoutGrids".into(), Value::Array(grids.iter().map(layout_grid).collect()));
-        }
-        if ty == "TEXT" {
-            self.style(v, "styleIdForText", "inheritTextStyleID", "text", &mut styles);
-        }
-        if !styles.is_empty() {
-            o.insert("styles".into(), Value::Object(styles));
-        }
-        stroke(o, v);
-        copy_num(o, v, "cornerRadius", "cornerRadius");
-        copy_num(o, v, "cornerSmoothing", "cornerSmoothing");
-        if v.flag("rectangleCornerRadiiIndependent") == Some(true) {
-            let r = |k: &str| v.num(k).unwrap_or(0.0);
-            o.insert(
-                "rectangleCornerRadii".into(),
-                json!([
-                    r("rectangleTopLeftCornerRadius"),
-                    r("rectangleTopRightCornerRadius"),
-                    r("rectangleBottomRightCornerRadius"),
-                    r("rectangleBottomLeftCornerRadius")
-                ]),
-            );
-        }
-        let constraint = |k: &str, min: &'static str, max: &'static str, both: &'static str| match v.str(k) {
-            Some("CENTER") => "CENTER",
-            Some("MAX" | "FIXED_MAX") => max,
-            Some("STRETCH") => both,
-            Some("SCALE") => "SCALE",
-            _ => min,
-        };
-        o.insert(
-            "constraints".into(),
-            json!({
-                "horizontal": constraint("horizontalConstraint", "LEFT", "RIGHT", "LEFT_RIGHT"),
-                "vertical": constraint("verticalConstraint", "TOP", "BOTTOM", "TOP_BOTTOM"),
-            }),
-        );
-        if matches!(ty, "FRAME" | "COMPONENT" | "COMPONENT_SET" | "INSTANCE" | "SECTION") {
-            o.insert("clipsContent".into(), json!(!v.flag("frameMaskDisabled").unwrap_or(false)));
-            self.auto_layout(o, v);
-        }
-        child_layout(o, v, parent);
-        let exports: Vec<Value> = v.list("exportSettings").iter().map(export_setting).collect();
-        if !exports.is_empty() {
-            o.insert("exportSettings".into(), Value::Array(exports));
-        }
-        if let Some(b) = v.flag("sectionContentsHidden") {
-            o.insert("sectionContentsHidden".into(), json!(b));
-        }
-        self.prototype(o, v);
-        self.variable_bindings(o, v);
-    }
-
-    /// The style node a layer links in `key` (or the older `legacy` field), recorded for the REST
-    /// `styles` map under `slot`.
-    fn style(&mut self, v: &View<'a>, key: &str, legacy: &str, slot: &str, out: &mut Obj) -> Option<&'a Kv<'a>> {
-        let id = style_link(v, key, legacy)?;
-        let node = *self.nodes.get(&id)?;
-        node.get("styleType").and_then(Kv::str)?;
-        out.insert(slot.into(), json!(id));
-        if !self.styles.contains_key(&id) {
-            let name = node.get("name").and_then(Kv::str).unwrap_or("Style");
-            let desc = node.get("styleDescription").or_else(|| node.get("description")).and_then(Kv::str).unwrap_or("");
-            self.styles.insert(id, json!({"name": name, "description": desc}));
-        }
-        Some(node)
-    }
-
-    fn auto_layout(&mut self, o: &mut Obj, v: &View<'a>) {
-        let Some(mode) = v.str("stackMode").filter(|m| matches!(*m, "HORIZONTAL" | "VERTICAL" | "GRID")) else { return };
-        o.insert("layoutMode".into(), json!(mode));
-        copy_num(o, v, "stackSpacing", "itemSpacing");
-        copy_num(o, v, "stackCounterSpacing", "counterAxisSpacing");
-        if v.str("stackWrap") == Some("WRAP") {
-            o.insert("layoutWrap".into(), json!("WRAP"));
-        }
-        if v.str("stackCounterAlignContent") == Some("SPACE_BETWEEN") {
-            o.insert("counterAxisAlignContent".into(), json!("SPACE_BETWEEN"));
-        }
-        let (h, vert) = (v.num("stackHorizontalPadding").unwrap_or(0.0), v.num("stackVerticalPadding").unwrap_or(0.0));
-        o.insert("paddingLeft".into(), json!(h));
-        o.insert("paddingTop".into(), json!(vert));
-        o.insert("paddingRight".into(), json!(v.num("stackPaddingRight").unwrap_or(h)));
-        o.insert("paddingBottom".into(), json!(v.num("stackPaddingBottom").unwrap_or(vert)));
-        let main = match v.str("stackPrimaryAlignItems").or_else(|| v.str("stackJustify")) {
-            Some("CENTER") => "CENTER",
-            Some("MAX") => "MAX",
-            Some("SPACE_AROUND") => "SPACE_AROUND",
-            // `SPACE_EVENLY` is the format's older name for equal gaps without edge space.
-            Some("SPACE_EVENLY_CSS") => "SPACE_EVENLY",
-            Some("SPACE_BETWEEN" | "SPACE_EVENLY") => "SPACE_BETWEEN",
-            _ => "MIN",
-        };
-        o.insert("primaryAxisAlignItems".into(), json!(main));
-        let cross = match v.str("stackCounterAlignItems").or_else(|| v.str("stackAlign")) {
-            Some("CENTER") => "CENTER",
-            Some("MAX") => "MAX",
-            Some("BASELINE") => "BASELINE",
-            _ => "MIN",
-        };
-        o.insert("counterAxisAlignItems".into(), json!(cross));
-        let sizing = |k: &str| if v.str(k).is_some_and(|s| s.starts_with("RESIZE_TO_FIT")) { "AUTO" } else { "FIXED" };
-        // A flow that records no sizing for its primary axis sizes it by its content: auto layout
-        // did before that axis could be fixed.
-        let primary = if v.get("stackPrimarySizing").is_none() && mode != "GRID" { "AUTO" } else { sizing("stackPrimarySizing") };
-        o.insert("primaryAxisSizingMode".into(), json!(primary));
-        o.insert("counterAxisSizingMode".into(), json!(sizing("stackCounterSizing")));
-        if let Some(b) = v.flag("bordersTakeSpace") {
-            o.insert("strokesIncludedInLayout".into(), json!(b));
-        }
-        if let Some(b) = v.flag("stackReverseZIndex") {
-            o.insert("itemReverseZIndex".into(), json!(b));
-        }
-        if mode == "GRID" {
-            copy_num(o, v, "gridColumnGap", "gridColumnGap");
-            copy_num(o, v, "gridRowGap", "gridRowGap");
-            o.insert("gridColumnCount".into(), json!(tracks(v, "gridColumns").len()));
-            o.insert("gridRowCount".into(), json!(tracks(v, "gridRows").len()));
-            let track_data = [("columnTracks", "gridColumns", "gridColumnsSizing"), ("rowTracks", "gridRows", "gridRowsSizing")]
-                .into_iter()
-                .filter_map(|(out_key, order_key, sizing_key)| {
-                    self.map_grid_tracks(v, order_key, sizing_key).map(|mapped| (out_key.to_string(), mapped))
-                })
-                .collect::<Obj>();
-            if !track_data.is_empty() {
-                let source = o.entry(crate::rest::FIG_SOURCE_FIELD).or_insert_with(|| json!({}));
-                if let Some(source) = source.as_object_mut() {
-                    source.insert("gridTracks".into(), Value::Object(track_data));
-                }
-            }
-        }
-    }
-
-    /// Track sizing maps are keyed by GUID; their order comes from the separate track list.
-    fn map_grid_tracks(&mut self, v: &View<'a>, order_key: &str, sizing_key: &str) -> Option<Value> {
-        let track_entries = v.get(order_key).and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default();
-        let sizes = v.get(sizing_key).and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default();
-        if track_entries.len() > MAX_GRID_TRACKS {
-            self.warn("grid track list exceeds 1000 entries; the tracks use the default equal sizing");
-            return None;
-        }
-        if sizes.is_empty() {
-            return None;
-        }
-        if sizes.len() > MAX_GRID_TRACKS {
-            self.warn("grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing");
-            return None;
-        }
-        let ordered = tracks(v, order_key);
-        let ordered_ids: BTreeSet<&str> = ordered.iter().map(String::as_str).collect();
-        let mut size_by_id: BTreeMap<String, Option<&Kv<'a>>> = BTreeMap::new();
-        for entry in sizes {
-            let Some(id) = entry.get("id").and_then(guid) else {
-                self.warn("stale or invalid grid track sizing entries were ignored");
-                continue;
-            };
-            if !ordered_ids.contains(id.as_str()) {
-                self.warn("stale or invalid grid track sizing entries were ignored");
-                continue;
-            }
-            match size_by_id.entry(id) {
-                std::collections::btree_map::Entry::Vacant(slot) => {
-                    slot.insert(Some(entry));
-                }
-                std::collections::btree_map::Entry::Occupied(mut slot) => {
-                    slot.insert(None);
-                    self.warn("duplicate grid track sizing entries use equal tracks");
-                }
-            }
-        }
-        let mut mapped = Vec::with_capacity(ordered.len());
-        for id in ordered {
-            if let Some(Some(entry)) = size_by_id.get(&id) {
-                match grid_track_sizing(entry.get("trackSize")) {
-                    Some(track) => mapped.push(track),
-                    None => {
-                        self.warn("grid track sizing is unsupported or malformed; affected tracks use equal sizing");
-                        mapped.push(json!({"sizing": "fill", "value": 1.0}));
-                    }
-                }
-            } else {
-                mapped.push(json!({"sizing": "fill", "value": 1.0}));
-            }
-        }
-        Some(Value::Array(mapped))
-    }
-
-    fn text(&mut self, o: &mut Obj, v: &View<'a>) {
-        let style_node = style_link(v, "styleIdForText", "inheritTextStyleID").and_then(|s| self.nodes.get(&s).copied());
-        // Instance overrides beat the shared style; the style beats the layer's own copy.
-        let sv = v.styled(style_node.filter(|s| s.get("styleType").and_then(Kv::str) == Some("TEXT")));
-        let td = v.get("textData");
-        let chars = td.and_then(|t| t.get("characters")).and_then(Kv::str).unwrap_or("");
-        o.insert("characters".into(), json!(chars));
-        let mut style = text_style(&sv, None);
-        // The style's typography beats the layer's own copy of it (the copy is stale when the style
-        // changed). The file cannot tell a stale copy of these four values from a deliberate local
-        // one, and "original", "none" and 0 could never be set locally if the style always won, so
-        // a value the layer or an override sets itself is taken as deliberate.
-        if let Some(decoration @ ("NONE" | "UNDERLINE" | "STRIKETHROUGH")) = v.str("textDecoration") {
-            style.insert("textDecoration".into(), json!(decoration));
-        }
-        if let Some(skip_ink) = v.flag("textDecorationSkipInk") {
-            style.insert("textDecorationSkipInk".into(), json!(skip_ink));
-        }
-        if let Some(case @ ("ORIGINAL" | "UPPER" | "LOWER" | "TITLE" | "SMALL_CAPS" | "SMALL_CAPS_FORCED")) = v.str("textCase") {
-            style.insert("textCase".into(), json!(case));
-        }
-        for k in ["textAlignHorizontal", "textAlignVertical", "textAutoResize", "textTruncation"] {
-            copy_str(&mut style, v, k, k);
-        }
-        // Paragraph settings belong to the effective text layer, including explicit zero clears.
-        for k in ["paragraphSpacing", "paragraphIndent"] {
-            copy_num(&mut style, v, k, k);
-        }
-        insert_text_options(&mut style, v);
-        if let Some(n) = v.num("maxLines").filter(|n| *n >= 1.0) {
-            style.insert("maxLines".into(), json!(n));
-        }
-        let size = sv.num("fontSize");
-        if let Some(b) = o.get_mut("style").and_then(|s| s.get_mut("boundVariables")).map(Value::take) {
-            style.insert("boundVariables".into(), b);
-        }
-        o.insert("style".into(), Value::Object(style));
-        let Some(td) = td else { return };
-        char_styles(o, td, size, &mut |w| self.warn(w));
-        let raw = td.get("lines").map(Kv::list).unwrap_or_default();
-        let lines: Vec<&str> = raw
-            .iter()
-            .map(|l| match l.get("lineType").and_then(Kv::str) {
-                Some("ORDERED_LIST") => "ORDERED",
-                Some("UNORDERED_LIST") => "UNORDERED",
-                _ => "NONE",
-            })
-            .collect();
-        if lines.iter().any(|l| *l != "NONE") {
-            o.insert("lineTypes".into(), json!(lines));
-        }
-        // Where a numbered list starts counting, less one (not a REST field).
-        let starts: Vec<u32> =
-            raw.iter().map(|l| num(l, "listStartOffset").filter(|n| n.is_finite()).map_or(0, |n| n.clamp(0.0, f64::from(u32::MAX)) as u32)).collect();
-        if starts.iter().any(|n| *n > 0) {
-            o.insert("listStartOffsets".into(), json!(starts));
-        }
-    }
-
-    /// Carry supported text-path data through the private .fig REST ingress only.
-    fn text_path(&mut self, o: &mut Obj, v: &View<'a>) {
-        let fail = |this: &mut Self, reason: &str| {
-            this.warn(format!("text path {reason}; text imports off its path"));
-        };
-        let Some(start) = v.get("textPathStart") else {
-            fail(self, "has no start data");
-            return;
-        };
-        let (Some(t), Some(forward)) = (num(start, "tValue"), start.get("forward").and_then(Kv::bool)) else {
-            fail(self, "has invalid start data");
-            return;
-        };
-        let Some(vd) = v.get("vectorData") else {
-            fail(self, "has no vector data");
-            return;
-        };
-        let Some(blob) = num(vd, "vectorNetworkBlob")
-            .filter(|i| i.is_finite() && *i >= 0.0 && i.fract() == 0.0)
-            .and_then(|i| usize::try_from(i as u64).ok())
-            .and_then(|i| self.blobs.get(i))
-            .copied()
-        else {
-            fail(self, "has no vector network");
-            return;
-        };
-        let Some(net) = network::decode(blob) else {
-            fail(self, "has damaged vector data");
-            return;
-        };
-        let Some(norm) = vd.get("normalizedSize") else {
-            fail(self, "has invalid normalized size");
-            return;
-        };
-        let Some(size) = v.get("size") else {
-            fail(self, "has invalid dimensions");
-            return;
-        };
-        let (Some(nx), Some(ny), Some(w), Some(h)) = (num(norm, "x"), num(norm, "y"), num(size, "x"), num(size, "y")) else {
-            fail(self, "has invalid dimensions");
-            return;
-        };
-        let axis_scale = |size: f64, normalized: f64, values: &[f64]| -> Option<f64> {
-            if !size.is_finite() || size < 0.0 || !normalized.is_finite() || normalized < 0.0 {
-                return None;
-            }
-            if normalized > 1e-9 {
-                if size <= 0.0 {
-                    return None;
-                }
-                return Some(size / normalized);
-            }
-            (size == 0.0 && values.iter().all(|v| *v == 0.0)).then_some(1.0)
-        };
-        let xs: Vec<f64> = net.vertices.iter().map(|p| p.x).chain(net.segments.iter().flat_map(|s| [s.ta.0, s.tb.0])).collect();
-        let ys: Vec<f64> = net.vertices.iter().map(|p| p.y).chain(net.segments.iter().flat_map(|s| [s.ta.1, s.tb.1])).collect();
-        let sx = axis_scale(w, nx, &xs);
-        let sy = axis_scale(h, ny, &ys);
-        let (Some(sx), Some(sy)) = (sx, sy) else {
-            fail(self, "has invalid path scale");
-            return;
-        };
-        if v.str("textAlignVertical").is_some_and(|x| x != "TOP") {
-            fail(self, "uses unsupported vertical placement");
-            return;
-        }
-        if v.get("textData").and_then(|td| td.get("characters")).and_then(Kv::str).is_some_and(|s| s.chars().any(|c| matches!(c, '\n' | '\r'))) {
-            fail(self, "contains multiple lines");
-            return;
-        }
-        let path = match super::text_path::from_network(&net, sx, sy, t, forward) {
-            Ok(path) => path,
-            Err(reason) => {
-                fail(self, reason);
-                return;
-            }
-        };
-        let has_decoration = |style: &Value| style.get("textDecoration").and_then(Value::as_str).is_some_and(|x| x != "NONE");
-        let decorated = o.get("style").is_some_and(has_decoration)
-            || o.get("styleOverrideTable").and_then(Value::as_object).into_iter().flat_map(|styles| styles.values()).any(has_decoration);
-        if decorated {
-            self.warn("text path underline or strikethrough decoration is not rendered");
-        }
-        o.insert("_figTextPath".into(), json!({"d": path.d, "start": path.start, "flip": path.flip}));
-    }
-
-    /// `fillGeometry` / `strokeGeometry` as SVG path data, and star/polygon parameters.
-    fn geometry(&mut self, o: &mut Obj, v: &View<'a>) {
-        for key in ["fillGeometry", "strokeGeometry"] {
-            let mut out = Vec::new();
-            for p in v.list(key) {
-                let Some(blob) = num(p, "commandsBlob").and_then(|i| self.blobs.get(i as usize)).copied() else { continue };
-                let Some(d) = svg_path(blob) else {
-                    self.warn("damaged vector geometry was skipped");
-                    continue;
-                };
-                if d.is_empty() {
-                    continue;
-                }
-                let winding = if p.get("windingRule").and_then(Kv::str) == Some("ODD") { "EVENODD" } else { "NONZERO" };
-                out.push(json!({"path": d, "windingRule": winding}));
-            }
-            if !out.is_empty() {
-                o.insert(key.into(), Value::Array(out));
-            }
-        }
-        let vector = o.get("type").and_then(Value::as_str) == Some("VECTOR");
-        if vector && !self.network(o, v) && !o.contains_key("fillGeometry") && !o.contains_key("strokeGeometry") && v.str("type") != Some("CONNECTOR")
-        {
-            self.warn("vectors without geometry are empty");
-        }
-        if !vector {
-            copy_num(o, v, "count", "pointCount");
-            copy_num(o, v, "starInnerScale", "innerRadius");
-        }
-    }
-
-    /// The editable network of `vectorData` as `vectorNetwork` (the REST importer's extension),
-    /// scaled to the layer's size, with per-point corner radii, handle mirroring and end caps.
-    /// False when there's none or it's damaged (the outlines stand in).
-    fn network(&mut self, o: &mut Obj, v: &View<'a>) -> bool {
-        let Some(vd) = v.get("vectorData") else { return false };
-        let Some(blob_id) = num(vd, "vectorNetworkBlob").map(|i| i as usize) else { return false };
-        let Some(blob) = self.blobs.get(blob_id).copied() else { return false };
-        let Some(net) = network::decode(blob) else {
-            self.warn("damaged vector networks import as outlines");
-            return false;
-        };
-        let styles: BTreeMap<u64, &Kv> =
-            vd.get("styleOverrideTable").map(Kv::list).unwrap_or_default().iter().filter_map(|s| Some((num(s, "styleID")? as u64, s))).collect();
-        let mut has_uninterpreted = false;
-        let mut has_missing = false;
-        for segment in &net.segments {
-            if segment.style == 0 {
-                continue;
-            }
-            if styles.contains_key(&u64::from(segment.style)) {
-                has_uninterpreted = true;
-            } else {
-                has_missing = true;
-            }
-        }
-        if has_uninterpreted {
-            self.warn("style settings of some vector segments aren't supported; those segments use the layer's stroke");
-        }
-        if has_missing {
-            self.warn("some vector segments refer to style settings missing from the file; they use the layer's stroke");
-        }
-        // An open path shows its fill, which regions can't hold: the outline keeps the look.
-        let fills_shown =
-            o.get("fills").and_then(Value::as_array).is_some_and(|f| f.iter().any(|p| p.get("visible").and_then(Value::as_bool) != Some(false)));
-        if net.segments.is_empty() || (net.regions.is_empty() && fills_shown && o.contains_key("fillGeometry")) {
-            return false;
-        }
-        let style = |id: u32| styles.get(&u64::from(id)).copied().filter(|_| id != 0);
-        let scale = |k: &str| {
-            let size = v.size().map(|s| if k == "x" { s.0 } else { s.1 });
-            let norm = vd.get("normalizedSize").and_then(|s| num(s, k));
-            size.zip(norm).filter(|(s, n)| s.is_finite() && *n > 1e-9).map_or(1.0, |(s, n)| s / n)
-        };
-        let (sx, sy) = (scale("x"), scale("y"));
-        // An absent layer join is the source default.
-        let layer_join = v.str("strokeJoin").unwrap_or("MITER");
-        let point_join = |p: &network::Vertex| style(p.style).and_then(|s| s.get("strokeJoin"));
-        let known = |j: &str| matches!(j, "MITER" | "BEVEL" | "ROUND");
-        let unresolved_style = net.vertices.iter().any(|p| p.style != 0 && style(p.style).is_none());
-        let unknown_join = net.vertices.iter().any(|p| point_join(p).is_some_and(|j| !j.str().is_some_and(known)));
-        let unsupported_join = net.vertices.iter().any(|p| point_join(p).and_then(Kv::str).is_some_and(|j| known(j) && j != layer_join));
-        if net.regions.iter().any(|r| style(r.style).is_some_and(|s| s.get("fillPaints").is_some())) {
-            self.warn("filled areas of a vector with their own fill use the layer's fill");
-        }
-        if unresolved_style {
-            self.warn("some vector points refer to point settings missing from the file; they use the layer's joins and plain corners");
-        }
-        if unknown_join {
-            self.warn("vector points with unknown stroke joins use the layer join");
-        }
-        if unsupported_join && (o.contains_key("strokeDashes") || o.contains_key("strokeWidthProfile")) {
-            self.warn("point stroke joins were preserved; dashed or variable-width strokes render with the layer join");
-        }
-        // The stroke starts at the first end point and stops at the last (as the editor draws it).
-        let mut degree = vec![0usize; net.vertices.len()];
-        for s in &net.segments {
-            for i in [s.a, s.b] {
-                if let Some(d) = degree.get_mut(i) {
-                    *d += 1;
-                }
-            }
-        }
-        let ends: Vec<usize> = (0..degree.len()).filter(|i| degree.get(*i) == Some(&1)).collect();
-        let cap =
-            |i: Option<&usize>| i.and_then(|i| net.vertices.get(*i)).and_then(|p| style(p.style)).and_then(|s| s.get("strokeCap")).and_then(Kv::str);
-        let (first, last) = (cap(ends.first()), cap(ends.last()));
-        if first.is_some() || last.is_some() {
-            let node = v.str("strokeCap").unwrap_or("NONE");
-            o.insert("strokeCapStart".into(), json!(cap_name(first.unwrap_or(node))));
-            o.insert("strokeCapEnd".into(), json!(cap_name(last.unwrap_or(node))));
-        }
-        // Every instance of a main shows the same network: it is written once and shared.
-        let key = (blob_id, sx.to_bits(), sy.to_bits(), std::ptr::from_ref(vd) as usize);
-        let id = match self.network_ids.get(&key) {
-            Some(id) => *id,
-            None => {
-                let vertices: Vec<Value> = net
-                    .vertices
-                    .iter()
-                    .map(|p| {
-                        let mut out = json!({"x": p.x * sx, "y": p.y * sy});
-                        let st = style(p.style);
-                        if let Some(r) = st.and_then(|s| num(s, "cornerRadius")).filter(|r| *r > 0.0) {
-                            out["radius"] = json!(r);
-                        }
-                        match st.and_then(|s| s.get("handleMirroring")).and_then(Kv::str) {
-                            Some("ANGLE") => out["mirror"] = json!("angle"),
-                            Some("ANGLE_AND_LENGTH") => out["mirror"] = json!("angleAndLength"),
-                            Some("NONE") => out["mirror"] = json!("none"),
-                            _ => {}
-                        }
-                        if let Some(join @ ("MITER" | "BEVEL" | "ROUND")) = st.and_then(|s| s.get("strokeJoin")).and_then(Kv::str) {
-                            out["join"] = json!(join.to_ascii_lowercase());
-                        }
-                        out
-                    })
-                    .collect();
-                let segments: Vec<Value> = net
-                    .segments
-                    .iter()
-                    .map(|s| json!({"a": s.a, "b": s.b, "ta": [s.ta.0 * sx, s.ta.1 * sy], "tb": [s.tb.0 * sx, s.tb.1 * sy]}))
-                    .collect();
-                let regions: Vec<Value> =
-                    net.regions.iter().map(|r| json!({"loops": r.loops, "winding": if r.non_zero { "nonZero" } else { "evenOdd" }})).collect();
-                let mut entry = json!({});
-                entry["vertices"] = Value::Array(vertices);
-                entry["segments"] = Value::Array(segments);
-                entry["regions"] = Value::Array(regions);
-                self.networks.push(crate::rest::network(&entry));
-                self.network_ids.insert(key, self.networks.len() - 1);
-                self.networks.len() - 1
-            }
-        };
-        o.insert("vectorNetworkRef".into(), json!(id));
-        true
-    }
-
-    /// Component property definitions and description.
-    fn component(&mut self, o: &mut Obj, v: &View<'a>, id: &str) {
-        let mut defs = Obj::new();
-        for d in v.list("componentPropDefs") {
-            if d.get("isDeleted").and_then(Kv::bool) == Some(true) {
-                continue;
-            }
-            let Some((name, ty)) = d.get("id").and_then(guid).and_then(|i| self.prop_defs.get(&i).cloned()) else { continue };
-            let init = d.get("initialValue");
-            let def = match ty {
-                "BOOL" => json!({"type": "BOOLEAN", "defaultValue": init.and_then(|i| i.get("boolValue")).and_then(Kv::bool).unwrap_or(true)}),
-                "TEXT" => json!({"type": "TEXT", "defaultValue": init.and_then(prop_text).unwrap_or("")}),
-                "INSTANCE_SWAP" => match init.and_then(|i| i.get("guidValue")).and_then(guid) {
-                    Some(g) => {
-                        if self.nodes.contains_key(&g) {
-                            self.referenced_mains.insert(g.clone());
-                        }
-                        json!({"type": "INSTANCE_SWAP", "defaultValue": g})
-                    }
-                    None => continue,
-                },
-                "VARIANT" => json!({"type": "VARIANT"}),
-                "SLOT" => {
-                    self.warn_non_default_slot_config(d);
-                    self.warn_dropped_slot_preferred_values(d);
-                    json!({"type": "SLOT"})
-                }
-                _ => {
-                    self.warn(format!("{} component properties are not supported and were skipped", ty.to_ascii_lowercase()));
-                    continue;
-                }
-            };
-            defs.insert(name, def);
-        }
-        if !defs.is_empty() {
-            o.insert("componentPropertyDefinitions".into(), Value::Object(defs));
-        }
-        if let Some(d) = v.str("symbolDescription").or_else(|| v.str("description")).filter(|d| !d.is_empty()) {
-            let into = if o.get("type").and_then(Value::as_str) == Some("COMPONENT_SET") { &mut self.sets } else { &mut self.components };
-            into.insert(id.to_string(), json!({"description": d}));
-        }
-    }
-
-    /// Preferred slot values are source component keys, but this mapper has no proven way to map
-    /// those keys to file GUIDs. They are dropped instead of guessing native NodeIds.
-    fn warn_dropped_slot_preferred_values(&mut self, def: &Kv<'a>) {
-        let entries = def.get("preferredValues").and_then(|v| v.get("instanceSwapValues")).map(Kv::list).unwrap_or_default();
-        if !entries.is_empty() {
-            self.warn("preferred slot component keys cannot be resolved to file nodes and were skipped");
-        }
-    }
-
-    fn warn_non_default_slot_config(&mut self, def: &Kv<'a>) {
-        let Some(config) = def.get("slotPropConfig") else { return };
-        let non_default = [
-            ("stretchChildOnInsert", Some(false)),
-            ("displayByDefault", Some(false)),
-            ("minChildren", None),
-            ("maxChildren", None),
-            ("allowPreferredValuesOnly", Some(false)),
-        ]
-        .into_iter()
-        .any(|(field, bool_default)| {
-            let Some(value) = config.get(field) else { return false };
-            if let Some(default) = bool_default { value.bool() != Some(default) } else { value.f64() != Some(0.0) }
-        });
-        if non_default {
-            self.warn("non-default slot settings are not represented and were skipped");
-        }
-    }
-
-    /// A layer's component property references, and inside an instance the values they take.
-    fn prop_refs(&mut self, o: &mut Obj, v: &View<'a>, inst: Option<&Inst<'a>>) {
-        let mut refs = Obj::new();
-        for e in v.get("parameterConsumptionMap").and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default() {
-            let field = match e.get("variableField").and_then(Kv::str) {
-                Some("VISIBLE") => "visible",
-                Some("TEXT_DATA") => "characters",
-                Some("OVERRIDDEN_SYMBOL_ID") => "mainComponent",
-                Some("SLOT_CONTENT_ID") => "slot",
-                _ => continue,
-            };
-            let Some(def) =
-                e.get("variableData").and_then(|d| d.get("value")).and_then(|x| x.get("propRefValue")).and_then(|p| p.get("defId")).and_then(guid)
-            else {
-                continue;
-            };
-            // Expanded frames must follow their main frame's source link. A direct slot reference
-            // makes the engine resolve ownership against the instance, where the property is not defined.
-            if !(field == "slot" && inst.is_some())
-                && let Some((name, _)) = self.prop_def(&def)
-            {
-                refs.insert(field.into(), json!(name));
-            }
-            let Some(val) = inst.and_then(|i| i.props.get(&self.prop_root(&def))) else { continue };
-            match field {
-                "visible" => {
-                    if let Some(b) = val.get("boolValue").and_then(Kv::bool) {
-                        o.insert("visible".into(), json!(b));
-                    }
-                }
-                "characters" => {
-                    if let Some(t) = prop_text(val) {
-                        o.insert("characters".into(), json!(t));
-                        // Run styles count the chars they were made for: for other chars only
-                        // the value's own apply.
-                        if own_text(v) != Some(t) {
-                            o.remove("characterStyleOverrides");
-                            o.remove("styleOverrideTable");
-                            if let Some(tv) = prop_text_data(val) {
-                                let size = o.get("style").and_then(|s| s.get("fontSize")).and_then(Value::as_f64);
-                                char_styles(o, tv, size, &mut |w| self.warn(w));
-                            }
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-        if !refs.is_empty() {
-            o.insert("componentPropertyReferences".into(), Value::Object(refs));
-        }
-    }
-
-    /// An instance's main and properties; the context its expanded layers are built in.
-    fn instance(&mut self, o: &mut Obj, v: &View<'a>, id: &str, outer: Option<&Inst<'a>>, rest_id: &str) -> Option<(Inst<'a>, String)> {
-        let sd = v.get("symbolData");
-        let mut sym = v.get("overriddenSymbolID").and_then(guid).or_else(|| sd.and_then(|s| s.get("symbolID")).and_then(guid));
-        // An instance swap property value picks the main.
-        if let Some(i) = outer
-            && let Some(def) = prop_ref(v, "OVERRIDDEN_SYMBOL_ID")
-            && let Some(g) = i.props.get(&self.prop_root(&def)).and_then(|p| prop_guid(p))
-        {
-            sym = Some(g);
-        }
-        let Some(sym) = sym else {
-            self.warn("instances without a main component were imported as empty frames");
-            return None;
-        };
-        o.insert("componentId".into(), json!(sym));
-        let assignments = v.list("componentPropAssignments");
-        let mut props = Obj::new();
-        for a in assignments {
-            let Some((name, ty)) = a.get("defID").and_then(guid).and_then(|d| self.prop_def(&d).cloned()) else { continue };
-            let val = assigned(a);
-            let p = match ty {
-                "BOOL" => val.and_then(|x| x.get("boolValue")).and_then(Kv::bool).map(|b| json!({"type": "BOOLEAN", "value": b})),
-                "TEXT" => val.and_then(prop_text).map(|t| json!({"type": "TEXT", "value": t})),
-                "INSTANCE_SWAP" => val.and_then(prop_guid).map(|g| json!({"type": "INSTANCE_SWAP", "value": g})),
-                _ => None,
-            };
-            if let Some(p) = p {
-                props.insert(name, p);
-            }
-        }
-        if !props.is_empty() {
-            o.insert("componentProperties".into(), Value::Object(props));
-        }
-        if !self.nodes.contains_key(&sym) {
-            self.warn("instances of components that aren't in the file show no layers");
-            return None;
-        }
-        if !self.referenced_mains.contains(&sym) {
-            self.referenced_mains.insert(sym.clone());
-        }
-        if outer.is_some_and(|i| i.symbols.contains(&sym)) {
-            return None;
-        }
-        // Overrides by id path below this instance (the instance itself is addressed by its main's id).
-        let own_path: Vec<String> = outer.map(|i| [i.path.as_slice(), &[id.to_string()]].concat()).unwrap_or_default();
-        let scope = self.override_scope(&sym);
-        let mut overrides: Overrides<'a> = BTreeMap::new();
-        if let Some(inherited) = outer {
-            for (path, rows) in inherited.overrides.iter() {
-                let mut path = path.clone();
-                // Rows an outer instance wrote for this instance's layers may use their old keys.
-                if path.starts_with(&own_path) && path.len() > own_path.len() {
-                    normalize_override_segment(&mut path, own_path.len(), &scope);
-                }
-                overrides.entry(path).or_default().extend(rows.iter().cloned());
-            }
-        }
-        // A nested instance's derived layout is for the size it has in its main: resized here, the
-        // sizes and places in it no longer hold and its layers follow their constraints instead.
-        let differs = |a: f64, b: f64| (a - b).abs() > 1e-6 * a.abs().max(b.abs()).max(1.0);
-        let resized = outer.is_some()
-            && match (self.nodes.get(id).and_then(|b| View::of(b).size()), v.size()) {
-                (Some(a), Some(b)) => differs(a.0, b.0) || differs(a.1, b.1),
-                (a, b) => a.is_some() != b.is_some(),
-            };
-        let mut local: Overrides<'a> = BTreeMap::new();
-        let lists = [sd.and_then(|s| s.get("symbolOverrides")).map(Kv::list).unwrap_or_default(), v.list("derivedSymbolData")];
-        let source_depth = outer.map_or(0, |i| i.symbols.len());
-        let mut ordinal = 0;
-        for (layer, list) in lists.into_iter().enumerate() {
-            for ov in list {
-                let row_ordinal = ordinal;
-                ordinal += 1;
-                let mut rel: Vec<String> =
-                    ov.get("guidPath").and_then(|g| g.get("guids")).map(Kv::list).unwrap_or_default().iter().filter_map(guid).collect();
-                if rel.is_empty() || rel == [sym.clone()] {
-                    continue;
-                }
-                normalize_override_segment(&mut rel, 0, &scope);
-                // Explicit overrides, then derived layout (stale once the instance is resized).
-                let entry = match (layer, resized) {
-                    (0, _) => Entry::Override,
-                    (_, false) => Entry::Derived,
-                    (_, true) => Entry::Stale,
-                };
-                local.entry([own_path.as_slice(), &rel].concat()).or_default().push(OverrideRow {
-                    row: ov,
-                    entry,
-                    source_depth,
-                    ordinal: row_ordinal,
-                });
-            }
-        }
-        for (path, rows) in local {
-            overrides.entry(path).or_default().extend(rows);
-        }
-        for rows in overrides.values_mut() {
-            // Deeper source rows apply first; outer rows win, with wire order preserved per source.
-            rows.sort_by_key(|row| (std::cmp::Reverse(row.source_depth), row.ordinal));
-        }
-        let mut all_props: BTreeMap<String, &'a Kv<'a>> = outer.map(|i| (*i.props).clone()).unwrap_or_default();
-        let mut slot_contents: BTreeMap<String, String> = outer.map(|i| (*i.slot_contents).clone()).unwrap_or_default();
-        for a in assignments {
-            if let (Some(d), Some(val)) = (a.get("defID").and_then(guid), assigned(a)) {
-                all_props.entry(self.prop_root(&d)).or_insert(val);
-            }
-            let Some(def) = a.get("defID").and_then(guid) else { continue };
-            if self.prop_def(&def).is_none_or(|(_, ty)| *ty != "SLOT") {
-                continue;
-            }
-            let var_value = a.get("varValue");
-            if var_value.and_then(|v| v.get("dataType")).and_then(Kv::str) != Some("SLOT_CONTENT_ID") {
-                self.warn("malformed slot content assignment was skipped");
-                continue;
-            }
-            let target = var_value.and_then(|v| v.get("value")).and_then(|v| v.get("slotContentIdValue")).and_then(|v| v.get("guid")).and_then(guid);
-            let Some(target) = target else {
-                self.warn("malformed slot content assignment was skipped");
-                continue;
-            };
-            if target == "4294967295:4294967295" {
-                self.warn("slot content assignment uses the empty GUID sentinel and was skipped");
-                continue;
-            }
-            if self.nodes.get(&target).is_none_or(|n| n.get("isSlotContent").and_then(Kv::bool) != Some(true)) {
-                self.warn("slot content assignment target is missing or is not slot content");
-                continue;
-            }
-            slot_contents.entry(self.prop_root(&def)).or_insert(target);
-        }
-        let mut symbols = outer.map(|i| i.symbols.clone()).unwrap_or_default();
-        symbols.push(sym.clone());
-        let root = outer.map_or_else(|| rest_id.to_string(), |i| i.root.clone());
-        Some((
-            Inst {
-                root,
-                path: own_path,
-                overrides: Rc::new(overrides),
-                props: Rc::new(all_props),
-                slot_contents: Rc::new(slot_contents),
-                slot_content: false,
-                symbols,
-            },
-            sym,
-        ))
-    }
-
-    fn prototype(&mut self, o: &mut Obj, v: &View<'a>) {
-        let mut list = Vec::new();
-        for it in v.list("prototypeInteractions") {
-            if it.get("isDeleted").and_then(Kv::bool) == Some(true) {
-                continue;
-            }
-            if let Some(i) = self.interaction(it) {
-                list.push(i);
-            }
-        }
-        if !list.is_empty() {
-            o.insert("interactions".into(), Value::Array(list));
-        }
-        let overflow = match v.str("scrollDirection") {
-            Some("HORIZONTAL") => Some("HORIZONTAL_SCROLLING"),
-            Some("VERTICAL") => Some("VERTICAL_SCROLLING"),
-            Some("BOTH") => Some("HORIZONTAL_AND_VERTICAL_SCROLLING"),
-            _ => None,
-        };
-        if let Some(d) = overflow {
-            o.insert("overflowDirection".into(), json!(d));
-        }
-        let behavior = match v.str("scrollBehavior") {
-            Some("FIXED_WHEN_CHILD_OF_SCROLLING_FRAME") => Some("FIXED"),
-            Some("STICKY_SCROLLS") => Some("STICKY_SCROLLS"),
-            _ => None,
-        };
-        if let Some(b) = behavior {
-            o.insert("scrollBehavior".into(), json!(b));
-        }
-        copy_str(o, v, "overlayPositionType", "overlayPositionType");
-        copy_str(o, v, "overlayBackgroundInteraction", "overlayBackgroundInteraction");
-        if let Some(a) = v.get("overlayBackgroundAppearance") {
-            let ty = a.get("backgroundType").and_then(Kv::str).unwrap_or("NONE");
-            o.insert("overlayBackground".into(), json!({"type": ty, "color": a.get("backgroundColor").map_or(Value::Null, color)}));
-        }
-    }
-
-    fn interaction(&mut self, it: &Kv) -> Option<Value> {
-        let ev = it.get("event");
-        let ty = match ev.and_then(|e| e.get("interactionType")).and_then(Kv::str).unwrap_or("ON_CLICK") {
-            "DRAG" => "ON_DRAG",
-            "MOUSE_IN" => "MOUSE_ENTER",
-            "MOUSE_OUT" => "MOUSE_LEAVE",
-            t => t,
-        };
-        let mut trigger = json!({"type": ty});
-        if let Some(t) = ev.and_then(|e| num(e, "transitionTimeout")) {
-            // Seconds as 32-bit floats: whole milliseconds.
-            trigger["timeout"] = json!((t * 1000.0).round());
-        }
-        if let Some(k) = ev.and_then(|e| e.get("keyTrigger")) {
-            let codes: Vec<f64> = k.get("keyCodes").map(Kv::list).unwrap_or_default().iter().filter_map(Kv::f64).collect();
-            trigger["keyCodes"] = json!(codes);
-            if let Some(d) = k.get("triggerDevice").and_then(Kv::str) {
-                trigger["device"] = json!(if d.contains("KEYBOARD") { "KEYBOARD" } else { d });
-            }
-        }
-        let actions: Vec<Value> = it.get("actions").map(Kv::list).unwrap_or_default().iter().filter_map(|a| self.action(a, 0)).collect();
-        (!actions.is_empty()).then(|| json!({"trigger": trigger, "actions": actions}))
-    }
-
-    /// One prototype action in the REST shape (`depth`: conditionals it's nested in).
-    fn action(&mut self, a: &Kv, depth: usize) -> Option<Value> {
-        Some(match a.get("connectionType").and_then(Kv::str) {
-            Some("INTERNAL_NODE") | None => {
-                let dest = a.get("transitionNodeID").and_then(guid)?;
-                let nav = match a.get("navigationType").and_then(Kv::str) {
-                    Some("SWAP_STATE") => "CHANGE_TO",
-                    Some(n) => n,
-                    None => "NAVIGATE",
-                };
-                let mut act = json!({"type": "NODE", "destinationId": dest, "navigation": nav});
-                if let Some(t) = transition(a) {
-                    act["transition"] = t;
-                }
-                if let Some(b) = a.get("transitionPreserveScroll").and_then(Kv::bool) {
-                    act["preserveScrollPosition"] = json!(b);
-                }
-                if let Some(p) = a.get("overlayRelativePosition") {
-                    act["overlayRelativePosition"] = json!({"x": num(p, "x"), "y": num(p, "y")});
-                }
-                act
-            }
-            Some("URL") => json!({"type": "URL", "url": a.get("connectionURL").and_then(Kv::str)?}),
-            Some("BACK") => json!({"type": "BACK"}),
-            Some("CLOSE") => json!({"type": "CLOSE"}),
-            Some("NONE") => return None,
-            Some("SET_VARIABLE") => {
-                let var = a.get("targetVariable").and_then(|t| t.get("id")).and_then(ref_guid).or_else(|| a.get("targetVariableID").and_then(guid));
-                // Missing parts are left out: the REST importer skips the action with a warning.
-                let mut act = json!({"type": "SET_VARIABLE", "variableId": var});
-                if let Some(d) = a.get("targetVariableData").and_then(|d| variable_data(d, 0)) {
-                    act["variableValue"] = d;
-                }
-                act
-            }
-            Some("SET_VARIABLE_MODE") => json!({
-                "type": "SET_VARIABLE_MODE",
-                "variableCollectionId": a.get("targetVariableSetID").and_then(ref_guid),
-                "variableModeId": a.get("targetVariableModeID").and_then(guid),
-            }),
-            Some("CONDITIONAL") if depth < MAX_ACTION_DEPTH => {
-                let mut blocks = Vec::new();
-                for b in a.get("conditionalActions").map(Kv::list).unwrap_or_default() {
-                    let actions: Vec<Value> =
-                        b.get("actions").map(Kv::list).unwrap_or_default().iter().filter_map(|x| self.action(x, depth + 1)).collect();
-                    let mut block = json!({"actions": actions});
-                    // A condition that can't be read must not turn the block into an "else".
-                    if let Some(c) = b.get("condition") {
-                        block["condition"] = variable_data(c, 0).unwrap_or_else(|| json!({}));
-                    }
-                    blocks.push(block);
-                }
-                json!({"type": "CONDITIONAL", "conditionalBlocks": blocks})
-            }
-            Some(other) => {
-                self.warn(format!("{} prototype actions are not imported from .fig files yet", other.to_ascii_lowercase().replace('_', " ")));
-                return None;
-            }
-        })
-    }
-
-    fn variable_bindings(&mut self, o: &mut Obj, v: &View<'a>) {
-        let mut bound = Obj::new();
-        let mut text_bound = Obj::new();
-        for e in v.get("variableConsumptionMap").and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default() {
-            let Some(var) = alias(e.get("variableData")) else { continue };
-            let a = json!({"type": "VARIABLE_ALIAS", "id": var});
-            let field = e.get("variableField").and_then(Kv::str).unwrap_or("");
-            match (binding_key(field), text_binding_key(field)) {
-                (Some(k), _) => {
-                    bound.insert(k.into(), a);
-                }
-                (_, Some(k)) => {
-                    text_bound.insert(k.into(), a);
-                }
-                _ if field == "CORNER_RADIUS" => {
-                    for k in ["topLeftRadius", "topRightRadius", "bottomLeftRadius", "bottomRightRadius"] {
-                        bound.insert(k.into(), a.clone());
-                    }
-                }
-                _ if field.starts_with("BORDER_") => {
-                    let side = match field {
-                        "BORDER_TOP_WEIGHT" => "strokeTopWeight",
-                        "BORDER_RIGHT_WEIGHT" => "strokeRightWeight",
-                        "BORDER_BOTTOM_WEIGHT" => "strokeBottomWeight",
-                        _ => "strokeLeftWeight",
-                    };
-                    bound.insert(side.into(), a);
-                }
-                _ if field == "WIDTH" || field == "HEIGHT" => {
-                    let axis = if field == "WIDTH" { "x" } else { "y" };
-                    let size = bound.entry("size").or_insert_with(|| json!({}));
-                    size[axis] = a;
-                }
-                _ => self.warn(format!("variables bound to {} are not imported from .fig files yet", field.to_ascii_lowercase().replace('_', " "))),
-            }
-        }
-        if !bound.is_empty() {
-            o.insert("boundVariables".into(), Value::Object(bound));
-        }
-        // (The text style itself is added after this: it keeps these.)
-        if !text_bound.is_empty() {
-            o.insert("style".into(), json!({"boundVariables": text_bound}));
-        }
-        let mut modes = Obj::new();
-        let mut lost = false;
-        for e in v.get("variableModeBySetMap").and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default() {
-            let (Some(set), Some(mode)) = (e.get("variableSetID"), e.get("variableModeID").and_then(guid)) else { continue };
-            match self.resource_id(set) {
-                Some(id) => {
-                    modes.insert(id, json!(mode));
-                }
-                // A mode of a collection neither named by guid nor resolvable in the file.
-                None if set.get("guid").is_some() || set.get("assetRef").is_some() => lost = true,
-                None => {}
-            }
-        }
-        if lost {
-            self.warn("variable modes of collections that aren't in the file were skipped");
-        }
-        if !modes.is_empty() {
-            o.insert("explicitVariableModes".into(), Value::Object(modes));
-        }
-    }
-
-    /// The shared styles the file defines, in their order: each with the sample layer that holds
-    /// its values (`styleDefinitions`, our extension of the file JSON; the REST importer reads it).
-    fn style_definitions(&mut self) -> Vec<Value> {
-        let mut found: Vec<(&'a str, String, &'a Kv<'a>)> = Vec::new();
-        for (id, n) in &self.nodes {
-            let live = n.get("isSoftDeleted").and_then(Kv::bool) != Some(true) && n.get("isSoftDeletedStyle").and_then(Kv::bool) != Some(true);
-            if live && n.get("styleType").and_then(Kv::str).is_some_and(|t| matches!(t, "FILL" | "TEXT" | "EFFECT" | "GRID")) {
-                found.push((n.get("sortPosition").and_then(Kv::str).unwrap_or(""), id.clone(), n));
-            }
-        }
-        found.sort_by(|a, b| (a.0, &a.1).cmp(&(b.0, &b.1)));
-        let mut out = Vec::new();
-        for (_, id, n) in found {
-            let Some(node) = self.layer(&id, None, Affine::IDENTITY, None, None, 0) else { break };
-            let name = n.get("name").and_then(Kv::str).unwrap_or("Style");
-            let desc = n.get("styleDescription").or_else(|| n.get("description")).and_then(Kv::str).unwrap_or("");
-            let ty = n.get("styleType").and_then(Kv::str).unwrap_or("");
-            out.push(json!({"id": id, "name": name, "description": desc, "styleType": ty, "node": node}));
-        }
-        out
-    }
-
-    /// Collections and variables, as the local variables response's `meta`, with their ids in the
-    /// file's order (`collectionOrder` and `variableOrder`, our extensions).
-    fn variables(&self) -> Option<Value> {
-        let of_type = |t: &'static str, key: &'static str| {
-            let live = move |n: &Kv| n.get("type").and_then(Kv::str) == Some(t) && n.get("isSoftDeleted").and_then(Kv::bool) != Some(true);
-            let mut list: Vec<(&str, &String, &'a Kv<'a>)> = self
-                .nodes
-                .iter()
-                .filter(|(_, n)| live(n))
-                .map(|(id, n)| (n.get(key).and_then(|p| p.get("position").or(Some(p))).and_then(Kv::str).unwrap_or(""), id, *n))
-                .collect();
-            list.sort_by(|a, b| (a.0, a.1).cmp(&(b.0, b.1)));
-            list.into_iter().map(|(_, id, n)| (id, n))
-        };
-        let mut order = Vec::new();
-        let mut collections = Obj::new();
-        for (id, n) in of_type("VARIABLE_SET", "parentIndex") {
-            order.push(json!(id));
-            let mut modes: Vec<(&str, Value)> = n
-                .get("variableSetModes")
-                .map(Kv::list)
-                .unwrap_or_default()
-                .iter()
-                .filter_map(|m| {
-                    let mode = json!({"modeId": m.get("id").and_then(guid)?, "name": m.get("name").and_then(Kv::str).unwrap_or("Mode")});
-                    Some((m.get("sortPosition").and_then(Kv::str).unwrap_or(""), mode))
-                })
-                .collect();
-            modes.sort_by(|a, b| a.0.cmp(b.0));
-            let default = modes.first().map_or(Value::Null, |m| m.1["modeId"].clone());
-            let name = n.get("name").and_then(Kv::str).unwrap_or("Collection");
-            let modes: Vec<Value> = modes.into_iter().map(|m| m.1).collect();
-            collections.insert(id.clone(), json!({"id": id, "name": name, "modes": modes, "defaultModeId": default}));
-        }
-        let mut variable_order = Vec::new();
-        let mut variables = Obj::new();
-        for (id, n) in of_type("VARIABLE", "sortPosition") {
-            let Some(set) = n.get("variableSetID").and_then(|s| self.resource_id(s)).filter(|s| collections.contains_key(s)) else { continue };
-            let ty = n.get("variableResolvedType").and_then(Kv::str).unwrap_or("");
-            if !matches!(ty, "BOOLEAN" | "FLOAT" | "STRING" | "COLOR") {
-                continue;
-            }
-            let mut values = Obj::new();
-            for e in n.get("variableDataValues").and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default() {
-                if let (Some(mode), Some(val)) = (e.get("modeID").and_then(guid), e.get("variableData").and_then(variable_value)) {
-                    values.insert(mode, val);
-                }
-            }
-            let name = n.get("name").and_then(Kv::str).unwrap_or("Variable");
-            let desc = n.get("description").and_then(Kv::str).unwrap_or("");
-            let mut var =
-                json!({"id": id, "name": name, "variableCollectionId": set, "resolvedType": ty, "valuesByMode": values, "description": desc});
-            // The properties pickers offer the variable for, under the REST names.
-            if let Some(scopes) = n.get("variableScopes") {
-                var["scopes"] = scopes.list().iter().filter_map(Kv::str).map(|s| if s == "STROKE" { "STROKE_COLOR" } else { s }).collect();
-            }
-            variable_order.push(json!(id));
-            variables.insert(id.clone(), var);
-        }
-        (!collections.is_empty())
-            .then(|| json!({"variableCollections": collections, "variables": variables, "collectionOrder": order, "variableOrder": variable_order}))
-    }
-}
-
-/// The REST `boundVariables` key of a bound layer field.
-fn binding_key(field: &str) -> Option<&'static str> {
-    Some(match field {
-        "STROKE_WEIGHT" => "strokeWeight",
-        "STACK_SPACING" => "itemSpacing",
-        "STACK_COUNTER_SPACING" => "counterAxisSpacing",
-        "STACK_PADDING_LEFT" => "paddingLeft",
-        "STACK_PADDING_TOP" => "paddingTop",
-        "STACK_PADDING_RIGHT" => "paddingRight",
-        "STACK_PADDING_BOTTOM" => "paddingBottom",
-        "VISIBLE" => "visible",
-        "TEXT_DATA" => "characters",
-        "OPACITY" => "opacity",
-        "MIN_WIDTH" => "minWidth",
-        "MAX_WIDTH" => "maxWidth",
-        "MIN_HEIGHT" => "minHeight",
-        "MAX_HEIGHT" => "maxHeight",
-        "RECTANGLE_TOP_LEFT_CORNER_RADIUS" => "topLeftRadius",
-        "RECTANGLE_TOP_RIGHT_CORNER_RADIUS" => "topRightRadius",
-        "RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS" => "bottomLeftRadius",
-        "RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS" => "bottomRightRadius",
-        _ => return None,
-    })
-}
-
-/// The REST text style `boundVariables` key of a bound text field.
-fn text_binding_key(field: &str) -> Option<&'static str> {
-    Some(match field {
-        "FONT_SIZE" => "fontSize",
-        "FONT_FAMILY" => "fontFamily",
-        "FONT_STYLE" => "fontStyle",
-        "LETTER_SPACING" => "letterSpacing",
-        "LINE_HEIGHT" => "lineHeight",
-        "PARAGRAPH_SPACING" => "paragraphSpacing",
-        "PARAGRAPH_INDENT" => "paragraphIndent",
-        _ => return None,
-    })
-}
-
-fn stroke(o: &mut Obj, v: &View) {
-    copy_num(o, v, "strokeWeight", "strokeWeight");
-    if let Some(a) = v.str("strokeAlign").filter(|a| *a != "OFFSET") {
-        o.insert("strokeAlign".into(), json!(a));
-    }
-    copy_str(o, v, "strokeJoin", "strokeJoin");
-    if let Some(cap) = v.str("strokeCap") {
-        o.insert("strokeCap".into(), json!(cap_name(cap)));
-    }
-    // A layer written as the outline of its stroke keeps what it was as plugin data
-    // (`outlinedStroke`, our extension of the file JSON).
-    let (id, key) = super::export::STASH;
-    let kept = v.list("pluginData").iter().find(|p| p.get("pluginID").and_then(Kv::str) == Some(id) && p.get("key").and_then(Kv::str) == Some(key));
-    if let Some(original) = kept.and_then(|p| p.get("value")).and_then(Kv::str).and_then(|s| serde_json::from_str::<Value>(s).ok()) {
-        o.insert("outlinedStroke".into(), original);
-    }
-    // A variable width: each point's reach on the two sides of the path (shares of the stroke
-    // weight), as `[t, scale, bias]` (`strokeWidthProfile`, our extension of the file JSON).
-    let profile: Vec<Value> = v
-        .list("variableWidthPoints")
-        .iter()
-        .filter_map(|p| {
-            let (left, right) = (num(p, "ascent")?.max(0.0), num(p, "descent")?.max(0.0));
-            let bias = if left + right > 0.0 { (right - left) / (left + right) } else { 0.0 };
-            Some(json!([num(p, "position")?, left + right, bias]))
-        })
-        .collect();
-    if !profile.is_empty() {
-        o.insert("strokeWidthProfile".into(), Value::Array(profile));
-    }
-    let dashes: Vec<f64> = v.list("dashPattern").iter().filter_map(Kv::f64).collect();
-    if !dashes.is_empty() {
-        o.insert("strokeDashes".into(), json!(dashes));
-    }
-    // A miter limit L bevels joins sharper than 2·asin(1/L).
-    if let Some(l) = v.num("miterLimit").filter(|l| *l > 1.0) {
-        o.insert("strokeMiterAngle".into(), json!((2.0 * (1.0 / l).asin()).to_degrees()));
-    }
-    if v.flag("borderStrokeWeightsIndependent") == Some(true) {
-        // A side that isn't written has no border.
-        let side = |k: &str| v.num(k).unwrap_or(0.0);
-        o.insert(
-            "individualStrokeWeights".into(),
-            json!({"top": side("borderTopWeight"), "right": side("borderRightWeight"), "bottom": side("borderBottomWeight"), "left": side("borderLeftWeight")}),
-        );
-    }
-}
-
-/// A `VariableData` (literal, variable reference or expression) in the REST shape; `None` for
-/// kinds a prototype can't evaluate.
-fn variable_data(d: &Kv, depth: usize) -> Option<Value> {
-    let v = d.get("value")?;
-    let ty = d.get("dataType").and_then(Kv::str)?;
-    let value = match ty {
-        "ALIAS" => json!({"type": "VARIABLE_ALIAS", "id": v.get("alias").and_then(ref_guid)?}),
-        "EXPRESSION" if depth < MAX_EXPR_DEPTH => {
-            let e = v.get("expressionValue")?;
-            let function = match e.get("expressionFunction").and_then(Kv::str)? {
-                "MULTIPLY" => "MULTIPLICATION",
-                "DIVIDE" => "DIVISION",
-                f => f,
-            };
-            let args = e.get("expressionArguments").map(Kv::list).unwrap_or_default();
-            let args = args.iter().map(|x| variable_data(x, depth + 1)).collect::<Option<Vec<Value>>>()?;
-            json!({"expressionFunction": function, "expressionArguments": args})
-        }
-        "BOOLEAN" => json!(v.get("boolValue").and_then(Kv::bool)?),
-        "FLOAT" => json!(num(v, "floatValue").filter(|x| x.is_finite())?),
-        "STRING" => json!(v.get("textValue").and_then(Kv::str)?),
-        "COLOR" => color(v.get("colorValue")?),
-        _ => return None,
-    };
-    let mut out = json!({"type": ty, "value": value});
-    if let Some(r) = d.get("resolvedDataType").and_then(Kv::str) {
-        out["resolvedType"] = json!(r);
-    }
-    Some(out)
-}
-
-/// The text a layer that isn't a text layer carries (a note's, a shape's), unless blank.
-fn own_text<'a>(v: &View<'a>) -> Option<&'a str> {
-    v.get("textData").and_then(|t| t.get("characters")).and_then(Kv::str).filter(|c| !c.trim().is_empty())
-}
-
-/// A generated connector child is identified by one exact template GUID, not its array position.
-fn connector_record<'a>(v: &View<'a>, field: &str, local_id: u32) -> Option<&'a Kv<'a>> {
-    v.get(field)?.get("overrides")?.list().iter().find(|row| {
-        row.get("guidPath").and_then(|path| path.get("guids")).map(Kv::list).is_some_and(|guids| {
-            guids.len() == 1 && num(&guids[0], "sessionID") == Some(40_000_000.0) && num(&guids[0], "localID") == Some(f64::from(local_id))
-        })
-    })
-}
-
-fn connector_has_saved_label(v: &View<'_>) -> bool {
-    own_text(v).is_some()
-        || connector_record(v, "nodeGenerationData", 1)
-            .and_then(|r| r.get("textData"))
-            .and_then(|d| d.get("characters"))
-            .and_then(Kv::str)
-            .is_some_and(|s| !s.trim().is_empty())
-}
-
-fn valid_size(value: Option<&Kv<'_>>) -> Option<(f64, f64)> {
-    let x = num(value?, "x")?;
-    let y = num(value?, "y")?;
-    (x.is_finite() && y.is_finite() && x >= 0.0 && y >= 0.0).then_some((x, y))
-}
-
-/// The REST name of a stroke cap.
-fn cap_name(cap: &str) -> &str {
-    match cap {
-        "ARROW_LINES" => "LINE_ARROW",
-        "ARROW_EQUILATERAL" => "TRIANGLE_ARROW",
-        c => c,
-    }
-}
-
-/// The layer kind (and how the warning names it) that a layer the editor has no counterpart for
-/// imports as: frames for notes, shapes, tables, slides and the like (their text as a text layer),
-/// vectors for connectors and marker strokes, plain text for text on a path.
-fn stand_in(ty: &str) -> Option<(&'static str, &'static str)> {
-    Some(match ty {
-        "STICKY"
-        | "SHAPE_WITH_TEXT"
-        | "CODE_BLOCK"
-        | "TABLE"
-        | "TABLE_CELL"
-        | "STAMP"
-        | "MEDIA"
-        | "WIDGET"
-        | "SLIDE"
-        | "SLIDE_GRID"
-        | "SLIDE_ROW"
-        | "INTERACTIVE_SLIDE_ELEMENT"
-        | "MODULE" => ("FRAME", "frames with their text"),
-        "CONNECTOR" | "HIGHLIGHT" | "WASHI_TAPE" => ("VECTOR", "vectors"),
-        "TEXT_PATH" => ("TEXT", "text off its path"),
-        _ => return None,
-    })
-}
-
-/// How a layer sizes and sits in an auto layout parent.
-fn child_layout(o: &mut Obj, v: &View, parent: Option<&View>) {
-    copy_num(o, v, "stackChildPrimaryGrow", "layoutGrow");
-    if v.str("stackChildAlignSelf") == Some("STRETCH") {
-        o.insert("layoutAlign".into(), json!("STRETCH"));
-    }
-    if v.str("stackPositioning") == Some("ABSOLUTE") {
-        o.insert("layoutPositioning".into(), json!("ABSOLUTE"));
-    }
-    for (k, w, h) in [("minSize", "minWidth", "minHeight"), ("maxSize", "maxWidth", "maxHeight")] {
-        if let Some(val) = v.get(k).and_then(|s| s.get("value")) {
-            for (axis, to) in [("x", w), ("y", h)] {
-                if let Some(x) = num(val, axis).filter(|x| *x > 0.0 && *x < 1e9) {
-                    o.insert(to.into(), json!(x));
-                }
-            }
-        }
-    }
-    if let Some(p) = parent.filter(|p| p.str("stackMode") == Some("GRID")) {
-        for (anchor, list, to) in [("gridColumnAnchor", "gridColumns", "gridColumnAnchorIndex"), ("gridRowAnchor", "gridRows", "gridRowAnchorIndex")]
-        {
-            if let Some(i) = v.get(anchor).and_then(guid).and_then(|g| tracks(p, list).iter().position(|t| *t == g)) {
-                o.insert(to.into(), json!(i));
-            }
-        }
-        copy_num(o, v, "gridColumnSpan", "gridColumnSpan");
-        copy_num(o, v, "gridRowSpan", "gridRowSpan");
-    }
-}
-
-/// Whether a paint's colour or one of its gradient stops is bound to a variable.
-fn paint_bound(p: &Kv) -> bool {
-    alias(p.get("colorVar")).is_some() || p.get("stopsVar").map(Kv::list).unwrap_or_default().iter().any(|s| alias(s.get("colorVar")).is_some())
-}
-
-fn paint(p: &Kv, warn: &mut dyn FnMut(String)) -> Option<Value> {
-    let ty = p.get("type").and_then(Kv::str)?;
-    let mut o = Obj::new();
-    o.insert("type".into(), json!(ty));
-    if let Some(x) = num(p, "opacity") {
-        o.insert("opacity".into(), json!(x));
-    }
-    if let Some(b) = p.get("visible").and_then(Kv::bool) {
-        o.insert("visible".into(), json!(b));
-    }
-    if let Some(b) = p.get("blendMode").and_then(Kv::str) {
-        o.insert("blendMode".into(), json!(b));
-    }
-    let t = p.get("transform").and_then(matrix);
-    match ty {
-        "SOLID" => {
-            if let Some(c) = p.get("color") {
-                o.insert("color".into(), color(c));
-            }
-            if let Some(var) = alias(p.get("colorVar")) {
-                o.insert("boundVariables".into(), json!({"color": {"type": "VARIABLE_ALIAS", "id": var}}));
-            }
-        }
-        _ if ty.starts_with("GRADIENT_") => {
-            // The paint transform maps the layer's unit box to gradient space, where a linear
-            // gradient runs from (0, ½) to (1, ½) and the others are centred on (½, ½).
-            let inv = t.filter(|t| t.determinant().abs() > 1e-12).map_or(Affine::IDENTITY, Affine::inverse);
-            let pts = if ty == "GRADIENT_LINEAR" { [(0.0, 0.5), (1.0, 0.5), (0.0, 1.0)] } else { [(0.5, 0.5), (1.0, 0.5), (0.5, 1.0)] };
-            let handles: Vec<Value> = pts
-                .iter()
-                .map(|(x, y)| {
-                    let q = inv * Point::new(*x, *y);
-                    json!({"x": q.x, "y": q.y})
-                })
-                .collect();
-            o.insert("gradientHandlePositions".into(), Value::Array(handles));
-            // Stops bound to variables are listed again, each with its variable.
-            let vars = p.get("stopsVar").map(Kv::list).unwrap_or_default();
-            let stops: Vec<Value> = p
-                .get("stops")
-                .map(Kv::list)
-                .unwrap_or_default()
-                .iter()
-                .enumerate()
-                .map(|(i, s)| {
-                    let mut stop = json!({"position": num(s, "position").unwrap_or(0.0), "color": s.get("color").map_or(Value::Null, color)});
-                    if let Some(b) = bound(vars.get(i), &[("colorVar", "color")]) {
-                        stop["boundVariables"] = b;
-                    }
-                    stop
-                })
-                .collect();
-            o.insert("gradientStops".into(), Value::Array(stops));
-        }
-        "IMAGE" => {
-            let hash: String =
-                p.get("image").and_then(|i| i.get("hash")).and_then(Kv::bytes).unwrap_or_default().iter().map(|b| format!("{b:02x}")).collect();
-            o.insert("imageRef".into(), json!(hash));
-            let mode = p.get("imageScaleMode").and_then(Kv::str).unwrap_or("FILL");
-            o.insert("scaleMode".into(), json!(mode));
-            if let (Some(t), "STRETCH") = (t, mode) {
-                o.insert("imageTransform".into(), rows(t));
-            }
-            if let Some(s) = num(p, "scale") {
-                o.insert("scalingFactor".into(), json!(s));
-            }
-            if let Some(r) = num(p, "rotation") {
-                o.insert("rotation".into(), json!(r));
-            }
-            match (p.get("filterColorAdjust"), p.get("paintFilter")) {
-                (Some(_), Some(_)) => {
-                    warn("image filters are ambiguous because both filter containers are present; filter conversion was skipped".into())
-                }
-                (Some(_), None) => warn("legacy image filter container is unsupported; filter conversion was skipped".into()),
-                (None, Some(filters)) => {
-                    let mut mapped = Obj::new();
-                    let fields = [
-                        ("exposure", "exposure"),
-                        ("contrast", "contrast"),
-                        ("vibrance", "saturation"),
-                        ("temperature", "temperature"),
-                        ("tint", "tint"),
-                        ("highlights", "highlights"),
-                        ("shadows", "shadows"),
-                    ];
-                    if let Kv::Object(values) = filters {
-                        for (source, target) in fields {
-                            if let Some(value) = filters.get(source) {
-                                match filter_number(value) {
-                                    Some(value) => {
-                                        mapped.insert(target.into(), json!(value));
-                                    }
-                                    None => warn(format!("malformed image filter `{source}` was skipped")),
-                                }
-                            }
-                        }
-                        for (name, value) in values {
-                            if fields.iter().any(|(known, _)| *known == *name) {
-                                continue;
-                            }
-                            match filter_number(value) {
-                                Some(0.0) => {}
-                                Some(_) => warn(format!("nonzero unsupported image filter `{}` was skipped", crate::rest::props::clip_str(name))),
-                                None => warn(format!("malformed unsupported image filter `{}` was skipped", crate::rest::props::clip_str(name))),
-                            }
-                        }
-                    } else {
-                        warn("malformed image paintFilter container was skipped".into());
-                    }
-                    if !mapped.is_empty() {
-                        o.insert("filters".into(), Value::Object(mapped));
-                    }
-                }
-                (None, None) => {}
-            }
-        }
-        _ => {}
-    }
-    Some(Value::Object(o))
-}
-
-/// The variables bound to the fields of a paint stop, an effect or a layout grid, as its REST
-/// `boundVariables`: `fields` pairs the format's field with the REST name.
-fn bound(v: Option<&Kv>, fields: &[(&str, &str)]) -> Option<Value> {
-    let v = v?;
-    let found: Obj =
-        fields.iter().filter_map(|(from, to)| Some((to.to_string(), json!({"type": "VARIABLE_ALIAS", "id": alias(v.get(from))?})))).collect();
-    (!found.is_empty()).then_some(Value::Object(found))
-}
-
-/// The track ids of a grid's columns or rows, in order.
-fn tracks(v: &View, key: &str) -> Vec<String> {
-    let mut t: Vec<(&str, String)> = v
-        .get(key)
-        .and_then(|m| m.get("entries"))
-        .map(Kv::list)
-        .unwrap_or_default()
-        .iter()
-        .filter_map(|e| Some((e.get("position").and_then(Kv::str).unwrap_or(""), e.get("id").and_then(guid)?)))
-        .collect();
-    t.sort();
-    t.into_iter().map(|e| e.1).collect()
-}
-
-/// Convert only unconstrained tracks, whose min and max sizing functions agree.
-fn grid_track_sizing(size: Option<&Kv<'_>>) -> Option<Value> {
-    let size = size?;
-    let min = size.get("minSizing")?;
-    let max = size.get("maxSizing")?;
-    let min_type = min.get("type").and_then(Kv::str)?;
-    let max_type = max.get("type").and_then(Kv::str)?;
-    if min_type != max_type {
-        return None;
-    }
-    match min_type {
-        "FIXED" => {
-            let px = num(min, "value")?;
-            let max_px = num(max, "value")?;
-            (px == max_px && px.is_finite() && (0.0..=MAX_GRID_TRACK_VALUE).contains(&px)).then(|| json!({"sizing": "fixed", "value": px}))
-        }
-        "FLEX" => {
-            let fr = num(min, "value")?;
-            let max_fr = num(max, "value")?;
-            (fr == max_fr && fr.is_finite() && fr > 0.0 && fr <= MAX_GRID_TRACK_VALUE).then(|| json!({"sizing": "fill", "value": fr}))
-        }
-        "HUG" => Some(json!({"sizing": "hug", "value": 0.0})),
-        _ => None,
-    }
-}
-
-/// The variable an `ALIAS` variable data points at.
-fn alias(d: Option<&Kv>) -> Option<String> {
-    let d = d?;
-    if d.get("dataType").and_then(Kv::str) != Some("ALIAS") {
-        return None;
-    }
-    d.get("value").and_then(|v| v.get("alias")).and_then(ref_guid)
-}
-
-fn variable_value(d: &Kv) -> Option<Value> {
-    if let Some(a) = alias(Some(d)) {
-        return Some(json!({"type": "VARIABLE_ALIAS", "id": a}));
-    }
-    let v = d.get("value")?;
-    if let Some(c) = v.get("colorValue") {
-        return Some(color(c));
-    }
-    if let Some(b) = v.get("boolValue").and_then(Kv::bool) {
-        return Some(json!(b));
-    }
-    if let Some(x) = num(v, "floatValue") {
-        return Some(json!(x));
-    }
-    v.get("textValue").and_then(Kv::str).map(|s| json!(s))
-}
-
-/// Per-character styles of text data `td` (`characterStyleIDs` + `styleOverrideTable`) as REST
-/// `characterStyleOverrides` + `styleOverrideTable`; `size`: the base font size.
-fn char_styles(o: &mut Obj, td: &Kv, size: Option<f64>, warn: &mut dyn FnMut(String)) {
-    let ids: Vec<u64> = td.get("characterStyleIDs").map(Kv::list).unwrap_or_default().iter().filter_map(Kv::f64).map(|i| i as u64).collect();
-    if ids.iter().all(|i| *i == 0) {
-        return;
-    }
-    let mut table = Obj::new();
-    for e in td.get("styleOverrideTable").map(Kv::list).unwrap_or_default() {
-        let Some(sid) = num(e, "styleID") else { continue };
-        let mut s = text_style(&View::of(e), size);
-        if let Some(fills) = e.get("fillPaints") {
-            s.insert("fills".into(), Value::Array(fills.list().iter().filter_map(|p| paint(p, warn)).collect()));
-        }
-        table.insert((sid as u64).to_string(), Value::Object(s));
-    }
-    o.insert("characterStyleOverrides".into(), json!(ids));
-    o.insert("styleOverrideTable".into(), Value::Object(table));
-}
-
-/// The text of a component property value.
-fn prop_text<'k>(v: &'k Kv) -> Option<&'k str> {
-    prop_text_data(v).and_then(|t| t.get("characters")).and_then(Kv::str)
-}
-
-/// The text data of a component property value: `textValue`, or `textDataValue` in the variable form.
-fn prop_text_data<'k, 's>(v: &'k Kv<'s>) -> Option<&'k Kv<'s>> {
-    v.get("textValue").or_else(|| v.get("textDataValue"))
-}
-
-/// The main an instance swap value names: `guidValue`, or `symbolIdValue` in the variable form.
-fn prop_guid(v: &Kv) -> Option<String> {
-    v.get("guidValue").and_then(guid).or_else(|| v.get("symbolIdValue")?.get("guid").and_then(guid))
-}
-
-/// The value a component property assignment sets: `value`, or the variable form `varValue` holds
-/// when `value` is empty, as current files write many booleans and instance swaps.
-fn assigned<'k, 's>(assignment: &'k Kv<'s>) -> Option<&'k Kv<'s>> {
-    assignment.get("value").filter(|v| !matches!(v, Kv::Object(fields) if fields.is_empty())).or_else(|| assignment.get("varValue")?.get("value"))
-}
-
-/// The property a layer's `field` is bound to (`parameterConsumptionMap`).
-fn prop_ref(v: &View, field: &str) -> Option<String> {
-    v.get("parameterConsumptionMap")?.get("entries")?.list().iter().find_map(|e| {
-        if e.get("variableField").and_then(Kv::str) != Some(field) {
-            return None;
-        }
-        e.get("variableData")?.get("value")?.get("propRefValue")?.get("defId").and_then(guid)
-    })
-}
-
-/// The REST TypeStyle fields a node (or text override entry) sets. `size`: the font size that
-/// letter spacing in percent refers to when the entry doesn't set one.
-fn text_style(v: &View, size: Option<f64>) -> Obj {
-    let mut s = Obj::new();
-    if let Some(f) = v.get("fontName") {
-        for (from, to) in [("family", "fontFamily"), ("style", "fontStyle"), ("postscript", "fontPostScriptName")] {
-            if let Some(x) = f.get(from).and_then(Kv::str).filter(|x| !x.is_empty()) {
-                // Compact and spaced style names ("SemiBold", "Semi Bold") are the same style.
-                s.insert(to.into(), if from == "style" { json!(super::style_name(x)) } else { json!(x) });
-            }
-        }
-    }
-    copy_num(&mut s, v, "fontSize", "fontSize");
-    copy_num(&mut s, v, "paragraphSpacing", "paragraphSpacing");
-    copy_num(&mut s, v, "paragraphIndent", "paragraphIndent");
-    insert_text_options(&mut s, v);
-    copy_str(&mut s, v, "textCase", "textCase");
-    copy_str(&mut s, v, "textDecoration", "textDecoration");
-    if let Some(skip_ink) = v.flag("textDecorationSkipInk") {
-        s.insert("textDecorationSkipInk".into(), json!(skip_ink));
-    }
-    copy_str(&mut s, v, "leadingTrim", "leadingTrim");
-    let font_size = v.num("fontSize").or(size).unwrap_or(12.0);
-    if let Some(ls) = v.get("letterSpacing") {
-        let val = num(ls, "value").unwrap_or(0.0);
-        let px = match ls.get("units").and_then(Kv::str) {
-            Some("PIXELS") => val,
-            Some("PERCENT") => {
-                // Private (read by `rest/text.rs`): REST spacing is in pixels; keep the percent.
-                s.insert("_letterSpacingPercent".into(), json!(val));
-                val / 100.0 * font_size
-            }
-            _ => val * font_size,
-        };
-        s.insert("letterSpacing".into(), json!(px));
-    }
-    if let Some(lh) = v.get("lineHeight") {
-        let val = num(lh, "value").unwrap_or(100.0);
-        match lh.get("units").and_then(Kv::str) {
-            Some("PIXELS") => {
-                s.insert("lineHeightUnit".into(), json!("PIXELS"));
-                s.insert("lineHeightPx".into(), json!(val));
-            }
-            // shortcut: percent units count from the font's own line height (100 % is "auto"), which
-            // the document can only say for 100 %; other values read as % of the font size. Upgrade
-            // when line heights can be a share of the font's own.
-            Some("PERCENT") if (val - 100.0).abs() < 1e-6 => {
-                s.insert("lineHeightUnit".into(), json!("INTRINSIC_%"));
-            }
-            Some("PERCENT") => {
-                s.insert("lineHeightUnit".into(), json!("FONT_SIZE_%"));
-                s.insert("lineHeightPercentFontSize".into(), json!(val));
-            }
-            _ => {
-                s.insert("lineHeightUnit".into(), json!("FONT_SIZE_%"));
-                s.insert("lineHeightPercentFontSize".into(), json!(val * 100.0));
-            }
-        }
-    }
-    // An empty URL is kept: on an override entry it clears the text's own link.
-    if let Some(u) = v.get("hyperlink").and_then(|h| h.get("url")).and_then(Kv::str) {
-        s.insert("hyperlink".into(), json!({"type": "URL", "url": u}));
-    }
-    s
-}
-
-fn effect(e: &Kv) -> Option<Value> {
-    let ty = match e.get("type").and_then(Kv::str)? {
-        "FOREGROUND_BLUR" => "LAYER_BLUR",
-        "GRAIN" => "TEXTURE",
-        t => t,
-    };
-    let mut o = Obj::new();
-    o.insert("type".into(), json!(ty));
-    for k in ["radius", "spread", "startRadius", "density", "opacity"] {
-        if let Some(x) = num(e, k) {
-            o.insert(k.into(), json!(x));
-        }
-    }
-    for k in ["visible", "showShadowBehindNode", "clipToShape"] {
-        if let Some(b) = e.get(k).and_then(Kv::bool) {
-            o.insert(k.into(), json!(b));
-        }
-    }
-    for k in ["blendMode", "noiseType"] {
-        if let Some(s) = e.get(k).and_then(Kv::str) {
-            o.insert(k.into(), json!(s));
-        }
-    }
-    for k in ["color", "secondaryColor"] {
-        if let Some(c) = e.get(k) {
-            o.insert(k.into(), color(c));
-        }
-    }
-    for (from, to) in [("offset", "offset"), ("startOffset", "startOffset"), ("endOffset", "endOffset"), ("noiseSize", "noiseSizeVector")] {
-        if let Some(p) = e.get(from).and_then(vec2) {
-            o.insert(to.into(), p);
-        }
-    }
-    if e.get("blurOpType").and_then(Kv::str) == Some("PROGRESSIVE") {
-        o.insert("blurType".into(), json!("PROGRESSIVE"));
-    }
-    let vars = [
-        ("colorVar", "color"),
-        ("radiusVar", "radius"),
-        ("spreadVar", "spread"),
-        ("xVar", "offsetX"),
-        ("yVar", "offsetY"),
-        ("startRadiusVar", "startRadius"),
-    ];
-    if let Some(b) = bound(Some(e), &vars) {
-        o.insert("boundVariables".into(), b);
-    }
-    Some(Value::Object(o))
-}
-
-fn layout_grid(g: &Kv) -> Value {
-    let pattern = match (g.get("pattern").and_then(Kv::str), g.get("axis").and_then(Kv::str)) {
-        (Some("GRID"), _) => "GRID",
-        (_, Some("Y")) => "ROWS",
-        _ => "COLUMNS",
-    };
-    let mut o = json!({"pattern": pattern, "alignment": g.get("type").and_then(Kv::str).unwrap_or("STRETCH")});
-    for (from, to) in [("sectionSize", "sectionSize"), ("numSections", "count"), ("gutterSize", "gutterSize"), ("offset", "offset")] {
-        if let Some(x) = num(g, from) {
-            o[to] = json!(x);
-        }
-    }
-    if let Some(c) = g.get("color") {
-        o["color"] = color(c);
-    }
-    if let Some(b) = g.get("visible").and_then(Kv::bool) {
-        o["visible"] = json!(b);
-    }
-    let vars = [("numSectionsVar", "count"), ("offsetVar", "offset"), ("sectionSizeVar", "sectionSize"), ("gutterSizeVar", "gutterSize")];
-    if let Some(b) = bound(Some(g), &vars) {
-        o["boundVariables"] = b;
-    }
-    o
-}
-
-fn export_setting(e: &Kv) -> Value {
-    let c = e.get("constraint");
-    let ty = match c.and_then(|c| c.get("type")).and_then(Kv::str) {
-        Some("CONTENT_WIDTH") => "WIDTH",
-        Some("CONTENT_HEIGHT") => "HEIGHT",
-        _ => "SCALE",
-    };
-    json!({
-        "format": e.get("imageType").and_then(Kv::str).unwrap_or("PNG"),
-        "suffix": e.get("suffix").and_then(Kv::str).unwrap_or(""),
-        "constraint": {"type": ty, "value": c.and_then(|c| num(c, "value")).unwrap_or(1.0)},
-    })
-}
-
-/// A prototype action's transition (`None`: instant).
-fn transition(a: &Kv) -> Option<Value> {
-    let ty = a.get("transitionType").and_then(Kv::str)?;
-    // Directions name where the incoming screen moves (SLIDE_FROM_LEFT moves right).
-    let (kind, dir) = match ty {
-        "INSTANT_TRANSITION" => return None,
-        "DISSOLVE" | "FADE" => ("DISSOLVE", None),
-        "SMART_ANIMATE" | "MAGIC_MOVE" => ("SMART_ANIMATE", None),
-        "SCROLL_ANIMATE" => ("SCROLL_ANIMATE", None),
-        t => {
-            let prefixes = [
-                ("SLIDE_FROM_", "SLIDE_IN"),
-                ("PUSH_FROM_", "PUSH"),
-                ("MOVE_FROM_", "MOVE_IN"),
-                ("SLIDE_OUT_TO_", "SLIDE_OUT"),
-                ("MOVE_OUT_TO_", "MOVE_OUT"),
-            ];
-            let (kind, side) = prefixes.iter().find_map(|(p, k)| t.strip_prefix(p).map(|r| (*k, r)))?;
-            let incoming = matches!(kind, "SLIDE_IN" | "PUSH" | "MOVE_IN");
-            let dir = match (side, incoming) {
-                ("LEFT", true) | ("RIGHT", false) => "RIGHT",
-                ("RIGHT", true) | ("LEFT", false) => "LEFT",
-                ("TOP", true) | ("BOTTOM", false) => "BOTTOM",
-                _ => "TOP",
-            };
-            (kind, Some(dir))
-        }
-    };
-    let easing = match a.get("easingType").and_then(Kv::str) {
-        Some("IN_CUBIC" | "EASE_IN") => "EASE_IN",
-        Some("INOUT_CUBIC") => "EASE_IN_AND_OUT",
-        Some("LINEAR") => "LINEAR",
-        Some("IN_BACK_CUBIC") => "EASE_IN_BACK",
-        Some("OUT_BACK_CUBIC") => "EASE_OUT_BACK",
-        Some("INOUT_BACK_CUBIC") => "EASE_IN_AND_OUT_BACK",
-        Some("GENTLE_SPRING") => "GENTLE",
-        Some("CUSTOM_CUBIC") => "CUSTOM_CUBIC_BEZIER",
-        _ => "EASE_OUT",
-    };
-    let mut e = json!({"type": easing});
-    let f: Vec<f64> = a.get("easingFunction").map(Kv::list).unwrap_or_default().iter().filter_map(Kv::f64).collect();
-    if let (true, [x1, y1, x2, y2, ..]) = (easing == "CUSTOM_CUBIC_BEZIER", f.as_slice()) {
-        e["easingFunctionCubicBezier"] = json!({"x1": x1, "y1": y1, "x2": x2, "y2": y2});
-    }
-    let mut t = json!({"type": kind, "duration": (num(a, "transitionDuration").unwrap_or(0.3) * 1000.0).round(), "easing": e});
-    if let Some(d) = dir {
-        t["direction"] = json!(d);
-    }
-    Some(t)
-}
-
-/// SVG path data of a geometry blob: commands `0` close, `1` move, `2` line, `3` quadratic and
-/// `4` cubic, each followed by its points as little-endian `f32` pairs. `None` when damaged.
-fn svg_path(b: &[u8]) -> Option<String> {
-    let mut out = String::new();
-    let mut i = 0usize;
-    let mut n = 0usize;
-    while i < b.len() {
-        n += 1;
-        if n > MAX_COMMANDS {
-            return None;
-        }
-        let (letter, points) = match *b.get(i)? {
-            0 => ('Z', 0),
-            1 => ('M', 1),
-            2 => ('L', 1),
-            3 => ('Q', 2),
-            4 => ('C', 3),
-            _ => return None,
-        };
-        i += 1;
-        if !out.is_empty() {
-            out.push(' ');
-        }
-        out.push(letter);
-        for _ in 0..points * 2 {
-            let bytes: [u8; 4] = b.get(i..i + 4)?.try_into().ok()?;
-            let x = f32::from_le_bytes(bytes);
-            if !x.is_finite() {
-                return None;
-            }
-            out.push_str(&format!(" {x}"));
-            i += 4;
-        }
-    }
-    Some(out)
 }
diff --git a/crates/format/src/fig/map/component.rs b/crates/format/src/fig/map/component.rs
new file mode 100644
index 00000000..abc2225e
--- /dev/null
+++ b/crates/format/src/fig/map/component.rs
@@ -0,0 +1,441 @@
+use super::layer::own_text;
+use super::text::char_styles;
+use super::*;
+
+/// An override row names a layer of the main by its current GUID or by the `overrideKey` the
+/// layer had when the row was written: the key becomes the current GUID, unless the layer is
+/// current already or the key is ambiguous.
+fn normalize_override_segment(path: &mut [String], index: usize, scope: &OverrideScope) {
+    let Some(segment) = path.get(index) else { return };
+    if scope.current.contains(segment) {
+        return;
+    }
+    if let Some(Some(current)) = scope.aliases.get(segment) {
+        path[index] = current.clone();
+    }
+}
+
+/// Overrides and derived layout by id path.
+type Overrides<'a> = BTreeMap<Vec<String>, Vec<OverrideRow<'a>>>;
+
+/// Where an override entry comes from.
+#[derive(Clone, Copy, PartialEq)]
+pub(super) enum Entry {
+    Override,
+    Derived,
+    /// Derived layout of a nested instance for a size it no longer has: its size and place no
+    /// longer hold, the rest (resolved colours, text) still does.
+    Stale,
+}
+
+/// One override or derived-layout row addressed to a layer.
+#[derive(Clone)]
+pub(super) struct OverrideRow<'a> {
+    pub(super) row: &'a Kv<'a>,
+    pub(super) entry: Entry,
+    /// How many mains are being expanded around the instance that wrote the row: the rows of
+    /// the enclosing (outer) instances win over those of the inner ones.
+    source_depth: usize,
+    /// Position among the rows of the instance that wrote it; later rows win.
+    ordinal: usize,
+}
+
+/// The layers of a main by current GUID, and the old `overrideKey` of each that has one
+/// (`None` when two layers claim the same key).
+pub(super) struct OverrideScope {
+    current: BTreeSet<String>,
+    aliases: BTreeMap<String, Option<String>>,
+}
+
+/// Where an instance's expanded layers are: the overrides and derived layout of the outermost
+/// instance (by id path), the path of the instance being expanded, and the property values.
+#[derive(Clone)]
+pub(super) struct Inst<'a> {
+    pub(super) root: String,
+    pub(super) path: Vec<String>,
+    pub(super) overrides: Rc<Overrides<'a>>,
+    props: Rc<BTreeMap<String, &'a Kv<'a>>>,
+    /// Slot property GUID → private slot-content node GUID.
+    pub(super) slot_contents: Rc<BTreeMap<String, String>>,
+    /// Layers imported from a slot's independent content subtree.
+    pub(super) slot_content: bool,
+    /// Mains being expanded (an instance inside its own main stops there).
+    symbols: Vec<String>,
+}
+
+impl<'a> Mapper<'a> {
+    /// The layers of main `main` by current GUID and by `overrideKey`. An instance nested in the
+    /// main is not entered: its layers belong to another main.
+    fn override_scope(&mut self, main: &str) -> Rc<OverrideScope> {
+        if let Some(scope) = self.override_scopes.get(main) {
+            return Rc::clone(scope);
+        }
+        let mut current = BTreeSet::new();
+        let mut aliases: BTreeMap<String, Option<String>> = BTreeMap::new();
+        let mut visited = BTreeSet::new();
+        let mut pending: Vec<(String, usize)> = self.children(main).into_iter().map(|id| (id, 1)).collect();
+        let mut complete = true;
+        while let Some((id, depth)) = pending.pop() {
+            if depth > MAX_DEPTH || visited.len() >= self.max_nodes {
+                complete = false;
+                break;
+            }
+            if !visited.insert(id.clone()) {
+                continue;
+            }
+            let Some(node) = self.nodes.get(&id) else { continue };
+            current.insert(id.clone());
+            if let Some(alias) = node.get("overrideKey").and_then(guid) {
+                let target = aliases.entry(alias).or_insert_with(|| Some(id.clone()));
+                if target.as_deref().is_some_and(|target| target != id) {
+                    *target = None;
+                }
+            }
+            if node.get("type").and_then(Kv::str) != Some("INSTANCE") {
+                pending.extend(self.children(&id).into_iter().map(|child| (child, depth + 1)));
+            }
+        }
+        // A scope cut short could name the wrong layer for a key: use none of the keys.
+        if !complete {
+            aliases.clear();
+        }
+        let scope = Rc::new(OverrideScope { current, aliases });
+        let cost = scope.current.len() + scope.aliases.len();
+        if cost <= self.max_nodes.saturating_sub(self.override_scope_entries) {
+            self.override_scope_entries += cost;
+            self.override_scopes.insert(main.to_string(), Rc::clone(&scope));
+        }
+        scope
+    }
+
+    pub(super) fn is_instance_swap(&self, def: &Kv) -> Option<()> {
+        matches!(self.prop_def(&guid(def)?), Some((_, "INSTANCE_SWAP"))).then_some(())
+    }
+
+    /// The definition a copy of it was made from, followed to the original: the values an instance
+    /// sets are kept under it, since an assignment and the layers that read it may name different
+    /// copies of one definition.
+    pub(super) fn prop_root(&self, def: &str) -> String {
+        let mut def = def;
+        for _ in 0..=MAX_DEPTH {
+            let Some(parent) = self.prop_parents.get(def) else { break };
+            def = parent;
+        }
+        def.to_string()
+    }
+
+    /// The definition `def` names: its own, or the set's for a variant's copy of it.
+    fn prop_def(&self, def: &str) -> Option<&(String, &'a str)> {
+        let mut def = def;
+        for _ in 0..=MAX_DEPTH {
+            if let Some(found) = self.prop_defs.get(def) {
+                return Some(found);
+            }
+            def = self.prop_parents.get(def)?;
+        }
+        None
+    }
+
+    /// Component property definitions and description.
+    pub(super) fn component(&mut self, o: &mut Obj, v: &View<'a>, id: &str) {
+        let mut defs = Obj::new();
+        for d in v.list("componentPropDefs") {
+            if d.get("isDeleted").and_then(Kv::bool) == Some(true) {
+                continue;
+            }
+            let Some((name, ty)) = d.get("id").and_then(guid).and_then(|i| self.prop_defs.get(&i).cloned()) else { continue };
+            let init = d.get("initialValue");
+            let def = match ty {
+                "BOOL" => json!({"type": "BOOLEAN", "defaultValue": init.and_then(|i| i.get("boolValue")).and_then(Kv::bool).unwrap_or(true)}),
+                "TEXT" => json!({"type": "TEXT", "defaultValue": init.and_then(prop_text).unwrap_or("")}),
+                "INSTANCE_SWAP" => match init.and_then(|i| i.get("guidValue")).and_then(guid) {
+                    Some(g) => {
+                        if self.nodes.contains_key(&g) {
+                            self.referenced_mains.insert(g.clone());
+                        }
+                        json!({"type": "INSTANCE_SWAP", "defaultValue": g})
+                    }
+                    None => continue,
+                },
+                "VARIANT" => json!({"type": "VARIANT"}),
+                "SLOT" => {
+                    self.warn_non_default_slot_config(d);
+                    self.warn_dropped_slot_preferred_values(d);
+                    json!({"type": "SLOT"})
+                }
+                _ => {
+                    self.warn(format!("{} component properties are not supported and were skipped", ty.to_ascii_lowercase()));
+                    continue;
+                }
+            };
+            defs.insert(name, def);
+        }
+        if !defs.is_empty() {
+            o.insert("componentPropertyDefinitions".into(), Value::Object(defs));
+        }
+        if let Some(d) = v.str("symbolDescription").or_else(|| v.str("description")).filter(|d| !d.is_empty()) {
+            let into = if o.get("type").and_then(Value::as_str) == Some("COMPONENT_SET") { &mut self.sets } else { &mut self.components };
+            into.insert(id.to_string(), json!({"description": d}));
+        }
+    }
+
+    /// Preferred slot values are source component keys, but this mapper has no proven way to map
+    /// those keys to file GUIDs. They are dropped instead of guessing native NodeIds.
+    fn warn_dropped_slot_preferred_values(&mut self, def: &Kv<'a>) {
+        let entries = def.get("preferredValues").and_then(|v| v.get("instanceSwapValues")).map(Kv::list).unwrap_or_default();
+        if !entries.is_empty() {
+            self.warn("preferred slot component keys cannot be resolved to file nodes and were skipped");
+        }
+    }
+
+    fn warn_non_default_slot_config(&mut self, def: &Kv<'a>) {
+        let Some(config) = def.get("slotPropConfig") else { return };
+        let non_default = [
+            ("stretchChildOnInsert", Some(false)),
+            ("displayByDefault", Some(false)),
+            ("minChildren", None),
+            ("maxChildren", None),
+            ("allowPreferredValuesOnly", Some(false)),
+        ]
+        .into_iter()
+        .any(|(field, bool_default)| {
+            let Some(value) = config.get(field) else { return false };
+            if let Some(default) = bool_default { value.bool() != Some(default) } else { value.f64() != Some(0.0) }
+        });
+        if non_default {
+            self.warn("non-default slot settings are not represented and were skipped");
+        }
+    }
+
+    /// A layer's component property references, and inside an instance the values they take.
+    pub(super) fn prop_refs(&mut self, o: &mut Obj, v: &View<'a>, inst: Option<&Inst<'a>>) {
+        let mut refs = Obj::new();
+        for e in v.get("parameterConsumptionMap").and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default() {
+            let field = match e.get("variableField").and_then(Kv::str) {
+                Some("VISIBLE") => "visible",
+                Some("TEXT_DATA") => "characters",
+                Some("OVERRIDDEN_SYMBOL_ID") => "mainComponent",
+                Some("SLOT_CONTENT_ID") => "slot",
+                _ => continue,
+            };
+            let Some(def) =
+                e.get("variableData").and_then(|d| d.get("value")).and_then(|x| x.get("propRefValue")).and_then(|p| p.get("defId")).and_then(guid)
+            else {
+                continue;
+            };
+            // Expanded frames must follow their main frame's source link. A direct slot reference
+            // makes the engine resolve ownership against the instance, where the property is not defined.
+            if !(field == "slot" && inst.is_some())
+                && let Some((name, _)) = self.prop_def(&def)
+            {
+                refs.insert(field.into(), json!(name));
+            }
+            let Some(val) = inst.and_then(|i| i.props.get(&self.prop_root(&def))) else { continue };
+            match field {
+                "visible" => {
+                    if let Some(b) = val.get("boolValue").and_then(Kv::bool) {
+                        o.insert("visible".into(), json!(b));
+                    }
+                }
+                "characters" => {
+                    if let Some(t) = prop_text(val) {
+                        o.insert("characters".into(), json!(t));
+                        // Run styles count the chars they were made for: for other chars only
+                        // the value's own apply.
+                        if own_text(v) != Some(t) {
+                            o.remove("characterStyleOverrides");
+                            o.remove("styleOverrideTable");
+                            if let Some(tv) = prop_text_data(val) {
+                                let size = o.get("style").and_then(|s| s.get("fontSize")).and_then(Value::as_f64);
+                                char_styles(o, tv, size, &mut |w| self.warn(w));
+                            }
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+        if !refs.is_empty() {
+            o.insert("componentPropertyReferences".into(), Value::Object(refs));
+        }
+    }
+
+    /// An instance's main and properties; the context its expanded layers are built in.
+    pub(super) fn instance(&mut self, o: &mut Obj, v: &View<'a>, id: &str, outer: Option<&Inst<'a>>, rest_id: &str) -> Option<(Inst<'a>, String)> {
+        let sd = v.get("symbolData");
+        let mut sym = v.get("overriddenSymbolID").and_then(guid).or_else(|| sd.and_then(|s| s.get("symbolID")).and_then(guid));
+        // An instance swap property value picks the main.
+        if let Some(i) = outer
+            && let Some(def) = prop_ref(v, "OVERRIDDEN_SYMBOL_ID")
+            && let Some(g) = i.props.get(&self.prop_root(&def)).and_then(|p| prop_guid(p))
+        {
+            sym = Some(g);
+        }
+        let Some(sym) = sym else {
+            self.warn("instances without a main component were imported as empty frames");
+            return None;
+        };
+        o.insert("componentId".into(), json!(sym));
+        let assignments = v.list("componentPropAssignments");
+        let mut props = Obj::new();
+        for a in assignments {
+            let Some((name, ty)) = a.get("defID").and_then(guid).and_then(|d| self.prop_def(&d).cloned()) else { continue };
+            let val = assigned(a);
+            let p = match ty {
+                "BOOL" => val.and_then(|x| x.get("boolValue")).and_then(Kv::bool).map(|b| json!({"type": "BOOLEAN", "value": b})),
+                "TEXT" => val.and_then(prop_text).map(|t| json!({"type": "TEXT", "value": t})),
+                "INSTANCE_SWAP" => val.and_then(prop_guid).map(|g| json!({"type": "INSTANCE_SWAP", "value": g})),
+                _ => None,
+            };
+            if let Some(p) = p {
+                props.insert(name, p);
+            }
+        }
+        if !props.is_empty() {
+            o.insert("componentProperties".into(), Value::Object(props));
+        }
+        if !self.nodes.contains_key(&sym) {
+            self.warn("instances of components that aren't in the file show no layers");
+            return None;
+        }
+        if !self.referenced_mains.contains(&sym) {
+            self.referenced_mains.insert(sym.clone());
+        }
+        if outer.is_some_and(|i| i.symbols.contains(&sym)) {
+            return None;
+        }
+        // Overrides by id path below this instance (the instance itself is addressed by its main's id).
+        let own_path: Vec<String> = outer.map(|i| [i.path.as_slice(), &[id.to_string()]].concat()).unwrap_or_default();
+        let scope = self.override_scope(&sym);
+        let mut overrides: Overrides<'a> = BTreeMap::new();
+        if let Some(inherited) = outer {
+            for (path, rows) in inherited.overrides.iter() {
+                let mut path = path.clone();
+                // Rows an outer instance wrote for this instance's layers may use their old keys.
+                if path.starts_with(&own_path) && path.len() > own_path.len() {
+                    normalize_override_segment(&mut path, own_path.len(), &scope);
+                }
+                overrides.entry(path).or_default().extend(rows.iter().cloned());
+            }
+        }
+        // A nested instance's derived layout is for the size it has in its main: resized here, the
+        // sizes and places in it no longer hold and its layers follow their constraints instead.
+        let differs = |a: f64, b: f64| (a - b).abs() > 1e-6 * a.abs().max(b.abs()).max(1.0);
+        let resized = outer.is_some()
+            && match (self.nodes.get(id).and_then(|b| View::of(b).size()), v.size()) {
+                (Some(a), Some(b)) => differs(a.0, b.0) || differs(a.1, b.1),
+                (a, b) => a.is_some() != b.is_some(),
+            };
+        let mut local: Overrides<'a> = BTreeMap::new();
+        let lists = [sd.and_then(|s| s.get("symbolOverrides")).map(Kv::list).unwrap_or_default(), v.list("derivedSymbolData")];
+        let source_depth = outer.map_or(0, |i| i.symbols.len());
+        let mut ordinal = 0;
+        for (layer, list) in lists.into_iter().enumerate() {
+            for ov in list {
+                let row_ordinal = ordinal;
+                ordinal += 1;
+                let mut rel: Vec<String> =
+                    ov.get("guidPath").and_then(|g| g.get("guids")).map(Kv::list).unwrap_or_default().iter().filter_map(guid).collect();
+                if rel.is_empty() || rel == [sym.clone()] {
+                    continue;
+                }
+                normalize_override_segment(&mut rel, 0, &scope);
+                // Explicit overrides, then derived layout (stale once the instance is resized).
+                let entry = match (layer, resized) {
+                    (0, _) => Entry::Override,
+                    (_, false) => Entry::Derived,
+                    (_, true) => Entry::Stale,
+                };
+                local.entry([own_path.as_slice(), &rel].concat()).or_default().push(OverrideRow {
+                    row: ov,
+                    entry,
+                    source_depth,
+                    ordinal: row_ordinal,
+                });
+            }
+        }
+        for (path, rows) in local {
+            overrides.entry(path).or_default().extend(rows);
+        }
+        for rows in overrides.values_mut() {
+            // Deeper source rows apply first; outer rows win, with wire order preserved per source.
+            rows.sort_by_key(|row| (std::cmp::Reverse(row.source_depth), row.ordinal));
+        }
+        let mut all_props: BTreeMap<String, &'a Kv<'a>> = outer.map(|i| (*i.props).clone()).unwrap_or_default();
+        let mut slot_contents: BTreeMap<String, String> = outer.map(|i| (*i.slot_contents).clone()).unwrap_or_default();
+        for a in assignments {
+            if let (Some(d), Some(val)) = (a.get("defID").and_then(guid), assigned(a)) {
+                all_props.entry(self.prop_root(&d)).or_insert(val);
+            }
+            let Some(def) = a.get("defID").and_then(guid) else { continue };
+            if self.prop_def(&def).is_none_or(|(_, ty)| *ty != "SLOT") {
+                continue;
+            }
+            let var_value = a.get("varValue");
+            if var_value.and_then(|v| v.get("dataType")).and_then(Kv::str) != Some("SLOT_CONTENT_ID") {
+                self.warn("malformed slot content assignment was skipped");
+                continue;
+            }
+            let target = var_value.and_then(|v| v.get("value")).and_then(|v| v.get("slotContentIdValue")).and_then(|v| v.get("guid")).and_then(guid);
+            let Some(target) = target else {
+                self.warn("malformed slot content assignment was skipped");
+                continue;
+            };
+            if target == "4294967295:4294967295" {
+                self.warn("slot content assignment uses the empty GUID sentinel and was skipped");
+                continue;
+            }
+            if self.nodes.get(&target).is_none_or(|n| n.get("isSlotContent").and_then(Kv::bool) != Some(true)) {
+                self.warn("slot content assignment target is missing or is not slot content");
+                continue;
+            }
+            slot_contents.entry(self.prop_root(&def)).or_insert(target);
+        }
+        let mut symbols = outer.map(|i| i.symbols.clone()).unwrap_or_default();
+        symbols.push(sym.clone());
+        let root = outer.map_or_else(|| rest_id.to_string(), |i| i.root.clone());
+        Some((
+            Inst {
+                root,
+                path: own_path,
+                overrides: Rc::new(overrides),
+                props: Rc::new(all_props),
+                slot_contents: Rc::new(slot_contents),
+                slot_content: false,
+                symbols,
+            },
+            sym,
+        ))
+    }
+}
+
+/// The text of a component property value.
+fn prop_text<'k>(v: &'k Kv) -> Option<&'k str> {
+    prop_text_data(v).and_then(|t| t.get("characters")).and_then(Kv::str)
+}
+
+/// The text data of a component property value: `textValue`, or `textDataValue` in the variable form.
+fn prop_text_data<'k, 's>(v: &'k Kv<'s>) -> Option<&'k Kv<'s>> {
+    v.get("textValue").or_else(|| v.get("textDataValue"))
+}
+
+/// The main an instance swap value names: `guidValue`, or `symbolIdValue` in the variable form.
+pub(super) fn prop_guid(v: &Kv) -> Option<String> {
+    v.get("guidValue").and_then(guid).or_else(|| v.get("symbolIdValue")?.get("guid").and_then(guid))
+}
+
+/// The value a component property assignment sets: `value`, or the variable form `varValue` holds
+/// when `value` is empty, as current files write many booleans and instance swaps.
+pub(super) fn assigned<'k, 's>(assignment: &'k Kv<'s>) -> Option<&'k Kv<'s>> {
+    assignment.get("value").filter(|v| !matches!(v, Kv::Object(fields) if fields.is_empty())).or_else(|| assignment.get("varValue")?.get("value"))
+}
+
+/// The property a layer's `field` is bound to (`parameterConsumptionMap`).
+pub(super) fn prop_ref(v: &View, field: &str) -> Option<String> {
+    v.get("parameterConsumptionMap")?.get("entries")?.list().iter().find_map(|e| {
+        if e.get("variableField").and_then(Kv::str) != Some(field) {
+            return None;
+        }
+        e.get("variableData")?.get("value")?.get("propRefValue")?.get("defId").and_then(guid)
+    })
+}
diff --git a/crates/format/src/fig/map/connector.rs b/crates/format/src/fig/map/connector.rs
new file mode 100644
index 00000000..172616dc
--- /dev/null
+++ b/crates/format/src/fig/map/connector.rs
@@ -0,0 +1,271 @@
+use super::layer::{cap_name, own_text, svg_path, valid_size};
+use super::*;
+
+impl<'a> Mapper<'a> {
+    /// A connector's end caps, and when it has no saved outline or network a straight line
+    /// between its ends: free points, or a point (the centre unless given) of a sibling layer.
+    pub(super) fn connector(&mut self, o: &mut Obj, v: &View<'a>, space: Affine) {
+        for (from, to) in [("connectorStartCap", "strokeCapStart"), ("connectorEndCap", "strokeCapEnd")] {
+            if let Some(c) = v.str(from) {
+                o.insert(to.into(), json!(cap_name(c)));
+            }
+        }
+        if connector_has_saved_label(v) {
+            self.warn("connector labels were skipped");
+        }
+        if ["vectorNetwork", "vectorNetworkRef", "fillGeometry", "strokeGeometry"].iter().any(|k| o.contains_key(*k)) {
+            return;
+        }
+        let parent = v.get("parentIndex").and_then(|p| p.get("guid")).and_then(guid);
+        let end = |k: &str| -> Option<Point> {
+            let e = v.get(k)?;
+            let p = match e.get("endpointNodeID").and_then(guid).filter(|g| g != NO_STYLE) {
+                Some(id) => {
+                    let n = *self.nodes.get(&id)?;
+                    // Only siblings share the connector's coordinates.
+                    if n.get("parentIndex").and_then(|p| p.get("guid")).and_then(guid) != parent {
+                        return None;
+                    }
+                    let (w, h) = n.get("size").map_or((0.0, 0.0), |s| (num(s, "x").unwrap_or(0.0), num(s, "y").unwrap_or(0.0)));
+                    let (rx, ry) = e.get("relativePosition").and_then(|r| Some((num(r, "x")?, num(r, "y")?))).unwrap_or((0.5, 0.5));
+                    n.get("transform").and_then(matrix).unwrap_or_default() * Point::new(w * rx, h * ry)
+                }
+                None => e.get("position").and_then(|p| Some(Point::new(num(p, "x")?, num(p, "y")?)))?,
+            };
+            (p.x.is_finite() && p.y.is_finite()).then_some(p)
+        };
+        let (Some(a), Some(b)) = (end("connectorStart"), end("connectorEnd")) else {
+            self.warn("connectors whose ends can't be placed are empty");
+            return;
+        };
+        if v.str("connectorLineStyle").is_some_and(|s| s != "STRAIGHT") {
+            self.warn("elbowed and curved connectors without a saved path import as straight lines");
+        }
+        let (x0, y0) = (a.x.min(b.x), a.y.min(b.y));
+        o.insert("relativeTransform".into(), rows(space * Affine::translate((x0, y0))));
+        o.insert("size".into(), json!({"x": (a.x - b.x).abs(), "y": (a.y - b.y).abs()}));
+        o.insert(
+            "vectorNetwork".into(),
+            json!({"vertices": [{"x": a.x - x0, "y": a.y - y0}, {"x": b.x - x0, "y": b.y - y0}], "segments": [{"a": 0, "b": 1}]}),
+        );
+    }
+
+    pub(super) fn connector_snapshot_supported(&self, v: &View<'a>) -> bool {
+        if v.str("connectorType") != Some("MANUAL")
+            || v.get("connectorVersion").and_then(Kv::f64) != Some(1.0)
+            || v.str("connectorLineStyle") != Some("STRAIGHT")
+            || v.get("derivedImmutableFrameData").and_then(|data| data.get("version")).and_then(Kv::f64) != Some(1.0)
+        {
+            return false;
+        }
+        let Some(line) = connector_record(v, "derivedImmutableFrameData", 0) else { return false };
+        if line.get("transform").and_then(matrix).is_none() || valid_size(line.get("size")).is_none() {
+            return false;
+        }
+        let geometry = ["fillGeometry", "strokeGeometry"].iter().any(|key| {
+            line.get(key).map(Kv::list).unwrap_or_default().iter().any(|path| {
+                num(path, "commandsBlob")
+                    .and_then(|index| self.blobs.get(index as usize))
+                    .and_then(|blob| svg_path(blob))
+                    .is_some_and(|data| !data.is_empty())
+            })
+        });
+        let network = line
+            .get("vectorData")
+            .and_then(|data| num(data, "vectorNetworkBlob"))
+            .and_then(|index| self.blobs.get(index as usize))
+            .and_then(|blob| network::decode(blob))
+            .is_some_and(|network| !network.segments.is_empty());
+        (geometry || network) && connector_record(v, "nodeGenerationData", 0).is_some()
+    }
+
+    pub(super) fn connector_snapshot_flatten(&mut self, out: &mut Obj, v: &View<'a>, rest_id: &str, space: Affine) {
+        let parent = space * v.get("transform").and_then(matrix).unwrap_or_default();
+        let Some(vector) = self.connector_snapshot_vector(v, rest_id, parent, false) else {
+            self.warn("connector snapshot vector data is missing; connector was left empty");
+            return;
+        };
+        for key in [
+            "size",
+            "relativeTransform",
+            "fills",
+            "strokes",
+            "strokeWeight",
+            "strokeAlign",
+            "strokeJoin",
+            "strokeDashes",
+            "strokeCap",
+            "strokeCapStart",
+            "strokeCapEnd",
+            "styles",
+            "fillGeometry",
+            "strokeGeometry",
+            "vectorNetwork",
+        ] {
+            if let Some(value) = vector.get(key) {
+                out.insert(key.to_string(), value.clone());
+            }
+        }
+        if vector.get("visible").and_then(Value::as_bool) == Some(false) {
+            out.insert("visible".into(), json!(false));
+        }
+        if let Some(line_opacity) = vector.get("opacity").and_then(Value::as_f64) {
+            let root_opacity = out.get("opacity").and_then(Value::as_f64).unwrap_or(1.0);
+            out.insert("opacity".into(), json!(root_opacity * line_opacity));
+        }
+        if connector_has_saved_label(v) {
+            let reason = if self.count >= self.budget() { "node budget" } else { "depth limit" };
+            self.warn(format!("connector label was skipped: {reason} prevents nested snapshot children"));
+        }
+    }
+
+    /// Build the saved vector child or flattened terminal connector from the same child-only view.
+    fn connector_snapshot_vector(&mut self, v: &View<'a>, rest_id: &str, space: Affine, nested: bool) -> Option<Obj> {
+        let (Some(line), Some(line_style)) = (connector_record(v, "derivedImmutableFrameData", 0), connector_record(v, "nodeGenerationData", 0))
+        else {
+            return None;
+        };
+        let mut vector = Obj::new();
+        vector.insert("id".into(), json!(if nested { format!("{rest_id};vector") } else { rest_id.to_string() }));
+        vector.insert("type".into(), json!("VECTOR"));
+        if let Some(name) = v.str("name") {
+            vector.insert("name".into(), json!(if nested { format!("{name} vector") } else { name.to_string() }));
+        }
+        let line_view = View::of(line).with([line_style]);
+        self.common(&mut vector, &line_view, "VECTOR", space, None);
+        self.geometry(&mut vector, &line_view);
+        for (from, to) in [("connectorStartCap", "strokeCapStart"), ("connectorEndCap", "strokeCapEnd")] {
+            if let Some(cap) = v.str(from) {
+                vector.entry(to).or_insert_with(|| json!(cap_name(cap)));
+            }
+        }
+        Some(vector)
+    }
+
+    /// Snapshot the straight, manual connector contract carried by its generated children.
+    pub(crate) fn connector_snapshot_children(&mut self, v: &View<'a>, rest_id: &str) -> Vec<Value> {
+        if self.count >= self.budget() {
+            self.warn(format!("the file has more than {} layers; connector snapshot children were skipped", self.max_nodes));
+            return Vec::new();
+        }
+        let Some(vector) = self.connector_snapshot_vector(v, rest_id, Affine::IDENTITY, true) else {
+            self.warn("connector snapshot vector data is missing; connector was left empty");
+            return Vec::new();
+        };
+        let mut children = Vec::new();
+        children.push(Value::Object(vector));
+        self.count += 1;
+
+        let Some(text_frame) = connector_record(v, "derivedImmutableFrameData", 1) else {
+            if connector_has_saved_label(v) {
+                self.warn("connector label was skipped: derived text bounds are missing");
+            }
+            return children;
+        };
+        let Some(background) = connector_record(v, "derivedImmutableFrameData", 2) else {
+            if connector_has_saved_label(v) || valid_size(text_frame.get("size")).is_some_and(|(w, h)| w > 0.0 && h > 0.0) {
+                self.warn("connector label was skipped: derived background bounds are missing");
+            }
+            return children;
+        };
+        let Some(text_style) = connector_record(v, "nodeGenerationData", 1) else {
+            if valid_size(text_frame.get("size")).is_some_and(|(w, h)| w > 0.0 && h > 0.0) {
+                self.warn("connector label was skipped: text style data is missing");
+            }
+            return children;
+        };
+        let text_view = View::of(text_frame).with([text_style]);
+        let Some(characters) = text_view.get("textData").and_then(|d| d.get("characters")).and_then(Kv::str).filter(|s| !s.trim().is_empty()) else {
+            return children;
+        };
+        let Some(text_transform) = text_frame.get("transform").and_then(matrix) else {
+            self.warn("connector label was skipped: text transform is invalid");
+            return children;
+        };
+        let Some(background_transform) = background.get("transform").and_then(matrix) else {
+            self.warn("connector label was skipped: background transform is invalid");
+            return children;
+        };
+        let Some(text_size) = valid_size(text_frame.get("size")) else {
+            self.warn("connector label was skipped: text bounds are invalid");
+            return children;
+        };
+        let Some(background_size) = valid_size(background.get("size")) else {
+            self.warn("connector label was skipped: background bounds are invalid");
+            return children;
+        };
+        let composed_text_transform = background_transform * text_transform;
+        if !composed_text_transform.as_coeffs().iter().all(|coefficient| coefficient.is_finite()) {
+            self.warn("connector label was skipped: composed text transform is invalid");
+            return children;
+        }
+
+        let Some(background_style) = connector_record(v, "nodeGenerationData", 2) else {
+            self.warn("connector label background was skipped: style data is missing");
+            self.add_connector_text(&mut children, rest_id, characters, text_size, composed_text_transform, &text_view);
+            return children;
+        };
+        let background_view = View::of(background).with([background_style]);
+        if !background_view.list("fillPaints").is_empty() {
+            if self.count >= self.budget() {
+                self.warn(format!("the file has more than {} layers; connector label background was skipped", self.max_nodes));
+            } else {
+                let mut rect = Obj::new();
+                rect.insert("id".into(), json!(format!("{rest_id};label-background")));
+                rect.insert("type".into(), json!("RECTANGLE"));
+                rect.insert("name".into(), json!("connector label background"));
+                self.common(&mut rect, &background_view, "RECTANGLE", Affine::IDENTITY, None);
+                rect.insert("size".into(), json!({"x": background_size.0, "y": background_size.1}));
+                rect.insert("relativeTransform".into(), rows(background_transform));
+                rect.insert("clipsContent".into(), json!(false));
+                children.push(Value::Object(rect));
+                self.count += 1;
+            }
+        }
+        self.add_connector_text(&mut children, rest_id, characters, text_size, composed_text_transform, &text_view);
+        children
+    }
+
+    fn add_connector_text(
+        &mut self,
+        children: &mut Vec<Value>,
+        rest_id: &str,
+        characters: &str,
+        size: (f64, f64),
+        transform: Affine,
+        view: &View<'a>,
+    ) {
+        if self.count >= self.budget() {
+            self.warn(format!("the file has more than {} layers; connector label was skipped", self.max_nodes));
+            return;
+        }
+        let mut text = Obj::new();
+        text.insert("id".into(), json!(format!("{rest_id};label-text")));
+        text.insert("type".into(), json!("TEXT"));
+        text.insert("name".into(), json!(characters));
+        text.insert("size".into(), json!({"x": size.0, "y": size.1}));
+        self.common(&mut text, view, "TEXT", Affine::IDENTITY, None);
+        text.insert("relativeTransform".into(), rows(transform));
+        self.text(&mut text, view);
+        children.push(Value::Object(text));
+        self.count += 1;
+    }
+}
+
+/// A generated connector child is identified by one exact template GUID, not its array position.
+fn connector_record<'a>(v: &View<'a>, field: &str, local_id: u32) -> Option<&'a Kv<'a>> {
+    v.get(field)?.get("overrides")?.list().iter().find(|row| {
+        row.get("guidPath").and_then(|path| path.get("guids")).map(Kv::list).is_some_and(|guids| {
+            guids.len() == 1 && num(&guids[0], "sessionID") == Some(40_000_000.0) && num(&guids[0], "localID") == Some(f64::from(local_id))
+        })
+    })
+}
+
+pub(super) fn connector_has_saved_label(v: &View<'_>) -> bool {
+    own_text(v).is_some()
+        || connector_record(v, "nodeGenerationData", 1)
+            .and_then(|r| r.get("textData"))
+            .and_then(|d| d.get("characters"))
+            .and_then(Kv::str)
+            .is_some_and(|s| !s.trim().is_empty())
+}
diff --git a/crates/format/src/fig/map/document.rs b/crates/format/src/fig/map/document.rs
new file mode 100644
index 00000000..d31ef5c6
--- /dev/null
+++ b/crates/format/src/fig/map/document.rs
@@ -0,0 +1,308 @@
+use super::component::{assigned, prop_guid};
+use super::paint::color;
+use super::variables::variable_value;
+use super::*;
+
+impl<'a> Mapper<'a> {
+    /// The DOCUMENT with its pages.
+    pub(super) fn document(&mut self) -> Value {
+        let doc_id = self.nodes.iter().find(|(_, n)| n.get("type").and_then(Kv::str) == Some("DOCUMENT")).map(|(id, _)| id.clone());
+        let pages: Vec<String> = match &doc_id {
+            Some(d) => self.children(d),
+            None => self.nodes.iter().filter(|(_, n)| n.get("type").and_then(Kv::str) == Some("CANVAS")).map(|(id, _)| id.clone()).collect(),
+        };
+        let mut internal = Vec::new();
+        let mut visible = Vec::new();
+        for p in pages {
+            let Some(&n) = self.nodes.get(&p) else { continue };
+            if n.get("type").and_then(Kv::str) != Some("CANVAS") {
+                self.warn("document children other than pages were skipped");
+                continue;
+            }
+            // The hidden page that holds styles, variables and library copies.
+            if n.get("internalOnly").and_then(Kv::bool) == Some(true) {
+                internal.push((p, n));
+            } else {
+                visible.push((p, n));
+            }
+        }
+        // The library copies the pages use come first: in a file past the layer cap, the pages'
+        // last layers are skipped rather than the mains every instance of them needs (#981).
+        let visible_pages: Vec<String> = visible.iter().map(|(p, _)| p.clone()).collect();
+        let required_mains = self.referenced_component_mains(&visible_pages);
+        // The pages and their top-level layers, up to half the cap, stay for the pages.
+        let top: usize = visible_pages.iter().map(|p| 1 + self.children(p).len()).sum();
+        self.reserved = top.min(self.max_nodes / 2);
+        for (id, canvas) in internal {
+            if let Some(context) = self.library_context(&id, canvas, &required_mains) {
+                self.library_contexts.push(context);
+            }
+        }
+        self.reserved = 0;
+        let out: Vec<Value> = visible.into_iter().map(|(p, n)| self.page(&p, n)).collect();
+        if out.is_empty() {
+            self.warn("the file has no pages");
+        }
+        let mut doc = json!({"id": doc_id.unwrap_or_else(|| "0:0".into()), "type": "DOCUMENT"});
+        doc["children"] = Value::Array(out);
+        doc
+    }
+
+    /// The ids of the components the visible pages use, directly or through the components they
+    /// use in turn (nested instances, swap targets, overrides naming another main).
+    fn referenced_component_mains(&mut self, visible_pages: &[String]) -> BTreeSet<String> {
+        let mut mains = BTreeSet::new();
+        let mut visited = BTreeSet::new();
+        let mut pending: Vec<(String, usize)> = visible_pages.iter().flat_map(|page| self.children(page)).map(|id| (id, 1)).collect();
+        while let Some((id, depth)) = pending.pop() {
+            if depth > MAX_DEPTH {
+                self.warn(format!("component references below {MAX_DEPTH} layer levels were skipped"));
+                continue;
+            }
+            if !visited.insert(id.clone()) {
+                continue;
+            }
+            if visited.len() > self.max_nodes {
+                let max = self.max_nodes;
+                self.warn(format!("the component reference scan reached the {max}-layer limit"));
+                break;
+            }
+            let Some(node) = self.nodes.get(&id) else { continue };
+            for target in self.component_main_targets(node) {
+                if mains.insert(target.clone()) {
+                    pending.push((target, 1));
+                }
+            }
+            pending.extend(self.children(&id).into_iter().map(|child| (child, depth + 1)));
+        }
+        mains
+    }
+
+    /// The mains a layer names: an instance's own, the ones its overrides swap in, the instance-swap
+    /// defaults and values of component properties.
+    fn component_main_targets(&self, node: &Kv<'a>) -> Vec<String> {
+        let mut targets: Vec<String> = node
+            .get("componentPropDefs")
+            .map(Kv::list)
+            .unwrap_or_default()
+            .iter()
+            .filter_map(|definition| {
+                self.is_instance_swap(definition.get("id")?)?;
+                definition.get("initialValue")?.get("guidValue").and_then(guid)
+            })
+            .collect();
+        if node.get("type").and_then(Kv::str) != Some("INSTANCE") {
+            return targets;
+        }
+        // The instance and the override rows below it (rows carry the same fields, nested).
+        let mut pending: Vec<(&Kv<'a>, usize)> = vec![(node, 0)];
+        let mut rows = 0usize;
+        while let Some((row, depth)) = pending.pop() {
+            rows += 1;
+            if depth > MAX_DEPTH || rows > self.max_nodes {
+                break;
+            }
+            let data = row.get("symbolData");
+            targets.extend(row.get("overriddenSymbolID").and_then(guid));
+            targets.extend(data.and_then(|d| d.get("symbolID")).and_then(guid));
+            for assignment in row.get("componentPropAssignments").map(Kv::list).unwrap_or_default() {
+                if assignment.get("defID").is_some_and(|def| self.is_instance_swap(def).is_some()) {
+                    targets.extend(assigned(assignment).and_then(prop_guid));
+                }
+            }
+            let overrides = data.and_then(|d| d.get("symbolOverrides")).map(Kv::list).unwrap_or_default();
+            let derived = row.get("derivedSymbolData").map(Kv::list).unwrap_or_default();
+            pending.extend(overrides.iter().chain(derived).map(|row| (row, depth + 1)));
+        }
+        targets
+    }
+
+    /// The branches of the internal canvas `id` that hold the `required_mains` (with the frames
+    /// they sit in), as a frame of its own: the cached definitions of components that come from a
+    /// library. `None` when it holds none.
+    fn library_context(&mut self, id: &str, canvas: &'a Kv<'a>, required_mains: &BTreeSet<String>) -> Option<Value> {
+        let mut included = BTreeSet::new();
+        let mut parents: BTreeMap<String, String> = BTreeMap::new();
+        // The canvas itself is never a layer of the walk, whatever the parent links say.
+        let mut visited = BTreeSet::from([id.to_string()]);
+        // Each entry: layer, depth, inside a required definition.
+        let mut pending: Vec<(String, usize, bool)> = self.children(id).into_iter().map(|child| (child, 1, false)).collect();
+        while let Some((node_id, depth, in_definition)) = pending.pop() {
+            if depth > MAX_DEPTH {
+                self.warn(format!("internal library branches deeper than {MAX_DEPTH} levels were skipped"));
+                continue;
+            }
+            if !visited.insert(node_id.clone()) {
+                continue;
+            }
+            self.library_scan_count += 1;
+            if self.library_scan_count > self.max_nodes {
+                let max = self.max_nodes;
+                self.warn(format!("the internal library scan reached the {max}-layer limit; the remaining branches were skipped"));
+                break;
+            }
+            let Some(node) = self.nodes.get(&node_id) else { continue };
+            let kind = node.get("type").and_then(Kv::str);
+            let definition = (kind == Some("SYMBOL") || (kind == Some("FRAME") && node.get("isStateGroup").and_then(Kv::bool) == Some(true)))
+                && required_mains.contains(&node_id);
+            let in_definition = in_definition || definition;
+            if in_definition {
+                included.insert(node_id.clone());
+            }
+            if definition {
+                // The frames around it keep the path its layers are addressed by.
+                let mut ancestor = parents.get(&node_id);
+                for _ in 0..=MAX_DEPTH {
+                    let Some(parent) = ancestor else { break };
+                    if !included.insert(parent.clone()) {
+                        break;
+                    }
+                    ancestor = parents.get(parent);
+                }
+            }
+            for child in self.children(&node_id).into_iter().rev() {
+                // A layer reached again keeps the parent it was first reached by, so the parents
+                // lead back to the canvas.
+                if visited.contains(&child) {
+                    continue;
+                }
+                parents.entry(child.clone()).or_insert_with(|| node_id.clone());
+                pending.push((child, depth + 1, in_definition));
+            }
+        }
+        if included.is_empty() {
+            return None;
+        }
+        let mut context = Obj::new();
+        context.insert("id".into(), json!(id));
+        context.insert("type".into(), json!("FRAME"));
+        copy_str(&mut context, &View::of(canvas), "name", "name");
+        context.insert("size".into(), json!({"x": 0.0, "y": 0.0}));
+        context.insert("relativeTransform".into(), rows(Affine::IDENTITY));
+        context.insert(crate::rest::FIG_SOURCE_FIELD.into(), json!({"origin": id, "expanded": false, "wireFrame": true, "wireInstance": false}));
+        self.variable_bindings(&mut context, &View::of(canvas));
+        let mut children = Vec::new();
+        for child in self.children(id) {
+            children.extend(self.layer_filtered(&child, None, Affine::IDENTITY, None, None, 0, Some(&included)));
+        }
+        if !children.is_empty() {
+            context.insert("children".into(), Value::Array(children));
+        }
+        Some(Value::Object(context))
+    }
+
+    fn page(&mut self, id: &str, n: &'a Kv<'a>) -> Value {
+        let v = View::of(n);
+        let mut o = Obj::new();
+        o.insert("id".into(), json!(id));
+        o.insert("type".into(), json!("CANVAS"));
+        copy_str(&mut o, &v, "name", "name");
+        if let Some(c) = v.get("backgroundColor") {
+            o.insert("backgroundColor".into(), color(c));
+        }
+        if let Some(c) = v.get("prototypeBackgroundColor") {
+            o.insert("prototypeBackgrounds".into(), json!([color(c)]));
+        }
+        self.variable_bindings(&mut o, &v);
+        let mut flows: Vec<(&str, Value)> = Vec::new();
+        let mut kids = Vec::new();
+        for c in self.children(id) {
+            if let Some(sp) = self.nodes.get(&c).and_then(|k| k.get("prototypeStartingPoint")) {
+                let name = sp.get("name").and_then(Kv::str).filter(|s| !s.is_empty()).unwrap_or("Flow");
+                flows.push((sp.get("position").and_then(Kv::str).unwrap_or(""), json!({"nodeId": c, "name": name})));
+            }
+            kids.extend(self.layer(&c, None, Affine::IDENTITY, None, None, 0));
+        }
+        flows.sort_by(|a, b| a.0.cmp(b.0));
+        if !flows.is_empty() {
+            o.insert("flowStartingPoints".into(), Value::Array(flows.into_iter().map(|f| f.1).collect()));
+        }
+        o.insert("children".into(), Value::Array(kids));
+        Value::Object(o)
+    }
+
+    /// The shared styles the file defines, in their order: each with the sample layer that holds
+    /// its values (`styleDefinitions`, our extension of the file JSON; the REST importer reads it).
+    pub(super) fn style_definitions(&mut self) -> Vec<Value> {
+        let mut found: Vec<(&'a str, String, &'a Kv<'a>)> = Vec::new();
+        for (id, n) in &self.nodes {
+            let live = n.get("isSoftDeleted").and_then(Kv::bool) != Some(true) && n.get("isSoftDeletedStyle").and_then(Kv::bool) != Some(true);
+            if live && n.get("styleType").and_then(Kv::str).is_some_and(|t| matches!(t, "FILL" | "TEXT" | "EFFECT" | "GRID")) {
+                found.push((n.get("sortPosition").and_then(Kv::str).unwrap_or(""), id.clone(), n));
+            }
+        }
+        found.sort_by(|a, b| (a.0, &a.1).cmp(&(b.0, &b.1)));
+        let mut out = Vec::new();
+        for (_, id, n) in found {
+            let Some(node) = self.layer(&id, None, Affine::IDENTITY, None, None, 0) else { break };
+            let name = n.get("name").and_then(Kv::str).unwrap_or("Style");
+            let desc = n.get("styleDescription").or_else(|| n.get("description")).and_then(Kv::str).unwrap_or("");
+            let ty = n.get("styleType").and_then(Kv::str).unwrap_or("");
+            out.push(json!({"id": id, "name": name, "description": desc, "styleType": ty, "node": node}));
+        }
+        out
+    }
+
+    /// Collections and variables, as the local variables response's `meta`, with their ids in the
+    /// file's order (`collectionOrder` and `variableOrder`, our extensions).
+    pub(super) fn variables(&self) -> Option<Value> {
+        let of_type = |t: &'static str, key: &'static str| {
+            let live = move |n: &Kv| n.get("type").and_then(Kv::str) == Some(t) && n.get("isSoftDeleted").and_then(Kv::bool) != Some(true);
+            let mut list: Vec<(&str, &String, &'a Kv<'a>)> = self
+                .nodes
+                .iter()
+                .filter(|(_, n)| live(n))
+                .map(|(id, n)| (n.get(key).and_then(|p| p.get("position").or(Some(p))).and_then(Kv::str).unwrap_or(""), id, *n))
+                .collect();
+            list.sort_by(|a, b| (a.0, a.1).cmp(&(b.0, b.1)));
+            list.into_iter().map(|(_, id, n)| (id, n))
+        };
+        let mut order = Vec::new();
+        let mut collections = Obj::new();
+        for (id, n) in of_type("VARIABLE_SET", "parentIndex") {
+            order.push(json!(id));
+            let mut modes: Vec<(&str, Value)> = n
+                .get("variableSetModes")
+                .map(Kv::list)
+                .unwrap_or_default()
+                .iter()
+                .filter_map(|m| {
+                    let mode = json!({"modeId": m.get("id").and_then(guid)?, "name": m.get("name").and_then(Kv::str).unwrap_or("Mode")});
+                    Some((m.get("sortPosition").and_then(Kv::str).unwrap_or(""), mode))
+                })
+                .collect();
+            modes.sort_by(|a, b| a.0.cmp(b.0));
+            let default = modes.first().map_or(Value::Null, |m| m.1["modeId"].clone());
+            let name = n.get("name").and_then(Kv::str).unwrap_or("Collection");
+            let modes: Vec<Value> = modes.into_iter().map(|m| m.1).collect();
+            collections.insert(id.clone(), json!({"id": id, "name": name, "modes": modes, "defaultModeId": default}));
+        }
+        let mut variable_order = Vec::new();
+        let mut variables = Obj::new();
+        for (id, n) in of_type("VARIABLE", "sortPosition") {
+            let Some(set) = n.get("variableSetID").and_then(|s| self.resource_id(s)).filter(|s| collections.contains_key(s)) else { continue };
+            let ty = n.get("variableResolvedType").and_then(Kv::str).unwrap_or("");
+            if !matches!(ty, "BOOLEAN" | "FLOAT" | "STRING" | "COLOR") {
+                continue;
+            }
+            let mut values = Obj::new();
+            for e in n.get("variableDataValues").and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default() {
+                if let (Some(mode), Some(val)) = (e.get("modeID").and_then(guid), e.get("variableData").and_then(variable_value)) {
+                    values.insert(mode, val);
+                }
+            }
+            let name = n.get("name").and_then(Kv::str).unwrap_or("Variable");
+            let desc = n.get("description").and_then(Kv::str).unwrap_or("");
+            let mut var =
+                json!({"id": id, "name": name, "variableCollectionId": set, "resolvedType": ty, "valuesByMode": values, "description": desc});
+            // The properties pickers offer the variable for, under the REST names.
+            if let Some(scopes) = n.get("variableScopes") {
+                var["scopes"] = scopes.list().iter().filter_map(Kv::str).map(|s| if s == "STROKE" { "STROKE_COLOR" } else { s }).collect();
+            }
+            variable_order.push(json!(id));
+            variables.insert(id.clone(), var);
+        }
+        (!collections.is_empty())
+            .then(|| json!({"variableCollections": collections, "variables": variables, "collectionOrder": order, "variableOrder": variable_order}))
+    }
+}
diff --git a/crates/format/src/fig/map/layer.rs b/crates/format/src/fig/map/layer.rs
new file mode 100644
index 00000000..e4793d48
--- /dev/null
+++ b/crates/format/src/fig/map/layer.rs
@@ -0,0 +1,699 @@
+use super::component::{Entry, Inst, OverrideRow, prop_ref};
+use super::connector::connector_has_saved_label;
+use super::layout::{layout_grid, tracks};
+use super::paint::{effect, export_setting, paint, paint_bound, stroke};
+use super::*;
+
+/// How the layers of a resized container follow it when the file gives no derived layout for
+/// them: a frame's by their constraints, from its main's size to its own; a group's scale with it.
+#[derive(Clone, Copy)]
+pub(super) enum Fit {
+    Frame { from: (f64, f64), to: (f64, f64) },
+    Scale(f64, f64),
+}
+
+impl Fit {
+    fn frame(from: Option<(f64, f64)>, to: Option<(f64, f64)>) -> Option<Self> {
+        let (from, to) = (from?, to?);
+        ((from.0 - to.0).abs() > 1e-9 || (from.1 - to.1).abs() > 1e-9).then_some(Fit::Frame { from, to })
+    }
+
+    fn scale(from: Option<(f64, f64)>, to: Option<(f64, f64)>) -> Option<Self> {
+        let (from, to) = (from?, to?);
+        let k = |a: f64, b: f64| if a > 1e-9 { b / a } else { 1.0 };
+        let (kx, ky) = (k(from.0, to.0), k(from.1, to.1));
+        ((kx - 1.0).abs() > 1e-9 || (ky - 1.0).abs() > 1e-9).then_some(Fit::Scale(kx, ky))
+    }
+
+    /// The size and transform (in the parent's coordinates) of a `w` × `h` layer at `t` with
+    /// constraints `h_con`, `v_con`. Like the editor's constraint solver, a layer keeps its
+    /// rotation and flip and stretches along its own axes.
+    fn apply(self, w: f64, h: f64, t: Affine, h_con: Option<&str>, v_con: Option<&str>) -> ((f64, f64), Affine) {
+        let [a, b, c, d, _, _] = t.as_coeffs();
+        let lin = Affine::new([a, b, c, d, 0.0, 0.0]);
+        let bb = figcraft_doc::geom::transform_rect_bbox(t, figcraft_doc::geom::Rect::new(0.0, 0.0, w, h));
+        // Where the new box goes: its top-left (constraints) or its centre (a group's scale).
+        let (kx, ky, x0, y0, centred) = match self {
+            Fit::Frame { from, to } => {
+                let axis = |con: Option<&str>, lo: f64, hi: f64, old: f64, new: f64| match con {
+                    Some("MAX" | "FIXED_MAX") => (lo + new - old, hi + new - old),
+                    Some("STRETCH") => (lo, hi + new - old),
+                    Some("CENTER") => (lo + (new - old) / 2.0, hi + (new - old) / 2.0),
+                    Some("SCALE") if old > 1e-9 => (lo * new / old, hi * new / old),
+                    _ => (lo, hi),
+                };
+                let (x0, x1) = axis(h_con, bb.x0, bb.x1, from.0, to.0);
+                let (y0, y1) = axis(v_con, bb.y0, bb.y1, from.1, to.1);
+                let k = |new: f64, old: f64| if old > 1e-9 { (new / old).max(0.0) } else { 1.0 };
+                (k(x1 - x0, bb.width()), k(y1 - y0, bb.height()), x0, y0, false)
+            }
+            Fit::Scale(kx, ky) => (kx, ky, bb.center().x * kx, bb.center().y * ky, true),
+        };
+        let along = |x: f64, y: f64, fallback: f64| {
+            let len = x.hypot(y);
+            let k = (kx * x).hypot(ky * y) / len;
+            if len > 1e-12 && k.is_finite() { k } else { fallback }
+        };
+        let size = (w * along(a, b, kx), h * along(c, d, ky));
+        let nb = figcraft_doc::geom::transform_rect_bbox(lin, figcraft_doc::geom::Rect::new(0.0, 0.0, size.0, size.1));
+        let at = if centred { nb.center() } else { figcraft_doc::geom::Point::new(nb.x0, nb.y0) };
+        (size, Affine::translate((x0 - at.x, y0 - at.y)) * lin)
+    }
+}
+
+impl<'a> Mapper<'a> {
+    /// Layer `id` (inside instance `inst` when expanding one) and its subtree. `space`: from the
+    /// parent's coordinates to the enclosing frame's (groups and booleans place their children in
+    /// the frame's space, like the REST JSON). `parent`: the parent's view (grid tracks).
+    pub(crate) fn layer(
+        &mut self,
+        id: &str,
+        inst: Option<&Inst<'a>>,
+        space: Affine,
+        parent: Option<&View<'a>>,
+        fit: Option<Fit>,
+        depth: usize,
+    ) -> Option<Value> {
+        self.layer_filtered(id, inst, space, parent, fit, depth, None)
+    }
+
+    /// [`Self::layer`], keeping only the layers in `included` (all when `None`) below the
+    /// top-level one: the cached library definitions of an internal canvas.
+    pub(super) fn layer_filtered(
+        &mut self,
+        id: &str,
+        inst: Option<&Inst<'a>>,
+        space: Affine,
+        parent: Option<&View<'a>>,
+        fit: Option<Fit>,
+        depth: usize,
+        included: Option<&BTreeSet<String>>,
+    ) -> Option<Value> {
+        if included.is_some_and(|ids| !ids.contains(id)) {
+            return None;
+        }
+        if depth > MAX_DEPTH {
+            self.warn(format!("layers nested deeper than {MAX_DEPTH} levels were skipped"));
+            return None;
+        }
+        if self.count >= self.budget() {
+            let max = self.max_nodes;
+            self.warn(format!("the file has more than {max} layers; the rest were skipped"));
+            return None;
+        }
+        let base = *self.nodes.get(id)?;
+        let path = inst.map(|i| [i.path.as_slice(), &[id.to_string()]].concat());
+        let entries: &[OverrideRow<'a>] = match (inst, &path) {
+            (Some(i), Some(p)) => i.overrides.get(p).map(Vec::as_slice).unwrap_or_default(),
+            _ => &[],
+        };
+        let mut view = View::of(base).with(entries.iter().map(|e| e.row));
+        // A layer of a resized instance the file gives no derived layout for follows its
+        // constraints from the main's geometry, then takes the size and place overridden on it
+        // (auto layout places the others, as in the editor).
+        let derived = entries.iter().any(|e| e.entry == Entry::Derived && (e.row.get("size").is_some() || e.row.get("transform").is_some()));
+        let stacked = parent.and_then(|p| p.str("stackMode")).is_some_and(|m| matches!(m, "HORIZONTAL" | "VERTICAL" | "GRID"))
+            && view.str("stackPositioning") != Some("ABSOLUTE");
+        let main = View::of(base);
+        let set = |k: &str| entries.iter().rev().filter(|e| e.entry != Entry::Stale).find_map(|e| e.row.get(k));
+        if let (Some(f), false, false, Some((w, h))) = (fit, derived, stacked, main.size()) {
+            let t = main.transform().unwrap_or_default();
+            let (fw, ft) = f.apply(w, h, t, view.str("horizontalConstraint"), view.str("verticalConstraint"));
+            view.fitted = Some((set("size").and_then(size).unwrap_or(fw), set("transform").and_then(matrix).unwrap_or(ft)));
+        } else if entries.iter().any(|e| e.entry == Entry::Stale && (e.row.get("size").is_some() || e.row.get("transform").is_some()))
+            && let Some(s) = set("size").and_then(size).or_else(|| main.size())
+        {
+            view.fitted = Some((s, set("transform").and_then(matrix).or_else(|| main.transform()).unwrap_or_default()));
+        }
+        let rest_id = match (inst, &path) {
+            (Some(i), Some(p)) => format!("I{};{}", i.root, p.join(";")),
+            _ => id.to_string(),
+        };
+        let own = view.str("type").unwrap_or("");
+        let connector_snapshot = own == "CONNECTOR" && self.connector_snapshot_supported(&view);
+        // Only a connector with a saved label needs the frame wrapper; an unlabelled one stays a single vector.
+        let connector_terminal =
+            connector_snapshot && (!connector_has_saved_label(&view) || depth >= MAX_DEPTH || self.count.saturating_add(1) >= self.budget());
+        // A supported connector snapshot has its own note below instead of the generic stand-in one.
+        let stand = stand_in(own).filter(|_| !connector_snapshot);
+        let ty = match own {
+            "ROUNDED_RECTANGLE" => "RECTANGLE",
+            "SYMBOL" => "COMPONENT",
+            "FRAME" if view.flag("isStateGroup") == Some(true) => "COMPONENT_SET",
+            "FRAME" if view.flag("resizeToFit") == Some(true) => "GROUP",
+            "VARIABLE" | "VARIABLE_SET" => return None,
+            "CONNECTOR" if connector_snapshot && connector_terminal => "VECTOR",
+            "CONNECTOR" if connector_snapshot => "FRAME",
+            t => stand.map_or(t, |s| s.0),
+        };
+        if let Some((_, what)) = stand.filter(|_| own != "TEXT_PATH") {
+            self.warn(format!("{} layers import as {what}", own.to_ascii_lowercase().replace('_', " ")));
+        }
+        if connector_snapshot {
+            self.warn("connector layers import as static frame/vector snapshots with labels when present; live endpoint bindings are not retained");
+        }
+        self.count += 1;
+        if own == "SYMBOL" && inst.is_none() {
+            self.mapped_mains.insert(id.to_string());
+        }
+        let mut o = Obj::new();
+        o.insert("id".into(), json!(rest_id));
+        // Private provenance for the .fig importer; ordinary REST import ignores it.
+        o.insert(
+            crate::rest::FIG_SOURCE_FIELD.into(),
+            json!({
+                "origin": id,
+                "expanded": inst.is_some(),
+                "wireFrame": own == "FRAME",
+                "wireInstance": own == "INSTANCE",
+                "slotContent": inst.is_some_and(|i| i.slot_content),
+                // A size the instance gives this layer itself (kept when the instance relays out).
+                "sizeOverride": entries.iter().any(|e| e.entry == Entry::Override && e.row.get("size").is_some()),
+            }),
+        );
+        o.insert("type".into(), json!(ty));
+        copy_str(&mut o, &view, "name", "name");
+        self.common(&mut o, &view, ty, space, parent);
+        match ty {
+            "TEXT" => {
+                self.text(&mut o, &view);
+                if own == "TEXT_PATH" {
+                    self.text_path(&mut o, &view);
+                }
+            }
+            "VECTOR" | "STAR" | "REGULAR_POLYGON" => self.geometry(&mut o, &view),
+            "ELLIPSE" => {
+                if let Some(a) = view.get("arcData") {
+                    let arc: Obj =
+                        ["startingAngle", "endingAngle", "innerRadius"].iter().filter_map(|k| Some((k.to_string(), json!(num(a, k)?)))).collect();
+                    o.insert("arcData".into(), Value::Object(arc));
+                }
+            }
+            "BOOLEAN_OPERATION" => {
+                if let Some(op) = view.str("booleanOperation") {
+                    o.insert("booleanOperation".into(), json!(if op == "XOR" { "EXCLUDE" } else { op }));
+                }
+            }
+            _ => {}
+        }
+        if own == "CONNECTOR" && connector_snapshot {
+            if connector_terminal {
+                self.connector_snapshot_flatten(&mut o, &view, &rest_id, space);
+            } else {
+                o.insert("fills".into(), json!([]));
+                o.insert("strokes".into(), json!([]));
+                for key in ["styles", "strokeWeight", "strokeAlign", "strokeJoin", "strokeDashes", "strokeCap"] {
+                    o.remove(key);
+                }
+                o.insert("clipsContent".into(), json!(false));
+            }
+        } else if own == "CONNECTOR" {
+            self.connector(&mut o, &view, space);
+        }
+        if ty == "COMPONENT" || ty == "COMPONENT_SET" {
+            self.component(&mut o, &view, &rest_id);
+        }
+        self.prop_refs(&mut o, &view, inst);
+        let slot_content = if own == "FRAME" {
+            prop_ref(&view, "SLOT_CONTENT_ID").and_then(|def| inst.and_then(|i| i.slot_contents.get(&self.prop_root(&def)).cloned()))
+        } else {
+            None
+        };
+        if slot_content.is_some()
+            && let Some(source) = o.get_mut(crate::rest::FIG_SOURCE_FIELD).and_then(Value::as_object_mut)
+        {
+            source.insert("slotOverride".into(), json!(true));
+        }
+        let child_space = if matches!(ty, "GROUP" | "BOOLEAN_OPERATION") { space * view.transform().unwrap_or_default() } else { Affine::IDENTITY };
+        let mut kids = if connector_snapshot && !connector_terminal { self.connector_snapshot_children(&view, &rest_id) } else { Vec::new() };
+        if connector_terminal {
+            // The saved vector is flattened into the connector node when no child slot remains.
+        } else if ty == "INSTANCE" {
+            if let Some((sub, sym)) = self.instance(&mut o, &view, id, inst, &rest_id) {
+                let main = self.nodes.get(&sym).map(|m| View::of(m));
+                let fit = Fit::frame(main.as_ref().and_then(View::size), view.size());
+                // An instance that records no auto layout of its own has its main's.
+                let view = match main {
+                    Some(m) if view.get("stackMode").is_none() && m.get("stackMode").is_some() => {
+                        let layered = View { fitted: view.fitted, ..m.with(view.layers.iter().copied()) };
+                        self.auto_layout(&mut o, &layered);
+                        layered
+                    }
+                    _ => view.clone(),
+                };
+                for c in self.children(&sym) {
+                    // The main's branch can live outside the cached context being mapped.
+                    kids.extend(self.layer_filtered(&c, Some(&sub), child_space, Some(&view), fit, depth + 1, None));
+                }
+            }
+        } else if let Some(content) = slot_content {
+            let mut content_inst = inst.cloned();
+            if let Some(content_inst) = &mut content_inst {
+                content_inst.slot_content = true;
+            }
+            for c in self.children(&content) {
+                kids.extend(self.layer_filtered(&c, content_inst.as_ref(), child_space, Some(&view), None, depth + 1, included));
+            }
+        } else {
+            // Inside an instance a layer's children are its main's: they follow it from the main's
+            // size to its own.
+            let fit = match (inst, ty) {
+                (None, _) => None,
+                (Some(_), "GROUP" | "BOOLEAN_OPERATION") => Fit::scale(View::of(base).size(), view.size()),
+                (Some(_), _) => Fit::frame(View::of(base).size(), view.size()),
+            };
+            for c in self.children(id) {
+                kids.extend(self.layer_filtered(&c, inst, child_space, Some(&view), fit, depth + 1, included));
+            }
+        }
+        if stand.is_some_and(|s| s.0 == "FRAME") {
+            kids.splice(0..0, self.shape_with_text(&mut o, &view, own, &rest_id));
+            kids.extend(self.inner_text(&o, &view, &rest_id, own == "STICKY"));
+        }
+        if !kids.is_empty() {
+            o.insert("children".into(), Value::Array(kids));
+        }
+        Some(Value::Object(o))
+    }
+
+    /// A non-rectangular shape-with-text's shape, as a vector under its frame (which gives up its
+    /// paints to it).
+    fn shape_with_text(&mut self, o: &mut Obj, v: &View<'a>, own: &str, rest_id: &str) -> Option<Value> {
+        let shape = v.str("shapeWithTextType").unwrap_or("SQUARE");
+        let outlined = !v.list("fillGeometry").is_empty() || !v.list("strokeGeometry").is_empty();
+        if own != "SHAPE_WITH_TEXT" || matches!(shape, "SQUARE" | "ROUNDED_RECTANGLE") || !outlined || self.count >= self.budget() {
+            return None;
+        }
+        let mut s = Obj::new();
+        s.insert("id".into(), json!(format!("{rest_id};shape")));
+        s.insert("type".into(), json!("VECTOR"));
+        s.insert("name".into(), json!(shape.to_ascii_lowercase().replace('_', " ")));
+        for k in ["size", "strokeWeight", "strokeAlign", "strokeJoin", "strokeDashes"] {
+            if let Some(x) = o.get(k) {
+                s.insert(k.into(), x.clone());
+            }
+        }
+        for k in ["fills", "strokes"] {
+            s.insert(k.into(), o.insert(k.into(), json!([])).unwrap_or_else(|| json!([])));
+        }
+        s.insert("relativeTransform".into(), rows(Affine::IDENTITY));
+        self.geometry(&mut s, v);
+        if !s.contains_key("fillGeometry") && !s.contains_key("strokeGeometry") {
+            // Damaged outlines: the frame keeps its paints and box.
+            for k in ["fills", "strokes"] {
+                o.insert(k.into(), s.remove(k).unwrap_or_else(|| json!([])));
+            }
+            return None;
+        }
+        self.count += 1;
+        Some(Value::Object(s))
+    }
+
+    /// The text a stand-in frame holds (a sticky note's, a shape's, a table cell's) as a text
+    /// layer filling it, inset a little; centred unless it's a note.
+    fn inner_text(&mut self, o: &Obj, v: &View<'a>, rest_id: &str, note: bool) -> Option<Value> {
+        let chars = own_text(v)?;
+        if self.count >= self.budget() {
+            return None;
+        }
+        self.count += 1;
+        let size = |k: &str| o.get("size").and_then(|s| s.get(k)).and_then(Value::as_f64).unwrap_or(0.0);
+        let (w, h) = (size("x"), size("y"));
+        let pad = (w.min(h) / 4.0).clamp(0.0, 16.0);
+        let mut t = Obj::new();
+        t.insert("id".into(), json!(format!("{rest_id};text")));
+        t.insert("type".into(), json!("TEXT"));
+        t.insert("name".into(), json!(chars.chars().take(40).collect::<String>()));
+        t.insert("size".into(), json!({"x": (w - 2.0 * pad).max(1.0), "y": (h - 2.0 * pad).max(1.0)}));
+        t.insert("relativeTransform".into(), rows(Affine::translate((pad, pad))));
+        self.text(&mut t, v);
+        if let Some(Value::Object(st)) = t.get_mut("style") {
+            let (hor, ver) = if note { ("LEFT", "TOP") } else { ("CENTER", "CENTER") };
+            st.entry("textAlignHorizontal").or_insert_with(|| json!(hor));
+            st.entry("textAlignVertical").or_insert_with(|| json!(ver));
+            st.insert("textAutoResize".into(), json!("NONE"));
+        }
+        Some(Value::Object(t))
+    }
+
+    /// Fields every layer type shares.
+    pub(super) fn common(&mut self, o: &mut Obj, v: &View<'a>, ty: &str, space: Affine, parent: Option<&View<'a>>) {
+        for (from, to) in [("visible", "visible"), ("locked", "locked"), ("mask", "isMask")] {
+            if let Some(b) = v.flag(from) {
+                o.insert(to.into(), json!(b));
+            }
+        }
+        if let Some(m) = v.str("maskType") {
+            o.insert("maskType".into(), json!(if m == "OUTLINE" { "VECTOR" } else { m }));
+        }
+        copy_num(o, v, "opacity", "opacity");
+        if let Some(b) = v.str("blendMode").filter(|b| *b != "UNSET") {
+            o.insert("blendMode".into(), json!(b));
+        }
+        if let Some((x, y)) = v.size() {
+            o.insert("size".into(), json!({"x": x, "y": y}));
+        }
+        let t = v.transform().unwrap_or_default();
+        o.insert("relativeTransform".into(), rows(space * t));
+        // Paints, from the shared style when one is linked (the layer's own copy can be stale),
+        // unless the layer's own paints are bound to variables: those bindings must not be lost.
+        let mut styles = Obj::new();
+        let own = |k: &str| Some(v.list(k)).filter(|l| l.iter().any(paint_bound));
+        let fill_style = self.style(v, "styleIdForFill", "inheritFillStyleID", "fill", &mut styles);
+        let fills = own("fillPaints")
+            .unwrap_or_else(|| fill_style.map_or_else(|| v.list("fillPaints"), |s| s.get("fillPaints").map(Kv::list).unwrap_or_default()));
+        o.insert("fills".into(), Value::Array(fills.iter().filter_map(|p| paint(p, &mut |w| self.warn(w))).collect()));
+        let stroke_style = self.style(v, "styleIdForStrokeFill", "inheritFillStyleIDForStroke", "stroke", &mut styles);
+        let strokes = own("strokePaints")
+            .unwrap_or_else(|| stroke_style.map_or_else(|| v.list("strokePaints"), |s| s.get("fillPaints").map(Kv::list).unwrap_or_default()));
+        o.insert("strokes".into(), Value::Array(strokes.iter().filter_map(|p| paint(p, &mut |w| self.warn(w))).collect()));
+        let effect_style = self.style(v, "styleIdForEffect", "inheritEffectStyleID", "effect", &mut styles);
+        let effects = effect_style.map_or_else(|| v.list("effects"), |s| s.get("effects").map(Kv::list).unwrap_or_default());
+        if !effects.is_empty() {
+            o.insert("effects".into(), Value::Array(effects.iter().filter_map(effect).collect()));
+        }
+        let grid_style = self.style(v, "styleIdForGrid", "inheritGridStyleID", "grid", &mut styles);
+        let grids = grid_style.map_or_else(|| v.list("layoutGrids"), |s| s.get("layoutGrids").map(Kv::list).unwrap_or_default());
+        if !grids.is_empty() {
+            o.insert("layoutGrids".into(), Value::Array(grids.iter().map(layout_grid).collect()));
+        }
+        if ty == "TEXT" {
+            self.style(v, "styleIdForText", "inheritTextStyleID", "text", &mut styles);
+        }
+        if !styles.is_empty() {
+            o.insert("styles".into(), Value::Object(styles));
+        }
+        stroke(o, v);
+        copy_num(o, v, "cornerRadius", "cornerRadius");
+        copy_num(o, v, "cornerSmoothing", "cornerSmoothing");
+        if v.flag("rectangleCornerRadiiIndependent") == Some(true) {
+            let r = |k: &str| v.num(k).unwrap_or(0.0);
+            o.insert(
+                "rectangleCornerRadii".into(),
+                json!([
+                    r("rectangleTopLeftCornerRadius"),
+                    r("rectangleTopRightCornerRadius"),
+                    r("rectangleBottomRightCornerRadius"),
+                    r("rectangleBottomLeftCornerRadius")
+                ]),
+            );
+        }
+        let constraint = |k: &str, min: &'static str, max: &'static str, both: &'static str| match v.str(k) {
+            Some("CENTER") => "CENTER",
+            Some("MAX" | "FIXED_MAX") => max,
+            Some("STRETCH") => both,
+            Some("SCALE") => "SCALE",
+            _ => min,
+        };
+        o.insert(
+            "constraints".into(),
+            json!({
+                "horizontal": constraint("horizontalConstraint", "LEFT", "RIGHT", "LEFT_RIGHT"),
+                "vertical": constraint("verticalConstraint", "TOP", "BOTTOM", "TOP_BOTTOM"),
+            }),
+        );
+        if matches!(ty, "FRAME" | "COMPONENT" | "COMPONENT_SET" | "INSTANCE" | "SECTION") {
+            o.insert("clipsContent".into(), json!(!v.flag("frameMaskDisabled").unwrap_or(false)));
+            self.auto_layout(o, v);
+        }
+        child_layout(o, v, parent);
+        let exports: Vec<Value> = v.list("exportSettings").iter().map(export_setting).collect();
+        if !exports.is_empty() {
+            o.insert("exportSettings".into(), Value::Array(exports));
+        }
+        if let Some(b) = v.flag("sectionContentsHidden") {
+            o.insert("sectionContentsHidden".into(), json!(b));
+        }
+        self.prototype(o, v);
+        self.variable_bindings(o, v);
+    }
+
+    /// `fillGeometry` / `strokeGeometry` as SVG path data, and star/polygon parameters.
+    pub(super) fn geometry(&mut self, o: &mut Obj, v: &View<'a>) {
+        for key in ["fillGeometry", "strokeGeometry"] {
+            let mut out = Vec::new();
+            for p in v.list(key) {
+                let Some(blob) = num(p, "commandsBlob").and_then(|i| self.blobs.get(i as usize)).copied() else { continue };
+                let Some(d) = svg_path(blob) else {
+                    self.warn("damaged vector geometry was skipped");
+                    continue;
+                };
+                if d.is_empty() {
+                    continue;
+                }
+                let winding = if p.get("windingRule").and_then(Kv::str) == Some("ODD") { "EVENODD" } else { "NONZERO" };
+                out.push(json!({"path": d, "windingRule": winding}));
+            }
+            if !out.is_empty() {
+                o.insert(key.into(), Value::Array(out));
+            }
+        }
+        let vector = o.get("type").and_then(Value::as_str) == Some("VECTOR");
+        if vector && !self.network(o, v) && !o.contains_key("fillGeometry") && !o.contains_key("strokeGeometry") && v.str("type") != Some("CONNECTOR")
+        {
+            self.warn("vectors without geometry are empty");
+        }
+        if !vector {
+            copy_num(o, v, "count", "pointCount");
+            copy_num(o, v, "starInnerScale", "innerRadius");
+        }
+    }
+
+    /// The editable network of `vectorData` as `vectorNetwork` (the REST importer's extension),
+    /// scaled to the layer's size, with per-point corner radii, handle mirroring and end caps.
+    /// False when there's none or it's damaged (the outlines stand in).
+    fn network(&mut self, o: &mut Obj, v: &View<'a>) -> bool {
+        let Some(vd) = v.get("vectorData") else { return false };
+        let Some(blob_id) = num(vd, "vectorNetworkBlob").map(|i| i as usize) else { return false };
+        let Some(blob) = self.blobs.get(blob_id).copied() else { return false };
+        let Some(net) = network::decode(blob) else {
+            self.warn("damaged vector networks import as outlines");
+            return false;
+        };
+        let styles: BTreeMap<u64, &Kv> =
+            vd.get("styleOverrideTable").map(Kv::list).unwrap_or_default().iter().filter_map(|s| Some((num(s, "styleID")? as u64, s))).collect();
+        let mut has_uninterpreted = false;
+        let mut has_missing = false;
+        for segment in &net.segments {
+            if segment.style == 0 {
+                continue;
+            }
+            if styles.contains_key(&u64::from(segment.style)) {
+                has_uninterpreted = true;
+            } else {
+                has_missing = true;
+            }
+        }
+        if has_uninterpreted {
+            self.warn("style settings of some vector segments aren't supported; those segments use the layer's stroke");
+        }
+        if has_missing {
+            self.warn("some vector segments refer to style settings missing from the file; they use the layer's stroke");
+        }
+        // An open path shows its fill, which regions can't hold: the outline keeps the look.
+        let fills_shown =
+            o.get("fills").and_then(Value::as_array).is_some_and(|f| f.iter().any(|p| p.get("visible").and_then(Value::as_bool) != Some(false)));
+        if net.segments.is_empty() || (net.regions.is_empty() && fills_shown && o.contains_key("fillGeometry")) {
+            return false;
+        }
+        let style = |id: u32| styles.get(&u64::from(id)).copied().filter(|_| id != 0);
+        let scale = |k: &str| {
+            let size = v.size().map(|s| if k == "x" { s.0 } else { s.1 });
+            let norm = vd.get("normalizedSize").and_then(|s| num(s, k));
+            size.zip(norm).filter(|(s, n)| s.is_finite() && *n > 1e-9).map_or(1.0, |(s, n)| s / n)
+        };
+        let (sx, sy) = (scale("x"), scale("y"));
+        // An absent layer join is the source default.
+        let layer_join = v.str("strokeJoin").unwrap_or("MITER");
+        let point_join = |p: &network::Vertex| style(p.style).and_then(|s| s.get("strokeJoin"));
+        let known = |j: &str| matches!(j, "MITER" | "BEVEL" | "ROUND");
+        let unresolved_style = net.vertices.iter().any(|p| p.style != 0 && style(p.style).is_none());
+        let unknown_join = net.vertices.iter().any(|p| point_join(p).is_some_and(|j| !j.str().is_some_and(known)));
+        let unsupported_join = net.vertices.iter().any(|p| point_join(p).and_then(Kv::str).is_some_and(|j| known(j) && j != layer_join));
+        if net.regions.iter().any(|r| style(r.style).is_some_and(|s| s.get("fillPaints").is_some())) {
+            self.warn("filled areas of a vector with their own fill use the layer's fill");
+        }
+        if unresolved_style {
+            self.warn("some vector points refer to point settings missing from the file; they use the layer's joins and plain corners");
+        }
+        if unknown_join {
+            self.warn("vector points with unknown stroke joins use the layer join");
+        }
+        if unsupported_join && (o.contains_key("strokeDashes") || o.contains_key("strokeWidthProfile")) {
+            self.warn("point stroke joins were preserved; dashed or variable-width strokes render with the layer join");
+        }
+        // The stroke starts at the first end point and stops at the last (as the editor draws it).
+        let mut degree = vec![0usize; net.vertices.len()];
+        for s in &net.segments {
+            for i in [s.a, s.b] {
+                if let Some(d) = degree.get_mut(i) {
+                    *d += 1;
+                }
+            }
+        }
+        let ends: Vec<usize> = (0..degree.len()).filter(|i| degree.get(*i) == Some(&1)).collect();
+        let cap =
+            |i: Option<&usize>| i.and_then(|i| net.vertices.get(*i)).and_then(|p| style(p.style)).and_then(|s| s.get("strokeCap")).and_then(Kv::str);
+        let (first, last) = (cap(ends.first()), cap(ends.last()));
+        if first.is_some() || last.is_some() {
+            let node = v.str("strokeCap").unwrap_or("NONE");
+            o.insert("strokeCapStart".into(), json!(cap_name(first.unwrap_or(node))));
+            o.insert("strokeCapEnd".into(), json!(cap_name(last.unwrap_or(node))));
+        }
+        // Every instance of a main shows the same network: it is written once and shared.
+        let key = (blob_id, sx.to_bits(), sy.to_bits(), std::ptr::from_ref(vd) as usize);
+        let id = match self.network_ids.get(&key) {
+            Some(id) => *id,
+            None => {
+                let vertices: Vec<Value> = net
+                    .vertices
+                    .iter()
+                    .map(|p| {
+                        let mut out = json!({"x": p.x * sx, "y": p.y * sy});
+                        let st = style(p.style);
+                        if let Some(r) = st.and_then(|s| num(s, "cornerRadius")).filter(|r| *r > 0.0) {
+                            out["radius"] = json!(r);
+                        }
+                        match st.and_then(|s| s.get("handleMirroring")).and_then(Kv::str) {
+                            Some("ANGLE") => out["mirror"] = json!("angle"),
+                            Some("ANGLE_AND_LENGTH") => out["mirror"] = json!("angleAndLength"),
+                            Some("NONE") => out["mirror"] = json!("none"),
+                            _ => {}
+                        }
+                        if let Some(join @ ("MITER" | "BEVEL" | "ROUND")) = st.and_then(|s| s.get("strokeJoin")).and_then(Kv::str) {
+                            out["join"] = json!(join.to_ascii_lowercase());
+                        }
+                        out
+                    })
+                    .collect();
+                let segments: Vec<Value> = net
+                    .segments
+                    .iter()
+                    .map(|s| json!({"a": s.a, "b": s.b, "ta": [s.ta.0 * sx, s.ta.1 * sy], "tb": [s.tb.0 * sx, s.tb.1 * sy]}))
+                    .collect();
+                let regions: Vec<Value> =
+                    net.regions.iter().map(|r| json!({"loops": r.loops, "winding": if r.non_zero { "nonZero" } else { "evenOdd" }})).collect();
+                let mut entry = json!({});
+                entry["vertices"] = Value::Array(vertices);
+                entry["segments"] = Value::Array(segments);
+                entry["regions"] = Value::Array(regions);
+                self.networks.push(crate::rest::network(&entry));
+                self.network_ids.insert(key, self.networks.len() - 1);
+                self.networks.len() - 1
+            }
+        };
+        o.insert("vectorNetworkRef".into(), json!(id));
+        true
+    }
+}
+
+/// The text a layer that isn't a text layer carries (a note's, a shape's), unless blank.
+pub(super) fn own_text<'a>(v: &View<'a>) -> Option<&'a str> {
+    v.get("textData").and_then(|t| t.get("characters")).and_then(Kv::str).filter(|c| !c.trim().is_empty())
+}
+
+pub(super) fn valid_size(value: Option<&Kv<'_>>) -> Option<(f64, f64)> {
+    let x = num(value?, "x")?;
+    let y = num(value?, "y")?;
+    (x.is_finite() && y.is_finite() && x >= 0.0 && y >= 0.0).then_some((x, y))
+}
+
+/// The REST name of a stroke cap.
+pub(super) fn cap_name(cap: &str) -> &str {
+    match cap {
+        "ARROW_LINES" => "LINE_ARROW",
+        "ARROW_EQUILATERAL" => "TRIANGLE_ARROW",
+        c => c,
+    }
+}
+
+/// The layer kind (and how the warning names it) that a layer the editor has no counterpart for
+/// imports as: frames for notes, shapes, tables, slides and the like (their text as a text layer),
+/// vectors for connectors and marker strokes, plain text for text on a path.
+fn stand_in(ty: &str) -> Option<(&'static str, &'static str)> {
+    Some(match ty {
+        "STICKY"
+        | "SHAPE_WITH_TEXT"
+        | "CODE_BLOCK"
+        | "TABLE"
+        | "TABLE_CELL"
+        | "STAMP"
+        | "MEDIA"
+        | "WIDGET"
+        | "SLIDE"
+        | "SLIDE_GRID"
+        | "SLIDE_ROW"
+        | "INTERACTIVE_SLIDE_ELEMENT"
+        | "MODULE" => ("FRAME", "frames with their text"),
+        "CONNECTOR" | "HIGHLIGHT" | "WASHI_TAPE" => ("VECTOR", "vectors"),
+        "TEXT_PATH" => ("TEXT", "text off its path"),
+        _ => return None,
+    })
+}
+
+/// How a layer sizes and sits in an auto layout parent.
+fn child_layout(o: &mut Obj, v: &View, parent: Option<&View>) {
+    copy_num(o, v, "stackChildPrimaryGrow", "layoutGrow");
+    if v.str("stackChildAlignSelf") == Some("STRETCH") {
+        o.insert("layoutAlign".into(), json!("STRETCH"));
+    }
+    if v.str("stackPositioning") == Some("ABSOLUTE") {
+        o.insert("layoutPositioning".into(), json!("ABSOLUTE"));
+    }
+    for (k, w, h) in [("minSize", "minWidth", "minHeight"), ("maxSize", "maxWidth", "maxHeight")] {
+        if let Some(val) = v.get(k).and_then(|s| s.get("value")) {
+            for (axis, to) in [("x", w), ("y", h)] {
+                if let Some(x) = num(val, axis).filter(|x| *x > 0.0 && *x < 1e9) {
+                    o.insert(to.into(), json!(x));
+                }
+            }
+        }
+    }
+    if let Some(p) = parent.filter(|p| p.str("stackMode") == Some("GRID")) {
+        for (anchor, list, to) in [("gridColumnAnchor", "gridColumns", "gridColumnAnchorIndex"), ("gridRowAnchor", "gridRows", "gridRowAnchorIndex")]
+        {
+            if let Some(i) = v.get(anchor).and_then(guid).and_then(|g| tracks(p, list).iter().position(|t| *t == g)) {
+                o.insert(to.into(), json!(i));
+            }
+        }
+        copy_num(o, v, "gridColumnSpan", "gridColumnSpan");
+        copy_num(o, v, "gridRowSpan", "gridRowSpan");
+    }
+}
+
+/// SVG path data of a geometry blob: commands `0` close, `1` move, `2` line, `3` quadratic and
+/// `4` cubic, each followed by its points as little-endian `f32` pairs. `None` when damaged.
+pub(super) fn svg_path(b: &[u8]) -> Option<String> {
+    let mut out = String::new();
+    let mut i = 0usize;
+    let mut n = 0usize;
+    while i < b.len() {
+        n += 1;
+        if n > MAX_COMMANDS {
+            return None;
+        }
+        let (letter, points) = match *b.get(i)? {
+            0 => ('Z', 0),
+            1 => ('M', 1),
+            2 => ('L', 1),
+            3 => ('Q', 2),
+            4 => ('C', 3),
+            _ => return None,
+        };
+        i += 1;
+        if !out.is_empty() {
+            out.push(' ');
+        }
+        out.push(letter);
+        for _ in 0..points * 2 {
+            let bytes: [u8; 4] = b.get(i..i + 4)?.try_into().ok()?;
+            let x = f32::from_le_bytes(bytes);
+            if !x.is_finite() {
+                return None;
+            }
+            out.push_str(&format!(" {x}"));
+            i += 4;
+        }
+    }
+    Some(out)
+}
diff --git a/crates/format/src/fig/map/layout.rs b/crates/format/src/fig/map/layout.rs
new file mode 100644
index 00000000..f4d50891
--- /dev/null
+++ b/crates/format/src/fig/map/layout.rs
@@ -0,0 +1,188 @@
+use super::paint::{bound, color};
+use super::*;
+
+impl<'a> Mapper<'a> {
+    pub(super) fn auto_layout(&mut self, o: &mut Obj, v: &View<'a>) {
+        let Some(mode) = v.str("stackMode").filter(|m| matches!(*m, "HORIZONTAL" | "VERTICAL" | "GRID")) else { return };
+        o.insert("layoutMode".into(), json!(mode));
+        copy_num(o, v, "stackSpacing", "itemSpacing");
+        copy_num(o, v, "stackCounterSpacing", "counterAxisSpacing");
+        if v.str("stackWrap") == Some("WRAP") {
+            o.insert("layoutWrap".into(), json!("WRAP"));
+        }
+        if v.str("stackCounterAlignContent") == Some("SPACE_BETWEEN") {
+            o.insert("counterAxisAlignContent".into(), json!("SPACE_BETWEEN"));
+        }
+        let (h, vert) = (v.num("stackHorizontalPadding").unwrap_or(0.0), v.num("stackVerticalPadding").unwrap_or(0.0));
+        o.insert("paddingLeft".into(), json!(h));
+        o.insert("paddingTop".into(), json!(vert));
+        o.insert("paddingRight".into(), json!(v.num("stackPaddingRight").unwrap_or(h)));
+        o.insert("paddingBottom".into(), json!(v.num("stackPaddingBottom").unwrap_or(vert)));
+        let main = match v.str("stackPrimaryAlignItems").or_else(|| v.str("stackJustify")) {
+            Some("CENTER") => "CENTER",
+            Some("MAX") => "MAX",
+            Some("SPACE_AROUND") => "SPACE_AROUND",
+            // `SPACE_EVENLY` is the format's older name for equal gaps without edge space.
+            Some("SPACE_EVENLY_CSS") => "SPACE_EVENLY",
+            Some("SPACE_BETWEEN" | "SPACE_EVENLY") => "SPACE_BETWEEN",
+            _ => "MIN",
+        };
+        o.insert("primaryAxisAlignItems".into(), json!(main));
+        let cross = match v.str("stackCounterAlignItems").or_else(|| v.str("stackAlign")) {
+            Some("CENTER") => "CENTER",
+            Some("MAX") => "MAX",
+            Some("BASELINE") => "BASELINE",
+            _ => "MIN",
+        };
+        o.insert("counterAxisAlignItems".into(), json!(cross));
+        let sizing = |k: &str| if v.str(k).is_some_and(|s| s.starts_with("RESIZE_TO_FIT")) { "AUTO" } else { "FIXED" };
+        // A flow that records no sizing for its primary axis sizes it by its content: auto layout
+        // did before that axis could be fixed.
+        let primary = if v.get("stackPrimarySizing").is_none() && mode != "GRID" { "AUTO" } else { sizing("stackPrimarySizing") };
+        o.insert("primaryAxisSizingMode".into(), json!(primary));
+        o.insert("counterAxisSizingMode".into(), json!(sizing("stackCounterSizing")));
+        if let Some(b) = v.flag("bordersTakeSpace") {
+            o.insert("strokesIncludedInLayout".into(), json!(b));
+        }
+        if let Some(b) = v.flag("stackReverseZIndex") {
+            o.insert("itemReverseZIndex".into(), json!(b));
+        }
+        if mode == "GRID" {
+            copy_num(o, v, "gridColumnGap", "gridColumnGap");
+            copy_num(o, v, "gridRowGap", "gridRowGap");
+            o.insert("gridColumnCount".into(), json!(tracks(v, "gridColumns").len()));
+            o.insert("gridRowCount".into(), json!(tracks(v, "gridRows").len()));
+            let track_data = [("columnTracks", "gridColumns", "gridColumnsSizing"), ("rowTracks", "gridRows", "gridRowsSizing")]
+                .into_iter()
+                .filter_map(|(out_key, order_key, sizing_key)| {
+                    self.map_grid_tracks(v, order_key, sizing_key).map(|mapped| (out_key.to_string(), mapped))
+                })
+                .collect::<Obj>();
+            if !track_data.is_empty() {
+                let source = o.entry(crate::rest::FIG_SOURCE_FIELD).or_insert_with(|| json!({}));
+                if let Some(source) = source.as_object_mut() {
+                    source.insert("gridTracks".into(), Value::Object(track_data));
+                }
+            }
+        }
+    }
+
+    /// Track sizing maps are keyed by GUID; their order comes from the separate track list.
+    fn map_grid_tracks(&mut self, v: &View<'a>, order_key: &str, sizing_key: &str) -> Option<Value> {
+        let track_entries = v.get(order_key).and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default();
+        let sizes = v.get(sizing_key).and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default();
+        if track_entries.len() > MAX_GRID_TRACKS {
+            self.warn("grid track list exceeds 1000 entries; the tracks use the default equal sizing");
+            return None;
+        }
+        if sizes.is_empty() {
+            return None;
+        }
+        if sizes.len() > MAX_GRID_TRACKS {
+            self.warn("grid track sizing list exceeds 1000 entries; the tracks use the default equal sizing");
+            return None;
+        }
+        let ordered = tracks(v, order_key);
+        let ordered_ids: BTreeSet<&str> = ordered.iter().map(String::as_str).collect();
+        let mut size_by_id: BTreeMap<String, Option<&Kv<'a>>> = BTreeMap::new();
+        for entry in sizes {
+            let Some(id) = entry.get("id").and_then(guid) else {
+                self.warn("stale or invalid grid track sizing entries were ignored");
+                continue;
+            };
+            if !ordered_ids.contains(id.as_str()) {
+                self.warn("stale or invalid grid track sizing entries were ignored");
+                continue;
+            }
+            match size_by_id.entry(id) {
+                std::collections::btree_map::Entry::Vacant(slot) => {
+                    slot.insert(Some(entry));
+                }
+                std::collections::btree_map::Entry::Occupied(mut slot) => {
+                    slot.insert(None);
+                    self.warn("duplicate grid track sizing entries use equal tracks");
+                }
+            }
+        }
+        let mut mapped = Vec::with_capacity(ordered.len());
+        for id in ordered {
+            if let Some(Some(entry)) = size_by_id.get(&id) {
+                match grid_track_sizing(entry.get("trackSize")) {
+                    Some(track) => mapped.push(track),
+                    None => {
+                        self.warn("grid track sizing is unsupported or malformed; affected tracks use equal sizing");
+                        mapped.push(json!({"sizing": "fill", "value": 1.0}));
+                    }
+                }
+            } else {
+                mapped.push(json!({"sizing": "fill", "value": 1.0}));
+            }
+        }
+        Some(Value::Array(mapped))
+    }
+}
+
+/// The track ids of a grid's columns or rows, in order.
+pub(super) fn tracks(v: &View, key: &str) -> Vec<String> {
+    let mut t: Vec<(&str, String)> = v
+        .get(key)
+        .and_then(|m| m.get("entries"))
+        .map(Kv::list)
+        .unwrap_or_default()
+        .iter()
+        .filter_map(|e| Some((e.get("position").and_then(Kv::str).unwrap_or(""), e.get("id").and_then(guid)?)))
+        .collect();
+    t.sort();
+    t.into_iter().map(|e| e.1).collect()
+}
+
+/// Convert only unconstrained tracks, whose min and max sizing functions agree.
+fn grid_track_sizing(size: Option<&Kv<'_>>) -> Option<Value> {
+    let size = size?;
+    let min = size.get("minSizing")?;
+    let max = size.get("maxSizing")?;
+    let min_type = min.get("type").and_then(Kv::str)?;
+    let max_type = max.get("type").and_then(Kv::str)?;
+    if min_type != max_type {
+        return None;
+    }
+    match min_type {
+        "FIXED" => {
+            let px = num(min, "value")?;
+            let max_px = num(max, "value")?;
+            (px == max_px && px.is_finite() && (0.0..=MAX_GRID_TRACK_VALUE).contains(&px)).then(|| json!({"sizing": "fixed", "value": px}))
+        }
+        "FLEX" => {
+            let fr = num(min, "value")?;
+            let max_fr = num(max, "value")?;
+            (fr == max_fr && fr.is_finite() && fr > 0.0 && fr <= MAX_GRID_TRACK_VALUE).then(|| json!({"sizing": "fill", "value": fr}))
+        }
+        "HUG" => Some(json!({"sizing": "hug", "value": 0.0})),
+        _ => None,
+    }
+}
+
+pub(super) fn layout_grid(g: &Kv) -> Value {
+    let pattern = match (g.get("pattern").and_then(Kv::str), g.get("axis").and_then(Kv::str)) {
+        (Some("GRID"), _) => "GRID",
+        (_, Some("Y")) => "ROWS",
+        _ => "COLUMNS",
+    };
+    let mut o = json!({"pattern": pattern, "alignment": g.get("type").and_then(Kv::str).unwrap_or("STRETCH")});
+    for (from, to) in [("sectionSize", "sectionSize"), ("numSections", "count"), ("gutterSize", "gutterSize"), ("offset", "offset")] {
+        if let Some(x) = num(g, from) {
+            o[to] = json!(x);
+        }
+    }
+    if let Some(c) = g.get("color") {
+        o["color"] = color(c);
+    }
+    if let Some(b) = g.get("visible").and_then(Kv::bool) {
+        o["visible"] = json!(b);
+    }
+    let vars = [("numSectionsVar", "count"), ("offsetVar", "offset"), ("sectionSizeVar", "sectionSize"), ("gutterSizeVar", "gutterSize")];
+    if let Some(b) = bound(Some(g), &vars) {
+        o["boundVariables"] = b;
+    }
+    o
+}
diff --git a/crates/format/src/fig/map/paint.rs b/crates/format/src/fig/map/paint.rs
new file mode 100644
index 00000000..fe8cfa7b
--- /dev/null
+++ b/crates/format/src/fig/map/paint.rs
@@ -0,0 +1,291 @@
+use super::layer::cap_name;
+use super::variables::alias;
+use super::*;
+
+fn filter_number(value: &Kv) -> Option<f64> {
+    let number = match value {
+        Kv::Float(value) => f64::from(*value),
+        Kv::Int(value) => *value as f64,
+        Kv::Uint(value) => *value as f64,
+        _ => return None,
+    };
+    number.is_finite().then_some(number)
+}
+
+/// The style a layer links in `key`, or in the older `legacy` field when `key` names none. An
+/// explicit NO_STYLE in `key` is a detach and wins over the legacy field.
+pub(super) fn style_link(v: &View, key: &str, legacy: &str) -> Option<String> {
+    match v.get(key).and_then(|r| r.get("guid")).and_then(guid) {
+        Some(id) => Some(id).filter(|g| g != NO_STYLE),
+        None => v.get(legacy).and_then(guid).filter(|g| g != NO_STYLE),
+    }
+}
+
+pub(super) fn color(c: &Kv) -> Value {
+    let ch = |k: &str| num(c, k).unwrap_or(0.0);
+    json!({"r": ch("r"), "g": ch("g"), "b": ch("b"), "a": num(c, "a").unwrap_or(1.0)})
+}
+
+impl<'a> Mapper<'a> {
+    /// The style node a layer links in `key` (or the older `legacy` field), recorded for the REST
+    /// `styles` map under `slot`.
+    pub(super) fn style(&mut self, v: &View<'a>, key: &str, legacy: &str, slot: &str, out: &mut Obj) -> Option<&'a Kv<'a>> {
+        let id = style_link(v, key, legacy)?;
+        let node = *self.nodes.get(&id)?;
+        node.get("styleType").and_then(Kv::str)?;
+        out.insert(slot.into(), json!(id));
+        if !self.styles.contains_key(&id) {
+            let name = node.get("name").and_then(Kv::str).unwrap_or("Style");
+            let desc = node.get("styleDescription").or_else(|| node.get("description")).and_then(Kv::str).unwrap_or("");
+            self.styles.insert(id, json!({"name": name, "description": desc}));
+        }
+        Some(node)
+    }
+}
+
+pub(super) fn stroke(o: &mut Obj, v: &View) {
+    copy_num(o, v, "strokeWeight", "strokeWeight");
+    if let Some(a) = v.str("strokeAlign").filter(|a| *a != "OFFSET") {
+        o.insert("strokeAlign".into(), json!(a));
+    }
+    copy_str(o, v, "strokeJoin", "strokeJoin");
+    if let Some(cap) = v.str("strokeCap") {
+        o.insert("strokeCap".into(), json!(cap_name(cap)));
+    }
+    // A layer written as the outline of its stroke keeps what it was as plugin data
+    // (`outlinedStroke`, our extension of the file JSON).
+    let (id, key) = crate::fig::export::STASH;
+    let kept = v.list("pluginData").iter().find(|p| p.get("pluginID").and_then(Kv::str) == Some(id) && p.get("key").and_then(Kv::str) == Some(key));
+    if let Some(original) = kept.and_then(|p| p.get("value")).and_then(Kv::str).and_then(|s| serde_json::from_str::<Value>(s).ok()) {
+        o.insert("outlinedStroke".into(), original);
+    }
+    // A variable width: each point's reach on the two sides of the path (shares of the stroke
+    // weight), as `[t, scale, bias]` (`strokeWidthProfile`, our extension of the file JSON).
+    let profile: Vec<Value> = v
+        .list("variableWidthPoints")
+        .iter()
+        .filter_map(|p| {
+            let (left, right) = (num(p, "ascent")?.max(0.0), num(p, "descent")?.max(0.0));
+            let bias = if left + right > 0.0 { (right - left) / (left + right) } else { 0.0 };
+            Some(json!([num(p, "position")?, left + right, bias]))
+        })
+        .collect();
+    if !profile.is_empty() {
+        o.insert("strokeWidthProfile".into(), Value::Array(profile));
+    }
+    let dashes: Vec<f64> = v.list("dashPattern").iter().filter_map(Kv::f64).collect();
+    if !dashes.is_empty() {
+        o.insert("strokeDashes".into(), json!(dashes));
+    }
+    // A miter limit L bevels joins sharper than 2·asin(1/L).
+    if let Some(l) = v.num("miterLimit").filter(|l| *l > 1.0) {
+        o.insert("strokeMiterAngle".into(), json!((2.0 * (1.0 / l).asin()).to_degrees()));
+    }
+    if v.flag("borderStrokeWeightsIndependent") == Some(true) {
+        // A side that isn't written has no border.
+        let side = |k: &str| v.num(k).unwrap_or(0.0);
+        o.insert(
+            "individualStrokeWeights".into(),
+            json!({"top": side("borderTopWeight"), "right": side("borderRightWeight"), "bottom": side("borderBottomWeight"), "left": side("borderLeftWeight")}),
+        );
+    }
+}
+
+/// Whether a paint's colour or one of its gradient stops is bound to a variable.
+pub(super) fn paint_bound(p: &Kv) -> bool {
+    alias(p.get("colorVar")).is_some() || p.get("stopsVar").map(Kv::list).unwrap_or_default().iter().any(|s| alias(s.get("colorVar")).is_some())
+}
+
+pub(crate) fn paint(p: &Kv, warn: &mut dyn FnMut(String)) -> Option<Value> {
+    let ty = p.get("type").and_then(Kv::str)?;
+    let mut o = Obj::new();
+    o.insert("type".into(), json!(ty));
+    if let Some(x) = num(p, "opacity") {
+        o.insert("opacity".into(), json!(x));
+    }
+    if let Some(b) = p.get("visible").and_then(Kv::bool) {
+        o.insert("visible".into(), json!(b));
+    }
+    if let Some(b) = p.get("blendMode").and_then(Kv::str) {
+        o.insert("blendMode".into(), json!(b));
+    }
+    let t = p.get("transform").and_then(matrix);
+    match ty {
+        "SOLID" => {
+            if let Some(c) = p.get("color") {
+                o.insert("color".into(), color(c));
+            }
+            if let Some(var) = alias(p.get("colorVar")) {
+                o.insert("boundVariables".into(), json!({"color": {"type": "VARIABLE_ALIAS", "id": var}}));
+            }
+        }
+        _ if ty.starts_with("GRADIENT_") => {
+            // The paint transform maps the layer's unit box to gradient space, where a linear
+            // gradient runs from (0, ½) to (1, ½) and the others are centred on (½, ½).
+            let inv = t.filter(|t| t.determinant().abs() > 1e-12).map_or(Affine::IDENTITY, Affine::inverse);
+            let pts = if ty == "GRADIENT_LINEAR" { [(0.0, 0.5), (1.0, 0.5), (0.0, 1.0)] } else { [(0.5, 0.5), (1.0, 0.5), (0.5, 1.0)] };
+            let handles: Vec<Value> = pts
+                .iter()
+                .map(|(x, y)| {
+                    let q = inv * Point::new(*x, *y);
+                    json!({"x": q.x, "y": q.y})
+                })
+                .collect();
+            o.insert("gradientHandlePositions".into(), Value::Array(handles));
+            // Stops bound to variables are listed again, each with its variable.
+            let vars = p.get("stopsVar").map(Kv::list).unwrap_or_default();
+            let stops: Vec<Value> = p
+                .get("stops")
+                .map(Kv::list)
+                .unwrap_or_default()
+                .iter()
+                .enumerate()
+                .map(|(i, s)| {
+                    let mut stop = json!({"position": num(s, "position").unwrap_or(0.0), "color": s.get("color").map_or(Value::Null, color)});
+                    if let Some(b) = bound(vars.get(i), &[("colorVar", "color")]) {
+                        stop["boundVariables"] = b;
+                    }
+                    stop
+                })
+                .collect();
+            o.insert("gradientStops".into(), Value::Array(stops));
+        }
+        "IMAGE" => {
+            let hash: String =
+                p.get("image").and_then(|i| i.get("hash")).and_then(Kv::bytes).unwrap_or_default().iter().map(|b| format!("{b:02x}")).collect();
+            o.insert("imageRef".into(), json!(hash));
+            let mode = p.get("imageScaleMode").and_then(Kv::str).unwrap_or("FILL");
+            o.insert("scaleMode".into(), json!(mode));
+            if let (Some(t), "STRETCH") = (t, mode) {
+                o.insert("imageTransform".into(), rows(t));
+            }
+            if let Some(s) = num(p, "scale") {
+                o.insert("scalingFactor".into(), json!(s));
+            }
+            if let Some(r) = num(p, "rotation") {
+                o.insert("rotation".into(), json!(r));
+            }
+            match (p.get("filterColorAdjust"), p.get("paintFilter")) {
+                (Some(_), Some(_)) => {
+                    warn("image filters are ambiguous because both filter containers are present; filter conversion was skipped".into())
+                }
+                (Some(_), None) => warn("legacy image filter container is unsupported; filter conversion was skipped".into()),
+                (None, Some(filters)) => {
+                    let mut mapped = Obj::new();
+                    let fields = [
+                        ("exposure", "exposure"),
+                        ("contrast", "contrast"),
+                        ("vibrance", "saturation"),
+                        ("temperature", "temperature"),
+                        ("tint", "tint"),
+                        ("highlights", "highlights"),
+                        ("shadows", "shadows"),
+                    ];
+                    if let Kv::Object(values) = filters {
+                        for (source, target) in fields {
+                            if let Some(value) = filters.get(source) {
+                                match filter_number(value) {
+                                    Some(value) => {
+                                        mapped.insert(target.into(), json!(value));
+                                    }
+                                    None => warn(format!("malformed image filter `{source}` was skipped")),
+                                }
+                            }
+                        }
+                        for (name, value) in values {
+                            if fields.iter().any(|(known, _)| *known == *name) {
+                                continue;
+                            }
+                            match filter_number(value) {
+                                Some(0.0) => {}
+                                Some(_) => warn(format!("nonzero unsupported image filter `{}` was skipped", crate::rest::props::clip_str(name))),
+                                None => warn(format!("malformed unsupported image filter `{}` was skipped", crate::rest::props::clip_str(name))),
+                            }
+                        }
+                    } else {
+                        warn("malformed image paintFilter container was skipped".into());
+                    }
+                    if !mapped.is_empty() {
+                        o.insert("filters".into(), Value::Object(mapped));
+                    }
+                }
+                (None, None) => {}
+            }
+        }
+        _ => {}
+    }
+    Some(Value::Object(o))
+}
+
+/// The variables bound to the fields of a paint stop, an effect or a layout grid, as its REST
+/// `boundVariables`: `fields` pairs the format's field with the REST name.
+pub(super) fn bound(v: Option<&Kv>, fields: &[(&str, &str)]) -> Option<Value> {
+    let v = v?;
+    let found: Obj =
+        fields.iter().filter_map(|(from, to)| Some((to.to_string(), json!({"type": "VARIABLE_ALIAS", "id": alias(v.get(from))?})))).collect();
+    (!found.is_empty()).then_some(Value::Object(found))
+}
+
+pub(super) fn effect(e: &Kv) -> Option<Value> {
+    let ty = match e.get("type").and_then(Kv::str)? {
+        "FOREGROUND_BLUR" => "LAYER_BLUR",
+        "GRAIN" => "TEXTURE",
+        t => t,
+    };
+    let mut o = Obj::new();
+    o.insert("type".into(), json!(ty));
+    for k in ["radius", "spread", "startRadius", "density", "opacity"] {
+        if let Some(x) = num(e, k) {
+            o.insert(k.into(), json!(x));
+        }
+    }
+    for k in ["visible", "showShadowBehindNode", "clipToShape"] {
+        if let Some(b) = e.get(k).and_then(Kv::bool) {
+            o.insert(k.into(), json!(b));
+        }
+    }
+    for k in ["blendMode", "noiseType"] {
+        if let Some(s) = e.get(k).and_then(Kv::str) {
+            o.insert(k.into(), json!(s));
+        }
+    }
+    for k in ["color", "secondaryColor"] {
+        if let Some(c) = e.get(k) {
+            o.insert(k.into(), color(c));
+        }
+    }
+    for (from, to) in [("offset", "offset"), ("startOffset", "startOffset"), ("endOffset", "endOffset"), ("noiseSize", "noiseSizeVector")] {
+        if let Some(p) = e.get(from).and_then(vec2) {
+            o.insert(to.into(), p);
+        }
+    }
+    if e.get("blurOpType").and_then(Kv::str) == Some("PROGRESSIVE") {
+        o.insert("blurType".into(), json!("PROGRESSIVE"));
+    }
+    let vars = [
+        ("colorVar", "color"),
+        ("radiusVar", "radius"),
+        ("spreadVar", "spread"),
+        ("xVar", "offsetX"),
+        ("yVar", "offsetY"),
+        ("startRadiusVar", "startRadius"),
+    ];
+    if let Some(b) = bound(Some(e), &vars) {
+        o.insert("boundVariables".into(), b);
+    }
+    Some(Value::Object(o))
+}
+
+pub(super) fn export_setting(e: &Kv) -> Value {
+    let c = e.get("constraint");
+    let ty = match c.and_then(|c| c.get("type")).and_then(Kv::str) {
+        Some("CONTENT_WIDTH") => "WIDTH",
+        Some("CONTENT_HEIGHT") => "HEIGHT",
+        _ => "SCALE",
+    };
+    json!({
+        "format": e.get("imageType").and_then(Kv::str).unwrap_or("PNG"),
+        "suffix": e.get("suffix").and_then(Kv::str).unwrap_or(""),
+        "constraint": {"type": ty, "value": c.and_then(|c| num(c, "value")).unwrap_or(1.0)},
+    })
+}
diff --git a/crates/format/src/fig/map/proto.rs b/crates/format/src/fig/map/proto.rs
new file mode 100644
index 00000000..d3f5c022
--- /dev/null
+++ b/crates/format/src/fig/map/proto.rs
@@ -0,0 +1,179 @@
+use super::paint::color;
+use super::variables::variable_data;
+use super::*;
+
+impl<'a> Mapper<'a> {
+    pub(super) fn prototype(&mut self, o: &mut Obj, v: &View<'a>) {
+        let mut list = Vec::new();
+        for it in v.list("prototypeInteractions") {
+            if it.get("isDeleted").and_then(Kv::bool) == Some(true) {
+                continue;
+            }
+            if let Some(i) = self.interaction(it) {
+                list.push(i);
+            }
+        }
+        if !list.is_empty() {
+            o.insert("interactions".into(), Value::Array(list));
+        }
+        let overflow = match v.str("scrollDirection") {
+            Some("HORIZONTAL") => Some("HORIZONTAL_SCROLLING"),
+            Some("VERTICAL") => Some("VERTICAL_SCROLLING"),
+            Some("BOTH") => Some("HORIZONTAL_AND_VERTICAL_SCROLLING"),
+            _ => None,
+        };
+        if let Some(d) = overflow {
+            o.insert("overflowDirection".into(), json!(d));
+        }
+        let behavior = match v.str("scrollBehavior") {
+            Some("FIXED_WHEN_CHILD_OF_SCROLLING_FRAME") => Some("FIXED"),
+            Some("STICKY_SCROLLS") => Some("STICKY_SCROLLS"),
+            _ => None,
+        };
+        if let Some(b) = behavior {
+            o.insert("scrollBehavior".into(), json!(b));
+        }
+        copy_str(o, v, "overlayPositionType", "overlayPositionType");
+        copy_str(o, v, "overlayBackgroundInteraction", "overlayBackgroundInteraction");
+        if let Some(a) = v.get("overlayBackgroundAppearance") {
+            let ty = a.get("backgroundType").and_then(Kv::str).unwrap_or("NONE");
+            o.insert("overlayBackground".into(), json!({"type": ty, "color": a.get("backgroundColor").map_or(Value::Null, color)}));
+        }
+    }
+
+    fn interaction(&mut self, it: &Kv) -> Option<Value> {
+        let ev = it.get("event");
+        let ty = match ev.and_then(|e| e.get("interactionType")).and_then(Kv::str).unwrap_or("ON_CLICK") {
+            "DRAG" => "ON_DRAG",
+            "MOUSE_IN" => "MOUSE_ENTER",
+            "MOUSE_OUT" => "MOUSE_LEAVE",
+            t => t,
+        };
+        let mut trigger = json!({"type": ty});
+        if let Some(t) = ev.and_then(|e| num(e, "transitionTimeout")) {
+            // Seconds as 32-bit floats: whole milliseconds.
+            trigger["timeout"] = json!((t * 1000.0).round());
+        }
+        if let Some(k) = ev.and_then(|e| e.get("keyTrigger")) {
+            let codes: Vec<f64> = k.get("keyCodes").map(Kv::list).unwrap_or_default().iter().filter_map(Kv::f64).collect();
+            trigger["keyCodes"] = json!(codes);
+            if let Some(d) = k.get("triggerDevice").and_then(Kv::str) {
+                trigger["device"] = json!(if d.contains("KEYBOARD") { "KEYBOARD" } else { d });
+            }
+        }
+        let actions: Vec<Value> = it.get("actions").map(Kv::list).unwrap_or_default().iter().filter_map(|a| self.action(a, 0)).collect();
+        (!actions.is_empty()).then(|| json!({"trigger": trigger, "actions": actions}))
+    }
+
+    /// One prototype action in the REST shape (`depth`: conditionals it's nested in).
+    fn action(&mut self, a: &Kv, depth: usize) -> Option<Value> {
+        Some(match a.get("connectionType").and_then(Kv::str) {
+            Some("INTERNAL_NODE") | None => {
+                let dest = a.get("transitionNodeID").and_then(guid)?;
+                let nav = match a.get("navigationType").and_then(Kv::str) {
+                    Some("SWAP_STATE") => "CHANGE_TO",
+                    Some(n) => n,
+                    None => "NAVIGATE",
+                };
+                let mut act = json!({"type": "NODE", "destinationId": dest, "navigation": nav});
+                if let Some(t) = transition(a) {
+                    act["transition"] = t;
+                }
+                if let Some(b) = a.get("transitionPreserveScroll").and_then(Kv::bool) {
+                    act["preserveScrollPosition"] = json!(b);
+                }
+                if let Some(p) = a.get("overlayRelativePosition") {
+                    act["overlayRelativePosition"] = json!({"x": num(p, "x"), "y": num(p, "y")});
+                }
+                act
+            }
+            Some("URL") => json!({"type": "URL", "url": a.get("connectionURL").and_then(Kv::str)?}),
+            Some("BACK") => json!({"type": "BACK"}),
+            Some("CLOSE") => json!({"type": "CLOSE"}),
+            Some("NONE") => return None,
+            Some("SET_VARIABLE") => {
+                let var = a.get("targetVariable").and_then(|t| t.get("id")).and_then(ref_guid).or_else(|| a.get("targetVariableID").and_then(guid));
+                // Missing parts are left out: the REST importer skips the action with a warning.
+                let mut act = json!({"type": "SET_VARIABLE", "variableId": var});
+                if let Some(d) = a.get("targetVariableData").and_then(|d| variable_data(d, 0)) {
+                    act["variableValue"] = d;
+                }
+                act
+            }
+            Some("SET_VARIABLE_MODE") => json!({
+                "type": "SET_VARIABLE_MODE",
+                "variableCollectionId": a.get("targetVariableSetID").and_then(ref_guid),
+                "variableModeId": a.get("targetVariableModeID").and_then(guid),
+            }),
+            Some("CONDITIONAL") if depth < MAX_ACTION_DEPTH => {
+                let mut blocks = Vec::new();
+                for b in a.get("conditionalActions").map(Kv::list).unwrap_or_default() {
+                    let actions: Vec<Value> =
+                        b.get("actions").map(Kv::list).unwrap_or_default().iter().filter_map(|x| self.action(x, depth + 1)).collect();
+                    let mut block = json!({"actions": actions});
+                    // A condition that can't be read must not turn the block into an "else".
+                    if let Some(c) = b.get("condition") {
+                        block["condition"] = variable_data(c, 0).unwrap_or_else(|| json!({}));
+                    }
+                    blocks.push(block);
+                }
+                json!({"type": "CONDITIONAL", "conditionalBlocks": blocks})
+            }
+            Some(other) => {
+                self.warn(format!("{} prototype actions are not imported from .fig files yet", other.to_ascii_lowercase().replace('_', " ")));
+                return None;
+            }
+        })
+    }
+}
+
+/// A prototype action's transition (`None`: instant).
+fn transition(a: &Kv) -> Option<Value> {
+    let ty = a.get("transitionType").and_then(Kv::str)?;
+    // Directions name where the incoming screen moves (SLIDE_FROM_LEFT moves right).
+    let (kind, dir) = match ty {
+        "INSTANT_TRANSITION" => return None,
+        "DISSOLVE" | "FADE" => ("DISSOLVE", None),
+        "SMART_ANIMATE" | "MAGIC_MOVE" => ("SMART_ANIMATE", None),
+        "SCROLL_ANIMATE" => ("SCROLL_ANIMATE", None),
+        t => {
+            let prefixes = [
+                ("SLIDE_FROM_", "SLIDE_IN"),
+                ("PUSH_FROM_", "PUSH"),
+                ("MOVE_FROM_", "MOVE_IN"),
+                ("SLIDE_OUT_TO_", "SLIDE_OUT"),
+                ("MOVE_OUT_TO_", "MOVE_OUT"),
+            ];
+            let (kind, side) = prefixes.iter().find_map(|(p, k)| t.strip_prefix(p).map(|r| (*k, r)))?;
+            let incoming = matches!(kind, "SLIDE_IN" | "PUSH" | "MOVE_IN");
+            let dir = match (side, incoming) {
+                ("LEFT", true) | ("RIGHT", false) => "RIGHT",
+                ("RIGHT", true) | ("LEFT", false) => "LEFT",
+                ("TOP", true) | ("BOTTOM", false) => "BOTTOM",
+                _ => "TOP",
+            };
+            (kind, Some(dir))
+        }
+    };
+    let easing = match a.get("easingType").and_then(Kv::str) {
+        Some("IN_CUBIC" | "EASE_IN") => "EASE_IN",
+        Some("INOUT_CUBIC") => "EASE_IN_AND_OUT",
+        Some("LINEAR") => "LINEAR",
+        Some("IN_BACK_CUBIC") => "EASE_IN_BACK",
+        Some("OUT_BACK_CUBIC") => "EASE_OUT_BACK",
+        Some("INOUT_BACK_CUBIC") => "EASE_IN_AND_OUT_BACK",
+        Some("GENTLE_SPRING") => "GENTLE",
+        Some("CUSTOM_CUBIC") => "CUSTOM_CUBIC_BEZIER",
+        _ => "EASE_OUT",
+    };
+    let mut e = json!({"type": easing});
+    let f: Vec<f64> = a.get("easingFunction").map(Kv::list).unwrap_or_default().iter().filter_map(Kv::f64).collect();
+    if let (true, [x1, y1, x2, y2, ..]) = (easing == "CUSTOM_CUBIC_BEZIER", f.as_slice()) {
+        e["easingFunctionCubicBezier"] = json!({"x1": x1, "y1": y1, "x2": x2, "y2": y2});
+    }
+    let mut t = json!({"type": kind, "duration": (num(a, "transitionDuration").unwrap_or(0.3) * 1000.0).round(), "easing": e});
+    if let Some(d) = dir {
+        t["direction"] = json!(d);
+    }
+    Some(t)
+}
diff --git a/crates/format/src/fig/map/text.rs b/crates/format/src/fig/map/text.rs
new file mode 100644
index 00000000..7431fbb5
--- /dev/null
+++ b/crates/format/src/fig/map/text.rs
@@ -0,0 +1,270 @@
+use super::paint::{paint, style_link};
+use super::*;
+
+/// The value from the last override layer holding a valid one for an optional text setting; invalid instance rows fall through.
+fn text_num(v: &View, key: &str) -> Option<f64> {
+    v.layers.iter().rev().find_map(|layer| {
+        layer.get(key).and_then(|value| match value {
+            Kv::Bool(_) => None,
+            _ => value.f64(),
+        })
+    })
+}
+
+fn text_flag(v: &View, key: &str) -> Option<bool> {
+    v.layers.iter().rev().find_map(|layer| layer.get(key).and_then(Kv::bool))
+}
+
+fn insert_text_options(style: &mut Obj, v: &View) {
+    if let Some(value) = text_num(v, "listSpacing") {
+        style.insert("listSpacing".into(), json!(value));
+    }
+    for k in ["hangingList", "hangingPunctuation"] {
+        if let Some(value) = text_flag(v, k) {
+            style.insert(k.into(), json!(value));
+        }
+    }
+    if let Some(value) = leading_trim(v) {
+        style.insert("leadingTrim".into(), json!(value));
+    }
+}
+
+fn leading_trim<'a>(v: &View<'a>) -> Option<&'a str> {
+    v.layers.iter().rev().find_map(|layer| match layer.get("leadingTrim").and_then(Kv::str) {
+        Some(value @ ("NONE" | "CAP_HEIGHT")) => Some(value),
+        _ => None,
+    })
+}
+
+impl<'a> Mapper<'a> {
+    pub(super) fn text(&mut self, o: &mut Obj, v: &View<'a>) {
+        let style_node = style_link(v, "styleIdForText", "inheritTextStyleID").and_then(|s| self.nodes.get(&s).copied());
+        // Instance overrides beat the shared style; the style beats the layer's own copy.
+        let sv = v.styled(style_node.filter(|s| s.get("styleType").and_then(Kv::str) == Some("TEXT")));
+        let td = v.get("textData");
+        let chars = td.and_then(|t| t.get("characters")).and_then(Kv::str).unwrap_or("");
+        o.insert("characters".into(), json!(chars));
+        let mut style = text_style(&sv, None);
+        // The style's typography beats the layer's own copy of it (the copy is stale when the style
+        // changed). The file cannot tell a stale copy of these four values from a deliberate local
+        // one, and "original", "none" and 0 could never be set locally if the style always won, so
+        // a value the layer or an override sets itself is taken as deliberate.
+        if let Some(decoration @ ("NONE" | "UNDERLINE" | "STRIKETHROUGH")) = v.str("textDecoration") {
+            style.insert("textDecoration".into(), json!(decoration));
+        }
+        if let Some(skip_ink) = v.flag("textDecorationSkipInk") {
+            style.insert("textDecorationSkipInk".into(), json!(skip_ink));
+        }
+        if let Some(case @ ("ORIGINAL" | "UPPER" | "LOWER" | "TITLE" | "SMALL_CAPS" | "SMALL_CAPS_FORCED")) = v.str("textCase") {
+            style.insert("textCase".into(), json!(case));
+        }
+        for k in ["textAlignHorizontal", "textAlignVertical", "textAutoResize", "textTruncation"] {
+            copy_str(&mut style, v, k, k);
+        }
+        // Paragraph settings belong to the effective text layer, including explicit zero clears.
+        for k in ["paragraphSpacing", "paragraphIndent"] {
+            copy_num(&mut style, v, k, k);
+        }
+        insert_text_options(&mut style, v);
+        if let Some(n) = v.num("maxLines").filter(|n| *n >= 1.0) {
+            style.insert("maxLines".into(), json!(n));
+        }
+        let size = sv.num("fontSize");
+        if let Some(b) = o.get_mut("style").and_then(|s| s.get_mut("boundVariables")).map(Value::take) {
+            style.insert("boundVariables".into(), b);
+        }
+        o.insert("style".into(), Value::Object(style));
+        let Some(td) = td else { return };
+        char_styles(o, td, size, &mut |w| self.warn(w));
+        let raw = td.get("lines").map(Kv::list).unwrap_or_default();
+        let lines: Vec<&str> = raw
+            .iter()
+            .map(|l| match l.get("lineType").and_then(Kv::str) {
+                Some("ORDERED_LIST") => "ORDERED",
+                Some("UNORDERED_LIST") => "UNORDERED",
+                _ => "NONE",
+            })
+            .collect();
+        if lines.iter().any(|l| *l != "NONE") {
+            o.insert("lineTypes".into(), json!(lines));
+        }
+        // Where a numbered list starts counting, less one (not a REST field).
+        let starts: Vec<u32> =
+            raw.iter().map(|l| num(l, "listStartOffset").filter(|n| n.is_finite()).map_or(0, |n| n.clamp(0.0, f64::from(u32::MAX)) as u32)).collect();
+        if starts.iter().any(|n| *n > 0) {
+            o.insert("listStartOffsets".into(), json!(starts));
+        }
+    }
+
+    /// Carry supported text-path data through the private .fig REST ingress only.
+    pub(super) fn text_path(&mut self, o: &mut Obj, v: &View<'a>) {
+        let fail = |this: &mut Self, reason: &str| {
+            this.warn(format!("text path {reason}; text imports off its path"));
+        };
+        let Some(start) = v.get("textPathStart") else {
+            fail(self, "has no start data");
+            return;
+        };
+        let (Some(t), Some(forward)) = (num(start, "tValue"), start.get("forward").and_then(Kv::bool)) else {
+            fail(self, "has invalid start data");
+            return;
+        };
+        let Some(vd) = v.get("vectorData") else {
+            fail(self, "has no vector data");
+            return;
+        };
+        let Some(blob) = num(vd, "vectorNetworkBlob")
+            .filter(|i| i.is_finite() && *i >= 0.0 && i.fract() == 0.0)
+            .and_then(|i| usize::try_from(i as u64).ok())
+            .and_then(|i| self.blobs.get(i))
+            .copied()
+        else {
+            fail(self, "has no vector network");
+            return;
+        };
+        let Some(net) = network::decode(blob) else {
+            fail(self, "has damaged vector data");
+            return;
+        };
+        let Some(norm) = vd.get("normalizedSize") else {
+            fail(self, "has invalid normalized size");
+            return;
+        };
+        let Some(size) = v.get("size") else {
+            fail(self, "has invalid dimensions");
+            return;
+        };
+        let (Some(nx), Some(ny), Some(w), Some(h)) = (num(norm, "x"), num(norm, "y"), num(size, "x"), num(size, "y")) else {
+            fail(self, "has invalid dimensions");
+            return;
+        };
+        let axis_scale = |size: f64, normalized: f64, values: &[f64]| -> Option<f64> {
+            if !size.is_finite() || size < 0.0 || !normalized.is_finite() || normalized < 0.0 {
+                return None;
+            }
+            if normalized > 1e-9 {
+                if size <= 0.0 {
+                    return None;
+                }
+                return Some(size / normalized);
+            }
+            (size == 0.0 && values.iter().all(|v| *v == 0.0)).then_some(1.0)
+        };
+        let xs: Vec<f64> = net.vertices.iter().map(|p| p.x).chain(net.segments.iter().flat_map(|s| [s.ta.0, s.tb.0])).collect();
+        let ys: Vec<f64> = net.vertices.iter().map(|p| p.y).chain(net.segments.iter().flat_map(|s| [s.ta.1, s.tb.1])).collect();
+        let sx = axis_scale(w, nx, &xs);
+        let sy = axis_scale(h, ny, &ys);
+        let (Some(sx), Some(sy)) = (sx, sy) else {
+            fail(self, "has invalid path scale");
+            return;
+        };
+        if v.str("textAlignVertical").is_some_and(|x| x != "TOP") {
+            fail(self, "uses unsupported vertical placement");
+            return;
+        }
+        if v.get("textData").and_then(|td| td.get("characters")).and_then(Kv::str).is_some_and(|s| s.chars().any(|c| matches!(c, '\n' | '\r'))) {
+            fail(self, "contains multiple lines");
+            return;
+        }
+        let path = match crate::fig::text_path::from_network(&net, sx, sy, t, forward) {
+            Ok(path) => path,
+            Err(reason) => {
+                fail(self, reason);
+                return;
+            }
+        };
+        let has_decoration = |style: &Value| style.get("textDecoration").and_then(Value::as_str).is_some_and(|x| x != "NONE");
+        let decorated = o.get("style").is_some_and(has_decoration)
+            || o.get("styleOverrideTable").and_then(Value::as_object).into_iter().flat_map(|styles| styles.values()).any(has_decoration);
+        if decorated {
+            self.warn("text path underline or strikethrough decoration is not rendered");
+        }
+        o.insert("_figTextPath".into(), json!({"d": path.d, "start": path.start, "flip": path.flip}));
+    }
+}
+
+/// Per-character styles of text data `td` (`characterStyleIDs` + `styleOverrideTable`) as REST
+/// `characterStyleOverrides` + `styleOverrideTable`; `size`: the base font size.
+pub(super) fn char_styles(o: &mut Obj, td: &Kv, size: Option<f64>, warn: &mut dyn FnMut(String)) {
+    let ids: Vec<u64> = td.get("characterStyleIDs").map(Kv::list).unwrap_or_default().iter().filter_map(Kv::f64).map(|i| i as u64).collect();
+    if ids.iter().all(|i| *i == 0) {
+        return;
+    }
+    let mut table = Obj::new();
+    for e in td.get("styleOverrideTable").map(Kv::list).unwrap_or_default() {
+        let Some(sid) = num(e, "styleID") else { continue };
+        let mut s = text_style(&View::of(e), size);
+        if let Some(fills) = e.get("fillPaints") {
+            s.insert("fills".into(), Value::Array(fills.list().iter().filter_map(|p| paint(p, warn)).collect()));
+        }
+        table.insert((sid as u64).to_string(), Value::Object(s));
+    }
+    o.insert("characterStyleOverrides".into(), json!(ids));
+    o.insert("styleOverrideTable".into(), Value::Object(table));
+}
+
+/// The REST TypeStyle fields a node (or text override entry) sets. `size`: the font size that
+/// letter spacing in percent refers to when the entry doesn't set one.
+fn text_style(v: &View, size: Option<f64>) -> Obj {
+    let mut s = Obj::new();
+    if let Some(f) = v.get("fontName") {
+        for (from, to) in [("family", "fontFamily"), ("style", "fontStyle"), ("postscript", "fontPostScriptName")] {
+            if let Some(x) = f.get(from).and_then(Kv::str).filter(|x| !x.is_empty()) {
+                // Compact and spaced style names ("SemiBold", "Semi Bold") are the same style.
+                s.insert(to.into(), if from == "style" { json!(crate::fig::style_name(x)) } else { json!(x) });
+            }
+        }
+    }
+    copy_num(&mut s, v, "fontSize", "fontSize");
+    copy_num(&mut s, v, "paragraphSpacing", "paragraphSpacing");
+    copy_num(&mut s, v, "paragraphIndent", "paragraphIndent");
+    insert_text_options(&mut s, v);
+    copy_str(&mut s, v, "textCase", "textCase");
+    copy_str(&mut s, v, "textDecoration", "textDecoration");
+    if let Some(skip_ink) = v.flag("textDecorationSkipInk") {
+        s.insert("textDecorationSkipInk".into(), json!(skip_ink));
+    }
+    copy_str(&mut s, v, "leadingTrim", "leadingTrim");
+    let font_size = v.num("fontSize").or(size).unwrap_or(12.0);
+    if let Some(ls) = v.get("letterSpacing") {
+        let val = num(ls, "value").unwrap_or(0.0);
+        let px = match ls.get("units").and_then(Kv::str) {
+            Some("PIXELS") => val,
+            Some("PERCENT") => {
+                // Private (read by `rest/text.rs`): REST spacing is in pixels; keep the percent.
+                s.insert("_letterSpacingPercent".into(), json!(val));
+                val / 100.0 * font_size
+            }
+            _ => val * font_size,
+        };
+        s.insert("letterSpacing".into(), json!(px));
+    }
+    if let Some(lh) = v.get("lineHeight") {
+        let val = num(lh, "value").unwrap_or(100.0);
+        match lh.get("units").and_then(Kv::str) {
+            Some("PIXELS") => {
+                s.insert("lineHeightUnit".into(), json!("PIXELS"));
+                s.insert("lineHeightPx".into(), json!(val));
+            }
+            // shortcut: percent units count from the font's own line height (100 % is "auto"), which
+            // the document can only say for 100 %; other values read as % of the font size. Upgrade
+            // when line heights can be a share of the font's own.
+            Some("PERCENT") if (val - 100.0).abs() < 1e-6 => {
+                s.insert("lineHeightUnit".into(), json!("INTRINSIC_%"));
+            }
+            Some("PERCENT") => {
+                s.insert("lineHeightUnit".into(), json!("FONT_SIZE_%"));
+                s.insert("lineHeightPercentFontSize".into(), json!(val));
+            }
+            _ => {
+                s.insert("lineHeightUnit".into(), json!("FONT_SIZE_%"));
+                s.insert("lineHeightPercentFontSize".into(), json!(val * 100.0));
+            }
+        }
+    }
+    // An empty URL is kept: on an override entry it clears the text's own link.
+    if let Some(u) = v.get("hyperlink").and_then(|h| h.get("url")).and_then(Kv::str) {
+        s.insert("hyperlink".into(), json!({"type": "URL", "url": u}));
+    }
+    s
+}
diff --git a/crates/format/src/fig/map/variables.rs b/crates/format/src/fig/map/variables.rs
new file mode 100644
index 00000000..d27c834b
--- /dev/null
+++ b/crates/format/src/fig/map/variables.rs
@@ -0,0 +1,164 @@
+use super::paint::color;
+use super::*;
+
+impl<'a> Mapper<'a> {
+    pub(super) fn variable_bindings(&mut self, o: &mut Obj, v: &View<'a>) {
+        let mut bound = Obj::new();
+        let mut text_bound = Obj::new();
+        for e in v.get("variableConsumptionMap").and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default() {
+            let Some(var) = alias(e.get("variableData")) else { continue };
+            let a = json!({"type": "VARIABLE_ALIAS", "id": var});
+            let field = e.get("variableField").and_then(Kv::str).unwrap_or("");
+            match (binding_key(field), text_binding_key(field)) {
+                (Some(k), _) => {
+                    bound.insert(k.into(), a);
+                }
+                (_, Some(k)) => {
+                    text_bound.insert(k.into(), a);
+                }
+                _ if field == "CORNER_RADIUS" => {
+                    for k in ["topLeftRadius", "topRightRadius", "bottomLeftRadius", "bottomRightRadius"] {
+                        bound.insert(k.into(), a.clone());
+                    }
+                }
+                _ if field.starts_with("BORDER_") => {
+                    let side = match field {
+                        "BORDER_TOP_WEIGHT" => "strokeTopWeight",
+                        "BORDER_RIGHT_WEIGHT" => "strokeRightWeight",
+                        "BORDER_BOTTOM_WEIGHT" => "strokeBottomWeight",
+                        _ => "strokeLeftWeight",
+                    };
+                    bound.insert(side.into(), a);
+                }
+                _ if field == "WIDTH" || field == "HEIGHT" => {
+                    let axis = if field == "WIDTH" { "x" } else { "y" };
+                    let size = bound.entry("size").or_insert_with(|| json!({}));
+                    size[axis] = a;
+                }
+                _ => self.warn(format!("variables bound to {} are not imported from .fig files yet", field.to_ascii_lowercase().replace('_', " "))),
+            }
+        }
+        if !bound.is_empty() {
+            o.insert("boundVariables".into(), Value::Object(bound));
+        }
+        // (The text style itself is added after this: it keeps these.)
+        if !text_bound.is_empty() {
+            o.insert("style".into(), json!({"boundVariables": text_bound}));
+        }
+        let mut modes = Obj::new();
+        let mut lost = false;
+        for e in v.get("variableModeBySetMap").and_then(|m| m.get("entries")).map(Kv::list).unwrap_or_default() {
+            let (Some(set), Some(mode)) = (e.get("variableSetID"), e.get("variableModeID").and_then(guid)) else { continue };
+            match self.resource_id(set) {
+                Some(id) => {
+                    modes.insert(id, json!(mode));
+                }
+                // A mode of a collection neither named by guid nor resolvable in the file.
+                None if set.get("guid").is_some() || set.get("assetRef").is_some() => lost = true,
+                None => {}
+            }
+        }
+        if lost {
+            self.warn("variable modes of collections that aren't in the file were skipped");
+        }
+        if !modes.is_empty() {
+            o.insert("explicitVariableModes".into(), Value::Object(modes));
+        }
+    }
+}
+
+/// The REST `boundVariables` key of a bound layer field.
+fn binding_key(field: &str) -> Option<&'static str> {
+    Some(match field {
+        "STROKE_WEIGHT" => "strokeWeight",
+        "STACK_SPACING" => "itemSpacing",
+        "STACK_COUNTER_SPACING" => "counterAxisSpacing",
+        "STACK_PADDING_LEFT" => "paddingLeft",
+        "STACK_PADDING_TOP" => "paddingTop",
+        "STACK_PADDING_RIGHT" => "paddingRight",
+        "STACK_PADDING_BOTTOM" => "paddingBottom",
+        "VISIBLE" => "visible",
+        "TEXT_DATA" => "characters",
+        "OPACITY" => "opacity",
+        "MIN_WIDTH" => "minWidth",
+        "MAX_WIDTH" => "maxWidth",
+        "MIN_HEIGHT" => "minHeight",
+        "MAX_HEIGHT" => "maxHeight",
+        "RECTANGLE_TOP_LEFT_CORNER_RADIUS" => "topLeftRadius",
+        "RECTANGLE_TOP_RIGHT_CORNER_RADIUS" => "topRightRadius",
+        "RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS" => "bottomLeftRadius",
+        "RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS" => "bottomRightRadius",
+        _ => return None,
+    })
+}
+
+/// The REST text style `boundVariables` key of a bound text field.
+fn text_binding_key(field: &str) -> Option<&'static str> {
+    Some(match field {
+        "FONT_SIZE" => "fontSize",
+        "FONT_FAMILY" => "fontFamily",
+        "FONT_STYLE" => "fontStyle",
+        "LETTER_SPACING" => "letterSpacing",
+        "LINE_HEIGHT" => "lineHeight",
+        "PARAGRAPH_SPACING" => "paragraphSpacing",
+        "PARAGRAPH_INDENT" => "paragraphIndent",
+        _ => return None,
+    })
+}
+
+/// A `VariableData` (literal, variable reference or expression) in the REST shape; `None` for
+/// kinds a prototype can't evaluate.
+pub(super) fn variable_data(d: &Kv, depth: usize) -> Option<Value> {
+    let v = d.get("value")?;
+    let ty = d.get("dataType").and_then(Kv::str)?;
+    let value = match ty {
+        "ALIAS" => json!({"type": "VARIABLE_ALIAS", "id": v.get("alias").and_then(ref_guid)?}),
+        "EXPRESSION" if depth < MAX_EXPR_DEPTH => {
+            let e = v.get("expressionValue")?;
+            let function = match e.get("expressionFunction").and_then(Kv::str)? {
+                "MULTIPLY" => "MULTIPLICATION",
+                "DIVIDE" => "DIVISION",
+                f => f,
+            };
+            let args = e.get("expressionArguments").map(Kv::list).unwrap_or_default();
+            let args = args.iter().map(|x| variable_data(x, depth + 1)).collect::<Option<Vec<Value>>>()?;
+            json!({"expressionFunction": function, "expressionArguments": args})
+        }
+        "BOOLEAN" => json!(v.get("boolValue").and_then(Kv::bool)?),
+        "FLOAT" => json!(num(v, "floatValue").filter(|x| x.is_finite())?),
+        "STRING" => json!(v.get("textValue").and_then(Kv::str)?),
+        "COLOR" => color(v.get("colorValue")?),
+        _ => return None,
+    };
+    let mut out = json!({"type": ty, "value": value});
+    if let Some(r) = d.get("resolvedDataType").and_then(Kv::str) {
+        out["resolvedType"] = json!(r);
+    }
+    Some(out)
+}
+
+/// The variable an `ALIAS` variable data points at.
+pub(super) fn alias(d: Option<&Kv>) -> Option<String> {
+    let d = d?;
+    if d.get("dataType").and_then(Kv::str) != Some("ALIAS") {
+        return None;
+    }
+    d.get("value").and_then(|v| v.get("alias")).and_then(ref_guid)
+}
+
+pub(super) fn variable_value(d: &Kv) -> Option<Value> {
+    if let Some(a) = alias(Some(d)) {
+        return Some(json!({"type": "VARIABLE_ALIAS", "id": a}));
+    }
+    let v = d.get("value")?;
+    if let Some(c) = v.get("colorValue") {
+        return Some(color(c));
+    }
+    if let Some(b) = v.get("boolValue").and_then(Kv::bool) {
+        return Some(json!(b));
+    }
+    if let Some(x) = num(v, "floatValue") {
+        return Some(json!(x));
+    }
+    v.get("textValue").and_then(Kv::str).map(|s| json!(s))
+}

From 064e6be65fc856bffdd4e48bedbbb321b0d161b0 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:03:41 +0000
Subject: [PATCH 48/67] refactor(format): split fig/export.rs into export/

---
 crates/format/src/fig/export.rs           | 2225 +--------------------
 crates/format/src/fig/export/assets.rs    |  365 ++++
 crates/format/src/fig/export/common.rs    |  365 ++++
 crates/format/src/fig/export/component.rs |  324 +++
 crates/format/src/fig/export/layer.rs     |  440 ++++
 crates/format/src/fig/export/paint.rs     |  239 +++
 crates/format/src/fig/export/prototype.rs |  174 ++
 crates/format/src/fig/export/shape.rs     |  341 ++++
 8 files changed, 2256 insertions(+), 2217 deletions(-)
 create mode 100644 crates/format/src/fig/export/assets.rs
 create mode 100644 crates/format/src/fig/export/common.rs
 create mode 100644 crates/format/src/fig/export/component.rs
 create mode 100644 crates/format/src/fig/export/layer.rs
 create mode 100644 crates/format/src/fig/export/paint.rs
 create mode 100644 crates/format/src/fig/export/prototype.rs
 create mode 100644 crates/format/src/fig/export/shape.rs

diff --git a/crates/format/src/fig/export.rs b/crates/format/src/fig/export.rs
index 8343a4ff..b475a9cb 100644
--- a/crates/format/src/fig/export.rs
+++ b/crates/format/src/fig/export.rs
@@ -37,6 +37,14 @@ use super::kiwi::{Kv, Schema, encode};
 use super::network;
 use crate::FormatError;
 
+mod assets;
+mod common;
+mod component;
+mod layer;
+mod paint;
+mod prototype;
+mod shape;
+
 /// Most layers written, and deepest nesting followed (the import's limits).
 const MAX_NODES: usize = crate::rest::MAX_NODES;
 const MAX_DEPTH: usize = 256;
@@ -598,2062 +606,10 @@ impl<'d> Exporter<'d> {
             ("blobs", arr(blobs.into_iter().map(|(_, bytes)| o(vec![("bytes", Kv::Bytes(bytes))])).collect())),
         ])
     }
-
-    /// GUIDs for every layer (pages first, then depth-first), component property definitions,
-    /// flow starting points and overlay settings, before anything refers to them.
-    fn assign(&mut self) {
-        let doc = self.doc;
-        let mut stack: Vec<NodeId> = doc.pages.iter().rev().copied().collect();
-        while let Some(id) = stack.pop() {
-            let Some(n) = doc.node(id) else { continue };
-            if self.ids.len() >= MAX_NODES {
-                self.warn("the document has more layers than a .fig file is read with; the rest were left out");
-                break;
-            }
-            let local = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
-            self.ids.insert(id, local);
-            // An instance's layers aren't written (its main says them), so nothing may refer to them.
-            let mirrored = matches!(&n.kind, NodeKind::Instance { component, .. } if doc.node(*component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })));
-            if !mirrored {
-                stack.extend(n.children.iter().rev());
-            }
-            match &n.kind {
-                NodeKind::Component { props, .. } => {
-                    let set = self.set_of(id);
-                    let owner = set.unwrap_or(id);
-                    for (name, d) in props {
-                        if let Some(ty) = prop_type(d) {
-                            let key = (owner, name.clone(), ty);
-                            if !self.defs.contains_key(&key) {
-                                let def = self.next_aux();
-                                self.defs.insert(key, def);
-                            }
-                            if set.is_some() {
-                                let child = self.next_aux();
-                                self.child_defs.insert((id, name.clone(), ty), child);
-                            }
-                        }
-                    }
-                    if let Some(set) = set {
-                        for (prop, _) in variant_pairs(&n.name) {
-                            let key = (set, prop, "VARIANT");
-                            if !self.defs.contains_key(&key) {
-                                let def = self.next_aux();
-                                self.defs.insert(key, def);
-                            }
-                        }
-                    }
-                }
-                NodeKind::Page { flows, .. } => {
-                    for (i, f) in flows.iter().enumerate() {
-                        self.starts.entry(f.start).or_insert((i, f.name.clone()));
-                    }
-                }
-                _ => {}
-            }
-            for a in n.interactions.iter().flat_map(|it| figcraft_doc::proto::walk(&it.actions)) {
-                if let Action::OpenOverlay { dest, position, close_on_outside, background, anchor, .. } = a {
-                    let position = if !anchor.is_screen() && *position != OverlayPosition::Manual { OverlayPosition::Manual } else { *position };
-                    let o = Overlay { position, close_on_outside: *close_on_outside, background: *background };
-                    match self.overlays.get(dest) {
-                        Some(old) if (old.position, old.close_on_outside, old.background) != (o.position, o.close_on_outside, o.background) => {
-                            self.warn("overlays opened with different settings keep the first one's");
-                        }
-                        Some(_) => {}
-                        None => {
-                            self.overlays.insert(*dest, o);
-                        }
-                    }
-                }
-            }
-        }
-        // The page that holds styles and variables takes the next id, then their nodes.
-        let mut next = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
-        let mut node = || {
-            next = next.saturating_add(1);
-            next
-        };
-        for st in &doc.styles {
-            self.style_ids.entry(st.id.as_str()).or_insert_with(&mut node);
-        }
-        for c in &doc.variables.collections {
-            self.set_ids.entry(c.id.as_str()).or_insert_with(&mut node);
-        }
-        for v in &doc.variables.variables {
-            if self.set_ids.contains_key(v.collection.as_str()) {
-                self.var_ids.entry(v.id.as_str()).or_insert_with(&mut node);
-            }
-        }
-        for c in &doc.variables.collections {
-            for m in &c.modes {
-                if !self.mode_ids.contains_key(&(c.id.as_str(), m.id.as_str())) {
-                    let id = self.next_aux();
-                    self.mode_ids.insert((c.id.as_str(), m.id.as_str()), id);
-                }
-            }
-        }
-    }
-
-    /// The hidden page after the `pages` real ones that holds the shared styles, the variable
-    /// collections and the variables, each a node of its own.
-    fn assets(&mut self, pages: usize) {
-        let doc = self.doc;
-        if self.style_ids.is_empty() && self.set_ids.is_empty() {
-            return;
-        }
-        let page = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
-        let mut f: Fields = vec![
-            ("guid", guid(LAYERS, page)),
-            ("phase", e("CREATED")),
-            ("parentIndex", o(vec![("guid", guid(0, 0)), ("position", s(&position(pages)))])),
-            ("type", e("CANVAS")),
-            ("name", s("Internal Only Canvas")),
-        ];
-        f.extend(root_fields().into_iter().map(|(k, v)| if k == "visible" { (k, b(false)) } else { (k, v) }));
-        f.push(("internalOnly", b(true)));
-        self.nodes.push(o(f));
-        let mut index = 0usize;
-        let mut head = |local: u32, ty: &'static str, name: &str| -> Fields {
-            index += 1;
-            vec![
-                ("guid", guid(LAYERS, local)),
-                ("phase", e("CREATED")),
-                ("parentIndex", o(vec![("guid", guid(LAYERS, page)), ("position", s(&position(index)))])),
-                ("type", e(ty)),
-                ("name", s(name)),
-                ("sortPosition", s(&position(index))),
-            ]
-        };
-        for st in &doc.styles {
-            let Some(&local) = self.style_ids.get(st.id.as_str()) else { continue };
-            // A sample layer that shows the style: a square for paints and effects, a frame for
-            // grids, two letters for text.
-            let (ty, kind) = match &st.kind {
-                StyleKind::Paint { .. } => ("ROUNDED_RECTANGLE", "FILL"),
-                StyleKind::Effect { .. } => ("ROUNDED_RECTANGLE", "EFFECT"),
-                StyleKind::Grid { .. } => ("FRAME", "GRID"),
-                StyleKind::Text { .. } => ("TEXT", "TEXT"),
-            };
-            let mut f = head(local, ty, &st.name);
-            f.extend([
-                ("styleType", e(kind)),
-                ("visible", b(true)),
-                ("opacity", fl(1.0)),
-                ("size", xy(100.0, 100.0)),
-                ("transform", matrix(Affine::IDENTITY)),
-                ("strokeWeight", fl(0.0)),
-                ("strokeAlign", e("INSIDE")),
-                ("strokeJoin", e("MITER")),
-            ]);
-            if !st.description.is_empty() {
-                f.push(("description", s(&st.description)));
-            }
-            // The style's variable bindings ride on its sample layer, as a layer's do.
-            let none = if st.bound.is_empty() {
-                Bound::default()
-            } else {
-                let mut sample = Node::new(NodeId(0), NodeKind::Rectangle, "", 0.0, 0.0);
-                if let StyleKind::Text { style } = &st.kind {
-                    sample.kind = NodeKind::Text(TextData { style: style.as_text_style(), ..TextData::new("Ag") });
-                }
-                sample.bound.clone_from(&st.bound);
-                self.bound(&sample)
-            };
-            let entries = none.entries.clone();
-            if !entries.is_empty() {
-                f.push(("variableConsumptionMap", o(vec![("entries", arr(entries))])));
-            }
-            match &st.kind {
-                StyleKind::Paint { paints } => f.push(("fillPaints", self.paints(paints, true, &none))),
-                StyleKind::Effect { effects } => {
-                    let list = effects.iter().enumerate().map(|(i, x)| self.effect(x, i, &none)).collect();
-                    f.extend([("fillPaints", arr(Vec::new())), ("effects", arr(list))]);
-                }
-                StyleKind::Grid { grids } => {
-                    let list = grids.iter().enumerate().map(|(i, g)| layout_grid(g, i, &none)).collect();
-                    f.extend([("fillPaints", arr(Vec::new())), ("layoutGrids", arr(list))]);
-                }
-                StyleKind::Text { style } => {
-                    let td = TextData { style: style.as_text_style(), ..TextData::new("Ag") };
-                    let fills = [Paint::solid(Color::BLACK)];
-                    f.push(("fillPaints", self.paints(style.fills.as_deref().unwrap_or(&fills), true, &none)));
-                    self.text(&td, &fills, &mut f);
-                }
-            }
-            self.nodes.push(o(f));
-        }
-        for c in &doc.variables.collections {
-            let Some(&local) = self.set_ids.get(c.id.as_str()) else { continue };
-            let mut f = head(local, "VARIABLE_SET", &c.name);
-            let modes = c.modes.iter().enumerate().filter_map(|(i, m)| {
-                let id = self.mode_ids.get(&(c.id.as_str(), m.id.as_str()))?;
-                Some(o(vec![("id", guid(AUX, *id)), ("name", s(&m.name)), ("sortPosition", s(&position(i)))]))
-            });
-            f.push(("variableSetModes", arr(modes.collect())));
-            self.nodes.push(o(f));
-            if c.extends.is_some() {
-                self.warn("extended variable collections were written as collections of their own");
-            }
-        }
-        for v in &doc.variables.variables {
-            let ids = (self.var_ids.get(v.id.as_str()), self.set_ids.get(v.collection.as_str()));
-            let (Some(&local), Some(&set), Some(c)) = (ids.0, ids.1, doc.variables.collections.iter().find(|c| c.id == v.collection)) else {
-                self.warn("variables whose collection isn't in the document were left out");
-                continue;
-            };
-            let resolved = resolved_type(v.kind);
-            let mut values = Vec::new();
-            for m in &c.modes {
-                let (Some(mode), Some(val)) = (self.mode_ids.get(&(c.id.as_str(), m.id.as_str())), v.values.get(&m.id)) else { continue };
-                let (ty, value) = match val {
-                    VariableValue::Color(x) => ("COLOR", ("colorValue", color(*x))),
-                    VariableValue::Number(x) => ("FLOAT", ("floatValue", fl(*x))),
-                    // NULs can't be stored in a string.
-                    VariableValue::String(x) => ("STRING", ("textValue", s(&x.replace('\0', "")))),
-                    VariableValue::Boolean(x) => ("BOOLEAN", ("boolValue", b(*x))),
-                    VariableValue::Alias(a) => match self.var_ids.get(a.as_str()) {
-                        Some(t) => ("ALIAS", ("alias", o(vec![("guid", guid(LAYERS, *t))]))),
-                        None => {
-                            self.warn("variable aliases to variables that aren't in the document were left out");
-                            continue;
-                        }
-                    },
-                };
-                let data = o(vec![("value", o(vec![value])), ("dataType", e(ty)), ("resolvedDataType", e(resolved))]);
-                values.push(o(vec![("modeID", guid(AUX, *mode)), ("variableData", data)]));
-            }
-            let mut f = head(local, "VARIABLE", &v.name);
-            f.extend([
-                ("variableSetID", o(vec![("guid", guid(LAYERS, set))])),
-                ("variableResolvedType", e(resolved)),
-                ("variableDataValues", o(vec![("entries", arr(values))])),
-            ]);
-            if !v.description.is_empty() {
-                f.push(("description", s(&v.description)));
-            }
-            if let Some(scopes) = &v.scopes {
-                let known: Vec<Kv> = scopes.iter().filter_map(|sc| scope_name(sc)).map(e).collect();
-                if known.len() < scopes.len() {
-                    self.warn("variable scopes the format has no name for were left out");
-                }
-                f.push(("variableScopes", arr(known)));
-            }
-            if v.hidden_from_publishing || !v.code_syntax.is_empty() || v.extends.is_some() {
-                self.warn("variables' publishing, code syntax and inheritance settings were left out");
-            }
-            self.nodes.push(o(f));
-        }
-    }
-
-    /// A reference to variable `var` (its id or name) as variable data.
-    fn alias(&mut self, var: &str) -> Option<Kv<'static>> {
-        let found = self.doc.variables.get(var).and_then(|v| Some((v.kind, *self.var_ids.get(v.id.as_str())?)));
-        let Some((kind, local)) = found else {
-            self.warn("bindings to variables that aren't in the document were written as their values");
-            return None;
-        };
-        Some(o(vec![
-            ("value", o(vec![("alias", o(vec![("guid", guid(LAYERS, local))]))])),
-            ("dataType", e("ALIAS")),
-            ("resolvedDataType", e(resolved_type(kind))),
-        ]))
-    }
-
-    /// Layer `n`'s variable bindings, sorted into the fields that carry them. What the format has
-    /// no field for stays as the value the layer already shows, with a warning.
-    fn bound(&mut self, n: &Node) -> Bound {
-        const BAKED: &str = "variables bound to properties the format has no field for were written as their values";
-        let mut out = Bound::default();
-        for (key, var) in &n.bound {
-            let parts: Vec<&str> = key.split('/').collect();
-            let index = |i: &str| i.parse::<usize>().ok().filter(|_| i.bytes().all(|c| c.is_ascii_digit()));
-            let fields: &[&'static str] = match (parts.as_slice(), key.as_str()) {
-                (_, "fill" | "fills" | "fills/0" | "stroke") => {
-                    if let Some(a) = self.alias(var) {
-                        out.paints.insert((key != "stroke", 0), a);
-                    }
-                    continue;
-                }
-                ([list @ ("fills" | "strokes"), i, "color"], _) => {
-                    if let (Some(i), Some(a)) = (index(i), self.alias(var)) {
-                        out.paints.insert((*list == "fills", i), a);
-                    }
-                    continue;
-                }
-                ([list @ ("fills" | "strokes"), i, "stops", j, "color"], _) => {
-                    if let (Some(i), Some(j), Some(a)) = (index(i), index(j), self.alias(var)) {
-                        out.stops.insert((*list == "fills", i, j), a);
-                    }
-                    continue;
-                }
-                ([list @ ("effects" | "layoutGrids"), i, field], _) => {
-                    let names: &[&'static str] = if *list == "effects" {
-                        &["color", "radius", "spread", "offsetX", "offsetY", "startRadius"]
-                    } else {
-                        &["size", "count", "gutter", "offset"]
-                    };
-                    match (index(i), names.iter().find(|f| *f == field)) {
-                        (Some(i), Some(name)) => {
-                            if let Some(a) = self.alias(var) {
-                                if *list == "effects" { &mut out.effects } else { &mut out.grids }.insert((i, *name), a);
-                            }
-                        }
-                        _ => self.warn(BAKED),
-                    }
-                    continue;
-                }
-                (_, "width") => &["WIDTH"],
-                (_, "height") => &["HEIGHT"],
-                (_, "gap") => &["STACK_SPACING"],
-                (_, "crossGap") => &["STACK_COUNTER_SPACING"],
-                (_, "paddingLeft") => &["STACK_PADDING_LEFT"],
-                (_, "paddingTop") => &["STACK_PADDING_TOP"],
-                (_, "paddingRight") => &["STACK_PADDING_RIGHT"],
-                (_, "paddingBottom") => &["STACK_PADDING_BOTTOM"],
-                (_, "paddingHorizontal") => &["STACK_PADDING_LEFT", "STACK_PADDING_RIGHT"],
-                (_, "paddingVertical") => &["STACK_PADDING_TOP", "STACK_PADDING_BOTTOM"],
-                (_, "padding") => &["STACK_PADDING_LEFT", "STACK_PADDING_TOP", "STACK_PADDING_RIGHT", "STACK_PADDING_BOTTOM"],
-                (_, "cornerRadius") => &[
-                    "CORNER_RADIUS",
-                    "RECTANGLE_TOP_LEFT_CORNER_RADIUS",
-                    "RECTANGLE_TOP_RIGHT_CORNER_RADIUS",
-                    "RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS",
-                    "RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS",
-                ],
-                (_, "topLeftRadius") => &["RECTANGLE_TOP_LEFT_CORNER_RADIUS"],
-                (_, "topRightRadius") => &["RECTANGLE_TOP_RIGHT_CORNER_RADIUS"],
-                (_, "bottomLeftRadius") => &["RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS"],
-                (_, "bottomRightRadius") => &["RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS"],
-                (_, "opacity") => &["OPACITY"],
-                (_, "visible") => &["VISIBLE"],
-                (_, "characters") => &["TEXT_DATA"],
-                (_, "strokeWeight") => &["STROKE_WEIGHT"],
-                (_, "strokeTopWeight") => &["BORDER_TOP_WEIGHT"],
-                (_, "strokeRightWeight") => &["BORDER_RIGHT_WEIGHT"],
-                (_, "strokeBottomWeight") => &["BORDER_BOTTOM_WEIGHT"],
-                (_, "strokeLeftWeight") => &["BORDER_LEFT_WEIGHT"],
-                (_, "minWidth") => &["MIN_WIDTH"],
-                (_, "maxWidth") => &["MAX_WIDTH"],
-                (_, "minHeight") => &["MIN_HEIGHT"],
-                (_, "maxHeight") => &["MAX_HEIGHT"],
-                (_, "fontSize") => &["FONT_SIZE"],
-                (_, "fontFamily") => &["FONT_FAMILY"],
-                (_, "fontStyle") => &["FONT_STYLE"],
-                (_, "letterSpacing") => &["LETTER_SPACING"],
-                (_, "lineHeight") => &["LINE_HEIGHT"],
-                (_, "paragraphSpacing") => &["PARAGRAPH_SPACING"],
-                (_, "paragraphIndent") => &["PARAGRAPH_INDENT"],
-                _ => {
-                    self.warn(BAKED);
-                    continue;
-                }
-            };
-            // Each entry names the bound property and the number of the layer field that holds it.
-            for field in fields {
-                if let Some(a) = self.alias(var) {
-                    let mut entry: Fields = node_field(field).into_iter().map(|id| ("nodeField", u(id))).collect();
-                    entry.extend([("variableData", a), ("variableField", e(field))]);
-                    out.entries.push(o(entry));
-                }
-            }
-        }
-        out
-    }
-
-    /// Write layer `id` (child `index` of the layer with GUID `parent_guid`) and its subtree.
-    fn emit(&mut self, id: NodeId, parent_guid: Kv<'static>, index: usize, parent: Option<&Node>, depth: usize) {
-        let doc = self.doc;
-        let (Some(&local), Some(n)) = (self.ids.get(&id), doc.node(id)) else { return };
-        if depth > MAX_DEPTH {
-            self.warn("layers nested deeper than 256 levels were left out");
-            return;
-        }
-        let mut f: Fields = vec![
-            ("guid", guid(LAYERS, local)),
-            ("phase", e("CREATED")),
-            ("parentIndex", o(vec![("guid", parent_guid), ("position", s(&position(index)))])),
-        ];
-        let children = if let NodeKind::Page { background, guides, prototype, .. } = &n.kind {
-            f.extend([("type", e("CANVAS")), ("name", s(&n.name))]);
-            f.extend(root_fields());
-            f.extend([("backgroundColor", color(*background)), ("backgroundOpacity", fl(background.a.into())), ("backgroundEnabled", b(true))]);
-            if !guides.is_empty() {
-                self.warn("ruler guides were left out");
-            }
-            if *prototype != Default::default() {
-                self.warn("prototype device settings were left out");
-            }
-            self.modes(n, &mut f);
-            true
-        } else {
-            self.layer(n, parent, &mut f, false)
-        };
-        self.nodes.push(o(f));
-        if children {
-            for (i, c) in n.children.iter().enumerate() {
-                self.emit(*c, guid(LAYERS, local), i, Some(n), depth + 1);
-            }
-        }
-    }
-
-    /// The fields of layer `n` (whose parent is `parent`). `nested`: for an instance's override
-    /// (no type, no instance or component data). Returns whether its children are written as
-    /// layers (an instance's come from its main).
-    fn layer(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields, nested: bool) -> bool {
-        let doc = self.doc;
-        if let Some((outline, original)) = outlined(n) {
-            // The format's variable width is the same on both sides of the path: a stroke wider on
-            // one side is written as the area it paints, with the stroke itself kept as plugin data
-            // (which the import puts back).
-            self.warn("strokes wider on one side of their path were written as filled outlines (the stroke itself is kept for FigCraft)");
-            let children = self.layer(&outline, parent, f, nested);
-            f.push(("pluginData", arr(vec![o(vec![("pluginID", s(STASH.0)), ("value", s(&original)), ("key", s(STASH.1))])])));
-            return children;
-        }
-        let main = match &n.kind {
-            NodeKind::Instance { component, .. } => {
-                let found = self.ids.contains_key(component) && doc.node(*component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. }));
-                if !found && !nested {
-                    self.warn("instances of components that aren't in the file were written as frames");
-                }
-                found.then_some(*component)
-            }
-            _ => None,
-        };
-        let ty = match &n.kind {
-            NodeKind::Page { .. } | NodeKind::Frame | NodeKind::Group | NodeKind::ComponentSet { .. } => "FRAME",
-            NodeKind::Instance { .. } if main.is_none() => "FRAME",
-            NodeKind::Section { .. } => "SECTION",
-            NodeKind::Rectangle => "ROUNDED_RECTANGLE",
-            NodeKind::Ellipse { .. } => "ELLIPSE",
-            NodeKind::Polygon { .. } => "REGULAR_POLYGON",
-            NodeKind::Star { .. } => "STAR",
-            NodeKind::Line => "LINE",
-            NodeKind::Vector { .. } => "VECTOR",
-            NodeKind::Text(_) => "TEXT",
-            NodeKind::BooleanOp { .. } => "BOOLEAN_OPERATION",
-            NodeKind::Component { .. } => "SYMBOL",
-            NodeKind::Instance { .. } => "INSTANCE",
-            NodeKind::Slice => "SLICE",
-        };
-        if !nested {
-            f.push(("type", e(ty)));
-        }
-        f.push(("name", s(&n.name)));
-        self.common(n, parent, f);
-        match &n.kind {
-            NodeKind::Group => f.push(("resizeToFit", b(true))),
-            NodeKind::Section { contents_hidden } => f.push(("sectionContentsHidden", b(*contents_hidden))),
-            NodeKind::Ellipse { start, sweep, inner } => {
-                f.push(("arcData", o(vec![("startingAngle", fl(*start)), ("endingAngle", fl(start + sweep)), ("innerRadius", fl(*inner))])))
-            }
-            NodeKind::Polygon { count } => f.push(("count", u(*count))),
-            NodeKind::Star { count, inner_ratio } => f.extend([("count", u(*count)), ("starInnerScale", fl(*inner_ratio))]),
-            NodeKind::Vector { network } => self.vector(n, network, f),
-            NodeKind::Text(td) => self.text(td, &n.fills, f),
-            NodeKind::BooleanOp { op } => {
-                let name = match op {
-                    BoolOp::Union => "UNION",
-                    BoolOp::Subtract => "SUBTRACT",
-                    BoolOp::Intersect => "INTERSECT",
-                    BoolOp::Exclude => "XOR",
-                };
-                f.push(("booleanOperation", e(name)));
-                if n.children.iter().filter_map(|c| doc.node(*c)).any(|c| c.bool_op.is_some()) {
-                    self.warn("boolean groups whose layers combine in different ways use the group's operation");
-                }
-            }
-            NodeKind::Component { description, props } if !nested => {
-                if let Some(set) = self.set_of(n.id) {
-                    // A variant: its set holds the definitions; the variant has its own copy of
-                    // each (pointing at the set's), and its values of the variant properties.
-                    let own: Vec<Kv> = props
-                        .iter()
-                        .filter_map(|(name, d)| {
-                            let ty = prop_type(d)?;
-                            let id = *self.child_defs.get(&(n.id, name.clone(), ty))?;
-                            let parent = *self.defs.get(&(set, name.clone(), ty))?;
-                            Some(o(vec![("id", guid(AUX, id)), ("parentPropDefId", guid(AUX, parent))]))
-                        })
-                        .collect();
-                    if !own.is_empty() {
-                        f.push(("componentPropDefs", arr(own)));
-                    }
-                    let specs: Vec<Kv> = variant_pairs(&n.name)
-                        .into_iter()
-                        .filter_map(|(prop, value)| {
-                            let id = *self.defs.get(&(set, prop, "VARIANT"))?;
-                            Some(o(vec![("propDefId", guid(AUX, id)), ("value", s(&value))]))
-                        })
-                        .collect();
-                    if !specs.is_empty() {
-                        f.push(("variantPropSpecs", arr(specs)));
-                    }
-                } else {
-                    let defs: Vec<Kv> = props.iter().enumerate().filter_map(|(i, (name, d))| self.prop_def(n.id, name, d, i)).collect();
-                    if !defs.is_empty() {
-                        f.push(("componentPropDefs", arr(defs)));
-                    }
-                }
-                if props.values().any(|d| matches!(d, PropDef::Slot { .. })) {
-                    self.warn("slot properties were left out");
-                }
-                if !description.is_empty() {
-                    f.push(("symbolDescription", s(description)));
-                }
-            }
-            NodeKind::ComponentSet { description } if !nested => {
-                f.push(("isStateGroup", b(true)));
-                self.set_props(n, f);
-                if !description.is_empty() {
-                    f.push(("symbolDescription", s(description)));
-                }
-            }
-            NodeKind::Instance { props, .. } if !nested => {
-                if let Some(main) = main {
-                    self.instance(n, main, props, f);
-                }
-            }
-            _ => {}
-        }
-        let boxy = n.kind.is_frame_like() || matches!(n.kind, NodeKind::Rectangle | NodeKind::Section { .. });
-        if (boxy || matches!(n.kind, NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. }))
-            && let Some(p) = figcraft_doc::geometry::shape_path(n)
-        {
-            self.geometry("fillGeometry", &p, WindingRule::NonZero, f);
-        }
-        self.stroke_geometry(n, boxy, f);
-        main.is_none()
-    }
-
-    /// Fields every layer kind shares.
-    fn common(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields) {
-        f.extend([
-            ("visible", b(n.visible)),
-            ("locked", b(n.locked)),
-            ("opacity", fl(n.opacity.into())),
-            ("blendMode", e(blend_name(n.blend))),
-            ("size", xy(n.width, n.height)),
-            ("transform", matrix(n.transform)),
-        ]);
-        if n.is_mask {
-            let ty = match n.mask_type {
-                MaskType::Alpha => "ALPHA",
-                MaskType::Vector => "OUTLINE",
-                MaskType::Luminance => "LUMINANCE",
-            };
-            f.extend([("mask", b(true)), ("maskType", e(ty))]);
-        }
-        let bound = self.bound(n);
-        // Text whose own style sets fills paints with them (the layer's fills only show through
-        // runs); a variable bound to the layer's fill colours the layer's.
-        let fills = match &n.kind {
-            NodeKind::Text(TextData { style: TextStyle { fills: Some(own), .. }, .. }) => self.paints(own, true, &Bound::default()),
-            _ => self.paints(&n.fills, true, &bound),
-        };
-        let strokes = self.paints(&n.strokes, false, &bound);
-        f.extend([("fillPaints", fills), ("strokePaints", strokes)]);
-        self.stroke(n, f);
-        if !n.effects.is_empty() {
-            let effects = n.effects.iter().enumerate().map(|(i, x)| self.effect(x, i, &bound)).collect();
-            f.push(("effects", arr(effects)));
-        }
-        if n.kind.has_corner_radius() {
-            let r = n.corners.radii;
-            f.push(("cornerRadius", fl(r[0])));
-            let differ = r.iter().any(|x| *x != r[0]);
-            if n.kind.has_independent_corners() && (differ || r[0] > 0.0) {
-                f.extend(differ.then(|| ("rectangleCornerRadiiIndependent", b(true))));
-                f.extend([
-                    ("rectangleTopLeftCornerRadius", fl(r[0])),
-                    ("rectangleTopRightCornerRadius", fl(r[1])),
-                    ("rectangleBottomRightCornerRadius", fl(r[2])),
-                    ("rectangleBottomLeftCornerRadius", fl(r[3])),
-                ]);
-            }
-            if n.corners.smoothing > 0.0 {
-                f.push(("cornerSmoothing", fl(n.corners.smoothing)));
-            }
-        }
-        let h = match n.constraints.horizontal {
-            HConstraint::Left => "MIN",
-            HConstraint::Right => "MAX",
-            HConstraint::LeftRight => "STRETCH",
-            HConstraint::Center => "CENTER",
-            HConstraint::Scale => "SCALE",
-        };
-        let v = match n.constraints.vertical {
-            VConstraint::Top => "MIN",
-            VConstraint::Bottom => "MAX",
-            VConstraint::TopBottom => "STRETCH",
-            VConstraint::Center => "CENTER",
-            VConstraint::Scale => "SCALE",
-        };
-        f.extend([("horizontalConstraint", e(h)), ("verticalConstraint", e(v))]);
-        if n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. }) {
-            f.push(("frameMaskDisabled", b(!n.clip)));
-        }
-        if n.kind.is_frame_like() {
-            if let Some(l) = &n.layout {
-                self.auto_layout(n, l, f);
-            }
-            if !n.grids.is_empty() {
-                f.push(("layoutGrids", arr(n.grids.iter().enumerate().map(|(i, g)| layout_grid(g, i, &bound)).collect())));
-            }
-        }
-        self.child_layout(n, parent, f);
-        if !n.exports.is_empty() {
-            if n.exports.iter().any(|x| x.format == figcraft_doc::ExportFormat::Webp) {
-                self.warn("WebP export settings were written as PNG");
-            }
-            if n.exports.iter().any(|x| x.format == figcraft_doc::ExportFormat::VectorDrawable) {
-                self.warn("Android Vector Drawable (XML) export settings were written as SVG");
-            }
-            f.push(("exportSettings", arr(n.exports.iter().map(export_setting).collect())));
-        }
-        self.prototype(n, f);
-        let (entries, refs): (Vec<Kv>, Vec<Kv>) = n.prop_refs.iter().filter_map(|(field, prop)| self.prop_ref(n, field, prop)).unzip();
-        if !entries.is_empty() {
-            f.push(("parameterConsumptionMap", o(vec![("entries", arr(entries))])));
-            f.push(("componentPropRefs", arr(refs)));
-        }
-        let text = matches!(n.kind, NodeKind::Text(_));
-        let links = [
-            ("styleIdForFill", &n.styles.fill, true),
-            ("styleIdForStrokeFill", &n.styles.stroke, true),
-            ("styleIdForEffect", &n.styles.effect, true),
-            ("styleIdForGrid", &n.styles.grid, n.kind.is_frame_like()),
-            ("styleIdForText", &n.styles.text, text),
-        ];
-        for (key, id, fits) in links {
-            let Some(id) = id else { continue };
-            match self.style_ids.get(id.as_str()).filter(|_| fits) {
-                Some(local) => f.push((key, o(vec![("guid", guid(LAYERS, *local))]))),
-                None => self.warn("links to shared styles that aren't in the document were left out (their layers keep the values)"),
-            }
-        }
-        if let NodeKind::Text(td) = &n.kind
-            && n.styles.text.is_none()
-            && std::iter::once(&td.style).chain(td.runs.iter().map(|r| &r.style)).any(|st| st.style_id.is_some())
-        {
-            self.warn("text styles applied to part of a text were written as their values");
-        }
-        if !bound.entries.is_empty() {
-            f.push(("variableConsumptionMap", o(vec![("entries", arr(bound.entries))])));
-        }
-        self.modes(n, f);
-        if !n.guides.is_empty() {
-            self.warn("ruler guides were left out");
-        }
-        if !n.annotations.is_empty()
-            || !n.dev_resources.is_empty()
-            || !n.code_links.is_empty()
-            || !n.measurements.is_empty()
-            || !n.dev_status.is_none()
-        {
-            self.warn("Dev Mode annotations, statuses, resources, measurements and code links were left out");
-        }
-        if !n.plugin_data.is_empty() {
-            self.warn("plugin data was left out");
-        }
-    }
-
-    /// The variable modes layer (or page) `n` sets for what is in it.
-    fn modes(&mut self, n: &Node, f: &mut Fields) {
-        let mut entries = Vec::new();
-        for (coll, mode) in &n.var_modes {
-            match (self.set_ids.get(coll.as_str()), self.mode_ids.get(&(coll.as_str(), mode.as_str()))) {
-                (Some(set), Some(mode)) => {
-                    entries.push(o(vec![("variableSetID", o(vec![("guid", guid(LAYERS, *set))])), ("variableModeID", guid(AUX, *mode))]));
-                }
-                _ => self.warn("variable modes of collections that aren't in the document were left out"),
-            }
-        }
-        if !entries.is_empty() {
-            f.push(("variableModeBySetMap", o(vec![("entries", arr(entries))])));
-        }
-    }
-
-    /// A paint list: a layer's fills (`fills`) or strokes with the variables `bound` to them.
-    fn paints(&mut self, list: &[Paint], fills: bool, bound: &Bound) -> Kv<'static> {
-        arr(list.iter().enumerate().filter_map(|(i, p)| self.paint(p, (fills, i), bound)).collect())
-    }
-
-    fn paint(&mut self, p: &Paint, at: (bool, usize), bound: &Bound) -> Option<Kv<'static>> {
-        let mut f: Fields = vec![("visible", b(p.visible)), ("blendMode", e(blend_name(p.blend)))];
-        let mut opacity = f64::from(p.opacity);
-        match &p.kind {
-            PaintKind::Solid { color: c } => {
-                opacity *= f64::from(c.a);
-                f.extend([("type", e("SOLID")), ("color", color(c.with_alpha(1.0)))]);
-                f.extend(bound.paints.get(&at).map(|a| ("colorVar", a.clone())));
-            }
-            PaintKind::Gradient(g) => {
-                let ty = match g.kind {
-                    GradientKind::Linear => "GRADIENT_LINEAR",
-                    GradientKind::Radial => "GRADIENT_RADIAL",
-                    GradientKind::Angular => "GRADIENT_ANGULAR",
-                    GradientKind::Diamond => "GRADIENT_DIAMOND",
-                };
-                // The handles in the unit box come from the inverse of the paint transform: it maps
-                // (0, ½) → start, (1, ½) → end, (0, 1) → width for linear gradients, and the centre
-                // (½, ½) and the points half a box away from it for the others.
-                let (from, to, width) = (g.from, g.to, g.width);
-                let (ax, ay) =
-                    if g.kind == GradientKind::Linear { (to.0 - from.0, to.1 - from.1) } else { (2.0 * (to.0 - from.0), 2.0 * (to.1 - from.1)) };
-                let (cx, cy) = (2.0 * (width.0 - from.0), 2.0 * (width.1 - from.1));
-                let (ex, ey) = if g.kind == GradientKind::Linear {
-                    (from.0 - 0.5 * cx, from.1 - 0.5 * cy)
-                } else {
-                    (from.0 - 0.5 * (ax + cx), from.1 - 0.5 * (ay + cy))
-                };
-                let handles = Affine::new([ax, ay, cx, cy, ex, ey]);
-                let t = if handles.determinant().abs() > 1e-12 && handles.as_coeffs().iter().all(|x| x.is_finite()) {
-                    handles.inverse()
-                } else {
-                    self.warn("gradients with handles on one line were written with the default direction");
-                    Affine::IDENTITY
-                };
-                let stops = g.stops.iter().map(|st| o(vec![("color", color(st.color)), ("position", fl(st.position.into()))])).collect();
-                f.extend([("type", e(ty)), ("stops", arr(stops)), ("transform", matrix(t))]);
-                // Stops bound to variables: every stop again, the bound ones with their variable.
-                if bound.stops.range((at.0, at.1, 0)..=(at.0, at.1, usize::MAX)).next().is_some() {
-                    let vars = g.stops.iter().enumerate().map(|(j, st)| {
-                        let mut sf: Fields = vec![("color", color(st.color))];
-                        sf.extend(bound.stops.get(&(at.0, at.1, j)).map(|a| ("colorVar", a.clone())));
-                        sf.push(("position", fl(st.position.into())));
-                        o(sf)
-                    });
-                    f.push(("stopsVar", arr(vars.collect())));
-                }
-            }
-            PaintKind::Image(img) => {
-                let hash = self.image(&img.image);
-                let mode = match img.scale_mode {
-                    ImageScaleMode::Fill => "FILL",
-                    ImageScaleMode::Fit => "FIT",
-                    ImageScaleMode::Crop => "STRETCH",
-                    ImageScaleMode::Tile => "TILE",
-                };
-                f.extend([
-                    ("type", e("IMAGE")),
-                    ("image", o(vec![("hash", Kv::Bytes(hash)), ("name", s(""))])),
-                    ("imageScaleMode", e(mode)),
-                    ("rotation", fl(f64::from(img.rotation.rem_euclid(4)) * 90.0)),
-                    ("scale", fl(img.scale)),
-                ]);
-                if let (ImageScaleMode::Crop, Some(c)) = (img.scale_mode, img.crop) {
-                    f.push(("transform", matrix(Affine::new(c))));
-                }
-                if img.filters != Default::default() {
-                    self.warn("image adjustments (exposure, contrast, …) were left out");
-                }
-            }
-            PaintKind::Pattern(_) => {
-                self.warn("pattern fills were left out");
-                return None;
-            }
-        }
-        f.push(("opacity", fl(opacity)));
-        Some(o(f))
-    }
-
-    /// The hash bytes of image `key`, writing its file once (empty when its bytes aren't there).
-    fn image(&mut self, key: &str) -> Vec<u8> {
-        let hex = match self.images.get(key) {
-            Some(h) => h.clone(),
-            None => {
-                let h = match self.doc.images.get(key) {
-                    Some(img) if img.bytes.len() as u64 <= MAX_IMAGE => {
-                        let h = sha1_hex(&img.bytes);
-                        if !self.files.iter().any(|(x, _)| *x == h) {
-                            self.files.push((h.clone(), img.bytes.clone()));
-                        }
-                        Some(h)
-                    }
-                    Some(_) => {
-                        self.warn("images larger than 256 MB were left out");
-                        None
-                    }
-                    None => {
-                        self.warn("image fills whose image isn't in the document were written without one");
-                        None
-                    }
-                };
-                self.images.insert(key.to_string(), h.clone());
-                h
-            }
-        };
-        let hex = hex.unwrap_or_default();
-        (0..hex.len() / 2).filter_map(|i| hex.get(2 * i..2 * i + 2).and_then(|d| u8::from_str_radix(d, 16).ok())).collect()
-    }
-
-    fn stroke(&mut self, n: &Node, f: &mut Fields) {
-        let sp = &n.stroke;
-        let align = match sp.align {
-            StrokeAlign::Inside => "INSIDE",
-            StrokeAlign::Center => "CENTER",
-            StrokeAlign::Outside => "OUTSIDE",
-        };
-        f.extend([
-            ("strokeWeight", fl(sp.weight)),
-            ("strokeAlign", e(align)),
-            ("strokeJoin", e(join_name(sp.join))),
-            ("strokeCap", e(cap_name(sp.cap_start))),
-            ("miterLimit", fl(sp.miter_limit)),
-        ]);
-        if !sp.dashes.is_empty() {
-            f.push(("dashPattern", arr(sp.dashes.iter().map(|d| fl(*d)).collect())));
-        }
-        if let Some([t, r, bo, l]) = sp.sides {
-            f.extend([
-                ("borderStrokeWeightsIndependent", b(true)),
-                ("borderTopWeight", fl(t)),
-                ("borderRightWeight", fl(r)),
-                ("borderBottomWeight", fl(bo)),
-                ("borderLeftWeight", fl(l)),
-            ]);
-        }
-        // A variable width: how far the stroke reaches on each side of the path at positions along
-        // its length, as a share of the stroke weight (half of it each for the full weight). The
-        // two sides are the same: a reader draws nothing for a point with unequal sides.
-        if let Some(p) = sp.profile().filter(|_| sp.weight.is_finite() && sp.weight > 0.0) {
-            let point = |q: &figcraft_doc::WidthPoint| o(vec![("position", fl(q.t)), ("ascent", fl(q.scale / 2.0)), ("descent", fl(q.scale / 2.0))]);
-            let p = p.sanitized();
-            if one_sided(&p) {
-                self.warn("strokes wider on one side of their path were written with that width on both sides");
-            }
-            f.push(("variableWidthPoints", arr(p.points.iter().map(point).collect())));
-        }
-        if sp.brush.is_some() {
-            self.warn("brush strokes were written as plain strokes");
-        }
-        if [sp.cap_start, sp.cap_end].contains(&StrokeCap::ReversedTriangle) {
-            self.warn("reversed triangle stroke ends were written as triangle arrows");
-        }
-        // Vectors keep each end's cap on their end points; other layers have one cap.
-        if sp.cap_start != sp.cap_end && !matches!(n.kind, NodeKind::Vector { .. }) {
-            self.warn("lines with different stroke ends use the start's at both ends");
-        }
-    }
-
-    /// Effect `index` of a layer, with the variables `bound` to its fields.
-    fn effect(&mut self, x: &figcraft_doc::Effect, index: usize, bound: &Bound) -> Kv<'static> {
-        let mut f: Fields = vec![("visible", b(x.visible))];
-        let vars = [
-            ("color", "colorVar"),
-            ("radius", "radiusVar"),
-            ("spread", "spreadVar"),
-            ("offsetX", "xVar"),
-            ("offsetY", "yVar"),
-            ("startRadius", "startRadiusVar"),
-        ];
-        f.extend(vars.into_iter().filter_map(|(ours, key)| Some((key, bound.effects.get(&(index, ours))?.clone()))));
-        let blur = |f: &mut Fields, ty: &'static str, bl: &figcraft_doc::Blur| {
-            f.extend([("type", e(ty)), ("radius", fl(bl.radius))]);
-            if bl.blur_type == figcraft_doc::BlurType::Progressive {
-                f.extend([
-                    ("blurOpType", e("PROGRESSIVE")),
-                    ("startRadius", fl(bl.start_radius)),
-                    ("startOffset", xy(bl.start.0, bl.start.1)),
-                    ("endOffset", xy(bl.end.0, bl.end.1)),
-                ]);
-            }
-        };
-        let grain = |size: f64, size_y: Option<f64>| xy(size, size_y.unwrap_or(size));
-        match &x.kind {
-            EffectKind::DropShadow(sh) | EffectKind::InnerShadow(sh) => {
-                let ty = if matches!(x.kind, EffectKind::DropShadow(_)) { "DROP_SHADOW" } else { "INNER_SHADOW" };
-                f.extend([
-                    ("type", e(ty)),
-                    ("color", color(sh.color)),
-                    ("offset", xy(sh.offset.0, sh.offset.1)),
-                    ("radius", fl(sh.radius)),
-                    ("spread", fl(sh.spread)),
-                    ("blendMode", e(blend_name(sh.blend))),
-                    ("showShadowBehindNode", b(sh.show_behind)),
-                ]);
-            }
-            EffectKind::LayerBlur(bl) => blur(&mut f, "FOREGROUND_BLUR", bl),
-            EffectKind::BackgroundBlur(bl) => blur(&mut f, "BACKGROUND_BLUR", bl),
-            EffectKind::Noise(nz) => {
-                let mode = match nz.mode {
-                    NoiseMode::Mono => "MONOTONE",
-                    NoiseMode::Duo => "DUOTONE",
-                    NoiseMode::Multi => "MULTITONE",
-                };
-                f.extend([
-                    ("type", e("NOISE")),
-                    ("noiseType", e(mode)),
-                    ("noiseSize", grain(nz.size, nz.size_y)),
-                    ("density", fl(nz.density)),
-                    ("color", color(nz.color)),
-                    ("secondaryColor", color(nz.secondary)),
-                    ("opacity", fl(nz.opacity.into())),
-                    ("blendMode", e(blend_name(nz.blend))),
-                ]);
-            }
-            EffectKind::Texture(t) => {
-                f.extend([
-                    ("type", e("GRAIN")),
-                    ("noiseSize", grain(t.size, t.size_y)),
-                    ("radius", fl(t.radius)),
-                    ("clipToShape", b(t.clip_to_shape)),
-                ]);
-            }
-            EffectKind::Glass(g) => {
-                self.warn("glass effects keep only their frost");
-                f.extend([("type", e("GLASS")), ("radius", fl(g.frost))]);
-            }
-        }
-        o(f)
-    }
-
-    fn auto_layout(&mut self, n: &Node, l: &AutoLayout, f: &mut Fields) {
-        let grid = l.mode == LayoutMode::Grid;
-        let mode = match l.mode {
-            LayoutMode::Horizontal => "HORIZONTAL",
-            LayoutMode::Vertical => "VERTICAL",
-            LayoutMode::Grid => "GRID",
-        };
-        let [top, right, bottom, left] = l.padding;
-        let main = match l.main_align {
-            MainAlign::Min => "MIN",
-            MainAlign::Center => "CENTER",
-            MainAlign::Max => "MAX",
-            MainAlign::SpaceBetween => "SPACE_BETWEEN",
-            MainAlign::SpaceAround => "SPACE_AROUND",
-            MainAlign::SpaceEvenly => "SPACE_EVENLY_CSS",
-        };
-        let cross = match l.cross_align {
-            CrossAlign::Min => "MIN",
-            CrossAlign::Center => "CENTER",
-            CrossAlign::Max => "MAX",
-            CrossAlign::Baseline => "BASELINE",
-        };
-        // The main axis is the width for horizontal and grid layouts.
-        let (main_hug, cross_hug) = {
-            let (h, v) = (n.child_layout.sizing_h == Sizing::Hug, n.child_layout.sizing_v == Sizing::Hug);
-            if l.mode == LayoutMode::Vertical { (v, h) } else { (h, v) }
-        };
-        let size = |hug: bool| e(if hug { "RESIZE_TO_FIT" } else { "FIXED" });
-        f.extend([
-            ("stackMode", e(mode)),
-            ("stackWrap", e(if l.wrap { "WRAP" } else { "NO_WRAP" })),
-            ("stackHorizontalPadding", fl(left)),
-            ("stackVerticalPadding", fl(top)),
-            ("stackPaddingRight", fl(right)),
-            ("stackPaddingBottom", fl(bottom)),
-            ("stackPrimaryAlignItems", e(main)),
-            ("stackCounterAlignItems", e(cross)),
-            ("stackPrimarySizing", size(main_hug)),
-            ("stackCounterSizing", size(cross_hug)),
-            ("bordersTakeSpace", b(l.strokes_included)),
-            ("stackReverseZIndex", b(l.reverse_z)),
-        ]);
-        if grid {
-            self.grid_layout(n, l, f);
-        } else {
-            let spread = l.content_align == ContentAlign::SpaceBetween;
-            f.extend([
-                ("stackSpacing", fl(l.gap)),
-                ("stackCounterSpacing", fl(l.cross_gap)),
-                ("stackCounterAlignContent", e(if spread { "SPACE_BETWEEN" } else { "AUTO" })),
-            ]);
-        }
-    }
-
-    /// A grid layout's track gaps, order and sizes.
-    fn grid_layout(&mut self, n: &Node, l: &AutoLayout, f: &mut Fields) {
-        // Instance layers share their main layer's track ids, so unchanged tracks and the cells
-        // their layers sit in still match.
-        let key = self.main_layer(n.id);
-        let (want_c, want_r) = (l.grid_columns.min(1000) as usize, l.grid_rows.min(1000) as usize);
-        let (cols, rows) = match self.tracks.get(&key) {
-            Some((c, r)) if (c.len(), r.len()) == (want_c, want_r) => (c.clone(), r.clone()),
-            _ => ((0..want_c).map(|_| self.next_aux()).collect(), (0..want_r).map(|_| self.next_aux()).collect()),
-        };
-        let map = |ids: &[u32]| {
-            o(vec![("entries", arr(ids.iter().enumerate().map(|(i, t)| o(vec![("id", guid(AUX, *t)), ("position", s(&position(i)))])).collect()))])
-        };
-        f.extend([("gridColumnGap", fl(l.gap)), ("gridRowGap", fl(l.cross_gap)), ("gridColumns", map(&cols)), ("gridRows", map(&rows))]);
-        let mut dropped = false;
-        let column_sizing = grid_sizing(&l.column_tracks, &cols, &mut dropped);
-        let row_sizing = grid_sizing(&l.row_tracks, &rows, &mut dropped);
-        if dropped {
-            self.warn("grid tracks whose size the format can't hold were written as equal tracks");
-        }
-        for (name, sizing) in [("gridColumnsSizing", column_sizing), ("gridRowsSizing", row_sizing)] {
-            if let Some(v) = sizing {
-                f.push((name, v));
-            }
-        }
-        self.tracks.insert(key, (cols, rows));
-    }
-
-    /// How a layer sizes and sits in its auto layout parent. Min/max sizes are the layer's own
-    /// and are written whatever its parent is.
-    fn child_layout(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields) {
-        let cl = &n.child_layout;
-        // An axis without a minimum is 0; one without a maximum is infinite (0 would be a maximum
-        // of 0, which collapses the layer in readers that apply it).
-        for (key, w, h, none) in [("minSize", cl.min_w, cl.min_h, 0.0), ("maxSize", cl.max_w, cl.max_h, f32::INFINITY)] {
-            if w.is_some() || h.is_some() {
-                let axis = |x: Option<f64>| x.map_or(Kv::Float(none), fl);
-                f.push((key, o(vec![("value", o(vec![("x", axis(w)), ("y", axis(h))]))])));
-            }
-        }
-        let Some(pl) = parent.and_then(|p| p.layout.as_ref()) else { return };
-        let (fill_h, fill_v) = (cl.sizing_h == Sizing::Fill, cl.sizing_v == Sizing::Fill);
-        let (grow, stretch) = if pl.mode == LayoutMode::Vertical { (fill_v, fill_h) } else { (fill_h, fill_v) };
-        if grow {
-            f.push(("stackChildPrimaryGrow", fl(1.0)));
-        }
-        if stretch {
-            f.push(("stackChildAlignSelf", e("STRETCH")));
-        }
-        if cl.absolute {
-            f.push(("stackPositioning", e("ABSOLUTE")));
-        }
-        if pl.mode == LayoutMode::Grid
-            && let Some((cols, rows)) = parent.and_then(|p| self.tracks.get(&self.main_layer(p.id)))
-        {
-            let anchor = |ids: &[u32], i: Option<u32>| i.and_then(|i| ids.get(i as usize)).map(|t| guid(AUX, *t));
-            let (c, r) = (anchor(cols, cl.grid_column), anchor(rows, cl.grid_row));
-            f.extend(c.map(|g| ("gridColumnAnchor", g)));
-            f.extend(r.map(|g| ("gridRowAnchor", g)));
-            if cl.grid_column_span > 0 {
-                f.push(("gridColumnSpan", int(cl.grid_column_span.into())));
-            }
-            if cl.grid_row_span > 0 {
-                f.push(("gridRowSpan", int(cl.grid_row_span.into())));
-            }
-        }
-    }
-
-    /// Text: its style, box settings, and characters with their styled runs. `fills`: the layer's
-    /// (what runs without fills of their own show when the text's own style sets other fills).
-    fn text(&mut self, td: &TextData, fills: &[Paint], f: &mut Fields) {
-        style_fields(&td.style, f);
-        let (ha, va) = (
-            match td.align_h {
-                TextAlignH::Left => "LEFT",
-                TextAlignH::Center => "CENTER",
-                TextAlignH::Right => "RIGHT",
-                TextAlignH::Justified => "JUSTIFIED",
-            },
-            match td.align_v {
-                TextAlignV::Top => "TOP",
-                TextAlignV::Middle => "CENTER",
-                TextAlignV::Bottom => "BOTTOM",
-            },
-        );
-        let resize = match td.auto_resize {
-            TextAutoResize::WidthAndHeight => "WIDTH_AND_HEIGHT",
-            TextAutoResize::Height => "HEIGHT",
-            TextAutoResize::None | TextAutoResize::Truncate => "NONE",
-        };
-        f.extend([
-            ("textAlignHorizontal", e(ha)),
-            ("textAlignVertical", e(va)),
-            ("textAutoResize", e(resize)),
-            ("paragraphSpacing", fl(td.paragraph_spacing)),
-            ("paragraphIndent", fl(td.paragraph_indent)),
-            ("autoRename", b(false)),
-            ("fontVariantCommonLigatures", b(true)),
-            ("fontVariantContextualLigatures", b(true)),
-            ("fontVersion", s("")),
-            ("textUserLayoutVersion", u(5)),
-            ("textExplicitLayoutVersion", u(1)),
-            ("textBidiVersion", u(1)),
-            ("textTracking", fl(0.0)),
-            ("emojiImageSet", e("APPLE")),
-        ]);
-        if td.truncates() {
-            f.push(("textTruncation", e("ENDING")));
-        }
-        if td.max_lines > 0 {
-            f.push(("maxLines", int(td.max_lines.into())));
-        }
-        // Styles per UTF-16 unit: 0 for the base style, else an entry of the override table.
-        if td.char_count() > MAX_CHARS {
-            self.warn("text longer than 1,048,576 characters was cut");
-        }
-        let spans = td.spans();
-        let mut table: Vec<&TextStyle> = Vec::new();
-        let mut span_ids = Vec::with_capacity(spans.len());
-        for (_, _, st) in &spans {
-            span_ids.push(if **st == td.style {
-                0
-            } else {
-                let i = table.iter().position(|t| *t == *st).unwrap_or_else(|| {
-                    table.push(st);
-                    table.len() - 1
-                });
-                i as u32 + 1
-            });
-        }
-        let mut chars = String::new();
-        let mut ids: Vec<Kv> = Vec::new();
-        let mut span = 0;
-        for (i, ch) in td.characters.chars().take(MAX_CHARS).enumerate() {
-            while spans.get(span).is_some_and(|sp| i >= sp.1) {
-                span += 1;
-            }
-            // NULs can't be stored in a string.
-            if ch == '\0' {
-                continue;
-            }
-            chars.push(ch);
-            let id = span_ids.get(span).copied().unwrap_or(0);
-            ids.extend((0..ch.len_utf16()).map(|_| u(id)));
-        }
-        let mut data: Fields = vec![("characters", Kv::Str(chars))];
-        if !table.is_empty() {
-            let entries = table
-                .iter()
-                .zip(1u32..)
-                .map(|(st, id)| {
-                    let mut ef: Fields = vec![("styleID", u(id))];
-                    style_fields(st, &mut ef);
-                    // An empty link clears the text's own (a missing one would inherit it).
-                    if st.link.is_none() && td.style.link.is_some() {
-                        ef.push(("hyperlink", o(vec![("url", s(""))])));
-                    }
-                    if let Some(p) = st.fills.as_deref().or(td.style.fills.as_ref().map(|_| fills)) {
-                        ef.push(("fillPaints", self.paints(p, true, &Bound::default())));
-                    }
-                    o(ef)
-                })
-                .collect();
-            data.extend([("characterStyleIDs", arr(ids)), ("styleOverrideTable", arr(entries))]);
-        }
-        let lists: Vec<ListStyle> = (0..td.paragraph_count()).map(|p| td.para_list(p).list).collect();
-        let first = |i: usize, l: &ListStyle| *l != ListStyle::None && (i == 0 || lists.get(i - 1) != Some(l));
-        // Where each line's numbered list starts counting, less one: its first item's start, on
-        // every line of the list.
-        let mut run = 0;
-        let starts: Vec<u32> = lists
-            .iter()
-            .enumerate()
-            .map(|(i, l)| {
-                if first(i, l) {
-                    run = td.para_list(i).start_offset;
-                }
-                if *l == ListStyle::Numbered { run } else { 0 }
-            })
-            .collect();
-        // One entry per paragraph, each with every field a reader expects.
-        let line = |(i, l): (usize, &ListStyle)| {
-            let ty = match l {
-                ListStyle::None => "PLAIN",
-                ListStyle::Numbered => "ORDERED_LIST",
-                ListStyle::Bulleted => "UNORDERED_LIST",
-            };
-            let listed = *l != ListStyle::None;
-            let begins = first(i, l);
-            let start = starts.get(i).copied().unwrap_or(0);
-            o(vec![
-                ("lineType", e(ty)),
-                ("styleId", int(0)),
-                ("indentationLevel", int(i64::from(listed))),
-                ("sourceDirectionality", e("AUTO")),
-                ("listStartOffset", int(i64::from(start))),
-                ("isFirstLineOfList", b(begins)),
-            ])
-        };
-        data.push(("lines", arr(lists.iter().enumerate().map(line).collect())));
-        f.push(("textData", o(data)));
-        if (0..td.paragraph_count()).any(|p| td.para_list(p).indent > 0) {
-            self.warn("nested list levels were written as the first level");
-        }
-        let styles = std::iter::once(&td.style).chain(td.runs.iter().map(|r| &r.style));
-        if styles.clone().any(|st| unsupported_decoration_look(st) || !st.variations.is_empty()) {
-            self.warn("text decoration looks and variable font settings were left out");
-        }
-        if td.path.is_some() {
-            self.warn("text on a path was written as plain text");
-        }
-        if td.list_spacing != 0.0 || td.hanging_punctuation || td.hanging_list || td.leading_trim != Default::default() || !td.features.is_empty() {
-            self.warn("list spacing, hanging punctuation, leading trim and OpenType features were left out");
-        }
-    }
-
-    /// The editable network (with per-point corner radii, handle mirroring and end caps) and,
-    /// when it has filled areas, their outline.
-    fn vector(&mut self, n: &Node, net: &VectorNetwork, f: &mut Fields) {
-        let entries: usize = net.regions.iter().flat_map(|r| &r.loops).map(Vec::len).sum();
-        if net.vertices.len() + net.segments.len() + entries > MAX_NETWORK {
-            self.warn("vector networks too large for the format were written as outlines");
-        } else {
-            // The stroke starts at the first end point and stops at the last: the layer's end caps go
-            // there (where the point has none of its own).
-            let mut degree = vec![0usize; net.vertices.len()];
-            for sg in &net.segments {
-                for i in [sg.a, sg.b] {
-                    if let Some(d) = degree.get_mut(i) {
-                        *d += 1;
-                    }
-                }
-            }
-            let ends: Vec<usize> = (0..degree.len()).filter(|i| degree.get(*i) == Some(&1)).collect();
-            let (first, last) = (ends.first().copied(), ends.last().copied());
-            let caps_differ = n.stroke.cap_start != n.stroke.cap_end || net.vertices.iter().any(|v| v.cap.is_some());
-            let mut styles: Vec<Fields> = Vec::new();
-            let mut style_of = |fields: Fields| -> u32 {
-                if fields.is_empty() {
-                    return 0;
-                }
-                let i = styles.iter().position(|x| *x == fields).unwrap_or_else(|| {
-                    styles.push(fields);
-                    styles.len() - 1
-                });
-                i as u32 + 1
-            };
-            let vertices = net
-                .vertices
-                .iter()
-                .enumerate()
-                .map(|(i, v)| {
-                    let mut st: Fields = Vec::new();
-                    if v.radius > 0.0 {
-                        st.push(("cornerRadius", fl(v.radius)));
-                    }
-                    if let Some(m) = v.mirror {
-                        st.push((
-                            "handleMirroring",
-                            e(match m {
-                                figcraft_doc::HandleMirroring::None => "NONE",
-                                figcraft_doc::HandleMirroring::Angle => "ANGLE",
-                                figcraft_doc::HandleMirroring::AngleAndLength => "ANGLE_AND_LENGTH",
-                            }),
-                        ));
-                    }
-                    let end_cap = if Some(i) == first {
-                        Some(n.stroke.cap_start)
-                    } else if Some(i) == last {
-                        Some(n.stroke.cap_end)
-                    } else {
-                        None
-                    };
-                    if let Some(c) = v.cap.or(end_cap.filter(|_| caps_differ)) {
-                        st.push(("strokeCap", e(cap_name(c))));
-                    }
-                    if let Some(j) = v.join {
-                        st.push(("strokeJoin", e(join_name(j))));
-                    }
-                    network::Vertex { style: style_of(st), x: finite(v.x), y: finite(v.y) }
-                })
-                .collect();
-            let segments = net
-                .segments
-                .iter()
-                .map(|sg| network::Segment {
-                    style: 0,
-                    a: sg.a,
-                    ta: (finite(sg.ta.0), finite(sg.ta.1)),
-                    b: sg.b,
-                    tb: (finite(sg.tb.0), finite(sg.tb.1)),
-                })
-                .collect();
-            let regions = net
-                .regions
-                .iter()
-                .map(|r| network::Region { style: 0, non_zero: r.winding == WindingRule::NonZero, loops: r.loops.clone() })
-                .collect();
-            let blob = network::encode(&network::Network { vertices, segments, regions });
-            let table = styles.into_iter().zip(1u32..).map(|(mut st, id)| {
-                st.insert(0, ("styleID", u(id)));
-                o(st)
-            });
-            let table: Vec<Kv> = table.collect();
-            if let Some(i) = self.blob(blob) {
-                f.push((
-                    "vectorData",
-                    o(vec![("vectorNetworkBlob", u(i)), ("normalizedSize", xy(n.width, n.height)), ("styleOverrideTable", arr(table))]),
-                ));
-            }
-        }
-        if !net.regions.is_empty() {
-            let winding = net.regions.first().map(|r| r.winding).unwrap_or_default();
-            if net.regions.iter().any(|r| r.winding != winding) {
-                self.warn("vectors whose filled areas use different winding rules use the first one's in their outline");
-            }
-            self.geometry("fillGeometry", &net.fill_path(), winding, f);
-        }
-    }
-
-    /// `fillGeometry` or `strokeGeometry` (`key`) from a local path.
-    fn geometry(&mut self, key: &'static str, p: &BezPath, winding: WindingRule, f: &mut Fields) {
-        if p.elements().is_empty() {
-            return;
-        }
-        if let Some(i) = self.blob(path_blob(p)) {
-            let rule = if winding == WindingRule::EvenOdd { "ODD" } else { "NONZERO" };
-            f.push((key, arr(vec![o(vec![("windingRule", e(rule)), ("commandsBlob", u(i)), ("styleID", u(0))])])));
-        }
-    }
-
-    /// `strokeGeometry`, the outline of a plain stroke: a ring around boxes and whole ellipses, the
-    /// widened path of other centred strokes. Dashed, per-side and other strokes get none (a reader
-    /// builds theirs from the stroke settings).
-    fn stroke_geometry(&mut self, n: &Node, boxy: bool, f: &mut Fields) {
-        let sp = &n.stroke;
-        let (w, h, weight) = (n.width, n.height, sp.weight);
-        let plain = n.strokes.iter().any(|p| p.visible) && sp.dashes.is_empty() && sp.sides.is_none() && sp.profile().is_none() && sp.brush.is_none();
-        if !(plain && weight.is_finite() && weight > 0.0 && w.is_finite() && h.is_finite()) {
-            return;
-        }
-        let whole = matches!(n.kind, NodeKind::Ellipse { sweep, inner, .. } if inner == 0.0 && sweep.abs() >= std::f64::consts::TAU - 1e-9);
-        if boxy || whole {
-            let (out, inset) = match sp.align {
-                StrokeAlign::Inside => (0.0, weight),
-                StrokeAlign::Center => (weight / 2.0, weight / 2.0),
-                StrokeAlign::Outside => (weight, 0.0),
-            };
-            // The shape grown by `d` (shrunk when negative), or nothing when it shrinks away.
-            let grown = |d: f64| -> Option<BezPath> {
-                let (gw, gh) = (w + 2.0 * d, h + 2.0 * d);
-                if gw <= 0.0 || gh <= 0.0 {
-                    return None;
-                }
-                let mut p = if whole {
-                    figcraft_doc::geom::ellipse(gw, gh, 0.0, std::f64::consts::TAU, 0.0)
-                } else {
-                    let radii = n.corners.radii.map(|r| if r > 0.0 { (r + d).max(0.0) } else { 0.0 });
-                    figcraft_doc::geom::rounded_rect(gw, gh, radii, n.corners.smoothing)
-                };
-                p.apply_affine(Affine::translate((-d, -d)));
-                Some(p)
-            };
-            let Some(mut ring) = grown(out) else { return };
-            ring.extend(grown(-inset).iter().flat_map(|p| p.elements().iter().copied()));
-            self.geometry("strokeGeometry", &ring, WindingRule::EvenOdd, f);
-        } else if sp.align == StrokeAlign::Center {
-            let path = match &n.kind {
-                NodeKind::Vector { network } => Some(network.stroke_path()),
-                NodeKind::Text(_) => None,
-                _ => figcraft_doc::geometry::shape_path(n),
-            };
-            let Some(path) = path.filter(|p| !p.elements().is_empty()) else { return };
-            use figcraft_doc::geom::kurbo::{Cap, Join, Stroke, StrokeOpts, stroke};
-            let cap = match sp.cap_start {
-                StrokeCap::Round => Cap::Round,
-                StrokeCap::Square => Cap::Square,
-                _ => Cap::Butt,
-            };
-            let join = match sp.join {
-                StrokeJoin::Miter => Join::Miter,
-                StrokeJoin::Bevel => Join::Bevel,
-                StrokeJoin::Round => Join::Round,
-            };
-            let limit = if sp.miter_limit.is_finite() { sp.miter_limit.max(1.0) } else { 4.0 };
-            let style = Stroke::new(weight).with_caps(cap).with_join(join).with_miter_limit(limit);
-            self.geometry("strokeGeometry", &stroke(path, &style, &StrokeOpts::default(), 0.05), WindingRule::NonZero, f);
-        }
-    }
-
-    /// Add a blob; its index (`None` once the blobs would make the file too large).
-    fn blob(&mut self, bytes: Vec<u8>) -> Option<u32> {
-        if let Some(i) = self.blobs.get(&bytes) {
-            return Some(*i);
-        }
-        self.blob_bytes += bytes.len() as u64;
-        if self.blob_bytes > MAX_CANVAS {
-            self.warn("vector data too large for the format was left out");
-            return None;
-        }
-        let i = u32::try_from(self.blobs.len()).ok()?;
-        self.blobs.insert(bytes, i);
-        Some(i)
-    }
-
-    /// A component property definition of `owner` (a component, or a set), `index`-th in its list.
-    /// The default value is written twice: as `initialValue` and as `varValue`, which is what
-    /// readers that know variables take.
-    fn prop_def(&mut self, owner: NodeId, name: &str, d: &PropDef, index: usize) -> Option<Kv<'static>> {
-        let ty = prop_type(d)?;
-        let id = *self.defs.get(&(owner, name.to_string(), ty))?;
-        let (value, var) = match d {
-            PropDef::Boolean { default } => (o(vec![("boolValue", b(*default))]), bool_data(*default)),
-            PropDef::Text { default } => (o(vec![("textValue", text_value(default))]), text_data(default)),
-            PropDef::InstanceSwap { default, preferred } => {
-                if !preferred.is_empty() {
-                    self.warn("preferred values of instance swap properties were left out");
-                }
-                let main = self.guid_of(*default)?;
-                (o(vec![("guidValue", main.clone())]), symbol_data(main))
-            }
-            PropDef::Variant { .. } | PropDef::Slot { .. } => return None,
-        };
-        Some(o(vec![
-            ("id", guid(AUX, id)),
-            ("name", s(name)),
-            ("initialValue", value),
-            ("sortPosition", s(&sort_position(index))),
-            ("type", e(ty)),
-            ("preferredValues", o(Vec::new())),
-            ("varValue", var),
-        ]))
-    }
-
-    /// A component set's property definitions: its variant properties (from the variants' names,
-    /// in the order they first appear, with their values in order) and the other properties its
-    /// variants share; written on the set, as the format keeps them.
-    fn set_props(&mut self, set: &Node, f: &mut Fields) {
-        let doc = self.doc;
-        let variants: Vec<&Node> =
-            set.children.iter().filter_map(|c| doc.node(*c)).filter(|c| matches!(c.kind, NodeKind::Component { .. })).collect();
-        let mut order: Vec<(String, Vec<String>)> = Vec::new();
-        for v in &variants {
-            for (prop, value) in variant_pairs(&v.name) {
-                let i = match order.iter().position(|(p, _)| *p == prop) {
-                    Some(i) => i,
-                    None => {
-                        order.push((prop, Vec::new()));
-                        order.len() - 1
-                    }
-                };
-                if let Some((_, values)) = order.get_mut(i)
-                    && !values.contains(&value)
-                {
-                    values.push(value);
-                }
-            }
-        }
-        let mut defs = Vec::new();
-        for (prop, _) in &order {
-            if let Some(&id) = self.defs.get(&(set.id, prop.clone(), "VARIANT")) {
-                defs.push(o(vec![
-                    ("id", guid(AUX, id)),
-                    ("name", s(prop)),
-                    ("initialValue", o(Vec::new())),
-                    ("sortPosition", s(&sort_position(defs.len()))),
-                    ("type", e("VARIANT")),
-                    ("preferredValues", o(Vec::new())),
-                    ("varValue", var_data(("textValue", s("")), "STRING", "STRING")),
-                ]));
-            }
-        }
-        // The format keeps one default per property of a set (a variant's copy holds none): the first
-        // variant's, with a warning when another variant's differs.
-        // A name used with two types is two properties (their definitions have their own ids).
-        let mut seen: BTreeMap<(String, &'static str), PropDef> = BTreeMap::new();
-        for v in &variants {
-            let NodeKind::Component { props, .. } = &v.kind else { continue };
-            for (name, d) in props {
-                let Some(ty) = prop_type(d) else { continue };
-                match seen.get(&(name.clone(), ty)) {
-                    Some(first) if first != d => self.warn("variants with different defaults for one property were written with the first variant's"),
-                    Some(_) => {}
-                    None => {
-                        seen.insert((name.clone(), ty), d.clone());
-                        let index = defs.len();
-                        defs.extend(self.prop_def(set.id, name, d, index));
-                    }
-                }
-            }
-        }
-        if !defs.is_empty() {
-            f.push(("componentPropDefs", arr(defs)));
-        }
-        if !order.is_empty() {
-            let orders = order.into_iter().map(|(p, values)| o(vec![("property", s(&p)), ("values", arr(values.iter().map(|x| s(x)).collect()))]));
-            f.push(("stateGroupPropertyValueOrders", arr(orders.collect())));
-        }
-    }
-
-    /// Which property controls a layer's `field`: the entry of its parameter consumption map and
-    /// its component property reference (readers take one or the other), both naming the
-    /// definition of the component the layer is in (a variant's own copy, in a set).
-    fn prop_ref(&mut self, n: &Node, field: &str, prop: &str) -> Option<(Kv<'static>, Kv<'static>)> {
-        let (var_field, ty, resolved) = match field {
-            "visible" => ("VISIBLE", "BOOL", "BOOLEAN"),
-            "characters" => ("TEXT_DATA", "TEXT", "TEXT_DATA"),
-            "mainComponent" => ("OVERRIDDEN_SYMBOL_ID", "INSTANCE_SWAP", "SYMBOL_ID"),
-            _ => {
-                self.warn("slot layers were written as plain layers");
-                return None;
-            }
-        };
-        let id = self.def_for(self.component_of(n)?, prop, ty)?;
-        let data = o(vec![
-            ("value", o(vec![("propRefValue", o(vec![("defId", guid(AUX, id))]))])),
-            ("dataType", e("PROP_REF")),
-            ("resolvedDataType", e(resolved)),
-        ]);
-        let entry = o(vec![("variableData", data), ("variableField", e(var_field))]);
-        let reference = o(vec![("defID", guid(AUX, id)), ("componentPropNodeField", e(var_field))]);
-        Some((entry, reference))
-    }
-
-    /// An instance: its main, the fields it and its layers override, the size, place and outline
-    /// its layers get from that (derived data), its property values. `f`: its own fields so far.
-    fn instance(&mut self, n: &Node, main: NodeId, props: &BTreeMap<String, Value>, f: &mut Fields) {
-        // Which properties control the instance itself (a nested instance in a main component) is
-        // its own too, not an override of its main.
-        const OWN: [&str; 9] =
-            ["guid", "phase", "parentIndex", "type", "transform", "fillGeometry", "strokeGeometry", "parameterConsumptionMap", "componentPropRefs"];
-        let doc = self.doc;
-        let (Some(m), Some(symbol)) = (doc.node(main), self.guid_of(main)) else { return };
-        // What the instance itself changes from its main (its size, its paints, …) is an override
-        // addressed by the main's id: a reader takes everything else from the main. Where it sits
-        // is its own.
-        let mut root_theirs = Vec::new();
-        self.layer(m, m.parent.and_then(|p| doc.node(p)), &mut root_theirs, true);
-        root_theirs.retain(|(k, _)| !OWN.contains(k));
-        // An instance is named after its component (the set, for a variant) until renamed.
-        let set = m.parent.and_then(|p| doc.node(p)).filter(|p| matches!(p.kind, NodeKind::ComponentSet { .. }));
-        let named = set.is_none_or(|s| s.name != n.name);
-        let root_mine: Fields = f.iter().filter(|(k, _)| !OWN.contains(k) && (named || *k != "name")).cloned().collect();
-        // Each layer below: its id path, the fields that differ from the main's layer, that layer's
-        // fields, whether its size is its own (a nested instance, a size override) and the
-        // component a nested instance was swapped for.
-        struct Row {
-            path: Kv<'static>,
-            changed: Fields,
-            theirs: Fields,
-            sized: bool,
-            swap: Option<Kv<'static>>,
-        }
-        let mut rows: Vec<Row> = Vec::new();
-        let mut stack: Vec<(NodeId, NodeId)> = n.children.iter().rev().map(|c| (*c, n.id)).collect();
-        let mut seen = 0usize;
-        while let Some((id, parent)) = stack.pop() {
-            let Some(d) = doc.node(id) else { continue };
-            seen += 1;
-            if seen > MAX_NODES {
-                break;
-            }
-            stack.extend(d.children.iter().rev().map(|c| (*c, id)));
-            let path = self.layer_path(d, n.id, main, 0);
-            let guids: Option<Vec<Kv>> = path.and_then(|p| p.iter().map(|x| self.guid_of(*x)).collect());
-            let (Some(guids), Some(src)) = (guids, d.source.and_then(|src| doc.node(src))) else {
-                self.warn("instance layers that don't come from their main component were left out");
-                continue;
-            };
-            let (mut mine, mut theirs) = (Vec::new(), Vec::new());
-            self.layer(d, doc.node(parent), &mut mine, true);
-            self.layer(src, src.parent.and_then(|p| doc.node(p)), &mut theirs, true);
-            // A nested instance swapped for another component.
-            let swap = match (&d.kind, &src.kind) {
-                (NodeKind::Instance { component, .. }, NodeKind::Instance { component: was, .. }) if component == was => None,
-                (NodeKind::Instance { component, .. }, _) => self.guid_of(*component),
-                _ => None,
-            };
-            let sized = matches!(d.kind, NodeKind::Instance { .. }) || d.overrides.contains("size");
-            rows.push(Row { path: o(vec![("guids", arr(guids))]), changed: changed(mine, &theirs), theirs, sized, swap });
-        }
-        // An instance scaled as a whole (the Scale tool) is `factor` times its main in every length:
-        // sizes, places and stroke weights, its own and its layers'. A resized one keeps its weights.
-        let field = |fields: &Fields, key: &str| fields.iter().find(|(k, _)| *k == key).map(|(_, v)| v.clone());
-        let factor = Some(n.width / m.width).filter(|k| k.is_finite() && *k > 0.0 && (k - 1.0).abs() > 1e-6).filter(|k| {
-            let grown = |mine: &Fields, theirs: &Fields| {
-                let weight = field(theirs, "strokeWeight").and_then(|w| w.f64()).unwrap_or(0.0);
-                (weight == 0.0 || field(mine, "strokeWeight").is_some_and(|w| scaled(&w, &fl(weight), *k, 0.0)))
-                    && field(mine, "size").zip(field(theirs, "size")).is_some_and(|(a, b)| scaled(&a, &b, *k, 1.0))
-                    && field(mine, "transform").zip(field(theirs, "transform")).is_none_or(|(a, b)| scaled(&a, &b, *k, 1.0))
-            };
-            (n.height / m.height - k).abs() <= 1e-6 * k.max(1.0)
-                && grown(&changed(root_mine.clone(), &root_theirs), &root_theirs)
-                && rows.iter().all(|r| grown(&r.changed, &r.theirs))
-        });
-        // What follows from the overrides goes with the derived data: a layer's size, place and
-        // outline (a vector's network is the main's, drawn at the layer's size), the colours its
-        // variables give here, and what the scale factor makes of the main's values.
-        let follows = |k: &str, v: &Kv<'static>, theirs: &Fields| {
-            ["size", "transform", "fillGeometry", "strokeGeometry", "vectorData"].contains(&k)
-                || resolved_alike(k, v, theirs)
-                || factor.is_some_and(|x| field(theirs, k).is_some_and(|t| scaled(v, &t, x, 0.0)))
-        };
-        let mut overrides = Vec::new();
-        let mut derived = Vec::new();
-        let mut of: Fields = vec![("guidPath", o(vec![("guids", arr(vec![symbol.clone()]))]))];
-        of.extend(changed(root_mine, &root_theirs).into_iter().filter(|(k, v)| *k == "size" || !follows(k, v, &root_theirs)));
-        if of.len() > 1 {
-            overrides.push(o(of));
-        }
-        for r in rows {
-            let (mut of, mut df): (Fields, Fields) = (vec![("guidPath", r.path.clone())], vec![("guidPath", r.path)]);
-            for (k, v) in r.changed {
-                let follows = follows(k, &v, &r.theirs);
-                // A nested instance's size is its own to set, as is a size the layer overrides.
-                if follows && r.sized && k == "size" {
-                    of.push((k, v.clone()));
-                }
-                if follows { &mut df } else { &mut of }.push((k, v));
-            }
-            if df.len() > 1 {
-                derived.push(o(df));
-            }
-            of.extend(r.swap.map(|g| ("overriddenSymbolID", g)));
-            if of.len() > 1 {
-                overrides.push(o(of));
-            }
-        }
-        f.push(("symbolData", o(vec![("symbolID", symbol), ("symbolOverrides", arr(overrides)), ("uniformScaleFactor", fl(factor.unwrap_or(1.0)))])));
-        if !derived.is_empty() {
-            f.push(("derivedSymbolData", arr(derived)));
-        }
-        let mut assignments = Vec::new();
-        for (name, v) in props {
-            let (ty, value, var) = match v {
-                Value::Bool(x) => ("BOOL", o(vec![("boolValue", b(*x))]), bool_data(*x)),
-                Value::String(t) => ("TEXT", o(vec![("textValue", text_value(t))]), text_data(t)),
-                Value::Number(c) => {
-                    let Some(g) = c.as_u64().and_then(|c| self.guid_of(NodeId(c))) else { continue };
-                    ("INSTANCE_SWAP", o(vec![("guidValue", g.clone())]), symbol_data(g))
-                }
-                _ => continue,
-            };
-            // Variant values have no definition of their own: the main they show says them. A
-            // variant's instance names the variant's own copy of the definition.
-            if let Some(id) = self.def_for(main, name, ty) {
-                assignments.push(o(vec![("defID", guid(AUX, id)), ("value", value), ("varValue", var)]));
-            }
-        }
-        if !assignments.is_empty() {
-            f.push(("componentPropAssignments", arr(assignments)));
-        }
-        if n.children.iter().filter_map(|c| doc.node(*c)).any(|c| c.source.is_none()) {
-            self.warn("instance layers that don't come from their main component were left out");
-        }
-    }
-
-    /// The main component layer an instance or instance layer mirrors (through nested instances),
-    /// or `id` itself.
-    fn main_layer(&self, id: NodeId) -> NodeId {
-        let mut cur = id;
-        for _ in 0..32 {
-            let next = self.doc.node(cur).and_then(|n| match &n.kind {
-                _ if n.source.is_some() => n.source,
-                NodeKind::Instance { component, .. } => Some(*component),
-                _ => None,
-            });
-            match next.filter(|s| self.doc.contains(*s)) {
-                Some(s) => cur = s,
-                None => break,
-            }
-        }
-        cur
-    }
-
-    /// The id path of layer `d` of instance `inst` (of `main`): that of the main's layer it mirrors,
-    /// or, inside a nested instance swapped for another component, the path of that instance and
-    /// then the one inside its new main.
-    fn layer_path(&self, d: &Node, inst: NodeId, main: NodeId, depth: usize) -> Option<Vec<NodeId>> {
-        let src = d.source?;
-        if let Some(p) = self.path_in(src, main, 0) {
-            return Some(p);
-        }
-        if depth > 32 {
-            return None;
-        }
-        let doc = self.doc;
-        let nested = doc.ancestors(d.id).into_iter().take_while(|a| *a != inst).filter_map(|a| doc.node(a)).find_map(|a| match &a.kind {
-            NodeKind::Instance { component, .. } => Some((a, *component)),
-            _ => None,
-        });
-        let (outer, component) = nested?;
-        let mut p = self.layer_path(outer, inst, main, depth + 1)?;
-        p.extend(self.path_in(src, component, 0)?);
-        Some(p)
-    }
-
-    /// The id path of layer `s` inside component `comp`: `s` itself, or through the nested
-    /// instance it is expanded in, then on inside that instance's main.
-    fn path_in(&self, s: NodeId, comp: NodeId, depth: usize) -> Option<Vec<NodeId>> {
-        if depth > 32 {
-            return None;
-        }
-        let doc = self.doc;
-        let up = doc.ancestors(s);
-        let below: Vec<NodeId> = up.iter().take_while(|a| **a != comp).copied().collect();
-        if below.len() == up.len() {
-            return None;
-        }
-        // The outermost nested instance between the component and the layer.
-        match below.iter().rev().find_map(|a| match doc.node(*a).map(|n| &n.kind) {
-            Some(NodeKind::Instance { component, .. }) => Some((*a, *component)),
-            _ => None,
-        }) {
-            None => Some(vec![s]),
-            Some((inst, main)) => {
-                let mut p = vec![inst];
-                p.extend(self.path_in(doc.node(s)?.source?, main, depth + 1)?);
-                Some(p)
-            }
-        }
-    }
-
-    /// Interactions, scrolling, flow starts and the overlay settings this layer is opened with.
-    fn prototype(&mut self, n: &Node, f: &mut Fields) {
-        self.trigger_size = [n.width, n.height];
-        let list: Vec<Kv> = n.interactions.iter().filter_map(|it| self.interaction(it)).collect();
-        if !list.is_empty() {
-            f.push(("prototypeInteractions", arr(list)));
-        }
-        let dir = match n.overflow {
-            Overflow::None => None,
-            Overflow::Horizontal => Some("HORIZONTAL"),
-            Overflow::Vertical => Some("VERTICAL"),
-            Overflow::Both => Some("BOTH"),
-        };
-        f.extend(dir.map(|d| ("scrollDirection", e(d))));
-        let behavior = match n.scroll_position {
-            ScrollPosition::Scrolls => None,
-            ScrollPosition::Fixed => Some("FIXED_WHEN_CHILD_OF_SCROLLING_FRAME"),
-            ScrollPosition::Sticky => Some("STICKY_SCROLLS"),
-        };
-        f.extend(behavior.map(|x| ("scrollBehavior", e(x))));
-        if let Some((i, name)) = self.starts.get(&n.id) {
-            f.push(("prototypeStartingPoint", o(vec![("name", s(name)), ("position", s(&position(*i)))])));
-        }
-        if let Some(ov) = self.overlays.get(&n.id) {
-            const POSITIONS: [&str; 8] = ["CENTER", "TOP_LEFT", "TOP_CENTER", "TOP_RIGHT", "BOTTOM_LEFT", "BOTTOM_CENTER", "BOTTOM_RIGHT", "MANUAL"];
-            let pos = POSITIONS.into_iter().find(|p| crate::rest::proto::overlay_position(p) == Some(ov.position)).unwrap_or("CENTER");
-            let bg = match ov.background {
-                Some(c) => o(vec![("backgroundType", e("SOLID_COLOR")), ("backgroundColor", color(c))]),
-                None => o(vec![("backgroundType", e("NONE"))]),
-            };
-            f.extend([
-                ("overlayPositionType", e(pos)),
-                ("overlayBackgroundInteraction", e(if ov.close_on_outside { "CLOSE_ON_CLICK_OUTSIDE" } else { "NONE" })),
-                ("overlayBackgroundAppearance", bg),
-            ]);
-        }
-    }
-
-    fn interaction(&mut self, it: &Interaction) -> Option<Kv<'static>> {
-        let mut event: Fields = Vec::new();
-        let ty = match &it.trigger {
-            Trigger::OnClick => "ON_CLICK",
-            Trigger::OnHover => "ON_HOVER",
-            Trigger::OnPress => "ON_PRESS",
-            Trigger::OnDrag => "DRAG",
-            Trigger::MouseEnter => "MOUSE_IN",
-            Trigger::MouseLeave => "MOUSE_OUT",
-            Trigger::MouseDown => "MOUSE_DOWN",
-            Trigger::MouseUp => "MOUSE_UP",
-            Trigger::AfterDelay { ms } => {
-                event.push(("transitionTimeout", fl(f64::from(*ms) / 1000.0)));
-                "AFTER_TIMEOUT"
-            }
-            Trigger::KeyPress { key } => {
-                let Some((codes, pad)) = key_codes(key) else {
-                    self.warn("key triggers on keys the format has no code for were left out");
-                    return None;
-                };
-                let device = e(if pad { "UNKNOWN_CONTROLLER" } else { "KEYBOARD" });
-                event.push(("keyTrigger", o(vec![("keyCodes", arr(codes.into_iter().map(int).collect())), ("triggerDevice", device)])));
-                "ON_KEY_DOWN"
-            }
-        };
-        // A mouse trigger's delay is the event's timeout.
-        if it.delay_secs() > 0.0 {
-            event.push(("transitionTimeout", fl(it.delay_secs())));
-        }
-        event.insert(0, ("interactionType", e(ty)));
-        let actions: Vec<Kv> = it.actions.iter().filter_map(|a| self.action(a, it)).collect();
-        (!actions.is_empty()).then(|| o(vec![("event", o(event)), ("actions", arr(actions))]))
-    }
-
-    fn action(&mut self, a: &Action, it: &Interaction) -> Option<Kv<'static>> {
-        let node = |x: &mut Self, dest: &NodeId, nav: &'static str| -> Option<Kv<'static>> {
-            let Some(g) = x.guid_of(*dest) else {
-                x.warn("prototype actions whose destination isn't written were left out");
-                return None;
-            };
-            let mut f: Fields = vec![("transitionNodeID", g), ("connectionType", e("INTERNAL_NODE")), ("navigationType", e(nav))];
-            x.transition(it, &mut f);
-            Some(o(f))
-        };
-        let plain = |ty: &'static str| Some(o(vec![("connectionType", e(ty))]));
-        match a {
-            Action::Navigate { dest, preserve_scroll } => {
-                let mut act = node(self, dest, "NAVIGATE")?;
-                if let Kv::Object(f) = &mut act {
-                    f.push(("transitionPreserveScroll", b(*preserve_scroll)));
-                }
-                Some(act)
-            }
-            Action::OpenOverlay { dest, position, offset, anchor, .. } => {
-                let mut act = node(self, dest, "OVERLAY")?;
-                let size = self.doc.node(*dest).map_or([0.0, 0.0], |d| [d.width, d.height]);
-                let offset = match anchor.offset(*position, self.trigger_size, size) {
-                    Some(o) => Some(o),
-                    None if *position == OverlayPosition::Manual => *offset,
-                    None => None,
-                };
-                if let (Kv::Object(f), Some([x, y])) = (&mut act, offset) {
-                    f.push(("overlayRelativePosition", o(vec![("x", fl(x)), ("y", fl(y))])));
-                }
-                Some(act)
-            }
-            Action::SwapOverlay { dest } => node(self, dest, "SWAP"),
-            Action::ChangeTo { dest } => node(self, dest, "SWAP_STATE"),
-            Action::ScrollTo { dest, offset } => {
-                if *offset != [0.0, 0.0] {
-                    self.warn("scroll-to offsets were left out");
-                }
-                node(self, dest, "SCROLL_TO")
-            }
-            Action::Back => plain("BACK"),
-            Action::CloseOverlay => plain("CLOSE"),
-            Action::OpenUrl { url } => Some(o(vec![("connectionType", e("URL")), ("connectionURL", s(url))])),
-            Action::SetVariable { .. } | Action::SetVariableMode { .. } | Action::Conditional { .. } => {
-                self.warn("variable and conditional prototype actions were left out");
-                None
-            }
-        }
-    }
-
-    /// An interaction's transition on one of its actions.
-    fn transition(&mut self, it: &Interaction, f: &mut Fields) {
-        let side_from = |d: Direction, l: &'static str, r: &'static str, t: &'static str, bo: &'static str| match d {
-            // The direction names where the incoming screen moves: it comes from the other side.
-            Direction::Right => l,
-            Direction::Left => r,
-            Direction::Bottom => t,
-            Direction::Top => bo,
-        };
-        let side_to = |d: Direction, l: &'static str, r: &'static str, t: &'static str, bo: &'static str| match d {
-            Direction::Left => l,
-            Direction::Right => r,
-            Direction::Top => t,
-            Direction::Bottom => bo,
-        };
-        let ty = match it.transition {
-            Transition::Instant => "INSTANT_TRANSITION",
-            Transition::Dissolve => "DISSOLVE",
-            Transition::SmartAnimate => "SMART_ANIMATE",
-            Transition::SlideIn { direction } => side_from(direction, "SLIDE_FROM_LEFT", "SLIDE_FROM_RIGHT", "SLIDE_FROM_TOP", "SLIDE_FROM_BOTTOM"),
-            Transition::Push { direction } => side_from(direction, "PUSH_FROM_LEFT", "PUSH_FROM_RIGHT", "PUSH_FROM_TOP", "PUSH_FROM_BOTTOM"),
-            Transition::MoveIn { direction } => side_from(direction, "MOVE_FROM_LEFT", "MOVE_FROM_RIGHT", "MOVE_FROM_TOP", "MOVE_FROM_BOTTOM"),
-            Transition::SlideOut { direction } => {
-                side_to(direction, "SLIDE_OUT_TO_LEFT", "SLIDE_OUT_TO_RIGHT", "SLIDE_OUT_TO_TOP", "SLIDE_OUT_TO_BOTTOM")
-            }
-            Transition::MoveOut { direction } => side_to(direction, "MOVE_OUT_TO_LEFT", "MOVE_OUT_TO_RIGHT", "MOVE_OUT_TO_TOP", "MOVE_OUT_TO_BOTTOM"),
-        };
-        let easing = match it.easing {
-            Easing::Linear => "LINEAR",
-            Easing::EaseIn => "IN_CUBIC",
-            Easing::EaseOut => "OUT_CUBIC",
-            Easing::EaseInOut => "INOUT_CUBIC",
-            Easing::EaseInBack => "IN_BACK_CUBIC",
-            Easing::EaseOutBack => "OUT_BACK_CUBIC",
-            Easing::EaseInOutBack => "INOUT_BACK_CUBIC",
-            Easing::Gentle => "GENTLE_SPRING",
-            Easing::CustomBezier { .. } => "CUSTOM_CUBIC",
-            Easing::Quick | Easing::Bouncy | Easing::Slow | Easing::CustomSpring { .. } => {
-                self.warn("spring animations other than Gentle were written as ease out");
-                "OUT_CUBIC"
-            }
-        };
-        f.extend([("transitionType", e(ty)), ("transitionDuration", fl(f64::from(it.duration_ms) / 1000.0)), ("easingType", e(easing))]);
-        if let Easing::CustomBezier { x1, y1, x2, y2 } = it.easing {
-            f.push(("easingFunction", arr(vec![fl(x1), fl(y1), fl(x2), fl(y2)])));
-        }
-    }
 }
 
 /// The plugin id and key under which a layer written as an outline keeps what it was.
 pub(super) const STASH: (&str, &str) = ("figcraft", "stroke");
-/// Longest kept description of such a layer (bytes of JSON).
-const MAX_STASH: usize = 1 << 20;
-
-/// Whether a width profile reaches further on one side of the path than on the other.
-fn one_sided(p: &figcraft_doc::WidthProfile) -> bool {
-    p.points.iter().any(|q| q.bias.abs() > 1e-6)
-}
-
-/// A shape whose stroke is wider on one side of its path, as the area that stroke paints (a vector
-/// filled with the stroke's paints), with what it was as JSON: its kind, paints and stroke. Only
-/// for shapes that show nothing but that stroke; `None` for every other layer.
-fn outlined(n: &Node) -> Option<(Node, String)> {
-    let sp = &n.stroke;
-    let shape = matches!(
-        n.kind,
-        NodeKind::Line | NodeKind::Vector { .. } | NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. } | NodeKind::Rectangle
-    );
-    let shown = |paints: &[Paint]| paints.iter().any(|p| p.visible);
-    if !(shape
-        && sp.brush.is_none()
-        && sp.profile().is_some_and(one_sided)
-        && sp.weight.is_finite()
-        && sp.weight > 0.0
-        && shown(&n.strokes)
-        && !shown(&n.fills))
-    {
-        return None;
-    }
-    let path = figcraft_doc::geometry::stroke_geometry(n)?;
-    let net = match &n.kind {
-        NodeKind::Vector { network } => Some(network),
-        _ => None,
-    };
-    let area = figcraft_pathops::stroke_outline_of(&path, sp, figcraft_doc::geometry::is_closed(n), net);
-    if area.elements().is_empty() || area.elements().len() > MAX_NETWORK / 4 {
-        return None;
-    }
-    let original = serde_json::json!({"kind": n.kind, "fills": n.fills, "strokes": n.strokes, "stroke": n.stroke}).to_string();
-    if original.len() > MAX_STASH {
-        return None;
-    }
-    let mut network = VectorNetwork::from_path(&area);
-    for r in &mut network.regions {
-        r.winding = WindingRule::NonZero;
-    }
-    let mut v = n.clone();
-    v.kind = NodeKind::Vector { network };
-    v.fills = std::mem::take(&mut v.strokes);
-    v.stroke = Default::default();
-    v.styles.fill = v.styles.stroke.take();
-    // Bindings name the stroke's paints, which are the fills now: the values stay.
-    v.bound.retain(|k, _| !(k == "stroke" || k == "fill" || k.starts_with("strokes/") || k.starts_with("fills/") || k.starts_with("stroke")));
-    Some((v, original))
-}
-
-/// The number of the layer field a bound property (`VariableField`) is held in.
-fn node_field(field: &str) -> Option<u32> {
-    let name = match field {
-        "WIDTH" | "HEIGHT" => "size",
-        "MIN_WIDTH" | "MIN_HEIGHT" => "minSize",
-        "MAX_WIDTH" | "MAX_HEIGHT" => "maxSize",
-        "STACK_SPACING" => "stackSpacing",
-        "STACK_COUNTER_SPACING" => "stackCounterSpacing",
-        "STACK_PADDING_LEFT" => "stackHorizontalPadding",
-        "STACK_PADDING_TOP" => "stackVerticalPadding",
-        "STACK_PADDING_RIGHT" => "stackPaddingRight",
-        "STACK_PADDING_BOTTOM" => "stackPaddingBottom",
-        "CORNER_RADIUS" => "cornerRadius",
-        "RECTANGLE_TOP_LEFT_CORNER_RADIUS" => "rectangleTopLeftCornerRadius",
-        "RECTANGLE_TOP_RIGHT_CORNER_RADIUS" => "rectangleTopRightCornerRadius",
-        "RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS" => "rectangleBottomLeftCornerRadius",
-        "RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS" => "rectangleBottomRightCornerRadius",
-        "OPACITY" => "opacity",
-        "VISIBLE" => "visible",
-        "TEXT_DATA" => "textData",
-        "STROKE_WEIGHT" => "strokeWeight",
-        "BORDER_TOP_WEIGHT" => "borderTopWeight",
-        "BORDER_RIGHT_WEIGHT" => "borderRightWeight",
-        "BORDER_BOTTOM_WEIGHT" => "borderBottomWeight",
-        "BORDER_LEFT_WEIGHT" => "borderLeftWeight",
-        "FONT_SIZE" => "fontSize",
-        "FONT_FAMILY" | "FONT_STYLE" => "fontName",
-        "LETTER_SPACING" => "letterSpacing",
-        "LINE_HEIGHT" => "lineHeight",
-        "PARAGRAPH_SPACING" => "paragraphSpacing",
-        "PARAGRAPH_INDENT" => "paragraphIndent",
-        _ => return None,
-    };
-    // The numbers are the schema's.
-    let layer = SCHEMA.lines().find(|l| l.starts_with("message NodeChange "))?;
-    layer.split(", ").find_map(|f| f.rsplit_once(' ')?.1.strip_prefix(name)?.strip_prefix('=')?.parse().ok())
-}
-
-/// Whether `a` is `b` with its lengths scaled by `k`: every number is `k` times the other's (within
-/// `slack`, for sizes that snap to whole pixels) or the same, and the rest is equal.
-fn scaled(a: &Kv<'static>, b: &Kv<'static>, k: f64, slack: f64) -> bool {
-    match (a, b) {
-        (Kv::Float(x), Kv::Float(y)) => {
-            let (x, y) = (f64::from(*x), f64::from(*y));
-            x == y || (x - y * k).abs() <= slack + 1e-3 * x.abs().max(1.0)
-        }
-        (Kv::Array(x), Kv::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(p, q)| scaled(p, q, k, slack)),
-        (Kv::Object(x), Kv::Object(y)) => x.len() == y.len() && x.iter().zip(y).all(|((kp, p), (kq, q))| kp == kq && scaled(p, q, k, slack)),
-        _ => a == b,
-    }
-}
-
-/// The fields of `mine` that differ from `theirs` (a layer and the main's layer it mirrors), and
-/// the ones only `theirs` has at their empty values.
-fn changed(mine: Fields, theirs: &Fields) -> Fields {
-    let cleared: Fields = theirs.iter().filter(|(k, _)| !mine.iter().any(|(mk, _)| mk == k)).filter_map(|(k, _)| Some((*k, unset(k)?))).collect();
-    let mut out: Fields = mine.into_iter().filter(|(k, v)| !theirs.iter().any(|(tk, tv)| tk == k && tv == v)).collect();
-    out.extend(cleared);
-    out
-}
-
-/// Whether paint list `v` (field `key`) is `theirs` but for the colours variables give: two layers
-/// bound alike are the same, whatever mode each one shows.
-fn resolved_alike(key: &str, v: &Kv<'static>, theirs: &Fields) -> bool {
-    fn unresolved(v: &Kv<'static>) -> Vec<Kv<'static>> {
-        let bare = |p: &Kv<'static>| match p {
-            Kv::Object(f) if f.iter().any(|(k, _)| *k == "colorVar") => o(f.iter().filter(|(k, _)| *k != "color").cloned().collect()),
-            other => other.clone(),
-        };
-        v.list().iter().map(bare).collect()
-    }
-    matches!(key, "fillPaints" | "strokePaints") && theirs.iter().any(|(k, t)| *k == key && unresolved(t) == unresolved(v))
-}
-
-/// The format's name of a variable type.
-fn resolved_type(kind: VariableType) -> &'static str {
-    match kind {
-        VariableType::Color => "COLOR",
-        VariableType::Number => "FLOAT",
-        VariableType::String => "STRING",
-        VariableType::Boolean => "BOOLEAN",
-    }
-}
-
-/// The format's name of a variable scope (`None`: it has none).
-fn scope_name(scope: &str) -> Option<&'static str> {
-    const NAMES: [&str; 20] = [
-        "ALL_SCOPES",
-        "TEXT_CONTENT",
-        "CORNER_RADIUS",
-        "WIDTH_HEIGHT",
-        "GAP",
-        "ALL_FILLS",
-        "FRAME_FILL",
-        "SHAPE_FILL",
-        "TEXT_FILL",
-        "STROKE_FLOAT",
-        "EFFECT_FLOAT",
-        "EFFECT_COLOR",
-        "OPACITY",
-        "FONT_STYLE",
-        "FONT_FAMILY",
-        "FONT_SIZE",
-        "LINE_HEIGHT",
-        "LETTER_SPACING",
-        "PARAGRAPH_SPACING",
-        "PARAGRAPH_INDENT",
-    ];
-    if scope == "STROKE_COLOR" {
-        return Some("STROKE");
-    }
-    NAMES.into_iter().find(|n| *n == scope)
-}
-
-/// The empty value of a field only written when set (an override clears it with this).
-fn unset(key: &str) -> Option<Kv<'static>> {
-    Some(match key {
-        "styleIdForFill" | "styleIdForStrokeFill" | "styleIdForEffect" | "styleIdForGrid" | "styleIdForText" => {
-            o(vec![("guid", guid(u32::MAX, u32::MAX))])
-        }
-        "variableConsumptionMap" | "variableModeBySetMap" | "gridColumnsSizing" | "gridRowsSizing" => o(vec![("entries", arr(Vec::new()))]),
-        "mask" | "rectangleCornerRadiiIndependent" | "borderStrokeWeightsIndependent" => b(false),
-        "effects" | "dashPattern" | "layoutGrids" | "exportSettings" | "prototypeInteractions" | "fillGeometry" | "variableWidthPoints" => {
-            arr(Vec::new())
-        }
-        "cornerSmoothing" | "stackChildPrimaryGrow" => fl(0.0),
-        "stackMode" => e("NONE"),
-        "stackChildAlignSelf" | "stackPositioning" => e("AUTO"),
-        "minSize" => o(vec![("value", xy(0.0, 0.0))]),
-        // No maximum is infinite (a maximum of 0 collapses the layer).
-        "maxSize" => o(vec![("value", o(vec![("x", Kv::Float(f32::INFINITY)), ("y", Kv::Float(f32::INFINITY))]))]),
-        "gridColumnSpan" | "gridRowSpan" | "maxLines" => int(0),
-        "scrollDirection" => e("NONE"),
-        "scrollBehavior" => e("SCROLLS"),
-        "parameterConsumptionMap" => o(vec![("entries", arr(Vec::new()))]),
-        "textTruncation" => e("DISABLED"),
-        "hyperlink" => o(vec![("url", s(""))]),
-        _ => return None,
-    })
-}
 
 /// An image's name in the file: the SHA-1 of its bytes (lowercase hex). Paints refer to images by
 /// these 20 bytes, and readers reject other hash lengths (the document's own SHA-256 key is not
@@ -2673,168 +629,3 @@ pub(super) fn face_style(family: &str, style: &str) -> String {
     }
     ["Extra", "Ultra", "Semi", "Demi"].iter().fold(standard, |acc, p| acc.replace(&format!("{p} "), p))
 }
-
-/// The pairs of a variant's name, `Property=Value, …` (parts without `=` are left out).
-fn variant_pairs(name: &str) -> Vec<(String, String)> {
-    name.split(',')
-        .filter_map(|part| {
-            let (p, v) = part.split_once('=')?;
-            let (p, v) = (p.trim(), v.trim());
-            (!p.is_empty()).then(|| (p.to_string(), v.to_string()))
-        })
-        .collect()
-}
-
-/// The `index`-th sort position of a list: one printable character from `"` on, two past the end
-/// of that range.
-fn sort_position(index: usize) -> String {
-    const FIRST: u32 = 34;
-    const SPAN: usize = 93;
-    let ch = |i: usize| char::from_u32(FIRST + u32::try_from(i % SPAN).unwrap_or(0)).unwrap_or('"');
-    if index < SPAN { ch(index).to_string() } else { format!("~{}", ch(index - SPAN)) }
-}
-
-/// Text as a property value: its characters and one plain line per paragraph.
-fn text_value(t: &str) -> Kv<'static> {
-    let line = || {
-        o(vec![
-            ("lineType", e("PLAIN")),
-            ("styleId", int(0)),
-            ("indentationLevel", int(0)),
-            ("sourceDirectionality", e("AUTO")),
-            ("listStartOffset", int(0)),
-            ("isFirstLineOfList", b(false)),
-        ])
-    };
-    o(vec![("characters", s(t)), ("lines", arr(t.split('\n').map(|_| line()).collect()))])
-}
-
-/// A property value as variable data (`varValue`).
-fn var_data(value: (&'static str, Kv<'static>), ty: &'static str, resolved: &'static str) -> Kv<'static> {
-    o(vec![("value", o(vec![value])), ("dataType", e(ty)), ("resolvedDataType", e(resolved))])
-}
-fn bool_data(x: bool) -> Kv<'static> {
-    var_data(("boolValue", b(x)), "BOOLEAN", "BOOLEAN")
-}
-fn text_data(t: &str) -> Kv<'static> {
-    var_data(("textDataValue", text_value(t)), "TEXT_DATA", "TEXT_DATA")
-}
-fn symbol_data(main: Kv<'static>) -> Kv<'static> {
-    var_data(("symbolIdValue", o(vec![("guid", main)])), "SYMBOL_ID", "SYMBOL_ID")
-}
-
-/// The format's type of a component property (`None`: not written).
-fn prop_type(d: &PropDef) -> Option<&'static str> {
-    match d {
-        PropDef::Boolean { .. } => Some("BOOL"),
-        PropDef::Text { .. } => Some("TEXT"),
-        PropDef::InstanceSwap { .. } => Some("INSTANCE_SWAP"),
-        PropDef::Variant { .. } | PropDef::Slot { .. } => None,
-    }
-}
-
-/// The key codes of a key trigger (modifiers first), and whether it's a controller button.
-fn key_codes(key: &str) -> Option<(Vec<i64>, bool)> {
-    if let Some(i) = GAMEPAD_BUTTONS.iter().position(|g| g.eq_ignore_ascii_case(key.trim())) {
-        return Some((vec![i as i64], true));
-    }
-    let (mods, k): (KeyMods, &str) = KeyMods::split(key);
-    let code = (0..=255).find(|c| crate::rest::proto::key_name(f64::from(*c)).is_some_and(|n| n.eq_ignore_ascii_case(k)))?;
-    let mut codes: Vec<i64> = [(mods.shift, 16), (mods.ctrl, 17), (mods.alt, 18), (mods.cmd, 91)].into_iter().filter(|m| m.0).map(|m| m.1).collect();
-    codes.push(i64::from(code));
-    Some((codes, false))
-}
-
-/// Whether the decoration look has more than skip ink, which the file can't hold.
-fn unsupported_decoration_look(st: &TextStyle) -> bool {
-    let mut look = st.look();
-    look.skip_ink = false;
-    look != Default::default()
-}
-
-/// The text style fields of a layer or of an override table entry.
-fn style_fields(st: &TextStyle, f: &mut Fields) {
-    let line_height = match st.line_height {
-        // Percent units count from the font's own line height (100 % is "auto"); a share of the
-        // font size is a raw multiplier.
-        LineHeight::Auto => o(vec![("value", fl(100.0)), ("units", e("PERCENT"))]),
-        LineHeight::Percent(p) => o(vec![("value", fl(p / 100.0)), ("units", e("RAW"))]),
-        LineHeight::Pixels(v) => o(vec![("value", fl(v)), ("units", e("PIXELS"))]),
-    };
-    let letter_spacing = match st.letter_spacing {
-        LetterSpacing::Percent(p) => o(vec![("value", fl(p)), ("units", e("PERCENT"))]),
-        LetterSpacing::Pixels(v) => o(vec![("value", fl(v)), ("units", e("PIXELS"))]),
-    };
-    let case = match st.case {
-        TextCase::Original => "ORIGINAL",
-        TextCase::Upper => "UPPER",
-        TextCase::Lower => "LOWER",
-        TextCase::Title => "TITLE",
-        TextCase::SmallCaps => "SMALL_CAPS",
-    };
-    let decoration = match st.decoration {
-        TextDecoration::None => "NONE",
-        TextDecoration::Underline => "UNDERLINE",
-        TextDecoration::Strikethrough => "STRIKETHROUGH",
-    };
-    f.extend([
-        ("fontName", o(vec![("family", s(&st.font_family)), ("style", s(&face_style(&st.font_family, &st.font_style))), ("postscript", s(""))])),
-        ("fontSize", fl(st.font_size)),
-        ("lineHeight", line_height),
-        ("letterSpacing", letter_spacing),
-        ("textCase", e(case)),
-        ("textDecoration", e(decoration)),
-        // Skip ink only shows on an underline; other text gets the files' default (on), the value
-        // the import leaves out again.
-        ("textDecorationSkipInk", b(st.look().skip_ink || st.decoration != TextDecoration::Underline)),
-    ]);
-    if let Some(url) = &st.link {
-        f.push(("hyperlink", o(vec![("url", s(url))])));
-    }
-}
-
-/// Layout grid `index` of a layer, with the variables `bound` to its fields.
-fn layout_grid(g: &figcraft_doc::LayoutGrid, index: usize, bound: &Bound) -> Kv<'static> {
-    let (pattern, axis) = match g.kind {
-        GridKind::Grid => ("GRID", "X"),
-        GridKind::Columns => ("STRIPES", "X"),
-        GridKind::Rows => ("STRIPES", "Y"),
-    };
-    let align = match g.align {
-        GridAlign::Stretch => "STRETCH",
-        GridAlign::Min => "MIN",
-        GridAlign::Center => "CENTER",
-        GridAlign::Max => "MAX",
-    };
-    let mut f: Fields = vec![
-        ("type", e(align)),
-        ("axis", e(axis)),
-        ("visible", b(g.visible)),
-        ("numSections", int(g.count.into())),
-        ("offset", fl(g.offset)),
-        ("sectionSize", fl(g.size)),
-        ("gutterSize", fl(g.gutter)),
-        ("color", color(g.color)),
-        ("pattern", e(pattern)),
-    ];
-    let vars = [("count", "numSectionsVar"), ("offset", "offsetVar"), ("size", "sectionSizeVar"), ("gutter", "gutterSizeVar")];
-    f.extend(vars.into_iter().filter_map(|(ours, key)| Some((key, bound.grids.get(&(index, ours))?.clone()))));
-    o(f)
-}
-
-fn export_setting(x: &figcraft_doc::ExportSetting) -> Kv<'static> {
-    let format = match x.format {
-        // The format has no WebP export setting.
-        figcraft_doc::ExportFormat::Png | figcraft_doc::ExportFormat::Webp => "PNG",
-        figcraft_doc::ExportFormat::Jpg => "JPEG",
-        // Nor an Android Vector Drawable one: the nearest is the other vector format.
-        figcraft_doc::ExportFormat::Svg | figcraft_doc::ExportFormat::VectorDrawable => "SVG",
-        figcraft_doc::ExportFormat::Pdf => "PDF",
-    };
-    let (ty, value) = match x.size {
-        ExportSize::Scale { value } => ("CONTENT_SCALE", value),
-        ExportSize::Width { value } => ("CONTENT_WIDTH", value),
-        ExportSize::Height { value } => ("CONTENT_HEIGHT", value),
-    };
-    o(vec![("suffix", s(&x.suffix)), ("imageType", e(format)), ("constraint", o(vec![("type", e(ty)), ("value", fl(value))]))])
-}
diff --git a/crates/format/src/fig/export/assets.rs b/crates/format/src/fig/export/assets.rs
new file mode 100644
index 00000000..00c84639
--- /dev/null
+++ b/crates/format/src/fig/export/assets.rs
@@ -0,0 +1,365 @@
+use super::common::{layout_grid, node_field, prop_type, resolved_type, scope_name, variant_pairs};
+use super::*;
+
+impl<'d> Exporter<'d> {
+    /// GUIDs for every layer (pages first, then depth-first), component property definitions,
+    /// flow starting points and overlay settings, before anything refers to them.
+    pub(super) fn assign(&mut self) {
+        let doc = self.doc;
+        let mut stack: Vec<NodeId> = doc.pages.iter().rev().copied().collect();
+        while let Some(id) = stack.pop() {
+            let Some(n) = doc.node(id) else { continue };
+            if self.ids.len() >= MAX_NODES {
+                self.warn("the document has more layers than a .fig file is read with; the rest were left out");
+                break;
+            }
+            let local = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
+            self.ids.insert(id, local);
+            // An instance's layers aren't written (its main says them), so nothing may refer to them.
+            let mirrored = matches!(&n.kind, NodeKind::Instance { component, .. } if doc.node(*component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })));
+            if !mirrored {
+                stack.extend(n.children.iter().rev());
+            }
+            match &n.kind {
+                NodeKind::Component { props, .. } => {
+                    let set = self.set_of(id);
+                    let owner = set.unwrap_or(id);
+                    for (name, d) in props {
+                        if let Some(ty) = prop_type(d) {
+                            let key = (owner, name.clone(), ty);
+                            if !self.defs.contains_key(&key) {
+                                let def = self.next_aux();
+                                self.defs.insert(key, def);
+                            }
+                            if set.is_some() {
+                                let child = self.next_aux();
+                                self.child_defs.insert((id, name.clone(), ty), child);
+                            }
+                        }
+                    }
+                    if let Some(set) = set {
+                        for (prop, _) in variant_pairs(&n.name) {
+                            let key = (set, prop, "VARIANT");
+                            if !self.defs.contains_key(&key) {
+                                let def = self.next_aux();
+                                self.defs.insert(key, def);
+                            }
+                        }
+                    }
+                }
+                NodeKind::Page { flows, .. } => {
+                    for (i, f) in flows.iter().enumerate() {
+                        self.starts.entry(f.start).or_insert((i, f.name.clone()));
+                    }
+                }
+                _ => {}
+            }
+            for a in n.interactions.iter().flat_map(|it| figcraft_doc::proto::walk(&it.actions)) {
+                if let Action::OpenOverlay { dest, position, close_on_outside, background, anchor, .. } = a {
+                    let position = if !anchor.is_screen() && *position != OverlayPosition::Manual { OverlayPosition::Manual } else { *position };
+                    let o = Overlay { position, close_on_outside: *close_on_outside, background: *background };
+                    match self.overlays.get(dest) {
+                        Some(old) if (old.position, old.close_on_outside, old.background) != (o.position, o.close_on_outside, o.background) => {
+                            self.warn("overlays opened with different settings keep the first one's");
+                        }
+                        Some(_) => {}
+                        None => {
+                            self.overlays.insert(*dest, o);
+                        }
+                    }
+                }
+            }
+        }
+        // The page that holds styles and variables takes the next id, then their nodes.
+        let mut next = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
+        let mut node = || {
+            next = next.saturating_add(1);
+            next
+        };
+        for st in &doc.styles {
+            self.style_ids.entry(st.id.as_str()).or_insert_with(&mut node);
+        }
+        for c in &doc.variables.collections {
+            self.set_ids.entry(c.id.as_str()).or_insert_with(&mut node);
+        }
+        for v in &doc.variables.variables {
+            if self.set_ids.contains_key(v.collection.as_str()) {
+                self.var_ids.entry(v.id.as_str()).or_insert_with(&mut node);
+            }
+        }
+        for c in &doc.variables.collections {
+            for m in &c.modes {
+                if !self.mode_ids.contains_key(&(c.id.as_str(), m.id.as_str())) {
+                    let id = self.next_aux();
+                    self.mode_ids.insert((c.id.as_str(), m.id.as_str()), id);
+                }
+            }
+        }
+    }
+
+    /// The hidden page after the `pages` real ones that holds the shared styles, the variable
+    /// collections and the variables, each a node of its own.
+    pub(super) fn assets(&mut self, pages: usize) {
+        let doc = self.doc;
+        if self.style_ids.is_empty() && self.set_ids.is_empty() {
+            return;
+        }
+        let page = u32::try_from(self.ids.len() + 1).unwrap_or(u32::MAX);
+        let mut f: Fields = vec![
+            ("guid", guid(LAYERS, page)),
+            ("phase", e("CREATED")),
+            ("parentIndex", o(vec![("guid", guid(0, 0)), ("position", s(&position(pages)))])),
+            ("type", e("CANVAS")),
+            ("name", s("Internal Only Canvas")),
+        ];
+        f.extend(root_fields().into_iter().map(|(k, v)| if k == "visible" { (k, b(false)) } else { (k, v) }));
+        f.push(("internalOnly", b(true)));
+        self.nodes.push(o(f));
+        let mut index = 0usize;
+        let mut head = |local: u32, ty: &'static str, name: &str| -> Fields {
+            index += 1;
+            vec![
+                ("guid", guid(LAYERS, local)),
+                ("phase", e("CREATED")),
+                ("parentIndex", o(vec![("guid", guid(LAYERS, page)), ("position", s(&position(index)))])),
+                ("type", e(ty)),
+                ("name", s(name)),
+                ("sortPosition", s(&position(index))),
+            ]
+        };
+        for st in &doc.styles {
+            let Some(&local) = self.style_ids.get(st.id.as_str()) else { continue };
+            // A sample layer that shows the style: a square for paints and effects, a frame for
+            // grids, two letters for text.
+            let (ty, kind) = match &st.kind {
+                StyleKind::Paint { .. } => ("ROUNDED_RECTANGLE", "FILL"),
+                StyleKind::Effect { .. } => ("ROUNDED_RECTANGLE", "EFFECT"),
+                StyleKind::Grid { .. } => ("FRAME", "GRID"),
+                StyleKind::Text { .. } => ("TEXT", "TEXT"),
+            };
+            let mut f = head(local, ty, &st.name);
+            f.extend([
+                ("styleType", e(kind)),
+                ("visible", b(true)),
+                ("opacity", fl(1.0)),
+                ("size", xy(100.0, 100.0)),
+                ("transform", matrix(Affine::IDENTITY)),
+                ("strokeWeight", fl(0.0)),
+                ("strokeAlign", e("INSIDE")),
+                ("strokeJoin", e("MITER")),
+            ]);
+            if !st.description.is_empty() {
+                f.push(("description", s(&st.description)));
+            }
+            // The style's variable bindings ride on its sample layer, as a layer's do.
+            let none = if st.bound.is_empty() {
+                Bound::default()
+            } else {
+                let mut sample = Node::new(NodeId(0), NodeKind::Rectangle, "", 0.0, 0.0);
+                if let StyleKind::Text { style } = &st.kind {
+                    sample.kind = NodeKind::Text(TextData { style: style.as_text_style(), ..TextData::new("Ag") });
+                }
+                sample.bound.clone_from(&st.bound);
+                self.bound(&sample)
+            };
+            let entries = none.entries.clone();
+            if !entries.is_empty() {
+                f.push(("variableConsumptionMap", o(vec![("entries", arr(entries))])));
+            }
+            match &st.kind {
+                StyleKind::Paint { paints } => f.push(("fillPaints", self.paints(paints, true, &none))),
+                StyleKind::Effect { effects } => {
+                    let list = effects.iter().enumerate().map(|(i, x)| self.effect(x, i, &none)).collect();
+                    f.extend([("fillPaints", arr(Vec::new())), ("effects", arr(list))]);
+                }
+                StyleKind::Grid { grids } => {
+                    let list = grids.iter().enumerate().map(|(i, g)| layout_grid(g, i, &none)).collect();
+                    f.extend([("fillPaints", arr(Vec::new())), ("layoutGrids", arr(list))]);
+                }
+                StyleKind::Text { style } => {
+                    let td = TextData { style: style.as_text_style(), ..TextData::new("Ag") };
+                    let fills = [Paint::solid(Color::BLACK)];
+                    f.push(("fillPaints", self.paints(style.fills.as_deref().unwrap_or(&fills), true, &none)));
+                    self.text(&td, &fills, &mut f);
+                }
+            }
+            self.nodes.push(o(f));
+        }
+        for c in &doc.variables.collections {
+            let Some(&local) = self.set_ids.get(c.id.as_str()) else { continue };
+            let mut f = head(local, "VARIABLE_SET", &c.name);
+            let modes = c.modes.iter().enumerate().filter_map(|(i, m)| {
+                let id = self.mode_ids.get(&(c.id.as_str(), m.id.as_str()))?;
+                Some(o(vec![("id", guid(AUX, *id)), ("name", s(&m.name)), ("sortPosition", s(&position(i)))]))
+            });
+            f.push(("variableSetModes", arr(modes.collect())));
+            self.nodes.push(o(f));
+            if c.extends.is_some() {
+                self.warn("extended variable collections were written as collections of their own");
+            }
+        }
+        for v in &doc.variables.variables {
+            let ids = (self.var_ids.get(v.id.as_str()), self.set_ids.get(v.collection.as_str()));
+            let (Some(&local), Some(&set), Some(c)) = (ids.0, ids.1, doc.variables.collections.iter().find(|c| c.id == v.collection)) else {
+                self.warn("variables whose collection isn't in the document were left out");
+                continue;
+            };
+            let resolved = resolved_type(v.kind);
+            let mut values = Vec::new();
+            for m in &c.modes {
+                let (Some(mode), Some(val)) = (self.mode_ids.get(&(c.id.as_str(), m.id.as_str())), v.values.get(&m.id)) else { continue };
+                let (ty, value) = match val {
+                    VariableValue::Color(x) => ("COLOR", ("colorValue", color(*x))),
+                    VariableValue::Number(x) => ("FLOAT", ("floatValue", fl(*x))),
+                    // NULs can't be stored in a string.
+                    VariableValue::String(x) => ("STRING", ("textValue", s(&x.replace('\0', "")))),
+                    VariableValue::Boolean(x) => ("BOOLEAN", ("boolValue", b(*x))),
+                    VariableValue::Alias(a) => match self.var_ids.get(a.as_str()) {
+                        Some(t) => ("ALIAS", ("alias", o(vec![("guid", guid(LAYERS, *t))]))),
+                        None => {
+                            self.warn("variable aliases to variables that aren't in the document were left out");
+                            continue;
+                        }
+                    },
+                };
+                let data = o(vec![("value", o(vec![value])), ("dataType", e(ty)), ("resolvedDataType", e(resolved))]);
+                values.push(o(vec![("modeID", guid(AUX, *mode)), ("variableData", data)]));
+            }
+            let mut f = head(local, "VARIABLE", &v.name);
+            f.extend([
+                ("variableSetID", o(vec![("guid", guid(LAYERS, set))])),
+                ("variableResolvedType", e(resolved)),
+                ("variableDataValues", o(vec![("entries", arr(values))])),
+            ]);
+            if !v.description.is_empty() {
+                f.push(("description", s(&v.description)));
+            }
+            if let Some(scopes) = &v.scopes {
+                let known: Vec<Kv> = scopes.iter().filter_map(|sc| scope_name(sc)).map(e).collect();
+                if known.len() < scopes.len() {
+                    self.warn("variable scopes the format has no name for were left out");
+                }
+                f.push(("variableScopes", arr(known)));
+            }
+            if v.hidden_from_publishing || !v.code_syntax.is_empty() || v.extends.is_some() {
+                self.warn("variables' publishing, code syntax and inheritance settings were left out");
+            }
+            self.nodes.push(o(f));
+        }
+    }
+
+    /// A reference to variable `var` (its id or name) as variable data.
+    fn alias(&mut self, var: &str) -> Option<Kv<'static>> {
+        let found = self.doc.variables.get(var).and_then(|v| Some((v.kind, *self.var_ids.get(v.id.as_str())?)));
+        let Some((kind, local)) = found else {
+            self.warn("bindings to variables that aren't in the document were written as their values");
+            return None;
+        };
+        Some(o(vec![
+            ("value", o(vec![("alias", o(vec![("guid", guid(LAYERS, local))]))])),
+            ("dataType", e("ALIAS")),
+            ("resolvedDataType", e(resolved_type(kind))),
+        ]))
+    }
+
+    /// Layer `n`'s variable bindings, sorted into the fields that carry them. What the format has
+    /// no field for stays as the value the layer already shows, with a warning.
+    pub(super) fn bound(&mut self, n: &Node) -> Bound {
+        const BAKED: &str = "variables bound to properties the format has no field for were written as their values";
+        let mut out = Bound::default();
+        for (key, var) in &n.bound {
+            let parts: Vec<&str> = key.split('/').collect();
+            let index = |i: &str| i.parse::<usize>().ok().filter(|_| i.bytes().all(|c| c.is_ascii_digit()));
+            let fields: &[&'static str] = match (parts.as_slice(), key.as_str()) {
+                (_, "fill" | "fills" | "fills/0" | "stroke") => {
+                    if let Some(a) = self.alias(var) {
+                        out.paints.insert((key != "stroke", 0), a);
+                    }
+                    continue;
+                }
+                ([list @ ("fills" | "strokes"), i, "color"], _) => {
+                    if let (Some(i), Some(a)) = (index(i), self.alias(var)) {
+                        out.paints.insert((*list == "fills", i), a);
+                    }
+                    continue;
+                }
+                ([list @ ("fills" | "strokes"), i, "stops", j, "color"], _) => {
+                    if let (Some(i), Some(j), Some(a)) = (index(i), index(j), self.alias(var)) {
+                        out.stops.insert((*list == "fills", i, j), a);
+                    }
+                    continue;
+                }
+                ([list @ ("effects" | "layoutGrids"), i, field], _) => {
+                    let names: &[&'static str] = if *list == "effects" {
+                        &["color", "radius", "spread", "offsetX", "offsetY", "startRadius"]
+                    } else {
+                        &["size", "count", "gutter", "offset"]
+                    };
+                    match (index(i), names.iter().find(|f| *f == field)) {
+                        (Some(i), Some(name)) => {
+                            if let Some(a) = self.alias(var) {
+                                if *list == "effects" { &mut out.effects } else { &mut out.grids }.insert((i, *name), a);
+                            }
+                        }
+                        _ => self.warn(BAKED),
+                    }
+                    continue;
+                }
+                (_, "width") => &["WIDTH"],
+                (_, "height") => &["HEIGHT"],
+                (_, "gap") => &["STACK_SPACING"],
+                (_, "crossGap") => &["STACK_COUNTER_SPACING"],
+                (_, "paddingLeft") => &["STACK_PADDING_LEFT"],
+                (_, "paddingTop") => &["STACK_PADDING_TOP"],
+                (_, "paddingRight") => &["STACK_PADDING_RIGHT"],
+                (_, "paddingBottom") => &["STACK_PADDING_BOTTOM"],
+                (_, "paddingHorizontal") => &["STACK_PADDING_LEFT", "STACK_PADDING_RIGHT"],
+                (_, "paddingVertical") => &["STACK_PADDING_TOP", "STACK_PADDING_BOTTOM"],
+                (_, "padding") => &["STACK_PADDING_LEFT", "STACK_PADDING_TOP", "STACK_PADDING_RIGHT", "STACK_PADDING_BOTTOM"],
+                (_, "cornerRadius") => &[
+                    "CORNER_RADIUS",
+                    "RECTANGLE_TOP_LEFT_CORNER_RADIUS",
+                    "RECTANGLE_TOP_RIGHT_CORNER_RADIUS",
+                    "RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS",
+                    "RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS",
+                ],
+                (_, "topLeftRadius") => &["RECTANGLE_TOP_LEFT_CORNER_RADIUS"],
+                (_, "topRightRadius") => &["RECTANGLE_TOP_RIGHT_CORNER_RADIUS"],
+                (_, "bottomLeftRadius") => &["RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS"],
+                (_, "bottomRightRadius") => &["RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS"],
+                (_, "opacity") => &["OPACITY"],
+                (_, "visible") => &["VISIBLE"],
+                (_, "characters") => &["TEXT_DATA"],
+                (_, "strokeWeight") => &["STROKE_WEIGHT"],
+                (_, "strokeTopWeight") => &["BORDER_TOP_WEIGHT"],
+                (_, "strokeRightWeight") => &["BORDER_RIGHT_WEIGHT"],
+                (_, "strokeBottomWeight") => &["BORDER_BOTTOM_WEIGHT"],
+                (_, "strokeLeftWeight") => &["BORDER_LEFT_WEIGHT"],
+                (_, "minWidth") => &["MIN_WIDTH"],
+                (_, "maxWidth") => &["MAX_WIDTH"],
+                (_, "minHeight") => &["MIN_HEIGHT"],
+                (_, "maxHeight") => &["MAX_HEIGHT"],
+                (_, "fontSize") => &["FONT_SIZE"],
+                (_, "fontFamily") => &["FONT_FAMILY"],
+                (_, "fontStyle") => &["FONT_STYLE"],
+                (_, "letterSpacing") => &["LETTER_SPACING"],
+                (_, "lineHeight") => &["LINE_HEIGHT"],
+                (_, "paragraphSpacing") => &["PARAGRAPH_SPACING"],
+                (_, "paragraphIndent") => &["PARAGRAPH_INDENT"],
+                _ => {
+                    self.warn(BAKED);
+                    continue;
+                }
+            };
+            // Each entry names the bound property and the number of the layer field that holds it.
+            for field in fields {
+                if let Some(a) = self.alias(var) {
+                    let mut entry: Fields = node_field(field).into_iter().map(|id| ("nodeField", u(id))).collect();
+                    entry.extend([("variableData", a), ("variableField", e(field))]);
+                    out.entries.push(o(entry));
+                }
+            }
+        }
+        out
+    }
+}
diff --git a/crates/format/src/fig/export/common.rs b/crates/format/src/fig/export/common.rs
new file mode 100644
index 00000000..2853dd72
--- /dev/null
+++ b/crates/format/src/fig/export/common.rs
@@ -0,0 +1,365 @@
+use super::*;
+
+/// Longest kept description of such a layer (bytes of JSON).
+const MAX_STASH: usize = 1 << 20;
+
+/// Whether a width profile reaches further on one side of the path than on the other.
+pub(super) fn one_sided(p: &figcraft_doc::WidthProfile) -> bool {
+    p.points.iter().any(|q| q.bias.abs() > 1e-6)
+}
+
+/// A shape whose stroke is wider on one side of its path, as the area that stroke paints (a vector
+/// filled with the stroke's paints), with what it was as JSON: its kind, paints and stroke. Only
+/// for shapes that show nothing but that stroke; `None` for every other layer.
+pub(super) fn outlined(n: &Node) -> Option<(Node, String)> {
+    let sp = &n.stroke;
+    let shape = matches!(
+        n.kind,
+        NodeKind::Line | NodeKind::Vector { .. } | NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. } | NodeKind::Rectangle
+    );
+    let shown = |paints: &[Paint]| paints.iter().any(|p| p.visible);
+    if !(shape
+        && sp.brush.is_none()
+        && sp.profile().is_some_and(one_sided)
+        && sp.weight.is_finite()
+        && sp.weight > 0.0
+        && shown(&n.strokes)
+        && !shown(&n.fills))
+    {
+        return None;
+    }
+    let path = figcraft_doc::geometry::stroke_geometry(n)?;
+    let net = match &n.kind {
+        NodeKind::Vector { network } => Some(network),
+        _ => None,
+    };
+    let area = figcraft_pathops::stroke_outline_of(&path, sp, figcraft_doc::geometry::is_closed(n), net);
+    if area.elements().is_empty() || area.elements().len() > MAX_NETWORK / 4 {
+        return None;
+    }
+    let original = serde_json::json!({"kind": n.kind, "fills": n.fills, "strokes": n.strokes, "stroke": n.stroke}).to_string();
+    if original.len() > MAX_STASH {
+        return None;
+    }
+    let mut network = VectorNetwork::from_path(&area);
+    for r in &mut network.regions {
+        r.winding = WindingRule::NonZero;
+    }
+    let mut v = n.clone();
+    v.kind = NodeKind::Vector { network };
+    v.fills = std::mem::take(&mut v.strokes);
+    v.stroke = Default::default();
+    v.styles.fill = v.styles.stroke.take();
+    // Bindings name the stroke's paints, which are the fills now: the values stay.
+    v.bound.retain(|k, _| !(k == "stroke" || k == "fill" || k.starts_with("strokes/") || k.starts_with("fills/") || k.starts_with("stroke")));
+    Some((v, original))
+}
+
+/// The number of the layer field a bound property (`VariableField`) is held in.
+pub(super) fn node_field(field: &str) -> Option<u32> {
+    let name = match field {
+        "WIDTH" | "HEIGHT" => "size",
+        "MIN_WIDTH" | "MIN_HEIGHT" => "minSize",
+        "MAX_WIDTH" | "MAX_HEIGHT" => "maxSize",
+        "STACK_SPACING" => "stackSpacing",
+        "STACK_COUNTER_SPACING" => "stackCounterSpacing",
+        "STACK_PADDING_LEFT" => "stackHorizontalPadding",
+        "STACK_PADDING_TOP" => "stackVerticalPadding",
+        "STACK_PADDING_RIGHT" => "stackPaddingRight",
+        "STACK_PADDING_BOTTOM" => "stackPaddingBottom",
+        "CORNER_RADIUS" => "cornerRadius",
+        "RECTANGLE_TOP_LEFT_CORNER_RADIUS" => "rectangleTopLeftCornerRadius",
+        "RECTANGLE_TOP_RIGHT_CORNER_RADIUS" => "rectangleTopRightCornerRadius",
+        "RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS" => "rectangleBottomLeftCornerRadius",
+        "RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS" => "rectangleBottomRightCornerRadius",
+        "OPACITY" => "opacity",
+        "VISIBLE" => "visible",
+        "TEXT_DATA" => "textData",
+        "STROKE_WEIGHT" => "strokeWeight",
+        "BORDER_TOP_WEIGHT" => "borderTopWeight",
+        "BORDER_RIGHT_WEIGHT" => "borderRightWeight",
+        "BORDER_BOTTOM_WEIGHT" => "borderBottomWeight",
+        "BORDER_LEFT_WEIGHT" => "borderLeftWeight",
+        "FONT_SIZE" => "fontSize",
+        "FONT_FAMILY" | "FONT_STYLE" => "fontName",
+        "LETTER_SPACING" => "letterSpacing",
+        "LINE_HEIGHT" => "lineHeight",
+        "PARAGRAPH_SPACING" => "paragraphSpacing",
+        "PARAGRAPH_INDENT" => "paragraphIndent",
+        _ => return None,
+    };
+    // The numbers are the schema's.
+    let layer = SCHEMA.lines().find(|l| l.starts_with("message NodeChange "))?;
+    layer.split(", ").find_map(|f| f.rsplit_once(' ')?.1.strip_prefix(name)?.strip_prefix('=')?.parse().ok())
+}
+
+/// Whether `a` is `b` with its lengths scaled by `k`: every number is `k` times the other's (within
+/// `slack`, for sizes that snap to whole pixels) or the same, and the rest is equal.
+pub(super) fn scaled(a: &Kv<'static>, b: &Kv<'static>, k: f64, slack: f64) -> bool {
+    match (a, b) {
+        (Kv::Float(x), Kv::Float(y)) => {
+            let (x, y) = (f64::from(*x), f64::from(*y));
+            x == y || (x - y * k).abs() <= slack + 1e-3 * x.abs().max(1.0)
+        }
+        (Kv::Array(x), Kv::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(p, q)| scaled(p, q, k, slack)),
+        (Kv::Object(x), Kv::Object(y)) => x.len() == y.len() && x.iter().zip(y).all(|((kp, p), (kq, q))| kp == kq && scaled(p, q, k, slack)),
+        _ => a == b,
+    }
+}
+
+/// The fields of `mine` that differ from `theirs` (a layer and the main's layer it mirrors), and
+/// the ones only `theirs` has at their empty values.
+pub(super) fn changed(mine: Fields, theirs: &Fields) -> Fields {
+    let cleared: Fields = theirs.iter().filter(|(k, _)| !mine.iter().any(|(mk, _)| mk == k)).filter_map(|(k, _)| Some((*k, unset(k)?))).collect();
+    let mut out: Fields = mine.into_iter().filter(|(k, v)| !theirs.iter().any(|(tk, tv)| tk == k && tv == v)).collect();
+    out.extend(cleared);
+    out
+}
+
+/// Whether paint list `v` (field `key`) is `theirs` but for the colours variables give: two layers
+/// bound alike are the same, whatever mode each one shows.
+pub(super) fn resolved_alike(key: &str, v: &Kv<'static>, theirs: &Fields) -> bool {
+    fn unresolved(v: &Kv<'static>) -> Vec<Kv<'static>> {
+        let bare = |p: &Kv<'static>| match p {
+            Kv::Object(f) if f.iter().any(|(k, _)| *k == "colorVar") => o(f.iter().filter(|(k, _)| *k != "color").cloned().collect()),
+            other => other.clone(),
+        };
+        v.list().iter().map(bare).collect()
+    }
+    matches!(key, "fillPaints" | "strokePaints") && theirs.iter().any(|(k, t)| *k == key && unresolved(t) == unresolved(v))
+}
+
+/// The format's name of a variable type.
+pub(super) fn resolved_type(kind: VariableType) -> &'static str {
+    match kind {
+        VariableType::Color => "COLOR",
+        VariableType::Number => "FLOAT",
+        VariableType::String => "STRING",
+        VariableType::Boolean => "BOOLEAN",
+    }
+}
+
+/// The format's name of a variable scope (`None`: it has none).
+pub(super) fn scope_name(scope: &str) -> Option<&'static str> {
+    const NAMES: [&str; 20] = [
+        "ALL_SCOPES",
+        "TEXT_CONTENT",
+        "CORNER_RADIUS",
+        "WIDTH_HEIGHT",
+        "GAP",
+        "ALL_FILLS",
+        "FRAME_FILL",
+        "SHAPE_FILL",
+        "TEXT_FILL",
+        "STROKE_FLOAT",
+        "EFFECT_FLOAT",
+        "EFFECT_COLOR",
+        "OPACITY",
+        "FONT_STYLE",
+        "FONT_FAMILY",
+        "FONT_SIZE",
+        "LINE_HEIGHT",
+        "LETTER_SPACING",
+        "PARAGRAPH_SPACING",
+        "PARAGRAPH_INDENT",
+    ];
+    if scope == "STROKE_COLOR" {
+        return Some("STROKE");
+    }
+    NAMES.into_iter().find(|n| *n == scope)
+}
+
+/// The empty value of a field only written when set (an override clears it with this).
+fn unset(key: &str) -> Option<Kv<'static>> {
+    Some(match key {
+        "styleIdForFill" | "styleIdForStrokeFill" | "styleIdForEffect" | "styleIdForGrid" | "styleIdForText" => {
+            o(vec![("guid", guid(u32::MAX, u32::MAX))])
+        }
+        "variableConsumptionMap" | "variableModeBySetMap" | "gridColumnsSizing" | "gridRowsSizing" => o(vec![("entries", arr(Vec::new()))]),
+        "mask" | "rectangleCornerRadiiIndependent" | "borderStrokeWeightsIndependent" => b(false),
+        "effects" | "dashPattern" | "layoutGrids" | "exportSettings" | "prototypeInteractions" | "fillGeometry" | "variableWidthPoints" => {
+            arr(Vec::new())
+        }
+        "cornerSmoothing" | "stackChildPrimaryGrow" => fl(0.0),
+        "stackMode" => e("NONE"),
+        "stackChildAlignSelf" | "stackPositioning" => e("AUTO"),
+        "minSize" => o(vec![("value", xy(0.0, 0.0))]),
+        // No maximum is infinite (a maximum of 0 collapses the layer).
+        "maxSize" => o(vec![("value", o(vec![("x", Kv::Float(f32::INFINITY)), ("y", Kv::Float(f32::INFINITY))]))]),
+        "gridColumnSpan" | "gridRowSpan" | "maxLines" => int(0),
+        "scrollDirection" => e("NONE"),
+        "scrollBehavior" => e("SCROLLS"),
+        "parameterConsumptionMap" => o(vec![("entries", arr(Vec::new()))]),
+        "textTruncation" => e("DISABLED"),
+        "hyperlink" => o(vec![("url", s(""))]),
+        _ => return None,
+    })
+}
+
+/// The pairs of a variant's name, `Property=Value, …` (parts without `=` are left out).
+pub(super) fn variant_pairs(name: &str) -> Vec<(String, String)> {
+    name.split(',')
+        .filter_map(|part| {
+            let (p, v) = part.split_once('=')?;
+            let (p, v) = (p.trim(), v.trim());
+            (!p.is_empty()).then(|| (p.to_string(), v.to_string()))
+        })
+        .collect()
+}
+
+/// The `index`-th sort position of a list: one printable character from `"` on, two past the end
+/// of that range.
+pub(super) fn sort_position(index: usize) -> String {
+    const FIRST: u32 = 34;
+    const SPAN: usize = 93;
+    let ch = |i: usize| char::from_u32(FIRST + u32::try_from(i % SPAN).unwrap_or(0)).unwrap_or('"');
+    if index < SPAN { ch(index).to_string() } else { format!("~{}", ch(index - SPAN)) }
+}
+
+/// Text as a property value: its characters and one plain line per paragraph.
+pub(super) fn text_value(t: &str) -> Kv<'static> {
+    let line = || {
+        o(vec![
+            ("lineType", e("PLAIN")),
+            ("styleId", int(0)),
+            ("indentationLevel", int(0)),
+            ("sourceDirectionality", e("AUTO")),
+            ("listStartOffset", int(0)),
+            ("isFirstLineOfList", b(false)),
+        ])
+    };
+    o(vec![("characters", s(t)), ("lines", arr(t.split('\n').map(|_| line()).collect()))])
+}
+
+/// A property value as variable data (`varValue`).
+pub(super) fn var_data(value: (&'static str, Kv<'static>), ty: &'static str, resolved: &'static str) -> Kv<'static> {
+    o(vec![("value", o(vec![value])), ("dataType", e(ty)), ("resolvedDataType", e(resolved))])
+}
+
+pub(super) fn bool_data(x: bool) -> Kv<'static> {
+    var_data(("boolValue", b(x)), "BOOLEAN", "BOOLEAN")
+}
+
+pub(super) fn text_data(t: &str) -> Kv<'static> {
+    var_data(("textDataValue", text_value(t)), "TEXT_DATA", "TEXT_DATA")
+}
+
+pub(super) fn symbol_data(main: Kv<'static>) -> Kv<'static> {
+    var_data(("symbolIdValue", o(vec![("guid", main)])), "SYMBOL_ID", "SYMBOL_ID")
+}
+
+/// The format's type of a component property (`None`: not written).
+pub(super) fn prop_type(d: &PropDef) -> Option<&'static str> {
+    match d {
+        PropDef::Boolean { .. } => Some("BOOL"),
+        PropDef::Text { .. } => Some("TEXT"),
+        PropDef::InstanceSwap { .. } => Some("INSTANCE_SWAP"),
+        PropDef::Variant { .. } | PropDef::Slot { .. } => None,
+    }
+}
+
+/// The key codes of a key trigger (modifiers first), and whether it's a controller button.
+pub(super) fn key_codes(key: &str) -> Option<(Vec<i64>, bool)> {
+    if let Some(i) = GAMEPAD_BUTTONS.iter().position(|g| g.eq_ignore_ascii_case(key.trim())) {
+        return Some((vec![i as i64], true));
+    }
+    let (mods, k): (KeyMods, &str) = KeyMods::split(key);
+    let code = (0..=255).find(|c| crate::rest::proto::key_name(f64::from(*c)).is_some_and(|n| n.eq_ignore_ascii_case(k)))?;
+    let mut codes: Vec<i64> = [(mods.shift, 16), (mods.ctrl, 17), (mods.alt, 18), (mods.cmd, 91)].into_iter().filter(|m| m.0).map(|m| m.1).collect();
+    codes.push(i64::from(code));
+    Some((codes, false))
+}
+
+/// Whether the decoration look has more than skip ink, which the file can't hold.
+pub(super) fn unsupported_decoration_look(st: &TextStyle) -> bool {
+    let mut look = st.look();
+    look.skip_ink = false;
+    look != Default::default()
+}
+
+/// The text style fields of a layer or of an override table entry.
+pub(super) fn style_fields(st: &TextStyle, f: &mut Fields) {
+    let line_height = match st.line_height {
+        // Percent units count from the font's own line height (100 % is "auto"); a share of the
+        // font size is a raw multiplier.
+        LineHeight::Auto => o(vec![("value", fl(100.0)), ("units", e("PERCENT"))]),
+        LineHeight::Percent(p) => o(vec![("value", fl(p / 100.0)), ("units", e("RAW"))]),
+        LineHeight::Pixels(v) => o(vec![("value", fl(v)), ("units", e("PIXELS"))]),
+    };
+    let letter_spacing = match st.letter_spacing {
+        LetterSpacing::Percent(p) => o(vec![("value", fl(p)), ("units", e("PERCENT"))]),
+        LetterSpacing::Pixels(v) => o(vec![("value", fl(v)), ("units", e("PIXELS"))]),
+    };
+    let case = match st.case {
+        TextCase::Original => "ORIGINAL",
+        TextCase::Upper => "UPPER",
+        TextCase::Lower => "LOWER",
+        TextCase::Title => "TITLE",
+        TextCase::SmallCaps => "SMALL_CAPS",
+    };
+    let decoration = match st.decoration {
+        TextDecoration::None => "NONE",
+        TextDecoration::Underline => "UNDERLINE",
+        TextDecoration::Strikethrough => "STRIKETHROUGH",
+    };
+    f.extend([
+        ("fontName", o(vec![("family", s(&st.font_family)), ("style", s(&face_style(&st.font_family, &st.font_style))), ("postscript", s(""))])),
+        ("fontSize", fl(st.font_size)),
+        ("lineHeight", line_height),
+        ("letterSpacing", letter_spacing),
+        ("textCase", e(case)),
+        ("textDecoration", e(decoration)),
+        // Skip ink only shows on an underline; other text gets the files' default (on), the value
+        // the import leaves out again.
+        ("textDecorationSkipInk", b(st.look().skip_ink || st.decoration != TextDecoration::Underline)),
+    ]);
+    if let Some(url) = &st.link {
+        f.push(("hyperlink", o(vec![("url", s(url))])));
+    }
+}
+
+/// Layout grid `index` of a layer, with the variables `bound` to its fields.
+pub(super) fn layout_grid(g: &figcraft_doc::LayoutGrid, index: usize, bound: &Bound) -> Kv<'static> {
+    let (pattern, axis) = match g.kind {
+        GridKind::Grid => ("GRID", "X"),
+        GridKind::Columns => ("STRIPES", "X"),
+        GridKind::Rows => ("STRIPES", "Y"),
+    };
+    let align = match g.align {
+        GridAlign::Stretch => "STRETCH",
+        GridAlign::Min => "MIN",
+        GridAlign::Center => "CENTER",
+        GridAlign::Max => "MAX",
+    };
+    let mut f: Fields = vec![
+        ("type", e(align)),
+        ("axis", e(axis)),
+        ("visible", b(g.visible)),
+        ("numSections", int(g.count.into())),
+        ("offset", fl(g.offset)),
+        ("sectionSize", fl(g.size)),
+        ("gutterSize", fl(g.gutter)),
+        ("color", color(g.color)),
+        ("pattern", e(pattern)),
+    ];
+    let vars = [("count", "numSectionsVar"), ("offset", "offsetVar"), ("size", "sectionSizeVar"), ("gutter", "gutterSizeVar")];
+    f.extend(vars.into_iter().filter_map(|(ours, key)| Some((key, bound.grids.get(&(index, ours))?.clone()))));
+    o(f)
+}
+
+pub(super) fn export_setting(x: &figcraft_doc::ExportSetting) -> Kv<'static> {
+    let format = match x.format {
+        // The format has no WebP export setting.
+        figcraft_doc::ExportFormat::Png | figcraft_doc::ExportFormat::Webp => "PNG",
+        figcraft_doc::ExportFormat::Jpg => "JPEG",
+        // Nor an Android Vector Drawable one: the nearest is the other vector format.
+        figcraft_doc::ExportFormat::Svg | figcraft_doc::ExportFormat::VectorDrawable => "SVG",
+        figcraft_doc::ExportFormat::Pdf => "PDF",
+    };
+    let (ty, value) = match x.size {
+        ExportSize::Scale { value } => ("CONTENT_SCALE", value),
+        ExportSize::Width { value } => ("CONTENT_WIDTH", value),
+        ExportSize::Height { value } => ("CONTENT_HEIGHT", value),
+    };
+    o(vec![("suffix", s(&x.suffix)), ("imageType", e(format)), ("constraint", o(vec![("type", e(ty)), ("value", fl(value))]))])
+}
diff --git a/crates/format/src/fig/export/component.rs b/crates/format/src/fig/export/component.rs
new file mode 100644
index 00000000..7d88dcc8
--- /dev/null
+++ b/crates/format/src/fig/export/component.rs
@@ -0,0 +1,324 @@
+use super::common::{
+    bool_data, changed, prop_type, resolved_alike, scaled, sort_position, symbol_data, text_data, text_value, var_data, variant_pairs,
+};
+use super::*;
+
+impl<'d> Exporter<'d> {
+    /// A component property definition of `owner` (a component, or a set), `index`-th in its list.
+    /// The default value is written twice: as `initialValue` and as `varValue`, which is what
+    /// readers that know variables take.
+    pub(super) fn prop_def(&mut self, owner: NodeId, name: &str, d: &PropDef, index: usize) -> Option<Kv<'static>> {
+        let ty = prop_type(d)?;
+        let id = *self.defs.get(&(owner, name.to_string(), ty))?;
+        let (value, var) = match d {
+            PropDef::Boolean { default } => (o(vec![("boolValue", b(*default))]), bool_data(*default)),
+            PropDef::Text { default } => (o(vec![("textValue", text_value(default))]), text_data(default)),
+            PropDef::InstanceSwap { default, preferred } => {
+                if !preferred.is_empty() {
+                    self.warn("preferred values of instance swap properties were left out");
+                }
+                let main = self.guid_of(*default)?;
+                (o(vec![("guidValue", main.clone())]), symbol_data(main))
+            }
+            PropDef::Variant { .. } | PropDef::Slot { .. } => return None,
+        };
+        Some(o(vec![
+            ("id", guid(AUX, id)),
+            ("name", s(name)),
+            ("initialValue", value),
+            ("sortPosition", s(&sort_position(index))),
+            ("type", e(ty)),
+            ("preferredValues", o(Vec::new())),
+            ("varValue", var),
+        ]))
+    }
+
+    /// A component set's property definitions: its variant properties (from the variants' names,
+    /// in the order they first appear, with their values in order) and the other properties its
+    /// variants share; written on the set, as the format keeps them.
+    pub(super) fn set_props(&mut self, set: &Node, f: &mut Fields) {
+        let doc = self.doc;
+        let variants: Vec<&Node> =
+            set.children.iter().filter_map(|c| doc.node(*c)).filter(|c| matches!(c.kind, NodeKind::Component { .. })).collect();
+        let mut order: Vec<(String, Vec<String>)> = Vec::new();
+        for v in &variants {
+            for (prop, value) in variant_pairs(&v.name) {
+                let i = match order.iter().position(|(p, _)| *p == prop) {
+                    Some(i) => i,
+                    None => {
+                        order.push((prop, Vec::new()));
+                        order.len() - 1
+                    }
+                };
+                if let Some((_, values)) = order.get_mut(i)
+                    && !values.contains(&value)
+                {
+                    values.push(value);
+                }
+            }
+        }
+        let mut defs = Vec::new();
+        for (prop, _) in &order {
+            if let Some(&id) = self.defs.get(&(set.id, prop.clone(), "VARIANT")) {
+                defs.push(o(vec![
+                    ("id", guid(AUX, id)),
+                    ("name", s(prop)),
+                    ("initialValue", o(Vec::new())),
+                    ("sortPosition", s(&sort_position(defs.len()))),
+                    ("type", e("VARIANT")),
+                    ("preferredValues", o(Vec::new())),
+                    ("varValue", var_data(("textValue", s("")), "STRING", "STRING")),
+                ]));
+            }
+        }
+        // The format keeps one default per property of a set (a variant's copy holds none): the first
+        // variant's, with a warning when another variant's differs.
+        // A name used with two types is two properties (their definitions have their own ids).
+        let mut seen: BTreeMap<(String, &'static str), PropDef> = BTreeMap::new();
+        for v in &variants {
+            let NodeKind::Component { props, .. } = &v.kind else { continue };
+            for (name, d) in props {
+                let Some(ty) = prop_type(d) else { continue };
+                match seen.get(&(name.clone(), ty)) {
+                    Some(first) if first != d => self.warn("variants with different defaults for one property were written with the first variant's"),
+                    Some(_) => {}
+                    None => {
+                        seen.insert((name.clone(), ty), d.clone());
+                        let index = defs.len();
+                        defs.extend(self.prop_def(set.id, name, d, index));
+                    }
+                }
+            }
+        }
+        if !defs.is_empty() {
+            f.push(("componentPropDefs", arr(defs)));
+        }
+        if !order.is_empty() {
+            let orders = order.into_iter().map(|(p, values)| o(vec![("property", s(&p)), ("values", arr(values.iter().map(|x| s(x)).collect()))]));
+            f.push(("stateGroupPropertyValueOrders", arr(orders.collect())));
+        }
+    }
+
+    /// Which property controls a layer's `field`: the entry of its parameter consumption map and
+    /// its component property reference (readers take one or the other), both naming the
+    /// definition of the component the layer is in (a variant's own copy, in a set).
+    pub(super) fn prop_ref(&mut self, n: &Node, field: &str, prop: &str) -> Option<(Kv<'static>, Kv<'static>)> {
+        let (var_field, ty, resolved) = match field {
+            "visible" => ("VISIBLE", "BOOL", "BOOLEAN"),
+            "characters" => ("TEXT_DATA", "TEXT", "TEXT_DATA"),
+            "mainComponent" => ("OVERRIDDEN_SYMBOL_ID", "INSTANCE_SWAP", "SYMBOL_ID"),
+            _ => {
+                self.warn("slot layers were written as plain layers");
+                return None;
+            }
+        };
+        let id = self.def_for(self.component_of(n)?, prop, ty)?;
+        let data = o(vec![
+            ("value", o(vec![("propRefValue", o(vec![("defId", guid(AUX, id))]))])),
+            ("dataType", e("PROP_REF")),
+            ("resolvedDataType", e(resolved)),
+        ]);
+        let entry = o(vec![("variableData", data), ("variableField", e(var_field))]);
+        let reference = o(vec![("defID", guid(AUX, id)), ("componentPropNodeField", e(var_field))]);
+        Some((entry, reference))
+    }
+
+    /// An instance: its main, the fields it and its layers override, the size, place and outline
+    /// its layers get from that (derived data), its property values. `f`: its own fields so far.
+    pub(super) fn instance(&mut self, n: &Node, main: NodeId, props: &BTreeMap<String, Value>, f: &mut Fields) {
+        // Which properties control the instance itself (a nested instance in a main component) is
+        // its own too, not an override of its main.
+        const OWN: [&str; 9] =
+            ["guid", "phase", "parentIndex", "type", "transform", "fillGeometry", "strokeGeometry", "parameterConsumptionMap", "componentPropRefs"];
+        let doc = self.doc;
+        let (Some(m), Some(symbol)) = (doc.node(main), self.guid_of(main)) else { return };
+        // What the instance itself changes from its main (its size, its paints, …) is an override
+        // addressed by the main's id: a reader takes everything else from the main. Where it sits
+        // is its own.
+        let mut root_theirs = Vec::new();
+        self.layer(m, m.parent.and_then(|p| doc.node(p)), &mut root_theirs, true);
+        root_theirs.retain(|(k, _)| !OWN.contains(k));
+        // An instance is named after its component (the set, for a variant) until renamed.
+        let set = m.parent.and_then(|p| doc.node(p)).filter(|p| matches!(p.kind, NodeKind::ComponentSet { .. }));
+        let named = set.is_none_or(|s| s.name != n.name);
+        let root_mine: Fields = f.iter().filter(|(k, _)| !OWN.contains(k) && (named || *k != "name")).cloned().collect();
+        // Each layer below: its id path, the fields that differ from the main's layer, that layer's
+        // fields, whether its size is its own (a nested instance, a size override) and the
+        // component a nested instance was swapped for.
+        struct Row {
+            path: Kv<'static>,
+            changed: Fields,
+            theirs: Fields,
+            sized: bool,
+            swap: Option<Kv<'static>>,
+        }
+        let mut rows: Vec<Row> = Vec::new();
+        let mut stack: Vec<(NodeId, NodeId)> = n.children.iter().rev().map(|c| (*c, n.id)).collect();
+        let mut seen = 0usize;
+        while let Some((id, parent)) = stack.pop() {
+            let Some(d) = doc.node(id) else { continue };
+            seen += 1;
+            if seen > MAX_NODES {
+                break;
+            }
+            stack.extend(d.children.iter().rev().map(|c| (*c, id)));
+            let path = self.layer_path(d, n.id, main, 0);
+            let guids: Option<Vec<Kv>> = path.and_then(|p| p.iter().map(|x| self.guid_of(*x)).collect());
+            let (Some(guids), Some(src)) = (guids, d.source.and_then(|src| doc.node(src))) else {
+                self.warn("instance layers that don't come from their main component were left out");
+                continue;
+            };
+            let (mut mine, mut theirs) = (Vec::new(), Vec::new());
+            self.layer(d, doc.node(parent), &mut mine, true);
+            self.layer(src, src.parent.and_then(|p| doc.node(p)), &mut theirs, true);
+            // A nested instance swapped for another component.
+            let swap = match (&d.kind, &src.kind) {
+                (NodeKind::Instance { component, .. }, NodeKind::Instance { component: was, .. }) if component == was => None,
+                (NodeKind::Instance { component, .. }, _) => self.guid_of(*component),
+                _ => None,
+            };
+            let sized = matches!(d.kind, NodeKind::Instance { .. }) || d.overrides.contains("size");
+            rows.push(Row { path: o(vec![("guids", arr(guids))]), changed: changed(mine, &theirs), theirs, sized, swap });
+        }
+        // An instance scaled as a whole (the Scale tool) is `factor` times its main in every length:
+        // sizes, places and stroke weights, its own and its layers'. A resized one keeps its weights.
+        let field = |fields: &Fields, key: &str| fields.iter().find(|(k, _)| *k == key).map(|(_, v)| v.clone());
+        let factor = Some(n.width / m.width).filter(|k| k.is_finite() && *k > 0.0 && (k - 1.0).abs() > 1e-6).filter(|k| {
+            let grown = |mine: &Fields, theirs: &Fields| {
+                let weight = field(theirs, "strokeWeight").and_then(|w| w.f64()).unwrap_or(0.0);
+                (weight == 0.0 || field(mine, "strokeWeight").is_some_and(|w| scaled(&w, &fl(weight), *k, 0.0)))
+                    && field(mine, "size").zip(field(theirs, "size")).is_some_and(|(a, b)| scaled(&a, &b, *k, 1.0))
+                    && field(mine, "transform").zip(field(theirs, "transform")).is_none_or(|(a, b)| scaled(&a, &b, *k, 1.0))
+            };
+            (n.height / m.height - k).abs() <= 1e-6 * k.max(1.0)
+                && grown(&changed(root_mine.clone(), &root_theirs), &root_theirs)
+                && rows.iter().all(|r| grown(&r.changed, &r.theirs))
+        });
+        // What follows from the overrides goes with the derived data: a layer's size, place and
+        // outline (a vector's network is the main's, drawn at the layer's size), the colours its
+        // variables give here, and what the scale factor makes of the main's values.
+        let follows = |k: &str, v: &Kv<'static>, theirs: &Fields| {
+            ["size", "transform", "fillGeometry", "strokeGeometry", "vectorData"].contains(&k)
+                || resolved_alike(k, v, theirs)
+                || factor.is_some_and(|x| field(theirs, k).is_some_and(|t| scaled(v, &t, x, 0.0)))
+        };
+        let mut overrides = Vec::new();
+        let mut derived = Vec::new();
+        let mut of: Fields = vec![("guidPath", o(vec![("guids", arr(vec![symbol.clone()]))]))];
+        of.extend(changed(root_mine, &root_theirs).into_iter().filter(|(k, v)| *k == "size" || !follows(k, v, &root_theirs)));
+        if of.len() > 1 {
+            overrides.push(o(of));
+        }
+        for r in rows {
+            let (mut of, mut df): (Fields, Fields) = (vec![("guidPath", r.path.clone())], vec![("guidPath", r.path)]);
+            for (k, v) in r.changed {
+                let follows = follows(k, &v, &r.theirs);
+                // A nested instance's size is its own to set, as is a size the layer overrides.
+                if follows && r.sized && k == "size" {
+                    of.push((k, v.clone()));
+                }
+                if follows { &mut df } else { &mut of }.push((k, v));
+            }
+            if df.len() > 1 {
+                derived.push(o(df));
+            }
+            of.extend(r.swap.map(|g| ("overriddenSymbolID", g)));
+            if of.len() > 1 {
+                overrides.push(o(of));
+            }
+        }
+        f.push(("symbolData", o(vec![("symbolID", symbol), ("symbolOverrides", arr(overrides)), ("uniformScaleFactor", fl(factor.unwrap_or(1.0)))])));
+        if !derived.is_empty() {
+            f.push(("derivedSymbolData", arr(derived)));
+        }
+        let mut assignments = Vec::new();
+        for (name, v) in props {
+            let (ty, value, var) = match v {
+                Value::Bool(x) => ("BOOL", o(vec![("boolValue", b(*x))]), bool_data(*x)),
+                Value::String(t) => ("TEXT", o(vec![("textValue", text_value(t))]), text_data(t)),
+                Value::Number(c) => {
+                    let Some(g) = c.as_u64().and_then(|c| self.guid_of(NodeId(c))) else { continue };
+                    ("INSTANCE_SWAP", o(vec![("guidValue", g.clone())]), symbol_data(g))
+                }
+                _ => continue,
+            };
+            // Variant values have no definition of their own: the main they show says them. A
+            // variant's instance names the variant's own copy of the definition.
+            if let Some(id) = self.def_for(main, name, ty) {
+                assignments.push(o(vec![("defID", guid(AUX, id)), ("value", value), ("varValue", var)]));
+            }
+        }
+        if !assignments.is_empty() {
+            f.push(("componentPropAssignments", arr(assignments)));
+        }
+        if n.children.iter().filter_map(|c| doc.node(*c)).any(|c| c.source.is_none()) {
+            self.warn("instance layers that don't come from their main component were left out");
+        }
+    }
+
+    /// The main component layer an instance or instance layer mirrors (through nested instances),
+    /// or `id` itself.
+    pub(super) fn main_layer(&self, id: NodeId) -> NodeId {
+        let mut cur = id;
+        for _ in 0..32 {
+            let next = self.doc.node(cur).and_then(|n| match &n.kind {
+                _ if n.source.is_some() => n.source,
+                NodeKind::Instance { component, .. } => Some(*component),
+                _ => None,
+            });
+            match next.filter(|s| self.doc.contains(*s)) {
+                Some(s) => cur = s,
+                None => break,
+            }
+        }
+        cur
+    }
+
+    /// The id path of layer `d` of instance `inst` (of `main`): that of the main's layer it mirrors,
+    /// or, inside a nested instance swapped for another component, the path of that instance and
+    /// then the one inside its new main.
+    fn layer_path(&self, d: &Node, inst: NodeId, main: NodeId, depth: usize) -> Option<Vec<NodeId>> {
+        let src = d.source?;
+        if let Some(p) = self.path_in(src, main, 0) {
+            return Some(p);
+        }
+        if depth > 32 {
+            return None;
+        }
+        let doc = self.doc;
+        let nested = doc.ancestors(d.id).into_iter().take_while(|a| *a != inst).filter_map(|a| doc.node(a)).find_map(|a| match &a.kind {
+            NodeKind::Instance { component, .. } => Some((a, *component)),
+            _ => None,
+        });
+        let (outer, component) = nested?;
+        let mut p = self.layer_path(outer, inst, main, depth + 1)?;
+        p.extend(self.path_in(src, component, 0)?);
+        Some(p)
+    }
+
+    /// The id path of layer `s` inside component `comp`: `s` itself, or through the nested
+    /// instance it is expanded in, then on inside that instance's main.
+    fn path_in(&self, s: NodeId, comp: NodeId, depth: usize) -> Option<Vec<NodeId>> {
+        if depth > 32 {
+            return None;
+        }
+        let doc = self.doc;
+        let up = doc.ancestors(s);
+        let below: Vec<NodeId> = up.iter().take_while(|a| **a != comp).copied().collect();
+        if below.len() == up.len() {
+            return None;
+        }
+        // The outermost nested instance between the component and the layer.
+        match below.iter().rev().find_map(|a| match doc.node(*a).map(|n| &n.kind) {
+            Some(NodeKind::Instance { component, .. }) => Some((*a, *component)),
+            _ => None,
+        }) {
+            None => Some(vec![s]),
+            Some((inst, main)) => {
+                let mut p = vec![inst];
+                p.extend(self.path_in(doc.node(s)?.source?, main, depth + 1)?);
+                Some(p)
+            }
+        }
+    }
+}
diff --git a/crates/format/src/fig/export/layer.rs b/crates/format/src/fig/export/layer.rs
new file mode 100644
index 00000000..9925042f
--- /dev/null
+++ b/crates/format/src/fig/export/layer.rs
@@ -0,0 +1,440 @@
+use super::common::{export_setting, layout_grid, outlined, prop_type, variant_pairs};
+use super::*;
+
+impl<'d> Exporter<'d> {
+    /// Write layer `id` (child `index` of the layer with GUID `parent_guid`) and its subtree.
+    pub(super) fn emit(&mut self, id: NodeId, parent_guid: Kv<'static>, index: usize, parent: Option<&Node>, depth: usize) {
+        let doc = self.doc;
+        let (Some(&local), Some(n)) = (self.ids.get(&id), doc.node(id)) else { return };
+        if depth > MAX_DEPTH {
+            self.warn("layers nested deeper than 256 levels were left out");
+            return;
+        }
+        let mut f: Fields = vec![
+            ("guid", guid(LAYERS, local)),
+            ("phase", e("CREATED")),
+            ("parentIndex", o(vec![("guid", parent_guid), ("position", s(&position(index)))])),
+        ];
+        let children = if let NodeKind::Page { background, guides, prototype, .. } = &n.kind {
+            f.extend([("type", e("CANVAS")), ("name", s(&n.name))]);
+            f.extend(root_fields());
+            f.extend([("backgroundColor", color(*background)), ("backgroundOpacity", fl(background.a.into())), ("backgroundEnabled", b(true))]);
+            if !guides.is_empty() {
+                self.warn("ruler guides were left out");
+            }
+            if *prototype != Default::default() {
+                self.warn("prototype device settings were left out");
+            }
+            self.modes(n, &mut f);
+            true
+        } else {
+            self.layer(n, parent, &mut f, false)
+        };
+        self.nodes.push(o(f));
+        if children {
+            for (i, c) in n.children.iter().enumerate() {
+                self.emit(*c, guid(LAYERS, local), i, Some(n), depth + 1);
+            }
+        }
+    }
+
+    /// The fields of layer `n` (whose parent is `parent`). `nested`: for an instance's override
+    /// (no type, no instance or component data). Returns whether its children are written as
+    /// layers (an instance's come from its main).
+    pub(super) fn layer(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields, nested: bool) -> bool {
+        let doc = self.doc;
+        if let Some((outline, original)) = outlined(n) {
+            // The format's variable width is the same on both sides of the path: a stroke wider on
+            // one side is written as the area it paints, with the stroke itself kept as plugin data
+            // (which the import puts back).
+            self.warn("strokes wider on one side of their path were written as filled outlines (the stroke itself is kept for FigCraft)");
+            let children = self.layer(&outline, parent, f, nested);
+            f.push(("pluginData", arr(vec![o(vec![("pluginID", s(STASH.0)), ("value", s(&original)), ("key", s(STASH.1))])])));
+            return children;
+        }
+        let main = match &n.kind {
+            NodeKind::Instance { component, .. } => {
+                let found = self.ids.contains_key(component) && doc.node(*component).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. }));
+                if !found && !nested {
+                    self.warn("instances of components that aren't in the file were written as frames");
+                }
+                found.then_some(*component)
+            }
+            _ => None,
+        };
+        let ty = match &n.kind {
+            NodeKind::Page { .. } | NodeKind::Frame | NodeKind::Group | NodeKind::ComponentSet { .. } => "FRAME",
+            NodeKind::Instance { .. } if main.is_none() => "FRAME",
+            NodeKind::Section { .. } => "SECTION",
+            NodeKind::Rectangle => "ROUNDED_RECTANGLE",
+            NodeKind::Ellipse { .. } => "ELLIPSE",
+            NodeKind::Polygon { .. } => "REGULAR_POLYGON",
+            NodeKind::Star { .. } => "STAR",
+            NodeKind::Line => "LINE",
+            NodeKind::Vector { .. } => "VECTOR",
+            NodeKind::Text(_) => "TEXT",
+            NodeKind::BooleanOp { .. } => "BOOLEAN_OPERATION",
+            NodeKind::Component { .. } => "SYMBOL",
+            NodeKind::Instance { .. } => "INSTANCE",
+            NodeKind::Slice => "SLICE",
+        };
+        if !nested {
+            f.push(("type", e(ty)));
+        }
+        f.push(("name", s(&n.name)));
+        self.common(n, parent, f);
+        match &n.kind {
+            NodeKind::Group => f.push(("resizeToFit", b(true))),
+            NodeKind::Section { contents_hidden } => f.push(("sectionContentsHidden", b(*contents_hidden))),
+            NodeKind::Ellipse { start, sweep, inner } => {
+                f.push(("arcData", o(vec![("startingAngle", fl(*start)), ("endingAngle", fl(start + sweep)), ("innerRadius", fl(*inner))])))
+            }
+            NodeKind::Polygon { count } => f.push(("count", u(*count))),
+            NodeKind::Star { count, inner_ratio } => f.extend([("count", u(*count)), ("starInnerScale", fl(*inner_ratio))]),
+            NodeKind::Vector { network } => self.vector(n, network, f),
+            NodeKind::Text(td) => self.text(td, &n.fills, f),
+            NodeKind::BooleanOp { op } => {
+                let name = match op {
+                    BoolOp::Union => "UNION",
+                    BoolOp::Subtract => "SUBTRACT",
+                    BoolOp::Intersect => "INTERSECT",
+                    BoolOp::Exclude => "XOR",
+                };
+                f.push(("booleanOperation", e(name)));
+                if n.children.iter().filter_map(|c| doc.node(*c)).any(|c| c.bool_op.is_some()) {
+                    self.warn("boolean groups whose layers combine in different ways use the group's operation");
+                }
+            }
+            NodeKind::Component { description, props } if !nested => {
+                if let Some(set) = self.set_of(n.id) {
+                    // A variant: its set holds the definitions; the variant has its own copy of
+                    // each (pointing at the set's), and its values of the variant properties.
+                    let own: Vec<Kv> = props
+                        .iter()
+                        .filter_map(|(name, d)| {
+                            let ty = prop_type(d)?;
+                            let id = *self.child_defs.get(&(n.id, name.clone(), ty))?;
+                            let parent = *self.defs.get(&(set, name.clone(), ty))?;
+                            Some(o(vec![("id", guid(AUX, id)), ("parentPropDefId", guid(AUX, parent))]))
+                        })
+                        .collect();
+                    if !own.is_empty() {
+                        f.push(("componentPropDefs", arr(own)));
+                    }
+                    let specs: Vec<Kv> = variant_pairs(&n.name)
+                        .into_iter()
+                        .filter_map(|(prop, value)| {
+                            let id = *self.defs.get(&(set, prop, "VARIANT"))?;
+                            Some(o(vec![("propDefId", guid(AUX, id)), ("value", s(&value))]))
+                        })
+                        .collect();
+                    if !specs.is_empty() {
+                        f.push(("variantPropSpecs", arr(specs)));
+                    }
+                } else {
+                    let defs: Vec<Kv> = props.iter().enumerate().filter_map(|(i, (name, d))| self.prop_def(n.id, name, d, i)).collect();
+                    if !defs.is_empty() {
+                        f.push(("componentPropDefs", arr(defs)));
+                    }
+                }
+                if props.values().any(|d| matches!(d, PropDef::Slot { .. })) {
+                    self.warn("slot properties were left out");
+                }
+                if !description.is_empty() {
+                    f.push(("symbolDescription", s(description)));
+                }
+            }
+            NodeKind::ComponentSet { description } if !nested => {
+                f.push(("isStateGroup", b(true)));
+                self.set_props(n, f);
+                if !description.is_empty() {
+                    f.push(("symbolDescription", s(description)));
+                }
+            }
+            NodeKind::Instance { props, .. } if !nested => {
+                if let Some(main) = main {
+                    self.instance(n, main, props, f);
+                }
+            }
+            _ => {}
+        }
+        let boxy = n.kind.is_frame_like() || matches!(n.kind, NodeKind::Rectangle | NodeKind::Section { .. });
+        if (boxy || matches!(n.kind, NodeKind::Ellipse { .. } | NodeKind::Polygon { .. } | NodeKind::Star { .. }))
+            && let Some(p) = figcraft_doc::geometry::shape_path(n)
+        {
+            self.geometry("fillGeometry", &p, WindingRule::NonZero, f);
+        }
+        self.stroke_geometry(n, boxy, f);
+        main.is_none()
+    }
+
+    /// Fields every layer kind shares.
+    fn common(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields) {
+        f.extend([
+            ("visible", b(n.visible)),
+            ("locked", b(n.locked)),
+            ("opacity", fl(n.opacity.into())),
+            ("blendMode", e(blend_name(n.blend))),
+            ("size", xy(n.width, n.height)),
+            ("transform", matrix(n.transform)),
+        ]);
+        if n.is_mask {
+            let ty = match n.mask_type {
+                MaskType::Alpha => "ALPHA",
+                MaskType::Vector => "OUTLINE",
+                MaskType::Luminance => "LUMINANCE",
+            };
+            f.extend([("mask", b(true)), ("maskType", e(ty))]);
+        }
+        let bound = self.bound(n);
+        // Text whose own style sets fills paints with them (the layer's fills only show through
+        // runs); a variable bound to the layer's fill colours the layer's.
+        let fills = match &n.kind {
+            NodeKind::Text(TextData { style: TextStyle { fills: Some(own), .. }, .. }) => self.paints(own, true, &Bound::default()),
+            _ => self.paints(&n.fills, true, &bound),
+        };
+        let strokes = self.paints(&n.strokes, false, &bound);
+        f.extend([("fillPaints", fills), ("strokePaints", strokes)]);
+        self.stroke(n, f);
+        if !n.effects.is_empty() {
+            let effects = n.effects.iter().enumerate().map(|(i, x)| self.effect(x, i, &bound)).collect();
+            f.push(("effects", arr(effects)));
+        }
+        if n.kind.has_corner_radius() {
+            let r = n.corners.radii;
+            f.push(("cornerRadius", fl(r[0])));
+            let differ = r.iter().any(|x| *x != r[0]);
+            if n.kind.has_independent_corners() && (differ || r[0] > 0.0) {
+                f.extend(differ.then(|| ("rectangleCornerRadiiIndependent", b(true))));
+                f.extend([
+                    ("rectangleTopLeftCornerRadius", fl(r[0])),
+                    ("rectangleTopRightCornerRadius", fl(r[1])),
+                    ("rectangleBottomRightCornerRadius", fl(r[2])),
+                    ("rectangleBottomLeftCornerRadius", fl(r[3])),
+                ]);
+            }
+            if n.corners.smoothing > 0.0 {
+                f.push(("cornerSmoothing", fl(n.corners.smoothing)));
+            }
+        }
+        let h = match n.constraints.horizontal {
+            HConstraint::Left => "MIN",
+            HConstraint::Right => "MAX",
+            HConstraint::LeftRight => "STRETCH",
+            HConstraint::Center => "CENTER",
+            HConstraint::Scale => "SCALE",
+        };
+        let v = match n.constraints.vertical {
+            VConstraint::Top => "MIN",
+            VConstraint::Bottom => "MAX",
+            VConstraint::TopBottom => "STRETCH",
+            VConstraint::Center => "CENTER",
+            VConstraint::Scale => "SCALE",
+        };
+        f.extend([("horizontalConstraint", e(h)), ("verticalConstraint", e(v))]);
+        if n.kind.is_frame_like() || matches!(n.kind, NodeKind::Section { .. }) {
+            f.push(("frameMaskDisabled", b(!n.clip)));
+        }
+        if n.kind.is_frame_like() {
+            if let Some(l) = &n.layout {
+                self.auto_layout(n, l, f);
+            }
+            if !n.grids.is_empty() {
+                f.push(("layoutGrids", arr(n.grids.iter().enumerate().map(|(i, g)| layout_grid(g, i, &bound)).collect())));
+            }
+        }
+        self.child_layout(n, parent, f);
+        if !n.exports.is_empty() {
+            if n.exports.iter().any(|x| x.format == figcraft_doc::ExportFormat::Webp) {
+                self.warn("WebP export settings were written as PNG");
+            }
+            if n.exports.iter().any(|x| x.format == figcraft_doc::ExportFormat::VectorDrawable) {
+                self.warn("Android Vector Drawable (XML) export settings were written as SVG");
+            }
+            f.push(("exportSettings", arr(n.exports.iter().map(export_setting).collect())));
+        }
+        self.prototype(n, f);
+        let (entries, refs): (Vec<Kv>, Vec<Kv>) = n.prop_refs.iter().filter_map(|(field, prop)| self.prop_ref(n, field, prop)).unzip();
+        if !entries.is_empty() {
+            f.push(("parameterConsumptionMap", o(vec![("entries", arr(entries))])));
+            f.push(("componentPropRefs", arr(refs)));
+        }
+        let text = matches!(n.kind, NodeKind::Text(_));
+        let links = [
+            ("styleIdForFill", &n.styles.fill, true),
+            ("styleIdForStrokeFill", &n.styles.stroke, true),
+            ("styleIdForEffect", &n.styles.effect, true),
+            ("styleIdForGrid", &n.styles.grid, n.kind.is_frame_like()),
+            ("styleIdForText", &n.styles.text, text),
+        ];
+        for (key, id, fits) in links {
+            let Some(id) = id else { continue };
+            match self.style_ids.get(id.as_str()).filter(|_| fits) {
+                Some(local) => f.push((key, o(vec![("guid", guid(LAYERS, *local))]))),
+                None => self.warn("links to shared styles that aren't in the document were left out (their layers keep the values)"),
+            }
+        }
+        if let NodeKind::Text(td) = &n.kind
+            && n.styles.text.is_none()
+            && std::iter::once(&td.style).chain(td.runs.iter().map(|r| &r.style)).any(|st| st.style_id.is_some())
+        {
+            self.warn("text styles applied to part of a text were written as their values");
+        }
+        if !bound.entries.is_empty() {
+            f.push(("variableConsumptionMap", o(vec![("entries", arr(bound.entries))])));
+        }
+        self.modes(n, f);
+        if !n.guides.is_empty() {
+            self.warn("ruler guides were left out");
+        }
+        if !n.annotations.is_empty()
+            || !n.dev_resources.is_empty()
+            || !n.code_links.is_empty()
+            || !n.measurements.is_empty()
+            || !n.dev_status.is_none()
+        {
+            self.warn("Dev Mode annotations, statuses, resources, measurements and code links were left out");
+        }
+        if !n.plugin_data.is_empty() {
+            self.warn("plugin data was left out");
+        }
+    }
+
+    /// The variable modes layer (or page) `n` sets for what is in it.
+    fn modes(&mut self, n: &Node, f: &mut Fields) {
+        let mut entries = Vec::new();
+        for (coll, mode) in &n.var_modes {
+            match (self.set_ids.get(coll.as_str()), self.mode_ids.get(&(coll.as_str(), mode.as_str()))) {
+                (Some(set), Some(mode)) => {
+                    entries.push(o(vec![("variableSetID", o(vec![("guid", guid(LAYERS, *set))])), ("variableModeID", guid(AUX, *mode))]));
+                }
+                _ => self.warn("variable modes of collections that aren't in the document were left out"),
+            }
+        }
+        if !entries.is_empty() {
+            f.push(("variableModeBySetMap", o(vec![("entries", arr(entries))])));
+        }
+    }
+
+    fn auto_layout(&mut self, n: &Node, l: &AutoLayout, f: &mut Fields) {
+        let grid = l.mode == LayoutMode::Grid;
+        let mode = match l.mode {
+            LayoutMode::Horizontal => "HORIZONTAL",
+            LayoutMode::Vertical => "VERTICAL",
+            LayoutMode::Grid => "GRID",
+        };
+        let [top, right, bottom, left] = l.padding;
+        let main = match l.main_align {
+            MainAlign::Min => "MIN",
+            MainAlign::Center => "CENTER",
+            MainAlign::Max => "MAX",
+            MainAlign::SpaceBetween => "SPACE_BETWEEN",
+            MainAlign::SpaceAround => "SPACE_AROUND",
+            MainAlign::SpaceEvenly => "SPACE_EVENLY_CSS",
+        };
+        let cross = match l.cross_align {
+            CrossAlign::Min => "MIN",
+            CrossAlign::Center => "CENTER",
+            CrossAlign::Max => "MAX",
+            CrossAlign::Baseline => "BASELINE",
+        };
+        // The main axis is the width for horizontal and grid layouts.
+        let (main_hug, cross_hug) = {
+            let (h, v) = (n.child_layout.sizing_h == Sizing::Hug, n.child_layout.sizing_v == Sizing::Hug);
+            if l.mode == LayoutMode::Vertical { (v, h) } else { (h, v) }
+        };
+        let size = |hug: bool| e(if hug { "RESIZE_TO_FIT" } else { "FIXED" });
+        f.extend([
+            ("stackMode", e(mode)),
+            ("stackWrap", e(if l.wrap { "WRAP" } else { "NO_WRAP" })),
+            ("stackHorizontalPadding", fl(left)),
+            ("stackVerticalPadding", fl(top)),
+            ("stackPaddingRight", fl(right)),
+            ("stackPaddingBottom", fl(bottom)),
+            ("stackPrimaryAlignItems", e(main)),
+            ("stackCounterAlignItems", e(cross)),
+            ("stackPrimarySizing", size(main_hug)),
+            ("stackCounterSizing", size(cross_hug)),
+            ("bordersTakeSpace", b(l.strokes_included)),
+            ("stackReverseZIndex", b(l.reverse_z)),
+        ]);
+        if grid {
+            self.grid_layout(n, l, f);
+        } else {
+            let spread = l.content_align == ContentAlign::SpaceBetween;
+            f.extend([
+                ("stackSpacing", fl(l.gap)),
+                ("stackCounterSpacing", fl(l.cross_gap)),
+                ("stackCounterAlignContent", e(if spread { "SPACE_BETWEEN" } else { "AUTO" })),
+            ]);
+        }
+    }
+
+    /// A grid layout's track gaps, order and sizes.
+    fn grid_layout(&mut self, n: &Node, l: &AutoLayout, f: &mut Fields) {
+        // Instance layers share their main layer's track ids, so unchanged tracks and the cells
+        // their layers sit in still match.
+        let key = self.main_layer(n.id);
+        let (want_c, want_r) = (l.grid_columns.min(1000) as usize, l.grid_rows.min(1000) as usize);
+        let (cols, rows) = match self.tracks.get(&key) {
+            Some((c, r)) if (c.len(), r.len()) == (want_c, want_r) => (c.clone(), r.clone()),
+            _ => ((0..want_c).map(|_| self.next_aux()).collect(), (0..want_r).map(|_| self.next_aux()).collect()),
+        };
+        let map = |ids: &[u32]| {
+            o(vec![("entries", arr(ids.iter().enumerate().map(|(i, t)| o(vec![("id", guid(AUX, *t)), ("position", s(&position(i)))])).collect()))])
+        };
+        f.extend([("gridColumnGap", fl(l.gap)), ("gridRowGap", fl(l.cross_gap)), ("gridColumns", map(&cols)), ("gridRows", map(&rows))]);
+        let mut dropped = false;
+        let column_sizing = grid_sizing(&l.column_tracks, &cols, &mut dropped);
+        let row_sizing = grid_sizing(&l.row_tracks, &rows, &mut dropped);
+        if dropped {
+            self.warn("grid tracks whose size the format can't hold were written as equal tracks");
+        }
+        for (name, sizing) in [("gridColumnsSizing", column_sizing), ("gridRowsSizing", row_sizing)] {
+            if let Some(v) = sizing {
+                f.push((name, v));
+            }
+        }
+        self.tracks.insert(key, (cols, rows));
+    }
+
+    /// How a layer sizes and sits in its auto layout parent. Min/max sizes are the layer's own
+    /// and are written whatever its parent is.
+    fn child_layout(&mut self, n: &Node, parent: Option<&Node>, f: &mut Fields) {
+        let cl = &n.child_layout;
+        // An axis without a minimum is 0; one without a maximum is infinite (0 would be a maximum
+        // of 0, which collapses the layer in readers that apply it).
+        for (key, w, h, none) in [("minSize", cl.min_w, cl.min_h, 0.0), ("maxSize", cl.max_w, cl.max_h, f32::INFINITY)] {
+            if w.is_some() || h.is_some() {
+                let axis = |x: Option<f64>| x.map_or(Kv::Float(none), fl);
+                f.push((key, o(vec![("value", o(vec![("x", axis(w)), ("y", axis(h))]))])));
+            }
+        }
+        let Some(pl) = parent.and_then(|p| p.layout.as_ref()) else { return };
+        let (fill_h, fill_v) = (cl.sizing_h == Sizing::Fill, cl.sizing_v == Sizing::Fill);
+        let (grow, stretch) = if pl.mode == LayoutMode::Vertical { (fill_v, fill_h) } else { (fill_h, fill_v) };
+        if grow {
+            f.push(("stackChildPrimaryGrow", fl(1.0)));
+        }
+        if stretch {
+            f.push(("stackChildAlignSelf", e("STRETCH")));
+        }
+        if cl.absolute {
+            f.push(("stackPositioning", e("ABSOLUTE")));
+        }
+        if pl.mode == LayoutMode::Grid
+            && let Some((cols, rows)) = parent.and_then(|p| self.tracks.get(&self.main_layer(p.id)))
+        {
+            let anchor = |ids: &[u32], i: Option<u32>| i.and_then(|i| ids.get(i as usize)).map(|t| guid(AUX, *t));
+            let (c, r) = (anchor(cols, cl.grid_column), anchor(rows, cl.grid_row));
+            f.extend(c.map(|g| ("gridColumnAnchor", g)));
+            f.extend(r.map(|g| ("gridRowAnchor", g)));
+            if cl.grid_column_span > 0 {
+                f.push(("gridColumnSpan", int(cl.grid_column_span.into())));
+            }
+            if cl.grid_row_span > 0 {
+                f.push(("gridRowSpan", int(cl.grid_row_span.into())));
+            }
+        }
+    }
+}
diff --git a/crates/format/src/fig/export/paint.rs b/crates/format/src/fig/export/paint.rs
new file mode 100644
index 00000000..f0f40c18
--- /dev/null
+++ b/crates/format/src/fig/export/paint.rs
@@ -0,0 +1,239 @@
+use super::common::one_sided;
+use super::*;
+
+impl<'d> Exporter<'d> {
+    /// A paint list: a layer's fills (`fills`) or strokes with the variables `bound` to them.
+    pub(super) fn paints(&mut self, list: &[Paint], fills: bool, bound: &Bound) -> Kv<'static> {
+        arr(list.iter().enumerate().filter_map(|(i, p)| self.paint(p, (fills, i), bound)).collect())
+    }
+
+    fn paint(&mut self, p: &Paint, at: (bool, usize), bound: &Bound) -> Option<Kv<'static>> {
+        let mut f: Fields = vec![("visible", b(p.visible)), ("blendMode", e(blend_name(p.blend)))];
+        let mut opacity = f64::from(p.opacity);
+        match &p.kind {
+            PaintKind::Solid { color: c } => {
+                opacity *= f64::from(c.a);
+                f.extend([("type", e("SOLID")), ("color", color(c.with_alpha(1.0)))]);
+                f.extend(bound.paints.get(&at).map(|a| ("colorVar", a.clone())));
+            }
+            PaintKind::Gradient(g) => {
+                let ty = match g.kind {
+                    GradientKind::Linear => "GRADIENT_LINEAR",
+                    GradientKind::Radial => "GRADIENT_RADIAL",
+                    GradientKind::Angular => "GRADIENT_ANGULAR",
+                    GradientKind::Diamond => "GRADIENT_DIAMOND",
+                };
+                // The handles in the unit box come from the inverse of the paint transform: it maps
+                // (0, ½) → start, (1, ½) → end, (0, 1) → width for linear gradients, and the centre
+                // (½, ½) and the points half a box away from it for the others.
+                let (from, to, width) = (g.from, g.to, g.width);
+                let (ax, ay) =
+                    if g.kind == GradientKind::Linear { (to.0 - from.0, to.1 - from.1) } else { (2.0 * (to.0 - from.0), 2.0 * (to.1 - from.1)) };
+                let (cx, cy) = (2.0 * (width.0 - from.0), 2.0 * (width.1 - from.1));
+                let (ex, ey) = if g.kind == GradientKind::Linear {
+                    (from.0 - 0.5 * cx, from.1 - 0.5 * cy)
+                } else {
+                    (from.0 - 0.5 * (ax + cx), from.1 - 0.5 * (ay + cy))
+                };
+                let handles = Affine::new([ax, ay, cx, cy, ex, ey]);
+                let t = if handles.determinant().abs() > 1e-12 && handles.as_coeffs().iter().all(|x| x.is_finite()) {
+                    handles.inverse()
+                } else {
+                    self.warn("gradients with handles on one line were written with the default direction");
+                    Affine::IDENTITY
+                };
+                let stops = g.stops.iter().map(|st| o(vec![("color", color(st.color)), ("position", fl(st.position.into()))])).collect();
+                f.extend([("type", e(ty)), ("stops", arr(stops)), ("transform", matrix(t))]);
+                // Stops bound to variables: every stop again, the bound ones with their variable.
+                if bound.stops.range((at.0, at.1, 0)..=(at.0, at.1, usize::MAX)).next().is_some() {
+                    let vars = g.stops.iter().enumerate().map(|(j, st)| {
+                        let mut sf: Fields = vec![("color", color(st.color))];
+                        sf.extend(bound.stops.get(&(at.0, at.1, j)).map(|a| ("colorVar", a.clone())));
+                        sf.push(("position", fl(st.position.into())));
+                        o(sf)
+                    });
+                    f.push(("stopsVar", arr(vars.collect())));
+                }
+            }
+            PaintKind::Image(img) => {
+                let hash = self.image(&img.image);
+                let mode = match img.scale_mode {
+                    ImageScaleMode::Fill => "FILL",
+                    ImageScaleMode::Fit => "FIT",
+                    ImageScaleMode::Crop => "STRETCH",
+                    ImageScaleMode::Tile => "TILE",
+                };
+                f.extend([
+                    ("type", e("IMAGE")),
+                    ("image", o(vec![("hash", Kv::Bytes(hash)), ("name", s(""))])),
+                    ("imageScaleMode", e(mode)),
+                    ("rotation", fl(f64::from(img.rotation.rem_euclid(4)) * 90.0)),
+                    ("scale", fl(img.scale)),
+                ]);
+                if let (ImageScaleMode::Crop, Some(c)) = (img.scale_mode, img.crop) {
+                    f.push(("transform", matrix(Affine::new(c))));
+                }
+                if img.filters != Default::default() {
+                    self.warn("image adjustments (exposure, contrast, …) were left out");
+                }
+            }
+            PaintKind::Pattern(_) => {
+                self.warn("pattern fills were left out");
+                return None;
+            }
+        }
+        f.push(("opacity", fl(opacity)));
+        Some(o(f))
+    }
+
+    /// The hash bytes of image `key`, writing its file once (empty when its bytes aren't there).
+    fn image(&mut self, key: &str) -> Vec<u8> {
+        let hex = match self.images.get(key) {
+            Some(h) => h.clone(),
+            None => {
+                let h = match self.doc.images.get(key) {
+                    Some(img) if img.bytes.len() as u64 <= MAX_IMAGE => {
+                        let h = sha1_hex(&img.bytes);
+                        if !self.files.iter().any(|(x, _)| *x == h) {
+                            self.files.push((h.clone(), img.bytes.clone()));
+                        }
+                        Some(h)
+                    }
+                    Some(_) => {
+                        self.warn("images larger than 256 MB were left out");
+                        None
+                    }
+                    None => {
+                        self.warn("image fills whose image isn't in the document were written without one");
+                        None
+                    }
+                };
+                self.images.insert(key.to_string(), h.clone());
+                h
+            }
+        };
+        let hex = hex.unwrap_or_default();
+        (0..hex.len() / 2).filter_map(|i| hex.get(2 * i..2 * i + 2).and_then(|d| u8::from_str_radix(d, 16).ok())).collect()
+    }
+
+    pub(super) fn stroke(&mut self, n: &Node, f: &mut Fields) {
+        let sp = &n.stroke;
+        let align = match sp.align {
+            StrokeAlign::Inside => "INSIDE",
+            StrokeAlign::Center => "CENTER",
+            StrokeAlign::Outside => "OUTSIDE",
+        };
+        f.extend([
+            ("strokeWeight", fl(sp.weight)),
+            ("strokeAlign", e(align)),
+            ("strokeJoin", e(join_name(sp.join))),
+            ("strokeCap", e(cap_name(sp.cap_start))),
+            ("miterLimit", fl(sp.miter_limit)),
+        ]);
+        if !sp.dashes.is_empty() {
+            f.push(("dashPattern", arr(sp.dashes.iter().map(|d| fl(*d)).collect())));
+        }
+        if let Some([t, r, bo, l]) = sp.sides {
+            f.extend([
+                ("borderStrokeWeightsIndependent", b(true)),
+                ("borderTopWeight", fl(t)),
+                ("borderRightWeight", fl(r)),
+                ("borderBottomWeight", fl(bo)),
+                ("borderLeftWeight", fl(l)),
+            ]);
+        }
+        // A variable width: how far the stroke reaches on each side of the path at positions along
+        // its length, as a share of the stroke weight (half of it each for the full weight). The
+        // two sides are the same: a reader draws nothing for a point with unequal sides.
+        if let Some(p) = sp.profile().filter(|_| sp.weight.is_finite() && sp.weight > 0.0) {
+            let point = |q: &figcraft_doc::WidthPoint| o(vec![("position", fl(q.t)), ("ascent", fl(q.scale / 2.0)), ("descent", fl(q.scale / 2.0))]);
+            let p = p.sanitized();
+            if one_sided(&p) {
+                self.warn("strokes wider on one side of their path were written with that width on both sides");
+            }
+            f.push(("variableWidthPoints", arr(p.points.iter().map(point).collect())));
+        }
+        if sp.brush.is_some() {
+            self.warn("brush strokes were written as plain strokes");
+        }
+        if [sp.cap_start, sp.cap_end].contains(&StrokeCap::ReversedTriangle) {
+            self.warn("reversed triangle stroke ends were written as triangle arrows");
+        }
+        // Vectors keep each end's cap on their end points; other layers have one cap.
+        if sp.cap_start != sp.cap_end && !matches!(n.kind, NodeKind::Vector { .. }) {
+            self.warn("lines with different stroke ends use the start's at both ends");
+        }
+    }
+
+    /// Effect `index` of a layer, with the variables `bound` to its fields.
+    pub(super) fn effect(&mut self, x: &figcraft_doc::Effect, index: usize, bound: &Bound) -> Kv<'static> {
+        let mut f: Fields = vec![("visible", b(x.visible))];
+        let vars = [
+            ("color", "colorVar"),
+            ("radius", "radiusVar"),
+            ("spread", "spreadVar"),
+            ("offsetX", "xVar"),
+            ("offsetY", "yVar"),
+            ("startRadius", "startRadiusVar"),
+        ];
+        f.extend(vars.into_iter().filter_map(|(ours, key)| Some((key, bound.effects.get(&(index, ours))?.clone()))));
+        let blur = |f: &mut Fields, ty: &'static str, bl: &figcraft_doc::Blur| {
+            f.extend([("type", e(ty)), ("radius", fl(bl.radius))]);
+            if bl.blur_type == figcraft_doc::BlurType::Progressive {
+                f.extend([
+                    ("blurOpType", e("PROGRESSIVE")),
+                    ("startRadius", fl(bl.start_radius)),
+                    ("startOffset", xy(bl.start.0, bl.start.1)),
+                    ("endOffset", xy(bl.end.0, bl.end.1)),
+                ]);
+            }
+        };
+        let grain = |size: f64, size_y: Option<f64>| xy(size, size_y.unwrap_or(size));
+        match &x.kind {
+            EffectKind::DropShadow(sh) | EffectKind::InnerShadow(sh) => {
+                let ty = if matches!(x.kind, EffectKind::DropShadow(_)) { "DROP_SHADOW" } else { "INNER_SHADOW" };
+                f.extend([
+                    ("type", e(ty)),
+                    ("color", color(sh.color)),
+                    ("offset", xy(sh.offset.0, sh.offset.1)),
+                    ("radius", fl(sh.radius)),
+                    ("spread", fl(sh.spread)),
+                    ("blendMode", e(blend_name(sh.blend))),
+                    ("showShadowBehindNode", b(sh.show_behind)),
+                ]);
+            }
+            EffectKind::LayerBlur(bl) => blur(&mut f, "FOREGROUND_BLUR", bl),
+            EffectKind::BackgroundBlur(bl) => blur(&mut f, "BACKGROUND_BLUR", bl),
+            EffectKind::Noise(nz) => {
+                let mode = match nz.mode {
+                    NoiseMode::Mono => "MONOTONE",
+                    NoiseMode::Duo => "DUOTONE",
+                    NoiseMode::Multi => "MULTITONE",
+                };
+                f.extend([
+                    ("type", e("NOISE")),
+                    ("noiseType", e(mode)),
+                    ("noiseSize", grain(nz.size, nz.size_y)),
+                    ("density", fl(nz.density)),
+                    ("color", color(nz.color)),
+                    ("secondaryColor", color(nz.secondary)),
+                    ("opacity", fl(nz.opacity.into())),
+                    ("blendMode", e(blend_name(nz.blend))),
+                ]);
+            }
+            EffectKind::Texture(t) => {
+                f.extend([
+                    ("type", e("GRAIN")),
+                    ("noiseSize", grain(t.size, t.size_y)),
+                    ("radius", fl(t.radius)),
+                    ("clipToShape", b(t.clip_to_shape)),
+                ]);
+            }
+            EffectKind::Glass(g) => {
+                self.warn("glass effects keep only their frost");
+                f.extend([("type", e("GLASS")), ("radius", fl(g.frost))]);
+            }
+        }
+        o(f)
+    }
+}
diff --git a/crates/format/src/fig/export/prototype.rs b/crates/format/src/fig/export/prototype.rs
new file mode 100644
index 00000000..866b03c4
--- /dev/null
+++ b/crates/format/src/fig/export/prototype.rs
@@ -0,0 +1,174 @@
+use super::common::key_codes;
+use super::*;
+
+impl<'d> Exporter<'d> {
+    /// Interactions, scrolling, flow starts and the overlay settings this layer is opened with.
+    pub(super) fn prototype(&mut self, n: &Node, f: &mut Fields) {
+        self.trigger_size = [n.width, n.height];
+        let list: Vec<Kv> = n.interactions.iter().filter_map(|it| self.interaction(it)).collect();
+        if !list.is_empty() {
+            f.push(("prototypeInteractions", arr(list)));
+        }
+        let dir = match n.overflow {
+            Overflow::None => None,
+            Overflow::Horizontal => Some("HORIZONTAL"),
+            Overflow::Vertical => Some("VERTICAL"),
+            Overflow::Both => Some("BOTH"),
+        };
+        f.extend(dir.map(|d| ("scrollDirection", e(d))));
+        let behavior = match n.scroll_position {
+            ScrollPosition::Scrolls => None,
+            ScrollPosition::Fixed => Some("FIXED_WHEN_CHILD_OF_SCROLLING_FRAME"),
+            ScrollPosition::Sticky => Some("STICKY_SCROLLS"),
+        };
+        f.extend(behavior.map(|x| ("scrollBehavior", e(x))));
+        if let Some((i, name)) = self.starts.get(&n.id) {
+            f.push(("prototypeStartingPoint", o(vec![("name", s(name)), ("position", s(&position(*i)))])));
+        }
+        if let Some(ov) = self.overlays.get(&n.id) {
+            const POSITIONS: [&str; 8] = ["CENTER", "TOP_LEFT", "TOP_CENTER", "TOP_RIGHT", "BOTTOM_LEFT", "BOTTOM_CENTER", "BOTTOM_RIGHT", "MANUAL"];
+            let pos = POSITIONS.into_iter().find(|p| crate::rest::proto::overlay_position(p) == Some(ov.position)).unwrap_or("CENTER");
+            let bg = match ov.background {
+                Some(c) => o(vec![("backgroundType", e("SOLID_COLOR")), ("backgroundColor", color(c))]),
+                None => o(vec![("backgroundType", e("NONE"))]),
+            };
+            f.extend([
+                ("overlayPositionType", e(pos)),
+                ("overlayBackgroundInteraction", e(if ov.close_on_outside { "CLOSE_ON_CLICK_OUTSIDE" } else { "NONE" })),
+                ("overlayBackgroundAppearance", bg),
+            ]);
+        }
+    }
+
+    fn interaction(&mut self, it: &Interaction) -> Option<Kv<'static>> {
+        let mut event: Fields = Vec::new();
+        let ty = match &it.trigger {
+            Trigger::OnClick => "ON_CLICK",
+            Trigger::OnHover => "ON_HOVER",
+            Trigger::OnPress => "ON_PRESS",
+            Trigger::OnDrag => "DRAG",
+            Trigger::MouseEnter => "MOUSE_IN",
+            Trigger::MouseLeave => "MOUSE_OUT",
+            Trigger::MouseDown => "MOUSE_DOWN",
+            Trigger::MouseUp => "MOUSE_UP",
+            Trigger::AfterDelay { ms } => {
+                event.push(("transitionTimeout", fl(f64::from(*ms) / 1000.0)));
+                "AFTER_TIMEOUT"
+            }
+            Trigger::KeyPress { key } => {
+                let Some((codes, pad)) = key_codes(key) else {
+                    self.warn("key triggers on keys the format has no code for were left out");
+                    return None;
+                };
+                let device = e(if pad { "UNKNOWN_CONTROLLER" } else { "KEYBOARD" });
+                event.push(("keyTrigger", o(vec![("keyCodes", arr(codes.into_iter().map(int).collect())), ("triggerDevice", device)])));
+                "ON_KEY_DOWN"
+            }
+        };
+        // A mouse trigger's delay is the event's timeout.
+        if it.delay_secs() > 0.0 {
+            event.push(("transitionTimeout", fl(it.delay_secs())));
+        }
+        event.insert(0, ("interactionType", e(ty)));
+        let actions: Vec<Kv> = it.actions.iter().filter_map(|a| self.action(a, it)).collect();
+        (!actions.is_empty()).then(|| o(vec![("event", o(event)), ("actions", arr(actions))]))
+    }
+
+    fn action(&mut self, a: &Action, it: &Interaction) -> Option<Kv<'static>> {
+        let node = |x: &mut Self, dest: &NodeId, nav: &'static str| -> Option<Kv<'static>> {
+            let Some(g) = x.guid_of(*dest) else {
+                x.warn("prototype actions whose destination isn't written were left out");
+                return None;
+            };
+            let mut f: Fields = vec![("transitionNodeID", g), ("connectionType", e("INTERNAL_NODE")), ("navigationType", e(nav))];
+            x.transition(it, &mut f);
+            Some(o(f))
+        };
+        let plain = |ty: &'static str| Some(o(vec![("connectionType", e(ty))]));
+        match a {
+            Action::Navigate { dest, preserve_scroll } => {
+                let mut act = node(self, dest, "NAVIGATE")?;
+                if let Kv::Object(f) = &mut act {
+                    f.push(("transitionPreserveScroll", b(*preserve_scroll)));
+                }
+                Some(act)
+            }
+            Action::OpenOverlay { dest, position, offset, anchor, .. } => {
+                let mut act = node(self, dest, "OVERLAY")?;
+                let size = self.doc.node(*dest).map_or([0.0, 0.0], |d| [d.width, d.height]);
+                let offset = match anchor.offset(*position, self.trigger_size, size) {
+                    Some(o) => Some(o),
+                    None if *position == OverlayPosition::Manual => *offset,
+                    None => None,
+                };
+                if let (Kv::Object(f), Some([x, y])) = (&mut act, offset) {
+                    f.push(("overlayRelativePosition", o(vec![("x", fl(x)), ("y", fl(y))])));
+                }
+                Some(act)
+            }
+            Action::SwapOverlay { dest } => node(self, dest, "SWAP"),
+            Action::ChangeTo { dest } => node(self, dest, "SWAP_STATE"),
+            Action::ScrollTo { dest, offset } => {
+                if *offset != [0.0, 0.0] {
+                    self.warn("scroll-to offsets were left out");
+                }
+                node(self, dest, "SCROLL_TO")
+            }
+            Action::Back => plain("BACK"),
+            Action::CloseOverlay => plain("CLOSE"),
+            Action::OpenUrl { url } => Some(o(vec![("connectionType", e("URL")), ("connectionURL", s(url))])),
+            Action::SetVariable { .. } | Action::SetVariableMode { .. } | Action::Conditional { .. } => {
+                self.warn("variable and conditional prototype actions were left out");
+                None
+            }
+        }
+    }
+
+    /// An interaction's transition on one of its actions.
+    fn transition(&mut self, it: &Interaction, f: &mut Fields) {
+        let side_from = |d: Direction, l: &'static str, r: &'static str, t: &'static str, bo: &'static str| match d {
+            // The direction names where the incoming screen moves: it comes from the other side.
+            Direction::Right => l,
+            Direction::Left => r,
+            Direction::Bottom => t,
+            Direction::Top => bo,
+        };
+        let side_to = |d: Direction, l: &'static str, r: &'static str, t: &'static str, bo: &'static str| match d {
+            Direction::Left => l,
+            Direction::Right => r,
+            Direction::Top => t,
+            Direction::Bottom => bo,
+        };
+        let ty = match it.transition {
+            Transition::Instant => "INSTANT_TRANSITION",
+            Transition::Dissolve => "DISSOLVE",
+            Transition::SmartAnimate => "SMART_ANIMATE",
+            Transition::SlideIn { direction } => side_from(direction, "SLIDE_FROM_LEFT", "SLIDE_FROM_RIGHT", "SLIDE_FROM_TOP", "SLIDE_FROM_BOTTOM"),
+            Transition::Push { direction } => side_from(direction, "PUSH_FROM_LEFT", "PUSH_FROM_RIGHT", "PUSH_FROM_TOP", "PUSH_FROM_BOTTOM"),
+            Transition::MoveIn { direction } => side_from(direction, "MOVE_FROM_LEFT", "MOVE_FROM_RIGHT", "MOVE_FROM_TOP", "MOVE_FROM_BOTTOM"),
+            Transition::SlideOut { direction } => {
+                side_to(direction, "SLIDE_OUT_TO_LEFT", "SLIDE_OUT_TO_RIGHT", "SLIDE_OUT_TO_TOP", "SLIDE_OUT_TO_BOTTOM")
+            }
+            Transition::MoveOut { direction } => side_to(direction, "MOVE_OUT_TO_LEFT", "MOVE_OUT_TO_RIGHT", "MOVE_OUT_TO_TOP", "MOVE_OUT_TO_BOTTOM"),
+        };
+        let easing = match it.easing {
+            Easing::Linear => "LINEAR",
+            Easing::EaseIn => "IN_CUBIC",
+            Easing::EaseOut => "OUT_CUBIC",
+            Easing::EaseInOut => "INOUT_CUBIC",
+            Easing::EaseInBack => "IN_BACK_CUBIC",
+            Easing::EaseOutBack => "OUT_BACK_CUBIC",
+            Easing::EaseInOutBack => "INOUT_BACK_CUBIC",
+            Easing::Gentle => "GENTLE_SPRING",
+            Easing::CustomBezier { .. } => "CUSTOM_CUBIC",
+            Easing::Quick | Easing::Bouncy | Easing::Slow | Easing::CustomSpring { .. } => {
+                self.warn("spring animations other than Gentle were written as ease out");
+                "OUT_CUBIC"
+            }
+        };
+        f.extend([("transitionType", e(ty)), ("transitionDuration", fl(f64::from(it.duration_ms) / 1000.0)), ("easingType", e(easing))]);
+        if let Easing::CustomBezier { x1, y1, x2, y2 } = it.easing {
+            f.push(("easingFunction", arr(vec![fl(x1), fl(y1), fl(x2), fl(y2)])));
+        }
+    }
+}
diff --git a/crates/format/src/fig/export/shape.rs b/crates/format/src/fig/export/shape.rs
new file mode 100644
index 00000000..7ef79a78
--- /dev/null
+++ b/crates/format/src/fig/export/shape.rs
@@ -0,0 +1,341 @@
+use super::common::{style_fields, unsupported_decoration_look};
+use super::*;
+
+impl<'d> Exporter<'d> {
+    /// Text: its style, box settings, and characters with their styled runs. `fills`: the layer's
+    /// (what runs without fills of their own show when the text's own style sets other fills).
+    pub(super) fn text(&mut self, td: &TextData, fills: &[Paint], f: &mut Fields) {
+        style_fields(&td.style, f);
+        let (ha, va) = (
+            match td.align_h {
+                TextAlignH::Left => "LEFT",
+                TextAlignH::Center => "CENTER",
+                TextAlignH::Right => "RIGHT",
+                TextAlignH::Justified => "JUSTIFIED",
+            },
+            match td.align_v {
+                TextAlignV::Top => "TOP",
+                TextAlignV::Middle => "CENTER",
+                TextAlignV::Bottom => "BOTTOM",
+            },
+        );
+        let resize = match td.auto_resize {
+            TextAutoResize::WidthAndHeight => "WIDTH_AND_HEIGHT",
+            TextAutoResize::Height => "HEIGHT",
+            TextAutoResize::None | TextAutoResize::Truncate => "NONE",
+        };
+        f.extend([
+            ("textAlignHorizontal", e(ha)),
+            ("textAlignVertical", e(va)),
+            ("textAutoResize", e(resize)),
+            ("paragraphSpacing", fl(td.paragraph_spacing)),
+            ("paragraphIndent", fl(td.paragraph_indent)),
+            ("autoRename", b(false)),
+            ("fontVariantCommonLigatures", b(true)),
+            ("fontVariantContextualLigatures", b(true)),
+            ("fontVersion", s("")),
+            ("textUserLayoutVersion", u(5)),
+            ("textExplicitLayoutVersion", u(1)),
+            ("textBidiVersion", u(1)),
+            ("textTracking", fl(0.0)),
+            ("emojiImageSet", e("APPLE")),
+        ]);
+        if td.truncates() {
+            f.push(("textTruncation", e("ENDING")));
+        }
+        if td.max_lines > 0 {
+            f.push(("maxLines", int(td.max_lines.into())));
+        }
+        // Styles per UTF-16 unit: 0 for the base style, else an entry of the override table.
+        if td.char_count() > MAX_CHARS {
+            self.warn("text longer than 1,048,576 characters was cut");
+        }
+        let spans = td.spans();
+        let mut table: Vec<&TextStyle> = Vec::new();
+        let mut span_ids = Vec::with_capacity(spans.len());
+        for (_, _, st) in &spans {
+            span_ids.push(if **st == td.style {
+                0
+            } else {
+                let i = table.iter().position(|t| *t == *st).unwrap_or_else(|| {
+                    table.push(st);
+                    table.len() - 1
+                });
+                i as u32 + 1
+            });
+        }
+        let mut chars = String::new();
+        let mut ids: Vec<Kv> = Vec::new();
+        let mut span = 0;
+        for (i, ch) in td.characters.chars().take(MAX_CHARS).enumerate() {
+            while spans.get(span).is_some_and(|sp| i >= sp.1) {
+                span += 1;
+            }
+            // NULs can't be stored in a string.
+            if ch == '\0' {
+                continue;
+            }
+            chars.push(ch);
+            let id = span_ids.get(span).copied().unwrap_or(0);
+            ids.extend((0..ch.len_utf16()).map(|_| u(id)));
+        }
+        let mut data: Fields = vec![("characters", Kv::Str(chars))];
+        if !table.is_empty() {
+            let entries = table
+                .iter()
+                .zip(1u32..)
+                .map(|(st, id)| {
+                    let mut ef: Fields = vec![("styleID", u(id))];
+                    style_fields(st, &mut ef);
+                    // An empty link clears the text's own (a missing one would inherit it).
+                    if st.link.is_none() && td.style.link.is_some() {
+                        ef.push(("hyperlink", o(vec![("url", s(""))])));
+                    }
+                    if let Some(p) = st.fills.as_deref().or(td.style.fills.as_ref().map(|_| fills)) {
+                        ef.push(("fillPaints", self.paints(p, true, &Bound::default())));
+                    }
+                    o(ef)
+                })
+                .collect();
+            data.extend([("characterStyleIDs", arr(ids)), ("styleOverrideTable", arr(entries))]);
+        }
+        let lists: Vec<ListStyle> = (0..td.paragraph_count()).map(|p| td.para_list(p).list).collect();
+        let first = |i: usize, l: &ListStyle| *l != ListStyle::None && (i == 0 || lists.get(i - 1) != Some(l));
+        // Where each line's numbered list starts counting, less one: its first item's start, on
+        // every line of the list.
+        let mut run = 0;
+        let starts: Vec<u32> = lists
+            .iter()
+            .enumerate()
+            .map(|(i, l)| {
+                if first(i, l) {
+                    run = td.para_list(i).start_offset;
+                }
+                if *l == ListStyle::Numbered { run } else { 0 }
+            })
+            .collect();
+        // One entry per paragraph, each with every field a reader expects.
+        let line = |(i, l): (usize, &ListStyle)| {
+            let ty = match l {
+                ListStyle::None => "PLAIN",
+                ListStyle::Numbered => "ORDERED_LIST",
+                ListStyle::Bulleted => "UNORDERED_LIST",
+            };
+            let listed = *l != ListStyle::None;
+            let begins = first(i, l);
+            let start = starts.get(i).copied().unwrap_or(0);
+            o(vec![
+                ("lineType", e(ty)),
+                ("styleId", int(0)),
+                ("indentationLevel", int(i64::from(listed))),
+                ("sourceDirectionality", e("AUTO")),
+                ("listStartOffset", int(i64::from(start))),
+                ("isFirstLineOfList", b(begins)),
+            ])
+        };
+        data.push(("lines", arr(lists.iter().enumerate().map(line).collect())));
+        f.push(("textData", o(data)));
+        if (0..td.paragraph_count()).any(|p| td.para_list(p).indent > 0) {
+            self.warn("nested list levels were written as the first level");
+        }
+        let styles = std::iter::once(&td.style).chain(td.runs.iter().map(|r| &r.style));
+        if styles.clone().any(|st| unsupported_decoration_look(st) || !st.variations.is_empty()) {
+            self.warn("text decoration looks and variable font settings were left out");
+        }
+        if td.path.is_some() {
+            self.warn("text on a path was written as plain text");
+        }
+        if td.list_spacing != 0.0 || td.hanging_punctuation || td.hanging_list || td.leading_trim != Default::default() || !td.features.is_empty() {
+            self.warn("list spacing, hanging punctuation, leading trim and OpenType features were left out");
+        }
+    }
+
+    /// The editable network (with per-point corner radii, handle mirroring and end caps) and,
+    /// when it has filled areas, their outline.
+    pub(super) fn vector(&mut self, n: &Node, net: &VectorNetwork, f: &mut Fields) {
+        let entries: usize = net.regions.iter().flat_map(|r| &r.loops).map(Vec::len).sum();
+        if net.vertices.len() + net.segments.len() + entries > MAX_NETWORK {
+            self.warn("vector networks too large for the format were written as outlines");
+        } else {
+            // The stroke starts at the first end point and stops at the last: the layer's end caps go
+            // there (where the point has none of its own).
+            let mut degree = vec![0usize; net.vertices.len()];
+            for sg in &net.segments {
+                for i in [sg.a, sg.b] {
+                    if let Some(d) = degree.get_mut(i) {
+                        *d += 1;
+                    }
+                }
+            }
+            let ends: Vec<usize> = (0..degree.len()).filter(|i| degree.get(*i) == Some(&1)).collect();
+            let (first, last) = (ends.first().copied(), ends.last().copied());
+            let caps_differ = n.stroke.cap_start != n.stroke.cap_end || net.vertices.iter().any(|v| v.cap.is_some());
+            let mut styles: Vec<Fields> = Vec::new();
+            let mut style_of = |fields: Fields| -> u32 {
+                if fields.is_empty() {
+                    return 0;
+                }
+                let i = styles.iter().position(|x| *x == fields).unwrap_or_else(|| {
+                    styles.push(fields);
+                    styles.len() - 1
+                });
+                i as u32 + 1
+            };
+            let vertices = net
+                .vertices
+                .iter()
+                .enumerate()
+                .map(|(i, v)| {
+                    let mut st: Fields = Vec::new();
+                    if v.radius > 0.0 {
+                        st.push(("cornerRadius", fl(v.radius)));
+                    }
+                    if let Some(m) = v.mirror {
+                        st.push((
+                            "handleMirroring",
+                            e(match m {
+                                figcraft_doc::HandleMirroring::None => "NONE",
+                                figcraft_doc::HandleMirroring::Angle => "ANGLE",
+                                figcraft_doc::HandleMirroring::AngleAndLength => "ANGLE_AND_LENGTH",
+                            }),
+                        ));
+                    }
+                    let end_cap = if Some(i) == first {
+                        Some(n.stroke.cap_start)
+                    } else if Some(i) == last {
+                        Some(n.stroke.cap_end)
+                    } else {
+                        None
+                    };
+                    if let Some(c) = v.cap.or(end_cap.filter(|_| caps_differ)) {
+                        st.push(("strokeCap", e(cap_name(c))));
+                    }
+                    if let Some(j) = v.join {
+                        st.push(("strokeJoin", e(join_name(j))));
+                    }
+                    network::Vertex { style: style_of(st), x: finite(v.x), y: finite(v.y) }
+                })
+                .collect();
+            let segments = net
+                .segments
+                .iter()
+                .map(|sg| network::Segment {
+                    style: 0,
+                    a: sg.a,
+                    ta: (finite(sg.ta.0), finite(sg.ta.1)),
+                    b: sg.b,
+                    tb: (finite(sg.tb.0), finite(sg.tb.1)),
+                })
+                .collect();
+            let regions = net
+                .regions
+                .iter()
+                .map(|r| network::Region { style: 0, non_zero: r.winding == WindingRule::NonZero, loops: r.loops.clone() })
+                .collect();
+            let blob = network::encode(&network::Network { vertices, segments, regions });
+            let table = styles.into_iter().zip(1u32..).map(|(mut st, id)| {
+                st.insert(0, ("styleID", u(id)));
+                o(st)
+            });
+            let table: Vec<Kv> = table.collect();
+            if let Some(i) = self.blob(blob) {
+                f.push((
+                    "vectorData",
+                    o(vec![("vectorNetworkBlob", u(i)), ("normalizedSize", xy(n.width, n.height)), ("styleOverrideTable", arr(table))]),
+                ));
+            }
+        }
+        if !net.regions.is_empty() {
+            let winding = net.regions.first().map(|r| r.winding).unwrap_or_default();
+            if net.regions.iter().any(|r| r.winding != winding) {
+                self.warn("vectors whose filled areas use different winding rules use the first one's in their outline");
+            }
+            self.geometry("fillGeometry", &net.fill_path(), winding, f);
+        }
+    }
+
+    /// `fillGeometry` or `strokeGeometry` (`key`) from a local path.
+    pub(super) fn geometry(&mut self, key: &'static str, p: &BezPath, winding: WindingRule, f: &mut Fields) {
+        if p.elements().is_empty() {
+            return;
+        }
+        if let Some(i) = self.blob(path_blob(p)) {
+            let rule = if winding == WindingRule::EvenOdd { "ODD" } else { "NONZERO" };
+            f.push((key, arr(vec![o(vec![("windingRule", e(rule)), ("commandsBlob", u(i)), ("styleID", u(0))])])));
+        }
+    }
+
+    /// `strokeGeometry`, the outline of a plain stroke: a ring around boxes and whole ellipses, the
+    /// widened path of other centred strokes. Dashed, per-side and other strokes get none (a reader
+    /// builds theirs from the stroke settings).
+    pub(super) fn stroke_geometry(&mut self, n: &Node, boxy: bool, f: &mut Fields) {
+        let sp = &n.stroke;
+        let (w, h, weight) = (n.width, n.height, sp.weight);
+        let plain = n.strokes.iter().any(|p| p.visible) && sp.dashes.is_empty() && sp.sides.is_none() && sp.profile().is_none() && sp.brush.is_none();
+        if !(plain && weight.is_finite() && weight > 0.0 && w.is_finite() && h.is_finite()) {
+            return;
+        }
+        let whole = matches!(n.kind, NodeKind::Ellipse { sweep, inner, .. } if inner == 0.0 && sweep.abs() >= std::f64::consts::TAU - 1e-9);
+        if boxy || whole {
+            let (out, inset) = match sp.align {
+                StrokeAlign::Inside => (0.0, weight),
+                StrokeAlign::Center => (weight / 2.0, weight / 2.0),
+                StrokeAlign::Outside => (weight, 0.0),
+            };
+            // The shape grown by `d` (shrunk when negative), or nothing when it shrinks away.
+            let grown = |d: f64| -> Option<BezPath> {
+                let (gw, gh) = (w + 2.0 * d, h + 2.0 * d);
+                if gw <= 0.0 || gh <= 0.0 {
+                    return None;
+                }
+                let mut p = if whole {
+                    figcraft_doc::geom::ellipse(gw, gh, 0.0, std::f64::consts::TAU, 0.0)
+                } else {
+                    let radii = n.corners.radii.map(|r| if r > 0.0 { (r + d).max(0.0) } else { 0.0 });
+                    figcraft_doc::geom::rounded_rect(gw, gh, radii, n.corners.smoothing)
+                };
+                p.apply_affine(Affine::translate((-d, -d)));
+                Some(p)
+            };
+            let Some(mut ring) = grown(out) else { return };
+            ring.extend(grown(-inset).iter().flat_map(|p| p.elements().iter().copied()));
+            self.geometry("strokeGeometry", &ring, WindingRule::EvenOdd, f);
+        } else if sp.align == StrokeAlign::Center {
+            let path = match &n.kind {
+                NodeKind::Vector { network } => Some(network.stroke_path()),
+                NodeKind::Text(_) => None,
+                _ => figcraft_doc::geometry::shape_path(n),
+            };
+            let Some(path) = path.filter(|p| !p.elements().is_empty()) else { return };
+            use figcraft_doc::geom::kurbo::{Cap, Join, Stroke, StrokeOpts, stroke};
+            let cap = match sp.cap_start {
+                StrokeCap::Round => Cap::Round,
+                StrokeCap::Square => Cap::Square,
+                _ => Cap::Butt,
+            };
+            let join = match sp.join {
+                StrokeJoin::Miter => Join::Miter,
+                StrokeJoin::Bevel => Join::Bevel,
+                StrokeJoin::Round => Join::Round,
+            };
+            let limit = if sp.miter_limit.is_finite() { sp.miter_limit.max(1.0) } else { 4.0 };
+            let style = Stroke::new(weight).with_caps(cap).with_join(join).with_miter_limit(limit);
+            self.geometry("strokeGeometry", &stroke(path, &style, &StrokeOpts::default(), 0.05), WindingRule::NonZero, f);
+        }
+    }
+
+    /// Add a blob; its index (`None` once the blobs would make the file too large).
+    fn blob(&mut self, bytes: Vec<u8>) -> Option<u32> {
+        if let Some(i) = self.blobs.get(&bytes) {
+            return Some(*i);
+        }
+        self.blob_bytes += bytes.len() as u64;
+        if self.blob_bytes > MAX_CANVAS {
+            self.warn("vector data too large for the format was left out");
+            return None;
+        }
+        let i = u32::try_from(self.blobs.len()).ok()?;
+        self.blobs.insert(bytes, i);
+        Some(i)
+    }
+}

From a7a35a83226dd20425c4607dff2d197e56ad7d1c Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:03:41 +0000
Subject: [PATCH 49/67] refactor(collab-net): split hub.rs into hub/

---
 crates/collab-net/src/hub.rs         | 1050 +-------------------------
 crates/collab-net/src/hub/backend.rs |  138 ++++
 crates/collab-net/src/hub/conn.rs    |  404 ++++++++++
 crates/collab-net/src/hub/hosting.rs |  201 +++++
 crates/collab-net/src/hub/limits.rs  |   99 +++
 crates/collab-net/src/hub/queue.rs   |  210 ++++++
 6 files changed, 1067 insertions(+), 1035 deletions(-)
 create mode 100644 crates/collab-net/src/hub/backend.rs
 create mode 100644 crates/collab-net/src/hub/conn.rs
 create mode 100644 crates/collab-net/src/hub/hosting.rs
 create mode 100644 crates/collab-net/src/hub/limits.rs
 create mode 100644 crates/collab-net/src/hub/queue.rs

diff --git a/crates/collab-net/src/hub.rs b/crates/collab-net/src/hub.rs
index 1471c179..d45041a5 100644
--- a/crates/collab-net/src/hub.rs
+++ b/crates/collab-net/src/hub.rs
@@ -46,1047 +46,27 @@ use crate::join::{ENDED, RESTARTING};
 use crate::net::{Bucket, Duplex, Meter, NetLimits, Readers, config, shutdown};
 use crate::throttle::{PRESENCE_INTERVAL, Throttle, earliest};
 
-/// How long a closing connection waits for the peer to hang up.
-const LINGER: Duration = Duration::from_secs(2);
+mod backend;
+mod conn;
+mod hosting;
+mod limits;
+mod queue;
 
-/// Signals (cursor chat, spotlight) a client may send per second on average, and in a burst;
-/// beyond that they are dropped.
-pub const SIGNAL_RATE: f64 = 20.0;
-pub const SIGNAL_BURST: f64 = 40.0;
+pub use backend::{Backend, Closing, Handled, OpenFile};
+pub use conn::{SIGNAL_BURST, SIGNAL_RATE};
+use conn::{encode, reason, refuse, refused};
+pub use hosting::Hosting;
+pub(crate) use hosting::{Local, clean_name};
+pub use limits::{Admission, Block, ip_blocks, ip_key};
+pub use queue::wide_block;
+#[cfg(test)]
+use queue::{BlockUse, Blocks};
+use queue::{Charges, HubIn, InFlight, Line, Out, Push};
 
 /// Most messages the hub handles before it sends what they produced (bounds the delay a burst
 /// adds).
 const BURST: usize = 256;
 
-/// What a link lets a hello do.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Admission {
-    pub access: Access,
-    /// The link's id, when the backend has several per file (revoking it disconnects whoever
-    /// joined with it).
-    pub link: Option<String>,
-}
-
-/// An admin request's reply, and what the hub must do about connections it affects.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Handled {
-    pub reply: AdminReply,
-    /// A link was revoked: `(file, link)`; whoever joined with it is disconnected.
-    pub revoked: Option<(String, String)>,
-    /// A file was removed: whoever is in it is disconnected and it is closed without saving.
-    pub removed: Option<String>,
-    /// An address was blocked ([`ip_key`]): its connections are dropped.
-    pub blocked: Option<IpAddr>,
-}
-
-impl From<AdminReply> for Handled {
-    fn from(reply: AdminReply) -> Self {
-        Self { reply, revoked: None, removed: None, blocked: None }
-    }
-}
-
-/// The address limits and blocks count a client by: its IPv4 address (an IPv4-mapped IPv6 address
-/// as IPv4), or its IPv6 address's /64 (one subscriber's block: they have billions of addresses).
-pub fn ip_key(ip: IpAddr) -> IpAddr {
-    match ip.to_canonical() {
-        IpAddr::V6(v6) => {
-            let [a, b, c, d, ..] = v6.segments();
-            IpAddr::V6(Ipv6Addr::new(a, b, c, d, 0, 0, 0, 0))
-        }
-        v4 => v4,
-    }
-}
-
-/// What everyone is told when a hub stops.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Closing {
-    /// The session is over (the app stopped hosting): final.
-    Ended,
-    /// The server is restarting: clients reconnect until it is back.
-    Restarting,
-}
-
-/// What the hub knows of an open file (for listings).
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct OpenFile {
-    /// People connected to it.
-    pub people: u32,
-    /// Its latest sequence number.
-    pub seq: u64,
-}
-
-/// Where a hub's files come from and what it keeps of them (see the module docs). The hub calls it
-/// from its own thread only.
-pub trait Backend: Send + 'static {
-    /// A hello for `file` with `token`: what it may do, or why it may not join (the reason is
-    /// shown to the person joining; never echo the token).
-    fn admit(&mut self, file: &str, token: &str) -> Result<Admission, String>;
-
-    /// The session for a file that isn't open (after [`admit`](Self::admit) let someone in).
-    fn open(&mut self, file: &str) -> Result<Server, String>;
-
-    /// The hub handled a message for an open file: keep what changed (its server's journal).
-    fn changed(&mut self, _file: &str, _server: &mut Server) {}
-
-    /// Make what [`changed`](Self::changed) kept durable; the hub sends the servers' answers
-    /// after this. The files whose changes couldn't be made durable: nobody hears of them, the
-    /// files are closed (the backend forgets their open state) and everyone in them reconnects.
-    fn flush(&mut self) -> Vec<String> {
-        Vec::new()
-    }
-
-    /// Whether `file` has room for a batch of about `bytes` (its size on the wire): why not, and
-    /// the batch is refused.
-    fn room(&mut self, _file: &str, _server: &Server, _bytes: usize) -> Result<(), String> {
-        Ok(())
-    }
-
-    /// Everyone left `file`: save it. True closes it (the next hello opens it again).
-    fn idle(&mut self, _file: &str, _server: &mut Server) -> bool {
-        false
-    }
-
-    /// The hub is stopping: save the open files.
-    fn stop(&mut self, _open: Vec<(&str, &mut Server)>) {}
-
-    /// A managing connection's key: whether it may manage files.
-    fn manage(&mut self, _key: &str) -> Result<(), String> {
-        Err("this session is hosted by an app: it has no files to manage".into())
-    }
-
-    /// A request on a managing connection; `open` tells about a file that is open.
-    fn admin(&mut self, _req: Admin, _open: &dyn Fn(&str) -> Option<OpenFile>) -> Handled {
-        AdminReply::Failed { reason: "nothing to manage here".into() }.into()
-    }
-
-    /// A request on a library connection to `file`, opened with a link of `access` (checked by
-    /// [`admit`](Self::admit)).
-    fn library(&mut self, _ip: IpAddr, _file: &str, _access: Access, _req: LibraryReq) -> LibraryReply {
-        LibraryReply::Failed { reason: "this session is hosted by an app: team libraries live on a figcraft-server".into() }
-    }
-
-    /// A request on a plugin directory connection; `publisher`: it was opened with the right key
-    /// (checked by [`manage`](Self::manage)).
-    fn plugins(&mut self, _ip: IpAddr, _publisher: bool, _req: PluginReq) -> PluginReply {
-        PluginReply::Failed { reason: "this session is hosted by an app: plugin directories live on a figcraft-server".into() }
-    }
-
-    /// A new connection from `ip` ([`ip_key`]): whether it may go on (why not is shown to the
-    /// client).
-    fn connect(&mut self, _ip: IpAddr) -> Result<(), String> {
-        Ok(())
-    }
-
-    /// A message from a connection from `ip`: false disconnects it (that address sends too much).
-    fn message(&mut self, _ip: IpAddr, _msg: &ClientMsg) -> bool {
-        true
-    }
-
-    /// What to tell a client that reads it about the server's hosting, after its welcome to
-    /// `file` (`None`: nothing).
-    fn hosting(&mut self, _file: &str) -> Option<HostInfo> {
-        None
-    }
-
-    /// An open hosting connection from `ip`, with a file's owner token when `file` isn't empty:
-    /// what the server says about its hosting, or why the connection is refused.
-    fn open_hosting(&mut self, _ip: IpAddr, _file: &str, _owner: &str) -> Result<HostInfo, String> {
-        Err("this session is hosted by an app: it doesn't keep files for anyone".into())
-    }
-
-    /// A request on an open hosting connection from `ip`; `owns`: the file whose owner token it
-    /// was opened with.
-    fn hosted(&mut self, _ip: IpAddr, _owns: Option<&str>, _req: Admin, _open: &dyn Fn(&str) -> Option<OpenFile>) -> Handled {
-        AdminReply::Failed { reason: "nothing to manage here".into() }.into()
-    }
-
-    /// Someone in `file` (joined with `link`, from `ip`) reports it to the operator.
-    fn report(&mut self, _file: &str, _link: Option<&str>, _ip: IpAddr, _reason: &str) -> Result<(), String> {
-        Err("this session is hosted by an app: tell the person hosting it".into())
-    }
-
-    /// A join code typed by someone at `ip`: the file it opens and that link's token, or why not
-    /// (shown to them; wrong codes are counted against the address).
-    fn resolve(&mut self, _ip: IpAddr, _code: &str) -> Result<(String, String), String> {
-        Err("this session is hosted by an app: join it with its own code or invite link".into())
-    }
-
-    /// What everyone is told when the hub stops.
-    fn closing(&self) -> Closing;
-}
-
-/// A message for one connection's writer: bytes (with what they count against, released when
-/// they are sent or dropped), or the close.
-enum Out {
-    Bytes(Bytes, Option<Charge>),
-    Close(CloseCode, String),
-}
-
-/// One message's bytes held for one or more connections (a broadcast shares one buffer), counted
-/// once against a shared counter (the server's, or a block's) until the last copy is sent or
-/// dropped.
-struct Held {
-    n: usize,
-    counter: Arc<AtomicUsize>,
-}
-
-impl Held {
-    fn new(n: usize, counter: &Arc<AtomicUsize>) -> Arc<Held> {
-        counter.fetch_add(n, Ordering::Relaxed);
-        Arc::new(Held { n, counter: counter.clone() })
-    }
-}
-
-impl Drop for Held {
-    fn drop(&mut self) {
-        self.counter.fetch_sub(self.n, Ordering::Relaxed);
-    }
-}
-
-/// What one message counts against, made by its first recipient and shared by the others: the
-/// server's budget once, and each recipient block's once (twenty people behind one office's
-/// address cost their block one copy of a broadcast, not twenty).
-#[derive(Default)]
-struct Charges {
-    all: Option<Arc<Held>>,
-    blocks: Vec<(usize, Arc<Held>)>,
-    /// Count it against blocks at all: a welcome isn't (it is bounded by the file's size and each
-    /// connection's cap, and a whole office joining at once must fit).
-    skip_blocks: bool,
-}
-
-/// Bytes waiting in a connection's queue, counted against its cap until dropped (and, through
-/// [`Held`], once against the server's budget and once against its block's).
-struct Charge {
-    n: usize,
-    mine: Arc<AtomicUsize>,
-    _all: Arc<Held>,
-    _block: Option<Arc<Held>>,
-}
-
-impl Drop for Charge {
-    fn drop(&mut self) {
-        self.mine.fetch_sub(self.n, Ordering::Relaxed);
-    }
-}
-
-/// Why a message couldn't be queued.
-#[derive(Debug, PartialEq, Eq)]
-enum Push {
-    /// The connection's or its block's queue is full: it can't keep up.
-    Full,
-    /// The server's budget for queued bytes is used up.
-    Everyone,
-    /// The connection is gone.
-    Gone,
-}
-
-/// One connection's way out: its writer's queue, capped in messages and in bytes (its own, its
-/// block of addresses', and the server's for everyone), so a client that doesn't read can't make
-/// the server hold more than that for it.
-#[derive(Clone)]
-struct Line {
-    tx: SyncSender<Out>,
-    queued: Arc<AtomicUsize>,
-    block: Arc<AtomicUsize>,
-    all: Arc<AtomicUsize>,
-    max: usize,
-    max_block: usize,
-    max_all: usize,
-}
-
-impl Line {
-    /// Queue `b`. One message always fits an empty queue (a welcome as large as the largest file
-    /// gets out). `charges` is what the message counts against, shared by its recipients;
-    /// `over_budget` lets it past the server's budget (the hub just dropped the biggest consumer
-    /// to make room).
-    fn push(&self, b: &Bytes, charges: &mut Charges, over_budget: bool) -> Result<(), Push> {
-        let n = b.len();
-        let mine = self.queued.load(Ordering::Relaxed);
-        if mine > 0 && mine.saturating_add(n) > self.max {
-            return Err(Push::Full);
-        }
-        let key = Arc::as_ptr(&self.block) as usize;
-        let block = if charges.skip_blocks {
-            None
-        } else if let Some((_, h)) = charges.blocks.iter().find(|(k, _)| *k == key) {
-            Some(h.clone())
-        } else {
-            let used = self.block.load(Ordering::Relaxed);
-            if used > 0 && used.saturating_add(n) > self.max_block {
-                return Err(Push::Full);
-            }
-            let h = Held::new(n, &self.block);
-            charges.blocks.push((key, h.clone()));
-            Some(h)
-        };
-        let all = match &charges.all {
-            Some(h) => h.clone(),
-            None => {
-                if !over_budget && self.all.load(Ordering::Relaxed).saturating_add(n) > self.max_all {
-                    return Err(Push::Everyone);
-                }
-                charges.all.insert(Held::new(n, &self.all)).clone()
-            }
-        };
-        self.queued.fetch_add(n, Ordering::Relaxed);
-        let charge = Charge { n, mine: self.queued.clone(), _all: all, _block: block };
-        self.tx.try_send(Out::Bytes(b.clone(), Some(charge))).map_err(|e| match e {
-            TrySendError::Full(_) => Push::Full,
-            TrySendError::Disconnected(_) => Push::Gone,
-        })
-    }
-}
-
-/// What one block of addresses (an IPv4 address, an IPv6 /48: [`wide_block`]) has queued and is
-/// having read, shared by its connections.
-#[derive(Clone, Default)]
-struct BlockUse {
-    queued: Arc<AtomicUsize>,
-    reading: Arc<AtomicUsize>,
-}
-
-/// The blocks with open connections; a block leaves when its last connection ends.
-#[derive(Clone, Default)]
-struct Blocks(Arc<Mutex<HashMap<IpAddr, BlockUse>>>);
-
-impl Blocks {
-    /// Block `key`'s counters; blocks nobody uses any more (only the table holds their counters,
-    /// whose connections' queues and readers are all gone) are forgotten first, so the table
-    /// never holds more than the blocks of open connections.
-    fn get(&self, key: IpAddr) -> BlockUse {
-        let mut t = self.0.lock().unwrap_or_else(PoisonError::into_inner);
-        t.retain(|_, u| Arc::strong_count(&u.queued) > 1 || Arc::strong_count(&u.reading) > 1);
-        t.entry(key).or_default().clone()
-    }
-
-    /// Blocks remembered.
-    fn len(&self) -> usize {
-        self.0.lock().unwrap_or_else(PoisonError::into_inner).len()
-    }
-}
-
-/// The widest block an address counts in for the server's shared budgets: an IPv4 address, or an
-/// IPv6 address's /48.
-pub fn wide_block(key: IpAddr) -> IpAddr {
-    ip_blocks(key).last().map_or(key, |(b, _)| b.0)
-}
-
-/// Messages handed to the hub thread and not handled yet, in bytes: past the budget a reader
-/// drops its connection instead of piling more on a busy hub.
-#[derive(Clone)]
-struct InFlight(Arc<AtomicUsize>);
-
-impl InFlight {
-    fn take(&self, n: usize, max: usize) -> bool {
-        if self.0.fetch_add(n, Ordering::Relaxed).saturating_add(n) > max {
-            self.0.fetch_sub(n, Ordering::Relaxed);
-            return false;
-        }
-        true
-    }
-
-    fn give(&self, n: usize) {
-        self.0.fetch_sub(n, Ordering::Relaxed);
-    }
-}
-
-enum HubIn {
-    /// A connection's first message (`Hello`, `Manage`, `OpenLibrary`, `OpenPlugins`,
-    /// `OpenHosting` or `Resolve`) and its client's address ([`ip_key`]).
-    Open {
-        conn: u64,
-        ip: IpAddr,
-        first: ClientMsg,
-        out: Line,
-        sock: TcpStream,
-        /// Its size (in flight until handled).
-        bytes: usize,
-        /// Told when the hub takes the connection in (dropped unsent when it doesn't).
-        admitted: SyncSender<()>,
-    },
-    Msg {
-        conn: u64,
-        msg: ClientMsg,
-        bytes: usize,
-    },
-    Gone {
-        conn: u64,
-    },
-    Local(Presence),
-    LocalMsg(ClientMsg),
-    /// The person hosting removes client `id` from their file (app sessions).
-    Remove(u32),
-    /// Cut every connection without a word (tests: a network failure).
-    #[cfg(test)]
-    Cut,
-    Stop,
-}
-
-/// The person hosting an app session: in the file's session without a socket.
-pub(crate) struct Local {
-    pub file: String,
-    pub server: Server,
-    /// Their client id (they joined `server` already).
-    pub id: u32,
-    pub inbox: Inbox,
-}
-
-fn spawn(name: &str, f: impl FnOnce() + Send + 'static) -> io::Result<JoinHandle<()>> {
-    std::thread::Builder::new().name(name.to_string()).spawn(f)
-}
-
-/// A name others may see: trimmed, no control characters, at most [`MAX_NAME`] characters.
-pub(crate) fn clean_name(s: &str) -> String {
-    s.trim().chars().filter(|c| !c.is_control()).take(MAX_NAME).collect()
-}
-
-/// A running hub: its listener, connections and hub thread. Dropping it stops it.
-pub struct Hosting {
-    addr: SocketAddr,
-    hub: Sender<HubIn>,
-    stop: Arc<AtomicBool>,
-    open: Arc<AtomicUsize>,
-    /// Bytes queued for every connection together, and in flight to the hub.
-    queued: Arc<AtomicUsize>,
-    in_flight: InFlight,
-    blocks: Blocks,
-    reading: Arc<AtomicUsize>,
-    hub_thread: Option<JoinHandle<()>>,
-    accept_thread: Option<JoinHandle<()>>,
-}
-
-impl Hosting {
-    /// Serve `backend`'s files on `listener`.
-    pub fn serve<B: Backend>(listener: TcpListener, backend: B, limits: NetLimits) -> io::Result<Hosting> {
-        Self::start(listener, backend, limits, None)
-    }
-
-    pub(crate) fn start<B: Backend>(listener: TcpListener, backend: B, limits: NetLimits, local: Option<Local>) -> io::Result<Hosting> {
-        let addr = listener.local_addr()?;
-        let in_flight = InFlight(Arc::default());
-        let mut hub = Hub {
-            backend,
-            rooms: HashMap::new(),
-            conns: HashMap::new(),
-            local: None,
-            outbox: Vec::new(),
-            in_flight: in_flight.clone(),
-            barred: HashMap::new(),
-        };
-        if let Some(l) = local {
-            let mut room = Room::new(l.server);
-            room.local = Some((l.id, l.inbox));
-            hub.rooms.insert(l.file.clone(), room);
-            hub.local = Some(l.file);
-        }
-        let (hub_tx, hub_rx) = channel();
-        let stop = Arc::new(AtomicBool::new(false));
-        let open = Arc::new(AtomicUsize::new(0));
-        let hub_thread = spawn("live-hub", move || hub.run(&hub_rx))?;
-        let shared = Shared {
-            per_address: PerAddress::default(),
-            queued: Arc::default(),
-            in_flight: in_flight.clone(),
-            blocks: Blocks::default(),
-            reading: Arc::default(),
-            readers: Readers::default(),
-        };
-        let queued = shared.queued.clone();
-        let blocks = shared.blocks.clone();
-        let reading = shared.reading.clone();
-        let accept_thread = {
-            let (hub_tx, stop, open) = (hub_tx.clone(), stop.clone(), open.clone());
-            spawn("live-accept", move || accept(&listener, &hub_tx, &stop, &open, limits, shared))
-        };
-        let accept_thread = match accept_thread {
-            Ok(t) => t,
-            Err(e) => {
-                let _ = hub_tx.send(HubIn::Stop);
-                let _ = hub_thread.join();
-                return Err(e);
-            }
-        };
-        log::info!("live session: listening on {addr}");
-        Ok(Hosting {
-            addr,
-            hub: hub_tx,
-            stop,
-            open,
-            queued,
-            in_flight,
-            blocks,
-            reading,
-            hub_thread: Some(hub_thread),
-            accept_thread: Some(accept_thread),
-        })
-    }
-
-    /// Bytes waiting to be sent to clients, all connections together.
-    pub fn queued_bytes(&self) -> usize {
-        self.queued.load(Ordering::Relaxed)
-    }
-
-    /// Blocks of addresses the server keeps counters for (those of open connections, and any
-    /// whose last connection just ended, until the next connection prunes them).
-    pub fn blocks_remembered(&self) -> usize {
-        self.blocks.len()
-    }
-
-    /// Bytes being read into messages not whole yet, all connections together.
-    pub fn reading_bytes(&self) -> usize {
-        self.reading.load(Ordering::Relaxed)
-    }
-
-    /// Bytes of messages read and not handled by the hub yet.
-    pub fn in_flight_bytes(&self) -> usize {
-        self.in_flight.0.load(Ordering::Relaxed)
-    }
-
-    /// Where it listens.
-    pub fn addr(&self) -> SocketAddr {
-        self.addr
-    }
-
-    /// Open connections (joined or not).
-    pub fn connections(&self) -> usize {
-        self.open.load(Ordering::Relaxed)
-    }
-
-    /// The hosting person's presence (app sessions).
-    pub(crate) fn presence(&self, p: Presence) {
-        let _ = self.hub.send(HubIn::Local(p));
-    }
-
-    /// A message from the hosting person's sync client (their edits).
-    pub(crate) fn send(&self, msg: ClientMsg) {
-        let _ = self.hub.send(HubIn::LocalMsg(msg));
-    }
-
-    /// The hosting person removes client `id` from their file (app sessions; see
-    /// [`HubIn::Remove`]).
-    pub(crate) fn remove(&self, id: u32) {
-        let _ = self.hub.send(HubIn::Remove(id));
-    }
-
-    /// Cut every connection as a network failure would (no close frame).
-    #[cfg(test)]
-    pub(crate) fn cut_connections(&self) {
-        let _ = self.hub.send(HubIn::Cut);
-    }
-
-    /// Stop: the backend saves what's open, everyone is told and disconnected, the port is
-    /// released.
-    pub fn stop(&mut self) {
-        if self.stop.swap(true, Ordering::SeqCst) {
-            return;
-        }
-        let _ = self.hub.send(HubIn::Stop);
-        if let Some(t) = self.hub_thread.take() {
-            let _ = t.join();
-        }
-        // The accept loop checks the flag after each connection: wake it with one.
-        let wake = if self.addr.ip().is_unspecified() { SocketAddr::new(loopback(self.addr), self.addr.port()) } else { self.addr };
-        let woke = TcpStream::connect_timeout(&wake, Duration::from_secs(1)).is_ok();
-        if let Some(t) = self.accept_thread.take() {
-            if woke {
-                let _ = t.join();
-            } else {
-                log::warn!("live session: couldn't wake the accept loop; it ends with the next connection");
-            }
-        }
-        // Readers end once their writers have closed the sockets.
-        let deadline = Instant::now() + Duration::from_secs(2);
-        while self.open.load(Ordering::Relaxed) > 0 && Instant::now() < deadline {
-            std::thread::sleep(Duration::from_millis(5));
-        }
-        log::info!("live session: stopped listening on {}", self.addr);
-    }
-}
-
-impl Drop for Hosting {
-    fn drop(&mut self) {
-        self.stop();
-    }
-}
-
-/// The loopback address of `addr`'s family.
-fn loopback(addr: SocketAddr) -> std::net::IpAddr {
-    if addr.is_ipv6() { std::net::Ipv6Addr::LOCALHOST.into() } else { std::net::Ipv4Addr::LOCALHOST.into() }
-}
-
-/// Counts an open connection until dropped.
-struct Open(Arc<AtomicUsize>);
-
-impl Drop for Open {
-    fn drop(&mut self) {
-        self.0.fetch_sub(1, Ordering::Relaxed);
-    }
-}
-
-/// A block of addresses: its first address and its prefix length (2001:db8:: as a /64 and as a
-/// /48 are different blocks).
-pub type Block = (IpAddr, u8);
-
-/// The blocks a client's address ([`ip_key`]) counts in, with how many times its own limits each
-/// gets: the address itself (an IPv4 /32 or an IPv6 /64, ×1) and, for IPv6, its /56 (×2) and /48
-/// (×4), so a tunnel's free /48 doesn't multiply the limits 65,536 times.
-pub fn ip_blocks(key: IpAddr) -> Vec<(Block, u32)> {
-    let IpAddr::V6(v6) = key else { return vec![((key, 32), 1)] };
-    let [a, b, c, d, ..] = v6.segments();
-    vec![
-        ((IpAddr::V6(Ipv6Addr::new(a, b, c, d, 0, 0, 0, 0)), 64), 1),
-        ((IpAddr::V6(Ipv6Addr::new(a, b, c, d & 0xff00, 0, 0, 0, 0)), 56), 2),
-        ((IpAddr::V6(Ipv6Addr::new(a, b, c, 0, 0, 0, 0, 0)), 48), 4),
-    ]
-}
-
-/// Open connections per client address ([`ip_key`], and its wider IPv6 blocks); an address
-/// leaves when its last one closes, so the table never holds more than the open connections.
-#[derive(Clone, Default)]
-struct PerAddress(Arc<Mutex<HashMap<Block, usize>>>);
-
-/// One connection counted for a block until dropped.
-struct Counted {
-    table: PerAddress,
-    ip: Block,
-}
-
-impl PerAddress {
-    /// Count a connection from block `ip`, unless it has `cap` already (0: no cap).
-    fn enter(&self, ip: Block, cap: usize) -> Option<Counted> {
-        let mut t = self.0.lock().unwrap_or_else(PoisonError::into_inner);
-        let n = t.entry(ip).or_insert(0);
-        if cap > 0 && *n >= cap {
-            if *n == 0 {
-                t.remove(&ip);
-            }
-            return None;
-        }
-        *n += 1;
-        Some(Counted { table: self.clone(), ip })
-    }
-
-    /// Count a connection from `ip` in each of its blocks, unless one of them is full. A wider
-    /// block's cap is its multiple of `cap`, but at most a sixteenth (/56) or an eighth (/48) of
-    /// `all` connections, so no block takes every connection.
-    fn enter_all(&self, ip: IpAddr, cap: usize, all: usize) -> Option<Vec<Counted>> {
-        let mut held = Vec::new();
-        for ((addr, prefix), times) in ip_blocks(ip) {
-            let block_cap = match prefix {
-                56 => cap.saturating_mul(times as usize).min(all / 16).max(1),
-                48 => cap.saturating_mul(times as usize).min(all / 8).max(1),
-                _ => cap,
-            };
-            held.push(self.enter((addr, prefix), if cap == 0 { 0 } else { block_cap })?);
-        }
-        Some(held)
-    }
-}
-
-impl Drop for Counted {
-    fn drop(&mut self) {
-        let mut t = self.table.0.lock().unwrap_or_else(PoisonError::into_inner);
-        if let Some(n) = t.get_mut(&self.ip) {
-            *n = n.saturating_sub(1);
-            if *n == 0 {
-                t.remove(&self.ip);
-            }
-        }
-    }
-}
-
-/// Longest request line an uptime check may have.
-const MAX_CHECK_LINE: usize = 2048;
-
-/// An uptime check: a plain `GET` of a path ending in `/healthz` is answered `200 ok` and closed.
-/// True when it was one (the connection is done). Anything else is only peeked at, so a WebSocket
-/// handshake goes on untouched.
-fn health_check(stream: &mut TcpStream, until: Instant) -> bool {
-    let mut buf = [0u8; MAX_CHECK_LINE];
-    let line = loop {
-        let n = match stream.peek(&mut buf) {
-            Ok(0) | Err(_) => return false,
-            Ok(n) => n,
-        };
-        let seen = buf.get(..n).unwrap_or_default();
-        if !seen.starts_with(b"GET ") && !b"GET ".starts_with(seen) {
-            return false;
-        }
-        if let Some(end) = seen.windows(2).position(|w| w == b"\r\n") {
-            break seen.get(..end).unwrap_or_default().to_vec();
-        }
-        if n == buf.len() || Instant::now() >= until {
-            return false;
-        }
-        // The rest of the line is on its way (it nearly always arrives in one piece).
-        std::thread::sleep(Duration::from_millis(10));
-    };
-    let path = line.split(|b| *b == b' ').nth(1).unwrap_or_default();
-    let path = path.split(|b| *b == b'?').next().unwrap_or_default();
-    if !path.ends_with(b"/healthz") {
-        return false;
-    }
-    // Read the request (its headers end with a blank line), so closing doesn't reset it.
-    let mut req = Vec::new();
-    let mut chunk = [0u8; 1024];
-    while !req.windows(4).any(|w| w == b"\r\n\r\n") && req.len() < 16 << 10 {
-        match stream.read(&mut chunk) {
-            Ok(0) | Err(_) => break,
-            Ok(n) => req.extend_from_slice(chunk.get(..n).unwrap_or_default()),
-        }
-    }
-    let _ = stream
-        .write_all(b"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 3\r\nCache-Control: no-store\r\nConnection: close\r\n\r\nok\n");
-    let _ = stream.shutdown(std::net::Shutdown::Write);
-    true
-}
-
-/// The client a trusted proxy names: the last address of its last `X-Forwarded-For` (the one the
-/// proxy added; any before it are whatever the client sent).
-fn forwarded_for(req: &Request) -> Option<IpAddr> {
-    let last = req.headers().get_all("x-forwarded-for").iter().next_back()?.to_str().ok()?;
-    let entry = last.rsplit(',').next()?.trim();
-    entry.parse::<IpAddr>().ok().or_else(|| entry.parse::<SocketAddr>().ok().map(|a| a.ip()))
-}
-
-/// What every connection shares: the count per address, the bytes queued for all of them and the
-/// bytes in flight to the hub.
-#[derive(Clone)]
-struct Shared {
-    per_address: PerAddress,
-    queued: Arc<AtomicUsize>,
-    in_flight: InFlight,
-    blocks: Blocks,
-    /// Bytes being read into messages, all connections together, and who is reading them.
-    reading: Arc<AtomicUsize>,
-    readers: Readers,
-}
-
-fn accept(listener: &TcpListener, hub: &Sender<HubIn>, stop: &AtomicBool, open: &Arc<AtomicUsize>, limits: NetLimits, shared: Shared) {
-    let mut next = 0u64;
-    for stream in listener.incoming() {
-        if stop.load(Ordering::SeqCst) {
-            break;
-        }
-        let stream = match stream {
-            Ok(s) => s,
-            Err(e) => {
-                // Out of sockets or similar: don't spin.
-                log::warn!("live session: accept failed: {e}");
-                std::thread::sleep(Duration::from_millis(50));
-                continue;
-            }
-        };
-        if open.load(Ordering::Relaxed) >= limits.max_connections {
-            log::info!("live session: too many connections; refusing one");
-            continue;
-        }
-        open.fetch_add(1, Ordering::Relaxed);
-        let guard = Open(open.clone());
-        next += 1;
-        let (conn, hub, shared) = (next, hub.clone(), shared.clone());
-        if let Err(e) = spawn("live-conn", move || serve(stream, conn, &hub, limits, guard, &shared)) {
-            log::warn!("live session: can't start a connection thread: {e}");
-        }
-    }
-}
-
-/// A close reason that fits a WebSocket close frame (123 bytes).
-fn reason(s: &str) -> String {
-    let mut end = s.len().min(123);
-    while !s.is_char_boundary(end) {
-        end -= 1;
-    }
-    s.get(..end).unwrap_or_default().to_string()
-}
-
-fn encode(msg: &ServerMsg) -> Option<Bytes> {
-    match message::encode(msg) {
-        Ok(b) => Some(Bytes::from(b)),
-        Err(e) => {
-            log::warn!("live session: can't encode a message: {e}");
-            None
-        }
-    }
-}
-
-/// Queue `Refused {reason}` and a close for one connection (small: not counted against its caps).
-fn refuse(out: &Line, why: &str) {
-    refused(out, why);
-}
-
-/// [`refuse`], and whether the close was queued (it isn't when the queue is full).
-fn refused(out: &Line, why: &str) -> bool {
-    if let Some(b) = encode(&ServerMsg::Refused { reason: why.to_string() }) {
-        let _ = out.tx.try_send(Out::Bytes(b, None));
-    }
-    out.tx.try_send(Out::Close(CloseCode::Policy, reason(why))).is_ok()
-}
-
-/// What the server tells a client when it is too busy to take more from it.
-const BUSY: &str = "the server is busy: try again in a moment";
-
-/// Read the next binary message (skipping pings, until `deadline`) and its size, or why the connection should end.
-fn next_message(ws: &mut WebSocket<Duplex>, max: usize, deadline: Option<Instant>) -> Result<Option<(ClientMsg, usize)>, String> {
-    loop {
-        return match ws.read() {
-            Ok(Message::Binary(b)) => {
-                // Whole now: it counts as in flight from here, no longer as being read.
-                ws.get_mut().read_done();
-                message::decode::<ClientMsg>(&b, max).map(|m| Some((m, b.len()))).map_err(|_| "that message couldn't be read".to_string())
-            }
-            Ok(Message::Text(_)) => Err("only binary messages are spoken here".into()),
-            // Pings keep the per-read timeout alive, but not the overall deadline (slowloris), and
-            // a message trickled in is cut off by it (`Duplex::read_until`).
-            Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_)) | Err(tungstenite::Error::Io(_))
-                if deadline.is_some_and(|d| Instant::now() >= d) =>
-            {
-                Err("no hello in time".into())
-            }
-            Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_)) => continue,
-            Ok(Message::Close(_)) => Ok(None),
-            Err(tungstenite::Error::Capacity(_)) => Err(too_large(max)),
-            // The reading budget's refusal (see `Meter`).
-            Err(tungstenite::Error::Io(e)) if e.kind() == io::ErrorKind::Other => Err(e.to_string()),
-            Err(_) => Ok(None),
-        };
-    }
-}
-
-/// Why a message over `max` bytes is refused.
-fn too_large(max: usize) -> String {
-    match max >> 20 {
-        0 => format!("message too large: this server takes at most {} KiB at once here", max >> 10),
-        mib => format!("message too large: this server takes at most {mib} MiB at once (a change that big can't be kept here)"),
-    }
-}
-
-/// One connection's reader (the writer runs on its own thread).
-fn serve(mut stream: TcpStream, conn: u64, hub: &Sender<HubIn>, limits: NetLimits, open: Open, shared: &Shared) {
-    let _ = stream.set_nodelay(true);
-    let hello_deadline = Instant::now() + limits.hello_timeout;
-    if stream.set_read_timeout(Some(limits.hello_timeout)).is_err() || stream.set_write_timeout(Some(limits.write_timeout)).is_err() {
-        return;
-    }
-    if health_check(&mut stream, Instant::now() + limits.hello_timeout) {
-        return;
-    }
-    let Ok(peer) = stream.peer_addr().map(|a| a.ip().to_canonical()) else { return };
-    let proxied = limits.trusted_proxy.is_some_and(|p| p.to_canonical() == peer);
-    let Ok((mut rd, wr, sock)) = Duplex::split(stream, None) else { return };
-    // The handshake and the hello must be in by the deadline, however slowly they trickle in.
-    rd.read_until(Some(hello_deadline));
-    let cfg = config(limits.max_client_message);
-    let mut forwarded = None;
-    // The handshake callback's type is tungstenite's (its error is an HTTP response).
-    #[allow(clippy::result_large_err)]
-    let read_client = |req: &Request, resp: Response| -> Result<Response, ErrorResponse> {
-        if proxied {
-            forwarded = forwarded_for(req);
-        }
-        Ok(resp)
-    };
-    let mut ws = match tungstenite::accept_hdr_with_config(rd, read_client, Some(config(limits.max_hello))) {
-        Ok(ws) => ws,
-        Err(e) => {
-            log::debug!("live session: handshake failed: {e}");
-            shutdown(&sock);
-            return;
-        }
-    };
-    if proxied && forwarded.is_none() {
-        log::debug!("live session: connection {conn} came through the proxy without X-Forwarded-For");
-    }
-    let ip = ip_key(forwarded.unwrap_or(peer));
-    let counted = shared.per_address.enter_all(ip, limits.max_per_address, limits.max_connections);
-    let wide = wide_block(ip);
-    let block = shared.blocks.get(wide);
-    ws.get_mut().meter(Meter::new(
-        conn,
-        &sock,
-        &shared.readers,
-        block.reading.clone(),
-        shared.reading.clone(),
-        limits.max_reading_block,
-        limits.max_reading_total,
-    ));
-    let (tx, rx) = sync_channel::<Out>(limits.queue.max(4));
-    let out = Line {
-        tx,
-        queued: Arc::default(),
-        block: block.queued.clone(),
-        all: shared.queued.clone(),
-        max: limits.max_queued_bytes,
-        max_block: limits.max_queued_block,
-        max_all: limits.max_queued_total,
-    };
-    let writer =
-        match sock.try_clone().map(|s| spawn("live-write", move || write_loop(WebSocket::from_raw_socket(wr, Role::Server, Some(cfg)), &rx, &s))) {
-            Ok(Ok(t)) => t,
-            _ => {
-                shutdown(&sock);
-                return;
-            }
-        };
-    let end = |why: Option<&str>| {
-        if let Some(why) = why {
-            refuse(&out, why);
-        } else {
-            let _ = out.tx.try_send(Out::Close(CloseCode::Normal, String::new()));
-        }
-    };
-    if counted.is_none() {
-        log::info!("event=refused ip={ip} reason=connections_per_address");
-        end(Some("too many connections from your address: close some and try again"));
-    } else {
-        let hello = next_message(&mut ws, limits.max_hello, Some(hello_deadline));
-        // In time or not, the hello's deadline is over: what's read next has timeouts of its own.
-        ws.get_mut().read_until(None);
-        match hello {
-            Ok(Some((
-                first @ (ClientMsg::Hello(_)
-                | ClientMsg::Manage(_)
-                | ClientMsg::OpenLibrary(_)
-                | ClientMsg::OpenPlugins(_)
-                | ClientMsg::OpenHosting(_)
-                | ClientMsg::Resolve(_)),
-                bytes,
-            ))) => {
-                // Sessions and the operator may use the last connections; one-shot requests
-                // (hosting, libraries, browsing plugins) leave them free.
-                let session = matches!(first, ClientMsg::Hello(_) | ClientMsg::Manage(_));
-                // A publish uploads a whole file; a large one on a slow link takes the server a
-                // while to receive and answer. The manage/hosting connections that carry uploads
-                // wait the longer request-reply timeout, not the short request idle.
-                let idle = match first {
-                    ClientMsg::Manage(_) | ClientMsg::OpenHosting(_) => limits.request_reply_timeout,
-                    ClientMsg::Hello(_) => limits.idle_timeout,
-                    _ => limits.request_idle,
-                };
-                let max = match &first {
-                    ClientMsg::OpenPlugins(o) if o.key.is_empty() => limits.max_request,
-                    _ => limits.max_client_message,
-                };
-                let reserved = !session && open.0.load(Ordering::Relaxed) > limits.max_connections.saturating_sub(limits.reserve_for_sessions);
-                // (In flight is only taken when the connection goes on: the hub gives it back.)
-                if reserved || !shared.in_flight.take(bytes, limits.max_in_flight) {
-                    end(Some(BUSY));
-                } else {
-                    let (admitted, verdict) = sync_channel(1);
-                    let opened =
-                        sock.try_clone().is_ok_and(|s| hub.send(HubIn::Open { conn, ip, first, out: out.clone(), sock: s, bytes, admitted }).is_ok());
-                    // Nothing more is read until the hub took the connection in (its token checked):
-                    // only then may it send messages of the full size.
-                    if opened && verdict.recv().is_ok() && ws.get_ref().set_read_timeout(Some(idle)).is_ok() {
-                        ws.set_config(|c| *c = config(max));
-                        read_loop(&mut ws, conn, hub, limits, max, &shared.in_flight, &end);
-                        let _ = hub.send(HubIn::Gone { conn });
-                    }
-                }
-            }
-            Ok(Some(_)) => end(Some("say hello first")),
-            Ok(None) => {}
-            Err(why) => end(Some(&why)),
-        }
-    }
-    drop(counted);
-    // The block's counters go with the last handle on them (the table forgets it then).
-    drop(block);
-    ws.get_mut().read_until(None);
-    linger(&mut ws);
-    drop(out);
-    // The writer closes the socket once it has sent what's queued (a refusal, a close).
-    let _ = writer.join();
-    shutdown(&sock);
-}
-
-fn read_loop(
-    ws: &mut WebSocket<Duplex>,
-    conn: u64,
-    hub: &Sender<HubIn>,
-    limits: NetLimits,
-    max: usize,
-    in_flight: &InFlight,
-    end: &dyn Fn(Option<&str>),
-) {
-    let mut bucket = Bucket::new(limits.rate, limits.burst);
-    let mut signals = Bucket::new(SIGNAL_RATE, SIGNAL_BURST);
-    loop {
-        match next_message(ws, max, None) {
-            Ok(Some((msg, bytes))) => {
-                let now = Instant::now();
-                if !bucket.take(now) {
-                    log::info!("live session: connection {conn} sends too much; disconnecting it");
-                    return end(Some("too many messages"));
-                }
-                // Typing sends a chat signal per keystroke; more than this is dropped.
-                if matches!(msg, ClientMsg::Signal(_)) && !signals.take(now) {
-                    log::debug!("live session: connection {conn} sends signals too fast; dropping one");
-                    continue;
-                }
-                if !in_flight.take(bytes, limits.max_in_flight) {
-                    log::info!("live session: the hub is behind; dropping connection {conn}");
-                    return end(Some(BUSY));
-                }
-                if hub.send(HubIn::Msg { conn, msg, bytes }).is_err() {
-                    return;
-                }
-            }
-            Ok(None) => return end(None),
-            Err(why) => return end(Some(&why)),
-        }
-    }
-}
-
-fn write_loop(mut ws: WebSocket<Duplex>, rx: &Receiver<Out>, sock: &TcpStream) {
-    let mut close = Some((CloseCode::Normal, String::new()));
-    while let Ok(o) = rx.recv() {
-        match o {
-            Out::Bytes(b, _charge) => {
-                if ws.send(Message::Binary(b)).is_err() {
-                    close = None;
-                    break;
-                }
-            }
-            Out::Close(code, why) => {
-                close = Some((code, why));
-                break;
-            }
-        }
-    }
-    if let Some((code, why)) = close {
-        // Close politely: the close frame, then no more writing; the reader drains what the peer
-        // still sends until it hangs up (closing on unread data would reset the connection and
-        // could lose the close frame), or until the linger runs out.
-        let _ = ws.close(Some(CloseFrame { code, reason: why.into() }));
-        let _ = sock.shutdown(std::net::Shutdown::Write);
-        let until = Instant::now() + LINGER;
-        while let Ok(_) | Err(RecvTimeoutError::Timeout) = rx.recv_timeout(until.saturating_duration_since(Instant::now())) {
-            if Instant::now() >= until {
-                break;
-            }
-        }
-    }
-    shutdown(sock);
-}
-
-/// Read and drop what the peer still sends after the close, until it hangs up (at most
-/// [`LINGER`]). Raw bytes, not frames: after a frame over the size limit the WebSocket's reader
-/// is mid-frame and mustn't be asked for more.
-fn linger(ws: &mut WebSocket<Duplex>) {
-    let until = Instant::now() + LINGER;
-    let mut buf = [0u8; 4096];
-    while Instant::now() < until && ws.get_ref().set_read_timeout(Some(Duration::from_millis(250))).is_ok() {
-        match ws.get_mut().read(&mut buf) {
-            Ok(0) => break,
-            Ok(_) => {}
-            Err(e) if matches!(e.kind(), io::ErrorKind::WouldBlock | io::ErrorKind::TimedOut | io::ErrorKind::Interrupted) => {}
-            Err(_) => break,
-        }
-    }
-}
-
 /// What a connection is for.
 enum Kind {
     /// In `file`'s session as client `id`, through link `link`.
diff --git a/crates/collab-net/src/hub/backend.rs b/crates/collab-net/src/hub/backend.rs
new file mode 100644
index 00000000..04c5363d
--- /dev/null
+++ b/crates/collab-net/src/hub/backend.rs
@@ -0,0 +1,138 @@
+use super::limits::Admission;
+use super::*;
+
+/// An admin request's reply, and what the hub must do about connections it affects.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Handled {
+    pub reply: AdminReply,
+    /// A link was revoked: `(file, link)`; whoever joined with it is disconnected.
+    pub revoked: Option<(String, String)>,
+    /// A file was removed: whoever is in it is disconnected and it is closed without saving.
+    pub removed: Option<String>,
+    /// An address was blocked ([`ip_key`]): its connections are dropped.
+    pub blocked: Option<IpAddr>,
+}
+
+impl From<AdminReply> for Handled {
+    fn from(reply: AdminReply) -> Self {
+        Self { reply, revoked: None, removed: None, blocked: None }
+    }
+}
+
+/// What everyone is told when a hub stops.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Closing {
+    /// The session is over (the app stopped hosting): final.
+    Ended,
+    /// The server is restarting: clients reconnect until it is back.
+    Restarting,
+}
+
+/// What the hub knows of an open file (for listings).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct OpenFile {
+    /// People connected to it.
+    pub people: u32,
+    /// Its latest sequence number.
+    pub seq: u64,
+}
+
+/// Where a hub's files come from and what it keeps of them (see the module docs). The hub calls it
+/// from its own thread only.
+pub trait Backend: Send + 'static {
+    /// A hello for `file` with `token`: what it may do, or why it may not join (the reason is
+    /// shown to the person joining; never echo the token).
+    fn admit(&mut self, file: &str, token: &str) -> Result<Admission, String>;
+
+    /// The session for a file that isn't open (after [`admit`](Self::admit) let someone in).
+    fn open(&mut self, file: &str) -> Result<Server, String>;
+
+    /// The hub handled a message for an open file: keep what changed (its server's journal).
+    fn changed(&mut self, _file: &str, _server: &mut Server) {}
+
+    /// Make what [`changed`](Self::changed) kept durable; the hub sends the servers' answers
+    /// after this. The files whose changes couldn't be made durable: nobody hears of them, the
+    /// files are closed (the backend forgets their open state) and everyone in them reconnects.
+    fn flush(&mut self) -> Vec<String> {
+        Vec::new()
+    }
+
+    /// Whether `file` has room for a batch of about `bytes` (its size on the wire): why not, and
+    /// the batch is refused.
+    fn room(&mut self, _file: &str, _server: &Server, _bytes: usize) -> Result<(), String> {
+        Ok(())
+    }
+
+    /// Everyone left `file`: save it. True closes it (the next hello opens it again).
+    fn idle(&mut self, _file: &str, _server: &mut Server) -> bool {
+        false
+    }
+
+    /// The hub is stopping: save the open files.
+    fn stop(&mut self, _open: Vec<(&str, &mut Server)>) {}
+
+    /// A managing connection's key: whether it may manage files.
+    fn manage(&mut self, _key: &str) -> Result<(), String> {
+        Err("this session is hosted by an app: it has no files to manage".into())
+    }
+
+    /// A request on a managing connection; `open` tells about a file that is open.
+    fn admin(&mut self, _req: Admin, _open: &dyn Fn(&str) -> Option<OpenFile>) -> Handled {
+        AdminReply::Failed { reason: "nothing to manage here".into() }.into()
+    }
+
+    /// A request on a library connection to `file`, opened with a link of `access` (checked by
+    /// [`admit`](Self::admit)).
+    fn library(&mut self, _ip: IpAddr, _file: &str, _access: Access, _req: LibraryReq) -> LibraryReply {
+        LibraryReply::Failed { reason: "this session is hosted by an app: team libraries live on a figcraft-server".into() }
+    }
+
+    /// A request on a plugin directory connection; `publisher`: it was opened with the right key
+    /// (checked by [`manage`](Self::manage)).
+    fn plugins(&mut self, _ip: IpAddr, _publisher: bool, _req: PluginReq) -> PluginReply {
+        PluginReply::Failed { reason: "this session is hosted by an app: plugin directories live on a figcraft-server".into() }
+    }
+
+    /// A new connection from `ip` ([`ip_key`]): whether it may go on (why not is shown to the
+    /// client).
+    fn connect(&mut self, _ip: IpAddr) -> Result<(), String> {
+        Ok(())
+    }
+
+    /// A message from a connection from `ip`: false disconnects it (that address sends too much).
+    fn message(&mut self, _ip: IpAddr, _msg: &ClientMsg) -> bool {
+        true
+    }
+
+    /// What to tell a client that reads it about the server's hosting, after its welcome to
+    /// `file` (`None`: nothing).
+    fn hosting(&mut self, _file: &str) -> Option<HostInfo> {
+        None
+    }
+
+    /// An open hosting connection from `ip`, with a file's owner token when `file` isn't empty:
+    /// what the server says about its hosting, or why the connection is refused.
+    fn open_hosting(&mut self, _ip: IpAddr, _file: &str, _owner: &str) -> Result<HostInfo, String> {
+        Err("this session is hosted by an app: it doesn't keep files for anyone".into())
+    }
+
+    /// A request on an open hosting connection from `ip`; `owns`: the file whose owner token it
+    /// was opened with.
+    fn hosted(&mut self, _ip: IpAddr, _owns: Option<&str>, _req: Admin, _open: &dyn Fn(&str) -> Option<OpenFile>) -> Handled {
+        AdminReply::Failed { reason: "nothing to manage here".into() }.into()
+    }
+
+    /// Someone in `file` (joined with `link`, from `ip`) reports it to the operator.
+    fn report(&mut self, _file: &str, _link: Option<&str>, _ip: IpAddr, _reason: &str) -> Result<(), String> {
+        Err("this session is hosted by an app: tell the person hosting it".into())
+    }
+
+    /// A join code typed by someone at `ip`: the file it opens and that link's token, or why not
+    /// (shown to them; wrong codes are counted against the address).
+    fn resolve(&mut self, _ip: IpAddr, _code: &str) -> Result<(String, String), String> {
+        Err("this session is hosted by an app: join it with its own code or invite link".into())
+    }
+
+    /// What everyone is told when the hub stops.
+    fn closing(&self) -> Closing;
+}
diff --git a/crates/collab-net/src/hub/conn.rs b/crates/collab-net/src/hub/conn.rs
new file mode 100644
index 00000000..109dfed9
--- /dev/null
+++ b/crates/collab-net/src/hub/conn.rs
@@ -0,0 +1,404 @@
+use super::hosting::{Open, spawn};
+use super::limits::{PerAddress, ip_key};
+use super::queue::{Blocks, HubIn, InFlight, Line, Out, wide_block};
+use super::*;
+
+/// How long a closing connection waits for the peer to hang up.
+const LINGER: Duration = Duration::from_secs(2);
+
+/// Signals (cursor chat, spotlight) a client may send per second on average, and in a burst;
+/// beyond that they are dropped.
+pub const SIGNAL_RATE: f64 = 20.0;
+
+pub const SIGNAL_BURST: f64 = 40.0;
+
+/// Longest request line an uptime check may have.
+const MAX_CHECK_LINE: usize = 2048;
+
+/// An uptime check: a plain `GET` of a path ending in `/healthz` is answered `200 ok` and closed.
+/// True when it was one (the connection is done). Anything else is only peeked at, so a WebSocket
+/// handshake goes on untouched.
+fn health_check(stream: &mut TcpStream, until: Instant) -> bool {
+    let mut buf = [0u8; MAX_CHECK_LINE];
+    let line = loop {
+        let n = match stream.peek(&mut buf) {
+            Ok(0) | Err(_) => return false,
+            Ok(n) => n,
+        };
+        let seen = buf.get(..n).unwrap_or_default();
+        if !seen.starts_with(b"GET ") && !b"GET ".starts_with(seen) {
+            return false;
+        }
+        if let Some(end) = seen.windows(2).position(|w| w == b"\r\n") {
+            break seen.get(..end).unwrap_or_default().to_vec();
+        }
+        if n == buf.len() || Instant::now() >= until {
+            return false;
+        }
+        // The rest of the line is on its way (it nearly always arrives in one piece).
+        std::thread::sleep(Duration::from_millis(10));
+    };
+    let path = line.split(|b| *b == b' ').nth(1).unwrap_or_default();
+    let path = path.split(|b| *b == b'?').next().unwrap_or_default();
+    if !path.ends_with(b"/healthz") {
+        return false;
+    }
+    // Read the request (its headers end with a blank line), so closing doesn't reset it.
+    let mut req = Vec::new();
+    let mut chunk = [0u8; 1024];
+    while !req.windows(4).any(|w| w == b"\r\n\r\n") && req.len() < 16 << 10 {
+        match stream.read(&mut chunk) {
+            Ok(0) | Err(_) => break,
+            Ok(n) => req.extend_from_slice(chunk.get(..n).unwrap_or_default()),
+        }
+    }
+    let _ = stream
+        .write_all(b"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 3\r\nCache-Control: no-store\r\nConnection: close\r\n\r\nok\n");
+    let _ = stream.shutdown(std::net::Shutdown::Write);
+    true
+}
+
+/// The client a trusted proxy names: the last address of its last `X-Forwarded-For` (the one the
+/// proxy added; any before it are whatever the client sent).
+fn forwarded_for(req: &Request) -> Option<IpAddr> {
+    let last = req.headers().get_all("x-forwarded-for").iter().next_back()?.to_str().ok()?;
+    let entry = last.rsplit(',').next()?.trim();
+    entry.parse::<IpAddr>().ok().or_else(|| entry.parse::<SocketAddr>().ok().map(|a| a.ip()))
+}
+
+/// What every connection shares: the count per address, the bytes queued for all of them and the
+/// bytes in flight to the hub.
+#[derive(Clone)]
+pub(super) struct Shared {
+    pub(super) per_address: PerAddress,
+    pub(super) queued: Arc<AtomicUsize>,
+    pub(super) in_flight: InFlight,
+    pub(super) blocks: Blocks,
+    /// Bytes being read into messages, all connections together, and who is reading them.
+    pub(super) reading: Arc<AtomicUsize>,
+    pub(super) readers: Readers,
+}
+
+pub(super) fn accept(listener: &TcpListener, hub: &Sender<HubIn>, stop: &AtomicBool, open: &Arc<AtomicUsize>, limits: NetLimits, shared: Shared) {
+    let mut next = 0u64;
+    for stream in listener.incoming() {
+        if stop.load(Ordering::SeqCst) {
+            break;
+        }
+        let stream = match stream {
+            Ok(s) => s,
+            Err(e) => {
+                // Out of sockets or similar: don't spin.
+                log::warn!("live session: accept failed: {e}");
+                std::thread::sleep(Duration::from_millis(50));
+                continue;
+            }
+        };
+        if open.load(Ordering::Relaxed) >= limits.max_connections {
+            log::info!("live session: too many connections; refusing one");
+            continue;
+        }
+        open.fetch_add(1, Ordering::Relaxed);
+        let guard = Open(open.clone());
+        next += 1;
+        let (conn, hub, shared) = (next, hub.clone(), shared.clone());
+        if let Err(e) = spawn("live-conn", move || serve(stream, conn, &hub, limits, guard, &shared)) {
+            log::warn!("live session: can't start a connection thread: {e}");
+        }
+    }
+}
+
+/// A close reason that fits a WebSocket close frame (123 bytes).
+pub(super) fn reason(s: &str) -> String {
+    let mut end = s.len().min(123);
+    while !s.is_char_boundary(end) {
+        end -= 1;
+    }
+    s.get(..end).unwrap_or_default().to_string()
+}
+
+pub(super) fn encode(msg: &ServerMsg) -> Option<Bytes> {
+    match message::encode(msg) {
+        Ok(b) => Some(Bytes::from(b)),
+        Err(e) => {
+            log::warn!("live session: can't encode a message: {e}");
+            None
+        }
+    }
+}
+
+/// Queue `Refused {reason}` and a close for one connection (small: not counted against its caps).
+pub(super) fn refuse(out: &Line, why: &str) {
+    refused(out, why);
+}
+
+/// [`refuse`], and whether the close was queued (it isn't when the queue is full).
+pub(super) fn refused(out: &Line, why: &str) -> bool {
+    if let Some(b) = encode(&ServerMsg::Refused { reason: why.to_string() }) {
+        let _ = out.tx.try_send(Out::Bytes(b, None));
+    }
+    out.tx.try_send(Out::Close(CloseCode::Policy, reason(why))).is_ok()
+}
+
+/// What the server tells a client when it is too busy to take more from it.
+const BUSY: &str = "the server is busy: try again in a moment";
+
+/// Read the next binary message (skipping pings, until `deadline`) and its size, or why the connection should end.
+fn next_message(ws: &mut WebSocket<Duplex>, max: usize, deadline: Option<Instant>) -> Result<Option<(ClientMsg, usize)>, String> {
+    loop {
+        return match ws.read() {
+            Ok(Message::Binary(b)) => {
+                // Whole now: it counts as in flight from here, no longer as being read.
+                ws.get_mut().read_done();
+                message::decode::<ClientMsg>(&b, max).map(|m| Some((m, b.len()))).map_err(|_| "that message couldn't be read".to_string())
+            }
+            Ok(Message::Text(_)) => Err("only binary messages are spoken here".into()),
+            // Pings keep the per-read timeout alive, but not the overall deadline (slowloris), and
+            // a message trickled in is cut off by it (`Duplex::read_until`).
+            Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_)) | Err(tungstenite::Error::Io(_))
+                if deadline.is_some_and(|d| Instant::now() >= d) =>
+            {
+                Err("no hello in time".into())
+            }
+            Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_)) => continue,
+            Ok(Message::Close(_)) => Ok(None),
+            Err(tungstenite::Error::Capacity(_)) => Err(too_large(max)),
+            // The reading budget's refusal (see `Meter`).
+            Err(tungstenite::Error::Io(e)) if e.kind() == io::ErrorKind::Other => Err(e.to_string()),
+            Err(_) => Ok(None),
+        };
+    }
+}
+
+/// Why a message over `max` bytes is refused.
+fn too_large(max: usize) -> String {
+    match max >> 20 {
+        0 => format!("message too large: this server takes at most {} KiB at once here", max >> 10),
+        mib => format!("message too large: this server takes at most {mib} MiB at once (a change that big can't be kept here)"),
+    }
+}
+
+/// One connection's reader (the writer runs on its own thread).
+fn serve(mut stream: TcpStream, conn: u64, hub: &Sender<HubIn>, limits: NetLimits, open: Open, shared: &Shared) {
+    let _ = stream.set_nodelay(true);
+    let hello_deadline = Instant::now() + limits.hello_timeout;
+    if stream.set_read_timeout(Some(limits.hello_timeout)).is_err() || stream.set_write_timeout(Some(limits.write_timeout)).is_err() {
+        return;
+    }
+    if health_check(&mut stream, Instant::now() + limits.hello_timeout) {
+        return;
+    }
+    let Ok(peer) = stream.peer_addr().map(|a| a.ip().to_canonical()) else { return };
+    let proxied = limits.trusted_proxy.is_some_and(|p| p.to_canonical() == peer);
+    let Ok((mut rd, wr, sock)) = Duplex::split(stream, None) else { return };
+    // The handshake and the hello must be in by the deadline, however slowly they trickle in.
+    rd.read_until(Some(hello_deadline));
+    let cfg = config(limits.max_client_message);
+    let mut forwarded = None;
+    // The handshake callback's type is tungstenite's (its error is an HTTP response).
+    #[allow(clippy::result_large_err)]
+    let read_client = |req: &Request, resp: Response| -> Result<Response, ErrorResponse> {
+        if proxied {
+            forwarded = forwarded_for(req);
+        }
+        Ok(resp)
+    };
+    let mut ws = match tungstenite::accept_hdr_with_config(rd, read_client, Some(config(limits.max_hello))) {
+        Ok(ws) => ws,
+        Err(e) => {
+            log::debug!("live session: handshake failed: {e}");
+            shutdown(&sock);
+            return;
+        }
+    };
+    if proxied && forwarded.is_none() {
+        log::debug!("live session: connection {conn} came through the proxy without X-Forwarded-For");
+    }
+    let ip = ip_key(forwarded.unwrap_or(peer));
+    let counted = shared.per_address.enter_all(ip, limits.max_per_address, limits.max_connections);
+    let wide = wide_block(ip);
+    let block = shared.blocks.get(wide);
+    ws.get_mut().meter(Meter::new(
+        conn,
+        &sock,
+        &shared.readers,
+        block.reading.clone(),
+        shared.reading.clone(),
+        limits.max_reading_block,
+        limits.max_reading_total,
+    ));
+    let (tx, rx) = sync_channel::<Out>(limits.queue.max(4));
+    let out = Line {
+        tx,
+        queued: Arc::default(),
+        block: block.queued.clone(),
+        all: shared.queued.clone(),
+        max: limits.max_queued_bytes,
+        max_block: limits.max_queued_block,
+        max_all: limits.max_queued_total,
+    };
+    let writer =
+        match sock.try_clone().map(|s| spawn("live-write", move || write_loop(WebSocket::from_raw_socket(wr, Role::Server, Some(cfg)), &rx, &s))) {
+            Ok(Ok(t)) => t,
+            _ => {
+                shutdown(&sock);
+                return;
+            }
+        };
+    let end = |why: Option<&str>| {
+        if let Some(why) = why {
+            refuse(&out, why);
+        } else {
+            let _ = out.tx.try_send(Out::Close(CloseCode::Normal, String::new()));
+        }
+    };
+    if counted.is_none() {
+        log::info!("event=refused ip={ip} reason=connections_per_address");
+        end(Some("too many connections from your address: close some and try again"));
+    } else {
+        let hello = next_message(&mut ws, limits.max_hello, Some(hello_deadline));
+        // In time or not, the hello's deadline is over: what's read next has timeouts of its own.
+        ws.get_mut().read_until(None);
+        match hello {
+            Ok(Some((
+                first @ (ClientMsg::Hello(_)
+                | ClientMsg::Manage(_)
+                | ClientMsg::OpenLibrary(_)
+                | ClientMsg::OpenPlugins(_)
+                | ClientMsg::OpenHosting(_)
+                | ClientMsg::Resolve(_)),
+                bytes,
+            ))) => {
+                // Sessions and the operator may use the last connections; one-shot requests
+                // (hosting, libraries, browsing plugins) leave them free.
+                let session = matches!(first, ClientMsg::Hello(_) | ClientMsg::Manage(_));
+                // A publish uploads a whole file; a large one on a slow link takes the server a
+                // while to receive and answer. The manage/hosting connections that carry uploads
+                // wait the longer request-reply timeout, not the short request idle.
+                let idle = match first {
+                    ClientMsg::Manage(_) | ClientMsg::OpenHosting(_) => limits.request_reply_timeout,
+                    ClientMsg::Hello(_) => limits.idle_timeout,
+                    _ => limits.request_idle,
+                };
+                let max = match &first {
+                    ClientMsg::OpenPlugins(o) if o.key.is_empty() => limits.max_request,
+                    _ => limits.max_client_message,
+                };
+                let reserved = !session && open.0.load(Ordering::Relaxed) > limits.max_connections.saturating_sub(limits.reserve_for_sessions);
+                // (In flight is only taken when the connection goes on: the hub gives it back.)
+                if reserved || !shared.in_flight.take(bytes, limits.max_in_flight) {
+                    end(Some(BUSY));
+                } else {
+                    let (admitted, verdict) = sync_channel(1);
+                    let opened =
+                        sock.try_clone().is_ok_and(|s| hub.send(HubIn::Open { conn, ip, first, out: out.clone(), sock: s, bytes, admitted }).is_ok());
+                    // Nothing more is read until the hub took the connection in (its token checked):
+                    // only then may it send messages of the full size.
+                    if opened && verdict.recv().is_ok() && ws.get_ref().set_read_timeout(Some(idle)).is_ok() {
+                        ws.set_config(|c| *c = config(max));
+                        read_loop(&mut ws, conn, hub, limits, max, &shared.in_flight, &end);
+                        let _ = hub.send(HubIn::Gone { conn });
+                    }
+                }
+            }
+            Ok(Some(_)) => end(Some("say hello first")),
+            Ok(None) => {}
+            Err(why) => end(Some(&why)),
+        }
+    }
+    drop(counted);
+    // The block's counters go with the last handle on them (the table forgets it then).
+    drop(block);
+    ws.get_mut().read_until(None);
+    linger(&mut ws);
+    drop(out);
+    // The writer closes the socket once it has sent what's queued (a refusal, a close).
+    let _ = writer.join();
+    shutdown(&sock);
+}
+
+fn read_loop(
+    ws: &mut WebSocket<Duplex>,
+    conn: u64,
+    hub: &Sender<HubIn>,
+    limits: NetLimits,
+    max: usize,
+    in_flight: &InFlight,
+    end: &dyn Fn(Option<&str>),
+) {
+    let mut bucket = Bucket::new(limits.rate, limits.burst);
+    let mut signals = Bucket::new(SIGNAL_RATE, SIGNAL_BURST);
+    loop {
+        match next_message(ws, max, None) {
+            Ok(Some((msg, bytes))) => {
+                let now = Instant::now();
+                if !bucket.take(now) {
+                    log::info!("live session: connection {conn} sends too much; disconnecting it");
+                    return end(Some("too many messages"));
+                }
+                // Typing sends a chat signal per keystroke; more than this is dropped.
+                if matches!(msg, ClientMsg::Signal(_)) && !signals.take(now) {
+                    log::debug!("live session: connection {conn} sends signals too fast; dropping one");
+                    continue;
+                }
+                if !in_flight.take(bytes, limits.max_in_flight) {
+                    log::info!("live session: the hub is behind; dropping connection {conn}");
+                    return end(Some(BUSY));
+                }
+                if hub.send(HubIn::Msg { conn, msg, bytes }).is_err() {
+                    return;
+                }
+            }
+            Ok(None) => return end(None),
+            Err(why) => return end(Some(&why)),
+        }
+    }
+}
+
+fn write_loop(mut ws: WebSocket<Duplex>, rx: &Receiver<Out>, sock: &TcpStream) {
+    let mut close = Some((CloseCode::Normal, String::new()));
+    while let Ok(o) = rx.recv() {
+        match o {
+            Out::Bytes(b, _charge) => {
+                if ws.send(Message::Binary(b)).is_err() {
+                    close = None;
+                    break;
+                }
+            }
+            Out::Close(code, why) => {
+                close = Some((code, why));
+                break;
+            }
+        }
+    }
+    if let Some((code, why)) = close {
+        // Close politely: the close frame, then no more writing; the reader drains what the peer
+        // still sends until it hangs up (closing on unread data would reset the connection and
+        // could lose the close frame), or until the linger runs out.
+        let _ = ws.close(Some(CloseFrame { code, reason: why.into() }));
+        let _ = sock.shutdown(std::net::Shutdown::Write);
+        let until = Instant::now() + LINGER;
+        while let Ok(_) | Err(RecvTimeoutError::Timeout) = rx.recv_timeout(until.saturating_duration_since(Instant::now())) {
+            if Instant::now() >= until {
+                break;
+            }
+        }
+    }
+    shutdown(sock);
+}
+
+/// Read and drop what the peer still sends after the close, until it hangs up (at most
+/// [`LINGER`]). Raw bytes, not frames: after a frame over the size limit the WebSocket's reader
+/// is mid-frame and mustn't be asked for more.
+fn linger(ws: &mut WebSocket<Duplex>) {
+    let until = Instant::now() + LINGER;
+    let mut buf = [0u8; 4096];
+    while Instant::now() < until && ws.get_ref().set_read_timeout(Some(Duration::from_millis(250))).is_ok() {
+        match ws.get_mut().read(&mut buf) {
+            Ok(0) => break,
+            Ok(_) => {}
+            Err(e) if matches!(e.kind(), io::ErrorKind::WouldBlock | io::ErrorKind::TimedOut | io::ErrorKind::Interrupted) => {}
+            Err(_) => break,
+        }
+    }
+}
diff --git a/crates/collab-net/src/hub/hosting.rs b/crates/collab-net/src/hub/hosting.rs
new file mode 100644
index 00000000..8588e56a
--- /dev/null
+++ b/crates/collab-net/src/hub/hosting.rs
@@ -0,0 +1,201 @@
+use super::backend::Backend;
+use super::conn::{Shared, accept};
+use super::limits::{PerAddress, loopback};
+use super::queue::{Blocks, HubIn, InFlight};
+use super::*;
+
+/// The person hosting an app session: in the file's session without a socket.
+pub(crate) struct Local {
+    pub file: String,
+    pub server: Server,
+    /// Their client id (they joined `server` already).
+    pub id: u32,
+    pub inbox: Inbox,
+}
+
+pub(super) fn spawn(name: &str, f: impl FnOnce() + Send + 'static) -> io::Result<JoinHandle<()>> {
+    std::thread::Builder::new().name(name.to_string()).spawn(f)
+}
+
+/// A name others may see: trimmed, no control characters, at most [`MAX_NAME`] characters.
+pub(crate) fn clean_name(s: &str) -> String {
+    s.trim().chars().filter(|c| !c.is_control()).take(MAX_NAME).collect()
+}
+
+/// A running hub: its listener, connections and hub thread. Dropping it stops it.
+pub struct Hosting {
+    addr: SocketAddr,
+    hub: Sender<HubIn>,
+    stop: Arc<AtomicBool>,
+    open: Arc<AtomicUsize>,
+    /// Bytes queued for every connection together, and in flight to the hub.
+    queued: Arc<AtomicUsize>,
+    in_flight: InFlight,
+    blocks: Blocks,
+    reading: Arc<AtomicUsize>,
+    hub_thread: Option<JoinHandle<()>>,
+    accept_thread: Option<JoinHandle<()>>,
+}
+
+impl Hosting {
+    /// Serve `backend`'s files on `listener`.
+    pub fn serve<B: Backend>(listener: TcpListener, backend: B, limits: NetLimits) -> io::Result<Hosting> {
+        Self::start(listener, backend, limits, None)
+    }
+
+    pub(crate) fn start<B: Backend>(listener: TcpListener, backend: B, limits: NetLimits, local: Option<Local>) -> io::Result<Hosting> {
+        let addr = listener.local_addr()?;
+        let in_flight = InFlight(Arc::default());
+        let mut hub = Hub {
+            backend,
+            rooms: HashMap::new(),
+            conns: HashMap::new(),
+            local: None,
+            outbox: Vec::new(),
+            in_flight: in_flight.clone(),
+            barred: HashMap::new(),
+        };
+        if let Some(l) = local {
+            let mut room = Room::new(l.server);
+            room.local = Some((l.id, l.inbox));
+            hub.rooms.insert(l.file.clone(), room);
+            hub.local = Some(l.file);
+        }
+        let (hub_tx, hub_rx) = channel();
+        let stop = Arc::new(AtomicBool::new(false));
+        let open = Arc::new(AtomicUsize::new(0));
+        let hub_thread = spawn("live-hub", move || hub.run(&hub_rx))?;
+        let shared = Shared {
+            per_address: PerAddress::default(),
+            queued: Arc::default(),
+            in_flight: in_flight.clone(),
+            blocks: Blocks::default(),
+            reading: Arc::default(),
+            readers: Readers::default(),
+        };
+        let queued = shared.queued.clone();
+        let blocks = shared.blocks.clone();
+        let reading = shared.reading.clone();
+        let accept_thread = {
+            let (hub_tx, stop, open) = (hub_tx.clone(), stop.clone(), open.clone());
+            spawn("live-accept", move || accept(&listener, &hub_tx, &stop, &open, limits, shared))
+        };
+        let accept_thread = match accept_thread {
+            Ok(t) => t,
+            Err(e) => {
+                let _ = hub_tx.send(HubIn::Stop);
+                let _ = hub_thread.join();
+                return Err(e);
+            }
+        };
+        log::info!("live session: listening on {addr}");
+        Ok(Hosting {
+            addr,
+            hub: hub_tx,
+            stop,
+            open,
+            queued,
+            in_flight,
+            blocks,
+            reading,
+            hub_thread: Some(hub_thread),
+            accept_thread: Some(accept_thread),
+        })
+    }
+
+    /// Bytes waiting to be sent to clients, all connections together.
+    pub fn queued_bytes(&self) -> usize {
+        self.queued.load(Ordering::Relaxed)
+    }
+
+    /// Blocks of addresses the server keeps counters for (those of open connections, and any
+    /// whose last connection just ended, until the next connection prunes them).
+    pub fn blocks_remembered(&self) -> usize {
+        self.blocks.len()
+    }
+
+    /// Bytes being read into messages not whole yet, all connections together.
+    pub fn reading_bytes(&self) -> usize {
+        self.reading.load(Ordering::Relaxed)
+    }
+
+    /// Bytes of messages read and not handled by the hub yet.
+    pub fn in_flight_bytes(&self) -> usize {
+        self.in_flight.0.load(Ordering::Relaxed)
+    }
+
+    /// Where it listens.
+    pub fn addr(&self) -> SocketAddr {
+        self.addr
+    }
+
+    /// Open connections (joined or not).
+    pub fn connections(&self) -> usize {
+        self.open.load(Ordering::Relaxed)
+    }
+
+    /// The hosting person's presence (app sessions).
+    pub(crate) fn presence(&self, p: Presence) {
+        let _ = self.hub.send(HubIn::Local(p));
+    }
+
+    /// A message from the hosting person's sync client (their edits).
+    pub(crate) fn send(&self, msg: ClientMsg) {
+        let _ = self.hub.send(HubIn::LocalMsg(msg));
+    }
+
+    /// The hosting person removes client `id` from their file (app sessions; see
+    /// [`HubIn::Remove`]).
+    pub(crate) fn remove(&self, id: u32) {
+        let _ = self.hub.send(HubIn::Remove(id));
+    }
+
+    /// Cut every connection as a network failure would (no close frame).
+    #[cfg(test)]
+    pub(crate) fn cut_connections(&self) {
+        let _ = self.hub.send(HubIn::Cut);
+    }
+
+    /// Stop: the backend saves what's open, everyone is told and disconnected, the port is
+    /// released.
+    pub fn stop(&mut self) {
+        if self.stop.swap(true, Ordering::SeqCst) {
+            return;
+        }
+        let _ = self.hub.send(HubIn::Stop);
+        if let Some(t) = self.hub_thread.take() {
+            let _ = t.join();
+        }
+        // The accept loop checks the flag after each connection: wake it with one.
+        let wake = if self.addr.ip().is_unspecified() { SocketAddr::new(loopback(self.addr), self.addr.port()) } else { self.addr };
+        let woke = TcpStream::connect_timeout(&wake, Duration::from_secs(1)).is_ok();
+        if let Some(t) = self.accept_thread.take() {
+            if woke {
+                let _ = t.join();
+            } else {
+                log::warn!("live session: couldn't wake the accept loop; it ends with the next connection");
+            }
+        }
+        // Readers end once their writers have closed the sockets.
+        let deadline = Instant::now() + Duration::from_secs(2);
+        while self.open.load(Ordering::Relaxed) > 0 && Instant::now() < deadline {
+            std::thread::sleep(Duration::from_millis(5));
+        }
+        log::info!("live session: stopped listening on {}", self.addr);
+    }
+}
+
+impl Drop for Hosting {
+    fn drop(&mut self) {
+        self.stop();
+    }
+}
+
+/// Counts an open connection until dropped.
+pub(super) struct Open(pub(super) Arc<AtomicUsize>);
+
+impl Drop for Open {
+    fn drop(&mut self) {
+        self.0.fetch_sub(1, Ordering::Relaxed);
+    }
+}
diff --git a/crates/collab-net/src/hub/limits.rs b/crates/collab-net/src/hub/limits.rs
new file mode 100644
index 00000000..333ff165
--- /dev/null
+++ b/crates/collab-net/src/hub/limits.rs
@@ -0,0 +1,99 @@
+use super::*;
+
+/// What a link lets a hello do.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Admission {
+    pub access: Access,
+    /// The link's id, when the backend has several per file (revoking it disconnects whoever
+    /// joined with it).
+    pub link: Option<String>,
+}
+
+/// The address limits and blocks count a client by: its IPv4 address (an IPv4-mapped IPv6 address
+/// as IPv4), or its IPv6 address's /64 (one subscriber's block: they have billions of addresses).
+pub fn ip_key(ip: IpAddr) -> IpAddr {
+    match ip.to_canonical() {
+        IpAddr::V6(v6) => {
+            let [a, b, c, d, ..] = v6.segments();
+            IpAddr::V6(Ipv6Addr::new(a, b, c, d, 0, 0, 0, 0))
+        }
+        v4 => v4,
+    }
+}
+
+/// The loopback address of `addr`'s family.
+pub(super) fn loopback(addr: SocketAddr) -> std::net::IpAddr {
+    if addr.is_ipv6() { std::net::Ipv6Addr::LOCALHOST.into() } else { std::net::Ipv4Addr::LOCALHOST.into() }
+}
+
+/// A block of addresses: its first address and its prefix length (2001:db8:: as a /64 and as a
+/// /48 are different blocks).
+pub type Block = (IpAddr, u8);
+
+/// The blocks a client's address ([`ip_key`]) counts in, with how many times its own limits each
+/// gets: the address itself (an IPv4 /32 or an IPv6 /64, ×1) and, for IPv6, its /56 (×2) and /48
+/// (×4), so a tunnel's free /48 doesn't multiply the limits 65,536 times.
+pub fn ip_blocks(key: IpAddr) -> Vec<(Block, u32)> {
+    let IpAddr::V6(v6) = key else { return vec![((key, 32), 1)] };
+    let [a, b, c, d, ..] = v6.segments();
+    vec![
+        ((IpAddr::V6(Ipv6Addr::new(a, b, c, d, 0, 0, 0, 0)), 64), 1),
+        ((IpAddr::V6(Ipv6Addr::new(a, b, c, d & 0xff00, 0, 0, 0, 0)), 56), 2),
+        ((IpAddr::V6(Ipv6Addr::new(a, b, c, 0, 0, 0, 0, 0)), 48), 4),
+    ]
+}
+
+/// Open connections per client address ([`ip_key`], and its wider IPv6 blocks); an address
+/// leaves when its last one closes, so the table never holds more than the open connections.
+#[derive(Clone, Default)]
+pub(super) struct PerAddress(pub(super) Arc<Mutex<HashMap<Block, usize>>>);
+
+/// One connection counted for a block until dropped.
+pub(super) struct Counted {
+    table: PerAddress,
+    ip: Block,
+}
+
+impl PerAddress {
+    /// Count a connection from block `ip`, unless it has `cap` already (0: no cap).
+    fn enter(&self, ip: Block, cap: usize) -> Option<Counted> {
+        let mut t = self.0.lock().unwrap_or_else(PoisonError::into_inner);
+        let n = t.entry(ip).or_insert(0);
+        if cap > 0 && *n >= cap {
+            if *n == 0 {
+                t.remove(&ip);
+            }
+            return None;
+        }
+        *n += 1;
+        Some(Counted { table: self.clone(), ip })
+    }
+
+    /// Count a connection from `ip` in each of its blocks, unless one of them is full. A wider
+    /// block's cap is its multiple of `cap`, but at most a sixteenth (/56) or an eighth (/48) of
+    /// `all` connections, so no block takes every connection.
+    pub(super) fn enter_all(&self, ip: IpAddr, cap: usize, all: usize) -> Option<Vec<Counted>> {
+        let mut held = Vec::new();
+        for ((addr, prefix), times) in ip_blocks(ip) {
+            let block_cap = match prefix {
+                56 => cap.saturating_mul(times as usize).min(all / 16).max(1),
+                48 => cap.saturating_mul(times as usize).min(all / 8).max(1),
+                _ => cap,
+            };
+            held.push(self.enter((addr, prefix), if cap == 0 { 0 } else { block_cap })?);
+        }
+        Some(held)
+    }
+}
+
+impl Drop for Counted {
+    fn drop(&mut self) {
+        let mut t = self.table.0.lock().unwrap_or_else(PoisonError::into_inner);
+        if let Some(n) = t.get_mut(&self.ip) {
+            *n = n.saturating_sub(1);
+            if *n == 0 {
+                t.remove(&self.ip);
+            }
+        }
+    }
+}
diff --git a/crates/collab-net/src/hub/queue.rs b/crates/collab-net/src/hub/queue.rs
new file mode 100644
index 00000000..b6bce39e
--- /dev/null
+++ b/crates/collab-net/src/hub/queue.rs
@@ -0,0 +1,210 @@
+use super::limits::ip_blocks;
+use super::*;
+
+/// A message for one connection's writer: bytes (with what they count against, released when
+/// they are sent or dropped), or the close.
+pub(crate) enum Out {
+    Bytes(Bytes, Option<Charge>),
+    Close(CloseCode, String),
+}
+
+/// One message's bytes held for one or more connections (a broadcast shares one buffer), counted
+/// once against a shared counter (the server's, or a block's) until the last copy is sent or
+/// dropped.
+pub(super) struct Held {
+    n: usize,
+    counter: Arc<AtomicUsize>,
+}
+
+impl Held {
+    fn new(n: usize, counter: &Arc<AtomicUsize>) -> Arc<Held> {
+        counter.fetch_add(n, Ordering::Relaxed);
+        Arc::new(Held { n, counter: counter.clone() })
+    }
+}
+
+impl Drop for Held {
+    fn drop(&mut self) {
+        self.counter.fetch_sub(self.n, Ordering::Relaxed);
+    }
+}
+
+/// What one message counts against, made by its first recipient and shared by the others: the
+/// server's budget once, and each recipient block's once (twenty people behind one office's
+/// address cost their block one copy of a broadcast, not twenty).
+#[derive(Default)]
+pub(crate) struct Charges {
+    pub(super) all: Option<Arc<Held>>,
+    pub(super) blocks: Vec<(usize, Arc<Held>)>,
+    /// Count it against blocks at all: a welcome isn't (it is bounded by the file's size and each
+    /// connection's cap, and a whole office joining at once must fit).
+    pub(crate) skip_blocks: bool,
+}
+
+/// Bytes waiting in a connection's queue, counted against its cap until dropped (and, through
+/// [`Held`], once against the server's budget and once against its block's).
+pub(super) struct Charge {
+    n: usize,
+    mine: Arc<AtomicUsize>,
+    _all: Arc<Held>,
+    _block: Option<Arc<Held>>,
+}
+
+impl Drop for Charge {
+    fn drop(&mut self) {
+        self.mine.fetch_sub(self.n, Ordering::Relaxed);
+    }
+}
+
+/// Why a message couldn't be queued.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum Push {
+    /// The connection's or its block's queue is full: it can't keep up.
+    Full,
+    /// The server's budget for queued bytes is used up.
+    Everyone,
+    /// The connection is gone.
+    Gone,
+}
+
+/// One connection's way out: its writer's queue, capped in messages and in bytes (its own, its
+/// block of addresses', and the server's for everyone), so a client that doesn't read can't make
+/// the server hold more than that for it.
+#[derive(Clone)]
+pub(crate) struct Line {
+    pub(crate) tx: SyncSender<Out>,
+    pub(crate) queued: Arc<AtomicUsize>,
+    pub(crate) block: Arc<AtomicUsize>,
+    pub(crate) all: Arc<AtomicUsize>,
+    pub(crate) max: usize,
+    pub(crate) max_block: usize,
+    pub(crate) max_all: usize,
+}
+
+impl Line {
+    /// Queue `b`. One message always fits an empty queue (a welcome as large as the largest file
+    /// gets out). `charges` is what the message counts against, shared by its recipients;
+    /// `over_budget` lets it past the server's budget (the hub just dropped the biggest consumer
+    /// to make room).
+    pub(crate) fn push(&self, b: &Bytes, charges: &mut Charges, over_budget: bool) -> Result<(), Push> {
+        let n = b.len();
+        let mine = self.queued.load(Ordering::Relaxed);
+        if mine > 0 && mine.saturating_add(n) > self.max {
+            return Err(Push::Full);
+        }
+        let key = Arc::as_ptr(&self.block) as usize;
+        let block = if charges.skip_blocks {
+            None
+        } else if let Some((_, h)) = charges.blocks.iter().find(|(k, _)| *k == key) {
+            Some(h.clone())
+        } else {
+            let used = self.block.load(Ordering::Relaxed);
+            if used > 0 && used.saturating_add(n) > self.max_block {
+                return Err(Push::Full);
+            }
+            let h = Held::new(n, &self.block);
+            charges.blocks.push((key, h.clone()));
+            Some(h)
+        };
+        let all = match &charges.all {
+            Some(h) => h.clone(),
+            None => {
+                if !over_budget && self.all.load(Ordering::Relaxed).saturating_add(n) > self.max_all {
+                    return Err(Push::Everyone);
+                }
+                charges.all.insert(Held::new(n, &self.all)).clone()
+            }
+        };
+        self.queued.fetch_add(n, Ordering::Relaxed);
+        let charge = Charge { n, mine: self.queued.clone(), _all: all, _block: block };
+        self.tx.try_send(Out::Bytes(b.clone(), Some(charge))).map_err(|e| match e {
+            TrySendError::Full(_) => Push::Full,
+            TrySendError::Disconnected(_) => Push::Gone,
+        })
+    }
+}
+
+/// What one block of addresses (an IPv4 address, an IPv6 /48: [`wide_block`]) has queued and is
+/// having read, shared by its connections.
+#[derive(Clone, Default)]
+pub(crate) struct BlockUse {
+    pub(super) queued: Arc<AtomicUsize>,
+    pub(super) reading: Arc<AtomicUsize>,
+}
+
+/// The blocks with open connections; a block leaves when its last connection ends.
+#[derive(Clone, Default)]
+pub(crate) struct Blocks(pub(crate) Arc<Mutex<HashMap<IpAddr, BlockUse>>>);
+
+impl Blocks {
+    /// Block `key`'s counters; blocks nobody uses any more (only the table holds their counters,
+    /// whose connections' queues and readers are all gone) are forgotten first, so the table
+    /// never holds more than the blocks of open connections.
+    pub(crate) fn get(&self, key: IpAddr) -> BlockUse {
+        let mut t = self.0.lock().unwrap_or_else(PoisonError::into_inner);
+        t.retain(|_, u| Arc::strong_count(&u.queued) > 1 || Arc::strong_count(&u.reading) > 1);
+        t.entry(key).or_default().clone()
+    }
+
+    /// Blocks remembered.
+    pub(crate) fn len(&self) -> usize {
+        self.0.lock().unwrap_or_else(PoisonError::into_inner).len()
+    }
+}
+
+/// The widest block an address counts in for the server's shared budgets: an IPv4 address, or an
+/// IPv6 address's /48.
+pub fn wide_block(key: IpAddr) -> IpAddr {
+    ip_blocks(key).last().map_or(key, |(b, _)| b.0)
+}
+
+/// Messages handed to the hub thread and not handled yet, in bytes: past the budget a reader
+/// drops its connection instead of piling more on a busy hub.
+#[derive(Clone)]
+pub(crate) struct InFlight(pub(crate) Arc<AtomicUsize>);
+
+impl InFlight {
+    pub(super) fn take(&self, n: usize, max: usize) -> bool {
+        if self.0.fetch_add(n, Ordering::Relaxed).saturating_add(n) > max {
+            self.0.fetch_sub(n, Ordering::Relaxed);
+            return false;
+        }
+        true
+    }
+
+    pub(super) fn give(&self, n: usize) {
+        self.0.fetch_sub(n, Ordering::Relaxed);
+    }
+}
+
+pub(super) enum HubIn {
+    /// A connection's first message (`Hello`, `Manage`, `OpenLibrary`, `OpenPlugins`,
+    /// `OpenHosting` or `Resolve`) and its client's address ([`ip_key`]).
+    Open {
+        conn: u64,
+        ip: IpAddr,
+        first: ClientMsg,
+        out: Line,
+        sock: TcpStream,
+        /// Its size (in flight until handled).
+        bytes: usize,
+        /// Told when the hub takes the connection in (dropped unsent when it doesn't).
+        admitted: SyncSender<()>,
+    },
+    Msg {
+        conn: u64,
+        msg: ClientMsg,
+        bytes: usize,
+    },
+    Gone {
+        conn: u64,
+    },
+    Local(Presence),
+    LocalMsg(ClientMsg),
+    /// The person hosting removes client `id` from their file (app sessions).
+    Remove(u32),
+    /// Cut every connection without a word (tests: a network failure).
+    #[cfg(test)]
+    Cut,
+    Stop,
+}

From 3102bffc90a034580672c403652210f32dc06f08 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:03:41 +0000
Subject: [PATCH 50/67] refactor(server): split store.rs into store/

---
 apps/figcraft-server/src/store.rs         | 1121 +--------------------
 apps/figcraft-server/src/store/backend.rs |  242 +++++
 apps/figcraft-server/src/store/files.rs   |  300 ++++++
 apps/figcraft-server/src/store/journal.rs |  270 +++++
 apps/figcraft-server/src/store/library.rs |  161 +++
 apps/figcraft-server/src/store/links.rs   |  154 +++
 6 files changed, 1135 insertions(+), 1113 deletions(-)
 create mode 100644 apps/figcraft-server/src/store/backend.rs
 create mode 100644 apps/figcraft-server/src/store/files.rs
 create mode 100644 apps/figcraft-server/src/store/journal.rs
 create mode 100644 apps/figcraft-server/src/store/library.rs
 create mode 100644 apps/figcraft-server/src/store/links.rs

diff --git a/apps/figcraft-server/src/store.rs b/apps/figcraft-server/src/store.rs
index 1ea420a5..90fce92b 100644
--- a/apps/figcraft-server/src/store.rs
+++ b/apps/figcraft-server/src/store.rs
@@ -52,6 +52,14 @@ use crate::codes::{self, Sealed};
 use crate::directory::{Directory, DirectoryConfig};
 use crate::disk::{self, LIBRARY, LINKS, LOG, LOG_HEADER, META, SNAPSHOT, USAGE};
 
+mod backend;
+mod files;
+mod journal;
+mod library;
+mod links;
+
+pub use library::library_name;
+
 pub const LOCK: &str = "LOCK";
 pub const KEY: &str = "server.key";
 pub const FILES: &str = "files";
@@ -541,847 +549,6 @@ impl Store {
             people: open.map_or(0, |o| o.people),
         }
     }
-
-    /// Keep a document (its snapshot) as a new file with an edit link and a view link.
-    pub fn publish(&mut self, name: &str, snapshot: &[Change]) -> Result<(FileInfo, NewLink, NewLink), String> {
-        self.keep(name, snapshot, None, &|_| Ok(())).map(|(info, edit, view, _)| (info, edit, view))
-    }
-
-    /// For each block the address `ip` counts in ([`ip_blocks`]), how many times one address's
-    /// caps it gets, and the files and bytes kept by the files published from addresses in it. An
-    /// address that doesn't parse counts as itself only, ×1, by its exact text.
-    fn per_block(&self, ip: &str) -> Vec<(u32, usize, u64)> {
-        let blocks_of = |text: &str| text.parse::<IpAddr>().map(|a| ip_blocks(ip_key(a))).unwrap_or_default();
-        let kept: Vec<(&str, Vec<_>, u64)> = self
-            .files
-            .iter()
-            .filter_map(|(id, e)| {
-                let from = e.meta.ip.as_deref()?;
-                Some((from, blocks_of(from).into_iter().map(|(b, _)| b).collect(), self.bytes(id)))
-            })
-            .collect();
-        let sum = |mine: &mut dyn Iterator<Item = &(&str, Vec<_>, u64)>| mine.fold((0, 0u64), |(f, b), (_, _, n)| (f + 1, b.saturating_add(*n)));
-        let blocks = blocks_of(ip);
-        if blocks.is_empty() {
-            let (files, bytes) = sum(&mut kept.iter().filter(|(from, _, _)| *from == ip));
-            return vec![(1, files, bytes)];
-        }
-        blocks
-            .into_iter()
-            .map(|(block, times)| {
-                let (files, bytes) = sum(&mut kept.iter().filter(|(_, blocks, _)| blocks.contains(&block)));
-                (times, files, bytes)
-            })
-            .collect()
-    }
-
-    /// Keep a document published without the key from `ip`, within the caps on what one address
-    /// and everyone may keep: the file, its links and its owner token.
-    pub fn publish_open(&mut self, ip: IpAddr, name: &str, snapshot: &[Change]) -> Result<(FileInfo, NewLink, NewLink, String), String> {
-        let h = &self.cfg.hosting;
-        let (open, max_files, max_ip, max_all) = (h.open, h.max_files_per_ip, h.max_bytes_per_ip, h.max_total_bytes);
-        if !open {
-            return Err(KEY_ONLY.into());
-        }
-        if !self.abuse.allow(ip, Action::Publish, Instant::now()) {
-            return Err("too many files published from your address lately: try again in an hour".into());
-        }
-        let blocks = self.per_block(&ip.to_string());
-        for &(times, files, _) in &blocks {
-            if files >= max_files.saturating_mul(times as usize) {
-                return Err(format!(
-                    "your address keeps {files} files on this server already, the most it may: remove one (with its owner token) or wait until one expires"
-                ));
-            }
-        }
-        let used_all: u64 = self.files.keys().map(|id| self.bytes(id)).sum();
-        let fits = |n: u64| {
-            for &(times, _, used) in &blocks {
-                let cap = max_ip.saturating_mul(u64::from(times));
-                if used.saturating_add(n) > cap {
-                    return Err(format!("your address's files would take more than the {} MiB it may keep here: remove one first", cap >> 20));
-                }
-            }
-            if used_all.saturating_add(n) > max_all {
-                return Err("this server is full: it takes no more files for now (try again later, or another server)".into());
-            }
-            Ok(())
-        };
-        let (info, edit, view, owner) = self.keep(name, snapshot, Some(ip), &fits)?;
-        Ok((info, edit, view, owner.unwrap_or_default()))
-    }
-
-    /// Keep a document as a new file: published without the key from `ip` (it gets an owner
-    /// token), else by the operator. `fits` checks its size against the caps that apply.
-    fn keep(
-        &mut self,
-        name: &str,
-        snapshot: &[Change],
-        ip: Option<IpAddr>,
-        fits: &dyn Fn(u64) -> Result<(), String>,
-    ) -> Result<(FileInfo, NewLink, NewLink, Option<String>), String> {
-        if self.files.len() >= self.cfg.max_files {
-            return Err(format!("the server keeps at most {} files", self.cfg.max_files));
-        }
-        if let Some(why) = self.low_disk() {
-            return Err(why);
-        }
-        let replica = Replica::from_snapshot(snapshot).map_err(|e| format!("the file couldn't be read: {e}"))?;
-        if replica.document().node_count() > self.cfg.core.max_nodes {
-            return Err(format!("the file has more than {} layers", self.cfg.core.max_nodes));
-        }
-        let mut doc = replica.document().clone();
-        let name = match clean_name(name) {
-            n if n.is_empty() => doc.name.clone(),
-            n => n,
-        };
-        doc.name = name.clone();
-        let server = Server::new(doc, "", self.cfg.core);
-        let state = server.state().map_err(|e| e.to_string())?;
-        let bytes = disk::encode_snapshot(1, &state)?;
-        if bytes.len() as u64 > self.cfg.max_file_bytes {
-            return Err(format!("the file is {} MiB; this server keeps files up to {} MiB", bytes.len() >> 20, self.cfg.max_file_bytes >> 20));
-        }
-        fits(bytes.len() as u64)?;
-        let id = loop {
-            let id = token::file_id()?;
-            if !self.files.contains_key(&id) && !self.dir(&id).exists() {
-                break id;
-            }
-        };
-        let t = now();
-        let (edit, edit_token) = new_link(Access::Edit, "Published (edit)", t)?;
-        let (view, view_token) = new_link(Access::View, "Published (view)", t)?;
-        let owner = ip.map(|_| token::secret()).transpose()?;
-        let meta =
-            Meta { name, created: t, updated: t, seq: 0, library: None, owner: owner.as_deref().map(hash), ip: ip.map(|i| i.to_string()), opened: 0 };
-        let dir = self.dir(&id);
-        let written = fs::create_dir_all(&dir)
-            .map_err(|e| e.to_string())
-            .and_then(|()| {
-                disk::sync_dir(Some(&self.root.join(FILES)));
-                disk::write_atomic(&dir.join(SNAPSHOT), &bytes).map_err(|e| e.to_string())
-            })
-            .and_then(|()| disk::write_atomic(&dir.join(LOG), &disk::log_header(1)).map_err(|e| e.to_string()))
-            .and_then(|()| write_json(&dir.join(LINKS), &[edit.clone(), view.clone()]))
-            // Last: a folder without its description is an upload cut short.
-            .and_then(|()| write_json(&dir.join(META), &meta));
-        if let Err(e) = written {
-            let _ = fs::remove_dir_all(&dir);
-            return Err(format!("couldn't keep the file: {e}"));
-        }
-        let entry = Entry { meta, links: vec![edit.clone(), view.clone()], log: None, bytes: (bytes.len() + LOG_HEADER) as u64, forced: 0 };
-        self.files.insert(id.clone(), entry);
-        let info = self.files.get(&id).map(|e| self.info(&id, e, None)).ok_or("the file vanished")?;
-        match ip {
-            Some(ip) => log::info!("event=published file={id} bytes={} ip={ip} by=public", bytes.len()),
-            None => log::info!("event=published file={id} bytes={} by=key", bytes.len()),
-        }
-        Ok((info, NewLink { link: edit.info(&id), token: edit_token }, NewLink { link: view.info(&id), token: view_token }, owner))
-    }
-
-    /// The files kept, with what the operator moderates by.
-    pub fn listing(&self, open: &dyn Fn(&str) -> Option<OpenFile>) -> Vec<FileRow> {
-        self.files
-            .iter()
-            .map(|(id, e)| FileRow {
-                info: self.info(id, e, open(id)),
-                opened: e.meta.opened,
-                expires: self.expires(&e.meta),
-                open: e.meta.owner.is_some(),
-                ip: e.meta.ip.clone().unwrap_or_default(),
-                reports: u32::try_from(self.reports.iter().filter(|r| r.file == *id).count()).unwrap_or(u32::MAX),
-            })
-            .collect()
-    }
-
-    /// Owner token `owner` manages file `file` (one published without the key).
-    fn owns(&self, file: &str, owner: &str) -> bool {
-        let presented = hash(owner);
-        self.files.get(file).and_then(|e| e.meta.owner.as_deref()).is_some_and(|h| same_secret(&presented, h))
-    }
-
-    /// What became of the files these `(file id, owner token)` pairs own: each one's name, links
-    /// and expiry, or `None` when that token manages no file of that id here (which doesn't say
-    /// whether the id exists). Asking opens nothing: it doesn't count as using a file.
-    pub fn owned(&self, files: &[(String, String)]) -> AdminReply {
-        if files.len() > MAX_OWNED {
-            return AdminReply::Failed { reason: format!("ask about at most {MAX_OWNED} files at a time") };
-        }
-        let one = |(file, owner): &(String, String)| {
-            let e = self.files.get(file).filter(|_| self.owns(file, owner))?;
-            Some(OwnedFile { name: e.meta.name.clone(), links: e.links.iter().map(|l| l.id.clone()).collect(), expires: self.expires(&e.meta) })
-        };
-        AdminReply::Owned(files.iter().map(one).collect())
-    }
-
-    /// Rename a file (its listing; the document inside keeps its own name).
-    pub fn rename(&mut self, file: &str, name: &str) -> Result<(), String> {
-        let name = clean_name(name);
-        if name.is_empty() {
-            return Err("give the file a name".into());
-        }
-        let path = self.dir(file).join(META);
-        let entry = self.entry(file)?;
-        let before = std::mem::replace(&mut entry.meta.name, name);
-        if let Err(e) = write_json(&path, &entry.meta) {
-            entry.meta.name = before;
-            return Err(format!("couldn't rename the file: {e}"));
-        }
-        Ok(())
-    }
-
-    /// Delete the files published without the key that nobody opened for the idle time (not
-    /// those open now); their ids.
-    pub fn sweep(&mut self) -> Vec<String> {
-        let t = now();
-        self.next_sweep = t.saturating_add(SWEEP_EVERY);
-        let due: Vec<String> =
-            self.files.iter().filter(|(_, e)| e.log.is_none() && self.expires(&e.meta).is_some_and(|x| x <= t)).map(|(id, _)| id.clone()).collect();
-        for id in &due {
-            match self.remove(id) {
-                Ok(()) => log::info!("event=expired file={id}"),
-                Err(e) => log::warn!("event=expire_failed file={id} reason={e:?}"),
-            }
-        }
-        due
-    }
-
-    /// Make a file look unused for `secs` more (tests: expiry without waiting).
-    #[cfg(test)]
-    pub fn age(&mut self, file: &str, secs: u64) {
-        let path = self.dir(file).join(META);
-        if let Some(e) = self.files.get_mut(file) {
-            let m = &mut e.meta;
-            (m.created, m.updated, m.opened) = (m.created.saturating_sub(secs), m.updated.saturating_sub(secs), m.opened.saturating_sub(secs));
-            let _ = write_json(&path, m);
-        }
-    }
-
-    /// Make an open file's log refuse writes (tests: a full or failing disk).
-    #[cfg(test)]
-    pub fn break_log(&mut self, file: &str) {
-        let path = self.dir(file).join(LOG);
-        if let Some(log) = self.files.get_mut(file).and_then(|e| e.log.as_mut())
-            && let Ok(f) = File::open(path)
-        {
-            log.file = f;
-        }
-    }
-
-    /// Note that a file was opened now (it is used: it doesn't expire).
-    fn touch(&mut self, file: &str) {
-        let path = self.dir(file).join(META);
-        if let Some(e) = self.files.get_mut(file) {
-            e.meta.opened = now();
-            if let Err(err) = write_json(&path, &e.meta) {
-                log::warn!("file {file}: couldn't update {META}: {err}");
-            }
-        }
-    }
-
-    /// What the server says about its hosting (with `file`'s expiry).
-    fn host_info(&self, file: Option<&str>) -> HostInfo {
-        let h = &self.cfg.hosting;
-        let expires = file.and_then(|f| self.files.get(f)).and_then(|e| self.expires(&e.meta));
-        HostInfo { open: h.open, operator: h.operator.clone(), terms: h.terms.clone(), idle_secs: h.idle_secs, max_file_mb: h.max_file_mb, expires }
-    }
-
-    /// Block or unblock an address (an IPv6 address: its /64); the address as kept.
-    pub fn block(&mut self, ip: &str, on: bool) -> Result<IpAddr, String> {
-        let ip = ip_key(ip.trim().parse::<IpAddr>().map_err(|_| format!("`{}` isn't an IP address", ip.trim()))?);
-        if on && !self.blocked.contains(&ip) && self.blocked.len() >= MAX_BLOCKED {
-            return Err(format!("at most {MAX_BLOCKED} addresses can be blocked"));
-        }
-        let changed = if on { self.blocked.insert(ip) } else { self.blocked.remove(&ip) };
-        if changed {
-            let list: Vec<String> = self.blocked.iter().map(IpAddr::to_string).collect();
-            write_json(&self.root.join(BLOCKED), &list).map_err(|e| format!("couldn't keep the blocked addresses: {e}"))?;
-            log::info!("event={} ip={ip}", if on { "blocked" } else { "unblocked" });
-        }
-        Ok(ip)
-    }
-
-    /// The blocked addresses.
-    pub fn blocked(&self) -> Vec<String> {
-        self.blocked.iter().map(IpAddr::to_string).collect()
-    }
-
-    /// The reports kept, oldest first.
-    pub fn reports(&self) -> &[ReportInfo] {
-        &self.reports
-    }
-
-    /// Keep a report about `file` (from someone who joined it with `link`, at `ip`).
-    pub fn keep_report(&mut self, file: &str, link: Option<&str>, ip: IpAddr, reason: &str) -> Result<(), String> {
-        let reason = clean_reason(reason);
-        if reason.is_empty() {
-            return Err("say what is wrong with the file".into());
-        }
-        let name = self.entry(file)?.meta.name.clone();
-        if !self.abuse.allow(ip, Action::Report, Instant::now()) {
-            return Err("too many reports from your address lately: try again in an hour".into());
-        }
-        self.reports.push(ReportInfo {
-            at: now(),
-            file: file.to_string(),
-            name,
-            link: link.unwrap_or_default().to_string(),
-            ip: ip.to_string(),
-            reason,
-        });
-        if self.reports.len() > MAX_REPORTS {
-            let extra = self.reports.len() - MAX_REPORTS;
-            self.reports.drain(..extra);
-        }
-        write_json(&self.root.join(REPORTS), &self.reports).map_err(|e| format!("couldn't keep the report: {e}"))?;
-        log::info!("event=report file={file} ip={ip}");
-        Ok(())
-    }
-
-    /// The files kept.
-    pub fn list(&self, open: &dyn Fn(&str) -> Option<OpenFile>) -> Vec<FileInfo> {
-        self.files.iter().map(|(id, e)| self.info(id, e, open(id))).collect()
-    }
-
-    /// A file's links.
-    pub fn links(&mut self, file: &str) -> Result<Vec<LinkInfo>, String> {
-        Ok(self.entry(file)?.links.iter().map(|l| l.info(file)).collect())
-    }
-
-    /// A new link to a file.
-    pub fn create_link(&mut self, file: &str, access: Access, label: &str) -> Result<NewLink, String> {
-        let max = self.cfg.max_links;
-        let path = self.dir(file).join(LINKS);
-        let entry = self.entry(file)?;
-        if entry.links.len() >= max {
-            return Err(format!("a file has at most {max} links: revoke one first"));
-        }
-        let (link, token) = new_link(access, &clean_name(label), now())?;
-        entry.links.push(link.clone());
-        if let Err(e) = write_json(&path, &entry.links) {
-            entry.links.pop();
-            return Err(format!("couldn't keep the link: {e}"));
-        }
-        Ok(NewLink { link: link.info(file), token })
-    }
-
-    /// The link of `entry` whose token `token` is (every link is compared, in constant time, so
-    /// timing doesn't tell which one matched).
-    fn link_of(entry: &Entry, token: &str) -> Option<usize> {
-        let presented = hash(token);
-        let mut found = None;
-        for (i, l) in entry.links.iter().enumerate() {
-            if same_secret(&presented, &l.hash) {
-                found = Some(i);
-            }
-        }
-        found
-    }
-
-    /// These join codes no longer open anything: typing one says so.
-    fn forget_codes(&mut self, codes: impl IntoIterator<Item = Sealed>) {
-        self.gone_codes.extend(codes.into_iter().map(|c| c.hash));
-        let extra = self.gone_codes.len().saturating_sub(MAX_GONE_CODES);
-        self.gone_codes.drain(..extra);
-    }
-
-    /// Where the link with the join code `key` is: its file, its place among the file's links
-    /// and its token (every code is compared, so timing doesn't tell which one matched).
-    fn find_code(&self, key: &codes::Key) -> Option<(String, usize, String)> {
-        let mut found = None;
-        for (id, e) in &self.files {
-            for (i, l) in e.links.iter().enumerate() {
-                if let Some(token) = l.code.as_ref().and_then(|c| key.open(c)) {
-                    found = Some((id.clone(), i, token));
-                }
-            }
-        }
-        found
-    }
-
-    /// A new join code for the link of `file` whose token is `token` (it takes the place of the
-    /// link's earlier code): the code, shown this once.
-    pub fn set_code(&mut self, file: &str, token: &str) -> Result<String, String> {
-        let at = Self::link_of(self.entry(file)?, token).ok_or("that token isn't one of this file's links (it may have been revoked)")?;
-        // 45 random bits: one already in use is all but impossible, and never handed out twice.
-        let (code, key) = loop {
-            let code = codes::new_code()?;
-            let key = codes::Key::new(&code);
-            if self.find_code(&key).is_none() {
-                break (code, key);
-            }
-        };
-        let sealed = key.seal(token)?;
-        let path = self.dir(file).join(LINKS);
-        let entry = self.entry(file)?;
-        let link = entry.links.get_mut(at).ok_or("that file has no such link")?;
-        let before = link.code.replace(sealed);
-        let id = link.id.clone();
-        if let Err(e) = write_json(&path, &entry.links) {
-            if let Some(l) = entry.links.get_mut(at) {
-                l.code = before;
-            }
-            return Err(format!("couldn't keep the join code: {e}"));
-        }
-        self.forget_codes(before);
-        log::info!("event=code file={file} link={id}");
-        Ok(code)
-    }
-
-    /// The file a join code typed at `ip` opens, and its link's token; wrong codes count against
-    /// the address (see `abuse`), and nothing is looked up for an address that is locked out.
-    pub fn resolve_code(&mut self, ip: IpAddr, typed: &str) -> Result<(String, String), String> {
-        let now = Instant::now();
-        if let Some(left) = self.abuse.code_locked(ip, now) {
-            return Err(format!(
-                "Too many wrong codes from your address: try again in {} minutes, or join with the invite link",
-                left.as_secs() / 60 + 1
-            ));
-        }
-        if !self.abuse.allow(ip, Action::Code, now) {
-            return Err("Too many codes tried from your address: wait a minute and try again".into());
-        }
-        if !self.abuse.codes_open(now) {
-            return Err(CODES_BUSY.into());
-        }
-        // Anything that isn't a code's symbols is a wrong code too (and costs no hashing).
-        let key = figcraft_collab::code::normalize(typed).ok().filter(|c| c.len() == figcraft_collab::code::ONLINE_LEN).map(|c| codes::Key::new(&c));
-        let found = key.as_ref().and_then(|k| self.find_code(k));
-        self.abuse.code_tried(ip, found.is_some(), now);
-        match found {
-            Some((file, _, token)) => {
-                log::info!("event=code_used file={file} ip={ip}");
-                Ok((file, token))
-            }
-            None => {
-                let gone = key.is_some_and(|k| self.gone_codes.iter().any(|g| g == k.hash()));
-                Err(if gone { CODE_GONE } else { NO_CODE }.into())
-            }
-        }
-    }
-
-    /// Revoke a link.
-    pub fn revoke(&mut self, file: &str, link: &str) -> Result<(), String> {
-        let path = self.dir(file).join(LINKS);
-        let entry = self.entry(file)?;
-        let at = entry.links.iter().position(|l| l.id == link).ok_or("that file has no such link")?;
-        let gone = entry.links.remove(at);
-        if let Err(e) = write_json(&path, &entry.links) {
-            entry.links.insert(at, gone);
-            return Err(format!("couldn't revoke the link: {e}"));
-        }
-        log::info!("revoked link {link} of file {file}");
-        self.forget_codes(gone.code);
-        Ok(())
-    }
-
-    /// Remove a file and its links for good. `Err` when its folder couldn't be deleted (it is no
-    /// longer served either way).
-    pub fn remove(&mut self, file: &str) -> Result<(), String> {
-        // Closed first: an open log would keep the folder from being deleted on Windows.
-        let entry = self.files.remove(file).ok_or("this file isn't on the server (it may have been removed)")?;
-        self.forget_codes(entry.links.iter().filter_map(|l| l.code.clone()));
-        drop(entry);
-        let dir = self.dir(file);
-        fs::remove_dir_all(&dir)
-            .map_err(|e| format!("it is no longer served, but its folder {} couldn't be deleted ({e}); delete it by hand", dir.display()))?;
-        log::info!("removed file {file}");
-        Ok(())
-    }
-
-    /// A file's team library for `ip`, unless its version is `have`; within what one address and
-    /// everyone may download (the size is known before anything is read).
-    fn fetch_library(&mut self, ip: IpAddr, file: &str, have: Option<u64>) -> Result<LibraryReply, String> {
-        let (dir, max) = (self.dir(file), self.cfg.max_file_bytes);
-        let Some(lib) = self.entry(file)?.meta.library.clone() else { return Ok(LibraryReply::Empty) };
-        if have == Some(lib.version) {
-            return Ok(LibraryReply::Unchanged { version: lib.version });
-        }
-        let path = library_file(&dir, lib.version);
-        let size = fs::metadata(&path).map_or(0, |m| m.len());
-        let now = Instant::now();
-        if !self.abuse.allow(ip, Action::Download(usize::try_from(size).unwrap_or(usize::MAX)), now) || !self.served.take_n(now, size as f64) {
-            return Err(BUSY_DOWNLOADS.into());
-        }
-        Ok(LibraryReply::Library { version: lib.version, archive: disk::read_capped(&path, max)? })
-    }
-
-    /// Keep `archive` as a file's team library: it must read as a library (with the limits files
-    /// using it read it with), be the file's library if it has one, and be a newer version.
-    // shortcut: the archive is checked on the hub thread (other files' sessions wait meanwhile);
-    // move it to a worker if large libraries make that noticeable.
-    pub fn publish_library(&mut self, file: &str, archive: &[u8]) -> Result<u64, String> {
-        let max = self.cfg.max_file_bytes;
-        if self.cfg.hosting.open && self.entry(file)?.meta.owner.is_some() {
-            return Err(NO_PUBLIC_LIBRARY.into());
-        }
-        if archive.len() as u64 > max {
-            return Err(format!("the library is {} MiB; this server keeps files up to {} MiB", archive.len() >> 20, max >> 20));
-        }
-        // Everything it unpacks to counts against the same cap, so a small archive can't expand
-        // into a large library in memory.
-        let lib = match figcraft_format::read_library_within(Cursor::new(archive), max) {
-            Ok(Some(lib)) => lib,
-            Ok(None) => return Err("that isn't a published library".into()),
-            Err(e) => return Err(format!("the library can't be read: {e}")),
-        };
-        if lib.doc.node_count() > self.cfg.core.max_nodes {
-            return Err(format!("the library has more than {} layers", self.cfg.core.max_nodes));
-        }
-        let m = &lib.manifest;
-        let dir = self.dir(file);
-        let entry = self.entry(file)?;
-        if let Some(old) = &entry.meta.library {
-            if old.id != m.id {
-                return Err(format!("this file's library on the server is another one (\"{}\")", old.name));
-            }
-            if m.version <= old.version {
-                return Err(format!("version {} is on the server already: publish again to follow it", old.version));
-            }
-            // A jump would let a client use up the numbers and leave no newer version to publish.
-            if m.version > old.version.saturating_add(1) {
-                return Err(format!("version {} is too high: the next one after {} is {}", m.version, old.version, old.version.saturating_add(1)));
-            }
-        } else if m.version > MAX_FIRST_LIBRARY_VERSION {
-            return Err(format!("version {} is too high: a first publish goes up to {MAX_FIRST_LIBRARY_VERSION}", m.version));
-        }
-        // Each version has a file of its own, written before the description names it: a failed
-        // description write or a crash in between leaves the previous version served whole, never
-        // the new bytes under the old number.
-        let path = dir.join(library_name(m.version));
-        disk::write_atomic(&path, archive).map_err(|e| format!("couldn't keep the library: {e}"))?;
-        let before = entry.meta.library.replace(LibraryMeta { id: m.id.clone(), name: m.name.clone(), version: m.version });
-        if let Err(e) = write_json(&dir.join(META), &entry.meta) {
-            // Never served (the description doesn't name it); the next publish of it replaces it.
-            if let Err(r) = fs::remove_file(&path) {
-                log::warn!("file {file}: an unpublished library version couldn't be deleted: {r}");
-            }
-            entry.meta.library = before;
-            return Err(format!("couldn't keep the library: {e}"));
-        }
-        // The previous version isn't served any more.
-        if let Some(Err(e)) = before.map(|old| fs::remove_file(library_file(&dir, old.version))) {
-            log::warn!("file {file}: the previous library version couldn't be deleted: {e}");
-        }
-        log::info!("file {file}: published library version {} ({} bytes)", m.version, archive.len());
-        Ok(m.version)
-    }
-
-    /// A library's usage reports in memory (read from disk the first time; a damaged list starts
-    /// over: it is only statistics). `None` when the file has no library.
-    fn usage_of(&mut self, file: &str) -> Result<Option<&mut UsageCache>, String> {
-        if self.entry(file)?.meta.library.is_none() {
-            return Ok(None);
-        }
-        if !self.usage.contains_key(file) {
-            let path = self.dir(file).join(USAGE);
-            let list = if path.exists() {
-                disk::read_capped(&path, MAX_USAGE_FILE).ok().and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default()
-            } else {
-                Vec::new()
-            };
-            self.usage.insert(file.to_string(), UsageCache { list, dirty: false, written: now() });
-        }
-        Ok(self.usage.get_mut(file))
-    }
-
-    /// The usage reports kept for a file's library (none when it has no library).
-    pub fn library_usage(&mut self, file: &str) -> Result<Vec<FileUsage>, String> {
-        Ok(self.usage_of(file)?.map(|u| u.list.clone()).unwrap_or_default())
-    }
-
-    /// Keep how one file uses a file's library (in memory; written when it changed, at most every
-    /// [`USAGE_WRITE_EVERY`] seconds).
-    pub fn report_usage(&mut self, file: &str, usage: Usage) -> Result<(), String> {
-        let name = clean_name(&usage.file);
-        if name.is_empty() {
-            return Ok(());
-        }
-        let mut components: Vec<_> = usage.components.into_iter().filter(|(_, n)| *n > 0).take(MAX_REPORTED * 4).collect();
-        components.sort();
-        components.dedup_by_key(|c| c.0);
-        components.truncate(MAX_REPORTED);
-        let Some(u) = self.usage_of(file)? else { return Ok(()) };
-        match u.list.iter_mut().find(|f| f.usage.file == name) {
-            Some(f) if f.usage.components == components => return Ok(()),
-            Some(f) => {
-                f.usage.components = components;
-                f.updated = now();
-            }
-            None => u.list.push(FileUsage { usage: Usage { file: name, components }, updated: now() }),
-        }
-        if u.list.len() > MAX_USERS {
-            u.list.sort_by_key(|f| std::cmp::Reverse(f.updated));
-            u.list.truncate(MAX_USERS);
-        }
-        u.dirty = true;
-        if now() >= u.written.saturating_add(USAGE_WRITE_EVERY) {
-            self.write_usage(false);
-        }
-        Ok(())
-    }
-
-    /// Write the usage reports that changed (`all`: whenever they were last written).
-    fn write_usage(&mut self, all: bool) {
-        let t = now();
-        let root = self.root.join(FILES);
-        for (file, u) in &mut self.usage {
-            if u.dirty && (all || t >= u.written.saturating_add(USAGE_WRITE_EVERY)) {
-                if let Err(e) = write_json(&root.join(file).join(USAGE), &u.list) {
-                    log::warn!("file {file}: library usage couldn't be kept: {e}");
-                }
-                (u.dirty, u.written) = (false, t);
-            }
-        }
-    }
-
-    /// Whether `file` has room for about `n` more bytes: its cap, and for a file published
-    /// without the key its address's share and everyone's. A log that took it over its cap is
-    /// compacted first (the state may be smaller than its history).
-    fn room_for(&mut self, file: &str, server: &Server, n: u64) -> Result<(), String> {
-        if let Some(why) = self.low_disk() {
-            return Err(why);
-        }
-        let max = self.cfg.max_file_bytes;
-        let over = |s: &Store| s.bytes(file).saturating_add(n) > max;
-        // A compaction to make room at most once a minute per file (it rewrites the whole file).
-        let t = now();
-        let may_compact = self.files.get(file).is_some_and(|e| {
-            t >= e.forced.saturating_add(FORCED_COMPACTION_EVERY) && e.log.as_ref().is_some_and(|l| l.entries > 0 || !l.pending.is_empty())
-        });
-        if over(self) && may_compact {
-            if let Some(e) = self.files.get_mut(file) {
-                e.forced = t;
-            }
-            self.compact(file, server);
-        }
-        if over(self) {
-            return Err(format!("this file has reached the server's limit of {} MiB: that change wasn't kept", max >> 20));
-        }
-        let h = &self.cfg.hosting;
-        let Some(ip) = self.files.get(file).filter(|e| e.meta.owner.is_some()).and_then(|e| e.meta.ip.clone()) else { return Ok(()) };
-        let (max_ip, max_all) = (h.max_bytes_per_ip, h.max_total_bytes);
-        for (times, _, used) in self.per_block(&ip) {
-            let cap = max_ip.saturating_mul(u64::from(times));
-            if used.saturating_add(n) > cap {
-                return Err(format!("the files published from this file's address have reached their {} MiB: that change wasn't kept", cap >> 20));
-            }
-        }
-        let used_all: u64 = self.files.keys().map(|id| self.bytes(id)).sum();
-        if used_all.saturating_add(n) > max_all {
-            return Err("this server is full: that change wasn't kept".into());
-        }
-        Ok(())
-    }
-
-    /// Load a file's session: its snapshot, then its log (a damaged end is dropped and reported).
-    fn load(&mut self, file: &str) -> Result<Server, String> {
-        self.touch(file);
-        let dir = self.dir(file);
-        let (generation, state) = disk::decode_snapshot(&disk::read_capped(&dir.join(SNAPSHOT), self.snapshot_cap())?)?;
-        let mut server = Server::restore(state, "", self.cfg.core).map_err(|e| format!("the snapshot can't be used: {e}"))?;
-        let mut issues = Vec::new();
-        let mut fresh_log = true;
-        let mut kept = 0;
-        let log_path = dir.join(LOG);
-        // A log that's there but can't be read (an IO error, or over a lowered cap) may hold
-        // confirmed edits: the file isn't opened, and the log is left as it is for another try.
-        let read = match disk::read_capped(&log_path, self.cfg.max_file_bytes) {
-            Err(why) if log_path.exists() => return Err(format!("its log can't be read ({why}); it was left as it is")),
-            r => r,
-        };
-        // One that isn't a log is moved aside before a new one replaces it (or the file isn't opened).
-        let read = match read.map(|b| disk::read_log(&b)) {
-            Ok(Err(why)) => {
-                let aside = dir.join(format!("{LOG}.unreadable-{generation}-{}", now()));
-                fs::rename(&log_path, &aside).map_err(|e| format!("{why}, and it couldn't be moved aside ({e})"))?;
-                Err(format!("{why}; it was moved aside to {}", aside.display()))
-            }
-            Ok(Ok(log)) => Ok(log),
-            Err(why) => Err(why),
-        };
-        match read {
-            Ok(log) if log.generation == generation => {
-                fresh_log = false;
-                for entry in log.entries {
-                    if let Err(e) = server.replay(entry) {
-                        issues.push(format!("file {file}: its log stops making sense after {kept} entries ({e}); the rest was dropped"));
-                        fresh_log = true;
-                        break;
-                    }
-                    kept += 1;
-                }
-                if let Some(why) = log.damaged {
-                    issues.push(format!("file {file}: its log ended with {why}; that part was dropped"));
-                    fresh_log = true;
-                }
-            }
-            // From before a compaction that was cut short, the snapshot has it all; or a generation
-            // field damaged, which no checksum covers. Replaying tells them apart without trusting
-            // it: entries the snapshot holds are skipped, so only edits it lacks change anything.
-            Ok(log) => {
-                let before = server.seq();
-                let mut stopped = None;
-                for entry in log.entries {
-                    if let Err(e) = server.replay(entry) {
-                        stopped = Some(e);
-                        break;
-                    }
-                }
-                let (snap, found, recovered) = (generation, log.generation, server.seq().saturating_sub(before));
-                if recovered > 0 {
-                    issues.push(format!(
-                        "file {file}: its log's generation ({found}) doesn't match its snapshot's ({snap}), but it held \
-                         {recovered} changes the snapshot didn't; they were recovered"
-                    ));
-                }
-                if let Some(e) = stopped {
-                    issues.push(format!(
-                        "file {file}: its log's generation ({found}) doesn't match its snapshot's ({snap}) and it stops \
-                         making sense after {recovered} newer changes ({e}); the rest was dropped"
-                    ));
-                }
-            }
-            Err(why) => issues.push(format!("file {file}: {why}; starting a new log")),
-        }
-        for i in issues {
-            log::warn!("{i}");
-            self.note(i);
-        }
-        server.journaling(true);
-        let file_handle = OpenOptions::new().append(true).open(dir.join(LOG));
-        let log = match (fresh_log, file_handle) {
-            (false, Ok(f)) => {
-                let bytes = f.metadata().map_or(LOG_HEADER as u64, |m| m.len());
-                // Replayed entries make it worth compacting once everyone has left.
-                Log { generation, file: f, pending: Vec::new(), entries: kept, bytes, dirty: kept > 0 }
-            }
-            // A new snapshot and log of the next generation, so appends start clean.
-            _ => {
-                let next = generation.checked_add(1).ok_or("the file's generation can't go any higher")?;
-                self.rewrite(file, next, &server).map_err(|e| e.why)?
-            }
-        };
-        self.entry(file)?.log = Some(log);
-        Ok(server)
-    }
-
-    /// The largest snapshot read back: a file's cap plus room for what its state keeps beside the
-    /// document (recent batches for reconnecting clients, deletions), which may take it over.
-    fn snapshot_cap(&self) -> u64 {
-        self.cfg.max_file_bytes.saturating_mul(2)
-    }
-
-    /// Write `server`'s state as snapshot `generation` and start an empty log of it.
-    fn rewrite(&mut self, file: &str, generation: u64, server: &Server) -> Result<Log, RewriteError> {
-        let dir = self.dir(file);
-        let kept = |why: String| RewriteError { why, snapshot_replaced: false };
-        let state = server.state().map_err(|e| kept(e.to_string()))?;
-        let bytes = disk::encode_snapshot(generation, &state).map_err(kept)?;
-        // Never replace a readable snapshot with one that can't be opened again: the old snapshot
-        // and log still hold everything.
-        if bytes.len() as u64 > self.snapshot_cap() {
-            return Err(kept(format!("the snapshot would be {} MiB, more than can be opened again", bytes.len() >> 20)));
-        }
-        if bytes.len() as u64 > self.cfg.max_file_bytes {
-            log::warn!("file {file} is {} MiB, over the {} MiB cap (kept anyway)", bytes.len() >> 20, self.cfg.max_file_bytes >> 20);
-        }
-        disk::write_atomic(&dir.join(SNAPSHOT), &bytes).map_err(|e| kept(format!("couldn't write the snapshot: {e}")))?;
-        // From here the old log no longer goes with the snapshot on disk.
-        let replaced = |why: String| RewriteError { why, snapshot_replaced: true };
-        disk::write_atomic(&dir.join(LOG), &disk::log_header(generation)).map_err(|e| replaced(format!("couldn't start the log: {e}")))?;
-        let f = OpenOptions::new().append(true).open(dir.join(LOG)).map_err(|e| replaced(format!("couldn't open the log: {e}")))?;
-        if let Ok(e) = self.entry(file) {
-            e.bytes = (bytes.len() + LOG_HEADER) as u64;
-            e.meta.seq = server.seq();
-            let meta = e.meta.clone();
-            if let Err(err) = write_json(&dir.join(META), &meta) {
-                log::warn!("file {file}: couldn't update {META}: {err}");
-            }
-        }
-        Ok(Log { generation, file: f, pending: Vec::new(), entries: 0, bytes: LOG_HEADER as u64, dirty: false })
-    }
-
-    /// Compactions so far.
-    pub fn compactions(&self) -> u64 {
-        self.compactions
-    }
-
-    /// Why nothing more may be written when the data directory's disk is nearly full (less free
-    /// than [`StoreConfig::min_free_bytes`]); looked up at most once a second. Where the free space
-    /// can't be told, nothing is refused.
-    fn low_disk(&mut self) -> Option<String> {
-        let now = Instant::now();
-        let free = match self.free {
-            Some((at, free)) if now.saturating_duration_since(at) < std::time::Duration::from_secs(1) => free,
-            _ => {
-                let free = disk::free_bytes(&self.root);
-                self.free = Some((now, free));
-                free
-            }
-        };
-        free.filter(|f| *f < self.cfg.min_free_bytes)
-            .map(|_| "the server's disk is nearly full: it takes no changes or new files for now (tell its operator)".to_string())
-    }
-
-    /// Note a problem for the operator (logged too); only the latest [`MAX_PROBLEMS`] are kept.
-    fn note(&mut self, problem: String) {
-        if self.problems.len() >= MAX_PROBLEMS {
-            self.problems.remove(0);
-        }
-        self.problems.push(problem);
-    }
-
-    /// Compact an open file: its state as the next snapshot, an empty log.
-    fn compact(&mut self, file: &str, server: &Server) {
-        self.compactions += 1;
-        let Some(generation) = self.files.get(file).and_then(|e| e.log.as_ref()).map(|l| l.generation) else { return };
-        let Some(next) = generation.checked_add(1) else {
-            log::error!("file {file}: compaction failed: the file's generation can't go any higher");
-            return;
-        };
-        match self.rewrite(file, next, server) {
-            Ok(log) => {
-                if let Ok(e) = self.entry(file) {
-                    e.log = Some(log);
-                }
-                log::debug!("compacted file {file}");
-            }
-            // The new snapshot holds everything, but a restart would drop whatever is appended to
-            // the old log now (its generation no longer matches): the file closes, the hub hears
-            // it at the next flush, and it opens again from the new snapshot.
-            Err(RewriteError { why, snapshot_replaced: true }) => {
-                self.note(format!("file {file}: compaction was cut short ({why}); it was closed"));
-                log::error!("file {file}: compaction was cut short: {why}");
-                if let Some(e) = self.files.get_mut(file) {
-                    e.log = None;
-                }
-                self.cut_short.push(file.to_string());
-            }
-            // The old snapshot and log still hold everything: carry on appending.
-            Err(RewriteError { why, .. }) => log::error!("file {file}: compaction failed: {why}"),
-        }
-    }
-
-    /// Write and sync what's pending in every open log; the files whose log couldn't be written.
-    /// Those are closed here (their pending records dropped: nobody was told of them) and open
-    /// again from what is on disk.
-    fn flush_all(&mut self) -> Vec<String> {
-        let mut failed = std::mem::take(&mut self.cut_short);
-        for (id, e) in &mut self.files {
-            if let Some(log) = e.log.as_mut() {
-                match flush_log(id, log) {
-                    Ok(n) => e.bytes += n,
-                    Err(()) => {
-                        e.log = None;
-                        failed.push(id.clone());
-                    }
-                }
-            }
-        }
-        failed
-    }
 }
 
 /// Why a snapshot and log couldn't be rewritten, and whether the snapshot on disk was replaced
@@ -1391,38 +558,6 @@ struct RewriteError {
     snapshot_replaced: bool,
 }
 
-/// Write and sync a log's pending records: the bytes written, or `Err` when that failed (the log
-/// can't be trusted to hold them).
-fn flush_log(id: &str, log: &mut Log) -> Result<u64, ()> {
-    if log.pending.is_empty() {
-        return Ok(0);
-    }
-    match log.file.write_all(&log.pending).and_then(|()| log.file.sync_data()) {
-        Ok(()) => {
-            let n = log.pending.len() as u64;
-            log.bytes += n;
-            log.pending.clear();
-            Ok(n)
-        }
-        Err(e) => {
-            log::error!("file {id}: couldn't write its log: {e}");
-            Err(())
-        }
-    }
-}
-
-/// The name of the file holding version `version` of a file's team library.
-pub fn library_name(version: u64) -> String {
-    format!("library-{version}.bin")
-}
-
-/// Where version `version` of the team library in `dir` is: its own file, or `library.bin` for a
-/// version published before each version had one.
-fn library_file(dir: &Path, version: u64) -> PathBuf {
-    let path = dir.join(library_name(version));
-    if path.exists() { path } else { dir.join(LIBRARY) }
-}
-
 fn write_json<T: Serialize + ?Sized>(path: &Path, value: &T) -> Result<(), String> {
     let text = serde_json::to_vec_pretty(value).map_err(|e| e.to_string())?;
     disk::write_atomic(path, &text).map_err(|e| e.to_string())
@@ -1433,243 +568,3 @@ fn new_link(access: Access, label: &str, created: u64) -> Result<(Link, String),
     let token = token::secret()?;
     Ok((Link { id: token::file_id()?, access, label: label.to_string(), created, hash: hash(&token), code: None }, token))
 }
-
-impl Backend for Store {
-    fn admit(&mut self, file: &str, token: &str) -> Result<Admission, String> {
-        let entry = self.entry(file)?;
-        let link = Self::link_of(entry, token).and_then(|i| entry.links.get(i));
-        link.map(|l| Admission { access: l.access, link: Some(l.id.clone()) })
-            .ok_or_else(|| "this link isn't valid (it may have been revoked)".to_string())
-    }
-
-    fn open(&mut self, file: &str) -> Result<Server, String> {
-        self.load(file).map_err(|e| {
-            let why = format!("file {file} can't be opened: {e}");
-            log::error!("{why}");
-            self.note(why);
-            "this file can't be opened on the server (its data is damaged); tell the server's owner".to_string()
-        })
-    }
-
-    fn changed(&mut self, file: &str, server: &mut Server) {
-        let journal = server.take_journal();
-        if journal.is_empty() {
-            return;
-        }
-        let (after, max_bytes) = (self.cfg.compact_after, self.cfg.compact_bytes);
-        let Some(e) = self.files.get_mut(file) else { return };
-        let Some(log) = e.log.as_mut() else { return };
-        for j in &journal {
-            match disk::record(j) {
-                Ok(r) => log.pending.extend(r),
-                Err(err) => log::error!("file {file}: a change couldn't be logged: {err}"),
-            }
-        }
-        log.entries += journal.len();
-        log.dirty = true;
-        e.meta.updated = now();
-        if log.entries >= after || log.bytes + log.pending.len() as u64 >= max_bytes {
-            // The snapshot holds what's pending too.
-            self.compact(file, server);
-        }
-    }
-
-    fn flush(&mut self) -> Vec<String> {
-        self.flush_all()
-    }
-
-    fn room(&mut self, file: &str, server: &Server, bytes: usize) -> Result<(), String> {
-        self.room_for(file, server, bytes as u64)
-    }
-
-    fn idle(&mut self, file: &str, server: &mut Server) -> bool {
-        let compact = self.files.get_mut(file).is_some_and(|entry| {
-            let snapshot_seq = entry.meta.seq;
-            entry.log.as_mut().is_some_and(|log| {
-                // Issued client ids and refusals are durable in the log; only edits need a
-                // new image-bearing snapshot. Still try a snapshot if syncing the log failed.
-                flush_log(file, log).is_err() || (log.dirty && server.seq() > snapshot_seq)
-            })
-        });
-        if compact {
-            self.compact(file, server);
-        }
-        // It closes anyway, with its state in the snapshot and durable log.
-        self.cut_short.retain(|f| f != file);
-        if let Some(e) = self.files.get_mut(file) {
-            e.log = None;
-        }
-        // Everyone just left: idle time counts from now.
-        self.touch(file);
-        true
-    }
-
-    fn stop(&mut self, open: Vec<(&str, &mut Server)>) {
-        self.write_usage(true);
-        self.flush_all();
-        for (file, server) in open {
-            if self.files.get(file).and_then(|e| e.log.as_ref()).is_some_and(|l| l.dirty) {
-                self.compact(file, server);
-            }
-        }
-    }
-
-    fn manage(&mut self, key: &str) -> Result<(), String> {
-        match same_secret(key, &self.key) {
-            true => Ok(()),
-            false if self.cfg.hosting.open => {
-                Err("wrong server key (this server is open to the public: publish without a key, with an up-to-date FigCraft)".into())
-            }
-            false => Err("wrong server key".into()),
-        }
-    }
-
-    fn connect(&mut self, ip: IpAddr) -> Result<(), String> {
-        if now() >= self.next_sweep {
-            self.sweep();
-            self.write_usage(false);
-        }
-        if self.blocked.contains(&ip) {
-            return Err("this server doesn't accept connections from your address".into());
-        }
-        if !self.abuse.allow(ip, Action::Connect, Instant::now()) {
-            return Err("too many connections from your address lately: wait a minute and try again".into());
-        }
-        Ok(())
-    }
-
-    fn message(&mut self, ip: IpAddr, msg: &ClientMsg) -> bool {
-        // Cursors and cursor chat (many people behind one address each send ~30 a second while
-        // they move) have a budget of their own, beside everything else.
-        let what = if matches!(msg, ClientMsg::Presence(_) | ClientMsg::Signal(_) | ClientMsg::Ping) { Action::Presence } else { Action::Message };
-        self.abuse.allow(ip, what, Instant::now())
-    }
-
-    fn hosting(&mut self, file: &str) -> Option<HostInfo> {
-        Some(self.host_info(Some(file)))
-    }
-
-    fn open_hosting(&mut self, _ip: IpAddr, file: &str, owner: &str) -> Result<HostInfo, String> {
-        if file.is_empty() && owner.is_empty() {
-            return Ok(self.host_info(None));
-        }
-        if !self.owns(file, owner) {
-            return Err("that owner token doesn't manage a file of that id here (it may have been removed or expired)".into());
-        }
-        Ok(self.host_info(Some(file)))
-    }
-
-    fn hosted(&mut self, ip: IpAddr, owns: Option<&str>, req: Admin, open: &dyn Fn(&str) -> Option<OpenFile>) -> Handled {
-        let failed = |reason: &str| Handled::from(AdminReply::Failed { reason: reason.to_string() });
-        let file = match &req {
-            Admin::Publish { name, snapshot } => {
-                return match self.publish_open(ip, name, snapshot) {
-                    Ok((file, edit, view, owner)) => {
-                        let expires = self.files.get(&file.id).and_then(|e| self.expires(&e.meta));
-                        AdminReply::Hosted { file, edit, view, owner, expires }.into()
-                    }
-                    Err(e) => {
-                        log::info!("event=publish_refused ip={ip} reason={e:?}");
-                        Handled::from(AdminReply::Failed { reason: e })
-                    }
-                };
-            }
-            Admin::Owned { files } => return self.owned(files).into(),
-            Admin::Links { file }
-            | Admin::CreateLink { file, .. }
-            | Admin::Revoke { file, .. }
-            | Admin::Rename { file, .. }
-            | Admin::Code { file, .. }
-            | Admin::Remove { file } => file,
-            _ => return failed("that needs the server key"),
-        };
-        if owns != Some(file.as_str()) {
-            return failed("an owner token manages only its own file");
-        }
-        self.admin(req, open)
-    }
-
-    fn report(&mut self, file: &str, link: Option<&str>, ip: IpAddr, reason: &str) -> Result<(), String> {
-        self.keep_report(file, link, ip, reason)
-    }
-
-    fn admin(&mut self, req: Admin, open: &dyn Fn(&str) -> Option<OpenFile>) -> Handled {
-        let failed = |reason: String| Handled::from(AdminReply::Failed { reason });
-        match req {
-            Admin::Publish { name, snapshot } => match self.publish(&name, &snapshot) {
-                Ok((file, edit, view)) => AdminReply::Published { file, edit, view }.into(),
-                Err(e) => failed(e),
-            },
-            Admin::Files => AdminReply::Files(self.list(open)).into(),
-            Admin::Links { file } => self.links(&file).map_or_else(failed, |l| AdminReply::Links(l).into()),
-            Admin::CreateLink { file, access, label } => self.create_link(&file, access, &label).map_or_else(failed, |l| AdminReply::Link(l).into()),
-            Admin::Revoke { file, link } => match self.revoke(&file, &link) {
-                Ok(()) => Handled { reply: AdminReply::Done, revoked: Some((file, link)), removed: None, blocked: None },
-                Err(e) => failed(e),
-            },
-            Admin::Rename { file, name } => self.rename(&file, &name).map_or_else(failed, |()| AdminReply::Done.into()),
-            Admin::Listing => AdminReply::Listing(self.listing(open)).into(),
-            Admin::Reports => AdminReply::Reports(self.reports.clone()).into(),
-            Admin::Block { ip } => match self.block(&ip, true) {
-                Ok(ip) => Handled { reply: AdminReply::Done, revoked: None, removed: None, blocked: Some(ip) },
-                Err(e) => failed(e),
-            },
-            Admin::Unblock { ip } => self.block(&ip, false).map_or_else(failed, |_| AdminReply::Done.into()),
-            Admin::Blocked => AdminReply::Blocked(self.blocked()).into(),
-            Admin::Code { file, token } => self.set_code(&file, &token).map_or_else(failed, |code| AdminReply::Code { code }.into()),
-            Admin::Owned { files } => self.owned(&files).into(),
-            // The hub removes people itself (it knows who is connected); it never asks the store.
-            Admin::RemovePeer { .. } => failed("removing someone from a file is done by the server's hub".into()),
-            Admin::Remove { file } => {
-                if !self.files.contains_key(&file) {
-                    return failed("this file isn't on the server (it may have been removed)".into());
-                }
-                let reply = match self.remove(&file) {
-                    Ok(()) => AdminReply::Done,
-                    Err(reason) => AdminReply::Failed { reason },
-                };
-                Handled { reply, revoked: None, removed: Some(file), blocked: None }
-            }
-        }
-    }
-
-    fn library(&mut self, ip: IpAddr, file: &str, access: Access, req: LibraryReq) -> LibraryReply {
-        let failed = |reason: String| LibraryReply::Failed { reason };
-        match req {
-            LibraryReq::Fetch { have, usage } => {
-                if let Some(u) = usage
-                    && let Err(e) = self.report_usage(file, u)
-                {
-                    log::warn!("file {file}: a library usage report couldn't be kept: {e}");
-                }
-                self.fetch_library(ip, file, have).unwrap_or_else(failed)
-            }
-            LibraryReq::Publish { .. } if access != Access::Edit => {
-                failed("you can only view this file: publishing its library needs an edit link".into())
-            }
-            LibraryReq::Publish { archive } => {
-                self.publish_library(file, &archive).map_or_else(failed, |version| LibraryReply::Published { version })
-            }
-            LibraryReq::Usage => self.library_usage(file).map_or_else(failed, LibraryReply::Usage),
-        }
-    }
-
-    fn plugins(&mut self, ip: IpAddr, publisher: bool, req: PluginReq) -> PluginReply {
-        // One address's share first (before everyone's budget is spent or anything is read).
-        if let PluginReq::Fetch { id, version } = &req
-            && let Some(size) = self.directory.size_of(id, version.as_deref())
-            && !self.abuse.allow(ip, Action::Download(usize::try_from(size).unwrap_or(usize::MAX)), Instant::now())
-        {
-            return PluginReply::Failed { reason: BUSY_DOWNLOADS.into() };
-        }
-        self.directory.handle(publisher, req)
-    }
-
-    fn resolve(&mut self, ip: IpAddr, code: &str) -> Result<(String, String), String> {
-        self.resolve_code(ip, code)
-    }
-
-    fn closing(&self) -> Closing {
-        Closing::Restarting
-    }
-}
diff --git a/apps/figcraft-server/src/store/backend.rs b/apps/figcraft-server/src/store/backend.rs
new file mode 100644
index 00000000..af9b8bbb
--- /dev/null
+++ b/apps/figcraft-server/src/store/backend.rs
@@ -0,0 +1,242 @@
+use super::journal::flush_log;
+use super::*;
+
+impl Backend for Store {
+    fn admit(&mut self, file: &str, token: &str) -> Result<Admission, String> {
+        let entry = self.entry(file)?;
+        let link = Self::link_of(entry, token).and_then(|i| entry.links.get(i));
+        link.map(|l| Admission { access: l.access, link: Some(l.id.clone()) })
+            .ok_or_else(|| "this link isn't valid (it may have been revoked)".to_string())
+    }
+
+    fn open(&mut self, file: &str) -> Result<Server, String> {
+        self.load(file).map_err(|e| {
+            let why = format!("file {file} can't be opened: {e}");
+            log::error!("{why}");
+            self.note(why);
+            "this file can't be opened on the server (its data is damaged); tell the server's owner".to_string()
+        })
+    }
+
+    fn changed(&mut self, file: &str, server: &mut Server) {
+        let journal = server.take_journal();
+        if journal.is_empty() {
+            return;
+        }
+        let (after, max_bytes) = (self.cfg.compact_after, self.cfg.compact_bytes);
+        let Some(e) = self.files.get_mut(file) else { return };
+        let Some(log) = e.log.as_mut() else { return };
+        for j in &journal {
+            match disk::record(j) {
+                Ok(r) => log.pending.extend(r),
+                Err(err) => log::error!("file {file}: a change couldn't be logged: {err}"),
+            }
+        }
+        log.entries += journal.len();
+        log.dirty = true;
+        e.meta.updated = now();
+        if log.entries >= after || log.bytes + log.pending.len() as u64 >= max_bytes {
+            // The snapshot holds what's pending too.
+            self.compact(file, server);
+        }
+    }
+
+    fn flush(&mut self) -> Vec<String> {
+        self.flush_all()
+    }
+
+    fn room(&mut self, file: &str, server: &Server, bytes: usize) -> Result<(), String> {
+        self.room_for(file, server, bytes as u64)
+    }
+
+    fn idle(&mut self, file: &str, server: &mut Server) -> bool {
+        let compact = self.files.get_mut(file).is_some_and(|entry| {
+            let snapshot_seq = entry.meta.seq;
+            entry.log.as_mut().is_some_and(|log| {
+                // Issued client ids and refusals are durable in the log; only edits need a
+                // new image-bearing snapshot. Still try a snapshot if syncing the log failed.
+                flush_log(file, log).is_err() || (log.dirty && server.seq() > snapshot_seq)
+            })
+        });
+        if compact {
+            self.compact(file, server);
+        }
+        // It closes anyway, with its state in the snapshot and durable log.
+        self.cut_short.retain(|f| f != file);
+        if let Some(e) = self.files.get_mut(file) {
+            e.log = None;
+        }
+        // Everyone just left: idle time counts from now.
+        self.touch(file);
+        true
+    }
+
+    fn stop(&mut self, open: Vec<(&str, &mut Server)>) {
+        self.write_usage(true);
+        self.flush_all();
+        for (file, server) in open {
+            if self.files.get(file).and_then(|e| e.log.as_ref()).is_some_and(|l| l.dirty) {
+                self.compact(file, server);
+            }
+        }
+    }
+
+    fn manage(&mut self, key: &str) -> Result<(), String> {
+        match same_secret(key, &self.key) {
+            true => Ok(()),
+            false if self.cfg.hosting.open => {
+                Err("wrong server key (this server is open to the public: publish without a key, with an up-to-date FigCraft)".into())
+            }
+            false => Err("wrong server key".into()),
+        }
+    }
+
+    fn connect(&mut self, ip: IpAddr) -> Result<(), String> {
+        if now() >= self.next_sweep {
+            self.sweep();
+            self.write_usage(false);
+        }
+        if self.blocked.contains(&ip) {
+            return Err("this server doesn't accept connections from your address".into());
+        }
+        if !self.abuse.allow(ip, Action::Connect, Instant::now()) {
+            return Err("too many connections from your address lately: wait a minute and try again".into());
+        }
+        Ok(())
+    }
+
+    fn message(&mut self, ip: IpAddr, msg: &ClientMsg) -> bool {
+        // Cursors and cursor chat (many people behind one address each send ~30 a second while
+        // they move) have a budget of their own, beside everything else.
+        let what = if matches!(msg, ClientMsg::Presence(_) | ClientMsg::Signal(_) | ClientMsg::Ping) { Action::Presence } else { Action::Message };
+        self.abuse.allow(ip, what, Instant::now())
+    }
+
+    fn hosting(&mut self, file: &str) -> Option<HostInfo> {
+        Some(self.host_info(Some(file)))
+    }
+
+    fn open_hosting(&mut self, _ip: IpAddr, file: &str, owner: &str) -> Result<HostInfo, String> {
+        if file.is_empty() && owner.is_empty() {
+            return Ok(self.host_info(None));
+        }
+        if !self.owns(file, owner) {
+            return Err("that owner token doesn't manage a file of that id here (it may have been removed or expired)".into());
+        }
+        Ok(self.host_info(Some(file)))
+    }
+
+    fn hosted(&mut self, ip: IpAddr, owns: Option<&str>, req: Admin, open: &dyn Fn(&str) -> Option<OpenFile>) -> Handled {
+        let failed = |reason: &str| Handled::from(AdminReply::Failed { reason: reason.to_string() });
+        let file = match &req {
+            Admin::Publish { name, snapshot } => {
+                return match self.publish_open(ip, name, snapshot) {
+                    Ok((file, edit, view, owner)) => {
+                        let expires = self.files.get(&file.id).and_then(|e| self.expires(&e.meta));
+                        AdminReply::Hosted { file, edit, view, owner, expires }.into()
+                    }
+                    Err(e) => {
+                        log::info!("event=publish_refused ip={ip} reason={e:?}");
+                        Handled::from(AdminReply::Failed { reason: e })
+                    }
+                };
+            }
+            Admin::Owned { files } => return self.owned(files).into(),
+            Admin::Links { file }
+            | Admin::CreateLink { file, .. }
+            | Admin::Revoke { file, .. }
+            | Admin::Rename { file, .. }
+            | Admin::Code { file, .. }
+            | Admin::Remove { file } => file,
+            _ => return failed("that needs the server key"),
+        };
+        if owns != Some(file.as_str()) {
+            return failed("an owner token manages only its own file");
+        }
+        self.admin(req, open)
+    }
+
+    fn report(&mut self, file: &str, link: Option<&str>, ip: IpAddr, reason: &str) -> Result<(), String> {
+        self.keep_report(file, link, ip, reason)
+    }
+
+    fn admin(&mut self, req: Admin, open: &dyn Fn(&str) -> Option<OpenFile>) -> Handled {
+        let failed = |reason: String| Handled::from(AdminReply::Failed { reason });
+        match req {
+            Admin::Publish { name, snapshot } => match self.publish(&name, &snapshot) {
+                Ok((file, edit, view)) => AdminReply::Published { file, edit, view }.into(),
+                Err(e) => failed(e),
+            },
+            Admin::Files => AdminReply::Files(self.list(open)).into(),
+            Admin::Links { file } => self.links(&file).map_or_else(failed, |l| AdminReply::Links(l).into()),
+            Admin::CreateLink { file, access, label } => self.create_link(&file, access, &label).map_or_else(failed, |l| AdminReply::Link(l).into()),
+            Admin::Revoke { file, link } => match self.revoke(&file, &link) {
+                Ok(()) => Handled { reply: AdminReply::Done, revoked: Some((file, link)), removed: None, blocked: None },
+                Err(e) => failed(e),
+            },
+            Admin::Rename { file, name } => self.rename(&file, &name).map_or_else(failed, |()| AdminReply::Done.into()),
+            Admin::Listing => AdminReply::Listing(self.listing(open)).into(),
+            Admin::Reports => AdminReply::Reports(self.reports.clone()).into(),
+            Admin::Block { ip } => match self.block(&ip, true) {
+                Ok(ip) => Handled { reply: AdminReply::Done, revoked: None, removed: None, blocked: Some(ip) },
+                Err(e) => failed(e),
+            },
+            Admin::Unblock { ip } => self.block(&ip, false).map_or_else(failed, |_| AdminReply::Done.into()),
+            Admin::Blocked => AdminReply::Blocked(self.blocked()).into(),
+            Admin::Code { file, token } => self.set_code(&file, &token).map_or_else(failed, |code| AdminReply::Code { code }.into()),
+            Admin::Owned { files } => self.owned(&files).into(),
+            // The hub removes people itself (it knows who is connected); it never asks the store.
+            Admin::RemovePeer { .. } => failed("removing someone from a file is done by the server's hub".into()),
+            Admin::Remove { file } => {
+                if !self.files.contains_key(&file) {
+                    return failed("this file isn't on the server (it may have been removed)".into());
+                }
+                let reply = match self.remove(&file) {
+                    Ok(()) => AdminReply::Done,
+                    Err(reason) => AdminReply::Failed { reason },
+                };
+                Handled { reply, revoked: None, removed: Some(file), blocked: None }
+            }
+        }
+    }
+
+    fn library(&mut self, ip: IpAddr, file: &str, access: Access, req: LibraryReq) -> LibraryReply {
+        let failed = |reason: String| LibraryReply::Failed { reason };
+        match req {
+            LibraryReq::Fetch { have, usage } => {
+                if let Some(u) = usage
+                    && let Err(e) = self.report_usage(file, u)
+                {
+                    log::warn!("file {file}: a library usage report couldn't be kept: {e}");
+                }
+                self.fetch_library(ip, file, have).unwrap_or_else(failed)
+            }
+            LibraryReq::Publish { .. } if access != Access::Edit => {
+                failed("you can only view this file: publishing its library needs an edit link".into())
+            }
+            LibraryReq::Publish { archive } => {
+                self.publish_library(file, &archive).map_or_else(failed, |version| LibraryReply::Published { version })
+            }
+            LibraryReq::Usage => self.library_usage(file).map_or_else(failed, LibraryReply::Usage),
+        }
+    }
+
+    fn plugins(&mut self, ip: IpAddr, publisher: bool, req: PluginReq) -> PluginReply {
+        // One address's share first (before everyone's budget is spent or anything is read).
+        if let PluginReq::Fetch { id, version } = &req
+            && let Some(size) = self.directory.size_of(id, version.as_deref())
+            && !self.abuse.allow(ip, Action::Download(usize::try_from(size).unwrap_or(usize::MAX)), Instant::now())
+        {
+            return PluginReply::Failed { reason: BUSY_DOWNLOADS.into() };
+        }
+        self.directory.handle(publisher, req)
+    }
+
+    fn resolve(&mut self, ip: IpAddr, code: &str) -> Result<(String, String), String> {
+        self.resolve_code(ip, code)
+    }
+
+    fn closing(&self) -> Closing {
+        Closing::Restarting
+    }
+}
diff --git a/apps/figcraft-server/src/store/files.rs b/apps/figcraft-server/src/store/files.rs
new file mode 100644
index 00000000..53ae9c87
--- /dev/null
+++ b/apps/figcraft-server/src/store/files.rs
@@ -0,0 +1,300 @@
+use super::*;
+
+impl Store {
+    /// Keep a document (its snapshot) as a new file with an edit link and a view link.
+    pub fn publish(&mut self, name: &str, snapshot: &[Change]) -> Result<(FileInfo, NewLink, NewLink), String> {
+        self.keep(name, snapshot, None, &|_| Ok(())).map(|(info, edit, view, _)| (info, edit, view))
+    }
+
+    /// For each block the address `ip` counts in ([`ip_blocks`]), how many times one address's
+    /// caps it gets, and the files and bytes kept by the files published from addresses in it. An
+    /// address that doesn't parse counts as itself only, ×1, by its exact text.
+    pub(super) fn per_block(&self, ip: &str) -> Vec<(u32, usize, u64)> {
+        let blocks_of = |text: &str| text.parse::<IpAddr>().map(|a| ip_blocks(ip_key(a))).unwrap_or_default();
+        let kept: Vec<(&str, Vec<_>, u64)> = self
+            .files
+            .iter()
+            .filter_map(|(id, e)| {
+                let from = e.meta.ip.as_deref()?;
+                Some((from, blocks_of(from).into_iter().map(|(b, _)| b).collect(), self.bytes(id)))
+            })
+            .collect();
+        let sum = |mine: &mut dyn Iterator<Item = &(&str, Vec<_>, u64)>| mine.fold((0, 0u64), |(f, b), (_, _, n)| (f + 1, b.saturating_add(*n)));
+        let blocks = blocks_of(ip);
+        if blocks.is_empty() {
+            let (files, bytes) = sum(&mut kept.iter().filter(|(from, _, _)| *from == ip));
+            return vec![(1, files, bytes)];
+        }
+        blocks
+            .into_iter()
+            .map(|(block, times)| {
+                let (files, bytes) = sum(&mut kept.iter().filter(|(_, blocks, _)| blocks.contains(&block)));
+                (times, files, bytes)
+            })
+            .collect()
+    }
+
+    /// Keep a document published without the key from `ip`, within the caps on what one address
+    /// and everyone may keep: the file, its links and its owner token.
+    pub fn publish_open(&mut self, ip: IpAddr, name: &str, snapshot: &[Change]) -> Result<(FileInfo, NewLink, NewLink, String), String> {
+        let h = &self.cfg.hosting;
+        let (open, max_files, max_ip, max_all) = (h.open, h.max_files_per_ip, h.max_bytes_per_ip, h.max_total_bytes);
+        if !open {
+            return Err(KEY_ONLY.into());
+        }
+        if !self.abuse.allow(ip, Action::Publish, Instant::now()) {
+            return Err("too many files published from your address lately: try again in an hour".into());
+        }
+        let blocks = self.per_block(&ip.to_string());
+        for &(times, files, _) in &blocks {
+            if files >= max_files.saturating_mul(times as usize) {
+                return Err(format!(
+                    "your address keeps {files} files on this server already, the most it may: remove one (with its owner token) or wait until one expires"
+                ));
+            }
+        }
+        let used_all: u64 = self.files.keys().map(|id| self.bytes(id)).sum();
+        let fits = |n: u64| {
+            for &(times, _, used) in &blocks {
+                let cap = max_ip.saturating_mul(u64::from(times));
+                if used.saturating_add(n) > cap {
+                    return Err(format!("your address's files would take more than the {} MiB it may keep here: remove one first", cap >> 20));
+                }
+            }
+            if used_all.saturating_add(n) > max_all {
+                return Err("this server is full: it takes no more files for now (try again later, or another server)".into());
+            }
+            Ok(())
+        };
+        let (info, edit, view, owner) = self.keep(name, snapshot, Some(ip), &fits)?;
+        Ok((info, edit, view, owner.unwrap_or_default()))
+    }
+
+    /// Keep a document as a new file: published without the key from `ip` (it gets an owner
+    /// token), else by the operator. `fits` checks its size against the caps that apply.
+    fn keep(
+        &mut self,
+        name: &str,
+        snapshot: &[Change],
+        ip: Option<IpAddr>,
+        fits: &dyn Fn(u64) -> Result<(), String>,
+    ) -> Result<(FileInfo, NewLink, NewLink, Option<String>), String> {
+        if self.files.len() >= self.cfg.max_files {
+            return Err(format!("the server keeps at most {} files", self.cfg.max_files));
+        }
+        if let Some(why) = self.low_disk() {
+            return Err(why);
+        }
+        let replica = Replica::from_snapshot(snapshot).map_err(|e| format!("the file couldn't be read: {e}"))?;
+        if replica.document().node_count() > self.cfg.core.max_nodes {
+            return Err(format!("the file has more than {} layers", self.cfg.core.max_nodes));
+        }
+        let mut doc = replica.document().clone();
+        let name = match clean_name(name) {
+            n if n.is_empty() => doc.name.clone(),
+            n => n,
+        };
+        doc.name = name.clone();
+        let server = Server::new(doc, "", self.cfg.core);
+        let state = server.state().map_err(|e| e.to_string())?;
+        let bytes = disk::encode_snapshot(1, &state)?;
+        if bytes.len() as u64 > self.cfg.max_file_bytes {
+            return Err(format!("the file is {} MiB; this server keeps files up to {} MiB", bytes.len() >> 20, self.cfg.max_file_bytes >> 20));
+        }
+        fits(bytes.len() as u64)?;
+        let id = loop {
+            let id = token::file_id()?;
+            if !self.files.contains_key(&id) && !self.dir(&id).exists() {
+                break id;
+            }
+        };
+        let t = now();
+        let (edit, edit_token) = new_link(Access::Edit, "Published (edit)", t)?;
+        let (view, view_token) = new_link(Access::View, "Published (view)", t)?;
+        let owner = ip.map(|_| token::secret()).transpose()?;
+        let meta =
+            Meta { name, created: t, updated: t, seq: 0, library: None, owner: owner.as_deref().map(hash), ip: ip.map(|i| i.to_string()), opened: 0 };
+        let dir = self.dir(&id);
+        let written = fs::create_dir_all(&dir)
+            .map_err(|e| e.to_string())
+            .and_then(|()| {
+                disk::sync_dir(Some(&self.root.join(FILES)));
+                disk::write_atomic(&dir.join(SNAPSHOT), &bytes).map_err(|e| e.to_string())
+            })
+            .and_then(|()| disk::write_atomic(&dir.join(LOG), &disk::log_header(1)).map_err(|e| e.to_string()))
+            .and_then(|()| write_json(&dir.join(LINKS), &[edit.clone(), view.clone()]))
+            // Last: a folder without its description is an upload cut short.
+            .and_then(|()| write_json(&dir.join(META), &meta));
+        if let Err(e) = written {
+            let _ = fs::remove_dir_all(&dir);
+            return Err(format!("couldn't keep the file: {e}"));
+        }
+        let entry = Entry { meta, links: vec![edit.clone(), view.clone()], log: None, bytes: (bytes.len() + LOG_HEADER) as u64, forced: 0 };
+        self.files.insert(id.clone(), entry);
+        let info = self.files.get(&id).map(|e| self.info(&id, e, None)).ok_or("the file vanished")?;
+        match ip {
+            Some(ip) => log::info!("event=published file={id} bytes={} ip={ip} by=public", bytes.len()),
+            None => log::info!("event=published file={id} bytes={} by=key", bytes.len()),
+        }
+        Ok((info, NewLink { link: edit.info(&id), token: edit_token }, NewLink { link: view.info(&id), token: view_token }, owner))
+    }
+
+    /// The files kept, with what the operator moderates by.
+    pub fn listing(&self, open: &dyn Fn(&str) -> Option<OpenFile>) -> Vec<FileRow> {
+        self.files
+            .iter()
+            .map(|(id, e)| FileRow {
+                info: self.info(id, e, open(id)),
+                opened: e.meta.opened,
+                expires: self.expires(&e.meta),
+                open: e.meta.owner.is_some(),
+                ip: e.meta.ip.clone().unwrap_or_default(),
+                reports: u32::try_from(self.reports.iter().filter(|r| r.file == *id).count()).unwrap_or(u32::MAX),
+            })
+            .collect()
+    }
+
+    /// Owner token `owner` manages file `file` (one published without the key).
+    pub(super) fn owns(&self, file: &str, owner: &str) -> bool {
+        let presented = hash(owner);
+        self.files.get(file).and_then(|e| e.meta.owner.as_deref()).is_some_and(|h| same_secret(&presented, h))
+    }
+
+    /// What became of the files these `(file id, owner token)` pairs own: each one's name, links
+    /// and expiry, or `None` when that token manages no file of that id here (which doesn't say
+    /// whether the id exists). Asking opens nothing: it doesn't count as using a file.
+    pub fn owned(&self, files: &[(String, String)]) -> AdminReply {
+        if files.len() > MAX_OWNED {
+            return AdminReply::Failed { reason: format!("ask about at most {MAX_OWNED} files at a time") };
+        }
+        let one = |(file, owner): &(String, String)| {
+            let e = self.files.get(file).filter(|_| self.owns(file, owner))?;
+            Some(OwnedFile { name: e.meta.name.clone(), links: e.links.iter().map(|l| l.id.clone()).collect(), expires: self.expires(&e.meta) })
+        };
+        AdminReply::Owned(files.iter().map(one).collect())
+    }
+
+    /// Rename a file (its listing; the document inside keeps its own name).
+    pub fn rename(&mut self, file: &str, name: &str) -> Result<(), String> {
+        let name = clean_name(name);
+        if name.is_empty() {
+            return Err("give the file a name".into());
+        }
+        let path = self.dir(file).join(META);
+        let entry = self.entry(file)?;
+        let before = std::mem::replace(&mut entry.meta.name, name);
+        if let Err(e) = write_json(&path, &entry.meta) {
+            entry.meta.name = before;
+            return Err(format!("couldn't rename the file: {e}"));
+        }
+        Ok(())
+    }
+
+    /// Delete the files published without the key that nobody opened for the idle time (not
+    /// those open now); their ids.
+    pub fn sweep(&mut self) -> Vec<String> {
+        let t = now();
+        self.next_sweep = t.saturating_add(SWEEP_EVERY);
+        let due: Vec<String> =
+            self.files.iter().filter(|(_, e)| e.log.is_none() && self.expires(&e.meta).is_some_and(|x| x <= t)).map(|(id, _)| id.clone()).collect();
+        for id in &due {
+            match self.remove(id) {
+                Ok(()) => log::info!("event=expired file={id}"),
+                Err(e) => log::warn!("event=expire_failed file={id} reason={e:?}"),
+            }
+        }
+        due
+    }
+
+    /// Make a file look unused for `secs` more (tests: expiry without waiting).
+    #[cfg(test)]
+    pub fn age(&mut self, file: &str, secs: u64) {
+        let path = self.dir(file).join(META);
+        if let Some(e) = self.files.get_mut(file) {
+            let m = &mut e.meta;
+            (m.created, m.updated, m.opened) = (m.created.saturating_sub(secs), m.updated.saturating_sub(secs), m.opened.saturating_sub(secs));
+            let _ = write_json(&path, m);
+        }
+    }
+
+    /// Make an open file's log refuse writes (tests: a full or failing disk).
+    #[cfg(test)]
+    pub fn break_log(&mut self, file: &str) {
+        let path = self.dir(file).join(LOG);
+        if let Some(log) = self.files.get_mut(file).and_then(|e| e.log.as_mut())
+            && let Ok(f) = File::open(path)
+        {
+            log.file = f;
+        }
+    }
+
+    /// Note that a file was opened now (it is used: it doesn't expire).
+    pub(super) fn touch(&mut self, file: &str) {
+        let path = self.dir(file).join(META);
+        if let Some(e) = self.files.get_mut(file) {
+            e.meta.opened = now();
+            if let Err(err) = write_json(&path, &e.meta) {
+                log::warn!("file {file}: couldn't update {META}: {err}");
+            }
+        }
+    }
+
+    /// What the server says about its hosting (with `file`'s expiry).
+    pub(super) fn host_info(&self, file: Option<&str>) -> HostInfo {
+        let h = &self.cfg.hosting;
+        let expires = file.and_then(|f| self.files.get(f)).and_then(|e| self.expires(&e.meta));
+        HostInfo { open: h.open, operator: h.operator.clone(), terms: h.terms.clone(), idle_secs: h.idle_secs, max_file_mb: h.max_file_mb, expires }
+    }
+
+    /// Block or unblock an address (an IPv6 address: its /64); the address as kept.
+    pub fn block(&mut self, ip: &str, on: bool) -> Result<IpAddr, String> {
+        let ip = ip_key(ip.trim().parse::<IpAddr>().map_err(|_| format!("`{}` isn't an IP address", ip.trim()))?);
+        if on && !self.blocked.contains(&ip) && self.blocked.len() >= MAX_BLOCKED {
+            return Err(format!("at most {MAX_BLOCKED} addresses can be blocked"));
+        }
+        let changed = if on { self.blocked.insert(ip) } else { self.blocked.remove(&ip) };
+        if changed {
+            let list: Vec<String> = self.blocked.iter().map(IpAddr::to_string).collect();
+            write_json(&self.root.join(BLOCKED), &list).map_err(|e| format!("couldn't keep the blocked addresses: {e}"))?;
+            log::info!("event={} ip={ip}", if on { "blocked" } else { "unblocked" });
+        }
+        Ok(ip)
+    }
+
+    /// The blocked addresses.
+    pub fn blocked(&self) -> Vec<String> {
+        self.blocked.iter().map(IpAddr::to_string).collect()
+    }
+
+    /// The reports kept, oldest first.
+    pub fn reports(&self) -> &[ReportInfo] {
+        &self.reports
+    }
+
+    /// Keep a report about `file` (from someone who joined it with `link`, at `ip`).
+    pub fn keep_report(&mut self, file: &str, link: Option<&str>, ip: IpAddr, reason: &str) -> Result<(), String> {
+        let reason = clean_reason(reason);
+        if reason.is_empty() {
+            return Err("say what is wrong with the file".into());
+        }
+        let name = self.entry(file)?.meta.name.clone();
+        if !self.abuse.allow(ip, Action::Report, Instant::now()) {
+            return Err("too many reports from your address lately: try again in an hour".into());
+        }
+        self.reports.push(ReportInfo {
+            at: now(),
+            file: file.to_string(),
+            name,
+            link: link.unwrap_or_default().to_string(),
+            ip: ip.to_string(),
+            reason,
+        });
+        if self.reports.len() > MAX_REPORTS {
+            let extra = self.reports.len() - MAX_REPORTS;
+            self.reports.drain(..extra);
+        }
+        write_json(&self.root.join(REPORTS), &self.reports).map_err(|e| format!("couldn't keep the report: {e}"))?;
+        log::info!("event=report file={file} ip={ip}");
+        Ok(())
+    }
+}
diff --git a/apps/figcraft-server/src/store/journal.rs b/apps/figcraft-server/src/store/journal.rs
new file mode 100644
index 00000000..e3983543
--- /dev/null
+++ b/apps/figcraft-server/src/store/journal.rs
@@ -0,0 +1,270 @@
+use super::*;
+
+impl Store {
+    /// Whether `file` has room for about `n` more bytes: its cap, and for a file published
+    /// without the key its address's share and everyone's. A log that took it over its cap is
+    /// compacted first (the state may be smaller than its history).
+    pub(super) fn room_for(&mut self, file: &str, server: &Server, n: u64) -> Result<(), String> {
+        if let Some(why) = self.low_disk() {
+            return Err(why);
+        }
+        let max = self.cfg.max_file_bytes;
+        let over = |s: &Store| s.bytes(file).saturating_add(n) > max;
+        // A compaction to make room at most once a minute per file (it rewrites the whole file).
+        let t = now();
+        let may_compact = self.files.get(file).is_some_and(|e| {
+            t >= e.forced.saturating_add(FORCED_COMPACTION_EVERY) && e.log.as_ref().is_some_and(|l| l.entries > 0 || !l.pending.is_empty())
+        });
+        if over(self) && may_compact {
+            if let Some(e) = self.files.get_mut(file) {
+                e.forced = t;
+            }
+            self.compact(file, server);
+        }
+        if over(self) {
+            return Err(format!("this file has reached the server's limit of {} MiB: that change wasn't kept", max >> 20));
+        }
+        let h = &self.cfg.hosting;
+        let Some(ip) = self.files.get(file).filter(|e| e.meta.owner.is_some()).and_then(|e| e.meta.ip.clone()) else { return Ok(()) };
+        let (max_ip, max_all) = (h.max_bytes_per_ip, h.max_total_bytes);
+        for (times, _, used) in self.per_block(&ip) {
+            let cap = max_ip.saturating_mul(u64::from(times));
+            if used.saturating_add(n) > cap {
+                return Err(format!("the files published from this file's address have reached their {} MiB: that change wasn't kept", cap >> 20));
+            }
+        }
+        let used_all: u64 = self.files.keys().map(|id| self.bytes(id)).sum();
+        if used_all.saturating_add(n) > max_all {
+            return Err("this server is full: that change wasn't kept".into());
+        }
+        Ok(())
+    }
+
+    /// Load a file's session: its snapshot, then its log (a damaged end is dropped and reported).
+    pub(super) fn load(&mut self, file: &str) -> Result<Server, String> {
+        self.touch(file);
+        let dir = self.dir(file);
+        let (generation, state) = disk::decode_snapshot(&disk::read_capped(&dir.join(SNAPSHOT), self.snapshot_cap())?)?;
+        let mut server = Server::restore(state, "", self.cfg.core).map_err(|e| format!("the snapshot can't be used: {e}"))?;
+        let mut issues = Vec::new();
+        let mut fresh_log = true;
+        let mut kept = 0;
+        let log_path = dir.join(LOG);
+        // A log that's there but can't be read (an IO error, or over a lowered cap) may hold
+        // confirmed edits: the file isn't opened, and the log is left as it is for another try.
+        let read = match disk::read_capped(&log_path, self.cfg.max_file_bytes) {
+            Err(why) if log_path.exists() => return Err(format!("its log can't be read ({why}); it was left as it is")),
+            r => r,
+        };
+        // One that isn't a log is moved aside before a new one replaces it (or the file isn't opened).
+        let read = match read.map(|b| disk::read_log(&b)) {
+            Ok(Err(why)) => {
+                let aside = dir.join(format!("{LOG}.unreadable-{generation}-{}", now()));
+                fs::rename(&log_path, &aside).map_err(|e| format!("{why}, and it couldn't be moved aside ({e})"))?;
+                Err(format!("{why}; it was moved aside to {}", aside.display()))
+            }
+            Ok(Ok(log)) => Ok(log),
+            Err(why) => Err(why),
+        };
+        match read {
+            Ok(log) if log.generation == generation => {
+                fresh_log = false;
+                for entry in log.entries {
+                    if let Err(e) = server.replay(entry) {
+                        issues.push(format!("file {file}: its log stops making sense after {kept} entries ({e}); the rest was dropped"));
+                        fresh_log = true;
+                        break;
+                    }
+                    kept += 1;
+                }
+                if let Some(why) = log.damaged {
+                    issues.push(format!("file {file}: its log ended with {why}; that part was dropped"));
+                    fresh_log = true;
+                }
+            }
+            // From before a compaction that was cut short, the snapshot has it all; or a generation
+            // field damaged, which no checksum covers. Replaying tells them apart without trusting
+            // it: entries the snapshot holds are skipped, so only edits it lacks change anything.
+            Ok(log) => {
+                let before = server.seq();
+                let mut stopped = None;
+                for entry in log.entries {
+                    if let Err(e) = server.replay(entry) {
+                        stopped = Some(e);
+                        break;
+                    }
+                }
+                let (snap, found, recovered) = (generation, log.generation, server.seq().saturating_sub(before));
+                if recovered > 0 {
+                    issues.push(format!(
+                        "file {file}: its log's generation ({found}) doesn't match its snapshot's ({snap}), but it held \
+                         {recovered} changes the snapshot didn't; they were recovered"
+                    ));
+                }
+                if let Some(e) = stopped {
+                    issues.push(format!(
+                        "file {file}: its log's generation ({found}) doesn't match its snapshot's ({snap}) and it stops \
+                         making sense after {recovered} newer changes ({e}); the rest was dropped"
+                    ));
+                }
+            }
+            Err(why) => issues.push(format!("file {file}: {why}; starting a new log")),
+        }
+        for i in issues {
+            log::warn!("{i}");
+            self.note(i);
+        }
+        server.journaling(true);
+        let file_handle = OpenOptions::new().append(true).open(dir.join(LOG));
+        let log = match (fresh_log, file_handle) {
+            (false, Ok(f)) => {
+                let bytes = f.metadata().map_or(LOG_HEADER as u64, |m| m.len());
+                // Replayed entries make it worth compacting once everyone has left.
+                Log { generation, file: f, pending: Vec::new(), entries: kept, bytes, dirty: kept > 0 }
+            }
+            // A new snapshot and log of the next generation, so appends start clean.
+            _ => {
+                let next = generation.checked_add(1).ok_or("the file's generation can't go any higher")?;
+                self.rewrite(file, next, &server).map_err(|e| e.why)?
+            }
+        };
+        self.entry(file)?.log = Some(log);
+        Ok(server)
+    }
+
+    /// The largest snapshot read back: a file's cap plus room for what its state keeps beside the
+    /// document (recent batches for reconnecting clients, deletions), which may take it over.
+    pub(super) fn snapshot_cap(&self) -> u64 {
+        self.cfg.max_file_bytes.saturating_mul(2)
+    }
+
+    /// Write `server`'s state as snapshot `generation` and start an empty log of it.
+    fn rewrite(&mut self, file: &str, generation: u64, server: &Server) -> Result<Log, RewriteError> {
+        let dir = self.dir(file);
+        let kept = |why: String| RewriteError { why, snapshot_replaced: false };
+        let state = server.state().map_err(|e| kept(e.to_string()))?;
+        let bytes = disk::encode_snapshot(generation, &state).map_err(kept)?;
+        // Never replace a readable snapshot with one that can't be opened again: the old snapshot
+        // and log still hold everything.
+        if bytes.len() as u64 > self.snapshot_cap() {
+            return Err(kept(format!("the snapshot would be {} MiB, more than can be opened again", bytes.len() >> 20)));
+        }
+        if bytes.len() as u64 > self.cfg.max_file_bytes {
+            log::warn!("file {file} is {} MiB, over the {} MiB cap (kept anyway)", bytes.len() >> 20, self.cfg.max_file_bytes >> 20);
+        }
+        disk::write_atomic(&dir.join(SNAPSHOT), &bytes).map_err(|e| kept(format!("couldn't write the snapshot: {e}")))?;
+        // From here the old log no longer goes with the snapshot on disk.
+        let replaced = |why: String| RewriteError { why, snapshot_replaced: true };
+        disk::write_atomic(&dir.join(LOG), &disk::log_header(generation)).map_err(|e| replaced(format!("couldn't start the log: {e}")))?;
+        let f = OpenOptions::new().append(true).open(dir.join(LOG)).map_err(|e| replaced(format!("couldn't open the log: {e}")))?;
+        if let Ok(e) = self.entry(file) {
+            e.bytes = (bytes.len() + LOG_HEADER) as u64;
+            e.meta.seq = server.seq();
+            let meta = e.meta.clone();
+            if let Err(err) = write_json(&dir.join(META), &meta) {
+                log::warn!("file {file}: couldn't update {META}: {err}");
+            }
+        }
+        Ok(Log { generation, file: f, pending: Vec::new(), entries: 0, bytes: LOG_HEADER as u64, dirty: false })
+    }
+
+    /// Compactions so far.
+    pub fn compactions(&self) -> u64 {
+        self.compactions
+    }
+
+    /// Why nothing more may be written when the data directory's disk is nearly full (less free
+    /// than [`StoreConfig::min_free_bytes`]); looked up at most once a second. Where the free space
+    /// can't be told, nothing is refused.
+    pub(super) fn low_disk(&mut self) -> Option<String> {
+        let now = Instant::now();
+        let free = match self.free {
+            Some((at, free)) if now.saturating_duration_since(at) < std::time::Duration::from_secs(1) => free,
+            _ => {
+                let free = disk::free_bytes(&self.root);
+                self.free = Some((now, free));
+                free
+            }
+        };
+        free.filter(|f| *f < self.cfg.min_free_bytes)
+            .map(|_| "the server's disk is nearly full: it takes no changes or new files for now (tell its operator)".to_string())
+    }
+
+    /// Note a problem for the operator (logged too); only the latest [`MAX_PROBLEMS`] are kept.
+    pub(super) fn note(&mut self, problem: String) {
+        if self.problems.len() >= MAX_PROBLEMS {
+            self.problems.remove(0);
+        }
+        self.problems.push(problem);
+    }
+
+    /// Compact an open file: its state as the next snapshot, an empty log.
+    pub(super) fn compact(&mut self, file: &str, server: &Server) {
+        self.compactions += 1;
+        let Some(generation) = self.files.get(file).and_then(|e| e.log.as_ref()).map(|l| l.generation) else { return };
+        let Some(next) = generation.checked_add(1) else {
+            log::error!("file {file}: compaction failed: the file's generation can't go any higher");
+            return;
+        };
+        match self.rewrite(file, next, server) {
+            Ok(log) => {
+                if let Ok(e) = self.entry(file) {
+                    e.log = Some(log);
+                }
+                log::debug!("compacted file {file}");
+            }
+            // The new snapshot holds everything, but a restart would drop whatever is appended to
+            // the old log now (its generation no longer matches): the file closes, the hub hears
+            // it at the next flush, and it opens again from the new snapshot.
+            Err(RewriteError { why, snapshot_replaced: true }) => {
+                self.note(format!("file {file}: compaction was cut short ({why}); it was closed"));
+                log::error!("file {file}: compaction was cut short: {why}");
+                if let Some(e) = self.files.get_mut(file) {
+                    e.log = None;
+                }
+                self.cut_short.push(file.to_string());
+            }
+            // The old snapshot and log still hold everything: carry on appending.
+            Err(RewriteError { why, .. }) => log::error!("file {file}: compaction failed: {why}"),
+        }
+    }
+
+    /// Write and sync what's pending in every open log; the files whose log couldn't be written.
+    /// Those are closed here (their pending records dropped: nobody was told of them) and open
+    /// again from what is on disk.
+    pub(super) fn flush_all(&mut self) -> Vec<String> {
+        let mut failed = std::mem::take(&mut self.cut_short);
+        for (id, e) in &mut self.files {
+            if let Some(log) = e.log.as_mut() {
+                match flush_log(id, log) {
+                    Ok(n) => e.bytes += n,
+                    Err(()) => {
+                        e.log = None;
+                        failed.push(id.clone());
+                    }
+                }
+            }
+        }
+        failed
+    }
+}
+
+/// Write and sync a log's pending records: the bytes written, or `Err` when that failed (the log
+/// can't be trusted to hold them).
+pub(super) fn flush_log(id: &str, log: &mut Log) -> Result<u64, ()> {
+    if log.pending.is_empty() {
+        return Ok(0);
+    }
+    match log.file.write_all(&log.pending).and_then(|()| log.file.sync_data()) {
+        Ok(()) => {
+            let n = log.pending.len() as u64;
+            log.bytes += n;
+            log.pending.clear();
+            Ok(n)
+        }
+        Err(e) => {
+            log::error!("file {id}: couldn't write its log: {e}");
+            Err(())
+        }
+    }
+}
diff --git a/apps/figcraft-server/src/store/library.rs b/apps/figcraft-server/src/store/library.rs
new file mode 100644
index 00000000..adb592db
--- /dev/null
+++ b/apps/figcraft-server/src/store/library.rs
@@ -0,0 +1,161 @@
+use super::*;
+
+impl Store {
+    /// A file's team library for `ip`, unless its version is `have`; within what one address and
+    /// everyone may download (the size is known before anything is read).
+    pub(super) fn fetch_library(&mut self, ip: IpAddr, file: &str, have: Option<u64>) -> Result<LibraryReply, String> {
+        let (dir, max) = (self.dir(file), self.cfg.max_file_bytes);
+        let Some(lib) = self.entry(file)?.meta.library.clone() else { return Ok(LibraryReply::Empty) };
+        if have == Some(lib.version) {
+            return Ok(LibraryReply::Unchanged { version: lib.version });
+        }
+        let path = library_file(&dir, lib.version);
+        let size = fs::metadata(&path).map_or(0, |m| m.len());
+        let now = Instant::now();
+        if !self.abuse.allow(ip, Action::Download(usize::try_from(size).unwrap_or(usize::MAX)), now) || !self.served.take_n(now, size as f64) {
+            return Err(BUSY_DOWNLOADS.into());
+        }
+        Ok(LibraryReply::Library { version: lib.version, archive: disk::read_capped(&path, max)? })
+    }
+
+    /// Keep `archive` as a file's team library: it must read as a library (with the limits files
+    /// using it read it with), be the file's library if it has one, and be a newer version.
+    // shortcut: the archive is checked on the hub thread (other files' sessions wait meanwhile);
+    // move it to a worker if large libraries make that noticeable.
+    pub fn publish_library(&mut self, file: &str, archive: &[u8]) -> Result<u64, String> {
+        let max = self.cfg.max_file_bytes;
+        if self.cfg.hosting.open && self.entry(file)?.meta.owner.is_some() {
+            return Err(NO_PUBLIC_LIBRARY.into());
+        }
+        if archive.len() as u64 > max {
+            return Err(format!("the library is {} MiB; this server keeps files up to {} MiB", archive.len() >> 20, max >> 20));
+        }
+        // Everything it unpacks to counts against the same cap, so a small archive can't expand
+        // into a large library in memory.
+        let lib = match figcraft_format::read_library_within(Cursor::new(archive), max) {
+            Ok(Some(lib)) => lib,
+            Ok(None) => return Err("that isn't a published library".into()),
+            Err(e) => return Err(format!("the library can't be read: {e}")),
+        };
+        if lib.doc.node_count() > self.cfg.core.max_nodes {
+            return Err(format!("the library has more than {} layers", self.cfg.core.max_nodes));
+        }
+        let m = &lib.manifest;
+        let dir = self.dir(file);
+        let entry = self.entry(file)?;
+        if let Some(old) = &entry.meta.library {
+            if old.id != m.id {
+                return Err(format!("this file's library on the server is another one (\"{}\")", old.name));
+            }
+            if m.version <= old.version {
+                return Err(format!("version {} is on the server already: publish again to follow it", old.version));
+            }
+            // A jump would let a client use up the numbers and leave no newer version to publish.
+            if m.version > old.version.saturating_add(1) {
+                return Err(format!("version {} is too high: the next one after {} is {}", m.version, old.version, old.version.saturating_add(1)));
+            }
+        } else if m.version > MAX_FIRST_LIBRARY_VERSION {
+            return Err(format!("version {} is too high: a first publish goes up to {MAX_FIRST_LIBRARY_VERSION}", m.version));
+        }
+        // Each version has a file of its own, written before the description names it: a failed
+        // description write or a crash in between leaves the previous version served whole, never
+        // the new bytes under the old number.
+        let path = dir.join(library_name(m.version));
+        disk::write_atomic(&path, archive).map_err(|e| format!("couldn't keep the library: {e}"))?;
+        let before = entry.meta.library.replace(LibraryMeta { id: m.id.clone(), name: m.name.clone(), version: m.version });
+        if let Err(e) = write_json(&dir.join(META), &entry.meta) {
+            // Never served (the description doesn't name it); the next publish of it replaces it.
+            if let Err(r) = fs::remove_file(&path) {
+                log::warn!("file {file}: an unpublished library version couldn't be deleted: {r}");
+            }
+            entry.meta.library = before;
+            return Err(format!("couldn't keep the library: {e}"));
+        }
+        // The previous version isn't served any more.
+        if let Some(Err(e)) = before.map(|old| fs::remove_file(library_file(&dir, old.version))) {
+            log::warn!("file {file}: the previous library version couldn't be deleted: {e}");
+        }
+        log::info!("file {file}: published library version {} ({} bytes)", m.version, archive.len());
+        Ok(m.version)
+    }
+
+    /// A library's usage reports in memory (read from disk the first time; a damaged list starts
+    /// over: it is only statistics). `None` when the file has no library.
+    fn usage_of(&mut self, file: &str) -> Result<Option<&mut UsageCache>, String> {
+        if self.entry(file)?.meta.library.is_none() {
+            return Ok(None);
+        }
+        if !self.usage.contains_key(file) {
+            let path = self.dir(file).join(USAGE);
+            let list = if path.exists() {
+                disk::read_capped(&path, MAX_USAGE_FILE).ok().and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default()
+            } else {
+                Vec::new()
+            };
+            self.usage.insert(file.to_string(), UsageCache { list, dirty: false, written: now() });
+        }
+        Ok(self.usage.get_mut(file))
+    }
+
+    /// The usage reports kept for a file's library (none when it has no library).
+    pub fn library_usage(&mut self, file: &str) -> Result<Vec<FileUsage>, String> {
+        Ok(self.usage_of(file)?.map(|u| u.list.clone()).unwrap_or_default())
+    }
+
+    /// Keep how one file uses a file's library (in memory; written when it changed, at most every
+    /// [`USAGE_WRITE_EVERY`] seconds).
+    pub fn report_usage(&mut self, file: &str, usage: Usage) -> Result<(), String> {
+        let name = clean_name(&usage.file);
+        if name.is_empty() {
+            return Ok(());
+        }
+        let mut components: Vec<_> = usage.components.into_iter().filter(|(_, n)| *n > 0).take(MAX_REPORTED * 4).collect();
+        components.sort();
+        components.dedup_by_key(|c| c.0);
+        components.truncate(MAX_REPORTED);
+        let Some(u) = self.usage_of(file)? else { return Ok(()) };
+        match u.list.iter_mut().find(|f| f.usage.file == name) {
+            Some(f) if f.usage.components == components => return Ok(()),
+            Some(f) => {
+                f.usage.components = components;
+                f.updated = now();
+            }
+            None => u.list.push(FileUsage { usage: Usage { file: name, components }, updated: now() }),
+        }
+        if u.list.len() > MAX_USERS {
+            u.list.sort_by_key(|f| std::cmp::Reverse(f.updated));
+            u.list.truncate(MAX_USERS);
+        }
+        u.dirty = true;
+        if now() >= u.written.saturating_add(USAGE_WRITE_EVERY) {
+            self.write_usage(false);
+        }
+        Ok(())
+    }
+
+    /// Write the usage reports that changed (`all`: whenever they were last written).
+    pub(super) fn write_usage(&mut self, all: bool) {
+        let t = now();
+        let root = self.root.join(FILES);
+        for (file, u) in &mut self.usage {
+            if u.dirty && (all || t >= u.written.saturating_add(USAGE_WRITE_EVERY)) {
+                if let Err(e) = write_json(&root.join(file).join(USAGE), &u.list) {
+                    log::warn!("file {file}: library usage couldn't be kept: {e}");
+                }
+                (u.dirty, u.written) = (false, t);
+            }
+        }
+    }
+}
+
+/// The name of the file holding version `version` of a file's team library.
+pub fn library_name(version: u64) -> String {
+    format!("library-{version}.bin")
+}
+
+/// Where version `version` of the team library in `dir` is: its own file, or `library.bin` for a
+/// version published before each version had one.
+fn library_file(dir: &Path, version: u64) -> PathBuf {
+    let path = dir.join(library_name(version));
+    if path.exists() { path } else { dir.join(LIBRARY) }
+}
diff --git a/apps/figcraft-server/src/store/links.rs b/apps/figcraft-server/src/store/links.rs
new file mode 100644
index 00000000..ad30f458
--- /dev/null
+++ b/apps/figcraft-server/src/store/links.rs
@@ -0,0 +1,154 @@
+use super::*;
+
+impl Store {
+    /// The files kept.
+    pub fn list(&self, open: &dyn Fn(&str) -> Option<OpenFile>) -> Vec<FileInfo> {
+        self.files.iter().map(|(id, e)| self.info(id, e, open(id))).collect()
+    }
+
+    /// A file's links.
+    pub fn links(&mut self, file: &str) -> Result<Vec<LinkInfo>, String> {
+        Ok(self.entry(file)?.links.iter().map(|l| l.info(file)).collect())
+    }
+
+    /// A new link to a file.
+    pub fn create_link(&mut self, file: &str, access: Access, label: &str) -> Result<NewLink, String> {
+        let max = self.cfg.max_links;
+        let path = self.dir(file).join(LINKS);
+        let entry = self.entry(file)?;
+        if entry.links.len() >= max {
+            return Err(format!("a file has at most {max} links: revoke one first"));
+        }
+        let (link, token) = new_link(access, &clean_name(label), now())?;
+        entry.links.push(link.clone());
+        if let Err(e) = write_json(&path, &entry.links) {
+            entry.links.pop();
+            return Err(format!("couldn't keep the link: {e}"));
+        }
+        Ok(NewLink { link: link.info(file), token })
+    }
+
+    /// The link of `entry` whose token `token` is (every link is compared, in constant time, so
+    /// timing doesn't tell which one matched).
+    pub(super) fn link_of(entry: &Entry, token: &str) -> Option<usize> {
+        let presented = hash(token);
+        let mut found = None;
+        for (i, l) in entry.links.iter().enumerate() {
+            if same_secret(&presented, &l.hash) {
+                found = Some(i);
+            }
+        }
+        found
+    }
+
+    /// These join codes no longer open anything: typing one says so.
+    fn forget_codes(&mut self, codes: impl IntoIterator<Item = Sealed>) {
+        self.gone_codes.extend(codes.into_iter().map(|c| c.hash));
+        let extra = self.gone_codes.len().saturating_sub(MAX_GONE_CODES);
+        self.gone_codes.drain(..extra);
+    }
+
+    /// Where the link with the join code `key` is: its file, its place among the file's links
+    /// and its token (every code is compared, so timing doesn't tell which one matched).
+    fn find_code(&self, key: &codes::Key) -> Option<(String, usize, String)> {
+        let mut found = None;
+        for (id, e) in &self.files {
+            for (i, l) in e.links.iter().enumerate() {
+                if let Some(token) = l.code.as_ref().and_then(|c| key.open(c)) {
+                    found = Some((id.clone(), i, token));
+                }
+            }
+        }
+        found
+    }
+
+    /// A new join code for the link of `file` whose token is `token` (it takes the place of the
+    /// link's earlier code): the code, shown this once.
+    pub fn set_code(&mut self, file: &str, token: &str) -> Result<String, String> {
+        let at = Self::link_of(self.entry(file)?, token).ok_or("that token isn't one of this file's links (it may have been revoked)")?;
+        // 45 random bits: one already in use is all but impossible, and never handed out twice.
+        let (code, key) = loop {
+            let code = codes::new_code()?;
+            let key = codes::Key::new(&code);
+            if self.find_code(&key).is_none() {
+                break (code, key);
+            }
+        };
+        let sealed = key.seal(token)?;
+        let path = self.dir(file).join(LINKS);
+        let entry = self.entry(file)?;
+        let link = entry.links.get_mut(at).ok_or("that file has no such link")?;
+        let before = link.code.replace(sealed);
+        let id = link.id.clone();
+        if let Err(e) = write_json(&path, &entry.links) {
+            if let Some(l) = entry.links.get_mut(at) {
+                l.code = before;
+            }
+            return Err(format!("couldn't keep the join code: {e}"));
+        }
+        self.forget_codes(before);
+        log::info!("event=code file={file} link={id}");
+        Ok(code)
+    }
+
+    /// The file a join code typed at `ip` opens, and its link's token; wrong codes count against
+    /// the address (see `abuse`), and nothing is looked up for an address that is locked out.
+    pub fn resolve_code(&mut self, ip: IpAddr, typed: &str) -> Result<(String, String), String> {
+        let now = Instant::now();
+        if let Some(left) = self.abuse.code_locked(ip, now) {
+            return Err(format!(
+                "Too many wrong codes from your address: try again in {} minutes, or join with the invite link",
+                left.as_secs() / 60 + 1
+            ));
+        }
+        if !self.abuse.allow(ip, Action::Code, now) {
+            return Err("Too many codes tried from your address: wait a minute and try again".into());
+        }
+        if !self.abuse.codes_open(now) {
+            return Err(CODES_BUSY.into());
+        }
+        // Anything that isn't a code's symbols is a wrong code too (and costs no hashing).
+        let key = figcraft_collab::code::normalize(typed).ok().filter(|c| c.len() == figcraft_collab::code::ONLINE_LEN).map(|c| codes::Key::new(&c));
+        let found = key.as_ref().and_then(|k| self.find_code(k));
+        self.abuse.code_tried(ip, found.is_some(), now);
+        match found {
+            Some((file, _, token)) => {
+                log::info!("event=code_used file={file} ip={ip}");
+                Ok((file, token))
+            }
+            None => {
+                let gone = key.is_some_and(|k| self.gone_codes.iter().any(|g| g == k.hash()));
+                Err(if gone { CODE_GONE } else { NO_CODE }.into())
+            }
+        }
+    }
+
+    /// Revoke a link.
+    pub fn revoke(&mut self, file: &str, link: &str) -> Result<(), String> {
+        let path = self.dir(file).join(LINKS);
+        let entry = self.entry(file)?;
+        let at = entry.links.iter().position(|l| l.id == link).ok_or("that file has no such link")?;
+        let gone = entry.links.remove(at);
+        if let Err(e) = write_json(&path, &entry.links) {
+            entry.links.insert(at, gone);
+            return Err(format!("couldn't revoke the link: {e}"));
+        }
+        log::info!("revoked link {link} of file {file}");
+        self.forget_codes(gone.code);
+        Ok(())
+    }
+
+    /// Remove a file and its links for good. `Err` when its folder couldn't be deleted (it is no
+    /// longer served either way).
+    pub fn remove(&mut self, file: &str) -> Result<(), String> {
+        // Closed first: an open log would keep the folder from being deleted on Windows.
+        let entry = self.files.remove(file).ok_or("this file isn't on the server (it may have been removed)")?;
+        self.forget_codes(entry.links.iter().filter_map(|l| l.code.clone()));
+        drop(entry);
+        let dir = self.dir(file);
+        fs::remove_dir_all(&dir)
+            .map_err(|e| format!("it is no longer served, but its folder {} couldn't be deleted ({e}); delete it by hand", dir.display()))?;
+        log::info!("removed file {file}");
+        Ok(())
+    }
+}

From f664a8209394faf12fc211fba4ff8e4282647080 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:50 +0000
Subject: [PATCH 51/67] refactor(engine): move assets/library_swap test files
 to assets/library_swap/

---
 crates/engine/src/assets/library_swap.rs                         | 1 -
 .../src/assets/{library_swap_tests.rs => library_swap/tests.rs}  | 0
 2 files changed, 1 deletion(-)
 rename crates/engine/src/assets/{library_swap_tests.rs => library_swap/tests.rs} (100%)

diff --git a/crates/engine/src/assets/library_swap.rs b/crates/engine/src/assets/library_swap.rs
index de709b10..1220d24c 100644
--- a/crates/engine/src/assets/library_swap.rs
+++ b/crates/engine/src/assets/library_swap.rs
@@ -245,5 +245,4 @@ pub fn swap_library(doc: &mut Document, from: &str, to: &PublishedLibrary) -> Re
 }
 
 #[cfg(test)]
-#[path = "library_swap_tests.rs"]
 mod tests;
diff --git a/crates/engine/src/assets/library_swap_tests.rs b/crates/engine/src/assets/library_swap/tests.rs
similarity index 100%
rename from crates/engine/src/assets/library_swap_tests.rs
rename to crates/engine/src/assets/library_swap/tests.rs

From 3398ec3c8c40186658c4ba619cbee712223c5b7b Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:50 +0000
Subject: [PATCH 52/67] refactor(engine): move automation/file_access test
 files to automation/file_access/

---
 crates/engine/src/automation/file_access.rs                      | 1 -
 .../automation/{file_access_tests.rs => file_access/tests.rs}    | 0
 2 files changed, 1 deletion(-)
 rename crates/engine/src/automation/{file_access_tests.rs => file_access/tests.rs} (100%)

diff --git a/crates/engine/src/automation/file_access.rs b/crates/engine/src/automation/file_access.rs
index 7a8ab8c9..f741e21c 100644
--- a/crates/engine/src/automation/file_access.rs
+++ b/crates/engine/src/automation/file_access.rs
@@ -306,5 +306,4 @@ pub fn create_dir_all(path: impl AsRef<Path>) -> Result<()> {
 }
 
 #[cfg(test)]
-#[path = "file_access_tests.rs"]
 mod tests;
diff --git a/crates/engine/src/automation/file_access_tests.rs b/crates/engine/src/automation/file_access/tests.rs
similarity index 100%
rename from crates/engine/src/automation/file_access_tests.rs
rename to crates/engine/src/automation/file_access/tests.rs

From 32bd9dc35a81d684ba2bd7ddce5a6d651043c769 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:50 +0000
Subject: [PATCH 53/67] refactor(engine): move fonts test files to fonts/

---
 crates/engine/src/fonts.rs                           | 1 -
 crates/engine/src/{fonts_tests.rs => fonts/tests.rs} | 0
 2 files changed, 1 deletion(-)
 rename crates/engine/src/{fonts_tests.rs => fonts/tests.rs} (100%)

diff --git a/crates/engine/src/fonts.rs b/crates/engine/src/fonts.rs
index bdda411c..dee5d1f7 100644
--- a/crates/engine/src/fonts.rs
+++ b/crates/engine/src/fonts.rs
@@ -160,5 +160,4 @@ pub fn specs() -> Vec<CommandSpec> {
 }
 
 #[cfg(test)]
-#[path = "fonts_tests.rs"]
 mod tests;
diff --git a/crates/engine/src/fonts_tests.rs b/crates/engine/src/fonts/tests.rs
similarity index 100%
rename from crates/engine/src/fonts_tests.rs
rename to crates/engine/src/fonts/tests.rs

From 9c97cb6e1777c53aa04a2a55b965250c33aa9ba9 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:50 +0000
Subject: [PATCH 54/67] refactor(engine): move assets/library_server test files
 to assets/library_server/

---
 crates/engine/src/assets/library_server.rs                       | 1 -
 .../assets/{library_server_tests.rs => library_server/tests.rs}  | 0
 2 files changed, 1 deletion(-)
 rename crates/engine/src/assets/{library_server_tests.rs => library_server/tests.rs} (100%)

diff --git a/crates/engine/src/assets/library_server.rs b/crates/engine/src/assets/library_server.rs
index 10852b5f..b9dbce47 100644
--- a/crates/engine/src/assets/library_server.rs
+++ b/crates/engine/src/assets/library_server.rs
@@ -212,5 +212,4 @@ impl Session {
 }
 
 #[cfg(test)]
-#[path = "library_server_tests.rs"]
 mod tests;
diff --git a/crates/engine/src/assets/library_server_tests.rs b/crates/engine/src/assets/library_server/tests.rs
similarity index 100%
rename from crates/engine/src/assets/library_server_tests.rs
rename to crates/engine/src/assets/library_server/tests.rs

From 7d70e0bfe5f2f0a4210a409335bf04d7cc6aff6f Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:50 +0000
Subject: [PATCH 55/67] refactor(engine): move assets/library test files to
 assets/library/

---
 crates/engine/src/assets/library.rs                             | 1 -
 crates/engine/src/assets/{library_tests.rs => library/tests.rs} | 0
 2 files changed, 1 deletion(-)
 rename crates/engine/src/assets/{library_tests.rs => library/tests.rs} (100%)

diff --git a/crates/engine/src/assets/library.rs b/crates/engine/src/assets/library.rs
index 40d6b3ca..56b0fc07 100644
--- a/crates/engine/src/assets/library.rs
+++ b/crates/engine/src/assets/library.rs
@@ -1331,5 +1331,4 @@ pub fn published_variables(lib: &PublishedLibrary) -> impl Iterator<Item = &Vari
 }
 
 #[cfg(test)]
-#[path = "library_tests.rs"]
 mod tests;
diff --git a/crates/engine/src/assets/library_tests.rs b/crates/engine/src/assets/library/tests.rs
similarity index 100%
rename from crates/engine/src/assets/library_tests.rs
rename to crates/engine/src/assets/library/tests.rs

From 2576e646a13c4d0eb04dc6c905979f761e62f21a Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:50 +0000
Subject: [PATCH 56/67] refactor(engine): move sharing/background test files to
 sharing/background/

---
 crates/engine/src/sharing/background.rs                          | 1 -
 .../src/sharing/{background_tests.rs => background/tests.rs}     | 0
 2 files changed, 1 deletion(-)
 rename crates/engine/src/sharing/{background_tests.rs => background/tests.rs} (100%)

diff --git a/crates/engine/src/sharing/background.rs b/crates/engine/src/sharing/background.rs
index aa2eef0f..1a29c2d1 100644
--- a/crates/engine/src/sharing/background.rs
+++ b/crates/engine/src/sharing/background.rs
@@ -148,5 +148,4 @@ impl Session {
 }
 
 #[cfg(test)]
-#[path = "background_tests.rs"]
 mod tests;
diff --git a/crates/engine/src/sharing/background_tests.rs b/crates/engine/src/sharing/background/tests.rs
similarity index 100%
rename from crates/engine/src/sharing/background_tests.rs
rename to crates/engine/src/sharing/background/tests.rs

From 0330a7cc856c91745fdf484b6d5f804068209dd8 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 57/67] refactor(engine): move assets/components test files to
 assets/components/

---
 crates/engine/src/assets/components.rs                          | 2 --
 .../rebase_source_tests.rs}                                     | 0
 .../src/assets/{components_tests.rs => components/tests.rs}     | 0
 3 files changed, 2 deletions(-)
 rename crates/engine/src/assets/{components_rebase_source_tests.rs => components/rebase_source_tests.rs} (100%)
 rename crates/engine/src/assets/{components_tests.rs => components/tests.rs} (100%)

diff --git a/crates/engine/src/assets/components.rs b/crates/engine/src/assets/components.rs
index 07389419..3932efff 100644
--- a/crates/engine/src/assets/components.rs
+++ b/crates/engine/src/assets/components.rs
@@ -295,9 +295,7 @@ pub fn prop_default_value(d: &PropDef) -> Value {
 }
 
 #[cfg(test)]
-#[path = "components_rebase_source_tests.rs"]
 mod rebase_source_tests;
 
 #[cfg(test)]
-#[path = "components_tests.rs"]
 pub(crate) mod tests;
diff --git a/crates/engine/src/assets/components_rebase_source_tests.rs b/crates/engine/src/assets/components/rebase_source_tests.rs
similarity index 100%
rename from crates/engine/src/assets/components_rebase_source_tests.rs
rename to crates/engine/src/assets/components/rebase_source_tests.rs
diff --git a/crates/engine/src/assets/components_tests.rs b/crates/engine/src/assets/components/tests.rs
similarity index 100%
rename from crates/engine/src/assets/components_tests.rs
rename to crates/engine/src/assets/components/tests.rs

From 9ca6e1a82f4c9d900a020ce0b922ea453fd45f83 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 58/67] refactor(ui-egui): move bidi test files to bidi/

---
 crates/ui-egui/src/bidi.rs                               | 1 -
 crates/ui-egui/src/{rtl_names_tests.rs => bidi/tests.rs} | 0
 2 files changed, 1 deletion(-)
 rename crates/ui-egui/src/{rtl_names_tests.rs => bidi/tests.rs} (100%)

diff --git a/crates/ui-egui/src/bidi.rs b/crates/ui-egui/src/bidi.rs
index 0c7bf99e..dffd4955 100644
--- a/crates/ui-egui/src/bidi.rs
+++ b/crates/ui-egui/src/bidi.rs
@@ -70,5 +70,4 @@ pub fn script_fallbacks(have: &dyn Fn(char) -> bool, taken: &mut Vec<Arc<figcraf
 }
 
 #[cfg(test)]
-#[path = "rtl_names_tests.rs"]
 mod tests;
diff --git a/crates/ui-egui/src/rtl_names_tests.rs b/crates/ui-egui/src/bidi/tests.rs
similarity index 100%
rename from crates/ui-egui/src/rtl_names_tests.rs
rename to crates/ui-egui/src/bidi/tests.rs

From a1308e1c1a2616d3baccd9add55e91983ca22de9 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 59/67] refactor(ui-egui): move dialogs/credits test files to
 dialogs/credits/

---
 crates/ui-egui/src/dialogs/credits.rs                            | 1 -
 .../src/dialogs/{credits_tests.rs => credits/ui_tests.rs}        | 0
 2 files changed, 1 deletion(-)
 rename crates/ui-egui/src/dialogs/{credits_tests.rs => credits/ui_tests.rs} (100%)

diff --git a/crates/ui-egui/src/dialogs/credits.rs b/crates/ui-egui/src/dialogs/credits.rs
index bce5822c..90df5ee3 100644
--- a/crates/ui-egui/src/dialogs/credits.rs
+++ b/crates/ui-egui/src/dialogs/credits.rs
@@ -648,5 +648,4 @@ mod tests {
 }
 
 #[cfg(test)]
-#[path = "credits_tests.rs"]
 mod ui_tests;
diff --git a/crates/ui-egui/src/dialogs/credits_tests.rs b/crates/ui-egui/src/dialogs/credits/ui_tests.rs
similarity index 100%
rename from crates/ui-egui/src/dialogs/credits_tests.rs
rename to crates/ui-egui/src/dialogs/credits/ui_tests.rs

From d436103fca691eaffbdb7038a5e7a6b6543d88bb Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 60/67] refactor(ui-egui): move i18n test files to i18n/

---
 crates/ui-egui/src/i18n.rs                          | 1 -
 crates/ui-egui/src/{i18n_tests.rs => i18n/tests.rs} | 0
 2 files changed, 1 deletion(-)
 rename crates/ui-egui/src/{i18n_tests.rs => i18n/tests.rs} (100%)

diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs
index 2ae15293..621a5005 100644
--- a/crates/ui-egui/src/i18n.rs
+++ b/crates/ui-egui/src/i18n.rs
@@ -241,5 +241,4 @@ fn label<'a>(menu: bool, id: &str, english: &'a str) -> Cow<'a, str> {
 }
 
 #[cfg(test)]
-#[path = "i18n_tests.rs"]
 mod tests;
diff --git a/crates/ui-egui/src/i18n_tests.rs b/crates/ui-egui/src/i18n/tests.rs
similarity index 100%
rename from crates/ui-egui/src/i18n_tests.rs
rename to crates/ui-egui/src/i18n/tests.rs

From 8f2f93cd0b71e553cbebd07ad98b1a7f4839df4e Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 61/67] refactor(ui-egui): move canvas test files to canvas/

---
 crates/ui-egui/src/canvas.rs                          | 2 --
 crates/ui-egui/src/{ => canvas}/builder_poly_tests.rs | 0
 crates/ui-egui/src/{ => canvas}/zoom_preview_tests.rs | 0
 3 files changed, 2 deletions(-)
 rename crates/ui-egui/src/{ => canvas}/builder_poly_tests.rs (100%)
 rename crates/ui-egui/src/{ => canvas}/zoom_preview_tests.rs (100%)

diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index 9ef65cba..faf10528 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -360,9 +360,7 @@ fn describe_box([x0, y0, x1, y1]: [f64; 4]) -> String {
 }
 
 #[cfg(test)]
-#[path = "builder_poly_tests.rs"]
 mod builder_poly_tests;
 
 #[cfg(test)]
-#[path = "zoom_preview_tests.rs"]
 mod zoom_preview_tests;
diff --git a/crates/ui-egui/src/builder_poly_tests.rs b/crates/ui-egui/src/canvas/builder_poly_tests.rs
similarity index 100%
rename from crates/ui-egui/src/builder_poly_tests.rs
rename to crates/ui-egui/src/canvas/builder_poly_tests.rs
diff --git a/crates/ui-egui/src/zoom_preview_tests.rs b/crates/ui-egui/src/canvas/zoom_preview_tests.rs
similarity index 100%
rename from crates/ui-egui/src/zoom_preview_tests.rs
rename to crates/ui-egui/src/canvas/zoom_preview_tests.rs

From aca3643b188f06d4e7d0eef949b4773197c556d0 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 62/67] refactor(ui-egui): move control test files to control/

---
 crates/ui-egui/src/control.rs                                   | 2 --
 .../src/{control_capture_tests.rs => control/capture_tests.rs}  | 0
 .../src/{control_roots_tests.rs => control/roots_tests.rs}      | 0
 3 files changed, 2 deletions(-)
 rename crates/ui-egui/src/{control_capture_tests.rs => control/capture_tests.rs} (100%)
 rename crates/ui-egui/src/{control_roots_tests.rs => control/roots_tests.rs} (100%)

diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index 97e62d1f..afef387d 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -1461,9 +1461,7 @@ fn pointer(app: &mut FigApp, p: &Value) -> Result<Value, String> {
 }
 
 #[cfg(test)]
-#[path = "control_roots_tests.rs"]
 mod roots_tests;
 
 #[cfg(test)]
-#[path = "control_capture_tests.rs"]
 mod capture_tests;
diff --git a/crates/ui-egui/src/control_capture_tests.rs b/crates/ui-egui/src/control/capture_tests.rs
similarity index 100%
rename from crates/ui-egui/src/control_capture_tests.rs
rename to crates/ui-egui/src/control/capture_tests.rs
diff --git a/crates/ui-egui/src/control_roots_tests.rs b/crates/ui-egui/src/control/roots_tests.rs
similarity index 100%
rename from crates/ui-egui/src/control_roots_tests.rs
rename to crates/ui-egui/src/control/roots_tests.rs

From 990742c32e63e0af856ba267f96adb9a9f2751a0 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 63/67] refactor(ui-egui): move present test files to present/

---
 crates/ui-egui/src/present.rs                                | 5 -----
 .../behaviour_tests.rs}                                      | 0
 .../src/{present_delay_tests.rs => present/delay_tests.rs}   | 0
 .../overlay_anchor_tests.rs}                                 | 0
 .../src/{present_tail_tests.rs => present/tail_tests.rs}     | 0
 .../variables_tests.rs}                                      | 0
 6 files changed, 5 deletions(-)
 rename crates/ui-egui/src/{present_behaviour_tests.rs => present/behaviour_tests.rs} (100%)
 rename crates/ui-egui/src/{present_delay_tests.rs => present/delay_tests.rs} (100%)
 rename crates/ui-egui/src/{present_overlay_anchor_tests.rs => present/overlay_anchor_tests.rs} (100%)
 rename crates/ui-egui/src/{present_tail_tests.rs => present/tail_tests.rs} (100%)
 rename crates/ui-egui/src/{present_variables_tests.rs => present/variables_tests.rs} (100%)

diff --git a/crates/ui-egui/src/present.rs b/crates/ui-egui/src/present.rs
index 20e22cb1..64a3b70a 100644
--- a/crates/ui-egui/src/present.rs
+++ b/crates/ui-egui/src/present.rs
@@ -441,23 +441,18 @@ pub fn anchored_overlay_rect(
 }
 
 #[cfg(test)]
-#[path = "present_variables_tests.rs"]
 mod variables_tests;
 
 #[cfg(test)]
-#[path = "present_behaviour_tests.rs"]
 mod behaviour_tests;
 
 #[cfg(test)]
-#[path = "present_tail_tests.rs"]
 mod tail_tests;
 
 #[cfg(test)]
-#[path = "present_delay_tests.rs"]
 mod delay_tests;
 
 #[cfg(test)]
-#[path = "present_overlay_anchor_tests.rs"]
 mod overlay_anchor_tests;
 
 #[cfg(test)]
diff --git a/crates/ui-egui/src/present_behaviour_tests.rs b/crates/ui-egui/src/present/behaviour_tests.rs
similarity index 100%
rename from crates/ui-egui/src/present_behaviour_tests.rs
rename to crates/ui-egui/src/present/behaviour_tests.rs
diff --git a/crates/ui-egui/src/present_delay_tests.rs b/crates/ui-egui/src/present/delay_tests.rs
similarity index 100%
rename from crates/ui-egui/src/present_delay_tests.rs
rename to crates/ui-egui/src/present/delay_tests.rs
diff --git a/crates/ui-egui/src/present_overlay_anchor_tests.rs b/crates/ui-egui/src/present/overlay_anchor_tests.rs
similarity index 100%
rename from crates/ui-egui/src/present_overlay_anchor_tests.rs
rename to crates/ui-egui/src/present/overlay_anchor_tests.rs
diff --git a/crates/ui-egui/src/present_tail_tests.rs b/crates/ui-egui/src/present/tail_tests.rs
similarity index 100%
rename from crates/ui-egui/src/present_tail_tests.rs
rename to crates/ui-egui/src/present/tail_tests.rs
diff --git a/crates/ui-egui/src/present_variables_tests.rs b/crates/ui-egui/src/present/variables_tests.rs
similarity index 100%
rename from crates/ui-egui/src/present_variables_tests.rs
rename to crates/ui-egui/src/present/variables_tests.rs

From e1e5b4bbe3f489f3c94cd1251666e0ae3c103bc8 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 64/67] refactor(ui-egui): move widgets/style_picker test files
 to widgets/style_picker/

---
 crates/ui-egui/src/widgets/style_picker.rs                       | 1 -
 .../src/widgets/{style_picker_tests.rs => style_picker/tests.rs} | 0
 2 files changed, 1 deletion(-)
 rename crates/ui-egui/src/widgets/{style_picker_tests.rs => style_picker/tests.rs} (100%)

diff --git a/crates/ui-egui/src/widgets/style_picker.rs b/crates/ui-egui/src/widgets/style_picker.rs
index d29d33ba..f97dfeb9 100644
--- a/crates/ui-egui/src/widgets/style_picker.rs
+++ b/crates/ui-egui/src/widgets/style_picker.rs
@@ -1273,5 +1273,4 @@ pub fn local_styles(app: &mut FigApp, ui: &mut Ui, doc: &Document) {
 }
 
 #[cfg(test)]
-#[path = "style_picker_tests.rs"]
 mod tests;
diff --git a/crates/ui-egui/src/widgets/style_picker_tests.rs b/crates/ui-egui/src/widgets/style_picker/tests.rs
similarity index 100%
rename from crates/ui-egui/src/widgets/style_picker_tests.rs
rename to crates/ui-egui/src/widgets/style_picker/tests.rs

From c9d6b356fc826c5df8c919e5b51dd31105b67554 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 65/67] refactor(format): move fig/map test files to fig/map/

---
 crates/format/src/fig/map.rs                                    | 2 --
 .../connector_snapshot_budget_tests.rs}                         | 0
 .../{map_image_filter_tests.rs => map/image_filter_tests.rs}    | 0
 3 files changed, 2 deletions(-)
 rename crates/format/src/fig/{map_connector_snapshot_budget_tests.rs => map/connector_snapshot_budget_tests.rs} (100%)
 rename crates/format/src/fig/{map_image_filter_tests.rs => map/image_filter_tests.rs} (100%)

diff --git a/crates/format/src/fig/map.rs b/crates/format/src/fig/map.rs
index 5f82cb9f..06cfdb8b 100644
--- a/crates/format/src/fig/map.rs
+++ b/crates/format/src/fig/map.rs
@@ -84,7 +84,6 @@ pub(super) fn to_rest(msg: &Kv, name: &str, max_nodes: usize) -> (Value, Vec<Str
 }
 
 #[cfg(test)]
-#[path = "map_image_filter_tests.rs"]
 mod image_filter_tests;
 
 /// REST importer warnings reworded for a `.fig` import (`None`: drop it).
@@ -110,7 +109,6 @@ fn guid(v: &Kv) -> Option<String> {
 }
 
 #[cfg(test)]
-#[path = "map_connector_snapshot_budget_tests.rs"]
 mod connector_snapshot_budget_tests;
 
 /// A `GUID`-holding reference (`StyleId`, `VariableID`, …): its `guid`.
diff --git a/crates/format/src/fig/map_connector_snapshot_budget_tests.rs b/crates/format/src/fig/map/connector_snapshot_budget_tests.rs
similarity index 100%
rename from crates/format/src/fig/map_connector_snapshot_budget_tests.rs
rename to crates/format/src/fig/map/connector_snapshot_budget_tests.rs
diff --git a/crates/format/src/fig/map_image_filter_tests.rs b/crates/format/src/fig/map/image_filter_tests.rs
similarity index 100%
rename from crates/format/src/fig/map_image_filter_tests.rs
rename to crates/format/src/fig/map/image_filter_tests.rs

From 52d89286cf1a2ddcdfd2040880f7d9a18139ad4c Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:09:51 +0000
Subject: [PATCH 66/67] refactor(collab-net): move hub test files to hub/

---
 crates/collab-net/src/hub.rs                     | 3 ---
 crates/collab-net/src/{ => hub}/barred_tests.rs  | 0
 crates/collab-net/src/{ => hub}/preauth_tests.rs | 0
 crates/collab-net/src/{ => hub}/queue_tests.rs   | 0
 4 files changed, 3 deletions(-)
 rename crates/collab-net/src/{ => hub}/barred_tests.rs (100%)
 rename crates/collab-net/src/{ => hub}/preauth_tests.rs (100%)
 rename crates/collab-net/src/{ => hub}/queue_tests.rs (100%)

diff --git a/crates/collab-net/src/hub.rs b/crates/collab-net/src/hub.rs
index d45041a5..363ecae0 100644
--- a/crates/collab-net/src/hub.rs
+++ b/crates/collab-net/src/hub.rs
@@ -763,13 +763,10 @@ pub(crate) fn to_local(inbox: &Inbox, local: u32, msg: &ServerMsg) {
 }
 
 #[cfg(test)]
-#[path = "queue_tests.rs"]
 mod queue_tests;
 
 #[cfg(test)]
-#[path = "barred_tests.rs"]
 mod barred_tests;
 
 #[cfg(test)]
-#[path = "preauth_tests.rs"]
 mod preauth_tests;
diff --git a/crates/collab-net/src/barred_tests.rs b/crates/collab-net/src/hub/barred_tests.rs
similarity index 100%
rename from crates/collab-net/src/barred_tests.rs
rename to crates/collab-net/src/hub/barred_tests.rs
diff --git a/crates/collab-net/src/preauth_tests.rs b/crates/collab-net/src/hub/preauth_tests.rs
similarity index 100%
rename from crates/collab-net/src/preauth_tests.rs
rename to crates/collab-net/src/hub/preauth_tests.rs
diff --git a/crates/collab-net/src/queue_tests.rs b/crates/collab-net/src/hub/queue_tests.rs
similarity index 100%
rename from crates/collab-net/src/queue_tests.rs
rename to crates/collab-net/src/hub/queue_tests.rs

From 60c671da66ddcf3ee27252ecbd901ef133f292c0 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:16:58 +0000
Subject: [PATCH 67/67] docs: update source paths for the layout moves

---
 docs/boards-parity.md           |  2 +-
 docs/collab-protocol.md         |  2 +-
 docs/components-parity.md       |  2 +-
 docs/egui-037-migration-plan.md | 14 +++++++-------
 docs/gaps.md                    |  4 ++--
 docs/mcp.md                     |  2 +-
 docs/prototyping-parity.md      |  6 +++---
 7 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/docs/boards-parity.md b/docs/boards-parity.md
index fcf44627..69526a18 100644
--- a/docs/boards-parity.md
+++ b/docs/boards-parity.md
@@ -49,7 +49,7 @@ all end with the same geometry.
 | Timer music, timer sounds | missing | |
 | Voting sessions | done | one at a time: votes per person (1–99), on every object, on sticky notes or on the selection; a click on an object places a vote (several on one object allowed), a click on your badge or an Alt-click takes it back; your own votes show as badges while it runs, everyone's once it ends, with a ranked list (ties share a rank) that selects an object from its row; Clear results. `board.vote {action: start\|cast\|retract\|end\|clear}`, `board.voteResults`. Ballots sync per voter (keyed by the live-session client id, or your name offline), so people voting at once never overwrite each other. Not undo steps |
 | Voting: only the facilitator ends or clears it, who voted for what | missing | anyone who can edit the board can end or clear a vote; results are counts only |
-| Board widgets | missing | design-file widgets exist (`crates/engine/src/widgets.rs`), not wired to boards |
+| Board widgets | missing | design-file widgets exist (`crates/engine/src/extensions/widgets.rs`), not wired to boards |
 | Templates (retrospective, brainstorm, flow chart…) | partial | five built-in templates drawn up for FigCraft (retrospective, brainstorm, weekly planner, flow chart, kanban board), placed from the toolbar's templates picker (each with a picture of itself) or `board.template {name, x?, y?}` as ordinary sections, stickies, shapes, connectors and text in one undo step; `board.templates` lists them. No community templates, no saving your own |
 | Tables | partial | `board.table {rows, columns, cells?, x?, y?}` (at most 50 × 20): an auto layout frame of rows of cells with text, a tinted header row and lines between rows and columns; a cell's row grows with its text; a double-click types in the cell under the pointer; add or remove a row or column from the bar over the selection or `board.tableEdit {id, action, index?}`; undoable and synced in live sessions. No column resizing by dragging, no cell colours, no Tab between cells, no CSV paste |
 | Mind maps | missing | |
diff --git a/docs/collab-protocol.md b/docs/collab-protocol.md
index 641a7040..2dfbbb6f 100644
--- a/docs/collab-protocol.md
+++ b/docs/collab-protocol.md
@@ -107,7 +107,7 @@ fit FigCraft's architecture:
   back with their ids (the server accepts re-creating deleted ids). Merging a branch whose new
   layers, styles, variables or comments lie in another id space (one made offline or in an earlier
   session) is refused by the app before anything is sent, since the server would refuse it (see
-  `crates/engine/src/branches.rs`).
+  `crates/engine/src/sharing/branches.rs`).
 - Objects inside an entry are not separate objects: modes are part of their collection, a
   variable's values per mode part of the variable and replies part of their comment thread. Two
   people adding a mode to the same collection, editing different modes of one variable, or replying
diff --git a/docs/components-parity.md b/docs/components-parity.md
index aeb1e50d..18083632 100644
--- a/docs/components-parity.md
+++ b/docs/components-parity.md
@@ -4,7 +4,7 @@
 
 Design systems are why teams adopt Figma. **Components: breadth ~96%, ready ~72%. Styles and
 variables: breadth ~95%, ready ~76% (estimated).** QA'd with a synthetic design system of ~300
-components used 2,000 times (`crates/engine/src/synthetic_ds.rs`, `components_scale_tests.rs`);
+components used 2,000 times (`crates/engine/src/content/synthetic_ds.rs`, `components_scale_tests.rs`);
 not with real libraries. Remaining: 4–10 h here, plus team libraries' tail (4–8 h, partly after
 accounts).
 
diff --git a/docs/egui-037-migration-plan.md b/docs/egui-037-migration-plan.md
index 93fd815b..5bdfa188 100644
--- a/docs/egui-037-migration-plan.md
+++ b/docs/egui-037-migration-plan.md
@@ -157,7 +157,7 @@ Entry points:
 - Headless/UI tests: `Context::default().run_ui(...)` in many `crates/ui-egui/src/*_tests.rs`
   files; `crates/ui-egui/src/idle_tests.rs` has the frame/idle harness; `windows_tests.rs` has the
   `run_logic` hidden-window harness.
-- Render/control: `crates/ui-egui/src/render_worker.rs`; `crates/ui-egui/src/control.rs`.
+- Render/control: `crates/ui-egui/src/canvas/render_worker.rs`; `crates/ui-egui/src/control.rs`.
 
 Build/test entry points:
 
@@ -217,8 +217,8 @@ deadline work merely because a pass index is nonzero.
 | `crates/ui-egui/src/control.rs:119`, `idle_tests.rs:275` | `egui::UserData` not found | Removed with the callback API |
 | `crates/ui-egui/src/control.rs:367` + 11 test files | `Event::MouseWheel` missing field `source` | Add `MouseWheelSource` |
 | `crates/ui-egui/src/dialogs.rs:108` | `Role::SelectableLabel` not found | 0.37 keeps deprecated `pub type WidgetType = Role`; only renamed variants such as `SelectableLabel` are gone. Map to `Role::Button` |
-| `crates/ui-egui/src/frame_labels.rs:63` | non-exhaustive match missing `Shape::Band` | Add the 0.37 shape variant |
-| `crates/ui-egui/src/typography.rs:1312` | `ScrollArea` state `offset` private | Use `clamped_offset()` |
+| `crates/ui-egui/src/canvas/frame_labels.rs:63` | non-exhaustive match missing `Shape::Band` | Add the 0.37 shape variant |
+| `crates/ui-egui/src/panels/typography.rs:1312` | `ScrollArea` state `offset` private | Use `clamped_offset()` |
 | Many files | `Id::new`/`Ui::id()` deprecation warnings | CI clippy `-D warnings` turns these into failures; replace mechanically |
 
 `clip_rect_margin` is not removed in 0.37; it remains as a deprecated unused field. Remove its use
@@ -254,7 +254,7 @@ by egui/default fonts; leaving any of them on crates.io creates mixed egui-famil
 `egui_glow` only if a glow build is introduced. If a crate is not resolved in the final graph,
 remove its patch row and record the `cargo tree` evidence.
 
-`egui_extras` must be patched because `crates/ui-egui/src/credits.rs` uses
+`egui_extras` must be patched because `crates/ui-egui/src/dialogs/credits.rs` uses
 `TableBuilder`/`TableRow`/`TableBody`; a 0.36 `egui_extras` would pull a second egui 0.36.
 
 `craft-window` is a git dependency, not a path patch. Pin it to the final craft-libs revision whose
@@ -373,10 +373,10 @@ Optional new provenance patches, only if measurements require them:
 | 63 uses, e.g. `tabs.rs`, `layers.rs`, `right.rs`, `widgets.rs` | `ui.id()` | `ui.scope_id()` | Renamed; same scope ID |
 | any `UiBuilder::new().id(...)` (none found now) | `.id(id)` | `.scope_id(id)` | Deprecated; verify by grep after codemod |
 | `crates/ui-egui/src/dialogs.rs` `tab_strip` | `WidgetType::SelectableLabel` | `egui::Role::Button` | `WidgetType` survives as deprecated `pub type WidgetType = Role`; only `SelectableLabel` is gone |
-| `crates/ui-egui/src/credits.rs` `sort_header` | `WidgetType::Button`/`Label` | `egui::Role::Button`/`Role::Label` | Same mapping; aliases may compile but should not produce warnings |
+| `crates/ui-egui/src/dialogs/credits.rs` `sort_header` | `WidgetType::Button`/`Label` | `egui::Role::Button`/`Role::Label` | Same mapping; aliases may compile but should not produce warnings |
 | `crates/ui-egui/src/control.rs` `ui.input` scroll branch; 11 test files | `Event::MouseWheel { unit, delta, phase, modifiers }` | add `source: egui::MouseWheelSource` | Use `Wheel` for synthetic wheel input, `Unknown` where unspecified |
-| `crates/ui-egui/src/frame_labels.rs` `turn` | exhaustive `Shape` match | add `Shape::Band(_)` | 0.37 `BandShape`; label drawing never adds one, leave it unchanged with a comment or rotate via its `angle` if a Band ever appears |
-| `crates/ui-egui/src/typography.rs` `font_picker` | `shown.state.offset.y` | `shown.state.clamped_offset().y` | `State::offset` private/deprecated; `clamped_offset` is the drawn position |
+| `crates/ui-egui/src/canvas/frame_labels.rs` `turn` | exhaustive `Shape` match | add `Shape::Band(_)` | 0.37 `BandShape`; label drawing never adds one, leave it unchanged with a comment or rotate via its `angle` if a Band ever appears |
+| `crates/ui-egui/src/panels/typography.rs` `font_picker` | `shown.state.offset.y` | `shown.state.clamped_offset().y` | `State::offset` private/deprecated; `clamped_offset` is the drawn position |
 | `crates/ui-egui/src/control.rs` `PendingShot`/`drain` | polls `Event::Screenshot` | capture-slot callback | API removed; see 6.3 |
 | tests in `idle_tests.rs` | synthetic `Event::Screenshot` | complete a test capture slot | API removed |
 
diff --git a/docs/gaps.md b/docs/gaps.md
index f020bf67..edc18dc3 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -131,7 +131,7 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
 - **Missing:** a corpus of real documents (design systems, app screens, prototypes) imported and
   compared with Figma's own PNG/SVG/PDF exports.
 - **Evidence:** every corpus in the repo is synthetic (`crates/svg/tests/corpus`, the synthetic
-  design system in `crates/engine/src/synthetic_ds.rs`). Scores were self-graded by the agents that
+  design system in `crates/engine/src/content/synthetic_ds.rs`). Scores were self-graded by the agents that
   built the features.
 - **Impact:** unknown fidelity in auto layout sizing, text metrics, effects and component
   resolution on real files; the numbers in this repo can't be trusted beyond "estimated" until it
@@ -362,7 +362,7 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
   API) and takes `ui.input {gamepad}` on the control channel; widgets react to clicks in a
   presented prototype, on the prototype's own copy; `proto.evaluate` computes expressions (mode
   lookups included) where a layer's interaction would run (`crates/engine/src/proto_tail_tests.rs`,
-  `crates/ui-egui/src/present_tail_tests.rs`, `crates/format/src/rest/gamepad_tests.rs`).
+  `crates/ui-egui/src/present/tail_tests.rs`, `crates/format/src/rest/gamepad_tests.rs`).
 - **Missing:** video triggers (on media hit/end) and play/pause/mute/seek actions (the REST
   importer warns and skips them, `crates/format/src/rest/proto.rs`); controllers on macOS, Linux
   and FreeBSD (the usual Rust controller library links libudev on Linux; a pure-Rust reader per
diff --git a/docs/mcp.md b/docs/mcp.md
index cddc761a..05dfd1e6 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -60,7 +60,7 @@ Each may be given more than once, as `--flag DIR` or `--flag=DIR`:
 - The roots must be existing folders: a missing one, or a file, stops the server at startup.
   `initialize`'s `instructions` name the folders, so the agent knows where it may work.
 - **What is covered:** everything a call does, because the engine reaches the file system through
-  one module (`crates/engine/src/file_access.rs`), and `crates/engine/clippy.toml` refuses `std::fs`
+  one module (`crates/engine/src/automation/file_access.rs`), and `crates/engine/clippy.toml` refuses `std::fs`
   anywhere else in the engine, so a command added later is covered too. That is `open_file` (and the
   `variables` file it may name), `save_file`, `export {path}`, and through `run_command` / `batch`
   every command that names a file: `file.open`, `file.openRecent` (recent files outside the roots
diff --git a/docs/prototyping-parity.md b/docs/prototyping-parity.md
index 6929aec6..6c7b2437 100644
--- a/docs/prototyping-parity.md
+++ b/docs/prototyping-parity.md
@@ -7,10 +7,10 @@ media control, every transition and easing exist; key/gamepad triggers take cont
 read from controllers on Windows and in the browser. Every rule of the public
 documentation on triggers, actions, overlays, animations, easing, scrolling and interactive
 components is a test case with what it implies (`crates/engine/src/proto_behaviour_tests.rs`, 7
-tests on the model, and `crates/ui-egui/src/present_behaviour_tests.rs`, 14 tests driving the
+tests on the model, and `crates/ui-egui/src/present/behaviour_tests.rs`, 14 tests driving the
 player, 21 gestures among them; presentation tabs: `crates/ui-egui/src/present_tab_tests.rs`, 6
 tests; the tail: `crates/engine/src/proto_tail_tests.rs`, 4 tests, and
-`crates/ui-egui/src/present_tail_tests.rs`, 5 tests), and all pass. Not yet checked against
+`crates/ui-egui/src/present/tail_tests.rs`, 5 tests), and all pass. Not yet checked against
 larger real prototypes. Remaining: 2–5 h.
 
 | Group | Figma | FigCraft | Missing |
@@ -105,7 +105,7 @@ tool; opt-in), **silent** (the documentation doesn't say; the case pins the curr
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-10-24 | patch | The Triggers row's Missing column no longer lists delays on mouse enter, leave, down and up, which landed on 2026-10-13 (`crates/engine/src/proto_delay_tests.rs`, `crates/ui-egui/src/present_delay_tests.rs`). Numbers unchanged |
+| 2026-10-24 | patch | The Triggers row's Missing column no longer lists delays on mouse enter, leave, down and up, which landed on 2026-10-13 (`crates/engine/src/proto_delay_tests.rs`, `crates/ui-egui/src/present/delay_tests.rs`). Numbers unchanged |
 | 2026-10-24 | patch | Open link to a website first shows a notice that it leaves the prototype, with the link, Open link, Cancel and "Don't show this again", which the desktop app saves with its preferences and the web build keeps until the page reloads (`proto.linkNotice` turns the notice back on); a second link to a website that fires while the notice shows is dropped, and a mail link still opens. Before, the player opened the link at once, also from an After delay trigger. Numbers unchanged |
 | 2026-10-23 | patch | A top-level frame taller (or wider) than the device's screen scrolls with no overflow setting, as Figma's documentation says; before, "No scrolling" frames such as the landing page template's Phone frame only clipped. Content past a frame's own edges still scrolls only as its overflow allows. Checked in the app on macOS. Numbers unchanged |
 | 2026-10-22 | minor | Change to, set variable and set variable mode lay out what they change in the player as the canvas does: text sizes to what it shows and hugging frames follow (an instance with a longer label changed to the main's width; a bound text kept its old size). Two player tests. Breadth and ready unchanged. |