From 4e4bf54bb6b9168b7e61a393b10d8099d14555a1 Mon Sep 17 00:00:00 2001
From: Cody Campbell <framecodechaos@gmail.com>
Date: Sun, 18 Oct 2026 18:53:32 -0400
Subject: [PATCH 1/5] M1: smart-selection drag reordering

---
 ROADMAP.md                                    |   2 +
 crates/engine/src/cmd/arrange.rs              |  49 +++++
 crates/engine/src/lib.rs                      |   3 +
 crates/engine/src/selection_reorder.rs        | 107 ++++++++++
 crates/engine/src/selection_reorder_tests.rs  | 152 ++++++++++++++
 crates/engine/src/tests.rs                    |   3 +
 crates/ui-egui/locales/en.toml                |   1 +
 crates/ui-egui/locales/es.toml                |   2 +
 crates/ui-egui/src/selection_spacing.rs       | 192 ++++++++++++++----
 crates/ui-egui/src/selection_spacing_tests.rs | 128 ++++++++++++
 docs/gaps.md                                  |   6 +-
 docs/parity-checklist.md                      |   4 +-
 docs/target-app-parity.md                     |   5 +-
 docs/ui-parity.md                             |   5 +-
 14 files changed, 607 insertions(+), 52 deletions(-)
 create mode 100644 crates/engine/src/selection_reorder.rs
 create mode 100644 crates/engine/src/selection_reorder_tests.rs

diff --git a/ROADMAP.md b/ROADMAP.md
index 8a587286..1c3db7e4 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -131,6 +131,8 @@ Ranked; detail and milestones in [`docs/roadmap.md`](docs/roadmap.md).
 
 ## Progress log
 
+- **2026-10-18** · Smart-selection drag reordering (M1): Smart-selection center rings insert a layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl-drag swaps entries. Unequal sizes reflow with the original gaps, hierarchy and selection stay intact, and each drag is one undo step. Escape or Undo during the drag cancels; switching documents, pages or tools rolls back the owning gesture. Mixed gaps, incomplete grids and unsupported selections keep spacing controls without reorder rings. Multiple marked items and irregular-grid insertion remain unimplemented. Engine and raw-input UI regression tests; desktop Linux before/during/after screenshots and insertion, undo/redo and Escape checked on synthetic cards. No side-by-side comparison with the incumbent. Headline estimates unchanged. Validation: 1,039 engine unit tests passed (2 ignored), 555 UI unit tests passed (1 ignored); formatting, layering, assets, parity and `cargo xtask wasm` passed. Clippy passes with only the existing `collapsible_match` findings suppressed; strict `cargo xtask ci` stops on seven findings in unchanged UI files. The workspace test run stops on the unchanged text crate’s `tail_tests::hanging_punctuation_outside_the_aligned_edge` (2 lines instead of 1); no text code changed.
+
 - **2026-10-17** · Control channel while the window is minimised (M8, #720): a minimised or covered window answers every request that acts on the app's state (edits, `ui.inspect`, `ui.pointer`, `ui.key`, `ui.type`, `ui.set`, `app.quit`…) without drawing, and what needs a drawn frame (`ui.screenshot`, `ui.input`, `window.new`) is an error at once; before, those waited up to 60 s and held up every later request on the connection (an attached agent's `inspect_ui` or window screenshot stalled until the window came back). Measured on Windows 11, minimised: requests ~100 ms each (eframe wakes a minimised window at most ten times a second; ~2 ms on screen), a window screenshot fails in ~100 ms instead of 60 s, idle CPU 0. Numbers unchanged.
 - **2026-10-17** · Number variables on text content (M3, #629): the Typography section's variable picker also lists number variables for a text layer's content, as the engine already accepted (the text shows the number, e.g. 42.5, and follows the variable). Other text fields keep their own types. Numbers unchanged.
 - **2026-10-17** · Frames and sections convert into each other (M1, #719): `object.convertToSection` turns a frame on the page or in a section into a section in place (same box, name, fill and layers, which stay where they are; what only a frame has goes: auto layout, clipping, layout grids, guides, scrolling), and `object.convertToFrame` now also turns a section into a frame that keeps its fill and doesn't clip, so the look stays. Nested frames, instances, main components and sections holding sections are refused with the reason; one undo step each. Both are in the canvas context menu (Convert to section / Convert to frame) and in Spanish. Numbers unchanged.
diff --git a/crates/engine/src/cmd/arrange.rs b/crates/engine/src/cmd/arrange.rs
index ad6c21d1..3b4d2b26 100644
--- a/crates/engine/src/cmd/arrange.rs
+++ b/crates/engine/src/cmd/arrange.rs
@@ -27,6 +27,13 @@ pub fn specs() -> Vec<CommandSpec> {
             spacing
         ),
         spec!("arrange.tidy", "Tidy up", "{ids?, spacing?}", true, tidy),
+        spec!(
+            "arrange.reorder",
+            "Reorder selection",
+            "{ids?, source, target, swap?, fromGesture?} (insert at target's visual slot; no hierarchy changes)",
+            true,
+            reorder
+        ),
         spec!("arrange.packH", "Pack horizontal", "{ids?}", true, |s, p| pack(s, p, true)),
         spec!("arrange.packV", "Pack vertical", "{ids?}", true, |s, p| pack(s, p, false)),
         spec!("arrange.roundToPixels", "Round to pixels", "{ids?}", true, round_px),
@@ -554,6 +561,48 @@ pub(crate) fn resize_cmd(s: &mut Session, p: &Value) -> Result<Value> {
     ok()
 }
 
+/// Reorder visual slots without rebuilding or reparenting layers.
+fn reorder(s: &mut Session, p: &Value) -> Result<Value> {
+    let cmd = "arrange.reorder";
+    let ids = req_targets(cmd, s, p)?;
+    let source = req_id(cmd, p, "source")?;
+    let target = req_id(cmd, p, "target")?;
+    let ds = s.ds()?;
+    let base = ds.interaction.as_ref().filter(|_| boolean(p, "fromGesture") == Some(true)).map(|i| i.doc.clone()).unwrap_or_else(|| ds.doc.clone());
+    let layout =
+        crate::selection_reorder::ReorderLayout::new(&base, &ids).ok_or_else(|| bad(cmd, "select a regular row, column or complete aligned grid"))?;
+    let positions = layout
+        .positions(source, target, boolean(p, "swap") == Some(true))
+        .ok_or_else(|| bad(cmd, "source and target must belong to the selection"))?;
+    // Validate every delta before editing; absolute targets always come from the gesture's
+    // snapshot so crossing several slots and returning to the start does not accumulate edits.
+    let doc = s.doc()?;
+    let mut moves = Vec::new();
+    for (id, at) in positions {
+        let now = doc.world_bounds(id).ok_or_else(|| bad(cmd, "layer is no longer available"))?;
+        let (dx, dy) = (at.x - now.x0, at.y - now.y0);
+        if !dx.is_finite() || !dy.is_finite() {
+            return Err(bad(cmd, "non-finite reorder result"));
+        }
+        if dx.abs() > 1e-9 || dy.abs() > 1e-9 {
+            let node = doc.get(id)?;
+            let parent = node.parent.map(|p| doc.world_transform(p)).unwrap_or(Affine::IDENTITY);
+            let transform = parent.inverse() * Affine::translate((dx, dy)) * parent * node.transform;
+            if !transform.as_coeffs().iter().all(|v| v.is_finite()) {
+                return Err(bad(cmd, "non-finite local transform"));
+            }
+            moves.push((id, dx, dy));
+        }
+    }
+    if !moves.is_empty() {
+        let doc = s.doc_mut()?;
+        for (id, dx, dy) in moves {
+            move_world(doc, id, dx, dy)?;
+        }
+    }
+    ok()
+}
+
 /// Set the distances between smart-selection tracks without rebuilding/reparenting the layers.
 fn spacing(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = req_targets("arrange.spacing", s, p)?;
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 312c2e87..c3c53c35 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -49,6 +49,7 @@ 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;
@@ -1838,5 +1839,7 @@ mod view_behaviour_tests;
 #[cfg(test)]
 mod widgets_tests;
 
+#[cfg(test)]
+mod selection_reorder_tests;
 #[cfg(test)]
 mod selection_spacing_tests;
diff --git a/crates/engine/src/selection_reorder.rs b/crates/engine/src/selection_reorder.rs
new file mode 100644
index 00000000..e538fc8b
--- /dev/null
+++ b/crates/engine/src/selection_reorder.rs
@@ -0,0 +1,107 @@
+//! Geometry for reordering a smart selection. Only regular, non-overlapping rows, columns
+//! and complete top-left-aligned grids have unambiguous insertion slots.
+//! Behavior reference: https://help.figma.com/hc/en-us/articles/360040450233
+//! (public documentation only; multi-item marking and irregular grids remain out of scope).
+use figcraft_doc::{Document, NodeId};
+use figcraft_geom::{Point, Rect};
+
+use crate::selection_spacing::selection_spacing;
+
+#[derive(Clone, Debug)]
+pub struct ReorderLayout {
+    /// Visual order, independent of selection order and layer stacking.
+    pub slots: Vec<(NodeId, Rect)>,
+    columns: usize,
+    rows: usize,
+    gap_x: f64,
+    gap_y: f64,
+}
+
+impl ReorderLayout {
+    pub fn new(doc: &Document, ids: &[NodeId]) -> Option<Self> {
+        let layout = selection_spacing(doc, ids);
+        let h = layout.horizontal.as_ref();
+        let v = layout.vertical.as_ref();
+        let gap = |axis: Option<&crate::selection_spacing::Axis>| match axis {
+            Some(a) => a.value.filter(|v| *v >= 0.0),
+            None => Some(0.0),
+        };
+        let (gap_x, gap_y) = (gap(h)?, gap(v)?);
+        let columns = h.map_or(1, |a| a.tracks.len());
+        let rows = v.map_or(1, |a| a.tracks.len());
+        if ids.len() < 2 || columns.checked_mul(rows)? != ids.len() {
+            return None;
+        }
+        let mut cells = std::collections::BTreeMap::new();
+        for id in ids {
+            let col = match h {
+                Some(a) => a.tracks.iter().position(|t| t.ids.contains(id))?,
+                None => 0,
+            };
+            let row = match v {
+                Some(a) => a.tracks.iter().position(|t| t.ids.contains(id))?,
+                None => 0,
+            };
+            let b = doc.world_bounds(*id)?;
+            if columns > 1 && rows > 1 {
+                let x = h?.tracks.get(col)?.bounds.x0;
+                let y = v?.tracks.get(row)?.bounds.y0;
+                if (b.x0 - x).abs() > 0.01 || (b.y0 - y).abs() > 0.01 {
+                    return None;
+                }
+            }
+            if cells.insert((row, col), (*id, b)).is_some() {
+                return None;
+            }
+        }
+        Some(Self { slots: cells.into_values().collect(), columns, rows, gap_x, gap_y })
+    }
+
+    /// Insertion shifts intervening items; swapping exchanges just two entries. Sizes and
+    /// original gaps are retained, so unequal-sized layers reflow instead of overlapping.
+    pub fn positions(&self, source: NodeId, target: NodeId, swap: bool) -> Option<Vec<(NodeId, Point)>> {
+        let from = self.slots.iter().position(|(id, _)| *id == source)?;
+        let to = self.slots.iter().position(|(id, _)| *id == target)?;
+        if from == to {
+            return Some(self.slots.iter().map(|(id, b)| (*id, Point::new(b.x0, b.y0))).collect());
+        }
+        let mut order = self.slots.clone();
+        if swap {
+            order.swap(from, to);
+        } else {
+            let item = order.remove(from);
+            order.insert(to, item);
+        }
+        let mut widths = vec![0.0_f64; self.columns];
+        let mut heights = vec![0.0_f64; self.rows];
+        for (i, (_, b)) in order.iter().enumerate() {
+            let w = widths.get_mut(i % self.columns)?;
+            *w = w.max(b.width());
+            let h = heights.get_mut(i / self.columns)?;
+            *h = h.max(b.height());
+        }
+        let x0 = self.slots.iter().map(|(_, b)| b.x0).fold(f64::INFINITY, f64::min);
+        let y0 = self.slots.iter().map(|(_, b)| b.y0).fold(f64::INFINITY, f64::min);
+        let starts = |sizes: &[f64], mut at: f64, gap: f64| {
+            sizes
+                .iter()
+                .map(|size| {
+                    let start = at;
+                    at += size + gap;
+                    start
+                })
+                .collect::<Vec<_>>()
+        };
+        let xs = starts(&widths, x0, self.gap_x);
+        let ys = starts(&heights, y0, self.gap_y);
+        order
+            .iter()
+            .enumerate()
+            .map(|(i, (id, b))| {
+                let x = if self.columns == 1 { b.x0 } else { *xs.get(i % self.columns)? };
+                let y = if self.rows == 1 { b.y0 } else { *ys.get(i / self.columns)? };
+                Some((*id, Point::new(x, y)))
+            })
+            .collect()
+    }
+}
diff --git a/crates/engine/src/selection_reorder_tests.rs b/crates/engine/src/selection_reorder_tests.rs
new file mode 100644
index 00000000..83ae5b31
--- /dev/null
+++ b/crates/engine/src/selection_reorder_tests.rs
@@ -0,0 +1,152 @@
+use crate::{Session, selection_reorder::ReorderLayout};
+use figcraft_doc::NodeId;
+use serde_json::json;
+
+fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64, parent: Option<NodeId>) -> NodeId {
+    NodeId(s.execute("shape.rectangle", &json!({"x":x,"y":y,"width":w,"height":h,"parent":parent})).unwrap()["id"].as_u64().unwrap())
+}
+fn xy(s: &Session, id: NodeId) -> (f64, f64) {
+    let b = s.doc().unwrap().world_bounds(id).unwrap();
+    (b.x0, b.y0)
+}
+
+#[test]
+fn insertion_reflows_unequal_sizes_with_original_gaps_and_hierarchy() {
+    for vertical in [false, true] {
+        let mut s = Session::new();
+        let mut ids = vec![];
+        for (at, size) in [(0., 40.), (50., 60.), (120., 20.)] {
+            ids.push(rect(
+                &mut s,
+                if vertical { 0. } else { at },
+                if vertical { at } else { 0. },
+                if vertical { 30. } else { size },
+                if vertical { size } else { 30. },
+                None,
+            ));
+        }
+        let before = s.doc().unwrap().clone();
+        // Explicit selection order must not determine visual order.
+        s.execute("arrange.reorder", &json!({"ids":[ids[2],ids[0],ids[1]],"source":ids[0],"target":ids[2]})).unwrap();
+        for (id, at) in [(ids[1], 0.), (ids[2], 70.), (ids[0], 100.)] {
+            assert_eq!(xy(&s, id), if vertical { (0., at) } else { (at, 0.) });
+            let old = before.node(id).unwrap();
+            let new = s.doc().unwrap().node(id).unwrap();
+            assert_eq!((new.width, new.height, new.parent), (old.width, old.height, old.parent));
+        }
+        assert_eq!(s.doc().unwrap().node(s.ds().unwrap().page).unwrap().children, before.node(s.ds().unwrap().page).unwrap().children);
+        s.undo().unwrap();
+        assert_eq!(s.doc().unwrap(), &before);
+        s.redo().unwrap();
+        assert_eq!(xy(&s, ids[0]), if vertical { (0., 100.) } else { (100., 0.) });
+    }
+}
+
+#[test]
+fn grids_insert_across_rows_and_swap_only_the_two_entries() {
+    let mut s = Session::new();
+    let mut ids = vec![];
+    for row in 0..2 {
+        for col in 0..3 {
+            ids.push(rect(&mut s, col as f64 * 70., row as f64 * 60., 50., 40., None));
+        }
+    }
+    let before = s.doc().unwrap().clone();
+    s.execute("arrange.reorder", &json!({"ids":ids,"source":ids[0],"target":ids[4]})).unwrap();
+    assert_eq!(xy(&s, ids[0]), (70., 60.));
+    assert_eq!(xy(&s, ids[3]), (140., 0.));
+    assert_eq!(xy(&s, ids[5]), (140., 60.));
+    s.undo().unwrap();
+    s.execute("arrange.reorder", &json!({"ids":ids,"source":ids[0],"target":ids[4],"swap":true})).unwrap();
+    assert_eq!(xy(&s, ids[0]), (70., 60.));
+    assert_eq!(xy(&s, ids[4]), (0., 0.));
+    for id in [ids[1], ids[2], ids[3], ids[5]] {
+        assert_eq!(s.doc().unwrap().node(id), before.node(id));
+    }
+}
+
+#[test]
+fn grid_reflow_keeps_gaps_with_different_sizes() {
+    let mut s = Session::new();
+    let a = rect(&mut s, 0., 0., 40., 30., None);
+    let b = rect(&mut s, 50., 0., 60., 30., None);
+    let c = rect(&mut s, 0., 50., 40., 50., None);
+    let d = rect(&mut s, 50., 50., 60., 50., None);
+    s.execute("arrange.reorder", &json!({"ids":[a,b,c,d],"source":a,"target":d})).unwrap();
+    assert_eq!(xy(&s, b), (0., 0.));
+    assert_eq!(xy(&s, c), (70., 0.));
+    assert_eq!(xy(&s, d), (0., 70.));
+    assert_eq!(xy(&s, a), (70., 70.));
+}
+
+#[test]
+fn previews_are_absolute_and_returning_to_start_is_a_noop() {
+    let mut s = Session::new();
+    let ids: Vec<_> = (0..3).map(|i| rect(&mut s, i as f64 * 70., 0., 50., 40., None)).collect();
+    s.execute("select.set", &json!({"ids":ids})).unwrap();
+    let before = s.doc().unwrap().clone();
+    let history = s.undo_depth().0;
+    s.begin_interaction("Reorder selection").unwrap();
+    for target in [ids[2], ids[1], ids[0]] {
+        s.execute("arrange.reorder", &json!({"ids":ids,"source":ids[0],"target":target,"fromGesture":true})).unwrap();
+    }
+    s.commit_interaction().unwrap();
+    assert_eq!(s.doc().unwrap(), &before);
+    assert_eq!(s.undo_depth().0, history);
+    s.begin_interaction("Reorder selection").unwrap();
+    for target in [ids[1], ids[2]] {
+        s.execute("arrange.reorder", &json!({"ids":ids,"source":ids[0],"target":target,"fromGesture":true})).unwrap();
+    }
+    s.commit_interaction().unwrap();
+    assert_eq!(s.undo_depth().0, history + 1);
+    assert_eq!(s.selection(), ids);
+    s.undo().unwrap();
+    assert_eq!(s.doc().unwrap(), &before);
+}
+
+#[test]
+fn invalid_selections_and_targets_do_not_edit_the_document() {
+    let mut s = Session::new();
+    let a = rect(&mut s, 0., 0., 50., 40., None);
+    let b = rect(&mut s, 70., 0., 50., 40., None);
+    let c = rect(&mut s, 160., 0., 50., 40., None);
+    for args in [
+        json!({"ids":[a,b,c],"source":a,"target":b}), // Mixed gaps.
+        json!({"ids":[a,b],"source":c,"target":b}),
+        json!({"ids":[a,b],"source":a,"target":999999}),
+        json!({"ids":[a,a,b],"source":a,"target":b}),
+        json!({"ids":[a,b],"source":[],"target":b}),
+    ] {
+        let before = s.doc().unwrap().clone();
+        assert!(s.execute("arrange.reorder", &args).is_err());
+        assert_eq!(s.doc().unwrap(), &before);
+    }
+    for props in [json!({"locked":true}), json!({"visible":false})] {
+        s.execute("node.set", &json!({"id":b,"props":props})).unwrap();
+        assert!(ReorderLayout::new(s.doc().unwrap(), &[a, b]).is_none());
+        s.execute("node.set", &json!({"id":b,"props":{"locked":false,"visible":true}})).unwrap();
+    }
+    let d = rect(&mut s, 0., 70., 50., 40., None);
+    assert!(ReorderLayout::new(s.doc().unwrap(), &[a, b, d]).is_none(), "an incomplete grid has no slots");
+    let frame =
+        NodeId(s.execute("frame.create", &json!({"width":300,"height":100,"props":{"layout":"horizontal"}})).unwrap()["id"].as_u64().unwrap());
+    let x = rect(&mut s, 0., 0., 50., 40., Some(frame));
+    let y = rect(&mut s, 70., 0., 50., 40., Some(frame));
+    assert!(ReorderLayout::new(s.doc().unwrap(), &[x, y]).is_none());
+    assert!(ReorderLayout::new(s.doc().unwrap(), &[a, x]).is_none());
+}
+
+#[test]
+fn reordering_children_of_a_rotated_parent_uses_page_coordinates() {
+    let mut s = Session::new();
+    let frame = NodeId(
+        s.execute("frame.create", &json!({"x":200,"y":200,"width":300,"height":100,"props":{"rotation":90}})).unwrap()["id"].as_u64().unwrap(),
+    );
+    let a = rect(&mut s, 0., 0., 50., 40., Some(frame));
+    let b = rect(&mut s, 70., 0., 50., 40., Some(frame));
+    let (pa, pb) = (xy(&s, a), xy(&s, b));
+    s.execute("arrange.reorder", &json!({"ids":[a,b],"source":a,"target":b})).unwrap();
+    let (qa, qb) = (xy(&s, a), xy(&s, b));
+    assert!((qa.0 - pb.0).abs() < 1e-7 && (qa.1 - pb.1).abs() < 1e-7);
+    assert!((qb.0 - pa.0).abs() < 1e-7 && (qb.1 - pa.1).abs() < 1e-7);
+}
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index d8ebfc9e..145f4f07 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -418,6 +418,9 @@ fn every_command_survives_junk_params() {
         // Selection color slots: malformed indexes, ranges and paints.
         json!({"targets": [{"id": 2, "fills": true, "index": -1, "range": [0, 1e308]}], "paint": {"type": "solid", "color": "invalid"}}),
         json!({"targets": [{"id": 2, "fills": "yes", "index": 0, "range": [4, 1]}], "style": 5}),
+        // Smart-selection reorder targets and modes as junk.
+        json!({"ids": [2, 3], "source": -1, "target": {"id": 3}, "swap": [], "fromGesture": true}),
+        json!({"source": 1e308, "target": "NaN", "swap": "yes", "fromGesture": []}),
         // Rotation origins and placing with a tool as junk.
         json!({"tool": [1], "x": 1e308, "y": "NaN", "reset": "maybe", "on": {"x": 1}}),
         json!({"tool": "frame", "x": -1e308, "y": 1e308, "reset": true, "on": "yes"}),
diff --git a/crates/ui-egui/locales/en.toml b/crates/ui-egui/locales/en.toml
index 17f6b4c5..ffc75fe1 100644
--- a/crates/ui-egui/locales/en.toml
+++ b/crates/ui-egui/locales/en.toml
@@ -8,6 +8,7 @@
 name = "English"
 
 [ui]
+"Reorder selection" = "Reorder selection"
 "% of all commits" = "% of all commits"
 "(no longer published)" = "(no longer published)"
 "({n} warnings: some entries were skipped)" = { one = "({n} warning: some entries were skipped)", other = "({n} warnings: some entries were skipped)" }
diff --git a/crates/ui-egui/locales/es.toml b/crates/ui-egui/locales/es.toml
index d054e222..96662b9d 100644
--- a/crates/ui-egui/locales/es.toml
+++ b/crates/ui-egui/locales/es.toml
@@ -8,6 +8,7 @@ name = "Español"
 status = "draft — needs native review"
 
 [ui]
+"Reorder selection" = "Reordenar selección"
 "Compatibility notes" = "Notas de compatibilidad"
 "Couldn't download the variables" = "No se pudieron descargar las variables"
 
@@ -1741,6 +1742,7 @@ status = "draft — needs native review"
 "⌥ drag" = "⌥ arrastrar"
 
 [commands]
+"arrange.reorder" = "Reordenar selección"
 "align.bottom" = "Alinear abajo"
 "align.hcenter" = "Alinear centros horizontales"
 "align.left" = "Alinear a la izquierda"
diff --git a/crates/ui-egui/src/selection_spacing.rs b/crates/ui-egui/src/selection_spacing.rs
index 5110be1c..c2465404 100644
--- a/crates/ui-egui/src/selection_spacing.rs
+++ b/crates/ui-egui/src/selection_spacing.rs
@@ -3,6 +3,7 @@ use std::sync::Arc;
 
 use egui::{CursorIcon, Id, Pos2, Rect, Stroke, Ui, vec2};
 use figcraft_doc::{Document, NodeId};
+use figcraft_engine::selection_reorder::ReorderLayout;
 use figcraft_engine::selection_spacing::{Axis, SelectionSpacing, selection_spacing};
 use serde_json::json;
 
@@ -20,6 +21,7 @@ struct LayoutCache {
     ids: Vec<NodeId>,
     frame: u64,
     layout: Arc<SelectionSpacing>,
+    reorder: Option<Arc<ReorderLayout>>,
 }
 
 fn layout(app: &FigApp, ctx: &egui::Context, ids: &[NodeId]) -> Arc<SelectionSpacing> {
@@ -41,25 +43,58 @@ fn layout(app: &FigApp, ctx: &egui::Context, ids: &[NodeId]) -> Arc<SelectionSpa
     // Panel, input and drawing share one calculation per frame. If a command changes the
     // document during this frame, refresh next frame; unchanged snapshots also reuse it then.
     let layout = Arc::new(selection_spacing(&ds.doc, ids));
+    let reorder = ReorderLayout::new(&ds.doc, ids).map(Arc::new);
     ctx.data_mut(|d| {
-        d.insert_temp(key, LayoutCache { document: ds.uid, page: ds.page, doc: ds.doc.clone(), ids: ids.to_vec(), frame, layout: layout.clone() });
+        d.insert_temp(
+            key,
+            LayoutCache { document: ds.uid, page: ds.page, doc: ds.doc.clone(), ids: ids.to_vec(), frame, layout: layout.clone(), reorder },
+        );
     });
     layout
 }
+fn reorder_layout(app: &FigApp, ctx: &egui::Context, ids: &[NodeId]) -> Option<Arc<ReorderLayout>> {
+    layout(app, ctx, ids);
+    ctx.data(|d| d.get_temp::<LayoutCache>(Id::new("selection_spacing_layout"))).and_then(|c| c.reorder)
+}
+
 fn drag_id() -> Id {
     Id::new("selection_spacing_drag")
 }
 
+#[derive(Clone)]
+enum Action {
+    Spacing { axis: Axis, value: f64, last_value: Option<f64> },
+    Reorder { layout: Arc<ReorderLayout>, source: NodeId, target: NodeId, swap: bool },
+}
+
 #[derive(Clone)]
 struct Drag {
     ids: Vec<NodeId>,
-    axis: Axis,
+    action: Action,
     start: Pos2,
-    value: f64,
     uid: u64,
     page: NodeId,
     moved: bool,
-    last_value: Option<f64>,
+}
+
+fn start_drag(app: &mut FigApp, ctx: &egui::Context, ids: Vec<NodeId>, p: Pos2, action: Action) {
+    let label = match action {
+        Action::Spacing { .. } => tr("Spacing"),
+        Action::Reorder { .. } => tr("Reorder selection"),
+    };
+    if app.session.begin_interaction(label).is_ok()
+        && let Ok(ds) = app.session.ds()
+    {
+        let drag = Drag { ids, action, start: p, uid: ds.uid, page: ds.page, moved: false };
+        app.ui.layers_focus = false;
+        app.ui.key_box = None;
+        ctx.memory_mut(|m| {
+            if let Some(f) = m.focused() {
+                m.surrender_focus(f);
+            }
+        });
+        ctx.data_mut(|d| d.insert_temp(drag_id(), drag));
+    }
 }
 
 pub fn panel(app: &mut FigApp, ui: &mut Ui, ids: &[NodeId]) {
@@ -146,7 +181,7 @@ pub fn cancel(app: &mut FigApp, ctx: &egui::Context) -> bool {
 /// Retire handles when another document, page, tool or editing context takes over.
 pub fn sync(app: &mut FigApp, ctx: &egui::Context) {
     if let Some(drag) = ctx.data(|d| d.get_temp::<Drag>(drag_id())) {
-        let same = app.session.ds().is_ok_and(|d| d.uid == drag.uid && d.page == drag.page && d.selection == drag.ids);
+        let same = app.session.ds().is_ok_and(|d| d.uid == drag.uid && d.page == drag.page && d.selection == drag.ids && d.interaction.is_some());
         if !same || !available(app) {
             cancel(app, ctx);
         }
@@ -157,39 +192,77 @@ pub fn sync(app: &mut FigApp, ctx: &egui::Context) {
 pub fn input(app: &mut FigApp, ctx: &egui::Context, pos: Option<Pos2>, hovered: bool, space: bool) -> bool {
     let dragging = ctx.data(|d| d.get_temp::<Drag>(drag_id()));
     if let Some(mut drag) = dragging {
-        let same = app.session.ds().is_ok_and(|d| d.uid == drag.uid && d.page == drag.page && d.selection == drag.ids);
+        let same = app.session.ds().is_ok_and(|d| d.uid == drag.uid && d.page == drag.page && d.selection == drag.ids && d.interaction.is_some());
         if !same {
             cancel(app, ctx);
             return true;
         }
         let down = ctx.input(|i| i.pointer.primary_down());
         if let Some(p) = pos {
-            let zoom = app.session.ds().map_or(1.0, |d| d.view.zoom).max(1e-6);
-            let distance = if drag.axis.vertical { p.y - drag.start.y } else { p.x - drag.start.x };
-            drag.moved |= distance.abs() >= 3.0;
-            if drag.moved {
-                let value = ctx
-                    .input(|i| {
-                        let quantum = if i.modifiers.alt {
-                            0.1
-                        } else if i.modifiers.shift {
-                            10.0
-                        } else {
-                            1.0
-                        };
-                        ((drag.value + f64::from(distance) / zoom) / quantum).round() * quantum
-                    })
-                    .clamp(-1e6, 1e6);
-                let key = if drag.axis.vertical { "vertical" } else { "horizontal" };
-                if drag.last_value != Some(value) {
-                    match app.session.execute("arrange.spacing", &json!({"ids":drag.ids,key:value,"fromGesture":true})) {
-                        Ok(_) => drag.last_value = Some(value),
-                        Err(e) => app.toast(e.to_string()),
+            match &mut drag.action {
+                Action::Spacing { axis, value: original, last_value } => {
+                    let zoom = app.session.ds().map_or(1.0, |d| d.view.zoom).max(1e-6);
+                    let distance = if axis.vertical { p.y - drag.start.y } else { p.x - drag.start.x };
+                    drag.moved |= distance.abs() >= 3.0;
+                    if drag.moved {
+                        let value = ctx
+                            .input(|i| {
+                                let quantum = if i.modifiers.alt {
+                                    0.1
+                                } else if i.modifiers.shift {
+                                    10.0
+                                } else {
+                                    1.0
+                                };
+                                ((*original + f64::from(distance) / zoom) / quantum).round() * quantum
+                            })
+                            .clamp(-1e6, 1e6);
+                        let key = if axis.vertical { "vertical" } else { "horizontal" };
+                        if *last_value != Some(value) {
+                            match app.session.execute("arrange.spacing", &json!({"ids":drag.ids,key:value,"fromGesture":true})) {
+                                Ok(_) => *last_value = Some(value),
+                                Err(e) => app.toast(e.to_string()),
+                            }
+                        }
                     }
                 }
+                Action::Reorder { layout, source, target, swap } if app.canvas.rect.contains(p) => {
+                    drag.moved |= p.distance(drag.start) >= 3.0;
+                    // Hit original slots, never the moving preview: otherwise a stationary
+                    // pointer could alternate between two permutations on successive frames.
+                    let nearest = layout
+                        .slots
+                        .iter()
+                        .min_by(|a, b| {
+                            let center = |b: figcraft_geom::Rect| app.to_screen((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5);
+                            center(a.1).distance_sq(p).total_cmp(&center(b.1).distance_sq(p))
+                        })
+                        .map(|(id, _)| *id)
+                        .unwrap_or(*source);
+                    let swapping = ctx.input(|i| i.modifiers.command);
+                    if drag.moved && (nearest != *target || swapping != *swap) {
+                        match app
+                            .session
+                            .execute("arrange.reorder", &json!({"ids":drag.ids,"source":source,"target":nearest,"swap":swapping,"fromGesture":true}))
+                        {
+                            Ok(_) => {
+                                *target = nearest;
+                                *swap = swapping;
+                            }
+                            Err(e) => app.toast(e.to_string()),
+                        }
+                    }
+                }
+                // A release over a panel or outside the window commits the last canvas
+                // preview; the release's sentinel coordinates must not select a new slot.
+                Action::Reorder { .. } => {}
             }
         }
-        ctx.set_cursor_icon(if drag.axis.vertical { CursorIcon::ResizeVertical } else { CursorIcon::ResizeHorizontal });
+        ctx.set_cursor_icon(match &drag.action {
+            Action::Spacing { axis, .. } if axis.vertical => CursorIcon::ResizeVertical,
+            Action::Spacing { .. } => CursorIcon::ResizeHorizontal,
+            Action::Reorder { .. } => CursorIcon::Grabbing,
+        });
         if !down {
             let _ = app.session.commit_interaction();
             ctx.data_mut(|d| d.remove::<Drag>(drag_id()));
@@ -198,11 +271,27 @@ pub fn input(app: &mut FigApp, ctx: &egui::Context, pos: Option<Pos2>, hovered:
         }
         return true;
     }
-    if !hovered || space || !available(app) || ctx.input(|i| i.modifiers.command) {
+    if !hovered || space || !available(app) {
         return false;
     }
     let Some(p) = pos else { return false };
     let ids = app.session.selection();
+    if let Some(reorder) = reorder_layout(app, ctx, &ids) {
+        for (id, b) in &reorder.slots {
+            let center = app.to_screen((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5);
+            if center.distance(p) <= 8.0 {
+                ctx.set_cursor_icon(CursorIcon::Grab);
+                if ctx.input(|i| i.pointer.primary_pressed()) {
+                    let source = *id;
+                    start_drag(app, ctx, ids, p, Action::Reorder { layout: reorder, source, target: source, swap: false });
+                }
+                return true;
+            }
+        }
+    }
+    if ctx.input(|i| i.modifiers.command) {
+        return false;
+    }
     let layout = layout(app, ctx, &ids);
     for axis in [layout.horizontal.as_ref(), layout.vertical.as_ref()].into_iter().flatten() {
         for h in handles(app, axis) {
@@ -210,20 +299,8 @@ pub fn input(app: &mut FigApp, ctx: &egui::Context, pos: Option<Pos2>, hovered:
                 continue;
             }
             ctx.set_cursor_icon(if axis.vertical { CursorIcon::ResizeVertical } else { CursorIcon::ResizeHorizontal });
-            if ctx.input(|i| i.pointer.primary_pressed())
-                && app.session.begin_interaction(tr("Spacing")).is_ok()
-                && let Ok(ds) = app.session.ds()
-            {
-                let drag =
-                    Drag { ids, axis: axis.clone(), start: p, value: h.value, uid: ds.uid, page: ds.page, moved: false, last_value: axis.value };
-                app.ui.layers_focus = false;
-                app.ui.key_box = None;
-                ctx.memory_mut(|m| {
-                    if let Some(f) = m.focused() {
-                        m.surrender_focus(f);
-                    }
-                });
-                ctx.data_mut(|d| d.insert_temp(drag_id(), drag));
+            if ctx.input(|i| i.pointer.primary_pressed()) {
+                start_drag(app, ctx, ids, p, Action::Spacing { axis: axis.clone(), value: h.value, last_value: axis.value });
             }
             return true;
         }
@@ -244,8 +321,33 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
     if drag.is_none() && !hover.is_some_and(|p| rect.contains(p)) {
         return;
     }
-    let axes = if let Some(d) = &drag {
-        vec![d.axis.clone()]
+    let reorder = match drag.as_ref().map(|d| &d.action) {
+        Some(Action::Reorder { layout, .. }) => Some(layout.clone()),
+        Some(Action::Spacing { .. }) => None,
+        None => reorder_layout(app, ctx, &ds.selection),
+    };
+    if let Some(layout) = reorder {
+        for (id, _) in &layout.slots {
+            let Some(b) = ds.doc.world_bounds(*id) else { continue };
+            let center = app.to_screen((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5);
+            let hot = hover.is_some_and(|p| center.distance(p) <= 8.0);
+            let active = matches!(drag.as_ref().map(|d| &d.action), Some(Action::Reorder { source, .. }) if source == id);
+            if active {
+                painter.circle_filled(center, 4.5, PINK);
+            } else {
+                painter.circle_stroke(center, 4.5, Stroke::new(if hot { 2.5 } else { 1.5 }, PINK));
+            }
+        }
+    }
+    if let Some(Drag { action: Action::Reorder { layout, target, .. }, moved: true, .. }) = &drag {
+        if let Some((_, b)) = layout.slots.iter().find(|(id, _)| id == target) {
+            let rect = Rect::from_two_pos(app.to_screen(b.x0, b.y0), app.to_screen(b.x1, b.y1)).expand(3.0);
+            painter.rect_stroke(rect, 0, Stroke::new(2.0, crate::theme::ACCENT), egui::StrokeKind::Outside);
+        }
+        return;
+    }
+    let axes = if let Some(Drag { action: Action::Spacing { axis, .. }, .. }) = &drag {
+        vec![axis.clone()]
     } else {
         let layout = layout(app, ctx, &ds.selection);
         [layout.horizontal.clone(), layout.vertical.clone()].into_iter().flatten().collect()
diff --git a/crates/ui-egui/src/selection_spacing_tests.rs b/crates/ui-egui/src/selection_spacing_tests.rs
index 453bd60d..685f7b4e 100644
--- a/crates/ui-egui/src/selection_spacing_tests.rs
+++ b/crates/ui-egui/src/selection_spacing_tests.rs
@@ -205,3 +205,131 @@ fn stationary_gap_drag_does_not_change_the_document_again() {
     u.button(p + vec2(20.2 * z, 0.), false);
     assert_eq!(xy(&u, ids[1]), (200., 100.));
 }
+
+#[test]
+fn reorder_ring_drag_inserts_across_grid_rows_as_one_undo_step() {
+    let (mut u, ids) = scene(true);
+    let before = u.app.session.undo_depth().0;
+    let p = u.app.to_screen(125., 130.);
+    let target = u.app.to_screen(205., 230.);
+    let output = u.frame_output(vec![Event::PointerMoved(p)]);
+    assert_eq!(output.platform_output.cursor_icon, egui::CursorIcon::Grab);
+    drag(&mut u, p, target - p, true);
+    assert_eq!(xy(&u, ids[0]), (180., 200.));
+    assert_eq!(xy(&u, ids[3]), (260., 100.));
+    assert_eq!(u.app.session.selection(), ids);
+    assert_eq!(u.app.session.undo_depth().0, before + 1);
+    u.app.run("edit.undo", json!({}));
+    assert_eq!(xy(&u, ids[0]), (100., 100.));
+    u.app.run("edit.redo", json!({}));
+    assert_eq!(xy(&u, ids[0]), (180., 200.));
+}
+
+#[test]
+fn reorder_ring_escape_click_and_returning_home_make_no_undo_step() {
+    for action in [0, 1, 2] {
+        let (mut u, ids) = scene(false);
+        let history = u.app.session.undo_depth().0;
+        let before = u.app.session.doc().unwrap().clone();
+        let p = u.app.to_screen(125., 130.);
+        let target = u.app.to_screen(285., 130.);
+        u.frame(vec![Event::PointerMoved(p)]);
+        if action == 0 {
+            u.button(p, true);
+        } else {
+            drag(&mut u, p, target - p, false);
+            assert_eq!(xy(&u, ids[0]), (260., 100.));
+            if action == 1 {
+                key(&mut u, Key::Escape);
+            } else {
+                u.frame(vec![Event::PointerMoved(p)]);
+            }
+        }
+        u.button(p, false);
+        u.frame(vec![]);
+        assert_eq!(u.app.session.doc().unwrap(), &before);
+        assert_eq!(u.app.session.undo_depth().0, history);
+        assert_eq!(u.app.session.selection(), ids);
+        assert!(u.app.session.ds().unwrap().interaction.is_none());
+    }
+}
+
+#[test]
+fn command_drag_swaps_and_a_stationary_pointer_keeps_the_preview() {
+    let (mut u, ids) = scene(true);
+    let p = u.app.to_screen(125., 130.);
+    let target = u.app.to_screen(205., 230.);
+    // The modifier can already be down when the handle is pressed.
+    let m = Modifiers::COMMAND;
+    u.frame_with(vec![Event::PointerMoved(p)], m);
+    u.frame_with(vec![Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed: true, modifiers: m }], m);
+    u.frame_with(vec![Event::PointerMoved(target)], m);
+    assert_eq!(xy(&u, ids[0]), (180., 200.));
+    assert_eq!(xy(&u, ids[4]), (100., 100.));
+    assert_eq!(xy(&u, ids[1]), (180., 100.));
+    let snapshot = u.app.session.ds().unwrap().doc.clone();
+    for _ in 0..5 {
+        u.frame_with(vec![], m);
+    }
+    assert!(std::sync::Arc::ptr_eq(&snapshot, &u.app.session.ds().unwrap().doc));
+    // Changing modifiers without moving the pointer switches to insertion.
+    u.frame(vec![]);
+    assert_eq!(xy(&u, ids[1]), (100., 100.));
+    assert_eq!(xy(&u, ids[4]), (100., 200.));
+    u.button(target, false);
+}
+
+#[test]
+fn switching_documents_during_reordering_rolls_back_its_owner() {
+    let (mut u, ids) = scene(false);
+    let before = u.app.session.doc().unwrap().clone();
+    let p = u.app.to_screen(125., 130.);
+    let target = u.app.to_screen(285., 130.);
+    drag(&mut u, p, target - p, false);
+    u.app.run("file.new", json!({}));
+    u.app.session.begin_interaction("Unrelated").unwrap();
+    u.frame(vec![]);
+    assert!(u.app.session.ds().unwrap().interaction.is_some());
+    u.app.session.active = 0;
+    assert_eq!(u.app.session.doc().unwrap(), &before);
+    assert_eq!(u.app.session.selection(), ids);
+}
+
+#[test]
+fn reorder_release_outside_window_commits_and_undo_while_dragging_cancels() {
+    for undo in [false, true] {
+        let (mut u, ids) = scene(false);
+        let history = u.app.session.undo_depth().0;
+        let p = u.app.to_screen(125., 130.);
+        let target = u.app.to_screen(285., 130.);
+        drag(&mut u, p, target - p, false);
+        if undo {
+            let m = Modifiers::COMMAND;
+            u.frame_with(vec![Event::Key { key: Key::Z, physical_key: None, pressed: true, repeat: false, modifiers: m }], m);
+        }
+        u.frame(vec![Event::PointerGone]);
+        u.button(Pos2::new(-1., -1.), false);
+        u.frame(vec![]);
+        assert_eq!(u.app.session.undo_depth().0, history + usize::from(!undo));
+        assert_eq!(xy(&u, ids[0]), if undo { (100., 100.) } else { (260., 100.) });
+        assert!(u.app.session.ds().unwrap().interaction.is_none());
+    }
+}
+
+#[test]
+fn an_externally_finished_reorder_cannot_resume_on_later_pointer_motion() {
+    let (mut u, ids) = scene(false);
+    let p = u.app.to_screen(125., 130.);
+    let target = u.app.to_screen(285., 130.);
+    drag(&mut u, p, target - p, false);
+    u.app.session.commit_interaction().unwrap();
+    let history = u.app.session.undo_depth().0;
+    let committed = u.app.session.doc().unwrap().clone();
+    let middle = u.app.to_screen(205., 130.);
+    u.frame(vec![Event::PointerMoved(middle)]);
+    u.button(middle, false);
+    u.frame(vec![]);
+    assert_eq!(u.app.session.doc().unwrap(), &committed);
+    assert_eq!(u.app.session.undo_depth().0, history);
+    assert_eq!(xy(&u, ids[0]), (260., 100.));
+}
diff --git a/docs/gaps.md b/docs/gaps.md
index 9b1a770c..5f2255e6 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Where FigCraft falls short of Figma
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-17 · **Change:** minor (the 2026-10-17 landings: `.fig` import fidelity, budgets for large files, the import report, a `.fig` copy from Save as and paste from another design app (gap 1); menus, the Actions palette, editor fixes, Selection colors and smart-selection spacing (gap 4); catalog counts re-measured (gap 5); bounded canvas pan overscan; reviewed Russian catalog and integer plurals; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; `.fig` import: editable vector networks, more layer kinds, variable prototype actions; `.fig` import, best effort: gap 1 down to its tail; Windows QA pass: everyday workflows on Windows 11, eight fixes incl. unsaved work kept after a crash or a forced quit; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings: gap 14 down to its tail) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (smart-selection drag reordering; the 2026-10-17 landings: `.fig` import fidelity, budgets for large files, the import report, a `.fig` copy from Save as and paste from another design app (gap 1); menus, the Actions palette, editor fixes, Selection colors and smart-selection spacing (gap 4); catalog counts re-measured (gap 5); bounded canvas pan overscan; reviewed Russian catalog and integer plurals; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; `.fig` import: editable vector networks, more layer kinds, variable prototype actions; `.fig` import, best effort: gap 1 down to its tail; Windows QA pass: everyday workflows on Windows 11, eight fixes incl. unsaved work kept after a crash or a forced quit; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings: gap 14 down to its tail) · **Target:** Figma Design (desktop app 126.10.7)
 
 Every known shortfall against Figma, one entry each, ranked by how much it stops a Figma user from
 doing real work in FigCraft. Agents: pick work from the top unless the owner says otherwise. The
@@ -174,6 +174,9 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
   Layers; Paste over and Paste properties from the keyboard; then (#753) Selection colors for mixed
   selections and smart-selection spacing fields and canvas handles (no reorder rings). Each was checked in the app (on
   Windows; the submenus by their author), none side by side with Figma, none on macOS.
+- **Landed (2026-10-18):** smart-selection center rings for single-layer insertion and
+  Command/Ctrl swaps in regular rows, columns and complete top-left-aligned grids; live preview,
+  cancellation and one undo step. Multiple marked layers and irregular-grid insertion remain.
 - **Evidence:** ROADMAP item 7 ("Left: tool by tool, panel by panel against the incumbent").
 - **Impact:** Figma users notice the feel within minutes; it decides whether they stay.
 - **Estimate:** 40–60 h. Detail in [`ui-parity.md`](ui-parity.md).
@@ -444,6 +447,7 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-18 | minor | Smart-selection center rings insert a layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl-drag swaps entries. Unequal sizes reflow with the original gaps, hierarchy and selection stay intact, and each drag is one undo step. Escape or Undo during the drag cancels; switching documents, pages or tools rolls back the owning gesture. Mixed gaps, incomplete grids and unsupported selections keep spacing controls without reorder rings. Multiple marked items and irregular-grid insertion remain unimplemented. Engine and raw-input UI regression tests; desktop Linux before/during/after screenshots and insertion, undo/redo and Escape checked on synthetic cards. No side-by-side comparison with the incumbent. Headline estimates unchanged. |
 | 2026-10-17 | minor | The 2026-10-17 landings. Gap 1: a new Landed entry (community batches #727 and #728, then #745: instance identity and cached library components, overrides by key, text style precedence, grid track sizes, slot content, labels of connectors saved with their path, skip ink, paragraph options, list start numbers, vertical trim, per-point stroke joins, text on a path, image adjustments, images in the message, instance layers' size and resizing overrides, Hug where nothing is recorded; budgets from the file's size; the import report; a `.fig` copy from Save as; paste from another design app), its Missing list cut to what is still left, and the wrong "whether other apps open its files is unknown" replaced by what was checked; all on synthetic files, so the beta blocker and hours stand. Gap 2: server limits, log recovery and web join links in the evidence. Gap 4: menus, the Actions palette and the editor fixes (#733, #735, #736, #729), then Selection colors and smart-selection spacing (#753) landed, none compared side by side. Gap 5: catalog counts re-measured (2,272 entries; drafts at 95–99%; Indonesian, Czech, Turkish and Swedish listed). Gap 8: the Linux and BSD clipboard changes and Wayland window controls, not run there by the maintainers. Ranking and hours unchanged |
 | 2026-10-15 | minor | Gap 7: bounded canvas overscan for smoother panning. Estimates and ranking unchanged. |
 | 2026-10-14 | minor | Russian catalog (M9), reviewed and approved by VanTan: all 2,165 current entries, Русский in Preferences and regional ru tags. Russian integer plurals use one/few/many; contributor display name VanTan added. Existing estimates unchanged. |
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index 775a4fcb..d53c9c52 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -1,8 +1,8 @@
 # Parity checklist
 
-> **Generated:** 2026-10-17 by `cargo xtask parity`. Do not edit by hand.
+> **Generated:** 2026-10-18 by `cargo xtask parity`. Do not edit by hand.
 
-FigCraft commands registered for the incumbent's main menu and toolbar (561 commands in the engine).
+FigCraft commands registered for the incumbent's main menu and toolbar (563 commands in the engine).
 
 **212 / 212 menu items (100.0%)**
 
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 16a5af69..a9a1a507 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,6 +1,6 @@
 # FigCraft parity with Figma
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-17 · **Change:** minor (rows for the community batches: Selection colors, smart-selection spacing and a Present tab (#753), `.fig` import fidelity, paste from another design app, a `.fig` copy from Save as; control requests while the window is minimised (#720); catalog counts re-measured; automation roots (#715); number variables in the text content picker (#629); frames and sections convert into each other (#719); reviewed Russian catalog and integer plurals; vector edit mode regions: hover hatch, selection and drag; plugin log byte/count limits (#191); core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; starter templates, a Templates tab and Getting started tips on the home screen: essentials ~57% → ~59%; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages, numbers unchanged but menu breadth 211/211; text box sizes measured against documents re-saved by other software: whole-pixel line heights, advances on a 1024-per-em grid, letter spacing between glyphs only, numbers unchanged; .fig export checked by opening written files in other software, numbers unchanged; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%; last major: full re-measure against Figma desktop 126.10.7) · **Target:** Figma Design (desktop app 126.10.7, macOS)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (smart-selection drag reordering; rows for the community batches: Selection colors, smart-selection spacing and a Present tab (#753), `.fig` import fidelity, paste from another design app, a `.fig` copy from Save as; control requests while the window is minimised (#720); catalog counts re-measured; automation roots (#715); number variables in the text content picker (#629); frames and sections convert into each other (#719); reviewed Russian catalog and integer plurals; vector edit mode regions: hover hatch, selection and drag; plugin log byte/count limits (#191); core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; starter templates, a Templates tab and Getting started tips on the home screen: essentials ~57% → ~59%; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages, numbers unchanged but menu breadth 211/211; text box sizes measured against documents re-saved by other software: whole-pixel line heights, advances on a 1024-per-em grid, letter spacing between glyphs only, numbers unchanged; .fig export checked by opening written files in other software, numbers unchanged; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%; last major: full re-measure against Figma desktop 126.10.7) · **Target:** Figma Design (desktop app 126.10.7, macOS)
 
 The authoritative assessment of how close FigCraft is to Figma Design. [`ROADMAP.md`](../ROADMAP.md)
 summarizes it; [`gaps.md`](gaps.md) is the ranked work list; the measured menu checklist is
@@ -95,7 +95,7 @@ Breadth: does it exist. Ready: depth, correctness and fidelity for real projects
 | # | Area | Weight | Breadth | Ready | Remaining | Hours |
 |---|---|---|---|---|---|---|
 | 1 | Canvas & navigation | 6 | 98% | 74% | Outline mode's Include hidden layers and Include object bounds, Display P3 on screen, QA at extreme zooms (behaviour suite for navigation, rulers, guides, layout grids and outline mode landed: guide selection, Auto grid counts, outline-mode clicks) | 1–4 |
-| 2 | Selection & transform | 8 | 97% | 72% | Handles, measuring and snapping checked tool by tool against Figma and real files (snap distance, handle reach, cursors); children turned off a right angle scale without skew, approximately (behaviour suite from the documentation, rotated groups and mixed selections, equal spacing snapping, Cmd/Ctrl to ignore constraints and marquees inside frames landed) | 3–5 |
+| 2 | Selection & transform | 8 | 97% | 72% | Handles, measuring and snapping checked tool by tool against Figma and real files (snap distance, handle reach, cursors); children turned off a right angle scale without skew, approximately (behaviour suite from the documentation, rotated groups and mixed selections, equal spacing snapping, Cmd/Ctrl to ignore constraints and marquees inside frames landed; smart-selection rings reorder single layers in regular rows, columns and complete aligned grids, with Command/Ctrl swaps; multi-item marks and irregular-grid insertion remain) | 3–5 |
 | 3 | Layers panel | 5 | 99% | 85% | QA with long real files (behaviour suite from the documentation, Rename layers dialog, sweeping eyes and padlocks, page dragging and dividers, several layers dropped together, keyboard box selection, F2 rename, Shift+F10 context menu and 10k-layer timings landed) | 1–2 |
 | 4 | Shapes & vector | 8 | 99% | 73% | Corner smoothing on polygons, stars and vectors; the transform box around points of several layers; per-point caps and joins on dashed, variable-width and brush strokes; vector QA with real files (behaviour suites from the documentation, corner radius and star ratio handles, rounded vector points drawn, also beside curved segments, a cap and join per point, several handles dragged together, cut and paint bucket drags, delete and heal along the curve, a boolean group's look by operation and the miter angle landed) | 1–3 |
 | 5 | Paint | 7 | 90% | 71% | Video fills, wide-gamut canvas, HEIC images; plus darker in PDF (behaviour suite from the documentation, pass-through and isolating groups, clipping frames that don't isolate, plus darker, animated GIF fills, TIFF images and embedded image colour profiles landed) | 2–5 |
@@ -638,6 +638,7 @@ Carried over from the ROADMAP's "Shipped so far" (2026-10-10). The test count th
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-18 | minor | Smart-selection center rings insert a layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl-drag swaps entries. Unequal sizes reflow with the original gaps, hierarchy and selection stay intact, and each drag is one undo step. Escape or Undo during the drag cancels; switching documents, pages or tools rolls back the owning gesture. Mixed gaps, incomplete grids and unsupported selections keep spacing controls without reorder rings. Multiple marked items and irregular-grid insertion remain unimplemented. Engine and raw-input UI regression tests; desktop Linux before/during/after screenshots and insertion, undo/redo and Escape checked on synthetic cards. No side-by-side comparison with the incumbent. Headline estimates unchanged. |
 | 2026-10-17 | minor | Menu breadth re-run with `cargo xtask parity`: 212 / 212 (100%; the catalog gained View ▸ Full screen with #227 on 2026-10-14), 561 commands. Rows for the 2026-10-17 landings: import/export (area 14) and the file formats dimension name the `.fig` import's new fidelity (instance identity, overrides by key, text style precedence, grid tracks, slots, connector labels, per-point joins, text on a path, image adjustments, list start numbers, vertical trim), budgets from the file's size, the import report, a `.fig` copy from Save as and paste from another design app; the localization evidence takes the re-measured catalog counts (2,272 entries, drafts at 95–99%, Indonesian and Czech drafts, Swedish and Turkish catalogs); the Automation line adds control requests answered while the window is minimised (#720); batch #753's Selection colors, smart-selection spacing, Present tab and auto layout on empty frames are in ui-parity, prototyping-parity and auto-layout-parity. Numbers unchanged: every `.fig` and paste change is checked on synthetic files or clipboard HTML made from our own export, and real files are what gap 1's blocker and the file-exchange discounts wait for; the UI changes (menus, the Actions palette, editor fixes) are not compared side by side, so UI/UX stays at 58%; the localization grade and hours stay (Indonesian's draft is offset by the drafts' new gaps) |
 | 2026-10-17 | minor | Automation roots (M8, #715, #481): `figcraft-cli mcp --automation-read-root DIR --automation-write-root DIR` (each repeatable, existing folders) and the desktop app with the same flags confine every file a command reads to the read and write roots and every file it writes to the write roots; paths are resolved (links followed, `..`, Windows `\\?\` and UNC paths, case) and compared by whole folder names, anything else is an ordinary error. The engine reaches the file system through one module (enforced by `crates/engine/clippy.toml`), and a sweep runs every command with paths outside the roots. `--attach` refuses the flags (the app confines itself); `ui.screenshot` and `ui.render` return PNG data without a `path`, so the attached MCP server writes no temporary files. Numbers unchanged. |
 | 2026-10-17 | minor | Number variables on text content (M3, #629): the Typography section's variable picker also lists number variables for a text layer's content, as the engine already accepted (the text shows the number, e.g. 42.5, and follows the variable). Other text fields keep their own types. Numbers unchanged. |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 766284f1..eab5aafe 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI and interaction parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (a rename selects the whole name, so typing replaces it; Escape or Enter after a pen path stays on the same vector (#760); IME composition kept on through idle frames of a text edit, candidates at the caret (#747); Selection colors for mixed selections and smart-selection spacing (#753); submenus with a hover delay and a safe triangle; the Actions palette's tabs, ranked search, highlight and recents; menu items that ask for a value; editor fixes from the community batches; fields select their text on focus; Typography spacing icons support scrubbing (#373); CSS colour names in hex fields; the Small caps sample in Type settings drawn from capitals; recent files as cards; vector edit mode: hovering, hatching, selecting and dragging filled regions; home screen: Templates tab, first-run templates and Getting started tips; number fields: scrub rates, arrow steps, arithmetic with brackets, relative edits of mixed values; outline mode's hidden layers and object bounds; Hide when publishing; cursors per tool and modifier; panel widths; dark pages for files made in the dark theme; drag threshold and double-clicks into text in groups; rotation origin on Alt+R and placing with Enter: no documented shortcut missing; keyboard shortcut parity suite and bindings; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and the vector edit tail; canvas navigation, guides and grids behaviour suite and fixes; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; layers panel keyboard: F2 rename, Shift+F10 context menu, F8 box selection; selection and transform behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; boolean hit testing on the result, group drags, frame outlines and slices; outlines for the selection, mask outlines; arc fields, live boolean editing, shape builder on strokes, one-sided widths) · **Target:** Figma Design UI3 (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (smart-selection drag reordering; a rename selects the whole name, so typing replaces it; Escape or Enter after a pen path stays on the same vector (#760); IME composition kept on through idle frames of a text edit, candidates at the caret (#747); Selection colors for mixed selections and smart-selection spacing (#753); submenus with a hover delay and a safe triangle; the Actions palette's tabs, ranked search, highlight and recents; menu items that ask for a value; editor fixes from the community batches; fields select their text on focus; Typography spacing icons support scrubbing (#373); CSS colour names in hex fields; the Small caps sample in Type settings drawn from capitals; recent files as cards; vector edit mode: hovering, hatching, selecting and dragging filled regions; home screen: Templates tab, first-run templates and Getting started tips; number fields: scrub rates, arrow steps, arithmetic with brackets, relative edits of mixed values; outline mode's hidden layers and object bounds; Hide when publishing; cursors per tool and modifier; panel widths; dark pages for files made in the dark theme; drag threshold and double-clicks into text in groups; rotation origin on Alt+R and placing with Enter: no documented shortcut missing; keyboard shortcut parity suite and bindings; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and the vector edit tail; canvas navigation, guides and grids behaviour suite and fixes; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; layers panel keyboard: F2 rename, Shift+F10 context menu, F8 box selection; selection and transform behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; boolean hit testing on the result, group drags, frame outlines and slices; outlines for the selection, mask outlines; arc fields, live boolean editing, shape builder on strokes, one-sided widths) · **Target:** Figma Design UI3 (desktop app 126.10.7)
 
 Fine canvas control is what Figma users feel first: handles, snapping, nudging, modifier keys,
 drag behaviour, numeric precision. This checklist covers the tools, gestures and panels. Status:
@@ -69,7 +69,7 @@ interaction feel not yet compared.
 | Numeric fields: arithmetic, scrubbing by dragging the label, mixed values | done | Numeric panels use `widgets::number_field`; Typography line height, letter spacing and paragraph spacing share its leading-icon scrub logic (#373), retaining their existing unit parsing, Auto/Mixed values, variable chips and selected-character targeting (`typography_scrub_tests`). Scrubbing the label: a step a point (1 px; 1% of opacity, 1° of rotation), ten with Shift, a tenth with Alt, each stretch at the rate held while it was dragged, one undo step when let go; past the edge of the screen it goes on where the platform reports the mouse's own motion (desktop), otherwise it stops there. Arrow keys: Up/Down step a pixel field by the small nudge and Shift by the big nudge (the preferences), other fields by their own step and ten of it; they work while typing (from what is typed) and with the keyboard on the field. Typing: `+ - * /`, brackets, units (`px`, `°`, `%`, `x`, `ms`), a decimal comma; `+10`, `*2`, `/4` are relative to the value, and `50%`, `+10%`, `-10%` too in a field that isn't a percentage. Enter, Tab or a click elsewhere commits (Tab and Shift+Tab move to the next and previous control), Escape restores; a field left as it was commits nothing (no undo step, and a rounded display isn't written back). Mixed values show "Mixed": a number sets them all, a relative edit or an arrow key goes to each layer from its own value in one undo step, for X, Y, W, H, rotation, opacity, corner radius and stroke weight (elsewhere `+10` on Mixed sets 10 and `*2` does nothing) (`field_tests`). Left: scrubbing a Mixed field (nothing happens), `x2`-style suffix edits, the pointer isn't wrapped to the other side of the screen; rates not compared with Figma's |
 | Transform box at small sizes | done | a press inside a layer smaller than its handles moves it, the nearest handle wins, handles answer just outside and are hidden under 16 px on screen; cursors follow each handle and the box's rotation |
 | Locked layers | done | selectable from the layers panel; no handles, not dragged with the rest of a selection |
-| Smart selection spacing | partial | with layers in a row, a column or an aligned grid selected, the Layout section shows horizontal and vertical spacing ("Mixed" until set; typed, scrubbed, fractional and negative) and pink handles in the gaps on the canvas drag them, one undo step, Escape cancels (`arrange.spacing`; sizes, parents and offsets within each track kept; at most 2,000 layers; flow children, locked layers and layers inside instances left out). No reorder rings for swapping layers; checked by its author on macOS and in the app on Windows (#402) |
+| Smart selection spacing | partial | with layers in a row, a column or an aligned grid selected, the Layout section shows horizontal and vertical spacing ("Mixed" until set; typed, scrubbed, fractional and negative) and pink handles in the gaps on the canvas drag them, one undo step, Escape cancels (`arrange.spacing`; sizes, parents and offsets within each track kept; at most 2,000 layers; flow children, locked layers and layers inside instances left out). Center rings drag a single layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl swaps entries. Preview, target outline, Escape cancellation and one-step undo (`arrange.reorder`, `selection_reorder_tests`, `selection_spacing_tests`). Sizes, gaps and layer hierarchy kept. Mixed gaps and incomplete or differently aligned grids have no rings; multiple marked-item dragging remains. Spacing checked by its author on macOS and in the app on Windows (#402) |
 | Selection colors | partial | for a mixed selection the Design panel lists their solid and gradient paints (children and text ranges included; hidden paints, masks, images, patterns and boolean operands left out; styles and variables listed apart): editing a colour changes every matching fill and stroke in one undo step, a row selects the layers that use it or applies a colour style of the document (`selection.colors`, `selection.setPaint`, `selection.applyColorStyle`, `selection.selectColor`). No library styles or variable binding from there (#403) |
 | Keyboard box selection | done | Alt+Space on macOS, Ctrl+Space on Windows and Linux, or F8 (`select.area`): a box around the selection or in the middle of the view; arrows move it, Cmd/Ctrl+arrows or Shift+arrows size it (Shift with Cmd/Ctrl: farther), Enter selects like a marquee (Shift+Enter toggles, Cmd/Ctrl+Enter nested), Escape closes |
 
@@ -172,6 +172,7 @@ in the table. `crates/ui-egui/src/shortcut_keys_tests.rs` drives the keys a look
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-18 | minor | Smart-selection center rings insert a layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl-drag swaps entries. Unequal sizes reflow with the original gaps, hierarchy and selection stay intact, and each drag is one undo step. Escape or Undo during the drag cancels; switching documents, pages or tools rolls back the owning gesture. Mixed gaps, incomplete grids and unsupported selections keep spacing controls without reorder rings. Multiple marked items and irregular-grid insertion remain unimplemented. Engine and raw-input UI regression tests; desktop Linux before/during/after screenshots and insertion, undo/redo and Escape checked on synthetic cards. No side-by-side comparison with the incumbent. Headline estimates unchanged. |
 | 2026-10-18 | minor | A rename (layers double-click, F2, File ▸ Rename, a page) selects the whole name in the frame its field first draws, so the first key replaces the name instead of being appended. Checked in the app on Windows over the control channel |
 | 2026-10-17 | minor | Escape or Enter while the pen draws ends the path and keeps its vector in edit mode with the pen, so the next path is drawn into the same layer (unconnected); another Escape leaves edit mode (#760). Entering edit mode on a layer that already is a vector no longer records an empty undo step. Numbers unchanged |
 | 2026-10-17 | minor | Text layers keep the platform IME on for every frame of an edit, not only frames with input (an idle frame turned it off and macOS dropped each composition, #747); the candidate window opens at the caret instead of the canvas corner; keys pressed while composing go to the IME |

From 9fddc4b058aa4440f8e629ea8530cef2efbe0504 Mon Sep 17 00:00:00 2001
From: bflatastic <bombayapirat@gmail.com>
Date: Mon, 19 Oct 2026 23:49:00 +0700
Subject: [PATCH 2/5] #854: drop the progress-doc edits (ROADMAP, gaps, parity
 docs, generated checklist); the maintainer adds them

---
 ROADMAP.md                | 2 --
 docs/gaps.md              | 6 +-----
 docs/parity-checklist.md  | 4 ++--
 docs/target-app-parity.md | 5 ++---
 docs/ui-parity.md         | 5 ++---
 5 files changed, 7 insertions(+), 15 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index 1c3db7e4..8a587286 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -131,8 +131,6 @@ Ranked; detail and milestones in [`docs/roadmap.md`](docs/roadmap.md).
 
 ## Progress log
 
-- **2026-10-18** · Smart-selection drag reordering (M1): Smart-selection center rings insert a layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl-drag swaps entries. Unequal sizes reflow with the original gaps, hierarchy and selection stay intact, and each drag is one undo step. Escape or Undo during the drag cancels; switching documents, pages or tools rolls back the owning gesture. Mixed gaps, incomplete grids and unsupported selections keep spacing controls without reorder rings. Multiple marked items and irregular-grid insertion remain unimplemented. Engine and raw-input UI regression tests; desktop Linux before/during/after screenshots and insertion, undo/redo and Escape checked on synthetic cards. No side-by-side comparison with the incumbent. Headline estimates unchanged. Validation: 1,039 engine unit tests passed (2 ignored), 555 UI unit tests passed (1 ignored); formatting, layering, assets, parity and `cargo xtask wasm` passed. Clippy passes with only the existing `collapsible_match` findings suppressed; strict `cargo xtask ci` stops on seven findings in unchanged UI files. The workspace test run stops on the unchanged text crate’s `tail_tests::hanging_punctuation_outside_the_aligned_edge` (2 lines instead of 1); no text code changed.
-
 - **2026-10-17** · Control channel while the window is minimised (M8, #720): a minimised or covered window answers every request that acts on the app's state (edits, `ui.inspect`, `ui.pointer`, `ui.key`, `ui.type`, `ui.set`, `app.quit`…) without drawing, and what needs a drawn frame (`ui.screenshot`, `ui.input`, `window.new`) is an error at once; before, those waited up to 60 s and held up every later request on the connection (an attached agent's `inspect_ui` or window screenshot stalled until the window came back). Measured on Windows 11, minimised: requests ~100 ms each (eframe wakes a minimised window at most ten times a second; ~2 ms on screen), a window screenshot fails in ~100 ms instead of 60 s, idle CPU 0. Numbers unchanged.
 - **2026-10-17** · Number variables on text content (M3, #629): the Typography section's variable picker also lists number variables for a text layer's content, as the engine already accepted (the text shows the number, e.g. 42.5, and follows the variable). Other text fields keep their own types. Numbers unchanged.
 - **2026-10-17** · Frames and sections convert into each other (M1, #719): `object.convertToSection` turns a frame on the page or in a section into a section in place (same box, name, fill and layers, which stay where they are; what only a frame has goes: auto layout, clipping, layout grids, guides, scrolling), and `object.convertToFrame` now also turns a section into a frame that keeps its fill and doesn't clip, so the look stays. Nested frames, instances, main components and sections holding sections are refused with the reason; one undo step each. Both are in the canvas context menu (Convert to section / Convert to frame) and in Spanish. Numbers unchanged.
diff --git a/docs/gaps.md b/docs/gaps.md
index 5f2255e6..9b1a770c 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Where FigCraft falls short of Figma
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (smart-selection drag reordering; the 2026-10-17 landings: `.fig` import fidelity, budgets for large files, the import report, a `.fig` copy from Save as and paste from another design app (gap 1); menus, the Actions palette, editor fixes, Selection colors and smart-selection spacing (gap 4); catalog counts re-measured (gap 5); bounded canvas pan overscan; reviewed Russian catalog and integer plurals; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; `.fig` import: editable vector networks, more layer kinds, variable prototype actions; `.fig` import, best effort: gap 1 down to its tail; Windows QA pass: everyday workflows on Windows 11, eight fixes incl. unsaved work kept after a crash or a forced quit; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings: gap 14 down to its tail) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-17 · **Change:** minor (the 2026-10-17 landings: `.fig` import fidelity, budgets for large files, the import report, a `.fig` copy from Save as and paste from another design app (gap 1); menus, the Actions palette, editor fixes, Selection colors and smart-selection spacing (gap 4); catalog counts re-measured (gap 5); bounded canvas pan overscan; reviewed Russian catalog and integer plurals; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; `.fig` import: editable vector networks, more layer kinds, variable prototype actions; `.fig` import, best effort: gap 1 down to its tail; Windows QA pass: everyday workflows on Windows 11, eight fixes incl. unsaved work kept after a crash or a forced quit; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings: gap 14 down to its tail) · **Target:** Figma Design (desktop app 126.10.7)
 
 Every known shortfall against Figma, one entry each, ranked by how much it stops a Figma user from
 doing real work in FigCraft. Agents: pick work from the top unless the owner says otherwise. The
@@ -174,9 +174,6 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
   Layers; Paste over and Paste properties from the keyboard; then (#753) Selection colors for mixed
   selections and smart-selection spacing fields and canvas handles (no reorder rings). Each was checked in the app (on
   Windows; the submenus by their author), none side by side with Figma, none on macOS.
-- **Landed (2026-10-18):** smart-selection center rings for single-layer insertion and
-  Command/Ctrl swaps in regular rows, columns and complete top-left-aligned grids; live preview,
-  cancellation and one undo step. Multiple marked layers and irregular-grid insertion remain.
 - **Evidence:** ROADMAP item 7 ("Left: tool by tool, panel by panel against the incumbent").
 - **Impact:** Figma users notice the feel within minutes; it decides whether they stay.
 - **Estimate:** 40–60 h. Detail in [`ui-parity.md`](ui-parity.md).
@@ -447,7 +444,6 @@ No alpha blockers: the alpha gate in [`roadmap.md`](roadmap.md#alpha-gate) passe
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-10-18 | minor | Smart-selection center rings insert a layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl-drag swaps entries. Unequal sizes reflow with the original gaps, hierarchy and selection stay intact, and each drag is one undo step. Escape or Undo during the drag cancels; switching documents, pages or tools rolls back the owning gesture. Mixed gaps, incomplete grids and unsupported selections keep spacing controls without reorder rings. Multiple marked items and irregular-grid insertion remain unimplemented. Engine and raw-input UI regression tests; desktop Linux before/during/after screenshots and insertion, undo/redo and Escape checked on synthetic cards. No side-by-side comparison with the incumbent. Headline estimates unchanged. |
 | 2026-10-17 | minor | The 2026-10-17 landings. Gap 1: a new Landed entry (community batches #727 and #728, then #745: instance identity and cached library components, overrides by key, text style precedence, grid track sizes, slot content, labels of connectors saved with their path, skip ink, paragraph options, list start numbers, vertical trim, per-point stroke joins, text on a path, image adjustments, images in the message, instance layers' size and resizing overrides, Hug where nothing is recorded; budgets from the file's size; the import report; a `.fig` copy from Save as; paste from another design app), its Missing list cut to what is still left, and the wrong "whether other apps open its files is unknown" replaced by what was checked; all on synthetic files, so the beta blocker and hours stand. Gap 2: server limits, log recovery and web join links in the evidence. Gap 4: menus, the Actions palette and the editor fixes (#733, #735, #736, #729), then Selection colors and smart-selection spacing (#753) landed, none compared side by side. Gap 5: catalog counts re-measured (2,272 entries; drafts at 95–99%; Indonesian, Czech, Turkish and Swedish listed). Gap 8: the Linux and BSD clipboard changes and Wayland window controls, not run there by the maintainers. Ranking and hours unchanged |
 | 2026-10-15 | minor | Gap 7: bounded canvas overscan for smoother panning. Estimates and ranking unchanged. |
 | 2026-10-14 | minor | Russian catalog (M9), reviewed and approved by VanTan: all 2,165 current entries, Русский in Preferences and regional ru tags. Russian integer plurals use one/few/many; contributor display name VanTan added. Existing estimates unchanged. |
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index d53c9c52..775a4fcb 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -1,8 +1,8 @@
 # Parity checklist
 
-> **Generated:** 2026-10-18 by `cargo xtask parity`. Do not edit by hand.
+> **Generated:** 2026-10-17 by `cargo xtask parity`. Do not edit by hand.
 
-FigCraft commands registered for the incumbent's main menu and toolbar (563 commands in the engine).
+FigCraft commands registered for the incumbent's main menu and toolbar (561 commands in the engine).
 
 **212 / 212 menu items (100.0%)**
 
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index a9a1a507..16a5af69 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,6 +1,6 @@
 # FigCraft parity with Figma
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (smart-selection drag reordering; rows for the community batches: Selection colors, smart-selection spacing and a Present tab (#753), `.fig` import fidelity, paste from another design app, a `.fig` copy from Save as; control requests while the window is minimised (#720); catalog counts re-measured; automation roots (#715); number variables in the text content picker (#629); frames and sections convert into each other (#719); reviewed Russian catalog and integer plurals; vector edit mode regions: hover hatch, selection and drag; plugin log byte/count limits (#191); core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; starter templates, a Templates tab and Getting started tips on the home screen: essentials ~57% → ~59%; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages, numbers unchanged but menu breadth 211/211; text box sizes measured against documents re-saved by other software: whole-pixel line heights, advances on a 1024-per-em grid, letter spacing between glyphs only, numbers unchanged; .fig export checked by opening written files in other software, numbers unchanged; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%; last major: full re-measure against Figma desktop 126.10.7) · **Target:** Figma Design (desktop app 126.10.7, macOS)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-17 · **Change:** minor (rows for the community batches: Selection colors, smart-selection spacing and a Present tab (#753), `.fig` import fidelity, paste from another design app, a `.fig` copy from Save as; control requests while the window is minimised (#720); catalog counts re-measured; automation roots (#715); number variables in the text content picker (#629); frames and sections convert into each other (#719); reviewed Russian catalog and integer plurals; vector edit mode regions: hover hatch, selection and drag; plugin log byte/count limits (#191); core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; starter templates, a Templates tab and Getting started tips on the home screen: essentials ~57% → ~59%; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages, numbers unchanged but menu breadth 211/211; text box sizes measured against documents re-saved by other software: whole-pixel line heights, advances on a 1024-per-em grid, letter spacing between glyphs only, numbers unchanged; .fig export checked by opening written files in other software, numbers unchanged; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%; last major: full re-measure against Figma desktop 126.10.7) · **Target:** Figma Design (desktop app 126.10.7, macOS)
 
 The authoritative assessment of how close FigCraft is to Figma Design. [`ROADMAP.md`](../ROADMAP.md)
 summarizes it; [`gaps.md`](gaps.md) is the ranked work list; the measured menu checklist is
@@ -95,7 +95,7 @@ Breadth: does it exist. Ready: depth, correctness and fidelity for real projects
 | # | Area | Weight | Breadth | Ready | Remaining | Hours |
 |---|---|---|---|---|---|---|
 | 1 | Canvas & navigation | 6 | 98% | 74% | Outline mode's Include hidden layers and Include object bounds, Display P3 on screen, QA at extreme zooms (behaviour suite for navigation, rulers, guides, layout grids and outline mode landed: guide selection, Auto grid counts, outline-mode clicks) | 1–4 |
-| 2 | Selection & transform | 8 | 97% | 72% | Handles, measuring and snapping checked tool by tool against Figma and real files (snap distance, handle reach, cursors); children turned off a right angle scale without skew, approximately (behaviour suite from the documentation, rotated groups and mixed selections, equal spacing snapping, Cmd/Ctrl to ignore constraints and marquees inside frames landed; smart-selection rings reorder single layers in regular rows, columns and complete aligned grids, with Command/Ctrl swaps; multi-item marks and irregular-grid insertion remain) | 3–5 |
+| 2 | Selection & transform | 8 | 97% | 72% | Handles, measuring and snapping checked tool by tool against Figma and real files (snap distance, handle reach, cursors); children turned off a right angle scale without skew, approximately (behaviour suite from the documentation, rotated groups and mixed selections, equal spacing snapping, Cmd/Ctrl to ignore constraints and marquees inside frames landed) | 3–5 |
 | 3 | Layers panel | 5 | 99% | 85% | QA with long real files (behaviour suite from the documentation, Rename layers dialog, sweeping eyes and padlocks, page dragging and dividers, several layers dropped together, keyboard box selection, F2 rename, Shift+F10 context menu and 10k-layer timings landed) | 1–2 |
 | 4 | Shapes & vector | 8 | 99% | 73% | Corner smoothing on polygons, stars and vectors; the transform box around points of several layers; per-point caps and joins on dashed, variable-width and brush strokes; vector QA with real files (behaviour suites from the documentation, corner radius and star ratio handles, rounded vector points drawn, also beside curved segments, a cap and join per point, several handles dragged together, cut and paint bucket drags, delete and heal along the curve, a boolean group's look by operation and the miter angle landed) | 1–3 |
 | 5 | Paint | 7 | 90% | 71% | Video fills, wide-gamut canvas, HEIC images; plus darker in PDF (behaviour suite from the documentation, pass-through and isolating groups, clipping frames that don't isolate, plus darker, animated GIF fills, TIFF images and embedded image colour profiles landed) | 2–5 |
@@ -638,7 +638,6 @@ Carried over from the ROADMAP's "Shipped so far" (2026-10-10). The test count th
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-10-18 | minor | Smart-selection center rings insert a layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl-drag swaps entries. Unequal sizes reflow with the original gaps, hierarchy and selection stay intact, and each drag is one undo step. Escape or Undo during the drag cancels; switching documents, pages or tools rolls back the owning gesture. Mixed gaps, incomplete grids and unsupported selections keep spacing controls without reorder rings. Multiple marked items and irregular-grid insertion remain unimplemented. Engine and raw-input UI regression tests; desktop Linux before/during/after screenshots and insertion, undo/redo and Escape checked on synthetic cards. No side-by-side comparison with the incumbent. Headline estimates unchanged. |
 | 2026-10-17 | minor | Menu breadth re-run with `cargo xtask parity`: 212 / 212 (100%; the catalog gained View ▸ Full screen with #227 on 2026-10-14), 561 commands. Rows for the 2026-10-17 landings: import/export (area 14) and the file formats dimension name the `.fig` import's new fidelity (instance identity, overrides by key, text style precedence, grid tracks, slots, connector labels, per-point joins, text on a path, image adjustments, list start numbers, vertical trim), budgets from the file's size, the import report, a `.fig` copy from Save as and paste from another design app; the localization evidence takes the re-measured catalog counts (2,272 entries, drafts at 95–99%, Indonesian and Czech drafts, Swedish and Turkish catalogs); the Automation line adds control requests answered while the window is minimised (#720); batch #753's Selection colors, smart-selection spacing, Present tab and auto layout on empty frames are in ui-parity, prototyping-parity and auto-layout-parity. Numbers unchanged: every `.fig` and paste change is checked on synthetic files or clipboard HTML made from our own export, and real files are what gap 1's blocker and the file-exchange discounts wait for; the UI changes (menus, the Actions palette, editor fixes) are not compared side by side, so UI/UX stays at 58%; the localization grade and hours stay (Indonesian's draft is offset by the drafts' new gaps) |
 | 2026-10-17 | minor | Automation roots (M8, #715, #481): `figcraft-cli mcp --automation-read-root DIR --automation-write-root DIR` (each repeatable, existing folders) and the desktop app with the same flags confine every file a command reads to the read and write roots and every file it writes to the write roots; paths are resolved (links followed, `..`, Windows `\\?\` and UNC paths, case) and compared by whole folder names, anything else is an ordinary error. The engine reaches the file system through one module (enforced by `crates/engine/clippy.toml`), and a sweep runs every command with paths outside the roots. `--attach` refuses the flags (the app confines itself); `ui.screenshot` and `ui.render` return PNG data without a `path`, so the attached MCP server writes no temporary files. Numbers unchanged. |
 | 2026-10-17 | minor | Number variables on text content (M3, #629): the Typography section's variable picker also lists number variables for a text layer's content, as the engine already accepted (the text shows the number, e.g. 42.5, and follows the variable). Other text fields keep their own types. Numbers unchanged. |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index eab5aafe..766284f1 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI and interaction parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (smart-selection drag reordering; a rename selects the whole name, so typing replaces it; Escape or Enter after a pen path stays on the same vector (#760); IME composition kept on through idle frames of a text edit, candidates at the caret (#747); Selection colors for mixed selections and smart-selection spacing (#753); submenus with a hover delay and a safe triangle; the Actions palette's tabs, ranked search, highlight and recents; menu items that ask for a value; editor fixes from the community batches; fields select their text on focus; Typography spacing icons support scrubbing (#373); CSS colour names in hex fields; the Small caps sample in Type settings drawn from capitals; recent files as cards; vector edit mode: hovering, hatching, selecting and dragging filled regions; home screen: Templates tab, first-run templates and Getting started tips; number fields: scrub rates, arrow steps, arithmetic with brackets, relative edits of mixed values; outline mode's hidden layers and object bounds; Hide when publishing; cursors per tool and modifier; panel widths; dark pages for files made in the dark theme; drag threshold and double-clicks into text in groups; rotation origin on Alt+R and placing with Enter: no documented shortcut missing; keyboard shortcut parity suite and bindings; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and the vector edit tail; canvas navigation, guides and grids behaviour suite and fixes; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; layers panel keyboard: F2 rename, Shift+F10 context menu, F8 box selection; selection and transform behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; boolean hit testing on the result, group drags, frame outlines and slices; outlines for the selection, mask outlines; arc fields, live boolean editing, shape builder on strokes, one-sided widths) · **Target:** Figma Design UI3 (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (a rename selects the whole name, so typing replaces it; Escape or Enter after a pen path stays on the same vector (#760); IME composition kept on through idle frames of a text edit, candidates at the caret (#747); Selection colors for mixed selections and smart-selection spacing (#753); submenus with a hover delay and a safe triangle; the Actions palette's tabs, ranked search, highlight and recents; menu items that ask for a value; editor fixes from the community batches; fields select their text on focus; Typography spacing icons support scrubbing (#373); CSS colour names in hex fields; the Small caps sample in Type settings drawn from capitals; recent files as cards; vector edit mode: hovering, hatching, selecting and dragging filled regions; home screen: Templates tab, first-run templates and Getting started tips; number fields: scrub rates, arrow steps, arithmetic with brackets, relative edits of mixed values; outline mode's hidden layers and object bounds; Hide when publishing; cursors per tool and modifier; panel widths; dark pages for files made in the dark theme; drag threshold and double-clicks into text in groups; rotation origin on Alt+R and placing with Enter: no documented shortcut missing; keyboard shortcut parity suite and bindings; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and the vector edit tail; canvas navigation, guides and grids behaviour suite and fixes; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; layers panel keyboard: F2 rename, Shift+F10 context menu, F8 box selection; selection and transform behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; boolean hit testing on the result, group drags, frame outlines and slices; outlines for the selection, mask outlines; arc fields, live boolean editing, shape builder on strokes, one-sided widths) · **Target:** Figma Design UI3 (desktop app 126.10.7)
 
 Fine canvas control is what Figma users feel first: handles, snapping, nudging, modifier keys,
 drag behaviour, numeric precision. This checklist covers the tools, gestures and panels. Status:
@@ -69,7 +69,7 @@ interaction feel not yet compared.
 | Numeric fields: arithmetic, scrubbing by dragging the label, mixed values | done | Numeric panels use `widgets::number_field`; Typography line height, letter spacing and paragraph spacing share its leading-icon scrub logic (#373), retaining their existing unit parsing, Auto/Mixed values, variable chips and selected-character targeting (`typography_scrub_tests`). Scrubbing the label: a step a point (1 px; 1% of opacity, 1° of rotation), ten with Shift, a tenth with Alt, each stretch at the rate held while it was dragged, one undo step when let go; past the edge of the screen it goes on where the platform reports the mouse's own motion (desktop), otherwise it stops there. Arrow keys: Up/Down step a pixel field by the small nudge and Shift by the big nudge (the preferences), other fields by their own step and ten of it; they work while typing (from what is typed) and with the keyboard on the field. Typing: `+ - * /`, brackets, units (`px`, `°`, `%`, `x`, `ms`), a decimal comma; `+10`, `*2`, `/4` are relative to the value, and `50%`, `+10%`, `-10%` too in a field that isn't a percentage. Enter, Tab or a click elsewhere commits (Tab and Shift+Tab move to the next and previous control), Escape restores; a field left as it was commits nothing (no undo step, and a rounded display isn't written back). Mixed values show "Mixed": a number sets them all, a relative edit or an arrow key goes to each layer from its own value in one undo step, for X, Y, W, H, rotation, opacity, corner radius and stroke weight (elsewhere `+10` on Mixed sets 10 and `*2` does nothing) (`field_tests`). Left: scrubbing a Mixed field (nothing happens), `x2`-style suffix edits, the pointer isn't wrapped to the other side of the screen; rates not compared with Figma's |
 | Transform box at small sizes | done | a press inside a layer smaller than its handles moves it, the nearest handle wins, handles answer just outside and are hidden under 16 px on screen; cursors follow each handle and the box's rotation |
 | Locked layers | done | selectable from the layers panel; no handles, not dragged with the rest of a selection |
-| Smart selection spacing | partial | with layers in a row, a column or an aligned grid selected, the Layout section shows horizontal and vertical spacing ("Mixed" until set; typed, scrubbed, fractional and negative) and pink handles in the gaps on the canvas drag them, one undo step, Escape cancels (`arrange.spacing`; sizes, parents and offsets within each track kept; at most 2,000 layers; flow children, locked layers and layers inside instances left out). Center rings drag a single layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl swaps entries. Preview, target outline, Escape cancellation and one-step undo (`arrange.reorder`, `selection_reorder_tests`, `selection_spacing_tests`). Sizes, gaps and layer hierarchy kept. Mixed gaps and incomplete or differently aligned grids have no rings; multiple marked-item dragging remains. Spacing checked by its author on macOS and in the app on Windows (#402) |
+| Smart selection spacing | partial | with layers in a row, a column or an aligned grid selected, the Layout section shows horizontal and vertical spacing ("Mixed" until set; typed, scrubbed, fractional and negative) and pink handles in the gaps on the canvas drag them, one undo step, Escape cancels (`arrange.spacing`; sizes, parents and offsets within each track kept; at most 2,000 layers; flow children, locked layers and layers inside instances left out). No reorder rings for swapping layers; checked by its author on macOS and in the app on Windows (#402) |
 | Selection colors | partial | for a mixed selection the Design panel lists their solid and gradient paints (children and text ranges included; hidden paints, masks, images, patterns and boolean operands left out; styles and variables listed apart): editing a colour changes every matching fill and stroke in one undo step, a row selects the layers that use it or applies a colour style of the document (`selection.colors`, `selection.setPaint`, `selection.applyColorStyle`, `selection.selectColor`). No library styles or variable binding from there (#403) |
 | Keyboard box selection | done | Alt+Space on macOS, Ctrl+Space on Windows and Linux, or F8 (`select.area`): a box around the selection or in the middle of the view; arrows move it, Cmd/Ctrl+arrows or Shift+arrows size it (Shift with Cmd/Ctrl: farther), Enter selects like a marquee (Shift+Enter toggles, Cmd/Ctrl+Enter nested), Escape closes |
 
@@ -172,7 +172,6 @@ in the table. `crates/ui-egui/src/shortcut_keys_tests.rs` drives the keys a look
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-10-18 | minor | Smart-selection center rings insert a layer through a regular row, column or complete top-left-aligned grid; Command/Ctrl-drag swaps entries. Unequal sizes reflow with the original gaps, hierarchy and selection stay intact, and each drag is one undo step. Escape or Undo during the drag cancels; switching documents, pages or tools rolls back the owning gesture. Mixed gaps, incomplete grids and unsupported selections keep spacing controls without reorder rings. Multiple marked items and irregular-grid insertion remain unimplemented. Engine and raw-input UI regression tests; desktop Linux before/during/after screenshots and insertion, undo/redo and Escape checked on synthetic cards. No side-by-side comparison with the incumbent. Headline estimates unchanged. |
 | 2026-10-18 | minor | A rename (layers double-click, F2, File ▸ Rename, a page) selects the whole name in the frame its field first draws, so the first key replaces the name instead of being appended. Checked in the app on Windows over the control channel |
 | 2026-10-17 | minor | Escape or Enter while the pen draws ends the path and keeps its vector in edit mode with the pen, so the next path is drawn into the same layer (unconnected); another Escape leaves edit mode (#760). Entering edit mode on a layer that already is a vector no longer records an empty undo step. Numbers unchanged |
 | 2026-10-17 | minor | Text layers keep the platform IME on for every frame of an edit, not only frames with input (an idle frame turned it off and macOS dropped each composition, #747); the candidate window opens at the caret instead of the canvas corner; keys pressed while composing go to the IME |

From cfbb5a8f504f3c0150b0ee404621a1ac20da38cd Mon Sep 17 00:00:00 2001
From: bflatastic <bombayapirat@gmail.com>
Date: Mon, 19 Oct 2026 23:49:01 +0700
Subject: [PATCH 3/5] #854: no help-centre URL in selection_reorder.rs

---
 crates/engine/src/selection_reorder.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/engine/src/selection_reorder.rs b/crates/engine/src/selection_reorder.rs
index e538fc8b..d54109c7 100644
--- a/crates/engine/src/selection_reorder.rs
+++ b/crates/engine/src/selection_reorder.rs
@@ -1,7 +1,6 @@
 //! Geometry for reordering a smart selection. Only regular, non-overlapping rows, columns
 //! and complete top-left-aligned grids have unambiguous insertion slots.
-//! Behavior reference: https://help.figma.com/hc/en-us/articles/360040450233
-//! (public documentation only; multi-item marking and irregular grids remain out of scope).
+//! Marking several items and irregular grids are out of scope.
 use figcraft_doc::{Document, NodeId};
 use figcraft_geom::{Point, Rect};
 

From 109b90c0aac1a9c881e126c2389da07858efa4d0 Mon Sep 17 00:00:00 2001
From: bflatastic <bombayapirat@gmail.com>
Date: Mon, 19 Oct 2026 23:49:02 +0700
Subject: [PATCH 4/5] #854: locale entries in sorted position

---
 crates/ui-egui/locales/en.toml | 2 +-
 crates/ui-egui/locales/es.toml | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/ui-egui/locales/en.toml b/crates/ui-egui/locales/en.toml
index 132fda0b..0544eccc 100644
--- a/crates/ui-egui/locales/en.toml
+++ b/crates/ui-egui/locales/en.toml
@@ -8,7 +8,6 @@
 name = "English"
 
 [ui]
-"Reorder selection" = "Reorder selection"
 "% of all commits" = "% of all commits"
 "(no longer published)" = "(no longer published)"
 "({n} warnings: some entries were skipped)" = { one = "({n} warning: some entries were skipped)", other = "({n} warnings: some entries were skipped)" }
@@ -1101,6 +1100,7 @@ name = "English"
 "Rename on the server…" = "Rename on the server…"
 "Rename page" = "Rename page"
 "Rename to" = "Rename to"
+"Reorder selection" = "Reorder selection"
 "Replace all" = "Replace all"
 "Replace mixed export settings" = "Replace mixed export settings"
 "Replace with" = "Replace with"
diff --git a/crates/ui-egui/locales/es.toml b/crates/ui-egui/locales/es.toml
index dc8bc40b..862f0570 100644
--- a/crates/ui-egui/locales/es.toml
+++ b/crates/ui-egui/locales/es.toml
@@ -8,7 +8,6 @@ name = "Español"
 status = "draft — needs native review"
 
 [ui]
-"Reorder selection" = "Reordenar selección"
 "Compatibility notes" = "Notas de compatibilidad"
 "Couldn't download the variables" = "No se pudieron descargar las variables"
 
@@ -1102,6 +1101,7 @@ status = "draft — needs native review"
 "Rename on the server…" = "Cambiar el nombre en el servidor…"
 "Rename page" = "Cambiar nombre de página"
 "Rename to" = "Nuevo nombre"
+"Reorder selection" = "Reordenar selección"
 "Replace all" = "Reemplazar todo"
 "Replace mixed export settings" = "Reemplazar ajustes de exportación mixtos"
 "Replace with" = "Reemplazar con"
@@ -1743,7 +1743,6 @@ status = "draft — needs native review"
 "⌥ drag" = "⌥ arrastrar"
 
 [commands]
-"arrange.reorder" = "Reordenar selección"
 "align.bottom" = "Alinear abajo"
 "align.hcenter" = "Alinear centros horizontales"
 "align.left" = "Alinear a la izquierda"
@@ -1766,6 +1765,7 @@ status = "draft — needs native review"
 "arrange.front" = "Traer al frente"
 "arrange.packH" = "Agrupar en horizontal"
 "arrange.packV" = "Agrupar en vertical"
+"arrange.reorder" = "Reordenar selección"
 "arrange.roundToPixels" = "Redondear a píxeles"
 "arrange.spacing" = "Espaciado"
 "arrange.tidy" = "Ordenar"

From bb793470f1c30d3df6cfcf44148af37acaa7cd7d Mon Sep 17 00:00:00 2001
From: bflatastic <bombayapirat@gmail.com>
Date: Mon, 19 Oct 2026 23:49:03 +0700
Subject: [PATCH 5/5] #854: no reorder ring on a layer under 16 px on screen,
 and its hit radius is at most a quarter of the layer, so a small layer still
 drags the selection

---
 crates/ui-egui/src/selection_spacing.rs       | 17 ++++++++----
 crates/ui-egui/src/selection_spacing_tests.rs | 26 +++++++++++++++++++
 2 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/crates/ui-egui/src/selection_spacing.rs b/crates/ui-egui/src/selection_spacing.rs
index 01e32d30..3a39955a 100644
--- a/crates/ui-egui/src/selection_spacing.rs
+++ b/crates/ui-egui/src/selection_spacing.rs
@@ -61,6 +61,15 @@ fn drag_id() -> Id {
     Id::new("selection_spacing_drag")
 }
 
+/// The reorder ring of a layer with world bounds `b`: its centre on screen and hit radius. The
+/// radius is 8 px, at most a quarter of the layer's smaller side on screen, so most of a small
+/// layer still drags the selection; a layer under 16 px on screen has no ring.
+fn ring(app: &FigApp, b: figcraft_geom::Rect) -> Option<(Pos2, f32)> {
+    let zoom = app.session.ds().map_or(1.0, |d| d.view.zoom);
+    let side = ((b.x1 - b.x0).min(b.y1 - b.y0) * zoom) as f32;
+    (side >= 16.0).then(|| (app.to_screen((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5), (side / 4.0).min(8.0)))
+}
+
 #[derive(Clone)]
 enum Action {
     Spacing { axis: Axis, value: f64, last_value: Option<f64> },
@@ -279,8 +288,7 @@ pub fn input(app: &mut FigApp, ctx: &egui::Context, pos: Option<Pos2>, hovered:
     let ids = app.session.selection();
     if let Some(reorder) = reorder_layout(app, ctx, &ids) {
         for (id, b) in &reorder.slots {
-            let center = app.to_screen((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5);
-            if center.distance(p) <= 8.0 {
+            if ring(app, *b).is_some_and(|(center, r)| center.distance(p) <= r) {
                 ctx.set_cursor_icon(CursorIcon::Grab);
                 if ctx.input(|i| i.pointer.primary_pressed()) {
                     let source = *id;
@@ -329,9 +337,8 @@ pub fn draw(app: &FigApp, painter: &egui::Painter) {
     };
     if let Some(layout) = reorder {
         for (id, _) in &layout.slots {
-            let Some(b) = ds.doc.world_bounds(*id) else { continue };
-            let center = app.to_screen((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5);
-            let hot = hover.is_some_and(|p| center.distance(p) <= 8.0);
+            let Some((center, r)) = ds.doc.world_bounds(*id).and_then(|b| ring(app, b)) else { continue };
+            let hot = hover.is_some_and(|p| center.distance(p) <= r);
             let active = matches!(drag.as_ref().map(|d| &d.action), Some(Action::Reorder { source, .. }) if source == id);
             if active {
                 painter.circle_filled(center, 4.5, PINK);
diff --git a/crates/ui-egui/src/selection_spacing_tests.rs b/crates/ui-egui/src/selection_spacing_tests.rs
index 685f7b4e..2ee44742 100644
--- a/crates/ui-egui/src/selection_spacing_tests.rs
+++ b/crates/ui-egui/src/selection_spacing_tests.rs
@@ -333,3 +333,29 @@ fn an_externally_finished_reorder_cannot_resume_on_later_pointer_motion() {
     assert_eq!(u.app.session.undo_depth().0, history);
     assert_eq!(xy(&u, ids[0]), (260., 100.));
 }
+
+#[test]
+fn small_layers_on_screen_have_no_reorder_ring_and_drag_the_selection_from_their_middle() {
+    let mut u = Ui::new(Session::new());
+    let z = u.app.session.ds().unwrap().view.zoom;
+    // 12 px squares 36 px apart on screen: a regular row, too small for rings.
+    let ids: Vec<NodeId> = (0..3)
+        .map(|col| {
+            let p = json!({"x": (100. + f64::from(col) * 36.) / z, "y": 100. / z, "width": 12. / z, "height": 12. / z});
+            NodeId(u.app.session.execute("shape.rectangle", &p).unwrap()["id"].as_u64().unwrap())
+        })
+        .collect();
+    u.app.session.execute("select.set", &json!({"ids": ids})).unwrap();
+    let before: Vec<_> = ids.iter().map(|id| xy(&u, *id)).collect();
+    let p = u.app.to_screen(before[0].0 + 6. / z, before[0].1 + 6. / z);
+    let output = u.frame_output(vec![Event::PointerMoved(p)]);
+    assert_ne!(output.platform_output.cursor_icon, egui::CursorIcon::Grab);
+    drag(&mut u, p, vec2(0., 60.), true);
+    let after: Vec<_> = ids.iter().map(|id| xy(&u, *id)).collect();
+    assert!(after[0].1 > before[0].1, "the selection moved: {before:?} -> {after:?}");
+    assert!(
+        before.iter().zip(&after).all(|(b, a)| (a.0 - b.0).abs() < 1e-6 && (a.1 - b.1 - (after[0].1 - before[0].1)).abs() < 1e-6),
+        "all together, in order"
+    );
+    assert_eq!(u.app.session.selection(), ids);
+}