@cardenelabs/dragon 0.7.0

package/dist/index.js

@@ -0,0 +1,4870 @@
+import { NODE_KINDS, TONES, layout, diagram, rendersRows, requiredRowsHeight, requiredRowsWidth, sequence, flow, swimlane, er, stateMachine, topology } from '@cardenelabs/cdl';
+
+// src/keywords.ts
+var HEADERS = {
+  title: ["\u30BF\u30A4\u30C8\u30EB", "title"],
+  type: ["\u7A2E\u985E", "type"],
+  actors: ["\u767B\u5834\u4EBA\u7269", "actors"],
+  flow: ["\u6D41\u308C", "flow", "steps"],
+  animate: ["\u30A2\u30CB\u30E1\u30FC\u30B7\u30E7\u30F3", "animate", "animation"]
+};
+var PRESET_NAMES = ["sequence", "flow", "swimlane", "er", "state", "topology"];
+var NODE_KIND_ALIAS = {
+  // 日本語
+  \u4EBA: "actor",
+  \u95A2\u6570: "function",
+  \u30B9\u30C8\u30EC\u30FC\u30B8: "storage",
+  \u30A4\u30D9\u30F3\u30C8: "event",
+  // 英語 (NodeKind そのまま)
+  actor: "actor",
+  function: "function",
+  storage: "storage",
+  event: "event",
+  cdn: "cdn",
+  service: "service",
+  database: "database",
+  cache: "cache",
+  queue: "queue"
+  // ... 残り 29 NodeKind は parser 内で types.NodeKind を直接受理
+};
+var TONE_ALIAS = {
+  // 日本語
+  \u6210\u529F: "success",
+  \u5931\u6557: "error",
+  \u8B66\u544A: "warning",
+  \u60C5\u5831: "info",
+  \u4E2D\u7ACB: "accent",
+  // 英語
+  success: "success",
+  error: "error",
+  warning: "warning",
+  info: "info",
+  neutral: "accent",
+  accent: "accent",
+  teal: "teal"
+};
+var ANIM_SUBKEYS = {
+  state: ["\u72B6\u614B", "state"],
+  step: ["\u30B9\u30C6\u30C3\u30D7", "step"],
+  highlight: ["\u5F37\u8ABF", "highlight", "active", "activate"],
+  tween: ["\u9077\u79FB", "tween"],
+  set: ["\u5207\u66FF", "set"],
+  body: ["\u8AAC\u660E", "body", "description"],
+  badge: ["\u30D0\u30C3\u30B8", "badge"]
+};
+var ARROW_PATTERNS = ["\u2192", "->", "=>", ">>", "->>", "-->>", "->>"];
+function normalizeArrow(s) {
+  let r = s;
+  for (const p of ARROW_PATTERNS) {
+    r = r.split(p).join("\u2192");
+  }
+  return r;
+}
+function resolveHeader(s) {
+  const lower = s.toLowerCase().trim();
+  for (const [canon, aliases] of Object.entries(HEADERS)) {
+    if (aliases.some((a) => a.toLowerCase() === lower)) {
+      return canon;
+    }
+  }
+  return null;
+}
+function resolveAnimSubkey(s) {
+  const lower = s.toLowerCase().trim();
+  for (const [canon, aliases] of Object.entries(ANIM_SUBKEYS)) {
+    if (aliases.some((a) => a.toLowerCase() === lower)) {
+      return canon;
+    }
+  }
+  return null;
+}
+function parseDuration(s) {
+  const trimmed = s.trim();
+  const sec = trimmed.match(/^([\d.]+)\s*秒$/);
+  if (sec) return Math.round(parseFloat(sec[1]) * 1e3);
+  const ms = trimmed.match(/^([\d.]+)\s*ms$/i);
+  if (ms) return Math.round(parseFloat(ms[1]));
+  const en = trimmed.match(/^([\d.]+)\s*s$/i);
+  if (en) return Math.round(parseFloat(en[1]) * 1e3);
+  return null;
+}
+
+// src/parser.ts
+function indentOf(s) {
+  let n = 0;
+  for (const c of s) {
+    if (c === " ") n += 1;
+    else if (c === "	") n += 2;
+    else break;
+  }
+  return n;
+}
+function splitLines(src) {
+  return src.split("\n").map((raw, i) => {
+    const noComment = raw.replace(/\s*#.*$/, "");
+    return {
+      raw,
+      trimmed: noComment.trim(),
+      indent: indentOf(noComment),
+      lineNo: i + 1
+    };
+  });
+}
+function isBlank(l) {
+  return l.trimmed === "";
+}
+function splitKv(s) {
+  const idx = s.indexOf(":");
+  if (idx < 0) return null;
+  return [s.slice(0, idx).trim(), s.slice(idx + 1).trim()];
+}
+function parseListItem(s) {
+  const m = s.match(/^-\s*(.+?)(?:\s*\(\s*(.+?)\s*\))?\s*$/);
+  if (!m) return null;
+  return { name: m[1].trim(), paren: m[2]?.trim() };
+}
+function parseTextDsl(src) {
+  const lines = splitLines(src);
+  const errors = [];
+  let title;
+  let type;
+  const actors = [];
+  const steps = [];
+  let animate;
+  let i = 0;
+  while (i < lines.length) {
+    const l = lines[i];
+    if (isBlank(l)) {
+      i += 1;
+      continue;
+    }
+    const kv = splitKv(l.trimmed);
+    if (kv && l.indent === 0) {
+      const header = resolveHeader(kv[0]);
+      if (header === "title") {
+        title = kv[1];
+        i += 1;
+        continue;
+      }
+      if (header === "type") {
+        if (!PRESET_NAMES.includes(kv[1].toLowerCase())) {
+          errors.push({
+            line: l.lineNo,
+            message: `\u672A\u77E5\u306E\u7A2E\u985E "${kv[1]}"`,
+            hint: `\u6B21\u304B\u3089\u9078\u3093\u3067\u304F\u3060\u3055\u3044: ${PRESET_NAMES.join(" / ")}`
+          });
+        }
+        type = kv[1].toLowerCase();
+        i += 1;
+        continue;
+      }
+      if (header === "actors") {
+        i += 1;
+        while (i < lines.length && (lines[i].indent > 0 || isBlank(lines[i]))) {
+          if (!isBlank(lines[i])) {
+            const a = parseActor(lines[i], errors);
+            if (a) actors.push(a);
+          }
+          i += 1;
+        }
+        continue;
+      }
+      if (header === "flow") {
+        i += 1;
+        while (i < lines.length && (lines[i].indent > 0 || isBlank(lines[i]))) {
+          if (!isBlank(lines[i])) {
+            const s = parseStep(lines[i], errors, actors);
+            if (s) steps.push(s);
+          }
+          i += 1;
+        }
+        continue;
+      }
+      if (header === "animate") {
+        const r = parseAnimate(lines, i + 1, errors);
+        animate = r.anim;
+        i = r.nextIndex;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  if (!title) errors.push({ line: 1, message: "\u30BF\u30A4\u30C8\u30EB: \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093", hint: "\u30D5\u30A1\u30A4\u30EB\u5148\u982D\u306B `\u30BF\u30A4\u30C8\u30EB: <\u540D\u524D>` \u3092\u8FFD\u52A0" });
+  if (!type) errors.push({ line: 1, message: "\u7A2E\u985E: \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093", hint: "\u30D5\u30A1\u30A4\u30EB\u306B `\u7A2E\u985E: sequence` \u7B49\u3092\u8FFD\u52A0" });
+  if (actors.length === 0) errors.push({ line: 1, message: "\u767B\u5834\u4EBA\u7269: \u30D6\u30ED\u30C3\u30AF\u304C\u7A7A\u307E\u305F\u306F\u898B\u3064\u304B\u308A\u307E\u305B\u3093", hint: "`\u767B\u5834\u4EBA\u7269:` \u306E\u4E0B\u306B `- \u540D\u524D (\u7A2E\u985E)` \u3092\u8FFD\u52A0" });
+  if (errors.length > 0) return { ok: false, errors };
+  return {
+    ok: true,
+    doc: {
+      title,
+      type,
+      actors,
+      flow: steps,
+      animate,
+      pos: { line: 1 }
+    }
+  };
+}
+function parseActor(l, errors) {
+  const item = parseListItem(l.trimmed);
+  if (!item) {
+    errors.push({ line: l.lineNo, message: `\u767B\u5834\u4EBA\u7269\u306E\u66F8\u5F0F\u30A8\u30E9\u30FC: "${l.trimmed}"`, hint: "`- \u540D\u524D (\u7A2E\u985E)` \u5F62\u5F0F\u3067\u66F8\u3044\u3066\u304F\u3060\u3055\u3044" });
+    return null;
+  }
+  let kind = "actor";
+  let kindWritten = false;
+  if (item.paren) {
+    const resolved = NODE_KIND_ALIAS[item.paren] ?? item.paren;
+    kind = resolved;
+    kindWritten = true;
+  }
+  return { name: item.name, kind, kindWritten, pos: { line: l.lineNo } };
+}
+function parseStep(l, errors, actors) {
+  const m = l.trimmed.match(/^(\d+)\.\s*(.+)$/);
+  if (!m) {
+    errors.push({ line: l.lineNo, message: `\u6D41\u308C\u306E\u66F8\u5F0F\u30A8\u30E9\u30FC: "${l.trimmed}"`, hint: "`\u756A\u53F7. <from> \u2192 <to>: <\u30E9\u30D9\u30EB>` \u5F62\u5F0F" });
+    return null;
+  }
+  const no = parseInt(m[1], 10);
+  const rest = normalizeArrow(m[2]);
+  const m2 = rest.match(/^(.+?)\s*→\s*(.+?)\s*:\s*(.+)$/);
+  if (!m2) {
+    errors.push({ line: l.lineNo, message: `\u77E2\u5370\u307E\u305F\u306F \u30E9\u30D9\u30EB \u306A\u3057: "${l.trimmed}"`, hint: "`<from> \u2192 <to>: <\u30E9\u30D9\u30EB>` \u5F62\u5F0F" });
+    return null;
+  }
+  const from = m2[1].trim();
+  const to = m2[2].trim();
+  let labelPart = m2[3].trim();
+  let tone;
+  const toneMatch = labelPart.match(/^(.+?)\s*\(\s*(.+?)\s*\)\s*$/);
+  if (toneMatch) {
+    const resolved = TONE_ALIAS[toneMatch[2]];
+    if (resolved) {
+      tone = resolved;
+      labelPart = toneMatch[1].trim();
+    }
+  }
+  let sub;
+  if (!tone && toneMatch) {
+    sub = toneMatch[2];
+    labelPart = toneMatch[1].trim();
+  }
+  const names = new Set(actors.map((a) => a.name));
+  if (!names.has(from)) {
+    errors.push({ line: l.lineNo, message: `"${from}" \u304C\u767B\u5834\u4EBA\u7269\u306B\u3044\u307E\u305B\u3093`, hint: `\u767B\u5834\u4EBA\u7269: \u306B "- ${from}" \u3092\u8FFD\u52A0` });
+  }
+  if (!names.has(to)) {
+    errors.push({ line: l.lineNo, message: `"${to}" \u304C\u767B\u5834\u4EBA\u7269\u306B\u3044\u307E\u305B\u3093`, hint: `\u767B\u5834\u4EBA\u7269: \u306B "- ${to}" \u3092\u8FFD\u52A0` });
+  }
+  return { no, from, to, label: labelPart, sub, tone, pos: { line: l.lineNo } };
+}
+function parseAnimate(lines, startIdx, errors) {
+  const states = [];
+  const phases = [];
+  const anim = { states, phases, pos: { line: startIdx + 1 } };
+  let i = startIdx;
+  while (i < lines.length) {
+    const l = lines[i];
+    if (isBlank(l)) {
+      i += 1;
+      continue;
+    }
+    if (l.indent === 0) break;
+    const kv = splitKv(l.trimmed);
+    if (kv) {
+      let sub = null;
+      const head = kv[0].trim();
+      if (/^(ステップ|step|STEP)/i.test(head)) sub = "step";
+      else sub = resolveAnimSubkey(head);
+      if (sub === "state") {
+        const m = kv[1].match(/^(.+?)\s*=\s*(.+)$/);
+        if (!m) {
+          errors.push({ line: l.lineNo, message: `\u72B6\u614B \u66F8\u5F0F\u30A8\u30E9\u30FC: "${kv[1]}"`, hint: "`\u72B6\u614B: <\u540D\u524D> = <\u521D\u671F\u5024>`" });
+        } else {
+          const name = m[1].trim();
+          const raw = m[2].trim();
+          const num = parseFloat(raw);
+          const initial = isNaN(num) ? raw.replace(/^["']|["']$/g, "") : num;
+          states.push({ name, initial, pos: { line: l.lineNo } });
+        }
+        i += 1;
+        continue;
+      }
+      if (sub === "step") {
+        const afterKeyword = kv[0].replace(/^(ステップ|step|STEP)\s*/i, "").trim();
+        const nameMatch = afterKeyword.match(/^[「"](.+?)[」"]\s*(.+)$/);
+        if (!nameMatch) {
+          errors.push({ line: l.lineNo, message: `\u30B9\u30C6\u30C3\u30D7 \u66F8\u5F0F\u30A8\u30E9\u30FC: "${kv[0]}"`, hint: `\`\u30B9\u30C6\u30C3\u30D7\u300C<\u540D\u524D>\u300D <\u6642\u9593>:\` \u5F62\u5F0F` });
+          i += 1;
+          continue;
+        }
+        const phaseName = nameMatch[1];
+        const durStr = nameMatch[2].trim();
+        const durMs = parseDuration(durStr);
+        if (durMs === null) {
+          errors.push({ line: l.lineNo, message: `\u6642\u9593 \u89E3\u91C8\u4E0D\u80FD: "${durStr}"`, hint: "`1.5 \u79D2` / `1500ms` / `2s` \u7B49" });
+          i += 1;
+          continue;
+        }
+        const phase = { name: phaseName, durationMs: durMs, pos: { line: l.lineNo } };
+        i += 1;
+        const phaseBaseIndent = l.indent;
+        while (i < lines.length && (lines[i].indent > phaseBaseIndent || isBlank(lines[i]))) {
+          if (!isBlank(lines[i])) {
+            applyPhaseSubLine(lines[i], phase, errors);
+          }
+          i += 1;
+        }
+        phases.push(phase);
+        continue;
+      }
+    }
+    i += 1;
+  }
+  return { anim, nextIndex: i };
+}
+function applyPhaseSubLine(l, phase, errors) {
+  const kv = splitKv(l.trimmed);
+  if (!kv) return;
+  const sub = resolveAnimSubkey(kv[0]);
+  if (sub === "highlight") {
+    phase.highlight = kv[1].split(",").map((s) => s.trim()).filter(Boolean);
+    return;
+  }
+  if (sub === "tween") {
+    const rest = normalizeArrow(kv[1]);
+    const m = rest.match(/^(.+?)\s*:\s*([\d.]+)\s*→\s*([\d.]+)$/);
+    if (!m) {
+      errors.push({ line: l.lineNo, message: `\u9077\u79FB \u66F8\u5F0F\u30A8\u30E9\u30FC: "${kv[1]}"`, hint: "`\u9077\u79FB: <state>: <from> \u2192 <to>`" });
+      return;
+    }
+    phase.tweens = phase.tweens ?? [];
+    phase.tweens.push({
+      state: m[1].trim(),
+      from: parseFloat(m[2]),
+      to: parseFloat(m[3]),
+      pos: { line: l.lineNo }
+    });
+    return;
+  }
+  if (sub === "set") {
+    const m = kv[1].match(/^(.+?)\s*:\s*(.+)$/);
+    if (!m) {
+      errors.push({ line: l.lineNo, message: `\u5207\u66FF \u66F8\u5F0F\u30A8\u30E9\u30FC: "${kv[1]}"`, hint: "`\u5207\u66FF: <state>: <\u5024>`" });
+      return;
+    }
+    const raw = m[2].trim();
+    const num = parseFloat(raw);
+    const value = isNaN(num) ? raw : num;
+    phase.sets = phase.sets ?? [];
+    phase.sets.push({ state: m[1].trim(), value, pos: { line: l.lineNo } });
+    return;
+  }
+  if (sub === "body") {
+    phase.body = kv[1];
+    return;
+  }
+  if (sub === "badge") {
+    phase.badge = kv[1];
+    return;
+  }
+}
+
+// src/focus.ts
+var ARROW = /^(.+?)\s*(?:->|→)\s*(.+)$/;
+function parseFocusEntry(raw, knownNames) {
+  const item = raw.trim();
+  if (knownNames?.has(item)) return { kind: "node", name: item };
+  const m = item.match(ARROW);
+  if (!m) return { kind: "node", name: item };
+  return { kind: "edge", from: m[1].trim(), to: m[2].trim() };
+}
+
+// src/color.ts
+var CSS_COLOR_NAMES = /* @__PURE__ */ new Set([
+  "aliceblue",
+  "antiquewhite",
+  "aqua",
+  "aquamarine",
+  "azure",
+  "beige",
+  "bisque",
+  "black",
+  "blanchedalmond",
+  "blue",
+  "blueviolet",
+  "brown",
+  "burlywood",
+  "cadetblue",
+  "chartreuse",
+  "chocolate",
+  "coral",
+  "cornflowerblue",
+  "cornsilk",
+  "crimson",
+  "cyan",
+  "darkblue",
+  "darkcyan",
+  "darkgoldenrod",
+  "darkgray",
+  "darkgreen",
+  "darkgrey",
+  "darkkhaki",
+  "darkmagenta",
+  "darkolivegreen",
+  "darkorange",
+  "darkorchid",
+  "darkred",
+  "darksalmon",
+  "darkseagreen",
+  "darkslateblue",
+  "darkslategray",
+  "darkslategrey",
+  "darkturquoise",
+  "darkviolet",
+  "deeppink",
+  "deepskyblue",
+  "dimgray",
+  "dimgrey",
+  "dodgerblue",
+  "firebrick",
+  "floralwhite",
+  "forestgreen",
+  "fuchsia",
+  "gainsboro",
+  "ghostwhite",
+  "gold",
+  "goldenrod",
+  "gray",
+  "green",
+  "greenyellow",
+  "grey",
+  "honeydew",
+  "hotpink",
+  "indianred",
+  "indigo",
+  "ivory",
+  "khaki",
+  "lavender",
+  "lavenderblush",
+  "lawngreen",
+  "lemonchiffon",
+  "lightblue",
+  "lightcoral",
+  "lightcyan",
+  "lightgoldenrodyellow",
+  "lightgray",
+  "lightgreen",
+  "lightgrey",
+  "lightpink",
+  "lightsalmon",
+  "lightseagreen",
+  "lightskyblue",
+  "lightslategray",
+  "lightslategrey",
+  "lightsteelblue",
+  "lightyellow",
+  "lime",
+  "limegreen",
+  "linen",
+  "magenta",
+  "maroon",
+  "mediumaquamarine",
+  "mediumblue",
+  "mediumorchid",
+  "mediumpurple",
+  "mediumseagreen",
+  "mediumslateblue",
+  "mediumspringgreen",
+  "mediumturquoise",
+  "mediumvioletred",
+  "midnightblue",
+  "mintcream",
+  "mistyrose",
+  "moccasin",
+  "navajowhite",
+  "navy",
+  "oldlace",
+  "olive",
+  "olivedrab",
+  "orange",
+  "orangered",
+  "orchid",
+  "palegoldenrod",
+  "palegreen",
+  "paleturquoise",
+  "palevioletred",
+  "papayawhip",
+  "peachpuff",
+  "peru",
+  "pink",
+  "plum",
+  "powderblue",
+  "purple",
+  "rebeccapurple",
+  "red",
+  "rosybrown",
+  "royalblue",
+  "saddlebrown",
+  "salmon",
+  "sandybrown",
+  "seagreen",
+  "seashell",
+  "sienna",
+  "silver",
+  "skyblue",
+  "slateblue",
+  "slategray",
+  "slategrey",
+  "snow",
+  "springgreen",
+  "steelblue",
+  "tan",
+  "teal",
+  "thistle",
+  "tomato",
+  "transparent",
+  "turquoise",
+  "violet",
+  "wheat",
+  "white",
+  "whitesmoke",
+  "yellow",
+  "yellowgreen",
+  // 塗らないことを表す値。 色ではないが、 色を書く位置に置ける正当な値
+  "none",
+  "currentcolor"
+]);
+function isColorValue(v) {
+  if (typeof v !== "string") return false;
+  const s = v.trim();
+  if (/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(s)) return true;
+  return CSS_COLOR_NAMES.has(s.toLowerCase());
+}
+function pointsOutside(v) {
+  if (typeof v !== "string") return false;
+  const compact = v.replace(/\s+/g, "").toLowerCase();
+  const m = compact.match(/url\(([^)]*)/);
+  if (m) {
+    const inner = (m[1] ?? "").replace(/^["']/, "");
+    return !inner.startsWith("#");
+  }
+  return /^(https?:)?\/\//.test(compact) || compact.startsWith("data:");
+}
+var PAINT_KEYS = /* @__PURE__ */ new Set([
+  "fill",
+  "stroke",
+  "color",
+  "bg",
+  "background",
+  "fillbind",
+  "strokebind",
+  "colorbind",
+  "stfill",
+  "strokecolor",
+  "fillcolor"
+]);
+var SAFE_PAINT = "none";
+function stripExternalPaint(diagram2) {
+  const stripped = [];
+  walk(diagram2, "", false, stripped);
+  return stripped;
+}
+function walk(node, path, inStateValue, out) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      walk(node[i], `${path}[${i}]`, inStateValue, out);
+    }
+    return;
+  }
+  const obj = node;
+  for (const [key, value] of Object.entries(obj)) {
+    const here = path ? `${path}.${key}` : key;
+    const lower = key.toLowerCase();
+    const nextInState = inStateValue || lower === "states" || lower === "sets" || lower === "tweens";
+    if (typeof value === "string") {
+      const isPaint = PAINT_KEYS.has(lower) || nextInState && (lower === "initial" || lower === "to" || lower === "from" || !isReservedStateKey(lower));
+      if (isPaint && pointsOutside(value)) {
+        obj[key] = SAFE_PAINT;
+        out.push({ path: here, value });
+      }
+      continue;
+    }
+    walk(value, here, nextInState, out);
+  }
+}
+function isReservedStateKey(lowerKey) {
+  return lowerKey === "id" || lowerKey === "stateid" || lowerKey === "duration" || lowerKey === "title" || lowerKey === "body" || lowerKey === "badge" || lowerKey === "kind";
+}
+
+// src/input-size.ts
+var MAX_INPUT_ELEMENTS = 2e3;
+var MAX_INPUT_BYTES = 512 * 1024;
+function countDocElements(doc) {
+  const phases = doc.animate?.phases ?? [];
+  const phaseChildren = phases.reduce(
+    (acc, p) => acc + (p.highlight?.length ?? 0) + (p.tweens?.length ?? 0) + (p.sets?.length ?? 0),
+    0
+  );
+  return doc.actors.length + doc.flow.length + phases.length + phaseChildren + (doc.animate?.states.length ?? 0) + (doc.groups ? Object.keys(doc.groups).length : 0) + (doc.lanes ? Object.keys(doc.lanes).length : 0);
+}
+function countDiagramElements(diagram2) {
+  const phases = Array.isArray(diagram2.phases) ? diagram2.phases : [];
+  const phaseChildren = phases.reduce((acc, p) => {
+    const ph = p;
+    return acc + (Array.isArray(ph?.activate) ? ph.activate.length : 0) + (Array.isArray(ph?.highlight) ? ph.highlight.length : 0) + (Array.isArray(ph?.tweens) ? ph.tweens.length : 0) + (Array.isArray(ph?.sets) ? ph.sets.length : 0);
+  }, 0);
+  return (diagram2.nodes?.length ?? 0) + (diagram2.edges?.length ?? 0) + (diagram2.lanes?.length ?? 0) + (diagram2.states?.length ?? 0) + phases.length + phaseChildren + // 図が持てる並びは全部数える。 1 つでも外すと、そこに寄せた図が素通りする
+  (diagram2.readouts?.length ?? 0) + (diagram2.inputs?.length ?? 0) + (diagram2.formulas?.length ?? 0) + (diagram2.scrollTriggers?.length ?? 0) + (diagram2.eventBindings?.length ?? 0);
+}
+function countBytes(src) {
+  return new TextEncoder().encode(src).length;
+}
+function describeOversize(size) {
+  if (size.elements > MAX_INPUT_ELEMENTS) {
+    return `\u8981\u7D20\u304C ${size.elements.toLocaleString()} \u4EF6\u3042\u308A\u307E\u3059\u3002 ${MAX_INPUT_ELEMENTS.toLocaleString()} \u4EF6\u307E\u3067\u306B\u3057\u3066\u304F\u3060\u3055\u3044 (\u3053\u308C\u4EE5\u4E0A\u306F\u7D44\u307F\u7ACB\u3066\u306B\u6642\u9593\u304C\u304B\u304B\u308A\u3001 \u753B\u9762\u304C\u6B62\u307E\u308A\u307E\u3059)`;
+  }
+  if (size.bytes > MAX_INPUT_BYTES) {
+    const kb = Math.ceil(size.bytes / 1024);
+    const limitKb = Math.floor(MAX_INPUT_BYTES / 1024);
+    return `\u672C\u6587\u304C ${kb.toLocaleString()}KB \u3042\u308A\u307E\u3059\u3002 ${limitKb.toLocaleString()}KB \u307E\u3067\u306B\u3057\u3066\u304F\u3060\u3055\u3044 (\u3053\u308C\u4EE5\u4E0A\u306F\u8AAD\u307F\u53D6\u308A\u3060\u3051\u3067\u5F85\u305F\u3055\u308C\u3001 \u8A18\u61B6\u3082\u5927\u304D\u304F\u4F7F\u3044\u307E\u3059)`;
+  }
+  return null;
+}
+function describeOversizeSource(src) {
+  return describeOversize({ elements: 0, bytes: countBytes(src) });
+}
+
+// src/relative-pos.ts
+var RELATIVE_GAP_DEFAULT = 160;
+var DIRECTION_WORDS = {
+  \u53F3: "right",
+  \u5DE6: "left",
+  \u4E0A: "above",
+  \u4E0B: "below",
+  right: "right",
+  left: "left",
+  above: "above",
+  below: "below"
+};
+var GAP_NUM = String.raw`(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?`;
+var RE_JA = new RegExp(String.raw`^(.+?)\s*の\s*(右|左|上|下)(?:\s*(${GAP_NUM}))?$`);
+var RE_EN = new RegExp(String.raw`^(.+?)\s+(right|left|above|below)(?:\s+(${GAP_NUM}))?$`, "i");
+function parseRelativePos(raw) {
+  const s = raw.trim();
+  if (s === "") return null;
+  const m = s.match(RE_JA) ?? s.match(RE_EN);
+  if (!m) return null;
+  const anchor = m[1].trim();
+  if (anchor === "") return null;
+  const dir = DIRECTION_WORDS[m[2].toLowerCase()];
+  if (dir === void 0) return null;
+  const gapRaw = m[3];
+  if (gapRaw === void 0) return { anchor, dir };
+  const gap = Number(gapRaw);
+  return Number.isFinite(gap) ? { anchor, dir, gap } : { anchor, dir };
+}
+function resolveRelativePos(rel, anchor, target) {
+  const raw = rel.gap ?? RELATIVE_GAP_DEFAULT;
+  const gap = Number.isFinite(raw) && raw >= 0 ? raw : RELATIVE_GAP_DEFAULT;
+  const dx = anchor.w / 2 + gap + target.w / 2;
+  const dy = anchor.h / 2 + gap + target.h / 2;
+  switch (rel.dir) {
+    case "right":
+      return { posX: anchor.cx + dx, posY: anchor.cy };
+    case "left":
+      return { posX: anchor.cx - dx, posY: anchor.cy };
+    case "below":
+      return { posX: anchor.cx, posY: anchor.cy + dy };
+    case "above":
+      return { posX: anchor.cx, posY: anchor.cy - dy };
+  }
+}
+function orderByDependency(items) {
+  const relOf = /* @__PURE__ */ new Map();
+  const known = /* @__PURE__ */ new Set();
+  for (const it of items) {
+    known.add(it.name);
+    if (it.rel) relOf.set(it.name, it.rel);
+  }
+  const order = [];
+  const done = /* @__PURE__ */ new Set();
+  const cyclic = /* @__PURE__ */ new Set();
+  for (const it of items) {
+    if (done.has(it.name) || cyclic.has(it.name)) continue;
+    const path = [];
+    const onPath = /* @__PURE__ */ new Set();
+    let cur = it.name;
+    while (cur !== void 0) {
+      if (done.has(cur) || cyclic.has(cur)) break;
+      if (onPath.has(cur)) {
+        for (const n of path.slice(path.indexOf(cur))) cyclic.add(n);
+        break;
+      }
+      path.push(cur);
+      onPath.add(cur);
+      const rel = relOf.get(cur);
+      if (rel === void 0 || !known.has(rel.anchor)) break;
+      cur = rel.anchor;
+    }
+    for (let i = path.length - 1; i >= 0; i -= 1) {
+      const n = path[i];
+      if (cyclic.has(n) || done.has(n)) continue;
+      done.add(n);
+      order.push(n);
+    }
+  }
+  return { order, cyclic: [...cyclic] };
+}
+
+// src/compile.ts
+function compileToCdl(doc, opts) {
+  const oversize = describeOversize({ elements: countDocElements(doc), bytes: 0 });
+  if (oversize) throw new Error(oversize);
+  let diagram2;
+  switch (doc.type) {
+    case "sequence":
+      diagram2 = compileSequence(doc);
+      break;
+    case "flow":
+      diagram2 = compileFlow(doc);
+      break;
+    case "swimlane":
+      diagram2 = compileSwimlane(doc);
+      break;
+    case "er":
+      diagram2 = compileEr(doc);
+      break;
+    case "state":
+      diagram2 = compileState(doc);
+      break;
+    case "topology":
+      diagram2 = compileTopology(doc);
+      break;
+    case "solidity":
+      diagram2 = compileSolidity(doc);
+      break;
+    case "gantt":
+      diagram2 = compileGantt(doc);
+      break;
+    case "class":
+      diagram2 = compileClass(doc);
+      break;
+    case "pie":
+      diagram2 = compilePie(doc);
+      break;
+    case "c4":
+      diagram2 = compileC4(doc);
+      break;
+    case "mind":
+      diagram2 = compileMind(doc);
+      break;
+    default:
+      throw new Error(`unknown type: ${String(doc.type)}`);
+  }
+  const edgeSourceLines = opts?.onEdgeSource ? /* @__PURE__ */ new Map() : void 0;
+  applyEdgeInlineOptions(diagram2, doc, edgeSourceLines);
+  if (edgeSourceLines) fillFlowEdgeSources(diagram2, doc, edgeSourceLines);
+  applyGroupContainers(diagram2, doc);
+  applyNodeTones(diagram2, doc);
+  reportMissingFocusTargets(doc, opts?.onNotice);
+  const placed = resolveRelativeDoc(diagram2, doc, opts?.onNotice, opts?.partsCatalog);
+  applyCanvasPivotPositions(diagram2, placed);
+  const extended = applyV05Extensions(diagram2, placed);
+  const merged = mergePartsFromActors(extended, placed, opts?.partsCatalog, opts?.onNotice);
+  if (edgeSourceLines && opts?.onEdgeSource) {
+    const alive = new Set(merged.edges.map((e) => e.id));
+    for (const [id, line] of edgeSourceLines) {
+      if (alive.has(id)) opts.onEdgeSource(id, line);
+    }
+  }
+  injectStaticPhase(merged);
+  for (const dropped of stripExternalPaint(merged)) {
+    opts?.onNotice?.({
+      kind: "external-paint-dropped",
+      actor: dropped.path,
+      line: 0,
+      message: `\u56F3\u306E\u5916\u3092\u6307\u3059\u5024 (${truncateForMessage(dropped.value)}) \u306F\u8272\u3068\u3057\u3066\u4F7F\u3048\u306A\u3044\u305F\u3081\u5916\u3057\u307E\u3057\u305F`,
+      hint: "\u8272\u306F `#ff0000` \u306E\u3088\u3046\u306A\u8272\u756A\u53F7\u304B\u3001 `red` \u306E\u3088\u3046\u306A\u8272\u540D\u3067\u66F8\u304F"
+    });
+  }
+  return merged;
+}
+function injectStaticPhase(diagram2) {
+  if (diagram2.phases.length > 0) return;
+  const activate = [...diagram2.nodes.map((n) => n.id), ...diagram2.edges.map((e) => e.id)];
+  diagram2.phases.push({
+    id: "static",
+    duration: 1e3,
+    title: diagram2.topic ?? "\u5168\u4F53",
+    body: "",
+    activate,
+    tweens: [],
+    sets: []
+  });
+}
+function truncateForMessage(v) {
+  const s = v.trim();
+  return s.length <= 40 ? s : `${s.slice(0, 37)}...`;
+}
+function reportMissingFocusTargets(doc, onNotice) {
+  if (!onNotice || !doc.animate) return;
+  const names = new Set(doc.actors.map((a) => a.name));
+  const accepted = new Set(names);
+  const slugCount = /* @__PURE__ */ new Map();
+  for (const n of names) {
+    const sl = slugify(n);
+    slugCount.set(sl, (slugCount.get(sl) ?? 0) + 1);
+  }
+  for (const [sl, count] of slugCount) if (count === 1) accepted.add(sl);
+  const steps = /* @__PURE__ */ new Map();
+  for (const st of doc.flow) {
+    const tos = steps.get(st.from) ?? /* @__PURE__ */ new Set();
+    tos.add(st.to);
+    steps.set(st.from, tos);
+  }
+  for (const phase of doc.animate.phases) {
+    for (const raw of phase.highlight ?? []) {
+      const entry = parseFocusEntry(raw, names);
+      const found = entry.kind === "edge" ? steps.get(entry.from)?.has(entry.to) ?? false : accepted.has(entry.name);
+      if (found) continue;
+      onNotice({
+        kind: "focus-target-missing",
+        actor: raw,
+        line: phase.pos.line,
+        message: entry.kind === "edge" ? `\u5149\u3089\u305B\u308B\u77E2\u5370\u304C\u6D41\u308C\u306B\u3042\u308A\u307E\u305B\u3093: "${raw}"` : `\u5149\u3089\u305B\u308B\u76F8\u624B\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: "${raw}"`,
+        hint: entry.kind === "edge" ? "flow: \u306B\u66F8\u3044\u305F\u77E2\u5370\u3068\u540C\u3058\u5411\u304D\u3067\u66F8\u304F" : `actors: \u306B\u66F8\u304B\u308C\u3066\u3044\u308B\u540D\u524D = ${[...names].join(", ")}`
+        // 縦列の id は受理しないので、 その旨は hint に出さない (光らせられないため)
+      });
+    }
+  }
+}
+function resolveRelativeDoc(diagram2, doc, onNotice, partsCatalog) {
+  if (!doc.actors.some((a) => a.posRel !== void 0)) return doc;
+  const measured = measureActorBoxes(withPositions(diagram2, doc, /* @__PURE__ */ new Map()));
+  const baseBoxes = new Map(measured);
+  if (partsCatalog) {
+    for (const [name, box] of partBoxes(diagram2, doc, partsCatalog)) baseBoxes.set(name, box);
+  }
+  const sizeOverride = partsCatalog ? partSizes(doc, partsCatalog) : /* @__PURE__ */ new Map();
+  const want = desiredCenters(doc, baseBoxes, sizeOverride);
+  if (want.size === 0) return doc;
+  const naive = new Map(
+    [...want].map(([name, c]) => {
+      const off = sizeOverride.get(name);
+      return [name, { posX: c.cx - (off?.dx ?? 0), posY: c.cy - (off?.dy ?? 0) }];
+    })
+  );
+  const isPart = new Set(doc.actors.filter((a) => a.partId !== void 0).map((a) => a.name));
+  const partOverride = /* @__PURE__ */ new Map();
+  for (const [name, box] of baseBoxes) {
+    if (isPart.has(name)) partOverride.set(name, box);
+  }
+  for (const [name, c] of want) {
+    if (!isPart.has(name)) continue;
+    partOverride.set(name, c);
+  }
+  const placedBoxes = measureActorBoxes(withPositions(diagram2, doc, naive));
+  const fixed = /* @__PURE__ */ new Map();
+  for (const [name, pos] of naive) {
+    if (isPart.has(name)) {
+      fixed.set(name, pos);
+      continue;
+    }
+    const got = placedBoxes.get(name);
+    const target = want.get(name);
+    if (!got) {
+      fixed.set(name, pos);
+      continue;
+    }
+    fixed.set(name, {
+      posX: pos.posX + (target.cx - got.cx),
+      posY: pos.posY + (target.cy - got.cy)
+    });
+  }
+  return withDocPositions(doc, verifyPlacement(diagram2, doc, fixed, partOverride, onNotice));
+}
+function verifyPlacement(diagram2, doc, assign, partOverride, onNotice) {
+  const boxes = measureActorBoxes(withPositions(diagram2, doc, assign));
+  for (const [name, box] of partOverride) boxes.set(name, box);
+  const kept = new Map(assign);
+  for (const actor of doc.actors) {
+    const rel = actor.posRel;
+    const pos = assign.get(actor.name);
+    if (!rel || !pos) continue;
+    const self = boxes.get(actor.name);
+    const anchor = boxes.get(rel.anchor);
+    if (!self || !anchor) continue;
+    const expect = resolveRelativePos(rel, anchor, self);
+    const offX = Math.abs(expect.posX - self.cx);
+    const offY = Math.abs(expect.posY - self.cy);
+    if (offX <= PLACEMENT_TOLERANCE && offY <= PLACEMENT_TOLERANCE) continue;
+    kept.delete(actor.name);
+    onNotice?.({
+      kind: "relative-position-ignored",
+      actor: actor.name,
+      line: actor.pos.line,
+      message: `"${actor.name}" \u306E\u4F4D\u7F6E (${rel.anchor} \u306E${DIRECTION_LABEL[rel.dir]}) \u306F${doc.type}\u56F3\u3067\u306F\u52B9\u304D\u307E\u305B\u3093`,
+      hint: "\u5EA7\u6A19 (`\u4F4D\u7F6E: 300,200`) \u3067\u7F6E\u304F\u304B\u3001 \u81EA\u52D5\u914D\u7F6E\u306B\u4EFB\u305B\u308B"
+    });
+  }
+  return kept;
+}
+var DIRECTION_LABEL = {
+  right: "\u53F3",
+  left: "\u5DE6",
+  above: "\u4E0A",
+  below: "\u4E0B"
+};
+var PLACEMENT_TOLERANCE = 1;
+function desiredCenters(doc, boxes, sizeOverride = /* @__PURE__ */ new Map()) {
+  const byName = new Map(doc.actors.map((a) => [a.name, a]));
+  const { order } = orderByDependency(doc.actors.map((a) => ({ name: a.name, rel: a.posRel })));
+  const centers = new Map(boxes);
+  const out = /* @__PURE__ */ new Map();
+  for (const name of order) {
+    const actor = byName.get(name);
+    const override = sizeOverride.get(name);
+    const measuredSelf = boxes.get(name);
+    const self = override ? { cx: measuredSelf?.cx ?? 0, cy: measuredSelf?.cy ?? 0, w: override.w, h: override.h } : measuredSelf;
+    if (!actor?.posRel || !self) continue;
+    const anchor = centers.get(actor.posRel.anchor);
+    if (!anchor) continue;
+    const p = resolveRelativePos(actor.posRel, anchor, self);
+    const center = { cx: p.posX, cy: p.posY, w: self.w, h: self.h };
+    centers.set(name, center);
+    out.set(name, center);
+  }
+  return out;
+}
+function measureActorBoxes(diagram2, laidHint) {
+  const laid = laidHint ?? layout(diagram2);
+  const bounds = /* @__PURE__ */ new Map();
+  for (const n of laid.nodes) {
+    const title = n.title;
+    if (!title) continue;
+    const x0 = n.cx - n.w / 2;
+    const y0 = n.cy - n.h / 2;
+    const x1 = n.cx + n.w / 2;
+    const y1 = n.cy + n.h / 2;
+    const cur = bounds.get(title);
+    if (cur) {
+      cur.x0 = Math.min(cur.x0, x0);
+      cur.y0 = Math.min(cur.y0, y0);
+      cur.x1 = Math.max(cur.x1, x1);
+      cur.y1 = Math.max(cur.y1, y1);
+    } else {
+      bounds.set(title, { x0, y0, x1, y1 });
+    }
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, b] of bounds) {
+    out.set(name, { cx: (b.x0 + b.x1) / 2, cy: (b.y0 + b.y1) / 2, w: b.x1 - b.x0, h: b.y1 - b.y0 });
+  }
+  for (const lane of laid.lanes) {
+    const label = lane.label;
+    if (!label || out.has(label)) continue;
+    const y = lane.y ?? 0;
+    const h = lane.height ?? 0;
+    out.set(label, { cx: (lane.x ?? 0) + lane.width / 2, cy: y + h / 2, w: lane.width, h });
+  }
+  return out;
+}
+function withDocPositions(doc, assign) {
+  if (assign.size === 0) return doc;
+  return {
+    ...doc,
+    actors: doc.actors.map((a) => {
+      const p = assign.get(a.name);
+      return p ? { ...a, posX: p.posX, posY: p.posY } : a;
+    })
+  };
+}
+function withPositions(diagram2, doc, assign) {
+  const probe = {
+    ...diagram2,
+    lanes: diagram2.lanes.map((l) => ({ ...l })),
+    nodes: diagram2.nodes.map((n) => ({ ...n }))
+  };
+  applyCanvasPivotPositions(probe, withDocPositions(doc, assign));
+  return probe;
+}
+function applyNodeTones(diagram2, doc) {
+  for (const actor of doc.actors) {
+    if (actor.tone === void 0) continue;
+    for (const node of diagram2.nodes) {
+      if (node.title === actor.name) node.tone = actor.tone;
+    }
+  }
+}
+function applyCanvasPivotPositions(diagram2, doc) {
+  for (const actor of doc.actors) {
+    if (actor.partId !== void 0) continue;
+    const aliasSlug = slugify(actor.name);
+    if (actor.posX !== void 0 && actor.posY !== void 0) {
+      for (const lane of diagram2.lanes) {
+        if (lane.id === aliasSlug || lane.id === actor.name) {
+          lane.posX = actor.posX;
+          lane.posY = actor.posY;
+          if (actor.posW !== void 0) lane.posW = actor.posW;
+          if (actor.posH !== void 0) lane.posH = actor.posH;
+        }
+      }
+      for (const node of diagram2.nodes) {
+        if (node.id === aliasSlug || node.id === actor.name) {
+          node.posX = actor.posX;
+          node.posY = actor.posY;
+          if (actor.posW !== void 0) node.posW = actor.posW;
+          if (actor.posH !== void 0) node.posH = actor.posH;
+        }
+      }
+    }
+    if (actor.nodes) {
+      for (const [subKey, override] of Object.entries(actor.nodes)) {
+        if (override.posX === void 0 || override.posY === void 0) continue;
+        for (const node of diagram2.nodes) {
+          if (node.id === `${aliasSlug}-${subKey}` || node.id === `${subKey}-${aliasSlug}`) {
+            node.posX = override.posX;
+            node.posY = override.posY;
+            if (override.posW !== void 0) node.posW = override.posW;
+            if (override.posH !== void 0) node.posH = override.posH;
+          }
+        }
+      }
+    }
+  }
+}
+function lookupPart(partsCatalog, partId) {
+  const found = lookupPartRaw(partsCatalog, partId);
+  if (found === void 0) return void 0;
+  return partIsMeasurable(found) ? found : void 0;
+}
+function lookupPartRaw(partsCatalog, partId) {
+  if (typeof partId !== "string" || partId.length === 0) return void 0;
+  if (Object.hasOwn(partsCatalog, partId)) return partsCatalog[partId];
+  if (Object.hasOwn(partsCatalog, `parts-${partId}`)) return partsCatalog[`parts-${partId}`];
+  return void 0;
+}
+function partIsMeasurable(part) {
+  return countDiagramElements(part) <= MAX_INPUT_ELEMENTS;
+}
+var CDL_DEFAULT_NODE_W = 340;
+var CDL_DEFAULT_NODE_H = 200;
+function positiveOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function maxOf(values, fallback) {
+  if (values.length === 0) return fallback;
+  let out = values[0];
+  for (const v of values) if (v > out) out = v;
+  return out;
+}
+function minOf(values, fallback) {
+  if (values.length === 0) return fallback;
+  let out = values[0];
+  for (const v of values) if (v < out) out = v;
+  return out;
+}
+var PART_STACK_PITCH = 220;
+var MAX_PART_SCALE = 1e3;
+function normalizePartScale(value) {
+  if (!Number.isFinite(value) || value <= 0) return 1;
+  return Math.min(value, MAX_PART_SCALE);
+}
+function partScaleFactor(part, posW, posH, scale) {
+  const base = partScaleBase(part);
+  const k = scale === void 0 ? 1 : normalizePartScale(scale);
+  const rx = posW !== void 0 && posW > 0 ? posW / base.w : 1;
+  const ry = posH !== void 0 && posH > 0 ? posH / base.h : 1;
+  return { x: normalizePartScale(rx * k), y: normalizePartScale(ry * k) };
+}
+function partTargetSize(part, posW, posH, scale) {
+  if (posW === void 0 && posH === void 0 && scale === void 0) {
+    return { w: void 0, h: void 0 };
+  }
+  const base = partScaleBase(part);
+  const f = partScaleFactor(part, posW, posH, scale);
+  return {
+    w: posW === void 0 && scale === void 0 ? void 0 : base.w * f.x,
+    h: posH === void 0 && scale === void 0 ? void 0 : base.h * f.y
+  };
+}
+function partScaleBase(part) {
+  const lanes = Array.isArray(part.lanes) ? part.lanes : [];
+  const nodes = Array.isArray(part.nodes) ? part.nodes : [];
+  const lefts = [];
+  const rights = [];
+  for (const l of lanes) {
+    const lx = typeof l.x === "number" && Number.isFinite(l.x) ? l.x : 0;
+    const lw = positiveOr(l.width, 400);
+    lefts.push(lx);
+    rights.push(lx + lw);
+  }
+  const stacks = nodes.map(
+    (n) => typeof n.stack === "number" && Number.isFinite(n.stack) ? n.stack : 0
+  );
+  return {
+    w: positiveOr(maxOf(rights, 400) - minOf(lefts, 0), 400),
+    h: Math.max(1, (maxOf(stacks, 0) - minOf(stacks, 0) + 1) * PART_STACK_PITCH)
+  };
+}
+function partTargetScale(part, targetW, targetH) {
+  const none = { x: 1, y: 1 };
+  if (!Array.isArray(part.lanes) || !Array.isArray(part.nodes)) return none;
+  return partScaleFactor(part, targetW, targetH, void 0);
+}
+function partExtent(part, targetW, targetH) {
+  const fallback = { w: 400, h: 200, dx: 0, dy: 0 };
+  if (!Array.isArray(part.lanes) || !Array.isArray(part.nodes)) return fallback;
+  if (part.nodes.length === 0) return fallback;
+  const lanes = /* @__PURE__ */ new Map();
+  const laneLefts = [];
+  const laneRights = [];
+  for (const l of part.lanes) {
+    const x = typeof l.x === "number" && Number.isFinite(l.x) ? l.x : 0;
+    const w = positiveOr(l.width, 400);
+    lanes.set(l.id, { x, w });
+    laneLefts.push(x);
+    laneRights.push(x + w);
+  }
+  const bboxW = positiveOr(maxOf(laneRights, 400) - minOf(laneLefts, 0), 400);
+  const bboxCenterX = minOf(laneLefts, 0) + bboxW / 2;
+  const { x: scaleX, y: scaleY } = partTargetScale(part, targetW, targetH);
+  const stacks = part.nodes.map(
+    (n) => typeof n.stack === "number" && Number.isFinite(n.stack) ? n.stack : 0
+  );
+  const maxStack = maxOf(stacks, 0);
+  const minStack = minOf(stacks, 0);
+  const centerStack = (minStack + maxStack) / 2;
+  const tops = [];
+  const bottoms = [];
+  const lefts = [];
+  const rights = [];
+  part.nodes.forEach((n, i) => {
+    const lane = lanes.get(n.lane) ?? { x: 0, w: 320 };
+    const cx = (lane.x + lane.w / 2 - bboxCenterX) * scaleX;
+    const cy = ((stacks[i] ?? 0) - centerStack) * PART_STACK_PITCH * scaleY;
+    const halfW = positiveOr(n.w, CDL_DEFAULT_NODE_W) * scaleX / 2;
+    const halfH = positiveOr(n.h, CDL_DEFAULT_NODE_H) * scaleY / 2;
+    lefts.push(cx - halfW);
+    rights.push(cx + halfW);
+    tops.push(cy - halfH);
+    bottoms.push(cy + halfH);
+  });
+  const x0 = minOf(lefts, 0);
+  const x1 = maxOf(rights, 400);
+  const y0 = minOf(tops, 0);
+  const y1 = maxOf(bottoms, 200);
+  return {
+    w: positiveOr(x1 - x0, 400),
+    h: positiveOr(y1 - y0, 200),
+    dx: Number.isFinite((x0 + x1) / 2) ? (x0 + x1) / 2 : 0,
+    dy: Number.isFinite((y0 + y1) / 2) ? (y0 + y1) / 2 : 0
+  };
+}
+function partRenderSize(part) {
+  const g = partFrameGeometry(part);
+  return { w: g.w, h: g.h };
+}
+function partDrawsInDiagram(part) {
+  const readouts = part.readouts;
+  if (!Array.isArray(readouts) || readouts.length === 0) return true;
+  const g = partFrameGeometry(part);
+  if (!(g.w > 0) || !(g.h > 0)) return true;
+  const ratio = g.boxW / g.w * (g.boxH / g.h);
+  if (!Number.isFinite(ratio)) return true;
+  return ratio >= 0.01;
+}
+function partBoxInFrame(part) {
+  const g = partFrameGeometry(part);
+  return { w: g.boxW, h: g.boxH, left: g.left, top: g.top };
+}
+var PART_FRAME_CACHE = /* @__PURE__ */ new WeakMap();
+function partFrameGeometry(part) {
+  const cached = PART_FRAME_CACHE.get(part);
+  if (cached) return cached;
+  const fallback = { w: 400, h: 200, left: 0, top: 0, boxW: 400, boxH: 200 };
+  let out = fallback;
+  if (countDiagramElements(part) <= MAX_INPUT_ELEMENTS) {
+    try {
+      const own = layout(part);
+      const vb = own.viewBox;
+      const w = positiveOr(vb.w, 400);
+      const h = positiveOr(vb.h, 200);
+      if (own.nodes.length === 0) {
+        out = { w, h, left: 0, top: 0, boxW: w, boxH: h };
+      } else {
+        let x0 = Infinity;
+        let y0 = Infinity;
+        let x1 = -Infinity;
+        let y1 = -Infinity;
+        for (const n of own.nodes) {
+          x0 = Math.min(x0, n.cx - n.w / 2);
+          x1 = Math.max(x1, n.cx + n.w / 2);
+          y0 = Math.min(y0, n.cy - n.h / 2);
+          y1 = Math.max(y1, n.cy + n.h / 2);
+        }
+        const left = x0 - vb.x;
+        const top = y0 - vb.y;
+        out = {
+          w,
+          h,
+          left: Number.isFinite(left) ? left : 0,
+          top: Number.isFinite(top) ? top : 0,
+          boxW: positiveOr(x1 - x0, w),
+          boxH: positiveOr(y1 - y0, h)
+        };
+      }
+    } catch {
+      out = fallback;
+    }
+  }
+  PART_FRAME_CACHE.set(part, out);
+  return out;
+}
+function partFrameExtent(part, targetW, targetH) {
+  const box = partExtent(part, targetW, targetH);
+  const geom = partFrameGeometry(part);
+  const t = partTargetScale(part, targetW, targetH);
+  const frame = {
+    w: geom.w * t.x,
+    h: geom.h * t.y,
+    left: geom.left * t.x,
+    top: geom.top * t.y
+  };
+  const frameDx = box.dx + frame.w / 2 - frame.left - box.w / 2;
+  const frameDy = box.dy + frame.h / 2 - frame.top - box.h / 2;
+  const x0 = Math.min(frameDx - frame.w / 2, box.dx - box.w / 2);
+  const x1 = Math.max(frameDx + frame.w / 2, box.dx + box.w / 2);
+  const y0 = Math.min(frameDy - frame.h / 2, box.dy - box.h / 2);
+  const y1 = Math.max(frameDy + frame.h / 2, box.dy + box.h / 2);
+  return {
+    w: positiveOr(x1 - x0, frame.w),
+    h: positiveOr(y1 - y0, frame.h),
+    dx: Number.isFinite((x0 + x1) / 2) ? (x0 + x1) / 2 : frameDx,
+    dy: Number.isFinite((y0 + y1) / 2) ? (y0 + y1) / 2 : frameDy
+  };
+}
+function partVisualSize(part, targetW, targetH) {
+  const e = partExtent(part, targetW, targetH);
+  return { w: e.w, h: e.h };
+}
+var PARTS_PER_ROW = 3;
+var PARTS_GAP = 120;
+var STACK_PITCH = 280;
+function partsGridCenters(baseNodeCount, items) {
+  const out = /* @__PURE__ */ new Map();
+  if (items.length === 0) return out;
+  const safeCount = Number.isSafeInteger(baseNodeCount) && baseNodeCount >= 0 ? baseNodeCount : 0;
+  const top = safeCount * STACK_PITCH + PARTS_GAP * 2;
+  const seen = /* @__PURE__ */ new Set();
+  const unique = items.filter((i) => {
+    if (seen.has(i.id)) return false;
+    seen.add(i.id);
+    return true;
+  });
+  const cellW = maxOf(
+    unique.map((i) => positiveOr(i.w, 400)),
+    400
+  );
+  const rowTops = [];
+  {
+    let y = top;
+    for (let i = 0; i < unique.length; i += PARTS_PER_ROW) {
+      rowTops.push(y);
+      const rowH = maxOf(
+        unique.slice(i, i + PARTS_PER_ROW).map((x) => positiveOr(x.h, 200)),
+        200
+      );
+      y += rowH + PARTS_GAP;
+    }
+  }
+  unique.forEach((item, i) => {
+    const col = i % PARTS_PER_ROW;
+    const row = Math.floor(i / PARTS_PER_ROW);
+    const cx = col * (cellW + PARTS_GAP) + cellW / 2;
+    const cy = (rowTops[row] ?? top) + positiveOr(item.h, 200) / 2;
+    if (!Number.isFinite(cx) || !Number.isFinite(cy)) return;
+    out.set(item.id, { cx, cy });
+  });
+  return out;
+}
+function partsBudget(target, partsActors, partsCatalog) {
+  const accepted = /* @__PURE__ */ new Set();
+  let used = countDiagramElements(target);
+  partsActors.forEach((a, i) => {
+    const part = lookupPart(partsCatalog, a.partId);
+    if (part === void 0) return;
+    const cost = countDiagramElements(part);
+    if (used + cost > MAX_INPUT_ELEMENTS) return;
+    used += cost;
+    accepted.add(i);
+  });
+  return accepted;
+}
+function partGridCenters(target, doc, partsCatalog, accepted, acceptedFrom) {
+  const partsActors = doc.actors.filter((a) => a.partId !== void 0);
+  const autoActors = partsActors.filter(
+    (a) => a.posX === void 0 && a.posY === void 0 && a.posRel === void 0
+  );
+  if (autoActors.length === 0) return /* @__PURE__ */ new Map();
+  const otherActorNames = new Set(
+    doc.actors.filter((a) => a.partId === void 0).map((a) => a.name)
+  );
+  const partsActorNames = new Set(
+    partsActors.map((a) => a.name).filter((n) => !otherActorNames.has(n))
+  );
+  const sharedLaneIds = new Set(
+    partsActors.map((a) => a.lane).filter((l) => l !== void 0)
+  );
+  const partsLaneIds = /* @__PURE__ */ new Set();
+  for (const l of target.lanes) {
+    if (l.label === void 0) continue;
+    if (!partsActorNames.has(l.label)) continue;
+    if (sharedLaneIds.has(l.id)) continue;
+    partsLaneIds.add(l.id);
+  }
+  const baseNodes = target.nodes.filter(
+    (n) => !partsActorNames.has(n.title) && !partsLaneIds.has(n.lane)
+  );
+  const acceptedNames = accepted === void 0 || acceptedFrom === void 0 ? void 0 : new Set(acceptedFrom.filter((_, i) => accepted.has(i)).map((a) => a.name));
+  const placedActors = autoActors.filter(
+    (a) => lookupPart(partsCatalog, a.partId) !== void 0 && (acceptedNames === void 0 || acceptedNames.has(a.name))
+  );
+  const extents = /* @__PURE__ */ new Map();
+  for (const a of placedActors) {
+    const part = lookupPart(partsCatalog, a.partId);
+    const t = partTargetSize(part, a.posW, a.posH, a.scale);
+    extents.set(a.name, partFrameExtent(part, t.w, t.h));
+  }
+  const centers = partsGridCenters(
+    baseNodes.length,
+    placedActors.map((a) => ({ id: a.name, ...extents.get(a.name) }))
+  );
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, c] of centers) {
+    const e = extents.get(name);
+    out.set(name, { cx: c.cx - e.dx, cy: c.cy - e.dy });
+  }
+  return out;
+}
+function partSizes(doc, partsCatalog) {
+  const out = /* @__PURE__ */ new Map();
+  for (const a of doc.actors) {
+    if (a.partId === void 0) continue;
+    const part = lookupPart(partsCatalog, a.partId);
+    if (part) {
+      const t = partTargetSize(part, a.posW, a.posH, a.scale);
+      out.set(a.name, partExtent(part, t.w, t.h));
+    }
+  }
+  return out;
+}
+function partBoxes(target, doc, partsCatalog) {
+  const grid = partGridCenters(target, doc, partsCatalog);
+  const out = /* @__PURE__ */ new Map();
+  for (const a of doc.actors) {
+    if (a.partId === void 0) continue;
+    const part = lookupPart(partsCatalog, a.partId);
+    if (!part) continue;
+    const t = partTargetSize(part, a.posW, a.posH, a.scale);
+    const size = partExtent(part, t.w, t.h);
+    const placed = a.posX !== void 0 && a.posY !== void 0 ? { cx: a.posX, cy: a.posY } : grid.get(a.name);
+    if (!placed) continue;
+    out.set(a.name, { cx: placed.cx + size.dx, cy: placed.cy + size.dy, w: size.w, h: size.h });
+  }
+  return out;
+}
+function cleanupPlaceholderActor(target, doc, a) {
+  const aliasSlug = slugify(a.name);
+  const ownedLaneIds = /* @__PURE__ */ new Set();
+  if (doc.type === "sequence" || doc.type === "solidity") {
+    for (const l of target.lanes) {
+      if (a.lane !== void 0 && l.id === a.lane) continue;
+      if (l.label === a.name) ownedLaneIds.add(l.id);
+    }
+  }
+  const ownedNodeIds = /* @__PURE__ */ new Set();
+  for (const n of target.nodes) {
+    if (ownedLaneIds.has(n.lane)) ownedNodeIds.add(n.id);
+  }
+  const matchesAliasSlug = (id) => {
+    if (id === aliasSlug) return true;
+    if (id.startsWith(`${aliasSlug}-`)) return true;
+    if (/^s\d+-/.test(id) && id.endsWith(`-${aliasSlug}`)) return true;
+    return false;
+  };
+  const relatedToActor = (id) => ownedLaneIds.size > 0 ? ownedNodeIds.has(id) : matchesAliasSlug(id);
+  target.nodes = target.nodes.filter((n) => !relatedToActor(n.id));
+  const removedEdgeIds = /* @__PURE__ */ new Set();
+  target.edges = target.edges.filter((e) => {
+    const drop = relatedToActor(e.from) || relatedToActor(e.to);
+    if (drop) removedEdgeIds.add(e.id);
+    return !drop;
+  });
+  if (doc.type === "sequence" || doc.type === "solidity") {
+    target.lanes = target.lanes.filter((l) => {
+      if (a.lane !== void 0 && l.id === a.lane) return true;
+      if (l.label === a.name) return false;
+      if (l.id === aliasSlug) return false;
+      return true;
+    });
+  }
+  for (const phase of target.phases) {
+    phase.activate = phase.activate.filter((id) => !relatedToActor(id) && !removedEdgeIds.has(id));
+  }
+}
+function mergePartsFromActors(target, doc, partsCatalog, onNotice) {
+  const partsActors = doc.actors.filter((a) => a.partId !== void 0);
+  if (partsActors.length === 0) return target;
+  if (!partsCatalog) {
+    if (typeof console !== "undefined" && console.warn) {
+      const names = partsActors.map((a) => `${a.name} (kind: ${a.partId ?? "?"})`).join(", ");
+      console.warn(`[dragon] parts kind actors detected but no partsCatalog provided: ${names}`);
+    }
+    return target;
+  }
+  const budget = partsBudget(target, partsActors, partsCatalog);
+  const gridCenters = partGridCenters(target, doc, partsCatalog, budget, partsActors);
+  for (const [actorIndex, actor] of partsActors.entries()) {
+    const partId = actor.partId;
+    if (typeof partId !== "string" || partId.length === 0) continue;
+    const found = lookupPartRaw(partsCatalog, partId);
+    if (found !== void 0 && !budget.has(actorIndex)) {
+      const overOne = !partIsMeasurable(found);
+      onNotice?.({
+        kind: "part-not-drawn",
+        actor: actor.name,
+        line: 0,
+        message: `"${actor.name}" (${partId}) \u306F\u5927\u304D\u3059\u304E\u308B\u305F\u3081\u53D6\u308A\u8FBC\u307F\u307E\u305B\u3093\u3002`,
+        hint: overOne ? `\u8981\u7D20\u6570\u304C\u4E0A\u9650 (${MAX_INPUT_ELEMENTS}) \u3092\u8D85\u3048\u3066\u3044\u307E\u3059` : `\u56F3\u5168\u4F53\u306E\u8981\u7D20\u6570\u304C\u4E0A\u9650 (${MAX_INPUT_ELEMENTS}) \u3092\u8D85\u3048\u307E\u3059`
+      });
+      cleanupPlaceholderActor(target, doc, actor);
+      continue;
+    }
+    const part = found;
+    if (!part) {
+      if (typeof console !== "undefined" && console.warn) {
+        console.warn(`[dragon] parts kind "${partId}" not found in partsCatalog (actor: ${actor.name})`);
+      }
+      continue;
+    }
+    cleanupPlaceholderActor(target, doc, actor);
+    const merged = applyColorHex(part, actor.colorHex, actor.stateOverride ?? {});
+    let placeX = actor.posX;
+    let placeY = actor.posY;
+    if (placeX === void 0 && placeY === void 0) {
+      const center = gridCenters.get(actor.name);
+      placeX = center?.cx;
+      placeY = center?.cy;
+    }
+    const written = new Set(actor.scaleKeys ?? []);
+    if (written.size > 0) {
+      const clashed = (part.states ?? []).find((st) => written.has(String(st.id ?? "")));
+      if (clashed) {
+        onNotice?.({
+          kind: "scale-reserved",
+          actor: actor.name,
+          line: actor.pos?.line ?? 0,
+          message: `"${clashed.id}" \u306F\u898B\u672C\u306E\u5927\u304D\u3055\u3092\u5909\u3048\u308B\u9805\u76EE\u3068\u3057\u3066\u6271\u3044\u307E\u3057\u305F (${clashed.id} \u3068\u3044\u3046\u540D\u524D\u306E\u72B6\u614B\u306F\u5909\u3048\u3066\u3044\u307E\u305B\u3093)`,
+          hint: `\u72B6\u614B\u3092\u5909\u3048\u305F\u3044\u6642\u306F \`state: { ${clashed.id}: ... }\` \u3068\u66F8\u304F`
+        });
+      }
+    }
+    const t = partTargetSize(part, actor.posW, actor.posH, actor.scale);
+    mergePartIntoDiagram(target, part, actor.name, merged, actor.lane, placeX, placeY, t.w, t.h, onNotice, actor.pos?.line ?? 0);
+  }
+  return target;
+}
+function resolveStateOverride(original, override) {
+  if (override === void 0) return { initial: original, rejected: false };
+  if (isColorValue(original) && !isColorValue(override)) return { initial: original, rejected: true };
+  return { initial: override, rejected: false };
+}
+function applyColorHex(part, colorHex, stateOverride) {
+  if (!colorHex) return stateOverride;
+  const colorStates = part.states.filter((st) => isColorValue(st.initial));
+  if (colorStates.length === 0) return stateOverride;
+  const out = { ...stateOverride };
+  for (const st of colorStates) {
+    if (out[st.id] === void 0) out[st.id] = colorHex;
+  }
+  return out;
+}
+function mergePartIntoDiagram(target, part, alias, stateOverride, laneMapping, offsetX, offsetY, targetW, targetH, onNotice, noticeLine = 0) {
+  const prefix = (id) => `${alias}__${id}`;
+  const stateIdSet = new Set(part.states.map((s) => s.id));
+  const rewriteTemplate = (s) => {
+    if (!s) return s;
+    return s.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (m, name) => {
+      return stateIdSet.has(name) ? `{${prefix(name)}}` : m;
+    });
+  };
+  const targetLaneId = laneMapping;
+  const laneIdMap = /* @__PURE__ */ new Map();
+  const PARTS_LANE_GAP = 300;
+  const existingLaneMaxX = target.lanes.length > 0 ? Math.max(...target.lanes.map((l) => (l.x ?? 0) + l.width)) : 0;
+  const partLaneGeom = /* @__PURE__ */ new Map();
+  for (const l of part.lanes) {
+    partLaneGeom.set(l.id, {
+      x: typeof l.x === "number" && Number.isFinite(l.x) ? l.x : 0,
+      w: positiveOr(l.width, 400)
+    });
+  }
+  const laneXs = [...partLaneGeom.values()].map((g) => g.x);
+  const laneRights = [...partLaneGeom.values()].map((g) => g.x + g.w);
+  const partMinLaneX = minOf(laneXs, 0);
+  const partMaxLaneRight = maxOf(laneRights, 400);
+  const rawBboxW = partMaxLaneRight - partMinLaneX;
+  const partsBboxW = rawBboxW > 0 ? rawBboxW : 1;
+  const rawLaneScaleX = targetW !== void 0 && targetW > 0 ? targetW / partsBboxW : 1;
+  const laneScaleX = Number.isFinite(rawLaneScaleX) && rawLaneScaleX > 0 ? rawLaneScaleX : 1;
+  const partOrigBboxCenterX = partMinLaneX + partsBboxW / 2;
+  const dropCenterX = offsetX !== void 0 ? offsetX : existingLaneMaxX + PARTS_LANE_GAP + partsBboxW * laneScaleX / 2;
+  const mapLaneX = (x) => (x - partOrigBboxCenterX) * laneScaleX + dropCenterX;
+  for (const laneOrig of part.lanes) {
+    if (targetLaneId) {
+      laneIdMap.set(laneOrig.id, targetLaneId);
+    } else {
+      const newLaneId = prefix(laneOrig.id);
+      laneIdMap.set(laneOrig.id, newLaneId);
+      const geom = partLaneGeom.get(laneOrig.id) ?? { x: 0, w: 400 };
+      target.lanes.push({
+        ...laneOrig,
+        id: newLaneId,
+        label: laneOrig.label ?? alias,
+        x: mapLaneX(geom.x),
+        width: geom.w * laneScaleX
+      });
+    }
+  }
+  const STACK_ISOLATION_OFFSET = 1e3;
+  const shouldForcePos = offsetX !== void 0 || offsetY !== void 0;
+  const targetMaxStack = shouldForcePos && target.nodes.length > 0 ? Math.max(...target.nodes.map((n) => n.stack ?? 0)) : 0;
+  const stackShiftBase = shouldForcePos ? targetMaxStack + STACK_ISOLATION_OFFSET : 0;
+  const STACK_PITCH_APPROX = 220;
+  const partStacks = part.nodes.map(
+    (n) => typeof n.stack === "number" && Number.isFinite(n.stack) ? n.stack : 0
+  );
+  const minStack = partStacks.length > 0 ? Math.min(...partStacks) : 0;
+  const maxStack = partStacks.length > 0 ? Math.max(...partStacks) : 0;
+  const partCenterStack = (minStack + maxStack) / 2;
+  const partOrigH = Math.max(1, (maxStack - minStack + 1) * STACK_PITCH_APPROX);
+  const scaleX = laneScaleX;
+  const rawScaleY = targetH !== void 0 && targetH > 0 ? targetH / partOrigH : 1;
+  const scaleY = Number.isFinite(rawScaleY) && rawScaleY > 0 ? rawScaleY : 1;
+  for (const nodeOrig of part.nodes) {
+    const mappedLane = laneIdMap.get(nodeOrig.lane) ?? nodeOrig.lane;
+    let newShape = nodeOrig.shape ? deepRewriteStrings(nodeOrig.shape, rewriteTemplate) : void 0;
+    if (newShape && (scaleX !== 1 || scaleY !== 1)) {
+      const shapeScale = Math.min(scaleX, scaleY);
+      const geomKeys = /* @__PURE__ */ new Set(["radius", "outerRadius", "innerRadius", "thickness"]);
+      const scaleGeom = (obj) => {
+        if (obj === null || typeof obj !== "object") return obj;
+        if (Array.isArray(obj)) return obj.map(scaleGeom);
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+          if (geomKeys.has(k) && typeof v === "number") {
+            out[k] = v * shapeScale;
+          } else if (typeof v === "object" && v !== null) {
+            out[k] = scaleGeom(v);
+          } else {
+            out[k] = v;
+          }
+        }
+        return out;
+      };
+      newShape = scaleGeom(newShape);
+    }
+    let nodePosX = nodeOrig.posX !== void 0 ? mapLaneX(nodeOrig.posX) : void 0;
+    let nodePosY = nodeOrig.posY !== void 0 ? nodeOrig.posY + (offsetY ?? 0) : void 0;
+    if (shouldForcePos && nodePosX === void 0) {
+      const geom = partLaneGeom.get(nodeOrig.lane) ?? { x: 0, w: 320 };
+      nodePosX = mapLaneX(geom.x + geom.w / 2);
+    }
+    if (shouldForcePos && nodePosY === void 0) {
+      const stack = nodeOrig.stack ?? 0;
+      nodePosY = (stack - partCenterStack) * STACK_PITCH_APPROX * scaleY + (offsetY ?? 0);
+    }
+    const rawNodeW = nodeOrig.w !== void 0 ? positiveOr(nodeOrig.w, 200) : void 0;
+    const rawNodeH = nodeOrig.h !== void 0 ? positiveOr(nodeOrig.h, 200) : void 0;
+    const nodeW = rawNodeW !== void 0 && (scaleX !== 1 || scaleY !== 1) ? rawNodeW * scaleX : rawNodeW;
+    const nodeH = rawNodeH !== void 0 && (scaleX !== 1 || scaleY !== 1) ? rawNodeH * scaleY : rawNodeH;
+    target.nodes.push({
+      ...nodeOrig,
+      id: prefix(nodeOrig.id),
+      lane: mappedLane,
+      title: rewriteTemplate(nodeOrig.title) ?? nodeOrig.title,
+      subtitle: rewriteTemplate(nodeOrig.subtitle),
+      value: rewriteTemplate(nodeOrig.value),
+      // parts stack を target 側と分離 (D2 fix、 posX/posY 明示との 2 段防御)
+      stack: (nodeOrig.stack ?? 0) + stackShiftBase,
+      ...newShape ? { shape: newShape } : {},
+      ...nodePosX !== void 0 ? { posX: nodePosX } : {},
+      ...nodePosY !== void 0 ? { posY: nodePosY } : {},
+      ...nodeW !== void 0 ? { w: nodeW } : {},
+      ...nodeH !== void 0 ? { h: nodeH } : {}
+    });
+  }
+  for (const stateOrig of part.states) {
+    const { initial, rejected } = resolveStateOverride(stateOrig.initial, stateOverride[stateOrig.id]);
+    if (rejected) {
+      onNotice?.({
+        kind: "state-override-rejected",
+        actor: alias,
+        line: noticeLine,
+        message: `"${alias}" \u306E ${stateOrig.id} \u306B\u66F8\u3044\u305F\u5024\u306F\u8272\u3068\u3057\u3066\u8AAD\u3081\u306A\u3044\u305F\u3081\u4F7F\u3044\u307E\u305B\u3093`,
+        hint: "\u8272\u306F `#ff0000` \u306E\u3088\u3046\u306A\u8272\u756A\u53F7\u304B\u3001 `red` \u306E\u3088\u3046\u306A\u8272\u540D\u3067\u66F8\u304F"
+      });
+    }
+    target.states.push({ id: prefix(stateOrig.id), initial });
+  }
+  for (const edgeOrig of part.edges) {
+    target.edges.push({
+      ...edgeOrig,
+      id: prefix(edgeOrig.id),
+      from: prefix(edgeOrig.from),
+      to: prefix(edgeOrig.to)
+    });
+  }
+  if (part.readouts && part.readouts.length > 0) {
+    if (!target.readouts) target.readouts = [];
+    for (const readoutOrig of part.readouts) {
+      const rewritten = deepRewriteStrings(readoutOrig, rewriteTemplate);
+      target.readouts.push({
+        ...rewritten,
+        id: prefix(rewritten.id)
+      });
+    }
+  }
+  const phaseOptOut = stateOverride["phase"] === false;
+  if (phaseOptOut) {
+    return;
+  }
+  if (target.phases.length === 0) {
+    for (const phaseOrig of part.phases) {
+      target.phases.push({
+        ...phaseOrig,
+        id: prefix(phaseOrig.id),
+        activate: phaseOrig.activate.map(prefix),
+        tweens: phaseOrig.tweens.map((t) => ({ ...t, stateId: prefix(t.stateId) })),
+        sets: phaseOrig.sets.map((s) => ({ ...s, stateId: prefix(s.stateId) }))
+      });
+    }
+  } else {
+    const targetLen = target.phases.length;
+    const partsLen = part.phases.length;
+    const commonLen = Math.min(targetLen, partsLen);
+    for (let i = 0; i < commonLen; i++) {
+      const targetPhase = target.phases[i];
+      const partPhase = part.phases[i];
+      targetPhase.duration = Math.max(targetPhase.duration, partPhase.duration);
+      targetPhase.activate = [...targetPhase.activate, ...partPhase.activate.map(prefix)];
+      targetPhase.tweens = [...targetPhase.tweens, ...partPhase.tweens.map((t) => ({ ...t, stateId: prefix(t.stateId) }))];
+      targetPhase.sets = [...targetPhase.sets, ...partPhase.sets.map((s) => ({ ...s, stateId: prefix(s.stateId) }))];
+    }
+    for (let i = commonLen; i < partsLen; i++) {
+      const phaseOrig = part.phases[i];
+      target.phases.push({
+        ...phaseOrig,
+        id: prefix(phaseOrig.id),
+        activate: phaseOrig.activate.map(prefix),
+        tweens: phaseOrig.tweens.map((t) => ({ ...t, stateId: prefix(t.stateId) })),
+        sets: phaseOrig.sets.map((s) => ({ ...s, stateId: prefix(s.stateId) }))
+      });
+    }
+  }
+}
+function deepRewriteStrings(value, rewrite, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") return rewrite(value) ?? value;
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return value;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((v) => deepRewriteStrings(v, rewrite, seen));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[k] = deepRewriteStrings(v, rewrite, seen);
+  }
+  return out;
+}
+function applyEdgeInlineOptions(diagram2, doc, sourceLines) {
+  const used = /* @__PURE__ */ new Set();
+  const isSeqLike = doc.type === "sequence" || doc.type === "solidity";
+  doc.flow.forEach((s, stepIdx) => {
+    const fromId = slugify(s.from);
+    const toId = slugify(s.to);
+    const target = diagram2.edges.find((e) => {
+      if (used.has(e.id)) return false;
+      if (isSeqLike) {
+        return (e.from === `s${stepIdx}-${fromId}` || e.from === fromId) && (e.to === `s${stepIdx}-${toId}` || e.from === e.to);
+      }
+      return e.from === fromId && e.to === toId;
+    });
+    if (!target) return;
+    used.add(target.id);
+    sourceLines?.set(target.id, s.pos.line);
+    if (s.guard !== void 0) {
+      target.guard = s.guard;
+      if (doc.type === "state" && target.sub === void 0) target.sub = s.guard;
+    }
+    if (s.cardinality !== void 0) {
+      target.cardinality = s.cardinality;
+      if (doc.type === "er" && !target.label.includes(s.cardinality)) {
+        target.label = target.label ? `${target.label} (${s.cardinality})` : `(${s.cardinality})`;
+      }
+    }
+    if (s.labelOffsetX !== void 0) target.labelOffsetX = s.labelOffsetX;
+    if (s.labelOffsetY !== void 0) target.labelOffsetY = s.labelOffsetY;
+  });
+}
+var DRAWABLE_KINDS = new Set(NODE_KINDS);
+var KIND_ALIAS = {
+  eoa: "shape-wallet",
+  wallet: "shape-wallet",
+  multisig: "signer",
+  contract: "shape-smart-contract",
+  proxy: "shape-smart-contract",
+  library: "shape-code-block",
+  interface: "shape-code-block"
+};
+var SINGLE_BOX_KINDS = /* @__PURE__ */ new Set([
+  "chart-pie",
+  "chart-line",
+  "chart-bar",
+  "gantt-timeline",
+  "mind-map",
+  "mind-radial",
+  "funnel-stages",
+  "quadrant-matrix",
+  "tree-hierarchy",
+  "journey-map"
+]);
+function drawableKind(kind) {
+  if (kind === void 0) return void 0;
+  const mapped = KIND_ALIAS[kind] ?? kind;
+  return DRAWABLE_KINDS.has(mapped) ? mapped : void 0;
+}
+function alignSeqHeaderHeights(diagram2, doc) {
+  if (doc.type !== "sequence" && doc.type !== "solidity") return;
+  const isEnd = (n) => n.id === `${n.lane}-header` || n.id === `${n.lane}-footer`;
+  const ends = diagram2.nodes.filter(isEnd);
+  if (ends.length === 0) return;
+  const auto = ends.filter((n) => n.posH === void 0);
+  if (auto.length === 0) return;
+  const tallest = Math.max(...auto.map((n) => n.h ?? 0));
+  if (tallest <= 0) return;
+  for (const n of auto) n.h = tallest;
+}
+var LABEL_MIN_H = {
+  // `shape-` のうち、 高さを上げれば下のはみ出しが消える 4 種 (#1067)。 値は「収まる最小の高さ」
+  // で、 1 手前 (値 - 1) では 0.9-1 はみ出すことを実測した
+  "shape-person": 228,
+  // 名札 72 で下へ 155.9
+  "shape-server-rack": 166,
+  // 94
+  "shape-website": 98,
+  // 26
+  "shape-warehouse": 79
+  // 7
+};
+var LABEL_NEVER_FITS = /* @__PURE__ */ new Set([
+  // 左右にはみ出す 24 種。 横幅は高さで変わらないため直らない
+  "shape-api-gateway",
+  "shape-atm",
+  "shape-auditor",
+  "shape-bank",
+  "shape-bitcoin-chain",
+  "shape-blockchain",
+  "shape-blockchain-block",
+  "shape-blockchain-node",
+  "shape-brokerage",
+  "shape-code-block",
+  "shape-customer-service",
+  "shape-ethereum-chain",
+  "shape-hexagon",
+  "shape-kanban-card",
+  "shape-lawyer",
+  "shape-network-node",
+  "shape-nft",
+  "shape-notary",
+  "shape-regulator",
+  "shape-satellite",
+  "shape-smart-contract",
+  "shape-terminal",
+  "shape-trader",
+  "shape-trust-bank",
+  // 下のはみ出しが高さに依らない 6 種
+  "shape-cylinder",
+  "shape-diamond",
+  "shape-file",
+  "shape-folder",
+  "shape-mobile-device",
+  "shape-stack",
+  // 上へ出る絵が名札の大きさでは読めない。 `#1067` では「上は何ともぶつからない」 として残したが、
+  // 実際には絵が小さく潰れて名前と重なり、 横に並べた時も 1 本だけ頭が浮く (user 実機確認)
+  "shape-wallet"
+]);
+function hasAuthoredText(n) {
+  if (n.subtitle !== void 0 || n.eyebrow !== void 0 || n.value !== void 0) return true;
+  return rendersRows(n.kind) && (n.rows?.length ?? 0) > 0;
+}
+function dropUnfittableEndKinds(diagram2, doc) {
+  if (doc.type !== "sequence" && doc.type !== "solidity") return;
+  const ends = /* @__PURE__ */ new Map();
+  for (const n of diagram2.nodes) {
+    if (n.id !== `${n.lane}-header` && n.id !== `${n.lane}-footer`) continue;
+    const pair = ends.get(n.lane);
+    if (pair === void 0) ends.set(n.lane, [n]);
+    else pair.push(n);
+  }
+  for (const pair of ends.values()) {
+    if (pair.some(hasAuthoredText)) continue;
+    const \u53CE\u307E\u3089\u306A\u3044 = pair.some((n) => {
+      if (LABEL_NEVER_FITS.has(n.kind)) return true;
+      const need = LABEL_MIN_H[n.kind];
+      if (need === void 0) return false;
+      const h = (n.posX !== void 0 && n.posY !== void 0 ? n.posH : void 0) ?? n.h;
+      return h !== void 0 && h < need;
+    });
+    if (!\u53CE\u307E\u3089\u306A\u3044) continue;
+    for (const n of pair) {
+      if (LABEL_NEVER_FITS.has(n.kind) || LABEL_MIN_H[n.kind] !== void 0) n.kind = "card";
+    }
+  }
+}
+function fillFlowEdgeSources(diagram2, doc, sourceLines) {
+  if (doc.type !== "flow") return;
+  if (doc.animate && doc.animate.phases.length > 0) return;
+  diagram2.edges.forEach((e, idx) => {
+    const to = doc.actors[idx + 1];
+    if (to === void 0) return;
+    const step = doc.flow.find((s) => s.to === to.name);
+    if (step === void 0) return;
+    sourceLines.set(e.id, step.pos.line);
+  });
+}
+function applyGroupContainers(diagram2, doc) {
+  if (!doc.groups || Object.keys(doc.groups).length === 0) return;
+  for (const [id, g] of Object.entries(doc.groups)) {
+    const containerId = `group-${id}`;
+    if (diagram2.lanes.some((l) => l.id === containerId)) continue;
+    diagram2.lanes.push({
+      id: containerId,
+      width: 800,
+      label: g.label ?? id,
+      contain: true,
+      // 束ねる lane 群に重ねて描く枠。 横に並べる lane ではないので、 engine の間隔調整
+      // (lane を詰めた分を幅で埋め合わせる処理) の対象から外す。
+      role: "overlay"
+    });
+  }
+}
+function compileSolidity(doc) {
+  const kindOrder = {
+    eoa: 0,
+    actor: 0,
+    multisig: 0,
+    signer: 0,
+    wallet: 0,
+    contract: 1,
+    proxy: 1,
+    library: 1,
+    interface: 1,
+    storage: 2,
+    event: 3
+  };
+  const sorted = [...doc.actors].sort(
+    (a, b) => (kindOrder[a.kind] ?? 5) - (kindOrder[b.kind] ?? 5)
+  );
+  const sortedDoc = { ...doc, actors: sorted };
+  return compileSequence(sortedDoc);
+}
+function compileGantt(doc) {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const CHART_W = 720;
+  b.lane("gantt", { width: CHART_W, label: doc.title });
+  const \u76EE\u76DB\u308A = [];
+  const \u76EE\u76DB\u308A\u306A\u3057 = [];
+  const \u30BF\u30B9\u30AF = [];
+  for (const a of doc.actors) {
+    const label = (a.value ?? a.subtitle ?? "").trim();
+    if (label === "") {
+      \u76EE\u76DB\u308A\u306A\u3057.push(a.name);
+      continue;
+    }
+    if (!\u76EE\u76DB\u308A.includes(label)) \u76EE\u76DB\u308A.push(label);
+    \u30BF\u30B9\u30AF.push({ name: a.name, label, ...a.tone !== void 0 ? { tone: a.tone } : {} });
+  }
+  if (\u76EE\u76DB\u308A\u306A\u3057.length > 0 && typeof console !== "undefined" && console.warn) {
+    console.warn(
+      `[dragon] type: gantt \u3067\u6642\u671F\u3092\u8AAD\u3081\u306A\u3044\u9805\u76EE\u304C\u3042\u308A\u307E\u3059 (\u5E2F\u306B\u8F09\u305B\u307E\u305B\u3093): ${\u76EE\u76DB\u308A\u306A\u3057.join(", ")}\u3002 \`- \u8A2D\u8A08: "Q1"\` \u306E\u5F62\u3067\u66F8\u3044\u3066\u304F\u3060\u3055\u3044`
+    );
+  }
+  const \u30BF\u30B9\u30AF\u540D = new Set(\u30BF\u30B9\u30AF.map((t) => t.name));
+  const \u4F9D\u5B58\u5143 = /* @__PURE__ */ new Map();
+  const \u5C45\u306A\u3044 = [];
+  const \u88C5\u98FE\u3064\u304D = [];
+  for (const s of doc.flow) {
+    if (!\u30BF\u30B9\u30AF\u540D.has(s.from) || !\u30BF\u30B9\u30AF\u540D.has(s.to)) {
+      \u5C45\u306A\u3044.push(`${s.from} -> ${s.to}`);
+      continue;
+    }
+    \u4F9D\u5B58\u5143.set(s.to, s.from);
+    if ((s.label ?? "") !== "" || (s.sub ?? "") !== "" || s.tone !== void 0 || s.style !== void 0) {
+      \u88C5\u98FE\u3064\u304D.push(`${s.from} -> ${s.to}`);
+    }
+  }
+  if (\u5C45\u306A\u3044.length > 0 && typeof console !== "undefined" && console.warn) {
+    console.warn(
+      `[dragon] type: gantt \u3067\u4F9D\u5B58\u3092\u7D50\u3079\u306A\u3044\u77E2\u5370\u304C\u3042\u308A\u307E\u3059 (\u5C45\u306A\u3044\u9805\u76EE\u304B\u6642\u671F\u306A\u3057): ${\u5C45\u306A\u3044.join(", ")}`
+    );
+  }
+  if (\u88C5\u98FE\u3064\u304D.length > 0 && typeof console !== "undefined" && console.warn) {
+    console.warn(
+      `[dragon] type: gantt \u306E\u77E2\u5370\u306F\u524D\u5F8C\u306E\u95A2\u4FC2\u3060\u3051\u3092\u4F7F\u3044\u307E\u3059 (\u6587\u5B57 / \u8272 / \u7DDA\u7A2E\u306F\u63CF\u3051\u307E\u305B\u3093): ${\u88C5\u98FE\u3064\u304D.join(", ")}`
+    );
+  }
+  const CHART_H = Math.max(360, 48 * \u30BF\u30B9\u30AF.length + 96);
+  b.node(`${slugify(doc.title)}-chart`, {
+    lane: "gantt",
+    stack: 0,
+    kind: "gantt-timeline",
+    title: doc.title,
+    w: CHART_W,
+    h: CHART_H,
+    ganttData: \u30BF\u30B9\u30AF.map((t) => {
+      const idx = \u76EE\u76DB\u308A.indexOf(t.label);
+      const from = \u4F9D\u5B58\u5143.get(t.name);
+      return {
+        id: slugify(t.name),
+        title: t.name,
+        startIdx: idx,
+        endIdx: idx,
+        startLabel: t.label,
+        endLabel: t.label,
+        ...from !== void 0 ? { dependsOn: slugify(from) } : {},
+        ...t.tone !== void 0 ? { tone: t.tone } : {}
+      };
+    })
+  });
+  return b.build();
+}
+function compileClass(doc) {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const CLASS_W = 400;
+  if (doc.actors.length === 0) return b.build();
+  b.lane("class-stack", { width: CLASS_W, label: doc.title });
+  doc.actors.forEach((a, idx) => {
+    const nodeId = slugify(a.name);
+    b.node(nodeId, {
+      lane: "class-stack",
+      stack: idx,
+      kind: "storage",
+      title: a.name,
+      w: CLASS_W
+    });
+  });
+  for (const s of doc.flow) {
+    const fromId = slugify(s.from);
+    const toId = slugify(s.to);
+    b.edge(fromId, toId, {
+      label: s.label,
+      ...s.sub ? { sub: s.sub } : {},
+      ...s.tone ? { tone: s.tone } : {},
+      ...s.style ? { style: s.style } : {}
+    });
+  }
+  return b.build();
+}
+function parseShareValue(raw) {
+  if (raw === void 0) return null;
+  const m = raw.trim().match(/^(\d+(?:\.\d+)?)\s*%?$/);
+  if (m === null) return null;
+  const v = Number(m[1]);
+  return Number.isFinite(v) ? v : null;
+}
+function compilePie(doc) {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const CHART_W = 640;
+  const CHART_H = 320;
+  b.lane("chart", { width: CHART_W + 64, label: doc.title });
+  const data = [];
+  const \u8AAD\u3081\u306A\u3044 = [];
+  for (const a of doc.actors) {
+    const value = parseShareValue(a.value ?? a.subtitle);
+    if (value === null) {
+      \u8AAD\u3081\u306A\u3044.push(a.name);
+      continue;
+    }
+    data.push({ label: a.name, value, ...a.tone !== void 0 ? { tone: a.tone } : {} });
+  }
+  if (\u8AAD\u3081\u306A\u3044.length > 0 && typeof console !== "undefined" && console.warn) {
+    console.warn(
+      `[dragon] type: pie \u3067\u5272\u5408\u3092\u8AAD\u3081\u306A\u3044\u9805\u76EE\u304C\u3042\u308A\u307E\u3059 (\u5186\u306B\u8F09\u305B\u307E\u305B\u3093): ${\u8AAD\u3081\u306A\u3044.join(", ")}\u3002 \`- \u540D\u524D: "45%"\` \u306E\u5F62\u3067\u66F8\u3044\u3066\u304F\u3060\u3055\u3044`
+    );
+  }
+  if (doc.flow.length > 0 && typeof console !== "undefined" && console.warn) {
+    console.warn(
+      `[dragon] type: pie \u3067\u306F\u77E2\u5370\u3092\u63CF\u3051\u307E\u305B\u3093 (${doc.flow.length} \u672C\u3092\u7121\u8996\u3057\u307E\u3057\u305F)\u3002 \u95A2\u4FC2\u3092\u63CF\u304F\u306A\u3089 type: flow \u3092\u4F7F\u3063\u3066\u304F\u3060\u3055\u3044`
+    );
+  }
+  b.node(`${slugify(doc.title)}-chart`, {
+    lane: "chart",
+    stack: 0,
+    kind: "chart-pie",
+    title: doc.title,
+    w: CHART_W,
+    h: CHART_H,
+    chartData: data
+  });
+  return b.build();
+}
+function \u6BB5\u3092\u8AAD\u307F\u53D6\u308B(subtitle) {
+  const \u5143 = (subtitle ?? "").trim();
+  const m = \u5143.match(/^L([123])(?![0-9A-Za-z])/i);
+  if (m === null) return { \u6BB5: 1, \u8AAC\u660E: subtitle };
+  const \u6B8B\u308A = \u5143.slice(m[0].length).replace(/^[:：\s]+/, "").trim();
+  return { \u6BB5: Number(m[1]), \u8AAC\u660E: \u6B8B\u308A === "" ? void 0 : \u6B8B\u308A };
+}
+function compileC4(doc) {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const LANE_W = 400;
+  const LANE_GAP = 80;
+  const \u6BB5\u306E\u540D\u524D = { 1: "System Context", 2: "Container", 3: "Component" };
+  const \u5272\u5F53 = doc.actors.map((a, idx) => {
+    const { \u6BB5, \u8AAC\u660E } = \u6BB5\u3092\u8AAD\u307F\u53D6\u308B(a.subtitle);
+    return { \u6BB5, \u8AAC\u660E, id: slugify(a.name), actor: a };
+  });
+  const \u4F7F\u3046\u6BB5 = [1, 2, 3].filter((lv) => \u5272\u5F53.some((x) => x.\u6BB5 === lv));
+  \u4F7F\u3046\u6BB5.forEach((lv, i) => {
+    b.lane(`c4-l${lv}`, {
+      // 空の段を飛ばした分だけ左に詰める。 飛ばした位置に隙間を残すと、 やはり
+      // 「何かが抜けている」 ように見える
+      x: i * (LANE_W + LANE_GAP),
+      width: LANE_W,
+      label: \u6BB5\u306E\u540D\u524D[lv],
+      contain: true
+    });
+  });
+  const stackPerLane = { "c4-l1": 0, "c4-l2": 0, "c4-l3": 0 };
+  for (const x of \u5272\u5F53) {
+    const lid = `c4-l${x.\u6BB5}`;
+    const stack = stackPerLane[lid];
+    stackPerLane[lid] = stack + 1;
+    b.node(x.id, {
+      lane: lid,
+      stack,
+      kind: x.actor.kind,
+      title: x.actor.name
+    });
+  }
+  for (const s of doc.flow) {
+    const fromId = slugify(s.from);
+    const toId = slugify(s.to);
+    b.edge(fromId, toId, {
+      label: s.label,
+      ...s.sub ? { sub: s.sub } : {},
+      ...s.tone ? { tone: s.tone } : {},
+      ...s.style ? { style: s.style } : {}
+    });
+  }
+  return b.build();
+}
+function compileMind(doc) {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const LEAF_W = 280;
+  const ROOT_W = 320;
+  const GAP = 80;
+  const \u679D\u306E\u6570 = Math.max(0, doc.actors.length - 1);
+  const \u5DE6\u306B\u7F6E\u304F\u6570 = Math.ceil(\u679D\u306E\u6570 / 2);
+  const \u53F3\u306B\u7F6E\u304F\u6570 = \u679D\u306E\u6570 - \u5DE6\u306B\u7F6E\u304F\u6570;
+  const \u5DE6\u3092\u4F7F\u3046 = \u5DE6\u306B\u7F6E\u304F\u6570 > 0;
+  const \u53F3\u3092\u4F7F\u3046 = \u53F3\u306B\u7F6E\u304F\u6570 > 0;
+  if (doc.actors.length === 0) return b.build();
+  let x = 0;
+  if (\u5DE6\u3092\u4F7F\u3046) {
+    b.lane("mind-left", { x, width: LEAF_W, label: "" });
+    x += LEAF_W + GAP;
+  }
+  b.lane("mind-center", { x, width: ROOT_W, label: doc.title });
+  x += ROOT_W + GAP;
+  if (\u53F3\u3092\u4F7F\u3046) {
+    b.lane("mind-right", { x, width: LEAF_W, label: "" });
+  }
+  const root = doc.actors[0];
+  const rootId = slugify(root.name);
+  const leafCount = doc.actors.length - 1;
+  const rootStack = Math.floor(leafCount / 2);
+  b.node(rootId, {
+    lane: "mind-center",
+    stack: rootStack,
+    kind: "card",
+    title: root.name,
+    w: ROOT_W
+  });
+  const stackLeft = { v: 0 };
+  const stackRight = { v: 0 };
+  doc.actors.slice(1).forEach((a, i) => {
+    const isLeft = i % 2 === 0;
+    const lid = isLeft ? "mind-left" : "mind-right";
+    const counter = isLeft ? stackLeft : stackRight;
+    const nodeId = slugify(a.name);
+    b.node(nodeId, {
+      lane: lid,
+      stack: counter.v,
+      kind: "card",
+      title: a.name,
+      w: LEAF_W
+    });
+    counter.v += 1;
+  });
+  if (doc.flow.length === 0 && doc.actors.length > 1) {
+    doc.actors.slice(1).forEach((a) => {
+      const leafId = slugify(a.name);
+      b.edge(rootId, leafId, { label: "" });
+    });
+  } else {
+    for (const s of doc.flow) {
+      const fromId = slugify(s.from);
+      const toId = slugify(s.to);
+      b.edge(fromId, toId, {
+        label: s.label,
+        ...s.sub ? { sub: s.sub } : {},
+        ...s.tone ? { tone: s.tone } : {},
+        ...s.style ? { style: s.style } : {}
+      });
+    }
+  }
+  return b.build();
+}
+function applyV05Extensions(diagram2, doc) {
+  const isSeqLike = doc.type === "sequence" || doc.type === "solidity";
+  for (const a of doc.actors) {
+    const dragonSlug = slugify(a.name);
+    let primaryNodes;
+    if (isSeqLike) {
+      const ownedLaneIds = new Set(
+        diagram2.lanes.filter((l) => l.label === a.name).map((l) => l.id)
+      );
+      primaryNodes = ownedLaneIds.size > 0 ? diagram2.nodes.filter((n) => ownedLaneIds.has(n.lane) && n.id === `${n.lane}-header`) : diagram2.nodes.filter((n) => n.id === `${dragonSlug}-header`);
+    } else {
+      primaryNodes = diagram2.nodes.filter((n) => n.id === dragonSlug);
+    }
+    for (const node of primaryNodes) {
+      const \u8AAC\u660E = doc.type === "c4" ? \u6BB5\u3092\u8AAD\u307F\u53D6\u308B(a.subtitle).\u8AAC\u660E : a.subtitle;
+      if (\u8AAC\u660E !== void 0) node.subtitle = \u8AAC\u660E;
+      if (a.eyebrow !== void 0) node.eyebrow = a.eyebrow;
+      if (a.value !== void 0) node.value = a.value;
+      if (a.rows !== void 0) node.rows = a.rows;
+      const drawn = isSeqLike && a.kindWritten !== false ? drawableKind(a.kind) : void 0;
+      if (drawn !== void 0) {
+        node.kind = drawn;
+        const footer = diagram2.nodes.find((n) => n.id === `${node.lane}-footer`);
+        if (footer) footer.kind = drawn;
+      }
+      if (isSeqLike && a.rows !== void 0 && a.rows.length > 0 && rendersRows(a.kind)) {
+        node.h = Math.max(node.h ?? 0, requiredRowsHeight(a.kind, a.rows.length) ?? 0);
+        node.w = Math.max(node.w ?? 0, requiredRowsWidth(a.rows, a.kind));
+      }
+      if (isSeqLike) {
+        if (a.posW !== void 0) node.w = a.posW;
+        if (a.posH !== void 0) node.h = a.posH;
+        const footer = diagram2.nodes.find((n) => n.id === `${node.lane}-footer`);
+        if (footer && a.posW !== void 0) footer.w = a.posW;
+      }
+    }
+  }
+  alignSeqHeaderHeights(diagram2, doc);
+  dropUnfittableEndKinds(diagram2, doc);
+  if (doc.animate && doc.animate.phases.length > 0 && diagram2.phases.length === 0) {
+    injectPhasesFallback(diagram2, doc);
+  }
+  if (doc.lanes) {
+    for (const [id, laneOpt] of Object.entries(doc.lanes)) {
+      const lane = diagram2.lanes.find((l) => l.id === id);
+      if (lane) {
+        if (laneOpt.x !== void 0) lane.x = laneOpt.x;
+        if (laneOpt.width !== void 0) lane.width = laneOpt.width;
+        if (laneOpt.label !== void 0) lane.label = laneOpt.label;
+        if (laneOpt.contain !== void 0) lane.contain = laneOpt.contain;
+        if (laneOpt.lifeline !== void 0) lane.lifeline = laneOpt.lifeline;
+      } else {
+        diagram2.lanes.push({
+          id,
+          x: laneOpt.x ?? 0,
+          width: laneOpt.width ?? 320,
+          label: laneOpt.label,
+          contain: laneOpt.contain,
+          lifeline: laneOpt.lifeline
+        });
+      }
+    }
+  }
+  if (doc.viewport?.laneWidth !== void 0) {
+    for (const lane of diagram2.lanes) {
+      lane.width = doc.viewport.laneWidth;
+    }
+  }
+  if (doc.viewport) {
+    diagram2.viewport = {
+      ...diagram2.viewport ?? {},
+      ...doc.viewport.width !== void 0 ? { width: doc.viewport.width } : {},
+      ...doc.viewport.height !== void 0 ? { height: doc.viewport.height } : {},
+      ...doc.viewport.gap !== void 0 ? { gap: doc.viewport.gap } : {},
+      ...doc.viewport.laneGap !== void 0 ? { laneGap: doc.viewport.laneGap } : {},
+      ...doc.viewport.nodeGap !== void 0 ? { nodeGap: doc.viewport.nodeGap } : {},
+      ...doc.viewport.scale !== void 0 ? { scale: doc.viewport.scale } : {},
+      ...doc.viewport.labelMargin !== void 0 ? { labelMargin: doc.viewport.labelMargin } : {}
+    };
+  }
+  return diagram2;
+}
+function injectPhasesFallback(diagram2, doc) {
+  if (!doc.animate) return;
+  const existingStateIds = new Set(diagram2.states.map((s) => s.id));
+  for (const st of doc.animate.states) {
+    if (!existingStateIds.has(st.name)) {
+      diagram2.states.push({ id: st.name, initial: st.initial });
+    }
+  }
+  const knownNames = new Set(doc.actors.map((a) => a.name));
+  const singleBoxNodes = diagram2.nodes.filter((n) => SINGLE_BOX_KINDS.has(String(n.kind)));
+  const singleBoxNode = singleBoxNodes.length === 1 ? singleBoxNodes[0] : void 0;
+  const resolveIds = (highlight) => {
+    const out = [];
+    for (const h of highlight) {
+      const entry = parseFocusEntry(h, knownNames);
+      if (entry.kind === "edge") {
+        const fromSlug = slugify(entry.from);
+        const toSlug = slugify(entry.to);
+        let \u898B\u3064\u304B\u3063\u305F = false;
+        for (const e of diagram2.edges) {
+          if (e.from === fromSlug && e.to === toSlug) {
+            out.push(e.id);
+            \u898B\u3064\u304B\u3063\u305F = true;
+          }
+        }
+        if (!\u898B\u3064\u304B\u3063\u305F && singleBoxNode !== void 0 && knownNames.has(entry.from) && knownNames.has(entry.to)) {
+          out.push(singleBoxNode.id);
+        }
+        continue;
+      }
+      const nodeSlug = slugify(entry.name);
+      const node = diagram2.nodes.find((n) => n.id === nodeSlug || n.id === `${nodeSlug}-header`);
+      if (node) {
+        out.push(node.id);
+        continue;
+      }
+      if (knownNames.has(entry.name) && singleBoxNode !== void 0) out.push(singleBoxNode.id);
+    }
+    return [...new Set(out)];
+  };
+  for (const p of doc.animate.phases) {
+    const activateIds = [...resolveIds(p.highlight ?? [])];
+    diagram2.phases.push({
+      id: slugify(p.name),
+      duration: p.durationMs,
+      title: p.name,
+      body: p.body ?? "",
+      activate: activateIds,
+      tweens: (p.tweens ?? []).map((t) => ({ stateId: t.state, from: t.from, to: t.to })),
+      sets: (p.sets ?? []).map((s) => ({ stateId: s.state, value: s.value })),
+      ...p.badge ? { badge: p.badge } : {}
+    });
+  }
+}
+function compileSequence(doc) {
+  if (doc.animate && doc.animate.phases.length > 0) {
+    return compileSequenceWithAnimate(doc);
+  }
+  const seqBuilder = sequence({
+    id: slugify(doc.title),
+    topic: doc.title,
+    actors: doc.actors.map((a) => a.name)
+  });
+  for (const s of doc.flow) {
+    seqBuilder.step({
+      from: s.from,
+      to: s.to,
+      label: s.label,
+      ...s.sub ? { sub: s.sub } : {},
+      ...s.tone ? { tone: s.tone } : {},
+      ...s.style ? { style: s.style } : {}
+    });
+  }
+  return seqBuilder.build();
+}
+function compileSequenceWithAnimate(doc) {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const laneW = 340;
+  const actorIds = /* @__PURE__ */ new Map();
+  doc.actors.forEach((a, i) => {
+    const id = slugify(a.name);
+    actorIds.set(a.name, id);
+    actorIds.set(id, id);
+    const laneOpts = { width: laneW, label: a.name, lifeline: true };
+    if (a.posX !== void 0 && a.posY !== void 0) {
+      laneOpts.posX = a.posX;
+      laneOpts.posY = a.posY;
+      if (a.posW !== void 0) laneOpts.posW = a.posW;
+      if (a.posH !== void 0) laneOpts.posH = a.posH;
+    }
+    b.lane(id, laneOpts);
+    const headerId = `${id}-header`;
+    const actorW = Math.max(140, a.name.length * 22 + 52);
+    b.node(headerId, { lane: id, stack: 0, kind: "card", title: a.name, w: actorW, h: 72 });
+    const spacerId = `${id}-spacer`;
+    b.node(spacerId, { lane: id, stack: 1, kind: "card", title: "", w: 2, h: 40 });
+  });
+  doc.flow.forEach((s, idx) => {
+    const fromLaneId = actorIds.get(s.from) ?? s.from;
+    const toLaneId = actorIds.get(s.to) ?? s.to;
+    const stack = idx + 2;
+    const fromBoxId = `s${idx}-${fromLaneId}`;
+    const toBoxId = `s${idx}-${toLaneId}`;
+    b.node(fromBoxId, { lane: fromLaneId, stack, kind: "card", title: "", w: 2, h: 2 });
+    if (fromLaneId !== toLaneId) {
+      b.node(toBoxId, { lane: toLaneId, stack, kind: "card", title: "", w: 2, h: 2 });
+    }
+    const edgeId = `e${idx}-${fromLaneId}-${toLaneId}`;
+    b.edge(fromBoxId, fromLaneId === toLaneId ? fromBoxId : toBoxId, {
+      id: edgeId,
+      label: s.label,
+      ...s.sub ? { sub: s.sub } : {},
+      ...s.tone ? { tone: s.tone } : {},
+      ...s.style ? { style: s.style } : {},
+      ...s.guard ? { guard: s.guard } : {},
+      ...s.cardinality ? { cardinality: s.cardinality } : {},
+      ...s.labelOffsetX !== void 0 ? { labelOffsetX: s.labelOffsetX } : {},
+      ...s.labelOffsetY !== void 0 ? { labelOffsetY: s.labelOffsetY } : {}
+    });
+  });
+  const footerStack = doc.flow.length + 2;
+  doc.actors.forEach((a) => {
+    const laneId = actorIds.get(a.name) ?? slugify(a.name);
+    const footerId = `${laneId}-footer`;
+    const actorW = Math.max(140, a.name.length * 22 + 52);
+    b.node(footerId, { lane: laneId, stack: footerStack, kind: "card", title: a.name, w: actorW, h: 72 });
+  });
+  for (const st of doc.animate.states) {
+    b.state(st.name, { initial: st.initial });
+  }
+  for (const p of doc.animate.phases) {
+    b.phase(
+      slugify(p.name),
+      {
+        duration: p.durationMs,
+        title: p.name,
+        body: p.body ?? ""
+      },
+      (pb) => {
+        const activateIds = resolveHighlight(p, doc, actorIds);
+        if (activateIds.length > 0) {
+          pb.activate(...activateIds);
+        }
+        for (const t of p.tweens ?? []) {
+          pb.tween(t.state, t.from, t.to);
+        }
+        for (const s of p.sets ?? []) {
+          pb.set(s.state, s.value);
+        }
+        if (p.badge) {
+          pb.badge(p.badge);
+        }
+        return pb;
+      }
+    );
+  }
+  return b.build();
+}
+function resolveHighlight(phase, doc, actorIds, _stepEdgeIds) {
+  const out = [];
+  const knownNames = new Set(actorIds.keys());
+  for (const raw of phase.highlight ?? []) {
+    const entry = parseFocusEntry(raw, knownNames);
+    if (entry.kind === "edge") {
+      const fromLaneId = actorIds.get(entry.from) ?? slugify(entry.from);
+      const toLaneId = actorIds.get(entry.to) ?? slugify(entry.to);
+      doc.flow.forEach((s, idx) => {
+        const sFromId = actorIds.get(s.from) ?? slugify(s.from);
+        const sToId = actorIds.get(s.to) ?? slugify(s.to);
+        if (sFromId === fromLaneId && sToId === toLaneId) {
+          out.push(`e${idx}-${fromLaneId}-${toLaneId}`);
+        }
+      });
+      const stackIdx = doc.flow.findIndex((s) => {
+        const sFromId = actorIds.get(s.from) ?? slugify(s.from);
+        const sToId = actorIds.get(s.to) ?? slugify(s.to);
+        return sFromId === fromLaneId && sToId === toLaneId;
+      });
+      if (stackIdx >= 0) {
+        out.push(`s${stackIdx}-${fromLaneId}`);
+        if (fromLaneId !== toLaneId) out.push(`s${stackIdx}-${toLaneId}`);
+      }
+      continue;
+    }
+    const laneId = actorIds.get(entry.name) ?? slugLookup(actorIds, entry.name);
+    if (laneId) {
+      out.push(`${laneId}-header`);
+      out.push(`${laneId}-footer`);
+      doc.flow.forEach((s, idx) => {
+        const sFromId = actorIds.get(s.from) ?? slugify(s.from);
+        const sToId = actorIds.get(s.to) ?? slugify(s.to);
+        if (sFromId === laneId || sToId === laneId) {
+          out.push(`s${idx}-${laneId}`);
+        }
+      });
+    }
+  }
+  return out;
+}
+function slugLookup(byName, wanted) {
+  let hit;
+  for (const [name, id] of byName) {
+    if (slugify(name) !== wanted) continue;
+    if (hit !== void 0) return void 0;
+    hit = id;
+  }
+  return hit;
+}
+function compileFlow(doc) {
+  if (doc.animate && doc.animate.phases.length > 0) {
+    return compileGenericWithAnimate(doc, { kind: "flow", laneId: "main", laneWidth: 400 });
+  }
+  if (doc.actors.length === 0) {
+    return diagram(slugify(doc.title), { topic: doc.title }).build();
+  }
+  const flowBuilder = flow({
+    id: slugify(doc.title),
+    topic: doc.title
+  });
+  for (let i = 0; i < doc.actors.length; i++) {
+    const a = doc.actors[i];
+    const incomingEdge = doc.flow.find((s) => s.to === a.name);
+    const edgeLabel = incomingEdge?.label;
+    flowBuilder.step(
+      {
+        id: slugify(a.name),
+        kind: a.kind,
+        title: a.name
+      },
+      edgeLabel
+    );
+  }
+  return flowBuilder.build();
+}
+function compileSwimlane(doc) {
+  if (doc.animate && doc.animate.phases.length > 0) {
+    return compileGenericWithAnimate(doc, { kind: "swimlane", laneWidth: 400 });
+  }
+  const swim = swimlane({
+    id: slugify(doc.title),
+    topic: doc.title,
+    lanes: doc.actors.map((a) => a.name)
+  });
+  const placedNodes = /* @__PURE__ */ new Set();
+  const laneStackCount = /* @__PURE__ */ new Map();
+  let edgeIdx = 0;
+  for (const s of doc.flow) {
+    for (const actorName of [s.from, s.to]) {
+      if (placedNodes.has(actorName)) continue;
+      const laneId = swim.laneId(actorName);
+      const actor = doc.actors.find((a) => a.name === actorName);
+      const stack = laneStackCount.get(laneId) ?? 0;
+      const nodeId = slugify(actorName);
+      swim.node(nodeId, {
+        lane: laneId,
+        stack,
+        kind: actor?.kind ?? "actor",
+        title: actorName
+      });
+      laneStackCount.set(laneId, stack + 1);
+      placedNodes.add(actorName);
+    }
+    const fromId = slugify(s.from);
+    const toId = slugify(s.to);
+    swim.edge(fromId, toId, {
+      id: `e${edgeIdx++}-${fromId}-${toId}`,
+      label: s.label,
+      ...s.sub ? { sub: s.sub } : {},
+      ...s.tone ? { tone: s.tone } : {},
+      ...s.style ? { style: s.style } : {},
+      ...s.guard ? { guard: s.guard } : {},
+      ...s.cardinality ? { cardinality: s.cardinality } : {},
+      ...s.labelOffsetX !== void 0 ? { labelOffsetX: s.labelOffsetX } : {},
+      ...s.labelOffsetY !== void 0 ? { labelOffsetY: s.labelOffsetY } : {}
+    });
+  }
+  return swim.build();
+}
+function compileEr(doc) {
+  if (doc.animate && doc.animate.phases.length > 0) {
+    return compileGenericWithAnimate(doc, { kind: "er", laneWidth: 450 });
+  }
+  const erBuilder = er({
+    id: slugify(doc.title),
+    topic: doc.title
+  });
+  for (const a of doc.actors) {
+    erBuilder.entity({
+      id: slugify(a.name),
+      title: a.name,
+      rows: []
+      // v0.2 では rows なし
+    });
+  }
+  for (const s of doc.flow) {
+    erBuilder.relation({
+      from: slugify(s.from),
+      to: slugify(s.to),
+      cardinality: parseCardinalityFromLabel(s.label) ?? "1:N",
+      label: stripCardinality(s.label),
+      ...s.tone ? { tone: s.tone } : {}
+    });
+  }
+  return erBuilder.build();
+}
+function compileState(doc) {
+  if (doc.animate && doc.animate.phases.length > 0) {
+    return compileGenericWithAnimate(doc, { kind: "state", laneWidth: 360 });
+  }
+  const fsm = stateMachine({
+    id: slugify(doc.title),
+    topic: doc.title
+  });
+  for (let i = 0; i < doc.actors.length; i++) {
+    const a = doc.actors[i];
+    const initial = i === 0;
+    const final = i === doc.actors.length - 1 && doc.actors.length > 1;
+    fsm.state({
+      id: slugify(a.name),
+      title: a.name,
+      ...initial ? { initial: true } : {},
+      ...final ? { final: true } : {}
+    });
+  }
+  for (const s of doc.flow) {
+    fsm.transition({
+      from: slugify(s.from),
+      to: slugify(s.to),
+      trigger: s.label,
+      ...s.sub ? { guard: s.sub } : {},
+      ...s.tone ? { tone: s.tone } : {}
+    });
+  }
+  return fsm.build();
+}
+function compileTopology(doc) {
+  if (doc.animate && doc.animate.phases.length > 0) {
+    return compileGenericWithAnimate(doc, { kind: "topology", laneWidth: 460 });
+  }
+  if (doc.actors.length === 0) {
+    return diagram(slugify(doc.title), { topic: doc.title }).build();
+  }
+  const topo = topology({
+    id: slugify(doc.title),
+    topic: doc.title
+  });
+  const groupId = "main";
+  const groupBuilder = topo.group(groupId, { label: doc.title });
+  for (const a of doc.actors) {
+    groupBuilder.add({
+      id: slugify(a.name),
+      kind: a.kind,
+      title: a.name
+    });
+  }
+  for (const s of doc.flow) {
+    topo.connect(slugify(s.from), slugify(s.to), {
+      label: s.label,
+      ...s.sub ? { sub: s.sub } : {},
+      ...s.tone ? { tone: s.tone } : {},
+      ...s.style ? { style: s.style } : {}
+    });
+  }
+  return topo.build();
+}
+function compileGenericWithAnimate(doc, opts) {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const { kind, laneWidth } = opts;
+  const actorToNodeId = /* @__PURE__ */ new Map();
+  if (kind === "flow" || kind === "topology") {
+    const lid = opts.laneId ?? "main";
+    b.lane(lid, { width: laneWidth, label: doc.title, ...kind === "topology" ? { contain: true } : {} });
+    doc.actors.forEach((a, idx) => {
+      const id = slugify(a.name);
+      actorToNodeId.set(a.name, id);
+      b.node(id, { lane: lid, stack: idx, kind: a.kind, title: a.name });
+    });
+  } else {
+    doc.actors.forEach((a, idx) => {
+      const lid = `lane-${slugify(a.name)}`;
+      b.lane(lid, { width: laneWidth, label: a.name });
+      const id = slugify(a.name);
+      actorToNodeId.set(a.name, id);
+      const isInitial = kind === "state" && idx === 0;
+      const isFinal = kind === "state" && idx === doc.actors.length - 1 && doc.actors.length > 1;
+      b.node(id, {
+        lane: lid,
+        stack: 0,
+        kind: a.kind,
+        title: a.name,
+        ...isInitial ? { eyebrow: "\u521D\u671F" } : {},
+        ...isFinal ? { eyebrow: "\u6700\u7D42" } : {}
+      });
+    });
+  }
+  const edgeIds = [];
+  doc.flow.forEach((s, idx) => {
+    const fromId = actorToNodeId.get(s.from) ?? slugify(s.from);
+    const toId = actorToNodeId.get(s.to) ?? slugify(s.to);
+    const edgeId = `e${idx}-${fromId}-${toId}`;
+    const labelWithCard = kind === "er" && s.cardinality && !s.label.includes(s.cardinality) ? s.label ? `${s.label} (${s.cardinality})` : `(${s.cardinality})` : s.label;
+    b.edge(fromId, toId, {
+      id: edgeId,
+      label: labelWithCard,
+      ...s.sub ? { sub: s.sub } : {},
+      ...s.tone ? { tone: s.tone } : {},
+      ...s.style ? { style: s.style } : {},
+      ...s.guard ? { guard: s.guard } : {},
+      ...s.cardinality ? { cardinality: s.cardinality } : {},
+      ...s.labelOffsetX !== void 0 ? { labelOffsetX: s.labelOffsetX } : {},
+      ...s.labelOffsetY !== void 0 ? { labelOffsetY: s.labelOffsetY } : {}
+    });
+    edgeIds.push(edgeId);
+  });
+  for (const st of doc.animate.states) {
+    b.state(st.name, { initial: st.initial });
+  }
+  for (const p of doc.animate.phases) {
+    b.phase(
+      slugify(p.name),
+      {
+        duration: p.durationMs,
+        title: p.name,
+        body: p.body ?? ""
+      },
+      (pb) => {
+        const activateIds = resolveHighlightGeneric(p, doc, actorToNodeId, edgeIds);
+        if (activateIds.length > 0) {
+          pb.activate(...activateIds);
+        }
+        for (const t of p.tweens ?? []) {
+          pb.tween(t.state, t.from, t.to);
+        }
+        for (const s of p.sets ?? []) {
+          pb.set(s.state, s.value);
+        }
+        if (p.badge) {
+          pb.badge(p.badge);
+        }
+        return pb;
+      }
+    );
+  }
+  return b.build();
+}
+function resolveHighlightGeneric(phase, doc, actorToNodeId, edgeIds) {
+  const out = [];
+  const knownNames = new Set(actorToNodeId.keys());
+  for (const raw of phase.highlight ?? []) {
+    const entry = parseFocusEntry(raw, knownNames);
+    if (entry.kind === "edge") {
+      const fromId = actorToNodeId.get(entry.from) ?? slugify(entry.from);
+      const toId = actorToNodeId.get(entry.to) ?? slugify(entry.to);
+      for (const edgeId of edgeIds) {
+        if (edgeId.endsWith(`-${fromId}-${toId}`)) {
+          out.push(edgeId);
+        }
+      }
+      continue;
+    }
+    const nodeId = actorToNodeId.get(entry.name) ?? slugLookup(actorToNodeId, entry.name);
+    if (nodeId) {
+      out.push(nodeId);
+    }
+  }
+  return out;
+}
+function slugify(s) {
+  return s.toLowerCase().normalize("NFKC").replace(/[^a-z0-9ぁ-んァ-ヶ一-龯\-_]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "n";
+}
+var CARDINALITY_PATTERNS = [
+  [/1:1/, "1:1"],
+  [/1:N/i, "1:N"],
+  [/N:1/i, "N:1"],
+  [/N:M/i, "N:M"],
+  [/0\.\.1/, "0..1"],
+  [/1\.\.\*/, "1..*"]
+];
+function boundedCardinalityRegExp(pattern, extraFlags = "") {
+  const base = pattern.flags.includes("i") ? "i" : "";
+  return new RegExp(`(?<![A-Za-z0-9_])(?:${pattern.source})(?![A-Za-z0-9_])`, base + extraFlags);
+}
+function parseCardinalityFromLabel(label) {
+  for (const [pattern, card] of CARDINALITY_PATTERNS) {
+    if (boundedCardinalityRegExp(pattern).test(label)) return card;
+  }
+  return null;
+}
+var HORIZONTAL_WS = " \\t\\u3000";
+var HWS = `[${HORIZONTAL_WS}]`;
+function stripCardinality(label) {
+  let r = label;
+  let removed = false;
+  for (const [pattern] of CARDINALITY_PATTERNS) {
+    const src = pattern.source;
+    const flags = pattern.flags.includes("i") ? "gi" : "g";
+    const before = r;
+    r = r.replace(new RegExp(`\\(${HWS}*${src}${HWS}*\\)`, flags), "");
+    r = r.replace(boundedCardinalityRegExp(pattern, "g"), "");
+    if (r !== before) removed = true;
+  }
+  if (!removed) return label;
+  r = r.replace(new RegExp(`${HWS}{2,}`, "g"), " ").replace(new RegExp(`${HWS}*([\\r\\n])${HWS}*`, "g"), "$1").replace(new RegExp(`^${HWS}+|${HWS}+$`, "g"), "");
+  const hasVisible = /[^\p{White_Space}\p{Cf}\p{Cc}\p{Default_Ignorable_Code_Point}]/u.test(r);
+  return hasVisible ? r : label;
+}
+var PRESET_TYPES = /* @__PURE__ */ new Set([
+  "sequence",
+  "flow",
+  "swimlane",
+  "er",
+  "state",
+  "topology",
+  "solidity",
+  "gantt",
+  "class",
+  "pie",
+  "c4",
+  "mind"
+]);
+var NODE_KIND_DEFAULT = "actor";
+var DSL_ONLY_KINDS = [
+  "entity",
+  "state",
+  "contract",
+  "eoa",
+  "multisig",
+  "proxy",
+  "library",
+  "interface"
+];
+var INFRA_KIND_ALIAS = {
+  alb: "shape-api-gateway",
+  // 入口で振り分ける
+  browser: "frontend",
+  // 画面側
+  ecs: "microservice",
+  // コンテナ群
+  iam: "admin",
+  // 権限を守る
+  kms: "admin",
+  // 鍵を守る
+  lambda: "function",
+  // 呼ぶと動く
+  rds: "database",
+  // 表を持つ
+  s3: "storage",
+  // 置き場
+  secret: "storage",
+  // 機密の置き場
+  user: "person",
+  // 人
+  container: "service"
+  // 動かす単位 (C4 の container)
+};
+var NODE_KIND_VALID = /* @__PURE__ */ new Set([
+  ...NODE_KINDS,
+  ...DSL_ONLY_KINDS,
+  ...Object.keys(INFRA_KIND_ALIAS)
+]);
+var TONE_VALID = new Set(TONES);
+var STYLE_VALID = /* @__PURE__ */ new Set(["solid", "dotted-flow"]);
+function parseTextDslV05(src) {
+  const errors = [];
+  const lines = tokenize(src);
+  let title = null;
+  let type = null;
+  let actors = [];
+  const flow2 = [];
+  let animate = void 0;
+  let viewport = void 0;
+  let lanesMap = void 0;
+  let groupsMap = void 0;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trimmed || line.trimmed.startsWith("#")) {
+      i += 1;
+      continue;
+    }
+    const head = matchTopHeader(line.trimmed);
+    if (!head) {
+      errors.push({
+        line: line.no,
+        message: `unknown top-level key: "${line.trimmed}"`,
+        hint: "expected one of: title, type, actors, flow, states, animation, viewport, lanes, groups"
+      });
+      i += 1;
+      continue;
+    }
+    if (head.key === "title") {
+      title = head.value ?? null;
+      if (!title) {
+        errors.push({ line: line.no, message: "title is required", hint: 'use `title: "..."`' });
+      }
+      i += 1;
+      continue;
+    }
+    if (head.key === "type") {
+      const v = (head.value ?? "").trim().toLowerCase();
+      if (!PRESET_TYPES.has(v)) {
+        errors.push({
+          line: line.no,
+          message: `unknown type: "${v}"`,
+          hint: `expected: ${Array.from(PRESET_TYPES).join(", ")}`
+        });
+      } else {
+        type = v;
+      }
+      i += 1;
+      continue;
+    }
+    if (head.key === "actors") {
+      const { items, next } = collectActorEntries(lines, i + 1, line.indent);
+      actors = [];
+      for (const entry of items) {
+        const base = parseActor2(entry[0], errors);
+        if (base === null) {
+          errors.push({
+            line: entry[0].no,
+            message: `invalid actor entry: "${entry[0].trimmed}"`,
+            hint: "use `- Client` or `- Client: storage`"
+          });
+          continue;
+        }
+        actors.push(applyContinuationLines(base, entry.slice(1), errors));
+      }
+      validateRelativePositions(actors, errors);
+      i = next;
+      continue;
+    }
+    if (head.key === "flow") {
+      const { items, next } = collectIndentedList(lines, i + 1, line.indent);
+      let stepNo = 1;
+      for (const it of items) {
+        const step = parseFlowStep(it, stepNo);
+        if (step) {
+          flow2.push(step);
+          stepNo += 1;
+        } else {
+          errors.push({
+            line: it.no,
+            message: `invalid flow entry: "${it.trimmed}"`,
+            hint: 'use `- A -> B: "label"` or `- A -> B: "label" (success)`'
+          });
+        }
+      }
+      i = next;
+      continue;
+    }
+    if (head.key === "states") {
+      const inlineMatch = head.value?.trim();
+      if (inlineMatch && inlineMatch.startsWith("{") && inlineMatch.endsWith("}")) {
+        const inner = inlineMatch.slice(1, -1).trim();
+        animate = ensureAnimate(animate, line.no);
+        for (const pair of splitTopLevelCommas(inner)) {
+          const st = parseStateEntry(pair, line.no);
+          if (st) animate.states.push(st);
+        }
+        i += 1;
+        continue;
+      }
+      const { items, next } = collectIndentedList(lines, i + 1, line.indent);
+      animate = ensureAnimate(animate, line.no);
+      for (const it of items) {
+        const st = parseStateEntry(it.trimmed.replace(/^-\s*/, ""), it.no);
+        if (st) animate.states.push(st);
+        else errors.push({ line: it.no, message: `invalid state entry: "${it.trimmed}"`, hint: "use `name: initial`" });
+      }
+      i = next;
+      continue;
+    }
+    if (head.key === "animation") {
+      const { items: stepBlocks, next } = collectAnimationSteps(lines, i + 1, line.indent);
+      animate = ensureAnimate(animate, line.no);
+      for (const block of stepBlocks) {
+        const ph = parsePhase(block, errors);
+        if (ph) animate.phases.push(ph);
+      }
+      i = next;
+      continue;
+    }
+    if (head.key === "viewport") {
+      const inline = head.value?.trim();
+      if (inline && inline.startsWith("{") && inline.endsWith("}")) {
+        const opts2 = parseInlineMapping(inline.slice(1, -1));
+        viewport = {
+          width: numberOrUndef(opts2.width),
+          height: numberOrUndef(opts2.height),
+          laneWidth: numberOrUndef(opts2.laneWidth),
+          gap: numberOrUndef(opts2.gap),
+          laneGap: numberOrUndef(opts2.laneGap),
+          nodeGap: numberOrUndef(opts2.nodeGap),
+          scale: numberOrUndef(opts2.scale),
+          labelMargin: numberOrUndef(opts2.labelMargin),
+          pos: { line: line.no }
+        };
+        i += 1;
+        continue;
+      }
+      const { items, next } = collectIndentedList(lines, i + 1, line.indent);
+      const opts = {};
+      for (const it of items) {
+        const m = it.trimmed.match(/^([a-zA-Z][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
+        if (m) opts[m[1]] = stripQuotes(m[2].trim());
+      }
+      viewport = {
+        width: numberOrUndef(opts.width),
+        height: numberOrUndef(opts.height),
+        laneWidth: numberOrUndef(opts.laneWidth),
+        gap: numberOrUndef(opts.gap),
+        laneGap: numberOrUndef(opts.laneGap),
+        nodeGap: numberOrUndef(opts.nodeGap),
+        scale: numberOrUndef(opts.scale),
+        labelMargin: numberOrUndef(opts.labelMargin),
+        pos: { line: line.no }
+      };
+      i = next;
+      continue;
+    }
+    if (head.key === "lanes") {
+      const { items, next } = collectIndentedList(lines, i + 1, line.indent);
+      lanesMap = {};
+      for (const it of items) {
+        const m = it.trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*\{([^}]*)\}\s*$/);
+        if (m) {
+          const id = m[1];
+          const opts = parseInlineMapping(m[2]);
+          lanesMap[id] = {
+            id,
+            x: numberOrUndef(opts.x),
+            width: numberOrUndef(opts.width),
+            label: opts.label,
+            contain: boolOrUndef(opts.contain),
+            lifeline: boolOrUndef(opts.lifeline),
+            pos: { line: it.no }
+          };
+        } else {
+          errors.push({
+            line: it.no,
+            message: `invalid lane entry: "${it.trimmed}"`,
+            hint: 'use `id: { x: 0, width: 320, label: "..." }`'
+          });
+        }
+      }
+      i = next;
+      continue;
+    }
+    if (head.key === "groups") {
+      const { items, next } = collectIndentedList(lines, i + 1, line.indent);
+      groupsMap = {};
+      for (const it of items) {
+        const m = it.trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*\{([^}]*)\}\s*$/);
+        if (m) {
+          const id = m[1];
+          const opts = parseInlineMapping(m[2]);
+          const lanesList = (opts.lanes ?? "").replace(/^\[|\]$/g, "").split(",").map((x) => x.trim()).filter(Boolean);
+          groupsMap[id] = {
+            id,
+            label: opts.label,
+            lanes: lanesList,
+            pos: { line: it.no }
+          };
+        } else {
+          errors.push({
+            line: it.no,
+            message: `invalid group entry: "${it.trimmed}"`,
+            hint: 'use `id: { label: "...", lanes: [a, b] }`'
+          });
+        }
+      }
+      i = next;
+      continue;
+    }
+    i += 1;
+  }
+  if (!title) errors.push({ line: 1, message: "title is required", hint: 'add `title: "..."` at top' });
+  if (!type) errors.push({ line: 1, message: "type is required", hint: "add `type: sequence|flow|swimlane|er|state|topology|solidity|gantt|class|pie|c4|mind`" });
+  if (errors.length > 0) return { ok: false, errors };
+  return {
+    ok: true,
+    doc: {
+      title,
+      type,
+      actors,
+      flow: flow2,
+      animate,
+      viewport,
+      lanes: lanesMap,
+      groups: groupsMap,
+      pos: { line: 1 }
+    }
+  };
+}
+function tokenize(src) {
+  const out = [];
+  const raw = src.split("\n");
+  for (let i = 0; i < raw.length; i += 1) {
+    const r = raw[i] ?? "";
+    const trimmed = r.trim();
+    const indent = r.length - r.trimStart().length;
+    out.push({ raw: r, trimmed, indent, no: i + 1 });
+  }
+  return out;
+}
+function matchTopHeader(trimmed) {
+  const m = trimmed.match(/^([a-zA-Z][a-zA-Z0-9_]*)\s*:\s*(.*)$/);
+  if (!m) return null;
+  const value = (m[2] ?? "").trim();
+  return { key: (m[1] ?? "").toLowerCase(), value: value.length ? stripQuotes(value) : null };
+}
+function stripQuotes(s) {
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function lastTopLevelColon(s) {
+  let depth = 0;
+  let quote = "";
+  let last = -1;
+  for (let i = 0; i < s.length; i += 1) {
+    const c = s[i];
+    if (quote) {
+      if (c === quote) quote = "";
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      continue;
+    }
+    if (c === "[" || c === "{") depth += 1;
+    else if (c === "]" || c === "}") depth -= 1;
+    else if (c === ":" && depth === 0) last = i;
+  }
+  return last;
+}
+function splitValues(s) {
+  const out = [];
+  let buf = "";
+  let depth = 0;
+  let quote = "";
+  for (let i = 0; i < s.length; i += 1) {
+    const c = s[i];
+    if (quote) {
+      buf += c;
+      if (c === quote) quote = "";
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      buf += c;
+      continue;
+    }
+    if (c === "[" || c === "{") {
+      depth += 1;
+      buf += c;
+      continue;
+    }
+    if (c === "]" || c === "}") {
+      depth -= 1;
+      buf += c;
+      continue;
+    }
+    if (/\s/.test(c) && depth === 0) {
+      if (buf) {
+        out.push(buf);
+        buf = "";
+      }
+      continue;
+    }
+    buf += c;
+  }
+  if (buf) out.push(buf);
+  return out;
+}
+function classifyValues(values) {
+  const out = { kind: "" };
+  const scaleWritten = /* @__PURE__ */ new Map();
+  const kindWords = [];
+  for (const v of values) {
+    if (v.startsWith('"') && v.endsWith('"') && v.length > 1 || v.startsWith("'") && v.endsWith("'") && v.length > 1) {
+      if (out.subtitle === void 0) out.subtitle = stripQuotes(v);
+      else if (out.value === void 0) out.value = stripQuotes(v);
+      continue;
+    }
+    if (v.startsWith("[") && v.endsWith("]")) {
+      out.rows = v.slice(1, -1).split(/,(?![^[]*\])/).map((x) => stripQuotes(x.trim())).filter(Boolean);
+      continue;
+    }
+    const at = v.match(/^@(-?\d+(?:\.\d+)?)\s*[,、]\s*(-?\d+(?:\.\d+)?)$/);
+    if (at) {
+      out.posX = Number(at[1]);
+      out.posY = Number(at[2]);
+      continue;
+    }
+    const eq = v.indexOf("=");
+    if (eq > 0) {
+      const key = v.slice(0, eq);
+      const raw = stripQuotes(v.slice(eq + 1));
+      if (SCALE_KEYS.has(key)) {
+        scaleWritten.set(key, raw);
+        continue;
+      }
+      if (/^[A-Za-z_][\w-]*$/.test(key)) {
+        out.state = { ...out.state ?? {}, [key]: coerceStateValue(raw) };
+        continue;
+      }
+    }
+    const tone = toneOrUndef(v);
+    if (tone) {
+      out.tone = tone;
+      continue;
+    }
+    kindWords.push(v);
+  }
+  out.kind = kindWords.join(" ").toLowerCase();
+  const s = resolveScale(scaleWritten);
+  out.scale = s.scale;
+  out.scaleKeys = s.keys;
+  return out;
+}
+function resolveKind(raw) {
+  if (raw === "") return NODE_KIND_DEFAULT;
+  return Object.hasOwn(INFRA_KIND_ALIAS, raw) ? INFRA_KIND_ALIAS[raw] : raw;
+}
+function numberOrUndef(s) {
+  if (s === void 0 || s === "") return void 0;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : void 0;
+}
+function boolOrUndef(s) {
+  if (s === void 0) return void 0;
+  const lower = s.toLowerCase();
+  if (lower === "true") return true;
+  if (lower === "false") return false;
+  return void 0;
+}
+function toneOrUndef(s) {
+  if (s === void 0) return void 0;
+  const raw = stripQuotes(s.trim());
+  const lower = raw.toLowerCase();
+  const resolved = Object.hasOwn(TONE_ALIAS, raw) ? TONE_ALIAS[raw] : Object.hasOwn(TONE_ALIAS, lower) ? TONE_ALIAS[lower] : void 0;
+  if (resolved !== void 0 && TONE_VALID.has(resolved)) return resolved;
+  return TONE_VALID.has(lower) ? lower : void 0;
+}
+function matchActorInlineMapping(raw) {
+  const colonIdx = raw.indexOf(":");
+  if (colonIdx < 0) return null;
+  const name = raw.slice(0, colonIdx);
+  const rest = raw.slice(colonIdx + 1).trim();
+  if (!rest.startsWith("{")) return null;
+  let depth = 0;
+  let endIdx = -1;
+  for (let i = 0; i < rest.length; i += 1) {
+    const c = rest[i];
+    if (c === "{") depth += 1;
+    else if (c === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        endIdx = i;
+        break;
+      }
+    }
+  }
+  if (endIdx < 0) return null;
+  const inner = rest.slice(1, endIdx);
+  return { name, inner };
+}
+function parseInlineMapping(inner) {
+  const out = {};
+  for (const p of splitInlineFields(inner)) {
+    const m = p.match(/^\s*([^\s:,{}[\]"']+)\s*:\s*(.+?)\s*$/);
+    if (m) {
+      const key = m[1];
+      out[key] = stripQuotes(m[2].trim());
+    }
+  }
+  return out;
+}
+function writtenScaleFields(inner) {
+  const out = /* @__PURE__ */ new Map();
+  for (const field of splitInlineFields(inner)) {
+    const idx = field.indexOf(":");
+    if (idx < 0) continue;
+    const key = field.slice(0, idx).trim();
+    if (!SCALE_KEYS.has(key)) continue;
+    out.set(key, stripQuotes(field.slice(idx + 1).trim()));
+  }
+  return out;
+}
+function splitInlineFields(inner) {
+  let depth = 0;
+  let buf = "";
+  const parts = [];
+  for (let i = 0; i < inner.length; i += 1) {
+    const c = inner[i];
+    if (c === "[" || c === "{") depth += 1;
+    else if (c === "]" || c === "}") depth -= 1;
+    if (c === "," && depth === 0) {
+      parts.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += c;
+  }
+  if (buf.trim()) parts.push(buf);
+  return parts;
+}
+function collectIndentedList(lines, start, parentIndent) {
+  const items = [];
+  let i = start;
+  while (i < lines.length) {
+    const ln = lines[i];
+    if (!ln.trimmed) {
+      i += 1;
+      continue;
+    }
+    if (ln.indent <= parentIndent) break;
+    if (ln.trimmed.startsWith("- ")) {
+      items.push({ ...ln, trimmed: ln.trimmed.slice(2).trim() });
+    } else if (ln.trimmed.includes(":")) {
+      items.push(ln);
+    }
+    i += 1;
+  }
+  return { items, next: i };
+}
+function splitColorValue(raw) {
+  const v = stripQuotes(raw.trim());
+  if (v.startsWith("#")) return { hex: v };
+  const tone = toneOrUndef(v);
+  return tone ? { tone } : {};
+}
+var COLOR_KEYS = /* @__PURE__ */ new Set(["\u8272", "color", "tone"]);
+var SCALE_KEYS = /* @__PURE__ */ new Set(["scale", "\u500D\u7387"]);
+var SCALE_ORDER = ["scale", "\u500D\u7387"];
+function resolveScale(written) {
+  const keys = [...written.keys()];
+  for (const key of SCALE_ORDER) {
+    const raw = written.get(key);
+    if (raw !== void 0) return { scale: numberOrUndef(raw), keys };
+  }
+  return { keys };
+}
+function applyContinuationLines(actor, rest, errors) {
+  if (rest.length === 0) return actor;
+  const out = { ...actor };
+  const state = { ...actor.stateOverride ?? {} };
+  let touchedState = false;
+  const scaleWritten = /* @__PURE__ */ new Map();
+  const unknownKeys = [];
+  for (const ln of rest) {
+    const idx = ln.trimmed.indexOf(":");
+    if (idx < 0) continue;
+    const key = ln.trimmed.slice(0, idx).trim();
+    const raw = ln.trimmed.slice(idx + 1).trim();
+    if (!key) continue;
+    if (SCALE_KEYS.has(key)) {
+      scaleWritten.set(key, stripQuotes(raw));
+      unknownKeys.push({ key, line: ln.no });
+      continue;
+    }
+    if (!raw) continue;
+    if (COLOR_KEYS.has(key)) {
+      const { tone, hex } = splitColorValue(raw);
+      if (tone) out.tone = tone;
+      if (hex) out.colorHex = hex;
+      continue;
+    }
+    switch (key) {
+      case "kind":
+      case "\u7A2E\u985E": {
+        const k = stripQuotes(raw).toLowerCase();
+        const isPart = k !== "" && !NODE_KIND_VALID.has(k);
+        out.kind = isPart ? NODE_KIND_DEFAULT : resolveKind(k);
+        out.kindWritten = k !== "" && !isPart;
+        out.partId = isPart ? k : void 0;
+        break;
+      }
+      case "subtitle":
+      case "\u88DC\u8DB3":
+        out.subtitle = stripQuotes(raw);
+        break;
+      case "value":
+      case "\u5024":
+        out.value = stripQuotes(raw);
+        break;
+      case "rows":
+      case "\u884C":
+        out.rows = raw.replace(/^\[|\]$/g, "").split(/,(?![^[]*\])/).map((x) => stripQuotes(x.trim())).filter(Boolean);
+        break;
+      case "\u4F4D\u7F6E":
+      case "pos": {
+        const value = stripQuotes(raw);
+        const m = value.match(/^(-?\d+(?:\.\d+)?)\s*[,、]\s*(-?\d+(?:\.\d+)?)$/);
+        if (m) {
+          out.posX = Number(m[1]);
+          out.posY = Number(m[2]);
+          out.posRel = void 0;
+          break;
+        }
+        const rel = parseRelativePos(value);
+        if (rel) {
+          out.posRel = rel;
+          out.posX = void 0;
+          out.posY = void 0;
+          break;
+        }
+        const negative = /^(.+?)\s*(?:の\s*(?:右|左|上|下)|\s(?:right|left|above|below))\s*-\s*[\d.]/i.test(value);
+        errors.push({
+          line: ln.no,
+          message: negative ? `\u9593\u9694\u306B\u8CA0\u306E\u6570\u306F\u66F8\u3051\u307E\u305B\u3093: "${value}"` : `\u4F4D\u7F6E\u306E\u66F8\u304D\u65B9\u304C\u8AAD\u3081\u307E\u305B\u3093: "${value}"`,
+          hint: negative ? "\u5411\u304D\u3092\u5909\u3048\u305F\u3044\u6642\u306F `\u53F3` / `\u5DE6` / `\u4E0A` / `\u4E0B` \u3092\u66F8\u304D\u63DB\u3048\u308B" : "`\u4F4D\u7F6E: 300,200` (\u5EA7\u6A19) \u304B `\u4F4D\u7F6E: Web \u306E\u53F3 200` (\u4ED6\u306E\u767B\u5834\u4EBA\u7269\u304B\u3089\u306E\u76F8\u5BFE)"
+        });
+        break;
+      }
+      case "posX":
+        out.posX = numberOrUndef(raw);
+        break;
+      case "posY":
+        out.posY = numberOrUndef(raw);
+        break;
+      case "\u5927\u304D\u3055":
+      case "size": {
+        const value = stripQuotes(raw);
+        const m = value.match(/^(-?\d+(?:\.\d+)?)\s*[,、]\s*(-?\d+(?:\.\d+)?)$/);
+        if (m) {
+          out.posW = Number(m[1]);
+          out.posH = Number(m[2]);
+          break;
+        }
+        errors.push({
+          line: ln.no,
+          message: `\u5927\u304D\u3055\u306E\u66F8\u304D\u65B9\u304C\u8AAD\u3081\u307E\u305B\u3093: "${value}"`,
+          hint: "`\u5927\u304D\u3055: 400,200` (\u5E45, \u9AD8\u3055) \u306E\u5F62\u3067\u66F8\u304F"
+        });
+        break;
+      }
+      case "lane":
+        out.lane = stripQuotes(raw);
+        break;
+      case "stack":
+        out.stack = numberOrUndef(raw);
+        break;
+      default:
+        state[key] = coerceStateValue(stripQuotes(raw));
+        touchedState = true;
+        unknownKeys.push({ key, line: ln.no });
+        break;
+    }
+  }
+  if (scaleWritten.size > 0) {
+    const s = resolveScale(scaleWritten);
+    out.scale = s.scale;
+    out.scaleKeys = [.../* @__PURE__ */ new Set([...actor.scaleKeys ?? [], ...s.keys])];
+  }
+  if (out.partId !== void 0) {
+    if (touchedState) out.stateOverride = state;
+    return out;
+  }
+  for (const u of unknownKeys) {
+    errors.push({
+      line: u.line,
+      message: `\u9805\u76EE\u540D\u304C\u8AAD\u3081\u307E\u305B\u3093: "${u.key}"`,
+      hint: `\u4F7F\u3048\u308B\u9805\u76EE = ${[...ACTOR_ITEM_KEYS].join(", ")}`
+    });
+  }
+  return out;
+}
+var ACTOR_ITEM_KEYS = /* @__PURE__ */ new Set([
+  ...COLOR_KEYS,
+  "kind",
+  "\u7A2E\u985E",
+  "subtitle",
+  "\u88DC\u8DB3",
+  "value",
+  "\u5024",
+  "rows",
+  "\u884C",
+  "\u4F4D\u7F6E",
+  "pos",
+  "posX",
+  "posY",
+  "\u5927\u304D\u3055",
+  "size",
+  "\u500D\u7387",
+  "scale",
+  "lane",
+  "stack"
+]);
+function validateRelativePositions(actors, errors) {
+  const named = new Set(actors.map((a) => a.name));
+  const broken = /* @__PURE__ */ new Set();
+  for (const a of actors) {
+    const rel = a.posRel;
+    if (!rel) continue;
+    if (rel.anchor === a.name) {
+      errors.push({
+        line: a.pos.line,
+        message: `\u4F4D\u7F6E\u306E\u57FA\u6E96\u304C\u81EA\u5206\u81EA\u8EAB\u3067\u3059: "${a.name}"`,
+        hint: "\u5225\u306E\u767B\u5834\u4EBA\u7269\u306E\u540D\u524D\u3092\u66F8\u304F"
+      });
+      broken.add(a.name);
+      continue;
+    }
+    if (!named.has(rel.anchor)) {
+      errors.push({
+        line: a.pos.line,
+        message: `\u4F4D\u7F6E\u306E\u57FA\u6E96\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: "${rel.anchor}"`,
+        hint: named.size > 0 ? `actors: \u306B\u66F8\u304B\u308C\u3066\u3044\u308B\u540D\u524D = ${[...named].join(", ")}` : "actors: \u306B\u57FA\u6E96\u306B\u3059\u308B\u767B\u5834\u4EBA\u7269\u3092\u66F8\u304F"
+      });
+      broken.add(a.name);
+    }
+  }
+  const { cyclic } = orderByDependency(
+    actors.map((a) => ({ name: a.name, rel: broken.has(a.name) ? void 0 : a.posRel }))
+  );
+  for (const name of cyclic) {
+    const a = actors.find((x) => x.name === name);
+    errors.push({
+      line: a?.pos.line ?? 1,
+      message: `\u4F4D\u7F6E\u306E\u57FA\u6E96\u304C\u4E92\u3044\u3092\u6307\u3057\u3066\u3044\u307E\u3059: "${name}"`,
+      hint: "\u3069\u308C\u304B 1 \u3064\u306F\u5EA7\u6A19 (`\u4F4D\u7F6E: 300,200`) \u304B\u81EA\u52D5\u914D\u7F6E\u306B\u3059\u308B"
+    });
+    broken.add(name);
+  }
+  for (const a of actors) {
+    if (broken.has(a.name)) a.posRel = void 0;
+  }
+}
+function collectActorEntries(lines, start, parentIndent) {
+  const items = [];
+  let cur = null;
+  let headIndent = -1;
+  let i = start;
+  while (i < lines.length) {
+    const ln = lines[i];
+    if (!ln.trimmed) {
+      i += 1;
+      continue;
+    }
+    if (ln.indent <= parentIndent) break;
+    if (ln.trimmed.startsWith("- ")) {
+      if (cur) items.push(cur);
+      cur = [{ ...ln, trimmed: ln.trimmed.slice(2).trim() }];
+      headIndent = ln.indent;
+    } else if (cur && ln.indent > headIndent) {
+      cur.push(ln);
+    }
+    i += 1;
+  }
+  if (cur) items.push(cur);
+  return { items, next: i };
+}
+function collectAnimationSteps(lines, start, parentIndent) {
+  const out = [];
+  let i = start;
+  let cur = null;
+  while (i < lines.length) {
+    const ln = lines[i];
+    if (!ln.trimmed) {
+      i += 1;
+      continue;
+    }
+    if (ln.indent <= parentIndent) break;
+    if (ln.trimmed.startsWith("- step")) {
+      if (cur) out.push(cur);
+      cur = [{ ...ln, trimmed: ln.trimmed.slice(2).trim() }];
+    } else if (cur) {
+      cur.push(ln);
+    }
+    i += 1;
+  }
+  if (cur) out.push(cur);
+  return { items: out, next: i };
+}
+var ACTOR_RESERVED_FIELDS = /* @__PURE__ */ new Set([
+  "kind",
+  "subtitle",
+  "eyebrow",
+  "value",
+  "rows",
+  "lane",
+  "stack",
+  "initial",
+  "final",
+  "state",
+  // canvas pivot 新 spec = 絶対座標 4 field (dragon canvas pivot spec §layout-role-conversion)
+  "posX",
+  "posY",
+  "posW",
+  "posH",
+  // canvas pivot UX 修正 (B1) = sub-node 単位 override map (nested `nodes: { header: {...} }`)
+  "nodes",
+  // 図形の倍率 (#1026)。 状態の名前としては読まない
+  "scale",
+  "\u500D\u7387",
+  // 日本語の項目名 (#1026)。 中括弧の形が日本語の項目名を読めるようになったため、
+  // ここに載せないと状態の名前として拾われる。 縦に並べた形での意味 (位置 / 大きさ 等) は
+  // 中括弧の形では未対応なので、これまでどおり落とす方に揃える
+  "\u7A2E\u985E",
+  "\u88DC\u8DB3",
+  "\u5024",
+  "\u884C",
+  "\u4F4D\u7F6E",
+  "\u5927\u304D\u3055",
+  "\u8272"
+]);
+function extractStateOverride(opts) {
+  const out = {};
+  let count = 0;
+  const explicit = opts.state;
+  if (explicit && explicit.startsWith("{") && explicit.endsWith("}")) {
+    const inner = parseInlineMapping(explicit.slice(1, -1));
+    for (const [k, v] of Object.entries(inner)) {
+      out[k] = coerceStateValue(v);
+      count += 1;
+    }
+  }
+  for (const [k, v] of Object.entries(opts)) {
+    if (ACTOR_RESERVED_FIELDS.has(k)) continue;
+    if (k in out) continue;
+    out[k] = coerceStateValue(v);
+    count += 1;
+  }
+  return count > 0 ? out : void 0;
+}
+function parseActorNodesField(raw) {
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return void 0;
+  const inner = trimmed.slice(1, -1).trim();
+  if (!inner) return void 0;
+  const parts = [];
+  let depth = 0;
+  let buf = "";
+  for (let i = 0; i < inner.length; i += 1) {
+    const c = inner[i];
+    if (c === "[" || c === "{") depth += 1;
+    else if (c === "]" || c === "}") depth -= 1;
+    if (c === "," && depth === 0) {
+      parts.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += c;
+  }
+  if (buf.trim()) parts.push(buf);
+  const out = {};
+  for (const p of parts) {
+    const colonIdx = p.indexOf(":");
+    if (colonIdx < 0) continue;
+    const key = p.slice(0, colonIdx).trim();
+    const val = p.slice(colonIdx + 1).trim();
+    if (!key || !val.startsWith("{") || !val.endsWith("}")) continue;
+    const nodeOpts = parseInlineMapping(val.slice(1, -1));
+    out[key] = {
+      posX: numberOrUndef(nodeOpts.posX),
+      posY: numberOrUndef(nodeOpts.posY),
+      posW: numberOrUndef(nodeOpts.posW),
+      posH: numberOrUndef(nodeOpts.posH)
+    };
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function coerceStateValue(raw) {
+  const stripped = stripQuotes(raw);
+  if (stripped === "true") return true;
+  if (stripped === "false") return false;
+  const n = Number(stripped);
+  if (Number.isFinite(n) && stripped !== "" && !isNaN(n)) return n;
+  return stripped;
+}
+function reportScaleOnNonPart(isPart, key, line, errors) {
+  if (isPart || key === void 0) return;
+  errors.push({
+    line,
+    message: `\u9805\u76EE\u540D\u304C\u8AAD\u3081\u307E\u305B\u3093: "${key}"`,
+    hint: `\u4F7F\u3048\u308B\u9805\u76EE = ${[...ACTOR_ITEM_KEYS].join(", ")}`
+  });
+}
+var INLINE_ACTOR_KEYS = /* @__PURE__ */ new Set([
+  "kind",
+  "subtitle",
+  "eyebrow",
+  "value",
+  "rows",
+  "lane",
+  "stack",
+  "initial",
+  "final",
+  "tone",
+  "nodes",
+  "posX",
+  "posY",
+  "posW",
+  "posH",
+  // 倍率は別経路 (`reportScaleOnNonPart`) が知らせる。 ここでも読める扱いにしないと
+  // 同じ名前で 2 度知らせることになる
+  "scale",
+  "\u500D\u7387"
+]);
+function reportUnknownInlineKeys(isPart, inner, line, errors) {
+  if (isPart) return;
+  for (const field of splitInlineFields(inner)) {
+    const idx = field.indexOf(":");
+    if (idx < 0) continue;
+    const key = field.slice(0, idx).trim();
+    if (!key) continue;
+    if (INLINE_ACTOR_KEYS.has(key)) continue;
+    errors.push({
+      line,
+      message: `\u9805\u76EE\u540D\u304C\u8AAD\u3081\u307E\u305B\u3093: "${key}"`,
+      hint: `\u4F7F\u3048\u308B\u9805\u76EE = ${[...INLINE_ACTOR_KEYS].join(", ")}`
+    });
+  }
+}
+function parseActor2(line, errors) {
+  const raw = line.trimmed.trim();
+  if (!raw) return null;
+  const mapMatch = matchActorInlineMapping(raw);
+  if (mapMatch) {
+    const namePart2 = stripQuotes(mapMatch.name.trim());
+    if (!namePart2) return null;
+    const opts = parseInlineMapping(mapMatch.inner);
+    const kindRaw = (opts.kind ?? "").toLowerCase();
+    const isPart = kindRaw !== "" && !NODE_KIND_VALID.has(kindRaw);
+    const inlineScale = resolveScale(writtenScaleFields(mapMatch.inner));
+    reportScaleOnNonPart(isPart, inlineScale.keys[0], line.no, errors);
+    reportUnknownInlineKeys(isPart, mapMatch.inner, line.no, errors);
+    const kind = isPart ? NODE_KIND_DEFAULT : resolveKind(NODE_KIND_VALID.has(kindRaw) ? kindRaw : "");
+    return {
+      name: namePart2,
+      kind,
+      // parts 候補は `kind` を既定に倒して `partId` へ退避するため、 名札に載せる種類としては
+      // 「書かなかった」 と同じ扱いにする (#1058)
+      kindWritten: kindRaw !== "" && !isPart,
+      subtitle: opts.subtitle,
+      eyebrow: opts.eyebrow,
+      value: opts.value,
+      rows: opts.rows ? opts.rows.replace(/^\[|\]$/g, "").split(/,(?![^[]*\])/).map((x) => stripQuotes(x.trim())).filter(Boolean) : void 0,
+      lane: opts.lane,
+      stack: numberOrUndef(opts.stack),
+      initial: boolOrUndef(opts.initial),
+      final: boolOrUndef(opts.final),
+      // parts では `tone` を状態の上書きとして従来から使えるため、 色として横取りしない
+      tone: isPart ? void 0 : toneOrUndef(opts.tone),
+      partId: isPart ? kindRaw : void 0,
+      stateOverride: isPart ? extractStateOverride(opts) : void 0,
+      // canvas pivot 新 spec = 絶対座標 field を actor に格納、 compile 経由で CDL に受け渡す
+      posX: numberOrUndef(opts.posX),
+      posY: numberOrUndef(opts.posY),
+      posW: numberOrUndef(opts.posW),
+      posH: numberOrUndef(opts.posH),
+      // 図形の倍率 (#1026)。 どれが効くかは `resolveScale` が 1 箇所で決める
+      scale: inlineScale.scale,
+      scaleKeys: inlineScale.keys.length ? inlineScale.keys : void 0,
+      // canvas pivot UX 修正 (B1) = sub-node 単位 override map (`nodes: { header: {posX:..., ...}, ...}`)
+      nodes: parseActorNodesField(opts.nodes),
+      pos: { line: line.no }
+    };
+  }
+  if (lastTopLevelColon(raw) >= 0) {
+    const idx = lastTopLevelColon(raw);
+    const namePart2 = stripQuotes(raw.slice(0, idx).trim());
+    const rest = raw.slice(idx + 1).trim();
+    if (!namePart2) return null;
+    const v = classifyValues(splitValues(rest));
+    const isPart = v.kind !== "" && !NODE_KIND_VALID.has(v.kind);
+    reportScaleOnNonPart(isPart, v.scaleKeys?.[0], line.no, errors);
+    const kind = isPart ? NODE_KIND_DEFAULT : resolveKind(NODE_KIND_VALID.has(v.kind) ? v.kind : "");
+    return {
+      name: namePart2,
+      kind,
+      // parts 候補は `kind` を既定に倒して `partId` へ退避するため、 名札に載せる種類としては
+      // 「書かなかった」 と同じ扱いにする (#1058)
+      kindWritten: v.kind !== "" && !isPart,
+      // parts では `tone` を状態の上書きとして扱うため、 色として渡さない
+      tone: isPart ? void 0 : v.tone,
+      subtitle: v.subtitle,
+      rows: v.rows,
+      value: v.value,
+      posX: v.posX,
+      posY: v.posY,
+      scale: v.scale,
+      scaleKeys: v.scaleKeys?.length ? v.scaleKeys : void 0,
+      partId: isPart ? v.kind : void 0,
+      stateOverride: isPart ? v.state : void 0,
+      pos: { line: line.no }
+    };
+  }
+  const namePart = stripQuotes(raw);
+  if (!namePart) return null;
+  return { name: namePart, kind: NODE_KIND_DEFAULT, kindWritten: false, pos: { line: line.no } };
+}
+function parseFlowStep(line, no) {
+  const raw = line.trimmed;
+  const arrowIdx = raw.indexOf("->");
+  if (arrowIdx < 0) return null;
+  const from = raw.slice(0, arrowIdx).trim();
+  let rest = raw.slice(arrowIdx + 2).trim();
+  let label = "";
+  let tone;
+  let style;
+  let sub;
+  let guard;
+  let cardinality;
+  let labelOffsetX;
+  let labelOffsetY;
+  const mapMatch = rest.match(/\s*\{([^}]*)\}\s*$/);
+  if (mapMatch) {
+    const opts = parseInlineMapping(mapMatch[1]);
+    sub = opts.sub;
+    guard = opts.guard;
+    cardinality = opts.cardinality;
+    labelOffsetX = numberOrUndef(opts.labelOffsetX);
+    labelOffsetY = numberOrUndef(opts.labelOffsetY);
+    rest = rest.slice(0, mapMatch.index ?? 0).trim();
+  }
+  const optMatch = rest.match(/\s*\(([^)]*)\)\s*$/);
+  if (optMatch) {
+    const opts = (optMatch[1] ?? "").split(",").map((s) => s.trim());
+    for (const opt of opts) {
+      const resolvedTone = toneOrUndef(opt);
+      if (resolvedTone !== void 0) tone = resolvedTone;
+      else if (STYLE_VALID.has(opt.toLowerCase())) style = opt.toLowerCase();
+    }
+    rest = rest.slice(0, optMatch.index ?? 0).trim();
+  } else {
+    const words = splitValues(rest);
+    while (words.length > 1) {
+      const last = words[words.length - 1];
+      if (last.startsWith('"') || last.startsWith("'")) break;
+      const resolvedTone = toneOrUndef(last);
+      if (resolvedTone !== void 0) {
+        tone = resolvedTone;
+        words.pop();
+        continue;
+      }
+      if (STYLE_VALID.has(last.toLowerCase())) {
+        style = last.toLowerCase();
+        words.pop();
+        continue;
+      }
+      break;
+    }
+    rest = words.join(" ");
+  }
+  let to = rest;
+  const labelMatch = rest.match(/^(.+?):\s*(.+)$/);
+  if (labelMatch) {
+    to = (labelMatch[1] ?? "").trim();
+    label = stripQuotes((labelMatch[2] ?? "").trim());
+  }
+  if (!from || !to) return null;
+  return {
+    no,
+    from: stripQuotes(from),
+    to: stripQuotes(to),
+    label,
+    tone,
+    style,
+    sub,
+    guard,
+    cardinality,
+    labelOffsetX,
+    labelOffsetY,
+    pos: { line: line.no }
+  };
+}
+function parseStateEntry(text, lineNo) {
+  const m = text.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
+  if (!m) return null;
+  const name = m[1] ?? "";
+  const raw = (m[2] ?? "").trim();
+  const stripped = stripQuotes(raw);
+  const asNum = Number(stripped);
+  const initial = Number.isFinite(asNum) && stripped !== "" && !isNaN(asNum) ? asNum : stripped;
+  return { name, initial, pos: { line: lineNo } };
+}
+function splitTopLevelCommas(s) {
+  return s.split(",").map((x) => x.trim()).filter(Boolean);
+}
+function ensureAnimate(a, lineNo) {
+  if (a) return a;
+  return { states: [], phases: [], pos: { line: lineNo } };
+}
+function parsePhase(block, errors) {
+  const head = block[0];
+  const m = head.trimmed.match(/^step\s*:\s*(.+)$/);
+  if (!m) {
+    errors.push({ line: head.no, message: `invalid step header: "${head.trimmed}"`, hint: 'use `- step: "name" 1.5s`' });
+    return null;
+  }
+  const headRest = (m[1] ?? "").trim();
+  const headParse = parseStepHead(headRest);
+  if (!headParse) {
+    errors.push({ line: head.no, message: `invalid step value: "${headRest}"`, hint: 'use `"name" 1.5s` (duration in s)' });
+    return null;
+  }
+  const phase = {
+    name: headParse.name,
+    durationMs: headParse.durationMs,
+    pos: { line: head.no },
+    highlight: [],
+    tweens: [],
+    sets: []
+  };
+  let i = 1;
+  while (i < block.length) {
+    const ln = block[i];
+    const t = ln.trimmed;
+    const propMatch = t.match(/^([a-zA-Z][a-zA-Z0-9_]*)\s*:\s*(.*)$/);
+    if (!propMatch) {
+      i += 1;
+      continue;
+    }
+    const key = (propMatch[1] ?? "").toLowerCase();
+    const value = (propMatch[2] ?? "").trim();
+    if (key === "focus") {
+      phase.highlight = parseFocusList(value);
+      i += 1;
+      continue;
+    }
+    if (key === "badge") {
+      phase.badge = stripQuotes(value);
+      i += 1;
+      continue;
+    }
+    if (key === "description" || key === "body") {
+      phase.body = stripQuotes(value);
+      i += 1;
+      continue;
+    }
+    if (key === "tween") {
+      if (value) {
+        const tw = parseTweenLine(value, ln.no);
+        if (tw) phase.tweens.push(tw);
+        else errors.push({ line: ln.no, message: `invalid tween: "${value}"`, hint: "use `tween: name 100 -> 90`" });
+        i += 1;
+        continue;
+      }
+      const baseIndent = ln.indent;
+      let j = i + 1;
+      while (j < block.length) {
+        const nx = block[j];
+        if (nx.indent <= baseIndent) break;
+        const tw = parseTweenLine(nx.trimmed, nx.no);
+        if (tw) phase.tweens.push(tw);
+        else errors.push({ line: nx.no, message: `invalid tween entry: "${nx.trimmed}"`, hint: "use `name: 100 -> 90`" });
+        j += 1;
+      }
+      i = j;
+      continue;
+    }
+    if (key === "set") {
+      if (value) {
+        const st = parseSetLine(value, ln.no);
+        if (st) phase.sets.push(st);
+        i += 1;
+        continue;
+      }
+      const baseIndent = ln.indent;
+      let j = i + 1;
+      while (j < block.length) {
+        const nx = block[j];
+        if (nx.indent <= baseIndent) break;
+        const st = parseSetLine(nx.trimmed, nx.no);
+        if (st) phase.sets.push(st);
+        j += 1;
+      }
+      i = j;
+      continue;
+    }
+    i += 1;
+  }
+  return phase;
+}
+function parseStepHead(s) {
+  let rest = s.trim();
+  let name = "";
+  if (rest.startsWith('"') || rest.startsWith("'")) {
+    const q = rest[0] ?? '"';
+    const end = rest.indexOf(q, 1);
+    if (end < 0) return null;
+    name = rest.slice(1, end);
+    rest = rest.slice(end + 1).trim();
+  } else {
+    const spaceIdx = rest.indexOf(" ");
+    if (spaceIdx < 0) return null;
+    name = rest.slice(0, spaceIdx);
+    rest = rest.slice(spaceIdx + 1).trim();
+  }
+  const dm = rest.match(/^(\d+(?:\.\d+)?)\s*(ms|s)?$/);
+  if (!dm) return null;
+  const n = parseFloat(dm[1] ?? "0");
+  const unit = dm[2] ?? "s";
+  const durationMs = unit === "ms" ? Math.round(n) : Math.round(n * 1e3);
+  return { name, durationMs };
+}
+function parseFocusList(s) {
+  let body = s.trim();
+  if (body.startsWith("[") && body.endsWith("]")) body = body.slice(1, -1);
+  const parts = [];
+  let buf = "";
+  let quote = null;
+  for (const ch of body) {
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+        continue;
+      }
+      buf += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === ",") {
+      const t = buf.trim();
+      if (t) parts.push(t);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  const tail = buf.trim();
+  if (tail) parts.push(tail);
+  const out = [];
+  for (const p of parts) {
+    if (/[-→][>]?/.test(p) && /\s/.test(p)) {
+      out.push(p);
+      continue;
+    }
+    if (/\s/.test(p)) {
+      for (const x of p.split(/\s+/)) {
+        if (x) out.push(x);
+      }
+      continue;
+    }
+    out.push(p);
+  }
+  return out;
+}
+function parseTweenLine(s, lineNo) {
+  const cleaned = s.replace(/^-\s*/, "").trim();
+  const m = cleaned.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*[:\s]\s*(-?\d+(?:\.\d+)?)\s*->\s*(-?\d+(?:\.\d+)?)$/);
+  if (!m) return null;
+  return {
+    state: m[1] ?? "",
+    from: parseFloat(m[2] ?? "0"),
+    to: parseFloat(m[3] ?? "0"),
+    pos: { line: lineNo }
+  };
+}
+function parseSetLine(s, lineNo) {
+  const cleaned = s.replace(/^-\s*/, "").trim();
+  const m = cleaned.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*[:\s]\s*(.+)$/);
+  if (!m) return null;
+  const raw = (m[2] ?? "").trim();
+  const stripped = stripQuotes(raw);
+  const asNum = Number(stripped);
+  const value = Number.isFinite(asNum) && stripped !== "" && !isNaN(asNum) ? asNum : stripped;
+  return { state: m[1] ?? "", value, pos: { line: lineNo } };
+}
+
+// src/notation-lint.ts
+var REDUNDANT_TOPIC_PATTERNS = [
+  { pattern: /\bpreset\s*\(/i, hint: "\u300C\u301C preset (\u8A73\u7D30)\u300D \u306F\u5B9F\u88C5\u8868\u73FE\u3001 \u300C\u301C \u3092\u793A\u3059\u56F3\u300D \u306E\u3088\u3046\u306B\u8AAD\u8005\u5411\u3051\u8AAC\u660E\u306B" },
+  { pattern: /render\s*未実装/, hint: "\u300Crender \u672A\u5B9F\u88C5\u300D \u306F\u958B\u767A\u8005\u5411\u3051\u5185\u90E8\u30E1\u30E2\u3001 catalog \u8868\u793A\u3067\u306F\u7701\u304F" },
+  { pattern: /SVG\s+(polyline|arc|rect|path)/i, hint: "\u300CSVG polyline / arc / rect / path\u300D \u306F\u5B9F\u88C5\u8A73\u7D30\u3001 \u300C\u301C \u3092\u793A\u3059\u56F3\u300D \u306B\u7F6E\u63DB" },
+  { pattern: /\bpolygon\b/i, hint: "\u300Cpolygon\u300D \u306F\u5B9F\u88C5\u7528\u8A9E\u3001 \u56F3\u306E\u610F\u5473\u3092\u8AAC\u660E\u3059\u308B\u81EA\u7136\u6587\u306B\u7F6E\u63DB" }
+];
+function lintDiagram(d) {
+  const issues = [];
+  issues.push(...ruleTopicRedundancy(d));
+  issues.push(...ruleEmptyChartData(d));
+  issues.push(...ruleGanttUnknownDependsOn(d));
+  issues.push(...ruleMindMapParentReference(d));
+  issues.push(...ruleTreeParentReference(d));
+  issues.push(...ruleQuadrantMissingItems(d));
+  issues.push(...ruleFunnelMonotonicCount(d));
+  return {
+    diagramId: d.id,
+    issues,
+    autoFixableCount: issues.filter((i) => i.autoFixable).length
+  };
+}
+function autoFix(d) {
+  const patched = {
+    ...d,
+    topic: applyTopicAutoFix(d.topic),
+    nodes: d.nodes.map((n) => ({ ...n }))
+  };
+  return patched;
+}
+var KIND_TO_JA = {
+  chart: "\u7D71\u8A08\u30C1\u30E3\u30FC\u30C8",
+  "line chart": "\u6298\u308C\u7DDA\u30B0\u30E9\u30D5",
+  "pie chart": "\u5186\u30B0\u30E9\u30D5",
+  "bar chart": "\u68D2\u30B0\u30E9\u30D5",
+  flow: "\u51E6\u7406\u306E\u6D41\u308C",
+  swimlane: "\u30B9\u30A4\u30E0\u30EC\u30FC\u30F3 (\u5F79\u5272\u5225\u30EC\u30FC\u30F3)",
+  sequence: "\u6642\u7CFB\u5217\u306E\u3084\u308A\u53D6\u308A",
+  topology: "\u30B7\u30B9\u30C6\u30E0\u69CB\u6210",
+  er: "\u30C6\u30FC\u30D6\u30EB\u95A2\u4FC2 (ER \u56F3)",
+  stateMachine: "\u72B6\u614B\u9077\u79FB (\u30B9\u30C6\u30FC\u30C8\u56F3)",
+  stateMachine2: "\u62E1\u5F35\u30B9\u30C6\u30FC\u30C8\u56F3 (\u968E\u5C64\u72B6\u614B)",
+  infrastructure: "\u30AF\u30E9\u30A6\u30C9\u69CB\u6210",
+  classDiagram: "UML \u30AF\u30E9\u30B9\u56F3",
+  tree: "\u968E\u5C64\u30C4\u30EA\u30FC",
+  userJourney: "\u30E6\u30FC\u30B6\u30FC\u30B8\u30E3\u30FC\u30CB\u30FC",
+  mindMap: "\u30DE\u30A4\u30F3\u30C9\u30DE\u30C3\u30D7",
+  mindMapRadial: "\u653E\u5C04\u72B6\u30DE\u30A4\u30F3\u30C9\u30DE\u30C3\u30D7",
+  funnel: "\u30D5\u30A1\u30CD\u30EB (\u6BB5\u968E\u5225\u96E2\u8131)",
+  quadrant: "\u56DB\u8C61\u9650\u30DE\u30C8\u30EA\u30AF\u30B9",
+  gantt: "\u30AC\u30F3\u30C8\u30C1\u30E3\u30FC\u30C8",
+  flowchart: "\u5206\u5C90\u30D5\u30ED\u30FC\u30C1\u30E3\u30FC\u30C8",
+  network: "\u30CD\u30C3\u30C8\u30EF\u30FC\u30AF\u69CB\u6210"
+};
+function applyTopicAutoFix(topic) {
+  const kindMatch = topic.match(
+    /^\s*(chart|flow|swimlane|sequence|topology|er|stateMachine2?|infrastructure|classDiagram|tree|userJourney|mindMap(?:Radial)?|funnel|quadrant|gantt|flowchart|network|line chart|pie chart|bar chart)\b/i
+  );
+  if (kindMatch) {
+    const kind = kindMatch[1].toLowerCase();
+    const canonical = Object.keys(KIND_TO_JA).find((k) => k.toLowerCase() === kind);
+    if (canonical) {
+      return `${KIND_TO_JA[canonical]} \u3092\u793A\u3059\u56F3`;
+    }
+  }
+  let out = topic;
+  out = out.replace(/\s*\([^)]*(preset|render|SVG|polygon|polyline|arc|rect|path)[^)]*\)/gi, "");
+  out = out.replace(/\b(preset|render)\b/gi, "");
+  out = out.replace(/\s+/g, " ").trim();
+  if (out.length < 3) return "\u56F3\u306E\u8AAC\u660E";
+  return out;
+}
+function ruleTopicRedundancy(d) {
+  const out = [];
+  for (const { pattern, hint } of REDUNDANT_TOPIC_PATTERNS) {
+    if (pattern.test(d.topic)) {
+      out.push({
+        rule: "topic-redundant-implementation-detail",
+        severity: "warn",
+        target: d.id,
+        message: `topic \u306B\u5B9F\u88C5\u8A73\u7D30\u304C\u542B\u307E\u308C\u308B: "${d.topic}"`,
+        suggestion: hint,
+        autoFixable: true
+      });
+    }
+  }
+  return out;
+}
+function ruleEmptyChartData(d) {
+  const out = [];
+  for (const n of d.nodes) {
+    if (n.kind === "chart-line" || n.kind === "chart-pie" || n.kind === "chart-bar") {
+      const data = n.chartData ?? [];
+      if (data.length === 0) {
+        out.push({
+          rule: "chart-empty-datum",
+          severity: "warn",
+          target: n.id,
+          message: `chart node "${n.id}" \u304C datum 0 \u4EF6\u3001 chart \u306F\u975E\u8868\u793A\u306B\u306A\u308B`,
+          suggestion: `.datum({ id: ..., label: ..., value: ... }) \u3092 1 \u4EF6\u4EE5\u4E0A\u8FFD\u52A0`,
+          autoFixable: false
+        });
+      }
+      if (data.length === 1) {
+        out.push({
+          rule: "chart-single-datum",
+          severity: "info",
+          target: n.id,
+          message: `chart node "${n.id}" \u304C datum 1 \u4EF6\u3001 \u6BD4\u8F03 / \u63A8\u79FB\u3068\u3057\u3066\u610F\u5473\u304C\u8584\u3044`,
+          suggestion: `2 \u4EF6\u4EE5\u4E0A\u306E datum \u3092\u63A8\u5968 (line \u7CFB\u306F 3 \u4EF6\u4EE5\u4E0A\u3067 trend \u304C\u898B\u3048\u308B)`,
+          autoFixable: false
+        });
+      }
+    }
+  }
+  return out;
+}
+function ruleGanttUnknownDependsOn(d) {
+  const out = [];
+  for (const n of d.nodes) {
+    if (n.kind === "gantt-timeline") {
+      const tasks = n.ganttData ?? [];
+      const ids = new Set(tasks.map((t) => t.id));
+      for (const t of tasks) {
+        if (t.dependsOn && !ids.has(t.dependsOn)) {
+          out.push({
+            rule: "gantt-unknown-depends-on",
+            severity: "warn",
+            target: t.id,
+            message: `task "${t.id}" \u304C\u672A\u5B9A\u7FA9 task "${t.dependsOn}" \u306B dependsOn \u53C2\u7167`,
+            suggestion: `\u53C2\u7167\u5148 id \u3092\u4FEE\u6B63 or dependsOn \u3092\u9664\u53BB`,
+            autoFixable: false
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+function ruleMindMapParentReference(d) {
+  const out = [];
+  for (const n of d.nodes) {
+    if ((n.kind === "mind-map" || n.kind === "mind-radial") && n.mindData) {
+      const known = /* @__PURE__ */ new Set([n.mindData.rootId]);
+      for (const b of n.mindData.branches) known.add(b.id);
+      for (const b of n.mindData.branches) {
+        if (!known.has(b.parent)) {
+          out.push({
+            rule: "mindmap-unknown-parent",
+            severity: "warn",
+            target: b.id,
+            message: `branch "${b.id}" \u304C\u672A\u5B9A\u7FA9 parent "${b.parent}" \u3092\u53C2\u7167`,
+            suggestion: `parent \u3092 rootId ("${n.mindData.rootId}") \u307E\u305F\u306F\u65E2\u5B58 branch id \u306B\u4FEE\u6B63`,
+            autoFixable: false
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+function ruleTreeParentReference(d) {
+  const out = [];
+  for (const n of d.nodes) {
+    if (n.kind === "tree-hierarchy" && n.treeData) {
+      const ids = new Set(n.treeData.map((t) => t.id));
+      for (const t of n.treeData) {
+        if (t.parent && !ids.has(t.parent)) {
+          out.push({
+            rule: "tree-unknown-parent",
+            severity: "warn",
+            target: t.id,
+            message: `tree node "${t.id}" \u304C\u672A\u5B9A\u7FA9 parent "${t.parent}" \u3092\u53C2\u7167`,
+            suggestion: `parent id \u3092\u65E2\u5B58 tree node \u306B\u4FEE\u6B63 or parent \u9664\u53BB (root \u306B\u3059\u308B)`,
+            autoFixable: false
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+function ruleQuadrantMissingItems(d) {
+  const out = [];
+  for (const n of d.nodes) {
+    if (n.kind === "quadrant-matrix" && n.quadrantData) {
+      const items = n.quadrantData.items;
+      if (items.length === 0) {
+        out.push({
+          rule: "quadrant-empty",
+          severity: "warn",
+          target: n.id,
+          message: `quadrant "${n.id}" \u304C item 0 \u4EF6\u3001 \u8EF8\u306E\u307F\u8868\u793A\u3055\u308C\u308B`,
+          suggestion: `.item({ id: ..., title: ..., quadrant: "topLeft" | ... }) \u3092 1 \u4EF6\u4EE5\u4E0A\u8FFD\u52A0`,
+          autoFixable: false
+        });
+      }
+      const bySlot = new Set(items.map((it) => it.quadrant));
+      if (items.length >= 4 && bySlot.size === 1) {
+        out.push({
+          rule: "quadrant-single-quadrant",
+          severity: "info",
+          target: n.id,
+          message: `quadrant "${n.id}" \u306E item \u304C 1 \u8C61\u9650\u306B\u96C6\u4E2D\u3001 \u30DE\u30C8\u30EA\u30AF\u30B9\u306E\u610F\u5473\u304C\u8584\u3044`,
+          suggestion: `2 \u8C61\u9650\u4EE5\u4E0A\u306B item \u3092\u5206\u6563 (SWOT / Priority matrix \u7B49\u306F 4 \u8C61\u9650 balanced \u3092\u63A8\u5968)`,
+          autoFixable: false
+        });
+      }
+    }
+  }
+  return out;
+}
+function ruleFunnelMonotonicCount(d) {
+  const out = [];
+  for (const n of d.nodes) {
+    if (n.kind === "funnel-stages" && n.funnelData) {
+      const stages = n.funnelData;
+      for (let i = 1; i < stages.length; i++) {
+        if (stages[i].count > stages[i - 1].count) {
+          out.push({
+            rule: "funnel-increasing-count",
+            severity: "warn",
+            target: stages[i].id,
+            message: `stage "${stages[i].id}" (${stages[i].count}) \u304C\u524D\u6BB5 (${stages[i - 1].count}) \u3088\u308A\u5897\u52A0\u3001 funnel \u306F\u5358\u8ABF\u6E1B\u5C11\u304C\u671F\u5F85\u3055\u308C\u308B`,
+            suggestion: `stage \u9806\u3092\u518D\u78BA\u8A8D\u3001 \u5897\u52A0 pattern \u306A\u3089\u5225 preset (chart-line \u7B49) \u3092\u691C\u8A0E`,
+            autoFixable: false
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+var DIAGRAM_BOUNDARY_PADDING = 20;
+function computeDiagramBoundingBox(diag) {
+  const laid = layout(diag);
+  const vb = laid.viewBox;
+  return {
+    x: vb.x - DIAGRAM_BOUNDARY_PADDING,
+    y: vb.y - DIAGRAM_BOUNDARY_PADDING,
+    width: vb.w + DIAGRAM_BOUNDARY_PADDING * 2,
+    height: vb.h + DIAGRAM_BOUNDARY_PADDING * 2
+  };
+}
+function rectsOverlap(a, b) {
+  const aRight = a.x + a.width;
+  const aBottom = a.y + a.height;
+  const bRight = b.x + b.width;
+  const bBottom = b.y + b.height;
+  return a.x < bRight && aRight > b.x && a.y < bBottom && aBottom > b.y;
+}
+
+// src/write-position.ts
+function writeActorPosition(src, actorName, posX, posY) {
+  if (!Number.isFinite(posX) || !Number.isFinite(posY)) return null;
+  const x = Math.round(posX);
+  const y = Math.round(posY);
+  const seg = src.split(/(\r\n|\n)/);
+  const lineAt = (i) => seg[i * 2] ?? "";
+  const lineCount = Math.ceil(seg.length / 2);
+  const span = actorsSpan(lineAt, lineCount);
+  if (!span) return null;
+  for (let i = span.from; i < span.to; i += 1) {
+    const head = matchActorHead(lineAt(i));
+    if (!head || head.name !== actorName) continue;
+    if (head.rest.startsWith("{") && head.rest.endsWith("}")) {
+      seg[i * 2] = `${head.prefix}{ ${upsertInlineFields(head.rest.slice(1, -1), x, y)} }`;
+      return seg.join("");
+    }
+    if (head.hasColon && head.rest === "") {
+      return writeVerticalForm(seg, i, span.to, head.indent, x, y);
+    }
+    if (head.hasColon) {
+      seg[i * 2] = `${head.prefix}${upsertAtToken(head.rest, x, y)}`;
+      return seg.join("");
+    }
+    seg[i * 2] = `${head.indentText}- ${head.rawName}: @${x},${y}`;
+    return seg.join("");
+  }
+  return null;
+}
+function actorsSpan(lineAt, lineCount) {
+  let from = -1;
+  let to = lineCount;
+  for (let i = 0; i < lineCount; i += 1) {
+    const line = lineAt(i);
+    if (/^actors[ \t]*:[ \t]*$/.test(line)) {
+      from = i + 1;
+      to = lineCount;
+      continue;
+    }
+    if (from >= 0 && to === lineCount && /^[^\s#][^:]*:/.test(line)) to = i;
+  }
+  return from < 0 ? null : { from, to };
+}
+function matchActorHead(line) {
+  const NAME = String.raw`"(?:[^"\\]|\\.)*"|[^:\s][^:]*?`;
+  const withColon = line.match(new RegExp(String.raw`^(\s*)-[ \t]+(${NAME})[ \t]*:[ \t]*(.*)$`));
+  if (withColon) {
+    const [, indentText2 = "", rawName2 = "", rest = ""] = withColon;
+    return {
+      // 元の空白の入れ方を壊さないよう、 行頭から値の直前までをそのまま持つ
+      prefix: line.slice(0, line.length - rest.length),
+      indentText: indentText2,
+      indent: indentText2.length,
+      rawName: rawName2,
+      name: unquote(rawName2),
+      hasColon: true,
+      rest: rest.trimEnd()
+    };
+  }
+  const nameOnly = line.match(new RegExp(String.raw`^(\s*)-[ \t]+("(?:[^"\\]|\\.)*"|\S+)[ \t]*$`));
+  if (!nameOnly) return null;
+  const [, indentText = "", rawName = ""] = nameOnly;
+  return {
+    prefix: line,
+    indentText,
+    indent: indentText.length,
+    rawName,
+    name: unquote(rawName),
+    hasColon: false,
+    rest: ""
+  };
+}
+function unquote(raw) {
+  if (!raw.startsWith('"') || !raw.endsWith('"') || raw.length < 2) return raw;
+  return raw.slice(1, -1).replace(/\\(.)/g, "$1");
+}
+function upsertAtToken(rest, x, y) {
+  const kept = splitOutsideQuotes(rest).filter((t) => !/^@-?\d+(\.\d+)?\s*[,、]\s*-?\d+(\.\d+)?$/.test(t));
+  kept.push(`@${x},${y}`);
+  return kept.join(" ");
+}
+function splitOutsideQuotes(s) {
+  const out = [];
+  let buf = "";
+  let quote = null;
+  let depth = 0;
+  for (let i = 0; i < s.length; i += 1) {
+    const c = s[i];
+    if (quote) {
+      buf += c;
+      if (quote === '"' && c === "\\") {
+        buf += s[i + 1] ?? "";
+        i += 1;
+        continue;
+      }
+      if (c === quote) quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      buf += c;
+      continue;
+    }
+    if (c === "[") depth += 1;
+    if (c === "]") depth -= 1;
+    if (/\s/.test(c) && depth === 0) {
+      if (buf) out.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += c;
+  }
+  if (buf) out.push(buf);
+  return out;
+}
+function upsertInlineFields(inner, x, y) {
+  const kept = splitTopLevel(inner).filter((f) => {
+    const key = f.slice(0, f.indexOf(":")).trim();
+    return key !== "posX" && key !== "posY";
+  });
+  kept.push(`posX: ${x}`, `posY: ${y}`);
+  return kept.join(", ");
+}
+function splitTopLevel(inner) {
+  const out = [];
+  let depth = 0;
+  let start = 0;
+  let quote = null;
+  for (let i = 0; i < inner.length; i += 1) {
+    const c = inner[i];
+    if (quote) {
+      if (quote === '"' && c === "\\") {
+        i += 1;
+        continue;
+      }
+      if (c === quote) quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'") quote = c;
+    else if (c === "{" || c === "[") depth += 1;
+    else if (c === "}" || c === "]") depth -= 1;
+    else if (c === "," && depth === 0) {
+      out.push(inner.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(inner.slice(start));
+  return out.map((f) => f.trim()).filter((f) => f.length > 0);
+}
+function writeVerticalForm(seg, headIdx, lineCount, headIndent, x, y) {
+  let lastChild = -1;
+  let childIndent = -1;
+  for (let j = headIdx + 1; j < lineCount; j += 1) {
+    const line = seg[j * 2] ?? "";
+    if (line.trim() === "") continue;
+    const indent2 = line.length - line.trimStart().length;
+    if (indent2 <= headIndent) break;
+    if (childIndent < 0) childIndent = indent2;
+    lastChild = j;
+    const key = indent2 === childIndent ? line.trim().match(/^(位置|pos)\s*:/) : null;
+    if (key) {
+      seg[j * 2] = `${" ".repeat(indent2)}${key[1]}: ${x},${y}`;
+      return seg.join("");
+    }
+  }
+  const indent = childIndent >= 0 ? childIndent : headIndent + 4;
+  const newLine = `${" ".repeat(indent)}\u4F4D\u7F6E: ${x},${y}`;
+  const insertAt = (lastChild >= 0 ? lastChild : headIdx) + 1;
+  const sep = seg[insertAt * 2 - 1] ?? seg[seg.length - 2] ?? "\n";
+  if (insertAt * 2 >= seg.length) seg.push(sep, newLine);
+  else seg.splice(insertAt * 2, 0, newLine, sep);
+  return seg.join("");
+}
+
+// src/json-parser.ts
+var VALID_KIND_SET = /* @__PURE__ */ new Set([
+  "actor",
+  "function",
+  "storage",
+  "event",
+  "cdn",
+  "service",
+  "database",
+  "cache",
+  "queue",
+  "api",
+  "person",
+  "entity",
+  "state",
+  "container",
+  "card",
+  "lambda",
+  "kms",
+  "secret",
+  "alb",
+  "ecs",
+  "rds",
+  "s3",
+  "iam",
+  "user",
+  "browser",
+  "contract",
+  "eoa",
+  "multisig",
+  "proxy",
+  "library",
+  "interface"
+]);
+var VALID_PRESETS = [
+  "sequence",
+  "flow",
+  "swimlane",
+  "er",
+  "state",
+  "topology",
+  "solidity",
+  "gantt",
+  "class",
+  "pie",
+  "c4",
+  "mind"
+];
+function validateLayoutPos(v, path, errors) {
+  if (v === void 0) return;
+  if (!v || typeof v !== "object" || Array.isArray(v)) {
+    errors.push({ path, message: "pos must be an object with x and y numbers" });
+    return;
+  }
+  const p = v;
+  if (typeof p.x !== "number" || !Number.isFinite(p.x)) {
+    errors.push({ path: `${path}.x`, message: "pos.x must be a finite number" });
+  }
+  if (typeof p.y !== "number" || !Number.isFinite(p.y)) {
+    errors.push({ path: `${path}.y`, message: "pos.y must be a finite number" });
+  }
+}
+function validateJson(json) {
+  const errors = [];
+  if (!json || typeof json !== "object" || Array.isArray(json)) {
+    return { ok: false, errors: [{ path: "$", message: "root must be a JSON object" }] };
+  }
+  const j = json;
+  if (typeof j.title !== "string" || j.title.length === 0) {
+    errors.push({ path: "$.title", message: "title must be a non-empty string" });
+  }
+  if (j.layout !== void 0 && j.layout !== "auto" && j.layout !== "manual") {
+    errors.push({ path: "$.layout", message: 'layout must be "auto" or "manual" if present' });
+  }
+  if (typeof j.type !== "string" || !VALID_PRESETS.includes(j.type)) {
+    errors.push({
+      path: "$.type",
+      message: `type must be one of: ${VALID_PRESETS.join(", ")}`,
+      hint: typeof j.type === "string" ? `got "${j.type}"` : void 0
+    });
+  }
+  if (!Array.isArray(j.actors) || j.actors.length === 0) {
+    errors.push({ path: "$.actors", message: "actors must be a non-empty array" });
+  } else {
+    j.actors.forEach((a, i) => {
+      if (typeof a === "string") return;
+      if (!a || typeof a !== "object" || Array.isArray(a)) {
+        errors.push({ path: `$.actors[${i}]`, message: "actor must be string or object" });
+        return;
+      }
+      const ao = a;
+      if (typeof ao.name !== "string" || ao.name.length === 0) {
+        errors.push({ path: `$.actors[${i}].name`, message: "actor.name must be a non-empty string" });
+      }
+      if (ao.kind !== void 0 && (typeof ao.kind !== "string" || ao.kind.length === 0)) {
+        errors.push({ path: `$.actors[${i}].kind`, message: "actor.kind must be a non-empty string" });
+      }
+      if (ao.state !== void 0) {
+        if (!ao.state || typeof ao.state !== "object" || Array.isArray(ao.state)) {
+          errors.push({ path: `$.actors[${i}].state`, message: "actor.state must be a plain object" });
+        } else {
+          for (const [sk, sv] of Object.entries(ao.state)) {
+            const svType = typeof sv;
+            if (svType !== "number" && svType !== "string" && svType !== "boolean") {
+              errors.push({
+                path: `$.actors[${i}].state.${sk}`,
+                message: `actor.state.${sk} must be number / string / boolean (got ${sv === null ? "null" : svType})`
+              });
+            }
+          }
+        }
+      }
+      validateLayoutPos(ao.pos, `$.actors[${i}].pos`, errors);
+    });
+  }
+  if (!Array.isArray(j.flow)) {
+    errors.push({ path: "$.flow", message: "flow must be an array" });
+  } else {
+    j.flow.forEach((s, i) => {
+      if (!s || typeof s !== "object" || Array.isArray(s)) {
+        errors.push({ path: `$.flow[${i}]`, message: "step must be an object" });
+        return;
+      }
+      const so = s;
+      if (typeof so.from !== "string") errors.push({ path: `$.flow[${i}].from`, message: "step.from must be a string" });
+      if (typeof so.to !== "string") errors.push({ path: `$.flow[${i}].to`, message: "step.to must be a string" });
+      if (typeof so.label !== "string") errors.push({ path: `$.flow[${i}].label`, message: "step.label must be a string" });
+      validateLayoutPos(so.pos, `$.flow[${i}].pos`, errors);
+    });
+  }
+  if (j.lanes !== void 0 && j.lanes && typeof j.lanes === "object" && !Array.isArray(j.lanes)) {
+    for (const [laneId, lane] of Object.entries(j.lanes)) {
+      if (lane && typeof lane === "object" && !Array.isArray(lane)) {
+        validateLayoutPos(lane.pos, `$.lanes.${laneId}.pos`, errors);
+      }
+    }
+  }
+  if (j.animation !== void 0) {
+    if (!Array.isArray(j.animation)) {
+      errors.push({ path: "$.animation", message: "animation must be an array if present" });
+    } else {
+      j.animation.forEach((p, i) => {
+        if (!p || typeof p !== "object" || Array.isArray(p)) {
+          errors.push({ path: `$.animation[${i}]`, message: "phase must be an object" });
+          return;
+        }
+        const po = p;
+        if (typeof po.step !== "string" || po.step.length === 0) {
+          errors.push({ path: `$.animation[${i}].step`, message: "phase.step must be a non-empty string" });
+        }
+      });
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, data: j };
+}
+function jsonToDoc(json) {
+  const p0 = { line: 0 };
+  const actors = json.actors.map((a) => {
+    if (typeof a === "string") {
+      return { name: a, kind: "actor", kindWritten: false, pos: p0 };
+    }
+    const kindStr = a.kind ?? "actor";
+    const isPart = kindStr !== "actor" && !VALID_KIND_SET.has(kindStr);
+    return {
+      name: a.name,
+      kind: isPart ? "actor" : a.kind ?? "actor",
+      // parts 候補は `kind` を `actor` に倒して `partId` へ退避するため、 名札に載せる種類としては
+      // 「書かなかった」 と同じ扱いにする (#1058)
+      kindWritten: a.kind !== void 0 && !isPart,
+      subtitle: a.subtitle,
+      eyebrow: a.eyebrow,
+      value: a.value,
+      rows: a.rows,
+      lane: a.lane,
+      stack: a.stack,
+      initial: a.initial,
+      final: a.final,
+      partId: isPart ? kindStr : void 0,
+      stateOverride: isPart ? a.state : void 0,
+      // CAR-1693 Phase 1: DSL 表面 pos → 内部 AST layoutPos の 2 層 mapping (naming collision 回避)
+      layoutPos: a.pos,
+      pos: p0
+    };
+  });
+  const flow2 = json.flow.map((s, i) => ({
+    no: i + 1,
+    from: s.from,
+    to: s.to,
+    label: s.label,
+    sub: s.sub,
+    tone: s.tone,
+    style: s.style,
+    guard: s.guard,
+    cardinality: s.cardinality,
+    labelOffsetX: s.labelOffsetX,
+    labelOffsetY: s.labelOffsetY,
+    // CAR-1693 Phase 1: DSL 表面 pos → 内部 AST layoutPos
+    layoutPos: s.pos,
+    pos: p0
+  }));
+  let animate;
+  if (json.animation && json.animation.length > 0) {
+    const phases = json.animation.map((p) => ({
+      name: p.step,
+      durationMs: Math.round((p.duration ?? 1.4) * 1e3),
+      highlight: p.focus,
+      body: p.body,
+      badge: p.badge,
+      pos: p0
+    }));
+    animate = { states: [], phases, pos: p0 };
+  }
+  return {
+    title: json.title,
+    type: json.type,
+    actors,
+    flow: flow2,
+    animate,
+    viewport: json.viewport ? { ...json.viewport, pos: p0 } : void 0,
+    lanes: json.lanes ? Object.fromEntries(
+      Object.entries(json.lanes).map(([id, l]) => {
+        const { pos: layoutPos, ...laneRest } = l;
+        return [id, { id, ...laneRest, layoutPos, pos: p0 }];
+      })
+    ) : void 0,
+    groups: json.groups ? Object.fromEntries(
+      Object.entries(json.groups).map(([id, g]) => [id, { id, label: g.label, lanes: g.lanes, pos: p0 }])
+    ) : void 0,
+    // CAR-1693 Phase 1: diagram-level layout mode (auto|manual)、 未指定は undefined = auto default
+    layout: json.layout,
+    pos: p0
+  };
+}
+function jsonToDiagram(json, opts) {
+  const v = validateJson(json);
+  if (!v.ok) {
+    const msg = v.errors.map((e) => `  ${e.path}: ${e.message}${e.hint ? ` (${e.hint})` : ""}`).join("\n");
+    throw new Error(`Dragon JSON DSL validation error:
+${msg}`);
+  }
+  const doc = jsonToDoc(v.data);
+  return compileToCdl(doc, opts);
+}
+function validateDragonJson(json) {
+  return validateJson(json);
+}
+
+// src/schemas/diagram.json
+var diagram_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://github.com/cardene777/dragon/schemas/diagram.json",
+  title: "Dragon DSL Diagram",
+  description: "LLM \u5411\u3051 Dragon DSL \u306E JSON Schema\u3002 Anthropic Claude tool use / OpenAI GPT structured output \u306E schema field \u306B\u6CE8\u5165\u3057\u3066\u4F7F\u3046\u3002 \u751F\u6210\u3055\u308C\u305F JSON \u306F jsonToDiagram() \u306B\u6E21\u3057\u3066 CdlDiagram \u306B\u5909\u63DB\u3059\u308B\u3002",
+  type: "object",
+  required: ["title", "type", "actors", "flow"],
+  additionalProperties: false,
+  properties: {
+    title: {
+      type: "string",
+      minLength: 1,
+      description: "\u56F3\u306E title (\u753B\u9762\u4E0A\u90E8\u306B\u8868\u793A\u3055\u308C\u308B\u898B\u51FA\u3057)"
+    },
+    type: {
+      type: "string",
+      enum: ["sequence", "flow", "swimlane", "er", "state", "topology", "solidity", "gantt", "class", "pie", "c4", "mind"],
+      description: "preset type = \u56F3\u306E\u7A2E\u985E\u3002 sequence (\u6642\u7CFB\u5217 API \u547C\u3073\u51FA\u3057) / flow (\u51E6\u7406 flow) / swimlane (\u8CAC\u52D9\u5206\u62C5 flow) / er (DB schema) / state (\u72B6\u614B\u9077\u79FB) / topology (network) / solidity (contract) / gantt (schedule) / class (UML class) / pie (\u5186\u30B0\u30E9\u30D5) / c4 (architecture) / mind (mind map)"
+    },
+    actors: {
+      type: "array",
+      minItems: 1,
+      description: "\u767B\u5834\u4EBA\u7269 (node) \u306E\u914D\u5217\u3002 \u6587\u5B57\u5217\u3067 name \u306E\u307F\u3001 \u307E\u305F\u306F object \u3067 kind / subtitle \u7B49\u3092\u6307\u5B9A\u3002",
+      items: {
+        oneOf: [
+          {
+            type: "string",
+            description: "actor \u540D\u306E\u307F (kind \u306F default 'actor')"
+          },
+          {
+            type: "object",
+            required: ["name"],
+            additionalProperties: false,
+            properties: {
+              name: { type: "string", minLength: 1, description: "actor \u540D (flow \u306E from / to \u3067\u53C2\u7167\u3055\u308C\u308B)" },
+              kind: {
+                type: "string",
+                description: "node kind\u3002 shape-* \u3092\u6307\u5B9A\u3057\u3066 49 shape \u4E2D\u304B\u3089\u9078\u3076\u3002 \u4F8B: 'shape-wallet' / 'shape-smart-contract' / 'shape-cloud' / 'shape-file' / 'actor' (default) / 'function' / 'storage' / 'event' \u7B49"
+              },
+              subtitle: { type: "string", description: "node \u4E0B\u90E8\u306E\u88DC\u8DB3\u30C6\u30AD\u30B9\u30C8" },
+              eyebrow: { type: "string", description: "node \u4E0A\u90E8\u306E\u5206\u985E\u30E9\u30D9\u30EB (accent \u8272)" },
+              value: { type: "string", description: "actor \u6570\u5024\u8868\u793A (kind: actor \u7528)" },
+              rows: { type: "array", items: { type: "string" }, description: "storage \u5185\u306E column \u5217 (kind: storage \u7528)" },
+              lane: { type: "string", description: "swimlane / topology \u3067\u5C5E\u3059\u308B lane id" },
+              stack: { type: "integer", minimum: 0, description: "lane \u5185\u306E\u7E26\u4F4D\u7F6E (0-based)" },
+              initial: { type: "boolean", description: "state \u958B\u59CB\u70B9 (kind: state \u7528)" },
+              final: { type: "boolean", description: "state \u7D42\u4E86\u70B9 (kind: state \u7528)" }
+            }
+          }
+        ]
+      }
+    },
+    flow: {
+      type: "array",
+      description: "step \u306E\u914D\u5217 (\u77E2\u5370\u3067 actor \u9593\u3092\u7E4B\u3050)\u3002 sequence \u3067\u306F\u9806\u5E8F\u304C\u610F\u5473\u3092\u6301\u3064\u3002",
+      items: {
+        type: "object",
+        required: ["from", "to", "label"],
+        additionalProperties: false,
+        properties: {
+          from: { type: "string", description: "\u8D77\u70B9 actor \u540D" },
+          to: { type: "string", description: "\u7D42\u70B9 actor \u540D" },
+          label: { type: "string", description: "\u77E2\u5370\u4E0A\u306E\u30E9\u30D9\u30EB (\u95A2\u6570\u547C\u51FA\u3057\u540D / \u30E1\u30C3\u30BB\u30FC\u30B8\u7B49)" },
+          sub: { type: "string", description: "\u30E9\u30D9\u30EB\u4E0B\u306E\u88DC\u8DB3" },
+          tone: { type: "string", enum: ["accent", "success", "warning", "danger"], description: "\u77E2\u5370\u306E\u8272\u8ABF" },
+          style: { type: "string", enum: ["solid", "dashed", "dotted", "dotted-flow"], description: "\u77E2\u5370\u306E\u7DDA\u7A2E" },
+          guard: { type: "string", description: "state \u9077\u79FB\u306E\u6761\u4EF6 (kind: state \u7528)" },
+          cardinality: { type: "string", description: "ER \u306E\u591A\u91CD\u5EA6 (1..N \u7B49\u3001 kind: er \u7528)" },
+          labelOffsetX: { type: "number", description: "\u30E9\u30D9\u30EB\u4F4D\u7F6E x \u8ABF\u6574" },
+          labelOffsetY: { type: "number", description: "\u30E9\u30D9\u30EB\u4F4D\u7F6E y \u8ABF\u6574" }
+        }
+      }
+    },
+    animation: {
+      type: "array",
+      description: "\u30A2\u30CB\u30E1\u30FC\u30B7\u30E7\u30F3 phase \u914D\u5217\u3002 \u5404 phase \u3067 focus \u5BFE\u8C61\u3092 highlight \u3059\u308B\u3002 optional\u3002",
+      items: {
+        type: "object",
+        required: ["step"],
+        additionalProperties: false,
+        properties: {
+          step: { type: "string", minLength: 1, description: "phase \u540D" },
+          duration: { type: "number", minimum: 0.1, description: "phase \u6642\u9593 (\u79D2\u3001 default 1.4)" },
+          focus: { type: "array", items: { type: "string" }, description: "\u3053\u306E phase \u3067 active \u5316\u3059\u308B actor \u540D or edge 'A -> B' \u306E\u914D\u5217" },
+          body: { type: "string", description: "phase \u8AAC\u660E\u6587" },
+          badge: { type: "string", description: "phase \u4E2D\u306B\u8868\u793A\u3059\u308B badge label" }
+        }
+      }
+    },
+    viewport: {
+      type: "object",
+      description: "\u5168\u4F53 canvas \u30B5\u30A4\u30BA + gap \u306E\u8ABF\u6574\u3002 optional\u3002",
+      additionalProperties: false,
+      properties: {
+        width: { type: "number", minimum: 100 },
+        height: { type: "number", minimum: 100 },
+        laneWidth: { type: "number", minimum: 100 },
+        gap: { type: "number", minimum: 0 },
+        laneGap: { type: "number", minimum: 0 },
+        nodeGap: { type: "number", minimum: 0 },
+        labelMargin: { type: "number", minimum: 0 }
+      }
+    },
+    lanes: {
+      type: "object",
+      description: "swimlane / topology \u3067\u4F7F\u3046 lane \u5BA3\u8A00\u3002 key = lane id\u3001 value = lane \u5B9A\u7FA9\u3002",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          x: { type: "number" },
+          width: { type: "number", minimum: 50 },
+          label: { type: "string" },
+          contain: { type: "boolean" },
+          lifeline: { type: "boolean" }
+        }
+      }
+    },
+    groups: {
+      type: "object",
+      description: "topology \u3067\u4F7F\u3046 group \u5BA3\u8A00\u3002 key = group id\u3001 value = { label, lanes }\u3002",
+      additionalProperties: {
+        type: "object",
+        required: ["lanes"],
+        additionalProperties: false,
+        properties: {
+          label: { type: "string" },
+          lanes: { type: "array", items: { type: "string" }, minItems: 1 }
+        }
+      }
+    }
+  }
+};
+
+// src/schema.ts
+var diagramJsonSchema = diagram_default;
+
+// src/index.ts
+function textDslToDiagram(src, opts) {
+  const oversize = describeOversizeSource(src);
+  if (oversize) throw new Error(oversize);
+  if (isV05Source(src)) {
+    const r2 = parseTextDslV05(src);
+    if (!r2.ok) {
+      const msg = r2.errors.map((e) => `  L${e.line}: ${e.message}${e.hint ? `
+         hint: ${e.hint}` : ""}`).join("\n");
+      throw new Error(`Dragon DSL v0.5 parse error:
+${msg}`);
+    }
+    return compileToCdl(r2.doc, opts);
+  }
+  if (typeof console !== "undefined" && console.warn) {
+    console.warn(
+      "[dragon] v0.4 syntax (Japanese keywords) is deprecated. Please migrate to v0.5 (English keywords) by 2026-12-31."
+    );
+  }
+  const r = parseTextDsl(src);
+  if (!r.ok) {
+    const msg = r.errors.map((e) => `  L${e.line}: ${e.message}${e.hint ? `
+         \u30D2\u30F3\u30C8: ${e.hint}` : ""}`).join("\n");
+    throw new Error(`Dragon DSL parse error:
+${msg}`);
+  }
+  return compileToCdl(r.doc, opts);
+}
+function isV05Source(src) {
+  const V04_KEYWORDS = [
+    // Japanese v0.4 専用 keyword (v0.5 は英語のみ)
+    /^\s*タイトル\s*[:：]/,
+    // title (JA)
+    /^\s*種類\s*[:：]/,
+    // type (JA)
+    /^\s*登場人物\s*[:：]/,
+    // actors (JA)
+    /^\s*流れ\s*[:：]/,
+    // flow (JA)
+    /^\s*アニメーション\s*[:：]/,
+    // animation (JA)
+    /^\s*動作\s*[:：]/,
+    // step (JA)
+    /^\s*状態\s*[:：]/,
+    // state (JA)
+    /^\s*ステップ\s*[「『]/,
+    // step (JA)
+    // v0.4 English-specific syntax = colon なし step (v0.5 は step: 必須)
+    /^\s*step\s+"[^"]+"\s+[\d.]+\s*s\b/,
+    /^\s*step\s+'[^']+'\s+[\d.]+\s*s\b/,
+    // v0.4 numbered flow (`1. A → B`、 v0.5 は `- A -> B`)
+    /^\s*\d+\.\s+\S+\s*(?:→|->)\s*\S+/
+  ];
+  const lines = src.split("\n");
+  for (const ln of lines) {
+    for (const kw of V04_KEYWORDS) {
+      if (kw.test(ln)) return false;
+    }
+  }
+  return true;
+}
+
+export { DIAGRAM_BOUNDARY_PADDING, MAX_INPUT_BYTES, MAX_INPUT_ELEMENTS, MAX_PART_SCALE, NODE_KIND_ALIAS, NODE_KIND_VALID, PRESET_TYPES, RELATIVE_GAP_DEFAULT, TONE_ALIAS, autoFix, compileToCdl, computeDiagramBoundingBox, countBytes, countDiagramElements, countDocElements, describeOversize, describeOversizeSource, diagramJsonSchema, isColorValue, jsonToDiagram, lintDiagram, measureActorBoxes, normalizePartScale, orderByDependency, parseFocusEntry, parseRelativePos, parseTextDsl, parseTextDslV05, partBoxInFrame, partDrawsInDiagram, partIsMeasurable, partRenderSize, partScaleFactor, partTargetScale, partTargetSize, partVisualSize, partsGridCenters, pointsOutside, rectsOverlap, resolveRelativePos, stripExternalPaint, stripQuotes, textDslToDiagram, validateDragonJson, writeActorPosition };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map