@cardenelabs/dragon 0.30.0 → 0.33.0

package/src/compile.ts

@@ -12,29 +12,48 @@
 import type { DslDocument, DslLane, DslStep, DslEventBinding, PresetType } from "./types";
 // 図種ごとの組み立てを分けた先 (#2030)。 共有の小道具から順に出している。
 // どれも他の file を取り込まない葉なので、図種ごとの file と両方から呼んでも輪にならない
-import { 向きを選べる図種 } from "./compile/direction";
+import { 向きを選べる図種, 縦列より向きが勝つ図種, 既定の向き } from "./compile/direction";
+import { 並び順が効くか, 並び順を選べる図種 } from "./compile/order";
 import { actorRefTable, canonicalizeFlowActors } from "./compile/actors";
 import { compileC4 } from "./compile/c4";
-import { compileClass } from "./compile/class";
-import { 鎖でつなぐ形か, 鎖に並べる登場人物 } from "./compile/chain";
-import { compileEr } from "./compile/er";
+import { 鎖でつなぐ形か, 鎖に並べる登場人物, 鎖にしない書き方の案内 } from "./compile/chain";
+import { compileRecord } from "./compile/record";
+import { 行頭の印にする, 行頭の印を読むか, 鍵の行を上にまとめる } from "./compile/row-marks";
 import { compileFlow } from "./compile/flow";
 import { compileFunnel } from "./compile/funnel";
+import { 共通の組み立てへ回す } from "./compile/generic";
 import { compileGantt } from "./compile/gantt";
 
 import { compileJourney } from "./compile/journey";
 import { compileMind } from "./compile/mind";
 import { compileQuadrant } from "./compile/quadrant";
 import { compileSequence } from "./compile/sequence";
-import { compileSolidity } from "./compile/solidity";
-import { compileState } from "./compile/state";
+import { compileFlowchart } from "./compile/flowchart";
 import { compileSwimlane } from "./compile/swimlane";
 import { compileTopology } from "./compile/topology";
 import { compileTree } from "./compile/tree";
 import { compileValueChart } from "./compile/value-chart";
 import { deepRewriteStrings } from "./compile/deep-rewrite";
+import {
+  効かない箱の欄を並べる,
+  板が伝えない箱の欄,
+  木の図が伝えない箱の欄,
+  値として読む図種,
+  値として読む図が伝えない箱の欄,
+  値として読む図が主役を読む,
+  骨組みの図種,
+  骨組みの図が伝えない箱の欄,
+} from "./compile/actor-option-notice";
+import {
+  効かない矢印の欄を並べる,
+  向きだけを使う図が伝えない矢印の欄,
+} from "./compile/edge-option-notice";
 import { recordDerivedSourceLine } from "./compile/derived-source";
-import { mergePartsFromActors, reportPartNodeNotHonored } from "./compile/parts";
+import {
+  mergePartsFromActors,
+  reportPartNodeNotHonored,
+  測るために配置する,
+} from "./compile/parts";
 // 見本の取り込みが外へ出していた 13 個を、この file から出していた形のまま渡す (#2034)。
 // `index.ts` と検査が `./compile` から取り込んでいるので、窓口をここに残す
 export {
@@ -51,6 +70,7 @@ export {
   partsBaseBottom,
   partsGridCenters,
   部品に上書きを当てる,
+  測るために受け取った知らせの数,
 } from "./compile/parts";
 import { SINGLE_BOX_KINDS, 図種の作り } from "./compile/kinds";
 import { collectRenamedTargets, disambiguateActorIds, restoreActorNames } from "./compile/actor-ids";
@@ -65,7 +85,7 @@ import {
 // 箱を測る物差しを、この file から出していた形のまま外へ渡す (#2036)。
 // `index.ts` が画面側の測りに使う
 export { measureActorBoxes } from "./compile/placement-apply";
-import { 縦列を選べる図種, 書いた縦列に置く } from "./compile/lanes";
+import { 縦列を選べる図種, 書いた縦列に置く, 縦列の判定に数える箱 } from "./compile/lanes";
 import type { CompileNotice } from "./compile/notice";
 // 分けた先の型を、この file から出していた形のまま外へ渡す (#2030)。
 // `index.ts` と 47 個の検査が `./compile` から取り込んでいるので、窓口をここに残す
@@ -73,11 +93,20 @@ export type { CompileNotice } from "./compile/notice";
 import { 段を読み取る } from "./compile/rows";
 import { truncateForMessage } from "./compile/subtitle";
 import { slugify } from "./compile/slug";
+import { 省く泳法図の印を外す, 泳法図で印をどう描く } from "./compile/swimlane-marks";
 import { 語の状態を図の語へ直す } from "./compile/word-state";
-import type { CdlDiagram, CdlEdge, RowMark } from "@cardenelabs/cdl";
-import { FSM_ACTION_MARK, layout, parseFormula, extractIdentifiers, inputDefaultValue } from "@cardenelabs/cdl";
+import type { CdlDiagram, CdlEdge, CdlLegendItem, CdlNode } from "@cardenelabs/cdl";
+import { parseFormula, extractIdentifiers, inputDefaultValue } from "@cardenelabs/cdl";
 import { parseFocusEntry } from "./focus";
-import { DRAW_TARGETS } from "./v05/parser";
+import { DRAW_TARGETS, 描く語がその図を指すか } from "./v05/parser";
+import {
+  DIAGRAM_SHAPES,
+  resolveShape,
+  shapesForDiagramType,
+  棒を描く節か,
+  意匠の棒の角,
+  type DslShape,
+} from "./keywords";
 import { pointsOutside, stripExternalPaint } from "./color";
 import { countDocElements, describeOversize } from "./input-size";
 export interface CompileToCdlOpts {
@@ -131,6 +160,7 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // 端にしか出てこない名前で id を分けても、 その箱は作られない
   const 分けた = disambiguateActorIds(doc, opts?.onNotice);
   doc = 分けた.doc;
+  doc = 省く泳法図の印を外す(doc);
 
   // 図種の組み立てが知らせた行を控える (#2107 / #2111)。 同じ行に多重度の知らせを重ねない。
   // 知らせる図種も知らせの種類も手で並べず、実際に出た知らせで決める
@@ -151,53 +181,29 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
     case "flow":
       diagram = compileFlow(doc, opts?.partsCatalog);
       break;
+    case "flowchart":
+      diagram = compileFlowchart(doc);
+      break;
     case "swimlane":
       diagram = compileSwimlane(doc);
       break;
-    case "er":
-      diagram = compileEr(doc);
-      break;
-    case "state":
-      diagram = compileState(doc);
+    case "record":
+      diagram = compileRecord(doc);
       break;
     case "topology":
       diagram = compileTopology(doc);
       break;
-    case "solidity":
-      diagram = compileSolidity(doc);
-      break;
     case "gantt":
       diagram = compileGantt(doc, 図種の知らせ);
       break;
-    case "class":
-      diagram = compileClass(doc);
-      break;
-    case "pie":
-      diagram = compileValueChart(doc, "pie", "chart-pie", 図種の知らせ);
-      break;
-    case "bar":
-      diagram = compileValueChart(doc, "bar", "chart-bar", 図種の知らせ);
-      break;
-    case "line":
-      diagram = compileValueChart(doc, "line", "chart-line", 図種の知らせ);
-      break;
-    case "gauge":
-      diagram = compileValueChart(doc, "gauge", "chart-gauge", 図種の知らせ);
-      break;
-    case "radial":
-      diagram = compileValueChart(doc, "radial", "chart-radial", 図種の知らせ);
-      break;
-    case "stat":
-      diagram = compileValueChart(doc, "stat", "chart-stat", 図種の知らせ);
-      break;
-    case "waffle":
-      diagram = compileValueChart(doc, "waffle", "chart-waffle", 図種の知らせ);
-      break;
-    case "stacked":
-      diagram = compileValueChart(doc, "stacked", "chart-stacked-bar", 図種の知らせ);
-      break;
-    case "slope":
-      diagram = compileValueChart(doc, "slope", "chart-slope", 図種の知らせ);
+    case "chart":
+      // 形は `shape:` が決める (#2657)。 書かなければ棒 = 数を並べる図で最も素直な形で、
+      // 形を書かずに数だけ書いた記法が図にならない状態を作らない
+      diagram = compileValueChart(
+        doc,
+        doc.shape === undefined ? "bar" : (resolveShape(doc.shape) ?? "bar"),
+        図種の知らせ,
+      );
       break;
     case "funnel":
       diagram = compileFunnel(doc, 図種の知らせ);
@@ -234,10 +240,10 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   const 矢印の行 = new Map<string, DslStep>();
   applyEdgeInlineOptions(diagram, doc, edgeSourceLines, 矢印の行, opts?.partsCatalog);
   const 作った組の枠 = applyGroupContainers(diagram, doc);
-  applyNodeTones(diagram, doc);
   // 光らせる相手が実在するかを確かめる。 id への解決は図種ごとに違うが、 名前が居るか
-  // 居ないかは記述だけで決まるので 1 か所で見る
-  reportMissingFocusTargets(書いたまま, opts?.onNotice);
+  // 居ないかは記述だけで決まるので 1 か所で見る。
+  // 記法にはあるのに図がその相手を持たない形 (#2398) は、組み上がった図と突き合わせる
+  reportMissingFocusTargets(書いたまま, opts?.onNotice, diagram);
   // 矢印が指す名前が actors に居るかを確かめる。 図種ごとの解決より前に、 記述だけで決まる
   reportMissingFlowActors(書いたまま, opts?.onNotice);
   // 両端が同じ矢印を伝える (#1227)。 落とす前の `flow` を見る
@@ -245,12 +251,39 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // 自分へ戻る形と居ない名前を指す形は既に落ちた後の `doc` を見る = 上の 2 件と重ねない
   reportFlowEndpointNotHonored(doc, 分けた.元の名前, opts?.onNotice, opts?.partsCatalog);
   reportLaneNotHonored(書いたまま, opts?.onNotice);
-  reportActorKindNotHonored(書いたまま, opts?.onNotice);
+  /*
+   * 箱の知らせが出た行を控える (#2368)。 片方だけの位置の知らせ (#2362) を同じ行に重ねない。
+   *
+   * 知らせる図種も知らせの種類も手で並べず、実際に出た知らせで決める (`図種の知らせ` と同じ形)。
+   */
+  const 箱に知らせた行 = new Set<number>();
+  const 箱の知らせ = 受け取り口
+    ? (n: CompileNotice): void => {
+        箱に知らせた行.add(n.line);
+        受け取り口(n);
+      }
+    : undefined;
+  reportActorKindNotHonored(書いたまま, 箱の知らせ);
+  reportTreeActorOptionNotHonored(書いたまま, 箱の知らせ);
+  reportValueChartActorOptionNotHonored(書いたまま, 箱の知らせ);
+  reportSkeletonActorOptionNotHonored(書いたまま, 箱の知らせ);
+  reportHalfWrittenPosition(書いたまま, 箱に知らせた行, opts?.onNotice);
+  // 出した行を `図種が知らせた行` に控える = 多重度の知らせ (#2107) を同じ行に重ねない
+  reportSkeletonEdgeOptionNotHonored(書いたまま, 図種が知らせた行, 図種の知らせ);
   reportMessageOptionNotHonored(書いたまま, opts?.onNotice);
+  reportBandProblems(書いたまま, diagram, opts?.onNotice);
   reportCardinalityNotHonored(書いたまま, 図種が知らせた行, opts?.onNotice);
   reportFlowOffsetNotHonored(書いたまま, opts?.onNotice);
   reportDocEyebrowNotHonored(書いたまま, opts?.onNotice);
   reportDirectionNotHonored(書いたまま, opts?.onNotice);
+  reportOrderNotHonored(書いたまま, opts?.onNotice);
+  reportShapeNotHonored(書いたまま, opts?.onNotice);
+  reportFormNotHonored(書いたまま, opts?.onNotice);
+  reportTicksNotHonored(書いたまま, opts?.onNotice);
+  reportLaneSubtitleNotHonored(書いたまま, opts?.onNotice);
+  reportStageFromLane(書いたまま, opts?.onNotice);
+  reportTrackFromName(書いたまま, opts?.onNotice);
+  reportThemeAlsoPalette(書いたまま, opts?.onNotice);
   reportDrawNotHonored(書いたまま, opts?.onNotice);
   reportChartFieldsNotHonored(書いたまま, opts?.onNotice);
   reportAxesNotHonored(書いたまま, opts?.onNotice);
@@ -262,6 +295,19 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // CAR-1657 = parts kind actor を merge (opts.partsCatalog 経由)、 applyV05Extensions 後段で実行
   const 追加した縦列: DslLane[] = [];
   const extended = applyV05Extensions(diagram, placed, 追加した縦列);
+  /*
+   * 書いた色を箱に載せる (#2333)。 **題を写した後に呼ぶ**。
+   *
+   * 照合は箱に出る題で行う (理由は `applyNodeTones` の説明)。 その題が箱に入る時点が
+   * 図種で 2 つに割れており、15 図種は組み立て器が `箱の題` で入れる一方、
+   * 順序図 / 帯図 / c4 は登場人物の名前で箱を作り、`applyV05Extensions` が
+   * 題へ書き換える。 書き換えより前に照合すると、後者の 4 図種で題と名前が食い違う。
+   *
+   * 実測 = ここより前で呼んでいた間、題を書いた箱の色が 5 図種 (フロー / 構成図 /
+   * 状態遷移 / クラス図 / ER 図) で消え、名前で照合していたため帯図と c4 だけが通っていた。
+   * 呼ぶ位置を変えずに照合だけを題へ寄せると、今度は帯図と c4 が落ちる (実測)。
+   */
+  applyNodeTones(extended, placed);
   // 値の知らせは、本文なら値を書いた行、見本なら見本を置いた行を指す。 `derived` 自体には
   // source position が無いため、見本を重ねる間だけ別表で宣言元を持ち回る (#1180)。
   const inheritedDerivedSourceLines = opts?.onNotice ? new Map<string, number[]>() : undefined;
@@ -298,8 +344,8 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // 動かない図に段を 1 つ入れる (#1086)。
   //
   // 描画側は「段が 1 件以上」 を要求するが、 段を作るかどうかは種類ごとにばらけている。
-  // 実測 = `animation:` を書かない同じ記法を 12 種に与えると、 6 種 (sequence / flow / er /
-  // state / topology / solidity) は描かれ、 6 種 (swimlane / gantt / class / pie / c4 / mind)
+  // 実測 = `animation:` を書かない同じ記法を旧 12 種に与えると、6 種 (sequence / flow / er /
+  // state / topology) は描かれ、6 種 (swimlane / gantt / class / pie / c4 / mind)
   // は「phase が 0 件です」 で弾かれた。 書く人から見ると区別する手がかりが無い。
   //
   // **出口で 1 度だけ見る**。 種類ごとに塞ぐと 12 経路のどれかを見落とす。 図は必ずここを
@@ -329,8 +375,12 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   if (doc.readouts && doc.readouts.length > 0) {
     // 出口の paint 検査は diagram を直接書き換える。 doc の object を共有すると、検査が
     // compileToCdl の入力まで書き換えて入力不変性を壊すため、nested field も含めて写す。
-    const ownReadouts = doc.readouts.map(
-      (readout) => deepRewriteStrings(readout, (value) => value) as typeof readout,
+    //
+    // **書いた行は図へ載せない** (#2405)。 行は読む元の名前を突き合わせた知らせのために持つ。
+    // 残すと、行を足しただけで組み上がる図が変わる。
+    type 図の読み取り値 = NonNullable<CdlDiagram["readouts"]>[number];
+    const ownReadouts = doc.readouts.map(({ pos: _書いた行, ...readout }) =>
+      deepRewriteStrings(readout, (value) => value) as 図の読み取り値,
     );
     merged.readouts = [...(merged.readouts ?? []), ...ownReadouts];
   }
@@ -427,6 +477,12 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
     if (載せる式.length > 0) merged.formulas = 載せる式;
     else delete merged.formulas;
   }
+  // **3 つの節を全て載せ終えてから呼ぶ** = 読む元は `states` / `inputs` / `formulas` に散っており、
+  // 途中で呼ぶと、後から載る節の名前を「無い」 と知らせる
+  // **つまみを載せ終えてから呼ぶ** = 記法は `states:` を `inputs:` より前に書けるため、
+  // 途中で呼ぶと後から載るつまみを見落とす
+  reportStateInputMismatch(doc, merged, opts?.onNotice);
+  reportReadoutSourceMissing(doc, merged, opts?.onNotice);
   /*
    * 押下などの出来事で動く仕掛けを図に載せる (#1393)。
    *
@@ -441,13 +497,34 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
     for (const e of doc.events) {
       const 相手 = 出来事の相手を解く(merged, doc, e);
       if (相手 === undefined) {
-        opts?.onNotice?.({
-          kind: "event-target-missing",
-          actor: e.handlerId,
-          line: e.pos.line,
-          message: `出来事 "${e.handlerId}" が指す相手が見つかりません`,
-          hint: "box は箱の名前、 lane は縦列の名前、 arrow は `A -> B` で書く",
-        });
+        /*
+         * **原因を 2 つに分ける** (#2336)。 書いた名前が本文に在るかで、直し方が正反対になる。
+         *
+         * 無い = 綴り違いなので「名前で書く」 の案内が効く。
+         * 在る = その図種が登場人物を箱 / 矢印にしないので、同じ案内に従っても永久に直らない。
+         * 1 つの知らせにまとめていた間、後者は書き直しの繰り返しに入る形だった
+         * (実測 = 24 図種のうち箱を指せるのは 7 図種)。
+         */
+        const 呼び名 = 出来事の相手の呼び名[e.target.kind];
+        opts?.onNotice?.(
+          出来事の相手が本文に在る(doc, e)
+            ? {
+                kind: "event-target-not-honored",
+                actor: e.handlerId,
+                line: e.pos.line,
+                message:
+                  `type: ${doc.type} は書いた名前を${呼び名}にしないため、` +
+                  ` 出来事 "${e.handlerId}" を付けられません`,
+                hint: `名前の書き方の問題ではありません。 図そのもの (\`diagram: true\`) を指すか、${呼び名}を作る図種に変えてください`,
+              }
+            : {
+                kind: "event-target-missing",
+                actor: e.handlerId,
+                line: e.pos.line,
+                message: `出来事 "${e.handlerId}" が指す相手が見つかりません`,
+                hint: "box は箱の名前、 lane は縦列の名前、 arrow は `A -> B` で書く",
+              },
+        );
         continue;
       }
       載せる.push({
@@ -484,9 +561,31 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // 作り替えた名前を表示だけ戻す (#1220)。 **図への追加を全て終えた後**に戻す = 途中で戻すと、
   // 後続の処理が名前で引く時に作り替え前と後が混ざる
   restoreActorNames(merged, 分けた.元の名前, 作り替えた対象);
-  // 配色と行の縞は **図への追加を全て終えた後**に当てる (#1553)。 図種ごとの組み立ては
-  // 20 か所以上あり、そのどれに足しても残りが取り残される
+  // 字幅・配色・行の縞は **図への追加を全て終えた後**に当てる (#1553 / #2918)。
+  // 図種ごとの組み立ては 20 か所以上あり、そのどれに足しても残りが取り残される
   配色と縞を当てる(merged, doc);
+  if (doc.legend && doc.legend.length > 0) {
+    // cdl 0.129.0 の凡例は印付き項目と注記の union。両方の欄を落とさず、組み立て API と
+    // 同じ順 (mark/text/tone/lineStyle または text/align/lead) で写す。
+    merged.legend = doc.legend.map((item) =>
+      (item.mark === undefined
+        ? {
+            text: item.text,
+            ...(item.align === undefined ? {} : { align: item.align }),
+            ...(item.lead === undefined ? {} : { lead: item.lead }),
+          }
+        : {
+            mark: item.mark,
+            text: item.text,
+            ...(item.tone === undefined ? {} : { tone: item.tone }),
+            ...(item.lineStyle === undefined ? {} : { lineStyle: item.lineStyle }),
+          }) as CdlLegendItem,
+    );
+  }
+  if (doc.legendFontSize !== undefined) merged.legendFontSize = doc.legendFontSize;
+  if (doc.legendOffset !== undefined) merged.legendOffset = doc.legendOffset;
+  if (doc.edgeEndGap !== undefined) merged.edgeEndGap = doc.edgeEndGap;
+  if (doc.stageLayout !== undefined) merged.stageLayout = doc.stageLayout;
   静止した図の焦点を外す(merged, doc);
   // 位置のずらしは **配置に効く欄を全て載せた後** に当てる (#1971)。 縦列の幅や視点の間隔を
   // 足す前に測ると、後から足された分だけ狙いがずれる
@@ -494,9 +593,44 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // 組の枠は **縦列の位置が全て決まった後** に置く (#1972)。 位置のずらしより前に置くと、
   // ずらした縦列から枠が離れる
   applyGroupFrames(merged, doc, 作った組の枠, opts?.onNotice);
+  cdlの未指定欄を外す(merged);
   return merged;
 }
 
+/** cdl が object に足す未指定欄を、記法で値を書かなかった時の省略形へ戻す。 */
+function cdlの未指定欄を外す(diagram: CdlDiagram): void {
+  for (const node of diagram.nodes) {
+    if (node.terminalDecoration === undefined) delete node.terminalDecoration;
+    if (node.cornerForm === undefined) delete node.cornerForm;
+    if (node.figureKindLabel === undefined) delete node.figureKindLabel;
+    if (node.figureInset === undefined) delete node.figureInset;
+    if (node.chartBarSize === undefined) delete node.chartBarSize;
+    if (node.chartBarShape === undefined) delete node.chartBarShape;
+    if (node.barCornerRadii === undefined) delete node.barCornerRadii;
+    if (node.chartLineSize === undefined) delete node.chartLineSize;
+    if (node.chartPieSize === undefined) delete node.chartPieSize;
+    if (node.chartWaffleSize === undefined) delete node.chartWaffleSize;
+    if (node.chartSlopeLabelTemplate === undefined) delete node.chartSlopeLabelTemplate;
+    if (node.chartSlopeSize === undefined) delete node.chartSlopeSize;
+    if (node.chartStackedLayout === undefined) delete node.chartStackedLayout;
+    if (node.chartGaugeSize === undefined) delete node.chartGaugeSize;
+    if (node.ganttSize === undefined) delete node.ganttSize;
+    if (node.journeySize === undefined) delete node.journeySize;
+    if (node.quadrantLabelPosition === undefined) delete node.quadrantLabelPosition;
+    if (node.quadrantSize === undefined) delete node.quadrantSize;
+  }
+  for (const edge of diagram.edges) {
+    if (edge.posX1 === undefined) delete edge.posX1;
+    if (edge.posY1 === undefined) delete edge.posY1;
+    if (edge.posX2 === undefined) delete edge.posX2;
+    if (edge.posY2 === undefined) delete edge.posY2;
+    if (edge.waypoints === undefined) delete edge.waypoints;
+    if (edge.labelCollision === undefined) delete edge.labelCollision;
+    if (edge.labelSize === undefined) delete edge.labelSize;
+  }
+  if (diagram.stageLayout === undefined) delete diagram.stageLayout;
+}
+
 /**
  * 段を書かない図では、どの箱も「いま」 にしない (#1557)。
  *
@@ -507,7 +641,7 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
  * dragon が 1 段を足す経路 (`injectStaticPhase`)。 どちらも **全ての箱と矢印を段に載せる**。
  *
  * 描画側は段に載った箱を「いま」 として描く (枠を主役色にして太くする)。 その結果、静止した図は
- * 全ての箱が「いま」 になり、止まっている箱の枠が 1 度も出ない (実測 = ER 図 3 箱 / 流れ図 2 箱)。
+ * 全ての箱が「いま」 になり、止まっている箱の枠が 1 度も出ない (実測 = ER 図 3 箱 / フロー 2 箱)。
  *
  * 全部を強調するのと何も強調しないのは、どちらも「区別が無い」 状態。 後者の方が落ち着いて読める。
  *
@@ -529,39 +663,57 @@ function 静止した図の焦点を外す(diagram: CdlDiagram, doc: DslDocument
   }
 }
 
-const 既定の配色を持つ図種: ReadonlySet<DslDocument["type"]> = new Set(["er", "class"]);
+/**
+ * 行を書いた箱か (#2782)。 縞を敷く相手を決める。
+ *
+ * 縞の目的は行を横に追うことなので、行が無い箱に敷いても追う対象が無い。
+ */
+function 行を書いた箱か(node: CdlNode): boolean {
+  return (node.rows?.length ?? 0) > 0;
+}
 
 /**
- * 図の配色と、表の箱の行の縞を当てる (#1553)。
+ * 図の字幅・配色と、行を書いた箱の縞を当てる (#1553 / #2782 / #2918)。
  *
  * ## 配色
  *
  * cdl は色を持たない。 名前だけを `data-cdl-palette` として markup に出し、消費側
  * (`cdl-theme.css`) が名前を見て 7 つの口 (台 / 行の面 / 縞 / 枠 / 字 / 型名 / 線) に色を当てる。
+ * 字の測り方は配色の有無にかかわらず、この出口で比例・等幅の広い方へ揃える。端末だけ
+ * 等幅へ替えると配色で骨組みが変わり、比例だけでは端末の字が箱から出るためである。
+ * この出口は後段の配置計算より前なので、箱・札・縦列の隙間も同じ幅で測られる (#2818)。
  *
- * ER 図とクラス図は書かなくても `kinari` (生成りに茶) になる。
- * どちらも箱の作りが同じ (行頭の印 + 左に名前 + 右に型) で、名前と型が離れて並ぶため、
- * 行を横に追う目印 (行の縞) が要る。
- * 縞の色は配色からしか来ないので、既定が無いと縞が箱の面と同じ色に落ちて 1 本も出ない。
- * 書き手が `palette:` を書いた時はそちらが勝つ。
+ * **`record` は書かなければ配色を持たない** (#2782)。 畳む前は `type: er` が書かなくても
+ * `kinari` (生成りに茶) になったが、畳んだ先には移り変わりを書いた図も入る。
+ * 表の図と移り変わりの図は行の有無でも行の中身でも分かれない = 同じ `kind: storage` に
+ * 同じ形の行 (`督促を送る: 7 日ごと`) を書く。 分けられない材料で推し量ると、
+ * どちらかの図が書いていない色みを名乗る。
  *
- * クラス図の意匠は `docs/design/class/note.md` が持つ。
+ * これは #2782 で落とした 3 つの既定 (始まりと終わりの札 / 矢印の先端 / 箱の種類) と
+ * 同じ形で、**書かないものを図が名乗らない** 側に倒している。
+ * 表の図には見本の側で `palette: kinari` を書く。
  *
  * ## 行の縞
  *
- * cdl の `er()` 組み立て器は縞を既定で敷くが、**動きを持つ ER 図はその経路を通らない**
- * (`compileGenericWithAnimate` が箱を直に組む)。 同じ図が動きの有無で縞を持ったり持たなかったり
- * しないよう、出口で揃える。
+ * 縞の色は配色からしか来ない。 配色が無い図に敷くと箱の面と同じ色に落ちて 1 本も出ないので、
+ * **配色が決まった図の、行を書いた表の箱** にだけ敷く。
  *
- * 縞を描くのは表の箱 (`storage`) だけ。 他の種別の箱に書いても描画側が読まないので、
- * ここで対象を絞って「書いたのに出ない」 欄を残さない。
+ * 畳む前は組み立て器 `er()` が縞を敷く経路と、箱を直に組む経路の 2 つがあり、同じ図が
+ * 動きの有無で縞を持ったり持たなかったりしていた。 経路が 1 本になった後も出口で揃える。
  */
 function 配色と縞を当てる(diagram: CdlDiagram, doc: DslDocument): void {
-  const 配色 = doc.palette ?? (既定の配色を持つ図種.has(doc.type) ? "kinari" : undefined);
-  if (配色 !== undefined) diagram.palette = 配色;
-  if (doc.type !== "er") return;
+  diagram.textMetrics = "widest";
+  const 配色 = doc.theme;
+  if (配色 === undefined) return;
+  diagram.palette = 配色;
   for (const node of diagram.nodes) {
-    if (node.kind === "storage") node.rowStripe = true;
+    if (棒を描く節か(node)) {
+      const 棒の角 = 意匠の棒の角(配色, node);
+      if (棒の角 !== undefined) node.barCornerRadii = 棒の角;
+    }
+    if (node.kind === "storage" && 行を書いた箱か(node) && node.rowStripe === undefined) {
+      node.rowStripe = true;
+    }
   }
 }
 
@@ -708,15 +860,20 @@ function reportDrawNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) =>
       });
       continue;
     }
-    // 語が別の図種を指している形 (#1314)。 図は描けるので誤りにはしない
-    const 語の図種 = DRAW_TARGETS.get(phase.draw);
-    if (語の図種 !== undefined && 語の図種 !== doc.type) {
+    // 語が別の図を指している形 (#1314)。 図は描けるので誤りにはしない
+    const 相手 = DRAW_TARGETS.get(phase.draw);
+    const 数の図の形 = doc.shape === undefined ? undefined : (resolveShape(doc.shape) ?? undefined);
+    if (相手 !== undefined && !描く語がその図を指すか(phase.draw, doc.type, 数の図の形)) {
+      // 数を描く図は 1 つの型に 9 つの形が入るので、相手も この図も形で名乗る (#2657)
+      const 名乗り = (t: PresetType, sh: DslShape | undefined): string =>
+        t === "chart" && sh !== undefined ? `type: chart と shape: ${sh}` : `type: ${t}`;
+      const この図 = 名乗り(doc.type, 数の図の形);
       onNotice({
         kind: "draw-target-mismatch",
         actor: phase.name,
         line,
-        message: `段 "${phase.name}" の draw: ${phase.draw} は type: ${doc.type} では効きません (${phase.draw} は type: ${語の図種} の図に書きます)`,
-        hint: `この図では draw: ${doc.type} と書いてください`,
+        message: `段 "${phase.name}" の draw: ${phase.draw} は ${この図} では効きません (${phase.draw} は ${名乗り(相手.type, 相手.shape)} の図に書きます)`,
+        hint: `この図では draw: ${doc.type === "chart" ? (doc.shape ?? "bar") : doc.type} と書いてください`,
       });
     }
   }
@@ -728,7 +885,9 @@ function reportDrawNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) =>
  * **語と図種の対応表から導く** (`DRAW_TARGETS`)。 一覧を写すと、語を足した時に片方だけ
  * 古いまま残る。 描画側 (`cdl` の `DRAW_KINDS`) が対応する種別と一致する。
  */
-const DRAWABLE_DOC_TYPES: ReadonlySet<PresetType> = new Set<PresetType>(DRAW_TARGETS.values());
+const DRAWABLE_DOC_TYPES: ReadonlySet<PresetType> = new Set<PresetType>(
+  [...DRAW_TARGETS.values()].map((v) => v.type),
+);
 
 /**
  * 縦列を選べる図種で、一部の箱だけが縦列を書いた時に伝える (#1263)。
@@ -737,9 +896,12 @@ const DRAWABLE_DOC_TYPES: ReadonlySet<PresetType> = new Set<PresetType>(DRAW_TAR
  * 書いた人の意図と一致する保証が無い。 **全部書くか 1 つも書かないか** を求める。
  *
  * 1 つも書いていない形は従来どおりの並びになるだけなので知らせない。
+ *
+ * 数える箱は置く側と同じ `縦列の判定に数える箱` から採る (#2372)。 別々に数えると、
+ * 見本だけの図で「一部だけ書いた」 形が知らせずに落ちる。
  */
 function reportLaneMixed(doc: DslDocument, onNotice: (n: CompileNotice) => void): void {
-  const 対象 = doc.actors.filter((a) => a.partId === undefined);
+  const 対象 = 縦列の判定に数える箱(doc);
   const 書いた = 対象.filter((a) => a.lane !== undefined);
   if (書いた.length === 0 || 書いた.length === 対象.length) return;
   const 書いていない = 対象.filter((a) => a.lane === undefined);
@@ -810,11 +972,33 @@ function reportFlowEndpointNotHonored(
       actor: 書いた名前(s.from),
       line: s.pos.line,
       message: `"${truncateForMessage(書いた名前(s.from))} -> ${truncateForMessage(書いた名前(s.to))}" の端は使われません (type: flow は登場人物を書いた順に繋ぎます)`,
-      hint: "書いた端どおりに繋ぐには、direction: 縦 を書くか箱に lane: を書いてください (向きか縦列を書いた形は書いた端がそのまま矢印になります)",
+      hint: `書いた端どおりに繋ぐには次のどれかを書いてください: ${鎖にしない書き方の案内()} (どれも書いた端がそのまま矢印になります)`,
     });
   }
 }
 
+/**
+ * 板の言づてで、効かないと伝えない矢印の欄 (#2356)。
+ *
+ * **除外側を書く**。 効かない欄を並べる形にすると、矢印に欄を足した日にその欄だけが
+ * 一覧から漏れ、書いた人には「書いたのに何も起きない」 としか見えない。
+ *
+ * | 区分 | 欄 |
+ * |---|---|
+ * | 板が描く | 出どころ / 行き先 / 語 / 言づての種類 と、行番号と書いた場所 |
+ * | 別の知らせが受け持つ | 部品の端 (`part-node-ignored` が 1 件ずつ伝える) |
+ */
+const 板が伝えない矢印の欄: ReadonlySet<string> = new Set([
+  "no",
+  "from",
+  "to",
+  "label",
+  "msgKind",
+  "pos",
+  "fromPartNode",
+  "toPartNode",
+]);
+
 /**
  * 順序図の言づてに書いた飾りが使われないことを伝える (#1466)。
  *
@@ -822,29 +1006,20 @@ function reportFlowEndpointNotHonored(
  * 色味 (`tone`) / 添え字 (`sub`) / 寄せ (`side`) が矢印に付いていたが、板では行になった。
  * 黙って落とすと、書いた側は効いていると思い込む。
  *
- * 同じ理由で、後から名前のずらし (#1971) と多重度 (#2107) も数える。 数える飾りは下の一覧が持ち、
- * 説明には写さない。
+ * **伝える欄を並べない** (#2356)。 以前は色味 / 添え字 / 寄せ / 名前のずらし / 多重度 を手で並べて
+ * いたため、後から足した項目がどこにも入らなかった (実測 = 矢印に書ける 21 項目のうち 13 件が、
+ * 図も変わらず知らせも出ないまま落ちていた)。 板が描く欄を **除いた残り全部** を伝える。
  *
  * `actors` に無い名前を指す言づては見ない (#2111)。 その言づては組み立ての前に落ちて板に載らず、
  * 同じ行を居ない名前の知らせ (`reportMissingFlowActors`) が指している。
  */
 function reportMessageOptionNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
   if (!onNotice) return;
-  if (doc.type !== "sequence" && doc.type !== "solidity") return;
+  if (doc.type !== "sequence") return;
   const 名前の表 = actorRefTable(doc);
   for (const s of doc.flow) {
     if (!名前の表.has(s.from) || !名前の表.has(s.to)) continue;
-    const 効かない = [
-      s.tone !== undefined ? "色味" : "",
-      s.sub !== undefined ? "添え字" : "",
-      s.side !== undefined ? "寄せ" : "",
-      // 名前のずらしも板には載せる先が無い (#1971)。 位置のずらし (`pos`) は名前のずらしに足す欄なので同じ扱い
-      s.layoutPos !== undefined || s.labelOffsetX !== undefined || s.labelOffsetY !== undefined
-        ? "名前のずらし"
-        : "",
-      // 多重度も板には描く先が無い (#2107)。 他の図種は `reportCardinalityNotHonored` が知らせる
-      書いた多重度を読む(s.cardinality) !== undefined ? "多重度" : "",
-    ].filter((x) => x !== "");
+    const 効かない = 効かない矢印の欄を並べる(s, 板が伝えない矢印の欄);
     if (効かない.length === 0) continue;
     onNotice({
       kind: "message-option-not-honored",
@@ -856,10 +1031,268 @@ function reportMessageOptionNotHonored(doc: DslDocument, onNotice?: (n: CompileN
   }
 }
 
+/**
+ * 名前を指す欄かどうかを、 綴りで決める (#2405)。
+ *
+ * 部品の表 (`readout-table.generated.ts`) の 107 種が持つ欄のうち、 別の所に書いた値を名前で
+ * 指すのは `source` / `〜Source` / `sourceA` の 3 つの形。 表そのものは「文字列」 としか
+ * 言わないため、 どの文字列が名前かは綴りからしか決められない。
+ *
+ * **規則から外れた綴りで名前の欄が足されると、 その欄だけが黙る**。 規則に当たらない欄の
+ * 一覧を検査で固定し、 増えた日に人が 1 件ずつ見分ける形にする
+ * (`test/readout-source-2405.test.ts`)。
+ */
+function 名前を指す欄(欄名: string): boolean {
+  return 欄名 === "source" || 欄名.endsWith("Source") || /^source[A-Z]$/.test(欄名);
+}
+
+/**
+ * 値を見せる部品 (`readouts:`) が読む元の名前を突き合わせて知らせる (#2405)。
+ *
+ * ## 直す前に起きていたこと
+ *
+ * 読み取り値は `source: done` の形で、 別の所に書いた値を名前で指す。 **その名前が在るかを
+ * 誰も見ていなかった** = 状態を指す図も、 どこにも無い名前を指す図も、 大文字小文字を
+ * 間違えた図も、 すべて知らせ 0 件で同じ形のまま描く側へ渡っていた (実測 6 通り)。
+ * 描く側は知らない名前を読むと何も出さないので、 書いた人には「部品を置いたのに数字が
+ * 出ない」 だけが残る。
+ *
+ * ## 読む元は 3 つ
+ *
+ * `states` / `inputs` / `formulas`。 式の名前の突き合わせ (`formula-unresolved`) は
+ * つまみと先に書いた式の 2 つしか見ないが、 読み取り値は状態も読めるので 3 つを合わせる。
+ *
+ * ## 3 つの節を全て載せ終えてから呼ぶ
+ *
+ * 記法は `readouts:` を 3 つの節より前に書ける。 途中で呼ぶと、 後から載る節の名前を
+ * 「無い」 と知らせる。
+ *
+ * ## 見る欄を `source` だけにしない
+ *
+ * `stacked-bar` は `source` を持たず `sourceA` / `sourceB` だけを持つ。 `source` だけを
+ * 見る形にすると、 その種類が丸ごと黙ったまま残る (表の 107 種が持つ名前の欄は 24 種類)。
+ *
+ * ## 1 つの部品で 2 つ外れたら 2 件とも出す
+ *
+ * 片方で打ち切ると、 直した次の回にもう片方が初めて出る。
+ */
+function reportReadoutSourceMissing(
+  doc: DslDocument,
+  merged: CdlDiagram,
+  onNotice?: (n: CompileNotice) => void,
+): void {
+  if (!onNotice) return;
+  const 読み取り値 = doc.readouts ?? [];
+  if (読み取り値.length === 0) return;
+  const 書かれた名前 = new Set<string>([
+    ...(merged.states ?? []).map((x) => x.id),
+    ...(merged.inputs ?? []).map((x) => x.id),
+    ...(merged.formulas ?? []).map((x) => x.id),
+  ]);
+  const hint = 書ける値の案内(書かれた名前);
+  for (const r of 読み取り値) {
+    for (const [欄, 値] of Object.entries(r)) {
+      if (!名前を指す欄(欄) || typeof 値 !== "string") continue;
+      if (書かれた名前.has(値)) continue;
+      onNotice({
+        kind: "readout-source-missing",
+        actor: 値,
+        line: r.pos?.line ?? 0,
+        message: `部品 "${truncateForMessage(r.id)}" の ${欄} が、 状態でもつまみでも式でもない名前 "${truncateForMessage(値)}" を読んでいます`,
+        hint,
+      });
+    }
+  }
+}
+
+/**
+ * 状態 (`states:`) とつまみ (`inputs:`) に同じ名前を書いて、 値がずれたことを知らせる (#2413)。
+ *
+ * ## 両方に書くこと自体は意図された書き方
+ *
+ * 状態が静止した図の値を決め、 つまみが読み手に値を変えさせる。 カタログの見本 105 箇所が
+ * この形で書かれているので、 重なりそのものは誤りにしない。
+ *
+ * ## ずれると状態の初期値は図のどこにも出ない
+ *
+ * 描く側は `mergeStateValues(base, overrides)` でつまみの既定値を状態の上に塗り、
+ * 静止した最初の一枚にもつまみの既定値が入る。 見本 77 組は 1 組もずれておらず、
+ * 書き手が全部手で揃えている決まりなのに、 守れているかを見る仕組みが無かった。
+ *
+ * ## 効く既定値を自前で導かない
+ *
+ * 種類によって値の作り方が違い、 欄の名前からは導けない (`timeline` は `defaultSpeedIdx` を
+ * 持つが効く既定値は 0)。 描く側が書き出している `inputDefaultValue` をそのまま呼ぶ。
+ *
+ * ## 突き合わせは文字列で行う
+ *
+ * 描く側が `merged[key] = String(v)` で文字列にしてから塗るため、 `42` と `"42"` は
+ * 同じ値として扱う。
+ *
+ * ## 式と巻き上げは対象にしない
+ *
+ * 静止した最初の一枚 (`serverSnapshot`) に入るのはつまみの既定値だけで、 式や巻き上げが
+ * 値を作るまでは状態の初期値が見える。 置き値として役に立つので、 ずれていても誤りにならない。
+ */
+function reportStateInputMismatch(
+  doc: DslDocument,
+  merged: CdlDiagram,
+  onNotice?: (n: CompileNotice) => void,
+): void {
+  if (!onNotice) return;
+  const つまみ = merged.inputs ?? [];
+  if (つまみ.length === 0) return;
+  const 状態 = new Map((doc.animate?.states ?? []).map((s) => [s.name, s]));
+  if (状態.size === 0) return;
+  for (const input of つまみ) {
+    const s = 状態.get(input.id);
+    if (s === undefined) continue;
+    const 既定 = inputDefaultValue(input);
+    if (既定 === undefined) continue;
+    if (String(s.initial) === String(既定)) continue;
+    onNotice({
+      kind: "state-shadowed-by-input",
+      actor: input.id,
+      line: s.pos.line,
+      message: `"${truncateForMessage(input.id)}" を states と inputs の両方に書いていますが、 値が違います (states の ${truncateForMessage(String(s.initial))} は出ません。 つまみの ${truncateForMessage(String(既定))} が使われます)`,
+      hint: `states の初期値をつまみの既定値 ${truncateForMessage(String(既定))} に揃えるか、 どちらか一方だけに書く`,
+    });
+  }
+}
+
+/**
+ * 「states / inputs / formulas に書いた名前で指す」 の直し方を 1 本作る (#2405)。
+ *
+ * 並べる件数と 1 件ずつの長さを切るのは `書ける面の案内` と同じ理由 = 名前を上限まで書いた
+ * 図で知らせが数百 MB になる。
+ */
+function 書ける値の案内(書かれた名前: ReadonlySet<string>): string {
+  const 見せる数 = 8;
+  const 全部 = [...書かれた名前];
+  if (全部.length === 0) return "states / inputs / formulas のどれかに値を書く";
+  const 一覧 = 全部.slice(0, 見せる数).map(truncateForMessage).join(" / ");
+  const 残り = 全部.length - 見せる数;
+  return `states / inputs / formulas に書いた名前で指す (${一覧}${残り > 0 ? ` ほか ${残り} 件` : ""})`;
+}
+
+/**
+ * 順序図の帯 (`bands:`) に書いた面の名前と言づての番号を突き合わせて知らせる (#2404)。
+ *
+ * ## なぜ誤りにせず知らせにするか
+ *
+ * 帯が 1 本ずれても図は出る。 「別の所に書いた名前を指す」 欄は 4 つとも知らせで扱っており
+ * (箱の `lane` / 組の `lanes` / 出来事の `box` / 矢印の端)、 帯だけを誤りにする理由が無い。
+ *
+ * ## 帯を描かない図種は、 それを先に知らせて打ち切る
+ *
+ * 帯は板の縦線に重ねる四角なので、 板を作らない図種には載せる先が無い
+ * (実測 = 24 図種のうち 22 図種が `bands:` を読んだうえで黙って捨てていた)。
+ * その図で名前や番号を直しても帯は出ないため、 直しても直らない案内を返さない。
+ *
+ * **図種を手で並べない**。 組み上がった図が板を持つかで決める = 図種を足した日にずれない
+ * (`rules/quality.md` の導出可能記述)。
+ *
+ * ## なぜ読む側ではなくここで確かめるか
+ *
+ * 記法は `bands:` を `actors:` より前に書ける = 読む途中では面の一覧が揃っていない。
+ * 板に載る言づての数も `flow:` を読み終えるまで決まらない。 組み立ての入口は両方を持っている。
+ *
+ * ## 突き合わせ先は「書いた `actors`」
+ *
+ * 板の図種は箱が 1 つしか無く、 面は箱の中の行になる = 組み上がった図と突き合わせる相手が居ない
+ * (段の注目先 #2398 と同じ)。 名前の受け方は矢印の端と同じ表 (`actorRefTable`) を使うので、
+ * id の形 (`api-gateway`) で書いた指定も通る。
+ *
+ * ## 番号が指すのは言づての行で、 0 から数える
+ *
+ * 記法の `- DB: 1..2` は段 (`animation` の `step`) ではなく **板に載る言づての行**を指す
+ * (実測 = 描く側は `rowY(from)` と `rowY(to)` で四角の上下を決め、 `rowY(i)` は i 通目の
+ * 言づての高さを返す)。 見本もその読み方で書かれている (面 4 つ ・ 言づて 7 通の図で
+ * `ブラウザ: 0..5` / `DB: 6..6`)。
+ *
+ * 段と言づては数も起点も違う = 段で数えると、 正しく書いた見本を範囲外として知らせてしまう。
+ *
+ * ## 板に載らない言づてを数に入れない
+ *
+ * `actors` に無い名前を指す言づては組み立ての前に落ちて板に載らない (実測 = 3 通のうち 1 通が
+ * 落ちて 2 通になる)。 書いた行数で数えると、 落ちた分だけ上限が広がって範囲外を見逃す。
+ *
+ * ## 言づてが 1 通も無い図でも黙らない
+ *
+ * 比べる相手が無いからと飛ばすと、 帯を書いたのに何も描かれない図が黙る経路になる。
+ * 範囲を示せないので、 理由を「言づてが 1 通も無い」 に変えて同じ知らせを出す。
+ *
+ * ## 負の番号はここで見ない
+ *
+ * 記法は数字だけを受ける形 (`\d+`) で読み、 JSON は「0 以上の整数」 を要求する = 2 つの入口が
+ * どちらも先に断っている。 ここに枝を置いても 1 度も通らない。 入口の側が緩んだら気付けるよう、
+ * 断ることそのものを検査で固定する。
+ *
+ * ## 名前と番号で打ち切らない
+ *
+ * 両方外れた帯には 2 件とも出す。 片方で止めると、 名前を直した次の回に番号の誤りが初めて出る。
+ */
+function reportBandProblems(
+  doc: DslDocument,
+  diagram: CdlDiagram,
+  onNotice?: (n: CompileNotice) => void,
+): void {
+  if (!onNotice) return;
+  const 帯 = doc.bands ?? [];
+  if (帯.length === 0) return;
+  const 板がある = diagram.nodes.some((n) => n.sequenceData !== undefined);
+  if (!板がある) {
+    for (const b of 帯) {
+      onNotice({
+        kind: "band-not-honored",
+        actor: b.actor,
+        line: b.pos?.line ?? 0,
+        message: `type: ${doc.type} は帯を描きません (書いた帯は図に出ません)`,
+        hint: "帯は板の縦線に重ねる四角なので、 type: sequence で使う",
+      });
+    }
+    return;
+  }
+  const 名前の表 = actorRefTable(doc);
+  const hint = 書ける面の案内(doc);
+  const 言づての数 = doc.flow.filter((s) => 名前の表.has(s.from) && 名前の表.has(s.to)).length;
+  for (const b of 帯) {
+    const line = b.pos?.line ?? 0;
+    if (!名前の表.has(b.actor)) {
+      onNotice({
+        kind: "band-actor-missing",
+        actor: b.actor,
+        line,
+        message: `帯が "${truncateForMessage(b.actor)}" を指していますが、 actors に書かれていません (先頭の面に帯が出ます)`,
+        hint,
+      });
+    }
+    const 外れ =
+      言づての数 === 0
+        ? "板に載る言づてが 1 通もありません"
+        : b.to > 言づての数 - 1
+          ? `板に載る言づては ${言づての数} 通で、 最後は ${言づての数 - 1} 番です`
+          : b.from > b.to
+            ? "始まりが終わりより後ろです"
+            : undefined;
+    if (外れ === undefined) continue;
+    onNotice({
+      kind: "band-row-out-of-range",
+      actor: b.actor,
+      line,
+      message: `帯 "${truncateForMessage(b.actor)}: ${b.from}..${b.to}" の区間が言づての並びに収まりません (${外れ})`,
+      hint:
+        言づての数 === 0
+          ? "帯は言づての行に重ねる四角なので、 flow に言づてを書く"
+          : `0..${言づての数 - 1} の範囲で、 始まりを終わり以下にする (番号は flow に書いた言づての行、 段ではありません)`,
+    });
+  }
+}
+
 /**
  * 矢印に書いた多重度 (`cardinality`) から端の形を描けない時に伝える (#2107)。
  *
- * 多重度で端の形が決まるのは `type: er` の 6 語だけ (描画側の `ER_CARDINALITY_HEAD`)。
+ * 多重度で端の形が決まるのは `type: record` の 6 語だけ (描画側の `ER_CARDINALITY_HEAD`)。
  * `er` でそれ以外の語を書くと名前に `(語)` と添えるだけで、`er` 以外では何も描かない。
  * 黙って通すと、書いた側は端の形が付くと思い込む (`N:M` の代わりに `N:N` と書く形で起きる)。
  *
@@ -872,7 +1305,7 @@ function reportMessageOptionNotHonored(doc: DslDocument, onNotice?: (n: CompileN
  * |---|---|---|
  * | 順序図の板の言づて | 図種 | `reportMessageOptionNotHonored` が他の飾りと合わせて伝える |
  * | `actors` に無い名前を指す矢印 | 名前の解決に使う表 (`actorRefTable`) | 居ない名前の知らせ (`reportMissingFlowActors`) |
- * | 図種の組み立てが知らせた行 | 実際に出た知らせ | 捨てた矢印 / 自分を親にする矢印 / 工程表の矢印の飾り (多重度を含む) など |
+ * | 図種の組み立てが知らせた行 | 実際に出た知らせ | 捨てた矢印 / 自分を親にする矢印 / ガントチャートの矢印の飾り (多重度を含む) など |
  *
  * 値の図 (`pie` 等) は捨てた本数を最初の矢印の行でまとめて伝えるため、2 本目以降の矢印に書いた
  * 多重度はここで伝わる。
@@ -890,7 +1323,7 @@ function reportCardinalityNotHonored(
   onNotice?: (n: CompileNotice) => void,
 ): void {
   if (!onNotice) return;
-  if (doc.type === "sequence" || doc.type === "solidity") return;
+  if (doc.type === "sequence") return;
   const 名前の表 = actorRefTable(doc);
   for (const s of doc.flow) {
     const 書いた = 書いた多重度を読む(s.cardinality);
@@ -900,17 +1333,13 @@ function reportCardinalityNotHonored(
     if (図種が知らせた行.has(line)) continue;
     const 矢印 = `${truncateForMessage(s.from)} -> ${truncateForMessage(s.to)}`;
     const 字 = truncateForMessage(書いた.字);
-    if (doc.type !== "er") {
+    if (doc.type !== "record") {
       onNotice({
         kind: "cardinality-not-honored",
         actor: s.from,
         line,
         message: `${矢印} に書いた多重度 "${字}" は効きません (type: ${doc.type} は多重度を描きません)`,
-        // クラス図は多重度を別の欄で受け取り、端の横に添える (`compile/class.ts`)
-        hint:
-          doc.type === "class"
-            ? "クラス図の多重度は、行き先の側を sub、出どころの側を tailSub に書いてください"
-            : "多重度から両端の形を描くのは type: er です",
+        hint: "多重度から両端の形を描くのは type: record です",
       });
       continue;
     }
@@ -938,7 +1367,7 @@ function reportCardinalityNotHonored(
  */
 function reportFlowOffsetNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
   if (!onNotice) return;
-  if (doc.type === "sequence" || doc.type === "solidity") return;
+  if (doc.type === "sequence") return;
   for (const s of doc.flow) {
     if (s.layoutPos === undefined) continue;
     if (s.label !== undefined && s.label.trim() !== "") continue;
@@ -959,38 +1388,34 @@ function reportFlowOffsetNotHonored(doc: DslDocument, onNotice?: (n: CompileNoti
  * 面ごとの箱が無いので、種類 / 大きさ / 位置 / 行 / 色 / 小見出し / 値 / 図形を載せる先も無い。
  * 黙って落とすと、書いた側は効いていると思い込む。
  *
+ * **伝える欄を並べない** (#2358)。 以前は 8 種を手で並べていたため、後から足した項目が
+ * どこにも入らなかった (実測 = 箱に書ける 31 項目のうち 11 件が、図も変わらず知らせも出ない)。
+ * 板が描く欄を **除いた残り全部** を伝える。
+ *
  * 見本 (`parts`) を重ねた面は対象外 = 見本は別経路で図に取り込まれ、板の見出しには並ばない。
  */
 function reportActorKindNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
   if (!onNotice) return;
-  if (doc.type !== "sequence" && doc.type !== "solidity") return;
+  if (doc.type !== "sequence") return;
+  /*
+   * **種類で並べ替える図では鳴らさない** (#2655)。
+   *
+   * 種類は板の絵には出ないが、並び順を書いた図では **面の並びを決めている**ので、
+   * 書いた意味は figure に出ている。 落ちたと伝えると、正しく効いている指定に毎回鳴る。
+   *
+   * 畳む前はこの判定を図種 (`solidity`) で行っていた。 型を畳んだので、同じことを
+   * 並び順が効いているかで見る = 古い名前で書いた図は読み替えでこの語が入るため、
+   * 鳴らないという振る舞いが前と変わらない。
+   */
+  if (並び順が効くか(doc)) return;
   for (const a of doc.actors) {
     if (a.partId !== undefined) continue;
-    const 効かない = [
-      /*
-       * 種類は `sequence` でだけ落ちる。
-       *
-       * `solidity` は種類で **面の並びを決める** (`compileSolidity`) ので、絵にならなくても
-       * 書いた意味は figure に出ている。 落ちたと伝えると、正しく効いている指定に毎回鳴る。
-       *
-       * 記法を通すと既定の `actor` が必ず入るため、値ではなく書いたかどうかの印で見る。
-       * 記法を通さず直接組み立てた場合はこの印が無いので、種類を置いたこと自体を「書いた」 とみなす
-       */
-      doc.type === "sequence" && a.kindWritten !== false && a.kind !== undefined ? "種類" : "",
-      a.posW !== undefined || a.posH !== undefined ? "大きさ" : "",
-      a.posX !== undefined ||
-      a.posY !== undefined ||
-      a.posRel !== undefined ||
-      // 位置のずらし (#1971)。 板は面ごとの箱を持たないので動かす相手が無い
-      a.layoutPos !== undefined
-        ? "位置"
-        : "",
-      a.rows !== undefined ? "行" : "",
-      a.tone !== undefined ? "色" : "",
-      a.eyebrow !== undefined ? "小見出し" : "",
-      a.value !== undefined ? "値" : "",
-      a.shape !== undefined ? "図形" : "",
-    ].filter((x) => x !== "");
+    /*
+     * 記法を通すと既定の `actor` が必ず入るため、値ではなく書いたかどうかの印で見る。
+     * 記法を通さず直接組み立てた場合はこの印が無いので、種類を置いたこと自体を「書いた」 とみなす
+     */
+    const 判定で外す = doc.type !== "sequence" || a.kindWritten === false ? ["kind"] : [];
+    const 効かない = 効かない箱の欄を並べる(a, 板が伝えない箱の欄, 判定で外す);
     if (効かない.length === 0) continue;
     onNotice({
       kind: "actor-kind-not-honored",
@@ -1003,88 +1428,471 @@ function reportActorKindNotHonored(doc: DslDocument, onNotice?: (n: CompileNotic
 }
 
 /**
- * 箱に書いた縦列が効かないことを伝える (#1246)。
- *
- * 縦列は **図種が決める**。 `flow` / `topology` は 1 本にまとめ、 `swimlane` / `er` / `state`
- * は箱ごとに 1 本作り、 `sequence` はそれがそのまま生命線になる。 図全体を 1 箱にする図種
- * (`pie` / `bar` 等) では箱が 1 つしかない。
+ * 矢印を骨格として描く図種 (#2364)。
  *
- * **箱の `lane` を読むのは、 `縦列を選べる図種` で全ての箱が書いた時だけ** (#1263)。
- * 一部の箱だけが書いた形は `reportLaneMixed` が伝えるので、 ここではそれ以外の図種に書いた
- * 縦列を伝える。
+ * 木の図と思考の地図は矢印を親子のつながりとして描き、線の形も向きも階層から決める。
+ * 飾りを載せる先が無い。
  *
- * 黙って捨てると、 書いた縦列は消え、 `lanes:` で宣言した縦列だけが中身のないまま残る。
- * 実測 (#1246) = `type: flow` で `lane: ui` / `lane: api` を書くと箱は両方 `flow` に入り、
- * 宣言した `ui` / `api` は空のまま増えた。 知らせは 1 件も出なかった。
+ * ガントチャート (`gantt`) も同じ性質を持つが、知らせを図種ごとの組み立て (`compile/gantt.ts`) の
+ * 中で出しているので、ここには入れない。
+ */
+const 矢印を骨格にする図種: ReadonlySet<string> = new Set(["tree", "mind"]);
+
+/**
+ * 矢印を骨格として描く図で、矢印に書いた飾りが使われないことを伝える (#2364)。
  *
- * ## なぜ組み立ての側で伝えるのか
+ * 実測 = 矢印に書ける 21 項目のうち 18 件が、図も変わらず知らせも出なかった (2 図種とも)。
+ * 文字を足すと 19 件になる。
  *
- * 記法の解析は図種を見ずに 1 行ずつ読む。 そこで弾くと **見本 (parts) の張替え先** まで
- * 巻き添えになる = 見本では `lane` が実際に読まれる (`mergePartsFromActors` が読む)。
- * 図種を知っているのは組み立ての側なので、 効くかどうかの判断もここに置く。
+ * 呼び名は板と同じ表を使う (`効かない矢印の欄の呼び名`) = 同じ欄を 2 つの文言で呼ぶと、
+ * 図種を変えた読み手が同じ飾りだと気付けない。
+ */
+function reportSkeletonEdgeOptionNotHonored(
+  doc: DslDocument,
+  図種が知らせた行: ReadonlySet<number>,
+  onNotice?: (n: CompileNotice) => void,
+): void {
+  if (!onNotice) return;
+  if (!矢印を骨格にする図種.has(doc.type)) return;
+  const 名前の表 = actorRefTable(doc);
+  for (const s of doc.flow) {
+    if (!名前の表.has(s.from) || !名前の表.has(s.to)) continue;
+    /*
+     * 図種の組み立てが知らせた行には重ねない (#2107 と同じ決まり)。
+     *
+     * 捨てた矢印 (自分を親にする形など) は組み立てが既に伝えており、そこへ飾りの知らせを
+     * 足すと同じ行に 2 件並ぶ。 実測 = `A -> A` に多重度を書いた木の図で 2 件出た。
+     */
+    if (図種が知らせた行.has(s.pos?.line ?? 0)) continue;
+    const 効かない = 効かない矢印の欄を並べる(s, 向きだけを使う図が伝えない矢印の欄);
+    if (効かない.length === 0) continue;
+    onNotice({
+      kind: "edge-option-not-honored",
+      actor: s.from,
+      line: s.pos?.line ?? 0,
+      message: `type: ${doc.type} で "${truncateForMessage(s.from)} -> ${truncateForMessage(s.to)}" に書いた ${効かない.join(" / ")} は描けません (矢印は親子のつながりだけを描きます)`,
+      hint: "つながりの線は階層から決まるため飾りを載せる先がありません。 箱の名前で伝えるか、矢印を自分で引く図種を使ってください",
+    });
+  }
+}
+
+/**
+ * 木の図で、箱に書いた指定が使われないことを伝える (#2360)。
  *
- * ## 見本と `type: mind` では伝えない
+ * 木の図は箱を階層の節として描き、位置も大きさも親子関係から決める。 箱ごとの飾りを
+ * 載せる先が無いのは設計どおりだが、**書いても知らせが出なかった** (実測 = 箱に書ける
+ * 31 項目のうち 21 件が、図も変わらず知らせも出ない)。
  *
- * 見本は上のとおり実際に効く。 `type: mind` は描けない欄をまとめて 1 件で伝えており
- * (`compileMind` の「名前と副題 / 値、 枝の色しか描けません」)、 そこに `枠の指定` が既に
- * 入っている。 二重に伝えると同じ 1 行について知らせが 2 件並ぶ。
+ * 呼び名は板と同じ表を使う (`箱の欄の呼び名`) = 同じ欄を 2 つの文言で呼ぶと、
+ * 図種を変えた読み手が同じ指定だと気付けない。
  */
-function reportLaneNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+function reportTreeActorOptionNotHonored(
+  doc: DslDocument,
+  onNotice?: (n: CompileNotice) => void,
+): void {
   if (!onNotice) return;
-  if (doc.type === "mind") return;
-  // 縦列を選べる図種では、全ての箱が書いていれば効く (#1263)。 効く形では知らせない
-  const 効く図種 = 縦列を選べる図種.has(doc.type);
-  if (効く図種 && 書いた縦列に置く(doc.type, doc)) return;
-  if (効く図種) {
-    reportLaneMixed(doc, onNotice);
-    return;
-  }
+  if (doc.type !== "tree") return;
   for (const a of doc.actors) {
     if (a.partId !== undefined) continue;
-    if (a.lane === undefined) continue;
+    // 種類は書かなくても既定の `actor` が入るため、値ではなく書いたかどうかの印で見る (#1058)
+    const 効かない = 効かない箱の欄を並べる(
+      a,
+      木の図が伝えない箱の欄,
+      a.kindWritten === false ? ["kind"] : [],
+    );
+    if (効かない.length === 0) continue;
     onNotice({
-      kind: "lane-not-honored",
+      kind: "actor-option-not-honored",
       actor: a.name,
       line: a.pos?.line ?? 0,
-      message: `"${truncateForMessage(a.name)}" に書いた lane は効きません (縦列は type: ${doc.type} が決めます)`,
-      hint: "縦列は図種が決めるため箱からは選べません。 lane を消してください (見本では張替え先として使えます)",
+      message: `"${truncateForMessage(a.name)}" に書いた ${効かない.join(" / ")} は効きません (type: tree は名前と値だけを描き、位置も大きさも親子関係から決めます)`,
+      hint: "木の図の箱は階層の節なので飾りを載せる先がありません。 呼び名 (subtitle) に書くか、箱を並べる図種を使ってください",
     });
   }
 }
 
 /**
- * 矢印が `actors` に無い名前を指したことを知らせる (#1209)。
+ * 知らせの文に出す「その図種が読むもの」 (#2370)。
  *
- * 知らせずに通すと、 **どちらに転んでも書いた人の意図が消える**。 動きを書いていない図では
- * 種類ごとの組み立てが actors を順に繋ぐため、 書いた矢印そのものが捨てられて label も
- * 消える (実測 = "変換" が "→" になった)。 動きを書いた図では名前がそのまま下流へ渡り、
- * 存在しない node を指す図ができて描画の直前で落ちる
- * (実測 = `unknown-ref: edge "e0-v-c" の from "v" が node に存在しません`)。
+ * 表に無い図種は「名前と値」 とする = 足し忘れても文が消えず、読み手に伝わる。
+ */
+const 図種が読むものの呼び名: ReadonlyMap<string, string> = new Map([
+  ["chart", "名前と値と色"],
+  ["gantt", "名前と時期と色と担当"],
+  ["journey", "名前と気持ちと接点"],
+]);
+
+/**
+ * 箱を名前と値の組として読む図で、箱に書いた指定が使われないことを伝える (#2368 / #2370)。
  *
- * 落ちる場所も消える場所も本文から遠いので、 書いた行で知らせる。
+ * 対象の図種と、図種ごとに読む欄は `値として読む図種` が持つ (実装が SSOT)。
+ *
+ * 実測 = 箱に書ける 30 項目のうち、値の図で 17 件 / じょうごで 19 件 /
+ * ガントチャートと体験の地図と四象限で 22-23 件が、図も変わらず知らせも出なかった。
+ *
+ * 位置 (`posX` + `posY`) は片方だけだと別の知らせ (#2362) が出るため、1 項目ずつ足す走査では
+ * 「知らせる」 に数えられ、組で書いた時の穴が隠れていた。
+ *
+ * 呼び名は板と木の図と同じ表を使う (`効かない箱の欄の呼び名`) = 同じ欄を 2 つの文言で呼ぶと、
+ * 図種を変えた読み手が同じ指定だと気付けない。
  */
-function reportMissingFlowActors(
+function reportValueChartActorOptionNotHonored(
   doc: DslDocument,
-  onNotice?: (notice: CompileNotice) => void,
+  onNotice?: (n: CompileNotice) => void,
 ): void {
   if (!onNotice) return;
-  const 表 = actorRefTable(doc);
-  // hint は **1 度だけ作る**。 知らせごとに全 actor 名を並べ直すと、 名前も矢印も上限
-  // (各 1,000) まで書いた図で数百 MB になる (Round 1 の指摘)。 並べる数にも上限を置く
-  //
-  // **1 件ずつの長さも切る**。 件数だけを絞っても、 名前 1 つが 2 万字なら知らせも 2 万字に
-  // なる (Round 4 の実測)。 名前も矢印の指定も外から来る文字列なので、 表示に使う所は
-  // すべて `truncateForMessage` を通す (光らせる相手の知らせと同じ扱い)。
-  const 見せる数 = 8;
-  const 名前一覧 = doc.actors
-    .slice(0, 見せる数)
+  if (!値として読む図種.has(doc.type)) return;
+  const 伝えない欄 = 値として読む図が伝えない箱の欄(doc.type);
+  // 何を読むかを知らせの文に出す。 図種ごとに違うので表から引く (実装が SSOT)
+  const 読む欄 = 図種が読むものの呼び名.get(doc.type) ?? "名前と値";
+  for (const a of doc.actors) {
+    if (a.partId !== undefined) continue;
+    const 判定で外す: string[] = [];
+    // 種類は書かなくても既定の `actor` が入るため、値ではなく書いたかどうかの印で見る (#1058)
+    if (a.kindWritten === false) 判定で外す.push("kind");
+    /*
+     * 呼び名は **値を書いていない箱でだけ** 値として読まれる (#2390)。
+     * 読む側と同じ式 (`a.value ?? a.subtitle`) に合わせる = 条件を写すと、
+     * 読む側を直した日に伝える側が古くなる。
+     */
+    if (a.value === undefined) 判定で外す.push("subtitle");
+    const 効かない = 効かない箱の欄を並べる(a, 伝えない欄, 判定で外す);
+    if (効かない.length === 0) continue;
+    onNotice({
+      kind: "actor-option-not-honored",
+      actor: a.name,
+      line: a.pos?.line ?? 0,
+      message: `"${truncateForMessage(a.name)}" に書いた ${効かない.join(" / ")} は効きません (type: ${doc.type} は${読む欄}だけを読み、1 枚の図にまとめて描きます)`,
+      hint: 値として読む図の案内(効かない),
+    });
+  }
+}
+
+/**
+ * 値として読む図の案内を、伝えた欄から組み立てる (#2390)。
+ *
+ * **固定の 1 文を添えない** (#2382 の決まり)。 飾りの欄 (位置 / 大きさ / 図形 ほか) は
+ * 「箱を並べる図種を使ってください」 が行き先になるが、呼び名の行き先は同じ図種の中にある =
+ * 値を消せば値として読まれ、題 (`title`) を書けば箱に出る。
+ * 1 文で済ませると、呼び名だけを書いた読み手が図種を変えろと読まされる。
+ */
+function 値として読む図の案内(効かない: readonly string[]): string | undefined {
+  const 案内: string[] = [];
+  if (効かない.includes("呼び名")) {
+    案内.push(
+      "呼び名を値として読ませるなら同じ箱の値 (value) を消します。 箱に題を出すなら title を書きます",
+    );
+  }
+  if (効かない.some((欄) => 欄 !== "呼び名")) {
+    案内.push(
+      "値の図は箱ごとの絵を持たないため飾りを載せる先がありません。 箱を並べる図種を使ってください",
+    );
+  }
+  return 案内.length === 0 ? undefined : 案内.join("、");
+}
+
+/**
+ * 箱を並べて線で繋ぐ図で、箱に書いた指定が使われないことを伝える (#2376)。
+ *
+ * 対象の図種と、図種ごとに読まない欄は `骨組みの図種` が持つ (実装が SSOT)。
+ *
+ * 実測 = フロー 447 枚 ・ 泳路の図 35 枚 ・ 配置の図 8 枚の見本すべてで、始まりの印
+ * (`initial`) ・ 終わりの印 (`final`) ・ 印 (`marks`) ・ 前の値 (`previous`) の 4 件が、
+ * 図も変わらず知らせも出なかった。構成の図はこれに 1 件足した形になる。
+ *
+ * 始まりと終わりの印を読むのは状態遷移図だけ (`compile/generic.ts` の札)。
+ * 同じ記法をフローに書いても札は出ないが、書き手には状態遷移図と同じに見える。
+ *
+ * 印 (`marks`) は **行と組にして読み替えられる図種でだけ** 外す (#2377)。
+ * 読み替えの表は `行頭の印にする` が持つので、図種の一覧をここに写さず関数に聞く。
+ * 行を書いていない印は、どの図種でも読み替える先が無いので伝える。
+ *
+ * 案内は **伝えた欄から組み立てる** (#2382)。 3 つの行き先を並べた 1 文を固定で添えていたが、
+ * 状態遷移図を族に入れた時に 2 つが誤りになった = 読み手は既に状態遷移図に居るのに
+ * 「始まりと終わりの印は type: record が描きます」 と読まされ、印については
+ * 「type: record が描きます」 と読まされる (状態遷移図も描く。 足りないのは行のほう)。
+ *
+ * 段 (`stack`) は **図 1 枚ごとに読むかが決まる** (#2386)。 書いた番号の段に置くのは
+ * 全ての箱が縦列を書いた図だけで、1 つでも書いていない箱があると図全体が別の並べ方に落ち、
+ * 段はどの箱でも読まれない。 図種では表せない条件なので、置く側と同じ関数
+ * (`書いた縦列に置く`) に聞く。
+ *
+ */
+function reportSkeletonActorOptionNotHonored(
+  doc: DslDocument,
+  onNotice?: (n: CompileNotice) => void,
+): void {
+  if (!onNotice) return;
+  if (!骨組みの図種.has(doc.type)) return;
+  const 伝えない欄 = 図ごとの条件も見た伝えない箱の欄(doc);
+  for (const a of doc.actors) {
+    if (a.partId !== undefined) continue;
+    const 判定で外す: string[] = [];
+    // 種類は書かなくても既定の `actor` が入るため、値ではなく書いたかどうかの印で見る (#1058)
+    if (a.kindWritten === false || 泳法図で印をどう描く(doc, a) !== undefined) 判定で外す.push("kind");
+    // 行と組にして読み替えられる印は効く = 効いている指定には鳴らさない
+    if (
+      a.rows !== undefined &&
+      a.marks !== undefined &&
+      行頭の印を読むか(doc.type)
+    ) {
+      判定で外す.push("marks");
+    }
+    const 効かない = 効かない箱の欄を並べる(a, 伝えない欄, 判定で外す);
+    if (効かない.length === 0) continue;
+    onNotice({
+      kind: "actor-option-not-honored",
+      actor: a.name,
+      line: a.pos?.line ?? 0,
+      message: `"${truncateForMessage(a.name)}" に書いた ${効かない.join(" / ")} は効きません (type: ${doc.type} は箱を並べて線で繋ぐ図です)`,
+      hint:
+        doc.type === "swimlane" && doc.shape === "stages"
+          ? "札は段階ごとの列へ actors に書いた順に積み、種類は card で固定されます。 decision は札の右に「分かれ道」を添え、mark-start と mark-end は描きません"
+          : doc.type === "swimlane" && doc.shape === "timeline"
+          ? "番号付きの札は軸の左右へ交互に並び、種類は card で固定されます。 decision の脇の札は同じ段へ置き、decision と mark-end は軸の上に描き、mark-start は描きません"
+          : doc.type === "swimlane" && doc.shape === "metro"
+            ? "駅は actors に書いた順に並び、種類は station で固定されます。 decision / mark-start / mark-end は分かれ道と始まりと終わりの印として描きます"
+          : 骨組みの図の案内(doc.type, 効かない),
+    });
+  }
+}
+
+/**
+ * その図で、効かないと伝えない箱の欄 (#2386 / #2388)。
+ *
+ * 図種ごとの違いは族の表 (`骨組みの図種`) が持つ。 **図 1 枚ごとに** 読むかが決まる欄は
+ * 表では表せないので、ここで読まない図から抜いて伝える側へ回す。
+ *
+ * 条件は使う側と同じ関数に聞く = 2 か所に写すと、使う側を直した日に伝える側が古くなる。
+ * 段 (`stack`) は縦列を選べる図種すべてに同じ条件が掛かるので `書いた縦列に置く` を直に呼ぶ。
+ *
+ * 図種ごとに違う条件を持つ欄は 1 つも無い (#2782)。 畳む前は表の図の種類 (`kind`) が
+ * 2 経路に分かれていたが、経路を 1 本にしたので図種の表だけで決まる。
+ *
+ * @param doc 組み立てる本文
+ * @returns 族の除外から、この図では読まない欄を抜いた集合
+ */
+function 図ごとの条件も見た伝えない箱の欄(doc: DslDocument): ReadonlySet<string> {
+  const 族の除外 = 骨組みの図が伝えない箱の欄(doc.type);
+  const 段階ごとの箱か = doc.type === "swimlane" && doc.shape === "stages";
+  const 路線図か = doc.type === "swimlane" && doc.shape === "metro";
+  const 時間軸か = doc.type === "swimlane" && doc.shape === "timeline";
+  const 読まない欄: string[] = [];
+  const この形が読む欄: string[] = [];
+  if (doc.type === "flowchart") この形が読む欄.push("titleFontSize", "markGap");
+  if (路線図か) この形が読む欄.push("stationNamePosition");
+  if (時間軸か) この形が読む欄.push("subtitlePlacement");
+  // 段を読まない図では伝える側へ回す。 既に抜けている図種 (c4) は下の `delete` が空振りする
+  if (路線図か || 時間軸か || (!段階ごとの箱か && !書いた縦列に置く(doc.type, doc))) 読まない欄.push("stack");
+  const 残り = new Set(族の除外);
+  // `stage` はこの形でだけ箱の置き先を決める。 他の骨組みの図では知らせる側へ残す (#2797)。
+  let 変えた = 段階ごとの箱か && !残り.has("stage");
+  if (段階ごとの箱か) 残り.add("stage");
+  // 3 形とも種類を固定する (段の箱は札、路線図は駅、時間軸は札)。書いた種類は伝える側へ回す (#2831)
+  if ((段階ごとの箱か || 路線図か || 時間軸か) && 残り.delete("kind")) 変えた = true;
+  for (const 欄 of 読まない欄) if (残り.delete(欄)) 変えた = true;
+  for (const 欄 of この形が読む欄) {
+    if (!残り.has(欄)) 変えた = true;
+    残り.add(欄);
+  }
+  return 変えた ? 残り : 族の除外;
+}
+
+/**
+ * 行頭の印を読む図種 (#2382)。 `行頭の印を読むか` に聞いて導く。
+ *
+ * 図種の名前を案内の文に写すと、読み替える図種を足した日に案内だけが古くなる。
+ * 走査の範囲は骨組みの族に閉じる = この案内が出るのも族の中だけ。
+ */
+const 行頭の印を読む図種: readonly string[] = [...骨組みの図種.keys()].filter((t) =>
+  行頭の印を読むか(t),
+);
+
+/**
+ * 骨組みの図の知らせに添える案内を、伝えた欄から組み立てる (#2382)。
+ *
+ * **伝えていない欄の行き先を書かない**。 3 つの行き先を並べた 1 文を固定で添えていた間、
+ * 状態遷移図では 2 つが誤りになっていた。
+ *
+ * **行き先を持たない欄では案内を付けない**。 当たり障りのない 1 文で埋めると、
+ * 読み手は次に何をすればよいか分からないまま「案内は読んだ」 状態になる。
+ *
+ * @param 図種 いま組んでいる図の種類
+ * @param 効かない 知らせに並べた呼び名 (`効かない箱の欄を並べる` の返り値)
+ * @returns 案内の文。 行き先を持つ欄が 1 つも無ければ `undefined`
+ */
+function 骨組みの図の案内(図種: string, 効かない: readonly string[]): string | undefined {
+  const 案内: string[] = [];
+  /*
+   * 段は **縦列を選べる図種でだけ** 書き方の行き先を持つ (#2386)。 その図種で伝えたということは
+   * 縦列を書いていない箱が在ったということなので、足せば効く。
+   * 縦列を選べない図種 (構成の図) では、どう書いても効かないので行き先が無い。
+   */
+  if (効かない.includes("段") && 縦列を選べる図種.has(図種 as never)) {
+    案内.push("段は全ての箱に縦列 (lane) を書いた図で効きます");
+  }
+  if (効かない.includes("始まりの印") || 効かない.includes("終わりの印")) {
+    案内.push("始まりと終わりの印は type: record が描きます");
+  }
+  if (効かない.includes("前の値")) 案内.push("前の値は値を並べる図が描きます");
+  /*
+   * この族で「色」 に立つのは色番号だけ (#2384)。 色味 (`tone`) は共通の除外に入っているので
+   * ここへ来ない = 呼び名が同じでも、伝えているのは 16 進数で書いた形に限る。
+   */
+  if (効かない.includes("色")) {
+    案内.push("色番号が効くのは部品を置いた箱だけです。 色の名前 (color: 成功) は箱の色になります");
+  }
+  if (効かない.includes("印")) {
+    案内.push(
+      行頭の印を読む図種.includes(図種)
+        ? "行頭の印は行 (rows) と組にして書くと記号になります"
+        : `行頭の印は ${行頭の印を読む図種.map((t) => `type: ${t}`).join(" と ")} が、行 (rows) と組にした時に描きます`,
+    );
+  }
+  return 案内.length === 0 ? undefined : 案内.join("、");
+}
+
+/**
+ * 箱の座標を片方だけ書いた時に伝える (#2362)。
+ *
+ * 座標を図に写す処理 (`applyCanvasPivotPositions`) は **横と縦の両方が書かれている** 時だけ
+ * 動く。 片方だけの時は何もしないまま通るため、図が 1 bit も変わらず知らせも出なかった
+ * (実測 = 座標が効く 5 図種すべてで消えた)。
+ *
+ * **効かせる側には倒さない**。 片方だけ動かす書き方は既にずらし (`offsetX` / `offsetY`) が
+ * 受け持っており、座標に同じ役目を持たせると 2 つの書き方が同じことをする。
+ *
+ * 大きさ (`posW` / `posH`) は片方だけでも効くので見ない (実測)。
+ * 部品として置いた箱は別経路 (`mergePartsFromActors`) が位置を決めるので外す。
+ */
+function reportHalfWrittenPosition(
+  doc: DslDocument,
+  箱に知らせた行: ReadonlySet<number>,
+  onNotice?: (n: CompileNotice) => void,
+): void {
+  if (!onNotice) return;
+  for (const a of doc.actors) {
+    if (a.partId !== undefined) continue;
+    /*
+     * 箱の知らせが出た行には重ねない (#2368)。
+     *
+     * 位置そのものが効かない図種では「片方だけでは決まらない」 という案内が誤りになる
+     * (両方書いても効かない)。 その図種では箱の知らせが位置を含めて伝えている。
+     */
+    if (箱に知らせた行.has(a.pos?.line ?? 0)) continue;
+    const 書いた = a.posX !== undefined ? "posX" : a.posY !== undefined ? "posY" : undefined;
+    if (書いた === undefined) continue;
+    if (a.posX !== undefined && a.posY !== undefined) continue;
+    const 足りない = 書いた === "posX" ? "posY" : "posX";
+    onNotice({
+      kind: "position-axis-missing",
+      actor: a.name,
+      line: a.pos?.line ?? 0,
+      message: `"${truncateForMessage(a.name)}" に書いた ${書いた} だけでは位置が決まりません (${足りない} も書くと効きます)`,
+      hint: `横と縦を両方書くか、片方だけ動かすなら ずらし (offsetX / offsetY) を使ってください`,
+    });
+  }
+}
+
+/**
+ * 箱に書いた縦列が効かないことを伝える (#1246)。
+ *
+ * 縦列は **図種が決める**。 `flow` / `topology` は 1 本にまとめ、 `swimlane` / `er` / `state`
+ * は箱ごとに 1 本作り、 `sequence` はそれがそのまま生命線になる。 図全体を 1 箱にする図種
+ * (`pie` / `bar` 等) では箱が 1 つしかない。
+ *
+ * **箱の `lane` を読むのは、 `縦列を選べる図種` で全ての箱が書いた時だけ** (#1263)。
+ * 一部の箱だけが書いた形は `reportLaneMixed` が伝えるので、 ここではそれ以外の図種に書いた
+ * 縦列を伝える。
+ *
+ * 黙って捨てると、 書いた縦列は消え、 `lanes:` で宣言した縦列だけが中身のないまま残る。
+ * 実測 (#1246) = `type: flow` で `lane: ui` / `lane: api` を書くと箱は両方 `flow` に入り、
+ * 宣言した `ui` / `api` は空のまま増えた。 知らせは 1 件も出なかった。
+ *
+ * ## なぜ組み立ての側で伝えるのか
+ *
+ * 記法の解析は図種を見ずに 1 行ずつ読む。 そこで弾くと **見本 (parts) の張替え先** まで
+ * 巻き添えになる = 見本では `lane` が実際に読まれる (`mergePartsFromActors` が読む)。
+ * 図種を知っているのは組み立ての側なので、 効くかどうかの判断もここに置く。
+ *
+ * ## 見本と `type: mind` では伝えない
+ *
+ * 見本は上のとおり実際に効く。 `type: mind` は描けない欄をまとめて 1 件で伝えており
+ * (`compileMind` の「名前と副題 / 値、 枝の色しか描けません」)、 そこに `枠の指定` が既に
+ * 入っている。 二重に伝えると同じ 1 行について知らせが 2 件並ぶ。
+ */
+function reportLaneNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice) return;
+  if (doc.type === "mind") return;
+  // 時間軸の lane は縦列ではなく札の担当名なので、箱ごとに省いてよい。
+  if (doc.type === "swimlane" && doc.shape === "timeline") return;
+  // 縦列を選べる図種では、全ての箱が書いていれば効く (#1263)。 効く形では知らせない
+  const 効く図種 = 縦列を選べる図種.has(doc.type);
+  if (効く図種 && 書いた縦列に置く(doc.type, doc)) return;
+  if (効く図種) {
+    reportLaneMixed(doc, onNotice);
+    return;
+  }
+  for (const a of doc.actors) {
+    if (a.partId !== undefined) continue;
+    if (a.lane === undefined) continue;
+    onNotice({
+      kind: "lane-not-honored",
+      actor: a.name,
+      line: a.pos?.line ?? 0,
+      message: `"${truncateForMessage(a.name)}" に書いた lane は効きません (縦列は type: ${doc.type} が決めます)`,
+      hint: "縦列は図種が決めるため箱からは選べません。 lane を消してください (見本では張替え先として使えます)",
+    });
+  }
+}
+
+/**
+ * 「actors に書いた名前で指す」 の直し方を 1 本作る (#1209、 #2404 で帯と共有)。
+ *
+ * **1 度だけ作る**。 知らせごとに全ての面の名前を並べ直すと、 名前も矢印も上限 (各 1,000) まで
+ * 書いた図で数百 MB になる。 並べる数にも上限を置く。
+ *
+ * **1 件ずつの長さも切る**。 件数だけを絞っても、 名前 1 つが 2 万字なら知らせも 2 万字になる
+ * (実測)。 名前も指定も外から来る文字列なので、 表示に使う所はすべて `truncateForMessage` を通す。
+ *
+ * 矢印の端と帯で同じ文を使う = 同じ「actors に無い名前を指した」 という誤りに、 欄ごとに違う
+ * 直し方が返らないようにする。
+ */
+function 書ける面の案内(doc: DslDocument): string {
+  const 見せる数 = 8;
+  if (doc.actors.length === 0) return "actors に登場人物を書く";
+  const 名前一覧 = doc.actors
+    .slice(0, 見せる数)
     .map((a) => truncateForMessage(a.name))
     .join(" / ");
   const 残り = doc.actors.length - 見せる数;
-  const hint =
-    doc.actors.length > 0
-      ? `actors に書いた名前で指す (${名前一覧}${残り > 0 ? ` ほか ${残り} 件` : ""})`
-      : "actors に登場人物を書く";
+  return `actors に書いた名前で指す (${名前一覧}${残り > 0 ? ` ほか ${残り} 件` : ""})`;
+}
+
+/**
+ * 矢印が `actors` に無い名前を指したことを知らせる (#1209)。
+ *
+ * 知らせずに通すと、 **どちらに転んでも書いた人の意図が消える**。 動きを書いていない図では
+ * 種類ごとの組み立てが actors を順に繋ぐため、 書いた矢印そのものが捨てられて label も
+ * 消える (実測 = "変換" が "→" になった)。 動きを書いた図では名前がそのまま下流へ渡り、
+ * 存在しない node を指す図ができて描画の直前で落ちる
+ * (実測 = `unknown-ref: edge "e0-v-c" の from "v" が node に存在しません`)。
+ *
+ * 落ちる場所も消える場所も本文から遠いので、 書いた行で知らせる。
+ */
+function reportMissingFlowActors(
+  doc: DslDocument,
+  onNotice?: (notice: CompileNotice) => void,
+): void {
+  if (!onNotice) return;
+  const 表 = actorRefTable(doc);
+  // hint は **1 度だけ作る**。 知らせごとに全 actor 名を並べ直すと、 名前も矢印も上限
+  // (各 1,000) まで書いた図で数百 MB になる (Round 1 の指摘)。 並べる数にも上限を置く
+  //
+  // **1 件ずつの長さも切る**。 件数だけを絞っても、 名前 1 つが 2 万字なら知らせも 2 万字に
+  // なる (Round 4 の実測)。 名前も矢印の指定も外から来る文字列なので、 表示に使う所は
+  // すべて `truncateForMessage` を通す (光らせる相手の知らせと同じ扱い)。
+  const hint = 書ける面の案内(doc);
   const 知らせた = new Set<string>();
   for (const s of doc.flow) {
     for (const ref of [s.from, s.to]) {
@@ -1102,18 +1910,48 @@ function reportMissingFlowActors(
 }
 
 /**
- * 光らせる相手 (`focus:`) が実在しない分を知らせる。
+ * 光らせる相手 (`focus:`) が届かない分を知らせる。 理由で 2 通りに分ける。
  *
  * 名前が当たらなかった指定は静かに消える。 光らせたい相手を書いたのに光らない状態が、
  * 手掛かりなしで起きる。
  *
- * 見るのは記述だけ。 id の形は図種で違うが、 「その名前の箱が居るか」「その矢印が流れに
- * あるか」 は書かれた内容だけで決まる。 図種ごとの解決経路に検査を分けると、 経路が増える
- * たびに検査が取り残される。
+ * | 理由 | 見るもの | 知らせ |
+ * |---|---|---|
+ * | 記法にその名前が無い | 記述だけ | `focus-target-missing` (綴り違い) |
+ * | 記法にはあるが、書いたとおりに光らない | 組み上がった図 | `focus-target-not-honored` (#2398) |
+ *
+ * **2 つを 1 つにまとめない**。 直し方が正反対で、前者は書き直せば直り、後者は同じ案内に
+ * 従っても永久に直らない。 出来事 (`events:`) の側は #2336 で同じ分け方を持っており、
+ * 注目先の側だけ持っていなかった。
+ *
+ * 綴り違いの側は **記述だけを見る**。 id の形は図種で違うが「その名前の箱が居るか」
+ * 「その矢印が流れにあるか」 は書かれた内容だけで決まる。 図種ごとの解決経路に検査を分けると、
+ * 経路が増えるたびに検査が取り残される。
+ *
+ * ## 何が光るかは図種で 3 通りに分かれる (実測)
+ *
+ * | 光り方 | 図種 | 知らせる条件 |
+ * |---|---|---|
+ * | 書いた箱 / 矢印が光る | `c4` `flow` `record` `swimlane` `topology` | 図がその相手を持たない時 |
+ * | 書いた名前に合う言づてまで板が進む | `sequence` | 知らせない (下記) |
+ * | 図全体の 1 箱が光る | 残る 15 図種 | 書かなかった箱がある時と、矢印を書いた時 |
+ *
+ * **板の 2 図種では知らせない**。 板は箱も矢印も持たないが、書いた名前は捨てられておらず
+ * 板が何通目まで描くかを決めている (`段の番号`、 実測 = 3 通の図で `focus: ["あ -> い"]` が
+ * 0 通目、 `["う -> あ"]` が 2 通目)。 図に相手が居ないことだけを見ると、効いている指定に
+ * 「選べません」 と知らせることになる。
+ *
+ * **図全体が光る図種でも、全ての箱を書いた段では知らせない**。 光る結果 (全ての箱) と
+ * 書いたこと (全ての箱) が一致するため、伝えることが無い。 知らせるのは **書かなかった箱も
+ * 光る時** = 4 本の棒のうち 1 本だけを書いても 4 本とも光る形で、ここだけが書いたとおりに
+ * ならない。
+ *
+ * @param diagram 組み上がった図。 渡さない時は綴り違いだけを見る
  */
 function reportMissingFocusTargets(
   doc: DslDocument,
   onNotice?: (notice: CompileNotice) => void,
+  diagram?: CdlDiagram,
 ): void {
   if (!onNotice || !doc.animate) return;
   const names = new Set(doc.actors.map((a) => a.name));
@@ -1156,30 +1994,152 @@ function reportMissingFocusTargets(
   const 部品の名前 = doc.actors.filter((a) => a.partId !== undefined).map((a) => a.name);
   const 部品の中を指す = (name: string): boolean => 部品の名前.some((p) => name.startsWith(`${p}__`));
 
+  // 部品そのものの名前は、取り込む側が図の相手を決める (`部品の名前で光らせる`)。
+  // ここで図を見ると、取り込む前の図にしか当たらず「選べません」 の誤報になる
+  const 部品そのもの = new Set(部品の名前);
+
+  // 板の 2 図種は書いた名前を板の番号に使う (doc comment の表)。 図と突き合わせない
+  const 板になる = doc.type === "sequence";
+  const 見比べる図 = 板になる ? undefined : diagram;
+
+  // 綴り違いの補足は **1 度だけ作る**。 知らせごとに全ての名前を並べ直すと、名前も注目先も
+  // 上限 (各 1,000) まで書いた図で知らせが数百 MB になる (矢印の端の知らせが #1209 で踏んだ形)
+  const 名前の案内 = `actors: に書かれている名前 = ${並べて切る([...names])}`;
+
   for (const phase of doc.animate.phases) {
+    /** 記法には書いてあるのに、書いたとおりに光らない指定 (#2398) */
+    const 選べない: string[] = [];
+    /** その段が名指しした箱。 図全体が光る図種で「書かなかった箱があるか」 を見る */
+    const 書いた箱 = new Set<string>();
+    /** 選べない指定に矢印が混じったか。 図全体が光る図種は矢印を 1 本も描かない */
+    let 矢印も書いた = false;
+    /** 書いた箱のうち 1 つでも図に居たか。 居るなら図全体が光る形ではない */
+    let 箱が図に居た = false;
     for (const raw of phase.highlight ?? []) {
       const entry = parseFocusEntry(raw, names);
       const found =
         entry.kind === "edge"
           ? (steps.get(揃える(entry.from))?.has(揃える(entry.to)) ?? false)
           : accepted.has(entry.name) || 部品の中を指す(entry.name);
-      if (found) continue;
-      onNotice({
-        kind: "focus-target-missing",
-        actor: raw,
-        line: phase.pos.line,
-        message:
-          entry.kind === "edge"
-            ? `光らせる矢印が流れにありません: "${raw}"`
-            : `光らせる相手が見つかりません: "${raw}"`,
-        hint:
-          entry.kind === "edge"
-            ? "flow: に書いた矢印と同じ向きで書く"
-            : `actors: に書かれている名前 = ${[...names].join(", ")}`,
-        // 縦列の id は受理しないので、 その旨は hint に出さない (光らせられないため)
-      });
+      if (!found) {
+        onNotice({
+          kind: "focus-target-missing",
+          actor: raw,
+          line: phase.pos.line,
+          message:
+            entry.kind === "edge"
+              ? `光らせる矢印が流れにありません: "${truncateForMessage(raw)}"`
+              : `光らせる相手が見つかりません: "${truncateForMessage(raw)}"`,
+          hint: entry.kind === "edge" ? "flow: に書いた矢印と同じ向きで書く" : 名前の案内,
+          // 縦列の id は受理しないので、 その旨は hint に出さない (光らせられないため)
+        });
+        continue;
+      }
+      if (見比べる図 === undefined) continue;
+      if (entry.kind === "node") 書いた箱.add(揃える(entry.name));
+      if (entry.kind === "node" && (部品そのもの.has(entry.name) || 部品の中を指す(entry.name)))
+        continue;
+      const 相手 =
+        entry.kind === "edge"
+          ? 図の矢印を探す(見比べる図, doc, entry.from, entry.to)
+          : 図の箱を探す(見比べる図, entry.name);
+      if (相手 === undefined) {
+        選べない.push(raw);
+        if (entry.kind === "edge") 矢印も書いた = true;
+      } else if (entry.kind === "node") 箱が図に居た = true;
     }
+    if (選べない.length === 0) continue;
+    /*
+     * 全ての箱を書いた段は、光る結果 (図全体) と書いたことが一致する (doc comment の表)。
+     *
+     * **1 つでも図に居た段はここへ入れない**。 箱を 1 つずつ選べる図種で 1 箱だけが図から
+     * 落ちた時、全ての名前を書いていると「一致している」 と読めてしまう。 図全体が光る図種は
+     * どの名前も図に当たらないので、この条件で落ちることはない
+     */
+    if (!矢印も書いた && !箱が図に居た && [...names].every((n) => 書いた箱.has(n))) continue;
+    /*
+     * **1 行に 1 件だけ出す** (#2398)。 同じ段に書いた名前はどれも同じ理由で選べないので、
+     * 1 つずつ知らせると同じ文が 1 行に並ぶ。 書いた名前は文に並べる。
+     */
+    const 書かなかった箱 = [...names].filter((n) => !書いた箱.has(n));
+    onNotice({
+      kind: "focus-target-not-honored",
+      actor: 選べない[0]!,
+      line: phase.pos.line,
+      message:
+        `type: ${doc.type} は箱を 1 つずつ選べず図全体が光るため、` +
+        ` ${並べて切る(選べない, (x) => `"${x}"`)} を注目先に書いても` +
+        (書かなかった箱.length > 0
+          ? ` 書かなかった箱 (${並べて切る(書かなかった箱)}) も光ります`
+          : " 図全体が光ります"),
+      hint: "名前の書き方の問題ではありません。 全ての箱を書くか、箱を 1 つずつ選べる図種 (flow / record など) に変えてください",
+    });
+  }
+}
+
+/**
+ * 知らせの本文に名前を並べる。 件数も 1 件あたりの長さも切る (#2398)。
+ *
+ * **件数だけを絞っても足りない**。 名前は外から来る文字列なので、1 つが 2 万字なら
+ * 知らせも 2 万字になる (矢印の端の知らせが #1209 で踏んだ形)。 箱の上限は 1,000 件で、
+ * 全て並べると 1 件の知らせが数百 KB になる。
+ */
+function 並べて切る(一覧: readonly string[], 包む = (s: string): string => s): string {
+  const 見せる数 = 8;
+  const 並び = 一覧.slice(0, 見せる数).map((x) => 包む(truncateForMessage(x)));
+  const 残り = 一覧.length - 見せる数;
+  return 残り > 0 ? `${並び.join(" / ")} ほか ${残り} 件` : 並び.join(" / ");
+}
+
+/**
+ * 図の中から、書いた名前の箱を探す (#2336 / #2398)。
+ *
+ * 名前から作った識別子と、名前そのものと、描かれる題の 3 通りで探す。 記法は名前で書き、
+ * 図の識別子はそこから作られるが、見本を重ねた図など識別子が名前と揃わない形もある。
+ *
+ * **出来事の相手と注目先が同じ探し方を使う**。 片方だけ厳しくすると、正しく書いた名前が
+ * 一方では光り、もう一方では「見つからない」 と知らされる。
+ */
+function 図の箱を探す(diagram: CdlDiagram, 名: string): CdlNode | undefined {
+  const slug = slugify(名);
+  return diagram.nodes.find((n) => n.id === slug || n.id === 名 || n.title === 名);
+}
+
+/**
+ * 図の中から、書いた両端の矢印を探す (#2336 / #2398)。
+ *
+ * 板になる図種 (`sequence`) は識別子に行の番号が入るので、書いた組が
+ * 流れの何番目かを先に引いてから照合する。
+ */
+function 図の矢印を探す(
+  diagram: CdlDiagram,
+  doc: DslDocument,
+  fromName: string,
+  toName: string,
+  used?: ReadonlySet<string>,
+): CdlEdge | undefined {
+  const from = slugify(fromName);
+  const to = slugify(toName);
+  // 同じ両端を持つ行は出現順に別の線へ写すため、書き写し済みの線を候補から外す。
+  const 未使用 = (edge: CdlEdge): boolean => !used?.has(edge.id);
+  if (doc.type === "sequence") {
+    const stepIdx = doc.flow.findIndex(
+      (step) => slugify(step.from) === from && slugify(step.to) === to,
+    );
+    if (stepIdx < 0) return undefined;
+    return diagram.edges.find(
+      (x) =>
+        未使用(x) &&
+        (x.from === `s${stepIdx}-${from}` || x.from === from) &&
+        (x.to === `s${stepIdx}-${to}` || x.from === x.to),
+    );
+  }
+  // 時間軸の進行線は番号の箱を結ぶが、id は札の両端を残す。
+  // focus と出来事は書き手が札の名前で指定するため、その id の末尾で照合する。
+  if (doc.type === "swimlane" && doc.shape === "timeline") {
+    return diagram.edges.find((x) => 未使用(x) && x.id.endsWith(`-${from}-${to}`));
   }
+  return diagram.edges.find((x) => 未使用(x) && x.from === from && x.to === to);
 }
 
 /**
@@ -1217,16 +2177,9 @@ function applyEdgeInlineOptions(
     return;
   }
   const used = new Set<string>();
-  // edge.from / edge.to は plain slug (slugify(actor 名))。
-  //
-  // 順序図系 (`sequence` / `solidity`) はここに来ない = #1466 で板になり矢印を作らない。
   doc.flow.forEach((s) => {
-    const fromId = slugify(s.from);
-    const toId = slugify(s.to);
-    const target = diagram.edges.find((e) => {
-      if (used.has(e.id)) return false;
-      return e.from === fromId && e.to === toId;
-    });
+    // focus・出来事と同じ照合を使い、図種が線の端を置き換えても書いた行との対応を保つ。
+    const target = 図の矢印を探す(diagram, doc, s.from, s.to, used);
     if (!target) return;
     used.add(target.id);
     sourceLines?.set(target.id, s.pos.line);
@@ -1249,55 +2202,99 @@ function 出来事の相手を解く(
 ): NonNullable<CdlDiagram["eventBindings"]>[number]["target"] | undefined {
   if (e.target.kind === "diagram") return { kind: "diagram" };
   if (e.target.kind === "edge") {
-    const from = slugify(e.target.from);
-    const to = slugify(e.target.to);
-    let 矢印: CdlEdge | undefined;
-    if (doc.type === "sequence" || doc.type === "solidity") {
-      const stepIdx = doc.flow.findIndex(
-        (step) => slugify(step.from) === from && slugify(step.to) === to,
-      );
-      if (stepIdx >= 0) {
-        矢印 = diagram.edges.find(
-          (x) =>
-            (x.from === `s${stepIdx}-${from}` || x.from === from) &&
-            (x.to === `s${stepIdx}-${to}` || x.from === x.to),
-        );
-      }
-    } else {
-      矢印 = diagram.edges.find((x) => x.from === from && x.to === to);
-    }
+    const 矢印 = 図の矢印を探す(diagram, doc, e.target.from, e.target.to);
     return 矢印 ? { kind: "edge", id: 矢印.id } : undefined;
   }
   const 名 = e.target.name;
-  const slug = slugify(名);
   if (e.target.kind === "node") {
-    const 箱 = diagram.nodes.find((n) => n.id === slug || n.id === 名 || n.title === 名);
+    const 箱 = 図の箱を探す(diagram, 名);
     return 箱 ? { kind: "node", id: 箱.id } : undefined;
   }
+  const slug = slugify(名);
   const 列 = (diagram.lanes ?? []).find((l) => l.id === slug || l.id === 名 || l.label === 名);
   return 列 ? { kind: "lane", id: 列.id } : undefined;
 }
 
+/**
+ * 出来事が指す名前を、書いた人が本文に書いているか (#2336)。
+ *
+ * 相手が解けなかった原因を 2 つに分けるために使う。 **本文に在るなら書き直しても直らない** =
+ * その図種が登場人物を箱にしない (値を並べる図種は図全体で 1 つの箱、 順序図は
+ * 1 枚の板)。 本文に無いなら綴り違いで、書き直せば直る。
+ *
+ * 分けないと、直る件と直らない件に同じ「名前で書く」 という案内が付く。 案内に従っても
+ * 直らない側では、書いた人は綴りを疑って何度も書き直すことになる (実測 = 24 図種のうち
+ * 箱を指せるのは 7 図種)。
+ *
+ * 照合は図の識別子と同じ作り方に揃える = 箱は名前と題の両方で探し (`出来事の相手を解く` と
+ * 同じ 2 経路)、矢印は両端の名前から作った識別子で突き合わせる。 ここだけ厳しくすると、
+ * 正しく書いた名前を綴り違いとして知らせてしまう。
+ */
+function 出来事の相手が本文に在る(doc: DslDocument, e: DslEventBinding): boolean {
+  if (e.target.kind === "diagram") return true;
+  if (e.target.kind === "edge") {
+    const from = slugify(e.target.from);
+    const to = slugify(e.target.to);
+    return doc.flow.some((s) => slugify(s.from) === from && slugify(s.to) === to);
+  }
+  const 名 = e.target.name;
+  const slug = slugify(名);
+  if (e.target.kind === "node") {
+    return doc.actors.some(
+      (a) => a.name === 名 || slugify(a.name) === slug || (a.title ?? a.name) === 名,
+    );
+  }
+  return Object.entries(doc.lanes ?? {}).some(
+    ([id, 列]) => id === 名 || slugify(id) === slug || 列.label === 名,
+  );
+}
+
+/** 出来事の相手の呼び名。 知らせの本文で「何を指したか」 を言うために使う */
+const 出来事の相手の呼び名: Record<DslEventBinding["target"]["kind"], string> = {
+  node: "箱",
+  lane: "縦列",
+  edge: "矢印",
+  diagram: "図そのもの",
+};
+
 /** 本文に書いた矢印の指定を、対応が取れた矢印へ書き写す。 対応の取り方は呼出側が決める。 */
 function 矢印へ書き写す(target: CdlEdge, s: DslStep, doc: DslDocument): void {
   // **書いた補足が勝つ** (#1275)。 ここで写さないと 2 つ落ちる。 静止した `type: flow` は
-  // 鎖を作る時に説明文しか渡さないため補足が消え、`er` は見本が多重度から作った補足が
+  // 鎖を作る時に説明文しか渡さないため補足が消え、`record` は見本が多重度から作った補足が
   // 残って書いた値が無視される (どちらも実測)
   //
-  // **クラス図の `sub` は多重度なので写さない** (#1769)。 クラス図の組み立てが既に `cardinality` として
-  // 渡し、engine が行き先の端に添える (cdl#821)。 ここで札の下の行にも写すと、`1..*` が札と端の
-  // 2 か所に出て、組み立て器で書いた同じ図と食い違う (実測 = 記法の見本が組み立て器の見本と一致しなくなった)
-  if (s.sub !== undefined && doc.type !== "class") target.sub = s.sub;
+  // `relation` を書いた record の `sub` は行き先側の多重度。それ以外の `sub` は
+  // 従来どおり名前の下の補足にする (#2783)。
+  if (s.sub !== undefined) {
+    if (doc.type === "record" && s.relation !== undefined) target.headLabel = s.sub;
+    else target.sub = s.sub;
+  }
   if (s.guard !== undefined) {
     target.guard = s.guard;
     // FSM preset では sub が guard 同期、 author 明示 guard を sub に反映 (sub 既存なら上書きしない)
-    if (doc.type === "state" && target.sub === undefined) target.sub = s.guard;
+    // 書いた条件は名前の下の行にも出す (`sub` が既に在れば上書きしない)
+    if (doc.type === "record" && target.sub === undefined) target.sub = s.guard;
   }
-  // ER の多重度が名前と端にどう出るかは組み立ての時に決まっている (`compile/er-relation.ts`、#2105)。
+  // 色味と線の種類も、図種ごとの組み立てではなくここで写す (#2394)。
+  //
+  // **渡す側を図種ごとに並べる形にしない**。 この 2 欄は図種ごとの組み立てが個別に渡していて、
+  // 渡し忘れた図種でそのまま落ちていた (実測 = 線の種類は `record` / 鎖でつないだ `flow`、
+  // 色味は鎖でつないだ `flow` で黙って消える)。 図種を足した日に同じ落とし方が再発するため、
+  // 矢印を描く図種が必ず通るここへ移す。 図種ごとの組み立てに置いていた同じ受け渡しは外した =
+  // 2 か所に置くと、片方だけ直した日に食い違う。 板になる図種 (`sequence`) は
+  // 矢印を作らずここを通らないので、そちらは組み立てが持ったまま
+  if (s.tone !== undefined) target.tone = s.tone;
+  if (s.style !== undefined) target.style = s.style;
+  // 出どころの端に添える字 (#2394)。 engine は `tailLabel` として端に置く (cdl#825)。
+  //
+  if (s.tailSub !== undefined) target.tailLabel = s.tailSub;
+  // 多重度が名前と端にどう出るかは組み立ての時に決まっている (`compile/er-relation.ts`、#2105)。
   // ここで名前へ `(1:N)` を足すと、組み立てが名前の下の行に出した語と 2 度並ぶ
   if (s.cardinality !== undefined) target.cardinality = s.cardinality;
   // 矢印がどの辺から出るか (#1385)。 書かなければ描画側が自動で選ぶ
   if (s.side !== undefined) target.side = s.side;
+  if (s.fromSide !== undefined) target.fromSide = s.fromSide;
+  if (s.toSide !== undefined) target.toSide = s.toSide;
   // 矢印の先の形 (#1462)。 書かない矢印には値を入れない = 既存の図が変わらない。
   //
   // **矢印を作る 9 図種すべてがここを通る**。 図種ごとの組み立てにも同じ形を置いたが、
@@ -1313,6 +2310,13 @@ function 矢印へ書き写す(target: CdlEdge, s: DslStep, doc: DslDocument): v
   if (s.labelPlate !== undefined) target.labelPlate = s.labelPlate;
   if (s.labelOffsetX !== undefined) target.labelOffsetX = s.labelOffsetX;
   if (s.labelOffsetY !== undefined) target.labelOffsetY = s.labelOffsetY;
+  if (s.posX1 !== undefined) target.posX1 = s.posX1;
+  if (s.posY1 !== undefined) target.posY1 = s.posY1;
+  if (s.posX2 !== undefined) target.posX2 = s.posX2;
+  if (s.posY2 !== undefined) target.posY2 = s.posY2;
+  if (s.waypoints !== undefined) target.waypoints = s.waypoints;
+  if (s.labelCollision !== undefined) target.labelCollision = s.labelCollision;
+  if (s.labelSize !== undefined) target.labelSize = s.labelSize;
   // 矢印の位置のずらし (#1971)。 矢印は自分の位置を持たず、通り道は両端の箱で決まるので、
   // 動かせるのは名前だけ。 名前のずらしに足す = 両方書いた時は合わせた量だけ動く
   if (s.layoutPos !== undefined) {
@@ -1429,8 +2433,19 @@ function applyGroupFrames(
   }
   if (置く.length === 0) return;
 
-  const 配置 = layout(diagram);
-  const 並びの縦列 = 配置.lanes.filter((l) => !作った枠.has(l.id));
+  // **ここで作った枠を測る図から外す** (#2300)。 枠はまだ置いていない = `posX: 0, posY: 0` の
+  // 仮置きなので、 渡すと組の名札が全部同じ `x = 16` に積み上がり、 記法の engine が
+  // 実物と合わない重なりを知らせる (組を 2 つ書くと `1994px²`、 組を N 個書くと最大 N(N-1)/2 件)。
+  // 出来上がった図では 1 度も重ならない (名札の箱は `16.0..87.2` と `564.0..682.4`)。
+  //
+  // 外しても測る値は変わらない。 枠は `posX` と `posY` を持つ縦列として並べ直しの対象から
+  // 外れており (`role: "overlay"` で間隔の調整からも外れる)、 結果からは元から捨てていた。
+  // 渡す時点で外すだけで、 縦列と箱の位置は 1 単位も動かない。
+  const 配置 = 測るために配置する({
+    ...diagram,
+    lanes: diagram.lanes.filter((l) => !作った枠.has(l.id)),
+  });
+  const 並びの縦列 = 配置.lanes;
   for (const { 枠, 名前, line, 縦列 } of 置く) {
     const 束 = 並びの縦列.filter((l) => 縦列.includes(l.id));
     const 左 = Math.min(...束.map((l) => l.x ?? 0));
@@ -1466,9 +2481,9 @@ function applyGroupFrames(
 }
 
 /**
- * 体験の道筋の欄を、 それを描けない図種で書いた時に伝える (#1251)。
+ * ユーザージャーニーの欄を、 それを描けない図種で書いた時に伝える (#1251)。
  *
- * `touchpoint` と `opportunity` は `type: journey` の段だけが持つ。 他の図種では相手が無く、
+ * `touchpoint` と `opportunity` と `opportunityPosition` は `type: journey` の段だけが持つ。 他の図種では相手が無く、
  * 黙って捨てると「書いたのに出ない」 が手掛かりなしで起きる。
  *
  * `type: mind` では伝えない = `compileMind` が描けない欄をまとめて 1 件で伝えており、
@@ -1488,18 +2503,27 @@ function reportChartFieldsNotHonored(
         : [
             ...(a.touchpoint !== undefined ? ["touchpoint"] : []),
             ...(a.opportunity !== undefined ? ["opportunity"] : []),
+            ...(a.opportunityPosition !== undefined ? ["opportunityPosition"] : []),
           ];
     const 工程 =
       doc.type === "gantt"
         ? []
-        : [...(a.owner !== undefined ? ["owner"] : []), ...(a.end !== undefined ? ["end"] : [])];
+        : [
+            ...(a.owner !== undefined ? ["owner"] : []),
+            ...(a.end !== undefined ? ["end"] : []),
+            ...(a.startLabel !== undefined ? ["startLabel"] : []),
+            ...(a.milestone !== undefined ? ["milestone"] : []),
+            ...(a.emphasis !== undefined && doc.type !== "record" && !値として読む図が主役を読む(doc.type, doc.shape)
+              ? ["emphasis"]
+              : []),
+          ];
     if (道筋.length > 0) {
       onNotice({
         kind: "chart-value-unreadable",
         actor: a.name,
         line: a.pos?.line ?? 0,
-        message: `"${truncateForMessage(a.name)}" に書いた ${道筋.join(" / ")} は効きません (type: ${doc.type} には体験の道筋の欄がありません)`,
-        hint: "体験の道筋を描くなら type: journey を使ってください",
+        message: `"${truncateForMessage(a.name)}" に書いた ${道筋.join(" / ")} は効きません (type: ${doc.type} にはユーザージャーニーの欄がありません)`,
+        hint: "ユーザージャーニーを描くなら type: journey を使ってください",
       });
     }
     if (工程.length > 0) {
@@ -1533,93 +2557,6 @@ function reportAxesNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) =>
   });
 }
 
-/**
- * 行を組み立て器が加工する図の種類 (#1466)。
- *
- * ここに載る種類では、記法に書いた行をそのまま箱へ載せ直さない = 組み立て器が行頭の印に
- * 合わせて字を落としているため。
- */
-function 行を組み立て器が持つ(type: DslDocument["type"]): boolean {
-  return type === "class";
-}
-
-/**
- * 行と印を組む (#1466)。 群の分け方は図の種類が決める。
- *
- * ER は **鍵の群を上にまとめる** (組み立て器 `er()` と同じ形)。
- * 状態遷移は群を分けないので、書いた並びのまま。
- *
- * **空の行では開けない** (cdl `#606`)。 群の区切りは行頭の印が持っている = ER は鍵の名前に
- * 下線が付く。 空の行はその 2 つ目の手掛かりで、代わりに行の間隔を不揃いにしていた
- * (鍵と値を持つ箱だけ境目が広がる)。 組み立て器が cdl 0.23.0 で空の行をやめたので、
- * こちらも同時にやめる = 片方だけ残ると記法と図の照合が落ちる。
- */
-function 行と印を組む(
-  type: DslDocument["type"],
-  rows: readonly string[],
-  marks: readonly string[],
-): { rows: string[]; rowMarks: (RowMark | null)[] } | null {
-  const 印 = 行頭の印にする(type, marks);
-  if (印 === null) return null;
-  if (type !== "er") {
-    return { rows: [...rows], rowMarks: rows.map((_, i) => 印[i] ?? null) };
-  }
-  const 鍵: number[] = [];
-  const 値: number[] = [];
-  rows.forEach((_, i) => ((印[i]?.underline === true ? 鍵 : 値).push(i)));
-  const 並び = [...鍵, ...値];
-  return {
-    rows: 並び.map((i) => rows[i] ?? ""),
-    rowMarks: 並び.map((i) => 印[i] ?? null),
-  };
-}
-
-/**
- * 書いた語を行頭の印に読み替える (#1466)。
- *
- * **軸の意味は図の種類が決める**。 印そのものは 形 (四角 / 山形) × 塗り (塗る / 中空) の
- * 2 軸で共通だが、その軸が何を指すかは種類ごとに違う。
- *
- * | 種類 | 山形 | 塗り |
- * |---|---|---|
- * | `er` | 外を指す列 (`fk`) | 空にできない (`opt` を書かない) |
- * | `state` | 出入りの瞬間 (`entry` / `exit`) | 続く・入る側 (`entry` / `do`) |
- *
- * ER の `pk` は印の 2 軸とは別の段 (名前の下線) に載るので、`fk` と重ねて書ける。
- *
- * 語を 1 つも知らない図の種類では `null` を返す = 印を付けない。
- */
-function 行頭の印にする(
-  type: DslDocument["type"],
-  marks: readonly string[],
-): (RowMark | null)[] | null {
-  if (type === "er") {
-    return marks.map((m) => {
-      const 語 = m.trim().split(/\s+/).filter(Boolean);
-      /*
-       * **語を書かない行は「ただの値」**。 印を付けない行にはしない (#1466)。
-       *
-       * ER の印は 2 軸とも既定を持つ = 四角 (外を指さない) で塗る (空にできない)。
-       * 印なしにすると、書かなかった列だけ行頭が空いて群の間と見分けが付かなくなる。
-       */
-      return {
-        shape: 語.includes("fk") ? ("chevron" as const) : ("square" as const),
-        filled: !語.includes("opt"),
-        ...(語.includes("pk") ? { underline: true } : {}),
-      };
-    });
-  }
-  if (type === "state") {
-    return marks.map((m) => {
-      const 語 = m.trim();
-      if (語 === "") return null;
-      const 表 = FSM_ACTION_MARK as Record<string, RowMark>;
-      return 表[語] ?? null;
-    });
-  }
-  return null;
-}
-
 /**
  * `lanes:` で作った縦列と、見本 (parts) が作った同一idの縦列を 1 つに重ねる (#1241)。
  *
@@ -1705,7 +2642,7 @@ function applyV05Extensions(
   /** `lanes:` が新しく作った縦列。 箱が入ったかは見本を重ねた後でないと分からない (#1241) */
   追加した縦列out?: DslLane[],
 ): CdlDiagram {
-  // actor の主要 node を preset 種別で回収する。 sequence / solidity は header/footer を対で生成する
+  // actor の主要 node を preset 種別で回収する。 sequence は header/footer を対で生成する
   // preset で主要 node は header、 それ以外の preset は actor 名 slug がそのまま node id になる。
   //
   // seq-like の非 animate 経路は実 node id を CDL preset 側 slugify (`_` → `-` 置換 + 全角正規化) で
@@ -1713,7 +2650,7 @@ function applyV05Extensions(
   // primaryNodeId `a_b-header` が実 node `a-b-header` と食い違い、 inline option (subtitle / eyebrow /
   // value / rows) が drop する (#881、 #873 / #877 と同根の dragon⇔CDL slug 不一致)。
   //
-  // **順序図系はここを通らない** (#1466)。 `sequence` / `solidity` は 1 枚の板になり、面ごとの
+  // **順序図はここを通らない** (#1466)。 `sequence` は 1 枚の板になり、面ごとの
   // 箱も縦列も作らなくなった = 書いた欄を写す相手が無い。 面に書いた内容が効かないことは
   // `reportActorKindNotHonored` が伝える。
   // actor inline option → node merge
@@ -1723,30 +2660,34 @@ function applyV05Extensions(
     const primaryNodes = diagram.nodes.filter((n) => n.id === dragonSlug);
     for (const node of primaryNodes) {
       // 識別に使う名前と、箱に出す題を分ける (#1381)。 preset が actor 名で
-      // node を作る経路 (sequence / solidity / swimlane / c4) もここで書き換える。
+      // node を作る経路 (sequence / swimlane / c4) もここで書き換える。
       if (a.title !== undefined) node.title = a.title;
       // `type: c4` では説明の先頭に段の目印 (`L1` / `L2` / `L3`) を書く。 目印は組み立てに
       // 段を伝えるためのもので読む人に意味を持たず、 段の名前は枠のラベルが既に出している。
       // ここで落とさないと、 組み立てが読み取った目印がそのまま箱の説明として出る (#1098)
       const 説明 = doc.type === "c4" ? 段を読み取る(a.subtitle).説明 : a.subtitle;
       if (説明 !== undefined) node.subtitle = 説明;
+      if (a.kindForm !== undefined) node.kindForm = a.kindForm;
+      if (a.icon !== undefined) node.icon = a.icon;
+      if (a.emptyRowsNote !== undefined) node.emptyRowsNote = a.emptyRowsNote;
+      if (a.emphasis !== undefined && doc.type === "record") node.emphasis = a.emphasis;
+      if (a.titleAlign !== undefined) node.titleAlign = a.titleAlign;
+      if (a.rowRules !== undefined) node.rowRules = a.rowRules;
+      if (a.rowStripe !== undefined) node.rowStripe = a.rowStripe;
+      if (a.rowLayout !== undefined) node.rowLayout = a.rowLayout;
+      if (a.rowDividerForm !== undefined) node.rowDividerForm = a.rowDividerForm;
+      if (a.rowWell !== undefined) node.rowWell = a.rowWell;
+      if (a.rowMarkForm !== undefined) node.rowMarkForm = a.rowMarkForm;
+      if (a.nestIn !== undefined) node.nestIn = slugify(a.nestIn);
+      if (a.figureCard !== undefined) node.figureCard = a.figureCard;
       if (a.eyebrow !== undefined) node.eyebrow = a.eyebrow;
       if (a.value !== undefined) node.value = a.value;
-      /*
-       * 行は **組み立て器が持つ図では上書きしない** (#1466)。
-       *
-       * クラス図は行頭の印を出すために、公開の記号 (`+` / `-`) と呼び出しの括弧を字から
-       * 落とし、群の区切り (`───`) を空の行に置き換える。 書いた字をそのまま載せ直すと
-       * その加工が消え、印と字が同じことを 2 度言う形に戻る (実測)。
-       */
-      if (a.rows !== undefined && !行を組み立て器が持つ(doc.type)) node.rows = a.rows;
+      if (a.rows !== undefined) node.rows = a.rows;
       // 行頭の印 (#1466)。 書いた語を図の種類ごとの意味で読み、群の分け方も種類が決める
-      if (a.marks !== undefined && a.rows !== undefined) {
-        const 組 = 行と印を組む(doc.type, a.rows, a.marks);
-        if (組 !== null) {
-          node.rows = 組.rows;
-          node.rowMarks = 組.rowMarks;
-        }
+      if (a.marks !== undefined && a.rows !== undefined && 行頭の印を読むか(doc.type)) {
+        const 組 = 鍵の行を上にまとめる(a.rows, 行頭の印にする(a.marks, a.rows.length));
+        node.rows = 組.rows;
+        node.rowMarks = 組.rowMarks;
       }
       /*
        * **行を持たない状態でも欄を置く** (#1466)。
@@ -1755,7 +2696,7 @@ function applyV05Extensions(
        * 欄ごと省くと、その箱だけ従来の意匠に落ちて呼び名が消える (組み立て API 側の
        * `stateMachine` は同じ理由で空の欄を置いている)。
        */
-      if (doc.type === "state" && node.kind === "storage" && node.rowMarks === undefined) {
+      if (doc.type === "record" && node.kind === "storage" && node.rowMarks === undefined) {
         node.rows = a.rows ?? [];
         node.rowMarks = [];
       }
@@ -1791,7 +2732,7 @@ function applyV05Extensions(
     }
   }
   // v0.5+ animation phase 後段注入 (CAR-1657 fix、 元 dragon PR #413 report user)。
-  // preset (class / pie / c4 / mind / gantt) が doc.animate を無視して build するケースを補償。
+  // 単一箱の preset (chart / c4 / mind / gantt 等) が doc.animate を無視して build するケースを補償。
   // 既に preset が phase を生成済 (sequence / flow / swimlane / er / state / topology 経由 = compileGenericWithAnimate) なら skip。
   // doc に phase 指定があって diagram.phases が空なら、 preset 由来 lane/node/edge に対して generic phase を注入する。
   if (doc.animate && doc.animate.phases.length > 0 && diagram.phases.length === 0) {
@@ -1804,13 +2745,14 @@ function applyV05Extensions(
   // `lane-Ａ`) がこの形になり、黙って捨てられていた (実測 = 幅 999 を持つ空の縦列が増え、
   // 元の縦列は 360 のままだった)
   const 追加した縦列: DslLane[] = 追加した縦列out ?? [];
-  if (doc.lanes) {
+  if (doc.lanes && !(doc.type === "swimlane" && (doc.shape === "stages" || doc.shape === "metro" || doc.shape === "timeline"))) {
     for (const [id, laneOpt] of Object.entries(doc.lanes)) {
       const lane = diagram.lanes.find((l) => l.id === id);
       if (lane) {
         if (laneOpt.x !== undefined) lane.x = laneOpt.x;
         if (laneOpt.width !== undefined) lane.width = laneOpt.width;
         if (laneOpt.label !== undefined) lane.label = laneOpt.label;
+        if (laneOpt.subtitle !== undefined) lane.subtitle = laneOpt.subtitle;
         if (laneOpt.contain !== undefined) lane.contain = laneOpt.contain;
         if (laneOpt.lifeline !== undefined) lane.lifeline = laneOpt.lifeline;
       } else {
@@ -1825,6 +2767,7 @@ function applyV05Extensions(
           ...(laneOpt.x !== undefined ? { x: laneOpt.x } : {}),
           width: laneOpt.width ?? 320,
           label: laneOpt.label,
+          subtitle: laneOpt.subtitle,
           contain: laneOpt.contain,
           lifeline: laneOpt.lifeline,
         });
@@ -1844,6 +2787,7 @@ function applyV05Extensions(
       ...(diagram.viewport ?? {}),
       ...(doc.viewport.width !== undefined ? { width: doc.viewport.width } : {}),
       ...(doc.viewport.height !== undefined ? { height: doc.viewport.height } : {}),
+      ...(doc.viewport.contentOffsetX !== undefined ? { contentOffsetX: doc.viewport.contentOffsetX } : {}),
       ...(doc.viewport.gap !== undefined ? { gap: doc.viewport.gap } : {}),
       ...(doc.viewport.laneGap !== undefined ? { laneGap: doc.viewport.laneGap } : {}),
       ...(doc.viewport.nodeGap !== undefined ? { nodeGap: doc.viewport.nodeGap } : {}),
@@ -1857,7 +2801,7 @@ function applyV05Extensions(
 /**
  * v0.5+ animation phase 後段 fallback 注入 (CAR-1657)。
  *
- * class / pie / c4 / mind / gantt preset は独自 layout を持ち、 compileGenericWithAnimate 経路に
+ * chart / c4 / mind / gantt 等の preset は独自 layout を持ち、compileGenericWithAnimate 経路に
  * 乗らないため、 doc.animate.phases があっても diagram.phases が空になる。
  * 本 helper が applyV05Extensions から呼ばれて post-hoc に phase を差込む、 lane/node/edge は
  * 既存 preset 出力を保持したまま animation だけ追加する。
@@ -1938,7 +2882,13 @@ function injectPhasesFallback(diagram: CdlDiagram, doc: DslDocument): void {
     // **`activate` と兼ねない**。 描画側は焦点と別集合で持つ (`cdl#512`) = 焦点が当たり
     // 続ける図で毎段引き直しになるため。 書いた段だけが欄を持つ
     const drawIds =
-      p.draw !== undefined && DRAW_TARGETS.get(p.draw) === doc.type && singleBoxNode !== undefined
+      p.draw !== undefined &&
+      描く語がその図を指すか(
+        p.draw,
+        doc.type,
+        doc.shape === undefined ? undefined : (resolveShape(doc.shape) ?? undefined),
+      ) &&
+      singleBoxNode !== undefined
         ? [singleBoxNode.id]
         : [];
     diagram.phases.push({
@@ -1959,10 +2909,45 @@ function injectPhasesFallback(diagram: CdlDiagram, doc: DslDocument): void {
 }
 
 /**
- * 書いた向きが効かない時に伝える (#1494)。
+ * 向きの行を外しても、同じ組み立ての経路を通るか (#2421)。
+ *
+ * **向きを書くこと自体が経路を切り替える**。 フローは鎖をやめて書いた端のとおりに繋ぎ
+ * (`鎖にしない書き方`)、担当の図は静止図の組み立てから共通の組み立てへ回る
+ * (`共通の組み立てへ回す` の図種ごとの理由)。
  *
- * 効かない形は 2 つある。 向きを選べない図種に書いた形と、全ての箱が縦列を書いた形。
- * 後者は書いた縦列が勝つので、向きだけが黙って捨てられる。
+ * だから「既定と同じ値なら何もしない」 は成り立たない。 実測 = 動きを書かないフローに
+ * `direction: 縦` を足すと、viewBox が 490×539 から 504×631 に変わり、矢印の線種も変わる。
+ *
+ * 同じ経路を通る時だけ、書いた向きは本当に何もしない。 その経路の中で向きを読むのは
+ * `並べる向き` だけで、既定と同じ値ならそこも同じ値を返す。
+ *
+ * **判定は経路を決める関数から導く**。 条件を手で並べると、`鎖にしない書き方` に行が増えた日に
+ * ここだけ古くなる。
+ */
+function 向きを外しても同じ経路か(doc: DslDocument): boolean {
+  const 向きなし: DslDocument = { ...doc, direction: undefined };
+  if (doc.type === "flow") return 鎖でつなぐ形か(向きなし) === 鎖でつなぐ形か(doc);
+  if (doc.type === "swimlane") {
+    return 共通の組み立てへ回す("swimlane", 向きなし, false) === 共通の組み立てへ回す("swimlane", doc, true);
+  }
+  /*
+   * 分かれ道の図は向きで経路が変わらない (#2524)。 組み立ては 1 本で、向きは中で
+   * 「縦列 1 本に積むか」 の 1 点だけを切り替える。 既定と同じ値を書いた図は同じ並びになる。
+   */
+  if (doc.type === "flowchart") return true;
+  return false;
+}
+
+/**
+ * 書いた向きが図を変えない時に伝える (#1494 / #2421)。
+ *
+ * 変えない形は 3 つある。 向きを選べない図種に書いた形と、全ての箱が縦列を書いた形と、
+ * 既定と同じ向きを書いて経路も変わらない形。
+ * 前の 2 つは書いた向きが捨てられる形なので `direction-not-honored`、
+ * 3 つ目は書いても書かなくても同じ図になる形なので `direction-same-as-default`。
+ *
+ * **読み手が次に取る手が違うので 1 つにまとめない**。 前者は書き方を変えれば効くが、
+ * 後者は既に効いている値と同じで、行を外すか別の値を書くかの選択になる。
  *
  * 黙って捨てると「書いたのに変わらない」 が手掛かりなしで起きる。
  */
@@ -1970,6 +2955,36 @@ function reportDirectionNotHonored(doc: DslDocument, onNotice?: (n: CompileNotic
   if (!onNotice) return;
   if (doc.direction === undefined) return;
   const 行 = doc.directionPos?.line ?? doc.pos?.line ?? 0;
+  if (doc.type === "swimlane" && doc.shape === "timeline") {
+    onNotice({
+      kind: "direction-not-honored",
+      actor: doc.title,
+      line: 行,
+      message: "書いた direction は効きません (shape: timeline は段を常に上から下へ並べます)",
+      hint: "段の並びは actors に書いた順で決まります",
+    });
+    return;
+  }
+  if (doc.type === "swimlane" && doc.shape === "metro") {
+    onNotice({
+      kind: "direction-not-honored",
+      actor: doc.title,
+      line: 行,
+      message: "書いた direction は効きません (shape: metro は駅を常に左から右へ並べます)",
+      hint: "駅の並びは actors に書いた順で決まります",
+    });
+    return;
+  }
+  if (doc.type === "swimlane" && doc.shape === "stages") {
+    onNotice({
+      kind: "direction-not-honored",
+      actor: doc.title,
+      line: 行,
+      message: "書いた direction は効きません (shape: stages は段階を常に左から右へ並べます)",
+      hint: "段階の並びは actors に最初に現れた順で決まります",
+    });
+    return;
+  }
   if (!向きを選べる図種.has(doc.type)) {
     onNotice({
       kind: "direction-not-honored",
@@ -1980,7 +2995,7 @@ function reportDirectionNotHonored(doc: DslDocument, onNotice?: (n: CompileNotic
     });
     return;
   }
-  if (書いた縦列に置く(doc.type, doc)) {
+  if (!縦列より向きが勝つ図種.has(doc.type) && 書いた縦列に置く(doc.type, doc)) {
     onNotice({
       kind: "direction-not-honored",
       actor: doc.title,
@@ -1988,5 +3003,167 @@ function reportDirectionNotHonored(doc: DslDocument, onNotice?: (n: CompileNotic
       message: "書いた direction は効きません (全ての箱が縦列を書いているので、そちらが優先されます)",
       hint: "direction で並べたい時は箱の `lane` を外してください",
     });
+    return;
   }
+  const 既定 = 既定の向き(doc.type);
+  if (doc.direction === 既定 && 向きを外しても同じ経路か(doc)) {
+    onNotice({
+      kind: "direction-same-as-default",
+      actor: doc.title,
+      line: 行,
+      message: `書いた direction は図を変えません (${既定} は type: ${doc.type} の既定で、この図は向きの行を外しても同じ並びになります)`,
+      hint: `並びを変えるなら ${既定 === "縦" ? "横" : "縦"} を書いてください。 今の並びのままにするなら direction の行は外せます`,
+    });
+  }
+}
+
+/**
+ * 書いた並び順が効かない図種に書かれた時に伝える (#2655)。
+ *
+ * 向きの知らせと同じ形にする。 黙って捨てると「書いたのに並びが変わらない」 が
+ * 手掛かりなしで起きる。
+ *
+ * **既定と同じ値の知らせは持たない** = 並び順は書かなければ書いた順で、`種類` はそれと
+ * 必ず違う結果になる (同じ並びになるのは箱が種類の順に書かれていた時だけで、それは
+ * 図ごとに変わる)。 向きのように「既定と同じ語」 が存在しない。
+ */
+function reportOrderNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice) return;
+  if (doc.order === undefined) return;
+  if (並び順を選べる図種.has(doc.type)) return;
+  onNotice({
+    kind: "order-not-honored",
+    actor: doc.title,
+    line: doc.orderPos?.line ?? doc.pos?.line ?? 0,
+    message: `書いた order は効きません (type: ${doc.type} は並び方そのものが読み方を決めます)`,
+    hint: `order を書けるのは ${[...並び順を選べる図種].join(" / ")} です`,
+  });
+}
+
+/**
+ * 書いた形が効かない図種に書かれた時に伝える (#2657)。
+ *
+ * 並べ替えの知らせと同じ形にする。 黙って捨てると「書いたのに形が変わらない」 が
+ * 手掛かりなしで起きる。
+ *
+ * 書ける形は `DIAGRAM_SHAPES` が図種ごとに決める。 別の図種の語は解析後も残し、ここで
+ * 「読めたがこの図種では効かない」 と伝える。
+ */
+function reportShapeNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice) return;
+  if (doc.shape === undefined) return;
+  const 図種の語 = shapesForDiagramType(doc.type);
+  if (図種の語.includes(doc.shape)) return;
+  const hint =
+    図種の語.length > 0
+      ? `type: ${doc.type} で書ける shape = ${図種の語.join(" / ")}`
+      : `shape を書けるのは ${Object.entries(DIAGRAM_SHAPES)
+          .map(([type, shapes]) => `type: ${type} (${shapes.join(" / ")})`)
+          .join(" / ")} です`;
+  onNotice({
+    kind: "shape-not-honored",
+    actor: doc.title,
+    line: doc.shapePos?.line ?? doc.pos?.line ?? 0,
+    message: `書いた shape: ${doc.shape} は効きません (type: ${doc.type} では使えません)`,
+    hint,
+  });
+}
+
+/** `form` は円グラフだけ、`ticks` はガントチャートだけが読む。 */
+function reportFormNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (doc.form === undefined || (doc.type === "chart" && doc.shape === "pie")) return;
+  onNotice?.({
+    kind: "chart-value-unreadable",
+    actor: doc.title,
+    line: doc.formPos?.line ?? 0,
+    message: `form (見せ方) は shape: pie にだけ効きます (type: ${doc.type} では無視しました)`,
+  });
+}
+
+function reportTicksNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (doc.type === "gantt") return;
+  const fields = [
+    ...(doc.ticks !== undefined ? ["ticks (目盛り)"] : []),
+    ...(doc.ganttToday !== undefined ? ["ganttToday"] : []),
+    ...(doc.ganttTickLabels !== undefined ? ["ganttTickLabels"] : []),
+    ...(doc.ganttBarEnd !== undefined ? ["ganttBarEnd"] : []),
+    ...(doc.ganttBarThickness !== undefined ? ["ganttBarThickness"] : []),
+  ];
+  if (fields.length === 0) return;
+  onNotice?.({
+    kind: "chart-value-unreadable",
+    actor: doc.title,
+    line: doc.ticksPos?.line ?? 0,
+    message: `${fields.join(" / ")} は type: gantt にだけ効きます (type: ${doc.type} では無視しました)`,
+  });
+}
+
+/** 特別な泳路配置が元の lane を組み直す時、補足を黙って捨てないために伝える。 */
+function reportLaneSubtitleNotHonored(
+  doc: DslDocument,
+  onNotice?: (n: CompileNotice) => void,
+): void {
+  if (
+    !onNotice ||
+    doc.type !== "swimlane" ||
+    (doc.shape !== "stages" && doc.shape !== "timeline")
+  ) return;
+  for (const lane of Object.values(doc.lanes ?? {})) {
+    if (lane.subtitle === undefined) continue;
+    onNotice({
+      kind: "lane-option-not-honored",
+      actor: lane.id,
+      line: lane.pos.line,
+      message: `縦列 "${truncateForMessage(lane.id)}" に書いた subtitle は shape: ${doc.shape} では効きません`,
+      hint: "subtitle を消すか、通常の縦列または shape: metro の路線図で使ってください",
+    });
+  }
+}
+
+/** `stage` を省いた箱で担当または箱名を段階に使ったことを、図全体で 1 件だけ伝える (#2797)。 */
+function reportStageFromLane(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice || doc.type !== "swimlane" || doc.shape !== "stages") return;
+  const 補った = doc.actors.filter(
+    (actor) => actor.stage === undefined && 泳法図で印をどう描く(doc, actor) !== "省く",
+  );
+  const 最初 = 補った[0];
+  if (最初 === undefined) return;
+  onNotice({
+    kind: "stage-from-lane",
+    actor: doc.title,
+    line: 最初.pos?.line ?? doc.pos?.line ?? 0,
+    message: `段階を書いていない箱は担当または箱の名前を段階として使いました: ${補った
+      .map((actor) => truncateForMessage(actor.name))
+      .join(" / ")}`,
+    hint: "段階を分けて決めるなら、各箱に stage または 段階 を書いてください",
+  });
+}
+
+/** `lane` を省いた箱で箱名を線路名に使ったことを、図全体で 1 件だけ伝える (#2799)。 */
+function reportTrackFromName(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice || doc.type !== "swimlane" || doc.shape !== "metro") return;
+  const 補った = doc.actors.filter((actor) => actor.lane === undefined);
+  const 最初 = 補った[0];
+  if (最初 === undefined) return;
+  onNotice({
+    kind: "track-from-name",
+    actor: doc.title,
+    line: 最初.pos?.line ?? doc.pos?.line ?? 0,
+    message: `担当を書いていない箱は箱の名前を線路に使いました: ${補った
+      .map((actor) => truncateForMessage(actor.name))
+      .join(" / ")}`,
+    hint: "線路を担当でまとめるなら、各箱に lane を書いてください",
+  });
+}
+
+/** `theme:` と別名の `palette:` を両方書いた時に、消す行を 1 件だけ伝える (#2790)。 */
+function reportThemeAlsoPalette(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice || doc.themeAlsoPalettePos === undefined || doc.theme === undefined) return;
+  onNotice({
+    kind: "theme-palette-both",
+    actor: doc.title,
+    line: doc.themeAlsoPalettePos.paletteLine,
+    message: `theme: と palette: を両方書きました。 palette: は theme: の別名なので theme: の値 (${doc.theme}) を使います`,
+    hint: "palette: の行を消してください",
+  });
 }