feat: render fenced code blocks at 0.9x body size; persist+remap folds across file reload

Author: wilfreddenton

src/core.rs

@@ -1652,8 +1652,16 @@ impl Editor {
     /// Only parse/snapshot/diff work — no IO.
     pub fn apply_reload(&mut self, content: String, base_text: Option<String>) {
         if !self.state.buffer.content_eq(&content) {
+            // Persist folds across the reload: remap their offsets from the actual
+            // splice (external edits are usually a localized change), the same way a
+            // local edit does. `set_text` leaves `folded_headings` untouched, so without
+            // this the old offsets would land on the wrong lines in the new content.
+            let before = (!self.folded_headings.is_empty()).then(|| self.state.buffer.text());
             let cursor_line = self.state.buffer.byte_to_line(self.state.selection.head);
             self.set_text(&content);
+            if let Some(before) = before {
+                self.remap_folds(&before, &content);
+            }
             let line = cursor_line.min(self.state.buffer.line_count().saturating_sub(1));
             let offset = self.state.buffer.line_to_byte(line);
             self.state.selection = Selection::new(offset, offset);
@@ -2533,6 +2541,24 @@ let code = target(); // fenced block line
         );
     }
 
+    #[test]
+    fn folds_persist_and_remap_across_reload() {
+        let mut e = Editor::new("# One\nbody\n## Two\nmore\n");
+        let two = e.text().find("## Two").unwrap();
+        e.toggle_fold(two);
+        assert!(e.folded_headings.contains(&two));
+        // An external edit prepends a line; the reload should shift the fold offset so it
+        // still lands on the (moved) heading rather than pointing at stale bytes.
+        let prefix = "intro line\n";
+        e.apply_reload(format!("{prefix}# One\nbody\n## Two\nmore\n"), None);
+        let two_after = e.text().find("## Two").unwrap();
+        assert_eq!(two_after, two + prefix.len());
+        assert!(
+            e.folded_headings.contains(&two_after),
+            "fold should remap to the heading's new offset after reload"
+        );
+    }
+
     #[test]
     fn find_replace_current_is_single_undo_step() {
         let mut e = Editor::new("a a a\n");

src/render.rs

@@ -121,6 +121,10 @@ pub struct LineRender {
     pub table: Option<TableLineRef>,
 }
 
+/// Font-size multiplier for fenced code blocks — slightly smaller than body, matching
+/// how GitHub/most editors render code denser than prose.
+const CODE_BLOCK_SCALE: f32 = 0.9;
+
 /// Font-size multiplier for a heading level (1 = largest). 0 = body text. A modular type
 /// scale on the Major Third ratio (1.25), anchored so H6 = body size (the floor — no
 /// heading is ever smaller than body) and each step up is 1.25× the last, giving large,
@@ -217,9 +221,16 @@ pub fn build_line_render(
     let line_end = line_start + line_text.len();
 
     let heading_level = markers.heading_level().unwrap_or(0);
-    let font_size = base_font_size * heading_scale(heading_level);
-    let cursor_on_line = cursor_in(&range, cursor_offset);
     let in_code_block = markers.in_code_block || markers.is_fence();
+    // Fenced code renders slightly smaller (GitHub-style) so a code block reads as a
+    // denser, distinct block instead of competing with body prose. Headings and code are
+    // mutually exclusive, so the two scales never combine.
+    let font_size = if in_code_block {
+        base_font_size * CODE_BLOCK_SCALE
+    } else {
+        base_font_size * heading_scale(heading_level)
+    };
+    let cursor_on_line = cursor_in(&range, cursor_offset);
 
     // Grid table row: the cursor is off the whole table block, so this line hides its
     // raw pipe text and the draw path paints the cell grid. While the cursor is inside