termrender 4.9.1__tar.gz → 4.10.0__tar.gz

{termrender-4.9.1 → termrender-4.10.0}/CHANGELOG.md

@@ -1,6 +1,38 @@
 # CHANGELOG
 
 
+## v4.10.0 (2026-07-07)
+
+### Features
+
+- **mermaid**: Native dispatch for flowchart/class/state/er, drop vendored Go binary
+  ([`6935f30`](https://github.com/crouton-labs/termrender/commit/6935f30a1dccfefcc34344de02191f8481d53668))
+
+Wire the four previously-unwired native renderers into mermaid.py's first-line dispatcher:
+  flowchart/graph -> mermaid_flow.render_flowchart, classDiagram -> mermaid_class.render_class,
+  stateDiagram/-v2 -> mermaid_state.render_state, erDiagram -> mermaid_er.render_er. Every mermaid
+  type termrender renders is now native Python; no diagram type shells out anymore.
+
+Unrecognized/exotic types (sankey, C4, gitgraph, block, packet, kanban, quadrantChart, ...) degrade
+  in the dispatcher itself to a raw echo of the source with box-drawing/geometric glyphs stripped,
+  preserving the contract the crouter attach viewer relies on to detect render failure by glyph
+  absence.
+
+Delete the vendored Go path entirely: src/termrender/_bin/ (binary), src/termrender/_mermaid_bin.py,
+  scripts/build-mermaid-ascii.sh, the mermaid-ascii runtime dependency and hatch artifacts stanza in
+  pyproject.toml (relocked via uv.lock), and scripts/mermaid_flow_parity.py (a standalone dev-only
+  harness comparing native output against the now-deleted binary).
+
+tests/test_mermaid_compat.py pinned Go-era preprocessing (preprocess_mermaid_for_ascii) that no
+  longer exists; deleted wholesale since dispatch/prelude contracts it also touched already live in
+  test_mermaid_dispatch.py. That file's routing tests are updated for the four newly-wired types and
+  gain dispatch tests for the exotic raw-echo path (including a no-native-renderer-called assertion
+  and a glyph-range sweep pinning the no-box-glyph contract).
+
+Swept src/termrender/renderers/CLAUDE.md and README.md to current-state only; no remaining
+  references to mermaid-ascii/_mermaid_bin/the Go binary anywhere in the tree.
+
+
 ## v4.9.1 (2026-07-07)
 
 ### Bug Fixes

{termrender-4.9.1 → termrender-4.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 4.9.1
+Version: 4.10.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
@@ -22,7 +22,6 @@ Classifier: Topic :: Terminals
 Classifier: Topic :: Text Processing :: Markup :: Markdown
 Requires-Python: >=3.10
 Requires-Dist: grandalf>=0.8
-Requires-Dist: mermaid-ascii>=1.2
 Requires-Dist: mistune>=3.0
 Requires-Dist: pygments>=2.0
 Description-Content-Type: text/markdown
@@ -163,7 +162,7 @@ That entire output — the nested borders, the tree guide lines, the side-by-sid
 pip install termrender
 ```
 
-Python 3.10+. Three dependencies: [mistune](https://github.com/lepture/mistune) (markdown parsing), [pygments](https://pygments.org/) (syntax highlighting), [mermaid-ascii](https://github.com/mermaid-js/mermaid-ascii) (diagram rendering).
+Python 3.10+. Three dependencies: [mistune](https://github.com/lepture/mistune) (markdown parsing), [pygments](https://pygments.org/) (syntax highlighting), [grandalf](https://github.com/bdcht/grandalf) (mermaid diagram layout).
 
 
 ## Usage
@@ -409,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). Use the `:::mermaid` directive, or a standard GFM ` ```mermaid ` fenced code block — both render the same diagram.
+Renders mermaid diagrams (flowcharts, class/state/ER diagrams, pie/gantt/sequence/mindmap/journey/timeline charts) natively as ASCII/unicode art. Use the `:::mermaid` directive, or a standard GFM ` ```mermaid ` fenced code block — both render the same diagram.
 
 **Input:**
 ```markdown
@@ -421,7 +420,7 @@ graph LR
 :::
 ```
 
-The diagram gets rendered as ASCII art inline in the terminal output. Requires `mermaid-ascii` to be installed (it's a dependency, so it should be).
+The diagram gets rendered as ASCII art inline in the terminal output, no external binary required.
 
 
 ### Nesting

{termrender-4.9.1 → termrender-4.10.0}/README.md

@@ -134,7 +134,7 @@ That entire output — the nested borders, the tree guide lines, the side-by-sid
 pip install termrender
 ```
 
-Python 3.10+. Three dependencies: [mistune](https://github.com/lepture/mistune) (markdown parsing), [pygments](https://pygments.org/) (syntax highlighting), [mermaid-ascii](https://github.com/mermaid-js/mermaid-ascii) (diagram rendering).
+Python 3.10+. Three dependencies: [mistune](https://github.com/lepture/mistune) (markdown parsing), [pygments](https://pygments.org/) (syntax highlighting), [grandalf](https://github.com/bdcht/grandalf) (mermaid diagram layout).
 
 
 ## Usage
@@ -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). Use the `:::mermaid` directive, or a standard GFM ` ```mermaid ` fenced code block — both render the same diagram.
+Renders mermaid diagrams (flowcharts, class/state/ER diagrams, pie/gantt/sequence/mindmap/journey/timeline charts) natively as ASCII/unicode art. Use the `:::mermaid` directive, or a standard GFM ` ```mermaid ` fenced code block — both render the same diagram.
 
 **Input:**
 ```markdown
@@ -392,7 +392,7 @@ graph LR
 :::
 ```
 
-The diagram gets rendered as ASCII art inline in the terminal output. Requires `mermaid-ascii` to be installed (it's a dependency, so it should be).
+The diagram gets rendered as ASCII art inline in the terminal output, no external binary required.
 
 
 ### Nesting

{termrender-4.9.1 → termrender-4.10.0}/pyproject.toml

@@ -28,7 +28,6 @@ classifiers = [
 ]
 dependencies = [
     "mistune>=3.0",
-    "mermaid-ascii>=1.2",
     "pygments>=2.0",
     "grandalf>=0.8",
 ]
@@ -46,11 +45,6 @@ source = "vcs"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/termrender"]
-# Ship the vendored mermaid-ascii binary (built from pinned upstream master;
-# see scripts/build-mermaid-ascii.sh). It lives inside the package dir so the
-# default file selection includes it; artifacts ensures it survives even if
-# VCS-ignored, and hatchling preserves its 0o755 exec bit.
-artifacts = ["src/termrender/_bin/*"]
 
 [tool.semantic_release]
 version_toml = []

{termrender-4.9.1 → termrender-4.10.0}/src/termrender/renderers/CLAUDE.md

@@ -43,20 +43,14 @@ Attribution line is rendered for `block.attrs["author"]` **or** `block.attrs["by
 
 `mermaid.py`'s `render(block, color)` (leaf signature, no `render_child` — the parent `CLAUDE.md` incorrectly lists mermaid as a Container renderer) is a thin wrapper: it reads `block.attrs["_rendered"]` if layout already precomputed it, else calls `render_mermaid_lines(source, width)`, then pads every line to `block.width` with `visual_ljust`. All the type-routing logic lives in `render_mermaid_lines`, shared with `layout.py`'s height pass (see below) so there is exactly one dispatch path, not two.
 
-**Dispatch is by first real line, case-insensitive** (`_first_line_type`), after skipping any prelude via `mermaid_prelude.strip_prelude_lines` (see below): `pie`, `gantt`, `sequenceDiagram`, `mindmap`, `journey`, and `timeline` route to native Python renderers (`mermaid_pie.py`, `mermaid_gantt.py`, `mermaid_sequence.py`, `mermaid_mindmap.py`, `mermaid_journey.py`, `mermaid_timeline.py`). Every other type — `graph`/`flowchart`, `classDiagram`, `stateDiagram`, `erDiagram`, … — routes to `_render_via_binary`, the pre-existing single path through the vendored Go `mermaid-ascii` binary. **Only the six listed types have native renderers; every other type's degradation is byte-for-byte what it was before this dispatcher existed** — do not add a bordered fallback panel for them, since crouter's attach viewer detects render failure by the *absence* of box-drawing glyphs in the output, and a decorative border would defeat that.
+**Dispatch is by first real line, case-insensitive** (`_first_line_type`), after skipping any prelude via `mermaid_prelude.strip_prelude_lines` (see below): `pie`, `gantt`, `sequenceDiagram`, `mindmap`, `journey`, `timeline`, `graph`/`flowchart`, `classDiagram`, `stateDiagram`/`stateDiagram-v2`, and `erDiagram` all route to dedicated native Python renderers (`mermaid_pie.py`, `mermaid_gantt.py`, `mermaid_sequence.py`, `mermaid_mindmap.py`, `mermaid_journey.py`, `mermaid_timeline.py`, `mermaid_flow.py::render_flowchart`, `mermaid_class.py::render_class`, `mermaid_state.py::render_state`, `mermaid_er.py::render_er`). Every other type (sankey, C4, gitgraph, block, packet, kanban, quadrantChart, …, and anything unrecognized) has no renderer at all and degrades in the dispatcher itself, via `_raw_echo`: the source lines verbatim, `.rstrip()`-ed, with any box-drawing/geometric glyph (`\u2500-\u259f`/`\u25a0-\u25ff`) replaced by `?`. **Do not add a bordered fallback panel for the exotic path** — crouter's attach viewer detects render failure by the *absence* of box-drawing glyphs in the output, and a decorative border would defeat that; the four flowchart-model-backed native renderers (flow/class/state/ER) uphold the identical no-glyph guarantee on their own internal degradation paths (malformed input, wrong header, zero nodes/classes/states/entities parsed, or an unexpected exception escaping layout) — see each module's own docstring.
 
-**`mermaid_prelude.py`** — a tiny shared module (no dependency on `Block` or the rest of the pipeline) implementing `strip_prelude_lines(lines)`, used by both `mermaid.py`'s dispatch sniff and `mermaid_sequence.py`'s own header check. It skips leading blank lines, `%%` line comments, `%%{init: ...}%%` directives, and `---`-delimited YAML frontmatter, permissively: an unterminated frontmatter block or directive is left alone rather than eating real content. Prelude stripping is for *sniffing/validating the type line only* — the per-type body parsers still receive the full untouched source; `mermaid_sequence.py`'s `_parse` already tolerates arbitrary prelude lines before its header (they fail every line pattern and are skipped via its `seen_header` gate), and `mermaid_pie.py`/`mermaid_gantt.py`/the mindmap/journey/timeline parsers likewise just skip lines that don't match their grammar — a frontmatter `title: X` line could in principle collide with a `title` grammar rule, but this is accepted as the same class of pragmatic-parsing tradeoff as any other unrecognized line, not something the prelude skip needs to prevent.
+**`mermaid_prelude.py`** — a tiny shared module (no dependency on `Block` or the rest of the pipeline) implementing `strip_prelude_lines(lines)`, used by `mermaid.py`'s dispatch sniff and by every native renderer's own header check (`mermaid_sequence.py`, `mermaid_flow_parser.py`, `mermaid_class.py`, `mermaid_state.py`, `mermaid_er.py`). It skips leading blank lines, `%%` line comments, `%%{init: ...}%%` directives, and `---`-delimited YAML frontmatter, permissively: an unterminated frontmatter block or directive is left alone rather than eating real content. Prelude stripping is for *sniffing/validating the type line only* — most per-type body parsers receive the full untouched source and do their own prelude-aware header check internally (flow/class/state/ER/sequence); `mindmap`/`journey`/`timeline` are the exception, called with `mermaid.py::_stripped(source)` since those parsers don't skip prelude themselves. `mermaid_pie.py`/`mermaid_gantt.py` just skip lines that don't match their grammar — a frontmatter `title: X` line could in principle collide with a `title` grammar rule, but this is accepted as the same class of pragmatic-parsing tradeoff as any other unrecognized line.
 
-**`_render_via_binary`** (used for flowchart/graph/class/state/ER/everything-without-a-native-renderer): normalizes via `preprocess_mermaid_for_ascii`, shells out with `check=True`, and undoes the Latin-1 double-encoding via `fix_mermaid_encoding` (`mermaid-ascii` misreads UTF-8 input as Latin-1 and re-encodes, corrupting multi-byte characters — e.g. `→` becomes `â\x86\x92`; `text.encode("latin-1").decode("utf-8")` reverses it, and on failure silently returns the corrupted string). Any failure — `CalledProcessError` (including a non-zero exit, now actually checked via `check=True`), missing binary, or timeout — degrades to the raw source text. A labeled back-edge (`X -->|lbl| Y` in `graph LR`) panics the binary on both the PyPI 1.2.0 wheel and vendored master; the resulting non-zero exit degrades the same way. Note `preprocess_mermaid_for_ascii` has its own independent first-line sniff (not `mermaid_prelude`-aware) to decide sequence-vs-flowchart-vs-other normalization — a prelude ahead of `graph`/`flowchart`/`sequenceDiagram` here means no shape/arrow normalization runs, an existing (unfixed) limitation of the binary path, orthogonal to dispatch routing.
-
-**`visual_ljust` pads but never truncates**: every output line (from any type — binary or native) is padded to `block.width` in the outer `render()`. Lines wider than `block.width` overflow without clipping. `mermaid-ascii` has no width-control flag (`--maxWidth`/`-w` do not exist — the call passes only `-f - -y 1`), so wide flowchart output silently exceeds the layout boundary; the native renderers respect `width` by construction (pie/gantt/timeline size their own bars to it; sequence/mindmap/journey have intrinsic width and may overflow, matching the binary path's contract) — see each renderer's own note below.
+**`visual_ljust` pads but never truncates**: every output line (from any type) is padded to `block.width` in the outer `render()`. Lines wider than `block.width` overflow without clipping — pie/gantt/timeline size their own bars to `width`; sequence/mindmap/journey and the four flowchart-model-backed renderers (flow/class/state/ER) have intrinsic content-driven width and may overflow, `width` there is advisory only.
 
 Layout (`layout.py::resolve_height`, `BlockType.MERMAID` branch) precomputes `block.attrs["_rendered"]` by calling the same `render_mermaid_lines`, so `mermaid.py`'s `render()` only recomputes when that key is absent (e.g. calling `render()` on a block that skipped the layout pass).
 
-**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**: 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_pie.py` — re-expressed as a bar chart, not a text circle
 
 A text pie chart is worse than a labeled bar chart at the same information density (per the ratified plan), so `parse_pie` extracts `(title, items)` from the `pie [showData]` / `title …` / `"label" : value` grammar and `render` hands the items to `charts.py::render_bar` via a synthetic `Block(type=BlockType.BAR, ...)` — no duplicated bar-drawing logic. Each item's `unit` attr is set to the pre-formatted percentage string (e.g. `" (40.0%)"`) so `render_bar`'s existing value-formatting appends it for free. Called with `color=False` always — mermaid output is monochrome by design (the attach viewer relies on `--color on == --color off`). Unparseable/empty input degrades to the raw source lines, same contract as the binary path.

{termrender-4.9.1 → termrender-4.10.0}/src/termrender/renderers/borders.py

@@ -31,9 +31,10 @@ def render_box(
     corner_v = visual_len("┌")  # same as ┐, └, ┘
 
     # Grow the box if any content line (or the title) won't fit at the
-    # requested width. mermaid-ascii has no width-control flag, so a child
-    # mermaid block can return lines wider than its allocated content area.
-    # Truncating would corrupt the diagram; growing keeps the box's top,
+    # requested width. Several mermaid renderers size to content rather than
+    # to width (flowchart/class/state/ER/sequence/mindmap/journey), so a
+    # child mermaid block can return lines wider than its allocated content
+    # area. Truncating would corrupt the diagram; growing keeps the box's top,
     # bottom, and side borders aligned at the same column even if it
     # overflows the parent's allocation.
     content_max = visual_len("")

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

@@ -0,0 +1,117 @@
+"""Mermaid diagram renderer for termrender."""
+
+from __future__ import annotations
+
+import re
+
+from termrender.blocks import Block
+from termrender.renderers import (
+    mermaid_class,
+    mermaid_er,
+    mermaid_flow,
+    mermaid_gantt,
+    mermaid_journey,
+    mermaid_mindmap,
+    mermaid_pie,
+    mermaid_sequence,
+    mermaid_state,
+    mermaid_timeline,
+)
+from termrender.renderers.mermaid_prelude import strip_prelude_lines
+from termrender.style import visual_ljust
+
+# Same box-drawing/geometric glyph ranges the native renderers (mermaid_flow,
+# mermaid_class, mermaid_state, mermaid_er) guard their own raw-echo paths
+# with, and the same ranges the downstream crouter viewer keys on to detect
+# render *success*. An exotic/unrecognized diagram type has no renderer at
+# all, so its degradation lives here rather than in a shared renderer module;
+# it must uphold the identical contract — no such glyph survives the echo,
+# even one present verbatim in the source itself.
+_GLYPH_RANGE_RE = re.compile("[\u2500-\u259f\u25a0-\u25ff]")
+
+
+def _first_line_type(source: str) -> str:
+    """Return the lowercased first real line's leading keyword.
+
+    This is the dispatch key: mermaid identifies a diagram's type from its
+    first line (``graph``/``flowchart``, ``pie``, ``gantt``, ``sequenceDiagram``,
+    ``classDiagram``, ``stateDiagram``, ``erDiagram``, …), after skipping any
+    prelude (blank lines, ``%%`` comments/directives, ``---`` YAML
+    frontmatter — see ``mermaid_prelude.py``). Returns ``""`` for a source
+    with no real content past its prelude.
+    """
+    lines = strip_prelude_lines(source.splitlines())
+    first = next((l.strip() for l in lines if l.strip()), "")
+    return first.lower()
+
+
+def _stripped(source: str) -> str:
+    """Return ``source`` with its leading prelude (comments/directives/
+    frontmatter) removed, for native renderers that don't otherwise skip it.
+    """
+    return "\n".join(strip_prelude_lines(source.splitlines()))
+
+
+def _raw_echo(source: str) -> list[str]:
+    """Degrade an exotic/unrecognized diagram type to its raw source lines.
+
+    No renderer exists for these types (sankey, C4, gitgraph, block, packet,
+    kanban, quadrantChart, …, and anything unrecognized): the source is
+    echoed back verbatim, with box-drawing/geometric glyphs neutralized so
+    the crouter viewer's "no glyphs survived" success check can't be fooled
+    by one present in the raw source itself — the same guarantee every
+    native renderer's own raw-echo path upholds.
+    """
+    return [
+        _GLYPH_RANGE_RE.sub("?", line.rstrip()) for line in source.splitlines()
+    ]
+
+
+def render_mermaid_lines(source: str, width: int) -> list[str]:
+    """Dispatch a mermaid source to its type's renderer and return raw lines.
+
+    Every diagram type mermaid supports that termrender renders has a
+    dedicated native Python renderer: ``pie``, ``gantt``, ``sequenceDiagram``,
+    ``mindmap``, ``journey``, ``timeline``, ``graph``/``flowchart``,
+    ``classDiagram``, ``stateDiagram``/``stateDiagram-v2``, and ``erDiagram``.
+    Any other type (sankey, C4, gitgraph, block, packet, kanban, …, or
+    anything unrecognized) degrades to a raw echo of the source with no
+    box-drawing glyphs — see :func:`_raw_echo`. Lines are returned unpadded;
+    callers apply width padding uniformly.
+    """
+    diagram_type = _first_line_type(source)
+    if diagram_type.startswith("pie"):
+        return mermaid_pie.render(source, width)
+    if diagram_type.startswith("gantt"):
+        return mermaid_gantt.render(source, width)
+    if diagram_type.startswith("sequencediagram"):
+        return mermaid_sequence.render_sequence(source, width)
+    if diagram_type.startswith("mindmap"):
+        return mermaid_mindmap.render(_stripped(source), width)
+    if diagram_type.startswith("journey"):
+        return mermaid_journey.render(_stripped(source), width)
+    if diagram_type.startswith("timeline"):
+        return mermaid_timeline.render(_stripped(source), width)
+    if diagram_type.startswith(("graph", "flowchart")):
+        return mermaid_flow.render_flowchart(source, width)
+    if diagram_type.startswith("classdiagram"):
+        return mermaid_class.render_class(source, width)
+    if diagram_type.startswith("statediagram"):
+        return mermaid_state.render_state(source, width)
+    if diagram_type.startswith("erdiagram"):
+        return mermaid_er.render_er(source, width)
+    return _raw_echo(source)
+
+
+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", "")
+        raw_lines = render_mermaid_lines(source, w or 60)
+    else:
+        raw_lines = rendered.split("\n")
+
+    return [visual_ljust(raw_line, w) for raw_line in raw_lines]

{termrender-4.9.1 → termrender-4.10.0}/tests/test_mermaid_dispatch.py

@@ -7,143 +7,201 @@ from termrender.renderers import mermaid
 class TestMermaidDispatch(unittest.TestCase):
     """Routing tests for mermaid.py's first-line type dispatcher.
 
-    These mock the per-type renderers/binary call so they verify *routing*
-    only, independent of the actual rendering logic (covered by
+    These mock the per-type renderers so they verify *routing* only,
+    independent of the actual rendering logic (covered by
     test_mermaid_pie.py, test_mermaid_gantt.py, test_mermaid_sequence.py,
     test_mermaid_mindmap.py, test_mermaid_journey.py, test_mermaid_timeline.py,
-    and test_mermaid_compat.py).
+    test_mermaid_flow.py, test_mermaid_class.py, test_mermaid_state.py, and
+    test_mermaid_er.py).
     """
 
     def test_pie_routes_to_native_pie_renderer(self):
         with mock.patch(
             "termrender.renderers.mermaid.mermaid_pie.render", return_value=["PIE"]
-        ) as pie_mock, mock.patch(
-            "termrender.renderers.mermaid._render_via_binary"
-        ) as binary_mock:
+        ) as pie_mock:
             lines = mermaid.render_mermaid_lines('pie\n    "A" : 1', 40)
             self.assertEqual(lines, ["PIE"])
             pie_mock.assert_called_once()
-            binary_mock.assert_not_called()
 
     def test_gantt_routes_to_native_gantt_renderer(self):
         with mock.patch(
             "termrender.renderers.mermaid.mermaid_gantt.render", return_value=["GANTT"]
-        ) as gantt_mock, mock.patch(
-            "termrender.renderers.mermaid._render_via_binary"
-        ) as binary_mock:
+        ) as gantt_mock:
             lines = mermaid.render_mermaid_lines("gantt\n    dateFormat YYYY-MM-DD", 40)
             self.assertEqual(lines, ["GANTT"])
             gantt_mock.assert_called_once()
-            binary_mock.assert_not_called()
 
-    def test_graph_routes_to_binary_fallback(self):
+    def test_graph_routes_to_native_flowchart_renderer(self):
         with mock.patch(
-            "termrender.renderers.mermaid._render_via_binary", return_value="RENDERED"
-        ) as binary_mock:
+            "termrender.renderers.mermaid.mermaid_flow.render_flowchart",
+            return_value=["FLOW"],
+        ) as flow_mock:
             lines = mermaid.render_mermaid_lines("graph LR\nA-->B", 40)
-            self.assertEqual(lines, ["RENDERED"])
-            binary_mock.assert_called_once()
+            self.assertEqual(lines, ["FLOW"])
+            flow_mock.assert_called_once()
 
-    def test_flowchart_routes_to_binary_fallback(self):
+    def test_flowchart_routes_to_native_flowchart_renderer(self):
         with mock.patch(
-            "termrender.renderers.mermaid._render_via_binary", return_value="RENDERED"
-        ) as binary_mock:
+            "termrender.renderers.mermaid.mermaid_flow.render_flowchart",
+            return_value=["FLOW"],
+        ) as flow_mock:
             mermaid.render_mermaid_lines("flowchart TD\nA-->B", 40)
-            binary_mock.assert_called_once()
+            flow_mock.assert_called_once()
+
+    def test_class_diagram_routes_to_native_class_renderer(self):
+        with mock.patch(
+            "termrender.renderers.mermaid.mermaid_class.render_class",
+            return_value=["CLASS"],
+        ) as class_mock:
+            lines = mermaid.render_mermaid_lines("classDiagram\n    Animal <|-- Duck", 40)
+            self.assertEqual(lines, ["CLASS"])
+            class_mock.assert_called_once()
+
+    def test_state_diagram_routes_to_native_state_renderer(self):
+        with mock.patch(
+            "termrender.renderers.mermaid.mermaid_state.render_state",
+            return_value=["STATE"],
+        ) as state_mock:
+            lines = mermaid.render_mermaid_lines("stateDiagram-v2\n    [*] --> Idle", 40)
+            self.assertEqual(lines, ["STATE"])
+            state_mock.assert_called_once()
+
+    def test_er_diagram_routes_to_native_er_renderer(self):
+        with mock.patch(
+            "termrender.renderers.mermaid.mermaid_er.render_er", return_value=["ER"]
+        ) as er_mock:
+            lines = mermaid.render_mermaid_lines("erDiagram\n    A ||--o{ B : has", 40)
+            self.assertEqual(lines, ["ER"])
+            er_mock.assert_called_once()
 
     def test_sequence_routes_to_native_sequence_renderer(self):
         with mock.patch(
             "termrender.renderers.mermaid.mermaid_sequence.render_sequence",
             return_value=["SEQ"],
-        ) as seq_mock, mock.patch(
-            "termrender.renderers.mermaid._render_via_binary"
-        ) as binary_mock:
+        ) as seq_mock:
             lines = mermaid.render_mermaid_lines("sequenceDiagram\n    A->>B: hi", 40)
             self.assertEqual(lines, ["SEQ"])
             seq_mock.assert_called_once()
-            binary_mock.assert_not_called()
 
     def test_mindmap_routes_to_native_mindmap_renderer(self):
         with mock.patch(
             "termrender.renderers.mermaid.mermaid_mindmap.render", return_value=["MM"]
-        ) as mm_mock, mock.patch(
-            "termrender.renderers.mermaid._render_via_binary"
-        ) as binary_mock:
+        ) as mm_mock:
             lines = mermaid.render_mermaid_lines("mindmap\n  root", 40)
             self.assertEqual(lines, ["MM"])
             mm_mock.assert_called_once()
-            binary_mock.assert_not_called()
 
     def test_journey_routes_to_native_journey_renderer(self):
         with mock.patch(
             "termrender.renderers.mermaid.mermaid_journey.render", return_value=["J"]
-        ) as journey_mock, mock.patch(
-            "termrender.renderers.mermaid._render_via_binary"
-        ) as binary_mock:
+        ) as journey_mock:
             lines = mermaid.render_mermaid_lines("journey\n    title My journey", 40)
             self.assertEqual(lines, ["J"])
             journey_mock.assert_called_once()
-            binary_mock.assert_not_called()
 
     def test_timeline_routes_to_native_timeline_renderer(self):
         with mock.patch(
             "termrender.renderers.mermaid.mermaid_timeline.render", return_value=["T"]
-        ) as timeline_mock, mock.patch(
-            "termrender.renderers.mermaid._render_via_binary"
-        ) as binary_mock:
+        ) as timeline_mock:
             lines = mermaid.render_mermaid_lines("timeline\n    2024 : x", 40)
             self.assertEqual(lines, ["T"])
             timeline_mock.assert_called_once()
-            binary_mock.assert_not_called()
 
-    def test_unsupported_type_routes_to_binary_fallback(self):
-        for source in (
-            "classDiagram\n    Animal <|-- Duck",
-            "stateDiagram-v2\n    [*] --> Idle",
-            "erDiagram\n    A ||--o{ B : has",
+    def test_exotic_type_degrades_to_raw_echo(self):
+        src = "sankey-beta\n\nA,B,10\nB,C,5"
+        lines = mermaid.render_mermaid_lines(src, 40)
+        self.assertEqual(lines, src.splitlines())
+
+    def test_exotic_type_raw_echo_contains_no_box_glyphs(self):
+        # Pinning the degradation contract: the crouter viewer keys on the
+        # *absence* of box-drawing glyphs to keep the original code fence,
+        # so an exotic type's echo must never contain one — even one
+        # present verbatim in the source itself.
+        for src in (
+            "sankey-beta\nA,B,10",
+            "C4Context\n    Person(a, \"A\")",
+            "gitGraph\n    commit",
+            "block-beta\n    columns 1\n    a",
+            "packet-beta\n    0-15: \"data\"",
+            "kanban\n    Todo\n    Task1",
+            "totally-unknown-type\nsome line with a literal ┌ box glyph",
         ):
-            with mock.patch(
-                "termrender.renderers.mermaid._render_via_binary", return_value="X"
-            ) as binary_mock:
-                mermaid.render_mermaid_lines(source, 40)
-                binary_mock.assert_called_once()
+            lines = mermaid.render_mermaid_lines(src, 40)
+            joined = "\n".join(lines)
+            for cp in range(0x2500, 0x2600):
+                self.assertNotIn(chr(cp), joined)
+
+    def test_unknown_type_routes_to_raw_echo_not_any_native_renderer(self):
+        with mock.patch(
+            "termrender.renderers.mermaid.mermaid_flow.render_flowchart"
+        ) as flow_mock, mock.patch(
+            "termrender.renderers.mermaid.mermaid_class.render_class"
+        ) as class_mock, mock.patch(
+            "termrender.renderers.mermaid.mermaid_state.render_state"
+        ) as state_mock, mock.patch(
+            "termrender.renderers.mermaid.mermaid_er.render_er"
+        ) as er_mock:
+            mermaid.render_mermaid_lines("sankey-beta\nA,B,10", 40)
+            flow_mock.assert_not_called()
+            class_mock.assert_not_called()
+            state_mock.assert_not_called()
+            er_mock.assert_not_called()
+
+    def test_flowchart_full_integration_renders_real_diagram(self):
+        # No mocking: proves the wiring actually reaches render_flowchart and
+        # produces its real box-drawing output, not just that routing occurs.
+        lines = mermaid.render_mermaid_lines("flowchart LR\n    A[Start] --> B[End]", 60)
+        joined = "\n".join(lines)
+        self.assertIn("Start", joined)
+        self.assertIn("End", joined)
+        self.assertIn("┌", joined)
+
+    def test_class_diagram_full_integration_renders_real_diagram(self):
+        lines = mermaid.render_mermaid_lines("classDiagram\n    class Animal", 60)
+        joined = "\n".join(lines)
+        self.assertIn("Animal", joined)
+        self.assertIn("┌", joined)
+
+    def test_state_diagram_full_integration_renders_real_diagram(self):
+        lines = mermaid.render_mermaid_lines("stateDiagram-v2\n    [*] --> Idle", 60)
+        joined = "\n".join(lines)
+        self.assertIn("Idle", joined)
+        self.assertIn("┌", joined)
+
+    def test_er_diagram_full_integration_renders_real_diagram(self):
+        lines = mermaid.render_mermaid_lines("erDiagram\n    CUSTOMER ||--o{ ORDER : places", 60)
+        joined = "\n".join(lines)
+        self.assertIn("CUSTOMER", joined)
+        self.assertIn("ORDER", joined)
+        self.assertIn("┌", joined)
 
     def test_prelude_comment_before_pie_routes_natively(self):
         with mock.patch(
             "termrender.renderers.mermaid.mermaid_pie.render", return_value=["PIE"]
-        ) as pie_mock, mock.patch(
-            "termrender.renderers.mermaid._render_via_binary"
-        ) as binary_mock:
+        ) as pie_mock:
             src = '%% a leading comment\npie\n    "A" : 1'
             lines = mermaid.render_mermaid_lines(src, 40)
             self.assertEqual(lines, ["PIE"])
             pie_mock.assert_called_once()
-            binary_mock.assert_not_called()
 
     def test_prelude_init_directive_before_sequence_routes_natively(self):
         with mock.patch(
             "termrender.renderers.mermaid.mermaid_sequence.render_sequence",
             return_value=["SEQ"],
-        ) as seq_mock, mock.patch(
-            "termrender.renderers.mermaid._render_via_binary"
-        ) as binary_mock:
+        ) as seq_mock:
             src = '%%{init: {"theme": "dark"}}%%\nsequenceDiagram\n    A->>B: hi'
             lines = mermaid.render_mermaid_lines(src, 40)
             self.assertEqual(lines, ["SEQ"])
             seq_mock.assert_called_once()
-            binary_mock.assert_not_called()
 
     def test_prelude_frontmatter_before_gantt_routes_natively(self):
         with mock.patch(
             "termrender.renderers.mermaid.mermaid_gantt.render", return_value=["GANTT"]
-        ) as gantt_mock, mock.patch(
-            "termrender.renderers.mermaid._render_via_binary"
-        ) as binary_mock:
+        ) as gantt_mock:
             src = "---\ntitle: my diagram\n---\ngantt\n    dateFormat YYYY-MM-DD"
             lines = mermaid.render_mermaid_lines(src, 40)
             self.assertEqual(lines, ["GANTT"])
             gantt_mock.assert_called_once()
-            binary_mock.assert_not_called()
 
     def test_type_sniff_is_case_insensitive(self):
         with mock.patch(

termrender-4.10.0/uv.lock

@@ -0,0 +1,70 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "grandalf"
+version = "0.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyparsing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/95/0e/4ac934b416857969f9135dec17ac80660634327e003a870835dd1f382659/grandalf-0.8.tar.gz", hash = "sha256:2813f7aab87f0d20f334a3162ccfbcbf085977134a17a5b516940a93a77ea974", size = 38128, upload-time = "2023-01-26T07:37:06.668Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/30/44c7eb0a952478dbb5f2f67df806686d6a7e4b19f6204e091c4f49dc7c69/grandalf-0.8-py3-none-any.whl", hash = "sha256:793ca254442f4a79252ea9ff1ab998e852c1e071b863593e5383afee906b4185", size = 41802, upload-time = "2023-01-10T15:16:19.753Z" },
+]
+
+[[package]]
+name = "mistune"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ca/84/620cc3f7e3adf6f5067e10f4dbae71295d8f9e16d5d3f9ef97c40f2f592c/mistune-3.2.1.tar.gz", hash = "sha256:7c8e5501d38bac1582e067e46c8343f17d57ea1aaa735823f3aba1fd59c88a28", size = 98003, upload-time = "2026-05-03T14:33:22.312Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/7f/a946aa4f8752b37102b41e64dca18a1976ac705c3a0d1dfe74d820a02552/mistune-3.2.1-py3-none-any.whl", hash = "sha256:78cdb0ba5e938053ccf63651b352508d2efa9411dc8810bfb05f2dc5140c0048", size = 53749, upload-time = "2026-05-03T14:33:20.551Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },
+]
+
+[[package]]
+name = "termrender"
+source = { editable = "." }
+dependencies = [
+    { name = "grandalf" },
+    { name = "mistune" },
+    { name = "pygments" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "grandalf", specifier = ">=0.8" },
+    { name = "mistune", specifier = ">=3.0" },
+    { name = "pygments", specifier = ">=2.0" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]