@shibayama/pdgkit 0.1.0

package/dist/pdgkit.js

@@ -0,0 +1,3534 @@
+#!/usr/bin/env node
+
+// bin/pdgkit.ts
+import fs from "fs";
+
+// 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/node/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/node/dom.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var ShimElement = class {
+  constructor(namespaceURI, tagName) {
+    this.namespaceURI = namespaceURI;
+    this.tagName = tagName;
+  }
+  namespaceURI;
+  tagName;
+  nodeType = "element";
+  attrs = /* @__PURE__ */ new Map();
+  children = [];
+  text = null;
+  setAttribute(name, value) {
+    this.attrs.set(name, String(value));
+  }
+  getAttribute(name) {
+    return this.attrs.has(name) ? this.attrs.get(name) : null;
+  }
+  removeAttribute(name) {
+    this.attrs.delete(name);
+  }
+  appendChild(child) {
+    this.text = null;
+    this.children.push(child);
+    return child;
+  }
+  set textContent(value) {
+    this.text = value == null ? "" : String(value);
+    this.children = [];
+  }
+  get textContent() {
+    if (this.text != null) return this.text;
+    return this.children.map((c) => c.textContent).join("");
+  }
+};
+var shimDocument = {
+  createElementNS(ns, qualifiedName) {
+    return new ShimElement(ns, qualifiedName);
+  },
+  createElement(tagName) {
+    return new ShimElement(SVG_NS, tagName);
+  }
+};
+function withShimDocument(fn) {
+  const g = globalThis;
+  const prev = g.document;
+  g.document = shimDocument;
+  try {
+    return fn();
+  } finally {
+    g.document = prev;
+  }
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeSvg(node) {
+  const attrs = [...node.attrs].map(([name, value]) => ` ${name}="${escapeAttr(value)}"`).join("");
+  if (node.text != null) {
+    return `<${node.tagName}${attrs}>${escapeText(node.text)}</${node.tagName}>`;
+  }
+  if (node.children.length === 0) {
+    return `<${node.tagName}${attrs}/>`;
+  }
+  const inner = node.children.map(serializeSvg).join("");
+  return `<${node.tagName}${attrs}>${inner}</${node.tagName}>`;
+}
+
+// src/node/content-box.ts
+var DEFAULT_BLEED = 3;
+function num(node, name, fallback = 0) {
+  const raw = node.getAttribute(name);
+  if (raw == null) return fallback;
+  const n = Number.parseFloat(raw);
+  return Number.isFinite(n) ? n : fallback;
+}
+function parseNumbers(text) {
+  const out = [];
+  const re = /-?\d*\.?\d+(?:e[-+]?\d+)?/gi;
+  let m;
+  while ((m = re.exec(text)) !== null) out.push(Number.parseFloat(m[0]));
+  return out;
+}
+function primitiveBounds(node) {
+  switch (node.tagName) {
+    case "rect": {
+      const x = num(node, "x");
+      const y = num(node, "y");
+      const w = num(node, "width");
+      const h = num(node, "height");
+      if (w <= 0 && h <= 0) return null;
+      return { minX: x, minY: y, maxX: x + w, maxY: y + h };
+    }
+    case "circle": {
+      const cx = num(node, "cx");
+      const cy = num(node, "cy");
+      const r = num(node, "r");
+      if (r <= 0) return null;
+      return { minX: cx - r, minY: cy - r, maxX: cx + r, maxY: cy + r };
+    }
+    case "line": {
+      const x1 = num(node, "x1");
+      const y1 = num(node, "y1");
+      const x2 = num(node, "x2");
+      const y2 = num(node, "y2");
+      return {
+        minX: Math.min(x1, x2),
+        minY: Math.min(y1, y2),
+        maxX: Math.max(x1, x2),
+        maxY: Math.max(y1, y2)
+      };
+    }
+    case "polygon":
+    case "polyline": {
+      const nums = parseNumbers(node.getAttribute("points") ?? "");
+      return boundsFromPairs(nums);
+    }
+    case "path": {
+      const nums = parseNumbers(node.getAttribute("d") ?? "");
+      return boundsFromPairs(nums);
+    }
+    case "text": {
+      return textBounds(node);
+    }
+    default:
+      return null;
+  }
+}
+function boundsFromPairs(nums) {
+  if (nums.length < 2) return null;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (let i = 0; i + 1 < nums.length; i += 2) {
+    const x = nums[i];
+    const y = nums[i + 1];
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+  }
+  if (!Number.isFinite(minX)) return null;
+  return { minX, minY, maxX, maxY };
+}
+function textBounds(node) {
+  const text = node.textContent;
+  if (!text) return null;
+  const x = num(node, "x");
+  const y = num(node, "y");
+  const fontSize = num(node, "font-size", 2.8);
+  const width = estimateTextWidth(text, fontSize);
+  const anchor = node.getAttribute("text-anchor") ?? "start";
+  let minX;
+  if (anchor === "middle") minX = x - width / 2;
+  else if (anchor === "end") minX = x - width;
+  else minX = x;
+  const maxX = minX + width;
+  const baseline = node.getAttribute("dominant-baseline") ?? "alphabetic";
+  let minY;
+  let maxY;
+  if (baseline === "middle" || baseline === "central") {
+    minY = y - fontSize * 0.6;
+    maxY = y + fontSize * 0.6;
+  } else {
+    minY = y - fontSize * 0.8;
+    maxY = y + fontSize * 0.25;
+  }
+  return { minX, minY, maxX, maxY };
+}
+function collectBounds(node, acc) {
+  const b = primitiveBounds(node);
+  if (b) acc.push(b);
+  for (const child of node.children) collectBounds(child, acc);
+}
+function unionAll(bounds) {
+  if (bounds.length === 0) return null;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const b of bounds) {
+    if (b.minX < minX) minX = b.minX;
+    if (b.minY < minY) minY = b.minY;
+    if (b.maxX > maxX) maxX = b.maxX;
+    if (b.maxY > maxY) maxY = b.maxY;
+  }
+  return { minX, minY, maxX, maxY };
+}
+function fallbackViewBox(root) {
+  const nums = parseNumbers(root.getAttribute("viewBox") ?? "");
+  if (nums.length === 4 && nums[2] > 0 && nums[3] > 0) {
+    return { minX: nums[0], minY: nums[1], width: nums[2], height: nums[3] };
+  }
+  return { minX: 0, minY: 0, width: 210, height: 297 };
+}
+function computeContentBox(root, bleed = DEFAULT_BLEED) {
+  const all = [];
+  collectBounds(root, all);
+  const merged = unionAll(all);
+  if (!merged) return fallbackViewBox(root);
+  const pad = Math.max(0, bleed);
+  return {
+    minX: merged.minX - pad,
+    minY: merged.minY - pad,
+    width: Math.max(1, merged.maxX - merged.minX + pad * 2),
+    height: Math.max(1, merged.maxY - merged.minY + pad * 2)
+  };
+}
+function svgDisplayDimensions(viewBox, targetSide = 1600) {
+  const longest = Math.max(viewBox.width, viewBox.height, 1);
+  const scale = Math.max(1, targetSide / longest);
+  return {
+    width: Math.max(1, Math.ceil(viewBox.width * scale)),
+    height: Math.max(1, Math.ceil(viewBox.height * scale)),
+    scale
+  };
+}
+var RASTER_SCALE = 8;
+var RASTER_MAX_SIDE = 24e3;
+var RASTER_MAX_PIXELS = 1e8;
+function rasterDimensions(viewBox, scale = RASTER_SCALE) {
+  const requested = Number.isFinite(scale) && scale > 0 ? scale : RASTER_SCALE;
+  const sideScale = RASTER_MAX_SIDE / Math.max(viewBox.width, viewBox.height, 1);
+  const pixelScale = Math.sqrt(RASTER_MAX_PIXELS / Math.max(viewBox.width * viewBox.height, 1));
+  const capped = Math.min(requested, sideScale, pixelScale);
+  return {
+    width: Math.max(1, Math.ceil(viewBox.width * capped)),
+    height: Math.max(1, Math.ceil(viewBox.height * capped)),
+    scale: capped
+  };
+}
+
+// src/node/svg.ts
+var SVG_NS2 = "http://www.w3.org/2000/svg";
+var DEFAULT_BLEED2 = 3;
+var DEFAULT_TARGET_SIDE = 1600;
+function buildSvgModel(source, opts = {}) {
+  const {
+    lang = "ja",
+    crop = true,
+    bleed = DEFAULT_BLEED2,
+    targetSide = DEFAULT_TARGET_SIDE
+  } = opts;
+  const doc = parse(source);
+  const laid = layout(doc);
+  const svgEl = withShimDocument(() => render(laid, { lang }));
+  const viewBox = crop ? computeContentBox(svgEl, bleed) : { minX: 0, minY: 0, width: laid.width, height: laid.height };
+  const display = svgDisplayDimensions(viewBox, targetSide);
+  svgEl.setAttribute("xmlns", SVG_NS2);
+  svgEl.setAttribute("version", "1.1");
+  svgEl.setAttribute(
+    "viewBox",
+    `${viewBox.minX} ${viewBox.minY} ${viewBox.width} ${viewBox.height}`
+  );
+  svgEl.setAttribute("width", String(display.width));
+  svgEl.setAttribute("height", String(display.height));
+  svgEl.setAttribute("preserveAspectRatio", "xMidYMid meet");
+  return { el: svgEl, kind: doc.kind, viewBox, width: display.width, height: display.height };
+}
+function renderToSvg(source, opts = {}) {
+  const model = buildSvgModel(source, opts);
+  const body = serializeSvg(model.el);
+  const svg = opts.xmlDeclaration ?? true ? `<?xml version="1.0" encoding="UTF-8"?>
+${body}` : body;
+  return {
+    svg,
+    kind: model.kind,
+    viewBox: model.viewBox,
+    width: model.width,
+    height: model.height
+  };
+}
+
+// src/node/assets.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var FONT_FAMILY_NAME = "IPAexGothic";
+var cachedPath = null;
+var cachedBuffer = null;
+function moduleDir() {
+  let url = "";
+  try {
+    url = import.meta.url;
+  } catch {
+  }
+  if (url) {
+    try {
+      return dirname(fileURLToPath(url));
+    } catch {
+    }
+  }
+  if (typeof __dirname !== "undefined") return __dirname;
+  return process.cwd();
+}
+function resolvePackageFile(...segments) {
+  let dir = moduleDir();
+  for (let i = 0; i < 8; i++) {
+    const candidate = join(dir, ...segments);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    `pdgkit: bundled file ${segments.join("/")} not found. Ensure the package was installed with its data files intact.`
+  );
+}
+function resolveFontPath() {
+  if (cachedPath) return cachedPath;
+  cachedPath = resolvePackageFile("assets", "ipaexg.ttf");
+  return cachedPath;
+}
+function loadFontBuffer() {
+  if (cachedBuffer) return cachedBuffer;
+  cachedBuffer = readFileSync(resolveFontPath());
+  return cachedBuffer;
+}
+function loadFontBase64() {
+  return loadFontBuffer().toString("base64");
+}
+
+// src/node/validate.ts
+var KIND_LABEL_JA = {
+  block: "\u30D6\u30ED\u30C3\u30AF\u56F3",
+  flow: "\u30D5\u30ED\u30FC\u30C1\u30E3\u30FC\u30C8",
+  state: "\u72B6\u614B\u9077\u79FB\u56F3",
+  seq: "\u30B7\u30FC\u30B1\u30F3\u30B9\u56F3"
+};
+function commentOf(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(i + 1);
+  }
+  return null;
+}
+function uncommented(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;
+}
+var KIND_DIRECTIVE_RE = /^\s*!?\s*(?:pdgkit\s*:)?\s*kind\s*[:=]?\s*(block|flow|state|seq)\b/i;
+function findKindDirective(lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const comment = commentOf(lines[i]);
+    if (comment == null) continue;
+    const m = comment.match(KIND_DIRECTIVE_RE);
+    if (m) return { kind: m[1].toLowerCase(), line: i + 1 };
+  }
+  return null;
+}
+var SPACED_OP_RE = /(?:^|\s)(?:<->|=>|->|<-|\.>|\.\.|-)(?:\s|$)/g;
+var GLUED_OP_RE = /[A-Za-z0-9_*](?:<->|<-|->|=>|\.>|\.\.|-)[A-Za-z0-9_*]/;
+function countSpacedOps(text) {
+  const matches = text.match(SPACED_OP_RE);
+  return matches ? matches.length : 0;
+}
+function validate(source) {
+  const doc = parse(source);
+  const diagnostics = [...doc.diagnostics];
+  const lines = source.split(/\r?\n/);
+  const directive = findKindDirective(lines);
+  const declaredKind = directive ? directive.kind : null;
+  let kindMatches = null;
+  if (directive) {
+    kindMatches = directive.kind === doc.kind;
+    if (!kindMatches) {
+      diagnostics.push({
+        severity: "error",
+        line: directive.line,
+        col: 1,
+        message: `\u56F3\u7A2E\u30A2\u30B5\u30FC\u30B7\u30E7\u30F3\u4E0D\u4E00\u81F4: \u5BA3\u8A00=${KIND_LABEL_JA[directive.kind]}(${directive.kind}) \u3060\u304C\u63A8\u8AD6=${KIND_LABEL_JA[doc.kind]}(${doc.kind})\u3002\u69CB\u9020(\u5305\u542B\u300C:\u300D/ \u672B\u5C3E\u300C?\u300D/ \u7B26\u53F7\u300C*\u300D/ \u5F80\u5FA9\u30FB\u300C<->\u300D)\u3092\u898B\u76F4\u3059\u304B\u3001\u5BA3\u8A00\u3092\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+      });
+    }
+  }
+  const unknownLines = new Set(
+    doc.diagnostics.filter((d) => d.severity === "error" && d.message.startsWith("\u69CB\u6587\u4E0D\u660E")).map((d) => d.line)
+  );
+  for (const lineNum of unknownLines) {
+    const code = uncommented(lines[lineNum - 1] ?? "").trim();
+    if (!code) continue;
+    if (countSpacedOps(code) >= 2) {
+      diagnostics.push({
+        severity: "info",
+        line: lineNum,
+        col: 1,
+        message: "\u9023\u9396\u8A18\u6CD5(A -> B -> C)\u306F\u672A\u5BFE\u5FDC\u3067\u3059\u30021\u884C\u306B1\u63A5\u7D9A\u3067\u5206\u5272\u3057\u3066\u304F\u3060\u3055\u3044(\u4F8B: A -> B / B -> C)\u3002"
+      });
+    } else if (GLUED_OP_RE.test(code)) {
+      diagnostics.push({
+        severity: "info",
+        line: lineNum,
+        col: 1,
+        message: '\u63A5\u7D9A\u6F14\u7B97\u5B50\u306E\u524D\u5F8C\u306B\u306F\u534A\u89D2\u30B9\u30DA\u30FC\u30B9\u304C\u5FC5\u8981\u3067\u3059(\u4F8B: "11-12" \u3067\u306F\u306A\u304F "11 - 12")\u3002'
+      });
+    }
+  }
+  diagnostics.sort((a, b) => a.line - b.line || a.col - b.col);
+  const counts = {
+    errors: diagnostics.filter((d) => d.severity === "error").length,
+    warnings: diagnostics.filter((d) => d.severity === "warning").length,
+    infos: diagnostics.filter((d) => d.severity === "info").length
+  };
+  return {
+    ok: counts.errors === 0,
+    kind: doc.kind,
+    declaredKind,
+    kindMatches,
+    diagnostics,
+    counts
+  };
+}
+
+// src/node/raster.ts
+var JPEG_QUALITY = 100;
+async function renderPixels(source, opts) {
+  const { lang = "ja", scale = 8, bleed = 3 } = opts;
+  const { svg, viewBox } = renderToSvg(source, { lang, crop: true, bleed });
+  const dims = rasterDimensions(viewBox, scale);
+  const { Resvg } = await import("@resvg/resvg-js");
+  const resvg = new Resvg(svg, {
+    background: "rgba(255,255,255,1)",
+    fitTo: { mode: "width", value: dims.width },
+    font: {
+      fontFiles: [resolveFontPath()],
+      loadSystemFonts: false,
+      defaultFontFamily: FONT_FAMILY_NAME
+    }
+  });
+  const rendered = resvg.render();
+  const raw = {
+    pixels: rendered.pixels,
+    width: rendered.width,
+    height: rendered.height
+  };
+  return { raw, png: rendered.asPng() };
+}
+async function renderToPng(source, opts = {}) {
+  const { png } = await renderPixels(source, opts);
+  return png;
+}
+async function renderToJpeg(source, opts = {}) {
+  const { raw } = await renderPixels(source, opts);
+  const jpeg = (await import("jpeg-js")).default;
+  const encoded = jpeg.encode(
+    { data: Buffer.from(raw.pixels), width: raw.width, height: raw.height },
+    JPEG_QUALITY
+  );
+  return encoded.data;
+}
+
+// src/node/ooxml.ts
+var PPTX_SLIDE_W = 12192e3;
+var PPTX_SLIDE_H = 6858e3;
+var PPTX_MARGIN = 457200;
+function fitRectIntoPage(sourceW, sourceH, pageW, pageH, margin = 10) {
+  const usableW = Math.max(1, pageW - margin * 2);
+  const usableH = Math.max(1, pageH - margin * 2);
+  const scale = Math.min(usableW / sourceW, usableH / sourceH);
+  const width = sourceW * scale;
+  const height = sourceH * scale;
+  return { x: (pageW - width) / 2, y: (pageH - height) / 2, width, height };
+}
+function fitRectIntoSlide(sourceW, sourceH, slideW = PPTX_SLIDE_W, slideH = PPTX_SLIDE_H, margin = PPTX_MARGIN) {
+  return fitRectIntoPage(sourceW, sourceH, slideW, slideH, margin);
+}
+function buildPptxPackage(imagePng, imageW, imageH) {
+  const fit = fitRectIntoSlide(imageW, imageH);
+  const iso = (/* @__PURE__ */ new Date()).toISOString();
+  return createStoredZip([
+    ["[Content_Types].xml", contentTypesXml()],
+    ["_rels/.rels", rootRelsXml()],
+    ["docProps/app.xml", appPropsXml()],
+    ["docProps/core.xml", corePropsXml(iso)],
+    ["ppt/presentation.xml", presentationXml()],
+    ["ppt/_rels/presentation.xml.rels", presentationRelsXml()],
+    ["ppt/slides/slide1.xml", slideXml(fit)],
+    ["ppt/slides/_rels/slide1.xml.rels", slideRelsXml()],
+    ["ppt/slideMasters/slideMaster1.xml", slideMasterXml()],
+    ["ppt/slideMasters/_rels/slideMaster1.xml.rels", slideMasterRelsXml()],
+    ["ppt/slideLayouts/slideLayout1.xml", slideLayoutXml()],
+    ["ppt/slideLayouts/_rels/slideLayout1.xml.rels", slideLayoutRelsXml()],
+    ["ppt/theme/theme1.xml", themeXml()],
+    ["ppt/media/image1.png", imagePng]
+  ]);
+}
+function buildEditablePptxPackage(svgEl) {
+  const viewBox = computeContentBox(svgEl);
+  const fit = fitRectIntoSlide(viewBox.width, viewBox.height);
+  const shapes = editablePptxShapes(svgEl, viewBox, fit);
+  const iso = (/* @__PURE__ */ new Date()).toISOString();
+  return createStoredZip([
+    ["[Content_Types].xml", contentTypesXmlEditable()],
+    ["_rels/.rels", rootRelsXml()],
+    ["docProps/app.xml", appPropsXml()],
+    ["docProps/core.xml", corePropsXml(iso)],
+    ["ppt/presentation.xml", presentationXml()],
+    ["ppt/_rels/presentation.xml.rels", presentationRelsXml()],
+    ["ppt/slides/slide1.xml", editableSlideXml(shapes)],
+    ["ppt/slides/_rels/slide1.xml.rels", editableSlideRelsXml()],
+    ["ppt/slideMasters/slideMaster1.xml", slideMasterXml()],
+    ["ppt/slideMasters/_rels/slideMaster1.xml.rels", slideMasterRelsXml()],
+    ["ppt/slideLayouts/slideLayout1.xml", slideLayoutXml()],
+    ["ppt/slideLayouts/_rels/slideLayout1.xml.rels", slideLayoutRelsXml()],
+    ["ppt/theme/theme1.xml", themeXml()]
+  ]);
+}
+function collectElements(root, tags) {
+  const out = [];
+  const walk = (node) => {
+    if (tags.has(node.tagName.toLowerCase())) out.push(node);
+    for (const child of node.children) walk(child);
+  };
+  walk(root);
+  return out;
+}
+function editablePptxShapes(svgEl, viewBox, fit) {
+  const ctx = {
+    nextId: 2,
+    tx: {
+      minX: viewBox.minX,
+      minY: viewBox.minY,
+      scaleX: fit.width / viewBox.width,
+      scaleY: fit.height / viewBox.height,
+      fitX: fit.x,
+      fitY: fit.y
+    }
+  };
+  const out = [];
+  const elements = collectElements(svgEl, /* @__PURE__ */ new Set(["rect", "circle", "polygon", "path", "text", "line", "polyline"]));
+  for (const el2 of elements) {
+    const tag = el2.tagName.toLowerCase();
+    if (tag === "rect") out.push(...pptxRect(el2, ctx));
+    else if (tag === "circle") out.push(...pptxCircle(el2, ctx));
+    else if (tag === "polygon") out.push(...pptxPolygon(el2, ctx));
+    else if (tag === "path") out.push(...pptxPath(el2, ctx));
+    else if (tag === "line") out.push(...pptxLine(el2, ctx));
+    else if (tag === "polyline") out.push(...pptxPolyline(el2, ctx));
+    else if (tag === "text") out.push(...pptxText(el2, ctx));
+  }
+  return out.filter(Boolean).join("\n");
+}
+function pptxRect(el2, ctx) {
+  const x = numAttr(el2, "x");
+  const y = numAttr(el2, "y");
+  const w = numAttr(el2, "width");
+  const h = numAttr(el2, "height");
+  if (w <= 0 || h <= 0) return [];
+  const p = mapBox(ctx.tx, x, y, w, h);
+  const rx = Math.max(numAttr(el2, "rx"), numAttr(el2, "ry"));
+  return [shapeXml(
+    ctx.nextId++,
+    "rect",
+    p.x,
+    p.y,
+    p.w,
+    p.h,
+    rx > 0 ? "roundRect" : "rect",
+    fillXml(colorAttr(el2, "fill", "none")),
+    lineXml(lineStyleFromElement(el2, ctx.tx))
+  )];
+}
+function pptxCircle(el2, ctx) {
+  const cx = numAttr(el2, "cx");
+  const cy = numAttr(el2, "cy");
+  const r = numAttr(el2, "r");
+  if (r <= 0) return [];
+  const p = mapBox(ctx.tx, cx - r, cy - r, r * 2, r * 2);
+  return [shapeXml(
+    ctx.nextId++,
+    "circle",
+    p.x,
+    p.y,
+    p.w,
+    p.h,
+    "ellipse",
+    fillXml(colorAttr(el2, "fill", "#000")),
+    lineXml(lineStyleFromElement(el2, ctx.tx))
+  )];
+}
+function pptxPolygon(el2, ctx) {
+  const points = parsePoints(el2.getAttribute("points"));
+  if (points.length < 3) return [];
+  return [freeformXml(
+    ctx.nextId++,
+    "polygon",
+    points.map((point) => mapPoint(ctx.tx, point[0], point[1])),
+    fillXml(colorAttr(el2, "fill", "none")),
+    lineXml(lineStyleFromElement(el2, ctx.tx))
+  )];
+}
+function pptxPath(el2, ctx) {
+  const points = parsePathPoints(el2.getAttribute("d"));
+  if (points.length < 2) return [];
+  const line = lineStyleFromElement(el2, ctx.tx);
+  const out = [];
+  for (let i = 0; i < points.length - 1; i++) {
+    const a = mapPoint(ctx.tx, points[i][0], points[i][1]);
+    const b = mapPoint(ctx.tx, points[i + 1][0], points[i + 1][1]);
+    out.push(connectorXml(ctx.nextId++, "line", a.x, a.y, b.x, b.y, line));
+  }
+  return out;
+}
+function pptxLine(el2, ctx) {
+  const a = mapPoint(ctx.tx, numAttr(el2, "x1"), numAttr(el2, "y1"));
+  const b = mapPoint(ctx.tx, numAttr(el2, "x2"), numAttr(el2, "y2"));
+  return [connectorXml(ctx.nextId++, "line", a.x, a.y, b.x, b.y, lineStyleFromElement(el2, ctx.tx))];
+}
+function pptxPolyline(el2, ctx) {
+  const points = parsePoints(el2.getAttribute("points"));
+  if (points.length < 2) return [];
+  const line = lineStyleFromElement(el2, ctx.tx);
+  const out = [];
+  for (let i = 0; i < points.length - 1; i++) {
+    const a = mapPoint(ctx.tx, points[i][0], points[i][1]);
+    const b = mapPoint(ctx.tx, points[i + 1][0], points[i + 1][1]);
+    out.push(connectorXml(ctx.nextId++, "line", a.x, a.y, b.x, b.y, line));
+  }
+  return out;
+}
+function pptxText(el2, ctx) {
+  const text = (el2.textContent ?? "").trim();
+  if (!text) return [];
+  const x = numAttr(el2, "x");
+  const y = numAttr(el2, "y");
+  const fontSize = numAttr(el2, "font-size", 2.8);
+  const widthSvg = estimateSvgTextWidth(text, fontSize);
+  const heightSvg = fontSize * 1.35;
+  const anchor = el2.getAttribute("text-anchor") ?? "start";
+  const baseline = el2.getAttribute("dominant-baseline") ?? "alphabetic";
+  let left = x;
+  if (anchor === "middle") left -= widthSvg / 2;
+  else if (anchor === "end") left -= widthSvg;
+  let top = y - fontSize * 0.95;
+  if (baseline === "middle" || baseline === "central") top = y - heightSvg / 2;
+  const p = mapBox(ctx.tx, left, top, widthSvg, heightSvg);
+  const fontPt = Math.max(1, Math.round(fontSize * ctx.tx.scaleY / 12700 * 100) / 100);
+  const align = anchor === "middle" ? "ctr" : anchor === "end" ? "r" : "l";
+  return [textBoxXml(ctx.nextId++, p.x, p.y, p.w, p.h, text, fontPt, align, colorAttr(el2, "fill", "#000"))];
+}
+function mapPoint(tx, x, y) {
+  return {
+    x: Math.round(tx.fitX + (x - tx.minX) * tx.scaleX),
+    y: Math.round(tx.fitY + (y - tx.minY) * tx.scaleY)
+  };
+}
+function mapBox(tx, x, y, w, h) {
+  const a = mapPoint(tx, x, y);
+  return { x: a.x, y: a.y, w: Math.max(1, Math.round(w * tx.scaleX)), h: Math.max(1, Math.round(h * tx.scaleY)) };
+}
+function numAttr(el2, name, fallback = 0) {
+  const n = Number.parseFloat(el2.getAttribute(name) ?? "");
+  return Number.isFinite(n) ? n : fallback;
+}
+function colorAttr(el2, name, fallback) {
+  const value = (el2.getAttribute(name) ?? fallback).trim();
+  if (!value || value === "none" || value === "transparent") return "none";
+  if (value.startsWith("#")) {
+    const hex = value.slice(1);
+    if (/^[0-9a-f]{3}$/i.test(hex)) return hex.split("").map((c) => c + c).join("").toUpperCase();
+    if (/^[0-9a-f]{6}$/i.test(hex)) return hex.toUpperCase();
+  }
+  if (value.toLowerCase() === "white") return "FFFFFF";
+  if (value.toLowerCase() === "black") return "000000";
+  return fallback === "none" ? "none" : "000000";
+}
+function lineStyleFromElement(el2, tx) {
+  const stroke = colorAttr(el2, "stroke", "none");
+  if (stroke === "none") return null;
+  const svgWidth = numAttr(el2, "stroke-width", 0.4);
+  const width = Math.max(1270, Math.round(svgWidth * (tx.scaleX + tx.scaleY) / 2));
+  return { color: stroke, width, dash: !!el2.getAttribute("stroke-dasharray") };
+}
+function parsePoints(raw) {
+  if (!raw) return [];
+  const nums = raw.trim().split(/[\s,]+/).map(Number).filter(Number.isFinite);
+  const out = [];
+  for (let i = 0; i + 1 < nums.length; i += 2) out.push([nums[i], nums[i + 1]]);
+  return out;
+}
+function parsePathPoints(raw) {
+  if (!raw) return [];
+  const nums = raw.replace(/[MLZ]/gi, " ").trim().split(/[\s,]+/).map(Number).filter(Number.isFinite);
+  const out = [];
+  for (let i = 0; i + 1 < nums.length; i += 2) out.push([nums[i], nums[i + 1]]);
+  return out;
+}
+function estimateSvgTextWidth(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.2, width + fontSize * 0.8);
+}
+function shapeXml(id, name, x, y, w, h, preset, fill, line) {
+  return `<p:sp>
+<p:nvSpPr><p:cNvPr id="${id}" name="${xmlAttr(name)}"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr>
+<p:spPr><a:xfrm><a:off x="${x}" y="${y}"/><a:ext cx="${w}" cy="${h}"/></a:xfrm><a:prstGeom prst="${preset}"><a:avLst/></a:prstGeom>${fill}${line}</p:spPr>
+</p:sp>`;
+}
+function connectorXml(id, name, x1, y1, x2, y2, line) {
+  const x = Math.min(x1, x2);
+  const y = Math.min(y1, y2);
+  const w = Math.max(1, Math.abs(x2 - x1));
+  const h = Math.max(1, Math.abs(y2 - y1));
+  const flipH = x2 < x1 ? ' flipH="1"' : "";
+  const flipV = y2 < y1 ? ' flipV="1"' : "";
+  return `<p:cxnSp>
+<p:nvCxnSpPr><p:cNvPr id="${id}" name="${xmlAttr(name)}"/><p:cNvCxnSpPr/><p:nvPr/></p:nvCxnSpPr>
+<p:spPr><a:xfrm${flipH}${flipV}><a:off x="${x}" y="${y}"/><a:ext cx="${w}" cy="${h}"/></a:xfrm><a:prstGeom prst="line"><a:avLst/></a:prstGeom>${lineXml(line)}</p:spPr>
+</p:cxnSp>`;
+}
+function freeformXml(id, name, points, fill, line) {
+  const left = Math.min(...points.map((p) => p.x));
+  const top = Math.min(...points.map((p) => p.y));
+  const right = Math.max(...points.map((p) => p.x));
+  const bottom = Math.max(...points.map((p) => p.y));
+  const w = Math.max(1, right - left);
+  const h = Math.max(1, bottom - top);
+  const local = points.map((p) => ({ x: p.x - left, y: p.y - top }));
+  const first = local[0];
+  const rest = local.slice(1).map((p) => `<a:lnTo><a:pt x="${p.x}" y="${p.y}"/></a:lnTo>`).join("");
+  return `<p:sp>
+<p:nvSpPr><p:cNvPr id="${id}" name="${xmlAttr(name)}"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr>
+<p:spPr><a:xfrm><a:off x="${left}" y="${top}"/><a:ext cx="${w}" cy="${h}"/></a:xfrm><a:custGeom><a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/><a:rect l="l" t="t" r="r" b="b"/><a:pathLst><a:path w="${w}" h="${h}"><a:moveTo><a:pt x="${first.x}" y="${first.y}"/></a:moveTo>${rest}<a:close/></a:path></a:pathLst></a:custGeom>${fill}${line}</p:spPr>
+</p:sp>`;
+}
+function textBoxXml(id, x, y, w, h, text, fontPt, align, color) {
+  const sz = Math.max(100, Math.round(fontPt * 100));
+  return `<p:sp>
+<p:nvSpPr><p:cNvPr id="${id}" name="text"/><p:cNvSpPr txBox="1"/><p:nvPr/></p:nvSpPr>
+<p:spPr><a:xfrm><a:off x="${x}" y="${y}"/><a:ext cx="${w}" cy="${h}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:noFill/><a:ln><a:noFill/></a:ln></p:spPr>
+<p:txBody><a:bodyPr wrap="none" anchor="ctr" lIns="0" tIns="0" rIns="0" bIns="0"><a:spAutoFit/></a:bodyPr><a:lstStyle/><a:p><a:pPr algn="${align}"/><a:r><a:rPr lang="ja-JP" sz="${sz}" dirty="0">${fillXml(color)}</a:rPr><a:t>${xmlText(text)}</a:t></a:r></a:p></p:txBody>
+</p:sp>`;
+}
+function fillXml(color) {
+  return color === "none" ? "<a:noFill/>" : `<a:solidFill><a:srgbClr val="${xmlAttr(color)}"/></a:solidFill>`;
+}
+function lineXml(line) {
+  if (!line) return "<a:ln><a:noFill/></a:ln>";
+  const dash = line.dash ? '<a:prstDash val="dash"/>' : '<a:prstDash val="solid"/>';
+  return `<a:ln w="${line.width}" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:srgbClr val="${xmlAttr(line.color)}"/></a:solidFill>${dash}</a:ln>`;
+}
+function xmlText(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function xmlAttr(text) {
+  return xmlText(text).replace(/"/g, "&quot;");
+}
+function createStoredZip(entries) {
+  const encoder = new TextEncoder();
+  const files = entries.map(([name, data]) => {
+    const bytes = typeof data === "string" ? encoder.encode(data) : data;
+    return { name, nameBytes: encoder.encode(name), bytes, crc: crc32(bytes) };
+  });
+  const chunks = [];
+  const central = [];
+  let offset = 0;
+  for (const file of files) {
+    const local = zipLocalHeader(file.nameBytes, file.bytes, file.crc);
+    chunks.push(local, file.nameBytes, file.bytes);
+    central.push(zipCentralHeader(file.nameBytes, file.bytes, file.crc, offset), file.nameBytes);
+    offset += local.length + file.nameBytes.length + file.bytes.length;
+  }
+  const centralOffset = offset;
+  const centralSize = central.reduce((sum, chunk) => sum + chunk.length, 0);
+  return concatBytes([...chunks, ...central, zipEndRecord(files.length, centralSize, centralOffset)]);
+}
+function zipLocalHeader(name, data, crc) {
+  const out = new Uint8Array(30);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, 67324752, true);
+  view.setUint16(4, 20, true);
+  view.setUint16(6, 0, true);
+  view.setUint16(8, 0, true);
+  view.setUint16(10, 0, true);
+  view.setUint16(12, 0, true);
+  view.setUint32(14, crc, true);
+  view.setUint32(18, data.length, true);
+  view.setUint32(22, data.length, true);
+  view.setUint16(26, name.length, true);
+  view.setUint16(28, 0, true);
+  return out;
+}
+function zipCentralHeader(name, data, crc, offset) {
+  const out = new Uint8Array(46);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, 33639248, true);
+  view.setUint16(4, 20, true);
+  view.setUint16(6, 20, true);
+  view.setUint16(8, 0, true);
+  view.setUint16(10, 0, true);
+  view.setUint16(12, 0, true);
+  view.setUint16(14, 0, true);
+  view.setUint32(16, crc, true);
+  view.setUint32(20, data.length, true);
+  view.setUint32(24, data.length, true);
+  view.setUint16(28, name.length, true);
+  view.setUint16(30, 0, true);
+  view.setUint16(32, 0, true);
+  view.setUint16(34, 0, true);
+  view.setUint16(36, 0, true);
+  view.setUint32(38, 0, true);
+  view.setUint32(42, offset, true);
+  return out;
+}
+function zipEndRecord(entries, centralSize, centralOffset) {
+  const out = new Uint8Array(22);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, 101010256, true);
+  view.setUint16(4, 0, true);
+  view.setUint16(6, 0, true);
+  view.setUint16(8, entries, true);
+  view.setUint16(10, entries, true);
+  view.setUint32(12, centralSize, true);
+  view.setUint32(16, centralOffset, true);
+  view.setUint16(20, 0, true);
+  return out;
+}
+function concatBytes(chunks) {
+  const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let i = 0; i < 8; i++) {
+      crc = crc >>> 1 ^ 3988292384 & -(crc & 1);
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function contentTypesXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+<Default Extension="xml" ContentType="application/xml"/>
+<Default Extension="png" ContentType="image/png"/>
+<Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
+<Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
+<Override PartName="/ppt/presentation.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml"/>
+<Override PartName="/ppt/slides/slide1.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.slide+xml"/>
+<Override PartName="/ppt/slideMasters/slideMaster1.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml"/>
+<Override PartName="/ppt/slideLayouts/slideLayout1.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml"/>
+<Override PartName="/ppt/theme/theme1.xml" ContentType="application/vnd.openxmlformats-officedocument.theme+xml"/>
+</Types>`;
+}
+function contentTypesXmlEditable() {
+  return contentTypesXml().replace('<Default Extension="png" ContentType="image/png"/>\n', "");
+}
+function rootRelsXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="ppt/presentation.xml"/>
+<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
+<Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
+</Relationships>`;
+}
+function appPropsXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">
+<Application>pdgkit</Application>
+<PresentationFormat>Widescreen</PresentationFormat>
+<Slides>1</Slides>
+<Notes>0</Notes>
+<HiddenSlides>0</HiddenSlides>
+</Properties>`;
+}
+function corePropsXml(iso) {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+<dc:title>pdgkit figure</dc:title>
+<dc:creator>pdgkit</dc:creator>
+<cp:lastModifiedBy>pdgkit</cp:lastModifiedBy>
+<dcterms:created xsi:type="dcterms:W3CDTF">${iso}</dcterms:created>
+<dcterms:modified xsi:type="dcterms:W3CDTF">${iso}</dcterms:modified>
+</cp:coreProperties>`;
+}
+function presentationXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:presentation xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+<p:sldMasterIdLst><p:sldMasterId id="2147483648" r:id="rId1"/></p:sldMasterIdLst>
+<p:sldIdLst><p:sldId id="256" r:id="rId2"/></p:sldIdLst>
+<p:sldSz cx="${PPTX_SLIDE_W}" cy="${PPTX_SLIDE_H}" type="screen16x9"/>
+<p:notesSz cx="6858000" cy="9144000"/>
+<p:defaultTextStyle/>
+</p:presentation>`;
+}
+function presentationRelsXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster" Target="slideMasters/slideMaster1.xml"/>
+<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" Target="slides/slide1.xml"/>
+</Relationships>`;
+}
+function slideXml(fit) {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+<p:cSld name="pdgkit">
+<p:bg><p:bgPr><a:solidFill><a:srgbClr val="FFFFFF"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>
+<p:spTree>
+<p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr>
+<p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${PPTX_SLIDE_W}" cy="${PPTX_SLIDE_H}"/><a:chOff x="0" y="0"/><a:chExt cx="${PPTX_SLIDE_W}" cy="${PPTX_SLIDE_H}"/></a:xfrm></p:grpSpPr>
+<p:pic>
+<p:nvPicPr><p:cNvPr id="2" name="figure.png"/><p:cNvPicPr><a:picLocks noChangeAspect="1"/></p:cNvPicPr><p:nvPr/></p:nvPicPr>
+<p:blipFill><a:blip r:embed="rId1"/><a:stretch><a:fillRect/></a:stretch></p:blipFill>
+<p:spPr><a:xfrm><a:off x="${Math.round(fit.x)}" y="${Math.round(fit.y)}"/><a:ext cx="${Math.round(fit.width)}" cy="${Math.round(fit.height)}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr>
+</p:pic>
+</p:spTree>
+</p:cSld>
+<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>
+</p:sld>`;
+}
+function slideRelsXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/image1.png"/>
+<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout" Target="../slideLayouts/slideLayout1.xml"/>
+</Relationships>`;
+}
+function editableSlideXml(shapes) {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+<p:cSld name="pdgkit">
+<p:bg><p:bgPr><a:solidFill><a:srgbClr val="FFFFFF"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>
+<p:spTree>
+<p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr>
+<p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${PPTX_SLIDE_W}" cy="${PPTX_SLIDE_H}"/><a:chOff x="0" y="0"/><a:chExt cx="${PPTX_SLIDE_W}" cy="${PPTX_SLIDE_H}"/></a:xfrm></p:grpSpPr>
+${shapes}
+</p:spTree>
+</p:cSld>
+<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>
+</p:sld>`;
+}
+function editableSlideRelsXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout" Target="../slideLayouts/slideLayout1.xml"/>
+</Relationships>`;
+}
+function slideMasterXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:sldMaster xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+<p:cSld><p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${PPTX_SLIDE_W}" cy="${PPTX_SLIDE_H}"/><a:chOff x="0" y="0"/><a:chExt cx="${PPTX_SLIDE_W}" cy="${PPTX_SLIDE_H}"/></a:xfrm></p:grpSpPr></p:spTree></p:cSld>
+<p:clrMap bg1="lt1" tx1="dk1" bg2="lt2" tx2="dk2" accent1="accent1" accent2="accent2" accent3="accent3" accent4="accent4" accent5="accent5" accent6="accent6" hlink="hlink" folHlink="folHlink"/>
+<p:sldLayoutIdLst><p:sldLayoutId id="2147483649" r:id="rId1"/></p:sldLayoutIdLst>
+<p:txStyles><p:titleStyle/><p:bodyStyle/><p:otherStyle/></p:txStyles>
+</p:sldMaster>`;
+}
+function slideMasterRelsXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout" Target="../slideLayouts/slideLayout1.xml"/>
+<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" Target="../theme/theme1.xml"/>
+</Relationships>`;
+}
+function slideLayoutXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:sldLayout xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main" type="blank" preserve="1">
+<p:cSld name="Blank"><p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${PPTX_SLIDE_W}" cy="${PPTX_SLIDE_H}"/><a:chOff x="0" y="0"/><a:chExt cx="${PPTX_SLIDE_W}" cy="${PPTX_SLIDE_H}"/></a:xfrm></p:grpSpPr></p:spTree></p:cSld>
+<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>
+</p:sldLayout>`;
+}
+function slideLayoutRelsXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster" Target="../slideMasters/slideMaster1.xml"/>
+</Relationships>`;
+}
+function themeXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="pdgkit">
+<a:themeElements>
+<a:clrScheme name="pdgkit"><a:dk1><a:srgbClr val="000000"/></a:dk1><a:lt1><a:srgbClr val="FFFFFF"/></a:lt1><a:dk2><a:srgbClr val="000000"/></a:dk2><a:lt2><a:srgbClr val="FFFFFF"/></a:lt2><a:accent1><a:srgbClr val="0B5FFF"/></a:accent1><a:accent2><a:srgbClr val="666666"/></a:accent2><a:accent3><a:srgbClr val="999999"/></a:accent3><a:accent4><a:srgbClr val="CCCCCC"/></a:accent4><a:accent5><a:srgbClr val="333333"/></a:accent5><a:accent6><a:srgbClr val="111111"/></a:accent6><a:hlink><a:srgbClr val="0B5FFF"/></a:hlink><a:folHlink><a:srgbClr val="0B5FFF"/></a:folHlink></a:clrScheme>
+<a:fontScheme name="pdgkit"><a:majorFont><a:latin typeface="Arial"/><a:ea typeface="Yu Gothic"/><a:cs typeface="Arial"/></a:majorFont><a:minorFont><a:latin typeface="Arial"/><a:ea typeface="Yu Gothic"/><a:cs typeface="Arial"/></a:minorFont></a:fontScheme>
+<a:fmtScheme name="pdgkit"><a:fillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:fillStyleLst><a:lnStyleLst><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:prstDash val="solid"/></a:ln></a:lnStyleLst><a:effectStyleLst><a:effectStyle><a:effectLst/></a:effectStyle></a:effectStyleLst><a:bgFillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:bgFillStyleLst></a:fmtScheme>
+</a:themeElements>
+<a:objectDefaults/>
+<a:extraClrSchemeLst/>
+</a:theme>`;
+}
+
+// src/node/pdf.ts
+async function renderToPdf(source, opts = {}) {
+  const { lang = "ja", bleed = 3, vector = true, scale = 8 } = opts;
+  const { svg, viewBox } = renderToSvg(source, { lang, crop: true, bleed });
+  if (vector) {
+    try {
+      return await renderVectorPdf(svg, viewBox);
+    } catch {
+    }
+  }
+  return await renderRasterPdf(source, viewBox, { lang, scale, bleed });
+}
+async function renderVectorPdf(svg, viewBox) {
+  const { JSDOM } = await import("jsdom");
+  const { jsPDF } = await import("jspdf");
+  const { svg2pdf } = await import("svg2pdf.js");
+  const dom = new JSDOM(svg, { contentType: "image/svg+xml" });
+  patchSvgGeometry(dom.window);
+  const svgEl = dom.window.document.documentElement;
+  svgEl.setAttribute("font-family", FONT_FAMILY_NAME);
+  for (const t of Array.from(dom.window.document.getElementsByTagName("text"))) {
+    t.setAttribute("font-family", FONT_FAMILY_NAME);
+  }
+  const orientation = viewBox.width > viewBox.height ? "l" : "p";
+  const pdf = new jsPDF({ unit: "mm", format: "a4", orientation });
+  try {
+    pdf.addFileToVFS(`${FONT_FAMILY_NAME}.ttf`, loadFontBase64());
+    pdf.addFont(`${FONT_FAMILY_NAME}.ttf`, FONT_FAMILY_NAME, "normal");
+  } catch {
+  }
+  const pageW = pdf.internal.pageSize.getWidth();
+  const pageH = pdf.internal.pageSize.getHeight();
+  const fit = fitRectIntoPage(viewBox.width, viewBox.height, pageW, pageH, 10);
+  await svg2pdf(svgEl, pdf, {
+    x: fit.x,
+    y: fit.y,
+    width: fit.width,
+    height: fit.height
+  });
+  return new Uint8Array(pdf.output("arraybuffer"));
+}
+async function renderRasterPdf(source, viewBox, opts) {
+  const { jsPDF } = await import("jspdf");
+  const png = await renderToPng(source, opts);
+  const orientation = viewBox.width > viewBox.height ? "l" : "p";
+  const pdf = new jsPDF({ unit: "mm", format: "a4", orientation });
+  const pageW = pdf.internal.pageSize.getWidth();
+  const pageH = pdf.internal.pageSize.getHeight();
+  const fit = fitRectIntoPage(viewBox.width, viewBox.height, pageW, pageH, 10);
+  const dataUrl = "data:image/png;base64," + Buffer.from(png).toString("base64");
+  pdf.addImage(dataUrl, "PNG", fit.x, fit.y, fit.width, fit.height);
+  return new Uint8Array(pdf.output("arraybuffer"));
+}
+function patchSvgGeometry(win) {
+  const proto = win.SVGElement?.prototype;
+  if (!proto) return;
+  const numOf = (el2, name, d = 0) => {
+    const v = Number.parseFloat(el2.getAttribute?.(name) ?? "");
+    return Number.isFinite(v) ? v : d;
+  };
+  proto.getBBox = function() {
+    const tag = (this.tagName ?? "").toLowerCase();
+    if (tag === "rect") {
+      return { x: numOf(this, "x"), y: numOf(this, "y"), width: numOf(this, "width"), height: numOf(this, "height") };
+    }
+    if (tag === "circle") {
+      const r = numOf(this, "r");
+      return { x: numOf(this, "cx") - r, y: numOf(this, "cy") - r, width: 2 * r, height: 2 * r };
+    }
+    if (tag === "text") {
+      const fs2 = numOf(this, "font-size", 2.8);
+      return { x: numOf(this, "x"), y: numOf(this, "y") - fs2, width: estimateTextWidth(this.textContent ?? "", fs2), height: fs2 * 1.2 };
+    }
+    return { x: 0, y: 0, width: 0, height: 0 };
+  };
+  proto.getComputedTextLength = function() {
+    const fs2 = numOf(this, "font-size", 2.8);
+    return estimateTextWidth(this.textContent ?? "", fs2);
+  };
+  for (const m of ["getCTM", "getScreenCTM"]) {
+    if (typeof proto[m] !== "function") {
+      proto[m] = function() {
+        return null;
+      };
+    }
+  }
+}
+
+// src/node/pptx.ts
+async function renderToPptx(source, opts = {}) {
+  const { lang = "ja", editable = false, scale = 8, bleed = 3 } = opts;
+  if (editable) {
+    const model = buildSvgModel(source, { lang, crop: true, bleed });
+    return buildEditablePptxPackage(model.el);
+  }
+  const { viewBox } = buildSvgModel(source, { lang, crop: true, bleed });
+  const dims = rasterDimensions(viewBox, scale);
+  const png = await renderToPng(source, { lang, scale, bleed });
+  return buildPptxPackage(png, dims.width, dims.height);
+}
+
+// src/node/index.ts
+var VERSION = "0.1.0";
+function loadAuthoringGuide() {
+  return readFileSync2(resolvePackageFile("docs", "ai-authoring-guide.md"), "utf8");
+}
+
+// bin/pdgkit.ts
+function parseArgs(args) {
+  const positionals = [];
+  const opts = /* @__PURE__ */ new Map();
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "-o" || a === "--out") {
+      opts.set("out", args[++i] ?? "");
+    } else if (a.startsWith("--no-")) {
+      opts.set(a.slice(5), "false");
+    } else if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        opts.set(a.slice(2, eq), a.slice(eq + 1));
+      } else {
+        const next = args[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          opts.set(a.slice(2), next);
+          i++;
+        } else {
+          opts.set(a.slice(2), true);
+        }
+      }
+    } else {
+      positionals.push(a);
+    }
+  }
+  return { positionals, opts };
+}
+function fail(message, code = 1) {
+  process.stderr.write(`pdgkit: ${message}
+`);
+  process.exit(code);
+}
+function readStdin() {
+  try {
+    return fs.readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+function resolveSource(positional, opts) {
+  const sample = opts.get("sample");
+  if (typeof sample === "string") {
+    if (!SAMPLE_ORDER.includes(sample)) {
+      fail(`unknown sample "${sample}". Run "pdgkit samples" to list them.`, 2);
+    }
+    return SAMPLES[sample].source;
+  }
+  if (positional && positional !== "-") {
+    try {
+      return fs.readFileSync(positional, "utf8");
+    } catch {
+      fail(`cannot read file: ${positional}`, 2);
+    }
+  }
+  return readStdin();
+}
+function getLang(opts) {
+  const lang = opts.get("lang");
+  if (lang === "ja" || lang === "en" || lang === "both") return lang;
+  if (lang === void 0 || lang === true) return "ja";
+  fail(`invalid --lang "${String(lang)}" (expected ja, en, or both)`, 2);
+}
+function writeOut(opts, text) {
+  const out = opts.get("out");
+  if (typeof out === "string" && out) {
+    fs.writeFileSync(out, text, "utf8");
+    process.stderr.write(`pdgkit: wrote ${out}
+`);
+  } else {
+    process.stdout.write(text.endsWith("\n") ? text : text + "\n");
+  }
+}
+function writeBinary(opts, bytes) {
+  const out = opts.get("out");
+  if (typeof out !== "string" || !out) {
+    fail("binary output requires -o <file>", 2);
+  }
+  fs.writeFileSync(out, bytes);
+  process.stderr.write(`pdgkit: wrote ${out} (${bytes.length} bytes)
+`);
+}
+function formatDiagnostic(d) {
+  const tag = d.severity === "error" ? "ERROR" : d.severity === "warning" ? "WARN " : "INFO ";
+  return `  ${tag} line ${d.line}:${d.col}  ${d.message}`;
+}
+async function cmdRender(args) {
+  const source = resolveSource(args.positionals[0], args.opts);
+  const lang = getLang(args.opts);
+  const to = args.opts.get("to") ?? "svg";
+  const crop = args.opts.get("crop") !== "false";
+  switch (to) {
+    case "svg": {
+      const { svg } = renderToSvg(source, { lang, crop });
+      writeOut(args.opts, svg);
+      return;
+    }
+    case "png":
+      writeBinary(args.opts, await renderToPng(source, { lang }));
+      return;
+    case "jpeg":
+    case "jpg":
+      writeBinary(args.opts, await renderToJpeg(source, { lang }));
+      return;
+    case "pdf":
+      writeBinary(args.opts, await renderToPdf(source, { lang }));
+      return;
+    case "pptx":
+      writeBinary(args.opts, await renderToPptx(source, { lang, editable: args.opts.get("editable") === true }));
+      return;
+    default:
+      fail(`unknown --to "${to}" (expected svg, png, jpeg, pdf, or pptx)`, 2);
+  }
+}
+function cmdValidate(args) {
+  const source = resolveSource(args.positionals[0], args.opts);
+  const result = validate(source);
+  const lines = [];
+  lines.push(`kind: ${result.kind}${result.declaredKind ? ` (declared: ${result.declaredKind})` : ""}`);
+  if (result.diagnostics.length === 0) {
+    lines.push("no diagnostics");
+  } else {
+    for (const d of result.diagnostics) lines.push(formatDiagnostic(d));
+  }
+  lines.push(
+    `summary: ${result.counts.errors} error(s), ${result.counts.warnings} warning(s), ${result.counts.infos} info`
+  );
+  process.stderr.write(lines.join("\n") + "\n");
+  process.exit(result.ok ? 0 : 1);
+}
+function cmdRefs(args) {
+  const source = resolveSource(args.positionals[0], args.opts);
+  const doc = parse(source);
+  const format = args.opts.get("format") ?? "md";
+  if (format === "md" || format === "markdown") {
+    writeOut(args.opts, refsToMarkdown(doc));
+  } else if (format === "csv") {
+    writeOut(args.opts, refsToCsv(doc));
+  } else {
+    fail(`unknown --format "${format}" (expected md or csv)`, 2);
+  }
+}
+function cmdGuide() {
+  process.stdout.write(loadAuthoringGuide().replace(/\n*$/, "\n"));
+}
+function cmdSamples() {
+  const rows = SAMPLE_ORDER.map((id) => `  ${id.padEnd(16)} ${SAMPLES[id].label} \u2014 ${SAMPLES[id].hint}`);
+  process.stdout.write(`built-in samples:
+${rows.join("\n")}
+`);
+}
+var HELP = `pdgkit ${VERSION} \u2014 headless engine for the PatentDSL (.pdg) language
+
+usage:
+  pdgkit render   <input> [--to svg|png|jpeg|pdf|pptx] [--lang ja|en|both] [-o file] [--no-crop]
+  pdgkit validate <input> [--lang ja|en|both]
+  pdgkit refs     <input> [--format md|csv] [-o file]
+  pdgkit guide
+  pdgkit samples
+  pdgkit version
+
+<input> is a file path, "-" for stdin, or omitted with --sample <id>.
+"pdgkit guide" prints the .pdg authoring guide, so an AI can read it instead of
+having it pasted in.
+
+examples:
+  pdgkit render fig1.pdg -o fig1.svg
+  pdgkit render --sample block --lang both -o block.svg
+  cat fig1.pdg | pdgkit validate -
+  pdgkit refs fig1.pdg --format csv -o signs.csv
+  pdgkit render fig1.pdg --to pdf -o fig1.pdf
+  pdgkit render fig1.pdg --to pptx --editable -o fig1.pptx
+
+formats: svg, png, jpeg, pdf, pptx (add --editable for editable PowerPoint shapes).
+an MCP server is also available: run \`pdgkit-mcp\`.`;
+async function main() {
+  const argv = process.argv.slice(2);
+  const cmd = argv[0];
+  const rest = parseArgs(argv.slice(1));
+  switch (cmd) {
+    case "render":
+      await cmdRender(rest);
+      break;
+    case "validate":
+      cmdValidate(rest);
+      break;
+    case "refs":
+      cmdRefs(rest);
+      break;
+    case "samples":
+      cmdSamples();
+      break;
+    case "guide":
+      cmdGuide();
+      break;
+    case "version":
+    case "--version":
+    case "-v":
+      process.stdout.write(`${VERSION}
+`);
+      break;
+    case void 0:
+    case "help":
+    case "--help":
+    case "-h":
+      process.stdout.write(HELP + "\n");
+      break;
+    default:
+      fail(`unknown command "${cmd}". Run "pdgkit help".`, 2);
+  }
+}
+main().catch((err) => {
+  fail(err instanceof Error ? err.message : String(err), 1);
+});