feat(update): show release notes + version-card layout in update notice

The update notice dialog now mirrors what GitHub publishes: side-by-side
Installed → Latest version cards (the new one accent-tinted to draw the
eye) and a scrollable release-notes panel under them. Light markdown
rendering covers `##` headings, bullet lists, and inline bold/code
markers — enough for the GitHub release body format we ship.

- update_check::check_for_update() returns UpdateInfo { version, body };
  body is parsed from the releases API JSON with a tiny custom
  string-field extractor (\n / \" / \u handling) so we keep the
  serde_json-free dependency footprint.
- Window grows from 480x240 to 560x460 and becomes resizable to make
  room for the notes scroller.
- Layout tightens: header bottom padding drops 14 → 6, notes heading
  10, and the notes block is wrapped in a Fill-height container so it
  claims every leftover pixel — no more dead space between heading and
  footer.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/app/mod.rs

@@ -104,6 +104,10 @@ pub(super) struct H7CAD {
     /// Tag of the latest available release (without the leading "v"),
     /// e.g. `"0.3.0"`. `None` when up-to-date or check hasn't returned.
     update_notice_version: Option<String>,
+    /// Release-notes body for the version above (GitHub release "body"
+    /// markdown, as returned by the API). May be empty when the release
+    /// shipped without notes.
+    update_notice_body: Option<String>,
     /// In-memory clipboard: cloned entities waiting to be pasted.
     clipboard: Vec<acadrust::EntityType>,
     /// Centroid of the clipboard entities (XZ plane, Y-up).
@@ -542,7 +546,7 @@ pub enum Message {
     Noop,
     /// GitHub releases API returned a result. `Some(version)` means a
     /// newer release exists; we open the update-notice window.
-    UpdateCheckResult(Option<String>),
+    UpdateCheckResult(Option<crate::update_check::UpdateInfo>),
     /// User dismissed the update-notice window.
     UpdateNoticeClose,
     /// User clicked the "Open release page" button — opens the GitHub
@@ -739,6 +743,7 @@ impl H7CAD {
             about_window: None,
             update_notice_window: None,
             update_notice_version: None,
+            update_notice_body: None,
             clipboard: Vec::new(),
             clipboard_centroid: glam::Vec3::ZERO,
             layout_context_menu: None,

src/app/update.rs

@@ -3688,16 +3688,20 @@ impl H7CAD {
                 }
             }
             Message::UpdateCheckResult(latest) => {
-                let Some(version) = latest else {
+                let Some(info) = latest else {
                     return Task::none();
                 };
-                self.update_notice_version = Some(version);
+                self.update_notice_version = Some(info.version);
+                self.update_notice_body = Some(info.body);
                 if let Some(id) = self.update_notice_window {
                     return window::gain_focus(id);
                 }
                 let (id, task) = window::open(window::Settings {
-                    size: iced::Size::new(480.0, 240.0),
+                    // Sized for the new release-notes panel — wide enough
-                    resizable: false,
+                    // for typical GitHub release headlines, tall enough for
+                    // a meaningful scroll preview without dwarfing the app.
+                    size: iced::Size::new(560.0, 460.0),
+                    resizable: true,
                     ..Default::default()
                 });
                 self.update_notice_window = Some(id);

src/app/view.rs

@@ -195,7 +195,8 @@ impl H7CAD {
                 .update_notice_version
                 .as_deref()
                 .unwrap_or("?");
-            return crate::ui::update_notice::view_window(latest);
+            let body = self.update_notice_body.as_deref().unwrap_or("");
+            return crate::ui::update_notice::view_window(latest, body);
         }
         if Some(window_id) == self.unsaved_dialog_window {
             let tab_name = match &self.pending_close {

src/ui/update_notice.rs

@@ -1,5 +1,5 @@
 use crate::app::Message;
-use iced::widget::{button, column, container, row, text, Space};
+use iced::widget::{button, column, container, row, scrollable, text, Space};
 use iced::{Background, Border, Color, Element, Fill, Theme};
 
 const BG: Color = Color {
@@ -39,18 +39,104 @@ const WHITE: Color = Color {
     a: 1.0,
 };
 
-fn info_row<'a>(label: &'static str, value: String) -> Element<'a, Message> {
+/// Renders one of the two "Installed" / "Latest" cards. The `highlight`
-    row![
+/// flag tints the border + label with the accent colour, making the new
-        text(label).size(11).color(DIM).width(100),
+/// version the visual anchor of the row.
-        text(value).size(11).color(WHITE),
+fn version_card<'a>(label: &'static str, value: String, highlight: bool) -> Element<'a, Message> {
+    let label_color = if highlight { ACCENT } else { DIM };
+    let value_color = WHITE;
+    let border_color = if highlight { ACCENT } else { BORDER };
+    let bg = if highlight {
+        Color { r: 0.10, g: 0.16, b: 0.22, a: 1.0 } // accent-tinted dark
+    } else {
+        PANEL
+    };
+    container(
+        column![
+            text(label).size(10).color(label_color),
+            text(value).size(20).color(value_color),
         ]
-    .spacing(8)
+        .spacing(4)
-    .align_y(iced::Center)
+        .align_x(iced::Center),
-    .padding([3, 0])
+    )
+    .width(Fill)
+    .padding(iced::Padding {
+        top: 14.0,
+        right: 12.0,
+        bottom: 14.0,
+        left: 12.0,
+    })
+    .align_x(iced::Center)
+    .style(move |_: &Theme| container::Style {
+        background: Some(Background::Color(bg)),
+        border: Border {
+            color: border_color,
+            width: 1.0,
+            radius: 6.0.into(),
+        },
+        ..Default::default()
+    })
     .into()
 }
 
-pub fn view_window<'a>(latest: &'a str) -> Element<'a, Message> {
+/// Light-weight renderer for a single line of GitHub-style release-notes
+/// markdown. Recognises:
+///   * `## Heading` → bold accent line
+///   * `### Heading` → smaller bold line
+///   * `- bullet`   → indented bullet text
+///   * `**bold**` runs and `` `code` `` runs (rendered tonally, not styled
+///     differently — iced's text widget has no inline run styling).
+/// Anything else is plain body text. Strips the markdown markers so the
+/// dialog reads cleanly even if the user has a Patreon-formatted note.
+fn render_notes_line<'a>(raw: &str) -> Element<'a, Message> {
+    let trimmed = raw.trim_end();
+    if trimmed.is_empty() {
+        return Space::new()
+            .height(iced::Length::Fixed(6.0))
+            .into();
+    }
+    if let Some(rest) = trimmed.strip_prefix("## ") {
+        return text(strip_inline_md(rest))
+            .size(13)
+            .color(ACCENT)
+            .into();
+    }
+    if let Some(rest) = trimmed.strip_prefix("### ") {
+        return text(strip_inline_md(rest))
+            .size(12)
+            .color(WHITE)
+            .into();
+    }
+    if let Some(rest) = trimmed.strip_prefix("- ").or_else(|| trimmed.strip_prefix("* ")) {
+        return row![
+            text("•").size(11).color(DIM).width(14),
+            text(strip_inline_md(rest)).size(11).color(WHITE),
+        ]
+        .spacing(4)
+        .into();
+    }
+    text(strip_inline_md(trimmed)).size(11).color(WHITE).into()
+}
+
+/// Drop `**…**` and `` `…` `` markers without preserving emphasis (iced 0.14
+/// Text widgets style the whole string uniformly). Keeps the inner text.
+fn strip_inline_md(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    let mut chars = s.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '*' && chars.peek() == Some(&'*') {
+            chars.next();
+            continue;
+        }
+        if c == '`' {
+            continue;
+        }
+        out.push(c);
+    }
+    out
+}
+
+pub fn view_window<'a>(latest: &'a str, body: &'a str) -> Element<'a, Message> {
     let header = container(
         column![
             text("New Release Available").size(20).color(ACCENT),
@@ -63,31 +149,31 @@ pub fn view_window<'a>(latest: &'a str) -> Element<'a, Message> {
     )
     .width(Fill)
     .padding(iced::Padding {
-        top: 16.0,
+        top: 14.0,
         right: 0.0,
-        bottom: 14.0,
+        bottom: 6.0,
         left: 0.0,
     })
     .align_x(iced::Center);
 
-    let info_block = container(
+    // Two side-by-side version cards (Installed → Latest) with the latest
-        column![
+    // one accent-tinted to draw the eye. Replaces the previous label/value
-            info_row("Installed", format!("v{}", env!("CARGO_PKG_VERSION"))),
+    // row layout. The arrow between them is purely decorative.
-            info_row("Latest", format!("v{}", latest)),
+    let installed = version_card(
-        ]
+        "Installed",
-        .spacing(2)
+        format!("v{}", env!("CARGO_PKG_VERSION")),
-        .padding([12, 16]),
+        false,
-    )
+    );
-    .width(Fill)
+    let latest_card = version_card("Latest", format!("v{}", latest), true);
-    .style(|_: &Theme| container::Style {
+    let arrow = container(text("→").size(22).color(DIM))
-        background: Some(Background::Color(PANEL)),
+        .width(iced::Length::Fixed(32.0))
-        border: Border {
+        .height(Fill)
-            color: BORDER,
+        .align_x(iced::Center)
-            width: 1.0,
+        .align_y(iced::Center);
-            radius: 4.0.into(),
+    let info_block = row![installed, arrow, latest_card]
-        },
+        .spacing(0)
-        ..Default::default()
+        .align_y(iced::Center)
-    });
+        .width(Fill);
 
     let later_btn = button(text("Later").size(11))
         .on_press(Message::UpdateNoticeClose)
@@ -147,9 +233,56 @@ pub fn view_window<'a>(latest: &'a str) -> Element<'a, Message> {
             left: 0.0,
         });
 
+    // Release notes panel. Rendered as a light-markdown column inside a
+    // bordered scrollable so long bodies stay contained and don't
+    // explode the window. Empty body → "No release notes provided."
+    let notes_heading = container(text("What's new").size(11).color(DIM))
+        .padding(iced::Padding {
+            top: 10.0,
+            right: 0.0,
+            bottom: 4.0,
+            left: 0.0,
+        });
+
+    let notes_body: Element<'a, Message> = if body.trim().is_empty() {
+        text("No release notes provided.")
+            .size(11)
+            .color(DIM)
+            .into()
+    } else {
+        let mut col = column![].spacing(4);
+        for line in body.lines() {
+            col = col.push(render_notes_line(line));
+        }
+        scrollable(container(col).padding([10, 14])).height(Fill).into()
+    };
+
+    let notes_block = container(notes_body)
+        .width(Fill)
+        .height(Fill)
+        .style(|_: &Theme| container::Style {
+            background: Some(Background::Color(PANEL)),
+            border: Border {
+                color: BORDER,
+                width: 1.0,
+                radius: 4.0.into(),
+            },
+            ..Default::default()
+        });
+
+    // Wrap notes_block in a Fill-height container outside the column so it
+    // greedily claims every pixel left over after the fixed-height rows
+    // (header, version cards, heading, footer). Without this iced lets the
+    // notes panel shrink to its content height, leaving a gap above the
+    // footer.
+    let notes_fill = container(notes_block)
+        .width(Fill)
+        .height(Fill);
+
     container(
-        column![header, info_block, footer]
+        column![header, info_block, notes_heading, notes_fill, footer]
             .spacing(0)
+            .height(Fill)
             .padding(iced::Padding {
                 top: 0.0,
                 right: 20.0,

src/update_check.rs

@@ -3,7 +3,7 @@
 // `check_for_update()` runs on a background thread (joined inside an
 // async wrapper, mirroring how the rest of `crate::io` wraps blocking
 // work for iced's `Task::perform`). It hits the GitHub releases API and
-// returns `Some(latest_version)` when a newer release is available, or
+// returns `Some(UpdateInfo)` when a newer release is available, or
 // `None` when up to date / on network failure / on parse error.
 
 const RELEASES_API: &str =
@@ -11,14 +11,24 @@ const RELEASES_API: &str =
 pub const RELEASES_PAGE: &str =
     "https://github.com/HakanSeven12/H7CAD/releases/latest";
 
-pub async fn check_for_update() -> Option<String> {
+/// What `check_for_update` reports when a newer release exists.
+#[derive(Debug, Clone)]
+pub struct UpdateInfo {
+    /// `tag_name` with the leading `v` stripped (e.g. `0.3.7`).
+    pub version: String,
+    /// Release notes / markdown body from the GitHub release. May be empty
+    /// when the release was published without notes.
+    pub body: String,
+}
+
+pub async fn check_for_update() -> Option<UpdateInfo> {
     std::thread::spawn(fetch_latest_if_outdated)
         .join()
         .ok()
         .flatten()
 }
 
-fn fetch_latest_if_outdated() -> Option<String> {
+fn fetch_latest_if_outdated() -> Option<UpdateInfo> {
     let body = ureq::AgentBuilder::new()
         .timeout(std::time::Duration::from_secs(5))
         .build()
@@ -29,22 +39,71 @@ fn fetch_latest_if_outdated() -> Option<String> {
         .ok()?
         .into_string()
         .ok()?;
-    let latest = extract_tag(&body)?
+    let latest = extract_string_field(&body, "tag_name")?
         .trim_start_matches('v')
         .to_string();
-    if latest != env!("CARGO_PKG_VERSION") {
+    if latest == env!("CARGO_PKG_VERSION") {
-        Some(latest)
+        return None;
-    } else {
-        None
     }
+    // Release notes are optional; treat missing as empty.
+    let notes = extract_string_field(&body, "body").unwrap_or_default();
+    Some(UpdateInfo { version: latest, body: notes })
 }
 
-fn extract_tag(body: &str) -> Option<String> {
+/// Minimal extractor for a top-level string field in the releases JSON.
-    // Minimal substring extraction so we don't pull serde_json just for
+/// Avoids pulling in `serde_json` for two fields. Handles standard JSON
-    // one field. The GitHub releases endpoint always returns
+/// string escapes (`\"`, `\\`, `\n`, `\r`, `\t`, `\/`) which are all the
-    // `"tag_name":"v…"` near the top of the JSON object.
+/// GitHub release body uses in practice.
-    const KEY: &str = "\"tag_name\":\"";
+fn extract_string_field(body: &str, field: &str) -> Option<String> {
-    let start = body.find(KEY)? + KEY.len();
+    let key = format!("\"{}\":\"", field);
-    let end = body[start..].find('"')? + start;
+    let start = body.find(&key)? + key.len();
-    Some(body[start..end].to_string())
+    // Walk to the closing unescaped `"`, JSON-unescaping as we go.
+    let mut out = String::new();
+    let bytes = body.as_bytes();
+    let mut i = start;
+    while i < bytes.len() {
+        let b = bytes[i];
+        if b == b'"' {
+            return Some(out);
+        }
+        if b == b'\\' && i + 1 < bytes.len() {
+            match bytes[i + 1] {
+                b'"' => out.push('"'),
+                b'\\' => out.push('\\'),
+                b'/' => out.push('/'),
+                b'n' => out.push('\n'),
+                b'r' => out.push('\r'),
+                b't' => out.push('\t'),
+                b'u' => {
+                    // \uXXXX — decode 4 hex digits. Surrogate pairs (BMP only
+                    // for now) are uncommon in release notes; skip on parse
+                    // failure.
+                    if i + 5 < bytes.len() {
+                        let hex = std::str::from_utf8(&bytes[i + 2..i + 6]).ok()?;
+                        if let Ok(code) = u32::from_str_radix(hex, 16) {
+                            if let Some(c) = char::from_u32(code) {
+                                out.push(c);
+                            }
+                        }
+                        i += 6;
+                        continue;
+                    }
+                    return None;
+                }
+                other => {
+                    // Unknown escape — keep the literal pair, GitHub doesn't emit these.
+                    out.push('\\');
+                    out.push(other as char);
+                }
+            }
+            i += 2;
+            continue;
+        }
+        // UTF-8 multi-byte chars: push the whole code-point so we don't
+        // bisect a sequence.
+        let ch = body[i..].chars().next()?;
+        out.push(ch);
+        i += ch.len_utf8();
+    }
+    None
 }