@cardenelabs/dragon 0.28.0 → 0.32.0

package/src/json-parser.ts

@@ -6,7 +6,7 @@
  * で確実に生成できるよう、 flat な object array を優先した shape になっている。
  *
  * 使い方 (LLM):
- *   1. `packages/dragon/schemas/diagram.json` の JSON Schema を LLM の tool schema に注入
+ *   1. `packages/dragon/src/schemas/diagram.json` の JSON Schema を LLM の tool schema に注入
  *   2. LLM が JSON を返す
  *   3. `jsonToDiagram(json)` で CdlDiagram に変換
  *   4. validation error は throw、 retry loop で LLM に修正させる
@@ -24,6 +24,7 @@ import {
   EDGE_HEAD_VALUES,
   NODE_KIND_VALID,
   PRESET_TYPES,
+  TYPE_ALIASES,
   STYLE_VALID,
   resolveNodeKind,
   resolveTone,
@@ -34,15 +35,69 @@ 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,
@@ -56,6 +111,8 @@ import type {
 import { extractIdentifiers, parseFormula } from "@cardenelabs/cdl";
 import type {
   DslDocument,
+  DslStageHeader,
+  DslRegions,
   DslActor,
   DslStep,
   DslAnimate,
@@ -71,7 +128,18 @@ import type {
   DslDynShape,
 } from "./types";
 import { checkValueExpression, isValueName, valueNameIssue } from "./value-syntax";
+import { 近い名前 } from "./near-name";
+import { 書いた場所の鍵, type 書いた行の表 } from "./json-line-map";
 import { compileToCdl } from "./compile";
+import {
+  RELATIVE_DIRECTIONS,
+  findRelativeProblems,
+  type RelativeDirection,
+  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。
@@ -79,12 +147,84 @@ import { compileToCdl } from "./compile";
 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` に書く。
    */
@@ -98,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, ... } */
@@ -174,6 +327,8 @@ export interface DragonJson {
       x?: number;
       width?: number;
       label?: string;
+      /** 路線図の担当の名札で、名前の下へ出す補足。 */
+      subtitle?: string;
       contain?: boolean;
       lifeline?: boolean;
       /**
@@ -199,16 +354,34 @@ 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[];
+}
+
+/**
+ * 位置を他の要素からの相対で書く指定の、JSON 側の形 (#2039)。
+ *
+ * 記法の `位置: Web の右 200` を 3 つの欄に開いたもの。 内側の値は `RelativePos` と同じで、
+ * 向きの語も同じ 4 つ (`right` / `left` / `above` / `below`) を使う。
+ *
+ * **向きの語を並べ直さない**。 `RelativeDirection` をそのまま使うことで、本文側に向きを
+ * 足した時に JSON 側が黙って取り残される形を作らない。
+ */
+export interface JsonRelativePos {
+  /** 基準にする相手の名前。 `actors:` に書かれた名前をそのまま書く */
+  anchor: string;
+  /** 基準からどちら側に置くか */
+  dir: RelativeDirection;
+  /** 相手との間隔。 書かなければ `RELATIVE_GAP_DEFAULT` */
+  gap?: number;
 }
 
 export interface JsonActor {
@@ -239,14 +412,31 @@ export interface JsonActor {
   renderOffsetX?: number | string;
   renderOffsetY?: number | string;
   /**
-   * CAR-1657 unified syntax = 既存 NodeKind (28 個) に加えて parts identifier (arc-gauge 等) を
-   * accept する。 未知 kind 値は parts 候補として partId に格納、 compile 側 partsCatalog で解決。
+   * CAR-1657 unified syntax = 既存 NodeKind (一覧は `v05/parser.ts` の `NODE_KIND_VALID`) に
+   * 加えて parts identifier (arc-gauge 等) を accept する。
+   * 未知 kind 値は parts 候補として partId に格納、 compile 側 partsCatalog で解決。
    * LLM structured output の typing 制約を緩めるため union に string 追加。
    * `string & {}` = NodeKind の候補を IDE 補完で提示しつつ任意 string も許容する idiom。
    * 素の `NodeKind | string` は no-redundant-type-constituents に抵触し補完も潰れる (#865)。
    */
   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;
   /**
@@ -257,6 +447,8 @@ export interface JsonActor {
    */
   previous?: string;
   rows?: string[];
+  /** 段階ごとの箱で、この箱を入れる段階。 記法の `stage` / `段階` と同じ (#2797)。 */
+  stage?: string;
   lane?: string;
   stack?: number;
   initial?: boolean;
@@ -266,6 +458,17 @@ export interface JsonActor {
    * と同じで、読み方は `DslActor.layoutPos` が持つ。
    */
   pos?: LayoutPos;
+  /**
+   * 位置を他の要素からの相対で書く指定 (#2039)。 記法の `位置: Web の右 200` と同じ。
+   *
+   * 記法は 1 本の文字列に「誰の」「どちら側に」「どれだけ離して」 を詰めるが、JSON では
+   * 3 つの欄に分ける。 文字列を組み立てて渡す形にすると、書く側が記法の並び順と区切りを
+   * 覚える必要が出る = JSON を書くのは主に LLM で、読み取りの規則は欄の名前で示す方が短い。
+   *
+   * 組み立ての段階で基準の実座標から `posX` / `posY` に直すため、解決した後は座標を直接
+   * 書いた時と同じ経路を通る。 `pos` (配置後のずらし幅) とは別の欄。
+   */
+  posRel?: JsonRelativePos;
   /**
    * CAR-1657 parts state override (kind = parts identifier 時のみ有効)。
    * LLM JSON DSL では nested 明示 = `{ "state": { "v": 50 } }` が natural、 human 側の
@@ -301,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:` と同じ。
    *
@@ -325,14 +536,33 @@ export interface JsonActor {
    * 読めない項目名として知らせる)。
    */
   scale?: number;
+  /**
+   * 見本が持つ段を使うか (#2125)。 記法の `{ kind: wave-gauge, phase: false }` と同じ。
+   *
+   * 既定 (書かない) は見本の段を書いた段と番号ごとに並べて再生する。 `false` を書くと
+   * 見本の段の中身 (点灯と値の変化) を空にし、値は書いた段だけが動かす。
+   *
+   * 見本 (parts) にしか効かない。 中身は状態の上書き (`state`) に `phase` として入る =
+   * `"state": { "phase": false }` と同じ所へ届く。 記法が中括弧の中に 1 つの名前として
+   * 書ける以上、JSON でも同じ名前で書けるようにする (入口で書き方が分かれない)。
+   */
+  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 {
@@ -342,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 }` と同じ。
    *
@@ -353,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 }` と同じ。
@@ -363,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;
@@ -385,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;
   /**
@@ -408,6 +647,13 @@ export interface JsonPhase {
   focus?: string[];
   /** body 説明文 */
   body?: string;
+  /**
+   * 説明文の別名 (#2621)。 記法が `description:` を受けるので JSON でも受ける。
+   *
+   * **正の語は `body`**。 両方書いた段は `body` を採る = 正の語を優先すると決めておくと、
+   * 読み手が「どちらが効くのか」 を実装を読まずに判断できる。
+   */
+  description?: string;
   /** badge label */
   badge?: string;
   /**
@@ -451,11 +697,13 @@ export interface JsonDslError {
  * 受け付ける種類 (`kind`)。 **記法側と同じ集合を使う** (`v05/parser.ts` の `NODE_KIND_VALID`)。
  *
  * ここに無い値は見本 (parts) の名前とみなし、`partId` へ退避して箱を `actor` に倒す
- * (CAR-1657 の unified syntax)。 つまりこの集合が小さいほど、**書いた種類が黙って消える**。
+ * (CAR-1657 の unified syntax)。 つまりこの集合が小さいほど、**書いた種類が箱の見た目に効かなくなる**。
+ * 部品を持つ一覧を渡した組み立てでは一覧に無い名前を知らせる (`part-not-found`、#2113) が、
+ * 一覧を渡さない組み立てと部品を持たない一覧の組み立てでは `console.warn` にしか残らない。
  *
  * 以前はここに一覧を写していたため、記法に種類が増えても JSON 経路が古い一覧のまま
  * 見本の名前として扱った (実測 = 記法が知る 108 種のうち 77 種が該当、`shape-*` は全滅)。
- * カタログに無い名前は `console.warn` にしか残らず `onNotice` を呼ばないため、
+ * 当時はカタログに無い名前が `console.warn` にしか残らず `onNotice` を呼ばなかったため、
  * 画面には何も出ないまま `actor` の箱が描かれていた (#1293)。
  *
  * 型が 2 箇所に散らばると、必ずどちらかが古くなる。 `VALID_PRESETS` (図種) と同じ扱いにする。
@@ -470,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 との
  * 突き合わせが、どちらもここを見る**。
@@ -487,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",
@@ -514,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",
@@ -534,8 +878,14 @@ export const ACCEPTED_KEYS = {
     "color",
     "owner",
     "end",
+    "startLabel",
+    "milestone",
+    "emphasis",
+    "at",
+    "点の位置",
     "touchpoint",
     "opportunity",
+    "opportunityPosition",
     "posX",
     "posY",
     "posW",
@@ -557,6 +907,10 @@ export const ACCEPTED_KEYS = {
     "renderOffsetY",
     // 行頭の印 (#1466)。 行ごとに 1 つ、図の種類ごとの語で書く
     "marks",
+    // 位置を他の要素からの相対で書く指定 (#2039)
+    "posRel",
+    // 見本が持つ段を使うか (#2125)
+    "phase",
   ],
   step: [
     "from",
@@ -565,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)
@@ -588,20 +944,32 @@ 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"],
 } as const satisfies Record<string, readonly string[]>;
 
 /** 受ける項目を持つ階層の名前 */
@@ -643,8 +1011,18 @@ export type 欄の型 =
   | "線種"
   | "辺"
   | "端の形"
+  // 相対で置く時の向き (#2039)。 書けば必ず要る = 向きが無いとどちら側か決まらない
+  | "必須の向き"
   | "色か色番号"
   | "描くもの"
+  | "意匠"
+  | "図の形"
+  | "ガントの帯の終わり"
+  | "ガントの帯の厚み"
+  | "札の角"
+  | "四象限の区画名位置"
+  | "線札の衝突"
+  | "主役"
   | "必須の図種"
   | "object"
   | "並び"
@@ -655,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",
@@ -682,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: "真偽",
@@ -701,8 +1168,14 @@ export const 欄の型表 = {
     color: "色か色番号",
     owner: "文字列",
     end: "文字列",
+    startLabel: "文字列",
+    milestone: "真偽",
+    emphasis: "主役",
+    at: "並び",
+    点の位置: "並び",
     touchpoint: "文字列",
     opportunity: "文字列",
+    opportunityPosition: "文字列",
     posX: "数",
     posY: "数",
     posW: "数",
@@ -723,7 +1196,11 @@ export const 欄の型表 = {
     renderOffsetX: "数か文字列",
     renderOffsetY: "数か文字列",
     // 行頭の印 (#1466)
-    marks: "文字列の並び",
+    marks: "並び",
+    // 相対で置く指定 (#2039)。 中身の形は `validateRelativePos` が見る
+    posRel: "object",
+    // 見本が持つ段を使うか (#2125)
+    phase: "真偽",
   },
   step: {
     from: "必須の文字列",
@@ -732,12 +1209,14 @@ export const 欄の型表 = {
     sub: "文字列",
     // 矢印がどの辺から出るか (#1385)
     side: "辺",
+    fromSide: "辺",
+    toSide: "辺",
     head: "端の形",
     // 端の印の残り 3 欄と、関係の語 / 言づての種類 (#1466)
     tailHead: "端の形",
     headFill: "非空の文字列",
     tailHeadFill: "非空の文字列",
-    // クラス図の出どころ側の多重度 (#1771)
+    // UML 関係の出どころ側の多重度 (#1771 / #2783)
     tailSub: "文字列",
     relation: "非空の文字列",
     // 辺の役目と名前の下地 (cdl#618)
@@ -754,6 +1233,13 @@ export const 欄の型表 = {
     dashOffsetBind: "非空の文字列",
     labelOffsetX: "数",
     labelOffsetY: "数",
+    posX1: "数",
+    posY1: "数",
+    posX2: "数",
+    posY2: "数",
+    waypoints: "並び",
+    labelCollision: "線札の衝突",
+    labelSize: "object",
     overlay: "真偽",
     pos: "object",
     // 部品の端で繋ぐ要素の id (#1979)。 空の id は要素を指せないので受けない
@@ -764,7 +1250,9 @@ export const 欄の型表 = {
     step: "必須の非空文字列",
     duration: "数",
     focus: "文字列の並び",
+    // 説明は正の語と別名のどちらでも同じ型。 表の欄は `ACCEPTED_KEYS.phase` と揃える (#2621)
     body: "文字列",
+    description: "文字列",
     badge: "文字列",
     tween: "object",
     set: "object",
@@ -774,6 +1262,7 @@ export const 欄の型表 = {
   viewport: {
     width: "数",
     height: "数",
+    contentOffsetX: "数",
     scale: "数",
     laneWidth: "数",
     gap: "数",
@@ -785,16 +1274,20 @@ 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)。 相手と向きは必ず要り、間隔は書かなければ既定で置く
+  posRel: { anchor: "必須の非空文字列", dir: "必須の向き", gap: "数" },
 } as const satisfies {
   [層 in 階層]: { [欄 in (typeof ACCEPTED_KEYS)[層][number]]: 欄の型 };
 };
@@ -839,6 +1332,8 @@ function JSONの色名か(v: string): boolean {
 export const 見本にしか効かない欄 = [
   "state",
   "scale",
+  // 見本が持つ段を使うか (#2125)。 普通の箱は自分の段を持たないので効かない
+  "phase",
 ] as const satisfies readonly (typeof ACCEPTED_KEYS.actor)[number][];
 
 /**
@@ -860,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)。 見本は自分の出方を持つ
@@ -962,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") {
@@ -997,6 +1540,17 @@ function 値を検査(
         });
       }
       return;
+    case "必須の向き":
+      // 受ける語は記法と同じ一覧を見る (`RELATIVE_DIRECTIONS`)。 写すと向きが増えた時に
+      // 片方だけ古くなる
+      if (typeof v !== "string" || !(RELATIVE_DIRECTIONS as readonly string[]).includes(v)) {
+        errors.push({
+          path,
+          message: `${名前} must be one of: ${RELATIVE_DIRECTIONS.join(", ")}`,
+          hint: typeof v === "string" ? `got "${v}"` : `got ${v === undefined ? "nothing" : typeof v}`,
+        });
+      }
+      return;
     case "端の形":
       if (v === undefined) return;
       // 受ける語は記法と同じ一覧を見る (`EDGE_HEAD_VALUES`)。 写すと描画側が形を増やした時に
@@ -1020,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") {
@@ -1046,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,
         });
       }
@@ -1086,48 +1665,6 @@ function 表で検査(
   }
 }
 
-/**
- * 綴り違いの候補を返す (#1295)。
- *
- * 「知らない項目です」 だけだと、`animations` と書いた人は正しい綴りを探しに行く必要がある。
- * 1 文字の違い (足りない / 多い / 入れ替わり / 別の字) までを候補とする。
- *
- * 遠い名前は勧めない。 無関係な項目名を勧めると、書いた人がそちらへ直して二度手間になる。
- */
-function 近い項目名(key: string, 候補: readonly string[]): string | undefined {
-  const 小文字 = key.toLowerCase();
-  let 最短: { 名: string; 距離: number } | undefined;
-  for (const c of 候補) {
-    const d = 編集距離(小文字, c.toLowerCase(), 2);
-    if (d <= 2 && (最短 === undefined || d < 最短.距離)) 最短 = { 名: c, 距離: d };
-  }
-  return 最短?.名;
-}
-
-/**
- * 2 つの語の編集距離 (上限付き)。
- *
- * 上限を持つのは、長い語どうしで表を全部埋めないため。 上限を超えた時点で打ち切る。
- */
-function 編集距離(a: string, b: string, 上限: number): number {
-  if (Math.abs(a.length - b.length) > 上限) return 上限 + 1;
-  let 前 = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1; i <= a.length; i += 1) {
-    const 今: number[] = [i];
-    let 行の最小 = i;
-    for (let j = 1; j <= b.length; j += 1) {
-      const 費用 = a[i - 1] === b[j - 1] ? 0 : 1;
-      const v = Math.min(今[j - 1]! + 1, 前[j]! + 1, 前[j - 1]! + 費用);
-      今.push(v);
-      if (v < 行の最小) 行の最小 = v;
-    }
-    // その行の最小が上限を超えたら、以降どう進んでも上限以下にはならない
-    if (行の最小 > 上限) return 上限 + 1;
-    前 = 今;
-  }
-  return 前[b.length]!;
-}
-
 /**
  * 知らない項目を誤りとして積む (#1295)。
  *
@@ -1139,7 +1676,7 @@ function checkUnknownKeys(v: unknown, 層: 階層, path: string, errors: JsonDsl
   const 受ける = ACCEPTED_KEYS[層] as readonly string[];
   for (const key of Object.keys(v)) {
     if (受ける.includes(key)) continue;
-    const 候補 = 近い項目名(key, 受ける);
+    const 候補 = 近い名前(key, 受ける);
     errors.push({
       path: `${path}.${key}`,
       message: `unknown key "${key}"`,
@@ -1148,10 +1685,6 @@ function checkUnknownKeys(v: unknown, 層: 階層, path: string, errors: JsonDsl
   }
 }
 
-/**
- * shape validation。 layer 1 = 必須 field + 型 check、 layer 2 は compile 側の validation に委譲。
- * fail-fast ではなく全 error 収集して返す (LLM に一括で修正させるため)。
- */
 /**
  * CAR-1693 Phase 1: DSL 表面 `pos: {x, y}` の型 check helper。 finite number pair を必須にし、
  * `NaN` / `Infinity` / non-number は reject する (組み立ての出口 `applyLayoutOffsets` が配置後の位置に足すため)。
@@ -1167,6 +1700,77 @@ function validateLayoutPos(v: unknown, path: string, errors: JsonDslError[]): vo
   表で検査(p, "layoutPos", path, "pos", errors);
 }
 
+/**
+ * 相対で置く指定の形を見る (#2039)。
+ *
+ * 相手の名前が実在するかはここでは見ない。 組み立て側 (`resolveRelativeDoc`) が figure 全体を
+ * 組んだ後に照合し、いない相手を指した時は知らせを出す。 入口ごとに別の場所で判定すると、
+ * 本文で書いた時と JSON で書いた時で返るものが変わる。
+ */
+function validateRelativePos(v: unknown, path: string, errors: JsonDslError[]): void {
+  if (v === undefined) return;
+  if (!v || typeof v !== "object" || Array.isArray(v)) {
+    errors.push({ path, message: "posRel must be an object with anchor and dir" });
+    return;
+  }
+  const p = v as Record<string, unknown>;
+  checkUnknownKeys(p, "posRel", path, errors);
+  表で検査(p, "posRel", path, "posRel", errors);
+}
+
+/**
+ * 図全体として相対の指定が解けるかを見る (#2039)。
+ *
+ * 判定は `relative-pos.ts` の `findRelativeProblems` が持つ。 記法側も同じ判定を呼ぶので、
+ * 同じ書き方が入口によって通ったり通らなかったりしない。
+ *
+ * 誤りの文だけをここで作る = 記法側は行番号を、こちらは欄の場所を添えるため。
+ */
+function validateRelativeAnchors(actors: readonly unknown[], errors: JsonDslError[]): void {
+  const items: Array<{ name: string; rel?: RelativePos }> = [];
+  const 場所 = new Map<string, number>();
+  actors.forEach((a, i) => {
+    if (!a || typeof a !== "object" || Array.isArray(a)) return;
+    const o = a as Record<string, unknown>;
+    if (typeof o.name !== "string") return;
+    const rel = o.posRel;
+    // 形の誤りは `validateRelativePos` が既に返している。 ここは形の整った指定だけを見る
+    const 整った =
+      rel !== null &&
+      typeof rel === "object" &&
+      !Array.isArray(rel) &&
+      typeof (rel as Record<string, unknown>).anchor === "string" &&
+      typeof (rel as Record<string, unknown>).dir === "string";
+    items.push({ name: o.name, rel: 整った ? (rel as RelativePos) : undefined });
+    if (!場所.has(o.name)) 場所.set(o.name, i);
+  });
+
+  const named = items.map((i) => i.name);
+  for (const p of findRelativeProblems(items)) {
+    const i = 場所.get(p.name) ?? 0;
+    errors.push({
+      path: `$.actors[${i}].posRel`,
+      ...(p.kind === "self"
+        ? {
+            message: `posRel.anchor must not be the actor itself: "${p.name}"`,
+            hint: "別の登場人物の名前を書く",
+          }
+        : p.kind === "missing-anchor"
+          ? {
+              message: `posRel.anchor must name an actor: "${p.anchor ?? ""}"`,
+              hint:
+                named.length > 0
+                  ? `actors に書かれている名前 = ${named.join(", ")}`
+                  : "actors に基準にする登場人物を書く",
+            }
+          : {
+              message: `posRel.anchor must not form a cycle: "${p.name}"`,
+              hint: "どれか 1 つは posX / posY か自動配置にする",
+            }),
+    });
+  }
+}
+
 /**
  * 見本 (parts) の名前として扱う値かどうか (#1294)。
  *
@@ -1196,22 +1800,13 @@ function validateViewport(v: unknown, errors: JsonDslError[]): void {
 }
 
 /**
- * 鍵を利用者が決める入れ物 (縦列 / 群) を見る (#1304)。
+ * 選択肢の組が受ける項目。 どれも必ず書く (#2258)。
  *
- * `lanes` / `groups` は id を鍵に持つため、鍵そのものは縛れない。 縛れるのは
- * 「入れ物が plain object か」 と「各 id の中身の項目名と値の型」 の 2 つ。
- *
- * #1304 まで外側の形が違う入力 (`lanes: 5`) は走査ごと飛ばされ、誤りが 1 件も返らなかった。
- * 形が違うものを黙って捨てると、書いた縦列が 1 つも効かない図が知らせなしで出る。
- */
-/**
- * 図形と部品の中身を、記法と **同じ表** で検査する (#1374)。
- *
- * 表を 2 つ持つと片方だけ直してずれる。 記法側 (`v05/parser.ts`) が持つ表をそのまま引く。
- *
- * 記法は値が全て文字列で届くため読み替えが要るが、JSON は型のまま届く。 ここでは
- * 「知らない種類」 「知らない欄」 「足りない必須の欄」 「欄の型違い」 の 4 つを見る。
+ * **判定と知らせが同じ集合を読む**。 別々に並べていた間、判定に項目を足しても
+ * 知らせは古い一覧を教え続ける形だった。
  */
+const 選択肢の項目 = ["value", "label"] as const;
+
 /**
  * 選択肢の並び (`["green", { "value": "red", "label": "失敗" }]`) を要素ごとに検査する (#1920)。
  *
@@ -1240,13 +1835,21 @@ function 選択肢の並びを検査する(値: unknown, path: string, errors: J
     }
     const 組 = x as Record<string, unknown>;
     for (const k of Object.keys(組)) {
-      if (k === "value" || k === "label") continue;
-      errors.push({ path: `${here}.${k}`, message: `unknown key "${k}"`, hint: "使える項目 = value, label" });
+      if ((選択肢の項目 as readonly string[]).includes(k)) continue;
+      errors.push({
+        path: `${here}.${k}`,
+        message: `unknown key "${k}"`,
+        hint: `使える項目 = ${選択肢の項目.join(", ")}`,
+      });
     }
-    for (const k of ["value", "label"] as const) {
+    for (const k of 選択肢の項目) {
       const v = 組[k];
       if (v === undefined) {
-        errors.push({ path: `${here}.${k}`, message: `${k} is required`, hint: "必須の項目 = value, label" });
+        errors.push({
+          path: `${here}.${k}`,
+          message: `${k} is required`,
+          hint: `必須の項目 = ${選択肢の項目.join(", ")}`,
+        });
       } else if (typeof v !== "string") {
         errors.push({ path: `${here}.${k}`, message: `${k} must be 文字列`, hint: `got ${v === null ? "null" : typeof v}` });
       } else if (v === "") {
@@ -1260,6 +1863,14 @@ function 選択肢の並びを検査する(値: unknown, path: string, errors: J
   });
 }
 
+/**
+ * 図形と部品の中身を、記法と **同じ表** で検査する (#1374)。
+ *
+ * 表を 2 つ持つと片方だけ直してずれる。 記法側 (`v05/parser.ts`) が持つ表をそのまま引く。
+ *
+ * 記法は値が全て文字列で届くため読み替えが要るが、JSON は型のまま届く。 ここでは
+ * 「知らない種類」 「知らない欄」 「足りない必須の欄」 「欄の型違い」 の 4 つを見る。
+ */
 function 表で中身を検査する(
   o: Record<string, unknown>,
   表: Record<string, 図形の定義>,
@@ -1344,18 +1955,30 @@ function 表で中身を検査する(
   }
 }
 
+/** 帯に書く相手の項目。 値が文字列で、他の 2 つと型が違う */
+const 帯の相手の項目 = ["actor"] as const;
+/** 帯に書く段の項目。 値が 0 以上の整数 */
+const 帯の段の項目 = ["from", "to"] as const;
 /**
- * 値を見せる部品の並びを検査する (#1374)。
+ * 帯が受ける項目。 判定と知らせの両方がここから作る (#2258)。
  *
- * **外側の形もここで見る**。 `欄の型表` は「並び」 とだけ宣言し、中身の検査は専用の検査に
- * 委ねる作りなので (`checkFieldType` の `case "並び"`)、ここで見ないと `readouts: 1` が
- * 素通りする。
+ * 公開 schema の `$.bands` も同じ 3 語を閉じた集合として宣言しており、
+ * `closed-level-coverage.test.ts` が両者の一致を見る。
  */
+export const 帯の項目: readonly string[] = [...帯の相手の項目, ...帯の段の項目];
+
 /**
  * 順序図の帯の並びを検査する (#1466)。
  *
  * **外側の形もここで見る**。 `欄の型表` は「並び」 とだけ宣言し、中身の検査は専用の検査に
  * 委ねる作りなので、ここで見ないと `bands: 1` が素通りする。
+ *
+ * ## 知らない項目も見る (#2262)
+ *
+ * 書いてある 3 つの型だけを見て、**知らない項目があるかを確かめていなかった**。
+ * 公開 schema は `$.bands` を閉じた階層として宣言しているので、
+ * schema を信じて書いた入力がこちらでは通り、schema 検証器では落ちる状態だった。
+ * 公開 schema が閉じた階層のうち、素通りしていたのはここだけだった。
  */
 function validateBands(v: unknown, errors: JsonDslError[]): void {
   if (v === undefined) return;
@@ -1374,10 +1997,20 @@ function validateBands(v: unknown, errors: JsonDslError[]): void {
       return;
     }
     const o = b as Record<string, unknown>;
-    if (typeof o.actor !== "string" || o.actor === "") {
-      errors.push({ path: `${path}.actor`, message: "band.actor must be a non-empty string" });
+    for (const k of Object.keys(o)) {
+      if (帯の項目.includes(k)) continue;
+      errors.push({
+        path: `${path}.${k}`,
+        message: `unknown key "${k}"`,
+        hint: `使える項目 = ${帯の項目.join(", ")}`,
+      });
+    }
+    for (const k of 帯の相手の項目) {
+      if (typeof o[k] !== "string" || o[k] === "") {
+        errors.push({ path: `${path}.${k}`, message: `band.${k} must be a non-empty string` });
+      }
     }
-    for (const k of ["from", "to"] as const) {
+    for (const k of 帯の段の項目) {
       if (typeof o[k] !== "number" || !Number.isInteger(o[k]) || o[k] < 0) {
         errors.push({ path: `${path}.${k}`, message: `band.${k} must be a non-negative integer` });
       }
@@ -1385,6 +2018,98 @@ 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)。
+ *
+ * **外側の形もここで見る**。 `欄の型表` は「並び」 とだけ宣言し、中身の検査は専用の検査に
+ * 委ねる作りなので (`checkFieldType` の `case "並び"`)、ここで見ないと `readouts: 1` が
+ * 素通りする。
+ */
 function validateReadouts(v: unknown, errors: JsonDslError[]): void {
   if (v === undefined) return;
   if (!Array.isArray(v)) {
@@ -1578,6 +2303,11 @@ function validateFormulas(v: unknown, inputs: unknown, errors: JsonDslError[]):
  */
 type 式の検査結果 = { readonly 読めた: true; readonly 値: unknown } | { readonly 読めた: false };
 
+/**
+ * 式の組が受ける項目 (#2258)。 判定と知らせが同じ集合を読む。
+ */
+const 式の組の項目 = ["expression", "label"] as const;
+
 /**
  * 式の値が組の形 (`{ expression, label }`) なら組を検査し、式の文字列を返す (#1916)。
  *
@@ -1589,12 +2319,12 @@ function 式の組を検査する(値: unknown, path: string, errors: JsonDslErr
   const 組 = 値 as Record<string, unknown>;
   let 読めた = true;
   for (const 鍵 of Object.keys(組)) {
-    if (鍵 === "expression" || 鍵 === "label") continue;
+    if ((式の組の項目 as readonly string[]).includes(鍵)) continue;
     読めた = false;
     errors.push({
       path: `${path}.${鍵}`,
       message: `unknown formula field: ${鍵}`,
-      hint: "使える項目 = expression, label",
+      hint: `使える項目 = ${式の組の項目.join(", ")}`,
     });
   }
   if (typeof 組.expression !== "string" || 組.expression.trim() === "") {
@@ -1632,7 +2362,11 @@ function validateEvents(v: unknown, errors: JsonDslError[]): void {
     });
     return;
   }
-  const 相手の鍵 = ["box", "lane", "arrow", "diagram"];
+  // 相手の指し方は記法の側が 1 か所で決める (#2256)。 同じ 4 語をここにも並べていた間、
+  // 1:1 を名乗りながら受ける項目が両側で別々に決まっていた。
+  // 必ず書く 2 つも同じ定数から取る (#2258) = 知らせが判定と別に並べる形をやめる
+  const 相手の鍵: readonly string[] = EVENT_TARGET_KEYS;
+  const 出来事の項目: readonly string[] = [...EVENT_REQUIRED_KEYS, ...EVENT_TARGET_KEYS];
   v.forEach((e, i) => {
     const path = `$.events[${i}]`;
     if (!e || typeof e !== "object" || Array.isArray(e)) {
@@ -1641,11 +2375,11 @@ function validateEvents(v: unknown, errors: JsonDslError[]): void {
     }
     const o = e as Record<string, unknown>;
     for (const k of Object.keys(o)) {
-      if (k === "on" || k === "handler" || 相手の鍵.includes(k)) continue;
+      if (出来事の項目.includes(k)) continue;
       errors.push({
         path: `${path}.${k}`,
         message: `unknown key "${k}"`,
-        hint: `使える項目 = on, handler, ${相手の鍵.join(", ")}`,
+        hint: `使える項目 = ${出来事の項目.join(", ")}`,
       });
     }
     if (typeof o.on !== "string" || !(EVENT_KINDS as readonly string[]).includes(o.on)) {
@@ -1700,6 +2434,16 @@ function validateEvents(v: unknown, errors: JsonDslError[]): void {
   });
 }
 
+/**
+ * 巻き上げに応じて進む値が受ける項目 (#2258)。
+ *
+ * **数を書く項目と文字を書く項目を分けて持つ** = 受け方が違うので判定が分かれるが、
+ * 知らせは 2 つを繋いで 1 つの一覧として出す。 別々に並べていた間、判定が 3 語で
+ * 知らせが 4 語という食い違いが同じ関数の中にあった。
+ */
+const 送りの数の項目 = ["start", "end", "scrub"] as const;
+const 送りの文の項目 = ["label"] as const;
+
 /**
  * 巻き上げに応じて進む値を検査する (#1393)。
  *
@@ -1749,17 +2493,17 @@ function validateScrolls(
       continue;
     }
     for (const [k, x] of Object.entries(spec as Record<string, unknown>)) {
-      if (k === "label") {
+      if ((送りの文の項目 as readonly string[]).includes(k)) {
         if (typeof x !== "string") {
-          errors.push({ path: `${path}.label`, message: "label must be a string" });
+          errors.push({ path: `${path}.${k}`, message: `${k} must be a string` });
         }
         continue;
       }
-      if (k !== "start" && k !== "end" && k !== "scrub") {
+      if (!(送りの数の項目 as readonly string[]).includes(k)) {
         errors.push({
           path: `${path}.${k}`,
           message: `unknown key "${k}"`,
-          hint: "使える項目 = start, end, scrub, label",
+          hint: `使える項目 = ${[...送りの数の項目, ...送りの文の項目].join(", ")}`,
         });
         continue;
       }
@@ -1794,6 +2538,15 @@ function validateActorShape(v: unknown, path: string, errors: JsonDslError[]): v
   表で中身を検査する(v as Record<string, unknown>, 図形の表, path, "shape", errors);
 }
 
+/**
+ * 鍵を利用者が決める入れ物 (縦列 / 群) を見る (#1304)。
+ *
+ * `lanes` / `groups` は id を鍵に持つため、鍵そのものは縛れない。 縛れるのは
+ * 「入れ物が plain object か」 と「各 id の中身の項目名と値の型」 の 2 つ。
+ *
+ * #1304 まで外側の形が違う入力 (`lanes: 5`) は走査ごと飛ばされ、誤りが 1 件も返らなかった。
+ * 形が違うものを黙って捨てると、書いた縦列が 1 つも効かない図が知らせなしで出る。
+ */
 function validateIdMap(
   v: unknown,
   欄: "lanes" | "groups",
@@ -1850,9 +2603,450 @@ 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);
+}
+
 /**
  * 写しを作る時の入れ子の深さの上限。
  *
@@ -2075,6 +3269,10 @@ export function 素のデータに写す(
   }
 }
 
+/**
+ * shape validation。 layer 1 = 必須 field + 型 check、 layer 2 は compile 側の validation に委譲。
+ * fail-fast ではなく全 error 収集して返す (LLM に一括で修正させるため)。
+ */
 function validateJson(
   json: unknown,
 ): { ok: true; data: DragonJson } | { ok: false; errors: JsonDslError[] } {
@@ -2115,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)
@@ -2126,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" });
@@ -2141,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)。
@@ -2150,6 +3460,7 @@ function validateJson(
       const 代わりに使う欄: Record<(typeof 見本にしか効かない欄)[number], string> = {
         state: "箱の見た目を変えるなら tone / color を使う",
         scale: "大きさを変えるなら posW / posH を使う",
+        phase: "普通の箱は自分の段を持たない。 動かす段は animation に書く",
       };
       if (!見本か) {
         for (const 欄 of 見本にしか効かない欄) {
@@ -2173,8 +3484,8 @@ function validateJson(
           });
         }
       }
-      // codex-review MAJOR fix = state override は plain object + 値は primitive (number / string / boolean) 限定、
-      // `{ v: {} }` 等 nested object や null が流入すると CdlState.initial に不正な型が入り compile 崩れる。
+      // 値の上書き (`state`) は素の object に限り、中の値も数 / 文字 / 真偽のいずれかに限る。
+      // `{ v: {} }` のような入れ子や null を通すと、値の初期値に扱えない型が入って組み立てが崩れる。
       if (ao.state !== undefined) {
         if (!ao.state || typeof ao.state !== "object" || Array.isArray(ao.state)) {
           errors.push({
@@ -2195,7 +3506,11 @@ function validateJson(
       }
       // CAR-1693 Phase 1: actor DSL 表面 pos の validation
       validateLayoutPos(ao.pos, `$.actors[${i}].pos`, errors);
+      // 相対で置く指定 (#2039)
+      validateRelativePos(ao.posRel, `$.actors[${i}].posRel`, errors);
     });
+    // 解けない相対の指定 (#2039)。 欄ごとの形を見た後に、図全体として解けるかを見る
+    validateRelativeAnchors(j.actors, errors);
   }
   if (!Array.isArray(j.flow)) {
     errors.push({ path: "$.flow", message: "flow must be an array" });
@@ -2209,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);
     });
@@ -2245,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)。
  *
@@ -2376,11 +3756,19 @@ function validateValues(v: unknown, errors: JsonDslError[]): void {
 }
 
 /**
- * JSON DSL → DslDocument (AST) 変換。 pos は JSON なので line 情報なし、 全て line 0。
+ * 段の説明を取り出す (#2621)。 受ける語は `PHASE_BODY_KEYS` が持つ。
  *
- * CAR-1693 Phase 1: DSL 表面 `pos: {x, y}` → 内部 AST `layoutPos:` の 2 層 mapping の実装 core。
- * test で mapping logic を実 execute するため export する (pos-field.test.ts の regression guard)。
+ * **正の語 (`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)。
  *
@@ -2393,11 +3781,40 @@ function 整えた小見出し(v: string | undefined): string | undefined {
   return t.length > 0 ? t : undefined;
 }
 
-export function jsonToDoc(json: DragonJson): DslDocument {
-  const p0 = { line: 0 };
-  const actors: DslActor[] = json.actors.map((a) => {
+/**
+ * 見本の状態の上書きに、段を使うかどうか (`phase`) を混ぜる (#2125)。
+ *
+ * 組み立て側は段を外す指定を状態の上書きの中の `phase` として読む
+ * (`compile/parts.ts` の `段を外す`)。 記法は中括弧に書いた名前をすべて上書きへ入れるため
+ * `{ kind: wave-gauge, phase: false }` がそのまま届くが、JSON は欄ごとに型を宣言する形なので、
+ * 欄として受けたものを同じ場所へ入れ直す。
+ *
+ * **書かなかった時は欄を作らない**。 `{ phase: undefined }` を混ぜると、上書きの有無で
+ * 分岐する側から見て「書いた」 ことになる。
+ */
+function 段を含めた上書き(a: JsonActor): Record<string, number | string | boolean> | undefined {
+  if (a.phase === undefined) return a.state;
+  return { ...(a.state ?? {}), phase: a.phase };
+}
+
+/**
+ * JSON DSL → DslDocument (AST) 変換。
+ *
+ * 行番号は `行の表` を渡した時だけ入る (#2117)。 JSON そのものは書いた場所を持たないため、
+ * 本文の行が分かる入口 (編集画面の YAML 欄) が場所ごとの行を集めて渡す。 渡さない呼出は
+ * 全ての要素が 0 行になる = 「行が分からない」 ことを 0 で表す。
+ *
+ * CAR-1693 Phase 1: DSL 表面 `pos: {x, y}` → 内部 AST `layoutPos:` の 2 層 mapping の実装 core。
+ * test で mapping logic を実 execute するため export する (pos-field.test.ts の regression guard)。
+ */
+export function jsonToDoc(json: DragonJson, 行の表?: 書いた行の表): DslDocument {
+  // 書いた場所から行を引く。 引けない場所は 0 行 = 表を渡さない呼出と同じ状態になる
+  const 位置 = (...道: readonly (string | number)[]): { line: number } => ({
+    line: 行の表?.get(書いた場所の鍵(...道)) ?? 0,
+  });
+  const actors: DslActor[] = json.actors.map((a, i) => {
     if (typeof a === "string") {
-      return { name: a, kind: "actor" as NodeKind, kindWritten: false, pos: p0 };
+      return { name: a, kind: "actor" as NodeKind, kindWritten: false, pos: 位置("actors", i) };
     }
     // CAR-1657 = kind が既存 NodeKind に無い値なら parts identifier 候補、 partId に格納
     const kindStr = a.kind ?? "actor";
@@ -2405,6 +3822,7 @@ export function jsonToDoc(json: DragonJson): DslDocument {
     // 色は記法と同じ振り分けを通す (#1294)。 `#` で始まれば色番号、それ以外は色の名前。
     // 別々に書くと、同じ値が入口によって色番号にも色名にもなる
     const 色 = a.color !== undefined ? splitColorValue(a.color) : {};
+    const 書いた座標 = a.at ?? a.点の位置;
     return {
       name: a.name,
       kind: isPart ? "actor" : resolveNodeKind(kindStr),
@@ -2412,12 +3830,33 @@ export function jsonToDoc(json: DragonJson): DslDocument {
       // 「書かなかった」 と同じ扱いにする (#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,
@@ -2441,8 +3880,17 @@ export function jsonToDoc(json: DragonJson): DslDocument {
             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)
@@ -2457,14 +3905,25 @@ export function jsonToDoc(json: DragonJson): DslDocument {
       scale: isPart ? a.scale : undefined,
       scaleKeys: isPart && a.scale !== undefined ? ["scale"] : undefined,
       partId: isPart ? kindStr : undefined,
-      stateOverride: isPart ? a.state : undefined,
+      stateOverride: isPart ? 段を含めた上書き(a) : undefined,
       // CAR-1693 Phase 1: DSL 表面 pos → 内部 AST layoutPos の 2 層 mapping (naming collision 回避)
       layoutPos: a.pos,
-      pos: p0,
+      // 相対で置く指定 (#2039)。 欄の名前が内部と同じなのでそのまま渡す
+      posRel: a.posRel,
+      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,
@@ -2473,13 +3932,15 @@ export function jsonToDoc(json: DragonJson): DslDocument {
     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)
@@ -2498,13 +3959,20 @@ export function jsonToDoc(json: DragonJson): DslDocument {
     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 } : {}),
     ...(s.toPartNode !== undefined ? { toPartNode: s.toPartNode } : {}),
     // CAR-1693 Phase 1: DSL 表面 pos → 内部 AST layoutPos
     layoutPos: s.pos,
-    pos: p0,
+    pos: 位置("flow", i),
   }));
   // 状態は段が無くても図に載る (#1162 で組み立ての出口が載せる)。 **段の有無で分けない** =
   // 分けると `states` だけを書いた JSON で値が 1 つも届かない (記法側で起きていた形、 #1181)
@@ -2517,7 +3985,7 @@ export function jsonToDoc(json: DragonJson): DslDocument {
    *
    * 相手は名前のまま持ち、識別子への読み替えは組み立てが行う = 2 つの入口で同じ経路を通る。
    */
-  const events: DslEventBinding[] | undefined = json.events?.map((e) => ({
+  const events: DslEventBinding[] | undefined = json.events?.map((e, i) => ({
     event: e.on as DslEventBinding["event"],
     target:
       e.diagram === true
@@ -2532,7 +4000,7 @@ export function jsonToDoc(json: DragonJson): DslDocument {
             ? ({ kind: "lane" as const, name: e.lane } as const)
             : ({ kind: "node" as const, name: e.box ?? "" } as const),
     handlerId: e.handler.trim(),
-    pos: p0,
+    pos: 位置("events", i),
   }));
   const scrolls: DslScrollTrigger[] | undefined = json.scrolls
     ? Object.entries(json.scrolls).map(([id, spec]) => ({ id, ...spec }))
@@ -2542,28 +4010,28 @@ export function jsonToDoc(json: DragonJson): DslDocument {
   const formulas: DslFormula[] | undefined = json.formulas
     ? Object.entries(json.formulas).map(([id, 値]) =>
         typeof 値 === "string"
-          ? { id, expression: 値, pos: p0 }
+          ? { id, expression: 値, pos: 位置("formulas", id) }
           : {
               id,
               expression: 値.expression,
               ...(値.label !== undefined ? { label: 値.label } : {}),
-              pos: p0,
+              pos: 位置("formulas", id),
             },
       )
     : undefined;
   const states: DslState[] = Object.entries(json.states ?? {}).map(([name, initial]) => ({
     name,
     initial,
-    pos: p0,
+    pos: 位置("states", name),
   }));
-  const phases: DslPhase[] = (json.animation ?? []).map((p) => ({
+  const phases: DslPhase[] = (json.animation ?? []).map((p, i) => ({
     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: p0 } : {}),
+    ...(p.draw !== undefined ? { draw: p.draw, drawPos: 位置("animation", i, "draw") } : {}),
     // 割合は `draw` がある段にだけ写す。 単独で書いても描く相手が決まらず何も起きないので、
     // 記法側 (同じ行に書かせる形) と同じ状態に揃える
     ...(p.draw !== undefined && p.drawRatio !== undefined ? { drawRatio: p.drawRatio } : {}),
@@ -2575,47 +4043,142 @@ export function jsonToDoc(json: DragonJson): DslDocument {
             state,
             from,
             to,
-            pos: p0,
+            pos: 位置("animation", i, "tween", state),
           })),
         }
       : {}),
     ...(p.set && Object.keys(p.set).length > 0
-      ? { sets: Object.entries(p.set).map(([state, value]) => ({ state, value, pos: p0 })) }
+      ? {
+          sets: Object.entries(p.set).map(([state, value]) => ({
+            state,
+            value,
+            pos: 位置("animation", i, "set", state),
+          })),
+        }
       : {}),
-    pos: p0,
+    pos: 位置("animation", i),
   }));
   const animate: DslAnimate | undefined =
-    states.length > 0 || phases.length > 0 ? { states, phases, pos: p0 } : undefined;
+    states.length > 0 || phases.length > 0
+      ? // 動きの塊そのものには書いた場所が無い。 段がある文書は `animation`、無い文書は
+        // `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 の指摘で実測)
     ...(整えた小見出し(json.eyebrow) !== undefined
-      ? { eyebrow: 整えた小見出し(json.eyebrow), eyebrowPos: p0 }
+      ? { eyebrow: 整えた小見出し(json.eyebrow), eyebrowPos: 位置("eyebrow") }
       : {}),
     // 2 軸で仕分ける図の軸の名前 (#1294)。 中身の無い形は「書かなかった」 と同じにする =
     // 空の軸を渡すと、書いていない側の名前が空文字で描かれる (記法側と同じ扱い)
     ...(json.axes && (json.axes.x !== undefined || json.axes.y !== undefined)
-      ? { axes: json.axes, axesPos: p0 }
+      ? { 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,
     // 他の値から決まる値 (#1181)。 書いた順に並べる = 解く順は参照から決まるので順序に
     // 意味は無いが、知らせの並びが書いた順になる
     values: json.values
-      ? Object.entries(json.values).map(([name, expression]) => ({ name, expression, pos: p0 }))
+      ? Object.entries(json.values).map(([name, expression]) => ({
+          name,
+          expression,
+          pos: 位置("values", name),
+        }))
       : undefined,
-    viewport: json.viewport ? { ...json.viewport, pos: p0 } : undefined,
+    viewport: json.viewport ? { ...json.viewport, pos: 位置("viewport") } : undefined,
     lanes: json.lanes
       ? Object.fromEntries(
           Object.entries(json.lanes).map(([id, l]) => {
             // CAR-1693 Phase 1: DSL 表面 pos → 内部 AST layoutPos の 2 層 mapping。
             // JSON input の { pos, x, width, ... } を分離し、 pos のみ layoutPos に rename する。
             const { pos: layoutPos, ...laneRest } = l;
-            return [id, { id, ...laneRest, layoutPos, pos: p0 }];
+            return [id, { id, ...laneRest, layoutPos, pos: 位置("lanes", id) }];
           }),
         )
       : undefined,
@@ -2623,7 +4186,7 @@ export function jsonToDoc(json: DragonJson): DslDocument {
       ? Object.fromEntries(
           Object.entries(json.groups).map(([id, g]) => [
             id,
-            { id, label: g.label, lanes: g.lanes, pos: p0 },
+            { id, label: g.label, lanes: g.lanes, pos: 位置("groups", id) },
           ]),
         )
       : undefined,
@@ -2638,12 +4201,31 @@ export function jsonToDoc(json: DragonJson): DslDocument {
     reveal: json.reveal,
     // 箱に触れると関係する線だけを光らせるか (#1757)
     relations: json.relations,
-    // 図の並ぶ向き (#1494)。 JSON は英語で書くので、記法と同じ語に直してから渡す
-    ...(json.direction !== undefined ? { direction: json.direction === "horizontal" ? ("横" as const) : ("縦" as const) } : {}),
-    // 図の配色 (#1553)。 記法と同じ解決を通す = 別名 (`生成り` / `青磁`) の受け方がずれない。
-    // 読めない語は渡さない = 上流の型検査が語を絞っているので、ここに来るのは書き間違いだけ
-    ...(配色 !== null ? { palette: 配色 } : {}),
-    pos: p0,
+    // 図の並ぶ向き (#1494)。 JSON は英語で書くので、記法と同じ語に直してから渡す。
+    // 書いた行も記法と同じく持つ = 持たないと、向きの知らせが文書の行 (1 行目) を指す
+    ...(json.direction !== undefined
+      ? {
+          direction: json.direction === "horizontal" ? ("横" as const) : ("縦" as const),
+          directionPos: 位置("direction"),
+        }
+      : {}),
+    // 箱を並べ替える軸 (#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: 位置(),
   };
 }
 
@@ -2673,7 +4255,17 @@ export function jsonToDiagram(
   // **`onNotice` も通す**。 記法経路だけに通知を付けていたため、 同じ型を受ける JSON / YAML
   // 経路では読めない値や捨てた矢印が利用者へ届かなかった (review 指摘)。 エディタの YAML タブは
   // ここを通る
-  opts?: { partsCatalog?: Record<string, CdlDiagram>; onNotice?: CompileToCdlOpts["onNotice"] },
+  opts?: {
+    partsCatalog?: Record<string, CdlDiagram>;
+    onNotice?: CompileToCdlOpts["onNotice"];
+    /**
+     * 本文の場所から書いた行を引く表 (#2117)。 渡すと知らせが書いた行を指す。
+     *
+     * JSON そのものは書いた場所を持たないため、本文の行が分かる入口 (編集画面の YAML 欄) が
+     * 集めて渡す。 渡さない呼出は今までどおり全ての知らせが 0 行になる。
+     */
+    行の表?: 書いた行の表;
+  },
 ): CdlDiagram {
   const v = validateJson(json);
   if (!v.ok) {
@@ -2682,7 +4274,7 @@ export function jsonToDiagram(
       .join("\n");
     throw new Error(`Dragon JSON DSL validation error:\n${msg}`);
   }
-  const doc = jsonToDoc(v.data);
+  const doc = jsonToDoc(v.data, opts?.行の表);
   return compileToCdl(doc, opts);
 }