@shibayama/pdgkit 0.1.0

package/dist/core.cjs

@@ -0,0 +1,2378 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  OP_TABLE: () => OP_TABLE,
+  PATTERN_LABEL: () => PATTERN_LABEL,
+  PATTERN_SOURCE: () => PATTERN_SOURCE,
+  SAMPLES: () => SAMPLES,
+  SAMPLE_ORDER: () => SAMPLE_ORDER,
+  chooseLabelPlacement: () => chooseLabelPlacement,
+  estimateTextWidth: () => estimateTextWidth,
+  layout: () => layout,
+  parse: () => parse,
+  refsToCsv: () => refsToCsv,
+  refsToMarkdown: () => refsToMarkdown,
+  render: () => render,
+  splitBilingual: () => splitBilingual,
+  stripComment: () => stripComment
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/core/parser.ts
+var ID_PATTERN = /[A-Za-z0-9_*]+/.source;
+var OP_TABLE = [
+  { lit: "<->", kind: "bidir" },
+  { lit: "=>", kind: "thick" },
+  { lit: "->", kind: "arrow" },
+  { lit: "<-", kind: "arrow", reverse: true },
+  { lit: ".>", kind: "dashed-arrow" },
+  { lit: "..", kind: "dashed" },
+  { lit: "-", kind: "line" }
+];
+var DEF_RE = new RegExp(`^(${ID_PATTERN})\\s*=(?!>)\\s*(.*)$`);
+var CONN_RE = new RegExp(
+  `^(${ID_PATTERN})\\s+(<->|=>|->|<-|\\.>|\\.\\.|-)\\s+(${ID_PATTERN})\\s*(?::\\s*(.*))?$`
+);
+var CONT_RE = new RegExp(`^(${ID_PATTERN})\\s*:\\s*(.+)$`);
+function parse(source) {
+  const doc = {
+    nodes: /* @__PURE__ */ new Map(),
+    containments: [],
+    edges: [],
+    diagnostics: [],
+    kind: "block"
+  };
+  const lines = source.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const raw = stripComment(lines[i]);
+    const line = raw.trim();
+    if (!line) continue;
+    if (handleDef(line, i + 1, doc)) continue;
+    if (handleConn(line, i + 1, doc)) continue;
+    if (handleCont(line, i + 1, doc)) continue;
+    doc.diagnostics.push({
+      severity: "error",
+      line: i + 1,
+      col: 1,
+      message: `\u69CB\u6587\u4E0D\u660E: "${line}"`
+    });
+  }
+  doc.kind = inferKind(doc);
+  return doc;
+}
+function handleDef(line, lineNum, doc) {
+  const m = line.match(DEF_RE);
+  if (!m) return false;
+  const id = m[1];
+  const tail = m[2];
+  const label = splitBilingual(tail);
+  const existing = doc.nodes.get(id);
+  if (existing) {
+    doc.diagnostics.push({
+      severity: "warning",
+      line: lineNum,
+      col: 1,
+      message: `\u7B26\u53F7 "${id}" \u306F\u518D\u5B9A\u7FA9\u3055\u308C\u307E\u3057\u305F`
+    });
+  }
+  doc.nodes.set(id, {
+    id,
+    label,
+    implicit: false
+  });
+  return true;
+}
+function handleConn(line, lineNum, doc) {
+  const m = line.match(CONN_RE);
+  if (!m) return false;
+  const opLit = m[2];
+  const entry = OP_TABLE.find((o) => o.lit === opLit);
+  const from = entry.reverse ? m[3] : m[1];
+  const to = entry.reverse ? m[1] : m[3];
+  const labelText = m[4] ?? "";
+  const edge = {
+    from,
+    to,
+    op: entry.kind,
+    label: labelText.trim() ? splitBilingual(labelText) : void 0,
+    line: lineNum
+  };
+  doc.edges.push(edge);
+  ensureNode(doc, from);
+  ensureNode(doc, to);
+  return true;
+}
+function handleCont(line, lineNum, doc) {
+  const m = line.match(CONT_RE);
+  if (!m) return false;
+  const parent = m[1];
+  const rest = m[2].trim();
+  const children = rest.split(/\s+/).filter(Boolean);
+  const idRe = new RegExp(`^${ID_PATTERN}$`);
+  for (const c of children) {
+    if (!idRe.test(c)) {
+      doc.diagnostics.push({
+        severity: "error",
+        line: lineNum,
+        col: 1,
+        message: `\u5305\u542B\u306E\u5B50\u3068\u3057\u3066\u4E0D\u6B63\u306A\u30C8\u30FC\u30AF\u30F3: "${c}"`
+      });
+      return true;
+    }
+  }
+  doc.containments.push({ parent, children, line: lineNum });
+  ensureNode(doc, parent);
+  for (const c of children) ensureNode(doc, c);
+  return true;
+}
+function ensureNode(doc, id) {
+  let n = doc.nodes.get(id);
+  if (n) return n;
+  n = { id, label: {}, implicit: true };
+  doc.nodes.set(id, n);
+  return n;
+}
+function stripComment(line) {
+  let inQuote = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (c === '"') inQuote = !inQuote;
+    else if (!inQuote && c === "#") return line.slice(0, i);
+  }
+  return line;
+}
+function splitBilingual(text) {
+  const s = text.trim();
+  if (!s) return {};
+  const slashIdx = findBilingualSeparator(s);
+  if (slashIdx === -1) {
+    return { ja: stripQuotes(s) };
+  }
+  return {
+    ja: stripQuotes(s.slice(0, slashIdx).trim()),
+    en: stripQuotes(s.slice(slashIdx + 1).trim())
+  };
+}
+function findBilingualSeparator(s) {
+  let inQuote = false;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '"') {
+      inQuote = !inQuote;
+      continue;
+    }
+    if (!inQuote && s[i] === "/" && isSpace(s[i - 1]) && isSpace(s[i + 1])) return i;
+  }
+  return -1;
+}
+function isSpace(ch) {
+  return ch === " " || ch === "	";
+}
+function stripQuotes(s) {
+  if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function inferKind(doc) {
+  if (doc.containments.length > 0) return "block";
+  for (const n of doc.nodes.values()) {
+    const ja = n.label.ja ?? "";
+    const en = n.label.en ?? "";
+    if (ja.endsWith("?") || en.endsWith("?")) return "flow";
+  }
+  if (doc.nodes.has("*")) return "state";
+  const pairs = /* @__PURE__ */ new Set();
+  for (const e of doc.edges) {
+    if (e.op === "bidir") return "seq";
+    const fwd = `${e.from}|${e.to}`;
+    const rev = `${e.to}|${e.from}`;
+    if (pairs.has(rev)) return "seq";
+    pairs.add(fwd);
+  }
+  return "flow";
+}
+
+// src/core/layout.ts
+var NODE_W = 36;
+var NODE_H = 14;
+var PAD = 8;
+var GRID_GAP = 24;
+var TITLE_H = 5;
+var PARENT_EDGE_LANE_H = 14;
+var MARGIN = 8;
+var ROOT_GAP = MARGIN * 4;
+var ROUTE_GAP = PAD * 1.5;
+var OBSTACLE_PAD = 0.8;
+var BORDER_CLEARANCE = 4;
+var ARROW_TERMINAL_CLEARANCE = 4.6;
+var THICK_ARROW_TERMINAL_CLEARANCE = 5.4;
+var VERTICAL_PORT_RATIO = 0.25;
+var PORT_STUB = 6;
+var MAX_ROUTE_LANES = 18;
+var EPS = 1e-3;
+function layout(doc) {
+  switch (doc.kind) {
+    case "block":
+      return layoutBlock(doc);
+    case "flow":
+      return layoutFlow(doc);
+    case "state":
+      return layoutState(doc);
+    case "seq":
+      return layoutSeq(doc);
+  }
+}
+function layoutBlock(doc) {
+  const childMap = /* @__PURE__ */ new Map();
+  for (const c of doc.containments) childMap.set(c.parent, c.children);
+  const parentMap = /* @__PURE__ */ new Map();
+  for (const c of doc.containments) {
+    for (const child of c.children) parentMap.set(child, c.parent);
+  }
+  const childIds = /* @__PURE__ */ new Set();
+  for (const cs of childMap.values()) for (const c of cs) childIds.add(c);
+  const allIds = [...doc.nodes.keys()];
+  const roots = allIds.filter((id) => !childIds.has(id));
+  const placed = [];
+  const positions = /* @__PURE__ */ new Map();
+  function size(id) {
+    const children = childMap.get(id);
+    if (!children || children.length === 0) return { w: NODE_W, h: NODE_H };
+    const sizes = children.map(size);
+    if (arrangementOf(id) === "grid") {
+      const cols = gridColsOf(id, children);
+      const colW = Math.max(...sizes.map((s) => s.w));
+      const rowHeights = gridRowHeights(sizes, cols);
+      return {
+        w: cols * colW + 2 * PAD + (cols - 1) * GRID_GAP,
+        h: titleHeightOf(id) + rowHeights.reduce((sum, h) => sum + h, 0) + 2 * PAD + Math.max(0, rowHeights.length - 1) * GRID_GAP
+      };
+    }
+    const maxW = Math.max(...sizes.map((s) => s.w));
+    const totH = sizes.reduce((a, b) => a + b.h, 0);
+    return {
+      w: maxW + 2 * PAD,
+      h: titleHeightOf(id) + totH + 2 * PAD + (children.length - 1) * GRID_GAP
+    };
+  }
+  function arrangementOf(id) {
+    const children = childMap.get(id);
+    if (!children || children.length <= 2) return "stack";
+    if (hasParentToChildEdges(id, children)) return "grid";
+    return hasLinearChildFlow(children, doc.edges, childMap) ? "stack" : "grid";
+  }
+  function gridColsOf(id, children) {
+    if (hasParentToChildEdges(id, children)) return Math.min(children.length, 4);
+    if (children.length >= 7) return 4;
+    if (children.length >= 5) return 3;
+    return 2;
+  }
+  function gridRowHeights(sizes, cols) {
+    const rows = Math.ceil(sizes.length / cols);
+    const heights = [];
+    for (let row = 0; row < rows; row++) {
+      const rowSizes = sizes.slice(row * cols, row * cols + cols);
+      heights.push(Math.max(...rowSizes.map((s) => s.h)));
+    }
+    return heights;
+  }
+  function titleHeightOf(id) {
+    const children = childMap.get(id);
+    return children && hasParentToChildEdges(id, children) ? TITLE_H + PARENT_EDGE_LANE_H : TITLE_H;
+  }
+  function hasParentToChildEdges(id, children) {
+    return doc.edges.some((edge) => edge.from === id && children.some((child) => child === edge.to || containsDescendant(child, edge.to, childMap)));
+  }
+  function place(id, ox, oy) {
+    const s = size(id);
+    positions.set(id, { x: ox, y: oy, w: s.w, h: s.h });
+    const node = doc.nodes.get(id);
+    const children = childMap.get(id);
+    if (!children || children.length === 0) {
+      placed.push({
+        id,
+        x: ox,
+        y: oy,
+        w: s.w,
+        h: s.h,
+        label: node?.label ?? {},
+        shape: "box",
+        isContainer: false
+      });
+      return;
+    }
+    const sizes = children.map(size);
+    if (arrangementOf(id) === "grid") {
+      const cols = gridColsOf(id, children);
+      const colW = Math.max(...sizes.map((s2) => s2.w));
+      const rowHeights = gridRowHeights(sizes, cols);
+      const rowTops = [];
+      let rowTop = oy + titleHeightOf(id) + PAD;
+      for (let row = 0; row < rowHeights.length; row++) {
+        rowTops[row] = rowTop;
+        rowTop += rowHeights[row] + GRID_GAP;
+      }
+      for (let i = 0; i < children.length; i++) {
+        const r = Math.floor(i / cols);
+        const cc = i % cols;
+        const cx = ox + PAD + cc * (colW + GRID_GAP) + (colW - sizes[i].w) / 2;
+        const cy = rowTops[r] + (rowHeights[r] - sizes[i].h) / 2;
+        place(children[i], cx, cy);
+      }
+      alignGridRows(children, sizes, rowHeights, rowTops, cols, childMap, doc.edges, positions, placed);
+    } else {
+      const maxW = Math.max(...sizes.map((s2) => s2.w));
+      let yy = oy + titleHeightOf(id) + PAD;
+      for (let i = 0; i < children.length; i++) {
+        const cx = ox + PAD + (maxW - sizes[i].w) / 2;
+        place(children[i], cx, yy);
+        yy += sizes[i].h + GRID_GAP;
+      }
+    }
+    placed.push({
+      id,
+      x: ox,
+      y: oy,
+      w: s.w,
+      h: s.h,
+      label: node?.label ?? {},
+      shape: "box",
+      isContainer: true
+    });
+  }
+  let cur = MARGIN;
+  for (const r of roots) {
+    const previousIds = new Set(positions.keys());
+    place(r, cur, MARGIN);
+    const subtreeIds = collectSubtreeIds(r, childMap);
+    const dy = rootAlignmentDelta(r, subtreeIds, previousIds, doc.edges, positions);
+    if (Math.abs(dy) >= EPS) shiftSubtree(subtreeIds, dy, positions, placed);
+    const sz = size(r);
+    cur += sz.w + ROOT_GAP;
+  }
+  const edges = makeBlockEdges(doc.edges, positions, placed, parentMap);
+  placed.sort((a, b) => {
+    if (a.isContainer !== b.isContainer) return a.isContainer ? -1 : 1;
+    if (a.isContainer && b.isContainer) {
+      const depthDiff = depthOf(a.id, parentMap) - depthOf(b.id, parentMap);
+      if (depthDiff !== 0) return depthDiff;
+      return b.w * b.h - a.w * a.h;
+    }
+    return a.y - b.y || a.x - b.x;
+  });
+  const boxes = [...positions.values()];
+  const edgePoints = edges.flatMap((edge) => edge.points);
+  const maxBoxX = boxes.length ? Math.max(...boxes.map((b) => b.x + b.w)) : MARGIN;
+  const maxBoxY = boxes.length ? Math.max(...boxes.map((b) => b.y + b.h)) : MARGIN;
+  const maxEdgeX = edgePoints.length ? Math.max(...edgePoints.map(([x]) => x)) : MARGIN;
+  const maxEdgeY = edgePoints.length ? Math.max(...edgePoints.map(([, y]) => y)) : MARGIN;
+  const width = Math.max(maxBoxX, maxEdgeX) + MARGIN;
+  const height = Math.max(maxBoxY, maxEdgeY) + MARGIN;
+  return { nodes: placed, edges, width, height, kind: "block" };
+}
+function layoutFlow(doc) {
+  const ids = [...doc.nodes.keys()];
+  const { byRank } = computeRanks(doc);
+  function shapeOf(id) {
+    const n = doc.nodes.get(id);
+    const ja = n?.label.ja ?? "";
+    const en = n?.label.en ?? "";
+    if (ja.endsWith("?") || en.endsWith("?")) return "diamond";
+    const inc = doc.edges.filter((e) => e.to === id).length;
+    const out = doc.edges.filter((e) => e.from === id).length;
+    if (inc === 0 || out === 0) return "round";
+    return "box";
+  }
+  const V_GAP = 14;
+  const H_GAP = 10;
+  const positions = /* @__PURE__ */ new Map();
+  const sortedRanks = [...byRank.keys()].sort((a, b) => a - b);
+  let y = MARGIN;
+  let maxX = 0;
+  for (const r of sortedRanks) {
+    const lane = byRank.get(r);
+    const widths = lane.map((id) => shapeOf(id) === "diamond" ? NODE_W * 1.2 : NODE_W);
+    const totalW = widths.reduce((a, b) => a + b, 0) + (lane.length - 1) * H_GAP;
+    let x = MARGIN;
+    const canvasW = Math.max(totalW + 2 * MARGIN, 200);
+    x = (canvasW - totalW) / 2;
+    for (let i = 0; i < lane.length; i++) {
+      positions.set(lane[i], { x, y, w: widths[i], h: NODE_H });
+      x += widths[i] + H_GAP;
+    }
+    if (x > maxX) maxX = x;
+    y += NODE_H + V_GAP;
+  }
+  for (const id of ids) {
+    if (!positions.has(id)) {
+      positions.set(id, { x: MARGIN, y, w: NODE_W, h: NODE_H });
+      y += NODE_H + V_GAP;
+    }
+  }
+  const placed = [];
+  for (const [id, b] of positions) {
+    placed.push({
+      id,
+      ...b,
+      label: doc.nodes.get(id)?.label ?? {},
+      shape: shapeOf(id),
+      isContainer: false
+    });
+  }
+  const edges = makeEdges(doc.edges, positions);
+  return { nodes: placed, edges, width: maxX + MARGIN, height: y + MARGIN, kind: "flow" };
+}
+function layoutState(doc) {
+  const { byRank } = computeRanks(doc);
+  function shapeOf(id) {
+    if (id === "*") return "circle";
+    return "round";
+  }
+  const V_GAP = 14, H_GAP = 10;
+  const positions = /* @__PURE__ */ new Map();
+  const sortedRanks = [...byRank.keys()].sort((a, b) => a - b);
+  let y = MARGIN;
+  let maxX = 0;
+  for (const r of sortedRanks) {
+    const lane = byRank.get(r);
+    const widths = lane.map((id) => shapeOf(id) === "circle" ? 6 : NODE_W);
+    const heights = lane.map((id) => shapeOf(id) === "circle" ? 6 : NODE_H);
+    const totalW = widths.reduce((a, b) => a + b, 0) + (lane.length - 1) * H_GAP;
+    const canvasW = Math.max(totalW + 2 * MARGIN, 200);
+    let x = (canvasW - totalW) / 2;
+    for (let i = 0; i < lane.length; i++) {
+      positions.set(lane[i], { x, y: y + (NODE_H - heights[i]) / 2, w: widths[i], h: heights[i] });
+      x += widths[i] + H_GAP;
+    }
+    if (x > maxX) maxX = x;
+    y += NODE_H + V_GAP;
+  }
+  for (const id of doc.nodes.keys()) {
+    if (!positions.has(id)) {
+      positions.set(id, { x: MARGIN, y, w: NODE_W, h: NODE_H });
+      y += NODE_H + V_GAP;
+    }
+  }
+  const placed = [];
+  for (const [id, b] of positions) {
+    placed.push({
+      id,
+      ...b,
+      label: doc.nodes.get(id)?.label ?? {},
+      shape: shapeOf(id),
+      isContainer: false
+    });
+  }
+  const edges = makeEdges(doc.edges, positions);
+  return { nodes: placed, edges, width: maxX + MARGIN, height: y + MARGIN, kind: "state" };
+}
+function layoutSeq(doc) {
+  const seen = /* @__PURE__ */ new Set();
+  const actors = [];
+  for (const e of doc.edges) {
+    for (const id of [e.from, e.to]) {
+      if (!seen.has(id)) {
+        seen.add(id);
+        actors.push(id);
+      }
+    }
+  }
+  for (const id of doc.nodes.keys()) {
+    if (!seen.has(id)) {
+      seen.add(id);
+      actors.push(id);
+    }
+  }
+  const ACTOR_W = 40, ACTOR_H = 12, COL_GAP = 28, MSG_GAP = 12;
+  const xOf = /* @__PURE__ */ new Map();
+  const placed = [];
+  let x = MARGIN;
+  for (const id of actors) {
+    xOf.set(id, x + ACTOR_W / 2);
+    placed.push({
+      id,
+      x,
+      y: MARGIN,
+      w: ACTOR_W,
+      h: ACTOR_H,
+      label: doc.nodes.get(id)?.label ?? {},
+      shape: "actor",
+      isContainer: false
+    });
+    x += ACTOR_W + COL_GAP;
+  }
+  let y = MARGIN + ACTOR_H + MSG_GAP;
+  const msgEdges = [];
+  for (const e of doc.edges) {
+    const xa = xOf.get(e.from);
+    const xb = xOf.get(e.to);
+    if (xa === void 0 || xb === void 0) continue;
+    msgEdges.push({
+      from: e.from,
+      to: e.to,
+      points: [[xa, y], [xb, y]],
+      label: e.label,
+      op: e.op
+    });
+    y += MSG_GAP;
+  }
+  const lifelines = actors.map((id) => ({
+    from: id,
+    to: id,
+    points: [[xOf.get(id), MARGIN + ACTOR_H], [xOf.get(id), y + MSG_GAP]],
+    op: "dashed",
+    isLifeline: true
+  }));
+  return {
+    nodes: placed,
+    edges: [...lifelines, ...msgEdges],
+    width: x,
+    height: y + MARGIN * 2,
+    kind: "seq"
+  };
+}
+function computeRanks(doc) {
+  const ids = [...doc.nodes.keys()];
+  const incoming = /* @__PURE__ */ new Map();
+  for (const id of ids) incoming.set(id, 0);
+  for (const e of doc.edges) incoming.set(e.to, (incoming.get(e.to) ?? 0) + 1);
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const e of doc.edges) {
+    if (!outgoing.has(e.from)) outgoing.set(e.from, []);
+    outgoing.get(e.from).push(e.to);
+  }
+  let sources = ids.filter((id) => incoming.get(id) === 0);
+  if (sources.length === 0) {
+    sources = ids.includes("*") ? ["*"] : ids.length ? [ids[0]] : [];
+  }
+  const rank = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  for (const s of sources) {
+    rank.set(s, 0);
+    visited.add(s);
+  }
+  let frontier = [...sources];
+  while (frontier.length) {
+    const next = [];
+    for (const n of frontier) {
+      const r = rank.get(n);
+      for (const m of outgoing.get(n) ?? []) {
+        if (!visited.has(m)) {
+          rank.set(m, r + 1);
+          visited.add(m);
+          next.push(m);
+        }
+      }
+    }
+    frontier = next;
+  }
+  let maxRank = 0;
+  for (const r of rank.values()) if (r > maxRank) maxRank = r;
+  for (const id of ids) {
+    if (!visited.has(id)) {
+      maxRank++;
+      rank.set(id, maxRank);
+      visited.add(id);
+    }
+  }
+  const byRank = /* @__PURE__ */ new Map();
+  for (const [id, r] of rank) {
+    if (!byRank.has(r)) byRank.set(r, []);
+    byRank.get(r).push(id);
+  }
+  return { byRank };
+}
+function makeEdges(srcEdges, positions) {
+  return srcEdges.map((e) => {
+    const a = positions.get(e.from);
+    const b = positions.get(e.to);
+    if (!a || !b) {
+      return { from: e.from, to: e.to, points: [], label: e.label, op: e.op };
+    }
+    return {
+      from: e.from,
+      to: e.to,
+      points: orthogonalRoute(a, b),
+      label: e.label,
+      op: e.op
+    };
+  });
+}
+function hasLinearChildFlow(children, edges, childMap) {
+  const childSet = new Set(children);
+  const pairs = /* @__PURE__ */ new Set();
+  const incoming = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const child of children) {
+    incoming.set(child, 0);
+    outgoing.set(child, 0);
+  }
+  for (const edge of edges) {
+    const from = topChildFor(edge.from, childSet, childMap);
+    const to = topChildFor(edge.to, childSet, childMap);
+    if (!from || !to || from === to) continue;
+    const key = `${from}|${to}`;
+    if (pairs.has(key)) continue;
+    pairs.add(key);
+    outgoing.set(from, (outgoing.get(from) ?? 0) + 1);
+    incoming.set(to, (incoming.get(to) ?? 0) + 1);
+  }
+  if (pairs.size < children.length - 1) return false;
+  let starts = 0;
+  let ends = 0;
+  for (const child of children) {
+    const inc = incoming.get(child) ?? 0;
+    const out = outgoing.get(child) ?? 0;
+    if (inc > 1 || out > 1) return false;
+    if (inc === 0 && out === 1) starts++;
+    if (inc === 1 && out === 0) ends++;
+  }
+  return starts === 1 && ends === 1;
+}
+function topChildFor(id, childSet, childMap) {
+  if (childSet.has(id)) return id;
+  for (const child of childSet) {
+    if (containsDescendant(child, id, childMap)) return child;
+  }
+  return void 0;
+}
+function containsDescendant(ancestor, id, childMap) {
+  const children = childMap.get(ancestor);
+  if (!children) return false;
+  for (const child of children) {
+    if (child === id || containsDescendant(child, id, childMap)) return true;
+  }
+  return false;
+}
+function collectSubtreeIds(id, childMap) {
+  const ids = /* @__PURE__ */ new Set([id]);
+  for (const child of childMap.get(id) ?? []) {
+    for (const descendant of collectSubtreeIds(child, childMap)) ids.add(descendant);
+  }
+  return ids;
+}
+function alignGridRows(children, sizes, rowHeights, rowTops, cols, childMap, edges, positions, placed) {
+  const rows = Math.ceil(children.length / cols);
+  for (let row = 0; row < rows; row++) {
+    const rowChildren = children.slice(row * cols, row * cols + cols);
+    const rowTop = rowTops[row];
+    const rowH = rowHeights[row];
+    if (rowTop === void 0 || rowH === void 0) continue;
+    for (const child of rowChildren) {
+      const childIndex = children.indexOf(child);
+      const childSize = sizes[childIndex];
+      if (!childSize || childSize.h >= rowH - EPS) continue;
+      const subtreeIds = collectSubtreeIds(child, childMap);
+      const siblingIds = /* @__PURE__ */ new Set();
+      for (const sibling of rowChildren) {
+        if (sibling === child) continue;
+        for (const id of collectSubtreeIds(sibling, childMap)) siblingIds.add(id);
+      }
+      const deltas = [];
+      for (const edge of edges) {
+        const fromChild = subtreeIds.has(edge.from);
+        const toChild = subtreeIds.has(edge.to);
+        if (fromChild && siblingIds.has(edge.to)) {
+          addWeightedDelta(
+            deltas,
+            centerY(positions.get(edge.to)) - centerY(positions.get(edge.from)),
+            alignmentWeight(edge, false)
+          );
+        } else if (toChild && siblingIds.has(edge.from)) {
+          addWeightedDelta(
+            deltas,
+            centerY(positions.get(edge.from)) - centerY(positions.get(edge.to)),
+            alignmentWeight(edge, true)
+          );
+        }
+      }
+      if (deltas.length === 0) continue;
+      deltas.sort((a, b) => a - b);
+      const desired = deltas[Math.floor(deltas.length / 2)];
+      const box = positions.get(child);
+      if (!box) continue;
+      const minDy = rowTop - box.y;
+      const maxDy = rowTop + rowH - childSize.h - box.y;
+      const dy = Math.min(maxDy, Math.max(minDy, desired));
+      if (Math.abs(dy) >= EPS) shiftSubtree(subtreeIds, dy, positions, placed);
+    }
+  }
+}
+function rootAlignmentDelta(rootId, subtreeIds, previousIds, edges, positions) {
+  const deltas = [];
+  for (const edge of edges) {
+    const fromCurrent = subtreeIds.has(edge.from);
+    const toCurrent = subtreeIds.has(edge.to);
+    const fromPrevious = previousIds.has(edge.from);
+    const toPrevious = previousIds.has(edge.to);
+    if (fromCurrent && toPrevious) {
+      addWeightedDelta(
+        deltas,
+        centerY(positions.get(edge.to)) - centerY(positions.get(edge.from)),
+        alignmentWeight(edge, false)
+      );
+    } else if (toCurrent && fromPrevious) {
+      addWeightedDelta(
+        deltas,
+        centerY(positions.get(edge.from)) - centerY(positions.get(edge.to)),
+        alignmentWeight(edge, true)
+      );
+    }
+  }
+  if (deltas.length === 0) return 0;
+  deltas.sort((a, b) => a - b);
+  const desired = deltas[Math.floor(deltas.length / 2)];
+  const root = positions.get(rootId);
+  if (!root) return desired;
+  return Math.max(MARGIN - root.y, desired);
+}
+function addWeightedDelta(deltas, delta, weight) {
+  if (!Number.isFinite(delta)) return;
+  for (let i = 0; i < weight; i++) deltas.push(delta);
+}
+function alignmentWeight(edge, currentIsTarget) {
+  const feedback = edge.op === "dashed" || edge.op === "dashed-arrow";
+  return (feedback ? 1 : 3) + (currentIsTarget ? 1 : 0);
+}
+function centerY(box) {
+  return box ? box.y + box.h / 2 : Number.NaN;
+}
+function shiftSubtree(ids, dy, positions, placed) {
+  for (const id of ids) {
+    const box = positions.get(id);
+    if (box) box.y += dy;
+  }
+  for (const node of placed) {
+    if (ids.has(node.id)) node.y += dy;
+  }
+}
+function makeBlockEdges(srcEdges, positions, obstacles, parentMap) {
+  const containerIds = new Set(obstacles.filter((o) => o.isContainer).map((o) => o.id));
+  const plans = srcEdges.map((edge, index) => {
+    const a = positions.get(edge.from);
+    const b = positions.get(edge.to);
+    if (!a || !b) {
+      return { edge, index, endpointBoundaries: [], endpointInteriorBarriers: [] };
+    }
+    const routeA = routeEndpointBox(edge.from, edge.to, positions, parentMap, containerIds) ?? a;
+    const routeB = routeEndpointBox(edge.to, edge.from, positions, parentMap, containerIds) ?? b;
+    const endpointBoundaries = [
+      ...routeA === a ? [] : [a],
+      ...routeB === b ? [] : [b]
+    ];
+    const endpointInteriorBarriers = [
+      ...isExternalContainerEndpoint(edge.from, edge.to, parentMap, containerIds) ? [a] : [],
+      ...isExternalContainerEndpoint(edge.to, edge.from, parentMap, containerIds) ? [b] : []
+    ];
+    return {
+      edge,
+      index,
+      routeA,
+      routeB,
+      endpointBoundaries,
+      endpointInteriorBarriers,
+      bounds: commonRoutingBounds(edge.from, edge.to, parentMap, positions)
+    };
+  });
+  return routePlansSequentially(plans, obstacles, parentMap);
+}
+function routePlansSequentially(plans, baseObstacles, parentMap) {
+  const routed = [];
+  for (const plan of plans) {
+    const searchBox = routeSearchBox(plan);
+    const routedArrowGuards = routed.flatMap((edge, index) => arrowGuardObstaclesFor(edge, index));
+    const routedEdgeGuards = routed.flatMap((edge, index) => edgeGuardObstaclesFor(edge, index));
+    const extraArrowGuards = routedArrowGuards.filter((guard) => guard.edgeIndex !== plan.index && !sharesRouteEndpoint(guard, plan.edge) && (!searchBox || boxesOverlap(searchBox, guard)));
+    const extraEdgeGuards = routedEdgeGuards.filter((guard) => shouldUseEdgeGuard(guard, plan, searchBox));
+    routed.push(routeBlockPlan(plan, [...baseObstacles, ...extraArrowGuards, ...extraEdgeGuards], parentMap));
+  }
+  return routed;
+}
+function routeBlockPlan(plan, obstacles, parentMap) {
+  const { edge, routeA, routeB } = plan;
+  if (!routeA || !routeB) {
+    return { from: edge.from, to: edge.to, points: [], label: edge.label, op: edge.op };
+  }
+  return {
+    from: edge.from,
+    to: edge.to,
+    points: avoidObstaclesRoute(
+      routeA,
+      routeB,
+      edge.from,
+      edge.to,
+      obstacles,
+      parentMap,
+      plan.bounds,
+      plan.endpointBoundaries,
+      plan.endpointInteriorBarriers,
+      edge.op
+    ),
+    label: edge.label,
+    op: edge.op
+  };
+}
+function arrowGuardObstaclesFor(edge, edgeIndex) {
+  if (edge.isLifeline || edge.points.length < 2) return [];
+  const guards = [];
+  if (hasEndArrow(edge.op)) {
+    guards.push(makeArrowGuard(edge, edgeIndex, edge.points[edge.points.length - 1], "end"));
+  }
+  if (edge.op === "bidir") {
+    guards.push(makeArrowGuard(edge, edgeIndex, edge.points[0], "start"));
+  }
+  return guards;
+}
+function hasEndArrow(op) {
+  return op !== "line" && op !== "dashed";
+}
+function makeArrowGuard(edge, edgeIndex, tip, side) {
+  const half = edge.op === "thick" ? 5 : 4.2;
+  return {
+    id: `__arrow_guard_${edgeIndex}_${side}`,
+    x: tip[0] - half,
+    y: tip[1] - half,
+    w: half * 2,
+    h: half * 2,
+    isContainer: false,
+    edgeIndex,
+    edgeFrom: edge.from,
+    edgeTo: edge.to
+  };
+}
+function sharesRouteEndpoint(guard, edge) {
+  return guard.edgeFrom === edge.from || guard.edgeFrom === edge.to || guard.edgeTo === edge.from || guard.edgeTo === edge.to;
+}
+function edgeGuardObstaclesFor(edge, edgeIndex) {
+  if (edge.points.length < 2) return [];
+  const guards = [];
+  const clear = 2.2;
+  const trim = 1.2;
+  for (let i = 0; i < edge.points.length - 1; i++) {
+    const a = edge.points[i];
+    const b = edge.points[i + 1];
+    const len = segmentLength(a, b);
+    if (len <= trim * 2) continue;
+    if (Math.abs(a[0] - b[0]) < EPS) {
+      const y1 = Math.min(a[1], b[1]) + trim;
+      const y2 = Math.max(a[1], b[1]) - trim;
+      guards.push({
+        id: `__edge_guard_${edgeIndex}_${i}`,
+        x: a[0] - clear,
+        y: y1,
+        w: clear * 2,
+        h: y2 - y1,
+        isContainer: false,
+        edgeIndex,
+        edgeOp: edge.op,
+        orientation: "vertical"
+      });
+    } else if (Math.abs(a[1] - b[1]) < EPS) {
+      const x1 = Math.min(a[0], b[0]) + trim;
+      const x2 = Math.max(a[0], b[0]) - trim;
+      guards.push({
+        id: `__edge_guard_${edgeIndex}_${i}`,
+        x: x1,
+        y: a[1] - clear,
+        w: x2 - x1,
+        h: clear * 2,
+        isContainer: false,
+        edgeIndex,
+        edgeOp: edge.op,
+        orientation: "horizontal"
+      });
+    }
+  }
+  return guards;
+}
+function shouldUseEdgeGuard(guard, plan, searchBox) {
+  if (guard.edgeIndex === plan.index) return false;
+  return !searchBox || boxesOverlap(searchBox, guard);
+}
+function routeSearchBox(plan) {
+  if (!plan.routeA || !plan.routeB) return void 0;
+  const left = Math.min(plan.routeA.x, plan.routeB.x);
+  const top = Math.min(plan.routeA.y, plan.routeB.y);
+  const right = Math.max(plan.routeA.x + plan.routeA.w, plan.routeB.x + plan.routeB.w);
+  const bottom = Math.max(plan.routeA.y + plan.routeA.h, plan.routeB.y + plan.routeB.h);
+  const pad = ROUTE_GAP * 4;
+  const candidate = {
+    x: left - pad,
+    y: top - pad,
+    w: right - left + pad * 2,
+    h: bottom - top + pad * 2
+  };
+  if (!plan.bounds) return candidate;
+  return {
+    x: Math.max(candidate.x, plan.bounds.x),
+    y: Math.max(candidate.y, plan.bounds.y),
+    w: Math.min(candidate.x + candidate.w, plan.bounds.x + plan.bounds.w) - Math.max(candidate.x, plan.bounds.x),
+    h: Math.min(candidate.y + candidate.h, plan.bounds.y + plan.bounds.h) - Math.max(candidate.y, plan.bounds.y)
+  };
+}
+function boxesOverlap(a, b) {
+  return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+}
+function routeEndpointBox(id, otherId, positions, parentMap, containerIds) {
+  const container = positions.get(id);
+  const other = positions.get(otherId);
+  if (!container || !other) return void 0;
+  if (!isAncestorOf(id, otherId, parentMap)) {
+    if (!containerIds.has(id)) return void 0;
+    return container;
+  }
+  const left = container.x + PAD;
+  const right = container.x + container.w - PAD;
+  const top = container.y + TITLE_H + PAD / 2;
+  const x = Math.min(right, Math.max(left, other.x + other.w / 2));
+  return { x: x - 0.1, y: top - 0.1, w: 0.2, h: 0.2 };
+}
+function isExternalContainerEndpoint(id, otherId, parentMap, containerIds) {
+  return containerIds.has(id) && !isAncestorOf(id, otherId, parentMap);
+}
+function isAncestorOf(ancestor, id, parentMap) {
+  let cur = id;
+  const seen = /* @__PURE__ */ new Set();
+  while (parentMap.has(cur) && !seen.has(cur)) {
+    seen.add(cur);
+    cur = parentMap.get(cur);
+    if (cur === ancestor) return true;
+  }
+  return false;
+}
+function depthOf(id, parentMap) {
+  let depth = 0;
+  let cur = id;
+  const seen = /* @__PURE__ */ new Set();
+  while (parentMap.has(cur) && !seen.has(cur)) {
+    seen.add(cur);
+    cur = parentMap.get(cur);
+    depth++;
+  }
+  return depth;
+}
+function avoidObstaclesRoute(a, b, from, to, obstacles, parentMap, bounds, endpointBoundaries = [], endpointInteriorBarriers = [], op = "line", strictEdgeGuards = true) {
+  const routedObstacles = obstacles.filter((o) => o.id !== from && o.id !== to);
+  const leafObstacles = routedObstacles.filter((o) => !o.isContainer);
+  const hardLeafObstacles = leafObstacles.filter((o) => o.id.startsWith("__arrow_guard_"));
+  const allowedContainers = allowedContainerIds(from, to, parentMap);
+  const passableContainerObstacles = routedObstacles.filter((o) => o.isContainer && allowedContainers.has(o.id));
+  const blockedContainerObstacles = routedObstacles.filter((o) => o.isContainer && !allowedContainers.has(o.id));
+  const externalContainerObstacles = passableContainerObstacles.filter((o) => isAncestorOf(o.id, from, parentMap) !== isAncestorOf(o.id, to, parentMap));
+  const boundaryObstacles = endpointBoundaries.map((box, index) => ({
+    ...box,
+    id: `__endpoint_boundary_${index}`,
+    isContainer: true
+  }));
+  const realLeafObstacles = leafObstacles.filter((o) => !o.id.startsWith("__"));
+  const edgeGuardObstacles = leafObstacles.filter(isEdgeGuardObstacle);
+  const straight = preferredStraightRoute(a, b);
+  if (straight && hasArrowTerminalClearance(straight, op) && (!bounds || routeFitsBounds(straight, bounds)) && !routeIntersectsAnyInterior(straight, realLeafObstacles, OBSTACLE_PAD) && !routeIntersectsAnyInterior(straight, hardLeafObstacles, OBSTACLE_PAD) && (!strictEdgeGuards || !routeSharesAnyEdgeGuardLane(straight, edgeGuardObstacles)) && !routeIntersectsAnyInterior(straight, blockedContainerObstacles, OBSTACLE_PAD) && !routeIntersectsAnyInterior(straight, endpointInteriorBarriers, 0) && !routeOverlapsAnyBorder(straight, [
+    ...endpointBoundaries,
+    ...passableContainerObstacles,
+    ...blockedContainerObstacles
+  ], BORDER_CLEARANCE)) {
+    return straight;
+  }
+  const lanes = routeLanes(a, b, [...routedObstacles, ...boundaryObstacles], bounds);
+  let best = orthogonalRoute(a, b);
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (const start of portsOf(a)) {
+    for (const end of portsOf(b)) {
+      const sourcePort = start.point;
+      const targetPort = end.point;
+      const sp = portLeadPoint(start);
+      const ep = portLeadPoint(end);
+      const candidates = [
+        [sourcePort, sp, [ep[0], sp[1]], ep, targetPort],
+        [sourcePort, sp, [sp[0], ep[1]], ep, targetPort]
+      ];
+      if (Math.abs(sp[0] - ep[0]) < EPS || Math.abs(sp[1] - ep[1]) < EPS) {
+        candidates.push([sourcePort, sp, ep, targetPort]);
+      }
+      for (const x of lanes.xs) {
+        candidates.push([sourcePort, sp, [x, sp[1]], [x, ep[1]], ep, targetPort]);
+      }
+      for (const y of lanes.ys) {
+        candidates.push([sourcePort, sp, [sp[0], y], [ep[0], y], ep, targetPort]);
+      }
+      for (const x of lanes.xs) {
+        for (const y of lanes.ys) {
+          candidates.push([sourcePort, sp, [x, sp[1]], [x, y], [ep[0], y], ep, targetPort]);
+          candidates.push([sourcePort, sp, [sp[0], y], [x, y], [x, ep[1]], ep, targetPort]);
+        }
+      }
+      for (const candidate of candidates) {
+        const normalized = normalizeRoute(candidate);
+        if (!isOrthogonalRoute(normalized)) continue;
+        if (!hasArrowTerminalClearance(normalized, op)) continue;
+        if (bounds && !routeFitsBounds(normalized, bounds)) continue;
+        if (routeOverlapsAnyBorder(normalized, [a, b], 0)) continue;
+        if (routeIntersectsAnyInterior(normalized, endpointInteriorBarriers, 0)) continue;
+        if (routeIntersectsAnyInterior(normalized, realLeafObstacles, OBSTACLE_PAD)) continue;
+        if (routeIntersectsAnyInterior(normalized, hardLeafObstacles, OBSTACLE_PAD)) continue;
+        if (strictEdgeGuards && routeSharesAnyEdgeGuardLane(normalized, edgeGuardObstacles)) continue;
+        if (routeIntersectsAnyInterior(normalized, blockedContainerObstacles, OBSTACLE_PAD)) continue;
+        if (routeOverlapsAnyBorder(normalized, [
+          ...endpointBoundaries,
+          ...passableContainerObstacles,
+          ...blockedContainerObstacles
+        ], BORDER_CLEARANCE)) continue;
+        const score = scoreRoute(
+          normalized,
+          a,
+          b,
+          leafObstacles,
+          blockedContainerObstacles,
+          passableContainerObstacles,
+          externalContainerObstacles,
+          endpointBoundaries
+        ) + portPairPenalty(a, b, start.side, end.side, op) + start.offsetPenalty + end.offsetPenalty;
+        if (score < bestScore) {
+          best = normalized;
+          bestScore = score;
+        }
+      }
+    }
+  }
+  if (bestScore === Number.POSITIVE_INFINITY) {
+    if (strictEdgeGuards && edgeGuardObstacles.length > 0) {
+      return avoidObstaclesRoute(
+        a,
+        b,
+        from,
+        to,
+        obstacles,
+        parentMap,
+        bounds,
+        endpointBoundaries,
+        endpointInteriorBarriers,
+        op,
+        false
+      );
+    }
+    return orthogonalRoute(a, b);
+  }
+  return best;
+}
+function preferredStraightRoute(a, b) {
+  const acx = a.x + a.w / 2;
+  const acy = a.y + a.h / 2;
+  const bcx = b.x + b.w / 2;
+  const bcy = b.y + b.h / 2;
+  if (Math.abs(acy - bcy) < EPS) {
+    if (a.x + a.w <= b.x) return [[a.x + a.w, acy], [b.x, bcy]];
+    if (b.x + b.w <= a.x) return [[a.x, acy], [b.x + b.w, bcy]];
+  }
+  if (Math.abs(acx - bcx) < EPS) {
+    if (a.y + a.h <= b.y) return [[acx, a.y + a.h], [bcx, b.y]];
+    if (b.y + b.h <= a.y) return [[acx, a.y], [bcx, b.y + b.h]];
+  }
+  return void 0;
+}
+function hasArrowTerminalClearance(points, op) {
+  if (points.length < 2) return false;
+  if (op !== "line" && op !== "dashed") {
+    if (terminalSegmentLength(points, false) < arrowTerminalClearance(op)) return false;
+  }
+  if (op === "bidir") {
+    if (terminalSegmentLength(points, true) < arrowTerminalClearance(op)) return false;
+  }
+  return true;
+}
+function terminalSegmentLength(points, atStart) {
+  if (points.length < 2) return 0;
+  const a = atStart ? points[0] : points[points.length - 1];
+  const b = atStart ? points[1] : points[points.length - 2];
+  return segmentLength(a, b);
+}
+function arrowTerminalClearance(op) {
+  return op === "thick" ? THICK_ARROW_TERMINAL_CLEARANCE : ARROW_TERMINAL_CLEARANCE;
+}
+function routeIntersectsAnyInterior(points, boxes, pad) {
+  for (let i = 0; i < points.length - 1; i++) {
+    for (const box of boxes) {
+      if (boxInteriorOverlap(points[i], points[i + 1], box, pad) > EPS) return true;
+    }
+  }
+  return false;
+}
+function routeOverlapsAnyBorder(points, boxes, tolerance) {
+  for (let i = 0; i < points.length - 1; i++) {
+    for (const box of boxes) {
+      if (boxBorderProximityOverlap(points[i], points[i + 1], box, tolerance) > EPS) return true;
+    }
+  }
+  return false;
+}
+function routeSharesAnyEdgeGuardLane(points, guards) {
+  for (let i = 0; i < points.length - 1; i++) {
+    for (const guard of guards) {
+      if (segmentSharesEdgeGuardLane(points[i], points[i + 1], guard)) return true;
+    }
+  }
+  return false;
+}
+function segmentSharesEdgeGuardLane(a, b, guard) {
+  const segmentVertical = Math.abs(a[0] - b[0]) < EPS;
+  const segmentHorizontal = Math.abs(a[1] - b[1]) < EPS;
+  if (segmentVertical && guard.orientation === "vertical") {
+    const guardX = guard.x + guard.w / 2;
+    if (Math.abs(a[0] - guardX) > guard.w / 2 + EPS) return false;
+    return intervalOverlap(a[1], b[1], guard.y, guard.y + guard.h) > EPS;
+  }
+  if (segmentHorizontal && guard.orientation === "horizontal") {
+    const guardY = guard.y + guard.h / 2;
+    if (Math.abs(a[1] - guardY) > guard.h / 2 + EPS) return false;
+    return intervalOverlap(a[0], b[0], guard.x, guard.x + guard.w) > EPS;
+  }
+  return false;
+}
+function allowedContainerIds(from, to, parentMap) {
+  return /* @__PURE__ */ new Set([from, to, ...ancestorsOf(from, parentMap), ...ancestorsOf(to, parentMap)]);
+}
+function portsOf(box) {
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  const xOffset = Math.min(box.w * 0.25, Math.max(3, box.w / 2 - 4));
+  const yOffset = Math.min(box.h * 0.25, Math.max(2, box.h / 2 - 3));
+  const sidePenalty = 9;
+  return [
+    { point: [box.x + box.w, cy], side: "right", offsetPenalty: 0 },
+    { point: [box.x, cy], side: "left", offsetPenalty: 0 },
+    { point: [cx, box.y + box.h], side: "bottom", offsetPenalty: 0 },
+    { point: [cx, box.y], side: "top", offsetPenalty: 0 },
+    { point: [box.x + box.w, cy - yOffset], side: "right", offsetPenalty: sidePenalty },
+    { point: [box.x + box.w, cy + yOffset], side: "right", offsetPenalty: sidePenalty },
+    { point: [box.x, cy - yOffset], side: "left", offsetPenalty: sidePenalty },
+    { point: [box.x, cy + yOffset], side: "left", offsetPenalty: sidePenalty },
+    { point: [cx - xOffset, box.y + box.h], side: "bottom", offsetPenalty: sidePenalty },
+    { point: [cx + xOffset, box.y + box.h], side: "bottom", offsetPenalty: sidePenalty },
+    { point: [cx - xOffset, box.y], side: "top", offsetPenalty: sidePenalty },
+    { point: [cx + xOffset, box.y], side: "top", offsetPenalty: sidePenalty }
+  ];
+}
+function portLeadPoint(port) {
+  const [x, y] = port.point;
+  switch (port.side) {
+    case "right":
+      return [x + PORT_STUB, y];
+    case "left":
+      return [x - PORT_STUB, y];
+    case "bottom":
+      return [x, y + PORT_STUB];
+    case "top":
+      return [x, y - PORT_STUB];
+  }
+}
+function portPairPenalty(source, target, start, end, op) {
+  const sx = source.x + source.w / 2;
+  const sy = source.y + source.h / 2;
+  const tx = target.x + target.w / 2;
+  const ty = target.y + target.h / 2;
+  const dx = tx - sx;
+  const dy = ty - sy;
+  if (op === "dashed") return dashedPortPairPenalty(start, end, dx, dy, source, target);
+  return sourcePortPenalty(start, dx, dy, source) + targetPortPenalty(end, dx, dy, target);
+}
+function dashedPortPairPenalty(start, end, dx, dy, source, target) {
+  if (Math.abs(dy) > Math.min(source.h, target.h) * 0.8) {
+    const startDesired = dy > 0 ? "bottom" : "top";
+    const endDesired = dy > 0 ? "top" : "bottom";
+    return dashedSidePenalty(start, startDesired) + dashedSidePenalty(end, endDesired);
+  }
+  if (Math.abs(dx) > Math.min(source.w, target.w) * 0.8) {
+    const startDesired = dx > 0 ? "right" : "left";
+    const endDesired = dx > 0 ? "left" : "right";
+    return dashedSidePenalty(start, startDesired) + dashedSidePenalty(end, endDesired);
+  }
+  return 0;
+}
+function dashedSidePenalty(side, desired) {
+  if (side === desired) return 0;
+  if (side === oppositeSide(desired)) return 1400;
+  return 450;
+}
+function sourcePortPenalty(side, dx, dy, box) {
+  if (Math.abs(dy) > box.h * 0.8 && Math.abs(dy) >= Math.abs(dx) * VERTICAL_PORT_RATIO) {
+    const desired = dy > 0 ? "bottom" : "top";
+    if (side === desired) return 0;
+    return side === oppositeSide(desired) ? 800 : 180;
+  }
+  if (Math.abs(dx) > box.w * 0.5) {
+    const desired = dx > 0 ? "right" : "left";
+    if (side === desired) return 0;
+    return side === oppositeSide(desired) ? 900 : 90;
+  }
+  if (Math.abs(dy) > box.h * 0.8) {
+    const desired = dy > 0 ? "bottom" : "top";
+    if (side === desired) return 0;
+    return side === oppositeSide(desired) ? 600 : 120;
+  }
+  return 0;
+}
+function targetPortPenalty(side, dx, dy, box) {
+  if (Math.abs(dy) > box.h * 0.8 && Math.abs(dy) >= Math.abs(dx) * VERTICAL_PORT_RATIO) {
+    const desired = dy > 0 ? "top" : "bottom";
+    if (side === desired) return 0;
+    return side === oppositeSide(desired) ? 1400 : 360;
+  }
+  if (Math.abs(dx) > box.w * 0.5 && Math.abs(dx) >= Math.abs(dy) * 1.2) {
+    const desired = dx > 0 ? "left" : "right";
+    if (side === desired) return 0;
+    return side === oppositeSide(desired) ? 1200 : 220;
+  }
+  if (Math.abs(dy) > box.h * 0.35) {
+    const desired = dy > 0 ? "top" : "bottom";
+    if (side === desired) return 0;
+    return side === "left" || side === "right" ? 9e3 : 1200;
+  }
+  if (Math.abs(dx) > box.w * 0.5) {
+    const desired = dx > 0 ? "left" : "right";
+    if (side === desired) return 0;
+    return side === oppositeSide(desired) ? 1e3 : 160;
+  }
+  return 0;
+}
+function oppositeSide(side) {
+  switch (side) {
+    case "right":
+      return "left";
+    case "left":
+      return "right";
+    case "bottom":
+      return "top";
+    case "top":
+      return "bottom";
+  }
+}
+function routeLanes(a, b, obstacles, bounds) {
+  const boxes = [a, b, ...obstacles];
+  const laneMargin = ROUTE_GAP * 2;
+  const minX = bounds ? bounds.x : Math.max(MARGIN, Math.min(...boxes.map((o) => o.x)) - laneMargin);
+  const maxX = bounds ? bounds.x + bounds.w : Math.max(...boxes.map((o) => o.x + o.w)) + laneMargin;
+  const minY = bounds ? bounds.y : Math.max(MARGIN, Math.min(...boxes.map((o) => o.y)) - laneMargin);
+  const maxY = bounds ? bounds.y + bounds.h : Math.max(...boxes.map((o) => o.y + o.h)) + laneMargin;
+  const xs = [(a.x + a.w / 2 + b.x + b.w / 2) / 2];
+  const ys = [(a.y + a.h / 2 + b.y + b.h / 2) / 2];
+  for (const box of boxes) {
+    for (const gap of [ROUTE_GAP, ROUTE_GAP * 1.5, ROUTE_GAP * 2]) {
+      xs.push(box.x - gap, box.x + box.w + gap);
+      ys.push(box.y - gap, box.y + box.h + gap);
+    }
+  }
+  if (bounds) {
+    xs.push(bounds.x, bounds.x + bounds.w);
+    ys.push(bounds.y, bounds.y + bounds.h);
+  }
+  return {
+    xs: limitRouteLanes(
+      uniqueSorted(xs.filter((x) => x >= minX && x <= maxX)),
+      (a.x + a.w / 2 + b.x + b.w / 2) / 2
+    ),
+    ys: limitRouteLanes(
+      uniqueSorted(ys.filter((y) => y >= minY && y <= maxY)),
+      (a.y + a.h / 2 + b.y + b.h / 2) / 2
+    )
+  };
+}
+function limitRouteLanes(values, anchor) {
+  if (values.length <= MAX_ROUTE_LANES) return values;
+  const keep = /* @__PURE__ */ new Set([values[0], values[values.length - 1]]);
+  for (const value of [...values].sort((a, b) => Math.abs(a - anchor) - Math.abs(b - anchor))) {
+    keep.add(value);
+    if (keep.size >= MAX_ROUTE_LANES) break;
+  }
+  return [...keep].sort((a, b) => a - b);
+}
+function commonRoutingBounds(from, to, parentMap, positions) {
+  const common = nearestCommonAncestor(from, to, parentMap);
+  if (!common) return void 0;
+  const box = positions.get(common);
+  if (!box) return void 0;
+  const inset = ROUTE_GAP / 2;
+  const top = box.y + TITLE_H + PAD / 2;
+  const bottom = box.y + box.h - inset;
+  return {
+    x: box.x + inset,
+    y: top,
+    w: Math.max(0, box.w - inset * 2),
+    h: Math.max(0, bottom - top)
+  };
+}
+function nearestCommonAncestor(from, to, parentMap) {
+  const toAncestors = new Set(ancestorsOf(to, parentMap));
+  return ancestorsOf(from, parentMap).find((id) => toAncestors.has(id));
+}
+function ancestorsOf(id, parentMap) {
+  const out = [];
+  let cur = id;
+  const seen = /* @__PURE__ */ new Set();
+  while (parentMap.has(cur) && !seen.has(cur)) {
+    seen.add(cur);
+    cur = parentMap.get(cur);
+    out.push(cur);
+  }
+  return out;
+}
+function routeFitsBounds(points, bounds) {
+  const right = bounds.x + bounds.w;
+  const bottom = bounds.y + bounds.h;
+  return points.every(([x, y]) => x >= bounds.x - EPS && x <= right + EPS && y >= bounds.y - EPS && y <= bottom + EPS);
+}
+function uniqueSorted(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    const rounded = Math.round(value * 1e3) / 1e3;
+    const key = rounded.toFixed(3);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(rounded);
+  }
+  return out.sort((a, b) => a - b);
+}
+function normalizeRoute(points) {
+  const deduped = [];
+  for (const point of points) {
+    const prev = deduped[deduped.length - 1];
+    if (!prev || Math.abs(prev[0] - point[0]) >= EPS || Math.abs(prev[1] - point[1]) >= EPS) {
+      deduped.push(point);
+    }
+  }
+  const out = [];
+  for (const point of deduped) {
+    out.push(point);
+    while (out.length >= 3) {
+      const a = out[out.length - 3];
+      const b = out[out.length - 2];
+      const c = out[out.length - 1];
+      const sameX = Math.abs(a[0] - b[0]) < EPS && Math.abs(b[0] - c[0]) < EPS;
+      const sameY = Math.abs(a[1] - b[1]) < EPS && Math.abs(b[1] - c[1]) < EPS;
+      if (!sameX && !sameY) break;
+      out.splice(out.length - 2, 1);
+    }
+  }
+  return out;
+}
+function isOrthogonalRoute(points) {
+  if (points.length < 2) return false;
+  for (let i = 0; i < points.length - 1; i++) {
+    const a = points[i];
+    const b = points[i + 1];
+    if (Math.abs(a[0] - b[0]) >= EPS && Math.abs(a[1] - b[1]) >= EPS) return false;
+  }
+  return true;
+}
+function scoreRoute(points, source, target, leafObstacles, blockedContainerObstacles, passableContainerObstacles, externalContainerObstacles, endpointBoundaries) {
+  let score = 0;
+  for (let i = 0; i < points.length - 1; i++) {
+    const a = points[i];
+    const b = points[i + 1];
+    score += segmentLength(a, b);
+    const sourceInterior = boxInteriorOverlap(a, b, source, 0);
+    if (sourceInterior > 0) score += 22e4 + sourceInterior * 1500;
+    const targetInterior = boxInteriorOverlap(a, b, target, 0);
+    if (targetInterior > 0) score += 22e4 + targetInterior * 1500;
+    const sourceBorder = boxBorderOverlap(a, b, source);
+    if (sourceBorder > 0) score += 8e3 + sourceBorder * 120;
+    const targetBorder = boxBorderOverlap(a, b, target);
+    if (targetBorder > 0) score += 8e3 + targetBorder * 120;
+    for (const boundary of endpointBoundaries) {
+      const overlap = boxBorderOverlap(a, b, boundary);
+      if (overlap > 0) score += 12e3 + overlap * 160;
+    }
+    for (const obstacle of leafObstacles) {
+      const overlap = boxInteriorOverlap(a, b, obstacle, OBSTACLE_PAD);
+      if (overlap > 0) score += leafObstaclePenalty(obstacle, a, b, overlap);
+    }
+    for (const obstacle of blockedContainerObstacles) {
+      const overlap = boxInteriorOverlap(a, b, obstacle, OBSTACLE_PAD);
+      if (overlap > 0) score += 18e4 + overlap * 1200;
+      const border = boxBorderOverlap(a, b, obstacle);
+      if (border > 0) score += 18e3 + border * 300;
+    }
+    for (const obstacle of passableContainerObstacles) {
+      const titleOverlap = boxInteriorOverlap(a, b, containerTitleRoutingBand(obstacle), OBSTACLE_PAD);
+      if (titleOverlap > 0) score += 14e3 + titleOverlap * 120;
+      const overlap = boxBorderOverlap(a, b, obstacle);
+      if (overlap > 0) score += 6e3 + overlap * 120;
+    }
+    for (const obstacle of externalContainerObstacles) {
+      const overlap = boxInteriorOverlap(a, b, obstacle, 0);
+      if (overlap > 0) score += overlap * 40;
+    }
+  }
+  score += Math.max(0, points.length - 2) * 3;
+  score += routeExcursionPenalty(points, source, target);
+  return score;
+}
+function routeExcursionPenalty(points, source, target) {
+  const pad = ROUTE_GAP * 5;
+  const left = Math.min(source.x, target.x) - pad;
+  const top = Math.min(source.y, target.y) - pad;
+  const right = Math.max(source.x + source.w, target.x + target.w) + pad;
+  const bottom = Math.max(source.y + source.h, target.y + target.h) + pad;
+  let penalty = 0;
+  for (const [x, y] of points) {
+    if (x < left) penalty += (left - x) * 90;
+    if (x > right) penalty += (x - right) * 90;
+    if (y < top) penalty += (top - y) * 90;
+    if (y > bottom) penalty += (y - bottom) * 90;
+  }
+  return penalty;
+}
+function leafObstaclePenalty(obstacle, a, b, overlap) {
+  if (obstacle.id.startsWith("__arrow_guard_")) return 7e4 + overlap * 700;
+  if (isEdgeGuardObstacle(obstacle)) return edgeGuardPenalty(obstacle, a, b, overlap);
+  return 16e4 + overlap * 1200;
+}
+function edgeGuardPenalty(obstacle, a, b, overlap) {
+  const segmentVertical = Math.abs(a[0] - b[0]) < EPS;
+  const guardVertical = obstacle.orientation === "vertical";
+  if (segmentVertical === guardVertical) return 85e3 + overlap * 1200;
+  return 500 + overlap * 160;
+}
+function isEdgeGuardObstacle(obstacle) {
+  return obstacle.id.startsWith("__edge_guard_") && "orientation" in obstacle && (obstacle.orientation === "vertical" || obstacle.orientation === "horizontal");
+}
+function containerTitleRoutingBand(container) {
+  return {
+    x: container.x,
+    y: container.y,
+    w: container.w,
+    h: TITLE_H + PAD
+  };
+}
+function segmentLength(a, b) {
+  return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);
+}
+function boxInteriorOverlap(a, b, box, pad) {
+  const left = box.x - pad;
+  const right = box.x + box.w + pad;
+  const top = box.y - pad;
+  const bottom = box.y + box.h + pad;
+  if (Math.abs(a[0] - b[0]) < EPS) {
+    const x = a[0];
+    if (x <= left || x >= right) return 0;
+    return intervalOverlap(a[1], b[1], top, bottom);
+  }
+  if (Math.abs(a[1] - b[1]) < EPS) {
+    const y = a[1];
+    if (y <= top || y >= bottom) return 0;
+    return intervalOverlap(a[0], b[0], left, right);
+  }
+  return 0;
+}
+function boxBorderOverlap(a, b, box) {
+  return boxBorderProximityOverlap(a, b, box, 0);
+}
+function boxBorderProximityOverlap(a, b, box, tolerance) {
+  if (Math.abs(a[0] - b[0]) < EPS) {
+    const x = a[0];
+    if (Math.abs(x - box.x) > tolerance + EPS && Math.abs(x - (box.x + box.w)) > tolerance + EPS) return 0;
+    return intervalOverlap(a[1], b[1], box.y, box.y + box.h);
+  }
+  if (Math.abs(a[1] - b[1]) < EPS) {
+    const y = a[1];
+    if (Math.abs(y - box.y) > tolerance + EPS && Math.abs(y - (box.y + box.h)) > tolerance + EPS) return 0;
+    return intervalOverlap(a[0], b[0], box.x, box.x + box.w);
+  }
+  return 0;
+}
+function intervalOverlap(a1, a2, b1, b2) {
+  const minA = Math.min(a1, a2);
+  const maxA = Math.max(a1, a2);
+  const minB = Math.min(b1, b2);
+  const maxB = Math.max(b1, b2);
+  return Math.max(0, Math.min(maxA, maxB) - Math.max(minA, minB));
+}
+function orthogonalRoute(a, b) {
+  const ca = { x: a.x + a.w / 2, y: a.y + a.h / 2 };
+  const cb = { x: b.x + b.w / 2, y: b.y + b.h / 2 };
+  const dx = cb.x - ca.x;
+  const dy = cb.y - ca.y;
+  let pa, pb;
+  const separatedHorizontally = a.x + a.w <= b.x || b.x + b.w <= a.x;
+  const separatedVertically = a.y + a.h <= b.y || b.y + b.h <= a.y;
+  const horizontal = separatedHorizontally ? true : separatedVertically ? false : Math.abs(dx) > Math.abs(dy);
+  if (horizontal) {
+    pa = [dx > 0 ? a.x + a.w : a.x, ca.y];
+    pb = [dx > 0 ? b.x : b.x + b.w, cb.y];
+    if (Math.abs(pa[1] - pb[1]) < 0.5) return [pa, pb];
+    const midX = (pa[0] + pb[0]) / 2;
+    return [pa, [midX, pa[1]], [midX, pb[1]], pb];
+  } else {
+    pa = [ca.x, dy > 0 ? a.y + a.h : a.y];
+    pb = [cb.x, dy > 0 ? b.y : b.y + b.h];
+    if (Math.abs(pa[0] - pb[0]) < 0.5) return [pa, pb];
+    const midY = (pa[1] + pb[1]) / 2;
+    return [pa, [pa[0], midY], [pb[0], midY], pb];
+  }
+}
+
+// src/core/render.ts
+var NS = "http://www.w3.org/2000/svg";
+var FONT_FAMILY = '"Hiragino Sans", "Yu Gothic", "Noto Sans CJK JP", sans-serif';
+var LABEL_OFFSET = 4;
+var LABEL_FONT_JA = 2.4;
+var LABEL_FONT_EN = 2.1;
+var LABEL_GAP = 0.6;
+var LABEL_OFFSET_STEPS = [0, 3.2, 6.4];
+var EPS2 = 1e-3;
+function render(laid, opts = {}) {
+  const lang = opts.lang ?? "ja";
+  const svg = el("svg", {
+    xmlns: NS,
+    viewBox: `0 0 ${laid.width} ${laid.height}`,
+    "font-family": FONT_FAMILY,
+    "shape-rendering": "geometricPrecision"
+  });
+  const containers = laid.nodes.filter((n) => n.isContainer);
+  const leaves = laid.nodes.filter((n) => !n.isContainer);
+  const labelBoxes = [];
+  for (const c of containers) svg.appendChild(renderContainer(c, lang));
+  for (const e of laid.edges) svg.appendChild(renderEdge(e, lang, laid, labelBoxes));
+  for (const e of laid.edges) svg.appendChild(renderEdgeHeads(e));
+  for (const n of leaves) svg.appendChild(renderNode(n, lang));
+  return svg;
+}
+function renderContainer(n, lang) {
+  const g = el("g");
+  g.appendChild(el("rect", {
+    x: n.x,
+    y: n.y,
+    width: n.w,
+    height: n.h,
+    fill: "white",
+    stroke: "#000",
+    "stroke-width": 0.3
+  }));
+  const labels = pickLabel(n.label, lang);
+  if (labels.length || n.id) {
+    const t = el("text", {
+      x: n.x + 2,
+      y: n.y + 3.5,
+      "font-size": 2.6,
+      fill: "#000"
+    });
+    t.textContent = (n.id ? n.id + " " : "") + (labels[0] ?? "");
+    g.appendChild(t);
+  }
+  return g;
+}
+function renderNode(n, lang) {
+  const g = el("g");
+  g.appendChild(renderShape(n));
+  const lines = [];
+  if (n.id && n.id !== "*") lines.push(n.id);
+  const labels = pickLabel(n.label, lang);
+  for (const l of labels) lines.push(l);
+  if (lines.length === 0) return g;
+  const fontSize = 2.8;
+  const lineH = fontSize * 1.2;
+  const totalH = lines.length * lineH;
+  const startY = n.y + n.h / 2 - totalH / 2 + lineH * 0.8;
+  for (let i = 0; i < lines.length; i++) {
+    const t = el("text", {
+      x: n.x + n.w / 2,
+      y: startY + i * lineH,
+      "font-size": fontSize,
+      fill: "#000",
+      "text-anchor": "middle"
+    });
+    t.textContent = lines[i];
+    g.appendChild(t);
+  }
+  return g;
+}
+function renderShape(n) {
+  const stroke = "#000";
+  const fill = "white";
+  const sw = 0.4;
+  switch (n.shape) {
+    case "round":
+      return el("rect", {
+        x: n.x,
+        y: n.y,
+        width: n.w,
+        height: n.h,
+        rx: Math.min(n.w, n.h) / 2,
+        ry: Math.min(n.w, n.h) / 2,
+        fill,
+        stroke,
+        "stroke-width": sw
+      });
+    case "circle": {
+      const r = Math.min(n.w, n.h) / 2;
+      return el("circle", {
+        cx: n.x + n.w / 2,
+        cy: n.y + n.h / 2,
+        r,
+        fill: "#000",
+        stroke
+      });
+    }
+    case "diamond": {
+      const cx = n.x + n.w / 2;
+      const cy = n.y + n.h / 2;
+      const pts = [[cx, n.y], [n.x + n.w, cy], [cx, n.y + n.h], [n.x, cy]].map((p) => p.join(",")).join(" ");
+      return el("polygon", { points: pts, fill, stroke, "stroke-width": sw });
+    }
+    case "actor":
+    case "box":
+    default:
+      return el("rect", {
+        x: n.x,
+        y: n.y,
+        width: n.w,
+        height: n.h,
+        fill,
+        stroke,
+        "stroke-width": sw
+      });
+  }
+}
+function renderEdge(e, lang, laid, labelBoxes) {
+  const g = el("g");
+  if (e.points.length < 2) return g;
+  const bodyPoints = edgeBodyPoints(e);
+  if (bodyPoints.length < 2) return g;
+  const d = bodyPoints.map((p, i) => i === 0 ? `M ${p[0]} ${p[1]}` : `L ${p[0]} ${p[1]}`).join(" ");
+  const path = el("path", {
+    d,
+    fill: "none",
+    stroke: "#000",
+    "stroke-width": strokeWidth(e.op),
+    "stroke-linecap": "butt",
+    "stroke-linejoin": "miter"
+  });
+  const dash = strokeDash(e.op);
+  if (dash) path.setAttribute("stroke-dasharray", dash);
+  g.appendChild(path);
+  const labels = pickLabel(e.label, lang);
+  if (labels.length) {
+    const ja = labels[0];
+    const en = labels[1];
+    const placement = chooseLabelPlacement(e, labels, laid, labelBoxes);
+    labelBoxes.push(expandBox(placement.box, 0.8));
+    const drawText = (text, x, y, fontSize, anchor, baseline) => {
+      const t = el("text", {
+        x,
+        y,
+        "font-size": fontSize,
+        fill: "#000",
+        "text-anchor": anchor,
+        "dominant-baseline": baseline
+      });
+      t.textContent = text;
+      g.appendChild(t);
+    };
+    drawText(ja, placement.ja.x, placement.ja.y, LABEL_FONT_JA, placement.anchor, placement.ja.baseline);
+    if (en && placement.en) {
+      drawText(en, placement.en.x, placement.en.y, LABEL_FONT_EN, placement.anchor, placement.en.baseline);
+    }
+  }
+  return g;
+}
+function renderEdgeHeads(e) {
+  const g = el("g");
+  if (e.isLifeline) return g;
+  const endHead = arrowHeadFor(e, false);
+  const startHead = arrowHeadFor(e, true);
+  if (endHead) g.appendChild(endHead);
+  if (startHead) g.appendChild(startHead);
+  return g;
+}
+function strokeWidth(op) {
+  return op === "thick" ? 0.7 : 0.4;
+}
+function strokeDash(op) {
+  return op === "dashed" || op === "dashed-arrow" ? "1.4 1.2" : null;
+}
+function edgeBodyPoints(e) {
+  let points = e.points.map((p) => [p[0], p[1]]);
+  if (e.op !== "line" && e.op !== "dashed") {
+    points = trimPolyline(points, false, arrowLength(e.op));
+  }
+  if (e.op === "bidir") {
+    points = trimPolyline(points, true, arrowLength(e.op));
+  }
+  return points;
+}
+function trimPolyline(points, atStart, amount) {
+  if (points.length < 2 || amount <= 0) return points;
+  const out = atStart ? [...points].reverse() : [...points];
+  let remaining = amount;
+  while (out.length >= 2 && remaining > 0) {
+    const tip = out[out.length - 1];
+    const prev = out[out.length - 2];
+    const dx = prev[0] - tip[0];
+    const dy = prev[1] - tip[1];
+    const len = Math.hypot(dx, dy);
+    if (len < EPS2) {
+      out.pop();
+      continue;
+    }
+    if (len > remaining) {
+      out[out.length - 1] = [
+        tip[0] + dx / len * remaining,
+        tip[1] + dy / len * remaining
+      ];
+      remaining = 0;
+    } else {
+      out.pop();
+      remaining -= len;
+    }
+  }
+  return atStart ? out.reverse() : out;
+}
+function arrowLength(op) {
+  return op === "thick" ? 3.4 : 2.8;
+}
+function arrowHeadFor(e, atStart) {
+  if (e.points.length < 2) return null;
+  if (atStart && e.op !== "bidir") return null;
+  if (!atStart && (e.op === "line" || e.op === "dashed")) return null;
+  const points = atStart ? e.points : [...e.points].reverse();
+  return renderArrowHead(points[0], points[1], e.op === "thick");
+}
+function renderArrowHead(tip, next, bold) {
+  const dx = next[0] - tip[0];
+  const dy = next[1] - tip[1];
+  const len = Math.hypot(dx, dy);
+  if (len < 1e-3) return null;
+  const ux = dx / len;
+  const uy = dy / len;
+  const arrowLen = bold ? 3.4 : 2.8;
+  const halfW = bold ? 1.6 : 1.25;
+  const bx = tip[0] + ux * arrowLen;
+  const by = tip[1] + uy * arrowLen;
+  const px = -uy;
+  const py = ux;
+  const pts = [
+    tip,
+    [bx + px * halfW, by + py * halfW],
+    [bx - px * halfW, by - py * halfW]
+  ].map((p) => p.join(",")).join(" ");
+  return el("polygon", {
+    points: pts,
+    fill: "#000",
+    stroke: "#000",
+    "stroke-width": 0
+  });
+}
+function el(tag, attrs = {}) {
+  const node = document.createElementNS(NS, tag);
+  for (const [k, v] of Object.entries(attrs)) node.setAttribute(k, String(v));
+  return node;
+}
+function pickLabel(b, lang) {
+  if (!b) return [];
+  if (lang === "ja") return b.ja ? [b.ja] : b.en ? [b.en] : [];
+  if (lang === "en") return b.en ? [b.en] : b.ja ? [b.ja] : [];
+  const out = [];
+  if (b.ja) out.push(b.ja);
+  if (b.en) out.push(b.en);
+  return out;
+}
+function chooseLabelPlacement(edge, labels, laid, occupiedLabels = []) {
+  const candidates = [];
+  const textW = Math.max(...labels.map((label, index) => estimateTextWidth(
+    label,
+    index === 0 ? LABEL_FONT_JA : LABEL_FONT_EN
+  )));
+  const textH = labels.length > 1 ? LABEL_FONT_JA + LABEL_FONT_EN + LABEL_GAP : LABEL_FONT_JA;
+  for (let i = 0; i < edge.points.length - 1; i++) {
+    const a = edge.points[i];
+    const b = edge.points[i + 1];
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const len = Math.abs(dx) + Math.abs(dy);
+    if (len < 8) continue;
+    for (const t of [0.5, 0.35, 0.65, 0.22, 0.78]) {
+      const x = a[0] + dx * t;
+      const y = a[1] + dy * t;
+      for (const offsetStep of LABEL_OFFSET_STEPS) {
+        const offset = LABEL_OFFSET + offsetStep;
+        const offsetPenalty = offsetStep * 9;
+        if (Math.abs(dy) < EPS2) {
+          candidates.push(makeHorizontalLabel(edge, laid, occupiedLabels, labels, textW, textH, a, b, x, y, "above", offset, offsetPenalty));
+          candidates.push(makeHorizontalLabel(edge, laid, occupiedLabels, labels, textW, textH, a, b, x, y, "below", offset, offsetPenalty));
+        } else if (Math.abs(dx) < EPS2) {
+          candidates.push(makeVerticalLabel(edge, laid, occupiedLabels, labels, textW, textH, a, b, x, y, "right", offset, offsetPenalty));
+          candidates.push(makeVerticalLabel(edge, laid, occupiedLabels, labels, textW, textH, a, b, x, y, "left", offset, offsetPenalty));
+        }
+      }
+    }
+  }
+  if (candidates.length === 0) {
+    const [a, b] = longestSegment(edge.points);
+    const x = (a[0] + b[0]) / 2;
+    const y = (a[1] + b[1]) / 2;
+    return Math.abs(b[1] - a[1]) >= Math.abs(b[0] - a[0]) ? makeVerticalLabel(edge, laid, occupiedLabels, labels, textW, textH, a, b, x, y, "right", LABEL_OFFSET, 0) : makeHorizontalLabel(edge, laid, occupiedLabels, labels, textW, textH, a, b, x, y, "above", LABEL_OFFSET, 0);
+  }
+  candidates.sort((a, b) => a.score - b.score);
+  return candidates[0];
+}
+function makeHorizontalLabel(edge, laid, occupiedLabels, labels, textW, textH, lineA, lineB, x, lineY, side, offset, offsetPenalty) {
+  const top = side === "above" ? lineY - offset - textH : lineY + offset;
+  const box = { x: x - textW / 2, y: top, w: textW, h: textH };
+  let jaY;
+  let enY;
+  if (labels.length > 1) {
+    jaY = top + LABEL_FONT_JA;
+    enY = jaY + LABEL_GAP + LABEL_FONT_EN;
+  } else {
+    jaY = top + LABEL_FONT_JA;
+  }
+  const placement = {
+    box,
+    lineA,
+    lineB,
+    score: 0,
+    vertical: false,
+    anchor: "middle",
+    ja: { x, y: jaY, baseline: "alphabetic" },
+    en: enY === void 0 ? void 0 : { x, y: enY, baseline: "alphabetic" }
+  };
+  placement.score = labelPlacementScore(placement, edge, laid, occupiedLabels) + (side === "above" ? 0 : 8) + offsetPenalty;
+  return placement;
+}
+function makeVerticalLabel(edge, laid, occupiedLabels, labels, textW, textH, lineA, lineB, lineX, y, side, offset, offsetPenalty) {
+  const x = side === "right" ? lineX + offset : lineX - offset;
+  const box = {
+    x: side === "right" ? x : x - textW,
+    y: y - textH / 2,
+    w: textW,
+    h: textH
+  };
+  const anchor = side === "right" ? "start" : "end";
+  const jaY = labels.length > 1 ? y - LABEL_FONT_JA / 2 - LABEL_GAP / 2 : y;
+  const enY = labels.length > 1 ? y + LABEL_FONT_EN / 2 + LABEL_GAP / 2 : void 0;
+  const placement = {
+    box,
+    lineA,
+    lineB,
+    score: 0,
+    vertical: true,
+    anchor,
+    ja: { x, y: jaY, baseline: "middle" },
+    en: enY === void 0 ? void 0 : { x, y: enY, baseline: "middle" }
+  };
+  placement.score = labelPlacementScore(placement, edge, laid, occupiedLabels) + (side === "right" ? 0 : 8) + offsetPenalty;
+  return placement;
+}
+function labelPlacementScore(placement, edge, laid, occupiedLabels) {
+  let score = placement.vertical ? 5 : 0;
+  const box = placement.box;
+  if (box.x < 0) score += Math.abs(box.x) * 300;
+  if (box.y < 0) score += Math.abs(box.y) * 300;
+  if (box.x + box.w > laid.width) score += (box.x + box.w - laid.width) * 300;
+  if (box.y + box.h > laid.height) score += (box.y + box.h - laid.height) * 300;
+  for (const node of laid.nodes) {
+    if (node.isContainer) {
+      const title = { x: node.x, y: node.y, w: node.w, h: 6 };
+      score += rectOverlapArea(box, title) * 900;
+      score += rectBorderOverlapPenalty(box, node) * 1800;
+      score += rectBorderBandOverlapArea(box, node, 1.8) * 9e3;
+    } else {
+      const bodyOverlap = rectOverlapArea(box, node);
+      if (bodyOverlap > 0) score += 1e6 + bodyOverlap * 5e4;
+      score += rectOverlapArea(box, expandBox(node, 1.8)) * 5200;
+    }
+  }
+  for (const other of laid.edges) {
+    for (let i = 0; i < other.points.length - 1; i++) {
+      const a = other.points[i];
+      const b = other.points[i + 1];
+      const overlap = segmentIntersectsRect(a, b, expandBox(box, 0.8));
+      if (!overlap) continue;
+      score += other === edge ? 35 : 380;
+    }
+  }
+  for (const occupied of occupiedLabels) {
+    score += rectOverlapArea(box, occupied) * 18e3;
+  }
+  const segmentLen = Math.abs(placement.lineA[0] - placement.lineB[0]) + Math.abs(placement.lineA[1] - placement.lineB[1]);
+  const labelSpan = placement.vertical ? box.h : box.w;
+  score += Math.max(0, Math.max(36, labelSpan * 2.4) - segmentLen) * 80;
+  const center = placement.vertical ? box.y + box.h / 2 : box.x + box.w / 2;
+  const start = placement.vertical ? placement.lineA[1] : placement.lineA[0];
+  const end = placement.vertical ? placement.lineB[1] : placement.lineB[0];
+  const endpointDistance = Math.min(Math.abs(center - start), Math.abs(center - end));
+  score += Math.max(0, 12 - endpointDistance) * 80;
+  return score;
+}
+function estimateTextWidth(text, fontSize) {
+  let width = 0;
+  for (const char of text) {
+    if (char === " ") width += fontSize * 0.35;
+    else if (char.charCodeAt(0) <= 127) width += fontSize * 0.58;
+    else width += fontSize;
+  }
+  return Math.max(fontSize * 2, width);
+}
+function longestSegment(pts) {
+  let best = 0;
+  let bestLen = -1;
+  for (let i = 0; i < pts.length - 1; i++) {
+    const dx = pts[i + 1][0] - pts[i][0];
+    const dy = pts[i + 1][1] - pts[i][1];
+    const len = dx * dx + dy * dy;
+    if (len > bestLen) {
+      bestLen = len;
+      best = i;
+    }
+  }
+  const a = pts[best];
+  const b = pts[best + 1];
+  return [a, b];
+}
+function expandBox(box, pad) {
+  return { x: box.x - pad, y: box.y - pad, w: box.w + pad * 2, h: box.h + pad * 2 };
+}
+function rectOverlapArea(a, b) {
+  const x = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x));
+  const y = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+  return x * y;
+}
+function rectBorderOverlapPenalty(a, b) {
+  const nearLeft = Math.abs(a.x - b.x) < 1 || Math.abs(a.x + a.w - b.x) < 1;
+  const nearRight = Math.abs(a.x - (b.x + b.w)) < 1 || Math.abs(a.x + a.w - (b.x + b.w)) < 1;
+  const nearTop = Math.abs(a.y - b.y) < 1 || Math.abs(a.y + a.h - b.y) < 1;
+  const nearBottom = Math.abs(a.y - (b.y + b.h)) < 1 || Math.abs(a.y + a.h - (b.y + b.h)) < 1;
+  return Number(nearLeft || nearRight || nearTop || nearBottom);
+}
+function rectBorderBandOverlapArea(a, b, band) {
+  return rectOverlapArea(a, { x: b.x - band, y: b.y - band, w: band * 2, h: b.h + band * 2 }) + rectOverlapArea(a, { x: b.x + b.w - band, y: b.y - band, w: band * 2, h: b.h + band * 2 }) + rectOverlapArea(a, { x: b.x - band, y: b.y - band, w: b.w + band * 2, h: band * 2 }) + rectOverlapArea(a, { x: b.x - band, y: b.y + b.h - band, w: b.w + band * 2, h: band * 2 });
+}
+function segmentIntersectsRect(a, b, box) {
+  const left = box.x;
+  const right = box.x + box.w;
+  const top = box.y;
+  const bottom = box.y + box.h;
+  if (Math.abs(a[0] - b[0]) < EPS2) {
+    const x = a[0];
+    if (x <= left || x >= right) return false;
+    return intervalOverlap2(a[1], b[1], top, bottom) > EPS2;
+  }
+  if (Math.abs(a[1] - b[1]) < EPS2) {
+    const y = a[1];
+    if (y <= top || y >= bottom) return false;
+    return intervalOverlap2(a[0], b[0], left, right) > EPS2;
+  }
+  return false;
+}
+function intervalOverlap2(a1, a2, b1, b2) {
+  const minA = Math.min(a1, a2);
+  const maxA = Math.max(a1, a2);
+  const minB = Math.min(b1, b2);
+  const maxB = Math.max(b1, b2);
+  return Math.max(0, Math.min(maxA, maxB) - Math.max(minA, minB));
+}
+
+// src/core/refs.ts
+function refsToMarkdown(doc) {
+  const ids = sortedIds(doc);
+  const lines = [];
+  lines.push("## \u7B26\u53F7\u306E\u8AAC\u660E / Reference Signs");
+  lines.push("");
+  lines.push("| \u7B26\u53F7 | \u540D\u79F0(\u65E5\u672C\u8A9E) | Name (English) |");
+  lines.push("|------|---------------|----------------|");
+  for (const id of ids) {
+    const n = doc.nodes.get(id);
+    lines.push(`| ${id} | ${n.label.ja ?? ""} | ${n.label.en ?? ""} |`);
+  }
+  return lines.join("\n");
+}
+function refsToCsv(doc) {
+  const ids = sortedIds(doc);
+  const lines = ["id,ja,en"];
+  for (const id of ids) {
+    const n = doc.nodes.get(id);
+    lines.push(`${csv(id)},${csv(n.label.ja ?? "")},${csv(n.label.en ?? "")}`);
+  }
+  return lines.join("\n");
+}
+function csv(s) {
+  return /[",\n]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s;
+}
+function sortedIds(doc) {
+  const ids = [...doc.nodes.keys()].filter((id) => id !== "*");
+  return ids.sort((a, b) => {
+    const na = parseInt(a, 10);
+    const nb = parseInt(b, 10);
+    if (!isNaN(na) && !isNaN(nb)) return na - nb;
+    return a.localeCompare(b);
+  });
+}
+
+// src/core/samples.ts
+var SAMPLE_ORDER = [
+  "block",
+  "system",
+  "iot",
+  "imagePipeline",
+  "controlLoop",
+  "flow",
+  "state",
+  "seq",
+  "handshake"
+];
+var SAMPLES = {
+  block: {
+    label: "\u30D6\u30ED\u30C3\u30AF\u56F3",
+    hint: "\u300C:\u300D\u3092\u4F7F\u3046\u3068\u30D6\u30ED\u30C3\u30AF\u56F3\u306B\u306A\u308B",
+    source: `# \u30D6\u30ED\u30C3\u30AF\u56F3(\u88C5\u7F6E\u30AF\u30EC\u30FC\u30E0\u7528)
+# \u30D2\u30F3\u30C8:\u300C:\u300D\u3067\u5305\u542B\u95A2\u4FC2\u3092\u66F8\u304F \u2192 \u30D6\u30ED\u30C3\u30AF\u56F3\u3068\u5224\u5B9A\u3055\u308C\u308B
+
+10 = \u5236\u5FA1\u88C5\u7F6E / control device
+11 = CPU
+12 = \u30E1\u30E2\u30EA / memory
+13 = "I/O \u30A4\u30F3\u30BF\u30FC\u30D5\u30A7\u30FC\u30B9" / "I/O interface"
+20 = \u5916\u90E8\u6A5F\u5668 / external device
+
+10 : 11 12 13
+
+11 - 12
+11 - 13
+13 -> 20 : \u4FE1\u53F7 / signal
+`
+  },
+  system: {
+    label: "\u30B7\u30B9\u30C6\u30E0\u5168\u4F53",
+    hint: "\u968E\u5C64\u69CB\u6210 + \u5916\u90E8\u63A5\u7D9A",
+    source: `# \u30B7\u30B9\u30C6\u30E0\u5168\u4F53(\u968E\u5C64+\u5916\u90E8\u63A5\u7D9A)
+# \u30D2\u30F3\u30C8: \u5185\u90E8\u30D6\u30ED\u30C3\u30AF\u3068\u5916\u90E8\u88C5\u7F6E\u3092\u5206\u3051\u3066\u66F8\u304F\u3068\u3001\u7279\u8A31\u56F3\u9762\u3089\u3057\u3044\u69CB\u6210\u306B\u306A\u308B
+
+100 = \u30B7\u30B9\u30C6\u30E0\u672C\u4F53 / Main system
+10 = \u5236\u5FA1\u90E8 / Control
+20 = \u901A\u4FE1\u90E8 / Comm
+11 = CPU
+12 = \u30E1\u30E2\u30EA / memory
+21 = \u7121\u7DDA\u90E8 / wireless
+22 = \u6709\u7DDA\u90E8 / wired
+30 = \u5916\u90E8\u30B5\u30FC\u30D0 / external server
+40 = \u5916\u90E8\u7AEF\u672B / external terminal
+
+100 : 10 20
+10 : 11 12
+20 : 21 22
+
+21 .> 40 : \u7121\u7DDA / wireless
+22 -> 30 : \u6709\u7DDA / wired
+30 <-> 40 : \u901A\u4FE1 / comm
+`
+  },
+  iot: {
+    label: "IoT/\u30AF\u30E9\u30A6\u30C9",
+    hint: "\u30BB\u30F3\u30B5\u7AEF\u672B\u30FB\u30B2\u30FC\u30C8\u30A6\u30A7\u30A4\u30FB\u30AF\u30E9\u30A6\u30C9\u306E\u5178\u578B\u69CB\u6210",
+    source: `# IoT/\u30AF\u30E9\u30A6\u30C9\u69CB\u6210
+# \u30D2\u30F3\u30C8: \u7AEF\u672B\u5185\u90E8\u306E\u69CB\u6210\u3068\u30AF\u30E9\u30A6\u30C9\u5074\u306E\u69CB\u6210\u3092\u5225\u30B3\u30F3\u30C6\u30CA\u306B\u3059\u308B
+
+100 = \u30BB\u30F3\u30B5\u7AEF\u672B / sensor terminal
+10 = \u691C\u51FA\u90E8 / detector
+11 = \u6E29\u5EA6\u30BB\u30F3\u30B5 / temperature sensor
+12 = \u52A0\u901F\u5EA6\u30BB\u30F3\u30B5 / acceleration sensor
+20 = \u51E6\u7406\u90E8 / processor
+21 = \u53D6\u5F97\u90E8 / acquisition unit
+22 = \u5224\u5B9A\u90E8 / determination unit
+30 = \u901A\u4FE1\u90E8 / communication unit
+200 = \u30B2\u30FC\u30C8\u30A6\u30A7\u30A4 / gateway
+300 = \u30AF\u30E9\u30A6\u30C9\u30B5\u30FC\u30D0 / cloud server
+310 = \u53D7\u4FE1\u90E8 / receiver
+320 = \u89E3\u6790\u90E8 / analyzer
+330 = \u8A18\u61B6\u90E8 / storage
+
+100 : 10 20 30
+10 : 11 12
+20 : 21 22
+300 : 310 320 330
+
+10 -> 20 : \u30BB\u30F3\u30B5\u5024 / sensor value
+20 -> 30 : \u9001\u4FE1\u30C7\u30FC\u30BF / transmission data
+30 .> 200 : \u7121\u7DDA / wireless
+200 -> 310 : \u4E2D\u7D99 / relay
+310 -> 320 : \u30C7\u30FC\u30BF / data
+320 -> 330 : \u7D50\u679C / result
+`
+  },
+  imagePipeline: {
+    label: "\u753B\u50CF\u51E6\u7406",
+    hint: "\u753B\u50CF\u5165\u529B\u304B\u3089\u5224\u5B9A\u7D50\u679C\u307E\u3067\u306E\u51E6\u7406\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3",
+    source: `# \u753B\u50CF\u51E6\u7406\u30D1\u30A4\u30D7\u30E9\u30A4\u30F3(\u65B9\u6CD5\u30AF\u30EC\u30FC\u30E0\u7528)
+# \u30D2\u30F3\u30C8: \u7247\u65B9\u5411\u306E\u63A5\u7D9A\u306E\u307F\u306A\u3089\u30D5\u30ED\u30FC\u30C1\u30E3\u30FC\u30C8\u3068\u3057\u3066\u63CF\u753B\u3055\u308C\u308B
+
+S100 = \u753B\u50CF\u3092\u53D6\u5F97 / Acquire image
+S110 = \u524D\u51E6\u7406 / Preprocess
+S120 = \u7279\u5FB4\u91CF\u3092\u62BD\u51FA / Extract features
+S130 = \u6B20\u9665\u3042\u308A? / Defect?
+S140 = \u30A2\u30E9\u30FC\u30C8\u3092\u51FA\u529B / Output alert
+S150 = \u6B63\u5E38\u7D50\u679C\u3092\u8A18\u9332 / Record normal result
+S160 = \u7D42\u4E86 / End
+
+S100 -> S110
+S110 -> S120
+S120 -> S130
+S130 -> S140 : Yes
+S130 -> S150 : No
+S140 -> S160
+S150 -> S160
+`
+  },
+  controlLoop: {
+    label: "\u5236\u5FA1\u30EB\u30FC\u30D7",
+    hint: "\u30BB\u30F3\u30B5\u30FB\u5236\u5FA1\u5668\u30FB\u30A2\u30AF\u30C1\u30E5\u30A8\u30FC\u30BF\u306E\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u69CB\u6210",
+    source: `# \u5236\u5FA1\u30EB\u30FC\u30D7(\u88C5\u7F6E\u30AF\u30EC\u30FC\u30E0\u7528)
+# \u30D2\u30F3\u30C8: \u30EB\u30FC\u30D7\u3059\u308B\u69CB\u6210\u306F\u30011\u3064\u306E\u30B7\u30B9\u30C6\u30E0\u5185\u3067\u6642\u8A08\u56DE\u308A\u306B\u4E26\u3079\u308B\u3068\u8AAD\u307F\u3084\u3059\u3044
+
+100 = \u5236\u5FA1\u30B7\u30B9\u30C6\u30E0 / control system
+10 = \u5236\u5FA1\u90E8 / controller
+11 = \u76EE\u6A19\u5024\u53D6\u5F97\u90E8 / target acquisition unit
+12 = \u504F\u5DEE\u7B97\u51FA\u90E8 / error calculator
+13 = \u6307\u4EE4\u751F\u6210\u90E8 / command generator
+20 = \u99C6\u52D5\u90E8 / driver
+30 = \u30BB\u30F3\u30B5\u90E8 / sensor unit
+40 = \u5BFE\u8C61\u88C5\u7F6E / controlled object
+
+100 : 30 10 40 20
+10 : 11 12 13
+
+30 -> 12 : \u6E2C\u5B9A\u5024 / measured value
+11 -> 12 : \u76EE\u6A19\u5024 / target value
+12 -> 13 : \u504F\u5DEE / error
+13 -> 20 : \u6307\u4EE4 / command
+20 -> 40 : \u99C6\u52D5\u4FE1\u53F7 / drive signal
+40 .> 30 : \u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF / feedback
+`
+  },
+  flow: {
+    label: "\u30D5\u30ED\u30FC\u30C1\u30E3\u30FC\u30C8",
+    hint: "\u30E9\u30D9\u30EB\u306B\u300C?\u300D\u304C\u3042\u308B \u2192 \u30D5\u30ED\u30FC\u3068\u5224\u5B9A",
+    source: `# \u30D5\u30ED\u30FC\u30C1\u30E3\u30FC\u30C8(\u65B9\u6CD5\u30AF\u30EC\u30FC\u30E0\u7528)
+# \u30D2\u30F3\u30C8:\u30E9\u30D9\u30EB\u672B\u5C3E\u306B\u300C?\u300D \u2192 \u83F1\u5F62(\u6761\u4EF6\u5206\u5C90)\u306B\u81EA\u52D5\u63A8\u8AD6
+
+S100 = \u958B\u59CB / Start
+S110 = \u6761\u4EF6A? / "Condition A?"
+S120 = \u51E6\u7406X / Process X
+S130 = \u51E6\u7406Y / Process Y
+S140 = \u7D42\u4E86 / End
+
+S100 -> S110
+S110 -> S120 : Yes
+S110 -> S130 : No
+S120 -> S140
+S130 -> S140
+`
+  },
+  state: {
+    label: "\u72B6\u614B\u9077\u79FB\u56F3",
+    hint: "\u300C*\u300D\u3092\u4F7F\u3046 \u2192 \u72B6\u614B\u9077\u79FB\u3068\u5224\u5B9A",
+    source: `# \u72B6\u614B\u9077\u79FB\u56F3
+# \u30D2\u30F3\u30C8:\u300C*\u300D\u304C\u521D\u671F/\u7D42\u7AEF\u306E\u7B26\u53F7(\u9ED2\u4E38\u3067\u63CF\u753B)
+
+S1 = \u5F85\u6A5F / Idle
+S2 = \u52D5\u4F5C\u4E2D / Running
+S3 = \u30A8\u30E9\u30FC / Error
+
+* -> S1
+S1 -> S2 : \u8D77\u52D5 / start
+S2 -> S1 : \u505C\u6B62 / stop
+S2 -> S3 : \u7570\u5E38 / fault
+S3 -> S1 : \u30EA\u30BB\u30C3\u30C8 / reset
+S3 -> *
+`
+  },
+  seq: {
+    label: "\u30B7\u30FC\u30B1\u30F3\u30B9\u56F3",
+    hint: "\u300C:\u300D\u3082\u300C?\u300D\u3082\u300C*\u300D\u3082\u306A\u3044 \u2192 \u30B7\u30FC\u30B1\u30F3\u30B9",
+    source: `# \u30B7\u30FC\u30B1\u30F3\u30B9\u56F3(\u30D7\u30ED\u30C8\u30B3\u30EB\u7CFB)
+# \u30D2\u30F3\u30C8:\u5305\u542B\u3082?\u3082*\u3082\u7121\u3044 \u2192 \u30B7\u30FC\u30B1\u30F3\u30B9\u56F3\u3068\u3057\u3066\u63CF\u753B
+#         \u30A2\u30AF\u30BF\u306F\u767B\u5834\u9806\u306B\u5DE6\u304B\u3089\u4E26\u3076
+
+100 = \u30AF\u30E9\u30A4\u30A2\u30F3\u30C8 / client
+200 = \u30B5\u30FC\u30D0 / server
+
+100 -> 200 : \u8A8D\u8A3C\u8981\u6C42 / auth request
+200 -> 100 : \u30C8\u30FC\u30AF\u30F3 / token
+100 -> 200 : \u30EA\u30BD\u30FC\u30B9\u8981\u6C42 / resource request
+200 -> 100 : \u30EA\u30BD\u30FC\u30B9\u5FDC\u7B54 / resource response
+`
+  },
+  handshake: {
+    label: "\u30CF\u30F3\u30C9\u30B7\u30A7\u30A4\u30AF",
+    hint: "\u8981\u6C42/\u5FDC\u7B54/\u78BA\u7ACB/\u7D42\u4E86\u306E\u901A\u4FE1\u30B7\u30FC\u30B1\u30F3\u30B9",
+    source: `# \u901A\u4FE1\u30CF\u30F3\u30C9\u30B7\u30A7\u30A4\u30AF(\u30B7\u30FC\u30B1\u30F3\u30B9\u56F3)
+# \u30D2\u30F3\u30C8: \u5F80\u5FA9\u30E1\u30C3\u30BB\u30FC\u30B8\u304C\u3042\u308B\u3068\u30B7\u30FC\u30B1\u30F3\u30B9\u56F3\u306B\u306A\u308B
+
+100 = \u7AEF\u672B / terminal
+200 = \u30B5\u30FC\u30D0 / server
+
+100 -> 200 : \u63A5\u7D9A\u8981\u6C42 / connect request
+200 -> 100 : \u5FDC\u7B54 / response
+100 -> 200 : \u8A8D\u8A3C\u60C5\u5831 / credentials
+200 -> 100 : \u8A8D\u8A3C\u7D50\u679C / auth result
+100 <-> 200 : \u30C7\u30FC\u30BF\u901A\u4FE1 / data exchange
+100 -> 200 : \u5207\u65AD\u8981\u6C42 / disconnect
+200 -> 100 : \u5207\u65AD\u5B8C\u4E86 / disconnected
+`
+  }
+};
+
+// src/core/patterns.ts
+var PATTERN_LABEL = {
+  cond: "\u6761\u4EF6\u5206\u5C90",
+  container: "\u89AA\u5B50\u69CB\u6210",
+  external: "\u89AA\u5B50+\u5916\u90E8",
+  seq: "\u30B7\u30FC\u30B1\u30F3\u30B9",
+  state: "\u72B6\u614B\u9077\u79FB",
+  bidir: "\u53CC\u65B9\u5411\u901A\u4FE1",
+  hierarchy: "3\u968E\u5C64\u69CB\u6210",
+  pipeline: "N\u6BB5\u968E\u51E6\u7406",
+  parallel: "\u4E26\u5217\u51E6\u7406",
+  handshake: "\u901A\u4FE1\u30CF\u30F3\u30C9\u30B7\u30A7\u30A4\u30AF",
+  state_with_cond: "\u72B6\u614B\u5224\u5B9A\u30D5\u30ED\u30FC",
+  system: "\u30B7\u30B9\u30C6\u30E0\u5168\u4F53"
+};
+var PATTERN_SOURCE = {
+  cond: `S100 = \u958B\u59CB / Start
+S110 = \u5224\u5B9A? / Decision?
+S120 = Yes\u51E6\u7406 / Yes Process
+S130 = No\u51E6\u7406 / No Process
+S140 = \u7D42\u4E86 / End
+S100 -> S110
+S110 -> S120 : Yes
+S110 -> S130 : No
+S120 -> S140
+S130 -> S140`,
+  container: `10 = \u89AA\u88C5\u7F6E / Parent
+11 = \u90E8\u54C11 / Part 1
+12 = \u90E8\u54C12 / Part 2
+13 = \u90E8\u54C13 / Part 3
+10 : 11 12 13`,
+  external: `10 = \u5236\u5FA1\u88C5\u7F6E / control device
+11 = \u5165\u529B\u90E8 / input
+12 = \u51E6\u7406\u90E8 / processor
+20 = \u5916\u90E8\u6A5F\u5668 / external device
+10 : 11 12
+12 -> 20 : \u4FE1\u53F7 / signal`,
+  seq: `100 = \u30AF\u30E9\u30A4\u30A2\u30F3\u30C8 / client
+200 = \u30B5\u30FC\u30D0 / server
+100 -> 200 : \u8981\u6C42 / request
+200 -> 100 : \u5FDC\u7B54 / response
+100 -> 200 : \u5207\u65AD / disconnect`,
+  state: `S1 = \u5F85\u6A5F / Idle
+S2 = \u52D5\u4F5C\u4E2D / Running
+* -> S1
+S1 -> S2 : \u8D77\u52D5 / start
+S2 -> S1 : \u505C\u6B62 / stop`,
+  bidir: `100 = \u7AEF\u672BA / Terminal A
+200 = \u7AEF\u672BB / Terminal B
+100 <-> 200 : \u901A\u4FE1 / comm`,
+  hierarchy: `100 = \u30B7\u30B9\u30C6\u30E0 / System
+10 = \u30B5\u30D6\u30B7\u30B9\u30C6\u30E0A / Subsystem A
+20 = \u30B5\u30D6\u30B7\u30B9\u30C6\u30E0B / Subsystem B
+11 = \u90E8\u54C1A1 / Part A1
+12 = \u90E8\u54C1A2 / Part A2
+21 = \u90E8\u54C1B1 / Part B1
+22 = \u90E8\u54C1B2 / Part B2
+100 : 10 20
+10 : 11 12
+20 : 21 22`,
+  pipeline: `S100 = \u5165\u529B / Input
+S110 = \u524D\u51E6\u7406 / Preprocess
+S120 = \u4E3B\u51E6\u7406 / Main Process
+S130 = \u5F8C\u51E6\u7406 / Postprocess
+S140 = \u51FA\u529B / Output
+S100 -> S110
+S110 -> S120
+S120 -> S130
+S130 -> S140`,
+  parallel: `S100 = \u958B\u59CB / Start
+S110 = \u5206\u5C90 / Branch
+S120 = \u7D4C\u8DEFA / Path A
+S130 = \u7D4C\u8DEFB / Path B
+S140 = \u7D4C\u8DEFC / Path C
+S150 = \u5408\u6D41 / Join
+S160 = \u7D42\u4E86 / End
+S100 -> S110
+S110 -> S120
+S110 -> S130
+S110 -> S140
+S120 -> S150
+S130 -> S150
+S140 -> S150
+S150 -> S160`,
+  handshake: `100 = \u7AEF\u672B / Terminal
+200 = \u30B5\u30FC\u30D0 / Server
+100 -> 200 : SYN\u8981\u6C42 / SYN
+200 -> 100 : SYN+ACK / SYN+ACK
+100 -> 200 : ACK\u5FDC\u7B54 / ACK
+100 <-> 200 : \u30C7\u30FC\u30BF\u4EA4\u63DB / data exchange
+100 -> 200 : FIN / FIN
+200 -> 100 : ACK / ACK`,
+  state_with_cond: `S100 = \u5F85\u6A5F\u72B6\u614B / Idle state
+S110 = \u691C\u8A3C\u51E6\u7406 / Verify
+S120 = OK? / OK?
+S130 = \u5B8C\u4E86\u72B6\u614B / Done state
+S140 = \u5931\u6557\u72B6\u614B / Failed state
+S150 = \u518D\u8A66\u884C / Retry
+S100 -> S110 : \u8981\u6C42 / request
+S110 -> S120 : \u5224\u5B9A / check
+S120 -> S130 : OK
+S120 -> S140 : NG
+S140 -> S150
+S150 -> S100`,
+  system: `100 = \u30B7\u30B9\u30C6\u30E0\u672C\u4F53 / Main system
+10 = \u5236\u5FA1\u90E8 / Control
+20 = \u901A\u4FE1\u90E8 / Comm
+11 = CPU
+12 = \u30E1\u30E2\u30EA / memory
+21 = \u7121\u7DDA\u90E8 / wireless
+22 = \u6709\u7DDA\u90E8 / wired
+30 = \u5916\u90E8\u30B5\u30FC\u30D0 / external server
+40 = \u5916\u90E8\u7AEF\u672B / external terminal
+100 : 10 20
+10 : 11 12
+20 : 21 22
+21 .> 40 : \u7121\u7DDA / wireless
+22 -> 30 : \u6709\u7DDA / wired
+30 <-> 40 : \u901A\u4FE1 / comm`
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OP_TABLE,
+  PATTERN_LABEL,
+  PATTERN_SOURCE,
+  SAMPLES,
+  SAMPLE_ORDER,
+  chooseLabelPlacement,
+  estimateTextWidth,
+  layout,
+  parse,
+  refsToCsv,
+  refsToMarkdown,
+  render,
+  splitBilingual,
+  stripComment
+});