npm - @diagrammo/dgmo - Versions diffs - 0.5.3 → 0.5.5 - Mend

@diagrammo/dgmo 0.5.3 → 0.5.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/README.md +16 -16
package/dist/cli.cjs +158 -158
package/dist/index.cjs +762 -318
package/dist/index.cjs.map +1 -1
package/dist/index.d.cts +37 -23
package/dist/index.d.ts +37 -23
package/dist/index.js +761 -318
package/dist/index.js.map +1 -1
package/docs/language-reference.md +20 -2
package/package.json +1 -1
package/src/d3.ts +236 -204
package/src/index.ts +3 -0
package/src/infra/compute.ts +88 -10
package/src/infra/layout.ts +97 -12
package/src/infra/parser.ts +47 -4
package/src/infra/renderer.ts +216 -42
package/src/infra/roles.ts +15 -0
package/src/infra/types.ts +7 -0
package/src/initiative-status/collapse.ts +76 -0
package/src/initiative-status/layout.ts +193 -26
package/src/initiative-status/renderer.ts +94 -46
package/src/org/layout.ts +5 -2
package/src/org/renderer.ts +65 -11
package/src/org/resolver.ts +1 -1
package/src/sharing.ts +12 -0

package/dist/index.js CHANGED Viewed

@@ -6861,7 +6861,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"]);
   }
@@ -6997,6 +7000,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();
@@ -7141,12 +7156,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;
@@ -7156,7 +7178,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) {
@@ -7169,14 +7197,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}'.`;
@@ -7278,12 +7312,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.]+)%$/;
@@ -7518,7 +7552,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;
@@ -7531,7 +7565,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,
@@ -8164,7 +8199,7 @@ function layoutOrg(parsed, hiddenCounts, activeTagGroup, hiddenAttributes, expan
     height: finalHeight
   };
 }
-var 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 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";
@@ -8194,6 +8229,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;
   }
 });
@@ -8296,22 +8333,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);
@@ -8326,7 +8368,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);
@@ -8454,7 +8496,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();
@@ -8475,8 +8517,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);
@@ -8522,7 +8575,7 @@ function renderOrgForExport(content, theme, palette) {
     document.body.removeChild(container);
   }
 }
-var 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 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";
@@ -8560,7 +8613,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";
   }
 });
@@ -8610,7 +8667,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,
@@ -9012,7 +9069,7 @@ function layoutSitemap(parsed, hiddenCounts, activeTagGroup, hiddenAttributes, e
     height: totalHeight
   };
 }
-var 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 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";
@@ -9039,8 +9096,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;
   }
 });
@@ -9394,15 +9451,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");
@@ -9455,7 +9512,7 @@ async function renderSitemapForExport(content, theme, palette) {
   const brandColor = theme === "transparent" ? "#888" : effectivePalette.textMuted;
   return injectBranding2(svgHtml, brandColor);
 }
-var 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 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";
@@ -9494,11 +9551,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";
   }
 });
@@ -10734,7 +10791,8 @@ var init_renderer5 = __esm({
 // src/initiative-status/layout.ts
 var layout_exports5 = {};
 __export(layout_exports5, {
-  layoutInitiativeStatus: () => layoutInitiativeStatus
+  layoutInitiativeStatus: () => layoutInitiativeStatus,
+  rollUpStatus: () => rollUpStatus
 });
 import dagre4 from "@dagrejs/dagre";
 function rollUpStatus(members) {
@@ -10749,14 +10807,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 dagre4.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" });
   }
@@ -10787,38 +10859,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) {
@@ -10842,7 +11006,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
       });
     }
   }
@@ -10868,7 +11033,7 @@ function layoutInitiativeStatus(parsed) {
   totalHeight += 40;
   return { nodes: layoutNodes, edges: layoutEdges, groups: layoutGroups, width: totalWidth, height: totalHeight };
 }
-var STATUS_PRIORITY, PHI, NODE_HEIGHT, NODE_WIDTH, GROUP_PADDING, NODESEP, RANKSEP;
+var 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";
@@ -10879,6 +11044,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;
   }
 });
@@ -10936,10 +11109,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;
@@ -11000,8 +11173,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 };
 }
@@ -11224,21 +11397,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++) {
@@ -11249,7 +11428,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);
@@ -11329,7 +11508,7 @@ function renderInitiativeStatusForExport(content, theme, palette) {
     document.body.removeChild(container);
   }
 }
-var 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 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";
@@ -11339,19 +11518,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);
   }
 });
@@ -14129,7 +14309,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) {
@@ -14167,7 +14347,7 @@ function renderFlowchartForExport(content, theme, palette) {
     document.body.removeChild(container);
   }
 }
-var 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 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";
@@ -14177,7 +14357,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;
@@ -14365,23 +14545,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;
@@ -14412,6 +14595,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;
@@ -14644,8 +14880,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) {
@@ -14654,7 +14892,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;
@@ -14750,6 +14988,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) {
@@ -14760,20 +14999,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
             });
           }
         }
@@ -14928,6 +15167,7 @@ function computeInfra(parsed, params = {}) {
       queueMetrics,
       properties: node.properties,
       tags: node.tags,
+      description: node.description,
       lineNumber: node.lineNumber
     };
   });
@@ -14952,6 +15192,7 @@ function computeInfra(parsed, params = {}) {
       label: edge.label,
       computedRps: rps,
       split: resolvedSplit,
+      fanout: edge.fanout,
       lineNumber: edge.lineNumber
     };
   });
@@ -14978,7 +15219,8 @@ var init_compute = __esm({
 // src/infra/layout.ts
 var layout_exports8 = {};
 __export(layout_exports8, {
-  layoutInfra: () => layoutInfra
+  layoutInfra: () => layoutInfra,
+  separateGroups: () => separateGroups
 });
 import dagre7 from "@dagrejs/dagre";
 function countDisplayProps(node, expanded, options) {
@@ -15045,7 +15287,7 @@ function computeNodeWidth2(node, expanded, options) {
       if (expanded) {
         allKeys.push("p50", "p90", "p99");
       } else {
-        allKeys.push("p99");
+        allKeys.push("p90");
       }
     }
     if (node.computedUptime < 1) {
@@ -15087,13 +15329,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);
@@ -15106,21 +15356,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) {
@@ -15147,7 +15402,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 };
   }
@@ -15169,7 +15453,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);
@@ -15230,6 +15514,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
       queueMetrics: node.queueMetrics,
       properties: node.properties,
       tags: node.tags,
+      description: node.description,
       lineNumber: node.lineNumber
     };
   });
@@ -15244,6 +15529,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
         label: edge.label,
         computedRps: edge.computedRps,
         split: edge.split,
+        fanout: edge.fanout,
         points: edgeData?.points ?? [],
         lineNumber: edge.lineNumber
       });
@@ -15255,6 +15541,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
         label: edge.label,
         computedRps: edge.computedRps,
         split: edge.split,
+        fanout: edge.fanout,
         points: edgeData?.points ?? [],
         lineNumber: edge.lineNumber
       });
@@ -15296,6 +15583,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;
@@ -15357,7 +15645,7 @@ function layoutInfra(computed, selectedNodeId, collapsedNodes) {
     height: totalHeight
   };
 }
-var 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 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";
@@ -15367,7 +15655,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;
@@ -15395,11 +15683,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",
@@ -15410,6 +15698,7 @@ var init_layout8 = __esm({
       "retention-hours": "retention",
       "partitions": "partitions"
     };
+    GROUP_GAP = 24;
   }
 });
@@ -15424,6 +15713,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 = [];
@@ -15437,7 +15733,7 @@ function collectDiagramRoles(allProperties) {
   }
   return roles;
 }
-var ROLE_RULES;
+var ROLE_RULES, FANOUT_ROLE;
 var init_roles = __esm({
   "src/infra/roles.ts"() {
     "use strict";
@@ -15450,6 +15746,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" };
   }
 });
@@ -15462,6 +15759,20 @@ __export(renderer_exports8, {
 });
 import * as d3Selection9 from "d3-selection";
 import * as d3Shape7 from "d3-shape";
+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;
@@ -15498,7 +15809,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);
@@ -15512,9 +15833,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");
@@ -15525,8 +15860,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 });
@@ -15614,7 +15958,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";
@@ -15625,8 +15969,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");
@@ -15644,10 +16002,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),
@@ -15662,6 +16024,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),
@@ -15755,10 +16124,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) {
@@ -15770,7 +16141,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";
@@ -15787,26 +16157,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 = [];
@@ -15902,14 +16282,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++) {
@@ -15919,7 +16300,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");
       }
     }
   }
@@ -15988,9 +16369,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,
@@ -16045,7 +16429,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;
 }
@@ -16116,16 +16500,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;
@@ -16182,7 +16571,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);
   }
@@ -16204,7 +16600,7 @@ function parseAndLayoutInfra(content) {
   const layout = layoutInfra(computed);
   return { parsed, computed, layout };
 }
-var 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 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";
@@ -16215,7 +16611,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;
@@ -16228,7 +16624,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;
@@ -16242,6 +16638,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;
@@ -16260,22 +16660,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"]);
@@ -16466,7 +16867,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);
     }
   }
 }
@@ -16505,7 +16906,7 @@ function renderStateForExport(content, theme, palette) {
     document.body.removeChild(container);
   }
 }
-var 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 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";
@@ -16515,7 +16916,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;
@@ -18127,7 +18528,6 @@ function parseD3(content, palette) {
     timelineSwimlanes: false,
     vennSets: [],
     vennOverlaps: [],
-    vennShowValues: false,
     quadrantLabels: {
       topRight: null,
       topLeft: null,
@@ -18149,6 +18549,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");
   }
@@ -18344,25 +18747,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;
       }
     }
@@ -18502,15 +18918,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") {
@@ -18588,9 +18995,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(" "));
@@ -18662,29 +19066,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;
@@ -19838,7 +20247,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;
@@ -19871,7 +20280,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);
@@ -19921,8 +20330,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) {
@@ -20003,7 +20412,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));
@@ -20406,49 +20815,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;
@@ -20523,54 +20889,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(
@@ -20583,8 +20923,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)) {
@@ -20606,7 +20945,8 @@ 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");
@@ -20614,17 +20954,59 @@ function renderVenn(container, parsed, palette, isDark, onClickItem, exportDims)
     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");
     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("data-line-number", regionLineNumber != null ? String(regionLineNumber) : "0").attr("clip-path", `url(#${clipId})`);
+    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 : 0.55));
+  };
+  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));
@@ -20647,8 +21029,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);
@@ -20683,11 +21066,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);
     }
   });
@@ -20715,40 +21095,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 {
@@ -20856,8 +21253,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;
@@ -21680,6 +22077,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();
@@ -21937,7 +22371,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();
@@ -22179,6 +22613,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) {
@@ -22205,6 +22645,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);
@@ -22237,6 +22679,7 @@ export {
   buildRenderSequence,
   buildThemeCSS,
   catppuccinPalette,
+  collapseInitiativeStatus,
   collapseOrgTree,
   collapseSitemapTree,
   collectDiagramRoles,