@drunkcoding/agents-and-skills 0.0.45 → 0.0.46

package/plugins/tech-graph/skills/tech-graph/scripts/generate-from-template.py

@@ -1,1587 +0,0 @@
-#!/usr/bin/env python3
-"""
-Style-driven SVG diagram generator.
-
-Usage:
-  python3 generate-from-template.py <template-type> <output-path> [data-json]
-
-This generator intentionally does more than "fill a template".
-It encodes the visual language from the documented style guides so the output
-tracks the showcase quality more closely than the previous generic renderer.
-"""
-
-from __future__ import annotations
-
-import copy
-import json
-import math
-import os
-import re
-import sys
-from dataclasses import dataclass
-from typing import Dict, Iterable, List, Optional, Sequence, Tuple
-from xml.sax.saxutils import escape
-
-Point = Tuple[float, float]
-Bounds = Tuple[float, float, float, float]
-
-SCRIPT_DIR = os.path.dirname(__file__)
-TEMPLATE_DIR = os.path.join(SCRIPT_DIR, "..", "templates")
-DEFAULT_VIEWBOX = {
-    "architecture": (960, 600),
-    "data-flow": (960, 600),
-    "flowchart": (960, 640),
-    "sequence": (960, 700),
-    "comparison": (960, 620),
-    "timeline": (960, 520),
-    "mind-map": (960, 620),
-    "agent": (960, 700),
-    "memory": (960, 720),
-    "use-case": (960, 600),
-    "class": (960, 700),
-    "state-machine": (960, 620),
-    "er-diagram": (960, 680),
-    "network-topology": (960, 620),
-}
-
-FLOW_ALIASES = {
-    "main": "control",
-    "api": "control",
-    "control": "control",
-    "write": "write",
-    "read": "read",
-    "data": "data",
-    "async": "async",
-    "feedback": "feedback",
-    "neutral": "neutral",
-}
-
-MARKER_IDS = {
-    "control": "arrowA",
-    "write": "arrowB",
-    "read": "arrowC",
-    "data": "arrowE",
-    "async": "arrowF",
-    "feedback": "arrowG",
-    "neutral": "arrowH",
-}
-
-STYLE_PROFILES: Dict[int, Dict[str, object]] = {
-    1: {
-        "name": "Flat Icon",
-        "font_family": "'Helvetica Neue', Helvetica, Arial, 'PingFang SC', 'Microsoft YaHei', 'Microsoft JhengHei', 'SimHei', sans-serif",
-        "background": "#ffffff",
-        "shadow": True,
-        "title_align": "center",
-        "title_fill": "#111827",
-        "title_size": 30,
-        "subtitle_fill": "#6b7280",
-        "subtitle_size": 14,
-        "node_fill": "#ffffff",
-        "node_stroke": "#d1d5db",
-        "node_radius": 10,
-        "node_shadow": "url(#shadowSoft)",
-        "section_fill": "none",
-        "section_stroke": "#dbe5f1",
-        "section_dash": "6 5",
-        "section_label_fill": "#2563eb",
-        "section_sub_fill": "#94a3b8",
-        "title_divider": False,
-        "section_upper": True,
-        "arrow_width": 2.4,
-        "arrow_colors": {
-            "control": "#7c3aed",
-            "write": "#10b981",
-            "read": "#2563eb",
-            "data": "#f97316",
-            "async": "#7c3aed",
-            "feedback": "#ef4444",
-            "neutral": "#6b7280",
-        },
-        "arrow_label_bg": "#ffffff",
-        "arrow_label_opacity": 0.94,
-        "arrow_label_fill": "#6b7280",
-        "type_label_fill": "#9ca3af",
-        "type_label_size": 12,
-        "text_primary": "#111827",
-        "text_secondary": "#6b7280",
-        "text_muted": "#94a3b8",
-        "legend_fill": "#6b7280",
-    },
-    2: {
-        "name": "Dark Terminal",
-        "font_family": "'SF Mono', 'Fira Code', Menlo, 'Microsoft YaHei', 'SimHei', monospace",
-        "background": "#0f172a",
-        "shadow": False,
-        "title_align": "center",
-        "title_fill": "#e2e8f0",
-        "title_size": 30,
-        "subtitle_fill": "#94a3b8",
-        "subtitle_size": 14,
-        "node_fill": "#111827",
-        "node_stroke": "#334155",
-        "node_radius": 10,
-        "node_shadow": "",
-        "section_fill": "rgba(15,23,42,0.28)",
-        "section_stroke": "#334155",
-        "section_dash": "7 6",
-        "section_label_fill": "#38bdf8",
-        "section_sub_fill": "#64748b",
-        "title_divider": False,
-        "section_upper": True,
-        "arrow_width": 2.3,
-        "arrow_colors": {
-            "control": "#a855f7",
-            "write": "#22c55e",
-            "read": "#38bdf8",
-            "data": "#fb7185",
-            "async": "#f59e0b",
-            "feedback": "#f97316",
-            "neutral": "#94a3b8",
-        },
-        "arrow_label_bg": "#0f172a",
-        "arrow_label_opacity": 0.92,
-        "arrow_label_fill": "#cbd5e1",
-        "type_label_fill": "#64748b",
-        "type_label_size": 12,
-        "text_primary": "#e2e8f0",
-        "text_secondary": "#94a3b8",
-        "text_muted": "#64748b",
-        "legend_fill": "#94a3b8",
-    },
-    3: {
-        "name": "Blueprint",
-        "font_family": "'SF Mono', 'Fira Code', Menlo, 'Microsoft YaHei', 'SimHei', monospace",
-        "background": "#082f49",
-        "shadow": False,
-        "title_align": "center",
-        "title_fill": "#e0f2fe",
-        "title_size": 30,
-        "subtitle_fill": "#7dd3fc",
-        "subtitle_size": 14,
-        "node_fill": "#0b3b5e",
-        "node_stroke": "#67e8f9",
-        "node_radius": 8,
-        "node_shadow": "",
-        "section_fill": "none",
-        "section_stroke": "#0ea5e9",
-        "section_dash": "6 4",
-        "section_label_fill": "#67e8f9",
-        "section_sub_fill": "#7dd3fc",
-        "title_divider": False,
-        "section_upper": True,
-        "arrow_width": 2.1,
-        "arrow_colors": {
-            "control": "#67e8f9",
-            "write": "#22d3ee",
-            "read": "#38bdf8",
-            "data": "#fde047",
-            "async": "#c084fc",
-            "feedback": "#fb7185",
-            "neutral": "#bae6fd",
-        },
-        "arrow_label_bg": "#082f49",
-        "arrow_label_opacity": 0.9,
-        "arrow_label_fill": "#e0f2fe",
-        "type_label_fill": "#7dd3fc",
-        "type_label_size": 11,
-        "text_primary": "#e0f2fe",
-        "text_secondary": "#bae6fd",
-        "text_muted": "#7dd3fc",
-        "legend_fill": "#bae6fd",
-    },
-    4: {
-        "name": "Notion Clean",
-        "font_family": "-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Helvetica Neue', Arial, 'PingFang SC', 'Microsoft YaHei', 'Microsoft JhengHei', 'SimHei', sans-serif",
-        "background": "#ffffff",
-        "shadow": False,
-        "title_align": "left",
-        "title_fill": "#111827",
-        "title_size": 18,
-        "subtitle_fill": "#9ca3af",
-        "subtitle_size": 13,
-        "node_fill": "#f9fafb",
-        "node_stroke": "#e5e7eb",
-        "node_radius": 4,
-        "node_shadow": "",
-        "section_fill": "none",
-        "section_stroke": "#e5e7eb",
-        "section_dash": "",
-        "section_label_fill": "#9ca3af",
-        "section_sub_fill": "#d1d5db",
-        "title_divider": True,
-        "section_upper": True,
-        "arrow_width": 1.8,
-        "arrow_colors": {
-            "control": "#3b82f6",
-            "write": "#3b82f6",
-            "read": "#3b82f6",
-            "data": "#3b82f6",
-            "async": "#9ca3af",
-            "feedback": "#9ca3af",
-            "neutral": "#d1d5db",
-        },
-        "arrow_label_bg": "#ffffff",
-        "arrow_label_opacity": 0.96,
-        "arrow_label_fill": "#6b7280",
-        "type_label_fill": "#9ca3af",
-        "type_label_size": 11,
-        "text_primary": "#111827",
-        "text_secondary": "#374151",
-        "text_muted": "#9ca3af",
-        "legend_fill": "#6b7280",
-    },
-    5: {
-        "name": "Glassmorphism",
-        "font_family": "'Helvetica Neue', Helvetica, Arial, 'PingFang SC', 'Microsoft YaHei', 'Microsoft JhengHei', 'SimHei', sans-serif",
-        "background": "#0f172a",
-        "shadow": True,
-        "title_align": "center",
-        "title_fill": "#f8fafc",
-        "title_size": 30,
-        "subtitle_fill": "#cbd5e1",
-        "subtitle_size": 14,
-        "node_fill": "rgba(255,255,255,0.12)",
-        "node_stroke": "rgba(255,255,255,0.28)",
-        "node_radius": 18,
-        "node_shadow": "url(#shadowGlass)",
-        "section_fill": "rgba(255,255,255,0.05)",
-        "section_stroke": "rgba(255,255,255,0.18)",
-        "section_dash": "7 6",
-        "section_label_fill": "#e2e8f0",
-        "section_sub_fill": "#94a3b8",
-        "title_divider": False,
-        "section_upper": True,
-        "arrow_width": 2.2,
-        "arrow_colors": {
-            "control": "#c084fc",
-            "write": "#34d399",
-            "read": "#60a5fa",
-            "data": "#fb923c",
-            "async": "#f472b6",
-            "feedback": "#f59e0b",
-            "neutral": "#cbd5e1",
-        },
-        "arrow_label_bg": "rgba(15,23,42,0.7)",
-        "arrow_label_opacity": 1,
-        "arrow_label_fill": "#e2e8f0",
-        "type_label_fill": "#cbd5e1",
-        "type_label_size": 12,
-        "text_primary": "#f8fafc",
-        "text_secondary": "#cbd5e1",
-        "text_muted": "#94a3b8",
-        "legend_fill": "#cbd5e1",
-    },
-    6: {
-        "name": "Claude Official",
-        "font_family": "'Helvetica Neue', Helvetica, Arial, 'PingFang SC', 'Microsoft YaHei', 'Microsoft JhengHei', 'SimHei', sans-serif",
-        "background": "#f8f6f3",
-        "shadow": False,
-        "title_align": "left",
-        "title_fill": "#141413",
-        "title_size": 24,
-        "subtitle_fill": "#8f8a80",
-        "subtitle_size": 13,
-        "node_fill": "#fffcf7",
-        "node_stroke": "#d9d0c3",
-        "node_radius": 10,
-        "node_shadow": "",
-        "section_fill": "none",
-        "section_stroke": "#ded8cf",
-        "section_dash": "5 4",
-        "section_label_fill": "#8b7355",
-        "section_sub_fill": "#b4aba0",
-        "title_divider": True,
-        "section_upper": True,
-        "arrow_width": 2.0,
-        "arrow_colors": {
-            "control": "#d97757",
-            "write": "#7b8b5c",
-            "read": "#8c6f5a",
-            "data": "#b45309",
-            "async": "#9a6fb0",
-            "feedback": "#d97757",
-            "neutral": "#8f8a80",
-        },
-        "arrow_label_bg": "#f8f6f3",
-        "arrow_label_opacity": 0.96,
-        "arrow_label_fill": "#6b6257",
-        "type_label_fill": "#a29a8f",
-        "type_label_size": 11,
-        "text_primary": "#141413",
-        "text_secondary": "#6b6257",
-        "text_muted": "#a29a8f",
-        "legend_fill": "#6b6257",
-    },
-    7: {
-        "name": "OpenAI",
-        "font_family": "'Helvetica Neue', Helvetica, Arial, 'PingFang SC', 'Microsoft YaHei', 'Microsoft JhengHei', 'SimHei', sans-serif",
-        "background": "#ffffff",
-        "shadow": False,
-        "title_align": "left",
-        "title_fill": "#0f172a",
-        "title_size": 24,
-        "subtitle_fill": "#64748b",
-        "subtitle_size": 13,
-        "node_fill": "#ffffff",
-        "node_stroke": "#dce5e3",
-        "node_radius": 14,
-        "node_shadow": "",
-        "section_fill": "none",
-        "section_stroke": "#e2e8f0",
-        "section_dash": "5 4",
-        "section_label_fill": "#10a37f",
-        "section_sub_fill": "#94a3b8",
-        "title_divider": True,
-        "section_upper": True,
-        "arrow_width": 2.0,
-        "arrow_colors": {
-            "control": "#10a37f",
-            "write": "#0f766e",
-            "read": "#0891b2",
-            "data": "#f59e0b",
-            "async": "#64748b",
-            "feedback": "#10a37f",
-            "neutral": "#94a3b8",
-        },
-        "arrow_label_bg": "#ffffff",
-        "arrow_label_opacity": 0.96,
-        "arrow_label_fill": "#475569",
-        "type_label_fill": "#94a3b8",
-        "type_label_size": 11,
-        "text_primary": "#0f172a",
-        "text_secondary": "#475569",
-        "text_muted": "#94a3b8",
-        "legend_fill": "#475569",
-    },
-}
-
-
-@dataclass
-class Node:
-    node_id: str
-    kind: str
-    shape: str
-    data: Dict[str, object]
-    bounds: Bounds
-    cx: float
-    cy: float
-
-
-def style_value(style: Dict[str, object], key: str) -> object:
-    return style[key]
-
-
-def to_float(value: object, default: float = 0.0) -> float:
-    try:
-        return float(value)
-    except (TypeError, ValueError):
-        return default
-
-
-def normalize_text(value: object) -> str:
-    return escape(str(value)) if value is not None else ""
-
-
-def parse_style(raw: object) -> Tuple[int, Dict[str, object]]:
-    if raw is None:
-        index = 1
-    elif isinstance(raw, int):
-        index = raw
-    else:
-        text = str(raw).strip().lower()
-        if text.isdigit():
-            index = int(text)
-        else:
-            names = {profile["name"].lower(): key for key, profile in STYLE_PROFILES.items()}
-            index = names.get(text, 1)
-    if index not in STYLE_PROFILES:
-        raise ValueError(f"Unsupported style: {raw}")
-    return index, copy.deepcopy(STYLE_PROFILES[index])
-
-
-def parse_template_viewbox(template_type: str) -> Tuple[float, float]:
-    template_path = os.path.join(TEMPLATE_DIR, f"{template_type}.svg")
-    if os.path.exists(template_path):
-        content = open(template_path, "r", encoding="utf-8").read()
-        match = re.search(r'viewBox="0 0 ([0-9.]+) ([0-9.]+)"', content)
-        if match:
-            return float(match.group(1)), float(match.group(2))
-    return DEFAULT_VIEWBOX.get(template_type, (960, 600))
-
-
-def render_defs(style_index: int, style: Dict[str, object]) -> str:
-    marker_size = "8" if style_index == 4 else "10"
-    marker_height = "6" if style_index == 4 else "7"
-    ref_x = "7" if style_index == 4 else "9"
-    ref_y = "3" if style_index == 4 else "3.5"
-    color_map = style_value(style, "arrow_colors")
-    marker_lines = []
-    for key, color in color_map.items():
-        marker_id = MARKER_IDS.get(key, "arrowA")
-        marker_lines.append(
-            f'    <marker id="{marker_id}" markerWidth="{marker_size}" markerHeight="{marker_height}" '
-            f'refX="{ref_x}" refY="{ref_y}" orient="auto">'
-        )
-        if style_index == 4:
-            marker_lines.append(f'      <polygon points="0 0, 8 3, 0 6" fill="{color}"/>')
-        else:
-            marker_lines.append(f'      <polygon points="0 0, 10 3.5, 0 7" fill="{color}"/>')
-        marker_lines.append("    </marker>")
-
-    filters = []
-    if style_value(style, "shadow"):
-        filters.extend(
-            [
-                '    <filter id="shadowSoft" x="-20%" y="-20%" width="140%" height="160%">',
-                '      <feDropShadow dx="0" dy="3" stdDeviation="6" flood-color="#0f172a" flood-opacity="0.12"/>',
-                "    </filter>",
-                '    <filter id="shadowGlass" x="-20%" y="-20%" width="140%" height="160%">',
-                '      <feDropShadow dx="0" dy="10" stdDeviation="16" flood-color="#020617" flood-opacity="0.28"/>',
-                "    </filter>",
-            ]
-        )
-
-    if style_index == 3:
-        filters.extend(
-            [
-                '    <pattern id="blueprintGrid" width="32" height="32" patternUnits="userSpaceOnUse">',
-                '      <path d="M 32 0 L 0 0 0 32" fill="none" stroke="#0ea5e9" stroke-opacity="0.12" stroke-width="1"/>',
-                "    </pattern>",
-            ]
-        )
-    if style_index == 2:
-        filters.extend(
-            [
-                '    <linearGradient id="terminalGradient" x1="0%" y1="0%" x2="100%" y2="100%">',
-                '      <stop offset="0%" stop-color="#0f0f1a"/>',
-                '      <stop offset="100%" stop-color="#1a1a2e"/>',
-                "    </linearGradient>",
-                '    <filter id="glowBlue" x="-30%" y="-30%" width="160%" height="160%">',
-                '      <feDropShadow dx="0" dy="0" stdDeviation="5" flood-color="#3b82f6" flood-opacity="0.65"/>',
-                "    </filter>",
-                '    <filter id="glowPurple" x="-30%" y="-30%" width="160%" height="160%">',
-                '      <feDropShadow dx="0" dy="0" stdDeviation="5" flood-color="#a855f7" flood-opacity="0.72"/>',
-                "    </filter>",
-                '    <filter id="glowGreen" x="-30%" y="-30%" width="160%" height="160%">',
-                '      <feDropShadow dx="0" dy="0" stdDeviation="5" flood-color="#22c55e" flood-opacity="0.62"/>',
-                "    </filter>",
-                '    <filter id="glowOrange" x="-30%" y="-30%" width="160%" height="160%">',
-                '      <feDropShadow dx="0" dy="0" stdDeviation="5" flood-color="#f97316" flood-opacity="0.62"/>',
-                "    </filter>",
-            ]
-        )
-
-    styles = [
-        f"    text {{ font-family: {style_value(style, 'font_family')}; }}",
-        f"    .title {{ font-size: {style_value(style, 'title_size')}px; font-weight: 700; fill: {style_value(style, 'title_fill')}; }}",
-        f"    .subtitle {{ font-size: {style_value(style, 'subtitle_size')}px; font-weight: 500; fill: {style_value(style, 'subtitle_fill')}; }}",
-        f"    .section {{ font-size: 13px; font-weight: 700; fill: {style_value(style, 'section_label_fill')}; letter-spacing: 1.4px; }}",
-        f"    .section-sub {{ font-size: 12px; font-weight: 500; fill: {style_value(style, 'section_sub_fill')}; }}",
-        f"    .node-title {{ font-size: 18px; font-weight: 700; fill: {style_value(style, 'text_primary')}; }}",
-        f"    .node-sub {{ font-size: 12px; font-weight: 500; fill: {style_value(style, 'text_secondary')}; }}",
-        f"    .node-type {{ font-size: {style_value(style, 'type_label_size')}px; font-weight: 700; fill: {style_value(style, 'type_label_fill')}; letter-spacing: 0.08em; }}",
-        f"    .arrow-label {{ font-size: 12px; font-weight: 600; fill: {style_value(style, 'arrow_label_fill')}; }}",
-        f"    .legend {{ font-size: 12px; font-weight: 500; fill: {style_value(style, 'legend_fill')}; }}",
-        f"    .footnote {{ font-size: 12px; font-weight: 500; fill: {style_value(style, 'text_muted')}; }}",
-    ]
-    return "\n".join(
-        ["  <defs>"] + marker_lines + filters + ["    <style>"] + styles + ["    </style>", "  </defs>"]
-    )
-
-
-def render_canvas(style_index: int, style: Dict[str, object], width: float, height: float) -> str:
-    background = str(style_value(style, "background"))
-    if style_index == 2:
-        parts = [f'  <rect width="{width}" height="{height}" fill="url(#terminalGradient)"/>']
-    else:
-        parts = [f'  <rect width="{width}" height="{height}" fill="{background}"/>']
-
-    return "\n".join(parts)
-
-
-def title_position(style: Dict[str, object], width: float) -> Tuple[float, str]:
-    if style_value(style, "title_align") == "left":
-        return 48.0, "start"
-    return width / 2.0, "middle"
-
-
-def render_title_block(style: Dict[str, object], data: Dict[str, object], width: float) -> Tuple[str, float]:
-    title = normalize_text(data.get("title", "Diagram"))
-    subtitle = normalize_text(data.get("subtitle", ""))
-    x, anchor = title_position(style, width)
-    if anchor == "middle":
-        parts = [f'  <text x="{x}" y="56" text-anchor="{anchor}" class="title">{title}</text>']
-        cursor_y = 82
-        if subtitle:
-            parts.append(f'  <text x="{x}" y="{cursor_y}" text-anchor="{anchor}" class="subtitle">{subtitle}</text>')
-            cursor_y += 24
-        return "\n".join(parts), cursor_y + 10
-
-    parts = [f'  <text x="{x}" y="48" text-anchor="{anchor}" class="title">{title}</text>']
-    cursor_y = 72
-    if subtitle:
-        parts.append(f'  <text x="{x}" y="{cursor_y}" text-anchor="{anchor}" class="subtitle">{subtitle}</text>')
-        cursor_y += 18
-    if style_value(style, "title_divider"):
-        parts.append(
-            f'  <line x1="48" y1="{cursor_y + 10}" x2="{width - 48}" y2="{cursor_y + 10}" '
-            f'stroke="{style_value(style, "section_stroke")}" stroke-width="1"/>'
-        )
-        cursor_y += 26
-    return "\n".join(parts), cursor_y + 8
-
-
-def render_window_controls(data: Dict[str, object], style_index: int, width: float) -> str:
-    controls = data.get("window_controls")
-    if not controls:
-        return ""
-    if controls is True:
-        controls = ["#ef4444", "#f59e0b", "#10b981"]
-    if style_index != 2:
-        return ""
-    cursor_x = 20.0
-    lines = []
-    for color in controls:
-        lines.append(f'  <circle cx="{cursor_x}" cy="20" r="5.5" fill="{color}"/>')
-        cursor_x += 18
-    return "\n".join(lines)
-
-
-def render_header_meta(data: Dict[str, object], style: Dict[str, object], width: float) -> str:
-    meta_left = normalize_text(data.get("meta_left", ""))
-    meta_center = normalize_text(data.get("meta_center", ""))
-    meta_right = normalize_text(data.get("meta_right", ""))
-    if not any([meta_left, meta_center, meta_right]):
-        return ""
-    fill = str(data.get("meta_fill", style_value(style, "text_muted")))
-    size = to_float(data.get("meta_size", 11))
-    lines = []
-    if meta_left:
-        lines.append(f'  <text x="28" y="24" font-size="{size}" font-weight="600" fill="{fill}">{meta_left}</text>')
-    if meta_center:
-        lines.append(f'  <text x="{width / 2}" y="24" text-anchor="middle" font-size="{size}" font-weight="600" fill="{fill}">{meta_center}</text>')
-    if meta_right:
-        lines.append(f'  <text x="{width - 28}" y="24" text-anchor="end" font-size="{size}" font-weight="600" fill="{fill}">{meta_right}</text>')
-    return "\n".join(lines)
-
-
-def render_blueprint_title_block(
-    data: Dict[str, object],
-    style: Dict[str, object],
-    style_index: int,
-    width: float,
-    height: float,
-) -> Tuple[str, Optional[Bounds]]:
-    if style_index != 3:
-        return "", None
-    block = data.get("blueprint_title_block")
-    if not block:
-        return "", None
-    block_width = to_float(block.get("width", 256))
-    block_height = to_float(block.get("height", 92))
-    x = to_float(block.get("x", width - block_width - 28))
-    y = to_float(block.get("y", height - block_height - 18))
-    title = normalize_text(block.get("title", data.get("title", "")))
-    subtitle = normalize_text(block.get("subtitle", "SYSTEM ARCHITECTURE"))
-    left_caption = normalize_text(block.get("left_caption", "REV: 1.0"))
-    center_caption = normalize_text(block.get("center_caption", "AUTO-GENERATED"))
-    right_caption = normalize_text(block.get("right_caption", "DWG: ARCH-001"))
-    stroke = str(block.get("stroke", style_value(style, "section_stroke")))
-    fill = str(block.get("fill", "#0b3552"))
-    title_fill = str(block.get("title_fill", style_value(style, "text_primary")))
-    sub_fill = str(block.get("subtitle_fill", style_value(style, "section_label_fill")))
-    muted_fill = str(block.get("muted_fill", style_value(style, "text_muted")))
-    lines = [
-        f'  <rect x="{x}" y="{y}" width="{block_width}" height="{block_height}" fill="{fill}" stroke="{stroke}" stroke-width="1.2"/>',
-        f'  <line x1="{x}" y1="{y + 18}" x2="{x + block_width}" y2="{y + 18}" stroke="{stroke}" stroke-width="1"/>',
-        f'  <line x1="{x}" y1="{y + 54}" x2="{x + block_width}" y2="{y + 54}" stroke="{stroke}" stroke-width="1"/>',
-        f'  <text x="{x + block_width / 2}" y="{y + 13}" text-anchor="middle" font-size="10" font-weight="600" fill="{muted_fill}">{subtitle}</text>',
-        f'  <text x="{x + block_width / 2}" y="{y + 42}" text-anchor="middle" font-size="18" font-weight="700" fill="{title_fill}">{title}</text>',
-        f'  <text x="{x + 12}" y="{y + 75}" font-size="9.5" font-weight="600" fill="{muted_fill}">{left_caption}</text>',
-        f'  <text x="{x + block_width / 2}" y="{y + 75}" text-anchor="middle" font-size="9.5" font-weight="600" fill="{sub_fill}">{center_caption}</text>',
-        f'  <text x="{x + block_width - 12}" y="{y + 75}" text-anchor="end" font-size="9.5" font-weight="600" fill="{muted_fill}">{right_caption}</text>',
-    ]
-    return "\n".join(lines), rectangle_bounds(x - 6, y - 6, block_width + 12, block_height + 12)
-
-
-def infer_shape(kind: str) -> str:
-    mapping = {
-        "rect": "rect",
-        "double_rect": "rect",
-        "cylinder": "rect",
-        "document": "rect",
-        "folder": "rect",
-        "terminal": "rect",
-        "hexagon": "rect",
-        "circle_cluster": "cluster",
-        "user_avatar": "rect",
-        "bot": "rect",
-        "speech": "rect",
-        "icon_box": "rect",
-    }
-    return mapping.get(kind, "rect")
-
-
-def node_bounds(data: Dict[str, object]) -> Bounds:
-    kind = str(data.get("kind", data.get("shape", "rect")))
-    x = to_float(data.get("x"))
-    y = to_float(data.get("y"))
-    if kind == "circle":
-        r = to_float(data.get("r", 50))
-        return (x - r, y - r, x + r, y + r)
-    width = to_float(data.get("width", 180))
-    height = to_float(data.get("height", 76))
-    return (x, y, x + width, y + height)
-
-
-def normalize_node(node_data: Dict[str, object], fallback_id: str) -> Node:
-    kind = str(node_data.get("kind", node_data.get("shape", "rect")))
-    bounds = node_bounds(node_data)
-    left, top, right, bottom = bounds
-    return Node(
-        node_id=str(node_data.get("id", fallback_id)),
-        kind=kind,
-        shape=infer_shape(kind),
-        data=node_data,
-        bounds=bounds,
-        cx=(left + right) / 2,
-        cy=(top + bottom) / 2,
-    )
-
-
-def anchor_on_side(node: Node, side: str) -> Point:
-    left, top, right, bottom = node.bounds
-    cx, cy = node.cx, node.cy
-    side = side.lower()
-    if side == "left":
-        return (left, cy)
-    if side == "right":
-        return (right, cy)
-    if side == "top":
-        return (cx, top)
-    if side == "bottom":
-        return (cx, bottom)
-    if side == "top-left":
-        return (left, top)
-    if side == "top-right":
-        return (right, top)
-    if side == "bottom-left":
-        return (left, bottom)
-    if side == "bottom-right":
-        return (right, bottom)
-    return (cx, cy)
-
-
-def anchor_point(node: Node, toward: Point, port: Optional[str] = None) -> Point:
-    if port:
-        return anchor_on_side(node, port)
-    left, top, right, bottom = node.bounds
-    dx = toward[0] - node.cx
-    dy = toward[1] - node.cy
-    width = right - left
-    height = bottom - top
-    if abs(dx) * height >= abs(dy) * width:
-        return (right, node.cy) if dx >= 0 else (left, node.cy)
-    return (node.cx, bottom) if dy >= 0 else (node.cx, top)
-
-
-def expand_bounds(bounds: Bounds, padding: float) -> Bounds:
-    left, top, right, bottom = bounds
-    return (left - padding, top - padding, right + padding, bottom + padding)
-
-
-def segment_hits_bounds(p1: Point, p2: Point, bounds: Bounds) -> bool:
-    x1, y1 = p1
-    x2, y2 = p2
-    left, top, right, bottom = bounds
-    eps = 1e-6
-
-    if abs(y1 - y2) < eps:
-        y = y1
-        if not (top + eps < y < bottom - eps):
-            return False
-        seg_left = min(x1, x2)
-        seg_right = max(x1, x2)
-        overlap_left = max(seg_left, left)
-        overlap_right = min(seg_right, right)
-        if overlap_right - overlap_left <= eps:
-            return False
-        if abs(overlap_left - x1) < eps and abs(overlap_right - x1) < eps:
-            return False
-        if abs(overlap_left - x2) < eps and abs(overlap_right - x2) < eps:
-            return False
-        return True
-
-    if abs(x1 - x2) < eps:
-        x = x1
-        if not (left + eps < x < right - eps):
-            return False
-        seg_top = min(y1, y2)
-        seg_bottom = max(y1, y2)
-        overlap_top = max(seg_top, top)
-        overlap_bottom = min(seg_bottom, bottom)
-        if overlap_bottom - overlap_top <= eps:
-            return False
-        if abs(overlap_top - y1) < eps and abs(overlap_bottom - y1) < eps:
-            return False
-        if abs(overlap_top - y2) < eps and abs(overlap_bottom - y2) < eps:
-            return False
-        return True
-
-    return False
-
-
-def segment_axis(p1: Point, p2: Point) -> str:
-    if abs(p1[1] - p2[1]) < 1e-6:
-        return "horizontal"
-    if abs(p1[0] - p2[0]) < 1e-6:
-        return "vertical"
-    return "other"
-
-
-def port_axis(port: Optional[str]) -> Optional[str]:
-    if not port:
-        return None
-    port = port.lower()
-    if port in {"left", "right"}:
-        return "horizontal"
-    if port in {"top", "bottom"}:
-        return "vertical"
-    return None
-
-
-def offset_point(point: Point, port: Optional[str], distance: float) -> Point:
-    if not port:
-        return point
-    x, y = point
-    port = port.lower()
-    if port == "left":
-        return (x - distance, y)
-    if port == "right":
-        return (x + distance, y)
-    if port == "top":
-        return (x, y - distance)
-    if port == "bottom":
-        return (x, y + distance)
-    return point
-
-
-def route_length(points: Sequence[Point]) -> float:
-    return sum(abs(x1 - x2) + abs(y1 - y2) for (x1, y1), (x2, y2) in zip(points, points[1:]))
-
-
-def route_uses_lane(points: Sequence[Point], value: float, axis: str, tolerance: float = 1.0) -> bool:
-    if axis == "x":
-        return any(abs(x - value) <= tolerance for x, _ in points)
-    return any(abs(y - value) <= tolerance for _, y in points)
-
-
-def collision_count(points: Sequence[Point], obstacles: Sequence[Bounds]) -> int:
-    """Count how many (segment, obstacle) pairs collide."""
-    return sum(
-        1
-        for p1, p2 in zip(points, points[1:])
-        for obs in obstacles
-        if segment_hits_bounds(p1, p2, obs)
-    )
-
-
-def route_is_orthogonal(points: Sequence[Point]) -> bool:
-    return all(segment_axis(p1, p2) != "other" for p1, p2 in zip(points, points[1:]))
-
-
-def route_score(
-    points: Sequence[Point],
-    hint_x: Sequence[float],
-    hint_y: Sequence[float],
-    source_port: Optional[str],
-    target_port: Optional[str],
-) -> float:
-    length = route_length(points)
-    bends = max(0, len(points) - 2)
-    score = length + bends * 22
-    if len(points) >= 2 and source_port:
-        first_axis = segment_axis(points[0], points[1])
-        if first_axis != port_axis(source_port):
-            score += 180
-    if len(points) >= 2 and target_port:
-        last_axis = segment_axis(points[-2], points[-1])
-        if last_axis != port_axis(target_port):
-            score += 180
-    for lane in hint_x:
-        score -= 28 if route_uses_lane(points, lane, "x") else 0
-    for lane in hint_y:
-        score -= 28 if route_uses_lane(points, lane, "y") else 0
-    return score
-
-
-def simplify_points(points: Sequence[Point]) -> List[Point]:
-    simplified: List[Point] = []
-    for x, y in points:
-        pt = (round(x, 2), round(y, 2))
-        if simplified and pt == simplified[-1]:
-            continue
-        simplified.append(pt)
-
-    collapsed: List[Point] = []
-    for point in simplified:
-        if len(collapsed) < 2:
-            collapsed.append(point)
-            continue
-        x0, y0 = collapsed[-2]
-        x1, y1 = collapsed[-1]
-        x2, y2 = point
-        if (x0 == x1 == x2) or (y0 == y1 == y2):
-            collapsed[-1] = point
-        else:
-            collapsed.append(point)
-    return collapsed
-
-
-def route_collides(points: Sequence[Point], obstacles: Sequence[Bounds]) -> bool:
-    return collision_count(points, obstacles) > 0
-
-
-def build_orthogonal_route(
-    start: Point,
-    end: Point,
-    obstacles: Sequence[Bounds],
-    arrow_data: Dict[str, object],
-) -> List[Point]:
-    if arrow_data.get("route_points"):
-        raw_points = [tuple(point) for point in arrow_data["route_points"]]
-        return simplify_points([start] + [(float(x), float(y)) for x, y in raw_points] + [end])
-
-    sx, sy = start
-    ex, ey = end
-    routing_padding = to_float(arrow_data.get("routing_padding", 24))
-    port_clearance = to_float(arrow_data.get("port_clearance", max(18, routing_padding * 0.85)))
-    source_port = str(arrow_data.get("source_port", "")).strip().lower() or None
-    target_port = str(arrow_data.get("target_port", "")).strip().lower() or None
-    inner_start = offset_point(start, source_port, port_clearance)
-    inner_end = offset_point(end, target_port, port_clearance)
-    ssx, ssy = inner_start
-    eex, eey = inner_end
-    expanded = [expand_bounds(bounds, routing_padding) for bounds in obstacles]
-    hint_x = [to_float(value) for value in arrow_data.get("corridor_x", [])]
-    hint_y = [to_float(value) for value in arrow_data.get("corridor_y", [])]
-    lane_x = sorted({ssx, eex, round((ssx + eex) / 2, 2), *hint_x, *[b[0] for b in expanded], *[b[2] for b in expanded]})
-    lane_y = sorted({ssy, eey, round((ssy + eey) / 2, 2), *hint_y, *[b[1] for b in expanded], *[b[3] for b in expanded]})
-    if expanded:
-        left_rail = min(b[0] for b in expanded) - 24
-        right_rail = max(b[2] for b in expanded) + 24
-        top_rail = min(b[1] for b in expanded) - 24
-        bottom_rail = max(b[3] for b in expanded) + 24
-    else:
-        left_rail = min(ssx, eex) - 48
-        right_rail = max(ssx, eex) + 48
-        top_rail = min(ssy, eey) - 48
-        bottom_rail = max(ssy, eey) + 48
-
-    candidates = [
-        [start, inner_start, inner_end, end],
-        [start, inner_start, (eex, ssy), inner_end, end],
-        [start, inner_start, (ssx, eey), inner_end, end],
-        [start, inner_start, ((ssx + eex) / 2, ssy), ((ssx + eex) / 2, eey), inner_end, end],
-        [start, inner_start, (ssx, (ssy + eey) / 2), (eex, (ssy + eey) / 2), inner_end, end],
-        [start, inner_start, (left_rail, ssy), (left_rail, eey), inner_end, end],
-        [start, inner_start, (right_rail, ssy), (right_rail, eey), inner_end, end],
-        [start, inner_start, (ssx, top_rail), (eex, top_rail), inner_end, end],
-        [start, inner_start, (ssx, bottom_rail), (eex, bottom_rail), inner_end, end],
-    ]
-    for x in lane_x:
-        candidates.append([start, inner_start, (x, ssy), (x, eey), inner_end, end])
-    for y in lane_y:
-        candidates.append([start, inner_start, (ssx, y), (eex, y), inner_end, end])
-    for x in hint_x:
-        for y in hint_y:
-            candidates.append([start, inner_start, (x, ssy), (x, y), (eex, y), inner_end, end])
-
-    default_route = simplify_points([start, inner_start, (eex, ssy), inner_end, end])
-    default_coll = collision_count(default_route, expanded)
-    default_raw_coll = collision_count(default_route, obstacles)
-    default_length = route_length(default_route)
-    best_route: Optional[List[Point]] = None
-    best_score = float("inf")
-    best_fallback: Optional[List[Point]] = None
-    best_fb_coll = float("inf")
-    best_fb_score = float("inf")
-    for candidate in candidates:
-        simplified = simplify_points(candidate)
-        coll = collision_count(simplified, expanded)
-        score = route_score(simplified, hint_x, hint_y, source_port, target_port)
-        if coll == 0:
-            if score < best_score:
-                best_score = score
-                best_route = simplified
-        elif route_is_orthogonal(simplified):
-            length = route_length(simplified)
-            raw_coll = collision_count(simplified, obstacles)
-            if (
-                coll < default_coll
-                and raw_coll <= default_raw_coll
-                and length <= default_length
-                and (coll < best_fb_coll or (coll == best_fb_coll and score < best_fb_score))
-            ):
-                best_fb_coll = coll
-                best_fb_score = score
-                best_fallback = simplified
-
-    if best_route is not None:
-        return best_route
-    if best_fallback is not None:
-        return best_fallback
-    return default_route
-
-
-def choose_label_position(points: Sequence[Point]) -> Point:
-    segments = list(zip(points, points[1:]))
-    if not segments:
-        return points[0]
-    best = max(segments, key=lambda seg: abs(seg[0][0] - seg[1][0]) + abs(seg[0][1] - seg[1][1]))
-    return ((best[0][0] + best[1][0]) / 2, (best[0][1] + best[1][1]) / 2)
-
-
-def color_for_flow(style: Dict[str, object], arrow_data: Dict[str, object]) -> str:
-    if arrow_data.get("color"):
-        return str(arrow_data["color"])
-    flow = FLOW_ALIASES.get(str(arrow_data.get("flow", "control")).lower(), "control")
-    return str(style_value(style, "arrow_colors")[flow])
-
-
-def marker_for_color(style: Dict[str, object], color: str, arrow_data: Dict[str, object]) -> str:
-    if arrow_data.get("marker"):
-        return f"url(#{arrow_data['marker']})"
-    colors = style_value(style, "arrow_colors")
-    for name, token in colors.items():
-        if token == color:
-            return f"url(#{MARKER_IDS.get(name, 'arrowA')})"
-    return "url(#arrowA)"
-
-
-def render_label_badge(x: float, y: float, text: str, style: Dict[str, object]) -> str:
-    width = max(36, len(text) * 7 + 14)
-    bg = style_value(style, "arrow_label_bg")
-    opacity = style_value(style, "arrow_label_opacity")
-    return "\n".join(
-        [
-            f'  <rect x="{round(x - width / 2, 2)}" y="{round(y - 10, 2)}" width="{width}" height="20" rx="6" fill="{bg}" opacity="{opacity}"/>',
-            f'  <text x="{round(x, 2)}" y="{round(y + 4, 2)}" text-anchor="middle" class="arrow-label">{normalize_text(text)}</text>',
-        ]
-    )
-
-
-def rectangle_bounds(x: float, y: float, width: float, height: float) -> Bounds:
-    return (x, y, x + width, y + height)
-
-
-def bounds_intersect(a: Bounds, b: Bounds, padding: float = 0.0) -> bool:
-    ax1, ay1, ax2, ay2 = a
-    bx1, by1, bx2, by2 = b
-    return not (
-        ax2 + padding <= bx1
-        or bx2 + padding <= ax1
-        or ay2 + padding <= by1
-        or by2 + padding <= ay1
-    )
-
-
-def estimate_label_bounds(x: float, y: float, text: str) -> Bounds:
-    width = max(36, len(text) * 7 + 14)
-    return rectangle_bounds(x - width / 2, y - 10, width, 20)
-
-
-def section_header_text(container: Dict[str, object], style: Dict[str, object]) -> str:
-    if container.get("header_text"):
-        text = str(container.get("header_text", ""))
-    else:
-        label = str(container.get("label", ""))
-        prefix = str(container.get("header_prefix", "")).strip()
-        separator = str(container.get("header_separator", " // " if prefix else ""))
-        text = f"{prefix}{separator}{label}" if prefix else label
-    if style_value(style, "section_upper") and not container.get("preserve_case"):
-        text = text.upper()
-    return text
-
-
-def render_section(container: Dict[str, object], style: Dict[str, object]) -> str:
-    x = to_float(container["x"])
-    y = to_float(container["y"])
-    width = to_float(container["width"])
-    height = to_float(container["height"])
-    rx = to_float(container.get("rx", 16 if style_value(style, "name") != "Notion Clean" else 4))
-    fill = str(container.get("fill", style_value(style, "section_fill")))
-    stroke = str(container.get("stroke", style_value(style, "section_stroke")))
-    dash = str(container.get("stroke_dasharray", style_value(style, "section_dash")))
-    label = section_header_text(container, style)
-    subtitle = str(container.get("subtitle", ""))
-    side_label = str(container.get("side_label", "")).strip()
-    side_label_fill = str(container.get("side_label_fill", style_value(style, "text_secondary")))
-    side_label_size = to_float(container.get("side_label_size", 14))
-    side_label_weight = str(container.get("side_label_weight", "600"))
-    side_label_anchor = str(container.get("side_label_anchor", "end"))
-    lines = [f'  <rect x="{x}" y="{y}" width="{width}" height="{height}" rx="{rx}" fill="{fill}" stroke="{stroke}" stroke-width="1.4"']
-    if dash:
-        lines[-1] += f' stroke-dasharray="{dash}"'
-    lines[-1] += "/>"
-    if label:
-        lines.append(f'  <text x="{x + 18}" y="{y + 24}" class="section">{normalize_text(label)}</text>')
-    if subtitle:
-        lines.append(f'  <text x="{x + 18}" y="{y + 44}" class="section-sub">{normalize_text(subtitle)}</text>')
-    if side_label:
-        side_x = to_float(container.get("side_label_x", max(28, x - 18)))
-        side_y = to_float(container.get("side_label_y", y + height / 2))
-        lines.append(
-            f'  <text x="{side_x}" y="{side_y}" text-anchor="{side_label_anchor}" dominant-baseline="middle" '
-            f'font-size="{side_label_size}" font-weight="{side_label_weight}" fill="{side_label_fill}">{normalize_text(side_label)}</text>'
-        )
-    return "\n".join(lines)
-
-
-def container_header_bounds(container: Dict[str, object]) -> Optional[Bounds]:
-    label = str(container.get("header_text", "") or container.get("label", "")).strip()
-    subtitle = str(container.get("subtitle", "")).strip()
-    if not label and not subtitle:
-        return None
-    x = to_float(container["x"])
-    y = to_float(container["y"])
-    width = to_float(container["width"])
-    header_height = to_float(container.get("header_height", 54 if subtitle else 30))
-    return rectangle_bounds(x + 6, y + 6, width - 12, header_height)
-
-
-def label_position_candidates(points: Sequence[Point]) -> List[Point]:
-    segments = list(zip(points, points[1:]))
-    if not segments:
-        return [points[0]]
-    ranked_segments = sorted(
-        segments,
-        key=lambda seg: abs(seg[0][0] - seg[1][0]) + abs(seg[0][1] - seg[1][1]),
-        reverse=True,
-    )
-    candidates: List[Point] = []
-    for (x1, y1), (x2, y2) in ranked_segments:
-        length = abs(x1 - x2) + abs(y1 - y2)
-        if length < 34:
-            continue
-        mx = (x1 + x2) / 2
-        my = (y1 + y2) / 2
-        if abs(y1 - y2) < 1e-6:
-            candidates.extend([(mx, my - 16), (mx, my + 16), (mx, my - 28), (mx, my + 28), (mx, my)])
-        elif abs(x1 - x2) < 1e-6:
-            candidates.extend([(mx - 18, my), (mx + 18, my), (mx - 30, my), (mx + 30, my), (mx, my)])
-        else:
-            candidates.extend([(mx, my - 16), (mx, my + 16), (mx, my)])
-    return candidates or [choose_label_position(points)]
-
-
-def choose_label_position_avoiding(points: Sequence[Point], text: str, occupied: Sequence[Bounds]) -> Point:
-    for candidate in label_position_candidates(points):
-        label_box = estimate_label_bounds(candidate[0], candidate[1], text)
-        if not any(bounds_intersect(label_box, other, 4) for other in occupied):
-            return candidate
-    return choose_label_position(points)
-
-
-def legend_layout(data: Dict[str, object], legend: Sequence[Dict[str, object]], width: float, height: float) -> Optional[Tuple[float, float, Bounds]]:
-    if not legend:
-        return None
-    x = to_float(data.get("legend_x", 42))
-    y = to_float(data.get("legend_y", height - (len(legend) * 22 + 34)))
-    position = str(data.get("legend_position", "bottom-left"))
-    max_label = max((len(str(item.get("label", ""))) for item in legend), default=12)
-    block_width = 40 + max_label * 7 + 12
-    block_height = len(legend) * 22 + 6
-    if position == "bottom-right":
-        x = to_float(data.get("legend_x", width - block_width - 42))
-    elif position == "top-right":
-        x = to_float(data.get("legend_x", width - block_width - 42))
-        y = to_float(data.get("legend_y", 96))
-    elif position == "top-left":
-        x = to_float(data.get("legend_x", 42))
-        y = to_float(data.get("legend_y", 96))
-    return (x, y, rectangle_bounds(x - 4, y - 10, block_width + 8, block_height + 12))
-
-
-def footer_layout(data: Dict[str, object], width: float, height: float) -> Optional[Tuple[float, float, Bounds]]:
-    text = str(data.get("footer", "")).strip()
-    if not text:
-        return None
-    footer_width = max(140, len(text) * 7)
-    x = to_float(data.get("footer_x", 42))
-    y = to_float(data.get("footer_y", height - 16))
-    position = str(data.get("footer_position", "bottom-left"))
-    if position == "bottom-right":
-        x = to_float(data.get("footer_x", width - footer_width - 42))
-    return (x, y, rectangle_bounds(x, y - 12, footer_width, 16))
-
-
-def render_tags(node: Dict[str, object], x: float, y: float, style: Dict[str, object]) -> List[str]:
-    tags = node.get("tags", [])
-    if not tags:
-        return []
-    cursor_x = x
-    lines = []
-    for tag in tags:
-        label = normalize_text(tag.get("label", ""))
-        width = max(62, len(str(tag.get("label", ""))) * 8 + 18)
-        fill = tag.get("fill", "#eff6ff")
-        stroke = tag.get("stroke", "#bfdbfe")
-        text_fill = tag.get("text_fill", style_value(style, "arrow_colors")["read"])
-        lines.append(
-            f'  <rect x="{cursor_x}" y="{y}" width="{width}" height="16" rx="3" fill="{fill}" stroke="{stroke}" stroke-width="1"/>'
-        )
-        lines.append(
-            f'  <text x="{cursor_x + width / 2}" y="{y + 11.5}" text-anchor="middle" font-size="11" font-weight="500" fill="{text_fill}">{label}</text>'
-        )
-        cursor_x += width + 8
-    return lines
-
-
-def render_rect_node(node: Dict[str, object], style: Dict[str, object], kind: str) -> str:
-    x = to_float(node["x"])
-    y = to_float(node["y"])
-    width = to_float(node.get("width", 180))
-    height = to_float(node.get("height", 76))
-    rx = to_float(node.get("rx", style_value(style, "node_radius")))
-    fill = str(node.get("fill", style_value(style, "node_fill")))
-    stroke = str(node.get("stroke", style_value(style, "node_stroke")))
-    stroke_width = to_float(node.get("stroke_width", 2.0 if kind != "rect" else 1.8))
-    filter_attr = ""
-    node_shadow = node.get("filter")
-    if node_shadow:
-        filter_attr = f' filter="url(#{node_shadow})"'
-    elif node.get("glow"):
-        glow_name = str(node.get("glow"))
-        glow_map = {
-            "blue": "glowBlue",
-            "purple": "glowPurple",
-            "green": "glowGreen",
-            "orange": "glowOrange",
-        }
-        if glow_name in glow_map:
-            filter_attr = f' filter="url(#{glow_map[glow_name]})"'
-    elif style_value(style, "node_shadow"):
-        if not node.get("flat", False):
-            filter_attr = f' filter="{style_value(style, "node_shadow")}"'
-    title = normalize_text(node.get("label", ""))
-    subtitle = normalize_text(node.get("sublabel", ""))
-    type_label = normalize_text(node.get("type_label", ""))
-    accent_fill = node.get("accent_fill")
-    lines = []
-
-    if kind == "double_rect":
-        lines.append(
-            f'  <rect x="{x}" y="{y}" width="{width}" height="{height}" rx="{rx}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"{filter_attr}/>'
-        )
-        lines.append(
-            f'  <rect x="{x + 6}" y="{y + 6}" width="{width - 12}" height="{height - 12}" rx="{max(rx - 3, 4)}" fill="none" stroke="{stroke}" stroke-width="1.2" opacity="0.65"/>'
-        )
-    elif kind == "terminal":
-        lines.append(
-            f'  <rect x="{x}" y="{y}" width="{width}" height="{height}" rx="{rx}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"{filter_attr}/>'
-        )
-        lines.append(
-            f'  <rect x="{x}" y="{y}" width="{width}" height="18" rx="{rx}" fill="{node.get("header_fill", "#1f2937")}" opacity="0.95"/>'
-        )
-        header_colors = node.get("header_dots", ["#ef4444", "#f59e0b", "#10b981"])
-        for idx, color in enumerate(header_colors):
-            lines.append(f'  <circle cx="{x + 16 + idx * 14}" cy="{y + 9}" r="4" fill="{color}"/>')
-        lines.append(
-            f'  <text x="{x + 18}" y="{y + 44}" font-size="28" font-weight="700" fill="{node.get("prompt_fill", "#10b981")}">$</text>'
-        )
-        lines.append(
-            f'  <text x="{x + 38}" y="{y + 44}" font-size="22" font-weight="500" fill="{style_value(style, "text_secondary")}">_</text>'
-        )
-    elif kind == "document":
-        fold = min(18, width * 0.18, height * 0.22)
-        path = (
-            f"M {x} {y} L {x + width - fold} {y} L {x + width} {y + fold} "
-            f"L {x + width} {y + height} L {x} {y + height} Z"
-        )
-        lines.append(
-            f'  <path d="{path}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"{filter_attr}/>'
-        )
-        lines.append(
-            f'  <path d="M {x + width - fold} {y} L {x + width - fold} {y + fold} L {x + width} {y + fold}" fill="none" stroke="{stroke}" stroke-width="{stroke_width}"/>'
-        )
-        for idx in range(4):
-            line_y = y + 26 + idx * 14
-            lines.append(
-                f'  <line x1="{x + 18}" y1="{line_y}" x2="{x + width - 28}" y2="{line_y}" stroke="{node.get("line_stroke", "#c4b5fd")}" stroke-width="1.2"/>'
-            )
-    elif kind == "folder":
-        tab_w = min(54, width * 0.34)
-        tab_h = 18
-        path = (
-            f"M {x} {y + tab_h} L {x + tab_w * 0.4} {y + tab_h} L {x + tab_w * 0.58} {y} "
-            f"L {x + tab_w} {y} L {x + width} {y} L {x + width} {y + height} L {x} {y + height} Z"
-        )
-        lines.append(
-            f'  <path d="{path}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"{filter_attr}/>'
-        )
-        for idx in range(3):
-            line_y = y + 42 + idx * 14
-            lines.append(
-                f'  <line x1="{x + 22}" y1="{line_y}" x2="{x + width - 22}" y2="{line_y}" stroke="{node.get("line_stroke", stroke)}" stroke-opacity="0.35" stroke-width="1.2"/>'
-            )
-    elif kind == "hexagon":
-        inset = 22
-        path = (
-            f"M {x + inset} {y} L {x + width - inset} {y} L {x + width} {y + height / 2} "
-            f"L {x + width - inset} {y + height} L {x + inset} {y + height} L {x} {y + height / 2} Z"
-        )
-        lines.append(f'  <path d="{path}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"{filter_attr}/>')
-    elif kind == "speech":
-        tail = 18
-        path = (
-            f"M {x + rx} {y} L {x + width - rx} {y} Q {x + width} {y} {x + width} {y + rx} "
-            f"L {x + width} {y + height - rx} Q {x + width} {y + height} {x + width - rx} {y + height} "
-            f"L {x + 26} {y + height} L {x + 12} {y + height + tail} L {x + 16} {y + height} "
-            f"L {x + rx} {y + height} Q {x} {y + height} {x} {y + height - rx} "
-            f"L {x} {y + rx} Q {x} {y} {x + rx} {y} Z"
-        )
-        lines.append(f'  <path d="{path}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"{filter_attr}/>')
-    else:
-        lines.append(
-            f'  <rect x="{x}" y="{y}" width="{width}" height="{height}" rx="{rx}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"{filter_attr}/>'
-        )
-
-    if accent_fill and kind == "icon_box":
-        lines.append(
-            f'  <rect x="{x + 12}" y="{y + 12}" width="{width - 24}" height="{height - 24}" rx="{max(rx - 4, 4)}" fill="{accent_fill}" opacity="0.9"/>'
-        )
-
-    if kind == "user_avatar":
-        circle_fill = node.get("icon_fill", "#dbeafe")
-        icon_stroke = node.get("icon_stroke", stroke)
-        cx = x + 26
-        cy = y + height / 2
-        lines.append(f'  <circle cx="{cx}" cy="{cy}" r="18" fill="{circle_fill}" stroke="{icon_stroke}" stroke-width="1.6"/>')
-        lines.append(f'  <circle cx="{cx}" cy="{cy - 6}" r="5" fill="{icon_stroke}"/>')
-        lines.append(f'  <path d="M {cx - 10} {cy + 11} Q {cx} {cy + 2} {cx + 10} {cy + 11}" fill="none" stroke="{icon_stroke}" stroke-width="2"/>')
-
-    if kind == "bot":
-        cx = x + width / 2
-        cy = y + height / 2 + 2
-        body_fill = node.get("body_fill", "#1e293b")
-        accent = node.get("accent_fill", "#34d399")
-        lines.append(f'  <rect x="{cx - 42}" y="{cy - 32}" width="84" height="84" rx="18" fill="{body_fill}" stroke="#334155" stroke-width="1.8"{filter_attr}/>')
-        lines.append(f'  <rect x="{cx - 26}" y="{cy - 16}" width="52" height="22" rx="6" fill="#0f172a" stroke="#475569" stroke-width="1.2"/>')
-        lines.append(f'  <circle cx="{cx - 12}" cy="{cy - 5}" r="5" fill="{accent}"/>')
-        lines.append(f'  <circle cx="{cx + 12}" cy="{cy - 5}" r="5" fill="{accent}"/>')
-        lines.append(f'  <rect x="{cx - 14}" y="{cy + 14}" width="28" height="6" rx="3" fill="#334155"/>')
-        lines.append(f'  <line x1="{cx}" y1="{cy - 36}" x2="{cx}" y2="{cy - 50}" stroke="{accent}" stroke-width="3"/>')
-        lines.append(f'  <circle cx="{cx}" cy="{cy - 54}" r="5" fill="{accent}"/>')
-
-    if kind == "circle_cluster":
-        r = min(width, height) / 4.0
-        centers = [(x + width * 0.36, y + height * 0.56), (x + width * 0.58, y + height * 0.45), (x + width * 0.74, y + height * 0.58)]
-        for cx, cy in centers:
-            lines.append(f'  <circle cx="{cx}" cy="{cy}" r="{r}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"/>')
-
-    type_offset = y + 18 if kind not in {"terminal", "bot"} else y + 18
-    title_y = y + height / 2 - (4 if type_label and kind not in {"terminal", "bot"} else 0)
-    if kind in {"document", "folder"}:
-        title_y = y + height + 26
-    elif kind == "circle_cluster":
-        title_y = y + height / 2 + 8
-    elif kind == "bot":
-        title_y = y + height + 22
-    elif kind == "user_avatar":
-        title_y = y + height / 2 + 6
-
-    if type_label:
-        lines.append(f'  <text x="{x + (54 if kind == "user_avatar" else width / 2)}" y="{type_offset}" text-anchor="middle" class="node-type">{type_label}</text>')
-        title_y += 10 if kind not in {"document", "folder", "circle_cluster", "bot"} else 0
-
-    title_x = x + width / 2
-    text_anchor = "middle"
-    if kind == "user_avatar":
-        title_x = x + 64
-        text_anchor = "start"
-    if kind == "terminal":
-        title_y = y + height - 14
-    if kind == "bot":
-        title_x = x + width / 2
-        text_anchor = "middle"
-    lines.append(f'  <text x="{title_x}" y="{title_y}" text-anchor="{text_anchor}" class="node-title">{title}</text>')
-
-    if subtitle:
-        sub_y = title_y + 22
-        if kind == "document":
-            sub_y = y + height + 44
-            title_y = y + height + 24
-        if kind == "folder":
-            sub_y = y + height + 44
-        if kind == "circle_cluster":
-            sub_y = y + height / 2 + 28
-        if kind == "bot":
-            sub_y = y + height + 42
-        if kind == "terminal":
-            sub_y = y + height + 20
-        if kind == "user_avatar":
-            sub_y = title_y + 22
-        lines.append(f'  <text x="{title_x}" y="{sub_y}" text-anchor="{text_anchor}" class="node-sub">{subtitle}</text>')
-
-    tag_lines = []
-    if node.get("tags"):
-        tag_x = x + 18
-        tag_y = y + height - 20
-        if kind in {"document", "folder", "circle_cluster", "bot", "terminal"}:
-            tag_y = y + height + 52
-        tag_lines = render_tags(node, tag_x, tag_y, style)
-    lines.extend(tag_lines)
-
-    return "\n".join(lines)
-
-
-def render_node(node: Dict[str, object], style: Dict[str, object]) -> str:
-    kind = str(node.get("kind", node.get("shape", "rect")))
-    if kind == "cylinder":
-        x = to_float(node["x"])
-        y = to_float(node["y"])
-        width = to_float(node.get("width", 160))
-        height = to_float(node.get("height", 120))
-        rx = width / 2
-        ry = min(18, height / 8)
-        fill = str(node.get("fill", "#ecfdf5"))
-        stroke = str(node.get("stroke", "#10b981"))
-        stroke_width = to_float(node.get("stroke_width", 2.2))
-        label = normalize_text(node.get("label", ""))
-        subtitle = normalize_text(node.get("sublabel", ""))
-        lines = [
-            f'  <ellipse cx="{x + width / 2}" cy="{y + ry}" rx="{rx / 2}" ry="{ry}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"/>',
-            f'  <rect x="{x}" y="{y + ry}" width="{width}" height="{height - 2 * ry}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"/>',
-            f'  <ellipse cx="{x + width / 2}" cy="{y + height - ry}" rx="{rx / 2}" ry="{ry}" fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"/>',
-            f'  <ellipse cx="{x + width / 2}" cy="{y + height * 0.38}" rx="{rx / 2}" ry="{ry}" fill="none" stroke="{stroke}" stroke-opacity="0.45" stroke-width="1.2"/>',
-            f'  <ellipse cx="{x + width / 2}" cy="{y + height * 0.6}" rx="{rx / 2}" ry="{ry}" fill="none" stroke="{stroke}" stroke-opacity="0.25" stroke-width="1.2"/>',
-            f'  <text x="{x + width / 2}" y="{y + height / 2 - 6}" text-anchor="middle" class="node-title">{label}</text>',
-        ]
-        if subtitle:
-            lines.append(f'  <text x="{x + width / 2}" y="{y + height / 2 + 18}" text-anchor="middle" class="node-sub">{subtitle}</text>')
-        return "\n".join(lines)
-    return render_rect_node(node, style, kind)
-
-
-def render_arrow(
-    arrow: Dict[str, object],
-    style: Dict[str, object],
-    node_map: Dict[str, Node],
-    route_obstacles: Sequence[Bounds],
-    label_obstacles: Sequence[Bounds],
-) -> Tuple[str, str, Optional[Bounds]]:
-    start_hint = (to_float(arrow.get("x1")), to_float(arrow.get("y1")))
-    end_hint = (to_float(arrow.get("x2")), to_float(arrow.get("y2")))
-    source_node = node_map.get(str(arrow.get("source"))) if arrow.get("source") else None
-    target_node = node_map.get(str(arrow.get("target"))) if arrow.get("target") else None
-    source_port = arrow.get("source_port")
-    target_port = arrow.get("target_port")
-
-    if source_node is not None:
-        toward = end_hint if target_node is None else (target_node.cx, target_node.cy)
-        start = anchor_point(source_node, toward, str(source_port) if source_port else None)
-    else:
-        start = start_hint
-
-    if target_node is not None:
-        toward = start_hint if source_node is None else (source_node.cx, source_node.cy)
-        end = anchor_point(target_node, toward, str(target_port) if target_port else None)
-    else:
-        end = end_hint
-
-    obstacles = list(route_obstacles)
-    if source_node is not None:
-        obstacles = [bounds for bounds in obstacles if bounds != source_node.bounds]
-    if target_node is not None:
-        obstacles = [bounds for bounds in obstacles if bounds != target_node.bounds]
-
-    route = build_orthogonal_route(start, end, obstacles, arrow)
-    path_d = "M " + " L ".join(f"{round(x, 2)},{round(y, 2)}" for x, y in route)
-    color = color_for_flow(style, arrow)
-    width = to_float(arrow.get("stroke_width", style_value(style, "arrow_width")))
-    dash = arrow.get("stroke_dasharray")
-    if dash is None and arrow.get("dashed"):
-        dash = "6,4"
-    marker = marker_for_color(style, color, arrow)
-    path = f'  <path d="{path_d}" fill="none" stroke="{color}" stroke-width="{width}" marker-end="{marker}"'
-    if dash:
-        path += f' stroke-dasharray="{dash}"'
-    if arrow.get("opacity") is not None:
-        path += f' opacity="{arrow["opacity"]}"'
-    path += "/>"
-    label_svg = ""
-    label_bounds = None
-
-    label = str(arrow.get("label", "")).strip()
-    if label:
-        label_x, label_y = choose_label_position_avoiding(route, label, label_obstacles)
-        label_x += to_float(arrow.get("label_dx", 0))
-        label_y += to_float(arrow.get("label_dy", -4))
-        label_svg = render_label_badge(label_x, label_y, label, style)
-        label_bounds = estimate_label_bounds(label_x, label_y, label)
-    return path, label_svg, label_bounds
-
-
-def render_legend(
-    legend: Sequence[Dict[str, object]],
-    style: Dict[str, object],
-    width: float,
-    height: float,
-    data: Dict[str, object],
-) -> str:
-    layout = legend_layout(data, legend, width, height)
-    if not layout:
-        return ""
-    legend_x, legend_y, _ = layout
-    lines = []
-    for idx, item in enumerate(legend):
-        y = legend_y + idx * 22
-        color = item.get("color")
-        if not color:
-            color = style_value(style, "arrow_colors")[FLOW_ALIASES.get(str(item.get("flow", "control")).lower(), "control")]
-        marker = marker_for_color(style, str(color), {"flow": item.get("flow", "control")})
-        lines.append(f'  <line x1="{legend_x}" y1="{y}" x2="{legend_x + 30}" y2="{y}" stroke="{color}" stroke-width="{style_value(style, "arrow_width")}" marker-end="{marker}"/>')
-        lines.append(f'  <text x="{legend_x + 40}" y="{y + 4}" class="legend">{normalize_text(item.get("label", ""))}</text>')
-    if data.get("legend_box"):
-        max_label = max((len(str(item.get("label", ""))) for item in legend), default=12)
-        block_width = 40 + max_label * 7 + 12
-        block_height = len(legend) * 22 + 6
-        bg = data.get("legend_box_fill", style_value(style, "arrow_label_bg"))
-        opacity = data.get("legend_box_opacity", 0.88)
-        lines.insert(0, f'  <rect x="{legend_x - 10}" y="{legend_y - 14}" width="{block_width + 20}" height="{block_height + 18}" rx="10" fill="{bg}" opacity="{opacity}"/>')
-    return "\n".join(lines)
-
-
-def render_footer(data: Dict[str, object], style: Dict[str, object], width: float, height: float) -> str:
-    layout = footer_layout(data, width, height)
-    if not layout:
-        return ""
-    x, y, _ = layout
-    text = str(data.get("footer", "")).strip()
-    return f'  <text x="{x}" y="{y}" class="footnote">{normalize_text(text)}</text>'
-
-
-def build_svg(template_type: str, data: Dict[str, object]) -> str:
-    style_index, style = parse_style(data.get("style"))
-    if data.get("style_overrides"):
-        style.update(data["style_overrides"])
-    width, height = parse_template_viewbox(template_type)
-    width = to_float(data.get("width", width))
-    height = to_float(data.get("height", height))
-    if data.get("viewBox"):
-        match = re.match(r"0 0 ([0-9.]+) ([0-9.]+)", str(data["viewBox"]))
-        if match:
-            width = float(match.group(1))
-            height = float(match.group(2))
-
-    containers = data.get("containers", [])
-    nodes_data = data.get("nodes", [])
-    arrows_data = data.get("arrows", [])
-    legend = data.get("legend", [])
-
-    normalized_nodes = [normalize_node(node, f"node-{idx}") for idx, node in enumerate(nodes_data)]
-    node_map = {node.node_id: node for node in normalized_nodes}
-
-    defs = render_defs(style_index, style)
-    canvas = render_canvas(style_index, style, width, height)
-    title_block, content_start_y = render_title_block(style, data, width)
-    window_controls = render_window_controls(data, style_index, width)
-    header_meta = render_header_meta(data, style, width)
-
-    lines = [f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {int(width)} {int(height)}" width="{int(width)}" height="{int(height)}">']
-    lines.append(defs)
-    lines.append(canvas)
-    if window_controls:
-        lines.append(window_controls)
-    if header_meta:
-        lines.append(header_meta)
-    lines.append(title_block)
-
-    if containers:
-        for container in containers:
-            lines.append(render_section(container, style))
-
-    section_obstacles = [bounds for container in containers if (bounds := container_header_bounds(container)) is not None]
-    legend_reserved = legend_layout(data, legend, width, height)
-    footer_reserved = footer_layout(data, width, height)
-    blueprint_block_svg, blueprint_block_bounds = render_blueprint_title_block(data, style, style_index, width, height)
-    reserved_bounds = list(section_obstacles)
-    if legend_reserved:
-        reserved_bounds.append(legend_reserved[2])
-    if footer_reserved:
-        reserved_bounds.append(footer_reserved[2])
-    if blueprint_block_bounds:
-        reserved_bounds.append(blueprint_block_bounds)
-
-    arrow_paths: List[str] = []
-    arrow_labels: List[str] = []
-    node_obstacles = [node.bounds for node in normalized_nodes]
-    route_obstacles = node_obstacles + reserved_bounds
-    label_obstacles = node_obstacles + reserved_bounds
-    for arrow in arrows_data:
-        path_svg, label_svg, label_bounds = render_arrow(arrow, style, node_map, route_obstacles, label_obstacles)
-        arrow_paths.append(path_svg)
-        if label_svg:
-            arrow_labels.append(label_svg)
-        if label_bounds:
-            label_obstacles.append(label_bounds)
-
-    lines.extend(path for path in arrow_paths if path)
-
-    for node_data in nodes_data:
-        if "y" not in node_data and node_data.get("auto_place"):
-            node_data["y"] = content_start_y + to_float(node_data.get("offset_y", 0))
-        lines.append(render_node(node_data, style))
-
-    lines.extend(label for label in arrow_labels if label)
-
-    legend_svg = render_legend(legend, style, width, height, data)
-    if legend_svg:
-        lines.append(legend_svg)
-
-    if blueprint_block_svg:
-        lines.append(blueprint_block_svg)
-
-    footer_svg = render_footer(data, style, width, height)
-    if footer_svg:
-        lines.append(footer_svg)
-
-    lines.append("</svg>")
-    return "\n".join(line for line in lines if line)
-
-
-def main() -> None:
-    if len(sys.argv) < 3:
-        print("Usage: python3 generate-from-template.py <template-type> <output-path> [data-json]")
-        sys.exit(1)
-
-    template_type = sys.argv[1]
-    output_path = sys.argv[2]
-
-    try:
-        if len(sys.argv) > 3:
-            data = json.loads(sys.argv[3])
-        else:
-            data = json.load(sys.stdin)
-        svg_content = build_svg(template_type, data)
-        with open(output_path, "w", encoding="utf-8") as handle:
-            handle.write(svg_content)
-        print(f"✓ SVG generated: {output_path}")
-    except FileNotFoundError as exc:
-        print(f"Error: {exc}")
-        sys.exit(1)
-    except json.JSONDecodeError as exc:
-        print(f"Error: Invalid JSON: {exc}")
-        sys.exit(1)
-    except ValueError as exc:
-        print(f"Error: {exc}")
-        sys.exit(1)
-    except Exception as exc:  # pragma: no cover
-        print(f"Unexpected error: {exc}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()