Merge callouts: nested foldable admonitions + FoldAnchor DRY, table healing/auto-grow, dev-profile perf, README screenshots, audit fixes

Author: wilfreddenton

Cargo.toml

@@ -9,6 +9,9 @@ repository = "https://github.com/wilfreddenton/writ"
 homepage = "https://github.com/wilfreddenton/writ"
 documentation = "https://docs.rs/writ"
 
+[package.metadata.docs.rs]
+all-features = true
+
 [lints.clippy]
 too_many_arguments = "allow"
 
@@ -100,6 +103,14 @@ tree-sitter-rust = "0.24"
 undo = "0.52"
 notify-debouncer-full = { version = "0.5", optional = true }
 
+# Optimize dependencies even in dev/test builds. writ's own code stays unoptimized
+# (fast incremental compile + debuggable), but the graphics/parsing stack (wgpu, vello,
+# parley/swash, tree-sitter, gix, …) runs at opt-level 2. Without this a debug build shapes
+# text ~10× slower and its large unoptimized working set page-faults in over the first ~30s
+# of use — making the editor feel sluggish at startup even though release is smooth.
+[profile.dev.package."*"]
+opt-level = 2
+
 [profile.release]
 lto = "thin"
 codegen-units = 1

README.md

@@ -6,6 +6,8 @@
 
 A hybrid markdown editor combining raw text editing with live inline rendering.
 
+![writ rendering Markdown inline — a clean heading, styled prose, and a syntax-highlighted Rust code block](https://raw.githubusercontent.com/wilfreddenton/writ/main/assets/hero.png)
+
 ## Install
 
 ```bash
@@ -55,7 +57,9 @@ comment = "#7A88B8"
 
 ### Inline git diff
 
-When the open file lives in a git repository, writ renders a live inline diff against `HEAD`: added lines and words are tinted green, deleted lines appear as red "ghost" rows above their position, all with the same markdown rendering as the rest of the document. writ watches the file, so edits made by an external tool (e.g. an AI agent) reload and re-diff live.
+When the open file lives in a git repository, writ renders a live inline diff against `HEAD`: added lines and words are tinted green, deleted lines appear as red "ghost" rows above their position, all with the same markdown rendering as the rest of the document. writ watches both the file and the repository's `HEAD`, so edits made by an external tool (e.g. an AI agent) reload and re-diff live — and committing, amending, or switching branches re-bases the diff immediately, even when the working file itself is untouched.
+
+![Inline git diff: red ghost rows for deletions above green added lines, with word-level highlighting, all rendered as Markdown](https://raw.githubusercontent.com/wilfreddenton/writ/main/assets/diff.png)
 
 ### GitHub integration
 
@@ -96,19 +100,15 @@ On Linux, using a faster linker significantly improves build times. See [Zed's l
 
 ### Build Profiles
 
-Debug builds are significantly slower, especially for image loading and text rendering. For day-to-day development with better performance, use the `release-fast` profile:
-
-```bash
-cargo run --profile release-fast -- --file path/to/document.md
-```
+The dev profile optimizes dependencies (`opt-level = 2` for all deps, via `[profile.dev.package."*"]`) while keeping writ's own code unoptimized and debuggable — so a plain `cargo run` is comfortably interactive (the graphics/parsing stack — wgpu, Vello, Parley, tree-sitter — runs at full speed). Dependencies compile once, so incremental writ builds stay fast.
 
 For maximum runtime performance (slower compile times), use a full release build:
 
 ```bash
 cargo run --release -- --file path/to/document.md
 ```
 
-The release profile enables thin LTO and single codegen unit for best optimization. The `release-fast` profile trades some runtime performance for faster compilation by disabling LTO and using parallel codegen units.
+The release profile enables thin LTO and a single codegen unit for best optimization; the `release-fast` profile (`cargo run --profile release-fast`) trades some of that for faster compilation by disabling LTO and using parallel codegen units.
 
 ## Features
 
@@ -126,6 +126,12 @@ Unordered list markers (`-`) are replaced with bullet symbols when the cursor is
 
 Nesting is fully supported. A task item inside a blockquote is represented internally as a stack of layers, and each layer contributes its visual treatment independently.
 
+### Callouts
+
+Obsidian-style callouts — a blockquote whose first line is `> [!note]` (or `tip`, `warning`, `danger`, `success`, `question`, `example`, `quote`, …) — render inline with a type icon and accent color. Twelve types with their aliases are recognized. Add `+`/`-` after the type (`> [!tip]-`) to make a callout foldable (and start it collapsed); callouts nest, and each nesting level folds independently with the same gutter-chevron gestures as headings and lists. A custom title after the type (`> [!warning] Be careful`) replaces the default. As with other markers, the raw `[!type]` syntax reveals while your cursor is on the header line.
+
+![Obsidian-style callouts: note, foldable tip, warning, and danger, each with its own icon and accent color](https://raw.githubusercontent.com/wilfreddenton/writ/main/assets/callouts.png)
+
 ### Smart Enter and Tab
 
 Enter inserts a raw newline—no magic. Shift+Enter continues the current container by copying markers from the current line (e.g., on `- item|`, Shift+Enter creates `\n- `). Shift+Alt+Enter creates an indented continuation for nested paragraphs within list items.
@@ -142,24 +148,32 @@ Full selection support with click, drag (with edge auto-scroll), shift+arrow key
 
 ### GFM Tables
 
-Pipe tables render as a live grid — bold header, per-column alignment (`:--`/`:-:`/`--:`), and inline styles (bold, code, links) inside cells. Move your cursor into a table and it reveals the raw pipe source for editing; move out and it snaps back to the grid. Type a header row like `| Name | Age |` and press Shift+Enter to scaffold the delimiter and a body row; Tab moves between cells (and appends a row from the last cell).
+Pipe tables render as a live grid — bold header, per-column alignment (`:--`/`:-:`/`--:`), and inline styles (bold, code, links) inside cells. Move your cursor into a table and it reveals the raw pipe source for editing; move out and it snaps back to the grid. Type a header row like `| Name | Age |` and press Shift+Enter to scaffold the delimiter and a body row; Tab moves between cells (and appends a row from the last cell). Type a new column into the header and the delimiter and every body row grow to match — in place, wherever you added it. Backspace on a freshly-added empty row removes it in one press.
+
+![A GFM table rendered as a grid with a bold header and right-aligned numeric columns](https://raw.githubusercontent.com/wilfreddenton/writ/main/assets/tables.png)
 
 ### Find and Replace
 
 Ctrl+F opens a find bar docked above the status bar; Ctrl+H adds the replace row. Matches highlight live with a count, and the current match is emphasized; Enter/Shift+Enter cycle through them. Toggle regular expressions (Alt+R, with `$1` capture groups in the replacement) and case sensitivity (Alt+C). Enter in the replace field swaps the current match, Ctrl+Enter replaces all in one undo step. Click into the document to keep the bar open while you edit.
 
 ### Folding
 
-Headings and nested lists fold from the gutter. Hover the left margin to reveal a chevron on any foldable line and click to collapse its section; the outline mirrors what's folded. Modifier-clicks scope the fold: Ctrl folds every section at that level, Shift folds recursively, Ctrl+Shift folds that level and everything deeper. Jumping to a hidden line auto-unfolds it. Task lists fold the same way, so a long checklist collapses to its parent item.
+Headings, nested lists, and callouts all fold from the gutter through one unified model. Hover the left margin to reveal a chevron on any foldable line and click to collapse its section; the outline mirrors what's folded. Modifier-clicks scope the fold: Ctrl folds every section at that level, Shift folds recursively, Ctrl+Shift folds that level and everything deeper. Jumping to a hidden line auto-unfolds it. Task lists fold the same way, so a long checklist collapses to its parent item.
+
+![A collapsed callout showing its gutter chevron, above a foldable heading section and a nested list](https://raw.githubusercontent.com/wilfreddenton/writ/main/assets/folding.png)
 
 ### Mermaid Diagrams
 
 Fenced ` ```mermaid ` blocks render inline as diagrams. Rendering runs off the UI thread and is cached, so scrolling stays smooth. Drag a selection through a diagram (or move the cursor onto its block) and it de-sugars back to the raw source you're actually editing, then snaps back to the rendered diagram when you leave.
 
+![A Mermaid flowchart rendered inline in writ](https://raw.githubusercontent.com/wilfreddenton/writ/main/assets/mermaid.png)
+
 ### Math
 
 LaTeX math renders inline via RaTeX with the KaTeX fonts embedded. Block `$$…$$` renders as centered display math on its own line; inline `$…$` renders as a baseline-aligned box within the text (the GitHub/pandoc rule keeps prose like "$5 and $10" literal). Glyphs take the theme foreground color. As with mermaid, moving the cursor into a span reveals its raw source for editing.
 
+![Inline and block LaTeX math rendered in writ](https://raw.githubusercontent.com/wilfreddenton/writ/main/assets/math.png)
+
 ## Library Usage
 
 writ is also a library: its rendering and editing layers work independently of the
@@ -229,7 +243,7 @@ and opt into only what you need:
 
 ```toml
 # render-only: pulls in none of tokio/reqwest/gix/github/winit
-writ = { version = "0.15", default-features = false }
+writ = { version = "0.16", default-features = false }
 ```
 
 | Feature | Adds |
@@ -269,12 +283,6 @@ This manual extraction approach was chosen over tree-sitter's built-in injection
 
 Currently Rust and Bash are supported; adding a language requires just the grammar crate and a highlights.scm query file. Highlights are cached and only recomputed after edits.
 
-## Known Issues
-
-### Short Headings Not Styled While Typing
-
-When typing `# Hello`, tree-sitter doesn't recognize it as a heading until enough content is present or a newline is added. This is a quirk of the tree-sitter-md grammar. The heading styling appears once you press Enter or type enough characters.
-
-### Ordered List Continuation Shows Wrong Number
+## Limitations
 
-Pressing Shift+Enter on an ordered list item inserts `1. ` as a placeholder. The correct number appears after you start typing, when tree-sitter recognizes the list structure and auto-numbering corrects it.
+Only **ATX** headings (`# Heading`) are recognized — setext headings (a line underlined with `===` or `---`) render as plain text and don't appear in the outline or fold. This is deliberate: setext text and its underline live on separate lines, so full support means both collecting *and* rendering it across the pair, for a syntax `#` dominates in practice.

assets/callouts.png

@@ -9,6 +9,7 @@ use undo::Record;
 /// Global counter for unique buffer versions.
 static NEXT_VERSION: AtomicU64 = AtomicU64::new(1);
 
+use crate::callout::CalloutInfo;
 use crate::highlight::{HighlightSpan, Highlighter};
 use crate::inline::{StyledRegion, extract_all_inline_styles, styles_in_range};
 use crate::marker::{
@@ -20,7 +21,7 @@ use crate::math::MathBlock;
 #[cfg(feature = "mermaid")]
 use crate::mermaid::MermaidBlock;
 use crate::parser::{MarkdownParser, MarkdownTree};
-use crate::table::{RowKind, TableInfo};
+use crate::table::{RowKind, TableInfo, row_kind_at_line};
 
 /// Compute the byte range for a line (excludes trailing newline).
 fn compute_line_byte_range(rope: &Rope, line_idx: usize) -> Range<usize> {
@@ -192,24 +193,28 @@ impl RenderSnapshot {
         (offset < table.block.end).then_some(table)
     }
 
-    /// Map a buffer line to the table and row role it belongs to, if any. A line
-    /// belongs to a row when the row's `line` byte range contains the line's start.
+    /// Map a buffer line to the table and row role it belongs to, if any. Compares by
+    /// line *number* (not byte containment): tree-sitter's error recovery can start a
+    /// row node mid-line (after the leading `|`), so a byte-range `contains` would miss
+    /// the row's own line.
     pub fn table_row_at_line(&self, line_idx: usize) -> Option<(&TableInfo, RowKind)> {
         let line_start = self.line_byte_range(line_idx).start;
         let table = self.table_containing_offset(line_start)?;
+        let kind = row_kind_at_line(table, line_idx, |b| self.rope.byte_to_line(b))?;
+        Some((table, kind))
+    }
 
-        if table.header.line.contains(&line_start) {
-            return Some((table, RowKind::Header));
-        }
-        if table.delimiter_line.contains(&line_start) {
-            return Some((table, RowKind::Delimiter));
-        }
-        for (i, row) in table.body.iter().enumerate() {
-            if row.line.contains(&line_start) {
-                return Some((table, RowKind::Body(i)));
-            }
-        }
-        None
+    /// Every detected callout, in document order.
+    pub fn callouts(&self) -> &[CalloutInfo] {
+        &self.parsed.callouts
+    }
+
+    /// The callout whose `[!type]` header is on `line_idx`, if any.
+    pub fn callout_header_at_line(&self, line_idx: usize) -> Option<&CalloutInfo> {
+        self.parsed
+            .callouts
+            .iter()
+            .find(|c| c.header_line == line_idx)
     }
 
     /// All ```` ```mermaid ```` fences in the document, scanned once. Computed per build
@@ -717,30 +722,11 @@ impl BufferContent {
         self.text.len_bytes() == 0
     }
 
-    /// Check if buffer ends with the given string (efficient, doesn't copy whole buffer).
-    pub fn ends_with(&self, suffix: &str) -> bool {
-        let len = self.text.len_bytes();
-        let suffix_len = suffix.len();
-        if len < suffix_len {
-            return false;
-        }
-        let start = len - suffix_len;
-        self.text
-            .byte_slice(start..len)
-            .as_str()
-            .map(|s| s == suffix)
-            .unwrap_or(false)
-    }
-
-    /// Get a single byte at the given offset, if it exists.
+    /// Get a single byte at the given offset, if it exists. `get_byte` indexes the rope
+    /// by byte directly — never slicing — so it's safe when `offset` is the interior byte
+    /// of a multi-byte UTF-8 codepoint (a `byte_slice(offset..offset+1)` would panic there).
     pub fn byte_at(&self, offset: usize) -> Option<u8> {
-        if offset >= self.text.len_bytes() {
-            return None;
-        }
-        self.text
-            .byte_slice(offset..offset + 1)
-            .as_str()
-            .and_then(|s| s.bytes().next())
+        self.text.get_byte(offset)
     }
 
     pub fn rope(&self) -> &Rope {
@@ -768,6 +754,11 @@ impl BufferContent {
         &self.parsed().list_items
     }
 
+    /// Callouts in document order. Rc-cached with the parse tree.
+    pub fn callouts(&self) -> &[CalloutInfo] {
+        &self.parsed().callouts
+    }
+
     /// Compute LineMarkers for a specific line on demand.
     pub fn line_markers(&self, line_idx: usize) -> LineMarkers {
         line_markers_from(&self.parsed, &self.text, line_idx)
@@ -1126,6 +1117,17 @@ impl FromStr for Buffer {
 mod tests {
     use super::*;
 
+    #[test]
+    fn byte_at_handles_multibyte_boundaries() {
+        // `é` is 0xC3 0xA9; `byte_at` must return each byte without panicking (the old
+        // `byte_slice(offset..offset+1)` panicked on the interior byte of a codepoint).
+        let buf: Buffer = "é!".parse().unwrap();
+        assert_eq!(buf.byte_at(0), Some(0xC3));
+        assert_eq!(buf.byte_at(1), Some(0xA9));
+        assert_eq!(buf.byte_at(2), Some(b'!'));
+        assert_eq!(buf.byte_at(3), None);
+    }
+
     fn apply_diff(old: &str, new: &str) -> String {
         let (start, old_end, replacement) = minimal_diff(old, new);
         let mut result = String::new();