` borrow. Use `*headers = row;` instead. The replacement code above is in the same spirit as the existing `parse_phrasing_content` recursion, where the helpers take `&mut Vec`. When editing, double-check borrow semantics against your local error output and adjust by adding `*` where needed.
+
+Run:
+```bash
+cargo test -p markdown_parser test_parse_html_raw_table test_parse_html_img_block --quiet
+```
+Expected: PASS. If clippy complains about the closure-borrow pattern, refactor to a free function that takes `&mut Vec` and returns `()`.
+
+- [ ] **Step 5: Add per-tag tests for kbd, sub, sup, del, mark**
+
+Append to `crates/markdown_parser/src/html_parser_tests.rs`:
+
+```rust
+#[test]
+fn test_parse_html_phrasing_tags() {
+ let html = "Press Cmd for 2 + 3, \
+ old, marked.
";
+ let parsed = parse_html(html).expect("HTML should parse");
+ let fragments: Vec<_> = parsed
+ .lines
+ .iter()
+ .filter_map(|line| match line {
+ FormattedTextLine::Line(frags) => Some(frags),
+ _ => None,
+ })
+ .flatten()
+ .cloned()
+ .collect();
+ let by_text = |needle: &str| {
+ fragments
+ .iter()
+ .find(|f| f.text == needle)
+ .cloned()
+ .unwrap_or_else(|| panic!("no fragment {needle:?} in {fragments:?}"))
+ };
+
+ assert!(by_text("Cmd").styles.inline_code, "kbd → inline_code");
+ assert!(by_text("2").styles.italic, "sub → italic");
+ assert!(by_text("3").styles.italic, "sup → italic");
+ assert!(by_text("old").styles.strikethrough, "del → strikethrough");
+ // has no equivalent style flag for v1 — passes through as plain text.
+ let marked = by_text("marked");
+ assert!(!marked.styles.inline_code);
+ assert_eq!(marked.styles.weight, None);
+}
+```
+
+In `crates/markdown_parser/src/html_parser.rs`, find the `match node_name.as_ref()` inside `parse_phrasing_content` (currently lines 442–451). Replace it with:
+
+```rust
+match node_name.as_ref() {
+ "b" | "strong" => decorated_styling.bold = true,
+ "i" | "em" => decorated_styling.italic = true,
+ "s" | "del" => decorated_styling.strikethrough = true,
+ "u" | "ins" => decorated_styling.underline = true,
+ "code" | "kbd" => decorated_styling.inline_code = true,
+ "sub" | "sup" => decorated_styling.italic = true,
+ "mark" | "small" | "q" | "span" => {}
+ _ => (),
+};
+```
+
+Also update `PHRASING_ELEMENT_TAGS` at line 27–29 to include the newcomers so the dispatcher routes them as phrasing rather than block:
+
+```rust
+const PHRASING_ELEMENT_TAGS: &[&str] = &[
+ "span", "i", "code", "strong", "em", "br", "a", "s", "u", "ins",
+ "del", "kbd", "sub", "sup", "mark", "small", "q",
+];
+```
+
+Run:
+```bash
+cargo test -p markdown_parser test_parse_html_phrasing_tags --quiet
+```
+Expected: PASS.
+
+- [ ] **Step 6: Run the full html_parser test suite**
+
+```bash
+cargo test -p markdown_parser html_parser --quiet
+```
+Expected: all pass (existing + new).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git branch --show-current
+./script/check_ai_attribution
+git add crates/markdown_parser/src/html_parser.rs crates/markdown_parser/src/html_parser_tests.rs
+git commit -S -m "feat(markdown_parser): render details/kbd/sub/sup/del/raw table/img html"
+git log -1 --show-signature
+```
+
+---
+
+## Phase 2 — HTML span lexer (`gfm_html.rs`)
+
+### Task 2.1: Scaffold `gfm_html.rs` with safe-list constants
+
+**Files:**
+- Create: `crates/markdown_parser/src/gfm_html.rs`
+- Modify: `crates/markdown_parser/src/lib.rs`
+
+- [ ] **Step 1: Create the file**
+
+Write `crates/markdown_parser/src/gfm_html.rs`:
+
+```rust
+//! GFM-style HTML span lexing for the markdown parser.
+//!
+//! `try_lex_html_span` recognizes a single HTML span starting at the current
+//! input position and returns it together with the remaining input. Tags are
+//! classified against a hardcoded safe-list / strip-list / block-list.
+//!
+//! This module does NOT parse HTML structure — that work is delegated to
+//! `html_parser::parse_html_inline_fragments` and
+//! `html_parser::parse_html_block_lines`, which both use `html5ever`.
+
+pub(crate) const PHRASING_SAFE_TAGS: &[&str] = &[
+ "a", "b", "br", "code", "del", "em", "i", "ins", "kbd",
+ "mark", "q", "s", "small", "span", "strong", "sub", "sup", "u",
+];
+
+pub(crate) const BLOCK_SAFE_TAGS: &[&str] = &[
+ "blockquote", "caption", "dd", "details", "div", "dl", "dt",
+ "h1", "h2", "h3", "h4", "h5", "h6",
+ "hr", "img", "li", "ol", "p", "pre", "summary",
+ "table", "tbody", "td", "tfoot", "th", "thead", "tr", "ul",
+];
+
+pub(crate) const STRIPPED_TAGS: &[&str] = &[
+ "applet", "body", "button", "embed", "form", "frame", "frameset",
+ "head", "html", "iframe", "input", "link", "meta", "noscript",
+ "object", "script", "style", "title",
+];
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum HtmlSpanKind {
+ PhrasingSafe,
+ BlockSafe,
+ Stripped,
+ Unknown,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct HtmlSpan<'a> {
+ /// The entire matched span, including `` … `` (or just the open tag if
+ /// self-closing or unmatched).
+ pub(crate) raw: &'a str,
+ /// Lowercased tag name.
+ pub(crate) tag: &'a str,
+ pub(crate) kind: HtmlSpanKind,
+}
+
+impl HtmlSpan<'_> {
+ pub(crate) fn is_block(&self) -> bool {
+ matches!(self.kind, HtmlSpanKind::BlockSafe)
+ }
+ pub(crate) fn is_phrasing(&self) -> bool {
+ matches!(self.kind, HtmlSpanKind::PhrasingSafe)
+ }
+ pub(crate) fn is_stripped(&self) -> bool {
+ matches!(self.kind, HtmlSpanKind::Stripped)
+ }
+}
+
+pub(crate) fn classify(tag: &str) -> HtmlSpanKind {
+ let lower = tag.to_ascii_lowercase();
+ if PHRASING_SAFE_TAGS.iter().any(|t| *t == lower) {
+ HtmlSpanKind::PhrasingSafe
+ } else if BLOCK_SAFE_TAGS.iter().any(|t| *t == lower) {
+ HtmlSpanKind::BlockSafe
+ } else if STRIPPED_TAGS.iter().any(|t| *t == lower) {
+ HtmlSpanKind::Stripped
+ } else {
+ HtmlSpanKind::Unknown
+ }
+}
+
+pub(crate) fn try_lex_html_span(input: &str) -> Option<(HtmlSpan<'_>, &str)> {
+ let bytes = input.as_bytes();
+ if bytes.first() != Some(&b'<') {
+ return None;
+ }
+ // HTML comment:
+ if input.starts_with("").map(|i| i + 4 + 3).unwrap_or(input.len());
+ return Some((
+ HtmlSpan { raw: &input[..end], tag: "", kind: HtmlSpanKind::Stripped },
+ &input[end..],
+ ));
+ }
+ let mut idx = 1;
+ let is_close = bytes.get(idx) == Some(&b'/');
+ if is_close {
+ idx += 1;
+ }
+ let tag_start = idx;
+ while idx < bytes.len() && (bytes[idx].is_ascii_alphanumeric() || bytes[idx] == b'-') {
+ idx += 1;
+ }
+ if idx == tag_start {
+ return None; // not a tag
+ }
+ let tag = &input[tag_start..idx];
+ let tag_lower_len = tag.len();
+ // For closing tags we have no body to scan; just find '>'.
+ if is_close {
+ let close_offset = input[idx..].find('>')?;
+ let after = idx + close_offset + 1;
+ return Some((
+ HtmlSpan { raw: &input[..after], tag, kind: classify(tag) },
+ &input[after..],
+ ));
+ }
+ // Skip the open-tag's attributes. We need to honor quoted attribute values
+ // so we don't mistake `'>'` inside a quote for end-of-tag.
+ let mut quote: Option = None;
+ let mut self_closing = false;
+ while idx < bytes.len() {
+ let c = bytes[idx];
+ match (quote, c) {
+ (Some(q), c) if c == q => quote = None,
+ (None, b'"') | (None, b'\'') => quote = Some(c),
+ (None, b'/') if bytes.get(idx + 1) == Some(&b'>') => {
+ self_closing = true;
+ idx += 2;
+ break;
+ }
+ (None, b'>') => {
+ idx += 1;
+ break;
+ }
+ _ => {}
+ }
+ idx += 1;
+ }
+ // Void / self-closing elements end here.
+ let void_tags = ["br", "hr", "img", "input", "meta", "link"];
+ let _ = tag_lower_len;
+ if self_closing || void_tags.iter().any(|t| tag.eq_ignore_ascii_case(t)) {
+ return Some((
+ HtmlSpan { raw: &input[..idx], tag, kind: classify(tag) },
+ &input[idx..],
+ ));
+ }
+ // Scan for matching close tag, honoring nested same-tag pairs.
+ let mut depth = 1usize;
+ let mut scan = idx;
+ while scan < bytes.len() {
+ // Skip non-`<` quickly.
+ let Some(rel) = input[scan..].find('<') else { break };
+ scan += rel;
+ // `") {
+ Some(i) => scan + 4 + i + 3,
+ None => bytes.len(),
+ };
+ continue;
+ }
+ let is_close_here = bytes.get(scan + 1) == Some(&b'/');
+ let name_start = scan + if is_close_here { 2 } else { 1 };
+ let mut name_end = name_start;
+ while name_end < bytes.len()
+ && (bytes[name_end].is_ascii_alphanumeric() || bytes[name_end] == b'-')
+ {
+ name_end += 1;
+ }
+ let same = input[name_start..name_end].eq_ignore_ascii_case(tag);
+ // Find this tag's '>' to advance scan past it.
+ let close_rel = match input[name_end..].find('>') {
+ Some(i) => i + 1,
+ None => bytes.len() - name_end,
+ };
+ let after_tag = name_end + close_rel;
+ if same {
+ if is_close_here {
+ depth -= 1;
+ if depth == 0 {
+ return Some((
+ HtmlSpan { raw: &input[..after_tag], tag, kind: classify(tag) },
+ &input[after_tag..],
+ ));
+ }
+ } else if !void_tags.iter().any(|t| (*t).eq_ignore_ascii_case(tag)) {
+ depth += 1;
+ }
+ }
+ scan = after_tag;
+ }
+ // No matching close; treat the open tag alone as the span.
+ Some((
+ HtmlSpan { raw: &input[..idx], tag, kind: classify(tag) },
+ &input[idx..],
+ ))
+}
+
+#[cfg(test)]
+#[path = "gfm_html_tests.rs"]
+mod tests;
+```
+
+Add `mod gfm_html;` to `crates/markdown_parser/src/lib.rs`. Place it next to the existing `pub mod html_parser;` and `pub mod markdown_parser;` declarations.
+
+```rust
+// crates/markdown_parser/src/lib.rs (around line 6)
+pub mod html_parser;
+pub mod markdown_parser;
+pub mod weight;
+mod gfm_html; // ← new
+```
+
+- [ ] **Step 2: Create the test stub file**
+
+Write `crates/markdown_parser/src/gfm_html_tests.rs`:
+
+```rust
+use super::*;
+
+#[test]
+fn lex_simple_open_close() {
+ let (span, rest) = try_lex_html_span("hi rest").unwrap();
+ assert_eq!(span.raw, "hi");
+ assert_eq!(span.tag, "b");
+ assert_eq!(span.kind, HtmlSpanKind::PhrasingSafe);
+ assert_eq!(rest, " rest");
+}
+
+#[test]
+fn lex_self_closing() {
+ let (span, rest) = try_lex_html_span("
after").unwrap();
+ assert_eq!(span.raw, "
");
+ assert_eq!(rest, "after");
+}
+
+#[test]
+fn lex_void_no_slash() {
+ let (span, rest) = try_lex_html_span("
after").unwrap();
+ assert_eq!(span.raw, "
");
+ assert_eq!(rest, "after");
+}
+
+#[test]
+fn lex_attribute_with_gt_in_quote() {
+ let (span, rest) = try_lex_html_span(r#"link!"#).unwrap();
+ assert_eq!(span.raw, r#"link"#);
+ assert_eq!(rest, "!");
+}
+
+#[test]
+fn lex_nested_same_tag() {
+ let (span, rest) =
+ try_lex_html_span("x x x and more").unwrap();
+ assert_eq!(span.raw, "");
+ assert_eq!(rest, "x and more");
+}
+
+#[test]
+fn lex_comment_stripped() {
+ let (span, rest) = try_lex_html_span("after").unwrap();
+ assert!(span.is_stripped());
+ assert_eq!(rest, "after");
+}
+
+#[test]
+fn lex_not_a_tag_returns_none() {
+ assert!(try_lex_html_span("< not a tag").is_none());
+ assert!(try_lex_html_span("a ").is_none());
+}
+
+#[test]
+fn lex_classification() {
+ assert_eq!(classify("kbd"), HtmlSpanKind::PhrasingSafe);
+ assert_eq!(classify("details"), HtmlSpanKind::BlockSafe);
+ assert_eq!(classify("script"), HtmlSpanKind::Stripped);
+ assert_eq!(classify("foo"), HtmlSpanKind::Unknown);
+ assert_eq!(classify("DETAILS"), HtmlSpanKind::BlockSafe, "case-insensitive");
+}
+```
+
+- [ ] **Step 3: Run the lexer tests**
+
+```bash
+cargo test -p markdown_parser gfm_html --quiet
+```
+Expected: all 9 tests PASS. If they fail, fix the lexer (most likely culprit: the attribute-in-quote scan or the nested-same-tag depth counter).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git branch --show-current
+./script/check_ai_attribution
+git add crates/markdown_parser/src/gfm_html.rs crates/markdown_parser/src/gfm_html_tests.rs crates/markdown_parser/src/lib.rs
+git commit -S -m "feat(markdown_parser): add gfm html span lexer with safe-list"
+git log -1 --show-signature
+```
+
+---
+
+## Phase 3 — Wire HTML dispatch into the markdown parser
+
+### Task 3.1: Add block-level HTML dispatch in `parse_markdown_internal`
+
+**Files:**
+- Modify: `crates/markdown_parser/src/markdown_parser.rs`
+- Modify: `crates/markdown_parser/src/markdown_parser_tests.rs`
+
+- [ ] **Step 1: Add the failing test**
+
+Append to `crates/markdown_parser/src/markdown_parser_tests.rs`:
+
+```rust
+#[test]
+fn test_parse_block_html_details() {
+ let source = "Click
Body
` line break and unknown-tag pass-through inline
+
+**Files:**
+- Modify: `crates/markdown_parser/src/markdown_parser_tests.rs`
+
+- [ ] **Step 1: Add the tests**
+
+Append:
+
+```rust
+#[test]
+fn test_parse_inline_html_br_emits_linebreak() {
+ let source = "before
after";
+ let parsed = test_parse_markdown(source);
+ // The HTML helper emits the
as a LineBreak line, then "after" as a
+ // continuation. Joined raw text should reflect the break.
+ let joined = parsed
+ .iter()
+ .map(|line| line.raw_text())
+ .collect::();
+ assert!(joined.contains("before"));
+ assert!(joined.contains("after"));
+}
+
+#[test]
+fn test_parse_inline_html_stripped_emits_nothing() {
+ let source = "before after";
+ let parsed = test_parse_markdown(source);
+ let joined: String = parsed
+ .iter()
+ .filter_map(|line| match line {
+ FormattedTextLine::Line(fragments) => {
+ Some(fragments.iter().map(|f| f.text.clone()).collect::())
+ }
+ _ => None,
+ })
+ .collect();
+ assert!(joined.contains("before"));
+ assert!(joined.contains("after"));
+ assert!(!joined.contains("alert"), "got {joined:?}");
+}
+```
+
+Run:
+```bash
+cargo test -p markdown_parser test_parse_inline_html_br_emits_linebreak test_parse_inline_html_stripped_emits_nothing --quiet
+```
+Expected: PASS.
+
+- [ ] **Step 2: Commit**
+
+```bash
+git branch --show-current
+./script/check_ai_attribution
+git add crates/markdown_parser/src/markdown_parser_tests.rs
+git commit -S -m "test(markdown_parser): cover inline html br and stripped tags"
+git log -1 --show-signature
+```
+
+---
+
+## Phase 4 — Footnotes (`footnotes.rs`)
+
+### Task 4.1: Scaffold the module and definition extraction
+
+**Files:**
+- Create: `crates/markdown_parser/src/footnotes.rs`
+- Create: `crates/markdown_parser/src/footnotes_tests.rs`
+- Modify: `crates/markdown_parser/src/lib.rs`
+
+- [ ] **Step 1: Create the module**
+
+Write `crates/markdown_parser/src/footnotes.rs`:
+
+```rust
+//! Footnote pre/post-processing for the markdown parser.
+//!
+//! GFM footnotes have two parts:
+//! - Definitions of the form `[^id]: text` (block-level, may continue on
+//! subsequent indented lines).
+//! - References of the form `[^id]` (inline).
+//!
+//! This module pre-extracts definitions from the raw markdown (returning the
+//! source minus the definition lines), and post-rewrites references in the
+//! parsed `FormattedText`, appending a footnotes section if any references
+//! were resolved.
+
+use std::collections::HashMap;
+
+use crate::{
+ FormattedIndentTextInline, FormattedText, FormattedTextFragment, FormattedTextLine,
+ FormattedTextStyles, Hyperlink, OrderedFormattedIndentTextInline,
+};
+
+#[derive(Debug, Clone)]
+pub(crate) struct FootnoteDef {
+ pub(crate) id: String,
+ pub(crate) content: String,
+}
+
+pub(crate) struct FootnoteContext {
+ pub(crate) definitions: HashMap,
+ /// Resolved id → assigned number (1-based, in order of first reference).
+ pub(crate) numbers: HashMap,
+ /// Definitions used at least once, in number order.
+ pub(crate) used: Vec,
+}
+
+impl FootnoteContext {
+ pub(crate) fn empty() -> Self {
+ Self {
+ definitions: HashMap::new(),
+ numbers: HashMap::new(),
+ used: Vec::new(),
+ }
+ }
+}
+
+/// Strip footnote definitions from the source. Returns the source minus the
+/// definition lines and the collected definition map.
+pub(crate) fn extract_definitions(source: &str) -> (String, HashMap) {
+ let mut definitions: HashMap = HashMap::new();
+ let mut output = String::with_capacity(source.len());
+ let mut lines = source.split_inclusive('\n').peekable();
+
+ while let Some(line) = lines.next() {
+ let trimmed = line.trim_end_matches(['\r', '\n']);
+ if let Some((id, first)) = parse_definition_line(trimmed) {
+ let mut content = first.to_string();
+ // Absorb indented continuation lines (4 spaces or a tab).
+ while let Some(peek) = lines.peek() {
+ let peek_no_eol = peek.trim_end_matches(['\r', '\n']);
+ if peek_no_eol.starts_with(" ") || peek_no_eol.starts_with('\t') {
+ let cont = lines.next().unwrap();
+ let cont_trimmed = cont
+ .trim_end_matches(['\r', '\n'])
+ .trim_start_matches(['\t'])
+ .trim_start_matches(" ");
+ content.push(' ');
+ content.push_str(cont_trimmed);
+ } else {
+ break;
+ }
+ }
+ definitions.insert(id.clone(), FootnoteDef { id, content });
+ continue;
+ }
+ output.push_str(line);
+ }
+
+ (output, definitions)
+}
+
+fn parse_definition_line(line: &str) -> Option<(String, &str)> {
+ let rest = line.strip_prefix("[^")?;
+ let close = rest.find(']')?;
+ let id = &rest[..close];
+ if id.is_empty() || id.contains(char::is_whitespace) {
+ return None;
+ }
+ let after = &rest[close + 1..];
+ let body = after.strip_prefix(':')?.trim_start();
+ Some((id.to_string(), body))
+}
+
+#[cfg(test)]
+#[path = "footnotes_tests.rs"]
+mod tests;
+```
+
+Add `mod footnotes;` to `crates/markdown_parser/src/lib.rs` next to `mod gfm_html;`.
+
+Write `crates/markdown_parser/src/footnotes_tests.rs`:
+
+```rust
+use super::*;
+
+#[test]
+fn extract_single_definition() {
+ let source = "claim[^x]\n\n[^x]: defn\n";
+ let (out, defs) = extract_definitions(source);
+ assert_eq!(out, "claim[^x]\n\n");
+ assert_eq!(defs.len(), 1);
+ assert_eq!(defs.get("x").unwrap().content, "defn");
+}
+
+#[test]
+fn extract_no_definitions_passthrough() {
+ let source = "plain text\n";
+ let (out, defs) = extract_definitions(source);
+ assert_eq!(out, "plain text\n");
+ assert!(defs.is_empty());
+}
+
+#[test]
+fn extract_continuation_line() {
+ let source = "[^x]: first\n continued\n";
+ let (out, defs) = extract_definitions(source);
+ assert_eq!(out, "");
+ assert_eq!(defs.get("x").unwrap().content, "first continued");
+}
+
+#[test]
+fn extract_id_with_space_skipped() {
+ // GFM ids don't allow whitespace; the line falls through as a regular paragraph.
+ let source = "[^bad id]: defn\n";
+ let (out, defs) = extract_definitions(source);
+ assert_eq!(out, source);
+ assert!(defs.is_empty());
+}
+```
+
+- [ ] **Step 2: Run extraction tests**
+
+```bash
+cargo test -p markdown_parser footnotes::tests --quiet
+```
+Expected: PASS.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git branch --show-current
+./script/check_ai_attribution
+git add crates/markdown_parser/src/footnotes.rs crates/markdown_parser/src/footnotes_tests.rs crates/markdown_parser/src/lib.rs
+git commit -S -m "feat(markdown_parser): extract footnote definitions from markdown source"
+git log -1 --show-signature
+```
+
+### Task 4.2: Reference rewriting + appended section
+
+**Files:**
+- Modify: `crates/markdown_parser/src/footnotes.rs`
+- Modify: `crates/markdown_parser/src/footnotes_tests.rs`
+
+- [ ] **Step 1: Add the failing tests**
+
+Append to `footnotes_tests.rs`:
+
+```rust
+use crate::{parse_markdown};
+
+#[test]
+fn rewrite_single_reference_appends_section() {
+ let parsed = parse_markdown("Some claim[^x].\n\n[^x]: Because reasons.\n")
+ .expect("parse");
+ // Expect: paragraph line with "Some claim" + "1" + "."; then hr; then ordered-list with content + " ↩"
+ let last_three: Vec<_> = parsed.lines.iter().rev().take(3).collect();
+ let (back, hr, list_or_paragraph) = (last_three[0], last_three[1], last_three[2]);
+ let _ = (back, hr, list_or_paragraph);
+ // Structural assertions:
+ assert!(parsed.lines.iter().any(|l| matches!(l, FormattedTextLine::HorizontalRule)));
+ let has_back_ref = parsed
+ .lines
+ .iter()
+ .filter_map(|line| match line {
+ FormattedTextLine::OrderedList(list) => Some(&list.indented_text.text),
+ _ => None,
+ })
+ .flatten()
+ .any(|f| f.text == " ↩" && matches!(&f.styles.hyperlink, Some(Hyperlink::Url(u)) if u.contains("fnref")));
+ assert!(has_back_ref, "expected back-reference fragment");
+ // The reference itself is now a hyperlink "1"
+ let reference_hyperlink_present = parsed
+ .lines
+ .iter()
+ .filter_map(|line| match line {
+ FormattedTextLine::Line(frags) => Some(frags),
+ _ => None,
+ })
+ .flatten()
+ .any(|f| f.text == "1" && matches!(&f.styles.hyperlink, Some(Hyperlink::Url(u)) if u == "#fn-x"));
+ assert!(reference_hyperlink_present, "expected #fn-x reference");
+}
+
+#[test]
+fn unused_definition_dropped() {
+ let parsed = parse_markdown("Plain text.\n\n[^never]: Unused.\n").expect("parse");
+ assert!(parsed.lines.iter().all(|l| !matches!(l, FormattedTextLine::HorizontalRule)));
+}
+
+#[test]
+fn undefined_reference_passes_through() {
+ let parsed = parse_markdown("Some claim[^missing] here.\n").expect("parse");
+ let joined: String = parsed
+ .lines
+ .iter()
+ .filter_map(|line| match line {
+ FormattedTextLine::Line(frags) => Some(frags.iter().map(|f| f.text.clone()).collect::()),
+ _ => None,
+ })
+ .collect();
+ assert!(joined.contains("[^missing]"), "expected literal pass-through: {joined:?}");
+}
+
+#[test]
+fn repeated_references_share_number() {
+ let parsed = parse_markdown("A[^x] B[^x]\n\n[^x]: D\n").expect("parse");
+ let line_fragments: Vec<_> = parsed
+ .lines
+ .iter()
+ .filter_map(|line| match line {
+ FormattedTextLine::Line(frags) => Some(frags),
+ _ => None,
+ })
+ .flatten()
+ .filter(|f| f.text == "1")
+ .count();
+ assert_eq!(line_fragments, 2, "both references should be number 1");
+}
+```
+
+Run and confirm FAIL.
+
+- [ ] **Step 2: Implement reference rewriting**
+
+Append to `crates/markdown_parser/src/footnotes.rs`:
+
+```rust
+/// Walk every inline fragment in `text` and rewrite occurrences of `[^id]` (for
+/// `id` present in `defs`) into a hyperlink fragment numbered in first-reference order.
+///
+/// Returns the rewritten text and a `FootnoteContext` populated with the
+/// definitions that were actually used (in numbered order).
+pub(crate) fn rewrite_references(
+ mut text: FormattedText,
+ defs: HashMap,
+) -> (FormattedText, FootnoteContext) {
+ let mut ctx = FootnoteContext {
+ definitions: defs,
+ numbers: HashMap::new(),
+ used: Vec::new(),
+ };
+
+ for line in text.lines.iter_mut() {
+ rewrite_line(line, &mut ctx);
+ }
+
+ (text, ctx)
+}
+
+fn rewrite_line(line: &mut FormattedTextLine, ctx: &mut FootnoteContext) {
+ let fragments = match line {
+ FormattedTextLine::Line(frags) => frags,
+ FormattedTextLine::Heading(h) => &mut h.text,
+ FormattedTextLine::OrderedList(list) => &mut list.indented_text.text,
+ FormattedTextLine::UnorderedList(list) => &mut list.text,
+ FormattedTextLine::TaskList(list) => &mut list.text,
+ _ => return,
+ };
+ rewrite_fragments(fragments, ctx);
+}
+
+fn rewrite_fragments(
+ fragments: &mut Vec,
+ ctx: &mut FootnoteContext,
+) {
+ let mut out: Vec = Vec::with_capacity(fragments.len());
+ for fragment in fragments.drain(..) {
+ if !fragment.text.contains("[^") || fragment.styles.inline_code {
+ out.push(fragment);
+ continue;
+ }
+ // Walk the fragment text and split out [^id] references.
+ let original_styles = fragment.styles.clone();
+ let mut remaining = fragment.text.as_str();
+ let mut buf = String::new();
+ while let Some(at) = remaining.find("[^") {
+ buf.push_str(&remaining[..at]);
+ let after = &remaining[at + 2..];
+ if let Some(close) = after.find(']') {
+ let id = &after[..close];
+ if !id.is_empty()
+ && !id.contains(char::is_whitespace)
+ && ctx.definitions.contains_key(id)
+ {
+ // Resolve.
+ if !buf.is_empty() {
+ out.push(FormattedTextFragment {
+ text: std::mem::take(&mut buf),
+ styles: original_styles.clone(),
+ });
+ }
+ let number = match ctx.numbers.get(id) {
+ Some(n) => *n,
+ None => {
+ let n = ctx.used.len() + 1;
+ ctx.numbers.insert(id.to_string(), n);
+ ctx.used.push(ctx.definitions[id].clone());
+ n
+ }
+ };
+ out.push(FormattedTextFragment {
+ text: number.to_string(),
+ styles: FormattedTextStyles {
+ italic: true,
+ hyperlink: Some(Hyperlink::Url(format!("#fn-{id}"))),
+ ..Default::default()
+ },
+ });
+ remaining = &after[close + 1..];
+ continue;
+ }
+ }
+ // Not a defined reference — emit the [^ literally and keep scanning.
+ buf.push_str("[^");
+ remaining = after;
+ }
+ buf.push_str(remaining);
+ if !buf.is_empty() {
+ out.push(FormattedTextFragment {
+ text: buf,
+ styles: original_styles,
+ });
+ }
+ }
+ *fragments = out;
+}
+
+/// Append a footnotes section to `text` based on `ctx.used`.
+pub(crate) fn append_section(text: &mut FormattedText, ctx: &FootnoteContext) {
+ if ctx.used.is_empty() {
+ return;
+ }
+ text.lines.push_back(FormattedTextLine::HorizontalRule);
+ for (index, def) in ctx.used.iter().enumerate() {
+ let number = index + 1;
+ let body_fragments = crate::parse_inline_markdown(&def.content);
+ let mut content_fragments: Vec = body_fragments.into_iter().collect();
+ content_fragments.push(FormattedTextFragment {
+ text: " ↩".to_string(),
+ styles: FormattedTextStyles {
+ hyperlink: Some(Hyperlink::Url(format!("#fnref-{}", def.id))),
+ ..Default::default()
+ },
+ });
+ text.lines
+ .push_back(FormattedTextLine::OrderedList(OrderedFormattedIndentTextInline {
+ number: Some(number),
+ indented_text: FormattedIndentTextInline {
+ indent_level: 0,
+ text: content_fragments,
+ },
+ }));
+ }
+}
+```
+
+- [ ] **Step 3: Wire the footnote pipeline into `parse_markdown_impl`**
+
+In `crates/markdown_parser/src/markdown_parser.rs`, change `parse_markdown_impl` to run the two passes:
+
+```rust
+fn parse_markdown_impl(markdown: &str, parse_gfm_tables: bool) -> Result {
+ let (stripped, defs) = crate::footnotes::extract_definitions(markdown);
+ let parsed = parse_markdown_internal::<'_, nom::error::Error<_>>(&stripped, parse_gfm_tables)
+ .map(|(_, mut res)| {
+ if let Some(FormattedTextLine::LineBreak) = res.last() {
+ res.pop();
+ }
+ FormattedText { lines: res.into() }
+ })
+ .map_err(|err| {
+ if cfg!(debug_assertions) {
+ anyhow::anyhow!("Failed to parse Markdown: {err}")
+ } else {
+ anyhow::anyhow!("Failed to parse Markdown")
+ }
+ })?;
+ let (mut rewritten, ctx) = crate::footnotes::rewrite_references(parsed, defs);
+ crate::footnotes::append_section(&mut rewritten, &ctx);
+ Ok(rewritten)
+}
+```
+
+- [ ] **Step 4: Run the footnote tests**
+
+```bash
+cargo test -p markdown_parser footnotes --quiet
+cargo test -p markdown_parser --quiet
+```
+Expected: all pass. If any existing test breaks because the footnote pipeline rewrites a fragment containing `[^x]` that's part of regular markdown (e.g. unrelated `^` usage), inspect and adjust: the `defs.contains_key(id)` gate protects against this — only defined ids get rewritten.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git branch --show-current
+./script/check_ai_attribution
+git add crates/markdown_parser/src/footnotes.rs crates/markdown_parser/src/footnotes_tests.rs crates/markdown_parser/src/markdown_parser.rs
+git commit -S -m "feat(markdown_parser): resolve footnote references and append section"
+git log -1 --show-signature
+```
+
+---
+
+## Phase 5 — Smoke test in CodeView
+
+### Task 5.1: Create the smoke fixture
+
+**Files:**
+- Create: `crates/markdown_parser/test-fixtures/gfm-smoketest.md`
+
+- [ ] **Step 1: Create the directory and file**
+
+```bash
+mkdir -p crates/markdown_parser/test-fixtures
+```
+
+Write `crates/markdown_parser/test-fixtures/gfm-smoketest.md`:
+
+````markdown
+# GFM Smoke Test
+
+This file is opened in CodeView's `.md` Rendered preview to confirm the GFM HTML
++ footnote work renders correctly. It is not a runnable test.
+
+## Inline HTML
+
+Press Cmd+K to clear. H2O reacts with E=mc2.
+This is important, this is old, and this is highlighted.
+
+## Block HTML
+
+
+Click to see commands
+
+Body text inside details.
+
+
+
+
+| Cmd | What |
|---|
+
+| build | Compile the project |
+| test | Run the test suite |
+
+
+
+## Mermaid
+
+```mermaid
+graph TD
+ A[Start] --> B{Decision}
+ B -->|Yes| C[Continue]
+ B -->|No| D[Stop]
+```
+
+## Footnotes
+
+A claim with a footnote.[^why] And another reference to the same one.[^why]
+And a separate footnote.[^how]
+
+[^why]: Because the spec says so.
+[^how]: With a hand-rolled two-pass parser.
+
+## Stripped
+
+
+This text appears.
+
+## Existing GFM (regression baseline)
+
+- [ ] Task list works
+- [x] So does this one
+- ~~strikethrough~~
+- A bare URL: https://github.com
+- A pipe table:
+
+| Col A | Col B |
+|-------|-------|
+| 1 | 2 |
+````
+
+- [ ] **Step 2: Commit**
+
+```bash
+git branch --show-current
+./script/check_ai_attribution
+git add crates/markdown_parser/test-fixtures/gfm-smoketest.md
+git commit -S -m "test(markdown_parser): add gfm smoketest fixture for codeview preview"
+git log -1 --show-signature
+```
+
+### Task 5.2: Run the app, open the fixture, verify
+
+**Files:** none modified.
+
+- [ ] **Step 1: Build the app**
+
+Run:
+```bash
+cargo build -p warp-app --bin cast-codes
+```
+Expected: build succeeds. The package name is `warp-app` (per `app/Cargo.toml:7`); the OSS binary is `cast-codes` (per `default-run` on line 3). If the build fails, follow the existing `castcodes-dev-loop` skill guidance.
+
+- [ ] **Step 2: Launch and open the fixture**
+
+```bash
+cargo run -p warp-app --bin cast-codes -- crates/markdown_parser/test-fixtures/gfm-smoketest.md
+```
+
+If the binary does not accept a file path positional argument, launch without args and open the file via the CodeView open-file affordance instead.
+
+In the app:
+1. The file opens in CodeView.
+2. Click the **Rendered** segmented control toggle in the file header (created by `update_markdown_mode_segmented_control` in `app/src/code/view.rs:299`).
+
+- [ ] **Step 3: Visual checks**
+
+Confirm each of:
+
+| Section | Expected |
+|---|---|
+| `# GFM Smoke Test` | Renders as an H1. |
+| `Cmd+K` | Each key label rendered as an inline-code chip. |
+| `H2O` and `mc2` | The `2` characters are italicized; rest is plain text. |
+| `important` | Underlined. |
+| `old` | Strikethrough. |
+| `highlighted` | Plain text (v1 has no highlight style). |
+| `` block | First line shows `▾ Click to see commands`; body paragraph follows immediately below. |
+| `` block | Renders as a 2-column table with the same headers and rows as a pipe table would. |
+| Mermaid block | Renders as an SVG (this is the verification step — no code expected to change). If it shows the placeholder text indefinitely or shows the raw text, capture a screenshot and STOP. |
+| Footnotes section | A horizontal rule appears below the document, followed by an ordered list (`1.`, `2.`). The numeric `1` and `2` in the body are styled (italic + hyperlink). The list items end with ` ↩`. |
+| `
+This text appears.
+
+## Existing GFM (regression baseline)
+
+- [ ] Task list works
+- [x] So does this one
+- ~~strikethrough~~
+- A bare URL: https://github.com
+- A pipe table:
+
+| Col A | Col B |
+|-------|-------|
+| 1 | 2 |
From 07d7351c345984fc3f00cdab8ae15cbac38722ab Mon Sep 17 00:00:00 2001
From: Val Alexander <68980965+BunsDev@users.noreply.github.com>
Date: Wed, 20 May 2026 10:44:39 -0500
Subject: [PATCH 12/18] docs(design-changes): record gfm html and footnote
preview support
---
DESIGN-CHANGES.md | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/DESIGN-CHANGES.md b/DESIGN-CHANGES.md
index 8916e7b5c..620d08dd9 100644
--- a/DESIGN-CHANGES.md
+++ b/DESIGN-CHANGES.md
@@ -46,6 +46,17 @@ crates.
## Applied (this PR)
+### GitHub-Flavored Markdown preview
+
+CodeView's `.md` Rendered preview now renders the GFM HTML safe-list
+(``, ``, ``, ``, ``, ``, raw ``,
+`![]()
`, plus inline phrasing tags) and GFM footnotes (`[^id]` references with
+`[^id]:` definitions). `` blocks render always-expanded with a `▾`
+glyph; interactive collapse is not provided in v1. Mermaid blocks render as
+SVG diagrams in the preview, unchanged from prior behavior. Inline HTML is
+parsed via the existing `html5ever` pipeline in `markdown_parser`; no new
+dependencies were added.
+
### Brand rebrand sweep
- `app/src/drive/index.rs:109` — `WARP_DRIVE_TITLE` literal updated from
From 89019b634e55909adb053873460aba81ac81b75d Mon Sep 17 00:00:00 2001
From: Val Alexander <68980965+BunsDev@users.noreply.github.com>
Date: Wed, 20 May 2026 10:48:21 -0500
Subject: [PATCH 13/18] chore(markdown_parser): drop unused HtmlSpan and
FootnoteContext helpers
---
crates/markdown_parser/src/footnotes.rs | 10 ----------
crates/markdown_parser/src/gfm_html.rs | 12 ------------
crates/markdown_parser/src/gfm_html_tests.rs | 2 +-
3 files changed, 1 insertion(+), 23 deletions(-)
diff --git a/crates/markdown_parser/src/footnotes.rs b/crates/markdown_parser/src/footnotes.rs
index aaf41d17a..d4cba5f0e 100644
--- a/crates/markdown_parser/src/footnotes.rs
+++ b/crates/markdown_parser/src/footnotes.rs
@@ -31,16 +31,6 @@ pub(crate) struct FootnoteContext {
pub(crate) used: Vec,
}
-impl FootnoteContext {
- pub(crate) fn empty() -> Self {
- Self {
- definitions: HashMap::new(),
- numbers: HashMap::new(),
- used: Vec::new(),
- }
- }
-}
-
/// Strip footnote definitions from the source. Returns the source minus the
/// definition lines and the collected definition map.
pub(crate) fn extract_definitions(source: &str) -> (String, HashMap) {
diff --git a/crates/markdown_parser/src/gfm_html.rs b/crates/markdown_parser/src/gfm_html.rs
index 6554fb6e7..399228112 100644
--- a/crates/markdown_parser/src/gfm_html.rs
+++ b/crates/markdown_parser/src/gfm_html.rs
@@ -44,18 +44,6 @@ pub(crate) struct HtmlSpan<'a> {
pub(crate) kind: HtmlSpanKind,
}
-impl HtmlSpan<'_> {
- pub(crate) fn is_block(&self) -> bool {
- matches!(self.kind, HtmlSpanKind::BlockSafe)
- }
- pub(crate) fn is_phrasing(&self) -> bool {
- matches!(self.kind, HtmlSpanKind::PhrasingSafe)
- }
- pub(crate) fn is_stripped(&self) -> bool {
- matches!(self.kind, HtmlSpanKind::Stripped)
- }
-}
-
pub(crate) fn classify(tag: &str) -> HtmlSpanKind {
let lower = tag.to_ascii_lowercase();
if PHRASING_SAFE_TAGS.iter().any(|t| *t == lower) {
diff --git a/crates/markdown_parser/src/gfm_html_tests.rs b/crates/markdown_parser/src/gfm_html_tests.rs
index 23d818449..dd9a9a5e5 100644
--- a/crates/markdown_parser/src/gfm_html_tests.rs
+++ b/crates/markdown_parser/src/gfm_html_tests.rs
@@ -48,7 +48,7 @@ fn lex_missing_close_returns_open_only() {
#[test]
fn lex_comment_stripped() {
let (span, rest) = try_lex_html_span("after").unwrap();
- assert!(span.is_stripped());
+ assert_eq!(span.kind, HtmlSpanKind::Stripped);
assert_eq!(rest, "after");
}
From 2f68db5be75f840fe7d5d8477758847dae778f87 Mon Sep 17 00:00:00 2001
From: Val Alexander <68980965+BunsDev@users.noreply.github.com>
Date: Wed, 20 May 2026 11:01:25 -0500
Subject: [PATCH 14/18] fix(markdown_parser): inline
emits hard break +
review nits
---
crates/markdown_parser/src/gfm_html.rs | 7 +++++--
crates/markdown_parser/src/html_parser.rs | 13 +++++++++++--
crates/markdown_parser/src/markdown_parser.rs | 2 --
.../src/markdown_parser_tests.rs | 17 +++++++++--------
4 files changed, 25 insertions(+), 14 deletions(-)
diff --git a/crates/markdown_parser/src/gfm_html.rs b/crates/markdown_parser/src/gfm_html.rs
index 399228112..a72949b89 100644
--- a/crates/markdown_parser/src/gfm_html.rs
+++ b/crates/markdown_parser/src/gfm_html.rs
@@ -63,8 +63,11 @@ pub(crate) fn try_lex_html_span(input: &str) -> Option<(HtmlSpan<'_>, &str)> {
return None;
}
// HTML comment:
- if input.starts_with("").map(|i| i + 4 + 3).unwrap_or(input.len());
+ if let Some(after_open) = input.strip_prefix("")
+ .map(|i| input.len() - after_open.len() + i + 3)
+ .unwrap_or(input.len());
return Some((
HtmlSpan { raw: &input[..end], tag: "", kind: HtmlSpanKind::Stripped },
&input[end..],
diff --git a/crates/markdown_parser/src/html_parser.rs b/crates/markdown_parser/src/html_parser.rs
index 3396c9511..d56eb2296 100644
--- a/crates/markdown_parser/src/html_parser.rs
+++ b/crates/markdown_parser/src/html_parser.rs
@@ -127,8 +127,9 @@ fn type_matches(attributes: &[Attribute], value: &str) -> bool {
/// Parse an HTML fragment and return its block-level lines.
///
/// Used by the markdown parser when it encounters a block-level HTML span in a `.md` file.
-/// Unlike `parse_html`, this assumes the caller already classified the span as block-level
-/// and does not perform any top-level element skipping.
+/// Delegates to `parse_html`, which top-level-skips wrapper elements like ``, ``,
+/// ``, ``. Those tags are not in the GFM safe-list, so the skipping is benign
+/// for the markdown→HTML dispatch path.
pub(crate) fn parse_html_block_lines(html: &str) -> Vec {
parse_html(html)
.map(|formatted| formatted.lines.into_iter().collect())
@@ -548,6 +549,14 @@ fn parse_phrasing_content(nodes: &[Rc], text_styling: Styling) -> Formatte
}
NodeData::Element { name, attrs, .. } => {
let node_name = name.local.to_string();
+ // `
` in inline context emits a hard line break as a `\n`
+ // text fragment so adjacent text stays visually separated.
+ // Block-context `
` is handled by the per-element dispatch
+ // in `parse_html` and produces `FormattedTextLine::LineBreak`.
+ if node_name.as_str() == "br" {
+ result.push(phrasing_to_formatted_text("\n", &text_styling));
+ continue;
+ }
let mut decorated_styling = text_styling.clone();
decorated_styling.update_with_attributes(&attrs.borrow());
match node_name.as_ref() {
diff --git a/crates/markdown_parser/src/markdown_parser.rs b/crates/markdown_parser/src/markdown_parser.rs
index d3e446b46..c4adf82ce 100644
--- a/crates/markdown_parser/src/markdown_parser.rs
+++ b/crates/markdown_parser/src/markdown_parser.rs
@@ -1320,8 +1320,6 @@ fn parse_link_target<'a, E: ContextError<&'a str> + ParseError<&'a str>>(
Ok((input, target))
}
-/// Parses underlined text using the same logic as parse_link.
-
/// Process emphasis delimiters on the state's delimiter stack, bounded by `stack_bottom`.
///
/// This is approximately equivalent to the CommonMark [process emphasis](https://spec.commonmark.org/0.30/#phase-2-inline-structure)
diff --git a/crates/markdown_parser/src/markdown_parser_tests.rs b/crates/markdown_parser/src/markdown_parser_tests.rs
index b76c17bf7..ec8f8d051 100644
--- a/crates/markdown_parser/src/markdown_parser_tests.rs
+++ b/crates/markdown_parser/src/markdown_parser_tests.rs
@@ -2825,14 +2825,15 @@ fn test_parse_inline_html_unknown_tag_passes_through() {
fn test_parse_inline_html_br_emits_linebreak() {
let source = "before
after";
let parsed = test_parse_markdown(source);
- // The HTML helper emits the
as a LineBreak line, then "after" as a
- // continuation. Joined raw text should reflect the break.
- let joined = parsed
- .iter()
- .map(|line| line.raw_text())
- .collect::();
- assert!(joined.contains("before"));
- assert!(joined.contains("after"));
+ let line = match parsed.first() {
+ Some(FormattedTextLine::Line(fragments)) => fragments,
+ other => panic!("expected single Line, got {other:?}"),
+ };
+ // Inline
emits a "\n" text fragment between "before" and "after"
+ // so the two halves aren't visually smashed together. (Block-context
+ //
, handled by parse_html, produces FormattedTextLine::LineBreak.)
+ let joined: String = line.iter().map(|f| f.text.clone()).collect();
+ assert_eq!(joined, "before\nafter", "got {joined:?}");
}
#[test]
From 3ae55a99fdc65473ecaa9433fcf46eef5cd8950b Mon Sep 17 00:00:00 2001
From: Val Alexander
Date: Wed, 20 May 2026 13:39:52 -0500
Subject: [PATCH 15/18] Potential fix for pull request finding
Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
crates/markdown_parser/src/gfm_html.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/crates/markdown_parser/src/gfm_html.rs b/crates/markdown_parser/src/gfm_html.rs
index a72949b89..11dd8e498 100644
--- a/crates/markdown_parser/src/gfm_html.rs
+++ b/crates/markdown_parser/src/gfm_html.rs
@@ -39,7 +39,7 @@ pub(crate) struct HtmlSpan<'a> {
/// The entire matched span, including `` … `` (or just the open tag if
/// self-closing or unmatched).
pub(crate) raw: &'a str,
- /// Lowercased tag name.
+ /// Tag name as matched in the input, preserving the original case.
pub(crate) tag: &'a str,
pub(crate) kind: HtmlSpanKind,
}
From 3b8f896633464b8a9a78d11d14440090f792e79c Mon Sep 17 00:00:00 2001
From: Val Alexander
Date: Wed, 20 May 2026 13:50:36 -0500
Subject: [PATCH 16/18] Potential fix for pull request finding
Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
crates/markdown_parser/src/html_parser.rs | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/crates/markdown_parser/src/html_parser.rs b/crates/markdown_parser/src/html_parser.rs
index d56eb2296..46f6cf0e5 100644
--- a/crates/markdown_parser/src/html_parser.rs
+++ b/crates/markdown_parser/src/html_parser.rs
@@ -127,9 +127,9 @@ fn type_matches(attributes: &[Attribute], value: &str) -> bool {
/// Parse an HTML fragment and return its block-level lines.
///
/// Used by the markdown parser when it encounters a block-level HTML span in a `.md` file.
-/// Delegates to `parse_html`, which top-level-skips wrapper elements like ``, ``,
-/// ``, ``. Those tags are not in the GFM safe-list, so the skipping is benign
-/// for the markdown→HTML dispatch path.
+/// Delegates to `parse_html`, inheriting its behavior of skipping certain top-level wrapper
+/// or container elements when extracting block lines. This helper intentionally preserves that
+/// behavior for the markdown→HTML dispatch path.
pub(crate) fn parse_html_block_lines(html: &str) -> Vec {
parse_html(html)
.map(|formatted| formatted.lines.into_iter().collect())
From 080171be36c70b9acb955d54519968180503202f Mon Sep 17 00:00:00 2001
From: Val Alexander
Date: Wed, 20 May 2026 13:51:03 -0500
Subject: [PATCH 17/18] Potential fix for pull request finding
Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
crates/markdown_parser/src/footnotes.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/crates/markdown_parser/src/footnotes.rs b/crates/markdown_parser/src/footnotes.rs
index d4cba5f0e..69afdf2b9 100644
--- a/crates/markdown_parser/src/footnotes.rs
+++ b/crates/markdown_parser/src/footnotes.rs
@@ -154,7 +154,7 @@ fn rewrite_fragments(
styles: FormattedTextStyles {
italic: true,
hyperlink: Some(Hyperlink::Url(format!("#fn-{id}"))),
- ..Default::default()
+ ..original_styles.clone()
},
});
remaining = &after[close + 1..];
From c39adcd88a6a781226a08abca970fec49fbeb7fc Mon Sep 17 00:00:00 2001
From: Val Alexander <68980965+BunsDev@users.noreply.github.com>
Date: Wed, 20 May 2026 13:58:22 -0500
Subject: [PATCH 18/18] fix(markdown_parser): preserve close-only html tags
---
crates/markdown_parser/src/markdown_parser.rs | 16 ++++++++++------
.../markdown_parser/src/markdown_parser_tests.rs | 12 ++++++++++++
2 files changed, 22 insertions(+), 6 deletions(-)
diff --git a/crates/markdown_parser/src/markdown_parser.rs b/crates/markdown_parser/src/markdown_parser.rs
index c4adf82ce..2fd3f9cdd 100644
--- a/crates/markdown_parser/src/markdown_parser.rs
+++ b/crates/markdown_parser/src/markdown_parser.rs
@@ -1638,9 +1638,10 @@ fn parse_inline_token_link_end<'a, E: ContextError<&'a str> + ParseError<&'a str
///
/// Checks (in order):
/// 1. The span must contain `>` (the open tag was properly closed).
-/// 2. The character immediately after the tag name must be a valid separator:
+/// 2. Close-only tags are rejected so they fall through to literal text parsing.
+/// 3. The character immediately after the tag name must be a valid separator:
/// whitespace, `>`, or `/`. This rejects malformed tags like ``.
-/// 3. For non-void, non-self-closing open tags, the span must contain a matching
+/// 4. For non-void, non-self-closing open tags, the span must contain a matching
/// close tag (`` are not
/// consumed as complete spans — they fall through to literal-text parsing.
fn is_well_formed_html_span(raw: &str) -> bool {
@@ -1649,8 +1650,11 @@ fn is_well_formed_html_span(raw: &str) -> bool {
}
let bytes = raw.as_bytes();
let is_close_tag = bytes.get(1) == Some(&b'/');
- // Skip `<` and optional `/` for close tags.
- let name_start = if is_close_tag { 2 } else { 1 };
+ if is_close_tag {
+ return false;
+ }
+ // Skip `<`.
+ let name_start = 1;
// Advance through the tag name.
let mut i = name_start;
while i < bytes.len() && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'-') {
@@ -1661,8 +1665,8 @@ fn is_well_formed_html_span(raw: &str) -> bool {
if !matches!(bytes.get(i), Some(b' ' | b'\t' | b'\n' | b'\r' | b'>' | b'/') | None) {
return false;
}
- // Close tags and self-closing tags are already complete.
- if is_close_tag || raw.ends_with("/>") {
+ // Self-closing tags are already complete.
+ if raw.ends_with("/>") {
return true;
}
// Void elements are inherently self-contained.
diff --git a/crates/markdown_parser/src/markdown_parser_tests.rs b/crates/markdown_parser/src/markdown_parser_tests.rs
index ec8f8d051..954b1bafc 100644
--- a/crates/markdown_parser/src/markdown_parser_tests.rs
+++ b/crates/markdown_parser/src/markdown_parser_tests.rs
@@ -2821,6 +2821,18 @@ fn test_parse_inline_html_unknown_tag_passes_through() {
assert_eq!(joined, "bar");
}
+#[test]
+fn test_parse_inline_html_close_only_tag_passes_through() {
+ let source = "before after";
+ let parsed = test_parse_markdown(source);
+ let line = match parsed.first() {
+ Some(FormattedTextLine::Line(line)) => line,
+ other => panic!("expected Line, got {other:?}"),
+ };
+ let joined: String = line.iter().map(|f| f.text.clone()).collect();
+ assert_eq!(joined, "before after");
+}
+
#[test]
fn test_parse_inline_html_br_emits_linebreak() {
let source = "before
after";
"#;
+ let parsed = parse_html(html).expect("HTML should parse");
+ let image = parsed
+ .lines
+ .iter()
+ .find_map(|line| match line {
+ FormattedTextLine::Image(img) => Some(img),
+ _ => None,
+ })
+ .expect("expected an Image line");
+ assert_eq!(image.source, "cat.png");
+ assert_eq!(image.alt_text, "A cat");
+}
+
+#[test]
+fn test_parse_html_phrasing_tags() {
+ let html = "