fix: bold/italic cause postcard unable reopen

koharu-app/src/session.rs

@@ -229,7 +229,9 @@ struct ProjectTomlFile {
 mod tests {
     use super::*;
     use camino::Utf8PathBuf;
-    use koharu_core::{Op, Page, PageId};
+    use koharu_core::{
+        Node, NodeId, NodeKind, Op, Page, PageId, TextData, TextShaderEffect, TextStyle, Transform,
+    };
     use tempfile::tempdir;
 
     fn tmp_dir() -> (tempfile::TempDir, Utf8PathBuf) {
@@ -257,6 +259,70 @@ mod tests {
         assert!(session.scene.read().pages.contains_key(&page_id));
     }
 
+    #[test]
+    fn reopen_preserves_text_style_effects_in_scene_bin() {
+        let (_tmp, path) = tmp_dir();
+        let page_id: PageId;
+        let node_id: NodeId;
+        {
+            let session = ProjectSession::create(&path, "styled").unwrap();
+            let page = Page::new("p1", 800, 600);
+            page_id = page.id;
+            session
+                .apply(Op::AddPage { page, at: 0 })
+                .expect("apply AddPage");
+
+            node_id = NodeId::new();
+            let mut scene = session.scene.write();
+            let page = scene.pages.get_mut(&page_id).expect("page");
+            page.nodes.insert(
+                node_id,
+                Node {
+                    id: node_id,
+                    transform: Transform {
+                        x: 0.0,
+                        y: 0.0,
+                        width: 100.0,
+                        height: 40.0,
+                        rotation_deg: 0.0,
+                    },
+                    visible: true,
+                    kind: NodeKind::Text(TextData {
+                        style: Some(TextStyle {
+                            font_families: vec!["Arial".to_string()],
+                            font_size: Some(20.0),
+                            color: [0, 0, 0, 255],
+                            effect: Some(TextShaderEffect {
+                                italic: true,
+                                bold: true,
+                            }),
+                            stroke: None,
+                            text_align: None,
+                        }),
+                        ..Default::default()
+                    }),
+                },
+            );
+            drop(scene);
+            session.compact().unwrap();
+        }
+
+        let session = ProjectSession::open(&path).unwrap();
+        let scene = session.scene.read();
+        let page = scene.pages.get(&page_id).expect("page");
+        let node = page.nodes.get(&node_id).expect("node");
+        let NodeKind::Text(text) = &node.kind else {
+            panic!("expected text node");
+        };
+        let effect = text
+            .style
+            .as_ref()
+            .and_then(|style| style.effect)
+            .expect("effect");
+        assert!(effect.italic);
+        assert!(effect.bold);
+    }
+
     #[test]
     fn exclusive_lock_prevents_second_open() {
         let (_tmp, path) = tmp_dir();

koharu-core/src/style.rs

@@ -151,6 +151,13 @@ impl<'de> Deserialize<'de> for TextShaderEffect {
             bold: Option<bool>,
         }
 
+        #[derive(Deserialize)]
+        #[serde(deny_unknown_fields)]
+        struct BinaryFlagsRepr {
+            italic: bool,
+            bold: bool,
+        }
+
         #[derive(Deserialize)]
         #[serde(untagged)]
         enum Repr {
@@ -158,13 +165,18 @@ impl<'de> Deserialize<'de> for TextShaderEffect {
             Legacy(String),
         }
 
-        match Repr::deserialize(deserializer)? {
-            Repr::Flags(FlagsRepr { italic, bold }) => Ok(Self {
-                italic: italic.unwrap_or(false),
-                bold: bold.unwrap_or(false),
-            }),
-            Repr::Legacy(value) => value.parse().map_err(serde::de::Error::custom),
+        if deserializer.is_human_readable() {
+            return match Repr::deserialize(deserializer)? {
+                Repr::Flags(FlagsRepr { italic, bold }) => Ok(Self {
+                    italic: italic.unwrap_or(false),
+                    bold: bold.unwrap_or(false),
+                }),
+                Repr::Legacy(value) => value.parse().map_err(serde::de::Error::custom),
+            };
         }
+
+        let BinaryFlagsRepr { italic, bold } = BinaryFlagsRepr::deserialize(deserializer)?;
+        Ok(Self { italic, bold })
     }
 }
 
@@ -219,7 +231,7 @@ pub struct TextStyle {
 
 #[cfg(test)]
 mod tests {
-    use super::TextShaderEffect;
+    use super::{TextShaderEffect, TextStyle};
 
     #[test]
     fn parse_combined_effects() {
@@ -240,4 +252,43 @@ mod tests {
         let effect: TextShaderEffect = "none".parse().expect("parse");
         assert_eq!(effect.to_string(), "none");
     }
+
+    #[test]
+    fn json_legacy_string_deserializes() {
+        let effect: TextShaderEffect = serde_json::from_str("\"italic,bold\"").expect("json");
+        assert!(effect.italic);
+        assert!(effect.bold);
+    }
+
+    #[test]
+    fn postcard_text_shader_effect_round_trips() {
+        let effect = TextShaderEffect {
+            italic: true,
+            bold: true,
+        };
+        let bytes = postcard::to_allocvec(&effect).expect("serialize");
+        let decoded: TextShaderEffect = postcard::from_bytes(&bytes).expect("deserialize");
+        assert!(decoded.italic);
+        assert!(decoded.bold);
+    }
+
+    #[test]
+    fn postcard_text_style_with_effect_round_trips() {
+        let style = TextStyle {
+            font_families: vec!["Arial".to_string()],
+            font_size: Some(18.0),
+            color: [12, 34, 56, 255],
+            effect: Some(TextShaderEffect {
+                italic: true,
+                bold: false,
+            }),
+            stroke: None,
+            text_align: None,
+        };
+        let bytes = postcard::to_allocvec(&style).expect("serialize");
+        let decoded: TextStyle = postcard::from_bytes(&bytes).expect("deserialize");
+        let effect = decoded.effect.expect("effect");
+        assert!(effect.italic);
+        assert!(!effect.bold);
+    }
 }