@cardenelabs/dragon 0.34.0 → 0.35.0

package/src/json-parser.ts

@@ -1,4306 +0,0 @@
-/**
- * LLM 向け JSON DSL parser。
- *
- * dragon の YAML DSL と 1:1 対応する JSON 記法を提供する。
- * LLM (Anthropic Claude / OpenAI GPT) が structured output (tool call / response_format)
- * で確実に生成できるよう、 flat な object array を優先した shape になっている。
- *
- * 使い方 (LLM):
- *   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 に修正させる
- *
- * YAML との対応:
- *   YAML `title: "..."` ⇔ JSON `{title: "..."}`
- *   YAML `actors: [A, B: kind]` ⇔ JSON `{actors: [{name: "A"}, {name: "B", kind: "storage"}]}`
- *   YAML `flow: [- A -> B: "label"]` ⇔ JSON `{flow: [{from: "A", to: "B", label: "label"}]}`
- *   YAML `animation: [step: "..."]` ⇔ JSON `{animation: [{step: "...", duration: 1.4, focus: [...]}]}`
- */
-
-import {
-  DRAW_WORDS,
-  EDGE_SIDE_VALUES,
-  EDGE_HEAD_VALUES,
-  NODE_KIND_VALID,
-  PRESET_TYPES,
-  TYPE_ALIASES,
-  STYLE_VALID,
-  resolveNodeKind,
-  resolveTone,
-  splitColorValue,
-  書ける色名,
-  図形の表,
-  部品の表,
-  部品の組の表,
-  つまみの表,
-  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 / #2790)。 記法の読み手と同じ解決を通す = 別名の受け方が
-// 記法と JSON でずれない
-import {
-  PHASE_BODY_KEYS,
-  DIAGRAM_SHAPES,
-  THEMES,
-  THEME_ALIAS,
-  resolveOrder,
-  resolveDiagramShape,
-  shapesForDiagramType,
-  resolveTheme,
-  resolveLegendMark,
-} from "./keywords";
-// 区画の語の表 (#2667)。 記法と同じ表から直す = 同じ区画を 2 通りで呼ばない
-import { 区画 } from "./compile/word-state";
-import { 外した図種の知らせ, 外した種類, 外した種類の知らせ } from "./v05/removed-syntax";
-// 行頭の印の古い語の読み替え (#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,
-  EdgeHead,
-  EdgeHeadFill,
-  EdgeReveal,
-  RelationFocus,
-  ClassRelationType,
-  SequenceMessageKind,
-} from "@cardenelabs/cdl";
-import { extractIdentifiers, parseFormula } from "@cardenelabs/cdl";
-import type {
-  DslDocument,
-  DslStageHeader,
-  DslRegions,
-  DslActor,
-  DslStep,
-  DslAnimate,
-  DslPhase,
-  DslState,
-  PresetType,
-  LayoutPos,
-  DslReadout,
-  DslInput,
-  DslFormula,
-  DslEventBinding,
-  DslScrollTrigger,
-  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 図種の別名 = DslShape;
-
-/**
- * LLM 向け JSON DSL の入力 shape。 YAML DSL と 1:1 対応、 top-level は flat な object。
- */
-export interface DragonJson {
-  /** 図の title (必須) */
-  title: string;
-  /**
-   * preset type (必須)。 受け付ける値は `PRESET_TYPES` と `TYPE_ALIASES` が SSOT。
-   *
-   * 別名 (#2655 / #2657) は読み取りで図種と語の 2 つに開く = `pie` と書いた JSON は
-   * 数を描く図 + 円の形 として読まれる。 外した図種 (`solidity`) は置き換え先を誤りとして返す
-   * (#2947、`v05/removed-syntax.ts`)。
-   */
-  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 箱にする図種 (`chart` / `funnel` / `tree` / `journey` /
-   * `quadrant` / `mind` / `gantt`) だけ。 箱ごとに分かれる図種では相手が決まらないため、
-   * 組み立て側が知らせを出す。 そちらは `actors[].eyebrow` に書く。
-   */
-  eyebrow?: string;
-  /**
-   * 2 軸で仕分ける図 (`type: quadrant`) の軸の名前 (#1294)。 記法の `axes:` と同じ。
-   *
-   * 書かないと「小さい / 大きい」 のままになり、何を判断する図か読めない。 区画の名前
-   * (`右上` 等) は軸の名前から決まる。
-   *
-   * 他の図種には軸が無いため、書かれていたら組み立て側が知らせる。
-   */
-  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, ... } */
-  flow: JsonStep[];
-  /**
-   * 値を見せる部品 (optional、 #1374)。 記法の最上位 `readouts:` と同じ。
-   *
-   * 箱ではないので縦列に載らない。 図全体に 1 つの並びとして持つ。
-   */
-  readouts?: DslReadout[];
-  /**
-   * 読む人が動かすつまみ (optional、 #1389)。 記法の最上位 `inputs:` と同じ。
-   *
-   * 部品と同じく箱ではないので縦列に載らない。 図全体に 1 つの並びとして持つ。
-   */
-  inputs?: DslInput[];
-  /**
-   * つまみの値から決まる値 (optional、 #1391)。 記法の最上位 `formulas:` と同じ。
-   *
-   * 形は `{ 名前: "式" }`。 `values:` と経路が別で、式は名前を中括弧で囲わない。
-   *
-   * 名札を付ける時は `{ 名前: { expression: "式", label: "名札" } }` の組で書く (#1916)。
-   * 描画側は名札を操作部の式の名前に描く (cdl#853)。
-   */
-  formulas?: Record<string, string | { expression: string; label?: string }>;
-  /**
-   * 押下などの出来事で動く仕掛け (optional、 #1393)。 記法の最上位 `events:` と同じ。
-   *
-   * 相手は名前で指す (`box` / `lane` / `arrow` / `diagram` のどれか 1 つ)。
-   */
-  events?: {
-    on: string;
-    handler: string;
-    box?: string;
-    lane?: string;
-    arrow?: string;
-    diagram?: boolean;
-  }[];
-  /** 巻き上げに応じて進む値 (optional、 #1393)。 記法の最上位 `scrolls:` と同じ */
-  scrolls?: Record<string, { start?: number; end?: number; scrub?: number; label?: string }>;
-  /**
-   * 状態の初期値 (optional)。 記法の `states:` と同じ (#1181)。
-   *
-   * `{名前}` を箱の文字に置くと、ここに書いた値が描画側で置き換わる。 名前は英数字と `_`
-   * だけ (描画側が置き換える時に見る範囲と揃える)。
-   *
-   * ここに書けるのは初期値まで。 段で動かすのは `animation[].tween` / `animation[].set`
-   * (`#1186` で追加、記法の `tween:` / `set:` と同じ)。
-   */
-  states?: Record<string, number | string>;
-  /**
-   * 他の値から自動で決まる値 (optional)。 記法の `values:` と同じ (#1181)。
-   *
-   * 式には四則 (`+ - * /`) と括弧、比較 (`> >= < <= == !=`)、`min` / `max` が書ける。
-   * 他の値は `{名前}` で読む。 解くのは描画側で、毎 frame 参照から順に決まる。
-   */
-  values?: Record<string, string>;
-  /** animation phase 配列 (optional) */
-  animation?: JsonPhase[];
-  /** viewport (optional): 全体 canvas size / gap */
-  viewport?: {
-    width?: number;
-    height?: number;
-    laneWidth?: number;
-    gap?: number;
-    laneGap?: number;
-    nodeGap?: number;
-    labelMargin?: number;
-  };
-  /** lanes (optional): topology / swimlane preset で使う lane 宣言 */
-  lanes?: Record<
-    string,
-    {
-      x?: number;
-      width?: number;
-      label?: string;
-      /** 路線図の担当の名札で、名前の下へ出す補足。 */
-      subtitle?: string;
-      contain?: boolean;
-      lifeline?: boolean;
-      /**
-       * 縦列の位置のずらし (#1971)。 配置後の縦列の左上を (x, y) だけ動かす。 記法の `offsetX` / `offsetY`
-       * と同じで、読み方は `DslLane.layoutPos` が持つ。
-       */
-      pos?: LayoutPos;
-    }
-  >;
-  /** groups (optional): topology preset で使う group 宣言 */
-  groups?: Record<
-    string,
-    {
-      label?: string;
-      lanes: string[];
-    }
-  >;
-  /** 順序図で面が動いている間の帯 (#1466)。 記法の最上位 `bands:` と同じ */
-  bands?: { actor: string; from: number; to: number }[];
-  /** 矢印をいつ出すか (#1470)。 記法の最上位 `reveal:` と同じ */
-  reveal?: EdgeReveal;
-  /** 箱に触れると関係する線だけを光らせるか (#1757)。 記法の最上位 `relations:` と同じ */
-  relations?: RelationFocus;
-  /** 図の並ぶ向き (#1494)。 記法の最上位 `direction:` と同じ。 JSON は英語の語で書く */
-  direction?: "vertical" | "horizontal";
-  /** 箱を並べ替える軸 (#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 {
-  name: string;
-  /**
-   * 箱の中に描く図形 (optional、 #1374)。 記法の `shape:` と同じ。
-   *
-   * 水位や角度を状態で動かす。 形は描画側の型が縛る。
-   */
-  shape?: DslDynShape;
-  /**
-   * その箱を出すかどうかの条件 (optional、 #1381)。 記法の `visibleIf:` と同じ。
-   */
-  visibleIf?: string;
-  /**
-   * 箱に出す題 (optional、 #1381)。 記法の `title:` と同じ。
-   */
-  title?: string;
-  /**
-   * 値に追随する 5 欄 (optional、 #1392)。 記法の `wBind:` / `hBind:` / `opacity:` /
-   * `renderOffsetX:` / `renderOffsetY:` と同じ。
-   *
-   * 大きさは文字列だけ (数を書いても追随のしようが無い)、濃さとずらしは数も受ける。
-   */
-  wBind?: string;
-  hBind?: string;
-  opacity?: number | string;
-  renderOffsetX?: number | string;
-  renderOffsetY?: number | string;
-  /**
-   * 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;
-  /**
-   * 前の時点の値 (#1450)。 記法の `{ value: "320", previous: "280" }` と同じ。
-   *
-   * 内訳の変化を帯で示す図 (`type: stacked`) が 2 本目の帯として描き、
-   * 値 1 つを大きく示す図 (`type: stat`) が差として出す。 書かない図は 1 本のまま。
-   */
-  previous?: string;
-  rows?: string[];
-  /** 段階ごとの箱で、この箱を入れる段階。 記法の `stage` / `段階` と同じ (#2797)。 */
-  stage?: string;
-  lane?: string;
-  stack?: number;
-  initial?: boolean;
-  final?: boolean;
-  /**
-   * 箱の位置のずらし (#1971)。 配置後の箱の中心を (x, y) だけ動かす。 記法の `offsetX` / `offsetY`
-   * と同じで、読み方は `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 側の
-   * inline 拡散 pattern (`- arc1: { kind: arc-gauge, v: 50 }`) とは記述形式が分岐する
-   * (spec § 2.3 分岐設計、 human = YAML 手書き最適 / LLM = JSON structured 最適)。
-   *
-   * 見本でない箱に書くと誤りとして返す (#1294)。 記法側は読めない項目名として行番号付きで
-   * 知らせるため、黙って捨てると入口によって扱いが変わる。
-   */
-  state?: Record<string, number | string | boolean>;
-  /**
-   * 箱の色 (#1294)。 記法の `tone:` と同じ。
-   *
-   * 色の名前と別名 (`成功` / `success` 等) を受ける。 見本 (parts) では色ではなく状態の
-   * 上書きとして意味を持つため、記法と同じく見本の箱には効かない。
-   */
-  tone?: Tone | (string & {});
-  /**
-   * 色番号または色の名前 (#1294)。 記法の `色:` / `color:` と同じ。
-   *
-   * `#` で始まる値は色番号として `colorHex` に入り、見本の絵の色を変える。 それ以外は
-   * 色の名前として読む (記法の `splitColorValue` と同じ振り分け)。
-   */
-  color?: string;
-  /**
-   * 工程の並び (`type: gantt`) で、その工程の担当 (#1294)。 記法の `owner:` と同じ。
-   */
-  owner?: string;
-  /**
-   * 工程の並び (`type: gantt`) で、その工程が終わる時期 (#1294)。 記法の `end:` と同じ。
-   *
-   * 値は他の工程が書いた時期のどれかに一致させる。 一致しない値は始まりと同じ位置に落ちる
-   * (記法側と同じ扱い)。
-   */
-  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:` と同じ。
-   */
-  touchpoint?: string;
-  /**
-   * ユーザージャーニー (`type: journey`) で、その段階の改善の余地 (#1294)。 記法の `opportunity:` と同じ。
-   */
-  opportunity?: string;
-  opportunityPosition?: DslActor["opportunityPosition"];
-  /**
-   * 箱を置く絶対座標と大きさ (#1294)。 記法の `posX:` / `posY:` / `posW:` / `posH:` と同じ。
-   *
-   * `pos` (ずらし幅) とは別物。 こちらは auto layout を使わずに位置そのものを決める。
-   */
-  posX?: number;
-  posY?: number;
-  posW?: number;
-  posH?: number;
-  /**
-   * 見本を何倍で描くか (#1294)。 記法の `scale:` / `倍率:` と同じ。
-   *
-   * 見本 (parts) にしか効かない。 見本でない箱に書くと誤りとして返す (記法側も同じく
-   * 読めない項目名として知らせる)。
-   */
-  scale?: number;
-  /**
-   * 見本が持つ段を使うか (#2125)。 記法の `{ kind: wave-gauge, phase: false }` と同じ。
-   *
-   * 既定 (書かない) は見本の段を書いた段と番号ごとに並べて再生する。 `false` を書くと
-   * 見本の段の中身 (点灯と値の変化) を空にし、値は書いた段だけが動かす。
-   *
-   * 見本 (parts) にしか効かない。 中身は状態の上書き (`state`) に `phase` として入る =
-   * `"state": { "phase": false }` と同じ所へ届く。 記法が中括弧の中に 1 つの名前として
-   * 書ける以上、JSON でも同じ名前で書けるようにする (入口で書き方が分かれない)。
-   */
-  phase?: boolean;
-  /** 行頭の印 (#1466)。 行と対で読む。 語の意味は図の種類が決める */
-  marks?: Array<string | { mark: string; tone?: "primary" | "muted" }>;
-}
-
-/** 2 軸で仕分ける図の軸の名前 (#1294)。 記法の `axes:` と同じ形 */
-export interface JsonAxes {
-  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 {
-  from: string;
-  to: string;
-  label: string;
-  sub?: string;
-  /** 矢印がどの辺から出るか (#1385)。 記法の `side:` と同じ */
-  side?: "top" | "right" | "bottom" | "left";
-  fromSide?: "top" | "right" | "bottom" | "left";
-  toSide?: "top" | "right" | "bottom" | "left";
-  /**
-   * 矢印の先の形 (#1462)。 記法の `{ head: triangle }` と同じ。
-   *
-   * 三角 (継承・実装) / 菱 (集約・コンポジション) / 開いた矢 (関連・依存) / 鳥の足 (多)。
-   * 書かなければ従来どおり塗った三角になる。
-   */
-  head?: EdgeHead;
-  /** 出どころ側の端の形と、両端の塗り (#1466)。 記法の `{ tailHead: diamond }` 等と同じ */
-  tailHead?: EdgeHead;
-  headFill?: EdgeHeadFill;
-  tailHeadFill?: EdgeHeadFill;
-  /** UML 関係の出どころ側の多重度 (#1771 / #2783)。記法の `{ tailSub: "1" }` と同じ */
-  tailSub?: string;
-  /**
-   * 辺の役目 (cdl#618)。 記法の `{ role: main }` と同じ。
-   *
-   * `main` を書いた辺だけ「いま」 の色で引く。 主となる 1 本 (または 1 続き) にだけ書く。
-   */
-  role?: "main";
-  /** 名前の下地を敷くか (cdl#618)。 記法の `{ labelPlate: false }` と同じ。 既定は敷く */
-  labelPlate?: boolean;
-  /** record の UML 関係の語 (#1466 / #2783)。書くと端の形 / 塗り / 線種がまとめて決まる */
-  relation?: ClassRelationType;
-  /** 順序図の言づての種類 (#1466)。 `call` / `return` / `fire` */
-  kind?: SequenceMessageKind;
-  /**
-   * 矢印の色 (#1304)。 記法の `(成功)` と同じく別名 (`成功` / `neutral` 等) も受ける。
-   *
-   * `string & {}` は箱の `tone` と同じ idiom = 正規の色名を補完に出しつつ別名も通す。
-   */
-  tone?: Tone | (string & {});
-  style?: EdgeStyle;
-  guard?: string;
-  cardinality?: string;
-  /**
-   * 矢印を値に追随させる 3 欄 (optional、 #1396)。 記法の `widthBind:` / `strokeBind:` /
-   * `dashOffsetBind:` と同じ。 描画側は文字列だけを取る。
-   */
-  widthBind?: string;
-  strokeBind?: string;
-  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;
-  /**
-   * 矢印の位置のずらし (#1971)。 名前のずらし (`labelOffsetX` / `labelOffsetY`) に足して名前を動かす。
-   */
-  pos?: LayoutPos;
-  /**
-   * 部品の端で矢印を繋ぐ部品の中の要素の id (#1979)。 記法の `{ fromPartNode: rC }` / `{ toPartNode: gC }` と同じ。
-   * 要素を 1 つだけ持つ部品は書かなくてもその要素に繋ぐ
-   */
-  fromPartNode?: string;
-  toPartNode?: string;
-}
-
-export interface JsonPhase {
-  /** phase name (必須) */
-  step: string;
-  /** duration in seconds (default 1.4) */
-  duration?: number;
-  /** highlight 対象 (actor name / edge "A -> B") */
-  focus?: string[];
-  /** body 説明文 */
-  body?: string;
-  /**
-   * 説明文の別名 (#2621)。 記法が `description:` を受けるので JSON でも受ける。
-   *
-   * **正の語は `body`**。 両方書いた段は `body` を採る = 正の語を優先すると決めておくと、
-   * 読み手が「どちらが効くのか」 を実装を読まずに判断できる。
-   */
-  description?: string;
-  /** badge label */
-  badge?: string;
-  /**
-   * その段で起点から描くもの (#1312 / #1314 / #1318)。 記法の `draw:` と同じ。
-   *
-   * 受ける 8 語は `DRAW_WORDS` が持つ。 語と同じ図種で、その段の間に図が起点から現れる。
-   */
-  draw?: string;
-  /**
-   * 描き終えるまでに段の何割を使うか (#1441)。 記法の `draw: line 0.4` の後半と同じ。
-   *
-   * 0 より大きく 1 以下。 書かなければ段の終わりに描き終わる。 `draw` が無い段に書いても
-   * 何も起きない (描く相手が決まらないため、写す時に外す)。
-   */
-  drawRatio?: number;
-  /**
-   * 段の中で値を動かす (#1186)。 記法の `tween: name 100 -> 90` と同じ。
-   *
-   * 足すまで JSON の入口は `states:` で初期値を書けても **動かす手段が無かった** ため、
-   * 同じ図を記法で書くと動き JSON で書くと静止する状態だった (#1181 で状態を足した時の残り)。
-   */
-  tween?: Record<string, readonly [number, number]>;
-  /**
-   * 段の切替で値を差し替える (#1186)。 記法の `set: name value` と同じ。
-   *
-   * `tween` が段の中を補間するのに対し、こちらは段の切替時に 1 度だけ変える。
-   */
-  set?: Record<string, number | string>;
-}
-
-/**
- * JSON DSL error。 line 概念がないため、 field path (JSON pointer style) で位置を示す。
- */
-export interface JsonDslError {
-  path: string;
-  message: string;
-  hint?: string;
-}
-
-/**
- * 受け付ける種類 (`kind`)。 **記法側と同じ集合を使う** (`v05/parser.ts` の `NODE_KIND_VALID`)。
- *
- * ここに無い値は見本 (parts) の名前とみなし、`partId` へ退避して箱を `actor` に倒す
- * (CAR-1657 の unified syntax)。 つまりこの集合が小さいほど、**書いた種類が箱の見た目に効かなくなる**。
- * 部品を持つ一覧を渡した組み立てでは一覧に無い名前を知らせる (`part-not-found`、#2113) が、
- * 一覧を渡さない組み立てと部品を持たない一覧の組み立てでは `console.warn` にしか残らない。
- *
- * 以前はここに一覧を写していたため、記法に種類が増えても JSON 経路が古い一覧のまま
- * 見本の名前として扱った (実測 = 記法が知る 108 種のうち 77 種が該当、`shape-*` は全滅)。
- * 当時はカタログに無い名前が `console.warn` にしか残らず `onNotice` を呼ばなかったため、
- * 画面には何も出ないまま `actor` の箱が描かれていた (#1293)。
- *
- * 型が 2 箇所に散らばると、必ずどちらかが古くなる。 `VALID_PRESETS` (図種) と同じ扱いにする。
- */
-const VALID_KIND_SET: ReadonlySet<string> = NODE_KIND_VALID;
-
-/**
- * 受け付ける図種。 **記法側と同じ集合を使う** (`v05/parser.ts` の `PRESET_TYPES`)。
- *
- * 以前はここに一覧を写していたため、 記法に型を足しても JSON 経路が古い一覧のまま弾いた
- * (`bar` / `line` で実際に起きた)。 型が 3 箇所に散らばると、 必ずどれかが古くなる。
- */
-const VALID_PRESETS: readonly PresetType[] = [...PRESET_TYPES];
-
-/**
- * 受け付ける図種の別名 (#2655)。 **記法側と同じ表を使う** (`v05/parser.ts` の `TYPE_ALIASES`)。
- *
- * 写すと片方だけ古くなる。 図種の一覧を 1 か所に寄せたのと同じ理由。
- */
-const VALID_ALIASES: readonly string[] = [...TYPE_ALIASES.keys()];
-
-/**
- * 受け付ける項目の一覧 (#1295)。 **知らない項目を誤りにする判定と、公開 schema との
- * 突き合わせが、どちらもここを見る**。
- *
- * 一覧を型 / 検査 / schema の 3 箇所に手で置くと必ずどれかが古くなる。 型は TypeScript が
- * 見る宣言で実行時には残らないため、実行時の判定と schema はこの表を出どころにする。
- *
- * 公開している JSON Schema は元から全階層で `additionalProperties: false` を宣言していた。
- * 知らない項目を弾くのは新しい方針ではなく、parser が自分の契約に追いついていなかった。
- *
- * `states` / `values` / `tween` / `set` / `lanes` / `groups` の **鍵は利用者が決める**
- * (状態の名前 / 縦列の id)。 表が縛るのはその中の値の形で、鍵そのものではない。
- */
-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",
-    "values",
-    "animation",
-    "viewport",
-    "lanes",
-    "groups",
-    // 値を見せる部品 (#1374)
-    "readouts",
-    // 読む人が動かすつまみ (#1389)
-    "inputs",
-    // つまみの値から決まる値 (#1391)
-    "formulas",
-    // 押下などの出来事で動く仕掛けと、巻き上げに応じて進む値 (#1393)
-    "events",
-    "scrolls",
-    // 順序図で面が動いている間の帯 (#1466)
-    "bands",
-    // 矢印をいつ出すか (#1470)
-    "reveal",
-    // 箱に触れると関係する線だけを光らせるか (#1757)
-    "relations",
-    // 図の並ぶ向き (#1494)
-    "direction",
-    // 箱を並べ替える軸 (#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",
-    "final",
-    "tone",
-    "color",
-    "owner",
-    "end",
-    "startLabel",
-    "milestone",
-    "emphasis",
-    "at",
-    "点の位置",
-    "touchpoint",
-    "opportunity",
-    "opportunityPosition",
-    "posX",
-    "posY",
-    "posW",
-    "posH",
-    "scale",
-    "state",
-    "pos",
-    // 箱の中に描く図形 (#1374)
-    "shape",
-    // その箱を出すかどうかの条件 (#1381)
-    "visibleIf",
-    // 箱に出す題 (#1381)
-    "title",
-    // 値に追随する 5 欄 (#1392)
-    "wBind",
-    "hBind",
-    "opacity",
-    "renderOffsetX",
-    "renderOffsetY",
-    // 行頭の印 (#1466)。 行ごとに 1 つ、図の種類ごとの語で書く
-    "marks",
-    // 位置を他の要素からの相対で書く指定 (#2039)
-    "posRel",
-    // 見本が持つ段を使うか (#2125)
-    "phase",
-  ],
-  step: [
-    "from",
-    "to",
-    "label",
-    "sub",
-    // 矢印がどの辺から出るか (#1385)
-    "side",
-    "fromSide",
-    "toSide",
-    // 矢印の先の形 (#1462)
-    "head",
-    // 端の印の残り 3 欄と、関係の語 / 言づての種類 (#1466)
-    "tailHead",
-    "headFill",
-    "tailHeadFill",
-    // UML 関係の出どころ側の多重度 (#1771 / #2783)
-    "tailSub",
-    "relation",
-    // 辺の役目と名前の下地 (cdl#618)
-    "role",
-    "labelPlate",
-    "kind",
-    "tone",
-    "style",
-    "guard",
-    "cardinality",
-    // 値に追随する 3 欄 (#1396)
-    "widthBind",
-    "strokeBind",
-    "dashOffsetBind",
-    "labelOffsetX",
-    "labelOffsetY",
-    "posX1",
-    "posY1",
-    "posX2",
-    "posY2",
-    "waypoints",
-    "labelCollision",
-    "labelSize",
-    "overlay",
-    "pos",
-    // 部品の端で繋ぐ要素の id (#1979)
-    "fromPartNode",
-    "toPartNode",
-  ],
-  // 説明の語は `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", "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[]>;
-
-/** 受ける項目を持つ階層の名前 */
-export type 階層 = keyof typeof ACCEPTED_KEYS;
-
-/**
- * 欄ごとの値の型 (#1304)。 **`ACCEPTED_KEYS` と同じ欄を必ず持つ**。
- *
- * 項目名の側は `#1295` で閉じたが、値の側は一部の欄にしか検査が無かった。 実測すると
- * 20 欄が型違いの値をそのまま通し、`type: sequence` では 17 欄の値が図まで届いていた
- * (`labelOffsetX: "q"` が矢印の中に `"q"` のまま入る、`tone: "bogus"` がそのまま色として載る)。
- *
- * 表を `ACCEPTED_KEYS` の隣に置き、下の `satisfies` で **欄が 1 つでも欠けたら型検査が落ちる**
- * ようにする。 欄を足した時に「名前は受けるが値は見ない」 状態が作れない。
- *
- * ## 誰がどの欄を見るか
- *
- * | 型 | 見る場所 |
- * |---|---|
- * | 値そのものの型 (文字列 / 数 / 真偽 / 色 / 線種 等) | 本 file の `表で検査` |
- * | `object` / `並び` | 欄ごとの専用の検査 (`validateViewport` 等) |
- *
- * 分けるのは、中身の形が欄ごとに違うから。 外側の形だけを表で見ても中身は見られないので、
- * 専用の検査に任せて二重に誤りを出さない。 **専用の検査が抜けても表からは分からない** ため、
- * 検査 (`test/json-value-types.test.ts`) が全欄に型違いの値を入れて誤りが返ることを確かめる。
- */
-export type 欄の型 =
-  | "必須の非空文字列"
-  | "必須の文字列"
-  | "非空の文字列"
-  | "文字列"
-  | "文字列の並び"
-  | "数"
-  | "必須の数"
-  // 値に追随する欄 (#1392)。 数を直に書く形と、状態の名前を書く形の両方を受ける
-  | "数か文字列"
-  | "真偽"
-  | "色"
-  | "線種"
-  | "辺"
-  | "端の形"
-  // 相対で置く時の向き (#2039)。 書けば必ず要る = 向きが無いとどちら側か決まらない
-  | "必須の向き"
-  | "色か色番号"
-  | "描くもの"
-  | "意匠"
-  | "図の形"
-  | "ガントの帯の終わり"
-  | "ガントの帯の厚み"
-  | "札の角"
-  | "四象限の区画名位置"
-  | "線札の衝突"
-  | "主役"
-  | "必須の図種"
-  | "object"
-  | "並び"
-  | "必須の並び"
-  | "必須の非空の並び";
-
-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",
-    values: "object",
-    animation: "並び",
-    viewport: "object",
-    lanes: "object",
-    groups: "object",
-    // 値を見せる部品 (#1374)。 中身は下の検査が種類ごとに見る
-    readouts: "並び",
-    // 読む人が動かすつまみ (#1389)。 部品と同じく中身は下の検査が種類ごとに見る
-    inputs: "並び",
-    // つまみの値から決まる値 (#1391)。 中身は下の検査が式ごとに見る
-    formulas: "object",
-    // 押下と巻き上げ (#1393)。 中身は下の検査が 1 件ずつ見る
-    events: "並び",
-    scrolls: "object",
-    // 順序図で面が動いている間の帯 (#1466)
-    bands: "並び",
-    // 矢印をいつ出すか (#1470)
-    reveal: "非空の文字列",
-    // 箱に触れると関係する線だけを光らせるか (#1757)
-    relations: "非空の文字列",
-    // 図の並ぶ向き (#1494)
-    direction: "非空の文字列",
-    // 箱を並べ替える軸 (#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: "真偽",
-    final: "真偽",
-    tone: "色",
-    color: "色か色番号",
-    owner: "文字列",
-    end: "文字列",
-    startLabel: "文字列",
-    milestone: "真偽",
-    emphasis: "主役",
-    at: "並び",
-    点の位置: "並び",
-    touchpoint: "文字列",
-    opportunity: "文字列",
-    opportunityPosition: "文字列",
-    posX: "数",
-    posY: "数",
-    posW: "数",
-    posH: "数",
-    scale: "数",
-    state: "object",
-    pos: "object",
-    // 箱の中に描く図形 (#1374)。 中身は下の検査が種類ごとに見る
-    shape: "object",
-    // その箱を出すかどうかの条件 (#1381)
-    visibleIf: "文字列",
-    // 箱に出す題 (#1381)
-    title: "文字列",
-    // 値に追随する 5 欄 (#1392)。 大きさは文字列だけ、濃さとずらしは数も受ける
-    wBind: "非空の文字列",
-    hBind: "非空の文字列",
-    opacity: "数か文字列",
-    renderOffsetX: "数か文字列",
-    renderOffsetY: "数か文字列",
-    // 行頭の印 (#1466)
-    marks: "並び",
-    // 相対で置く指定 (#2039)。 中身の形は `validateRelativePos` が見る
-    posRel: "object",
-    // 見本が持つ段を使うか (#2125)
-    phase: "真偽",
-  },
-  step: {
-    from: "必須の文字列",
-    to: "必須の文字列",
-    label: "必須の文字列",
-    sub: "文字列",
-    // 矢印がどの辺から出るか (#1385)
-    side: "辺",
-    fromSide: "辺",
-    toSide: "辺",
-    head: "端の形",
-    // 端の印の残り 3 欄と、関係の語 / 言づての種類 (#1466)
-    tailHead: "端の形",
-    headFill: "非空の文字列",
-    tailHeadFill: "非空の文字列",
-    // UML 関係の出どころ側の多重度 (#1771 / #2783)
-    tailSub: "文字列",
-    relation: "非空の文字列",
-    // 辺の役目と名前の下地 (cdl#618)
-    role: "非空の文字列",
-    labelPlate: "真偽",
-    kind: "非空の文字列",
-    tone: "色",
-    style: "線種",
-    guard: "文字列",
-    cardinality: "文字列",
-    // 値に追随する 3 欄 (#1396)。 描画側は文字列だけを取る
-    widthBind: "非空の文字列",
-    strokeBind: "非空の文字列",
-    dashOffsetBind: "非空の文字列",
-    labelOffsetX: "数",
-    labelOffsetY: "数",
-    posX1: "数",
-    posY1: "数",
-    posX2: "数",
-    posY2: "数",
-    waypoints: "並び",
-    labelCollision: "線札の衝突",
-    labelSize: "object",
-    overlay: "真偽",
-    pos: "object",
-    // 部品の端で繋ぐ要素の id (#1979)。 空の id は要素を指せないので受けない
-    fromPartNode: "非空の文字列",
-    toPartNode: "非空の文字列",
-  },
-  phase: {
-    step: "必須の非空文字列",
-    duration: "数",
-    focus: "文字列の並び",
-    // 説明は正の語と別名のどちらでも同じ型。 表の欄は `ACCEPTED_KEYS.phase` と揃える (#2621)
-    body: "文字列",
-    description: "文字列",
-    badge: "文字列",
-    tween: "object",
-    set: "object",
-    draw: "描くもの",
-    drawRatio: "数",
-  },
-  viewport: {
-    width: "数",
-    height: "数",
-    contentOffsetX: "数",
-    scale: "数",
-    laneWidth: "数",
-    gap: "数",
-    laneGap: "数",
-    nodeGap: "数",
-    labelMargin: "数",
-  },
-  lane: {
-    x: "数",
-    width: "数",
-    label: "文字列",
-    subtitle: "文字列",
-    contain: "真偽",
-    lifeline: "真偽",
-    pos: "object",
-  },
-  group: { label: "文字列", lanes: "文字列の並び" },
-  axes: { x: "object", y: "object" },
-  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]]: 欄の型 };
-};
-
-/**
- * 色番号の形 (#1304)。 公開 schema の `pattern` と同じ形を実装側でも 1 箇所に持つ。
- *
- * 受けるのは 3 / 4 / 6 / 8 桁 (`#rgb` / `#rgba` / `#rrggbb` / `#rrggbbaa`)。 5 桁や 7 桁は
- * CSS の色として成立しないため通さない。
- */
-const 色番号の形 = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
-
-/**
- * JSON で色名として受ける値か (#1304、 review Round 2 の指摘)。
- *
- * **記法の `resolveTone` は通さない**。 あちらは前後の空白と引用符を落として小文字に寄せるが、
- * それは記法の本文から語を切り出すために要る処理で、JSON には要らない。 JSON の値は既に
- * 切り出された文字列なので、`" success "` や `"\"success\""` は書き手の意図ではなく
- * 記法の癖が漏れた形になる。
- *
- * 公開 schema は色名を `enum` で宣言する。 `enum` は完全一致なので、**parser 側も完全一致に
- * 揃える**。 揃えないと「schema が拒む値を parser が受ける」 ずれが残り、本 file が閉じようと
- * している宣言と実装の食い違いを別の形で作ることになる。
- *
- * 揃え方は 2 通りあった。 schema を parser に合わせて広げる案は、大文字小文字と空白と引用符を
- * `pattern` で書くことになり、**色名の一覧が `enum` と `pattern` の 2 か所に写る**。 色が増えた
- * 時に片方だけ直る形を作るため採らなかった。 同じ理由で、この判定は `tone` (箱と矢印) と
- * `color` の 3 欄すべてが共有する。
- */
-function JSONの色名か(v: string): boolean {
-  return 書ける色名().includes(v);
-}
-
-/**
- * 見本 (parts) にしか効かない欄 (#1294)。
- *
- * 普通の箱に書くと `jsonToDoc` が落とすため、書いても何も起きない。 #1294 で誤りにした。
- *
- * `見本に効かない欄` (#1308) と対になる。 2 つの表で「どちらの箱にしか効かないか」 を
- * 両方向から宣言する = 片方だけ増えると鏡の関係が崩れる。
- */
-export const 見本にしか効かない欄 = [
-  "state",
-  "scale",
-  // 見本が持つ段を使うか (#2125)。 普通の箱は自分の段を持たないので効かない
-  "phase",
-] as const satisfies readonly (typeof ACCEPTED_KEYS.actor)[number][];
-
-/**
- * 普通の箱にしか効かない欄 (#1308)。
- *
- * 見本 (parts) の箱に書くと `jsonToDoc` が丸ごと落とす。 検査を通ったうえで値が消えるため、
- * 書いた人には「書いたのに図が変わらない」 としか見えない (実測 = 5 欄すべてが消えていた)。
- *
- * 記法では同じ本文が状態の上書きに入る。 特別扱いしているのではなく、見本の中括弧に書いた
- * 名前を **すべて** 状態の上書きとして読むため、結果として届いている。 JSON は欄ごとに型を
- * 宣言する形なので同じ設計を持ち込めない。
- *
- * したがって **誤りとして返す**。 #1294 が決めた向き (見本にしか効かない `state` / `scale` を
- * 普通の箱に書いたら誤り) の鏡になる。 効く書き方は `state` が既に持つため、誤りにしても
- * 利用者の手段は失われない。
- *
- * **この表は検査と組み立ての両方が見る**。 落とす欄と誤りにする欄が別々に並ぶと、片方だけ
- * 増えた時に「検査は通すが組み立てが捨てる」 状態が戻る。
- */
-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)。 見本は自分の出方を持つ
-  "visibleIf",
-  // 箱に出す題 (#1381)。 見本は自分の題を持つ
-  "title",
-  // 値に追随する 5 欄 (#1392)。 見本は自分の大きさと出方を持つ
-  "wBind",
-  "hBind",
-  "opacity",
-  "renderOffsetX",
-  "renderOffsetY",
-] as const satisfies readonly (typeof ACCEPTED_KEYS.actor)[number][];
-
-/**
- * 表に沿って 1 つの欄の値を見る (#1304)。
- *
- * `名前` は知らせの文に出す欄の呼び名 (`actor.tone` / `viewport.width`)。 `path` は直す場所を
- * 指す JSON pointer 風の文字列で、この 2 つは役割が違う (前者は「何の欄か」、後者は「どこか」)。
- */
-function 値を検査(
-  v: unknown,
-  型: 欄の型,
-  path: string,
-  名前: string,
-  errors: JsonDslError[],
-): void {
-  const 型違い = (期待: string, 補足?: string): void => {
-    errors.push({
-      path,
-      message: `${名前} must be ${期待}`,
-      hint: 補足 ?? `got ${v === null ? "null" : Array.isArray(v) ? "array" : typeof v}`,
-    });
-  };
-  switch (型) {
-    case "必須の非空文字列":
-      if (typeof v !== "string" || v.length === 0) 型違い("a non-empty string");
-      return;
-    case "必須の文字列":
-      if (typeof v !== "string") 型違い("a string");
-      return;
-    case "非空の文字列":
-      if (v === undefined) return;
-      if (typeof v !== "string" || v.trim().length === 0) 型違い("a non-empty string if present");
-      return;
-    case "文字列":
-      if (v === undefined) return;
-      if (typeof v !== "string") 型違い("a string if present");
-      return;
-    case "文字列の並び":
-      if (v === undefined) return;
-      if (!Array.isArray(v)) {
-        型違い("an array of strings if present");
-        return;
-      }
-      // 要素の場所まで指す。 並び全体を指すと、どれを直せばよいか読めない
-      v.forEach((要素, i) => {
-        if (typeof 要素 !== "string") {
-          errors.push({
-            path: `${path}[${i}]`,
-            message: `${名前}[${i}] must be a string`,
-            hint: `got ${要素 === null ? "null" : typeof 要素}`,
-          });
-        }
-      });
-      return;
-    case "数":
-      if (v === undefined) return;
-      if (typeof v !== "number" || !Number.isFinite(v)) {
-        型違い(
-          "a finite number if present",
-          typeof v === "number" ? `got ${String(v)}` : undefined,
-        );
-      }
-      return;
-    case "必須の数":
-      if (typeof v !== "number" || !Number.isFinite(v)) {
-        型違い("a finite number", typeof v === "number" ? `got ${String(v)}` : undefined);
-      }
-      return;
-    case "数か文字列":
-      if (v === undefined) return;
-      // 空文字は受けない。 描画側は 0 として読むため、書き忘れが「箱が消える」 形で出る
-      if (typeof v === "string") {
-        if (v.trim().length === 0) 型違い("a non-empty string if present");
-        return;
-      }
-      if (typeof v !== "number" || !Number.isFinite(v)) {
-        型違い(
-          "a finite number or a non-empty string if present",
-          typeof v === "number" ? `got ${String(v)}` : undefined,
-        );
-      }
-      return;
-    case "真偽":
-      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") {
-        型違い("a color name if present");
-        return;
-      }
-      // 別名 (`成功` / `neutral`) も受ける。 一覧は engine から取る
-      if (!JSONの色名か(v)) {
-        errors.push({
-          path,
-          message: `${名前} must be a known color name`,
-          hint: `使える値 = ${書ける色名().join(", ")} (got ${JSON.stringify(v)})`,
-        });
-      }
-      return;
-    case "線種":
-      if (v === undefined) return;
-      if (typeof v !== "string" || !STYLE_VALID.has(v)) {
-        errors.push({
-          path,
-          message: `${名前} must be one of: ${[...STYLE_VALID].join(", ")}`,
-          hint: typeof v === "string" ? `got "${v}"` : `got ${typeof v}`,
-        });
-      }
-      return;
-    case "辺":
-      if (v === undefined) return;
-      if (typeof v !== "string" || !(EDGE_SIDE_VALUES as readonly string[]).includes(v)) {
-        errors.push({
-          path,
-          message: `${名前} must be one of: ${EDGE_SIDE_VALUES.join(", ")}`,
-          hint: typeof v === "string" ? `got "${v}"` : `got ${typeof v}`,
-        });
-      }
-      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`)。 写すと描画側が形を増やした時に
-      // 片方だけ古くなる
-      if (typeof v !== "string" || !EDGE_HEAD_VALUES.includes(v)) {
-        errors.push({
-          path,
-          message: `${名前} must be one of: ${EDGE_HEAD_VALUES.join(", ")}`,
-          hint: typeof v === "string" ? `got "${v}"` : `got ${typeof v}`,
-        });
-      }
-      return;
-    case "描くもの":
-      if (v === undefined) return;
-      // 受ける語は記法と同じ一覧を見る (`DRAW_WORDS`)。 写すと語が増えた時に片方だけ古くなる
-      if (typeof v !== "string" || !DRAW_WORDS.has(v)) {
-        errors.push({
-          path,
-          message: `${名前} must be one of: ${[...DRAW_WORDS].join(", ")}`,
-          hint: typeof v === "string" ? `got "${v}"` : `got ${typeof v}`,
-        });
-      }
-      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") {
-        型違い("a color name or a #hex value if present");
-        return;
-      }
-      // 振り分けは記法と同じ (`splitColorValue`)。 `#` で始まれば色番号、それ以外は色の名前
-      if (v.startsWith("#")) {
-        if (!色番号の形.test(v)) {
-          errors.push({
-            path,
-            message: `${名前} must be a #hex color`,
-            hint: `\`#f59e0b\` の形で書く (got ${JSON.stringify(v)})`,
-          });
-        }
-        return;
-      }
-      if (!JSONの色名か(v)) {
-        errors.push({
-          path,
-          message: `${名前} must be a known color name or a #hex value`,
-          hint: `使える値 = ${書ける色名().join(", ")} / \`#f59e0b\` (got ${JSON.stringify(v)})`,
-        });
-      }
-      return;
-    case "必須の図種": {
-      // 外した図種は置き換え先を示す (#2947)。 「使える図種の一覧」 では書き換え先が分からない
-      const 外した = typeof v === "string" ? 外した図種の知らせ(v) : undefined;
-      if (外した !== undefined) {
-        errors.push({ path, message: `${名前} "${String(v)}" was removed`, hint: 外した.hint });
-        return;
-      }
-      if (
-        typeof v !== "string" ||
-        !(VALID_PRESETS.includes(v as PresetType) || VALID_ALIASES.includes(v))
-      ) {
-        errors.push({
-          path,
-          message: `${名前} must be one of: ${[...VALID_PRESETS, ...VALID_ALIASES].join(", ")}`,
-          hint: typeof v === "string" ? `got "${v}"` : undefined,
-        });
-      }
-      return;
-    }
-    case "object":
-    case "並び":
-    case "必須の並び":
-    case "必須の非空の並び":
-      // 中身の形が欄ごとに違うため専用の検査が見る (`validateViewport` / `validateStates` 等)。
-      // ここで外側の形も見ると、同じ入力に 2 つ誤りが出てどちらを直せばよいか読めなくなる
-      return;
-  }
-  // 型を足して `case` を書き忘れると、その型の欄が黙って素通りする。 網羅を型検査で固定する
-  型 satisfies never;
-}
-
-/**
- * 1 つの階層の欄をまとめて見る (#1304)。
- *
- * `名前接頭` は知らせの文に出す呼び名の前半 (`actor` / `viewport` / `lanes.web`)。 空文字なら
- * 欄名だけを出す (最上位の `title` 等)。
- */
-function 表で検査(
-  o: Record<string, unknown>,
-  層: 階層,
-  path: string,
-  名前接頭: string,
-  errors: JsonDslError[],
-): void {
-  // 表が `ACCEPTED_KEYS` と同じ欄を持つことは `欄の型表` の `satisfies` が固定する。 欄を
-  // 足して型を書き忘れると型検査が落ちるため、ここでは欠落を扱わない
-  for (const [欄, 型] of Object.entries<欄の型>(欄の型表[層])) {
-    値を検査(o[欄], 型, `${path}.${欄}`, 名前接頭 === "" ? 欄 : `${名前接頭}.${欄}`, errors);
-  }
-}
-
-/**
- * 知らない項目を誤りとして積む (#1295)。
- *
- * 対象は plain object だけ。 形が違う入力は呼出側が別に誤りを積むため、ここでは何もしない
- * (同じ入力に 2 つの誤りを出すと、どちらを直せばよいか読めなくなる)。
- */
-function checkUnknownKeys(v: unknown, 層: 階層, path: string, errors: JsonDslError[]): void {
-  if (!v || typeof v !== "object" || Array.isArray(v)) return;
-  const 受ける = ACCEPTED_KEYS[層] as readonly string[];
-  for (const key of Object.keys(v)) {
-    if (受ける.includes(key)) continue;
-    const 候補 = 近い名前(key, 受ける);
-    errors.push({
-      path: `${path}.${key}`,
-      message: `unknown key "${key}"`,
-      hint: 候補 !== undefined ? `"${候補}" のことですか` : `使える項目 = ${受ける.join(", ")}`,
-    });
-  }
-}
-
-/**
- * CAR-1693 Phase 1: DSL 表面 `pos: {x, y}` の型 check helper。 finite number pair を必須にし、
- * `NaN` / `Infinity` / non-number は reject する (組み立ての出口 `applyLayoutOffsets` が配置後の位置に足すため)。
- */
-function validateLayoutPos(v: unknown, path: string, errors: JsonDslError[]): void {
-  if (v === undefined) return;
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    errors.push({ path, message: "pos must be an object with x and y numbers" });
-    return;
-  }
-  const p = v as Record<string, unknown>;
-  checkUnknownKeys(p, "layoutPos", path, errors);
-  表で検査(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)。
- *
- * 判定は `jsonToDoc` と同じにする。 別々に書くと、検査が「見本でない」 と見た箱を
- * 組み立て側が見本として扱う形ができ、見本にしか効かない項目の誤り判定がずれる。
- */
-function 見本の名前か(kind: unknown): boolean {
-  if (typeof kind !== "string" || kind.length === 0) return false;
-  // 外した種類は見本の名前として扱わない (#2947)。 置き換え先の知らせだけを出す
-  return kind !== "actor" && !外した種類.has(kind) && !VALID_KIND_SET.has(kind);
-}
-
-/**
- * 図全体の大きさと間隔を見る (#1295)。
- *
- * これまで `viewport` は検査そのものが無く、中身を丸ごと写していた
- * (`{ ...json.viewport }`)。 型にも schema にも無い `scale` が素通しで効いていた一方、
- * 数でない値を書いても誰も止めなかった。
- */
-function validateViewport(v: unknown, errors: JsonDslError[]): void {
-  if (v === undefined) return;
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    errors.push({ path: "$.viewport", message: "viewport must be a plain object" });
-    return;
-  }
-  checkUnknownKeys(v, "viewport", "$.viewport", errors);
-  表で検査(v as Record<string, unknown>, "viewport", "$.viewport", "viewport", errors);
-}
-
-/**
- * 選択肢の組が受ける項目。 どれも必ず書く (#2258)。
- *
- * **判定と知らせが同じ集合を読む**。 別々に並べていた間、判定に項目を足しても
- * 知らせは古い一覧を教え続ける形だった。
- */
-const 選択肢の項目 = ["value", "label"] as const;
-
-/**
- * 選択肢の並び (`["green", { "value": "red", "label": "失敗" }]`) を要素ごとに検査する (#1920)。
- *
- * 要素は文字列か、`value` と `label` の 2 項目を持つ組。 誤りは要素の場所 (`options[1].label`) で
- * 返す = 並び全体の型違いとして返すと、どの組のどの項目を直せばよいかが読み手に届かない。
- */
-function 選択肢の並びを検査する(値: unknown, path: string, errors: JsonDslError[]): void {
-  if (!Array.isArray(値)) {
-    errors.push({
-      path,
-      message: "options must be 選択肢の並び",
-      hint: `got ${値 === null ? "null" : typeof 値}`,
-    });
-    return;
-  }
-  値.forEach((x, i) => {
-    const here = `${path}[${i}]`;
-    if (typeof x === "string") return;
-    if (typeof x !== "object" || x === null || Array.isArray(x)) {
-      errors.push({
-        path: here,
-        message: "option must be a string or { value, label }",
-        hint: `got ${Array.isArray(x) ? "array" : x === null ? "null" : typeof x}`,
-      });
-      return;
-    }
-    const 組 = x as Record<string, unknown>;
-    for (const k of Object.keys(組)) {
-      if ((選択肢の項目 as readonly string[]).includes(k)) continue;
-      errors.push({
-        path: `${here}.${k}`,
-        message: `unknown key "${k}"`,
-        hint: `使える項目 = ${選択肢の項目.join(", ")}`,
-      });
-    }
-    for (const k of 選択肢の項目) {
-      const v = 組[k];
-      if (v === undefined) {
-        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 === "") {
-        errors.push({
-          path: `${here}.${k}`,
-          message: `${k} must not be empty`,
-          hint: k === "label" ? "名前を書かないなら文字列だけを並べる" : "値を 1 文字以上書く",
-        });
-      }
-    }
-  });
-}
-
-/**
- * 図形と部品の中身を、記法と **同じ表** で検査する (#1374)。
- *
- * 表を 2 つ持つと片方だけ直してずれる。 記法側 (`v05/parser.ts`) が持つ表をそのまま引く。
- *
- * 記法は値が全て文字列で届くため読み替えが要るが、JSON は型のまま届く。 ここでは
- * 「知らない種類」 「知らない欄」 「足りない必須の欄」 「欄の型違い」 の 4 つを見る。
- */
-function 表で中身を検査する(
-  o: Record<string, unknown>,
-  表: Record<string, 図形の定義>,
-  path: string,
-  何: string,
-  errors: JsonDslError[],
-): void {
-  // JSON は公開 schema の enum と同じ正規名だけを受ける。 ここだけ小文字化すると、
-  // schema が拒む種類を validator が通した上、種類別の追加検査も回避できてしまう。
-  const kind = typeof o.kind === "string" ? o.kind : "";
-  // 通常の object を表に使うため、継承した名前を own kind として扱わない。
-  const 定義 = Object.hasOwn(表, kind) ? 表[kind] : undefined;
-  if (定義 === undefined) {
-    errors.push({
-      path: `${path}.kind`,
-      // **文字列でない値をそのまま文にしない**。 object を混ぜると `[object Object]` になり、
-      // 何を書いたのかが読み手に届かない
-      message: `unknown ${何} kind ${typeof o.kind === "string" ? `"${o.kind}"` : JSON.stringify(o.kind ?? null)}`,
-      hint: `使える種類 = ${Object.keys(表).join(", ")}`,
-    });
-    return;
-  }
-  for (const [欄, 値] of Object.entries(o)) {
-    if (欄 === "kind" || 欄 === "id") continue;
-    const 形 = 定義.欄[欄];
-    if (形 === undefined) {
-      errors.push({
-        path: `${path}.${欄}`,
-        message: `unknown key "${欄}"`,
-        hint: `使える項目 = ${Object.keys(定義.欄).join(", ")}`,
-      });
-      continue;
-    }
-    if (形 === "選択肢の並び") {
-      選択肢の並びを検査する(値, `${path}.${欄}`, errors);
-      continue;
-    }
-    const 型が合う =
-      形 === "数"
-        ? typeof 値 === "number" && Number.isFinite(値)
-        : 形 === "数か文字列"
-          ? (typeof 値 === "number" && Number.isFinite(値)) || typeof 値 === "string"
-          : 形 === "文字列の並び"
-            ? Array.isArray(値) && 値.every((x) => typeof x === "string")
-            : 形 === "数の並び"
-              ? Array.isArray(値) && 値.every((x) => typeof x === "number" && Number.isFinite(x))
-              : 形 === "真偽"
-                ? typeof 値 === "boolean"
-                : 形 === "組の並び"
-                  ? Array.isArray(値) &&
-                    値.length > 0 &&
-                    値.every(
-                      (x) =>
-                        typeof x === "object" &&
-                        x !== null &&
-                        !Array.isArray(x) &&
-                        Object.keys(x as object).length > 0 &&
-                        Object.values(x as object).every(
-                          (y) =>
-                            typeof y === "string" || (typeof y === "number" && Number.isFinite(y)),
-                        ),
-                    )
-                  : 形 === "向き"
-                    ? typeof 値 === "string" && ["up", "down", "left", "right"].includes(値)
-                    : typeof 値 === "string";
-    if (!型が合う) {
-      errors.push({
-        path: `${path}.${欄}`,
-        message: `${欄} must be ${形}`,
-        hint: `got ${Array.isArray(値) ? "array" : 値 === null ? "null" : typeof 値}`,
-      });
-    }
-  }
-  for (const 欄 of 定義.必須) {
-    if (o[欄] === undefined) {
-      errors.push({
-        path: `${path}.${欄}`,
-        message: `${欄} is required for ${何} kind "${kind}"`,
-        hint: `必須の項目 = ${定義.必須.join(", ")}`,
-      });
-    }
-  }
-}
-
-/** 帯に書く相手の項目。 値が文字列で、他の 2 つと型が違う */
-const 帯の相手の項目 = ["actor"] as const;
-/** 帯に書く段の項目。 値が 0 以上の整数 */
-const 帯の段の項目 = ["from", "to"] as const;
-/**
- * 帯が受ける項目。 判定と知らせの両方がここから作る (#2258)。
- *
- * 公開 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;
-  if (!Array.isArray(v)) {
-    errors.push({
-      path: "$.bands",
-      message: "bands must be an array of band objects",
-      hint: `got ${v === null ? "null" : typeof v}`,
-    });
-    return;
-  }
-  v.forEach((b, i) => {
-    const path = `$.bands[${i}]`;
-    if (typeof b !== "object" || b === null || Array.isArray(b)) {
-      errors.push({ path, message: "band must be an object", hint: "{ actor, from, to } の形で書く" });
-      return;
-    }
-    const o = b as Record<string, unknown>;
-    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 帯の段の項目) {
-      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` });
-      }
-    }
-  });
-}
-
-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)) {
-    errors.push({
-      path: "$.readouts",
-      message: "readouts must be an array of readout objects",
-      hint: `got ${v === null ? "null" : typeof v}`,
-    });
-    return;
-  }
-  v.forEach((r, i) => {
-    const path = `$.readouts[${i}]`;
-    if (!r || typeof r !== "object" || Array.isArray(r)) {
-      errors.push({ path, message: "readout must be a plain object", hint: `got ${typeof r}` });
-      return;
-    }
-    const o = r as Record<string, unknown>;
-    if (typeof o.id !== "string" || o.id === "") {
-      errors.push({ path: `${path}.id`, message: "id is required", hint: "空でない文字列で書く" });
-    }
-    表で中身を検査する(o, 部品の表, path, "readout", errors);
-
-    /*
-     * 組の並びを取る欄の中身を、記法と同じ表で見る (#1385)。
-     *
-     * **種類を手で並べない**。 元は `status-dot` と `status-timeline` を直書きしていたが、
-     * 表は描画側の型定義から生成しており、種類が増えるたびに書き足す形になる。
-     */
-    const 組の定義 = 部品の組の表[String(o.kind)];
-    for (const [欄名, 定義] of Object.entries(組の定義 ?? {})) {
-      if (!Array.isArray(o[欄名])) continue;
-      (o[欄名] as unknown[]).forEach((entry, j) => {
-        const entryPath = `${path}.${欄名}[${j}]`;
-        if (!entry || typeof entry !== "object" || Array.isArray(entry)) return;
-        const item = entry as Record<string, unknown>;
-        for (const key of Object.keys(item)) {
-          if (key in 定義.欄) continue;
-          errors.push({
-            path: `${entryPath}.${key}`,
-            message: `${key} is not allowed for readout kind "${String(o.kind)}"`,
-            hint: `使える項目 = ${Object.keys(定義.欄).join(", ")}`,
-          });
-        }
-        for (const key of 定義.必須) {
-          if (item[key] !== undefined) continue;
-          errors.push({
-            path: `${entryPath}.${key}`,
-            message: `${key} is required for readout kind "${String(o.kind)}"`,
-          });
-        }
-        for (const [key, 形] of Object.entries(定義.欄)) {
-          const 値 = item[key];
-          if (値 === undefined) continue;
-          const 合う =
-            形 === "数" ? typeof 値 === "number" && Number.isFinite(値) : typeof 値 === "string";
-          if (合う) continue;
-          errors.push({
-            path: `${entryPath}.${key}`,
-            message: `${key} must be ${形}`,
-            hint: `got ${Array.isArray(値) ? "array" : 値 === null ? "null" : typeof 値}`,
-          });
-        }
-      });
-    }
-  });
-}
-
-/**
- * 読む人が動かすつまみの並びを検査する (#1389)。
- *
- * **外側の形もここで見る**。 `欄の型表` は「並び」 とだけ宣言し、中身の検査は専用の検査に
- * 委ねる作りなので (`checkFieldType` の `case "並び"`)、ここで見ないと `inputs: 1` が
- * 素通りする。
- *
- * 種類ごとの欄は記法と同じ表 (`つまみの表`) で見る。 表は描画側の型定義から生成しており、
- * 種類が増えても書き足す場所が増えない。
- */
-function validateInputs(v: unknown, errors: JsonDslError[]): void {
-  if (v === undefined) return;
-  if (!Array.isArray(v)) {
-    errors.push({
-      path: "$.inputs",
-      message: "inputs must be an array of input objects",
-      hint: `got ${v === null ? "null" : typeof v}`,
-    });
-    return;
-  }
-  v.forEach((r, i) => {
-    const path = `$.inputs[${i}]`;
-    if (!r || typeof r !== "object" || Array.isArray(r)) {
-      errors.push({ path, message: "input must be a plain object", hint: `got ${typeof r}` });
-      return;
-    }
-    const o = r as Record<string, unknown>;
-    if (typeof o.id !== "string" || o.id === "") {
-      errors.push({ path: `${path}.id`, message: "id is required", hint: "空でない文字列で書く" });
-    }
-    表で中身を検査する(o, つまみの表, path, "input", errors);
-  });
-}
-
-/**
- * つまみの値から決まる値を検査する (#1391)。
- *
- * **外側の形もここで見る**。 `欄の型表` は「object」 とだけ宣言するため、
- * ここで見ないと `formulas: { a: 1 }` が素通りする。
- *
- * 式そのものは描画側の parser に通す = 自前で書き方を決めると、通ったのに描画側が
- * 解けない式を受けてしまう。
- */
-function validateFormulas(v: unknown, inputs: unknown, errors: JsonDslError[]): void {
-  if (v === undefined) return;
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    errors.push({
-      path: "$.formulas",
-      message: "formulas must be an object of name to expression",
-      hint: `got ${v === null ? "null" : Array.isArray(v) ? "array" : typeof v}`,
-    });
-    return;
-  }
-  const つまみ = new Map<string, string>();
-  if (Array.isArray(inputs)) {
-    for (const input of inputs) {
-      if (input && typeof input === "object" && !Array.isArray(input)) {
-        const candidate = input as { id?: unknown; kind?: unknown };
-        if (typeof candidate.id === "string" && typeof candidate.kind === "string") {
-          つまみ.set(candidate.id, candidate.kind);
-        }
-      }
-    }
-  }
-  const 先に書かれた式 = new Set<string>();
-  for (const [名前, 値] of Object.entries(v as Record<string, unknown>)) {
-    const path = `$.formulas.${名前}`;
-    if (!isValueName(名前)) {
-      errors.push({ path, ...valueNameIssue(名前) });
-      continue;
-    }
-    const 検査結果 = 式の組を検査する(値, path, errors);
-    if (!検査結果.読めた) continue;
-    const 式 = 検査結果.値;
-    if (typeof 式 !== "string" || 式.trim() === "") {
-      errors.push({
-        path,
-        message: `${名前} must be a non-empty expression string`,
-        hint: `got ${Array.isArray(式) ? "array" : 式 === null ? "null" : typeof 式}`,
-      });
-      continue;
-    }
-    try {
-      const names = extractIdentifiers(parseFormula(式));
-      if (つまみ.has(名前) || 先に書かれた式.has(名前)) {
-        errors.push({
-          path,
-          message: `${名前} collides with an input or an earlier formula`,
-          hint: "inputs と formulas では重ならない名前を使う",
-        });
-        continue;
-      }
-      let valid = true;
-      for (const name of names) {
-        if (先に書かれた式.has(name)) continue;
-        const kind = つまみ.get(name);
-        if (["slider", "number", "stepper", "timeline", "toggle"].includes(kind ?? "")) continue;
-        valid = false;
-        errors.push({
-          path,
-          message: `${名前} references an unavailable formula identifier`,
-          hint: `${name} は数値/真偽の input にするか、この式より前の formula に書く`,
-        });
-      }
-      if (valid) 先に書かれた式.add(名前);
-    } catch (e) {
-      errors.push({
-        path,
-        message: `${名前} is not a readable expression`,
-        hint: (e as Error).message,
-      });
-    }
-  }
-}
-
-/**
- * 式の組を検査した結果 (#1916 / #2006)。
- *
- * **読めたかどうかを別の欄に持つ**。 値そのものに合図を混ぜると、`{ a: null }` の `null` が
- * 合図と区別が付かず、呼び手が「組の誤りは知らせ済み」 と読んで何も知らせずに通してしまう (実測)。
- *
- * 印 (`unique symbol`) を値に混ぜる形も採らない。 返す型が `unknown` を含むと印が飲み込まれ、
- * 呼び手は型で見分けられないまま等値比較に頼ることになる。
- */
-type 式の検査結果 = { readonly 読めた: true; readonly 値: unknown } | { readonly 読めた: false };
-
-/**
- * 式の組が受ける項目 (#2258)。 判定と知らせが同じ集合を読む。
- */
-const 式の組の項目 = ["expression", "label"] as const;
-
-/**
- * 式の値が組の形 (`{ expression, label }`) なら組を検査し、式の文字列を返す (#1916)。
- *
- * 文字列やそれ以外の形は **そのまま返す** = 式の文字列の検査は呼び手が文字列の形と同じ経路で行う。
- * 組に誤りがあれば知らせて `読めた: false` を返す。
- */
-function 式の組を検査する(値: unknown, path: string, errors: JsonDslError[]): 式の検査結果 {
-  if (!値 || typeof 値 !== "object" || Array.isArray(値)) return { 読めた: true, 値 };
-  const 組 = 値 as Record<string, unknown>;
-  let 読めた = true;
-  for (const 鍵 of Object.keys(組)) {
-    if ((式の組の項目 as readonly string[]).includes(鍵)) continue;
-    読めた = false;
-    errors.push({
-      path: `${path}.${鍵}`,
-      message: `unknown formula field: ${鍵}`,
-      hint: `使える項目 = ${式の組の項目.join(", ")}`,
-    });
-  }
-  if (typeof 組.expression !== "string" || 組.expression.trim() === "") {
-    読めた = false;
-    errors.push({
-      path: `${path}.expression`,
-      message: "expression must be a non-empty expression string",
-      hint: `got ${組.expression === undefined ? "nothing" : JSON.stringify(組.expression)}`,
-    });
-  }
-  if (組.label !== undefined && (typeof 組.label !== "string" || 組.label.trim() === "")) {
-    読めた = false;
-    errors.push({
-      path: `${path}.label`,
-      message: "label must be a non-empty string",
-      hint: "名札を付けないなら label を書かない",
-    });
-  }
-  return 読めた ? { 読めた: true, 値: 組.expression } : { 読めた: false };
-}
-
-/**
- * 押下などの出来事で動く仕掛けを検査する (#1393)。
- *
- * 相手の指し方は 4 つあり、**ちょうど 1 つだけ書く**。 2 つ書くとどちらを指したのか
- * 決まらず、0 なら相手がいない。 記法側の読み取りと同じ規則にする。
- */
-function validateEvents(v: unknown, errors: JsonDslError[]): void {
-  if (v === undefined) return;
-  if (!Array.isArray(v)) {
-    errors.push({
-      path: "$.events",
-      message: "events must be an array of event objects",
-      hint: `got ${v === null ? "null" : typeof v}`,
-    });
-    return;
-  }
-  // 相手の指し方は記法の側が 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)) {
-      errors.push({ path, message: "event must be a plain object", hint: `got ${typeof e}` });
-      return;
-    }
-    const o = e as Record<string, unknown>;
-    for (const k of Object.keys(o)) {
-      if (出来事の項目.includes(k)) continue;
-      errors.push({
-        path: `${path}.${k}`,
-        message: `unknown key "${k}"`,
-        hint: `使える項目 = ${出来事の項目.join(", ")}`,
-      });
-    }
-    if (typeof o.on !== "string" || !(EVENT_KINDS as readonly string[]).includes(o.on)) {
-      errors.push({
-        path: `${path}.on`,
-        message: "on must be a known event kind",
-        hint: `使える種類 = ${EVENT_KINDS.join(", ")}`,
-      });
-    }
-    if (typeof o.handler !== "string" || o.handler.trim() === "") {
-      errors.push({
-        path: `${path}.handler`,
-        message: "handler is required",
-        hint: "空でない文字列で書く",
-      });
-    }
-    const 書いた = 相手の鍵.filter((k) => o[k] !== undefined);
-    if (書いた.length !== 1) {
-      errors.push({
-        path,
-        message:
-          書いた.length === 0 ? "event target is required" : "event target must be written once",
-        hint: `${相手の鍵.join(" / ")} のどれか 1 つだけを書く`,
-      });
-      return;
-    }
-    const 鍵 = 書いた[0]!;
-    if (鍵 === "diagram") {
-      if (o.diagram !== true) {
-        errors.push({
-          path: `${path}.diagram`,
-          message: "diagram must be true",
-          hint: "図全体を指す時だけ書く",
-        });
-      }
-      return;
-    }
-    if (typeof o[鍵] !== "string" || o[鍵].trim() === "") {
-      errors.push({ path: `${path}.${鍵}`, message: `${鍵} must be a non-empty string` });
-      return;
-    }
-    if (鍵 === "arrow") {
-      const 両端 = (o.arrow as string).split("->");
-      if (両端.length !== 2 || 両端.some((x) => x.trim() === "")) {
-        errors.push({
-          path: `${path}.arrow`,
-          message: "arrow must be `A -> B`",
-          hint: "矢印の両端の名前を書く",
-        });
-      }
-    }
-  });
-}
-
-/**
- * 巻き上げに応じて進む値が受ける項目 (#2258)。
- *
- * **数を書く項目と文字を書く項目を分けて持つ** = 受け方が違うので判定が分かれるが、
- * 知らせは 2 つを繋いで 1 つの一覧として出す。 別々に並べていた間、判定が 3 語で
- * 知らせが 4 語という食い違いが同じ関数の中にあった。
- */
-const 送りの数の項目 = ["start", "end", "scrub"] as const;
-const 送りの文の項目 = ["label"] as const;
-
-/**
- * 巻き上げに応じて進む値を検査する (#1393)。
- *
- * 形は `{ 名前: { start, end, scrub, label } }`。 名前の規則は状態と揃える。
- */
-function validateScrolls(
-  v: unknown,
-  inputs: unknown,
-  formulas: unknown,
-  errors: JsonDslError[],
-): void {
-  if (v === undefined) return;
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    errors.push({
-      path: "$.scrolls",
-      message: "scrolls must be an object of name to spec",
-      hint: `got ${v === null ? "null" : Array.isArray(v) ? "array" : typeof v}`,
-    });
-    return;
-  }
-  const 既に値を作る名前 = new Set<string>();
-  if (Array.isArray(inputs)) {
-    for (const input of inputs) {
-      if (!input || typeof input !== "object" || Array.isArray(input)) continue;
-      const id = (input as { id?: unknown }).id;
-      if (typeof id === "string") 既に値を作る名前.add(id);
-    }
-  }
-  if (formulas && typeof formulas === "object" && !Array.isArray(formulas)) {
-    for (const id of Object.keys(formulas)) 既に値を作る名前.add(id);
-  }
-  for (const [名前, spec] of Object.entries(v as Record<string, unknown>)) {
-    const path = `$.scrolls.${名前}`;
-    if (!isValueName(名前)) {
-      errors.push({ path, ...valueNameIssue(名前) });
-      continue;
-    }
-    if (既に値を作る名前.has(名前)) {
-      errors.push({
-        path,
-        message: `${名前} collides with an input or formula`,
-        hint: "inputs / formulas / scrolls では重ならない名前を使う",
-      });
-    }
-    if (!spec || typeof spec !== "object" || Array.isArray(spec)) {
-      errors.push({ path, message: `${名前} must be a plain object`, hint: `got ${typeof spec}` });
-      continue;
-    }
-    for (const [k, x] of Object.entries(spec as Record<string, unknown>)) {
-      if ((送りの文の項目 as readonly string[]).includes(k)) {
-        if (typeof x !== "string") {
-          errors.push({ path: `${path}.${k}`, message: `${k} must be a string` });
-        }
-        continue;
-      }
-      if (!(送りの数の項目 as readonly string[]).includes(k)) {
-        errors.push({
-          path: `${path}.${k}`,
-          message: `unknown key "${k}"`,
-          hint: `使える項目 = ${[...送りの数の項目, ...送りの文の項目].join(", ")}`,
-        });
-        continue;
-      }
-      if (typeof x !== "number" || !Number.isFinite(x)) {
-        errors.push({ path: `${path}.${k}`, message: `${k} must be a finite number` });
-      } else if (x < 0 || x > 1) {
-        errors.push({
-          path: `${path}.${k}`,
-          message: `${k} must be between 0 and 1`,
-          hint: "0 と 1 を含む範囲で書く",
-        });
-      }
-    }
-  }
-}
-
-/**
- * 箱の中に描く図形を検査する (#1374)。
- *
- * `validateReadouts` と同じ理由で外側の形もここで見る。
- */
-function validateActorShape(v: unknown, path: string, errors: JsonDslError[]): void {
-  if (v === undefined) return;
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    errors.push({
-      path,
-      message: "shape must be a plain object",
-      hint: `got ${v === null ? "null" : Array.isArray(v) ? "array" : typeof v}`,
-    });
-    return;
-  }
-  表で中身を検査する(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",
-  層: 階層,
-  errors: JsonDslError[],
-  中身を見る: (o: Record<string, unknown>, id: string, path: string) => void,
-): void {
-  if (v === undefined) return;
-  const path = `$.${欄}`;
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    errors.push({
-      path,
-      message: `${欄} must be a plain object of id -> settings`,
-      hint: `got ${v === null ? "null" : Array.isArray(v) ? "array" : typeof v}`,
-    });
-    return;
-  }
-  for (const [id, 中] of Object.entries(v as Record<string, unknown>)) {
-    const idPath = `${path}.${id}`;
-    if (!中 || typeof 中 !== "object" || Array.isArray(中)) {
-      errors.push({
-        path: idPath,
-        message: `${欄}.${id} must be a plain object`,
-        hint: `got ${中 === null ? "null" : Array.isArray(中) ? "array" : typeof 中}`,
-      });
-      continue;
-    }
-    const o = 中 as Record<string, unknown>;
-    checkUnknownKeys(o, 層, idPath, errors);
-    中身を見る(o, id, idPath);
-  }
-}
-
-/** 2 軸で仕分ける図の軸の名前を見る (#1294) */
-function validateAxes(v: unknown, errors: JsonDslError[]): void {
-  if (v === undefined) return;
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    errors.push({
-      path: "$.axes",
-      message: "axes must be a plain object like { x: { left, right }, y: { bottom, top } }",
-    });
-    return;
-  }
-  const 軸 = v as Record<string, unknown>;
-  checkUnknownKeys(軸, "axes", "$.axes", errors);
-  const 層の名 = { x: "axesX", y: "axesY" } as const;
-  for (const 名 of ["x", "y"] as const) {
-    const 一方 = 軸[名];
-    if (一方 === undefined) continue;
-    if (!一方 || typeof 一方 !== "object" || Array.isArray(一方)) {
-      errors.push({ path: `$.axes.${名}`, message: `axes.${名} must be a plain object` });
-      continue;
-    }
-    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);
-}
-
-/**
- * 写しを作る時の入れ子の深さの上限。
- *
- * 枠の並びの長さが入れ子の深さで決まる。 図の入れ子は深くても数段で、 64 に届く形は書けない。
- */
-const 写しの最大の深さ = 64;
-
-/**
- * 写しを作る時に触る値の数の上限。
- *
- * **書式の規則ではなく、 資源を使い切らないための歯止め**。 図の書式は値の数を制限していないので、
- * ここで拒むのは「構造としては正しいが大きすぎる」 入力になる。 だから **正当な入力が届かない
- * 高さ** に置く。
- *
- * 500 万は、 記法の入力の大きさの上限 (`input-size.ts` の 512KB) を全て 2 文字の値で埋めても
- * 届かない数になる。 JSON でも同じ規模の図が 500 万個の値を持つことはない。
- *
- * **数を数えないと守れない** (Round 4 の指摘)。 一度は「写しの大きさは元の入力の大きさで決まる
- * から数える意味が無い」 として外したが、 これは誤りだった。 Proxy は読まれるたびに新しい object
- * を返せるため、 **小さな入力から枝を生やせる** (実測 = 1 個の Proxy が深さ 6 / 6 分岐で
- * 55,987 個の object に膨らんだ)。 深さの上限だけでは横の広がりを止められない。
- */
-const 写しの最大の項目数 = 5_000_000;
-
-/** 写しを作れなかった理由 (path 付き) */
-class 写せない extends Error {
-  constructor(
-    readonly path: string,
-    readonly 理由: string,
-  ) {
-    super(`${path}: ${理由}`);
-  }
-}
-
-/**
- * 検査の前に 1 度だけ読んで作る、 素のデータの複製 (#1217)。
- *
- * 入口は検査する時と図に写す時で同じ項目を 2 度読んでいた。 渡された object が値を返す関数
- * (getter) を持っていると、 2 度目の読み取りで別の値を返せる = **検査を通った値と図に届く値が
- * 別物になり、 検査が意味を持たない** (実測 = `animation[0].tween` を 6 回目から
- * `[NaN, Infinity]` を返す getter にすると、 検査を通って図に `from: null` が届いた)。
- *
- * ここで 1 度だけ読んで写しを作り、 以降は写しだけを読む。 各項目の読み取りは 1 回で、
- * 項目の名前も添字も同じ値を 2 度取りに行かない。
- *
- * **`structuredClone` は使わない**。 関数や symbol を含む入力で `DataCloneError` を投げるため、
- * `validateDragonJson` が約束している「誤りは `{ ok: false, errors }` で返す」 が破れる。
- * 自前で写せば、 写せない値もそのまま持ち越して検査側の型の判定に落とせる。
- *
- * **再帰では書かない** (Round 1 の指摘)。 検査が見ない項目も含めて写すため、 深い入れ子を渡すと
- * 呼び出しの積み上げが溢れる (実測 = 使わない項目に 20,000 段の入れ子を付けると
- * `RangeError: Maximum call stack size exceeded`)。 枠を自前で積んで回す。
- *
- * **読む順は書いた順のまま、 深さ優先で降りる** (Round 2 / 3 の指摘)。 値を返す関数が副作用を
- * 持つ入力では読む順が結果に出るため、 再帰で書いた時と同じ順を保つ。 幅優先で回すと、 先に
- * 書いた兄弟の深い所より後の兄弟の浅い所を先に読む。
- *
- * **読み取りの例外も外に出さない** (Round 1 の指摘)。 項目の名前を数える所も値を読む所も、
- * getter や Proxy が投げれば `validateDragonJson` 自体が throw して約束が破れる。 投げた場所を
- * path として拾い、 検査の誤りに変える。
- *
- * 書き込みは `Object.defineProperty` で行う = `__proto__` を項目名に持つ入力で代入が
- * prototype の setter に落ちるのを避ける (`JSON.parse` と同じく普通の項目として持つ)。
- * `__proto__` を書いた時の扱いそのものは `#1184` が持つ。
- *
- * 輪 (自分を指す入れ子) は同じ写しを返して止める。 JSON からは作れないが、 object を直接
- * 渡す経路では作れる。
- *
- * ## 守る範囲 (Round 6 で線を引いた)
- *
- * この関数が守るのは **自分が確保する量** = 写しの入れ物と、 名前の一覧と、 枠の並び。 いずれも
- * 上限 (深さ / 数) を見てから作る。
- *
- * **渡された側が自分で確保する量は守れない**。 Proxy の `ownKeys` は「名前の並びを返す」 のが
- * 仕事で、 その並びは trap の中で作られる。 こちらが受け取った時点で既に在るため、 長さを見て
- * 拒んでも確保そのものは起きた後になる。 これは呼ぶ側の code が確保するもので、 同じ process に
- * 任意の object を渡せる相手は、 この関数を通さずに同じことができる。
- *
- * 線を引くのは、 5 round にわたって「読む前に量を作れる経路」 を潰し続けた末に、 残りが
- * 呼ぶ側の code の中に移ったため。 潰す対象が自分の外に出た時点で、 この関数の責務ではない。
- *
- * **test のために export する** (#1295)。 写しの性質 (深さ / 数の上限 / 読む順 / 値を返す
- * 関数の扱い) を確かめる検査は、以前は「検査が見ない項目」 に構造をぶら下げて
- * `validateDragonJson` 越しに見ていた。 知らない項目を誤りにしたことでその足場が無くなり、
- * かつ写しは検査より前に走るため、検査の結果からは写しの中身を取り出せない。
- * 検査の対象そのものを直接呼ぶ形にする。
- */
-export function 素のデータに写す(
-  root: unknown,
-): { ok: true; value: unknown } | { ok: false; error: JsonDslError } {
-  const 写し済 = new WeakMap<object, unknown[] | Record<string, unknown>>();
-  let 項目数 = 0;
-  // 例外を拾った時に「どこを読んでいたか」 を言うために持つ。 投げるのは値を読む所と名前を
-  // 数える所の両方で、 どちらも path を持たないまま外へ出ると `$` としか言えない
-  let 読んでいる場所 = "$";
-
-  /**
-   * まだ中身を埋めていない入れ物と、 その進み具合。
-   *
-   * 配列は名前の並びを持たず長さだけを持つ (Round 6 の指摘)。 添字を文字の並びとして実体化すると、
-   * **上限を見る前にその並びを作ってしまう** (実測 = `new Array(5_000_001)` で 500 万個の添字を
-   * 作ろうとした)。 添字は数から導けるので持つ必要がない。
-   */
-  type 枠 = {
-    元: object;
-    器: unknown[] | Record<string, unknown>;
-    /** object の時だけ持つ。 配列は `長さ` を使う */
-    名前の並び: string[] | null;
-    長さ: number;
-    次: number;
-    深さ: number;
-    path: string;
-  };
-
-  /** 入れ物だけ作る (ここでは降りない)。 新しく作った時だけ枠を返す */
-  const 器を作る = (v: unknown, 深さ: number, path: string): { 値: unknown; 枠: 枠 | null } => {
-    項目数 += 1;
-    if (項目数 > 写しの最大の項目数) {
-      throw new 写せない(path, `項目が多すぎる (上限 ${写しの最大の項目数})`);
-    }
-    if (v === null || typeof v !== "object") return { 値: v, 枠: null };
-
-    const 既にある = 写し済.get(v);
-    if (既にある !== undefined) return { 値: 既にある, 枠: null };
-
-    if (深さ >= 写しの最大の深さ) {
-      throw new 写せない(path, `入れ子が深すぎる (上限 ${写しの最大の深さ})`);
-    }
-    読んでいる場所 = path;
-    const 並びか = Array.isArray(v);
-    const 器: unknown[] | Record<string, unknown> = 並びか ? [] : {};
-    写し済.set(v, 器);
-
-    if (並びか) {
-      // **長さを先に見てから降りる** (Round 6 の指摘)。 添字を文字の並びとして作ると、 上限を
-      // 見る前にその並びを作ってしまう。 長さは数を読むだけなので何も作らない。
-      //
-      // **長さは正規化してから使う** (Round 7 の指摘)。 `Array.from({ length })` は仕様の
-      // `ToLength` を通しており、 生の値をそのまま使うと 2 つの形で壊れる。
-      //
-      // | `length` が返す値 | 正規化しないと |
-      // |---|---|
-      // | `2.5` | 3 回読む (`Array.from` は 2 要素) |
-      // | `NaN` | 数の合計が `NaN` になり、 上限も終わりも判定できず読み続ける |
-      //
-      // `ToLength` と同じく 0 へ丸め、 0 以上 2^53-1 以下に収める。
-      //
-      // **数に直すのは単項 `+`** (Round 8 の指摘)。 `Number()` は `BigInt` を通してしまうが、
-      // 仕様の `ToNumber` は `TypeError` を投げる = `Array.from({ length: 2n })` は投げる。
-      // 単項 `+` は `ToNumber` そのものなので、 投げる形も含めて元の挙動と揃う (投げた分は
-      // 下の `catch` が検査の誤りに変える)。
-      const 生の長さ = +(v as unknown[]).length;
-      const 長さ = Number.isNaN(生の長さ)
-        ? 0
-        : Math.min(Math.max(Math.trunc(生の長さ), 0), Number.MAX_SAFE_INTEGER);
-      項目数 += 長さ;
-      if (項目数 > 写しの最大の項目数) {
-        throw new 写せない(path, `項目が多すぎる (上限 ${写しの最大の項目数})`);
-      }
-      return { 値: 器, 枠: { 元: v, 器, 名前の並び: null, 長さ, 次: 0, 深さ, path } };
-    }
-
-    // **名前も数に入れる** (Round 5 の指摘)。 値を読む前に名前の一覧を作るため、 値だけを
-    // 数えると「名前が 20,000 個ある段を 63 回降りる」 形で 126 万個を並べられる = 上限を
-    // 見る前に資源を使い切れる
-    const 名前の並び = Object.keys(v);
-    項目数 += 名前の並び.length;
-    if (項目数 > 写しの最大の項目数) {
-      throw new 写せない(path, `項目が多すぎる (上限 ${写しの最大の項目数})`);
-    }
-    return { 値: 器, 枠: { 元: v, 器, 名前の並び, 長さ: 名前の並び.length, 次: 0, 深さ, path } };
-  };
-
-  try {
-    const 先頭 = 器を作る(root, 0, "$");
-    const 積み: 枠[] = 先頭.枠 ? [先頭.枠] : [];
-
-    while (積み.length > 0) {
-      const 今 = 積み[積み.length - 1]!;
-      if (今.次 >= 今.長さ) {
-        積み.pop();
-        continue;
-      }
-      // 配列は添字をその場で作る (並びとして持たない)
-      const key = 今.名前の並び === null ? String(今.次) : 今.名前の並び[今.次]!;
-      今.次 += 1;
-      const 子のpath = 今.名前の並び === null ? `${今.path}[${key}]` : `${今.path}.${key}`;
-
-      // 読む直前に場所を控える = 値の読み取りそのものが投げるため、 読んだ後では遅い
-      読んでいる場所 = 子のpath;
-      const 生の値 = (今.元 as Record<string, unknown>)[key];
-
-      const 子 = 器を作る(生の値, 今.深さ + 1, 子のpath);
-      if (Array.isArray(今.器)) 今.器.push(子.値);
-      else {
-        Object.defineProperty(今.器, key, {
-          value: 子.値,
-          enumerable: true,
-          writable: true,
-          configurable: true,
-        });
-      }
-      // 深さ優先で降りる = 次の兄弟を読む前に、 この子の中身を全部読む
-      if (子.枠) 積み.push(子.枠);
-    }
-    return { ok: true, value: 先頭.値 };
-  } catch (e) {
-    if (e instanceof 写せない) {
-      return { ok: false, error: { path: e.path, message: e.理由 } };
-    }
-    // getter / Proxy が投げた形。 約束どおり誤りとして返す (throw しない)
-    return {
-      ok: false,
-      error: {
-        path: 読んでいる場所,
-        message: "入力を読み取れない",
-        hint: e instanceof Error ? e.message : String(e),
-      },
-    };
-  }
-}
-
-/**
- * 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[] } {
-  const errors: JsonDslError[] = [];
-  // root の形は写しより先に見る = 形が違う入力には従来どおり `root must be a JSON object` を
-  // 返すため。 写した後に見ると、 root が配列の入力で中の getter が先に動き、 別の誤りに化ける
-  // (Round 3 の指摘)。
-  //
-  // ただし `Array.isArray` は失効した Proxy で `TypeError` を投げる (Round 2 の指摘)。 判定
-  // そのものを受けて、 投げた形は「読み取れない」 として返す。
-  let rootがobjectか: boolean;
-  try {
-    rootがobjectか = !!json && typeof json === "object" && !Array.isArray(json);
-  } catch (e) {
-    return {
-      ok: false,
-      errors: [
-        {
-          path: "$",
-          message: "入力を読み取れない",
-          hint: e instanceof Error ? e.message : String(e),
-        },
-      ],
-    };
-  }
-  if (!rootがobjectか) {
-    return { ok: false, errors: [{ path: "$", message: "root must be a JSON object" }] };
-  }
-
-  // 以降は写しだけを読む。 元の object には二度と触らない (#1217)
-  const 写し = 素のデータに写す(json);
-  if (!写し.ok) return { ok: false, errors: [写し.error] };
-  const j = 写し.value as Record<string, unknown>;
-
-  // 知らない項目を先に見る (#1295)。 綴り違いは「書いた項目が効かない」 形で表に出るため、
-  // 個々の型の誤りより先に伝える方が直しやすい
-  checkUnknownKeys(j, "root", "$", errors);
-  // 値を見せる部品の中身を、記法と同じ表で見る (#1374)
-  validateReadouts(j.readouts, errors);
-  validateBands(j.bands, errors);
-  validateLegend(j.legend, errors);
-  validateStageHeader(j.stageHeader, errors);
-  // 読む人が動かすつまみの中身も、記法と同じ表で見る (#1389)
-  validateInputs(j.inputs, errors);
-  // 式は描画側の parser に通す (#1391)
-  validateFormulas(j.formulas, j.inputs, errors);
-  // 押下と巻き上げ (#1393)
-  validateEvents(j.events, errors);
-  validateScrolls(j.scrolls, j.inputs, j.formulas, errors);
-
-  // 値そのものの型は表が見る (#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" });
-  } else {
-    j.actors.forEach((a, i) => {
-      if (typeof a === "string") return;
-      if (!a || typeof a !== "object" || Array.isArray(a)) {
-        errors.push({ path: `$.actors[${i}]`, message: "actor must be string or object" });
-        return;
-      }
-      const ao = a as Record<string, unknown>;
-      checkUnknownKeys(ao, "actor", `$.actors[${i}]`, errors);
-      // 外した種類は置き換え先を示す (#2947)。 記法と同じ表を引く
-      const 外した = typeof ao.kind === "string" ? 外した種類の知らせ(ao.kind) : undefined;
-      if (外した !== undefined) {
-        errors.push({ path: `$.actors[${i}].kind`, message: `kind "${String(ao.kind)}" was removed`, hint: 外した.hint });
-      }
-      // 値そのものの型は表が見る (#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)。
-      // 記法側は読めない項目名として行番号付きで知らせるため、黙って捨てると入口で扱いが変わる。
-      const 見本か = 見本の名前か(ao.kind);
-      // 見本にしか効かない欄を普通の箱に書いた形 (#1294)。 一覧は表が持つ
-      const 代わりに使う欄: Record<(typeof 見本にしか効かない欄)[number], string> = {
-        state: "箱の見た目を変えるなら tone / color を使う",
-        scale: "大きさを変えるなら posW / posH を使う",
-        phase: "普通の箱は自分の段を持たない。 動かす段は animation に書く",
-      };
-      if (!見本か) {
-        for (const 欄 of 見本にしか効かない欄) {
-          if (ao[欄] === undefined) continue;
-          errors.push({
-            path: `$.actors[${i}].${欄}`,
-            message: `actor.${欄} is only for parts (kind must be a parts identifier)`,
-            hint: 代わりに使う欄[欄],
-          });
-        }
-      }
-      // 逆向きも同じく誤りにする (#1308)。 普通の箱にしか効かない欄を見本に書くと、
-      // `jsonToDoc` が丸ごと落として何も起きない
-      if (見本か) {
-        for (const 欄 of 見本に効かない欄) {
-          if (ao[欄] === undefined) continue;
-          errors.push({
-            path: `$.actors[${i}].${欄}`,
-            message: `actor.${欄} is not for parts (kind is a parts identifier)`,
-            hint: `見本の状態を変えるなら state を使う (\`"state": { "${欄}": ... }\`)`,
-          });
-        }
-      }
-      // 値の上書き (`state`) は素の object に限り、中の値も数 / 文字 / 真偽のいずれかに限る。
-      // `{ v: {} }` のような入れ子や null を通すと、値の初期値に扱えない型が入って組み立てが崩れる。
-      if (ao.state !== undefined) {
-        if (!ao.state || typeof ao.state !== "object" || Array.isArray(ao.state)) {
-          errors.push({
-            path: `$.actors[${i}].state`,
-            message: "actor.state must be a plain object",
-          });
-        } else {
-          for (const [sk, sv] of Object.entries(ao.state as Record<string, unknown>)) {
-            const svType = typeof sv;
-            if (svType !== "number" && svType !== "string" && svType !== "boolean") {
-              errors.push({
-                path: `$.actors[${i}].state.${sk}`,
-                message: `actor.state.${sk} must be number / string / boolean (got ${sv === null ? "null" : svType})`,
-              });
-            }
-          }
-        }
-      }
-      // 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" });
-  } else {
-    j.flow.forEach((s, i) => {
-      if (!s || typeof s !== "object" || Array.isArray(s)) {
-        errors.push({ path: `$.flow[${i}]`, message: "step must be an object" });
-        return;
-      }
-      const so = s as Record<string, unknown>;
-      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);
-    });
-  }
-  validateViewport(j.viewport, errors);
-  // 縦列と群は **鍵を利用者が決める** (id)。 表が縛るのはその中の項目
-  //
-  // #1304 まで外側の形すら見ておらず、`lanes: 5` のような値が誤りにならないまま素通りしていた
-  // (形が違えば中の走査ごと飛ばす書き方だったため)。 形が違う値は黙って捨てない
-  validateIdMap(j.lanes, "lanes", "lane", errors, (lane, laneId, path) => {
-    表で検査(lane, "lane", path, `lanes.${laneId}`, errors);
-    // CAR-1693 Phase 1: lane DSL 表面 pos の validation
-    validateLayoutPos(lane.pos, `${path}.pos`, errors);
-  });
-  validateIdMap(j.groups, "groups", "group", errors, (group, groupId, path) => {
-    表で検査(group, "group", path, `groups.${groupId}`, errors);
-  });
-  if (j.animation !== undefined) {
-    if (!Array.isArray(j.animation)) {
-      errors.push({ path: "$.animation", message: "animation must be an array if present" });
-    } else {
-      j.animation.forEach((p, i) => {
-        if (!p || typeof p !== "object" || Array.isArray(p)) {
-          errors.push({ path: `$.animation[${i}]`, message: "phase must be an object" });
-          return;
-        }
-        const po = p as Record<string, unknown>;
-        checkUnknownKeys(po, "phase", `$.animation[${i}]`, errors);
-        // 値そのものの型は表が見る (#1304)
-        表で検査(po, "phase", `$.animation[${i}]`, "phase", errors);
-        validatePhaseMotion(po, i, errors);
-      });
-    }
-  }
-  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)。
- *
- * 状態名の記法は `states:` と同じ判定を使う。 参照先はこの JSON の `states` だけでは決めない。
- * 見本や preset が持つ状態を動かす指定もあるためで、記法側と同じく compile 後の図で解決する。
- */
-function validatePhaseMotion(po: Record<string, unknown>, i: number, errors: JsonDslError[]): void {
-  if (po.tween !== undefined) {
-    if (!po.tween || typeof po.tween !== "object" || Array.isArray(po.tween)) {
-      errors.push({
-        path: `$.animation[${i}].tween`,
-        message: "tween must be a plain object of state -> [from, to]",
-      });
-    } else {
-      for (const [name, range] of Object.entries(po.tween as Record<string, unknown>)) {
-        const path = `$.animation[${i}].tween.${name}`;
-        if (!isValueName(name)) errors.push({ path, ...valueNameIssue(name) });
-        if (!Array.isArray(range) || range.length !== 2) {
-          errors.push({ path, message: "tween value must be [from, to]" });
-          continue;
-        }
-        // 補間は数どうしでしか成り立たない。 文字列を通すと描画側が数として読めず
-        // 段の途中が壊れる (記法側も数だけを受ける)
-        for (const v of range) {
-          if (typeof v !== "number" || !Number.isFinite(v)) {
-            errors.push({
-              path,
-              message: "tween value must be finite numbers",
-              hint: `got ${typeof v}`,
-            });
-            break;
-          }
-        }
-      }
-    }
-  }
-
-  if (po.set !== undefined) {
-    if (!po.set || typeof po.set !== "object" || Array.isArray(po.set)) {
-      errors.push({
-        path: `$.animation[${i}].set`,
-        message: "set must be a plain object of state -> value",
-      });
-    } else {
-      for (const [name, value] of Object.entries(po.set as Record<string, unknown>)) {
-        const path = `$.animation[${i}].set.${name}`;
-        if (!isValueName(name)) errors.push({ path, ...valueNameIssue(name) });
-        const t = typeof value;
-        if (t !== "number" && t !== "string") {
-          errors.push({ path, message: "set value must be a number or string", hint: `got ${t}` });
-        } else if (t === "number" && !Number.isFinite(value)) {
-          errors.push({ path, message: "set value must be a finite number" });
-        }
-      }
-    }
-  }
-}
-
-/**
- * 状態の初期値を見る (#1181)。
- *
- * 名前の判定は記法と同じものを使う (`value-syntax.ts`)。 別々に持つと、YAML では弾かれる
- * 名前が JSON では通る形ができ、描画側が `{名前}` を置き換えられない図が生まれる。
- */
-function validateStates(v: unknown, errors: JsonDslError[]): void {
-  if (v === undefined) return;
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    errors.push({
-      path: "$.states",
-      message: "states must be a plain object of name -> initial value",
-    });
-    return;
-  }
-  for (const [name, initial] of Object.entries(v as Record<string, unknown>)) {
-    if (!isValueName(name)) {
-      errors.push({ path: `$.states.${name}`, ...valueNameIssue(name) });
-    }
-    const t = typeof initial;
-    if (t !== "number" && t !== "string") {
-      errors.push({
-        path: `$.states.${name}`,
-        message: "state initial must be a number or string",
-        hint: `got ${t}`,
-      });
-    } else if (t === "number" && !Number.isFinite(initial)) {
-      // `NaN` / `Infinity` は JSON には書けないが、object を直接渡す経路では届く。
-      // 描画側は文字列に直して式に流すため、そのまま通すと計算が全て壊れる
-      errors.push({ path: `$.states.${name}`, message: "state initial must be a finite number" });
-    }
-  }
-}
-
-/**
- * 他の値から決まる値を見る (#1181)。
- *
- * 名前と式の判定は記法と同じものを使う。 式が文法として正しいかまでは見ない (描画側が
- * 評価する時に判定して、その値だけを止める = spec § 4.2)。
- */
-function validateValues(v: unknown, errors: JsonDslError[]): void {
-  if (v === undefined) return;
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    errors.push({
-      path: "$.values",
-      message: "values must be a plain object of name -> expression",
-    });
-    return;
-  }
-  for (const [name, expression] of Object.entries(v as Record<string, unknown>)) {
-    if (!isValueName(name)) {
-      errors.push({ path: `$.values.${name}`, ...valueNameIssue(name) });
-    }
-    if (typeof expression !== "string" || expression.trim() === "") {
-      errors.push({
-        path: `$.values.${name}`,
-        message: "value expression must be a non-empty string",
-        hint: '`"{inflow} - {done}"` の形で書く',
-      });
-      continue;
-    }
-    for (const issue of checkValueExpression(expression, name)) {
-      errors.push({ path: `$.values.${name}`, ...issue });
-    }
-  }
-}
-
-/**
- * 段の説明を取り出す (#2621)。 受ける語は `PHASE_BODY_KEYS` が持つ。
- *
- * **正の語 (`body`) を先に見る**。 表の先頭が正の語なので、並び順のまま最初に値を持つ語を
- * 採れば「どちらが効くか」 の規則を別に書かなくて済む。
- */
-function 段の説明(p: JsonPhase): string | undefined {
-  for (const key of PHASE_BODY_KEYS) {
-    const v = p[key];
-    if (typeof v === "string") return v;
-  }
-  return undefined;
-}
-
-/**
- * 図表の箱の上の小見出しを、 記法側と同じ形に整える (#1247)。
- *
- * 記法は値を `trim()` してから空かどうかを見る。 JSON でも同じ順で見ないと、 空白だけの値が
- * 入口によって別の意味になる (記法は書かなかった扱い、 JSON は中身のない帯)。
- */
-function 整えた小見出し(v: string | undefined): string | undefined {
-  if (v === undefined) return undefined;
-  const t = v.trim();
-  return t.length > 0 ? t : undefined;
-}
-
-/**
- * 見本の状態の上書きに、段を使うかどうか (`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: 位置("actors", i) };
-    }
-    // CAR-1657 = kind が既存 NodeKind に無い値なら parts identifier 候補、 partId に格納
-    const kindStr = a.kind ?? "actor";
-    const isPart = 見本の名前か(kindStr);
-    // 外した種類 (#2947) は検査が誤りとして返す。 検査を通さずに呼ばれても描けない種類を
-    // 描画側へ渡さないよう、書かなかった箱と同じ扱いにする
-    const 外した = 外した種類.has(kindStr);
-    // 色は記法と同じ振り分けを通す (#1294)。 `#` で始まれば色番号、それ以外は色の名前。
-    // 別々に書くと、同じ値が入口によって色番号にも色名にもなる
-    const 色 = a.color !== undefined ? splitColorValue(a.color) : {};
-    const 書いた座標 = a.at ?? a.点の位置;
-    return {
-      name: a.name,
-      kind: isPart || 外した ? "actor" : resolveNodeKind(kindStr),
-      // parts 候補は `kind` を `actor` に倒して `partId` へ退避するため、 名札に載せる種類としては
-      // 「書かなかった」 と同じ扱いにする (#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)。 行と対で読む。 古い語は記法と同じ関数で読み替える (#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,
-      final: a.final,
-      // 箱の中に描く図形 (#1374)。 見本では状態の上書きが効くため、通常の箱にだけ渡す
-      shape: isPart ? undefined : a.shape,
-      visibleIf: isPart ? undefined : a.visibleIf,
-      title: isPart ? undefined : a.title,
-      // 値に追随する 5 欄 (#1392)。 記法と同じく見本には渡さない
-      wBind: isPart ? undefined : a.wBind,
-      hBind: isPart ? undefined : a.hBind,
-      opacity: isPart ? undefined : a.opacity,
-      renderOffsetX: isPart ? undefined : a.renderOffsetX,
-      renderOffsetY: isPart ? undefined : a.renderOffsetY,
-      // 普通の箱にしか効かない欄は見本では落とす。 落とす欄の一覧は `見本に効かない欄` が
-      // 唯一の出どころで、検査 (#1308) も同じ表を見る = 「検査は通すが組み立てが捨てる」
-      // 状態が作れない
-      ...(isPart
-        ? {}
-        : {
-            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)
-      partColorName: isPart ? 色.tone : undefined,
-      // 絶対座標と大きさ (#1294)。 `pos` (ずらし幅) とは別経路
-      posX: a.posX,
-      posY: a.posY,
-      posW: a.posW,
-      posH: a.posH,
-      // 倍率は見本にしか効かない (検査が見本でない箱を弾く)。 書かれた名前は JSON では
-      // 常に `scale` で、記法の別名 (`倍率`) は JSON に持ち込まない
-      scale: isPart ? a.scale : undefined,
-      scaleKeys: isPart && a.scale !== undefined ? ["scale"] : undefined,
-      partId: isPart ? kindStr : undefined,
-      stateOverride: isPart ? 段を含めた上書き(a) : undefined,
-      // CAR-1693 Phase 1: DSL 表面 pos → 内部 AST layoutPos の 2 層 mapping (naming collision 回避)
-      layoutPos: a.pos,
-      // 相対で置く指定 (#2039)。 欄の名前が内部と同じなのでそのまま渡す
-      posRel: a.posRel,
-      pos: 位置("actors", i),
-    };
-  });
-  // 図の意匠 (#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,
-    from: s.from,
-    to: s.to,
-    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,
-    // UML 関係の出どころ側の多重度 (#1771 / #2783)
-    tailSub: s.tailSub,
-    relation: s.relation,
-    // 辺の役目と名前の下地 (cdl#618)
-    role: s.role,
-    labelPlate: s.labelPlate,
-    msgKind: s.kind,
-    // 箱と同じ読み替えを通す (#1304)。 通さないと `tone: "成功"` が色名として解決されないまま
-    // 図に届き、同じ値が箱では色になり矢印では色にならない
-    tone: resolveTone(s.tone),
-    style: s.style,
-    guard: s.guard,
-    cardinality: s.cardinality,
-    // 値に追随する 3 欄 (#1396)
-    widthBind: s.widthBind,
-    strokeBind: s.strokeBind,
-    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: 位置("flow", i),
-  }));
-  // 状態は段が無くても図に載る (#1162 で組み立ての出口が載せる)。 **段の有無で分けない** =
-  // 分けると `states` だけを書いた JSON で値が 1 つも届かない (記法側で起きていた形、 #1181)
-  // 値を見せる部品はそのまま渡す (#1374)。 形は描画側の型が縛る
-  const readouts: DslReadout[] | undefined = json.readouts ? [...json.readouts] : undefined;
-  // つまみもそのまま渡す (#1389)。 形は描画側の型が縛る
-  const inputs: DslInput[] | undefined = json.inputs ? [...json.inputs] : undefined;
-  /*
-   * 押下と巻き上げも記法側と同じ形へ写す (#1393)。
-   *
-   * 相手は名前のまま持ち、識別子への読み替えは組み立てが行う = 2 つの入口で同じ経路を通る。
-   */
-  const events: DslEventBinding[] | undefined = json.events?.map((e, i) => ({
-    event: e.on as DslEventBinding["event"],
-    target:
-      e.diagram === true
-        ? ({ kind: "diagram" } as const)
-        : e.arrow !== undefined
-          ? ({
-              kind: "edge" as const,
-              from: e.arrow.split("->")[0]?.trim() ?? "",
-              to: e.arrow.split("->")[1]?.trim() ?? "",
-            } as const)
-          : e.lane !== undefined
-            ? ({ kind: "lane" as const, name: e.lane } as const)
-            : ({ kind: "node" as const, name: e.box ?? "" } as const),
-    handlerId: e.handler.trim(),
-    pos: 位置("events", i),
-  }));
-  const scrolls: DslScrollTrigger[] | undefined = json.scrolls
-    ? Object.entries(json.scrolls).map(([id, spec]) => ({ id, ...spec }))
-    : undefined;
-  // 式は `{ 名前: "式" }` から並びへ写す (#1391)。 記法側と同じ形にして組み立てを 1 本にする。
-  // 組の形 (`{ expression, label }`) は名札を持ったまま写す (#1916)
-  const formulas: DslFormula[] | undefined = json.formulas
-    ? Object.entries(json.formulas).map(([id, 値]) =>
-        typeof 値 === "string"
-          ? { id, expression: 値, pos: 位置("formulas", id) }
-          : {
-              id,
-              expression: 値.expression,
-              ...(値.label !== undefined ? { label: 値.label } : {}),
-              pos: 位置("formulas", id),
-            },
-      )
-    : undefined;
-  const states: DslState[] = Object.entries(json.states ?? {}).map(([name, initial]) => ({
-    name,
-    initial,
-    pos: 位置("states", name),
-  }));
-  const phases: DslPhase[] = (json.animation ?? []).map((p, i) => ({
-    name: p.step,
-    durationMs: Math.round((p.duration ?? 1.4) * 1000),
-    highlight: p.focus,
-    body: 段の説明(p),
-    badge: p.badge,
-    // 書いた段だけが欄を持つ。 空文字を置くと「書いた」 と「書いていない」 が同じ形になる
-    ...(p.draw !== undefined ? { draw: p.draw, drawPos: 位置("animation", i, "draw") } : {}),
-    // 割合は `draw` がある段にだけ写す。 単独で書いても描く相手が決まらず何も起きないので、
-    // 記法側 (同じ行に書かせる形) と同じ状態に揃える
-    ...(p.draw !== undefined && p.drawRatio !== undefined ? { drawRatio: p.drawRatio } : {}),
-    // 段の中で動かす分 (#1186)。 記法側の `tweens` / `sets` と同じ形に写す。
-    // 空の配列を置かないのは、記法側が「無ければ field ごと持たない」 形だから
-    ...(p.tween && Object.keys(p.tween).length > 0
-      ? {
-          tweens: Object.entries(p.tween).map(([state, [from, to]]) => ({
-            state,
-            from,
-            to,
-            pos: 位置("animation", i, "tween", state),
-          })),
-        }
-      : {}),
-    ...(p.set && Object.keys(p.set).length > 0
-      ? {
-          sets: Object.entries(p.set).map(([state, value]) => ({
-            state,
-            value,
-            pos: 位置("animation", i, "set", state),
-          })),
-        }
-      : {}),
-    pos: 位置("animation", i),
-  }));
-  const animate: DslAnimate | 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: 別名?.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 } : {}),
-    ...(別名?.shape !== undefined ? { shape: 別名.shape, shapePos: 位置("type") } : {}),
-    // 前後の空白を落としてから見る。 記法側 (`v05/parser.ts`) が `trim()` してから
-    // 空かどうかを判定するため、 揃えないと **空白だけの値で入口ごとに図が変わる**
-    // (記法は書かなかった扱い、 JSON は中身のない帯を描く。 Round 2 の指摘で実測)
-    ...(整えた小見出し(json.eyebrow) !== undefined
-      ? { eyebrow: 整えた小見出し(json.eyebrow), eyebrowPos: 位置("eyebrow") }
-      : {}),
-    // 2 軸で仕分ける図の軸の名前 (#1294)。 中身の無い形は「書かなかった」 と同じにする =
-    // 空の軸を渡すと、書いていない側の名前が空文字で描かれる (記法側と同じ扱い)
-    ...(json.axes && (json.axes.x !== undefined || json.axes.y !== undefined)
-      ? { axes: json.axes, axesPos: 位置("axes") }
-      : {}),
-    // 区画の名前 (#2667)。 鍵は記法と同じ 4 語なので、描画側の綴りへここで直す
-    ...(区画の名前を直す(json.regions) === undefined
-      ? {}
-      : { regions: 区画の名前を直す(json.regions) }),
-    ...(json.legendFontSize !== undefined ? { legendFontSize: json.legendFontSize } : {}),
-    ...(json.legendOffset !== undefined ? { legendOffset: json.legendOffset } : {}),
-    ...(json.stageHeader !== undefined ? { stageHeader: json.stageHeader } : {}),
-    ...(json.stageLayout !== undefined ? { stageLayout: json.stageLayout } : {}),
-    actors,
-    flow,
-    animate,
-    // 他の値から決まる値 (#1181)。 書いた順に並べる = 解く順は参照から決まるので順序に
-    // 意味は無いが、知らせの並びが書いた順になる
-    values: json.values
-      ? Object.entries(json.values).map(([name, expression]) => ({
-          name,
-          expression,
-          pos: 位置("values", name),
-        }))
-      : 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: 位置("lanes", id) }];
-          }),
-        )
-      : undefined,
-    groups: json.groups
-      ? Object.fromEntries(
-          Object.entries(json.groups).map(([id, g]) => [
-            id,
-            { id, label: g.label, lanes: g.lanes, pos: 位置("groups", id) },
-          ]),
-        )
-      : undefined,
-    readouts,
-    inputs,
-    formulas,
-    events,
-    scrolls,
-    // 順序図で面が動いている間の帯 (#1466)
-    bands: json.bands,
-    // 矢印をいつ出すか (#1470)
-    reveal: json.reveal,
-    // 箱に触れると関係する線だけを光らせるか (#1757)
-    relations: json.relations,
-    // 図の並ぶ向き (#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: 位置(),
-  };
-}
-
-/**
- * LLM 向け JSON DSL の parse + compile 一発変換。
- *
- * @param json - DragonJson shape の object (parsed JSON、 not string)
- * @returns CdlDiagram (@cardenelabs/cdl の CdlDiagramView 等に渡せる)
- * @throws Error - validation error + hint 付きの詳細メッセージ、 LLM に retry させるための情報を含む
- *
- * @example
- * const diagram = jsonToDiagram({
- *   title: "ログインAPI",
- *   type: "sequence",
- *   actors: ["User", "API", { name: "DB", kind: "storage" }],
- *   flow: [
- *     { from: "User", to: "API", label: "login" },
- *     { from: "API", to: "DB", label: "SELECT" },
- *   ],
- *   animation: [
- *     { step: "call", duration: 1.4, focus: ["User", "API"] },
- *   ],
- * });
- */
-export function jsonToDiagram(
-  json: unknown,
-  // **`onNotice` も通す**。 記法経路だけに通知を付けていたため、 同じ型を受ける JSON / YAML
-  // 経路では読めない値や捨てた矢印が利用者へ届かなかった (review 指摘)。 エディタの YAML タブは
-  // ここを通る
-  opts?: {
-    partsCatalog?: Record<string, CdlDiagram>;
-    onNotice?: CompileToCdlOpts["onNotice"];
-    /**
-     * 本文の場所から書いた行を引く表 (#2117)。 渡すと知らせが書いた行を指す。
-     *
-     * JSON そのものは書いた場所を持たないため、本文の行が分かる入口 (編集画面の YAML 欄) が
-     * 集めて渡す。 渡さない呼出は今までどおり全ての知らせが 0 行になる。
-     */
-    行の表?: 書いた行の表;
-  },
-): CdlDiagram {
-  const v = validateJson(json);
-  if (!v.ok) {
-    const msg = v.errors
-      .map((e) => `  ${e.path}: ${e.message}${e.hint ? ` (${e.hint})` : ""}`)
-      .join("\n");
-    throw new Error(`Dragon JSON DSL validation error:\n${msg}`);
-  }
-  const doc = jsonToDoc(v.data, opts?.行の表);
-  return compileToCdl(doc, opts);
-}
-
-/**
- * JSON DSL を validate だけ実施 (compile しない)。 error 詳細を配列で取得したい場合に使う。
- * LLM の structured output の retry loop で、 error path を prompt に注入する用途。
- */
-export function validateDragonJson(
-  json: unknown,
-): { ok: true; data: DragonJson } | { ok: false; errors: JsonDslError[] } {
-  return validateJson(json);
-}