@diagrammo/dgmo 0.5.2 → 0.5.4

package/dist/index.cjs

@@ -6883,7 +6883,10 @@ var init_types2 = __esm({
       "buffer",
       "drain-rate",
       "retention-hours",
-      "partitions"
+      "partitions",
+      "slo-availability",
+      "slo-p90-latency-ms",
+      "slo-warning-margin"
     ]);
     EDGE_ONLY_KEYS = /* @__PURE__ */ new Set(["rps"]);
   }
@@ -7019,6 +7022,18 @@ function parseInfra(content) {
         result.options["default-uptime"] = trimmed.replace(/^default-uptime\s*:\s*/i, "").trim();
         continue;
       }
+      if (/^slo-availability\s*:/i.test(trimmed)) {
+        result.options["slo-availability"] = trimmed.replace(/^slo-availability\s*:\s*/i, "").trim();
+        continue;
+      }
+      if (/^slo-p90-latency-ms\s*:/i.test(trimmed)) {
+        result.options["slo-p90-latency-ms"] = trimmed.replace(/^slo-p90-latency-ms\s*:\s*/i, "").trim();
+        continue;
+      }
+      if (/^slo-warning-margin\s*:/i.test(trimmed)) {
+        result.options["slo-warning-margin"] = trimmed.replace(/^slo-warning-margin\s*:\s*/i, "").trim();
+        continue;
+      }
       if (/^scenario\s*:/i.test(trimmed)) {
         finishCurrentNode();
         finishCurrentTagGroup();
@@ -7163,12 +7178,19 @@ function parseInfra(content) {
       if (simpleConn) {
         const targetName = simpleConn[1].trim();
         const splitStr = simpleConn[2];
+        const fanoutStr = simpleConn[3];
         const split = splitStr ? parseFloat(splitStr) : null;
+        const fanoutRaw = fanoutStr ? parseInt(fanoutStr, 10) : null;
+        if (fanoutRaw !== null && fanoutRaw < 1) {
+          warn(lineNumber, `Fan-out multiplier must be at least 1 (got x${fanoutRaw}). Ignoring.`);
+        }
+        const fanout = fanoutRaw !== null && fanoutRaw >= 1 ? fanoutRaw : null;
         result.edges.push({
           sourceId: currentNode.id,
           targetId: nodeId2(targetName),
           label: "",
           split,
+          fanout,
           lineNumber
         });
         continue;
@@ -7178,7 +7200,13 @@ function parseInfra(content) {
         const label = connMatch[1]?.trim() || "";
         const targetName = connMatch[2].trim();
         const splitStr = connMatch[3];
+        const fanoutStr = connMatch[4];
         const split = splitStr ? parseFloat(splitStr) : null;
+        const fanoutRaw = fanoutStr ? parseInt(fanoutStr, 10) : null;
+        if (fanoutRaw !== null && fanoutRaw < 1) {
+          warn(lineNumber, `Fan-out multiplier must be at least 1 (got x${fanoutRaw}). Ignoring.`);
+        }
+        const fanout = fanoutRaw !== null && fanoutRaw >= 1 ? fanoutRaw : null;
         let targetId;
         const targetGroupMatch = targetName.match(GROUP_RE);
         if (targetGroupMatch) {
@@ -7191,14 +7219,20 @@ function parseInfra(content) {
           targetId,
           label,
           split,
+          fanout,
           lineNumber
         });
         continue;
       }
+      if (/^description\s*:\s*$/i.test(trimmed)) continue;
       const propMatch = trimmed.match(PROPERTY_RE);
       if (propMatch) {
         const key = propMatch[1].toLowerCase();
         const rawVal = propMatch[2].trim();
+        if (key === "description" && currentNode) {
+          if (!currentNode.isEdge) currentNode.description = rawVal;
+          continue;
+        }
         if (!INFRA_BEHAVIOR_KEYS.has(key) && !EDGE_ONLY_KEYS.has(key)) {
           const allKeys = [...INFRA_BEHAVIOR_KEYS, ...EDGE_ONLY_KEYS];
           let msg = `Unknown property '${key}'.`;
@@ -7300,12 +7334,12 @@ var init_parser9 = __esm({
     init_diagnostics();
     init_parsing();
     init_types2();
-    CONNECTION_RE = /^-(?:([^-].*?))?->\s+(.+?)(?:(?:\s*\|\s*|\s+)split\s*:?\s*(\d+)%)?\s*$/;
-    SIMPLE_CONNECTION_RE = /^->\s+(.+?)(?:(?:\s*\|\s*|\s+)split\s*:?\s*(\d+)%)?\s*$/;
+    CONNECTION_RE = /^-(?:([^-].*?))?->\s+(.+?)(?:(?:\s*\|\s*|\s+)split\s*:?\s*(\d+)%)?\s*(?:x(\d+))?\s*$/;
+    SIMPLE_CONNECTION_RE = /^->\s+(.+?)(?:(?:\s*\|\s*|\s+)split\s*:?\s*(\d+)%)?\s*(?:x(\d+))?\s*$/;
     GROUP_RE = /^\[([^\]]+)\]$/;
     TAG_GROUP_RE = /^tag\s*:\s*(\w[\w\s]*?)(?:\s+alias\s+(\w+))?\s*$/;
     TAG_VALUE_RE = /^(\w[\w\s]*?)(?:\(([^)]+)\))?(\s+default)?\s*$/;
-    COMPONENT_RE = /^([a-zA-Z_][\w]*)(.*)$/;
+    COMPONENT_RE = /^([a-zA-Z_][\w-]*)(.*)$/;
     PIPE_META_RE = /[|,]\s*(\w+)\s*:\s*([^|,]+)/g;
     PROPERTY_RE = /^([\w-]+)\s*:\s*(.+)$/;
     PERCENT_RE = /^([\d.]+)%$/;
@@ -7539,7 +7573,7 @@ function centerHeavyChildren(node) {
   }
   node.children = result;
 }
-function computeLegendGroups(tagGroups, _showEyeIcons, usedValuesByGroup) {
+function computeLegendGroups(tagGroups, showEyeIcons, usedValuesByGroup) {
   const groups = [];
   for (const group of tagGroups) {
     if (group.entries.length === 0) continue;
@@ -7552,7 +7586,8 @@ function computeLegendGroups(tagGroups, _showEyeIcons, usedValuesByGroup) {
     for (const entry of visibleEntries) {
       entriesWidth += LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + entry.value.length * LEGEND_ENTRY_FONT_W + LEGEND_ENTRY_TRAIL;
     }
-    const capsuleWidth = LEGEND_CAPSULE_PAD * 2 + pillWidth + 4 + entriesWidth;
+    const eyeSpace = showEyeIcons ? LEGEND_EYE_SIZE + LEGEND_EYE_GAP : 0;
+    const capsuleWidth = LEGEND_CAPSULE_PAD * 2 + pillWidth + 4 + eyeSpace + entriesWidth;
     groups.push({
       name: group.name,
       alias: group.alias,
@@ -8185,7 +8220,7 @@ function layoutOrg(parsed, hiddenCounts, activeTagGroup, hiddenAttributes, expan
     height: finalHeight
   };
 }
-var import_d3_hierarchy, CHAR_WIDTH, META_LINE_HEIGHT, HEADER_HEIGHT, SEPARATOR_GAP, CARD_H_PAD, CARD_V_PAD, MIN_CARD_WIDTH, H_GAP, V_GAP, MARGIN, CONTAINER_PAD_X, CONTAINER_PAD_BOTTOM, CONTAINER_LABEL_HEIGHT, CONTAINER_META_LINE_HEIGHT, STACK_V_GAP, LEGEND_GAP, LEGEND_HEIGHT, LEGEND_PILL_PAD, LEGEND_PILL_FONT_W, LEGEND_CAPSULE_PAD, LEGEND_DOT_R, LEGEND_ENTRY_FONT_W, LEGEND_ENTRY_DOT_GAP, LEGEND_ENTRY_TRAIL, LEGEND_GROUP_GAP;
+var import_d3_hierarchy, CHAR_WIDTH, META_LINE_HEIGHT, HEADER_HEIGHT, SEPARATOR_GAP, CARD_H_PAD, CARD_V_PAD, MIN_CARD_WIDTH, H_GAP, V_GAP, MARGIN, CONTAINER_PAD_X, CONTAINER_PAD_BOTTOM, CONTAINER_LABEL_HEIGHT, CONTAINER_META_LINE_HEIGHT, STACK_V_GAP, LEGEND_GAP, LEGEND_HEIGHT, LEGEND_PILL_PAD, LEGEND_PILL_FONT_W, LEGEND_CAPSULE_PAD, LEGEND_DOT_R, LEGEND_ENTRY_FONT_W, LEGEND_ENTRY_DOT_GAP, LEGEND_ENTRY_TRAIL, LEGEND_GROUP_GAP, LEGEND_EYE_SIZE, LEGEND_EYE_GAP;
 var init_layout = __esm({
   "src/org/layout.ts"() {
     "use strict";
@@ -8216,6 +8251,8 @@ var init_layout = __esm({
     LEGEND_ENTRY_DOT_GAP = 4;
     LEGEND_ENTRY_TRAIL = 8;
     LEGEND_GROUP_GAP = 12;
+    LEGEND_EYE_SIZE = 14;
+    LEGEND_EYE_GAP = 6;
   }
 });
 
@@ -8317,22 +8354,27 @@ function renderOrg(container, parsed, layout, palette, isDark, onClickItem, expo
   const layoutLegendShift = LEGEND_HEIGHT2 + LEGEND_GROUP_GAP2;
   const fixedLegend = !exportDims && hasLegend && !legendOnly;
   const legendReserve = fixedLegend ? LEGEND_HEIGHT2 + LEGEND_FIXED_GAP : 0;
+  const fixedTitle = !exportDims && !!parsed.title;
+  const titleReserve = fixedTitle ? TITLE_HEIGHT : 0;
   const diagramW = layout.width;
-  let diagramH = layout.height + titleOffset;
+  let diagramH = layout.height + (fixedTitle ? 0 : titleOffset);
   if (fixedLegend) {
     diagramH -= layoutLegendShift;
   }
-  const availH = height - DIAGRAM_PADDING * 2 - legendReserve;
+  const availH = height - DIAGRAM_PADDING * 2 - legendReserve - titleReserve;
   const scaleX = (width - DIAGRAM_PADDING * 2) / diagramW;
   const scaleY = availH / diagramH;
   const scale = Math.min(MAX_SCALE, scaleX, scaleY);
   const scaledW = diagramW * scale;
   const offsetX = (width - scaledW) / 2;
-  const offsetY = legendPosition === "top" && fixedLegend ? DIAGRAM_PADDING + legendReserve : DIAGRAM_PADDING;
+  const offsetY = legendPosition === "top" && fixedLegend ? DIAGRAM_PADDING + legendReserve + titleReserve : DIAGRAM_PADDING + titleReserve;
   const svg = d3Selection.select(container).append("svg").attr("width", width).attr("height", height).style("font-family", FONT_FAMILY);
   const mainG = svg.append("g").attr("transform", `translate(${offsetX}, ${offsetY}) scale(${scale})`);
   if (parsed.title) {
-    const titleEl = mainG.append("text").attr("x", diagramW / 2).attr("y", TITLE_FONT_SIZE).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-size", TITLE_FONT_SIZE).attr("font-weight", "bold").attr("class", "org-title chart-title").style(
+    const titleParent = fixedTitle ? svg : mainG;
+    const titleX = fixedTitle ? width / 2 : diagramW / 2;
+    const titleY = fixedTitle ? DIAGRAM_PADDING + TITLE_FONT_SIZE : TITLE_FONT_SIZE;
+    const titleEl = titleParent.append("text").attr("x", titleX).attr("y", titleY).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-size", TITLE_FONT_SIZE).attr("font-weight", "bold").attr("class", "org-title chart-title").style(
       "cursor",
       onClickItem && parsed.titleLineNumber ? "pointer" : "default"
     ).text(parsed.title);
@@ -8347,7 +8389,7 @@ function renderOrg(container, parsed, layout, palette, isDark, onClickItem, expo
       }
     }
   }
-  const contentG = mainG.append("g").attr("transform", `translate(0, ${titleOffset})`);
+  const contentG = mainG.append("g").attr("transform", `translate(0, ${fixedTitle ? 0 : titleOffset})`);
   const displayNames = /* @__PURE__ */ new Map();
   for (const group of parsed.tagGroups) {
     displayNames.set(group.name.toLowerCase(), group.name);
@@ -8475,7 +8517,7 @@ function renderOrg(container, parsed, layout, palette, isDark, onClickItem, expo
     }
     const legendParent = fixedLegend ? svg.append("g").attr("class", "org-legend-fixed").attr(
       "transform",
-      legendPosition === "bottom" ? `translate(0, ${height - DIAGRAM_PADDING - LEGEND_HEIGHT2})` : `translate(0, ${DIAGRAM_PADDING})`
+      legendPosition === "bottom" ? `translate(0, ${height - DIAGRAM_PADDING - LEGEND_HEIGHT2})` : `translate(0, ${DIAGRAM_PADDING + titleReserve})`
     ) : contentG;
     for (const group of visibleGroups) {
       const isActive = legendOnly || activeTagGroup != null && group.name.toLowerCase() === activeTagGroup.toLowerCase();
@@ -8496,8 +8538,19 @@ function renderOrg(container, parsed, layout, palette, isDark, onClickItem, expo
         gEl.append("rect").attr("x", pillXOff).attr("y", pillYOff).attr("width", pillWidth).attr("height", pillH).attr("rx", pillH / 2).attr("fill", "none").attr("stroke", mix(palette.textMuted, palette.bg, 50)).attr("stroke-width", 0.75);
       }
       gEl.append("text").attr("x", pillXOff + pillWidth / 2).attr("y", LEGEND_HEIGHT2 / 2 + LEGEND_PILL_FONT_SIZE / 2 - 2).attr("font-size", LEGEND_PILL_FONT_SIZE).attr("font-weight", "500").attr("fill", isActive ? palette.text : palette.textMuted).attr("text-anchor", "middle").text(pillLabel);
+      if (isActive && fixedLegend) {
+        const groupKey = group.name.toLowerCase();
+        const isHidden = hiddenAttributes?.has(groupKey) ?? false;
+        const eyeX = pillXOff + pillWidth + LEGEND_EYE_GAP2;
+        const eyeY = (LEGEND_HEIGHT2 - LEGEND_EYE_SIZE2) / 2;
+        const hitPad = 6;
+        const eyeG = gEl.append("g").attr("class", "org-legend-eye").attr("data-legend-visibility", groupKey).style("cursor", "pointer").attr("opacity", isHidden ? 0.4 : 0.7);
+        eyeG.append("rect").attr("x", eyeX - hitPad).attr("y", eyeY - hitPad).attr("width", LEGEND_EYE_SIZE2 + hitPad * 2).attr("height", LEGEND_EYE_SIZE2 + hitPad * 2).attr("fill", "transparent").attr("pointer-events", "all");
+        eyeG.append("path").attr("d", isHidden ? EYE_CLOSED_PATH : EYE_OPEN_PATH).attr("transform", `translate(${eyeX}, ${eyeY})`).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 1.2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+      }
       if (isActive) {
-        let entryX = pillXOff + pillWidth + 4;
+        const eyeShift = fixedLegend ? LEGEND_EYE_SIZE2 + LEGEND_EYE_GAP2 : 0;
+        let entryX = pillXOff + pillWidth + 4 + eyeShift;
         for (const entry of group.entries) {
           const entryG = gEl.append("g").attr("data-legend-entry", entry.value.toLowerCase()).style("cursor", "pointer");
           entryG.append("circle").attr("cx", entryX + LEGEND_DOT_R2).attr("cy", LEGEND_HEIGHT2 / 2).attr("r", LEGEND_DOT_R2).attr("fill", entry.color);
@@ -8543,7 +8596,7 @@ function renderOrgForExport(content, theme, palette) {
     document.body.removeChild(container);
   }
 }
-var d3Selection, DIAGRAM_PADDING, MAX_SCALE, TITLE_HEIGHT, TITLE_FONT_SIZE, LABEL_FONT_SIZE, META_FONT_SIZE, META_LINE_HEIGHT2, HEADER_HEIGHT2, SEPARATOR_GAP2, EDGE_STROKE_WIDTH, NODE_STROKE_WIDTH, CARD_RADIUS, CONTAINER_RADIUS, CONTAINER_LABEL_FONT_SIZE, CONTAINER_META_FONT_SIZE, CONTAINER_META_LINE_HEIGHT2, CONTAINER_HEADER_HEIGHT, COLLAPSE_BAR_HEIGHT, COLLAPSE_BAR_INSET, LEGEND_HEIGHT2, LEGEND_PILL_PAD2, LEGEND_PILL_FONT_SIZE, LEGEND_PILL_FONT_W2, LEGEND_CAPSULE_PAD2, LEGEND_DOT_R2, LEGEND_ENTRY_FONT_SIZE, LEGEND_ENTRY_FONT_W2, LEGEND_ENTRY_DOT_GAP2, LEGEND_ENTRY_TRAIL2, LEGEND_GROUP_GAP2, LEGEND_FIXED_GAP;
+var d3Selection, DIAGRAM_PADDING, MAX_SCALE, TITLE_HEIGHT, TITLE_FONT_SIZE, LABEL_FONT_SIZE, META_FONT_SIZE, META_LINE_HEIGHT2, HEADER_HEIGHT2, SEPARATOR_GAP2, EDGE_STROKE_WIDTH, NODE_STROKE_WIDTH, CARD_RADIUS, CONTAINER_RADIUS, CONTAINER_LABEL_FONT_SIZE, CONTAINER_META_FONT_SIZE, CONTAINER_META_LINE_HEIGHT2, CONTAINER_HEADER_HEIGHT, COLLAPSE_BAR_HEIGHT, COLLAPSE_BAR_INSET, LEGEND_HEIGHT2, LEGEND_PILL_PAD2, LEGEND_PILL_FONT_SIZE, LEGEND_PILL_FONT_W2, LEGEND_CAPSULE_PAD2, LEGEND_DOT_R2, LEGEND_ENTRY_FONT_SIZE, LEGEND_ENTRY_FONT_W2, LEGEND_ENTRY_DOT_GAP2, LEGEND_ENTRY_TRAIL2, LEGEND_GROUP_GAP2, LEGEND_EYE_SIZE2, LEGEND_EYE_GAP2, LEGEND_FIXED_GAP, EYE_OPEN_PATH, EYE_CLOSED_PATH;
 var init_renderer = __esm({
   "src/org/renderer.ts"() {
     "use strict";
@@ -8582,7 +8635,11 @@ var init_renderer = __esm({
     LEGEND_ENTRY_DOT_GAP2 = 4;
     LEGEND_ENTRY_TRAIL2 = 8;
     LEGEND_GROUP_GAP2 = 12;
+    LEGEND_EYE_SIZE2 = 14;
+    LEGEND_EYE_GAP2 = 6;
     LEGEND_FIXED_GAP = 8;
+    EYE_OPEN_PATH = "M1 7s2.5-5 6-5 6 5 6 5-2.5 5-6 5-6-5-6-5z M7 9.5a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5z";
+    EYE_CLOSED_PATH = "M2.5 2.5l9 9 M1.5 7s2.2-4 5.5-4c1.2 0 2.2.5 3 1.1 M12.5 7s-2.2 4-5.5 4c-1.2 0-2.2-.5-3-1.1";
   }
 });
 
@@ -8631,7 +8688,7 @@ function computeLegendGroups2(tagGroups, usedValuesByGroup) {
     for (const entry of visibleEntries) {
       entriesWidth += LEGEND_DOT_R3 * 2 + LEGEND_ENTRY_DOT_GAP3 + entry.value.length * LEGEND_ENTRY_FONT_W3 + LEGEND_ENTRY_TRAIL3;
     }
-    const eyeSpace = LEGEND_EYE_SIZE + LEGEND_EYE_GAP;
+    const eyeSpace = LEGEND_EYE_SIZE3 + LEGEND_EYE_GAP3;
     const capsuleWidth = LEGEND_CAPSULE_PAD3 * 2 + pillWidth + 4 + eyeSpace + entriesWidth;
     groups.push({
       name: group.name,
@@ -9033,7 +9090,7 @@ function layoutSitemap(parsed, hiddenCounts, activeTagGroup, hiddenAttributes, e
     height: totalHeight
   };
 }
-var import_dagre, CHAR_WIDTH2, META_LINE_HEIGHT3, HEADER_HEIGHT3, SEPARATOR_GAP3, CARD_H_PAD2, CARD_V_PAD2, MIN_CARD_WIDTH2, MARGIN2, CONTAINER_PAD_X2, CONTAINER_PAD_TOP, CONTAINER_PAD_BOTTOM2, CONTAINER_LABEL_HEIGHT2, CONTAINER_META_LINE_HEIGHT3, LEGEND_HEIGHT3, LEGEND_PILL_PAD3, LEGEND_PILL_FONT_W3, LEGEND_CAPSULE_PAD3, LEGEND_DOT_R3, LEGEND_ENTRY_FONT_W3, LEGEND_ENTRY_DOT_GAP3, LEGEND_ENTRY_TRAIL3, LEGEND_GROUP_GAP3, LEGEND_EYE_SIZE, LEGEND_EYE_GAP, OVERLAP_GAP;
+var import_dagre, CHAR_WIDTH2, META_LINE_HEIGHT3, HEADER_HEIGHT3, SEPARATOR_GAP3, CARD_H_PAD2, CARD_V_PAD2, MIN_CARD_WIDTH2, MARGIN2, CONTAINER_PAD_X2, CONTAINER_PAD_TOP, CONTAINER_PAD_BOTTOM2, CONTAINER_LABEL_HEIGHT2, CONTAINER_META_LINE_HEIGHT3, LEGEND_HEIGHT3, LEGEND_PILL_PAD3, LEGEND_PILL_FONT_W3, LEGEND_CAPSULE_PAD3, LEGEND_DOT_R3, LEGEND_ENTRY_FONT_W3, LEGEND_ENTRY_DOT_GAP3, LEGEND_ENTRY_TRAIL3, LEGEND_GROUP_GAP3, LEGEND_EYE_SIZE3, LEGEND_EYE_GAP3, OVERLAP_GAP;
 var init_layout2 = __esm({
   "src/sitemap/layout.ts"() {
     "use strict";
@@ -9061,8 +9118,8 @@ var init_layout2 = __esm({
     LEGEND_ENTRY_DOT_GAP3 = 4;
     LEGEND_ENTRY_TRAIL3 = 8;
     LEGEND_GROUP_GAP3 = 12;
-    LEGEND_EYE_SIZE = 14;
-    LEGEND_EYE_GAP = 6;
+    LEGEND_EYE_SIZE3 = 14;
+    LEGEND_EYE_GAP3 = 6;
     OVERLAP_GAP = 20;
   }
 });
@@ -9414,15 +9471,15 @@ function renderLegend(parent, legendGroups, palette, isDark, activeTagGroup, fix
     if (isActive && fixedWidth != null) {
       const groupKey = group.name.toLowerCase();
       const isHidden = hiddenAttributes?.has(groupKey) ?? false;
-      const eyeX = pillXOff + pillW + LEGEND_EYE_GAP2;
-      const eyeY = (LEGEND_HEIGHT4 - LEGEND_EYE_SIZE2) / 2;
+      const eyeX = pillXOff + pillW + LEGEND_EYE_GAP4;
+      const eyeY = (LEGEND_HEIGHT4 - LEGEND_EYE_SIZE4) / 2;
       const hitPad = 6;
       const eyeG = legendG.append("g").attr("class", "sitemap-legend-eye").attr("data-legend-visibility", groupKey).style("cursor", "pointer").attr("opacity", isHidden ? 0.4 : 0.7);
-      eyeG.append("rect").attr("x", eyeX - hitPad).attr("y", eyeY - hitPad).attr("width", LEGEND_EYE_SIZE2 + hitPad * 2).attr("height", LEGEND_EYE_SIZE2 + hitPad * 2).attr("fill", "transparent").attr("pointer-events", "all");
-      eyeG.append("path").attr("d", isHidden ? EYE_CLOSED_PATH : EYE_OPEN_PATH).attr("transform", `translate(${eyeX}, ${eyeY})`).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 1.2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+      eyeG.append("rect").attr("x", eyeX - hitPad).attr("y", eyeY - hitPad).attr("width", LEGEND_EYE_SIZE4 + hitPad * 2).attr("height", LEGEND_EYE_SIZE4 + hitPad * 2).attr("fill", "transparent").attr("pointer-events", "all");
+      eyeG.append("path").attr("d", isHidden ? EYE_CLOSED_PATH2 : EYE_OPEN_PATH2).attr("transform", `translate(${eyeX}, ${eyeY})`).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 1.2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
     }
     if (isActive) {
-      const eyeShift = fixedWidth != null ? LEGEND_EYE_SIZE2 + LEGEND_EYE_GAP2 : 0;
+      const eyeShift = fixedWidth != null ? LEGEND_EYE_SIZE4 + LEGEND_EYE_GAP4 : 0;
       let entryX = pillXOff + pillW + 4 + eyeShift;
       for (const entry of group.entries) {
         const entryG = legendG.append("g").attr("data-legend-entry", entry.value.toLowerCase()).style("cursor", "pointer");
@@ -9475,7 +9532,7 @@ async function renderSitemapForExport(content, theme, palette) {
   const brandColor = theme === "transparent" ? "#888" : effectivePalette.textMuted;
   return injectBranding2(svgHtml, brandColor);
 }
-var d3Selection2, d3Shape, DIAGRAM_PADDING2, MAX_SCALE2, TITLE_HEIGHT2, TITLE_FONT_SIZE2, LABEL_FONT_SIZE2, META_FONT_SIZE2, META_LINE_HEIGHT4, HEADER_HEIGHT4, SEPARATOR_GAP4, EDGE_STROKE_WIDTH2, NODE_STROKE_WIDTH2, CARD_RADIUS2, CONTAINER_RADIUS2, CONTAINER_LABEL_FONT_SIZE2, CONTAINER_META_FONT_SIZE2, CONTAINER_META_LINE_HEIGHT4, CONTAINER_HEADER_HEIGHT2, ARROWHEAD_W, ARROWHEAD_H, EDGE_LABEL_FONT_SIZE, COLLAPSE_BAR_HEIGHT2, LEGEND_HEIGHT4, LEGEND_FIXED_GAP2, LEGEND_PILL_PAD4, LEGEND_PILL_FONT_SIZE2, LEGEND_PILL_FONT_W4, LEGEND_CAPSULE_PAD4, LEGEND_DOT_R4, LEGEND_ENTRY_FONT_SIZE2, LEGEND_ENTRY_FONT_W4, LEGEND_ENTRY_DOT_GAP4, LEGEND_ENTRY_TRAIL4, LEGEND_GROUP_GAP4, LEGEND_EYE_SIZE2, LEGEND_EYE_GAP2, lineGenerator, EYE_OPEN_PATH, EYE_CLOSED_PATH;
+var d3Selection2, d3Shape, DIAGRAM_PADDING2, MAX_SCALE2, TITLE_HEIGHT2, TITLE_FONT_SIZE2, LABEL_FONT_SIZE2, META_FONT_SIZE2, META_LINE_HEIGHT4, HEADER_HEIGHT4, SEPARATOR_GAP4, EDGE_STROKE_WIDTH2, NODE_STROKE_WIDTH2, CARD_RADIUS2, CONTAINER_RADIUS2, CONTAINER_LABEL_FONT_SIZE2, CONTAINER_META_FONT_SIZE2, CONTAINER_META_LINE_HEIGHT4, CONTAINER_HEADER_HEIGHT2, ARROWHEAD_W, ARROWHEAD_H, EDGE_LABEL_FONT_SIZE, COLLAPSE_BAR_HEIGHT2, LEGEND_HEIGHT4, LEGEND_FIXED_GAP2, LEGEND_PILL_PAD4, LEGEND_PILL_FONT_SIZE2, LEGEND_PILL_FONT_W4, LEGEND_CAPSULE_PAD4, LEGEND_DOT_R4, LEGEND_ENTRY_FONT_SIZE2, LEGEND_ENTRY_FONT_W4, LEGEND_ENTRY_DOT_GAP4, LEGEND_ENTRY_TRAIL4, LEGEND_GROUP_GAP4, LEGEND_EYE_SIZE4, LEGEND_EYE_GAP4, lineGenerator, EYE_OPEN_PATH2, EYE_CLOSED_PATH2;
 var init_renderer2 = __esm({
   "src/sitemap/renderer.ts"() {
     "use strict";
@@ -9516,11 +9573,11 @@ var init_renderer2 = __esm({
     LEGEND_ENTRY_DOT_GAP4 = 4;
     LEGEND_ENTRY_TRAIL4 = 8;
     LEGEND_GROUP_GAP4 = 12;
-    LEGEND_EYE_SIZE2 = 14;
-    LEGEND_EYE_GAP2 = 6;
+    LEGEND_EYE_SIZE4 = 14;
+    LEGEND_EYE_GAP4 = 6;
     lineGenerator = d3Shape.line().x((d) => d.x).y((d) => d.y).curve(d3Shape.curveBasis);
-    EYE_OPEN_PATH = "M1 7s2.5-5 6-5 6 5 6 5-2.5 5-6 5-6-5-6-5z M7 9.5a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5z";
-    EYE_CLOSED_PATH = "M2.5 2.5l9 9 M1.5 7s2.2-4 5.5-4c1.2 0 2.2.5 3 1.1 M12.5 7s-2.2 4-5.5 4c-1.2 0-2.2-.5-3-1.1";
+    EYE_OPEN_PATH2 = "M1 7s2.5-5 6-5 6 5 6 5-2.5 5-6 5-6-5-6-5z M7 9.5a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5z";
+    EYE_CLOSED_PATH2 = "M2.5 2.5l9 9 M1.5 7s2.2-4 5.5-4c1.2 0 2.2.5 3 1.1 M12.5 7s-2.2 4-5.5 4c-1.2 0-2.2-.5-3-1.1";
   }
 });
 
@@ -10756,7 +10813,8 @@ var init_renderer5 = __esm({
 // src/initiative-status/layout.ts
 var layout_exports5 = {};
 __export(layout_exports5, {
-  layoutInitiativeStatus: () => layoutInitiativeStatus
+  layoutInitiativeStatus: () => layoutInitiativeStatus,
+  rollUpStatus: () => rollUpStatus
 });
 function rollUpStatus(members) {
   let worst = null;
@@ -10770,14 +10828,28 @@ function rollUpStatus(members) {
   }
   return worst;
 }
-function layoutInitiativeStatus(parsed) {
-  if (parsed.nodes.length === 0) {
+function layoutInitiativeStatus(parsed, collapseResult) {
+  if (parsed.nodes.length === 0 && (!collapseResult || collapseResult.collapsedGroupStatuses.size === 0)) {
     return { nodes: [], edges: [], groups: [], width: 0, height: 0 };
   }
-  const hasGroups = parsed.groups.length > 0;
+  const originalGroups = collapseResult?.originalGroups ?? parsed.groups;
+  const collapsedGroupStatuses = collapseResult?.collapsedGroupStatuses ?? /* @__PURE__ */ new Map();
+  const collapsedGroupLabels = new Set(
+    originalGroups.map((g2) => g2.label).filter((l) => !parsed.groups.some((g2) => g2.label === l))
+  );
+  const hasGroups = parsed.groups.length > 0 || collapsedGroupLabels.size > 0;
   const g = new import_dagre4.default.graphlib.Graph({ multigraph: true, compound: hasGroups });
   g.setGraph({ rankdir: "LR", nodesep: NODESEP, ranksep: RANKSEP });
   g.setDefaultEdgeLabel(() => ({}));
+  for (const group of originalGroups) {
+    if (collapsedGroupLabels.has(group.label)) {
+      const collapsedW = Math.max(
+        NODE_WIDTH,
+        Math.ceil(group.label.length * CHAR_WIDTH_RATIO * NODE_FONT_SIZE) + NODE_TEXT_PADDING * 2
+      );
+      g.setNode(group.label, { label: group.label, width: collapsedW, height: NODE_HEIGHT });
+    }
+  }
   for (const group of parsed.groups) {
     g.setNode(`__group_${group.label}`, { label: group.label, clusterLabelPos: "top" });
   }
@@ -10808,38 +10880,130 @@ function layoutInitiativeStatus(parsed) {
       height: pos.height
     };
   });
-  const nodeMap = new Map(layoutNodes.map((n) => [n.label, n]));
-  const allNodeX = layoutNodes.map((n) => n.x);
-  const layoutEdges = parsed.edges.map((edge, i) => {
-    const src = nodeMap.get(edge.source);
-    const tgt = nodeMap.get(edge.target);
+  const posMap = new Map(layoutNodes.map((n) => [n.label, n]));
+  for (const label of collapsedGroupLabels) {
+    const pos = g.node(label);
+    if (pos) posMap.set(label, { x: pos.x, y: pos.y, width: pos.width, height: pos.height });
+  }
+  const allNodeX = [...posMap.values()].map((n) => n.x);
+  const avgNodeY = layoutNodes.length > 0 ? layoutNodes.reduce((s, n) => s + n.y, 0) / layoutNodes.length : 0;
+  const avgNodeX = layoutNodes.length > 0 ? layoutNodes.reduce((s, n) => s + n.x, 0) / layoutNodes.length : 0;
+  const edgeYOffsets = new Array(parsed.edges.length).fill(0);
+  const edgeParallelCounts = new Array(parsed.edges.length).fill(1);
+  const parallelGroups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < parsed.edges.length; i++) {
+    const edge = parsed.edges[i];
+    const key = `${edge.source}\0${edge.target}`;
+    parallelGroups.set(key, parallelGroups.get(key) ?? []);
+    parallelGroups.get(key).push(i);
+  }
+  for (const group of parallelGroups.values()) {
+    const capped = group.slice(0, MAX_PARALLEL_EDGES);
+    for (const idx of group.slice(MAX_PARALLEL_EDGES)) {
+      edgeParallelCounts[idx] = 0;
+    }
+    if (capped.length < 2) continue;
+    const effectiveSpacing = Math.min(PARALLEL_SPACING, (NODE_HEIGHT - PARALLEL_EDGE_MARGIN) / (capped.length - 1));
+    for (let j = 0; j < capped.length; j++) {
+      edgeYOffsets[capped[j]] = (j - (capped.length - 1) / 2) * effectiveSpacing;
+      edgeParallelCounts[capped[j]] = capped.length;
+    }
+  }
+  const layoutEdges = [];
+  for (let i = 0; i < parsed.edges.length; i++) {
+    const edge = parsed.edges[i];
+    const src = posMap.get(edge.source);
+    const tgt = posMap.get(edge.target);
+    if (edgeParallelCounts[i] === 0) continue;
+    if (!src || !tgt) continue;
+    const yOffset = edgeYOffsets[i];
+    const parallelCount = edgeParallelCounts[i];
     const exitX = src.x + src.width / 2;
     const enterX = tgt.x - tgt.width / 2;
     const dagreEdge = g.edge(edge.source, edge.target, `e${i}`);
     const dagrePoints = dagreEdge?.points ?? [];
     const hasIntermediateRank = allNodeX.some((x) => x > src.x + 20 && x < tgt.x - 20);
     const step = Math.min((enterX - exitX) * 0.15, 20);
-    const fixedDagrePoints = dagrePoints.length >= 2 ? [
-      { x: exitX, y: src.y },
-      ...dagrePoints.slice(1, -1),
-      { x: enterX, y: tgt.y }
-    ] : dagrePoints;
-    const points = tgt.x > src.x && !hasIntermediateRank ? [
-      { x: exitX, y: src.y },
-      { x: exitX + step, y: src.y },
-      { x: enterX - step, y: tgt.y },
-      { x: enterX, y: tgt.y }
-    ] : fixedDagrePoints;
-    return {
+    const isBackEdge = tgt.x < src.x - 5;
+    const isYDisplaced = !isBackEdge && Math.abs(tgt.y - src.y) > NODESEP;
+    let points;
+    if (isBackEdge) {
+      const routeAbove = Math.min(src.y, tgt.y) > avgNodeY;
+      const srcHalfH = src.height / 2;
+      const tgtHalfH = tgt.height / 2;
+      const rawMidX = (src.x + tgt.x) / 2;
+      const spreadDir = avgNodeX < rawMidX ? 1 : -1;
+      const unclamped = Math.abs(src.x - tgt.x) < NODE_WIDTH ? rawMidX + spreadDir * BACK_EDGE_MIN_SPREAD : rawMidX;
+      const midX = Math.min(src.x, Math.max(tgt.x, unclamped));
+      if (routeAbove) {
+        const arcY = Math.min(src.y - srcHalfH, tgt.y - tgtHalfH) - BACK_EDGE_MARGIN;
+        points = [
+          { x: src.x, y: src.y - srcHalfH },
+          { x: midX, y: arcY },
+          { x: tgt.x, y: tgt.y - tgtHalfH }
+        ];
+      } else {
+        const arcY = Math.max(src.y + srcHalfH, tgt.y + tgtHalfH) + BACK_EDGE_MARGIN;
+        points = [
+          { x: src.x, y: src.y + srcHalfH },
+          { x: midX, y: arcY },
+          { x: tgt.x, y: tgt.y + tgtHalfH }
+        ];
+      }
+    } else if (isYDisplaced) {
+      const exitY = tgt.y > src.y + NODESEP ? src.y + src.height / 2 : src.y - src.height / 2;
+      const midX = Math.max(src.x + 1, (src.x + enterX) / 2);
+      const midY = (exitY + tgt.y) / 2;
+      points = [
+        { x: src.x, y: exitY },
+        { x: midX, y: midY },
+        { x: enterX, y: tgt.y }
+      ];
+    } else if (tgt.x > src.x && !hasIntermediateRank) {
+      points = [
+        { x: exitX, y: src.y },
+        // exits node center — stays pinned
+        { x: exitX + step, y: src.y + yOffset },
+        // fans out
+        { x: enterX - step, y: tgt.y + yOffset },
+        // still fanned
+        { x: enterX, y: tgt.y }
+        // enters node center — stays pinned
+      ];
+    } else {
+      points = dagrePoints.length >= 2 ? [
+        { x: exitX, y: src.y + yOffset },
+        ...dagrePoints.slice(1, -1),
+        { x: enterX, y: tgt.y + yOffset }
+      ] : dagrePoints;
+    }
+    layoutEdges.push({
       source: edge.source,
       target: edge.target,
       label: edge.label,
       status: edge.status,
       lineNumber: edge.lineNumber,
-      points
-    };
-  });
+      points,
+      parallelCount
+    });
+  }
   const layoutGroups = [];
+  for (const group of originalGroups) {
+    if (collapsedGroupLabels.has(group.label)) {
+      const pos = g.node(group.label);
+      if (!pos) continue;
+      layoutGroups.push({
+        label: group.label,
+        status: collapsedGroupStatuses.get(group.label) ?? null,
+        x: pos.x - pos.width / 2,
+        y: pos.y - pos.height / 2,
+        width: pos.width,
+        height: pos.height,
+        lineNumber: group.lineNumber,
+        collapsed: true
+      });
+    }
+  }
   if (parsed.groups.length > 0) {
     const nMap = new Map(layoutNodes.map((n) => [n.label, n]));
     for (const group of parsed.groups) {
@@ -10863,7 +11027,8 @@ function layoutInitiativeStatus(parsed) {
         y: minY - GROUP_PADDING,
         width: maxX - minX + GROUP_PADDING * 2,
         height: maxY - minY + GROUP_PADDING * 2,
-        lineNumber: group.lineNumber
+        lineNumber: group.lineNumber,
+        collapsed: false
       });
     }
   }
@@ -10889,7 +11054,7 @@ function layoutInitiativeStatus(parsed) {
   totalHeight += 40;
   return { nodes: layoutNodes, edges: layoutEdges, groups: layoutGroups, width: totalWidth, height: totalHeight };
 }
-var import_dagre4, STATUS_PRIORITY, PHI, NODE_HEIGHT, NODE_WIDTH, GROUP_PADDING, NODESEP, RANKSEP;
+var import_dagre4, STATUS_PRIORITY, PHI, NODE_HEIGHT, NODE_WIDTH, GROUP_PADDING, NODESEP, RANKSEP, PARALLEL_SPACING, PARALLEL_EDGE_MARGIN, MAX_PARALLEL_EDGES, BACK_EDGE_MARGIN, BACK_EDGE_MIN_SPREAD, CHAR_WIDTH_RATIO, NODE_FONT_SIZE, NODE_TEXT_PADDING;
 var init_layout5 = __esm({
   "src/initiative-status/layout.ts"() {
     "use strict";
@@ -10901,6 +11066,14 @@ var init_layout5 = __esm({
     GROUP_PADDING = 20;
     NODESEP = 80;
     RANKSEP = 160;
+    PARALLEL_SPACING = 16;
+    PARALLEL_EDGE_MARGIN = 12;
+    MAX_PARALLEL_EDGES = 5;
+    BACK_EDGE_MARGIN = 40;
+    BACK_EDGE_MIN_SPREAD = Math.round(NODE_WIDTH * 0.75);
+    CHAR_WIDTH_RATIO = 0.6;
+    NODE_FONT_SIZE = 13;
+    NODE_TEXT_PADDING = 12;
   }
 });
 
@@ -10956,10 +11129,10 @@ function splitCamelCase(word) {
   return parts.length > 1 ? parts : [word];
 }
 function fitTextToNode(label, nodeWidth, nodeHeight) {
-  const maxTextWidth = nodeWidth - NODE_TEXT_PADDING * 2;
+  const maxTextWidth = nodeWidth - NODE_TEXT_PADDING2 * 2;
   const lineHeight = 1.3;
-  for (let fontSize = NODE_FONT_SIZE; fontSize >= MIN_NODE_FONT_SIZE; fontSize--) {
-    const charWidth2 = fontSize * CHAR_WIDTH_RATIO;
+  for (let fontSize = NODE_FONT_SIZE2; fontSize >= MIN_NODE_FONT_SIZE; fontSize--) {
+    const charWidth2 = fontSize * CHAR_WIDTH_RATIO2;
     const maxCharsPerLine = Math.floor(maxTextWidth / charWidth2);
     const maxLines = Math.floor((nodeHeight - 8) / (fontSize * lineHeight));
     if (maxCharsPerLine < 2 || maxLines < 1) continue;
@@ -11020,8 +11193,8 @@ function fitTextToNode(label, nodeWidth, nodeHeight) {
       return { lines: hardLines, fontSize };
     }
   }
-  const charWidth = MIN_NODE_FONT_SIZE * CHAR_WIDTH_RATIO;
-  const maxChars = Math.floor((nodeWidth - NODE_TEXT_PADDING * 2) / charWidth);
+  const charWidth = MIN_NODE_FONT_SIZE * CHAR_WIDTH_RATIO2;
+  const maxChars = Math.floor((nodeWidth - NODE_TEXT_PADDING2 * 2) / charWidth);
   const truncated = label.length > maxChars ? label.slice(0, maxChars - 1) + "\u2026" : label;
   return { lines: [truncated], fontSize: MIN_NODE_FONT_SIZE };
 }
@@ -11244,21 +11417,27 @@ function renderInitiativeStatus(container, parsed, layout, palette, isDark, onCl
   const labelMap = /* @__PURE__ */ new Map();
   for (const lp of labelPlacements) labelMap.set(lp.edgeIdx, lp);
   for (const group of layout.groups) {
-    if (group.width === 0 && group.height === 0) continue;
-    const gx = group.x - GROUP_EXTRA_PADDING;
-    const gy = group.y - GROUP_EXTRA_PADDING - GROUP_LABEL_FONT_SIZE - 4;
-    const gw = group.width + GROUP_EXTRA_PADDING * 2;
-    const gh = group.height + GROUP_EXTRA_PADDING * 2 + GROUP_LABEL_FONT_SIZE + 4;
-    const groupStatusColor = group.status ? statusColor(group.status, palette, isDark) : palette.textMuted;
-    const fillColor = mix(groupStatusColor, isDark ? palette.surface : palette.bg, 15);
-    const strokeColor = mix(groupStatusColor, palette.textMuted, 50);
-    const groupG = contentG.append("g").attr("class", "is-group").attr("data-line-number", String(group.lineNumber));
-    groupG.append("rect").attr("x", gx).attr("y", gy).attr("width", gw).attr("height", gh).attr("rx", 6).attr("fill", fillColor).attr("stroke", strokeColor).attr("stroke-width", 1).attr("stroke-opacity", 0.5);
-    groupG.append("text").attr("x", gx + 8).attr("y", gy + GROUP_LABEL_FONT_SIZE + 4).attr("fill", strokeColor).attr("font-size", GROUP_LABEL_FONT_SIZE).attr("font-weight", "bold").attr("opacity", 0.7).attr("class", "is-group-label").text(group.label);
-    if (onClickItem) {
-      groupG.style("cursor", "pointer").on("click", () => {
-        onClickItem(group.lineNumber);
-      });
+    if (group.collapsed) {
+      const fillCol = nodeFill4(group.status, palette, isDark);
+      const strokeCol = nodeStroke4(group.status, palette, isDark);
+      const textCol = nodeTextColor(group.status, palette, isDark);
+      const clipId = `clip-group-${group.lineNumber}`;
+      const groupG = contentG.append("g").attr("class", "is-group is-group-collapsed").attr("data-line-number", String(group.lineNumber)).attr("data-group-toggle", group.label).style("cursor", "pointer");
+      groupG.append("clipPath").attr("id", clipId).append("rect").attr("x", group.x).attr("y", group.y).attr("width", group.width).attr("height", group.height).attr("rx", NODE_RX);
+      groupG.append("rect").attr("x", group.x).attr("y", group.y).attr("width", group.width).attr("height", group.height).attr("rx", NODE_RX).attr("fill", fillCol).attr("stroke", strokeCol).attr("stroke-width", NODE_STROKE_WIDTH5);
+      groupG.append("rect").attr("x", group.x).attr("y", group.y + group.height - COLLAPSE_BAR_HEIGHT3).attr("width", group.width).attr("height", COLLAPSE_BAR_HEIGHT3).attr("fill", strokeCol).attr("clip-path", `url(#${clipId})`).attr("class", "is-collapse-bar");
+      groupG.append("text").attr("x", group.x + group.width / 2).attr("y", group.y + group.height / 2 - COLLAPSE_BAR_HEIGHT3 / 2).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", textCol).attr("font-size", NODE_FONT_SIZE2).attr("font-weight", "bold").attr("font-family", FONT_FAMILY).text(group.label);
+    } else {
+      if (group.width === 0 && group.height === 0) continue;
+      const gx = group.x - GROUP_EXTRA_PADDING;
+      const gy = group.y - GROUP_EXTRA_PADDING - GROUP_LABEL_FONT_SIZE - 4;
+      const gw = group.width + GROUP_EXTRA_PADDING * 2;
+      const gh = group.height + GROUP_EXTRA_PADDING * 2 + GROUP_LABEL_FONT_SIZE + 4;
+      const fillColor = isDark ? palette.surface : palette.bg;
+      const strokeColor = palette.textMuted;
+      const groupG = contentG.append("g").attr("class", "is-group").attr("data-line-number", String(group.lineNumber)).attr("data-group-toggle", group.label).style("cursor", "pointer");
+      groupG.append("rect").attr("x", gx).attr("y", gy).attr("width", gw).attr("height", gh).attr("rx", 6).attr("fill", fillColor).attr("stroke", strokeColor).attr("stroke-opacity", 0.5);
+      groupG.append("text").attr("x", gx + 8).attr("y", gy + GROUP_LABEL_FONT_SIZE + 4).attr("fill", strokeColor).attr("font-size", GROUP_LABEL_FONT_SIZE).attr("font-weight", "bold").attr("opacity", 0.7).attr("class", "is-group-label").text(group.label);
     }
   }
   for (let ei = 0; ei < layout.edges.length; ei++) {
@@ -11269,7 +11448,7 @@ function renderInitiativeStatus(container, parsed, layout, palette, isDark, onCl
     const edgeG = contentG.append("g").attr("class", "is-edge-group").attr("data-line-number", String(edge.lineNumber));
     const pathD = lineGenerator4(edge.points);
     if (pathD) {
-      edgeG.append("path").attr("d", pathD).attr("fill", "none").attr("stroke", "transparent").attr("stroke-width", 16);
+      edgeG.append("path").attr("d", pathD).attr("fill", "none").attr("stroke", "transparent").attr("stroke-width", Math.max(6, Math.round(16 / (edge.parallelCount ?? 1))));
       edgeG.append("path").attr("d", pathD).attr("fill", "none").attr("stroke", edgeColor2).attr("stroke-width", EDGE_STROKE_WIDTH5).attr("marker-end", `url(#${markerId})`).attr("class", "is-edge");
     }
     const lp = labelMap.get(ei);
@@ -11349,7 +11528,7 @@ function renderInitiativeStatusForExport(content, theme, palette) {
     document.body.removeChild(container);
   }
 }
-var d3Selection6, d3Shape4, DIAGRAM_PADDING6, MAX_SCALE5, NODE_FONT_SIZE, MIN_NODE_FONT_SIZE, EDGE_LABEL_FONT_SIZE4, EDGE_STROKE_WIDTH5, NODE_STROKE_WIDTH5, NODE_RX, ARROWHEAD_W2, ARROWHEAD_H2, CHAR_WIDTH_RATIO, NODE_TEXT_PADDING, SERVICE_RX, GROUP_EXTRA_PADDING, GROUP_LABEL_FONT_SIZE, lineGenerator4;
+var d3Selection6, d3Shape4, DIAGRAM_PADDING6, MAX_SCALE5, NODE_FONT_SIZE2, MIN_NODE_FONT_SIZE, EDGE_LABEL_FONT_SIZE4, EDGE_STROKE_WIDTH5, NODE_STROKE_WIDTH5, NODE_RX, ARROWHEAD_W2, ARROWHEAD_H2, CHAR_WIDTH_RATIO2, NODE_TEXT_PADDING2, SERVICE_RX, GROUP_EXTRA_PADDING, GROUP_LABEL_FONT_SIZE, COLLAPSE_BAR_HEIGHT3, lineGenerator4;
 var init_renderer6 = __esm({
   "src/initiative-status/renderer.ts"() {
     "use strict";
@@ -11361,19 +11540,20 @@ var init_renderer6 = __esm({
     init_layout5();
     DIAGRAM_PADDING6 = 20;
     MAX_SCALE5 = 3;
-    NODE_FONT_SIZE = 13;
+    NODE_FONT_SIZE2 = 13;
     MIN_NODE_FONT_SIZE = 9;
     EDGE_LABEL_FONT_SIZE4 = 11;
     EDGE_STROKE_WIDTH5 = 2;
     NODE_STROKE_WIDTH5 = 2;
     NODE_RX = 8;
-    ARROWHEAD_W2 = 10;
-    ARROWHEAD_H2 = 7;
-    CHAR_WIDTH_RATIO = 0.6;
-    NODE_TEXT_PADDING = 12;
+    ARROWHEAD_W2 = 5;
+    ARROWHEAD_H2 = 4;
+    CHAR_WIDTH_RATIO2 = 0.6;
+    NODE_TEXT_PADDING2 = 12;
     SERVICE_RX = 10;
     GROUP_EXTRA_PADDING = 8;
     GROUP_LABEL_FONT_SIZE = 11;
+    COLLAPSE_BAR_HEIGHT3 = 6;
     lineGenerator4 = d3Shape4.line().x((d) => d.x).y((d) => d.y).curve(d3Shape4.curveMonotoneX);
   }
 });
@@ -14149,7 +14329,7 @@ function renderFlowchart(container, graph, layout, palette, isDark, onClickItem,
       });
     }
     renderNodeShape2(nodeG, node, palette, isDark, endTerminalIds, colorOff);
-    nodeG.append("text").attr("x", 0).attr("y", 0).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", palette.text).attr("font-size", NODE_FONT_SIZE2).text(node.label);
+    nodeG.append("text").attr("x", 0).attr("y", 0).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", palette.text).attr("font-size", NODE_FONT_SIZE3).text(node.label);
   }
 }
 function renderFlowchartForExport(content, theme, palette) {
@@ -14187,7 +14367,7 @@ function renderFlowchartForExport(content, theme, palette) {
     document.body.removeChild(container);
   }
 }
-var d3Selection8, d3Shape6, DIAGRAM_PADDING8, MAX_SCALE7, NODE_FONT_SIZE2, EDGE_LABEL_FONT_SIZE6, EDGE_STROKE_WIDTH7, NODE_STROKE_WIDTH7, ARROWHEAD_W3, ARROWHEAD_H3, IO_SKEW, SUBROUTINE_INSET, DOC_WAVE_HEIGHT, lineGenerator6;
+var d3Selection8, d3Shape6, DIAGRAM_PADDING8, MAX_SCALE7, NODE_FONT_SIZE3, EDGE_LABEL_FONT_SIZE6, EDGE_STROKE_WIDTH7, NODE_STROKE_WIDTH7, ARROWHEAD_W3, ARROWHEAD_H3, IO_SKEW, SUBROUTINE_INSET, DOC_WAVE_HEIGHT, lineGenerator6;
 var init_flowchart_renderer = __esm({
   "src/graph/flowchart-renderer.ts"() {
     "use strict";
@@ -14199,7 +14379,7 @@ var init_flowchart_renderer = __esm({
     init_layout7();
     DIAGRAM_PADDING8 = 20;
     MAX_SCALE7 = 3;
-    NODE_FONT_SIZE2 = 13;
+    NODE_FONT_SIZE3 = 13;
     EDGE_LABEL_FONT_SIZE6 = 11;
     EDGE_STROKE_WIDTH7 = 1.5;
     NODE_STROKE_WIDTH7 = 1.5;
@@ -14387,23 +14567,26 @@ function collapseGroups(parsed, collapsedIds, defaultLatencyMs = 0, defaultUptim
     if (!collapsedIds.has(group.id)) continue;
     const children = groupChildren.get(group.id) ?? [];
     if (children.length === 0) continue;
-    let totalLatency = 0;
     let minEffectiveCapacity = Infinity;
     let hasMaxRps = false;
     let composedUptime = 1;
     const behaviorProps = [];
     const perChildCapacities = [];
+    const childIdSet = new Set(children.map((c) => c.id));
+    const childLatencies = /* @__PURE__ */ new Map();
     for (const child of children) {
       const latencyProp = child.properties.find((p) => p.key === "latency-ms");
       const childIsServerless = child.properties.some((p) => p.key === "concurrency");
+      let childLat;
       if (childIsServerless) {
         const durationProp = child.properties.find((p) => p.key === "duration-ms");
-        totalLatency += durationProp ? typeof durationProp.value === "number" ? durationProp.value : parseFloat(String(durationProp.value)) || 100 : 100;
+        childLat = durationProp ? typeof durationProp.value === "number" ? durationProp.value : parseFloat(String(durationProp.value)) || 100 : 100;
       } else if (latencyProp) {
-        totalLatency += typeof latencyProp.value === "number" ? latencyProp.value : parseFloat(String(latencyProp.value)) || 0;
+        childLat = typeof latencyProp.value === "number" ? latencyProp.value : parseFloat(String(latencyProp.value)) || 0;
       } else {
-        totalLatency += defaultLatencyMs;
+        childLat = defaultLatencyMs;
       }
+      childLatencies.set(child.id, childLat);
       const maxRps = child.properties.find((p) => p.key === "max-rps");
       if (maxRps) {
         hasMaxRps = true;
@@ -14434,6 +14617,59 @@ function collapseGroups(parsed, collapsedIds, defaultLatencyMs = 0, defaultUptim
         }
       }
     }
+    const entryIds = /* @__PURE__ */ new Set();
+    const exitIds = /* @__PURE__ */ new Set();
+    for (const edge of inboundEdges) {
+      if (childIdSet.has(edge.targetId)) entryIds.add(edge.targetId);
+    }
+    for (const edge of outboundEdges) {
+      if (childIdSet.has(edge.sourceId)) exitIds.add(edge.sourceId);
+    }
+    for (const edge of crossGroupEdges) {
+      if (childIdSet.has(edge.sourceId)) exitIds.add(edge.sourceId);
+      if (childIdSet.has(edge.targetId)) entryIds.add(edge.targetId);
+    }
+    const fwdAdj = /* @__PURE__ */ new Map();
+    for (const edge of internalEdges) {
+      if (!childIdSet.has(edge.sourceId) || !childIdSet.has(edge.targetId)) continue;
+      const list = fwdAdj.get(edge.sourceId) ?? [];
+      list.push(edge.targetId);
+      fwdAdj.set(edge.sourceId, list);
+    }
+    const topoOrder = [];
+    const tsVisited = /* @__PURE__ */ new Set();
+    const dfsTopoSort = (id) => {
+      if (tsVisited.has(id)) return;
+      tsVisited.add(id);
+      for (const next of fwdAdj.get(id) ?? []) dfsTopoSort(next);
+      topoOrder.unshift(id);
+    };
+    for (const child of children) dfsTopoSort(child.id);
+    const dist = /* @__PURE__ */ new Map();
+    for (const child of children) {
+      dist.set(child.id, entryIds.has(child.id) ? childLatencies.get(child.id) ?? 0 : -Infinity);
+    }
+    for (const nodeId3 of topoOrder) {
+      const curDist = dist.get(nodeId3) ?? -Infinity;
+      if (curDist === -Infinity) continue;
+      for (const nextId of fwdAdj.get(nodeId3) ?? []) {
+        const newDist = curDist + (childLatencies.get(nextId) ?? 0);
+        if (newDist > (dist.get(nextId) ?? -Infinity)) dist.set(nextId, newDist);
+      }
+    }
+    let totalLatency = 0;
+    if (exitIds.size > 0) {
+      for (const id of exitIds) {
+        const d = dist.get(id);
+        if (d !== void 0 && d > -Infinity && d > totalLatency) totalLatency = d;
+      }
+    } else if (entryIds.size > 0) {
+      for (const [, d] of dist) {
+        if (d > 0 && d > totalLatency) totalLatency = d;
+      }
+    } else {
+      for (const [, lat] of childLatencies) totalLatency += lat;
+    }
     const props = [];
     if (totalLatency > 0) props.push({ key: "latency-ms", value: totalLatency, lineNumber: group.lineNumber });
     const groupInstances = typeof group.instances === "number" ? group.instances : 1;
@@ -14666,8 +14902,10 @@ function computeInfra(parsed, params = {}) {
       const resolved = resolveSplits(outbound, diagnostics);
       for (const { edge, split } of resolved) {
         const edgeRps = outboundRps * (split / 100);
+        const fanout = edge.fanout != null && edge.fanout >= 1 ? edge.fanout : 1;
+        const fanoutedRps = edgeRps * fanout;
         const edgeKey = `${edge.sourceId}->${edge.targetId}`;
-        computedEdgeRps.set(edgeKey, edgeRps);
+        computedEdgeRps.set(edgeKey, fanoutedRps);
         let targetIds;
         const groupChildren = groupChildMap.get(edge.targetId);
         if (groupChildren && groupChildren.length > 0) {
@@ -14676,7 +14914,7 @@ function computeInfra(parsed, params = {}) {
           targetIds = [edge.targetId];
         }
         for (const targetId of targetIds) {
-          const perTarget = edgeRps / targetIds.length;
+          const perTarget = fanoutedRps / targetIds.length;
           const existing = computedRps.get(targetId) ?? 0;
           computedRps.set(targetId, existing + perTarget);
           const prevLatency = computedLatency.get(targetId) ?? 0;
@@ -14772,6 +15010,7 @@ function computeInfra(parsed, params = {}) {
     const resolved = resolveSplits(outbound, []);
     const paths = [];
     for (const { edge, split } of resolved) {
+      const fanout = edge.fanout != null && edge.fanout >= 1 ? edge.fanout : 1;
       const groupChildren = groupChildMap.get(edge.targetId);
       const targetIds = groupChildren && groupChildren.length > 0 ? groupChildren : [edge.targetId];
       for (const targetId of targetIds) {
@@ -14782,20 +15021,20 @@ function computeInfra(parsed, params = {}) {
               latency: nodeLatency + cp.latency,
               uptime: nodeUptimeFrac * cp.uptime,
               availability: nodeAvail * cp.availability,
-              weight: cp.weight * (split / 100) / targetIds.length * 0.95
+              weight: cp.weight * (split / 100) / targetIds.length * fanout * 0.95
             });
             paths.push({
               latency: coldLatency + cp.latency,
               uptime: nodeUptimeFrac * cp.uptime,
               availability: nodeAvail * cp.availability,
-              weight: cp.weight * (split / 100) / targetIds.length * 0.05
+              weight: cp.weight * (split / 100) / targetIds.length * fanout * 0.05
             });
           } else {
             paths.push({
               latency: nodeLatency + cp.latency,
               uptime: nodeUptimeFrac * cp.uptime,
               availability: nodeAvail * cp.availability,
-              weight: cp.weight * (split / 100) / targetIds.length
+              weight: cp.weight * (split / 100) / targetIds.length * fanout
             });
           }
         }
@@ -14950,6 +15189,7 @@ function computeInfra(parsed, params = {}) {
       queueMetrics,
       properties: node.properties,
       tags: node.tags,
+      description: node.description,
       lineNumber: node.lineNumber
     };
   });
@@ -14974,6 +15214,7 @@ function computeInfra(parsed, params = {}) {
       label: edge.label,
       computedRps: rps,
       split: resolvedSplit,
+      fanout: edge.fanout,
       lineNumber: edge.lineNumber
     };
   });
@@ -15000,7 +15241,8 @@ var init_compute = __esm({
 // src/infra/layout.ts
 var layout_exports8 = {};
 __export(layout_exports8, {
-  layoutInfra: () => layoutInfra
+  layoutInfra: () => layoutInfra,
+  separateGroups: () => separateGroups
 });
 function countDisplayProps(node, expanded, options) {
   if (!expanded) return 0;
@@ -15066,7 +15308,7 @@ function computeNodeWidth2(node, expanded, options) {
       if (expanded) {
         allKeys.push("p50", "p90", "p99");
       } else {
-        allKeys.push("p99");
+        allKeys.push("p90");
       }
     }
     if (node.computedUptime < 1) {
@@ -15108,13 +15350,21 @@ function computeNodeWidth2(node, expanded, options) {
   }
   if (computedRows > 0) {
     const perc = node.computedLatencyPercentiles;
-    const msValues = expanded ? [perc.p50, perc.p90, perc.p99] : [perc.p99];
+    const msValues = expanded ? [perc.p50, perc.p90, perc.p99] : [perc.p90];
     for (const ms of msValues) {
       if (ms > 0) {
         const valLen = formatMs(ms).length;
         maxRowWidth = Math.max(maxRowWidth, (maxKeyLen + 2 + valLen) * META_CHAR_WIDTH3);
       }
     }
+    if (perc.p90 > 0) {
+      const rawThreshold = node.properties.find((p) => p.key === "slo-p90-latency-ms")?.value ?? options?.["slo-p90-latency-ms"];
+      const threshold = rawThreshold != null ? parseFloat(String(rawThreshold)) : NaN;
+      if (!isNaN(threshold) && threshold > 0) {
+        const combinedVal = `${formatMs(perc.p90)} / ${formatMs(threshold)}`;
+        maxRowWidth = Math.max(maxRowWidth, (maxKeyLen + 2 + combinedVal.length) * META_CHAR_WIDTH3);
+      }
+    }
     if (node.computedUptime < 1) {
       const valLen = formatUptime(node.computedUptime).length;
       maxRowWidth = Math.max(maxRowWidth, (maxKeyLen + 2 + valLen) * META_CHAR_WIDTH3);
@@ -15127,21 +15377,26 @@ function computeNodeWidth2(node, expanded, options) {
       maxRowWidth = Math.max(maxRowWidth, "CB: OPEN".length * META_CHAR_WIDTH3 + 8);
     }
   }
-  return Math.max(MIN_NODE_WIDTH2, labelWidth, maxRowWidth + 20);
+  const DESC_MAX_CHARS2 = 120;
+  const descText = expanded && node.description && !node.isEdge ? node.description : "";
+  const descTruncated = descText.length > DESC_MAX_CHARS2 ? descText.slice(0, DESC_MAX_CHARS2 - 1) + "\u2026" : descText;
+  const descWidth = descTruncated.length > 0 ? descTruncated.length * META_CHAR_WIDTH3 + PADDING_X3 : 0;
+  return Math.max(MIN_NODE_WIDTH2, labelWidth, maxRowWidth + 20, descWidth);
 }
 function computeNodeHeight2(node, expanded, options) {
   const propCount = countDisplayProps(node, expanded, options);
   const computedCount = countComputedRows(node, expanded);
   const hasRps = node.computedRps > 0;
-  if (propCount === 0 && computedCount === 0 && !hasRps) return NODE_HEADER_HEIGHT + NODE_PAD_BOTTOM;
-  let h = NODE_HEADER_HEIGHT + NODE_SEPARATOR_GAP;
+  const descH = expanded && node.description && !node.isEdge ? META_LINE_HEIGHT7 : 0;
+  if (propCount === 0 && computedCount === 0 && !hasRps) return NODE_HEADER_HEIGHT + descH + NODE_PAD_BOTTOM;
+  let h = NODE_HEADER_HEIGHT + descH + NODE_SEPARATOR_GAP;
   const computedSectionCount = (hasRps ? 1 : 0) + computedCount;
   h += computedSectionCount * META_LINE_HEIGHT7;
   if (computedSectionCount > 0 && propCount > 0) h += NODE_SEPARATOR_GAP;
   h += propCount * META_LINE_HEIGHT7;
   if (hasRoles(node)) h += ROLE_DOT_ROW;
   h += NODE_PAD_BOTTOM;
-  if (node.id.startsWith("[")) h += COLLAPSE_BAR_HEIGHT3;
+  if (node.id.startsWith("[")) h += COLLAPSE_BAR_HEIGHT4;
   return h;
 }
 function formatRps(rps) {
@@ -15168,7 +15423,36 @@ function formatUptime(fraction) {
   if (pct >= 99) return `${pct.toFixed(1)}%`;
   return `${pct.toFixed(1)}%`;
 }
-function layoutInfra(computed, selectedNodeId, collapsedNodes) {
+function separateGroups(groups, nodes, isLR, maxIterations = 20) {
+  for (let iter = 0; iter < maxIterations; iter++) {
+    let anyOverlap = false;
+    for (let i = 0; i < groups.length; i++) {
+      for (let j = i + 1; j < groups.length; j++) {
+        const ga = groups[i];
+        const gb = groups[j];
+        const primaryOverlap = isLR ? Math.min(ga.y + ga.height, gb.y + gb.height) - Math.max(ga.y, gb.y) : Math.min(ga.x + ga.width, gb.x + gb.width) - Math.max(ga.x, gb.x);
+        if (primaryOverlap <= 0) continue;
+        const crossOverlap = isLR ? Math.min(ga.x + ga.width, gb.x + gb.width) - Math.max(ga.x, gb.x) : Math.min(ga.y + ga.height, gb.y + gb.height) - Math.max(ga.y, gb.y);
+        if (crossOverlap <= 0) continue;
+        anyOverlap = true;
+        const shift = primaryOverlap + GROUP_GAP;
+        const aCenter = isLR ? ga.y + ga.height / 2 : ga.x + ga.width / 2;
+        const bCenter = isLR ? gb.y + gb.height / 2 : gb.x + gb.width / 2;
+        const groupToShift = aCenter <= bCenter ? gb : ga;
+        if (isLR) groupToShift.y += shift;
+        else groupToShift.x += shift;
+        for (const node of nodes) {
+          if (node.groupId === groupToShift.id) {
+            if (isLR) node.y += shift;
+            else node.x += shift;
+          }
+        }
+      }
+    }
+    if (!anyOverlap) break;
+  }
+}
+function layoutInfra(computed, expandedNodeIds, collapsedNodes) {
   if (computed.nodes.length === 0) {
     return { nodes: [], edges: [], groups: [], options: {}, width: 0, height: 0 };
   }
@@ -15190,7 +15474,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
   const heightMap = /* @__PURE__ */ new Map();
   for (const node of computed.nodes) {
     const isNodeCollapsed = collapsedNodes?.has(node.id) ?? false;
-    const expanded = !isNodeCollapsed && node.id === selectedNodeId;
+    const expanded = !isNodeCollapsed && (expandedNodeIds?.has(node.id) ?? false);
     const width = computeNodeWidth2(node, expanded, computed.options);
     const height = isNodeCollapsed ? NODE_HEADER_HEIGHT + NODE_PAD_BOTTOM : computeNodeHeight2(node, expanded, computed.options);
     widthMap.set(node.id, width);
@@ -15251,6 +15535,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
       queueMetrics: node.queueMetrics,
       properties: node.properties,
       tags: node.tags,
+      description: node.description,
       lineNumber: node.lineNumber
     };
   });
@@ -15265,6 +15550,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
         label: edge.label,
         computedRps: edge.computedRps,
         split: edge.split,
+        fanout: edge.fanout,
         points: edgeData?.points ?? [],
         lineNumber: edge.lineNumber
       });
@@ -15276,6 +15562,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
         label: edge.label,
         computedRps: edge.computedRps,
         split: edge.split,
+        fanout: edge.fanout,
         points: edgeData?.points ?? [],
         lineNumber: edge.lineNumber
       });
@@ -15317,6 +15604,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
       lineNumber: group.lineNumber
     };
   });
+  separateGroups(layoutGroups, layoutNodes, isLR);
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (const node of layoutNodes) {
     const left = node.x - node.width / 2;
@@ -15378,7 +15666,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
     height: totalHeight
   };
 }
-var import_dagre7, MIN_NODE_WIDTH2, NODE_HEADER_HEIGHT, META_LINE_HEIGHT7, NODE_SEPARATOR_GAP, NODE_PAD_BOTTOM, ROLE_DOT_ROW, COLLAPSE_BAR_HEIGHT3, CHAR_WIDTH6, META_CHAR_WIDTH3, PADDING_X3, GROUP_PADDING3, GROUP_HEADER_HEIGHT, EDGE_MARGIN, DISPLAY_KEYS, DISPLAY_NAMES;
+var import_dagre7, MIN_NODE_WIDTH2, NODE_HEADER_HEIGHT, META_LINE_HEIGHT7, NODE_SEPARATOR_GAP, NODE_PAD_BOTTOM, ROLE_DOT_ROW, COLLAPSE_BAR_HEIGHT4, CHAR_WIDTH6, META_CHAR_WIDTH3, PADDING_X3, GROUP_PADDING3, GROUP_HEADER_HEIGHT, EDGE_MARGIN, DISPLAY_KEYS, DISPLAY_NAMES, GROUP_GAP;
 var init_layout8 = __esm({
   "src/infra/layout.ts"() {
     "use strict";
@@ -15389,7 +15677,7 @@ var init_layout8 = __esm({
     NODE_SEPARATOR_GAP = 4;
     NODE_PAD_BOTTOM = 10;
     ROLE_DOT_ROW = 12;
-    COLLAPSE_BAR_HEIGHT3 = 6;
+    COLLAPSE_BAR_HEIGHT4 = 6;
     CHAR_WIDTH6 = 7;
     META_CHAR_WIDTH3 = 6;
     PADDING_X3 = 24;
@@ -15417,11 +15705,11 @@ var init_layout8 = __esm({
     DISPLAY_NAMES = {
       "cache-hit": "cache hit",
       "firewall-block": "fw block",
-      "ratelimit-rps": "rate limit",
+      "ratelimit-rps": "rate limit RPS",
       "latency-ms": "latency",
       "uptime": "uptime",
       "instances": "instances",
-      "max-rps": "capacity",
+      "max-rps": "max RPS",
       "cb-error-threshold": "CB error",
       "cb-latency-threshold-ms": "CB latency",
       "concurrency": "concurrency",
@@ -15432,6 +15720,7 @@ var init_layout8 = __esm({
       "retention-hours": "retention",
       "partitions": "partitions"
     };
+    GROUP_GAP = 24;
   }
 });
 
@@ -15446,6 +15735,13 @@ function inferRoles(properties) {
   }
   return roles;
 }
+function collectFanoutSourceIds(edges) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (e.fanout != null) ids.add(e.sourceId);
+  }
+  return ids;
+}
 function collectDiagramRoles(allProperties) {
   const seen = /* @__PURE__ */ new Set();
   const roles = [];
@@ -15459,7 +15755,7 @@ function collectDiagramRoles(allProperties) {
   }
   return roles;
 }
-var ROLE_RULES;
+var ROLE_RULES, FANOUT_ROLE;
 var init_roles = __esm({
   "src/infra/roles.ts"() {
     "use strict";
@@ -15472,6 +15768,7 @@ var init_roles = __esm({
       { keys: ["concurrency"], role: { name: "Serverless", color: "#06b6d4" } },
       { keys: ["buffer"], role: { name: "Queue", color: "#8b5cf6" } }
     ];
+    FANOUT_ROLE = { name: "Fan-Out", color: "#f97316" };
   }
 });
 
@@ -15482,6 +15779,20 @@ __export(renderer_exports8, {
   parseAndLayoutInfra: () => parseAndLayoutInfra,
   renderInfra: () => renderInfra
 });
+function resolveNodeSlo(node, diagramOptions) {
+  const nodeProp = (key) => node.properties.find((p) => p.key === key);
+  const availRaw = nodeProp("slo-availability")?.value ?? diagramOptions["slo-availability"];
+  const latencyRaw = nodeProp("slo-p90-latency-ms")?.value ?? diagramOptions["slo-p90-latency-ms"];
+  const marginRaw = nodeProp("slo-warning-margin")?.value ?? diagramOptions["slo-warning-margin"];
+  const availParsed = availRaw != null ? parseFloat(String(availRaw).replace("%", "")) / 100 : NaN;
+  const availThreshold = !isNaN(availParsed) ? availParsed : null;
+  const latencyParsed = latencyRaw != null ? parseFloat(String(latencyRaw)) : NaN;
+  const latencyP90 = !isNaN(latencyParsed) ? latencyParsed : null;
+  const marginParsed = marginRaw != null ? parseFloat(String(marginRaw).replace("%", "")) / 100 : NaN;
+  const warningMargin = !isNaN(marginParsed) ? marginParsed : 0.05;
+  if (availThreshold == null && latencyP90 == null) return null;
+  return { availThreshold, latencyP90, warningMargin };
+}
 function nodeBorderPoint(node, target) {
   const hw = node.width / 2;
   const hh = node.height / 2;
@@ -15518,7 +15829,17 @@ function isWarning(node) {
   const cap = Number(maxRps.value) * node.computedInstances;
   return cap > 0 && node.computedRps / cap > 0.7;
 }
-function getComputedRows(node, expanded) {
+function truncateDesc(text) {
+  if (text.length <= DESC_MAX_CHARS) return text;
+  return text.slice(0, DESC_MAX_CHARS - 1) + "\u2026";
+}
+function sloLatencyColor(p90, slo) {
+  const t = slo.latencyP90 ?? 0;
+  if (t === 0) return COLOR_HEALTHY;
+  const m = slo.warningMargin;
+  return p90 > t ? COLOR_OVERLOADED : p90 > t * (1 - m) ? COLOR_WARNING : COLOR_HEALTHY;
+}
+function getComputedRows(node, expanded, slo) {
   const rows = [];
   if (node.computedConcurrentInvocations > 0) {
     const concurrency = getNodeNumProp(node, "concurrency", 0);
@@ -15532,9 +15853,23 @@ function getComputedRows(node, expanded) {
   if (p.p50 > 0 || p.p90 > 0 || p.p99 > 0) {
     if (expanded) {
       rows.push({ key: "p50", value: formatMsShort(p.p50) });
-      rows.push({ key: "p90", value: formatMsShort(p.p90) });
+      if (slo?.latencyP90 != null) {
+        const color = sloLatencyColor(p.p90, slo);
+        const p90Value = color !== COLOR_HEALTHY ? `${formatMsShort(p.p90)} / ${formatMsShort(slo.latencyP90)}` : formatMsShort(p.p90);
+        rows.push({ key: "p90", value: p90Value, color, inverted: color !== COLOR_HEALTHY });
+      } else {
+        rows.push({ key: "p90", value: formatMsShort(p.p90) });
+      }
+      rows.push({ key: "p99", value: formatMsShort(p.p99) });
+    } else if (p.p90 > 0) {
+      if (slo?.latencyP90 != null) {
+        const color = sloLatencyColor(p.p90, slo);
+        const p90Value = color !== COLOR_HEALTHY ? `${formatMsShort(p.p90)} / ${formatMsShort(slo.latencyP90)}` : formatMsShort(p.p90);
+        rows.push({ key: "p90", value: p90Value, color, inverted: color !== COLOR_HEALTHY });
+      } else {
+        rows.push({ key: "p90", value: formatMsShort(p.p90) });
+      }
     }
-    rows.push({ key: "p99", value: formatMsShort(p.p99) });
   }
   if (node.computedUptime < 1) {
     const declaredUptime = node.properties.find((p2) => p2.key === "uptime");
@@ -15545,8 +15880,17 @@ function getComputedRows(node, expanded) {
     }
   }
   if (node.computedAvailability < 1) {
-    const color = node.computedAvailability < 0.95 ? COLOR_OVERLOADED : node.computedAvailability < 0.99 ? COLOR_WARNING : void 0;
-    rows.push({ key: "availability", value: formatUptimeShort(node.computedAvailability), color, inverted: color != null });
+    let color;
+    if (slo?.availThreshold != null) {
+      const t = slo.availThreshold;
+      const m = slo.warningMargin;
+      if (node.computedAvailability < t) color = COLOR_OVERLOADED;
+      else if (node.computedAvailability < Math.min(1, t + m)) color = COLOR_WARNING;
+      else color = COLOR_HEALTHY;
+    } else {
+      color = node.computedAvailability < 0.95 ? COLOR_OVERLOADED : node.computedAvailability < 0.99 ? COLOR_WARNING : void 0;
+    }
+    rows.push({ key: "availability", value: formatUptimeShort(node.computedAvailability), color, inverted: color != null && color !== COLOR_HEALTHY });
   }
   if (node.computedCbState === "open") {
     rows.push({ key: "CB", value: "OPEN", color: COLOR_OVERLOADED, inverted: true });
@@ -15634,7 +15978,7 @@ function formatRpsShort2(rps) {
   if (rps >= 1e3) return `${(rps / 1e3).toFixed(1)}k`;
   return `${Math.round(rps)}`;
 }
-function worstNodeSeverity(node) {
+function worstNodeSeverity(node, slo) {
   let worst = "normal";
   const upgrade = (s) => {
     if (s === "overloaded") worst = "overloaded";
@@ -15645,8 +15989,22 @@ function worstNodeSeverity(node) {
   if (node.overloaded) upgrade("overloaded");
   if (node.rateLimited) upgrade("warning");
   if (isWarning(node)) upgrade("warning");
-  if (node.computedAvailability < 0.95) upgrade("overloaded");
-  else if (node.computedAvailability < 0.99) upgrade("warning");
+  if (slo?.availThreshold != null) {
+    const t = slo.availThreshold;
+    const m = slo.warningMargin;
+    if (node.computedAvailability < t) upgrade("overloaded");
+    else if (node.computedAvailability < Math.min(1, t + m)) upgrade("warning");
+  } else {
+    if (node.computedAvailability < 0.95) upgrade("overloaded");
+    else if (node.computedAvailability < 0.99) upgrade("warning");
+  }
+  if (slo?.latencyP90 != null) {
+    const t = slo.latencyP90;
+    const m = slo.warningMargin;
+    const p90 = node.computedLatencyPercentiles.p90;
+    if (p90 > t) upgrade("overloaded");
+    else if (p90 > t * (1 - m)) upgrade("warning");
+  }
   if (node.computedCbState === "open") upgrade("overloaded");
   if (node.queueMetrics && node.queueMetrics.fillRate > 0) {
     if (node.queueMetrics.timeToOverflow < 60) upgrade("overloaded");
@@ -15664,10 +16022,14 @@ function worstNodeSeverity(node) {
       else if (preRl > nodeRateLimit * 0.8) upgrade("warning");
     }
   }
+  if (worst === "normal" && slo != null) {
+    const availGreen = slo.availThreshold == null || node.computedAvailability >= Math.min(1, slo.availThreshold + slo.warningMargin);
+    const latencyGreen = slo.latencyP90 == null || node.computedLatencyPercentiles.p90 <= slo.latencyP90 * (1 - slo.warningMargin);
+    if (availGreen && latencyGreen) return "healthy";
+  }
   return worst;
 }
-function nodeColor(node, palette, isDark) {
-  const severity = worstNodeSeverity(node);
+function nodeColor(_node, palette, isDark, severity) {
   if (severity === "overloaded") {
     return {
       fill: mix(palette.bg, COLOR_OVERLOADED, isDark ? 80 : 92),
@@ -15682,6 +16044,13 @@ function nodeColor(node, palette, isDark) {
       textFill: palette.text
     };
   }
+  if (severity === "healthy") {
+    return {
+      fill: mix(palette.bg, COLOR_HEALTHY, isDark ? 85 : 93),
+      stroke: COLOR_HEALTHY,
+      textFill: palette.text
+    };
+  }
   return {
     fill: isDark ? mix(palette.bg, palette.text, 90) : mix(palette.bg, palette.text, 95),
     stroke: isDark ? mix(palette.text, palette.bg, 60) : mix(palette.text, palette.bg, 40),
@@ -15775,10 +16144,12 @@ function resolveActiveTagStroke(node, activeGroup, tagGroups, palette) {
   if (!tv?.color) return null;
   return resolveColor(tv.color, palette);
 }
-function renderNodes(svg, nodes, palette, isDark, animate, selectedNodeId, activeGroup, diagramOptions, collapsedNodes, tagGroups) {
+function renderNodes(svg, nodes, palette, isDark, animate, expandedNodeIds, activeGroup, diagramOptions, collapsedNodes, tagGroups, fanoutSourceIds, scaledGroupIds) {
   const mutedColor = palette.textMuted;
   for (const node of nodes) {
-    let { fill: fill2, stroke: stroke2, textFill } = nodeColor(node, palette, isDark);
+    const slo = !node.isEdge && diagramOptions ? resolveNodeSlo(node, diagramOptions) : null;
+    const severity = worstNodeSeverity(node, slo);
+    let { fill: fill2, stroke: stroke2, textFill } = nodeColor(node, palette, isDark, severity);
     if (activeGroup && tagGroups && !node.isEdge) {
       const tagStroke = resolveActiveTagStroke(node, activeGroup, tagGroups, palette);
       if (tagStroke) {
@@ -15790,7 +16161,6 @@ function renderNodes(svg, nodes, palette, isDark, animate, selectedNodeId, activ
     if (animate && node.isEdge) {
       cls += " infra-node-edge-throb";
     } else if (animate && !node.isEdge) {
-      const severity = worstNodeSeverity(node);
       if (node.computedCbState === "open") cls += " infra-node-cb-open";
       else if (severity === "overloaded") cls += " infra-node-overload";
       else if (severity === "warning") cls += " infra-node-warning";
@@ -15807,26 +16177,36 @@ function renderNodes(svg, nodes, palette, isDark, animate, selectedNodeId, activ
       for (const role of roles) {
         g.attr(`data-role-${role.name.toLowerCase().replace(/\s+/g, "-")}`, "true");
       }
+      if (fanoutSourceIds?.has(node.id)) {
+        g.attr("data-role-fan-out", "true");
+      }
     }
     const x = node.x - node.width / 2;
     const y = node.y - node.height / 2;
     const isCollapsedGroup = node.id.startsWith("[");
-    const strokeWidth = worstNodeSeverity(node) !== "normal" ? OVERLOAD_STROKE_WIDTH : NODE_STROKE_WIDTH8;
+    const strokeWidth = severity !== "normal" ? OVERLOAD_STROKE_WIDTH : NODE_STROKE_WIDTH8;
     g.append("rect").attr("x", x).attr("y", y).attr("width", node.width).attr("height", node.height).attr("rx", NODE_BORDER_RADIUS).attr("fill", fill2).attr("stroke", stroke2).attr("stroke-width", strokeWidth);
-    const headerCenterY = y + NODE_HEADER_HEIGHT2 / 2 + NODE_FONT_SIZE3 * 0.35;
-    g.append("text").attr("x", node.x).attr("y", headerCenterY).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("font-size", NODE_FONT_SIZE3).attr("font-weight", "600").attr("fill", textFill).text(node.label);
+    const headerCenterY = y + NODE_HEADER_HEIGHT2 / 2 + NODE_FONT_SIZE4 * 0.35;
+    g.append("text").attr("x", node.x).attr("y", headerCenterY).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("font-size", NODE_FONT_SIZE4).attr("font-weight", "600").attr("fill", textFill).text(node.label);
     const isNodeCollapsed = collapsedNodes?.has(node.id) ?? false;
     if (isNodeCollapsed) {
       const chevronY = y + node.height - 6;
       g.append("text").attr("x", node.x).attr("y", chevronY).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("font-size", 8).attr("fill", textFill).attr("opacity", 0.5).text("\u25BC");
     }
     if (!isNodeCollapsed) {
-      const expanded = node.id === selectedNodeId;
+      const expanded = expandedNodeIds?.has(node.id) ?? false;
+      const descH = expanded && node.description && !node.isEdge ? META_LINE_HEIGHT8 : 0;
+      if (descH > 0 && node.description) {
+        const descTruncated = truncateDesc(node.description);
+        const isTruncated = descTruncated !== node.description;
+        const textEl = g.append("text").attr("x", node.x).attr("y", y + NODE_HEADER_HEIGHT2 + META_LINE_HEIGHT8 / 2 + META_FONT_SIZE4 * 0.35).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("font-size", META_FONT_SIZE4).attr("fill", mutedColor).text(descTruncated);
+        if (isTruncated) textEl.append("title").text(node.description);
+      }
       const displayProps = !node.isEdge && expanded ? getDisplayProps(node, expanded, diagramOptions) : [];
-      const computedRows = getComputedRows(node, expanded);
+      const computedRows = getComputedRows(node, expanded, slo);
       const hasContent = displayProps.length > 0 || computedRows.length > 0 || node.computedRps > 0;
       if (hasContent) {
-        const sepY = y + NODE_HEADER_HEIGHT2;
+        const sepY = y + NODE_HEADER_HEIGHT2 + descH;
         g.append("line").attr("x1", x).attr("y1", sepY).attr("x2", x + node.width).attr("y2", sepY).attr("stroke", stroke2).attr("stroke-opacity", 0.3).attr("stroke-width", 1);
         const computedSection = [];
         const declaredSection = [];
@@ -15922,14 +16302,15 @@ function renderNodes(svg, nodes, palette, isDark, animate, selectedNodeId, activ
           rowIdx++;
         }
       }
-      if (!node.isEdge && node.computedConcurrentInvocations === 0 && node.computedInstances > 1) {
+      const inScaledGroup = node.groupId != null && (scaledGroupIds?.has(node.groupId) ?? false);
+      if (!node.isEdge && node.computedConcurrentInvocations === 0 && node.computedInstances > 1 && !inScaledGroup) {
         const badgeText = `${node.computedInstances}x`;
         g.append("text").attr("x", x + node.width - 6).attr("y", y + NODE_HEADER_HEIGHT2 / 2 + META_FONT_SIZE4 * 0.35).attr("text-anchor", "end").attr("font-family", FONT_FAMILY).attr("font-size", META_FONT_SIZE4).attr("fill", mutedColor).attr("data-instance-node", node.id).style("cursor", "pointer").text(badgeText);
       }
       const showDots = activeGroup != null && activeGroup.toLowerCase() === "capabilities";
       const roles = showDots && !node.isEdge ? inferRoles(node.properties) : [];
       if (roles.length > 0) {
-        const dotY = isCollapsedGroup ? y + node.height - COLLAPSE_BAR_HEIGHT4 - NODE_PAD_BOTTOM2 / 2 : y + node.height - NODE_PAD_BOTTOM2 / 2;
+        const dotY = isCollapsedGroup ? y + node.height - COLLAPSE_BAR_HEIGHT5 - NODE_PAD_BOTTOM2 / 2 : y + node.height - NODE_PAD_BOTTOM2 / 2;
         const totalDotsWidth = roles.length * (ROLE_DOT_RADIUS * 2 + 2) - 2;
         const startX = node.x - totalDotsWidth / 2 + ROLE_DOT_RADIUS;
         for (let i = 0; i < roles.length; i++) {
@@ -15939,7 +16320,7 @@ function renderNodes(svg, nodes, palette, isDark, animate, selectedNodeId, activ
       if (isCollapsedGroup) {
         const clipId = `clip-${node.id.replace(/[[\]\s]/g, "")}`;
         g.append("clipPath").attr("id", clipId).append("rect").attr("x", x).attr("y", y).attr("width", node.width).attr("height", node.height).attr("rx", NODE_BORDER_RADIUS);
-        g.append("rect").attr("x", x + COLLAPSE_BAR_INSET2).attr("y", y + node.height - COLLAPSE_BAR_HEIGHT4).attr("width", node.width - COLLAPSE_BAR_INSET2 * 2).attr("height", COLLAPSE_BAR_HEIGHT4).attr("fill", stroke2).attr("clip-path", `url(#${clipId})`).attr("class", "infra-collapse-bar");
+        g.append("rect").attr("x", x + COLLAPSE_BAR_INSET2).attr("y", y + node.height - COLLAPSE_BAR_HEIGHT5).attr("width", node.width - COLLAPSE_BAR_INSET2 * 2).attr("height", COLLAPSE_BAR_HEIGHT5).attr("fill", stroke2).attr("clip-path", `url(#${clipId})`).attr("class", "infra-collapse-bar");
       }
     }
   }
@@ -16008,9 +16389,12 @@ function renderRejectParticles(svg, nodes) {
     }
   }
 }
-function computeInfraLegendGroups(nodes, tagGroups, palette) {
+function computeInfraLegendGroups(nodes, tagGroups, palette, edges) {
   const groups = [];
   const roles = collectDiagramRoles(nodes.filter((n) => !n.isEdge).map((n) => n.properties));
+  if (edges && collectFanoutSourceIds(edges).size > 0) {
+    roles.push(FANOUT_ROLE);
+  }
   if (roles.length > 0) {
     const entries = roles.map((r) => ({
       value: r.name,
@@ -16065,7 +16449,7 @@ function computePlaybackWidth(playback) {
   let entriesW = 8;
   entriesW += LEGEND_PILL_FONT_SIZE5 * 0.8 + 6;
   for (const s of playback.speedOptions) {
-    entriesW += `${s}x`.length * LEGEND_ENTRY_FONT_W7 + 6;
+    entriesW += `${s}x`.length * LEGEND_ENTRY_FONT_W7 + SPEED_BADGE_H_PAD * 2 + SPEED_BADGE_GAP;
   }
   return LEGEND_CAPSULE_PAD7 * 2 + pillWidth + entriesW;
 }
@@ -16136,16 +16520,21 @@ function renderLegend3(rootSvg, legendGroups, totalWidth, legendY, palette, isDa
       for (const s of playback.speedOptions) {
         const label = `${s}x`;
         const isActive = playback.speed === s;
-        pbG.append("text").attr("x", entryX).attr("y", entryY).attr("font-family", FONT_FAMILY).attr("font-size", LEGEND_ENTRY_FONT_SIZE6).attr("font-weight", isActive ? "600" : "400").attr("fill", isActive ? palette.primary : palette.textMuted).attr("data-playback-action", "set-speed").attr("data-playback-value", String(s)).style("cursor", "pointer").text(label);
-        entryX += label.length * LEGEND_ENTRY_FONT_W7 + 6;
+        const slotW = label.length * LEGEND_ENTRY_FONT_W7 + SPEED_BADGE_H_PAD * 2;
+        const badgeH = LEGEND_ENTRY_FONT_SIZE6 + SPEED_BADGE_V_PAD * 2;
+        const badgeY = (LEGEND_HEIGHT8 - badgeH) / 2;
+        const speedG = pbG.append("g").attr("data-playback-action", "set-speed").attr("data-playback-value", String(s)).style("cursor", "pointer");
+        speedG.append("rect").attr("x", entryX).attr("y", badgeY).attr("width", slotW).attr("height", badgeH).attr("rx", badgeH / 2).attr("fill", isActive ? palette.primary : "transparent");
+        speedG.append("text").attr("x", entryX + slotW / 2).attr("y", entryY).attr("font-family", FONT_FAMILY).attr("font-size", LEGEND_ENTRY_FONT_SIZE6).attr("font-weight", isActive ? "600" : "400").attr("fill", isActive ? palette.bg : palette.textMuted).attr("text-anchor", "middle").text(label);
+        entryX += slotW + SPEED_BADGE_GAP;
       }
     }
     cursorX += fullW + LEGEND_GROUP_GAP5;
   }
 }
-function renderInfra(container, layout, palette, isDark, title, titleLineNumber, tagGroups, activeGroup, animate, playback, selectedNodeId, exportMode, collapsedNodes) {
+function renderInfra(container, layout, palette, isDark, title, titleLineNumber, tagGroups, activeGroup, animate, playback, expandedNodeIds, exportMode, collapsedNodes) {
   d3Selection9.select(container).selectAll(":not([data-d3-tooltip])").remove();
-  const legendGroups = computeInfraLegendGroups(layout.nodes, tagGroups ?? [], palette);
+  const legendGroups = computeInfraLegendGroups(layout.nodes, tagGroups ?? [], palette, layout.edges);
   const hasLegend = legendGroups.length > 0 || !!playback;
   const fixedLegend = !exportMode && hasLegend;
   const legendOffset = hasLegend && !fixedLegend ? LEGEND_HEIGHT8 : 0;
@@ -16202,7 +16591,14 @@ function renderInfra(container, layout, palette, isDark, title, titleLineNumber,
   }
   renderGroups(svg, layout.groups, palette, isDark);
   renderEdgePaths(svg, layout.edges, layout.nodes, palette, isDark, shouldAnimate);
-  renderNodes(svg, layout.nodes, palette, isDark, shouldAnimate, selectedNodeId, activeGroup, layout.options, collapsedNodes, tagGroups ?? []);
+  const fanoutSourceIds = collectFanoutSourceIds(layout.edges);
+  const scaledGroupIds = new Set(
+    layout.groups.filter((g) => {
+      const gi = typeof g.instances === "number" ? g.instances : typeof g.instances === "string" ? parseInt(String(g.instances), 10) || 0 : 0;
+      return gi > 1;
+    }).map((g) => g.id)
+  );
+  renderNodes(svg, layout.nodes, palette, isDark, shouldAnimate, expandedNodeIds, activeGroup, layout.options, collapsedNodes, tagGroups ?? [], fanoutSourceIds, scaledGroupIds);
   if (shouldAnimate) {
     renderRejectParticles(svg, layout.nodes);
   }
@@ -16224,7 +16620,7 @@ function parseAndLayoutInfra(content) {
   const layout = layoutInfra(computed);
   return { parsed, computed, layout };
 }
-var d3Selection9, d3Shape7, NODE_FONT_SIZE3, META_FONT_SIZE4, META_LINE_HEIGHT8, EDGE_LABEL_FONT_SIZE7, GROUP_LABEL_FONT_SIZE2, NODE_BORDER_RADIUS, EDGE_STROKE_WIDTH8, NODE_STROKE_WIDTH8, OVERLOAD_STROKE_WIDTH, ROLE_DOT_RADIUS, NODE_HEADER_HEIGHT2, NODE_SEPARATOR_GAP2, NODE_PAD_BOTTOM2, COLLAPSE_BAR_HEIGHT4, COLLAPSE_BAR_INSET2, LEGEND_HEIGHT8, LEGEND_PILL_PAD7, LEGEND_PILL_FONT_SIZE5, LEGEND_PILL_FONT_W7, LEGEND_CAPSULE_PAD7, LEGEND_DOT_R8, LEGEND_ENTRY_FONT_SIZE6, LEGEND_ENTRY_FONT_W7, LEGEND_ENTRY_DOT_GAP7, LEGEND_ENTRY_TRAIL7, LEGEND_GROUP_GAP5, LEGEND_FIXED_GAP3, COLOR_WARNING, COLOR_OVERLOADED, FLOW_SPEED_MIN, FLOW_SPEED_MAX, PARTICLE_R, PARTICLE_COUNT_MIN, PARTICLE_COUNT_MAX, NODE_PULSE_SPEED, NODE_PULSE_OVERLOAD, REJECT_PARTICLE_R, REJECT_DROP_DISTANCE, REJECT_DURATION_MIN, REJECT_DURATION_MAX, REJECT_COUNT_MIN, REJECT_COUNT_MAX, lineGenerator7, PROP_DISPLAY, RPS_FORMAT_KEYS, MS_FORMAT_KEYS, PCT_FORMAT_KEYS;
+var d3Selection9, d3Shape7, NODE_FONT_SIZE4, META_FONT_SIZE4, META_LINE_HEIGHT8, EDGE_LABEL_FONT_SIZE7, GROUP_LABEL_FONT_SIZE2, NODE_BORDER_RADIUS, EDGE_STROKE_WIDTH8, NODE_STROKE_WIDTH8, OVERLOAD_STROKE_WIDTH, ROLE_DOT_RADIUS, NODE_HEADER_HEIGHT2, NODE_SEPARATOR_GAP2, NODE_PAD_BOTTOM2, COLLAPSE_BAR_HEIGHT5, COLLAPSE_BAR_INSET2, LEGEND_HEIGHT8, LEGEND_PILL_PAD7, LEGEND_PILL_FONT_SIZE5, LEGEND_PILL_FONT_W7, LEGEND_CAPSULE_PAD7, LEGEND_DOT_R8, LEGEND_ENTRY_FONT_SIZE6, LEGEND_ENTRY_FONT_W7, LEGEND_ENTRY_DOT_GAP7, LEGEND_ENTRY_TRAIL7, LEGEND_GROUP_GAP5, LEGEND_FIXED_GAP3, SPEED_BADGE_H_PAD, SPEED_BADGE_V_PAD, SPEED_BADGE_GAP, COLOR_HEALTHY, COLOR_WARNING, COLOR_OVERLOADED, FLOW_SPEED_MIN, FLOW_SPEED_MAX, PARTICLE_R, PARTICLE_COUNT_MIN, PARTICLE_COUNT_MAX, NODE_PULSE_SPEED, NODE_PULSE_OVERLOAD, REJECT_PARTICLE_R, REJECT_DROP_DISTANCE, REJECT_DURATION_MIN, REJECT_DURATION_MAX, REJECT_COUNT_MIN, REJECT_COUNT_MAX, lineGenerator7, PROP_DISPLAY, DESC_MAX_CHARS, RPS_FORMAT_KEYS, MS_FORMAT_KEYS, PCT_FORMAT_KEYS;
 var init_renderer8 = __esm({
   "src/infra/renderer.ts"() {
     "use strict";
@@ -16237,7 +16633,7 @@ var init_renderer8 = __esm({
     init_parser9();
     init_compute();
     init_layout8();
-    NODE_FONT_SIZE3 = 13;
+    NODE_FONT_SIZE4 = 13;
     META_FONT_SIZE4 = 10;
     META_LINE_HEIGHT8 = 14;
     EDGE_LABEL_FONT_SIZE7 = 11;
@@ -16250,7 +16646,7 @@ var init_renderer8 = __esm({
     NODE_HEADER_HEIGHT2 = 28;
     NODE_SEPARATOR_GAP2 = 4;
     NODE_PAD_BOTTOM2 = 10;
-    COLLAPSE_BAR_HEIGHT4 = 6;
+    COLLAPSE_BAR_HEIGHT5 = 6;
     COLLAPSE_BAR_INSET2 = 0;
     LEGEND_HEIGHT8 = 28;
     LEGEND_PILL_PAD7 = 16;
@@ -16264,6 +16660,10 @@ var init_renderer8 = __esm({
     LEGEND_ENTRY_TRAIL7 = 8;
     LEGEND_GROUP_GAP5 = 12;
     LEGEND_FIXED_GAP3 = 16;
+    SPEED_BADGE_H_PAD = 5;
+    SPEED_BADGE_V_PAD = 3;
+    SPEED_BADGE_GAP = 6;
+    COLOR_HEALTHY = "#22c55e";
     COLOR_WARNING = "#eab308";
     COLOR_OVERLOADED = "#ef4444";
     FLOW_SPEED_MIN = 2.5;
@@ -16282,22 +16682,23 @@ var init_renderer8 = __esm({
     lineGenerator7 = d3Shape7.line().x((d) => d.x).y((d) => d.y).curve(d3Shape7.curveBasis);
     PROP_DISPLAY = {
       "cache-hit": "cache hit",
-      "firewall-block": "fw block",
-      "ratelimit-rps": "rate limit",
+      "firewall-block": "firewall block",
+      "ratelimit-rps": "rate limit RPS",
       "latency-ms": "latency",
       "uptime": "uptime",
       "instances": "instances",
-      "max-rps": "capacity",
-      "cb-error-threshold": "CB error",
-      "cb-latency-threshold-ms": "CB latency",
+      "max-rps": "max RPS",
+      "cb-error-threshold": "CB error threshold",
+      "cb-latency-threshold-ms": "CB latency threshold",
       "concurrency": "concurrency",
       "duration-ms": "duration",
       "cold-start-ms": "cold start",
       "buffer": "buffer",
-      "drain-rate": "drain",
+      "drain-rate": "drain rate",
       "retention-hours": "retention",
       "partitions": "partitions"
     };
+    DESC_MAX_CHARS = 120;
     RPS_FORMAT_KEYS = /* @__PURE__ */ new Set(["max-rps", "ratelimit-rps"]);
     MS_FORMAT_KEYS = /* @__PURE__ */ new Set(["latency-ms", "cb-latency-threshold-ms", "duration-ms", "cold-start-ms"]);
     PCT_FORMAT_KEYS = /* @__PURE__ */ new Set(["cache-hit", "firewall-block", "uptime", "cb-error-threshold"]);
@@ -16486,7 +16887,7 @@ function renderState(container, graph, layout, palette, isDark, onClickItem, exp
       const w = node.width;
       const h = node.height;
       nodeG.append("rect").attr("x", -w / 2).attr("y", -h / 2).attr("width", w).attr("height", h).attr("rx", STATE_CORNER_RADIUS).attr("ry", STATE_CORNER_RADIUS).attr("fill", stateFill(palette, isDark, node.color, colorOff)).attr("stroke", stateStroke(palette, node.color, colorOff)).attr("stroke-width", NODE_STROKE_WIDTH9);
-      nodeG.append("text").attr("x", 0).attr("y", 0).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", palette.text).attr("font-size", NODE_FONT_SIZE4).text(node.label);
+      nodeG.append("text").attr("x", 0).attr("y", 0).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", palette.text).attr("font-size", NODE_FONT_SIZE5).text(node.label);
     }
   }
 }
@@ -16525,7 +16926,7 @@ function renderStateForExport(content, theme, palette) {
     document.body.removeChild(container);
   }
 }
-var d3Selection10, d3Shape8, DIAGRAM_PADDING9, MAX_SCALE8, NODE_FONT_SIZE4, EDGE_LABEL_FONT_SIZE8, GROUP_LABEL_FONT_SIZE3, EDGE_STROKE_WIDTH9, NODE_STROKE_WIDTH9, ARROWHEAD_W4, ARROWHEAD_H4, PSEUDOSTATE_RADIUS, STATE_CORNER_RADIUS, GROUP_EXTRA_PADDING2, lineGenerator8;
+var d3Selection10, d3Shape8, DIAGRAM_PADDING9, MAX_SCALE8, NODE_FONT_SIZE5, EDGE_LABEL_FONT_SIZE8, GROUP_LABEL_FONT_SIZE3, EDGE_STROKE_WIDTH9, NODE_STROKE_WIDTH9, ARROWHEAD_W4, ARROWHEAD_H4, PSEUDOSTATE_RADIUS, STATE_CORNER_RADIUS, GROUP_EXTRA_PADDING2, lineGenerator8;
 var init_state_renderer = __esm({
   "src/graph/state-renderer.ts"() {
     "use strict";
@@ -16537,7 +16938,7 @@ var init_state_renderer = __esm({
     init_layout7();
     DIAGRAM_PADDING9 = 20;
     MAX_SCALE8 = 3;
-    NODE_FONT_SIZE4 = 13;
+    NODE_FONT_SIZE5 = 13;
     EDGE_LABEL_FONT_SIZE8 = 11;
     GROUP_LABEL_FONT_SIZE3 = 11;
     EDGE_STROKE_WIDTH9 = 1.5;
@@ -18144,7 +18545,6 @@ function parseD3(content, palette) {
     timelineSwimlanes: false,
     vennSets: [],
     vennOverlaps: [],
-    vennShowValues: false,
     quadrantLabels: {
       topRight: null,
       topLeft: null,
@@ -18166,6 +18566,9 @@ function parseD3(content, palette) {
     result.error = formatDgmoError(diag);
     return result;
   };
+  const warn = (line10, message) => {
+    result.diagnostics.push(makeDgmoError(line10, message, "warning"));
+  };
   if (!content || !content.trim()) {
     return fail(0, "Empty content");
   }
@@ -18361,25 +18764,38 @@ function parseD3(content, palette) {
       }
     }
     if (result.type === "venn") {
-      const overlapMatch = line10.match(
-        /^(.+?&.+?)\s*:\s*(\d+(?:\.\d+)?)\s*(?:"([^"]*)")?\s*$/
-      );
-      if (overlapMatch) {
-        const sets = overlapMatch[1].split("&").map((s) => s.trim()).filter(Boolean).sort();
-        const size = parseFloat(overlapMatch[2]);
-        const label = overlapMatch[3] ?? null;
-        result.vennOverlaps.push({ sets, size, label, lineNumber });
-        continue;
+      if (/\+/.test(line10)) {
+        const colonIdx = line10.indexOf(":");
+        let setsPart;
+        let label;
+        if (colonIdx >= 0) {
+          setsPart = line10.substring(0, colonIdx).trim();
+          label = line10.substring(colonIdx + 1).trim() || null;
+        } else {
+          setsPart = line10.trim();
+          label = null;
+        }
+        const rawSets = setsPart.split("+").map((s) => s.trim()).filter(Boolean);
+        if (rawSets.length >= 2) {
+          result.vennOverlaps.push({ sets: rawSets, label, lineNumber });
+          continue;
+        }
       }
-      const setMatch = line10.match(
-        /^(.+?)(?:\(([^)]+)\))?\s*:\s*(\d+(?:\.\d+)?)\s*(?:"([^"]*)")?\s*$/
-      );
-      if (setMatch) {
-        const name = setMatch[1].trim();
-        const color = setMatch[2] ? resolveColor(setMatch[2].trim(), palette) : null;
-        const size = parseFloat(setMatch[3]);
-        const label = setMatch[4] ?? null;
-        result.vennSets.push({ name, size, color, label, lineNumber });
+      const setDeclMatch = line10.match(/^([^(:]+?)(?:\(([^)]+)\))?(?:\s+alias\s+(\S+))?\s*$/i);
+      if (setDeclMatch) {
+        const name = setDeclMatch[1].trim();
+        const colorName = setDeclMatch[2]?.trim() ?? null;
+        let color = null;
+        if (colorName) {
+          const resolved = resolveColor(colorName, palette);
+          if (resolved.startsWith("#")) {
+            color = resolved;
+          } else {
+            warn(lineNumber, `Unknown color "${colorName}" on set "${name}". Using auto-assigned color.`);
+          }
+        }
+        const alias = setDeclMatch[3]?.trim() ?? null;
+        result.vennSets.push({ name, alias, color, lineNumber });
         continue;
       }
     }
@@ -18519,15 +18935,6 @@ function parseD3(content, palette) {
         }
         continue;
       }
-      if (key === "values") {
-        const v = line10.substring(colonIndex + 1).trim().toLowerCase();
-        if (v === "off") {
-          result.vennShowValues = false;
-        } else if (v === "on") {
-          result.vennShowValues = true;
-        }
-        continue;
-      }
       if (key === "rotate") {
         const v = line10.substring(colonIndex + 1).trim().toLowerCase();
         if (v === "none" || v === "mixed" || v === "angled") {
@@ -18605,9 +19012,6 @@ function parseD3(content, palette) {
   if (result.type === "sequence") {
     return result;
   }
-  const warn = (line10, message) => {
-    result.diagnostics.push(makeDgmoError(line10, message, "warning"));
-  };
   if (result.type === "wordcloud") {
     if (result.words.length === 0 && freeformLines.length > 0) {
       result.words = tokenizeFreeformText(freeformLines.join(" "));
@@ -18679,29 +19083,34 @@ function parseD3(content, palette) {
   }
   if (result.type === "venn") {
     if (result.vennSets.length < 2) {
-      return fail(1, 'At least 2 sets are required. Add sets as "Name: size" (e.g., "Math: 100")');
+      return fail(1, 'At least 2 sets are required. Add set names (e.g., "Apples", "Oranges")');
     }
     if (result.vennSets.length > 3) {
-      return fail(1, "At most 3 sets are supported. Remove extra sets.");
+      return fail(1, "Venn diagrams support 2\u20133 sets");
+    }
+    const setNameLower = new Map(
+      result.vennSets.map((s) => [s.name.toLowerCase(), s.name])
+    );
+    const aliasLower = /* @__PURE__ */ new Map();
+    for (const s of result.vennSets) {
+      if (s.alias) aliasLower.set(s.alias.toLowerCase(), s.name);
     }
-    const setMap = new Map(result.vennSets.map((s) => [s.name, s.size]));
+    const resolveSetRef = (ref) => setNameLower.get(ref.toLowerCase()) ?? aliasLower.get(ref.toLowerCase()) ?? null;
     const validOverlaps = [];
     for (const ov of result.vennOverlaps) {
+      const resolvedSets = [];
       let valid = true;
-      for (const setName of ov.sets) {
-        if (!setMap.has(setName)) {
-          result.diagnostics.push(makeDgmoError(ov.lineNumber, `Overlap references unknown set "${setName}". Define it first as "${setName}: <size>"`));
+      for (const ref of ov.sets) {
+        const resolved = resolveSetRef(ref);
+        if (!resolved) {
+          result.diagnostics.push(makeDgmoError(ov.lineNumber, `Intersection references unknown set or alias "${ref}"`));
           if (!result.error) result.error = formatDgmoError(result.diagnostics[result.diagnostics.length - 1]);
           valid = false;
           break;
         }
+        resolvedSets.push(resolved);
       }
-      if (!valid) continue;
-      const minSetSize = Math.min(...ov.sets.map((s) => setMap.get(s)));
-      if (ov.size > minSetSize) {
-        warn(ov.lineNumber, `Overlap size ${ov.size} exceeds smallest constituent set size ${minSetSize}`);
-      }
-      validOverlaps.push(ov);
+      if (valid) validOverlaps.push({ ...ov, sets: resolvedSets.sort() });
     }
     result.vennOverlaps = validOverlaps;
     return result;
@@ -19855,7 +20264,7 @@ function renderTimeline(container, parsed, palette, isDark, onClickItem, exportD
     return;
   }
   const BAR_H = 22;
-  const GROUP_GAP = 12;
+  const GROUP_GAP2 = 12;
   const useGroupedHorizontal = tagLanes != null || timelineSort === "group" && timelineGroups.length > 0;
   if (useGroupedHorizontal) {
     let lanes;
@@ -19888,7 +20297,7 @@ function renderTimeline(container, parsed, palette, isDark, onClickItem, exportD
     };
     const innerWidth = width - margin.left - margin.right;
     const innerHeight = height - margin.top - margin.bottom;
-    const totalGaps = (lanes.length - 1) * GROUP_GAP;
+    const totalGaps = (lanes.length - 1) * GROUP_GAP2;
     const rowH = Math.min(28, (innerHeight - totalGaps) / totalEventRows);
     const xScale = d3Scale.scaleLinear().domain([minDate - datePadding, maxDate + datePadding]).range([0, innerWidth]);
     const svg = d3Selection12.select(container).append("svg").attr("width", width).attr("height", height).style("background", bgColor);
@@ -19938,8 +20347,8 @@ function renderTimeline(container, parsed, palette, isDark, onClickItem, exportD
       lanes.forEach((lane, idx) => {
         const laneSpan = lane.events.length * rowH;
         const fillColor = idx % 2 === 0 ? textColor : "transparent";
-        g.append("rect").attr("class", "tl-swimlane").attr("data-group", lane.name).attr("x", -margin.left).attr("y", swimY).attr("width", innerWidth + margin.left).attr("height", laneSpan + (idx < lanes.length - 1 ? GROUP_GAP : 0)).attr("fill", fillColor).attr("opacity", 0.06);
-        swimY += laneSpan + GROUP_GAP;
+        g.append("rect").attr("class", "tl-swimlane").attr("data-group", lane.name).attr("x", -margin.left).attr("y", swimY).attr("width", innerWidth + margin.left).attr("height", laneSpan + (idx < lanes.length - 1 ? GROUP_GAP2 : 0)).attr("fill", fillColor).attr("opacity", 0.06);
+        swimY += laneSpan + GROUP_GAP2;
       });
     }
     for (const lane of lanes) {
@@ -20020,7 +20429,7 @@ function renderTimeline(container, parsed, palette, isDark, onClickItem, exportD
           evG.append("text").attr("x", flipLeft ? x - 10 : x + 10).attr("y", y).attr("dy", "0.35em").attr("text-anchor", flipLeft ? "end" : "start").attr("fill", textColor).attr("font-size", "12px").text(ev.label);
         }
       });
-      curY += laneSpan + GROUP_GAP;
+      curY += laneSpan + GROUP_GAP2;
     }
   } else {
     const sorted = timelineEvents.slice().sort((a, b) => parseTimelineDate(a.date) - parseTimelineDate(b.date));
@@ -20203,18 +20612,19 @@ function renderTimeline(container, parsed, palette, isDark, onClickItem, exportD
         );
       }, drawLegend2 = function() {
         mainSvg.selectAll(".tl-tag-legend-group").remove();
+        const effectiveColorKey = (currentActiveGroup ?? currentSwimlaneGroup)?.toLowerCase() ?? null;
         const visibleGroups = viewMode ? legendGroups.filter(
-          (lg) => currentActiveGroup != null && lg.group.name.toLowerCase() === currentActiveGroup.toLowerCase()
+          (lg) => effectiveColorKey != null && lg.group.name.toLowerCase() === effectiveColorKey
         ) : legendGroups;
         if (visibleGroups.length === 0) return;
         const totalW = visibleGroups.reduce((s, lg) => {
-          const isActive = currentActiveGroup != null && lg.group.name.toLowerCase() === currentActiveGroup.toLowerCase();
+          const isActive = viewMode || currentActiveGroup != null && lg.group.name.toLowerCase() === currentActiveGroup.toLowerCase();
           return s + (isActive ? lg.expandedWidth : lg.minifiedWidth);
         }, 0) + (visibleGroups.length - 1) * LG_GROUP_GAP;
         let cx = (width - totalW) / 2;
         for (const lg of visibleGroups) {
           const groupKey = lg.group.name.toLowerCase();
-          const isActive = currentActiveGroup != null && currentActiveGroup.toLowerCase() === groupKey;
+          const isActive = viewMode || currentActiveGroup != null && currentActiveGroup.toLowerCase() === groupKey;
           const isSwimActive = currentSwimlaneGroup != null && currentSwimlaneGroup.toLowerCase() === groupKey;
           const pillLabel = lg.group.name;
           const pillWidth = pillLabel.length * LG_PILL_FONT_W + LG_PILL_PAD;
@@ -20422,49 +20832,6 @@ function renderWordCloudAsync(container, parsed, palette, _isDark, exportDims) {
     }).start();
   });
 }
-function radiusFromArea(area) {
-  return Math.sqrt(area / Math.PI);
-}
-function circleOverlapArea(r1, r2, d) {
-  if (d >= r1 + r2) return 0;
-  if (d + Math.min(r1, r2) <= Math.max(r1, r2)) {
-    return Math.PI * Math.min(r1, r2) ** 2;
-  }
-  const part1 = r1 * r1 * Math.acos((d * d + r1 * r1 - r2 * r2) / (2 * d * r1));
-  const part2 = r2 * r2 * Math.acos((d * d + r2 * r2 - r1 * r1) / (2 * d * r2));
-  const part3 = 0.5 * Math.sqrt((-d + r1 + r2) * (d + r1 - r2) * (d - r1 + r2) * (d + r1 + r2));
-  return part1 + part2 - part3;
-}
-function distanceForOverlap(r1, r2, targetArea) {
-  if (targetArea <= 0) return r1 + r2;
-  const minR = Math.min(r1, r2);
-  if (targetArea >= Math.PI * minR * minR) return Math.abs(r1 - r2);
-  let lo = Math.abs(r1 - r2);
-  let hi = r1 + r2;
-  for (let i = 0; i < 64; i++) {
-    const mid = (lo + hi) / 2;
-    if (circleOverlapArea(r1, r2, mid) > targetArea) {
-      lo = mid;
-    } else {
-      hi = mid;
-    }
-  }
-  return (lo + hi) / 2;
-}
-function thirdCirclePosition(ax, ay, dAC, bx, by, dBC) {
-  const dx = bx - ax;
-  const dy = by - ay;
-  const dAB = Math.sqrt(dx * dx + dy * dy);
-  if (dAB === 0) return { x: ax + dAC, y: ay };
-  const cosA = (dAB * dAB + dAC * dAC - dBC * dBC) / (2 * dAB * dAC);
-  const sinA = Math.sqrt(Math.max(0, 1 - cosA * cosA));
-  const ux = dx / dAB;
-  const uy = dy / dAB;
-  return {
-    x: ax + dAC * (cosA * ux - sinA * uy),
-    y: ay + dAC * (cosA * uy + sinA * ux)
-  };
-}
 function fitCirclesToContainerAsymmetric(circles, w, h, mLeft, mRight, mTop, mBottom) {
   if (circles.length === 0) return [];
   let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
@@ -20539,54 +20906,28 @@ function regionCentroid(circles, inside) {
   return { x: sx / count, y: sy / count };
 }
 function renderVenn(container, parsed, palette, isDark, onClickItem, exportDims) {
-  const { vennSets, vennOverlaps, vennShowValues, title } = parsed;
+  const { vennSets, vennOverlaps, title } = parsed;
   if (vennSets.length < 2) return;
   const init2 = initD3Chart(container, palette, exportDims);
   if (!init2) return;
   const { svg, width, height, textColor, colors } = init2;
   const titleHeight = title ? 40 : 0;
-  const radii = vennSets.map((s) => radiusFromArea(s.size));
-  const overlapMap = /* @__PURE__ */ new Map();
-  for (const ov of vennOverlaps) {
-    overlapMap.set(ov.sets.join("&"), ov.size);
-  }
-  let rawCircles;
   const n = vennSets.length;
+  const BASE_R = 100;
+  const OVERLAP_DISTANCE = BASE_R * 1.4;
+  let rawCircles;
   if (n === 2) {
-    const d = distanceForOverlap(
-      radii[0],
-      radii[1],
-      overlapMap.get([vennSets[0].name, vennSets[1].name].sort().join("&")) ?? 0
-    );
     rawCircles = [
-      { x: -d / 2, y: 0, r: radii[0] },
-      { x: d / 2, y: 0, r: radii[1] }
+      { x: -OVERLAP_DISTANCE / 2, y: 0, r: BASE_R },
+      { x: OVERLAP_DISTANCE / 2, y: 0, r: BASE_R }
     ];
   } else {
-    const names = vennSets.map((s) => s.name);
-    const pairKey = (i, j) => [names[i], names[j]].sort().join("&");
-    const dAB = distanceForOverlap(
-      radii[0],
-      radii[1],
-      overlapMap.get(pairKey(0, 1)) ?? 0
-    );
-    const dAC = distanceForOverlap(
-      radii[0],
-      radii[2],
-      overlapMap.get(pairKey(0, 2)) ?? 0
-    );
-    const dBC = distanceForOverlap(
-      radii[1],
-      radii[2],
-      overlapMap.get(pairKey(1, 2)) ?? 0
-    );
-    const ax = -dAB / 2;
-    const bx = dAB / 2;
-    const cPos = thirdCirclePosition(ax, 0, dAC, bx, 0, dBC);
+    const s = OVERLAP_DISTANCE;
+    const h = Math.sqrt(3) / 2 * s;
     rawCircles = [
-      { x: ax, y: 0, r: radii[0] },
-      { x: bx, y: 0, r: radii[1] },
-      { x: cPos.x, y: cPos.y, r: radii[2] }
+      { x: -s / 2, y: h / 3, r: BASE_R },
+      { x: s / 2, y: h / 3, r: BASE_R },
+      { x: 0, y: -(2 * h) / 3, r: BASE_R }
     ];
   }
   const setColors = vennSets.map(
@@ -20599,8 +20940,7 @@ function renderVenn(container, parsed, palette, isDark, onClickItem, exportDims)
   const edgePad = 8;
   const labelTextPad = 4;
   for (let i = 0; i < n; i++) {
-    const displayName = vennSets[i].label ?? vennSets[i].name;
-    const estimatedWidth = displayName.length * 8.5 + stubLen + edgePad + labelTextPad;
+    const estimatedWidth = vennSets[i].name.length * 8.5 + stubLen + edgePad + labelTextPad;
     const dx = rawCircles[i].x - clusterCx;
     const dy = rawCircles[i].y - clusterCy;
     if (Math.abs(dx) >= Math.abs(dy)) {
@@ -20622,25 +20962,71 @@ function renderVenn(container, parsed, palette, isDark, onClickItem, exportDims)
     marginTop,
     marginBottom
   ).map((c) => ({ ...c, y: c.y + titleHeight }));
-  const tooltip = createTooltip(container, palette, isDark);
+  const scaledR = circles[0].r;
+  svg.append("style").text("circle:focus, circle:focus-visible { outline: none !important; }");
   renderChartTitle(svg, title, parsed.titleLineNumber, width, textColor, onClickItem);
   const circleEls = [];
   const circleGroup = svg.append("g");
   circles.forEach((c, i) => {
-    const el = circleGroup.append("circle").attr("cx", c.x).attr("cy", c.y).attr("r", c.r).attr("fill", setColors[i]).attr("fill-opacity", 0.35).attr("stroke", setColors[i]).attr("stroke-width", 2).style("pointer-events", "none");
+    const el = circleGroup.append("circle").attr("cx", c.x).attr("cy", c.y).attr("r", c.r).attr("fill", setColors[i]).attr("fill-opacity", 0.35).attr("stroke", setColors[i]).attr("stroke-width", 2).attr("class", "venn-fill-circle").attr("data-line-number", String(vennSets[i].lineNumber)).style("pointer-events", "none");
     circleEls.push(el);
   });
+  const defs = svg.append("defs");
+  circles.forEach((c, i) => {
+    defs.append("clipPath").attr("id", `vcp-${i}`).append("circle").attr("cx", c.x).attr("cy", c.y).attr("r", c.r);
+  });
+  const regionIdxSets = circles.map((_, i) => [i]);
+  if (n === 2) {
+    regionIdxSets.push([0, 1]);
+  } else {
+    regionIdxSets.push([0, 1], [0, 2], [1, 2], [0, 1, 2]);
+  }
+  const overlayGroup = svg.append("g").style("pointer-events", "none");
+  const overlayEls = /* @__PURE__ */ new Map();
+  for (const idxs of regionIdxSets) {
+    const key = idxs.join("-");
+    const excluded = Array.from({ length: n }, (_, j) => j).filter((j) => !idxs.includes(j));
+    let clipId = `vcp-${idxs[0]}`;
+    for (let k = 1; k < idxs.length; k++) {
+      const nestedId = `vcp-n-${idxs.slice(0, k + 1).join("-")}`;
+      const ci = idxs[k];
+      defs.append("clipPath").attr("id", nestedId).append("circle").attr("cx", circles[ci].x).attr("cy", circles[ci].y).attr("r", circles[ci].r).attr("clip-path", `url(#${clipId})`);
+      clipId = nestedId;
+    }
+    let regionLineNumber = null;
+    if (idxs.length === 1) {
+      regionLineNumber = vennSets[idxs[0]].lineNumber;
+    } else {
+      const sortedNames = idxs.map((i) => vennSets[i].name).sort();
+      const ov = vennOverlaps.find(
+        (o) => o.sets.length === sortedNames.length && o.sets.every((s, k) => s === sortedNames[k])
+      );
+      regionLineNumber = ov?.lineNumber ?? null;
+    }
+    const el = overlayGroup.append("rect").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height).attr("fill", "white").attr("fill-opacity", 0).attr("class", "venn-region-overlay").attr("clip-path", `url(#${clipId})`);
+    if (regionLineNumber != null) {
+      el.attr("data-line-number", String(regionLineNumber));
+    }
+    if (excluded.length > 0) {
+      const maskId = `vvm-${key}`;
+      const mask = defs.append("mask").attr("id", maskId);
+      mask.append("rect").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height).attr("fill", "white");
+      for (const j of excluded) {
+        mask.append("circle").attr("cx", circles[j].x).attr("cy", circles[j].y).attr("r", circles[j].r).attr("fill", "black");
+      }
+      el.attr("mask", `url(#${maskId})`);
+    }
+    overlayEls.set(key, el);
+  }
+  const showRegionOverlay = (idxs) => {
+    const key = [...idxs].sort((a, b) => a - b).join("-");
+    overlayEls.forEach((el, k) => el.attr("fill-opacity", k === key ? 0.3 : 0));
+  };
+  const hideAllOverlays = () => {
+    overlayEls.forEach((el) => el.attr("fill-opacity", 0));
+  };
   const gcx = circles.reduce((s, c) => s + c.x, 0) / n;
   const gcy = circles.reduce((s, c) => s + c.y, 0) / n;
-  function rayCircleExit(ox, oy, dx, dy, c) {
-    const lx = ox - c.x;
-    const ly = oy - c.y;
-    const b = lx * dx + ly * dy;
-    const det = b * b - (lx * lx + ly * ly - c.r * c.r);
-    if (det < 0) return 0;
-    return -b + Math.sqrt(det);
-  }
-  const labelGroup = svg.append("g").style("pointer-events", "none");
   function exclusiveHSpan(px, py, ci) {
     const dy = py - circles[ci].y;
     const halfChord = Math.sqrt(Math.max(0, circles[ci].r * circles[ci].r - dy * dy));
@@ -20663,8 +21049,9 @@ function renderVenn(container, parsed, palette, isDark, onClickItem, exportDims)
   const MIN_FONT = 10;
   const MAX_FONT = 22;
   const INTERNAL_PAD = 12;
+  const labelGroup = svg.append("g").style("pointer-events", "none");
   circles.forEach((c, i) => {
-    const text = vennSets[i].label ?? vennSets[i].name;
+    const text = vennSets[i].name;
     const inside = circles.map((_, j) => j === i);
     const centroid = regionCentroid(circles, inside);
     const availW = exclusiveHSpan(centroid.x, centroid.y, i);
@@ -20699,11 +21086,8 @@ function renderVenn(container, parsed, palette, isDark, onClickItem, exportDims)
       let textX = stubEndX + (isRight ? labelTextPad : -labelTextPad);
       const textY = stubEndY;
       const estW = text.length * 8.5;
-      if (isRight) {
-        textX = Math.min(textX, width - estW - 4);
-      } else {
-        textX = Math.max(textX, estW + 4);
-      }
+      if (isRight) textX = Math.min(textX, width - estW - 4);
+      else textX = Math.max(textX, estW + 4);
       labelGroup.append("text").attr("x", textX).attr("y", Math.max(14, Math.min(height - 4, textY))).attr("text-anchor", textAnchor).attr("dominant-baseline", "central").attr("fill", textColor).attr("font-size", "14px").attr("font-weight", "bold").text(text);
     }
   });
@@ -20731,40 +21115,57 @@ function renderVenn(container, parsed, palette, isDark, onClickItem, exportDims)
     return Math.max(0, right - left);
   }
   for (const ov of vennOverlaps) {
+    if (!ov.label) continue;
     const idxs = ov.sets.map((s) => vennSets.findIndex((vs) => vs.name === s));
     if (idxs.some((idx) => idx < 0)) continue;
-    if (!ov.label) continue;
     const inside = circles.map((_, j) => idxs.includes(j));
     const centroid = regionCentroid(circles, inside);
-    const text = ov.label;
     const availW = overlapHSpan(centroid.y, idxs);
     const fitFont = Math.min(MAX_FONT, Math.max(
       MIN_FONT,
-      (availW - INTERNAL_PAD * 2) / (text.length * CH_RATIO)
+      (availW - INTERNAL_PAD * 2) / (ov.label.length * CH_RATIO)
     ));
-    labelGroup.append("text").attr("x", centroid.x).attr("y", centroid.y).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", textColor).attr("font-size", `${Math.round(fitFont)}px`).attr("font-weight", "600").text(text);
+    labelGroup.append("text").attr("x", centroid.x).attr("y", centroid.y).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", textColor).attr("font-size", `${Math.round(fitFont)}px`).attr("font-weight", "600").text(ov.label);
   }
   const hoverGroup = svg.append("g");
   circles.forEach((c, i) => {
-    const tipName = vennSets[i].label ? `${vennSets[i].label} (${vennSets[i].name})` : vennSets[i].name;
-    const tipHtml = `<strong>${tipName}</strong><br>Size: ${vennSets[i].size}`;
-    hoverGroup.append("circle").attr("cx", c.x).attr("cy", c.y).attr("r", c.r).attr("fill", "transparent").attr("data-line-number", String(vennSets[i].lineNumber)).style("cursor", onClickItem ? "pointer" : "default").on("mouseenter", (event) => {
-      circleEls.forEach((el, ci) => {
-        el.attr("fill-opacity", ci === i ? 0.5 : 0.1);
-      });
-      showTooltip(tooltip, tipHtml, event);
-    }).on("mousemove", (event) => {
-      showTooltip(tooltip, tipHtml, event);
+    hoverGroup.append("circle").attr("cx", c.x).attr("cy", c.y).attr("r", c.r).attr("fill", "transparent").attr("stroke", "none").attr("class", "venn-hit-target").attr("data-line-number", String(vennSets[i].lineNumber)).style("cursor", onClickItem ? "pointer" : "default").style("outline", "none").on("mouseenter", () => {
+      showRegionOverlay([i]);
     }).on("mouseleave", () => {
-      circleEls.forEach((el) => {
-        el.attr("fill-opacity", 0.35);
-      });
-      hideTooltip(tooltip);
-    }).on("click", () => {
-      if (onClickItem && vennSets[i].lineNumber)
-        onClickItem(vennSets[i].lineNumber);
+      hideAllOverlays();
+    }).on("click", function() {
+      this.blur?.();
+      if (onClickItem && vennSets[i].lineNumber) onClickItem(vennSets[i].lineNumber);
     });
   });
+  const overlayR = scaledR * 0.35;
+  const subsets = [];
+  if (n === 2) {
+    subsets.push({ idxs: [0, 1], sets: [vennSets[0].name, vennSets[1].name].sort() });
+  } else {
+    for (let a = 0; a < n; a++) {
+      for (let b = a + 1; b < n; b++) {
+        subsets.push({ idxs: [a, b], sets: [vennSets[a].name, vennSets[b].name].sort() });
+      }
+    }
+    subsets.push({ idxs: [0, 1, 2], sets: [vennSets[0].name, vennSets[1].name, vennSets[2].name].sort() });
+  }
+  for (const subset of subsets) {
+    const { idxs, sets } = subset;
+    const inside = circles.map((_, j) => idxs.includes(j));
+    const centroid = regionCentroid(circles, inside);
+    const declaredOv = vennOverlaps.find(
+      (ov) => ov.sets.length === sets.length && ov.sets.every((s, k) => s === sets[k])
+    );
+    hoverGroup.append("circle").attr("cx", centroid.x).attr("cy", centroid.y).attr("r", overlayR).attr("fill", "transparent").attr("stroke", "none").attr("class", "venn-hit-target").attr("data-line-number", declaredOv ? String(declaredOv.lineNumber) : "").style("cursor", onClickItem && declaredOv ? "pointer" : "default").style("outline", "none").on("mouseenter", () => {
+      showRegionOverlay(idxs);
+    }).on("mouseleave", () => {
+      hideAllOverlays();
+    }).on("click", function() {
+      this.blur?.();
+      if (onClickItem && declaredOv) onClickItem(declaredOv.lineNumber);
+    });
+  }
 }
 function renderQuadrant(container, parsed, palette, isDark, onClickItem, exportDims) {
   const {
@@ -20872,8 +21273,8 @@ function renderQuadrant(container, parsed, palette, isDark, onClickItem, exportD
   const LABEL_MAX_FONT = 48;
   const LABEL_MIN_FONT = 14;
   const LABEL_PAD = 40;
-  const CHAR_WIDTH_RATIO2 = 0.6;
-  const estTextWidth = (text, fontSize) => text.length * fontSize * CHAR_WIDTH_RATIO2;
+  const CHAR_WIDTH_RATIO3 = 0.6;
+  const estTextWidth = (text, fontSize) => text.length * fontSize * CHAR_WIDTH_RATIO3;
   const quadrantLabelLayout = (text, qw2, qh2) => {
     const availW = qw2 - LABEL_PAD;
     const availH = qh2 - LABEL_PAD;
@@ -21495,6 +21896,7 @@ __export(index_exports, {
   buildRenderSequence: () => buildRenderSequence,
   buildThemeCSS: () => buildThemeCSS,
   catppuccinPalette: () => catppuccinPalette,
+  collapseInitiativeStatus: () => collapseInitiativeStatus,
   collapseOrgTree: () => collapseOrgTree,
   collapseSitemapTree: () => collapseSitemapTree,
   collectDiagramRoles: () => collectDiagramRoles,
@@ -21843,6 +22245,43 @@ init_renderer7();
 init_parser7();
 init_layout5();
 init_renderer6();
+
+// src/initiative-status/collapse.ts
+init_layout5();
+function collapseInitiativeStatus(parsed, collapsedGroups) {
+  const originalGroups = parsed.groups;
+  if (collapsedGroups.size === 0) {
+    return { parsed, collapsedGroupStatuses: /* @__PURE__ */ new Map(), originalGroups };
+  }
+  const nodeToGroup = /* @__PURE__ */ new Map();
+  const collapsedGroupStatuses = /* @__PURE__ */ new Map();
+  for (const group of parsed.groups) {
+    if (!collapsedGroups.has(group.label)) continue;
+    const children = group.nodeLabels.map((l) => parsed.nodes.find((n) => n.label === l)).filter((n) => n !== void 0);
+    for (const node of children) nodeToGroup.set(node.label, group.label);
+    collapsedGroupStatuses.set(group.label, rollUpStatus(children));
+  }
+  const nodes = parsed.nodes.filter((n) => !nodeToGroup.has(n.label));
+  const edgeKeys = /* @__PURE__ */ new Set();
+  const edges = [];
+  for (const edge of parsed.edges) {
+    const src = nodeToGroup.get(edge.source) ?? edge.source;
+    const tgt = nodeToGroup.get(edge.target) ?? edge.target;
+    if (src === tgt) continue;
+    const key = `${src}|${tgt}|${edge.label ?? ""}`;
+    if (edgeKeys.has(key)) continue;
+    edgeKeys.add(key);
+    edges.push({ ...edge, source: src, target: tgt });
+  }
+  const groups = parsed.groups.filter((g) => !collapsedGroups.has(g.label));
+  return {
+    parsed: { ...parsed, nodes, edges, groups },
+    collapsedGroupStatuses,
+    originalGroups
+  };
+}
+
+// src/index.ts
 init_parser8();
 init_layout2();
 init_renderer2();
@@ -22100,7 +22539,7 @@ async function resolveFile(content, filePath, readFileFn, diagnostics, ancestorC
       continue;
     }
     if (isTagBlockHeading(trimmed)) continue;
-    if (lines[i] !== trimmed) continue;
+    if (/^\s/.test(lines[i])) continue;
     const tagsMatch = trimmed.match(TAGS_RE);
     if (tagsMatch) {
       tagsDirective = tagsMatch[1].trim();
@@ -22339,6 +22778,12 @@ function encodeDiagramUrl(dsl, options) {
   if (options?.viewState?.swimlaneTagGroup) {
     hash += `&swim=${encodeURIComponent(options.viewState.swimlaneTagGroup)}`;
   }
+  if (options?.viewState?.palette && options.viewState.palette !== "nord") {
+    hash += `&pal=${encodeURIComponent(options.viewState.palette)}`;
+  }
+  if (options?.viewState?.theme && options.viewState.theme !== "dark") {
+    hash += `&th=${encodeURIComponent(options.viewState.theme)}`;
+  }
   return { url: `${baseUrl}?${hash}#${hash}` };
 }
 function decodeDiagramUrl(hash) {
@@ -22365,6 +22810,8 @@ function decodeDiagramUrl(hash) {
     if (key === "swim" && val) {
       viewState.swimlaneTagGroup = val;
     }
+    if (key === "pal" && val) viewState.palette = val;
+    if (key === "th" && (val === "light" || val === "dark")) viewState.theme = val;
   }
   if (payload.startsWith("dgmo=")) {
     payload = payload.slice(5);
@@ -22398,6 +22845,7 @@ init_branding();
   buildRenderSequence,
   buildThemeCSS,
   catppuccinPalette,
+  collapseInitiativeStatus,
   collapseOrgTree,
   collapseSitemapTree,
   collectDiagramRoles,