@cardenelabs/dragon 0.26.0 → 0.28.0

package/src/compile.ts

@@ -150,6 +150,18 @@ export type CompileNotice = {
     | "direction-not-honored"
     // `倍率:` を書いた見本が、同じ名前の状態も持っていた (#1026)
     | "scale-reserved"
+    // 部品に書いた色が効かない (#1973)。 色番号を入れる状態を 1 つも持たない部品に色番号を
+    // 書いた時と、色番号でなく色の名前を書いた時
+    | "part-color-ignored"
+    // 部品に、部品が持たない状態の名前で値を書いた (#1976)。 綴り違いと、外した欄 (`nodes`) を書いた時
+    | "part-state-missing"
+    // 部品へ引いた矢印を、部品の中のどの要素にも繋げず外した (#1979)。 要素が 2 つ以上あり名指しが無い時、
+    // 名指しした要素が部品に無い時、部品を取り込まなかった時
+    | "part-edge-dropped"
+    // 矢印に部品の要素の名指し (`fromPartNode` / `toPartNode`) を書いたが、その端が部品でない (#1979)
+    | "part-node-ignored"
+    // 縦列に置くはずの部品が他の箱の位置の基準になっていて、縦列に置けなかった (#1980)
+    | "part-lane-ignored"
     // 値で描く図 (`pie` / `bar` / `line`) で値を読めなかった (#1154)
     | "chart-value-unreadable"
     // 同上で矢印を書いた。 これらの図は関係を描けない (#1154)
@@ -182,10 +194,14 @@ export type CompileNotice = {
     | "event-target-missing"
     // 順序図で面に種類を書いたが、板は名前と呼び名しか描かない (#1466)
     | "actor-kind-not-honored"
-    // 箱の中の小さな箱に位置を書いたが、その名前の箱が図に無かった (#1466)
-    | "sub-node-not-found"
     // 順序図の言づてに、板が描かない飾り (色味 / 添え字 / 寄せ) を書いた (#1466)
-    | "message-option-not-honored";
+    | "message-option-not-honored"
+    // 位置のずらし (`pos` / `offsetX` / `offsetY`) を載せる相手が無いか、書いた量だけ動かせなかった (#1971)
+    | "position-offset-ignored"
+    // 組 (`groups:`) が束ねる縦列が図に無い (#1972)
+    | "group-lane-missing"
+    // 組が束ねる縦列の間に、束ねない縦列を挟んでいる (#1972)
+    | "group-lanes-apart";
   /** 対象の名前。 光らせる相手なら書かれた指定そのまま */
   actor: string;
   /** 書かれていた行 */
@@ -226,7 +242,7 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
       diagram = compileSequence(doc);
       break;
     case "flow":
-      diagram = compileFlow(doc);
+      diagram = compileFlow(doc, opts?.partsCatalog);
       break;
     case "swimlane":
       diagram = compileSwimlane(doc);
@@ -306,8 +322,11 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // edge と本文の行の対応は表に集めてから 1 edge = 1 回で知らせる (#998)。 経路ごとに
   // その場で呼ぶと、 同じ edge に別の行を 2 度知らせることになる。
   const edgeSourceLines = opts?.onEdgeSource ? new Map<string, number>() : undefined;
-  applyEdgeInlineOptions(diagram, doc, edgeSourceLines);
-  applyGroupContainers(diagram, doc);
+  // 矢印ごとに、どの行から来たか。 部品へ引いた矢印を部品の要素へ繋ぎ直す時に、その行に書いた
+  // 名指し (`toPartNode`) を読む (#1979)。 矢印の id は部品の取り込みで変わらない
+  const 矢印の行 = new Map<string, DslStep>();
+  applyEdgeInlineOptions(diagram, doc, edgeSourceLines, 矢印の行, opts?.partsCatalog);
+  const 作った組の枠 = applyGroupContainers(diagram, doc);
   applyNodeTones(diagram, doc);
   // 光らせる相手が実在するかを確かめる。 id への解決は図種ごとに違うが、 名前が居るか
   // 居ないかは記述だけで決まるので 1 か所で見る
@@ -317,19 +336,21 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // 両端が同じ矢印を伝える (#1227)。 落とす前の `flow` を見る
   // 静止した `type: flow` で書いた矢印の端が使われないことを伝える (#1269)。
   // 自分へ戻る形と居ない名前を指す形は既に落ちた後の `doc` を見る = 上の 2 件と重ねない
-  reportFlowEndpointNotHonored(doc, 分けた.元の名前, opts?.onNotice);
+  reportFlowEndpointNotHonored(doc, 分けた.元の名前, opts?.onNotice, opts?.partsCatalog);
   reportLaneNotHonored(書いたまま, opts?.onNotice);
   reportActorKindNotHonored(書いたまま, opts?.onNotice);
   reportMessageOptionNotHonored(書いたまま, opts?.onNotice);
+  reportFlowOffsetNotHonored(書いたまま, opts?.onNotice);
   reportDocEyebrowNotHonored(書いたまま, opts?.onNotice);
   reportDirectionNotHonored(書いたまま, opts?.onNotice);
   reportDrawNotHonored(書いたまま, opts?.onNotice);
   reportChartFieldsNotHonored(書いたまま, opts?.onNotice);
   reportAxesNotHonored(書いたまま, opts?.onNotice);
+  reportPartNodeNotHonored(書いたまま, 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, opts?.onNotice);
+  applyCanvasPivotPositions(diagram, placed);
   // CAR-1657 = parts kind actor を merge (opts.partsCatalog 経由)、 applyV05Extensions 後段で実行
   const 追加した縦列: DslLane[] = [];
   const extended = applyV05Extensions(diagram, placed, 追加した縦列);
@@ -345,6 +366,7 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
     opts?.partsCatalog,
     opts?.onNotice,
     inheritedDerivedSourceLines,
+    矢印の行,
   );
   // 箱が 1 つも入らなかった縦列を伝える (#1241)。
   //
@@ -385,6 +407,7 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
    * どれかを見落とす (`injectStaticPhase` / `materializeStates` と同じ理由)。
    */
   if (doc.reveal !== undefined) merged.edgeReveal = doc.reveal;
+  if (doc.relations !== undefined) merged.relationFocus = doc.relations;
   // 語の欄が状態を読むとき、その状態には記法の語が入っている。 図の語へ直す (#1201)
   語の状態を図の語へ直す(merged);
   // きっかけ形の値を段の時計を読む式へ畳む (#1161 段 2)。 **値を載せるより先に呼ぶ** =
@@ -425,6 +448,8 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
     const ownFormulas = doc.formulas.map((formula) => ({
       id: formula.id,
       expression: formula.expression,
+      // 名札は操作部が式の名前として描く (#1916、cdl#853)。 書かなければ欄ごと付けない
+      ...(formula.label !== undefined ? { label: formula.label } : {}),
       line: formula.pos?.line ?? 0,
     }));
     /*
@@ -484,7 +509,11 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
         });
       }
       if (解けない) continue;
-      載せる式.push({ id: formula.id, expression: formula.expression });
+      載せる式.push({
+        id: formula.id,
+        expression: formula.expression,
+        ...(formula.label !== undefined ? { label: formula.label } : {}),
+      });
       先に書かれた式.add(formula.id);
     }
     if (載せる式.length > 0) merged.formulas = 載せる式;
@@ -551,6 +580,12 @@ export function compileToCdl(doc: DslDocument, opts?: CompileToCdlOpts): CdlDiag
   // 20 か所以上あり、そのどれに足しても残りが取り残される
   配色と縞を当てる(merged, doc);
   静止した図の焦点を外す(merged, doc);
+  // 位置のずらしは **配置に効く欄を全て載せた後** に当てる (#1971)。 縦列の幅や視点の間隔を
+  // 足す前に測ると、後から足された分だけ狙いがずれる
+  applyLayoutOffsets(merged, doc, opts?.onNotice);
+  // 組の枠は **縦列の位置が全て決まった後** に置く (#1972)。 位置のずらしより前に置くと、
+  // ずらした縦列から枠が離れる
+  applyGroupFrames(merged, doc, 作った組の枠, opts?.onNotice);
   return merged;
 }
 
@@ -907,7 +942,7 @@ function reportDrawNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) =>
  * 段の `draw:` が効く図種 (#1312 / #1314 / #1318)。
  *
  * **語と図種の対応表から導く** (`DRAW_TARGETS`)。 一覧を写すと、語を足した時に片方だけ
- * 古いまま残る。 描画側 (`cdl` の `CdlPhase.draw`) が対応する 8 種と一致する。
+ * 古いまま残る。 描画側 (`cdl` の `DRAW_KINDS`) が対応する種別と一致する。
  */
 const DRAWABLE_DOC_TYPES: ReadonlySet<PresetType> = new Set<PresetType>(DRAW_TARGETS.values());
 
@@ -946,7 +981,8 @@ function reportLaneMixed(doc: DslDocument, onNotice: (n: CompileNotice) => void)
  * ## 鎖にすること自体は変えない
  *
  * 線形の流れを描く図種なので、鎖にするのは仕様。 書いた端どおりに繋ぎたい形は
- * 箱に `lane:` を書けば別の経路へ回る (#1266)。 知らせの hint でそれを案内する。
+ * 箱に `lane:` を書くか (#1266)、`direction:` を書けば別の経路へ回る (#1494)。 知らせの hint で
+ * それを案内する。 `direction: 縦` を先に挙げるのは、箱ごとに書かずに済み、並びも鎖の時と変わらないため。
  *
  * ## 偶然一致する形では知らせない
  *
@@ -964,6 +1000,8 @@ function reportFlowEndpointNotHonored(
   doc: DslDocument,
   元の名前: Map<string, string>,
   onNotice?: (n: CompileNotice) => void,
+  /** 鎖に並べない部品を決める一覧 (#1987)。 `compileFlow` に渡したものと同じ */
+  partsCatalog?: Record<string, CdlDiagram>,
 ): void {
   if (!onNotice) return;
   if (!鎖でつなぐ形か(doc)) return;
@@ -975,8 +1013,9 @@ function reportFlowEndpointNotHonored(
   // 鎖が作る組を集める。 登場人物が 1 人以下なら矢印が 1 本も出来ないので、
   // 書いた矢印は全て使われない扱いになる
   const 鎖の組 = new Set<string>();
-  doc.actors.forEach((a, i) => {
-    const 次 = doc.actors[i + 1];
+  const 並び = 鎖に並べる登場人物(doc, partsCatalog);
+  並び.forEach((a, i) => {
+    const 次 = 並び[i + 1];
     if (次 === undefined) return;
     鎖の組.add(`${a.name}\u0000${次.name}`);
   });
@@ -987,7 +1026,7 @@ function reportFlowEndpointNotHonored(
       actor: 書いた名前(s.from),
       line: s.pos.line,
       message: `"${truncateForMessage(書いた名前(s.from))} -> ${truncateForMessage(書いた名前(s.to))}" の端は使われません (type: flow は登場人物を書いた順に繋ぎます)`,
-      hint: "書いた端どおりに繋ぐには、箱に lane: を書いてください (縦列を書いた形は書いた端がそのまま矢印になります)",
+      hint: "書いた端どおりに繋ぐには、direction: 縦 を書くか箱に lane: を書いてください (向きか縦列を書いた形は書いた端がそのまま矢印になります)",
     });
   }
 }
@@ -1039,6 +1078,10 @@ function reportMessageOptionNotHonored(doc: DslDocument, onNotice?: (n: CompileN
       s.tone !== undefined ? "色味" : "",
       s.sub !== undefined ? "添え字" : "",
       s.side !== undefined ? "寄せ" : "",
+      // 名前のずらしも板には載せる先が無い (#1971)。 位置のずらし (`pos`) は名前のずらしに足す欄なので同じ扱い
+      s.layoutPos !== undefined || s.labelOffsetX !== undefined || s.labelOffsetY !== undefined
+        ? "名前のずらし"
+        : "",
     ].filter((x) => x !== "");
     if (効かない.length === 0) continue;
     onNotice({
@@ -1051,6 +1094,28 @@ function reportMessageOptionNotHonored(doc: DslDocument, onNotice?: (n: CompileN
   }
 }
 
+/**
+ * 名前の無い矢印に書いた位置のずらしを知らせる (#1971)。
+ *
+ * 矢印の位置のずらしは名前をずらす欄に足す。 名前が無い矢印では動くものが無く、書いても図は
+ * 変わらない。 順序図の板は `reportMessageOptionNotHonored` が知らせるので、ここでは見ない。
+ */
+function reportFlowOffsetNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
+  if (!onNotice) return;
+  if (doc.type === "sequence" || doc.type === "solidity") return;
+  for (const s of doc.flow) {
+    if (s.layoutPos === undefined) continue;
+    if (s.label !== undefined && s.label.trim() !== "") continue;
+    onNotice({
+      kind: "position-offset-ignored",
+      actor: s.from,
+      line: s.pos?.line ?? 0,
+      message: `${s.from} -> ${s.to} の位置のずらしは、名前の無い矢印では動かすものがありません`,
+      hint: "矢印の位置のずらしは名前をずらします。 名前を書くか、ずらしを外す",
+    });
+  }
+}
+
 function reportActorKindNotHonored(doc: DslDocument, onNotice?: (n: CompileNotice) => void): void {
   if (!onNotice) return;
   if (doc.type !== "sequence" && doc.type !== "solidity") return;
@@ -1068,7 +1133,13 @@ function reportActorKindNotHonored(doc: DslDocument, onNotice?: (n: CompileNotic
        */
       doc.type === "sequence" && a.kindWritten !== false && a.kind !== undefined ? "種類" : "",
       a.posW !== undefined || a.posH !== undefined ? "大きさ" : "",
-      a.posX !== undefined || a.posY !== undefined || a.posRel !== undefined ? "位置" : "",
+      a.posX !== undefined ||
+      a.posY !== undefined ||
+      a.posRel !== undefined ||
+      // 位置のずらし (#1971)。 板は面ごとの箱を持たないので動かす相手が無い
+      a.layoutPos !== undefined
+        ? "位置"
+        : "",
       a.rows !== undefined ? "行" : "",
       a.tone !== undefined ? "色" : "",
       a.eyebrow !== undefined ? "小見出し" : "",
@@ -1789,6 +1860,309 @@ function withPositions(
   return probe;
 }
 
+/** ずらしを当てる相手 1 つ。 狙いは配置後の位置 (箱は中心、縦列は左上) */
+type ずらしの相手 = {
+  名前: string;
+  line: number;
+  箱: { id: string; 狙いX: number; 狙いY: number }[];
+  縦列: { id: string; 狙いX: number; 狙いY: number }[];
+  /** 縦列に書いたずらしの相手なら、その縦列の id */
+  ずらした縦列?: string;
+};
+
+/**
+ * 書いた位置のずらし (JSON の `pos` / 記法の `offsetX` / `offsetY`) を、配置後の位置に足して置き直す (#1971)。
+ *
+ * **最後の図の上で置き直す**。 配置は縦列の間隔や視点の間隔を足した後でないと決まらず、途中の
+ * 図で測ると、後から足される間隔の分だけ狙いがずれる。
+ *
+ * 手順は 3 つ。
+ *
+ * 1. 1 度配置して、ずらす箱の中心と縦列の左上を測る
+ * 2. 狙い (測った位置 + ずらし) を `posX` / `posY` に書いてもう 1 度配置する
+ * 3. 狙いからずれた分を足して直し (最大 2 回)、それでも 1 を超えてずれる相手は固定を戻して知らせる
+ *
+ * **縦列は 1 本でもずらすなら全ての縦列を固定する**。 1 本だけ固定すると、残りの縦列が左端から
+ * 詰め直されて崩れる (実測 = 3 本のうち最初を動かすと 2 本目が 0 に来た)。 固定する位置と大きさは
+ * 配置後の値なので、ずらさない縦列の配置は変わらない (実測 = 6 図種で一致)。
+ *
+ * **ずらした縦列の箱も同じ量で固定し、他の箱は動いたら元の位置に留める**。 縦列を固定しただけでは、
+ * 中の箱は縦列の並ぶ向きにしか付いて来ず (`topology` / `c4` は縦列自身も縦に 32 ずれた)、最初の
+ * 縦列を縦にずらすと他の縦列の箱まで動く (実測)。 動いた箱を留めるのは手順 3 の直し。
+ *
+ * **近すぎる箱を押し下げるのは止めない**。 ずらした箱に同じ縦列の箱が近づくと、描画側が間隔を保つよう
+ * そちらを動かす (実測 = 静止した flow で下の箱が 100 下がった)。 これは描画側の規則で、ずらした箱
+ * 自身は狙いに置かれる。
+ *
+ * ずらしを持つ相手が 1 つも無い図は何もしない = 配置を 1 度も計算しない。
+ */
+function applyLayoutOffsets(
+  diagram: CdlDiagram,
+  doc: DslDocument,
+  onNotice?: (notice: CompileNotice) => void,
+): void {
+  // `mind` は放射に描けない欄として「配置のずらし」 を既に知らせる (`放射で描けない欄の名前`)。 2 度知らせない
+  const ずらす箱 =
+    doc.type === "mind" ? [] : doc.actors.filter((a) => a.layoutPos !== undefined);
+  const ずらす縦列 = Object.entries(doc.lanes ?? {}).filter(([, l]) => l.layoutPos !== undefined);
+  if (ずらす箱.length === 0 && ずらす縦列.length === 0) return;
+  // 順序図の板は面ごとの箱を持たない。 効かないことは `reportActorKindNotHonored` が伝える
+  if (doc.type === "sequence" || doc.type === "solidity") return;
+
+  const 前 = layout(diagram);
+  const 箱の配置 = new Map(前.nodes.map((n) => [n.id, n] as const));
+  const 縦列の配置 = new Map(前.lanes.map((l) => [l.id, l] as const));
+  const 相手たち: ずらしの相手[] = [];
+  const 縦列のずらし = new Map<string, { x: number; y: number }>();
+  /** 箱のずらしだけの狙い (縦列のずらしを足さない)。 縦列をずらす図で、ずらさない箱の基準を取るのに使う */
+  const 箱だけの狙い = new Map<string, { x: number; y: number }>();
+
+  for (const [id, lane] of ずらす縦列) {
+    const laid = 縦列の配置.get(id);
+    const d = lane.layoutPos!;
+    if (!laid) {
+      onNotice?.({
+        kind: "position-offset-ignored",
+        actor: id,
+        line: lane.pos?.line ?? 0,
+        message: `縦列 "${id}" の位置のずらしを載せる縦列が図にありません (type: ${doc.type})`,
+        hint: "縦列を作る図種で書くか、ずらしを外す",
+      });
+      continue;
+    }
+    縦列のずらし.set(id, d);
+    相手たち.push({
+      名前: id,
+      line: lane.pos?.line ?? 0,
+      // 縦列を固定しただけでは、中の箱は縦列の並ぶ向きにしか付いて来ない (実測 = flow の縦列を
+      // 右へ 120、下へ 40 ずらすと、見出しは両方動き箱は右へ 120 だけ動いた)。 箱も同じ量で固定する
+      箱: diagram.nodes.flatMap((n) => {
+        const 箱laid = n.lane === id ? 箱の配置.get(n.id) : undefined;
+        return 箱laid ? [{ id: n.id, 狙いX: 箱laid.cx + d.x, 狙いY: 箱laid.cy + d.y }] : [];
+      }),
+      縦列: [{ id, 狙いX: (laid.x ?? 0) + d.x, 狙いY: (laid.y ?? 0) + d.y }],
+      ずらした縦列: id,
+    });
+  }
+
+  for (const a of ずらす箱) {
+    const d = a.layoutPos!;
+    // 見本は `{名前}__{元の id}` で重なる。 箱と縦列を見本 1 つ分まとめて動かす
+    const 前置き = `${a.name}__`;
+    const 箱 =
+      a.partId !== undefined
+        ? diagram.nodes.filter((n) => n.id.startsWith(前置き))
+        : diagram.nodes.filter((n) => n.id === slugify(a.name));
+    const 縦列 = a.partId !== undefined ? diagram.lanes.filter((l) => l.id.startsWith(前置き)) : [];
+    if (箱.length === 0) {
+      onNotice?.({
+        kind: "position-offset-ignored",
+        actor: a.name,
+        line: a.pos?.line ?? 0,
+        message: `"${truncateForMessage(a.name)}" の位置のずらしを載せる箱が図にありません (type: ${doc.type})`,
+        hint: "箱を描く図種で書くか、ずらしを外す",
+      });
+      continue;
+    }
+    相手たち.push({
+      名前: a.name,
+      line: a.pos?.line ?? 0,
+      箱: 箱.map((n) => {
+        const laid = 箱の配置.get(n.id)!;
+        箱だけの狙い.set(n.id, { x: laid.cx + d.x, y: laid.cy + d.y });
+        // 箱を固定すると縦列を動かしても付いて来ないので、縦列のずらしも狙いに足す
+        const 列 = 縦列のずらし.get(n.lane);
+        return { id: n.id, 狙いX: laid.cx + d.x + (列?.x ?? 0), 狙いY: laid.cy + d.y + (列?.y ?? 0) };
+      }),
+      縦列: 縦列.map((l) => {
+        const laid = 縦列の配置.get(l.id)!;
+        return { id: l.id, 狙いX: (laid.x ?? 0) + d.x, 狙いY: (laid.y ?? 0) + d.y };
+      }),
+    });
+  }
+  if (相手たち.length === 0) return;
+
+  // 固定を戻せるよう、書き換える前の欄を控える
+  const 元の箱 = new Map(diagram.nodes.map((n) => [n.id, { posX: n.posX, posY: n.posY }] as const));
+  const 元の縦列 = new Map(
+    diagram.lanes.map((l) => [l.id, { posX: l.posX, posY: l.posY, posW: l.posW, posH: l.posH }] as const),
+  );
+  const 箱の狙い = new Map<string, { x: number; y: number }>();
+  const 縦列の狙い = new Map<string, { x: number; y: number }>();
+  for (const t of 相手たち) {
+    for (const b of t.箱) 箱の狙い.set(b.id, { x: b.狙いX, y: b.狙いY });
+    for (const l of t.縦列) 縦列の狙い.set(l.id, { x: l.狙いX, y: l.狙いY });
+  }
+  const 縦列を固定する = 縦列の狙い.size > 0;
+
+  /**
+   * 縦列をずらす図で、ずらさない箱を留める位置。
+   *
+   * 描画側は箱を並べ始める高さを最初の縦列に合わせるので、最初の縦列を縦にずらすと固定しない箱が
+   * 全て一緒に動く (実測 = 3 本のうち最初の縦列を 40 下げると他の縦列の箱も 40 下がり、2 本目と
+   * 3 本目を下げても動かない)。 箱のずらしだけを当てた配置を基準に取り、そこから動いた箱をその位置に
+   * 留める。 基準に箱のずらしを含めるのは、近すぎる箱の押し下げを残すため。
+   */
+  const 留める位置 = new Map<string, { x: number; y: number }>();
+  if (縦列を固定する) {
+    let 基準 = 前;
+    if (箱だけの狙い.size > 0) {
+      for (const node of diagram.nodes) {
+        const 狙い = 箱だけの狙い.get(node.id);
+        if (!狙い) continue;
+        node.posX = 狙い.x;
+        node.posY = 狙い.y;
+      }
+      基準 = layout(diagram);
+      for (const node of diagram.nodes) {
+        if (!箱だけの狙い.has(node.id)) continue;
+        const 元 = 元の箱.get(node.id)!;
+        node.posX = 元.posX;
+        node.posY = 元.posY;
+      }
+    }
+    const 基準の箱 = new Map(基準.nodes.map((n) => [n.id, n] as const));
+    // 縦列と一緒に動かす箱は、押し下げを含む基準の位置から縦列のずらしだけ動かす
+    for (const t of 相手たち) {
+      const d = t.ずらした縦列 === undefined ? undefined : 縦列のずらし.get(t.ずらした縦列);
+      if (!d) continue;
+      for (const b of t.箱) {
+        const n = 基準の箱.get(b.id);
+        if (!n || 箱だけの狙い.has(b.id)) continue;
+        箱の狙い.set(b.id, { x: n.cx + d.x, y: n.cy + d.y });
+      }
+    }
+    for (const n of 基準.nodes) {
+      if (!箱の狙い.has(n.id)) 留める位置.set(n.id, { x: n.cx, y: n.cy });
+    }
+  }
+  /** 基準から動いたので固定した、ずらさない箱 */
+  const 留めた箱 = new Set<string>();
+
+  // 手順 2。 縦列を固定する時は、ずらさない縦列も配置後の位置と大きさで固定する
+  const 書く = (直し: ReadonlyMap<string, { x: number; y: number }>): void => {
+    if (縦列を固定する) {
+      for (const lane of diagram.lanes) {
+        const laid = 縦列の配置.get(lane.id);
+        if (!laid) continue;
+        const 狙い = 縦列の狙い.get(lane.id) ?? { x: laid.x ?? 0, y: laid.y ?? 0 };
+        const 差 = 直し.get(`lane:${lane.id}`) ?? { x: 0, y: 0 };
+        lane.posX = 狙い.x - 差.x;
+        lane.posY = 狙い.y - 差.y;
+        lane.posW = laid.width;
+        lane.posH = laid.height;
+      }
+    }
+    for (const node of diagram.nodes) {
+      const 狙い = 箱の狙い.get(node.id);
+      const 留める = 留めた箱.has(node.id) ? 留める位置.get(node.id) : undefined;
+      if (!狙い && !留める) continue;
+      const 差 = 直し.get(狙い ? `node:${node.id}` : `keep:${node.id}`) ?? { x: 0, y: 0 };
+      node.posX = (狙い ?? 留める)!.x - 差.x;
+      node.posY = (狙い ?? 留める)!.y - 差.y;
+    }
+  };
+  /** 狙いと実際の差。 縦列を固定する時は、ずらさない縦列と箱も元の位置に居るかを見る */
+  const 測る = (): Map<string, { x: number; y: number }> => {
+    const 後 = layout(diagram);
+    const 差 = new Map<string, { x: number; y: number }>();
+    for (const n of 後.nodes) {
+      const 狙い = 箱の狙い.get(n.id);
+      if (狙い) 差.set(`node:${n.id}`, { x: n.cx - 狙い.x, y: n.cy - 狙い.y });
+      const 留める = 留める位置.get(n.id);
+      if (留める) 差.set(`keep:${n.id}`, { x: n.cx - 留める.x, y: n.cy - 留める.y });
+    }
+    if (縦列を固定する) {
+      for (const l of 後.lanes) {
+        const laid = 縦列の配置.get(l.id);
+        if (!laid) continue;
+        const 狙い = 縦列の狙い.get(l.id) ?? { x: laid.x ?? 0, y: laid.y ?? 0 };
+        差.set(`lane:${l.id}`, { x: (l.x ?? 0) - 狙い.x, y: (l.y ?? 0) - 狙い.y });
+      }
+    }
+    return 差;
+  };
+  const ずれた = (差: { x: number; y: number } | undefined): boolean =>
+    差 !== undefined && (Math.abs(差.x) > PLACEMENT_TOLERANCE || Math.abs(差.y) > PLACEMENT_TOLERANCE);
+
+  const 直し = new Map<string, { x: number; y: number }>();
+  書く(直し);
+  let 差 = 測る();
+  // 手順 3。 狙いからの差を書いた位置から引いて置き直す。 固定した相手の差は図種ごとに一定なので
+  // 1 度で合う。 基準から動いた箱はその回に初めて固定し、固定で出る差をもう 1 度で直す。
+  //
+  // **ずらす箱と縦列そのものの差 (`node:` / `lane:`) を直す入力は組めていない** (#1971 の実測)。
+  // 縦列だけを固定していた形では `topology` / `c4` の縦列が縦に 32 ずれたが、中の箱も固定する今の形
+  // ではずれない。 試した形 = 7 図種の箱 / 全ての縦列を 1 本ずつ / 箱の無い縦列。 実際に直すのは
+  // 留める箱 (`keep:`) で、最初の縦列を縦にずらした図が通る
+  for (let 回 = 0; 回 < 2 && [...差.values()].some(ずれた); 回++) {
+    for (const [k, v] of 差) {
+      if (!ずれた(v)) continue;
+      const id = k.slice(k.indexOf(":") + 1);
+      if (k.startsWith("keep:") && !留めた箱.has(id)) {
+        留めた箱.add(id);
+        continue;
+      }
+      const 前の直し = 直し.get(k) ?? { x: 0, y: 0 };
+      直し.set(k, { x: 前の直し.x + v.x, y: 前の直し.y + v.y });
+    }
+    書く(直し);
+    差 = 測る();
+  }
+
+  const 戻す箱 = (t: ずらしの相手): void => {
+    for (const b of t.箱) {
+      const node = diagram.nodes.find((n) => n.id === b.id)!;
+      const 元 = 元の箱.get(b.id)!;
+      node.posX = 元.posX;
+      node.posY = 元.posY;
+    }
+  };
+  const 知らせる = (t: ずらしの相手): void =>
+    onNotice?.({
+      kind: "position-offset-ignored",
+      actor: t.名前,
+      line: t.line,
+      message: `"${truncateForMessage(t.名前)}" の位置のずらしは type: ${doc.type} の図では書いた量だけ動かせません`,
+      hint: "ずらしを外すか、座標 (`位置: 300,200`) で置く",
+    });
+
+  // **ここから下の「戻して知らせる」 経路に届く入力は組めていない** (#1971 の実測)。 描画側は
+  // `posX` / `posY` を書いた箱と縦列をそのまま置き、囲いの縦列のずれも 1 度の直しで合う。 試した
+  // 形 = 大きく正と負にずらす / 図の広さを固定してその外へ出す / 7 図種の箱 / 囲いを持つ 2 図種と
+  // クラス図と横長の図の縦列。 描画側が置いた位置を動かす規則を持った時に備えて残す
+  //
+  // 縦列が 1 本でも狙いに置けないか、ずらさない箱を留められなければ、全ての固定を戻して全ての相手を
+  // 知らせる。 縦列を 1 本だけ残すと他が詰め直され、箱の狙いは縦列のずらしを含むので、縦列を戻すと
+  // 箱の狙いも崩れる
+  if ([...差].some(([k, v]) => (k.startsWith("lane:") || k.startsWith("keep:")) && ずれた(v))) {
+    for (const lane of diagram.lanes) {
+      const 元 = 元の縦列.get(lane.id);
+      if (!元) continue;
+      lane.posX = 元.posX;
+      lane.posY = 元.posY;
+      lane.posW = 元.posW;
+      lane.posH = 元.posH;
+    }
+    for (const node of diagram.nodes) {
+      if (!留めた箱.has(node.id)) continue;
+      const 元 = 元の箱.get(node.id)!;
+      node.posX = 元.posX;
+      node.posY = 元.posY;
+    }
+    for (const t of 相手たち) {
+      戻す箱(t);
+      知らせる(t);
+    }
+    return;
+  }
+  for (const t of 相手たち) {
+    if (!t.箱.some((b) => ずれた(差.get(`node:${b.id}`)))) continue;
+    戻す箱(t);
+    知らせる(t);
+  }
+}
+
 /**
  * 全図種共通の後処理で、 登場人物に書かれた色を対応する箱に載せる。
  *
@@ -1824,13 +2198,11 @@ function applyNodeTones(diagram: CdlDiagram, doc: DslDocument): void {
  * preset builder が生成した diagram に対して、 doc.actors の 4 field を絶対座標として反映する。
  * slugify で actor 名 → lane id / node id の逆引き、 posX/Y set 済 actor に対応する lane / node に
  * 座標を書込む。 未指定 actor は従来 auto layout 経路そのまま。
+ *
+ * **知らせは出さない**。 かつて `sub-node-not-found` を出していたが、 その知らせが見ていた
+ * `nodes` の欄を #1976 で外した時に出し所が消えた。 知らせる相手が戻った時に引数を足す。
  */
-function applyCanvasPivotPositions(
-  diagram: CdlDiagram,
-  doc: DslDocument,
-  // 下見 (`probe`) の呼出では渡さない = 同じ知らせが 2 度出る
-  onNotice?: (notice: CompileNotice) => void,
-): void {
+function applyCanvasPivotPositions(diagram: CdlDiagram, doc: DslDocument): void {
   for (const actor of doc.actors) {
     if (actor.partId !== undefined) continue; // parts actor は別経路 (mergePartsFromActors) で処理
     const aliasSlug = slugify(actor.name);
@@ -1853,45 +2225,6 @@ function applyCanvasPivotPositions(
         }
       }
     }
-    // canvas pivot UX 修正 (B1) = actor.nodes[subKey] を対応 CDL node に個別反映。
-    // sub-node id pattern を actor scope 限定の 2 経路に絞る (subagent review MAJOR-1 対応、 CAR-canvas-pivot):
-    //   1. `{aliasSlug}-{subKey}` = header / footer / spacer 等 suffix
-    //   2. `{subKey}-{aliasSlug}` = sequence step box `s{N}-{aliasSlug}` 等 prefix
-    // 旧 `node.id === subKey` 完全一致 fallback は actor scope を持たず cross-actor pollution risk
-    // (別 actor が保有する同名 id node に座標が漏れる silent bug) のため削除。 全 sub-node は必ず
-    // aliasSlug を接頭 / 接尾に含む形式で生成されるため、 2 経路で網羅済。
-    // lane 側は触らない = 他 sub-node の auto layout 経路を保持 (B1 独立性の SSOT)。
-    if (actor.nodes) {
-      for (const [subKey, override] of Object.entries(actor.nodes)) {
-        if (override.posX === undefined || override.posY === undefined) continue;
-        let 当たった = 0;
-        for (const node of diagram.nodes) {
-          if (node.id === `${aliasSlug}-${subKey}` || node.id === `${subKey}-${aliasSlug}`) {
-            node.posX = override.posX;
-            node.posY = override.posY;
-            if (override.posW !== undefined) node.posW = override.posW;
-            if (override.posH !== undefined) node.posH = override.posH;
-            当たった += 1;
-          }
-        }
-        /*
-         * **当たらなかったことを伝える** (#1466)。
-         *
-         * この経路が動くのは、図種が 1 人につき複数の箱を作る時だけ。 順序図が名札 / 余白 /
-         * 足を作っていた頃はそこに当たっていたが、板になって作らなくなった = いまはどの図種も
-         * この形の箱を作らない。 黙って落とすと、書いた側は効いていると思い込む。
-         */
-        if (当たった === 0) {
-          onNotice?.({
-            kind: "sub-node-not-found",
-            actor: actor.name,
-            line: actor.pos?.line ?? 0,
-            message: `"${truncateForMessage(actor.name)}" の nodes に書いた "${truncateForMessage(subKey)}" に当たる箱が図にありません`,
-            hint: "1 人に複数の箱を作る図種でだけ効きます。 箱そのものの位置は actor 側の 位置: に書いてください",
-          });
-        }
-      }
-    }
   }
 }
 
@@ -1975,10 +2308,13 @@ function minOf(values: readonly number[], fallback: number): number {
 }
 
 /**
- * merge がパーツを縦に送る幅。 `mergePartIntoDiagram` の `STACK_PITCH_APPROX` と同じ値。
+ * 段 1 つぶんの送り幅。 2 つの用途で使う。
+ *
+ * - `大きさ:` の縦の基準 (`partScaleBase`)。 縦は段の送り幅の合計に対する倍率で掛かる
+ * - 部品の頁を配置できない部品を、書いた値で置く時の段の間 (`書いた置き方`)
  *
- * 大きさの見積りは merge が実際に置く形と揃える。 別の規則で見積ると、 間隔が狂う
- * (実測 = 2 段のパーツで 200 空けたいところが 90 になった)。
+ * 頁を配置できる部品の要素の縦位置は、頁で配置した位置から取る (#1992)。 この値で置くと、
+ * 頁で段の間が 220 より広い部品 (実測 = `bind-grid-4` は段の中心の間 280) が置いた図で詰まる。
  */
 const PART_STACK_PITCH = 220;
 
@@ -2058,28 +2394,24 @@ export function partTargetSize(
 /**
  * `大きさ:` と `倍率:` が掛かる時の基準の大きさ (#1026)。
  *
- * 横は縦列の外接矩形、縦は段の送り幅の合計。 **図枠 (`partRenderSize`) ではない**。
- * 図枠は余白を含むため、これを基準にすると書いた倍率より大きく掛かる。
+ * 横は部品の頁で配置した縦列の外接矩形 (`部品の置き方を読む`)、縦は段の送り幅の合計。
+ * **図枠 (`partRenderSize`) ではない**。 図枠は余白を含むため、これを基準にすると書いた倍率より
+ * 大きく掛かる。
+ *
+ * 横を頁の縦列にするのは、組み込みが要素を頁の縦列に沿って置くため (#1992)。 書いた縦列を
+ * 基準のまま残すと、頁で縦列が広がる部品は `大きさ:` に書いた幅より広く描かれる。
  *
  * `partTargetScale` と `partTargetSize` が同じ物差しを使うことで、
  * `partTargetScale(part, base.w * k, base.h * k)` が丁度 `k` 倍を返す関係が保たれる。
+ * 組み込み (`mergePartIntoDiagram`) も同じ基準で伸縮する。
  */
 function partScaleBase(part: CdlDiagram): { w: number; h: number } {
-  const lanes = Array.isArray(part.lanes) ? part.lanes : [];
   const nodes = Array.isArray(part.nodes) ? part.nodes : [];
-  const lefts: number[] = [];
-  const rights: number[] = [];
-  for (const l of lanes) {
-    const lx = typeof l.x === "number" && Number.isFinite(l.x) ? l.x : 0;
-    const lw = positiveOr(l.width, 400);
-    lefts.push(lx);
-    rights.push(lx + lw);
-  }
   const stacks = nodes.map((n) =>
     typeof n.stack === "number" && Number.isFinite(n.stack) ? n.stack : 0,
   );
   return {
-    w: positiveOr(maxOf(rights, 400) - minOf(lefts, 0), 400),
+    w: 部品の置き方を読む(part).幅,
     h: Math.max(1, (maxOf(stacks, 0) - minOf(stacks, 0) + 1) * PART_STACK_PITCH),
   };
 }
@@ -2123,9 +2455,8 @@ export function partTargetScale(
  * 箱ごとに位置と大きさを見る。 一番高い箱の高さと段の数から概算すると実際の矩形と合わない
  * (実測 = 段 5 だけのパーツで 200 空けたいところが 750、 段 0,5 で高さが違うと 275 になった)。
  *
- * 段の送り幅は merge の近似 (`PART_STACK_PITCH`) を使う。 パーツを自分の図として配置計算した
- * 実寸とは段を持つパーツで 3% ほど違うが (実測 = 3 段で実高 620 に対して 640)、 ここで見たいのは
- * 「merge がどこに置くか」 なので merge の規則に合わせる。
+ * 箱の位置は merge と同じ置き方 (`部品の置き方を読む`) と同じ式 (`部品の要素のずれ`) から出す。
+ * ここで見たいのは「merge がどこに置くか」 なので、merge と別の規則を持たない (#1992)。
  */
 function partExtent(
   part: CdlDiagram,
@@ -2136,37 +2467,17 @@ function partExtent(
   if (!Array.isArray(part.lanes) || !Array.isArray(part.nodes)) return fallback;
   if (part.nodes.length === 0) return fallback;
 
-  // 縦列の位置と幅を先に正す。 catalog は呼出側が渡す値なので、 数でない値を計算に入れない
-  const lanes = new Map<string, { x: number; w: number }>();
-  const laneLefts: number[] = [];
-  const laneRights: number[] = [];
-  for (const l of part.lanes) {
-    const x = typeof l.x === "number" && Number.isFinite(l.x) ? l.x : 0;
-    const w = positiveOr(l.width, 400);
-    lanes.set(l.id, { x, w });
-    laneLefts.push(x);
-    laneRights.push(x + w);
-  }
-  const bboxW = positiveOr(maxOf(laneRights, 400) - minOf(laneLefts, 0), 400);
-  const bboxCenterX = minOf(laneLefts, 0) + bboxW / 2;
+  const 置き方 = 部品の置き方を読む(part);
   const { x: scaleX, y: scaleY } = partTargetScale(part, targetW, targetH);
 
-  const stacks = part.nodes.map((n) =>
-    typeof n.stack === "number" && Number.isFinite(n.stack) ? n.stack : 0,
-  );
-  const maxStack = maxOf(stacks, 0);
-  const minStack = minOf(stacks, 0);
-  const centerStack = (minStack + maxStack) / 2;
-
   // 箱ごとに、 merge が置く位置 (基準からの相対) と大きさから上下左右の端を出す
   const tops: number[] = [];
   const bottoms: number[] = [];
   const lefts: number[] = [];
   const rights: number[] = [];
   part.nodes.forEach((n, i) => {
-    const lane = lanes.get(n.lane) ?? { x: 0, w: 320 };
-    const cx = (lane.x + lane.w / 2 - bboxCenterX) * scaleX;
-    const cy = ((stacks[i] ?? 0) - centerStack) * PART_STACK_PITCH * scaleY;
+    const 頁 = 置き方.要素[i] ?? { x: 置き方.左端 + 置き方.幅 / 2, y: 0 };
+    const { dx: cx, dy: cy } = 部品の要素のずれ(n, 頁, 置き方, scaleX, scaleY);
     const halfW = (positiveOr(n.w, CDL_DEFAULT_NODE_W) * scaleX) / 2;
     const halfH = (positiveOr(n.h, CDL_DEFAULT_NODE_H) * scaleY) / 2;
     lefts.push(cx - halfW);
@@ -2279,8 +2590,8 @@ export function partBoxInFrame(part: CdlDiagram): {
  * 別名の数だけ組み立て直す (相対指定があると 1 個につき 4 回になる)。 覚えるのは大きさだけで、
  * 色などの見た目は含まないため、 呼出側が色を差し替えても古い値にはならない。
  *
- * 組み立てと違い画面を描くたびに呼ばれるので、 大きすぎる図は測る前に止める。 上限は
- * 組み立て側と同じ物差しを使う (#1005)。 catalog の見本は数十要素なので通常は掛からない。
+ * 配置は `部品の頁を配置する` から受け取る。 置き方 (`部品の置き方を読む`) も同じ配置を読むので、
+ * 部品を 1 つ置いても配置は 1 度で済む。
  *
  * 測れない図では既定の大きさと余白 0 に落とす。
  */
@@ -2300,45 +2611,210 @@ function partFrameGeometry(part: CdlDiagram): PartFrameGeometry {
   if (cached) return cached;
   const fallback = { w: 400, h: 200, left: 0, top: 0, boxW: 400, boxH: 200 };
   let out = fallback;
-  if (countDiagramElements(part) <= MAX_INPUT_ELEMENTS) {
-    try {
-      const own = layout(part);
-      const vb = own.viewBox;
-      const w = positiveOr(vb.w, 400);
-      const h = positiveOr(vb.h, 200);
-      if (own.nodes.length === 0) {
-        // 箱を持たない図では図枠をそのまま箱として扱う。 相対指定の間隔は図枠の縁から測る
-        out = { w, h, left: 0, top: 0, boxW: w, boxH: h };
-      } else {
-        let x0 = Infinity;
-        let y0 = Infinity;
-        let x1 = -Infinity;
-        let y1 = -Infinity;
-        for (const n of own.nodes) {
-          x0 = Math.min(x0, n.cx - n.w / 2);
-          x1 = Math.max(x1, n.cx + n.w / 2);
-          y0 = Math.min(y0, n.cy - n.h / 2);
-          y1 = Math.max(y1, n.cy + n.h / 2);
-        }
-        const left = x0 - vb.x;
-        const top = y0 - vb.y;
-        out = {
-          w,
-          h,
-          left: Number.isFinite(left) ? left : 0,
-          top: Number.isFinite(top) ? top : 0,
-          boxW: positiveOr(x1 - x0, w),
-          boxH: positiveOr(y1 - y0, h),
-        };
+  const own = 部品の頁を配置する(part);
+  if (own !== undefined) {
+    const vb = own.viewBox;
+    const w = positiveOr(vb.w, 400);
+    const h = positiveOr(vb.h, 200);
+    if (own.nodes.length === 0) {
+      // 箱を持たない図では図枠をそのまま箱として扱う。 相対指定の間隔は図枠の縁から測る
+      out = { w, h, left: 0, top: 0, boxW: w, boxH: h };
+    } else {
+      let x0 = Infinity;
+      let y0 = Infinity;
+      let x1 = -Infinity;
+      let y1 = -Infinity;
+      for (const n of own.nodes) {
+        x0 = Math.min(x0, n.cx - n.w / 2);
+        x1 = Math.max(x1, n.cx + n.w / 2);
+        y0 = Math.min(y0, n.cy - n.h / 2);
+        y1 = Math.max(y1, n.cy + n.h / 2);
       }
-    } catch {
-      out = fallback;
+      const left = x0 - vb.x;
+      const top = y0 - vb.y;
+      out = {
+        w,
+        h,
+        left: Number.isFinite(left) ? left : 0,
+        top: Number.isFinite(top) ? top : 0,
+        boxW: positiveOr(x1 - x0, w),
+        boxH: positiveOr(y1 - y0, h),
+      };
     }
   }
   PART_FRAME_CACHE.set(part, out);
   return out;
 }
 
+/**
+ * 部品の頁 (部品の図だけ) を配置した結果。 配置できない図では `undefined` (#1992)。
+ *
+ * 図枠 (`partFrameGeometry`) と置き方 (`部品の置き方を読む`) が同じ結果を読む。 見本ごとに
+ * 覚えておくのは、catalog の見本が複数の別名から同じものを指し、画面を描くたびにも呼ばれるため。
+ *
+ * 大きすぎる図は配置する前に止める。 上限は組み立て側と同じ物差しを使う (#1005)。
+ * catalog の見本は数十要素なので通常は掛からない。
+ */
+const PART_PAGE_CACHE = new WeakMap<CdlDiagram, LaidDiagram | null>();
+
+function 部品の頁を配置する(part: CdlDiagram): LaidDiagram | undefined {
+  const cached = PART_PAGE_CACHE.get(part);
+  if (cached !== undefined) return cached ?? undefined;
+  let out: LaidDiagram | null = null;
+  if (countDiagramElements(part) <= MAX_INPUT_ELEMENTS) {
+    try {
+      out = layout(part);
+    } catch {
+      out = null;
+    }
+  }
+  PART_PAGE_CACHE.set(part, out);
+  return out ?? undefined;
+}
+
+/**
+ * 部品を図に置く時に、縦列と要素をどこに置くか (#1992)。
+ *
+ * 部品の頁で配置した縦列の位置と幅、要素の中心を使う。 組み込み (`mergePartIntoDiagram`)、
+ * 組み込んだ大きさの見積り (`partExtent`)、`大きさ:` の横の基準 (`partScaleBase`) の 3 か所が
+ * これを読む。
+ *
+ * 部品が書いた縦列の位置と幅は、頁で配置した後の値と違う。 描画側が隣と近づきすぎないよう
+ * 縦列を広げ、段の間を箱の高さに合わせて取るため。 書いた値で置くと頁で空いた分が消え、
+ * 置いた図だけが間隔の検査に掛かる (実測 = 80 種のうち 14 種。 `wifi-signal` は頁で要素の間 80、
+ * 書いた値で置くと 40)。
+ *
+ * 頁を配置できない図 (描画側が止める図と、大きすぎて測らない図) は書いた値に落とす
+ * (`書いた置き方`)。 頁の位置が数にならない図も同じ。 描画側は書いた値が数でない時に止めずに
+ * 数でない座標を返す (実測 = 幅を書かない縦列は幅が `NaN`、段が数でない要素は縦が `-Infinity`)。
+ *
+ * 1 つの部品で 2 つを混ぜない。 数にならない縦列や要素が 1 つでもあれば全体を書いた値にする。
+ * 混ぜると、要素ごとに別の物差しで置くことになる。
+ */
+type 部品の置き方 = {
+  /** 縦列ごとの左端と幅 */
+  縦列: ReadonlyMap<string, { x: number; w: number }>;
+  /** 縦列の外接矩形の左端と幅。 横に写す時の中心と、`大きさ:` の横の基準に使う */
+  左端: number;
+  幅: number;
+  /**
+   * 要素ごとの中心 (`part.nodes` と同じ並び)。 横は縦列と同じ座標、縦は要素全体の縦の中心からの差。
+   * どちらも伸縮を掛ける前の値
+   */
+  要素: readonly { x: number; y: number }[];
+};
+
+const 部品の置き方の控え = new WeakMap<CdlDiagram, 部品の置き方>();
+
+function 部品の置き方を読む(part: CdlDiagram): 部品の置き方 {
+  const 控え = 部品の置き方の控え.get(part);
+  if (控え) return 控え;
+  const 置き方 = 頁の置き方(part) ?? 書いた置き方(part);
+  部品の置き方の控え.set(part, 置き方);
+  return 置き方;
+}
+
+/**
+ * 縦列の外接矩形。 幅が正でない時 (縦列が 1 本も無い図) は 400 に落とす。
+ * 1 未満の正の幅はそのまま使う。 1 に切り上げると、その分だけ `大きさ:` の倍率が小さくなる
+ */
+function 縦列の外接(縦列: ReadonlyMap<string, { x: number; w: number }>): { 左端: number; 幅: number } {
+  const 値 = [...縦列.values()];
+  const 左端 = minOf(値.map((g) => g.x), 0);
+  const 右端 = maxOf(値.map((g) => g.x + g.w), 400);
+  return { 左端, 幅: positiveOr(右端 - 左端, 400) };
+}
+
+/**
+ * 部品の頁で配置した縦列と要素の中心。 頁を配置できない時と、頁の位置が数にならない時は
+ * `undefined` を返し、呼出側が書いた値に落とす。
+ *
+ * 縦の中心は、頁に並んだ要素全体の上下の中心 (一番上と一番下の要素の中心の中間)。 書いた値の
+ * 経路が段の番号の中間を中心にするのと同じ取り方で、部品の中心を置く位置に合わせる。
+ *
+ * 部品の要素が頁に見つからない場合も書いた値に落とす。 描画側は部品の要素を全て配置して返す
+ * ため、この場合に届く入力は作れない (実測 = カタログ 80 種で見つからない要素は 0)。 残すのは、
+ * 見つからない要素だけを別の物差しで置かないため。
+ */
+function 頁の置き方(part: CdlDiagram): 部品の置き方 | undefined {
+  if (!Array.isArray(part.lanes) || !Array.isArray(part.nodes)) return undefined;
+  const laid = 部品の頁を配置する(part);
+  if (laid === undefined) return undefined;
+  const 縦列 = new Map<string, { x: number; w: number }>();
+  for (const l of laid.lanes) {
+    if (!Number.isFinite(l.x) || !Number.isFinite(l.width) || !(l.width > 0)) return undefined;
+    縦列.set(l.id, { x: l.x, w: l.width });
+  }
+  const 頁の箱 = new Map(laid.nodes.map((n) => [n.id, n]));
+  const 箱たち: { cx: number; cy: number }[] = [];
+  for (const n of part.nodes) {
+    const 箱 = 頁の箱.get(n.id);
+    if (箱 === undefined || !Number.isFinite(箱.cx) || !Number.isFinite(箱.cy)) return undefined;
+    箱たち.push(箱);
+  }
+  const 縦たち = 箱たち.map((b) => b.cy);
+  const 縦の中心 = (minOf(縦たち, 0) + maxOf(縦たち, 0)) / 2;
+  return {
+    縦列,
+    ...縦列の外接(縦列),
+    要素: 箱たち.map((b) => ({ x: b.cx, y: b.cy - 縦の中心 })),
+  };
+}
+
+/**
+ * 部品が書いた値で置く時の縦列と要素の中心。 頁を配置できない部品だけが使う。
+ *
+ * 横は書いた縦列の中心、縦は段の番号に段の送り幅 (`PART_STACK_PITCH`) を掛けた位置。
+ * 縦列の位置と幅は先に正す。 catalog は呼出側が渡す値で、生値のまま外接矩形を出すと
+ * 拡大の基準が崩れて箱が桁違いに大きくなる (実測 = 指定間隔 200 が -31800 になった)。
+ * 数でない段は 0 として扱う (#1018)。
+ */
+function 書いた置き方(part: CdlDiagram): 部品の置き方 {
+  const lanes = Array.isArray(part.lanes) ? part.lanes : [];
+  const nodes = Array.isArray(part.nodes) ? part.nodes : [];
+  const 縦列 = new Map<string, { x: number; w: number }>();
+  for (const l of lanes) {
+    縦列.set(l.id, {
+      x: typeof l.x === "number" && Number.isFinite(l.x) ? l.x : 0,
+      w: positiveOr(l.width, 400),
+    });
+  }
+  const stacks = nodes.map((n) =>
+    typeof n.stack === "number" && Number.isFinite(n.stack) ? n.stack : 0,
+  );
+  const 中央の段 = (minOf(stacks, 0) + maxOf(stacks, 0)) / 2;
+  return {
+    縦列,
+    ...縦列の外接(縦列),
+    要素: nodes.map((n, i) => {
+      const l = 縦列.get(n.lane) ?? { x: 0, w: 320 };
+      return { x: l.x + l.w / 2, y: ((stacks[i] ?? 0) - 中央の段) * PART_STACK_PITCH };
+    }),
+  };
+}
+
+/**
+ * 部品の要素 1 つの中心が、置く位置 (merge に渡す座標) からどれだけずれるか (#1992)。
+ *
+ * 組み込み (`mergePartIntoDiagram`) と見積り (`partExtent`) が同じ式を通る。 別々に書くと、
+ * 格子が確保した場所と実際に置いた場所がずれる。
+ *
+ * 要素が自分で位置を書いていれば、その値を使う。 横は縦列と同じ写し方 (縦列の外接矩形の中心を
+ * 置く位置に合わせて伸縮する) で写し、縦は置く位置に足すだけで伸縮を掛けない。
+ */
+function 部品の要素のずれ(
+  node: { posX?: number; posY?: number },
+  頁: { x: number; y: number },
+  置き方: 部品の置き方,
+  scaleX: number,
+  scaleY: number,
+): { dx: number; dy: number } {
+  return {
+    dx: ((node.posX ?? 頁.x) - (置き方.左端 + 置き方.幅 / 2)) * scaleX,
+    dy: node.posY ?? 頁.y * scaleY,
+  };
+}
+
 /**
  * パーツ 1 個が図の上で確保する図枠 (merge に渡す座標での表し方)。
  *
@@ -2406,26 +2882,25 @@ export function partVisualSize(
 /** 格子に並べる時の 1 行あたりの個数と隙間。 */
 const PARTS_PER_ROW = 3;
 const PARTS_GAP = 120;
-/**
- * 既存の図の下に置く時の目安。
- *
- * 既存の箱は自動配置なので、 この時点では座標を持たない。 箱の数から概算する。
- * 1 段あたりの高さは cdl の既定の縦送り幅に合わせる。
- */
-const STACK_PITCH = 280;
 
 /**
- * 既存の図が縦に何段ぶんを占めるかの目安 (#1481)。
+ * 組み立てた図の下端 (#2002)。 箱が 1 つも無ければ `undefined`。
+ *
+ * **段数で概算しない**。 かつては箱の数から `箱 1 つ = 1 段 (280)` で見積もっていたが、
+ * `flow` の箱は実際には高さ 68 で 168 おきに並ぶため 1 段あたり 112 ずつ余分に見積もる。
+ * 誤差は箱の数に比例して積み上がり、実測で箱 2 つの図に 496、箱 4 つの図に 720 の空きが
+ * 入っていた (部品どうしの間は 120)。
  *
- * **箱の数では数えない**。 数で数えると、図を丸ごと 1 つの箱で描く種別が 1 段に潰れる。
- * 順序図は `#1466` で 1 枚の板になり、高さ 432 の箱 1 つになった = 1 段 (280) と見積もられ、
- * その下に置いたパーツが板に 31px 重なっていた (実測)。
+ * **箱の下端ではなく図枠の下端を返す**。 格子は図枠どうしを `PARTS_GAP` 空けて並べるので、
+ * 既存の図との間も図枠で測らないと、部品どうしの間と既存の図との間が揃わない
+ * (箱で測ると 180、図枠で測ると 240 で、後者が部品どうしの段の間と一致する)。
  *
- * 大きさを自分で持つ箱は、その高さから段数を出す。 持たない箱は今までどおり 1 段と数えるので、
- * 高さを書かない図の並び方は変わらない。
+ * **箱が無いことを 0 に潰さない**。 0 を下端として使うと、部品だけを並べた図で部品が
+ * 図の上端へ貼り付く。 呼出側が「箱が無い」 と「下端が 0」 を分けられるように `undefined` を返す。
  */
-export function partsBaseRows(nodes: ReadonlyArray<{ h?: number }>): number {
-  return nodes.reduce((acc, n) => acc + Math.max(1, Math.ceil(positiveOr(n.h, 0) / STACK_PITCH)), 0);
+export function partsBaseBottom(laid: LaidDiagram): number | undefined {
+  if (laid.nodes.length === 0) return undefined;
+  return laid.viewBox.y + laid.viewBox.h;
 }
 
 /**
@@ -2438,18 +2913,24 @@ export function partsBaseRows(nodes: ReadonlyArray<{ h?: number }>): number {
  * 隣と重なる (実測 = 400 の次に 200 を置くと 280 重なった)。 段の高さも段内の最大高で揃える。
  * 縦は自分の高さの半分だけ段の上端から下げて、 段内で上端を揃える。
  *
- * @param baseRows 既存の図が占める段数の目安 (`partsBaseRows`)。 図の下から並べ始めるために使う
+ * @param baseBottom 既存の図の下端 (`partsBaseBottom`)。 その下に間を空けて並べ始める。
+ *   箱が 1 つも無い図では `undefined` を渡す
  */
 export function partsGridCenters(
-  baseRows: number,
+  baseBottom: number | undefined,
   items: ReadonlyArray<{ id: string; w: number; h: number }>,
 ): Map<string, { cx: number; cy: number }> {
   const out = new Map<string, { cx: number; cy: number }>();
   if (items.length === 0) return out;
-  // 公開している関数なので、 呼出側が渡す値を入口で閉じる。 数でない箱の数や桁溢れを
-  // そのまま計算に入れると、 描けない座標を返すことになる
-  const safeCount = Number.isSafeInteger(baseRows) && baseRows >= 0 ? baseRows : 0;
-  const top = safeCount * STACK_PITCH + PARTS_GAP * 2;
+  // 公開している関数なので、 呼出側が渡す値を入口で閉じる。 数でない下端や桁溢れを
+  // そのまま計算に入れると、 描けない座標を返すことになる。
+  //
+  // 負の下端は捨てない = 図は原点より上にも置ける。 0 で下げ止めると、上にある図の下に
+  // 無駄な空きが入る
+  const top =
+    baseBottom === undefined || !Number.isFinite(baseBottom)
+      ? PARTS_GAP * 2
+      : baseBottom + PARTS_GAP;
   // 同じ名前が 2 度来たら先の方だけを見る。 後の分を残すと、 どちらを指したか決められない
   // まま列の送り幅にも影響する
   const seen = new Set<string>();
@@ -2516,6 +2997,44 @@ function partsBudget(
   return accepted;
 }
 
+/**
+ * パーツを除いた図を組み立てて、その下端を返す (#2002)。 箱が 1 つも無ければ `undefined`。
+ *
+ * **宣言のままの箱は座標を持たない** (`CdlNode` に `cx` / `cy` が無い)。 下端を知るには
+ * 一度組み立てる必要がある。 パーツを除いた図を組み立てるのは、パーツを含めて測ると
+ * パーツを足すたびに下端が下がり、置き場所が自分自身に追随して逃げるため。
+ *
+ * ## 除く 3 つは、いまの呼び出し順では結果を変えない
+ *
+ * 箱 / 縦列 / 矢印の 3 つを除いているが、**この 3 つを残しても下端は 1 も動かない**
+ * (変異試験で 3 つとも、また 3 つ同時でも落ちる検査は 0 件)。 この関数が走るのは
+ * パーツを取り込む前で、その時点のパーツの仮の箱は書いた位置も縦列の段も反映しておらず、
+ * 必ず本体の箱と同じ段に居るため。 図種 5 種 × 段の深さ 2 通り、位置を書いた深さ 3 通り、
+ * 縦列に置いた段数 2 通りを実測して、1 件も差が出なかった。
+ *
+ * それでも残すのは、この関数が「パーツを除いた図を測る」 と読めることに意味があるため。
+ * 呼び出し順が変わった時に黙って下端が動くより、除く形が書いてある方が直しやすい。
+ */
+function baseDiagramBottom(
+  target: CdlDiagram,
+  baseNodes: readonly CdlDiagram["nodes"][number][],
+  partsLaneIds: ReadonlySet<string>,
+): number | undefined {
+  // 箱が 1 つも無い図では組み立てない。 **返す値を変えるための分岐ではない**
+  // (`partsBaseBottom` も箱 0 個で `undefined` を返す) = 組み立て 1 回ぶんを省くためだけの
+  // 早い戻り。 変異試験でこの行を外しても落ちる検査は 0 件で、それが期待どおり
+  if (baseNodes.length === 0) return undefined;
+  const baseIds = new Set(baseNodes.map((n) => n.id));
+  return partsBaseBottom(
+    layout({
+      ...target,
+      lanes: target.lanes.filter((l) => !partsLaneIds.has(l.id)),
+      nodes: [...baseNodes],
+      edges: target.edges.filter((e) => baseIds.has(e.from) && baseIds.has(e.to)),
+    }),
+  );
+}
+
 /**
  * 位置を書かなかったパーツの、 merge に渡す座標。
  *
@@ -2536,8 +3055,16 @@ function partGridCenters(
   //
   // merge 側は「縦横どちらも書かなかった時」 に格子へ落とす。 条件が食い違うと、 片方だけ
   // 書いたパーツが格子の枠を 1 つ消費して後続がずれる (実測 = 後続の中心が 200 から 720 に動いた)
+  //
+  // 縦列に置く部品も外す (#1980)。 格子の枠を使うと、縦列へ動かした後に後続の部品との間に
+  // 空きが残る。 相対の位置を解く側 (`partBoxes`) も同じ関数を通るので、基準の位置は揃う
+  const 縦列の部品 = 縦列に置く部品(target, doc).縦列;
   const autoActors = partsActors.filter(
-    (a) => a.posX === undefined && a.posY === undefined && a.posRel === undefined,
+    (a) =>
+      a.posX === undefined &&
+      a.posY === undefined &&
+      a.posRel === undefined &&
+      !縦列の部品.has(a.name),
   );
   if (autoActors.length === 0) return new Map();
   // パーツ自身の仮の箱は数えない。 この時点では未削除で残っており、 数えるとパーツを足すたびに
@@ -2596,7 +3123,7 @@ function partGridCenters(
     extents.set(a.name, partFrameExtent(part, t.w, t.h));
   }
   const centers = partsGridCenters(
-    partsBaseRows(baseNodes),
+    baseDiagramBottom(target, baseNodes, partsLaneIds),
     placedActors.map((a) => ({ id: a.name, ...extents.get(a.name)! })),
   );
   // merge に渡すのは段の中心。 矩形の中心とのずれを引く。 引かないと、 段ごとに箱の高さが
@@ -2659,6 +3186,240 @@ function partBoxes(
   return out;
 }
 
+/**
+ * 部品へ引いた矢印を、部品の図の要素へ繋ぎ直す手順を作る (#1979)。
+ *
+ * 部品を置くと組み立ては仮の箱を消し、部品の図の要素を `{名前}__{要素の id}` で足す。 仮の箱へ
+ * 引いた矢印は繋ぎ先を失うため、以前は知らせも無く消えていた。
+ *
+ * | 部品 | 繋ぎ先 |
+ * |---|---|
+ * | 要素 1 つ | その要素 |
+ * | 要素 2 つ以上 | 矢印の行に書いた `fromPartNode` / `toPartNode` の要素 |
+ *
+ * **要素が 2 つ以上ある部品で 1 つを自動で選ばない**。 カタログの部品は外枠を持たず同格の要素が並ぶ
+ * (信号の 3 灯、星 5 つ、棒 5 本) ため、最初の要素や一番大きい要素を選ぶと「その 1 つだけ」 を
+ * 指す矢印に見える。 名指しが無い時、名指しした要素が無い時、部品を取り込まなかった時 (`part` が
+ * `undefined`) は矢印を外し、矢印ごとに 1 件知らせる。
+ *
+ * **繋ぐのは書いた矢印だけ** = 矢印を書いた行の端の名前が、この部品の名前と一致する時。 静止した
+ * `type: flow` は行を書かなくても箱を並び順で繋ぐが、その矢印は書き手が部品へ引いたものではないので
+ * 従来どおり知らせずに外す。 繋ぐと、部品を本文から抜いて図の上に重ねる編集画面 (行が部品を指す
+ * 本文だけを抜かずに描く) と絵が食い違う (実測 = 箱と部品を並べただけの本文に、組み立て側だけ矢印が出た)。
+ */
+function 部品の要素へ繋ぐ(
+  部品の名前: string,
+  partId: string,
+  part: CdlDiagram | undefined,
+  edgeSteps: Map<string, DslStep> | undefined,
+  onNotice: ((notice: CompileNotice) => void) | undefined,
+): (edge: CdlEdge, 端: { from: boolean; to: boolean }) => CdlEdge | undefined {
+  const 要素 = (part?.nodes ?? []).map((n) => n.id);
+  const 見せる数 = 8;
+  const 要素の一覧 = `${要素.slice(0, 見せる数).map(truncateForMessage).join(", ")}${要素.length > 見せる数 ? ` ほか ${要素.length - 見せる数} 件` : ""}`;
+  return (edge, 端) => {
+    const s = edgeSteps?.get(edge.id);
+    const 繋いだ: CdlEdge = { ...edge };
+    for (const 側 of ["from", "to"] as const) {
+      if (!端[側]) continue;
+      // 書いていない矢印 (並び順で作られた矢印) は知らせずに外す
+      if (s === undefined || s[側] !== 部品の名前) return undefined;
+      const 欄 = 側 === "from" ? "fromPartNode" : "toPartNode";
+      const 名指し = s[欄];
+      let 理由: { message: string; hint: string } | undefined;
+      if (part === undefined) {
+        理由 = {
+          message: "を図に取り込まなかった",
+          hint: "部品が図に入らないため、矢印の端にできません",
+        };
+      } else if (名指し !== undefined) {
+        if (要素.includes(名指し)) 繋いだ[側] = `${部品の名前}__${名指し}`;
+        else
+          理由 = {
+            message: `の中に ${欄} に書いた "${truncateForMessage(名指し)}" という要素が無い`,
+            hint: `この部品の要素 = ${要素の一覧}`,
+          };
+      } else if (要素.length === 1) {
+        繋いだ[側] = `${部品の名前}__${要素[0]}`;
+      } else {
+        理由 =
+          要素.length === 0
+            ? { message: "の中に繋げる要素が無い", hint: "この部品は要素を持たないため、矢印の端にできません" }
+            : {
+                message: "の中のどの要素に繋ぐかが決まらない",
+                hint: `要素が 2 つ以上ある部品は、矢印に ${欄}: <要素の id> を書いて繋ぐ要素を選ぶ (要素 = ${要素の一覧})`,
+              };
+      }
+      if (理由 === undefined) continue;
+      const 矢印 = `"${truncateForMessage(s.from)}" から "${truncateForMessage(s.to)}" への矢印`;
+      onNotice?.({
+        kind: "part-edge-dropped",
+        actor: 部品の名前,
+        line: s.pos.line,
+        message: `${矢印}は、"${truncateForMessage(部品の名前)}" (${truncateForMessage(partId)}) ${理由.message}ため外しました`,
+        hint: 理由.hint,
+      });
+      return undefined;
+    }
+    return 繋いだ;
+  };
+}
+
+/**
+ * 矢印に書いた部品の要素の名指し (`fromPartNode` / `toPartNode`) が効かないことを知らせる (#1979)。
+ *
+ * 名指しは部品の端でだけ読む。 部品でない箱の端に書くと値はどこにも届かず、黙って捨てると
+ * 「書いたのに繋ぎ先が変わらない」 が手掛かりなしで起きる。
+ *
+ * 順序図 (`sequence` / `solidity`) は板の言づてが縦の線に届き、部品の要素へは繋がないため、
+ * 部品の端に書いても効かない。 部品の一覧に無い部品は組み立てが部品を引いてから知らせる。
+ */
+function reportPartNodeNotHonored(
+  doc: DslDocument,
+  onNotice?: (notice: CompileNotice) => void,
+): void {
+  if (!onNotice) return;
+  const 順序図 = doc.type === "sequence" || doc.type === "solidity";
+  const 部品 = new Set(doc.actors.filter((a) => a.partId !== undefined).map((a) => a.name));
+  const 居る = new Set(doc.actors.map((a) => a.name));
+  for (const s of doc.flow) {
+    for (const [側, 欄] of [
+      ["from", "fromPartNode"],
+      ["to", "toPartNode"],
+    ] as const) {
+      const 値 = s[欄];
+      if (値 === undefined) continue;
+      const 名 = s[側];
+      // 居ない名前は `flow-actor-missing` が知らせる
+      if (!居る.has(名)) continue;
+      if (!順序図 && 部品.has(名)) continue;
+      onNotice({
+        kind: "part-node-ignored",
+        actor: 名,
+        line: s.pos.line,
+        message: 順序図
+          ? `順序図の言づては "${truncateForMessage(名)}" の縦の線に届くため、${欄} に書いた "${truncateForMessage(値)}" は効きません`
+          : `"${truncateForMessage(名)}" は部品ではないため、${欄} に書いた "${truncateForMessage(値)}" は効きません`,
+        hint: 順序図
+          ? "部品の中の要素へ矢印を繋ぐのは、矢印を箱の間に引く図種 (flow / swimlane など)"
+          : "部品の中の要素の名指しは、kind に部品の名前を書いた箱の端にだけ効く",
+      });
+    }
+  }
+}
+
+/**
+ * 部品のために作られた仮の箱の id かを見分ける。
+ *
+ * 仮の箱の id は部品の名前の slug か、それを頭に持つ形 (`a-header` / `s0-a`) で作られる。
+ * 仮の箱を消す側 (`cleanupPlaceholderActor`) と、部品を置く縦列を探す側 (`縦列に置く部品`) が
+ * 同じ判定を使う = 別々に持つと、消した箱と縦列を探した箱が食い違う。
+ *
+ * 素の登場人物が持つ id は仮の箱に数えない (#1466)。 名前が重なった素の登場人物は
+ * `重なりを解く` 側で `a-c40bf6` のような id に作り替えられるため、同じ頭で始まり
+ * **本体の箱まで巻き込む** (実測で `flow` / `swimlane` / `er` / `state` / `topology` /
+ * `class` / `c4` の 7 図種すべてで素の箱が黙って消えていた)。
+ *
+ * 名前の頭が自分と重なる別の登場人物 (`設備` に対する `設備-予備`) の仮の箱も数えない (#1980)。
+ * 数えると `設備` の仮の箱が 2 本の縦列にまたがって見え、`設備` を消す時に `設備-予備` の
+ * 仮の箱と縦列まで消す。 部品同士でも起き、後から組み込む `設備-予備` が消えた縦列を指して
+ * 配置が止まっていた (`cdl layout: node "設備-予備__ind" の lane "設備-予備" が定義されていない`)。
+ */
+function 仮の箱のidか(doc: DslDocument, name: string): (id: string) => boolean {
+  const aliasSlug = slugify(name);
+  const 素の箱のid = new Set(
+    doc.actors.filter((x) => x.partId === undefined).map((x) => slugify(x.name)),
+  );
+  const 頭が重なるid = [
+    ...new Set(
+      doc.actors
+        .filter((x) => x.name !== name)
+        .map((x) => slugify(x.name))
+        .filter((s) => s.startsWith(`${aliasSlug}-`) || s.endsWith(`-${aliasSlug}`)),
+    ),
+  ];
+  // sequence step anchor = `s{N}-{slug}` pattern
+  const 自分の形か = (id: string, slug: string): boolean =>
+    id === slug || id.startsWith(`${slug}-`) || (/^s\d+-/.test(id) && id.endsWith(`-${slug}`));
+  return (id: string): boolean => {
+    if (素の箱のid.has(id)) return false;
+    if (頭が重なるid.some((s) => 自分の形か(id, s))) return false;
+    return 自分の形か(id, aliasSlug);
+  };
+}
+
+/**
+ * 縦列の中に置く部品と、その縦列の id (#1980)。
+ *
+ * 位置を書かない部品は格子に並ぶが、格子は縦列の位置を読まない。 部品が縦列に属する図では、
+ * 部品の要素だけが縦列に属し、描く位置は別の縦列の上になっていた (実測 = 縦列 b 480〜890 に
+ * 属する部品が 60〜420 に描かれた)。
+ *
+ * 縦列に置くのは、位置 (`posX` / `posY` / `位置:`) を書かない部品のうち次のどちらかに当たるもの。
+ *
+ * | 形 | 縦列 |
+ * |---|---|
+ * | `lane:` に図にある縦列を書いた | 書いた縦列 |
+ * | 仮の箱が自分だけの縦列を持つ (`swimlane` / `state` / `er` / `class` の作り方) | その縦列 |
+ *
+ * **自分だけの縦列は図の形で見分ける**。 図種の名前で分けると、縦列の作り方を変えた図種で
+ * 黙って外れる。 仮の箱が入った縦列に他の登場人物の箱が無く、図に縦列が 2 本以上ある時に
+ * 限る = 全員が 1 本の縦列を共有する図種 (`flow` / `topology` / `c4`) は格子のまま残る。
+ * 仮の箱が作られない形 (流れに現れない `swimlane` の登場人物) は、名札が部品の名前の空の縦列で引く。
+ *
+ * **順序図 (`sequence` / `solidity`) は対象にしない**。 1 枚の板で描き、縦列を持たない (#1466)。
+ *
+ * **他の箱の位置の基準になっている部品は縦列に置かない**。 相対の位置 (`位置: 印 の右 200`) は
+ * 組み立ての前に格子の位置を基準に解くため、基準の部品だけを縦列へ動かすと書いた位置関係が
+ * 崩れる。 外した部品は `基準のため外した` に入れ、呼出側が知らせる。
+ */
+function 縦列に置く部品(
+  target: CdlDiagram,
+  doc: DslDocument,
+): { 縦列: Map<string, string>; 基準のため外した: Map<string, string> } {
+  const 縦列 = new Map<string, string>();
+  const 基準のため外した = new Map<string, string>();
+  if (doc.type === "sequence" || doc.type === "solidity") return { 縦列, 基準のため外した };
+  const 基準の名前 = new Set(
+    doc.actors.map((a) => a.posRel?.anchor).filter((n): n is string => n !== undefined),
+  );
+  const 縦列のid = new Set(target.lanes.map((l) => l.id));
+  for (const a of doc.actors) {
+    if (a.partId === undefined) continue;
+    // 同じ名前を 2 度書いた時は先の 1 件を使う (組み立て側の他の判定と同じ)
+    if (縦列.has(a.name) || 基準のため外した.has(a.name)) continue;
+    if (a.posX !== undefined || a.posY !== undefined || a.posRel !== undefined) continue;
+    const 置く縦列 = 部品の縦列(target, doc, a, 縦列のid);
+    if (置く縦列 === undefined) continue;
+    if (基準の名前.has(a.name)) 基準のため外した.set(a.name, 置く縦列);
+    else 縦列.set(a.name, 置く縦列);
+  }
+  return { 縦列, 基準のため外した };
+}
+
+/** 部品を置く縦列。 書いた縦列か、仮の箱が自分だけで使う縦列。 どちらも無ければ `undefined` */
+function 部品の縦列(
+  target: CdlDiagram,
+  doc: DslDocument,
+  a: DslActor,
+  縦列のid: ReadonlySet<string>,
+): string | undefined {
+  if (a.lane !== undefined) return 縦列のid.has(a.lane) ? a.lane : undefined;
+  if (target.lanes.length < 2) return undefined;
+  const 仮の箱か = 仮の箱のidか(doc, a.name);
+  const 仮の箱の縦列 = new Set(target.nodes.filter((n) => 仮の箱か(n.id)).map((n) => n.lane));
+  // 2 本にまたがる入力は見つかっていない (実測 = 縦列に置く 7 図種とも仮の箱は登場人物ごとに 1 つ。
+  // 名前の頭が重なる登場人物の箱は `仮の箱のidか` が外す)。 またがった時にどちらかの縦列を選ぶと
+  // 他の縦列を部品が占めるため、格子に残す
+  if (仮の箱の縦列.size > 1) return undefined;
+  const [入っていた] = [...仮の箱の縦列];
+  const 候補 =
+    入っていた ?? target.lanes.find((l) => l.label === a.name && !target.nodes.some((n) => n.lane === l.id))?.id;
+  if (候補 === undefined) return undefined;
+  // 他の登場人物の箱が同じ縦列に居れば、自分だけの縦列ではない
+  return target.nodes.some((n) => n.lane === 候補 && !仮の箱か(n.id)) ? undefined : 候補;
+}
+
 /**
  * パーツ用に作られた仮の箱 / 線 / 列を掃除する (#1015 で helper 化)。
  *
@@ -2669,6 +3430,11 @@ function cleanupPlaceholderActor(
   target: CdlDiagram,
   doc: DslDocument,
   a: { name: string; lane?: string },
+  /**
+   * 仮の箱に繋がっていた矢印を、部品の図の要素へ繋ぎ直す (#1979)。 仮の箱の側の端を受け取り、
+   * 繋ぎ直した矢印を返す。 `undefined` を返した矢印は外す。 渡さなければ全て外す
+   */
+  繋ぎ直す?: (edge: CdlEdge, 端: { from: boolean; to: boolean }) => CdlEdge | undefined,
 ): void {
   const aliasSlug = slugify(a.name);
   const ownedLaneIds = new Set<string>();
@@ -2683,41 +3449,30 @@ function cleanupPlaceholderActor(
   for (const n of target.nodes) {
     if (ownedLaneIds.has(n.lane)) ownedNodeIds.add(n.id);
   }
-  /*
-   * 素の登場人物が持つ id は消さない (#1466)。
-   *
-   * 下の頭一致は、見本のために作られた仮の箱 (`a-header` / `s0-a`) を拾うためのもの。
-   * ところが名前が重なった素の登場人物は `重なりを解く` 側で `a-c40bf6` のような id に
-   * 作り替えられるため、同じ頭で始まり **本体の箱まで巻き込む**。
-   *
-   * 見本と重なる名前を書いた図で、素の箱が黙って消えていた (実測で `flow` / `swimlane` /
-   * `er` / `state` / `topology` / `class` / `c4` の 7 図種すべて)。 順序図だけは面ごとの
-   * 縦列で引けたため免れており、#1466 で板になって縦列が無くなると同じ穴に落ちる。
-   */
-  const 素の箱のid = new Set(
-    doc.actors.filter((x) => x.partId === undefined).map((x) => slugify(x.name)),
-  );
   // actor 専用 lane を引き当てられない経路 (flow / topology 等の共有 lane preset) は従来どおり dragon
   // slug の prefix match に fallback する。 これらは 1 actor = 1 node (id = slug) の生成規則。
-  const matchesAliasSlug = (id: string): boolean => {
-    if (素の箱のid.has(id)) return false;
-    if (id === aliasSlug) return true;
-    if (id.startsWith(`${aliasSlug}-`)) return true;
-    // sequence step anchor = `s{N}-{aliasSlug}` pattern
-    if (/^s\d+-/.test(id) && id.endsWith(`-${aliasSlug}`)) return true;
-    return false;
-  };
+  const matchesAliasSlug = 仮の箱のidか(doc, a.name);
   const relatedToActor = (id: string): boolean =>
     ownedLaneIds.size > 0 ? ownedNodeIds.has(id) : matchesAliasSlug(id);
+  // 仮の箱が入っていた縦列。 仮の箱を消して空になった縦列は下で消す (#1973)
+  const 仮の箱の縦列 = new Set(target.nodes.filter((n) => relatedToActor(n.id)).map((n) => n.lane));
   target.nodes = target.nodes.filter((n) => !relatedToActor(n.id));
-  // edge も同経路で削除 (parts actor に接続していた flow を除去、 parts merge 後の flow は user が
-  // 別途書く経路になる)。 削除した edge の id は phase.activate に残ると dangling 参照になるため回収する。
+  // 仮の箱に繋がっていた矢印は、部品の要素へ繋ぎ直せたものだけ残す (#1979)。 以前は全て消しており、
+  // 部品へ引いた矢印が知らせも無く図から消えていた。 繋ぎ直した矢印は id を変えないので、段の
+  // 点灯 (`activate`) からも外さない。 外した矢印の id は `activate` に残ると存在しない参照になるため回収する
   const removedEdgeIds = new Set<string>();
-  target.edges = target.edges.filter((e) => {
-    const drop = relatedToActor(e.from) || relatedToActor(e.to);
-    if (drop) removedEdgeIds.add(e.id);
-    return !drop;
-  });
+  const 残す矢印: CdlEdge[] = [];
+  for (const e of target.edges) {
+    const 端 = { from: relatedToActor(e.from), to: relatedToActor(e.to) };
+    if (!端.from && !端.to) {
+      残す矢印.push(e);
+      continue;
+    }
+    const 繋いだ = 繋ぎ直す?.(e, 端);
+    if (繋いだ) 残す矢印.push(繋いだ);
+    else removedEdgeIds.add(e.id);
+  }
+  target.edges = 残す矢印;
   // lane も削除 = sequence preset は parts actor 用に lane (id = aliasSlug、 label = actor 名) を
   // 生成する。 node/edge だけ消して lane を残すと、 merge 後の part 側 lane (label = alias) と 2 本が
   // 同じ label を lane-label として描画し二重表示になる (actor ラベル二重表示 bug の root cause)。
@@ -2749,6 +3504,10 @@ function cleanupPlaceholderActor(
     if (残る箱を持つ.has(l.id)) return true;
     if (l.label === a.name) return false;
     if (l.id === aliasSlug) return false;
+    // 図種が自動で作った縦列 (`flow` 等) に部品の箱しか無かった図では、仮の箱を消すと縦列が
+    // 空のまま残る (実測 = 部品 1 つだけの図に中身の無い `flow` の縦列)。 書き手が `lanes:` に
+    // 書いた縦列は、空でも書いたとおりに残す (#1973)
+    if (仮の箱の縦列.has(l.id) && !Object.hasOwn(doc.lanes ?? {}, l.id)) return false;
     return true;
   });
   // 削除された node / edge を activate 参照している既存 phase の cleanup (node 削除と同じ判定経路
@@ -2769,6 +3528,8 @@ function mergePartsFromActors(
   partsCatalog?: Record<string, CdlDiagram>,
   onNotice?: (notice: CompileNotice) => void,
   derivedSourceLines?: Map<string, number[]>,
+  /** 矢印の id から、その矢印を書いた行。 行に書いた要素の名指しを読む (#1979) */
+  edgeSteps?: Map<string, DslStep>,
 ): CdlDiagram {
   const partsActors = doc.actors.filter((a) => a.partId !== undefined);
   if (partsActors.length === 0) return target;
@@ -2793,6 +3554,10 @@ function mergePartsFromActors(
   // 格子より先に決める。 後にすると、落とす見本が格子の枠を消費して後続がずれる
   const budget = partsBudget(target, partsActors, partsCatalog);
   const gridCenters = partGridCenters(target, doc, partsCatalog, budget, partsActors);
+  // 縦列の中に置く部品 (#1980)。 仮の箱を消す前に探す = 消した後は自分だけの縦列を見分けられない
+  const { 縦列: 縦列の部品, 基準のため外した } = 縦列に置く部品(target, doc);
+  const 縦列に置いた: 縦列に置いた部品[] = [];
+  const 自分の縦列に置いた: 自分の縦列に置いた部品[] = [];
 
   for (const [actorIndex, actor] of partsActors.entries()) {
     const partId = actor.partId;
@@ -2815,8 +3580,14 @@ function mergePartsFromActors(
           ? `要素数が上限 (${MAX_INPUT_ELEMENTS}) を超えています`
           : `図全体の要素数が上限 (${MAX_INPUT_ELEMENTS}) を超えます`,
       });
-      // 落とす時も仮の箱を掃除する。 残すと格子から外した後続の見本と重なる
-      cleanupPlaceholderActor(target, doc, actor);
+      // 落とす時も仮の箱を掃除する。 残すと格子から外した後続の見本と重なる。
+      // 部品が図に入らないので、部品へ引いた矢印も繋ぎ先が無い = 矢印ごとに知らせて外す
+      cleanupPlaceholderActor(
+        target,
+        doc,
+        actor,
+        部品の要素へ繋ぐ(actor.name, partId, undefined, edgeSteps, onNotice),
+      );
       continue;
     }
     const part = found;
@@ -2826,6 +3597,25 @@ function mergePartsFromActors(
           `[dragon] parts kind "${partId}" not found in partsCatalog (actor: ${actor.name})`,
         );
       }
+      // 一覧に無い部品は仮の箱のまま描かれ、矢印も仮の箱に繋がる。 要素の名指しは効かない
+      for (const s of doc.flow) {
+        for (const [側, 欄] of [
+          ["from", "fromPartNode"],
+          ["to", "toPartNode"],
+        ] as const) {
+          const 値 = s[欄];
+          if (値 === undefined || s[側] !== actor.name) continue;
+          // 順序図は部品の有無に依らず名指しが効かない。 そちらの知らせと 2 度出さない
+          if (doc.type === "sequence" || doc.type === "solidity") continue;
+          onNotice?.({
+            kind: "part-node-ignored",
+            actor: actor.name,
+            line: s.pos.line,
+            message: `"${truncateForMessage(actor.name)}" (${truncateForMessage(partId)}) は部品の一覧に無いため、${欄} に書いた "${truncateForMessage(値)}" は効きません`,
+            hint: "kind に部品の名前を書く (綴りを確かめる)",
+          });
+        }
+      }
       continue;
     }
     // codex-review MAJOR fix (§ sequence header/footer/spacer 削除) = preset (sequence 等) が生成した
@@ -2843,14 +3633,80 @@ function mergePartsFromActors(
     // 厳密収集する。 slug の prefix 推測を挟まないため、 slug 実装差の取りこぼしと、 別 actor を巻き込む
     // 誤削除 (parts actor `a_b` の lane id `a-b` が actor `a-b-c` の `a-b-c-header` に prefix match する)
     // の両方を同時に排除する。
-    cleanupPlaceholderActor(target, doc, actor);
+    //
+    // 仮の箱に繋がっていた矢印は、部品の図の要素へ繋ぎ直す (#1979)。
+    // 縦列に置く部品は、仮の箱の縦列を消さずに残す (#1980)。 部品用の縦列 (`名前__l`) を足すと、
+    // 縦列が書いた順ではなく仮に置いた横位置の順に並ぶ (実測 = 3 人目に書いた部品が真ん中になった)
+    const 置く縦列 = 縦列の部品.get(actor.name);
+    cleanupPlaceholderActor(
+      target,
+      doc,
+      置く縦列 !== undefined ? { name: actor.name, lane: 置く縦列 } : actor,
+      部品の要素へ繋ぐ(actor.name, partId, part, edgeSteps, onNotice),
+    );
+    const 外した縦列 = 基準のため外した.get(actor.name);
+    if (外した縦列 !== undefined) {
+      onNotice?.({
+        kind: "part-lane-ignored",
+        actor: actor.name,
+        line: actor.pos?.line ?? 0,
+        message: `"${actor.name}" は他の箱の位置の基準になっているため、縦列 "${target.lanes.find((l) => l.id === 外した縦列)?.label ?? 外した縦列}" には置かず図の下に並べました`,
+        hint: `縦列に置きたい時は、"${actor.name}" を基準にした位置 (位置: ${actor.name} の右 200 など) を座標で書く`,
+      });
+    }
     const merged = applyColorHex(part, actor.colorHex, actor.stateOverride ?? {});
+    // 色番号は部品の色の状態へ入れる。 塗りを図形に直接書いた部品 (`arc-gauge` 等) は入れる先が
+    // 無く、書いても絵が変わらない。 黙って既定の色で描くと手掛かりが残らないので知らせる (#1973)
+    if (actor.colorHex && !(part.states ?? []).some((st) => isColorValue(st.initial))) {
+      onNotice?.({
+        kind: "part-color-ignored",
+        actor: actor.name,
+        line: actor.pos?.line ?? 0,
+        message: `"${actor.name}" (${partId}) は色を変えられる状態を持たないため、色番号 ${actor.colorHex} は効きません`,
+        hint: "色を変えられる部品は、初期値が色番号の状態を持つもの (例 = state-indicator)",
+      });
+    }
+    // 色の名前は箱の色にしか効かず、部品の色の状態は色番号しか受けない。 名前の色は描く側の
+    // 配色の変数 (`--cdl-tone-*`) で決まり固定の色番号を持たないため、置き換えて入れることもしない
+    if (actor.partColorName) {
+      onNotice?.({
+        kind: "part-color-ignored",
+        actor: actor.name,
+        line: actor.pos?.line ?? 0,
+        // 残っている名前は読み替えた後の正規の名前 (`成功` なら `success`) なので文には出さない
+        message: `"${actor.name}" (${partId}) の色は色の名前では変わりません`,
+        hint: '部品の色は色番号で書く (例 = color: "#d9534f")',
+      });
+    }
+    // 上書きが読むのは部品の状態の名前と `phase` (段を外す) だけで、他の名前は何も変えない。
+    // 綴り違いや、外した欄 (`nodes`、#1976) を書いた時に、効いていない値を黙って持たない
+    const 部品の状態 = new Set((part.states ?? []).map((st) => st.id));
+    const 無い状態 = Object.keys(actor.stateOverride ?? {}).filter(
+      (k) => k !== "phase" && !部品の状態.has(k),
+    );
+    if (無い状態.length > 0) {
+      onNotice?.({
+        kind: "part-state-missing",
+        actor: actor.name,
+        line: actor.pos?.line ?? 0,
+        message: `"${actor.name}" (${partId}) は ${無い状態.map((k) => `"${truncateForMessage(k)}"`).join(" / ")} という状態を持たないため、書いた値は効きません`,
+        hint:
+          部品の状態.size > 0
+            ? `この部品の状態 = ${[...部品の状態].join(", ")}`
+            : "この部品は状態を持たないため、値を書いても変わりません",
+      });
+    }
     // 位置を書いていないパーツは格子に並べる。 書いてあればその位置を使う
     let placeX = actor.posX;
     let placeY = actor.posY;
     // 格子に落とすのは縦横どちらも書かなかった時だけ。 片方だけ書いた時に残りを格子で
     // 埋めると、 書いた値と格子が混ざった位置になる (従来の条件をそのまま保つ)
-    if (placeX === undefined && placeY === undefined) {
+    if (置く縦列 !== undefined) {
+      // 縦列の位置は図を配置するまで決まらない。 ここでは座標で置く形にだけして、
+      // 全部の部品を組み込んだ後に縦列へ寄せる (`縦列に置いた部品を揃える`)
+      placeX = 0;
+      placeY = 0;
+    } else if (placeX === undefined && placeY === undefined) {
       const center = gridCenters.get(actor.name);
       placeX = center?.cx;
       placeY = center?.cy;
@@ -2874,12 +3730,13 @@ function mergePartsFromActors(
       }
     }
     const t = partTargetSize(part, actor.posW, actor.posH, actor.scale);
-    mergePartIntoDiagram(
+    const 組み込む前の箱の数 = target.nodes.length;
+    const 作った縦列 = mergePartIntoDiagram(
       target,
       part,
       actor.name,
       merged,
-      actor.lane,
+      置く縦列 ?? actor.lane,
       placeX,
       placeY,
       t.w,
@@ -2889,10 +3746,219 @@ function mergePartsFromActors(
       derivedSourceLines,
       値の前置き.get(actor.name),
     );
+    const 要素 = new Set(target.nodes.slice(組み込む前の箱の数).map((n) => n.id));
+    if (置く縦列 !== undefined) {
+      縦列に置いた.push({ 縦列: 置く縦列, 要素 });
+    } else if (作った縦列.length > 0) {
+      自分の縦列に置いた.push({ 名前: actor.name, 縦列: 作った縦列, 要素 });
+    }
   }
+  // 部品用の縦列を先に固定する。 縦列に置く部品は配置した縦列の位置に合わせるので、固定する前に
+  // 揃えると、揃えた時の縦列 (部品用の縦列も詰める送りに加わる) と描いた図の縦列が食い違う
+  部品の縦列を部品に固定する(target, 自分の縦列に置いた);
+  縦列に置いた部品を揃える(target, 縦列に置いた);
   return target;
 }
 
+type 自分の縦列に置いた部品 = {
+  /** 登場人物の名前。 名札に使う */
+  名前: string;
+  /** 部品用に作った縦列。 部品の縦列の順 */
+  縦列: readonly 部品用の縦列[];
+  要素: ReadonlySet<string>;
+};
+
+type 部品用の縦列 = {
+  id: string;
+  /** 部品自身が縦列に書いた名札 */
+  部品の名札: string | undefined;
+};
+
+/** 部品用の縦列の、部品の要素の上端から縦列の上端までの高さ。 名札 (縦列の上端から 26 下) を収める */
+const 部品の縦列の名札の高さ = 60;
+
+/**
+ * 部品用の縦列を部品の位置に固定し、登場人物の名前の名札を部品のすぐ上に 1 つだけ出す (#1990)。
+ *
+ * 部品の要素は座標で置くが、縦列は描画側が左から詰めて並べ直す。 格子の 2 段目の部品の縦列は
+ * 1 段目の縦列と重なるため右へ送られ、名札が別の部品の上に出て、送った分だけ図が横に伸びた
+ * (実測 = 部品 4 つの流れ図で `稼働2` の名札が `稼働3` の上、図の右に 875 の空き)。 部品が 1 つでも
+ * 名札は図の上端に出て、流れ図の途中に置くと先頭の箱の見出しに見えた。
+ *
+ * 描画側は `posX` と `posY` を両方持つ縦列を置いた位置に置き、詰める送りも幅の自動拡張もしない。
+ * 幅は `posW` が無ければ縦列の `width` を使うので、横は位置だけを書く。
+ *
+ * | 向き | 固定する範囲 |
+ * |---|---|
+ * | 横 | 組み込みで決めた位置と幅のまま (部品が書いた縦列を、置いた位置へ写したもの。 #879 / #880) |
+ * | 縦 | 部品全体の上端より名札の分 (60) 上から、部品全体の下端まで。 部品の縦列は全て同じ |
+ *
+ * | 縦列 | 名札 |
+ * |---|---|
+ * | 左端が最も左の縦列 (同じなら部品の縦列の順で先) | 部品が書いた名札、無ければ登場人物の名前 |
+ * | 他の縦列 | 部品が書いた名札だけ |
+ *
+ * 縦を部品全体に揃えるのは、部品の頁の絵と同じく縦列の名札を 1 列に並べるため (部品の頁では
+ * 縦列が全て同じ上端から始まる)。 縦列ごとの要素に合わせると、左の縦列の要素が他より低い部品で
+ * 名前の名札が下がり、右の縦列の要素と重なる。
+ *
+ * **下に余白を足さない**。 縦列の枠は塗りも線も持たず絵に出ないが、図の大きさには数えられる。
+ * 足すと、部品が一番下にある図だけ図の下の空きが広がる (実測 = 箱だけの図と直す前の図は 60、
+ * 下に 25 足すと 85)。 高さを書かないと縦列は名札の分 (40) に縮み、部品の要素が縦列の外に出る。
+ *
+ * **要素の高さは配置しないと分からない** (種類ごとの既定値で描画側が決める)。 全ての部品を
+ * 組み込んだ後に 1 度だけ配置して測る。 座標で置いた要素は配置で動かないので、測った範囲に
+ * 固定しても要素は動かない。
+ *
+ * 座標で置かない要素を持つ部品は固定しない。 そういう要素は縦列の中心に描かれるため、縦列の
+ * 詰める送りを止めると要素の位置も変わる。 **この分岐はテストで覆えていない** = 本文から入力を
+ * 作れない。 格子の部品は必ず格子の中心を持ち、位置を書いた部品は縦横の両方を持つ (片方だけの
+ * 位置と基準が見つからない位置は読む段階で止まる)。 どちらも座標で置かれる (`shouldForcePos`)。
+ *
+ * 配置できない図 (描画側が止める図) では固定しない。 描画でも同じ所で止まる。
+ */
+function 部品の縦列を部品に固定する(
+  target: CdlDiagram,
+  部品たち: readonly 自分の縦列に置いた部品[],
+): void {
+  const 座標で置いた = (id: string): boolean => {
+    const n = target.nodes.find((x) => x.id === id);
+    return n !== undefined && n.posX !== undefined && n.posY !== undefined;
+  };
+  const 対象 = 部品たち.filter((p) => [...p.要素].every(座標で置いた));
+  if (対象.length === 0) return;
+  let laid: LaidDiagram;
+  try {
+    laid = layout(target);
+  } catch {
+    return;
+  }
+  for (const p of 対象) {
+    const 箱 = laid.nodes.filter((n) => p.要素.has(n.id));
+    if (箱.length === 0) continue;
+    const 上端 = Math.min(...箱.map((n) => n.cy - n.h / 2));
+    const 下端 = Math.max(...箱.map((n) => n.cy + n.h / 2));
+    const 縦列たち = p.縦列.flatMap((l) => {
+      const 縦列 = target.lanes.find((x) => x.id === l.id);
+      return 縦列 ? [{ ...l, 縦列 }] : [];
+    });
+    let 名札の縦列: (typeof 縦列たち)[number] | undefined;
+    for (const l of 縦列たち) {
+      if (名札の縦列 === undefined || (l.縦列.x ?? 0) < (名札の縦列.縦列.x ?? 0)) 名札の縦列 = l;
+    }
+    for (const l of 縦列たち) {
+      l.縦列.posX = l.縦列.x ?? 0;
+      l.縦列.posY = 上端 - 部品の縦列の名札の高さ;
+      l.縦列.posH = 下端 - 上端 + 部品の縦列の名札の高さ;
+      const 名札 = l === 名札の縦列 ? (l.部品の名札 ?? p.名前) : l.部品の名札;
+      if (名札 === undefined) delete l.縦列.label;
+      else l.縦列.label = 名札;
+    }
+  }
+}
+
+type 縦列に置いた部品 = { 縦列: string; 要素: ReadonlySet<string> };
+
+/** 部品が縦列より広い時に、縦列の左右に残す余白。 描画側が縦列の中の箱に取る最小の余白と同じ */
+const 部品の縦列の余白 = 25;
+
+/**
+ * 縦列に置いた部品を、縦列の中心と図の下へ動かす (#1980)。
+ *
+ * 部品は座標で置く (部品の中の要素の並びを保つため)。 座標で置いた箱は描画側の配置が動かさないので、
+ * 縦列の位置を知るには図を 1 度配置する。
+ *
+ * **配置は 1 度で足りる**。 縦列の横位置は縦列の幅・中の箱の幅・矢印の札で決まり、座標で置いた箱の
+ * 座標には依らない。 部品を動かしても縦列は動かない。
+ *
+ * | 向き | 置き方 |
+ * |---|---|
+ * | 横 | 部品の中心を縦列の中心に合わせる。 部品が縦列より広ければ縦列を広げ、配置し直す |
+ * | 縦 | 部品以外の箱の一番下から `PARTS_GAP` 空ける。 同じ縦列の部品は書いた順に下へ積む |
+ *
+ * **縦列の段には入れない**。 段の高さは縦列をまたいで共有され、背の高い部品を段に入れると隣の
+ * 縦列の箱まで伸びる (実測 = `受付` の高さが 68 から 380 になった)。
+ *
+ * 配置できない図 (描画側が止める図) では動かさない。 描画でも同じ所で止まるので、ここで
+ * 別の知らせは足さない。
+ */
+function 縦列に置いた部品を揃える(target: CdlDiagram, 置いた: readonly 縦列に置いた部品[]): void {
+  if (置いた.length === 0) return;
+  const 配置する = (): LaidDiagram | undefined => {
+    try {
+      return layout(target);
+    } catch {
+      return undefined;
+    }
+  };
+  let laid = 配置する();
+  if (!laid) return;
+  const 範囲 = (d: LaidDiagram, 要素: ReadonlySet<string>) => {
+    const 箱 = d.nodes.filter((n) => 要素.has(n.id));
+    if (箱.length === 0) return undefined;
+    return {
+      x0: Math.min(...箱.map((n) => n.cx - n.w / 2)),
+      x1: Math.max(...箱.map((n) => n.cx + n.w / 2)),
+      y0: Math.min(...箱.map((n) => n.cy - n.h / 2)),
+      y1: Math.max(...箱.map((n) => n.cy + n.h / 2)),
+    };
+  };
+  // 部品より狭い縦列を広げる。 描画側は縦列を中の箱 1 つの幅までしか広げず、要素を横に並べた
+  // 部品は隣の縦列へはみ出す
+  let 広げた = false;
+  for (const p of 置いた) {
+    const r = 範囲(laid, p.要素);
+    const 縦列 = target.lanes.find((l) => l.id === p.縦列);
+    const 描いた縦列 = laid.lanes.find((l) => l.id === p.縦列);
+    if (!r || !縦列 || !描いた縦列) continue;
+    const 要る幅 = r.x1 - r.x0 + 部品の縦列の余白 * 2;
+    if (要る幅 > 描いた縦列.width && 要る幅 > 縦列.width) {
+      縦列.width = 要る幅;
+      広げた = true;
+    }
+  }
+  if (広げた) {
+    laid = 配置する();
+    if (!laid) return;
+  }
+  // 動かした後に配置し直して確かめ、狙いと合うまで繰り返す。 座標で置いた箱が他の箱と重なると
+  // 描画側は他の箱を下げるため、仮の位置 (図の上端) のまま測った下端は実際より下にずれる
+  // (実測 = 狙った上端 316 が 400 になった)。 部品を図の下へ動かせば重ならなくなり、2 回目で合う
+  const 部品の要素 = new Set(置いた.flatMap((p) => [...p.要素]));
+  for (let 回 = 0; 回 < 部品を揃え直す上限; 回 += 1) {
+    // 下端は部品以外の箱 (格子に並べた部品を含む) と縦列の名札で測る。 箱を囲む縦列 (`contain`) は
+    // 仮に置いた部品まで囲んでいるため数えない = 中の箱は箱として数えている
+    const 他の箱の下端 = Math.max(
+      ...laid.nodes.filter((n) => !部品の要素.has(n.id)).map((n) => n.cy + n.h / 2),
+      ...laid.lanes.filter((l) => !l.contain).map((l) => l.y + l.height),
+    );
+    const 次の上端 = new Map<string, number>();
+    let 動かした = false;
+    for (const p of 置いた) {
+      const r = 範囲(laid, p.要素);
+      const 縦列 = laid.lanes.find((l) => l.id === p.縦列);
+      if (!r || !縦列) continue;
+      const 上端 = 次の上端.get(p.縦列) ?? 他の箱の下端 + PARTS_GAP;
+      const dx = 縦列.x + 縦列.width / 2 - (r.x0 + r.x1) / 2;
+      const dy = 上端 - r.y0;
+      次の上端.set(p.縦列, 上端 + (r.y1 - r.y0) + PARTS_GAP);
+      if (Math.abs(dx) <= PLACEMENT_TOLERANCE && Math.abs(dy) <= PLACEMENT_TOLERANCE) continue;
+      for (const n of target.nodes) {
+        if (!p.要素.has(n.id) || n.posX === undefined || n.posY === undefined) continue;
+        n.posX += dx;
+        n.posY += dy;
+      }
+      動かした = true;
+    }
+    if (!動かした) return;
+    laid = 配置する();
+    if (!laid) return;
+  }
+}
+
+/** 縦列に置いた部品を配置し直して確かめる回数の上限。 実測では 2 回目で動かなくなる */
+const 部品を揃え直す上限 = 3;
+
 /**
  * 状態の初期値に上書きを当てた結果と、 色として読めないため捨てたかどうか。
  *
@@ -2942,6 +4008,38 @@ function applyColorHex(
   return out;
 }
 
+/**
+ * 本文に書いた状態の上書きと色番号を、部品の図そのものに当てて返す (#1973)。
+ *
+ * 編集画面の本文欄は、部品を図から抜いて別に重ねて描く。 重ねる側が部品の図をそのまま
+ * 描くと、`state: { lvl: 0.4 }` や `color: "#d9534f"` がカタログの絵にだけ効き、
+ * 編集画面では既定の値で描かれる。 値の決め方は組み立て側と同じ 2 つの関数を通す。
+ *
+ * `phase: false` は組み立て側と同じく部品の段を外す。 段の数は残し、中身 (点灯と値の変化)
+ * だけを空にする = 段を消すと、重ねた部品だけ段の進みが止まらない形になる。
+ *
+ * 色として読めない上書きは組み立て側と同じく捨てる。 知らせは組み立て側が出すため、
+ * ここでは出さない (同じ本文で 2 度出さない)。
+ */
+export function 部品に上書きを当てる(
+  part: CdlDiagram,
+  actor: Pick<DslActor, "stateOverride" | "colorHex">,
+): CdlDiagram {
+  const 上書き = applyColorHex(part, actor.colorHex, actor.stateOverride ?? {});
+  const 段を外す = 上書き["phase"] === false;
+  if (Object.keys(上書き).length === 0) return part;
+  return {
+    ...part,
+    states: part.states.map((st) => ({
+      ...st,
+      initial: resolveStateOverride(st.initial, 上書き[st.id]).initial,
+    })),
+    phases: 段を外す
+      ? part.phases.map((ph) => ({ ...ph, activate: [], tweens: [], sets: [] }))
+      : part.phases,
+  };
+}
+
 /**
  * CAR-1657 = parts CdlDiagram (単一 part 内容) を target CdlDiagram に prefix 付きで merge する。
  * alias = user が書く actor 名 ('arc1')、 全 id を '{alias}__{origId}' で prefix、 lane 参照 rename、
@@ -3030,7 +4128,7 @@ function mergePartIntoDiagram(
    * 登場人物の名前をそのまま使えない。 渡されない経路では従来どおり名前をそのまま使う
    */
   valueAlias?: string,
-): void {
+): 部品用の縦列[] {
   const prefix = (id: string): string => `${alias}__${id}`;
   // 値と状態だけ別の前置きを使う (#1189)。 箱 / 縦列 / 矢印の id は `prefix` のまま
   const 値前置き = valueAlias ?? alias;
@@ -3069,11 +4167,13 @@ function mergePartIntoDiagram(
   // 決定的 lane 参照 = user が書いた lane 指定を優先、 なければ parts 内部 lane を prefix 付きで作る
   const targetLaneId = laneMapping;
   const laneIdMap = new Map<string, string>();
+  // 部品用に作った縦列。 組み込んだ後に部品の位置へ固定する (#1990)
+  const 作った縦列: 部品用の縦列[] = [];
   // parts lane の横位置。
   //   offset (drop / click 座標) 指定時 = part 中心を offsetX に合わせる = user が置いた位置に
   //     parts の中心が来る。 node は lane 中心 (lane.x + laneW/2) に描画されるため、 lane 左端を
   //     offsetX - laneW/2 に置くと node 中心 = offsetX となり cursor / viewport 中央に一致する
-  //     (縦方向 offsetY と対称、 offsetY 側は partCenterStack で既に中心合わせ済)。
+  //     (縦方向 offsetY と対称、 offsetY 側は要素全体の縦の中心で合わせる = `部品の置き方を読む`)。
   //     従来の auto-adjust (max(offsetX, existingMax + gap) で既存 lane 右端へ強制右寄せ) は user
   //     directive で廃止 (2026-07-21)。 重なりは user の意図位置を優先し、 手動移動で回避する経路。
   //   未指定 (座標なし fallback) 時のみ existingMax + gap で右外配置 (通常経路は drop/click で座標を渡す)。
@@ -3084,37 +4184,26 @@ function mergePartIntoDiagram(
   // scale 基準は part 全体の bbox 幅 (全 lane の最左端〜最右端) にする。 lane[0] 幅だけを基準にすると
   // multi-lane part (複数 lane を横に並べた part) で全体幅を過小評価し、 非先頭 lane の node が自 lane
   // 中心からずれる (#880)。
-  // 縦列の位置と幅を先に正す。 catalog は呼出側が渡す値で、 生値のまま bbox を出すと
-  // 拡大の基準が 1 に落ちて箱が桁違いに大きくなる (実測 = 指定間隔 200 が -31800 になった)
-  const partLaneGeom = new Map<string, { x: number; w: number }>();
-  for (const l of part.lanes) {
-    partLaneGeom.set(l.id, {
-      x: typeof l.x === "number" && Number.isFinite(l.x) ? l.x : 0,
-      w: positiveOr(l.width, 400),
-    });
-  }
-  const laneXs = [...partLaneGeom.values()].map((g) => g.x);
-  const laneRights = [...partLaneGeom.values()].map((g) => g.x + g.w);
-  const partMinLaneX = minOf(laneXs, 0);
-  const partMaxLaneRight = maxOf(laneRights, 400);
-  // 幅は max >= min で常に非負。 正の幅 (極小 sub-pixel 含む) はそのまま scale 基準に使い、
-  // 0 (全 lane が同一 x + 幅 0 の退化ケース) の時だけ除算保護で 1 に fallback する。
-  // Math.max(1, w) だと 0 < w < 1 の正当な幅まで 1 に floor して over-scale するため使わない。
-  const rawBboxW = partMaxLaneRight - partMinLaneX;
-  const partsBboxW = rawBboxW > 0 ? rawBboxW : 1;
+  //
+  // 縦列の位置と幅、要素の中心は部品の頁で配置した値を使う (`部品の置き方を読む`、#1992)。
+  // 書いた値で置くと、頁で描画側が広げた縦列の間と段の間が消え、要素が頁より詰まる。
+  // 伸縮の基準は画面側 (`partScaleFactor`) と同じ関数から取る
+  const 置き方 = 部品の置き方を読む(part);
+  const 伸縮の基準 = partScaleBase(part);
   // 非有限は 1 に倒す。 桁が溢れた `大きさ:` (`Number()` が Infinity を返す長さ) を
   // そのまま掛けると描けない座標になり、 大きさを見積る側 (`partTargetScale`) だけが
   // 1 に倒していたため経路で食い違っていた (#1018)
-  const rawLaneScaleX = targetW !== undefined && targetW > 0 ? targetW / partsBboxW : 1;
+  const rawLaneScaleX = targetW !== undefined && targetW > 0 ? targetW / 伸縮の基準.w : 1;
   const laneScaleX = Number.isFinite(rawLaneScaleX) && rawLaneScaleX > 0 ? rawLaneScaleX : 1;
   // part 全体を「元 bbox 中心 → drop 座標」 の scale 変換で写す単一式 mapLaneX。 lane も node も同じ式で
   // 変換し、 lane.x = mapLaneX(元 lane 左端) にすることで全 lane / 全 node が一貫して drop 座標を中心に
   // scale 配置される (cc-codex #879 の mapPartX と同じ発想を lane push まで前倒し、 #880 root fix)。
-  const partOrigBboxCenterX = partMinLaneX + partsBboxW / 2;
+  // node 側は `部品の要素のずれ` が同じ中心と倍率で写す
+  const partOrigBboxCenterX = 置き方.左端 + 置き方.幅 / 2;
   const dropCenterX =
     offsetX !== undefined
       ? offsetX
-      : existingLaneMaxX + PARTS_LANE_GAP + (partsBboxW * laneScaleX) / 2;
+      : existingLaneMaxX + PARTS_LANE_GAP + (置き方.幅 * laneScaleX) / 2;
   const mapLaneX = (x: number): number => (x - partOrigBboxCenterX) * laneScaleX + dropCenterX;
 
   for (const laneOrig of part.lanes) {
@@ -3126,7 +4215,7 @@ function mergePartIntoDiagram(
       // lane の左端を mapLaneX で変換 = 元 lane 左端 (x) を scale 変換後の位置に置く。 lane 幅も
       // scale して lane 中心が mapLaneX(元 lane 中心) に一致する。 これで multi-lane でも各 lane が
       // part 全体の scale 変換に沿って配置される。
-      const geom = partLaneGeom.get(laneOrig.id) ?? { x: 0, w: 400 };
+      const geom = 置き方.縦列.get(laneOrig.id) ?? { x: 0, w: 400 };
       target.lanes.push({
         ...laneOrig,
         id: newLaneId,
@@ -3134,6 +4223,7 @@ function mergePartIntoDiagram(
         x: mapLaneX(geom.x),
         width: geom.w * laneScaleX,
       });
+      作った縦列.push({ id: newLaneId, 部品の名札: laneOrig.label });
     }
   }
 
@@ -3144,8 +4234,8 @@ function mergePartIntoDiagram(
   //             (1) 全 parts node に posX/posY 明示 set (CDL layout の絶対配置経路 = stack 計算 skip)
   //             (2) parts の stack 番号を target 側 max stack + STACK_ISOLATION_OFFSET (1000) に shift
   //                 = 万一 layout が rowH で参照しても sequence stack と重ならず影響 0 化
-  //   D1 = drop 座標尊重の縦方向 = parts の元 stack (0..N) から近似 pitch で cy を組み立て、
-  //        offsetY を加算して drop 座標付近に描画。 lane.x + lane.width/2 + offsetX で横位置。
+  //   D1 = drop 座標尊重 = 部品の頁で配置した要素の中心を、部品の中心が drop 座標に来るよう
+  //        写して描画する (#1992、`部品の要素のずれ`)。
   //
   const STACK_ISOLATION_OFFSET = 1000;
   const shouldForcePos = offsetX !== undefined || offsetY !== undefined;
@@ -3160,34 +4250,23 @@ function mergePartIntoDiagram(
   // に対する比率 = scale 係数、 全 sub-node の w / h + cx / cy 相対位置に scale 反映。
   // scaleX は lane push と同じ part bbox 幅基準 (laneScaleX) を使う = multi-lane で lane と node の
   // scale 係数が一致する (#880、 lane[0] 幅基準だと非先頭 lane の node がずれる)。
-  // parts 内部 stack 別の垂直 pitch (world unit)。 CDL layout の実 stackGap (~100) +
-  // 標準 node h (~140-200) の合計相当。 parts の cy を厳密に再現しないが、 渡した座標付近に
-  // parts が中心配置される見た目に十分な近似。
-  //
-  // 実配置に置き換える案を試したが、 拡大の基準 (縦列基準 → 箱基準) まで変わって既存の
-  // 期待 14 件が崩れた。 段を持つパーツ (実 catalog で 80 件中 7 件) の内部比率が実配置と
-  // 3% ずれるが、 見た目の大きさは呼出側が揃えるため観測される差は無い
-  const STACK_PITCH_APPROX = 220;
-  // 数でない段は 0 として扱う。 大きさを見積る側 (`partTargetScale`) が同じ判定をしており、
-  // ここだけ NaN を通すと段の数が NaN になって倍率が経路で食い違う (#1018)
-  const partStacks = part.nodes.map((n) =>
-    typeof n.stack === "number" && Number.isFinite(n.stack) ? n.stack : 0,
-  );
-  const minStack = partStacks.length > 0 ? Math.min(...partStacks) : 0;
-  const maxStack = partStacks.length > 0 ? Math.max(...partStacks) : 0;
-  const partCenterStack = (minStack + maxStack) / 2;
-  const partOrigH = Math.max(1, (maxStack - minStack + 1) * STACK_PITCH_APPROX);
+  // 縦の基準は段の送り幅の合計 (`partScaleBase`)。 `大きさ:` の縦は、この合計に対する倍率で掛かる
   const scaleX = laneScaleX;
-  const rawScaleY = targetH !== undefined && targetH > 0 ? targetH / partOrigH : 1;
+  const rawScaleY = targetH !== undefined && targetH > 0 ? targetH / 伸縮の基準.h : 1;
   const scaleY = Number.isFinite(rawScaleY) && rawScaleY > 0 ? rawScaleY : 1;
 
+  // 縦列を 2 本以上持つ部品を 1 本の縦列へまとめる時は、要素ごとに別の段番号を振る (#1980)。
+  // 元の段番号のままだと横に並んでいた要素が同じ段で重なり、配置が止まる (実測 =
+  // `lane "b" の stack=1000 に node が重複`)。 座標で置く要素の位置は段番号で決まらないので、
+  // 振り直しても絵は変わらない
+  const 段を振り直す = targetLaneId !== undefined && shouldForcePos && part.lanes.length > 1;
   // node merge = id prefix + lane 参照 rewrite + shape / subtitle / value 内 template rewrite
-  for (const nodeOrig of part.nodes) {
+  for (const [nodeIndex, nodeOrig] of part.nodes.entries()) {
     const mappedLane = laneIdMap.get(nodeOrig.lane) ?? nodeOrig.lane;
     // codex-review MAJOR fix (§ nested shape template) = recursive walk で shape 内 nested object /
     // array の string leaf 全対象、 前実装は 1 depth のみで `fill: { gradient: "{v}" }` 等 miss。
     let newShape = nodeOrig.shape
-      ? deepRewriteStrings(nodeOrig.shape as unknown, rewriteTemplate)
+      ? deepRewriteStrings(nodeOrig.shape, rewriteTemplate)
       : undefined;
     // parts 全体 resize (I2 forensic): shape 内 radius / outerRadius / innerRadius / thickness に
     // scale 反映 = user が SE handle drag で拡大すると shape の見た目も比例拡大される。 scaleX を採用
@@ -3211,31 +4290,24 @@ function mergePartIntoDiagram(
         }
         return out;
       };
-      newShape = scaleGeom(newShape) as typeof newShape;
+      newShape = scaleGeom(newShape);
     }
     // parts drop 位置 offset 反映:
-    //   - node.posX set 済 (parts が絶対座標を持つ) = その posX を part 中心基準で scale 変換
-    //   - offsetX 指定時 (drop 経路) で posX 未設定 = node が属する lane 中央を同じ式で変換
-    //   - offset なし (従来経路) は auto layout 継続 (posX undefined)
+    //   - node.posX / posY set 済 (parts が座標を持つ) = 横は part 中心基準で scale 変換、縦は offsetY を足す
+    //   - offset 指定時 (drop 経路) で未設定 = 部品の頁で配置した node の中心を同じ式で変換
+    //   - offset なし (従来経路) は auto layout 継続 (posX / posY undefined)
     //
-    // 明示 posX と auto-layout の両経路を、 lane push と同じ単一式 mapLaneX で変換する
-    // (cc-codex #879 Round 2/3 MAJOR + #880)。 mapLaneX は part bbox 中心 → drop 座標の scale 変換で、
-    // lane / node / 明示 posX / auto-layout の全経路がこの 1 式を共有するため、 lane.x != 0 でも
-    // multi-lane でも node 中心と自 lane 中心が一致する。
-    let nodePosX: number | undefined =
-      nodeOrig.posX !== undefined ? mapLaneX(nodeOrig.posX) : undefined;
-    let nodePosY: number | undefined =
-      nodeOrig.posY !== undefined ? nodeOrig.posY + (offsetY ?? 0) : undefined;
-    if (shouldForcePos && nodePosX === undefined) {
-      // posX を持たない node は所属 lane の中央 (auto layout の cx 相当) を同じ mapLaneX で変換する。
-      const geom = partLaneGeom.get(nodeOrig.lane) ?? { x: 0, w: 320 };
-      nodePosX = mapLaneX(geom.x + geom.w / 2);
-    }
-    if (shouldForcePos && nodePosY === undefined) {
-      // parts の元 stack から近似 pitch で cy を組み立て、 全 parts の中心が offsetY に来るよう調整
-      const stack = nodeOrig.stack ?? 0;
-      nodePosY = (stack - partCenterStack) * STACK_PITCH_APPROX * scaleY + (offsetY ?? 0);
-    }
+    // 明示 posX と頁の中心の両経路を、 lane push と同じ中心と倍率で写す (cc-codex #879 Round 2/3
+    // MAJOR + #880)。 写す式は見積り (`partExtent`) と共有する `部品の要素のずれ` が持つため、
+    // lane.x != 0 でも multi-lane でも node 中心と自 lane 中心が一致し、格子が確保した場所とも一致する。
+    //
+    // offset なしの経路 (格子が場所を返さない部品だけが通る) では、node が書いた縦位置は
+    // `...nodeOrig` がそのまま残す。 足す offsetY が無いので写す必要が無い
+    const 頁 = 置き方.要素[nodeIndex] ?? { x: partOrigBboxCenterX, y: 0 };
+    const ずれ = 部品の要素のずれ(nodeOrig, 頁, 置き方, scaleX, scaleY);
+    const nodePosX =
+      shouldForcePos || nodeOrig.posX !== undefined ? dropCenterX + ずれ.dx : undefined;
+    const nodePosY = shouldForcePos ? (offsetY ?? 0) + ずれ.dy : undefined;
     // parts sub-node の w / h に scale 適用 (I2 forensic 対応、 targetW/H 指定時のみ)
     // catalog の値は呼出側が渡すので、 拡大しない時も数として通るか確かめる。 通さないと
     // 座標が非有限になって図が描けない (実測 = 箱の中心が NaN になった)
@@ -3253,7 +4325,7 @@ function mergePartIntoDiagram(
       subtitle: rewriteTemplate(nodeOrig.subtitle),
       value: rewriteTemplate(nodeOrig.value),
       // parts stack を target 側と分離 (D2 fix、 posX/posY 明示との 2 段防御)
-      stack: (nodeOrig.stack ?? 0) + stackShiftBase,
+      stack: (段を振り直す ? nodeIndex : (nodeOrig.stack ?? 0)) + stackShiftBase,
       ...(newShape ? { shape: newShape as CdlDiagram["nodes"][number]["shape"] } : {}),
       ...(nodePosX !== undefined ? { posX: nodePosX } : {}),
       ...(nodePosY !== undefined ? { posY: nodePosY } : {}),
@@ -3312,7 +4384,7 @@ function mergePartIntoDiagram(
     if (!target.readouts) target.readouts = [];
     for (const readoutOrig of part.readouts) {
       const rewritten = deepRewriteStrings(
-        readoutOrig as unknown,
+        readoutOrig,
         rewriteTemplate,
       ) as CdlDiagram["readouts"] extends readonly (infer R)[] ? R : never;
       // id は shape 全 walk で rewrite されないので個別に prefix
@@ -3328,7 +4400,7 @@ function mergePartIntoDiagram(
   // は union。 stateOverride.phase === false 時は parts phase 破棄 (opt-out)。
   const phaseOptOut = stateOverride["phase"] === false;
   if (phaseOptOut) {
-    return; // parts phase を破棄、 activate / tweens / sets の rewrite 不要
+    return 作った縦列; // parts phase を破棄、 activate / tweens / sets の rewrite 不要
   }
   if (target.phases.length === 0) {
     // target に phase なし = parts phase をそのまま追加 (prefix 付き)
@@ -3373,6 +4445,7 @@ function mergePartIntoDiagram(
       });
     }
   }
+  return 作った縦列;
 }
 
 /**
@@ -3387,8 +4460,8 @@ function deepRewriteStrings(
 ): unknown {
   if (typeof value === "string") return rewrite(value) ?? value;
   if (value === null || typeof value !== "object") return value;
-  if (seen.has(value as object)) return value;
-  seen.add(value as object);
+  if (seen.has(value)) return value;
+  seen.add(value);
   if (Array.isArray(value)) {
     return value.map((v) => deepRewriteStrings(v, rewrite, seen));
   }
@@ -3416,13 +4489,19 @@ function applyEdgeInlineOptions(
   doc: DslDocument,
   /** 対応が取れた edge を記録する表。 callback は呼ばない (1 edge = 1 回にするため)。 */
   sourceLines?: Map<string, number>,
+  /** 対応が取れた edge の行そのもの。 部品の取り込みが、行に書いた要素の名指しを読む (#1979) */
+  edgeSteps?: Map<string, DslStep>,
+  /** 鎖に並べない部品を決める一覧 (#1987)。 `compileFlow` に渡したものと同じ */
+  partsCatalog?: Record<string, CdlDiagram>,
 ): void {
   // **静止した `type: flow` は書いた端で対応が取れない** (#1267)。 鎖の規則で先に埋める
   if (鎖でつなぐ形か(doc)) {
+    const 並び = 鎖に並べる登場人物(doc, partsCatalog);
     diagram.edges.forEach((e, idx) => {
-      const s = 鎖のどの行から来たか(doc, idx);
+      const s = 鎖のどの行から来たか(doc, 並び, idx);
       if (s === undefined) return;
       sourceLines?.set(e.id, s.pos.line);
+      edgeSteps?.set(e.id, s);
       矢印へ書き写す(e, s, doc);
     });
     return;
@@ -3441,6 +4520,7 @@ function applyEdgeInlineOptions(
     if (!target) return;
     used.add(target.id);
     sourceLines?.set(target.id, s.pos.line);
+    edgeSteps?.set(target.id, s);
     矢印へ書き写す(target, s, doc);
   });
 }
@@ -3493,7 +4573,11 @@ function 矢印へ書き写す(target: CdlEdge, s: DslStep, doc: DslDocument): v
   // **書いた補足が勝つ** (#1275)。 ここで写さないと 2 つ落ちる。 静止した `type: flow` は
   // 鎖を作る時に説明文しか渡さないため補足が消え、`er` は見本が多重度から作った補足が
   // 残って書いた値が無視される (どちらも実測)
-  if (s.sub !== undefined) target.sub = s.sub;
+  //
+  // **クラス図の `sub` は多重度なので写さない** (#1769)。 クラス図の組み立てが既に `cardinality` として
+  // 渡し、engine が行き先の端に添える (cdl#821)。 ここで札の下の行にも写すと、`1..*` が札と端の
+  // 2 か所に出て、組み立て器で書いた同じ図と食い違う (実測 = 記法の見本が組み立て器の見本と一致しなくなった)
+  if (s.sub !== undefined && doc.type !== "class") target.sub = s.sub;
   if (s.guard !== undefined) {
     target.guard = s.guard;
     // FSM preset では sub が guard 同期、 author 明示 guard を sub に反映 (sub 既存なら上書きしない)
@@ -3523,6 +4607,12 @@ function 矢印へ書き写す(target: CdlEdge, s: DslStep, doc: DslDocument): v
   if (s.labelPlate !== undefined) target.labelPlate = s.labelPlate;
   if (s.labelOffsetX !== undefined) target.labelOffsetX = s.labelOffsetX;
   if (s.labelOffsetY !== undefined) target.labelOffsetY = s.labelOffsetY;
+  // 矢印の位置のずらし (#1971)。 矢印は自分の位置を持たず、通り道は両端の箱で決まるので、
+  // 動かせるのは名前だけ。 名前のずらしに足す = 両方書いた時は合わせた量だけ動く
+  if (s.layoutPos !== undefined) {
+    target.labelOffsetX = (s.labelOffsetX ?? 0) + s.layoutPos.x;
+    target.labelOffsetY = (s.labelOffsetY ?? 0) + s.layoutPos.y;
+  }
   if (s.overlay !== undefined) target.overlay = s.overlay;
   // 値に追随する 3 欄 (#1396)。 太さ / 色 / 破線の位置が値に合わせて動く。
   // 通り道そのものは動かないので、配置計算と重なり解消には影響しない
@@ -3534,15 +4624,48 @@ function 矢印へ書き写す(target: CdlEdge, s: DslStep, doc: DslDocument): v
 /**
  * 静止した `type: flow` かどうか。 この形だけ矢印を鎖状に作る (`compileFlow`)。
  *
- * 段を持つ形と縦列を書いた形は generic 経路へ回るため鎖にならない。 判定を 1 か所に
- * 集めるのは、`compileFlow` の分岐と食い違うと対応の取り方だけがずれるため。
+ * 段を持つ形・縦列を書いた形・向きを書いた形は generic 経路へ回るため鎖にならない。
+ *
+ * **`compileFlow` の分岐もこの判定を使う**。 判定を 2 か所に書くと、組み立てだけが別経路へ回り、
+ * 行の対応と端の知らせが鎖のまま残る。 向きを書いた形 (#1494) は組み立てにだけ足され、`A -> C` に
+ * 書いた `head` が `C -> B` に載り、書いた端のとおりの矢印に「端は使われません」 が出ていた (#1986)。
  */
 function 鎖でつなぐ形か(doc: DslDocument): boolean {
   if (doc.type !== "flow") return false;
   if (doc.animate && doc.animate.phases.length > 0) return false;
+  if (doc.direction !== undefined) return false;
   return !書いた縦列に置く("flow", doc);
 }
 
+/**
+ * 静止した流れ図の鎖に並べる登場人物 (#1987)。
+ *
+ * **どの行にも書かれていない部品は鎖に並べない**。 並べると、部品の前後の並び順の矢印は書き手が
+ * 部品へ引いたものではないため部品へ繋がずに外され (#1979)、部品を途中に置いた図から矢印が全て
+ * 消えていた (実測 = `受付 / 印 / 出荷` で矢印 0 本、知らせ 0 件)。 編集画面は部品を本文から抜いてから
+ * 鎖を作るので `受付 -> 出荷` を描き、カタログと絵が食い違っていた。 部品は図の下の格子に置くため、
+ * 鎖から外しても流れの列に空きは生まれない。
+ *
+ * - 部品の一覧に無い部品は仮の箱のまま描かれるので残す (一覧を渡さない組み立ても同じ)
+ * - 大きすぎて取り込まない部品は一覧にあるので外す (図に入らない場所へ鎖を通さない)
+ * - 行の端に書かれた部品は残し、#1979 の繋ぎ方に従う
+ *
+ * 鎖を作る `compileFlow`、行との対応 (`鎖のどの行から来たか`)、端の知らせ
+ * (`reportFlowEndpointNotHonored`) の 3 つがこの並びを使う。 1 つでも `doc.actors` を見ると、
+ * N 本目の矢印と行の対応がずれる。
+ */
+function 鎖に並べる登場人物(
+  doc: DslDocument,
+  partsCatalog: Record<string, CdlDiagram> | undefined,
+): DslActor[] {
+  if (!partsCatalog) return doc.actors;
+  const 行に書かれた = new Set(doc.flow.flatMap((s) => [s.from, s.to]));
+  // 部品でない箱は `partId` を持たず一覧を引けないので、一覧に無い部品と同じく残る
+  return doc.actors.filter(
+    (a) => 行に書かれた.has(a.name) || lookupPartRaw(partsCatalog, a.partId) === undefined,
+  );
+}
+
 /**
  * 鎖の N 本目の矢印が、本文のどの行から来たかを返す (#1267)。
  *
@@ -3552,8 +4675,12 @@ function 鎖でつなぐ形か(doc: DslDocument): boolean {
  *
  * 説明文を決めた規則と同じ規則で指定も決める = 説明文と指定が必ず同じ行から来る。
  */
-function 鎖のどの行から来たか(doc: DslDocument, edgeIndex: number): DslStep | undefined {
-  const to = doc.actors[edgeIndex + 1];
+function 鎖のどの行から来たか(
+  doc: DslDocument,
+  並び: readonly DslActor[],
+  edgeIndex: number,
+): DslStep | undefined {
+  const to = 並び[edgeIndex + 1];
   if (to === undefined) return undefined;
   return doc.flow.find((s) => s.to === to.name);
 }
@@ -4077,6 +5204,16 @@ const VALUE_NOTICE_HINT: Readonly<Record<string, string>> = {
  * `mind-map` は engine 側でその性質を持ち続けており、 記法が到達しないのは当時の
  * `compileMind` の実装によるものだった。 `#1177` で `compileMind` を `mind-map` に寄せたため、
  * **今は記法からも到達する** (一覧へ戻す作業が要らなかったのはこのため)。
+ *
+ * ## 図表の種別は 1 つ残らず載せる (#1668)
+ *
+ * 弧と帯で量を表す 3 種 (`chart-gauge` / `chart-radial` / `chart-stacked-bar`) と、
+ * 値 1 つを大きく示す 2 種 (`chart-stat` / `chart-waffle`) が抜けていた。 5 種とも中身を
+ * payload で受け取って 1 箱で描く = この一覧が言う性質をそのまま持つ。
+ *
+ * 抜けている間、段の `draw:` を書いても指す先が引けず **書けるのに動かない** 状態になる
+ * (`draw` の解決は「1 箱で描く箱がちょうど 1 つ」 を条件にしている)。 `focus:` で登場人物の
+ * 名前を書いた時に何も光らないのも同じ穴で、載せると図の箱が光るようになる。
  */
 const SINGLE_BOX_KINDS: ReadonlySet<string> = new Set([
   "chart-pie",
@@ -4090,6 +5227,14 @@ const SINGLE_BOX_KINDS: ReadonlySet<string> = new Set([
   "journey-map",
   // 2 時点を直線でつなぐ図も 1 箱で全体を描く (#1647)
   "chart-slope",
+  // 弧と帯で量を表す 3 種も 1 箱で全体を描く (#1668)
+  "chart-gauge",
+  "chart-radial",
+  "chart-stacked-bar",
+  // 値 1 つを大きく示す図と、1 個 = 1% の印を埋める図も同じ (#1668)。
+  // 段の `draw:` は受けない (描画側が起点から描く動きを持たない) が、性質は同じなので載せる
+  "chart-stat",
+  "chart-waffle",
 ]);
 
 
@@ -4114,18 +5259,19 @@ const SINGLE_BOX_KINDS: ReadonlySet<string> = new Set([
  * するため、 #998)。
  */
 /**
- * v0.5+ groups section を topology preset 経由の diagram に container lane として反映。
- * group.lanes に含まれる lane id 集合に対し、 wrap する `group-{id}` lane を contain: true で生成。
+ * v0.5+ groups section を、 束ねる縦列に重ねる枠の縦列 (`group-{id}`、 contain: true) として図に足す。
  *
- * 簡易実装 ... group container lane を独立 lane として並べ、 lane label に group.label を採用。
- * lane の物理的内包 (子 lane を group container の x 内に再配置) は engine layout に委ねる範囲外なので、
- * 本実装は CdlDiagram 上に「contain: true な group container lane」 を追加する最小骨格に留める。
+ * ここでは枠を作るだけで、 位置と大きさは縦列の位置が全て決まった後に `applyGroupFrames` が決める。
+ * 作った枠の id を返す = 同じ id の縦列を書き手が `lanes:` に書いていた時は作らず、 後で置き直さない。
  */
-function applyGroupContainers(diagram: CdlDiagram, doc: DslDocument): void {
-  if (!doc.groups || Object.keys(doc.groups).length === 0) return;
+function applyGroupContainers(diagram: CdlDiagram, doc: DslDocument): Set<string> {
+  const 作った = new Set<string>();
+  if (!doc.groups || Object.keys(doc.groups).length === 0) return 作った;
   for (const [id, g] of Object.entries(doc.groups)) {
     const containerId = `group-${id}`;
-    if (diagram.lanes.some((l) => l.id === containerId)) continue;
+    // 書き手が `lanes:` に同じ id を書いた縦列は、ここより後で図に入る。 枠として作ると書いた縦列と
+    // 重なって 1 本になり、 置き直しが書き手の位置と幅を上書きする
+    if (diagram.lanes.some((l) => l.id === containerId) || doc.lanes?.[containerId]) continue;
     diagram.lanes.push({
       id: containerId,
       width: 800,
@@ -4134,7 +5280,119 @@ function applyGroupContainers(diagram: CdlDiagram, doc: DslDocument): void {
       // 束ねる lane 群に重ねて描く枠。 横に並べる lane ではないので、 engine の間隔調整
       // (lane を詰めた分を幅で埋め合わせる処理) の対象から外す。
       role: "overlay",
+      // 置き直すまでは座標を固定しておく。 固定しない枠は縦列の並びに加わり、 他の縦列の間隔を
+      // 広げる (実測 = 3 本の縦列の 2 本目が 666 から 710 へ動いた)。 並びから外した配置で測らないと、
+      // 枠を置いた後に縦列が詰め直されて枠から外れる
+      posX: 0,
+      posY: 0,
+      posW: 1,
+      posH: 1,
     });
+    作った.add(containerId);
+  }
+  return 作った;
+}
+
+/**
+ * 組の枠と束ねた縦列の間の余白。
+ *
+ * | 向き | 値 | 理由 (実測) |
+ * |---|---|---|
+ * | 上 | 40 | 枠の名札を縦列の名札に重ねない高さ。 0 で 74 重なり、 40 で重ならない |
+ * | 下 | 20 | 箱の下端から枠を離す |
+ * | 横 (囲いを持つ縦列) | 20 | 枠を縦列の囲いの線に重ねない。 囲いを持つ縦列の間は矢印の名前が入る広さがある |
+ * | 横 (囲いの無い縦列) | 0 | 縦列の端は箱から既に離れている。 20 取ると、 縦列の間に置いた矢印の名前を枠の線が貫く (箱の種別 `person` で 8 食い込んだ) |
+ */
+const 組の枠の余白 = { 上: 40, 下: 20, 囲いの横: 20, 囲いの無い横: 0 } as const;
+
+/**
+ * 組 (`groups:`) の枠を、 束ねた縦列とその中の箱を全て囲む位置と大きさに置く (#1972)。
+ *
+ * **縦列の位置が全て決まった後に 1 度だけ配置して測る**。 枠は作った時から座標を固定してあるので、
+ * 枠を置いても他の縦列は動かない (固定した縦列は並びに加わらない)。
+ *
+ * 束ねた縦列の扱い。
+ *
+ * | 状態 | 扱い |
+ * |---|---|
+ * | 図に無い縦列を書いた | その縦列を除いて囲み、 無いことを知らせる |
+ * | 図に在る縦列が 1 本も無い | 枠を作らず、 知らせる (図の端に何も囲まない枠を描かない) |
+ * | 間に束ねない縦列を挟む | 間の縦列ごと囲み、 挟んだ縦列を知らせる (縦列の並びは書いた順を変えない) |
+ */
+function applyGroupFrames(
+  diagram: CdlDiagram,
+  doc: DslDocument,
+  作った枠: ReadonlySet<string>,
+  onNotice?: (notice: CompileNotice) => void,
+): void {
+  if (作った枠.size === 0) return;
+  const 置く: { 枠: CdlDiagram["lanes"][number]; 名前: string; line: number; 縦列: string[] }[] = [];
+  for (const [id, g] of Object.entries(doc.groups ?? {})) {
+    const 枠 = diagram.lanes.find((l) => l.id === `group-${id}`);
+    if (!枠 || !作った枠.has(枠.id)) continue;
+    const 書いた = Array.isArray(g.lanes) ? g.lanes : [];
+    const 在る = 書いた.filter((x) => diagram.lanes.some((l) => l.id === x && !作った枠.has(l.id)));
+    const 無い = 書いた.filter((x) => !在る.includes(x));
+    if (在る.length === 0) {
+      diagram.lanes = diagram.lanes.filter((l) => l !== 枠);
+      onNotice?.({
+        kind: "group-lane-missing",
+        actor: id,
+        line: g.pos?.line ?? 0,
+        message:
+          書いた.length === 0
+            ? `組 "${truncateForMessage(id)}" は束ねる縦列を書いていないので、枠を描きません`
+            : `組 "${truncateForMessage(id)}" が束ねる縦列 ${無い.map((x) => `"${truncateForMessage(x)}"`).join(", ")} が図に無いので、枠を描きません`,
+        hint: "`lanes: [縦列の名前, ...]` に `lanes:` で書いた縦列の名前を並べる",
+      });
+      continue;
+    }
+    if (無い.length > 0) {
+      onNotice?.({
+        kind: "group-lane-missing",
+        actor: id,
+        line: g.pos?.line ?? 0,
+        message: `組 "${truncateForMessage(id)}" が束ねる縦列 ${無い.map((x) => `"${truncateForMessage(x)}"`).join(", ")} が図に無いので、残りの縦列だけを囲みます`,
+        hint: "`lanes:` で書いた縦列の名前か確かめる",
+      });
+    }
+    置く.push({ 枠, 名前: id, line: g.pos?.line ?? 0, 縦列: 在る });
+  }
+  if (置く.length === 0) return;
+
+  const 配置 = layout(diagram);
+  const 並びの縦列 = 配置.lanes.filter((l) => !作った枠.has(l.id));
+  for (const { 枠, 名前, line, 縦列 } of 置く) {
+    const 束 = 並びの縦列.filter((l) => 縦列.includes(l.id));
+    const 左 = Math.min(...束.map((l) => l.x ?? 0));
+    const 右 = Math.max(...束.map((l) => (l.x ?? 0) + l.width));
+    // 束ねた縦列の左端と右端の間に入る縦列は、 束ねなくても枠に入る
+    const 挟んだ = 並びの縦列.filter(
+      (l) => !縦列.includes(l.id) && (l.x ?? 0) < 右 && (l.x ?? 0) + l.width > 左,
+    );
+    if (挟んだ.length > 0) {
+      onNotice?.({
+        kind: "group-lanes-apart",
+        actor: 名前,
+        line,
+        message: `組 "${truncateForMessage(名前)}" が束ねる縦列の間に ${挟んだ.map((l) => `"${truncateForMessage(l.id)}"`).join(", ")} があるので、その縦列も枠に入ります`,
+        hint: "束ねる縦列を `lanes:` で隣り合う順に並べる",
+      });
+    }
+    const 囲む縦列 = new Set([...束, ...挟んだ].map((l) => l.id));
+    const 囲む = [...束, ...挟んだ];
+    const 箱 = 配置.nodes.filter((n) => 囲む縦列.has(n.lane));
+    const 上 = Math.min(...囲む.map((l) => l.y ?? 0));
+    const 下 = Math.max(
+      ...囲む.map((l) => (l.y ?? 0) + (l.height ?? 0)),
+      ...箱.map((n) => n.cy + n.h / 2),
+    );
+    const 囲いを持つ = diagram.lanes.some((l) => 囲む縦列.has(l.id) && l.contain === true);
+    const 横 = 囲いを持つ ? 組の枠の余白.囲いの横 : 組の枠の余白.囲いの無い横;
+    枠.posX = 左 - 横;
+    枠.posY = 上 - 組の枠の余白.上;
+    枠.posW = 右 - 左 + 横 * 2;
+    枠.posH = 下 - 上 + 組の枠の余白.上 + 組の枠の余白.下;
   }
 }
 
@@ -4459,6 +5717,8 @@ function compileClass(doc: DslDocument): CdlDiagram {
       type: s2.relation ?? "uses",
       ...(s2.label ? { label: s2.label } : {}),
       ...(s2.sub ? { cardinality: s2.sub } : {}),
+      // 出どころ側の多重度 (#1771)。 engine が出どころの端に添える (cdl#825)
+      ...(s2.tailSub ? { tailCardinality: s2.tailSub } : {}),
       ...(s2.tone ? { tone: s2.tone } : {}),
       ...(s2.style ? { style: s2.style } : {}),
       ...(s2.head ? { head: s2.head } : {}),
@@ -5170,7 +6430,7 @@ function compileJourney(doc: DslDocument, onNotice?: (n: CompileNotice) => void)
         読めない.push(a.name);
         continue;
       }
-      data.push({ id: slugify(a.name), title: 箱の題(a), emotion: 語 as never, ...道筋の欄(a) });
+      data.push({ id: slugify(a.name), title: 箱の題(a), emotion: 語, ...道筋の欄(a) });
       continue;
     }
     const e = 気持ち.get(語);
@@ -5283,7 +6543,7 @@ function compileQuadrant(doc: DslDocument, onNotice?: (n: CompileNotice) => void
         読めない.push(a.name);
         continue;
       }
-      items.push({ id: slugify(a.name), title: 箱の題(a), quadrant: 語 as never });
+      items.push({ id: slugify(a.name), title: 箱の題(a), quadrant: 語 });
       continue;
     }
     const q = 区画.get(語);
@@ -5326,7 +6586,7 @@ function compileQuadrant(doc: DslDocument, onNotice?: (n: CompileNotice) => void
  * 段の目印を読み取る。 目印と、 それを落とした残りの説明を返す (#1098)。
  *
  * 目印 (`L1` / `L2` / `L3`) は「どの段に置くか」 を組み立てに伝えるためのもので、 読む人には
- * 意味を持たない。 段の名前は枠のラベル (`System Context` 等) が出すので二重でもある。
+ * 意味を持たない。 段の名前は枠のラベル (`全体の見取り図` 等) が出すので二重でもある。
  * 読み取ったら説明から落とす = 書いた人が説明として書いた部分だけが箱に出る。
  *
  * | 書いた文字 | 段 | 残る説明 |
@@ -5356,9 +6616,9 @@ function 段を読み取る(subtitle: string | undefined): { 段: number; 説明
  * C4 preset (C4 model 階層 system context 専用 layout)
  *
  * 設計 ... actor.subtitle の先頭に "L1" / "L2" / "L3" を置き、 階層 lane を生成。
- * - L1 = System Context
- * - L2 = Container
- * - L3 = Component
+ * - L1 = 全体の見取り図 (C4 model の System Context)
+ * - L2 = 動かす単位 (同 Container = 単体で動かす application や保管庫)
+ * - L3 = 部品 (同 Component)
  *
  * 実装 ... **中身のある段だけ** lane を作り、 使う段を左から順に詰めて横並び (contain: true で
  * 囲む) 配置する。 3 lane を常に作ると中身のない枠が画面に残り、 描かれ損ねたように見える (#1078)。
@@ -5371,7 +6631,9 @@ function compileC4(doc: DslDocument): CdlDiagram {
   const b = diagram(slugify(doc.title), { topic: doc.title, type: "infrastructure" });
   const LANE_W = 400;
   const LANE_GAP = 80;
-  const 段の名前: Record<number, string> = { 1: "System Context", 2: "Container", 3: "Component" };
+  // 段の名前は **枠に描く字** で、記法に打ち込む識別子ではない (#1886)。 打ち込む字は目印
+  // (`L1` / `L2` / `L3`) の側で、そちらは綴りを変えない
+  const 段の名前: Record<number, string> = { 1: "全体の見取り図", 2: "動かす単位", 3: "部品" };
 
   // 段は **先頭一致** で読み、 読んだ目印は説明から落とす (`段を読み取る` の説明を参照)
   const 割当 = doc.actors.map((a, idx) => {
@@ -5612,6 +6874,8 @@ type 放射で描けない欄 =
   // 前の時点の値 (#1450)。 放射の枝は 1 時点しか描かない = 2 本目の帯に当たるものが無い
   | "previous"
   | "colorHex"
+  // 部品に書いた色の名前 (#1973)。 色番号と同じく部品にしか残らない
+  | "partColorName"
   | "stateOverride"
   | "posX"
   | "posY"
@@ -5620,7 +6884,6 @@ type 放射で描けない欄 =
   | "scale"
   | "scaleKeys"
   | "posRel"
-  | "nodes"
   | "layoutPos"
   // 箱の中に描く図形 (#1374)。 放射の枝は箱の中に図形を持たない
   | "shape"
@@ -5677,6 +6940,7 @@ const 放射で描けない欄の名前: Record<放射で描けない欄, string
   final: "始まり / 終わり の印",
   previous: "前の時点の値",
   colorHex: "色番号",
+  partColorName: "色の名前",
   stateOverride: "状態の上書き",
   // 位置は「登場人物ごとの箱をどこに置くか」 の指定で、 箱が 1 つの図では置く先が無い
   posX: "位置 (座標)",
@@ -5686,7 +6950,6 @@ const 放射で描けない欄の名前: Record<放射で描けない欄, string
   scale: "倍率",
   scaleKeys: "倍率",
   posRel: "位置 (相対)",
-  nodes: "中の箱ごとの指定",
   layoutPos: "配置のずらし",
   shape: "箱の中の図形",
   visibleIf: "出す条件",
@@ -5729,7 +6992,8 @@ function 放射に出す文字(a: DslActor): { title: string; subtitle?: string
 }
 
 function compileMind(doc: DslDocument, onNotice?: (n: CompileNotice) => void): CdlDiagram {
-  const b = diagram(slugify(doc.title), { topic: doc.title, type: "mindmap" });
+  // 図の型は描画側の組み立て関数 `mindMap()` と同じ綴り (cdl 0.63.0 で `mindmap` から `mind` に揃った)
+  const b = diagram(slugify(doc.title), { topic: doc.title, type: "mind" });
   const { w: W, h: H } = 図表の大きさ.mind;
 
   const 伝える = (kind: CompileNotice["kind"], 名: string, message: string, line = 0): void => {
@@ -6025,8 +7289,8 @@ function applyV05Extensions(
       // 組み立てだけで渡すと、同じ記法でも静止図では指定が消える。
       //
       // **幅が図に出るかは縦列との大小で決まる**。 縦列に収まれば箱だけが変わり、
-      // 縦列より広ければ縦列ごと押し広げる (実測 = ステート図の 320 は縦列 370 に収まって
-      // 図が変わらないが、拡張ステート図の 280 に対し既定 640 は縦列 330 を押し広げた)。
+      // 縦列より広ければ縦列ごと押し広げる (実測 = 状態遷移図の 320 は縦列 370 に収まって
+      // 図が変わらないが、入れ子の状態遷移図の 280 に対し既定 640 は縦列 330 を押し広げた)。
       // #1260 で 1 件だけ見て「見た目に出ない」 と判断し配線を外した = 同じ誤りを繰り返さない
       if (a.posW !== undefined) node.w = a.posW;
       if (a.posH !== undefined) node.h = a.posH;
@@ -6190,7 +7454,7 @@ function injectPhasesFallback(diagram: CdlDiagram, doc: DslDocument): void {
   for (const p of doc.animate.phases) {
     const activateIds: string[] = [...resolveIds(p.highlight ?? [])];
     // `draw:` を描画側の欄へ写す (#1312 / #1314 / #1318)。 相手は 1 箱で図全体を描く
-    // 対象 8 種の箱で、必ず 1 つに決まるため名前を書かせずに引ける。
+    // 対象の箱で、必ず 1 つに決まるため名前を書かせずに引ける。
     //
     // **`activate` と兼ねない**。 描画側は焦点と別集合で持つ (`cdl#512`) = 焦点が当たり
     // 続ける図で毎段引き直しになるため。 書いた段だけが欄を持つ
@@ -6311,23 +7575,27 @@ function slugLookup(byName: ReadonlyMap<string, string>, wanted: string): string
   return hit;
 }
 
-function compileFlow(doc: DslDocument): CdlDiagram {
+function compileFlow(
+  doc: DslDocument,
+  /** 鎖に並べない部品を決める一覧 (#1987) */
+  partsCatalog?: Record<string, CdlDiagram>,
+): CdlDiagram {
   // v0.4 ... animation あり時 builder 直接経路で複数 phase 注入
   // **縦列を書いた形は動きの有無に関わらず generic 経路へ** (#1263)。 動く図だけで効かせると、
   // 同じ記法でも静止図では指定が黙って消える (実測 = 縦列 3 本のはずが 1 本になり知らせも出ない)
   // **向きを書いた形も generic 経路へ** (#1494)。 静止図の経路は並びを固定で持つので、
   // ここを通さないと書いた向きが黙って消える (縦列を書いた形と同じ理由)
-  if (
-    (doc.animate && doc.animate.phases.length > 0) ||
-    書いた縦列に置く("flow", doc) ||
-    doc.direction !== undefined
-  ) {
+  //
+  // 振り分けは行の対応と端の知らせと同じ判定で行う (#1986)
+  if (!鎖でつなぐ形か(doc)) {
     return compileGenericWithAnimate(doc, { kind: "flow", laneId: "main", laneWidth: 400 });
   }
   // 登場人物が 0 人なら枠も作らない。 描画側の `flow()` は枠を必ず 1 つ作るため、 そのまま
   // 通すと中身の無い枠が残る (実測 = `title` と `type` だけの本文で枠 `flow` が空)。
-  // 枠を持たない図として返す = `swimlane` / `c4` が 0 人で枠 0 になるのと揃う
-  if (doc.actors.length === 0) {
+  // 枠を持たない図として返す = `swimlane` / `c4` が 0 人で枠 0 になるのと揃う。
+  // 鎖に並べる登場人物で見る = 行に書かれていない部品しか居ない図も枠を作らない (#1987)
+  const 並び = 鎖に並べる登場人物(doc, partsCatalog);
+  if (並び.length === 0) {
     return diagram(slugify(doc.title), { topic: doc.title, type: "flow" }).build();
   }
   // flow preset は actors を順に step として配置、 step 間に edge auto
@@ -6336,8 +7604,9 @@ function compileFlow(doc: DslDocument): CdlDiagram {
     topic: doc.title,
   });
   // 各 actor を step として登録、 edge label は流れ から拾う
-  for (let i = 0; i < doc.actors.length; i++) {
-    const a = doc.actors[i]!;
+  for (const a of 並び) {
+    // 名前から id を作れない時の番号は、書いた順の番号にする (部品を飛ばしても変わらない)
+    const i = doc.actors.indexOf(a);
     // 直前の step との edge label = この actor を to に持つ flow から拾う
     const incomingEdge = doc.flow.find((s) => s.to === a.name);
     const edgeLabel = incomingEdge?.label;