termrender 3.0.1__tar.gz → 4.0.0__tar.gz

{termrender-3.0.1 → termrender-4.0.0}/CHANGELOG.md

@@ -1,6 +1,63 @@
 # CHANGELOG
 
 
+## v4.0.0 (2026-07-06)
+
+### Features
+
+- **mermaid**: Also route ```mermaid fences through the mermaid renderer
+  ([`99a8017`](https://github.com/crouton-labs/termrender/commit/99a801783d719125505eef2dc1194e2e418ed025))
+
+BREAKING CHANGE: partially reverses 083f590. A fenced code block whose info string is `mermaid`
+  (e.g. GFM ````mermaid```` fences used by GitHub and most docs/agents unaware of the :::mermaid
+  directive) now renders as an ASCII mermaid diagram, same as :::mermaid. Any other language tag
+  still falls through to a plain CODE block; the :::mermaid directive is unchanged.
+
+Root-caused: the reported bug (fences render as raw source, not a diagram) was not a regression or
+  missing binary — the vendored mermaid-ascii binary and subprocess pipeline both work correctly. It
+  was 083f590's deliberate, documented breaking change dropping fence support. Human chose to extend
+  support back to fences rather than close as working-as-intended.
+
+### Breaking Changes
+
+- **mermaid**: Partially reverses 083f590. A fenced code block whose info string is `mermaid` (e.g.
+  GFM ````mermaid```` fences used by GitHub and most docs/agents unaware of the :::mermaid
+  directive) now renders as an ASCII mermaid diagram, same as :::mermaid. Any other language tag
+  still falls through to a plain CODE block; the :::mermaid directive is unchanged.
+
+
+## v3.0.2 (2026-06-17)
+
+### Bug Fixes
+
+- **docs**: Correct nested-directive examples to increasing-colon rule
+  ([`4332854`](https://github.com/crouton-labs/termrender/commit/4332854cc1bdab8122f7e022c2d79a69e2d8a719))
+
+Every nested example in the README and the doc -h 'Document format' help predated 4a501d9 (require
+  strictly more colons on outer fences) and fails `termrender doc check`: the flagship deploy panel,
+  the Columns example, and the Nesting section all used equal colons. Rewrote them so each outer
+  directive uses strictly more colons than the one nested inside (MyST-style), documented the rule
+  in the intro + Nesting prose + the agent-facing doc help, and added the gotcha to src CLAUDE.md.
+  Rendered output is unchanged (colon count is pure syntax). All 11 README markdown blocks now pass
+  doc check.
+
+- **mermaid**: Normalize flowchart node shapes to rectangles
+  ([`8c45f7c`](https://github.com/crouton-labs/termrender/commit/8c45f7c20810a3960cb037831a7c5f152406b3f6))
+
+mermaid-ascii (vendored, pinned master 6fffb8e) only parses [text] rectangle nodes; every other
+  mermaid node shape leaked raw delimiters or the bare node id into the rendered box — B{Auth?}
+  rendered the literal 'B{Auth?}', E[(Database)] rendered '(Database)'. The preprocessor only
+  handled sequence diagrams; flowcharts passed through untouched.
+
+Add a flowchart shape normalizer that rewrites rhombus {}, cylinder [()], circle (()), stadium ([]),
+  hexagon {{}}, subroutine [[]], and parallelogram/trapezoid [/ /] nodes to id[label], preserving
+  the label text. The backend draws a rectangle regardless, so only the text matters.
+
+Node shapes remain unsupported on current upstream master (parseNode handles only rectangles; the 6
+  commits since our pin are arrow-parsing only), so this is a permanent workaround, not a stopgap
+  for a pin bump. Regression test + CLAUDE.md note added.
+
+
 ## v3.0.1 (2026-06-10)
 
 ### Bug Fixes

{termrender-3.0.1 → termrender-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 3.0.1
+Version: 4.0.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
@@ -77,13 +77,13 @@ Here's a realistic example — the kind of thing an LLM agent might produce afte
 The agent writes this:
 
 ```markdown
-:::panel{title="Deploy — api-gateway v3.2.0" color="cyan"}
+:::::::panel{title="Deploy — api-gateway v3.2.0" color="cyan"}
 
 Completed at **14:32 UTC** on `prod-us-east-1`. Health checks passing.
 
-:::columns
-:::col{width="55%"}
-:::panel{title="Services" color="green"}
+::::::columns
+:::::col{width="55%"}
+::::panel{title="Services" color="green"}
 :::tree
 api-gateway/ [x]
   auth/ [x]
@@ -94,23 +94,23 @@ worker-pool/
   scheduler/ [!]
   dead-letter/ [x]
 :::
-:::
-:::
-:::col{width="45%"}
-:::callout{type="success"}
+::::
+:::::
+:::::col{width="45%"}
+::::callout{type="success"}
 6 of 7 services healthy
-:::
+::::
 
-:::callout{type="warning"}
+::::callout{type="warning"}
 scheduler: 83% memory
 GC tuning shipping next release
-:::
+::::
 
 - **p99 latency**: 34ms
 - **error rate**: 0.02%
 - **throughput**: 12.4k req/s
-:::
-:::
+:::::
+::::::
 
 :::divider{label="rollback"}
 :::
@@ -124,7 +124,7 @@ kubectl rollout status deployment/api-gateway -n prod
 :::quote{author="deploy-bot"}
 Previous stable: v3.1.4 (deployed 2025-03-28)
 :::
-:::
+:::::::
 ```
 
 And termrender produces this:
@@ -208,7 +208,7 @@ One function. Source in, ANSI string out.
 
 ## Directives
 
-Triple-colon syntax with optional attributes in curly braces. They nest arbitrarily. Standard markdown works everywhere inside them.
+Triple-colon syntax with optional attributes in curly braces. They nest, but an outer directive must use strictly **more** colons than the one nested inside it (`::::columns` wraps `:::col`) — see [Nesting](#nesting). Standard markdown works everywhere inside them.
 
 ```
 :::name{key="value" key2="value2"}
@@ -246,7 +246,7 @@ Side-by-side layout. Each `:::col` takes a width as a percentage.
 
 **Input:**
 ```markdown
-:::columns
+::::columns
 :::col{width="50%"}
 **Before**
 - Manual deploys
@@ -259,7 +259,7 @@ Side-by-side layout. Each `:::col` takes a width as a percentage.
 - 2 min rollbacks
 - Full staging env
 :::
-:::
+::::
 ```
 
 **Output:**
@@ -408,7 +408,7 @@ Horizontal rules with optional centered labels.
 
 ### Mermaid diagrams
 
-Renders mermaid flowcharts as ASCII art via [mermaid-ascii](https://github.com/mermaid-js/mermaid-ascii). Mermaid uses the `:::mermaid` directive — backtick fences (`` ```mermaid ``) are treated as plain code blocks.
+Renders mermaid flowcharts as ASCII art via [mermaid-ascii](https://github.com/mermaid-js/mermaid-ascii). Use the `:::mermaid` directive, or a standard GFM ` ```mermaid ` fenced code block — both render the same diagram.
 
 **Input:**
 ```markdown
@@ -427,31 +427,33 @@ The diagram gets rendered as ASCII art inline in the terminal output. Requires `
 
 Directives compose. Put a tree inside a panel, panels inside columns, callouts next to trees with a divider between sections.
 
+**Nesting is by colon count: an outer directive must use strictly more colons than the directive nested inside it, and each block closes with a bare run of its own colon count on its own line.** Below, the panel uses 6 colons, the columns 5, each column 4, and the leaf tree/callout/divider 3. Innermost is always `:::` (3); add one colon per level as you go outward. (`termrender doc check` reports the exact fix when counts are off.)
+
 **Input:**
 ```markdown
-:::panel{title="Deployment" color="green"}
+::::::panel{title="Deployment" color="green"}
 
-:::columns
-:::col{width="60%"}
+:::::columns
+::::col{width="60%"}
 :::tree
 services/
   api/ [x]
   worker/ [x]
   scheduler/ [!]
 :::
-:::
-:::col{width="40%"}
+::::
+::::col{width="40%"}
 :::callout{type="success"}
 2 of 3 services deployed
 :::
-:::
-:::
+::::
+:::::
 
 :::divider{label="logs"}
 :::
 
 Last deploy: `api@v2.4.1` at 14:32 UTC
-:::
+::::::
 ```
 
 A bordered panel containing two columns (file tree on the left, status callout on the right), a labeled divider, and a status line. All from nested directives.

{termrender-3.0.1 → termrender-4.0.0}/README.md

@@ -49,13 +49,13 @@ Here's a realistic example — the kind of thing an LLM agent might produce afte
 The agent writes this:
 
 ```markdown
-:::panel{title="Deploy — api-gateway v3.2.0" color="cyan"}
+:::::::panel{title="Deploy — api-gateway v3.2.0" color="cyan"}
 
 Completed at **14:32 UTC** on `prod-us-east-1`. Health checks passing.
 
-:::columns
-:::col{width="55%"}
-:::panel{title="Services" color="green"}
+::::::columns
+:::::col{width="55%"}
+::::panel{title="Services" color="green"}
 :::tree
 api-gateway/ [x]
   auth/ [x]
@@ -66,23 +66,23 @@ worker-pool/
   scheduler/ [!]
   dead-letter/ [x]
 :::
-:::
-:::
-:::col{width="45%"}
-:::callout{type="success"}
+::::
+:::::
+:::::col{width="45%"}
+::::callout{type="success"}
 6 of 7 services healthy
-:::
+::::
 
-:::callout{type="warning"}
+::::callout{type="warning"}
 scheduler: 83% memory
 GC tuning shipping next release
-:::
+::::
 
 - **p99 latency**: 34ms
 - **error rate**: 0.02%
 - **throughput**: 12.4k req/s
-:::
-:::
+:::::
+::::::
 
 :::divider{label="rollback"}
 :::
@@ -96,7 +96,7 @@ kubectl rollout status deployment/api-gateway -n prod
 :::quote{author="deploy-bot"}
 Previous stable: v3.1.4 (deployed 2025-03-28)
 :::
-:::
+:::::::
 ```
 
 And termrender produces this:
@@ -180,7 +180,7 @@ One function. Source in, ANSI string out.
 
 ## Directives
 
-Triple-colon syntax with optional attributes in curly braces. They nest arbitrarily. Standard markdown works everywhere inside them.
+Triple-colon syntax with optional attributes in curly braces. They nest, but an outer directive must use strictly **more** colons than the one nested inside it (`::::columns` wraps `:::col`) — see [Nesting](#nesting). Standard markdown works everywhere inside them.
 
 ```
 :::name{key="value" key2="value2"}
@@ -218,7 +218,7 @@ Side-by-side layout. Each `:::col` takes a width as a percentage.
 
 **Input:**
 ```markdown
-:::columns
+::::columns
 :::col{width="50%"}
 **Before**
 - Manual deploys
@@ -231,7 +231,7 @@ Side-by-side layout. Each `:::col` takes a width as a percentage.
 - 2 min rollbacks
 - Full staging env
 :::
-:::
+::::
 ```
 
 **Output:**
@@ -380,7 +380,7 @@ Horizontal rules with optional centered labels.
 
 ### Mermaid diagrams
 
-Renders mermaid flowcharts as ASCII art via [mermaid-ascii](https://github.com/mermaid-js/mermaid-ascii). Mermaid uses the `:::mermaid` directive — backtick fences (`` ```mermaid ``) are treated as plain code blocks.
+Renders mermaid flowcharts as ASCII art via [mermaid-ascii](https://github.com/mermaid-js/mermaid-ascii). Use the `:::mermaid` directive, or a standard GFM ` ```mermaid ` fenced code block — both render the same diagram.
 
 **Input:**
 ```markdown
@@ -399,31 +399,33 @@ The diagram gets rendered as ASCII art inline in the terminal output. Requires `
 
 Directives compose. Put a tree inside a panel, panels inside columns, callouts next to trees with a divider between sections.
 
+**Nesting is by colon count: an outer directive must use strictly more colons than the directive nested inside it, and each block closes with a bare run of its own colon count on its own line.** Below, the panel uses 6 colons, the columns 5, each column 4, and the leaf tree/callout/divider 3. Innermost is always `:::` (3); add one colon per level as you go outward. (`termrender doc check` reports the exact fix when counts are off.)
+
 **Input:**
 ```markdown
-:::panel{title="Deployment" color="green"}
+::::::panel{title="Deployment" color="green"}
 
-:::columns
-:::col{width="60%"}
+:::::columns
+::::col{width="60%"}
 :::tree
 services/
   api/ [x]
   worker/ [x]
   scheduler/ [!]
 :::
-:::
-:::col{width="40%"}
+::::
+::::col{width="40%"}
 :::callout{type="success"}
 2 of 3 services deployed
 :::
-:::
-:::
+::::
+:::::
 
 :::divider{label="logs"}
 :::
 
 Last deploy: `api@v2.4.1` at 14:32 UTC
-:::
+::::::
 ```
 
 A bordered panel containing two columns (file tree on the left, status callout on the right), a labeled divider, and a status line. All from nested directives.

termrender-4.0.0/src/termrender/CLAUDE.md

@@ -0,0 +1,3 @@
+- **Nesting is by colon count** (`parser.py`, since `4a501d9`): an outer directive must use strictly MORE colons than the directive nested inside it — `::::columns` (4) wraps `:::col` (3); a leaf closes with a bare run of its own colon count. Equal-colon nesting is a `syntax_error` (the closer matches the wrong opener). Mirrors MyST colon fences. All docs/examples must follow this — `termrender doc check` is the gate.
+- **QUOTE** height gets `+1` only when `author` or `by` attr is set. Using any other key (`attribution`, `source`) silently omits the extra line — the renderer's attribution line is clipped.
+- **``` mermaid fences and `:::mermaid` both produce `BlockType.MERMAID`** (`parser.py::_convert_ast`, block_code handling): a fenced code block whose info string's first word is `mermaid` (case-insensitive) is special-cased to `BlockType.MERMAID` instead of `BlockType.CODE`, so GFM-style ``` ```mermaid ``` docs render the same as the directive form. This was a deliberate reversal of `083f590` (which had dropped fence support); any other language tag still falls through to a plain CODE block.

{termrender-3.0.1 → termrender-4.0.0}/src/termrender/__main__.py

@@ -63,20 +63,22 @@ Branches
 
 Document format
   Directive-flavored markdown. Triple-colon blocks carry attributes in {} and
-  nest arbitrarily; every block closes with a bare `:::`. Plain markdown
-  (headings, **bold**, *italic*, `code`, bullet/numbered lists) works
-  everywhere, including inside directives. Write structure, not box-drawing —
-  layout, padding, and guide lines are computed.
+  nest by COLON COUNT: an outer block needs strictly MORE colons than the block
+  nested inside it (::::columns wraps :::col), and each block closes with a bare
+  run of its own colon count on its own line. Plain markdown (headings, **bold**,
+  *italic*, `code`, bullet/numbered lists) works everywhere, including inside
+  directives. Write structure, not box-drawing — layout, padding, and guide
+  lines are computed.
 
   :::panel{title="" color=""}            bordered box; color e.g. green|cyan|red
-  :::columns / :::col{width="N%"}        side-by-side; col widths sum to 100%
+  ::::columns / :::col{width="N%"}       side-by-side; col widths sum to 100%
   :::tree{color=""}                      indentation → Unicode guide lines;
                                          [x]=done [!]=warning status markers
   :::callout{type=""}                     admonition; type success|warning|error|info
   :::divider{label=""}                    labeled horizontal rule
   :::code{lang=""}                        syntax-highlighted block (``` fences also work)
   :::quote{author=""}                     attributed block quote
-  :::mermaid                             flowchart → ASCII (NOT ```mermaid fences)
+  :::mermaid                             flowchart → ASCII (``` mermaid fences also work)
 """
 
 _DOC_RENDER_HELP = """\

{termrender-3.0.1 → termrender-4.0.0}/src/termrender/parser.py

@@ -303,10 +303,21 @@ def _convert_ast(nodes: list[dict], _depth: int = 0) -> list[Block]:
         elif ntype == "block_code":
             raw = node.get("raw", "")
             info = node.get("attrs", {}).get("info", "")
-            blocks.append(Block(
-                type=BlockType.CODE,
-                attrs={"lang": info, "source": raw},
-            ))
+            # A ```mermaid fence is GFM's standard way to tag a mermaid diagram
+            # (GitHub, and most docs/agents that don't know this project's
+            # :::mermaid directive, use this form) — route it through the
+            # mermaid renderer same as :::mermaid, instead of a plain code panel.
+            lang = info.split()[0].lower() if info.split() else ""
+            if lang == "mermaid":
+                blocks.append(Block(
+                    type=BlockType.MERMAID,
+                    attrs={"source": raw},
+                ))
+            else:
+                blocks.append(Block(
+                    type=BlockType.CODE,
+                    attrs={"lang": info, "source": raw},
+                ))
 
         elif ntype == "list":
             ordered = node.get("attrs", {}).get("ordered", False)

{termrender-3.0.1 → termrender-4.0.0}/src/termrender/renderers/CLAUDE.md

@@ -53,4 +53,6 @@ Attribution line is rendered for `block.attrs["author"]` **or** `block.attrs["by
 
 Layout pre-renders into `block.attrs["_rendered"]` (see `src/termrender/CLAUDE.md`); this renderer re-runs the subprocess only when that key is absent.
 
+**Flowchart node shapes are normalized to rectangles**: `preprocess_mermaid_for_ascii` rewrites every non-rectangle flowchart node shape (`{rhombus}`, `[(cylinder)]`, `((circle))`, `([stadium])`, `{{hexagon}}`, `[[subroutine]]`, `[/parallelogram/]`) to the `id[label]` form via `_FLOWCHART_SHAPE_SUBS`, because mermaid-ascii's `parseNode` only recognizes `[text]` rectangles — other shapes otherwise leak raw delimiters or the bare node id into the box. This is a permanent workaround: node shapes are unsupported on current upstream master (pin `6fffb8e`) and the 6 newer master commits are arrow-parsing only, so don't expect a pin bump to remove the need. The backend draws a rectangle regardless, so only the label text matters.
+
 **Binary resolution & no width flag**: the executable comes from `_mermaid_bin.mermaid_ascii_bin()` — the vendored `_bin/mermaid-ascii-<os>-<arch>` (pinned upstream master `6fffb8e`, built via `scripts/build-mermaid-ascii.sh`) if present for the platform, else `mermaid-ascii` on PATH (the PyPI wheel, capped at 1.2.0). **`mermaid-ascii` has no width-control flag** (never has — `--maxWidth`/`-w` do not exist); the call passes only `-f - -y 1`, so `block.width` does not constrain the diagram and wide output overflows (compounding the no-truncation gotcha above). A labeled back-edge (`X -->|lbl| Y` in `graph LR`) panics the binary on **both** 1.2.0 and master; the non-zero exit is caught and the block degrades to raw source.

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

@@ -0,0 +1,142 @@
+"""Mermaid diagram renderer for termrender."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+
+from termrender._mermaid_bin import mermaid_ascii_bin
+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)
+
+# Flowchart node-shape normalizers. mermaid-ascii only parses the ``[text]``
+# rectangle form; every other mermaid node shape leaks its raw delimiters (or
+# the node id) into the rendered box — e.g. ``B{Auth?}`` renders the literal
+# ``B{Auth?}`` and ``E[(Database)]`` renders ``(Database)``. Since mermaid-ascii
+# draws every node as a rectangle regardless, we rewrite each alternate shape to
+# ``id[label]``, preserving the label text and dropping only the shape (which
+# the ASCII backend cannot draw anyway). Order matters: multi-char delimiters
+# (``{{``, ``[[``, ``[(``, ``((``, ``([``) must run before their single-char
+# counterparts so the greedy single forms don't bite off half a delimiter.
+_FLOWCHART_SHAPE_SUBS: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"(\w+)\{\{(.+?)\}\}"), r"\1[\2]"),        # hexagon {{ }}
+    (re.compile(r"(\w+)\[\[(.+?)\]\]"), r"\1[\2]"),        # subroutine [[ ]]
+    (re.compile(r"(\w+)\[\((.+?)\)\]"), r"\1[\2]"),        # cylinder [( )]
+    (re.compile(r"(\w+)\(\(\((.+?)\)\)\)"), r"\1[\2]"),    # double circle ((( )))
+    (re.compile(r"(\w+)\(\((.+?)\)\)"), r"\1[\2]"),        # circle (( ))
+    (re.compile(r"(\w+)\(\[(.+?)\]\)"), r"\1[\2]"),        # stadium ([ ])
+    (re.compile(r"(\w+)\[[\\/](.+?)[\\/]\]"), r"\1[\2]"),  # parallelogram/trapezoid [/ /] [\ \] [/ \] [\ /]
+    (re.compile(r"(\w+)\{(.+?)\}"), r"\1[\2]"),            # rhombus { }
+    (re.compile(r"(\w+)>(.+?)\]"), r"\1[\2]"),             # asymmetric/flag > ]
+    (re.compile(r"(\w+)\((.+?)\)"), r"\1[\2]"),            # round ( )
+]
+_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 normalize_flowchart_shapes(source: str) -> str:
+    """Rewrite alternate flowchart node shapes to the ``[text]`` form.
+
+    mermaid-ascii only parses rectangle nodes (``id[text]``); rhombus ``{}``,
+    cylinder ``[()]``, circle ``(())``, stadium ``([])``, hexagon ``{{}}``,
+    subroutine ``[[]]``, and parallelogram/trapezoid ``[/ /]`` nodes otherwise
+    render with their raw delimiters or bare node id. Each is rewritten to
+    ``id[text]`` so the label survives; the backend draws a rectangle either way.
+    """
+    out: list[str] = []
+    for line in source.splitlines():
+        for pattern, repl in _FLOWCHART_SHAPE_SUBS:
+            line = pattern.sub(repl, line)
+        out.append(line)
+    return "\n".join(out)
+
+
+def preprocess_mermaid_for_ascii(source: str) -> str:
+    """Rewrite a mermaid diagram into the subset mermaid-ascii supports.
+
+    For sequence diagrams: convert ``Note`` lines into self-loops, map the
+    arrow variants (``->``, ``-x``, ``--x``, ``-)``, ``--)``, ``-->``) to the
+    supported ``->>``/``-->>`` pair, drop block keywords (``loop``, ``alt``,
+    ``activate``…), and flatten ``<br/>`` tags. For flowcharts (``graph`` /
+    ``flowchart``): normalize alternate node shapes to ``[text]`` rectangles.
+    Other diagram types are returned unchanged.
+    """
+    lines = source.splitlines()
+    first = next((l.strip() for l in lines if l.strip()), "")
+    first_lower = first.lower()
+    if not first_lower.startswith("sequencediagram"):
+        if first_lower.startswith(("graph", "flowchart")):
+            return normalize_flowchart_shapes(source)
+        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_bin(), "-f", "-", "-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-3.0.1 → termrender-4.0.0}/tests/test_mermaid_compat.py

@@ -5,10 +5,46 @@ from termrender.renderers.mermaid import preprocess_mermaid_for_ascii
 
 class TestMermaidPreprocessor(unittest.TestCase):
 
-    def test_non_sequence_diagrams_pass_through(self):
+    def test_unknown_diagram_types_pass_through(self):
+        src = "pie\n    \"A\" : 40\n    \"B\" : 60"
+        self.assertEqual(preprocess_mermaid_for_ascii(src), src)
+
+    def test_flowchart_plain_edges_pass_through(self):
         src = "flowchart TD\n    A-->B\n    B-->C"
         self.assertEqual(preprocess_mermaid_for_ascii(src), src)
 
+    # Regression: mermaid-ascii (pinned master 6fffb8e) only parses ``[text]``
+    # rectangle nodes — every other mermaid node shape leaked its raw delimiters
+    # or bare node id into the rendered box (``B{Auth?}`` rendered the literal
+    # ``B{Auth?}``; ``E[(Database)]`` rendered ``(Database)``). Node shapes are
+    # still unsupported upstream (parseNode only handles rectangles), so we
+    # normalize every shape to ``id[label]`` on our side.
+    def test_flowchart_node_shapes_normalized_to_rectangles(self):
+        src = (
+            "graph LR\n"
+            "    A[Client] --> B{Auth?}\n"
+            "    B -->|Yes| C[Handler]\n"
+            "    C --> E[(Database)]\n"
+            "    F((Circle)) --> G([Stadium])\n"
+            "    G --> H{{Hex}}\n"
+            "    H --> I[[Sub]]\n"
+            "    I --> J[/Para/]"
+        )
+        out = preprocess_mermaid_for_ascii(src)
+        self.assertIn("B[Auth?]", out)
+        self.assertIn("E[Database]", out)
+        self.assertIn("F[Circle]", out)
+        self.assertIn("G[Stadium]", out)
+        self.assertIn("H[Hex]", out)
+        self.assertIn("I[Sub]", out)
+        self.assertIn("J[Para]", out)
+        # Rectangle nodes and edge labels are untouched.
+        self.assertIn("A[Client]", out)
+        self.assertIn("|Yes|", out)
+        # No raw alternate delimiters survive.
+        for leak in ("{Auth?}", "[(", "((", "))", "{{", "}}", "[[", "]]"):
+            self.assertNotIn(leak, out)
+
     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)

{termrender-3.0.1 → termrender-4.0.0}/tests/test_myst_gaps.py

@@ -7,7 +7,7 @@ from termrender.parser import parse, _strip_options
 
 
 class TestMermaidDirective(unittest.TestCase):
-    """:::mermaid is the only fence form for mermaid diagrams."""
+    """:::mermaid and ```mermaid fences both produce mermaid diagrams."""
 
     def test_basic_mermaid_directive(self):
         """:::mermaid\ngraph LR\nA-->B\n::: → BlockType.MERMAID"""
@@ -26,12 +26,12 @@ class TestMermaidDirective(unittest.TestCase):
         self.assertIn("graph LR", block.attrs["source"])
         self.assertNotIn(":title:", block.attrs["source"])
 
-    def test_backtick_mermaid_is_plain_code_block(self):
-        """```mermaid is no longer a mermaid block — it renders as a code block."""
+    def test_backtick_mermaid_is_mermaid_block(self):
+        """```mermaid fences route through the mermaid renderer, same as :::mermaid."""
         doc = parse("```mermaid\ngraph LR\nA-->B\n```")
         block = doc.children[0]
-        self.assertEqual(block.type, BlockType.CODE)
-        self.assertEqual(block.attrs.get("lang"), "mermaid")
+        self.assertEqual(block.type, BlockType.MERMAID)
+        self.assertIn("graph LR", block.attrs["source"])
 
     def test_backtick_directive_is_plain_code_block(self):
         """```{panel} is no longer a directive — it renders as a code block."""

termrender-3.0.1/src/termrender/CLAUDE.md

@@ -1 +0,0 @@
-- **QUOTE** height gets `+1` only when `author` or `by` attr is set. Using any other key (`attribution`, `source`) silently omits the extra line — the renderer's attribution line is clipped.

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

@@ -1,99 +0,0 @@
-"""Mermaid diagram renderer for termrender."""
-
-from __future__ import annotations
-
-import re
-import subprocess
-
-from termrender._mermaid_bin import mermaid_ascii_bin
-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_bin(), "-f", "-", "-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