@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-SRTU6HMQ.js

@@ -0,0 +1,1851 @@
+import {
+  renderInlineText
+} from "./chunk-3HDBAXF5.js";
+import {
+  wrapDescriptionLines
+} from "./chunk-BMR4CIEO.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-PWIHZ6NJ.js";
+import {
+  ScaleContext
+} from "./chunk-YYVTBZZC.js";
+import {
+  getMaxLegendReservedHeight
+} from "./chunk-YAA6IID3.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  measureText,
+  truncateText
+} from "./chunk-WCT3NYCV.js";
+import {
+  contrastText,
+  mix,
+  shapeFill,
+  themeBaseBg
+} from "./chunk-P6T66CCZ.js";
+import {
+  isSequenceBlock,
+  isSequenceNote,
+  isSequenceSection
+} from "./chunk-SML67VPV.js";
+import {
+  resolveActiveTagGroup,
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+
+// src/sequence/renderer.ts
+import * as d3Selection from "d3-selection";
+
+// src/sequence/collapse.ts
+function applyCollapseProjection(parsed, collapsedGroups) {
+  if (collapsedGroups.size === 0) {
+    return {
+      participants: parsed.participants,
+      messages: parsed.messages,
+      elements: parsed.elements,
+      groups: parsed.groups,
+      collapsedGroupIds: /* @__PURE__ */ new Map()
+    };
+  }
+  const memberToGroup = /* @__PURE__ */ new Map();
+  const collapsedGroupNames = /* @__PURE__ */ new Set();
+  for (const group of parsed.groups) {
+    if (collapsedGroups.has(group.lineNumber)) {
+      collapsedGroupNames.add(group.name);
+      for (const memberId of group.participantIds) {
+        memberToGroup.set(memberId, group.name);
+      }
+    }
+  }
+  const participants = [];
+  const insertedGroups = /* @__PURE__ */ new Set();
+  for (const p of parsed.participants) {
+    const groupName = memberToGroup.get(p.id);
+    if (groupName) {
+      if (!insertedGroups.has(groupName)) {
+        insertedGroups.add(groupName);
+        const group = parsed.groups.find(
+          (g) => g.name === groupName && collapsedGroups.has(g.lineNumber)
+        );
+        participants.push({
+          id: groupName,
+          // already ParticipantId from memberToGroup value type
+          label: groupName,
+          type: "default",
+          lineNumber: group.lineNumber
+        });
+      }
+    } else if (collapsedGroupNames.has(p.id)) {
+    } else {
+      participants.push(p);
+    }
+  }
+  const remap = (id) => memberToGroup.get(id) ?? id;
+  const messages = parsed.messages.map((msg) => ({
+    ...msg,
+    from: remap(msg.from),
+    to: remap(msg.to)
+  }));
+  const elements = remapElements(parsed.elements, memberToGroup);
+  const groups = parsed.groups.filter(
+    (g) => !collapsedGroups.has(g.lineNumber)
+  );
+  return {
+    participants,
+    messages,
+    elements,
+    groups,
+    collapsedGroupIds: memberToGroup
+  };
+}
+function remapElements(elements, memberToGroup) {
+  const remap = (id) => memberToGroup.get(id) ?? id;
+  const result = [];
+  for (const el of elements) {
+    if (isSequenceSection(el)) {
+      result.push(el);
+    } else if (isSequenceNote(el)) {
+      result.push({
+        ...el,
+        participantId: remap(el.participantId)
+      });
+    } else if (isSequenceBlock(el)) {
+      result.push({
+        ...el,
+        children: remapElements(el.children, memberToGroup),
+        elseChildren: remapElements(el.elseChildren, memberToGroup),
+        ...el.elseIfBranches ? {
+          elseIfBranches: el.elseIfBranches.map((branch) => ({
+            ...branch,
+            children: remapElements(branch.children, memberToGroup)
+          }))
+        } : {}
+      });
+    } else {
+      const msg = el;
+      const from = remap(msg.from);
+      const to = remap(msg.to);
+      if (from === to && from !== msg.from && !msg.label) {
+        continue;
+      }
+      result.push({ ...msg, from, to });
+    }
+  }
+  return result;
+}
+
+// src/sequence/tag-resolution.ts
+function propagateGroupTags(participantMeta, groups) {
+  for (const group of groups) {
+    if (!group.metadata) continue;
+    for (const id of group.participantIds) {
+      const meta = participantMeta.get(id);
+      if (!meta) continue;
+      for (const [key, value] of Object.entries(group.metadata)) {
+        if (!(key in meta)) {
+          meta[key] = value;
+        }
+      }
+    }
+  }
+}
+function computeReceiverInheritance(participants, messages, groupKey, participantMeta) {
+  const inheritance = /* @__PURE__ */ new Map();
+  for (const p of participants) {
+    const meta = participantMeta.get(p.id);
+    if (meta?.[groupKey]) continue;
+    const incomingValues = /* @__PURE__ */ new Set();
+    for (const msg of messages) {
+      if (msg.to === p.id && msg.metadata?.[groupKey]) {
+        incomingValues.add(msg.metadata[groupKey]);
+      }
+    }
+    if (incomingValues.size === 1) {
+      inheritance.set(p.id, [...incomingValues][0]);
+    }
+  }
+  return inheritance;
+}
+function resolveSequenceTags(parsed, activeTagGroup) {
+  const result = {
+    participants: /* @__PURE__ */ new Map(),
+    messages: /* @__PURE__ */ new Map()
+  };
+  const group = parsed.tagGroups.find(
+    (g) => g.name.toLowerCase() === activeTagGroup.toLowerCase()
+  );
+  if (!group) {
+    for (const p of parsed.participants) {
+      result.participants.set(p.id, void 0);
+    }
+    for (const m of parsed.messages) {
+      result.messages.set(m.lineNumber, void 0);
+    }
+    return result;
+  }
+  const groupKey = tagAttrKey(group.name);
+  const participantMeta = /* @__PURE__ */ new Map();
+  for (const p of parsed.participants) {
+    participantMeta.set(p.id, { ...p.metadata || {} });
+  }
+  propagateGroupTags(participantMeta, parsed.groups);
+  const inherited = computeReceiverInheritance(
+    parsed.participants,
+    parsed.messages,
+    groupKey,
+    participantMeta
+  );
+  for (const [id, value] of inherited) {
+    const meta = participantMeta.get(id);
+    meta[groupKey] = value;
+  }
+  if (group.defaultValue) {
+    for (const p of parsed.participants) {
+      const meta = participantMeta.get(p.id);
+      if (!(groupKey in meta)) {
+        meta[groupKey] = group.defaultValue;
+      }
+    }
+  }
+  for (const p of parsed.participants) {
+    const meta = participantMeta.get(p.id);
+    result.participants.set(p.id, meta[groupKey] || void 0);
+  }
+  for (const msg of parsed.messages) {
+    result.messages.set(msg.lineNumber, msg.metadata?.[groupKey] || void 0);
+  }
+  return result;
+}
+
+// src/sequence/renderer.ts
+var PARTICIPANT_GAP = 160;
+var PARTICIPANT_BOX_WIDTH = 120;
+var PARTICIPANT_BOX_HEIGHT = 50;
+var LABEL_FONT_SIZE = 13;
+var TOP_MARGIN = 20;
+var TITLE_HEIGHT = 30;
+var PARTICIPANT_Y_OFFSET = 10;
+var MESSAGE_START_OFFSET = 50;
+var LIFELINE_TAIL = 30;
+var ARROWHEAD_SIZE = 8;
+var NOTE_MAX_W = 200;
+var NOTE_FOLD = 10;
+var NOTE_PAD_H = 8;
+var NOTE_PAD_V = 6;
+var NOTE_FONT_SIZE = 10;
+var NOTE_LINE_H = 14;
+var NOTE_GAP = 15;
+var ACTIVATION_WIDTH = 10;
+var SELF_CALL_HEIGHT = 25;
+var SELF_CALL_WIDTH = 30;
+var ACTOR_LABEL_CLEARANCE = 22;
+function wrapTextLines(text, maxWidth, fontSize) {
+  const rawLines = text.split("\n").map((l) => l.startsWith("- ") ? "\u2022 " + l.slice(2) : l);
+  return wrapDescriptionLines(
+    rawLines,
+    maxWidth,
+    (s) => measureText(s, fontSize)
+  );
+}
+var labelTextWidth = (boxW) => boxW - 10;
+function splitParticipantLabel(label, maxWidth, fontSize) {
+  if (measureText(label, fontSize) <= maxWidth) return [label];
+  if (label.includes(" ")) {
+    return wrapLabelWords(label.split(" "), maxWidth, fontSize);
+  }
+  if (/[-_:/]/.test(label)) {
+    const parts = label.split(/[-_:/]+/);
+    return wrapLabelWords(parts, maxWidth, fontSize);
+  }
+  const camelParts = label.replace(/([a-z])([A-Z])/g, "$1\0$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1\0$2").split("\0");
+  if (camelParts.length > 1) {
+    return wrapLabelWords(camelParts, maxWidth, fontSize);
+  }
+  return [label];
+}
+function wrapLabelWords(words, maxWidth, fontSize) {
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    const test = current ? current + word : word;
+    if (measureText(test, fontSize) > maxWidth && current) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = test;
+    }
+  }
+  if (current) lines.push(current);
+  return lines;
+}
+var fill = (palette, isDark, color, solid) => color ? shapeFill(palette, color, isDark, {
+  ...solid !== void 0 && { solid }
+}) : isDark ? mix(palette.overlay, palette.surface, 50) : mix(palette.bg, palette.surface, 50);
+var stroke = (palette, color) => color || palette.border;
+var SW = 1.5;
+var W = PARTICIPANT_BOX_WIDTH;
+var H = PARTICIPANT_BOX_HEIGHT;
+function renderRectParticipant(g, palette, isDark, color, solid, w = W, h = H) {
+  g.append("rect").attr("x", -w / 2).attr("y", 0).attr("width", w).attr("height", h).attr("rx", 2).attr("ry", 2).attr("fill", fill(palette, isDark, color, solid)).attr("stroke", stroke(palette, color)).attr("stroke-width", SW);
+}
+function renderActorParticipant(g, palette, color, h = H) {
+  const sc = h / H;
+  const headR = 8 * sc;
+  const cx = 0;
+  const headY = 10 * sc;
+  const bodyTopY = 19 * sc;
+  const bodyBottomY = h * 0.65;
+  const legY = h - 2 * sc;
+  const armY = 24 * sc;
+  const armSpan = 16 * sc;
+  const legSpan = 12 * sc;
+  const s = stroke(palette, color);
+  const actorSW = Math.max(1.2, 2.5 * sc);
+  g.append("circle").attr("cx", cx).attr("cy", headY).attr("r", headR).attr("fill", "none").attr("stroke", s).attr("stroke-width", actorSW);
+  g.append("line").attr("x1", cx).attr("y1", bodyTopY).attr("x2", cx).attr("y2", bodyBottomY).attr("stroke", s).attr("stroke-width", actorSW);
+  g.append("line").attr("x1", cx - armSpan).attr("y1", armY).attr("x2", cx + armSpan).attr("y2", armY).attr("stroke", s).attr("stroke-width", actorSW);
+  g.append("line").attr("x1", cx).attr("y1", bodyBottomY).attr("x2", cx - legSpan).attr("y2", legY).attr("stroke", s).attr("stroke-width", actorSW);
+  g.append("line").attr("x1", cx).attr("y1", bodyBottomY).attr("x2", cx + legSpan).attr("y2", legY).attr("stroke", s).attr("stroke-width", actorSW);
+}
+function renderDatabaseParticipant(g, palette, isDark, color, solid, w = W, h = H) {
+  const ry = 7;
+  const topY = ry;
+  const bodyH = h - ry * 2;
+  const f = fill(palette, isDark, color, solid);
+  const s = stroke(palette, color);
+  g.append("ellipse").attr("cx", 0).attr("cy", topY + bodyH).attr("rx", w / 2).attr("ry", ry).attr("fill", f).attr("stroke", s).attr("stroke-width", SW);
+  g.append("rect").attr("class", "participant-body").attr("x", -w / 2).attr("y", topY).attr("width", w).attr("height", bodyH).attr("fill", f).attr("stroke", "none");
+  g.append("line").attr("x1", -w / 2).attr("y1", topY).attr("x2", -w / 2).attr("y2", topY + bodyH).attr("stroke", s).attr("stroke-width", SW);
+  g.append("line").attr("x1", w / 2).attr("y1", topY).attr("x2", w / 2).attr("y2", topY + bodyH).attr("stroke", s).attr("stroke-width", SW);
+  g.append("ellipse").attr("cx", 0).attr("cy", topY).attr("rx", w / 2).attr("ry", ry).attr("fill", f).attr("stroke", s).attr("stroke-width", SW);
+}
+function renderQueueParticipant(g, palette, isDark, color, solid, w = W, h = H) {
+  const rx = 10;
+  const leftX = -w / 2 + rx;
+  const bodyW = w - rx * 2;
+  const f = fill(palette, isDark, color, solid);
+  const s = stroke(palette, color);
+  g.append("ellipse").attr("cx", leftX + bodyW).attr("cy", h / 2).attr("rx", rx).attr("ry", h / 2).attr("fill", f).attr("stroke", s).attr("stroke-width", SW);
+  g.append("rect").attr("class", "participant-body").attr("x", leftX).attr("y", 0).attr("width", bodyW).attr("height", h).attr("fill", f).attr("stroke", "none");
+  g.append("line").attr("x1", leftX).attr("y1", 0).attr("x2", leftX + bodyW).attr("y2", 0).attr("stroke", s).attr("stroke-width", SW);
+  g.append("line").attr("x1", leftX).attr("y1", h).attr("x2", leftX + bodyW).attr("y2", h).attr("stroke", s).attr("stroke-width", SW);
+  g.append("ellipse").attr("cx", leftX).attr("cy", h / 2).attr("rx", rx).attr("ry", h / 2).attr("fill", f).attr("stroke", s).attr("stroke-width", SW);
+}
+function renderCacheParticipant(g, palette, isDark, color, solid, w = W, h = H) {
+  const ry = 7;
+  const topY = ry;
+  const bodyH = h - ry * 2;
+  const f = fill(palette, isDark, color, solid);
+  const s = stroke(palette, color);
+  const dash = "4 3";
+  g.append("ellipse").attr("cx", 0).attr("cy", topY + bodyH).attr("rx", w / 2).attr("ry", ry).attr("fill", f).attr("stroke", s).attr("stroke-width", SW).attr("stroke-dasharray", dash);
+  g.append("rect").attr("class", "participant-body").attr("x", -w / 2).attr("y", topY).attr("width", w).attr("height", bodyH).attr("fill", f).attr("stroke", "none");
+  g.append("line").attr("x1", -w / 2).attr("y1", topY).attr("x2", -w / 2).attr("y2", topY + bodyH).attr("stroke", s).attr("stroke-width", SW).attr("stroke-dasharray", dash);
+  g.append("line").attr("x1", w / 2).attr("y1", topY).attr("x2", w / 2).attr("y2", topY + bodyH).attr("stroke", s).attr("stroke-width", SW).attr("stroke-dasharray", dash);
+  g.append("ellipse").attr("cx", 0).attr("cy", topY).attr("rx", w / 2).attr("ry", ry).attr("fill", f).attr("stroke", s).attr("stroke-width", SW).attr("stroke-dasharray", dash);
+}
+function groupMessagesBySection(elements, messages) {
+  const groups = [];
+  let currentGroup = null;
+  const msgLineToIdx = /* @__PURE__ */ new Map();
+  messages.forEach((m, i) => msgLineToIdx.set(m.lineNumber, i));
+  const collectIndices = (els) => {
+    const indices = [];
+    for (const el of els) {
+      if (isSequenceBlock(el)) {
+        indices.push(
+          ...collectIndices(el.children),
+          ...collectIndices(el.elseChildren)
+        );
+        if (el.elseIfBranches) {
+          for (const branch of el.elseIfBranches) {
+            indices.push(...collectIndices(branch.children));
+          }
+        }
+      } else if (isSequenceSection(el) || isSequenceNote(el)) {
+        continue;
+      } else {
+        const idx = msgLineToIdx.get(el.lineNumber) ?? -1;
+        if (idx >= 0) indices.push(idx);
+      }
+    }
+    return indices;
+  };
+  for (const el of elements) {
+    if (isSequenceSection(el)) {
+      currentGroup = { section: el, messageIndices: [] };
+      groups.push(currentGroup);
+    } else if (currentGroup) {
+      if (isSequenceBlock(el)) {
+        currentGroup.messageIndices.push(...collectIndices([el]));
+      } else if (!isSequenceNote(el)) {
+        const idx = msgLineToIdx.get(el.lineNumber) ?? -1;
+        if (idx >= 0) currentGroup.messageIndices.push(idx);
+      }
+    }
+  }
+  return groups;
+}
+function buildRenderSequence(messages) {
+  const steps = [];
+  const stack = [];
+  for (let mi = 0; mi < messages.length; mi++) {
+    const msg = messages[mi];
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      if (top.to === msg.from) break;
+      stack.pop();
+      steps.push({
+        type: "return",
+        from: top.to,
+        to: top.from,
+        label: "",
+        messageIndex: top.messageIndex
+      });
+    }
+    if (stack.length > 0 && !msg.async && msg.from !== msg.to) {
+      const top = stack[stack.length - 1];
+      if (top.from === msg.to && top.to === msg.from) {
+        stack.pop();
+        steps.push({
+          type: "return",
+          from: msg.from,
+          to: msg.to,
+          label: msg.label,
+          messageIndex: mi
+        });
+        continue;
+      }
+    }
+    steps.push({
+      type: "call",
+      from: msg.from,
+      to: msg.to,
+      label: msg.label,
+      messageIndex: mi,
+      ...msg.async ? { async: true } : {}
+    });
+    if (msg.async) {
+      continue;
+    }
+    if (msg.from === msg.to) {
+      steps.push({
+        type: "return",
+        from: msg.to,
+        to: msg.from,
+        label: "",
+        messageIndex: mi
+      });
+    } else {
+      stack.push({
+        from: msg.from,
+        to: msg.to,
+        messageIndex: mi
+      });
+    }
+  }
+  while (stack.length > 0) {
+    const top = stack.pop();
+    steps.push({
+      type: "return",
+      from: top.to,
+      to: top.from,
+      label: "",
+      messageIndex: top.messageIndex
+    });
+  }
+  return steps;
+}
+function computeActivations(steps) {
+  const activations = [];
+  const stacks = /* @__PURE__ */ new Map();
+  const getStack = (id) => {
+    if (!stacks.has(id)) stacks.set(id, []);
+    return stacks.get(id);
+  };
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    if (step.type === "call") {
+      const s = getStack(step.to);
+      s.push(i);
+    } else {
+      const s = getStack(step.from);
+      if (s.length > 0) {
+        const startIdx = s.pop();
+        activations.push({
+          participantId: step.from,
+          startStep: startIdx,
+          endStep: i,
+          depth: s.length
+        });
+      }
+    }
+  }
+  return activations;
+}
+function applyPositionOverrides(participants) {
+  if (!participants.some((p) => p.position !== void 0))
+    return [...participants];
+  const total = participants.length;
+  const positioned = [];
+  const unpositioned = [];
+  for (const p of participants) {
+    if (p.position !== void 0) {
+      let idx = p.position < 0 ? total + p.position : p.position;
+      idx = Math.max(0, Math.min(total - 1, idx));
+      positioned.push({ participant: p, index: idx });
+    } else {
+      unpositioned.push(p);
+    }
+  }
+  positioned.sort((a, b) => a.index - b.index);
+  const result = new Array(total).fill(null);
+  const usedIndices = /* @__PURE__ */ new Set();
+  for (const { participant, index } of positioned) {
+    let idx = index;
+    if (usedIndices.has(idx)) {
+      for (let offset = 1; offset < total; offset++) {
+        if (idx + offset < total && !usedIndices.has(idx + offset)) {
+          idx = idx + offset;
+          break;
+        }
+        if (idx - offset >= 0 && !usedIndices.has(idx - offset)) {
+          idx = idx - offset;
+          break;
+        }
+      }
+    }
+    result[idx] = participant;
+    usedIndices.add(idx);
+  }
+  let uIdx = 0;
+  for (let i = 0; i < total; i++) {
+    if (result[i] === null) {
+      result[i] = unpositioned[uIdx++];
+    }
+  }
+  return result;
+}
+function applyGroupOrdering(participants, groups, messages = []) {
+  if (groups.length === 0) return [...participants];
+  const idToGroup = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    for (const id of group.participantIds) {
+      idToGroup.set(id, group);
+    }
+  }
+  const appearanceOrder = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    for (const id of [msg.from, msg.to]) {
+      if (!seen.has(id)) {
+        seen.add(id);
+        appearanceOrder.push(id);
+      }
+    }
+  }
+  for (const p of participants) {
+    if (!seen.has(p.id)) {
+      seen.add(p.id);
+      appearanceOrder.push(p.id);
+    }
+  }
+  const result = [];
+  const placed = /* @__PURE__ */ new Set();
+  const placedGroups = /* @__PURE__ */ new Set();
+  for (const id of appearanceOrder) {
+    if (placed.has(id)) continue;
+    const group = idToGroup.get(id);
+    if (group && !placedGroups.has(group)) {
+      placedGroups.add(group);
+      for (const gid of group.participantIds) {
+        const p = participants.find((pp) => pp.id === gid);
+        if (p && !placed.has(gid)) {
+          result.push(p);
+          placed.add(gid);
+        }
+      }
+    } else if (!group) {
+      const p = participants.find((pp) => pp.id === id);
+      if (p) {
+        result.push(p);
+        placed.add(id);
+      }
+    }
+  }
+  return result;
+}
+function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateToLine, options) {
+  d3Selection.select(container).selectAll("*").remove();
+  const { title, options: parsedOptions } = parsed;
+  const solid = parsedOptions["solid-fill"] === "on";
+  const effectiveCollapsedGroups = options?.collapsedGroups ? new Set(options.collapsedGroups) : new Set(
+    parsed.groups.filter((g) => g.collapsed).map((g) => g.lineNumber)
+  );
+  const collapsed = effectiveCollapsedGroups.size > 0 ? applyCollapseProjection(parsed, effectiveCollapsedGroups) : null;
+  const messages = collapsed ? collapsed.messages : parsed.messages;
+  const elements = collapsed ? collapsed.elements : parsed.elements;
+  const groups = collapsed ? collapsed.groups : parsed.groups;
+  const collapsedSections = options?.collapsedSections;
+  const sourceParticipants = collapsed ? collapsed.participants : parsed.participants;
+  const participants = applyPositionOverrides(
+    applyGroupOrdering(sourceParticipants, groups, messages)
+  );
+  if (participants.length === 0) return;
+  const groupBoundaryIds = /* @__PURE__ */ new Set();
+  if (groups.length > 0) {
+    const pToG = /* @__PURE__ */ new Map();
+    for (let gi = 0; gi < groups.length; gi++) {
+      for (const pid of groups[gi].participantIds) pToG.set(pid, gi);
+    }
+    const LOOSE = -1;
+    for (let i = 1; i < participants.length; i++) {
+      const prevGi = pToG.get(participants[i - 1].id) ?? LOOSE;
+      const gi = pToG.get(participants[i].id) ?? LOOSE;
+      if (gi !== prevGi && !(gi === LOOSE && prevGi === LOOSE)) {
+        groupBoundaryIds.add(participants[i].id);
+      }
+    }
+  }
+  const numGroupGaps = groupBoundaryIds.size;
+  const MAX_BOX_WIDTH = 225;
+  let uniformBoxWidth = PARTICIPANT_BOX_WIDTH;
+  for (const p of participants) {
+    const lines = splitParticipantLabel(
+      p.label,
+      labelTextWidth(PARTICIPANT_BOX_WIDTH),
+      LABEL_FONT_SIZE
+    );
+    if (lines.length === 0) continue;
+    const widest = Math.max(
+      ...lines.map((l) => measureText(l, LABEL_FONT_SIZE))
+    );
+    const labelWidth = widest + 10;
+    uniformBoxWidth = Math.max(uniformBoxWidth, labelWidth);
+  }
+  uniformBoxWidth = Math.min(MAX_BOX_WIDTH, uniformBoxWidth);
+  const effectiveGap = Math.max(PARTICIPANT_GAP, uniformBoxWidth + 30);
+  const idealWidth = Math.max(
+    participants.length * effectiveGap,
+    uniformBoxWidth + 40
+  );
+  const containerWidth = options?.exportWidth ?? container.getBoundingClientRect().width;
+  const ctx = options?.exportWidth ? ScaleContext.identity() : ScaleContext.from(containerWidth, idealWidth);
+  const sGap = ctx.structural(effectiveGap);
+  const sBoxW = ctx.structural(uniformBoxWidth);
+  const sBoxH = ctx.structural(PARTICIPANT_BOX_HEIGHT);
+  const sTopMargin = ctx.aesthetic(TOP_MARGIN);
+  const sTitleHeight = ctx.aesthetic(TITLE_HEIGHT);
+  const sParticipantYOffset = ctx.aesthetic(PARTICIPANT_Y_OFFSET);
+  const sMsgStartOffset = ctx.structural(MESSAGE_START_OFFSET);
+  const sLifelineTail = ctx.structural(LIFELINE_TAIL);
+  const sArrowheadSize = ctx.structural(ARROWHEAD_SIZE);
+  const sNoteMaxW = ctx.structural(NOTE_MAX_W);
+  const sNoteFold = ctx.structural(NOTE_FOLD);
+  const sNotePadH = ctx.structural(NOTE_PAD_H);
+  const sNotePadV = ctx.structural(NOTE_PAD_V);
+  const sNoteFontSize = ctx.text(NOTE_FONT_SIZE);
+  const sNoteLineH = ctx.structural(NOTE_LINE_H);
+  const sNoteGap = ctx.structural(NOTE_GAP);
+  const sActivationWidth = ctx.structural(ACTIVATION_WIDTH);
+  const sSelfCallHeight = SELF_CALL_HEIGHT;
+  const sSelfCallWidth = ctx.structural(SELF_CALL_WIDTH);
+  const sNoteTextWidthMax = sNoteMaxW - sNotePadH * 2 - sNoteFold;
+  const sNoteLaneMax = sGap - sActivationWidth - sNoteGap;
+  const sLabelFontSize = ctx.text(LABEL_FONT_SIZE);
+  const sLabelTextWidth = labelTextWidth(sBoxW);
+  const participantIndexMap = /* @__PURE__ */ new Map();
+  participants.forEach((p, i) => participantIndexMap.set(p.id, i));
+  const effectiveNotePosition = (note) => {
+    const idx = participantIndexMap.get(note.participantId);
+    if (idx === void 0) return note.position;
+    if (note.position === "right" && idx === participants.length - 1 && idx > 0)
+      return "left";
+    if (note.position === "left" && idx === 0 && participants.length > 1)
+      return "right";
+    return note.position;
+  };
+  const SELF_CALL_NOTE_X_SHIFT = sActivationWidth / 2 + sSelfCallWidth + sNoteGap - (sActivationWidth + sNoteGap);
+  const noteEffectiveMaxW = (participantId, position, afterSelfCall = false) => {
+    const idx = participantIndexMap.get(participantId);
+    if (idx === void 0) return sNoteMaxW;
+    const hasNeighbor = position === "right" ? idx < participants.length - 1 : idx > 0;
+    if (!hasNeighbor) return sNoteMaxW;
+    const laneMax = afterSelfCall && position === "right" ? sNoteLaneMax - SELF_CALL_NOTE_X_SHIFT : sNoteLaneMax;
+    return Math.min(sNoteMaxW, laneMax);
+  };
+  const noteTextWidth = (maxW) => maxW - sNotePadH * 2 - sNoteFold;
+  const activationsOff = parsedOptions["activations"]?.toLowerCase() === "off";
+  const activeTagGroup = resolveActiveTagGroup(
+    parsed.tagGroups.filter((tg) => tg.entries.length > 0),
+    parsedOptions["active-tag"],
+    options?.activeTagGroup
+  ) ?? void 0;
+  let tagMap;
+  const tagValueToColor = /* @__PURE__ */ new Map();
+  if (activeTagGroup) {
+    tagMap = resolveSequenceTags(parsed, activeTagGroup);
+    const tg = parsed.tagGroups.find(
+      (g) => g.name.toLowerCase() === activeTagGroup.toLowerCase()
+    );
+    if (tg) {
+      for (const entry of tg.entries) {
+        tagValueToColor.set(entry.value.toLowerCase(), entry.color);
+      }
+    }
+  }
+  const getTagColor = (value) => value ? tagValueToColor.get(value.toLowerCase()) : void 0;
+  const tagKey = activeTagGroup ? tagAttrKey(activeTagGroup) : void 0;
+  const hiddenMsgIndices = /* @__PURE__ */ new Set();
+  if (collapsedSections && collapsedSections.size > 0) {
+    const sectionGroups = groupMessagesBySection(elements, messages);
+    for (const grp of sectionGroups) {
+      if (collapsedSections.has(grp.section.lineNumber)) {
+        for (const idx of grp.messageIndices) {
+          hiddenMsgIndices.add(idx);
+        }
+      }
+    }
+  }
+  const allRenderSteps = buildRenderSequence(messages);
+  const stepSurvives = (s) => (hiddenMsgIndices.size === 0 || !hiddenMsgIndices.has(s.messageIndex)) && (s.type === "call" || !!s.label);
+  const renderSteps = [];
+  const allToFiltered = new Array(allRenderSteps.length);
+  for (let j = 0; j < allRenderSteps.length; j++) {
+    const s = allRenderSteps[j];
+    allToFiltered[j] = renderSteps.length;
+    if (stepSurvives(s)) renderSteps.push(s);
+  }
+  const lastStepIdx = Math.max(renderSteps.length - 1, 0);
+  const clampStep = (i) => Math.min(Math.max(i, 0), lastStepIdx);
+  const activations = activationsOff ? [] : computeActivations(allRenderSteps).map((a) => ({
+    ...a,
+    startStep: clampStep(allToFiltered[a.startStep] ?? 0),
+    endStep: clampStep(allToFiltered[a.endStep] ?? 0)
+  }));
+  const stepSpacing = 35;
+  const BLOCK_HEADER_SPACE = 30;
+  const BLOCK_AFTER_SPACE = 15;
+  const FRAME_PADDING_TOP = 42;
+  const msgToFirstStep = /* @__PURE__ */ new Map();
+  const msgToLastStep = /* @__PURE__ */ new Map();
+  renderSteps.forEach((step, si) => {
+    if (!msgToFirstStep.has(step.messageIndex)) {
+      msgToFirstStep.set(step.messageIndex, si);
+    }
+    msgToLastStep.set(step.messageIndex, si);
+  });
+  const findAssociatedLastStep = (note) => {
+    let closestMsgIndex = -1;
+    let closestLine = -1;
+    for (let mi = 0; mi < messages.length; mi++) {
+      const m = messages[mi];
+      if (m.lineNumber < note.lineNumber && m.lineNumber > closestLine) {
+        closestLine = m.lineNumber;
+        closestMsgIndex = mi;
+      }
+    }
+    if (closestMsgIndex >= 0 && hiddenMsgIndices.has(closestMsgIndex)) {
+      return -1;
+    }
+    if (closestMsgIndex < 0) return -1;
+    return msgToLastStep.get(closestMsgIndex) ?? -1;
+  };
+  const isNoteAfterSelfCall = (note) => {
+    let closestMsgIndex = -1;
+    let closestLine = -1;
+    for (let mi = 0; mi < messages.length; mi++) {
+      const m = messages[mi];
+      if (m.lineNumber < note.lineNumber && m.lineNumber > closestLine) {
+        closestLine = m.lineNumber;
+        closestMsgIndex = mi;
+      }
+    }
+    if (closestMsgIndex < 0) return false;
+    const msg = messages[closestMsgIndex];
+    return msg.from === msg.to;
+  };
+  const SELF_CALL_NOTE_GAP = ctx.structural(8);
+  const noteOffsetBelow = (note) => isNoteAfterSelfCall(note) ? sSelfCallHeight + NOTE_OFFSET_BELOW + SELF_CALL_NOTE_GAP : NOTE_OFFSET_BELOW;
+  const msgLineToIdx = /* @__PURE__ */ new Map();
+  messages.forEach((m, i) => msgLineToIdx.set(m.lineNumber, i));
+  const findFirstMsgIndex = (els) => {
+    for (const el of els) {
+      if (isSequenceBlock(el)) {
+        const idx = findFirstMsgIndex(el.children);
+        if (idx >= 0) return idx;
+        if (el.elseIfBranches) {
+          for (const branch of el.elseIfBranches) {
+            const branchIdx = findFirstMsgIndex(branch.children);
+            if (branchIdx >= 0) return branchIdx;
+          }
+        }
+        const elseIdx = findFirstMsgIndex(el.elseChildren);
+        if (elseIdx >= 0) return elseIdx;
+      } else if (!isSequenceSection(el) && !isSequenceNote(el)) {
+        const idx = msgLineToIdx.get(el.lineNumber) ?? -1;
+        if (idx >= 0 && !hiddenMsgIndices.has(idx)) return idx;
+      }
+    }
+    return -1;
+  };
+  const SECTION_TOP_PAD = 35;
+  const SECTION_BOTTOM_PAD = 45;
+  const extraBeforeMsg = /* @__PURE__ */ new Map();
+  const addExtra = (msgIdx, amount) => {
+    extraBeforeMsg.set(msgIdx, (extraBeforeMsg.get(msgIdx) || 0) + amount);
+  };
+  const markBlockSpacing = (els) => {
+    for (let i = 0; i < els.length; i++) {
+      const el = els[i];
+      if (isSequenceSection(el)) continue;
+      if (!isSequenceBlock(el)) continue;
+      const firstIdx = findFirstMsgIndex(el.children);
+      if (firstIdx >= 0) addExtra(firstIdx, BLOCK_HEADER_SPACE);
+      if (el.elseIfBranches) {
+        for (const branch of el.elseIfBranches) {
+          const firstBranchIdx = findFirstMsgIndex(branch.children);
+          if (firstBranchIdx >= 0) addExtra(firstBranchIdx, BLOCK_HEADER_SPACE);
+          markBlockSpacing(branch.children);
+        }
+      }
+      const firstElseIdx = findFirstMsgIndex(el.elseChildren);
+      if (firstElseIdx >= 0) addExtra(firstElseIdx, BLOCK_HEADER_SPACE);
+      markBlockSpacing(el.children);
+      markBlockSpacing(el.elseChildren);
+      if (i + 1 < els.length) {
+        const nextIdx = findFirstMsgIndex([els[i + 1]]);
+        if (nextIdx >= 0) addExtra(nextIdx, BLOCK_AFTER_SPACE);
+      }
+    }
+  };
+  if (elements && elements.length > 0) {
+    markBlockSpacing(elements);
+  }
+  const NOTE_OFFSET_BELOW = ctx.structural(14);
+  const NOTE_TRAILING_GAP = ctx.aesthetic(35);
+  const computeNoteHeight = (text, textWidth = sNoteTextWidthMax) => {
+    const lines = wrapTextLines(text, textWidth, sNoteFontSize);
+    return lines.length * sNoteLineH + sNotePadV * 2;
+  };
+  let trailingNoteSpace = 0;
+  const markNoteSpacing = (els) => {
+    for (let i = 0; i < els.length; i++) {
+      const el = els[i];
+      if (isSequenceNote(el)) {
+        const firstOffset = noteOffsetBelow(el);
+        let totalExtent = firstOffset;
+        let j = i;
+        while (j < els.length && isSequenceNote(els[j])) {
+          const note = els[j];
+          const sc = isNoteAfterSelfCall(note);
+          const maxW = noteEffectiveMaxW(note.participantId, note.position, sc);
+          const noteH = computeNoteHeight(note.text, noteTextWidth(maxW));
+          totalExtent += noteH + NOTE_OFFSET_BELOW;
+          j++;
+        }
+        const trailingGap = Math.max(NOTE_TRAILING_GAP, totalExtent * 0.3);
+        totalExtent += trailingGap - NOTE_OFFSET_BELOW;
+        let extraNeeded = Math.max(0, totalExtent - stepSpacing);
+        let nextMsgIdx = -1;
+        for (let k = j; k < els.length; k++) {
+          nextMsgIdx = findFirstMsgIndex([els[k]]);
+          if (nextMsgIdx >= 0) break;
+        }
+        if (j < els.length && isSequenceBlock(els[j])) {
+          extraNeeded += FRAME_PADDING_TOP - BLOCK_HEADER_SPACE;
+        }
+        if (nextMsgIdx >= 0) {
+          addExtra(nextMsgIdx, extraNeeded);
+        } else {
+          trailingNoteSpace = Math.max(trailingNoteSpace, extraNeeded);
+        }
+        i = j - 1;
+      } else if (isSequenceBlock(el)) {
+        markNoteSpacing(el.children);
+        if (el.elseIfBranches) {
+          for (const branch of el.elseIfBranches) {
+            markNoteSpacing(branch.children);
+          }
+        }
+        markNoteSpacing(el.elseChildren);
+      }
+    }
+  };
+  if (elements && elements.length > 0) {
+    markNoteSpacing(elements);
+  }
+  const preSectionMsgIndices = [];
+  const sectionRegions = [];
+  {
+    const msgLineToIndex = /* @__PURE__ */ new Map();
+    messages.forEach((m, i) => msgLineToIndex.set(m.lineNumber, i));
+    const findMsgIndex = (child) => msgLineToIndex.get(child.lineNumber) ?? -1;
+    const collectMsgIndicesFromBlock = (block) => {
+      const indices = [];
+      for (const child of block.children) {
+        if (isSequenceBlock(child)) {
+          indices.push(...collectMsgIndicesFromBlock(child));
+        } else if (!isSequenceSection(child) && !isSequenceNote(child)) {
+          const idx = findMsgIndex(child);
+          if (idx >= 0) indices.push(idx);
+        }
+      }
+      if (block.elseIfBranches) {
+        for (const branch of block.elseIfBranches) {
+          for (const child of branch.children) {
+            if (isSequenceBlock(child)) {
+              indices.push(...collectMsgIndicesFromBlock(child));
+            } else if (!isSequenceSection(child) && !isSequenceNote(child)) {
+              const idx = findMsgIndex(child);
+              if (idx >= 0) indices.push(idx);
+            }
+          }
+        }
+      }
+      for (const child of block.elseChildren) {
+        if (isSequenceBlock(child)) {
+          indices.push(...collectMsgIndicesFromBlock(child));
+        } else if (!isSequenceSection(child) && !isSequenceNote(child)) {
+          const idx = findMsgIndex(child);
+          if (idx >= 0) indices.push(idx);
+        }
+      }
+      return indices;
+    };
+    let currentTarget = preSectionMsgIndices;
+    for (const el of elements) {
+      if (isSequenceSection(el)) {
+        const region = { section: el, msgIndices: [] };
+        sectionRegions.push(region);
+        currentTarget = region.msgIndices;
+      } else if (isSequenceBlock(el)) {
+        currentTarget.push(...collectMsgIndicesFromBlock(el));
+      } else {
+        const idx = findMsgIndex(el);
+        if (idx >= 0) currentTarget.push(idx);
+      }
+    }
+  }
+  const allMsgToFirstStep = /* @__PURE__ */ new Map();
+  allRenderSteps.forEach((step, si) => {
+    if (!allMsgToFirstStep.has(step.messageIndex)) {
+      allMsgToFirstStep.set(step.messageIndex, si);
+    }
+  });
+  const originalToFiltered = /* @__PURE__ */ new Map();
+  {
+    let fi = 0;
+    for (let oi = 0; oi < allRenderSteps.length; oi++) {
+      const step = allRenderSteps[oi];
+      if (!hiddenMsgIndices.has(step.messageIndex) && (step.type === "call" || step.label)) {
+        originalToFiltered.set(oi, fi);
+        fi++;
+      }
+    }
+  }
+  const findFilteredInsertionPoint = (origStep) => {
+    for (let i = origStep; i < allRenderSteps.length; i++) {
+      const fi = originalToFiltered.get(i);
+      if (fi !== void 0) return fi;
+    }
+    return null;
+  };
+  const sectionsBeforeStep = /* @__PURE__ */ new Map();
+  const trailingSections = [];
+  for (const region of sectionRegions) {
+    if (region.msgIndices.length === 0) {
+      trailingSections.push(region.section);
+      continue;
+    }
+    const firstMsgIdx = region.msgIndices[0];
+    const origStep = allMsgToFirstStep.get(firstMsgIdx);
+    if (origStep === void 0) {
+      trailingSections.push(region.section);
+      continue;
+    }
+    const filteredStep = findFilteredInsertionPoint(origStep);
+    if (filteredStep === null) {
+      trailingSections.push(region.section);
+      continue;
+    }
+    const existing = sectionsBeforeStep.get(filteredStep) || [];
+    existing.push(region.section);
+    sectionsBeforeStep.set(filteredStep, existing);
+  }
+  const sectionMsgCounts = /* @__PURE__ */ new Map();
+  for (const region of sectionRegions) {
+    sectionMsgCounts.set(region.section.lineNumber, region.msgIndices.length);
+  }
+  const GROUP_PADDING_X = 15;
+  const GROUP_PADDING_TOP = 22;
+  const GROUP_PADDING_BOTTOM = 8;
+  const GROUP_LABEL_SIZE = 11;
+  const showTitle = !!title && parsedOptions["no-title"] !== "on";
+  const titleOffset = showTitle ? sTitleHeight : 0;
+  const LEGEND_FIXED_GAP = 8;
+  const resolvedGroups = parsed.tagGroups.filter((tg) => tg.entries.length > 0).map((tg) => ({
+    name: tg.name,
+    entries: tg.entries.map((e) => ({ value: e.value, color: e.color }))
+  }));
+  const legendConfig = {
+    groups: resolvedGroups,
+    position: { placement: "top-center", titleRelation: "below-title" },
+    mode: "preview"
+  };
+  const legendTopSpace = parsed.tagGroups.length > 0 ? getMaxLegendReservedHeight(legendConfig, containerWidth) + LEGEND_FIXED_GAP : 0;
+  const groupOffset = parsed.groups.length > 0 ? GROUP_PADDING_TOP + GROUP_LABEL_SIZE : 0;
+  const participantStartY = sTopMargin + titleOffset + legendTopSpace + sParticipantYOffset + groupOffset;
+  const lifelineStartY0 = participantStartY + sBoxH;
+  const hasActors = participants.some((p) => p.type === "actor");
+  const messageStartOffset = sMsgStartOffset + (hasActors ? 20 : 0) + (parsed.groups.length > 0 ? GROUP_PADDING_BOTTOM : 0);
+  const stepYPositions = [];
+  const sectionYPositions = /* @__PURE__ */ new Map();
+  let layoutEndY;
+  {
+    let curY = lifelineStartY0 + messageStartOffset;
+    for (let i = 0; i < renderSteps.length; i++) {
+      const sections = sectionsBeforeStep.get(i);
+      if (sections) {
+        for (const sec of sections) {
+          curY += SECTION_TOP_PAD;
+          sectionYPositions.set(sec.lineNumber, curY);
+          curY += SECTION_BOTTOM_PAD;
+        }
+      }
+      const step = renderSteps[i];
+      if (msgToFirstStep.get(step.messageIndex) === i) {
+        const extra = extraBeforeMsg.get(step.messageIndex) || 0;
+        curY += extra;
+      }
+      stepYPositions.push(curY);
+      const isSelfCall = step.type === "call" && step.from === step.to;
+      curY += isSelfCall ? sSelfCallHeight + 25 : stepSpacing;
+    }
+    for (const sec of trailingSections) {
+      curY += SECTION_TOP_PAD;
+      sectionYPositions.set(sec.lineNumber, curY);
+      curY += SECTION_BOTTOM_PAD;
+    }
+    curY += trailingNoteSpace;
+    layoutEndY = curY;
+  }
+  const stepY = (i) => stepYPositions[i];
+  const noteYMap = /* @__PURE__ */ new Map();
+  {
+    const computeNotePositions = (els) => {
+      for (let i = 0; i < els.length; i++) {
+        const el = els[i];
+        if (isSequenceNote(el)) {
+          const si = findAssociatedLastStep(el);
+          if (si < 0) continue;
+          const prevNote = i > 0 && isSequenceNote(els[i - 1]) ? els[i - 1] : null;
+          const prevNoteY = prevNote ? noteYMap.get(prevNote) : void 0;
+          let noteTopY;
+          if (prevNoteY !== void 0 && prevNote) {
+            const prevMaxW = noteEffectiveMaxW(
+              prevNote.participantId,
+              effectiveNotePosition(prevNote),
+              isNoteAfterSelfCall(prevNote)
+            );
+            const prevNoteH = computeNoteHeight(
+              prevNote.text,
+              noteTextWidth(prevMaxW)
+            );
+            noteTopY = prevNoteY + prevNoteH + NOTE_OFFSET_BELOW;
+          } else {
+            noteTopY = stepY(si) + noteOffsetBelow(el);
+          }
+          noteYMap.set(el, noteTopY);
+        } else if (isSequenceBlock(el)) {
+          computeNotePositions(el.children);
+          if (el.elseIfBranches) {
+            for (const branch of el.elseIfBranches) {
+              computeNotePositions(branch.children);
+            }
+          }
+          computeNotePositions(el.elseChildren);
+        }
+      }
+    };
+    if (elements && elements.length > 0) {
+      computeNotePositions(elements);
+    }
+  }
+  const lastStep = renderSteps[renderSteps.length - 1];
+  const lastIsSelfCall = lastStep?.type === "call" && lastStep.from === lastStep.to;
+  const lastStepTrailing = lastIsSelfCall ? sSelfCallHeight + 25 : stepSpacing;
+  let contentBottomY = renderSteps.length > 0 ? Math.max(
+    // In-bounds: renderSteps.length > 0 guarantees stepYPositions is
+    // non-empty (1:1 with renderSteps in the layout loop above).
+    stepYPositions[stepYPositions.length - 1] + lastStepTrailing,
+    layoutEndY
+  ) : layoutEndY;
+  for (const [note, noteTopY] of noteYMap) {
+    const maxW = noteEffectiveMaxW(
+      note.participantId,
+      effectiveNotePosition(note),
+      isNoteAfterSelfCall(note)
+    );
+    const noteH = computeNoteHeight(note.text, noteTextWidth(maxW));
+    contentBottomY = Math.max(
+      contentBottomY,
+      noteTopY + noteH + NOTE_TRAILING_GAP
+    );
+  }
+  const messageAreaHeight = contentBottomY - lifelineStartY0;
+  const lifelineLength = messageAreaHeight + sLifelineTail;
+  const totalGaps = participants.length > 1 ? participants.length - 1 : 0;
+  const numWithinGaps = totalGaps - numGroupGaps;
+  let sWithinGap = sGap;
+  let sBetweenGap = sGap;
+  if (numGroupGaps > 0 && totalGaps > 0) {
+    sWithinGap = sGap * 0.88;
+    sBetweenGap = (totalGaps * sGap - numWithinGaps * sWithinGap) / numGroupGaps;
+  }
+  const rightmostId = participants[participants.length - 1]?.id;
+  let rightProjection = sBoxW / 2;
+  if (rightmostId) {
+    if (parsed.groups.some(
+      (g) => g.participantIds.includes(rightmostId)
+    ))
+      rightProjection = Math.max(rightProjection, sBoxW / 2 + GROUP_PADDING_X);
+    for (const step of renderSteps) {
+      if (step.from === step.to && step.from === rightmostId) {
+        const selfProj = sActivationWidth + sSelfCallWidth;
+        let labelProj = 0;
+        if (step.label) labelProj = measureText(step.label, 12) + 15;
+        rightProjection = Math.max(rightProjection, selfProj + labelProj);
+      }
+    }
+    const blockFramePadX = 30;
+    const hasBlockWithRightmost = (els) => {
+      for (const el of els) {
+        if (isSequenceBlock(el)) {
+          const involvesRightmost = (children) => children.some(
+            (c) => !isSequenceBlock(c) && !isSequenceNote(c) && !isSequenceSection(c) && "from" in c && (c.from === rightmostId || c.to === rightmostId)
+          );
+          if (involvesRightmost(el.children) || involvesRightmost(el.elseChildren) || el.elseIfBranches?.some((b) => involvesRightmost(b.children)))
+            return true;
+          if (hasBlockWithRightmost(el.children) || hasBlockWithRightmost(el.elseChildren) || el.elseIfBranches?.some((b) => hasBlockWithRightmost(b.children)))
+            return true;
+        }
+      }
+      return false;
+    };
+    if (elements && hasBlockWithRightmost(elements))
+      rightProjection = Math.max(rightProjection, sBoxW / 2 + blockFramePadX);
+  }
+  let rightMargin = Math.max(rightProjection + 10, sGap / 2);
+  let leftMargin = sGap / 2;
+  const diagramWidth = participants.length * sGap;
+  let totalWidth = Math.max(
+    leftMargin + diagramWidth + rightMargin,
+    sBoxW + 40
+  );
+  const contentHeight = participantStartY + sBoxH + Math.max(lifelineLength, 40) + 40;
+  const totalHeight = contentHeight;
+  let svgWidth = Math.max(totalWidth, containerWidth);
+  let offsetX = leftMargin + Math.max(0, (svgWidth - totalWidth) / 2);
+  const participantX = /* @__PURE__ */ new Map();
+  const buildParticipantX = () => {
+    let px = offsetX;
+    participantX.clear();
+    participants.forEach((p, i) => {
+      participantX.set(p.id, px);
+      if (i < participants.length - 1) {
+        const nextId = participants[i + 1].id;
+        px += groupBoundaryIds.has(nextId) ? sBetweenGap : sWithinGap;
+      }
+    });
+  };
+  buildParticipantX();
+  let contentLeft = 0;
+  let contentRight = svgWidth;
+  for (const step of renderSteps) {
+    if (!step.label) continue;
+    const labelW = measureText(step.label, 12);
+    if (step.from === step.to) {
+      const px = participantX.get(step.from);
+      if (px !== void 0) {
+        const loopRight = px + sActivationWidth / 2 + sSelfCallWidth + 5 + labelW;
+        contentRight = Math.max(contentRight, loopRight);
+      }
+    } else {
+      const fromX = participantX.get(step.from);
+      const toX = participantX.get(step.to);
+      if (fromX !== void 0 && toX !== void 0) {
+        const midX = (fromX + toX) / 2;
+        contentLeft = Math.min(contentLeft, midX - labelW / 2);
+        contentRight = Math.max(contentRight, midX + labelW / 2);
+      }
+    }
+  }
+  if (elements) {
+    const scanNotes = (els) => {
+      for (const el of els) {
+        if (isSequenceNote(el)) {
+          const note = el;
+          const pos = effectiveNotePosition(note);
+          if (pos === "right") {
+            const px = participantX.get(note.participantId);
+            if (px !== void 0) {
+              const sc = isNoteAfterSelfCall(note);
+              const rOff = sc ? sActivationWidth / 2 + sSelfCallWidth + sNoteGap : sActivationWidth + sNoteGap;
+              const maxW = noteEffectiveMaxW(note.participantId, pos, sc);
+              contentRight = Math.max(contentRight, px + rOff + maxW);
+            }
+          }
+        } else if (isSequenceBlock(el)) {
+          scanNotes(el.children);
+          scanNotes(el.elseChildren);
+          if (el.elseIfBranches) {
+            for (const b of el.elseIfBranches) scanNotes(b.children);
+          }
+        }
+      }
+    };
+    scanNotes(elements);
+  }
+  const neededLeftPad = Math.max(0, -contentLeft);
+  const neededRightPad = Math.max(0, contentRight - svgWidth);
+  if (neededLeftPad > 0 || neededRightPad > 0) {
+    leftMargin += neededLeftPad;
+    rightMargin += neededRightPad;
+    totalWidth = Math.max(leftMargin + diagramWidth + rightMargin, sBoxW + 40);
+    svgWidth = Math.max(totalWidth, containerWidth);
+    offsetX = leftMargin + Math.max(0, (svgWidth - totalWidth) / 2);
+    buildParticipantX();
+  }
+  const svg = d3Selection.select(container).append("svg").attr("width", "100%").attr("height", totalHeight).attr("viewBox", `0 0 ${svgWidth} ${totalHeight}`).attr("preserveAspectRatio", "xMidYMin meet").attr("class", "sequence-diagram").style("font-family", FONT_FAMILY);
+  const defs = svg.append("defs");
+  defs.append("marker").attr("id", "seq-arrowhead").attr("viewBox", `0 0 ${sArrowheadSize} ${sArrowheadSize}`).attr("refX", sArrowheadSize).attr("refY", sArrowheadSize / 2).attr("markerWidth", sArrowheadSize).attr("markerHeight", sArrowheadSize).attr("orient", "auto").append("polygon").attr(
+    "points",
+    `0,0 ${sArrowheadSize},${sArrowheadSize / 2} 0,${sArrowheadSize}`
+  ).attr("fill", palette.text);
+  defs.append("marker").attr("id", "seq-arrowhead-open").attr("viewBox", `0 0 ${sArrowheadSize} ${sArrowheadSize}`).attr("refX", sArrowheadSize).attr("refY", sArrowheadSize / 2).attr("markerWidth", sArrowheadSize).attr("markerHeight", sArrowheadSize).attr("orient", "auto").append("polyline").attr(
+    "points",
+    `0,0 ${sArrowheadSize},${sArrowheadSize / 2} 0,${sArrowheadSize}`
+  ).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 1.2);
+  defs.append("marker").attr("id", "seq-arrowhead-async").attr("viewBox", `0 0 ${sArrowheadSize} ${sArrowheadSize}`).attr("refX", sArrowheadSize).attr("refY", sArrowheadSize / 2).attr("markerWidth", sArrowheadSize).attr("markerHeight", sArrowheadSize).attr("orient", "auto").append("polyline").attr(
+    "points",
+    `0,0 ${sArrowheadSize},${sArrowheadSize / 2} 0,${sArrowheadSize}`
+  ).attr("fill", "none").attr("stroke", palette.text).attr("stroke-width", 1.2);
+  const arrowPoints = `0,0 ${sArrowheadSize},${sArrowheadSize / 2} 0,${sArrowheadSize}`;
+  for (const [, color] of tagValueToColor) {
+    const hex = color.replace("#", "");
+    defs.append("marker").attr("id", `seq-arrowhead-c${hex}`).attr("viewBox", `0 0 ${sArrowheadSize} ${sArrowheadSize}`).attr("refX", sArrowheadSize).attr("refY", sArrowheadSize / 2).attr("markerWidth", sArrowheadSize).attr("markerHeight", sArrowheadSize).attr("orient", "auto").append("polygon").attr("points", arrowPoints).attr("fill", color);
+    defs.append("marker").attr("id", `seq-arrowhead-async-c${hex}`).attr("viewBox", `0 0 ${sArrowheadSize} ${sArrowheadSize}`).attr("refX", sArrowheadSize).attr("refY", sArrowheadSize / 2).attr("markerWidth", sArrowheadSize).attr("markerHeight", sArrowheadSize).attr("orient", "auto").append("polyline").attr("points", arrowPoints).attr("fill", "none").attr("stroke", color).attr("stroke-width", 1.2);
+    defs.append("marker").attr("id", `seq-arrowhead-open-c${hex}`).attr("viewBox", `0 0 ${sArrowheadSize} ${sArrowheadSize}`).attr("refX", sArrowheadSize).attr("refY", sArrowheadSize / 2).attr("markerWidth", sArrowheadSize).attr("markerHeight", sArrowheadSize).attr("orient", "auto").append("polyline").attr("points", arrowPoints).attr("fill", "none").attr("stroke", color).attr("stroke-width", 1.2);
+  }
+  const coloredMarker = (type, tagColor) => {
+    if (tagColor) {
+      const hex = tagColor.replace("#", "");
+      switch (type) {
+        case "call":
+          return `url(#seq-arrowhead-c${hex})`;
+        case "async":
+          return `url(#seq-arrowhead-async-c${hex})`;
+        case "return":
+          return `url(#seq-arrowhead-open-c${hex})`;
+      }
+    }
+    switch (type) {
+      case "call":
+        return "url(#seq-arrowhead)";
+      case "async":
+        return "url(#seq-arrowhead-async)";
+      case "return":
+        return "url(#seq-arrowhead-open)";
+    }
+  };
+  if (showTitle) {
+    const titleEl = svg.append("text").attr("class", "chart-title").attr("x", svgWidth / 2).attr("y", ctx.structural(TITLE_Y)).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-size", ctx.text(TITLE_FONT_SIZE)).attr("font-weight", TITLE_FONT_WEIGHT).text(title);
+    if (parsed.titleLineNumber) {
+      titleEl.attr("data-line-number", parsed.titleLineNumber);
+    }
+  }
+  const hasTagGroups = parsed.tagGroups.length > 0;
+  const collapsedGroupNames = /* @__PURE__ */ new Set();
+  const collapsedGroupMeta = /* @__PURE__ */ new Map();
+  for (const group of parsed.groups) {
+    if (effectiveCollapsedGroups.has(group.lineNumber)) {
+      collapsedGroupNames.add(group.name);
+      collapsedGroupMeta.set(group.name, {
+        lineNumber: group.lineNumber,
+        ...group.metadata !== void 0 && { metadata: group.metadata }
+      });
+    }
+  }
+  for (const group of groups) {
+    if (group.participantIds.length === 0) continue;
+    const memberXs = group.participantIds.map((id) => participantX.get(id)).filter((x) => x !== void 0);
+    if (memberXs.length === 0) continue;
+    const minX = Math.min(...memberXs) - sBoxW / 2 - GROUP_PADDING_X;
+    const maxX = Math.max(...memberXs) + sBoxW / 2 + GROUP_PADDING_X;
+    const boxY = participantStartY - GROUP_PADDING_TOP;
+    const boxH = sBoxH + GROUP_PADDING_TOP + GROUP_PADDING_BOTTOM;
+    const groupTagValue = tagKey && group.metadata?.[tagKey];
+    const groupTagColor = getTagColor(groupTagValue || void 0);
+    const fillColor = groupTagColor ? mix(groupTagColor, themeBaseBg(palette, isDark), isDark ? 15 : 20) : isDark ? palette.surface : palette.bg;
+    const strokeColor = groupTagColor || palette.textMuted;
+    const groupG = svg.append("g").attr("class", "group-box-wrapper").attr("data-group-toggle", "").attr("data-group-line", String(group.lineNumber)).attr("tabindex", "0").attr("role", "button").attr("aria-expanded", "true").attr("cursor", "pointer");
+    groupG.append("title").text("Click to collapse");
+    groupG.append("rect").attr("x", minX).attr("y", boxY).attr("width", maxX - minX).attr("height", boxH).attr("rx", 6).attr("fill", fillColor).attr("stroke", strokeColor).attr("stroke-width", 1).attr("stroke-opacity", 0.5).attr("pointer-events", "none").attr("class", "group-box");
+    groupG.append("rect").attr("x", minX).attr("y", boxY).attr("width", maxX - minX).attr("height", participantStartY - boxY).attr("fill", "transparent").attr("class", "group-label-hit");
+    groupG.append("text").attr("x", (minX + maxX) / 2).attr("y", boxY + GROUP_LABEL_SIZE + 4).attr("text-anchor", "middle").attr("fill", strokeColor).attr("font-size", GROUP_LABEL_SIZE).attr("font-weight", "bold").attr("opacity", 0.7).attr("pointer-events", "none").attr("class", "group-label").text(group.name);
+  }
+  const lifelineStartY = lifelineStartY0;
+  participants.forEach((participant) => {
+    const cx = participantX.get(participant.id);
+    const cy = participantStartY;
+    const pTagValue = tagMap?.participants.get(participant.id);
+    const pTagColor = getTagColor(pTagValue);
+    const pTagAttr = tagKey && pTagValue ? { key: tagKey, value: pTagValue.toLowerCase() } : void 0;
+    const isCollapsedGroup = collapsedGroupNames.has(participant.id);
+    let effectiveTagColor = pTagColor;
+    if (isCollapsedGroup && !effectiveTagColor) {
+      const meta = collapsedGroupMeta.get(participant.id);
+      if (meta?.metadata && tagKey) {
+        effectiveTagColor = getTagColor(meta.metadata[tagKey]);
+      }
+    }
+    renderParticipant(
+      svg,
+      participant,
+      cx,
+      cy,
+      palette,
+      isDark,
+      effectiveTagColor,
+      pTagAttr,
+      solid,
+      sBoxW,
+      sBoxH,
+      sLabelTextWidth,
+      sLabelFontSize
+    );
+    if (isCollapsedGroup) {
+      const meta = collapsedGroupMeta.get(participant.id);
+      const drillColor = effectiveTagColor || palette.textMuted;
+      const drillBarH = 6;
+      const boxW = sBoxW;
+      const fullH = sBoxH + GROUP_PADDING_TOP + GROUP_PADDING_BOTTOM;
+      const clipId = `clip-drill-group-${participant.id.replace(/[^a-zA-Z0-9-]/g, "-")}`;
+      const participantG = svg.select(
+        `.participant[data-participant-id="${participant.id}"]`
+      );
+      participantG.attr("data-group-toggle", "").attr("data-group-line", String(meta.lineNumber)).attr("tabindex", "0").attr("role", "button").attr("aria-expanded", "false").attr("cursor", "pointer");
+      participantG.append("title").text("Click to expand");
+      const pFill = effectiveTagColor ? mix(effectiveTagColor, themeBaseBg(palette, isDark), isDark ? 30 : 40) : isDark ? mix(palette.overlay, palette.surface, 50) : mix(palette.bg, palette.surface, 50);
+      const pStroke = effectiveTagColor || palette.border;
+      participantG.append("rect").attr("x", -boxW / 2).attr("y", -GROUP_PADDING_TOP).attr("width", boxW).attr("height", fullH).attr("rx", 6).attr("fill", pFill).attr("stroke", pStroke).attr("stroke-width", 1.5);
+      participantG.append("text").attr("x", 0).attr("y", -GROUP_PADDING_TOP + fullH / 2).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", palette.text).attr("font-size", ctx.text(13)).attr("font-weight", 500).text(participant.label);
+      participantG.append("clipPath").attr("id", clipId).append("rect").attr("x", -boxW / 2).attr("y", -GROUP_PADDING_TOP).attr("width", boxW).attr("height", fullH).attr("rx", 6);
+      participantG.append("rect").attr("class", "sequence-drill-bar").attr("x", -boxW / 2).attr("y", -GROUP_PADDING_TOP + fullH - drillBarH).attr("width", boxW).attr("height", drillBarH).attr("fill", drillColor).attr("clip-path", `url(#${clipId})`);
+    }
+    const llY = isCollapsedGroup ? lifelineStartY + GROUP_PADDING_BOTTOM : participant.type === "actor" ? lifelineStartY + ACTOR_LABEL_CLEARANCE : lifelineStartY;
+    const llColor = isCollapsedGroup ? effectiveTagColor || palette.textMuted : pTagColor || palette.textMuted;
+    const lifelineEl = svg.append("line").attr("x1", cx).attr("y1", llY).attr("x2", cx).attr("y2", lifelineStartY + lifelineLength).attr("stroke", llColor).attr("stroke-width", 1).attr("stroke-dasharray", "6 4").attr("class", "lifeline").attr("data-participant-id", participant.id);
+    if (tagKey && pTagValue) {
+      lifelineEl.attr(`data-tag-${tagKey}`, pTagValue.toLowerCase());
+    }
+  });
+  const FRAME_PADDING_X = 30;
+  const FRAME_PADDING_BOTTOM = 15;
+  const FRAME_LABEL_HEIGHT = 18;
+  const SELF_ARROW_PROJECTION = sActivationWidth / 2 + sSelfCallWidth;
+  const SELF_ARROW_FRAME_PAD = 10;
+  const frameRightmostX = Math.max(...Array.from(participantX.values()));
+  const collectMsgIndices = (els) => {
+    const indices = [];
+    for (const el of els) {
+      if (isSequenceBlock(el)) {
+        indices.push(
+          ...collectMsgIndices(el.children),
+          ...collectMsgIndices(el.elseChildren)
+        );
+        if (el.elseIfBranches) {
+          for (const branch of el.elseIfBranches) {
+            indices.push(...collectMsgIndices(branch.children));
+          }
+        }
+      } else if (!isSequenceSection(el) && !isSequenceNote(el)) {
+        const idx = messages.indexOf(el);
+        if (idx >= 0) indices.push(idx);
+      }
+    }
+    return indices;
+  };
+  const deferredLabels = [];
+  const deferredLines = [];
+  const renderBlockFrames = (els, depth) => {
+    for (const el of els) {
+      if (!isSequenceBlock(el)) continue;
+      const ifIndices = collectMsgIndices(el.children);
+      const elseIfBranchData = [];
+      if (el.elseIfBranches) {
+        for (const branch of el.elseIfBranches) {
+          elseIfBranchData.push({
+            label: branch.label,
+            indices: collectMsgIndices(branch.children),
+            lineNumber: branch.lineNumber
+          });
+        }
+      }
+      const elseIndices = collectMsgIndices(el.elseChildren);
+      const allIndices = [
+        ...ifIndices,
+        ...elseIfBranchData.flatMap((b) => b.indices),
+        ...elseIndices
+      ];
+      if (allIndices.length === 0) continue;
+      let minStep = Infinity;
+      let maxStep = -Infinity;
+      for (const mi of allIndices) {
+        const first = msgToFirstStep.get(mi);
+        const last = msgToLastStep.get(mi);
+        if (first !== void 0) minStep = Math.min(minStep, first);
+        if (last !== void 0) maxStep = Math.max(maxStep, last);
+      }
+      if (minStep === Infinity) continue;
+      const involved = /* @__PURE__ */ new Set();
+      for (const mi of allIndices) {
+        const m = messages[mi];
+        involved.add(m.from);
+        involved.add(m.to);
+      }
+      let minPX = Infinity;
+      let maxPX = -Infinity;
+      for (const pid of involved) {
+        const px = participantX.get(pid);
+        if (px !== void 0) {
+          minPX = Math.min(minPX, px);
+          maxPX = Math.max(maxPX, px);
+        }
+      }
+      let extraRight = 0;
+      let maxStepIsSelfCall = false;
+      for (const mi of allIndices) {
+        const m = messages[mi];
+        if (m.from === m.to) {
+          const px = participantX.get(m.from);
+          if (px !== void 0) {
+            const loopMax = px + SELF_ARROW_PROJECTION;
+            const need = loopMax - (maxPX + FRAME_PADDING_X) + SELF_ARROW_FRAME_PAD;
+            if (need > 0) extraRight = Math.max(extraRight, need);
+          }
+          if (msgToLastStep.get(mi) === maxStep) {
+            maxStepIsSelfCall = true;
+          }
+        }
+      }
+      const frameX = minPX - FRAME_PADDING_X;
+      const frameY = stepY(minStep) - FRAME_PADDING_TOP;
+      const frameW = maxPX - minPX + FRAME_PADDING_X * 2 + extraRight;
+      const frameH = stepY(maxStep) - stepY(minStep) + FRAME_PADDING_TOP + FRAME_PADDING_BOTTOM + (maxStepIsSelfCall ? sSelfCallHeight : 0);
+      svg.append("rect").attr("x", frameX).attr("y", frameY).attr("width", frameW).attr("height", frameH).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 1).attr("stroke-dasharray", "2 3").attr("rx", 3).attr("ry", 3).attr("class", "block-frame").attr("data-block-line", String(el.lineNumber));
+      deferredLabels.push({
+        x: frameX + 6,
+        y: frameY + FRAME_LABEL_HEIGHT - 4,
+        text: `${el.type} ${el.label}`,
+        bold: false,
+        italic: false,
+        blockLine: el.lineNumber
+      });
+      for (const branchData of elseIfBranchData) {
+        if (branchData.indices.length > 0) {
+          let firstBranchStep = Infinity;
+          for (const mi of branchData.indices) {
+            const first = msgToFirstStep.get(mi);
+            if (first !== void 0)
+              firstBranchStep = Math.min(firstBranchStep, first);
+          }
+          if (firstBranchStep < Infinity) {
+            const dividerY = stepY(firstBranchStep) - BLOCK_HEADER_SPACE;
+            deferredLines.push({
+              x1: frameX,
+              y1: dividerY,
+              x2: frameX + frameW,
+              y2: dividerY,
+              blockLine: branchData.lineNumber
+            });
+            deferredLabels.push({
+              x: frameX + 6,
+              y: dividerY + 14,
+              text: `else if ${branchData.label}`,
+              bold: false,
+              italic: false,
+              blockLine: branchData.lineNumber
+            });
+          }
+        }
+      }
+      if (elseIndices.length > 0) {
+        let firstElseStep = Infinity;
+        for (const mi of elseIndices) {
+          const first = msgToFirstStep.get(mi);
+          if (first !== void 0)
+            firstElseStep = Math.min(firstElseStep, first);
+        }
+        if (firstElseStep < Infinity) {
+          const dividerY = stepY(firstElseStep) - BLOCK_HEADER_SPACE;
+          deferredLines.push({
+            x1: frameX,
+            y1: dividerY,
+            x2: frameX + frameW,
+            y2: dividerY,
+            ...el.elseLineNumber !== void 0 && {
+              blockLine: el.elseLineNumber
+            }
+          });
+          deferredLabels.push({
+            x: frameX + 6,
+            y: dividerY + 14,
+            text: "else",
+            bold: false,
+            italic: false,
+            ...el.elseLineNumber !== void 0 && {
+              blockLine: el.elseLineNumber
+            }
+          });
+        }
+      }
+      renderBlockFrames(el.children, depth + 1);
+      if (el.elseIfBranches) {
+        for (const branch of el.elseIfBranches) {
+          renderBlockFrames(branch.children, depth + 1);
+        }
+      }
+      renderBlockFrames(el.elseChildren, depth + 1);
+    }
+  };
+  if (elements && elements.length > 0) {
+    renderBlockFrames(elements, 0);
+  }
+  const ACTIVATION_NEST_OFFSET = ctx.structural(6);
+  activations.forEach((act) => {
+    const px = participantX.get(act.participantId);
+    if (px === void 0) return;
+    const x = px - sActivationWidth / 2 + act.depth * ACTIVATION_NEST_OFFSET;
+    const y1 = stepY(act.startStep);
+    const y2 = stepY(act.endStep);
+    const coveredLines = [];
+    for (let si = act.startStep; si <= act.endStep; si++) {
+      const step = renderSteps[si];
+      if (!step) continue;
+      const msg = messages[step.messageIndex];
+      if (msg) coveredLines.push(msg.lineNumber);
+    }
+    const triggerStep = renderSteps[act.startStep];
+    const triggerMsg = triggerStep !== void 0 ? messages[triggerStep.messageIndex] : void 0;
+    const actTagValue = triggerMsg ? tagMap?.messages.get(triggerMsg.lineNumber) : void 0;
+    const actTagColor = getTagColor(actTagValue);
+    const actBaseColor = actTagColor || palette.primary;
+    svg.append("rect").attr("x", x).attr("y", y1).attr("width", sActivationWidth).attr("height", y2 - y1).attr("fill", themeBaseBg(palette, isDark));
+    const actFill = shapeFill(palette, actBaseColor, isDark, { solid });
+    const actRect = svg.append("rect").attr("x", x).attr("y", y1).attr("width", sActivationWidth).attr("height", y2 - y1).attr("fill", actFill).attr("stroke", actBaseColor).attr("stroke-width", 1).attr("stroke-opacity", 0.5).attr("data-participant-id", act.participantId).attr("data-msg-lines", coveredLines.join(",")).attr("data-line-number", coveredLines[0] ?? "").attr("class", "activation");
+    if (tagKey && actTagValue) {
+      actRect.attr(`data-tag-${tagKey}`, actTagValue.toLowerCase());
+    }
+  });
+  for (const ln of deferredLines) {
+    const line = svg.append("line").attr("x1", ln.x1).attr("y1", ln.y1).attr("x2", ln.x2).attr("y2", ln.y2).attr("stroke", palette.textMuted).attr("stroke-width", 1).attr("stroke-dasharray", "2 3").attr("class", "block-divider");
+    if (ln.blockLine !== void 0)
+      line.attr("data-block-line", String(ln.blockLine));
+  }
+  for (const lbl of deferredLabels) {
+    const t = svg.append("text").attr("x", lbl.x).attr("y", lbl.y).attr("fill", palette.text).attr("font-size", 11).attr("class", "block-label").text(lbl.text);
+    if (lbl.bold) t.attr("font-weight", "bold");
+    if (lbl.italic) t.attr("font-style", "italic");
+    if (lbl.blockLine !== void 0)
+      t.attr("data-block-line", String(lbl.blockLine));
+  }
+  const activeDepthAt = (pid, stepIdx) => {
+    let maxDepth = -1;
+    for (const act of activations) {
+      if (act.participantId === pid && act.startStep <= stepIdx && stepIdx <= act.endStep && act.depth > maxDepth) {
+        maxDepth = act.depth;
+      }
+    }
+    return maxDepth;
+  };
+  const arrowEdgeX = (pid, stepIdx, side) => {
+    const px = participantX.get(pid);
+    const depth = activeDepthAt(pid, stepIdx);
+    if (depth < 0) return px;
+    const offset = depth * ACTIVATION_NEST_OFFSET;
+    return side === "right" ? px + sActivationWidth / 2 + offset : px - sActivationWidth / 2 + offset;
+  };
+  const leftmostX = Math.min(...Array.from(participantX.values()));
+  const rightmostX = frameRightmostX;
+  const sectionLineX1 = leftmostX - sBoxW / 2 - 10;
+  const sectionLineX2 = rightmostX + sBoxW / 2 + 10;
+  for (const region of sectionRegions) {
+    const sec = region.section;
+    const secY = sectionYPositions.get(sec.lineNumber);
+    if (secY === void 0) continue;
+    const isCollapsed = collapsedSections?.has(sec.lineNumber) ?? false;
+    const lineColor = palette.textMuted;
+    const sectionG = svg.append("g").attr("data-section-toggle", "").attr("data-line-number", String(sec.lineNumber)).attr("data-section", "").attr("tabindex", "0").attr("role", "button").attr("aria-expanded", String(!isCollapsed));
+    const BAND_HEIGHT = 22;
+    const bandX = sectionLineX1 - 10;
+    const bandWidth = sectionLineX2 - sectionLineX1 + 20;
+    const bandOpacity = isCollapsed ? isDark ? 0.35 : 0.25 : isDark ? 0.1 : 0.08;
+    sectionG.append("rect").attr("x", bandX).attr("y", secY - BAND_HEIGHT / 2).attr("width", bandWidth).attr("height", BAND_HEIGHT).attr("fill", lineColor).attr("opacity", bandOpacity).attr("rx", 2).attr("pointer-events", "none").attr("class", "section-divider");
+    const msgCount = sectionMsgCounts.get(sec.lineNumber) ?? 0;
+    const labelText = isCollapsed ? `${sec.label} (${msgCount} ${msgCount === 1 ? "message" : "messages"})` : sec.label;
+    const labelX = (sectionLineX1 + sectionLineX2) / 2;
+    const labelHitW = Math.max(80, measureText(labelText, 11) + 24);
+    sectionG.append("rect").attr("x", labelX - labelHitW / 2).attr("y", secY - BAND_HEIGHT / 2).attr("width", labelHitW).attr("height", BAND_HEIGHT).attr("fill", "transparent").attr("class", "section-label-hit");
+    sectionG.append("text").attr("x", labelX).attr("y", secY + 4).attr("text-anchor", "middle").attr("fill", lineColor).attr("font-size", 11).attr("font-weight", "bold").attr("class", "section-label").text(labelText);
+  }
+  renderSteps.forEach((step, i) => {
+    const fromX = participantX.get(step.from);
+    const toX = participantX.get(step.to);
+    if (fromX === void 0 || toX === void 0) return;
+    const y = stepY(i);
+    const HIT_H = 20;
+    const msg = messages[step.messageIndex];
+    const msgTagValue = msg ? tagMap?.messages.get(msg.lineNumber) : void 0;
+    const msgTagColor = getTagColor(msgTagValue);
+    if (step.type === "call") {
+      const arrowColor = msgTagColor || palette.text;
+      if (step.from === step.to) {
+        const x = arrowEdgeX(step.from, i, "right");
+        const loopX = x + sSelfCallWidth;
+        const hitX = x;
+        svg.append("rect").attr("x", hitX).attr("y", y - 5).attr("width", sSelfCallWidth).attr("height", sSelfCallHeight + 10).attr("fill", "transparent").attr("class", "message-hit-area").attr("data-line-number", String(msg.lineNumber)).attr("data-msg-index", String(step.messageIndex)).attr("data-step-index", String(i));
+        const selfCallEl = svg.append("path").attr("d", `M ${x} ${y} H ${loopX} V ${y + sSelfCallHeight} H ${x}`).attr("fill", "none").attr("stroke", arrowColor).attr("stroke-width", 1.2).attr("marker-end", coloredMarker("call", msgTagColor)).attr("class", "message-arrow self-call").attr("data-line-number", String(msg.lineNumber)).attr("data-msg-index", String(step.messageIndex)).attr("data-step-index", String(i)).attr("data-from", step.from).attr("data-to", step.to);
+        if (tagKey && msgTagValue) {
+          selfCallEl.attr(`data-tag-${tagKey}`, msgTagValue.toLowerCase());
+        }
+        if (step.label) {
+          const labelEl = svg.append("text").attr("x", loopX + 5).attr("y", y + sSelfCallHeight / 2 + 4).attr("text-anchor", "start").attr("fill", arrowColor).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 4).attr("stroke-linejoin", "round").attr("font-size", 12).attr("class", "message-label").attr("data-line-number", String(msg.lineNumber)).attr("data-msg-index", String(step.messageIndex)).attr("data-step-index", String(i));
+          if (tagKey && msgTagValue) {
+            labelEl.attr(`data-tag-${tagKey}`, msgTagValue.toLowerCase());
+          }
+          labelEl.text(step.label);
+        }
+      } else {
+        const goingRight = fromX < toX;
+        const x1 = arrowEdgeX(step.from, i, goingRight ? "right" : "left");
+        const x2 = arrowEdgeX(step.to, i, goingRight ? "left" : "right");
+        svg.append("rect").attr("x", Math.min(x1, x2)).attr("y", y - HIT_H / 2).attr("width", Math.abs(x2 - x1)).attr("height", HIT_H).attr("fill", "transparent").attr("class", "message-hit-area").attr("data-line-number", String(msg.lineNumber)).attr("data-msg-index", String(step.messageIndex)).attr("data-step-index", String(i));
+        const markerRef = step.async ? coloredMarker("async", msgTagColor) : coloredMarker("call", msgTagColor);
+        const arrowEl = svg.append("line").attr("x1", x1).attr("y1", y).attr("x2", x2).attr("y2", y).attr("stroke", arrowColor).attr("stroke-width", 1.2).attr("marker-end", markerRef).attr("class", "message-arrow").attr("data-line-number", String(msg.lineNumber)).attr("data-msg-index", String(step.messageIndex)).attr("data-step-index", String(i)).attr("data-from", step.from).attr("data-to", step.to);
+        if (tagKey && msgTagValue) {
+          arrowEl.attr(`data-tag-${tagKey}`, msgTagValue.toLowerCase());
+        }
+        if (step.label) {
+          const midX = (x1 + x2) / 2;
+          const labelEl = svg.append("text").attr("x", midX).attr("y", y - 8).attr("text-anchor", "middle").attr("fill", arrowColor).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 4).attr("stroke-linejoin", "round").attr("font-size", 12).attr("class", "message-label").attr("data-line-number", String(msg.lineNumber)).attr("data-msg-index", String(step.messageIndex)).attr("data-step-index", String(i));
+          if (tagKey && msgTagValue) {
+            labelEl.attr(`data-tag-${tagKey}`, msgTagValue.toLowerCase());
+          }
+          labelEl.text(step.label);
+        }
+      }
+    } else {
+      if (step.from === step.to) {
+        return;
+      }
+      const goingRight = fromX < toX;
+      const x1 = arrowEdgeX(step.from, i, goingRight ? "right" : "left");
+      const x2 = arrowEdgeX(step.to, i, goingRight ? "left" : "right");
+      const returnColor = msgTagColor || palette.textMuted;
+      svg.append("rect").attr("x", Math.min(x1, x2)).attr("y", y - HIT_H / 2).attr("width", Math.abs(x2 - x1)).attr("height", HIT_H).attr("fill", "transparent").attr("class", "message-hit-area").attr("data-line-number", String(msg.lineNumber)).attr("data-msg-index", String(step.messageIndex)).attr("data-step-index", String(i));
+      const returnEl = svg.append("line").attr("x1", x1).attr("y1", y).attr("x2", x2).attr("y2", y).attr("stroke", returnColor).attr("stroke-width", 1).attr("stroke-dasharray", "6 4").attr("marker-end", coloredMarker("return", msgTagColor)).attr("class", "return-arrow").attr("data-line-number", String(msg.lineNumber)).attr("data-msg-index", String(step.messageIndex)).attr("data-step-index", String(i)).attr("data-from", step.from).attr("data-to", step.to);
+      if (tagKey && msgTagValue) {
+        returnEl.attr(`data-tag-${tagKey}`, msgTagValue.toLowerCase());
+      }
+      if (step.label) {
+        const midX = (x1 + x2) / 2;
+        const labelEl = svg.append("text").attr("x", midX).attr("y", y - 6).attr("text-anchor", "middle").attr("fill", returnColor).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 4).attr("stroke-linejoin", "round").attr("font-size", 11).attr("class", "message-label").attr("data-line-number", String(msg.lineNumber)).attr("data-msg-index", String(step.messageIndex)).attr("data-step-index", String(i));
+        if (tagKey && msgTagValue) {
+          labelEl.attr(`data-tag-${tagKey}`, msgTagValue.toLowerCase());
+        }
+        labelEl.text(step.label);
+      }
+    }
+  });
+  const noteFill = isDark ? mix(palette.surface, palette.bg, 50) : mix(palette.bg, palette.surface, 15);
+  const renderNoteElements = (els) => {
+    for (const el of els) {
+      if (isSequenceNote(el)) {
+        const px = participantX.get(el.participantId);
+        if (px === void 0) continue;
+        const noteTopY = noteYMap.get(el);
+        if (noteTopY === void 0) continue;
+        const position = effectiveNotePosition(el);
+        const isRight = position === "right";
+        const afterSelfCall = isNoteAfterSelfCall(el);
+        const maxW = noteEffectiveMaxW(
+          el.participantId,
+          position,
+          afterSelfCall
+        );
+        const textWidth = noteTextWidth(maxW);
+        const wrappedLines = wrapTextLines(el.text, textWidth, sNoteFontSize);
+        const noteH = wrappedLines.length * sNoteLineH + sNotePadV * 2;
+        const maxLineW = Math.max(
+          ...wrappedLines.map((l) => measureText(l.text, sNoteFontSize))
+        );
+        const noteW = Math.min(
+          maxW,
+          Math.max(80, maxLineW + sNotePadH * 2 + sNoteFold)
+        );
+        const rightOffset = afterSelfCall && isRight ? sActivationWidth / 2 + sSelfCallWidth + sNoteGap : sActivationWidth + sNoteGap;
+        const noteX = isRight ? px + rightOffset : px - sActivationWidth - sNoteGap - noteW;
+        const noteG = svg.append("g").attr("class", "note").attr("data-note-toggle", "").attr("data-line-number", String(el.lineNumber)).attr("data-line-end", String(el.endLineNumber));
+        noteG.append("path").attr(
+          "d",
+          [
+            `M ${noteX} ${noteTopY}`,
+            `L ${noteX + noteW - sNoteFold} ${noteTopY}`,
+            `L ${noteX + noteW} ${noteTopY + sNoteFold}`,
+            `L ${noteX + noteW} ${noteTopY + noteH}`,
+            `L ${noteX} ${noteTopY + noteH}`,
+            "Z"
+          ].join(" ")
+        ).attr("fill", noteFill).attr("stroke", palette.textMuted).attr("stroke-width", 0.75).attr("class", "note-box");
+        noteG.append("path").attr(
+          "d",
+          [
+            `M ${noteX + noteW - sNoteFold} ${noteTopY}`,
+            `L ${noteX + noteW - sNoteFold} ${noteTopY + sNoteFold}`,
+            `L ${noteX + noteW} ${noteTopY + sNoteFold}`
+          ].join(" ")
+        ).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 0.75).attr("class", "note-fold");
+        const BULLET_BODY_INDENT = 10;
+        wrappedLines.forEach((line, li) => {
+          const textY = noteTopY + sNotePadV + (li + 1) * sNoteLineH - 3;
+          const indent = line.kind === "plain" ? 0 : BULLET_BODY_INDENT;
+          if (line.kind === "bullet-first") {
+            noteG.append("text").attr("x", noteX + sNotePadH).attr("y", textY).attr("fill", palette.text).attr("font-size", sNoteFontSize).text("\u2022");
+          }
+          const textEl = noteG.append("text").attr("x", noteX + sNotePadH + indent).attr("y", textY).attr("fill", palette.text).attr("font-size", sNoteFontSize).attr("class", "note-text");
+          renderInlineText(textEl, line.text, palette, sNoteFontSize);
+        });
+      } else if (isSequenceBlock(el)) {
+        renderNoteElements(el.children);
+        if (el.elseIfBranches) {
+          for (const branch of el.elseIfBranches) {
+            renderNoteElements(branch.children);
+          }
+        }
+        renderNoteElements(el.elseChildren);
+      }
+    }
+  };
+  if (elements && elements.length > 0) {
+    renderNoteElements(elements);
+  }
+  if (hasTagGroups) {
+    const legendY = sTopMargin + titleOffset;
+    const legendCallbacks = {};
+    const legendG = svg.append("g").attr("class", "sequence-legend").attr("transform", `translate(0,${legendY})`);
+    renderIntegratedLegend(legendG, {
+      ...legendConfig,
+      palette,
+      isDark,
+      width: svgWidth,
+      activeGroup: activeTagGroup ?? null,
+      controlsExpanded: false,
+      callbacks: legendCallbacks
+    });
+  }
+}
+function buildNoteMessageMap(elements) {
+  const map = /* @__PURE__ */ new Map();
+  let lastMessageLine = -1;
+  const walk = (els) => {
+    for (const el of els) {
+      if (isSequenceNote(el)) {
+        if (lastMessageLine >= 0) {
+          map.set(el.lineNumber, lastMessageLine);
+        }
+      } else if (isSequenceBlock(el)) {
+        walk(el.children);
+        if (el.elseIfBranches) {
+          for (const branch of el.elseIfBranches) {
+            walk(branch.children);
+          }
+        }
+        walk(el.elseChildren);
+      } else if (!isSequenceSection(el)) {
+        lastMessageLine = el.lineNumber;
+      }
+    }
+  };
+  walk(elements);
+  return map;
+}
+function renderParticipant(svg, participant, cx, cy, palette, isDark, color, tagAttr, solid, boxW = W, boxH = H, labelTextW = labelTextWidth(W), labelFontSize = LABEL_FONT_SIZE) {
+  const g = svg.append("g").attr("transform", `translate(${cx}, ${cy})`).attr("class", "participant").attr("data-participant-id", participant.id);
+  if (tagAttr) {
+    g.attr(`data-tag-${tagAttr.key}`, tagAttr.value);
+  }
+  switch (participant.type) {
+    case "actor":
+      renderActorParticipant(g, palette, color, boxH);
+      break;
+    case "database":
+      renderDatabaseParticipant(g, palette, isDark, color, solid, boxW, boxH);
+      break;
+    case "queue":
+      renderQueueParticipant(g, palette, isDark, color, solid, boxW, boxH);
+      break;
+    case "cache":
+      renderCacheParticipant(g, palette, isDark, color, solid, boxW, boxH);
+      break;
+    default:
+      renderRectParticipant(g, palette, isDark, color, solid, boxW, boxH);
+      break;
+  }
+  const isActor = participant.type === "actor";
+  const labelLines = splitParticipantLabel(
+    participant.label,
+    labelTextW,
+    labelFontSize
+  );
+  const fontSize = labelFontSize;
+  const lineHeight = fontSize + 2;
+  const labelFill = isActor ? palette.text : contrastText(
+    fill(palette, isDark, color, solid),
+    palette.textOnFillLight,
+    palette.textOnFillDark
+  );
+  const textEl = g.append("text").attr("x", 0).attr("text-anchor", "middle").attr("fill", labelFill).attr("font-size", fontSize).attr("font-weight", 500);
+  const maxLabelW = labelTextWidth(boxW);
+  const truncLine = (text) => truncateText(text, fontSize, maxLabelW);
+  if (labelLines.length === 1) {
+    textEl.attr("y", isActor ? boxH + 14 : boxH / 2 + 5).text(truncLine(participant.label));
+  } else {
+    const totalHeight = labelLines.length * lineHeight;
+    const baseY = isActor ? boxH + 14 - (labelLines.length - 1) * lineHeight / 2 : boxH / 2 + 5 - (totalHeight - lineHeight) / 2;
+    labelLines.forEach((line, i) => {
+      textEl.append("tspan").attr("x", 0).attr("dy", i === 0 ? `${baseY}px` : `${lineHeight}px`).text(truncLine(line));
+    });
+  }
+}
+
+export {
+  applyCollapseProjection,
+  groupMessagesBySection,
+  buildRenderSequence,
+  computeActivations,
+  applyPositionOverrides,
+  applyGroupOrdering,
+  renderSequenceDiagram,
+  buildNoteMessageMap
+};
+//# sourceMappingURL=chunk-SRTU6HMQ.js.map