termrender 0.7.2__tar.gz → 0.8.0__tar.gz

{termrender-0.7.2 → termrender-0.8.0}/CHANGELOG.md

@@ -1,6 +1,39 @@
 # CHANGELOG
 
 
+## v0.8.0 (2026-04-18)
+
+### Features
+
+- **mermaid**: Preprocess sequence diagrams for mermaid-ascii compatibility
+  ([`a642576`](https://github.com/CaptainCrouton89/termrender/commit/a642576d41d5dbde372d7de2ab47745296a78e32))
+
+mermaid-ascii only parses ->> / -->> arrows, participants, and self-loops; every other common
+  sequence-diagram construct made it fail and fall back to raw source. Rewrite Note lines into
+  self-loops, map -> / -x / --x / -) / --) / -- > onto the supported arrow pair, drop block keywords
+  (loop/alt/activate/ autonumber/end/…), and flatten <br/> to ' / '. Non-sequence diagrams pass
+  through unchanged.
+
+
+## v0.7.3 (2026-04-15)
+
+### Bug Fixes
+
+- **code**: Wrap long code lines to fit layout width
+  ([`31c6e59`](https://github.com/CaptainCrouton89/termrender/commit/31c6e595a438c4ced8c61fff679b59d4ae55f938))
+
+Code blocks previously used raw line count for height and let render_box grow beyond the layout
+  allocation. Now wraps source lines to the available content width in both layout and renderer.
+
+- **parser**: Add directive trace and file-absolute line numbers to error messages
+  ([`0f99ea0`](https://github.com/CaptainCrouton89/termrender/commit/0f99ea0310116f8fa06e933cd26126246d7a3b43))
+
+Stray-closer and unclosed-directive errors now print the full open/close trace and, when nested
+  directives share a colon count, name the specific cause and suggest the fix. Recursive body
+  parsing reports file-absolute line numbers via _line_offset threading through parse →
+  _split_directives → _directive_to_block.
+
+
 ## v0.7.2 (2026-04-09)
 
 ### Bug Fixes

{termrender-0.7.2 → termrender-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 0.7.2
+Version: 0.8.0
 Summary: Rich terminal rendering of directive-flavored markdown
 Project-URL: Homepage, https://github.com/CaptainCrouton89/termrender
 Project-URL: Repository, https://github.com/CaptainCrouton89/termrender

{termrender-0.7.2 → termrender-0.8.0}/src/termrender/CLAUDE.md

@@ -8,7 +8,9 @@
 
 `layout.py:119–134` runs `mermaid-ascii` and caches the result in `block.attrs["_rendered"]`. The `mermaid` renderer (renderers/mermaid.py) reads this cache key; if it's absent, it runs the subprocess again. A failed layout subprocess (tool missing, timeout) silently stores the raw source diagram in `_rendered`, so the renderer falls back to printing source — no error is raised. Both sites have a 30s timeout.
 
-`layout.py` imports `fix_mermaid_encoding` from `renderers/mermaid.py` — the only reverse dependency from layout into renderers. Reorganizing `renderers/` must account for this import. The two subprocess call sites differ: layout uses `check=True` (non-zero exit raises `CalledProcessError` → caught → raw source fallback); the renderer omits `check` (non-zero exit silently reads `stdout`, which may be empty or partial). See `renderers/CLAUDE.md` for encoding-fix details.
+`layout.py` imports `fix_mermaid_encoding` and `preprocess_mermaid_for_ascii` from `renderers/mermaid.py` — the only reverse dependency from layout into renderers. Reorganizing `renderers/` must account for these imports. The two subprocess call sites differ: layout uses `check=True` (non-zero exit raises `CalledProcessError` → caught → raw source fallback); the renderer omits `check` (non-zero exit silently reads `stdout`, which may be empty or partial). See `renderers/CLAUDE.md` for encoding-fix details.
+
+`preprocess_mermaid_for_ascii` rewrites sequence diagrams into the subset `mermaid-ascii` parses (it only supports `->>` / `-->>` arrows, `participant`, and self-loops). `Note over|left of|right of X[,Y]: msg` becomes a self-loop `X->>X: 📝 msg`; `->`, `-x`, `--x`, `-)`, `--)`, and bare `-->` are mapped to `->>`/`-->>`; block keywords (`loop`/`alt`/`opt`/`par`/`critical`/`break`/`rect`/`activate`/`deactivate`/`autonumber`/`else`/`and`/`end`) are dropped so the inner arrow lines still render; `<br/>` is flattened to ` / `. Non-sequence diagrams (`flowchart`, `graph`, etc.) pass through unchanged. Semantics are lossy by design — `-x` (fail arrow) renders as a plain arrow, and block scoping is lost — but the flow diagram renders instead of silently degrading to raw source.
 
 ## Directive nesting: outer must have more colons than inner
 

{termrender-0.7.2 → termrender-0.8.0}/src/termrender/__main__.py

@@ -298,17 +298,9 @@ def main() -> None:
             from termrender.parser import parse as _parse
             _parse(source)
         except DirectiveError as e:
-            _error(
-                f"syntax error: {e}",
-                fix="check directive openers have matching ::: closers and attribute syntax is key=\"value\"",
-                code=EXIT_SYNTAX,
-            )
+            _error(f"syntax error: {e}", code=EXIT_SYNTAX)
         except ValueError as e:
-            _error(
-                f"nesting error: {e}",
-                fix="reduce directive nesting depth (max 50 levels)",
-                code=EXIT_SYNTAX,
-            )
+            _error(f"nesting error: {e}", code=EXIT_SYNTAX)
 
         import shlex
         import subprocess
@@ -447,17 +439,9 @@ def main() -> None:
             from termrender.parser import parse
             parse(source)
         except DirectiveError as e:
-            _error(
-                f"syntax error: {e}",
-                fix="check directive openers have matching ::: closers and attribute syntax is key=\"value\"",
-                code=EXIT_SYNTAX,
-            )
+            _error(f"syntax error: {e}", code=EXIT_SYNTAX)
         except ValueError as e:
-            _error(
-                f"nesting error: {e}",
-                fix="reduce directive nesting depth (max 50 levels)",
-                code=EXIT_SYNTAX,
-            )
+            _error(f"nesting error: {e}", code=EXIT_SYNTAX)
         print("ok", file=sys.stderr)
         sys.exit(EXIT_OK)
 
@@ -474,18 +458,9 @@ def main() -> None:
             code=EXIT_TERMINAL,
         )
     except DirectiveError as e:
-        _error(
-            f"syntax error: {e}",
-            fix="check directive openers have matching ::: closers and attribute syntax is key=\"value\"",
-            hint="run: termrender --check <file> to validate before rendering",
-            code=EXIT_SYNTAX,
-        )
+        _error(f"syntax error: {e}", code=EXIT_SYNTAX)
     except ValueError as e:
-        _error(
-            f"nesting error: {e}",
-            fix="reduce directive nesting depth (max 50 levels)",
-            code=EXIT_SYNTAX,
-        )
+        _error(f"nesting error: {e}", code=EXIT_SYNTAX)
 
     sys.stdout.write(output)
 

{termrender-0.7.2 → termrender-0.8.0}/src/termrender/layout.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import subprocess
 
 from termrender.blocks import Block, BlockType
-from termrender.renderers.mermaid import fix_mermaid_encoding
+from termrender.renderers.mermaid import fix_mermaid_encoding, preprocess_mermaid_for_ascii
 from termrender.style import wrap_text, visual_len
 
 
@@ -92,8 +92,11 @@ def resolve_height(block: Block) -> None:
 
     elif bt == BlockType.CODE:
         source = block.attrs.get("source") or _plain_text(block.text)
-        code_lines = source.split("\n") if source else [""]
-        block.height = len(code_lines) + 2
+        raw_lines = source.split("\n") if source else [""]
+        border_v = visual_len("│")
+        content_w = max(width - 2 * border_v - 2, 1)
+        total_lines = sum(len(wrap_text(line, content_w)) for line in raw_lines)
+        block.height = total_lines + 2
 
     elif bt == BlockType.COLUMNS:
         block.height = max((c.height or 0 for c in block.children), default=0)
@@ -145,7 +148,7 @@ def resolve_height(block: Block) -> None:
         try:
             result = subprocess.run(
                 ["mermaid-ascii", "-f", "-", "-w", str(block.width or 80), "-y", "1"],
-                input=source,
+                input=preprocess_mermaid_for_ascii(source),
                 capture_output=True,
                 text=True,
                 check=True,

{termrender-0.7.2 → termrender-0.8.0}/src/termrender/parser.py

@@ -405,21 +405,80 @@ def _parse_markdown(source: str, _depth: int = 0) -> list[Block]:
     return _convert_ast(ast_nodes, _depth=_depth)
 
 
-def _split_directives(source: str) -> list[dict]:
+def _find_nested_directives(body_lines: list[str]) -> list[str]:
+    """Return names of directive openers found in body lines."""
+    names: list[str] = []
+    for line in body_lines:
+        m = _DIRECTIVE_OPEN.match(line)
+        if m:
+            names.append(m.group(2))
+    return names
+
+
+def _stray_closer_message(
+    abs_line: int, close_colons: str, trace: list[str],
+    last_closed: dict | None,
+) -> str:
+    """Format a stray-closer error with trace and fix suggestion."""
+    msg = f"line {abs_line}: stray '{close_colons}' closer — no directive is open"
+    if trace:
+        msg += "\n\n  directive trace:\n" + "\n".join(trace)
+
+    if last_closed:
+        nested = _find_nested_directives(last_closed["body_lines"])
+        if nested:
+            outer = last_closed["name"]
+            inner = nested[0]
+            fix_colons = ":" * (last_closed["colon_count"] + 1)
+            msg += (
+                f"\n\n  Likely cause: :::{outer} at line {last_closed['open_line']} "
+                f"contains a nested :::{inner} with the same colon count.\n"
+                f"  The inner ':::' closer (line {last_closed['close_line']}) "
+                f"matched the outer directive instead.\n"
+                f"  Fix: use {fix_colons}{outer} for the outer directive"
+            )
+            return msg
+
+    msg += (
+        "\n\n  Fix: remove this stray closer, or if nesting is intended,\n"
+        "  use more colons on outer directives (::::outer wraps :::inner)"
+    )
+    return msg
+
+
+def _unclosed_directive_message(
+    open_line: int, colons: str, name: str, trace: list[str],
+    body_lines: list[str],
+) -> str:
+    """Format an unclosed-directive error with trace and fix suggestion."""
+    msg = f"line {open_line}: unclosed '{colons}{name}' — add '{colons}' on a new line to close it"
+    if trace:
+        msg += "\n\n  directive trace:\n" + "\n".join(trace)
+    return msg
+
+
+def _split_directives(source: str, _line_offset: int = 0) -> list[dict]:
     """Split source into directive and markdown segments.
 
     Returns a list of segments, each being either:
       {"type": "markdown", "content": str}
-      {"type": "directive", "name": str, "attrs": dict, "body": str}
+      {"type": "directive", "name": str, "attrs": dict, "body": str,
+       "body_start_offset": int}
+
+    On error, raises DirectiveError with a directive trace showing the
+    sequence of opens/closes that led to the error state.
     """
     lines = source.split("\n")
     segments: list[dict] = []
     current_md_lines: list[str] = []
     stack: list[dict] = []  # stack of open directives
+    trace: list[str] = []   # event log for error diagnostics
+    last_closed: dict | None = None  # most recently closed directive entry
 
     i = 0
     while i < len(lines):
         line = lines[i]
+        abs_line = _line_offset + i + 1  # 1-indexed file-absolute line number
 
         # Check for directive opener
         m_open = _DIRECTIVE_OPEN.match(line)
@@ -440,6 +499,8 @@ def _split_directives(source: str) -> list[dict]:
                     "attrs_raw": attrs_raw,
                     "body_lines": [],
                     "colon_count": len(colons),
+                    "open_line": abs_line,
+                    "body_start_offset": _line_offset + i + 1,
                 }
                 # Self-closing directives (no body content expected)
                 if entry["name"] in _SELF_CLOSING_DIRECTIVES:
@@ -448,9 +509,12 @@ def _split_directives(source: str) -> list[dict]:
                         "name": entry["name"],
                         "attrs": _parse_attrs(entry["attrs_raw"]),
                         "body": "",
+                        "body_start_offset": entry["body_start_offset"],
                     })
+                    trace.append(f"    line {abs_line}: {colons}{name}  (self-closing)")
                 else:
                     stack.append(entry)
+                    trace.append(f"    line {abs_line}: {colons}{name}  opened")
             else:
                 # Nested directive — always treat as body content
                 stack[-1]["body_lines"].append(line)
@@ -462,8 +526,9 @@ def _split_directives(source: str) -> list[dict]:
         if m_close and not stack:
             if not _any_self_closing_before(lines, i):
                 close_colons = m_close.group(1)
+                trace.append(f"    line {abs_line}: {close_colons}  stray closer (nothing is open)")
                 raise DirectiveError(
-                    f"line {i + 1}: stray '{close_colons}' closer with no open directive"
+                    _stray_closer_message(abs_line, close_colons, trace, last_closed)
                 )
             # Stray closer after a self-closing directive like divider — skip
             i += 1
@@ -476,11 +541,30 @@ def _split_directives(source: str) -> list[dict]:
             else:
                 # Closing the open directive
                 entry = stack.pop()
+                closed_colons = ":" * entry["colon_count"]
+                nested = _find_nested_directives(entry["body_lines"])
+                nested_note = ""
+                if nested:
+                    names = ", ".join(f":::{n}" for n in nested[:3])
+                    nested_note = f"  — body has nested {names}"
+                trace.append(
+                    f"    line {abs_line}: {closed_colons}  "
+                    f"closed {entry['name']} (opened line {entry['open_line']})"
+                    f"{nested_note}"
+                )
+                last_closed = {
+                    "name": entry["name"],
+                    "colon_count": entry["colon_count"],
+                    "open_line": entry["open_line"],
+                    "close_line": abs_line,
+                    "body_lines": entry["body_lines"],
+                }
                 segments.append({
                     "type": "directive",
                     "name": entry["name"],
                     "attrs": _parse_attrs(entry["attrs_raw"]),
                     "body": "\n".join(entry["body_lines"]),
+                    "body_start_offset": entry["body_start_offset"],
                 })
             i += 1
             continue
@@ -504,8 +588,10 @@ def _split_directives(source: str) -> list[dict]:
         unclosed = stack[-1]
         colons = ":" * unclosed["colon_count"]
         name = unclosed["name"]
+        open_line = unclosed["open_line"]
+        trace.append(f"    line {open_line}: {colons}{name}  ← still open at end of input")
         raise DirectiveError(
-            f"unclosed directive '{colons}{name}' — missing closing '{colons}'"
+            _unclosed_directive_message(open_line, colons, name, trace, unclosed["body_lines"])
         )
 
     return segments
@@ -514,7 +600,7 @@ def _split_directives(source: str) -> list[dict]:
 _MAX_PARSE_DEPTH = 50
 
 
-def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int = 0) -> Block:
+def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int = 0, _line_offset: int = 0) -> Block:
     """Convert a parsed directive into a Block."""
     # Strip option lines from body; inline attrs take precedence over options
     options, body = _strip_options(body)
@@ -545,12 +631,12 @@ def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int
 
     # Stat: optional caption body parsed as markdown
     if block_type == BlockType.STAT:
-        body_doc = parse(body, _depth=_depth + 1) if body.strip() else Block(type=BlockType.DOCUMENT)
+        body_doc = parse(body, _depth=_depth + 1, _line_offset=_line_offset) if body.strip() else Block(type=BlockType.DOCUMENT)
         return Block(type=block_type, children=body_doc.children, attrs=attrs)
 
     # Tasklist alias: parse body, find the inner list, force tasklist styling
     if name == "tasklist":
-        body_doc = parse(body, _depth=_depth + 1)
+        body_doc = parse(body, _depth=_depth + 1, _line_offset=_line_offset)
         for child in body_doc.children:
             if child.type == BlockType.LIST:
                 child.attrs["tasklist"] = True
@@ -563,7 +649,7 @@ def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int
         return Block(type=BlockType.LIST, attrs={"tasklist": True, **attrs})
 
     # Recursively parse the body through the full two-pass pipeline
-    body_doc = parse(body, _depth=_depth + 1)
+    body_doc = parse(body, _depth=_depth + 1, _line_offset=_line_offset)
     return Block(
         type=block_type,
         children=body_doc.children,
@@ -641,14 +727,14 @@ def _apply_tasklist_markers(block: Block) -> Block:
     return block
 
 
-def parse(source: str, _depth: int = 0) -> Block:
+def parse(source: str, _depth: int = 0, _line_offset: int = 0) -> Block:
     """Parse markdown+directive source into a Block tree.
 
     Returns a Block with type=DOCUMENT as root.
     """
     if _depth > _MAX_PARSE_DEPTH:
         raise ValueError(f"Maximum directive nesting depth ({_MAX_PARSE_DEPTH}) exceeded")
-    segments = _split_directives(source)
+    segments = _split_directives(source, _line_offset=_line_offset)
     children: list[Block] = []
 
     for seg in segments:
@@ -657,6 +743,7 @@ def parse(source: str, _depth: int = 0) -> Block:
         else:
             children.append(_directive_to_block(
                 seg["name"], seg["attrs"], seg["body"], _depth=_depth,
+                _line_offset=seg.get("body_start_offset", 0),
             ))
 
     # Walk the tree to auto-promote any markdown list with [ ]/[x] markers

{termrender-0.7.2 → termrender-0.8.0}/src/termrender/renderers/code.py

@@ -10,6 +10,7 @@ from pygments.lexers import TextLexer, get_lexer_by_name
 
 from termrender.blocks import Block
 from termrender.renderers.borders import render_box
+from termrender.style import visual_len, wrap_text
 
 
 def render(
@@ -19,18 +20,29 @@ def render(
     source = block.attrs.get("source", "")
     lang = block.attrs.get("lang")
 
+    # Wrap raw source lines to fit within the box before highlighting,
+    # so render_box doesn't need to grow beyond the layout allocation.
+    border_v = visual_len("│")
+    content_w = max((block.width or 1) - 2 * border_v - 2, 1)
+    raw_lines = source.split("\n") if source else [""]
+    wrapped_lines = []
+    for line in raw_lines:
+        wrapped_lines.extend(wrap_text(line, content_w))
+
+    wrapped_source = "\n".join(wrapped_lines)
+
     # Syntax highlight (or plain text)
-    if color and source:
+    if color and wrapped_source:
         try:
             lexer = get_lexer_by_name(lang) if lang else TextLexer()
         except Exception:
             lexer = TextLexer()
-        highlighted = highlight(source, lexer, TerminalFormatter())
+        highlighted = highlight(wrapped_source, lexer, TerminalFormatter())
         # Pygments adds a trailing newline — strip it
         highlighted = highlighted.rstrip("\n")
         code_lines = highlighted.split("\n")
     else:
-        code_lines = source.split("\n") if source else [""]
+        code_lines = wrapped_lines
 
     return render_box(
         code_lines,

termrender-0.8.0/src/termrender/renderers/mermaid.py

@@ -0,0 +1,98 @@
+"""Mermaid diagram renderer for termrender."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+
+from termrender.blocks import Block
+from termrender.style import visual_ljust
+
+
+def fix_mermaid_encoding(text: str) -> str:
+    """Undo mermaid-ascii's double-encoding of UTF-8 characters.
+
+    mermaid-ascii misinterprets UTF-8 input bytes as Latin-1 and re-encodes
+    to UTF-8, corrupting multi-byte characters (e.g. → becomes â\\x86\\x92).
+    Reversing the process: encode back to Latin-1 to recover the original
+    UTF-8 bytes, then decode as UTF-8.
+    """
+    try:
+        return text.encode("latin-1").decode("utf-8")
+    except (UnicodeDecodeError, UnicodeEncodeError):
+        return text
+
+
+_NOTE_RE = re.compile(
+    r"^(\s*)[Nn]ote\s+(?:over|left\s+of|right\s+of)\s+([^:]+?)\s*:\s*(.*)$"
+)
+_BR_RE = re.compile(r"<br\s*/?>", re.IGNORECASE)
+_UNSUPPORTED_BLOCK_RE = re.compile(
+    r"^\s*(?:loop|alt|else|opt|par|and|critical|option|break|rect|"
+    r"activate|deactivate|autonumber|end)\b.*$",
+    re.IGNORECASE,
+)
+
+
+def preprocess_mermaid_for_ascii(source: str) -> str:
+    """Rewrite mermaid sequence diagrams into the subset mermaid-ascii supports.
+
+    mermaid-ascii only understands ``->>`` and ``-->>`` arrows plus ``participant``
+    declarations. This helper converts ``Note`` lines into self-loops, maps the
+    other arrow variants (``->``, ``-x``, ``--x``, ``-)``, ``--)``, ``-->``) to
+    the supported pair, drops block keywords (``loop``, ``alt``, ``activate``…),
+    and flattens ``<br/>`` tags. Non-sequence diagrams are returned unchanged.
+    """
+    lines = source.splitlines()
+    first = next((l.strip() for l in lines if l.strip()), "")
+    if not first.lower().startswith("sequencediagram"):
+        return source
+
+    out: list[str] = []
+    for line in lines:
+        m = _NOTE_RE.match(line)
+        if m:
+            indent, parts, msg = m.group(1), m.group(2), m.group(3)
+            first_p = parts.split(",")[0].strip()
+            msg = _BR_RE.sub(" / ", msg)
+            out.append(f"{indent}{first_p}->>{first_p}: 📝 {msg}")
+            continue
+
+        if _UNSUPPORTED_BLOCK_RE.match(line):
+            continue
+
+        line = _BR_RE.sub(" / ", line)
+        line = re.sub(r"--x(?=\s|\w|\()", "-->>", line)
+        line = re.sub(r"-x(?=\s|\w|\()", "->>", line)
+        line = re.sub(r"--\)(?=\s|\w|\()", "-->>", line)
+        line = re.sub(r"-\)(?=\s|\w|\()", "->>", line)
+        line = re.sub(r"-->(?!>)", "-->>", line)
+        line = re.sub(r"(?<!-)->(?!>)", "->>", line)
+        out.append(line)
+    return "\n".join(out)
+
+
+def render(block: Block, color: bool) -> list[str]:
+    """Render a mermaid diagram from pre-rendered or on-the-fly ASCII output."""
+    w = block.width
+    rendered = block.attrs.get("_rendered")
+
+    if rendered is None:
+        source = block.attrs.get("source", "")
+        try:
+            result = subprocess.run(
+                ["mermaid-ascii", "-f", "-", "-w", str(block.width or 80), "-y", "1"],
+                input=preprocess_mermaid_for_ascii(source),
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            rendered = fix_mermaid_encoding(result.stdout)
+        except Exception:
+            rendered = source
+
+    lines: list[str] = []
+    for raw_line in rendered.split("\n"):
+        lines.append(visual_ljust(raw_line, w))
+
+    return lines

termrender-0.8.0/tests/test_mermaid_compat.py

@@ -0,0 +1,115 @@
+import unittest
+
+from termrender.renderers.mermaid import preprocess_mermaid_for_ascii
+
+
+class TestMermaidPreprocessor(unittest.TestCase):
+
+    def test_non_sequence_diagrams_pass_through(self):
+        src = "flowchart TD\n    A-->B\n    B-->C"
+        self.assertEqual(preprocess_mermaid_for_ascii(src), src)
+
+    def test_note_over_becomes_self_loop(self):
+        src = "sequenceDiagram\n    participant A\n    participant B\n    Note over A: hello"
+        out = preprocess_mermaid_for_ascii(src)
+        self.assertIn("A->>A: 📝 hello", out)
+        self.assertNotIn("Note over", out)
+
+    def test_note_over_multi_participant_picks_first(self):
+        src = "sequenceDiagram\n    participant A\n    participant B\n    Note over A,B: shared"
+        out = preprocess_mermaid_for_ascii(src)
+        self.assertIn("A->>A: 📝 shared", out)
+
+    def test_note_left_and_right_of(self):
+        src = (
+            "sequenceDiagram\n"
+            "    participant X\n"
+            "    Note left of X: L\n"
+            "    Note right of X: R"
+        )
+        out = preprocess_mermaid_for_ascii(src)
+        self.assertIn("X->>X: 📝 L", out)
+        self.assertIn("X->>X: 📝 R", out)
+
+    def test_br_tags_flattened_in_note(self):
+        src = "sequenceDiagram\n    participant A\n    Note over A: line1<br/>line2"
+        out = preprocess_mermaid_for_ascii(src)
+        self.assertIn("A->>A: 📝 line1 / line2", out)
+
+    def test_br_tags_flattened_in_arrow_message(self):
+        src = "sequenceDiagram\n    participant A\n    participant B\n    A->>B: a<br/>b<br />c"
+        out = preprocess_mermaid_for_ascii(src)
+        self.assertIn("A->>B: a / b / c", out)
+
+    def test_arrow_variants_rewritten(self):
+        src = (
+            "sequenceDiagram\n"
+            "    participant A\n"
+            "    participant B\n"
+            "    A-xB: fail\n"
+            "    A--xB: dashed fail\n"
+            "    A-)B: async\n"
+            "    A--)B: dashed async\n"
+            "    A->B: single\n"
+            "    A-->B: dashed single\n"
+        )
+        out = preprocess_mermaid_for_ascii(src)
+        self.assertNotIn("-x", out)
+        self.assertNotIn("-)", out)
+        # Each single-dash variant should be solid ->>
+        self.assertIn("A->>B: fail", out)
+        self.assertIn("A->>B: async", out)
+        self.assertIn("A->>B: single", out)
+        # Each double-dash variant should be dashed -->>
+        self.assertIn("A-->>B: dashed fail", out)
+        self.assertIn("A-->>B: dashed async", out)
+        self.assertIn("A-->>B: dashed single", out)
+
+    def test_existing_double_arrow_preserved(self):
+        src = "sequenceDiagram\n    participant A\n    participant B\n    A->>B: x\n    A-->>B: y"
+        out = preprocess_mermaid_for_ascii(src)
+        self.assertIn("A->>B: x", out)
+        self.assertIn("A-->>B: y", out)
+        # Should not have inflated to ->>>
+        self.assertNotIn("->>>", out)
+        self.assertNotIn("-->>>", out)
+
+    def test_block_keywords_dropped(self):
+        src = (
+            "sequenceDiagram\n"
+            "    participant A\n"
+            "    participant B\n"
+            "    activate A\n"
+            "    loop forever\n"
+            "    A->>B: x\n"
+            "    end\n"
+            "    deactivate A\n"
+            "    autonumber\n"
+            "    alt happy\n"
+            "    A->>B: y\n"
+            "    else sad\n"
+            "    A->>B: z\n"
+            "    end\n"
+        )
+        out = preprocess_mermaid_for_ascii(src)
+        for dropped in ("activate", "deactivate", "loop", "end", "alt ", "else ", "autonumber"):
+            self.assertNotIn(dropped, out.lower())
+        # But arrow lines survive
+        self.assertIn("A->>B: x", out)
+        self.assertIn("A->>B: y", out)
+        self.assertIn("A->>B: z", out)
+
+    def test_participant_aliases_with_parens_preserved(self):
+        src = (
+            "sequenceDiagram\n"
+            "    participant C1 as Core (PID 92348)\n"
+            "    participant C2 as Core (PID 93684)\n"
+            "    C1->>C2: x"
+        )
+        out = preprocess_mermaid_for_ascii(src)
+        self.assertIn("participant C1 as Core (PID 92348)", out)
+        self.assertIn("participant C2 as Core (PID 93684)", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

termrender-0.7.2/src/termrender/renderers/mermaid.py

@@ -1,48 +0,0 @@
-"""Mermaid diagram renderer for termrender."""
-
-from __future__ import annotations
-
-import subprocess
-
-from termrender.blocks import Block
-from termrender.style import visual_ljust
-
-
-def fix_mermaid_encoding(text: str) -> str:
-    """Undo mermaid-ascii's double-encoding of UTF-8 characters.
-
-    mermaid-ascii misinterprets UTF-8 input bytes as Latin-1 and re-encodes
-    to UTF-8, corrupting multi-byte characters (e.g. → becomes â\\x86\\x92).
-    Reversing the process: encode back to Latin-1 to recover the original
-    UTF-8 bytes, then decode as UTF-8.
-    """
-    try:
-        return text.encode("latin-1").decode("utf-8")
-    except (UnicodeDecodeError, UnicodeEncodeError):
-        return text
-
-
-def render(block: Block, color: bool) -> list[str]:
-    """Render a mermaid diagram from pre-rendered or on-the-fly ASCII output."""
-    w = block.width
-    rendered = block.attrs.get("_rendered")
-
-    if rendered is None:
-        source = block.attrs.get("source", "")
-        try:
-            result = subprocess.run(
-                ["mermaid-ascii", "-f", "-", "-w", str(block.width or 80), "-y", "1"],
-                input=source,
-                capture_output=True,
-                text=True,
-                timeout=30,
-            )
-            rendered = fix_mermaid_encoding(result.stdout)
-        except Exception:
-            rendered = source
-
-    lines: list[str] = []
-    for raw_line in rendered.split("\n"):
-        lines.append(visual_ljust(raw_line, w))
-
-    return lines