@cardenelabs/dragon 0.34.0 → 0.35.1

package/dist/export.js

@@ -0,0 +1,3907 @@
+import { mkdirSync, writeFileSync, rmSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { createRequire } from 'module';
+import { readFile } from 'fs/promises';
+
+// src/export/index.ts
+
+// src/look/palettes.json
+var palettes_default = {
+  clear: {
+    name: "\u6F84\u3093\u3060\u8272",
+    note: "\u767D\u3044\u5730\u306B\u3001\u4E2D\u304F\u3089\u3044\u306E\u660E\u308B\u3055\u306E\u9BAE\u3084\u304B\u306A 6 \u8272\u3002\u4ECA\u306E\u898B\u672C\u5E33\u306E\u8272",
+    light: {
+      page: "#f3f4f7",
+      bg: "#ffffff",
+      surf: "#ffffff",
+      sunk: "#f5f6f8",
+      ink: "#12141a",
+      ink2: "#3f4451",
+      mute: "#6b7180",
+      hair: "#12141a1c",
+      line: "#12141a40",
+      sh: "#101828",
+      "on-c": "#ffffff",
+      "c-blue": "#467deb",
+      "t-blue": "#2e62ce",
+      "c-amber": "#d28008",
+      "t-amber": "#975b04",
+      "c-green": "#0ea886",
+      "t-green": "#07775e",
+      "c-violet": "#6c3bb2",
+      "t-violet": "#6c3bb2",
+      "c-rose": "#ba3e40",
+      "t-rose": "#b83c3f",
+      "c-slate": "#5d6677",
+      "t-slate": "#5d6677",
+      coin: "#e9b114",
+      coint: "#856300",
+      coinin: "#a8740c",
+      tint: "5%",
+      edge: "20%",
+      shA: ".05",
+      shB: ".08",
+      carry: "#65686f"
+    },
+    dark: {
+      page: "#08090c",
+      bg: "#0d0e12",
+      surf: "#17191f",
+      sunk: "#121419",
+      ink: "#eceef3",
+      ink2: "#c4c8d2",
+      mute: "#9198a6",
+      hair: "#eceef31f",
+      line: "#eceef340",
+      sh: "#000000",
+      "on-c": "#0d0e12",
+      "c-blue": "#7e7ef6",
+      "t-blue": "#989cfd",
+      "c-amber": "#c78135",
+      "t-amber": "#dd954b",
+      "c-green": "#20ac7a",
+      "t-green": "#35b986",
+      "c-violet": "#695b9f",
+      "t-violet": "#a79ae3",
+      "c-rose": "#bc434b",
+      "t-rose": "#fd7d81",
+      "c-slate": "#9ba3b2",
+      "t-slate": "#9da5b4",
+      coin: "#f0c040",
+      coint: "#f0c040",
+      coinin: "#9a6a0c",
+      tint: "6%",
+      edge: "19%",
+      shA: ".45",
+      shB: ".35"
+    }
+  },
+  paper: {
+    name: "\u7D19\u3068\u58A8",
+    note: "\u751F\u6210\u308A\u306E\u7D19\u306E\u5730\u306B\u3001\u85CD / \u9EC4\u571F / \u82D4 / \u8461\u8404 / \u6731 / \u920D\u306E\u304F\u3059\u3093\u3060 6 \u8272",
+    light: {
+      page: "#ece7dd",
+      bg: "#f9f6f0",
+      surf: "#fffcf6",
+      sunk: "#f2ede4",
+      ink: "#221e18",
+      ink2: "#4b453b",
+      mute: "#7b7366",
+      hair: "#221e181f",
+      line: "#221e1847",
+      sh: "#3a2a10",
+      "on-c": "#fffcf6",
+      "c-blue": "#487dd5",
+      "t-blue": "#2d60b5",
+      "c-amber": "#c38405",
+      "t-amber": "#885a01",
+      "c-green": "#57a271",
+      "t-green": "#237143",
+      "c-violet": "#904698",
+      "t-violet": "#904698",
+      "c-rose": "#a9513e",
+      "t-rose": "#9f4836",
+      "c-slate": "#6a645a",
+      "t-slate": "#696359",
+      coin: "#d4a52a",
+      coint: "#7d5e05",
+      coinin: "#9a7016",
+      tint: "6%",
+      edge: "22%",
+      shA: ".06",
+      shB: ".07",
+      carry: "#68635c"
+    },
+    dark: {
+      page: "#0e0d0b",
+      bg: "#15130f",
+      surf: "#1e1b17",
+      sunk: "#191612",
+      ink: "#ede6d8",
+      ink2: "#cbc2b1",
+      mute: "#9c9283",
+      hair: "#ede6d81f",
+      line: "#ede6d842",
+      sh: "#000000",
+      "on-c": "#15130f",
+      "c-blue": "#5785d5",
+      "t-blue": "#76a6f9",
+      "c-amber": "#be8802",
+      "t-amber": "#d59e2f",
+      "c-green": "#52aa71",
+      "t-green": "#61b87e",
+      "c-violet": "#90529b",
+      "t-violet": "#d08edb",
+      "c-rose": "#bb4e3d",
+      "t-rose": "#f98672",
+      "c-slate": "#a9a295",
+      "t-slate": "#aca598",
+      coin: "#dcb24e",
+      coint: "#dcb24e",
+      coinin: "#8a6a14",
+      tint: "6%",
+      edge: "19%",
+      shA: ".45",
+      shB: ".35"
+    }
+  },
+  night: {
+    name: "\u591C\u306E\u8A08\u5668",
+    note: "\u9752\u307F\u306E\u9ED2\u306E\u5730\u306B\u3001\u5149\u308B\u6C34\u8272 / \u7425\u73C0 / \u82E5\u7DD1 / \u83EB / \u6843 \u306E 6 \u8272\u3002\u660E\u308B\u3044\u5074\u306F\u9752\u7070\u306E\u5730",
+    light: {
+      page: "#e9eef5",
+      bg: "#f6f9fc",
+      surf: "#ffffff",
+      sunk: "#eef3f8",
+      ink: "#0b1424",
+      ink2: "#34425a",
+      mute: "#64748b",
+      hair: "#0b14241c",
+      line: "#0b142440",
+      sh: "#0b1424",
+      "on-c": "#ffffff",
+      "c-blue": "#0385cd",
+      "t-blue": "#086aa3",
+      "c-amber": "#ba8e0f",
+      "t-amber": "#7f5f04",
+      "c-green": "#0a8857",
+      "t-green": "#027449",
+      "c-violet": "#5839ba",
+      "t-violet": "#5839ba",
+      "c-rose": "#dd4a94",
+      "t-rose": "#b82375",
+      "c-slate": "#64748b",
+      "t-slate": "#56667c",
+      coin: "#eab308",
+      coint: "#7e6005",
+      coinin: "#a16207",
+      tint: "5%",
+      edge: "22%",
+      shA: ".06",
+      shB: ".09",
+      carry: "#596579"
+    },
+    dark: {
+      page: "#060a12",
+      bg: "#0a101c",
+      surf: "#111a2a",
+      sunk: "#0d1522",
+      ink: "#e6edf7",
+      ink2: "#b8c4d6",
+      mute: "#8090a8",
+      hair: "#e6edf71c",
+      line: "#9fb3d145",
+      sh: "#000000",
+      "on-c": "#0a101c",
+      "c-blue": "#3884b6",
+      "t-blue": "#62ace1",
+      "c-amber": "#be8533",
+      "t-amber": "#d59b4b",
+      "c-green": "#3ba774",
+      "t-green": "#4fb884",
+      "c-violet": "#7d4ecd",
+      "t-violet": "#b494fd",
+      "c-rose": "#bc3a74",
+      "t-rose": "#ff77ad",
+      "c-slate": "#96a3b5",
+      "t-slate": "#99a6b8",
+      coin: "#facc15",
+      coint: "#facc15",
+      coinin: "#a16207",
+      tint: "6%",
+      edge: "19%",
+      shA: ".5",
+      shB: ".4"
+    }
+  }
+};
+
+// src/look/fonts.ts
+var FONTS = { sans: "Noto Sans JP Variable", mono: "JetBrains Mono Variable" };
+var SANS_ADVANCE = { "0": 590, "1": 590, "2": 590, "3": 590, "4": 590, "5": 590, "6": 590, "7": 590, "8": 590, "9": 590, " ": 228, "!": 371, '"': 575, "#": 590, "$": 590, "%": 963, "&": 740, "'": 325, "(": 378, ")": 378, "*": 507, "+": 590, ",": 325, "-": 371, ".": 325, "/": 390, ":": 325, ";": 325, "<": 590, "=": 590, ">": 590, "?": 514, "@": 1007, "A": 642, "B": 682, "C": 657, "D": 715, "E": 616, "F": 586, "G": 718, "H": 758, "I": 330, "J": 568, "K": 686, "L": 579, "M": 854, "N": 750, "O": 771, "P": 668, "Q": 771, "R": 682, "S": 624, "T": 626, "U": 748, "V": 619, "W": 915, "X": 627, "Y": 581, "Z": 614, "[": 378, "\\": 390, "]": 378, "^": 590, "_": 568, "`": 626, "a": 591, "b": 644, "c": 528, "d": 645, "e": 581, "f": 372, "g": 598, "h": 640, "i": 305, "j": 306, "k": 605, "l": 315, "m": 964, "n": 641, "o": 626, "p": 645, "q": 645, "r": 437, "s": 495, "t": 421, "u": 638, "v": 576, "w": 863, "x": 562, "y": 575, "z": 512, "{": 378, "|": 297, "}": 378, "~": 590, "\u2026": 1e3, "\u2212": 590, "\xD7": 1e3, "\u2192": 1e3, "\u2190": 1e3, "\u2191": 1e3, "\u2193": 1e3, "\u2013": 545, "\u2014": 908, "\u2018": 325, "\u2019": 325, "\u201C": 575, "\u201D": 575, "\xB0": 404, "\xB1": 1e3, "\xB7": 593, "\u2022": 379 };
+var MONO_ADVANCE = 600;
+var WIDE_FROM = 11904;
+var EM = 1e3;
+function advance(ch, family) {
+  if ((ch.codePointAt(0) ?? 0) >= WIDE_FROM) return EM;
+  if (family === "mono") return MONO_ADVANCE;
+  return SANS_ADVANCE[ch] ?? EM;
+}
+
+// src/look/values.ts
+var DEFAULT_PALETTE = "paper";
+var PALETTES = Object.fromEntries(
+  Object.entries(palettes_default).map(([id, p]) => [id, { id, ...p }])
+);
+function resolvePalette(id) {
+  const found = id !== void 0 && Object.hasOwn(PALETTES, id) ? PALETTES[id] : void 0;
+  return found ?? PALETTES[DEFAULT_PALETTE];
+}
+function paletteVars(palette, theme) {
+  return Object.entries(palette[theme]).map(([key, value]) => `--${key}:${value}`).join(";");
+}
+var FONT_VARS = `--sans:"${FONTS.sans}";--mono:"${FONTS.mono}"`;
+var COLOR_ORDER = ["blue", "amber", "green", "violet", "rose"];
+var text = (size, weight, family = "sans") => ({ size, weight, family });
+var TYPE = {
+  boxName: text(13, 650),
+  boxSub: text(11, 500),
+  boxSubStrong: text(11, 700),
+  regionName: text(12.5, 700),
+  regionNote: text(11, 500),
+  label: text(11, 600, "mono"),
+  labelJa: text(11, 650),
+  action: text(11, 650),
+  badge: text(10.5, 700, "mono"),
+  carrier: text(10.5, 700, "mono"),
+  carrierJa: text(10.5, 700),
+  stripTitle: text(12.5, 700),
+  fieldName: text(10.5, 600),
+  fieldValue: text(12, 600, "mono"),
+  fieldValueJa: text(12, 600),
+  tag: text(10.5, 700),
+  miniTitle: text(10.5, 700),
+  stepTitle: text(15, 700),
+  stepBody: text(13.5, 500),
+  stepNo: text(13, 700, "mono"),
+  button: text(14, 700)
+};
+var LOOK = {
+  /** 部品どうしの最小の隙間 */
+  gap: 10,
+  /** 図の外周の余白 */
+  margin: 14,
+  box: { h: 72, minW: 92, padX: 12, radius: 12, icon: 24, iconRadius: 7, iconY: -16, iconScale: 0.74, nameY: 12, subY: 27 },
+  region: { pad: 18, gap: 10, radius: 14, inset: 14, icon: 24, iconRadius: 7, iconScale: 0.68, nameY: 58, line: 16, minH: 108 },
+  architecture: { columns: 4, columnGap: 56, maxColumnGap: 160, rowGap: 44, labelRoom: 16 },
+  sequence: { columnGap: 40, labelRoom: 16, firstRow: 22, rowGap: 14, stepGap: 8, minPitch: 40, tail: 18, selfW: 34, selfH: 18 },
+  edge: { inset: 3, arrow: 6, arrowHalf: 3.5, parallel: 5, ghostDash: 5, flowDash: 9 },
+  label: { h: 20, padX: 9, radius: 10, offset: 22, side: 14, search: 4, searchMax: 400, soft: 6 },
+  action: { h: 22, padX: 10, radius: 11 },
+  badge: { r: 9.5, ring: 9, inset: 4, along: 14, short: 44 },
+  carrier: { envW: 24, envH: 17, coinR: 6.5, coinIn: 3.8, tagH: 18, tagPadX: 8, samples: 16 },
+  strip: { h: 72, line: 44, pad: 12, icon: 24, titleX: 44, fieldGap: 22, sepInset: 14, tagGap: 6, tagH: 15, tagPadX: 7, nameY: 22, valueY: 43 },
+  stroke: { hair: 1, edge: 1.7, edgeOn: 2.25, arrow: 1.5, flow: 1.3, halo: 7, on: 1.75, glyph: 2, lifeline: 1.2, envelope: 1.5, badgeRing: 1.5 },
+  shadow: { near: 0.8, far: 4, nearY: 1, farY: 3 },
+  mini: { w: 168, pad: 8, title: 14, inset: 12, radius: 10 },
+  /** 寄って追う見せ方の窓の高さの、幅に対する割合と下限 */
+  follow: { aspect: 0.75, minH: 320, ease: 0.6 },
+  /** 色を混ぜる割合 (%) */
+  mix: { icon: 14, regionIcon: 16, regionIconEdge: 34, cap: 12, capEdge: 42, badgePast: 14, badgePastEdge: 70, mini: 62, miniBand: 16, miniBandEdge: 36, view: 6 },
+  /** 字の並びの基準線を、置きたい高さの真ん中からどれだけ下げるか */
+  baseline: { label: 3.8, badge: 3.5, carrier: 3.7, stripTitle: 4.5, tag: 3.6, action: 3.8 },
+  /** 浮いて出る物が下から上がる長さと、弾んで出る物の始まりの大きさ */
+  rise: 5,
+  popFrom: 0.4};
+var MOTION = {
+  /** 最初の段の前に全体を見せる長さ */
+  intro: 1.4,
+  /** 最後の段の後に全体を見せる長さ */
+  outro: 4.6,
+  /** 繰り返す前に消えていく長さ */
+  tail: 0.6,
+  /** 段の長さ。本文の字数で伸ばし、段で起きることが全部見えてから dwell 秒は留める */
+  stepBase: 1.2,
+  perChar: 0.025,
+  stepMin: 2.2,
+  stepMax: 5,
+  dwell: 1.2,
+  /** 段の中で最初の線を引き始めるまでと、続く線を引き始める間 */
+  edgeAt: 0.1,
+  stagger: 0.5,
+  /** 線を引く長さ。運ぶ物を載せた線は運ぶ物が走るので長い */
+  draw: 0.55,
+  drawCarry: 0.9,
+  /** 処理を読む間 (次の線と書き換えはこれだけ待つ) と、書き換えが続く間 */
+  action: 0.9,
+  change: 0.12,
+  /** 箱の下の字が見えている短さの下限。これより早く次の字に替わる字は出さない */
+  minShow: 0.8,
+  /** 線の名前が線より遅れて出る長さと、出入りの長さ */
+  labelDelay: 0.15,
+  fade: 0.3,
+  popFade: 0.4,
+  untilFade: 0.2,
+  /** 段の止め絵を撮る時刻を、段の終わりからどれだけ前にするか */
+  still: 0.45
+};
+var READABLE_PX = 10.5;
+var EASE = {
+  inOut: "cubic-bezier(.65,0,.35,1)",
+  out: "cubic-bezier(.22,1,.36,1)",
+  pop: "cubic-bezier(.34,1.56,.64,1)"
+};
+
+// src/figure-text.ts
+var FIGURE_TEXT = {
+  ja: {
+    cannotDraw: (detail) => `\u56F3\u3092\u63CF\u3051\u306A\u3044: ${detail}`,
+    overview: "\u5168\u4F53\u56F3",
+    prev: "\u524D\u306E\u6BB5",
+    pause: "\u6B62\u3081\u308B",
+    play: "\u52D5\u304B\u3059",
+    next: "\u6B21\u306E\u6BB5",
+    steps: (title) => `${title} \u306E\u6BB5`
+  },
+  en: {
+    cannotDraw: (detail) => `Cannot draw the diagram: ${detail}`,
+    overview: "Overview",
+    prev: "Previous step",
+    pause: "Pause",
+    play: "Play",
+    next: "Next step",
+    steps: (title) => `Steps of ${title}`
+  }
+};
+
+// src/layout/measure.ts
+var hasWide = (text2) => [...text2].some((ch) => (ch.codePointAt(0) ?? 0) >= 11904);
+function familyFor(text2, preferred) {
+  return preferred === "mono" && hasWide(text2) ? "sans" : preferred;
+}
+function textWidth(text2, style) {
+  const family = familyFor(text2, style.family);
+  let sum = 0;
+  for (const ch of text2) sum += advance(ch, family);
+  return sum * style.size / EM;
+}
+
+// src/layout/scene.ts
+function edgesOf(diagram) {
+  return diagram.steps.flatMap(
+    (step, s) => step.events.flatMap((event, e) => event.type === "edge" ? [{ step: s, event: e, edge: event }] : [])
+  );
+}
+function boxColors(diagram) {
+  const regions = regionColors(diagram);
+  const colors = /* @__PURE__ */ new Map();
+  diagram.boxes.forEach((box, i) => {
+    const fromRegion = box.region === void 0 ? void 0 : regions.get(box.region);
+    colors.set(box.id, box.color ?? fromRegion ?? COLOR_ORDER[i % COLOR_ORDER.length]);
+  });
+  return colors;
+}
+function regionColors(diagram) {
+  const colors = /* @__PURE__ */ new Map();
+  (diagram.regions ?? []).forEach((region, i) => colors.set(region.id, region.color ?? COLOR_ORDER[i % COLOR_ORDER.length]));
+  return colors;
+}
+var edgeColor = (edge2, colors) => edge2.carry.kind === "coin" ? "coin" : colors.get(edge2.from) ?? "slate";
+function boxWidth(diagram, id, withActions) {
+  const box = diagram.boxes.find((b) => b.id === id);
+  if (!box) return LOOK.box.minW;
+  const lines = [textWidth(box.name, TYPE.boxName), textWidth(box.sub ?? "", TYPE.boxSub)];
+  for (const step of diagram.steps) {
+    for (const event of step.events) {
+      if (event.type === "swap" && event.box === id) lines.push(textWidth(event.text, TYPE.boxSubStrong));
+      if (withActions && event.type === "action" && event.box === id) lines.push(textWidth(event.label, TYPE.boxSubStrong));
+    }
+  }
+  return Math.max(LOOK.box.minW, Math.max(...lines) + LOOK.box.padX * 2);
+}
+function gapBetween(a, b) {
+  const dx = Math.max(b.x - (a.x + a.w), a.x - (b.x + b.w));
+  const dy = Math.max(b.y - (a.y + a.h), a.y - (b.y + b.h));
+  return Math.max(dx, dy);
+}
+function longest(points) {
+  let best = { a: points[0], b: points[1] ?? points[0], length: -1 };
+  for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    if (length > best.length) best = { a, b, length };
+  }
+  return { a: best.a, b: best.b, vertical: Math.abs(best.b[0] - best.a[0]) < Math.abs(best.b[1] - best.a[1]) };
+}
+function along(points, distance) {
+  let left = distance;
+  for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    if (left <= length && length > 0) return [a[0] + (b[0] - a[0]) * left / length, a[1] + (b[1] - a[1]) * left / length];
+    left -= length;
+  }
+  return points[points.length - 1];
+}
+function pathLength(points) {
+  let sum = 0;
+  for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    sum += Math.hypot(b[0] - a[0], b[1] - a[1]);
+  }
+  return sum;
+}
+function badgeOnPath(points) {
+  const length = pathLength(points);
+  return along(points, length < LOOK.badge.short ? length / 2 : LOOK.badge.along);
+}
+var labelStyle = (text2) => hasWide(text2) ? TYPE.labelJa : TYPE.label;
+function placeLabel(request, obstacles) {
+  const w = textWidth(request.text, labelStyle(request.text)) + LOOK.label.padX * 2;
+  const h = LOOK.label.h;
+  const segment = longest(request.points);
+  const mx = (segment.a[0] + segment.b[0]) / 2;
+  const my = (segment.a[1] + segment.b[1]) / 2;
+  const side = request.side ?? (segment.vertical ? "right" : "above");
+  const { offset, side: sideGap } = LOOK.label;
+  const base = side === "above" ? { x: mx - w / 2, y: my - offset - h / 2, w, h } : side === "below" ? { x: mx - w / 2, y: my + offset - h / 2, w, h } : side === "left" ? { x: mx - sideGap - w, y: my - h / 2, w, h } : { x: mx + sideGap, y: my - h / 2, w, h };
+  const away = side === "above" ? [0, -1] : side === "below" ? [0, 1] : side === "left" ? [-1, 0] : [1, 0];
+  const slideAxis = [Math.abs(away[1]), Math.abs(away[0])];
+  const slideMax = side === "above" || side === "below" ? w : h * 4;
+  const clear = (rect) => obstacles.hard.every((box) => gapBetween(rect, box) >= LOOK.gap) && obstacles.soft.every((other) => gapBetween(rect, other) >= LOOK.label.soft);
+  const { search, searchMax } = LOOK.label;
+  for (let d = 0; d <= searchMax; d += search) {
+    for (let s = 0; s <= slideMax; s += search) {
+      for (const sign of s === 0 ? [1] : [1, -1]) {
+        const rect = { x: base.x + away[0] * d + slideAxis[0] * s * sign, y: base.y + away[1] * d + slideAxis[1] * s * sign, w, h };
+        if (clear(rect)) return { ...rect, step: request.step, event: request.event, text: request.text, family: labelStyle(request.text).family, color: request.color };
+      }
+    }
+  }
+  return { ...base, step: request.step, event: request.event, text: request.text, family: labelStyle(request.text).family, color: request.color };
+}
+function fieldWidth(diagram, name) {
+  let value = 0;
+  let tag = 0;
+  for (const step of diagram.steps) {
+    for (const event of step.events) {
+      if (event.type !== "strip" || event.field !== name) continue;
+      if (event.value !== void 0) value = Math.max(value, textWidth(event.value, hasWide(event.value) ? TYPE.fieldValueJa : TYPE.fieldValue));
+      if (event.tag !== void 0) tag = Math.max(tag, textWidth(event.tag, TYPE.tag) + LOOK.strip.tagPadX * 2);
+    }
+  }
+  const both = value + (tag > 0 ? (value > 0 ? LOOK.strip.tagGap : 0) + tag : 0);
+  return Math.max(textWidth(name, TYPE.fieldName), both);
+}
+function stripNeed(diagram) {
+  if (!diagram.strip) return 0;
+  const { titleX, fieldGap, pad: pad2 } = LOOK.strip;
+  const start = titleX + textWidth(diagram.strip.title, TYPE.stripTitle) + fieldGap;
+  return start + diagram.strip.fields.reduce((sum, name) => sum + fieldWidth(diagram, name) + fieldGap, 0) - fieldGap + pad2;
+}
+function layoutStrip(diagram, x, y, width) {
+  if (!diagram.strip) return void 0;
+  const { titleX, fieldGap, pad: pad2, line, h } = LOOK.strip;
+  const start = titleX + textWidth(diagram.strip.title, TYPE.stripTitle) + fieldGap;
+  const fields = [];
+  let cx = start;
+  let row = 0;
+  for (const name of diagram.strip.fields) {
+    const w = fieldWidth(diagram, name);
+    if (cx > start && cx + w > width - pad2) {
+      cx = start;
+      row++;
+    }
+    fields.push({ name, x: x + cx, y: y + row * line, w });
+    cx += w + fieldGap;
+  }
+  return { x, y, w: width, h: h + row * line, title: diagram.strip.title, fields };
+}
+function shiftContent(layout, dx, dy) {
+  const move = (rect) => {
+    rect.x += dx;
+    rect.y += dy;
+  };
+  for (const box of layout.boxes) {
+    move(box);
+    box.cx += dx;
+    box.cy += dy;
+  }
+  for (const region of layout.regions) {
+    region.y += dy;
+    move(region.header);
+  }
+  for (const line of layout.lifelines) {
+    line.x += dx;
+    line.y1 += dy;
+    line.y2 += dy;
+  }
+  for (const edge2 of layout.edges) {
+    edge2.points = edge2.points.map(([px, py]) => [px + dx, py + dy]);
+    if (edge2.settle) edge2.settle = [edge2.settle[0] + dx, edge2.settle[1] + dy];
+  }
+  for (const label2 of layout.labels) move(label2);
+  for (const action2 of layout.actions) move(action2);
+  for (const badge2 of layout.badges) {
+    badge2.x += dx;
+    badge2.y += dy;
+  }
+  if (layout.strip) {
+    layout.strip.y += dy;
+    for (const field of layout.strip.fields) {
+      field.x += dx;
+      field.y += dy;
+    }
+  }
+}
+function cornerBadge(events, step, layout) {
+  const { inset } = LOOK.badge;
+  for (const event of events) {
+    const id = event.type === "swap" || event.type === "action" ? event.box : void 0;
+    const box2 = layout.boxes.find((b) => b.id === id);
+    if (box2) return { step, x: box2.x + inset, y: box2.y + inset, color: box2.color };
+  }
+  if (layout.strip && events.some((event) => event.type === "strip")) return { step, x: layout.strip.x + inset, y: layout.strip.y + inset, color: "slate" };
+  const box = layout.boxes[0];
+  return { step, x: box.x + inset, y: box.y + inset, color: box.color };
+}
+
+// src/layout/architecture.ts
+function layoutArchitecture(diagram) {
+  const groups = groupsOf(diagram);
+  const slots = placeBoxes(diagram, groups);
+  const rooms = groups.map(() => ({ top: 0, bottom: 0 }));
+  let layout = arrange(diagram, groups, slots, rooms);
+  for (let pass = 0; pass < 3 && grow(layout, groups, slots, rooms); pass++) layout = arrange(diagram, groups, slots, rooms);
+  return layout;
+}
+function groupsOf(diagram) {
+  const regions = diagram.regions ?? [];
+  const known = new Set(regions.map((r) => r.id));
+  const groups = regions.map((region) => ({ region, members: diagram.boxes.filter((b) => b.region === region.id).map((b) => b.id) }));
+  const loose = diagram.boxes.filter((b) => b.region === void 0 || !known.has(b.region)).map((b) => b.id);
+  if (loose.length > 0) groups.push({ members: loose });
+  return groups;
+}
+var vertical = (side) => side === "left" || side === "right";
+function placeBoxes(diagram, groups) {
+  const columns = LOOK.architecture.columns;
+  const edges = edgesOf(diagram).map((e) => e.edge);
+  const slots = /* @__PURE__ */ new Map();
+  groups.forEach((group, g) => {
+    const inGroup = new Set(group.members);
+    const taken = /* @__PURE__ */ new Set();
+    const free = (col, row) => col >= 0 && col < columns && !taken.has(`${col},${row}`);
+    const near = (col, row) => {
+      const start = Math.min(columns - 1, Math.max(0, col));
+      for (let r = row; ; r++) {
+        for (let d = 0; d < columns; d++) {
+          for (const c of [start + d, start - d]) if (free(c, r)) return [c, r];
+        }
+      }
+    };
+    const put = (id, col, row) => {
+      slots.set(id, { group: g, col, row });
+      taken.add(`${col},${row}`);
+    };
+    let dir = 1;
+    const visit = (id) => {
+      for (const edge2 of edges) {
+        const partner = edge2.from === id ? edge2.to : edge2.to === id ? edge2.from : void 0;
+        if (partner === void 0 || !inGroup.has(partner) || slots.has(partner)) continue;
+        const me = slots.get(id);
+        const [c, r] = vertical(edge2.labelSide) ? near(me.col, me.row + 1) : free(me.col + dir, me.row) ? [me.col + dir, me.row] : near(me.col + dir, me.row);
+        put(partner, c, r);
+        visit(partner);
+      }
+    };
+    const anchorOf = (id) => {
+      for (let i = 0; i < edges.length; i++) {
+        const edge2 = edges[i];
+        const partner = edge2?.from === id ? edge2.to : edge2?.to === id ? edge2.from : void 0;
+        const slot = partner === void 0 ? void 0 : slots.get(partner);
+        if (slot && slot.group < g) return { order: i, col: slot.col };
+      }
+      return void 0;
+    };
+    let placed = 0;
+    for (; ; ) {
+      const rest = group.members.filter((id) => !slots.has(id));
+      if (rest.length === 0) break;
+      const anchored = rest.map((id) => ({ id, anchor: anchorOf(id) })).filter((a) => a.anchor !== void 0);
+      anchored.sort((a, b) => (a.anchor?.order ?? 0) - (b.anchor?.order ?? 0));
+      const pick = anchored[0] ?? { id: rest[0], anchor: void 0 };
+      const want = pick.anchor?.col ?? 0;
+      if (placed === 0) dir = want >= (columns - 1) / 2 ? -1 : 1;
+      const [c, r] = free(want, 0) ? [want, 0] : near(want, 0);
+      put(pick.id, c, r);
+      visit(pick.id);
+      placed++;
+    }
+  });
+  const used = [...new Set([...slots.values()].map((s) => s.col))].sort((a, b) => a - b);
+  for (const slot of slots.values()) slot.col = used.indexOf(slot.col);
+  return slots;
+}
+function nameLines(name) {
+  const spaces = [...name.matchAll(/ /g)].map((m) => m.index);
+  if (spaces.length === 0) return [name];
+  const at2 = spaces.reduce((best, i) => Math.abs(i - name.length / 2) < Math.abs(best - name.length / 2) ? i : best);
+  return [name.slice(0, at2), name.slice(at2 + 1)];
+}
+function headerSize(region) {
+  const { icon, nameY, line, inset } = LOOK.region;
+  const lines = nameLines(region.name);
+  const w = Math.max(icon, ...lines.map((l) => textWidth(l, TYPE.regionName)), textWidth(region.note ?? "", TYPE.regionNote));
+  const h = nameY - inset + (lines.length - 1) * line + (region.note ? line : 0) + LOOK.gap / 2;
+  return { w, h, lines };
+}
+function arrange(diagram, groups, slots, rooms) {
+  const { box: B, region: R, architecture: A, margin, gap } = LOOK;
+  const colors = boxColors(diagram);
+  const regionColor = regionColors(diagram);
+  const edges = edgesOf(diagram);
+  const columnCount = Math.max(1, ...[...slots.values()].map((s) => s.col + 1));
+  const widths = new Map(diagram.boxes.map((b) => [b.id, boxWidth(diagram, b.id, true)]));
+  const colW = Array.from({ length: columnCount }, (_, c) => Math.max(B.minW, ...[...slots].filter(([, s]) => s.col === c).map(([id]) => widths.get(id) ?? B.minW)));
+  const between = Array.from({ length: Math.max(0, columnCount - 1) }, () => A.columnGap);
+  for (const { edge: edge2 } of edges) {
+    const a = slots.get(edge2.from);
+    const b = slots.get(edge2.to);
+    if (!a || !b || edge2.label === void 0 || a.group !== b.group || a.row !== b.row || Math.abs(a.col - b.col) !== 1 || vertical(edge2.labelSide)) continue;
+    const need = textWidth(edge2.label, labelStyle(edge2.label)) + LOOK.label.padX * 2 + A.labelRoom * 2;
+    const i = Math.min(a.col, b.col);
+    if (need <= A.maxColumnGap) between[i] = Math.max(between[i] ?? 0, need);
+  }
+  const headers = groups.map((g) => g.region ? headerSize(g.region) : void 0);
+  const headerW = Math.max(0, ...headers.map((h) => h ? h.w + R.inset * 2 : 0));
+  const colLeft = [];
+  for (let c = 0; c < columnCount; c++) colLeft.push(c === 0 ? margin + (headerW > 0 ? headerW : R.pad) : colLeft[c - 1] + colW[c - 1] + between[c - 1]);
+  const center = (c) => colLeft[c] + colW[c] / 2;
+  const boxes = [];
+  const bands = [];
+  let cursor = margin;
+  groups.forEach((group, g) => {
+    const rows = Math.max(1, ...group.members.map((id) => (slots.get(id)?.row ?? 0) + 1));
+    const room = rooms[g];
+    const top = cursor + R.pad + room.top;
+    for (const id of group.members) {
+      const slot = slots.get(id);
+      const source = diagram.boxes.find((b) => b.id === id);
+      const w = widths.get(id) ?? B.minW;
+      const cx = center(slot.col);
+      const y = top + slot.row * (B.h + A.rowGap);
+      boxes.push({
+        id,
+        name: source?.name ?? id,
+        ...source?.sub !== void 0 ? { sub: source.sub } : {},
+        ...source?.icon !== void 0 ? { icon: source.icon } : {},
+        color: colors.get(id) ?? "slate",
+        x: cx - w / 2,
+        y,
+        w,
+        h: B.h,
+        cx,
+        cy: y + B.h / 2
+      });
+    }
+    const contentBottom = top + rows * B.h + (rows - 1) * A.rowGap;
+    const header = headers[g];
+    const h = Math.max(contentBottom + R.pad + room.bottom - cursor, header ? header.h + R.inset * 2 : 0, group.region ? R.minH : 0);
+    bands.push({ group: g, y: cursor, h, rows });
+    cursor += h + R.gap;
+  });
+  const bandsBottom = cursor - R.gap;
+  const byId = new Map(boxes.map((b) => [b.id, b]));
+  const bandOf = (id) => bands[slots.get(id)?.group ?? 0];
+  const blocked = (points, a, b) => boxes.some((box) => {
+    if (box.id === a || box.id === b) return false;
+    const pad2 = LOOK.label.search;
+    for (let i = 1; i < points.length; i++) {
+      const [x1, y1] = points[i - 1];
+      const [x2, y2] = points[i];
+      if (Math.min(x1, x2) <= box.x + box.w + pad2 && Math.max(x1, x2) >= box.x - pad2 && Math.min(y1, y2) <= box.y + box.h + pad2 && Math.max(y1, y2) >= box.y - pad2) return true;
+    }
+    return false;
+  });
+  const laneBelow = (id) => {
+    const box = byId.get(id);
+    const band2 = bandOf(id);
+    return (slots.get(id)?.row ?? 0) < band2.rows - 1 ? box.y + box.h + A.rowGap / 2 : Math.min(box.y + box.h + R.pad / 2, band2.y + band2.h - LOOK.edge.inset);
+  };
+  const laneAbove = (id) => {
+    const box = byId.get(id);
+    const band2 = bandOf(id);
+    return (slots.get(id)?.row ?? 0) > 0 ? box.y - A.rowGap / 2 : Math.max(box.y - R.pad / 2, band2.y + LOOK.edge.inset);
+  };
+  const inset = LOOK.edge.inset;
+  const route = (from, to) => {
+    const a = byId.get(from);
+    const b = byId.get(to);
+    const sa = slots.get(from);
+    const sb = slots.get(to);
+    if (sa.group === sb.group && sa.row === sb.row) {
+      const right2 = b.cx > a.cx;
+      const straight = [
+        [right2 ? a.x + a.w : a.x, a.cy],
+        [right2 ? b.x - inset : b.x + b.w + inset, b.cy]
+      ];
+      if (!blocked(straight, from, to)) return straight;
+      const lane2 = laneBelow(from);
+      return [
+        [a.cx, a.y + a.h],
+        [a.cx, lane2],
+        [b.cx, lane2],
+        [b.cx, b.y + b.h + inset]
+      ];
+    }
+    const down = b.cy > a.cy;
+    const leave = [a.cx, down ? a.y + a.h : a.y];
+    const enter = [b.cx, down ? b.y - inset : b.y + b.h + inset];
+    if (sa.col === sb.col) {
+      const straight = [leave, enter];
+      if (!blocked(straight, from, to)) return straight;
+      const x = a.x + a.w + (between[sa.col] ?? A.columnGap) / 2;
+      return [
+        [a.x + a.w, a.cy],
+        [x, a.cy],
+        [x, b.cy],
+        [b.x + b.w + inset, b.cy]
+      ];
+    }
+    const right = b.cx > a.cx;
+    const lane = down ? laneBelow(from) : laneAbove(from);
+    const candidates = [
+      [leave, [a.cx, b.cy], [right ? b.x - inset : b.x + b.w + inset, b.cy]],
+      [[right ? a.x + a.w : a.x, a.cy], [b.cx, a.cy], enter],
+      [leave, [a.cx, lane], [b.cx, lane], enter]
+    ];
+    return candidates.find((points) => !blocked(points, from, to)) ?? candidates[2];
+  };
+  const sceneEdges = edges.map(({ step, event, edge: edge2 }) => {
+    const target = byId.get(edge2.to);
+    return {
+      step,
+      event,
+      from: edge2.from,
+      to: edge2.to,
+      points: route(edge2.from, edge2.to),
+      color: edgeColor(edge2, colors),
+      carry: edge2.carry,
+      settle: [target.cx, target.cy + B.iconY]
+    };
+  });
+  for (const edge2 of sceneEdges) {
+    if (edge2.points.length !== 2) continue;
+    const back = sceneEdges.some((other) => other.from === edge2.to && other.to === edge2.from && other.points.length === 2);
+    if (!back) continue;
+    const [p, q] = edge2.points;
+    const flat = Math.abs(q[1] - p[1]) < Math.abs(q[0] - p[0]);
+    const d = (edge2.from < edge2.to ? 1 : -1) * LOOK.edge.parallel;
+    edge2.points = edge2.points.map(([x, y]) => flat ? [x, y + d] : [x + d, y]);
+  }
+  const regions = [];
+  groups.forEach((group, g) => {
+    const band2 = bands[g];
+    const header = headers[g];
+    if (!group.region || !header) return;
+    regions.push({
+      id: group.region.id,
+      lines: header.lines,
+      ...group.region.note !== void 0 ? { note: group.region.note } : {},
+      ...group.region.icon !== void 0 ? { icon: group.region.icon } : {},
+      color: regionColor.get(group.region.id) ?? "slate",
+      x: margin,
+      y: band2.y,
+      w: 0,
+      h: band2.h,
+      header: { x: margin + R.inset, y: band2.y + R.inset, w: header.w, h: header.h }
+    });
+  });
+  const labels = [];
+  for (const edge2 of sceneEdges) {
+    const source = diagram.steps[edge2.step]?.events[edge2.event];
+    if (source?.type !== "edge" || source.label === void 0) continue;
+    const soft = [...regions.map((r) => r.header), ...labels.filter((l) => l.step === edge2.step)];
+    labels.push(
+      placeLabel(
+        { step: edge2.step, event: edge2.event, text: source.label, points: edge2.points, color: edge2.color, ...source.labelSide ? { side: source.labelSide } : {} },
+        { hard: boxes, soft }
+      )
+    );
+  }
+  const layout = { kind: "architecture", width: 0, height: 0, regions, boxes, lifelines: [], edges: sceneEdges, labels, actions: [], badges: [] };
+  const shift = labels.length > 0 ? Math.max(0, margin + LOOK.label.soft - Math.min(...labels.map((l) => l.x))) : 0;
+  if (shift > 0) shiftContent(layout, shift, 0);
+  const contentRight = Math.max(...boxes.map((b) => b.x + b.w + R.pad), ...labels.map((l) => l.x + l.w + LOOK.label.soft), ...sceneEdges.flatMap((e) => e.points.map((p) => p[0] + R.pad)));
+  const width = Math.max(contentRight + margin, stripNeed(diagram) + margin * 2);
+  for (const region of regions) region.w = width - margin * 2;
+  const strip2 = layoutStrip(diagram, margin, bandsBottom + gap, width - margin * 2);
+  layout.width = width;
+  layout.height = (strip2 ? strip2.y + strip2.h : bandsBottom) + margin;
+  if (strip2) layout.strip = strip2;
+  layout.badges = diagram.steps.map((step, s) => {
+    const edge2 = sceneEdges.find((e) => e.step === s);
+    if (!edge2) return cornerBadge(step.events, s, layout);
+    const [x, y] = badgeOnPath(edge2.points);
+    return { step: s, x, y, color: edge2.color };
+  });
+  return layout;
+}
+function grow(layout, groups, slots, rooms) {
+  let grown = false;
+  const soft = LOOK.label.soft;
+  for (const label2 of layout.labels) {
+    const edge2 = layout.edges.find((e) => e.step === label2.step && e.event === label2.event);
+    const a = edge2 && slots.get(edge2.from);
+    const b = edge2 && slots.get(edge2.to);
+    if (!a || !b || a.group !== b.group || !groups[a.group]?.region) continue;
+    const region = layout.regions.find((r) => r.id === groups[a.group]?.region?.id);
+    const room = rooms[a.group];
+    if (!region || !room) continue;
+    const over = region.y + soft - label2.y;
+    const under = label2.y + label2.h - (region.y + region.h - soft);
+    if (over > 0) {
+      room.top += over;
+      grown = true;
+    }
+    if (under > 0) {
+      room.bottom += under;
+      grown = true;
+    }
+  }
+  return grown;
+}
+
+// src/layout/sequence.ts
+function layoutSequence(diagram) {
+  const { box: B, sequence: Q, label: L, margin, gap } = LOOK;
+  const colors = boxColors(diagram);
+  const listed = diagram.sequence?.lifelines ?? [];
+  const order = [...listed, ...diagram.boxes.map((b) => b.id).filter((id) => !listed.includes(id))];
+  const column = new Map(order.map((id, i) => [id, i]));
+  const widths = order.map((id) => boxWidth(diagram, id, false));
+  const spacing = widths.slice(1).map((w, i) => widths[i] / 2 + w / 2 + Q.columnGap);
+  const needs = [];
+  for (const step of diagram.steps) {
+    for (const event of step.events) {
+      if (event.type !== "edge" || event.label === void 0) continue;
+      const a = column.get(event.from) ?? 0;
+      const b = column.get(event.to) ?? 0;
+      const w = textWidth(event.label, labelStyle(event.label)) + L.padX * 2;
+      if (a === b) {
+        if (a < spacing.length) needs.push({ from: a, to: a + 1, need: Q.selfW + L.side + w + Q.labelRoom });
+      } else {
+        needs.push({ from: Math.min(a, b), to: Math.max(a, b), need: w + Q.labelRoom * 2 });
+      }
+    }
+  }
+  needs.sort((x, y2) => x.to - x.from - (y2.to - y2.from));
+  for (const { from, to, need } of needs) {
+    let have = 0;
+    for (let i = from; i < to; i++) have += spacing[i] ?? 0;
+    if (have >= need) continue;
+    const add = (need - have) / (to - from);
+    for (let i = from; i < to; i++) spacing[i] = (spacing[i] ?? 0) + add;
+  }
+  const xs = [];
+  order.forEach((_, i) => xs.push(i === 0 ? margin + widths[0] / 2 : xs[i - 1] + spacing[i - 1]));
+  const boxes = order.map((id, i) => {
+    const source = diagram.boxes.find((b) => b.id === id);
+    const w = widths[i];
+    const cx = xs[i];
+    return {
+      id,
+      name: source?.name ?? id,
+      ...source?.sub !== void 0 ? { sub: source.sub } : {},
+      ...source?.icon !== void 0 ? { icon: source.icon } : {},
+      color: colors.get(id) ?? "slate",
+      x: cx - w / 2,
+      y: margin,
+      w,
+      h: B.h,
+      cx,
+      cy: margin + B.h / 2
+    };
+  });
+  const headBottom = margin + B.h;
+  const edges = [];
+  const actions = [];
+  const requests = [];
+  let y = headBottom + Q.firstRow;
+  let below = 0;
+  let first = true;
+  diagram.steps.forEach((step, s) => {
+    step.events.forEach((event, e) => {
+      if (event.type !== "edge" && event.type !== "action") return;
+      let above;
+      let under;
+      if (event.type === "edge") {
+        const side = event.labelSide ?? "above";
+        const self = event.from === event.to;
+        const named = event.label !== void 0;
+        above = named && side === "above" ? L.offset + L.h / 2 : gap;
+        under = self ? Q.selfH + gap : named && side === "below" ? L.offset + L.h / 2 : gap;
+      } else {
+        above = LOOK.action.h / 2;
+        under = LOOK.action.h / 2;
+      }
+      y = first ? y + above : y + Math.max(Q.minPitch, below + Q.rowGap + above) + (e === 0 && s > 0 ? Q.stepGap : 0);
+      first = false;
+      below = under;
+      if (event.type === "edge") {
+        const xf = xs[column.get(event.from) ?? 0];
+        const xt = xs[column.get(event.to) ?? 0];
+        const dir = Math.sign(xt - xf) || 1;
+        const points = xf === xt ? [
+          [xf, y],
+          [xf + Q.selfW, y],
+          [xf + Q.selfW, y + Q.selfH],
+          [xf + LOOK.edge.inset, y + Q.selfH]
+        ] : [
+          [xf, y],
+          [xt - dir * LOOK.edge.inset, y]
+        ];
+        const color = edgeColor(event, colors);
+        edges.push({ step: s, event: e, from: event.from, to: event.to, points, color, carry: event.carry });
+        if (event.label !== void 0) {
+          requests.push({
+            step: s,
+            event: e,
+            text: event.label,
+            points,
+            color,
+            ...event.labelSide ? { side: event.labelSide } : xf === xt ? { side: "right" } : {}
+          });
+        }
+      } else {
+        const x = xs[column.get(event.box) ?? 0];
+        const w = textWidth(event.label, TYPE.action) + LOOK.action.padX * 2;
+        actions.push({ step: s, event: e, box: event.box, text: event.label, color: colors.get(event.box) ?? "slate", x: x + LOOK.badge.r + 4, y: y - LOOK.action.h / 2, w, h: LOOK.action.h });
+      }
+    });
+  });
+  const bottom = (first ? headBottom : y + below) + Q.tail;
+  const lifelines = order.map((id, i) => ({ id, x: xs[i], y1: headBottom, y2: bottom }));
+  const labels = [];
+  for (const request of requests) {
+    const soft = [...labels.filter((l) => l.step === request.step), ...actions];
+    labels.push(placeLabel(request, { hard: boxes, soft }));
+  }
+  const layout = { kind: "sequence", width: 0, height: 0, regions: [], boxes, lifelines, edges, labels, actions, badges: [] };
+  const lefts = [...boxes.map((b) => b.x), ...labels.map((l) => l.x), ...actions.map((a) => a.x)];
+  const shift = Math.max(0, margin - Math.min(...lefts));
+  if (shift > 0) shiftContent(layout, shift, 0);
+  const rights = [...boxes.map((b) => b.x + b.w), ...labels.map((l) => l.x + l.w), ...actions.map((a) => a.x + a.w), ...edges.flatMap((edge2) => edge2.points.map((p) => p[0]))];
+  const width = Math.max(Math.max(...rights) + margin, stripNeed(diagram) + margin * 2);
+  const strip2 = layoutStrip(diagram, margin, bottom + gap, width - margin * 2);
+  layout.width = width;
+  layout.height = (strip2 ? strip2.y + strip2.h : bottom) + margin;
+  if (strip2) layout.strip = strip2;
+  layout.badges = badges(diagram, layout);
+  return layout;
+}
+function badges(diagram, layout) {
+  return diagram.steps.map((step, s) => {
+    const edge2 = layout.edges.find((e) => e.step === s);
+    if (edge2) {
+      const [x, y] = badgeOnPath(edge2.points);
+      return { step: s, x, y, color: edge2.color };
+    }
+    const action2 = layout.actions.find((a) => a.step === s);
+    const lifeline2 = action2 && layout.lifelines.find((l) => l.id === action2.box);
+    if (action2 && lifeline2) return { step: s, x: lifeline2.x, y: action2.y + action2.h / 2, color: action2.color };
+    return cornerBadge(step.events, s, layout);
+  });
+}
+
+// src/field-messages.ts
+var TYPES_JA = {
+  string: "\u6587\u5B57\u5217\u306B\u3059\u308B",
+  integer: "\u6574\u6570\u306B\u3059\u308B",
+  number: "\u6570\u306B\u3059\u308B",
+  object: "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306B\u3059\u308B",
+  array: "\u914D\u5217\u306B\u3059\u308B",
+  boolean: "true \u304B false \u306B\u3059\u308B",
+  null: "null \u306B\u3059\u308B"
+};
+var TYPES_EN = {
+  string: "Use a string",
+  integer: "Use an integer",
+  number: "Use a number",
+  object: "Use an object",
+  array: "Use an array",
+  boolean: "Use true or false",
+  null: "Use null"
+};
+var plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+var ja = {
+  additionalProperties: (key) => `${key} \u3068\u3044\u3046\u6B04\u306F\u66F8\u3051\u306A\u3044`,
+  required: (key) => `${key} \u306E\u6B04\u304C\u8981\u308B`,
+  enum: (values) => `${values.join(" / ")} \u306E\u3069\u308C\u304B\u306B\u3059\u308B`,
+  type: (type) => TYPES_JA[type] ?? `${type} \u306B\u3059\u308B`,
+  minLength: (limit) => `${limit} \u5B57\u4EE5\u4E0A\u66F8\u304F`,
+  pattern: (forbidden) => forbidden ? `${forbidden.space ? "\u7A7A\u767D\u3068 " : ""}${forbidden.chars.join(" ")} \u306F\u4F7F\u3048\u306A\u3044` : "\u4F7F\u3048\u306A\u3044\u5B57\u304C\u5165\u3063\u3066\u3044\u308B",
+  minItems: (limit) => `${limit} \u3064\u4EE5\u4E0A\u66F8\u304F`,
+  minimum: (limit) => `${limit} \u4EE5\u4E0A\u306B\u3059\u308B`,
+  const: (value) => `${value} \u306B\u3059\u308B`,
+  not: (allowed) => allowed ? `${allowed.field} \u306E\u6B04\u306F kind \u304C ${allowed.kind} \u306E\u6642\u3060\u3051\u66F8\u3051\u308B` : "\u3053\u306E\u6B04\u306E\u7D44\u307F\u5408\u308F\u305B\u306F\u66F8\u3051\u306A\u3044",
+  anyOf: (fields) => fields.length > 0 ? `${fields.join(" \u304B ")} \u306E${fields.length === 2 ? "\u3069\u3061\u3089\u304B" : "\u3069\u308C\u304B"}\u306E\u6B04\u304C\u8981\u308B` : "\u66F8\u3051\u308B\u5F62\u306E\u3069\u308C\u306B\u3082\u5408\u308F\u306A\u3044",
+  oneOf: "\u66F8\u3051\u308B\u5F62\u306E\u3069\u308C\u304B 1 \u3064\u3060\u3051\u306B\u5408\u308F\u305B\u308B",
+  discriminator: (tag, values) => `${tag} \u306F ${values.join(" / ")} \u306E\u3069\u308C\u304B\u306B\u3059\u308B`,
+  newer: (version, tool) => `\u7248 ${version} \u306E\u56F3\u306F\u3001\u3053\u306E\u9053\u5177 (\u7248 ${tool}) \u3088\u308A\u65B0\u3057\u3044\u306E\u3067\u8AAD\u3081\u306A\u3044\u3002\u9053\u5177\u3092\u65B0\u3057\u304F\u3059\u308B`
+};
+var en = {
+  additionalProperties: (key) => `The ${key} field is not allowed`,
+  required: (key) => `The ${key} field is required`,
+  enum: (values) => `Use one of ${values.join(" / ")}`,
+  type: (type) => TYPES_EN[type] ?? `Use ${type}`,
+  minLength: (limit) => `Write at least ${plural(limit, "character")}`,
+  pattern: (forbidden) => forbidden ? `Cannot contain ${forbidden.space ? "spaces or " : ""}${forbidden.chars.join(" ")}` : "Contains characters that are not allowed",
+  minItems: (limit) => `Write at least ${plural(limit, "item")}`,
+  minimum: (limit) => `Use ${limit} or greater`,
+  const: (value) => `Use ${value}`,
+  not: (allowed) => allowed ? `The ${allowed.field} field is allowed only when kind is ${allowed.kind}` : "This combination of fields is not allowed",
+  anyOf: (fields) => fields.length > 0 ? `Write one of the ${fields.join(" or ")} fields` : "Does not match any of the allowed shapes",
+  oneOf: "Match exactly one of the allowed shapes",
+  discriminator: (tag, values) => `${tag} is one of ${values.join(" / ")}`,
+  newer: (version, tool) => `Version ${version} diagrams are newer than this tool (version ${tool}) and cannot be read. Update the tool`
+};
+var FIELD_MESSAGES = { ja, en };
+
+// src/schemas/validate-diagram.js
+function ucs2length(str) {
+  let length = 0;
+  for (const _ of str) length++;
+  return length;
+}
+var validate_diagram_default = validate10;
+var schema11 = { "properties": { "version": { "description": "\u5F62\u5F0F\u306E\u7248", "type": "integer", "minimum": 1 }, "kind": { "description": "\u56F3\u306E\u7A2E\u985E", "enum": ["sequence", "architecture"] }, "title": { "$ref": "#/definitions/text" }, "view": { "description": "\u898B\u305B\u65B9\u3002\u66F8\u304B\u306A\u3051\u308C\u3070\u5B57\u306E\u5927\u304D\u3055\u3067\u9078\u3076\u3002fixed \u306F\u5168\u4F53\u3092\u6B62\u3081\u3066\u4E2D\u3060\u3051\u52D5\u304B\u3057\u3001follow \u306F\u5BC4\u3063\u3066\u52D5\u304B\u3057\u5168\u4F53\u56F3\u3067\u4ECA\u3069\u3053\u304B\u3092\u793A\u3059", "enum": ["fixed", "follow"] }, "regions": { "type": "array", "items": { "$ref": "#/definitions/region" } }, "boxes": { "type": "array", "minItems": 1, "items": { "$ref": "#/definitions/box" } }, "strip": { "$ref": "#/definitions/strip" }, "steps": { "type": "array", "minItems": 1, "items": { "$ref": "#/definitions/step" } }, "sequence": { "$ref": "#/definitions/sequence" } }};
+var func2 = Object.prototype.hasOwnProperty;
+var func3 = ucs2length;
+var schema17 = { "enum": ["blue", "amber", "green", "violet", "rose", "slate", "coin"] };
+var pattern0 = new RegExp("^[^\\s\\[\\]\u300C\u300D=:]+$", "u");
+function validate11(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.id === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "id" }, message: "must have required property 'id'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.name === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "name" }, message: "must have required property 'name'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    for (const key0 in data) {
+      if (!(key0 === "id" || key0 === "name" || key0 === "note" || key0 === "color" || key0 === "icon")) {
+        const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+    }
+    if (data.id !== void 0) {
+      let data0 = data.id;
+      if (typeof data0 === "string") {
+        if (!pattern0.test(data0)) {
+          const err3 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
+          if (vErrors === null) {
+            vErrors = [err3];
+          } else {
+            vErrors.push(err3);
+          }
+          errors++;
+        }
+      } else {
+        const err4 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.name !== void 0) {
+      let data1 = data.name;
+      if (typeof data1 === "string") {
+        if (func3(data1) < 1) {
+          const err5 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err5];
+          } else {
+            vErrors.push(err5);
+          }
+          errors++;
+        }
+      } else {
+        const err6 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.note !== void 0) {
+      let data2 = data.note;
+      if (typeof data2 === "string") {
+        if (func3(data2) < 1) {
+          const err7 = { instancePath: instancePath + "/note", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err7];
+          } else {
+            vErrors.push(err7);
+          }
+          errors++;
+        }
+      } else {
+        const err8 = { instancePath: instancePath + "/note", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.color !== void 0) {
+      let data3 = data.color;
+      if (!(data3 === "blue" || data3 === "amber" || data3 === "green" || data3 === "violet" || data3 === "rose" || data3 === "slate" || data3 === "coin")) {
+        const err9 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues: schema17.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.icon !== void 0) {
+      let data4 = data.icon;
+      if (typeof data4 === "string") {
+        if (func3(data4) < 1) {
+          const err10 = { instancePath: instancePath + "/icon", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err10];
+          } else {
+            vErrors.push(err10);
+          }
+          errors++;
+        }
+      } else {
+        const err11 = { instancePath: instancePath + "/icon", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err12 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err12];
+    } else {
+      vErrors.push(err12);
+    }
+    errors++;
+  }
+  validate11.errors = vErrors;
+  return errors === 0;
+}
+function validate13(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.id === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "id" }, message: "must have required property 'id'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.name === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "name" }, message: "must have required property 'name'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    for (const key0 in data) {
+      if (!(key0 === "id" || key0 === "name" || key0 === "sub" || key0 === "color" || key0 === "icon" || key0 === "region")) {
+        const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+    }
+    if (data.id !== void 0) {
+      let data0 = data.id;
+      if (typeof data0 === "string") {
+        if (!pattern0.test(data0)) {
+          const err3 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
+          if (vErrors === null) {
+            vErrors = [err3];
+          } else {
+            vErrors.push(err3);
+          }
+          errors++;
+        }
+      } else {
+        const err4 = { instancePath: instancePath + "/id", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.name !== void 0) {
+      let data1 = data.name;
+      if (typeof data1 === "string") {
+        if (func3(data1) < 1) {
+          const err5 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err5];
+          } else {
+            vErrors.push(err5);
+          }
+          errors++;
+        }
+      } else {
+        const err6 = { instancePath: instancePath + "/name", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.sub !== void 0) {
+      let data2 = data.sub;
+      if (typeof data2 === "string") {
+        if (func3(data2) < 1) {
+          const err7 = { instancePath: instancePath + "/sub", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err7];
+          } else {
+            vErrors.push(err7);
+          }
+          errors++;
+        }
+      } else {
+        const err8 = { instancePath: instancePath + "/sub", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.color !== void 0) {
+      let data3 = data.color;
+      if (!(data3 === "blue" || data3 === "amber" || data3 === "green" || data3 === "violet" || data3 === "rose" || data3 === "slate" || data3 === "coin")) {
+        const err9 = { instancePath: instancePath + "/color", schemaPath: "#/definitions/color/enum", keyword: "enum", params: { allowedValues: schema17.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.icon !== void 0) {
+      let data4 = data.icon;
+      if (typeof data4 === "string") {
+        if (func3(data4) < 1) {
+          const err10 = { instancePath: instancePath + "/icon", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err10];
+          } else {
+            vErrors.push(err10);
+          }
+          errors++;
+        }
+      } else {
+        const err11 = { instancePath: instancePath + "/icon", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+    }
+    if (data.region !== void 0) {
+      let data5 = data.region;
+      if (typeof data5 === "string") {
+        if (!pattern0.test(data5)) {
+          const err12 = { instancePath: instancePath + "/region", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
+          if (vErrors === null) {
+            vErrors = [err12];
+          } else {
+            vErrors.push(err12);
+          }
+          errors++;
+        }
+      } else {
+        const err13 = { instancePath: instancePath + "/region", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err13];
+        } else {
+          vErrors.push(err13);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err14 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err14];
+    } else {
+      vErrors.push(err14);
+    }
+    errors++;
+  }
+  validate13.errors = vErrors;
+  return errors === 0;
+}
+function validate15(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.title === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "title" }, message: "must have required property 'title'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.fields === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "fields" }, message: "must have required property 'fields'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    for (const key0 in data) {
+      if (!(key0 === "title" || key0 === "fields")) {
+        const err2 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+    }
+    if (data.title !== void 0) {
+      let data0 = data.title;
+      if (typeof data0 === "string") {
+        if (func3(data0) < 1) {
+          const err3 = { instancePath: instancePath + "/title", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err3];
+          } else {
+            vErrors.push(err3);
+          }
+          errors++;
+        }
+      } else {
+        const err4 = { instancePath: instancePath + "/title", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.fields !== void 0) {
+      let data1 = data.fields;
+      if (Array.isArray(data1)) {
+        if (data1.length < 1) {
+          const err5 = { instancePath: instancePath + "/fields", schemaPath: "#/properties/fields/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+          if (vErrors === null) {
+            vErrors = [err5];
+          } else {
+            vErrors.push(err5);
+          }
+          errors++;
+        }
+        const len0 = data1.length;
+        for (let i0 = 0; i0 < len0; i0++) {
+          let data2 = data1[i0];
+          if (typeof data2 === "string") {
+            if (func3(data2) < 1) {
+              const err6 = { instancePath: instancePath + "/fields/" + i0, schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+              if (vErrors === null) {
+                vErrors = [err6];
+              } else {
+                vErrors.push(err6);
+              }
+              errors++;
+            }
+          } else {
+            const err7 = { instancePath: instancePath + "/fields/" + i0, schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err7];
+            } else {
+              vErrors.push(err7);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err8 = { instancePath: instancePath + "/fields", schemaPath: "#/properties/fields/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err9 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err9];
+    } else {
+      vErrors.push(err9);
+    }
+    errors++;
+  }
+  validate15.errors = vErrors;
+  return errors === 0;
+}
+var schema33 = { "oneOf": [{ "description": "\u7DDA\u3002\u904B\u3076\u7269\u3092\u8F09\u305B\u3066\u9001\u308B\u5074\u304B\u3089\u53D7\u3051\u308B\u5074\u3078\u8D70\u308B", "type": "object", "additionalProperties": false, "required": ["type", "from", "to", "carry"], "properties": { "type": { "const": "edge" }, "from": { "$ref": "#/definitions/id" }, "to": { "$ref": "#/definitions/id" }, "label": { "$ref": "#/definitions/text" }, "carry": { "$ref": "#/definitions/carry" }, "labelSide": { "description": "\u7DDA\u306E\u540D\u524D\u3092\u7F6E\u304F\u5074 (\u5BC4\u305B\u306E\u6307\u793A)", "enum": ["above", "below", "left", "right"] } } }, { "description": "\u7BB1\u306E\u4E2D\u306E\u51E6\u7406", "type": "object", "additionalProperties": false, "required": ["type", "box", "label"], "properties": { "type": { "const": "action" }, "box": { "$ref": "#/definitions/id" }, "label": { "$ref": "#/definitions/text" } } }, { "description": "\u7BB1\u306E\u4E0B\u306E\u5C0F\u3055\u306A\u5B57\u306E\u66F8\u304D\u63DB\u3048", "type": "object", "additionalProperties": false, "required": ["type", "box", "text"], "properties": { "type": { "const": "swap" }, "box": { "$ref": "#/definitions/id" }, "text": { "$ref": "#/definitions/text" } } }, { "description": "\u4E2D\u8EAB\u306E\u5E2F\u306E\u6B04\u306E\u5024\u3068\u672D", "type": "object", "additionalProperties": false, "required": ["type", "field"], "anyOf": [{ "required": ["value"] }, { "required": ["tag"] }], "properties": { "type": { "const": "strip" }, "field": { "$ref": "#/definitions/text" }, "value": { "$ref": "#/definitions/text" }, "tag": { "$ref": "#/definitions/text" } } }] };
+var schema37 = { "properties": { "kind": { "enum": ["envelope", "tag", "coin", "none"] }}};
+function validate19(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const _errs1 = errors;
+  let valid0 = true;
+  const _errs2 = errors;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.kind === void 0 && ("kind")) {
+      const err0 = {};
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    } else {
+      if (data.kind !== void 0) {
+        if ("tag" !== data.kind) {
+          const err1 = {};
+          if (vErrors === null) {
+            vErrors = [err1];
+          } else {
+            vErrors.push(err1);
+          }
+          errors++;
+        }
+      }
+    }
+  }
+  var _valid0 = _errs2 === errors;
+  errors = _errs1;
+  if (vErrors !== null) {
+    if (_errs1) {
+      vErrors.length = _errs1;
+    } else {
+      vErrors = null;
+    }
+  }
+  let ifClause0;
+  if (_valid0) {
+    const _errs4 = errors;
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      if (data.text === void 0) {
+        const err2 = { instancePath, schemaPath: "#/then/required", keyword: "required", params: { missingProperty: "text" }, message: "must have required property 'text'" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+    }
+    var _valid0 = _errs4 === errors;
+    valid0 = _valid0;
+    ifClause0 = "then";
+  } else {
+    const _errs5 = errors;
+    const _errs6 = errors;
+    const _errs7 = errors;
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      if (data.text === void 0 && ("text")) {
+        const err3 = {};
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    var valid2 = _errs7 === errors;
+    if (valid2) {
+      const err4 = { instancePath, schemaPath: "#/else/not", keyword: "not", params: {}, message: "must NOT be valid" };
+      if (vErrors === null) {
+        vErrors = [err4];
+      } else {
+        vErrors.push(err4);
+      }
+      errors++;
+    } else {
+      errors = _errs6;
+      if (vErrors !== null) {
+        if (_errs6) {
+          vErrors.length = _errs6;
+        } else {
+          vErrors = null;
+        }
+      }
+    }
+    var _valid0 = _errs5 === errors;
+    valid0 = _valid0;
+    ifClause0 = "else";
+  }
+  if (!valid0) {
+    const err5 = { instancePath, schemaPath: "#/if", keyword: "if", params: { failingKeyword: ifClause0 }, message: 'must match "' + ifClause0 + '" schema' };
+    if (vErrors === null) {
+      vErrors = [err5];
+    } else {
+      vErrors.push(err5);
+    }
+    errors++;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.kind === void 0) {
+      const err6 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "kind" }, message: "must have required property 'kind'" };
+      if (vErrors === null) {
+        vErrors = [err6];
+      } else {
+        vErrors.push(err6);
+      }
+      errors++;
+    }
+    for (const key0 in data) {
+      if (!(key0 === "kind" || key0 === "text")) {
+        const err7 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+    if (data.kind !== void 0) {
+      let data1 = data.kind;
+      if (!(data1 === "envelope" || data1 === "tag" || data1 === "coin" || data1 === "none")) {
+        const err8 = { instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/enum", keyword: "enum", params: { allowedValues: schema37.properties.kind.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.text !== void 0) {
+      let data2 = data.text;
+      if (typeof data2 === "string") {
+        if (func3(data2) < 1) {
+          const err9 = { instancePath: instancePath + "/text", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err9];
+          } else {
+            vErrors.push(err9);
+          }
+          errors++;
+        }
+      } else {
+        const err10 = { instancePath: instancePath + "/text", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err11 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err11];
+    } else {
+      vErrors.push(err11);
+    }
+    errors++;
+  }
+  validate19.errors = vErrors;
+  return errors === 0;
+}
+function validate18(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.type === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    const tag0 = data.type;
+    if (typeof tag0 == "string") {
+      if (tag0 === "edge") {
+        if (data && typeof data == "object" && !Array.isArray(data)) {
+          if (data.type === void 0) {
+            const err1 = { instancePath, schemaPath: "#/oneOf/0/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
+            if (vErrors === null) {
+              vErrors = [err1];
+            } else {
+              vErrors.push(err1);
+            }
+            errors++;
+          }
+          if (data.from === void 0) {
+            const err2 = { instancePath, schemaPath: "#/oneOf/0/required", keyword: "required", params: { missingProperty: "from" }, message: "must have required property 'from'" };
+            if (vErrors === null) {
+              vErrors = [err2];
+            } else {
+              vErrors.push(err2);
+            }
+            errors++;
+          }
+          if (data.to === void 0) {
+            const err3 = { instancePath, schemaPath: "#/oneOf/0/required", keyword: "required", params: { missingProperty: "to" }, message: "must have required property 'to'" };
+            if (vErrors === null) {
+              vErrors = [err3];
+            } else {
+              vErrors.push(err3);
+            }
+            errors++;
+          }
+          if (data.carry === void 0) {
+            const err4 = { instancePath, schemaPath: "#/oneOf/0/required", keyword: "required", params: { missingProperty: "carry" }, message: "must have required property 'carry'" };
+            if (vErrors === null) {
+              vErrors = [err4];
+            } else {
+              vErrors.push(err4);
+            }
+            errors++;
+          }
+          for (const key0 in data) {
+            if (!(key0 === "type" || key0 === "from" || key0 === "to" || key0 === "label" || key0 === "carry" || key0 === "labelSide")) {
+              const err5 = { instancePath, schemaPath: "#/oneOf/0/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+              if (vErrors === null) {
+                vErrors = [err5];
+              } else {
+                vErrors.push(err5);
+              }
+              errors++;
+            }
+          }
+          if (data.type !== void 0) {
+            if ("edge" !== data.type) {
+              const err6 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/0/properties/type/const", keyword: "const", params: { allowedValue: "edge" }, message: "must be equal to constant" };
+              if (vErrors === null) {
+                vErrors = [err6];
+              } else {
+                vErrors.push(err6);
+              }
+              errors++;
+            }
+          }
+          if (data.from !== void 0) {
+            let data1 = data.from;
+            if (typeof data1 === "string") {
+              if (!pattern0.test(data1)) {
+                const err7 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
+                if (vErrors === null) {
+                  vErrors = [err7];
+                } else {
+                  vErrors.push(err7);
+                }
+                errors++;
+              }
+            } else {
+              const err8 = { instancePath: instancePath + "/from", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err8];
+              } else {
+                vErrors.push(err8);
+              }
+              errors++;
+            }
+          }
+          if (data.to !== void 0) {
+            let data2 = data.to;
+            if (typeof data2 === "string") {
+              if (!pattern0.test(data2)) {
+                const err9 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
+                if (vErrors === null) {
+                  vErrors = [err9];
+                } else {
+                  vErrors.push(err9);
+                }
+                errors++;
+              }
+            } else {
+              const err10 = { instancePath: instancePath + "/to", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err10];
+              } else {
+                vErrors.push(err10);
+              }
+              errors++;
+            }
+          }
+          if (data.label !== void 0) {
+            let data3 = data.label;
+            if (typeof data3 === "string") {
+              if (func3(data3) < 1) {
+                const err11 = { instancePath: instancePath + "/label", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                if (vErrors === null) {
+                  vErrors = [err11];
+                } else {
+                  vErrors.push(err11);
+                }
+                errors++;
+              }
+            } else {
+              const err12 = { instancePath: instancePath + "/label", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err12];
+              } else {
+                vErrors.push(err12);
+              }
+              errors++;
+            }
+          }
+          if (data.carry !== void 0) {
+            if (!validate19(data.carry, { instancePath: instancePath + "/carry", parentData: data, parentDataProperty: "carry", rootData })) {
+              vErrors = vErrors === null ? validate19.errors : vErrors.concat(validate19.errors);
+              errors = vErrors.length;
+            }
+          }
+          if (data.labelSide !== void 0) {
+            let data5 = data.labelSide;
+            if (!(data5 === "above" || data5 === "below" || data5 === "left" || data5 === "right")) {
+              const err13 = { instancePath: instancePath + "/labelSide", schemaPath: "#/oneOf/0/properties/labelSide/enum", keyword: "enum", params: { allowedValues: schema33.oneOf[0].properties.labelSide.enum }, message: "must be equal to one of the allowed values" };
+              if (vErrors === null) {
+                vErrors = [err13];
+              } else {
+                vErrors.push(err13);
+              }
+              errors++;
+            }
+          }
+        } else {
+          const err14 = { instancePath, schemaPath: "#/oneOf/0/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+          if (vErrors === null) {
+            vErrors = [err14];
+          } else {
+            vErrors.push(err14);
+          }
+          errors++;
+        }
+      } else if (tag0 === "action") {
+        if (data && typeof data == "object" && !Array.isArray(data)) {
+          if (data.type === void 0) {
+            const err15 = { instancePath, schemaPath: "#/oneOf/1/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
+            if (vErrors === null) {
+              vErrors = [err15];
+            } else {
+              vErrors.push(err15);
+            }
+            errors++;
+          }
+          if (data.box === void 0) {
+            const err16 = { instancePath, schemaPath: "#/oneOf/1/required", keyword: "required", params: { missingProperty: "box" }, message: "must have required property 'box'" };
+            if (vErrors === null) {
+              vErrors = [err16];
+            } else {
+              vErrors.push(err16);
+            }
+            errors++;
+          }
+          if (data.label === void 0) {
+            const err17 = { instancePath, schemaPath: "#/oneOf/1/required", keyword: "required", params: { missingProperty: "label" }, message: "must have required property 'label'" };
+            if (vErrors === null) {
+              vErrors = [err17];
+            } else {
+              vErrors.push(err17);
+            }
+            errors++;
+          }
+          for (const key1 in data) {
+            if (!(key1 === "type" || key1 === "box" || key1 === "label")) {
+              const err18 = { instancePath, schemaPath: "#/oneOf/1/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+              if (vErrors === null) {
+                vErrors = [err18];
+              } else {
+                vErrors.push(err18);
+              }
+              errors++;
+            }
+          }
+          if (data.type !== void 0) {
+            if ("action" !== data.type) {
+              const err19 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/1/properties/type/const", keyword: "const", params: { allowedValue: "action" }, message: "must be equal to constant" };
+              if (vErrors === null) {
+                vErrors = [err19];
+              } else {
+                vErrors.push(err19);
+              }
+              errors++;
+            }
+          }
+          if (data.box !== void 0) {
+            let data7 = data.box;
+            if (typeof data7 === "string") {
+              if (!pattern0.test(data7)) {
+                const err20 = { instancePath: instancePath + "/box", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
+                if (vErrors === null) {
+                  vErrors = [err20];
+                } else {
+                  vErrors.push(err20);
+                }
+                errors++;
+              }
+            } else {
+              const err21 = { instancePath: instancePath + "/box", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err21];
+              } else {
+                vErrors.push(err21);
+              }
+              errors++;
+            }
+          }
+          if (data.label !== void 0) {
+            let data8 = data.label;
+            if (typeof data8 === "string") {
+              if (func3(data8) < 1) {
+                const err22 = { instancePath: instancePath + "/label", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                if (vErrors === null) {
+                  vErrors = [err22];
+                } else {
+                  vErrors.push(err22);
+                }
+                errors++;
+              }
+            } else {
+              const err23 = { instancePath: instancePath + "/label", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err23];
+              } else {
+                vErrors.push(err23);
+              }
+              errors++;
+            }
+          }
+        } else {
+          const err24 = { instancePath, schemaPath: "#/oneOf/1/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+          if (vErrors === null) {
+            vErrors = [err24];
+          } else {
+            vErrors.push(err24);
+          }
+          errors++;
+        }
+      } else if (tag0 === "swap") {
+        if (data && typeof data == "object" && !Array.isArray(data)) {
+          if (data.type === void 0) {
+            const err25 = { instancePath, schemaPath: "#/oneOf/2/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
+            if (vErrors === null) {
+              vErrors = [err25];
+            } else {
+              vErrors.push(err25);
+            }
+            errors++;
+          }
+          if (data.box === void 0) {
+            const err26 = { instancePath, schemaPath: "#/oneOf/2/required", keyword: "required", params: { missingProperty: "box" }, message: "must have required property 'box'" };
+            if (vErrors === null) {
+              vErrors = [err26];
+            } else {
+              vErrors.push(err26);
+            }
+            errors++;
+          }
+          if (data.text === void 0) {
+            const err27 = { instancePath, schemaPath: "#/oneOf/2/required", keyword: "required", params: { missingProperty: "text" }, message: "must have required property 'text'" };
+            if (vErrors === null) {
+              vErrors = [err27];
+            } else {
+              vErrors.push(err27);
+            }
+            errors++;
+          }
+          for (const key2 in data) {
+            if (!(key2 === "type" || key2 === "box" || key2 === "text")) {
+              const err28 = { instancePath, schemaPath: "#/oneOf/2/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+              if (vErrors === null) {
+                vErrors = [err28];
+              } else {
+                vErrors.push(err28);
+              }
+              errors++;
+            }
+          }
+          if (data.type !== void 0) {
+            if ("swap" !== data.type) {
+              const err29 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/2/properties/type/const", keyword: "const", params: { allowedValue: "swap" }, message: "must be equal to constant" };
+              if (vErrors === null) {
+                vErrors = [err29];
+              } else {
+                vErrors.push(err29);
+              }
+              errors++;
+            }
+          }
+          if (data.box !== void 0) {
+            let data10 = data.box;
+            if (typeof data10 === "string") {
+              if (!pattern0.test(data10)) {
+                const err30 = { instancePath: instancePath + "/box", schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
+                if (vErrors === null) {
+                  vErrors = [err30];
+                } else {
+                  vErrors.push(err30);
+                }
+                errors++;
+              }
+            } else {
+              const err31 = { instancePath: instancePath + "/box", schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err31];
+              } else {
+                vErrors.push(err31);
+              }
+              errors++;
+            }
+          }
+          if (data.text !== void 0) {
+            let data11 = data.text;
+            if (typeof data11 === "string") {
+              if (func3(data11) < 1) {
+                const err32 = { instancePath: instancePath + "/text", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                if (vErrors === null) {
+                  vErrors = [err32];
+                } else {
+                  vErrors.push(err32);
+                }
+                errors++;
+              }
+            } else {
+              const err33 = { instancePath: instancePath + "/text", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err33];
+              } else {
+                vErrors.push(err33);
+              }
+              errors++;
+            }
+          }
+        } else {
+          const err34 = { instancePath, schemaPath: "#/oneOf/2/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+          if (vErrors === null) {
+            vErrors = [err34];
+          } else {
+            vErrors.push(err34);
+          }
+          errors++;
+        }
+      } else if (tag0 === "strip") {
+        const _errs39 = errors;
+        let valid15 = false;
+        const _errs40 = errors;
+        if (data && typeof data == "object" && !Array.isArray(data)) {
+          if (data.value === void 0) {
+            const err35 = { instancePath, schemaPath: "#/oneOf/3/anyOf/0/required", keyword: "required", params: { missingProperty: "value" }, message: "must have required property 'value'" };
+            if (vErrors === null) {
+              vErrors = [err35];
+            } else {
+              vErrors.push(err35);
+            }
+            errors++;
+          }
+        }
+        var _valid0 = _errs40 === errors;
+        valid15 = valid15 || _valid0;
+        if (!valid15) {
+          const _errs41 = errors;
+          if (data && typeof data == "object" && !Array.isArray(data)) {
+            if (data.tag === void 0) {
+              const err36 = { instancePath, schemaPath: "#/oneOf/3/anyOf/1/required", keyword: "required", params: { missingProperty: "tag" }, message: "must have required property 'tag'" };
+              if (vErrors === null) {
+                vErrors = [err36];
+              } else {
+                vErrors.push(err36);
+              }
+              errors++;
+            }
+          }
+          var _valid0 = _errs41 === errors;
+          valid15 = valid15 || _valid0;
+        }
+        if (!valid15) {
+          const err37 = { instancePath, schemaPath: "#/oneOf/3/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+          if (vErrors === null) {
+            vErrors = [err37];
+          } else {
+            vErrors.push(err37);
+          }
+          errors++;
+        } else {
+          errors = _errs39;
+          if (vErrors !== null) {
+            if (_errs39) {
+              vErrors.length = _errs39;
+            } else {
+              vErrors = null;
+            }
+          }
+        }
+        if (data && typeof data == "object" && !Array.isArray(data)) {
+          if (data.type === void 0) {
+            const err38 = { instancePath, schemaPath: "#/oneOf/3/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
+            if (vErrors === null) {
+              vErrors = [err38];
+            } else {
+              vErrors.push(err38);
+            }
+            errors++;
+          }
+          if (data.field === void 0) {
+            const err39 = { instancePath, schemaPath: "#/oneOf/3/required", keyword: "required", params: { missingProperty: "field" }, message: "must have required property 'field'" };
+            if (vErrors === null) {
+              vErrors = [err39];
+            } else {
+              vErrors.push(err39);
+            }
+            errors++;
+          }
+          for (const key3 in data) {
+            if (!(key3 === "type" || key3 === "field" || key3 === "value" || key3 === "tag")) {
+              const err40 = { instancePath, schemaPath: "#/oneOf/3/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" };
+              if (vErrors === null) {
+                vErrors = [err40];
+              } else {
+                vErrors.push(err40);
+              }
+              errors++;
+            }
+          }
+          if (data.type !== void 0) {
+            if ("strip" !== data.type) {
+              const err41 = { instancePath: instancePath + "/type", schemaPath: "#/oneOf/3/properties/type/const", keyword: "const", params: { allowedValue: "strip" }, message: "must be equal to constant" };
+              if (vErrors === null) {
+                vErrors = [err41];
+              } else {
+                vErrors.push(err41);
+              }
+              errors++;
+            }
+          }
+          if (data.field !== void 0) {
+            let data13 = data.field;
+            if (typeof data13 === "string") {
+              if (func3(data13) < 1) {
+                const err42 = { instancePath: instancePath + "/field", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                if (vErrors === null) {
+                  vErrors = [err42];
+                } else {
+                  vErrors.push(err42);
+                }
+                errors++;
+              }
+            } else {
+              const err43 = { instancePath: instancePath + "/field", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err43];
+              } else {
+                vErrors.push(err43);
+              }
+              errors++;
+            }
+          }
+          if (data.value !== void 0) {
+            let data14 = data.value;
+            if (typeof data14 === "string") {
+              if (func3(data14) < 1) {
+                const err44 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                if (vErrors === null) {
+                  vErrors = [err44];
+                } else {
+                  vErrors.push(err44);
+                }
+                errors++;
+              }
+            } else {
+              const err45 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err45];
+              } else {
+                vErrors.push(err45);
+              }
+              errors++;
+            }
+          }
+          if (data.tag !== void 0) {
+            let data15 = data.tag;
+            if (typeof data15 === "string") {
+              if (func3(data15) < 1) {
+                const err46 = { instancePath: instancePath + "/tag", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+                if (vErrors === null) {
+                  vErrors = [err46];
+                } else {
+                  vErrors.push(err46);
+                }
+                errors++;
+              }
+            } else {
+              const err47 = { instancePath: instancePath + "/tag", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err47];
+              } else {
+                vErrors.push(err47);
+              }
+              errors++;
+            }
+          }
+        } else {
+          const err48 = { instancePath, schemaPath: "#/oneOf/3/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+          if (vErrors === null) {
+            vErrors = [err48];
+          } else {
+            vErrors.push(err48);
+          }
+          errors++;
+        }
+      } else {
+        const err49 = { instancePath, schemaPath: "#/discriminator", keyword: "discriminator", params: { error: "mapping", tag: "type", tagValue: tag0 }, message: 'value of tag "type" must be in oneOf' };
+        if (vErrors === null) {
+          vErrors = [err49];
+        } else {
+          vErrors.push(err49);
+        }
+        errors++;
+      }
+    } else {
+      const err50 = { instancePath, schemaPath: "#/discriminator", keyword: "discriminator", params: { error: "tag", tag: "type", tagValue: tag0 }, message: 'tag "type" must be string' };
+      if (vErrors === null) {
+        vErrors = [err50];
+      } else {
+        vErrors.push(err50);
+      }
+      errors++;
+    }
+  } else {
+    const err51 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err51];
+    } else {
+      vErrors.push(err51);
+    }
+    errors++;
+  }
+  validate18.errors = vErrors;
+  return errors === 0;
+}
+function validate17(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.title === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "title" }, message: "must have required property 'title'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.body === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "body" }, message: "must have required property 'body'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.events === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "events" }, message: "must have required property 'events'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    for (const key0 in data) {
+      if (!(key0 === "title" || key0 === "body" || key0 === "code" || key0 === "events")) {
+        const err3 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.title !== void 0) {
+      let data0 = data.title;
+      if (typeof data0 === "string") {
+        if (func3(data0) < 1) {
+          const err4 = { instancePath: instancePath + "/title", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err4];
+          } else {
+            vErrors.push(err4);
+          }
+          errors++;
+        }
+      } else {
+        const err5 = { instancePath: instancePath + "/title", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.body !== void 0) {
+      let data1 = data.body;
+      if (typeof data1 === "string") {
+        if (func3(data1) < 1) {
+          const err6 = { instancePath: instancePath + "/body", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err6];
+          } else {
+            vErrors.push(err6);
+          }
+          errors++;
+        }
+      } else {
+        const err7 = { instancePath: instancePath + "/body", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+    if (data.code !== void 0) {
+      let data2 = data.code;
+      if (typeof data2 === "string") {
+        if (func3(data2) < 1) {
+          const err8 = { instancePath: instancePath + "/code", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err8];
+          } else {
+            vErrors.push(err8);
+          }
+          errors++;
+        }
+      } else {
+        const err9 = { instancePath: instancePath + "/code", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.events !== void 0) {
+      let data3 = data.events;
+      if (Array.isArray(data3)) {
+        const len0 = data3.length;
+        for (let i0 = 0; i0 < len0; i0++) {
+          if (!validate18(data3[i0], { instancePath: instancePath + "/events/" + i0, parentData: data3, parentDataProperty: i0, rootData })) {
+            vErrors = vErrors === null ? validate18.errors : vErrors.concat(validate18.errors);
+            errors = vErrors.length;
+          }
+        }
+      } else {
+        const err10 = { instancePath: instancePath + "/events", schemaPath: "#/properties/events/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err11 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err11];
+    } else {
+      vErrors.push(err11);
+    }
+    errors++;
+  }
+  validate17.errors = vErrors;
+  return errors === 0;
+}
+function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.lifelines === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "lifelines" }, message: "must have required property 'lifelines'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    for (const key0 in data) {
+      if (!(key0 === "lifelines")) {
+        const err1 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+        if (vErrors === null) {
+          vErrors = [err1];
+        } else {
+          vErrors.push(err1);
+        }
+        errors++;
+      }
+    }
+    if (data.lifelines !== void 0) {
+      let data0 = data.lifelines;
+      if (Array.isArray(data0)) {
+        if (data0.length < 1) {
+          const err2 = { instancePath: instancePath + "/lifelines", schemaPath: "#/properties/lifelines/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+          if (vErrors === null) {
+            vErrors = [err2];
+          } else {
+            vErrors.push(err2);
+          }
+          errors++;
+        }
+        const len0 = data0.length;
+        for (let i0 = 0; i0 < len0; i0++) {
+          let data1 = data0[i0];
+          if (typeof data1 === "string") {
+            if (!pattern0.test(data1)) {
+              const err3 = { instancePath: instancePath + "/lifelines/" + i0, schemaPath: "#/definitions/id/pattern", keyword: "pattern", params: { pattern: "^[^\\s\\[\\]\u300C\u300D=:]+$" }, message: 'must match pattern "^[^\\s\\[\\]\u300C\u300D=:]+$"' };
+              if (vErrors === null) {
+                vErrors = [err3];
+              } else {
+                vErrors.push(err3);
+              }
+              errors++;
+            }
+          } else {
+            const err4 = { instancePath: instancePath + "/lifelines/" + i0, schemaPath: "#/definitions/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err4];
+            } else {
+              vErrors.push(err4);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err5 = { instancePath: instancePath + "/lifelines", schemaPath: "#/properties/lifelines/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err6 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err6];
+    } else {
+      vErrors.push(err6);
+    }
+    errors++;
+  }
+  validate23.errors = vErrors;
+  return errors === 0;
+}
+function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const _errs1 = errors;
+  let valid0 = true;
+  const _errs2 = errors;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.kind === void 0 && ("kind")) {
+      const err0 = {};
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    } else {
+      if (data.kind !== void 0) {
+        if ("sequence" !== data.kind) {
+          const err1 = {};
+          if (vErrors === null) {
+            vErrors = [err1];
+          } else {
+            vErrors.push(err1);
+          }
+          errors++;
+        }
+      }
+    }
+  }
+  var _valid0 = _errs2 === errors;
+  errors = _errs1;
+  if (vErrors !== null) {
+    if (_errs1) {
+      vErrors.length = _errs1;
+    } else {
+      vErrors = null;
+    }
+  }
+  let ifClause0;
+  if (_valid0) {
+    const _errs4 = errors;
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      if (data.sequence === void 0) {
+        const err2 = { instancePath, schemaPath: "#/then/required", keyword: "required", params: { missingProperty: "sequence" }, message: "must have required property 'sequence'" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+    }
+    var _valid0 = _errs4 === errors;
+    valid0 = _valid0;
+    ifClause0 = "then";
+  } else {
+    const _errs5 = errors;
+    const _errs6 = errors;
+    const _errs7 = errors;
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      if (data.sequence === void 0 && ("sequence")) {
+        const err3 = {};
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    var valid2 = _errs7 === errors;
+    if (valid2) {
+      const err4 = { instancePath, schemaPath: "#/else/not", keyword: "not", params: {}, message: "must NOT be valid" };
+      if (vErrors === null) {
+        vErrors = [err4];
+      } else {
+        vErrors.push(err4);
+      }
+      errors++;
+    } else {
+      errors = _errs6;
+      if (vErrors !== null) {
+        if (_errs6) {
+          vErrors.length = _errs6;
+        } else {
+          vErrors = null;
+        }
+      }
+    }
+    var _valid0 = _errs5 === errors;
+    valid0 = _valid0;
+    ifClause0 = "else";
+  }
+  if (!valid0) {
+    const err5 = { instancePath, schemaPath: "#/if", keyword: "if", params: { failingKeyword: ifClause0 }, message: 'must match "' + ifClause0 + '" schema' };
+    if (vErrors === null) {
+      vErrors = [err5];
+    } else {
+      vErrors.push(err5);
+    }
+    errors++;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.version === void 0) {
+      const err6 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "version" }, message: "must have required property 'version'" };
+      if (vErrors === null) {
+        vErrors = [err6];
+      } else {
+        vErrors.push(err6);
+      }
+      errors++;
+    }
+    if (data.kind === void 0) {
+      const err7 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "kind" }, message: "must have required property 'kind'" };
+      if (vErrors === null) {
+        vErrors = [err7];
+      } else {
+        vErrors.push(err7);
+      }
+      errors++;
+    }
+    if (data.title === void 0) {
+      const err8 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "title" }, message: "must have required property 'title'" };
+      if (vErrors === null) {
+        vErrors = [err8];
+      } else {
+        vErrors.push(err8);
+      }
+      errors++;
+    }
+    if (data.boxes === void 0) {
+      const err9 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "boxes" }, message: "must have required property 'boxes'" };
+      if (vErrors === null) {
+        vErrors = [err9];
+      } else {
+        vErrors.push(err9);
+      }
+      errors++;
+    }
+    if (data.steps === void 0) {
+      const err10 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "steps" }, message: "must have required property 'steps'" };
+      if (vErrors === null) {
+        vErrors = [err10];
+      } else {
+        vErrors.push(err10);
+      }
+      errors++;
+    }
+    for (const key0 in data) {
+      if (!func2.call(schema11.properties, key0)) {
+        const err11 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+    }
+    if (data.version !== void 0) {
+      let data1 = data.version;
+      if (!(typeof data1 == "number" && (!(data1 % 1) && !isNaN(data1)) && isFinite(data1))) {
+        const err12 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+      if (typeof data1 == "number" && isFinite(data1)) {
+        if (data1 < 1 || isNaN(data1)) {
+          const err13 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+          if (vErrors === null) {
+            vErrors = [err13];
+          } else {
+            vErrors.push(err13);
+          }
+          errors++;
+        }
+      }
+    }
+    if (data.kind !== void 0) {
+      let data2 = data.kind;
+      if (!(data2 === "sequence" || data2 === "architecture")) {
+        const err14 = { instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/enum", keyword: "enum", params: { allowedValues: schema11.properties.kind.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err14];
+        } else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+    }
+    if (data.title !== void 0) {
+      let data3 = data.title;
+      if (typeof data3 === "string") {
+        if (func3(data3) < 1) {
+          const err15 = { instancePath: instancePath + "/title", schemaPath: "#/definitions/text/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err15];
+          } else {
+            vErrors.push(err15);
+          }
+          errors++;
+        }
+      } else {
+        const err16 = { instancePath: instancePath + "/title", schemaPath: "#/definitions/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err16];
+        } else {
+          vErrors.push(err16);
+        }
+        errors++;
+      }
+    }
+    if (data.view !== void 0) {
+      let data4 = data.view;
+      if (!(data4 === "fixed" || data4 === "follow")) {
+        const err17 = { instancePath: instancePath + "/view", schemaPath: "#/properties/view/enum", keyword: "enum", params: { allowedValues: schema11.properties.view.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err17];
+        } else {
+          vErrors.push(err17);
+        }
+        errors++;
+      }
+    }
+    if (data.regions !== void 0) {
+      let data5 = data.regions;
+      if (Array.isArray(data5)) {
+        const len0 = data5.length;
+        for (let i0 = 0; i0 < len0; i0++) {
+          if (!validate11(data5[i0], { instancePath: instancePath + "/regions/" + i0, parentData: data5, parentDataProperty: i0, rootData })) {
+            vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);
+            errors = vErrors.length;
+          }
+        }
+      } else {
+        const err18 = { instancePath: instancePath + "/regions", schemaPath: "#/properties/regions/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err18];
+        } else {
+          vErrors.push(err18);
+        }
+        errors++;
+      }
+    }
+    if (data.boxes !== void 0) {
+      let data7 = data.boxes;
+      if (Array.isArray(data7)) {
+        if (data7.length < 1) {
+          const err19 = { instancePath: instancePath + "/boxes", schemaPath: "#/properties/boxes/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+          if (vErrors === null) {
+            vErrors = [err19];
+          } else {
+            vErrors.push(err19);
+          }
+          errors++;
+        }
+        const len1 = data7.length;
+        for (let i1 = 0; i1 < len1; i1++) {
+          if (!validate13(data7[i1], { instancePath: instancePath + "/boxes/" + i1, parentData: data7, parentDataProperty: i1, rootData })) {
+            vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+            errors = vErrors.length;
+          }
+        }
+      } else {
+        const err20 = { instancePath: instancePath + "/boxes", schemaPath: "#/properties/boxes/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err20];
+        } else {
+          vErrors.push(err20);
+        }
+        errors++;
+      }
+    }
+    if (data.strip !== void 0) {
+      if (!validate15(data.strip, { instancePath: instancePath + "/strip", parentData: data, parentDataProperty: "strip", rootData })) {
+        vErrors = vErrors === null ? validate15.errors : vErrors.concat(validate15.errors);
+        errors = vErrors.length;
+      }
+    }
+    if (data.steps !== void 0) {
+      let data10 = data.steps;
+      if (Array.isArray(data10)) {
+        if (data10.length < 1) {
+          const err21 = { instancePath: instancePath + "/steps", schemaPath: "#/properties/steps/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+          if (vErrors === null) {
+            vErrors = [err21];
+          } else {
+            vErrors.push(err21);
+          }
+          errors++;
+        }
+        const len2 = data10.length;
+        for (let i2 = 0; i2 < len2; i2++) {
+          if (!validate17(data10[i2], { instancePath: instancePath + "/steps/" + i2, parentData: data10, parentDataProperty: i2, rootData })) {
+            vErrors = vErrors === null ? validate17.errors : vErrors.concat(validate17.errors);
+            errors = vErrors.length;
+          }
+        }
+      } else {
+        const err22 = { instancePath: instancePath + "/steps", schemaPath: "#/properties/steps/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err22];
+        } else {
+          vErrors.push(err22);
+        }
+        errors++;
+      }
+    }
+    if (data.sequence !== void 0) {
+      if (!validate23(data.sequence, { instancePath: instancePath + "/sequence", parentData: data, parentDataProperty: "sequence", rootData })) {
+        vErrors = vErrors === null ? validate23.errors : vErrors.concat(validate23.errors);
+        errors = vErrors.length;
+      }
+    }
+  } else {
+    const err23 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err23];
+    } else {
+      vErrors.push(err23);
+    }
+    errors++;
+  }
+  validate10.errors = vErrors;
+  return errors === 0;
+}
+
+// src/schema.ts
+var EVENT_TYPES = ["edge", "action", "swap", "strip"];
+var NOT_ALLOWED = {
+  "": { field: "sequence", kind: "sequence" },
+  carry: { field: "text", kind: "tag" }
+};
+var escape = (key) => key.replaceAll("~", "~0").replaceAll("/", "~1");
+function forbiddenOf(pattern) {
+  const inside = /^\^\[\^(.+)\]\+\$$/u.exec(pattern)?.[1];
+  if (inside === void 0) return void 0;
+  const chars = inside.match(/\\.|[^\\]/gu) ?? [];
+  return { space: chars.includes("\\s"), chars: chars.filter((char) => char !== "\\s").map((char) => char.replace(/^\\/u, "")) };
+}
+var branchesOf = (anyOf, errors) => errors.filter(
+  (error) => error !== anyOf && error.schemaPath.startsWith(`${anyOf.schemaPath}/`) && (error.instancePath === anyOf.instancePath || error.instancePath.startsWith(`${anyOf.instancePath}/`))
+);
+function toFieldError(error, errors, m) {
+  const params = error.params;
+  const at2 = error.instancePath;
+  switch (error.keyword) {
+    case "additionalProperties": {
+      const key = String(params.additionalProperty);
+      return { pointer: `${at2}/${escape(key)}`, message: m.additionalProperties(key) };
+    }
+    case "required": {
+      const key = String(params.missingProperty);
+      return { pointer: `${at2}/${escape(key)}`, message: m.required(key) };
+    }
+    case "not": {
+      const allowed = NOT_ALLOWED[at2.slice(at2.lastIndexOf("/") + 1)];
+      return { pointer: allowed ? `${at2}/${allowed.field}` : at2, message: m.not(allowed) };
+    }
+    case "anyOf": {
+      const branches = branchesOf(error, errors);
+      const missing = branches.every((branch) => branch.keyword === "required") ? branches.map((branch) => String(branch.params.missingProperty)) : [];
+      return { pointer: at2, message: m.anyOf(missing) };
+    }
+    case "discriminator": {
+      const tag = String(params.tag);
+      return { pointer: `${at2}/${escape(tag)}`, message: m.discriminator(tag, EVENT_TYPES) };
+    }
+    case "enum":
+      return { pointer: at2, message: m.enum(params.allowedValues.map(String)) };
+    case "type":
+      return { pointer: at2, message: m.type(String(params.type)) };
+    case "minLength":
+      return { pointer: at2, message: m.minLength(Number(params.limit)) };
+    case "pattern":
+      return { pointer: at2, message: m.pattern(forbiddenOf(String(params.pattern))) };
+    case "minItems":
+      return { pointer: at2, message: m.minItems(Number(params.limit)) };
+    case "minimum":
+      return { pointer: at2, message: m.minimum(Number(params.limit)) };
+    case "const":
+      return { pointer: at2, message: m.const(String(params.allowedValue)) };
+    case "oneOf":
+      return { pointer: at2, message: m.oneOf };
+    default:
+      return { pointer: at2, message: error.message ?? error.keyword };
+  }
+}
+function validateDiagram(input, options = {}) {
+  if (validate_diagram_default(input)) return { ok: true };
+  const all = validate_diagram_default.errors ?? [];
+  const inBranch = new Set(all.filter((error) => error.keyword === "anyOf").flatMap((anyOf) => branchesOf(anyOf, all)));
+  const m = FIELD_MESSAGES[options.lang ?? "ja"];
+  const errors = all.filter((error) => error.keyword !== "if" && !inBranch.has(error)).map((error) => toFieldError(error, all, m));
+  return { ok: false, errors };
+}
+
+// src/version.ts
+var FORMAT_VERSION = 1;
+function newerThanTool(input) {
+  if (typeof input !== "object" || input === null) return void 0;
+  const version = input.version;
+  return typeof version === "number" && version > FORMAT_VERSION ? version : void 0;
+}
+var newerError = (version, lang) => ({
+  pointer: "/version",
+  message: FIELD_MESSAGES[lang].newer(version, FORMAT_VERSION)
+});
+function readDiagram(input, options = {}) {
+  const newer = newerThanTool(input);
+  if (newer !== void 0) return { ok: false, errors: [newerError(newer, options.lang ?? "ja")] };
+  const checked = validateDiagram(input, options);
+  if (!checked.ok) return checked;
+  return { ok: true, diagram: input, warnings: [] };
+}
+
+// src/timeline.ts
+function plan(step) {
+  const out = { edges: [], events: [], busy: 0 };
+  let cursor = MOTION.edgeAt;
+  let arrived;
+  let changes = 0;
+  step.events.forEach((event, e) => {
+    if (event.type === "edge") {
+      const carries = event.carry.kind !== "none";
+      const a = cursor;
+      const b = a + (carries ? MOTION.drawCarry : MOTION.draw);
+      out.edges.push({ event: e, a, b, carries, coin: event.carry.kind === "coin", named: event.label !== void 0 });
+      cursor = a + MOTION.stagger;
+      arrived = b;
+      changes = 0;
+      out.busy = Math.max(out.busy, b);
+    } else if (event.type === "action") {
+      out.events.push({ event: e, at: cursor });
+      out.busy = Math.max(out.busy, cursor + MOTION.action);
+      cursor += MOTION.action;
+      changes = 0;
+    } else {
+      const at2 = (arrived ?? cursor) + MOTION.change * changes++;
+      out.events.push({ event: e, at: at2 });
+      out.busy = Math.max(out.busy, at2);
+    }
+  });
+  return out;
+}
+function buildTimeline(diagram) {
+  const plans = diagram.steps.map(plan);
+  const steps = [];
+  let t = MOTION.intro;
+  diagram.steps.forEach((step, s) => {
+    const read = Math.min(MOTION.stepMax, Math.max(MOTION.stepMin, MOTION.stepBase + [...step.body].length * MOTION.perChar));
+    const length = Math.max(read, (plans[s]?.busy ?? 0) + MOTION.dwell);
+    steps.push({ start: t, end: t + length });
+    t += length;
+  });
+  const end = t;
+  const total = Math.ceil(end + MOTION.outro);
+  const last = total - MOTION.tail;
+  const edges = [];
+  const labels = [];
+  const events = [];
+  const departures = [];
+  plans.forEach((p, s) => {
+    const span = steps[s];
+    const named = [];
+    for (const edge2 of p.edges) {
+      const a = span.start + edge2.a;
+      edges.push({ step: s, event: edge2.event, start: a, drawn: span.start + edge2.b, end: span.end });
+      if (edge2.carries) departures.push({ step: s, event: edge2.event, who: edge2.coin ? "coin" : "main", a, b: span.start + edge2.b });
+      if (edge2.named) named.push({ step: s, event: edge2.event, start: a + MOTION.labelDelay, end: span.end });
+    }
+    named.forEach((label2, k) => {
+      const later = named[k + 2];
+      if (later) label2.end = Math.min(label2.end, later.start);
+    });
+    labels.push(...named);
+    for (const event of p.events) events.push({ step: s, event: event.event, at: span.start + event.at });
+  });
+  const first = steps[0]?.start ?? 0;
+  const hasMain = departures.some((d) => d.who === "main");
+  const carriers = [];
+  for (const who of ["main", "coin"]) {
+    const list = departures.filter((d) => d.who === who);
+    list.forEach((d, k) => {
+      const next = list[k + 1];
+      const waits = k === 0 && (who === "main" || !hasMain);
+      carriers.push({
+        step: d.step,
+        event: d.event,
+        who,
+        depart: d.a,
+        arrive: d.b,
+        start: waits ? Math.min(first, d.a) : d.a,
+        end: next ? Math.max(next.a, d.b) : last
+      });
+    });
+  }
+  carriers.sort((x, y) => x.depart - y.depart);
+  return {
+    total,
+    last,
+    steps,
+    edges,
+    carriers,
+    labels,
+    badges: steps.map((span, s) => ({ step: s, appears: span.start })),
+    events,
+    stills: steps.map((span) => span.end - MOTION.still)
+  };
+}
+
+// src/render/icons.ts
+var ICONS = {
+  app: "M -9 -7 h18 a2 2 0 0 1 2 2 v10 a2 2 0 0 1 -2 2 h-18 a2 2 0 0 1 -2 -2 v-10 a2 2 0 0 1 2 -2 z M -11 -2 h22",
+  router: "M -9 -4 h16 M 3 -8 l4 4 l-4 4 M 9 5 h-16 M -3 1 l-4 4 l4 4",
+  on: "M -7 7 L 7 -7 M -1 -7 h8 v8",
+  off: "M -7 -7 L 7 7 M 7 -1 v8 h-8",
+  pool: "M -9 -5 a9 3.5 0 1 0 18 0 a9 3.5 0 1 0 -18 0 M -9 -5 v10 a9 3.5 0 0 0 18 0 v-10 M -9 0 a9 3.5 0 0 0 18 0",
+  db: "M -9 -5 a9 3.5 0 1 0 18 0 a9 3.5 0 1 0 -18 0 M -9 -5 v10 a9 3.5 0 0 0 18 0 v-10 M -9 0 a9 3.5 0 0 0 18 0",
+  exe: "M -5 -8 L 7 0 L -5 8 Z",
+  idx: "M -9 -7 h18 M -9 -2 h18 M -9 3 h18 M -9 8 h11",
+  sign: "M -9 4 c 3 -9 5 -9 6 0 s 3 7 6 -2 s 3 -6 6 0",
+  env: "M -8 -5.5 h16 v11 h-16 z M -8 -5.5 l8 6 l8 -6",
+  lock: "M -5.5 -1 h11 v8 h-11 z M -3.5 -1 v-3 a3.5 3.5 0 0 1 7 0 v3",
+  check: "M -5 0 l3.5 3.5 l6.5 -7",
+  x: "M -5 -5 l10 10 M 5 -5 l-10 10",
+  chain: "M -1.5 4.5 l-2 2 a3.5 3.5 0 0 1 -5 -5 l3 -3 a3.5 3.5 0 0 1 5 0 M 1.5 -4.5 l2 -2 a3.5 3.5 0 0 1 5 5 l-3 3 a3.5 3.5 0 0 1 -5 0 M -2.5 2.5 l5 -5",
+  net: "M -1.3 -4.6 L -5.8 3 M 1.3 -4.6 L 5.8 3 M -4.3 5.5 H 4.3 M -2.2 -7 a 2.2 2.2 0 1 0 4.4 0 a 2.2 2.2 0 1 0 -4.4 0 M -9.2 5.5 a 2.2 2.2 0 1 0 4.4 0 a 2.2 2.2 0 1 0 -4.4 0 M 4.8 5.5 a 2.2 2.2 0 1 0 4.4 0 a 2.2 2.2 0 1 0 -4.4 0",
+  user: "M -4 -4.5 a4 4 0 1 0 8 0 a4 4 0 1 0 -8 0 M -8 9 c0 -5 3.6 -7.5 8 -7.5 s8 2.5 8 7.5",
+  server: "M -9 -8 h18 v7 h-18 z M -9 1 h18 v7 h-18 z M -5 -4.5 h0.01 M -5 4.5 h0.01",
+  key: "M -9 0 a3.5 3.5 0 1 0 7 0 a3.5 3.5 0 1 0 -7 0 M -2 0 h10 M 5 0 v3.5 M 8 0 v2.5",
+  shield: "M 0 -9 l8 3 v5 c0 5 -3.5 8 -8 10 c-4.5 -2 -8 -5 -8 -10 v-5 z",
+  globe: "M -9 0 a9 9 0 1 0 18 0 a9 9 0 1 0 -18 0 M -9 0 h18 M 0 -9 c-4.5 4 -4.5 14 0 18 M 0 -9 c4.5 4 4.5 14 0 18",
+  bolt: "M 2 -9 L -5 1 h5 l-2 8 l7 -10 h-5 z",
+  doc: "M -6 -9 h8 l5 5 v13 h-13 z M 2 -9 v5 h5 M -3 1 h7 M -3 5 h5",
+  box: "M -9 -4.5 l9 -4.5 l9 4.5 v9 l-9 4.5 l-9 -4.5 z M -9 -4.5 l9 4.5 l9 -4.5 M 0 0 v9",
+  truck: "M -10 -6 h11 v10 h-11 z M 1 -2 h5 l3.5 3.5 v2.5 h-8.5 M -7.5 6.5 a1.8 1.8 0 1 0 3.6 0 a1.8 1.8 0 1 0 -3.6 0 M 3 6.5 a1.8 1.8 0 1 0 3.6 0 a1.8 1.8 0 1 0 -3.6 0",
+  card: "M -9 -6.5 h18 a2 2 0 0 1 2 2 v9 a2 2 0 0 1 -2 2 h-18 a2 2 0 0 1 -2 -2 v-9 a2 2 0 0 1 2 -2 z M -11 -2 h22 M -7 3 h5",
+  cart: "M -10 -8 h3 l3 11 h11 l2.5 -8 h-15.5 M -4.5 7.5 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0 M 5 7.5 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0",
+  clock: "M -9 0 a9 9 0 1 0 18 0 a9 9 0 1 0 -18 0 M 0 -5 v5 l3.5 2.5",
+  branch: "M -4 -4.5 v9 M 5 0.5 c0 4 -9 3 -9 6.5 M -6.2 -7 a2.2 2.2 0 1 0 4.4 0 a2.2 2.2 0 1 0 -4.4 0 M -6.2 7 a2.2 2.2 0 1 0 4.4 0 a2.2 2.2 0 1 0 -4.4 0 M 2.8 -2 a2.2 2.2 0 1 0 4.4 0 a2.2 2.2 0 1 0 -4.4 0",
+  cloud: "M -7 6 h13 a4.5 4.5 0 0 0 0.5 -9 a6 6 0 0 0 -11.5 -1 a4.5 4.5 0 0 0 -2 10 z",
+  refresh: "M 7 -3 a7.5 7.5 0 1 0 0.5 5 M 7.5 -8 v5 h-5",
+  layers: "M 0 -8 l9 4.5 l-9 4.5 l-9 -4.5 z M -9 2.5 l9 4.5 l9 -4.5",
+  code: "M -4 -6 l-5 6 l5 6 M 4 -6 l5 6 l-5 6",
+  paint: "M -8 8 c 0 -3 2 -5 4.5 -5 l 9 -9 l 3.5 3.5 l -9 9 c 0 2.5 -2 4.5 -5 4.5 z",
+  block: "M -9 -7 h18 a2 2 0 0 1 2 2 v10 a2 2 0 0 1 -2 2 h-18 a2 2 0 0 1 -2 -2 v-10 a2 2 0 0 1 2 -2 z M -11 -2.5 h22 M -6 2.5 h8"
+};
+
+// src/render/parts.ts
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var r1 = (v) => Math.round(v * 100) / 100;
+var cs = (k) => k === "coin" ? "--c:var(--coin);--ct:var(--coint)" : `--c:var(--c-${k});--ct:var(--t-${k})`;
+function glyph(name, x, y, scale, cls = "dg-gl") {
+  const d = name === void 0 ? void 0 : ICONS[name];
+  return d ? `<path class="${cls}" transform="translate(${r1(x)} ${r1(y)}) scale(${scale})" d="${d}"/>` : "";
+}
+var pathOf = (points) => points.map(([x, y], i) => `${i === 0 ? "M" : "L"} ${r1(x)} ${r1(y)}`).join(" ");
+function arrowHead(points) {
+  const [ex, ey] = points[points.length - 1];
+  const [px, py] = points[points.length - 2];
+  const len = Math.hypot(ex - px, ey - py) || 1;
+  const dx = (ex - px) / len;
+  const dy = (ey - py) / len;
+  const { arrow: a, arrowHalf: h } = LOOK.edge;
+  return `M ${r1(ex - dx * a - dy * h)} ${r1(ey - dy * a + dx * h)} L ${r1(ex)} ${r1(ey)} L ${r1(ex - dx * a + dy * h)} ${r1(ey - dy * a - dx * h)}`;
+}
+function rangeKf(m, ranges2) {
+  const pts = [[0, { opacity: 0 }]];
+  for (const [a, b] of ranges2) pts.push([a, { opacity: 0 }, EASE.out], [a + MOTION.fade, { opacity: 1 }], [b - 0.1, { opacity: 1 }, EASE.inOut], [b + 0.25, { opacity: 0 }]);
+  pts.push([m.total, { opacity: 0 }]);
+  return m.kf(pts);
+}
+function activeKf(ctx, on) {
+  const ranges2 = [];
+  for (let k = 0; k < on.length; ) {
+    let e = k;
+    while (e + 1 < on.length && on[e + 1] === on[e] + 1) e++;
+    ranges2.push([ctx.t.steps[on[k]].start, ctx.t.steps[on[e]].end]);
+    k = e + 1;
+  }
+  return rangeKf(ctx.m, ranges2);
+}
+function band(region) {
+  const { radius, icon, iconRadius, iconScale, nameY, line } = LOOK.region;
+  const { x, y } = region.header;
+  const lines = region.lines.map((t, k) => `<text class="dg-bz" x="${r1(x)}" y="${r1(region.y + nameY + k * line)}">${esc(t)}</text>`).join("");
+  const note = region.note ? `<text class="dg-bx" x="${r1(x)}" y="${r1(region.y + nameY + region.lines.length * line + 1)}">${esc(region.note)}</text>` : "";
+  const mark = region.icon && ICONS[region.icon] ? `<rect class="dg-bi" x="${r1(x)}" y="${r1(y)}" width="${icon}" height="${icon}" rx="${iconRadius}"/>${glyph(region.icon, x + icon / 2, y + icon / 2, iconScale)}` : "";
+  return `<g style="${cs(region.color)}"><rect class="dg-band" x="${r1(region.x + 0.5)}" y="${r1(region.y + 0.5)}" width="${r1(region.w - 1)}" height="${r1(region.h - 1)}" rx="${radius}"/>${mark}${lines}${note}</g>`;
+}
+function card(box, ctx, on, changes) {
+  const { m, sh } = ctx;
+  const { radius, icon, iconRadius, iconScale, iconY, nameY, subY } = LOOK.box;
+  const seq = [[0, box.sub ?? "", "dg-ss"], ...changes];
+  const subs = seq.map(([t, text2, cls], k) => {
+    const next = seq[k + 1]?.[0];
+    const anim = k === 0 ? next === void 0 ? "" : m.until(next - MOTION.untilFade) : next === void 0 ? m.rise(t) : m.rise(t, next - MOTION.untilFade);
+    if (text2 === "") return "";
+    return `<g${anim ? ` class="dg-a" style="${anim}"` : ""}><text class="${cls}" x="${r1(box.cx)}" y="${r1(box.cy + subY)}" text-anchor="middle">${esc(text2)}</text></g>`;
+  }).join("");
+  const act = on.length > 0 ? activeKf(ctx, on) : void 0;
+  const rect = (cls, extra = "") => `<rect class="${cls}" x="${r1(box.x)}" y="${r1(box.y)}" width="${r1(box.w)}" height="${box.h}" rx="${radius}"${extra}/>`;
+  const mark = box.icon && ICONS[box.icon] ? `<rect class="dg-ic" x="${r1(box.cx - icon / 2)}" y="${r1(box.cy + iconY - icon / 2)}" width="${icon}" height="${icon}" rx="${iconRadius}"/>${glyph(box.icon, box.cx, box.cy + iconY, iconScale)}` : "";
+  return `<g style="${cs(box.color)}">${act ? `<g class="dg-a" style="${act}">${rect("dg-halo")}</g>` : ""}${rect("dg-st", ` ${sh}`)}${act ? `<g class="dg-a" style="${act}">${rect("dg-on")}</g>` : ""}${mark}<text class="dg-sn" x="${r1(box.cx)}" y="${r1(box.cy + nameY)}" text-anchor="middle">${esc(box.name)}</text>${subs}</g>`;
+}
+function lifeline(x, y1, y2) {
+  return `<line class="dg-ll" x1="${r1(x)}" y1="${r1(y1)}" x2="${r1(x)}" y2="${r1(y2)}"/>`;
+}
+function edge(e, time, ctx) {
+  const { m } = ctx;
+  const d = pathOf(e.points);
+  const head = arrowHead(e.points);
+  const { start: a, drawn: b, end } = time;
+  const tail = [
+    [end, { opacity: 1 }, EASE.inOut],
+    [end + 0.4, { opacity: 0.45 }],
+    [ctx.end + 0.3, { opacity: 0.45 }, EASE.inOut],
+    [ctx.end + 1, { opacity: 0.95 }],
+    [m.last, { opacity: 0.95 }, EASE.inOut],
+    [m.total, { opacity: 0 }]
+  ];
+  const line = m.kf([
+    [0, { opacity: 0, "stroke-dashoffset": 1 }],
+    [a, { opacity: 0, "stroke-dashoffset": 1 }, EASE.inOut],
+    [a + 0.05, { opacity: 1 }],
+    [b, { "stroke-dashoffset": 0 }],
+    [m.last, { "stroke-dashoffset": 0 }],
+    [m.total, { "stroke-dashoffset": 1 }],
+    ...tail
+  ]);
+  const hk = m.kf([[0, { opacity: 0 }], [b - 0.05, { opacity: 0 }], [b, { opacity: 1 }], ...tail]);
+  const run = -(end - b) * 26;
+  const flow = m.kf([
+    [0, { opacity: 0, "stroke-dashoffset": 0 }],
+    [b, { opacity: 0, "stroke-dashoffset": 0 }],
+    [b + 0.25, { opacity: 0.9 }],
+    [end - 0.1, { opacity: 0.9 }, EASE.inOut],
+    [end + 0.2, { opacity: 0, "stroke-dashoffset": run }],
+    [m.total, { opacity: 0, "stroke-dashoffset": run }]
+  ]);
+  return {
+    base: `<path class="dg-e" d="${d}"/><path class="dg-eh" d="${head}"/>`,
+    lit: `<g style="${cs(e.color)}"><path class="dg-e-on dg-a" pathLength="1" d="${d}" style="${line}"/><path class="dg-eh-on dg-a" d="${head}" style="${hk}"/><path class="dg-flow dg-a" d="${d}" style="${flow}"/></g>`
+  };
+}
+function label(l, time, ctx) {
+  const ja2 = l.family === "sans" ? " dg-capj" : "";
+  const { radius } = LOOK.label;
+  return `<g class="dg-cap${ja2} dg-a" style="${cs(l.color)};${ctx.m.rise(time.start, time.end, true)}"><rect x="${r1(l.x)}" y="${r1(l.y)}" width="${r1(l.w)}" height="${l.h}" rx="${radius}"/><text x="${r1(l.x + l.w / 2)}" y="${r1(l.y + l.h / 2 + LOOK.baseline.label)}" text-anchor="middle">${esc(l.text)}</text></g>`;
+}
+function action(a, at2, until, ctx) {
+  return `<g class="dg-act dg-a" style="${cs(a.color)};${ctx.m.rise(at2, until, true)}"><rect x="${r1(a.x)}" y="${r1(a.y)}" width="${r1(a.w)}" height="${a.h}" rx="${LOOK.action.radius}"/><text x="${r1(a.x + a.w / 2)}" y="${r1(a.y + a.h / 2 + LOOK.baseline.action)}" text-anchor="middle">${esc(a.text)}</text></g>`;
+}
+function carrierShape(e, sh) {
+  const C = LOOK.carrier;
+  if (e.carry.kind === "coin") return `<circle class="dg-coin" r="${C.coinR}"/><circle class="dg-coin-in" r="${C.coinIn}"/>`;
+  if (e.carry.kind === "tag") {
+    const text2 = e.carry.text;
+    const ja2 = hasWide(text2);
+    const w = textWidth(text2, ja2 ? TYPE.carrierJa : TYPE.carrier) + C.tagPadX * 2;
+    return `<rect class="dg-car" x="${r1(-w / 2)}" y="${ -18 / 2}" width="${r1(w)}" height="${C.tagH}" rx="${C.tagH / 2}" ${sh}/><text class="dg-car-t${ja2 ? " dg-car-tj" : ""}" y="${LOOK.baseline.carrier}" text-anchor="middle">${esc(text2)}</text>`;
+  }
+  return `<rect class="dg-env" x="${ -24 / 2}" y="${ -17 / 2}" width="${C.envW}" height="${C.envH}" rx="3" ${sh}/><path class="dg-env-in" d="M -8 -4.5 L 0 1.5 L 8 -4.5"/>`;
+}
+var easeInOut = (t) => t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
+function carrier(e, time, ctx) {
+  const { m } = ctx;
+  const n = LOOK.carrier.samples;
+  const length = pathLength(e.points);
+  const { depart: a, arrive: b, start: from, end: gone } = time;
+  const path = [];
+  for (let k = 0; k <= n; k++) {
+    const [x, y] = along(e.points, easeInOut(k / n) * length);
+    path.push([a + (b - a) * k / n, x, y]);
+  }
+  const first = path[0];
+  const lastPoint = path[path.length - 1];
+  const rest = e.settle ?? [lastPoint[1], lastPoint[2]];
+  const pts = [[0, first[1], first[2]], ...path];
+  if (e.settle) pts.push([Math.min(b + 0.3, Math.max(gone, b + 0.01)), rest[0], rest[1]]);
+  pts.push([gone, rest[0], rest[1]], [m.total, rest[0], rest[1]]);
+  const fade = gone < m.last ? 0.05 : 0.18;
+  return `<g class="dg-a" style="${m.move(pts, m.blink(from + 0.02, gone, fade))}">${carrierShape(e, ctx.sh)}</g>`;
+}
+function badge(b, ctx) {
+  const { m } = ctx;
+  const span = ctx.t.steps[b.step];
+  const a = span.start;
+  const e = span.end;
+  const { r, ring: rr } = LOOK.badge;
+  const fill = m.kf([
+    [0, { opacity: 0, transform: "scale(.5)" }],
+    [a, { opacity: 0, transform: "scale(.5)" }, EASE.pop],
+    [a + 0.35, { opacity: 1, transform: "scale(1)" }],
+    [e, { opacity: 1, transform: "scale(1)" }, EASE.inOut],
+    [e + 0.4, { opacity: 0, transform: "scale(1)" }],
+    [m.total, { opacity: 0, transform: "scale(.5)" }]
+  ]);
+  const past = m.kf([[0, { opacity: 0 }], [e, { opacity: 0 }, EASE.inOut], [e + 0.4, { opacity: 1 }], [m.last, { opacity: 1 }, EASE.inOut], [m.total, { opacity: 0 }]]);
+  const ring = m.kf([
+    [0, { opacity: 0, transform: "scale(1)" }],
+    [a + 0.05, { opacity: 0, transform: "scale(1)" }],
+    [a + 0.1, { opacity: 0.7, transform: "scale(1)" }, EASE.out],
+    [a + 0.9, { opacity: 0, transform: "scale(2.3)" }],
+    [m.total, { opacity: 0, transform: "scale(1)" }]
+  ]);
+  const x = r1(b.x);
+  const y = r1(b.y);
+  const ty = r1(b.y + LOOK.baseline.badge);
+  const no = b.step + 1;
+  return `<g class="dg-bd" data-step="${b.step}" style="${cs(b.color)}"><circle class="dg-bdr dg-popc dg-a" cx="${x}" cy="${y}" r="${rr}" style="${ring}"/><g class="dg-a" style="${past}"><circle class="dg-bdp" cx="${x}" cy="${y}" r="${rr}"/><text class="dg-bdpt" x="${x}" y="${ty}" text-anchor="middle">${no}</text></g><g class="dg-popc dg-a" style="${fill}"><circle class="dg-bdf" cx="${x}" cy="${y}" r="${r}"/><text class="dg-bdft" x="${x}" y="${ty}" text-anchor="middle">${no}</text></g></g>`;
+}
+function strip(s, changes, ctx) {
+  const { m, sh } = ctx;
+  const S2 = LOOK.strip;
+  const my = s.y + S2.h / 2;
+  const parts = [
+    `<rect class="dg-strip" x="${r1(s.x + 0.5)}" y="${r1(s.y + 0.5)}" width="${r1(s.w - 1)}" height="${r1(s.h - 1)}" rx="${LOOK.region.radius}" ${sh}/>`,
+    `<g style="${cs("slate")}"><rect class="dg-bi" x="${r1(s.x + S2.pad)}" y="${r1(my - S2.icon / 2)}" width="${S2.icon}" height="${S2.icon}" rx="${LOOK.box.iconRadius}"/>${glyph("env", s.x + S2.pad + S2.icon / 2, my, 0.78)}</g>`,
+    `<text class="dg-sh" x="${r1(s.x + S2.titleX)}" y="${r1(my + LOOK.baseline.stripTitle)}">${esc(s.title)}</text>`
+  ];
+  s.fields.forEach((field, i) => {
+    const prev = s.fields[i - 1];
+    if (prev && prev.y === field.y) {
+      const sx = field.x - S2.fieldGap / 2;
+      parts.push(`<line class="dg-sep" x1="${r1(sx)}" y1="${r1(field.y + S2.sepInset)}" x2="${r1(sx)}" y2="${r1(field.y + S2.h - S2.sepInset)}"/>`);
+    }
+    parts.push(`<text class="dg-fl" x="${r1(field.x)}" y="${r1(field.y + S2.nameY)}">${esc(field.name)}</text>`);
+    const list = changes.get(field.name) ?? [];
+    const values = list.filter((c) => c.value !== void 0);
+    const tags = list.filter((c) => c.tag !== void 0);
+    values.forEach((c, k) => {
+      const next = values[k + 1]?.at;
+      const value = c.value;
+      const anim = next === void 0 ? m.rise(c.at) : m.rise(c.at, next - MOTION.untilFade);
+      parts.push(`<g class="dg-a" style="${anim}"><text class="${hasWide(value) ? "dg-fvj" : "dg-fv"}" x="${r1(field.x)}" y="${r1(field.y + S2.valueY)}">${esc(value)}</text></g>`);
+    });
+    tags.forEach((c, k) => {
+      const next = tags[k + 1]?.at;
+      const tag = c.tag;
+      const shown = [...values].reverse().find((v) => v.at <= c.at + 1e-9)?.value;
+      const x = field.x + (shown ? textWidth(shown, hasWide(shown) ? TYPE.fieldValueJa : TYPE.fieldValue) + S2.tagGap : 0);
+      const w = textWidth(tag, TYPE.tag) + S2.tagPadX * 2;
+      const y = field.y + S2.valueY - S2.tagH / 2 - LOOK.baseline.tag;
+      parts.push(
+        `<g class="dg-tg dg-popc dg-a" style="${cs(c.color)};${next === void 0 ? m.pop(c.at) : m.pop(c.at, next - MOTION.untilFade)}"><rect x="${r1(x)}" y="${r1(y)}" width="${r1(w)}" height="${S2.tagH}" rx="${S2.tagH / 2}"/><text x="${r1(x + w / 2)}" y="${r1(y + S2.tagH / 2 + LOOK.baseline.tag)}" text-anchor="middle">${esc(tag)}</text></g>`
+      );
+    });
+  });
+  return parts.join("");
+}
+
+// src/render/motion.ts
+var r2 = (v) => Math.round(v * 100) / 100;
+var Motion = class {
+  constructor(prefix, total, last) {
+    this.prefix = prefix;
+    this.total = total;
+    this.last = last;
+  }
+  prefix;
+  total;
+  last;
+  frames = [];
+  count = 0;
+  pct(t) {
+    return +(Math.min(Math.max(t, 0), this.total) / this.total * 100).toFixed(3);
+  }
+  /** keyframes を 1 つ足し、その名前を付ける style の字を返す。 */
+  kf(points) {
+    const name = `${this.prefix}-${this.count++}`;
+    const at2 = /* @__PURE__ */ new Map();
+    for (const [t, props, ease] of [...points].sort((a, b) => a[0] - b[0])) {
+      const p = this.pct(t);
+      const cur = at2.get(p) ?? { props: {} };
+      Object.assign(cur.props, props);
+      if (ease) cur.ease = ease;
+      at2.set(p, cur);
+    }
+    const body = [...at2].map(([p, { props, ease }]) => {
+      const d = Object.entries(props).map(([k, v]) => `${k}:${v}`);
+      if (ease) d.push(`animation-timing-function:${ease}`);
+      return `${p}%{${d.join(";")}}`;
+    }).join("");
+    this.frames.push(`@keyframes ${name}{${body}}`);
+    return `animation-name:${name}`;
+  }
+  /** `a` で出て `b` から消える。`within` を立てると `b` までに消え終わる。 */
+  vis(a, b = this.last, o = {}) {
+    const f = o.f ?? MOTION.fade;
+    const on = o.on ?? {};
+    const off = o.off ?? {};
+    const out = o.within ? Math.max(a + f, b - f) : b;
+    return this.kf([
+      [0, { opacity: 0, ...off }],
+      [a, { opacity: 0, ...off }, o.ein ?? EASE.out],
+      [a + f, { opacity: 1, ...on }],
+      [out, { opacity: 1, ...on }, EASE.inOut],
+      [Math.min(out + f, this.total), { opacity: 0, ...off }],
+      [this.total, { opacity: 0, ...off }]
+    ]);
+  }
+  /** 少し下から浮いて出る。 */
+  rise(a, b = this.last, within = false) {
+    return this.vis(a, b, { on: { transform: "translateY(0)" }, off: { transform: `translateY(${LOOK.rise}px)` }, within });
+  }
+  /** 小さな所から弾んで出る。 */
+  pop(a, b = this.last) {
+    return this.vis(a, b, { f: MOTION.popFade, ein: EASE.pop, on: { transform: "scale(1)" }, off: { transform: `scale(${LOOK.popFrom})` } });
+  }
+  /** 初めから出ていて `b` で消える。 */
+  until(b) {
+    const f = MOTION.untilFade;
+    return this.kf([
+      [0, { opacity: 1 }],
+      [b, { opacity: 1 }, EASE.inOut],
+      [b + f, { opacity: 0 }],
+      [this.last, { opacity: 0 }],
+      [this.total, { opacity: 1 }]
+    ]);
+  }
+  /** 点を辿って動く。`[時刻, x, y, 大きさ, 次の点までの緩急]` の並び。 */
+  move(points, extra = []) {
+    return this.kf(
+      points.map(([t, x, y, s = 1, ease]) => [t, { transform: `translate(${r2(x)}px,${r2(y)}px) scale(${s})` }, ease]).concat(extra)
+    );
+  }
+  /** `a` から `b` まで見え、`fade` 秒で消える。 */
+  blink(a, b, fade) {
+    return [
+      [0, { opacity: 0 }],
+      [a - 0.01, { opacity: 0 }],
+      [a, { opacity: 1 }],
+      [b, { opacity: 1 }],
+      [b + fade, { opacity: 0 }],
+      [this.total, { opacity: 0 }]
+    ];
+  }
+};
+
+// src/render/svg.ts
+var font = (t) => `font:${t.weight} ${t.size}px var(--${t.family})`;
+var mix = (pct, base = "var(--surf)") => `color-mix(in srgb,var(--c) ${pct}%,${base})`;
+var S = LOOK.stroke;
+var X = LOOK.mix;
+var PART_CSS = [
+  ".dg{display:block;width:100%;height:auto;overflow:visible}",
+  ".dg .dg-a{animation-duration:var(--T);animation-timing-function:linear;animation-iteration-count:infinite;animation-fill-mode:both;animation-delay:calc(var(--at,0) * -1s);animation-play-state:var(--play,running)}",
+  ".dg .dg-popc{transform-box:fill-box;transform-origin:center}",
+  ".dg-bg{fill:var(--bg)}",
+  ".dg-band{fill:color-mix(in srgb,var(--c) var(--tint),var(--bg));stroke:color-mix(in srgb,var(--c) var(--edge),transparent)}",
+  `.dg-bi{fill:${mix(X.regionIcon)};stroke:${mix(X.regionIconEdge, "transparent")}}`,
+  `.dg-bz{${font(TYPE.regionName)};fill:var(--ct)}`,
+  `.dg-bx{${font(TYPE.regionNote)};fill:var(--mute)}`,
+  ".dg-st{fill:var(--surf);stroke:var(--hair)}",
+  `.dg-halo{fill:none;stroke:var(--c);stroke-width:${S.halo};stroke-opacity:.16}`,
+  `.dg-on{fill:none;stroke:var(--c);stroke-width:${S.on}}`,
+  `.dg-ic{fill:${mix(X.icon)}}`,
+  `.dg-gl{fill:none;stroke:var(--c);stroke-width:${S.glyph};stroke-linecap:round;stroke-linejoin:round}`,
+  `.dg-sn{${font(TYPE.boxName)};fill:var(--ink)}`,
+  `.dg-ss{${font(TYPE.boxSub)};fill:var(--mute)}`,
+  `.dg-ss-ok{${font(TYPE.boxSubStrong)};fill:var(--ct)}`,
+  `.dg-ss-act{${font(TYPE.boxSubStrong)};fill:var(--ink)}`,
+  `.dg-ll{stroke:var(--line);stroke-width:${S.lifeline};stroke-dasharray:3 4}`,
+  `.dg-e{fill:none;stroke:var(--line);stroke-width:${S.edge};stroke-linecap:round;stroke-dasharray:0 ${LOOK.edge.ghostDash}}`,
+  `.dg-eh{fill:none;stroke:var(--line);stroke-width:${S.arrow};stroke-linecap:round;stroke-linejoin:round}`,
+  `.dg-e-on{fill:none;stroke:var(--c);stroke-width:${S.edgeOn};stroke-linecap:round;stroke-dasharray:1 2}`,
+  `.dg-eh-on{fill:none;stroke:var(--c);stroke-width:${S.edgeOn};stroke-linecap:round;stroke-linejoin:round}`,
+  `.dg-flow{fill:none;stroke:var(--surf);stroke-width:${S.flow};stroke-linecap:round;stroke-dasharray:1.5 ${LOOK.edge.flowDash}}`,
+  ".dg-bd{cursor:pointer}",
+  ".dg-bdf{fill:var(--c)}",
+  `.dg-bdft{${font(TYPE.badge)};fill:var(--on-c)}`,
+  `.dg-bdr{fill:none;stroke:var(--c);stroke-width:${S.badgeRing}}`,
+  `.dg-bdp{fill:${mix(X.badgePast)};stroke:${mix(X.badgePastEdge, "transparent")};stroke-width:${S.hair}}`,
+  `.dg-bdpt{${font(TYPE.badge)};fill:var(--ct)}`,
+  `.dg-cap rect,.dg-act rect{fill:${mix(X.cap)};stroke:${mix(X.capEdge, "transparent")}}`,
+  `.dg-cap text{${font(TYPE.label)};fill:var(--ct)}`,
+  `.dg-capj text{${font(TYPE.labelJa)}}`,
+  `.dg-act text{${font(TYPE.action)};fill:var(--ct)}`,
+  ".dg-car{fill:var(--carry,var(--ink))}",
+  `.dg-car-t{${font(TYPE.carrier)};fill:var(--bg)}`,
+  `.dg-car-tj{${font(TYPE.carrierJa)}}`,
+  `.dg-env{fill:var(--carry,var(--ink));stroke:var(--surf);stroke-width:${S.envelope}}`,
+  `.dg-env-in{fill:none;stroke:var(--surf);stroke-width:${S.flow};stroke-linejoin:round;stroke-linecap:round}`,
+  ".dg-coin{fill:var(--coin);stroke:var(--surf);stroke-width:1.2}",
+  ".dg-coin-in{fill:none;stroke:var(--coinin);stroke-width:1.1}",
+  ".dg-strip{fill:var(--surf);stroke:var(--hair)}",
+  `.dg-sep{stroke:var(--hair);stroke-width:${S.hair}}`,
+  `.dg-sh{${font(TYPE.stripTitle)};fill:var(--ink)}`,
+  `.dg-fl{${font(TYPE.fieldName)};fill:var(--mute)}`,
+  `.dg-fv{${font(TYPE.fieldValue)};fill:var(--ink)}`,
+  `.dg-fvj{${font(TYPE.fieldValueJa)};fill:var(--ink)}`,
+  ".dg-tg rect{fill:var(--c)}",
+  `.dg-tg text{${font(TYPE.tag)};fill:var(--on-c)}`,
+  ".dg-vp-bg{fill:var(--bg)}",
+  ".dg-vp-frame{fill:none;stroke:var(--hair)}",
+  ".dg-mm-bg{fill:var(--surf);stroke:var(--hair)}",
+  `.dg-mm-t{${font(TYPE.miniTitle)};fill:var(--mute)}`,
+  ".dg-mm-world{fill:var(--sunk);stroke:var(--hair)}",
+  `.dg-mm-band{fill:${mix(X.miniBand)};stroke:${mix(X.miniBandEdge, "transparent")};stroke-width:.6}`,
+  `.dg-mm-card{fill:${mix(X.mini)}}`,
+  `.dg-mm-vp{fill:color-mix(in srgb,var(--ink) ${X.view}%,transparent);stroke:var(--ink);stroke-width:${S.badgeRing};vector-effect:non-scaling-stroke}`
+].join("");
+function nameOf(text2) {
+  let h = 2166136261;
+  for (let i = 0; i < text2.length; i++) {
+    h ^= text2.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
+}
+function involved(diagram) {
+  const on = /* @__PURE__ */ new Map();
+  const add = (id, s) => {
+    on.set(id, (on.get(id) ?? /* @__PURE__ */ new Set()).add(s));
+  };
+  diagram.steps.forEach((step, s) => {
+    for (const event of step.events) {
+      if (event.type === "edge") {
+        add(event.from, s);
+        add(event.to, s);
+      } else if (event.type === "action" || event.type === "swap") add(event.box, s);
+    }
+  });
+  return new Map([...on].map(([id, steps]) => [id, [...steps].sort((a, b) => a - b)]));
+}
+function subChanges(diagram, timeline, actionsInBox) {
+  const raw = [];
+  let order = 0;
+  for (const time of timeline.events) {
+    const event = diagram.steps[time.step]?.events[time.event];
+    if (event?.type === "swap") raw.push({ t: time.at, order: order++, box: event.box, set: event.text });
+    if (actionsInBox && event?.type === "action") {
+      raw.push({ t: time.at, order: order++, box: event.box, act: event.label });
+      raw.push({ t: timeline.steps[time.step].end, order: order++, box: event.box, act: null });
+    }
+  }
+  raw.sort((a, b) => a.t - b.t || a.order - b.order);
+  const out = /* @__PURE__ */ new Map();
+  for (const box of diagram.boxes) {
+    let base = [box.sub ?? "", "dg-ss"];
+    let acting;
+    let shown = base.join("|");
+    const list = [];
+    for (const change of raw.filter((r) => r.box === box.id)) {
+      if (change.set !== void 0) {
+        base = [change.set, "dg-ss-ok"];
+        acting = void 0;
+      }
+      if (change.act !== void 0) acting = change.act ?? void 0;
+      const now = acting !== void 0 ? [acting, "dg-ss-act"] : base;
+      if (now.join("|") === shown) continue;
+      shown = now.join("|");
+      list.push([change.t, now[0], now[1]]);
+    }
+    const kept = list.filter((change, k) => {
+      const next = list[k + 1];
+      return next === void 0 || next[0] - change[0] >= MOTION.minShow;
+    });
+    out.set(box.id, kept);
+  }
+  return out;
+}
+function fieldChanges(diagram, timeline, layout) {
+  const out = /* @__PURE__ */ new Map();
+  for (const time of timeline.events) {
+    const event = diagram.steps[time.step]?.events[time.event];
+    if (event?.type !== "strip") continue;
+    const color = layout.badges[time.step]?.color ?? "slate";
+    const list = out.get(event.field) ?? [];
+    list.push({ at: time.at, color, ...event.value !== void 0 ? { value: event.value } : {}, ...event.tag !== void 0 ? { tag: event.tag } : {} });
+    out.set(event.field, list);
+  }
+  return out;
+}
+function drawSvg(diagram, layout, timeline, palette, theme, follow) {
+  const id = nameOf(`${JSON.stringify(diagram)}|${palette.id}|${theme}|${follow ? `${follow.width}|${follow.lang}` : ""}`);
+  const m = new Motion(`dg${id}`, timeline.total, timeline.last);
+  const ctx = { m, t: timeline, sh: `filter="url(#dg-sh-${id})"`, end: timeline.steps[timeline.steps.length - 1].end };
+  const on = involved(diagram);
+  const subs = subChanges(diagram, timeline, layout.kind === "architecture");
+  const L = { band: [], base: [], lit: [], node: [], badge: [], top: [] };
+  for (const region of layout.regions) L.band.push(band(region));
+  if (layout.strip) L.band.push(strip(layout.strip, fieldChanges(diagram, timeline, layout), ctx));
+  for (const line of layout.lifelines) L.base.push(lifeline(line.x, line.y1, line.y2));
+  for (const e of layout.edges) {
+    const time = timeline.edges.find((t) => t.step === e.step && t.event === e.event);
+    if (!time) continue;
+    const drawn = edge(e, time, ctx);
+    L.base.push(drawn.base);
+    L.lit.push(drawn.lit);
+  }
+  for (const box of layout.boxes) L.node.push(card(box, ctx, on.get(box.id) ?? [], subs.get(box.id) ?? []));
+  for (const b of layout.badges) L.badge.push(badge(b, ctx));
+  for (const l of layout.labels) {
+    const time = timeline.labels.find((t) => t.step === l.step && t.event === l.event);
+    if (time) L.top.push(label(l, time, ctx));
+  }
+  for (const a of layout.actions) {
+    const time = timeline.events.find((t) => t.step === a.step && t.event === a.event);
+    if (time) L.top.push(action(a, time.at, timeline.steps[a.step].end, ctx));
+  }
+  for (const time of timeline.carriers) {
+    const e = layout.edges.find((x) => x.step === time.step && x.event === time.event);
+    if (e) L.top.push(carrier(e, time, ctx));
+  }
+  const content = Object.values(L).map((parts) => parts.join("")).join("");
+  const { near, far, nearY, farY } = LOOK.shadow;
+  const shadow = `<filter id="dg-sh-${id}" x="-20%" y="-30%" width="140%" height="180%"><feDropShadow dx="0" dy="${nearY}" stdDeviation="${near}" style="flood-color:var(--sh);flood-opacity:var(--shA)"/><feDropShadow dx="0" dy="${farY}" stdDeviation="${far}" style="flood-color:var(--sh);flood-opacity:var(--shB)"/></filter>`;
+  const view = follow ? followView(layout, timeline, diagram, m, id, content, follow) : { body: `<rect class="dg-bg" width="${layout.width}" height="${layout.height}" rx="${LOOK.region.radius}"/>${content}`, w: layout.width, h: layout.height };
+  const css = `.dg-${id}{${FONT_VARS};--T:${timeline.total}s;${paletteVars(palette, theme)}}${PART_CSS}${m.frames.join("")}`;
+  return `<svg xmlns="http://www.w3.org/2000/svg" class="dg dg-${id}" viewBox="0 0 ${Math.ceil(view.w)} ${Math.ceil(view.h)}" width="${Math.ceil(view.w)}" height="${Math.ceil(view.h)}" role="img" aria-label="${esc(diagram.title)}" data-dragon="figure" data-view="${follow ? "follow" : "fixed"}"><style>${css}</style><defs>${shadow}</defs>${view.body}</svg>`;
+}
+function focusOf(layout, diagram, step) {
+  const rects = [];
+  for (const e of layout.edges.filter((x2) => x2.step === step)) {
+    const xs = e.points.map((p) => p[0]);
+    const ys = e.points.map((p) => p[1]);
+    rects.push({ x: Math.min(...xs), y: Math.min(...ys), w: Math.max(...xs) - Math.min(...xs), h: Math.max(...ys) - Math.min(...ys) });
+  }
+  rects.push(...layout.labels.filter((l) => l.step === step), ...layout.actions.filter((a) => a.step === step));
+  for (const event of diagram.steps[step]?.events ?? []) {
+    const ids = event.type === "edge" ? [event.from, event.to] : event.type === "action" || event.type === "swap" ? [event.box] : [];
+    for (const id of ids) {
+      const box = layout.boxes.find((b) => b.id === id);
+      if (box && (layout.kind === "architecture" || event.type === "swap")) rects.push(box);
+    }
+  }
+  if (rects.length === 0) return void 0;
+  const x = Math.min(...rects.map((r) => r.x));
+  const y = Math.min(...rects.map((r) => r.y));
+  return { x, y, w: Math.max(...rects.map((r) => r.x + r.w)) - x, h: Math.max(...rects.map((r) => r.y + r.h)) - y };
+}
+function followView(layout, timeline, diagram, m, id, content, follow) {
+  const F = LOOK.follow;
+  const M = LOOK.mini;
+  const vw = Math.min(layout.width, Math.max(1, follow.width));
+  const vh = Math.min(layout.height, Math.max(F.minH, vw * F.aspect));
+  const clampX = (x) => Math.min(layout.width - vw / 2, Math.max(vw / 2, x));
+  const clampY = (y) => Math.min(layout.height - vh / 2, Math.max(vh / 2, y));
+  let prev = [layout.width / 2, layout.height / 2];
+  const centers = timeline.steps.map((_, s) => {
+    const f = focusOf(layout, diagram, s);
+    prev = f ? [f.x + f.w / 2, f.y + f.h / 2] : prev;
+    return [clampX(prev[0]), clampY(prev[1])];
+  });
+  const c0 = centers[0];
+  const cam = [
+    [0, c0[0], c0[1]],
+    [timeline.steps[0].start, c0[0], c0[1]]
+  ];
+  centers.forEach((c, s) => {
+    if (s === 0) return;
+    const before = centers[s - 1];
+    const start = timeline.steps[s].start;
+    cam.push([start, before[0], before[1], 1, EASE.inOut], [start + F.ease, c[0], c[1]]);
+  });
+  const cl = centers[centers.length - 1];
+  cam.push([timeline.last, cl[0], cl[1], 1, EASE.inOut], [timeline.total, c0[0], c0[1]]);
+  const camKf = m.move(cam.map(([t, cx, cy, s, e]) => [t, vw / 2 - cx, vh / 2 - cy, s, e]));
+  const mw = Math.min(M.w, vw * 0.4, vh * 0.4 / layout.height * layout.width);
+  const k = mw / layout.width;
+  const mh = layout.height * k;
+  const title = FIGURE_TEXT[follow.lang].overview;
+  const bw = Math.max(mw, Math.ceil(textWidth(title, TYPE.miniTitle)));
+  const bx = vw - bw - M.inset - M.pad;
+  const mx = bx + (bw - mw) / 2;
+  const my = M.inset + M.pad + M.title;
+  const shapes = [
+    ...layout.regions.map((r) => `<rect class="dg-mm-band" style="${cs(r.color)}" x="${mx + r.x * k}" y="${my + r.y * k}" width="${r.w * k}" height="${r.h * k}" rx="3"/>`),
+    ...layout.boxes.map((b) => `<rect class="dg-mm-card" style="${cs(b.color)}" x="${mx + b.x * k}" y="${my + b.y * k}" width="${b.w * k}" height="${b.h * k}" rx="1.5"/>`)
+  ].join("");
+  const vp = m.move(cam.map(([t, cx, cy, , e]) => [t, mx + (cx - vw / 2) * k, my + (cy - vh / 2) * k, 1, e]));
+  const mini = `<rect class="dg-mm-bg" x="${bx - M.pad}" y="${my - M.pad - M.title}" width="${bw + M.pad * 2}" height="${mh + M.pad * 2 + M.title}" rx="${M.radius}"/><text class="dg-mm-t" x="${bx}" y="${my - M.pad + 2}">${title}</text><g clip-path="url(#dg-mm-${id})"><rect class="dg-mm-world" x="${mx}" y="${my}" width="${mw}" height="${mh}"/>${shapes}<rect class="dg-mm-vp dg-a" width="${vw * k}" height="${vh * k}" rx="2" style="${vp}"/></g>`;
+  const body = `<defs><clipPath id="dg-vp-${id}"><rect width="${vw}" height="${vh}" rx="${LOOK.region.radius}"/></clipPath><clipPath id="dg-mm-${id}"><rect x="${mx}" y="${my}" width="${mw}" height="${mh}" rx="4"/></clipPath></defs><g clip-path="url(#dg-vp-${id})"><rect class="dg-vp-bg" width="${vw}" height="${vh}"/><g class="dg-a" style="${camKf}">${content}</g></g><rect class="dg-vp-frame" x="0.5" y="0.5" width="${vw - 1}" height="${vh - 1}" rx="${LOOK.region.radius}"/>${mini}`;
+  return { body, w: vw, h: vh };
+}
+function renderDiagram(input, options = {}) {
+  const lang = options.lang ?? "ja";
+  const read = readDiagram(input, { lang });
+  if (!read.ok) throw new Error(FIGURE_TEXT[lang].cannotDraw(read.errors.map((e) => `${e.pointer} ${e.message}`).join(" / ")));
+  const diagram = read.diagram;
+  const palette = resolvePalette(options.palette);
+  const theme = options.theme === "dark" ? "dark" : "light";
+  const layout = diagram.kind === "sequence" ? layoutSequence(diagram) : layoutArchitecture(diagram);
+  const timeline = buildTimeline(diagram);
+  return {
+    svg: drawSvg(diagram, layout, timeline, palette, theme),
+    palette: palette.id,
+    theme,
+    ...diagram.view ? { view: diagram.view } : {},
+    fonts: { ...FONTS },
+    layout,
+    timeline,
+    diagram
+  };
+}
+
+// src/view.ts
+function chooseView(rendered, frameWidth) {
+  const textPx = Math.max(0, frameWidth) / rendered.layout.width * TYPE.boxName.size;
+  if (rendered.view) return { mode: rendered.view, textPx };
+  return { mode: textPx >= READABLE_PX ? "fixed" : "follow", textPx };
+}
+
+// src/player.ts
+var BUTTON_TEXT = { prev: "\u2039", pause: "\u275A\u275A", play: "\u25B6", next: "\u203A" };
+var pad = (n) => String(n).padStart(2, "0");
+var stepNo = (step, count) => `${pad(step + 1)}/${pad(count)}`;
+var require_ = createRequire(import.meta.url);
+var SCRIPTS = {
+  "/mediabunny.js": join(dirname(require_.resolve("mediabunny")), "mediabunny.min.mjs"),
+  "/gifenc.js": require_.resolve("gifenc/dist/gifenc.esm.js")
+};
+var SCALE = 2;
+var INSTALL_ADD = "`pnpm add -D playwright-core`";
+var INSTALL_CHROMIUM = "`pnpm exec playwright-core install chromium`";
+var LAUNCH_TEXT = {
+  ja: {
+    missing: "\u66F8\u304D\u51FA\u3057\u306B\u306F playwright-core \u304C\u8981\u308B\u3002",
+    cannotLaunch: "Chromium \u3092\u8D77\u52D5\u3067\u304D\u306A\u3044\u3002",
+    install: `${INSTALL_ADD} \u3067\u5165\u308C\u3001${INSTALL_CHROMIUM} \u3067 Chromium \u3092\u5165\u308C\u308B`
+  },
+  en: {
+    missing: "Exporting needs playwright-core. ",
+    cannotLaunch: "Cannot launch Chromium. ",
+    install: `Install playwright-core with ${INSTALL_ADD} and Chromium with ${INSTALL_CHROMIUM}`
+  }
+};
+async function launch(lang) {
+  const text2 = LAUNCH_TEXT[lang];
+  let chromium;
+  try {
+    ({ chromium } = await import('playwright-core'));
+  } catch {
+    throw new Error(`${text2.missing}${text2.install}`);
+  }
+  try {
+    return await chromium.launch();
+  } catch (error) {
+    throw new Error(`${text2.cannotLaunch}${text2.install} (${String(error).split("\n")[0]})`);
+  }
+}
+function sizeOf(svg) {
+  const [, width = "0", height = "0"] = /^<svg\b[^>]*?\swidth="(\d+)"\s+height="(\d+)"/.exec(svg) ?? [];
+  return { width: Number(width), height: Number(height) };
+}
+async function stage(browser, svg, fontCss, body) {
+  const { width, height } = sizeOf(svg);
+  const page = await browser.newPage({ viewport: { width, height }, deviceScaleFactor: SCALE });
+  const paused = svg.replace(/^<svg\b/, '<svg style="--play:paused;--at:0"');
+  const html = `<!doctype html><html><head><meta charset="utf-8"><style>${fontCss}html,body{margin:0}body{${body}}svg{display:block}</style><script type="module">import * as mb from "/mediabunny.js";import * as gif from "/gifenc.js";window.__tools={mb,gif};</script></head><body>${paused}</body></html>`;
+  await page.route("http://localhost/**", async (route) => {
+    const path = new URL(route.request().url()).pathname;
+    if (path === "/") return route.fulfill({ contentType: "text/html; charset=utf-8", body: html });
+    const script = SCRIPTS[path];
+    return script ? route.fulfill({ contentType: "text/javascript", body: readFileSync(script) }) : route.fulfill({ status: 404 });
+  });
+  await page.goto("http://localhost/");
+  await page.waitForFunction(() => "__tools" in window);
+  await page.evaluate(async () => {
+    const loads = [];
+    document.fonts.forEach((face) => loads.push(face.load()));
+    await Promise.all(loads);
+    await document.fonts.ready;
+  });
+  return { page, width, height };
+}
+async function at(page, t) {
+  await page.evaluate(
+    (t2) => new Promise((done) => {
+      document.querySelector("svg")?.style.setProperty("--at", String(t2));
+      requestAnimationFrame(() => requestAnimationFrame(() => done()));
+    }),
+    t
+  );
+}
+async function still(stage2, t) {
+  await at(stage2.page, t);
+  return stage2.page.screenshot({ type: "png", omitBackground: true });
+}
+async function film(stage2, plan2) {
+  const { page, width, height } = stage2;
+  await page.evaluate(
+    async ({ width: width2, height: height2, scale, fps, mp4, gifEvery }) => {
+      const { mb, gif } = window.__tools;
+      let add = () => Promise.resolve();
+      let close = () => Promise.resolve(void 0);
+      if (mp4) {
+        const canvas = new OffscreenCanvas(width2 * scale, height2 * scale);
+        const context = canvas.getContext("2d");
+        const target = new mb.BufferTarget();
+        const output = new mb.Output({ format: new mb.Mp4OutputFormat({ fastStart: "in-memory" }), target });
+        const source = new mb.CanvasSource(canvas, { codec: "avc", bitrate: mb.QUALITY_MEDIUM, keyFrameInterval: 2 });
+        output.addVideoTrack(source, { frameRate: fps });
+        await output.start();
+        add = async (bitmap, i) => {
+          context.drawImage(bitmap, 0, 0);
+          await source.add(i / fps, 1 / fps);
+        };
+        close = async () => {
+          await output.finalize();
+          return new Uint8Array(target.buffer);
+        };
+      }
+      const small = new OffscreenCanvas(width2, height2);
+      const smallContext = small.getContext("2d", { willReadFrequently: true });
+      const decode = (png) => createImageBitmap(new Blob([Uint8Array.from(atob(png), (c) => c.charCodeAt(0))], { type: "image/png" }));
+      const read = (bitmap) => {
+        smallContext.drawImage(bitmap, 0, 0, width2, height2);
+        return smallContext.getImageData(0, 0, width2, height2).data;
+      };
+      const encoder = gifEvery ? gif.GIFEncoder() : void 0;
+      const delay = gifEvery / fps * 1e3;
+      const sampled = [];
+      let colors = [];
+      const nearest = /* @__PURE__ */ new Map();
+      const toIndex = (data) => {
+        const index = new Uint8Array(data.length / 4);
+        for (let p = 0; p < index.length; p++) {
+          const i = p * 4;
+          const key = data[i] << 16 | data[i + 1] << 8 | data[i + 2];
+          let k = nearest.get(key);
+          if (k === void 0) {
+            k = gif.nearestColorIndex(colors, [data[i], data[i + 1], data[i + 2]]);
+            nearest.set(key, k);
+          }
+          index[p] = k;
+        }
+        return index;
+      };
+      let previous;
+      const writeGif = (data) => {
+        const clear = colors.length;
+        const index = toIndex(data);
+        const before = previous;
+        previous = data;
+        if (!before) {
+          encoder.writeFrame(index, width2, height2, { palette: [...colors, [0, 0, 0]], delay, dispose: 1 });
+          return;
+        }
+        let changed = 0;
+        for (let p = 0; p < index.length; p++) {
+          const i = p * 4;
+          if (data[i] === before[i] && data[i + 1] === before[i + 1] && data[i + 2] === before[i + 2]) index[p] = clear;
+          else changed++;
+        }
+        if (!changed) encoder.writeFrame(new Uint8Array([clear]), 1, 1, { transparent: true, transparentIndex: clear, delay, dispose: 1 });
+        else encoder.writeFrame(index, width2, height2, { transparent: true, transparentIndex: clear, delay, dispose: 1 });
+      };
+      const base64 = (bytes) => {
+        let text2 = "";
+        for (let i = 0; i < bytes.length; i += 32768) text2 += String.fromCharCode(...bytes.subarray(i, i + 32768));
+        return btoa(text2);
+      };
+      const box = {
+        async sample(png) {
+          const bitmap = await decode(png);
+          sampled.push(read(bitmap));
+          bitmap.close();
+        },
+        seal() {
+          const all = new Uint8ClampedArray(sampled.reduce((n, data) => n + data.length, 0));
+          let offset = 0;
+          for (const data of sampled) {
+            all.set(data, offset);
+            offset += data.length;
+          }
+          colors = gif.quantize(all, 255);
+        },
+        async push(png, i) {
+          const bitmap = await decode(png);
+          await add(bitmap, i);
+          if (gifEvery && i % gifEvery === 0) writeGif(read(bitmap));
+          bitmap.close();
+        },
+        async finish() {
+          const video = await close();
+          if (encoder) encoder.finish();
+          return { ...video ? { mp4: base64(video) } : {}, ...encoder ? { gif: base64(encoder.bytes()) } : {} };
+        }
+      };
+      window.__film = box;
+    },
+    { width, height, scale: SCALE, fps: plan2.fps, mp4: plan2.mp4, gifEvery: plan2.gifEvery }
+  );
+  const cdp = await page.context().newCDPSession(page);
+  const clip = { x: 0, y: 0, width, height, scale: SCALE };
+  const shoot = async (t) => {
+    await at(page, t);
+    return (await cdp.send("Page.captureScreenshot", { format: "png", optimizeForSpeed: true, clip })).data;
+  };
+  if (plan2.gifEvery) {
+    for (const t of plan2.samples) {
+      const png = await shoot(t);
+      await page.evaluate((png2) => window.__film.sample(png2), png);
+    }
+    await page.evaluate(() => window.__film.seal());
+  }
+  const frames = Math.round(plan2.total * plan2.fps);
+  for (let i = 0; i < frames; i++) {
+    const png = await shoot(i / plan2.fps);
+    await page.evaluate(([png2, i2]) => window.__film.push(png2, i2), [png, i]);
+  }
+  const out = await page.evaluate(() => window.__film.finish());
+  return {
+    frames,
+    ...out.mp4 ? { mp4: Buffer.from(out.mp4, "base64") } : {},
+    ...out.gif ? { gif: Buffer.from(out.gif, "base64") } : {}
+  };
+}
+var require_2 = createRequire(import.meta.url);
+var subsetFont = require_2("subset-font");
+var PACKAGES = [
+  { family: FONTS.sans, name: "noto-sans-jp" },
+  { family: FONTS.mono, name: "jetbrains-mono" }
+];
+var weights = Object.values(TYPE).map((style) => style.weight);
+var WEIGHT = { min: Math.min(...weights), max: Math.max(...weights) };
+function ranges(list) {
+  return list.split(",").map((part) => {
+    const [from = "", to = from] = part.trim().replace(/^U\+/i, "").split("-");
+    return [parseInt(from, 16), parseInt(to, 16)];
+  });
+}
+var hex = (code) => `U+${code.toString(16).toUpperCase()}`;
+function charsOf(texts) {
+  return [.../* @__PURE__ */ new Set([...texts.join("")])].filter((char) => char !== "\n" && char !== "\r" && char !== "	").sort();
+}
+async function fontFaces(chars) {
+  const faces = await Promise.all(
+    PACKAGES.flatMap(({ family, name }) => {
+      const base = dirname(require_2.resolve(`@fontsource-variable/${name}/unicode.json`));
+      const table = JSON.parse(readFileSync(join(base, "unicode.json"), "utf8"));
+      return Object.entries(table).map(async ([key, list]) => {
+        const span = ranges(list);
+        const own = chars.filter((char) => {
+          const code = char.codePointAt(0) ?? -1;
+          return span.some(([from, to]) => code >= from && code <= to);
+        });
+        if (!own.length) return "";
+        const file = join(base, "files", `${name}-${key.replace(/[[\]]/g, "")}-wght-normal.woff2`);
+        const woff2 = await subsetFont(await readFile(file), own.join(""), { targetFormat: "woff2", variationAxes: { wght: WEIGHT } });
+        const unicode = own.map((char) => hex(char.codePointAt(0) ?? 0)).join(",");
+        return `@font-face{font-family:"${family}";font-style:normal;font-display:block;font-weight:${WEIGHT.min} ${WEIGHT.max};src:url(data:font/woff2;base64,${woff2.toString("base64")}) format("woff2");unicode-range:${unicode}}`;
+      });
+    })
+  );
+  return faces.join("");
+}
+var PLAYER = new URL("./player.global.js", import.meta.url);
+function pageHtml(diagram, look, fontCss) {
+  const json = JSON.stringify(diagram).replace(/</g, "\\u003c");
+  const options = JSON.stringify({ palette: look.palette, theme: look.theme, lang: look.lang });
+  return [
+    "<!doctype html>",
+    `<html lang="${look.lang}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">`,
+    `<title>${esc(diagram.title)}</title>`,
+    `<style>${fontCss}:root{${look.vars}}html,body{margin:0}body{background:var(--bg)}</style>`,
+    '</head><body><div id="dragon"></div>',
+    `<script type="application/json" id="dragon-diagram">${json}</script>`,
+    `<script>${readFileSync(PLAYER, "utf8").replace(/<\/script/gi, "<\\/script")}</script>`,
+    `<script>DragonPlayer.mountDiagram(document.getElementById("dragon"),JSON.parse(document.getElementById("dragon-diagram").textContent),${options});</script>`,
+    "</body></html>"
+  ].join("\n");
+}
+
+// src/export/index.ts
+var FORMATS = ["mp4", "gif", "html", "png"];
+var DEFAULTS = { fps: 30, gifFps: 10, followWidth: 728 };
+var unescape = (s) => s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&");
+var svgTexts = (svg) => [...svg.matchAll(/<text\b[^>]*>([\s\S]*?)<\/text>/g)].map((m) => unescape((m[1] ?? "").replace(/<[^>]+>/g, "")));
+function drawnTexts(rendered, followSvg) {
+  const { diagram } = rendered;
+  const svgs = followSvg === void 0 ? [rendered.svg] : [rendered.svg, followSvg];
+  const count = diagram.steps.length;
+  return [...svgs.flatMap(svgTexts), ...diagram.steps.flatMap((step, s) => [step.title, step.body, stepNo(s, count)]), ...Object.values(BUTTON_TEXT)];
+}
+async function exportDiagram(input, options) {
+  const formats = options.formats ?? FORMATS;
+  const lang = options.lang ?? "ja";
+  const rendered = renderDiagram(input, {
+    ...options.palette ? { palette: options.palette } : {},
+    ...options.theme ? { theme: options.theme } : {},
+    lang
+  });
+  const { diagram, layout, timeline, theme } = rendered;
+  const palette = resolvePalette(rendered.palette);
+  const vars = paletteVars(palette, theme);
+  const width = options.width ?? (rendered.view === "follow" ? DEFAULTS.followWidth : layout.width);
+  const view = chooseView(rendered, width).mode;
+  const followSvg = rendered.view === "fixed" ? void 0 : drawSvg(diagram, layout, timeline, palette, theme, { width, lang });
+  const videoSvg = view === "follow" && followSvg ? followSvg : rendered.svg;
+  const fontCss = await fontFaces(charsOf(drawnTexts(rendered, followSvg)));
+  const outputs = [];
+  if (formats.includes("html")) outputs.push(["html", pageHtml(diagram, { palette: palette.id, theme, vars, lang }, fontCss)]);
+  let frames = 0;
+  const mp4 = formats.includes("mp4");
+  const gif = formats.includes("gif");
+  if (mp4 || gif || formats.includes("png")) {
+    const browser = await launch(lang);
+    try {
+      if (formats.includes("png")) {
+        const fixed = await stage(browser, rendered.svg, fontCss, "");
+        outputs.push(["png", await still(fixed, timeline.stills[timeline.stills.length - 1] ?? 0)]);
+      }
+      if (mp4 || gif) {
+        const fps = mp4 ? options.fps ?? DEFAULTS.fps : options.gifFps ?? DEFAULTS.gifFps;
+        const gifEvery = gif ? Math.max(1, Math.round(fps / (options.gifFps ?? DEFAULTS.gifFps))) : 0;
+        const shot = await film(await stage(browser, videoSvg, fontCss, `${vars};background:var(--bg)`), {
+          total: timeline.total,
+          fps,
+          mp4,
+          gifEvery,
+          // GIF の色の表は、最初の絵と段ごとの止め絵から作る
+          samples: [0, ...timeline.stills]
+        });
+        frames = shot.frames;
+        if (shot.mp4) outputs.push(["mp4", shot.mp4]);
+        if (shot.gif) outputs.push(["gif", shot.gif]);
+      }
+    } finally {
+      await browser.close();
+    }
+  }
+  const files = writeOutputs(options.outDir, options.name ?? "diagram", outputs);
+  return { files, view, frames, ...sizeOf(videoSvg) };
+}
+function writeOutputs(outDir, name, outputs) {
+  const created = mkdirSync(outDir, { recursive: true });
+  const files = {};
+  try {
+    for (const [format, data] of outputs) {
+      const path = join(outDir, `${name}.${format}`);
+      writeFileSync(path, data);
+      files[format] = path;
+    }
+  } catch (error) {
+    if (created !== void 0) rmSync(created, { recursive: true, force: true });
+    throw error;
+  }
+  return files;
+}
+
+export { FORMATS, exportDiagram };
+//# sourceMappingURL=export.js.map
+//# sourceMappingURL=export.js.map