Improve DomBuilder/Viewer: unify links, fix HardBreak, remove dead code

- Extract register_link() helper to unify link reflect/focus logic
  between build_link (standalone) and collect_inline_words (inline)
- Fix HardBreak rendering: split paragraphs at HardBreak boundaries
  into separate flexbox rows instead of emitting literal "\n"
- Use string_view in build_code_block to avoid full-string copy
- Delete move constructors on Viewer/Editor (prevent dangling refs)
- Add Viewer cache invalidation for builder config changes
- Remove dead StrongEmphasis enum value (cmark never produces it)
- Document component() lifecycle contract in both headers

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

Author: zvasilev

docs/api-reference.md

@@ -18,7 +18,6 @@ enum class NodeType {
     Text,            // Leaf text content
     Emphasis,        // Italic (*text* or _text_)
     Strong,          // Bold (**text** or __text__)
-    StrongEmphasis,  // Bold + italic (***text***)
     Link,            // Hyperlink [text](url)
     ListItem,        // Single list item
     BulletList,      // Unordered list container
@@ -480,7 +479,6 @@ for (auto const& link : builder.link_targets()) {
 | Heading (level 3+) | `theme.heading3` decorator (default: bold + dim) |
 | Strong | `ftxui::bold` |
 | Emphasis | `ftxui::italic` (where supported) |
-| StrongEmphasis | `ftxui::bold` (italic not always combined) |
 | Link | `ftxui::underlined` + `theme.link` + `ftxui::reflect()` for boxes |
 | Link (focused) | adds `ftxui::inverted` + `ftxui::focus` |
 | BulletList | `"  * "` prefix per item, indentation for nesting |

docs/architecture.md

@@ -94,7 +94,7 @@ A recursive tree structure representing parsed Markdown. Each node has a `NodeTy
               └── Text ("item two")
 ```
 
-Supported node types (18 total): Document, Heading, Paragraph, Text, Emphasis, Strong, StrongEmphasis, Link, ListItem, BulletList, OrderedList, CodeInline, CodeBlock, BlockQuote, SoftBreak, HardBreak, ThematicBreak, Image.
+Supported node types (17 total): Document, Heading, Paragraph, Text, Emphasis, Strong, Link, ListItem, BulletList, OrderedList, CodeInline, CodeBlock, BlockQuote, SoftBreak, HardBreak, ThematicBreak, Image.
 
 ### DomBuilder (`dom_builder.hpp`)
 

docs/testing.md

@@ -94,7 +94,7 @@ Tests are grouped in blocks within `main()`. Each block is independent and can b
 | `test_headings.cpp` | Headings H1-H6: correct `NodeType::Heading`, `level` field, bold/dim decorators in rendered output. |
 | `test_bold.cpp` | `**bold**` and `__bold__`: AST produces `NodeType::Strong`, rendered output contains bold text. |
 | `test_italic.cpp` | `*italic*` and `_italic_`: AST produces `NodeType::Emphasis`, rendered output contains italic text. |
-| `test_bold_italic.cpp` | `***bold italic***` and mixed nesting: AST produces `NodeType::StrongEmphasis` or nested Strong/Emphasis. |
+| `test_bold_italic.cpp` | `***bold italic***` and mixed nesting: AST produces nested Strong/Emphasis nodes. |
 | `test_links.cpp` | `[text](url)`: AST structure, URL extraction, link nesting with bold/italic, DomBuilder link_targets(). |
 | `test_lists.cpp` | `- item` unordered lists: AST structure, bullet prefix rendering, list item content. |
 | `test_code.cpp` | `` `inline code` ``: AST produces `NodeType::CodeInline`, inverted rendering in output. |

markdown/include/markdown/ast.hpp

@@ -12,7 +12,6 @@ enum class NodeType {
     Text,
     Emphasis,
     Strong,
-    StrongEmphasis,
     Link,
     ListItem,
     BulletList,

markdown/include/markdown/editor.hpp

@@ -13,7 +13,13 @@ namespace markdown {
 class Editor {
 public:
     explicit Editor();
+    Editor(Editor&&) = delete;
+    Editor& operator=(Editor&&) = delete;
 
+    /// Returns the FTXUI component. Created on first call, cached thereafter.
+    /// Configure the object (set_content, set_theme, etc.) before OR after
+    /// this call — the renderer reads live state each frame.
+    /// However, do not move this object after calling component().
     ftxui::Component component();
 
     std::string const& content() const;

markdown/include/markdown/viewer.hpp

@@ -23,6 +23,8 @@ struct ExternalFocusable {
 class Viewer {
 public:
     explicit Viewer(std::unique_ptr<MarkdownParser> parser);
+    Viewer(Viewer&&) = delete;
+    Viewer& operator=(Viewer&&) = delete;
 
     void set_content(std::string_view markdown_text);
     void set_scroll(float ratio);
@@ -32,9 +34,16 @@ class Viewer {
     void set_theme(Theme const& theme) {
         if (_theme.name != theme.name) { _theme = theme; ++_theme_gen; }
     }
-    void set_max_quote_depth(int d) { _builder.set_max_quote_depth(d); }
+    void set_max_quote_depth(int d) {
+        _builder.set_max_quote_depth(d);
+        ++_builder_gen;
+    }
     int max_quote_depth() const { return _builder.max_quote_depth(); }
 
+    /// Returns the FTXUI component. Created on first call, cached thereafter.
+    /// Configure the object (set_content, set_theme, on_link_click, etc.)
+    /// before OR after this call — the renderer reads live state each frame.
+    /// However, do not move this object after calling component().
     ftxui::Component component();
     bool active() const { return _active; }
     void set_active(bool a) { _active = a; }
@@ -79,6 +88,8 @@ class Viewer {
     Theme _theme{theme_default()};
     uint64_t _theme_gen = 0;
     uint64_t _built_theme_gen = 0;
+    uint64_t _builder_gen = 0;
+    uint64_t _built_builder_gen = 0;
     std::function<void(std::string const&, LinkEvent)> _link_callback;
     ftxui::Component _component;
     std::vector<ExternalFocusable> _externals;

markdown/src/dom_builder.cpp

@@ -1,5 +1,7 @@
 #include "markdown/dom_builder.hpp"
 
+#include <string_view>
+
 #include <ftxui/dom/flexbox_config.hpp>
 
 namespace markdown {
@@ -44,6 +46,22 @@ ftxui::Decorator link_style(bool is_focused, ftxui::Decorator base,
     return base | ftxui::underlined | theme.link;
 }
 
+// Register a link: create a LinkTarget, wrap each element in elems[from..]
+// with reflect for click detection, and apply focus to the first element.
+void register_link(Links& links, ftxui::Elements& elems, size_t from,
+                   std::string const& url, bool is_focused) {
+    links.emplace_back(LinkTarget{.url = url});
+    auto& target = links.back();
+    size_t count = elems.size() - from;
+    target.boxes.resize(count);
+    for (size_t i = from; i < elems.size(); ++i) {
+        elems[i] = elems[i] | ftxui::reflect(target.boxes[i - from]);
+    }
+    if (is_focused && count > 0) {
+        elems[from] = elems[from] | ftxui::focus;
+    }
+}
+
 ftxui::Element build_node(ASTNode const& node, int depth, int qd,
                           Links& links, int focused_link,
                           Theme const& theme);
@@ -107,7 +125,8 @@ void collect_inline_words(ASTNode const& node, int depth, int qd,
             break;
         }
         case NodeType::SoftBreak:
-            break; // flexbox gap handles spacing
+        case NodeType::HardBreak:
+            break; // handled by build_wrapping_container (HardBreak splits rows)
         case NodeType::Strong:
             collect_inline_words(child, depth + 1, qd, words,
                                  style | ftxui::bold, links, focused_link,
@@ -121,23 +140,10 @@ void collect_inline_words(ASTNode const& node, int depth, int qd,
         case NodeType::Link: {
             bool is_focused = is_next_link_focused(links, focused_link);
             auto ls = link_style(is_focused, style, theme);
-            // Collect link words with underline, then wrap in reflect
             size_t before = words.size();
             collect_inline_words(child, depth + 1, qd, words,
                                  ls, links, focused_link, theme);
-            // Wrap every word of this link with reflect for click detection
-            links.emplace_back(LinkTarget{.url = child.url});
-            auto& target = links.back();
-            size_t word_count = words.size() - before;
-            target.boxes.resize(word_count);
-            bool first_word = true;
-            for (size_t i = before; i < words.size(); ++i) {
-                words[i] = words[i] | ftxui::reflect(target.boxes[i - before]);
-                if (is_focused && first_word) {
-                    words[i] = words[i] | ftxui::focus;
-                    first_word = false;
-                }
-            }
+            register_link(links, words, before, child.url, is_focused);
             break;
         }
         case NodeType::CodeInline:
@@ -162,8 +168,25 @@ bool is_plain_text_paragraph(ASTNode const& node) {
     return true;
 }
 
+// Check if a node contains any HardBreak children.
+bool has_hard_break(ASTNode const& node) {
+    for (auto const& child : node.children) {
+        if (child.type == NodeType::HardBreak) return true;
+    }
+    return false;
+}
+
+// Build a flexbox row from a flat list of word elements.
+ftxui::Element words_to_element(ftxui::Elements& words) {
+    static const auto wrap_config = ftxui::FlexboxConfig().SetGap(1, 0);
+    if (words.empty()) return ftxui::text("");
+    if (words.size() == 1) return std::move(words[0]);
+    return ftxui::flexbox(std::move(words), wrap_config);
+}
+
 // Wrapping version of build_inline_container for block-level paragraphs.
 // Splits all inline content into word-level flexbox items for line wrapping.
+// HardBreak nodes force a new line by splitting into separate flexbox rows.
 ftxui::Element build_wrapping_container(ASTNode const& node, int depth, int qd,
                                         Links& links, int focused_link,
                                         Theme const& theme) {
@@ -186,13 +209,41 @@ ftxui::Element build_wrapping_container(ASTNode const& node, int depth, int qd,
         return ftxui::paragraph(combined);
     }
 
-    static const auto wrap_config = ftxui::FlexboxConfig().SetGap(1, 0);
-    ftxui::Elements words;
-    collect_inline_words(node, depth, qd, words, ftxui::nothing, links,
-                         focused_link, theme);
-    if (words.empty()) return ftxui::text("");
-    if (words.size() == 1) return std::move(words[0]);
-    return ftxui::flexbox(std::move(words), wrap_config);
+    // If no hard breaks, single flexbox row (common case).
+    if (!has_hard_break(node)) {
+        ftxui::Elements words;
+        collect_inline_words(node, depth, qd, words, ftxui::nothing, links,
+                             focused_link, theme);
+        return words_to_element(words);
+    }
+
+    // Split at HardBreak boundaries: each segment becomes its own row.
+    // Build a temporary ASTNode per segment and collect words from it.
+    ftxui::Elements rows;
+    ASTNode segment{.type = node.type};
+    auto flush_segment = [&] {
+        if (segment.children.empty()) {
+            rows.push_back(ftxui::text(""));
+            return;
+        }
+        ftxui::Elements words;
+        collect_inline_words(segment, depth, qd, words, ftxui::nothing,
+                             links, focused_link, theme);
+        rows.push_back(words_to_element(words));
+        segment.children.clear();
+    };
+
+    for (auto const& child : node.children) {
+        if (child.type == NodeType::HardBreak) {
+            flush_segment();
+        } else {
+            segment.children.push_back(child);
+        }
+    }
+    flush_segment();
+
+    if (rows.size() == 1) return std::move(rows[0]);
+    return ftxui::vbox(std::move(rows));
 }
 
 // Build a ListItem: first Paragraph gets bullet/number prefix,
@@ -261,10 +312,10 @@ ftxui::Element build_link(ASTNode const& node, int depth, int qd,
     auto el = build_inline_container(node, depth, qd, links, focused_link,
                                      theme)
         | link_style(is_focused, ftxui::nothing, theme);
-    if (is_focused) el = el | ftxui::focus;
-    links.emplace_back(LinkTarget{.url = node.url});
-    links.back().boxes.emplace_back();
-    return el | ftxui::reflect(links.back().boxes.back());
+    ftxui::Elements elems;
+    elems.push_back(std::move(el));
+    register_link(links, elems, 0, node.url, is_focused);
+    return std::move(elems[0]);
 }
 
 ftxui::Element build_bullet_list(ASTNode const& node, int depth, int qd,
@@ -307,17 +358,18 @@ ftxui::Element build_blockquote(ASTNode const& node, int depth, int qd,
 }
 
 ftxui::Element build_code_block(ASTNode const& node, Theme const& theme) {
-    std::string code = node.text;
-    if (!code.empty() && code.back() == '\n') code.pop_back();
+    std::string_view code = node.text;
+    if (!code.empty() && code.back() == '\n') code.remove_suffix(1);
     ftxui::Elements lines;
     size_t start = 0;
     while (start <= code.size()) {
         auto end = code.find('\n', start);
-        if (end == std::string::npos) {
-            lines.push_back(ftxui::text(code.substr(start)));
+        if (end == std::string_view::npos) {
+            lines.push_back(ftxui::text(std::string(code.substr(start))));
             break;
         }
-        lines.push_back(ftxui::text(code.substr(start, end - start)));
+        lines.push_back(
+            ftxui::text(std::string(code.substr(start, end - start))));
         start = end + 1;
     }
     if (lines.empty()) lines.push_back(ftxui::text(""));
@@ -382,7 +434,7 @@ ftxui::Element build_node(ASTNode const& node, int depth, int qd,
     case NodeType::SoftBreak:
         return ftxui::text(" ");
     case NodeType::HardBreak:
-        return ftxui::text("\n");
+        return ftxui::text("");
     default:
         return ftxui::text(node.text);
     }

markdown/src/viewer.cpp

@@ -231,15 +231,17 @@ ftxui::Component Viewer::component() {
         }
         _focused_link = (_focus_index >= ext_n) ? _focus_index - ext_n : -1;
 
-        // Rebuild element when content, focused link, or theme changes
+        // Rebuild element when content, focused link, theme, or builder config changes
         if (_parsed_gen != _built_gen ||
             _focused_link != _last_focused_link ||
-            _theme_gen != _built_theme_gen) {
+            _theme_gen != _built_theme_gen ||
+            _builder_gen != _built_builder_gen) {
             _cached_element = _builder.build(_cached_ast, _focused_link,
                                              _theme);
             _built_gen = _parsed_gen;
             _last_focused_link = _focused_link;
             _built_theme_gen = _theme_gen;
+            _built_builder_gen = _builder_gen;
         }
         auto el = _cached_element;