@cardenelabs/dragon 0.30.0 → 0.32.0

package/src/json-parser.ts

@@ -24,6 +24,7 @@ import {
   EDGE_HEAD_VALUES,
   NODE_KIND_VALID,
   PRESET_TYPES,
+  TYPE_ALIASES,
   STYLE_VALID,
   resolveNodeKind,
   resolveTone,
@@ -36,15 +37,67 @@ import {
   EVENT_KINDS,
   EVENT_TARGET_KEYS,
   EVENT_REQUIRED_KEYS,
+  CHART_LINE_DASH_VALUES,
+  CHART_LINE_MARKER_VALUES,
+  CHART_PIE_TABLE_COLUMN_VALUES,
+  CHART_PIE_RING_WIDTH_VALUES,
+  CHART_STACKED_LEGEND_POSITION_VALUES,
+  CHART_WAFFLE_LEGEND_POSITION_VALUES,
+  FUNNEL_FORM_VALUES,
+  FUNNEL_RATE_VALUES,
+  QUADRANT_POINT_LABEL_SIDE_VALUES,
+  TREE_NODE_FORM_VALUES,
+  TREE_EDGE_TONE_VALUES,
+  TREE_EDGE_HEAD_VALUES,
+  MIND_FORM_VALUES,
+  JOURNEY_FORM_VALUES,
+  JOURNEY_LINE_FORM_VALUES,
+  JOURNEY_OPPORTUNITY_POSITION_VALUES,
+  JOURNEY_LABEL_KEYS,
+  CORNER_FORM_VALUES,
+  CHART_BAR_SHAPE_VALUES,
+  QUADRANT_LABEL_POSITION_VALUES,
+  LABEL_COLLISION_VALUES,
+  GANTT_TASK_LABEL_ALIGN_VALUES,
+  CDL_ICON_VALUES,
+  KIND_FORM_VALUES,
+  TITLE_ALIGN_VALUES,
+  LEGEND_LINE_STYLE_VALUES,
+  LEGEND_NOTE_ALIGN_VALUES,
+  ROW_MARK_FORM_VALUES,
+  ROW_MARK_TONE_VALUES,
+  ROW_DIVIDER_FORM_VALUES,
+  ROW_WELL_KEYS,
+  SEQUENCE_ACTOR_FORM_VALUES,
+  SEQUENCE_LABEL_FORM_VALUES,
+  SEQUENCE_RETURN_HEAD_VALUES,
+  SEQUENCE_KIND_LABEL_KEYS,
+  SEQUENCE_SELF_LOOP_KEYS,
   type 図形の定義,
 } from "./v05/parser";
-// 図の配色 (#1553)。 記法の読み手と同じ解決を通す = 別名 (`生成り` / `青磁`) の受け方が
+// 図の意匠 (#1553 / #2790)。 記法の読み手と同じ解決を通す = 別名の受け方が
 // 記法と JSON でずれない
-import { resolvePalette } from "./keywords";
-import type { DslPalette } from "./keywords";
+import {
+  PHASE_BODY_KEYS,
+  DIAGRAM_SHAPES,
+  THEMES,
+  THEME_ALIAS,
+  resolveOrder,
+  resolveDiagramShape,
+  shapesForDiagramType,
+  resolveTheme,
+  resolveLegendMark,
+} from "./keywords";
+// 区画の語の表 (#2667)。 記法と同じ表から直す = 同じ区画を 2 通りで呼ばない
+import { 区画 } from "./compile/word-state";
+// 行頭の印の古い語の読み替え (#2782)。 記法と同じ表を通す = JSON だけ古い語が印を持たない
+// 形にならない
+import { 行頭の語へ読み替える } from "./compile/row-marks";
+import type { DslDiagramShape, DslShape } from "./keywords";
 import type { CompileToCdlOpts } from "./compile";
 import type {
   CdlDiagram,
+  CdlLegendItem,
   NodeKind,
   Tone,
   EdgeStyle,
@@ -58,6 +111,8 @@ import type {
 import { extractIdentifiers, parseFormula } from "@cardenelabs/cdl";
 import type {
   DslDocument,
+  DslStageHeader,
+  DslRegions,
   DslActor,
   DslStep,
   DslAnimate,
@@ -83,18 +138,93 @@ import {
   type RelativePos,
 } from "./relative-pos";
 
+/** 古い綴りで書いた図種 (#2655 / #2657)。 受ける値は `TYPE_ALIASES` が SSOT */
+type 図種の別名 = "solidity" | DslShape;
+
 /**
  * LLM 向け JSON DSL の入力 shape。 YAML DSL と 1:1 対応、 top-level は flat な object。
  */
 export interface DragonJson {
   /** 図の title (必須) */
   title: string;
-  /** preset type (必須): sequence / flow / swimlane / er / state / topology / solidity / gantt / class / pie / c4 / mind */
-  type: PresetType;
+  /**
+   * preset type (必須)。 受け付ける値は `PRESET_TYPES` と `TYPE_ALIASES` が SSOT。
+   *
+   * 別名 (#2655 / #2657) は読み取りで図種と語の 2 つに開く = `solidity` と書いた JSON は
+   * 順序図 + 種類で並べ替え、`pie` と書いた JSON は 数を描く図 + 円の形 として読まれる。
+   */
+  type: PresetType | 図種の別名;
+  /** 円グラフの見せ方。 */
+  form?: string;
+  /** `form` の和名。両方あれば `form` を採る。 */
+  見せ方?: string;
+  /** ガントチャートの目盛り。 */
+  ticks?: string[];
+  /** `ticks` の和名。両方あれば `ticks` を採る。 */
+  目盛り?: string[];
+  /** ガントチャートの今日の線の位置と札。 */
+  ganttToday?: { index: number; label: string };
+  /** 工程の端とは独立した目盛り名。 */
+  ganttTickLabels?: string[];
+  ganttBarEnd?: "position";
+  ganttBarThickness?: "thin";
+  chartSeriesSkipMuted?: DslDocument["chartSeriesSkipMuted"];
+  chartLineSeries?: DslDocument["chartLineSeries"];
+  chartPieCenterLabel?: DslDocument["chartPieCenterLabel"];
+  chartPieTableColumns?: DslDocument["chartPieTableColumns"];
+  chartPieRingWidth?: DslDocument["chartPieRingWidth"];
+  chartSlopePeriods?: DslDocument["chartSlopePeriods"];
+  chartSlopeEmphasisIds?: DslDocument["chartSlopeEmphasisIds"];
+  chartSlopeUnit?: DslDocument["chartSlopeUnit"];
+  chartStackedPeriods?: DslDocument["chartStackedPeriods"];
+  chartStackedRateId?: DslDocument["chartStackedRateId"];
+  chartStackedLegendPosition?: DslDocument["chartStackedLegendPosition"];
+  chartGaugeValue?: DslDocument["chartGaugeValue"];
+  chartWaffleLegendPosition?: DslDocument["chartWaffleLegendPosition"];
+  funnelForm?: DslDocument["funnelForm"];
+  funnelRate?: DslDocument["funnelRate"];
+  quadrantPointLabelSide?: DslDocument["quadrantPointLabelSide"];
+  treeNodeForm?: DslDocument["treeNodeForm"];
+  treeSize?: DslDocument["treeSize"];
+  treeEdgeTone?: DslDocument["treeEdgeTone"];
+  treeEdgeHead?: DslDocument["treeEdgeHead"];
+  mindForm?: DslDocument["mindForm"];
+  mindSize?: DslDocument["mindSize"];
+  edgeEndGap?: DslDocument["edgeEndGap"];
+  journeyForm?: DslDocument["journeyForm"];
+  journeyLineForm?: DslDocument["journeyLineForm"];
+  journeyLabels?: DslDocument["journeyLabels"];
+  journeySize?: DslDocument["journeySize"];
+  sequenceActorForm?: DslDocument["sequenceActorForm"];
+  sequenceLabelForm?: DslDocument["sequenceLabelForm"];
+  sequenceReturnHead?: DslDocument["sequenceReturnHead"];
+  sequenceKindLabels?: DslDocument["sequenceKindLabels"];
+  sequenceRowGap?: DslDocument["sequenceRowGap"];
+  sequenceGutter?: DslDocument["sequenceGutter"];
+  sequenceBandWidth?: DslDocument["sequenceBandWidth"];
+  sequenceSelfLoop?: DslDocument["sequenceSelfLoop"];
+  figureCard?: DslDocument["figureCard"];
+  figureSize?: DslDocument["figureSize"];
+  terminalDecoration?: DslDocument["terminalDecoration"];
+  cornerForm?: DslDocument["cornerForm"];
+  figureKindLabel?: DslDocument["figureKindLabel"];
+  figureInset?: DslDocument["figureInset"];
+  chartBarSize?: DslDocument["chartBarSize"];
+  chartBarShape?: DslDocument["chartBarShape"];
+  chartLineSize?: DslDocument["chartLineSize"];
+  chartPieSize?: DslDocument["chartPieSize"];
+  chartWaffleSize?: DslDocument["chartWaffleSize"];
+  chartSlopeLabelTemplate?: DslDocument["chartSlopeLabelTemplate"];
+  chartSlopeSize?: DslDocument["chartSlopeSize"];
+  chartStackedLayout?: DslDocument["chartStackedLayout"];
+  chartGaugeSize?: DslDocument["chartGaugeSize"];
+  ganttSize?: DslDocument["ganttSize"];
+  quadrantLabelPosition?: DslDocument["quadrantLabelPosition"];
+  quadrantSize?: DslDocument["quadrantSize"];
   /**
    * 図表の箱の上に出す小見出し (optional)。 記法の最上位 `eyebrow:` と同じ (#1247)。
    *
-   * 効くのは図全体を 1 箱にする図種 (`pie` / `bar` / `line` / `funnel` / `tree` / `journey` /
+   * 効くのは図全体を 1 箱にする図種 (`chart` / `funnel` / `tree` / `journey` /
    * `quadrant` / `mind` / `gantt`) だけ。 箱ごとに分かれる図種では相手が決まらないため、
    * 組み立て側が知らせを出す。 そちらは `actors[].eyebrow` に書く。
    */
@@ -108,6 +238,19 @@ export interface DragonJson {
    * 他の図種には軸が無いため、書かれていたら組み立て側が知らせる。
    */
   axes?: JsonAxes;
+  /**
+   * 2 軸で仕分ける図の区画の名前 (#2667)。 記法の `regions:` と同じ。
+   *
+   * 鍵は項目の欄と同じ 4 語 (`左上` / `右上` / `左下` / `右下`)。 別の言い方を足すと
+   * 同じ区画を 2 通りで呼ぶことになる。
+   */
+  regions?: JsonRegions;
+  /** 図の凡例の字の大きさ。 */
+  legendFontSize?: number;
+  legendOffset?: DslDocument["legendOffset"];
+  /** 段の箱で全意匠に共通して使う見出しの寸法。 */
+  stageHeader?: DslStageHeader;
+  stageLayout?: DslDocument["stageLayout"];
   /** 登場人物 (必須): 文字列 or { name, kind, ... } object */
   actors: (string | JsonActor)[];
   /** flow step 配列 (必須): { from, to, label, ... } */
@@ -184,6 +327,8 @@ export interface DragonJson {
       x?: number;
       width?: number;
       label?: string;
+      /** 路線図の担当の名札で、名前の下へ出す補足。 */
+      subtitle?: string;
       contain?: boolean;
       lifeline?: boolean;
       /**
@@ -209,16 +354,16 @@ export interface DragonJson {
   relations?: RelationFocus;
   /** 図の並ぶ向き (#1494)。 記法の最上位 `direction:` と同じ。 JSON は英語の語で書く */
   direction?: "vertical" | "horizontal";
-  /**
-   * 図の配色 (#1553)。 記法の最上位 `palette:` と同じ。
-   *
-   * 名前だけを図に載せる = cdl は色を持たず、値は `cdl-theme.css` が決める。
-   * ER 図とクラス図は書かなくても `kinari` (生成りに茶) になる。 どちらも箱の作りが同じ
-   * (行頭の印 + 左に名前 + 右に型) で、名前と型が離れて並ぶため、行を横に追う目印
-   * (行の縞) が要る。 縞の色は配色からしか来ないので、既定が無いと縞が箱の面と同じ色に
-   * 落ちて 1 本も出ない。 書き手が `palette:` を書いた時はそちらが勝つ。
-   */
-  palette?: DslPalette;
+  /** 箱を並べ替える軸 (#2655)。 記法の最上位 `order:` と同じ。 JSON は英語の語で書く */
+  order?: "kind";
+  /** 図種ごとに選ぶ形 (#2657 / #2797)。 記法の最上位 `shape:` と同じ */
+  shape?: DslDiagramShape;
+  /** 図の意匠 (#1553 / #2790)。 記法の最上位 `theme:` と同じ。 */
+  theme?: string;
+  /** `theme` の別名。 両方書いた時は `theme` を使う。 */
+  palette?: string;
+  /** 図の下へ置く凡例。 印は記法と同じ英語名または和名で書く。 */
+  legend?: CdlLegendItem[];
 }
 
 /**
@@ -276,6 +421,22 @@ export interface JsonActor {
    */
   kind?: NodeKind | (string & {});
   subtitle?: string;
+  kindForm?: "icon";
+  icon?: DslActor["icon"];
+  emptyRowsNote?: string;
+  titleAlign?: "center";
+  rowRules?: boolean;
+  rowStripe?: boolean;
+  rowLayout?: DslActor["rowLayout"];
+  rowDividerForm?: DslActor["rowDividerForm"];
+  rowWell?: DslActor["rowWell"];
+  rowMarkForm?: "tone";
+  nestIn?: string;
+  figureCard?: DslActor["figureCard"];
+  stationNamePosition?: "bottom";
+  subtitlePlacement?: "right";
+  titleFontSize?: number;
+  markGap?: number;
   eyebrow?: string;
   value?: string;
   /**
@@ -286,6 +447,8 @@ export interface JsonActor {
    */
   previous?: string;
   rows?: string[];
+  /** 段階ごとの箱で、この箱を入れる段階。 記法の `stage` / `段階` と同じ (#2797)。 */
+  stage?: string;
   lane?: string;
   stack?: number;
   initial?: boolean;
@@ -341,14 +504,22 @@ export interface JsonActor {
    * (記法側と同じ扱い)。
    */
   end?: string;
+  startLabel?: string;
+  milestone?: boolean;
+  emphasis?: "primary";
+  /** 四象限の座標 `[x, y]`。 */
+  at?: [number | string, number | string];
+  /** `at` の和名。両方あれば `at` を採る。 */
+  点の位置?: [number | string, number | string];
   /**
-   * 体験の道筋 (`type: journey`) で、その段階が起きる場所 (#1294)。 記法の `touchpoint:` と同じ。
+   * ユーザージャーニー (`type: journey`) で、その段階が起きる場所 (#1294)。 記法の `touchpoint:` と同じ。
    */
   touchpoint?: string;
   /**
-   * 体験の道筋 (`type: journey`) で、その段階の改善の余地 (#1294)。 記法の `opportunity:` と同じ。
+   * ユーザージャーニー (`type: journey`) で、その段階の改善の余地 (#1294)。 記法の `opportunity:` と同じ。
    */
   opportunity?: string;
+  opportunityPosition?: DslActor["opportunityPosition"];
   /**
    * 箱を置く絶対座標と大きさ (#1294)。 記法の `posX:` / `posY:` / `posW:` / `posH:` と同じ。
    *
@@ -377,13 +548,21 @@ export interface JsonActor {
    */
   phase?: boolean;
   /** 行頭の印 (#1466)。 行と対で読む。 語の意味は図の種類が決める */
-  marks?: string[];
+  marks?: Array<string | { mark: string; tone?: "primary" | "muted" }>;
 }
 
 /** 2 軸で仕分ける図の軸の名前 (#1294)。 記法の `axes:` と同じ形 */
 export interface JsonAxes {
-  x?: { left?: string; right?: string };
-  y?: { bottom?: string; top?: string };
+  x?: { left?: string; right?: string; label?: never; direction?: never } | { label: string; direction: true };
+  y?: { bottom?: string; top?: string; label?: never; direction?: never } | { label: string; direction: true };
+}
+
+/** 2 軸で仕分ける図の区画の名前 (#2667)。 記法の `regions:` と同じ形 */
+export interface JsonRegions {
+  左上?: string;
+  右上?: string;
+  左下?: string;
+  右下?: string;
 }
 
 export interface JsonStep {
@@ -393,6 +572,8 @@ export interface JsonStep {
   sub?: string;
   /** 矢印がどの辺から出るか (#1385)。 記法の `side:` と同じ */
   side?: "top" | "right" | "bottom" | "left";
+  fromSide?: "top" | "right" | "bottom" | "left";
+  toSide?: "top" | "right" | "bottom" | "left";
   /**
    * 矢印の先の形 (#1462)。 記法の `{ head: triangle }` と同じ。
    *
@@ -404,7 +585,7 @@ export interface JsonStep {
   tailHead?: EdgeHead;
   headFill?: EdgeHeadFill;
   tailHeadFill?: EdgeHeadFill;
-  /** クラス図の出どころ側の多重度 (#1771)。 記法の `{ tailSub: "1" }` と同じ */
+  /** UML 関係の出どころ側の多重度 (#1771 / #2783)。記法の `{ tailSub: "1" }` と同じ */
   tailSub?: string;
   /**
    * 辺の役目 (cdl#618)。 記法の `{ role: main }` と同じ。
@@ -414,7 +595,7 @@ export interface JsonStep {
   role?: "main";
   /** 名前の下地を敷くか (cdl#618)。 記法の `{ labelPlate: false }` と同じ。 既定は敷く */
   labelPlate?: boolean;
-  /** クラス図の関係の語 (#1466)。 書くと端の形 / 塗り / 線種がまとめて決まる */
+  /** record の UML 関係の語 (#1466 / #2783)。書くと端の形 / 塗り / 線種がまとめて決まる */
   relation?: ClassRelationType;
   /** 順序図の言づての種類 (#1466)。 `call` / `return` / `fire` */
   kind?: SequenceMessageKind;
@@ -436,6 +617,13 @@ export interface JsonStep {
   dashOffsetBind?: string;
   labelOffsetX?: number;
   labelOffsetY?: number;
+  posX1?: number;
+  posY1?: number;
+  posX2?: number;
+  posY2?: number;
+  waypoints?: DslStep["waypoints"];
+  labelCollision?: DslStep["labelCollision"];
+  labelSize?: DslStep["labelSize"];
   /** true で説明文を矢印の線の上に重ねる。 分岐図の条件ラベル用。 */
   overlay?: boolean;
   /**
@@ -459,6 +647,13 @@ export interface JsonPhase {
   focus?: string[];
   /** body 説明文 */
   body?: string;
+  /**
+   * 説明文の別名 (#2621)。 記法が `description:` を受けるので JSON でも受ける。
+   *
+   * **正の語は `body`**。 両方書いた段は `body` を採る = 正の語を優先すると決めておくと、
+   * 読み手が「どちらが効くのか」 を実装を読まずに判断できる。
+   */
+  description?: string;
   /** badge label */
   badge?: string;
   /**
@@ -523,6 +718,13 @@ const VALID_KIND_SET: ReadonlySet<string> = NODE_KIND_VALID;
  */
 const VALID_PRESETS: readonly PresetType[] = [...PRESET_TYPES];
 
+/**
+ * 受け付ける図種の別名 (#2655)。 **記法側と同じ表を使う** (`v05/parser.ts` の `TYPE_ALIASES`)。
+ *
+ * 写すと片方だけ古くなる。 図種の一覧を 1 か所に寄せたのと同じ理由。
+ */
+const VALID_ALIASES: readonly string[] = [...TYPE_ALIASES.keys()];
+
 /**
  * 受け付ける項目の一覧 (#1295)。 **知らない項目を誤りにする判定と、公開 schema との
  * 突き合わせが、どちらもここを見る**。
@@ -540,8 +742,70 @@ export const ACCEPTED_KEYS = {
   root: [
     "title",
     "type",
+    "form",
+    "見せ方",
+    "ticks",
+    "目盛り",
+    "ganttToday",
+    "ganttTickLabels",
+    "ganttBarEnd",
+    "ganttBarThickness",
+    "chartSeriesSkipMuted",
+    "chartLineSeries",
+    "chartPieCenterLabel",
+    "chartPieTableColumns",
+    "chartPieRingWidth",
+    "chartSlopePeriods",
+    "chartSlopeEmphasisIds",
+    "chartSlopeUnit",
+    "chartStackedPeriods",
+    "chartStackedRateId",
+    "chartStackedLegendPosition",
+    "chartGaugeValue",
+    "chartWaffleLegendPosition",
+    "funnelForm",
+    "funnelRate",
+    "quadrantPointLabelSide",
+    "treeNodeForm",
+    "treeSize",
+    "treeEdgeTone",
+    "treeEdgeHead",
+    "mindForm",
+    "mindSize",
+    "edgeEndGap",
+    "journeyForm",
+    "journeyLineForm",
+    "journeyLabels",
+    "journeySize",
+    "sequenceActorForm",
+    "sequenceLabelForm",
+    "sequenceReturnHead",
+    "sequenceKindLabels",
+    "sequenceRowGap",
+    "sequenceGutter",
+    "sequenceBandWidth",
+    "sequenceSelfLoop",
+    "figureCard",
+    "figureSize",
+    "terminalDecoration",
+    "cornerForm",
+    "figureKindLabel",
+    "figureInset",
+    "chartBarSize",
+    "chartBarShape",
+    "chartLineSize",
+    "chartPieSize",
+    "chartWaffleSize",
+    "chartSlopeLabelTemplate",
+    "chartSlopeSize",
+    "chartStackedLayout",
+    "chartGaugeSize",
+    "ganttSize",
+    "quadrantLabelPosition",
+    "quadrantSize",
     "eyebrow",
     "axes",
+    "regions",
     "actors",
     "flow",
     "states",
@@ -567,18 +831,45 @@ export const ACCEPTED_KEYS = {
     "relations",
     // 図の並ぶ向き (#1494)
     "direction",
-    // 図の配色 (#1553)
+    // 箱を並べ替える軸 (#2655)
+    "order",
+    // 数を描く図の形 (#2657)
+    "shape",
+    // 図の意匠とその別名 (#1553 / #2790)
+    "theme",
     "palette",
+    "legend",
+    "legendFontSize",
+    "legendOffset",
+    "stageHeader",
+    "stageLayout",
   ],
   actor: [
     "name",
     "kind",
     "subtitle",
+    "kindForm",
+    "icon",
+    "emptyRowsNote",
+    "titleAlign",
+    "rowRules",
+    "rowStripe",
+    "rowLayout",
+    "rowDividerForm",
+    "rowWell",
+    "rowMarkForm",
+    "nestIn",
+    "figureCard",
+    "stationNamePosition",
+    "subtitlePlacement",
+    "titleFontSize",
+    "markGap",
     "eyebrow",
     "value",
     // 前の時点の値 (#1450)。 内訳の変化を帯で示す図と、値 1 つを大きく示す図が読む
     "previous",
     "rows",
+    "stage",
     "lane",
     "stack",
     "initial",
@@ -587,8 +878,14 @@ export const ACCEPTED_KEYS = {
     "color",
     "owner",
     "end",
+    "startLabel",
+    "milestone",
+    "emphasis",
+    "at",
+    "点の位置",
     "touchpoint",
     "opportunity",
+    "opportunityPosition",
     "posX",
     "posY",
     "posW",
@@ -622,13 +919,15 @@ export const ACCEPTED_KEYS = {
     "sub",
     // 矢印がどの辺から出るか (#1385)
     "side",
+    "fromSide",
+    "toSide",
     // 矢印の先の形 (#1462)
     "head",
     // 端の印の残り 3 欄と、関係の語 / 言づての種類 (#1466)
     "tailHead",
     "headFill",
     "tailHeadFill",
-    // クラス図の出どころ側の多重度 (#1771)
+    // UML 関係の出どころ側の多重度 (#1771 / #2783)
     "tailSub",
     "relation",
     // 辺の役目と名前の下地 (cdl#618)
@@ -645,19 +944,29 @@ export const ACCEPTED_KEYS = {
     "dashOffsetBind",
     "labelOffsetX",
     "labelOffsetY",
+    "posX1",
+    "posY1",
+    "posX2",
+    "posY2",
+    "waypoints",
+    "labelCollision",
+    "labelSize",
     "overlay",
     "pos",
     // 部品の端で繋ぐ要素の id (#1979)
     "fromPartNode",
     "toPartNode",
   ],
-  phase: ["step", "duration", "focus", "body", "badge", "tween", "set", "draw", "drawRatio"],
-  viewport: ["width", "height", "scale", "laneWidth", "gap", "laneGap", "nodeGap", "labelMargin"],
-  lane: ["x", "width", "label", "contain", "lifeline", "pos"],
+  // 説明の語は `PHASE_BODY_KEYS` から導く (#2621)。 書き写すと記法の入口とずれる
+  phase: ["step", "duration", "focus", ...PHASE_BODY_KEYS, "badge", "tween", "set", "draw", "drawRatio"],
+  viewport: ["width", "height", "contentOffsetX", "scale", "laneWidth", "gap", "laneGap", "nodeGap", "labelMargin"],
+  lane: ["x", "width", "label", "subtitle", "contain", "lifeline", "pos"],
   group: ["label", "lanes"],
   axes: ["x", "y"],
-  axesX: ["left", "right"],
-  axesY: ["bottom", "top"],
+  axesX: ["left", "right", "label", "direction"],
+  axesY: ["bottom", "top", "label", "direction"],
+  // 区画を指す語は項目の欄と同じ 4 語 (#2667)
+  regions: ["左上", "右上", "左下", "右下"],
   layoutPos: ["x", "y"],
   // 位置を他の要素からの相対で書く指定 (#2039)。 間隔は書かなくてよい
   posRel: ["anchor", "dir", "gap"],
@@ -706,6 +1015,14 @@ export type 欄の型 =
   | "必須の向き"
   | "色か色番号"
   | "描くもの"
+  | "意匠"
+  | "図の形"
+  | "ガントの帯の終わり"
+  | "ガントの帯の厚み"
+  | "札の角"
+  | "四象限の区画名位置"
+  | "線札の衝突"
+  | "主役"
   | "必須の図種"
   | "object"
   | "並び"
@@ -716,8 +1033,70 @@ export const 欄の型表 = {
   root: {
     title: "必須の非空文字列",
     type: "必須の図種",
+    form: "非空の文字列",
+    見せ方: "非空の文字列",
+    ticks: "文字列の並び",
+    目盛り: "文字列の並び",
+    ganttToday: "object",
+    ganttTickLabels: "文字列の並び",
+    ganttBarEnd: "ガントの帯の終わり",
+    ganttBarThickness: "ガントの帯の厚み",
+    chartSeriesSkipMuted: "真偽",
+    chartLineSeries: "並び",
+    chartPieCenterLabel: "文字列",
+    chartPieTableColumns: "文字列",
+    chartPieRingWidth: "文字列",
+    chartSlopePeriods: "文字列の並び",
+    chartSlopeEmphasisIds: "文字列の並び",
+    chartSlopeUnit: "文字列",
+    chartStackedPeriods: "並び",
+    chartStackedRateId: "文字列",
+    chartStackedLegendPosition: "文字列",
+    chartGaugeValue: "object",
+    chartWaffleLegendPosition: "文字列",
+    funnelForm: "文字列",
+    funnelRate: "文字列",
+    quadrantPointLabelSide: "文字列",
+    treeNodeForm: "文字列",
+    treeSize: "object",
+    treeEdgeTone: "文字列",
+    treeEdgeHead: "文字列",
+    mindForm: "文字列",
+    mindSize: "object",
+    edgeEndGap: "数",
+    journeyForm: "文字列",
+    journeyLineForm: "文字列",
+    journeyLabels: "object",
+    journeySize: "object",
+    sequenceActorForm: "非空の文字列",
+    sequenceLabelForm: "非空の文字列",
+    sequenceReturnHead: "非空の文字列",
+    sequenceKindLabels: "object",
+    sequenceRowGap: "数",
+    sequenceGutter: "数",
+    sequenceBandWidth: "数",
+    sequenceSelfLoop: "object",
+    figureCard: "object",
+    figureSize: "object",
+    terminalDecoration: "object",
+    cornerForm: "札の角",
+    figureKindLabel: "object",
+    figureInset: "object",
+    chartBarSize: "object",
+    chartBarShape: "非空の文字列",
+    chartLineSize: "object",
+    chartPieSize: "object",
+    chartWaffleSize: "object",
+    chartSlopeLabelTemplate: "object",
+    chartSlopeSize: "object",
+    chartStackedLayout: "object",
+    chartGaugeSize: "object",
+    ganttSize: "object",
+    quadrantLabelPosition: "四象限の区画名位置",
+    quadrantSize: "object",
     eyebrow: "文字列",
     axes: "object",
+    regions: "object",
     actors: "必須の非空の並び",
     flow: "必須の並び",
     states: "object",
@@ -743,17 +1122,44 @@ export const 欄の型表 = {
     relations: "非空の文字列",
     // 図の並ぶ向き (#1494)
     direction: "非空の文字列",
-    // 図の配色 (#1553)
-    palette: "非空の文字列",
+    // 箱を並べ替える軸 (#2655)
+    order: "非空の文字列",
+    // 図種ごとの形 (#2657 / #2797)
+    shape: "図の形",
+    // 図の意匠とその別名 (#1553 / #2790)
+    theme: "意匠",
+    palette: "意匠",
+    legend: "並び",
+    legendFontSize: "数",
+    legendOffset: "object",
+    stageHeader: "object",
+    stageLayout: "object",
   },
   actor: {
     name: "必須の非空文字列",
     kind: "非空の文字列",
     subtitle: "文字列",
+    kindForm: "非空の文字列",
+    icon: "非空の文字列",
+    emptyRowsNote: "文字列",
+    titleAlign: "非空の文字列",
+    rowRules: "真偽",
+    rowStripe: "真偽",
+    rowLayout: "object",
+    rowDividerForm: "非空の文字列",
+    rowWell: "object",
+    rowMarkForm: "非空の文字列",
+    nestIn: "非空の文字列",
+    figureCard: "object",
+    stationNamePosition: "非空の文字列",
+    subtitlePlacement: "非空の文字列",
+    titleFontSize: "数",
+    markGap: "数",
     eyebrow: "文字列",
     value: "文字列",
     previous: "文字列",
     rows: "文字列の並び",
+    stage: "非空の文字列",
     lane: "文字列",
     stack: "数",
     initial: "真偽",
@@ -762,8 +1168,14 @@ export const 欄の型表 = {
     color: "色か色番号",
     owner: "文字列",
     end: "文字列",
+    startLabel: "文字列",
+    milestone: "真偽",
+    emphasis: "主役",
+    at: "並び",
+    点の位置: "並び",
     touchpoint: "文字列",
     opportunity: "文字列",
+    opportunityPosition: "文字列",
     posX: "数",
     posY: "数",
     posW: "数",
@@ -784,7 +1196,7 @@ export const 欄の型表 = {
     renderOffsetX: "数か文字列",
     renderOffsetY: "数か文字列",
     // 行頭の印 (#1466)
-    marks: "文字列の並び",
+    marks: "並び",
     // 相対で置く指定 (#2039)。 中身の形は `validateRelativePos` が見る
     posRel: "object",
     // 見本が持つ段を使うか (#2125)
@@ -797,12 +1209,14 @@ export const 欄の型表 = {
     sub: "文字列",
     // 矢印がどの辺から出るか (#1385)
     side: "辺",
+    fromSide: "辺",
+    toSide: "辺",
     head: "端の形",
     // 端の印の残り 3 欄と、関係の語 / 言づての種類 (#1466)
     tailHead: "端の形",
     headFill: "非空の文字列",
     tailHeadFill: "非空の文字列",
-    // クラス図の出どころ側の多重度 (#1771)
+    // UML 関係の出どころ側の多重度 (#1771 / #2783)
     tailSub: "文字列",
     relation: "非空の文字列",
     // 辺の役目と名前の下地 (cdl#618)
@@ -819,6 +1233,13 @@ export const 欄の型表 = {
     dashOffsetBind: "非空の文字列",
     labelOffsetX: "数",
     labelOffsetY: "数",
+    posX1: "数",
+    posY1: "数",
+    posX2: "数",
+    posY2: "数",
+    waypoints: "並び",
+    labelCollision: "線札の衝突",
+    labelSize: "object",
     overlay: "真偽",
     pos: "object",
     // 部品の端で繋ぐ要素の id (#1979)。 空の id は要素を指せないので受けない
@@ -829,7 +1250,9 @@ export const 欄の型表 = {
     step: "必須の非空文字列",
     duration: "数",
     focus: "文字列の並び",
+    // 説明は正の語と別名のどちらでも同じ型。 表の欄は `ACCEPTED_KEYS.phase` と揃える (#2621)
     body: "文字列",
+    description: "文字列",
     badge: "文字列",
     tween: "object",
     set: "object",
@@ -839,6 +1262,7 @@ export const 欄の型表 = {
   viewport: {
     width: "数",
     height: "数",
+    contentOffsetX: "数",
     scale: "数",
     laneWidth: "数",
     gap: "数",
@@ -850,14 +1274,16 @@ export const 欄の型表 = {
     x: "数",
     width: "数",
     label: "文字列",
+    subtitle: "文字列",
     contain: "真偽",
     lifeline: "真偽",
     pos: "object",
   },
   group: { label: "文字列", lanes: "文字列の並び" },
   axes: { x: "object", y: "object" },
-  axesX: { left: "文字列", right: "文字列" },
-  axesY: { bottom: "文字列", top: "文字列" },
+  axesX: { left: "文字列", right: "文字列", label: "文字列", direction: "真偽" },
+  axesY: { bottom: "文字列", top: "文字列", label: "文字列", direction: "真偽" },
+  regions: { 左上: "文字列", 右上: "文字列", 左下: "文字列", 右下: "文字列" },
   // 位置は書けば x と y の両方が要る。 片方だけでは寄せ幅が決まらない
   layoutPos: { x: "必須の数", y: "必須の数" },
   // 相対で置く指定 (#2039)。 相手と向きは必ず要り、間隔は書かなければ既定で置く
@@ -929,10 +1355,28 @@ export const 見本にしか効かない欄 = [
  */
 export const 見本に効かない欄 = [
   "tone",
+  "kindForm",
+  "icon",
+  "emptyRowsNote",
+  "titleAlign",
+  "rowRules",
+  "rowStripe",
+  "rowLayout",
+  "rowDividerForm",
+  "rowWell",
+  "rowMarkForm",
+  "nestIn",
+  "figureCard",
+  "at",
   "owner",
   "end",
+  "startLabel",
+  "milestone",
+  "emphasis",
   "touchpoint",
   "opportunity",
+  "opportunityPosition",
+  "stage",
   // 箱の中に描く図形 (#1374)。 見本は自分の形を持つため、外から図形を差し替えられない
   "shape",
   // その箱を出すかどうかの条件 (#1381)。 見本は自分の出方を持つ
@@ -1031,6 +1475,36 @@ function 値を検査(
       if (v === undefined) return;
       if (typeof v !== "boolean") 型違い("true or false if present");
       return;
+    case "ガントの帯の終わり":
+      if (v === undefined) return;
+      if (v !== "position") 型違い('"position" if present');
+      return;
+    case "ガントの帯の厚み":
+      if (v === undefined) return;
+      if (v !== "thin") 型違い('"thin" if present');
+      return;
+    case "札の角":
+      if (v === undefined) return;
+      if (!(CORNER_FORM_VALUES as readonly unknown[]).includes(v)) {
+        型違い(`one of: ${CORNER_FORM_VALUES.join(", ")}`);
+      }
+      return;
+    case "四象限の区画名位置":
+      if (v === undefined) return;
+      if (!(QUADRANT_LABEL_POSITION_VALUES as readonly unknown[]).includes(v)) {
+        型違い(`one of: ${QUADRANT_LABEL_POSITION_VALUES.join(", ")}`);
+      }
+      return;
+    case "線札の衝突":
+      if (v === undefined) return;
+      if (!(LABEL_COLLISION_VALUES as readonly unknown[]).includes(v)) {
+        型違い(`one of: ${LABEL_COLLISION_VALUES.join(", ")}`);
+      }
+      return;
+    case "主役":
+      if (v === undefined) return;
+      if (v !== "primary") 型違い('"primary" if present');
+      return;
     case "色":
       if (v === undefined) return;
       if (typeof v !== "string") {
@@ -1100,6 +1574,28 @@ function 値を検査(
         });
       }
       return;
+    case "意匠":
+      if (v === undefined) return;
+      if (typeof v !== "string" || resolveTheme(v) === null) {
+        errors.push({
+          path,
+          message: `${名前} must be one of: ${THEMES.join(", ")}`,
+          hint: `使える語 = ${Object.keys(THEME_ALIAS).join(" / ")} (got ${
+            typeof v === "string" ? JSON.stringify(v) : typeof v
+          })`,
+        });
+      }
+      return;
+    case "図の形":
+      if (v === undefined) return;
+      if (typeof v !== "string" || resolveDiagramShape(v) === null) {
+        errors.push({
+          path,
+          message: `${名前} must be one of: ${Object.values(DIAGRAM_SHAPES).flat().join(", ")}`,
+          hint: `使える語 = ${Object.values(DIAGRAM_SHAPES).flat().join(" / ")}`,
+        });
+      }
+      return;
     case "色か色番号":
       if (v === undefined) return;
       if (typeof v !== "string") {
@@ -1126,10 +1622,13 @@ function 値を検査(
       }
       return;
     case "必須の図種":
-      if (typeof v !== "string" || !VALID_PRESETS.includes(v as PresetType)) {
+      if (
+        typeof v !== "string" ||
+        !(VALID_PRESETS.includes(v as PresetType) || VALID_ALIASES.includes(v))
+      ) {
         errors.push({
           path,
-          message: `${名前} must be one of: ${VALID_PRESETS.join(", ")}`,
+          message: `${名前} must be one of: ${[...VALID_PRESETS, ...VALID_ALIASES].join(", ")}`,
           hint: typeof v === "string" ? `got "${v}"` : undefined,
         });
       }
@@ -1519,6 +2018,91 @@ function validateBands(v: unknown, errors: JsonDslError[]): void {
   });
 }
 
+const LEGEND_KEYS = ["mark", "text", "tone", "lineStyle", "align", "lead"] as const;
+const LEGEND_LINE_MARKS = ["line-triangle-hollow", "line-diamond-hollow", "line-diamond-solid"] as const;
+
+/** JSON の凡例を、外側の並びから各項目の必須値まで検査する。 */
+function validateLegend(v: unknown, errors: JsonDslError[]): void {
+  if (v === undefined) return;
+  if (!Array.isArray(v)) {
+    errors.push({ path: "$.legend", message: "legend must be an array" });
+    return;
+  }
+  v.forEach((item, index) => {
+    const path = `$.legend[${index}]`;
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      errors.push({ path, message: "legend item must be an object" });
+      return;
+    }
+    const o = item as Record<string, unknown>;
+    for (const key of Object.keys(o)) {
+      if ((LEGEND_KEYS as readonly string[]).includes(key)) continue;
+      errors.push({
+        path: `${path}.${key}`,
+        message: `unknown key "${key}"`,
+        hint: `使える項目 = ${LEGEND_KEYS.join(", ")}`,
+      });
+    }
+    const mark = typeof o.mark === "string" ? resolveLegendMark(o.mark) : undefined;
+    if (o.mark !== undefined && (typeof o.mark !== "string" || mark === null)) {
+      errors.push({ path: `${path}.mark`, message: "legend mark is not recognized" });
+    }
+    if (typeof o.text !== "string" || o.text.trim().length === 0) {
+      errors.push({ path: `${path}.text`, message: "legend text must be a non-empty string" });
+    }
+    if (o.mark === undefined) {
+      if (o.tone !== undefined || o.lineStyle !== undefined) errors.push({ path, message: "legend note cannot have tone or lineStyle" });
+      if (o.align !== undefined && !(LEGEND_NOTE_ALIGN_VALUES as readonly unknown[]).includes(o.align)) errors.push({ path: `${path}.align`, message: `align must be ${LEGEND_NOTE_ALIGN_VALUES.join(" or ")}` });
+      if (o.lead !== undefined && typeof o.lead !== "string") errors.push({ path: `${path}.lead`, message: "lead must be a string" });
+    } else {
+      if (o.align !== undefined || o.lead !== undefined) errors.push({ path, message: "marked legend item cannot have align or lead" });
+      if (o.tone !== undefined && (typeof o.tone !== "string" || resolveTone(o.tone) === undefined)) errors.push({ path: `${path}.tone`, message: "tone is not recognized" });
+      if (o.lineStyle !== undefined) {
+        if (!(LEGEND_LINE_STYLE_VALUES as readonly unknown[]).includes(o.lineStyle)) errors.push({ path: `${path}.lineStyle`, message: `lineStyle must be ${LEGEND_LINE_STYLE_VALUES.join(" or ")}` });
+        if (mark === undefined || mark === null || !(LEGEND_LINE_MARKS as readonly string[]).includes(mark)) errors.push({ path: `${path}.lineStyle`, message: "lineStyle requires a line-end legend mark" });
+      }
+    }
+  });
+}
+
+const STAGE_HEADER_KEYS = ["leftPad", "topPad", "numberSize", "gap", "nameSize", "bottomPad"] as const;
+const REQUIRED_STAGE_HEADER_KEYS = ["topPad", "numberSize", "gap", "nameSize", "bottomPad"] as const;
+
+/** JSON の段の見出し寸法を、閉じた欄・必須の正数まで検査する。 */
+function validateStageHeader(v: unknown, errors: JsonDslError[]): void {
+  if (v === undefined) return;
+  if (!v || typeof v !== "object" || Array.isArray(v)) {
+    errors.push({ path: "$.stageHeader", message: "stageHeader must be an object" });
+    return;
+  }
+  const path = "$.stageHeader";
+  const o = v as Record<string, unknown>;
+  for (const key of Object.keys(o)) {
+    if ((STAGE_HEADER_KEYS as readonly string[]).includes(key)) continue;
+    errors.push({
+      path: `${path}.${key}`,
+      message: `unknown key "${key}"`,
+      hint: `使える項目 = ${STAGE_HEADER_KEYS.join(", ")}`,
+    });
+  }
+  for (const key of REQUIRED_STAGE_HEADER_KEYS) {
+    if (o[key] === undefined) {
+      errors.push({ path: `${path}.${key}`, message: `${key} is required` });
+    }
+  }
+  for (const key of STAGE_HEADER_KEYS) {
+    const value = o[key];
+    if (value === undefined) continue;
+    const zeroAllowed = key === "leftPad" || key === "topPad" || key === "gap" || key === "bottomPad";
+    if (typeof value !== "number" || !Number.isFinite(value) || (zeroAllowed ? value < 0 : value <= 0)) {
+      errors.push({
+        path: `${path}.${key}`,
+        message: `${key} must be ${zeroAllowed ? "a non-negative" : "a positive"} number`,
+      });
+    }
+  }
+}
+
 /**
  * 値を見せる部品の並びを検査する (#1374)。
  *
@@ -2019,7 +2603,448 @@ function validateAxes(v: unknown, errors: JsonDslError[]): void {
     const o = 一方 as Record<string, unknown>;
     checkUnknownKeys(o, 層の名[名], `$.axes.${名}`, errors);
     表で検査(o, 層の名[名], `$.axes.${名}`, `axes.${名}`, errors);
+    if (o.direction === true) {
+      if (typeof o.label !== "string") {
+        errors.push({ path: `$.axes.${名}.label`, message: `axes.${名}.label must be a string for a directional axis` });
+      }
+    } else if (o.label !== undefined || o.direction !== undefined) {
+      errors.push({ path: `$.axes.${名}.direction`, message: `axes.${名}.direction must be true when label is used` });
+    }
+  }
+}
+
+/** #2854 で足した図表の複合欄と閉じた語を検査する。 */
+function validateChartPresentationFields(j: Record<string, unknown>, errors: JsonDslError[]): void {
+  const enumField = (name: string, allowed: readonly string[]): void => {
+    const value = j[name];
+    if (value === undefined || typeof value !== "string") return;
+    if (!allowed.includes(value)) {
+      errors.push({ path: `$.${name}`, message: `${name} must be one of: ${allowed.join(", ")}` });
+    }
+  };
+  enumField("chartPieTableColumns", CHART_PIE_TABLE_COLUMN_VALUES);
+  enumField("chartPieRingWidth", CHART_PIE_RING_WIDTH_VALUES);
+  enumField("chartStackedLegendPosition", CHART_STACKED_LEGEND_POSITION_VALUES);
+  enumField("chartWaffleLegendPosition", CHART_WAFFLE_LEGEND_POSITION_VALUES);
+  enumField("funnelForm", FUNNEL_FORM_VALUES);
+  enumField("funnelRate", FUNNEL_RATE_VALUES);
+  enumField("quadrantPointLabelSide", QUADRANT_POINT_LABEL_SIDE_VALUES);
+  enumField("treeNodeForm", TREE_NODE_FORM_VALUES);
+  enumField("treeEdgeTone", TREE_EDGE_TONE_VALUES);
+  enumField("treeEdgeHead", TREE_EDGE_HEAD_VALUES);
+  enumField("mindForm", MIND_FORM_VALUES);
+  enumField("journeyForm", JOURNEY_FORM_VALUES);
+  enumField("journeyLineForm", JOURNEY_LINE_FORM_VALUES);
+  enumField("sequenceActorForm", SEQUENCE_ACTOR_FORM_VALUES);
+  enumField("sequenceLabelForm", SEQUENCE_LABEL_FORM_VALUES);
+  enumField("sequenceReturnHead", SEQUENCE_RETURN_HEAD_VALUES);
+  enumField("cornerForm", CORNER_FORM_VALUES);
+  enumField("chartBarShape", CHART_BAR_SHAPE_VALUES);
+  enumField("quadrantLabelPosition", QUADRANT_LABEL_POSITION_VALUES);
+
+  const closedObject = (
+    name: "journeyLabels" | "figureCard" | "figureSize" | "treeSize" | "mindSize" |
+      "terminalDecoration" | "figureKindLabel" | "figureInset" | "journeySize" | "chartBarSize" |
+      "chartLineSize" | "chartPieSize" | "chartWaffleSize" | "chartSlopeLabelTemplate" | "chartSlopeSize" |
+      "chartStackedLayout" | "chartGaugeSize" | "ganttSize" | "quadrantSize" | "legendOffset" | "stageLayout",
+    keys: readonly string[],
+  ): Record<string, unknown> | undefined => {
+    const value = j[name];
+    if (value === undefined) return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      errors.push({ path: `$.${name}`, message: `${name} must be an object` });
+      return undefined;
+    }
+    const object = value as Record<string, unknown>;
+    for (const key of Object.keys(object)) {
+      if (!keys.includes(key)) errors.push({ path: `$.${name}.${key}`, message: `unknown key "${key}"` });
+    }
+    return object;
+  };
+  const labels = closedObject("journeyLabels", JOURNEY_LABEL_KEYS);
+  if (labels !== undefined) {
+    for (const key of JOURNEY_LABEL_KEYS) {
+      if (typeof labels[key] !== "string" || labels[key].trim() === "") {
+        errors.push({ path: `$.journeyLabels.${key}`, message: `${key} must be a non-empty string` });
+      }
+    }
+  }
+  if (j.sequenceKindLabels !== undefined) {
+    if (!j.sequenceKindLabels || typeof j.sequenceKindLabels !== "object" || Array.isArray(j.sequenceKindLabels)) {
+      errors.push({ path: "$.sequenceKindLabels", message: "sequenceKindLabels must be an object" });
+    } else {
+      const labels = j.sequenceKindLabels as Record<string, unknown>;
+      for (const [key, value] of Object.entries(labels)) {
+        if (!(SEQUENCE_KIND_LABEL_KEYS as readonly string[]).includes(key)) errors.push({ path: `$.sequenceKindLabels.${key}`, message: `unknown key "${key}"` });
+        else if (typeof value !== "string") errors.push({ path: `$.sequenceKindLabels.${key}`, message: `${key} must be a string` });
+      }
+    }
+  }
+  if (
+    j.sequenceRowGap !== undefined &&
+    (typeof j.sequenceRowGap !== "number" || !Number.isFinite(j.sequenceRowGap) || j.sequenceRowGap <= 0)
+  ) {
+    errors.push({ path: "$.sequenceRowGap", message: "sequenceRowGap must be a positive finite number" });
+  }
+  for (const key of ["sequenceGutter", "sequenceBandWidth"] as const) {
+    if (j[key] !== undefined && (typeof j[key] !== "number" || !Number.isFinite(j[key]) || j[key] <= 0)) {
+      errors.push({ path: `$.${key}`, message: `${key} must be a positive finite number` });
+    }
+  }
+  if (j.sequenceSelfLoop !== undefined) {
+    if (!j.sequenceSelfLoop || typeof j.sequenceSelfLoop !== "object" || Array.isArray(j.sequenceSelfLoop)) {
+      errors.push({ path: "$.sequenceSelfLoop", message: "sequenceSelfLoop must be an object" });
+    } else {
+      const loop = j.sequenceSelfLoop as Record<string, unknown>;
+      for (const key of Object.keys(loop)) {
+        if (!(SEQUENCE_SELF_LOOP_KEYS as readonly string[]).includes(key)) errors.push({ path: `$.sequenceSelfLoop.${key}`, message: `unknown key "${key}"` });
+      }
+      if (loop.form !== undefined && loop.form !== "orthogonal") errors.push({ path: "$.sequenceSelfLoop.form", message: "form must be orthogonal" });
+      for (const key of ["width", "drop"] as const) {
+        if (loop[key] !== undefined && (typeof loop[key] !== "number" || !Number.isFinite(loop[key]) || loop[key] <= 0)) errors.push({ path: `$.sequenceSelfLoop.${key}`, message: "must be a positive finite number" });
+      }
+    }
+  }
+  const card = closedObject("figureCard", ["label", "note"]);
+  if (card !== undefined) {
+    if (typeof card.label !== "string")
+      errors.push({ path: "$.figureCard.label", message: "label must be a string" });
+    if (card.note !== undefined && typeof card.note !== "string")
+      errors.push({ path: "$.figureCard.note", message: "note must be a string" });
+  }
+  const size = closedObject("figureSize", ["width", "height"]);
+  if (size !== undefined) {
+    for (const key of ["width", "height"] as const) {
+      if (typeof size[key] !== "number" || !Number.isFinite(size[key]) || size[key] <= 0)
+        errors.push({ path: `$.figureSize.${key}`, message: `${key} must be a positive finite number` });
+    }
+  }
+  const positiveNumber = (value: unknown, path: string): boolean => {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) return true;
+    errors.push({ path, message: "must be a positive finite number" });
+    return false;
+  };
+  const nonNegativeNumber = (value: unknown, path: string): boolean => {
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) return true;
+    errors.push({ path, message: "must be a non-negative finite number" });
+    return false;
+  };
+  if (j.edgeEndGap !== undefined) nonNegativeNumber(j.edgeEndGap, "$.edgeEndGap");
+  const treeSize = closedObject("treeSize", [
+    "nodeWidths",
+    "nodeHeight",
+    "titleFontSize",
+    "subtitleFontSize",
+    "siblingGap",
+    "levelGap",
+  ]);
+  if (treeSize !== undefined) {
+    if (treeSize.nodeWidths !== undefined) {
+      if (!Array.isArray(treeSize.nodeWidths) || treeSize.nodeWidths.length === 0) {
+        errors.push({ path: "$.treeSize.nodeWidths", message: "must be a non-empty array" });
+      } else {
+        treeSize.nodeWidths.forEach((value, index) => {
+          positiveNumber(value, `$.treeSize.nodeWidths[${index}]`);
+        });
+      }
+    }
+    for (const key of ["nodeHeight", "titleFontSize", "subtitleFontSize"] as const) {
+      if (treeSize[key] !== undefined) positiveNumber(treeSize[key], `$.treeSize.${key}`);
+    }
+    for (const key of ["siblingGap", "levelGap"] as const) {
+      if (treeSize[key] !== undefined) nonNegativeNumber(treeSize[key], `$.treeSize.${key}`);
+    }
+  }
+  const mindSize = closedObject("mindSize", [
+    "contentOffset",
+    "root",
+    "branch",
+    "leaf",
+    "rootBranchGap",
+    "branchLeafGap",
+    "branchRowGap",
+    "branchRowOffset",
+    "leafRowGap",
+    "leafRowOffset",
+  ]);
+  if (mindSize !== undefined) {
+    if (mindSize.contentOffset !== undefined) {
+      const value = mindSize.contentOffset;
+      const path = "$.mindSize.contentOffset";
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        errors.push({ path, message: "contentOffset must be an object" });
+      } else {
+        const offset = value as Record<string, unknown>;
+        for (const key of Object.keys(offset)) {
+          if (key !== "x" && key !== "y")
+            errors.push({ path: `${path}.${key}`, message: `unknown key "${key}"` });
+        }
+        for (const key of ["x", "y"] as const) {
+          if (typeof offset[key] !== "number" || !Number.isFinite(offset[key]))
+            errors.push({ path: `${path}.${key}`, message: "must be a finite number" });
+        }
+      }
+    }
+    const nestedSize = (
+      key: "root" | "branch" | "leaf",
+      allowed: readonly string[],
+    ): Record<string, unknown> | undefined => {
+      const value = mindSize[key];
+      if (value === undefined) return undefined;
+      const path = `$.mindSize.${key}`;
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        errors.push({ path, message: `${key} must be an object` });
+        return undefined;
+      }
+      const object = value as Record<string, unknown>;
+      for (const nestedKey of Object.keys(object)) {
+        if (!allowed.includes(nestedKey))
+          errors.push({ path: `${path}.${nestedKey}`, message: `unknown key "${nestedKey}"` });
+      }
+      return object;
+    };
+    for (const [key, allowed] of [
+      ["root", ["width", "height", "fontSize"]],
+      ["branch", ["width", "height", "fontSize"]],
+      ["leaf", ["fontSize"]],
+    ] as const) {
+      const nested = nestedSize(key, allowed);
+      if (nested === undefined) continue;
+      for (const nestedKey of allowed) {
+        if (nested[nestedKey] !== undefined)
+          positiveNumber(nested[nestedKey], `$.mindSize.${key}.${nestedKey}`);
+      }
+    }
+    for (const key of ["rootBranchGap", "branchLeafGap", "branchRowGap", "leafRowGap"] as const) {
+      if (mindSize[key] !== undefined) nonNegativeNumber(mindSize[key], `$.mindSize.${key}`);
+    }
+    for (const key of ["branchRowOffset", "leafRowOffset"] as const) {
+      const value = mindSize[key];
+      if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value))) {
+        errors.push({ path: `$.mindSize.${key}`, message: "must be a finite number" });
+      }
+    }
+  }
+
+  const specs = {
+    terminalDecoration: ["windowControls", "cursor", "rowOrdinal"],
+    figureKindLabel: ["text", "x", "y", "fontSize", "fontWeight", "letterSpacing"],
+    figureInset: ["top", "right", "bottom", "left", "radius"],
+    journeySize: ["plotPadding", "pointPadding"],
+    chartBarSize: ["tickFontSize", "valueFontSize", "labelFontSize", "plotPadding", "barWidth", "cornerRadius"],
+    chartLineSize: ["valueLabelOffset", "tickFontSize", "periodFontSize", "pointRadius", "plotPadding", "tickGap", "pointPadding", "periodY"],
+    chartPieSize: ["tableWidth", "tableLabelFontSize", "tableValueFontSize", "tableRowGap", "tablePaddingInline", "outerRadius", "centerX"],
+    chartWaffleSize: ["gridLeft", "cellPitch"],
+    chartSlopeLabelTemplate: ["left", "right"],
+    chartSlopeSize: ["pointRadius", "periodFontSize", "labelFontSize", "leftAxisX", "axisGap", "labelAxisGap", "plotPadding", "pointPadding"],
+    chartStackedLayout: ["legendColumns", "legendColumnGap", "segmentGap", "barThickness", "barWidth", "legendMarkSize", "legendFontSize", "periodFontSize", "rateFontSize", "legendOffsetY"],
+    chartGaugeSize: ["arcThickness", "outerRadius", "plotTop", "valueFontSize"],
+    ganttSize: ["taskLabelFontSize", "taskLabelAlign", "taskLabelX", "tickFontSize", "tickCount", "barThickness", "milestoneFontSize", "milestoneRadius", "dependencyStrokeWidth", "taskColumnWidth", "timelinePaddingRight"],
+    quadrantSize: ["plotOffset", "plotSize", "pointRadius", "pointFontSize", "pointLabelGap", "quadrantFontSize", "axisFontSize"],
+    legendOffset: ["x", "y"],
+    stageLayout: ["columnWidths", "columnGap", "backDetourTopGap", "backDetourSideGap", "backDetourTargetInset"],
+  } as const;
+  const objects = Object.fromEntries(Object.entries(specs).map(([name, keys]) => [name, closedObject(name as keyof typeof specs, keys)])) as Record<keyof typeof specs, Record<string, unknown> | undefined>;
+  const positiveKeys: Partial<Record<keyof typeof specs, readonly string[]>> = {
+    figureKindLabel: ["fontSize", "fontWeight"],
+    chartBarSize: ["tickFontSize", "valueFontSize", "labelFontSize", "barWidth"],
+    chartLineSize: ["tickFontSize", "periodFontSize", "pointRadius"],
+    chartPieSize: ["tableWidth", "tableLabelFontSize", "tableValueFontSize", "outerRadius"],
+    chartWaffleSize: ["cellPitch"],
+    chartSlopeSize: ["pointRadius", "periodFontSize", "labelFontSize", "axisGap"],
+    chartStackedLayout: ["barThickness", "barWidth", "legendMarkSize", "legendFontSize", "periodFontSize", "rateFontSize"],
+    chartGaugeSize: ["arcThickness", "outerRadius", "valueFontSize"],
+    ganttSize: ["taskLabelFontSize", "tickFontSize", "barThickness", "milestoneFontSize", "milestoneRadius", "dependencyStrokeWidth"],
+    quadrantSize: ["plotSize", "pointRadius", "pointFontSize", "quadrantFontSize", "axisFontSize"],
+  };
+  const nonNegativeKeys: Partial<Record<keyof typeof specs, readonly string[]>> = {
+    figureKindLabel: ["letterSpacing"], figureInset: ["top", "right", "bottom", "left", "radius"],
+    chartBarSize: ["cornerRadius"], chartLineSize: ["tickGap", "periodY"], chartPieSize: ["tableRowGap", "tablePaddingInline", "centerX"], chartWaffleSize: ["gridLeft"], chartSlopeSize: ["leftAxisX", "labelAxisGap"],
+    chartStackedLayout: ["legendColumnGap", "segmentGap"], chartGaugeSize: ["plotTop"],
+    ganttSize: ["taskLabelX", "taskColumnWidth", "timelinePaddingRight"], quadrantSize: ["pointLabelGap"],
+    stageLayout: ["columnGap", "backDetourTopGap", "backDetourSideGap", "backDetourTargetInset"],
+  };
+  for (const [name, object] of Object.entries(objects) as [keyof typeof specs, Record<string, unknown> | undefined][]) {
+    if (object === undefined) continue;
+    for (const key of positiveKeys[name] ?? []) if (object[key] !== undefined) positiveNumber(object[key], `$.${name}.${key}`);
+    for (const key of nonNegativeKeys[name] ?? []) if (object[key] !== undefined) nonNegativeNumber(object[key], `$.${name}.${key}`);
+  }
+  const finite = (value: unknown, path: string): void => { if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value))) errors.push({ path, message: "must be a finite number" }); };
+  if (objects.terminalDecoration) for (const key of specs.terminalDecoration) if (objects.terminalDecoration[key] !== undefined && typeof objects.terminalDecoration[key] !== "boolean") errors.push({ path: `$.terminalDecoration.${key}`, message: "must be boolean" });
+  if (objects.figureKindLabel) {
+    if (typeof objects.figureKindLabel.text !== "string" || objects.figureKindLabel.text.trim() === "") errors.push({ path: "$.figureKindLabel.text", message: "must be a non-empty string" });
+    finite(objects.figureKindLabel.x, "$.figureKindLabel.x"); finite(objects.figureKindLabel.y, "$.figureKindLabel.y");
+  }
+  if (objects.chartSlopeLabelTemplate) for (const key of specs.chartSlopeLabelTemplate) if (objects.chartSlopeLabelTemplate[key] !== undefined && typeof objects.chartSlopeLabelTemplate[key] !== "string") errors.push({ path: `$.chartSlopeLabelTemplate.${key}`, message: "must be a string" });
+  if (objects.chartStackedLayout) finite(objects.chartStackedLayout.legendOffsetY, "$.chartStackedLayout.legendOffsetY");
+  if (objects.legendOffset) {
+    finite(objects.legendOffset.x, "$.legendOffset.x");
+    finite(objects.legendOffset.y, "$.legendOffset.y");
+  }
+  const nestedNumberObject = (parent: keyof typeof specs, key: string, keys: readonly string[], positive: boolean): void => {
+    const value = objects[parent]?.[key]; if (value === undefined) return;
+    if (!value || typeof value !== "object" || Array.isArray(value)) { errors.push({ path: `$.${parent}.${key}`, message: "must be an object" }); return; }
+    const object = value as Record<string, unknown>;
+    for (const child of Object.keys(object)) if (!keys.includes(child)) errors.push({ path: `$.${parent}.${key}.${child}`, message: `unknown key "${child}"` });
+    for (const child of keys) if (object[child] !== undefined) (positive ? positiveNumber : nonNegativeNumber)(object[child], `$.${parent}.${key}.${child}`);
+  };
+  nestedNumberObject("chartBarSize", "plotPadding", ["top", "right", "bottom", "left"], false);
+  nestedNumberObject("chartLineSize", "valueLabelOffset", ["above", "below"], false);
+  nestedNumberObject("chartLineSize", "plotPadding", ["top", "right", "bottom", "left"], false);
+  nestedNumberObject("chartLineSize", "pointPadding", ["left", "right"], false);
+  nestedNumberObject("chartSlopeSize", "plotPadding", ["top", "bottom"], false);
+  nestedNumberObject("chartSlopeSize", "pointPadding", ["top", "bottom"], false);
+  nestedNumberObject("journeySize", "plotPadding", ["left", "right"], false);
+  nestedNumberObject("journeySize", "pointPadding", ["left", "right"], false);
+  nestedNumberObject("quadrantSize", "plotOffset", ["x", "y"], false);
+  const columnWidths = objects.stageLayout?.columnWidths;
+  if (columnWidths !== undefined) {
+    if (!columnWidths || typeof columnWidths !== "object" || Array.isArray(columnWidths)) errors.push({ path: "$.stageLayout.columnWidths", message: "must be an object" });
+    else for (const [key, value] of Object.entries(columnWidths)) nonNegativeNumber(value, `$.stageLayout.columnWidths.${key}`);
+  }
+  const stackedColumns = objects.chartStackedLayout?.legendColumns;
+  if (stackedColumns !== undefined && (!Number.isInteger(stackedColumns) || typeof stackedColumns !== "number" || stackedColumns <= 0)) errors.push({ path: "$.chartStackedLayout.legendColumns", message: "must be a positive integer" });
+  if (
+    objects.ganttSize?.taskLabelAlign !== undefined &&
+    !(GANTT_TASK_LABEL_ALIGN_VALUES as readonly unknown[]).includes(objects.ganttSize.taskLabelAlign)
+  ) errors.push({ path: "$.ganttSize.taskLabelAlign", message: "must be start or end" });
+  const tickCount = objects.ganttSize?.tickCount;
+  if (tickCount !== undefined && (!Number.isInteger(tickCount) || typeof tickCount !== "number" || tickCount < 2)) errors.push({ path: "$.ganttSize.tickCount", message: "must be an integer greater than or equal to 2" });
+
+  if (Array.isArray(j.chartSlopePeriods) &&
+      (j.chartSlopePeriods.length !== 2 || j.chartSlopePeriods.some((v) => typeof v !== "string" || v.trim() === ""))) {
+    errors.push({ path: "$.chartSlopePeriods", message: "chartSlopePeriods must contain exactly two non-empty strings" });
+  }
+  if (Array.isArray(j.chartSlopeEmphasisIds) && j.chartSlopeEmphasisIds.length === 0) {
+    errors.push({ path: "$.chartSlopeEmphasisIds", message: "chartSlopeEmphasisIds must contain at least one id" });
+  }
+
+  const boundNumber = (value: unknown): boolean =>
+    (typeof value === "number" && Number.isFinite(value)) ||
+    (typeof value === "string" && value.trim() !== "");
+  if (j.chartLineSeries !== undefined && !Array.isArray(j.chartLineSeries)) {
+    errors.push({ path: "$.chartLineSeries", message: "chartLineSeries must be an array" });
+  } else if (Array.isArray(j.chartLineSeries)) {
+    if (j.chartLineSeries.length === 0) {
+      errors.push({ path: "$.chartLineSeries", message: "chartLineSeries must contain at least one series" });
+    }
+    j.chartLineSeries.forEach((series, i) => {
+      const path = `$.chartLineSeries[${i}]`;
+      if (!series || typeof series !== "object" || Array.isArray(series)) {
+        errors.push({ path, message: "chartLineSeries item must be an object" });
+        return;
+      }
+      const value = series as Record<string, unknown>;
+      for (const key of Object.keys(value)) {
+        if (!["label", "points", "tone", "dash", "marker", "valueIndexes"].includes(key))
+          errors.push({ path: `${path}.${key}`, message: `unknown key "${key}"` });
+      }
+      if (value.label !== undefined && typeof value.label !== "string")
+        errors.push({ path: `${path}.label`, message: "label must be a string" });
+      if (value.tone !== undefined && (typeof value.tone !== "string" || resolveTone(value.tone) === undefined))
+        errors.push({ path: `${path}.tone`, message: "tone must be a known tone" });
+      if (
+        value.dash !== undefined &&
+        (typeof value.dash !== "string" ||
+          !(CHART_LINE_DASH_VALUES as readonly string[]).includes(value.dash))
+      )
+        errors.push({ path: `${path}.dash`, message: "dash must be solid or dotted" });
+      if (
+        value.marker !== undefined &&
+        (typeof value.marker !== "string" ||
+          !(CHART_LINE_MARKER_VALUES as readonly string[]).includes(value.marker))
+      )
+        errors.push({ path: `${path}.marker`, message: "marker must be dot, hollow, or none" });
+      if (value.valueIndexes !== undefined &&
+          (!Array.isArray(value.valueIndexes) || value.valueIndexes.some((v) => typeof v !== "number" || !Number.isInteger(v) || v < 0)))
+        errors.push({ path: `${path}.valueIndexes`, message: "valueIndexes must contain non-negative integers" });
+      if (!Array.isArray(value.points) || value.points.length === 0) {
+        errors.push({ path: `${path}.points`, message: "points must be a non-empty array" });
+      } else value.points.forEach((point, p) => {
+        const pointPath = `${path}.points[${p}]`;
+        if (!point || typeof point !== "object" || Array.isArray(point)) {
+          errors.push({ path: pointPath, message: "point must be an object" });
+          return;
+        }
+        const item = point as Record<string, unknown>;
+        for (const key of Object.keys(item)) if (key !== "label" && key !== "value")
+          errors.push({ path: `${pointPath}.${key}`, message: `unknown key "${key}"` });
+        if (typeof item.label !== "string") errors.push({ path: `${pointPath}.label`, message: "label must be a string" });
+        if (!boundNumber(item.value)) errors.push({ path: `${pointPath}.value`, message: "value must be a finite number or non-empty string" });
+      });
+    });
+  }
+
+  if (j.chartStackedPeriods !== undefined && !Array.isArray(j.chartStackedPeriods)) {
+    errors.push({ path: "$.chartStackedPeriods", message: "chartStackedPeriods must be an array" });
+  } else if (Array.isArray(j.chartStackedPeriods)) {
+    if (j.chartStackedPeriods.length === 0)
+      errors.push({ path: "$.chartStackedPeriods", message: "chartStackedPeriods must contain at least one period" });
+    j.chartStackedPeriods.forEach((period, i) => {
+      const path = `$.chartStackedPeriods[${i}]`;
+      if (!period || typeof period !== "object" || Array.isArray(period)) {
+        errors.push({ path, message: "chartStackedPeriods item must be an object" });
+        return;
+      }
+      const value = period as Record<string, unknown>;
+      for (const key of Object.keys(value)) if (key !== "label" && key !== "values")
+        errors.push({ path: `${path}.${key}`, message: `unknown key "${key}"` });
+      if (typeof value.label !== "string") errors.push({ path: `${path}.label`, message: "label must be a string" });
+      if (!Array.isArray(value.values) || value.values.some((entry) => !boundNumber(entry)))
+        errors.push({ path: `${path}.values`, message: "values must be an array of finite numbers or non-empty strings" });
+    });
+  }
+
+  if (
+    j.chartGaugeValue !== undefined &&
+    (!j.chartGaugeValue || typeof j.chartGaugeValue !== "object" || Array.isArray(j.chartGaugeValue))
+  ) {
+    errors.push({ path: "$.chartGaugeValue", message: "chartGaugeValue must be an object" });
+  } else if (j.chartGaugeValue && typeof j.chartGaugeValue === "object") {
+    const value = j.chartGaugeValue as Record<string, unknown>;
+    for (const key of Object.keys(value)) if (!["max", "current", "target", "previous", "previousLabel"].includes(key))
+      errors.push({ path: `$.chartGaugeValue.${key}`, message: `unknown key "${key}"` });
+    const finite = (entry: unknown): boolean => typeof entry === "number" && Number.isFinite(entry);
+    if (!finite(value.max) || Number(value.max) <= 0) errors.push({ path: "$.chartGaugeValue.max", message: "max must be a positive finite number" });
+    if (!boundNumber(value.current)) errors.push({ path: "$.chartGaugeValue.current", message: "current must be a finite number or non-empty string" });
+    for (const key of ["target", "previous"] as const) if (value[key] !== undefined && !boundNumber(value[key]))
+      errors.push({ path: `$.chartGaugeValue.${key}`, message: `${key} must be a finite number or non-empty string` });
+    if (value.previousLabel !== undefined && typeof value.previousLabel !== "string")
+      errors.push({ path: "$.chartGaugeValue.previousLabel", message: "previousLabel must be a string" });
+  }
+}
+
+/**
+ * JSON の区画の名前を、図の側の綴りへ直す (#2667)。
+ *
+ * 記法と JSON はどちらも `左上` のような語で書き、図の側は `topLeft` で受ける。
+ * 直す先の表は項目の欄と共有する (`区画`) = 同じ区画を 2 通りで呼ばない。
+ *
+ * 中身の無い形は「書かなかった」 と同じにする (`axes` と同じ扱い)。
+ */
+function 区画の名前を直す(r: JsonRegions | undefined): DslRegions | undefined {
+  if (r === undefined) return undefined;
+  const 出: DslRegions = {};
+  for (const [語, key] of 区画) {
+    const v = (r as Record<string, unknown>)[語];
+    if (typeof v === "string" && v.trim() !== "") 出[key] = v;
+  }
+  return Object.keys(出).length > 0 ? 出 : undefined;
+}
+
+/** 2 軸で仕分ける図の区画の名前を見る (#2667) */
+function validateRegions(v: unknown, errors: JsonDslError[]): void {
+  if (v === undefined) return;
+  if (!v || typeof v !== "object" || Array.isArray(v)) {
+    errors.push({
+      path: "$.regions",
+      message: 'regions must be a plain object like { "左上": "すぐやる" }',
+    });
+    return;
   }
+  const o = v as Record<string, unknown>;
+  checkUnknownKeys(o, "regions", "$.regions", errors);
+  表で検査(o, "regions", "$.regions", "regions", errors);
 }
 
 /**
@@ -2288,6 +3313,8 @@ function validateJson(
   // 値を見せる部品の中身を、記法と同じ表で見る (#1374)
   validateReadouts(j.readouts, errors);
   validateBands(j.bands, errors);
+  validateLegend(j.legend, errors);
+  validateStageHeader(j.stageHeader, errors);
   // 読む人が動かすつまみの中身も、記法と同じ表で見る (#1389)
   validateInputs(j.inputs, errors);
   // 式は描画側の parser に通す (#1391)
@@ -2299,6 +3326,29 @@ function validateJson(
   // 値そのものの型は表が見る (#1304)。 図表の箱の上の小見出し (#1247) の空文字は
   // 「書かなかった」 と同じ扱いにするため通す (記法側の `eyebrow:` と揃える。 落とすのは `jsonToDoc`)
   表で検査(j, "root", "$", "", errors);
+  validateDiagramShape(j, errors);
+  for (const 欄 of ["ticks", "目盛り"] as const) {
+    if (Array.isArray(j[欄]) && j[欄].length === 0) {
+      errors.push({ path: `$.${欄}`, message: `${欄} must contain at least one label` });
+    }
+  }
+  if (j.ganttToday !== undefined) {
+    const today = j.ganttToday;
+    if (!today || typeof today !== "object" || Array.isArray(today)) {
+      errors.push({ path: "$.ganttToday", message: "ganttToday must be an object" });
+    } else {
+      const value = today as Record<string, unknown>;
+      for (const key of Object.keys(value)) {
+        if (key !== "index" && key !== "label") errors.push({ path: `$.ganttToday.${key}`, message: `unknown key "${key}"` });
+      }
+      if (typeof value.index !== "number" || !Number.isFinite(value.index)) {
+        errors.push({ path: "$.ganttToday.index", message: "ganttToday.index must be a finite number" });
+      }
+      if (typeof value.label !== "string") {
+        errors.push({ path: "$.ganttToday.label", message: "ganttToday.label must be a string" });
+      }
+    }
+  }
 
   if (!Array.isArray(j.actors) || j.actors.length === 0) {
     errors.push({ path: "$.actors", message: "actors must be a non-empty array" });
@@ -2314,6 +3364,93 @@ function validateJson(
       // 値そのものの型は表が見る (#1304)。 `kind` は見本 (parts) の名前も受けるため
       // 非空の文字列までしか縛らない (CAR-1657 の unified syntax)
       表で検査(ao, "actor", `$.actors[${i}]`, "actor", errors);
+      const actorEnum = (key: string, allowed: readonly string[]): void => {
+        const value = ao[key];
+        if (value === undefined || typeof value !== "string") return;
+        if (!allowed.includes(value)) errors.push({ path: `$.actors[${i}].${key}`, message: `${key} must be one of: ${allowed.join(", ")}` });
+      };
+      actorEnum("kindForm", KIND_FORM_VALUES);
+      actorEnum("icon", CDL_ICON_VALUES);
+      actorEnum("titleAlign", TITLE_ALIGN_VALUES);
+      actorEnum("rowMarkForm", ROW_MARK_FORM_VALUES);
+      actorEnum("rowDividerForm", ROW_DIVIDER_FORM_VALUES);
+      if (ao.rowWell !== undefined) {
+        const path = `$.actors[${i}].rowWell`;
+        if (!ao.rowWell || typeof ao.rowWell !== "object" || Array.isArray(ao.rowWell)) {
+          errors.push({ path, message: "rowWell must be an object" });
+        } else {
+          const well = ao.rowWell as Record<string, unknown>;
+          for (const key of Object.keys(well)) {
+            if (!(ROW_WELL_KEYS as readonly string[]).includes(key)) errors.push({ path: `${path}.${key}`, message: `unknown key "${key}"` });
+          }
+          for (const key of ROW_WELL_KEYS) {
+            const value = well[key];
+            if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value) || value < 0)) errors.push({ path: `${path}.${key}`, message: "must be a non-negative finite number" });
+          }
+        }
+      }
+      if (ao.rowLayout !== undefined) {
+        const path = `$.actors[${i}].rowLayout`;
+        if (!ao.rowLayout || typeof ao.rowLayout !== "object" || Array.isArray(ao.rowLayout)) {
+          errors.push({ path, message: "rowLayout must be an object" });
+        } else {
+          const layout = ao.rowLayout as Record<string, unknown>;
+          for (const key of Object.keys(layout)) if (!["titleBaseline", "rowTop", "rowPitch"].includes(key)) errors.push({ path: `${path}.${key}`, message: `unknown key "${key}"` });
+          for (const key of ["titleBaseline", "rowTop", "rowPitch"] as const) {
+            const value = layout[key];
+            if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value) || (key === "rowPitch" ? value <= 0 : value < 0))) errors.push({ path: `${path}.${key}`, message: key === "rowPitch" ? "must be a positive finite number" : "must be a non-negative finite number" });
+          }
+        }
+      }
+      if (ao.figureCard !== undefined) {
+        const path = `$.actors[${i}].figureCard`;
+        if (!ao.figureCard || typeof ao.figureCard !== "object" || Array.isArray(ao.figureCard)) errors.push({ path, message: "figureCard must be an object" });
+        else {
+          const card = ao.figureCard as Record<string, unknown>;
+          for (const key of Object.keys(card)) if (key !== "label" && key !== "note") errors.push({ path: `${path}.${key}`, message: `unknown key "${key}"` });
+          if (typeof card.label !== "string") errors.push({ path: `${path}.label`, message: "label must be a string" });
+          if (card.note !== undefined && typeof card.note !== "string") errors.push({ path: `${path}.note`, message: "note must be a string" });
+        }
+      }
+      if (ao.marks !== undefined && !Array.isArray(ao.marks)) {
+        errors.push({ path: `$.actors[${i}].marks`, message: "marks must be an array" });
+      } else if (Array.isArray(ao.marks)) {
+        ao.marks.forEach((mark, markIndex) => {
+          if (typeof mark === "string") return;
+          const path = `$.actors[${i}].marks[${markIndex}]`;
+          if (!mark || typeof mark !== "object" || Array.isArray(mark)) {
+            errors.push({ path, message: "mark must be a string or object" });
+            return;
+          }
+          const entry = mark as Record<string, unknown>;
+          for (const key of Object.keys(entry)) if (key !== "mark" && key !== "tone") errors.push({ path: `${path}.${key}`, message: `unknown key "${key}"` });
+          if (typeof entry.mark !== "string") errors.push({ path: `${path}.mark`, message: "mark must be a string" });
+          if (entry.tone !== undefined && !(ROW_MARK_TONE_VALUES as readonly unknown[]).includes(entry.tone)) errors.push({ path: `${path}.tone`, message: `tone must be one of: ${ROW_MARK_TONE_VALUES.join(", ")}` });
+        });
+      }
+      if (
+        typeof ao.opportunityPosition === "string" &&
+        !(JOURNEY_OPPORTUNITY_POSITION_VALUES as readonly string[]).includes(ao.opportunityPosition)
+      ) {
+        errors.push({
+          path: `$.actors[${i}].opportunityPosition`,
+          message: `opportunityPosition must be one of: ${JOURNEY_OPPORTUNITY_POSITION_VALUES.join(", ")}`,
+        });
+      }
+      for (const 欄 of ["at", "点の位置"] as const) {
+        if (ao[欄] === undefined) continue;
+        const at = ao[欄];
+        if (
+          !Array.isArray(at) ||
+          at.length !== 2 ||
+          at.some((v) => typeof v !== "number" && typeof v !== "string")
+        ) {
+          errors.push({
+            path: `$.actors[${i}].${欄}`,
+            message: `actor.${欄} must be [x, y] with number or state reference values`,
+          });
+        }
+      }
       // 箱の中に描く図形の中身を、記法と同じ表で見る (#1374)
       validateActorShape(ao.shape, `$.actors[${i}].shape`, errors);
       // 見本 (parts) にしか効かない項目は、見本でない箱に書かれたら誤りにする (#1294)。
@@ -2387,6 +3524,44 @@ function validateJson(
       checkUnknownKeys(so, "step", `$.flow[${i}]`, errors);
       // 値そのものの型は表が見る (#1304)。 色と線種は engine の一覧と突き合わせる
       表で検査(so, "step", `$.flow[${i}]`, "step", errors);
+      if (so.labelCollision !== undefined && !(LABEL_COLLISION_VALUES as readonly unknown[]).includes(so.labelCollision)) {
+        errors.push({ path: `$.flow[${i}].labelCollision`, message: `labelCollision must be one of: ${LABEL_COLLISION_VALUES.join(", ")}` });
+      }
+      if (
+        so.labelSize !== undefined &&
+        (!so.labelSize || typeof so.labelSize !== "object" || Array.isArray(so.labelSize))
+      ) {
+        errors.push({ path: `$.flow[${i}].labelSize`, message: "labelSize must be an object" });
+      } else if (so.labelSize !== undefined) {
+        const size = so.labelSize as Record<string, unknown>;
+        for (const key of Object.keys(size)) if (!["width", "height", "fontSize"].includes(key)) errors.push({ path: `$.flow[${i}].labelSize.${key}`, message: `unknown key "${key}"` });
+        for (const key of ["width", "height", "fontSize"]) if (size[key] !== undefined && (typeof size[key] !== "number" || !Number.isFinite(size[key]) || size[key] <= 0)) errors.push({ path: `$.flow[${i}].labelSize.${key}`, message: "must be a positive finite number" });
+      }
+      if (so.waypoints !== undefined) {
+        const path = `$.flow[${i}].waypoints`;
+        if (!Array.isArray(so.waypoints)) errors.push({ path, message: "waypoints must be an array" });
+        else {
+          const points: Array<{ x: number; y: number }> = [];
+          so.waypoints.forEach((point, pointIndex) => {
+            const pointPath = `${path}[${pointIndex}]`;
+            if (!point || typeof point !== "object" || Array.isArray(point)) {
+              errors.push({ path: pointPath, message: "waypoint must be an object" });
+              return;
+            }
+            const value = point as Record<string, unknown>;
+            for (const key of Object.keys(value)) if (key !== "x" && key !== "y") errors.push({ path: `${pointPath}.${key}`, message: `unknown key "${key}"` });
+            if (typeof value.x !== "number" || !Number.isFinite(value.x) || typeof value.y !== "number" || !Number.isFinite(value.y)) errors.push({ path: pointPath, message: "waypoint x and y must be finite numbers" });
+            else points.push({ x: value.x, y: value.y });
+          });
+          const ends = [so.posX1, so.posY1, so.posX2, so.posY2];
+          if (ends.every((value) => typeof value === "number" && Number.isFinite(value)) && points.length === so.waypoints.length) {
+            const all = [{ x: so.posX1 as number, y: so.posY1 as number }, ...points, { x: so.posX2 as number, y: so.posY2 as number }];
+            all.forEach((point, pointIndex) => {
+              if (pointIndex > 0 && point.x !== all[pointIndex - 1]!.x && point.y !== all[pointIndex - 1]!.y) errors.push({ path: `${path}[${Math.min(pointIndex - 1, points.length - 1)}]`, message: "each waypoint segment must be orthogonal" });
+            });
+          }
+        }
+      }
       // CAR-1693 Phase 1: step DSL 表面 pos の validation
       validateLayoutPos(so.pos, `$.flow[${i}].pos`, errors);
     });
@@ -2423,11 +3598,38 @@ function validateJson(
   }
   validateStates(j.states, errors);
   validateValues(j.values, errors);
+  validateChartPresentationFields(j, errors);
   validateAxes(j.axes, errors);
+  validateRegions(j.regions, errors);
   if (errors.length > 0) return { ok: false, errors };
   return { ok: true, data: j as unknown as DragonJson };
 }
 
+/** 最上位の `shape` を記法と同じ図種別の集合で検査する (#2797)。 */
+function validateDiagramShape(j: Record<string, unknown>, errors: JsonDslError[]): void {
+  if (j.shape === undefined) return;
+  if (typeof j.shape !== "string" || typeof j.type !== "string") return;
+  const 別名 = TYPE_ALIASES.get(j.type);
+  const type = 別名?.type ?? (PRESET_TYPES.has(j.type as PresetType) ? (j.type as PresetType) : null);
+  if (type === null) return;
+  const shape = resolveDiagramShape(j.shape);
+  const 図種の語 = shapesForDiagramType(type);
+  // 語そのものの誤りは `欄の型表` が同じ集合から伝える。 ここでは図種との組だけを見る。
+  if (shape === null) return;
+  if (shape !== null && (type !== "chart" || 図種の語.includes(shape))) return;
+  const hint =
+    図種の語.length > 0
+      ? `使える語 = ${図種の語.join(" / ")}`
+      : `shape を書ける図種と語 = ${Object.entries(DIAGRAM_SHAPES)
+          .map(([図種, 語]) => `type: ${図種} (${語.join(" / ")})`)
+          .join(" / ")}`;
+  errors.push({
+    path: "$.shape",
+    message: `shape is not valid for type: ${type}`,
+    hint,
+  });
+}
+
 /**
  * 段の中で値を動かす指定を見る (#1186)。
  *
@@ -2553,6 +3755,20 @@ function validateValues(v: unknown, errors: JsonDslError[]): void {
   }
 }
 
+/**
+ * 段の説明を取り出す (#2621)。 受ける語は `PHASE_BODY_KEYS` が持つ。
+ *
+ * **正の語 (`body`) を先に見る**。 表の先頭が正の語なので、並び順のまま最初に値を持つ語を
+ * 採れば「どちらが効くか」 の規則を別に書かなくて済む。
+ */
+function 段の説明(p: JsonPhase): string | undefined {
+  for (const key of PHASE_BODY_KEYS) {
+    const v = p[key];
+    if (typeof v === "string") return v;
+  }
+  return undefined;
+}
+
 /**
  * 図表の箱の上の小見出しを、 記法側と同じ形に整える (#1247)。
  *
@@ -2606,6 +3822,7 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
     // 色は記法と同じ振り分けを通す (#1294)。 `#` で始まれば色番号、それ以外は色の名前。
     // 別々に書くと、同じ値が入口によって色番号にも色名にもなる
     const 色 = a.color !== undefined ? splitColorValue(a.color) : {};
+    const 書いた座標 = a.at ?? a.点の位置;
     return {
       name: a.name,
       kind: isPart ? "actor" : resolveNodeKind(kindStr),
@@ -2613,12 +3830,33 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
       // 「書かなかった」 と同じ扱いにする (#1058)
       kindWritten: a.kind !== undefined && !isPart,
       subtitle: a.subtitle,
+      kindForm: isPart ? undefined : a.kindForm,
+      icon: isPart ? undefined : a.icon,
+      emptyRowsNote: isPart ? undefined : a.emptyRowsNote,
+      titleAlign: isPart ? undefined : a.titleAlign,
+      rowRules: isPart ? undefined : a.rowRules,
+      rowStripe: isPart ? undefined : a.rowStripe,
+      rowLayout: isPart ? undefined : a.rowLayout,
+      rowDividerForm: isPart ? undefined : a.rowDividerForm,
+      rowWell: isPart ? undefined : a.rowWell,
+      rowMarkForm: isPart ? undefined : a.rowMarkForm,
+      nestIn: isPart ? undefined : a.nestIn,
+      figureCard: isPart ? undefined : a.figureCard,
+      stationNamePosition: a.stationNamePosition,
+      subtitlePlacement: a.subtitlePlacement,
+      titleFontSize: a.titleFontSize,
+      markGap: a.markGap,
       eyebrow: a.eyebrow,
       value: a.value,
       previous: a.previous,
       rows: a.rows,
-      // 行頭の印 (#1466)。 行と対で読む
-      marks: a.marks,
+      // 行頭の印 (#1466)。 行と対で読む。 古い語は記法と同じ関数で読み替える (#2782)
+      marks: a.marks?.map((m) =>
+        typeof m === "string"
+          ? 行頭の語へ読み替える(m)
+          : { mark: 行頭の語へ読み替える(m.mark), ...(m.tone === undefined ? {} : { tone: m.tone }) },
+      ),
+      stage: isPart ? undefined : a.stage,
       lane: a.lane,
       stack: a.stack,
       initial: a.initial,
@@ -2642,8 +3880,17 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
             tone: resolveTone(a.tone) ?? 色.tone,
             owner: a.owner,
             end: a.end,
+            startLabel: a.startLabel,
+            milestone: a.milestone,
+            emphasis: a.emphasis,
+            at:
+              書いた座標 === undefined
+                ? undefined
+                : { x: 書いた座標[0], y: 書いた座標[1], raw: `[${書いた座標.join(", ")}]` },
+            atPos: 書いた座標 === undefined ? undefined : 位置("actors", i, a.at ? "at" : "点の位置"),
             touchpoint: a.touchpoint,
             opportunity: a.opportunity,
+            opportunityPosition: a.opportunityPosition,
           }),
       colorHex: 色.hex,
       // 部品に書いた色の名前は効かない。 記法と同じく書いた名前として残し、組み立て側が知らせる (#1973)
@@ -2666,8 +3913,17 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
       pos: 位置("actors", i),
     };
   });
-  // 図の配色 (#1553)。 解くのは 1 度だけにする
-  const 配色 = json.palette === undefined ? null : resolvePalette(json.palette);
+  // 図の意匠 (#1553 / #2790)。 正の語と別名を別々に解き、順番に依らず `theme` を優先する
+  const 意匠 = json.theme === undefined ? null : resolveTheme(json.theme);
+  const 別名の意匠 = json.palette === undefined ? null : resolveTheme(json.palette);
+  const 選んだ意匠 = 意匠 ?? 別名の意匠;
+  const 並び順 = json.order === undefined ? null : resolveOrder(json.order);
+  const 形 = json.shape === undefined ? null : resolveDiagramShape(json.shape);
+  const legend = json.legend?.flatMap((item) => {
+    if (item.mark === undefined) return [item];
+    const mark = resolveLegendMark(item.mark);
+    return mark === null ? [] : [{ ...item, mark } as CdlLegendItem];
+  });
 
   const flow: DslStep[] = json.flow.map((s, i) => ({
     no: i + 1,
@@ -2676,13 +3932,15 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
     label: s.label,
     sub: s.sub,
     side: s.side,
+    fromSide: s.fromSide,
+    toSide: s.toSide,
     // 矢印の先の形 (#1462)。 読めない語は組み立てが落とす
     head: s.head,
     // 端の印の残り 3 欄と、関係の語 / 言づての種類 (#1466)
     tailHead: s.tailHead,
     headFill: s.headFill,
     tailHeadFill: s.tailHeadFill,
-    // クラス図の出どころ側の多重度 (#1771)
+    // UML 関係の出どころ側の多重度 (#1771 / #2783)
     tailSub: s.tailSub,
     relation: s.relation,
     // 辺の役目と名前の下地 (cdl#618)
@@ -2701,6 +3959,13 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
     dashOffsetBind: s.dashOffsetBind,
     labelOffsetX: s.labelOffsetX,
     labelOffsetY: s.labelOffsetY,
+    posX1: s.posX1,
+    posY1: s.posY1,
+    posX2: s.posX2,
+    posY2: s.posY2,
+    waypoints: s.waypoints,
+    labelCollision: s.labelCollision,
+    labelSize: s.labelSize,
     overlay: s.overlay,
     // 部品の端で繋ぐ要素の id (#1979)。 書かない矢印には欄を足さない = 記法と同じ形になる
     ...(s.fromPartNode !== undefined ? { fromPartNode: s.fromPartNode } : {}),
@@ -2763,7 +4028,7 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
     name: p.step,
     durationMs: Math.round((p.duration ?? 1.4) * 1000),
     highlight: p.focus,
-    body: p.body,
+    body: 段の説明(p),
     badge: p.badge,
     // 書いた段だけが欄を持つ。 空文字を置くと「書いた」 と「書いていない」 が同じ形になる
     ...(p.draw !== undefined ? { draw: p.draw, drawPos: 位置("animation", i, "draw") } : {}),
@@ -2799,9 +4064,82 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
         // `states` を指す = どちらも「動きを書き始めた場所」 になる
         { states, phases, pos: phases.length > 0 ? 位置("animation") : 位置("states") }
       : undefined;
+  // **別名は記法と同じ表で開く** (#2655 / #2657)。 開いた後は古い綴りが残らない。
+  //
+  // **開く語を 1 つずつ書く** = 表の値をそのまま広げると、持たない語が `undefined` の
+  // まま欄に載り、後ろの `...(形 !== null ? ...)` を打ち消す (実測 = `type: "pie"` の
+  // JSON が形を持たず、書かない時の形 (棒) の図になった)
+  const 別名 = TYPE_ALIASES.get(json.type);
+  const form = json.form ?? json.見せ方;
+  const ticks = json.ticks ?? json.目盛り;
   return {
     title: json.title,
-    type: json.type,
+    type: 別名?.type ?? (json.type as PresetType),
+    ...(form !== undefined
+      ? { form, formPos: 位置(json.form !== undefined ? "form" : "見せ方") }
+      : {}),
+    ...(ticks !== undefined
+      ? { ticks: [...ticks], ticksPos: 位置(json.ticks !== undefined ? "ticks" : "目盛り") }
+      : {}),
+    ...(json.ganttToday !== undefined ? { ganttToday: json.ganttToday } : {}),
+    ...(json.ganttTickLabels !== undefined ? { ganttTickLabels: [...json.ganttTickLabels] } : {}),
+    ...(json.ganttBarEnd !== undefined ? { ganttBarEnd: json.ganttBarEnd } : {}),
+    ...(json.ganttBarThickness !== undefined ? { ganttBarThickness: json.ganttBarThickness } : {}),
+    ...(json.chartSeriesSkipMuted !== undefined ? { chartSeriesSkipMuted: json.chartSeriesSkipMuted } : {}),
+    ...(json.chartLineSeries !== undefined ? { chartLineSeries: json.chartLineSeries } : {}),
+    ...(json.chartPieCenterLabel !== undefined ? { chartPieCenterLabel: json.chartPieCenterLabel } : {}),
+    ...(json.chartPieTableColumns !== undefined ? { chartPieTableColumns: json.chartPieTableColumns } : {}),
+    ...(json.chartPieRingWidth !== undefined ? { chartPieRingWidth: json.chartPieRingWidth } : {}),
+    ...(json.chartSlopePeriods !== undefined ? { chartSlopePeriods: json.chartSlopePeriods } : {}),
+    ...(json.chartSlopeEmphasisIds !== undefined ? { chartSlopeEmphasisIds: json.chartSlopeEmphasisIds } : {}),
+    ...(json.chartSlopeUnit !== undefined ? { chartSlopeUnit: json.chartSlopeUnit } : {}),
+    ...(json.chartStackedPeriods !== undefined ? { chartStackedPeriods: json.chartStackedPeriods } : {}),
+    ...(json.chartStackedRateId !== undefined ? { chartStackedRateId: json.chartStackedRateId } : {}),
+    ...(json.chartStackedLegendPosition !== undefined ? { chartStackedLegendPosition: json.chartStackedLegendPosition } : {}),
+    ...(json.chartGaugeValue !== undefined ? { chartGaugeValue: json.chartGaugeValue } : {}),
+    ...(json.chartWaffleLegendPosition !== undefined ? { chartWaffleLegendPosition: json.chartWaffleLegendPosition } : {}),
+    ...(json.funnelForm !== undefined ? { funnelForm: json.funnelForm } : {}),
+    ...(json.funnelRate !== undefined ? { funnelRate: json.funnelRate } : {}),
+    ...(json.quadrantPointLabelSide !== undefined ? { quadrantPointLabelSide: json.quadrantPointLabelSide } : {}),
+    ...(json.treeNodeForm !== undefined ? { treeNodeForm: json.treeNodeForm } : {}),
+    ...(json.treeSize !== undefined ? { treeSize: json.treeSize } : {}),
+    ...(json.treeEdgeTone !== undefined ? { treeEdgeTone: json.treeEdgeTone } : {}),
+    ...(json.treeEdgeHead !== undefined ? { treeEdgeHead: json.treeEdgeHead } : {}),
+    ...(json.mindForm !== undefined ? { mindForm: json.mindForm } : {}),
+    ...(json.mindSize !== undefined ? { mindSize: json.mindSize } : {}),
+    ...(json.edgeEndGap !== undefined ? { edgeEndGap: json.edgeEndGap } : {}),
+    ...(json.journeyForm !== undefined ? { journeyForm: json.journeyForm } : {}),
+    ...(json.journeyLineForm !== undefined ? { journeyLineForm: json.journeyLineForm } : {}),
+    ...(json.journeyLabels !== undefined ? { journeyLabels: json.journeyLabels } : {}),
+    ...(json.journeySize !== undefined ? { journeySize: json.journeySize } : {}),
+    ...(json.sequenceActorForm !== undefined ? { sequenceActorForm: json.sequenceActorForm } : {}),
+    ...(json.sequenceLabelForm !== undefined ? { sequenceLabelForm: json.sequenceLabelForm } : {}),
+    ...(json.sequenceReturnHead !== undefined ? { sequenceReturnHead: json.sequenceReturnHead } : {}),
+    ...(json.sequenceKindLabels !== undefined ? { sequenceKindLabels: json.sequenceKindLabels } : {}),
+    ...(json.sequenceRowGap !== undefined ? { sequenceRowGap: json.sequenceRowGap } : {}),
+    ...(json.sequenceGutter !== undefined ? { sequenceGutter: json.sequenceGutter } : {}),
+    ...(json.sequenceBandWidth !== undefined ? { sequenceBandWidth: json.sequenceBandWidth } : {}),
+    ...(json.sequenceSelfLoop !== undefined ? { sequenceSelfLoop: json.sequenceSelfLoop } : {}),
+    ...(json.figureCard !== undefined ? { figureCard: json.figureCard } : {}),
+    ...(json.figureSize !== undefined ? { figureSize: json.figureSize } : {}),
+    ...(json.terminalDecoration !== undefined ? { terminalDecoration: json.terminalDecoration } : {}),
+    ...(json.cornerForm !== undefined ? { cornerForm: json.cornerForm } : {}),
+    ...(json.figureKindLabel !== undefined ? { figureKindLabel: json.figureKindLabel } : {}),
+    ...(json.figureInset !== undefined ? { figureInset: json.figureInset } : {}),
+    ...(json.chartBarSize !== undefined ? { chartBarSize: json.chartBarSize } : {}),
+    ...(json.chartBarShape !== undefined ? { chartBarShape: json.chartBarShape } : {}),
+    ...(json.chartLineSize !== undefined ? { chartLineSize: json.chartLineSize } : {}),
+    ...(json.chartPieSize !== undefined ? { chartPieSize: json.chartPieSize } : {}),
+    ...(json.chartWaffleSize !== undefined ? { chartWaffleSize: json.chartWaffleSize } : {}),
+    ...(json.chartSlopeLabelTemplate !== undefined ? { chartSlopeLabelTemplate: json.chartSlopeLabelTemplate } : {}),
+    ...(json.chartSlopeSize !== undefined ? { chartSlopeSize: json.chartSlopeSize } : {}),
+    ...(json.chartStackedLayout !== undefined ? { chartStackedLayout: json.chartStackedLayout } : {}),
+    ...(json.chartGaugeSize !== undefined ? { chartGaugeSize: json.chartGaugeSize } : {}),
+    ...(json.ganttSize !== undefined ? { ganttSize: json.ganttSize } : {}),
+    ...(json.quadrantLabelPosition !== undefined ? { quadrantLabelPosition: json.quadrantLabelPosition } : {}),
+    ...(json.quadrantSize !== undefined ? { quadrantSize: json.quadrantSize } : {}),
+    ...(別名?.order !== undefined ? { order: 別名.order, orderPos: 位置("type") } : {}),
+    ...(別名?.shape !== undefined ? { shape: 別名.shape, shapePos: 位置("type") } : {}),
     // 前後の空白を落としてから見る。 記法側 (`v05/parser.ts`) が `trim()` してから
     // 空かどうかを判定するため、 揃えないと **空白だけの値で入口ごとに図が変わる**
     // (記法は書かなかった扱い、 JSON は中身のない帯を描く。 Round 2 の指摘で実測)
@@ -2813,6 +4151,14 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
     ...(json.axes && (json.axes.x !== undefined || json.axes.y !== undefined)
       ? { axes: json.axes, axesPos: 位置("axes") }
       : {}),
+    // 区画の名前 (#2667)。 鍵は記法と同じ 4 語なので、描画側の綴りへここで直す
+    ...(区画の名前を直す(json.regions) === undefined
+      ? {}
+      : { regions: 区画の名前を直す(json.regions) }),
+    ...(json.legendFontSize !== undefined ? { legendFontSize: json.legendFontSize } : {}),
+    ...(json.legendOffset !== undefined ? { legendOffset: json.legendOffset } : {}),
+    ...(json.stageHeader !== undefined ? { stageHeader: json.stageHeader } : {}),
+    ...(json.stageLayout !== undefined ? { stageLayout: json.stageLayout } : {}),
     actors,
     flow,
     animate,
@@ -2863,9 +4209,22 @@ export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): Dsl
           directionPos: 位置("direction"),
         }
       : {}),
-    // 図の配色 (#1553)。 記法と同じ解決を通す = 別名 (`生成り` / `青磁`) の受け方がずれない。
-    // 読めない語は渡さない = 上流の型検査が語を絞っているので、ここに来るのは書き間違いだけ
-    ...(配色 !== null ? { palette: 配色 } : {}),
+    // 箱を並べ替える軸 (#2655)。 向きと同じく英語で書くので、記法と同じ解決を通して日本語に直す。
+    // 読めない語は渡さない = 公開 schema の語の一覧が絞っているので、ここに来るのは書き間違いだけ
+    ...(並び順 !== null ? { order: 並び順, orderPos: 位置("order") } : {}),
+    // 数を描く図の形 (#2657)。 記法と同じ解決を通す = 受ける語がずれない
+    ...(形 !== null ? { shape: 形, shapePos: 位置("shape") } : {}),
+    // 図の意匠 (#1553 / #2790)。 dragon の文書では `theme`、cdl の図へ載せる時は `palette` とする
+    ...(選んだ意匠 !== null ? { theme: 選んだ意匠 } : {}),
+    ...(legend && legend.length > 0 ? { legend } : {}),
+    ...(意匠 !== null && 別名の意匠 !== null
+      ? {
+          themeAlsoPalettePos: {
+            themeLine: 位置("theme").line,
+            paletteLine: 位置("palette").line,
+          },
+        }
+      : {}),
     pos: 位置(),
   };
 }