mkdocs2confluence 0.16.0__tar.gz → 0.17.0__tar.gz

{mkdocs2confluence-0.16.0/src/mkdocs2confluence.egg-info → mkdocs2confluence-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.16.0
+Version: 0.17.0
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later
@@ -158,7 +158,7 @@ confluence:
   email: user@example.com
   token: !ENV CONFLUENCE_API_TOKEN   # never hardcode the token
   parent_page_id: "123456"           # optional root page
-  mermaid_render: kroki              # "kroki" (default) | "kroki:https://your-kroki" | "none"
+  mermaid_render: kroki              # "kroki" (default) | "kroki:https://your-kroki" | "none" — also controls PlantUML rendering
   full_width: true                   # default: true
   attachment_preview: false          # default: false — inline PDF/Office previews
   changelog: CHANGELOG.md           # optional: publish as a top-level "What's New" page

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0}/README.md

@@ -116,7 +116,7 @@ confluence:
   email: user@example.com
   token: !ENV CONFLUENCE_API_TOKEN   # never hardcode the token
   parent_page_id: "123456"           # optional root page
-  mermaid_render: kroki              # "kroki" (default) | "kroki:https://your-kroki" | "none"
+  mermaid_render: kroki              # "kroki" (default) | "kroki:https://your-kroki" | "none" — also controls PlantUML rendering
   full_width: true                   # default: true
   attachment_preview: false          # default: false — inline PDF/Office previews
   changelog: CHANGELOG.md           # optional: publish as a top-level "What's New" page

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs2confluence"
-version = "0.16.0"
+version = "0.17.0"
 description = "Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0/src/mkdocs2confluence.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.16.0
+Version: 0.17.0
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later
@@ -158,7 +158,7 @@ confluence:
   email: user@example.com
   token: !ENV CONFLUENCE_API_TOKEN   # never hardcode the token
   parent_page_id: "123456"           # optional root page
-  mermaid_render: kroki              # "kroki" (default) | "kroki:https://your-kroki" | "none"
+  mermaid_render: kroki              # "kroki" (default) | "kroki:https://your-kroki" | "none" — also controls PlantUML rendering
   full_width: true                   # default: true
   attachment_preview: false          # default: false — inline PDF/Office previews
   changelog: CHANGELOG.md           # optional: publish as a top-level "What's New" page

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0}/src/mkdocs2confluence.egg-info/SOURCES.txt

@@ -58,6 +58,7 @@ src/mkdocs_to_confluence/sync/github.py
 src/mkdocs_to_confluence/sync/platform.py
 src/mkdocs_to_confluence/sync/state.py
 src/mkdocs_to_confluence/transforms/__init__.py
+src/mkdocs_to_confluence/transforms/_kroki.py
 src/mkdocs_to_confluence/transforms/abbrevs.py
 src/mkdocs_to_confluence/transforms/admonition_titles.py
 src/mkdocs_to_confluence/transforms/assets.py
@@ -68,6 +69,7 @@ src/mkdocs_to_confluence/transforms/footer.py
 src/mkdocs_to_confluence/transforms/images.py
 src/mkdocs_to_confluence/transforms/internallinks.py
 src/mkdocs_to_confluence/transforms/mermaid.py
+src/mkdocs_to_confluence/transforms/plantuml.py
 tests/test_abbrevs.py
 tests/test_admonition_titles.py
 tests/test_attachment_previews.py
@@ -92,6 +94,7 @@ tests/test_mermaid.py
 tests/test_page_loader.py
 tests/test_parser.py
 tests/test_pdf.py
+tests/test_plantuml.py
 tests/test_preprocess.py
 tests/test_preview.py
 tests/test_publish_client.py

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0}/src/mkdocs_to_confluence/compiler/page.py

@@ -8,7 +8,7 @@ from mkdocs_to_confluence.ir.nodes import ChildrenMacro, FrontMatter, SourceFoot
 from mkdocs_to_confluence.loader.config import MkDocsConfig
 from mkdocs_to_confluence.loader.nav import NavNode
 from mkdocs_to_confluence.loader.page import load_page
-from mkdocs_to_confluence.parser.markdown import parse
+from mkdocs_to_confluence.parser.markdown import parse, parse_inline
 from mkdocs_to_confluence.preprocess.abbrevs import (
     extract_abbreviations,
     strip_abbreviation_defs,
@@ -26,6 +26,7 @@ from mkdocs_to_confluence.preprocess.linkdefs import (
     expand_link_refs,
     strip_link_defs,
 )
+from mkdocs_to_confluence.transforms._kroki import DEFAULT_KROKI_URL
 from mkdocs_to_confluence.transforms.abbrevs import apply_abbreviations
 from mkdocs_to_confluence.transforms.admonition_titles import (
     strip_links_in_admonition_titles,
@@ -38,7 +39,8 @@ from mkdocs_to_confluence.transforms.captions import resolve_captions
 from mkdocs_to_confluence.transforms.editlink import attach_source_url
 from mkdocs_to_confluence.transforms.footer import build_source_footer
 from mkdocs_to_confluence.transforms.internallinks import resolve_internal_links
-from mkdocs_to_confluence.transforms.mermaid import DEFAULT_KROKI_URL, render_mermaid_diagrams
+from mkdocs_to_confluence.transforms.mermaid import render_mermaid_diagrams
+from mkdocs_to_confluence.transforms.plantuml import render_plantuml_diagrams
 
 
 def compile_page(
@@ -79,7 +81,9 @@ def compile_page(
     ir_nodes = strip_links_in_admonition_titles(ir_nodes, node.docs_path or "")
     if is_section_index:
         ir_nodes = ir_nodes + (ChildrenMacro(),)
-    ir_nodes = apply_abbreviations(ir_nodes, abbrevs, page_text=preprocessed)
+    # Parse definitions as inline markdown so links etc. survive into the glossary.
+    parsed_abbrevs = {abbr: parse_inline(defn) for abbr, defn in abbrevs.items()}
+    ir_nodes = apply_abbreviations(ir_nodes, parsed_abbrevs, page_text=preprocessed)
     ir_nodes, attachments = resolve_local_assets(
         ir_nodes,
         page_path=node.source_path,
@@ -97,6 +101,8 @@ def compile_page(
         )
         ir_nodes, mermaid_attachments = render_mermaid_diagrams(ir_nodes, kroki_url, quiet=quiet)
         attachments = attachments + mermaid_attachments
+        ir_nodes, plantuml_attachments = render_plantuml_diagrams(ir_nodes, kroki_url, quiet=quiet)
+        attachments = attachments + plantuml_attachments
     effective_link_map = link_map if link_map is not None else {}
     if node.docs_path:
         ir_nodes = resolve_internal_links(ir_nodes, effective_link_map, node.docs_path)

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0}/src/mkdocs_to_confluence/emitter/xhtml.py

@@ -51,6 +51,7 @@ from mkdocs_to_confluence.ir.nodes import (
     MermaidDiagram,
     OrderedList,
     Paragraph,
+    PlantUMLDiagram,
     RawHTML,
     RawInlineHtml,
     Section,
@@ -187,6 +188,8 @@ def _emit_node(node: IRNode) -> str:
         return _emit_raw_html(node)
     if isinstance(node, MermaidDiagram):
         return _emit_mermaid(node)
+    if isinstance(node, PlantUMLDiagram):
+        return _emit_plantuml(node)
     if isinstance(node, ContentTabs):
         return _emit_content_tabs(node)
     if isinstance(node, Expandable):
@@ -505,6 +508,25 @@ def _emit_mermaid(node: MermaidDiagram) -> str:
     )
 
 
+def _emit_plantuml(node: PlantUMLDiagram) -> str:
+    if node.attachment_name is not None:
+        filename = html.escape(node.attachment_name)
+        local_attr = (
+            f' data-local-path="{html.escape(str(node.local_path))}"'
+            if node.local_path is not None
+            else ""
+        )
+        return f'<ac:image ac:align="center"{local_attr}><ri:attachment ri:filename="{filename}"/></ac:image>\n'
+    # Fallback: show source as a code block when rendering was skipped/disabled.
+    safe = node.source.replace("]]>", "]]]]><![CDATA[>")
+    return (
+        '<ac:structured-macro ac:name="code">\n'
+        '  <ac:parameter ac:name="language">text</ac:parameter>\n'
+        f"  <ac:plain-text-body><![CDATA[{safe}]]></ac:plain-text-body>\n"
+        "</ac:structured-macro>\n"
+    )
+
+
 def _emit_content_tabs(node: ContentTabs) -> str:
     # Degrade to a series of expand macros (one per tab)
     parts: list[str] = []
@@ -623,11 +645,11 @@ def _emit_abbrev_glossary_block(node: AbbrevGlossaryBlock) -> str:
             f"</ac:structured-macro>"
         )
         abbr = html.escape(fn.abbr)
-        defn = html.escape(fn.definition)
+        defn = _emit_inlines(fn.definition)
         parts.append(f"<li>{anchor_macro}<strong>{abbr}</strong> — {defn}</li>\n")
-    for abbr, defn in node.extras:
+    for fn in node.extras:
         # No anchor — these only appeared in headings/titles, no inline superscript links here.
-        parts.append(f"<li><strong>{html.escape(abbr)}</strong> — {html.escape(defn)}</li>\n")
+        parts.append(f"<li><strong>{html.escape(fn.abbr)}</strong> — {_emit_inlines(fn.definition)}</li>\n")
     parts.append("</ol>\n")
     return "".join(parts)
 

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0}/src/mkdocs_to_confluence/ir/nodes.py

@@ -378,6 +378,20 @@ class MermaidDiagram(IRNode):
     local_path: Path | None = None  # set by mermaid transform; used by preview renderer
 
 
+@dataclass(frozen=True)
+class PlantUMLDiagram(IRNode):
+    """A PlantUML diagram (`` ```plantuml `` fenced block).
+
+    ``source`` is the raw PlantUML DSL.  When ``attachment_name`` is set the
+    emitter renders an ``<ac:image>`` referencing the uploaded PNG; otherwise
+    it falls back to a code block showing the raw source.
+    """
+
+    source: str
+    attachment_name: str | None = None
+    local_path: Path | None = None  # set by plantuml transform; used by preview renderer
+
+
 @dataclass(frozen=True)
 class Tab(IRNode):
     """A single tab inside a :class:`ContentTabs` group."""
@@ -497,11 +511,16 @@ class AbbrevFootnoteNode(IRNode):
 
     The emitter renders ``ABBR<sup>[N]</sup>`` where ``[N]`` links to the
     corresponding entry in the end-of-page :class:`AbbrevGlossaryBlock`.
+
+    ``definition`` holds the definition text parsed as inline IR nodes so
+    that links and other inline formatting survive into the glossary.
     """
 
     abbr: str
-    definition: str
-    number: int  # 1-based, assigned by the transform in order of first encounter
+    definition: tuple[IRNode, ...]
+    # 1-based, assigned by the transform in order of first encounter.
+    # ``None`` for glossary-only entries (no inline superscript, no anchor).
+    number: int | None
 
 
 @dataclass(frozen=True)
@@ -509,17 +528,17 @@ class AbbrevGlossaryBlock(IRNode):
     """End-of-page abbreviations reference block.
 
     Rendered as a numbered list (with Confluence anchor targets for the
-    back-links) followed by an optional bullet list of abbreviations that
-    only appeared in headings or other non-expandable contexts.
+    back-links) followed by entries for abbreviations that only appeared
+    in headings or other non-expandable contexts.
 
     Attributes:
         footnoted: Abbreviations annotated inline, ordered by first encounter.
-        extras:    ``(abbr, definition)`` pairs for abbreviations that could
+        extras:    Entries (``number=None``) for abbreviations that could
                    not be annotated inline, sorted alphabetically.
     """
 
     footnoted: tuple[AbbrevFootnoteNode, ...]
-    extras: tuple[tuple[str, str], ...]
+    extras: tuple[AbbrevFootnoteNode, ...]
 
 
 # ── Footnotes ────────────────────────────────────────────────────────────────

mkdocs2confluence-0.17.0/src/mkdocs_to_confluence/parser/__init__.py

@@ -0,0 +1,5 @@
+"""Markdown parser: convert preprocessed markdown text into IR nodes."""
+
+from mkdocs_to_confluence.parser.markdown import parse, parse_inline
+
+__all__ = ["parse", "parse_inline"]

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0}/src/mkdocs_to_confluence/parser/markdown.py

@@ -81,6 +81,7 @@ from mkdocs_to_confluence.ir.nodes import (
     MermaidDiagram,
     OrderedList,
     Paragraph,
+    PlantUMLDiagram,
     RawInlineHtml,
     Section,
     StrikethroughNode,
@@ -111,6 +112,16 @@ def parse(text: str) -> tuple[IRNode, ...]:
     return _build_tree(tokens)
 
 
+def parse_inline(text: str) -> tuple[IRNode, ...]:
+    """Parse a standalone snippet of inline markdown into IR inline nodes.
+
+    Used for one-line fragments that live outside the main document flow,
+    e.g. abbreviation definitions, where links and other inline formatting
+    must still be honoured.
+    """
+    return _parse_inline(text)
+
+
 # ── Internal token types ──────────────────────────────────────────────────────
 
 
@@ -1131,6 +1142,8 @@ def _build_tree(
         elif isinstance(token, _CodeToken):
             if token.language and token.language.lower() == "mermaid":
                 _append_content(MermaidDiagram(source=token.code), stack, root)
+            elif token.language and token.language.lower() == "plantuml":
+                _append_content(PlantUMLDiagram(source=token.code), stack, root)
             else:
                 _append_content(
                     CodeBlock(

mkdocs2confluence-0.17.0/src/mkdocs_to_confluence/transforms/_kroki.py

@@ -0,0 +1,132 @@
+"""Generic Kroki diagram rendering utilities shared by all diagram transforms.
+
+Provides:
+- :func:`kroki_post_png` — low-level HTTP POST to Kroki for any diagram type.
+- :func:`render_diagrams` — concurrent deduplication/replacement loop used by
+  every diagram-type transform.  Each transform supplies its own ``render_fn``
+  that handles type-specific caching and retry behaviour.
+
+Shared constants (timeouts, retry counts, etc.) are defined here so diagram
+transforms stay in sync without duplication.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import sys
+import threading
+import urllib.request
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Protocol, TypeVar, cast
+
+from mkdocs_to_confluence.ir.nodes import IRNode, walk
+from mkdocs_to_confluence.ir.treeutil import replace_nodes
+
+DEFAULT_KROKI_URL = "https://kroki.io"
+
+_TIMEOUT = 30  # seconds
+_MIN_PNG_BYTES = 67  # smallest valid PNG (1×1 px) is 67 bytes
+_CACHE_LOCK = threading.Lock()
+_MAX_WORKERS = 8
+_RETRY_ATTEMPTS = 3
+_RETRY_BACKOFF = 1.0  # seconds; doubles each attempt
+_RETRYABLE_HTTP = {429, 500, 502, 503, 504}
+
+
+class _DiagramNode(Protocol):
+    """Structural protocol for diagram IR nodes (Mermaid, PlantUML, …)."""
+
+    source: str
+    attachment_name: str | None
+    local_path: Path | None
+
+
+_D = TypeVar("_D", bound="_DiagramNode")
+
+
+def kroki_post_png(source: str, diagram_type: str, kroki_url: str) -> bytes:
+    """POST *source* to Kroki for *diagram_type* and return PNG bytes."""
+    url = f"{kroki_url.rstrip('/')}/{diagram_type}/png"
+    body = source.encode("utf-8")
+    req = urllib.request.Request(
+        url,
+        data=body,
+        headers={
+            "Content-Type": "text/plain",
+            "Accept": "image/png",
+            "User-Agent": "mk2conf/1.0",
+        },
+        method="POST",
+    )
+    with urllib.request.urlopen(req, timeout=_TIMEOUT) as resp:  # noqa: S310  # nosec B310
+        return cast(bytes, resp.read())
+
+
+def warn(msg: str) -> None:
+    print(f"  warning    {msg}", file=sys.stderr)
+
+
+def render_diagrams(
+    nodes: tuple[IRNode, ...],
+    node_class: type[Any],
+    render_fn: Callable[[str, bool], Path | None],
+    *,
+    quiet: bool = False,
+) -> tuple[tuple[IRNode, ...], list[Path]]:
+    """Render all *node_class* nodes to PNG concurrently.
+
+    *render_fn* is called as ``render_fn(source, quiet)`` for each unique
+    diagram source; it must return a :class:`Path` on success or ``None`` on
+    failure.  Each diagram type supplies its own ``render_fn`` that handles
+    caching, retries, and any type-specific fallback.
+
+    Returns the updated IR node tuple (``attachment_name`` set on successful
+    renders) and a list of PNG paths to upload as page attachments.  Failed
+    nodes are left unchanged so the emitter can fall back to a code block.
+    """
+    diagrams: list[Any] = []
+    seen_sources: set[str] = set()
+    for top_node in nodes:
+        for node in walk(top_node):
+            if isinstance(node, node_class) and node.attachment_name is None:
+                if node.source not in seen_sources:
+                    diagrams.append(node)
+                    seen_sources.add(node.source)
+
+    if not diagrams:
+        return nodes, []
+
+    source_to_path: dict[str, Path | None] = {}
+    with ThreadPoolExecutor(max_workers=min(_MAX_WORKERS, len(diagrams))) as pool:
+        future_to_source = {
+            pool.submit(render_fn, d.source, quiet): d.source
+            for d in diagrams
+        }
+        for future in as_completed(future_to_source):
+            source = future_to_source[future]
+            source_to_path[source] = future.result()
+
+    attachments: list[Path] = []
+    replacements: dict[int, IRNode] = {}
+    seen_paths: set[Path] = set()
+
+    for top_node in nodes:
+        for node in walk(top_node):
+            if not isinstance(node, node_class) or node.attachment_name is not None:
+                continue
+            path = source_to_path.get(node.source)
+            if path is None:
+                continue
+            if path not in seen_paths:
+                attachments.append(path)
+                seen_paths.add(path)
+            replacements[id(node)] = dataclasses.replace(node, attachment_name=path.name, local_path=path)
+
+    if not replacements:
+        return nodes, attachments
+
+    return replace_nodes(nodes, replacements), attachments
+
+

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0}/src/mkdocs_to_confluence/transforms/abbrevs.py

@@ -65,7 +65,7 @@ _BLOCK_TYPES = (
 class _State:
     """Mutable transform state threaded through the recursive walk."""
 
-    def __init__(self, abbrevs: dict[str, str]) -> None:
+    def __init__(self, abbrevs: dict[str, tuple[IRNode, ...]]) -> None:
         self.abbrevs = abbrevs
         self._expanded_list: list[str] = []  # ordered by first encounter
         self._expanded_set: set[str] = set()  # fast membership test
@@ -207,7 +207,7 @@ def _transform_inline(node: IRNode, state: _State, safe: bool) -> tuple[IRNode,
 # ── Glossary builder ──────────────────────────────────────────────────────────
 
 
-def _find_mentioned(text: str, abbrevs: dict[str, str]) -> set[str]:
+def _find_mentioned(text: str, abbrevs: dict[str, tuple[IRNode, ...]]) -> set[str]:
     """Return abbreviations that appear as whole words anywhere in *text*."""
     return {
         abbr
@@ -221,7 +221,7 @@ def _find_mentioned(text: str, abbrevs: dict[str, str]) -> set[str]:
 
 def apply_abbreviations(
     nodes: tuple[IRNode, ...],
-    abbrevs: dict[str, str],
+    abbrevs: dict[str, tuple[IRNode, ...]],
     *,
     page_text: str = "",
 ) -> tuple[IRNode, ...]:
@@ -229,8 +229,12 @@ def apply_abbreviations(
 
     Args:
         nodes:      Top-level IR nodes returned by :func:`parse`.
-        abbrevs:    ``{abbreviation: definition}`` mapping, typically from
-                    :func:`~mkdocs_to_confluence.preprocess.abbrevs.extract_abbreviations`.
+        abbrevs:    ``{abbreviation: definition}`` mapping where each
+                    definition is parsed inline IR nodes (the caller parses
+                    the raw definition strings from
+                    :func:`~mkdocs_to_confluence.preprocess.abbrevs.extract_abbreviations`
+                    with :func:`~mkdocs_to_confluence.parser.parse_inline` so
+                    links and other inline formatting are preserved).
         page_text:  The preprocessed page text (after stripping abbreviation
                     definition lines) used to detect which abbreviations are
                     actually present on the page.
@@ -255,7 +259,7 @@ def apply_abbreviations(
         for i, abbr in enumerate(state._expanded_list)
     )
     extras = tuple(
-        (abbr, abbrevs[abbr])
+        AbbrevFootnoteNode(abbr=abbr, definition=abbrevs[abbr], number=None)
         for abbr in sorted(mentioned - state._expanded_set)
     )
 

{mkdocs2confluence-0.16.0 → mkdocs2confluence-0.17.0}/src/mkdocs_to_confluence/transforms/mermaid.py

@@ -23,32 +23,30 @@ out to external services.
 from __future__ import annotations
 
 import base64
-import dataclasses
 import hashlib
 import json
 import sys
-import threading
 import time
 import urllib.error
 import urllib.request
 import zlib
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import cast
 
-from mkdocs_to_confluence.ir.nodes import IRNode, MermaidDiagram, walk
-from mkdocs_to_confluence.ir.treeutil import replace_nodes
+from mkdocs_to_confluence.ir.nodes import IRNode, MermaidDiagram
+from mkdocs_to_confluence.transforms._kroki import (
+    _CACHE_LOCK,
+    _MIN_PNG_BYTES,
+    _RETRY_ATTEMPTS,
+    _RETRY_BACKOFF,
+    _RETRYABLE_HTTP,
+    _TIMEOUT,
+    DEFAULT_KROKI_URL,
+    render_diagrams,
+)
 
 _CACHE_DIR = Path.home() / ".cache" / "mk2conf" / "mermaid"
-DEFAULT_KROKI_URL = "https://kroki.io"
 _MERMAID_INK_URL = "https://mermaid.ink"
-_TIMEOUT = 30  # seconds
-_MIN_PNG_BYTES = 67  # smallest valid PNG (1×1 px) is 67 bytes
-_CACHE_LOCK = threading.Lock()
-_MAX_WORKERS = 8
-_RETRY_ATTEMPTS = 3
-_RETRY_BACKOFF = 1.0  # seconds; doubles each attempt
-_RETRYABLE_HTTP = {429, 500, 502, 503, 504}
 
 
 def _kroki_png(source: str, kroki_url: str) -> bytes:
@@ -189,49 +187,7 @@ def render_mermaid_diagrams(
     except OSError as exc:
         _warn(f"cannot create mermaid cache dir {_CACHE_DIR}: {exc} — all diagrams will fall back to code blocks")
 
-    # Collect all unresolved MermaidDiagram nodes (deduplicated by source).
-    diagrams: list[MermaidDiagram] = []
-    seen_sources: set[str] = set()
-    for top_node in nodes:
-        for node in walk(top_node):
-            if isinstance(node, MermaidDiagram) and node.attachment_name is None:
-                if node.source not in seen_sources:
-                    diagrams.append(node)
-                    seen_sources.add(node.source)
-
-    if not diagrams:
-        return nodes, []
-
-    # Render all diagrams concurrently, preserving source → result mapping.
-    source_to_path: dict[str, Path | None] = {}
-    with ThreadPoolExecutor(max_workers=min(_MAX_WORKERS, len(diagrams))) as pool:
-        future_to_source = {
-            pool.submit(_render_one, d.source, kroki_url, quiet=quiet): d.source for d in diagrams
-        }
-        for future in as_completed(future_to_source):
-            source = future_to_source[future]
-            source_to_path[source] = future.result()
-
-    # Build replacements and attachments from results.
-    attachments: list[Path] = []
-    replacements: dict[int, IRNode] = {}
-    seen_paths: set[Path] = set()
-
-    for top_node in nodes:
-        for node in walk(top_node):
-            if not isinstance(node, MermaidDiagram) or node.attachment_name is not None:
-                continue
-            path = source_to_path.get(node.source)
-            if path is None:
-                continue  # render failed — leave as code block
-            if path not in seen_paths:
-                attachments.append(path)
-                seen_paths.add(path)
-            replacements[id(node)] = dataclasses.replace(
-                node, attachment_name=path.name, local_path=path
-            )
-
-    if not replacements:
-        return nodes, attachments
-
-    return replace_nodes(nodes, replacements), attachments
+    def render_fn(source: str, q: bool) -> Path | None:
+        return _render_one(source, kroki_url, quiet=q)
+
+    return render_diagrams(nodes, MermaidDiagram, render_fn, quiet=quiet)