termrender 0.8.0__tar.gz → 1.0.1__tar.gz

termrender-1.0.1/.git

@@ -0,0 +1 @@
+gitdir: /Users/silasrhyneer/Code/cli/termrender/.git/worktrees/tr-v101

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

@@ -1,12 +1,85 @@
 # CHANGELOG
 
 
+## v1.0.1 (2026-04-28)
+
+### Bug Fixes
+
+- **parser**: Extract bullet text from paragraph children in loose lists
+  ([`95f389b`](https://github.com/crouton-labs/termrender/commit/95f389b808d89195a8b9dd957d7949328a8859e8))
+
+Mistune wraps list_item content in block_text for tight lists and in paragraph for loose lists. Only
+  block_text was being extracted into item spans, so loose-list bullets rendered with empty text —
+  the renderer's `if not block.text` short-circuit dropped the paragraph child entirely.
+
+
+## v1.0.0 (2026-04-27)
+
+### Documentation
+
+- **claude-md**: Tighten root and src CLAUDE.md
+  ([`7fe01ec`](https://github.com/crouton-labs/termrender/commit/7fe01ec2da0c7a0c1aa0f4eccf9b958496562be8))
+
+### Features
+
+- **mermaid**: Switch to :::mermaid directive, drop backtick fence forms
+  ([`083f590`](https://github.com/crouton-labs/termrender/commit/083f5900b4b516f9df599dd08129afee34310e3d))
+
+BREAKING CHANGE: ```mermaid fenced code blocks are no longer rendered as mermaid diagrams — they now
+  render as plain code blocks. Mermaid diagrams must use the new :::mermaid directive. The
+  MyST-style ```{name} backtick directive form is also removed; backtick fences now always produce a
+  code block, regardless of the language tag. Every directive uses ::: exclusively.
+
+### Breaking Changes
+
+- **mermaid**: ```mermaid fenced code blocks are no longer rendered as mermaid diagrams — they now
+  render as plain code blocks. Mermaid diagrams must use the new :::mermaid directive. The
+  MyST-style ```{name} backtick directive form is also removed; backtick fences now always produce a
+  code block, regardless of the language tag. Every directive uses ::: exclusively.
+
+
+## v0.9.1 (2026-04-25)
+
+### Bug Fixes
+
+- **timeline**: Wrap event text instead of truncating with ellipsis
+  ([`5af0e04`](https://github.com/crouton-labs/termrender/commit/5af0e04c3256075a2016e2cf8ae3d44e9e78c8fc))
+
+Long event entries previously got clipped with `…` when they exceeded event_w. Now they wrap across
+  multiple lines, with continuation lines indented under the bullet and prefixed by the accent bar.
+  Layout height sums per-entry wrapped line counts so the block reserves the right space.
+
+
+## v0.9.0 (2026-04-21)
+
+### Bug Fixes
+
+- **wrap**: Honor hard line breaks in wrap_text
+  ([`a383f4d`](https://github.com/crouton-labs/termrender/commit/a383f4de66b3d8370bda500dd4c3771a591563aa))
+
+Markdown hard breaks were parsed as \n spans but wrap_text only split on spaces, leaking raw \n into
+  wrapped output. Inside panels and columns this broke border alignment because visual_ljust padded
+  the string once, not per visual line.
+
+wrap_text now recursively wraps each \n-separated segment; the text-renderer offset heuristic skips
+  \n as well as space between lines. Layout height calcs pick up the extra lines automatically.
+
+### Features
+
+- **spacing**: Add blank lines between hard breaks and top-level blocks
+  ([`7610189`](https://github.com/crouton-labs/termrender/commit/761018928504cf9626678fe46b5ee66d5e899d5d))
+
+Hard line breaks now render a blank line between the two sides (parser emits \n\n so wrap_text
+  naturally produces the gap), and DOCUMENT-level siblings are separated by a blank padded line so
+  paragraphs, headings, and blocks no longer visually run together.
+
+
 ## v0.8.0 (2026-04-18)
 
 ### Features
 
 - **mermaid**: Preprocess sequence diagrams for mermaid-ascii compatibility
-  ([`a642576`](https://github.com/CaptainCrouton89/termrender/commit/a642576d41d5dbde372d7de2ab47745296a78e32))
+  ([`a642576`](https://github.com/crouton-labs/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
@@ -20,13 +93,13 @@ mermaid-ascii only parses ->> / -->> arrows, participants, and self-loops; every
 ### Bug Fixes
 
 - **code**: Wrap long code lines to fit layout width
-  ([`31c6e59`](https://github.com/CaptainCrouton89/termrender/commit/31c6e595a438c4ced8c61fff679b59d4ae55f938))
+  ([`31c6e59`](https://github.com/crouton-labs/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))
+  ([`0f99ea0`](https://github.com/crouton-labs/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
@@ -39,7 +112,7 @@ Stray-closer and unclosed-directive errors now print the full open/close trace a
 ### Bug Fixes
 
 - **cli**: Default --tmux pane to 1/3 window width
-  ([`d9c1bcc`](https://github.com/CaptainCrouton89/termrender/commit/d9c1bccbe95a4e5cf1f975b82cbafde6d9d3807a))
+  ([`d9c1bcc`](https://github.com/crouton-labs/termrender/commit/d9c1bccbe95a4e5cf1f975b82cbafde6d9d3807a))
 
 Instead of preview-rendering at 80 cols to measure content width, default to (window_width - 2) // 3
   for a consistent 1/3 split.
@@ -50,7 +123,7 @@ Instead of preview-rendering at 80 cols to measure content width, default to (wi
 ### Bug Fixes
 
 - **cli**: Give --pane error paths actionable recovery guidance
-  ([`f857c32`](https://github.com/CaptainCrouton89/termrender/commit/f857c32c89afe32a3a668f03a3d570b0f14dae97))
+  ([`f857c32`](https://github.com/crouton-labs/termrender/commit/f857c32c89afe32a3a668f03a3d570b0f14dae97))
 
 The two --pane error paths now tell the agent how to recover instead of restating the problem.
   "Check that the pane id is valid" is a dead end for an agent — it needs either a command to list
@@ -62,7 +135,7 @@ The two --pane error paths now tell the agent how to recover instead of restatin
 ### Features
 
 - **cli**: Add --pane for in-place tmux pane updates
-  ([`4ab1d77`](https://github.com/CaptainCrouton89/termrender/commit/4ab1d77b996aa356926407dcc11c1b408e68e0ee))
+  ([`4ab1d77`](https://github.com/crouton-labs/termrender/commit/4ab1d77b996aa356926407dcc11c1b408e68e0ee))
 
 --tmux now prints the newly-created pane id to stdout (via split-window -P -F) so callers can
   capture it for subsequent updates. --pane <ID> targets an existing pane via tmux respawn-pane -k
@@ -82,7 +155,7 @@ Also in this commit: - Expand -h epilog to cover the 8 visualization directives
 ### Bug Fixes
 
 - **borders**: Grow render_box to fit overflowing content and titles
-  ([`dc108c8`](https://github.com/CaptainCrouton89/termrender/commit/dc108c8242763828245569f719abce64b26ddf5b))
+  ([`dc108c8`](https://github.com/crouton-labs/termrender/commit/dc108c8242763828245569f719abce64b26ddf5b))
 
 mermaid-ascii's --maxWidth is non-strict, so a child mermaid block can return lines wider than the
   panel's allocated content area. Previously the side walls floated outward to accommodate the
@@ -99,7 +172,7 @@ render_box now measures the widest content line (and the title) and grows its ef
 ### Features
 
 - Add diff, charts, stat, timeline, tasklist, and inline badges
-  ([`e14f615`](https://github.com/CaptainCrouton89/termrender/commit/e14f615ae8d0723405db61c79b0f858d7bf0f863))
+  ([`e14f615`](https://github.com/crouton-labs/termrender/commit/e14f615ae8d0723405db61c79b0f858d7bf0f863))
 
 New block-level directives: - :::diff — colored unified diff with +/- gutters - :::bar — multi-bar
   chart with sub-cell precision via eighth blocks - :::progress — single-line progress bar (auto
@@ -122,7 +195,7 @@ Cross-cutting changes: - InlineSpan gained fg/bg fields; render_spans and span-s
 63 new tests across six test files. All 94 tests pass.
 
 - **cli**: Add --watch mode for live re-rendering
-  ([`4223ad8`](https://github.com/CaptainCrouton89/termrender/commit/4223ad86805b0b3ad45450bd7ca4441a668f0e23))
+  ([`4223ad8`](https://github.com/crouton-labs/termrender/commit/4223ad86805b0b3ad45450bd7ca4441a668f0e23))
 
 Re-renders the file whenever its mtime changes, with terminal-resize detection and inline error
   display so the watcher survives malformed input. Uses the alternate screen buffer so Ctrl+C
@@ -134,7 +207,7 @@ Composes with --tmux: --tmux --watch points the spawned pane at the real file pa
 ### Refactoring
 
 - **parser**: Require strictly more colons on outer fences
-  ([`4a501d9`](https://github.com/CaptainCrouton89/termrender/commit/4a501d917db191f758874bb6c3d922c879a763be))
+  ([`4a501d9`](https://github.com/crouton-labs/termrender/commit/4a501d917db191f758874bb6c3d922c879a763be))
 
 Drops the depth-counter that allowed `:::outer ... :::inner ... ::: ... :::` nesting with same colon
   counts. Termrender now matches the standard followed by MyST, Pandoc fenced divs,
@@ -154,7 +227,7 @@ Fixtures in test_column_alignment.py rewritten to ascending colon counts (7/6/5/
 ### Features
 
 - **table**: Render horizontal separator lines between data rows
-  ([`3e4c74a`](https://github.com/CaptainCrouton89/termrender/commit/3e4c74a10d63470f2eb2ec096bb47cf41f0b7f70))
+  ([`3e4c74a`](https://github.com/crouton-labs/termrender/commit/3e4c74a10d63470f2eb2ec096bb47cf41f0b7f70))
 
 
 ## v0.4.0 (2026-04-05)
@@ -162,7 +235,7 @@ Fixtures in test_column_alignment.py rewritten to ascending colon counts (7/6/5/
 ### Features
 
 - **parser**: Variable colon counts, backtick fence directives, and gloam-inspired theming
-  ([`47fac7f`](https://github.com/CaptainCrouton89/termrender/commit/47fac7fcf13d33e5d9986d3f9ca42ddaf5e7207d))
+  ([`47fac7f`](https://github.com/crouton-labs/termrender/commit/47fac7fcf13d33e5d9986d3f9ca42ddaf5e7207d))
 
 Parser changes: - Support 3+ colon openers/closers with stack-based matching - Backtick fence
   directive syntax (```{name}) via mistune AST interception - Option line stripping (:key: value)
@@ -184,18 +257,18 @@ Theming (gloam-inspired defaults): - Headings: depth-based colored fg + dim tint
 ### Documentation
 
 - Update CLAUDE.md notes for mermaid, tmux, and layout
-  ([`9e104d5`](https://github.com/CaptainCrouton89/termrender/commit/9e104d5ee7bad9a57902e79586c02b0e8d80c589))
+  ([`9e104d5`](https://github.com/crouton-labs/termrender/commit/9e104d5ee7bad9a57902e79586c02b0e8d80c589))
 
 ### Features
 
 - **cli**: Auto-size tmux pane to fit rendered content
-  ([`91f0414`](https://github.com/CaptainCrouton89/termrender/commit/91f0414d0bf8bfbe4d7167159b928ed9c736db74))
+  ([`91f0414`](https://github.com/crouton-labs/termrender/commit/91f0414d0bf8bfbe4d7167159b928ed9c736db74))
 
 - **mermaid**: Pass width and vertical padding to mermaid-ascii
-  ([`96145c2`](https://github.com/CaptainCrouton89/termrender/commit/96145c2789a52a4d94e9bc5f4adf7f3a88d8501f))
+  ([`96145c2`](https://github.com/crouton-labs/termrender/commit/96145c2789a52a4d94e9bc5f4adf7f3a88d8501f))
 
 - **table**: Auto-wrap cell content when columns overflow
-  ([`0fae56f`](https://github.com/CaptainCrouton89/termrender/commit/0fae56f8f00260c3263671df9a63a5bea17820bb))
+  ([`0fae56f`](https://github.com/crouton-labs/termrender/commit/0fae56f8f00260c3263671df9a63a5bea17820bb))
 
 When a table exceeds available width, cells now wrap text within their proportionally-shrunk column
   widths instead of overflowing. Layout height calculation updated to account for multi-line cells.
@@ -206,7 +279,7 @@ When a table exceeds available width, cells now wrap text within their proportio
 ### Bug Fixes
 
 - **mermaid**: Undo double-encoded UTF-8 from mermaid-ascii output
-  ([`9e0560c`](https://github.com/CaptainCrouton89/termrender/commit/9e0560ce46b6dc3f90d2d716a97780713e5e5e53))
+  ([`9e0560c`](https://github.com/crouton-labs/termrender/commit/9e0560ce46b6dc3f90d2d716a97780713e5e5e53))
 
 mermaid-ascii misinterprets UTF-8 bytes as Latin-1 and re-encodes, corrupting multi-byte characters
   (e.g. → renders as â<U+0086><U+0092>). Apply latin-1 round-trip to recover original UTF-8 in both
@@ -215,7 +288,7 @@ mermaid-ascii misinterprets UTF-8 bytes as Latin-1 and re-encodes, corrupting mu
 ### Documentation
 
 - Add tmux pane lifecycle and --check interaction notes to CLAUDE.md
-  ([`9400092`](https://github.com/CaptainCrouton89/termrender/commit/9400092e507d470acb97ac5a17b66fcf0e9aa2f6))
+  ([`9400092`](https://github.com/crouton-labs/termrender/commit/9400092e507d470acb97ac5a17b66fcf0e9aa2f6))
 
 
 ## v0.2.0 (2026-04-05)
@@ -223,27 +296,27 @@ mermaid-ascii misinterprets UTF-8 bytes as Latin-1 and re-encodes, corrupting mu
 ### Bug Fixes
 
 - Handle zero-width and emoji presentation chars in visual width calculation
-  ([`d0bb8dc`](https://github.com/CaptainCrouton89/termrender/commit/d0bb8dcfa5ca0d2c16d78a1d7f81825231b9cb59))
+  ([`d0bb8dc`](https://github.com/crouton-labs/termrender/commit/d0bb8dcfa5ca0d2c16d78a1d7f81825231b9cb59))
 
 _char_width now returns 0 for combining marks and format characters (ZWJ, variation selectors).
   visual_len handles VS16 emoji presentation sequences by promoting the preceding character to width
   2. Fixes panel border misalignment when content contains emoji or special Unicode.
 
 - **docs**: Update README output examples to match actual rendered output
-  ([`de6d0cc`](https://github.com/CaptainCrouton89/termrender/commit/de6d0ccfd8a60aca20f2b2659a313f8d8c87d853))
+  ([`de6d0cc`](https://github.com/crouton-labs/termrender/commit/de6d0ccfd8a60aca20f2b2659a313f8d8c87d853))
 
 ### Chores
 
 - Add README, design specs, and project CLAUDE.md files
-  ([`93ac358`](https://github.com/CaptainCrouton89/termrender/commit/93ac35857981c549797a9359573cacea1478b3ad))
+  ([`93ac358`](https://github.com/crouton-labs/termrender/commit/93ac35857981c549797a9359573cacea1478b3ad))
 
 - Derive version from git tags via hatch-vcs
-  ([`33595a0`](https://github.com/CaptainCrouton89/termrender/commit/33595a0b64363e445b90c9df135a50a4652e2bae))
+  ([`33595a0`](https://github.com/crouton-labs/termrender/commit/33595a0b64363e445b90c9df135a50a4652e2bae))
 
 ### Continuous Integration
 
 - Auto-release and publish via conventional commits
-  ([`80a456b`](https://github.com/CaptainCrouton89/termrender/commit/80a456b7301c57f2fd2b0cd30622b78f2d4b931e))
+  ([`80a456b`](https://github.com/crouton-labs/termrender/commit/80a456b7301c57f2fd2b0cd30622b78f2d4b931e))
 
 Replace manual GitHub release trigger with python-semantic-release. On push to main, conventional
   commits are analyzed to determine version bumps (feat→minor, fix→patch) and publish to PyPI
@@ -252,12 +325,12 @@ Replace manual GitHub release trigger with python-semantic-release. On push to m
 ### Documentation
 
 - Update README token count and expand CLAUDE.md implementation notes
-  ([`1f70a53`](https://github.com/CaptainCrouton89/termrender/commit/1f70a5352cbced30219012dbede7040c6ac97457))
+  ([`1f70a53`](https://github.com/crouton-labs/termrender/commit/1f70a5352cbced30219012dbede7040c6ac97457))
 
 ### Features
 
 - Add CJK ambiguous-width support, strict directive parsing, and rendering fixes
-  ([`c000883`](https://github.com/CaptainCrouton89/termrender/commit/c0008835d66b721b0a09c7a34dde11d08b3d3d94))
+  ([`c000883`](https://github.com/crouton-labs/termrender/commit/c0008835d66b721b0a09c7a34dde11d08b3d3d94))
 
 - Add emoji presentation and East Asian ambiguous-width character handling with --cjk flag and
   TERMRENDER_CJK env var - All renderers (borders, divider, quote, tree) now compute box-drawing
@@ -266,14 +339,14 @@ Replace manual GitHub release trigger with python-semantic-release. On push to m
   for inter-column gaps - Support 'author' as alias for 'by' attribute on quote blocks
 
 - Add GFM table rendering with box-drawing borders
-  ([`c3b61cd`](https://github.com/CaptainCrouton89/termrender/commit/c3b61cdd659fdb782089cbca2fd3f74b18486605))
+  ([`c3b61cd`](https://github.com/crouton-labs/termrender/commit/c3b61cdd659fdb782089cbca2fd3f74b18486605))
 
 Enable mistune table plugin, parse table AST into TABLE blocks, and render with box-drawing
   characters. Supports left/center/right column alignment, bold headers, auto-sized columns, and
   proportional overflow distribution.
 
 - **cli**: Add --tmux pane output, --check validation, and structured error handling
-  ([`36b52ee`](https://github.com/CaptainCrouton89/termrender/commit/36b52eed9701cd0acd363db2d0fa3d277244c8b0))
+  ([`36b52ee`](https://github.com/crouton-labs/termrender/commit/36b52eed9701cd0acd363db2d0fa3d277244c8b0))
 
 - --tmux renders in a new tmux side pane via split-window, piped through less -R - --check validates
   directive syntax without rendering (exit 0/2) - Structured _error() helper with fix/hint guidance
@@ -283,12 +356,12 @@ Enable mistune table plugin, parse table AST into TABLE blocks, and render with
   depth note
 
 - **cli**: Improve help output with examples, version flag, and tty detection
-  ([`cb3e7e2`](https://github.com/CaptainCrouton89/termrender/commit/cb3e7e2752ae860e5c3cbd4c4f1627e925a9c431))
+  ([`cb3e7e2`](https://github.com/crouton-labs/termrender/commit/cb3e7e2752ae860e5c3cbd4c4f1627e925a9c431))
 
 ### Testing
 
 - Add column alignment and visual width tests
-  ([`f8b6099`](https://github.com/CaptainCrouton89/termrender/commit/f8b60998625977b10dd4697f8e772d80125cb9ce))
+  ([`f8b6099`](https://github.com/crouton-labs/termrender/commit/f8b60998625977b10dd4697f8e772d80125cb9ce))
 
 Covers showpiece rendering, column line width consistency, status marker visual widths (text vs
   emoji presentation), and panel border alignment.

termrender-1.0.1/CLAUDE.md

@@ -0,0 +1,25 @@
+# termrender
+
+## Commands
+```bash
+pip install -e .
+pytest tests/
+python -m termrender <file.md>
+python -m build
+```
+
+No linter or formatter is configured.
+
+## Constraints
+- **Layout pass order is load-bearing**: `resolve_width()` top-down must complete before `resolve_height()` bottom-up — height calls `wrap_text(text, width)`, which requires width already set.
+- **`borders.py` `render_box` width**: takes **total** width including borders, not content width. Passing content width silently overflows.
+- **`wrap_text()` CJK bug**: uses `len()` internally, not `visual_len()` — silently overflows for CJK content.
+- **`_ambiguous_width` is global mutable state** with no reset path — `set_ambiguous_width()` or `TERMRENDER_CJK` env var changes persist for the process lifetime.
+- **Version**: derived from git tags via hatch-vcs — no version in `pyproject.toml`. Adding one will conflict.
+- **Commits**: conventional commits. `feat` → minor, `fix`/`perf` → patch. Auto-released via python-semantic-release on main.
+
+## Supplementary CLAUDE.md files
+- `src/termrender/CLAUDE.md` — parser, layout, mermaid, nesting, and `--check`/`--tmux` implementation gotchas
+- `src/termrender/renderers/CLAUDE.md` — renderer contracts, `render_box` width semantics, EAW edge cases
+
+Read these before modifying layout, parsing, or renderer code.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 0.8.0
+Version: 1.0.1
 Summary: Rich terminal rendering of directive-flavored markdown
 Project-URL: Homepage, https://github.com/CaptainCrouton89/termrender
 Project-URL: Repository, https://github.com/CaptainCrouton89/termrender
@@ -393,17 +393,17 @@ 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 standard mermaid fenced code blocks.
+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.
 
 **Input:**
-````markdown
-```mermaid
+```markdown
+:::mermaid
 graph LR
     A[Request] --> B{Auth?}
     B -->|Yes| C[Handler]
     B -->|No| D[401]
+:::
 ```
-````
 
 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).
 

{termrender-0.8.0 → termrender-1.0.1}/README.md

@@ -365,17 +365,17 @@ 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 standard mermaid fenced code blocks.
+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.
 
 **Input:**
-````markdown
-```mermaid
+```markdown
+:::mermaid
 graph LR
     A[Request] --> B{Auth?}
     B -->|Yes| C[Handler]
     B -->|No| D[401]
+:::
 ```
-````
 
 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).
 

termrender-1.0.1/src/termrender/CLAUDE.md

@@ -0,0 +1,15 @@
+- `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 preserve these imports. The two mermaid subprocess call sites differ: layout uses `check=True` (non-zero exit raises → caught → raw-source fallback); the renderer omits `check` (non-zero exit silently reads `stdout`, which may be empty or partial).
+
+- `--check` calls `parse()` and exits — it never runs `layout.py`. Layout-time failures (mermaid subprocess missing, column percent overflow, `resolve_width`/`resolve_height` exceptions) pass `--check` cleanly but crash at render time.
+
+- Column widths: explicit percent/absolute allocations are subtracted first; remaining space is split among auto-width columns with `max(remaining, 0)`. Two columns each claiming 80% of a 100px terminal leaves auto-width columns with `width = 1` — no error, no proportional scaling.
+
+- **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.
+
+- **LIST_ITEM** layout wraps at `max(width - 2, 1)`, hardcoding a 2-column indent. If the renderer changes the indent width, layout height and actual render height diverge silently.
+
+- `text.py:32–33`: after each wrapped line, the offset skips one character if the next plain-text character is a space (the space `wrap_text` consumed). If wrapping preserves trailing spaces, this skip shifts subsequent span styling by one character.
+
+- `--tmux` exits `EXIT_OK` after the tmux pane command succeeds — the `--check` branch comes later and is never reached. `--check` is silently dropped when combined with `--tmux`.
+
+- `_EMOJI_WIDE_RANGES` in `style.py`: `_char_width()` exits early when `cp < lo`, assuming ranges are in ascending codepoint order. Adding a range out of order silently misclassifies all codepoints whose `lo` is higher than the inserted range's `lo`.

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

@@ -53,7 +53,8 @@ directives (close each with a matching colon count):
   :::tasklist                        Checkbox list — [x] checked, [ ] unchecked, [!] in-progress
       Plain lists with at least one marker auto-promote; use the directive
       to force unchecked styling on items without explicit markers.
-  ```mermaid ... ```                  Mermaid diagram (via mermaid-ascii)
+  :::mermaid                         Mermaid diagram (via mermaid-ascii)
+      body: standard mermaid source (graph TD, flowchart, sequenceDiagram, ...)
 
   Inline:
   :badge[text]{color=c}              Inline pill badge
@@ -335,18 +336,27 @@ def main() -> None:
             if args.width:
                 pane_width = args.width
             else:
-                # Default: 1/3 of window width (minus separator)
+                # Default sizing aims for a readable side pane (~80 cols) and
+                # only falls back to 1/3-of-window when the window is too narrow
+                # to give that much without crushing the source pane.
                 try:
                     result = subprocess.run(
                         ["tmux", "display-message", "-p", "#{window_width}"],
                         capture_output=True, text=True, check=True,
                     )
                     window_width = int(result.stdout.strip())
-                    pane_width = (window_width - 2) // 3
+                    # Prefer 80 cols if the source pane keeps at least 60.
+                    # Otherwise split evenly. Floor of 40 keeps text legible.
+                    if window_width >= 140:
+                        pane_width = 80
+                    elif window_width >= 100:
+                        pane_width = window_width // 2
+                    else:
+                        pane_width = max(window_width - 2 - 50, 40)
                 except Exception:
-                    pane_width = 60
+                    pane_width = 80
 
-            pane_width = max(pane_width, 20)  # absolute minimum
+            pane_width = max(pane_width, 40)  # absolute minimum for readability
 
         # Watch mode points the new pane at the user's real file so edits
         # propagate; non-watch mode snapshots source into a tempfile.

{termrender-0.8.0 → termrender-1.0.1}/src/termrender/emit.py

@@ -7,12 +7,24 @@ from termrender.renderers import (
     panel, columns, tree, code, text, divider, quote, mermaid, table,
     diff, charts, stat, timeline,
 )
+from termrender.style import visual_ljust
 
 
 def emit_block(block: Block, color: bool) -> list[str]:
     """Render a single block and its children, returning output lines."""
     match block.type:
-        case BlockType.DOCUMENT | BlockType.COL:
+        case BlockType.DOCUMENT:
+            # Insert a blank padded line between top-level siblings so
+            # paragraphs, headings, and blocks don't visually run together.
+            lines: list[str] = []
+            sep = visual_ljust("", block.width or 0)
+            for i, child in enumerate(block.children):
+                if i > 0:
+                    lines.append(sep)
+                lines.extend(emit_block(child, color))
+            return lines
+
+        case BlockType.COL:
             lines: list[str] = []
             for child in block.children:
                 lines.extend(emit_block(child, color))

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

@@ -192,9 +192,15 @@ def resolve_height(block: Block) -> None:
     elif bt == BlockType.TIMELINE:
         entries = block.attrs.get("entries", [])
         title_h = 1 if block.attrs.get("title") else 0
-        # Each entry takes 1 line + 1 connector line between entries (none after last)
         if entries:
-            block.height = title_h + len(entries) * 2 - 1
+            date_w = max(visual_len(e["date"]) for e in entries)
+            event_w = max((block.width or 60) - date_w - 4, 5)
+            total = 0
+            for entry in entries:
+                wrapped = wrap_text(entry["event"], event_w) or [""]
+                total += len(wrapped)
+            total += len(entries) - 1  # connector between entries
+            block.height = title_h + total
         else:
             block.height = max(title_h, 1)
 

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

@@ -69,15 +69,13 @@ _DIRECTIVE_TO_BLOCK: dict[str, BlockType] = {
     "gauge": BlockType.GAUGE,
     "stat": BlockType.STAT,
     "timeline": BlockType.TIMELINE,
+    "mermaid": BlockType.MERMAID,
     "tasklist": BlockType.LIST,  # alias: forces tasklist styling on the inner list
 }
 
 _SELF_CLOSING_DIRECTIVES = frozenset({"divider", "progress", "gauge"})
 
-# MyST backtick fence directive: ```{name} optional-argument
-_BACKTICK_DIRECTIVE_RE = re.compile(r"^\{(\w[\w-]*)\}(.*)")
-
-# MyST option line: :key: value — intentionally requires a value after the key
+# Option line: :key: value — intentionally requires a value after the key
 # (the \s+(.+) part). Flag-style options like :nosandbox: (no value) won't match
 # and will be treated as body content.
 _OPTION_LINE_RE = re.compile(r"^:(\w[\w-]*):\s+(.+)$")
@@ -134,7 +132,10 @@ def _convert_inline(nodes: list[dict]) -> list[InlineSpan]:
         elif ntype == "softbreak":
             spans.append(InlineSpan(text=" "))
         elif ntype == "linebreak":
-            spans.append(InlineSpan(text="\n"))
+            # Two \n so wrap_text emits a blank line between the two sides
+            # of the hard break, giving more vertical breathing room than a
+            # soft wrap. See tests/test_linebreak.py.
+            spans.append(InlineSpan(text="\n\n"))
         else:
             # Fallback: try raw text
             if "raw" in node:
@@ -245,7 +246,7 @@ def _expand_inline_roles(spans: list[InlineSpan]) -> list[InlineSpan]:
 
 
 def _strip_options(body: str) -> tuple[dict[str, str], str]:
-    """Strip MyST option lines from the start of a directive body.
+    """Strip option lines from the start of a directive body.
 
     Option lines have the form `:key: value` and appear at the start of the body.
     Blank lines between option lines are allowed. Scanning stops at the first
@@ -302,33 +303,10 @@ 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", "")
-            # MyST backtick fence directive: ```{name} optional-arg
-            m_directive = _BACKTICK_DIRECTIVE_RE.match(info) if info else None
-            if m_directive:
-                dir_name = m_directive.group(1)
-                arg_text = m_directive.group(2).strip()
-                if dir_name == "mermaid":
-                    options, body = _strip_options(raw)
-                    attrs = dict(options)
-                    if arg_text:
-                        attrs["argument"] = arg_text
-                    attrs["source"] = body
-                    blocks.append(Block(type=BlockType.MERMAID, attrs=attrs))
-                else:
-                    attrs: dict[str, Any] = {}
-                    if arg_text:
-                        attrs["argument"] = arg_text
-                    blocks.append(_directive_to_block(dir_name, attrs, raw, _depth=_depth))
-            elif info == "mermaid":
-                blocks.append(Block(
-                    type=BlockType.MERMAID,
-                    attrs={"source": raw},
-                ))
-            else:
-                blocks.append(Block(
-                    type=BlockType.CODE,
-                    attrs={"lang": info, "source": raw},
-                ))
+            blocks.append(Block(
+                type=BlockType.CODE,
+                attrs={"lang": info, "source": raw},
+            ))
 
         elif ntype == "list":
             ordered = node.get("attrs", {}).get("ordered", False)
@@ -336,12 +314,19 @@ def _convert_ast(nodes: list[dict], _depth: int = 0) -> list[Block]:
             for item_node in node.get("children", []):
                 if item_node["type"] == "list_item":
                     item_children = item_node.get("children", [])
-                    # list_item contains block_text nodes
+                    # Tight lists wrap item content in block_text; loose lists
+                    # (blank line between items) wrap it in paragraph. Either way,
+                    # the first text-bearing child becomes the bullet's inline text.
                     item_spans: list[InlineSpan] = []
                     sub_blocks: list[Block] = []
+                    bullet_text_taken = False
                     for child in item_children:
-                        if child["type"] == "block_text":
+                        ctype = child["type"]
+                        if ctype == "block_text":
+                            item_spans.extend(_convert_inline(child.get("children", [])))
+                        elif ctype == "paragraph" and not bullet_text_taken:
                             item_spans.extend(_convert_inline(child.get("children", [])))
+                            bullet_text_taken = True
                         else:
                             sub_blocks.extend(_convert_ast([child], _depth=_depth))
                     items.append(Block(
@@ -610,8 +595,8 @@ def _directive_to_block(name: str, attrs: dict[str, Any], body: str, _depth: int
 
     block_type = _DIRECTIVE_TO_BLOCK.get(name, BlockType.PANEL)
 
-    # Tree, Code, Diff: store raw body, don't parse as markdown
-    if block_type in (BlockType.TREE, BlockType.CODE, BlockType.DIFF):
+    # Tree, Code, Diff, Mermaid: store raw body, don't parse as markdown
+    if block_type in (BlockType.TREE, BlockType.CODE, BlockType.DIFF, BlockType.MERMAID):
         attrs["source"] = body
         return Block(type=block_type, attrs=attrs)
 

{termrender-0.8.0 → termrender-1.0.1}/src/termrender/renderers/text.py

@@ -29,7 +29,7 @@ def _render_wrapped_spans(
         prefix = first_prefix if i == 0 else cont_prefix
         lines.append(visual_ljust(prefix + styled, total_width))
         char_offset += line_len
-        if char_offset < len(plain) and plain[char_offset] == " ":
+        if char_offset < len(plain) and plain[char_offset] in (" ", "\n"):
             char_offset += 1
 
     return lines

{termrender-0.8.0 → termrender-1.0.1}/src/termrender/renderers/timeline.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from termrender.blocks import Block
-from termrender.style import style, visual_len, visual_ljust
+from termrender.style import style, visual_len, visual_ljust, wrap_text
 
 
 def render(block: Block, color: bool, render_child=None) -> list[str]:
@@ -28,18 +28,16 @@ def render(block: Block, color: bool, render_child=None) -> list[str]:
     bar = style("│", color=accent, dim=True, enabled=color)
 
     event_w = max(w - date_w - 4, 5)  # date + space + bullet + space + event
+    cont_indent = " " * (date_w + 1)
 
     for i, entry in enumerate(entries):
         date_text = entry["date"].rjust(date_w)
         date_styled = style(date_text, dim=True, enabled=color)
-        event_text = entry["event"]
-        if visual_len(event_text) > event_w:
-            event_text = event_text[: max(event_w - 1, 0)] + "…"
-        line = f"{date_styled} {bullet} {event_text}"
-        lines.append(visual_ljust(line, w))
+        wrapped = wrap_text(entry["event"], event_w) or [""]
+        lines.append(visual_ljust(f"{date_styled} {bullet} {wrapped[0]}", w))
+        for cont in wrapped[1:]:
+            lines.append(visual_ljust(f"{cont_indent}{bar} {cont}", w))
         if i < len(entries) - 1:
-            connector_indent = " " * (date_w + 1)
-            connector = f"{connector_indent}{bar}"
-            lines.append(visual_ljust(connector, w))
+            lines.append(visual_ljust(f"{cont_indent}{bar}", w))
 
     return lines

{termrender-0.8.0 → termrender-1.0.1}/src/termrender/style.py

@@ -219,10 +219,17 @@ def visual_center(s: str, width: int, fillchar: str = ' ') -> str:
 
 
 def wrap_text(text: str, width: int) -> list[str]:
-    if not text or text.isspace():
+    if not text:
+        return ['']
+    if "\n" in text:
+        result: list[str] = []
+        for seg in text.split("\n"):
+            result.extend(wrap_text(seg, width))
+        return result
+    if text.isspace():
         return ['']
     if width <= 0:
-        return [text] if text else ['']
+        return [text]
     words = text.split(' ')
     lines: list[str] = []
     current = ''

{termrender-0.8.0 → termrender-1.0.1}/tests/test_column_alignment.py

@@ -85,24 +85,24 @@ c/
 # the column allocation. The inner panel's side walls and corner glyphs must
 # stay aligned even when content forces the panel to grow past its allotment.
 NESTED_PANEL_OVERFLOW_INPUT = """\
-::::::panel{title="Outer" color="cyan"}
-:::::columns
-::::col{width="58%"}
-:::panel{title="Request Flow" color="blue"}
-```mermaid
+:::::::panel{title="Outer" color="cyan"}
+::::::columns
+:::::col{width="58%"}
+::::panel{title="Request Flow" color="blue"}
+:::mermaid
 graph TD
     A[Edge gateway<br/>accepts request] --> B{Token valid?}
     B -->|yes| C[Route via LB<br/>to backend pool]
     B -->|no| D[Reject 401,<br/>write audit log]
     C --> E[Service responds,<br/>metrics emitted]
-```
 :::
 ::::
-::::col{width="42%"}
+:::::
+:::::col{width="42%"}
 right
-::::
 :::::
 ::::::
+:::::::
 """
 
 

termrender-1.0.1/tests/test_linebreak.py

@@ -0,0 +1,79 @@
+import unittest
+
+from termrender import render
+from termrender.style import visual_len, wrap_text
+
+
+class TestWrapTextLinebreak(unittest.TestCase):
+    def test_single_newline_splits(self):
+        self.assertEqual(wrap_text("a\nb", 10), ["a", "b"])
+
+    def test_newline_with_wrap(self):
+        # Each segment wraps independently.
+        self.assertEqual(wrap_text("aa bb\ncc dd", 3), ["aa", "bb", "cc", "dd"])
+
+    def test_leading_newline(self):
+        self.assertEqual(wrap_text("\nfoo", 10), ["", "foo"])
+
+    def test_trailing_newline(self):
+        self.assertEqual(wrap_text("foo\n", 10), ["foo", ""])
+
+    def test_consecutive_newlines(self):
+        self.assertEqual(wrap_text("a\n\nb", 10), ["a", "", "b"])
+
+    def test_plain_wrap_unchanged(self):
+        self.assertEqual(wrap_text("hello world foo bar", 10),
+                         ["hello", "world foo", "bar"])
+
+
+class TestLinebreakRendering(unittest.TestCase):
+    def test_hard_break_in_paragraph_pads_both_lines(self):
+        # Two trailing spaces = markdown hard line break.
+        # Hard breaks now emit a blank line between the two sides for extra
+        # vertical breathing room, so expect 3 padded lines.
+        output = render("line one  \nline two", width=40, color=False)
+        lines = output.split("\n")
+        if lines and lines[-1] == "":
+            lines = lines[:-1]
+        self.assertEqual(len(lines), 3)
+        self.assertEqual(lines[1].strip(), "")
+        for line in lines:
+            self.assertEqual(visual_len(line), 40)
+
+    def test_hard_break_in_panel_aligns_borders(self):
+        src = ':::panel{title="t"}\nline one  \nline two\n:::'
+        output = render(src, width=30, color=False)
+        lines = [ln for ln in output.split("\n") if ln]
+        # Panel: top border, line 1, blank, line 2, bottom border = 5 lines.
+        self.assertEqual(len(lines), 5)
+        widths = {visual_len(ln) for ln in lines}
+        self.assertEqual(widths, {30})
+        # Interior lines begin and end with the side border glyph.
+        for interior in lines[1:-1]:
+            self.assertTrue(interior.startswith("│"))
+            self.assertTrue(interior.rstrip().endswith("│"))
+
+    def test_hard_break_in_columns_preserves_row_width(self):
+        src = (
+            "::::columns\n:::col\nleft one  \nleft two\n:::\n"
+            ":::col\nright\n:::\n::::"
+        )
+        output = render(src, width=40, color=False)
+        lines = [ln for ln in output.split("\n") if ln]
+        # Left column: "left one", blank, "left two" = 3 rows.
+        self.assertEqual(len(lines), 3)
+        for line in lines:
+            self.assertEqual(visual_len(line), 40)
+
+    def test_hard_break_preserves_inline_style(self):
+        # Bold span followed by hard break and plain text — bold must not
+        # bleed onto line two (or the blank between).
+        output = render("**bold**  \nplain", width=30, color=True)
+        lines = output.rstrip("\n").split("\n")
+        self.assertEqual(len(lines), 3)
+        self.assertIn("\x1b[1m", lines[0])
+        self.assertNotIn("\x1b[1m", lines[2])
+
+
+if __name__ == "__main__":
+    unittest.main()

{termrender-0.8.0 → termrender-1.0.1}/tests/test_myst_gaps.py

@@ -1,4 +1,4 @@
-"""Tests for MyST Markdown syntax support in the parser."""
+"""Tests for directive option lines and the colon-fence mermaid directive."""
 
 import unittest
 
@@ -6,56 +6,43 @@ from termrender.blocks import BlockType
 from termrender.parser import parse, _strip_options
 
 
-class TestBacktickFenceDirective(unittest.TestCase):
-    """Feature 1: Backtick fence directive syntax."""
+class TestMermaidDirective(unittest.TestCase):
+    """:::mermaid is the only fence form for mermaid diagrams."""
 
-    def test_basic_backtick_fence_directive(self):
-        """```{panel}\ncontent\n``` → BlockType.PANEL"""
-        doc = parse("```{panel}\ncontent\n```")
+    def test_basic_mermaid_directive(self):
+        """:::mermaid\ngraph LR\nA-->B\n::: → BlockType.MERMAID"""
+        doc = parse(":::mermaid\ngraph LR\nA-->B\n:::")
         self.assertEqual(len(doc.children), 1)
-        self.assertEqual(doc.children[0].type, BlockType.PANEL)
-
-    def test_backtick_fence_with_option_lines(self):
-        """```{panel}\n:title: Hello\ncontent\n``` → panel with title attr"""
-        doc = parse("```{panel}\n:title: Hello\ncontent\n```")
-        panel = doc.children[0]
-        self.assertEqual(panel.type, BlockType.PANEL)
-        self.assertEqual(panel.attrs["title"], "Hello")
+        block = doc.children[0]
+        self.assertEqual(block.type, BlockType.MERMAID)
+        self.assertIn("graph LR", block.attrs["source"])
 
-    def test_backtick_mermaid_directive(self):
-        """```{mermaid}\ngraph LR\nA-->B\n``` → BlockType.MERMAID"""
-        doc = parse("```{mermaid}\ngraph LR\nA-->B\n```")
-        self.assertEqual(len(doc.children), 1)
+    def test_mermaid_with_option_lines(self):
+        """Option lines at the top of a mermaid body set attrs, not source."""
+        doc = parse(":::mermaid\n:title: Flow\ngraph LR\nA-->B\n:::")
         block = doc.children[0]
         self.assertEqual(block.type, BlockType.MERMAID)
+        self.assertEqual(block.attrs.get("title"), "Flow")
         self.assertIn("graph LR", block.attrs["source"])
+        self.assertNotIn(":title:", block.attrs["source"])
 
-    def test_bare_mermaid_still_works(self):
-        """```mermaid\ngraph LR\n``` → BlockType.MERMAID (backward compat)"""
+    def test_backtick_mermaid_is_plain_code_block(self):
+        """```mermaid is no longer a mermaid block — it renders as a code block."""
         doc = parse("```mermaid\ngraph LR\nA-->B\n```")
-        self.assertEqual(doc.children[0].type, BlockType.MERMAID)
-
-    def test_empty_body_backtick_directive(self):
-        """```{panel}\n``` → panel with no children"""
-        doc = parse("```{panel}\n```")
-        panel = doc.children[0]
-        self.assertEqual(panel.type, BlockType.PANEL)
-
-    def test_backtick_fence_with_argument(self):
-        """```{code-block} python\nprint("hi")\n``` → attrs["argument"] = "python" """
-        doc = parse('```{code-block} python\nprint("hi")\n```')
         block = doc.children[0]
-        self.assertEqual(block.attrs.get("argument"), "python")
+        self.assertEqual(block.type, BlockType.CODE)
+        self.assertEqual(block.attrs.get("lang"), "mermaid")
 
-    def test_four_backtick_fence(self):
-        """````{panel}\ncontent\n```` → works via mistune"""
-        doc = parse("````{panel}\ncontent\n````")
-        self.assertEqual(len(doc.children), 1)
-        self.assertEqual(doc.children[0].type, BlockType.PANEL)
+    def test_backtick_directive_is_plain_code_block(self):
+        """```{panel} is no longer a directive — it renders as a code block."""
+        doc = parse("```{panel}\ncontent\n```")
+        block = doc.children[0]
+        self.assertEqual(block.type, BlockType.CODE)
+        self.assertEqual(block.attrs.get("lang"), "{panel}")
 
 
 class TestDirectiveOptionLines(unittest.TestCase):
-    """Feature 2: Directive option lines."""
+    """Directive option lines (`:key: value` at top of body)."""
 
     def test_colon_directive_with_options(self):
         """:::panel\n:title: Hi\n:color: blue\ncontent\n::: → attrs have title and color"""

termrender-0.8.0/CLAUDE.md

@@ -1,64 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## What this is
-
-termrender renders directive-flavored markdown to ANSI terminal output. LLM agents describe layout with `:::directives` (panels, columns, trees, callouts, etc.) and termrender produces styled terminal output. Public API: `from termrender import render`.
-
-## Commands
-
-```bash
-# Install in dev mode
-pip install -e .
-
-# Run tests
-pytest tests/
-pytest tests/test_column_alignment.py::TestColumnAlignment::test_showpiece_renders_without_error
-
-# Run the CLI
-python -m termrender <file.md>
-echo ':::panel{title="Hi"}\nHello\n:::' | python -m termrender
-
-# Build
-python -m build
-```
-
-No linter or formatter is configured.
-
-## Architecture
-
-Three-stage pipeline: **parse → layout → emit**.
-
-1. **Parse** (`parser.py`) — Two-pass: regex extracts `:::directives` first, then mistune v3 processes markdown segments. Produces a tree of `Block` dataclasses (`blocks.py`).
-2. **Layout** (`layout.py`) — Two-pass, order is load-bearing: `resolve_width()` top-down, then `resolve_height()` bottom-up. Width must resolve first because height calls `wrap_text(text, width)`.
-3. **Emit** (`emit.py`) — Walks the block tree and dispatches to renderer functions in `renderers/`.
-
-Entry points:
-- **Library**: `__init__.py:render()` — parse → layout → emit
-- **CLI**: `__main__.py:main()` — argparse with `--width`, `--no-color`, `--check`, `--cjk`, `--tmux`. Exit codes: 0=ok, 1=input, 2=syntax, 3=terminal.
-
-### Renderers (`src/termrender/renderers/`)
-
-Two signatures (not type-enforced):
-- **Leaf**: `render(block, color) -> list[str]` — divider, tree
-- **Container**: `render(block, color, render_child) -> list[str]` — panel, quote, code, columns, callout, table, text, mermaid
-
-`borders.py` is a shared utility, not a renderer. Its `render_box(content_lines, width, ...)` takes **total** width (including borders), not content width.
-
-### Style (`style.py`)
-
-`visual_len()` measures display width accounting for ANSI escapes, emoji, CJK, and combining marks. `wrap_text()` uses `len()` internally (known bug: CJK overflow). `_ambiguous_width` is global mutable state with no reset path — set via `set_ambiguous_width()` or `TERMRENDER_CJK` env var.
-
-## Conventions
-
-- **Commits**: conventional commits (`feat:`, `fix:`, `chore:`, etc.). `feat` → minor, `fix`/`perf` → patch. Auto-released via python-semantic-release on main.
-- **Version**: derived from git tags via hatch-vcs (no version in pyproject.toml).
-- **Python**: 3.10+.
-
-## Supplementary CLAUDE.md files
-
-- `src/termrender/CLAUDE.md` — parser, layout, mermaid, nesting, and `--check`/`--tmux` implementation gotchas
-- `src/termrender/renderers/CLAUDE.md` — renderer contracts, `render_box` width semantics, EAW edge cases
-
-Read these before modifying layout, parsing, or renderer code.

termrender-0.8.0/src/termrender/CLAUDE.md

@@ -1,75 +0,0 @@
-# termrender/src/termrender
-
-## Layout: two-pass order is mandatory
-
-`layout.py` runs `resolve_width()` then `resolve_height()` — this order is load-bearing. Height resolution calls `wrap_text(text, width)`, so every block must have `.width` set first. Reversing the order causes `block.width = None`, which silently falls back to `width = 1` (layout.py:77), drastically underestimating all heights.
-
-## Mermaid: subprocess runs in layout, not in the renderer
-
-`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` 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
-
-The parser handles two directive syntaxes through different passes: colon directives (`:::name`) are extracted in pass 1 via regex in `_split_directives`, while backtick fence directives (`` ```{name} ``) are resolved in pass 2 via mistune's AST walk in `_convert_ast`. Both paths funnel through `_directive_to_block` for block construction.
-
-For colon directives, closers are paired strictly by colon count. A closer whose colon count differs from the open directive's colon count is treated as body content; the recursive `parse()` call inside `_directive_to_block` re-parses it as an inner directive. This matches the standard rule used by MyST, Pandoc fenced divs, markdown-it-container, and CommonMark fenced code blocks: outer fences must use strictly more colons than the inner fences they wrap, making opener/closer pairing unambiguous.
-
-Max recursion depth is 50; exceeding it raises `ValueError`, not `DirectiveError`. Both the render path and `--check` path in `__main__.py` catch `ValueError` and map it to exit code 2 (`EXIT_SYNTAX`).
-
-## `--check` validates parse only, not layout
-
-`__main__.py` `--check` calls `parse()` directly and exits — it never runs `layout.py`. Layout-time failures (mermaid subprocess missing, column percent overflow, `resolve_width`/`resolve_height` exceptions) pass `--check` cleanly but crash at render time. Use `--check` to catch directive syntax errors, not to guarantee a successful render.
-
-## `_ambiguous_width` is global mutable state; `TERMRENDER_CJK` makes it permanent
-
-`style.set_ambiguous_width(n)` (style.py:21–23) changes East Asian ambiguous-width measurement for the entire process with no reset function. The CLI `--cjk` flag sets `os.environ["TERMRENDER_CJK"]` rather than calling the function directly, so it persists for the entire process. `__init__.py:30–31` calls `set_ambiguous_width(2)` on every `render()` call when the env var is set — but since there's no reset, a single call in any render context permanently widens ambiguous-width for all subsequent renders in the same process. Affects `visual_len()` and therefore all wrapping and column math.
-
-## Column width: explicit widths exceeding available space truncate auto-columns to 1
-
-`layout.py:30–63`: explicit column widths (percent or absolute) are allocated first; remaining space is split among auto-width columns with `max(remaining, 0)`. Two columns each claiming 80% of a 100px terminal leaves auto-width columns with width 1 — no error, no proportional scaling.
-
-## Height calculations with hidden assumptions
-
-- **QUOTE** (layout.py:138): height gets `+1` only when the `author` or `by` attr is set. Using any other key (`attribution`, `source`) silently omits the extra line — the renderer's attribution line is clipped.
-- **TABLE** (layout.py:117): `height = len(rows) + 4` where `rows` includes the header row. The code comment mis-describes this as 5 structural parts; `rows[0]` is the header. Adding a footer or subtitle row needs `+5`, not `+4+1`.
-- **LIST_ITEM** (layout.py:107): text wraps at `max(width - 2, 1)`, hardcoding a 2-column indent. If the renderer changes the indent width, layout height and actual render height diverge silently.
-
-## Character offset tracking across wrapped lines
-
-`text.py:32–33`: after rendering each wrapped line, the offset advances by the line's length and then skips one character if the next character in the original plain text is a space (the space `wrap_text` consumed). If wrapping preserves trailing spaces, this skip is wrong and subsequent span styling shifts by one character.
-
-## `wrap_text` measures in characters, not visual columns
-
-`style.py:195–241`: all line-length comparisons inside `wrap_text` use `len()` (character count), not `visual_len()`. A 2-column-wide CJK character is counted as 1 column-unit, so wrapped lines silently overflow their allocated width by one cell per wide character. This affects every block type that calls `wrap_text`.
-
-## Unknown directive names silently become PANEL
-
-`parser.py:339`: `_DIRECTIVE_TO_BLOCK.get(name, BlockType.PANEL)` — any unrecognized `:::name` becomes a bordered PANEL block with no error or warning. Typos in directive names (e.g. `:::callOut`) produce visible output that looks correct but lacks the expected behavior (callout type, icon, color).
-
-## `--tmux`: exit code reflects pane creation, auto-sizing runs a full render, tempfiles leak
-
-`__main__.py:357`: after `tmux split-window` succeeds the parent exits `EXIT_OK` immediately — the pane renders asynchronously. Render errors surface only inside the pane. `--check` is silently dropped with `--tmux` (exit at line 357 precedes the `--check` branch at line 368), even though `--tmux` now runs its own `parse()` call (lines 253–266) for fail-fast syntax validation before spawning the pane. The `--check` "ok" message and exit-code contract are not honoured.
-
-Tempfile cleanup is embedded as `... | less -R; rm -f <tmpfile>` (line 339); `less` killed abnormally (SIGKILL, closed session) leaks `/tmp/termrender-*.md`. `--tmux --watch` skips tempfile creation entirely — the pane is pointed at the real file path, so no leak.
-
-When `--width` is omitted, `--tmux` calls `render(source, width=80, color=False)` (lines 283–290) to measure content width — mermaid subprocesses fire and `TERMRENDER_CJK` mutations apply here. Any exception silently falls back to `pane_width=80`. The pane is capped to `tmux #{pane_width} - 10`; if the tmux query fails, no cap is applied. Minimum enforced pane width is 20.
-
-## `--watch`: re-renders on resize as well as file change; errors are inline, not fatal
-
-`_watch_loop` (lines 99–169) polls `os.path.getmtime` every 0.2 s and also re-renders when `shutil.get_terminal_size()` changes — so a terminal resize triggers a re-render even with no file edit. `width=None` is passed to `render()` each cycle, so auto-detection always uses current pane width.
-
-The loop catches bare `Exception` (line 142) to keep the watcher alive across render errors; errors appear as a one-line message in the pane, not as an exit. `DirectiveError`, `TerminalError`, and `ValueError` (nesting depth) are each caught separately with distinct prefixes for that same reason — the watcher never exits on render failure, only on `KeyboardInterrupt`.
-
-The alternate screen buffer (`\033[?1049h` / `\033[?1049l`) is entered on start and restored in a `finally` block, so Ctrl+C cleanly returns to the prior terminal state. `--watch` requires a FILE argument; stdin cannot be watched (polled by path, not fd).
-
-## `TERMRENDER_COLOR=1` forces color when stdout is not a tty
-
-`use_color` (lines 361–363 and 388–390) is `True` when stdout is a tty OR `TERMRENDER_COLOR == "1"`. The tmux pane command is prefixed with `TERMRENDER_COLOR=1` (lines 334, 337) so color survives the `| less -R` pipe. Setting this env var in scripts achieves the same effect — it overrides the tty check entirely.
-
-## `_EMOJI_WIDE_RANGES` must stay sorted by codepoint
-
-`_char_width()` (style.py:144) exits the range scan early on `cp < lo`, assuming all ranges are in ascending codepoint order. Adding a new range out of order causes the early exit to skip ranges with higher `lo` values, silently misclassifying those codepoints as 1-wide.