Merge the landing branch into land-r8

# Conflicts:
#	contributors/people.toml
#	crates/engine/src/cmd/file.rs
#	crates/pptx/src/opc.rs
#	crates/pptx/tests/roundtrip.rs
#	crates/ui-egui/src/backstage.rs
#	crates/ui-egui/src/lib.rs

crates/engine/src/cmd/animation.rs

@@ -28,7 +28,7 @@ pub fn specs() -> Vec<CommandSpec> {
             has_selection,
             add
         ),
-        cmd!("animation.remove", "Remove Animation", ["Animation Pane"], None, "{index} | {ids?} (all of the shapes' animations)", has_slide, remove),
+        cmd!("animation.remove", "Remove Animation", ["Animation Pane"], None, "{index} | {ids? (all of the shapes' animations)}", has_slide, remove),
         cmd!("animation.move", "Reorder Animation", ["Animations", "Timing"], None, "{index, to}", has_slide, move_anim),
         cmd!(
             "animation.timing",

crates/engine/src/cmd/design.rs

@@ -43,7 +43,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Format Background",
             ["Design", "Customize"],
             None,
-            "{color? | gradient? | picture?: base64 | style?: 1..12 | reset?, all?: bool (apply to all), index?}",
+            "{color? | gradient? | picture?: base64 | pattern? | style?: 1..12 | reset?, all?: bool, index?, transparency?: 0..1, pictureProps?: {tile?, offsetX?, offsetY?: pt, scaleX?, scaleY?: 0.01..10, align?, mirror?, stretch?: [l,t,r,b], rotateWithShape?}, copy?: bool}",
             has_slide,
             background
         ),
@@ -53,7 +53,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Slide Size",
             ["Design", "Customize"],
             None,
-            "{preset?: widescreen|standard|… | w, h: pt, orientation?: portrait|landscape, scale?: maximize|ensureFit|none}",
+            "{preset: widescreen|standard|…, orientation?: portrait|landscape, scale?: maximize|ensureFit|none} | {w: pt, h: pt, orientation?: portrait|landscape, scale?: maximize|ensureFit|none}",
             has_doc,
             slide_size
         ),
@@ -152,7 +152,7 @@ fn browse_theme(s: &mut Session, p: &Value) -> Result<Value> {
         #[cfg(not(target_arch = "wasm32"))]
         {
             let path = str_param(p, "path").ok_or_else(|| bad("design.browseTheme", "give `path` or `data`"))?;
-            std::fs::read(path).map_err(|e| crate::EngineError::Other(format!("{path}: {e}")))?
+            crate::io::read_file(path).map_err(crate::EngineError::Other)?
         }
         #[cfg(target_arch = "wasm32")]
         return Err(bad("design.browseTheme", "give `data`"));
@@ -480,70 +480,256 @@ fn effects(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn background(s: &mut Session, p: &Value) -> Result<Value> {
-    let bg: Option<Background> = if bool_or(p, "reset", false) {
-        None
-    } else if let Some(c) = color_param(p, "color") {
-        Some(Background::Fill { fill: Fill::solid(c) })
-    } else if let Some(i) = usize_param(p, "style") {
+    if bool_or(p, "copy", false) {
+        return copy_slide_background(s);
+    }
+    let props = p.get("pictureProps").filter(|v| v.is_object()).cloned();
+    let transparency = f64_param(p, "transparency");
+    let reset = bool_or(p, "reset", false);
+    let color = color_param(p, "color");
+    let style = usize_param(p, "style");
+    let op = if reset {
+        BgOp::Set(None)
+    } else if let Some(mut c) = color {
+        if let Some(t) = transparency {
+            set_solid_transparency(&mut c, t);
+        }
+        BgOp::Set(Some(Background::Fill { fill: Fill::solid(c) }))
+    } else if let Some(i) = style {
         // Background styles: 3 theme bg fills × 4 colours (bg1, bg2, tx1, tx2).
         let slots =
             [deckcraft_color::SchemeSlot::Bg1, deckcraft_color::SchemeSlot::Bg2, deckcraft_color::SchemeSlot::Tx2, deckcraft_color::SchemeSlot::Tx1];
         let i = i.clamp(1, 12) - 1;
-        Some(Background::Ref {
+        BgOp::Set(Some(Background::Ref {
             idx: 1001 + (i / 4) as u32,
             color: deckcraft_model::ColorRef::scheme(slots.get(i % 4).copied().unwrap_or(deckcraft_color::SchemeSlot::Bg1)),
-        })
+        }))
     } else if let Some(g) = p.get("gradient") {
         let mut g = super::shape::gradient_param(g).ok_or_else(|| bad("design.background", "gradient needs two or more `stops`"))?;
         g.rotate_with_shape = false;
-        Some(Background::Fill { fill: Fill::Gradient(g) })
+        BgOp::Set(Some(Background::Fill { fill: Fill::Gradient(g) }))
     } else if let Some(pt) = p.get("pattern") {
-        Some(Background::Fill {
+        BgOp::Set(Some(Background::Fill {
             fill: Fill::Pattern(deckcraft_model::style::PatternFill {
                 preset: pt.get("preset").and_then(Value::as_str).unwrap_or("pct50").to_string(),
                 fg: pt.get("fg").and_then(color_value).unwrap_or(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Accent1)),
                 bg: pt.get("bg").and_then(color_value).unwrap_or(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Bg1)),
             }),
-        })
+        }))
     } else if p.get("picture").is_some() {
         let (name, bytes) = super::insert::media_bytes(&with_param(p, "data", p.get("picture").cloned().unwrap_or_default()), "design.background")?;
         let ct = super::insert::content_type(&name, &bytes);
         let media = s.edit(|doc, _| Ok(doc.add_media(&name, ct, bytes)))?;
-        Some(Background::Fill { fill: Fill::Picture(deckcraft_model::style::PictureFill { media, ..Default::default() }) })
+        let mut pf = deckcraft_model::style::PictureFill { media, ..Default::default() };
+        if let Some(pp) = &props {
+            apply_picture_props(&mut pf, pp);
+        }
+        if let Some(t) = transparency {
+            set_picture_transparency(&mut pf, t);
+        }
+        BgOp::Set(Some(Background::Fill { fill: Fill::Picture(pf) }))
+    } else if props.is_some() || transparency.is_some() {
+        BgOp::Adjust
     } else {
-        return Err(bad("design.background", "give `color`, `gradient`, `pattern`, `picture`, `style` or `reset`"));
+        return Err(bad(
+            "design.background",
+            "give `color`, `gradient`, `pattern`, `picture`, `style`, `reset`, `pictureProps`, `transparency` or `copy`",
+        ));
     };
     let all = bool_or(p, "all", false);
     let index = usize_param(p, "index");
+    if matches!(op, BgOp::Adjust) {
+        let next = {
+            let st = s.doc()?;
+            let current = background_of(&st.doc, &st.selection, index);
+            let picture = matches!(current, Some(Background::Fill { fill: Fill::Picture(_) }));
+            let solid = matches!(current, Some(Background::Fill { fill: Fill::Solid { .. } }));
+            if props.is_some() && !picture {
+                return Err(bad("design.background", "picture options need a picture background"));
+            }
+            if transparency.is_some() && !picture && !solid {
+                return Err(bad("design.background", "transparency needs a solid or picture background"));
+            }
+            let mut next = current.clone();
+            if let Some(bg) = next.as_mut() {
+                adjust_background(bg, props.as_ref(), transparency);
+            }
+            if next == current { None } else { Some(next) }
+        };
+        let Some(next) = next else { return ok() };
+        s.edit(|doc, sel| {
+            write_background(doc, sel, index, false, next);
+            Ok(())
+        })?;
+        return ok();
+    }
+    let BgOp::Set(bg) = op else { return ok() };
+    let unchanged = {
+        let st = s.doc()?;
+        backgrounds_already(&st.doc, &st.selection, index, all, &bg)
+    };
+    if unchanged {
+        return ok();
+    }
     s.edit(|doc, sel| {
-        match sel.target {
-            Target::Master { master } => {
-                if let Some(m) = doc.masters.get_mut(master) {
-                    Arc::make_mut(m).background = bg.clone();
+        write_background(doc, sel, index, all, bg);
+        Ok(())
+    })?;
+    ok()
+}
+
+enum BgOp {
+    Set(Option<Background>),
+    Adjust,
+}
+
+fn background_of(doc: &Presentation, sel: &crate::Selection, index: Option<usize>) -> Option<Background> {
+    match sel.target {
+        Target::Master { master } => doc.masters.get(master).and_then(|m| m.background.clone()),
+        Target::Layout { master, layout } => doc.masters.get(master).and_then(|m| m.layouts.get(layout)).and_then(|l| l.background.clone()),
+        t @ (Target::Handout | Target::NotesMaster) => crate::page_master(doc, t).and_then(|m| m.background.clone()),
+        Target::Slides => doc.slides.get(index.unwrap_or(sel.slide)).and_then(|sl| sl.background.clone()),
+    }
+}
+
+fn backgrounds_already(doc: &Presentation, sel: &crate::Selection, index: Option<usize>, all: bool, bg: &Option<Background>) -> bool {
+    match sel.target {
+        Target::Master { master } => doc.masters.get(master).is_some_and(|m| m.background == *bg),
+        Target::Layout { master, layout } => doc.masters.get(master).and_then(|m| m.layouts.get(layout)).is_some_and(|l| l.background == *bg),
+        t @ (Target::Handout | Target::NotesMaster) => crate::page_master(doc, t).is_some_and(|m| m.background == *bg),
+        Target::Slides => {
+            let list: Vec<usize> = if all { (0..doc.slides.len()).collect() } else { vec![index.unwrap_or(sel.slide)] };
+            !list.is_empty() && list.iter().all(|i| doc.slides.get(*i).is_some_and(|sl| sl.background == *bg))
+        }
+    }
+}
+
+fn write_background(doc: &mut Presentation, sel: &crate::Selection, index: Option<usize>, all: bool, bg: Option<Background>) {
+    match sel.target {
+        Target::Master { master } => {
+            if let Some(m) = doc.masters.get_mut(master) {
+                Arc::make_mut(m).background = bg;
+            }
+        }
+        Target::Layout { master, layout } => {
+            if let Some(l) = doc.masters.get_mut(master).and_then(|m| Arc::make_mut(m).layouts.get_mut(layout)) {
+                l.background = bg;
+            }
+        }
+        t @ (Target::Handout | Target::NotesMaster) => {
+            if let Some(m) = crate::page_master_mut(doc, t) {
+                Arc::make_mut(m).background = bg;
+            }
+        }
+        Target::Slides => {
+            let list: Vec<usize> = if all { (0..doc.slides.len()).collect() } else { vec![index.unwrap_or(sel.slide)] };
+            for i in list {
+                if let Some(sl) = doc.slides.get_mut(i) {
+                    Arc::make_mut(sl).background = bg.clone();
                 }
             }
-            Target::Layout { master, layout } => {
-                if let Some(l) = doc.masters.get_mut(master).and_then(|m| Arc::make_mut(m).layouts.get_mut(layout)) {
-                    l.background = bg.clone();
-                }
+        }
+    }
+}
+
+fn copy_slide_background(s: &mut Session) -> Result<Value> {
+    let bg = {
+        let st = s.doc()?;
+        if !matches!(st.selection.target, Target::Slides) {
+            return Err(bad("design.background", "copy applies to slides"));
+        }
+        let bg = st.doc.slides.get(st.selection.slide).and_then(|sl| sl.background.clone());
+        if st.doc.slides.iter().all(|sl| sl.background == bg) {
+            return ok();
+        }
+        bg
+    };
+    s.edit(|doc, sel| {
+        write_background(doc, sel, None, true, bg);
+        Ok(())
+    })?;
+    ok()
+}
+
+fn adjust_background(bg: &mut Background, props: Option<&Value>, transparency: Option<f64>) {
+    match bg {
+        Background::Fill { fill: Fill::Picture(pf) } => {
+            if let Some(pp) = props {
+                apply_picture_props(pf, pp);
             }
-            t @ (Target::Handout | Target::NotesMaster) => {
-                if let Some(m) = crate::page_master_mut(doc, t) {
-                    Arc::make_mut(m).background = bg.clone();
-                }
+            if let Some(t) = transparency {
+                set_picture_transparency(pf, t);
             }
-            Target::Slides => {
-                let list: Vec<usize> = if all { (0..doc.slides.len()).collect() } else { vec![index.unwrap_or(sel.slide)] };
-                for i in list {
-                    if let Some(sl) = doc.slides.get_mut(i) {
-                        Arc::make_mut(sl).background = bg.clone();
+        }
+        Background::Fill { fill: Fill::Solid { color } } => {
+            if let Some(t) = transparency {
+                set_solid_transparency(color, t);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn set_picture_transparency(pf: &mut deckcraft_model::style::PictureFill, t: f64) {
+    let a = 1.0 - t.clamp(0.0, 1.0);
+    pf.alpha = (a < 1.0).then_some(a);
+}
+
+fn set_solid_transparency(color: &mut deckcraft_model::ColorRef, t: f64) {
+    color.mods.retain(|m| !matches!(m, deckcraft_color::ColorTransform::Alpha(_)));
+    let t = t.clamp(0.0, 1.0);
+    if t > 0.0 {
+        color.mods.push(deckcraft_color::ColorTransform::Alpha(((1.0 - t) * 100_000.0).round() as i32));
+    }
+}
+
+/// Picture-fill options for Format Background (tile, offsets, scale, alignment, mirror, stretch).
+fn apply_picture_props(pf: &mut deckcraft_model::style::PictureFill, pp: &Value) {
+    use deckcraft_model::style::PictureMode;
+    let f = |k: &str| pp.get(k).and_then(Value::as_f64).filter(|v| v.is_finite());
+    if let Some(up) = pp.get("rotateWithShape").and_then(Value::as_bool) {
+        pf.upright = !up;
+    }
+    match pp.get("tile").and_then(Value::as_bool) {
+        Some(true) if !matches!(pf.mode, PictureMode::Tile { .. }) => {
+            pf.mode = PictureMode::Tile { tx: 0.0, ty: 0.0, sx: 1.0, sy: 1.0, flip: "none".into(), align: "tl".into() };
+        }
+        Some(false) if !matches!(pf.mode, PictureMode::Stretch { .. }) => pf.mode = PictureMode::default(),
+        _ => {}
+    }
+    match &mut pf.mode {
+        PictureMode::Tile { tx, ty, sx, sy, flip, align } => {
+            if let Some(v) = f("offsetX") {
+                *tx = v.clamp(-4000.0, 4000.0);
+            }
+            if let Some(v) = f("offsetY") {
+                *ty = v.clamp(-4000.0, 4000.0);
+            }
+            if let Some(v) = f("scaleX") {
+                *sx = v.clamp(0.01, 10.0);
+            }
+            if let Some(v) = f("scaleY") {
+                *sy = v.clamp(0.01, 10.0);
+            }
+            if let Some(m) = pp.get("mirror").and_then(Value::as_str).filter(|m| matches!(*m, "none" | "x" | "y" | "xy")) {
+                *flip = m.to_string();
+            }
+            if let Some(a) =
+                pp.get("align").and_then(Value::as_str).filter(|a| matches!(*a, "tl" | "t" | "tr" | "l" | "ctr" | "r" | "bl" | "b" | "br"))
+            {
+                *align = a.to_string();
+            }
+        }
+        PictureMode::Stretch { fill_rect } => {
+            if let Some(arr) = pp.get("stretch").and_then(Value::as_array) {
+                for (slot, v) in fill_rect.iter_mut().zip(arr) {
+                    if let Some(v) = v.as_f64().filter(|v| v.is_finite()) {
+                        *slot = v.clamp(-10.0, 0.99);
                     }
                 }
             }
         }
-        Ok(())
-    })?;
-    ok()
+    }
 }
 
 fn hide_bg_graphics(s: &mut Session, p: &Value) -> Result<Value> {
@@ -1266,7 +1452,9 @@ fn slide_number_paragraph() -> deckcraft_model::Paragraph {
 #[cfg(test)]
 mod tests {
     use deckcraft_color::SchemeSlot;
+    use deckcraft_model::style::PictureMode;
     use deckcraft_model::theme::{FontScheme, ScriptFont, builtin_color_schemes, builtin_font_schemes};
+    use deckcraft_model::{Background, Fill};
     use serde_json::{Value, json};
 
     use crate::{Session, UiRequest};
@@ -1283,6 +1471,21 @@ mod tests {
         s.doc().unwrap().history.undo.len()
     }
 
+    fn png() -> String {
+        let mut img = image::RgbaImage::new(2, 2);
+        img.put_pixel(0, 0, image::Rgba([10, 20, 30, 255]));
+        let mut bytes = Vec::new();
+        image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut bytes), image::ImageFormat::Png).unwrap();
+        crate::cmd::base64_encode(&bytes)
+    }
+
+    fn picture(s: &Session) -> deckcraft_model::style::PictureFill {
+        match &s.doc().unwrap().doc.slides[0].background {
+            Some(Background::Fill { fill: Fill::Picture(pf) }) => pf.clone(),
+            other => panic!("expected a picture background, got {other:?}"),
+        }
+    }
+
     #[test]
     fn civil_dates() {
         assert_eq!(super::civil(0), (1970, 1, 1));
@@ -1453,6 +1656,72 @@ mod tests {
         assert_eq!(font_scheme(&s).major.ea, "Kept");
         assert_eq!(font_scheme(&s).minor.latin, "Open Sans");
     }
+
+    #[test]
+    fn background_picture_options_tile_transparency_and_copy() {
+        let mut s = Session::with_new();
+        let n = undo_len(&s);
+        let err = s.execute("design.background", &json!({"pictureProps": {"tile": true}})).unwrap_err().to_string();
+        assert!(err.contains("picture background"), "{err}");
+        assert!(s.execute("design.background", &json!({"transparency": 0.2})).is_err());
+        assert_eq!(undo_len(&s), n);
+
+        s.execute("design.background", &json!({"color": "accent1", "transparency": 0.25})).unwrap();
+        match &s.doc().unwrap().doc.slides[0].background {
+            Some(Background::Fill { fill: Fill::Solid { color } }) => assert!((color.alpha() - 0.75).abs() < 1e-4, "{}", color.alpha()),
+            other => panic!("expected a solid background, got {other:?}"),
+        }
+        let n = undo_len(&s);
+        s.execute("design.background", &json!({"transparency": 0.25})).unwrap();
+        assert_eq!(undo_len(&s), n, "the same transparency is not an undo step");
+
+        s.execute("design.background", &json!({"picture": png(), "name": "dot.png", "transparency": 0.4, "pictureProps": {"tile": true}})).unwrap();
+        let pf = picture(&s);
+        assert!((pf.alpha.unwrap_or(1.0) - 0.6).abs() < 1e-6);
+        assert!(matches!(pf.mode, PictureMode::Tile { .. }));
+        let n = undo_len(&s);
+
+        s.execute(
+            "design.background",
+            &json!({"pictureProps": {"offsetX": 12.0, "offsetY": -3.0, "scaleX": 0.5, "scaleY": 50.0, "align": "ctr", "mirror": "xy", "rotateWithShape": false}}),
+        )
+        .unwrap();
+        match picture(&s).mode {
+            PictureMode::Tile { tx, ty, sx, sy, flip, align } => {
+                assert_eq!((tx, ty, sx, sy), (12.0, -3.0, 0.5, 10.0));
+                assert_eq!(flip, "xy");
+                assert_eq!(align, "ctr");
+            }
+            other => panic!("expected a tile, got {other:?}"),
+        }
+        assert!(picture(&s).upright);
+        s.execute("design.background", &json!({"pictureProps": {"align": "bogus", "offsetX": "nope"}})).unwrap();
+        match picture(&s).mode {
+            PictureMode::Tile { tx, align, .. } => {
+                assert_eq!(tx, 12.0);
+                assert_eq!(align, "ctr");
+            }
+            other => panic!("expected the tile to stay, got {other:?}"),
+        }
+        assert_eq!(undo_len(&s), n + 1, "ignored options are not an undo step");
+
+        s.execute("design.background", &json!({"pictureProps": {"tile": false, "stretch": [0.1, 0.2, 0.0, 0.0]}})).unwrap();
+        match picture(&s).mode {
+            PictureMode::Stretch { fill_rect } => assert_eq!(fill_rect, [0.1, 0.2, 0.0, 0.0]),
+            other => panic!("expected a stretch, got {other:?}"),
+        }
+
+        s.execute("slide.new", &json!({})).unwrap();
+        assert!(s.doc().unwrap().doc.slides[1].background.is_none());
+        s.execute("slide.go", &json!({"index": 0})).unwrap();
+        let n = undo_len(&s);
+        s.execute("design.background", &json!({"copy": true})).unwrap();
+        assert_eq!(s.doc().unwrap().doc.slides[1].background, s.doc().unwrap().doc.slides[0].background);
+        assert_eq!(undo_len(&s), n + 1);
+        assert_eq!(s.doc().unwrap().history.undo.last().unwrap().label, "Format Background");
+        s.execute("design.background", &json!({"copy": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1, "copying an already shared background is not an undo step");
+    }
 }
 
 #[cfg(test)]

crates/engine/src/cmd/file.rs

@@ -33,7 +33,7 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "file.saveAs", "Save As…", ["File"], Some("Cmd+Shift+S"), "{path, format?}", has_doc, save_as),
         cmd!(noundo "file.saveTemplate", "Save as Template…", ["File"], None, "{path}", has_doc, save_as),
         cmd!(query "file.saveBytes", "Save to Data", [], None, "{format?: deckcraft|pptx} → {data: base64}", has_doc, save_bytes_cmd),
-        cmd!(noundo "file.export", "Export…", ["File"], None, "{path, format: png|jpeg|pptx|deckcraft|outline|pdf, slide?: index, all?: bool, scale?: px per pt; pdf: layout?: slides|notes|handouts, perPage?: 1|2|3|4|6|9, paper?: letter|a4|legal|a3, orientation?: portrait|landscape, dpi?, slides?: [index] | \"1-3,5\", includeHidden?, textLayer?, frame?}", has_doc, export),
+        cmd!(noundo "file.export", "Export…", ["File"], None, "{path, format?: png|jpeg|pptx|deckcraft|outline|pdf|gif (else by path), slide?: index, all?: bool, scale?: px per pt, layout?: slides|notes|handouts (pdf), perPage?: 1|2|3|4|6|9, paper?: letter|a4|legal|a3 (pdf), orientation?: portrait|landscape (pdf), dpi?, slides?: [index]|range (\"1-3,5\"), includeHidden?, textLayer?, frame?, width?: px 16-3840|small|medium|large|extraLarge (gif), secondsPerSlide?: 0.1-600 (gif; 5), loop?: bool (gif; true: forever)} → {path, bytes} or {files} (png, jpeg); gif adds frames, width, height, secondsPerSlide", has_doc, export),
         cmd!(
             query "file.info",
             "Info",
@@ -66,7 +66,7 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "file.recovery.save", "Save AutoRecover Information", [], None, "{} → {written}", has_doc, recovery_save),
         cmd!(query "file.recovery.list", "Recovered Presentations", [], None, "{} → [{uid, path, title, saved}]", always, recovery_list),
         cmd!(noundo "file.recovery.open", "Open Recovered Presentations", [], None, "{} → {opened: [document index]}", always, recovery_open),
-        cmd!(noundo "file.recovery.discard", "Discard Recovered Presentations", [], None, "{uid?: one entry, else all}", always, recovery_discard),
+        cmd!(noundo "file.recovery.discard", "Discard Recovered Presentations", [], None, "{uid?: one entry (else all)}", always, recovery_discard),
         cmd!(noundo "file.revert", "Revert", [], None, "{}", has_doc, revert),
         cmd!(noundo "window.next", "Next Window", ["Window"], Some("Cmd+`"), "{index?}", has_doc, next_window),
     ]
@@ -187,7 +187,7 @@ pub struct LoadedFile {
 /// Read and parse the presentation at `path`.
 #[cfg(not(target_arch = "wasm32"))]
 pub fn read_presentation_file(path: &str) -> Result<LoadedFile> {
-    let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
+    let bytes = crate::io::read_file(path).map_err(EngineError::Other)?;
     let (doc, damaged) = open_checked(path, &bytes)?;
     let native = deckcraft_format::sniff(&bytes) || deckcraft_pptx::sniff(&bytes);
     Ok(LoadedFile { path: path.to_string(), doc, native, damaged })
@@ -257,12 +257,13 @@ fn report_damage(s: &mut Session, damaged: &[String]) -> Result<()> {
     Ok(())
 }
 
-/// Encode the presentation in `format` (`deckcraft`, `pptx`, `potx`, `ppsx`, `outline`, `pdf`).
+/// Encode the presentation in `format` (`deckcraft`, `pptx`, `potx`, `ppsx`, `outline`, `pdf`, `gif`).
 pub fn save_bytes(doc: &Presentation, format: &str) -> Result<Vec<u8>> {
     match format {
         f @ ("pptx" | "potx" | "ppsx") => deckcraft_pptx::export_as(doc, f).map_err(|e| EngineError::Other(e.to_string())),
         "outline" | "txt" => Ok(deckcraft_format::slides_to_outline(doc).into_bytes()),
         "pdf" => deckcraft_pdf::export(doc, &Default::default()).map_err(|e| EngineError::Other(e.to_string())),
+        "gif" => gif_bytes(doc, &Value::Null),
         _ => deckcraft_format::save(doc).map_err(|e| EngineError::Other(e.to_string())),
     }
 }
@@ -336,16 +337,21 @@ pub fn pdf_bytes(doc: &Presentation, p: &Value) -> Result<Vec<u8>> {
 }
 
 /// The output extensions [`format_for_path`] maps to a writer of that format.
-pub const WRITABLE_EXTENSIONS: &[&str] = &["deckcraft", "pptx", "potx", "ppsx", "pdf", "png", "jpg", "jpeg", "txt", "md"];
+pub const WRITABLE_EXTENSIONS: &[&str] = &["deckcraft", "pptx", "potx", "ppsx", "pdf", "png", "jpg", "jpeg", "gif", "txt", "md"];
 
 /// The format a file named `path` is written in, or `None` when its extension names no format
-/// DeckCraft writes (`.odp`, `.gif`, `.svg`, no extension …): [`format_for_path`] would save
+/// DeckCraft writes (`.odp`, `.svg`, no extension …): [`format_for_path`] would save
 /// those as native `.deckcraft` bytes under the wrong name.
 pub fn writable_format_for_path(path: &str) -> Option<&'static str> {
     let ext = std::path::Path::new(path).extension()?.to_str()?.to_ascii_lowercase();
     WRITABLE_EXTENSIONS.contains(&ext.as_str()).then(|| format_for_path(path))
 }
 
+/// Animated GIF bytes for `doc` with the options in `p` (see [`crate::gif_export::GifOptions::from_params`]).
+pub fn gif_bytes(doc: &Presentation, p: &Value) -> Result<Vec<u8>> {
+    Ok(crate::gif_export::encode(doc, &crate::gif_export::GifOptions::from_params(p)?)?.bytes)
+}
+
 pub fn format_for_path(path: &str) -> &'static str {
     let l = path.to_ascii_lowercase();
     if l.ends_with(".pptx") {
@@ -360,6 +366,8 @@ pub fn format_for_path(path: &str) -> &'static str {
         "jpeg"
     } else if l.ends_with(".pdf") {
         "pdf"
+    } else if l.ends_with(".gif") {
+        "gif"
     } else if l.ends_with(".txt") || l.ends_with(".md") {
         "outline"
     } else {
@@ -381,16 +389,8 @@ fn mark_saved(s: &mut Session, path: Option<String>) -> Result<()> {
     Ok(())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 fn write_file(path: &str, bytes: &[u8]) -> Result<()> {
-    // Write to a temporary sibling then rename, so a failed save never truncates the old file.
-    let tmp = format!("{path}.saving");
-    std::fs::write(&tmp, bytes).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
-    std::fs::rename(&tmp, path).map_err(|e| EngineError::Other(format!("{path}: {e}")))
-}
-#[cfg(target_arch = "wasm32")]
-fn write_file(_path: &str, _bytes: &[u8]) -> Result<()> {
-    Err(EngineError::Other("saving to a path is not available in the browser".into()))
+    crate::io::write_file(path, bytes).map_err(EngineError::Other)
 }
 
 fn save(s: &mut Session, p: &Value) -> Result<Value> {
@@ -519,6 +519,23 @@ fn export(s: &mut Session, p: &Value) -> Result<Value> {
             write_file(&path, &bytes)?;
             Ok(json!({"path": path, "bytes": bytes.len()}))
         }
+        "gif" => {
+            // `slides` may be a range, as for PDF ("1-3,5").
+            let mut gp = p.clone();
+            if let Some(text) = p.get("slides").and_then(Value::as_str) {
+                gp["slides"] = json!(parse_slide_range(text, st.doc.slides.len())?);
+            }
+            let out = crate::gif_export::encode(&st.doc, &crate::gif_export::GifOptions::from_params(&gp)?)?;
+            write_file(&path, &out.bytes)?;
+            Ok(json!({
+                "path": path,
+                "bytes": out.bytes.len(),
+                "frames": out.frames,
+                "width": out.width,
+                "height": out.height,
+                "secondsPerSlide": f64::from(out.delay_cs) / 100.0,
+            }))
+        }
         "pptx" | "potx" | "ppsx" | "deckcraft" | "outline" | "txt" => {
             let bytes = save_bytes(&st.doc, &format)?;
             write_file(&path, &bytes)?;
@@ -533,7 +550,7 @@ fn info(s: &mut Session, _p: &Value) -> Result<Value> {
     let st = s.doc()?;
     let doc = &st.doc;
     #[cfg(not(target_arch = "wasm32"))]
-    let bytes = st.path.as_ref().and_then(|p| std::fs::metadata(p).ok()).map(|m| m.len());
+    let bytes = st.path.as_deref().and_then(crate::io::file_len);
     #[cfg(target_arch = "wasm32")]
     let bytes: Option<u64> = None;
     Ok(json!({
@@ -644,3 +661,43 @@ fn recovery_discard(s: &mut Session, p: &Value) -> Result<Value> {
 #[cfg(test)]
 #[path = "color_at_tests.rs"]
 mod color_at_tests;
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    #![allow(clippy::unwrap_used, clippy::expect_used)]
+
+    use super::write_file;
+
+    fn scratch(name: &str) -> std::path::PathBuf {
+        let dir = std::env::temp_dir().join(format!("deckcraft-write-file-{}-{name}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    #[test]
+    fn write_file_does_not_touch_a_predictable_saving_sibling() {
+        let dir = scratch("sibling");
+        let dest = dir.join("deck.deckcraft");
+        let dest_str = dest.to_str().unwrap();
+        std::fs::write(&dest, b"old").unwrap();
+        std::fs::write(dir.join("deck.deckcraft.saving"), b"precious").unwrap();
+        write_file(dest_str, b"new").unwrap();
+        assert_eq!(std::fs::read(&dest).unwrap(), b"new");
+        assert_eq!(std::fs::read(dir.join("deck.deckcraft.saving")).unwrap(), b"precious");
+        let names: Vec<_> = std::fs::read_dir(&dir).unwrap().map(|e| e.unwrap().file_name()).collect();
+        assert_eq!(names.len(), 2, "no temporary file may be left behind: {names:?}");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn write_file_failed_rename_keeps_destination_and_cleans_up() {
+        let dir = scratch("failed");
+        let dest = dir.join("target");
+        std::fs::create_dir(&dest).unwrap();
+        assert!(write_file(dest.to_str().unwrap(), b"new").is_err());
+        assert!(dest.is_dir());
+        assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 1);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}

crates/engine/src/cmd/format.rs

@@ -41,15 +41,7 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("format.size", "Font Size", ["Home", "Font"], None, "{size: pt}", has_text_or_shapes, size),
         cmd!("format.grow", "Increase Font Size", ["Home", "Font"], Some("Cmd+Shift+."), "{}", has_text_or_shapes, grow),
         cmd!("format.shrink", "Decrease Font Size", ["Home", "Font"], Some("Cmd+Shift+,"), "{}", has_text_or_shapes, shrink),
-        cmd!(
-            "format.color",
-            "Font Color",
-            ["Home", "Font"],
-            None,
-            "{color: #RRGGBB | accent1..6 | tx1… | {scheme, lumMod…}}",
-            has_text_or_shapes,
-            color
-        ),
+        cmd!("format.color", "Font Color", ["Home", "Font"], None, "{color: #RRGGBB|accent1..6|tx1…|{scheme, lumMod…}}", has_text_or_shapes, color),
         cmd!(
             "format.textTransparency",
             "Text Transparency",
@@ -214,7 +206,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Text Box Margins",
             ["Format Shape", "Text Box"],
             None,
-            "{left?, top?, right?, bottom?: pt}",
+            "{left?: pt, top?: pt, right?: pt, bottom?: pt}",
             has_text_or_shapes,
             margins
         ),
@@ -1206,6 +1198,7 @@ fn state(s: &mut Session, _p: &Value) -> Result<Value> {
         "align": pp.align.map(|a| a.xml()),
         "bullets": matches!(pp.bullet, Some(Bullet::Char { .. })),
         "numbering": matches!(pp.bullet, Some(Bullet::AutoNum { .. })),
+        "lang": r.lang,
         "lineSpacing": serde_json::to_value(pp.line_spacing).unwrap_or_default(),
         "painter": s.painter.is_some(),
     }))

crates/engine/src/cmd/insert.rs

@@ -308,9 +308,8 @@ pub(crate) fn media_bytes(p: &Value, cmd: &str) -> Result<(String, Vec<u8>)> {
         let bytes = base64_decode(d).ok_or_else(|| bad(cmd, "invalid base64 `data`"))?;
         return Ok((str_param(p, "name").unwrap_or("media").to_string(), bytes));
     }
-    #[cfg(not(target_arch = "wasm32"))]
     if let Some(path) = str_param(p, "path") {
-        let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
+        let bytes = crate::io::read_file(path).map_err(EngineError::Other)?;
         let name = std::path::Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "media".into());
         return Ok((name, bytes));
     }

crates/engine/src/cmd/inspect.rs

@@ -10,7 +10,7 @@ use crate::{Result, Session};
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(query "document.inspect", "Inspect Presentation", [], None, "{} → slides with titles, layouts, shape counts; selection; size; theme", has_doc, document),
-        cmd!(query "slide.inspect", "Inspect Slide", [], None, "{index?} → the slide's shapes with ids, kinds, boxes, text, fills, animations, transition, notes", has_doc, slide),
+        cmd!(query "slide.inspect", "Inspect Slide", [], None, "{index?} → the slide's shapes with ids, kinds, boxes, text, fills, animations, transition, notes (text, and notesBody with its formatting)", has_doc, slide),
         cmd!(query "shape.inspect", "Inspect Shape", [], None, "{id} → full shape JSON plus its effective box", has_doc, shape),
         cmd!(query "commands.list", "List Commands", [], None, "{filter?: substring} → [{id, label, params, enabled}]", always, commands),
     ]
@@ -129,6 +129,7 @@ fn slide(s: &mut Session, p: &Value) -> Result<Value> {
         "transition": serde_json::to_value(&sl.transition).unwrap_or_default(),
         "animations": serde_json::to_value(&sl.animations).unwrap_or_default(),
         "notes": sl.notes_text(),
+        "notesBody": sl.notes,
         "comments": sl.comments.len(),
         "hidden": sl.hidden,
     }))

crates/engine/src/cmd/mod.rs

@@ -46,6 +46,9 @@ pub struct CommandSpec {
     /// Where it lives: `["Home", "Font"]` (ribbon tab and group) or `["Arrange"]` (menu).
     pub menu: &'static [&'static str],
     pub shortcut: Option<&'static str>,
+    /// The parameters as `describe` and `commands` show them, read by [`parse_params`]: `?` marks
+    /// an optional key, a spaced ` | ` separates alternative sets of keys (so alternative values
+    /// are written unspaced, `ms|null`), `(…)` is a remark and `→` starts the answer.
     pub params: &'static str,
     pub enabled: Enabled,
     pub run: Run,
@@ -66,6 +69,28 @@ pub struct CommandInfo {
 }
 
 impl CommandSpec {
+    /// Holds because `Session::execute` skips the selection check when `id` or `ids` is given.
+    pub fn acts_on(&self) -> Option<String> {
+        let keys = param_keys(self.params).unwrap_or_default();
+        let named = if keys.contains(&"ids") {
+            Some("the shapes in `ids`")
+        } else if keys.contains(&"id") {
+            Some("the shape in `id`")
+        } else {
+            None
+        };
+        let reason = (self.enabled)(&Session::with_new()).err()?;
+        Some(match (reason.as_str(), named) {
+            (SELECT_TEXT_OR_SHAPE, _) => "Acts on the selected text or shapes.".into(),
+            (NOTHING_SELECTED, Some(n)) => format!("Acts on {n}, else on the selected shapes."),
+            (NOTHING_SELECTED, None) => "Acts on the selected shapes.".into(),
+            (SELECT_TWO, Some(n)) => format!("Acts on two or more shapes: {n}, else the selected ones."),
+            (SELECT_TWO, None) => "Acts on two or more selected shapes.".into(),
+            (NO_TEXT_POINT, _) => "Acts on the text being edited; text.edit starts editing a shape's text.".into(),
+            _ => return None,
+        })
+    }
+
     pub fn info(&self, s: &Session) -> CommandInfo {
         let e = (self.enabled)(s);
         CommandInfo {
@@ -92,6 +117,8 @@ pub fn has_slide(s: &Session) -> std::result::Result<(), String> {
 }
 pub const NOTHING_SELECTED: &str = "nothing selected";
 pub const SELECT_TWO: &str = "select two or more objects";
+pub const NO_TEXT_POINT: &str = "no text insertion point";
+pub const SELECT_TEXT_OR_SHAPE: &str = "select text or a shape";
 pub fn has_selection(s: &Session) -> std::result::Result<(), String> {
     has_doc(s)?;
     if s.active().is_some_and(|d| !d.selection.shapes.is_empty()) { Ok(()) } else { Err(NOTHING_SELECTED.into()) }
@@ -102,17 +129,14 @@ pub fn has_two(s: &Session) -> std::result::Result<(), String> {
 }
 pub fn has_text(s: &Session) -> std::result::Result<(), String> {
     has_doc(s)?;
-    if s.active().is_some_and(|d| d.selection.text.is_some()) { Ok(()) } else { Err("no text insertion point".into()) }
+    if s.active().is_some_and(|d| d.selection.text.is_some()) { Ok(()) } else { Err(NO_TEXT_POINT.into()) }
 }
-/// Text editing or shapes with text selected (formatting commands apply to either).
+/// Text editing or selected shapes (formatting commands apply to either).
 pub fn has_text_or_shapes(s: &Session) -> std::result::Result<(), String> {
     has_doc(s)?;
-    if s.active().is_some_and(|d| d.selection.text.is_some() || !d.selection.shapes.is_empty()) {
-        Ok(())
-    } else {
-        Err("select text or a shape".into())
-    }
+    if s.active().is_some_and(|d| d.selection.text.is_some() || !d.selection.shapes.is_empty()) { Ok(()) } else { Err(SELECT_TEXT_OR_SHAPE.into()) }
 }
+
 pub fn can_undo(s: &Session) -> std::result::Result<(), String> {
     if s.active().is_some_and(|d| !d.history.undo.is_empty()) { Ok(()) } else { Err("nothing to undo".into()) }
 }
@@ -172,6 +196,99 @@ pub fn find_command(id: &str) -> Option<&'static CommandSpec> {
     command_specs().iter().find(|c| c.id == id)
 }
 
+pub(crate) fn param_keys(doc: &str) -> std::result::Result<Vec<&str>, String> {
+    let mut keys = vec![];
+    for p in parse_params(doc)? {
+        if !keys.contains(&p.name) {
+            keys.push(p.name);
+        }
+    }
+    Ok(keys)
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Param<'a> {
+    pub name: &'a str,
+    pub optional: bool,
+    /// What the doc says of it: its values, unit or remark (`rect|roundRect|…`, `[x,y,w,h] pt`).
+    pub about: &'a str,
+    /// An alternative to the parameter before it in the same object (`color? | none?`).
+    pub or: bool,
+    /// Which of the doc's alternative objects it belongs to: `{index} | {id}` puts id in object 1.
+    pub object: usize,
+}
+
+/// The top-level parameters of a params doc: `{preset, rect?: [x,y,w,h] pt} | {id}` gives preset,
+/// rect (optional, `[x,y,w,h] pt`) and id (in the second object). Text after `→` is the result
+/// and is skipped. Errs where the doc strays from that grammar.
+pub fn parse_params(doc: &str) -> std::result::Result<Vec<Param<'_>>, String> {
+    let doc = doc.split('→').next().unwrap_or_default();
+    let mut params: Vec<Param> = vec![];
+    let mut open: Vec<char> = vec![];
+    let mut expect_key = false;
+    let mut or = false;
+    let mut objects: usize = 0;
+    let mut about_from: Option<usize> = None;
+    let mut chars = doc.char_indices().peekable();
+    let mut prev = ' ';
+    fn end_about<'a>(doc: &'a str, params: &mut [Param<'a>], from: &mut Option<usize>, to: usize) {
+        if let (Some(f), Some(p)) = (from.take(), params.last_mut()) {
+            p.about = doc.get(f..to).unwrap_or_default().trim();
+        }
+    }
+    while let Some((i, c)) = chars.next() {
+        let in_object = open == ['{'];
+        match c {
+            '{' | '[' | '(' => {
+                open.push(c);
+                if open == ['{'] {
+                    expect_key = true;
+                    objects += 1;
+                    or = false;
+                }
+            }
+            '}' | ']' | ')' => {
+                if in_object {
+                    end_about(doc, &mut params, &mut about_from, i);
+                }
+                open.pop();
+            }
+            ',' if in_object => {
+                end_about(doc, &mut params, &mut about_from, i);
+                expect_key = true;
+            }
+            '|' if in_object && prev == ' ' && chars.peek().is_some_and(|(_, n)| *n == ' ') => {
+                end_about(doc, &mut params, &mut about_from, i);
+                expect_key = true;
+                or = true;
+            }
+            c if in_object && expect_key && (c.is_ascii_alphabetic() || c == '_') => {
+                let mut end = i + c.len_utf8();
+                while let Some((j, n)) = chars.peek().copied().filter(|(_, n)| n.is_ascii_alphanumeric() || *n == '_') {
+                    end = j + n.len_utf8();
+                    chars.next();
+                }
+                let after = doc.get(end..).unwrap_or_default();
+                let rest = after.trim_start_matches('?').trim_start();
+                let at = doc.len() - rest.len();
+                about_from = match rest.chars().next() {
+                    Some(':') => Some(at + 1),
+                    Some('(') => Some(at),
+                    Some(',' | '}' | '|') => None,
+                    _ => return Err(format!("`{}` is followed by `{}`", &doc[i..end], rest.chars().take(12).collect::<String>())),
+                };
+                params.push(Param { name: &doc[i..end], optional: after.starts_with('?'), about: "", or, object: objects.saturating_sub(1) });
+                or = false;
+                expect_key = false;
+            }
+            c if in_object && expect_key && !c.is_whitespace() => return Err(format!("expected a key at `{}`", &doc[i..])),
+            _ => {}
+        }
+        prev = c;
+    }
+    Ok(params)
+}
+
 // ---------- param helpers ----------
 
 pub(crate) fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {

crates/engine/src/cmd/review.rs

@@ -46,7 +46,7 @@ pub fn specs() -> Vec<CommandSpec> {
         ),
         cmd!(noundo "review.addToDictionary", "Add to Dictionary", ["Review", "Proofing"], None, "{word} → {word, file} (append to the user dictionary file; not an undo step)", always, add_to_dictionary),
         cmd!(query "review.dictionary", "Spelling Dictionary", ["Review", "Proofing"], None, "{lang?} → {lang, available, found, folders} (whether review.spelling has a dictionary, and which file)", always, dictionary_info),
-        cmd!(query "review.thesaurus", "Thesaurus", ["Review", "Proofing"], None, "{word?: default the selected word, or the word at the caret} → {word, senses: [{word, synonyms}]}", has_doc, thesaurus),
+        cmd!(query "review.thesaurus", "Thesaurus", ["Review", "Proofing"], None, "{word? (default: the selected word, or the word at the caret)} → {word, senses: [{word, synonyms}]}", has_doc, thesaurus),
         cmd!(
             "review.replaceWord",
             "Insert Synonym",
@@ -639,7 +639,7 @@ fn revised_bytes(p: &Value) -> Result<(String, Vec<u8>)> {
     }
     #[cfg(not(target_arch = "wasm32"))]
     if let Some(path) = str_param(p, "path") {
-        let bytes = std::fs::read(path).map_err(|e| crate::EngineError::Other(format!("{path}: {e}")))?;
+        let bytes = crate::io::read_file(path).map_err(crate::EngineError::Other)?;
         return Ok((path.to_string(), bytes));
     }
     Err(bad("review.compare", "give `path` or `data`"))

crates/engine/src/cmd/shape.rs

@@ -39,8 +39,16 @@ pub fn specs() -> Vec<CommandSpec> {
             ink_to_shape
         ),
         cmd!(query "shape.sites", "Connection Sites", [], None, "{id} → [[x, y]] connection sites in slide points", has_slide, sites),
-        cmd!("shape.move", "Move", [], None, "{dx?, dy?: pt (relative) | x?, y?: pt (absolute), ids?}", has_selection, move_by),
-        cmd!("shape.resize", "Size", ["Shape Format", "Size"], None, "{w?, h?: pt, lockAspect?: bool, ids?}", has_selection, resize),
+        cmd!(
+            "shape.move",
+            "Move",
+            [],
+            None,
+            "{dx?: pt (relative), dy?: pt (relative), ids?} | {x?: pt (absolute), y?: pt (absolute), ids?}",
+            has_selection,
+            move_by
+        ),
+        cmd!("shape.resize", "Size", ["Shape Format", "Size"], None, "{w?: pt, h?: pt, lockAspect?: bool, ids?}", has_selection, resize),
         cmd!("shape.setBounds", "Position and Size", [], None, "{x, y, w, h, ids?}", has_selection, set_bounds),
         cmd!(
             "shape.rotate",
@@ -121,7 +129,15 @@ pub fn specs() -> Vec<CommandSpec> {
             lock
         ),
         cmd!("shape.setDefault", "Set as Default Shape", [], None, "{}", has_selection, set_default),
-        cmd!("picture.crop", "Crop", ["Picture Format", "Size"], None, "{left?, top?, right?, bottom?: fraction 0..1, ids?}", has_selection, crop),
+        cmd!(
+            "picture.crop",
+            "Crop",
+            ["Picture Format", "Size"],
+            None,
+            "{left?: fraction 0..1, top?: fraction 0..1, right?: fraction 0..1, bottom?: fraction 0..1, ids?}",
+            has_selection,
+            crop
+        ),
         cmd!(
             "picture.adjust",
             "Corrections",

crates/engine/src/cmd/slide.rs

@@ -32,7 +32,15 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("slide.hide", "Hide Slide", ["Slide Show", "Set Up"], None, "{index?, hidden?: bool}", has_slide, hide),
         cmd!("slide.layout", "Layout", ["Home", "Slides"], None, "{layout: name or kind, index?}", has_slide, set_layout),
         cmd!("slide.reset", "Reset", ["Home", "Slides"], None, "{index?}", has_slide, reset),
-        cmd!("slide.notes", "Notes", ["View"], None, "{text, index?}", has_slide, notes),
+        cmd!(
+            "slide.notes",
+            "Notes",
+            ["View"],
+            None,
+            "{text | body: formatted notes (as in slide.inspect's notesBody), index?} (text as typed: untouched notes keep their formatting)",
+            has_slide,
+            notes
+        ),
         cmd!("slide.rename", "Rename Slide", [], None, "{name, index?}", has_slide, rename),
         cmd!("section.add", "Add Section", ["Home", "Slides", "Section"], None, "{name?, at?: slide index}", has_slide, section_add),
         cmd!("section.rename", "Rename Section", ["Home", "Slides", "Section"], None, "{index, name}", has_slide, section_rename),
@@ -468,10 +476,20 @@ fn reset(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn notes(s: &mut Session, p: &Value) -> Result<Value> {
     let i = index_of(s, p)?;
+    // Formatted notes as a whole (the notes editors), or text: then only what was retyped
+    // changes, so bold, levels and bullets around it survive.
+    let body = match p.get("body") {
+        Some(b) => Some(serde_json::from_value::<TextBody>(b.clone()).map_err(|e| bad("slide.notes", format!("invalid `body`: {e}")))?),
+        None => None,
+    };
     let text = str_param(p, "text").unwrap_or("").to_string();
     s.edit(|doc, _| {
         if let Some(sl) = doc.slides.get_mut(i) {
-            Arc::make_mut(sl).notes = TextBody::from_text(&text);
+            let notes = &mut Arc::make_mut(sl).notes;
+            match body {
+                Some(b) => *notes = b,
+                None => deckcraft_model::edit::replace_text(notes, &text),
+            }
         }
         Ok(())
     })?;

crates/engine/src/cmd/table.rs

@@ -1,10 +1,11 @@
 //! Table Design and Table Layout tabs.
 
-use deckcraft_model::{ShapeKind, Table};
+use deckcraft_geom::{Affine, Point, Rect};
+use deckcraft_model::{Shape, ShapeKind, Table};
 use serde_json::{Value, json};
 
 use super::*;
-use crate::{Result, Session};
+use crate::{DocState, Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
@@ -27,7 +28,15 @@ pub fn specs() -> Vec<CommandSpec> {
             s, p, "delCol"
         )),
         cmd!("table.merge", "Merge Cells", ["Table Layout", "Merge"], None, "{from: [r, c], to: [r, c], id?}", has_selection, merge),
-        cmd!("table.split", "Split Cells", ["Table Layout", "Merge"], None, "{cell: [r, c], id?}", has_selection, split),
+        cmd!(
+            "table.split",
+            "Split Cells",
+            ["Table Layout", "Merge"],
+            None,
+            "{cell?: [r, c] (else the edited cell), id?} | {row?: index, col?: index, id?}",
+            has_selection,
+            split
+        ),
         cmd!(
             "table.style",
             "Table Styles",
@@ -42,7 +51,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Table Style Options",
             ["Table Design", "Table Style Options"],
             None,
-            "{headerRow?, totalRow?, bandedRows?, firstColumn?, lastColumn?, bandedColumns?: bool, id?}",
+            "{headerRow?: bool, totalRow?: bool, bandedRows?: bool, firstColumn?: bool, lastColumn?: bool, bandedColumns?: bool, id?}",
             has_selection,
             options
         ),
@@ -86,7 +95,15 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("table.distributeColumns", "Distribute Columns", ["Table Layout", "Cell Size"], None, "{id?}", has_selection, |s, p| distribute(
             s, p, false
         )),
-        cmd!("table.columnWidth", "Width", ["Table Layout", "Cell Size"], None, "{col, width: pt, id?}", has_selection, column_width),
+        cmd!(
+            "table.columnWidth",
+            "Width",
+            ["Table Layout", "Cell Size"],
+            None,
+            "{col, width: pt, keepTotal?: bool (the next column absorbs the change), id?}",
+            has_selection,
+            column_width
+        ),
         cmd!("table.rowHeight", "Height", ["Table Layout", "Cell Size"], None, "{row, height: pt, id?}", has_selection, row_height),
         cmd!(
             "table.drawLine",
@@ -110,6 +127,104 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
+/// Narrowest a column gets when its border is dragged (points).
+pub const MIN_COLUMN_WIDTH: f64 = 12.0;
+
+/// A table as drawn on the slide: where it is, its drawn row heights and its visible cells.
+#[derive(Clone, Debug)]
+pub struct TableFrame {
+    /// Table-local (points from the table's top-left corner) → slide space, as the table is drawn.
+    pub affine: Affine,
+    pub cols: Vec<f64>,
+    /// Row heights as drawn: a stored height is a minimum, rows grow to fit their text.
+    pub heights: Vec<f64>,
+    /// Visible cells (merges honoured): (row, col, table-local rect).
+    pub cells: Vec<(usize, usize, Rect)>,
+}
+
+/// A border between table rows or columns that can be dragged.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TableBorder {
+    /// The right edge of this column (the last one is the table's right edge).
+    Column(usize),
+    /// The bottom edge of this row (the last one is the table's bottom edge).
+    Row(usize),
+}
+
+/// The drawn geometry of table shape `sh` on the edited slide (`None` if it isn't a table).
+pub fn table_frame(st: &DocState, sh: &Shape) -> Option<TableFrame> {
+    let ShapeKind::Table(t) = &sh.kind else { return None };
+    // The table is drawn in its own box; rows that grow past it don't move it.
+    let x = sh.xfrm.unwrap_or_else(|| xfrm_of(&st.doc, &st.selection, sh));
+    let heights = table_drawn_heights(&st.doc, &st.selection, t);
+    let cells = deckcraft_render::table_cell_rects(t, &heights);
+    Some(TableFrame { affine: x.affine(), cols: t.cols.clone(), heights, cells })
+}
+
+impl TableFrame {
+    pub fn width(&self) -> f64 {
+        self.cols.iter().map(|w| w.max(0.0)).sum()
+    }
+
+    pub fn height(&self) -> f64 {
+        self.heights.iter().map(|h| h.max(0.0)).sum()
+    }
+
+    /// Table-local point for slide point `p`.
+    pub fn local(&self, p: Point) -> Point {
+        self.affine.inverse() * p
+    }
+
+    /// Table-local rect of visible cell (`r`, `c`).
+    pub fn cell_rect(&self, r: usize, c: usize) -> Option<Rect> {
+        self.cells.iter().find(|(cr, cc, _)| (*cr, *cc) == (r, c)).map(|x| x.2)
+    }
+
+    /// The visible cell at table-local point `p` (points outside the table go to the nearest cell).
+    pub fn cell_at(&self, p: Point) -> Option<(usize, usize)> {
+        let q = Point::new(p.x.clamp(0.0, self.width().max(0.0)), p.y.clamp(0.0, self.height().max(0.0)));
+        let inside = |r: &Rect| q.x >= r.x0 && q.x <= r.x1 && q.y >= r.y0 && q.y <= r.y1;
+        // Edges are shared: prefer the cell the point is strictly inside.
+        self.cells
+            .iter()
+            .find(|(_, _, r)| q.x >= r.x0 && q.x < r.x1 && q.y >= r.y0 && q.y < r.y1)
+            .or_else(|| self.cells.iter().rev().find(|(_, _, r)| inside(r)))
+            .map(|(r, c, _)| (*r, *c))
+    }
+
+    /// The draggable border within `tol` of table-local point `p`: the inner borders and the right
+    /// and bottom edges (the left and top edges move the table). Borders hidden inside merged
+    /// cells don't count.
+    pub fn border_at(&self, p: Point, tol: f64) -> Option<TableBorder> {
+        let (w, h) = (self.width(), self.height());
+        if !(p.x >= -tol && p.y >= -tol && p.x <= w + tol && p.y <= h + tol) {
+            return None;
+        }
+        let q = Point::new(p.x.clamp(0.0, w), p.y.clamp(0.0, h));
+        let mut best: Option<(f64, TableBorder)> = None;
+        let mut x = 0.0;
+        for (i, cw) in self.cols.iter().enumerate() {
+            x += cw.max(0.0);
+            let d = (p.x - x).abs();
+            // A cell ending at this edge at this height shows the border.
+            let shown = self.cells.iter().any(|(_, _, r)| (r.x1 - x).abs() < 1e-6 && q.y >= r.y0 && q.y <= r.y1);
+            if d <= tol && shown && best.is_none_or(|b| d < b.0) {
+                best = Some((d, TableBorder::Column(i)));
+            }
+        }
+        let mut y = 0.0;
+        for (i, rh) in self.heights.iter().enumerate() {
+            y += rh.max(0.0);
+            let d = (p.y - y).abs();
+            let shown = self.cells.iter().any(|(_, _, r)| (r.y1 - y).abs() < 1e-6 && q.x >= r.x0 && q.x <= r.x1);
+            if d <= tol && shown && best.is_none_or(|b| d < b.0) {
+                best = Some((d, TableBorder::Row(i)));
+            }
+        }
+        best.map(|b| b.1)
+    }
+}
+
 fn cell_param(p: &Value, key: &str) -> Option<(usize, usize)> {
     let a = p.get(key)?.as_array()?;
     Some((a.first()?.as_u64()? as usize, a.get(1)?.as_u64()? as usize))
@@ -418,9 +533,27 @@ fn distribute(s: &mut Session, p: &Value, rows: bool) -> Result<Value> {
 fn column_width(s: &mut Session, p: &Value) -> Result<Value> {
     let (_, c) = at(s, p);
     let w = f64_param(p, "width").ok_or_else(|| bad("table.columnWidth", "missing `width`"))?.clamp(4.0, 4000.0);
+    let keep_total = bool_or(p, "keepTotal", false);
     with_table(s, p, "table.columnWidth", move |t| {
-        if let Some(x) = t.cols.get_mut(c) {
-            *x = w;
+        // Keeping the table's width, the column to the right gives or takes the difference (dragging
+        // an inner border). The last column has none: the table gets wider or narrower.
+        let pair = t.cols.get(c).zip(t.cols.get(c + 1)).map(|(a, b)| a.max(0.0) + b.max(0.0)).filter(|x| x.is_finite());
+        match pair {
+            Some(pair) if keep_total => {
+                let min = MIN_COLUMN_WIDTH.min(pair / 2.0);
+                let w = w.max(min).min(pair - min);
+                if let Some(x) = t.cols.get_mut(c) {
+                    *x = w;
+                }
+                if let Some(x) = t.cols.get_mut(c + 1) {
+                    *x = pair - w;
+                }
+            }
+            _ => {
+                if let Some(x) = t.cols.get_mut(c) {
+                    *x = w;
+                }
+            }
         }
         Ok(())
     })

crates/engine/src/cmd/text.rs

@@ -2,10 +2,11 @@
 
 use std::sync::Arc;
 
+use deckcraft_geom::{Affine, Point, Rect};
 use deckcraft_model::edit::{self as ed, Pos};
 use deckcraft_model::resolve::{self, Ctx};
-use deckcraft_model::text::{AutoFit, Hyperlink, Run, RunKind, RunProps, TextBody};
-use deckcraft_model::{Presentation, ShapeId, ShapeKind};
+use deckcraft_model::text::{Align, AutoFit, Hyperlink, Paragraph, Run, RunKind, RunProps, TextBody};
+use deckcraft_model::{Presentation, Shape, ShapeId, ShapeKind};
 use serde_json::{Value, json};
 
 use super::*;
@@ -114,7 +115,7 @@ fn body_mut<'a>(doc: &'a mut Presentation, sel: &Selection, t: &TextSel) -> Opti
 
 /// Edit the active text body and selection; refits auto-sizing text boxes afterwards.
 pub(crate) fn edit_text<T>(s: &mut Session, f: impl FnOnce(&mut TextBody, &mut TextSel) -> T) -> Result<T> {
-    let t0 = s.doc()?.selection.text.clone().ok_or_else(|| bad("text", "no text insertion point"))?;
+    let t0 = s.doc()?.selection.text.clone().ok_or_else(|| bad("text", NO_TEXT_POINT))?;
     // Materialise an inherited placeholder box before editing (so autofit can change it).
     let r = s.edit(|doc, sel| {
         let mut t = t0.clone();
@@ -183,20 +184,44 @@ pub(crate) fn ctx_for<'a>(doc: &'a Presentation, sel: &Selection) -> Option<Ctx<
 
 /// Lay out the text being edited (for vertical caret movement and hit testing).
 pub fn layout_for(st: &DocState, t: &TextSel) -> Option<deckcraft_text::TextLayout> {
-    if t.notes || t.cell.is_some() {
+    text_frame(st, t).map(|f| f.0)
+}
+
+/// The text being edited as it is drawn: its layout, and the transform from layout space to the
+/// slide (flips don't mirror text, vertical text is turned). Shapes and table cells alike; the
+/// caret, the text selection, hit testing and caret movement all use it. `None` for notes.
+pub fn text_frame(st: &DocState, t: &TextSel) -> Option<(deckcraft_text::TextLayout, Affine)> {
+    if t.notes {
         return None;
     }
     let sh = st.shape(t.shape)?;
-    let body = sh.text.as_ref()?;
     let ctx = ctx_for(&st.doc, &st.selection)?;
+    let lay = |s: &Shape, body: &TextBody, rect: Rect| {
+        deckcraft_text::layout(&ctx, s, body, &deckcraft_text::Opts { rect, fields: &deckcraft_text::NoFields, prompt_color: None, no_shrink: false })
+    };
+    if let Some((r, c)) = t.cell {
+        // A cell's text is laid out in the cell's rect with the cell's margins, anchor and the
+        // table style's text look, exactly as the table draws it.
+        let placed = cell_on_slide(st, t.shape, r, c)?;
+        return Some((placed.layout, placed.to_slide));
+    }
+    let body = sh.text.as_ref()?;
     let x = xfrm_of(&st.doc, &st.selection, sh);
-    let geo = deckcraft_render::shape_geometry(sh, x.w, x.h);
-    Some(deckcraft_text::layout(
-        &ctx,
-        sh,
-        body,
-        &deckcraft_text::Opts { rect: geo.text_rect, fields: &deckcraft_text::NoFields, prompt_color: None, no_shrink: false },
-    ))
+    let tr = deckcraft_render::shape_geometry(sh, x.w, x.h).text_rect;
+    let l = lay(sh, body, tr);
+    let m = deckcraft_render::text_transform(x.affine(), tr, l.rotation);
+    Some((l, m))
+}
+
+/// The text position under slide point `p` in the text being edited (its shape or cell).
+pub fn text_pos_at(st: &DocState, t: &TextSel, p: Point) -> Pos {
+    match text_frame(st, t) {
+        Some((l, m)) => {
+            let h = l.hit(m.inverse() * p);
+            (h.para, h.ch)
+        }
+        None => (0, 0),
+    }
 }
 
 /// The insertion point on the slide: its line from top to bottom, in slide coordinates (flips and
@@ -234,6 +259,22 @@ pub fn caret_line(st: &DocState, t: &TextSel) -> Option<(deckcraft_geom::Point,
     Some((m * deckcraft_geom::Point::new(cx, top), m * deckcraft_geom::Point::new(cx, bot)))
 }
 
+/// The colour of text typed at the caret. The canvas draws the caret in it, so the caret shows
+/// wherever the text does: light on a dark slide, dark on a light one. `None` when that text
+/// has no fill to take a colour from.
+pub fn caret_color(st: &DocState, t: &TextSel) -> Option<deckcraft_color::Rgba> {
+    if t.notes || t.cell.is_some() {
+        return None;
+    }
+    let sh = st.shape(t.shape)?;
+    let body = sh.text.as_ref()?;
+    let ctx = ctx_for(&st.doc, &st.selection)?;
+    let blank = Paragraph::default();
+    let para = body.paragraphs.get(t.caret.0).unwrap_or(&blank);
+    let props = resolve::run(&ctx, sh, para, &ed::props_at(body, t.caret));
+    Some(resolve::text_color(&ctx, &props)).filter(|c| c.a > 0)
+}
+
 fn pos_param(p: &Value, key: &str) -> Option<Pos> {
     let a = p.get(key)?.as_array()?;
     Some((a.first()?.as_u64()? as usize, a.get(1)?.as_u64()? as usize))
@@ -305,6 +346,7 @@ fn typed(s: &Session, body: &TextBody, at: Pos, text: &str) -> String {
 }
 
 pub(crate) fn insert_text(s: &mut Session, text: &str, props: Option<RunProps>) -> Result<Value> {
+    let inherited = inherited_aligns_for_edit(s);
     let text = {
         let st = s.doc()?;
         match &st.selection.text {
@@ -322,12 +364,53 @@ pub(crate) fn insert_text(s: &mut Session, text: &str, props: Option<RunProps>)
         let c = ed::insert(body, at, &text, props);
         t.anchor = c;
         t.caret = c;
+        for pi in at.0..=c.0 {
+            if let Some(para) = body.paragraphs.get_mut(pi) {
+                promote_rtl_if_needed(para, &inherited);
+            }
+        }
         c
     })?;
     autocorrect(s, text.chars().count() == 1)?;
     Ok(json!({"caret": [pos.0, pos.1]}))
 }
 
+/// Per outline level (0..=8), whether shape `id` on the current slide already resolves an
+/// alignment for its paragraphs (its own list style, the layout's or the master's). All `false`
+/// when the shape can't be resolved (notes, a shape that is gone).
+fn inherited_aligns(s: &Session, id: ShapeId) -> [bool; 9] {
+    let mut out = [false; 9];
+    let Ok(st) = s.doc() else { return out };
+    let Some(sh) = st.shape(id) else { return out };
+    let Some(ctx) = ctx_for(&st.doc, &st.selection) else { return out };
+    for (lvl, set) in out.iter_mut().enumerate() {
+        let para = deckcraft_model::text::Paragraph { level: lvl as u8, ..Default::default() };
+        *set = resolve::para(&ctx, sh, &para).align.is_some();
+    }
+    out
+}
+
+/// The aligns [`inherited_aligns`] gives for the text being edited (none for notes).
+fn inherited_aligns_for_edit(s: &Session) -> [bool; 9] {
+    match s.doc().ok().and_then(|st| st.selection.text.clone()) {
+        Some(t) if !t.notes => inherited_aligns(s, t.shape),
+        _ => [false; 9],
+    }
+}
+
+/// A paragraph with no direction of its own whose first strong character is right-to-left
+/// (Arabic, Hebrew, Kurdish…) becomes right-to-left, and right-aligned when nothing (the
+/// paragraph or what it inherits, `inherited`) sets its alignment.
+fn promote_rtl_if_needed(para: &mut deckcraft_model::text::Paragraph, inherited: &[bool; 9]) {
+    if para.props.rtl.is_none() && deckcraft_model::bidi::first_strong_is_rtl(&para.text()) {
+        para.props.rtl = Some(true);
+        let inherits_align = inherited.get(usize::from(para.level)).copied().unwrap_or(false);
+        if para.props.align.is_none() && !inherits_align {
+            para.props.align = Some(Align::Right);
+        }
+    }
+}
+
 /// Typing right after a hyperlink doesn't extend it (as in PowerPoint): at the end of a linked
 /// run, the props to type with are the run's without the link. `None` elsewhere.
 fn unlinked_at_link_end(body: &TextBody, at: Pos) -> Option<RunProps> {
@@ -598,12 +681,18 @@ fn autocorrect_options(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 pub(crate) fn paste_body(s: &mut Session, src: &TextBody) -> Result<Value> {
+    let inherited = inherited_aligns_for_edit(s);
     let pos = edit_text(s, |body, t| {
         let (a, b) = t.ordered();
         let at = ed::delete(body, a, b);
         let c = ed::insert_body(body, at, src);
         t.anchor = c;
         t.caret = c;
+        for pi in at.0..=c.0 {
+            if let Some(para) = body.paragraphs.get_mut(pi) {
+                promote_rtl_if_needed(para, &inherited);
+            }
+        }
         c
     })?;
     Ok(json!({"caret": [pos.0, pos.1]}))
@@ -1037,6 +1126,7 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
         None => s.doc()?.selection.shapes.first().copied().ok_or_else(|| bad("text.set", "missing `id` (or select a shape)"))?,
     };
     let cell = p.get("cell").and_then(Value::as_array).and_then(|a| Some((a.first()?.as_u64()? as usize, a.get(1)?.as_u64()? as usize)));
+    let inherited = inherited_aligns(s, id);
     edit_shapes(s, &json!({"id": id}), "text.set", |sh| {
         let target = match (&mut sh.kind, cell) {
             (ShapeKind::Table(t), Some((r, c))) => t.cell_mut(r, c).map(|x| &mut x.text),
@@ -1055,6 +1145,7 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
                 para.level = *lv;
                 para.props = pp.clone();
             }
+            promote_rtl_if_needed(para, &inherited);
             for r in &mut para.runs {
                 r.props = keep.clone();
             }
@@ -1104,7 +1195,7 @@ pub(crate) fn format_run(s: &mut Session, f: &(dyn Fn(&mut RunProps) + Send + Sy
     }
     let ids = st.selection.shapes.clone();
     if ids.is_empty() {
-        return Err(bad("format", "select text or a shape"));
+        return Err(bad("format", SELECT_TEXT_OR_SHAPE));
     }
     edit_shapes(s, &json!({"ids": ids}), "format", |sh| {
         match &mut sh.kind {
@@ -1194,7 +1285,7 @@ pub(crate) fn format_para(s: &mut Session, f: &(dyn Fn(&mut deckcraft_model::tex
     }
     let ids = st.selection.shapes.clone();
     if ids.is_empty() {
-        return Err(bad("format", "select text or a shape"));
+        return Err(bad("format", SELECT_TEXT_OR_SHAPE));
     }
     edit_shapes(s, &json!({"ids": ids}), "format", |sh| {
         match &mut sh.kind {
@@ -1264,6 +1355,30 @@ fn replace_font(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"replaced": n}))
 }
 
+#[cfg(test)]
+mod rtl_promote_tests {
+    use deckcraft_model::text::{Align, Paragraph, Run};
+
+    use super::promote_rtl_if_needed;
+
+    fn para(text: &str) -> Paragraph {
+        Paragraph { runs: vec![Run::new(text)], ..Default::default() }
+    }
+
+    #[test]
+    fn right_aligns_only_when_no_alignment_is_set_or_inherited() {
+        let mut p = para("مرحبا");
+        promote_rtl_if_needed(&mut p, &[false; 9]);
+        assert_eq!((p.props.rtl, p.props.align), (Some(true), Some(Align::Right)));
+        let mut p = para("مرحبا");
+        promote_rtl_if_needed(&mut p, &[true; 9]);
+        assert_eq!((p.props.rtl, p.props.align), (Some(true), None));
+        let mut p = para("Hello مرحبا");
+        promote_rtl_if_needed(&mut p, &[false; 9]);
+        assert_eq!((p.props.rtl, p.props.align), (None, None));
+    }
+}
+
 #[cfg(test)]
 mod replace_font_tests {
     use serde_json::json;

crates/engine/src/cmd/transition.rs

@@ -35,7 +35,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Sound",
             ["Transitions", "Timing"],
             None,
-            "{builtin?: chime|click|camera|whoosh|drumRoll|laser | path? | data: base64, name?; none?: true (No Sound); stopPrevious?: true; loop?: bool (Loop Until Next Sound); index?} — the sound plays as the slide comes in",
+            "{builtin?: chime|click|camera|whoosh|drumRoll|laser | path? | data: base64, name?, none?: true (No Sound), stopPrevious?: true, loop?: bool (Loop Until Next Sound), index?} — the sound plays as the slide comes in",
             has_slide,
             sound
         ),