@cardenelabs/dragon 0.7.0 → 0.8.0

package/src/compile.ts

@@ -9,11 +9,12 @@
  * v0.2 ... 6 preset 全対応 (sequence / flow / swimlane / er / state / topology)
  */
 
-import type { DslDocument, DslPhase } from "./types";
-import type { CdlDiagram, ErRelationCardinality, LaidDiagram } from "@cardenelabs/cdl";
+import type { DslActor, DslDocument, DslLane, DslPhase, DslStep, DslValue, PresetType } from "./types";
+import type { CdlDiagram, CdlEdge, ErRelationCardinality, FormulaAst, LaidDiagram } from "@cardenelabs/cdl";
 import {
   sequence, flow, swimlane, er, stateMachine, topology, diagram, layout,
   rendersRows, requiredRowsHeight, requiredRowsWidth, NODE_KINDS,
+  applyDerivedValues, parseFormula,
 } from "@cardenelabs/cdl";
 import { parseFocusEntry } from "./focus";
 import { isColorValue, stripExternalPaint } from "./color";
@@ -66,7 +67,31 @@ export type CompileNotice = {
     // 図の中に描く部品を持たない見本を重ねた (#1017)
     | "part-not-drawn"
     // `倍率:` を書いた見本が、同じ名前の状態も持っていた (#1026)
-    | "scale-reserved";
+    | "scale-reserved"
+    // 値で描く図 (`pie` / `bar` / `line`) で値を読めなかった (#1154)
+    | "chart-value-unreadable"
+    // 同上で矢印を書いた。 これらの図は関係を描けない (#1154)
+    | "chart-edge-dropped"
+    // 同じ名前を `states` と `values` の両方に書いた (#1162)
+    | "value-shadows-state"
+    // 式を解けず、その値を止めた (輪 / 無い名前 / 読めない式 / 数として読めない値、 #1162)
+    | "value-unresolved"
+    // 同じ名前を `values` に 2 度書いた。 先に書いた式を使う (#1162)
+    | "value-duplicate"
+    // 矢印が `actors` に無い名前を指した (#1209)
+    | "flow-actor-missing"
+    // きっかけ形の値を段に畳めなかった (段が無い / 相手が境目を通らない / 段からはみ出す、 #1161)
+    | "value-trigger-unresolved"
+    // 矢印の両端が同じ登場人物だった (#1227)
+    | "flow-self-loop"
+    // 箱に `lane:` を書いたが、 縦列は図種が決めるため効かなかった (#1246)
+    | "lane-not-honored"
+    // `lanes:` に書いた縦列に箱が 1 つも入らなかった (#1241)
+    | "lane-declared-empty"
+    // 最上位に `eyebrow:` を書いたが、 箱ごとに分かれる図種で相手が決まらなかった (#1247)
+    | "eyebrow-not-honored"
+    // 静止した `type: flow` で、書いた矢印の端が使われなかった (#1269)
+    | "flow-endpoint-not-honored";
   /** 対象の名前。 光らせる相手なら書かれた指定そのまま */
   actor: string;
   /** 書かれていた行 */
@@ -82,6 +107,28 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   const oversize = describeOversize({ elements: countDocElements(doc), bytes: 0 });
   if (oversize) throw new Error(oversize);
 
+  // 矢印の指す先を `actors` に書いた名前へ揃える (#1209)。 **図種ごとの組み立てより前**。
+  //
+  // 動きを書いた図は slug に落として引き、 書いていない図は名前の完全一致で引く。 揃えないと
+  // 同じ本文が図種ごとに別の相手を指す = 知らせは出ないのに label が消える / 題が slug に
+  // 化ける / 依存が切れる (Round 1 で実測)。
+  doc = canonicalizeFlowActors(doc);
+
+  // 知らせは **落とす前の矢印** を見る (#1219)。 落とした後を渡すと、 図が壊れないように
+  // 外した矢印が書いた人に届かなくなる
+  const 書いたまま = doc;
+  // 解決できない矢印を組み立てから外す (#1219)。 残すと、 存在しない箱や枠を指す図ができて
+  // 描画の直前で落ちる (実測 = 8 図種)
+  doc = dropUnresolvedFlow(doc);
+  // 自分へ戻る矢印を組み立てから外す (#1227)。 残すと描画側の検査が図ごと落とし、
+  // 本文のどの行が原因かも出ない
+  doc = dropSelfLoopFlow(doc);
+
+  // 名前から作る id が重なる分を解く (#1220)。 **矢印を落とした後**に見る = 落とした矢印の
+  // 端にしか出てこない名前で id を分けても、 その箱は作られない
+  const 分けた = disambiguateActorIds(doc, opts?.onNotice);
+  doc = 分けた.doc;
+
   let diagram: CdlDiagram;
   switch (doc.type) {
     case "sequence":
@@ -112,37 +159,92 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
       diagram = compileClass(doc);
       break;
     case "pie":
-      diagram = compilePie(doc);
+      diagram = compileValueChart(doc, "pie", "chart-pie", opts?.onNotice);
+      break;
+    case "bar":
+      diagram = compileValueChart(doc, "bar", "chart-bar", opts?.onNotice);
+      break;
+    case "line":
+      diagram = compileValueChart(doc, "line", "chart-line", opts?.onNotice);
+      break;
+    case "funnel":
+      diagram = compileFunnel(doc, opts?.onNotice);
+      break;
+    case "tree":
+      diagram = compileTree(doc, opts?.onNotice);
+      break;
+    case "journey":
+      diagram = compileJourney(doc, opts?.onNotice);
+      break;
+    case "quadrant":
+      diagram = compileQuadrant(doc, opts?.onNotice);
       break;
     case "c4":
       diagram = compileC4(doc);
       break;
     case "mind":
-      diagram = compileMind(doc);
+      diagram = compileMind(doc, opts?.onNotice);
       break;
     default:
       // switch case で全 type を網羅済のため default は unreachable、 template expression で
       // never 型を直接埋込めないので String() で明示 (defensive runtime error message 用)。
       throw new Error(`unknown type: ${String(doc.type)}`);
   }
+  // 作り替えた名前を持つ箱と枠を、 **組み立て直後に** 控える (#1220)。 出口で題の文字だけを
+  // 見て戻すと、 後から足された見本の中の箱がたまたま同じ題を持っていた時に書き換えてしまう
+  const 作り替えた対象 = collectRenamedTargets(diagram, 分けた.元の名前);
+
   // edge と本文の行の対応は表に集めてから 1 edge = 1 回で知らせる (#998)。 経路ごとに
   // その場で呼ぶと、 同じ edge に別の行を 2 度知らせることになる。
   const edgeSourceLines = opts?.onEdgeSource ? new Map<string, number>() : undefined;
   applyEdgeInlineOptions(diagram, doc, edgeSourceLines);
-  // `type: flow` は actor を鎖状に繋ぐため上の (from, to) 一致では取れない。 preset の規則で埋める。
-  if (edgeSourceLines) fillFlowEdgeSources(diagram, doc, edgeSourceLines);
   applyGroupContainers(diagram, doc);
   applyNodeTones(diagram, doc);
   // 光らせる相手が実在するかを確かめる。 id への解決は図種ごとに違うが、 名前が居るか
   // 居ないかは記述だけで決まるので 1 か所で見る
-  reportMissingFocusTargets(doc, opts?.onNotice);
+  reportMissingFocusTargets(書いたまま, opts?.onNotice);
+  // 矢印が指す名前が actors に居るかを確かめる。 図種ごとの解決より前に、 記述だけで決まる
+  reportMissingFlowActors(書いたまま, opts?.onNotice);
+  // 両端が同じ矢印を伝える (#1227)。 落とす前の `flow` を見る
+  reportSelfLoopFlow(書いたまま, opts?.onNotice);
+  // 静止した `type: flow` で書いた矢印の端が使われないことを伝える (#1269)。
+  // 自分へ戻る形と居ない名前を指す形は既に落ちた後の `doc` を見る = 上の 2 件と重ねない
+  reportFlowEndpointNotHonored(doc, 分けた.元の名前, opts?.onNotice);
+  reportLaneNotHonored(書いたまま, opts?.onNotice);
+  reportDocEyebrowNotHonored(書いたまま, opts?.onNotice);
+  reportChartFieldsNotHonored(書いたまま, opts?.onNotice);
+  reportAxesNotHonored(書いたまま, opts?.onNotice);
   // `位置: Web の右` を実際の配置から絶対座標に直す。 以降は座標を直接書いた時と同じ経路
   const placed = resolveRelativeDoc(diagram, doc, opts?.onNotice, opts?.partsCatalog);
   // canvas pivot 新 spec = 全 preset 共通の post-process で actor.posX/Y を CDL lane / node に伝播
   applyCanvasPivotPositions(diagram, placed);
   // CAR-1657 = parts kind actor を merge (opts.partsCatalog 経由)、 applyV05Extensions 後段で実行
-  const extended = applyV05Extensions(diagram, placed);
-  const merged = mergePartsFromActors(extended, placed, opts?.partsCatalog, opts?.onNotice);
+  const 追加した縦列: DslLane[] = [];
+  const extended = applyV05Extensions(diagram, placed, 追加した縦列);
+  // 値の知らせは、本文なら値を書いた行、見本なら見本を置いた行を指す。 `derived` 自体には
+  // source position が無いため、見本を重ねる間だけ別表で宣言元を持ち回る (#1180)。
+  const inheritedDerivedSourceLines = opts?.onNotice ? new Map<string, number[]>() : undefined;
+  for (const value of extended.derived ?? []) {
+    recordDerivedSourceLine(inheritedDerivedSourceLines, value.id, 0);
+  }
+  const merged = mergePartsFromActors(
+    extended,
+    placed,
+    opts?.partsCatalog,
+    opts?.onNotice,
+    inheritedDerivedSourceLines,
+  );
+  // 箱が 1 つも入らなかった縦列を伝える (#1241)。
+  //
+  // **見本 (parts) を重ねた後に見る**。 見本の箱は `lane` で行き先を選べるため、
+  // `lanes:` で作った縦列に後から入る (実測 = 重ねる前に見ると、箱が入っている縦列にまで
+  // 知らせが出た)。
+  //
+  // 字の集合では防げない = 全角 (`lane-Ａ` に対し生成は `lane-a`) でも打ち間違い
+  // (`lane-idl`) でも結果は同じで、新しい縦列が増えるだけで書いた幅は元の縦列に届かない。
+  // 受け付けを字で絞るのではなく、合わなかったこと自体を伝える
+  reportEmptyDeclaredLanes(merged, 追加した縦列, opts?.onNotice);
+
   // 表が揃ってから 1 edge = 1 回で知らせる。 merge 後に残っている edge だけを対象にする =
   // 途中で消えた edge の行を知らせても呼出側が使えない。
   if (edgeSourceLines && opts?.onEdgeSource) {
@@ -161,11 +263,21 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // **出口で 1 度だけ見る**。 種類ごとに塞ぐと 12 経路のどれかを見落とす。 図は必ずここを
   // 通るので、 ここで段が無ければ入れる。
   injectStaticPhase(merged);
+  // 書いた状態を図に載せる (#1162)。 段を書かない図でも値が届くようにする。
+  // **値を載せるより先に呼ぶ**。 状態が空のまま式を解くと、参照が全て「無い名前」 になる。
+  materializeStates(merged, doc);
+  // 語の欄が状態を読むとき、その状態には記法の語が入っている。 図の語へ直す (#1201)
+  語の状態を図の語へ直す(merged);
+  // きっかけ形の値を段の時計を読む式へ畳む (#1161 段 2)。 **値を載せるより先に呼ぶ** =
+  // 畳んだ式を `attachDerivedValues` が他の値と同じ経路で載せるため、 順序 / 重なり / 知らせの
+  // 扱いが式形と揃う。 時計の状態と段の補間もここで足す
+  const 畳んだきっかけ = foldValueTriggers(merged, doc, opts?.onNotice);
+  attachDerivedValues(merged, doc, opts?.onNotice, inheritedDerivedSourceLines, 畳んだきっかけ);
   // 図の外を指す値を、 色を塗る位置から落とす (#1004)。
   //
   // 入口ごとに塞ぐ形は採らない。 状態の上書き / phase が入れる値 / 画面が直接書く背景色 /
-  // 埋め込んだ JSON と入口が 4 つ以上あり、 1 つ見落とすと穴が残る。 描画へ渡る図は必ず
-  // ここを通るので、 出口で 1 度だけ見る。
+  // 埋め込んだ JSON / states / values と入口が複数あり、 1 つ見落とすと穴が残る。
+  // **図への追加を全て終えた後**、 出口で 1 度だけ見る。 この後に状態を足すと検査を迂回する。
   for (const dropped of stripExternalPaint(merged)) {
     opts?.onNotice?.({
       kind: "external-paint-dropped",
@@ -175,9 +287,35 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
       hint: "色は `#ff0000` のような色番号か、 `red` のような色名で書く",
     });
   }
+  // 作り替えた名前を表示だけ戻す (#1220)。 **図への追加を全て終えた後**に戻す = 途中で戻すと、
+  // 後続の処理が名前で引く時に作り替え前と後が混ざる
+  restoreActorNames(merged, 分けた.元の名前, 作り替えた対象);
   return merged;
 }
 
+/**
+ * 書いた状態 (`states:`) を図に載せる (#1162)。
+ *
+ * 状態を図に登録するのは `animation:` を書いた経路だけだった (`compileGenericWithAnimate` と
+ * `injectPhasesFallback` のどちらも段がある時しか走らない)。 このため `states:` と `values:`
+ * だけを書いた図では図の状態が 0 件になり、描画側が組み立てる値が空になる。 書いた値は
+ * 1 つも届かず、箱には `{waiting}` の生の形が出ていた (実測)。
+ *
+ * **出口で 1 度だけ載せる**。 段を作る経路は図の種類ごとにばらけており、経路ごとに書くと
+ * どれかを見落とす (`injectStaticPhase` と同じ理由)。
+ *
+ * 既に載っている名前は触らない。 段の経路が登録した初期値と、見本から引き継いだ状態
+ * (`alias__id` の形) の両方を保つ。
+ */
+function materializeStates(diagram: CdlDiagram, doc: DslDocument): void {
+  const 載っている = new Set(diagram.states.map((s) => s.id));
+  for (const st of doc.animate?.states ?? []) {
+    if (載っている.has(st.name)) continue;
+    diagram.states.push({ id: st.name, initial: st.initial });
+    載っている.add(st.name);
+  }
+}
+
 /**
  * 動かない図に段を 1 つ入れる (#1086)。
  *
@@ -227,6 +365,631 @@ function truncateForMessage(v: string): string {
  * あるか」 は書かれた内容だけで決まる。 図種ごとの解決経路に検査を分けると、 経路が増える
  * たびに検査が取り残される。
  */
+/**
+ * 矢印の指す先を `actors` に書いた **正規の名前** へ解決する表 (#1209)。
+ *
+ * 名前そのものに加えて **一意な slug も受ける**。 動きを書いた図の組み立ては `slugify` に
+ * 落として引くため、 `API Gateway` を `api-gateway` と書いた形が届く。 2 つ以上の名前が
+ * 同じ slug になる時は受けない = どちらを指したか決められない。
+ *
+ * **返すのは正規の名前で、 slug ではない**。 slug を返すと、 動きを書いていない図の組み立て
+ * (名前の完全一致で引く) と食い違う = 知らせは出ないのに label が消える / 題が slug に化ける /
+ * 依存が切れる、 という形になる (Round 1 で実測)。 中央で名前へ揃えれば全経路が同じ相手を指す。
+ */
+function actorRefTable(doc: DslDocument): Map<string, string> {
+  const 表 = new Map<string, string>();
+  const slug数 = new Map<string, number>();
+  for (const a of doc.actors) {
+    const sl = slugify(a.name);
+    slug数.set(sl, (slug数.get(sl) ?? 0) + 1);
+  }
+  for (const a of doc.actors) {
+    表.set(a.name, a.name);
+    const sl = slugify(a.name);
+    if ((slug数.get(sl) ?? 0) === 1) 表.set(sl, a.name);
+  }
+  return 表;
+}
+
+/**
+ * 矢印の指す先を正規の名前へ揃えた `flow` を返す (#1209)。
+ *
+ * 解決できない矢印はそのまま残す = 図種ごとに扱いが違う (木は独自の知らせを出し、 値で描く図は
+ * 落とす)。 中央で消すとその扱いが効かなくなる。 残した分は `reportMissingFlowActors` が
+ * 知らせ、 動きを書いた図の組み立てが落とす。
+ */
+function canonicalizeFlowActors(doc: DslDocument): DslDocument {
+  const 表 = actorRefTable(doc);
+  let 変えた = false;
+  const flow = doc.flow.map((s) => {
+    const from = 表.get(s.from) ?? s.from;
+    const to = 表.get(s.to) ?? s.to;
+    if (from === s.from && to === s.to) return s;
+    変えた = true;
+    return { ...s, from, to };
+  });
+  return 変えた ? { ...doc, flow } : doc;
+}
+
+/**
+ * 図種ごとの図の作り (#1219 / #1220)。
+ *
+ * 2 つの判断がここから決まる。 解決できない矢印を中央で落とすか (#1219) と、 名前が同じ id に
+ * 潰れる登場人物を作り替えるか (#1220)。 どちらも **登場人物の名前が箱や枠の id になる図種**
+ * でだけ要る。
+ *
+ * `#1209` は動きを書いた 2 経路だけを塞いだ。 残る経路では **知らせは出るのに図まで壊れる**
+ * 状態だった (実測 = 8 図種が `compile` の `unknown-ref` で落ちる)。
+ *
+ * | 作り | 解決できない矢印 | 同じ id に潰れる名前 |
+ * |---|---|---|
+ * | 登場人物ごとに箱 | 中央で落とす | 名前を作り替えて id を分ける |
+ * | 図全体を 1 箱 | 図種に任せる | 触らない |
+ *
+ * **1 箱で描く図種を中央で落とさない**。 これらは矢印そのものを描かず、 書かれた本数を数えて
+ * 独自の知らせを出す (`chart-edge-dropped` / 木の親子の知らせ)。 中央で外すと本数が変わり、
+ * 全部が解決できない図では知らせごと消える。 同じ id に潰れる名前も、 中身を payload が
+ * 持つため箱の id にならず、 木と放射は独自の知らせを出す。
+ *
+ * `Record<PresetType, ...>` にしてあるので、 図種を足した時にどちらかを決めないと型検査が
+ * 落ちる (`rules/quality.md § 多層 SSOT 経路の全 registration 保証` と同じ形)。
+ */
+const 図種の作り: Record<PresetType, "登場人物ごとに箱" | "図全体を 1 箱"> = {
+  // 矢印の端と登場人物の名前が、 そのまま箱や枠の id になる
+  sequence: "登場人物ごとに箱",
+  flow: "登場人物ごとに箱",
+  swimlane: "登場人物ごとに箱",
+  er: "登場人物ごとに箱",
+  state: "登場人物ごとに箱",
+  topology: "登場人物ごとに箱",
+  solidity: "登場人物ごとに箱",
+  class: "登場人物ごとに箱",
+  c4: "登場人物ごとに箱",
+  // 中身は payload が持ち、 図そのものは 1 箱。 矢印は描かず本数を数えて知らせる
+  gantt: "図全体を 1 箱",
+  pie: "図全体を 1 箱",
+  bar: "図全体を 1 箱",
+  line: "図全体を 1 箱",
+  funnel: "図全体を 1 箱",
+  tree: "図全体を 1 箱",
+  journey: "図全体を 1 箱",
+  quadrant: "図全体を 1 箱",
+  mind: "図全体を 1 箱",
+};
+
+/**
+ * 解決できない矢印を落とした `flow` を返す (#1219)。
+ *
+ * 落とすのは **組み立てに渡す分だけ**。 知らせ (`reportMissingFlowActors`) は元の `flow` を
+ * 見るので、 落とした矢印も書いた人に届く。
+ */
+function dropUnresolvedFlow(doc: DslDocument): DslDocument {
+  if (図種の作り[doc.type] === "図全体を 1 箱") return doc;
+  const 表 = actorRefTable(doc);
+  const flow = doc.flow.filter((s) => 表.has(s.from) && 表.has(s.to));
+  return flow.length === doc.flow.length ? doc : { ...doc, flow };
+}
+
+/**
+ * 自分へ戻る矢印を落とした `flow` を返す (#1227)。
+ *
+ * 描画側は両端が同じ矢印を受けない (`validate` が `self-loop` で落とす)。 記法の側は通すため、
+ * 書けてしまって描画の直前で図ごと落ちていた。 本文のどの行が原因かも出ない。
+ *
+ * `#1219` が「解決できない矢印は組み立てから外し、 知らせは元の `flow` を見る」 という形を
+ * 決めているので、 それに揃える。 落とすのは **組み立てに渡す分だけ** で、 書いた人には
+ * `reportSelfLoopFlow` が行番号付きで伝える。
+ *
+ * ## `type: state` の自己遷移をどう扱うか
+ *
+ * 矢印としては描けない。 描画側に自分へ戻る矢印を足すのは別 repo の判断で、 本 repo の
+ * 記法から決められない。 代わりに 2 通りの書き方が残る = 途中の箱を 1 つ足して 2 本の矢印に
+ * 分けるか、 段 (`animation`) で状態が変わる様子として見せる。 知らせの `hint` がこの 2 つを
+ * 案内する。
+ *
+ * 図全体を 1 箱で描く種別は矢印を作らないため対象にしない (本数を数えて別に伝えている)。
+ */
+function dropSelfLoopFlow(doc: DslDocument): DslDocument {
+  if (図種の作り[doc.type] === "図全体を 1 箱") return doc;
+  const flow = doc.flow.filter((s) => s.from !== s.to);
+  return flow.length === doc.flow.length ? doc : { ...doc, flow };
+}
+
+/**
+ * 自分へ戻る矢印を書いた人に伝える (#1227)。
+ *
+ * **落とす前の `flow` を見る**。 落とした後を渡すと、 図が壊れないように外した矢印が
+ * 書いた人に届かない (`reportMissingFlowActors` と同じ理由)。
+ *
+ * 同じ登場人物に何本書いても 1 件にまとめる = 本数だけ知らせが並んでも直し方は変わらない。
+ */
+function reportSelfLoopFlow(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice) return;
+  if (図種の作り[doc.type] === "図全体を 1 箱") return;
+  const 知らせた = new Set<string>();
+  for (const s of doc.flow) {
+    if (s.from !== s.to || 知らせた.has(s.from)) continue;
+    知らせた.add(s.from);
+    onNotice({
+      kind: "flow-self-loop",
+      actor: s.from,
+      line: s.pos.line,
+      message: `"${truncateForMessage(s.from)}" から自分へ戻る矢印は描けません (組み立てから外しました)`,
+      hint: "途中の箱を 1 つ足して 2 本に分けるか、 段 (animation) で状態が変わる様子として見せる",
+    });
+  }
+}
+
+/**
+ * 図全体を 1 箱にする図種で、 その箱の上に出す小見出しを渡す (#1247)。
+ *
+ * 書かなければ何も渡さない = 従来どおり小見出しは付かない。 `undefined` を明示して渡すと、
+ * 組立て側が「空の小見出しを書いた」 と区別できなくなるので、 項目ごと落とす。
+ */
+function 図の小見出し(doc: DslDocument): { eyebrow?: string } {
+  return doc.eyebrow === undefined ? {} : { eyebrow: doc.eyebrow };
+}
+
+/**
+ * 箱ごとに分かれる図種で最上位の小見出しを書いた時に伝える (#1247)。
+ *
+ * 小見出しは **箱 1 つに対して 1 つ**。 図全体を 1 箱にする図種 (`pie` / `bar` 等) では
+ * 相手が決まるが、 箱ごとに分かれる図種では「どの箱の小見出しか」 が決まらない。
+ *
+ * 黙って捨てると「書いたのに出ない」 が手掛かりなしで起きる。 箱ごとに書く形
+ * (`- A: { eyebrow: "..." }`) を案内する = そちらは従来どおり効く。
+ */
+function reportDocEyebrowNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice) return;
+  if (doc.eyebrow === undefined) return;
+  if (図種の作り[doc.type] === "図全体を 1 箱") return;
+  onNotice({
+    kind: "eyebrow-not-honored",
+    actor: doc.title,
+    // 図の `pos` は常に 1 行目を指す。 書いた行に辿り着けるよう `eyebrowPos` を優先する
+    line: doc.eyebrowPos?.line ?? doc.pos?.line ?? 0,
+    message: `最上位に書いた eyebrow は効きません (type: ${doc.type} は箱ごとに分かれるため相手が決まりません)`,
+    hint: '箱ごとに書いてください (`- A: { eyebrow: "..." }`)',
+  });
+}
+
+/**
+ * 縦列を選べる図種で、一部の箱だけが縦列を書いた時に伝える (#1263)。
+ *
+ * 書かなかった箱の行き先を決める規則が要るが、既定の縦列に集めても自分の縦列を作っても
+ * 書いた人の意図と一致する保証が無い。 **全部書くか 1 つも書かないか** を求める。
+ *
+ * 1 つも書いていない形は従来どおりの並びになるだけなので知らせない。
+ */
+function reportLaneMixed(doc: DslDocument, onNotice: (n: CompileNotice) => void): void {
+  const 対象 = doc.actors.filter((a) => a.partId === undefined);
+  const 書いた = 対象.filter((a) => a.lane !== undefined);
+  if (書いた.length === 0 || 書いた.length === 対象.length) return;
+  const 書いていない = 対象.filter((a) => a.lane === undefined);
+  onNotice({
+    kind: "lane-not-honored",
+    actor: 書いていない[0]?.name ?? "",
+    line: 書いていない[0]?.pos?.line ?? 0,
+    message: `type: ${doc.type} では縦列を書くなら全ての箱に書きます (書いていない箱: ${書いていない.map((a) => truncateForMessage(a.name)).join(" / ")})`,
+    hint: "書かなかった箱をどの縦列に置くかを決められないため、全部書くか 1 つも書かないかにしてください",
+  });
+}
+
+/**
+ * 静止した `type: flow` で、書いた矢印の端が使われないことを伝える (#1269)。
+ *
+ * この図種は **登場人物を書いた順に鎖状に繋ぐ**。 矢印の説明文は「その箱を to に持つ行」
+ * から拾い、書いた側の端 (from) は使わない (`compileFlow`)。
+ *
+ * そのため `A -> C` と書いても出来るのは `A -> B` で、書いた形と違う図になる。
+ * 実測 = `A -> C` / `C -> B` と書くと `A -> B` に `"y"`、`B -> C` に `"x"` が載った。
+ * 知らせは 1 件も出ていなかった。
+ *
+ * ## 鎖にすること自体は変えない
+ *
+ * 線形の流れを描く図種なので、鎖にするのは仕様。 書いた端どおりに繋ぎたい形は
+ * 箱に `lane:` を書けば別の経路へ回る (#1266)。 知らせの hint でそれを案内する。
+ *
+ * ## 偶然一致する形では知らせない
+ *
+ * `A -> B` / `B -> C` のように書いた端がそのまま鎖になる形は、書いたとおりの図になる。
+ * ここで知らせると、正しく書いた人にまで出る。
+ *
+ * ## 既に落ちた行は見ない
+ *
+ * 自分へ戻る形 (`flow-self-loop`) と居ない名前を指す形 (`flow-actor-missing`) は
+ * 別の知らせが担う。 落とした後の `doc` を見ることで、同じ 1 行に知らせが 2 件並ぶのを避ける。
+ */
+function reportFlowEndpointNotHonored(
+  doc: DslDocument,
+  元の名前: Map<string, string>,
+  onNotice?: (n: CompileNotice) => void,
+): void {
+  if (!onNotice) return;
+  if (!鎖でつなぐ形か(doc)) return;
+  // 名前が重なった登場人物は組み立ての間だけ尾を付けて分けている (`disambiguateActorIds`)。
+  // **判定は分けた後の名前で行い、伝える時は書いた名前に戻す** = 判定は `compileFlow` の
+  // 繋ぎ方と揃える必要があり、伝える先は本文なので書いていない名前を指すと直せない
+  // (実測 = `"A B 546d26" の端は使われません` と出て、本文にその名前は無い)
+  const 書いた名前 = (name: string): string => 元の名前.get(name) ?? name;
+  // 鎖が作る組を集める。 登場人物が 1 人以下なら矢印が 1 本も出来ないので、
+  // 書いた矢印は全て使われない扱いになる
+  const 鎖の組 = new Set<string>();
+  doc.actors.forEach((a, i) => {
+    const 次 = doc.actors[i + 1];
+    if (次 === undefined) return;
+    鎖の組.add(`${a.name}\u0000${次.name}`);
+  });
+  for (const s of doc.flow) {
+    if (鎖の組.has(`${s.from}\u0000${s.to}`)) continue;
+    onNotice({
+      kind: "flow-endpoint-not-honored",
+      actor: 書いた名前(s.from),
+      line: s.pos.line,
+      message: `"${truncateForMessage(書いた名前(s.from))} -> ${truncateForMessage(書いた名前(s.to))}" の端は使われません (type: flow は登場人物を書いた順に繋ぎます)`,
+      hint: "書いた端どおりに繋ぐには、箱に lane: を書いてください (縦列を書いた形は書いた端がそのまま矢印になります)",
+    });
+  }
+}
+
+/**
+ * 箱に書いた縦列が効かないことを伝える (#1246)。
+ *
+ * 縦列は **図種が決める**。 `flow` / `topology` は 1 本にまとめ、 `swimlane` / `er` / `state`
+ * は箱ごとに 1 本作り、 `sequence` はそれがそのまま生命線になる。 図全体を 1 箱にする図種
+ * (`pie` / `bar` 等) では箱が 1 つしかない。 **どの図種も箱の `lane` を読まない**。
+ *
+ * 黙って捨てると、 書いた縦列は消え、 `lanes:` で宣言した縦列だけが中身のないまま残る。
+ * 実測 = `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;
+  // 縦列を選べる図種では、全ての箱が書いていれば効く (#1263)。 効く形では知らせない
+  const 効く図種 = 縦列を選べる図種.has(doc.type as GenericKind);
+  if (効く図種 && 書いた縦列に置く(doc.type as GenericKind, 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 を消してください (見本では張替え先として使えます)",
+    });
+  }
+}
+
+/**
+ * 名前から作る id の重なりを解く (#1220)。
+ *
+ * 箱と枠の id は登場人物の名前から作る (`slugify`)。 **違う名前が同じ id に潰れる** と、
+ * どちらも正しく書いているのに図が組み立たない (実測 = `foo-bar` と `Foo Bar` を書くと
+ * 9 図種が `duplicate-id` で落ちる)。 知らせも出ない = どちらの名前も `actors` に在るため。
+ *
+ * ## なぜ名前を作り替えるのか
+ *
+ * id を作る所は 90 箇所を超え、 さらに **cdl 側の組み立てが名前から id を作る経路** がある
+ * (`swimlane()` / `er()` は渡した名札から lane id を作る)。 dragon 側だけを直しても届かない。
+ *
+ * そこで **渡す名前を変え、 最後に表示だけ戻す**。 作り替えた名前は組み立ての間だけ使い、
+ * 出口で `nodes[].title` と `lanes[].label` を元に戻す (`restoreActorNames`)。
+ *
+ * ## 尾は名前から作る
+ *
+ * 書き順で決めると、 登場人物を並べ替えただけで id が入れ替わる。 元の名前だけから決まる
+ * 短い値を尾に付ければ、 並べ替えても同じ id になる。
+ *
+ * ## まったく同じ名前は畳む
+ *
+ * 名前が 1 文字も違わない登場人物は区別できない。 2 つの箱に同じ題が付くだけなので、
+ * 先に書いた方を残して知らせる。
+ */
+function 名前の尾(name: string): string {
+  // FNV-1a。 短くて名前だけから決まればよく、 衝突しても下の検査が拾う
+  let h = 0x811c9dc5;
+  for (const c of name) {
+    h ^= c.codePointAt(0) ?? 0;
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0").slice(0, 6);
+}
+
+/**
+ * cdl 側が名札から id を作る時の規則 (`presets.ts` の `slugify`)。
+ *
+ * **dragon の規則と違う**。 dragon は `-` と `_` を残し `NFKC` で揃え 64 字で切るが、 cdl は
+ * どちらも `-` に潰し、 長さも切らない。 このため `a_b` と `a-b` は **dragon では別 id、 cdl では
+ * 同じ id** になる (実測 = 動きを書かない `sequence` / `solidity` が `duplicate-id` で落ちる)。
+ *
+ * ここに写している = cdl は `slugify` を公開していない。 **ずれると衝突を見落とす** ので、
+ * 下の検査が既知の組で対応を固定する。
+ */
+function cdl側のslug(s: string): string {
+  return s
+    .toLowerCase()
+    .replace(/[^a-z0-9぀-ゟ゠-ヿ一-龯]+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+/**
+ * cdl 側が「形が空になった名前」 に付ける id の頭 (#1220 Round 2 / 3)。
+ *
+ * cdl は形が空になった時に並びの位置へ逃げる。 逃げ先を鍵に入れないと、 逃げ先と同じ名前の
+ * 登場人物が居る図で重なる (実測 = `sequence` の `😀` と `actor-0`)。
+ *
+ * **図種ごとに違う** (Round 3 の指摘)。 両方を入れると、 その図種では使われない逃げ先まで
+ * 衝突とみなして **重なっていない図の id を変える**。 実測した対応は次のとおり。
+ *
+ * | 図種 | `😀` だけを書いた時に付く id |
+ * |---|---|
+ * | `sequence` / `solidity` | 枠 `actor-0` (cdl の `sequence()`) |
+ * | `swimlane` | 枠 `lane-0` (cdl の `swimlane()`) |
+ * | 残る 6 図種 | 箱 `n` (dragon 側の逃げ先。 cdl の逃げ道を通らない) |
+ *
+ * 空配列は「cdl の逃げ道を通らない」 を表す。 1 箱で描く図種はここに来ない (作り替え自体を
+ * しない) が、 図種を足した時に決め忘れないよう全種を並べる。
+ *
+ * **この表が効くのは動きを書いていない図だけ** (Round 4 の指摘)。 動きを書くと組み立てが別経路に
+ * 切り替わり、 id は dragon 側の規則で作られる = cdl の逃げ道を通らない。 使う側で条件を見る。
+ */
+const 空の形の逃げ先: Record<PresetType, string[]> = {
+  sequence: ["actor-"],
+  solidity: ["actor-"],
+  swimlane: ["lane-"],
+  flow: [],
+  er: [],
+  state: [],
+  topology: [],
+  class: [],
+  c4: [],
+  // 図全体を 1 箱で描く群 (作り替えないのでここは使わない)
+  gantt: [],
+  pie: [],
+  bar: [],
+  line: [],
+  funnel: [],
+  tree: [],
+  journey: [],
+  quadrant: [],
+  mind: [],
+};
+
+/**
+ * その名前が下流で id になりうる形。 どれか 1 つでも重なれば衝突する。
+ *
+ * 位置と逃げ先が分からない時 (作り替えた候補を確かめる時) は逃げ先を数えない。 作り替えた
+ * 名前は尾が付いて形が空にならないので、 そもそも逃げ道を通らない。
+ */
+function idになる形(name: string, 位置?: number, 逃げ先の頭: string[] = []): string[] {
+  const cdl = cdl側のslug(name);
+  const out = [slugify(name), cdl];
+  if (cdl === "" && 位置 !== undefined) {
+    for (const 頭 of 逃げ先の頭) out.push(`${頭}${位置}`);
+  }
+  return out;
+}
+
+function disambiguateActorIds(
+  doc: DslDocument,
+  onNotice?: (notice: CompileNotice) => void,
+): { doc: DslDocument; 元の名前: Map<string, string> } {
+  const 元の名前 = new Map<string, string>();
+  if (図種の作り[doc.type] !== "登場人物ごとに箱") return { doc, 元の名前 };
+
+  // 1. まったく同じ名前を畳む
+  const 見た = new Set<string>();
+  const 残す: DslActor[] = [];
+  for (const a of doc.actors) {
+    if (見た.has(a.name)) {
+      onNotice?.({
+        kind: "chart-value-unreadable",
+        actor: a.name,
+        line: a.pos?.line ?? 0,
+        message: `"${truncateForMessage(a.name)}" を 2 度書いています (先に書いた方だけ描きます)`,
+        hint: "違う名前にするか、 1 つにまとめる",
+      });
+      continue;
+    }
+    見た.add(a.name);
+    残す.push(a);
+  }
+
+  // 2. どの名前が重なるかを見る。 **両方の規則で見る** = 片方だけだと cdl 側の経路で落ちる
+  const 形ごとの名前 = new Map<string, Set<string>>();
+  const 位置 = new Map<string, number>();
+  残す.forEach((a, i) => 位置.set(a.name, i));
+  // **動きを書いた図では cdl の逃げ道を通らない** (Round 4 の指摘)。 動きがあると組み立てが
+  // 別経路 (`compileGenericWithAnimate` / `compileSequenceWithAnimate`) に切り替わり、 id は
+  // dragon 側の規則で作られる (実測 = `😀` は 枠 `n` / `lane-n` になり、 位置を使わない)。
+  //
+  // 逃げ先を鍵に入れたままにすると、 その経路で **重なっていない図の id を変える**。
+  // dragon 側の規則で作る分は、 1 つ目の鍵 (`slugify`) が既に見ている。
+  const 動きを書いた = (doc.animate?.phases.length ?? 0) > 0;
+  const 逃げ先の頭 = 動きを書いた ? [] : 空の形の逃げ先[doc.type];
+  for (const a of 残す) {
+    for (const 形 of idになる形(a.name, 位置.get(a.name), 逃げ先の頭)) {
+      const 群 = 形ごとの名前.get(形) ?? new Set<string>();
+      群.add(a.name);
+      形ごとの名前.set(形, 群);
+    }
+  }
+  const 重なる = (name: string): boolean =>
+    idになる形(name, 位置.get(name), 逃げ先の頭).some(
+      (形) => (形ごとの名前.get(形)?.size ?? 0) > 1,
+    );
+
+  // **見本 (`parts`) を重ねた登場人物は作り替えない**。 見本の中身は `別名__元の id` の形で
+  // 名前空間を持ち、 別名は名前から作るため、 作り替えると見本の id が総入れ替えになる。
+  //
+  // ただし **重なりの判定には数える** (Round 1 の指摘)。 数えないと、 素の登場人物と見本が
+  // 同じ id の仮置きを共有し、 見本を片付ける時に素の登場人物の箱まで消える。
+  const 作り替える = 残す.filter((a) => a.partId === undefined && 重なる(a.name));
+
+  // 3. 名前から決まる尾を付ける。 **できあがる id が一意になるまで見る**
+  //
+  // 尾は元の名前だけから決まる = 並べ替えても同じ id になる。 それでも重なる時 (尾そのものが
+  // 重なる形) は、 名前を並べ替えた順で番号を足す = ここも書き順に依らない
+  const 使う形 = new Set<string>();
+  for (const a of 残す) {
+    if (作り替える.some((b) => b.name === a.name)) continue;
+    for (const 形 of idになる形(a.name)) 使う形.add(形);
+  }
+  const 新しい名前 = new Map<string, string>();
+  // 名前で並べてから配る = 書いた順に依らない
+  for (const a of [...作り替える].sort((x, y) => (x.name < y.name ? -1 : x.name > y.name ? 1 : 0))) {
+    const 尾 = 名前の尾(a.name);
+    // **id の長さの上限のぶん、 元の名前を先に切る** (Round 1 の指摘)。 切らないと尾が
+    // 64 字で落ちて、 同じ頭を持つ長い名前どうしが元のまま重なる
+    const 余地 = ID_MAX - (尾.length + 1);
+    const 基底 = a.name.slice(0, 余地);
+    let 候補 = `${基底} ${尾}`;
+    let n = 0;
+    while (idになる形(候補).some((形) => 使う形.has(形))) {
+      n += 1;
+      候補 = `${基底.slice(0, 余地 - String(n).length)} ${尾}${n}`;
+    }
+    for (const 形 of idになる形(候補)) 使う形.add(形);
+    新しい名前.set(a.name, 候補);
+    元の名前.set(候補, a.name);
+  }
+
+  if (新しい名前.size === 0 && 残す.length === doc.actors.length) return { doc, 元の名前 };
+
+  const 直す = (名: string): string => 新しい名前.get(名) ?? 名;
+  const 次: DslDocument = {
+    ...doc,
+    actors: 残す.map((a) => (新しい名前.has(a.name) ? { ...a, name: 直す(a.name) } : a)),
+    flow: doc.flow.map((s) => {
+      const from = 直す(s.from);
+      const to = 直す(s.to);
+      return from === s.from && to === s.to ? s : { ...s, from, to };
+    }),
+  };
+  // 光らせる指定と位置の基準も名前で書くので、 同じ表で直す
+  if (次.animate) {
+    次.animate = {
+      ...次.animate,
+      phases: 次.animate.phases.map((ph) =>
+        ph.highlight ? { ...ph, highlight: ph.highlight.map((h) => 直す(h)) } : ph,
+      ),
+    };
+  }
+  次.actors = 次.actors.map((a) =>
+    a.posRel ? { ...a, posRel: { ...a.posRel, anchor: 直す(a.posRel.anchor) } } : a,
+  );
+  return { doc: 次, 元の名前 };
+}
+
+/**
+ * 作り替えた名前を持つ箱と枠を控える (#1220)。
+ *
+ * **組み立て直後に控える** (Round 1 の指摘)。 出口で題の文字だけを見て戻すと、 後から足された
+ * 見本の中の箱がたまたま同じ題を持っていた時に、 その表示まで書き換えてしまう。
+ */
+function collectRenamedTargets(
+  diagram: CdlDiagram,
+  元の名前: Map<string, string>,
+): { 箱: Set<string>; 枠: Set<string> } {
+  const 箱 = new Set<string>();
+  const 枠 = new Set<string>();
+  if (元の名前.size === 0) return { 箱, 枠 };
+  for (const n of diagram.nodes) if (元の名前.has(n.title)) 箱.add(n.id);
+  for (const l of diagram.lanes) if (l.label !== undefined && 元の名前.has(l.label)) 枠.add(l.id);
+  return { 箱, 枠 };
+}
+
+/**
+ * 作り替えた名前を、 図の表示だけ元に戻す (#1220)。
+ *
+ * 戻すのは題と名札だけ。 id は作り替えたまま = 分けるために作り替えたので、 戻すと元の
+ * 重なりに帰る。
+ */
+function restoreActorNames(
+  diagram: CdlDiagram,
+  元の名前: Map<string, string>,
+  対象: { 箱: Set<string>; 枠: Set<string> },
+): void {
+  if (元の名前.size === 0) return;
+  for (const n of diagram.nodes) {
+    if (!対象.箱.has(n.id)) continue;
+    const 元 = 元の名前.get(n.title);
+    if (元 !== undefined) n.title = 元;
+  }
+  for (const l of diagram.lanes) {
+    if (!対象.枠.has(l.id) || l.label === undefined) continue;
+    const 元 = 元の名前.get(l.label);
+    if (元 !== undefined) l.label = 元;
+  }
+}
+
+/**
+ * 矢印が `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 見せる数 = 8;
+  const 名前一覧 = doc.actors
+    .slice(0, 見せる数)
+    .map((a) => truncateForMessage(a.name))
+    .join(" / ");
+  const 残り = doc.actors.length - 見せる数;
+  const hint =
+    doc.actors.length > 0
+      ? `actors に書いた名前で指す (${名前一覧}${残り > 0 ? ` ほか ${残り} 件` : ""})`
+      : "actors に登場人物を書く";
+  const 知らせた = new Set<string>();
+  for (const s of doc.flow) {
+    for (const ref of [s.from, s.to]) {
+      if (表.has(ref) || 知らせた.has(ref)) continue;
+      知らせた.add(ref);
+      onNotice({
+        kind: "flow-actor-missing",
+        actor: ref,
+        line: s.pos.line,
+        message: `矢印が "${truncateForMessage(ref)}" を指していますが、 actors に書かれていません`,
+        hint,
+      });
+    }
+  }
+}
+
 function reportMissingFocusTargets(
   doc: DslDocument,
   onNotice?: (notice: CompileNotice) => void,
@@ -258,12 +1021,20 @@ function reportMissingFocusTargets(
     steps.set(st.from, tos);
   }
 
+  // 矢印の両端は **流れと同じ表で名前へ揃えてから** 照合する (#1209 Round 2)。
+  //
+  // 流れは入口で名前へ揃えている (`canonicalizeFlowActors`) 一方、 光らせる指定は生のまま
+  // 来る。 揃えずに比べると、 slug で書いた矢印 (`api-gateway -> db`) が実際は光るのに
+  // 「見つかりません」 と誤報する (実測)
+  const 名前へ = actorRefTable(doc);
+  const 揃える = (ref: string): string => 名前へ.get(ref) ?? ref;
+
   for (const phase of doc.animate.phases) {
     for (const raw of phase.highlight ?? []) {
       const entry = parseFocusEntry(raw, names);
       const found =
         entry.kind === "edge"
-          ? (steps.get(entry.from)?.has(entry.to) ?? false)
+          ? (steps.get(揃える(entry.from))?.has(揃える(entry.to)) ?? false)
           : accepted.has(entry.name);
       if (found) continue;
       onNotice({
@@ -1485,9 +2256,13 @@ function mergePartsFromActors(
   doc: DslDocument,
   partsCatalog?: Record<string, CdlDiagram>,
   onNotice?: (notice: CompileNotice) => void,
+  derivedSourceLines?: Map<string, number[]>,
 ): CdlDiagram {
   const partsActors = doc.actors.filter((a) => a.partId !== undefined);
   if (partsActors.length === 0) return target;
+  // 値と状態の名前に使う前置きを **書いた順に 1 度だけ** 決める (#1189)。 見本ごとに作ると
+  // 同じ形に潰れた時の番号が揃わず、後から重ねた見本が先の名前空間を踏む
+  const 値の前置き = 値の前置きを作る(partsActors.map((a) => a.name));
   if (!partsCatalog) {
     if (typeof console !== "undefined" && console.warn) {
       const names = partsActors.map((a) => `${a.name} (kind: ${a.partId ?? "?"})`).join(", ");
@@ -1585,7 +2360,21 @@ function mergePartsFromActors(
       }
     }
     const t = partTargetSize(part, actor.posW, actor.posH, actor.scale);
-    mergePartIntoDiagram(target, part, actor.name, merged, actor.lane, placeX, placeY, t.w, t.h, onNotice, actor.pos?.line ?? 0);
+    mergePartIntoDiagram(
+      target,
+      part,
+      actor.name,
+      merged,
+      actor.lane,
+      placeX,
+      placeY,
+      t.w,
+      t.h,
+      onNotice,
+      actor.pos?.line ?? 0,
+      derivedSourceLines,
+      値の前置き.get(actor.name),
+    );
   }
   return target;
 }
@@ -1644,6 +2433,56 @@ function applyColorHex(
  * state initial は stateOverride で上書き可、 shape / subtitle / value 内の '{stateName}' template も
  * '{alias__stateName}' に rewrite する。 phase parallel merge (activate / tweens / sets の id 参照 rename)。
  */
+/**
+ * 値と状態の名前に使う前置きを、登場人物の名前から作る (#1189)。
+ *
+ * `{名前}` に書ける字種は engine が 1 箇所で決めており (`template-name.ts`)、英数字と `_` に
+ * 限る。 **読む側 (置き換え) と書ける側 (式) の両方がその定義を使う** ため、記法の側だけ
+ * 広げることはできない。
+ *
+ * この記法では日本語の名前が普通なので、名前をそのまま前置きにすると値が 1 つも届かない。
+ * 実測 = `受付 1` に見本を重ねると、状態は表に載るのに箱の `{受付 1__v}` が置き換わらず、
+ * 見本の中の式は識別子として読めずに止まる (`value-unresolved`)。
+ *
+ * **箱 / 縦列 / 矢印の id は変えない**。 これらは `{名前}` の対象ではなく、画面側が id から
+ * 登場人物の名前を取り出す経路があるため、変えると別の場所が壊れる。
+ *
+ * ## 同じ形に潰れる名前
+ *
+ * `受付 1` と `受付-1` はどちらも英数字だけにすると同じ形になる。 潰れたまま使うと 2 つの
+ * 見本が同じ名前空間を共有し、片方の値がもう片方を上書きする。
+ *
+ * そこで **書いた順に番号を足して分ける**。 先に書いた方が番号なしを取り、後から同じ形に
+ * なった方が `_2` / `_3` と続く。 英数字の名前しか無い図では 1 つも番号が付かないため、
+ * 既存の図の名前は変わらない。
+ */
+function 値の前置きを作る(名前たち: readonly string[]): Map<string, string> {
+  const 出力 = new Map<string, string>();
+  const 使用中 = new Set<string>();
+  const 次の番号 = new Map<string, number>();
+  for (const 名前 of 名前たち) {
+    if (出力.has(名前)) continue;
+    let 素 = 名前
+      .normalize("NFKC")
+      .replace(/[^A-Za-z0-9_]+/g, "_")
+      .replace(/^_+|_+$/g, "");
+    // 空になる形 (記号だけの名前) と数字始まりは、そのままでは名前として使えない
+    if (素 === "" || /^[0-9]/.test(素)) 素 = `p${素}`;
+    // 接尾辞で分けた名前も使用済みとして扱う。 `p1` / `p1!` / `p1_2` の順では、
+    // base ごとの回数だけを見ると後ろ 2 つがどちらも `p1_2` になって再衝突する
+    let 候補 = 素;
+    let 番号 = 次の番号.get(素) ?? 2;
+    while (使用中.has(候補)) {
+      候補 = `${素}_${番号}`;
+      番号 += 1;
+    }
+    次の番号.set(素, 番号);
+    使用中.add(候補);
+    出力.set(名前, 候補);
+  }
+  return 出力;
+}
+
 function mergePartIntoDiagram(
   target: CdlDiagram,
   part: CdlDiagram,
@@ -1669,15 +2508,48 @@ function mergePartIntoDiagram(
   onNotice?: (notice: CompileNotice) => void,
   /** 知らせに載せる行。 パーツを書いた行を指す。 行が取れない経路 (JSON) では 0 */
   noticeLine = 0,
+  /** 見本から引き継いだ値の宣言元。 notice を見本を書いた行へ戻すために使う */
+  derivedSourceLines?: Map<string, number[]>,
+  /**
+   * 値と状態の名前に使う前置き (#1189)。 `{名前}` は英数字と `_` しか読めないため、
+   * 登場人物の名前をそのまま使えない。 渡されない経路では従来どおり名前をそのまま使う
+   */
+  valueAlias?: string,
 ): void {
   const prefix = (id: string): string => `${alias}__${id}`;
-  const stateIdSet = new Set(part.states.map((s) => s.id));
+  // 値と状態だけ別の前置きを使う (#1189)。 箱 / 縦列 / 矢印の id は `prefix` のまま
+  const 値前置き = valueAlias ?? alias;
+  const valuePrefix = (id: string): string => `${値前置き}__${id}`;
+  // 見本が自分で持つ名前。 **状態と、他の値から決まる値の両方** (#1180)。
+  //
+  // 値を含めないと、見本の中の `{決まる値}` が名前を付け替えられずに残り、重ねた先の同名の
+  // 値を指してしまう (見本どうしが互いの値を読む形になる)。
+  const ownIdSet = new Set([
+    ...part.states.map((s) => s.id),
+    ...(part.derived ?? []).map((d) => d.id),
+  ]);
   const rewriteTemplate = (s: string | undefined): string | undefined => {
     if (!s) return s;
-    return s.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (m, name: string) => {
-      return stateIdSet.has(name) ? `{${prefix(name)}}` : m;
+    return s.replace(/\{(\w+)\}/g, (m, name: string) => {
+      return ownIdSet.has(name) ? `{${valuePrefix(name)}}` : m;
     });
   };
+  // 値の式は見本の名前空間の中で閉じる。 見本が持つ名前だけを書き換えると、綴り違いの参照が
+  // 取り込み先の同名の値に偶然つながり、単体では止まる見本の意味が置いた場所で変わる。
+  //
+  // **どれが参照かは engine に決めさせる**。 engine は `{v}` と裸の `v` の両方を参照として
+  // 読み、関数名 (`min` / `Math.max` 等) は参照に数えない (実測)。 ここで関数の一覧を持つと
+  // 記法側 (`value-syntax.ts`) と engine に続く 3 つ目の写しになり、engine が関数を足した時に
+  // 静かにずれる。
+  const rewriteDerivedExpression = (expression: string): string => {
+    try {
+      return writeFormula(renameFormulaIdentifiers(parseFormula(expression), valuePrefix));
+    } catch {
+      // 読めない式は engine が止めて伝える (`value-unresolved`)。 書き換えられないので
+      // そのまま載せる = 名前は前置き無しのままだが、式自体が解けないため値は出ない
+      return expression;
+    }
+  };
 
   // 決定的 lane 参照 = user が書いた lane 指定を優先、 なければ parts 内部 lane を prefix 付きで作る
   const targetLaneId = laneMapping;
@@ -1886,7 +2758,22 @@ function mergePartIntoDiagram(
         hint: "色は `#ff0000` のような色番号か、 `red` のような色名で書く",
       });
     }
-    target.states.push({ id: prefix(stateOrig.id), initial });
+    target.states.push({ id: valuePrefix(stateOrig.id), initial });
+  }
+
+  // 見本が持つ「他の値から決まる値」 を引き継ぐ (#1180)。
+  //
+  // 引き継がないと、見本の中で書いた関係が重ねた先で解かれず、その値を読む箱に `{名前}` の
+  // 生の形が出る。 名前は状態と同じ規則で前置きを付ける = 見本を 2 つ重ねても互いの値を
+  // 読まない。 式の中の参照は、未定義の名前も含めて見本の名前空間へ閉じ込める。
+  for (const derivedOrig of part.derived ?? []) {
+    if (!target.derived) target.derived = [];
+    const id = valuePrefix(derivedOrig.id);
+    target.derived.push({
+      id,
+      expression: rewriteDerivedExpression(derivedOrig.expression),
+    });
+    recordDerivedSourceLine(derivedSourceLines, id, noticeLine);
   }
 
   // edge merge = id / from / to prefix (parts 内 edge は稀だが対応)
@@ -1928,8 +2815,8 @@ function mergePartIntoDiagram(
         ...phaseOrig,
         id: prefix(phaseOrig.id),
         activate: phaseOrig.activate.map(prefix),
-        tweens: phaseOrig.tweens.map((t) => ({ ...t, stateId: prefix(t.stateId) })),
-        sets: phaseOrig.sets.map((s) => ({ ...s, stateId: prefix(s.stateId) })),
+        tweens: phaseOrig.tweens.map((t) => ({ ...t, stateId: valuePrefix(t.stateId) })),
+        sets: phaseOrig.sets.map((s) => ({ ...s, stateId: valuePrefix(s.stateId) })),
       });
     }
   } else {
@@ -1943,8 +2830,8 @@ function mergePartIntoDiagram(
       const partPhase = part.phases[i]!;
       targetPhase.duration = Math.max(targetPhase.duration, partPhase.duration);
       targetPhase.activate = [...targetPhase.activate, ...partPhase.activate.map(prefix)];
-      targetPhase.tweens = [...targetPhase.tweens, ...partPhase.tweens.map((t) => ({ ...t, stateId: prefix(t.stateId) }))];
-      targetPhase.sets = [...targetPhase.sets, ...partPhase.sets.map((s) => ({ ...s, stateId: prefix(s.stateId) }))];
+      targetPhase.tweens = [...targetPhase.tweens, ...partPhase.tweens.map((t) => ({ ...t, stateId: valuePrefix(t.stateId) }))];
+      targetPhase.sets = [...targetPhase.sets, ...partPhase.sets.map((s) => ({ ...s, stateId: valuePrefix(s.stateId) }))];
     }
     // parts phase 余剰は append (target より parts が長い場合)
     for (let i = commonLen; i < partsLen; i++) {
@@ -1953,8 +2840,8 @@ function mergePartIntoDiagram(
         ...phaseOrig,
         id: prefix(phaseOrig.id),
         activate: phaseOrig.activate.map(prefix),
-        tweens: phaseOrig.tweens.map((t) => ({ ...t, stateId: prefix(t.stateId) })),
-        sets: phaseOrig.sets.map((s) => ({ ...s, stateId: prefix(s.stateId) })),
+        tweens: phaseOrig.tweens.map((t) => ({ ...t, stateId: valuePrefix(t.stateId) })),
+        sets: phaseOrig.sets.map((s) => ({ ...s, stateId: valuePrefix(s.stateId) })),
       });
     }
   }
@@ -1985,7 +2872,7 @@ function deepRewriteStrings(
 }
 
 /**
- * v0.5+ flow inline option (guard / cardinality / labelOffsetX / labelOffsetY) を
+ * v0.5+ flow inline option (guard / cardinality / labelOffsetX / labelOffsetY / overlay) を
  * 既存 preset 経由で生成された CdlEdge に対し、 doc.flow の (from, to) 一致順マッチングで反映する。
  *
  * 設計:
@@ -2002,6 +2889,16 @@ function applyEdgeInlineOptions(
   /** 対応が取れた edge を記録する表。 callback は呼ばない (1 edge = 1 回にするため)。 */
   sourceLines?: Map<string, number>,
 ): void {
+  // **静止した `type: flow` は書いた端で対応が取れない** (#1267)。 鎖の規則で先に埋める
+  if (鎖でつなぐ形か(doc)) {
+    diagram.edges.forEach((e, idx) => {
+      const s = 鎖のどの行から来たか(doc, idx);
+      if (s === undefined) return;
+      sourceLines?.set(e.id, s.pos.line);
+      矢印へ書き写す(e, s, doc);
+    });
+    return;
+  }
   const used = new Set<string>();
   // sequence preset では actor 名 が lane id、 edge.from は `s{stepIdx}-{laneId}` 形式。
   // solidity は sorted-actor を sequence preset 経由するため sequence と同形。
@@ -2025,28 +2922,65 @@ function applyEdgeInlineOptions(
     if (!target) return;
     used.add(target.id);
     sourceLines?.set(target.id, s.pos.line);
-    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;
-    }
-    if (s.cardinality !== undefined) {
-      target.cardinality = s.cardinality;
-      // ER preset の場合 label に "(1:N)" 形式で併記 (既に含まれていればスキップ)
-      if (doc.type === "er" && !target.label.includes(s.cardinality)) {
-        target.label = target.label
-          ? `${target.label} (${s.cardinality})`
-          : `(${s.cardinality})`;
-      }
-    }
-    if (s.labelOffsetX !== undefined) target.labelOffsetX = s.labelOffsetX;
-    if (s.labelOffsetY !== undefined) target.labelOffsetY = s.labelOffsetY;
+    矢印へ書き写す(target, s, doc);
   });
 }
 
-/**
- * 描画側が大きさを持つ種別。
- *
+/** 本文に書いた矢印の指定を、対応が取れた矢印へ書き写す。 対応の取り方は呼出側が決める。 */
+function 矢印へ書き写す(target: CdlEdge, s: DslStep, doc: DslDocument): void {
+  // **書いた補足が勝つ** (#1275)。 ここで写さないと 2 つ落ちる。 静止した `type: flow` は
+  // 鎖を作る時に説明文しか渡さないため補足が消え、`er` は見本が多重度から作った補足が
+  // 残って書いた値が無視される (どちらも実測)
+  if (s.sub !== undefined) 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;
+  }
+  if (s.cardinality !== undefined) {
+    target.cardinality = s.cardinality;
+    // ER preset の場合 label に "(1:N)" 形式で併記 (既に含まれていればスキップ)
+    if (doc.type === "er" && !target.label.includes(s.cardinality)) {
+      target.label = target.label
+        ? `${target.label} (${s.cardinality})`
+        : `(${s.cardinality})`;
+    }
+  }
+  if (s.labelOffsetX !== undefined) target.labelOffsetX = s.labelOffsetX;
+  if (s.labelOffsetY !== undefined) target.labelOffsetY = s.labelOffsetY;
+  if (s.overlay !== undefined) target.overlay = s.overlay;
+}
+
+/**
+ * 静止した `type: flow` かどうか。 この形だけ矢印を鎖状に作る (`compileFlow`)。
+ *
+ * 段を持つ形と縦列を書いた形は generic 経路へ回るため鎖にならない。 判定を 1 か所に
+ * 集めるのは、`compileFlow` の分岐と食い違うと対応の取り方だけがずれるため。
+ */
+function 鎖でつなぐ形か(doc: DslDocument): boolean {
+  if (doc.type !== "flow") return false;
+  if (doc.animate && doc.animate.phases.length > 0) return false;
+  return !書いた縦列に置く("flow", doc);
+}
+
+/**
+ * 鎖の N 本目の矢印が、本文のどの行から来たかを返す (#1267)。
+ *
+ * `compileFlow` は登場人物を書いた順に繋ぎ、説明文は **その箱を to に持つ行** から拾う。
+ * 書いた側の端 (from) は使わない。 そのため `A -> C` と書いても矢印は `A -> B` になり、
+ * (from, to) の一致では対応が取れない (実測 = 説明文だけが載り、指定が黙って落ちていた)。
+ *
+ * 説明文を決めた規則と同じ規則で指定も決める = 説明文と指定が必ず同じ行から来る。
+ */
+function 鎖のどの行から来たか(doc: DslDocument, edgeIndex: number): DslStep | undefined {
+  const to = doc.actors[edgeIndex + 1];
+  if (to === undefined) return undefined;
+  return doc.flow.find((s) => s.to === to.name);
+}
+
+/**
+ * 描画側が大きさを持つ種別。
+ *
  * 記法の `kind` は描画の種別より広い。 そのまま渡すと大きさを引けずに描画が落ちる
  * (実測 = solidity の golden 4 件が `Cannot read properties of undefined`)。
  */
@@ -2072,16 +3006,505 @@ const KIND_ALIAS: Readonly<Record<string, string>> = {
   interface: "shape-code-block",
 };
 
+/**
+ * 記法の `values:` を図に載せる (#1162)。
+ *
+ * `values` は「他の値から自動で決まる値」 で、 時間を持たない。 参照した値が動けば常に
+ * 追随する。 解くのは描画側 (`@cardenelabs/cdl` の `applyDerivedValues`) で、 段の値を出した
+ * 後に参照順で解いて `stateValues` に載せる。 **毎 frame ここを通る**ので、 掛け算や比較の
+ * ように端点 2 点では表せない関係も段の補間の途中で正しい値になる。
+ *
+ * ここは載せるだけで、 式は評価しない。 評価を compile 時に畳むと段の補間中に決まり直せない。
+ *
+ * **出口で 1 度だけ載せる**。 図の種類は 18 あり、 経路ごとに書くとどれかを見落とす
+ * (`injectStaticPhase` と同じ理由)。
+ *
+ * 名前が `states` と重なった場合は `values` を優先し、 重なったことを伝える。 spec の
+ * 4 節で決めた挙動で、 黙って一方を捨てると「書いたのに効かない」 が残る。
+ */
+/** 数を式に埋める。 指数表記 (`1e-7`) は engine の式が読めないため十進で書く */
+function 式に書く数(n: number): string {
+  if (!Number.isFinite(n)) return "0";
+  const text = String(n);
+  if (!/[eE]/.test(text)) return text;
+
+  // Number の有効桁を丸めず、指数表記だけを通常の十進表記へ展開する。 `toFixed(6)` では
+  // 1e-7 が 0 になり、正しく読める `to` の値が動かなくなる。
+  const [coefficient = "0", exponentText = "0"] = text.toLowerCase().split("e");
+  const negative = coefficient.startsWith("-");
+  const unsigned = negative ? coefficient.slice(1) : coefficient;
+  const [whole = "0", fraction = ""] = unsigned.split(".");
+  const digits = `${whole}${fraction}`;
+  const decimalAt = whole.length + Number(exponentText);
+  let expanded: string;
+  if (decimalAt <= 0) expanded = `0.${"0".repeat(-decimalAt)}${digits}`;
+  else if (decimalAt >= digits.length) expanded = `${digits}${"0".repeat(decimalAt - digits.length)}`;
+  else expanded = `${digits.slice(0, decimalAt)}.${digits.slice(decimalAt)}`;
+  return negative ? `-${expanded}` : expanded;
+}
+
+/** 段の中で 1 本の値が動く区間。 `from` から `to` へ `[start, end]` の間で線形に動く */
+type 動く区間 = { 段: number; start: number; end: number; dur: number; from: number; to: number };
+
+/**
+ * 相手の値が境目を通る時刻を求める。
+ *
+ * 相手は段の中で線形に動くので、 境目を通る時刻は逆算できる。 始めから成り立っているなら
+ * 相手が動き始めた時刻、 終わりまで成り立たないなら「通らない」 とする。
+ *
+ * `>` と `!=` の厳密な瞬間は境目の直後だが、 1 frame 未満の差なので境目そのものを返す。
+ */
+function 境目を通る時刻(区間: 動く区間, op: string, 境目: number): number | null {
+  const 満たす = (x: number): boolean => {
+    switch (op) {
+      case ">=": return x >= 境目;
+      case ">": return x > 境目;
+      case "<=": return x <= 境目;
+      case "<": return x < 境目;
+      case "==": return x === 境目;
+      case "!=": return x !== 境目;
+      default: return false;
+    }
+  };
+  if (満たす(区間.from)) return 区間.start;
+  // `==` は終点が一致しなくても、線形補間の途中で境目を通る。 終点だけを見ると
+  // 0 → 100 に対する `== 50` を「満たさない」と誤判定する。
+  if (op === "==") {
+    const min = Math.min(区間.from, 区間.to);
+    const max = Math.max(区間.from, 区間.to);
+    if (境目 < min || 境目 > max) return null;
+  } else if (!満たす(区間.to)) {
+    return null;
+  }
+  if (区間.to === 区間.from) return null;
+  const t = 区間.start + (区間.dur * (境目 - 区間.from)) / (区間.to - 区間.from);
+  if (!Number.isFinite(t)) return null;
+  return Math.min(Math.max(t, 区間.start), 区間.end);
+}
+
+/**
+ * きっかけ形の値 (`trigger` / `to` / `dur`) を、段の時計を読む式へ畳む (#1161 段 2)。
+ *
+ * ## なぜ式へ畳むのか
+ *
+ * 描画側の動きの模型は段と、 段の中の線形補間しか持たない。 条件で動き出す仕組みも、 値ごとの
+ * 長さも無い (実測)。 そのままでは `trigger` も `dur` も渡せない。
+ *
+ * 一方で描画側は `derived` の式を **毎 frame** 解く。 そこで段に時計を 1 本引き
+ * (`0` から段の長さまでの補間)、 各値を「時計を読む傾斜」 として書けば、 段を割らずに
+ * 値ごとの長さを守れる。
+ *
+ * ```
+ * 値 = from + (to - from) * min(max((時計 - 開始) / 長さ, 0), 1)
+ * ```
+ *
+ * `min` / `max` で挟むのは、 開始前は `from` のまま、 終了後は `to` のまま止めるため。
+ *
+ * ## 段を割らない
+ *
+ * 段は見出し / 本文 / 印を持つ表示物なので、 割ると段送りの見え方と件数が変わる。 時計を使えば
+ * 段は 1 つのまま値だけが順に動く。 収まらない形 (開始 + 長さ > 段の長さ) は畳まずに知らせる。
+ *
+ * ## 連鎖の解き方
+ *
+ * `trigger: <相手> >= <境目>` は、 相手も段の中で線形に動くため境目を通る時刻を逆算できる。
+ * 相手が動く値でない (式だけ、 または初期値のまま) 場合は時刻が決まらないので畳まない。
+ *
+ * 返すのは名前から式への表で、 `attachDerivedValues` がこれを `derived` に載せる。 畳めなかった
+ * 値は表に入らないため図に載らない = 半端に止まった値を黙って置かない。
+ */
+function foldValueTriggers(
+  diagram: CdlDiagram,
+  doc: DslDocument,
+  onNotice?: (n: CompileNotice) => void,
+): Map<string, string> {
+  const 出力 = new Map<string, string>();
+  const きっかけ付き = (doc.values ?? []).filter((v) => v.trigger !== undefined);
+  if (きっかけ付き.length === 0) return 出力;
+
+  // 同じ名前を 2 度書いた時は先に書いた方を使う (`values` の既存の扱いと揃える)
+  const 宣言 = new Map<string, DslValue>();
+  for (const v of きっかけ付き) if (!宣言.has(v.name)) 宣言.set(v.name, v);
+
+  const 初期値 = new Map<string, number>();
+  for (const s of diagram.states) {
+    const n = Number(s.initial);
+    if (Number.isFinite(n)) 初期値.set(s.id, n);
+  }
+
+  // 段は書いた名前でも slug でも指せる。 `focus:` が名前で指せるのと揃える
+  const 段の番号 = new Map<string, number>();
+  diagram.phases.forEach((p, i) => {
+    if (!段の番号.has(p.title)) 段の番号.set(p.title, i);
+    if (!段の番号.has(p.id)) 段の番号.set(p.id, i);
+  });
+
+  const 解けた = new Map<string, 動く区間>();
+  const 解けない = new Set<string>();
+  const 解決中 = new Set<string>();
+
+  const 知らせる = (v: DslValue, message: string, hint: string): void => {
+    onNotice?.({ kind: "value-trigger-unresolved", actor: v.name, line: v.pos?.line ?? 0, message, hint });
+  };
+
+  const 解く = (name: string): 動く区間 | null => {
+    const 既出 = 解けた.get(name);
+    if (既出) return 既出;
+    if (解けない.has(name)) return null;
+    const v = 宣言.get(name);
+    if (!v || !v.trigger) return null;
+    if (解決中.has(name)) {
+      解けない.add(name);
+      知らせる(v, `"${name}" のきっかけが一周しています`, "どれか 1 つを `trigger: step ...` に変える");
+      return null;
+    }
+    解決中.add(name);
+    const 区間 = 組み立てる(v);
+    解決中.delete(name);
+    if (!区間) {
+      解けない.add(name);
+      return null;
+    }
+    解けた.set(name, 区間);
+    return 区間;
+  };
+
+  const 組み立てる = (v: DslValue): 動く区間 | null => {
+    const trigger = v.trigger!;
+    const from = 初期値.get(v.name) ?? 0;
+    const to = v.to ?? 0;
+    const dur = v.durationMs ?? 0;
+    let 段 = 0;
+    let start = 0;
+    if (trigger.kind === "step") {
+      const idx = 段の番号.get(trigger.step);
+      if (idx === undefined) {
+        知らせる(v, `"${trigger.step}" という段がありません`, "`animation:` にその名前の段を書くか、 段の名前に合わせる");
+        return null;
+      }
+      段 = idx;
+      start = 0;
+    } else {
+      const 相手 = 解く(trigger.source);
+      if (!相手) {
+        知らせる(
+          v,
+          `"${trigger.source}" が動く値でないため、 きっかけの時刻を決められません`,
+          "見張る相手も `trigger:` を持つ値にする",
+        );
+        return null;
+      }
+      const at = 境目を通る時刻(相手, trigger.op, trigger.threshold);
+      if (at === null) {
+        知らせる(
+          v,
+          `"${trigger.source}" は ${trigger.op} ${trigger.threshold} を満たしません`,
+          "相手が通る値を境目にするか、 相手の `to` を見直す",
+        );
+        return null;
+      }
+      段 = 相手.段;
+      start = at;
+    }
+    const 段の長さ = diagram.phases[段]?.duration ?? 0;
+    if (start + dur > 段の長さ) {
+      知らせる(
+        v,
+        `段 "${diagram.phases[段]?.title ?? ""}" (${段の長さ}ms) に収まりません (${Math.round(start + dur)}ms 必要)`,
+        "段を長くするか `dur` を短くする",
+      );
+      return null;
+    }
+    return { 段, start, end: start + dur, dur, from, to };
+  };
+
+  for (const v of 宣言.values()) 解く(v.name);
+  if (解けた.size === 0) return 出力;
+
+  // 時計は段ごとに 1 本。 名前が既にある時は末尾に数を足してずらす = 書いた値を上書きしない
+  const 使用中 = new Set(diagram.states.map((s) => s.id));
+  for (const v of doc.values ?? []) 使用中.add(v.name);
+  const 段ごとの時計 = new Map<number, string>();
+  const 時計を用意する = (段: number): string => {
+    const 既出 = 段ごとの時計.get(段);
+    if (既出) return 既出;
+    let 名前 = `__step_clock_${段}`;
+    let 連番 = 2;
+    while (使用中.has(名前)) 名前 = `__step_clock_${段}_${連番++}`;
+    使用中.add(名前);
+    段ごとの時計.set(段, 名前);
+    diagram.states.push({ id: 名前, initial: 0 });
+    const 段の中身 = diagram.phases[段];
+    if (段の中身) 段の中身.tweens = [...段の中身.tweens, { stateId: 名前, from: 0, to: 段の中身.duration }];
+    return 名前;
+  };
+
+  for (const [name, 区間] of 解けた) {
+    const 時計 = 時計を用意する(区間.段);
+    const 進み = `min(max(({${時計}} - ${式に書く数(区間.start)}) / ${式に書く数(区間.dur)}, 0), 1)`;
+    出力.set(name, `((${進み} * ${式に書く数(区間.to - 区間.from)}) + ${式に書く数(区間.from)})`);
+  }
+  return 出力;
+}
+
+function attachDerivedValues(
+  diagram: CdlDiagram,
+  doc: DslDocument,
+  onNotice?: (n: CompileNotice) => void,
+  inheritedSourceLines?: ReadonlyMap<string, readonly number[]>,
+  foldedTriggers?: ReadonlyMap<string, string>,
+): void {
+  const values = doc.values ?? [];
+  // 本文に値を書いていなくても、重ねた見本が値を持つことがある (#1180)。 その場合も
+  // 解けなかった分は伝える = 見本の中で止まった値も、画面には `{名前}` の生の形で出る
+  if (values.length === 0) {
+    if ((diagram.derived?.length ?? 0) > 0) {
+      reportUnresolvedValues(diagram, doc, onNotice, inheritedSourceLines);
+    }
+    return;
+  }
+
+  // 名前が重なったかは **図に載った状態** で見る。 書いた `states:` だけを見ると、見本から
+  // 引き継いだ状態 (`alias__id`) との重なりを見落とす
+  const 状態の名前 = new Set(diagram.states.map((s) => s.id));
+  for (const v of values) {
+    if (!状態の名前.has(v.name)) continue;
+    // きっかけ形は `states:` の値を **動き始めの値として使う**。 両方書くのが正しい形なので
+    // 重なりとして知らせない (#1161)。 知らせると、 仕様どおりに書いた図が毎回警告を出す
+    if (v.trigger !== undefined) continue;
+    onNotice?.({
+      kind: "value-shadows-state",
+      actor: v.name,
+      line: v.pos?.line ?? 0,
+      message: `"${v.name}" を states と values の両方に書いています。 values を使います`,
+      hint: "states から外すか、 values の名前を変える",
+    });
+  }
+
+  // **見本から引き継いだ分に足す** (#1180)。 代入で書くと、重ねた見本が持つ値が消える。
+  //
+  // 本文に書いた分を先に置く = engine は同じ名前では先に書いた式を使うため、名前が重なった
+  // 時に本文が勝つ。 重なったことは engine の知らせ (`duplicate-id`) がそのまま伝える
+  // きっかけ形は `foldValueTriggers` が畳んだ式を使う。 畳めなかった値はここに現れないため
+  // 図に載らない = 半端に止まった値を黙って置かない (知らせは畳む時点で出している)
+  const 載せる: Array<{ id: string; expression: string }> = [];
+  for (const v of values) {
+    const expression = v.expression ?? foldedTriggers?.get(v.name);
+    if (expression === undefined) continue;
+    載せる.push({ id: v.name, expression });
+  }
+  diagram.derived = [...載せる, ...(diagram.derived ?? [])];
+  reportUnresolvedValues(diagram, doc, onNotice, inheritedSourceLines);
+}
+
+/**
+ * 式の中の名前を付け替える (#1180)。
+ *
+ * **字句ではなく木を経由する**。 engine の式は `{v}` / 裸の `v` / 数字始まり / `$` 入りと
+ * 参照の書き方が複数あり、正規表現で追うと書き方が 1 つ増えるたびに漏れる (review が 3 round
+ * 続けて別の漏れを見つけた)。 木は識別子をそのまま持つので、字句を網羅しなくてよい。
+ *
+ * 関数呼び出し (`min` / `Math.max`) は木の上で別の種類なので、名前と取り違えない。
+ */
+function renameFormulaIdentifiers(ast: FormulaAst, rename: (name: string) => string): FormulaAst {
+  switch (ast.type) {
+    case "number":
+      return ast;
+    case "identifier":
+      return { type: "identifier", name: rename(ast.name) };
+    case "unaryOp":
+      return { ...ast, operand: renameFormulaIdentifiers(ast.operand, rename) };
+    case "binaryOp":
+      return {
+        ...ast,
+        left: renameFormulaIdentifiers(ast.left, rename),
+        right: renameFormulaIdentifiers(ast.right, rename),
+      };
+    case "ternary":
+      return {
+        type: "ternary",
+        condition: renameFormulaIdentifiers(ast.condition, rename),
+        whenTrue: renameFormulaIdentifiers(ast.whenTrue, rename),
+        whenFalse: renameFormulaIdentifiers(ast.whenFalse, rename),
+      };
+    case "call":
+      return { ...ast, args: ast.args.map((a) => renameFormulaIdentifiers(a, rename)) };
+  }
+}
+
+/**
+ * 数を、engine の読み手が受け付ける形で書く (#1180)。
+ *
+ * **指数表記を出さない**。 `0.0000001` は JavaScript の既定では `"1e-7"` になるが、engine の
+ * 読み手は指数表記を読めない (実測 = `unexpected token after expression`)。 そのまま書くと、
+ * 元は解けていた式が書き換えた後だけ止まる。
+ *
+ * 展開は桁をずらすだけで、丸めない。 `String` が返す最短の形をそのまま使うため、値は変わらない。
+ * 有限でない数は書けないので投げる (呼出側が元の式のまま載せる)。
+ */
+function writeNumber(value: number): string {
+  if (!Number.isFinite(value)) throw new Error(`cannot write non-finite number: ${String(value)}`);
+  const s = String(value);
+  if (!/[eE]/.test(s)) return s;
+  const m = /^(-?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(s);
+  if (!m) throw new Error(`cannot write number: ${s}`);
+  const sign = m[1] ?? "";
+  const int = m[2] ?? "";
+  const frac = m[3] ?? "";
+  const digits = int + frac;
+  // 小数点の位置。 元の整数部の桁数を指数のぶんだけずらす
+  const point = int.length + Number(m[4] ?? "0");
+  if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`;
+  if (point >= digits.length) return `${sign}${digits}${"0".repeat(point - digits.length)}`;
+  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
+
+/**
+ * 式の木を文字列へ戻す (#1180)。
+ *
+ * **括弧を全て付ける**。 演算子の優先順位を再現しようとすると engine の表を写すことになり、
+ * 表がずれた時に式の意味が静かに変わる。 括弧が増えても解いた結果は変わらない。
+ */
+function writeFormula(ast: FormulaAst): string {
+  switch (ast.type) {
+    case "number":
+      return writeNumber(ast.value);
+    case "identifier":
+      // **裸で書ける形とそうでない形がある**。 engine は裸の名前を `[A-Za-z_$][\w$]*` で読む
+      // 一方、波括弧の中は `\w+` なので数字始まりの名前は波括弧付きでしか書けない。
+      // 名前は前置きで変わる (`1p__v` のように数字始まりになりうる) ため、書ける方を選ぶ
+      return /^[A-Za-z_$][\w$]*$/.test(ast.name) ? ast.name : `{${ast.name}}`;
+    case "unaryOp":
+      // 空白は挟まない。 読み手は負の数を字面として持たず (`-5` は単項 `-` と `5` の木になる)、
+      // `--5` も単項の 2 段として読む (実測)。 挟んでも挟まなくても意味が同じなので足さない
+      return `(${ast.op}${writeFormula(ast.operand)})`;
+    case "binaryOp":
+      return `(${writeFormula(ast.left)} ${ast.op} ${writeFormula(ast.right)})`;
+    case "ternary":
+      return `(${writeFormula(ast.condition)} ? ${writeFormula(ast.whenTrue)} : ${writeFormula(ast.whenFalse)})`;
+    case "call":
+      return `${ast.fn}(${ast.args.map(writeFormula).join(", ")})`;
+  }
+}
+
+/** `derived` の同名宣言を、engine が読む順のまま行番号の列として残す。 */
+function recordDerivedSourceLine(
+  sourceLines: Map<string, number[]> | undefined,
+  id: string,
+  line: number,
+): void {
+  if (!sourceLines) return;
+  const lines = sourceLines.get(id) ?? [];
+  lines.push(line);
+  sourceLines.set(id, lines);
+}
+
+/**
+ * 解けなかった値を書いた人に伝える (#1162)。
+ *
+ * 描画側は解けない値を黙って飛ばす (`computeStateValues` が engine の知らせを捨てている)。
+ * 書き間違えても図は描かれ、箱に `{waiting}` の生の形が出るだけになる。 綴りを疑う以外に
+ * 手掛かりが無いので、組み立ての時点で分かる分をここで伝える。
+ *
+ * **判定は engine にさせる**。 解く順序と、止める条件 (輪 / 無い名前 / 読めない式 / 数として
+ * 読めない値) は engine が持つ。 同じ判定を書き直すと、描画は動くのに知らせだけ出る
+ * (またはその逆) 状態を作る。
+ *
+ * 見るのは初期値 1 組だけ。 輪 / 無い名前 / 読めない式 / 二重宣言は値に依らないのでこれで
+ * 全て取れる。 段の途中でだけ起きる形 (割る数が段の途中で 0 になる等) は取れない =
+ * 毎 frame の知らせは engine 側が返し口を持たないため、ここでは扱わない。
+ */
+function reportUnresolvedValues(
+  diagram: CdlDiagram,
+  doc: DslDocument,
+  onNotice?: (n: CompileNotice) => void,
+  inheritedSourceLines?: ReadonlyMap<string, readonly number[]>,
+): void {
+  if (!onNotice) return;
+  // 描画側 (`computeStateValues`) が段を進める前に組み立てるのと同じ形。 値を解く手順は
+  // engine に渡すので、ここで組み立てるのは初期値の表だけにする
+  //
+  // **継承を持たない入れ物で作る**。 engine 側 (`computeStateValues` /
+  // `applyDerivedValues`) が同じ形で組むため、ここを通常の object にすると
+  // `__proto__` のような名前で **組み立てだけが「値が無い」 と知らせる** 状態ができる
+  // (実測 = 描画は `a = 5` を出すのに、知らせは `value-unresolved` を出していた)。
+  //
+  // engine が `{}` で組んでいた頃はここも `{}` で揃えていた。 cdl 側が継承なしに
+  // 揃えた (cdl#456 / cdl#490) ので、こちらも合わせる。 **揃っていることが要点**で、
+  // どちらの形にするかは engine が決める
+  const 初期値: Record<string, string> = Object.create(null) as Record<string, string>;
+  for (const s of diagram.states) 初期値[s.id] = String(s.initial);
+
+  // engine は同じ名前では先に書いた式を使う。 Map の一括生成で後ろから
+  // 上書きすると、先の式の未解決を後の行の問題として伝えてしまう
+  const 最初の行 = new Map<string, number>();
+  const 重複した行 = new Map<string, number[]>();
+  for (const v of doc.values ?? []) {
+    if (!最初の行.has(v.name)) {
+      最初の行.set(v.name, v.pos?.line ?? 0);
+      continue;
+    }
+    const 同じ名前の行 = 重複した行.get(v.name) ?? [];
+    同じ名前の行.push(v.pos?.line ?? 0);
+    重複した行.set(v.name, 同じ名前の行);
+  }
+  // 本文の値は `attachDerivedValues` が先頭へ置き、見本から引き継いだ値はその後ろに残る。
+  // 同じ順で行を足すことで、duplicate-id を「後から書かれた宣言」へ正確に戻す。
+  for (const [id, lines] of inheritedSourceLines ?? []) {
+    for (const line of lines) {
+      if (!最初の行.has(id)) {
+        最初の行.set(id, line);
+        continue;
+      }
+      const 同じ名前の行 = 重複した行.get(id) ?? [];
+      同じ名前の行.push(line);
+      重複した行.set(id, 同じ名前の行);
+    }
+  }
+  for (const n of applyDerivedValues(初期値, diagram.derived).notices) {
+    onNotice({
+      kind: n.kind === "duplicate-id" ? "value-duplicate" : "value-unresolved",
+      actor: n.id,
+      // 重複は後から書いた宣言そのものを、式の問題は engine が使う最初の宣言を指す
+      line:
+        n.kind === "duplicate-id"
+          ? (重複した行.get(n.id)?.shift() ?? 最初の行.get(n.id) ?? 0)
+          : (最初の行.get(n.id) ?? 0),
+      message: n.message,
+      hint: VALUE_NOTICE_HINT[n.kind],
+    });
+  }
+}
+
+/** 止まった理由ごとの直し方。 engine の知らせは何が起きたかまでで、直し方は記法側が持つ */
+const VALUE_NOTICE_HINT: Readonly<Record<string, string>> = {
+  cycle: "参照が一周しています。 どれか 1 つを states の初期値に変える",
+  "unknown-reference": "その名前の states / values を足すか、綴りを直す",
+  "parse-error": "式に書けるのは四則 (+ - * /) と括弧、比較、min / max だけ",
+  "eval-error": "初期値で計算できない形です。 割る数や、数として読めない初期値を見直す",
+  "duplicate-id": "同じ名前が 2 度あります。 片方を消すか名前を変える",
+  "invalid-id": "名前に使えるのは英数字と _ だけ",
+};
+
 /**
  * 図全体を 1 つの箱で描く種別。
  *
  * これらは中身 (扇 / 帯 / 枝) を payload で受け取り、 1 node で図全体を描く。 登場人物ごとの箱を
  * 持たないので、 段の `focus:` で名前を指しても引く先が無い。 `injectPhasesFallback` が
  * この一覧を使って「実在する名前ならその箱を光らせる」 に読み替える (#1076 / #1077)。
+ *
+ * `mind-map` は一時期 **記法から到達しなかった** (`#1174`)。 この種別を作っていたのは
+ * `compileRadial` だけで `#1170` で消え、 記法の `type: mind` は `card` を 3 列に並べる
+ * 別実装だった。
+ *
+ * それでも一覧に残すのは、 ここが「1 箱で図全体を描く種別」 という **性質の一覧** だから。
+ * `mind-map` は engine 側でその性質を持ち続けており、 記法が到達しないのは当時の
+ * `compileMind` の実装によるものだった。 `#1177` で `compileMind` を `mind-map` に寄せたため、
+ * **今は記法からも到達する** (一覧へ戻す作業が要らなかったのはこのため)。
  */
 const SINGLE_BOX_KINDS: ReadonlySet<string> = new Set([
   "chart-pie", "chart-line", "chart-bar",
-  "gantt-timeline", "mind-map", "mind-radial",
+  "gantt-timeline", "mind-map",
   "funnel-stages", "quadrant-matrix", "tree-hierarchy", "journey-map",
 ]);
 
@@ -2331,19 +3754,6 @@ function dropUnfittableEndKinds(diagram: CdlDiagram, doc: DslDocument): void {
  * 対応が取れない edge には何も入れない (呼出側が「対応が無い」 と「行 0」 を区別できるように
  * するため、 #998)。
  */
-function fillFlowEdgeSources(diagram: CdlDiagram, doc: DslDocument, sourceLines: Map<string, number>): void {
-  if (doc.type !== "flow") return;
-  // animation ありは別経路 (`compileGenericWithAnimate`) で、 鎖の規則が当てはまらない。
-  if (doc.animate && doc.animate.phases.length > 0) return;
-  diagram.edges.forEach((e, idx) => {
-    const to = doc.actors[idx + 1];
-    if (to === undefined) return;
-    const step = doc.flow.find((s) => s.to === to.name);
-    if (step === undefined) return;
-    sourceLines.set(e.id, step.pos.line);
-  });
-}
-
 /**
  * v0.5+ groups section を topology preset 経由の diagram に container lane として反映。
  * group.lanes に含まれる lane id 集合に対し、 wrap する `group-{id}` lane を contain: true で生成。
@@ -2422,16 +3832,106 @@ function compileSolidity(doc: DslDocument): CdlDiagram {
  *
  * flow は依存関係を edge で表現 (横棒間の矢印)。
  */
+/**
+ * `{名前}` が指す状態が取りうる値を、記法に書かれた範囲で集める (#1251)。
+ *
+ * 初期値と、段が動かす先 (`tween:` の両端と `set:` の値) を見る。 数として読めない値は
+ * 落とす = 位置として使われないため、下限の判定には関係しない。
+ */
+function 状態が取る値(参照: string, doc: DslDocument): number[] {
+  const 名 = 参照.slice(1, -1);
+  const out: number[] = [];
+  const 数にする = (v: unknown): void => {
+    if (typeof v === "number") {
+      if (Number.isFinite(v)) out.push(v);
+      return;
+    }
+    // **空文字と空白だけの値を数にしない**。 `Number("")` は 0 を返すため、そのままだと
+    // 位置 0 として扱われ、始まりが 1 以降の帯に誤った知らせが出る。 描画側はこの値を
+    // 解けず始まりへ倒すので、警告する相手ではない
+    const 文字 = String(v).trim();
+    if (文字 === "") return;
+    const n = Number(文字);
+    if (Number.isFinite(n)) out.push(n);
+  };
+  for (const st of doc.animate?.states ?? []) if (st.name === 名) 数にする(st.initial);
+  for (const p of doc.animate?.phases ?? []) {
+    for (const t of p.tweens ?? []) {
+      if (t.state !== 名) continue;
+      数にする(t.from);
+      数にする(t.to);
+    }
+    for (const v of p.sets ?? []) if (v.state === 名) 数にする(v.value);
+  }
+  return out;
+}
+
+/**
+ * 工程が終わる位置を決める (#1251)。
+ *
+ * 書かなければ始まりと同じ = 帯が 1 コマ (従来の挙動)。
+ *
+ * `{名前}` を書いたらそのまま渡す。 描画側が状態を解いて位置に直すため、段で帯が伸び縮みする。
+ * その場合 **時期の名前は始まりのものを使う** = 状態が指すのは位置であって時期の名前ではなく、
+ * 帯の端に出す字が段ごとに変わるわけではない。
+ *
+ * 時期の名前を書いたら、その名前の位置に終わる。 書いた名前が目盛りに無い形は始まりと同じに
+ * 倒す = 目盛りは書かれた順に作るため、載っていない名前は位置を持たない。
+ */
+function 終わる位置(
+  end: string | undefined,
+  始まり: number,
+  目盛り: readonly string[],
+  名前: string,
+  伝える: (名: string, message: string) => void,
+  doc: DslDocument,
+): { idx: number | string; label?: string } {
+  if (end === undefined) return { idx: 始まり };
+  if (/^\{\w+\}$/.test(end)) {
+    // **状態が取る値は記法に全部書いてある**。 初期値と、段が動かす先 (`tween:` の両端と
+    // `set:` の値) を集めれば、始まりより前に落ちる値をここで見つけられる。
+    //
+    // 覆えないのは `values:` の式から決まる値だけ = 他の状態から計算されるため、
+    // 段ごとの結果を組み立ての時点では出せない
+    const 低い = 状態が取る値(end, doc).filter((v) => v < 始まり);
+    if (低い.length > 0) {
+      伝える(
+        名前,
+        `type: gantt で ${truncateForMessage(名前)} の終わり (${truncateForMessage(end)}) が始まりより前になる値を取ります (${[...new Set(低い)].join(", ")})。 始まりは ${始まり} 番目です`,
+      );
+    }
+    return { idx: end };
+  }
+  const i = 目盛り.indexOf(end);
+  if (i < 0) return { idx: 始まり };
+  // 始まりより前に終わる帯は描けない。 そのまま渡すと横幅が負になり、帯が始まりの位置から
+  // 左へはみ出す。 始まりと同じに倒して伝える (黙って倒すと「書いたのに 1 コマのまま」 になる)
+  if (i < 始まり) {
+    伝える(
+      名前,
+      `type: gantt で ${truncateForMessage(名前)} の終わり (${truncateForMessage(end)}) が始まりより前です (始まりと同じに倒しました)`,
+    );
+    return { idx: 始まり };
+  }
+  return { idx: i, label: end };
+}
+
 function compileGantt(doc: DslDocument): CdlDiagram {
   const b = diagram(slugify(doc.title), { topic: doc.title });
   const CHART_W = 720;
-  b.lane("gantt", { width: CHART_W, label: doc.title });
+  b.lane("gantt", { width: CHART_W });
 
   // 目盛りは **書かれた順** に並べる。 以前は `Q1=200 / Q2=600 / ...` の決め打ちで、 Q1-Q4 以外は
   // 全て同じ位置に落ちていた。 順に並べれば月名でも週番号でも同じ規則で置ける
   const 目盛り: string[] = [];
   const 目盛りなし: string[] = [];
-  const タスク: { name: string; label: string; tone?: DslDocument["actors"][number]["tone"] }[] = [];
+  const タスク: {
+    name: string;
+    label: string;
+    tone?: DslDocument["actors"][number]["tone"];
+    owner?: string;
+    end?: string;
+  }[] = [];
   for (const a of doc.actors) {
     const label = (a.value ?? a.subtitle ?? "").trim();
     if (label === "") {
@@ -2440,7 +3940,13 @@ function compileGantt(doc: DslDocument): CdlDiagram {
     }
     if (!目盛り.includes(label)) 目盛り.push(label);
     // 色は帯にそのまま渡す。 箱が 1 つになっても、 書いた色が消えないようにする
-    タスク.push({ name: a.name, label, ...(a.tone !== undefined ? { tone: a.tone } : {}) });
+    タスク.push({
+      name: a.name,
+      label,
+      ...(a.tone !== undefined ? { tone: a.tone } : {}),
+      ...(a.owner !== undefined ? { owner: a.owner } : {}),
+      ...(a.end !== undefined ? { end: a.end } : {}),
+    });
   }
   if (目盛りなし.length > 0 && typeof console !== "undefined" && console.warn) {
     console.warn(
@@ -2477,6 +3983,12 @@ function compileGantt(doc: DslDocument): CdlDiagram {
     );
   }
 
+  // 帯の向きの誤りは `console.warn` に出す。 この図種の他の知らせ (時期なし / 依存が結べない /
+  // 矢印の飾り) が同じ経路を使っており、揃えないとどれが出るかが書き方で変わる
+  const 逆向きを伝える = (_名: string, message: string): void => {
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${message}`);
+  };
+
   // 高さは件数から決める。 描画側は 1 行 28 以上 + 行間 20 で積み、 上下に 32 / 44 の余白を取る
   // (`kinds/gantt.tsx`)。 360 の固定だと 8 件目から最後の帯が枠の外に出る (実測 = 8 件で 56 はみ出す)
   const CHART_H = Math.max(360, 48 * タスク.length + 96);
@@ -2486,152 +3998,807 @@ function compileGantt(doc: DslDocument): CdlDiagram {
     stack: 0,
     kind: "gantt-timeline",
     title: doc.title,
+    ...図の小見出し(doc),
     w: CHART_W,
     h: CHART_H,
     ganttData: タスク.map((t) => {
       const idx = 目盛り.indexOf(t.label);
       const from = 依存元.get(t.name);
+      const 終わり = 終わる位置(t.end, idx, 目盛り, t.name, 逆向きを伝える, doc);
       return {
         id: slugify(t.name) || t.name,
         title: t.name,
         startIdx: idx,
-        endIdx: idx,
+        endIdx: 終わり.idx,
         startLabel: t.label,
-        endLabel: t.label,
+        endLabel: 終わり.label ?? t.label,
+        ...(t.owner !== undefined ? { owner: t.owner } : {}),
         ...(from !== undefined ? { dependsOn: slugify(from) || from } : {}),
         ...(t.tone !== undefined ? { tone: t.tone } : {}),
       };
     }),
   });
-
+
+  return b.build();
+}
+
+/**
+ * クラス図の組み立て。
+ *
+ * 各クラスを 1 つの箱 (`storage`) にする。 描画側は題 (クラス名) と区切り線と行
+ * (項目 / 手続き) を UML のクラス箱として描く。
+ *
+ * **クラスごとに縦列を 1 本作り、横に並べる** (#1263)。 組立て API 側がそう並べており、
+ * 1 本にまとめると同じ内容でも横並びが縦並びになる (実測 = 見本は 3 縦列 450 幅)。
+ * 縦列に見出しは付けない = クラスの名前は箱が既に描いており、縦列は並べるための入れ物
+ * (`er` / `state` と同じ扱い、#1241)。
+ *
+ * 箱の種類は `storage` に強制する。 行と小見出しは `applyV05Extensions` が後から載せる。
+ *
+ * 矢印は継承や保有を表す (`extends` / `aggregates` 等を書き手が説明に書く)。
+ */
+function compileClass(doc: DslDocument): CdlDiagram {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const CLASS_W = 400;
+  // 縦列の幅は箱より広く取る。 組立て API 側の値に揃える (#1263)
+  const CLASS_LANE_W = 450;
+  // 登場人物が 0 人なら枠も作らない。 先に作ると中身の無い枠が 1 つ残る (#1096)
+  if (doc.actors.length === 0) return b.build();
+
+  // **クラスごとに縦列を 1 本作る** (#1263)。 組立て API 側がそう並べており、1 本にまとめると
+  // 同じ内容でも横並びが縦並びになる (実測 = 見本は 3 縦列 450 幅、記法は 1 縦列に縦積み)。
+  //
+  // 縦列に見出しは付けない。 クラスの名前は箱が既に描いており、縦列は並べるための入れ物
+  // (`er` / `state` と同じ扱い、#1241)
+  doc.actors.forEach((a, idx) => {
+    const nodeId = slugify(a.name) || `c${idx}`;
+    const laneId = `lane-${nodeId}`;
+    b.lane(laneId, { width: CLASS_LANE_W });
+    b.node(nodeId, {
+      lane: laneId,
+      stack: 0,
+      kind: "storage",
+      title: a.name,
+      w: CLASS_W,
+    });
+  });
+
+  for (const s of doc.flow) {
+    const fromId = slugify(s.from);
+    const toId = slugify(s.to);
+    b.edge(fromId, toId, {
+      label: s.label,
+      ...(s.sub ? { sub: s.sub } : {}),
+      ...(s.tone ? { tone: s.tone } : {}),
+      ...(s.style ? { style: s.style } : {}),
+    });
+  }
+
+  return b.build();
+}
+
+/**
+ * Pie preset (円グラフ風 slice list 専用 layout)
+ *
+ * 設計 ... 円グラフの SVG arc 描画は engine 改修が大きいため、 簡易版として「slice list + value (%) 表示」
+ * で代替する。 1 lane に slice を縦並びにし、 value 属性 (例 "30%") は applyV05Extensions が
+ * node.value に merge することで「[Slice A] 30%」 「[Slice B] 25%」 のような pie chart 意図を伝える。
+ *
+ * 実装 ... 全 slice を 1 lane に縦 stack。 kind: card 強制、 w=480 h=120。
+ *
+ * flow は通常なし (slice 間に依存関係はない)、 author 明示時のみ edge を描く。
+ */
+/**
+ * 割合の書き方から数値を読む。 読めなければ `null`。
+ *
+ * 受けるのは `"45%"` / `"45"` / `"45.5%"` と、 前後の空白。 `"四割"` や `"0.45"` のような
+ * 別の言い方は読まない = **黙って 0 にすると、 その分だけ欠けた円が「正しい図」 として出る**。
+ * 読めなかったことは呼出側が警告に出す。
+ */
+function parseShareValue(raw: string | undefined): number | null {
+  if (raw === undefined) return null;
+  const m = raw.trim().match(/^(-?\d+(?:\.\d+)?)\s*%?$/);
+  if (m === null) return null;
+  const v = Number(m[1]);
+  return Number.isFinite(v) ? v : null;
+}
+
+/**
+ * 状態を読む欄かどうか (`{名前}`)。
+ *
+ * **`{名前}` そのものだけを受ける**。 `{v} 件` のような混ざった形は、描画側が数として
+ * 読めず既定値に落ちて印が付くだけになる (`render/payload-binding.ts` は解いた文字列を
+ * そのまま数にする)。 書けたのに効かない形を作らない。
+ *
+ * `%` を付けた形も受けない。 同じ理由で `"45%"` は数に直せるが `"{v}%"` は直せない。
+ *
+ * 名前に使えるのは英数字と `_` で、読む側 (cdl の `interpolate`) と同じ範囲に合わせる。
+ * 決まった accessor (`.sum` 等) は付けてよい。
+ */
+function parseBoundValue(raw: string | undefined): string | null {
+  if (raw === undefined) return null;
+  const t = raw.trim();
+  return /^\{\w+(?:\.(?:length|sum|max|min|avg)|\[\d+\])?\}$/.test(t) ? t : null;
+}
+
+/**
+ * 図表の数の欄を読む。 数そのものか、状態を読む `{名前}` を返す。
+ *
+ * 数として解けない `{名前}` は、そのまま図表の中身に渡して描画側が段ごとに解く。
+ * 受け取る側の型 (`BoundNumber`) は元から 2 通りを想定している = 入口だけが塞がっていた。
+ */
+function parseChartValue(raw: string | undefined): number | string | null {
+  const n = parseShareValue(raw);
+  if (n !== null) return n;
+  return parseBoundValue(raw);
+}
+
+
+/** 状態を読む欄が指している名前 (`{v.sum}` なら `v`)。 欄でなければ null */
+function 参照する名前(value: number | string | null): string | null {
+  if (typeof value !== "string") return null;
+  const m = value.match(/^\{(\w+)/);
+  return m ? m[1]! : null;
+}
+
+/**
+ * 棒 / 折れ線の組立て。 円グラフと **入力の形が同じ**なので 1 つにまとめる。
+ *
+ * 3 種とも `- 名前: "45"` の 1 行 1 値で書く。 違うのは描画側の種別と、 値の意味だけ。
+ *
+ * | 型 | 種別 | 値の意味 |
+ * |---|---|---|
+ * | `pie` | `chart-pie` | 全体に対する取り分 |
+ * | `bar` | `chart-bar` | 棒の高さ (単位は問わない) |
+ * | `line` | `chart-line` | 線の高さ。 **書いた順に並ぶ** |
+ *
+ * 値を読めない項目は載せず、 まとめて警告に出す。 **黙って 0 にしない** = その項目だけ欠けた
+ * 図が「正しい図」 として出てしまうため。
+ *
+ * 矢印は描けない。 書かれていたら警告に出して捨てる (「書いたのに効かない」 を残さない)。
+ */
+function compileValueChart(
+  doc: DslDocument,
+  型: "pie" | "bar" | "line",
+  kind: "chart-pie" | "chart-bar" | "chart-line",
+  onNotice?: (notice: CompileNotice) => void,
+): CdlDiagram {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const CHART_W = 640;
+  // **高さは型で違い、 格子に載せる**。 描画側 (`cdl` の `chart()` preset) は `pie` を 320、
+  // 棒と折れ線を 360 とした上で **16 の倍数へ切り上げる** (360 は 16 で割り切れないので 368)。
+  // 切り上げないと下端が格子から外れ、 全図で位置の警告が出る (review 指摘)
+  const CHART_H = 型 === "pie" ? 320 : 368;
+  b.lane("chart", { width: CHART_W + 64 });
+
+  const data: NonNullable<CdlDiagram["nodes"][number]["chartData"]> = [];
+  const 読めない: string[] = [];
+  const 未宣言: string[] = [];
+  let 未宣言行 = 0;
+  const 参照できる = 数の欄から参照できる名前(doc);
+  // 最初に読めなかった行を覚える。 画面が案内できるようにする
+  let 読めない行 = 0;
+  for (const a of doc.actors) {
+    // 値の置き場所は記法で 2 通りある。 略記 (`- TypeScript: "45%"`) は説明文に、
+    // 縦書きの map (`- SliceA: { kind: card, value: "30%" }`) は値に入る。 両方を読む
+    const value = parseChartValue(a.value ?? a.subtitle);
+    // **負を受けるのは折れ線だけ**。 増減を追う図なので気温や損益のように 0 を跨ぐ値が来る。
+    // 円は取り分、 棒は高さで、 どちらも負に意味が無い (review 指摘)。
+    // 状態を読む欄 (`{名前}`) は書いた時点で符号が決まらないため、この検査を通す
+    if (value === null || (typeof value === "number" && value < 0 && 型 !== "line")) {
+      // `pos` を持たない経路がある (JSON 経路で組み立てた actor)。 無ければ 0 のまま
+      if (読めない.length === 0) 読めない行 = a.pos?.line ?? 0;
+      読めない.push(a.name);
+      continue;
+    }
+    // 数にならない参照は落とす。 通すと図は出るのに数が入っていない状態になる
+    const 名前 = 参照する名前(value);
+    if (名前 !== null && !参照できる.has(名前)) {
+      if (未宣言.length === 0) 未宣言行 = a.pos?.line ?? 0;
+      未宣言.push(a.name);
+      continue;
+    }
+    // 色はそのまま渡す。 箱が 1 つになっても、 書いた色が消えないようにする
+    data.push({ label: a.name, value, ...(a.tone !== undefined ? { tone: a.tone } : {}) });
+  }
+  // 案内の言葉は型ごとに変える。 共通化した時に `pie` の「割合 / 円 / 45%」 が「値 / 図 / 45」 に
+  // 薄まり、 既存の案内が後退した (review 指摘)。 何を書けばよいかは型ごとに違う
+  const 語 =
+    型 === "pie"
+      ? { 量: "割合", 図: "円", 例: '"45%"' }
+      : 型 === "bar"
+        ? { 量: "値", 図: "棒", 例: '"420"' }
+        : { 量: "値", 図: "折れ線", 例: '"180"' };
+
+  /**
+   * 利用者に伝える。 **`console.warn` だけにしない**。 エディタは受け取った notice を画面に
+   * 出す経路を持っており、 log だけだと項目が消えた理由が誰にも見えない (review 指摘)。
+   */
+  const 伝える = (種類: CompileNotice["kind"], 名前: string, message: string, line = 0) => {
+    onNotice?.({ kind: 種類, actor: 名前, line, message });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${message}`);
+  };
+
+  if (読めない.length > 0) {
+    伝える(
+      "chart-value-unreadable",
+      読めない[0]!,
+      `type: ${型} で${語.量}を読めない項目があります (${語.図}に載せません): ${読めない.join(", ")}。` +
+        ` \`- 名前: ${語.例}\` の形で書いてください`,
+      読めない行,
+    );
+  }
+  if (未宣言.length > 0) {
+    伝える(
+      "chart-value-unreadable",
+      未宣言[0]!,
+      `type: ${型} で数にならない値を参照した項目があります (${語.図}に載せません): ${未宣言.join(", ")}。` +
+        ` \`states:\` にその名前を数で書いてください`,
+      未宣言行,
+    );
+  }
+  if (doc.flow.length > 0) {
+    伝える(
+      "chart-edge-dropped",
+      doc.flow[0]?.from ?? "",
+      `type: ${型} では矢印を描けません (${doc.flow.length} 本を無視しました)。` +
+        ` 関係を描くなら type: flow を使ってください`,
+      doc.flow[0]?.pos?.line ?? 0,
+    );
+  }
+
+  b.node(`${slugify(doc.title) || 型}-chart`, {
+    lane: "chart",
+    stack: 0,
+    kind,
+    title: doc.title,
+    ...図の小見出し(doc),
+    w: CHART_W,
+    h: CHART_H,
+    chartData: data,
+  });
+
+  return b.build();
+}
+
+
+/**
+ * 図表 4 種の組立て (#1154 段 2 / 段 3)。
+ *
+ * 描画側に 1 node で渡す形は値で描く 3 型と同じ。 違うのは **actor から何を読むか**。
+ *
+ * | 型 | 読むもの | 書き方 |
+ * |---|---|---|
+ * | `funnel` | 数 | `- 訪問: "12000"` |
+ * | `tree` | 親子 | `flow` の矢印 (`親 -> 子`) |
+ * | `journey` | 気持ち | `- 登録: "不満"` |
+ * | `quadrant` | どの区画か | `- 重複削除: "左上"` |
+
+ * `tree` だけ `flow` を読む = 親子は 2 つの名前の関係で、 1 行 1 値では書けないため。
+ */
+
+/**
+ * 図表の大きさ。 **格子 (16) の倍数にする**。
+ *
+ * 描画側 (`cdl` の `chart()` preset) は高さを 16 の倍数へ切り上げる。 揃えないと下端が格子から
+ * 外れ、 正しい記法でも位置の警告が出る (review 指摘、 360 のまま 5 型が該当していた)。
+ */
+/**
+ * 図表の箱の大きさ (#1260)。
+ *
+ * **組立て API と同じ値を使う**。 別の値にすると、同じ内容を書いても描いた図の大きさが変わる
+ * (実測 = 記法の `funnel` は 640x368、組立て API は 560x480 で、描いた図の viewBox が
+ * 785x488 対 712x600 になっていた)。
+ *
+ * 組立て API 側は中身の件数で変えない (実測 = 2 / 4 / 8 件のどれでも同じ値)。 そのため
+ * こちらも定数で持つ。 `gantt` だけは件数で高さを変える = 8 件目から最後の帯が枠の外に
+ * 出るため (`compileGantt` の実測)、組立て API の固定 360 より正しい。
+ */
+const 図表の大きさ = {
+  funnel: { w: 560, h: 480 },
+  tree: { w: 720, h: 480 },
+  mind: { w: 720, h: 480 },
+  journey: { w: 720, h: 480 },
+  quadrant: { w: 640, h: 480 },
+} as const;
+
+/** 気持ちの言葉。 書きやすさのため日本語で受ける。 */
+//
+// **`Map` で持つ**。 plain object だと `__proto__` / `constructor` が親から引けてしまい、
+// 書ける語の一覧に無い入力が値として通る (review 指摘)。 型は付いていても中身は object や
+// function になり、 描画側へそのまま流れる。
+const 気持ち = new Map<string, "delighted" | "happy" | "neutral" | "frustrated" | "angry">([
+  ["最高", "delighted"],
+  ["満足", "happy"],
+  ["普通", "neutral"],
+  ["不満", "frustrated"],
+  ["怒り", "angry"],
+]);
+
+/** 区画の言葉。 縦横の位置をそのまま書く。 */
+// 同上の理由で `Map`。
+const 区画 = new Map<string, "topLeft" | "topRight" | "bottomLeft" | "bottomRight">([
+  ["左上", "topLeft"],
+  ["右上", "topRight"],
+  ["左下", "bottomLeft"],
+  ["右下", "bottomRight"],
+]);
+
+/**
+ * 図表の欄が `{名前}` で読む値を、**1 か所で** 確かめる (#1200)。
+ *
+ * 図表には数の欄 (割合 / 段の人数) と語の欄 (気持ち / 区画) があり、どちらも `{名前}` で
+ * 状態を読める。 確かめることは欄の種類で違うが、**土台は同じ** = 同じ名前を 2 回書いた時に
+ * 後ろが効くこと、段で状態に入る値 (切り替え / 補間) も見ること、の 2 つ。
+ *
+ * #1198 と #1201 では欄ごとに検査を書き足しており、同じ土台を 3 度書いていた。 3 度とも
+ * review で同じ形の穴を指摘されている (最初の宣言で判定する / 段で入る値を見落とす)。
+ * 土台を 1 つにして、欄ごとの違いだけを外から渡す。
+ *
+ * ## 確かめること
+ *
+ * | 欄 | 通す値 | 段で入る値 |
+ * |---|---|---|
+ * | 数 | 数として読める (空文字は弾く、`Number("")` が 0 を返すため) | 切り替え先が数 |
+ * | 語 | 語表にある語 | 切り替え先が語表にあり、補間されない (補間の行き先は数) |
+ *
+ * 自動で決まる値 (`values:`) は式の評価結果で必ず数になるため、数の欄からは参照できて
+ * 語の欄からは参照できない。 式そのものの不備 (語を読む / 名前が無い) は
+ * `value-unresolved` の警告が別に出る (実測で確認済)。
+ *
+ * ## 責務境界 (#1198 / #1200)
+ *
+ * **見るのは組み立ての時点で決まっている範囲だけ**。 記法の値は実行時に決まるため、ここで
+ * 全部を判定しようとすると式の評価を組み立て側で再現することになる。 実際に #1199 の review で
+ * 4 round 続けて同じ形の指摘が出て収束せず、境界を決めて切り分けた (穴を 1 つ塞ぐと別の形が
+ * 出る = 塞ぎ方ではなく責務の置き場所の問題だった)。
+ *
+ * | 見る | 見ない | 見ない理由 |
+ * |---|---|---|
+ * | 名前が宣言されているか | 段の行き先が負になる形 | 描画側が問題なく描く (負の大きさも `NaN` も出ないことを実測) |
+ * | 宣言の時点で読める値か | 式が実行時に返す値 | 式の不備は `value-unresolved` の警告が別に出る (実測で確認) |
+ * | 段で状態に入る値 | | |
+ *
+ * 見ない範囲は描画側が受け持つ = 解けない値は既定値で描いて `data-cdl-unresolved` を付ける。
+ */
+function 図表の欄から参照できる名前(
+  doc: DslDocument,
+  欄: { 読めるか: (v: number | string) => boolean; 補間で壊れるか: boolean; 自動の値を許すか: boolean },
+): Set<string> {
+  // 同じ名前を 2 回宣言した時は後ろが効く。 描画側が後の宣言を有効値として扱うため、
+  // 前の宣言で判定すると「読めると判定したのに読めない値が入る」 状態になる (実測)
+  const 実効 = new Map<string, number | string>();
+  for (const s of doc.animate?.states ?? []) 実効.set(s.name, s.initial);
+
+  const 壊れる = new Set<string>();
+  for (const p of doc.animate?.phases ?? []) {
+    for (const st of p.sets ?? []) if (!欄.読めるか(st.value)) 壊れる.add(st.state);
+    if (欄.補間で壊れるか) for (const tw of p.tweens ?? []) 壊れる.add(tw.state);
+  }
+
+  const out = new Set<string>();
+  for (const [名前, 値] of 実効) {
+    if (!欄.読めるか(値)) continue;
+    if (壊れる.has(名前)) continue;
+    out.add(名前);
+  }
+  if (欄.自動の値を許すか) for (const v of doc.values ?? []) out.add(v.name);
+  return out;
+}
+
+/** 数の欄が読める値か。 空文字と空白だけは弾く (`Number("")` は 0 を返す) */
+function 数として読めるか(v: number | string): boolean {
+  if (typeof v === "number") return Number.isFinite(v);
+  const t = v.trim();
+  if (t === "") return false;
+  return Number.isFinite(Number(t));
+}
+
+function 数の欄から参照できる名前(doc: DslDocument): Set<string> {
+  return 図表の欄から参照できる名前(doc, {
+    読めるか: 数として読めるか,
+    // 補間の行き先は数なので、数の欄では壊れない
+    補間で壊れるか: false,
+    自動の値を許すか: true,
+  });
+}
+
+function 語の欄から参照できる名前(doc: DslDocument, 語表: Map<string, string>): Set<string> {
+  return 図表の欄から参照できる名前(doc, {
+    読めるか: (v) => 語表.has(String(v).trim()),
+    // 補間の行き先は数。 語の欄が読む状態を補間すると、その段で語が数に変わる
+    補間で壊れるか: true,
+    // 式の評価結果は数になるため、語の欄からは読めない
+    自動の値を許すか: false,
+  });
+}
+
+/**
+ * 記法の語で書いた状態を、図の語へ直す (#1201)。
+ *
+ * 語の欄が `{名前}` を持つとき、その名前が指す状態には記法の語 (「不満」 「左上」) が
+ * 入っている。 描画側が知っているのは図の語 (`frustrated` / `topLeft`) なので、ここで直す。
+ *
+ * **記法の語彙に engine の内部語を混ぜないため**にこの形にしている。 状態にも図の語を
+ * 書かせる形なら直す処理は要らないが、記法の語と内部語が同じ file に並ぶことになる。
+ *
+ * 直すのは語の欄から参照されている名前だけ。 同じ名前を数の欄からも参照している図では
+ * 直さない (数として読めなくなるため)。
+ *
+ * **この「数の欄からも参照している」 分岐は、到達する入力を今は作れない**。 記法の図は
+ * 1 つの型しか持たず、語の欄を持つ型 (`journey` / `quadrant`) と数の欄を持つ型
+ * (`bar` / `line` / `pie` / `funnel`) は同時に現れないため。 変異試験でもこの行を外して
+ * 検査が落ちないことを確かめた = 覆えていない。 見本を重ねる経路で両方の欄を持つ箱が
+ * できた時のために残す。
+ */
+function 語の状態を図の語へ直す(diagram: CdlDiagram): void {
+  const 対象 = new Map<string, Map<string, string>>();
+  const 数の欄から = new Set<string>();
+  const 拾う = (v: unknown, 語表: Map<string, string>) => {
+    const m = typeof v === "string" ? v.match(/^\{(\w+)/) : null;
+    if (m) 対象.set(m[1]!, 語表);
+  };
+  for (const n of diagram.nodes) {
+    for (const st of n.journeyData ?? []) 拾う(st.emotion, 気持ち);
+    for (const it of n.quadrantData?.items ?? []) 拾う(it.quadrant, 区画);
+    for (const d of n.chartData ?? []) {
+      const m = typeof d.value === "string" ? d.value.match(/^\{(\w+)/) : null;
+      if (m) 数の欄から.add(m[1]!);
+    }
+    for (const f of n.funnelData ?? []) {
+      const m = typeof f.count === "string" ? f.count.match(/^\{(\w+)/) : null;
+      if (m) 数の欄から.add(m[1]!);
+    }
+  }
+  if (対象.size === 0) return;
+
+  const 直す = (名前: string, 値: string | number): string | number => {
+    const 語表 = 対象.get(名前);
+    if (!語表 || 数の欄から.has(名前)) return 値;
+    return 語表.get(String(値).trim()) ?? 値;
+  };
+  for (const s of diagram.states) s.initial = 直す(s.id, s.initial);
+  for (const p of diagram.phases) {
+    for (const st of p.sets) st.value = 直す(st.stateId, st.value);
+  }
+}
+
+function compileFunnel(doc: DslDocument, onNotice?: (n: CompileNotice) => void): CdlDiagram {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const { w: W, h: H } = 図表の大きさ.funnel;
+  b.lane("chart", { width: W + 64 });
+  const data: NonNullable<CdlDiagram["nodes"][number]["funnelData"]> = [];
+  const 読めない: string[] = [];
+  const 未宣言: string[] = [];
+  const 参照できる = 数の欄から参照できる名前(doc);
+  for (const a of doc.actors) {
+    const v = parseChartValue(a.value ?? a.subtitle);
+    // 段の数なので負に意味が無い (状態を読む欄は符号が決まらないので通す)
+    if (v === null || (typeof v === "number" && v < 0)) {
+      読めない.push(a.name);
+      continue;
+    }
+    // 数にならない参照は落とす (棒 / 折れ線 / 円と同じ扱い)
+    const 名前 = 参照する名前(v);
+    if (名前 !== null && !参照できる.has(名前)) {
+      未宣言.push(a.name);
+      continue;
+    }
+    data.push({ id: slugify(a.name), title: a.name, count: v });
+  }
+  if (未宣言.length > 0) {
+    const m3 = `type: funnel で数にならない値を参照した項目があります (段に載せません): ${未宣言.join(", ")}。 \`states:\` にその名前を数で書いてください`;
+    onNotice?.({ kind: "chart-value-unreadable", actor: 未宣言[0]!, line: 0, message: m3 });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${m3}`);
+  }
+  if (読めない.length > 0) {
+    const m = `type: funnel で数を読めない項目があります (段に載せません): ${読めない.join(", ")}。 \`- 訪問: "12000"\` の形で書いてください`;
+    onNotice?.({ kind: "chart-value-unreadable", actor: 読めない[0]!, line: 0, message: m });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${m}`);
+  }
+  // 矢印は描けない。 書かれていたら伝える (黙って捨てると「書いたのに効かない」 が残る)
+  if (doc.flow.length > 0) {
+    const m2 = `type: funnel では矢印を描けません (${doc.flow.length} 本を無視しました)。 関係を描くなら type: flow を使ってください`;
+    onNotice?.({ kind: "chart-edge-dropped", actor: doc.flow[0]?.from ?? "", line: doc.flow[0]?.pos?.line ?? 0, message: m2 });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${m2}`);
+  }
+  b.node(`${slugify(doc.title) || "funnel"}-chart`, {
+    lane: "chart", stack: 0, kind: "funnel-stages", title: doc.title, ...図の小見出し(doc), w: W, h: H, funnelData: data,
+  });
+  return b.build();
+}
+
+/**
+ * 矢印から親子を決める (#1251)。
+ *
+ * 矢印の先が子で、 どこからも指されない名前が根になる。 `type: tree` と `type: mind` が
+ * 同じ規則を使う = 同じ本文を書いた時に、 図種を変えただけで親子の解釈が変わらないようにする。
+ *
+ * **黙って上書きしない**。 同じ子に 2 本来たら後勝ちで消えるし、 書いていない名前を指した
+ * 矢印は無い親を作る。 どちらも図が静かに変わるので伝える。
+ *
+ * 親を辿って自分に戻る形は木にならないため、 その枝を切って伝える。
+ */
+function 矢印から親を決める(
+  doc: DslDocument,
+  図種: "tree" | "mind",
+  名前: ReadonlySet<string>,
+  伝える: (名: string, message: string, line?: number) => void,
+): Map<string, string> {
+  const 親 = new Map<string, string>();
+  for (const f of doc.flow) {
+    const 子 = slugify(f.to);
+    const 親名 = slugify(f.from);
+    if (!名前.has(親名)) {
+      伝える(f.from, `type: ${図種} で書いていない名前を親にしています: ${f.from} -> ${f.to}`, f.pos?.line ?? 0);
+      continue;
+    }
+    // 子の側も見る。 書いていない名前への矢印は、 黙って捨てると図から関係が消える
+    if (!名前.has(子)) {
+      伝える(f.to, `type: ${図種} で書いていない名前を子にしています: ${f.from} -> ${f.to}`, f.pos?.line ?? 0);
+      continue;
+    }
+    if (子 === 親名) {
+      伝える(f.to, `type: ${図種} で自分を親にしています: ${f.to}`, f.pos?.line ?? 0);
+      continue;
+    }
+    const 既存 = 親.get(子);
+    if (既存 !== undefined && 既存 !== 親名) {
+      伝える(f.to, `type: ${図種} で ${f.to} に親が 2 つあります (後の ${f.from} は使いません)`, f.pos?.line ?? 0);
+      continue;
+    }
+    親.set(子, 親名);
+  }
+  // 親を辿って自分に戻る形は木にならない。 その枝を切って伝える
+  for (const 子 of [...親.keys()]) {
+    const 見た = new Set<string>([子]);
+    let p2 = 親.get(子);
+    while (p2 !== undefined) {
+      if (見た.has(p2)) {
+        伝える(子, `type: ${図種} で親を辿ると輪になります (${子} の親を外しました)`);
+        親.delete(子);
+        break;
+      }
+      見た.add(p2);
+      p2 = 親.get(p2);
+    }
+  }
+  return 親;
+}
+
+function compileTree(doc: DslDocument, onNotice?: (n: CompileNotice) => void): CdlDiagram {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const { w: W, h: H } = 図表の大きさ.tree;
+  b.lane("chart", { width: W + 64 });
+  // **同じ slug になる名前を先に見る**。 違う名前が同じ id に潰れると、 自分を親にしたと
+  // 誤判定したり、 同じ id の要素が 2 つできたりする (review 指摘)
+  const slug別 = new Map<string, string[]>();
+  for (const a of doc.actors) {
+    const k = slugify(a.name);
+    slug別.set(k, [...(slug別.get(k) ?? []), a.name]);
+  }
+  const 名前 = new Set(slug別.keys());
+  // **行番号を渡す**。 `DslActor` / `DslStep` は `pos.line` を持つので遡れる。 前回「持てない」
+  // と書いたのは誤り (review 指摘)。 0 にすると画面が問題の行を案内できない
+  const 伝える = (名: string, message: string, line = 0) => {
+    onNotice?.({ kind: "chart-value-unreadable", actor: 名, line, message });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${message}`);
+  };
+  for (const [k, 群] of slug別) {
+    if (群.length > 1) {
+      伝える(群[0]!, `type: tree で ${群.join(" / ")} が同じ id (${k}) になります。 名前を変えてください`);
+    }
+  }
+  const 親 = 矢印から親を決める(doc, "tree", 名前, 伝える);
+  const data: NonNullable<CdlDiagram["nodes"][number]["treeData"]> = doc.actors.map((a) => {
+    const id = slugify(a.name);
+    const p3 = 親.get(id);
+    return { id, title: a.name, ...(p3 !== undefined ? { parent: p3 } : {}) };
+  });
+  b.node(`${slugify(doc.title) || "tree"}-chart`, {
+    lane: "chart", stack: 0, kind: "tree-hierarchy", title: doc.title, ...図の小見出し(doc), w: W, h: H, treeData: data,
+  });
   return b.build();
 }
 
 /**
- * Class preset (UML class diagram 専用 layout)
+ * 体験の道筋の段に添える欄 (#1251)。
  *
- * 設計 ... 各 class を 1 storage node として配置、 縦に stack する。 storage node renderer は
- * title (class 名) + divider + rows (fields / methods) を UML class box 風に表示する。
+ * 書かなければ項目ごと落とす = `undefined` を明示して渡すと、 組立て側が「空を書いた」 と
+ * 区別できなくなる (`図の小見出し` と同じ理由)。
+ */
+function 道筋の欄(a: DslActor): { touchpoint?: string; opportunity?: string } {
+  return {
+    ...(a.touchpoint !== undefined ? { touchpoint: a.touchpoint } : {}),
+    ...(a.opportunity !== undefined ? { opportunity: a.opportunity } : {}),
+  };
+}
+
+/**
+ * 体験の道筋の欄を、 それを描けない図種で書いた時に伝える (#1251)。
  *
- * 実装 ... 全 class を 1 lane に縦 stack 配置。 actor の kind を強制 storage、 rows / subtitle は
- * applyV05Extensions で node に merge される。
+ * `touchpoint` と `opportunity` は `type: journey` の段だけが持つ。 他の図種では相手が無く、
+ * 黙って捨てると「書いたのに出ない」 が手掛かりなしで起きる。
  *
- * flow ... 継承 / 関連を edge で表現 (label に "extends" / "implements" 等を author が指定)。
+ * `type: mind` では伝えない = `compileMind` が描けない欄をまとめて 1 件で伝えており、
+ * そこに 2 つとも入っている (`放射で描けない欄`)。 二重に伝えない (#1246 と同じ扱い)。
  */
-function compileClass(doc: DslDocument): CdlDiagram {
-  const b = diagram(slugify(doc.title), { topic: doc.title });
-  const CLASS_W = 400;
-  // 登場人物が 0 人なら枠も作らない。 先に作ると中身の無い枠が 1 つ残る (#1096)
-  if (doc.actors.length === 0) return b.build();
-  b.lane("class-stack", { width: CLASS_W, label: doc.title });
-
-  doc.actors.forEach((a, idx) => {
-    const nodeId = slugify(a.name) || `c${idx}`;
-    b.node(nodeId, {
-      lane: "class-stack",
-      stack: idx,
-      kind: "storage",
-      title: a.name,
-      w: CLASS_W,
-    });
-  });
-
-  for (const s of doc.flow) {
-    const fromId = slugify(s.from);
-    const toId = slugify(s.to);
-    b.edge(fromId, toId, {
-      label: s.label,
-      ...(s.sub ? { sub: s.sub } : {}),
-      ...(s.tone ? { tone: s.tone } : {}),
-      ...(s.style ? { style: s.style } : {}),
-    });
+function reportChartFieldsNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice) return;
+  if (doc.type === "mind") return;
+  for (const a of doc.actors) {
+    if (a.partId !== undefined) continue;
+    const 道筋 = doc.type === "journey" ? [] : [
+      ...(a.touchpoint !== undefined ? ["touchpoint"] : []),
+      ...(a.opportunity !== undefined ? ["opportunity"] : []),
+    ];
+    const 工程 = doc.type === "gantt" ? [] : [
+      ...(a.owner !== undefined ? ["owner"] : []),
+      ...(a.end !== undefined ? ["end"] : []),
+    ];
+    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 を使ってください",
+      });
+    }
+    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: gantt を使ってください",
+      });
+    }
   }
+}
 
+function compileJourney(doc: DslDocument, onNotice?: (n: CompileNotice) => void): CdlDiagram {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const { w: W, h: H } = 図表の大きさ.journey;
+  b.lane("chart", { width: W + 64 });
+  const data: NonNullable<CdlDiagram["nodes"][number]["journeyData"]> = [];
+  const 読めない: string[] = [];
+  const 参照できる = 語の欄から参照できる名前(doc, 気持ち);
+  for (const a of doc.actors) {
+    const 語 = (a.value ?? a.subtitle ?? "").trim();
+    // 状態を読む欄はそのまま渡す。 指す先の語は `語の状態を図の語へ直す` が図の語に直す
+    const 参照 = 語.match(/^\{(\w+)\}$/);
+    if (参照) {
+      if (!参照できる.has(参照[1]!)) {
+        読めない.push(a.name);
+        continue;
+      }
+      data.push({ id: slugify(a.name), title: a.name, emotion: 語 as never, ...道筋の欄(a) });
+      continue;
+    }
+    const e = 気持ち.get(語);
+    if (e === undefined) {
+      読めない.push(a.name);
+      continue;
+    }
+    data.push({ id: slugify(a.name), title: a.name, emotion: e, ...道筋の欄(a) });
+  }
+  if (読めない.length > 0) {
+    const m = `type: journey で気持ちを読めない項目があります (道筋に載せません): ${読めない.join(", ")}。 \`- 登録: "不満"\` の形で、 ${[...気持ち.keys()].join(" / ")} のどれかを書いてください`;
+    onNotice?.({ kind: "chart-value-unreadable", actor: 読めない[0]!, line: 0, message: m });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${m}`);
+  }
+  // 矢印は描けない。 書かれていたら伝える (黙って捨てると「書いたのに効かない」 が残る)
+  if (doc.flow.length > 0) {
+    const m2 = `type: journey では矢印を描けません (${doc.flow.length} 本を無視しました)。 関係を描くなら type: flow を使ってください`;
+    onNotice?.({ kind: "chart-edge-dropped", actor: doc.flow[0]?.from ?? "", line: doc.flow[0]?.pos?.line ?? 0, message: m2 });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${m2}`);
+  }
+  b.node(`${slugify(doc.title) || "journey"}-chart`, {
+    lane: "chart", stack: 0, kind: "journey-map", title: doc.title, ...図の小見出し(doc), w: W, h: H, journeyData: data,
+  });
   return b.build();
 }
 
+/** 軸を書かなかった時の名前。 何の軸か分からないため、位置をそのまま出す */
+const 軸の既定 = {
+  xAxis: { left: "小さい", right: "大きい" },
+  yAxis: { bottom: "小さい", top: "大きい" },
+  quadrantLabels: { topLeft: "左上", topRight: "右上", bottomLeft: "左下", bottomRight: "右下" },
+} as const;
+
 /**
- * Pie preset (円グラフ風 slice list 専用 layout)
+ * 2 軸で仕分ける図の軸と区画の名前を決める (#1251)。
  *
- * 設計 ... 円グラフの SVG arc 描画は engine 改修が大きいため、 簡易版として「slice list + value (%) 表示」
- * で代替する。 1 lane に slice を縦並びにし、 value 属性 (例 "30%") は applyV05Extensions が
- * node.value に merge することで「[Slice A] 30%」 「[Slice B] 25%」 のような pie chart 意図を伝える。
- *
- * 実装 ... 全 slice を 1 lane に縦 stack。 kind: card 強制、 w=480 h=120。
+ * `axes:` を書かなければ従来どおり位置の名前 (`左上` 等) を出す = 既に描いてある図が動かない。
  *
- * flow は通常なし (slice 間に依存関係はない)、 author 明示時のみ edge を描く。
- */
-/**
- * 割合の書き方から数値を読む。 読めなければ `null`。
+ * 書いたら区画の名前は **軸の名前から決める** (`{上} × {右}`)。 組立て API 側が同じ規則で
+ * 導いており (実測 = `xAxis: {left: "L", right: "R"}` / `yAxis: {bottom: "B", top: "T"}` で
+ * `topLeft: "T × L"`)、 別の規則にすると同じ内容を書いても図が食い違う。
  *
- * 受けるのは `"45%"` / `"45"` / `"45.5%"` と、 前後の空白。 `"四割"` や `"0.45"` のような
- * 別の言い方は読まない = **黙って 0 にすると、 その分だけ欠けた円が「正しい図」 として出る**。
- * 読めなかったことは呼出側が警告に出す。
+ * 片側だけ書いた形では、書かなかった側は既定のままにする。 空文字を渡すと名前の無い軸が描かれる。
  */
-function parseShareValue(raw: string | undefined): number | null {
-  if (raw === undefined) return null;
-  const m = raw.trim().match(/^(\d+(?:\.\d+)?)\s*%?$/);
-  if (m === null) return null;
-  const v = Number(m[1]);
-  return Number.isFinite(v) ? v : null;
+function 軸と区画の名前(doc: DslDocument): {
+  xAxis: { left: string; right: string };
+  yAxis: { bottom: string; top: string };
+  quadrantLabels: { topLeft: string; topRight: string; bottomLeft: string; bottomRight: string };
+} {
+  if (doc.axes === undefined) return 軸の既定;
+  const left = doc.axes.x?.left ?? 軸の既定.xAxis.left;
+  const right = doc.axes.x?.right ?? 軸の既定.xAxis.right;
+  const bottom = doc.axes.y?.bottom ?? 軸の既定.yAxis.bottom;
+  const top = doc.axes.y?.top ?? 軸の既定.yAxis.top;
+  return {
+    xAxis: { left, right },
+    yAxis: { bottom, top },
+    quadrantLabels: {
+      topLeft: `${top} × ${left}`,
+      topRight: `${top} × ${right}`,
+      bottomLeft: `${bottom} × ${left}`,
+      bottomRight: `${bottom} × ${right}`,
+    },
+  };
 }
 
 /**
- * Pie preset (円グラフ)。
+ * 軸の名前を、それを持たない図種で書いた時に伝える (#1251)。
  *
- * 描画側の `chart-pie` に 1 node で渡す。 以前は `card` を縦に積むだけで、 `type: pie` と
- * 書いても円が出ず、 割合が箱の説明文として枠からはみ出していた (実機報告)。
- *
- * 大きさは cdl の `chart()` preset と同じ 640x320 (どちらも格子 16 の倍数)。 lane 幅は
- * `chart()` が使う `gridAlignedLaneW` と同じ計算 = 中身 + 左右の余白 32 ずつ。
- *
- * 値は actor の説明文から読む (`- TypeScript: "45%"`)。 読めない actor は円に載せず、
- * まとめて警告に出す。 合計が 100 にならなくても描画側が比で割るので、 こちらでは正規化しない。
+ * 軸を持つのは `type: quadrant` だけ。 他の図種では相手が無く、黙って捨てると
+ * 「書いたのに出ない」 が手掛かりなしで起きる。
  */
-function compilePie(doc: DslDocument): CdlDiagram {
-  const b = diagram(slugify(doc.title), { topic: doc.title });
-  const CHART_W = 640;
-  const CHART_H = 320;
-  b.lane("chart", { width: CHART_W + 64, label: doc.title });
+function reportAxesNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice) return;
+  if (doc.axes === undefined) return;
+  if (doc.type === "quadrant") return;
+  onNotice({
+    kind: "chart-value-unreadable",
+    actor: doc.title,
+    line: doc.axesPos?.line ?? doc.pos?.line ?? 0,
+    message: `最上位に書いた axes は効きません (type: ${doc.type} には軸がありません)`,
+    hint: "2 つの軸で仕分ける図を描くなら type: quadrant を使ってください",
+  });
+}
 
-  const data: NonNullable<CdlDiagram["nodes"][number]["chartData"]> = [];
+function compileQuadrant(doc: DslDocument, onNotice?: (n: CompileNotice) => void): CdlDiagram {
+  const b = diagram(slugify(doc.title), { topic: doc.title });
+  const { w: W, h: H } = 図表の大きさ.quadrant;
+  b.lane("chart", { width: W + 64 });
+  const items: NonNullable<CdlDiagram["nodes"][number]["quadrantData"]>["items"] = [];
   const 読めない: string[] = [];
+  const 参照できる = 語の欄から参照できる名前(doc, 区画);
   for (const a of doc.actors) {
-    // 割合の置き場所は記法で 2 通りある。 略記 (`- TypeScript: "45%"`) は説明文に、
-    // 縦書きの map (`- SliceA: { kind: card, value: "30%" }`) は値に入る。 両方を読む
-    const value = parseShareValue(a.value ?? a.subtitle);
-    if (value === null) {
+    const 語 = (a.value ?? a.subtitle ?? "").trim();
+    const 参照 = 語.match(/^\{(\w+)\}$/);
+    if (参照) {
+      if (!参照できる.has(参照[1]!)) {
+        読めない.push(a.name);
+        continue;
+      }
+      items.push({ id: slugify(a.name), title: a.name, quadrant: 語 as never });
+      continue;
+    }
+    const q = 区画.get(語);
+    if (q === undefined) {
       読めない.push(a.name);
       continue;
     }
-    // 色は扇にそのまま渡す。 箱が 1 つになっても、 書いた色が消えないようにする
-    data.push({ label: a.name, value, ...(a.tone !== undefined ? { tone: a.tone } : {}) });
+    items.push({ id: slugify(a.name), title: a.name, quadrant: q });
   }
-  if (読めない.length > 0 && typeof console !== "undefined" && console.warn) {
-    console.warn(
-      `[dragon] type: pie で割合を読めない項目があります (円に載せません): ${読めない.join(", ")}。` +
-        ` \`- 名前: "45%"\` の形で書いてください`,
-    );
+  if (読めない.length > 0) {
+    const m = `type: quadrant で区画を読めない項目があります (図に載せません): ${読めない.join(", ")}。 \`- 重複削除: "左上"\` の形で、 ${[...区画.keys()].join(" / ")} のどれかを書いてください`;
+    onNotice?.({ kind: "chart-value-unreadable", actor: 読めない[0]!, line: 0, message: m });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${m}`);
   }
-  // 円グラフは扇 1 枚が 1 項目で、 項目どうしを結ぶ線が無い。 書いた矢印は描けないので、
-  // 黙って捨てずに伝える (「書いたのに効かない」 を残さない)
-  if (doc.flow.length > 0 && typeof console !== "undefined" && console.warn) {
-    console.warn(
-      `[dragon] type: pie では矢印を描けません (${doc.flow.length} 本を無視しました)。` +
-        ` 関係を描くなら type: flow を使ってください`,
-    );
+  // 矢印は描けない。 書かれていたら伝える (黙って捨てると「書いたのに効かない」 が残る)
+  if (doc.flow.length > 0) {
+    const m2 = `type: quadrant では矢印を描けません (${doc.flow.length} 本を無視しました)。 関係を描くなら type: flow を使ってください`;
+    onNotice?.({ kind: "chart-edge-dropped", actor: doc.flow[0]?.from ?? "", line: doc.flow[0]?.pos?.line ?? 0, message: m2 });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${m2}`);
   }
-
-  b.node(`${slugify(doc.title) || "pie"}-chart`, {
-    lane: "chart",
-    stack: 0,
-    kind: "chart-pie",
-    title: doc.title,
-    w: CHART_W,
-    h: CHART_H,
-    chartData: data,
+  b.node(`${slugify(doc.title) || "quadrant"}-chart`, {
+    lane: "chart", stack: 0, kind: "quadrant-matrix", title: doc.title, ...図の小見出し(doc), w: W, h: H,
+    quadrantData: { ...軸と区画の名前(doc), items },
   });
-
   return b.build();
 }
 
@@ -2743,86 +4910,315 @@ function compileC4(doc: DslDocument): CdlDiagram {
  *
  * flow ... 宣言なしなら root → 各 leaf の暗黙 edge を自動生成、 宣言ありならそれを採用。
  */
-function compileMind(doc: DslDocument): CdlDiagram {
+/**
+ * 記法の `type: mind` を engine の `mind-map` 種別に寄せる (#1177)。
+ *
+ * 以前は `card` を 3 列 (`mind-left` / `mind-center` / `mind-right`) に並べる別実装で、
+ * engine の `mind-map` を使っていなかった。 そのため 2 つの穴があった。
+ *
+ * | 穴 | 中身 |
+ * |---|---|
+ * | 枝の親を見る規則が届かない | `ruleMindMapParentReference` は `kind === "mind-map"` かつ `mindData` を持つ node にしか当たらない |
+ * | `SINGLE_BOX_KINDS` の `mind-map` が到達しない | 一覧に載っているのに記法から辿り着けない項目として残る |
+ *
+ * **枝の親は書けない**。 記法の `actors` は「1 つ目が根、 残りが枝」 の並びで、 `parent` を
+ * 書く場所が無い。 全ての枝を根の直下に置く。 親子を矢印で書く形は `type: tree` が持っており、
+ * `mind` は簡便形として別に残す (Issue の 実装しない条件)。
+ *
+ * したがって **矢印は描けない**。 書かれていたら伝える = 黙って捨てると「書いたのに効かない」
+ * が残る (`type: journey` / `type: quadrant` と同じ扱い)。
+ *
+ * 絵は変わる (3 列の箱 → 中心から放射)。 破壊的変更として `CHANGELOG` に記録している。
+ */
+/**
+ * 1 箱で描く放射が **描ける欄**。 これ以外は書いても出ない (#1177 Round 3)。
+ *
+ * 数え上げは 3 度直した。 副題 / 値 / 行 → 位置 / 大きさ → 種類 / 枠 / 積む順 …と、 見落とした
+ * 欄が review のたびに出た。 数え漏らしても検査は通ってしまう = 「書いたのに出ない」 が黙って
+ * 残る形が繰り返し発生した。
+ *
+ * そこで **`DslActor` の全ての欄を、 描ける側か描けない側のどちらかに必ず割り当てる**。
+ * 欄が増えた時に両方へ入れ忘れると型検査が落ちるので、 「描けるのか描けないのか」 を必ず
+ * 判断することになる (`rules/quality.md § 多層 SSOT 経路の全 registration 保証` と同じ形)。
+ */
+type 放射で描ける欄 =
+  /** 中心の名前 / 枝の名前になる */
+  | "name"
+  /**
+   * 名前の後ろに続けて出す 2 欄。
+   *
+   * `- 描く量を減らす: "{draw} ms"` の形は副題として解析されるため、 値の欄だけを見ると
+   * 記法で最も普通な書き方が届かない (#1230 で実測)。 明示的に書いた値の欄も同じ場所へ出す。
+   *
+   * 描画側が描くのは枝と中心の `title` だけで (`mind-map.tsx` は型にある `subtitle` を
+   * 1 度も描かない)、 状態を読み替えるのも `title` と `rootTitle` に限る
+   * (`resolveMindData`)。 届ける先が他に無いため名前と同じ欄へ載せる。
+   */
+  | "subtitle"
+  | "value"
+  /** 枝の色 (`MindBranchNode.tone`)。 中心は持てないので `描けない欄` が別に見る */
+  | "tone"
+  /** 見本は放射に載せず、 見本の中身だけを描く (別経路で伝える) */
+  | "partId"
+  /** 種類を書いたかどうかの印。 `kind` と対で見るので単独では扱わない */
+  | "kindWritten"
+  /** 本文の行番号。 知らせに載せるために使う */
+  | "pos";
+
+/** 放射では描けない欄。 書かれていたら伝える */
+type 放射で描けない欄 =
+  | "kind"
+  | "eyebrow"
+  | "touchpoint"
+  | "opportunity"
+  | "owner"
+  | "end"
+  | "rows"
+  | "lane"
+  | "stack"
+  | "initial"
+  | "final"
+  | "colorHex"
+  | "stateOverride"
+  | "posX"
+  | "posY"
+  | "posW"
+  | "posH"
+  | "scale"
+  | "scaleKeys"
+  | "posRel"
+  | "nodes"
+  | "layoutPos";
+
+/** 引数が `never` でなければ型検査が落ちる */
+type 空であること<T extends never> = T;
+
+/** `DslActor` に割り当て漏れの欄があると落ちる */
+export type _放射の欄を覆えている = 空であること<
+  Exclude<keyof DslActor, 放射で描ける欄 | 放射で描けない欄>
+>;
+
+/** `DslActor` に無い欄を割り当てていると落ちる */
+export type _放射の欄に余りがない = 空であること<
+  Exclude<放射で描ける欄 | 放射で描けない欄, keyof DslActor>
+>;
+
+/** 描ける側と描けない側が重なっていると落ちる */
+export type _放射の欄が重なっていない = 空であること<Extract<放射で描ける欄, 放射で描けない欄>>;
+
+/**
+ * 描けない欄と、 知らせに出す名前。
+ *
+ * **欄ごとに式を持たせない** (Round 5 の指摘)。 `{ 説明, 書いたか }` の形にすると、 項目名と式が
+ * 型で結ばれず `scale: { 書いたか: () => false }` のように **判定を骨抜きにしても型検査が通る**。
+ * 名前だけを持ち、 書かれていたかは下の 1 つの式で見る。
+ *
+ * `Record<放射で描けない欄, string>` なので、 欄を足すと項目も要る。 判定の側は欄ごとに書く所が
+ * 無いため、 書き忘れも骨抜きも起きない。
+ *
+ * 表示の名前は複数の欄で同じでよい (`posX` と `posY` はどちらも「位置 (座標)」)。 出す時に
+ * 重複を除く。
+ */
+const 放射で描けない欄の名前: Record<放射で描けない欄, string> = {
+  kind: "種類",
+  eyebrow: "上の小見出し",
+  touchpoint: "場所 (体験の道筋の欄)",
+  opportunity: "改善の余地 (体験の道筋の欄)",
+  owner: "担当 (工程の並びの欄)",
+  end: "終わる時期 (工程の並びの欄)",
+  rows: "行",
+  lane: "枠の指定",
+  stack: "積む順",
+  initial: "始まり / 終わり の印",
+  final: "始まり / 終わり の印",
+  colorHex: "色番号",
+  stateOverride: "状態の上書き",
+  // 位置は「登場人物ごとの箱をどこに置くか」 の指定で、 箱が 1 つの図では置く先が無い
+  posX: "位置 (座標)",
+  posY: "位置 (座標)",
+  posW: "大きさ",
+  posH: "大きさ",
+  scale: "倍率",
+  scaleKeys: "倍率",
+  posRel: "位置 (相対)",
+  nodes: "中の箱ごとの指定",
+  layoutPos: "配置のずらし",
+};
+
+/**
+ * その欄が書かれていたか。 **全ての欄をこの 1 つの式で見る**。
+ *
+ * 欄ごとに式を持たせると、 1 つだけ骨抜きにしても型検査が通る (Round 5 の指摘)。 1 つにすれば
+ * 骨抜きにした時点で全ての欄の検査が落ちる。
+ *
+ * 例外は種類だけ。 既定値 (`actor`) が必ず入るので、 書いたかどうかの印 (`kindWritten`) で見る。
+ * 真偽を持つ欄 (`initial` / `final`) は `false` を「書いていない」 として扱う = 既定と同じ意味で、
+ * 伝えると書いていない人にも出る。
+ */
+function 放射で描けない欄を書いたか(a: DslActor, 欄: 放射で描けない欄): boolean {
+  if (欄 === "kind") return a.kindWritten === true;
+  const v = a[欄];
+  if (typeof v === "boolean") return v;
+  return v !== undefined;
+}
+
+/**
+ * 放射の枝と中心に出す文字を組む (#1230)。
+ *
+ * 値の欄を書いた登場人物は名前の後ろに空白 1 つで続ける。 書いていない図は名前だけになり、
+ * 変更前と同じ文字列になる。
+ *
+ * **名前と同じ欄に載せるしかない**。 描画側が描くのは枝と中心の `title` だけで
+ * (`mind-map.tsx` は型にある `subtitle` を 1 度も描かない)、 状態を読み替えるのも
+ * `title` と `rootTitle` に限る (`resolveMindData`)。 値を別の欄へ渡しても絵に出ない。
+ */
+function 放射に出す文字(a: DslActor): string {
+  const 続き = [a.subtitle, a.value].map((x) => x?.trim()).filter((x): x is string => !!x);
+  return 続き.length > 0 ? `${a.name} ${続き.join(" ")}` : a.name;
+}
+
+function compileMind(doc: DslDocument, onNotice?: (n: CompileNotice) => void): CdlDiagram {
   const b = diagram(slugify(doc.title), { topic: doc.title });
-  const LEAF_W = 280;
-  const ROOT_W = 320;
-  const GAP = 80;
+  const { w: W, h: H } = 図表の大きさ.mind;
+
+  const 伝える = (kind: CompileNotice["kind"], 名: string, message: string, line = 0): void => {
+    onNotice?.({ kind, actor: 名, line, message });
+    if (typeof console !== "undefined" && console.warn) console.warn(`[dragon] ${message}`);
+  };
 
-  // 枝は左右に交互に置く。 中身のある枠だけ作る (#1096)。
+  // **見本 (`parts`) を重ねた登場人物は中心にも枝にもしない** (review 指摘)。 後段の
+  // `mergePartsFromActors` が見本の中身を別の箱として足すため、 こちらにも載せると同じ
+  // 登場人物が 2 箇所に描かれる。 中心だけ外し忘れると、 中心が見本の記法で二重になる
+  const 見本でない: DslActor[] = [];
+  for (const a of doc.actors) {
+    if (a.partId !== undefined) {
+      伝える(
+        "part-not-drawn",
+        a.name,
+        `type: mind では見本 (${a.partId}) を中心にも枝にもできません。 見本はそのまま描き、 放射には載せません`,
+        a.pos?.line ?? 0,
+      );
+      continue;
+    }
+    見本でない.push(a);
+  }
+  // 枝の親は矢印で決まる (#1251)。 書かなければ全て中心の直下 = 従来と同じ図になる。
+  // 規則は `type: tree` と共有する = 同じ本文で図種だけ変えた時に親子の解釈が割れない。
   //
-  // 3 枠を固定で作ると、 枝が 1 本の図で右の枠が中身なしで残る (実測 = 登場人物 2 人で
-  // `mind-right` が空)。 見る人には「何かが描かれ損ねた」 ようにしか見えない (`#1078` で
-  // `c4` を直したのと同じ欠陥)。
-  const 枝の数 = Math.max(0, doc.actors.length - 1);
-  const 左に置く数 = Math.ceil(枝の数 / 2);
-  const 右に置く数 = 枝の数 - 左に置く数;
-  const 左を使う = 左に置く数 > 0;
-  const 右を使う = 右に置く数 > 0;
-
-  // 登場人物が 0 人なら枠も作らない。 中央の枠を先に作ると、 中身の無い枠が 1 つ残る
-  // (実測 = `title` と `type` だけの本文で `mind-center` が空、 Round 1 review の指摘)
-  if (doc.actors.length === 0) return b.build();
+  // **早期 return より前に置く** = 見本しか居ない記法で矢印を書いた時、 枝が 1 本も無いため
+  // どの矢印も親にできない。 後ろに置くと、その形で矢印が黙って消える (Round 3 の指摘と同じ理由)
+  const 枝の名前 = new Set(見本でない.map((a) => slugify(a.name)));
+  const 親 = 矢印から親を決める(doc, "mind", 枝の名前, (名, message, line) =>
+    // 親にできなかった矢印は描かれない。 知らせの種別も「矢印を落とした」 にする
+    伝える("chart-edge-dropped", 名, message, line ?? 0),
+  );
+
+  // 放射に載る登場人物が 0 人なら枠も作らない。 中身の無い枠が 1 つ残るのを避ける (#1096)。
+  // **枠を作る前に見る** = 見本しか居ない記法で作ると、 見本だけが描かれた図に空の枠が残る
+  if (見本でない.length === 0) return b.build();
 
-  // 使う枠だけ左から詰める。 飛ばした位置に隙間を残すと、 やはり「抜けている」 ように見える
-  let x = 0;
-  if (左を使う) {
-    b.lane("mind-left", { x, width: LEAF_W, label: "" });
-    x += LEAF_W + GAP;
+  b.lane("chart", { width: W + 64 });
+
+  // **同じ slug になる名前を先に見る** (`type: tree` と同じ理由)。 違う名前が同じ id に潰れると、
+  // 枝が 1 本消えたり、 枝の親を見る規則が別の枝を指したりする
+  const slug別 = new Map<string, string[]>();
+  for (const a of 見本でない) {
+    const k = slugify(a.name);
+    slug別.set(k, [...(slug別.get(k) ?? []), a.name]);
   }
-  b.lane("mind-center", { x, width: ROOT_W, label: doc.title });
-  x += ROOT_W + GAP;
-  if (右を使う) {
-    b.lane("mind-right", { x, width: LEAF_W, label: "" });
+  for (const [k, 群] of slug別) {
+    if (群.length > 1) {
+      伝える(
+        "chart-value-unreadable",
+        群[0]!,
+        `type: mind で ${群.join(" / ")} が同じ id (${k}) になります。 名前を変えてください`,
+      );
+    }
   }
 
-  const root = doc.actors[0]!;
+  const root = 見本でない[0]!;
   const rootId = slugify(root.name) || "root";
-  const leafCount = doc.actors.length - 1;
-  const rootStack = Math.floor(leafCount / 2);
-  b.node(rootId, {
-    lane: "mind-center",
-    stack: rootStack,
-    kind: "card",
-    title: root.name,
-    w: ROOT_W,
-  });
 
-  const stackLeft = { v: 0 };
-  const stackRight = { v: 0 };
-  doc.actors.slice(1).forEach((a, i) => {
-    const isLeft = i % 2 === 0;
-    const lid = isLeft ? "mind-left" : "mind-right";
-    const counter = isLeft ? stackLeft : stackRight;
-    const nodeId = slugify(a.name) || `leaf-${i}`;
-    b.node(nodeId, {
-      lane: lid,
-      stack: counter.v,
-      kind: "card",
-      title: a.name,
-      w: LEAF_W,
+  // **中心を子にする矢印は表せない** (#1251 Round 1 の指摘)。 中心は枝の並びに居ないため
+  // 親を持てず、 解決はできても誰にも読まれずに消える。 黙って捨てると「書いたのに
+  // 図が変わらない」 が手掛かりなしで起きるので、 行番号付きで伝える
+  for (const f of doc.flow) {
+    if (slugify(f.to) !== rootId) continue;
+    伝える(
+      "chart-edge-dropped",
+      f.to,
+      `type: mind で中心 (${truncateForMessage(f.to)}) を子にはできません (${truncateForMessage(f.from)} -> ${truncateForMessage(f.to)} を使いません)。 中心は放射の真ん中に置く 1 つだけです`,
+      f.pos?.line ?? 0,
+    );
+  }
+
+  // **1 箱で描く種別が持てる欄は限られる**。 枝は名前と色、 中心は名前だけ。 書いても描けない
+  // 欄は伝える = 箱ごとに描いていた頃は載っていた欄で、 黙って消すと「書いたのに出ない」 が残る
+  const 描けない欄 = (a: DslActor): string[] => {
+    const out: string[] = [];
+    for (const 欄 of Object.keys(放射で描けない欄の名前) as 放射で描けない欄[]) {
+      if (!放射で描けない欄を書いたか(a, 欄)) continue;
+      const 名前 = 放射で描けない欄の名前[欄];
+      // 同じ名前を持つ欄 (`posX` と `posY`) は 1 度だけ出す
+      if (!out.includes(名前)) out.push(名前);
+    }
+    return out;
+  };
+  const 消えた欄 = new Map<string, string[]>();
+  const 記録する = (a: DslActor): void => {
+    const 欄 = 描けない欄(a);
+    if (欄.length > 0) 消えた欄.set(a.name, 欄);
+  };
+
+  const branches: NonNullable<CdlDiagram["nodes"][number]["mindData"]>["branches"] = [];
+  const 使った = new Set<string>([rootId]);
+  記録する(root);
+  // 中心は色の欄を持たない (`MindBranchPayload` に `tone` が無い)
+  if (root.tone) 消えた欄.set(root.name, [...(消えた欄.get(root.name) ?? []), "色 (中心は持てない)"]);
+
+  見本でない.slice(1).forEach((a, i) => {
+    const id = slugify(a.name) || `leaf-${i}`;
+    if (使った.has(id)) {
+      伝える(
+        "chart-value-unreadable",
+        a.name,
+        `type: mind で ${a.name} が既にある id (${id}) と重なります (枝に載せません)`,
+        a.pos?.line ?? 0,
+      );
+      return;
+    }
+    使った.add(id);
+    記録する(a);
+    // 矢印を書かなかった枝は中心の直下。 中心を親に指した矢印も同じ値になる
+    // (中心は `見本でない` の先頭なので、 その名前の slug が `rootId` そのもの)
+    // 枝は色を持てる (`MindBranchNode.tone`)
+    branches.push({
+      id,
+      title: 放射に出す文字(a),
+      parent: 親.get(id) ?? rootId,
+      ...(a.tone ? { tone: a.tone } : {}),
     });
-    counter.v += 1;
   });
 
-  if (doc.flow.length === 0 && doc.actors.length > 1) {
-    doc.actors.slice(1).forEach((a) => {
-      const leafId = slugify(a.name);
-      b.edge(rootId, leafId, { label: "" });
-    });
-  } else {
-    for (const s of doc.flow) {
-      const fromId = slugify(s.from);
-      const toId = slugify(s.to);
-      b.edge(fromId, toId, {
-        label: s.label,
-        ...(s.sub ? { sub: s.sub } : {}),
-        ...(s.tone ? { tone: s.tone } : {}),
-        ...(s.style ? { style: s.style } : {}),
-      });
-    }
+  if (消えた欄.size > 0) {
+    const 一覧 = [...消えた欄].map(([名, 欄]) => `${名} の${欄.join(" / ")}`).join("、 ");
+    伝える(
+      "chart-value-unreadable",
+      [...消えた欄.keys()][0]!,
+      `type: mind は名前と副題 / 値、 枝の色しか描けません (描かない欄: ${一覧})。 これらを描くなら type: tree か type: flow を使ってください`,
+    );
   }
 
+  b.node(`${slugify(doc.title) || "mind"}-chart`, {
+    lane: "chart",
+    stack: 0,
+    kind: "mind-map",
+    title: doc.title,
+    ...図の小見出し(doc),
+    w: W,
+    h: H,
+    mindData: { rootId, rootTitle: 放射に出す文字(root), branches },
+  });
   return b.build();
 }
 
@@ -2838,7 +5234,82 @@ function compileMind(doc: DslDocument): CdlDiagram {
  * これにより v0.5 syntax で 19 機能のうち以下が動く:
  * subtitle / eyebrow / value / rows / contain / lifeline / label / lane.x / lane.width / laneWidth
  */
-function applyV05Extensions(diagram: CdlDiagram, doc: DslDocument): CdlDiagram {
+/**
+ * `lanes:` で作った縦列と、見本 (parts) が作った同一idの縦列を 1 つに重ねる (#1241)。
+ *
+ * `lanes:` の中身を読むのは見本を重ねるより前で、その時点では見本の縦列がまだ無い。
+ * そのため同じ id を書くと **縦列が 2 つできて、書いた幅は箱の入っていない方に付く**
+ * (実測 = `g__l` が 777 と 400 の 2 本になり、箱は 400 の方に入った)。
+ *
+ * 後から来た見本の縦列に書いた値を移し、先に作った空の方を外す。 書いた人から見れば
+ * 「id を書けば効く」 が成り立つ。
+ */
+function mergeDuplicateDeclaredLanes(
+  diagram: CdlDiagram,
+  追加した縦列: readonly DslLane[],
+): void {
+  for (const 宣言 of 追加した縦列) {
+    const { id } = 宣言;
+    const 同一idの縦列 = diagram.lanes.filter((l) => l.id === id);
+    if (同一idの縦列.length < 2) continue;
+    // 宣言 lane は parts より先に追加されるため、後から作った parts lane を残す。
+    const 残す = 同一idの縦列.at(-1);
+    if (残す === undefined) continue;
+    const 元の中心X = (残す.x ?? 0) + 残す.width / 2;
+    // 新規 lane に入れた既定値ではなく、DSL に明示された値だけを parts lane へ重ねる。
+    if (宣言.x !== undefined) 残す.x = 宣言.x;
+    if (宣言.width !== undefined) 残す.width = 宣言.width;
+    if (宣言.label !== undefined) 残す.label = 宣言.label;
+    if (宣言.contain !== undefined) 残す.contain = 宣言.contain;
+    if (宣言.lifeline !== undefined) 残す.lifeline = 宣言.lifeline;
+    const 移動X = (残す.x ?? 0) + 残す.width / 2 - 元の中心X;
+    // parts node は絶対座標を持つため、lane だけ動かすと箱が元の場所に残る。
+    for (const node of diagram.nodes) {
+      if (node.lane === id && node.posX !== undefined) node.posX += 移動X;
+    }
+    for (let i = diagram.lanes.length - 1; i >= 0; i -= 1) {
+      if (diagram.lanes[i]?.id === id && diagram.lanes[i] !== 残す) diagram.lanes.splice(i, 1);
+    }
+  }
+}
+
+/**
+ * `lanes:` で作った縦列に箱が 1 つも入らなかったら伝える (#1241)。
+ *
+ * 意図して空の縦列を置くことはあるが、その場合も「置いた」 と分かる形で知らせる方が、
+ * 書き間違いを黙って捨てるより良い。
+ */
+function reportEmptyDeclaredLanes(
+  diagram: CdlDiagram,
+  追加した縦列: readonly DslLane[],
+  onNotice?: (n: CompileNotice) => void,
+): void {
+  if (追加した縦列.length === 0) return;
+  mergeDuplicateDeclaredLanes(diagram, 追加した縦列);
+  if (!onNotice) return;
+  const 使われている = new Set(diagram.nodes.map((n) => n.lane));
+  const ある縦列 = diagram.lanes.map((l) => l.id).filter((x) => 使われている.has(x));
+  for (const { id, pos } of 追加した縦列) {
+    if (使われている.has(id)) continue;
+    onNotice({
+      kind: "lane-declared-empty",
+      actor: id,
+      line: pos?.line ?? 0,
+      message: `lanes に書いた ${truncateForMessage(id)} はどの箱も入らない縦列です (新しく作りました)`,
+      hint:
+        ある縦列.length > 0
+          ? `この図が持つ縦列 = ${ある縦列.join(" / ")}`
+          : "この図は箱の入った縦列を持ちません",
+    });
+  }
+}
+
+function applyV05Extensions(
+  diagram: CdlDiagram,
+  doc: DslDocument,
+  /** `lanes:` が新しく作った縦列。 箱が入ったかは見本を重ねた後でないと分からない (#1241) */
+  追加した縦列out?: DslLane[],
+): CdlDiagram {
   // actor の主要 node を preset 種別で回収する。 sequence / solidity は header/footer を対で生成する
   // preset で主要 node は header、 それ以外の preset は actor 名 slug がそのまま node id になる。
   //
@@ -2884,6 +5355,19 @@ function applyV05Extensions(diagram: CdlDiagram, doc: DslDocument): CdlDiagram {
       if (a.eyebrow !== undefined) node.eyebrow = a.eyebrow;
       if (a.value !== undefined) node.value = a.value;
       if (a.rows !== undefined) node.rows = a.rows;
+      // 箱の大きさを反映する (#1259)。 **animation の有無に関係なく** = 動く図専用の
+      // 組み立てだけで渡すと、同じ記法でも静止図では指定が消える。
+      //
+      // 順序図は名札 / 余白 / 足を組で作り、大きさが縦線の並びと結びつくため対象外。
+      //
+      // **幅が図に出るかは縦列との大小で決まる**。 縦列に収まれば箱だけが変わり、
+      // 縦列より広ければ縦列ごと押し広げる (実測 = ステート図の 320 は縦列 370 に収まって
+      // 図が変わらないが、拡張ステート図の 280 に対し既定 640 は縦列 330 を押し広げた)。
+      // #1260 で 1 件だけ見て「見た目に出ない」 と判断し配線を外した = 同じ誤りを繰り返さない
+      if (!isSeqLike) {
+        if (a.posW !== undefined) node.w = a.posW;
+        if (a.posH !== undefined) node.h = a.posH;
+      }
       // seq-like preset の header / footer は kind を card 固定で作る。 書いた kind を載せる
       // (#975)。 載せないと「書いたのに効かない項目」 が残り、 `rows` を書いた時は行が card に
       // 付いて画面から消える (#387、 cdl 側 Axis 67 rows-not-rendered が検知する)。
@@ -2955,6 +5439,12 @@ function applyV05Extensions(diagram: CdlDiagram, doc: DslDocument): CdlDiagram {
     injectPhasesFallback(diagram, doc);
   }
   // top-level lanes section → lane merge
+  //
+  // **書いた id がどの縦列とも合わない形を後で伝える** (#1241)。 合わない id は新しい縦列を
+  // 作るだけで、書いた幅や見出しは元の縦列に届かない。 書き間違い (`lane-idl` / 全角の
+  // `lane-Ａ`) がこの形になり、黙って捨てられていた (実測 = 幅 999 を持つ空の縦列が増え、
+  // 元の縦列は 360 のままだった)
+  const 追加した縦列: DslLane[] = 追加した縦列out ?? [];
   if (doc.lanes) {
     for (const [id, laneOpt] of Object.entries(doc.lanes)) {
       const lane = diagram.lanes.find((l) => l.id === id);
@@ -2974,6 +5464,7 @@ function applyV05Extensions(diagram: CdlDiagram, doc: DslDocument): CdlDiagram {
           contain: laneOpt.contain,
           lifeline: laneOpt.lifeline,
         });
+        追加した縦列.push(laneOpt);
       }
     }
   }
@@ -3153,8 +5644,11 @@ function compileSequenceWithAnimate(doc: DslDocument): CdlDiagram {
   // step ごとに DSL flow item に対応、 actor 名 → lane id の slugify を活用。
   const stepEdgeIds: string[] = [];
   doc.flow.forEach((s, idx) => {
-    const fromLaneId = actorIds.get(s.from) ?? s.from;
-    const toLaneId = actorIds.get(s.to) ?? s.to;
+    // 解決できない名前の矢印は落とす (#1209)。 以前は名前をそのまま lane id として使い、
+    // 存在しない lane に箱を置いた図ができていた
+    const fromLaneId = actorIds.get(s.from);
+    const toLaneId = actorIds.get(s.to);
+    if (fromLaneId === undefined || toLaneId === undefined) return;
     const stack = idx + 2;
     const fromBoxId = `s${idx}-${fromLaneId}`;
     const toBoxId = `s${idx}-${toLaneId}`;
@@ -3169,10 +5663,6 @@ function compileSequenceWithAnimate(doc: DslDocument): CdlDiagram {
       ...(s.sub ? { sub: s.sub } : {}),
       ...(s.tone ? { tone: s.tone } : {}),
       ...(s.style ? { style: s.style } : {}),
-      ...(s.guard ? { guard: s.guard } : {}),
-      ...(s.cardinality ? { cardinality: s.cardinality } : {}),
-      ...(s.labelOffsetX !== undefined ? { labelOffsetX: s.labelOffsetX } : {}),
-      ...(s.labelOffsetY !== undefined ? { labelOffsetY: s.labelOffsetY } : {}),
     });
     stepEdgeIds.push(edgeId);
   });
@@ -3183,16 +5673,27 @@ function compileSequenceWithAnimate(doc: DslDocument): CdlDiagram {
     const laneId = actorIds.get(a.name) ?? slugify(a.name);
     const footerId = `${laneId}-footer`;
     const actorW = Math.max(140, a.name.length * 22 + 52);
-    b.node(footerId, { lane: laneId, stack: footerStack, kind: "card", title: a.name, w: actorW, h: 72 });
+    // `role` を付ける (#1273)。 付けないと生命線の終わりが footer より 100 下まで伸びる
+    // (実測 = 組立て API は `y2=848`、記法は `y2=948`)。 枠の大きさは同じなので
+    // 描いた図の大きさの比較では捕まらない
+    b.node(footerId, {
+      lane: laneId,
+      stack: footerStack,
+      kind: "card",
+      title: a.name,
+      w: actorW,
+      h: 72,
+      role: "lifeline-footer",
+    });
   });
 
   // state を builder に登録
-  for (const st of doc.animate!.states) {
+  for (const st of doc.animate?.states ?? []) {
     b.state(st.name, { initial: st.initial });
   }
 
   // phase を順次注入 ... highlight / tween / set / badge / body 全反映
-  for (const p of doc.animate!.phases) {
+  for (const p of doc.animate?.phases ?? []) {
     b.phase(
       slugify(p.name) || p.name,
       {
@@ -3302,7 +5803,9 @@ function slugLookup(byName: ReadonlyMap<string, string>, wanted: string): string
 
 function compileFlow(doc: DslDocument): CdlDiagram {
   // v0.4 ... animation あり時 builder 直接経路で複数 phase 注入
-  if (doc.animate && doc.animate.phases.length > 0) {
+  // **縦列を書いた形は動きの有無に関わらず generic 経路へ** (#1263)。 動く図だけで効かせると、
+  // 同じ記法でも静止図では指定が黙って消える (実測 = 縦列 3 本のはずが 1 本になり知らせも出ない)
+  if ((doc.animate && doc.animate.phases.length > 0) || 書いた縦列に置く("flow", doc)) {
     return compileGenericWithAnimate(doc, { kind: "flow", laneId: "main", laneWidth: 400 });
   }
   // 登場人物が 0 人なら枠も作らない。 描画側の `flow()` は枠を必ず 1 つ作るため、 そのまま
@@ -3336,7 +5839,9 @@ function compileFlow(doc: DslDocument): CdlDiagram {
 
 function compileSwimlane(doc: DslDocument): CdlDiagram {
   // v0.4 ... animation あり時 builder 直接経路 (各 actor 別 lane で配置)
-  if (doc.animate && doc.animate.phases.length > 0) {
+  // **縦列を書いた形は動きの有無に関わらず generic 経路へ** (#1263)。 動く図だけで効かせると、
+  // 同じ記法でも静止図では指定が黙って消える (実測 = 縦列 3 本のはずが 1 本になり知らせも出ない)
+  if ((doc.animate && doc.animate.phases.length > 0) || 書いた縦列に置く("swimlane", doc)) {
     return compileGenericWithAnimate(doc, { kind: "swimlane", laneWidth: 400 });
   }
   // swimlane preset は lane 配置 + 自由 node/edge。
@@ -3376,10 +5881,25 @@ function compileSwimlane(doc: DslDocument): CdlDiagram {
       ...(s.sub ? { sub: s.sub } : {}),
       ...(s.tone ? { tone: s.tone } : {}),
       ...(s.style ? { style: s.style } : {}),
-      ...(s.guard ? { guard: s.guard } : {}),
-      ...(s.cardinality ? { cardinality: s.cardinality } : {}),
-      ...(s.labelOffsetX !== undefined ? { labelOffsetX: s.labelOffsetX } : {}),
-      ...(s.labelOffsetY !== undefined ? { labelOffsetY: s.labelOffsetY } : {}),
+    });
+  }
+
+  // **箱が 1 つも置けなかった時は、 登場人物をそのまま置く** (#1219)。
+  //
+  // この図種は矢印の端から箱を作るため、 矢印が 1 本も無いと箱が 0 件になり `compile` が
+  // 落ちる (実測 = 矢印を書かない図は本 Issue の前から落ちていた)。 解決できない矢印を
+  // 外すと同じ形になるので、 受け皿を置く。
+  //
+  // **1 つでも置けた時は触らない**。 矢印に出てこない登場人物にも箱を置くと、 今まで枠だけ
+  // だった所に箱が増えて既存の図の見た目が変わる (それを変えるかは別の判断)。
+  if (placedNodes.size === 0) {
+    doc.actors.forEach((a, i) => {
+      swim.node(slugify(a.name) || `n${i}`, {
+        lane: swim.laneId(a.name),
+        stack: 0,
+        kind: a.kind ?? "actor",
+        title: a.name,
+      });
     });
   }
   return swim.build();
@@ -3419,6 +5939,29 @@ function compileEr(doc: DslDocument): CdlDiagram {
   return erBuilder.build();
 }
 
+/**
+ * 状態遷移図で、どの箱を始まり / 終わりとみなすか (#1275)。
+ *
+ * **書いた値が勝つ**。 `initial:` / `final:` は記法で書けるのに 1 度も読まれておらず、
+ * 位置だけで決まっていた (実測 = 中央の箱に `final: true` を書いても、最後に書いた箱が
+ * 「最終」 になった)。
+ *
+ * 1 つも書いていなければ従来どおり位置で決める = 書かない記法の図は変わらない。
+ * 片方だけ書いた形も、書いた側だけが切り替わる。
+ */
+function 始まりと終わりの決め方(doc: DslDocument): {
+  始まり: (a: DslActor, idx: number) => boolean;
+  終わり: (a: DslActor, idx: number) => boolean;
+} {
+  const 書いた始まり = doc.actors.some((a) => a.initial === true);
+  const 書いた終わり = doc.actors.some((a) => a.final === true);
+  return {
+    始まり: (a, idx) => (書いた始まり ? a.initial === true : idx === 0),
+    終わり: (a, idx) =>
+      書いた終わり ? a.final === true : idx === doc.actors.length - 1 && doc.actors.length > 1,
+  };
+}
+
 function compileState(doc: DslDocument): CdlDiagram {
   // v0.4 ... animation あり時 builder 直接経路 (各 state を lane で配置、 transition を edge)
   if (doc.animate && doc.animate.phases.length > 0) {
@@ -3429,11 +5972,12 @@ function compileState(doc: DslDocument): CdlDiagram {
     id: slugify(doc.title),
     topic: doc.title,
   });
+  const 決め方 = 始まりと終わりの決め方(doc);
   for (let i = 0; i < doc.actors.length; i++) {
     const a = doc.actors[i]!;
-    // 初期 / 最終 は (initial) / (final) を kind 部分に書く慣習、 もしくは順序で決め打ち
-    const initial = i === 0;
-    const final = i === doc.actors.length - 1 && doc.actors.length > 1;
+    // 書いた `initial:` / `final:` が勝つ。 1 つも書いていなければ順序で決める
+    const initial = 決め方.始まり(a, i);
+    const final = 決め方.終わり(a, i);
     fsm.state({
       id: slugify(a.name) || `s${i}`,
       title: a.name,
@@ -3455,7 +5999,9 @@ function compileState(doc: DslDocument): CdlDiagram {
 
 function compileTopology(doc: DslDocument): CdlDiagram {
   // v0.4 ... animation あり時 builder 直接経路 (各 actor を別 lane に)
-  if (doc.animate && doc.animate.phases.length > 0) {
+  // **縦列を書いた形は動きの有無に関わらず generic 経路へ** (#1263)。 動く図だけで効かせると、
+  // 同じ記法でも静止図では指定が黙って消える (実測 = 縦列 3 本のはずが 1 本になり知らせも出ない)
+  if ((doc.animate && doc.animate.phases.length > 0) || 書いた縦列に置く("topology", doc)) {
     return compileGenericWithAnimate(doc, { kind: "topology", laneWidth: 460 });
   }
   // 登場人物が 0 人なら枠も作らない。 描画側の `topology()` は枠を必ず 1 つ作るため、 そのまま
@@ -3503,13 +6049,84 @@ type GenericOpts = {
   laneWidth: number;
 };
 
+/**
+ * 後ろへ戻る矢印か (#1260)。
+ *
+ * 状態の図は、後ろの状態へ戻る矢印を **箱の上を回して** 描く (`routing: "back-detour"`)。
+ * 組立て API 側がそうしており、記法側で付けないと **描いた図の高さが変わる**
+ * (実測 = viewBox が 404 対 486 で、戻る矢印が箱の右横を回っていた)。
+ *
+ * 判定は並び順。 指す先が指す元より前にあれば戻る矢印
+ * (実測 = `stateMachine()` は c -> a と c -> b の 2 本だけに付け、a -> b と b -> c には付けない)。
+ *
+ * **状態の図だけに付ける**。 他の図種の組立て API は付けない (実測 = `er()` は付けなかった)。
+ */
+function 後ろへ戻る矢印か(
+  kind: GenericKind,
+  fromId: string,
+  toId: string,
+  箱の並び: ReadonlyMap<string, number>,
+): boolean {
+  if (kind !== "state") return false;
+  const 元 = 箱の並び.get(fromId);
+  const 先 = 箱の並び.get(toId);
+  if (元 === undefined || 先 === undefined) return false;
+  return 先 < 元;
+}
+
+/**
+ * 縦列を選べる図種 (#1263)。
+ *
+ * 縦列を **箱を並べるための入れ物** として使う図種だけを許す。 順序図と solidity は
+ * 縦列がそのまま生命線として描かれる骨格なので許さない (#1248 の判断はこちらに当たる)。
+ *
+ * `er` / `state` / `class` は「1 縦列 1 箱」 が図の読み方そのもの (表 / 状態 / クラスが
+ * 横に並ぶ) なので、2 つの箱を同じ縦列へ入れられる形にはしない。
+ */
+const 縦列を選べる図種: ReadonlySet<GenericKind> = new Set(["flow", "topology", "swimlane"]);
+
+/**
+ * 書いた縦列に箱を置く形か (#1263)。
+ *
+ * **全ての箱が縦列を書いた時だけ** この形にする。 一部だけ書いた形は、書かなかった箱の
+ * 行き先を決める規則が要る (既定の縦列に集める / 自分の縦列を作る) が、どちらも
+ * 書いた人の意図と一致する保証が無い。 混ざった形は `reportLaneMixed` が知らせる。
+ *
+ * 見本 (parts) は縦列を張替え先として使うため、この判定からは外す。
+ */
+function 書いた縦列に置く(kind: GenericKind, doc: DslDocument): boolean {
+  if (!縦列を選べる図種.has(kind)) return false;
+  const 対象 = doc.actors.filter((a) => a.partId === undefined);
+  return 対象.length > 0 && 対象.every((a) => a.lane !== undefined);
+}
+
 function compileGenericWithAnimate(doc: DslDocument, opts: GenericOpts): CdlDiagram {
   const b = diagram(slugify(doc.title), { topic: doc.title });
   const { kind, laneWidth } = opts;
 
   // lane / node 配置 ... preset kind に応じて切替
   const actorToNodeId = new Map<string, string>();
-  if (kind === "flow" || kind === "topology") {
+  if (書いた縦列に置く(kind, doc)) {
+    // **書いた縦列に置く** (#1263)。 縦列を並べるための入れ物として使う図種でだけ効く。
+    // 縦列は書かれた順に作り、同じ縦列の箱は書かれた順に積む
+    const 並び: string[] = [];
+    for (const a of doc.actors) {
+      const lid = a.lane;
+      if (lid !== undefined && !並び.includes(lid)) 並び.push(lid);
+    }
+    for (const lid of 並び) {
+      b.lane(lid, { width: laneWidth, ...(kind === "topology" ? { contain: true } : {}) });
+    }
+    const 積んだ数 = new Map<string, number>();
+    doc.actors.forEach((a, idx) => {
+      const id = slugify(a.name) || `n${idx}`;
+      actorToNodeId.set(a.name, id);
+      const lid = a.lane!;
+      const stack = 積んだ数.get(lid) ?? 0;
+      積んだ数.set(lid, stack + 1);
+      b.node(id, { lane: lid, stack, kind: a.kind, title: a.name });
+    });
+  } else if (kind === "flow" || kind === "topology") {
     // 1 lane に全 actor を縦 stack
     const lid = opts.laneId ?? "main";
     b.lane(lid, { width: laneWidth, label: doc.title, ...(kind === "topology" ? { contain: true } : {}) });
@@ -3520,14 +6137,24 @@ function compileGenericWithAnimate(doc: DslDocument, opts: GenericOpts): CdlDiag
     });
   } else {
     // swimlane / er / state ... actor ごとに 1 lane (横並び)
+    //
+    // **見出しを付けるのは `swimlane` だけ** (#1241)。 3 図種とも箱を 1 つずつ持ち、
+    // その箱が既に名前を描く。 縦列にも同じ名前を渡すと **同じ字が縦に 2 つ並ぶ**
+    // (実測 = 描いた絵に `Alpha` `Beta` が 2 度出る)。
+    //
+    // `swimlane` は縦列そのものが「誰の担当か」 を読ませる図なので見出しが要る。
+    // `er` の縦列は表を並べるための入れ物、 `state` の縦列は状態を並べるための入れ物で、
+    // どちらも読む人に見せる意味を持たない (組立て API 側も見出しを空のまま置く)。
+    const 見出しを付ける = kind === "swimlane";
+    const 決め方2 = 始まりと終わりの決め方(doc);
     doc.actors.forEach((a, idx) => {
       const lid = `lane-${slugify(a.name) || idx}`;
-      b.lane(lid, { width: laneWidth, label: a.name });
+      b.lane(lid, { width: laneWidth, ...(見出しを付ける ? { label: a.name } : {}) });
       const id = slugify(a.name) || `n${idx}`;
       actorToNodeId.set(a.name, id);
       // er は entity、 state は initial/final marker、 swimlane はそのまま actor
-      const isInitial = kind === "state" && idx === 0;
-      const isFinal = kind === "state" && idx === doc.actors.length - 1 && doc.actors.length > 1;
+      const isInitial = kind === "state" && 決め方2.始まり(a, idx);
+      const isFinal = kind === "state" && 決め方2.終わり(a, idx);
       b.node(id, {
         lane: lid,
         stack: 0,
@@ -3540,10 +6167,20 @@ function compileGenericWithAnimate(doc: DslDocument, opts: GenericOpts): CdlDiag
   }
 
   // edge ... flow の各 step を edge として登録
+  //
+  // 解決できない名前の矢印は **落とす** (#1209)。 以前は名前をそのまま id として使っており、
+  // 存在しない node を指す図ができて描画の直前で落ちていた
+  // (実測 = `unknown-ref: edge "e0-v-c" の from "v" が node に存在しません`)。
+  // 書いた人には `flow-actor-missing` の知らせが届く。
+  // 箱の並び。 後ろへ戻る矢印を見分けるために使う (#1260)
+  const 箱の並び = new Map([...actorToNodeId.values()].map((id, i) => [id, i]));
   const edgeIds: string[] = [];
   doc.flow.forEach((s, idx) => {
-    const fromId = actorToNodeId.get(s.from) ?? slugify(s.from);
-    const toId = actorToNodeId.get(s.to) ?? slugify(s.to);
+    // 名前は入口で正規化済 (`canonicalizeFlowActors`)。 ここで slug を受け直すと、
+    // 動きを書いていない図の組み立てと扱いが割れる
+    const fromId = actorToNodeId.get(s.from);
+    const toId = actorToNodeId.get(s.to);
+    if (fromId === undefined || toId === undefined) return;
     const edgeId = `e${idx}-${fromId}-${toId}`;
     // ER preset では cardinality を label に "(1:N)" 形式で併記、 他 preset は label そのまま。
     const labelWithCard =
@@ -3555,24 +6192,21 @@ function compileGenericWithAnimate(doc: DslDocument, opts: GenericOpts): CdlDiag
     b.edge(fromId, toId, {
       id: edgeId,
       label: labelWithCard,
+      ...後ろへ戻る矢印か(kind, fromId, toId, 箱の並び) ? { routing: "back-detour" as const } : {},
       ...(s.sub ? { sub: s.sub } : {}),
       ...(s.tone ? { tone: s.tone } : {}),
       ...(s.style ? { style: s.style } : {}),
-      ...(s.guard ? { guard: s.guard } : {}),
-      ...(s.cardinality ? { cardinality: s.cardinality } : {}),
-      ...(s.labelOffsetX !== undefined ? { labelOffsetX: s.labelOffsetX } : {}),
-      ...(s.labelOffsetY !== undefined ? { labelOffsetY: s.labelOffsetY } : {}),
     });
     edgeIds.push(edgeId);
   });
 
   // state 登録
-  for (const st of doc.animate!.states) {
+  for (const st of doc.animate?.states ?? []) {
     b.state(st.name, { initial: st.initial });
   }
 
   // phase 注入
-  for (const p of doc.animate!.phases) {
+  for (const p of doc.animate?.phases ?? []) {
     b.phase(
       slugify(p.name) || p.name,
       {
@@ -3643,6 +6277,9 @@ function resolveHighlightGeneric(
 
 // ─── helpers ──────────────────────────────────────────────────
 
+/** id の長さの上限。 `slugify` が切る幅で、 尾を付ける側もこの値から余地を決める (#1220) */
+const ID_MAX = 64;
+
 function slugify(s: string): string {
   return (
     s
@@ -3650,7 +6287,7 @@ function slugify(s: string): string {
       .normalize("NFKC")
       .replace(/[^a-z0-9ぁ-んァ-ヶ一-龯\-_]+/g, "-")
       .replace(/^-+|-+$/g, "")
-      .slice(0, 64) || "n"
+      .slice(0, ID_MAX) || "n"
   );
 }