@yalehwang/archguard 0.1.0

package/dist/plugins/golang/atlas/renderers/mermaid-templates.js

@@ -0,0 +1,688 @@
+import path from 'path';
+export class MermaidTemplates {
+    static SUBGRAPH_DEPTH_STYLES = [
+        'fill:#ffffff,stroke:#d0d7de,stroke-width:1px',
+        'fill:#f6f8fa,stroke:#d0d7de,stroke-width:1px',
+        'fill:#eaeef2,stroke:#8b949e,stroke-width:1px',
+        'fill:#d0d7de,stroke:#57606a,stroke-width:1px',
+    ];
+    static FLOWCHART_INIT = "%%{init: {'flowchart': {'nodeSpacing': 50, 'rankSpacing': 80, 'curve': 'basis'}}}%%\n";
+    static SEQUENCE_INIT = "%%{init: {'sequence': {'actorMargin': 50}}}%%\n";
+    static buildPackageTree(packages) {
+        const pkgSet = new Set(packages);
+        const prefixCount = new Map();
+        for (const pkg of packages) {
+            const segs = pkg.split('/');
+            for (let d = 1; d < segs.length; d++) {
+                const prefix = segs.slice(0, d).join('/');
+                prefixCount.set(prefix, (prefixCount.get(prefix) ?? 0) + 1);
+            }
+        }
+        const virtualGroups = new Set();
+        for (const [prefix, count] of prefixCount) {
+            if (count >= 2 && !pkgSet.has(prefix)) {
+                virtualGroups.add(prefix);
+            }
+        }
+        const allPrefixes = new Set([...packages, ...virtualGroups]);
+        const nodeMap = new Map();
+        for (const p of allPrefixes) {
+            nodeMap.set(p, { pkg: p, isVirtual: !pkgSet.has(p), children: [] });
+        }
+        const parentOf = (pkg) => {
+            const segs = pkg.split('/');
+            for (let d = segs.length - 1; d >= 1; d--) {
+                const prefix = segs.slice(0, d).join('/');
+                if (allPrefixes.has(prefix))
+                    return prefix;
+            }
+            return null;
+        };
+        const roots = [];
+        for (const p of allPrefixes) {
+            const parent = parentOf(p);
+            if (parent && nodeMap.has(parent)) {
+                nodeMap.get(parent).children.push(nodeMap.get(p));
+            }
+            else {
+                roots.push(nodeMap.get(p));
+            }
+        }
+        return roots;
+    }
+    static buildGroupTree(nodes) {
+        const prefixMembers = new Map();
+        for (const node of nodes) {
+            const segs = node.name.split('/');
+            for (let d = 1; d <= segs.length; d++) {
+                const prefix = segs.slice(0, d).join('/');
+                const arr = prefixMembers.get(prefix) ?? [];
+                arr.push(node.id);
+                prefixMembers.set(prefix, arr);
+            }
+        }
+        const validPrefixes = new Set();
+        for (const [prefix, ids] of prefixMembers) {
+            if (ids.length >= 2)
+                validPrefixes.add(prefix);
+        }
+        const deepestGroupFor = (name) => {
+            const segs = name.split('/');
+            for (let d = segs.length; d >= 1; d--) {
+                const prefix = segs.slice(0, d).join('/');
+                if (validPrefixes.has(prefix))
+                    return prefix;
+            }
+            return null;
+        };
+        const parentGroupFor = (prefix) => {
+            const segs = prefix.split('/');
+            for (let d = segs.length - 1; d >= 1; d--) {
+                const p = segs.slice(0, d).join('/');
+                if (validPrefixes.has(p))
+                    return p;
+            }
+            return null;
+        };
+        const nodeObjects = new Map();
+        for (const prefix of validPrefixes) {
+            nodeObjects.set(prefix, { prefix, children: [], nodeIds: [] });
+        }
+        const roots = [];
+        for (const prefix of validPrefixes) {
+            const parent = parentGroupFor(prefix);
+            if (parent && nodeObjects.has(parent)) {
+                nodeObjects.get(parent).children.push(nodeObjects.get(prefix));
+            }
+            else {
+                roots.push(nodeObjects.get(prefix));
+            }
+        }
+        const grouped = new Set();
+        for (const node of nodes) {
+            const group = deepestGroupFor(node.name);
+            if (group && nodeObjects.has(group)) {
+                nodeObjects.get(group).nodeIds.push(node.id);
+                grouped.add(node.id);
+            }
+        }
+        return { roots, grouped };
+    }
+    static renderGroupNodes(groups, nodeMap, cycleNodeIds, indent, inDegree, depthMap, depth) {
+        const currentDepth = depth ?? 0;
+        let out = '';
+        for (const group of groups) {
+            const sgId = 'grp_' + MermaidTemplates.sanitizeId(group.prefix);
+            if (depthMap)
+                depthMap.set(sgId, currentDepth);
+            out += `\n${indent}subgraph ${sgId}["${group.prefix}"]\n`;
+            out += MermaidTemplates.renderGroupNodes(group.children, nodeMap, cycleNodeIds, indent + '  ', inDegree, depthMap, currentDepth + 1);
+            const sortedIds = inDegree
+                ? [...group.nodeIds].sort((a, b) => {
+                    const diff = (inDegree.get(b) ?? 0) - (inDegree.get(a) ?? 0);
+                    return diff !== 0 ? diff : a.localeCompare(b);
+                })
+                : group.nodeIds;
+            for (const nodeId of sortedIds) {
+                const node = nodeMap.get(nodeId);
+                const style = cycleNodeIds.has(node.id) ? ':::cycle' : `:::${node.type}`;
+                out += `${indent}  ${MermaidTemplates.sanitizeId(node.id)}["${node.name}"]${style}\n`;
+            }
+            out += `${indent}end\n`;
+        }
+        return out;
+    }
+    static renderLegend(activeTypes) {
+        const LEGEND_LABELS = {
+            cmd: 'cmd (entry point)',
+            tests: 'tests',
+            examples: 'examples',
+            testutil: 'testutil',
+            internal: 'internal',
+            vendor: 'vendor',
+            external: 'external (module boundary)',
+            cycle: 'cycle (circular dep)',
+        };
+        let out = '  subgraph legend["Legend"]\n';
+        out += '    direction LR\n';
+        for (const type of Object.keys(LEGEND_LABELS)) {
+            if (activeTypes.has(type)) {
+                out += `    legend_${type}["${LEGEND_LABELS[type]}"]:::${type}\n`;
+            }
+        }
+        out += '    legend_edge["--> depends on (bolder = more imports)"]\n';
+        out += '  end\n';
+        out += '  style legend fill:#fff8c5,stroke:#d4a72c,stroke-dasharray:5 5,color:#633c01\n\n';
+        return out;
+    }
+    static renderPackageGraph(graph) {
+        let output = MermaidTemplates.FLOWCHART_INIT + 'flowchart TB\n';
+        const cycleNodeIds = new Set(graph.cycles.filter((c) => c.packages.length > 1).flatMap((c) => c.packages));
+        const activeTypes = new Set(graph.nodes.map((n) => n.type));
+        if (cycleNodeIds.size > 0)
+            activeTypes.add('cycle');
+        const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+        const { roots, grouped } = MermaidTemplates.buildGroupTree(graph.nodes);
+        const inDegree = new Map();
+        for (const node of graph.nodes)
+            inDegree.set(node.id, 0);
+        for (const edge of graph.edges) {
+            if (edge.from !== edge.to) {
+                inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+            }
+        }
+        const sortedNodes = [...graph.nodes].sort((a, b) => {
+            const diff = (inDegree.get(b.id) ?? 0) - (inDegree.get(a.id) ?? 0);
+            return diff !== 0 ? diff : a.id.localeCompare(b.id);
+        });
+        for (const node of sortedNodes) {
+            if (!grouped.has(node.id)) {
+                const style = cycleNodeIds.has(node.id) ? ':::cycle' : `:::${node.type}`;
+                output += `  ${MermaidTemplates.sanitizeId(node.id)}["${node.name}"]${style}\n`;
+            }
+        }
+        const subgraphDepthMap = new Map();
+        output += MermaidTemplates.renderGroupNodes(roots, nodeMap, cycleNodeIds, '  ', inDegree, subgraphDepthMap, 0);
+        output += MermaidTemplates.renderLegend(activeTypes);
+        for (const [sgId, sgDepth] of subgraphDepthMap) {
+            const styleStr = MermaidTemplates.SUBGRAPH_DEPTH_STYLES[Math.min(sgDepth, MermaidTemplates.SUBGRAPH_DEPTH_STYLES.length - 1)];
+            output += `  style ${sgId} ${styleStr}\n`;
+        }
+        output += '\n';
+        output += '  classDef cmd      fill:#ffebe9,stroke:#cf222e,color:#82071e\n';
+        output += '  classDef tests    fill:#f6f8fa,stroke:#d0d7de,color:#57606a\n';
+        output += '  classDef examples fill:#ddf4ff,stroke:#54aeff,color:#0550ae\n';
+        output += '  classDef testutil fill:#f6f8fa,stroke:#d0d7de,color:#57606a\n';
+        output += '  classDef internal fill:#dafbe1,stroke:#2da44e,color:#116329\n';
+        output += '  classDef vendor   fill:#fdf4ff,stroke:#d2a8ff,color:#6e40c9\n';
+        output += '  classDef external fill:#fff8c5,stroke:#d4a72c,color:#633c01\n';
+        output += '  classDef cycle    fill:#ffebe9,stroke:#cf222e,stroke-width:3px,color:#82071e,font-weight:bold\n';
+        const edgeThicknesses = [];
+        let edgeIndex = 0;
+        output += '\n';
+        for (const edge of graph.edges) {
+            const fromId = MermaidTemplates.sanitizeId(edge.from);
+            const toId = MermaidTemplates.sanitizeId(edge.to);
+            if (edge.from === edge.to) {
+                output += `  ${fromId} -.->|"⚠ self"| ${toId}\n`;
+                edgeIndex++;
+                continue;
+            }
+            const label = edge.strength > 1 ? `|"${edge.strength} refs"|` : '';
+            output += `  ${fromId} -->${label} ${toId}\n`;
+            edgeThicknesses.push({ index: edgeIndex, strength: edge.strength });
+            edgeIndex++;
+        }
+        if (edgeThicknesses.length > 0) {
+            const tiers = MermaidTemplates.computePackageEdgeTiers(edgeThicknesses.map((e) => e.strength));
+            if (tiers.size > 0) {
+                output += '\n';
+                for (const { index, strength } of edgeThicknesses) {
+                    const width = tiers.get(strength);
+                    if (width !== undefined) {
+                        output += `  linkStyle ${index} stroke-width:${width}px\n`;
+                    }
+                }
+            }
+        }
+        if (graph.cycles.length > 0) {
+            output += '\n  %% Cycles detected:\n';
+            for (const cycle of graph.cycles) {
+                output += `  %% ${cycle.severity}: ${cycle.packages.join(' → ')}\n`;
+            }
+        }
+        return output;
+    }
+    static renderCapabilityGraph(graph) {
+        if (graph.nodes.length === 0) {
+            return MermaidTemplates.FLOWCHART_INIT + 'flowchart LR';
+        }
+        let output = MermaidTemplates.FLOWCHART_INIT + 'flowchart LR\n';
+        const nodesByPkg = new Map();
+        for (const node of graph.nodes) {
+            if (!nodesByPkg.has(node.package))
+                nodesByPkg.set(node.package, []);
+            nodesByPkg.get(node.package).push(node);
+        }
+        const pkgList = Array.from(nodesByPkg.keys());
+        const pkgRoots = MermaidTemplates.buildPackageTree(pkgList);
+        let hasHotspot = false;
+        const capDepthMap = new Map();
+        const renderCapNode = (treeNode, indent, depth) => {
+            const sgId = 'grp_' + MermaidTemplates.sanitizeId(treeNode.pkg);
+            capDepthMap.set(sgId, depth);
+            output += `${indent}subgraph ${sgId}["${treeNode.pkg}"]\n`;
+            for (const child of treeNode.children) {
+                renderCapNode(child, indent + '  ', depth + 1);
+            }
+            if (!treeNode.isVirtual) {
+                for (const node of nodesByPkg.get(treeNode.pkg) ?? []) {
+                    const mId = MermaidTemplates.sanitizeId(node.id);
+                    const label = MermaidTemplates.formatCapabilityLabel(node);
+                    const isHot = MermaidTemplates.isHotspot(node);
+                    if (isHot)
+                        hasHotspot = true;
+                    const classSuffix = isHot
+                        ? ':::hotspot'
+                        : node.type === 'interface'
+                            ? ':::interface'
+                            : ':::concrete';
+                    if (node.type === 'interface') {
+                        output += `${indent}  ${mId}{{"${label}"}}${classSuffix}\n`;
+                    }
+                    else {
+                        output += `${indent}  ${mId}["${label}"]${classSuffix}\n`;
+                    }
+                }
+            }
+            output += `${indent}end\n`;
+        };
+        for (const root of pkgRoots) {
+            renderCapNode(root, '', 0);
+        }
+        for (const [sgId, sgDepth] of capDepthMap) {
+            const styleStr = MermaidTemplates.SUBGRAPH_DEPTH_STYLES[Math.min(sgDepth, MermaidTemplates.SUBGRAPH_DEPTH_STYLES.length - 1)];
+            output += `  style ${sgId} ${styleStr}\n`;
+        }
+        const hasConcreteEdge = graph.edges.some((e) => e.concreteUsage === true);
+        output += '  subgraph legend["Legend"]\n';
+        output += '    direction LR\n';
+        output += '    legend_interface{{"interface"}}:::interface\n';
+        output += '    legend_concrete["concrete"]:::concrete\n';
+        if (hasHotspot) {
+            output += '    legend_hotspot["hotspot (≥11m or fi>5)"]:::hotspot\n';
+        }
+        output += '    legend_impl["-.-> implements"]\n';
+        output += '    legend_uses["--> uses"]\n';
+        if (hasConcreteEdge) {
+            output += '    legend_conc["==> concrete usage"]\n';
+        }
+        output += '  end\n';
+        output += '  style legend fill:#fff8c5,stroke:#d4a72c,stroke-dasharray:5 5,color:#633c01\n';
+        output += '  classDef interface fill:#ddf4ff,stroke:#54aeff,color:#0550ae\n';
+        output += '  classDef concrete fill:#dafbe1,stroke:#2da44e,color:#116329\n';
+        if (hasHotspot) {
+            output += '  classDef hotspot fill:#ffebe9,stroke:#cf222e,stroke-width:2px,color:#82071e\n';
+        }
+        for (const edge of graph.edges) {
+            const src = MermaidTemplates.sanitizeId(edge.source);
+            const tgt = MermaidTemplates.sanitizeId(edge.target);
+            if (edge.type === 'implements') {
+                output += `  ${src} -.->|impl| ${tgt}\n`;
+            }
+            else if (edge.concreteUsage === true) {
+                output += `  ${src} ==>|conc| ${tgt}\n`;
+            }
+            else {
+                output += `  ${src} -->|uses| ${tgt}\n`;
+            }
+        }
+        return output;
+    }
+    static formatCapabilityLabel(node) {
+        const sizeParts = [];
+        if ((node.fieldCount ?? 0) > 0)
+            sizeParts.push(`${node.fieldCount}f`);
+        if ((node.methodCount ?? 0) > 0)
+            sizeParts.push(`${node.methodCount}m`);
+        const couplingParts = [];
+        if ((node.fanIn ?? 0) > 0)
+            couplingParts.push(`fi:${node.fanIn}`);
+        if ((node.fanOut ?? 0) > 0)
+            couplingParts.push(`fo:${node.fanOut}`);
+        if (sizeParts.length === 0 && couplingParts.length === 0) {
+            return node.name;
+        }
+        const sections = [];
+        if (sizeParts.length > 0)
+            sections.push(sizeParts.join(' '));
+        if (couplingParts.length > 0)
+            sections.push(couplingParts.join(' '));
+        return `${node.name} [${sections.join(' | ')}]`;
+    }
+    static isHotspot(node) {
+        return (node.methodCount ?? 0) > 10 || (node.fanIn ?? 0) > 5;
+    }
+    static computePackageEdgeTiers(strengths) {
+        if (strengths.length === 0)
+            return new Map();
+        const sorted = [...strengths].sort((a, b) => a - b);
+        const min = sorted[0];
+        const max = sorted[sorted.length - 1];
+        if (max === min)
+            return new Map();
+        const n = sorted.length;
+        let thMedium = sorted[Math.min(Math.floor(n * 0.5), n - 1)];
+        let thHeavy = sorted[Math.min(Math.floor(n * 0.85), n - 1)];
+        if (thMedium >= max) {
+            thMedium = min;
+            thHeavy = max;
+        }
+        const result = new Map();
+        for (const s of new Set(strengths)) {
+            if (s >= thHeavy) {
+                result.set(s, 5.0);
+            }
+            else if (s > thMedium) {
+                result.set(s, 3.0);
+            }
+        }
+        return result;
+    }
+    static renderGoroutineTopology(topology) {
+        let output = MermaidTemplates.FLOWCHART_INIT + 'flowchart TB\n';
+        const packageGroups = new Map();
+        const ungrouped = [];
+        const declaredIds = new Set();
+        const addDecl = (pkg, decl) => {
+            if (pkg) {
+                if (!packageGroups.has(pkg))
+                    packageGroups.set(pkg, []);
+                packageGroups.get(pkg).push(decl);
+            }
+            else {
+                ungrouped.push(decl);
+            }
+            declaredIds.add(decl.rawId);
+        };
+        const nodeIdToPackage = new Map();
+        for (const node of topology.nodes) {
+            if (node.package)
+                nodeIdToPackage.set(node.id, node.package);
+        }
+        for (const node of topology.nodes) {
+            const patternLabel = node.pattern ? ` (${node.pattern})` : '';
+            const displayName = MermaidTemplates.formatGoroutineName(node);
+            const lifecycleTag = node.type === 'spawned'
+                ? MermaidTemplates.getLifecycleTag(node.id, topology.lifecycle)
+                : '';
+            const label = `${displayName}${patternLabel}${lifecycleTag}`;
+            const style = node.type === 'main'
+                ? ':::main'
+                : label.includes('\u26a0 no exit')
+                    ? ':::spawned_noexit'
+                    : ':::spawned';
+            addDecl(node.package || undefined, {
+                rawId: node.id,
+                label,
+                style,
+            });
+        }
+        for (const edge of topology.edges) {
+            if (!declaredIds.has(edge.from)) {
+                const label = MermaidTemplates.formatSpawnerLabel(edge.from);
+                const pkg = nodeIdToPackage.get(edge.to);
+                addDecl(pkg, { rawId: edge.from, label, style: ':::spawner' });
+            }
+        }
+        for (const edge of topology.channelEdges) {
+            if (!edge.from.startsWith('chan-') && !declaredIds.has(edge.from)) {
+                const label = MermaidTemplates.formatSpawnerLabel(edge.from);
+                const pkg = nodeIdToPackage.get(edge.to);
+                addDecl(pkg, { rawId: edge.from, label, style: ':::spawner' });
+            }
+        }
+        const pkgList = Array.from(packageGroups.keys());
+        const pkgRoots = MermaidTemplates.buildPackageTree(pkgList);
+        const goroutineDepthMap = new Map();
+        const renderGoroutineNode = (treeNode, indent, depth) => {
+            const sgId = 'grp_' + MermaidTemplates.sanitizeId(treeNode.pkg);
+            goroutineDepthMap.set(sgId, depth);
+            output += `\n${indent}subgraph ${sgId}["${treeNode.pkg}"]\n`;
+            for (const child of treeNode.children) {
+                renderGoroutineNode(child, indent + '  ', depth + 1);
+            }
+            if (!treeNode.isVirtual) {
+                for (const decl of packageGroups.get(treeNode.pkg) ?? []) {
+                    output += `${indent}  ${this.sanitizeId(decl.rawId)}["${decl.label}"]${decl.style}\n`;
+                }
+            }
+            output += `${indent}end\n`;
+        };
+        for (const root of pkgRoots) {
+            renderGoroutineNode(root, '  ', 0);
+        }
+        for (const decl of ungrouped) {
+            output += `  ${this.sanitizeId(decl.rawId)}["${decl.label}"]${decl.style}\n`;
+        }
+        output += '\n';
+        for (const [sgId, sgDepth] of goroutineDepthMap) {
+            const styleStr = MermaidTemplates.SUBGRAPH_DEPTH_STYLES[Math.min(sgDepth, MermaidTemplates.SUBGRAPH_DEPTH_STYLES.length - 1)];
+            output += `  style ${sgId} ${styleStr}\n`;
+        }
+        for (const edge of topology.edges) {
+            output += `  ${this.sanitizeId(edge.from)} -->|go| ${this.sanitizeId(edge.to)}\n`;
+        }
+        if (topology.channels.length > 0) {
+            output += '\n  subgraph channels\n';
+            for (const ch of topology.channels) {
+                const label = ch.type !== 'chan' ? ch.type : MermaidTemplates.formatChannelLabel(ch.id);
+                output += `    ${this.sanitizeId(ch.id)}[("${label}")]:::channel\n`;
+            }
+            output += '  end\n';
+            output += '  style channels fill:#ffffff,stroke:#d0d7de,stroke-width:1px\n';
+        }
+        for (const edge of topology.channelEdges) {
+            output += `  ${this.sanitizeId(edge.from)} -->|${edge.edgeType}| ${this.sanitizeId(edge.to)}\n`;
+        }
+        const hasNormalSpawned = [...packageGroups.values()].flat().concat(ungrouped)
+            .some((d) => d.style === ':::spawned');
+        output += '\n  subgraph legend["Legend"]\n';
+        output += '    direction LR\n';
+        output += '    legend_main["main"]:::main\n';
+        output += '    legend_spawner["spawner"]:::spawner\n';
+        if (hasNormalSpawned) {
+            output += '    legend_spawned["spawned \u2713"]:::spawned\n';
+        }
+        output += '    legend_spawned_noexit["spawned \u26a0 no exit"]:::spawned_noexit\n';
+        output += '    legend_channel["channel"]:::channel\n';
+        output += '    legend_go["--> go (goroutine launch)"]\n';
+        if (topology.channels.length > 0) {
+            output += '    legend_make["--> make/send/recv"]\n';
+        }
+        output += '  end\n';
+        output += '  style legend fill:#fff8c5,stroke:#d4a72c,stroke-dasharray:5 5,color:#633c01\n';
+        output += '\n  classDef main fill:#ffebe9,stroke:#cf222e,stroke-width:2px,color:#82071e\n';
+        output += '  classDef spawned fill:#dafbe1,stroke:#2da44e,color:#116329\n';
+        output += '  classDef spawner fill:#ddf4ff,stroke:#54aeff,color:#0550ae\n';
+        output += '  classDef spawned_noexit fill:#fff3cd,stroke:#d4a72c,stroke-width:2px,color:#633c01\n';
+        output += '  classDef channel fill:#fff8c5,stroke:#d4a72c,color:#633c01\n';
+        return output;
+    }
+    static renderFlowGraph(graph, format = 'flowchart') {
+        if (format === 'sequence') {
+            let output = MermaidTemplates.SEQUENCE_INIT + 'sequenceDiagram\n';
+            for (const chain of graph.callChains) {
+                const entry = graph.entryPoints.find((e) => e.id === chain.entryPoint);
+                if (!entry)
+                    continue;
+                const handlerId = this.sanitizeId(entry.handler);
+                if (handlerId) {
+                    const entryLabel = MermaidTemplates.formatEntryLabel(entry);
+                    output += `\n  Note over ${handlerId}: ${entryLabel}\n`;
+                }
+                for (const call of chain.calls) {
+                    const fromId = this.sanitizeId(call.from);
+                    const toId = this.sanitizeId(call.to);
+                    if (!fromId || !toId)
+                        continue;
+                    output += `  ${fromId}->>+${toId}: call\n`;
+                    output += `  ${toId}-->>-${fromId}: return\n`;
+                }
+            }
+            return output;
+        }
+        let output = MermaidTemplates.FLOWCHART_INIT + 'flowchart LR\n';
+        const pkgGroups = new Map();
+        for (const entry of graph.entryPoints) {
+            const pkg = entry.package ?? path.dirname(entry.location.file);
+            if (!pkgGroups.has(pkg))
+                pkgGroups.set(pkg, []);
+            pkgGroups.get(pkg).push(entry);
+        }
+        const pkgPaths = Array.from(pkgGroups.keys());
+        const pkgTree = MermaidTemplates.buildPackageTree(pkgPaths);
+        const flowDepthMap = new Map();
+        const renderEntryPkg = (node, indent, depth) => {
+            const sgId = 'grp_' + MermaidTemplates.sanitizeId(node.pkg);
+            flowDepthMap.set(sgId, depth);
+            output += `${indent}subgraph ${sgId}["${node.pkg}"]\n`;
+            for (const child of node.children) {
+                renderEntryPkg(child, indent + '  ', depth + 1);
+            }
+            if (!node.isVirtual) {
+                for (const entry of pkgGroups.get(node.pkg) ?? []) {
+                    const nodeId = MermaidTemplates.sanitizeId(entry.id);
+                    const label = MermaidTemplates.formatEntryLabel(entry);
+                    output += `${indent}  ${nodeId}["${label}"]:::entry\n`;
+                }
+            }
+            output += `${indent}end\n`;
+        };
+        for (const root of pkgTree) {
+            renderEntryPkg(root, '  ', 0);
+        }
+        for (const [sgId, sgDepth] of flowDepthMap) {
+            const styleStr = MermaidTemplates.SUBGRAPH_DEPTH_STYLES[Math.min(sgDepth, MermaidTemplates.SUBGRAPH_DEPTH_STYLES.length - 1)];
+            output += `  style ${sgId} ${styleStr}\n`;
+        }
+        const handlerNodeIds = new Set(graph.entryPoints.map((e) => this.sanitizeId(e.handler)));
+        const declaredNodeIds = new Set(graph.entryPoints.map((e) => this.sanitizeId(e.id)));
+        let hasIfaceEdge = false;
+        let hasIndirEdge = false;
+        const emittedEdges = new Set();
+        const addEdge = (from, to, label, callEdge) => {
+            const key = `${from}\x00${to}`;
+            if (emittedEdges.has(key))
+                return;
+            emittedEdges.add(key);
+            if (callEdge) {
+                if (callEdge.type === 'interface') {
+                    hasIfaceEdge = true;
+                    output += `  ${from} -.->|iface| ${to}\n`;
+                }
+                else if (callEdge.type === 'indirect') {
+                    hasIndirEdge = true;
+                    output += `  ${from} -.->|indir| ${to}\n`;
+                }
+                else {
+                    output += `  ${from} --> ${to}\n`;
+                }
+            }
+            else if (label) {
+                output += `  ${from} -->|${label}| ${to}\n`;
+            }
+            else {
+                output += `  ${from} --> ${to}\n`;
+            }
+        };
+        const declareNode = (id, originalName) => {
+            if (declaredNodeIds.has(id))
+                return;
+            declaredNodeIds.add(id);
+            const classSuffix = handlerNodeIds.has(id) ? ':::handler' : ':::util';
+            output += `  ${id}["${originalName}"]${classSuffix}\n`;
+        };
+        for (const chain of graph.callChains) {
+            const entry = graph.entryPoints.find((e) => e.id === chain.entryPoint);
+            if (!entry || chain.calls.length === 0)
+                continue;
+            const entryNodeId = this.sanitizeId(entry.id);
+            const handlerNodeId = this.sanitizeId(entry.handler);
+            declareNode(handlerNodeId, entry.handler);
+            const entryLabel = `"${chain.calls.length} calls"`;
+            addEdge(entryNodeId, handlerNodeId, entryLabel);
+            for (const call of chain.calls) {
+                const fromId = this.sanitizeId(call.from);
+                const toId = this.sanitizeId(call.to);
+                if (!fromId || !toId)
+                    continue;
+                declareNode(fromId, call.from);
+                declareNode(toId, call.to);
+                addEdge(fromId, toId, undefined, call);
+            }
+        }
+        output += '\n  subgraph legend["Legend"]\n';
+        output += '    direction LR\n';
+        output += '    legend_entry["entry point"]:::entry\n';
+        output += '    legend_handler["handler"]:::handler\n';
+        output += '    legend_util["utility"]:::util\n';
+        output += '    legend_edge_calls["\u2192|N calls| entry \u2192 handler"]\n';
+        output += '    legend_edge_direct["\u2192 direct call"]\n';
+        if (hasIfaceEdge) {
+            output += '    legend_edge_iface["-\u00b7\u2192|iface| interface dispatch"]\n';
+        }
+        if (hasIndirEdge) {
+            output += '    legend_edge_indir["-\u00b7\u2192|indir| indirect call"]\n';
+        }
+        output += '  end\n';
+        output += '  style legend fill:#fff8c5,stroke:#d4a72c,stroke-dasharray:5 5,color:#633c01\n';
+        output += '\n  classDef entry fill:#ffebe9,stroke:#cf222e,color:#82071e\n';
+        output += '  classDef handler fill:#ddf4ff,stroke:#54aeff,color:#0550ae\n';
+        output += '  classDef util fill:#f6f8fa,stroke:#d0d7de,color:#57606a\n';
+        return output;
+    }
+    static formatEntryLabel(entry) {
+        if (entry.protocol === 'http') {
+            const m = entry.method ?? 'HTTP';
+            return `${m} ${entry.path}`;
+        }
+        if (entry.protocol === 'grpc')
+            return `gRPC ${entry.path}`;
+        if (entry.protocol === 'cli')
+            return `CMD ${entry.path || entry.handler}`;
+        if (entry.protocol === 'message')
+            return `MSG ${entry.path}`;
+        if (entry.protocol === 'scheduler')
+            return `CRON ${entry.path}`;
+        return entry.path || entry.id;
+    }
+    static formatSpawnerLabel(nodeId) {
+        const slashIdx = nodeId.lastIndexOf('/');
+        const afterSlash = slashIdx >= 0 ? nodeId.slice(slashIdx + 1) : nodeId;
+        const parts = afterSlash.split('.');
+        return parts.length > 2 ? parts.slice(-2).join('.') : afterSlash;
+    }
+    static formatChannelLabel(channelId) {
+        const withoutPrefix = channelId.startsWith('chan-') ? channelId.slice(5) : channelId;
+        const withoutSuffix = withoutPrefix.replace(/-\d+$/, '');
+        const slashIdx = withoutSuffix.lastIndexOf('/');
+        return slashIdx >= 0 ? withoutSuffix.slice(slashIdx + 1) : withoutSuffix;
+    }
+    static formatGoroutineName(node) {
+        if (node.name) {
+            const slashIdx = node.name.lastIndexOf('/');
+            const afterSlash = slashIdx >= 0 ? node.name.slice(slashIdx + 1) : node.name;
+            const dotIdx = afterSlash.indexOf('.');
+            if (dotIdx > 0 && afterSlash.slice(0, dotIdx).includes('-')) {
+                const symbol = afterSlash.slice(dotIdx + 1);
+                if (symbol.length > 0 &&
+                    symbol[0] === symbol[0].toUpperCase() &&
+                    symbol[0] !== symbol[0].toLowerCase()) {
+                    return symbol;
+                }
+            }
+            return afterSlash;
+        }
+        const stripped = node.id.replace(/\.spawn-\d+$/, '');
+        const afterSlash = stripped.slice(stripped.lastIndexOf('/') + 1);
+        const parts = afterSlash.split('.');
+        return parts.slice(-2).join('.');
+    }
+    static getLifecycleTag(nodeId, lifecycle) {
+        const entry = lifecycle?.find((l) => l.nodeId === nodeId);
+        if (!entry)
+            return '';
+        if (entry.receivesContext && entry.hasCancellationCheck)
+            return ' \u2713ctx';
+        if (entry.receivesContext && !entry.cancellationCheckAvailable)
+            return ' ctx?';
+        if (entry.orphan)
+            return ' \u26a0 no exit';
+        return '';
+    }
+    static sanitizeId(id) {
+        return id.replace(/[^a-zA-Z0-9_]/g, '_');
+    }
+}
+//# sourceMappingURL=mermaid-templates.js.map