From 78ab8f062629894793d9270d7687deb212f89613 Mon Sep 17 00:00:00 2001
From: SusieeTheFemboy <96988330+SusieeTheLinuxUser@users.noreply.github.com>
Date: Sat, 24 Oct 2026 00:09:16 +0200
Subject: [PATCH 01/88] H.264: temporal direct mvs are scaled in i32 and
 clipped to the spec range
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The temporal direct derivation truncated (mvCol · DistScaleFactor + 128) >> 8
with `as i16`, wrapping mvL0 past the spec's motion-vector range on crafted
streams, and mvL0 − mvCol then panicked a debug build with "attempt to
subtract with overflow". The scale and the subtraction now run in i32 (dsf is
already clamped to ±1024, so they cannot overflow) and only the results are
clipped to −2^15..2^15−1, as ITU-T H.264 8.4.1.2.4 reads — mvL1 scaled from
the unclamped mvL0, the shape review settled for the same decoder code in
SoundCraft (soundcraft#994): dsf 512, mvCol 32767 keeps mvL1 at 32767.

Extends the grouped robustness audit's codec-overflow list (#1183), which
covers the POC/MMCO/latency sites but not this one.

Co-Authored-By: GLM-5.3 <noreply@z.ai>
---
 crates/h264/src/slicedec.rs | 52 ++++++++++++++++++++++++++++++++-----
 1 file changed, 45 insertions(+), 7 deletions(-)

diff --git a/crates/h264/src/slicedec.rs b/crates/h264/src/slicedec.rs
index 10132d683..fee675a24 100644
--- a/crates/h264/src/slicedec.rs
+++ b/crates/h264/src/slicedec.rs
@@ -566,6 +566,19 @@ impl<'a> SliceDecoder<'a> {
         (refs, mvs, false)
     }
 
+    /// Temporal direct mvs (8.4.1.2.4) from the co-located mv and `DistScaleFactor` (clamped
+    /// to ±1024 in `SliceDecoder`): mvL0 = clip_mv((mvCol · dsf + 128) >> 8), mvL1 =
+    /// clip_mv(mvL0 − mvCol), both clipped to the spec's motion-vector range −2^15..2^15−1.
+    /// The i32 maths cannot overflow; a truncating `as i16` used to wrap mvL0 past the range,
+    /// after which the mvL1 subtraction overflowed a debug build. mvL1 is scaled from the
+    /// unclamped mvL0 with only the results clipped, as the sibling SoundCraft decoder's
+    /// review established (soundcraft#994): dsf 512, mvCol 32767 keeps mvL1 at 32767.
+    fn temporal_direct_mvs(dsf: i32, mv_col: [i16; 2]) -> ([i16; 2], [i16; 2]) {
+        let clamp = |v: i32| v.clamp(-(1 << 15), (1 << 15) - 1) as i16;
+        let m0 = mv_col.map(|c| (dsf * i32::from(c) + 128) >> 8);
+        (m0.map(clamp), [clamp(m0[0] - i32::from(mv_col[0])), clamp(m0[1] - i32::from(mv_col[1]))])
+    }
+
     /// Derive direct-mode motion for the 8x8 blocks in `b8_mask` of the current MB.
     fn derive_direct(&mut self, b8_mask: u8) -> Result<()> {
         let spatial = self.sh.direct_spatial_mv_pred;
@@ -600,13 +613,7 @@ impl<'a> SliceDecoder<'a> {
                         }
                     };
                     let (dsf, ltr) = self.tdirect.get(ref0 as usize).copied().unwrap_or((256, true));
-                    let (mv0, mv1) = if ltr {
-                        (mv_col, [0, 0])
-                    } else {
-                        let s = |c: i16| ((dsf * c as i32 + 128) >> 8) as i16;
-                        let m0 = [s(mv_col[0]), s(mv_col[1])];
-                        (m0, [m0[0] - mv_col[0], m0[1] - mv_col[1]])
-                    };
+                    let (mv0, mv1) = if ltr { (mv_col, [0, 0]) } else { Self::temporal_direct_mvs(dsf, mv_col) };
                     ([ref0, 0], [mv0, mv1])
                 };
                 self.set_motion(x, y, unit, unit, refs, mvs);
@@ -1467,3 +1474,34 @@ impl<'a> SliceDecoder<'a> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::SliceDecoder;
+
+    /// Temporal direct mvs stay inside the spec's motion-vector range −2^15..2^15−1 with a
+    /// large `DistScaleFactor` and a co-located mv at an i16 extreme: the scale used to
+    /// truncate past the range with `as i16`, and mvL0 − mvCol then overflowed a debug build
+    /// ("attempt to subtract with overflow"). `dsf` 256 is the identity scale.
+    #[test]
+    fn temporal_direct_mvs_at_i16_extremes_stay_in_the_spec_range() {
+        for dsf in [-1024i32, -1, 256, 1023] {
+            for col in [[i16::MIN, i16::MIN], [i16::MAX, i16::MAX], [i16::MIN, i16::MAX]] {
+                let (mv0, mv1) = SliceDecoder::temporal_direct_mvs(dsf, col);
+                for mv in [mv0, mv1] {
+                    for c in mv {
+                        assert!((-(1 << 15)..(1 << 15)).contains(&i32::from(c)), "dsf {dsf}, col {col:?}: {mv:?}");
+                    }
+                }
+                if dsf == 256 {
+                    assert_eq!((mv0, mv1), (col, [0, 0]), "dsf 256 is the identity scale");
+                }
+                // soundcraft#994: mvL1 is scaled from the unclamped mvL0 with only the results
+                // clipped — deriving it from the clipped mvL0 gave [0, 0] here.
+                if dsf == 512 && col == [i16::MAX, 0] {
+                    assert_eq!((mv0, mv1), ([i16::MAX, 0], [i16::MAX, 0]), "mvL1 keeps mvL0's off-range part");
+                }
+            }
+        }
+    }
+}

From 48c5ff67bf42ce58bf2f6cd9436bb02050b5f8b7 Mon Sep 17 00:00:00 2001
From: SusieeTheFemboy <96988330+SusieeTheLinuxUser@users.noreply.github.com>
Date: Sat, 24 Oct 2026 00:40:21 +0200
Subject: [PATCH 02/88] H.264: the temporal-direct test runs the dsf 512 case

The dsf 512 / mvCol [32767, 0] check sat inside loops that never
produce that pair, so it never ran. It is now a direct assertion after
the sweep.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/h264/src/slicedec.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/crates/h264/src/slicedec.rs b/crates/h264/src/slicedec.rs
index fee675a24..2ada51594 100644
--- a/crates/h264/src/slicedec.rs
+++ b/crates/h264/src/slicedec.rs
@@ -1496,12 +1496,11 @@ mod tests {
                 if dsf == 256 {
                     assert_eq!((mv0, mv1), (col, [0, 0]), "dsf 256 is the identity scale");
                 }
-                // soundcraft#994: mvL1 is scaled from the unclamped mvL0 with only the results
-                // clipped — deriving it from the clipped mvL0 gave [0, 0] here.
-                if dsf == 512 && col == [i16::MAX, 0] {
-                    assert_eq!((mv0, mv1), ([i16::MAX, 0], [i16::MAX, 0]), "mvL1 keeps mvL0's off-range part");
-                }
             }
         }
+        // soundcraft#994: mvL1 is scaled from the unclamped mvL0 with only the results clipped;
+        // deriving it from the clipped mvL0 gave [0, 0] here.
+        let (mv0, mv1) = SliceDecoder::temporal_direct_mvs(512, [i16::MAX, 0]);
+        assert_eq!((mv0, mv1), ([i16::MAX, 0], [i16::MAX, 0]), "mvL1 keeps mvL0's off-range part");
     }
 }

From 8c2560f31cba86def42f779b2d396d6d37253061 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:06:23 -0500
Subject: [PATCH 03/88] codec: validate configuration NAL types

---
 crates/h264/src/decoder.rs     | 35 +++++++++++++++++++++++++++++-----
 crates/h264/src/synth_tests.rs | 14 ++++++++++++++
 crates/hevc/src/decoder.rs     | 31 ++++++++++++++++++++++++++++--
 crates/hevc/src/synth_tests.rs | 15 +++++++++++++++
 4 files changed, 88 insertions(+), 7 deletions(-)

diff --git a/crates/h264/src/decoder.rs b/crates/h264/src/decoder.rs
index 37ef1f299..64fcb48b1 100644
--- a/crates/h264/src/decoder.rs
+++ b/crates/h264/src/decoder.rs
@@ -216,26 +216,37 @@ impl Decoder {
     pub fn configure_avcc(&mut self, avcc: &[u8]) -> Result<()> {
         ensure!(avcc.len() >= 7, "avcC too short");
         ensure!(avcc[0] == 1, "unsupported avcC version {}", avcc[0]);
-        self.nal_length_size = Some((avcc[4] & 3) as usize + 1);
         let mut pos = 5;
-        let read_sets = |pos: &mut usize, count: usize, d: &mut Decoder| -> Result<()> {
+        let mut sets = Vec::new();
+        let read_sets = |pos: &mut usize, count: usize, sets: &mut Vec<(usize, usize)>| -> Result<()> {
             for _ in 0..count {
                 ensure!(*pos + 2 <= avcc.len(), "avcC truncated");
                 let len = u16::from_be_bytes([avcc[*pos], avcc[*pos + 1]]) as usize;
                 *pos += 2;
                 ensure!(*pos + len <= avcc.len(), "avcC truncated");
-                d.handle_nal(&avcc[*pos..*pos + len], 0)?;
+                sets.push((*pos, len));
                 *pos += len;
             }
             Ok(())
         };
         let nsps = (avcc[pos] & 0x1f) as usize;
         pos += 1;
-        read_sets(&mut pos, nsps, self)?;
+        read_sets(&mut pos, nsps, &mut sets)?;
         ensure!(pos < avcc.len(), "avcC truncated");
         let npps = avcc[pos] as usize;
         pos += 1;
-        read_sets(&mut pos, npps, self)
+        read_sets(&mut pos, npps, &mut sets)?;
+        for (i, (start, len)) in sets.iter().enumerate() {
+            let nal = &avcc[*start..*start + *len];
+            let header = nal.first().copied().ok_or_else(|| Error::Invalid("empty avcC parameter set".into()))?;
+            let expected = if i < nsps { nal_type::SPS } else { nal_type::PPS };
+            ensure!(header & 0x1f == expected, "avcC parameter set has NAL type {}, expected {expected}", header & 0x1f);
+        }
+        for (start, len) in sets {
+            self.handle_nal(&avcc[start..start + len], 0)?;
+        }
+        self.nal_length_size = Some((avcc[4] & 3) as usize + 1);
+        Ok(())
     }
 
     /// Length of NAL length prefixes (from avcC), or None for Annex-B input.
@@ -675,3 +686,17 @@ fn make_picture(o: &Output) -> Picture {
         draft: o.meta.draft,
     }
 }
+
+#[cfg(test)]
+mod config_tests {
+    use super::Decoder;
+
+    #[test]
+    fn avcc_rejects_picture_slices_without_starting_a_picture() {
+        let config = [1, 66, 0, 30, 0xff, 0xe1, 0, 2, 0x41, 0x80, 0];
+        let mut decoder = Decoder::with_threads(1);
+        assert!(decoder.configure_avcc(&config).is_err());
+        assert!(decoder.pending.is_none());
+        assert_eq!(decoder.stats().pictures, 0);
+    }
+}
diff --git a/crates/h264/src/synth_tests.rs b/crates/h264/src/synth_tests.rs
index a0c9da2f2..8588c5402 100644
--- a/crates/h264/src/synth_tests.rs
+++ b/crates/h264/src/synth_tests.rs
@@ -82,6 +82,20 @@ fn pps(cabac: bool, weighted: bool) -> Vec<u8> {
     nal(3, 8, &w.finish())
 }
 
+#[test]
+fn avcc_accepts_generated_sps_and_pps() {
+    let sps = sps(66, 4, false, PocType::T2);
+    let pps = pps(false, false);
+    let (sps, pps) = (&sps[4..], &pps[4..]);
+    let mut avcc = vec![1, 66, 0, 30, 0xff, 0xe1];
+    avcc.extend_from_slice(&(sps.len() as u16).to_be_bytes());
+    avcc.extend_from_slice(sps);
+    avcc.push(1);
+    avcc.extend_from_slice(&(pps.len() as u16).to_be_bytes());
+    avcc.extend_from_slice(pps);
+    assert!(Decoder::from_avcc(&avcc).is_ok());
+}
+
 #[derive(Default, Clone)]
 struct Pic {
     idr: bool,
diff --git a/crates/hevc/src/decoder.rs b/crates/hevc/src/decoder.rs
index 4b46044da..a78600f20 100644
--- a/crates/hevc/src/decoder.rs
+++ b/crates/hevc/src/decoder.rs
@@ -160,11 +160,12 @@ impl Decoder {
     pub fn configure_hvcc(&mut self, hvcc: &[u8]) -> Result<()> {
         ensure!(hvcc.len() >= 23, "hvcC too short");
         ensure!(hvcc[0] == 1, "unsupported hvcC version {}", hvcc[0]);
-        self.nal_length_size = Some((hvcc[21] & 3) as usize + 1);
         let num_arrays = hvcc[22] as usize;
         let mut pos = 23;
+        let mut sets = Vec::new();
         for _ in 0..num_arrays {
             ensure!(pos + 3 <= hvcc.len(), "hvcC truncated");
+            let array_type = hvcc[pos] & 0x3f;
             let n = u16::from_be_bytes([hvcc[pos + 1], hvcc[pos + 2]]) as usize;
             pos += 3;
             for _ in 0..n {
@@ -172,10 +173,19 @@ impl Decoder {
                 let len = u16::from_be_bytes([hvcc[pos], hvcc[pos + 1]]) as usize;
                 pos += 2;
                 ensure!(pos + len <= hvcc.len(), "hvcC truncated");
-                self.handle_nal(&hvcc[pos..pos + len], 0)?;
+                sets.push((array_type, &hvcc[pos..pos + len]));
                 pos += len;
             }
         }
+        for (array_type, nal) in &sets {
+            let header = NalHeader::parse(nal)?;
+            ensure!([nal_type::VPS, nal_type::SPS, nal_type::PPS].contains(array_type), "hvcC array has non-parameter-set NAL type {array_type}");
+            ensure!(header.nal_type == *array_type, "hvcC array type {array_type} disagrees with NAL header type {}", header.nal_type);
+        }
+        for (_, nal) in sets {
+            self.handle_nal(nal, 0)?;
+        }
+        self.nal_length_size = Some((hvcc[21] & 3) as usize + 1);
         Ok(())
     }
 
@@ -651,3 +661,20 @@ fn make_picture(o: &Output) -> Picture {
         draft: o.meta.draft,
     }
 }
+
+#[cfg(test)]
+mod config_tests {
+    use super::Decoder;
+
+    #[test]
+    fn hvcc_rejects_picture_slices_without_starting_a_picture() {
+        let mut config = vec![0; 23];
+        config[0] = 1;
+        config[22] = 1;
+        config.extend_from_slice(&[32, 0, 1, 0, 2, 0x02, 0x01]);
+        let mut decoder = Decoder::with_threads(1);
+        assert!(decoder.configure_hvcc(&config).is_err());
+        assert!(decoder.pending.is_none());
+        assert_eq!(decoder.stats().pictures, 0);
+    }
+}
diff --git a/crates/hevc/src/synth_tests.rs b/crates/hevc/src/synth_tests.rs
index 4c2f1c968..52a6e177e 100644
--- a/crates/hevc/src/synth_tests.rs
+++ b/crates/hevc/src/synth_tests.rs
@@ -644,3 +644,18 @@ fn picture_store_is_checked_against_the_memory_budget() {
     assert!(!decodes_within(&stream, pictures * one - 1));
     assert!(decodes_within(&stream, deckcraft_bitstream::budget::DECODE_MEMORY_BUDGET));
 }
+
+#[test]
+fn hvcc_accepts_generated_vps_sps_and_pps() {
+    let sets = [vps(), sps(true), pps(0, &None, false)];
+    let mut hvcc = vec![0; 23];
+    hvcc[0] = 1;
+    hvcc[22] = sets.len() as u8;
+    for (kind, set) in [32, 33, 34].into_iter().zip(sets) {
+        let nal = &set[4..];
+        hvcc.extend_from_slice(&[kind, 0, 1]);
+        hvcc.extend_from_slice(&(nal.len() as u16).to_be_bytes());
+        hvcc.extend_from_slice(nal);
+    }
+    assert!(Decoder::from_hvcc(&hvcc).is_ok());
+}

From 33b6e11726206967b2172b5bf1b7612880366f54 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:48:37 -0500
Subject: [PATCH 04/88] Use private directories for print previews

---
 ROADMAP.md                            |   3 +-
 crates/ui-egui/src/app.rs             |   3 +-
 crates/ui-egui/src/app/files.rs       | 102 +++++++++++++++++++++++++-
 crates/ui-egui/src/backstage/tests.rs |  15 +++-
 crates/ui-egui/src/lib.rs             |   1 +
 5 files changed, 116 insertions(+), 8 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index b04c4b69f..39c1c6baf 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~20 points and ~120–210 h away
 
-> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-24 · **Change:** trivial (progress log: Edit Points handle drags with Shift, Ctrl/Cmd or Alt/Option set the point type; previous: trivial, progress log: scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-28 · **Change:** trivial (print previews use unique private temporary directories and are cleaned up with the UI app; parity scores unchanged; previous: trivial, progress log: Edit Points handle drags with Shift, Ctrl/Cmd or Alt/Option set the point type; previous: trivial, progress log: scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-24 · **Change:** trivial (progress log: Ctrl+wheel zoom during the slide show, #1286; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-24 · **Change:** trivial (progress log: picture and embedded object fills; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-22 · **Change:** trivial (fill and outline edits reach group members, #1079; stage and scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
@@ -137,6 +137,7 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | What landed |
 |---|---|
+| 2026-10-28 | Print previews use unique temporary directories, owner-only on Unix, and are removed when the UI app closes; parity scores unchanged |
 | 2026-10-25 | Windows installer: the Start menu shortcut takes the icon embedded in `deckcraft.exe` instead of an MSI `<Icon>`, so a taskbar pin keeps its icon after an update (#1114); a pin that already lost it has to be unpinned and pinned again once |
 | 2026-10-24 | AutoFormat as you type: a paragraph that starts with `*`, `-`, `--`, `>`, `<>`, `1.`, `1)`, `I.`, `i.`, `A.`, `a.` or `a)` and a space or tab becomes a bulleted or numbered list in that style; Backspace right after puts the typed text back, and Tools ▸ AutoCorrect and `text.autocorrect {lists}` turn it off |
 | 2026-10-24 | Tables: while the caret is in a cell, dragging into another cell selects that range of cells (shaded, merged cells taken in whole), and Shift+arrow grows or shrinks it; formatting applies to the selected cells only, and Delete clears their text and keeps the table |
diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
index 8496d0ed9..3b3da5929 100644
--- a/crates/ui-egui/src/app.rs
+++ b/crates/ui-egui/src/app.rs
@@ -13,7 +13,7 @@ use super::{
 mod clipboard;
 mod commands;
 mod control;
-mod files;
+pub(crate) mod files;
 mod frame;
 mod ime;
 mod input;
@@ -77,6 +77,7 @@ impl SlideApp {
             integrated_titlebar: false,
             backstage: None,
             pending_urls: vec![],
+            print_previews: files::PrintPreviews::default(),
             #[cfg(not(target_arch = "wasm32"))]
             updates_rt: updates_ui::Runtime::default(),
             pending_copy: None,
diff --git a/crates/ui-egui/src/app/files.rs b/crates/ui-egui/src/app/files.rs
index 0f3c944f7..310956a8e 100644
--- a/crates/ui-egui/src/app/files.rs
+++ b/crates/ui-egui/src/app/files.rs
@@ -3,6 +3,93 @@ use super::{
     json, media,
 };
 
+#[derive(Default)]
+pub(crate) struct PrintPreviews(Vec<std::path::PathBuf>);
+
+impl PrintPreviews {
+    fn create(&mut self, title: &str) -> std::io::Result<std::path::PathBuf> {
+        self.create_in(&std::env::temp_dir(), title)
+    }
+
+    fn create_in(&mut self, base: &std::path::Path, title: &str) -> std::io::Result<std::path::PathBuf> {
+        let dir = create_private_print_dir(base)?;
+        self.0.push(dir.clone());
+        let safe: String = title.chars().map(|c| if c.is_alphanumeric() || c == ' ' || c == '-' { c } else { '_' }).collect();
+        Ok(dir.join(format!("{safe} (print).pdf")))
+    }
+
+    fn discard(&mut self, path: &std::path::Path) {
+        if let Some(dir) = path.parent() {
+            let _ = std::fs::remove_dir_all(dir);
+            self.0.retain(|owned| owned != dir);
+        }
+    }
+}
+
+#[cfg(test)]
+mod print_preview_tests {
+    use super::PrintPreviews;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    #[test]
+    fn same_title_gets_distinct_private_paths_and_drop_cleans_them() {
+        let stamp = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or_default();
+        let base = std::env::temp_dir().join(format!("deckcraft-print-test-{}-{stamp}", std::process::id()));
+        std::fs::create_dir(&base).unwrap();
+        let (first, second) = {
+            let mut previews = PrintPreviews::default();
+            let first = previews.create_in(&base, "Same title").unwrap();
+            let second = previews.create_in(&base, "Same title").unwrap();
+            assert_ne!(first, second);
+            assert_eq!(first.file_name(), second.file_name());
+            assert!(first.parent().is_some_and(|dir| dir.is_dir()));
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::PermissionsExt;
+                let mode = std::fs::metadata(first.parent().unwrap()).unwrap().permissions().mode();
+                assert_eq!(mode & 0o777, 0o700);
+            }
+            (first, second)
+        };
+        assert!(!first.parent().is_some_and(|dir| dir.exists()));
+        assert!(!second.parent().is_some_and(|dir| dir.exists()));
+        std::fs::remove_dir(base).unwrap();
+    }
+}
+
+impl Drop for PrintPreviews {
+    fn drop(&mut self) {
+        for dir in &self.0 {
+            let _ = std::fs::remove_dir_all(dir);
+        }
+    }
+}
+
+fn create_private_print_dir(base: &std::path::Path) -> std::io::Result<std::path::PathBuf> {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static NEXT_DIR: AtomicU64 = AtomicU64::new(0);
+
+    for _ in 0..128 {
+        let id = NEXT_DIR.fetch_add(1, Ordering::Relaxed);
+        let path = base.join(format!("deckcraft-print-{}-{id}", std::process::id()));
+        #[cfg(unix)]
+        let mut builder = std::fs::DirBuilder::new();
+        #[cfg(not(unix))]
+        let builder = std::fs::DirBuilder::new();
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::DirBuilderExt;
+            builder.mode(0o700);
+        }
+        match builder.create(&path) {
+            Ok(()) => return Ok(path),
+            Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
+            Err(e) => return Err(e),
+        }
+    }
+    Err(std::io::Error::new(std::io::ErrorKind::AlreadyExists, "could not allocate a unique print preview directory"))
+}
+
 fn purpose_of(purpose: &str) -> FilePurpose {
     match purpose {
         "open" => FilePurpose::Open,
@@ -207,8 +294,14 @@ impl SlideApp {
             let bytes = deckcraft_engine::cmd::file::pdf_bytes(&doc, &params);
             return self.download(&format!("{title}.pdf"), bytes);
         }
-        let safe: String = title.chars().map(|c| if c.is_alphanumeric() || c == ' ' || c == '-' { c } else { '_' }).collect();
-        let path = std::env::temp_dir().join(format!("{safe} (print).pdf")).to_string_lossy().to_string();
+        let preview_path = match self.print_previews.create(&title) {
+            Ok(path) => path,
+            Err(e) => {
+                self.set_status(format!("Couldn't create a private print preview: {e}"));
+                return false;
+            }
+        };
+        let path = preview_path.to_string_lossy().to_string();
         if let Some(o) = params.as_object_mut() {
             o.insert("path".into(), json!(path));
             o.insert("format".into(), json!("pdf"));
@@ -219,7 +312,10 @@ impl SlideApp {
                 self.set_status("Opened the presentation as a PDF to print");
                 true
             }
-            Err(_) => false,
+            Err(_) => {
+                self.print_previews.discard(&preview_path);
+                false
+            }
         }
     }
 
diff --git a/crates/ui-egui/src/backstage/tests.rs b/crates/ui-egui/src/backstage/tests.rs
index 78330b1b5..305777970 100644
--- a/crates/ui-egui/src/backstage/tests.rs
+++ b/crates/ui-egui/src/backstage/tests.rs
@@ -618,10 +618,19 @@ fn print_previews_pages_and_prints_a_pdf() {
     h.run_steps(2);
     let url = h.state().pending_urls.first().cloned().unwrap_or_default();
     // The URL was handed to egui at the end of the frame; check what it pointed at.
-    let printed = std::env::temp_dir().join(format!("{} (print).pdf", h.state().session.active().unwrap().title()));
-    assert!(printed.is_file(), "the PDF to print was written: {url}");
+    assert!(url.contains("deckcraft-print-"), "print preview uses its private directory: {url}");
+    let title = h.state().session.active().unwrap().title();
+    let safe: String = title.chars().map(|c| if c.is_alphanumeric() || c == ' ' || c == '-' { c } else { '_' }).collect();
+    let file_name = format!("{safe} (print).pdf");
+    let printed = std::fs::read_dir(std::env::temp_dir())
+        .unwrap()
+        .filter_map(Result::ok)
+        .filter(|entry| entry.file_name().to_string_lossy().starts_with("deckcraft-print-"))
+        .map(|entry| entry.path().join(&file_name))
+        .find(|path| path.is_file())
+        .expect("the PDF to print was written in its private directory");
     assert!(std::fs::read(&printed).unwrap().starts_with(b"%PDF"));
-    let _ = std::fs::remove_file(printed);
+    let _ = std::fs::remove_dir_all(printed.parent().unwrap());
     let _ = std::fs::remove_dir_all(&dir);
 }
 
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 30b5a0cd5..fd3deaa45 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -278,6 +278,7 @@ pub struct SlideApp {
     /// creating or closing a presentation leaves it.
     pub backstage: Option<backstage::Backstage>,
     pending_urls: Vec<String>,
+    print_previews: app::files::PrintPreviews,
     #[cfg(not(target_arch = "wasm32"))]
     updates_rt: updates_ui::Runtime,
     /// Text for the system clipboard from a Copy or Cut command, handed over on the next frame.

From 14eef3aceb47119a0fd7a5d482b2bdcafd53be03 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Wed, 28 Oct 2026 16:09:41 -0500
Subject: [PATCH 05/88] dc-show-click-targets: follow animated show click
 targets

---
 crates/ui-egui/src/show/media.rs | 112 ++++++++++++++++++++++++++-----
 docs/gaps.md                     |  14 ++--
 2 files changed, 103 insertions(+), 23 deletions(-)

diff --git a/crates/ui-egui/src/show/media.rs b/crates/ui-egui/src/show/media.rs
index ee8b1dec5..ff69c3f4e 100644
--- a/crates/ui-egui/src/show/media.rs
+++ b/crates/ui-egui/src/show/media.rs
@@ -1,5 +1,6 @@
 use super::render::fit;
-use super::{Click, HitShape, Hyperlink, Presentation, Rect, ShapeId, Show, SlideApp, Ui, pos2, vec2};
+use super::{Click, HitShape, Hyperlink, PlacedShape, Presentation, Rect, ShapeId, Show, SlideApp, Ui, pos2, vec2};
+use deckcraft_anim::AnimState;
 
 /// The media-host voice for slide transition sounds (no shape has this id).
 pub(crate) const TRANSITION_SOUND: ShapeId = ShapeId(u32::MAX);
@@ -152,6 +153,55 @@ pub(super) struct Under {
     pub(super) pick: Option<Pick>,
 }
 
+/// Convert a slide-space point back into a shape's own coordinates, undoing its animation and
+/// those of its enclosing groups.
+fn hit_point(mut point: (f64, f64), shapes: &[PlacedShape], states: &[AnimState], index: usize) -> Option<(f64, f64)> {
+    let mut chain = Vec::new();
+    let mut at = Some(index);
+    for _ in 0..=shapes.len() {
+        let Some(i) = at else { break };
+        let shape = shapes.get(i)?;
+        chain.push(i);
+        at = shape.parent;
+    }
+    if at.is_some() {
+        return None;
+    }
+    chain.reverse();
+    let mut centers = Vec::with_capacity(chain.len());
+    for &i in &chain {
+        let r = shapes.get(i)?.rect;
+        let center = transform_point((r.center().x, r.center().y), centers.last().copied());
+        centers.push((center, *states.get(i)?));
+    }
+    for &(center, state) in centers.iter().rev() {
+        point = inverse_transform_point(point, center, state)?;
+    }
+    Some(point)
+}
+
+fn transform_point(mut p: (f64, f64), prior: Option<((f64, f64), AnimState)>) -> (f64, f64) {
+    if let Some((center, state)) = prior {
+        let (x, y) = (p.0 - center.0, p.1 - center.1);
+        let angle = state.rotate.to_radians();
+        p = (
+            center.0 + (x * angle.cos() - y * angle.sin()) * state.scale_x + state.offset_x,
+            center.1 + (x * angle.sin() + y * angle.cos()) * state.scale_y + state.offset_y,
+        );
+    }
+    p
+}
+
+fn inverse_transform_point(p: (f64, f64), center: (f64, f64), state: AnimState) -> Option<(f64, f64)> {
+    if state.scale_x.abs() <= f64::EPSILON || state.scale_y.abs() <= f64::EPSILON {
+        return None;
+    }
+    let (x, y) = (p.0 - center.0 - state.offset_x, p.1 - center.1 - state.offset_y);
+    let angle = -state.rotate.to_radians();
+    let (x, y) = (x * angle.cos() - y * angle.sin(), x * angle.sin() + y * angle.cos());
+    Some((center.0 + x / state.scale_x, center.1 + y / state.scale_y))
+}
+
 impl Under {
     fn visible(&self, id: ShapeId) -> bool {
         self.shapes.iter().zip(&self.visible).find(|(h, _)| h.id == id).is_none_or(|(_, v)| *v)
@@ -175,31 +225,29 @@ pub(super) fn shapes_under_pointer(ctx: &egui::Context, ui: &Ui, show: &mut Show
     }
     show.timeline(doc);
     let (Some((_, tl)), Some((_, links, shapes))) = (&show.timeline, &show.links) else { return None };
-    let inside = |x0: f64, y0: f64, x1: f64, y1: f64| x0 <= x && x <= x1 && y0 <= y && y <= y1;
-    let hits: Vec<HitShape> = shapes
-        .iter()
-        .map(|s| HitShape {
-            id: s.id,
-            parent: s.parent,
-            is_group: s.is_group,
-            link: s.link.as_ref().map(|l| l.action.clone()),
-            under_pointer: inside(s.rect.x0, s.rect.y0, s.rect.x1, s.rect.y1),
-        })
-        .collect();
     let (step, plays, stamps) = (show.state.step, show.state.trigger_plays(), show.state.trigger_stamps());
     let t = if show.state.playing { now - show.step_start } else { 0.0 };
-    let visible: Vec<bool> = shapes
+    let states: Vec<AnimState> = shapes.iter().map(|s| tl.state_ordered(s.id, None, step, t, &plays, &stamps)).collect();
+    let point_for = |i: usize| hit_point((x, y), shapes, &states, i);
+    let hits: Vec<HitShape> = shapes
         .iter()
-        .map(|s| {
-            let a = tl.state_ordered(s.id, None, step, t, &plays, &stamps);
-            a.visible && a.opacity > 0.0
+        .enumerate()
+        .map(|(i, s)| {
+            let under_pointer = point_for(i).is_some_and(|(x, y)| s.rect.x0 <= x && x <= s.rect.x1 && s.rect.y0 <= y && y <= s.rect.y1);
+            HitShape { id: s.id, parent: s.parent, is_group: s.is_group, link: s.link.as_ref().map(|l| l.action.clone()), under_pointer }
         })
         .collect();
+    let visible: Vec<bool> = states.iter().map(|a| a.visible && a.opacity > 0.0).collect();
     let mut under = Under { shapes: hits, visible, pick: None };
     let shown = |id: ShapeId| under.visible(id);
     // A hyperlink in text applies when its shape is the one on top.
     let top = show.state.top(doc, tl, &under.shapes, &shown);
-    let text = links.iter().rev().filter(|l| l.text && inside(l.rect.x0, l.rect.y0, l.rect.x1, l.rect.y1)).find(|l| {
+    let text = links.iter().rev().filter(|l| l.text).find(|l| {
+        let Some(i) = shapes.iter().position(|s| s.id == l.shape) else { return false };
+        let Some((x, y)) = point_for(i) else { return false };
+        if !(l.rect.x0 <= x && x <= l.rect.x1 && l.rect.y0 <= y && y <= l.rect.y1) {
+            return false;
+        }
         let mut at = top;
         (0..=under.shapes.len()).any(|_| match at.and_then(|k| under.shapes.get(k)) {
             Some(h) if h.id == l.shape => true,
@@ -217,6 +265,36 @@ pub(super) fn shapes_under_pointer(ctx: &egui::Context, ui: &Ui, show: &mut Show
     Some(under)
 }
 
+#[cfg(test)]
+mod hit_tests {
+    use super::*;
+
+    fn shape(id: u32, parent: Option<usize>, rect: deckcraft_geom::Rect) -> PlacedShape {
+        PlacedShape { id: ShapeId(id), parent, is_group: parent.is_none(), rect, link: None }
+    }
+
+    #[test]
+    fn motion_path_moves_the_hit_box() {
+        let shapes = [shape(1, None, deckcraft_geom::Rect::new(10.0, 10.0, 30.0, 30.0))];
+        let states = [AnimState { offset_x: 50.0, scale_x: 2.0, ..Default::default() }];
+
+        let moved = hit_point((65.0, 20.0), &shapes, &states, 0);
+        let abandoned = hit_point((15.0, 20.0), &shapes, &states, 0);
+        assert!(moved.is_some_and(|(x, y)| (10.0..=30.0).contains(&x) && (10.0..=30.0).contains(&y)));
+        assert!(!abandoned.is_some_and(|(x, y)| (10.0..=30.0).contains(&x) && (10.0..=30.0).contains(&y)));
+    }
+
+    #[test]
+    fn parent_animation_moves_child_hit_box() {
+        let shapes =
+            [shape(1, None, deckcraft_geom::Rect::new(0.0, 0.0, 100.0, 100.0)), shape(2, Some(0), deckcraft_geom::Rect::new(10.0, 10.0, 30.0, 30.0))];
+        let states = [AnimState { offset_x: 40.0, ..Default::default() }, AnimState::default()];
+
+        let moved = hit_point((55.0, 20.0), &shapes, &states, 1);
+        assert!(moved.is_some_and(|(x, y)| (10.0..=30.0).contains(&x) && (10.0..=30.0).contains(&y)));
+    }
+}
+
 impl Show {
     /// Advance the clock of the running triggered animations.
     pub(super) fn tick_triggers(&mut self, doc: &Presentation, now: f64) {
diff --git a/docs/gaps.md b/docs/gaps.md
index c4a875f1c..9512b6715 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,7 +1,7 @@
 # Where DeckCraft falls short of PowerPoint
 
-> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-22 · **Change:** minor (Animation Pane ▸ Play From; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: soak tests, PPTX corpus, comment threads (#70), embedded fonts, SmartArt Text Pane, Animation Pane timeline, Hunspell spelling, thesaurus, AutoCorrect, 14 new dialogs, pen pressure and trackpad gestures; duplicated entries and headers folded; previous: minor, 3-D bevel, camera and face lighting rendered) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
-> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-20 · **Change:** trivial (empty chart number-format sections hide values; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: soak tests, PPTX corpus, comment threads (#70), embedded fonts, SmartArt Text Pane, Animation Pane timeline, Hunspell spelling, thesaurus, AutoCorrect, 14 new dialogs, pen pressure and trackpad gestures; duplicated entries and headers folded; previous: minor, 3-D bevel, camera and face lighting rendered) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-28 · **Last updated:** 2026-10-28 · **Change:** minor (slide-show click targets follow animated shapes and text links; previous: minor, Animation Pane ▸ Play From; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: soak tests, PPTX corpus, comment threads (#70), embedded fonts, SmartArt Text Pane, Animation Pane timeline, Hunspell spelling, thesaurus, AutoCorrect, 14 new dialogs, pen pressure and trackpad gestures; duplicated entries and headers folded; previous: minor, 3-D bevel, camera and face lighting rendered) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-28 · **Last updated:** 2026-10-28 · **Change:** minor (slide-show click targets follow animated shapes and text links; previous: trivial, empty chart number-format sections hide values; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: soak tests, PPTX corpus, comment threads (#70), embedded fonts, SmartArt Text Pane, Animation Pane timeline, Hunspell spelling, thesaurus, AutoCorrect, 14 new dialogs, pen pressure and trackpad gestures; duplicated entries and headers folded; previous: minor, 3-D bevel, camera and face lighting rendered) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 
 Every known shortfall, one entry each, ranked by how much it stops someone who presents with
 PowerPoint from switching. This is the work list: pick from the top. Numbers are summarized in
@@ -219,11 +219,12 @@ and starts at that effect. The pane has an advanced timeline with draggable bars
   found by running three classroom game decks (Jeopardy-style boards, hide-and-reveal, score
   counters): a click on a shape whose action is "play sound" (`ppaction://media`, 126 and 486
   shapes in two decks) does nothing; triggers that start on `onStopAudio` or `begin` conditions are
-  not read as triggers; click boxes are the shape's bounding box (a hexagon's corners count) and do
-  not follow a shape that a motion path has moved. Trigger sequences now keep their separate
+  not read as triggers; click boxes are the shape's bounding box (a hexagon's corners count).
+  Slide-show click targets now follow animated translations and scales, including text links.
+  Trigger sequences now keep their separate
   click steps on PPTX save, including paragraph builds (`crates/pptx/tests/it/trigger_steps.rs`).
-- **Impact:** games built around sound effects on buttons, audio-triggered effects or moving
-  clickable shapes do not play as authored.
+- **Impact:** games built around sound effects on buttons or audio-triggered effects do not play
+  as authored.
 - **Estimate:** 4–8 h.
 
 ### Notes and Handout masters
@@ -440,6 +441,7 @@ Detail in [localization-parity.md](localization-parity.md).
 | 2026-10-13 | trivial | Chart workbook round-trip (#335) noted under the charts gap; editing chart data is still open |
 | 2026-10-13 | minor | Shape, picture and table rendering checked against PowerPoint on ~150 synthetic edge-case slides; 3-D bevels, cameras and face lighting now render approximately (gap narrowed to extrusion, rigs and the 3-D pane) |
 | 2026-10-13 | minor | Interactive decks: triggers, return-to-slide state and click rules landed in the slide show; the remaining pieces are one new entry under Features |
+| 2026-10-28 | minor | Slide-show click targets follow animated movement and scale for shapes and text links; sound actions and audio triggers remain open |
 | 2026-10-12 | minor | IME composition in slide text and notes, and CJK interface text with real glyphs (#101): the IME gap is now Korean on the web and table-cell underlines |
 | 2026-10-12 | minor | EMF/WMF text, pattern and hatch brushes drawn; legacy OLE and ActiveX previews shown; the SVG gap keeps only EMF clip regions |
 | 2026-10-12 | minor | Text warps render (all 40 presets, adjusts round-trip); the warp gap is now the gallery, command and handles |

From 4c1916466b0aad6758c2889193adae8a7316116b Mon Sep 17 00:00:00 2001
From: DominicTheD3v <119626487+DominicTheD3v@users.noreply.github.com>
Date: Fri, 30 Oct 2026 01:19:44 +0000
Subject: [PATCH 06/88] Allow resizing on all selected shapes

---
 crates/engine/src/tools.rs         |  4 ++--
 crates/engine/src/tools/drag.rs    | 12 ++++++++----
 crates/engine/src/tools/pointer.rs | 13 ++++++++-----
 3 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/crates/engine/src/tools.rs b/crates/engine/src/tools.rs
index 78c6ed35c..19440fb33 100644
--- a/crates/engine/src/tools.rs
+++ b/crates/engine/src/tools.rs
@@ -149,9 +149,9 @@ enum Drag {
         enter_text: Option<(ShapeId, Point)>,
     },
     Resize {
-        id: ShapeId,
+        ids: Vec<ShapeId>,
         handle: u8,
-        orig: Xfrm,
+        origs: Vec<(ShapeId, Xfrm)>,
         start: Point,
     },
     LineEnd {
diff --git a/crates/engine/src/tools/drag.rs b/crates/engine/src/tools/drag.rs
index 21aac4f38..5660a09a2 100644
--- a/crates/engine/src/tools/drag.rs
+++ b/crates/engine/src/tools/drag.rs
@@ -26,10 +26,14 @@ impl Session {
             Drag::Move { ids, start, origs, moved, duplicate, enter_text } => {
                 return self.drag_move(MoveDrag { ids, start, origs, moved, duplicate, enter_text }, p, mods, tol);
             }
-            Drag::Resize { id, handle, orig, start } => {
-                let nx = resize_box(&orig, handle, p - start, mods.shift || self.is_picture(id), mods.alt);
-                let nx = self.snap_resize(nx, &orig, handle, id, tol);
-                self.set_xfrm(id, nx)?;
+            Drag::Resize { ids, handle, origs, start } => {
+                if ids.len() >= 1 {
+                    for (id, o) in &origs {
+                        let nx = resize_box(&o, handle, p - start, mods.shift || self.is_picture(*id), mods.alt);
+                        let nx = self.snap_resize(nx, &o, handle, *id, tol);
+                        self.set_xfrm(*id, nx)?;
+                    }
+                }
             }
             Drag::LineEnd { id, end, orig } => {
                 let a = orig.affine();
diff --git a/crates/engine/src/tools/pointer.rs b/crates/engine/src/tools/pointer.rs
index bee8f3203..0a3999705 100644
--- a/crates/engine/src/tools/pointer.rs
+++ b/crates/engine/src/tools/pointer.rs
@@ -302,9 +302,10 @@ impl Session {
             Some(Hit::TableColumn { id, col }) => self.begin_table_border(id, true, col, p)?,
             Some(Hit::TableRow { id, row }) => self.begin_table_border(id, false, row, p)?,
             Some(Hit::Resize { id, handle }) => {
-                let orig = st.shape(id).map(|s| xfrm_of(&st.doc, &st.selection, s)).unwrap_or_default();
+                let ids: Vec<ShapeId> = if st.selection.shapes.contains(&id) { st.selection.shapes.clone() } else { vec![id] };
+                let origs: Vec<(ShapeId, Xfrm)> = ids.iter().filter_map(|i| st.shape(*i).map(|s| (*i, xfrm_of(&st.doc, &st.selection, s)))).collect();
                 self.begin("Size");
-                self.tool.drag = Some(Drag::Resize { id, handle, orig, start: p });
+                self.tool.drag = Some(Drag::Resize { ids, handle, origs, start: p });
             }
             Some(Hit::LineEnd { id, end }) => {
                 let orig = st.shape(id).map(|s| xfrm_of(&st.doc, &st.selection, s)).unwrap_or_default();
@@ -559,10 +560,12 @@ impl Session {
                     out = self.add_ink(points)?;
                 }
             }
-            Some(Drag::Resize { id, .. }) => {
+            Some(Drag::Resize { ids, .. }) => {
                 self.commit();
-                let _ = cmd::text::fit_text_box(self, id);
-                self.refit_after_resize(id)?;
+                for id in ids {
+                    let _ = cmd::text::fit_text_box(self, id);
+                    self.refit_after_resize(id)?;
+                }
             }
             Some(Drag::TextSelect { before, .. }) => {
                 out = self.paint_if_selection_changed(before, out)?;

From 32ef926c46d3b6312aaecfcc0870e14bb1e49c0e Mon Sep 17 00:00:00 2001
From: DominicTheD3v <119626487+DominicTheD3v@users.noreply.github.com>
Date: Fri, 30 Oct 2026 01:46:06 +0000
Subject: [PATCH 07/88] fix: address CodeRabbit review findings

---
 crates/engine/src/tools/pointer.rs | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/crates/engine/src/tools/pointer.rs b/crates/engine/src/tools/pointer.rs
index 0a3999705..50d11c39f 100644
--- a/crates/engine/src/tools/pointer.rs
+++ b/crates/engine/src/tools/pointer.rs
@@ -303,7 +303,8 @@ impl Session {
             Some(Hit::TableRow { id, row }) => self.begin_table_border(id, false, row, p)?,
             Some(Hit::Resize { id, handle }) => {
                 let ids: Vec<ShapeId> = if st.selection.shapes.contains(&id) { st.selection.shapes.clone() } else { vec![id] };
-                let origs: Vec<(ShapeId, Xfrm)> = ids.iter().filter_map(|i| st.shape(*i).map(|s| (*i, xfrm_of(&st.doc, &st.selection, s)))).collect();
+                let origs: Vec<(ShapeId, Xfrm)> = ids.iter().filter_map(|i| {st.shape(*i).filter(|s| !s.locked).map(|s| (*i, xfrm_of(&st.doc, &st.selection, s)))}).collect();
+                let ids: Vec<ShapeId> = origs.iter().map(|(id, _)| *id).collect();
                 self.begin("Size");
                 self.tool.drag = Some(Drag::Resize { ids, handle, origs, start: p });
             }
@@ -560,12 +561,24 @@ impl Session {
                     out = self.add_ink(points)?;
                 }
             }
-            Some(Drag::Resize { ids, .. }) => {
-                self.commit();
-                for id in ids {
-                    let _ = cmd::text::fit_text_box(self, id);
-                    self.refit_after_resize(id)?;
+            Some(Drag::Resize { origs, .. }) => {
+                let changed: Vec<ShapeId> = origs.iter()
+                    .filter_map(|(id, orig)| {
+                        let current = self.active()
+                            .and_then(|st| st.shape(*id).map(|s| {
+                                xfrm_of(&st.doc, &st.selection, s)
+                            }))?;
+
+                        (current != *orig).then_some(*id)
+                    })
+                    .collect();
+                if !changed.is_empty() {
+                    for id in changed {
+                        let _ = cmd::text::fit_text_box(self, id);
+                        self.refit_after_resize(id)?;
+                    }
                 }
+                self.commit();
             }
             Some(Drag::TextSelect { before, .. }) => {
                 out = self.paint_if_selection_changed(before, out)?;

From b082f12f70bbd1da2d17123c093382abdd969a3b Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 14:01:04 -0500
Subject: [PATCH 08/88] #129: inspect slide actions

---
 ROADMAP.md                       |   4 +-
 crates/engine/src/cmd/inspect.rs | 139 +++++++++++++++++++++++++++++++
 docs/control-protocol.md         |   1 +
 3 files changed, 143 insertions(+), 1 deletion(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index b04c4b69f..2cd05e360 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~20 points and ~120–210 h away
 
-> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-24 · **Change:** trivial (progress log: Edit Points handle drags with Shift, Ctrl/Cmd or Alt/Option set the point type; previous: trivial, progress log: scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-30 · **Change:** trivial (progress log: read-only `slide.actions` lists shape and table text actions; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-24 · **Change:** trivial (progress log: Ctrl+wheel zoom during the slide show, #1286; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-24 · **Change:** trivial (progress log: picture and embedded object fills; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-22 · **Change:** trivial (fill and outline edits reach group members, #1079; stage and scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
@@ -137,6 +137,7 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | What landed |
 |---|---|
+| 2026-10-30 | `slide.actions` lists shape click and hover actions and text-run hyperlinks (including table cells and grouped shapes) for audit; listing never runs an action. The UI pane is a follow-up |
 | 2026-10-25 | Windows installer: the Start menu shortcut takes the icon embedded in `deckcraft.exe` instead of an MSI `<Icon>`, so a taskbar pin keeps its icon after an update (#1114); a pin that already lost it has to be unpinned and pinned again once |
 | 2026-10-24 | AutoFormat as you type: a paragraph that starts with `*`, `-`, `--`, `>`, `<>`, `1.`, `1)`, `I.`, `i.`, `A.`, `a.` or `a)` and a space or tab becomes a bulleted or numbered list in that style; Backspace right after puts the typed text back, and Tools ▸ AutoCorrect and `text.autocorrect {lists}` turn it off |
 | 2026-10-24 | Tables: while the caret is in a cell, dragging into another cell selects that range of cells (shaded, merged cells taken in whole), and Shift+arrow grows or shrinks it; formatting applies to the selected cells only, and Delete clears their text and keeps the table |
@@ -294,6 +295,7 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-30 | trivial | Progress log: read-only slide action inspection; parity scores unchanged |
 | 2026-10-25 | trivial | Progress log: Windows shortcut icon survives updates (#1114). Scores and milestone names unchanged |
 | 2026-10-24 | trivial | Progress log: selecting a range of table cells by dragging. Scores and milestone names unchanged |
 | 2026-10-24 | trivial | Progress log: measurement units in centimetres (#1326). Scores unchanged |
diff --git a/crates/engine/src/cmd/inspect.rs b/crates/engine/src/cmd/inspect.rs
index 8995e6b59..e09cf14a0 100644
--- a/crates/engine/src/cmd/inspect.rs
+++ b/crates/engine/src/cmd/inspect.rs
@@ -1,6 +1,7 @@
 //! Inspection for agents: the deck, slides and shapes as JSON (verify work without screenshots).
 
 use deckcraft_model::resolve::{self, Ctx};
+use deckcraft_model::text::Hyperlink;
 use deckcraft_model::{Shape, ShapeKind};
 use serde_json::{Value, json};
 
@@ -11,6 +12,7 @@ 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 (text, and notesBody with its formatting)", has_doc, slide),
+        cmd!(query "slide.actions", "Inspect Slide Actions", [], None, "{index?} → {index, slideId, actions: [{owner, event, type, target, hyperlink}]}; lists shape click/hover actions and text-run links/hover actions (including table cells) without executing them", has_doc, actions),
         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),
     ]
@@ -135,6 +137,70 @@ fn slide(s: &mut Session, p: &Value) -> Result<Value> {
     }))
 }
 
+fn actions(s: &mut Session, p: &Value) -> Result<Value> {
+    let st = s.doc()?;
+    let i = usize_param(p, "index").unwrap_or(st.selection.slide);
+    let sl = st.doc.slides.get(i).ok_or_else(|| bad("slide.actions", format!("no slide {i}")))?;
+    let mut found = Vec::new();
+    for sh in &sl.shapes {
+        collect_actions(sh, &mut Vec::new(), &mut found);
+    }
+    Ok(json!({"index": i, "slideId": sl.id, "actions": found}))
+}
+
+fn collect_actions(sh: &Shape, path: &mut Vec<Value>, found: &mut Vec<Value>) {
+    path.push(json!({"id": sh.id, "name": sh.name}));
+    let owner = json!({"shapeId": sh.id, "shapeName": sh.name, "path": path});
+    if let Some(link) = &sh.click {
+        found.push(action_entry(owner.clone(), "click", link));
+    }
+    if let Some(link) = &sh.hover {
+        found.push(action_entry(owner.clone(), "hover", link));
+    }
+    if let Some(text) = &sh.text {
+        collect_text_actions(text, &owner, found);
+    }
+    if let ShapeKind::Table(table) = &sh.kind {
+        for (row_index, row) in table.rows.iter().enumerate() {
+            for (cell_index, cell) in row.cells.iter().enumerate() {
+                let mut cell_owner = owner.clone();
+                cell_owner["tableRowIndex"] = json!(row_index);
+                cell_owner["tableCellIndex"] = json!(cell_index);
+                collect_text_actions(&cell.text, &cell_owner, found);
+            }
+        }
+    }
+    if let ShapeKind::Group { children, .. } = &sh.kind {
+        for child in children {
+            collect_actions(child, path, found);
+        }
+    }
+    path.pop();
+}
+
+fn collect_text_actions(text: &deckcraft_model::text::TextBody, owner: &Value, found: &mut Vec<Value>) {
+    for (paragraph_index, paragraph) in text.paragraphs.iter().enumerate() {
+        for (run_index, run) in paragraph.runs.iter().enumerate() {
+            for (event, link) in [("textLink", run.props.link.as_ref()), ("textHover", run.props.hover.as_ref())] {
+                if let Some(link) = link {
+                    let mut text_owner = owner.clone();
+                    text_owner["paragraphIndex"] = json!(paragraph_index);
+                    text_owner["runIndex"] = json!(run_index);
+                    text_owner["text"] = json!(run.content());
+                    found.push(action_entry(text_owner, event, link));
+                }
+            }
+        }
+    }
+}
+
+fn action_entry(owner: Value, event: &str, link: &Hyperlink) -> Value {
+    let action = serde_json::to_value(&link.action).unwrap_or_default();
+    let kind = action.get("kind").cloned().unwrap_or(Value::Null);
+    let target = ["url", "slide", "name", "path"].iter().find_map(|key| action.get(key).cloned()).unwrap_or(Value::Null);
+    json!({"owner": owner, "event": event, "type": kind, "target": target, "hyperlink": link})
+}
+
 fn shape(s: &mut Session, p: &Value) -> Result<Value> {
     let st = s.doc()?;
     let id =
@@ -154,3 +220,76 @@ fn commands(s: &mut Session, p: &Value) -> Result<Value> {
             .collect(),
     ))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use deckcraft_geom::Xfrm;
+    use deckcraft_model::table::Row;
+    use deckcraft_model::text::{Action, Paragraph, Run, RunProps, TextBody};
+    use deckcraft_model::{Cell, Shape, ShapeId, ShapeKind, Table};
+
+    fn link(action: Action) -> Hyperlink {
+        Hyperlink { action, tooltip: String::new(), highlight_click: false, sound: None, stop_sound: false, zoom_return: None }
+    }
+
+    #[test]
+    fn slide_actions_lists_group_shape_and_text_actions() {
+        let mut s = Session::with_new();
+        let mut child = Shape { id: ShapeId(12), name: "Child".into(), ..Default::default() };
+        child.click = Some(link(Action::NextSlide));
+        child.hover = Some(link(Action::Url { url: "https://example.com/hover".into() }));
+        let mut run_props = RunProps::default();
+        run_props.link = Some(link(Action::Slide { slide: deckcraft_model::SlideId(7) }));
+        let mut paragraph = Paragraph::new("linked");
+        paragraph.runs = vec![Run::with("linked", run_props)];
+        child.text = Some(TextBody { paragraphs: vec![paragraph], ..Default::default() });
+        let group = Shape {
+            id: ShapeId(11),
+            name: "Group".into(),
+            kind: ShapeKind::Group { children: vec![child], child: Xfrm::default() },
+            ..Default::default()
+        };
+        let st = s.doc_mut().unwrap();
+        let slide_index = st.selection.slide;
+        let presentation = std::sync::Arc::make_mut(&mut st.doc);
+        std::sync::Arc::make_mut(&mut presentation.slides[slide_index]).shapes = vec![group];
+
+        let v = s.execute("slide.actions", &json!({})).unwrap();
+        let actions = v["actions"].as_array().unwrap();
+        assert_eq!(actions.len(), 3, "{v}");
+        assert_eq!(actions[0]["event"], "click");
+        assert_eq!(actions[0]["type"], "nextSlide");
+        assert_eq!(actions[0]["owner"]["path"][0]["name"], "Group");
+        assert_eq!(actions[0]["owner"]["path"][1]["id"], 12);
+        assert_eq!(actions[1]["event"], "hover");
+        assert_eq!(actions[1]["target"], "https://example.com/hover");
+        assert_eq!(actions[2]["event"], "textLink");
+        assert_eq!(actions[2]["owner"]["runIndex"], 0);
+        assert_eq!(actions[2]["target"], 7);
+
+        let mut cell_props = RunProps::default();
+        cell_props.hover = Some(link(Action::Url { url: "https://example.com/cell".into() }));
+        let mut cell_text = TextBody::from_text("cell link");
+        cell_text.paragraphs[0].runs = vec![Run::with("cell link", cell_props)];
+        let table =
+            Table { rows: vec![Row { cells: vec![Cell { text: cell_text, ..Default::default() }], ..Default::default() }], ..Default::default() };
+        let table_shape = Shape { id: ShapeId(13), name: "Table".into(), kind: ShapeKind::Table(table), ..Default::default() };
+        let st = s.doc_mut().unwrap();
+        let presentation = std::sync::Arc::make_mut(&mut st.doc);
+        std::sync::Arc::make_mut(&mut presentation.slides[slide_index]).shapes.push(table_shape);
+        let v = s.execute("slide.actions", &json!({})).unwrap();
+        let table_action = v["actions"].as_array().unwrap().last().cloned().unwrap();
+        assert_eq!(table_action["event"], "textHover");
+        assert_eq!(table_action["owner"]["tableRowIndex"], 0);
+        assert_eq!(table_action["owner"]["tableCellIndex"], 0);
+        assert_eq!(table_action["target"], "https://example.com/cell");
+    }
+
+    #[test]
+    fn slide_actions_returns_empty_array_for_slide_without_actions() {
+        let mut s = Session::with_new();
+        let v = s.execute("slide.actions", &json!({})).unwrap();
+        assert_eq!(v["actions"], json!([]));
+    }
+}
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index 9edb40a91..d1d130c77 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -32,6 +32,7 @@ Coordinates are slide points (1/72 inch; a 16:9 slide is 960 × 540) unless note
 | `engine.execute` / `ui.menu.invoke` / `command` | `{command, params}` | Run any command (see `engine.commands`; `deckcraft-cli describe COMMAND` documents one) |
 | `engine.commands` | — | Every command: id, label, menu path, shortcut, params doc, enabled / disabled reason |
 | `document.inspect` | — | Slides, sections, layouts, shapes, selection |
+| `slide.actions` | `{index?}` | Actions on one slide; returns `{index, slideId, actions}`. Each action has an `owner` (shape id/name and group path; text actions also include paragraph/run indexes and run text, plus table row/cell indexes for table text), `event` (`click`, `hover`, `textLink`, or `textHover`), action `type`, `target`, and the full `hyperlink`. Listing is read-only and never executes an action. An empty slide returns `"actions": []`. |
 | `ui.inspect` | — | UI state, active tool, window/canvas/slide rects, dialog, `home` (the File tab open over a presentation), `backstage` (its page, also the start screen), slide show state (`grid`, `zoomArm`, `zoom`, `blank`, `presenterPaused`, `presenterSecs`, `notesPx`, `custom`, `goto`; `cells` while See All Slides is open), documents, perf (fps, render ms) |
 | `ui.inspect` | — | UI state, active tool, window/canvas/slide rects, dialog, `home` (the File tab open over a presentation), `backstage` (its page, also the start screen), slide show state, `animPreview` (canvas playback: slide, time, duration), documents, perf (fps, render ms) |
 | `ui.tool.select` | `{tool, preset?}` | `select`, `text`, `shape` + preset, any preset name, `curve`, `freeform`, `scribble`, `pen`, `highlighter`, `eraser` |

From ef6fd299282d9d6f721e5d31031c206b11cc0010 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 16:00:43 -0500
Subject: [PATCH 09/88] DC-1521: hit-test each shape animation independently

---
 crates/ui-egui/src/show/media.rs | 72 ++++++++++++++++----------------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/crates/ui-egui/src/show/media.rs b/crates/ui-egui/src/show/media.rs
index 60b6d9416..51cd7b99f 100644
--- a/crates/ui-egui/src/show/media.rs
+++ b/crates/ui-egui/src/show/media.rs
@@ -232,6 +232,42 @@ pub(super) fn shapes_under_pointer(ctx: &egui::Context, ui: &Ui, show: &mut Show
     Some(under)
 }
 
+impl Show {
+    /// Advance the clock of the running triggered animations.
+    pub(super) fn tick_triggers(&mut self, doc: &Presentation, now: f64) {
+        self.timeline(doc);
+        if let Some((_, tl)) = &self.timeline {
+            self.state.tick(tl, now);
+        }
+    }
+
+    /// A click on the slide: the shape under the pointer acts, or the background advances.
+    pub(super) fn click_slide(&mut self, doc: &Presentation, under: &Under, now: f64) -> Click {
+        self.timeline(doc);
+        let last = self.last_viewed;
+        match &self.timeline {
+            Some((_, tl)) => self.state.click(doc, tl, &under.shapes, &|id| under.visible(id), now, last),
+            None => Click::None,
+        }
+    }
+}
+
+/// A slide-space box on screen, the slide being drawn in `srect` at `k` pixels per point.
+pub(super) fn on_screen(srect: Rect, k: f32, x: &deckcraft_geom::Xfrm) -> Rect {
+    Rect::from_min_size(pos2(srect.min.x + x.x as f32 * k, srect.min.y + x.y as f32 * k), vec2(x.w as f32 * k, x.h as f32 * k))
+}
+
+/// The animated GIF whose play/pause button is under the pointer on the shown slide.
+pub(super) fn gif_hit(ctx: &egui::Context, ui: &Ui, show: &Show, doc_uid: u64, doc: &Presentation, app: &mut SlideApp) -> Option<ShapeId> {
+    let p = ctx.input(|i| i.pointer.interact_pos())?;
+    let full = ui.max_rect();
+    let avail = if show.reading { Rect::from_min_max(full.min, pos2(full.max.x, full.max.y - 34.0)) } else { full };
+    let srect = fit(avail, doc);
+    let k = srect.width() / doc.slide_size.width.max(1.0) as f32;
+    let gifs = app.media.gifs(doc_uid, doc, show.state.slide, ctx.input(|i| i.time), &app.session.gif_paused);
+    gifs.iter().rev().find(|g| crate::media::gif_button_rect(on_screen(srect, k, &g.rect)).contains(p)).map(|g| g.id)
+}
+
 #[cfg(test)]
 mod hit_tests {
     use super::*;
@@ -273,39 +309,3 @@ mod hit_tests {
         assert!(!displaced.is_some_and(|(x, y)| (10.0..=30.0).contains(&x) && (10.0..=30.0).contains(&y)));
     }
 }
-
-impl Show {
-    /// Advance the clock of the running triggered animations.
-    pub(super) fn tick_triggers(&mut self, doc: &Presentation, now: f64) {
-        self.timeline(doc);
-        if let Some((_, tl)) = &self.timeline {
-            self.state.tick(tl, now);
-        }
-    }
-
-    /// A click on the slide: the shape under the pointer acts, or the background advances.
-    pub(super) fn click_slide(&mut self, doc: &Presentation, under: &Under, now: f64) -> Click {
-        self.timeline(doc);
-        let last = self.last_viewed;
-        match &self.timeline {
-            Some((_, tl)) => self.state.click(doc, tl, &under.shapes, &|id| under.visible(id), now, last),
-            None => Click::None,
-        }
-    }
-}
-
-/// A slide-space box on screen, the slide being drawn in `srect` at `k` pixels per point.
-pub(super) fn on_screen(srect: Rect, k: f32, x: &deckcraft_geom::Xfrm) -> Rect {
-    Rect::from_min_size(pos2(srect.min.x + x.x as f32 * k, srect.min.y + x.y as f32 * k), vec2(x.w as f32 * k, x.h as f32 * k))
-}
-
-/// The animated GIF whose play/pause button is under the pointer on the shown slide.
-pub(super) fn gif_hit(ctx: &egui::Context, ui: &Ui, show: &Show, doc_uid: u64, doc: &Presentation, app: &mut SlideApp) -> Option<ShapeId> {
-    let p = ctx.input(|i| i.pointer.interact_pos())?;
-    let full = ui.max_rect();
-    let avail = if show.reading { Rect::from_min_max(full.min, pos2(full.max.x, full.max.y - 34.0)) } else { full };
-    let srect = fit(avail, doc);
-    let k = srect.width() / doc.slide_size.width.max(1.0) as f32;
-    let gifs = app.media.gifs(doc_uid, doc, show.state.slide, ctx.input(|i| i.time), &app.session.gif_paused);
-    gifs.iter().rev().find(|g| crate::media::gif_button_rect(on_screen(srect, k, &g.rect)).contains(p)).map(|g| g.id)
-}

From 82adf7326e1e6be4770499e2bef3495091d19ee2 Mon Sep 17 00:00:00 2001
From: DominicTheD3v <119626487+DominicTheD3v@users.noreply.github.com>
Date: Fri, 30 Oct 2026 21:13:44 +0000
Subject: [PATCH 10/88] fix: address raised issues

---
 crates/engine/src/tests.rs          | 132 ++++++++++++++++++++++++++++
 crates/engine/src/tools/drag.rs     |  10 +--
 crates/engine/src/tools/geometry.rs |   4 +-
 crates/engine/src/tools/pointer.rs  |  11 ++-
 4 files changed, 143 insertions(+), 14 deletions(-)

diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 4dfc21f45..b72dcbd7d 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -5479,6 +5479,138 @@ fn box_of(s: &mut Session, id: u64) -> serde_json::Value {
     s.execute("shape.inspect", &json!({"id": id})).unwrap()["box"].clone()
 }
 
+/// Two selected boxes with different sizes and aligned right edges, on a blank slide.
+fn resize_selection_scene() -> (Session, [u64; 2]) {
+    let mut s = session();
+    s.execute("slide.new", &json!({"layout": "blank"})).unwrap();
+    s.prefs.smart_guides = false;
+    s.prefs.snap_to_grid = false;
+    let ids = [[100, 100, 100, 80], [120, 300, 80, 100]]
+        .map(|rect| s.execute("shape.insert", &json!({"preset": "rect", "rect": rect, "text": "Resize test"})).unwrap()["id"].as_u64().unwrap());
+    s.execute("edit.select", &json!({"ids": ids})).unwrap();
+    (s, ids)
+}
+
+/// Simulate file-loaded shapes whose stored boxes have not yet been fitted to their text.
+fn pending_resize_autofit(s: &mut Session, ids: &[u64]) {
+    s.edit(|doc, sel| {
+        let shapes = crate::shapes_mut(doc, sel).unwrap();
+        for id in ids {
+            let sh = deckcraft_model::find_shape_mut(shapes, ShapeId(*id as u32)).unwrap();
+            sh.text.as_mut().unwrap().body.autofit = Some(deckcraft_model::text::AutoFit::Shape);
+        }
+        Ok(())
+    })
+    .unwrap();
+}
+
+#[test]
+fn resizing_selected_shapes_is_one_undo_step() {
+    let (mut s, [a, b]) = resize_selection_scene();
+    let before = s.doc().unwrap().doc.clone();
+    let steps = s.doc().unwrap().history.undo.len();
+    let down = drag_gesture(&mut s, (200.0, 180.0), (250.0, 210.0));
+    assert_eq!(down["hit"]["kind"], "resize");
+    assert_eq!(down["hit"]["id"], a);
+    for (id, expected) in [(a, [100.0, 100.0, 150.0, 110.0]), (b, [120.0, 300.0, 130.0, 130.0])] {
+        let actual = box_of(&mut s, id);
+        for (key, value) in ["x", "y", "w", "h"].into_iter().zip(expected) {
+            assert_eq!(actual[key], value, "{id}: {key}");
+        }
+    }
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
+    let after = s.doc().unwrap().doc.clone();
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().doc, before, "one undo restores both shapes");
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().doc, after, "one redo resizes both shapes again");
+}
+
+#[test]
+fn resizing_selected_shapes_refits_text_in_the_same_undo_step() {
+    let (mut s, ids) = resize_selection_scene();
+    pending_resize_autofit(&mut s, &ids);
+    let before = s.doc().unwrap().doc.clone();
+    let steps = s.doc().unwrap().history.undo.len();
+    // An east-handle drag changes width only; a height change must come from text fitting.
+    drag_gesture(&mut s, (200.0, 140.0), (250.0, 140.0));
+    for (id, old_height) in ids.into_iter().zip([80.0, 100.0]) {
+        assert_ne!(box_of(&mut s, id)["h"], old_height, "both shapes' text is refitted");
+    }
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
+    let after = s.doc().unwrap().doc.clone();
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().doc, before);
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().doc, after, "redo includes the final text fit");
+}
+
+#[test]
+fn clicking_a_resize_handle_does_not_change_or_refit_selected_shapes() {
+    let (mut s, ids) = resize_selection_scene();
+    pending_resize_autofit(&mut s, &ids);
+    let before = s.doc().unwrap().doc.clone();
+    let steps = s.doc().unwrap().history.undo.len();
+    let revision = s.doc().unwrap().revision;
+    for kind in [PointerKind::Down, PointerKind::Up] {
+        s.pointer(PointerEvent { kind, x: 200.0, y: 180.0, tol: 3.0, ..Default::default() }).unwrap();
+    }
+    assert_eq!(s.doc().unwrap().doc, before);
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps, "a click creates no undo entry");
+    assert_eq!(s.doc().unwrap().revision, revision);
+    assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().doc, &before), "a click does not dirty the document");
+    // Ensure this fixture would catch an accidental refit on release.
+    for id in ids {
+        cmd::text::fit_text_box(&mut s, ShapeId(id as u32)).unwrap();
+    }
+    assert_ne!(s.doc().unwrap().doc, before);
+}
+
+#[test]
+fn resizing_selected_shapes_skips_locked_shapes_and_their_text_fit() {
+    let (mut s, [a, b]) = resize_selection_scene();
+    pending_resize_autofit(&mut s, &[b]);
+    s.execute("shape.lock", &json!({"ids": [b], "locked": true})).unwrap();
+    s.execute("edit.select", &json!({"ids": [a, b]})).unwrap();
+    let locked = s.doc().unwrap().shape(ShapeId(b as u32)).unwrap().clone();
+    let before = s.doc().unwrap().doc.clone();
+    let steps = s.doc().unwrap().history.undo.len();
+    drag_gesture(&mut s, (200.0, 180.0), (250.0, 210.0));
+    assert_eq!(box_of(&mut s, a)["w"], 150.0);
+    assert_eq!(box_of(&mut s, a)["h"], 110.0);
+    assert_eq!(s.doc().unwrap().shape(ShapeId(b as u32)).unwrap(), &locked, "the locked shape is neither resized nor refitted");
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().doc, before);
+}
+
+#[test]
+fn resizing_selected_shapes_does_not_snap_to_other_resize_targets() {
+    for reverse in [false, true] {
+        let (mut s, [a, b]) = resize_selection_scene();
+        s.prefs.smart_guides = true;
+        let ids = if reverse { [b, a] } else { [a, b] };
+        s.execute("edit.select", &json!({"ids": ids})).unwrap();
+        // Within snap tolerance of the other selected shape's original right edge.
+        drag_gesture(&mut s, (200.0, 140.0), (203.0, 140.0));
+        assert_eq!(box_of(&mut s, a)["w"], 103.0, "first shape must not snap back");
+        assert_eq!(box_of(&mut s, b)["w"], 83.0, "selection order must not affect snapping");
+    }
+}
+
+#[test]
+fn resizing_selected_shapes_still_snaps_to_stationary_shapes() {
+    let (mut s, [a, b]) = resize_selection_scene();
+    let fixed = s.execute("shape.insert", &json!({"preset": "rect", "rect": [207, 430, 100, 80]})).unwrap()["id"].as_u64().unwrap();
+    let fixed_before = box_of(&mut s, fixed);
+    s.execute("edit.select", &json!({"ids": [a, b]})).unwrap();
+    s.prefs.smart_guides = true;
+    drag_gesture(&mut s, (200.0, 140.0), (203.0, 140.0));
+    assert_eq!(box_of(&mut s, a)["w"], 107.0);
+    assert_eq!(box_of(&mut s, b)["w"], 87.0);
+    assert_eq!(box_of(&mut s, fixed), fixed_before);
+}
+
 /// #961: dragging the east handle snaps the dragged (right) edge, even when the fixed left edge
 /// already lines up with another shape. The nearest line used to be the fixed edge's, at distance 0.
 #[test]
diff --git a/crates/engine/src/tools/drag.rs b/crates/engine/src/tools/drag.rs
index 5660a09a2..7dca38225 100644
--- a/crates/engine/src/tools/drag.rs
+++ b/crates/engine/src/tools/drag.rs
@@ -27,12 +27,10 @@ impl Session {
                 return self.drag_move(MoveDrag { ids, start, origs, moved, duplicate, enter_text }, p, mods, tol);
             }
             Drag::Resize { ids, handle, origs, start } => {
-                if ids.len() >= 1 {
-                    for (id, o) in &origs {
-                        let nx = resize_box(&o, handle, p - start, mods.shift || self.is_picture(*id), mods.alt);
-                        let nx = self.snap_resize(nx, &o, handle, *id, tol);
-                        self.set_xfrm(*id, nx)?;
-                    }
+                for (id, o) in &origs {
+                    let nx = resize_box(o, handle, p - start, mods.shift || self.is_picture(*id), mods.alt);
+                    let nx = self.snap_resize(nx, handle, &ids, tol);
+                    self.set_xfrm(*id, nx)?;
                 }
             }
             Drag::LineEnd { id, end, orig } => {
diff --git a/crates/engine/src/tools/geometry.rs b/crates/engine/src/tools/geometry.rs
index 536a4ead2..cbbd01275 100644
--- a/crates/engine/src/tools/geometry.rs
+++ b/crates/engine/src/tools/geometry.rs
@@ -228,7 +228,7 @@ impl Session {
     }
 
     /// Snap the edges that resize handle `handle` drags in the resized box `x` to the smart guides.
-    pub(super) fn snap_resize(&mut self, x: Xfrm, _orig: &Xfrm, handle: u8, id: ShapeId, tol: f64) -> Xfrm {
+    pub(super) fn snap_resize(&mut self, x: Xfrm, handle: u8, exclude: &[ShapeId], tol: f64) -> Xfrm {
         if x.rot != 0.0 {
             self.tool.guides.clear();
             return x;
@@ -241,7 +241,7 @@ impl Session {
         let (top, bottom) = (matches!(handle, 0..=2), matches!(handle, 4..=6));
         let (moves_left, moves_right) = if x.flip_h { (right, left) } else { (left, right) };
         let (moves_top, moves_bottom) = if x.flip_v { (bottom, top) } else { (top, bottom) };
-        let (off, guides) = self.snap_edges(r, &[id], tol * 1.5, true, [moves_left, false, moves_right], [moves_top, false, moves_bottom]);
+        let (off, guides) = self.snap_edges(r, exclude, tol * 1.5, true, [moves_left, false, moves_right], [moves_top, false, moves_bottom]);
         let mut nx = x;
         if moves_left {
             nx.x += off.x;
diff --git a/crates/engine/src/tools/pointer.rs b/crates/engine/src/tools/pointer.rs
index 50d11c39f..dbaf495f8 100644
--- a/crates/engine/src/tools/pointer.rs
+++ b/crates/engine/src/tools/pointer.rs
@@ -303,7 +303,8 @@ impl Session {
             Some(Hit::TableRow { id, row }) => self.begin_table_border(id, false, row, p)?,
             Some(Hit::Resize { id, handle }) => {
                 let ids: Vec<ShapeId> = if st.selection.shapes.contains(&id) { st.selection.shapes.clone() } else { vec![id] };
-                let origs: Vec<(ShapeId, Xfrm)> = ids.iter().filter_map(|i| {st.shape(*i).filter(|s| !s.locked).map(|s| (*i, xfrm_of(&st.doc, &st.selection, s)))}).collect();
+                let origs: Vec<(ShapeId, Xfrm)> =
+                    ids.iter().filter_map(|i| st.shape(*i).filter(|s| !s.locked).map(|s| (*i, xfrm_of(&st.doc, &st.selection, s)))).collect();
                 let ids: Vec<ShapeId> = origs.iter().map(|(id, _)| *id).collect();
                 self.begin("Size");
                 self.tool.drag = Some(Drag::Resize { ids, handle, origs, start: p });
@@ -562,12 +563,10 @@ impl Session {
                 }
             }
             Some(Drag::Resize { origs, .. }) => {
-                let changed: Vec<ShapeId> = origs.iter()
+                let changed: Vec<ShapeId> = origs
+                    .iter()
                     .filter_map(|(id, orig)| {
-                        let current = self.active()
-                            .and_then(|st| st.shape(*id).map(|s| {
-                                xfrm_of(&st.doc, &st.selection, s)
-                            }))?;
+                        let current = self.active().and_then(|st| st.shape(*id).map(|s| xfrm_of(&st.doc, &st.selection, s)))?;
 
                         (current != *orig).then_some(*id)
                     })

From 2c11865b2da6caf8189652adad99cb8c87b600c5 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 16:49:21 -0500
Subject: [PATCH 11/88] codec: accept hvcC SEI arrays without allocation

---
 crates/h264/src/decoder.rs     | 14 --------
 crates/h264/src/synth_tests.rs | 34 +++++++++++++++++++
 crates/hevc/src/decoder.rs     | 61 ++++++++++++++++++----------------
 crates/hevc/src/synth_tests.rs | 43 ++++++++++++++++++++++++
 4 files changed, 109 insertions(+), 43 deletions(-)

diff --git a/crates/h264/src/decoder.rs b/crates/h264/src/decoder.rs
index b4b429b9a..a3244d473 100644
--- a/crates/h264/src/decoder.rs
+++ b/crates/h264/src/decoder.rs
@@ -687,17 +687,3 @@ fn make_picture(o: &Output) -> Picture {
         draft: o.meta.draft,
     }
 }
-
-#[cfg(test)]
-mod config_tests {
-    use super::Decoder;
-
-    #[test]
-    fn avcc_rejects_picture_slices_without_starting_a_picture() {
-        let config = [1, 66, 0, 30, 0xff, 0xe1, 0, 2, 0x41, 0x80, 0];
-        let mut decoder = Decoder::with_threads(1);
-        assert!(decoder.configure_avcc(&config).is_err());
-        assert!(decoder.pending.is_none());
-        assert_eq!(decoder.stats().pictures, 0);
-    }
-}
diff --git a/crates/h264/src/synth_tests.rs b/crates/h264/src/synth_tests.rs
index 8588c5402..24a104cf2 100644
--- a/crates/h264/src/synth_tests.rs
+++ b/crates/h264/src/synth_tests.rs
@@ -96,6 +96,40 @@ fn avcc_accepts_generated_sps_and_pps() {
     assert!(Decoder::from_avcc(&avcc).is_ok());
 }
 
+#[test]
+fn avcc_rejects_a_valid_picture_slice_without_starting_a_picture() {
+    let sequence = sps(66, 4, false, PocType::T0);
+    let picture = pps(false, false);
+    let slice = slice_nal(
+        &Pic {
+            idr: true,
+            frame_num: 0,
+            ref_idc: 3,
+            long_term_ref: false,
+            mods: vec![],
+            mmcos: vec![],
+            mbs: vec![Some(vec![128; 16 * 16]); NMB],
+            b: false,
+            poc_lsb: Some(0),
+            poc_delta: None,
+            wt: None,
+        },
+        false,
+    );
+    let mut avcc = vec![1, 66, 0, 30, 0xff, 0xe2];
+    for nal in [&sequence[4..], &slice[4..]] {
+        avcc.extend_from_slice(&(nal.len() as u16).to_be_bytes());
+        avcc.extend_from_slice(nal);
+    }
+    avcc.push(1);
+    avcc.extend_from_slice(&((picture.len() - 4) as u16).to_be_bytes());
+    avcc.extend_from_slice(&picture[4..]);
+
+    let mut decoder = Decoder::with_threads(1);
+    assert!(decoder.configure_avcc(&avcc).is_err());
+    assert_eq!(decoder.stats().pictures, 0);
+}
+
 #[derive(Default, Clone)]
 struct Pic {
     idr: bool,
diff --git a/crates/hevc/src/decoder.rs b/crates/hevc/src/decoder.rs
index d3419103f..b4ad29f98 100644
--- a/crates/hevc/src/decoder.rs
+++ b/crates/hevc/src/decoder.rs
@@ -161,30 +161,33 @@ impl Decoder {
         ensure!(hvcc.len() >= 23, "hvcC too short");
         ensure!(hvcc[0] == 1, "unsupported hvcC version {}", hvcc[0]);
         let num_arrays = hvcc[22] as usize;
-        let mut pos = 23;
-        let mut sets = Vec::new();
-        for _ in 0..num_arrays {
-            ensure!(pos + 3 <= hvcc.len(), "hvcC truncated");
-            let array_type = hvcc[pos] & 0x3f;
-            let n = u16::from_be_bytes([hvcc[pos + 1], hvcc[pos + 2]]) as usize;
-            pos += 3;
-            for _ in 0..n {
-                ensure!(pos + 2 <= hvcc.len(), "hvcC truncated");
-                let len = u16::from_be_bytes([hvcc[pos], hvcc[pos + 1]]) as usize;
-                pos += 2;
-                ensure!(pos + len <= hvcc.len(), "hvcC truncated");
-                sets.push((array_type, &hvcc[pos..pos + len]));
-                pos += len;
+        for pass in 0..2 {
+            let mut pos = 23;
+            for _ in 0..num_arrays {
+                ensure!(pos <= hvcc.len() && hvcc.len() - pos >= 3, "hvcC truncated");
+                let array_type = hvcc[pos] & 0x3f;
+                let n = u16::from_be_bytes([hvcc[pos + 1], hvcc[pos + 2]]) as usize;
+                pos += 3;
+                for _ in 0..n {
+                    ensure!(pos <= hvcc.len() && hvcc.len() - pos >= 2, "hvcC truncated");
+                    let len = u16::from_be_bytes([hvcc[pos], hvcc[pos + 1]]) as usize;
+                    pos += 2;
+                    ensure!(len <= hvcc.len() - pos, "hvcC truncated");
+                    let nal = &hvcc[pos..pos + len];
+                    if pass == 0 {
+                        let header = NalHeader::parse(nal)?;
+                        ensure!(
+                            [nal_type::VPS, nal_type::SPS, nal_type::PPS, nal_type::PREFIX_SEI, nal_type::SUFFIX_SEI].contains(&array_type),
+                            "hvcC array has unsupported NAL type {array_type}"
+                        );
+                        ensure!(header.nal_type == array_type, "hvcC array type {array_type} disagrees with NAL header type {}", header.nal_type);
+                    } else {
+                        self.handle_nal(nal, 0)?;
+                    }
+                    pos += len;
+                }
             }
         }
-        for (array_type, nal) in &sets {
-            let header = NalHeader::parse(nal)?;
-            ensure!([nal_type::VPS, nal_type::SPS, nal_type::PPS].contains(array_type), "hvcC array has non-parameter-set NAL type {array_type}");
-            ensure!(header.nal_type == *array_type, "hvcC array type {array_type} disagrees with NAL header type {}", header.nal_type);
-        }
-        for (_, nal) in sets {
-            self.handle_nal(nal, 0)?;
-        }
         self.nal_length_size = Some((hvcc[21] & 3) as usize + 1);
         Ok(())
     }
@@ -669,14 +672,14 @@ mod config_tests {
     use super::Decoder;
 
     #[test]
-    fn hvcc_rejects_picture_slices_without_starting_a_picture() {
+    fn hvcc_skips_prefix_and_suffix_sei_arrays() {
         let mut config = vec![0; 23];
         config[0] = 1;
-        config[22] = 1;
-        config.extend_from_slice(&[32, 0, 1, 0, 2, 0x02, 0x01]);
-        let mut decoder = Decoder::with_threads(1);
-        assert!(decoder.configure_hvcc(&config).is_err());
-        assert!(decoder.pending.is_none());
-        assert_eq!(decoder.stats().pictures, 0);
+        config[22] = 2;
+        config.extend_from_slice(&[39, 0, 1, 0, 2, 0x4e, 0x01]);
+        config.extend_from_slice(&[40, 0, 1, 0, 2, 0x50, 0x01]);
+
+        let decoder = Decoder::from_hvcc(&config);
+        assert!(decoder.is_ok());
     }
 }
diff --git a/crates/hevc/src/synth_tests.rs b/crates/hevc/src/synth_tests.rs
index 52a6e177e..7baf7b496 100644
--- a/crates/hevc/src/synth_tests.rs
+++ b/crates/hevc/src/synth_tests.rs
@@ -659,3 +659,46 @@ fn hvcc_accepts_generated_vps_sps_and_pps() {
     }
     assert!(Decoder::from_hvcc(&hvcc).is_ok());
 }
+
+#[test]
+fn hvcc_rejects_a_valid_picture_slice_without_starting_a_picture() {
+    let sets = [vps(), sps(true), pps(0, &None, false)];
+    let mut stream = Vec::new();
+    let mut saved = None;
+    encode_picture(
+        &PicDesc {
+            nal_type: 19,
+            poc: 0,
+            intra: true,
+            cu: Cu::Pcm,
+            pps_id: 0,
+            st: vec![],
+            lt: vec![],
+            num_ref: 0,
+            list_entry: None,
+            segments: whole(WC * HC),
+        },
+        &None,
+        &content(0),
+        &mut stream,
+        &mut saved,
+    );
+
+    let mut hvcc = vec![0; 23];
+    hvcc[0] = 1;
+    hvcc[22] = 4;
+    for (kind, set) in [32, 33, 34].into_iter().zip(sets) {
+        let nal = &set[4..];
+        hvcc.extend_from_slice(&[kind, 0, 1]);
+        hvcc.extend_from_slice(&(nal.len() as u16).to_be_bytes());
+        hvcc.extend_from_slice(nal);
+    }
+    let slice = &stream[4..];
+    hvcc.extend_from_slice(&[19, 0, 1]);
+    hvcc.extend_from_slice(&(slice.len() as u16).to_be_bytes());
+    hvcc.extend_from_slice(slice);
+
+    let mut decoder = Decoder::with_threads(1);
+    assert!(decoder.configure_hvcc(&hvcc).is_err());
+    assert_eq!(decoder.stats().pictures, 0);
+}

From b4c1905d7815bca00d04c33e8952f3359f03e46d Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 16:51:34 -0500
Subject: [PATCH 12/88] dc-fix-1519: address print preview review

---
 apps/deckcraft/src/main.rs            |  2 +
 crates/ui-egui/src/app.rs             |  5 ++
 crates/ui-egui/src/app/files.rs       | 83 ++++++++++++++++-----------
 crates/ui-egui/src/backstage/tests.rs | 31 +++++-----
 4 files changed, 75 insertions(+), 46 deletions(-)

diff --git a/apps/deckcraft/src/main.rs b/apps/deckcraft/src/main.rs
index 03859dc0a..ad3f820fa 100644
--- a/apps/deckcraft/src/main.rs
+++ b/apps/deckcraft/src/main.rs
@@ -60,6 +60,8 @@ impl eframe::App for App {
         // nothing after it is needed: the preferences are saved and the log file is unbuffered.
         // `on_exit` only runs once the app exists, never on a failed start. Same as GridCraft #117.
         #[cfg(target_os = "macos")]
+        self.0.cleanup_print_previews();
+        #[cfg(target_os = "macos")]
         std::process::exit(0);
     }
 }
diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
index 3b3da5929..7c9c373ab 100644
--- a/crates/ui-egui/src/app.rs
+++ b/crates/ui-egui/src/app.rs
@@ -30,6 +30,11 @@ pub use keys::key_name;
 const STATUS_LINGER_MS: f64 = 6000.0;
 
 impl SlideApp {
+    /// Remove temporary PDFs created for printing.
+    pub fn cleanup_print_previews(&mut self) {
+        self.print_previews.cleanup();
+    }
+
     /// Build application UI state, taking ownership of audio output and initialising media, dialogs,
     /// synthetic input, and timing fields.
     pub fn new(session: Session, mut services: Services) -> Self {
diff --git a/crates/ui-egui/src/app/files.rs b/crates/ui-egui/src/app/files.rs
index 310956a8e..1e846e0db 100644
--- a/crates/ui-egui/src/app/files.rs
+++ b/crates/ui-egui/src/app/files.rs
@@ -24,44 +24,17 @@ impl PrintPreviews {
             self.0.retain(|owned| owned != dir);
         }
     }
-}
 
-#[cfg(test)]
-mod print_preview_tests {
-    use super::PrintPreviews;
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    #[test]
-    fn same_title_gets_distinct_private_paths_and_drop_cleans_them() {
-        let stamp = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or_default();
-        let base = std::env::temp_dir().join(format!("deckcraft-print-test-{}-{stamp}", std::process::id()));
-        std::fs::create_dir(&base).unwrap();
-        let (first, second) = {
-            let mut previews = PrintPreviews::default();
-            let first = previews.create_in(&base, "Same title").unwrap();
-            let second = previews.create_in(&base, "Same title").unwrap();
-            assert_ne!(first, second);
-            assert_eq!(first.file_name(), second.file_name());
-            assert!(first.parent().is_some_and(|dir| dir.is_dir()));
-            #[cfg(unix)]
-            {
-                use std::os::unix::fs::PermissionsExt;
-                let mode = std::fs::metadata(first.parent().unwrap()).unwrap().permissions().mode();
-                assert_eq!(mode & 0o777, 0o700);
-            }
-            (first, second)
-        };
-        assert!(!first.parent().is_some_and(|dir| dir.exists()));
-        assert!(!second.parent().is_some_and(|dir| dir.exists()));
-        std::fs::remove_dir(base).unwrap();
+    pub(crate) fn cleanup(&mut self) {
+        for dir in self.0.drain(..) {
+            let _ = std::fs::remove_dir_all(dir);
+        }
     }
 }
 
 impl Drop for PrintPreviews {
     fn drop(&mut self) {
-        for dir in &self.0 {
-            let _ = std::fs::remove_dir_all(dir);
-        }
+        self.cleanup();
     }
 }
 
@@ -761,3 +734,49 @@ pub(crate) fn web_image_files(
         })
         .collect()
 }
+
+#[cfg(test)]
+mod print_preview_tests {
+    use super::PrintPreviews;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    #[test]
+    fn same_title_gets_distinct_private_paths_and_drop_cleans_them() {
+        let stamp = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or_default();
+        let base = std::env::temp_dir().join(format!("deckcraft-print-test-{}-{stamp}", std::process::id()));
+        std::fs::create_dir(&base).unwrap();
+        let (first, second) = {
+            let mut previews = PrintPreviews::default();
+            let first = previews.create_in(&base, "Same title").unwrap();
+            let second = previews.create_in(&base, "Same title").unwrap();
+            assert_ne!(first, second);
+            assert_eq!(first.file_name(), second.file_name());
+            assert!(first.parent().is_some_and(|dir| dir.is_dir()));
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::PermissionsExt;
+                let mode = std::fs::metadata(first.parent().unwrap()).unwrap().permissions().mode();
+                assert_eq!(mode & 0o777, 0o700);
+            }
+            (first, second)
+        };
+        assert!(!first.parent().is_some_and(|dir| dir.exists()));
+        assert!(!second.parent().is_some_and(|dir| dir.exists()));
+        std::fs::remove_dir(base).unwrap();
+    }
+
+    #[test]
+    fn explicit_cleanup_removes_previews() {
+        let stamp = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or_default();
+        let base = std::env::temp_dir().join(format!("deckcraft-print-cleanup-test-{}-{stamp}", std::process::id()));
+        std::fs::create_dir(&base).unwrap();
+        let mut previews = PrintPreviews::default();
+        let path = previews.create_in(&base, "Explicit cleanup").unwrap();
+        let dir = path.parent().unwrap().to_path_buf();
+
+        previews.cleanup();
+
+        assert!(!dir.exists());
+        std::fs::remove_dir(base).unwrap();
+    }
+}
diff --git a/crates/ui-egui/src/backstage/tests.rs b/crates/ui-egui/src/backstage/tests.rs
index 276461d01..22a27972b 100644
--- a/crates/ui-egui/src/backstage/tests.rs
+++ b/crates/ui-egui/src/backstage/tests.rs
@@ -634,21 +634,24 @@ fn print_previews_pages_and_prints_a_pdf() {
     h.state_mut().backstage.as_mut().unwrap().print_range = "1-2".into();
     h.run_steps(2);
     click_on_page(&h, "Print");
-    h.run_steps(2);
-    let url = h.state().pending_urls.first().cloned().unwrap_or_default();
-    // The URL was handed to egui at the end of the frame; check what it pointed at.
+    h.step();
+    let url = h
+        .output()
+        .platform_output
+        .commands
+        .iter()
+        .find_map(|command| match command {
+            egui::OutputCommand::OpenUrl(open) => Some(open.url.as_str()),
+            _ => None,
+        })
+        .expect("Print emits an egui OpenUrl command");
     assert!(url.contains("deckcraft-print-"), "print preview uses its private directory: {url}");
-    let title = h.state().session.active().unwrap().title();
-    let safe: String = title.chars().map(|c| if c.is_alphanumeric() || c == ' ' || c == '-' { c } else { '_' }).collect();
-    let file_name = format!("{safe} (print).pdf");
-    let printed = std::fs::read_dir(std::env::temp_dir())
-        .unwrap()
-        .filter_map(Result::ok)
-        .filter(|entry| entry.file_name().to_string_lossy().starts_with("deckcraft-print-"))
-        .map(|entry| entry.path().join(&file_name))
-        .find(|path| path.is_file())
-        .expect("the PDF to print was written in its private directory");
-    assert!(std::fs::read(&printed).unwrap().starts_with(b"%PDF"));
+    let path = url.strip_prefix("file://").expect("print preview URL is a file URL");
+    #[cfg(windows)]
+    let path = path.strip_prefix('/').unwrap_or(path);
+    let printed = std::path::Path::new(path);
+    assert!(printed.is_file(), "the PDF at the emitted URL was written: {url}");
+    assert!(std::fs::read(printed).unwrap().starts_with(b"%PDF"));
     let _ = std::fs::remove_dir_all(printed.parent().unwrap());
     let _ = std::fs::remove_dir_all(&dir);
 }

From ddd39249ba40256ce7370d08a3cd4e863d9c306b Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 17:03:36 -0500
Subject: [PATCH 13/88] test(codec): strengthen configuration slice regressions

---
 crates/h264/src/synth_tests.rs | 8 +++++---
 crates/hevc/src/synth_tests.rs | 1 +
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/crates/h264/src/synth_tests.rs b/crates/h264/src/synth_tests.rs
index 24a104cf2..a2f9988ae 100644
--- a/crates/h264/src/synth_tests.rs
+++ b/crates/h264/src/synth_tests.rs
@@ -116,14 +116,16 @@ fn avcc_rejects_a_valid_picture_slice_without_starting_a_picture() {
         },
         false,
     );
-    let mut avcc = vec![1, 66, 0, 30, 0xff, 0xe2];
-    for nal in [&sequence[4..], &slice[4..]] {
+    let mut avcc = vec![1, 66, 0, 30, 0xff, 0xe1];
+    for nal in [&sequence[4..]] {
         avcc.extend_from_slice(&(nal.len() as u16).to_be_bytes());
         avcc.extend_from_slice(nal);
     }
-    avcc.push(1);
+    avcc.push(2);
     avcc.extend_from_slice(&((picture.len() - 4) as u16).to_be_bytes());
     avcc.extend_from_slice(&picture[4..]);
+    avcc.extend_from_slice(&((slice.len() - 4) as u16).to_be_bytes());
+    avcc.extend_from_slice(&slice[4..]);
 
     let mut decoder = Decoder::with_threads(1);
     assert!(decoder.configure_avcc(&avcc).is_err());
diff --git a/crates/hevc/src/synth_tests.rs b/crates/hevc/src/synth_tests.rs
index 7baf7b496..4d044a3d5 100644
--- a/crates/hevc/src/synth_tests.rs
+++ b/crates/hevc/src/synth_tests.rs
@@ -700,5 +700,6 @@ fn hvcc_rejects_a_valid_picture_slice_without_starting_a_picture() {
 
     let mut decoder = Decoder::with_threads(1);
     assert!(decoder.configure_hvcc(&hvcc).is_err());
+    assert!(decoder.flush().is_empty());
     assert_eq!(decoder.stats().pictures, 0);
 }

From 7190c858604fb2c94d332554cdeeb8ad755d0707 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 17:06:36 -0500
Subject: [PATCH 14/88] test(h264): avoid singleton fixture loop

---
 crates/h264/src/synth_tests.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/crates/h264/src/synth_tests.rs b/crates/h264/src/synth_tests.rs
index a2f9988ae..ac00d8604 100644
--- a/crates/h264/src/synth_tests.rs
+++ b/crates/h264/src/synth_tests.rs
@@ -117,10 +117,9 @@ fn avcc_rejects_a_valid_picture_slice_without_starting_a_picture() {
         false,
     );
     let mut avcc = vec![1, 66, 0, 30, 0xff, 0xe1];
-    for nal in [&sequence[4..]] {
-        avcc.extend_from_slice(&(nal.len() as u16).to_be_bytes());
-        avcc.extend_from_slice(nal);
-    }
+    let nal = &sequence[4..];
+    avcc.extend_from_slice(&(nal.len() as u16).to_be_bytes());
+    avcc.extend_from_slice(nal);
     avcc.push(2);
     avcc.extend_from_slice(&((picture.len() - 4) as u16).to_be_bytes());
     avcc.extend_from_slice(&picture[4..]);

From 3c068df62879ce6444d0d04562d3b483def6a85e Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 17:13:38 -0500
Subject: [PATCH 15/88] test(h264): complete picture slice fixture

---
 crates/h264/src/synth_tests.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/h264/src/synth_tests.rs b/crates/h264/src/synth_tests.rs
index ac00d8604..76609dbde 100644
--- a/crates/h264/src/synth_tests.rs
+++ b/crates/h264/src/synth_tests.rs
@@ -108,7 +108,7 @@ fn avcc_rejects_a_valid_picture_slice_without_starting_a_picture() {
             long_term_ref: false,
             mods: vec![],
             mmcos: vec![],
-            mbs: vec![Some(vec![128; 16 * 16]); NMB],
+            mbs: vec![Some(vec![128; 384]); NMB],
             b: false,
             poc_lsb: Some(0),
             poc_delta: None,
@@ -128,6 +128,7 @@ fn avcc_rejects_a_valid_picture_slice_without_starting_a_picture() {
 
     let mut decoder = Decoder::with_threads(1);
     assert!(decoder.configure_avcc(&avcc).is_err());
+    assert!(decoder.flush().is_empty());
     assert_eq!(decoder.stats().pictures, 0);
 }
 

From 446bc528ad43864a89d68bd6b574f89e1d6cc194 Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Wed, 28 Oct 2026 13:45:57 +0000
Subject: [PATCH 16/88] Make layout/master placeholder formatting reach slides

Fixes #1487

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/text/formatting.rs | 32 ++++++++++++++++++++++++
 crates/engine/src/tests.rs               | 26 +++++++++++++++++++
 2 files changed, 58 insertions(+)

diff --git a/crates/engine/src/cmd/text/formatting.rs b/crates/engine/src/cmd/text/formatting.rs
index 158af0962..b58cb69e4 100644
--- a/crates/engine/src/cmd/text/formatting.rs
+++ b/crates/engine/src/cmd/text/formatting.rs
@@ -31,8 +31,10 @@ pub(crate) fn format_run(s: &mut Session, f: &(dyn Fn(&mut RunProps) + Send + Sy
         return Err(bad("format", SELECT_TEXT_OR_SHAPE));
     }
     let cells = st.selection.cells;
+    let on_master = editing_master(st);
     edit_shapes(s, &json!({"ids": ids}), "format", |sh| {
         let id = sh.id;
+        let inherited = on_master && sh.ph.is_some();
         match &mut sh.kind {
             ShapeKind::Table(t) => {
                 // Only the selected cells, when a range of them is selected.
@@ -48,6 +50,13 @@ pub(crate) fn format_run(s: &mut Session, f: &(dyn Fn(&mut RunProps) + Send + Sy
             _ => {
                 let body = sh.text.get_or_insert_with(TextBody::default);
                 ed::format_all(body, f);
+                if inherited {
+                    for l in 0..LIST_LEVELS {
+                        let mut lvl = body.list_style.level(l).cloned().unwrap_or_default();
+                        f(&mut lvl.run);
+                        body.list_style.set(l, lvl);
+                    }
+                }
             }
         }
         Ok(())
@@ -58,6 +67,15 @@ pub(crate) fn format_run(s: &mut Session, f: &(dyn Fn(&mut RunProps) + Send + Sy
     ok()
 }
 
+/// List-style levels (`lvl1pPr`–`lvl9pPr`) a placeholder passes on to the slides that use it.
+const LIST_LEVELS: u8 = 9;
+
+/// Formatting a placeholder on a layout or master (Slide Master view) also sets its list style,
+/// which is what the placeholders on slides inherit; its own runs may be few or none.
+fn editing_master(st: &DocState) -> bool {
+    matches!(st.selection.target, crate::Target::Layout { .. } | crate::Target::Master { .. })
+}
+
 /// What `format_run` formats while editing: the selection, or for a bare caret the word it's in
 /// (without its trailing space). Empty when the caret is at a word boundary. Insert Hyperlink
 /// edits this same span, so the dialog reads it too.
@@ -128,8 +146,10 @@ pub(crate) fn format_para(s: &mut Session, f: &(dyn Fn(&mut deckcraft_model::tex
         return Err(bad("format", SELECT_TEXT_OR_SHAPE));
     }
     let cells = st.selection.cells;
+    let on_master = editing_master(st);
     edit_shapes(s, &json!({"ids": ids}), "format", |sh| {
         let id = sh.id;
+        let inherited = on_master && sh.ph.is_some();
         match &mut sh.kind {
             ShapeKind::Table(t) => {
                 let range = crate::cmd::table::selected_range(cells, id, t);
@@ -147,6 +167,18 @@ pub(crate) fn format_para(s: &mut Session, f: &(dyn Fn(&mut deckcraft_model::tex
                     body.paragraphs.push(Default::default());
                 }
                 body.paragraphs.iter_mut().for_each(f);
+                if inherited {
+                    for l in 0..LIST_LEVELS {
+                        let mut lvl = body.list_style.level(l).cloned().unwrap_or_default();
+                        let mut p = deckcraft_model::text::Paragraph { level: l, props: lvl.para, ..Default::default() };
+                        f(&mut p);
+                        // A level change (indent/outdent) means nothing for a list-style level.
+                        if p.level == l {
+                            lvl.para = p.props;
+                            body.list_style.set(l, lvl);
+                        }
+                    }
+                }
             }
         }
         Ok(())
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 85cbe9d8c..5b3dcb03b 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -5956,3 +5956,29 @@ fn invalid_slide_index_never_falls_back_to_the_selection_in_export_commands() {
     }
     let _ = std::fs::remove_dir_all(&dir);
 }
+
+#[test]
+fn master_layout_placeholder_format_inherits() {
+    let mut s = Session::new();
+    sample::open_sample(&mut s).unwrap();
+    let title_of = |shapes: &[model::Shape]| shapes.iter().find(|sh| sh.ph.as_ref().is_some_and(|p| p.kind.is_title())).map(|sh| sh.id.0).unwrap();
+    let existing = title_of(&s.doc().unwrap().doc.slides[0].shapes);
+    s.execute("view.slideMaster", &json!({"master": 0, "layout": 0})).unwrap();
+    let layout_title = title_of(&s.doc().unwrap().doc.masters[0].layouts[0].shapes);
+    s.execute("edit.select", &json!({"ids": [layout_title]})).unwrap();
+    s.execute("format.font", &json!({"family": "Montserrat"})).unwrap();
+    s.execute("format.align", &json!({"align": "right"})).unwrap();
+    let st = s.execute("format.state", &json!({})).unwrap();
+    assert_eq!(st["fontRef"], "Montserrat", "layout placeholder: {st}");
+    s.execute("view.closeMaster", &json!({})).unwrap();
+    s.execute("slide.new", &json!({"layout": "title"})).unwrap();
+    let slide = s.doc().unwrap().selection.slide;
+    let fresh = title_of(&s.doc().unwrap().doc.slides[slide].shapes);
+    for (index, id) in [(slide, fresh), (0, existing)] {
+        s.execute("slide.go", &json!({"index": index})).unwrap();
+        s.execute("edit.select", &json!({"ids": [id]})).unwrap();
+        let st = s.execute("format.state", &json!({})).unwrap();
+        assert_eq!(st["fontRef"], "Montserrat", "slide placeholder {id}: {st}");
+        assert_eq!(st["align"], "r", "slide placeholder {id}: {st}");
+    }
+}

From adaa4e6fa1286794cf4cc0bd182f1e200ac76fb6 Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Fri, 30 Oct 2026 23:06:29 +0100
Subject: [PATCH 17/88] fix: keep per-level formatting when formatting
 layout/master placeholders

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/format.rs          |   2 +-
 crates/engine/src/cmd/format/font.rs     |  18 +++-
 crates/engine/src/cmd/text.rs            |   2 +-
 crates/engine/src/cmd/text/formatting.rs | 126 +++++++++++++++++++----
 crates/engine/src/tests.rs               |  49 +++++++++
 5 files changed, 168 insertions(+), 29 deletions(-)

diff --git a/crates/engine/src/cmd/format.rs b/crates/engine/src/cmd/format.rs
index 0f81cfaf5..4e273dc1c 100644
--- a/crates/engine/src/cmd/format.rs
+++ b/crates/engine/src/cmd/format.rs
@@ -8,7 +8,7 @@ use deckcraft_model::{ColorRef, ColorTransform, Effects, Fill, Line, SchemeSlot,
 use serde_json::{Value, json};
 use std::sync::Arc;
 
-use super::text::{format_body, format_para, format_run};
+use super::text::{format_body, format_para, format_run, format_run_levels};
 use super::{
     CommandSpec, always, bad, base64_decode, bool_or, bool_param, cmd, color_param, edit_shapes, f64_or, f64_param, has_doc, has_text,
     has_text_or_shapes, ids_param, ok, str_param,
diff --git a/crates/engine/src/cmd/format/font.rs b/crates/engine/src/cmd/format/font.rs
index 11af99b7e..fa30e93c4 100644
--- a/crates/engine/src/cmd/format/font.rs
+++ b/crates/engine/src/cmd/format/font.rs
@@ -1,6 +1,6 @@
 use super::{
     Arc, Caps, ColorRef, ColorTransform, Fill, Result, RunProps, SchemeSlot, Session, Shape, ShapeId, ShapeKind, Strike, Value, bad, bool_or,
-    bool_param, color_param, current_run, ed, edit_shapes, f64_param, format_run, json, ok, on_param, resolve, str_param,
+    bool_param, color_param, current_run, ed, edit_shapes, f64_param, format_run, format_run_levels, json, ok, on_param, resolve, str_param,
 };
 
 pub(super) fn bold(s: &mut Session, p: &Value) -> Result<Value> {
@@ -72,10 +72,18 @@ fn grow_shrink(s: &mut Session, up: bool) -> Result<Value> {
     let ctx_sizes = current_run(s).size.unwrap_or(18.0);
     let _ = st;
     let base = ctx_sizes;
-    format_run(s, &move |r| {
-        let cur = r.size.unwrap_or(base);
-        r.size = Some(step(cur, up));
-    })
+    // A layout/master level steps from its own effective size, not the first run's.
+    format_run_levels(
+        s,
+        &move |r| {
+            let cur = r.size.unwrap_or(base);
+            r.size = Some(step(cur, up));
+        },
+        &move |r, eff| {
+            let cur = r.size.or(eff.size).unwrap_or(18.0);
+            r.size = Some(step(cur, up));
+        },
+    )
 }
 
 pub(super) fn grow(s: &mut Session, _p: &Value) -> Result<Value> {
diff --git a/crates/engine/src/cmd/text.rs b/crates/engine/src/cmd/text.rs
index 6f85df870..d095d7faf 100644
--- a/crates/engine/src/cmd/text.rs
+++ b/crates/engine/src/cmd/text.rs
@@ -30,7 +30,7 @@ use editing::{edit, exit};
 pub(crate) use editing::{insert_field, insert_text, paste_body};
 pub use formatting::format_range;
 use formatting::{fonts_used, replace_font};
-pub(crate) use formatting::{format_body, format_para, format_run, link_text};
+pub(crate) use formatting::{format_body, format_para, format_run, format_run_levels, link_text};
 pub use ime::{IME_SURROUNDING_MAX_BYTES, ImeSurrounding, cell_range_underlines, composition_underlines, ime_surrounding, range_underlines};
 use ime::{commit, compose};
 pub(crate) use layout::ctx_for;
diff --git a/crates/engine/src/cmd/text/formatting.rs b/crates/engine/src/cmd/text/formatting.rs
index b58cb69e4..d942ee282 100644
--- a/crates/engine/src/cmd/text/formatting.rs
+++ b/crates/engine/src/cmd/text/formatting.rs
@@ -8,22 +8,34 @@ use super::{
 /// selected shapes). A caret without a range formats the word it's in (PowerPoint behaviour),
 /// or sets the formatting for what is typed next at a word boundary.
 pub(crate) fn format_run(s: &mut Session, f: &(dyn Fn(&mut RunProps) + Send + Sync)) -> Result<Value> {
+    format_run_levels(s, f, &|r, _| f(r))
+}
+
+/// Like [`format_run`], with a separate change for the list-style levels of a layout or master
+/// placeholder: `lf` gets the level's own run props and the level's effective ones (what a run at
+/// that level resolves to), so a relative change (grow/shrink) steps each level from its own value.
+pub(crate) fn format_run_levels(
+    s: &mut Session,
+    f: &(dyn Fn(&mut RunProps) + Send + Sync),
+    lf: &(dyn Fn(&mut RunProps, &RunProps) + Send + Sync),
+) -> Result<Value> {
     let st = s.doc()?;
     if let Some(t) = st.selection.text.clone() {
         let (a, b) = format_range(st, &t);
-        let collapsed = a == b;
+        // Only the levels of the paragraphs the selected range touches.
+        let levels = if a == b { Vec::new() } else { master_levels(st, &t, t.ordered()) };
         edit_text(s, |body, _| {
-            if collapsed {
-                // Next typed text: put the props on an empty paragraph's end mark or keep pending.
+            if levels.is_empty() {
                 ed::format(body, a, b, f);
             } else {
-                ed::format(body, a, b, f);
+                format_by_level(body, a, b, lf, &levels);
+            }
+            for (l, eff) in &levels {
+                let mut lvl = body.list_style.level(*l).cloned().unwrap_or_default();
+                lf(&mut lvl.run, eff);
+                body.list_style.set(*l, lvl);
             }
         })?;
-        if collapsed {
-            // Remember as pending typing props by inserting nothing: handled via end mark for
-            // empty paragraphs; mid-paragraph carets keep surrounding formatting.
-        }
         return ok();
     }
     let ids = st.selection.shapes.clone();
@@ -31,10 +43,21 @@ pub(crate) fn format_run(s: &mut Session, f: &(dyn Fn(&mut RunProps) + Send + Sy
         return Err(bad("format", SELECT_TEXT_OR_SHAPE));
     }
     let cells = st.selection.cells;
-    let on_master = editing_master(st);
+    // Effective run props of every level of the selected placeholders, resolved before editing.
+    let effective: Vec<(ShapeId, Vec<RunProps>)> = if editing_master(st) {
+        let ctx = crate::cmd::text::ctx_for(&st.doc, &st.selection);
+        ids.iter()
+            .filter_map(|id| {
+                let sh = st.shape(*id).filter(|sh| sh.ph.is_some())?;
+                let ctx = ctx.as_ref()?;
+                Some((*id, (0..LIST_LEVELS).map(|l| deckcraft_model::resolve::level_style(ctx, sh, l).run).collect()))
+            })
+            .collect()
+    } else {
+        Vec::new()
+    };
     edit_shapes(s, &json!({"ids": ids}), "format", |sh| {
         let id = sh.id;
-        let inherited = on_master && sh.ph.is_some();
         match &mut sh.kind {
             ShapeKind::Table(t) => {
                 // Only the selected cells, when a range of them is selected.
@@ -49,11 +72,19 @@ pub(crate) fn format_run(s: &mut Session, f: &(dyn Fn(&mut RunProps) + Send + Sy
             }
             _ => {
                 let body = sh.text.get_or_insert_with(TextBody::default);
-                ed::format_all(body, f);
-                if inherited {
-                    for l in 0..LIST_LEVELS {
+                let eff = effective.iter().find(|(i, _)| *i == id).map(|(_, e)| e);
+                match eff {
+                    Some(eff) => {
+                        let levels: Vec<(u8, RunProps)> = (0..LIST_LEVELS).zip(eff.iter().cloned()).collect();
+                        format_by_level(body, (0, 0), (usize::MAX, usize::MAX), lf, &levels);
+                    }
+                    None => ed::format_all(body, f),
+                }
+                // The whole shape is selected: every level of its list style.
+                if let Some(eff) = eff {
+                    for (l, eff) in (0..LIST_LEVELS).zip(eff) {
                         let mut lvl = body.list_style.level(l).cloned().unwrap_or_default();
-                        f(&mut lvl.run);
+                        lf(&mut lvl.run, eff);
                         body.list_style.set(l, lvl);
                     }
                 }
@@ -67,6 +98,25 @@ pub(crate) fn format_run(s: &mut Session, f: &(dyn Fn(&mut RunProps) + Send + Sy
     ok()
 }
 
+/// Format the runs of [a, b) paragraph by paragraph, each with its own level's effective props, so
+/// a relative change (grow/shrink) steps every paragraph from its own size instead of one shared
+/// value. `a`/`b` are clamped to the body.
+fn format_by_level(body: &mut TextBody, a: Pos, b: Pos, lf: &(dyn Fn(&mut RunProps, &RunProps) + Send + Sync), levels: &[(u8, RunProps)]) {
+    let Some(last) = body.paragraphs.len().checked_sub(1) else { return };
+    let (first, end) = (a.0.min(last), b.0.min(last));
+    for pi in first..=end {
+        let p = &body.paragraphs[pi];
+        let from = if pi == first { a.1.min(p.char_len()) } else { 0 };
+        let to = if pi == end { b.1.min(p.char_len()) } else { p.char_len() };
+        if from == to && p.char_len() > 0 {
+            continue;
+        }
+        let lvl = p.level.min(LIST_LEVELS - 1);
+        let Some((_, eff)) = levels.iter().find(|(l, _)| *l == lvl) else { continue };
+        ed::format(body, (pi, from), (pi, to), &|r| lf(r, eff));
+    }
+}
+
 /// List-style levels (`lvl1pPr`–`lvl9pPr`) a placeholder passes on to the slides that use it.
 const LIST_LEVELS: u8 = 9;
 
@@ -76,6 +126,27 @@ fn editing_master(st: &DocState) -> bool {
     matches!(st.selection.target, crate::Target::Layout { .. } | crate::Target::Master { .. })
 }
 
+/// The distinct list-style levels of the paragraphs `range` touches in a layout or master
+/// placeholder, with each level's effective run props. Empty anywhere else.
+fn master_levels(st: &DocState, t: &TextSel, range: (Pos, Pos)) -> Vec<(u8, RunProps)> {
+    if !editing_master(st) || t.notes || t.cell.is_some() {
+        return Vec::new();
+    }
+    let (Some(sh), Some(body), Some(ctx)) =
+        (st.shape(t.shape).filter(|sh| sh.ph.is_some()), body_of(st, t), crate::cmd::text::ctx_for(&st.doc, &st.selection))
+    else {
+        return Vec::new();
+    };
+    let mut levels: Vec<u8> =
+        body.paragraphs.iter().enumerate().filter(|(i, _)| (range.0.0..=range.1.0).contains(i)).map(|(_, p)| p.level.min(LIST_LEVELS - 1)).collect();
+    if body.paragraphs.is_empty() {
+        levels.push(0);
+    }
+    levels.sort_unstable();
+    levels.dedup();
+    levels.into_iter().map(|l| (l, deckcraft_model::resolve::level_style(&ctx, sh, l).run)).collect()
+}
+
 /// What `format_run` formats while editing: the selection, or for a bare caret the word it's in
 /// (without its trailing space). Empty when the caret is at a word boundary. Insert Hyperlink
 /// edits this same span, so the dialog reads it too.
@@ -128,6 +199,8 @@ pub(crate) fn format_para(s: &mut Session, f: &(dyn Fn(&mut deckcraft_model::tex
     let st = s.doc()?;
     if let Some(t) = st.selection.text.clone() {
         let (a, b) = t.ordered();
+        // Only the list-style levels of the paragraphs touched, on a layout or master placeholder.
+        let levels: Vec<u8> = master_levels(st, &t, (a, b)).into_iter().map(|(l, _)| l).collect();
         edit_text(s, |body, _| {
             if body.paragraphs.is_empty() {
                 body.paragraphs.push(Default::default());
@@ -138,6 +211,9 @@ pub(crate) fn format_para(s: &mut Session, f: &(dyn Fn(&mut deckcraft_model::tex
                     f(p);
                 }
             }
+            for l in levels {
+                format_list_level(body, l, f);
+            }
         })?;
         return ok();
     }
@@ -167,16 +243,10 @@ pub(crate) fn format_para(s: &mut Session, f: &(dyn Fn(&mut deckcraft_model::tex
                     body.paragraphs.push(Default::default());
                 }
                 body.paragraphs.iter_mut().for_each(f);
+                // The whole shape is selected: every level of its list style.
                 if inherited {
                     for l in 0..LIST_LEVELS {
-                        let mut lvl = body.list_style.level(l).cloned().unwrap_or_default();
-                        let mut p = deckcraft_model::text::Paragraph { level: l, props: lvl.para, ..Default::default() };
-                        f(&mut p);
-                        // A level change (indent/outdent) means nothing for a list-style level.
-                        if p.level == l {
-                            lvl.para = p.props;
-                            body.list_style.set(l, lvl);
-                        }
+                        format_list_level(body, l, f);
                     }
                 }
             }
@@ -189,6 +259,18 @@ pub(crate) fn format_para(s: &mut Session, f: &(dyn Fn(&mut deckcraft_model::tex
     ok()
 }
 
+/// Apply a paragraph change to one level of a body's list style.
+fn format_list_level(body: &mut TextBody, l: u8, f: &(dyn Fn(&mut deckcraft_model::text::Paragraph) + Send + Sync)) {
+    let mut lvl = body.list_style.level(l).cloned().unwrap_or_default();
+    let mut p = deckcraft_model::text::Paragraph { level: l, props: lvl.para, ..Default::default() };
+    f(&mut p);
+    // A level change (indent/outdent) means nothing for a list-style level.
+    if p.level == l {
+        lvl.para = p.props;
+        body.list_style.set(l, lvl);
+    }
+}
+
 /// Apply body (text box) changes to the edited or selected shapes.
 pub(crate) fn format_body(s: &mut Session, f: &(dyn Fn(&mut deckcraft_model::text::BodyProps) + Send + Sync)) -> Result<Value> {
     let st = s.doc()?;
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 5b3dcb03b..b3276046d 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -5982,3 +5982,52 @@ fn master_layout_placeholder_format_inherits() {
         assert_eq!(st["align"], "r", "slide placeholder {id}: {st}");
     }
 }
+
+#[test]
+fn master_body_placeholder_format_keeps_per_level_formatting() {
+    let mut s = Session::new();
+    sample::open_sample(&mut s).unwrap();
+    s.execute("view.slideMaster", &json!({"master": 0})).unwrap();
+    let body_idx =
+        s.doc().unwrap().doc.masters[0].shapes.iter().position(|sh| sh.ph.as_ref().is_some_and(|p| p.kind == model::PhType::Body)).unwrap();
+    let id = {
+        let st = s.doc_mut().unwrap();
+        let sh = &mut std::sync::Arc::make_mut(&mut std::sync::Arc::make_mut(&mut st.doc).masters[0]).shapes[body_idx];
+        let mut body = model::TextBody::from_text("Alpha\nBeta");
+        body.paragraphs[1].level = 1;
+        for (l, size) in [(0u8, 32.0), (1, 28.0)] {
+            let mut lvl = model::text::LevelStyle::default();
+            lvl.run.size = Some(size);
+            body.list_style.set(l, lvl);
+        }
+        sh.text = Some(body);
+        sh.id
+    };
+    let level =
+        |s: &Session, l: u8| s.doc().unwrap().doc.masters[0].shapes[body_idx].text.as_ref().unwrap().list_style.level(l).cloned().unwrap_or_default();
+    // Bolding the level-2 paragraph reaches level 2 only.
+    s.doc_mut().unwrap().selection.shapes = vec![id];
+    s.doc_mut().unwrap().selection.text = Some(TextSel { shape: id, anchor: (1, 0), caret: (1, 4), cell: None, notes: false, line_end: None });
+    s.execute("format.bold", &json!({"on": true})).unwrap();
+    assert_eq!(level(&s, 1).run.bold, Some(true));
+    for l in [0, 2, 3, 8] {
+        assert_eq!(level(&s, l).run.bold, None, "level {}", l + 1);
+    }
+    // Grow and shrink step each level from its own size.
+    s.doc_mut().unwrap().selection.text = None;
+    // The text itself: a run's explicit size, else its level's effective size.
+    let shown = |s: &Session| -> Vec<Option<f64>> {
+        let st = s.doc().unwrap();
+        let ctx = crate::cmd::text::ctx_for(&st.doc, &st.selection).unwrap();
+        let sh = &st.doc.masters[0].shapes[body_idx];
+        let body = sh.text.as_ref().unwrap();
+        body.paragraphs.iter().map(|p| p.runs[0].props.size.or(deckcraft_model::resolve::level_style(&ctx, sh, p.level).run.size)).collect()
+    };
+    s.execute("format.grow", &json!({})).unwrap();
+    assert_eq!((level(&s, 0).run.size, level(&s, 1).run.size), (Some(36.0), Some(32.0)));
+    assert_eq!(shown(&s), vec![Some(36.0), Some(32.0)]);
+    s.execute("format.shrink", &json!({})).unwrap();
+    s.execute("format.shrink", &json!({})).unwrap();
+    assert_eq!((level(&s, 0).run.size, level(&s, 1).run.size), (Some(28.0), Some(24.0)));
+    assert_eq!(shown(&s), vec![Some(28.0), Some(24.0)]);
+}

From ee4bdbcd7d5396964e13142f309710519180d2e5 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 17:23:00 -0500
Subject: [PATCH 18/88] fix: initialize slide action test run props

---
 crates/engine/src/cmd/inspect.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/crates/engine/src/cmd/inspect.rs b/crates/engine/src/cmd/inspect.rs
index e09cf14a0..1da38843f 100644
--- a/crates/engine/src/cmd/inspect.rs
+++ b/crates/engine/src/cmd/inspect.rs
@@ -239,8 +239,7 @@ mod tests {
         let mut child = Shape { id: ShapeId(12), name: "Child".into(), ..Default::default() };
         child.click = Some(link(Action::NextSlide));
         child.hover = Some(link(Action::Url { url: "https://example.com/hover".into() }));
-        let mut run_props = RunProps::default();
-        run_props.link = Some(link(Action::Slide { slide: deckcraft_model::SlideId(7) }));
+        let run_props = RunProps { link: Some(link(Action::Slide { slide: deckcraft_model::SlideId(7) })), ..Default::default() };
         let mut paragraph = Paragraph::new("linked");
         paragraph.runs = vec![Run::with("linked", run_props)];
         child.text = Some(TextBody { paragraphs: vec![paragraph], ..Default::default() });
@@ -268,8 +267,7 @@ mod tests {
         assert_eq!(actions[2]["owner"]["runIndex"], 0);
         assert_eq!(actions[2]["target"], 7);
 
-        let mut cell_props = RunProps::default();
-        cell_props.hover = Some(link(Action::Url { url: "https://example.com/cell".into() }));
+        let cell_props = RunProps { hover: Some(link(Action::Url { url: "https://example.com/cell".into() })), ..Default::default() };
         let mut cell_text = TextBody::from_text("cell link");
         cell_text.paragraphs[0].runs = vec![Run::with("cell link", cell_props)];
         let table =

From e812da58df5b2d1c268b6674c6b10dbee67ce8ce Mon Sep 17 00:00:00 2001
From: DominicTheD3v <119626487+DominicTheD3v@users.noreply.github.com>
Date: Fri, 30 Oct 2026 22:51:33 +0000
Subject: [PATCH 19/88] fix: addressing issues

---
 crates/engine/src/tests.rs         | 12 ++++++++---
 crates/engine/src/tools.rs         |  2 ++
 crates/engine/src/tools/drag.rs    | 33 +++++++++++++++++++++++++-----
 crates/engine/src/tools/pointer.rs |  3 ++-
 4 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index b72dcbd7d..ef18a31f6 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -5504,6 +5504,7 @@ fn pending_resize_autofit(s: &mut Session, ids: &[u64]) {
     .unwrap();
 }
 
+/// Resizing multiple selected shapes scales them proportionally around their anchors in one undo step.
 #[test]
 fn resizing_selected_shapes_is_one_undo_step() {
     let (mut s, [a, b]) = resize_selection_scene();
@@ -5512,7 +5513,7 @@ fn resizing_selected_shapes_is_one_undo_step() {
     let down = drag_gesture(&mut s, (200.0, 180.0), (250.0, 210.0));
     assert_eq!(down["hit"]["kind"], "resize");
     assert_eq!(down["hit"]["id"], a);
-    for (id, expected) in [(a, [100.0, 100.0, 150.0, 110.0]), (b, [120.0, 300.0, 130.0, 130.0])] {
+    for (id, expected) in [(a, [100.0, 100.0, 150.0, 110.0]), (b, [120.0, 300.0, 120.0, 137.5])] {
         let actual = box_of(&mut s, id);
         for (key, value) in ["x", "y", "w", "h"].into_iter().zip(expected) {
             assert_eq!(actual[key], value, "{id}: {key}");
@@ -5526,6 +5527,7 @@ fn resizing_selected_shapes_is_one_undo_step() {
     assert_eq!(s.doc().unwrap().doc, after, "one redo resizes both shapes again");
 }
 
+/// Resizing selected shapes refits their text boxes inside the same undo transaction.
 #[test]
 fn resizing_selected_shapes_refits_text_in_the_same_undo_step() {
     let (mut s, ids) = resize_selection_scene();
@@ -5545,6 +5547,7 @@ fn resizing_selected_shapes_refits_text_in_the_same_undo_step() {
     assert_eq!(s.doc().unwrap().doc, after, "redo includes the final text fit");
 }
 
+/// Clicking a resize handle without dragging neither modifies shapes nor triggers text autofit.
 #[test]
 fn clicking_a_resize_handle_does_not_change_or_refit_selected_shapes() {
     let (mut s, ids) = resize_selection_scene();
@@ -5566,6 +5569,7 @@ fn clicking_a_resize_handle_does_not_change_or_refit_selected_shapes() {
     assert_ne!(s.doc().unwrap().doc, before);
 }
 
+/// Locked shapes in a multi-selection are excluded from both resizing and post-resize text fitting.
 #[test]
 fn resizing_selected_shapes_skips_locked_shapes_and_their_text_fit() {
     let (mut s, [a, b]) = resize_selection_scene();
@@ -5584,6 +5588,7 @@ fn resizing_selected_shapes_skips_locked_shapes_and_their_text_fit() {
     assert_eq!(s.doc().unwrap().doc, before);
 }
 
+/// Resizing selected shapes excludes other selected resize targets from smart-guide snapping.
 #[test]
 fn resizing_selected_shapes_does_not_snap_to_other_resize_targets() {
     for reverse in [false, true] {
@@ -5594,10 +5599,11 @@ fn resizing_selected_shapes_does_not_snap_to_other_resize_targets() {
         // Within snap tolerance of the other selected shape's original right edge.
         drag_gesture(&mut s, (200.0, 140.0), (203.0, 140.0));
         assert_eq!(box_of(&mut s, a)["w"], 103.0, "first shape must not snap back");
-        assert_eq!(box_of(&mut s, b)["w"], 83.0, "selection order must not affect snapping");
+        assert_eq!(box_of(&mut s, b)["w"], 82.4, "selection order must not affect snapping");
     }
 }
 
+/// Resizing selected shapes snaps the active shape against unselected stationary shapes and scales others proportionally.
 #[test]
 fn resizing_selected_shapes_still_snaps_to_stationary_shapes() {
     let (mut s, [a, b]) = resize_selection_scene();
@@ -5607,7 +5613,7 @@ fn resizing_selected_shapes_still_snaps_to_stationary_shapes() {
     s.prefs.smart_guides = true;
     drag_gesture(&mut s, (200.0, 140.0), (203.0, 140.0));
     assert_eq!(box_of(&mut s, a)["w"], 107.0);
-    assert_eq!(box_of(&mut s, b)["w"], 87.0);
+    assert!((box_of(&mut s, b)["w"].as_f64().unwrap() - 85.6).abs() < 1e-9);
     assert_eq!(box_of(&mut s, fixed), fixed_before);
 }
 
diff --git a/crates/engine/src/tools.rs b/crates/engine/src/tools.rs
index 19440fb33..82f53dfc3 100644
--- a/crates/engine/src/tools.rs
+++ b/crates/engine/src/tools.rs
@@ -149,6 +149,8 @@ enum Drag {
         enter_text: Option<(ShapeId, Point)>,
     },
     Resize {
+        id: ShapeId,
+        orig: Xfrm,
         ids: Vec<ShapeId>,
         handle: u8,
         origs: Vec<(ShapeId, Xfrm)>,
diff --git a/crates/engine/src/tools/drag.rs b/crates/engine/src/tools/drag.rs
index 7dca38225..367e6b856 100644
--- a/crates/engine/src/tools/drag.rs
+++ b/crates/engine/src/tools/drag.rs
@@ -26,11 +26,34 @@ impl Session {
             Drag::Move { ids, start, origs, moved, duplicate, enter_text } => {
                 return self.drag_move(MoveDrag { ids, start, origs, moved, duplicate, enter_text }, p, mods, tol);
             }
-            Drag::Resize { ids, handle, origs, start } => {
-                for (id, o) in &origs {
-                    let nx = resize_box(o, handle, p - start, mods.shift || self.is_picture(*id), mods.alt);
-                    let nx = self.snap_resize(nx, handle, &ids, tol);
-                    self.set_xfrm(*id, nx)?;
+            Drag::Resize { id, orig, ids, handle, origs, start } => {
+                let nx = resize_box(&orig, handle, p - start, mods.shift || self.is_picture(id), mods.alt);
+                let nx = self.snap_resize(nx, handle, &ids, tol);
+                let sx = if orig.w > 1e-9 { (nx.w / orig.w) * if nx.flip_h != orig.flip_h { -1.0 } else { 1.0 } - 1.0 } else { 0.0 };
+                let sy = if orig.h > 1e-9 { (nx.h / orig.h) * if nx.flip_v != orig.flip_v { -1.0 } else { 1.0 } - 1.0 } else { 0.0 };
+                let div = if mods.alt { 2.0 } else { 1.0 };
+                let hx = match handle {
+                    0 | 6 | 7 => -1.0,
+                    2..=4 => 1.0,
+                    _ => 0.0,
+                };
+                let hy = match handle {
+                    0..=2 => -1.0,
+                    4..=6 => 1.0,
+                    _ => 0.0,
+                };
+                for (tid, o) in &origs {
+                    let target_nx = if *tid == id {
+                        nx
+                    } else {
+                        let lp = Affine::rotate(o.rot.to_radians())
+                            * Point::new(
+                                hx * sx * o.w / div * if o.flip_h { -1.0 } else { 1.0 },
+                                hy * sy * o.h / div * if o.flip_v { -1.0 } else { 1.0 },
+                            );
+                        resize_box(o, handle, Vec2::new(lp.x, lp.y), mods.shift || self.is_picture(*tid), mods.alt)
+                    };
+                    self.set_xfrm(*tid, target_nx)?;
                 }
             }
             Drag::LineEnd { id, end, orig } => {
diff --git a/crates/engine/src/tools/pointer.rs b/crates/engine/src/tools/pointer.rs
index dbaf495f8..1f4cba0c5 100644
--- a/crates/engine/src/tools/pointer.rs
+++ b/crates/engine/src/tools/pointer.rs
@@ -302,12 +302,13 @@ impl Session {
             Some(Hit::TableColumn { id, col }) => self.begin_table_border(id, true, col, p)?,
             Some(Hit::TableRow { id, row }) => self.begin_table_border(id, false, row, p)?,
             Some(Hit::Resize { id, handle }) => {
+                let orig = st.shape(id).map(|s| xfrm_of(&st.doc, &st.selection, s)).unwrap_or_default();
                 let ids: Vec<ShapeId> = if st.selection.shapes.contains(&id) { st.selection.shapes.clone() } else { vec![id] };
                 let origs: Vec<(ShapeId, Xfrm)> =
                     ids.iter().filter_map(|i| st.shape(*i).filter(|s| !s.locked).map(|s| (*i, xfrm_of(&st.doc, &st.selection, s)))).collect();
                 let ids: Vec<ShapeId> = origs.iter().map(|(id, _)| *id).collect();
                 self.begin("Size");
-                self.tool.drag = Some(Drag::Resize { ids, handle, origs, start: p });
+                self.tool.drag = Some(Drag::Resize { id, orig, ids, handle, origs, start: p });
             }
             Some(Hit::LineEnd { id, end }) => {
                 let orig = st.shape(id).map(|s| xfrm_of(&st.doc, &st.selection, s)).unwrap_or_default();

From 443f503407b58dcc3a08d40d5023a88949caf2b9 Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Fri, 30 Oct 2026 23:16:32 +0000
Subject: [PATCH 20/88] Reject invalid index in transition commands instead of
 using selection

Found while testing crates/engine/src/cmd/transition.rs:47-54 (slide_indices, via usize_param)

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/transition.rs | 40 ++++++++++++++++++++++++-----
 1 file changed, 33 insertions(+), 7 deletions(-)

diff --git a/crates/engine/src/cmd/transition.rs b/crates/engine/src/cmd/transition.rs
index 293b3d32c..6bd339563 100644
--- a/crates/engine/src/cmd/transition.rs
+++ b/crates/engine/src/cmd/transition.rs
@@ -6,7 +6,7 @@ use deckcraft_model::Transition;
 use deckcraft_model::anim::TRANSITIONS;
 use serde_json::{Value, json};
 
-use super::{CommandSpec, NO_ID_SPACE, always, bad, bool_param, cmd, has_slide, ok, str_param, usize_param};
+use super::{CommandSpec, NO_ID_SPACE, always, bad, bool_param, cmd, has_slide, ok, opt_usize_param, str_param};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {
@@ -44,9 +44,9 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
-fn slide_indices(s: &Session, p: &Value) -> Result<Vec<usize>> {
+fn slide_indices(s: &Session, p: &Value, cmd: &str) -> Result<Vec<usize>> {
     let st = s.doc()?;
-    if let Some(i) = usize_param(p, "index") {
+    if let Some(i) = opt_usize_param(p, "index", cmd)? {
         return Ok(vec![i]);
     }
     let v: Vec<usize> = st.selection.slides.iter().filter_map(|id| st.doc.slide_index(*id)).collect();
@@ -59,7 +59,7 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
         TRANSITIONS.iter().find(|t| t.0.eq_ignore_ascii_case(kind)).ok_or_else(|| bad("transition.set", format!("unknown transition `{kind}`")))?;
     let option = str_param(p, "option").map(String::from).or_else(|| info.4.first().map(|o| o.to_string())).unwrap_or_default();
     let duration = p.get("duration").and_then(Value::as_u64).map(|v| v.min(59_000) as u32);
-    let list = slide_indices(s, p)?;
+    let list = slide_indices(s, p, "transition.set")?;
     s.edit(|doc, _| {
         for i in list {
             if let Some(sl) = doc.slides.get_mut(i) {
@@ -83,7 +83,7 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn options(s: &mut Session, p: &Value) -> Result<Value> {
     let option = str_param(p, "option").ok_or_else(|| bad("transition.options", "missing `option`"))?.to_string();
-    let list = slide_indices(s, p)?;
+    let list = slide_indices(s, p, "transition.options")?;
     s.edit(|doc, _| {
         for i in list {
             if let Some(sl) = doc.slides.get_mut(i)
@@ -98,7 +98,7 @@ fn options(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn timing(s: &mut Session, p: &Value) -> Result<Value> {
-    let list = slide_indices(s, p)?;
+    let list = slide_indices(s, p, "transition.timing")?;
     s.edit(|doc, _| {
         for i in list {
             if let Some(sl) = doc.slides.get_mut(i) {
@@ -127,7 +127,7 @@ fn timing(s: &mut Session, p: &Value) -> Result<Value> {
 
 /// Transitions › Sound: embed an audio file as the slides' transition sound, or `none` to remove it.
 fn sound(s: &mut Session, p: &Value) -> Result<Value> {
-    let list = slide_indices(s, p)?;
+    let list = slide_indices(s, p, "transition.sound")?;
     let looping = bool_param(p, "loop");
     let edit_all = |s: &mut Session, f: &dyn Fn(&mut Transition)| {
         s.edit(|doc, _| {
@@ -215,3 +215,29 @@ fn apply_all(s: &mut Session, _p: &Value) -> Result<Value> {
 fn list(_s: &mut Session, _p: &Value) -> Result<Value> {
     Ok(Value::Array(TRANSITIONS.iter().map(|t| json!({"id": t.0, "label": t.1, "category": t.2, "duration": t.3, "options": t.4})).collect()))
 }
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use crate::Session;
+
+    #[test]
+    fn invalid_index_params_are_rejected_not_defaulted_to_selection() {
+        let mut s = Session::with_new();
+        while s.doc().expect("doc").doc.slides.len() < 3 {
+            s.execute("slide.new", &json!({})).expect("new slide");
+        }
+        for bad in [json!(-1), json!(1.5)] {
+            for (cmd, p) in [
+                ("transition.set", json!({"kind": "fade", "index": bad})),
+                ("transition.options", json!({"option": "x", "index": bad})),
+                ("transition.timing", json!({"duration": 500, "index": bad})),
+                ("transition.sound", json!({"none": true, "index": bad})),
+            ] {
+                assert!(s.execute(cmd, &p).is_err(), "{cmd} must reject {p}");
+                assert!(s.doc().expect("doc").doc.slides.iter().all(|sl| sl.transition.is_none()), "{cmd} {p}");
+            }
+        }
+    }
+}

From 09bbfc72176af42ae586795367caec9dd5e8db77 Mon Sep 17 00:00:00 2001
From: DominicTheD3v <119626487+DominicTheD3v@users.noreply.github.com>
Date: Fri, 30 Oct 2026 23:25:01 +0000
Subject: [PATCH 21/88] fix: addressing issues raised by coderabbit

---
 crates/engine/src/tools/drag.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/crates/engine/src/tools/drag.rs b/crates/engine/src/tools/drag.rs
index 367e6b856..24f0ae978 100644
--- a/crates/engine/src/tools/drag.rs
+++ b/crates/engine/src/tools/drag.rs
@@ -27,7 +27,11 @@ impl Session {
                 return self.drag_move(MoveDrag { ids, start, origs, moved, duplicate, enter_text }, p, mods, tol);
             }
             Drag::Resize { id, orig, ids, handle, origs, start } => {
-                let nx = resize_box(&orig, handle, p - start, mods.shift || self.is_picture(id), mods.alt);
+                if orig.w <= 0.0 || orig.h <= 0.0 {
+                    return Ok(Value::Null);
+                }
+                let keep_aspect = mods.shift || self.is_picture(id);
+                let nx = resize_box(&orig, handle, p - start, keep_aspect, mods.alt);
                 let nx = self.snap_resize(nx, handle, &ids, tol);
                 let sx = if orig.w > 1e-9 { (nx.w / orig.w) * if nx.flip_h != orig.flip_h { -1.0 } else { 1.0 } - 1.0 } else { 0.0 };
                 let sy = if orig.h > 1e-9 { (nx.h / orig.h) * if nx.flip_v != orig.flip_v { -1.0 } else { 1.0 } - 1.0 } else { 0.0 };
@@ -51,7 +55,7 @@ impl Session {
                                 hx * sx * o.w / div * if o.flip_h { -1.0 } else { 1.0 },
                                 hy * sy * o.h / div * if o.flip_v { -1.0 } else { 1.0 },
                             );
-                        resize_box(o, handle, Vec2::new(lp.x, lp.y), mods.shift || self.is_picture(*tid), mods.alt)
+                        resize_box(o, handle, Vec2::new(lp.x, lp.y), keep_aspect, mods.alt)
                     };
                     self.set_xfrm(*tid, target_nx)?;
                 }

From 4c1d77ddce19d75d4cea08da4b61260df250ae31 Mon Sep 17 00:00:00 2001
From: "Dylan M. Taylor" <dylan@dylanmtaylor.com>
Date: Fri, 30 Oct 2026 20:12:24 -0400
Subject: [PATCH 22/88] fix(flatpak): allow reading launcher version pins
 (#1575)

* fix(flatpak): allow reading launcher version pins

* fix(flatpak): allow reading launcher version pins
---
 packaging/linux/flatpak/ai.storyteller.deckcraft.bundle.yml | 1 +
 packaging/linux/flatpak/ai.storyteller.deckcraft.yml        | 1 +
 2 files changed, 2 insertions(+)

diff --git a/packaging/linux/flatpak/ai.storyteller.deckcraft.bundle.yml b/packaging/linux/flatpak/ai.storyteller.deckcraft.bundle.yml
index 230c22896..5b54f575f 100644
--- a/packaging/linux/flatpak/ai.storyteller.deckcraft.bundle.yml
+++ b/packaging/linux/flatpak/ai.storyteller.deckcraft.bundle.yml
@@ -17,6 +17,7 @@ runtime-version: '25.08'
 sdk: org.freedesktop.Sdk
 command: deckcraft
 finish-args:
+  - --filesystem=xdg-data/ArtCraft/versions:ro
   # Display: Wayland first; X11 only when no Wayland compositor is running.
   - --socket=wayland
   - --socket=fallback-x11
diff --git a/packaging/linux/flatpak/ai.storyteller.deckcraft.yml b/packaging/linux/flatpak/ai.storyteller.deckcraft.yml
index b99365c28..8c1d1e24f 100644
--- a/packaging/linux/flatpak/ai.storyteller.deckcraft.yml
+++ b/packaging/linux/flatpak/ai.storyteller.deckcraft.yml
@@ -18,6 +18,7 @@ sdk-extensions:
   - org.freedesktop.Sdk.Extension.rust-stable
 command: deckcraft
 finish-args:
+  - --filesystem=xdg-data/ArtCraft/versions:ro
   # Display: Wayland first; X11 only when no Wayland compositor is running.
   - --socket=wayland
   - --socket=fallback-x11

From 77e3a444b816eaea93dc2b608cf46043e243d902 Mon Sep 17 00:00:00 2001
From: DominicTheD3v <119626487+DominicTheD3v@users.noreply.github.com>
Date: Sat, 31 Oct 2026 00:21:06 +0000
Subject: [PATCH 23/88] Update crates/engine/src/tools/drag.rs

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
---
 crates/engine/src/tools/drag.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/engine/src/tools/drag.rs b/crates/engine/src/tools/drag.rs
index 24f0ae978..a25e47858 100644
--- a/crates/engine/src/tools/drag.rs
+++ b/crates/engine/src/tools/drag.rs
@@ -55,7 +55,7 @@ impl Session {
                                 hx * sx * o.w / div * if o.flip_h { -1.0 } else { 1.0 },
                                 hy * sy * o.h / div * if o.flip_v { -1.0 } else { 1.0 },
                             );
-                        resize_box(o, handle, Vec2::new(lp.x, lp.y), keep_aspect, mods.alt)
+                        resize_box(o, handle, Vec2::new(lp.x, lp.y), self.is_picture(*tid), mods.alt)
                     };
                     self.set_xfrm(*tid, target_nx)?;
                 }

From 6113f4e1a29ef787cf07f3b71600e996e447e4c8 Mon Sep 17 00:00:00 2001
From: marshiyar <57055687+marshiyar@users.noreply.github.com>
Date: Fri, 30 Oct 2026 17:57:10 -0700
Subject: [PATCH 24/88] contributors: add names for marshiyar

---
 contributors/people.toml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/contributors/people.toml b/contributors/people.toml
index caf4daa46..f0425452f 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -71,3 +71,8 @@ real_name = "Sofia Alves Figueredo"
 
 [people.dylanmtaylor]
 sync_github_name = true
+
+[people.marshiyar]
+display_name = "Arshiya"
+real_name = "Arshiya Rahgozar"
+sync_github_name = false

From 9aef8cc5ab9d9b2d82198ffb632ea9fc0a8a90be Mon Sep 17 00:00:00 2001
From: DominicTheD3v <119626487+DominicTheD3v@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:03:53 +0000
Subject: [PATCH 25/88] fix: addressing issues raised by coderabbit

---
 crates/engine/src/tools/drag.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/crates/engine/src/tools/drag.rs b/crates/engine/src/tools/drag.rs
index 24f0ae978..d65ae690a 100644
--- a/crates/engine/src/tools/drag.rs
+++ b/crates/engine/src/tools/drag.rs
@@ -27,9 +27,6 @@ impl Session {
                 return self.drag_move(MoveDrag { ids, start, origs, moved, duplicate, enter_text }, p, mods, tol);
             }
             Drag::Resize { id, orig, ids, handle, origs, start } => {
-                if orig.w <= 0.0 || orig.h <= 0.0 {
-                    return Ok(Value::Null);
-                }
                 let keep_aspect = mods.shift || self.is_picture(id);
                 let nx = resize_box(&orig, handle, p - start, keep_aspect, mods.alt);
                 let nx = self.snap_resize(nx, handle, &ids, tol);

From ede7a7ead7fc7fa927ec6c312f3ec811fdb2cfbd Mon Sep 17 00:00:00 2001
From: marshiyar <57055687+marshiyar@users.noreply.github.com>
Date: Fri, 30 Oct 2026 18:19:00 -0700
Subject: [PATCH 26/88] ogg: bound damage recovery work and the warnings list

What was wrong: when a page failed its CRC the demuxer had already read the
whole page (up to about 64 KiB), then moved on by one byte and tried again.
Nothing was charged for it, and only the scan for the next capture pattern had
a budget, which a candidate that matches "OggS" at the current position never
reaches. A file made of capture patterns 64 bytes apart, each claiming a full
page, made a 1 MB file read about 957 MB and compute a CRC over all of it. The
warnings list also grew with every damaged page, without limit.

What changed: the per-file recovery budget (32 MiB, the scan's existing one) is
now also charged with the length of every page read only to find its CRC wrong.
When it is spent the pages found so far are returned with a warning saying the
rest was not searched. At most 256 warnings are kept, plus one saying the rest
were dropped.

How it was tested: two new tests failed before the fix and pass after it, a
counting ByteSource over 1 MB of dense fake pages (bytes read stay within the
budget; before, 957 MB were read) and 100,000 bad-CRC pages (before, 199,999
warnings). A file of good pages is not charged and has no warnings. The other
ogg tests still pass, and clippy is clean with -D warnings.

Completes the Ogg part of storytold/filmcraft#2794
---
 crates/ogg/src/lib.rs   | 56 +++++++++++++++++++++++------
 crates/ogg/src/tests.rs | 80 ++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 124 insertions(+), 12 deletions(-)

diff --git a/crates/ogg/src/lib.rs b/crates/ogg/src/lib.rs
index 69ff1858a..b009f0425 100644
--- a/crates/ogg/src/lib.rs
+++ b/crates/ogg/src/lib.rs
@@ -196,6 +196,21 @@ pub struct OggFile {
     pub warnings: Vec<String>,
 }
 
+/// Source bytes damage recovery may read per file: the windows the scan for the next capture
+/// pattern fills and the pages read only to find their CRC wrong.
+const RECOVERY_BUDGET: u64 = 32 << 20;
+/// Warnings kept per file (not counting the one about the budget); the rest are counted in one last entry.
+const MAX_WARNINGS: usize = 256;
+
+/// Record a warning, keeping at most `MAX_WARNINGS` and one entry saying the rest were dropped.
+fn warn(warnings: &mut Vec<String>, msg: String) {
+    match warnings.len().cmp(&MAX_WARNINGS) {
+        std::cmp::Ordering::Less => warnings.push(msg),
+        std::cmp::Ordering::Equal => warnings.push("further warnings omitted".into()),
+        std::cmp::Ordering::Greater => {}
+    }
+}
+
 struct Partial {
     parts: Vec<(u64, u32)>,
     size: u32,
@@ -219,7 +234,7 @@ pub fn open(src: &(impl ByteSource + ?Sized)) -> Result<OggFile> {
             match scanner.find(src, pos + 1, len)? {
                 Some(p) => {
                     if found_any {
-                        warnings.push(format!("lost sync at byte {pos}; resumed at {p}"));
+                        warn(&mut warnings, format!("lost sync at byte {pos}; resumed at {p}"));
                     }
                     pos = p;
                     continue;
@@ -229,14 +244,14 @@ pub fn open(src: &(impl ByteSource + ?Sized)) -> Result<OggFile> {
         }
         let nseg = hdr[26] as usize;
         if pos + 27 + nseg as u64 > len {
-            warnings.push(format!("truncated page header at byte {pos}"));
+            warn(&mut warnings, format!("truncated page header at byte {pos}"));
             break;
         }
         src.read_at(pos + 27, &mut hdr[27..27 + nseg])?;
         let body_len: u64 = hdr[27..27 + nseg].iter().map(|&b| b as u64).sum();
         let page_len = 27 + nseg as u64 + body_len;
         if pos + page_len > len {
-            warnings.push(format!("truncated page at byte {pos}"));
+            warn(&mut warnings, format!("truncated page at byte {pos}"));
             break;
         }
         let mut page = vec![0u8; page_len as usize];
@@ -244,7 +259,11 @@ pub fn open(src: &(impl ByteSource + ?Sized)) -> Result<OggFile> {
         let stored_crc = u32::from_le_bytes([page[22], page[23], page[24], page[25]]);
         page[22..26].fill(0);
         if crc32(&page) != stored_crc {
-            warnings.push(format!("bad CRC on page at byte {pos}"));
+            warn(&mut warnings, format!("bad CRC on page at byte {pos}"));
+            // a page read only to find it damaged is recovery work, charged like the scan's windows
+            if scanner.charge(page_len) {
+                break;
+            }
             pos += 1;
             continue;
         }
@@ -275,7 +294,7 @@ pub fn open(src: &(impl ByteSource + ?Sized)) -> Result<OggFile> {
         // a continued page without a pending packet (lost a page): drop the fragment
         let continued = flags & 0x01 != 0;
         if !continued && partial.remove(&serial).is_some() {
-            warnings.push(format!("incomplete packet before page at byte {pos}"));
+            warn(&mut warnings, format!("incomplete packet before page at byte {pos}"));
         }
         let mut completed: Vec<Packet> = Vec::new();
         let mut off = 0u64;
@@ -331,8 +350,12 @@ pub fn open(src: &(impl ByteSource + ?Sized)) -> Result<OggFile> {
     if !found_any {
         return Err(Error::NotOgg);
     }
+    if scanner.spent() {
+        // once per file, so it is not subject to the cap on the others
+        warnings.push("recovery budget spent; the rest of the damaged data was not searched".into());
+    }
     if !partial.is_empty() {
-        warnings.push("file ends inside a packet".into());
+        warn(&mut warnings, "file ends inside a packet".into());
     }
     Ok(OggFile { streams, warnings })
 }
@@ -340,12 +363,23 @@ pub fn open(src: &(impl ByteSource + ?Sized)) -> Result<OggFile> {
 struct CaptureScanner {
     buf: Vec<u8>,
     buf_start: u64,
-    budget: usize,
+    budget: u64,
 }
 
 impl CaptureScanner {
     fn new() -> Self {
-        Self { buf: Vec::new(), buf_start: 0, budget: 32 * 1024 * 1024 }
+        Self { buf: Vec::new(), buf_start: 0, budget: RECOVERY_BUDGET }
+    }
+
+    /// Charge `bytes` of recovery work; true once the budget is spent.
+    fn charge(&mut self, bytes: u64) -> bool {
+        self.budget = self.budget.saturating_sub(bytes);
+        self.spent()
+    }
+
+    /// Nothing left to search with: fewer bytes than a capture pattern can still be charged for.
+    fn spent(&self) -> bool {
+        self.budget < 4
     }
 
     fn find(&mut self, src: &(impl ByteSource + ?Sized), from: u64, len: u64) -> Result<Option<u64>> {
@@ -360,17 +394,17 @@ impl CaptureScanner {
                 at = buf_end.saturating_sub(3);
                 continue;
             }
-            if self.budget == 0 {
+            if self.spent() {
                 return Ok(None);
             }
-            let n = ((len - at) as usize).min(64 * 1024).min(self.budget);
+            let n = ((len - at) as usize).min(64 * 1024).min(usize::try_from(self.budget).unwrap_or(usize::MAX));
             if n < 4 {
                 break;
             }
             self.buf.resize(n, 0);
             src.read_at(at, &mut self.buf)?;
             self.buf_start = at;
-            self.budget = self.budget.saturating_sub(n);
+            self.budget = self.budget.saturating_sub(n as u64);
             if let Some(i) = self.buf.windows(4).position(|w| w == b"OggS") {
                 return Ok(Some(at + i as u64));
             }
diff --git a/crates/ogg/src/tests.rs b/crates/ogg/src/tests.rs
index cf2720d88..480c1cda2 100644
--- a/crates/ogg/src/tests.rs
+++ b/crates/ogg/src/tests.rs
@@ -1,6 +1,9 @@
 //! Synthetic Ogg streams: a small page writer (RFC 3533) and Opus-like packets.
 
-use super::{Codec, Error, OpusTiming, Packet, Stream, crc32, open, opus_packet_samples, sniff};
+use std::cell::Cell;
+use std::io;
+
+use super::{ByteSource, CaptureScanner, Codec, Error, OpusTiming, Packet, Stream, crc32, open, opus_packet_samples, sniff};
 
 /// Write one page holding `segments` (lacing already computed by `lace`).
 fn page(out: &mut Vec<u8>, flags: u8, granule: i64, serial: u32, seq: u32, lacing: &[u8], body: &[u8]) {
@@ -196,3 +199,78 @@ fn opus_timing_rejects_a_granule_that_overflows() {
     assert_eq!(ok.total, 480);
     assert!(OpusTiming::of(&packet(i64::MIN), 0).is_err());
 }
+
+/// A source that counts the bytes read from it.
+struct Counting<'a> {
+    data: &'a [u8],
+    read: Cell<u64>,
+}
+
+impl ByteSource for Counting<'_> {
+    fn len(&self) -> u64 {
+        self.data.len() as u64
+    }
+    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
+        self.read.set(self.read.get() + buf.len() as u64);
+        self.data.read_at(offset, buf)
+    }
+}
+
+/// A valid file followed by `len` bytes of 0xFF with a capture pattern every 64 bytes. Each one
+/// claims 255 full lacing values, so it reads as a page of about 64 KiB that fails its CRC.
+fn dense_fake_pages(len: usize) -> Vec<u8> {
+    let mut f = opus_file(6, 312, 0);
+    let start = f.len();
+    f.resize(start + len, 0xFF);
+    for at in (start..start + len - 64).step_by(64) {
+        f[at..at + 5].copy_from_slice(b"OggS\0");
+        f[at + 26] = 255;
+    }
+    f
+}
+
+#[test]
+fn recovery_reads_a_bounded_amount_of_a_damaged_file() {
+    let f = dense_fake_pages(1 << 20);
+    let src = Counting { data: &f, read: Cell::new(0) };
+    let o = open(&src).unwrap();
+    assert_eq!(o.streams[0].packets.len(), 6, "the good pages are kept");
+    let read = src.read.get();
+    assert!(read <= 40 << 20, "read {read} bytes of a {} byte file", f.len());
+    assert!(o.warnings.iter().any(|w| w.contains("recovery budget")), "{:?}", o.warnings);
+}
+
+#[test]
+fn warnings_are_capped() {
+    // 100,000 pages with no segments and a wrong CRC, 27 bytes each
+    let mut f = opus_file(6, 312, 0);
+    for _ in 0..100_000 {
+        let at = f.len();
+        f.extend_from_slice(b"OggS\0\0");
+        f.resize(at + 27, 0);
+        f[at + 22] = 1;
+    }
+    let o = open(&f).unwrap();
+    assert!(o.warnings.len() <= 257, "{} warnings", o.warnings.len());
+    assert!(o.warnings.iter().any(|w| w.contains("omitted")), "{:?}", o.warnings.last());
+}
+
+#[test]
+fn a_file_of_good_pages_is_not_charged_for_recovery() {
+    let f = opus_file(2000, 312, 0);
+    let src = Counting { data: &f, read: Cell::new(0) };
+    let o = open(&src).unwrap();
+    assert_eq!(o.streams[0].packets.len(), 2000);
+    assert!(o.warnings.is_empty(), "{:?}", o.warnings);
+}
+
+#[test]
+fn a_budget_too_small_to_search_is_spent() {
+    // 1 to 3 bytes left cannot hold a capture pattern: the scan would stop without saying why
+    let mut scanner = CaptureScanner::new();
+    assert!(!scanner.spent());
+    assert!(scanner.charge(super::RECOVERY_BUDGET - 3));
+    assert!(scanner.spent());
+    let f = opus_file(6, 312, 0);
+    assert_eq!(scanner.find(&f, 0, f.len() as u64).unwrap(), None);
+}

From eaeb06c65581fb6f824112b641a9d8b35c3ea162 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <brandon@storyteller.ai>
Date: Fri, 30 Oct 2026 22:59:19 -0400
Subject: [PATCH 27/88] Release 0.13.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 56 +++++++++++++++++++++++++++---------------------------
 Cargo.toml |  2 +-
 2 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a6ef452e9..a30b0c9d4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -984,7 +984,7 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
 [[package]]
 name = "deckcraft"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "arboard",
  "chrono",
@@ -1006,7 +1006,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-anim"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-geom",
  "deckcraft-model",
@@ -1015,7 +1015,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-av1"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1024,14 +1024,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-bitstream"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-cli"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-mcp",
@@ -1041,14 +1041,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-color"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "deckcraft-engine"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "chrono",
  "deckcraft-anim",
@@ -1074,7 +1074,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-fonts"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "epaint_default_fonts",
  "harfrust 0.13.3",
@@ -1086,7 +1086,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-format"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-model",
  "serde",
@@ -1097,7 +1097,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-geom"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "kurbo",
  "serde",
@@ -1105,7 +1105,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-h264"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1114,7 +1114,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-hevc"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1123,21 +1123,21 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-isobmff"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-matroska"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-mcp"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-render",
@@ -1147,7 +1147,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-media"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-av1",
  "deckcraft-h264",
@@ -1165,7 +1165,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-metafile"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "image",
  "kurbo",
@@ -1174,7 +1174,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-model"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-color",
  "deckcraft-geom",
@@ -1186,15 +1186,15 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-ogg"
-version = "0.12.0"
+version = "0.13.0"
 
 [[package]]
 name = "deckcraft-opus"
-version = "0.12.0"
+version = "0.13.0"
 
 [[package]]
 name = "deckcraft-pdf"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "craft-pdf",
  "deckcraft-fonts",
@@ -1212,7 +1212,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-pptx"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-color",
  "deckcraft-engine",
@@ -1228,7 +1228,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-render"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-anim",
  "deckcraft-color",
@@ -1247,7 +1247,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-text"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "chrono",
  "deckcraft-color",
@@ -1261,7 +1261,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-ui-egui"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "craft-ui",
  "craft-update",
@@ -1286,7 +1286,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-vp9"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1295,7 +1295,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-web"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-ui-egui",
@@ -6177,7 +6177,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
 
 [[package]]
 name = "xtask"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "serde_json",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 3eada7087..79d9f5356 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]
 
 [workspace.package]
-version = "0.12.0"
+version = "0.13.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"

From e83f964077ad650006a5596c28462e6aa2d01d6a Mon Sep 17 00:00:00 2001
From: marshiyar <57055687+marshiyar@users.noreply.github.com>
Date: Fri, 30 Oct 2026 20:13:00 -0700
Subject: [PATCH 28/88] mcp: insert_chart takes x, y, w and h

What was wrong: the insert_chart tool had no x, y, w or h in its schema, so the
server refused them as unknown arguments, while insert_picture and insert_table
take them. A chart could only be placed at the default box, [144, 81, 672, 378]
on a 960x540 slide, and then had to be moved with a second command.

What changed: insert_chart declares x, y, w and h and folds them into the
engine's `rect` when all four are given, as insert_picture and insert_table do.
Without all four the chart keeps its default place.

How it was tested: insert_chart_takes_a_box failed before the change (the
arguments were refused) and passes after it. It checks the box of the placed
chart, that a partial box leaves the default place, and that an extreme box is
answered without a panic. The rest of the deckcraft-mcp tests pass, and clippy
is clean with -D warnings.

Fixes #1151
---
 crates/mcp/src/tests.rs | 34 ++++++++++++++++++++++++++++++++++
 crates/mcp/src/tools.rs | 12 +++++++++---
 docs/mcp.md             |  2 +-
 3 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rs
index bfffa83d0..665591872 100644
--- a/crates/mcp/src/tests.rs
+++ b/crates/mcp/src/tests.rs
@@ -62,6 +62,40 @@ fn handshake_and_tool_list() {
     assert!(s.handle_line("{}").is_some());
 }
 
+/// #1151: `insert_chart` takes x, y, w and h like `insert_picture` and `insert_table`.
+#[test]
+fn insert_chart_takes_a_box() {
+    let mut s = Server::new(Box::new(Headless::new()));
+    tool(&mut s, "new_presentation", json!({"theme": "Harbor"}));
+    let chart = json!({"type": "pie", "categories": ["A", "B"], "series": [{"name": "S", "values": [3, 5]}]});
+    let box_of = |s: &mut Server, id: u64| {
+        let sl = tool(s, "inspect_slide", json!({}));
+        let shape = sl["shapes"].as_array().unwrap().iter().find(|x| x["id"].as_u64() == Some(id)).unwrap().clone();
+        assert_eq!(shape["kind"], "chart");
+        shape["box"].clone()
+    };
+    let mut args = chart.clone();
+    for (k, v) in [("x", 50), ("y", 60), ("w", 300), ("h", 200)] {
+        args[k] = json!(v);
+    }
+    let placed = tool(&mut s, "insert_chart", args)["id"].as_u64().unwrap();
+    assert_eq!(box_of(&mut s, placed), json!([50.0, 60.0, 300.0, 200.0]));
+    // without a full box the chart keeps its default place, as for pictures and tables
+    let plain = tool(&mut s, "insert_chart", chart.clone())["id"].as_u64().unwrap();
+    let default_box = box_of(&mut s, plain);
+    let mut partial = chart.clone();
+    partial["x"] = json!(50);
+    let partial_id = tool(&mut s, "insert_chart", partial)["id"].as_u64().unwrap();
+    assert_eq!(box_of(&mut s, partial_id), default_box);
+    // a hostile box is answered, not a panic
+    let mut odd = chart;
+    for (k, v) in [("x", json!(-1e300)), ("y", json!(1e300)), ("w", json!(-5)), ("h", json!(0))] {
+        odd[k] = v;
+    }
+    let r = call(&mut s, 11, "tools/call", json!({"name": "insert_chart", "arguments": odd}));
+    assert!(r["result"].is_object(), "{r}");
+}
+
 #[test]
 fn agent_builds_a_deck() {
     let mut s = Server::new(Box::new(Headless::new()));
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index c4f7e85da..2bf09b8a9 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -234,9 +234,9 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "insert_chart",
             "Insert chart",
-            "Insert a chart (column, bar, line, pie, doughnut, area, scatter, stackedColumn…) with categories and series.",
+            "Insert a chart (column, bar, line, pie, doughnut, area, scatter, stackedColumn…) with categories and series, optionally at a box.",
             obj(
-                json!({"type": string("Chart type"), "title": string("Chart title"), "categories": {"type": "array", "items": {"type": "string"}}, "series": {"type": "array", "items": obj(json!({"name": string("Series name"), "values": {"type": "array", "items": {"type": "number"}}}), &["values"])}}),
+                json!({"type": string("Chart type"), "title": string("Chart title"), "categories": {"type": "array", "items": {"type": "string"}}, "series": {"type": "array", "items": obj(json!({"name": string("Series name"), "values": {"type": "array", "items": {"type": "number"}}}), &["values"])}, "x": num("Left"), "y": num("Top"), "w": num("Width"), "h": num("Height")}),
                 &[],
             ),
             false,
@@ -444,7 +444,13 @@ pub fn call_tool(b: &mut dyn Backend, name: &str, a: &Value) -> ToolResult {
             }
             wrap(exec(b, "insert.table", p))
         }
-        "insert_chart" => wrap(exec(b, "insert.chart", a)),
+        "insert_chart" => {
+            let mut p = a.clone();
+            if let (Some(x), Some(y), Some(w), Some(h)) = (f(&a, "x"), f(&a, "y"), f(&a, "w"), f(&a, "h")) {
+                p["rect"] = json!([x, y, w, h]);
+            }
+            wrap(exec(b, "insert.chart", p))
+        }
         "select" => wrap(exec(b, "edit.select", a)),
         "pointer" => wrap(b.call("ui.pointer", a)),
         "select_tool" => wrap(b.call("ui.tool.select", a)),
diff --git a/docs/mcp.md b/docs/mcp.md
index f936af660..7da2ffb3b 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -96,7 +96,7 @@ files it was given rather than guarding against other software on the computer.
 | `screenshot` | The whole window, UI included (connected mode) |
 | `call_app` | Any [control protocol](control-protocol.md) method (connected mode) |
 
-A tool refuses an argument that is not in its schema (`insert_chart: unknown argument "data" (expected: categories, series, title, type)`). Keys inside `run_command`'s `params` are that command's parameters.
+A tool refuses an argument that is not in its schema (`insert_chart: unknown argument "data" (expected: categories, h, series, title, type, w, x, y)`). Keys inside `run_command`'s `params` are that command's parameters.
 
 Useful commands for building decks: `slide.new {layout, title, body}`, `shape.insert {preset,
 rect, text}`, `shape.connect {from, to, preset}`, `shape.freeform {points, closed, smooth}`,

From b7482dd392aeedae8ff51543668aefb8340066b9 Mon Sep 17 00:00:00 2001
From: marshiyar <57055687+marshiyar@users.noreply.github.com>
Date: Fri, 30 Oct 2026 20:13:05 -0700
Subject: [PATCH 29/88] engine: animation.add and animation.set take the points
 of a custom motion path

What was wrong: animation.add ignored a `path` parameter, so a customPath
animation always got the default straight path of a quarter of the slide
height, and no command could set or change the points of one.

What changed: animation.add, animation.set and animation.options accept `path`
for a motion path: either points [[x, y], ...] in slide points, as offsets from
where the shape sits (converted to the stored slide-fraction path; `closed`
returns to the first point), or the OOXML path string animation.get answers.
At most 1000 points, finite numbers within 1e6 points, and strings of at most
16 KiB made of path commands and numbers are accepted; anything else is
refused before the deck changes, as is `path` on an animation that is not a
motion path. animation.add answers the stored path.

How it was tested: three new tests in cmd/animation.rs: points become the
expected path (add, set with `closed`, back to the default without `path`), a
raw string is kept and animation.options replaces it, and malformed paths are
refused with nothing added. The animation tests pass, and clippy is clean with
-D warnings.

Fixes #1576
---
 crates/engine/src/cmd/animation.rs | 158 +++++++++++++++++++++++++++--
 1 file changed, 149 insertions(+), 9 deletions(-)

diff --git a/crates/engine/src/cmd/animation.rs b/crates/engine/src/cmd/animation.rs
index b5d00bba1..e69d97b67 100644
--- a/crates/engine/src/cmd/animation.rs
+++ b/crates/engine/src/cmd/animation.rs
@@ -17,7 +17,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Animation Styles",
             ["Animations", "Animation"],
             None,
-            "{effect: fade|fly|zoom|wipe|appear|spin|pulse|fadeOut|lines|… (animation.list), class?: entrance|emphasis|exit|path, option?, ids?} — replaces the shapes' animations",
+            "{effect: fade|fly|zoom|wipe|appear|spin|pulse|fadeOut|lines|… (animation.list), class?: entrance|emphasis|exit|path, option?, path?: [[x,y],…] or OOXML string, closed?: bool, ids?} — replaces the shapes' animations. path (motion paths): points in slide points, as offsets from where the shape sits, or the OOXML path string (slide fractions) animation.get answers",
             has_selection,
             set
         ),
@@ -26,7 +26,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Add Animation",
             ["Animations", "Advanced Animation"],
             None,
-            "{effect, class?, option?, start?: onClick|withPrevious|afterPrevious, duration?: ms, delay?: ms, ids?}",
+            "{effect, class?, option?, path?: [[x,y],…] or OOXML string, closed?: bool, start?: onClick|withPrevious|afterPrevious, duration?: ms, delay?: ms, ids?} → {count, path?}",
             has_selection,
             add
         ),
@@ -46,7 +46,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Effect Options",
             ["Animations", "Animation"],
             None,
-            "{option?, textBuild?: asOne|byParagraph|byWord|byLetter, index?}",
+            "{option?, textBuild?: asOne|byParagraph|byWord|byLetter, path?: [[x,y],…] or OOXML string, closed?: bool, index?}",
             has_slide,
             options
         ),
@@ -129,7 +129,7 @@ fn resolve_option(allowed: &[&str], given: &str) -> Option<String> {
     cands.into_iter().find(|c| allowed.contains(&c.as_str()))
 }
 
-fn build(p: &Value) -> Result<Animation> {
+fn build(p: &Value, slide: (f64, f64)) -> Result<Animation> {
     let effect = str_param(p, "effect").ok_or_else(|| bad("animation", "missing `effect`"))?;
     let class = class_of(str_param(p, "class"));
     let info = match class {
@@ -155,7 +155,9 @@ fn build(p: &Value) -> Result<Animation> {
         a.start = start_of(st);
     }
     if a.class == AnimClass::Path {
-        a.path = Some(default_path(&a.effect, &a.option));
+        a.path = Some(path_param(p, slide)?.unwrap_or_else(|| default_path(&a.effect, &a.option)));
+    } else if p.get("path").is_some() {
+        return Err(bad("animation", "`path` only fits a motion path (class `path`)"));
     }
     if a.effect == "spin" {
         a.amount = Some(360.0);
@@ -166,6 +168,60 @@ fn build(p: &Value) -> Result<Animation> {
     Ok(a)
 }
 
+/// Most points of a motion path given as an array, and longest path string given as text.
+const MAX_PATH_POINTS: usize = 1_000;
+const MAX_PATH_TEXT: usize = 16 * 1024;
+/// Largest offset of a point, in slide points; anything beyond is not a place on any slide.
+const MAX_PATH_OFFSET: f64 = 1.0e6;
+
+/// A number of a path string: slide fractions, rounded to 6 places.
+fn path_num(v: f64) -> String {
+    let t = format!("{:.6}", v);
+    let t = t.trim_end_matches('0').trim_end_matches('.');
+    if t == "-0" || t.is_empty() { "0".into() } else { t.into() }
+}
+
+/// The motion path `path` asks for, as the OOXML path string animations store: either points
+/// (`[[x, y], …]`, slide points as offsets from where the shape sits, joined by lines, `closed?`
+/// to return to the first) or that string itself.
+fn path_param(p: &Value, slide: (f64, f64)) -> Result<Option<String>> {
+    let Some(v) = p.get("path") else { return Ok(None) };
+    let refuse = |why: &str| bad("animation", format!("`path` {why}"));
+    match v {
+        Value::String(text) => {
+            let ok = text.len() <= MAX_PATH_TEXT
+                && text.contains(|c: char| c.is_ascii_digit())
+                && text.chars().all(|c| c.is_ascii_digit() || " .+-eE,MmLlCcQqHhVvZz".contains(c));
+            if !ok {
+                return Err(refuse("string must be an OOXML motion path such as `M 0 0 L 0.25 0 E` (at most 16 KiB)"));
+            }
+            Ok(Some(text.clone()))
+        }
+        Value::Array(points) => {
+            if !(2..=MAX_PATH_POINTS).contains(&points.len()) {
+                return Err(refuse(&format!("needs 2 to {MAX_PATH_POINTS} points")));
+            }
+            if !(slide.0.is_finite() && slide.1.is_finite() && slide.0 > 0.0 && slide.1 > 0.0) {
+                return Err(refuse("can't be placed: the slide has no size"));
+            }
+            let mut out = String::new();
+            for (k, pt) in points.iter().enumerate() {
+                let xy = pt.as_array().filter(|a| a.len() == 2).and_then(|a| Some((a.first()?.as_f64()?, a.get(1)?.as_f64()?)));
+                let Some((x, y)) = xy.filter(|(x, y)| x.abs() <= MAX_PATH_OFFSET && y.abs() <= MAX_PATH_OFFSET) else {
+                    return Err(refuse(&format!("point {k} must be [x, y], two finite numbers within ±{MAX_PATH_OFFSET} points")));
+                };
+                out.push_str(&format!("{} {} {} ", if k == 0 { "M" } else { "L" }, path_num(x / slide.0), path_num(y / slide.1)));
+            }
+            if p.get("closed").and_then(Value::as_bool) == Some(true) {
+                out.push_str("Z ");
+            }
+            out.push('E');
+            Ok(Some(out))
+        }
+        _ => Err(refuse("must be [[x, y], …] or an OOXML path string")),
+    }
+}
+
 /// Default motion paths, in slide-fraction units relative to the shape's position.
 pub fn default_path(effect: &str, option: &str) -> String {
     let (dx, dy) = match option {
@@ -185,7 +241,7 @@ pub fn default_path(effect: &str, option: &str) -> String {
 
 fn set(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = targets(s, p)?;
-    let a = build(p)?;
+    let a = build(p, slide_extent(s)?)?;
     s.edit(|doc, sel| {
         let sl = doc.slides.get_mut(sel.slide).ok_or_else(|| bad("animation.set", "no slide"))?;
         let sl = Arc::make_mut(sl);
@@ -215,9 +271,16 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
     })
 }
 
+/// The slide's width and height in points.
+fn slide_extent(s: &mut Session) -> Result<(f64, f64)> {
+    let size = &s.doc()?.doc.slide_size;
+    Ok((size.width, size.height))
+}
+
 fn add(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = targets(s, p)?;
-    let a = build(p)?;
+    let a = build(p, slide_extent(s)?)?;
+    let path = a.path.clone();
     s.edit(|doc, sel| {
         let sl = Arc::make_mut(doc.slides.get_mut(sel.slide).ok_or_else(|| bad("animation.add", "no slide"))?);
         for (k, id) in ids.iter().enumerate() {
@@ -227,7 +290,10 @@ fn add(s: &mut Session, p: &Value) -> Result<Value> {
             }
             sl.animations.push(x);
         }
-        Ok(json!({"count": sl.animations.len()}))
+        Ok(match &path {
+            Some(path) => json!({"count": sl.animations.len(), "path": path}),
+            None => json!({"count": sl.animations.len()}),
+        })
     })
 }
 
@@ -320,13 +386,17 @@ fn options(s: &mut Session, p: &Value) -> Result<Value> {
         "byLetter" => TextBuild::ByLetter,
         _ => TextBuild::AsOne,
     });
+    let path = path_param(p, slide_extent(s)?)?;
     each_target(s, p, |a| {
+        if let (Some(path), AnimClass::Path) = (&path, a.class) {
+            a.path = Some(path.clone());
+        }
         if let Some(o) = &option {
             // Each target takes the option in its own effect's terms; one it has no such
             // option for keeps its own.
             let allowed = animation_info(&a.effect, a.class).map(|i| i.5).unwrap_or(&[]);
             if let Some(o) = resolve_option(allowed, o) {
-                if a.class == AnimClass::Path {
+                if a.class == AnimClass::Path && path.is_none() {
                     a.path = Some(default_path(&a.effect, &o));
                 }
                 a.option = o;
@@ -606,4 +676,74 @@ mod tests {
             assert_eq!(s.execute("animation.get", &json!({})).unwrap().as_array().unwrap().len(), 1);
         }
     }
+
+    fn path_of(s: &mut Session) -> Option<String> {
+        let all = s.execute("animation.get", &json!({})).unwrap();
+        all.as_array().unwrap().last().and_then(|a| a.get("path")).and_then(Value::as_str).map(String::from)
+    }
+
+    fn shape(s: &mut Session) -> u64 {
+        s.execute("shape.insert", &json!({"preset": "ellipse", "rect": [100.0, 400.0, 20.0, 20.0]})).unwrap().get("id").unwrap().as_u64().unwrap()
+    }
+
+    /// #1576: points in slide points, as offsets from the shape, become the slide-fraction path.
+    #[test]
+    fn a_custom_path_takes_its_points() {
+        let mut s = Session::with_new();
+        let id = shape(&mut s);
+        let w = s.doc().unwrap().doc.slide_size.width;
+        let h = s.doc().unwrap().doc.slide_size.height;
+        let r = s
+            .execute(
+                "animation.add",
+                &json!({"effect": "customPath", "class": "path", "path": [[0, 0], [w / 2.0, -h / 4.0], [w, -h / 2.0]], "ids": [id]}),
+            )
+            .unwrap();
+        assert_eq!(r["path"], "M 0 0 L 0.5 -0.25 L 1 -0.5 E");
+        assert_eq!(path_of(&mut s).as_deref(), Some("M 0 0 L 0.5 -0.25 L 1 -0.5 E"));
+        // closed shapes end back at the start; set replaces; no path keeps the default
+        s.execute("animation.set", &json!({"effect": "customPath", "path": [[0, 0], [w / 4.0, 0], [w / 4.0, h / 4.0]], "closed": true, "ids": [id]}))
+            .unwrap();
+        assert_eq!(path_of(&mut s).as_deref(), Some("M 0 0 L 0.25 0 L 0.25 0.25 Z E"));
+        s.execute("animation.set", &json!({"effect": "customPath", "ids": [id]})).unwrap();
+        assert_eq!(path_of(&mut s).as_deref(), Some("M 0 0 L 0 0.25 E"));
+    }
+
+    #[test]
+    fn a_raw_path_string_is_kept_and_options_edits_it() {
+        let mut s = Session::with_new();
+        let id = shape(&mut s);
+        s.execute("animation.add", &json!({"effect": "customPath", "path": "M 0 0 C 0.1 0 0.2 0.1 0.3 0.1 E", "ids": [id]})).unwrap();
+        assert_eq!(path_of(&mut s).as_deref(), Some("M 0 0 C 0.1 0 0.2 0.1 0.3 0.1 E"));
+        s.execute("animation.options", &json!({"index": 0, "path": [[0, 0], [96, 54]]})).unwrap();
+        assert_eq!(path_of(&mut s).as_deref(), Some("M 0 0 L 0.1 0.1 E"));
+    }
+
+    #[test]
+    fn a_bad_path_is_refused_and_changes_nothing() {
+        let mut s = Session::with_new();
+        let id = shape(&mut s);
+        let many: Vec<Value> = (0..2_000).map(|i| json!([i, i])).collect();
+        for bad_path in [
+            json!([[0, 0]]),
+            json!([]),
+            json!([[0, 0], [1]]),
+            json!([[0, 0], ["a", 1]]),
+            json!([[0, 0], [1e300, 1]]),
+            json!([[0, 0], [null, 1]]),
+            json!("M 0 0 L <script> E"),
+            json!("not a path"),
+            json!(5),
+            Value::Array(many),
+            Value::String("M 0 0 L 0.1 0.1 ".repeat(10_000)),
+        ] {
+            let r = s.execute("animation.add", &json!({"effect": "customPath", "path": bad_path, "ids": [id]}));
+            assert!(r.is_err(), "{bad_path:.60}");
+        }
+        assert!(
+            s.execute("animation.add", &json!({"effect": "fade", "path": [[0, 0], [1, 1]], "ids": [id]})).is_err(),
+            "path only fits a motion path"
+        );
+        assert!(s.execute("animation.get", &json!({})).unwrap().as_array().unwrap().is_empty(), "a refused add left an animation behind");
+    }
 }

From 255df314da653d7a9547b16348cd833a49893ead Mon Sep 17 00:00:00 2001
From: Brandon Thomas <brandon@storyteller.ai>
Date: Fri, 30 Oct 2026 23:21:55 -0400
Subject: [PATCH 30/88] FreeBSD packaging: compare ELF header bytes without
 od's column padding

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 packaging/freebsd/package.sh | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/packaging/freebsd/package.sh b/packaging/freebsd/package.sh
index deffe19e4..11859cabc 100755
--- a/packaging/freebsd/package.sh
+++ b/packaging/freebsd/package.sh
@@ -45,14 +45,17 @@ fi
 # Refuse placeholder, wrong-arch or non-FreeBSD binaries (also with --skip-build). Bytes: ELF magic,
 # 64-bit little-endian, OSABI SYSV or FreeBSD, e_machine.
 case "$ARCH" in
-  x86_64) MACHINE=" 3e 00" ;;
-  aarch64) MACHINE=" b7 00" ;;
+  x86_64) MACHINE=3e00 ;;
+  aarch64) MACHINE=b700 ;;
   *) echo "error: no ELF machine check for arch '$ARCH'" >&2; exit 1 ;;
 esac
+# FreeBSD's od pads its columns differently from GNU od, so compare the hex digits alone.
+hex() { od -An -tx1 "$@" | tr -d ' \n'; }
 for f in "$BIN/deckcraft" "$BIN/deckcraft-cli"; do
-  [[ "$(od -An -tx1 -N6 "$f" 2>/dev/null)" == " 7f 45 4c 46 02 01" ]] || { echo "error: $f is not a 64-bit little-endian ELF" >&2; exit 1; }
-  [[ "$(od -An -tx1 -j7 -N1 "$f")" =~ ^\ (00|09)$ ]] || { echo "error: $f is not a FreeBSD ELF (OSABI)" >&2; exit 1; }
-  [[ "$(od -An -tx1 -j18 -N2 "$f")" == "$MACHINE" ]] || { echo "error: $f is not an ELF for $ARCH" >&2; exit 1; }
+  [[ -f "$f" ]] || { echo "error: $f was not built" >&2; exit 1; }
+  [[ "$(hex -N6 "$f")" == 7f454c460201 ]] || { echo "error: $f is not a 64-bit little-endian ELF (starts $(hex -N6 "$f"))" >&2; exit 1; }
+  [[ "$(hex -j7 -N1 "$f")" =~ ^(00|09)$ ]] || { echo "error: $f is not a FreeBSD ELF (OSABI $(hex -j7 -N1 "$f"))" >&2; exit 1; }
+  [[ "$(hex -j18 -N2 "$f")" == "$MACHINE" ]] || { echo "error: $f is not an ELF for $ARCH (e_machine $(hex -j18 -N2 "$f"))" >&2; exit 1; }
 done
 
 NAME="deckcraft-$VERSION-freebsd-$ARCH"

From 4ce2944630b04188dee8504c14151994d06c416a Mon Sep 17 00:00:00 2001
From: Brandon Thomas <brandon@storyteller.ai>
Date: Fri, 30 Oct 2026 23:21:58 -0400
Subject: [PATCH 31/88] Release 0.13.1

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 56 +++++++++++++++++++++++++++---------------------------
 Cargo.toml |  2 +-
 2 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a30b0c9d4..af7160133 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -984,7 +984,7 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
 [[package]]
 name = "deckcraft"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "arboard",
  "chrono",
@@ -1006,7 +1006,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-anim"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-geom",
  "deckcraft-model",
@@ -1015,7 +1015,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-av1"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1024,14 +1024,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-bitstream"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-cli"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-mcp",
@@ -1041,14 +1041,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-color"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "deckcraft-engine"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "chrono",
  "deckcraft-anim",
@@ -1074,7 +1074,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-fonts"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "epaint_default_fonts",
  "harfrust 0.13.3",
@@ -1086,7 +1086,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-format"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-model",
  "serde",
@@ -1097,7 +1097,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-geom"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "kurbo",
  "serde",
@@ -1105,7 +1105,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-h264"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1114,7 +1114,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-hevc"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1123,21 +1123,21 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-isobmff"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-matroska"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-mcp"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-render",
@@ -1147,7 +1147,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-media"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-av1",
  "deckcraft-h264",
@@ -1165,7 +1165,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-metafile"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "image",
  "kurbo",
@@ -1174,7 +1174,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-model"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-color",
  "deckcraft-geom",
@@ -1186,15 +1186,15 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-ogg"
-version = "0.13.0"
+version = "0.13.1"
 
 [[package]]
 name = "deckcraft-opus"
-version = "0.13.0"
+version = "0.13.1"
 
 [[package]]
 name = "deckcraft-pdf"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "craft-pdf",
  "deckcraft-fonts",
@@ -1212,7 +1212,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-pptx"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-color",
  "deckcraft-engine",
@@ -1228,7 +1228,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-render"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-anim",
  "deckcraft-color",
@@ -1247,7 +1247,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-text"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "chrono",
  "deckcraft-color",
@@ -1261,7 +1261,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-ui-egui"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "craft-ui",
  "craft-update",
@@ -1286,7 +1286,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-vp9"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1295,7 +1295,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-web"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-ui-egui",
@@ -6177,7 +6177,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
 
 [[package]]
 name = "xtask"
-version = "0.13.0"
+version = "0.13.1"
 dependencies = [
  "serde_json",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 79d9f5356..0e0172b6f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]
 
 [workspace.package]
-version = "0.13.0"
+version = "0.13.1"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"

From 479c3cc5eadae1b3baf2e572e3d8dc52a2aa201e Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 22:24:08 -0500
Subject: [PATCH 32/88] Preserve explicit miter limits in PPTX

---
 crates/model/src/style.rs         |  2 ++
 crates/pptx/src/read/dml.rs       |  5 ++++-
 crates/pptx/src/write/dml.rs      |  2 +-
 crates/pptx/tests/it/roundtrip.rs | 14 ++++++++++++++
 4 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/crates/model/src/style.rs b/crates/model/src/style.rs
index 83c494bdf..e3369f358 100644
--- a/crates/model/src/style.rs
+++ b/crates/model/src/style.rs
@@ -324,6 +324,7 @@ pub struct Line {
     pub dash: Option<Dash>,
     pub cap: Option<LineCap>,
     pub join: Option<LineJoin>,
+    pub miter_limit: Option<u32>,
     pub compound: Option<Compound>,
     pub head: Option<LineEnd>,
     pub tail: Option<LineEnd>,
@@ -347,6 +348,7 @@ impl Line {
         }
         self.cap = self.cap.or(parent.cap);
         self.join = self.join.or(parent.join);
+        self.miter_limit = self.miter_limit.or(parent.miter_limit);
         self.compound = self.compound.or(parent.compound);
         if self.head.is_none() {
             self.head.clone_from(&parent.head);
diff --git a/crates/pptx/src/read/dml.rs b/crates/pptx/src/read/dml.rs
index 767b7dc02..e1e5dcd47 100644
--- a/crates/pptx/src/read/dml.rs
+++ b/crates/pptx/src/read/dml.rs
@@ -232,7 +232,10 @@ pub fn line(imp: &mut Imp, part: &Part, ln: &El) -> Line {
             }
             "round" => l.join = Some(LineJoin::Round),
             "bevel" => l.join = Some(LineJoin::Bevel),
-            "miter" => l.join = Some(LineJoin::Miter),
+            "miter" => {
+                l.join = Some(LineJoin::Miter);
+                l.miter_limit = e.attr("lim").and_then(|v| v.parse::<u32>().ok()).filter(|v| *v <= 1_000_000);
+            }
             "headEnd" => l.head = line_end(e),
             "tailEnd" => l.tail = line_end(e),
             _ => {}
diff --git a/crates/pptx/src/write/dml.rs b/crates/pptx/src/write/dml.rs
index 518f8c4af..a6d00ff49 100644
--- a/crates/pptx/src/write/dml.rs
+++ b/crates/pptx/src/write/dml.rs
@@ -233,7 +233,7 @@ pub fn line(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, l: &Line) {
     match l.join {
         Some(LineJoin::Round) => w.empty0("a:round"),
         Some(LineJoin::Bevel) => w.empty0("a:bevel"),
-        Some(LineJoin::Miter) => w.empty0("a:miter"),
+        Some(LineJoin::Miter) => w.empty("a:miter", A::new().o("lim", l.miter_limit)),
         None => {}
     }
     for (t, e) in [("a:headEnd", &l.head), ("a:tailEnd", &l.tail)] {
diff --git a/crates/pptx/tests/it/roundtrip.rs b/crates/pptx/tests/it/roundtrip.rs
index 370cc9a9f..599040718 100644
--- a/crates/pptx/tests/it/roundtrip.rs
+++ b/crates/pptx/tests/it/roundtrip.rs
@@ -488,6 +488,20 @@ fn shapes_fills_lines_effects_round_trip() {
     assert_eq!(by_name(&q.slides[1], "Group").id, by_name(&p.slides[1], "Group").id);
 }
 
+#[test]
+fn line_miter_limit_survives_two_pptx_round_trips() {
+    let mut p = Presentation::default();
+    let mut limited = shape(&mut p, "Limited miter", 20.0, 20.0, 100.0, 100.0);
+    limited.line = Some(Line { join: Some(deckcraft_model::style::LineJoin::Miter), miter_limit: Some(200_000), ..Default::default() });
+    let mut defaulted = shape(&mut p, "Default miter", 140.0, 20.0, 100.0, 100.0);
+    defaulted.line = Some(Line { join: Some(deckcraft_model::style::LineJoin::Miter), ..Default::default() });
+    Arc::make_mut(&mut p.slides[0]).shapes.extend([limited, defaulted]);
+
+    let q = round(&round(&p));
+    assert_eq!(by_name(&q.slides[0], "Limited miter").line.as_ref().and_then(|line| line.miter_limit), Some(200_000));
+    assert_eq!(by_name(&q.slides[0], "Default miter").line.as_ref().and_then(|line| line.miter_limit), None);
+}
+
 #[test]
 fn pictures_media_and_ink_round_trip() {
     let p = rich_deck();

From 9a716be59ead4c42482504e1b2d9904868c38f8c Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Sat, 31 Oct 2026 04:41:09 +0100
Subject: [PATCH 33/88] Reject invalid colour in format.highlight instead of
 clearing it

Found while testing crates/engine/src/cmd/format/font.rs:228-231 (highlight), color_param at crates/engine/src/cmd.rs:381

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/format/font.rs |  3 +++
 crates/engine/src/tests.rs           | 20 ++++++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/crates/engine/src/cmd/format/font.rs b/crates/engine/src/cmd/format/font.rs
index 11af99b7e..6a1cc6b1c 100644
--- a/crates/engine/src/cmd/format/font.rs
+++ b/crates/engine/src/cmd/format/font.rs
@@ -227,6 +227,9 @@ pub(super) fn language_all(s: &mut Session, p: &Value) -> Result<Value> {
 
 pub(super) fn highlight(s: &mut Session, p: &Value) -> Result<Value> {
     let c = color_param(p, "color");
+    if c.is_none() && p.get("color").is_some_and(|v| !v.is_null()) {
+        return Err(bad("format.highlight", "`color` is not a valid colour"));
+    }
     format_run(s, &move |r| r.highlight = c.clone())
 }
 
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 85cbe9d8c..9b43c83d6 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -5956,3 +5956,23 @@ fn invalid_slide_index_never_falls_back_to_the_selection_in_export_commands() {
     }
     let _ = std::fs::remove_dir_all(&dir);
 }
+
+#[test]
+fn highlight_with_an_invalid_colour_is_rejected_and_keeps_the_highlight() {
+    let mut s = session();
+    let title = s.doc().unwrap().current_slide().unwrap().shapes[0].id.0;
+    s.execute("text.edit", &json!({"id": title})).unwrap();
+    s.execute("text.insert", &json!({"text": "ARCH"})).unwrap();
+    s.execute("text.selectAll", &json!({})).unwrap();
+    s.execute("format.highlight", &json!({"color": "yellow"})).unwrap();
+    let has_highlight = |s: &mut Session| {
+        let t = s.doc().unwrap().shape(ShapeId(title)).unwrap().text.clone().unwrap();
+        t.paragraphs.iter().flat_map(|p| p.runs.iter()).any(|r| r.props.highlight.is_some())
+    };
+    assert!(has_highlight(&mut s));
+    let r = s.execute("format.highlight", &json!({"color": "notacolour"}));
+    assert!(matches!(r, Err(crate::EngineError::BadParams { .. })), "{r:?}");
+    assert!(has_highlight(&mut s), "an invalid colour must not clear the highlight");
+    s.execute("format.highlight", &json!({})).unwrap();
+    assert!(!has_highlight(&mut s), "an absent colour clears the highlight");
+}

From 8770fb90c3a232a248c791545d144c459d0c3ac6 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 22:45:55 -0500
Subject: [PATCH 34/88] Preserve bullet follow-text resets in PPTX

---
 crates/model/src/text.rs          | 39 ++++++++++++++++++++++++++++---
 crates/pptx/src/read/dml.rs       |  3 +++
 crates/pptx/src/write/dml.rs      | 15 +++++++++---
 crates/pptx/tests/it/roundtrip.rs | 27 +++++++++++++++++++++
 4 files changed, 78 insertions(+), 6 deletions(-)

diff --git a/crates/model/src/text.rs b/crates/model/src/text.rs
index 17d606de7..1c70e397e 100644
--- a/crates/model/src/text.rs
+++ b/crates/model/src/text.rs
@@ -236,10 +236,13 @@ pub struct ParaProps {
     pub space_after: Option<Spacing>,
     pub bullet: Option<Bullet>,
     pub bullet_font: Option<String>,
+    pub bullet_font_follow_text: Option<bool>,
     /// `None` = follow text colour.
     pub bullet_color: Option<ColorRef>,
+    pub bullet_color_follow_text: Option<bool>,
     /// Bullet size as a fraction of the text size.
     pub bullet_size: Option<f64>,
+    pub bullet_size_follow_text: Option<bool>,
     pub tabs: Option<Vec<TabStop>>,
     pub default_tab: Option<f64>,
     pub rtl: Option<bool>,
@@ -263,13 +266,15 @@ impl ParaProps {
         if self.bullet.is_none() {
             self.bullet.clone_from(&p.bullet);
         }
-        if self.bullet_font.is_none() {
+        if self.bullet_font.is_none() && self.bullet_font_follow_text.is_none() {
             self.bullet_font.clone_from(&p.bullet_font);
         }
-        if self.bullet_color.is_none() {
+        if self.bullet_color.is_none() && self.bullet_color_follow_text.is_none() {
             self.bullet_color.clone_from(&p.bullet_color);
         }
-        self.bullet_size = self.bullet_size.or(p.bullet_size);
+        if self.bullet_size_follow_text.is_none() {
+            self.bullet_size = self.bullet_size.or(p.bullet_size);
+        }
         if self.tabs.is_none() {
             self.tabs.clone_from(&p.tabs);
         }
@@ -632,3 +637,31 @@ impl TextBody {
         n + self.paragraphs.len().saturating_sub(1)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use deckcraft_color::Rgba;
+
+    #[test]
+    fn explicit_bullet_follow_text_resets_block_inheritance() {
+        let parent = ParaProps {
+            bullet_font: Some("Inter".into()),
+            bullet_color: Some(ColorRef::rgb(Rgba::rgb(0, 0, 0))),
+            bullet_size: Some(2.0),
+            ..Default::default()
+        };
+        let mut child = ParaProps {
+            bullet_font_follow_text: Some(true),
+            bullet_color_follow_text: Some(true),
+            bullet_size_follow_text: Some(true),
+            ..Default::default()
+        };
+
+        child.inherit(&parent);
+
+        assert_eq!(child.bullet_font, None);
+        assert_eq!(child.bullet_color, None);
+        assert_eq!(child.bullet_size, None);
+    }
+}
diff --git a/crates/pptx/src/read/dml.rs b/crates/pptx/src/read/dml.rs
index 767b7dc02..fe02d9b42 100644
--- a/crates/pptx/src/read/dml.rs
+++ b/crates/pptx/src/read/dml.rs
@@ -431,8 +431,11 @@ pub fn ppr(imp: &mut Imp, part: &Part, p: &El) -> (Option<u8>, ParaProps, Option
                 }
             }
             "buFont" => pp.bullet_font = e.attr("typeface").map(String::from),
+            "buFontTx" => pp.bullet_font_follow_text = Some(true),
             "buClr" => pp.bullet_color = color(e),
+            "buClrTx" => pp.bullet_color_follow_text = Some(true),
             "buSzPct" => pp.bullet_size = pct(e, "val").map(|v| v.clamp(0.25, 4.0)),
+            "buSzTx" => pp.bullet_size_follow_text = Some(true),
             "tabLst" => {
                 pp.tabs = Some(
                     e.children_named("tab")
diff --git a/crates/pptx/src/write/dml.rs b/crates/pptx/src/write/dml.rs
index 518f8c4af..5c47aa30d 100644
--- a/crates/pptx/src/write/dml.rs
+++ b/crates/pptx/src/write/dml.rs
@@ -533,8 +533,11 @@ pub fn ppr(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, level: Option<u8>, p:
         || p.space_after.is_some()
         || p.bullet.is_some()
         || p.bullet_font.is_some()
+        || p.bullet_font_follow_text.is_some()
         || p.bullet_color.is_some()
+        || p.bullet_color_follow_text.is_some()
         || p.bullet_size.is_some()
+        || p.bullet_size_follow_text.is_some()
         || p.tabs.is_some()
         || def.is_some();
     if !has_kids {
@@ -551,15 +554,21 @@ pub fn ppr(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, level: Option<u8>, p:
     if let Some(s) = &p.space_after {
         spacing(w, "a:spcAft", s);
     }
-    if let Some(c) = &p.bullet_color {
+    if p.bullet_color_follow_text == Some(true) {
+        w.empty0("a:buClrTx");
+    } else if let Some(c) = &p.bullet_color {
         w.open0("a:buClr");
         color(w, c);
         w.close("a:buClr");
     }
-    if let Some(s) = p.bullet_size {
+    if p.bullet_size_follow_text == Some(true) {
+        w.empty0("a:buSzTx");
+    } else if let Some(s) = p.bullet_size {
         w.val("a:buSzPct", pct(s.clamp(0.25, 4.0)));
     }
-    if let Some(f) = &p.bullet_font {
+    if p.bullet_font_follow_text == Some(true) {
+        w.empty0("a:buFontTx");
+    } else if let Some(f) = &p.bullet_font {
         w.empty("a:buFont", A::new().a("typeface", f));
     }
     match &p.bullet {
diff --git a/crates/pptx/tests/it/roundtrip.rs b/crates/pptx/tests/it/roundtrip.rs
index 370cc9a9f..d0c1a597e 100644
--- a/crates/pptx/tests/it/roundtrip.rs
+++ b/crates/pptx/tests/it/roundtrip.rs
@@ -488,6 +488,33 @@ fn shapes_fills_lines_effects_round_trip() {
     assert_eq!(by_name(&q.slides[1], "Group").id, by_name(&p.slides[1], "Group").id);
 }
 
+#[test]
+fn bullet_follow_text_resets_survive_two_pptx_round_trips() {
+    let mut p = Presentation::default();
+    let mut textbox = shape(&mut p, "Follow text bullets", 20.0, 20.0, 400.0, 100.0);
+    textbox.text = Some(TextBody {
+        paragraphs: vec![Paragraph {
+            props: deckcraft_model::text::ParaProps {
+                bullet: Some(Bullet::Char { char: "•".into() }),
+                bullet_color_follow_text: Some(true),
+                bullet_size_follow_text: Some(true),
+                bullet_font_follow_text: Some(true),
+                ..Default::default()
+            },
+            runs: vec![Run::with("Bullet text", RunProps::default())],
+            ..Default::default()
+        }],
+        ..Default::default()
+    });
+    Arc::make_mut(&mut p.slides[0]).shapes.push(textbox);
+
+    let q = round(&round(&p));
+    let props = &by_name(&q.slides[0], "Follow text bullets").text.as_ref().expect("text").paragraphs[0].props;
+    assert_eq!(props.bullet_color_follow_text, Some(true));
+    assert_eq!(props.bullet_size_follow_text, Some(true));
+    assert_eq!(props.bullet_font_follow_text, Some(true));
+}
+
 #[test]
 fn pictures_media_and_ink_round_trip() {
     let p = rich_deck();

From 727b682d17d2324e3b4a6860d58498aaa52e8dcf Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 22:48:31 -0500
Subject: [PATCH 35/88] Preserve inset line alignment in PPTX

---
 crates/model/src/style.rs         | 30 ++++++++++++++++++++++++++++++
 crates/pptx/src/read/dml.rs       |  5 +++--
 crates/pptx/src/write/dml.rs      |  5 ++++-
 crates/pptx/tests/it/roundtrip.rs | 17 +++++++++++++++++
 4 files changed, 54 insertions(+), 3 deletions(-)

diff --git a/crates/model/src/style.rs b/crates/model/src/style.rs
index 83c494bdf..f30444195 100644
--- a/crates/model/src/style.rs
+++ b/crates/model/src/style.rs
@@ -232,6 +232,34 @@ pub enum LineJoin {
     Miter,
 }
 
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum LineAlign {
+    #[default]
+    Center,
+    Inside,
+    Outside,
+}
+
+impl LineAlign {
+    pub fn xml(self) -> &'static str {
+        match self {
+            LineAlign::Center => "ctr",
+            LineAlign::Inside => "in",
+            LineAlign::Outside => "out",
+        }
+    }
+
+    pub fn from_xml(value: &str) -> Option<Self> {
+        match value {
+            "ctr" => Some(LineAlign::Center),
+            "in" => Some(LineAlign::Inside),
+            "out" => Some(LineAlign::Outside),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum Compound {
@@ -324,6 +352,7 @@ pub struct Line {
     pub dash: Option<Dash>,
     pub cap: Option<LineCap>,
     pub join: Option<LineJoin>,
+    pub align: Option<LineAlign>,
     pub compound: Option<Compound>,
     pub head: Option<LineEnd>,
     pub tail: Option<LineEnd>,
@@ -347,6 +376,7 @@ impl Line {
         }
         self.cap = self.cap.or(parent.cap);
         self.join = self.join.or(parent.join);
+        self.align = self.align.or(parent.align);
         self.compound = self.compound.or(parent.compound);
         if self.head.is_none() {
             self.head.clone_from(&parent.head);
diff --git a/crates/pptx/src/read/dml.rs b/crates/pptx/src/read/dml.rs
index 767b7dc02..61b861dfc 100644
--- a/crates/pptx/src/read/dml.rs
+++ b/crates/pptx/src/read/dml.rs
@@ -3,8 +3,8 @@
 use deckcraft_color::{ColorTransform, Rgba, SchemeSlot};
 use deckcraft_geom::{Xfrm, emu_to_pt};
 use deckcraft_model::style::{
-    ColorBase, ColorRef, Compound, Dash, Effects, Fill, Glow, Gradient, GradientShape, GradientStop, Line, LineCap, LineEnd, LineJoin, PatternFill,
-    PictureFill, PictureMode, Reflection, Shadow,
+    ColorBase, ColorRef, Compound, Dash, Effects, Fill, Glow, Gradient, GradientShape, GradientStop, Line, LineAlign, LineCap, LineEnd, LineJoin,
+    PatternFill, PictureFill, PictureMode, Reflection, Shadow,
 };
 use deckcraft_model::text::{
     Action, Align, Anchor, AutoFit, BodyProps, Bullet, Caps, Hyperlink, LevelStyle, ListStyle, ParaProps, Paragraph, Run, RunKind, RunProps, Spacing,
@@ -222,6 +222,7 @@ pub fn line(imp: &mut Imp, part: &Part, ln: &El) -> Line {
         _ => LineCap::Flat,
     });
     l.compound = ln.attr("cmpd").map(Compound::from_xml);
+    l.align = ln.attr("algn").and_then(LineAlign::from_xml);
     l.fill = fill_of(imp, part, ln);
     for e in ln.elements() {
         match e.local() {
diff --git a/crates/pptx/src/write/dml.rs b/crates/pptx/src/write/dml.rs
index 518f8c4af..fbf8857b7 100644
--- a/crates/pptx/src/write/dml.rs
+++ b/crates/pptx/src/write/dml.rs
@@ -1,7 +1,9 @@
 //! DrawingML writing: colours, fills, lines, effects, transforms and text.
 
 use deckcraft_geom::{Xfrm, pt_to_emu};
-use deckcraft_model::style::{ColorBase, ColorRef, Compound, Dash, Effects, Fill, GradientShape, Line, LineCap, LineJoin, PictureFill, PictureMode};
+use deckcraft_model::style::{
+    ColorBase, ColorRef, Compound, Dash, Effects, Fill, GradientShape, Line, LineAlign, LineCap, LineJoin, PictureFill, PictureMode,
+};
 use deckcraft_model::text::{
     Action, AutoFit, BodyProps, Bullet, Caps, Hyperlink, ListStyle, ParaProps, Paragraph, RunKind, RunProps, Spacing, Strike, TextBody,
 };
@@ -208,6 +210,7 @@ pub fn line(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, l: &Line) {
                 LineCap::Flat => "flat",
             }),
         )
+        .o("algn", l.align.map(LineAlign::xml))
         .o("cmpd", l.compound.map(Compound::xml));
     w.open(tag, a);
     if let Some(f) = &l.fill {
diff --git a/crates/pptx/tests/it/roundtrip.rs b/crates/pptx/tests/it/roundtrip.rs
index 370cc9a9f..e93807c21 100644
--- a/crates/pptx/tests/it/roundtrip.rs
+++ b/crates/pptx/tests/it/roundtrip.rs
@@ -488,6 +488,23 @@ fn shapes_fills_lines_effects_round_trip() {
     assert_eq!(by_name(&q.slides[1], "Group").id, by_name(&p.slides[1], "Group").id);
 }
 
+#[test]
+fn line_alignment_survives_two_pptx_round_trips() {
+    let mut p = Presentation::default();
+    let mut inside = shape(&mut p, "Inset line", 20.0, 20.0, 100.0, 100.0);
+    inside.line = Some(Line { align: Some(deckcraft_model::style::LineAlign::Inside), ..Default::default() });
+    let mut outside = shape(&mut p, "Outset line", 140.0, 20.0, 100.0, 100.0);
+    outside.line = Some(Line { align: Some(deckcraft_model::style::LineAlign::Outside), ..Default::default() });
+    let mut centered = shape(&mut p, "Centered line", 260.0, 20.0, 100.0, 100.0);
+    centered.line = Some(Line { align: Some(deckcraft_model::style::LineAlign::Center), ..Default::default() });
+    Arc::make_mut(&mut p.slides[0]).shapes.extend([inside, outside, centered]);
+
+    let q = round(&round(&p));
+    assert_eq!(by_name(&q.slides[0], "Inset line").line.as_ref().and_then(|line| line.align), Some(deckcraft_model::style::LineAlign::Inside));
+    assert_eq!(by_name(&q.slides[0], "Outset line").line.as_ref().and_then(|line| line.align), Some(deckcraft_model::style::LineAlign::Outside));
+    assert_eq!(by_name(&q.slides[0], "Centered line").line.as_ref().and_then(|line| line.align), Some(deckcraft_model::style::LineAlign::Center));
+}
+
 #[test]
 fn pictures_media_and_ink_round_trip() {
     let p = rich_deck();

From ad97533aec09aa18737ba051970e436b7d2059f6 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 22:57:14 -0500
Subject: [PATCH 36/88] Preserve gradient flip mode in PPTX

---
 crates/engine/src/cmd/shape/appearance.rs |  2 +-
 crates/engine/src/cmd/smartart/paint.rs   |  2 ++
 crates/model/src/style.rs                 | 32 +++++++++++++++++++++++
 crates/model/src/tests.rs                 |  9 +++++--
 crates/model/src/theme.rs                 |  2 ++
 crates/pptx/src/read/dml.rs               | 12 ++++++---
 crates/pptx/src/write/dml.rs              |  6 +++--
 crates/pptx/tests/it/corpus_style.rs      |  4 +++
 crates/pptx/tests/it/fills.rs             |  7 ++++-
 crates/pptx/tests/it/roundtrip.rs         | 14 ++++++++--
 crates/render/src/tests.rs                | 10 +++++++
 crates/render/src/tests_wild.rs           | 23 +++++++++++++---
 crates/ui-egui/src/panels/fillui.rs       |  4 +++
 13 files changed, 113 insertions(+), 14 deletions(-)

diff --git a/crates/engine/src/cmd/shape/appearance.rs b/crates/engine/src/cmd/shape/appearance.rs
index 460565f78..09a0e2360 100644
--- a/crates/engine/src/cmd/shape/appearance.rs
+++ b/crates/engine/src/cmd/shape/appearance.rs
@@ -108,7 +108,7 @@ pub(crate) fn gradient_param(v: &Value) -> Option<Gradient> {
             scaled: false,
         },
     };
-    Some(Gradient { tile: [0.0; 4], stops, shape, rotate_with_shape: v.get("rotateWithShape").and_then(Value::as_bool).unwrap_or(true) })
+    Some(Gradient { tile: [0.0; 4], stops, shape, rotate_with_shape: v.get("rotateWithShape").and_then(Value::as_bool).unwrap_or(true), flip: None })
 }
 
 /// Fill and outline apply to a group's visible members as well as its container. Other edits
diff --git a/crates/engine/src/cmd/smartart/paint.rs b/crates/engine/src/cmd/smartart/paint.rs
index fc75a1f90..e49efd902 100644
--- a/crates/engine/src/cmd/smartart/paint.rs
+++ b/crates/engine/src/cmd/smartart/paint.rs
@@ -99,6 +99,8 @@ pub(super) fn paint(d: &Diagram, sh: &mut Shape, i: usize, light: bool) {
                 shape: GradientShape::Linear { angle: 90.0, scaled: false },
                 rotate_with_shape: true,
                 tile: [0.0; 4],
+
+                flip: None,
             }));
             sh.line = Some(Line::solid(ColorRef::scheme(SchemeSlot::Lt1), 1.0));
             sh.effects = Some(Effects { outer_shadow: Some(shadow(8.0, 5.0)), ..Default::default() });
diff --git a/crates/model/src/style.rs b/crates/model/src/style.rs
index 83c494bdf..a653da936 100644
--- a/crates/model/src/style.rs
+++ b/crates/model/src/style.rs
@@ -72,6 +72,36 @@ pub struct GradientStop {
     pub color: ColorRef,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum GradientFlip {
+    None,
+    X,
+    Y,
+    Xy,
+}
+
+impl GradientFlip {
+    pub fn xml(self) -> &'static str {
+        match self {
+            GradientFlip::None => "none",
+            GradientFlip::X => "x",
+            GradientFlip::Y => "y",
+            GradientFlip::Xy => "xy",
+        }
+    }
+
+    pub fn from_xml(value: &str) -> Option<Self> {
+        match value {
+            "none" => Some(GradientFlip::None),
+            "x" => Some(GradientFlip::X),
+            "y" => Some(GradientFlip::Y),
+            "xy" => Some(GradientFlip::Xy),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", tag = "kind")]
 pub enum GradientShape {
@@ -90,6 +120,8 @@ pub enum GradientShape {
 pub struct Gradient {
     pub stops: Vec<GradientStop>,
     pub shape: GradientShape,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub flip: Option<GradientFlip>,
     #[serde(default = "crate::yes")]
     pub rotate_with_shape: bool,
     /// `a:tileRect`: the box the gradient is laid out in, as insets from the shape's box
diff --git a/crates/model/src/tests.rs b/crates/model/src/tests.rs
index 38d815ef9..1fd29aeff 100644
--- a/crates/model/src/tests.rs
+++ b/crates/model/src/tests.rs
@@ -73,8 +73,13 @@ fn a_gradient_without_stops_takes_them_from_its_style() {
     let p = Presentation::default();
     let s = &p.slides[0];
     let ctx = Ctx::for_slide(&p, s).unwrap();
-    let own =
-        style::Gradient { tile: [0.0; 4], stops: vec![], shape: style::GradientShape::Linear { angle: 45.0, scaled: true }, rotate_with_shape: true };
+    let own = style::Gradient {
+        tile: [0.0; 4],
+        stops: vec![],
+        shape: style::GradientShape::Linear { angle: 45.0, scaled: true },
+        rotate_with_shape: true,
+        flip: None,
+    };
     let mut st = ShapeStyle::accent(SchemeSlot::Accent2);
     st.fill_ref.0 = 3;
     let sh = Shape { style: Some(st.clone()), fill: Some(Fill::Gradient(own.clone())), ..Default::default() };
diff --git a/crates/model/src/theme.rs b/crates/model/src/theme.rs
index 870a8bb5a..27fe93e3d 100644
--- a/crates/model/src/theme.rs
+++ b/crates/model/src/theme.rs
@@ -115,6 +115,8 @@ pub fn default_format() -> FormatScheme {
             ],
             shape: GradientShape::Linear { angle: 90.0, scaled: false },
             rotate_with_shape: true,
+
+            flip: None,
         })
     };
     FormatScheme {
diff --git a/crates/pptx/src/read/dml.rs b/crates/pptx/src/read/dml.rs
index 767b7dc02..626f58776 100644
--- a/crates/pptx/src/read/dml.rs
+++ b/crates/pptx/src/read/dml.rs
@@ -3,8 +3,8 @@
 use deckcraft_color::{ColorTransform, Rgba, SchemeSlot};
 use deckcraft_geom::{Xfrm, emu_to_pt};
 use deckcraft_model::style::{
-    ColorBase, ColorRef, Compound, Dash, Effects, Fill, Glow, Gradient, GradientShape, GradientStop, Line, LineCap, LineEnd, LineJoin, PatternFill,
-    PictureFill, PictureMode, Reflection, Shadow,
+    ColorBase, ColorRef, Compound, Dash, Effects, Fill, Glow, Gradient, GradientFlip, GradientShape, GradientStop, Line, LineCap, LineEnd, LineJoin,
+    PatternFill, PictureFill, PictureMode, Reflection, Shadow,
 };
 use deckcraft_model::text::{
     Action, Align, Anchor, AutoFit, BodyProps, Bullet, Caps, Hyperlink, LevelStyle, ListStyle, ParaProps, Paragraph, Run, RunKind, RunProps, Spacing,
@@ -122,7 +122,13 @@ pub fn gradient(f: &El) -> Gradient {
         GradientShape::Linear { angle: 90.0, scaled: false }
     };
     let tile = f.child("tileRect").map(|r| [pct(r, "l"), pct(r, "t"), pct(r, "r"), pct(r, "b")].map(|v| v.unwrap_or(0.0).clamp(-10.0, 10.0)));
-    Gradient { tile: tile.unwrap_or_default(), stops, shape, rotate_with_shape: f.bool("rotWithShape").unwrap_or(true) }
+    Gradient {
+        tile: tile.unwrap_or_default(),
+        stops,
+        shape,
+        flip: f.attr("flip").and_then(GradientFlip::from_xml),
+        rotate_with_shape: f.bool("rotWithShape").unwrap_or(true),
+    }
 }
 
 /// `blipFill` (either `a:` or `p:`) → picture fill, registering the image as media.
diff --git a/crates/pptx/src/write/dml.rs b/crates/pptx/src/write/dml.rs
index 518f8c4af..aeae9801b 100644
--- a/crates/pptx/src/write/dml.rs
+++ b/crates/pptx/src/write/dml.rs
@@ -1,7 +1,9 @@
 //! DrawingML writing: colours, fills, lines, effects, transforms and text.
 
 use deckcraft_geom::{Xfrm, pt_to_emu};
-use deckcraft_model::style::{ColorBase, ColorRef, Compound, Dash, Effects, Fill, GradientShape, Line, LineCap, LineJoin, PictureFill, PictureMode};
+use deckcraft_model::style::{
+    ColorBase, ColorRef, Compound, Dash, Effects, Fill, GradientFlip, GradientShape, Line, LineCap, LineJoin, PictureFill, PictureMode,
+};
 use deckcraft_model::text::{
     Action, AutoFit, BodyProps, Bullet, Caps, Hyperlink, ListStyle, ParaProps, Paragraph, RunKind, RunProps, Spacing, Strike, TextBody,
 };
@@ -279,7 +281,7 @@ fn shadow(w: &mut W, tag: &str, s: &deckcraft_model::style::Shadow) {
 }
 
 fn gradient(w: &mut W, g: &deckcraft_model::style::Gradient) {
-    w.open("a:gradFill", A::new().a("rotWithShape", if g.rotate_with_shape { "1" } else { "0" }));
+    w.open("a:gradFill", A::new().o("flip", g.flip.map(GradientFlip::xml)).a("rotWithShape", if g.rotate_with_shape { "1" } else { "0" }));
     // No stops: no `a:gsLst`, so the gradient keeps taking them from its style's fill.
     let mut stops = g.stops.clone();
     if stops.len() == 1 {
diff --git a/crates/pptx/tests/it/corpus_style.rs b/crates/pptx/tests/it/corpus_style.rs
index 6eac7bddd..422897602 100644
--- a/crates/pptx/tests/it/corpus_style.rs
+++ b/crates/pptx/tests/it/corpus_style.rs
@@ -46,6 +46,8 @@ fn gradient(angle: f64) -> Fill {
         shape: GradientShape::Linear { angle, scaled: true },
         rotate_with_shape: true,
         tile: [0.0; 4],
+
+        flip: None,
     })
 }
 
@@ -116,6 +118,8 @@ fn style_deck() -> Presentation {
         shape: GradientShape::Path { path: "circle".into(), focus: [0.2, 0.2, 0.2, 0.2] },
         rotate_with_shape: false,
         tile: [0.0; 4],
+
+        flip: None,
     }));
 
     let mut patt = shape(&mut p, "Pattern", 200.0, 260.0, 120.0, 80.0);
diff --git a/crates/pptx/tests/it/fills.rs b/crates/pptx/tests/it/fills.rs
index 98069d114..51bd51de9 100644
--- a/crates/pptx/tests/it/fills.rs
+++ b/crates/pptx/tests/it/fills.rs
@@ -88,7 +88,8 @@ fn a_gradient_without_stops_is_saved_without_stops() {
     let mut p = defaults::new_presentation(None);
     let id = ShapeId(p.alloc_id().expect("ids"));
     let first = p.slides[0].id;
-    let own = Gradient { tile: [0.0; 4], stops: vec![], shape: GradientShape::Linear { angle: 45.0, scaled: true }, rotate_with_shape: true };
+    let own =
+        Gradient { tile: [0.0; 4], stops: vec![], shape: GradientShape::Linear { angle: 45.0, scaled: true }, rotate_with_shape: true, flip: None };
     p.slide_mut(first).expect("slide").shapes.push(Shape {
         id,
         name: "Styled".into(),
@@ -119,6 +120,8 @@ fn a_fill_overlay_round_trips() {
             ],
             shape: GradientShape::Linear { angle: 4.5, scaled: true },
             rotate_with_shape: true,
+
+            flip: None,
         }),
     };
     p.slide_mut(first).expect("slide").shapes.push(Shape {
@@ -148,6 +151,8 @@ fn a_gradient_tile_rect_is_read_and_round_trips() {
         shape: GradientShape::Path { path: "circle".into(), focus: [0.0, 0.0, 1.0, 1.0] },
         rotate_with_shape: true,
         tile: [-1.0, -1.0, 0.0, 0.0],
+
+        flip: None,
     };
     let mut p = defaults::new_presentation(None);
     let id = ShapeId(p.alloc_id().expect("ids"));
diff --git a/crates/pptx/tests/it/roundtrip.rs b/crates/pptx/tests/it/roundtrip.rs
index 370cc9a9f..985163107 100644
--- a/crates/pptx/tests/it/roundtrip.rs
+++ b/crates/pptx/tests/it/roundtrip.rs
@@ -7,8 +7,8 @@ use deckcraft_geom::Xfrm;
 use deckcraft_model::anim::{AnimClass, AnimStart, Animation, TextBuild, Transition};
 use deckcraft_model::chart::{Chart, ChartType};
 use deckcraft_model::style::{
-    ColorRef, Dash, Effects, Fill, Glow, Gradient, GradientShape, GradientStop, Line, LineEnd, PatternFill, PictureAdjust, PictureFill, PictureMode,
-    Shadow,
+    ColorRef, Dash, Effects, Fill, Glow, Gradient, GradientFlip, GradientShape, GradientStop, Line, LineEnd, PatternFill, PictureAdjust, PictureFill,
+    PictureMode, Shadow,
 };
 use deckcraft_model::table::Table;
 use deckcraft_model::text::{
@@ -115,6 +115,8 @@ pub fn rich_deck() -> Presentation {
         ],
         shape: GradientShape::Linear { angle: 45.0, scaled: false },
         rotate_with_shape: true,
+
+        flip: Some(GradientFlip::Xy),
     }));
     a.line = Some(Line { width: Some(3.0), dash: Some(Dash::Preset { name: "dash".into() }), ..Line::solid(ColorRef::rgb(Rgba::rgb(0, 0, 0)), 3.0) });
     a.effects = Some(Effects {
@@ -488,6 +490,14 @@ fn shapes_fills_lines_effects_round_trip() {
     assert_eq!(by_name(&q.slides[1], "Group").id, by_name(&p.slides[1], "Group").id);
 }
 
+#[test]
+fn gradient_flip_mode_survives_two_pptx_round_trips() {
+    let p = rich_deck();
+    let q = round(&round(&p));
+    let gradient = by_name(&q.slides[1], "Gradient Star").fill.as_ref();
+    assert!(matches!(gradient, Some(Fill::Gradient(g)) if g.flip == Some(GradientFlip::Xy)));
+}
+
 #[test]
 fn pictures_media_and_ink_round_trip() {
     let p = rich_deck();
diff --git a/crates/render/src/tests.rs b/crates/render/src/tests.rs
index db8644ab5..ad6b94245 100644
--- a/crates/render/src/tests.rs
+++ b/crates/render/src/tests.rs
@@ -978,6 +978,8 @@ fn a_linear_gradient_ramps_like_powerpoint() {
             stops: vec![stop(0.0, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
             shape: GradientShape::Linear { angle: 0.0, scaled: false },
             rotate_with_shape: true,
+
+            flip: None,
         })),
         line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
         ..Default::default()
@@ -1003,6 +1005,8 @@ fn a_gradient_with_a_stop_off_the_end_stays_linear() {
             stops: vec![stop(0.2, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
             shape: GradientShape::Linear { angle: 0.0, scaled: false },
             rotate_with_shape: true,
+
+            flip: None,
         })),
         line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
         ..Default::default()
@@ -1044,6 +1048,8 @@ fn a_shape_filled_with_the_background_shows_the_slide_background() {
             stops: vec![stop(0.0, 0), stop(0.5, 0), stop(1.0, 200)],
             shape: GradientShape::Linear { angle: 0.0, scaled: false },
             rotate_with_shape: true,
+
+            flip: None,
         }),
     });
     let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
@@ -1145,6 +1151,8 @@ fn a_text_gradient_starts_over_on_every_line() {
             stops: vec![stop(0.0, 0), stop(1.0, 255)],
             shape: GradientShape::Linear { angle: 90.0, scaled: false },
             rotate_with_shape: true,
+
+            flip: None,
         }));
     }
     sh.text = Some(t);
@@ -1306,6 +1314,8 @@ fn rect_path_gradients_draw_x_shaped_contours() {
             stops: vec![stop(0.0, 0), stop(0.5, 128), stop(1.0, 255)],
             shape: GradientShape::Path { path: "rect".into(), focus: [0.5, 0.5, 0.5, 0.5] },
             rotate_with_shape: true,
+
+            flip: None,
         })),
         line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
         ..Default::default()
diff --git a/crates/render/src/tests_wild.rs b/crates/render/src/tests_wild.rs
index fb5613467..c73987af5 100644
--- a/crates/render/src/tests_wild.rs
+++ b/crates/render/src/tests_wild.rs
@@ -186,6 +186,8 @@ fn radial(focus: [f64; 4]) -> Shape {
             stops,
             shape: GradientShape::Path { path: "circle".into(), focus },
             rotate_with_shape: true,
+
+            flip: None,
         })),
         line: no_line(),
         ..Default::default()
@@ -310,8 +312,13 @@ fn a_pictures_border_lies_outside_the_picture() {
 fn children_filled_with_the_group_fill_show_one_fill_across_the_group() {
     use deckcraft_model::style::{Gradient, GradientShape, GradientStop};
     let stops = vec![GradientStop { pos: 0.0, color: ColorRef::rgb(RED) }, GradientStop { pos: 1.0, color: ColorRef::rgb(Rgba::rgb(0, 0, 255)) }];
-    let grad =
-        Fill::Gradient(Gradient { tile: [0.0; 4], stops, shape: GradientShape::Linear { angle: 0.0, scaled: false }, rotate_with_shape: true });
+    let grad = Fill::Gradient(Gradient {
+        tile: [0.0; 4],
+        stops,
+        shape: GradientShape::Linear { angle: 0.0, scaled: false },
+        rotate_with_shape: true,
+        flip: None,
+    });
     let child = |id: u32, x: f64| Shape {
         id: ShapeId(id),
         xfrm: Some(Xfrm::new(x, 0.0, 90.0, 100.0)),
@@ -372,7 +379,13 @@ fn a_linear_gradient_spans_its_tile_rect() {
     use deckcraft_model::style::{Gradient, GradientShape, GradientStop};
     // Tile rect the left half of the box: the ramp ends half way and stays black after.
     let stops = vec![GradientStop { pos: 0.0, color: ColorRef::rgb(WHITE) }, GradientStop { pos: 1.0, color: ColorRef::rgb(Rgba::BLACK) }];
-    let g = Gradient { stops, shape: GradientShape::Linear { angle: 0.0, scaled: false }, rotate_with_shape: true, tile: [0.0, 0.0, 0.5, 0.0] };
+    let g = Gradient {
+        stops,
+        shape: GradientShape::Linear { angle: 0.0, scaled: false },
+        rotate_with_shape: true,
+        tile: [0.0, 0.0, 0.5, 0.0],
+        flip: None,
+    };
     let sh = Shape {
         id: ShapeId(20),
         xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 100.0)),
@@ -502,6 +515,8 @@ fn gradient_lines_and_their_heads_take_the_gradient() {
             shape: GradientShape::Linear { angle, scaled: false },
             rotate_with_shape: true,
             tile: [0.0; 4],
+
+            flip: None,
         })
     };
     // Left to right along a 20 pt line: red at its start, blue at its end, and the arrowhead at
@@ -656,6 +671,8 @@ fn a_gradient_not_rotating_with_its_shape_keeps_to_the_slide() {
             shape: GradientShape::Linear { angle: 0.0, scaled: false },
             rotate_with_shape,
             tile: [0.0; 4],
+
+            flip: None,
         };
         // 200 × 100 turned a quarter: it covers 150..250 across and 50..250 down.
         let sh = Shape {
diff --git a/crates/ui-egui/src/panels/fillui.rs b/crates/ui-egui/src/panels/fillui.rs
index 5150b8f0e..06b1ac930 100644
--- a/crates/ui-egui/src/panels/fillui.rs
+++ b/crates/ui-egui/src/panels/fillui.rs
@@ -21,6 +21,8 @@ pub fn default_gradient(base: ColorRef, angle: f64) -> Gradient {
         stops: vec![GradientStop { pos: 0.0, color: base }, GradientStop { pos: 1.0, color: dark }],
         shape: GradientShape::Linear { angle, scaled: false },
         rotate_with_shape: true,
+
+        flip: None,
     }
 }
 
@@ -142,6 +144,8 @@ pub fn gradient_editor(ui: &mut Ui, id: &str, g: &Gradient, sc: &ColorScheme) ->
                 stops: vec![GradientStop { pos: 0.0, color: light }, GradientStop { pos: 1.0, color: dark }],
                 shape: GradientShape::Path { path: "circle".into(), focus: [0.5, 0.5, 0.5, 0.5] },
                 rotate_with_shape: true,
+
+                flip: None,
             },
             Gradient {
                 stops: vec![GradientStop { pos: 0.0, color: base.clone() }, GradientStop { pos: 1.0, color: with_alpha(base, 0.0) }],

From 4408ff6153fb78255c2ae3f86e4c85cd0e5e709c Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 23:00:20 -0500
Subject: [PATCH 37/88] Restrict line alignment to schema values

---
 crates/model/src/style.rs         | 3 ---
 crates/pptx/tests/it/roundtrip.rs | 8 +++-----
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/crates/model/src/style.rs b/crates/model/src/style.rs
index f30444195..85eb9b80e 100644
--- a/crates/model/src/style.rs
+++ b/crates/model/src/style.rs
@@ -238,7 +238,6 @@ pub enum LineAlign {
     #[default]
     Center,
     Inside,
-    Outside,
 }
 
 impl LineAlign {
@@ -246,7 +245,6 @@ impl LineAlign {
         match self {
             LineAlign::Center => "ctr",
             LineAlign::Inside => "in",
-            LineAlign::Outside => "out",
         }
     }
 
@@ -254,7 +252,6 @@ impl LineAlign {
         match value {
             "ctr" => Some(LineAlign::Center),
             "in" => Some(LineAlign::Inside),
-            "out" => Some(LineAlign::Outside),
             _ => None,
         }
     }
diff --git a/crates/pptx/tests/it/roundtrip.rs b/crates/pptx/tests/it/roundtrip.rs
index e93807c21..b781bea54 100644
--- a/crates/pptx/tests/it/roundtrip.rs
+++ b/crates/pptx/tests/it/roundtrip.rs
@@ -493,16 +493,14 @@ fn line_alignment_survives_two_pptx_round_trips() {
     let mut p = Presentation::default();
     let mut inside = shape(&mut p, "Inset line", 20.0, 20.0, 100.0, 100.0);
     inside.line = Some(Line { align: Some(deckcraft_model::style::LineAlign::Inside), ..Default::default() });
-    let mut outside = shape(&mut p, "Outset line", 140.0, 20.0, 100.0, 100.0);
-    outside.line = Some(Line { align: Some(deckcraft_model::style::LineAlign::Outside), ..Default::default() });
-    let mut centered = shape(&mut p, "Centered line", 260.0, 20.0, 100.0, 100.0);
+    let mut centered = shape(&mut p, "Centered line", 140.0, 20.0, 100.0, 100.0);
     centered.line = Some(Line { align: Some(deckcraft_model::style::LineAlign::Center), ..Default::default() });
-    Arc::make_mut(&mut p.slides[0]).shapes.extend([inside, outside, centered]);
+    Arc::make_mut(&mut p.slides[0]).shapes.extend([inside, centered]);
 
     let q = round(&round(&p));
     assert_eq!(by_name(&q.slides[0], "Inset line").line.as_ref().and_then(|line| line.align), Some(deckcraft_model::style::LineAlign::Inside));
-    assert_eq!(by_name(&q.slides[0], "Outset line").line.as_ref().and_then(|line| line.align), Some(deckcraft_model::style::LineAlign::Outside));
     assert_eq!(by_name(&q.slides[0], "Centered line").line.as_ref().and_then(|line| line.align), Some(deckcraft_model::style::LineAlign::Center));
+    assert_eq!(deckcraft_model::style::LineAlign::from_xml("out"), None);
 }
 
 #[test]

From f5c2aca6446dcc9231e847505b1fe1519061d470 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 23:05:16 -0500
Subject: [PATCH 38/88] Preserve bullet follow-text inheritance

---
 crates/engine/src/cmd/format/paragraph.rs |  9 +++-
 crates/engine/src/tests.rs                | 13 ++++++
 crates/model/src/text.rs                  | 51 +++++++++++++++++++++--
 3 files changed, 68 insertions(+), 5 deletions(-)

diff --git a/crates/engine/src/cmd/format/paragraph.rs b/crates/engine/src/cmd/format/paragraph.rs
index dd88f4055..f036068f6 100644
--- a/crates/engine/src/cmd/format/paragraph.rs
+++ b/crates/engine/src/cmd/format/paragraph.rs
@@ -45,12 +45,17 @@ pub(super) fn bullets(s: &mut Session, p: &Value) -> Result<Value> {
     format_para(s, &move |para| {
         if on {
             para.props.bullet = Some(Bullet::Char { char: ch.clone() });
-            para.props.bullet_font = if explicit_char { Some("Arial".into()) } else { para.props.bullet_font.clone() };
+            if explicit_char {
+                para.props.bullet_font = Some("Arial".into());
+                para.props.bullet_font_follow_text = None;
+            }
             if col.is_some() {
                 para.props.bullet_color = col.clone();
+                para.props.bullet_color_follow_text = None;
             }
             if size.is_some() {
                 para.props.bullet_size = size;
+                para.props.bullet_size_follow_text = None;
             }
             if para.props.indent.is_none_or(|i| i >= 0.0) && para.props.margin_left.is_none_or(|m| m == 0.0) {
                 para.props.margin_left = Some(18.0 + 36.0 * para.level as f64);
@@ -76,9 +81,11 @@ pub(super) fn numbering(s: &mut Session, p: &Value) -> Result<Value> {
             para.props.bullet = Some(Bullet::AutoNum { scheme: scheme.clone(), start_at: start });
             if col.is_some() {
                 para.props.bullet_color = col.clone();
+                para.props.bullet_color_follow_text = None;
             }
             if size.is_some() {
                 para.props.bullet_size = size;
+                para.props.bullet_size_follow_text = None;
             }
             para.props.margin_left = Some(27.0 + 36.0 * para.level as f64);
             para.props.indent = Some(-27.0);
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 85cbe9d8c..dc07b2179 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -3198,6 +3198,15 @@ fn motion_path_presets_have_paths_ids_and_round_trip() {
 fn numbering_takes_color_and_size() {
     let mut s = Session::with_new();
     s.execute("insert.textBox", &json!({"rect": [10, 10, 300, 100], "text": "One\nTwo"})).unwrap();
+    {
+        let id = s.doc().unwrap().selection.shapes[0];
+        let d = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
+        let shape = deckcraft_model::find_shape_mut(&mut std::sync::Arc::make_mut(&mut d.slides[0]).shapes, id).unwrap();
+        let props = &mut shape.text.as_mut().unwrap().paragraphs[0].props;
+        props.bullet_font_follow_text = Some(true);
+        props.bullet_color_follow_text = Some(true);
+        props.bullet_size_follow_text = Some(true);
+    }
     s.execute("format.numbering", &json!({"on": true, "scheme": "romanUcPeriod", "start": 3, "color": "accent2", "size": 150})).unwrap();
     let para = |s: &Session| {
         let st = s.doc().unwrap();
@@ -3207,9 +3216,13 @@ fn numbering_takes_color_and_size() {
     let pp = para(&s);
     assert!(matches!(&pp.bullet, Some(deckcraft_model::text::Bullet::AutoNum { scheme, start_at: 3 }) if scheme == "romanUcPeriod"));
     assert_eq!(pp.bullet_size, Some(1.5));
+    assert_eq!(pp.bullet_font_follow_text, Some(true));
+    assert_eq!(pp.bullet_color_follow_text, None);
+    assert_eq!(pp.bullet_size_follow_text, None);
     assert_eq!(pp.bullet_color, Some(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Accent2)));
     s.execute("format.bullets", &json!({"on": true, "char": "★", "size": 9000})).unwrap();
     assert_eq!(para(&s).bullet_size, Some(4.0));
+    assert_eq!(para(&s).bullet_font_follow_text, None);
 }
 
 #[test]
diff --git a/crates/model/src/text.rs b/crates/model/src/text.rs
index 1c70e397e..362f43939 100644
--- a/crates/model/src/text.rs
+++ b/crates/model/src/text.rs
@@ -266,14 +266,35 @@ impl ParaProps {
         if self.bullet.is_none() {
             self.bullet.clone_from(&p.bullet);
         }
+        if self.bullet_font_follow_text == Some(false) || self.bullet_font.is_some() {
+            self.bullet_font_follow_text = None;
+        }
         if self.bullet_font.is_none() && self.bullet_font_follow_text.is_none() {
-            self.bullet_font.clone_from(&p.bullet_font);
+            if p.bullet_font_follow_text == Some(true) {
+                self.bullet_font_follow_text = Some(true);
+            } else {
+                self.bullet_font.clone_from(&p.bullet_font);
+            }
+        }
+        if self.bullet_color_follow_text == Some(false) || self.bullet_color.is_some() {
+            self.bullet_color_follow_text = None;
         }
         if self.bullet_color.is_none() && self.bullet_color_follow_text.is_none() {
-            self.bullet_color.clone_from(&p.bullet_color);
+            if p.bullet_color_follow_text == Some(true) {
+                self.bullet_color_follow_text = Some(true);
+            } else {
+                self.bullet_color.clone_from(&p.bullet_color);
+            }
         }
-        if self.bullet_size_follow_text.is_none() {
-            self.bullet_size = self.bullet_size.or(p.bullet_size);
+        if self.bullet_size_follow_text == Some(false) || self.bullet_size.is_some() {
+            self.bullet_size_follow_text = None;
+        }
+        if self.bullet_size.is_none() && self.bullet_size_follow_text.is_none() {
+            if p.bullet_size_follow_text == Some(true) {
+                self.bullet_size_follow_text = Some(true);
+            } else {
+                self.bullet_size = p.bullet_size;
+            }
         }
         if self.tabs.is_none() {
             self.tabs.clone_from(&p.tabs);
@@ -663,5 +684,27 @@ mod tests {
         assert_eq!(child.bullet_font, None);
         assert_eq!(child.bullet_color, None);
         assert_eq!(child.bullet_size, None);
+
+        let mut inherited_reset = ParaProps::default();
+        inherited_reset.inherit(&ParaProps {
+            bullet_font_follow_text: Some(true),
+            bullet_color_follow_text: Some(true),
+            bullet_size_follow_text: Some(true),
+            ..Default::default()
+        });
+        assert_eq!(inherited_reset.bullet_font_follow_text, Some(true));
+        assert_eq!(inherited_reset.bullet_color_follow_text, Some(true));
+        assert_eq!(inherited_reset.bullet_size_follow_text, Some(true));
+
+        let mut explicit_false = ParaProps {
+            bullet_font_follow_text: Some(false),
+            bullet_color_follow_text: Some(false),
+            bullet_size_follow_text: Some(false),
+            ..Default::default()
+        };
+        explicit_false.inherit(&parent);
+        assert_eq!(explicit_false.bullet_font, parent.bullet_font);
+        assert_eq!(explicit_false.bullet_color, parent.bullet_color);
+        assert_eq!(explicit_false.bullet_size, parent.bullet_size);
     }
 }

From 1de0101cedbe69e4e37f380c2737b84e7759ba38 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 23:11:12 -0500
Subject: [PATCH 39/88] Honor miter percentage schema bounds

---
 crates/pptx/src/read/dml.rs       | 23 ++++++++++++++++++++++-
 crates/pptx/src/write/dml.rs      |  5 ++++-
 crates/pptx/tests/it/roundtrip.rs |  5 ++++-
 3 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/crates/pptx/src/read/dml.rs b/crates/pptx/src/read/dml.rs
index e1e5dcd47..9ac999122 100644
--- a/crates/pptx/src/read/dml.rs
+++ b/crates/pptx/src/read/dml.rs
@@ -234,7 +234,7 @@ pub fn line(imp: &mut Imp, part: &Part, ln: &El) -> Line {
             "bevel" => l.join = Some(LineJoin::Bevel),
             "miter" => {
                 l.join = Some(LineJoin::Miter);
-                l.miter_limit = e.attr("lim").and_then(|v| v.parse::<u32>().ok()).filter(|v| *v <= 1_000_000);
+                l.miter_limit = e.attr("lim").and_then(parse_miter_limit);
             }
             "headEnd" => l.head = line_end(e),
             "tailEnd" => l.tail = line_end(e),
@@ -244,6 +244,17 @@ pub fn line(imp: &mut Imp, part: &Part, ln: &El) -> Line {
     l
 }
 
+fn parse_miter_limit(value: &str) -> Option<u32> {
+    const MAX: u32 = i32::MAX as u32;
+    let value = value.trim();
+    if let Some(percent) = value.strip_suffix('%') {
+        let units = percent.trim().parse::<f64>().ok()? * 1000.0;
+        (units.is_finite() && (0.0..=MAX as f64).contains(&units)).then(|| units.round() as u32)
+    } else {
+        value.parse::<u32>().ok().filter(|limit| *limit <= MAX)
+    }
+}
+
 fn line_end(e: &El) -> Option<LineEnd> {
     let kind = e.attr("type").unwrap_or("none");
     Some(LineEnd { kind: kind.to_string(), w: e.attr("w").unwrap_or("med").to_string(), len: e.attr("len").unwrap_or("med").to_string() })
@@ -671,6 +682,16 @@ mod tests {
         assert_eq!(color(&d.root).unwrap().base, ColorBase::Rgb { rgb: Rgba::rgb(255, 0, 0) });
     }
 
+    #[test]
+    fn miter_limit_accepts_both_percentage_forms_with_schema_bounds() {
+        assert_eq!(parse_miter_limit("200000"), Some(200_000));
+        assert_eq!(parse_miter_limit("200%"), Some(200_000));
+        assert_eq!(parse_miter_limit("1000001"), Some(1_000_001));
+        assert_eq!(parse_miter_limit("malformed"), None);
+        assert_eq!(parse_miter_limit("2147483648"), None);
+        assert_eq!(parse_miter_limit("2147483.648%"), None);
+    }
+
     #[test]
     fn body_props() {
         let d = parse(br#"<a:bodyPr lIns="91440" anchor="ctr" wrap="none" vert="vert270" numCol="2"><a:normAutofit fontScale="62500" lnSpcReduction="20000"/></a:bodyPr>"#).unwrap();
diff --git a/crates/pptx/src/write/dml.rs b/crates/pptx/src/write/dml.rs
index a6d00ff49..d46a7aae5 100644
--- a/crates/pptx/src/write/dml.rs
+++ b/crates/pptx/src/write/dml.rs
@@ -233,7 +233,10 @@ pub fn line(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, l: &Line) {
     match l.join {
         Some(LineJoin::Round) => w.empty0("a:round"),
         Some(LineJoin::Bevel) => w.empty0("a:bevel"),
-        Some(LineJoin::Miter) => w.empty("a:miter", A::new().o("lim", l.miter_limit)),
+        Some(LineJoin::Miter) => {
+            let limit = l.miter_limit.filter(|limit| *limit <= i32::MAX as u32);
+            w.empty("a:miter", A::new().o("lim", limit));
+        }
         None => {}
     }
     for (t, e) in [("a:headEnd", &l.head), ("a:tailEnd", &l.tail)] {
diff --git a/crates/pptx/tests/it/roundtrip.rs b/crates/pptx/tests/it/roundtrip.rs
index 599040718..d05252413 100644
--- a/crates/pptx/tests/it/roundtrip.rs
+++ b/crates/pptx/tests/it/roundtrip.rs
@@ -495,11 +495,14 @@ fn line_miter_limit_survives_two_pptx_round_trips() {
     limited.line = Some(Line { join: Some(deckcraft_model::style::LineJoin::Miter), miter_limit: Some(200_000), ..Default::default() });
     let mut defaulted = shape(&mut p, "Default miter", 140.0, 20.0, 100.0, 100.0);
     defaulted.line = Some(Line { join: Some(deckcraft_model::style::LineJoin::Miter), ..Default::default() });
-    Arc::make_mut(&mut p.slides[0]).shapes.extend([limited, defaulted]);
+    let mut large = shape(&mut p, "Large miter", 260.0, 20.0, 100.0, 100.0);
+    large.line = Some(Line { join: Some(deckcraft_model::style::LineJoin::Miter), miter_limit: Some(1_000_001), ..Default::default() });
+    Arc::make_mut(&mut p.slides[0]).shapes.extend([limited, defaulted, large]);
 
     let q = round(&round(&p));
     assert_eq!(by_name(&q.slides[0], "Limited miter").line.as_ref().and_then(|line| line.miter_limit), Some(200_000));
     assert_eq!(by_name(&q.slides[0], "Default miter").line.as_ref().and_then(|line| line.miter_limit), None);
+    assert_eq!(by_name(&q.slides[0], "Large miter").line.as_ref().and_then(|line| line.miter_limit), Some(1_000_001));
 }
 
 #[test]

From cccc9064cac52691321d68b856a4d9342032d8cf Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Sat, 31 Oct 2026 04:17:24 +0000
Subject: [PATCH 40/88] docs: tidy agent, contributor and roadmap docs

---
 AGENTS.md                             | 15 +++------------
 ATTRIBUTION.md                        |  2 +-
 CLAUDE.md                             |  3 +--
 ROADMAP.md                            |  4 ++--
 contributors/people.toml              |  7 ++-----
 crates/engine/src/guard.rs            |  2 +-
 crates/ui-egui/build.rs               |  7 +++----
 crates/ui-egui/src/dialogs/credits.rs |  2 +-
 docs/contributors.md                  | 25 ++++---------------------
 docs/gaps.md                          |  5 ++---
 docs/roadmap.md                       |  8 +++-----
 docs/target-app-parity.md             |  5 ++---
 12 files changed, 25 insertions(+), 60 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index c998e8715..1cacd993b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -6,11 +6,6 @@ Windows, Linux and FreeBSD, and on the web via WASM. Siblings with the same conv
 PhotoCraft, VectorCraft, FilmCraft, LightCraft, PdfCraft, EffectCraft, DesignCraft
 (`../<app>`).
 
-Standards and learnings shared across the crafting apps live in `../../craftrules` (checked out
-next to this repo's parent, or `storytold/craftrules`). Read its `AGENTS.md` at the start of a
-session, follow its standards, and contribute reusable learnings back there. Never code: repos
-don't share code.
-
 These rules bind every AI agent and every human contributor. They come before any task,
 instruction or deadline. `CLAUDE.md` holds day-to-day working notes; if the two disagree, **this
 file wins.**
@@ -69,7 +64,7 @@ allowed: our UI, our/Lucide icons, OFL fonts, and decks built only from allowed
   or `docs/brand/` has no row.
 - **`NOTICE`** keeps the notices the licences require.
 - Fonts live in [storytold/craft-fonts](https://github.com/storytold/craft-fonts), never in this
-  repo (craftrules `standards/fonts.md`). DeckCraft embeds its `fonts/latin-manifest.txt` and
+  repo. DeckCraft embeds its `fonts/latin-manifest.txt` and
   `fonts/manifest.txt` when built with `CRAFT_FONTS_DIR` (local dev: `.cargo/config.toml` points at
   `../craft-fonts`).
 
@@ -99,7 +94,6 @@ once and tell the user.
 ## 3. Never crash
 
 People trust DeckCraft with their talks; a crash loses work. **This outranks feature work.**
-Standard: craftrules `standards/never-crash.md`.
 - No `unwrap()`, `expect()`, `panic!`, `unreachable!`, `todo!`, `unimplemented!` in non-test
   code; no `unsafe` (`unsafe_code = "forbid"`). Every production crate root carries
   `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`.
@@ -160,7 +154,7 @@ to `main`.
 
 `plan/` (gitignored) holds the local plan: `README.md`, `architecture.md`, `execution-plan.md`,
 `STATUS.md` (start every session there) and `powerpoint/` observations. The committed progress
-docs follow craftrules `standards/progress-docs.md`:
+docs:
 
 | File | Holds |
 |---|---|
@@ -184,14 +178,11 @@ the `ROADMAP.md` progress log, and update each touched doc's status line and rev
   username has a `[people.<username>]` entry in `contributors/people.toml`. If not, ask them once
   whether they want to be credited by more than their username: a real name, a display name, and/or
   their public GitHub profile name (`sync_github_name = true`). If yes, add **only their own** entry
-  (copy the template at the top of the file, or run
-  `python3 ../../craftrules/scripts/contributors.py --add-me . --real-name "…" --sync-github-name`)
+  (copy the template at the top of the file)
   and include it in their PR, committed as them. If no, change nothing: they are credited as
   `@username` anyway.
 - Never add, edit, guess or copy anyone else's entry or name (not from git config, commit authors or
   GitHub profiles). Never hand-edit `contributors.json`.
-- Maintainers refresh the stats with `python3 ../../craftrules/scripts/contributors.py .` (it also
-  re-verifies who wrote each `people.toml` entry; `--check` only verifies).
 
 ## CI workflows
 - Workflows in `.github/workflows/` call the shared workflows in [`storytold/craft-common-actions`](https://github.com/storytold/craft-common-actions) at `@main`, with their inputs and secrets. No other jobs: if no shared workflow does what's needed, it doesn't go here.
diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md
index ff680bda2..8382a760b 100644
--- a/ATTRIBUTION.md
+++ b/ATTRIBUTION.md
@@ -18,7 +18,7 @@ artwork. The ribbon and menu icons stay original drawings.
 | `docs/brand/artcraft-logo-white.svg`, `docs/brand/artcraft-logo-white.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft trademark, `docs/brand/LICENSE-brand.txt` | README header (dark mode) |
 | `docs/brand/artcraft-mark.svg`, `docs/brand/artcraft-mark.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft trademark, `docs/brand/LICENSE-brand.txt` | README footer, About |
 | `docs/brand/artcraft-mark-black.svg`, `docs/brand/artcraft-mark-black.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft trademark, `docs/brand/LICENSE-brand.txt` | Mark for light backgrounds |
-| `docs/brand/LICENSE-brand.txt` | ArtCraft Team | craftrules `standards/license-files` | — (licence text) | Terms for the ArtCraft marks |
+| `docs/brand/LICENSE-brand.txt` | ArtCraft Team | ArtCraft brand kit | — (licence text) | Terms for the ArtCraft marks |
 | `assets/app-icon/deckcraft-1024.png`, `assets/app-icon/hicolor/*/apps/ai.storyteller.deckcraft.png` | DeckCraft contributors | rendered by DeckCraft from `assets/app-icon/icon-source.deckcraft` (shapes only) | MIT OR Apache-2.0 | Placeholder app icon (presentation board) until the mascot icon is drawn |
 | `packaging/macos/dmg/background.svg` | @XusBadia | DeckCraft macOS DMG window background, original work for this repository (2026-10-08), derived from the DeckCraft app icon `assets/app-icon/deckcraft-1024.png` (referenced via `<image>`, not copied); text is outlined Inter / JetBrains Mono glyph paths | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | Finder window of the macOS DMG; `packaging/macos/dmg/generate.py` renders it to `background.tiff` |
 | `packaging/macos/dmg/background.tiff` | @XusBadia | Rendered from `packaging/macos/dmg/background.svg` by `packaging/macos/dmg/generate.py` | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | 1x + 2x HiDPI TIFF for the macOS DMG window; includes the app icon (see its row) and LittleCMS's built-in sRGB profile ("No copyright, use freely") |
diff --git a/CLAUDE.md b/CLAUDE.md
index 669965b59..979388d87 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -9,8 +9,7 @@ before modules or other crate items; crate-level `//!` documentation may precede
 
 ## Start every session
 1. Read `plan/STATUS.md`, then the current milestone in `plan/execution-plan.md`.
-2. Read `../../craftrules/AGENTS.md` and the standards it lists for your task.
-3. Run `cargo xtask ci` before you change anything, so you know the tree is green.
+2. Run `cargo xtask ci` before you change anything, so you know the tree is green.
 
 ## Habits
 - Every user-visible action is a command with tests (`crates/engine/src/cmd/*`).
diff --git a/ROADMAP.md b/ROADMAP.md
index a99369256..d4cd80d07 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -303,7 +303,7 @@ app's JSON control channel (`deckcraft --control PORT`).
 | 2026-10-12 | Render: line widths, dashes and arrowheads inside a group no longer scale with the group's child-coordinate mapping, so a group in a small legacy child space (scale about 1600) draws thin lines instead of covering the slide (#233) |
 | 2026-10-12 | `deckcraft-cli help` and each subcommand's `--help` explain the CLI to an agent; `describe` spells out a command's parameters and what it acts on; `commands` lists one command per line |
 | 2026-10-11 | Animated GIF export of the deck: the Export… dialog (Animated GIF), `file.export` format `gif`, CLI and MCP (#171) |
-| 2026-10-10 | Progress docs restructured to the craftrules standard; full re-measure (breadth 79%, ready ~55%, mainstream ~53%, essentials ~62%, alpha). Landed: Animation Painter (#54), Morph geometry outlines (#27), animated GIF playback (#39), hyperlink colour and following links in the show (#37, #45), date fields in their own format (#36), flipped shapes keep readable text (#35), show transition fix (#46), start screen from the Home button (#49), MCP export lists PDF (#65), OmaStore manifest (#57) |
+| 2026-10-10 | Progress docs restructured; full re-measure (breadth 79%, ready ~55%, mainstream ~53%, essentials ~62%, alpha). Landed: Animation Painter (#54), Morph geometry outlines (#27), animated GIF playback (#39), hyperlink colour and following links in the show (#37, #45), date fields in their own format (#36), flipped shapes keep readable text (#35), show transition fix (#46), start screen from the Home button (#49), MCP export lists PDF (#65), OmaStore manifest (#57) |
 | 2026-10-09 | v0.4.0 released. UAX #9 bidi and Arabic shaping (#4), Morph with Words and Characters (#5), tables grow to fit and PDF cell text (#14), rotating log file (#7), DX12 default on Windows (#16), H.264/HEVC overflow hardening (#2), PPTX sniffing anywhere in the zip (#19) |
 | 2026-10-08 | v0.2.0 and v0.3.0 released: Windows arm64, Flatpak aarch64, AppImage zsync updates, branded DMG |
 | 2026-10-07 | v0.1.0 released, signed and notarized; About window with contributor credits (#3); PrintCraft renamed PdfCraft |
@@ -413,5 +413,5 @@ app's JSON control channel (`deckcraft --control PORT`).
 | 2026-10-10 | minor | Readiness-by-audience table with hours to ~95% for full, mainstream and essentials |
 | 2026-10-10 | minor | Added mainstream practitioner (~53%) and essentials user (~62%); features recomputed from written area weights, ready ~56% → ~55% |
 | 2026-10-10 | minor | Stage checked against the new core-workflow gate: passes, stays alpha |
-| 2026-10-10 | major | Restructured to craftrules `standards/progress-docs.md`: stage, two numbers, dimensions, features, languages; parity estimate moved to docs/target-app-parity.md, "Working today" to its evidence section, the alpha checklist to docs/roadmap.md |
+| 2026-10-10 | major | Restructured: stage, two numbers, dimensions, features, languages; parity estimate moved to docs/target-app-parity.md, "Working today" to its evidence section, the alpha checklist to docs/roadmap.md |
 | 2026-10-07 | major | Alpha checklist (~80% to a self-defined alpha), breadth ~80%, overall ~62%, ~190 h to full parity |
diff --git a/contributors/people.toml b/contributors/people.toml
index caf4daa46..cddf36867 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -1,13 +1,10 @@
-# Contributor names for the About window (craftrules standards/contributors.md).
+# Contributor names for the About window.
 #
 # Everyone who contributes is credited by GitHub username automatically. Anything more is up to
 # you: add YOUR OWN entry below, in your own PR (commit it yourself). Never add someone else; a
 # maintainer may add a person only when that person asked, recording where in consent_source.
 #
-# Easiest: python3 ../../craftrules/scripts/contributors.py --add-me . \
-#            [--real-name "Ada Lovelace"] [--display-name "Ada"] [--sync-github-name]
-#
-# Or copy this block, replacing your-github-username (every field is optional):
+# Copy this block, replacing your-github-username (every field is optional):
 #
 #   [people.your-github-username]
 #   real_name = "Your Name"        # shown when the viewer picks "Real name"
diff --git a/crates/engine/src/guard.rs b/crates/engine/src/guard.rs
index 1005a1a9a..4f0c89034 100644
--- a/crates/engine/src/guard.rs
+++ b/crates/engine/src/guard.rs
@@ -1,4 +1,4 @@
-//! Last-resort guard (craftrules `standards/never-crash.md`): a panic that escapes a command —
+//! Last-resort guard: a panic that escapes a command —
 //! any edit, import or export, from the UI, the CLI, MCP or the control channel — becomes an
 //! error, and the document is kept as it was before the command (and saved for crash recovery
 //! when a recovery directory is set). It is a safety net: commands still must not panic.
diff --git a/crates/ui-egui/build.rs b/crates/ui-egui/build.rs
index f40007fb2..8b262f12c 100644
--- a/crates/ui-egui/build.rs
+++ b/crates/ui-egui/build.rs
@@ -1,8 +1,7 @@
-//! Bake the contributor credits into the binary as static Rust tables (craftrules
-//! standards/contributors.md). Nothing is read at run time.
+//! Bake the contributor credits into the binary as static Rust tables. Nothing is read at run time.
 //!
-//! - contributors/contributors.json: commit stats per GitHub username, generated by craftrules
-//!   scripts/contributors.py, which also marks whose people.toml entry it verified.
+//! - contributors/contributors.json: commit stats per GitHub username, with a mark for whose
+//!   people.toml entry is verified.
 //! - contributors/people.toml: the names people chose for themselves. A name is used only when the
 //!   JSON says the entry was verified (`people_entry`).
 //!
diff --git a/crates/ui-egui/src/dialogs/credits.rs b/crates/ui-egui/src/dialogs/credits.rs
index b133efe18..d1bf5b30e 100644
--- a/crates/ui-egui/src/dialogs/credits.rs
+++ b/crates/ui-egui/src/dialogs/credits.rs
@@ -1,6 +1,6 @@
 //! The About window's credits: every contributor (GitHub login always; display and real names only
 //! with recorded consent) and the AI models that helped. The tables are baked into the binary by
-//! build.rs from contributors/contributors.json (craftrules standards/contributors.md); nothing is
+//! build.rs from contributors/contributors.json; nothing is
 //! read at run time.
 
 use std::cmp::Ordering;
diff --git a/docs/contributors.md b/docs/contributors.md
index 6086167e5..14efee2b7 100644
--- a/docs/contributors.md
+++ b/docs/contributors.md
@@ -1,16 +1,14 @@
 # Contributors in the About window
 
 **About ▸ Contributors** credits everyone who contributed to DeckCraft, and **About ▸ Models** credits
-the AI models named in `Co-Authored-By` trailers. This follows the shared craftrules standard
-[`standards/contributors.md`](https://github.com/storytold/craftrules/blob/main/standards/contributors.md);
-this page is the local copy of the decision.
+the AI models named in `Co-Authored-By` trailers.
 
 ## Decision
 
 - Two files, both **compiled into the binary** by the UI crate's `build.rs` (nothing is read from
   disk or the network at run time; the web build has them too):
   - [`contributors/contributors.json`](../contributors/contributors.json): commit stats per GitHub
-    username. **Generated** by `craftrules/scripts/contributors.py`; never hand-edit.
+    username. Never hand-edit.
   - [`contributors/people.toml`](../contributors/people.toml): the names people chose for
     themselves. **Each contributor adds only their own entry**, in their own PR.
 - Each contributor gets one line: GitHub username (always), display name (opt-in, or their synced
@@ -36,20 +34,5 @@ display_name = "Nickname"
 sync_github_name = true   # use the name on your public GitHub profile as display name
 ```
 
-or, with craftrules checked out next to `craft-apps/`:
-
-```sh
-python3 ../../craftrules/scripts/contributors.py --add-me . --real-name "Your Name" --sync-github-name
-```
-
-Names show after the next refresh: the script checks that each entry was committed by its own
-user (or by a maintainer with a `consent_source`). Delete your entry to remove your names.
-
-## Refreshing (maintainers)
-
-```sh
-python3 ../../craftrules/scripts/contributors.py .           # regenerate + verify; needs git, Python 3.11+, gh
-python3 ../../craftrules/scripts/contributors.py --check .   # verify people.toml only
-```
-
-Commit the updated `contributors/contributors.json`. Git author names and emails are never recorded.
+Names show for entries committed by their own user (or by a maintainer with a `consent_source`).
+Delete your entry to remove your names. Git author names and emails are never recorded.
diff --git a/docs/gaps.md b/docs/gaps.md
index c1746a17f..4ba02fc16 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -95,8 +95,7 @@ Detail in [file-format-parity.md](file-format-parity.md).
   outside this repo.
 - **Impact:** the main reason to switch is "open my PowerPoint decks". Fidelity on real decks
   (corporate templates, SmartArt, `chartex` charts, embedded fonts, EMF) is still mostly unknown.
-- **Estimate:** 20–35 h: grow the owned corpus in `storytold/photocraft-corpus` style (craftrules
-  `standards/test-corpora.md`), add render checks, have the owner open outputs in PowerPoint, fix
+- **Estimate:** 20–35 h: grow the owned corpus in `storytold/photocraft-corpus` style, add render checks, have the owner open outputs in PowerPoint, fix
   what breaks. **Beta blocker.**
 
 ### Round trip loses media playback options (#74)
@@ -305,7 +304,7 @@ Detail in [ui-parity.md](ui-parity.md).
   choice, video/GIF/CD exports or document protection. 4–8 h for the parts that need no cloud.
 - **Window chrome** (#71 macOS controls misaligned, #26 GNOME title bar, #41 system light/dark).
   2–4 h.
-- **Icon consistency across Craft apps** (#73, #56). 2–4 h; coordinate in craftrules.
+- **Icon consistency across Craft apps** (#73, #56). 2–4 h.
 - **Dialogs**: 42 dialogs vs PowerPoint's ~60. In since the d556ff9 count of 27: Font, Paragraph
   and Tabs, Columns, Bullets and Numbering, Find and Replace, Replace Fonts, Action Settings, Size and
   Position, Date and Time, Photo Album (Edit Photo Album reopens it), Create New Theme Colors and
diff --git a/docs/roadmap.md b/docs/roadmap.md
index 16cfae6cc..4cea48fe4 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -8,8 +8,7 @@ Forward-looking: where DeckCraft is going and in what order. The one-page summar
 
 ## Alpha gate: PowerPoint's core workflows
 
-What a typical PowerPoint user does every day, checked end to end on macOS, the main platform
-(craftrules `standards/progress-docs.md`, "The core-workflow gate"). Every workflow passes, so
+What a typical PowerPoint user does every day, checked end to end on macOS, the main platform. Every workflow passes, so
 DeckCraft stays **alpha**. The "partial" rows don't block the workflow, but they are its weakest
 points and lead the beta plan.
 
@@ -38,8 +37,7 @@ points and lead the beta plan.
 
 ## Plan to beta (~120–210 h; ~40–70 h wall clock with 3–4 agents)
 
-Beta means ~75% ready for real work and opening and saving PowerPoint's `.pptx` reliably
-(craftrules `standards/progress-docs.md`). Ranked:
+Beta means ~75% ready for real work and opening and saving PowerPoint's `.pptx` reliably. Ranked:
 
 | # | Work | Hours | Moves |
 |---|---|---|---|
@@ -94,7 +92,7 @@ From the local execution plan (`plan/execution-plan.md`, gitignored). Status as
 
 ## History: the 2026-10-07 alpha checklist
 
-Before the craftrules stages existed, DeckCraft defined "alpha" as: install a signed build on
+Before the stages existed, DeckCraft defined "alpha" as: install a signed build on
 macOS, Windows or Linux, make a real deck from scratch or from a PowerPoint file, present it with
 transitions, animations and media, save back to `.pptx`/PDF without losing work, and hit no crashes
 on common paths. On 2026-10-07 it was ~80% there with these blockers:
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 5d4320221..4f30ce5fe 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -16,7 +16,7 @@ number.
 | **Ready for real work** | **~55%** | **estimated**: weighted dimension table below (was ~56% until the features row was recomputed from written area weights) |
 | **Mainstream practitioner** | **~53%** | **estimated**: [method below](#mainstream-practitioner-and-essentials-user) |
 | **Essentials user** | **~62%** | **estimated**: [method below](#mainstream-practitioner-and-essentials-user) |
-| Stage | **alpha** (beta is ~20 points and ~120–210 h away) | judgement against craftrules `standards/progress-docs.md`: ~55% is in the alpha band and all six core workflows pass the [alpha gate](roadmap.md#alpha-gate-powerpoints-core-workflows) |
+| Stage | **alpha** (beta is ~20 points and ~120–210 h away) | judgement: ~55% is in the alpha band and all six core workflows pass the [alpha gate](roadmap.md#alpha-gate-powerpoints-core-workflows) |
 | Remaining effort to beta | **~120–210 Opus 5.5 agent hours** | estimated, itemized in [roadmap.md](roadmap.md) |
 | Remaining effort to full parity | **~365–650 Opus 5.5 agent hours** | estimated, by dimension below |
 
@@ -85,8 +85,7 @@ multi-display rigs).
 
 ## Mainstream practitioner and essentials user
 
-Two narrower readings of "ready", computed the same way in every Craft app (craftrules
-`standards/progress-docs.md`). The stage still follows the full number above and the alpha gate.
+Two narrower readings of "ready", computed the same way in every Craft app. The stage still follows the full number above and the alpha gate.
 
 ### Mainstream practitioner: ~53%
 

From 72c8621358c40a8b2443c939a78207db74c35592 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 23:17:32 -0500
Subject: [PATCH 41/88] Keep gradient flip when editing a fill

---
 crates/engine/src/cmd/shape/appearance.rs | 19 ++++++++++++++++-
 crates/ui-egui/src/panels/fillui.rs       | 26 ++++++++++++++++++++---
 2 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/crates/engine/src/cmd/shape/appearance.rs b/crates/engine/src/cmd/shape/appearance.rs
index 09a0e2360..24bfbabf8 100644
--- a/crates/engine/src/cmd/shape/appearance.rs
+++ b/crates/engine/src/cmd/shape/appearance.rs
@@ -108,7 +108,13 @@ pub(crate) fn gradient_param(v: &Value) -> Option<Gradient> {
             scaled: false,
         },
     };
-    Some(Gradient { tile: [0.0; 4], stops, shape, rotate_with_shape: v.get("rotateWithShape").and_then(Value::as_bool).unwrap_or(true), flip: None })
+    Some(Gradient {
+        tile: [0.0; 4],
+        stops,
+        shape,
+        rotate_with_shape: v.get("rotateWithShape").and_then(Value::as_bool).unwrap_or(true),
+        flip: v.get("flip").and_then(Value::as_str).and_then(deckcraft_model::style::GradientFlip::from_xml),
+    })
 }
 
 /// Fill and outline apply to a group's visible members as well as its container. Other edits
@@ -555,3 +561,14 @@ pub(super) fn quick_style(s: &mut Session, p: &Value) -> Result<Value> {
         Ok(())
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gradient_parameters_keep_flip_mode() {
+        let gradient = gradient_param(&json!({"stops": [[0, "#ff0000"], [1, "#0000ff"]], "flip": "xy"})).expect("gradient");
+        assert_eq!(gradient.flip, Some(deckcraft_model::style::GradientFlip::Xy));
+    }
+}
diff --git a/crates/ui-egui/src/panels/fillui.rs b/crates/ui-egui/src/panels/fillui.rs
index 06b1ac930..abee9bea4 100644
--- a/crates/ui-egui/src/panels/fillui.rs
+++ b/crates/ui-egui/src/panels/fillui.rs
@@ -4,7 +4,7 @@
 
 use deckcraft_color::{ColorScheme, ColorTransform, SchemeSlot};
 use deckcraft_model::ColorRef;
-use deckcraft_model::style::{Gradient, GradientShape, GradientStop, PatternFill};
+use deckcraft_model::style::{Gradient, GradientFlip, GradientShape, GradientStop, PatternFill};
 use egui::{Color32, CornerRadius, Rect, Sense, Stroke, Ui, pos2, vec2};
 use serde_json::{Value, json};
 
@@ -29,19 +29,39 @@ pub fn default_gradient(base: ColorRef, angle: f64) -> Gradient {
 /// The command parameter for `g` (`shape.fill {gradient}` / `design.background {gradient}`).
 pub fn gradient_json(g: &Gradient) -> Value {
     let stops: Vec<Value> = g.stops.iter().map(|s| json!([s.pos, cref_param(&s.color)])).collect();
+    let flip = g.flip.map(GradientFlip::xml);
     match &g.shape {
-        GradientShape::Linear { angle, .. } => json!({"stops": stops, "kind": "linear", "angle": angle, "rotateWithShape": g.rotate_with_shape}),
+        GradientShape::Linear { angle, .. } => {
+            json!({"stops": stops, "kind": "linear", "angle": angle, "rotateWithShape": g.rotate_with_shape, "flip": flip})
+        }
         GradientShape::Path { path, focus } => {
             let kind = match path.as_str() {
                 "rect" => "rectangular",
                 "shape" => "path",
                 _ => "radial",
             };
-            json!({"stops": stops, "kind": kind, "focus": focus, "rotateWithShape": g.rotate_with_shape})
+            json!({"stops": stops, "kind": kind, "focus": focus, "rotateWithShape": g.rotate_with_shape, "flip": flip})
         }
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gradient_json_retains_flip_mode() {
+        let gradient = Gradient {
+            stops: vec![],
+            shape: GradientShape::Linear { angle: 90.0, scaled: false },
+            flip: Some(GradientFlip::Xy),
+            rotate_with_shape: true,
+            tile: [0.0; 4],
+        };
+        assert_eq!(gradient_json(&gradient).get("flip"), Some(&json!("xy")));
+    }
+}
+
 fn alpha_of(c: &ColorRef) -> f64 {
     c.mods.iter().find_map(|m| if let ColorTransform::Alpha(a) = m { Some(*a as f64 / 100_000.0) } else { None }).unwrap_or(1.0)
 }

From 0e3f4cd353c00fb6bd4ba53eecd2f11868a63d64 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 23:20:43 -0500
Subject: [PATCH 42/88] Preserve explicit bullets over follow-text resets

---
 crates/pptx/src/write/dml.rs      |  6 +++---
 crates/pptx/tests/it/roundtrip.rs | 26 ++++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/crates/pptx/src/write/dml.rs b/crates/pptx/src/write/dml.rs
index 5c47aa30d..ac8d44569 100644
--- a/crates/pptx/src/write/dml.rs
+++ b/crates/pptx/src/write/dml.rs
@@ -554,19 +554,19 @@ pub fn ppr(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, level: Option<u8>, p:
     if let Some(s) = &p.space_after {
         spacing(w, "a:spcAft", s);
     }
-    if p.bullet_color_follow_text == Some(true) {
+    if p.bullet_color.is_none() && p.bullet_color_follow_text == Some(true) {
         w.empty0("a:buClrTx");
     } else if let Some(c) = &p.bullet_color {
         w.open0("a:buClr");
         color(w, c);
         w.close("a:buClr");
     }
-    if p.bullet_size_follow_text == Some(true) {
+    if p.bullet_size.is_none() && p.bullet_size_follow_text == Some(true) {
         w.empty0("a:buSzTx");
     } else if let Some(s) = p.bullet_size {
         w.val("a:buSzPct", pct(s.clamp(0.25, 4.0)));
     }
-    if p.bullet_font_follow_text == Some(true) {
+    if p.bullet_font.is_none() && p.bullet_font_follow_text == Some(true) {
         w.empty0("a:buFontTx");
     } else if let Some(f) = &p.bullet_font {
         w.empty("a:buFont", A::new().a("typeface", f));
diff --git a/crates/pptx/tests/it/roundtrip.rs b/crates/pptx/tests/it/roundtrip.rs
index d0c1a597e..fce75d24c 100644
--- a/crates/pptx/tests/it/roundtrip.rs
+++ b/crates/pptx/tests/it/roundtrip.rs
@@ -507,12 +507,38 @@ fn bullet_follow_text_resets_survive_two_pptx_round_trips() {
         ..Default::default()
     });
     Arc::make_mut(&mut p.slides[0]).shapes.push(textbox);
+    let mut conflicting = shape(&mut p, "Explicit bullet values", 20.0, 140.0, 400.0, 100.0);
+    conflicting.text = Some(TextBody {
+        paragraphs: vec![Paragraph {
+            props: deckcraft_model::text::ParaProps {
+                bullet: Some(Bullet::Char { char: "•".into() }),
+                bullet_color: Some(deckcraft_model::style::ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0))),
+                bullet_color_follow_text: Some(true),
+                bullet_size: Some(1.5),
+                bullet_size_follow_text: Some(true),
+                bullet_font: Some("Inter".into()),
+                bullet_font_follow_text: Some(true),
+                ..Default::default()
+            },
+            runs: vec![Run::with("Explicit bullet text", RunProps::default())],
+            ..Default::default()
+        }],
+        ..Default::default()
+    });
+    Arc::make_mut(&mut p.slides[0]).shapes.push(conflicting);
 
     let q = round(&round(&p));
     let props = &by_name(&q.slides[0], "Follow text bullets").text.as_ref().expect("text").paragraphs[0].props;
     assert_eq!(props.bullet_color_follow_text, Some(true));
     assert_eq!(props.bullet_size_follow_text, Some(true));
     assert_eq!(props.bullet_font_follow_text, Some(true));
+    let explicit = &by_name(&q.slides[0], "Explicit bullet values").text.as_ref().expect("text").paragraphs[0].props;
+    assert_eq!(explicit.bullet_color_follow_text, None);
+    assert_eq!(explicit.bullet_size_follow_text, None);
+    assert_eq!(explicit.bullet_font_follow_text, None);
+    assert_eq!(explicit.bullet_size, Some(1.5));
+    assert_eq!(explicit.bullet_font.as_deref(), Some("Inter"));
+    assert_eq!(explicit.bullet_color, Some(deckcraft_model::style::ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0))));
 }
 
 #[test]

From a96dcdbe8f4af8d6d7d8737e8085fd36fb03d68f Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Sat, 31 Oct 2026 04:25:45 +0000
Subject: [PATCH 43/88] docs: tidy wording

---
 docs/roadmap.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/roadmap.md b/docs/roadmap.md
index 4cea48fe4..17a23ae5f 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -106,7 +106,7 @@ on common paths. On 2026-10-07 it was ~80% there with these blockers:
 | UI fidelity pass on the most-used ribbon groups and dialogs; first run | Partly (start-screen fixes #20, #49); beta item 11 |
 | Mascot app icon, README screenshots, user docs | App icon (with a scalable SVG, #29) and README screenshots in place; user docs open |
 
-By the standard's definitions DeckCraft is **alpha** (~55% ready); these blockers now feed the beta
+DeckCraft is **alpha** (~55% ready); these blockers now feed the beta
 plan above.
 
 ## Revision history

From 5a235590ddb1c9196e5e1715826d0bc8f8532d84 Mon Sep 17 00:00:00 2001
From: Harrison Booth <73434116+Harrison-Booth@users.noreply.github.com>
Date: Fri, 30 Oct 2026 23:26:55 -0500
Subject: [PATCH 44/88] Move gradient editor test module to file end

---
 crates/ui-egui/src/panels/fillui.rs | 34 ++++++++++++++---------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/crates/ui-egui/src/panels/fillui.rs b/crates/ui-egui/src/panels/fillui.rs
index abee9bea4..3e247621a 100644
--- a/crates/ui-egui/src/panels/fillui.rs
+++ b/crates/ui-egui/src/panels/fillui.rs
@@ -45,23 +45,6 @@ pub fn gradient_json(g: &Gradient) -> Value {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn gradient_json_retains_flip_mode() {
-        let gradient = Gradient {
-            stops: vec![],
-            shape: GradientShape::Linear { angle: 90.0, scaled: false },
-            flip: Some(GradientFlip::Xy),
-            rotate_with_shape: true,
-            tile: [0.0; 4],
-        };
-        assert_eq!(gradient_json(&gradient).get("flip"), Some(&json!("xy")));
-    }
-}
-
 fn alpha_of(c: &ColorRef) -> f64 {
     c.mods.iter().find_map(|m| if let ColorTransform::Alpha(a) = m { Some(*a as f64 / 100_000.0) } else { None }).unwrap_or(1.0)
 }
@@ -532,3 +515,20 @@ pub fn pattern_editor(ui: &mut Ui, pt: &PatternFill, sc: &ColorScheme) -> Option
     }
     out
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gradient_json_retains_flip_mode() {
+        let gradient = Gradient {
+            stops: vec![],
+            shape: GradientShape::Linear { angle: 90.0, scaled: false },
+            flip: Some(GradientFlip::Xy),
+            rotate_with_shape: true,
+            tile: [0.0; 4],
+        };
+        assert_eq!(gradient_json(&gradient).get("flip"), Some(&json!("xy")));
+    }
+}

From 1de7b44a8d57d17bc21183ba2a3344c81c504821 Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Sat, 31 Oct 2026 05:33:56 +0100
Subject: [PATCH 45/88] Parse uppercase exponent in custom geometry path
 numbers

Found while testing crates/pptx/src/custgeom.rs:334

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/pptx/src/custgeom.rs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/crates/pptx/src/custgeom.rs b/crates/pptx/src/custgeom.rs
index ae122144f..815530268 100644
--- a/crates/pptx/src/custgeom.rs
+++ b/crates/pptx/src/custgeom.rs
@@ -331,13 +331,15 @@ pub fn parse_path(d: &str) -> Vec<(char, Vec<f64>)> {
     };
     for ch in d.chars() {
         match ch {
+            // An 'E' inside a number is an exponent, not the end command.
+            'E' if !token.is_empty() => token.push(ch),
             'M' | 'L' | 'C' | 'Q' | 'Z' | 'm' | 'l' | 'c' | 'q' | 'z' | 'E' => {
                 push_tok(&mut token, &mut nums);
                 flush(cmd, &mut nums, &mut out);
                 cmd = Some(ch.to_ascii_uppercase());
             }
             ' ' | ',' | '\t' | '\n' => push_tok(&mut token, &mut nums),
-            '-' if !token.is_empty() && !token.ends_with('e') => {
+            '-' if !token.is_empty() && !token.ends_with(['e', 'E']) => {
                 push_tok(&mut token, &mut nums);
                 token.push(ch);
             }
@@ -472,6 +474,13 @@ mod tests {
         assert_eq!(back[0].d, "M 0 0 L 100000 0 C 100000 10000 90000 50000 50000 50000 Q 0 50000 0 0 Z");
     }
 
+    #[test]
+    fn parse_path_uppercase_exponent() {
+        assert_eq!(parse_path("M 1E-5 2 L 3 4"), vec![('M', vec![1e-5, 2.0]), ('L', vec![3.0, 4.0])]);
+        assert_eq!(parse_path("M 1.5E3 2"), vec![('M', vec![1500.0, 2.0])]);
+        assert_eq!(parse_path("M 1e-5 2"), vec![('M', vec![1e-5, 2.0])]);
+    }
+
     #[test]
     fn parse_path_tokens() {
         let v = parse_path("M0,0 L10-5 Z");

From 9678ed7d7f35d204a0fc5f52c34615863832595e Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Sat, 31 Oct 2026 04:42:16 +0000
Subject: [PATCH 46/88] updates: show check results with craft-update's
 CheckResultDialog

---
 Cargo.lock                               | 14 +++++++-------
 Cargo.toml                               | 10 +++++-----
 crates/ui-egui/src/dialogs/updates_ui.rs | 24 +++++++++++++-----------
 3 files changed, 25 insertions(+), 23 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index af7160133..4c7e15203 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -823,12 +823,12 @@ dependencies = [
 [[package]]
 name = "craft-fonts-build"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 
 [[package]]
 name = "craft-i18n"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 dependencies = [
  "fixed_decimal",
  "icu_decimal",
@@ -851,7 +851,7 @@ dependencies = [
 [[package]]
 name = "craft-media"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 dependencies = [
  "thiserror 2.0.21",
 ]
@@ -859,7 +859,7 @@ dependencies = [
 [[package]]
 name = "craft-pdf"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 dependencies = [
  "krilla",
  "thiserror 2.0.21",
@@ -868,7 +868,7 @@ dependencies = [
 [[package]]
 name = "craft-ui"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 dependencies = [
  "craft-fonts-build",
  "craft-i18n",
@@ -888,7 +888,7 @@ dependencies = [
 [[package]]
 name = "craft-update"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=04aa1703b32d299e54f78fcde4182f2b393a9116#04aa1703b32d299e54f78fcde4182f2b393a9116"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 dependencies = [
  "chrono",
  "dunce",
@@ -2708,7 +2708,7 @@ dependencies = [
 [[package]]
 name = "krilla"
 version = "0.8.2"
-source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 dependencies = [
  "base64 0.22.1",
  "bumpalo",
diff --git a/Cargo.toml b/Cargo.toml
index 0e0172b6f..83d5d06bd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -59,11 +59,11 @@ harfrust = "0.13"
 vello_cpu = "0.2"
 vello_common = { version = "0.2", default-features = false }
 image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp", "gif", "tiff", "bmp"] }
-craft-media = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", version = "=0.1.0", default-features = false }
-craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", version = "=0.1.0", default-features = false, features = ["write", "write-simple-text"] }
+craft-media = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", version = "=0.1.0", default-features = false }
+craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", version = "=0.1.0", default-features = false, features = ["write", "write-simple-text"] }
 # craft-update: app-specific pretend versions apply to startup and manual checks.
-craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "04aa1703b32d299e54f78fcde4182f2b393a9116", features = ["egui"] }
-craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", version = "=0.1.0" }
+craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", features = ["egui"] }
+craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", version = "=0.1.0" }
 i_overlay = "9"
 quick-xml = "0.41"
 zip = { version = "3", default-features = false, features = ["deflate"] }
@@ -109,7 +109,7 @@ codegen-units = 16
 debug = 0
 
 [patch.crates-io]
-krilla = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", version = "=0.8.2" }
+krilla = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", version = "=0.8.2" }
 ecolor = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
 emath = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
 epaint = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
diff --git a/crates/ui-egui/src/dialogs/updates_ui.rs b/crates/ui-egui/src/dialogs/updates_ui.rs
index 1fbfe4d2c..cdf2bf207 100644
--- a/crates/ui-egui/src/dialogs/updates_ui.rs
+++ b/crates/ui-egui/src/dialogs/updates_ui.rs
@@ -2,6 +2,7 @@
 //! prompt that offers to update and restart. The flow itself is `craft_update::updater::Updater`.
 
 use craft_update::updater::{Action, Status, Updater};
+use craft_update::{CheckResultDialog, CheckResultResponse};
 
 use crate::SlideApp;
 
@@ -12,11 +13,13 @@ pub(crate) struct Runtime {
     /// The desktop host turns the check at start on; tests and the web build leave it off.
     enabled: bool,
     check_requested: bool,
+    /// A manual check's result dialog is showing (checking, up to date or failed).
+    result_open: bool,
 }
 
 impl Default for Runtime {
     fn default() -> Self {
-        Self { updater: Updater::new(&crate::UPDATE_APP, VERSION), enabled: false, check_requested: false }
+        Self { updater: Updater::new(&crate::UPDATE_APP, VERSION), enabled: false, check_requested: false, result_open: false }
     }
 }
 
@@ -28,7 +31,7 @@ pub(crate) fn enable(app: &mut SlideApp) {
 pub(crate) fn request_check(app: &mut SlideApp) {
     if !matches!(app.updates_rt.updater.status(), Status::Checking) {
         app.updates_rt.check_requested = true;
-        app.notify("Checking for updates…");
+        app.updates_rt.result_open = true;
     }
 }
 
@@ -40,15 +43,6 @@ pub(crate) fn tick(app: &mut SlideApp, ctx: &egui::Context) {
         rt.updater.check_at_start(ctx);
     }
     rt.updater.tick(ctx);
-    let outcome = match rt.updater.status() {
-        Status::UpToDate => Some(format!("DeckCraft {VERSION} is up to date.")),
-        Status::Failed(e) => Some(format!("Could not check for updates: {e}")),
-        Status::Idle | Status::Checking => None,
-    };
-    if let Some(message) = outcome {
-        rt.updater.dismiss_status();
-        app.notify(message);
-    }
 }
 
 pub(crate) fn show(app: &mut SlideApp, ctx: &egui::Context) {
@@ -60,6 +54,14 @@ pub(crate) fn show(app: &mut SlideApp, ctx: &egui::Context) {
         Action::Close => ctx.send_viewport_cmd(egui::ViewportCommand::Close),
         Action::None => {}
     }
+    let rt = &mut app.updates_rt;
+    if rt.result_open {
+        match CheckResultDialog::new(&crate::UPDATE_APP, VERSION).show(ctx, rt.updater.status()) {
+            CheckResultResponse::Close => rt.result_open = false,
+            CheckResultResponse::CheckAgain => rt.check_requested = true,
+            CheckResultResponse::None => {}
+        }
+    }
 }
 
 #[cfg(test)]

From 3bf35c801fafc62a7d257da35097cd866c8eaec6 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <echelon@gmail.com>
Date: Sat, 31 Oct 2026 00:51:36 -0400
Subject: [PATCH 47/88] Custom geometry: 'E' is an exponent only when digits
 follow, so 'M 0 0E' keeps its end command

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/pptx/src/custgeom.rs | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/crates/pptx/src/custgeom.rs b/crates/pptx/src/custgeom.rs
index 815530268..981cb2e24 100644
--- a/crates/pptx/src/custgeom.rs
+++ b/crates/pptx/src/custgeom.rs
@@ -329,10 +329,19 @@ pub fn parse_path(d: &str) -> Vec<(char, Vec<f64>)> {
             token.clear();
         }
     };
-    for ch in d.chars() {
+    let cs: Vec<char> = d.chars().collect();
+    for (i, &ch) in cs.iter().enumerate() {
         match ch {
-            // An 'E' inside a number is an exponent, not the end command.
-            'E' if !token.is_empty() => token.push(ch),
+            // An 'E' inside a number followed by a digit (or a sign and a digit) is an exponent,
+            // not the end command.
+            'E' if !token.is_empty() && {
+                let n1 = cs.get(i + 1).copied().unwrap_or(' ');
+                let n2 = cs.get(i + 2).copied().unwrap_or(' ');
+                n1.is_ascii_digit() || ((n1 == '-' || n1 == '+') && n2.is_ascii_digit())
+            } =>
+            {
+                token.push(ch)
+            }
             'M' | 'L' | 'C' | 'Q' | 'Z' | 'm' | 'l' | 'c' | 'q' | 'z' | 'E' => {
                 push_tok(&mut token, &mut nums);
                 flush(cmd, &mut nums, &mut out);
@@ -479,6 +488,8 @@ mod tests {
         assert_eq!(parse_path("M 1E-5 2 L 3 4"), vec![('M', vec![1e-5, 2.0]), ('L', vec![3.0, 4.0])]);
         assert_eq!(parse_path("M 1.5E3 2"), vec![('M', vec![1500.0, 2.0])]);
         assert_eq!(parse_path("M 1e-5 2"), vec![('M', vec![1e-5, 2.0])]);
+        // An 'E' right after a number with no exponent digits is the end command.
+        assert_eq!(parse_path("M 0 0E"), vec![('M', vec![0.0, 0.0]), ('E', vec![])]);
     }
 
     #[test]

From acf054852ca136119475db3dbf60f05a763aebdf Mon Sep 17 00:00:00 2001
From: Brandon Thomas <echelon@gmail.com>
Date: Sat, 31 Oct 2026 00:53:14 -0400
Subject: [PATCH 48/88] slide.actions refuses a bad index instead of using the
 selected slide

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/inspect.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/crates/engine/src/cmd/inspect.rs b/crates/engine/src/cmd/inspect.rs
index 1da38843f..dabc833d6 100644
--- a/crates/engine/src/cmd/inspect.rs
+++ b/crates/engine/src/cmd/inspect.rs
@@ -5,7 +5,7 @@ use deckcraft_model::text::Hyperlink;
 use deckcraft_model::{Shape, ShapeKind};
 use serde_json::{Value, json};
 
-use super::{CommandSpec, always, bad, cmd, has_doc, id_param, str_param, usize_param, xfrm_of};
+use super::{CommandSpec, always, bad, cmd, has_doc, id_param, opt_usize_param, str_param, usize_param, xfrm_of};
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {
@@ -139,7 +139,7 @@ fn slide(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn actions(s: &mut Session, p: &Value) -> Result<Value> {
     let st = s.doc()?;
-    let i = usize_param(p, "index").unwrap_or(st.selection.slide);
+    let i = opt_usize_param(p, "index", "slide.actions")?.unwrap_or(st.selection.slide);
     let sl = st.doc.slides.get(i).ok_or_else(|| bad("slide.actions", format!("no slide {i}")))?;
     let mut found = Vec::new();
     for sh in &sl.shapes {
@@ -290,4 +290,12 @@ mod tests {
         let v = s.execute("slide.actions", &json!({})).unwrap();
         assert_eq!(v["actions"], json!([]));
     }
+
+    #[test]
+    fn slide_actions_refuses_a_bad_index_instead_of_using_the_selection() {
+        let mut s = Session::with_new();
+        for index in [json!(-1), json!("0"), json!(1.5)] {
+            assert!(s.execute("slide.actions", &json!({"index": index})).is_err(), "{index}");
+        }
+    }
 }

From 04b0958bee296fa9ba224170a08bc6c533696ffe Mon Sep 17 00:00:00 2001
From: Brandon Thomas <echelon@gmail.com>
Date: Sat, 31 Oct 2026 00:54:16 -0400
Subject: [PATCH 49/88] Gradient flip: drop the blank lines before the new flip
 fields

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/smartart/paint.rs | 1 -
 crates/model/src/theme.rs               | 1 -
 crates/pptx/tests/it/corpus_style.rs    | 2 --
 crates/pptx/tests/it/fills.rs           | 2 --
 crates/render/src/tests.rs              | 5 -----
 crates/render/src/tests_wild.rs         | 3 ---
 crates/ui-egui/src/panels/fillui.rs     | 2 --
 7 files changed, 16 deletions(-)

diff --git a/crates/engine/src/cmd/smartart/paint.rs b/crates/engine/src/cmd/smartart/paint.rs
index e49efd902..88192cad3 100644
--- a/crates/engine/src/cmd/smartart/paint.rs
+++ b/crates/engine/src/cmd/smartart/paint.rs
@@ -99,7 +99,6 @@ pub(super) fn paint(d: &Diagram, sh: &mut Shape, i: usize, light: bool) {
                 shape: GradientShape::Linear { angle: 90.0, scaled: false },
                 rotate_with_shape: true,
                 tile: [0.0; 4],
-
                 flip: None,
             }));
             sh.line = Some(Line::solid(ColorRef::scheme(SchemeSlot::Lt1), 1.0));
diff --git a/crates/model/src/theme.rs b/crates/model/src/theme.rs
index 27fe93e3d..5087f3ea4 100644
--- a/crates/model/src/theme.rs
+++ b/crates/model/src/theme.rs
@@ -115,7 +115,6 @@ pub fn default_format() -> FormatScheme {
             ],
             shape: GradientShape::Linear { angle: 90.0, scaled: false },
             rotate_with_shape: true,
-
             flip: None,
         })
     };
diff --git a/crates/pptx/tests/it/corpus_style.rs b/crates/pptx/tests/it/corpus_style.rs
index 422897602..bc3ea2fa1 100644
--- a/crates/pptx/tests/it/corpus_style.rs
+++ b/crates/pptx/tests/it/corpus_style.rs
@@ -46,7 +46,6 @@ fn gradient(angle: f64) -> Fill {
         shape: GradientShape::Linear { angle, scaled: true },
         rotate_with_shape: true,
         tile: [0.0; 4],
-
         flip: None,
     })
 }
@@ -118,7 +117,6 @@ fn style_deck() -> Presentation {
         shape: GradientShape::Path { path: "circle".into(), focus: [0.2, 0.2, 0.2, 0.2] },
         rotate_with_shape: false,
         tile: [0.0; 4],
-
         flip: None,
     }));
 
diff --git a/crates/pptx/tests/it/fills.rs b/crates/pptx/tests/it/fills.rs
index 51bd51de9..c1b7e9f37 100644
--- a/crates/pptx/tests/it/fills.rs
+++ b/crates/pptx/tests/it/fills.rs
@@ -120,7 +120,6 @@ fn a_fill_overlay_round_trips() {
             ],
             shape: GradientShape::Linear { angle: 4.5, scaled: true },
             rotate_with_shape: true,
-
             flip: None,
         }),
     };
@@ -151,7 +150,6 @@ fn a_gradient_tile_rect_is_read_and_round_trips() {
         shape: GradientShape::Path { path: "circle".into(), focus: [0.0, 0.0, 1.0, 1.0] },
         rotate_with_shape: true,
         tile: [-1.0, -1.0, 0.0, 0.0],
-
         flip: None,
     };
     let mut p = defaults::new_presentation(None);
diff --git a/crates/render/src/tests.rs b/crates/render/src/tests.rs
index ad6b94245..f01ee1cf8 100644
--- a/crates/render/src/tests.rs
+++ b/crates/render/src/tests.rs
@@ -978,7 +978,6 @@ fn a_linear_gradient_ramps_like_powerpoint() {
             stops: vec![stop(0.0, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
             shape: GradientShape::Linear { angle: 0.0, scaled: false },
             rotate_with_shape: true,
-
             flip: None,
         })),
         line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
@@ -1005,7 +1004,6 @@ fn a_gradient_with_a_stop_off_the_end_stays_linear() {
             stops: vec![stop(0.2, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
             shape: GradientShape::Linear { angle: 0.0, scaled: false },
             rotate_with_shape: true,
-
             flip: None,
         })),
         line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
@@ -1048,7 +1046,6 @@ fn a_shape_filled_with_the_background_shows_the_slide_background() {
             stops: vec![stop(0.0, 0), stop(0.5, 0), stop(1.0, 200)],
             shape: GradientShape::Linear { angle: 0.0, scaled: false },
             rotate_with_shape: true,
-
             flip: None,
         }),
     });
@@ -1151,7 +1148,6 @@ fn a_text_gradient_starts_over_on_every_line() {
             stops: vec![stop(0.0, 0), stop(1.0, 255)],
             shape: GradientShape::Linear { angle: 90.0, scaled: false },
             rotate_with_shape: true,
-
             flip: None,
         }));
     }
@@ -1314,7 +1310,6 @@ fn rect_path_gradients_draw_x_shaped_contours() {
             stops: vec![stop(0.0, 0), stop(0.5, 128), stop(1.0, 255)],
             shape: GradientShape::Path { path: "rect".into(), focus: [0.5, 0.5, 0.5, 0.5] },
             rotate_with_shape: true,
-
             flip: None,
         })),
         line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
diff --git a/crates/render/src/tests_wild.rs b/crates/render/src/tests_wild.rs
index c73987af5..ae78f64b1 100644
--- a/crates/render/src/tests_wild.rs
+++ b/crates/render/src/tests_wild.rs
@@ -186,7 +186,6 @@ fn radial(focus: [f64; 4]) -> Shape {
             stops,
             shape: GradientShape::Path { path: "circle".into(), focus },
             rotate_with_shape: true,
-
             flip: None,
         })),
         line: no_line(),
@@ -515,7 +514,6 @@ fn gradient_lines_and_their_heads_take_the_gradient() {
             shape: GradientShape::Linear { angle, scaled: false },
             rotate_with_shape: true,
             tile: [0.0; 4],
-
             flip: None,
         })
     };
@@ -671,7 +669,6 @@ fn a_gradient_not_rotating_with_its_shape_keeps_to_the_slide() {
             shape: GradientShape::Linear { angle: 0.0, scaled: false },
             rotate_with_shape,
             tile: [0.0; 4],
-
             flip: None,
         };
         // 200 × 100 turned a quarter: it covers 150..250 across and 50..250 down.
diff --git a/crates/ui-egui/src/panels/fillui.rs b/crates/ui-egui/src/panels/fillui.rs
index 3e247621a..d1f807ae7 100644
--- a/crates/ui-egui/src/panels/fillui.rs
+++ b/crates/ui-egui/src/panels/fillui.rs
@@ -21,7 +21,6 @@ pub fn default_gradient(base: ColorRef, angle: f64) -> Gradient {
         stops: vec![GradientStop { pos: 0.0, color: base }, GradientStop { pos: 1.0, color: dark }],
         shape: GradientShape::Linear { angle, scaled: false },
         rotate_with_shape: true,
-
         flip: None,
     }
 }
@@ -147,7 +146,6 @@ pub fn gradient_editor(ui: &mut Ui, id: &str, g: &Gradient, sc: &ColorScheme) ->
                 stops: vec![GradientStop { pos: 0.0, color: light }, GradientStop { pos: 1.0, color: dark }],
                 shape: GradientShape::Path { path: "circle".into(), focus: [0.5, 0.5, 0.5, 0.5] },
                 rotate_with_shape: true,
-
                 flip: None,
             },
             Gradient {

From 6058fc788238c8ecfa927353881bb35be32f80a1 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <echelon@gmail.com>
Date: Sat, 31 Oct 2026 00:54:38 -0400
Subject: [PATCH 50/88] gaps.md: drop the stray 10-28 click-target row from
 among the 10-13 rows

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/gaps.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/docs/gaps.md b/docs/gaps.md
index eadb1d93d..e553b2d2a 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -440,7 +440,6 @@ Detail in [localization-parity.md](localization-parity.md).
 | 2026-10-13 | trivial | Chart workbook round-trip (#335) noted under the charts gap; editing chart data is still open |
 | 2026-10-13 | minor | Shape, picture and table rendering checked against PowerPoint on ~150 synthetic edge-case slides; 3-D bevels, cameras and face lighting now render approximately (gap narrowed to extrusion, rigs and the 3-D pane) |
 | 2026-10-13 | minor | Interactive decks: triggers, return-to-slide state and click rules landed in the slide show; the remaining pieces are one new entry under Features |
-| 2026-10-28 | minor | Slide-show click targets follow animated movement and scale for shapes and text links; sound actions and audio triggers remain open |
 | 2026-10-12 | minor | IME composition in slide text and notes, and CJK interface text with real glyphs (#101): the IME gap is now Korean on the web and table-cell underlines |
 | 2026-10-12 | minor | EMF/WMF text, pattern and hatch brushes drawn; legacy OLE and ActiveX previews shown; the SVG gap keeps only EMF clip regions |
 | 2026-10-12 | minor | Text warps render (all 40 presets, adjusts round-trip); the warp gap is now the gallery, command and handles |

From 6a34f13808e0caae6709f97556ab3b13b18752ca Mon Sep 17 00:00:00 2001
From: Brandon Thomas <echelon@gmail.com>
Date: Sat, 31 Oct 2026 00:54:52 -0400
Subject: [PATCH 51/88] Ogg: the budget-spent warning goes last, after the
 capped warnings

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/ogg/src/lib.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/ogg/src/lib.rs b/crates/ogg/src/lib.rs
index b009f0425..77c081d52 100644
--- a/crates/ogg/src/lib.rs
+++ b/crates/ogg/src/lib.rs
@@ -350,13 +350,13 @@ pub fn open(src: &(impl ByteSource + ?Sized)) -> Result<OggFile> {
     if !found_any {
         return Err(Error::NotOgg);
     }
-    if scanner.spent() {
-        // once per file, so it is not subject to the cap on the others
-        warnings.push("recovery budget spent; the rest of the damaged data was not searched".into());
-    }
     if !partial.is_empty() {
         warn(&mut warnings, "file ends inside a packet".into());
     }
+    if scanner.spent() {
+        // once per file and last, so it is not subject to the cap on the others
+        warnings.push("recovery budget spent; the rest of the damaged data was not searched".into());
+    }
     Ok(OggFile { streams, warnings })
 }
 

From d2504e5f8b79fad5803c72afd634e901e1e96a12 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <echelon@gmail.com>
Date: Sat, 31 Oct 2026 00:56:17 -0400
Subject: [PATCH 52/88] Motion paths: a raw path string must parse to at least
 two finite points

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/animation.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/crates/engine/src/cmd/animation.rs b/crates/engine/src/cmd/animation.rs
index e69d97b67..b03e49181 100644
--- a/crates/engine/src/cmd/animation.rs
+++ b/crates/engine/src/cmd/animation.rs
@@ -191,7 +191,12 @@ fn path_param(p: &Value, slide: (f64, f64)) -> Result<Option<String>> {
         Value::String(text) => {
             let ok = text.len() <= MAX_PATH_TEXT
                 && text.contains(|c: char| c.is_ascii_digit())
-                && text.chars().all(|c| c.is_ascii_digit() || " .+-eE,MmLlCcQqHhVvZz".contains(c));
+                && text.chars().all(|c| c.is_ascii_digit() || " .+-eE,MmLlCcQqHhVvZz".contains(c))
+                // it must also draw: at least two finite points once parsed the way the show plays it
+                && {
+                    let pts = deckcraft_anim::MotionPath::parse(text).points;
+                    pts.len() >= 2 && pts.iter().all(|(x, y)| x.is_finite() && y.is_finite())
+                };
             if !ok {
                 return Err(refuse("string must be an OOXML motion path such as `M 0 0 L 0.25 0 E` (at most 16 KiB)"));
             }
@@ -733,6 +738,8 @@ mod tests {
             json!([[0, 0], [null, 1]]),
             json!("M 0 0 L <script> E"),
             json!("not a path"),
+            json!("eeee1"),
+            json!("M 0 0 L 1e999 0 E"),
             json!(5),
             Value::Array(many),
             Value::String("M 0 0 L 0.1 0.1 ".repeat(10_000)),

From 800ffeaa590728e2fe014717626d1fc0ab226fd3 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <echelon@gmail.com>
Date: Sat, 31 Oct 2026 00:59:38 -0400
Subject: [PATCH 53/88] Motion paths: check raw path strings without
 deckcraft-anim, which the engine only has as a dev-dependency

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/animation.rs | 42 ++++++++++++++++++++++++++----
 1 file changed, 37 insertions(+), 5 deletions(-)

diff --git a/crates/engine/src/cmd/animation.rs b/crates/engine/src/cmd/animation.rs
index b03e49181..5e3265df6 100644
--- a/crates/engine/src/cmd/animation.rs
+++ b/crates/engine/src/cmd/animation.rs
@@ -181,6 +181,42 @@ fn path_num(v: f64) -> String {
     if t == "-0" || t.is_empty() { "0".into() } else { t.into() }
 }
 
+/// Does a raw motion path string draw: only commands and numbers, every number finite, and at
+/// least two points? (A lone `e`, or `1e999`, would play as an empty or partial path.)
+fn raw_path_draws(text: &str) -> bool {
+    let cs: Vec<char> = text.chars().collect();
+    let (mut i, mut nums) = (0, 0usize);
+    while let Some(&c) = cs.get(i) {
+        if c.is_ascii_digit() || c == '.' || ((c == '-' || c == '+') && cs.get(i + 1).is_some_and(|d| d.is_ascii_digit() || *d == '.')) {
+            let start = i;
+            i += 1;
+            while cs.get(i).is_some_and(|d| d.is_ascii_digit() || *d == '.') {
+                i += 1;
+            }
+            if cs.get(i).is_some_and(|d| *d == 'e' || *d == 'E') {
+                let n1 = cs.get(i + 1).copied().unwrap_or(' ');
+                let n2 = cs.get(i + 2).copied().unwrap_or(' ');
+                if n1.is_ascii_digit() || ((n1 == '-' || n1 == '+') && n2.is_ascii_digit()) {
+                    i += 2;
+                    while cs.get(i).is_some_and(char::is_ascii_digit) {
+                        i += 1;
+                    }
+                }
+            }
+            let tok: String = cs.get(start..i).map(|t| t.iter().collect()).unwrap_or_default();
+            match tok.parse::<f64>() {
+                Ok(v) if v.is_finite() => nums += 1,
+                _ => return false,
+            }
+        } else if " ,MmLlCcQqHhVvZzE".contains(c) {
+            i += 1;
+        } else {
+            return false;
+        }
+    }
+    nums >= 4
+}
+
 /// The motion path `path` asks for, as the OOXML path string animations store: either points
 /// (`[[x, y], …]`, slide points as offsets from where the shape sits, joined by lines, `closed?`
 /// to return to the first) or that string itself.
@@ -192,11 +228,7 @@ fn path_param(p: &Value, slide: (f64, f64)) -> Result<Option<String>> {
             let ok = text.len() <= MAX_PATH_TEXT
                 && text.contains(|c: char| c.is_ascii_digit())
                 && text.chars().all(|c| c.is_ascii_digit() || " .+-eE,MmLlCcQqHhVvZz".contains(c))
-                // it must also draw: at least two finite points once parsed the way the show plays it
-                && {
-                    let pts = deckcraft_anim::MotionPath::parse(text).points;
-                    pts.len() >= 2 && pts.iter().all(|(x, y)| x.is_finite() && y.is_finite())
-                };
+                && raw_path_draws(text);
             if !ok {
                 return Err(refuse("string must be an OOXML motion path such as `M 0 0 L 0.25 0 E` (at most 16 KiB)"));
             }

From e747bff42525c7e6fde01bea4651db0dc7a94ae6 Mon Sep 17 00:00:00 2001
From: dotCooCoo <RobertLeeLW@gmail.com>
Date: Fri, 30 Oct 2026 22:02:08 -0700
Subject: [PATCH 54/88] Shape Fill: the gradient help lists every kind and key
 the command takes

The shape.fill params doc listed only linear and radial gradients with
stops, angle and kind. The command also takes the rectangular and path
kinds, focus and rotateWithShape. The doc now names them, and a test
checks the doc's gradient keys and kinds against what the command reads.
---
 crates/engine/src/cmd/shape.rs |  2 +-
 crates/engine/src/tests.rs     | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/crates/engine/src/cmd/shape.rs b/crates/engine/src/cmd/shape.rs
index 9565cdf7b..08ed9be64 100644
--- a/crates/engine/src/cmd/shape.rs
+++ b/crates/engine/src/cmd/shape.rs
@@ -103,7 +103,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Shape Fill",
             ["Shape Format", "Shape Styles"],
             None,
-            "{color? | none?: true | background?: true (the slide background shows through; shapes and text boxes only) | gradient?: {stops: [[pos, color]], angle?, kind?: linear|radial} | picture?: base64 | pattern?: {preset, fg, bg} | transparency?: 0..1 | reset?: true, ids?}; pictureProps?: {tile?: bool, offsetX?, offsetY?: pt, scaleX?, scaleY?: 0..10, align?: tl|t|tr|l|ctr|r|bl|b|br, mirror?: none|x|y|xy, stretch?: [l, t, r, b] fractions, rotateWithShape?: bool} adjusts a picture fill; a group also formats its members",
+            "{color? | none?: true | background?: true (the slide background shows through; shapes and text boxes only) | gradient?: {stops: [[pos 0..1, color]], kind?: linear|radial|rectangular|path, angle?: deg (linear), focus?: [l, t, r, b] fractions (radial, rectangular and path: where the first stop sits), rotateWithShape?: bool} | picture?: base64 | pattern?: {preset, fg, bg} | transparency?: 0..1 | reset?: true, ids?}; pictureProps?: {tile?: bool, offsetX?, offsetY?: pt, scaleX?, scaleY?: 0..10, align?: tl|t|tr|l|ctr|r|bl|b|br, mirror?: none|x|y|xy, stretch?: [l, t, r, b] fractions, rotateWithShape?: bool} adjusts a picture fill; a group also formats its members",
             has_selection,
             fill
         ),
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 85cbe9d8c..1fc7fb2d7 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -4281,6 +4281,38 @@ fn a_params_doc_spells_out_each_parameter() {
     );
 }
 
+/// `shape.fill`'s params doc names each key and kind its `gradient` takes.
+#[test]
+fn shape_fill_documents_each_gradient_key_and_kind() {
+    use deckcraft_model::style::GradientShape;
+    let params = cmd::parse_params(find_command("shape.fill").unwrap().params).unwrap();
+    let about = params.iter().find(|p| p.name == "gradient").unwrap().about;
+    assert_eq!(cmd::param_keys(about).unwrap(), ["stops", "kind", "angle", "focus", "rotateWithShape"]);
+    for kind in ["linear", "radial", "rectangular", "path"] {
+        assert!(about.contains(kind), "{kind}: {about}");
+        let g = cmd::shape::gradient_param(&json!({
+            "stops": [[0, "#ffffff"], [1, "#000000"]],
+            "kind": kind,
+            "angle": 30,
+            "focus": [0, 0, 1, 1],
+            "rotateWithShape": false
+        }))
+        .unwrap();
+        assert!(!g.rotate_with_shape, "{kind}");
+        match g.shape {
+            GradientShape::Linear { angle, .. } => assert_eq!((kind, angle), ("linear", 30.0)),
+            GradientShape::Path { path, focus } => {
+                let expected = match kind {
+                    "radial" => "circle",
+                    "rectangular" => "rect",
+                    _ => "shape",
+                };
+                assert_eq!((path.as_str(), focus), (expected, [0.0, 0.0, 1.0, 1.0]), "{kind}");
+            }
+        }
+    }
+}
+
 #[test]
 fn what_a_command_acts_on_names_only_keys_it_takes() {
     for c in command_specs() {

From 92bf7fc67dbe8f934c45b33b94879221118dc089 Mon Sep 17 00:00:00 2001
From: Dylan Taylor <dylan@dylanmtaylor.com>
Date: Sat, 31 Oct 2026 01:05:27 -0400
Subject: [PATCH 55/88] fix(xtask): update SHARED_REV for craft-libs update

---
 xtask/src/pdf_deps.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/xtask/src/pdf_deps.rs b/xtask/src/pdf_deps.rs
index 100aa3a03..ad8e8725c 100644
--- a/xtask/src/pdf_deps.rs
+++ b/xtask/src/pdf_deps.rs
@@ -6,7 +6,7 @@ use std::process::Command;
 
 use serde_json::Value;
 
-const SHARED_REV: &str = "92d392cff132eaf53e13afff77f38b5c11b73aa0";
+const SHARED_REV: &str = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7";
 const REGISTRY: &str = "registry+https://github.com/rust-lang/crates.io-index";
 
 pub fn run(root: &Path) -> Result<(), String> {

From c3e9bd07e5600662ee4230b609144498f3fe7e05 Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Sat, 31 Oct 2026 06:38:17 +0100
Subject: [PATCH 56/88] Reject invalid slide index in design.background

Found while testing crates/engine/src/cmd/design/slide_background.rs:65 (index via usize_param); write_background at :175

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/design/slide_background.rs |  4 ++--
 crates/engine/src/cmd/design/tests.rs            | 13 +++++++++++++
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/crates/engine/src/cmd/design/slide_background.rs b/crates/engine/src/cmd/design/slide_background.rs
index 0de78e7e3..92f3ce773 100644
--- a/crates/engine/src/cmd/design/slide_background.rs
+++ b/crates/engine/src/cmd/design/slide_background.rs
@@ -1,6 +1,6 @@
 use super::{
     Arc, BTreeSet, Background, Fill, NO_ID_SPACE, Presentation, Result, Session, Target, Value, bad, bool_or, bool_param, color_param, color_value,
-    f64_param, ok, usize_param, with_param,
+    f64_param, ok, opt_usize_param, usize_param, with_param,
 };
 
 pub(super) fn background(s: &mut Session, p: &Value) -> Result<Value> {
@@ -62,7 +62,7 @@ pub(super) fn background(s: &mut Session, p: &Value) -> Result<Value> {
         ));
     };
     let all = bool_or(p, "all", false);
-    let index = usize_param(p, "index");
+    let index = opt_usize_param(p, "index", "design.background")?;
     if matches!(op, BgOp::Adjust) {
         let next = {
             let st = s.doc()?;
diff --git a/crates/engine/src/cmd/design/tests.rs b/crates/engine/src/cmd/design/tests.rs
index 9765fcc8f..82eed6feb 100644
--- a/crates/engine/src/cmd/design/tests.rs
+++ b/crates/engine/src/cmd/design/tests.rs
@@ -485,3 +485,16 @@ fn background_all_clears_layout_overrides_even_if_slides_and_master_match() {
     s.execute("design.background", &json!({"color": "#AA0000", "all": true})).unwrap();
     assert_eq!(undo_len(&s), n + 1, "now it is truly a no-op");
 }
+
+#[test]
+fn background_rejects_invalid_index() {
+    let mut s = Session::with_new();
+    s.execute("slide.new", &json!({})).unwrap();
+    s.execute("slide.go", &json!({"index": 0})).unwrap();
+    let before = s.doc().unwrap().doc.slides[0].background.clone();
+    for bad in [json!(-1), json!(1.5)] {
+        assert!(s.execute("design.background", &json!({"color": "#0000C8", "index": bad})).is_err());
+        assert!(s.execute("design.background", &json!({"transparency": 0.5, "index": bad})).is_err());
+        assert_eq!(s.doc().unwrap().doc.slides[0].background, before);
+    }
+}

From 84ac51a43953a11b5b1c3327b8a6c32e4d4e7951 Mon Sep 17 00:00:00 2001
From: DominicTheD3v <119626487+DominicTheD3v@users.noreply.github.com>
Date: Sat, 31 Oct 2026 07:04:09 +0000
Subject: [PATCH 57/88] fix: addressing more issues

---
 crates/engine/src/tests.rs      | 60 +++++++++++++++++++++++++++++++++
 crates/engine/src/tools/drag.rs | 14 +++++++-
 2 files changed, 73 insertions(+), 1 deletion(-)

diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index ef18a31f6..39c04610e 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -5617,6 +5617,66 @@ fn resizing_selected_shapes_still_snaps_to_stationary_shapes() {
     assert_eq!(box_of(&mut s, fixed), fixed_before);
 }
 
+/// Secondary pictures resize uniformly around their anchor, preserving independent flips
+/// and keeping the complete multi-selection resize in one undo step.
+#[test]
+fn resizing_selected_shapes_resizes_secondary_pictures() {
+    // Pointer destination, Alt, expected rectangle, expected picture, expected flips.
+    let cases = [
+        ((180.0, 200.0), false, [100.0, 100.0, 80.0, 100.0], [300.0, 300.0, 80.0, 80.0], [false, false]),
+        ((200.0, 180.0), false, [100.0, 100.0, 100.0, 80.0], [300.0, 300.0, 80.0, 80.0], [false, false]),
+        ((220.0, 200.0), false, [100.0, 100.0, 120.0, 100.0], [300.0, 300.0, 120.0, 120.0], [false, false]),
+        ((200.0, 220.0), false, [100.0, 100.0, 100.0, 120.0], [300.0, 300.0, 120.0, 120.0], [false, false]),
+        ((180.0, 200.0), true, [120.0, 100.0, 60.0, 100.0], [320.0, 320.0, 60.0, 60.0], [false, false]),
+        ((200.0, 180.0), true, [100.0, 120.0, 100.0, 60.0], [320.0, 320.0, 60.0, 60.0], [false, false]),
+        ((80.0, 200.0), false, [80.0, 100.0, 20.0, 100.0], [280.0, 300.0, 20.0, 20.0], [true, false]),
+        ((200.0, 80.0), false, [100.0, 80.0, 100.0, 20.0], [300.0, 280.0, 20.0, 20.0], [false, true]),
+    ];
+
+    for (to, alt, expected_rect, expected_picture, flips) in cases {
+        let mut s = session();
+        s.execute("slide.new", &json!({"layout": "blank"})).unwrap();
+        s.prefs.smart_guides = false;
+        s.prefs.snap_to_grid = false;
+
+        let rect = s.execute("shape.insert", &json!({"preset": "rect", "rect": [100, 100, 100, 100]})).unwrap()["id"].as_u64().unwrap();
+        let picture = ramp_picture(&mut s, 1, [300, 300, 100, 100]).as_u64().unwrap();
+        s.execute("edit.select", &json!({"ids": [rect, picture]})).unwrap();
+
+        let before = s.doc().unwrap().doc.clone();
+        let steps = s.doc().unwrap().history.undo.len();
+        let mods = Mods { alt, ..Default::default() };
+        let ev = |kind, (x, y): (f64, f64)| PointerEvent { kind, x, y, mods, tol: 3.0, pressure: None };
+
+        let down = s.pointer(ev(PointerKind::Down, (200.0, 200.0))).unwrap();
+        assert_eq!(down["hit"]["kind"], "resize");
+        assert_eq!(down["hit"]["id"], rect);
+        assert_eq!(down["hit"]["handle"], 4);
+
+        s.pointer(ev(PointerKind::Drag, ((200.0 + to.0) / 2.0, (200.0 + to.1) / 2.0))).unwrap();
+        s.pointer(ev(PointerKind::Drag, to)).unwrap();
+        s.pointer(ev(PointerKind::Up, to)).unwrap();
+
+        for (id, expected) in [(rect, expected_rect), (picture, expected_picture)] {
+            let actual = box_of(&mut s, id);
+            for (key, value) in ["x", "y", "w", "h"].into_iter().zip(expected) {
+                let got = actual[key].as_f64().unwrap();
+                assert!((got - value).abs() < 1e-9, "{to:?}, alt={alt}, shape={id}, {key}: expected {value}, got {got}");
+            }
+
+            let xfrm = s.doc().unwrap().shape(ShapeId(id as u32)).unwrap().xfrm.unwrap();
+            assert_eq!([xfrm.flip_h, xfrm.flip_v], flips, "{to:?}, alt={alt}, shape={id}");
+        }
+
+        assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
+        let after = s.doc().unwrap().doc.clone();
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(s.doc().unwrap().doc, before);
+        s.execute("edit.redo", &json!({})).unwrap();
+        assert_eq!(s.doc().unwrap().doc, after);
+    }
+}
+
 /// #961: dragging the east handle snaps the dragged (right) edge, even when the fixed left edge
 /// already lines up with another shape. The nearest line used to be the fixed edge's, at distance 0.
 #[test]
diff --git a/crates/engine/src/tools/drag.rs b/crates/engine/src/tools/drag.rs
index 9b672ffcd..11392c13d 100644
--- a/crates/engine/src/tools/drag.rs
+++ b/crates/engine/src/tools/drag.rs
@@ -47,12 +47,24 @@ impl Session {
                     let target_nx = if *tid == id {
                         nx
                     } else {
+                        let picture = self.is_picture(*tid);
+                        let (sx, sy) = if picture && matches!(handle, 0 | 2 | 4 | 6) {
+                            // Use the axis with the larger relative change so an unchanged
+                            // dimension cannot cancel shrinking. Preserve each axis's flip.
+                            let scale_x = 1.0 + sx;
+                            let scale_y = 1.0 + sy;
+                            let scale = if sx.abs() >= sy.abs() { scale_x.abs() } else { scale_y.abs() };
+                            (scale.copysign(scale_x) - 1.0, scale.copysign(scale_y) - 1.0)
+                        } else {
+                            (sx, sy)
+                        };
+
                         let lp = Affine::rotate(o.rot.to_radians())
                             * Point::new(
                                 hx * sx * o.w / div * if o.flip_h { -1.0 } else { 1.0 },
                                 hy * sy * o.h / div * if o.flip_v { -1.0 } else { 1.0 },
                             );
-                        resize_box(o, handle, Vec2::new(lp.x, lp.y), self.is_picture(*tid), mods.alt)
+                        resize_box(o, handle, Vec2::new(lp.x, lp.y), picture, mods.alt)
                     };
                     self.set_xfrm(*tid, target_nx)?;
                 }

From c5ac1dd44bb4bfe19777190fc98bd589d1fb26e2 Mon Sep 17 00:00:00 2001
From: DominicTheD3v <119626487+DominicTheD3v@users.noreply.github.com>
Date: Sat, 31 Oct 2026 07:52:55 +0000
Subject: [PATCH 58/88] docs: add missing docstrings

---
 crates/engine/src/tools/drag.rs    | 1 +
 crates/engine/src/tools/pointer.rs | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/crates/engine/src/tools/drag.rs b/crates/engine/src/tools/drag.rs
index 11392c13d..dcee9cf7d 100644
--- a/crates/engine/src/tools/drag.rs
+++ b/crates/engine/src/tools/drag.rs
@@ -13,6 +13,7 @@ struct MoveDrag {
 }
 
 impl Session {
+    /// Update the active drag interaction using the pointer position and modifiers.
     pub(super) fn drag(&mut self, p: Point, mods: Mods, tol: f64) -> Result<Value> {
         let Some(drag) = self.tool.drag.clone() else { return Ok(Value::Null) };
         match drag {
diff --git a/crates/engine/src/tools/pointer.rs b/crates/engine/src/tools/pointer.rs
index 1f4cba0c5..d049dcf35 100644
--- a/crates/engine/src/tools/pointer.rs
+++ b/crates/engine/src/tools/pointer.rs
@@ -220,6 +220,7 @@ impl Session {
         }
     }
 
+    /// Handle a pointer press and start the applicable tool interaction.
     fn down(&mut self, p: Point, mods: Mods, tol: f64) -> Result<Value> {
         if let Some(Drag::Freeform { mode, mut points, .. }) = self.tool.drag.clone() {
             // Next click of a freeform: close on the start point, else add a vertex.
@@ -440,6 +441,7 @@ impl Session {
         Ok(json!({"hit": serde_json::to_value(&hit).unwrap_or_default()}))
     }
 
+    /// Handle a pointer release and finalize the active tool interaction.
     fn up(&mut self, p: Point, mods: Mods) -> Result<Value> {
         let drag = self.tool.drag.take();
         self.tool.guides.clear();

From 2ed2ce18d8e229e95776068e73daffb194f9fd96 Mon Sep 17 00:00:00 2001
From: Madhasoeki <ramadhan.kpj@gmail.com>
Date: Sat, 31 Oct 2026 22:25:50 +0700
Subject: [PATCH 59/88] Fonts: unavailable monospace fonts fall back to a
 monospace substitute (#1598)

When a document uses a monospace font that is not installed on the
system (such as Cousine, Source Code Pro, JetBrains Mono, Consolas, or
Cascadia Code), document_face previously fell back to the generic
proportional MISSING_FONT_FAMILY (Calibri), causing code snippets and
columns to misalign.

Add is_monospace_family to recognize monospace families, ensure
substitutes returns open monospace replacements (Liberation Mono,
Courier New, Menlo, Courier, DejaVu Sans Mono), recognize Cousine as
a metric twin of Courier New, and keep monospace families on their
substitute chain in document_face.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 crates/fonts/src/fontdb.rs | 80 ++++++++++++++++++++++++++++++++++++--
 crates/fonts/src/lib.rs    |  3 +-
 crates/fonts/src/tests.rs  | 51 ++++++++++++++++++++++++
 3 files changed, 129 insertions(+), 5 deletions(-)

diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rs
index 043b8f2dd..cc2bd417a 100644
--- a/crates/fonts/src/fontdb.rs
+++ b/crates/fonts/src/fontdb.rs
@@ -30,12 +30,15 @@ pub fn bundled() -> Vec<&'static [u8]> {
 /// Open substitutes for families documents often ask for but we can't ship (metric-compatible
 /// where one exists), tried in order after the family itself.
 pub fn substitutes(family: &str) -> &'static [&'static str] {
-    match family.to_ascii_lowercase().as_str() {
+    let f = family.to_ascii_lowercase();
+    if is_monospace_family(&f) {
+        return &["Liberation Mono", "Courier New", "Menlo", "Courier", "DejaVu Sans Mono"];
+    }
+    match f.as_str() {
         "calibri" | "calibri light" => &["Carlito", "Liberation Sans", "Arial", "Inter"],
         "cambria" | "cambria math" => &["Caladea", "Liberation Serif", "Times New Roman", "Merriweather"],
         "arial" | "helvetica" | "helvetica neue" | "arial nova" => &["Liberation Sans", "Arial", "Helvetica Neue", "Helvetica", "Inter"],
         "times new roman" | "times" => &["Liberation Serif", "Times New Roman", "Times", "Merriweather"],
-        "courier new" | "courier" | "consolas" | "menlo" => &["Liberation Mono", "Courier New", "Menlo", "Courier"],
         "aptos" | "aptos display" | "aptos narrow" | "segoe ui" | "segoe ui light" | "segoe ui semibold" | "tahoma" | "verdana" => {
             &["Inter", "Helvetica Neue", "Arial", "Liberation Sans"]
         }
@@ -52,12 +55,75 @@ pub fn substitutes(family: &str) -> &'static [&'static str] {
     }
 }
 
+/// Families that are monospaced: when not installed, documents keep a monospaced substitute
+/// ([`substitutes`]) so code blocks and columns stay aligned instead of falling back to
+/// proportional Calibri.
+pub fn is_monospace_family(family: &str) -> bool {
+    let f = family.to_ascii_lowercase();
+    let s = f.trim();
+    if matches!(
+        s,
+        "courier new"
+            | "courier"
+            | "cousine"
+            | "consolas"
+            | "menlo"
+            | "monaco"
+            | "source code pro"
+            | "jetbrains mono"
+            | "cascadia code"
+            | "cascadia mono"
+            | "fira code"
+            | "fira mono"
+            | "inconsolata"
+            | "dejavu sans mono"
+            | "sf mono"
+            | "roboto mono"
+            | "hack"
+            | "ubuntu mono"
+            | "pt mono"
+            | "liberation mono"
+            | "andale mono"
+            | "lucida console"
+            | "lucida sans typewriter"
+            | "fixedsys"
+            | "terminal"
+            | "monospace"
+            | "iosevka"
+            | "monolisa"
+            | "envy code r"
+            | "hasklig"
+    ) {
+        return true;
+    }
+    s.starts_with("courier")
+        || s.starts_with("consolas")
+        || s.starts_with("inconsolata")
+        || s.starts_with("iosevka")
+        || s.ends_with(" mono")
+        || s.ends_with(" code")
+        || s.ends_with(" console")
+        || s.ends_with(" typewriter")
+        || s.ends_with(" monospace")
+        || s.split_whitespace().any(|w| w == "mono" || w == "code" || w == "terminal" || w == "monospace")
+}
+
 /// Families whose open substitutes ([`substitutes`]) keep their metrics, so text drawn with
 /// them breaks into the same lines.
 fn has_metric_twin(family: &str) -> bool {
     matches!(
         family.to_ascii_lowercase().as_str(),
-        "calibri" | "calibri light" | "cambria" | "cambria math" | "arial" | "helvetica" | "times new roman" | "times" | "courier new" | "courier"
+        "calibri"
+            | "calibri light"
+            | "cambria"
+            | "cambria math"
+            | "arial"
+            | "helvetica"
+            | "times new roman"
+            | "times"
+            | "courier new"
+            | "courier"
+            | "cousine"
     )
 }
 
@@ -1080,9 +1146,15 @@ impl FontDb {
     /// when it is installed or bundled, or a metric-compatible stand-in (Carlito for Calibri,
     /// Liberation Sans for Arial…), or the family PowerPoint maps it to (Liberation Sans as Arial,
     /// see `office_twin`); any other missing family is drawn in Calibri (or Carlito).
+    /// Monospaced families keep a monospaced substitute instead of falling back to Calibri.
     /// DeckCraft's own default family keeps [`FontDb::face`]'s fallbacks.
     pub fn document_face(&self, family: &str, style: &str) -> Arc<FontFace> {
-        if family.eq_ignore_ascii_case(FALLBACK_FAMILY) || has_metric_twin(family) || is_office_cloud_font(family) || self.has_family(family) {
+        if family.eq_ignore_ascii_case(FALLBACK_FAMILY)
+            || has_metric_twin(family)
+            || is_monospace_family(family)
+            || is_office_cloud_font(family)
+            || self.has_family(family)
+        {
             return self.face(family, style);
         }
         if let Some(twin) = office_twin(family) {
diff --git a/crates/fonts/src/lib.rs b/crates/fonts/src/lib.rs
index 92d2cb44d..0bb0edb50 100644
--- a/crates/fonts/src/lib.rs
+++ b/crates/fonts/src/lib.rs
@@ -15,7 +15,8 @@ mod shape;
 
 pub use fallback::{bundled_families, covers_cluster, is_emoji_cluster, ligature_carets};
 pub use fontdb::{
-    FALLBACK_FAMILY, FaceRef, FontDb, FontFace, LAST_RESORT_FAMILY, MISSING_FONT_FAMILY, base_style, bundled, substitutes, system_font_dirs,
+    FALLBACK_FAMILY, FaceRef, FontDb, FontFace, LAST_RESORT_FAMILY, MISSING_FONT_FAMILY, base_style, bundled, is_monospace_family, substitutes,
+    system_font_dirs,
 };
 pub use harfrust::Feature;
 use harfrust::Tag;
diff --git a/crates/fonts/src/tests.rs b/crates/fonts/src/tests.rs
index a6fca4c4d..69f54227d 100644
--- a/crates/fonts/src/tests.rs
+++ b/crates/fonts/src/tests.rs
@@ -237,6 +237,57 @@ fn office_fonts_have_substitutes() {
     assert!(substitutes("Times New Roman").contains(&"Liberation Serif"));
     assert!(substitutes("Aptos").contains(&"Inter"));
     assert!(substitutes("zzz").is_empty());
+
+    for mono in [
+        "Courier New",
+        "Cousine",
+        "Consolas",
+        "Menlo",
+        "Monaco",
+        "Source Code Pro",
+        "JetBrains Mono",
+        "Cascadia Code",
+        "Cascadia Mono",
+        "Fira Code",
+        "Inconsolata",
+        "DejaVu Sans Mono",
+        "Roboto Mono",
+        "Hack",
+        "Ubuntu Mono",
+        "Custom Monospace",
+        "Fantasque Sans Mono",
+    ] {
+        assert!(substitutes(mono).contains(&"Liberation Mono"), "{mono} should have Liberation Mono substitute");
+        assert!(is_monospace_family(mono), "{mono} should be recognized as monospace");
+    }
+
+    for prop in ["Calibri", "Arial", "Times New Roman", "Inter", "Monotype Corsiva", "Monotype Baskerville", "zzz"] {
+        assert!(!is_monospace_family(prop), "{prop} should not be recognized as monospace");
+    }
+}
+
+#[test]
+fn missing_monospace_fonts_keep_monospace_fallback() {
+    let db = FontDb::global();
+    let mono_sub = db.face("Unavailable JetBrains Mono", "Regular").family.clone();
+    let calibri_target = db.face(MISSING_FONT_FAMILY, "Regular").family.clone();
+
+    assert!(is_monospace_family(&mono_sub), "substitute {mono_sub} must be monospace");
+
+    // Cousine is metric-compatible with Courier New / Liberation Mono and must not fall back to Calibri.
+    if !db.has_family("Cousine") {
+        assert_eq!(db.document_face("Cousine", "Regular").family, mono_sub);
+    }
+
+    // Monospace fonts missing from the system must resolve to a monospace substitute.
+    for mono in ["Unavailable JetBrains Mono", "Custom App Code", "Unknown Space Mono", "Mock Terminal Font"] {
+        let f = db.document_face(mono, "Regular");
+        assert_eq!(f.family, mono_sub, "{mono}");
+        assert!(is_monospace_family(&f.family), "{mono} must resolve to a monospace family");
+        if mono_sub != calibri_target {
+            assert_ne!(f.family, calibri_target, "{mono} must not fall back to Calibri");
+        }
+    }
 }
 
 #[test]

From cd19752bb5007c8f3c2a8661996b59e24d537f51 Mon Sep 17 00:00:00 2001
From: Elliot Graham <elliotgraham94@gmail.com>
Date: Sat, 31 Oct 2026 19:38:08 +0000
Subject: [PATCH 60/88] FIX-1621: let no-fill interiors pass clicks to
 underlying objects

---
 ROADMAP.md                     |   4 +-
 crates/engine/src/tests.rs     | 114 +++++++++++++++++++++++++++++++++
 crates/engine/src/tools/hit.rs |   7 +-
 docs/gaps.md                   |   3 +-
 docs/parity-checklist.md       |  10 ++-
 docs/ui-parity.md              |   5 +-
 6 files changed, 136 insertions(+), 7 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index f92554c14..8dc52dfb7 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~20 points and ~120–210 h away
 
-> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-30 · **Change:** trivial (print-preview tests use egui's emitted URL, and macOS removes its previews before exit; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-10-31 · **Change:** trivial (No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-30 · **Change:** trivial (progress log: read-only `slide.actions` lists shape and table text actions; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-27 · **Change:** trivial (progress log: Set Up Slide Show ▸ Keep mouse cursor visible, #1445; stage and scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-26 · **Change:** trivial (progress log: dragging several selected slides moves them all; previous: trivial, progress log: Edit Points handle drags with Shift, Ctrl/Cmd or Alt/Option set the point type; previous: trivial, progress log: scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
@@ -148,6 +148,7 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | What landed |
 |---|---|
+| 2026-10-31 | No Fill shape interiors allow selection and editing of underlying objects, even when a quick style remains; hit-testing uses the renderer’s fill resolution. Outlines, rotation, text targets and actual fills keep their hit behaviour (#1621) |
 | 2026-10-30 | Print-preview tests use the URL emitted by egui and its exact file path; previews are explicitly removed before the macOS process exits |
 | 2026-10-30 | `slide.actions` lists shape click and hover actions and text-run hyperlinks (including table cells and grouped shapes) for audit; listing never runs an action. The UI pane is a follow-up |
 | 2026-10-29 | Slide Show: going back to the previous slide plays the transition of the slide being left, reversed, as PowerPoint does, instead of the previous slide's own entrance transition (#1531); a jump (Go to Slide, links) still plays the target slide's transition |
@@ -318,6 +319,7 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-31 | trivial | No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged |
 | 2026-10-30 | trivial | Progress log: read-only slide action inspection; parity scores unchanged |
 | 2026-10-29 | trivial | Progress log: going back in the slide show reverses the left slide's transition (#1531). Scores and milestone names unchanged |
 | 2026-10-29 | trivial | Progress log: the Picture Styles row leaves room for Crop and Size (#1232). Scores and milestone names unchanged |
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index a687de95c..08417b4f8 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -5572,6 +5572,120 @@ fn edit_points_conversion_is_one_undo_step() {
     assert!(preset(&s), "the only step was the conversion");
 }
 
+// #1621: No Fill changes hit-testing as well as rendering, even with a quick style.
+fn no_fill_overlap(s: &mut Session, text: bool) -> (ShapeId, ShapeId) {
+    s.execute("slide.new", &json!({"layout": "blank"})).unwrap();
+    let under = s
+        .execute(
+            if text { "insert.textBox" } else { "shape.insert" },
+            &json!({"preset": "rect", "rect": [100, 300, 300, 60], "text": if text { "UNDERLYING TEXT" } else { "" }}),
+        )
+        .unwrap()["id"]
+        .as_u64()
+        .unwrap();
+    let over = s.execute("shape.insert", &json!({"preset": "rect", "rect": [80, 270, 350, 140]})).unwrap()["id"].as_u64().unwrap();
+    (ShapeId(under as u32), ShapeId(over as u32))
+}
+
+#[test]
+fn no_fill_shape_allows_selecting_and_editing_underlying_text() {
+    let mut s = session();
+    let (under, over) = no_fill_overlap(&mut s, true);
+    s.execute("shape.fill", &json!({"none": true})).unwrap();
+    assert!(s.doc().unwrap().shape(over).unwrap().style.is_some(), "the ordinary quick style remains");
+    s.execute("edit.deselect", &json!({})).unwrap();
+    let p = deckcraft_geom::Point::new(200.0, 310.0);
+    assert!(matches!(s.hit_test(p, 3.0), Some(tools::Hit::Shape { id, .. }) if id == under));
+    for kind in [PointerKind::Down, PointerKind::Up] {
+        s.pointer(tev(kind, p.x, p.y)).unwrap();
+    }
+    assert_eq!(s.doc().unwrap().selection.shapes, vec![under]);
+    assert_eq!(text_sel(&s).unwrap().shape, under);
+    // The transparent foreground also leaves an already-active text editor's caret alone.
+    for kind in [PointerKind::Down, PointerKind::Up] {
+        s.pointer(tev(kind, p.x + 20.0, p.y)).unwrap();
+    }
+    assert_eq!(text_sel(&s).unwrap().shape, under);
+    s.execute("edit.deselect", &json!({})).unwrap();
+    // The rectangle's outline is still a target, and selecting it does not remove its style.
+    for kind in [PointerKind::Down, PointerKind::Up] {
+        s.pointer(tev(kind, 80.0, 330.0)).unwrap();
+    }
+    assert_eq!(s.doc().unwrap().selection.shapes, vec![over]);
+    assert!(s.doc().unwrap().shape(over).unwrap().style.is_some());
+    // A real fill still catches clicks, even with 100% transparency (distinct from No Fill).
+    for transparency in [0.0, 1.0] {
+        s.execute("edit.select", &json!({"ids": [over.0]})).unwrap();
+        s.execute("shape.fill", &json!({"color": "#336699", "transparency": transparency})).unwrap();
+        s.execute("edit.deselect", &json!({})).unwrap();
+        assert!(matches!(s.hit_test(p, 3.0), Some(tools::Hit::Shape { id, .. }) if id == over));
+    }
+}
+
+#[test]
+fn no_fill_shape_hit_testing_respects_rotation_and_pointer_tolerance() {
+    let mut s = session();
+    let (under, over) = no_fill_overlap(&mut s, false);
+    s.execute("shape.fill", &json!({"none": true})).unwrap();
+    s.execute("shape.rotate", &json!({"deg": 30})).unwrap();
+    let x = s.doc().unwrap().shape(over).unwrap().xfrm.unwrap();
+    let p = x.affine() * deckcraft_geom::Point::new(x.w / 2.0, x.h / 2.0);
+    let edge = x.affine() * deckcraft_geom::Point::new(0.0, x.h / 4.0);
+    for tol in [0.5, 3.0, 8.0] {
+        s.execute("edit.deselect", &json!({})).unwrap();
+        assert!(matches!(s.hit_test(p, tol), Some(tools::Hit::Shape { id, .. }) if id == under));
+        assert!(matches!(s.hit_test(edge, tol), Some(tools::Hit::Shape { id, .. }) if id == over));
+        for kind in [PointerKind::Down, PointerKind::Up] {
+            s.pointer(PointerEvent { tol, ..tev(kind, p.x, p.y) }).unwrap();
+        }
+        assert_eq!(s.doc().unwrap().selection.shapes, vec![under]);
+    }
+}
+
+#[test]
+fn no_fill_hit_testing_resolves_style_and_theme_fills() {
+    use std::sync::Arc;
+    for source in ["style", "theme", "absent"] {
+        let mut s = session();
+        let (under, over) = no_fill_overlap(&mut s, true);
+        {
+            let st = s.doc_mut().unwrap();
+            let doc = Arc::make_mut(&mut st.doc);
+            if source == "theme" {
+                Arc::make_mut(&mut doc.masters[0]).theme.format.fills[0] = model::Fill::None;
+            }
+            let sh = Arc::make_mut(&mut doc.slides[st.selection.slide]).shapes.iter_mut().find(|sh| sh.id == over).unwrap();
+            assert!(sh.fill.is_none(), "the shape has no explicit fill override");
+            if source == "absent" {
+                sh.style = None;
+            } else {
+                sh.style.as_mut().unwrap().fill_ref.0 = if source == "style" { 0 } else { 1 };
+            }
+        }
+        s.execute("edit.deselect", &json!({})).unwrap();
+        let p = deckcraft_geom::Point::new(200.0, 310.0);
+        assert!(matches!(s.hit_test(p, 3.0), Some(tools::Hit::Shape { id, .. }) if id == under), "{source}");
+        // An explicit fill takes precedence over the no-fill style/theme.
+        s.execute("edit.select", &json!({"ids": [over.0]})).unwrap();
+        s.execute("shape.fill", &json!({"color": "#336699"})).unwrap();
+        s.execute("edit.deselect", &json!({})).unwrap();
+        assert!(matches!(s.hit_test(p, 3.0), Some(tools::Hit::Shape { id, .. }) if id == over), "{source}");
+    }
+}
+
+#[test]
+fn no_fill_text_shapes_keep_their_interior_text_target() {
+    let mut s = session();
+    let (_, over) = no_fill_overlap(&mut s, true);
+    s.execute("text.set", &json!({"id": over.0, "text": "FOREGROUND TEXT"})).unwrap();
+    s.execute("shape.fill", &json!({"none": true})).unwrap();
+    s.execute("edit.deselect", &json!({})).unwrap();
+    let p = deckcraft_geom::Point::new(200.0, 310.0);
+    assert!(matches!(s.hit_test(p, 3.0), Some(tools::Hit::Shape { id, text: true }) if id == over));
+    s.pointer(tev(PointerKind::DoubleClick, p.x, p.y)).unwrap();
+    assert_eq!(text_sel(&s).unwrap().shape, over);
+}
+
 /// #931: while the text of a placeholder is being edited, a shape in front of it still takes a
 /// click (as in PowerPoint); a click on the text where nothing is in front still moves the caret.
 #[test]
diff --git a/crates/engine/src/tools/hit.rs b/crates/engine/src/tools/hit.rs
index 6a0da529f..0e4b6ddcb 100644
--- a/crates/engine/src/tools/hit.rs
+++ b/crates/engine/src/tools/hit.rs
@@ -267,8 +267,11 @@ pub(super) fn hit_shape(st: &crate::DocState, sh: &Shape, p: Point, tol: f64) ->
                 return None;
             }
             let has_text = matches!(sh.kind, ShapeKind::Shape) && (sh.text.as_ref().is_some_and(|t| !t.is_empty()) || sh.ph.is_some() || sh.text_box);
-            // Empty interiors of unfilled, text-less shapes don't catch clicks.
-            let filled = !matches!(sh.fill, Some(deckcraft_model::Fill::None)) || sh.style.is_some();
+            // Match rendering: an explicit No Fill overrides the style, and style/theme fills
+            // can themselves be No Fill. Empty, text-less interiors then let clicks through.
+            let fill =
+                cmd::text::ctx_for(&st.doc, &st.selection).map(|ctx| deckcraft_model::resolve::fill(&ctx, sh).0).unwrap_or_else(|| sh.fill.clone());
+            let filled = !matches!(fill, None | Some(deckcraft_model::Fill::None));
             let geo = deckcraft_render::shape_geometry(sh, x.w, x.h);
             let in_geo = {
                 use deckcraft_geom::KurboShape;
diff --git a/docs/gaps.md b/docs/gaps.md
index 29edfd573..3bc26cce7 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Where DeckCraft falls short of PowerPoint
 
-> **Last reviewed:** 2026-10-30 · **Last updated:** 2026-10-30 · **Change:** minor (slide-show hit testing follows each shape’s own animation state; scale and rotation covered; previous: trivial, AutoFormat lists run independently of Replace text as you type; previous: minor, slide-show click targets follow animated shapes and text links; previous: minor, Animation Pane ▸ Play From; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: soak tests, PPTX corpus, comment threads (#70), embedded fonts, SmartArt Text Pane, Animation Pane timeline, Hunspell spelling, thesaurus, AutoCorrect, 14 new dialogs, pen pressure and trackpad gestures; duplicated entries and headers folded; previous: minor, 3-D bevel, camera and face lighting rendered) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-10-31 · **Change:** trivial (No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 
 Every known shortfall, one entry each, ranked by how much it stops someone who presents with
 PowerPoint from switching. This is the work list: pick from the top. Numbers are summarized in
@@ -368,6 +368,7 @@ Detail in [localization-parity.md](localization-parity.md).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-31 | trivial | No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged |
 | 2026-10-30 | minor | Slide-show click targets use each shape’s own animation state; scale and rotation test added |
 | 2026-10-28 | trivial | Automatic lists now run independently of Replace text as you type; proofing gap description updated |
 | 2026-10-27 | minor | Refreshed against merged PRs: removed the Morph alignment entry (#67 merged 2026-10-14); #77 (animation rewind, PR #83) is fixed, leaving #74 in the round-trip gap; #75 was closed unmerged, so #60 stays open with no fix PR; #53 is closed and the image-paste gap is now Windows #1414; Reuse Slides (#1103) and Compare reject (#850) noted in the smaller rows; the duplicate header line is gone |
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index 0c0d3ec60..c088bd018 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -2,6 +2,8 @@
 
 > **Generated:** 2026-10-14 (bullets/numbering remain D after empty-line marker review; summary by `cargo xtask parity`; rows re-scored by the 2026-10-14 community PR wave, duplicate Thesaurus, AutoCorrect, Artistic effects and Corrections rows folded; Preview in editor re-scored 2026-10-13; earlier rows re-scored 2026-10-10 against PowerPoint for Mac 16.113.4; video/animated GIF row re-scored 2026-10-11, #171) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 
+> **Last updated:** 2026-10-31 · Fill row re-assessed after #1621: remains D; No Fill hit-testing now follows resolved appearance. Scores unchanged.
+
 The summary between `<!-- SUMMARY -->
 **Weighted breadth parity: 84%** over 191 features.
 
@@ -118,7 +120,7 @@ Open P0 items: Contextual tabs (Shape Format, Picture Format, Table Design/Layou
 | Shapes | Text warp transforms | P2 | P |
 | Shapes | Shape quick styles | P1 | D |
 | Shapes | Set as default shape | P2 | D |
-| Format | Solid fill and transparency | P0 | D |
+| Format | Solid fill and transparency (No Fill interiors pass clicks through, #1621) | P0 | D |
 | Format | Gradient fill (linear, radial, rectangular, path) | P0 | D |
 | Format | Picture and texture fill | P1 | P |
 | Format | Pattern fill | P2 | P |
@@ -233,3 +235,9 @@ Open P0 items: Contextual tabs (Shape Format, Picture Format, Table Design/Layou
 | Platforms (✱) | macOS, Windows, Linux builds | P0 | P |
 | Platforms (✱) | Web (WASM) build | P1 | D |
 | Platforms (✱) | BSD build | P2 | P |
+
+## Revision history
+
+| Date | Change | Summary |
+|---|---|---|
+| 2026-10-31 | trivial | No Fill interior hit-testing follows resolved fill (#1621); fill row remains D and summary scores are unchanged |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 1e2ef52f4..fa5f9ae88 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI parity with PowerPoint
 
-> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-29 · **Change:** trivial (Picture Format: the Picture Styles row leaves room for Crop and Size, #1232; previous: trivial, Edit Points: Shift, Ctrl/Cmd or Alt/Option on a handle drag sets the point type; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: major, community PR wave 2026-10-14: 14 new dialogs (41 in all), Eyedropper, Export button, New Window, Grid Options, WordArt gallery and handles, Slide Sorter sections, Quick Access Toolbar, Format Background and Format Shape depth, rich-text clipboard; duplicated rows and headers folded; previous: minor, File tab / Backstage, #76) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-10-31 · **Change:** trivial (No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-26 · **Change:** trivial (dragging several selected slides moves them all; previous: trivial, Edit Points: Shift, Ctrl/Cmd or Alt/Option on a handle drag sets the point type; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: major, community PR wave 2026-10-14: 14 new dialogs (41 in all), Eyedropper, Export button, New Window, Grid Options, WordArt gallery and handles, Slide Sorter sections, Quick Access Toolbar, Format Background and Format Shape depth, rich-text clipboard; duplicated rows and headers folded; previous: minor, File tab / Backstage, #76) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-22 · **Change:** trivial (group fill and outline edits reach members, #1079; scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-24 · **Change:** trivial (Edit Points: Shift, Ctrl/Cmd or Alt/Option on a handle drag sets the point type; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: major, community PR wave 2026-10-14: 14 new dialogs (41 in all), Eyedropper, Export button, New Window, Grid Options, WordArt gallery and handles, Slide Sorter sections, Quick Access Toolbar, Format Background and Format Shape depth, rich-text clipboard; duplicated rows and headers folded; previous: minor, File tab / Backstage, #76) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
@@ -81,7 +81,7 @@ menu colours taken from the theme tokens (menu `chrome`, page `card`).
 
 | Behaviour | PowerPoint | DeckCraft |
 |---|---|---|
-| Selection handles, rotation handle, yellow adjustment handles | yes | yes |
+| Selection handles, rotation handle, yellow adjustment handles | yes | yes; an empty No Fill shape passes interior clicks to underlying objects while its outline and handles remain selectable. Explicit, style and theme fills resolve as rendered (#1621) |
 | Marquee, Shift/Cmd multi-select, Tab to cycle | yes | yes |
 | Objects off the slide: drawn on the area around it in Normal view (full strength, master graphics too), selectable and movable there; clipped in the show, exports and thumbnails | yes | yes (#270) |
 | Scroll bars on the slide pane when the zoomed slide is larger than the window | yes | yes, on each axis that overflows: drag the thumb or click the track; the wheel and trackpad still pan. The vertical bar does not turn the page (#1157) |
@@ -171,6 +171,7 @@ consistency is open (#73, #56).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-31 | trivial | No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged |
 | 2026-10-29 | trivial | Picture Format: the Picture Styles row shows as many styles as fit beside the groups after it (at least two) and a More arrow with all 24, as the Transitions and Animations galleries do; Crop and Size are in view in the default window (#1232) |
 | 2026-10-26 | trivial | Thumbnail pane and Slide Sorter: dragging one of several selected slides moves the whole selection |
 | 2026-10-24 | trivial | Table cells: dragging across cells selects a range of cells |

From d990678b32609e7f7301be4f389481c83c7eba96 Mon Sep 17 00:00:00 2001
From: Simon Koch-Sultan <126534658+scks1@users.noreply.github.com>
Date: Sat, 31 Oct 2026 17:18:44 -0400
Subject: [PATCH 61/88] render: keep even-odd holes open in shadow, glow and
 reflection silhouettes

effects_below merged all subpaths into one silhouette and filled it
with the NonZero rule, discarding each subpath's even_odd flag, so the
holes of donut, frame and similar preset shapes filled in under outer
shadows, glows and reflections. Fill each participating subpath under
its own fill rule at the three effect fill sites, mirroring
fill_geometry; the glow stroke keeps the merged silhouette.

Fixes #1596. The picture-content shadow clip path is unchanged
(that is #1597's territory).
---
 crates/render/src/renderer.rs | 42 ++++++++++++++++++++++++-----
 crates/render/src/tests.rs    | 50 +++++++++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+), 7 deletions(-)

diff --git a/crates/render/src/renderer.rs b/crates/render/src/renderer.rs
index 84c5e5a8f..c25f6bab6 100644
--- a/crates/render/src/renderer.rs
+++ b/crates/render/src/renderer.rs
@@ -1125,12 +1125,15 @@ impl Renderer {
                 // see-through as its fill (none for an outline-only shape) …
                 None => {
                     if let Some(a) = fill_alpha {
-                        let mut filled = BezPath::new();
-                        for sp in geo.paths.iter().filter(|sp| sp.fill != FillMode::None) {
-                            filled.extend(sp.path.iter());
-                        }
                         ctx.set_paint(color(c.with_alpha(255), a));
-                        ctx.fill_path(&filled);
+                        // Each subpath under its own fill rule, as the shape itself is
+                        // drawn: one merged path filled NonZero fills the hole of an
+                        // even-odd shape (a donut, a frame) (#1596).
+                        for sp in geo.paths.iter().filter(|sp| sp.fill != FillMode::None) {
+                            ctx.set_fill_rule(if sp.even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
+                            ctx.fill_path(&sp.path);
+                        }
+                        ctx.set_fill_rule(peniko::Fill::NonZero);
                     }
                 }
             }
@@ -1161,7 +1164,19 @@ impl Renderer {
             ctx.stroke_path(&silhouette);
             // A shape without a fill (an outline, a frame) glows along its line only (#225).
             if fill_alpha.is_some() || content.is_some() {
-                ctx.fill_path(&silhouette);
+                // Per subpath under its own fill rule, as in the shadow above: the
+                // merged silhouette filled NonZero fills an even-odd hole (#1596).
+                // When no subpath takes part the silhouette is the outline fallback.
+                let mut filled_any = false;
+                for sp in geo.paths.iter().filter(|sp| sp.fill != FillMode::None || fill.is_none()) {
+                    ctx.set_fill_rule(if sp.even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
+                    ctx.fill_path(&sp.path);
+                    filled_any = true;
+                }
+                if !filled_any {
+                    ctx.fill_path(&silhouette);
+                }
+                ctx.set_fill_rule(peniko::Fill::NonZero);
             }
             ctx.pop_layer();
         }
@@ -1180,7 +1195,20 @@ impl Renderer {
                 }
                 None => {
                     if let Some(fl) = fill {
-                        paint::fill_path(ctx, rctx, fl, ph, &silhouette, Rect::new(0.0, 0.0, w, h), mm, FillMode::Norm, 1.0, rctx.pres);
+                        // Per subpath under its own fill rule, as in the shadow above:
+                        // the merged silhouette filled NonZero fills an even-odd hole
+                        // (#1596). The outline fallback covers shapes with no
+                        // participating subpath.
+                        let mut filled_any = false;
+                        for sp in geo.paths.iter().filter(|sp| sp.fill != FillMode::None || fill.is_none()) {
+                            ctx.set_fill_rule(if sp.even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
+                            paint::fill_path(ctx, rctx, fl, ph, &sp.path, Rect::new(0.0, 0.0, w, h), mm, FillMode::Norm, 1.0, rctx.pres);
+                            filled_any = true;
+                        }
+                        if !filled_any {
+                            paint::fill_path(ctx, rctx, fl, ph, &silhouette, Rect::new(0.0, 0.0, w, h), mm, FillMode::Norm, 1.0, rctx.pres);
+                        }
+                        ctx.set_fill_rule(peniko::Fill::NonZero);
                     }
                 }
             }
diff --git a/crates/render/src/tests.rs b/crates/render/src/tests.rs
index f01ee1cf8..2de2daabe 100644
--- a/crates/render/src/tests.rs
+++ b/crates/render/src/tests.rs
@@ -515,6 +515,56 @@ fn glow_of_a_shape_with_no_fill_and_no_line_is_not_drawn() {
     }
 }
 
+#[test]
+fn shadow_and_glow_keep_an_even_odd_shapes_hole() {
+    // #1596: a donut is one even-odd subpath — its hole exists only under the
+    // even-odd rule. The effects were cast from a merged silhouette filled
+    // NonZero, so the shadow and the glow filled the hole solid. The hole's
+    // centre must stay the slide's white in both, while the effects still draw.
+    let donut = |effects: deckcraft_model::Effects| {
+        let mut sh = Shape {
+            id: ShapeId(612),
+            xfrm: Some(Xfrm::new(50.0, 50.0, 200.0, 200.0)),
+            geom: Geom::preset("donut"),
+            fill: Some(Fill::solid(ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 160, 0)))),
+            ..Default::default()
+        };
+        sh.effects = Some(effects);
+        render_slide(&deck_with(vec![sh]), 0, &RenderOpts { scale: 1.0, ..Default::default() })
+    };
+    let img = donut(deckcraft_model::Effects {
+        outer_shadow: Some(deckcraft_model::style::Shadow {
+            color: ColorRef::rgb(deckcraft_color::Rgba::BLACK),
+            blur: 8.0,
+            dist: 0.0,
+            dir: 45.0,
+            inner: false,
+            sx: 1.0,
+            sy: 1.0,
+            kx: 0.0,
+            ky: 0.0,
+            align: String::new(),
+            rotate_with_shape: false,
+        }),
+        ..Default::default()
+    });
+    let hole = img.pixel(150, 150);
+    assert!(hole[0] > 245 && hole[1] > 245 && hole[2] > 245, "shadow in the hole: {hole:?}");
+    // The shadow still falls around the shape (just below its bottom edge).
+    let below = img.pixel(150, 251);
+    assert!(below[0] < 200 && below[0] == below[2], "no shadow below: {below:?}");
+
+    let img = donut(deckcraft_model::Effects {
+        glow: Some(deckcraft_model::style::Glow { color: ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0)), radius: 8.0 }),
+        ..Default::default()
+    });
+    let hole = img.pixel(150, 150);
+    assert!(hole[0] > 245 && hole[1] > 245 && hole[2] > 245, "glow in the hole: {hole:?}");
+    // The ring itself is the shape's orange.
+    let ring = img.pixel(150, 75);
+    assert!(ring[0] > 200 && ring[1] > 100 && ring[2] < 100, "ring: {ring:?}");
+}
+
 #[test]
 fn placeholder_prompts_only_in_edit_view() {
     let p = Presentation::default();

From 82573331a8f2b87ccb536b9b66d55b90295f2111 Mon Sep 17 00:00:00 2001
From: "Dylan M. Taylor" <dylan@dylanmtaylor.com>
Date: Sat, 31 Oct 2026 18:52:58 -0400
Subject: [PATCH 62/88] packaging(flatpak): add OCI image build and GHCR
 publishing helper (#1625)

---
 packaging/linux/flatpak-bundle.sh |  8 ++++
 packaging/linux/flatpak-oci.sh    | 64 +++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100755 packaging/linux/flatpak-oci.sh

diff --git a/packaging/linux/flatpak-bundle.sh b/packaging/linux/flatpak-bundle.sh
index 3a5508d7c..e56692adf 100755
--- a/packaging/linux/flatpak-bundle.sh
+++ b/packaging/linux/flatpak-bundle.sh
@@ -20,10 +20,12 @@ APP_ID=ai.storyteller.deckcraft
 FLATHUB=https://dl.flathub.org/repo/flathub.flatpakrepo
 
 TEST=1
+OCI=0
 TARBALL=""
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --no-test) TEST=0; shift ;;
+    --oci) OCI=1; shift ;;
     -h | --help) sed -n '2,14p' "$0"; exit 0 ;;
     -*) echo "unknown argument: $1" >&2; exit 2 ;;
     *) TARBALL="$1"; shift ;;
@@ -61,6 +63,12 @@ OUT="$DIST/$BASENAME.flatpak"
 # --runtime-repo lets `flatpak install` fetch the freedesktop runtime from Flathub if missing.
 flatpak build-bundle --runtime-repo="$FLATHUB" "$WORK/repo" "$OUT" "$APP_ID" stable
 echo "wrote $OUT"
+if [[ "$OCI" = 1 ]]; then
+  OUT_OCI="$DIST/$BASENAME-oci"
+  rm -rf "$OUT_OCI"
+  flatpak build-bundle --oci "$WORK/repo" "$OUT_OCI" "$APP_ID" stable
+  echo "wrote OCI layout to $OUT_OCI"
+fi
 
 if [[ "$TEST" = 1 ]]; then
   flatpak install --user -y --noninteractive --reinstall "$OUT"
diff --git a/packaging/linux/flatpak-oci.sh b/packaging/linux/flatpak-oci.sh
new file mode 100755
index 000000000..5dd360353
--- /dev/null
+++ b/packaging/linux/flatpak-oci.sh
@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# Build deckcraft as an OCI container layout and push it to GitHub Container Registry (GHCR)
+# for consumption by Flatpak OCI clients (flatpak-oci-specs).
+#
+# Usage:
+#   packaging/linux/flatpak-oci.sh [--push] [TARBALL]
+#
+# Environment variables:
+#   REGISTRY       Target registry image (default: ghcr.io/storytold/deckcraft)
+#   TAG            Target image tag (default: $VERSION-$ARCH, also tags stable-$ARCH)
+#   GITHUB_TOKEN   Token for GHCR authentication when --push is used
+set -euo pipefail
+# shellcheck source=../env.sh
+. "$(dirname "${BASH_SOURCE[0]}")/../env.sh"
+HERE="$ROOT/packaging/linux"
+
+PUSH=0
+TARBALL=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --push) PUSH=1; shift ;;
+    -h | --help) sed -n '2,12p' "$0"; exit 0 ;;
+    -*) echo "unknown argument: $1" >&2; exit 2 ;;
+    *) TARBALL="$1"; shift ;;
+  esac
+done
+
+ARCH="$(uname -m)"
+case "$ARCH" in
+  x86_64) ;;
+  aarch64 | arm64) ARCH=aarch64 ;;
+  *) echo "unsupported architecture $ARCH" >&2; exit 2 ;;
+esac
+
+BASENAME="deckcraft-$VERSION-linux-$ARCH"
+OUT_OCI="$DIST/$BASENAME-oci"
+
+echo "==> Building Flatpak OCI layout for $BASENAME"
+"$HERE/flatpak-bundle.sh" --oci --no-test "${TARBALL:-}"
+
+[[ -d "$OUT_OCI" ]] || { echo "error: $OUT_OCI layout not generated" >&2; exit 1; }
+
+REGISTRY="${REGISTRY:-ghcr.io/storytold/deckcraft}"
+TAG="${TAG:-$VERSION-$ARCH}"
+
+echo "==> OCI layout ready at $OUT_OCI (Target: $REGISTRY:$TAG)"
+
+if [[ "$PUSH" = 1 ]]; then
+  command -v skopeo >/dev/null || { echo "error: skopeo is required to push OCI images (apt install skopeo)" >&2; exit 1; }
+
+  AUTH_ARGS=()
+  if [[ -n "${GITHUB_TOKEN:-}" ]]; then
+    AUTH_ARGS=(--dest-creds "${GITHUB_ACTOR:-storytold}:$GITHUB_TOKEN")
+  fi
+
+  echo "==> Pushing to $REGISTRY:$TAG"
+  skopeo copy --format oci "${AUTH_ARGS[@]}" "oci:$OUT_OCI" "docker://$REGISTRY:$TAG"
+
+  # Also update architecture-specific stable tag
+  echo "==> Pushing to $REGISTRY:stable-$ARCH"
+  skopeo copy --format oci "${AUTH_ARGS[@]}" "oci:$OUT_OCI" "docker://$REGISTRY:stable-$ARCH"
+
+  echo "==> Push complete"
+fi

From 3fb6c4313657a2f755ab9bc99abd3cfff8a1ec0b Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Sun, 1 Nov 2026 00:08:51 +0100
Subject: [PATCH 63/88] =?UTF-8?q?Lowercase=20word-final=20=CE=A3=20as=20?=
 =?UTF-8?q?=CF=82=20in=20title=20and=20sentence=20case?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Found while testing crates/model/src/edit.rs:470-497 (change_case_parts, title/sentence branch)

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/model/src/edit.rs | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/crates/model/src/edit.rs b/crates/model/src/edit.rs
index d635c052e..3e21e3bf8 100644
--- a/crates/model/src/edit.rs
+++ b/crates/model/src/edit.rs
@@ -469,6 +469,9 @@ pub fn change_case(s: &str, mode: &str) -> String {
 /// piece is the changed form of the matching input piece, even where a character changes length.
 pub fn change_case_parts(parts: &[&str], mode: &str) -> Vec<String> {
     let mut start = true;
+    // All characters of all pieces, so word-final sigma sees neighbours across piece boundaries.
+    let all: Vec<char> = parts.iter().flat_map(|s| s.chars()).collect();
+    let mut base = 0;
     parts
         .iter()
         .map(|s| match mode {
@@ -479,10 +482,14 @@ pub fn change_case_parts(parts: &[&str], mode: &str) -> Vec<String> {
                 // `title` restarts after whitespace, sentence case after sentence punctuation.
                 let title = mode == "title";
                 let mut out = String::new();
-                for c in s.chars() {
+                for (j, c) in s.chars().enumerate() {
+                    let i = base + j;
                     if start && c.is_alphabetic() {
                         out.extend(c.to_uppercase());
                         start = false;
+                    } else if c == 'Σ' && i > 0 && all[i - 1].is_alphabetic() && !all.get(i + 1).is_some_and(|n| n.is_alphabetic()) {
+                        // Word-final capital sigma lowercases to ς, as `str::to_lowercase` does.
+                        out.push('ς');
                     } else {
                         out.extend(c.to_lowercase());
                     }
@@ -490,6 +497,7 @@ pub fn change_case_parts(parts: &[&str], mode: &str) -> Vec<String> {
                         start = true;
                     }
                 }
+                base += s.chars().count();
                 out
             }
         })
@@ -504,6 +512,20 @@ mod tests {
         TextBody::from_text(t)
     }
 
+    #[test]
+    fn title_and_sentence_final_sigma() {
+        assert_eq!(change_case("ΟΔΟΣ", "title"), "Οδος");
+        assert_eq!(change_case("ΟΔΟΣ ΜΟΥ.", "sentence"), "Οδος μου.");
+        assert_eq!(change_case("ΟΔΟΣ", "lower"), "οδος");
+    }
+
+    #[test]
+    fn title_sigma_across_runs_is_not_final() {
+        assert_eq!(change_case_parts(&["ΟΔΟΣ", "ΑΣ"], "title"), ["Οδοσ", "ας"]);
+        assert_eq!(change_case_parts(&["ΟΔΟ", "ΣΑ"], "title"), ["Οδο", "σα"]);
+        assert_eq!(change_case_parts(&["ΟΔΟΣ", " ΜΟΥ"], "title"), ["Οδος", " Μου"]);
+    }
+
     #[test]
     fn insert_and_split() {
         let mut b = body("Hello");

From 87a10fc8e2af63042e560e530336f1cc6ff8c535 Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Sun, 1 Nov 2026 00:19:15 +0100
Subject: [PATCH 64/88] Keep combining marks inside spell-check words

Found while testing crates/engine/src/spell.rs:693 (paragraph_words, the `inside` closure)

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/engine/src/spell.rs | 12 ++++++++++--
 crates/model/src/words.rs  |  7 ++++++-
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/crates/engine/src/spell.rs b/crates/engine/src/spell.rs
index 93852e3f8..8927ade5b 100644
--- a/crates/engine/src/spell.rs
+++ b/crates/engine/src/spell.rs
@@ -709,7 +709,8 @@ pub fn paragraph_words(p: &deckcraft_model::Paragraph, default: &str) -> Vec<Wor
         chars.extend(r.content().chars().map(|c| (c, ri)));
     }
     let lang_of = |ri: usize| p.runs.get(ri).and_then(|r| r.props.lang.clone()).filter(|l| !l.is_empty()).unwrap_or_else(|| default.to_string());
-    let inside = |c: char| c.is_alphanumeric() || c == '\'' || c == '’' || c == '-';
+    // Combining marks (decomposed accents) belong to the letter before them.
+    let inside = |c: char| c.is_alphanumeric() || deckcraft_model::words::is_combining_mark(c) || c == '\'' || c == '’' || c == '-';
     let mut out = vec![];
     let mut i = 0;
     while i < chars.len() {
@@ -725,7 +726,7 @@ pub fn paragraph_words(p: &deckcraft_model::Paragraph, default: &str) -> Vec<Wor
         while a < b && !chars[a].0.is_alphanumeric() {
             a += 1;
         }
-        while b > a && !chars[b - 1].0.is_alphanumeric() {
+        while b > a && !chars[b - 1].0.is_alphanumeric() && !deckcraft_model::words::is_combining_mark(chars[b - 1].0) {
             b -= 1;
         }
         let text: String = chars[a..b].iter().map(|c| c.0).collect();
@@ -819,6 +820,13 @@ SFX D Y 1\nSFX D 0 ed/S .\n";
         Dictionary::parse(AFF.as_bytes(), DIC.as_bytes())
     }
 
+    #[test]
+    fn nfd_word_not_split() {
+        let p = deckcraft_model::Paragraph::new("Das na\u{ef}ve Caf\u{e9} und cafe\u{301} na\u{308}ive");
+        let w: Vec<String> = paragraph_words(&p, "en-US").into_iter().map(|w| w.text).collect();
+        assert_eq!(w, ["Das", "na\u{ef}ve", "Caf\u{e9}", "und", "cafe\u{301}", "na\u{308}ive"]);
+    }
+
     #[test]
     fn curly_apostrophe_matches_ascii_entry() {
         let d = Dictionary::parse(AFF.as_bytes(), "2\ndon't\nwork\n".as_bytes());
diff --git a/crates/model/src/words.rs b/crates/model/src/words.rs
index 54b23659f..bcf662e22 100644
--- a/crates/model/src/words.rs
+++ b/crates/model/src/words.rs
@@ -90,11 +90,16 @@ fn base_class(c: char) -> Class {
         c if c.is_alphanumeric() => Class::Word,
         c if is_symbol(c) => Class::Symbol,
         // A combining mark with no base (or any other mark) stays with letters.
-        '\u{300}'..='\u{36f}' | '\u{1ab0}'..='\u{1aff}' | '\u{1dc0}'..='\u{1dff}' | '\u{20d0}'..='\u{20ff}' | '\u{fe20}'..='\u{fe2f}' => Class::Word,
+        c if is_combining_mark(c) => Class::Word,
         _ => Class::Punct,
     }
 }
 
+/// Whether `c` is a combining mark (a decomposed accent), which belongs to the letter before it.
+pub fn is_combining_mark(c: char) -> bool {
+    matches!(c, '\u{300}'..='\u{36f}' | '\u{1ab0}'..='\u{1aff}' | '\u{1dc0}'..='\u{1dff}' | '\u{20d0}'..='\u{20ff}' | '\u{fe20}'..='\u{fe2f}')
+}
+
 fn clusters(text: &str) -> Vec<Cluster> {
     let mut out: Vec<Cluster> = Vec::new();
     let mut firsts: Vec<char> = Vec::new();

From 8ec4f29059de67706a72e1066b06cc592828aa80 Mon Sep 17 00:00:00 2001
From: Madhasoeki <ramadhan.kpj@gmail.com>
Date: Sun, 1 Nov 2026 07:19:41 +0700
Subject: [PATCH 65/88] Fonts: refine monospace heuristic and preserve
 office_twin order (#1598)

- Avoid false-positive monospace match on 'code' in split_whitespace for
  proportional families like Code Pro.
- Check office_twin before is_monospace_family in document_face so alias
  families like Courier New CE resolve to Courier New when installed.
- Add negative tests for Code Pro and test Courier New CE mapping.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 crates/fonts/src/fontdb.rs | 12 +++++-------
 crates/fonts/src/tests.rs  | 12 ++++++++----
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rs
index cc2bd417a..1cffbe008 100644
--- a/crates/fonts/src/fontdb.rs
+++ b/crates/fonts/src/fontdb.rs
@@ -105,7 +105,7 @@ pub fn is_monospace_family(family: &str) -> bool {
         || s.ends_with(" console")
         || s.ends_with(" typewriter")
         || s.ends_with(" monospace")
-        || s.split_whitespace().any(|w| w == "mono" || w == "code" || w == "terminal" || w == "monospace")
+        || s.split_whitespace().any(|w| w == "mono" || w == "terminal" || w == "monospace")
 }
 
 /// Families whose open substitutes ([`substitutes`]) keep their metrics, so text drawn with
@@ -1149,17 +1149,15 @@ impl FontDb {
     /// Monospaced families keep a monospaced substitute instead of falling back to Calibri.
     /// DeckCraft's own default family keeps [`FontDb::face`]'s fallbacks.
     pub fn document_face(&self, family: &str, style: &str) -> Arc<FontFace> {
-        if family.eq_ignore_ascii_case(FALLBACK_FAMILY)
-            || has_metric_twin(family)
-            || is_monospace_family(family)
-            || is_office_cloud_font(family)
-            || self.has_family(family)
-        {
+        if family.eq_ignore_ascii_case(FALLBACK_FAMILY) || has_metric_twin(family) || is_office_cloud_font(family) || self.has_family(family) {
             return self.face(family, style);
         }
         if let Some(twin) = office_twin(family) {
             return self.face(twin, style);
         }
+        if is_monospace_family(family) {
+            return self.face(family, style);
+        }
         self.face(MISSING_FONT_FAMILY, style)
     }
 
diff --git a/crates/fonts/src/tests.rs b/crates/fonts/src/tests.rs
index 69f54227d..f912f9988 100644
--- a/crates/fonts/src/tests.rs
+++ b/crates/fonts/src/tests.rs
@@ -216,9 +216,13 @@ fn missing_document_fonts_are_drawn_in_calibri() {
         assert_eq!(f.family, db.face(MISSING_FONT_FAMILY, "Bold").family, "{missing:?}");
     }
     // PowerPoint's own twins and Windows' substitutes, when the font itself is missing.
-    for (missing, twin) in
-        [("Liberation Sans", "Arial"), ("Liberation Serif", "Times New Roman"), ("Arial CE", "Arial"), ("Times New Roman CYR", "Times New Roman")]
-    {
+    for (missing, twin) in [
+        ("Liberation Sans", "Arial"),
+        ("Liberation Serif", "Times New Roman"),
+        ("Arial CE", "Arial"),
+        ("Times New Roman CYR", "Times New Roman"),
+        ("Courier New CE", "Courier New"),
+    ] {
         if !db.has_family(missing) {
             assert_eq!(db.document_face(missing, "Regular").family, db.face(twin, "Regular").family, "{missing}");
         }
@@ -261,7 +265,7 @@ fn office_fonts_have_substitutes() {
         assert!(is_monospace_family(mono), "{mono} should be recognized as monospace");
     }
 
-    for prop in ["Calibri", "Arial", "Times New Roman", "Inter", "Monotype Corsiva", "Monotype Baskerville", "zzz"] {
+    for prop in ["Calibri", "Arial", "Times New Roman", "Inter", "Monotype Corsiva", "Monotype Baskerville", "Code Pro", "zzz"] {
         assert!(!is_monospace_family(prop), "{prop} should not be recognized as monospace");
     }
 }

From 773133ec42c01ea7f418e5bdb1048453dd427c50 Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Sun, 1 Nov 2026 00:52:04 +0000
Subject: [PATCH 66/88] Apply alphaMod and alphaOff in ColorRef::alpha

Found while testing crates/model/src/style.rs:59-63

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/model/src/style.rs |  4 +++-
 crates/model/src/tests.rs | 12 ++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/crates/model/src/style.rs b/crates/model/src/style.rs
index e2d70b994..3b81d3ae5 100644
--- a/crates/model/src/style.rs
+++ b/crates/model/src/style.rs
@@ -55,10 +55,12 @@ impl ColorRef {
         };
         deckcraft_color::apply(base, &self.mods)
     }
-    /// Alpha (0–1) from an `alpha` transform, if any.
+    /// Alpha (0–1) from the `alpha`, `alphaMod` and `alphaOff` transforms, applied in order.
     pub fn alpha(&self) -> f64 {
         self.mods.iter().fold(1.0, |a, m| match m {
             ColorTransform::Alpha(v) => (*v as f64 / 100_000.0).clamp(0.0, 1.0),
+            ColorTransform::AlphaMod(v) => (a * *v as f64 / 100_000.0).clamp(0.0, 1.0),
+            ColorTransform::AlphaOff(v) => (a + *v as f64 / 100_000.0).clamp(0.0, 1.0),
             _ => a,
         })
     }
diff --git a/crates/model/src/tests.rs b/crates/model/src/tests.rs
index 1fd29aeff..4ae6fc0fd 100644
--- a/crates/model/src/tests.rs
+++ b/crates/model/src/tests.rs
@@ -327,3 +327,15 @@ fn only_web_and_mail_links_are_safe_to_open() {
         assert!(!safe_url(url), "{url}");
     }
 }
+
+#[test]
+fn colour_alpha_follows_alpha_mod_and_off() {
+    use deckcraft_color::{ColorTransform, Rgba};
+    let base = || ColorRef::rgb(Rgba::rgb(1, 2, 3));
+    let mod_half = base().with(ColorTransform::AlphaMod(50000));
+    assert!((mod_half.alpha() - 0.5).abs() < 1e-9, "{}", mod_half.alpha());
+    let off = base().with(ColorTransform::AlphaOff(-50000));
+    assert!((off.alpha() - 0.5).abs() < 1e-9, "{}", off.alpha());
+    let both = base().with(ColorTransform::Alpha(40000)).with(ColorTransform::AlphaMod(50000));
+    assert!((both.alpha() - 0.2).abs() < 1e-9, "{}", both.alpha());
+}

From 5d27461fa633f261a6af037bac9b8ce0953a25ba Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Sun, 1 Nov 2026 02:55:58 +0100
Subject: [PATCH 67/88] Keep Xfrm::rot_norm within 0..360 for tiny negative
 rotations

Found while testing crates/geom/src/lib.rs:155-158

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/geom/src/lib.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rs
index 3be72e03f..6f695375b 100644
--- a/crates/geom/src/lib.rs
+++ b/crates/geom/src/lib.rs
@@ -153,8 +153,8 @@ impl Xfrm {
     }
     /// Rotation normalised to 0..360.
     pub fn rot_norm(&self) -> f64 {
-        let r = self.rot % 360.0;
-        if r < 0.0 { r + 360.0 } else { r }
+        let r = self.rot.rem_euclid(360.0);
+        if r >= 360.0 { 0.0 } else { r }
     }
 }
 
@@ -266,6 +266,14 @@ mod tests {
         assert!((p.x - 300.0).abs() < 1e-9 && (p.y - 200.0).abs() < 1e-9);
     }
 
+    #[test]
+    fn rot_norm_stays_below_360() {
+        for rot in [-1e-15, -1e-13, -f64::EPSILON, -0.0, 360.0, 720.0, -360.0] {
+            let n = Xfrm { rot, ..Default::default() }.rot_norm();
+            assert!((0.0..360.0).contains(&n), "rot {rot} -> {n}");
+        }
+    }
+
     #[test]
     fn segment_distance() {
         assert!((dist_to_segment(Point::new(5.0, 5.0), Point::new(0.0, 0.0), Point::new(10.0, 0.0)) - 5.0).abs() < 1e-9);

From c0468b59cd043286ca7453c0465da898a4f36751 Mon Sep 17 00:00:00 2001
From: Madhasoeki <ramadhan.kpj@gmail.com>
Date: Sun, 1 Nov 2026 10:31:17 +0700
Subject: [PATCH 68/88] Fonts: classify Cascadia Code PL as monospace (#1598)

Add Cascadia Code PL and Cascadia Mono PL to the monospace family
matching list, and add regression tests.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 crates/fonts/src/fontdb.rs | 2 ++
 crates/fonts/src/tests.rs  | 1 +
 2 files changed, 3 insertions(+)

diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rs
index 1cffbe008..2e2f35299 100644
--- a/crates/fonts/src/fontdb.rs
+++ b/crates/fonts/src/fontdb.rs
@@ -72,7 +72,9 @@ pub fn is_monospace_family(family: &str) -> bool {
             | "source code pro"
             | "jetbrains mono"
             | "cascadia code"
+            | "cascadia code pl"
             | "cascadia mono"
+            | "cascadia mono pl"
             | "fira code"
             | "fira mono"
             | "inconsolata"
diff --git a/crates/fonts/src/tests.rs b/crates/fonts/src/tests.rs
index f912f9988..dc52cfbbb 100644
--- a/crates/fonts/src/tests.rs
+++ b/crates/fonts/src/tests.rs
@@ -251,6 +251,7 @@ fn office_fonts_have_substitutes() {
         "Source Code Pro",
         "JetBrains Mono",
         "Cascadia Code",
+        "Cascadia Code PL",
         "Cascadia Mono",
         "Fira Code",
         "Inconsolata",

From e6908295439bdb5dad0b334f104c3a52f04a6d94 Mon Sep 17 00:00:00 2001
From: "Dylan M. Taylor" <dylan@dylanmtaylor.com>
Date: Sat, 31 Oct 2026 23:43:08 -0400
Subject: [PATCH 69/88] ci: grant packages write permission to release workflow

---
 .github/workflows/release.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 9d061bce5..09b477f38 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -12,6 +12,7 @@ on:
 
 permissions:
   contents: write
+  packages: write
 
 concurrency:
   group: release-${{ github.ref }}

From f3d8ba85a62c72bb526dad3b91852485b1ab4f09 Mon Sep 17 00:00:00 2001
From: Madhasoeki <ramadhan.kpj@gmail.com>
Date: Sun, 1 Nov 2026 11:35:53 +0700
Subject: [PATCH 70/88] tests(fonts): add specific tests requested by reviewer
 for monospace resolution

Verify Consolas, Courier New, Fira Code, Monotype Corsiva, Monoton,
and ensure proportional family substitutes remain unchanged.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 crates/fonts/src/tests.rs | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/crates/fonts/src/tests.rs b/crates/fonts/src/tests.rs
index dc52cfbbb..596415d51 100644
--- a/crates/fonts/src/tests.rs
+++ b/crates/fonts/src/tests.rs
@@ -266,9 +266,24 @@ fn office_fonts_have_substitutes() {
         assert!(is_monospace_family(mono), "{mono} should be recognized as monospace");
     }
 
-    for prop in ["Calibri", "Arial", "Times New Roman", "Inter", "Monotype Corsiva", "Monotype Baskerville", "Code Pro", "zzz"] {
+    for prop in ["Calibri", "Arial", "Times New Roman", "Inter", "Monotype Corsiva", "Monoton", "Monotype Baskerville", "Code Pro", "zzz"] {
         assert!(!is_monospace_family(prop), "{prop} should not be recognized as monospace");
     }
+
+    // Explicit checks requested in review: Consolas, Courier New, Fira Code, Monotype Corsiva, Monoton,
+    // and ensuring proportional families maintain their unchanged substitutes.
+    assert!(is_monospace_family("Consolas"));
+    assert!(is_monospace_family("Courier New"));
+    assert!(is_monospace_family("Fira Code"));
+    assert!(!is_monospace_family("Monotype Corsiva"));
+    assert!(!is_monospace_family("Monoton"));
+
+    assert_eq!(substitutes("Calibri"), &["Carlito", "Liberation Sans", "Arial", "Inter"]);
+    assert_eq!(substitutes("Arial"), &["Liberation Sans", "Arial", "Helvetica Neue", "Helvetica", "Inter"]);
+    assert_eq!(substitutes("Times New Roman"), &["Liberation Serif", "Times New Roman", "Times", "Merriweather"]);
+    assert_eq!(substitutes("Georgia"), &["Merriweather", "Liberation Serif", "Georgia"]);
+    assert!(substitutes("Monotype Corsiva").is_empty());
+    assert!(substitutes("Monoton").is_empty());
 }
 
 #[test]

From c37b1509502cfcbc70c678adcde6f6c4cdab9ec5 Mon Sep 17 00:00:00 2001
From: Naseq <nasim.naseq@gmail.com>
Date: Sun, 1 Nov 2026 11:17:08 +0430
Subject: [PATCH 71/88] PPTX: parse each tags part once, cap copied tags, and
 bound cache (#1164)

- Parse each tags part once per import and cache in `Imp::tags_by_part`
- Cap total copied tags into the model at `MAX_TAG_BYTES` (64 MiB), charging each pair a fixed size_of::<(String, String)>() in addition to text
- Bound the cache: once `tags_capped` is set, return early before parsing or caching any subsequent part
- Tests covering deduplicated part copies, empty-tag pair budgets, and verifying unread tag parts are not parsed or cached after the budget is reached
---
 crates/pptx/src/lib.rs       |   1 +
 crates/pptx/src/read.rs      |  72 +++++++++++++++++++++--
 crates/pptx/tests/it/tags.rs | 108 +++++++++++++++++++++++++++++++++++
 3 files changed, 175 insertions(+), 6 deletions(-)

diff --git a/crates/pptx/src/lib.rs b/crates/pptx/src/lib.rs
index 1b1dc5b46..be08c680f 100644
--- a/crates/pptx/src/lib.rs
+++ b/crates/pptx/src/lib.rs
@@ -14,6 +14,7 @@ mod maps;
 mod opc;
 mod png;
 pub(crate) mod read;
+pub use read::MAX_TAG_BYTES;
 mod tables;
 mod write;
 mod xml;
diff --git a/crates/pptx/src/read.rs b/crates/pptx/src/read.rs
index 917aa9277..288e497f8 100644
--- a/crates/pptx/src/read.rs
+++ b/crates/pptx/src/read.rs
@@ -40,6 +40,12 @@ pub struct Imp<'a> {
     pub kept_sidecar_bytes: usize,
     /// Cached kept sidecars by normalized chart part name.
     pub kept_charts: HashMap<String, deckcraft_model::chart::ChartKept>,
+    /// Add-in tags parts, parsed once each, by normalized part name.
+    pub tags_by_part: HashMap<String, Arc<[(String, String)]>>,
+    /// Bytes of tags copied into the model so far (see [`MAX_TAG_BYTES`]).
+    pub tag_bytes: usize,
+    /// The tag budget ran out and the warning was given.
+    pub tags_capped: bool,
 }
 
 impl Imp<'_> {
@@ -196,16 +202,64 @@ fn choice_has_model3d(el: &El, rels: &Rels) -> bool {
     rec(el, rels, 0)
 }
 
+/// Bytes of tags one import copies into the model, every tags part and reference together: a
+/// small compressed tags part listed by many shapes, or many times by one, must not grow without
+/// bound (#1164). The package budgets (`opc::MAX_XML_PART`, `MAX_TOTAL`, #1283) bound what is
+/// parsed; this bounds what is copied from it.
+pub const MAX_TAG_BYTES: usize = 64 << 20;
+/// What each copied pair costs besides its text, so empty pairs count too.
+const TAG_PAIR_COST: usize = std::mem::size_of::<(String, String)>();
+
 /// Add-in tags named by `holder`'s `p:custDataLst`: the name/value pairs of each tags part.
-pub fn tags(imp: &Imp, part: &Part, holder: &El) -> Vec<(String, String)> {
+/// Each part is parsed once per import and counted once per holder. Once [`MAX_TAG_BYTES`] is
+/// reached, no further tag parts are parsed or cached (#1164).
+pub fn tags(imp: &mut Imp, part: &Part, holder: &El) -> Vec<(String, String)> {
+    if imp.tags_capped {
+        return vec![];
+    }
     let Some(list) = holder.child("custDataLst") else { return vec![] };
     let mut out = Vec::new();
+    let mut seen = HashSet::new();
     for t in list.children_named("tags").take(100) {
-        let Some(doc) = t.attr("r:id").and_then(|id| part.rels.get(id)).and_then(|r| imp.pkg.xml(&r.target)) else { continue };
-        for tag in doc.root.children_named("tag").take(10_000) {
-            if let Some(name) = tag.attr("name") {
-                out.push((name.to_string(), tag.attr("val").unwrap_or("").to_string()));
+        if imp.tags_capped {
+            return out;
+        }
+        let Some(target) = t.attr("r:id").and_then(|id| part.rels.get(id)).map(|r| opc::norm(&r.target)) else { continue };
+        if !seen.insert(target.clone()) {
+            continue;
+        }
+        let parsed = match imp.tags_by_part.get(&target) {
+            Some(p) => p.clone(),
+            None => {
+                if imp.tags_capped {
+                    return out;
+                }
+                let p: Arc<[(String, String)]> = imp
+                    .pkg
+                    .xml(&target)
+                    .map(|doc| {
+                        doc.root
+                            .children_named("tag")
+                            .take(10_000)
+                            .filter_map(|tag| Some((tag.attr("name")?.to_string(), tag.attr("val").unwrap_or("").to_string())))
+                            .collect()
+                    })
+                    .unwrap_or_default();
+                imp.tags_by_part.insert(target, p.clone());
+                p
             }
+        };
+        for (name, val) in parsed.iter() {
+            let n = imp.tag_bytes.saturating_add(TAG_PAIR_COST + name.len() + val.len());
+            if n > MAX_TAG_BYTES {
+                if !imp.tags_capped {
+                    log::warn!("pptx: add-in tags over {MAX_TAG_BYTES} bytes; the rest are dropped");
+                    imp.tags_capped = true;
+                }
+                return out;
+            }
+            imp.tag_bytes = n;
+            out.push((name.clone(), val.clone()));
         }
     }
     out
@@ -389,6 +443,9 @@ pub fn import_theme(bytes: &[u8]) -> Result<(deckcraft_model::theme::Theme, Vec<
         vml_previews: HashMap::new(),
         kept_sidecar_bytes: 0,
         kept_charts: HashMap::new(),
+        tags_by_part: HashMap::new(),
+        tag_bytes: 0,
+        tags_capped: false,
     };
     let part = Part::new(&pkg, &theme_path, &doc);
     let theme = theme::read_theme(&mut imp, &part, &doc.root);
@@ -427,6 +484,9 @@ pub fn import_checked(bytes: &[u8]) -> Result<(Presentation, Vec<String>), PptxE
         vml_previews: HashMap::new(),
         kept_sidecar_bytes: 0,
         kept_charts: HashMap::new(),
+        tags_by_part: HashMap::new(),
+        tag_bytes: 0,
+        tags_capped: false,
     };
     // Slide ids first so hyperlinks anywhere can point at slides.
     let slide_ids = register_slides(&mut imp, &docs, &slide_entries, &mut lost_slides);
@@ -441,7 +501,7 @@ pub fn import_checked(bytes: &[u8]) -> Result<(Presentation, Vec<String>), PptxE
     let layout_by_part = read_masters(&mut imp, &mut p, &master_paths, &docs);
     let file_slide_ids = read_slides(&mut imp, &mut p, &pres_part, &docs, &slide_ids, &layout_by_part);
     read_sections(&mut p, &pres_part, pres_el, &file_slide_ids);
-    p.tags = tags(&imp, &pres_part, pres_el);
+    p.tags = tags(&mut imp, &pres_part, pres_el);
     read_custom_shows(&mut p, &imp, &pres_part, pres_el);
     read_guides_and_show(&mut p, &imp, &pres_part);
     read_notes_master(&mut imp, &mut p, &pres_part);
diff --git a/crates/pptx/tests/it/tags.rs b/crates/pptx/tests/it/tags.rs
index e8903b442..8cc0849be 100644
--- a/crates/pptx/tests/it/tags.rs
+++ b/crates/pptx/tests/it/tags.rs
@@ -36,3 +36,111 @@ fn tags_survive_round_trip() {
     assert_eq!(first.tags, vec![t("THINKCELLSHAPEDONOTDELETE", "t!abc")]);
     assert!(back.slides.iter().skip(1).all(|s| s.tags.is_empty()));
 }
+
+/// #1164: the same tags part listed over and over is read once, and the tags one import copies
+/// into the model are capped however often a shape lists them.
+#[test]
+fn a_tags_part_listed_many_times_is_copied_once_and_capped() {
+    let mut s = Session::new();
+    deckcraft_engine::sample::open_sample(&mut s).expect("sample");
+    for _ in 0..6 {
+        s.execute("shape.insert", &serde_json::json!({"preset": "rect", "rect": [10, 10, 50, 50]})).expect("shape");
+    }
+    let mut p = s.doc().expect("doc").doc.as_ref().clone();
+    let slide = Arc::make_mut(&mut p.slides[0]);
+    // A quarter of the budget with its name and pair cost: the fifth shape listing it goes over.
+    let pair = std::mem::size_of::<(String, String)>();
+    slide.shapes[0].tags = vec![t("BIG", &"x".repeat(deckcraft_pptx::MAX_TAG_BYTES / 4 - 3 - pair))];
+    let bytes = deckcraft_pptx::export(&p).expect("export");
+
+    // Every shape on the first slide lists that one tags part 100 times.
+    let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
+    let mut xml = String::new();
+    zip.by_name("ppt/slides/slide1.xml").expect("slide").read_to_string(&mut xml).expect("read");
+    let start = xml.find("<p:custDataLst>").expect("tags listed");
+    let end = xml[start..].find("</p:custDataLst>").expect("list ends") + start + "</p:custDataLst>".len();
+    let list = &xml[start..end];
+    let inner = list.trim_start_matches("<p:custDataLst>").trim_end_matches("</p:custDataLst>");
+    let many = format!("<p:custDataLst>{}</p:custDataLst>", inner.repeat(100));
+    let xml = xml.replace(list, "").replace("<p:nvPr/>", "<p:nvPr></p:nvPr>").replace("<p:nvPr>", &format!("<p:nvPr>{many}"));
+    assert!(xml.matches(&many).count() >= 5, "enough shapes to go over the budget");
+    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    for i in 0..zip.len() {
+        let mut f = zip.by_index(i).expect("entry");
+        let name = f.name().to_string();
+        let mut data = vec![];
+        f.read_to_end(&mut data).expect("read");
+        out.start_file(&name, zip::write::SimpleFileOptions::default()).expect("start");
+        std::io::Write::write_all(&mut out, if name == "ppt/slides/slide1.xml" { xml.as_bytes() } else { &data }).expect("write");
+    }
+    let bytes = out.finish().expect("finish").into_inner();
+
+    let back = deckcraft_pptx::import(&bytes).expect("import");
+    let tagged: Vec<_> = back.slides[0].shapes.iter().filter(|x| !x.tags.is_empty()).collect();
+    assert_eq!(tagged.len(), 4, "four copies fit the budget");
+    assert!(tagged.iter().all(|x| x.tags.len() == 1), "each shape keeps the part's tag once, not 100 times");
+}
+
+/// #1164: empty tags cost something too, or a part of 10,000 empty pairs listed by every shape
+/// would be copied without ever reaching the budget.
+#[test]
+fn empty_tags_count_against_the_budget() {
+    let pair = std::mem::size_of::<(String, String)>();
+    let per_shape = 10_000 * pair;
+    let shapes = deckcraft_pptx::MAX_TAG_BYTES / per_shape + 2;
+    let mut s = Session::new();
+    deckcraft_engine::sample::open_sample(&mut s).expect("sample");
+    let mut p = s.doc().expect("doc").doc.as_ref().clone();
+    let slide = Arc::make_mut(&mut p.slides[0]);
+    let template = slide.shapes[0].clone();
+    slide.shapes.clear();
+    for i in 0..shapes {
+        let mut sh = template.clone();
+        sh.id = deckcraft_model::ShapeId(10_000 + i as u32);
+        sh.ph = None;
+        sh.tags = vec![t("", ""); 10_000];
+        slide.shapes.push(sh);
+    }
+    let bytes = deckcraft_pptx::export(&p).expect("export");
+    let back = deckcraft_pptx::import(&bytes).expect("import");
+    let pairs: usize = back.slides[0].shapes.iter().map(|x| x.tags.len()).sum();
+    assert!(pairs * pair <= deckcraft_pptx::MAX_TAG_BYTES, "{pairs} pairs copied");
+    assert!(pairs < shapes * 10_000, "the budget stopped the copying");
+}
+
+/// #1164: once the budget is exhausted, further tags parts are not parsed or cached into
+/// `tags_by_part`.
+#[test]
+fn new_tag_parts_are_not_parsed_or_cached_after_the_budget_is_exhausted() {
+    let mut s = Session::new();
+    deckcraft_engine::sample::open_sample(&mut s).expect("sample");
+    s.execute("shape.insert", &serde_json::json!({"preset": "rect", "rect": [10, 10, 50, 50]})).expect("shape");
+    let mut p = s.doc().expect("doc").doc.as_ref().clone();
+    let slide = Arc::make_mut(&mut p.slides[0]);
+    assert!(slide.shapes.len() >= 2);
+    // The first shape's tag fits the budget, and a second pair pushes it over the cap.
+    let pair = std::mem::size_of::<(String, String)>();
+    slide.shapes[0].tags = vec![t("BIG", &"x".repeat(deckcraft_pptx::MAX_TAG_BYTES - 3 - pair)), t("OVER", "1")];
+    // The second shape has its own separate tag part.
+    slide.shapes[1].tags = vec![t("SHAPE2_TAG", "dropped")];
+    let bytes = deckcraft_pptx::export(&p).expect("export");
+
+    // Corrupt the second shape's tag part (`tag2.xml`) with invalid XML in the zip.
+    // If it were parsed, XML loading would fail. Because the budget was capped, it is never read.
+    let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
+    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    for i in 0..zip.len() {
+        let mut f = zip.by_index(i).expect("entry");
+        let name = f.name().to_string();
+        let mut data = vec![];
+        f.read_to_end(&mut data).expect("read");
+        out.start_file(&name, zip::write::SimpleFileOptions::default()).expect("start");
+        let payload = if name == "ppt/tags/tag2.xml" { b"<not valid xml<<<<" as &[u8] } else { &data };
+        std::io::Write::write_all(&mut out, payload).expect("write");
+    }
+    let corrupted = out.finish().expect("finish").into_inner();
+
+    let back = deckcraft_pptx::import(&corrupted).expect("import succeeds because tag2.xml is not parsed");
+    assert!(!back.slides[0].shapes[0].tags.is_empty(), "first shape tag was loaded");
+    assert!(back.slides[0].shapes[1].tags.is_empty(), "second shape tag was dropped and never parsed");
+}

From b6c1d87cf01cf877597c5133230245e7e047318d Mon Sep 17 00:00:00 2001
From: Naseq <nasim.naseq@gmail.com>
Date: Sun, 1 Nov 2026 11:54:38 +0430
Subject: [PATCH 72/88] Text: scale down insets when wider than the shape
 (#1632)

When text insets exceed the shape dimensions (e.g. lIns + rIns > width),
proportionally scale them down so the inner text rectangle remains
bounded within the shape. Prevents off-slide helper shapes with large
insets from having their text center shifted onto the slide canvas.
---
 crates/text/src/layout.rs | 24 ++++++++++++++++++------
 crates/text/src/tests.rs  | 21 +++++++++++++++++++++
 2 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index 05cc4beb2..94a0b5f27 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -93,12 +93,24 @@ impl BoxGeom {
         } else {
             text_rect
         };
-        let inner = Rect::new(
-            r.x0 + bp.inset_l.unwrap_or(7.2),
-            r.y0 + bp.inset_t.unwrap_or(3.6),
-            (r.x1 - bp.inset_r.unwrap_or(7.2)).max(r.x0 + bp.inset_l.unwrap_or(7.2)),
-            (r.y1 - bp.inset_b.unwrap_or(3.6)).max(r.y0 + bp.inset_t.unwrap_or(3.6)),
-        );
+        // Insets wider than the shape scale down proportionally to fit inside it (#1632).
+        let (mut ins_l, mut ins_r) = (bp.inset_l.unwrap_or(7.2).max(0.0), bp.inset_r.unwrap_or(7.2).max(0.0));
+        let (mut ins_t, mut ins_b) = (bp.inset_t.unwrap_or(3.6).max(0.0), bp.inset_b.unwrap_or(3.6).max(0.0));
+        let w = r.width().max(0.0);
+        let total_x = ins_l + ins_r;
+        if total_x > w && total_x > 0.0 {
+            let s = w / total_x;
+            ins_l *= s;
+            ins_r *= s;
+        }
+        let h = r.height().max(0.0);
+        let total_y = ins_t + ins_b;
+        if total_y > h && total_y > 0.0 {
+            let s = h / total_y;
+            ins_t *= s;
+            ins_b *= s;
+        }
+        let inner = Rect::new(r.x0 + ins_l, r.y0 + ins_t, (r.x1 - ins_r).max(r.x0 + ins_l), (r.y1 - ins_b).max(r.y0 + ins_t));
         // Text that follows a WordArt arch or circle is set on one line per paragraph.
         let follow = bp.warp.as_deref().is_some_and(deckcraft_geom::warp::is_follow);
         let wrap = bp.wrap.unwrap_or(true) && !follow && !matches!(bp.autofit, Some(AutoFit::Shape) if shape.text_box && !bp.wrap.unwrap_or(true));
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index f9f3f3101..a5d3b3248 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -1928,3 +1928,24 @@ fn a_paragraph_with_its_own_start_at_restarts_the_count_there() {
     // A later paragraph with a new start begins a fresh run.
     check(&[1, 1, 7, 7], &[1, 2, 7, 8]);
 }
+
+/// #1632: when insets are wider than the shape, they scale down proportionally so the text
+/// rectangle stays inside the shape bounds and unwrapped text does not project outside it.
+#[test]
+fn insets_wider_than_the_shape_scale_down_within_the_shape_bounds() {
+    let (p, mut sh) = setup("Collaboration Hub", 14.17, 14.17);
+    sh.ph = None;
+    let bp = &mut sh.text.as_mut().unwrap().body;
+    bp.wrap = Some(false);
+    bp.inset_l = Some(127.5);
+    bp.inset_r = Some(11.33);
+    bp.inset_t = Some(11.33);
+    bp.inset_b = Some(11.33);
+    sh.text.as_mut().unwrap().paragraphs[0].props = deckcraft_model::text::ParaProps { align: Some(Align::Center), ..Default::default() };
+    let l = lay(&p, &sh, 14.17, 14.17);
+    assert_eq!(l.lines.len(), 1);
+    let line = &l.lines[0];
+    let mid = (line.caret_x[0] + *line.caret_x.last().unwrap()) / 2.0;
+    // The text center must remain inside the 14.17 pt wide shape, not pushed ~127.5 pt to the right.
+    assert!((0.0..=14.17).contains(&mid), "line center {mid} should be within [0, 14.17]");
+}

From b5033b6213edfd91fd3558ff757d1320981bc2b2 Mon Sep 17 00:00:00 2001
From: Naseq <nasim.naseq@gmail.com>
Date: Sun, 1 Nov 2026 13:38:14 +0430
Subject: [PATCH 73/88] Text: preserve signed insets and scale only when both
 are non-negative

Address review finding: keep signed insets unchanged when their sum fits,
scaling opposing insets proportionally only when both in the pair are
non-negative and their sum exceeds the box dimension.
---
 crates/text/src/layout.rs |  8 ++++----
 crates/text/src/tests.rs  | 15 +++++++++++++++
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index 94a0b5f27..c0422815e 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -94,18 +94,18 @@ impl BoxGeom {
             text_rect
         };
         // Insets wider than the shape scale down proportionally to fit inside it (#1632).
-        let (mut ins_l, mut ins_r) = (bp.inset_l.unwrap_or(7.2).max(0.0), bp.inset_r.unwrap_or(7.2).max(0.0));
-        let (mut ins_t, mut ins_b) = (bp.inset_t.unwrap_or(3.6).max(0.0), bp.inset_b.unwrap_or(3.6).max(0.0));
+        let (mut ins_l, mut ins_r) = (bp.inset_l.unwrap_or(7.2), bp.inset_r.unwrap_or(7.2));
+        let (mut ins_t, mut ins_b) = (bp.inset_t.unwrap_or(3.6), bp.inset_b.unwrap_or(3.6));
         let w = r.width().max(0.0);
         let total_x = ins_l + ins_r;
-        if total_x > w && total_x > 0.0 {
+        if ins_l >= 0.0 && ins_r >= 0.0 && total_x > w && total_x > 0.0 {
             let s = w / total_x;
             ins_l *= s;
             ins_r *= s;
         }
         let h = r.height().max(0.0);
         let total_y = ins_t + ins_b;
-        if total_y > h && total_y > 0.0 {
+        if ins_t >= 0.0 && ins_b >= 0.0 && total_y > h && total_y > 0.0 {
             let s = h / total_y;
             ins_t *= s;
             ins_b *= s;
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index a5d3b3248..cb1be0e2e 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -1949,3 +1949,18 @@ fn insets_wider_than_the_shape_scale_down_within_the_shape_bounds() {
     // The text center must remain inside the 14.17 pt wide shape, not pushed ~127.5 pt to the right.
     assert!((0.0..=14.17).contains(&mid), "line center {mid} should be within [0, 14.17]");
 }
+
+/// #1632: signed insets (e.g. negative left inset with positive right inset) are preserved when
+/// their sum fits within the shape bounds.
+#[test]
+fn signed_insets_are_preserved_when_they_fit() {
+    let (p, mut sh) = setup("Text", 100.0, 50.0);
+    sh.ph = None;
+    let bp = &mut sh.text.as_mut().unwrap().body;
+    bp.inset_l = Some(-10.0);
+    bp.inset_r = Some(10.0);
+    sh.text.as_mut().unwrap().paragraphs[0].props = deckcraft_model::text::ParaProps { align: Some(Align::Left), ..Default::default() };
+    let l = lay(&p, &sh, 100.0, 50.0);
+    assert_eq!(l.lines.len(), 1);
+    assert_eq!(l.inner.x0, -10.0);
+}

From 7f742c9d4f4b00f60a16490d1ebc1f3e409fc60f Mon Sep 17 00:00:00 2001
From: Elliot Graham <elliotgraham94@gmail.com>
Date: Sun, 1 Nov 2026 09:29:42 +0000
Subject: [PATCH 74/88] FIX-1621: cover locked and outline-free No Fill shapes

---
 ROADMAP.md                     |  4 ++-
 crates/engine/src/tests.rs     | 52 +++++++++++++++++++++++++++++++++-
 crates/engine/src/tools/hit.rs |  1 +
 docs/gaps.md                   |  3 +-
 docs/parity-checklist.md       |  3 +-
 docs/ui-parity.md              |  5 ++--
 6 files changed, 62 insertions(+), 6 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index 8dc52dfb7..f5e084d3c 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~20 points and ~120–210 h away
 
-> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-10-31 · **Change:** trivial (No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-01 · **Change:** trivial (locked No Fill and no-outline click-through regression coverage added; No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-30 · **Change:** trivial (progress log: read-only `slide.actions` lists shape and table text actions; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-27 · **Change:** trivial (progress log: Set Up Slide Show ▸ Keep mouse cursor visible, #1445; stage and scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-26 · **Change:** trivial (progress log: dragging several selected slides moves them all; previous: trivial, progress log: Edit Points handle drags with Shift, Ctrl/Cmd or Alt/Option set the point type; previous: trivial, progress log: scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
@@ -148,6 +148,7 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | What landed |
 |---|---|
+| 2026-11-01 | No Fill regression coverage now includes locked shapes (outline selectable, position unchanged by dragging) and empty shapes without an outline, locked or unlocked (#1621). Existing text, outline and interior-hit tests retained |
 | 2026-10-31 | No Fill shape interiors allow selection and editing of underlying objects, even when a quick style remains; hit-testing uses the renderer’s fill resolution. Outlines, rotation, text targets and actual fills keep their hit behaviour (#1621) |
 | 2026-10-30 | Print-preview tests use the URL emitted by egui and its exact file path; previews are explicitly removed before the macOS process exits |
 | 2026-10-30 | `slide.actions` lists shape click and hover actions and text-run hyperlinks (including table cells and grouped shapes) for audit; listing never runs an action. The UI pane is a follow-up |
@@ -319,6 +320,7 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-01 | trivial | No Fill tests cover locked outline selection without movement and click-through without an outline; fill row and parity scores unchanged (#1621) |
 | 2026-10-31 | trivial | No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged |
 | 2026-10-30 | trivial | Progress log: read-only slide action inspection; parity scores unchanged |
 | 2026-10-29 | trivial | Progress log: going back in the slide show reverses the left slide's transition (#1531). Scores and milestone names unchanged |
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 08417b4f8..aefd3473c 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -5572,7 +5572,7 @@ fn edit_points_conversion_is_one_undo_step() {
     assert!(preset(&s), "the only step was the conversion");
 }
 
-// #1621: No Fill changes hit-testing as well as rendering, even with a quick style.
+/// #1621: build overlapping objects with an ordinary quick style on the foreground shape.
 fn no_fill_overlap(s: &mut Session, text: bool) -> (ShapeId, ShapeId) {
     s.execute("slide.new", &json!({"layout": "blank"})).unwrap();
     let under = s
@@ -5587,6 +5587,7 @@ fn no_fill_overlap(s: &mut Session, text: bool) -> (ShapeId, ShapeId) {
     (ShapeId(under as u32), ShapeId(over as u32))
 }
 
+/// No Fill passes interior clicks through while preserving outline and actual-fill targets.
 #[test]
 fn no_fill_shape_allows_selecting_and_editing_underlying_text() {
     let mut s = session();
@@ -5622,6 +5623,7 @@ fn no_fill_shape_allows_selecting_and_editing_underlying_text() {
     }
 }
 
+/// Rotation and pointer tolerance must preserve both pass-through interiors and outline hits.
 #[test]
 fn no_fill_shape_hit_testing_respects_rotation_and_pointer_tolerance() {
     let mut s = session();
@@ -5642,6 +5644,7 @@ fn no_fill_shape_hit_testing_respects_rotation_and_pointer_tolerance() {
     }
 }
 
+/// Style, theme and absent fills follow rendering, with explicit fill taking precedence.
 #[test]
 fn no_fill_hit_testing_resolves_style_and_theme_fills() {
     use std::sync::Arc;
@@ -5673,6 +5676,7 @@ fn no_fill_hit_testing_resolves_style_and_theme_fills() {
     }
 }
 
+/// Text on a foreground No Fill shape retains its selection and editing target.
 #[test]
 fn no_fill_text_shapes_keep_their_interior_text_target() {
     let mut s = session();
@@ -5686,6 +5690,52 @@ fn no_fill_text_shapes_keep_their_interior_text_target() {
     assert_eq!(text_sel(&s).unwrap().shape, over);
 }
 
+/// A locked No Fill shape remains selectable on its outline, but dragging cannot move it.
+#[test]
+fn no_fill_locked_shape_keeps_outline_selection_without_moving() {
+    let mut s = session();
+    let (under, over) = no_fill_overlap(&mut s, true);
+    s.execute("shape.fill", &json!({"none": true})).unwrap();
+    s.execute("shape.lock", &json!({"locked": true})).unwrap();
+    let before = s.doc().unwrap().shape(over).unwrap().xfrm;
+    s.execute("edit.deselect", &json!({})).unwrap();
+    let inside = deckcraft_geom::Point::new(200.0, 310.0);
+    assert!(matches!(s.hit_test(inside, 3.0), Some(tools::Hit::Shape { id, .. }) if id == under));
+    for kind in [PointerKind::Down, PointerKind::Up] {
+        s.pointer(tev(kind, inside.x, inside.y)).unwrap();
+    }
+    assert_eq!(text_sel(&s).unwrap().shape, under);
+    s.execute("edit.deselect", &json!({})).unwrap();
+    let edge = deckcraft_geom::Point::new(80.0, 330.0);
+    assert!(matches!(s.hit_test(edge, 3.0), Some(tools::Hit::Shape { id, .. }) if id == over));
+    s.pointer(tev(PointerKind::Down, edge.x, edge.y)).unwrap();
+    s.pointer(tev(PointerKind::Drag, edge.x + 40.0, edge.y + 20.0)).unwrap();
+    s.pointer(tev(PointerKind::Up, edge.x + 40.0, edge.y + 20.0)).unwrap();
+    let st = s.doc().unwrap();
+    assert_eq!(st.selection.shapes, vec![over]);
+    assert_eq!(st.shape(over).unwrap().xfrm, before);
+    assert!(st.shape(over).unwrap().locked);
+}
+
+/// Removing both fill and outline leaves the empty interior transparent to clicks, locked or not.
+#[test]
+fn no_fill_shape_without_text_or_outline_passes_interior_clicks() {
+    for locked in [false, true] {
+        let mut s = session();
+        let (under, _) = no_fill_overlap(&mut s, false);
+        s.execute("shape.fill", &json!({"none": true})).unwrap();
+        s.execute("shape.line", &json!({"none": true})).unwrap();
+        s.execute("shape.lock", &json!({"locked": locked})).unwrap();
+        s.execute("edit.deselect", &json!({})).unwrap();
+        let p = deckcraft_geom::Point::new(200.0, 310.0);
+        assert!(matches!(s.hit_test(p, 3.0), Some(tools::Hit::Shape { id, .. }) if id == under));
+        for kind in [PointerKind::Down, PointerKind::Up] {
+            s.pointer(tev(kind, p.x, p.y)).unwrap();
+        }
+        assert_eq!(s.doc().unwrap().selection.shapes, vec![under]);
+    }
+}
+
 /// #931: while the text of a placeholder is being edited, a shape in front of it still takes a
 /// click (as in PowerPoint); a click on the text where nothing is in front still moves the caret.
 #[test]
diff --git a/crates/engine/src/tools/hit.rs b/crates/engine/src/tools/hit.rs
index 0e4b6ddcb..247ab1e79 100644
--- a/crates/engine/src/tools/hit.rs
+++ b/crates/engine/src/tools/hit.rs
@@ -216,6 +216,7 @@ pub(super) fn in_table_cell(st: &crate::DocState, id: ShapeId, p: Point) -> bool
     })
 }
 
+/// Resolve a shape's target at slide point `p`, using its effective fill for interior hits.
 pub(super) fn hit_shape(st: &crate::DocState, sh: &Shape, p: Point, tol: f64) -> Option<Hit> {
     let x = xfrm_of(&st.doc, &st.selection, sh);
     let inv = x.affine().inverse();
diff --git a/docs/gaps.md b/docs/gaps.md
index 3bc26cce7..77764f1cf 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Where DeckCraft falls short of PowerPoint
 
-> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-10-31 · **Change:** trivial (No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-01 · **Change:** trivial (locked No Fill and no-outline click-through regression coverage added; No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 
 Every known shortfall, one entry each, ranked by how much it stops someone who presents with
 PowerPoint from switching. This is the work list: pick from the top. Numbers are summarized in
@@ -368,6 +368,7 @@ Detail in [localization-parity.md](localization-parity.md).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-01 | trivial | No Fill tests cover locked outline selection without movement and click-through without an outline; fill row and parity scores unchanged (#1621) |
 | 2026-10-31 | trivial | No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged |
 | 2026-10-30 | minor | Slide-show click targets use each shape’s own animation state; scale and rotation test added |
 | 2026-10-28 | trivial | Automatic lists now run independently of Replace text as you type; proofing gap description updated |
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index c088bd018..f776f4aac 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -2,7 +2,7 @@
 
 > **Generated:** 2026-10-14 (bullets/numbering remain D after empty-line marker review; summary by `cargo xtask parity`; rows re-scored by the 2026-10-14 community PR wave, duplicate Thesaurus, AutoCorrect, Artistic effects and Corrections rows folded; Preview in editor re-scored 2026-10-13; earlier rows re-scored 2026-10-10 against PowerPoint for Mac 16.113.4; video/animated GIF row re-scored 2026-10-11, #171) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 
-> **Last updated:** 2026-10-31 · Fill row re-assessed after #1621: remains D; No Fill hit-testing now follows resolved appearance. Scores unchanged.
+> **Last updated:** 2026-11-01 · Locked-shape and no-outline regressions added for #1621; fill row re-assessed: remains D; No Fill hit-testing now follows resolved appearance. Scores unchanged.
 
 The summary between `<!-- SUMMARY -->
 **Weighted breadth parity: 84%** over 191 features.
@@ -240,4 +240,5 @@ Open P0 items: Contextual tabs (Shape Format, Picture Format, Table Design/Layou
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-01 | trivial | No Fill tests cover locked outline selection without movement and click-through without an outline; fill row and parity scores unchanged (#1621) |
 | 2026-10-31 | trivial | No Fill interior hit-testing follows resolved fill (#1621); fill row remains D and summary scores are unchanged |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index fa5f9ae88..fd34a7928 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI parity with PowerPoint
 
-> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-10-31 · **Change:** trivial (No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-01 · **Change:** trivial (locked No Fill and no-outline click-through regression coverage added; No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-26 · **Change:** trivial (dragging several selected slides moves them all; previous: trivial, Edit Points: Shift, Ctrl/Cmd or Alt/Option on a handle drag sets the point type; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: major, community PR wave 2026-10-14: 14 new dialogs (41 in all), Eyedropper, Export button, New Window, Grid Options, WordArt gallery and handles, Slide Sorter sections, Quick Access Toolbar, Format Background and Format Shape depth, rich-text clipboard; duplicated rows and headers folded; previous: minor, File tab / Backstage, #76) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-22 · **Change:** trivial (group fill and outline edits reach members, #1079; scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-24 · **Change:** trivial (Edit Points: Shift, Ctrl/Cmd or Alt/Option on a handle drag sets the point type; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: major, community PR wave 2026-10-14: 14 new dialogs (41 in all), Eyedropper, Export button, New Window, Grid Options, WordArt gallery and handles, Slide Sorter sections, Quick Access Toolbar, Format Background and Format Shape depth, rich-text clipboard; duplicated rows and headers folded; previous: minor, File tab / Backstage, #76) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
@@ -81,7 +81,7 @@ menu colours taken from the theme tokens (menu `chrome`, page `card`).
 
 | Behaviour | PowerPoint | DeckCraft |
 |---|---|---|
-| Selection handles, rotation handle, yellow adjustment handles | yes | yes; an empty No Fill shape passes interior clicks to underlying objects while its outline and handles remain selectable. Explicit, style and theme fills resolve as rendered (#1621) |
+| Selection handles, rotation handle, yellow adjustment handles | yes | yes; an empty No Fill shape passes interior clicks to underlying objects while its outline and handles remain selectable. Explicit, style and theme fills resolve as rendered; tests also cover locked outline targets and empty interiors without an outline (#1621) |
 | Marquee, Shift/Cmd multi-select, Tab to cycle | yes | yes |
 | Objects off the slide: drawn on the area around it in Normal view (full strength, master graphics too), selectable and movable there; clipped in the show, exports and thumbnails | yes | yes (#270) |
 | Scroll bars on the slide pane when the zoomed slide is larger than the window | yes | yes, on each axis that overflows: drag the thumb or click the track; the wheel and trackpad still pan. The vertical bar does not turn the page (#1157) |
@@ -171,6 +171,7 @@ consistency is open (#73, #56).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-01 | trivial | No Fill tests cover locked outline selection without movement and click-through without an outline; fill row and parity scores unchanged (#1621) |
 | 2026-10-31 | trivial | No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged |
 | 2026-10-29 | trivial | Picture Format: the Picture Styles row shows as many styles as fit beside the groups after it (at least two) and a More arrow with all 24, as the Transitions and Animations galleries do; Crop and Size are in view in the default window (#1232) |
 | 2026-10-26 | trivial | Thumbnail pane and Slide Sorter: dragging one of several selected slides moves the whole selection |

From 5fb694d9917d232fbf5b2e0f42ac15d73febde7c Mon Sep 17 00:00:00 2001
From: xmaks82 <xmaks82@yandex.ru>
Date: Sun, 1 Nov 2026 12:54:32 +0300
Subject: [PATCH 75/88] Text: a word doesn't break after ?, !, } or + (URLs
 wrap as in PowerPoint) (#924)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Text: a word doesn't break after ?, !, } or + (URLs wrap as in PowerPoint)

Unicode line breaking allows a break after ?, !, } and + inside a word,
so a long URL broke after its '?' and after each '+' of a query and left
the rest of the line empty. Measured in PowerPoint 2016 for Windows with
latinLnBrk off (its default), none of them is a break: the word fills the
line and breaks where it no longer fits, as PowerPoint already does after
/ and \ (break_opportunities). The same synthetic slide now wraps line for
line as PowerPoint's PDF does, a Yandex search URL included.

* Text tests: the first line doesn't end at the separator

* Text tests: check the line is full, not that it avoids ending at a separator

* Keep the Unicode break after ?, !, / outside Latin words

The PowerPoint no-break rule only holds inside a word: before an ideograph
(日本!語) or punctuation the Unicode break stays, as CodeRabbit pointed out.

* Only letters and digits continue a word for the no-break rule

AL and AI also hold symbols such as & and ×, so a!&b kept no break after !.
is_word_char now also requires c.is_alphanumeric() (CodeRabbit).

* Test that Latin before CJK and a separator before a space still break

---------

Co-authored-by: Магда М.Г. <mail@mgmagda.ru>
---
 crates/text/src/breaking.rs | 15 ++++++++++++---
 crates/text/src/tests.rs    | 24 +++++++++++++++++++++---
 docs/target-app-parity.md   |  3 ++-
 3 files changed, 35 insertions(+), 7 deletions(-)

diff --git a/crates/text/src/breaking.rs b/crates/text/src/breaking.rs
index 36b9e5925..bb764b64c 100644
--- a/crates/text/src/breaking.rs
+++ b/crates/text/src/breaking.rs
@@ -82,9 +82,18 @@ fn is_cj_nonstarter(c: char) -> bool {
     )
 }
 
+/// A character that continues a Latin-style word: a letter or digit that Unicode does not break
+/// between, as opposed to CJK ideographs, kana, spaces, punctuation and symbols such as `&` or `×`
+/// (which share the AL and AI line-break classes with letters).
+fn is_word_char(c: char) -> bool {
+    use unicode_linebreak::BreakClass::{Alphabetic, Ambiguous, HebrewLetter, Numeric};
+    matches!(unicode_linebreak::break_property(c as u32), Alphabetic | Ambiguous | HebrewLetter | Numeric) && c.is_alphanumeric()
+}
+
 /// Break opportunities: allowed[i] = a line may start at char i. Unicode line breaking, then
-/// PowerPoint's differences: without `latinLnBrk` a word doesn't break after `/` or `\`, and
-/// Korean breaks only between words.
+/// PowerPoint's differences: without `latinLnBrk` a word doesn't break after `/`, `\`, `?`, `!`, `}`
+/// or `+` inside a word (measured in PowerPoint 2016 for Windows; before an ideograph or a space
+/// the Unicode break stays), and Korean breaks only between words.
 pub(crate) fn break_opportunities(text: &str, latin_break: bool) -> (Vec<bool>, Vec<bool>) {
     let n = text.chars().count();
     let mut allowed = vec![false; n + 1];
@@ -113,7 +122,7 @@ pub(crate) fn break_opportunities(text: &str, latin_break: bool) -> (Vec<bool>,
         let keep = if (is_hangul(prev) && is_hangul(next)) || prev == '\u{200B}' || next == '\u{2014}' || is_cj_nonstarter(next) {
             false
         } else {
-            latin_break || !matches!(prev, '/' | '\\') || next.is_whitespace()
+            latin_break || !matches!(prev, '/' | '\\' | '?' | '!' | '}' | '+') || !is_word_char(next)
         };
         if !keep
             && !mandatory.get(i + 1).copied().unwrap_or(false)
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index f9f3f3101..656dfdb66 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -857,19 +857,37 @@ fn one_line(text: &str) -> f64 {
 #[test]
 fn a_word_does_not_break_after_a_slash_or_backslash() {
     // PowerPoint (latinLnBrk off, its default) keeps "alpha/beta/gamma" whole and only breaks it
-    // where it no longer fits; Unicode line breaking would allow a break after each slash.
-    for sep in ["/", "\\"] {
+    // where it no longer fits; Unicode line breaking would allow a break after each slash. The
+    // same holds after ?, !, } and + (a URL's query, measured in PowerPoint 2016 for Windows).
+    for sep in ["/", "\\", "?", "!", "}", "+"] {
         let text = ["alpha", "beta", "gamma", "delta", "epsilon"].join(sep);
         let w = one_line(&text) * 0.6;
         let lines = wrapped(&text, w, |_| {});
         assert!(lines.len() >= 2, "{lines:?}");
         assert!(lines[0].chars().count() > "alpha/beta".len(), "filled to the edge, not cut at a separator: {lines:?}");
+        // The line breaks where the next character no longer fits, not at an earlier separator
+        // (it may still end with one when that is where the width runs out).
+        let next: String = lines[0].chars().chain(lines[1].chars().take(1)).collect();
+        assert!(one_line(&next) > w, "no break right after {sep:?} while more fits: {lines:?}");
     }
     // latinLnBrk on: Unicode's break after a slash is allowed again.
     let text = "alpha/beta/gamma/delta/epsilon";
     let lines = wrapped(text, one_line(text) * 0.6, |p| p.latin_line_break = Some(true));
     assert!(lines[0].ends_with('/'), "{lines:?}");
-    // A slash followed by a space still breaks, and hyphens still break.
+    // Outside a Latin word the Unicode break stays: "日本!" fits, "語" moves to the next line.
+    let lines = wrapped("日本!語", one_line("日本!") + 0.5, |_| {});
+    assert_eq!(lines[0], "日本!", "{lines:?}");
+    // Nor before a symbol that only shares the letters' line-break class.
+    let (allowed, _) = break_opportunities("ab!&cd", false);
+    assert!(allowed[3], "break after ! before &: {allowed:?}");
+    // Latin text before CJK still breaks after the mark: "ab?" fits, "日本" moves down.
+    let lines = wrapped("ab?日本", one_line("ab?") + 0.5, |_| {});
+    assert_eq!(lines[0], "ab?", "{lines:?}");
+    // A separator followed by a space still breaks, and hyphens still break.
+    for sep in ["/", "?", "!"] {
+        let lines = wrapped(&format!("alpha{sep} beta"), one_line(&format!("alpha{sep} b")) + 0.5, |_| {});
+        assert_eq!(lines.iter().map(|l| l.trim_end()).collect::<Vec<_>>(), [format!("alpha{sep}"), "beta".into()], "{lines:?}");
+    }
     let lines = wrapped("alpha-beta-gamma-delta-epsilon", one_line("alpha-beta-gamma-") + 1.0, |_| {});
     assert_eq!(lines[0], "alpha-beta-gamma-");
 }
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 4f30ce5fe..33b631882 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,6 +1,6 @@
 # DeckCraft vs Microsoft PowerPoint: parity assessment
 
-> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-22 · **Change:** trivial (Animations shortfall: preview from the selected effect is in; previous: major, community PR wave 2026-10-14: breadth 84% over 191 features (P0 92%, P1 82%, P2 55%) after `cargo xtask parity`; area table and What works today folded to one row or bullet each; 320 engine commands; ready ~55% and stage alpha unchanged; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-22 · **Change:** trivial (no break after `?`, `!`, `}`, `+` inside a word; previous: trivial, Animations shortfall: preview from the selected effect is in; before that: major, community PR wave 2026-10-14: breadth 84% over 191 features (P0 92%, P1 82%, P2 55%) after `cargo xtask parity`; area table and What works today folded to one row or bullet each; 320 engine commands; ready ~55% and stage alpha unchanged; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 
 The authoritative answer to "how close is DeckCraft to PowerPoint, and how much work is left?".
 [ROADMAP.md](../ROADMAP.md) summarizes it; [gaps.md](gaps.md) itemizes every shortfall;
@@ -289,6 +289,7 @@ scored done (16 open issues).
 | Date | Change | Summary |
 |---|---|---|
 | 2026-10-22 | trivial | Animations shortfall: preview from the selected effect (Play From) is in. Percentages unchanged |
+| 2026-10-17 | trivial | A word no longer breaks after `?`, `!`, `}` or `+` (a URL's query wraps at the edge as in PowerPoint 2016 for Windows), as it already didn't after `/` and `\`. Headline percentages unchanged |
 | 2026-10-16 | trivial | Arrange shortfall: Align to Slide and Align Selected Objects are in the Align menu. Percentages unchanged |
 | 2026-10-14 | minor | Community PR wave folded: one headline breadth row (84% over 191 features after `cargo xtask parity`; duplicate checklist rows removed), one row per feature area with the latest breadth and shortfalls, one Themes / Slide show / Views / Review / Automation bullet each (320 engine commands). SmartArt ready ~35% (Text Pane, 6e40335) moves the area mean to 62.8%; dimension and headline percentages unchanged |
 | 2026-10-13 | minor | Shapes shortfall "text warp" narrowed to adjust handles: the Transform gallery applies a preset |

From 9f952550b2b3b3a56b6b23e7b2b02eafcbe06e45 Mon Sep 17 00:00:00 2001
From: scks1 <126534658+scks1@users.noreply.github.com>
Date: Sun, 1 Nov 2026 08:58:11 -0500
Subject: [PATCH 76/88] #1596: add shadow, glow and reflection pixel goldens

---
 crates/render/src/lib.rs                |   3 +
 crates/render/src/tests_effect_holes.rs | 198 ++++++++++++++++++++++++
 2 files changed, 201 insertions(+)
 create mode 100644 crates/render/src/tests_effect_holes.rs

diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index 5fd011411..15b89ec57 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -94,6 +94,9 @@ mod tests;
 #[cfg(test)]
 mod tests_wild;
 
+#[cfg(test)]
+mod tests_effect_holes;
+
 #[cfg(test)]
 mod mt_tests {
     use super::*;
diff --git a/crates/render/src/tests_effect_holes.rs b/crates/render/src/tests_effect_holes.rs
new file mode 100644
index 000000000..10749229d
--- /dev/null
+++ b/crates/render/src/tests_effect_holes.rs
@@ -0,0 +1,198 @@
+//! Contributor-original pixel goldens for #1596 and the review of #1626.
+//! The fixed samples cover background, hole/centre, ring, visible halos and reflected coverage.
+
+use super::{Fill, Image, RenderOpts, Rgba, render_slide};
+use deckcraft_model::style::{ColorRef, Effects, Glow, Line, Reflection, Shadow};
+use deckcraft_model::{Geom, Presentation, Shape, ShapeId, Xfrm};
+
+const PROBES: [(u32, u32); 9] = [
+    (20, 20),   // Clear background.
+    (130, 130), // Clear donut hole; filled ellipse centre.
+    (130, 70),  // Original ring/ellipse fill.
+    (130, 47),  // Visible shadow/glow above the outer edge.
+    (130, 213), // Visible shadow/glow below the outer edge.
+    (130, 93),  // Shadow/glow along the inner rim, inside the hole.
+    (130, 230), // Reflected upper ring.
+    (130, 300), // Reflected hole/ellipse centre.
+    (70, 300),  // Reflected ring at the same fade as the hole.
+];
+
+#[derive(Clone, Copy, Debug)]
+enum Effect {
+    Shadow,
+    Glow,
+    Reflection,
+}
+
+fn scene(shape: &str, effect: Effect) -> Presentation {
+    let mut p = Presentation::default();
+    let mut effects = Effects::default();
+    match effect {
+        Effect::Shadow => {
+            effects.outer_shadow = Some(Shadow {
+                color: ColorRef::rgb(Rgba::BLACK),
+                blur: 8.0,
+                dist: 0.0,
+                dir: 45.0,
+                inner: false,
+                sx: 1.0,
+                sy: 1.0,
+                kx: 0.0,
+                ky: 0.0,
+                align: String::new(),
+                rotate_with_shape: false,
+            })
+        }
+        Effect::Glow => effects.glow = Some(Glow { color: ColorRef::rgb(Rgba::rgb(255, 0, 0)), radius: 8.0 }),
+        Effect::Reflection => effects.reflection = Some(Reflection { blur: 0.0, start_alpha: 1.0, end_alpha: 0.0, end_pos: 1.0, dist: 10.0 }),
+    }
+    let slide = std::sync::Arc::make_mut(&mut p.slides[0]);
+    slide.background = Some(deckcraft_model::Background::Fill { fill: Fill::solid(ColorRef::rgb(Rgba::WHITE)) });
+    slide.shapes = vec![Shape {
+        id: ShapeId(1596),
+        xfrm: Some(Xfrm::new(50.0, 50.0, 160.0, 160.0)),
+        geom: Geom::preset(shape),
+        fill: Some(Fill::solid(ColorRef::rgb(Rgba::rgb(32, 96, 224)))),
+        line: Some(Line::none()),
+        effects: Some(effects),
+        ..Default::default()
+    }];
+    p
+}
+
+fn draw(shape: &str, effect: Effect) -> Image {
+    let p = scene(shape, effect);
+    let image = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
+    if let Ok(dir) = std::env::var("DECKCRAFT_EFFECT_HOLES_QA") {
+        use std::io::Write as _;
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = std::path::Path::new(&dir).join(format!("{shape}-{effect:?}.png"));
+        let mut file = std::fs::OpenOptions::new().write(true).create_new(true).open(path).unwrap();
+        file.write_all(&image.to_png()).unwrap();
+    }
+    image
+}
+
+// Fixed contributor-original RGBA goldens; tolerate one final quantization step.
+// The nonwhite halo/reflection samples also fail if an effect is disabled outright.
+fn assert_golden(shape: &str, effect: Effect, expected: [[u8; 4]; 9]) {
+    let image = draw(shape, effect);
+    for ((x, y), want) in PROBES.into_iter().zip(expected) {
+        let got = image.pixel(x, y);
+        assert!(got.iter().zip(want).all(|(a, b)| (*a as i32 - b as i32).abs() <= 1), "{shape} {effect:?} at {x},{y}: {got:?} vs golden {want:?}");
+    }
+}
+
+#[test]
+fn donut_shadow_matches_golden() {
+    assert_golden(
+        "donut",
+        Effect::Shadow,
+        [
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [32, 96, 224, 255],
+            [214, 214, 214, 255],
+            [233, 233, 233, 255],
+            [227, 227, 227, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+        ],
+    );
+}
+
+#[test]
+fn donut_glow_matches_golden() {
+    assert_golden(
+        "donut",
+        Effect::Glow,
+        [
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [32, 96, 224, 255],
+            [255, 49, 49, 255],
+            [255, 111, 111, 255],
+            [255, 96, 96, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+        ],
+    );
+}
+
+#[test]
+fn donut_reflection_matches_golden() {
+    assert_golden(
+        "donut",
+        Effect::Reflection,
+        [
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [32, 96, 224, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [130, 166, 238, 255],
+            [255, 255, 255, 255],
+            [189, 208, 246, 255],
+        ],
+    );
+}
+
+#[test]
+fn ellipse_shadow_matches_golden() {
+    assert_golden(
+        "ellipse",
+        Effect::Shadow,
+        [
+            [255, 255, 255, 255],
+            [32, 96, 224, 255],
+            [32, 96, 224, 255],
+            [214, 214, 214, 255],
+            [233, 233, 233, 255],
+            [32, 96, 224, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+        ],
+    );
+}
+
+#[test]
+fn ellipse_glow_matches_golden() {
+    assert_golden(
+        "ellipse",
+        Effect::Glow,
+        [
+            [255, 255, 255, 255],
+            [32, 96, 224, 255],
+            [32, 96, 224, 255],
+            [255, 49, 49, 255],
+            [255, 111, 111, 255],
+            [32, 96, 224, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+        ],
+    );
+}
+
+#[test]
+fn ellipse_reflection_matches_golden() {
+    assert_golden(
+        "ellipse",
+        Effect::Reflection,
+        [
+            [255, 255, 255, 255],
+            [32, 96, 224, 255],
+            [32, 96, 224, 255],
+            [255, 255, 255, 255],
+            [255, 255, 255, 255],
+            [32, 96, 224, 255],
+            [130, 166, 238, 255],
+            [189, 208, 246, 255],
+            [189, 208, 246, 255],
+        ],
+    );
+}

From 650c4f949786a991247b2c6744d446a25cbab573 Mon Sep 17 00:00:00 2001
From: scks1 <126534658+scks1@users.noreply.github.com>
Date: Sun, 1 Nov 2026 08:58:13 -0500
Subject: [PATCH 77/88] #1597: make validation independent of installed fonts
 and dictionaries

---
 crates/pdf/src/tests.rs     | 5 ++++-
 crates/ui-egui/src/tests.rs | 3 ++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs
index 8bdbbce93..ba5cd7d7b 100644
--- a/crates/pdf/src/tests.rs
+++ b/crates/pdf/src/tests.rs
@@ -202,7 +202,10 @@ fn unsafe_url_links_are_not_exported() {
 /// memory. Its naming/shaping tables still parse, but its missing head table prevents PDF
 /// embedding. No font bytes or vendor assets are stored as test fixtures.
 fn font_without_head() -> Vec<u8> {
-    let mut bytes = FontDb::global().face("Ubuntu", "Regular").data().to_vec();
+    // An installed variable Ubuntu can expose many faces; use the bundled static
+    // Light face so the damaged fixture always adds exactly one face.
+    let bundled = FontDb::with_font_dirs(Vec::new());
+    let mut bytes = bundled.face("Ubuntu", "Light").data().to_vec();
     for (old, new) in [(b"Ubuntu".as_slice(), b"BadPDF".as_slice()), (b"\0U\0b\0u\0n\0t\0u".as_slice(), b"\0B\0a\0d\0P\0D\0F".as_slice())] {
         let mut offset = 0;
         while offset + old.len() <= bytes.len() {
diff --git a/crates/ui-egui/src/tests.rs b/crates/ui-egui/src/tests.rs
index 98f3b85c7..29fa755fd 100644
--- a/crates/ui-egui/src/tests.rs
+++ b/crates/ui-egui/src/tests.rs
@@ -999,7 +999,8 @@ fn the_language_dialog_marks_the_selected_text() {
     harness.state_mut().run("app.dialog", json!({"id": "language"})).unwrap();
     // The anchored window settles over its first frames; click once it stays put.
     harness.run_steps(4);
-    harness.get_by_label("Français (France)").click();
+    // Installed dictionaries append a marker to the language's accessible label.
+    harness.get_by_label_contains("Français (France)").click();
     harness.run_steps(2);
     harness.get_by_label("OK").click();
     harness.run_steps(2);

From 14cc73101b37a7c2305ff3763a29eaf28bd72eaa Mon Sep 17 00:00:00 2001
From: SusieeTheFemboy <96988330+SusieeTheLinuxUser@users.noreply.github.com>
Date: Sun, 1 Nov 2026 16:46:05 +0100
Subject: [PATCH 78/88] H.264: cite temporal direct as 8.4.1.2.3

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/h264/src/slicedec.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/h264/src/slicedec.rs b/crates/h264/src/slicedec.rs
index 2ada51594..557a94d46 100644
--- a/crates/h264/src/slicedec.rs
+++ b/crates/h264/src/slicedec.rs
@@ -566,7 +566,7 @@ impl<'a> SliceDecoder<'a> {
         (refs, mvs, false)
     }
 
-    /// Temporal direct mvs (8.4.1.2.4) from the co-located mv and `DistScaleFactor` (clamped
+    /// Temporal direct mvs (8.4.1.2.3) from the co-located mv and `DistScaleFactor` (clamped
     /// to ±1024 in `SliceDecoder`): mvL0 = clip_mv((mvCol · dsf + 128) >> 8), mvL1 =
     /// clip_mv(mvL0 − mvCol), both clipped to the spec's motion-vector range −2^15..2^15−1.
     /// The i32 maths cannot overflow; a truncating `as i16` used to wrap mvL0 past the range,

From f2f0c4373d2ac6ff707b42658909524796a582c9 Mon Sep 17 00:00:00 2001
From: "Dylan M. Taylor" <dylan@dylanmtaylor.com>
Date: Sun, 1 Nov 2026 12:30:03 -0500
Subject: [PATCH 79/88] docs: sync Craft App Suite list with ArtCraft Launcher

---
 README.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 0cdfc5842..730165a8e 100644
--- a/README.md
+++ b/README.md
@@ -286,7 +286,15 @@ stand on its own.
 | <img src="https://raw.githubusercontent.com/storytold/pdfcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.pdfcraft.png" alt="" width="32" height="32"> | **PdfCraft** | Reading, organizing and protecting PDFs | [GitHub](https://github.com/storytold/pdfcraft) | [Website](https://getartcraft.com/apps/pdfcraft) |
 | <img src="https://raw.githubusercontent.com/storytold/effectcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.effectcraft.png" alt="" width="32" height="32"> | **EffectCraft** | Motion graphics and visual effects | [GitHub](https://github.com/storytold/effectcraft) | [Website](https://getartcraft.com/apps/effectcraft) |
 | <img src="https://raw.githubusercontent.com/storytold/designcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.designcraft.png" alt="" width="32" height="32"> | **DesignCraft** | Page layout and publishing | [GitHub](https://github.com/storytold/designcraft) | [Website](https://getartcraft.com/apps/designcraft) |
-| <img src="https://raw.githubusercontent.com/storytold/deckcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.deckcraft.png" alt="" width="32" height="32"> | **DeckCraft** | **Presentations and slide shows · you are here** | [GitHub](https://github.com/storytold/deckcraft) | [Website](https://getartcraft.com/apps/deckcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/figcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.figcraft.png" alt="" width="32" height="32"> | **FigCraft** | Interface design and prototyping | [GitHub](https://github.com/storytold/figcraft) | [Website](https://getartcraft.com/apps/figcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/wordcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.wordcraft.png" alt="" width="32" height="32"> | **WordCraft** | Word processing and documents | [GitHub](https://github.com/storytold/wordcraft) | [Website](https://getartcraft.com/apps/wordcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/soundcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.soundcraft.png" alt="" width="32" height="32"> | **SoundCraft** | Audio recording and editing | [GitHub](https://github.com/storytold/soundcraft) | [Website](https://getartcraft.com/apps/soundcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/deckcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.deckcraft.png" alt="" width="32" height="32"> | **DeckCraft** | Presentations and slide decks | [GitHub](https://github.com/storytold/deckcraft) | [Website](https://getartcraft.com/apps/deckcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/cadcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.cadcraft.png" alt="" width="32" height="32"> | **CADCraft** | Computer-aided design | [GitHub](https://github.com/storytold/cadcraft) | [Website](https://getartcraft.com/apps/cadcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/gridcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.gridcraft.png" alt="" width="32" height="32"> | **GridCraft** | Spreadsheets and data | [GitHub](https://github.com/storytold/gridcraft) | [Website](https://getartcraft.com/apps/gridcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/texturecraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.texturecraft.png" alt="" width="32" height="32"> | **TextureCraft** | 3D texture painting | [GitHub](https://github.com/storytold/texturecraft) | [Website](https://getartcraft.com/apps/texturecraft) |
+| <img src="https://raw.githubusercontent.com/storytold/craft-anything/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.craft-anything.png" alt="" width="32" height="32"> | **Craft Anything** | See how any software works, then build your own | [GitHub](https://github.com/storytold/craft-anything) | [Website](https://getartcraft.com/apps/craft-anything) |
+| <img src="https://raw.githubusercontent.com/tangency-labs/solidcraft/main/assets/icons/app/linux/exports/hicolor/64x64/apps/io.tangencylabs.solidcraft.png" alt="" width="32" height="32"> | **SolidCraft** | Parametric 3D CAD by Tangency Labs (community app) | [GitHub](https://github.com/tangency-labs/solidcraft) | |
 
 And [**ArtCraft**](https://getartcraft.com/) itself, our AI image and video studio for artists who want real control.
 

From eaf8d1ce3f9e872b7c728d2cf3ca780e7fc1afd6 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <brandon@storyteller.ai>
Date: Sun, 1 Nov 2026 13:57:23 -0500
Subject: [PATCH 80/88] Release 0.14.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 56 +++++++++++++++++++++++++++---------------------------
 Cargo.toml |  2 +-
 2 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4c7e15203..73388603e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -984,7 +984,7 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
 [[package]]
 name = "deckcraft"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "arboard",
  "chrono",
@@ -1006,7 +1006,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-anim"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-geom",
  "deckcraft-model",
@@ -1015,7 +1015,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-av1"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1024,14 +1024,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-bitstream"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-cli"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-mcp",
@@ -1041,14 +1041,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-color"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "deckcraft-engine"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "chrono",
  "deckcraft-anim",
@@ -1074,7 +1074,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-fonts"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "epaint_default_fonts",
  "harfrust 0.13.3",
@@ -1086,7 +1086,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-format"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-model",
  "serde",
@@ -1097,7 +1097,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-geom"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "kurbo",
  "serde",
@@ -1105,7 +1105,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-h264"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1114,7 +1114,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-hevc"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1123,21 +1123,21 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-isobmff"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-matroska"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-mcp"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-render",
@@ -1147,7 +1147,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-media"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-av1",
  "deckcraft-h264",
@@ -1165,7 +1165,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-metafile"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "image",
  "kurbo",
@@ -1174,7 +1174,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-model"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-color",
  "deckcraft-geom",
@@ -1186,15 +1186,15 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-ogg"
-version = "0.13.1"
+version = "0.14.0"
 
 [[package]]
 name = "deckcraft-opus"
-version = "0.13.1"
+version = "0.14.0"
 
 [[package]]
 name = "deckcraft-pdf"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "craft-pdf",
  "deckcraft-fonts",
@@ -1212,7 +1212,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-pptx"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-color",
  "deckcraft-engine",
@@ -1228,7 +1228,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-render"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-anim",
  "deckcraft-color",
@@ -1247,7 +1247,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-text"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "chrono",
  "deckcraft-color",
@@ -1261,7 +1261,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-ui-egui"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "craft-ui",
  "craft-update",
@@ -1286,7 +1286,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-vp9"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1295,7 +1295,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-web"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-ui-egui",
@@ -6177,7 +6177,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
 
 [[package]]
 name = "xtask"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "serde_json",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 83d5d06bd..a814e4cc2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]
 
 [workspace.package]
-version = "0.13.1"
+version = "0.14.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"

From bbd579813fdf4d64e002ce9efd2c8de24becea06 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <brandon@storyteller.ai>
Date: Sun, 1 Nov 2026 14:14:20 -0500
Subject: [PATCH 81/88] packaging(flatpak): flatpak-oci.sh sources common.sh,
 not the absent env.sh

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 packaging/linux/flatpak-oci.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packaging/linux/flatpak-oci.sh b/packaging/linux/flatpak-oci.sh
index 5dd360353..a02f06063 100755
--- a/packaging/linux/flatpak-oci.sh
+++ b/packaging/linux/flatpak-oci.sh
@@ -10,8 +10,8 @@
 #   TAG            Target image tag (default: $VERSION-$ARCH, also tags stable-$ARCH)
 #   GITHUB_TOKEN   Token for GHCR authentication when --push is used
 set -euo pipefail
-# shellcheck source=../env.sh
-. "$(dirname "${BASH_SOURCE[0]}")/../env.sh"
+# shellcheck source=../common.sh
+. "$(dirname "${BASH_SOURCE[0]}")/../common.sh"
 HERE="$ROOT/packaging/linux"
 
 PUSH=0

From ee39ff67816d0039143ec7c98ea604cefe0cd2e5 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <brandon@storyteller.ai>
Date: Sun, 1 Nov 2026 14:14:22 -0500
Subject: [PATCH 82/88] Release 0.14.1

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock | 56 +++++++++++++++++++++++++++---------------------------
 Cargo.toml |  2 +-
 2 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 73388603e..408e99948 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -984,7 +984,7 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
 [[package]]
 name = "deckcraft"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "arboard",
  "chrono",
@@ -1006,7 +1006,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-anim"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-geom",
  "deckcraft-model",
@@ -1015,7 +1015,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-av1"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1024,14 +1024,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-bitstream"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-cli"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-mcp",
@@ -1041,14 +1041,14 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-color"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "deckcraft-engine"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "chrono",
  "deckcraft-anim",
@@ -1074,7 +1074,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-fonts"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "epaint_default_fonts",
  "harfrust 0.13.3",
@@ -1086,7 +1086,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-format"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-model",
  "serde",
@@ -1097,7 +1097,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-geom"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "kurbo",
  "serde",
@@ -1105,7 +1105,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-h264"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1114,7 +1114,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-hevc"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1123,21 +1123,21 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-isobmff"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-matroska"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "craft-media",
 ]
 
 [[package]]
 name = "deckcraft-mcp"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-render",
@@ -1147,7 +1147,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-media"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-av1",
  "deckcraft-h264",
@@ -1165,7 +1165,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-metafile"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "image",
  "kurbo",
@@ -1174,7 +1174,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-model"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-color",
  "deckcraft-geom",
@@ -1186,15 +1186,15 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-ogg"
-version = "0.14.0"
+version = "0.14.1"
 
 [[package]]
 name = "deckcraft-opus"
-version = "0.14.0"
+version = "0.14.1"
 
 [[package]]
 name = "deckcraft-pdf"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "craft-pdf",
  "deckcraft-fonts",
@@ -1212,7 +1212,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-pptx"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-color",
  "deckcraft-engine",
@@ -1228,7 +1228,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-render"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-anim",
  "deckcraft-color",
@@ -1247,7 +1247,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-text"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "chrono",
  "deckcraft-color",
@@ -1261,7 +1261,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-ui-egui"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "craft-ui",
  "craft-update",
@@ -1286,7 +1286,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-vp9"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-bitstream",
  "rayon",
@@ -1295,7 +1295,7 @@ dependencies = [
 
 [[package]]
 name = "deckcraft-web"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "deckcraft-engine",
  "deckcraft-ui-egui",
@@ -6177,7 +6177,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
 
 [[package]]
 name = "xtask"
-version = "0.14.0"
+version = "0.14.1"
 dependencies = [
  "serde_json",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index a814e4cc2..7cd456fdf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]
 
 [workspace.package]
-version = "0.14.0"
+version = "0.14.1"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"

From 90058395b78be26bb7ea7b4914a9f113c28d979d Mon Sep 17 00:00:00 2001
From: FredApps <153173854+FredApps@users.noreply.github.com>
Date: Sun, 1 Nov 2026 21:36:45 +0100
Subject: [PATCH 83/88] WASM: open presenter view in a separate browser window
 (#729) (#730)

* docs: track WASM presenter popout work (#729)

* Fix presenter transport retries and initialize popup note fonts

* Clarify optional font coverage and source-verified popup lifecycle

---------

Co-authored-by: FredApps <FredApps@users.noreply.github.com>
---
 apps/deckcraft-web/Cargo.toml       |   2 +-
 apps/deckcraft-web/src/main.rs      |   2 +
 apps/deckcraft-web/src/presenter.rs | 303 +++++++++++++++++++
 apps/deckcraft-web/src/web.rs       |  17 ++
 crates/engine/src/recovery.rs       |  10 +
 crates/pdf/src/tests.rs             |   3 +-
 crates/ui-egui/src/lib.rs           |   1 +
 crates/ui-egui/src/presenter.rs     | 450 ++++++++++++++++++++++++++++
 crates/ui-egui/src/services.rs      |   2 +
 crates/ui-egui/src/show.rs          |   8 +
 crates/ui-egui/src/show/keys.rs     |  21 +-
 crates/ui-egui/src/show/tests.rs    |  60 ++++
 crates/ui-egui/src/show/ui.rs       |  85 +++++-
 docs/wasm-presenter-popout-729.md   |  65 ++++
 14 files changed, 1018 insertions(+), 11 deletions(-)
 create mode 100644 apps/deckcraft-web/src/presenter.rs
 create mode 100644 crates/ui-egui/src/presenter.rs
 create mode 100644 docs/wasm-presenter-popout-729.md

diff --git a/apps/deckcraft-web/Cargo.toml b/apps/deckcraft-web/Cargo.toml
index 7014421d8..541985e5b 100644
--- a/apps/deckcraft-web/Cargo.toml
+++ b/apps/deckcraft-web/Cargo.toml
@@ -27,4 +27,4 @@ rfd = { workspace = true }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 js-sys = "0.3"
-web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration"] }
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "MessageEvent", "Event", "EventTarget"] }
diff --git a/apps/deckcraft-web/src/main.rs b/apps/deckcraft-web/src/main.rs
index 6d2b7e943..2ce622e9a 100644
--- a/apps/deckcraft-web/src/main.rs
+++ b/apps/deckcraft-web/src/main.rs
@@ -18,6 +18,8 @@
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 #![forbid(unsafe_code)]
 
+#[cfg(target_arch = "wasm32")]
+mod presenter;
 #[cfg(target_arch = "wasm32")]
 mod web;
 
diff --git a/apps/deckcraft-web/src/presenter.rs b/apps/deckcraft-web/src/presenter.rs
new file mode 100644
index 000000000..1ec9a298c
--- /dev/null
+++ b/apps/deckcraft-web/src/presenter.rs
@@ -0,0 +1,303 @@
+//! Same-origin popup transport. Each window starts its own eframe/WASM runner.
+use deckcraft_ui_egui::presenter::{Command, DeltaCache, Host, Snapshot, View};
+use std::{
+    cell::RefCell,
+    collections::VecDeque,
+    rc::{Rc, Weak},
+};
+use wasm_bindgen::{JsCast, closure::Closure};
+
+const MAX_MESSAGE: usize = 16 * 1024 * 1024;
+const MAX_COMMANDS: usize = 64;
+const PREFIX: &str = "#deckcraft-presenter=";
+fn error(e: wasm_bindgen::JsValue) -> String {
+    format!("{e:?}")
+}
+fn origin() -> Result<String, String> {
+    web_sys::window().ok_or("No browser window")?.location().origin().map_err(error)
+}
+pub fn token() -> Option<String> {
+    let hash = web_sys::window()?.location().hash().ok()?;
+    let token = hash.strip_prefix(PREFIX)?;
+    (!token.is_empty() && token.len() < 128).then(|| token.to_owned())
+}
+fn same_source(event: &web_sys::MessageEvent, window: &web_sys::Window, expected_origin: &str) -> bool {
+    event.origin() == expected_origin && event.source().is_some_and(|source| js_sys::Object::is(source.as_ref(), window.as_ref()))
+}
+fn send(window: &web_sys::Window, origin: &str, value: serde_json::Value) -> Result<(), String> {
+    let text = serde_json::to_string(&value).map_err(|e| e.to_string())?;
+    if text.len() > MAX_MESSAGE {
+        return Err("Presenter message is too large".into());
+    }
+    window.post_message(&wasm_bindgen::JsValue::from_str(&text), origin).map_err(error)
+}
+struct State {
+    popup: Option<web_sys::Window>,
+    token: String,
+    commands: VecDeque<Command>,
+    ready: bool,
+    refresh_images: bool,
+}
+pub struct BrowserHost {
+    state: Rc<RefCell<State>>,
+    origin: String,
+    listener: Closure<dyn FnMut(web_sys::MessageEvent)>,
+    button: Option<(web_sys::HtmlElement, Closure<dyn FnMut(web_sys::Event)>)>,
+    images: DeltaCache,
+}
+impl BrowserHost {
+    pub fn new(ctx: egui::Context) -> Result<Self, String> {
+        let window = web_sys::window().ok_or("No browser window")?;
+        let origin = origin()?;
+        let state = Rc::new(RefCell::new(State { popup: None, token: String::new(), commands: VecDeque::new(), ready: false, refresh_images: true }));
+        let weak = Rc::downgrade(&state);
+        let expected = origin.clone();
+        let listener = Closure::new(move |event: web_sys::MessageEvent| {
+            let Some(state) = weak.upgrade() else { return };
+            let Ok(mut state) = state.try_borrow_mut() else { return };
+            let Some(popup) = state.popup.as_ref() else { return };
+            if !same_source(&event, popup, &expected) {
+                return;
+            }
+            let Some(text) = event.data().as_string().filter(|s| s.len() <= 8192) else { return };
+            let Ok(value) = serde_json::from_str::<serde_json::Value>(&text) else { return };
+            if value.get("token").and_then(|v| v.as_str()) != Some(state.token.as_str()) {
+                return;
+            }
+            match value.get("kind").and_then(|v| v.as_str()) {
+                Some("ready") => {
+                    state.ready = true;
+                    state.refresh_images = true;
+                }
+                Some("command") if state.commands.len() < MAX_COMMANDS => {
+                    if let Some(command) = value.get("command").and_then(|v| serde_json::from_value(v.clone()).ok()) {
+                        state.commands.push_back(command);
+                    }
+                }
+                _ => {}
+            }
+            ctx.request_repaint();
+        });
+        window.add_event_listener_with_callback("message", listener.as_ref().unchecked_ref()).map_err(error)?;
+        Ok(Self { state, origin, listener, button: None, images: DeltaCache::default() })
+    }
+    fn remove_button(&mut self) {
+        if let Some((button, callback)) = self.button.take() {
+            let _ = button.remove_event_listener_with_callback("click", callback.as_ref().unchecked_ref());
+            button.remove();
+        }
+    }
+    fn recovery_button(&mut self) {
+        if self.button.is_some() {
+            return;
+        }
+        let Some(document) = web_sys::window().and_then(|w| w.document()) else { return };
+        let Some(body) = document.body() else { return };
+        let Ok(element) = document.create_element("button") else { return };
+        let Ok(button) = element.dyn_into::<web_sys::HtmlElement>() else { return };
+        button.set_text_content(Some("Open presenter window"));
+        let _ = button.set_attribute("style", "position:fixed;top:12px;right:12px;z-index:9999;padding:12px;color:white;background:#333;border:1px solid #aaa;border-radius:4px;cursor:pointer");
+        let weak: Weak<RefCell<State>> = Rc::downgrade(&self.state);
+        let button_copy = button.clone();
+        let callback = Closure::new(move |_event: web_sys::Event| {
+            if let Some(state) = weak.upgrade() {
+                match open_popup(&state) {
+                    Ok(()) => {
+                        button_copy.set_text_content(Some("Opening presenter window…"));
+                    }
+                    Err(_) => {
+                        button_copy.set_text_content(Some("Popup blocked. Allow popups, then click to retry."));
+                    }
+                }
+            }
+        });
+        if button.add_event_listener_with_callback("click", callback.as_ref().unchecked_ref()).is_ok() && body.append_child(&button).is_ok() {
+            self.button = Some((button, callback));
+        } else {
+            let _ = button.remove_event_listener_with_callback("click", callback.as_ref().unchecked_ref());
+            button.remove();
+        }
+    }
+}
+fn open_popup(state: &Rc<RefCell<State>>) -> Result<(), String> {
+    let window = web_sys::window().ok_or("No browser window")?;
+    let mut state = state.try_borrow_mut().map_err(|_| "Presenter is busy")?;
+    if let Some(popup) = &state.popup
+        && !popup.closed().unwrap_or(true)
+    {
+        let _ = popup.focus();
+        return Ok(());
+    }
+    let token = format!("{}-{}", js_sys::Date::now(), js_sys::Math::random());
+    let url = web_sys::Url::new(&window.location().href().map_err(error)?).map_err(error)?;
+    url.set_hash(&format!("{PREFIX}{token}"));
+    let popup = window
+        .open_with_url_and_target_and_features(&url.href(), "_blank", "popup,width=1100,height=700")
+        .map_err(error)?
+        .ok_or("Presenter popup was blocked. Use Open presenter window to retry.")?;
+    if popup.closed().unwrap_or(true) {
+        return Err("Browser isolation prevented connecting the presenter window".into());
+    }
+    state.popup = Some(popup);
+    state.token = token;
+    state.commands.clear();
+    state.ready = false;
+    Ok(())
+}
+impl Host for BrowserHost {
+    fn open(&mut self) -> Result<(), String> {
+        self.close();
+        let result = open_popup(&self.state);
+        if result.is_err() {
+            self.recovery_button();
+        }
+        result
+    }
+    fn is_open(&self) -> bool {
+        self.state.borrow().popup.as_ref().is_some_and(|w| !w.closed().unwrap_or(true))
+    }
+    fn commands(&mut self) -> Vec<Command> {
+        self.state.borrow_mut().commands.drain(..).collect()
+    }
+    fn update(&mut self, snapshot: Snapshot) {
+        if !self.is_open() {
+            self.recovery_button();
+            return;
+        }
+        self.remove_button();
+        let mut state = self.state.borrow_mut();
+        if !state.ready {
+            return;
+        }
+        if let Some(popup) = state.popup.clone() {
+            let token = state.token.clone();
+            let sent = self.images.send(snapshot, &token, state.refresh_images, |delta, current_changed, next_changed| {
+                send(
+                    &popup,
+                    &self.origin,
+                    serde_json::json!({"kind":"snapshot", "token":token, "snapshot":delta,
+                    "currentChanged":current_changed, "nextChanged":next_changed}),
+                )
+            });
+            if sent.is_ok() {
+                state.refresh_images = false;
+            }
+        }
+    }
+    fn close(&mut self) {
+        self.remove_button();
+        let mut state = self.state.borrow_mut();
+        if let Some(window) = state.popup.take() {
+            let _ = window.close();
+        }
+        state.commands.clear();
+        state.ready = false;
+        state.token.clear();
+    }
+}
+impl Drop for BrowserHost {
+    fn drop(&mut self) {
+        self.close();
+        if let Some(window) = web_sys::window() {
+            let _ = window.remove_event_listener_with_callback("message", self.listener.as_ref().unchecked_ref());
+        }
+    }
+}
+
+pub struct Popup {
+    token: String,
+    origin: String,
+    opener: web_sys::Window,
+    snapshot: Rc<RefCell<Option<Snapshot>>>,
+    last_received: Rc<RefCell<f64>>,
+    listener: Closure<dyn FnMut(web_sys::MessageEvent)>,
+    view: View,
+}
+impl Popup {
+    pub fn new(token: String, ctx: egui::Context) -> Result<Self, String> {
+        let window = web_sys::window().ok_or("No browser window")?;
+        // `opener` is a WindowProxy from another realm; instanceof Window can fail across
+        // realms. The browser API supplies a WindowProxy or null, and messages still verify
+        // exact source identity and origin before any data is accepted.
+        let opener = window.opener().map_err(error)?;
+        if opener.is_null() || opener.is_undefined() {
+            return Err("The audience window is unavailable".into());
+        }
+        let opener: web_sys::Window = opener.unchecked_into();
+        let origin = origin()?;
+        let snapshot: Rc<RefCell<Option<Snapshot>>> = Rc::new(RefCell::new(None));
+        let last_received = Rc::new(RefCell::new(js_sys::Date::now()));
+        let received = last_received.clone();
+        let target = snapshot.clone();
+        let expected_origin = origin.clone();
+        let expected_opener = opener.clone();
+        let expected_token = token.clone();
+        let listener = Closure::new(move |event: web_sys::MessageEvent| {
+            if !same_source(&event, &expected_opener, &expected_origin) {
+                return;
+            }
+            let Some(text) = event.data().as_string().filter(|s| s.len() <= MAX_MESSAGE) else { return };
+            let Ok(value) = serde_json::from_str::<serde_json::Value>(&text) else { return };
+            if value.get("token").and_then(|v| v.as_str()) != Some(expected_token.as_str())
+                || value.get("kind").and_then(|v| v.as_str()) != Some("snapshot")
+            {
+                return;
+            }
+            if let Some(mut data) = value.get("snapshot").and_then(|v| serde_json::from_value::<Snapshot>(v.clone()).ok()) {
+                if let Some(previous) = target.borrow().as_ref() {
+                    if value.get("currentChanged").and_then(|v| v.as_bool()) == Some(false) {
+                        data.current = previous.current.clone();
+                    }
+                    if value.get("nextChanged").and_then(|v| v.as_bool()) == Some(false) {
+                        data.next = previous.next.clone();
+                    }
+                }
+                *target.borrow_mut() = Some(data);
+                *received.borrow_mut() = js_sys::Date::now();
+                ctx.request_repaint();
+            }
+        });
+        window.add_event_listener_with_callback("message", listener.as_ref().unchecked_ref()).map_err(error)?;
+        if let Some(document) = window.document() {
+            document.set_title("Presenter View — DeckCraft");
+        }
+        let popup = Self { token, origin, opener, snapshot, last_received, listener, view: View::default() };
+        send(&popup.opener, &popup.origin, serde_json::json!({"kind":"ready","token":popup.token}))?;
+        Ok(popup)
+    }
+}
+impl eframe::App for Popup {
+    fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
+        let snapshot = self.snapshot.borrow();
+        let notes = snapshot.as_ref().map_or("", |snapshot| snapshot.notes.as_str());
+        if !self.view.prepare(ui.ctx(), notes) {
+            return;
+        }
+        ui.ctx().request_repaint_after(std::time::Duration::from_millis(500));
+        if self.opener.closed().unwrap_or(true) {
+            ui.heading("The audience window has closed.");
+            return;
+        }
+        if js_sys::Date::now() - *self.last_received.borrow() > 10_000.0 {
+            ui.heading("The audience window is not responding.");
+            ui.label("Return to the audience window to resume the connection.");
+            return;
+        }
+        egui::CentralPanel::default().show(ui, |ui| {
+            if let Some(snapshot) = snapshot.as_ref() {
+                for command in self.view.ui(ui, snapshot) {
+                    let _ = send(&self.opener, &self.origin, serde_json::json!({"kind":"command","token":self.token,"command":command}));
+                }
+            } else {
+                ui.label("Waiting for the audience window…");
+            }
+        });
+    }
+}
+impl Drop for Popup {
+    fn drop(&mut self) {
+        if let Some(window) = web_sys::window() {
+            let _ = window.remove_event_listener_with_callback("message", self.listener.as_ref().unchecked_ref());
+        }
+    }
+}
diff --git a/apps/deckcraft-web/src/web.rs b/apps/deckcraft-web/src/web.rs
index f8e68a35c..a385d44c8 100644
--- a/apps/deckcraft-web/src/web.rs
+++ b/apps/deckcraft-web/src/web.rs
@@ -39,6 +39,10 @@ pub fn start() {
                         log::info!("deckcraft-web {}: wgpu backend {:?}", env!("CARGO_PKG_VERSION"), rs.adapter.get_info().backend);
                     }
                     deckcraft_ui_egui::install_ime_pass_hooks(&cc.egui_ctx);
+                    if let Some(token) = crate::presenter::token() {
+                        let presenter = crate::presenter::Popup::new(token, cc.egui_ctx.clone()).map_err(std::io::Error::other)?;
+                        return Ok(Box::new(presenter) as Box<dyn eframe::App>);
+                    }
                     let inbox: Inbox = Inbox::default();
                     let mut app = SlideApp::new(Session::new(), services(inbox.clone(), cc.egui_ctx.clone()));
                     let q = query();
@@ -80,6 +84,11 @@ impl eframe::App for WebShell {
     /// Delegate one eframe logic pass to the wrapped application.
     fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         self.app.logic(ctx);
+        if self.app.show.is_none()
+            && let Some(host) = self.app.services.presenter.as_mut()
+        {
+            host.close();
+        }
     }
 
     /// Consume browser drops with fresh input, capture the identity before the asynchronous read,
@@ -118,7 +127,15 @@ impl eframe::App for WebShell {
 /// back to `open_async` (browser picker → inbox) and `download`.
 fn services(inbox: Inbox, ctx: egui::Context) -> Services {
     let open_inbox = inbox.clone();
+    let presenter = match crate::presenter::BrowserHost::new(ctx.clone()) {
+        Ok(host) => Some(Box::new(host) as Box<dyn deckcraft_ui_egui::presenter::Host>),
+        Err(error) => {
+            log::error!("Presenter window: {error}");
+            None
+        }
+    };
     Services {
+        presenter,
         open_async: Some(Box::new(move |purpose: &str, request: u64| {
             let inbox = open_inbox.clone();
             let ctx = ctx.clone();
diff --git a/crates/engine/src/recovery.rs b/crates/engine/src/recovery.rs
index 6c5c02308..d8c9f23ef 100644
--- a/crates/engine/src/recovery.rs
+++ b/crates/engine/src/recovery.rs
@@ -259,6 +259,16 @@ mod tests {
         dir
     }
 
+    #[test]
+    fn instance_identity_is_stable_nonzero_and_json_safe() {
+        let id = instance_id();
+        assert_eq!(instance_id(), id);
+        assert!(id != 0 && id <= UID_MASK);
+        assert_eq!(id & 0xFF_FFFF, 0);
+        let encoded = serde_json::to_value(id).unwrap();
+        assert_eq!(encoded.as_f64().unwrap() as u64, id);
+    }
+
     #[test]
     fn recovers_unsaved_presentations() {
         let dir = temp("recovery");
diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs
index 8bdbbce93..b34e963e1 100644
--- a/crates/pdf/src/tests.rs
+++ b/crates/pdf/src/tests.rs
@@ -202,7 +202,8 @@ fn unsafe_url_links_are_not_exported() {
 /// memory. Its naming/shaping tables still parse, but its missing head table prevents PDF
 /// embedding. No font bytes or vendor assets are stored as test fixtures.
 fn font_without_head() -> Vec<u8> {
-    let mut bytes = FontDb::global().face("Ubuntu", "Regular").data().to_vec();
+    // The final bundled face is always Ubuntu Light; a system lookup may select a variable font.
+    let mut bytes = deckcraft_fonts::bundled().last().unwrap().to_vec();
     for (old, new) in [(b"Ubuntu".as_slice(), b"BadPDF".as_slice()), (b"\0U\0b\0u\0n\0t\0u".as_slice(), b"\0B\0a\0d\0P\0D\0F".as_slice())] {
         let mut offset = 0;
         while offset + old.len() <= bytes.len() {
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index b4e531ba4..566dffabe 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -26,6 +26,7 @@ pub mod icons;
 pub mod media;
 pub mod menus;
 pub mod opening;
+pub mod presenter;
 pub mod ribbon;
 pub mod settings;
 pub mod show;
diff --git a/crates/ui-egui/src/presenter.rs b/crates/ui-egui/src/presenter.rs
new file mode 100644
index 000000000..95569778d
--- /dev/null
+++ b/crates/ui-egui/src/presenter.rs
@@ -0,0 +1,450 @@
+//! Bounded presenter-window messages. The audience owns the show; the remote window
+//! receives previews and sends input, never a second independently advancing show.
+use serde::{Deserialize, Serialize};
+
+pub const MAX_PREVIEW_SIDE: usize = 640;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Preview {
+    pub width: usize,
+    pub height: usize,
+    pub rgba: Vec<u8>,
+}
+impl Preview {
+    pub fn from_image(image: &egui::ColorImage) -> Option<Self> {
+        let [w, h] = image.size;
+        if w == 0 || h == 0 || w.checked_mul(h)? != image.pixels.len() {
+            return None;
+        }
+        let scale = (MAX_PREVIEW_SIDE as f64 / w.max(h) as f64).min(1.0);
+        let width = ((w as f64 * scale) as usize).max(1);
+        let height = ((h as f64 * scale) as usize).max(1);
+        let mut rgba = Vec::with_capacity(width * height * 4);
+        for y in 0..height {
+            for x in 0..width {
+                let pixel = image.pixels.get((y * h / height) * w + x * w / width)?;
+                rgba.extend_from_slice(&pixel.to_srgba_unmultiplied());
+            }
+        }
+        Some(Self { width, height, rgba })
+    }
+    pub fn image(&self) -> Option<egui::ColorImage> {
+        if self.width == 0
+            || self.height == 0
+            || self.width > MAX_PREVIEW_SIDE
+            || self.height > MAX_PREVIEW_SIDE
+            || self.width.checked_mul(self.height)?.checked_mul(4)? != self.rgba.len()
+        {
+            return None;
+        }
+        Some(egui::ColorImage::from_rgba_unmultiplied([self.width, self.height], &self.rgba))
+    }
+}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Snapshot {
+    pub slide: usize,
+    pub total: usize,
+    pub ended: bool,
+    pub notes: String,
+    pub elapsed: String,
+    pub paused: bool,
+    pub notes_px: f32,
+    pub blank: Option<String>,
+    pub grid: bool,
+    pub zoom_armed: bool,
+    pub current: Option<Preview>,
+    pub next: Option<Preview>,
+}
+
+/// Images acknowledged by a successful transport send, never merely attempted images.
+#[derive(Default)]
+pub struct DeltaCache {
+    current: Option<Preview>,
+    next: Option<Preview>,
+    token: String,
+}
+impl DeltaCache {
+    pub fn send<E>(
+        &mut self,
+        mut snapshot: Snapshot,
+        token: &str,
+        refresh: bool,
+        send: impl FnOnce(Snapshot, bool, bool) -> Result<(), E>,
+    ) -> Result<(), E> {
+        let fresh = refresh || self.token != token;
+        let current_changed = fresh || self.current != snapshot.current;
+        let next_changed = fresh || self.next != snapshot.next;
+        let current = snapshot.current.clone();
+        let next = snapshot.next.clone();
+        if !current_changed {
+            snapshot.current = None;
+        }
+        if !next_changed {
+            snapshot.next = None;
+        }
+        send(snapshot, current_changed, next_changed)?;
+        self.current = current;
+        self.next = next;
+        self.token = token.to_owned();
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum Command {
+    Key { name: String, command: bool, shift: bool, alt: bool, ctrl: bool },
+    Zoom { x: f32, y: f32 },
+    End,
+}
+/// Implemented by the browser host. Native hosts retain the existing egui viewport.
+pub trait Host {
+    fn open(&mut self) -> Result<(), String>;
+    fn is_open(&self) -> bool;
+    fn commands(&mut self) -> Vec<Command>;
+    fn update(&mut self, snapshot: Snapshot);
+    fn close(&mut self);
+}
+
+/// The popup's independent egui renderer. It never advances a local show clock.
+#[derive(Default)]
+pub struct View {
+    fonts: crate::uifonts::UiFonts,
+    styled: bool,
+    current: Option<egui::TextureHandle>,
+    next: Option<egui::TextureHandle>,
+    previous_current: Option<Preview>,
+    previous_next: Option<Preview>,
+}
+impl View {
+    /// Install the same interface and dynamic fallback fonts as SlideApp before layout.
+    /// Font definitions take effect on the next pass; never forward input on a discarded pass.
+    pub fn prepare(&mut self, ctx: &egui::Context, notes: &str) -> bool {
+        if !self.styled {
+            crate::theme::install_fonts_with(ctx, &self.fonts.faces);
+            crate::theme::apply(ctx, &crate::theme::Tokens::dark());
+            self.styled = true;
+            ctx.request_discard("install presenter interface fonts before layout");
+            return false;
+        }
+        if ctx.will_discard() {
+            return false;
+        }
+        self.fonts.note(ctx, notes);
+        if self.fonts.apply(ctx) {
+            ctx.request_discard("install presenter note fallback fonts before layout");
+            return false;
+        }
+        true
+    }
+
+    pub fn ui(&mut self, ui: &mut egui::Ui, snapshot: &Snapshot) -> Vec<Command> {
+        if !self.prepare(ui.ctx(), &snapshot.notes) {
+            return Vec::new();
+        }
+        let mut commands = Vec::new();
+        let keys = ui.input(|i| {
+            i.events
+                .iter()
+                .filter_map(|event| if let egui::Event::Key { key, pressed: true, modifiers, .. } = event { Some((*key, *modifiers)) } else { None })
+                .collect::<Vec<_>>()
+        });
+        for (key, modifiers) in keys {
+            // Consume once before widgets see Space/Enter, avoiding a second button activation.
+            ui.input_mut(|i| i.consume_key(modifiers, key));
+            commands.push(Command::Key {
+                name: key.name().into(),
+                command: modifiers.command,
+                shift: modifiers.shift,
+                alt: modifiers.alt,
+                ctrl: modifiers.ctrl,
+            });
+        }
+        fn update(
+            ctx: &egui::Context,
+            name: &str,
+            previous: &mut Option<Preview>,
+            texture: &mut Option<egui::TextureHandle>,
+            image: &Option<Preview>,
+        ) {
+            if previous == image {
+                return;
+            }
+            *previous = image.clone();
+            *texture = image.as_ref().and_then(Preview::image).map(|image| ctx.load_texture(name, image, egui::TextureOptions::LINEAR));
+        }
+        update(ui.ctx(), "remote-current", &mut self.previous_current, &mut self.current, &snapshot.current);
+        update(ui.ctx(), "remote-next", &mut self.previous_next, &mut self.next, &snapshot.next);
+        let key = |name: &str| Command::Key { name: name.into(), command: false, shift: false, alt: false, ctrl: false };
+        ui.horizontal_wrapped(|ui| {
+            ui.heading(&snapshot.elapsed);
+            ui.label(format!("Slide {} of {}", snapshot.slide.saturating_add(1), snapshot.total));
+            for (label, name) in [("◀ Previous", "ArrowLeft"), ("Next ▶", "ArrowRight")] {
+                if ui.button(label).clicked() {
+                    commands.push(key(name));
+                }
+            }
+            if ui.button("End Show").clicked() {
+                commands.push(Command::End);
+            }
+        });
+        ui.horizontal_wrapped(|ui| {
+            for (label, name) in [
+                (if snapshot.paused { "Resume" } else { "Pause" }, "T"),
+                ("Reset", "R"),
+                ("Black", "B"),
+                ("White", "W"),
+                ("All slides", "G"),
+                ("Zoom", "Z"),
+            ] {
+                if ui.button(label).clicked() {
+                    commands.push(key(name));
+                }
+            }
+        });
+        ui.separator();
+        ui.columns(2, |columns| {
+            let left = &mut columns[0];
+            if snapshot.ended {
+                left.heading("End of slide show");
+            } else if let Some(texture) = &self.current {
+                let response = left.add(
+                    egui::Image::new(texture)
+                        .fit_to_exact_size(fit_preview(texture.size_vec2(), left.available_width(), left.available_height() * 0.8))
+                        .sense(egui::Sense::click()),
+                );
+                if let Some(blank) = &snapshot.blank {
+                    let color = if blank == "white" { egui::Color32::WHITE } else { egui::Color32::BLACK };
+                    left.painter().rect_filled(response.rect, 0.0, color);
+                }
+                if snapshot.zoom_armed
+                    && response.clicked()
+                    && let Some(point) = response.interact_pointer_pos()
+                {
+                    commands.push(Command::Zoom {
+                        x: (point.x - response.rect.left()) / response.rect.width().max(1.0),
+                        y: (point.y - response.rect.top()) / response.rect.height().max(1.0),
+                    });
+                }
+            }
+            if snapshot.zoom_armed {
+                left.label("Click the preview to zoom.");
+            }
+            if snapshot.grid {
+                left.label("Choose a slide in the audience window, or press G to return.");
+            }
+            let right = &mut columns[1];
+            right.label("Next");
+            if let Some(texture) = &self.next {
+                right.add(egui::Image::new(texture).fit_to_exact_size(fit_preview(
+                    texture.size_vec2(),
+                    right.available_width(),
+                    right.available_height() * 0.45,
+                )));
+            } else {
+                right.label("End of slide show");
+            }
+            right.horizontal(|ui| {
+                ui.label("Notes");
+                if ui.button("A−").clicked() {
+                    commands.push(key(egui::Key::OpenBracket.name()));
+                }
+                if ui.button("A+").clicked() {
+                    commands.push(key(egui::Key::CloseBracket.name()));
+                }
+            });
+            egui::ScrollArea::vertical().show(right, |ui| {
+                ui.label(
+                    egui::RichText::new(if snapshot.notes.is_empty() { "No notes." } else { &snapshot.notes })
+                        .size(snapshot.notes_px.clamp(10.0, 72.0)),
+                );
+            });
+        });
+        commands
+    }
+}
+fn fit_preview(size: egui::Vec2, width: f32, height: f32) -> egui::Vec2 {
+    size * (width.max(1.0) / size.x.max(1.0)).min(height.max(1.0) / size.y.max(1.0))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn snapshot() -> Snapshot {
+        Snapshot {
+            slide: 0,
+            total: 2,
+            ended: false,
+            notes: String::new(),
+            elapsed: "00:00:00".into(),
+            paused: false,
+            notes_px: 18.0,
+            blank: None,
+            grid: false,
+            zoom_armed: false,
+            current: Some(Preview { width: 1, height: 1, rgba: vec![255; 4] }),
+            next: Some(Preview { width: 1, height: 1, rgba: vec![0; 4] }),
+        }
+    }
+
+    #[test]
+    fn failed_transport_retries_images_and_only_success_deduplicates() {
+        let mut cache = DeltaCache::default();
+        let first = snapshot();
+        let failed = cache.send(first.clone(), "session", false, |delta, current, next| {
+            assert!(current && next);
+            assert_eq!(delta.current, first.current);
+            assert_eq!(delta.next, first.next);
+            Err("serialization or postMessage failed")
+        });
+        assert!(failed.is_err());
+        let sent = cache.send(first.clone(), "session", false, |delta, current, next| {
+            assert!(current && next, "a failed initial send must not suppress either image");
+            assert_eq!(delta.current, first.current);
+            assert_eq!(delta.next, first.next);
+            Ok::<_, ()>(())
+        });
+        assert!(sent.is_ok());
+        let sent = cache.send(first.clone(), "session", false, |delta, current, next| {
+            assert!(!current && !next);
+            assert!(delta.current.is_none() && delta.next.is_none());
+            Ok::<_, ()>(())
+        });
+        assert!(sent.is_ok());
+        let mut changed = first.clone();
+        changed.current.as_mut().unwrap().rgba = vec![42; 4];
+        let failed = cache.send(changed.clone(), "session", false, |_, current, next| {
+            assert!(current && !next);
+            Err(())
+        });
+        assert!(failed.is_err());
+        let sent = cache.send(changed.clone(), "session", false, |delta, current, next| {
+            assert!(current && !next, "unchanged retry after a failed changed-image send");
+            assert_eq!(delta.current, changed.current);
+            Ok::<_, ()>(())
+        });
+        assert!(sent.is_ok());
+    }
+
+    #[test]
+    fn transport_refreshes_new_sessions_reloads_and_clears_previews() {
+        let mut cache = DeltaCache::default();
+        for (token, refresh) in [("first", false), ("second", false), ("second", true)] {
+            let sent = cache.send(snapshot(), token, refresh, |delta, current, next| {
+                assert!(current && next);
+                assert!(delta.current.is_some() && delta.next.is_some());
+                Ok::<_, ()>(())
+            });
+            assert!(sent.is_ok());
+        }
+        let failed = cache.send(snapshot(), "second", true, |_, current, next| {
+            assert!(current && next);
+            Err(())
+        });
+        // BrowserHost retains refresh_images after failure, even when the token is unchanged.
+        let refresh_images = failed.is_err();
+        let sent = cache.send(snapshot(), "second", refresh_images, |_, current, next| {
+            assert!(current && next, "reload refresh must survive a failed send");
+            Ok::<_, ()>(())
+        });
+        assert!(sent.is_ok());
+        let mut cleared = snapshot();
+        cleared.current = None;
+        cleared.next = None;
+        let failed = cache.send(cleared.clone(), "second", false, |_, current, next| {
+            assert!(current && next);
+            Err(())
+        });
+        assert!(failed.is_err());
+        let sent = cache.send(cleared.clone(), "second", false, |delta, current, next| {
+            assert!(current && next, "clearing images is retried too");
+            assert!(delta.current.is_none() && delta.next.is_none());
+            Ok::<_, ()>(())
+        });
+        assert!(sent.is_ok());
+        let sent = cache.send(cleared, "second", false, |_, current, next| {
+            assert!(!current && !next);
+            Ok::<_, ()>(())
+        });
+        assert!(sent.is_ok());
+    }
+
+    #[test]
+    fn popup_installs_interface_fonts_before_non_latin_note_layout() {
+        let ctx = egui::Context::default();
+        let mut view = View::default();
+        let mut data = snapshot();
+        let arabic = "\u{645}\u{631}\u{62d}\u{628}\u{627}";
+        let japanese = "\u{65e5}\u{672c}\u{8a9e}";
+        let korean = "\u{d55c}\u{ae00}";
+        data.notes = format!("{arabic} {japanese} {korean}");
+        let mut installing = 0;
+        let mut layouts = 0;
+        for _ in 0..4 {
+            let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
+                if !view.prepare(ui.ctx(), &data.notes) {
+                    installing += 1;
+                    assert!(view.ui(ui, &data).is_empty(), "no commands during a discarded font-install pass");
+                    return;
+                }
+                assert!(!ui.ctx().will_discard());
+                layouts += 1;
+                for (family, text) in [("Noto Sans Arabic", arabic), ("BIZ UDPGothic", japanese), ("NanumGothic", korean)] {
+                    if deckcraft_fonts::CRAFT_FONTS.iter().any(|face| face.family == family) {
+                        ui.ctx().fonts_mut(|fonts| {
+                            for c in text.chars() {
+                                assert!(fonts.has_glyph(&egui::FontId::proportional(18.0), c), "missing bundled {family} glyph {c:?}");
+                            }
+                        });
+                    }
+                }
+                let _ = view.ui(ui, &data);
+            });
+            output.textures_delta.clear();
+        }
+        assert!(installing > 0 && layouts > 0, "font installation must precede an actual notes layout");
+    }
+    #[test]
+    fn popup_input_is_forwarded_once_without_advancing_its_own_state() {
+        use egui_kittest::kittest::Queryable;
+        let snapshot = Snapshot {
+            slide: 0,
+            total: 3,
+            ended: false,
+            notes: "Synthetic notes".into(),
+            elapsed: "00:00:00".into(),
+            paused: false,
+            notes_px: 18.0,
+            blank: None,
+            grid: false,
+            zoom_armed: false,
+            current: None,
+            next: None,
+        };
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1000.0, 700.0)).build_ui_state(
+            |ui, (view, snapshot, sent): &mut (View, Snapshot, Vec<Command>)| {
+                sent.extend(view.ui(ui, snapshot));
+            },
+            (View::default(), snapshot, Vec::new()),
+        );
+        h.run_steps(2);
+        h.get_by_label("Next ▶").click();
+        h.run_steps(2);
+        assert_eq!(h.state().2.len(), 1);
+        h.key_press(egui::Key::Space);
+        h.run_steps(2);
+        assert_eq!(h.state().2.len(), 2, "Space must not also activate the focused Next button");
+        assert_eq!(h.state().0.previous_current, None);
+        assert_eq!(h.state().1.slide, 0, "only an audience snapshot changes the displayed position");
+        assert!(matches!(h.state().2.last(), Some(Command::Key { name, .. }) if name == egui::Key::Space.name()));
+    }
+
+    #[test]
+    fn previews_are_bounded_and_bad_dimensions_are_rejected() {
+        let image = egui::ColorImage::filled([1280, 720], egui::Color32::RED);
+        let p = Preview::from_image(&image).unwrap();
+        assert_eq!((p.width, p.height), (640, 360));
+        assert_eq!(p.image().unwrap().pixels[0], egui::Color32::RED);
+        for (width, height, rgba) in [(usize::MAX, 1, vec![]), (0, 1, vec![]), (1, 1, vec![0; 3]), (641, 1, vec![0; 2564])] {
+            assert!(Preview { width, height, rgba }.image().is_none());
+        }
+    }
+}
diff --git a/crates/ui-egui/src/services.rs b/crates/ui-egui/src/services.rs
index 88f03ac2c..fc8eb5d96 100644
--- a/crates/ui-egui/src/services.rs
+++ b/crates/ui-egui/src/services.rs
@@ -36,6 +36,8 @@ pub type Inbox = std::sync::Arc<std::sync::Mutex<Vec<InboxEvent>>>;
 /// Platform services injected by the host (desktop or web).
 #[derive(Default)]
 pub struct Services {
+    /// Browser-owned presenter popup; absent on native hosts.
+    pub presenter: Option<Box<dyn crate::presenter::Host>>,
     /// Open-file dialog for a purpose (`open`, `picture`, `audio`, `video`) → path.
     pub pick_open: Option<PickFn>,
     /// Save dialog with a suggested name → path.
diff --git a/crates/ui-egui/src/show.rs b/crates/ui-egui/src/show.rs
index 1896e3be7..a8521d3d8 100644
--- a/crates/ui-egui/src/show.rs
+++ b/crates/ui-egui/src/show.rs
@@ -63,6 +63,10 @@ pub struct Show {
     /// Preview renders started on another thread.
     #[cfg(test)]
     preview_spawns: usize,
+    remote_preview: Option<crate::presenter::Preview>,
+    remote_next: Option<(usize, crate::presenter::Preview)>,
+    remote_sent: f64,
+    remote_opened: bool,
     /// The next slide's first frame, rendered in the background while this one is shown so
     /// advancing only uploads it (#240).
     prefetch: Option<Prefetch>,
@@ -231,6 +235,10 @@ impl Show {
             next_job: None,
             #[cfg(test)]
             preview_spawns: 0,
+            remote_preview: None,
+            remote_next: None,
+            remote_sent: f64::NEG_INFINITY,
+            remote_opened: false,
             prefetch: None,
             backdrop: None,
             blank: None,
diff --git a/crates/ui-egui/src/show/keys.rs b/crates/ui-egui/src/show/keys.rs
index c7da76e2c..77741866d 100644
--- a/crates/ui-egui/src/show/keys.rs
+++ b/crates/ui-egui/src/show/keys.rs
@@ -12,6 +12,22 @@ pub(super) fn keyboard(ctx: &egui::Context, show: &mut Show, doc: &Presentation,
             .filter_map(|e| if let egui::Event::Key { key, pressed: true, modifiers, .. } = e { Some((*key, *modifiers)) } else { None })
             .collect()
     });
+    let (keep, consumed) = handle_keys(show, doc, now, keys, presenter);
+    for (key, modifiers) in consumed {
+        ctx.input_mut(|i| i.consume_key(modifiers, key));
+        ctx.request_repaint_of(egui::ViewportId::ROOT);
+    }
+    keep
+}
+
+pub(super) fn handle_keys(
+    show: &mut Show,
+    doc: &Presentation,
+    now: f64,
+    keys: Vec<(egui::Key, egui::Modifiers)>,
+    presenter: bool,
+) -> (bool, Vec<(egui::Key, egui::Modifiers)>) {
+    let mut consumed = vec![];
     let mut keep = true;
     let mut actions = vec![];
     for (k, m) in keys {
@@ -31,15 +47,14 @@ pub(super) fn keyboard(ctx: &egui::Context, show: &mut Show, doc: &Presentation,
         }
         // The same key must not also activate a focused presenter button or be handled again
         // by an embedded presenter viewport.
-        ctx.input_mut(|i| i.consume_key(m, k));
-        ctx.request_repaint_of(egui::ViewportId::ROOT);
+        consumed.push((k, m));
     }
     for action in actions {
         if !show.apply(action, doc, now) {
             keep = false;
         }
     }
-    keep
+    (keep, consumed)
 }
 
 /// Whether the grid that the presenter key G opens is showing in this viewport.
diff --git a/crates/ui-egui/src/show/tests.rs b/crates/ui-egui/src/show/tests.rs
index a1069a5bb..23909fe41 100644
--- a/crates/ui-egui/src/show/tests.rs
+++ b/crates/ui-egui/src/show/tests.rs
@@ -1123,6 +1123,66 @@ fn input_state_tracks_the_modes_that_move_show_click_targets() {
     assert_ne!(show.input_state(), base, "a blank screen has no slide click targets");
 }
 
+#[test]
+fn remote_presenter_uses_the_audience_state_and_closes_with_the_show() {
+    use crate::presenter::{Command, Host, Snapshot};
+    use std::{cell::RefCell, rc::Rc};
+    #[derive(Default)]
+    struct Bridge {
+        opens: usize,
+        closes: usize,
+        commands: Vec<Command>,
+    }
+    struct Mock(Rc<RefCell<Bridge>>);
+    impl Host for Mock {
+        fn open(&mut self) -> Result<(), String> {
+            self.0.borrow_mut().opens += 1;
+            Ok(())
+        }
+        fn is_open(&self) -> bool {
+            true
+        }
+        fn commands(&mut self) -> Vec<Command> {
+            std::mem::take(&mut self.0.borrow_mut().commands)
+        }
+        fn update(&mut self, _: Snapshot) {}
+        fn close(&mut self) {
+            self.0.borrow_mut().closes += 1;
+        }
+    }
+    let bridge = Rc::new(RefCell::new(Bridge::default()));
+    let mut session = deckcraft_engine::Session::with_new();
+    session.execute("slide.new", &json!({})).unwrap();
+    session.execute("slide.new", &json!({})).unwrap();
+    let services = crate::Services { presenter: Some(Box::new(Mock(bridge.clone()))), ..Default::default() };
+    let mut app = SlideApp::new(session, services);
+    app.ui.presenter_view = true;
+    let mut h = egui_kittest::Harness::builder().with_size(vec2(1000.0, 700.0)).build_ui_state(
+        |ui, app: &mut SlideApp| {
+            app.logic(ui.ctx());
+            app.ui(ui);
+        },
+        app,
+    );
+    h.run_steps(3);
+    h.state_mut().start_show(0, false);
+    h.run_steps(2);
+    assert_eq!(bridge.borrow().opens, 1);
+    for (key, slide) in [(egui::Key::ArrowRight, 1), (egui::Key::ArrowLeft, 0), (egui::Key::End, 2), (egui::Key::Home, 0)] {
+        bridge.borrow_mut().commands.push(Command::Key { name: key.name().into(), command: false, shift: false, alt: false, ctrl: false });
+        h.run_steps(2);
+        assert_eq!(h.state().show.as_ref().unwrap().state.slide, slide);
+    }
+    bridge.borrow_mut().commands.push(Command::End);
+    h.run_steps(2);
+    assert!(h.state().show.is_none());
+    assert_eq!(bridge.borrow().closes, 1);
+    h.state_mut().start_show(1, false);
+    h.run_steps(2);
+    assert_eq!(bridge.borrow().opens, 2);
+    assert_eq!(h.state().show.as_ref().unwrap().state.slide, 1);
+}
+
 /// #964: the next-slide preview renders on another thread; the presenter frame that asks for
 /// it doesn't wait, and the preview arrives on a later frame.
 #[test]
diff --git a/crates/ui-egui/src/show/ui.rs b/crates/ui-egui/src/show/ui.rs
index 71107f94f..a0a1fe29a 100644
--- a/crates/ui-egui/src/show/ui.rs
+++ b/crates/ui-egui/src/show/ui.rs
@@ -1,8 +1,8 @@
-use super::keys::keyboard;
+use super::keys::{handle_keys, keyboard};
 use super::media::{
     Pick, Under, gif_hit, media_bar_target, media_hit, on_screen, pointer_on_media_bar, run_media_cues, shapes_under_pointer, show_media,
 };
-use super::presenter::{PresenterTimer, presenter_window};
+use super::presenter::{PresenterTimer, format_elapsed, presenter_window};
 use super::render::{below_playing_video, fit, part_textures, quad_mesh, render_frame, render_overlay, render_threads, start_prefetch};
 use super::zoom::{
     Zoom, grid_indices, norm_on_slide, paint_grid, see_all_hit, slide_aspect, slide_box, slide_to_screen, toggle_blank, tool_bar_rect, unit_uv,
@@ -58,6 +58,9 @@ pub fn ui(app: &mut SlideApp, ui: &mut Ui) {
     let ctx = ui.ctx().clone();
     let Some((doc_uid, doc)) = app.session.active().map(|d| (d.uid, d.doc.clone())) else {
         app.show = None;
+        if let Some(host) = app.services.presenter.as_mut() {
+            host.close();
+        }
         return;
     };
     let now = ctx.input(|i| i.time);
@@ -71,8 +74,35 @@ pub fn ui(app: &mut SlideApp, ui: &mut Ui) {
         return;
     }
     show.observe_visible_frame(now, web_time::Instant::now());
-    begin_show(&ctx, &mut show, &doc, now);
+    begin_show(&ctx, &mut show, &doc, now, app.services.presenter.is_some());
     let mut out = Out { keep: keyboard(&ctx, &mut show, &doc, now, false), actions: vec![] };
+    if show.presenter
+        && !show.reading
+        && let Some(host) = app.services.presenter.as_mut()
+    {
+        if !show.remote_opened {
+            show.remote_opened = true;
+            if let Err(message) = host.open() {
+                app.status = Some((message, crate::now_ms()));
+            }
+        }
+        for command in host.commands() {
+            match command {
+                crate::presenter::Command::End => out.keep = false,
+                crate::presenter::Command::Zoom { x, y } if x.is_finite() && y.is_finite() && show.zoom_arm => {
+                    show.zoom = Some(Zoom::at(x.clamp(0.0, 1.0), y.clamp(0.0, 1.0)));
+                    show.zoom_arm = false;
+                }
+                crate::presenter::Command::Key { name, command, shift, alt, ctrl } => {
+                    if let Some(key) = egui::Key::ALL.iter().copied().find(|key| key.name() == name) {
+                        let modifiers = egui::Modifiers { command, shift, alt, ctrl, mac_cmd: command && !ctrl };
+                        out.keep &= handle_keys(&mut show, &doc, now, vec![(key, modifiers)], false).0;
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
     let (clicked, secondary, moved) = ctx.input(|i| (i.pointer.primary_clicked(), i.pointer.secondary_clicked(), i.pointer.delta().length() > 0.0));
     if moved {
         show.last_move = now;
@@ -94,6 +124,43 @@ pub fn ui(app: &mut SlideApp, ui: &mut Ui) {
     draw_pen_and_hints(ui, &mut show, &f, &painter, pointing);
     draw_bars(ui, &mut show, &f, &painter, &mut out);
     draw_extras(&mut show, &f, &painter, &mut out);
+    if out.keep
+        && show.presenter
+        && !show.reading
+        && let Some(host) = app.services.presenter.as_mut()
+    {
+        if now - show.remote_sent >= 0.2 {
+            let next = show.state.peek_next(&doc);
+            if let Some(n) = next
+                && show.remote_next.as_ref().is_none_or(|(old, _)| *old != n)
+            {
+                let size =
+                    crate::textures::fit_size((480, (480.0 * doc.slide_size.height / doc.slide_size.width.max(1.0)).clamp(1.0, 1e9) as u32), 640);
+                let image = deckcraft_render::render_slide(
+                    &doc,
+                    n,
+                    &RenderOpts { scale: size.0 as f64 / doc.slide_size.width.max(1.0), size: Some(size), ..Default::default() },
+                );
+                show.remote_next = crate::presenter::Preview::from_image(&crate::textures::to_color_image(&image, false)).map(|image| (n, image));
+            }
+            host.update(crate::presenter::Snapshot {
+                slide: show.state.slide,
+                total: doc.slides.len(),
+                ended: show.ended,
+                notes: doc.slides.get(show.state.slide).map(|s| s.notes_text()).unwrap_or_default(),
+                elapsed: format_elapsed(show.timer.elapsed(now)),
+                paused: show.timer.paused(),
+                notes_px: show.notes_px,
+                blank: show.blank_name().map(str::to_owned),
+                grid: show.grid,
+                zoom_armed: show.zoom_arm,
+                current: show.remote_preview.clone(),
+                next: show.remote_next.as_ref().filter(|(n, _)| Some(*n) == next).map(|(_, image)| image.clone()),
+            });
+            show.remote_sent = now;
+        }
+        ctx.request_repaint_after(std::time::Duration::from_millis(200));
+    }
     finish(app, show, &f, out.keep);
 }
 
@@ -110,7 +177,7 @@ fn paint_hidden(ui: &Ui, doc: &Presentation, show: &Show) {
     }
 }
 
-fn begin_show(ctx: &egui::Context, show: &mut Show, doc: &Presentation, now: f64) {
+fn begin_show(ctx: &egui::Context, show: &mut Show, doc: &Presentation, now: f64, remote: bool) {
     if !show.started {
         show.started = true;
         show.slide_start = now;
@@ -121,7 +188,7 @@ fn begin_show(ctx: &egui::Context, show: &mut Show, doc: &Presentation, now: f64
         show.show_start = now;
         show.timer = PresenterTimer::start(now);
         show.last_move = now;
-        if show_fills_screen(show.reading, &doc.show.show_type) {
+        if show_fills_screen(show.reading, &doc.show.show_type) && !(show.presenter && remote) {
             ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(true));
         }
         show.after_enter(doc, now);
@@ -303,6 +370,9 @@ fn frame_texture(show: &mut Show, f: &Fr, sl: &Sl) -> Option<TextureHandle> {
                 render_frame(doc, idx, tl, step, sl.t, size, sl.hidden.clone(), &sl.times, render_threads(), &sl.plays, &sl.stamps, back.as_deref())
             }
         };
+        if show.remote_opened && show.presenter {
+            show.remote_preview = crate::presenter::Preview::from_image(&ci);
+        }
         let tex = match show.tex.take() {
             Some((_, mut h)) => {
                 crate::textures::replace(ctx, &mut h, ci);
@@ -730,7 +800,7 @@ fn draw_extras(show: &mut Show, f: &Fr, painter: &egui::Painter, out: &mut Out)
         ctx.request_repaint_after(std::time::Duration::from_millis(100));
     }
     // Presenter view in a second window.
-    if out.keep && show.presenter && !show.reading {
+    if out.keep && show.presenter && !show.reading && !show.remote_opened {
         presenter_window(ctx, show, doc, now, &mut out.keep);
     }
 }
@@ -740,6 +810,9 @@ fn finish(app: &mut SlideApp, mut show: Show, f: &Fr, keep: bool) {
     if keep {
         app.show = Some(show);
     } else {
+        if let Some(host) = app.services.presenter.as_mut() {
+            host.close();
+        }
         app.media.stop_owned(crate::media::Owner::Show);
         if !show.reading {
             ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(false));
diff --git a/docs/wasm-presenter-popout-729.md b/docs/wasm-presenter-popout-729.md
new file mode 100644
index 000000000..0ee3f4979
--- /dev/null
+++ b/docs/wasm-presenter-popout-729.md
@@ -0,0 +1,65 @@
+# WASM presenter-view popout (#729)
+
+Tracks https://github.com/storytold/deckcraft/issues/729 (the reporter moved duplicate #726 here).
+
+## Implementation
+
+The browser presenter opens the same DeckCraft web build in a separate, same-origin window.
+That window starts its own eframe runner and renders only presenter controls, current/next
+previews and notes. The audience window remains the sole owner of slideshow state, animations,
+media and navigation. Presenter keyboard input uses the same navigation handler as the native
+presenter, so an input is applied once rather than advancing two independent shows.
+
+Messages check the exact origin, source window and a per-opening session identifier. Input
+queues and preview dimensions are bounded. Previews use the audience's rendered current frame;
+unchanged preview pixels are not retransmitted. Presenter updates are limited to five per second.
+
+If the browser blocks the initial popup, an explicit Open presenter window button calls the
+browser API directly from its click handler. Browser policy can still require the user to allow
+popups, or choose to open a tab instead of a window. Closing the presenter leaves the audience
+running and offers the same button to reopen it. Ending the show closes the presenter. The
+presenter reports a closed or unresponsive audience rather than continuing an independent show.
+Native presenter view continues to use its existing egui viewport.
+
+No native second-display placement, Linux display-counting policy, laser/rehearsal changes or
+other contributors' unmerged presenter work is included.
+
+## Validation
+
+Candidate implementation; not yet qualified for release. The current-main reconciliation and
+transport/font corrections have had source inspection and static diff checks only. No local Rust
+builds, tests or formatter were run for this candidate; hosted compilation and regression tests
+remain pending. Earlier-head validation recorded in the PR does not qualify this changed tree.
+The original bug was reproduced on the deployed 0.7.0 browser build on 2026-10-14; that
+deployment's exact commit is unknown.
+
+Regression coverage submitted for hosted execution checks successful image deduplication,
+failed-send retries, session/reload refresh and clearing previews. The independent popup uses
+the existing interface font definitions and UiFonts fallback discovery before laying out notes,
+discarding font-install passes before input forwarding. Its font regression checks bundled
+Arabic/Japanese/Hangul glyphs when those optional font inputs are present; missing optional
+inputs do not establish script coverage.
+
+Source inspection verifies these lifecycle paths: a blocked popup offers an explicit retry
+whose click handler calls the browser API; closing the popup offers reopening; ending the show
+closes the popup; incoming messages check origin, source window and opening-session token.
+This establishes the intended control flow, not empirical compatibility with each browser.
+
+Runtime checks that would add empirical coverage with a synthetic deck:
+
+- Popup allowed and blocked, explicit retry, and independent window positioning.
+- Initial popup behavior in Safari and Firefox, including whether explicit retry is needed on
+  each show start. These browser families have not been exercised for this candidate; missing
+  manual coverage alone is not evidence of a defect or a mandatory merge blocker.
+- Next/Previous, Home/End, numeric navigation, and no double advance on Space/Enter.
+- Current/next previews, notes, pause/reset, black/white screens, All Slides and zoom.
+- Navigation from both windows, including animation steps and the end screen.
+- Close/reopen the presenter, reload it, end/restart the show, and close/reload the audience.
+- Rejection of messages from the wrong origin, source window or prior session.
+- Native presenter regressions, WASM compilation and the full repository quality gates.
+
+All runtime items above, including actual browser popup/reload/end-show execution, remain
+unexecuted for this candidate. Shared native tests and source inspection do not constitute
+browser-executed validation. Font subsets can legitimately omit individual script families;
+the regression always checks installation/layout/discard handling, and checks a script's glyphs
+only when its corresponding bundled face is present.

From cc00a17dfe04194d9952d41b5e052efc634c1cda Mon Sep 17 00:00:00 2001
From: Simon Koch-Sultan <126534658+scks1@users.noreply.github.com>
Date: Sun, 1 Nov 2026 15:52:54 -0500
Subject: [PATCH 84/88] #1596: let effect-hole QA images overwrite an earlier
 run's

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/render/src/tests_effect_holes.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/crates/render/src/tests_effect_holes.rs b/crates/render/src/tests_effect_holes.rs
index 10749229d..fdddf60fd 100644
--- a/crates/render/src/tests_effect_holes.rs
+++ b/crates/render/src/tests_effect_holes.rs
@@ -64,11 +64,9 @@ fn draw(shape: &str, effect: Effect) -> Image {
     let p = scene(shape, effect);
     let image = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
     if let Ok(dir) = std::env::var("DECKCRAFT_EFFECT_HOLES_QA") {
-        use std::io::Write as _;
+        // Overwrite, so a QA directory can be reused across runs.
         std::fs::create_dir_all(&dir).unwrap();
-        let path = std::path::Path::new(&dir).join(format!("{shape}-{effect:?}.png"));
-        let mut file = std::fs::OpenOptions::new().write(true).create_new(true).open(path).unwrap();
-        file.write_all(&image.to_png()).unwrap();
+        std::fs::write(std::path::Path::new(&dir).join(format!("{shape}-{effect:?}.png")), image.to_png()).unwrap();
     }
     image
 }

From b0b87c5cad6d258eb7c085dc1df7a5a51c4c5e97 Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Mon, 2 Nov 2026 05:37:53 +0100
Subject: [PATCH 85/88] Fix Unit::format printing "-0.00" for tiny negative
 lengths

Found while testing crates/geom/src/lib.rs:72-76

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/geom/src/lib.rs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rs
index 3be72e03f..9ef790f3d 100644
--- a/crates/geom/src/lib.rs
+++ b/crates/geom/src/lib.rs
@@ -71,7 +71,10 @@ impl Unit {
     /// `2.08"` style text for a length in points.
     pub fn format(self, pt: f64) -> String {
         let v = pt / self.points_per_unit();
-        let s = format!("{v:.2}");
+        let mut s = format!("{v:.2}");
+        if s.starts_with('-') && s[1..].bytes().all(|b| b == b'0' || b == b'.') {
+            s.remove(0);
+        }
         format!("{s}{}", self.suffix())
     }
     /// Parses `2.5`, `2.5"`, `2.5 in`, `6 cm`, `30 pt`, `40px`, `5mm` into points. A bare number uses `self`.
@@ -222,6 +225,14 @@ pub fn preset_flatten(path: &BezPath, f: &mut dyn FnMut(PathEl)) {
 mod tests {
     use super::*;
 
+    #[test]
+    fn format_has_no_negative_zero() {
+        assert_eq!(Unit::Points.format(-0.001), "0.00 pt");
+        assert_eq!(Unit::Inches.format(-0.001), "0.00\"");
+        assert!(!Unit::Centimeters.format(-0.01).starts_with('-'));
+        assert_eq!(Unit::Points.format(-1.5), "-1.50 pt");
+    }
+
     #[test]
     fn emu_roundtrip_is_exact() {
         for emu in [0i64, 1, 12_699, 12_700, 914_400, 12_192_000, 6_858_000, -5, 123_456_789] {

From 01220df57928a6148d4779eeea9b2fbbdb737c54 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <brandon@storyteller.ai>
Date: Mon, 2 Nov 2026 04:51:01 -0500
Subject: [PATCH 86/88] design.background: check the index before a picture is
 added to the media

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/cmd/design/slide_background.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/engine/src/cmd/design/slide_background.rs b/crates/engine/src/cmd/design/slide_background.rs
index 92f3ce773..494b53be8 100644
--- a/crates/engine/src/cmd/design/slide_background.rs
+++ b/crates/engine/src/cmd/design/slide_background.rs
@@ -7,6 +7,8 @@ pub(super) fn background(s: &mut Session, p: &Value) -> Result<Value> {
     if bool_or(p, "copy", false) {
         return copy_slide_background(s);
     }
+    // Check the index before anything is edited: a picture is added to the media first.
+    let index = opt_usize_param(p, "index", "design.background")?;
     let props = p.get("pictureProps").filter(|v| v.is_object()).cloned();
     let transparency = f64_param(p, "transparency");
     let reset = bool_or(p, "reset", false);
@@ -62,7 +64,6 @@ pub(super) fn background(s: &mut Session, p: &Value) -> Result<Value> {
         ));
     };
     let all = bool_or(p, "all", false);
-    let index = opt_usize_param(p, "index", "design.background")?;
     if matches!(op, BgOp::Adjust) {
         let next = {
             let st = s.doc()?;

From 5eb0b7d2c0492b2e648140a3ff8ec7f792e55e92 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <brandon@storyteller.ai>
Date: Mon, 2 Nov 2026 04:51:13 -0500
Subject: [PATCH 87/88] docs: one revision row per doc for #1621, keep the Last
 reviewed dates

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 ROADMAP.md               | 4 +---
 docs/gaps.md             | 3 +--
 docs/parity-checklist.md | 1 -
 docs/ui-parity.md        | 3 +--
 4 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index f5e084d3c..ecf27f318 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~20 points and ~120–210 h away
 
-> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-01 · **Change:** trivial (locked No Fill and no-outline click-through regression coverage added; No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-11-01 · **Change:** trivial (locked No Fill and no-outline click-through regression coverage added; No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-30 · **Change:** trivial (progress log: read-only `slide.actions` lists shape and table text actions; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-27 · **Change:** trivial (progress log: Set Up Slide Show ▸ Keep mouse cursor visible, #1445; stage and scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-26 · **Change:** trivial (progress log: dragging several selected slides moves them all; previous: trivial, progress log: Edit Points handle drags with Shift, Ctrl/Cmd or Alt/Option set the point type; previous: trivial, progress log: scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
@@ -148,7 +148,6 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | What landed |
 |---|---|
-| 2026-11-01 | No Fill regression coverage now includes locked shapes (outline selectable, position unchanged by dragging) and empty shapes without an outline, locked or unlocked (#1621). Existing text, outline and interior-hit tests retained |
 | 2026-10-31 | No Fill shape interiors allow selection and editing of underlying objects, even when a quick style remains; hit-testing uses the renderer’s fill resolution. Outlines, rotation, text targets and actual fills keep their hit behaviour (#1621) |
 | 2026-10-30 | Print-preview tests use the URL emitted by egui and its exact file path; previews are explicitly removed before the macOS process exits |
 | 2026-10-30 | `slide.actions` lists shape click and hover actions and text-run hyperlinks (including table cells and grouped shapes) for audit; listing never runs an action. The UI pane is a follow-up |
@@ -320,7 +319,6 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-11-01 | trivial | No Fill tests cover locked outline selection without movement and click-through without an outline; fill row and parity scores unchanged (#1621) |
 | 2026-10-31 | trivial | No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged |
 | 2026-10-30 | trivial | Progress log: read-only slide action inspection; parity scores unchanged |
 | 2026-10-29 | trivial | Progress log: going back in the slide show reverses the left slide's transition (#1531). Scores and milestone names unchanged |
diff --git a/docs/gaps.md b/docs/gaps.md
index 77764f1cf..1fefa5d9d 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Where DeckCraft falls short of PowerPoint
 
-> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-01 · **Change:** trivial (locked No Fill and no-outline click-through regression coverage added; No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-30 · **Last updated:** 2026-11-01 · **Change:** trivial (locked No Fill and no-outline click-through regression coverage added; No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 
 Every known shortfall, one entry each, ranked by how much it stops someone who presents with
 PowerPoint from switching. This is the work list: pick from the top. Numbers are summarized in
@@ -368,7 +368,6 @@ Detail in [localization-parity.md](localization-parity.md).
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-11-01 | trivial | No Fill tests cover locked outline selection without movement and click-through without an outline; fill row and parity scores unchanged (#1621) |
 | 2026-10-31 | trivial | No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged |
 | 2026-10-30 | minor | Slide-show click targets use each shape’s own animation state; scale and rotation test added |
 | 2026-10-28 | trivial | Automatic lists now run independently of Replace text as you type; proofing gap description updated |
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index f776f4aac..606f1228d 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -240,5 +240,4 @@ Open P0 items: Contextual tabs (Shape Format, Picture Format, Table Design/Layou
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-11-01 | trivial | No Fill tests cover locked outline selection without movement and click-through without an outline; fill row and parity scores unchanged (#1621) |
 | 2026-10-31 | trivial | No Fill interior hit-testing follows resolved fill (#1621); fill row remains D and summary scores are unchanged |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index fd34a7928..0d4d5a649 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI parity with PowerPoint
 
-> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-01 · **Change:** trivial (locked No Fill and no-outline click-through regression coverage added; No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-11-01 · **Change:** trivial (locked No Fill and no-outline click-through regression coverage added; No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-26 · **Change:** trivial (dragging several selected slides moves them all; previous: trivial, Edit Points: Shift, Ctrl/Cmd or Alt/Option on a handle drag sets the point type; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: major, community PR wave 2026-10-14: 14 new dialogs (41 in all), Eyedropper, Export button, New Window, Grid Options, WordArt gallery and handles, Slide Sorter sections, Quick Access Toolbar, Format Background and Format Shape depth, rich-text clipboard; duplicated rows and headers folded; previous: minor, File tab / Backstage, #76) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-22 · **Change:** trivial (group fill and outline edits reach members, #1079; scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 > **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-24 · **Change:** trivial (Edit Points: Shift, Ctrl/Cmd or Alt/Option on a handle drag sets the point type; previous: trivial, scroll bars on the zoomed slide pane, #1157; previous: major, community PR wave 2026-10-14: 14 new dialogs (41 in all), Eyedropper, Export button, New Window, Grid Options, WordArt gallery and handles, Slide Sorter sections, Quick Access Toolbar, Format Background and Format Shape depth, rich-text clipboard; duplicated rows and headers folded; previous: minor, File tab / Backstage, #76) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
@@ -171,7 +171,6 @@ consistency is open (#73, #56).
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-11-01 | trivial | No Fill tests cover locked outline selection without movement and click-through without an outline; fill row and parity scores unchanged (#1621) |
 | 2026-10-31 | trivial | No Fill hit-testing follows resolved fill instead of the presence of a style (#1621); scores unchanged |
 | 2026-10-29 | trivial | Picture Format: the Picture Styles row shows as many styles as fit beside the groups after it (at least two) and a More arrow with all 24, as the Transitions and Animations galleries do; Crop and Size are in view in the default window (#1232) |
 | 2026-10-26 | trivial | Thumbnail pane and Slide Sorter: dragging one of several selected slides moves the whole selection |

From ffd77c7db00fb080f02b92663b6ef006e9f706ae Mon Sep 17 00:00:00 2001
From: Brandon Thomas <brandon@storyteller.ai>
Date: Mon, 2 Nov 2026 04:53:47 -0500
Subject: [PATCH 88/88] Spell check: a mark on trailing punctuation is trimmed
 with it

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/engine/src/spell.rs | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/crates/engine/src/spell.rs b/crates/engine/src/spell.rs
index 8927ade5b..2dda5c6f4 100644
--- a/crates/engine/src/spell.rs
+++ b/crates/engine/src/spell.rs
@@ -726,8 +726,14 @@ pub fn paragraph_words(p: &deckcraft_model::Paragraph, default: &str) -> Vec<Wor
         while a < b && !chars[a].0.is_alphanumeric() {
             a += 1;
         }
-        while b > a && !chars[b - 1].0.is_alphanumeric() && !deckcraft_model::words::is_combining_mark(chars[b - 1].0) {
-            b -= 1;
+        // Trim back to the last letter or digit, keeping only the marks that sit on it
+        // (a mark on a trailing apostrophe goes with the apostrophe).
+        while b > a {
+            let k = (a..b).rev().find(|&k| !deckcraft_model::words::is_combining_mark(chars[k].0)).unwrap_or(a);
+            if chars[k].0.is_alphanumeric() {
+                break;
+            }
+            b = k;
         }
         let text: String = chars[a..b].iter().map(|c| c.0).collect();
         if text.is_empty() || text.chars().any(|c| c.is_ascii_digit()) || !text.chars().any(char::is_alphabetic) {
@@ -827,6 +833,13 @@ SFX D Y 1\nSFX D 0 ed/S .\n";
         assert_eq!(w, ["Das", "na\u{ef}ve", "Caf\u{e9}", "und", "cafe\u{301}", "na\u{308}ive"]);
     }
 
+    #[test]
+    fn a_mark_on_trailing_punctuation_is_trimmed_with_it() {
+        let p = deckcraft_model::Paragraph::new("word'\u{301} cafe\u{301}' x");
+        let w: Vec<String> = paragraph_words(&p, "en-US").into_iter().map(|w| w.text).collect();
+        assert_eq!(w, ["word", "cafe\u{301}", "x"]);
+    }
+
     #[test]
     fn curly_apostrophe_matches_ascii_entry() {
         let d = Dictionary::parse(AFF.as_bytes(), "2\ndon't\nwork\n".as_bytes());