@cardenelabs/cdl 0.5.0

package/src/visual-validate.ts

@@ -0,0 +1,4381 @@
+/**
+ * Visual validator ... layout 出力 (LaidDiagram) を 67 軸で検証する。
+ *
+ * cdl 著者が「component が render される」 までで完成と思いがちな問題に対し、
+ * 「視覚的に正しい」 を engine 層で機械判定する。
+ *
+ * 軸の一覧は `VisualAxis` 型が SSOT。 Axis 48 (`axis-documentation-completeness`) が見るのは
+ * **手で並べた `allAxes` の要素数が `EXPECTED_AXIS_COUNT` と一致するか** だけで、 `VisualAxis` /
+ * `emptyCounts` / `allAxes` の 3 つが揃っているかまでは見ない。 型と `emptyCounts` のずれは
+ * 型検査が捕まえるが、 `allAxes` への追記漏れは捕まらない (#381)。
+ *
+ * 戻り値 ... ViolationReport (各軸の違反一覧 + sum + ok flag)。
+ * 既存 validate (構造的破綻) と別 layer。 throw せず report のみ返す純粋関数。
+ *
+ * ───────────────────────────────────────────────────────────
+ * ## 新しい軸を足す時の判断基準 (#381)
+ *
+ * **軸は、 品質と結びつく量を、 検証済の前提の下で測る**。 これを外すと、 件数が 0 でも品質を
+ * 表さない軸ができる。 0 件は「問題がない」 とも「測れていない」 とも読めるが、 軸の側からは
+ * 区別できない。
+ *
+ * 2026-07-31 の 1 セッションで、 同じ性質の欠陥を 9 例続けて直した。 件数は dragon の見本
+ * 512 図での実測。
+ *
+ * | 軸 | 何がずれていたか | 件数 |
+ * |---|---|---|
+ * | `lane-lane-gap` | `contain: false` の帯は境界を描かないのに、 境界どうしの間隔を測っていた | 99 |
+ * | `text-readability` / `accessibility-basics` | 題名を一度も描かない種別と、 常に非表示の節を対象にしていた | 50 |
+ * | `responsive-viewport` | 幅の下限の判定が **反転** していた (十分広い時に警告) | 17 |
+ * | `mermaid-parity` | 外部ライブラリの対応表が古く、 対応物がある 3 種を「なし」 としていた | 3 |
+ * | `edge-label-proximity` | label の **中心** から **弦** までを測っていた (弦は描かれず、 中心は label の長さで動く) | 3 |
+ * | `grid-alignment` | 箱の **中心** が 16 の格子に載るかを見ていた (中心を格子に載せる実装は無い) | 2 |
+ * | 衝突判定 (label × 線) | 弦に落とした線と label 矩形の交差を見て、 自分の弦と一致する segment を除いていた。 端点が同じ弧は弦も一致するため、 兄弟の弧が丸ごと消えていた | **-3** |
+ * | `accessibility-basics` (再) | `role="img"` の子孫は支援技術に公開されないのに、 節ごとの題名を見ていた | 0 |
+ * | `mermaid-parity` (再) | 図の id から組み立て器を推定していた (id は著者が付ける値で無関係) | 0 |
+ *
+ * `-3` は「見えていなかった破綻が 3 件あった」 の意味。 直すと件数が **増える** 側の例。
+ *
+ * ずれ方は 4 つに分かれる。
+ *
+ * - **描かれない図形を測る** ... 見えない帯の境界 / 弦 / 箱の中心。 幾何の代表点を実際の
+ *   描画物と取り違える形
+ * - **描かれない情報を測る** ... 題名を描かない種別 / 支援技術に公開されない節。 データには
+ *   あるが出力に出ない値を測る形
+ * - **意図を形から推測する** ... id からの組み立て器推定。 著者が持つ情報を図の形から当てよう
+ *   とする形。 推測は必ず両方向に外れる (偽陽性と偽陰性が同時に出る)
+ * - **外部の情報が古びる** ... mermaid の対応表。 外部が更新されても軸は気付かない
+ *
+ * `responsive-viewport` だけは別で、 測る量 (`viewBox` の幅) は実在した。 **判定の向きが逆**
+ * だっただけで、 これは片方向の例しか試さないと通ってしまう。
+ *
+ * 足す前に 6 点を確かめる。
+ *
+ *   1. **測る量が出力から取れるか**。 DOM / SVG の `d` / 描画結果のいずれかから取れないなら、
+ *      その軸は書けない。 データ構造の値で代用しない
+ *   2. **その量が品質と結びつく根拠を、 実装か規約で示せるか**。 「箱の中心が 16 の格子に載る」
+ *      のように、 **誰も実装していない不変条件** を軸が勝手に決めていないか確かめる。 出力から
+ *      取れる量でも、 品質と結びついていなければ測る意味が無い
+ *   3. **発火する例と発火しない例を両方書いたか**。 判定の向きの誤りは片方だけでは通る
+ *   4. **0 件になった時、 それが「実在しない」 ことを示せるか**。 示せないなら、 発火する反例を
+ *      1 つ作って test に置く (軸が dead になっていないことの証明)
+ *   5. **著者の意図を要する判定は、 形から推測せず宣言させる**。 宣言の例 =
+ *      `structuredData: "exclude"`
+ *   6. **外部の情報に依存するなら、 基準にした版を書き、 いつ確かめ直すかを決める**。 例 =
+ *      `MERMAID_PARITY_BASIS_VERSION`。 版だけでは外部の更新に気付けないので、 版を書いた上で
+ *      「次にこの表を見直す条件」 も併せて残す
+ *
+ * 同じことを静的 test が拾えるなら、 図ごとの軸は要らない。 静的 test は実際の export を
+ * 列挙でき、 推測が要らない (例 = `test/mermaid-parity.test.ts` が `presets.ts` の export を
+ * 全件列挙する)。
+ *
+ * 直した後は、 手で持つ一覧が実装とずれない仕組みを併せて置く。 全 90 種別の描画結果と述語の
+ * 一致 / 全 export と対応表の照合 / 生成物と種別集合の一致 のように、 **実装を列挙して照合する**
+ * test が無いと、 次に種別を足した時に同じ状態へ戻る。
+ * ───────────────────────────────────────────────────────────
+ */
+import type { CdlDiagram, LaidDiagram, NodeKind } from "./types";
+import { CLEARANCE_LANE_LABEL, DIST_LABEL_PATH_MAX } from "./layout/clearance-constants";
+import { layout } from "./layout";
+import {
+  collectBBoxes,
+  detectCollisions,
+  detectNearCollisions,
+  extractPathSegments,
+  flattenPathSegments,
+  measurePathLabelGapSegs,
+  segmentsCrossRect,
+} from "./layout/collisions";
+import { measureTextWidth } from "./layout/text-width";
+import {
+  bboxOverlaps,
+  isNearAny,
+  pointRectEdgeDistance,
+  rectRectOverlapArea,
+  segmentIntersection,
+  segmentsBBox,
+} from "./layout/geometry";
+import { TONE_HEX as TONE_SSOT, TONE_FALLBACK, hasTone } from "./render/tone";
+import {
+  EDGE_LABEL_TEXT,
+  describeTextSpec,
+  requiredContrastRatio,
+  type EdgeLabelLine,
+  type EdgeLabelTextSpec,
+} from "./label-text";
+
+// 文字仕様の SSOT は `label-text.ts`。 ここからも読めるようにしておくのは、 対比の
+// 検査を読む側が閾値を辿れるようにするため。
+export {
+  EDGE_LABEL_TEXT,
+  WCAG_AA_LARGE,
+  WCAG_AA_NORMAL,
+  isLargeText,
+  requiredContrastRatio,
+} from "./label-text";
+export type { EdgeLabelLine, EdgeLabelTextSpec } from "./label-text";
+import {
+  ARROW_ENDPOINT_CENTER_TOL,
+  COLUMN_GAP_VARIANCE_TOL,
+  DETOUR_CREST_OVERLAP_MIN,
+  DETOUR_SLOT_GAP,
+  EDGE_STUB_OUT,
+  LABEL_PILL_PAD_X,
+  computeLabelBoxW,
+  buildDiagramAltText,
+  computeLabelBBoxWorld,
+  hasRenderedLabel,
+  isRenderedNode,
+  rendersRows,
+  rendersTitleText,
+  rowBaselineY,
+  rowGlyphDepth,
+  LANE_BORDER_CLEARANCE_TOL,
+  MIN_COLUMN_ALIGNMENT_TOLERANCE,
+  MIN_ROW_ALIGNMENT_TOLERANCE,
+  ROW_GAP_VARIANCE_TOL,
+} from "./layout/spec";
+
+/**
+ * 対応表が基準にする mermaid.js の版。
+ *
+ * mermaid は diagram type を増やし続けており、 表を書いた時点を残さないと「対応物が無い」 が
+ * いつの話か分からなくなる。 実際にこの表は Architecture (v11.1.0) / TreeView (v11.14.0) /
+ * Swimlanes (v11.16.0) の追加に追随できておらず、 対応物がある組み立て器を「対応なし」 側に
+ * 置いたままだった。 表を更新する時はこの値も上げる。
+ */
+export const MERMAID_PARITY_BASIS_VERSION = "11.16";
+
+/**
+ * mermaid.js に対応する diagram type がある組み立て器。
+ *
+ * 短い別名 (`topo` / `infra` 等) も載せる。 図の id とは無関係で、 移行の手引きとして
+ * 「この呼び名でも同じ組み立て器を指す」 を示すためだけに置いている (#366 で図の id から
+ * 組み立て器を推定する判定は削除した)。
+ *
+ * 対応先。
+ *
+ * | 組み立て器 | mermaid の diagram type |
+ * |---|---|
+ * | sequence | sequenceDiagram |
+ * | flow / flowchart | flowchart |
+ * | stateMachine / stateMachine2 | stateDiagram-v2 (入れ子の状態と entry / exit の動作を扱える) |
+ * | er | erDiagram |
+ * | classDiagram | classDiagram |
+ * | gantt | gantt |
+ * | quadrant | quadrantChart |
+ * | mindMap / mindMapRadial | mindmap |
+ * | userJourney | journey |
+ * | chart / pie | xyChart / pie |
+ * | topology / infrastructure / network | architecture-beta (v11.1.0、 service / group / edge で構成を描く) |
+ * | swimlane | swimlanes (v11.16.0、 上位 subgraph が lane になる) |
+ * | tree | treeView-beta (v11.14.0、 階層を directory 風に描く) |
+ * | gitGraph | gitGraph |
+ * | block | block |
+ */
+export const MERMAID_COMPATIBLE_PRESETS: ReadonlySet<string> = new Set([
+  "sequence",
+  "seq",
+  "flow",
+  "flowchart",
+  "statemachine",
+  "fsm",
+  "statemachine2",
+  "sm2",
+  "er",
+  "classdiagram",
+  "class",
+  "gantt",
+  "quadrant",
+  "quad",
+  "mindmap",
+  "mind",
+  "mindmapradial",
+  "mindradial",
+  "userjourney",
+  "journey",
+  "chart",
+  "pie",
+  "topology",
+  "topo",
+  "infrastructure",
+  "infra",
+  "network",
+  "swimlane",
+  "swim",
+  "tree",
+  "gitgraph",
+  "git",
+  "block",
+]);
+
+/**
+ * mermaid.js に対応物を持たない cdl 独自の組み立て器。
+ *
+ * 対応物が無いのは設計上の事実で図の不備ではない。 拾いたいのは「組み立て器を足したのに
+ * 分類そのものを記録し忘れた」 状態だけで、 それは `test/mermaid-parity.test.ts` が
+ * `presets.ts` の export を全件列挙して固定する (#366)。
+ *
+ * `funnel` は mermaid 側で diagram type として提案されている段階で、 実装されていない。
+ * flowchart で近似はできるが、 段の幅で量を表す図としては別物なので対応物なしとする。
+ */
+export const CDL_ONLY_PRESETS: ReadonlySet<string> = new Set(["funnel"]);
+
+/**
+ * 箱を格子 (16 world) に載せる組み立て器が作る節の種別。
+ *
+ * これらは canvas の寸法を 16 の倍数で作り、 中身を自前で layout する。 `grid-alignment` は
+ * 箱の左 / 右 / 上 / 下の 4 辺が格子に載るかを見る。
+ */
+export const GRID_ALIGNED_KINDS: ReadonlySet<NodeKind> = new Set([
+  "chart-pie",
+  "chart-line",
+  "chart-bar",
+  "funnel-stages",
+  "quadrant-matrix",
+]);
+
+/** 点 (px, py) と線分 (x1,y1)-(x2,y2) の最短距離 */
+function pointToSegmentDistance(
+  px: number,
+  py: number,
+  x1: number,
+  y1: number,
+  x2: number,
+  y2: number,
+): number {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) return Math.hypot(px - x1, py - y1);
+  let t = ((px - x1) * dx + (py - y1) * dy) / lenSq;
+  t = Math.max(0, Math.min(1, t));
+  const cx = x1 + t * dx;
+  const cy = y1 + t * dy;
+  return Math.hypot(px - cx, py - cy);
+}
+
+export interface Violation {
+  axis: VisualAxis;
+  diagramId: string;
+  detail: string;
+  severity: "error" | "warn";
+}
+
+export type VisualAxis =
+  | "node-visibility"
+  | "edge-label-overlap"
+  | "edge-label-proximity"
+  | "text-readability"
+  | "row-format"
+  | "alignment"
+  | "clearance"
+  // CAR-Y (PR #75) で追加した位置検証 5 軸。 arrow endpoint / label char range / node z-order /
+  // edge crossing / edge-node cross の実座標検証を engine 側で機械化 SSOT。
+  | "arrow-endpoint-anchoring"
+  | "label-char-range"
+  | "node-overlap"
+  | "edge-crossing"
+  | "edge-node-cross"
+  // CAR-Z (PR #76) 追加 = より深い位置検証 5 軸。
+  | "edge-segment-orthogonality"
+  | "label-inside-viewbox"
+  | "lane-cx-consistency"
+  | "row-vertical-spacing"
+  | "group-boundary-clearance"
+  // CAR-Z2 (PR #81) 追加 = 隣接 clearance / arrow marker の 3 軸拡張。
+  | "node-vertical-clearance"
+  | "lane-lane-gap"
+  | "arrow-marker-clearance"
+  // CAR-Z3 (PR #82) 追加 = 4 領域拡張。
+  | "grid-alignment"
+  | "phase-layout-stability"
+  | "responsive-viewport"
+  | "accessibility-basics"
+  // CAR-Z4 (PR #83) 追加 = animation / i18n / contrast / print-media 4 領域。
+  | "animation-frame-integrity"
+  | "i18n-cjk-detection"
+  | "contrast-basics"
+  | "print-media-compat"
+  // CAR-Z5 (PR #84) 追加 = SVG filter / marker / gradient integrity 4 領域。
+  | "color-blind-safety"
+  | "marker-gradient-def-integrity"
+  // CAR-Z6 (PR #85) 追加 = subpixel / DOM complexity / motion / touch 4 領域。
+  | "subpixel-precision"
+  | "dom-complexity-budget"
+  | "reduced-motion-compat"
+  | "touch-target-size"
+  // CAR-Z7 (PR #86) 追加 = row-typing / terminal-safe-text / GPU / memory 4 領域。
+  | "row-content-typing"
+  | "terminal-safe-text"
+  | "gpu-layer-efficiency"
+  | "memory-budget"
+  // CAR-Z8 (PR #87) 追加 = XSS / SEO / bidi / structured-data 4 領域。
+  | "svg-injection-safety"
+  | "seo-metadata-quality"
+  | "bidi-hyphenation"
+  | "structured-data-extraction"
+  // CAR-Z9 (PR #88) 追加 = semver / migration / meta 4 領域。
+  | "diagram-version-semver"
+  | "migration-path-consistency"
+  | "axis-coverage-meta"
+  | "axis-documentation-completeness"
+  // CAR-Z10 (PR #89) 追加 = fixture-drift / locale / performance 3 領域
+  // (mermaid は #366 で削除、 対応表の完全性は静的 test に一本化)。
+  | "fixture-drift-detection"
+  | "locale-parity"
+  | "validate-performance-budget"
+  // Axis 53 (2026-07-03 追加) = node が diagram viewBox 内に収まっているか。
+  // 既存 Axis 14 (label-inside-viewbox) の node 版、 clip 検知の直接手段。
+  | "node-inside-viewbox"
+  // Axis 54 (2026-07-03 追加) = node bbox が所属 lane 内に収まっているか。
+  // Axis 15 (lane-cx-consistency) は中心 x のみ、 本 axis は node 4 辺と lane 4 辺の包含関係を検知。
+  | "node-inside-lane"
+  // Axis 55 (2026-07-03 追加) = edge path の全 segment 端点が viewBox 内に収まっているか。
+  // Axis 14 (label-inside-viewbox) は edge-label のみ、 Axis 53 (node-inside-viewbox) は node のみ、
+  // 本 axis は edge path (SVG d 属性の全 segment) の viewBox 収まりを見る。
+  | "edge-inside-viewbox"
+  // Axis 56 (2026-07-03 追加) = lane label (kind: "lane-label" bbox) が viewBox 内に収まっているか。
+  // Axis 14 は edge-label 対象、 本 axis は lane-label 対象で棲み分け。
+  | "lane-label-inside-viewbox"
+  | "lane-label-overlap"
+  // CAR-421 (PR 1 / CAR-418 chain 伝搬 shift + spec 固定化) 追加 = positive-check axis 5 種。
+  // 既存 axis は「これ以下は誤読」 の下限、 本 5 axis は「これを満たすと正しい」 の positive spec。
+  // spec.ts の SSOT 定数を参照。
+  // Axis 57 = 同 row 内 node cy 揃い (MIN_ROW_ALIGNMENT_TOLERANCE)。
+  | "row-alignment"
+  // Axis 58 = 同 column (同 lane) 内 node cx 揃い (MIN_COLUMN_ALIGNMENT_TOLERANCE)。
+  | "column-alignment"
+  // Axis 60 = edge 起点から水平方向に EDGE_STUB_OUT world 以上直進 (起点判別容易化)。
+  | "edge-stubout-min"
+  // Axis 61 = 同 from node から出る全 edge の起点 Y が同一 (fan-out origin 分散防止)。
+  | "fan-origin-single-point"
+  // CAR-422 (PR 2 / CAR-418 chain) 追加 = positive-check axis 5 種。
+  // Axis 62 = 同 obstacle を迂回する複数 detour path の Y peak 差 ≥ DETOUR_SLOT_GAP。
+  | "detour-slot-distinct"
+  // Axis 63 = arrow 終点 が終点 node の toSide 辺中央 (±ARROW_ENDPOINT_CENTER_TOL) に収束。
+  | "arrow-endpoint-center"
+  // Axis 64 = edge-label bbox が lane border 貫通なし (LANE_BORDER_CLEARANCE_TOL)。
+  | "lane-border-clearance"
+  // Axis 65 = 同 stack 内 node 間 gap variance (max-min) ≤ ROW_GAP_VARIANCE_TOL。
+  | "row-gap-uniform"
+  // Axis 66 = 同 lane 内 node 間 gap variance (max-min) ≤ COLUMN_GAP_VARIANCE_TOL。
+  | "column-gap-uniform"
+  // Axis 68 (#387) = 行を描かない種別に rows が書かれている (書いた内容が画面に出ない)。
+  | "rows-not-rendered"
+  // #393 = 検査に渡された図の形自体が壊れている (検査できなかったことを結果として出す)。
+  | "malformed-input"
+  // #393 = 検査が例外で中断したが、 原因が入力の破綻か検査側の欠陥か **決められない**。
+  // 入口が何も見つけていない時にここへ来る。 「検査側の欠陥」 と断定する名前を付けると、
+  // 実際には入力側 (getter が例外を投げる 等 入口の届かない破綻) の時に調査を誤らせる。
+  | "validation-interrupted";
+
+/**
+ * 検査の用途。 用途によって見るべき軸が違う。
+ *
+ * - `production` = 公開する web ページ。 全ての軸を見る (既定)
+ * - `catalog` = 記法の見本。 SEO の軸を見ない
+ *
+ * 見本は「記法をどう書くか」 を示すもので、 検索結果に出す対象ではない。 SEO の軸
+ * (`seo-metadata-quality` / `structured-data-extraction`) は題名の長さや有名な節の数を見るため、
+ * 短い題名の見本を足すたびに警告が出る。
+ *
+ * 経緯 = cardene777/dragon#887 の起票時は見本 412 図で 179 件出ていたが、 その後 見本側の題名が
+ * 整備されて現在は 0 件 (実測 = 316 図で 0 件)。 本区分は「今ある noise を消す」 のではなく
+ * 「見本に SEO の軸を課さない」 契約を先に置くもの。
+ */
+export type ValidationProfile = "production" | "catalog";
+
+/** 用途ごとに見ない軸。 */
+const SKIPPED_AXES: Readonly<Record<ValidationProfile, ReadonlySet<VisualAxis>>> = {
+  production: new Set(),
+  catalog: new Set<VisualAxis>(["seo-metadata-quality", "structured-data-extraction"]),
+};
+
+/** 検査の設定。 */
+export interface ValidateOptions {
+  /** 検査の用途。 既定は `production` (全ての軸を見る)。 */
+  profile?: ValidationProfile;
+}
+
+export interface VisualValidationReport {
+  diagramId: string;
+  ok: boolean;
+  violations: Violation[];
+  counts: Record<VisualAxis, number>;
+  /** 検査した用途。 report を保存して後から読む時に、 何を見たかが分かる。 */
+  profile: ValidationProfile;
+  /**
+   * 用途によって見なかった軸。
+   *
+   * `counts` はこれらも 0 を返す。 載せないと「検査して 0 件」 と「検査していない」 を
+   * 区別できず、 集計した時に見た範囲を過大に読む。
+   */
+  skippedAxes: VisualAxis[];
+}
+
+const MIN_NODE_W = 80;
+const MIN_NODE_H = 40;
+const MIN_FONT_SIZE = 12;
+const ROW_FORMAT = /^[^:]+:\s*.+$/;
+const PLACEHOLDER_RE = /\{(\w+)\}/g;
+
+function emptyCounts(): Record<VisualAxis, number> {
+  return {
+    "node-visibility": 0,
+    "edge-label-overlap": 0,
+    "edge-label-proximity": 0,
+    "text-readability": 0,
+    "row-format": 0,
+    alignment: 0,
+    clearance: 0,
+    "arrow-endpoint-anchoring": 0,
+    "label-char-range": 0,
+    "node-overlap": 0,
+    "edge-crossing": 0,
+    "edge-node-cross": 0,
+    "edge-segment-orthogonality": 0,
+    "label-inside-viewbox": 0,
+    "lane-cx-consistency": 0,
+    "row-vertical-spacing": 0,
+    "group-boundary-clearance": 0,
+    "node-vertical-clearance": 0,
+    "lane-lane-gap": 0,
+    "arrow-marker-clearance": 0,
+    "grid-alignment": 0,
+    "phase-layout-stability": 0,
+    "responsive-viewport": 0,
+    "accessibility-basics": 0,
+    "animation-frame-integrity": 0,
+    "i18n-cjk-detection": 0,
+    "contrast-basics": 0,
+    "print-media-compat": 0,
+    "color-blind-safety": 0,
+    "marker-gradient-def-integrity": 0,
+    "subpixel-precision": 0,
+    "dom-complexity-budget": 0,
+    "reduced-motion-compat": 0,
+    "touch-target-size": 0,
+    "row-content-typing": 0,
+    "terminal-safe-text": 0,
+    "gpu-layer-efficiency": 0,
+    "memory-budget": 0,
+    "svg-injection-safety": 0,
+    "seo-metadata-quality": 0,
+    "bidi-hyphenation": 0,
+    "structured-data-extraction": 0,
+    "diagram-version-semver": 0,
+    "migration-path-consistency": 0,
+    "axis-coverage-meta": 0,
+    "axis-documentation-completeness": 0,
+    "fixture-drift-detection": 0,
+    "locale-parity": 0,
+    "validate-performance-budget": 0,
+    "node-inside-viewbox": 0,
+    "node-inside-lane": 0,
+    "edge-inside-viewbox": 0,
+    "lane-label-inside-viewbox": 0,
+    "lane-label-overlap": 0,
+    "row-alignment": 0,
+    "column-alignment": 0,
+    "edge-stubout-min": 0,
+    "fan-origin-single-point": 0,
+    "detour-slot-distinct": 0,
+    "arrow-endpoint-center": 0,
+    "lane-border-clearance": 0,
+    "row-gap-uniform": 0,
+    "column-gap-uniform": 0,
+    "rows-not-rendered": 0,
+    "malformed-input": 0,
+    "validation-interrupted": 0,
+  };
+}
+
+/**
+ * LaidDiagram を直接受け取って 56 axis で視覚検証する低 layer API (v0.9+ 追加)。
+ *
+ * visualValidate() は layout 経由で LaidDiagram を得た後、 本関数を呼び出す thin wrapper。
+ * fixture test で layout を bypass して LaidDiagram を直接構築、 各 axis の real defect を
+ * assertion 化する際に本 API を使う。
+ *
+ * @param laid layout 済 diagram
+ * @param diag 元 CdlDiagram (viewport / states 等の check に必要)
+ */
+/**
+ * edge 起点の stub 長 (world unit) を測る (Issue #202)。
+ *
+ * 起点から、 進行が起点 side の軸方向に進み続ける距離。
+ *
+ * `extractPathSegments` は L 字 corner の `Q` 命令を弦 (始点 → 終点の直線) に近似する。
+ * engine は `L exitX - corner` → `Q exitX ...` の順で曲がり、 corner の弧が最後の
+ * corner 半径分を担って `exitX = 起点 + EDGE_STUB_OUT` に到達する (edges.ts の CAR-472 SSOT)。
+ * よって第 1 segment の長さだけを見ると corner 半径 (14) だけ短く読める。
+ *
+ * 軸方向の変位を累積し、 進行が止まる (or 反転する) 時点で打ち切ることで、
+ * 直線と corner の弧をまとめて「起点からどれだけ離れたか」 を測る。
+ *
+ * @param segs `extractPathSegments` の出力 (2 segment 以上)
+ * @returns 起点 side 軸方向の到達距離
+ */
+export function measureStubOut(
+  segs: readonly { x1: number; y1: number; x2: number; y2: number }[],
+): number {
+  const first = segs[0]!;
+  const dx0 = first.x2 - first.x1;
+  const dy0 = first.y2 - first.y1;
+  const axis: "x" | "y" = Math.abs(dx0) >= Math.abs(dy0) ? "x" : "y";
+  const sign = Math.sign(axis === "x" ? dx0 : dy0);
+  if (sign === 0) return 0;
+
+  let stub = 0;
+  for (const s of segs) {
+    const delta = (axis === "x" ? s.x2 - s.x1 : s.y2 - s.y1) * sign;
+    if (delta <= 0) break;
+    stub += delta;
+  }
+  return stub;
+}
+
+/** `render/edges.tsx` の `var(--cdl-label-bg, #ffffff)` の既定値。 */
+export const LABEL_BG_DEFAULT = "#ffffff";
+/** `render/edges.tsx` の非活性時の `var(--cdl-text-dim, #5a6270)` の既定値。 */
+export const LABEL_TEXT_INACTIVE_DEFAULT = "#5a6270";
+
+function hexToRgb(hex: string): [number, number, number] {
+  const h = hex.replace("#", "");
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+
+/** WCAG 2.x の相対輝度 (0..1)。 */
+function relativeLuminance(rgb: [number, number, number]): number {
+  const [r, g, b] = rgb.map((v) => {
+    const s = v / 255;
+    return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  }) as [number, number, number];
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+/** WCAG 2.x の contrast ratio (1..21)。 */
+export function contrastRatio(a: string, b: string): number {
+  const la = relativeLuminance(hexToRgb(a));
+  const lb = relativeLuminance(hexToRgb(b));
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+
+/** 前景色を背景色に alpha で乗せた合成色。 半透明の文字を実効色に直す。 */
+export function blendOver(fg: string, bg: string, alpha: number): string {
+  const [f, b] = [hexToRgb(fg), hexToRgb(bg)];
+  const ch = (i: 0 | 1 | 2) => Math.round(f[i] * alpha + b[i] * (1 - alpha));
+  return `#${[ch(0), ch(1), ch(2)].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+}
+
+/**
+ * edge label の文字と背景の対比を測る (Axis 27 `contrast-basics` の本体)。
+ *
+ * 色を引数で受け取る純粋関数にしてある。 cdl の既定値は呼出側が渡し、 test は閾値をまたぐ色を
+ * 注入して判定の向きを直接確かめられる (定数のままだと、 合成や分岐を消しても既定値では
+ * 判定が変わらず test が通ってしまう)。
+ *
+ * ## 何を測るか
+ *
+ * `render/edges.tsx` の edge label は 2 行構成で、 行ごとに WCAG の区分が違う。
+ *
+ *   main 行 ... fontSize 22 / fontWeight 700 / opacity 1    → large text (3:1)
+ *   sub 行  ... fontSize 19 / 太字なし        / opacity 0.95 → 通常文字 (4.5:1)
+ *
+ * WCAG の large text は 24px 以上 または 太字 18.66px 以上。 sub 行はどちらも満たさない。
+ * sub 行は半透明なので、 背景と合成した実効色で測る。
+ *
+ * 文字色は状態で変わる (`fill={active ? color : "var(--cdl-text-dim, ...)"}`)。 tone の色が
+ * 文字になるのは活性時だけで、 非活性時は tone に依らず 1 色。
+ *
+ * どちらの状態が起きるかは phase が決める。 `render/stage.tsx` は
+ * `activeSet = new Set(currentPhase?.activate ?? [])` なので、
+ *
+ *   - phase が無ければ全ての辺が常に非活性
+ *   - ある辺を activate しない phase があれば、 その辺は非活性の見た目も起きる
+ *   - どの phase も activate しない辺の tone は、 label の文字として一度も描かれない
+ *
+ * ## 何を測らないか
+ *
+ * 未知の tone は飛ばさない。 描画側 (`render/tone.ts` の `toneColor`) が既定色に落として
+ * 描くので、 その既定色で測る。
+ *
+ * 下流の CSS。 背景も文字色も CSS 変数で上書きでき、 さらに
+ * `[data-cdl-role="edge-label"]` への `fill: ... !important` で変数ごと迂回できる
+ * (dragon の 6 主題は実際にそうしている)。 下流側の対比は下流の test が見る。
+ *
+ * 非活性の pill の `opacity 0.92`。 背後の色が 8% 混ざるが、 既定の stage 背景との合成で
+ * 対比 6.15 → 6.10、 背後が純黒でも 5.16 で、 閾値 3.0 から十分離れている。
+ *
+ * @returns 閾値を割った組合せ。 (状態, 行, 実効文字色) が同じものは 1 件にまとめる
+ */
+export function evaluateLabelContrast(opts: {
+  edges: ReadonlyArray<{ id: string; label?: string; sub?: string; tone: string }>;
+  phases: ReadonlyArray<{ activate: readonly string[] }>;
+  /** tone 名から色を引く。 描画側と同じ解決 (未知の tone は既定色に落とす) を渡す。 */
+  toneColor: (tone: string) => string;
+  labelBg: string;
+  inactiveText: string;
+  /**
+   * 行ごとの文字仕様。 既定は描画側の SSOT なので、 呼出側は渡さない。
+   * test が「不透明度が 1 未満なら合成して測る」 等の分岐を動かすためだけに差し替える。
+   */
+  textSpec?: Record<EdgeLabelLine, EdgeLabelTextSpec>;
+}): Array<{ detail: string; ratio: number }> {
+  const { edges, phases, toneColor, labelBg, inactiveText, textSpec = EDGE_LABEL_TEXT } = opts;
+
+  // 型では `phases` も `activate` も配列だが、 検査は壊れた入力にも呼ばれる (dragon の変異
+  // test が phase を差し替えて別軸の発火を確かめる)。 本軸が例外を投げると、 その図の
+  // **全軸の検査が巻き添えで落ちる**。
+  //
+  // 配列でないものは「無い」 と見て進む。 `activate` が文字列でも同じ = 文字列は反復可能で
+  // `includes` も持つため、 `Array.isArray` を外すと 1 文字ずつを辺 id と誤解する。
+  // 形が違う要素は **数えずに落とす**。 空の `activate` を持つ phase として残すと、
+  // 有効な全 phase で活性な辺に「非活性の見た目も起きる」 と誤判定する。
+  const isObject = (v: unknown): v is Record<string, unknown> =>
+    typeof v === "object" && v !== null;
+  const phaseList = (Array.isArray(phases) ? phases : []).filter(
+    (p): p is { activate: readonly string[] } => isObject(p) && Array.isArray(p.activate),
+  );
+
+  const everActive = new Set<string>();
+  for (const p of phaseList) for (const id of p.activate) everActive.add(id);
+  const everInactive = (edgeId: string): boolean =>
+    phaseList.length === 0 || phaseList.some((p) => !p.activate.includes(edgeId));
+
+  const out: Array<{ detail: string; ratio: number }> = [];
+  const reported = new Set<string>();
+  // edge も形が違えば飛ばす。 `hasRenderedLabel` は `label?.trim()` を呼ぶので、 `label` が
+  // 文字列でないと例外になる。
+  const isStringOrAbsent = (v: unknown): v is string | undefined =>
+    v === undefined || typeof v === "string";
+  for (const e of Array.isArray(edges) ? edges : []) {
+    if (!isObject(e)) continue;
+    if (!isStringOrAbsent(e.label) || !isStringOrAbsent(e.sub)) continue;
+    if (typeof e.id !== "string" || typeof e.tone !== "string") continue;
+    if (!hasRenderedLabel(e)) continue;
+    // 行ごとの閾値と合成は描画側の SSOT (`label-text.ts`) から導く。 ここに 22 / 19 /
+    // 0.95 を書き写すと、 描画を変えた時に検査だけが古い値を測り続ける。
+    const lines: EdgeLabelLine[] = [];
+    if (e.label?.trim()) lines.push("main");
+    if (e.sub?.trim()) lines.push("sub");
+
+    const states: Array<{ state: "活性" | "非活性"; fg: string }> = [];
+    if (everActive.has(e.id)) {
+      // 未知の tone も描画側は既定色で描く (`render/tone.ts` の `toneColor`)。 ここで
+      // 飛ばすと、 既定色が閾値を割った時に見逃す。 `toneColors[e.tone]` の形で引くと
+      // `toString` 等の prototype 由来の key で関数が返り、 色として扱って落ちる
+      // (同じ欠陥を `render/tone.ts` が `hasTone` で既に塞いでいる)。
+      states.push({ state: "活性", fg: toneColor(e.tone) });
+    }
+    if (everInactive(e.id)) states.push({ state: "非活性", fg: inactiveText });
+
+    for (const { state, fg } of states) {
+      for (const line of lines) {
+        const spec = textSpec[line];
+        const minRatio = requiredContrastRatio(spec);
+        const effective = spec.opacity === 1 ? fg : blendOver(fg, labelBg, spec.opacity);
+        const key = `${state}:${line}:${effective}`;
+        if (reported.has(key)) continue;
+        const ratio = contrastRatio(effective, labelBg);
+        if (ratio >= minRatio) continue;
+        reported.add(key);
+        out.push({
+          ratio,
+          detail: `${state}時の edge label ${line} 行 (${describeTextSpec(spec)}) の文字 ${effective} vs 背景 ${labelBg} の対比 ${ratio.toFixed(2)}:1 が ${minRatio}:1 未満`,
+        });
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * property を読む。 getter が例外を投げる形でも落ちない。
+ *
+ * 検査は「壊れた入力を報告する」 のが仕事なので、 読取そのものが落ちると仕事にならない。
+ * 読めなかったことは呼出側が壊れている印として扱う。
+ */
+function safeRead(obj: object, key: string): { ok: true; value: unknown } | { ok: false } {
+  try {
+    return { ok: true, value: (obj as Record<string, unknown>)[key] };
+  } catch {
+    return { ok: false };
+  }
+}
+
+/**
+ * 配列の長さを読む。 Proxy は `length` にも trap を差せるので、 読取が落ちうる。
+ *
+ * **読めなかったことを呼出側に返す**。 0 を返して黙って走査を終えると「要素が無い」 と
+ * 区別できず、 検査していないのに違反 0 件と報告することになる (本 issue が消そうとして
+ * いる失敗そのもの)。
+ */
+function safeLength(arr: readonly unknown[]): { ok: true; value: number } | { ok: false } {
+  try {
+    const n = arr.length;
+    return typeof n === "number" && Number.isFinite(n) ? { ok: true, value: n } : { ok: false };
+  } catch {
+    return { ok: false };
+  }
+}
+
+/**
+ * 浅い copy を作る。 spread (`{ ...obj }`) は全 getter を走らせるので、 1 つでも例外を投げると
+ * copy 自体が落ちる。 読めた key だけを移す。
+ */
+function safeShallowCopy(obj: object): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  let keys: string[] = [];
+  try {
+    keys = Object.keys(obj);
+  } catch {
+    return out;
+  }
+  for (const k of keys) {
+    const r = safeRead(obj, k);
+    // 読めない key は落とす。 壊れていることは `findMalformedInput` が別に報告する。
+    if (r.ok) out[k] = r.value;
+  }
+  return out;
+}
+
+/**
+ * 例外の説明を安全に取り出す。
+ *
+ * `err` は何でも投げられる (文字列 / object / getter が例外を投げる Error)。 `.message` の
+ * 読取自体が落ちると、 受け止めた意味が無くなる。
+ */
+function describeError(err: unknown): string {
+  try {
+    if (err instanceof Error) return `${err.name}: ${err.message}`;
+    if (typeof err === "string") return err;
+    return `非 Error の値 (${err === null ? "null" : typeof err})`;
+  } catch {
+    return "説明を取り出せない値";
+  }
+}
+
+/**
+ * 例外がどこで起きたかを 1 行で添える。
+ *
+ * どの軸で落ちたかを記録するには 69 箇所に印を置くことになる。 stack の最初のフレームは
+ * file と行を持つので、 印を置かずに追跡できる。 取れない環境では空を返す。
+ */
+function describeErrorOrigin(err: unknown): string {
+  try {
+    const stack = err instanceof Error ? err.stack : undefined;
+    if (typeof stack !== "string") return "";
+    const frame = stack.split("\n").find((l) => l.trim().startsWith("at "));
+    return frame === undefined ? "" : ` [${frame.trim()}]`;
+  } catch {
+    return "";
+  }
+}
+
+/** 壊れた `diag` でも報告に載せられる id を返す。 */
+function safeDiagramId(diag: unknown): string {
+  if (typeof diag !== "object" || diag === null) return "";
+  const r = safeRead(diag, "id");
+  return r.ok && typeof r.value === "string" ? r.value : "";
+}
+
+/** 2 辺が共有する節を返す。 共有しなければ空。 */
+function sharedNodes(
+  a: { from?: string; to?: string },
+  b: { from?: string; to?: string },
+): string[] {
+  const other = new Set([b.from, b.to].filter((x): x is string => x !== undefined));
+  return [a.from, a.to].filter((x): x is string => x !== undefined && other.has(x));
+}
+
+/**
+ * 共有節ごとの、 2 辺それぞれの「その節に付く側」 (#445 review)。
+ *
+ * 端の **座標だけ** を渡すと、 辺の向きを座標の近さで当てることになる。 節の別々の側に付く
+ * 辺どうし (一方は左から、 もう一方は上から入る) では端の座標が離れるため、 向きを取り違える。
+ * `from` / `to` から決めれば取り違えない。
+ */
+type SharedSide = {
+  a: { toStart: boolean; end: { x: number; y: number } };
+  b: { toStart: boolean; end: { x: number; y: number } };
+};
+
+/** 2 辺が共有する節ごとに、 各辺のどちらの端がその節かを返す。 */
+function sharedSides(
+  aRef: { from?: string; to?: string },
+  aEnds: ReadonlyArray<{ x: number; y: number }>,
+  bRef: { from?: string; to?: string },
+  bEnds: ReadonlyArray<{ x: number; y: number }>,
+): SharedSide[] {
+  const 側 = (
+    ref: { from?: string; to?: string },
+    ends: ReadonlyArray<{ x: number; y: number }>,
+    id: string,
+  ): { toStart: boolean; end: { x: number; y: number } } | undefined => {
+    // 経路は `from` から `to` へ描かれるので、 始点側が `from`、 終点側が `to`。
+    if (ref.from === id && ends[0]) return { toStart: true, end: ends[0] };
+    if (ref.to === id && ends[1]) return { toStart: false, end: ends[1] };
+    return undefined;
+  };
+  const out: SharedSide[] = [];
+  for (const id of sharedNodes(aRef, bRef)) {
+    const a = 側(aRef, aEnds, id);
+    const b = 側(bRef, bEnds, id);
+    if (a && b) out.push({ a, b });
+  }
+  return out;
+}
+
+type Seg = { x1: number; y1: number; x2: number; y2: number };
+
+/**
+ * 合流かどうかの判定。
+ *
+ * `aborted` は「予算が足りなくて見ていない」。 **`not-merged` と混ぜてはいけない** = 見た上で
+ * 合流でないのか、 見ていないのかで、 呼出側が交点を数えるかどうかは同じでも「数え切れた」
+ * を下げる必要があるかが変わる。
+ */
+type 歩いた結果 = "merged" | "not-merged" | "aborted";
+
+/**
+ * 線分 `seg` のうち、 点 `c` から距離 `tol` 以内にある範囲を媒介変数の区間で返す。
+ *
+ * **2 次方程式の判別式を直に使わない**。 `b * b - 4 * a * c` は片が長いと桁が大きく育ち、
+ * 引き算で有効桁が消える。 消えた分を「丸めの見込み」 で埋めようとすると、 幅を狭くすれば
+ * 接する形が拾えなくなり、 広くすれば離れている 2 本を重なっていると読む。 どちらに寄せても
+ * 片の長さに judgment が依存する (codex review Round 6 / 7 の実測)。
+ *
+ * 代わりに幾何で組む。 中心から線への **垂線の足** を求め、 そこからの半幅を出す。
+ *
+ * - 垂線の足の位置 `t*` = 中心を線の向きへ射影した量
+ * - 線からの距離 `h` = 外積 / 片の長さ
+ * - 半幅 = `sqrt((tol - h) * (tol + h))` / 片の長さ
+ *
+ * 半幅を `tol * tol - h * h` でなく `(tol - h) * (tol + h)` で書くのは、 接する形 (`h` が `tol`
+ * と等しい) でちょうど 0 になるため。 二乗してから引くと桁落ちで符号が揺れる。
+ *
+ * **書き方の細部は検査で覆えていない**。 `tol * tol - h * h` に戻す / 距離を外積でなく射影の
+ * 引き算で出す / 接する形の見込みを外す / 向きを単位長へ直さず `len * len` を作る / 媒介変数の
+ * 見込み幅を定数に戻す、 のいずれも手元の形では結果が変わらなかった (実測)。 落ちるのは
+ * 判別式を直に使う形に戻した時で、 検査が押さえているのはそこ。 細部は、 入力の大きさが
+ * 変わった時に効く余地を見込んで書いてある。
+ */
+function 円に入る区間(seg: Seg, cx: number, cy: number, tol: number): [number, number] | null {
+  const dx = seg.x2 - seg.x1;
+  const dy = seg.y2 - seg.y1;
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return Math.hypot(seg.x1 - cx, seg.y1 - cy) <= tol ? [0, 1] : null;
+
+  // **向きを先に単位長へ直す**。 `len * len` を作ると、 片が極端に短い時にそれ自体が 0 へ
+  // 落ちて商が `NaN` になる (片の長さは 0 でないのに区間が `[NaN, NaN]` になった)。 割り算を
+  // 長さ 1 回ぶんに留めれば、 その形は出ない。
+  const nx = dx / len;
+  const ny = dy / len;
+  const ux = cx - seg.x1;
+  const uy = cy - seg.y1;
+  // ここまでは距離の単位で持ち、 最後に長さで割って媒介変数に直す。
+  const 足 = ux * nx + uy * ny;
+  const h = Math.abs(nx * uy - ny * ux);
+  // 接する形は `h` が `tol` と等しい。 丸めで僅かに超える分だけ見込む (`tol` に対する割合な
+  // ので、 片の長さでは緩まない)。
+  if (h > tol * (1 + 4 * Number.EPSILON)) return null;
+  const 半幅 = Math.sqrt(Math.max(0, (tol - h) * (tol + h)));
+
+  const t0 = (足 - 半幅) / len;
+  const t1 = (足 + 半幅) / len;
+  // **切り詰める前に外れているかを見る**。 先に `[0, 1]` へ丸めると、 丸めで `t0` が 1 を
+  // 僅かに超えた時に下端が上端を追い越して区間が消える (同じ形へ節を足すだけで判定が変わる)。
+  //
+  // 見込む幅は媒介変数の刻みで置く。 定数 (`1e-9` 等) にすると、 片が長い時にそれが実距離で
+  // 大きな幅になる = 片の長さで判定が緩む (長さ 5 億で 0.5 相当になり、 離れている 2 本を
+  // 合流に落とした)。
+  const eps = 8 * Number.EPSILON * Math.max(1, Math.abs(t0), Math.abs(t1));
+  if (t1 < -eps || t0 > 1 + eps) return null;
+  return [Math.min(1, Math.max(0, t0)), Math.max(0, Math.min(1, t1))];
+}
+
+/** 経路の `i` 番目の節。 `i` が片の数と同じなら終点。 */
+function 節(path: ReadonlyArray<Seg>, i: number): { x: number; y: number } {
+  const last = path[path.length - 1]!;
+  if (i >= path.length) return { x: last.x2, y: last.y2 };
+  const s = path[i]!;
+  return { x: s.x1, y: s.y1 };
+}
+
+/**
+ * 2 つの経路を **同時に、 後戻りせずに** 辿って、 最初から最後まで距離 `tol` 以内を保てるか。
+ *
+ * 互いに相手の帯へ入っているかを別々に見る形では、 **通る順序** が抜ける。 同じ場所の集まりを
+ * 逆順に通る 2 本が「どちらも相手に覆われている」 になり、 本物の交差を合流として落とす
+ * (codex review Round 4 の実測)。
+ *
+ * 片方を止めて相手だけ進めてよい (帯の中で蛇行する形を許す) が、 戻ることは許さない。 これは
+ * 2 曲線の Fréchet 距離が `tol` 以下かの判定そのもので、 **経路をどう分割しても値が変わらない**
+ * = 同じ形を別の `d` で書いても判定が変わらない。
+ *
+ * 判定は自由空間図 (Alt-Godau) で行う。 片の組 `(i, j)` ごとに、 左の辺 (`P` の節 `i` から見た
+ * `Q_j` の範囲) と下の辺 (`Q` の節 `j` から見た `P_i` の範囲) を円との交わりとして出し、
+ * 左下から右上へ届くかを順に伝える。
+ */
+function 一緒に歩ける(
+  P: ReadonlyArray<Seg>,
+  Q: ReadonlyArray<Seg>,
+  tol: number,
+   予算: { 残り: number },
+): 歩いた結果 {
+  const n = P.length;
+  const m = Q.length;
+  if (n === 0 || m === 0) return "not-merged";
+  // **外側の比較と同じ予算から引く**。 ここは片の数の積だけ手間がかかるので、 予算を分けると
+  // 外側の上限を素通りして図 1 枚の時間を食い潰す (実測 = 片 1001 本どうしで 237ms、 軸が
+  // 前提にする 100ms を超えた)。 足りなければ数えずに打ち切りを返す。
+  const セル数 = n * m;
+  // 足りなければ数えずに返す。 呼出元が切り出しの手間を先に引いているので、 打ち切りが
+  // 続いても予算は必ず減る = 交点の数だけ同じ手間を繰り返すことにはならない。
+  if (セル数 > 予算.残り) return "aborted";
+  予算.残り -= セル数;
+  // 媒介変数の刻みの何倍か。 **定数 (`1e-9` 等) にしない** = 片が長いとそれ自体が大きな実距離に
+  // なり、 端まで届いていない経路を届いたと読む (長さ 5 億で、 離れている 2 本が合流に落ちた)。
+  const eps = 8 * Number.EPSILON;
+  const 始点が近い = Math.hypot(節(P, 0).x - 節(Q, 0).x, 節(P, 0).y - 節(Q, 0).y) <= tol;
+  if (!始点が近い) return "not-merged";
+
+  /** 左の辺の自由な範囲。 `P` の節 `i` から見た `Q_j` 上の範囲。 */
+  const LF = (i: number, j: number) => {
+    const v = 節(P, i);
+    return 円に入る区間(Q[j]!, v.x, v.y, tol);
+  };
+  /** 下の辺の自由な範囲。 `Q` の節 `j` から見た `P_i` 上の範囲。 */
+  const BF = (i: number, j: number) => {
+    const v = 節(Q, j);
+    return 円に入る区間(P[i]!, v.x, v.y, tol);
+  };
+  /**
+   * 下端を `lo` まで押し上げる (後戻りを許さない)。
+   *
+   * **これを外しても落ちる検査が無い** (実測)。 片の組を右か上へしか進めない構造が、 片を
+   * またぐ後戻りを既に止めているため、 残るのは 1 つの片の内側で戻る形だけ。 手元の形では
+   * そこまで細かい後戻りが結果を変えなかった。 算法としては要るので残す。
+   */
+  const 押し上げ = (span: [number, number] | null, lo: number): [number, number] | null => {
+    if (!span) return null;
+    const a = Math.max(span[0], lo);
+    return a <= span[1] ? [a, span[1]] : null;
+  };
+  /** 区間が右端 (1) まで届いているか。 */
+  const 端まで = (span: [number, number] | null) => span !== null && span[1] >= 1 - eps;
+
+  // **行 1 本だけ持つ**。 全体を格子で持つと片の数の積だけ場所を取る。 各セルが要るのは左と
+  // 下の 1 つずつなので、 1 行ぶん持って上書きしながら進めれば足りる。
+  //
+  // `左列` は処理中の行の左の辺、 `下行` は下の辺。 左は読んだ直後に「次の行の左」 で上書きし、
+  // 下は 1 つ先 (`j + 1`) に書くので、 同じ配列で足りる。
+  const 左列: Array<[number, number] | null> = new Array(m).fill(null);
+  const 下行: Array<[number, number] | null> = new Array(m + 1).fill(null);
+
+  左列[0] = LF(0, 0);
+  下行[0] = BF(0, 0);
+  // 一番左の列は、 手前の片が上端まで自由な時だけ先へ進める。
+  for (let j = 1; j < m; j++) 左列[j] = 端まで(左列[j - 1] ?? null) ? LF(0, j) : null;
+
+  for (let i = 0; i < n; i++) {
+    // 一番下の行も同じ。 前の行の下の辺 (添字 0 は行内で書き換えないので残っている) から決める。
+    if (i > 0) 下行[0] = 端まで(下行[0] ?? null) ? BF(i, 0) : null;
+    for (let j = 0; j < m; j++) {
+      const left = 左列[j] ?? null;
+      const bottom = 下行[j] ?? null;
+      // 右の辺 = 次の行の左の辺。 下から入れれば全体、 左からだけなら後戻りを許さない。
+      左列[j] = bottom ? LF(i + 1, j) : left ? 押し上げ(LF(i + 1, j), left[0]) : null;
+      // 上の辺 = 次の列の下の辺。
+      下行[j + 1] = left ? BF(i, j + 1) : bottom ? 押し上げ(BF(i, j + 1), bottom[0]) : null;
+    }
+  }
+  // 右上の角 (両方の終点) に届いたか。
+  return 端まで(左列[m - 1] ?? null) ? "merged" : "not-merged";
+}
+
+/**
+ * 交点から共有節の側へ、 2 辺の経路が **連続して** 重なっているか (#408)。
+ *
+ * 扇 (同じ節から出る) も合流 (同じ節へ入る) も、 交点から共有節側は同じ道を通る。 これを見れば
+ * 端点からの距離や辺長に対する割合を決め打つ必要が無い (実測 = 扇の交点は辺長の 12-66%、
+ * 本物の交差は 11-85% で、 どちらの尺度でも重なる)。
+ *
+ * **経路の順序を追う**。 交点から共有節側の部分経路を両方から切り出し、 それを同時に後戻り
+ * せずに辿れるか (`一緒に歩ける`) で見る。 順序を見ない形は次の 2 つを通してしまう。
+ *
+ * | 見ない形 | 通ってしまう形 |
+ * |---|---|
+ * | 固定の点をいくつか取って「全て相手に近い」 | 標本点の付近だけ接近して間で離れる (Round 2 の実測) |
+ * | 互いに相手の帯に入っているかだけを見る | 同じ場所の集まりを逆順に通る (Round 4 の実測) |
+ *
+ * 交点を含む片を丸ごと飛ばすと、 交点が片の内側にあるか端にあるかで区間が 1 片ずれる (#412)。
+ */
+function mergesTowardShared(
+  aFlat: ReadonlyArray<{ x1: number; y1: number; x2: number; y2: number }>,
+  bFlat: ReadonlyArray<{ x1: number; y1: number; x2: number; y2: number }>,
+  p: { x: number; y: number },
+  共有側: ReadonlyArray<SharedSide>,
+  tol: number,
+  予算: { 残り: number },
+): 歩いた結果 {
+  /**
+   * 交点から共有節側の部分経路を切り出す。
+   *
+   * **交点を含む片は切って使う**。 片ごと飛ばすと、 交点が片の内側にあるか端にあるかで区間が
+   * 1 片ずれる (#412)。 交点が片の端にある形では切片の長さが 0 になり、 飛ばすのと一致する。
+   *
+   * @param toStart 共有節が経路の始点側にあるか (辺の `from` / `to` から決める)
+   */
+  const 共有節側の経路 = (
+    flat: ReadonlyArray<{ x1: number; y1: number; x2: number; y2: number }>,
+    toStart: boolean,
+  ): Array<{ x1: number; y1: number; x2: number; y2: number }> => {
+    let at = -1;
+    let best = Infinity;
+    for (let i = 0; i < flat.length; i++) {
+      const s = flat[i]!;
+      const d = pointToSegmentDistance(p.x, p.y, s.x1, s.y1, s.x2, s.y2);
+      if (d < best) {
+        best = d;
+        at = i;
+      }
+    }
+    if (at < 0) return [];
+    const 交点の片 = flat[at]!;
+    const 端 = toStart ? { x: 交点の片.x1, y: 交点の片.y1 } : { x: 交点の片.x2, y: 交点の片.y2 };
+    const out = [{ x1: p.x, y1: p.y, x2: 端.x, y2: 端.y }];
+    const step = toStart ? -1 : 1;
+    for (let i = at + step; i >= 0 && i < flat.length; i += step) {
+      const seg = flat[i]!;
+      // **始点側へ辿る時は片の向きも返す**。 並べ替えるだけだと片の終わりと次の片の始まりが
+      // 繋がらず、 経路が途切れる。 順序を見る判定 (`一緒に歩ける`) では、 これが「戻った」
+      // 扱いになって扇を交差と数える。
+      out.push(toStart ? { x1: seg.x2, y1: seg.y2, x2: seg.x1, y2: seg.y1 } : seg);
+    }
+    return out;
+  };
+
+  // 1 つでも合流と言える側があれば合流。 言えないまま打ち切った側があれば、 それを伝える
+  // (「見た上で合流でない」 と「見ていない」 を混ぜない)。
+  let 打ち切った = false;
+  for (const 側 of 共有側) {
+    // 端点と交点がほぼ同じ位置なら、 間に経路が無い。 その形は端点の除外が既に捌く。
+    if (Math.hypot(側.a.end.x - p.x, 側.a.end.y - p.y) < tol) continue;
+    if (Math.hypot(側.b.end.x - p.x, 側.b.end.y - p.y) < tol) continue;
+    // 交点から共有節まで、 両方の経路が途切れずに重なっているか。
+    // **切り出しも予算から引く**。 交点に一番近い片を探すのに経路を全部見るので、 手間は片の
+    // 数に比例する。 格子の手間だけを数えると、 交点が多い図でこの走査が上限を素通りする
+    // (実測 = 片 400 本で 796ms、 軸が前提にする 100ms を超えた)。
+    const 切り出しの手間 = aFlat.length + bFlat.length;
+    // 予算が切り出しの手間にも足りない = ここから先は何も見られない。 以降の交点でもこの
+    // 判定で即座に返るので、 交点が多くても手間は増えない。
+    if (予算.残り < 切り出しの手間) return "aborted";
+    予算.残り -= 切り出しの手間;
+    const aPath = 共有節側の経路(aFlat, 側.a.toStart);
+    const bPath = 共有節側の経路(bFlat, 側.b.toStart);
+    if (aPath.length === 0 || bPath.length === 0) continue;
+    const r = 一緒に歩ける(aPath, bPath, tol, 予算);
+    if (r === "merged") return "merged";
+    if (r === "aborted") 打ち切った = true;
+  }
+  return 打ち切った ? "aborted" : "not-merged";
+}
+
+/** 点が線分のどちら側にあるか。 線上なら 0。 */ /** 点が線分のどちら側にあるか。 線上なら 0。 */
+function sideOf(
+  seg: { x1: number; y1: number; x2: number; y2: number },
+  x: number,
+  y: number,
+): number {
+  const v = (seg.x2 - seg.x1) * (y - seg.y1) - (seg.y2 - seg.y1) * (x - seg.x1);
+  return v > 0 ? 1 : v < 0 ? -1 : 0;
+}
+
+/**
+ * 交点で本当に反対側へ抜けているか。 触れて同じ側へ戻る形は交差に数えない。
+ *
+ * 分割点でヒットした時、 その前後で相手の線のどちら側に居るかを見る。 側が変わっていなければ
+ * 接しているだけ (実測 = 水平線に下から触れて戻る曲線 3 本で 3 件の誤検知)。
+ *
+ * 相手の線は交点の近くの分割片で近似する。 曲線どうしでも、 交点の周りでは直線とみなせる。
+ */
+function crossesSides(
+  aFlat: ReadonlyArray<{ x1: number; y1: number; x2: number; y2: number }>,
+  bFlat: ReadonlyArray<{ x1: number; y1: number; x2: number; y2: number }>,
+  p: { x: number; y: number },
+  tol: number,
+): boolean {
+  // 交点に最も近い相手の分割片を基準線にする。
+  let base: { x1: number; y1: number; x2: number; y2: number } | undefined;
+  let bestD = Infinity;
+  for (const sb of bFlat) {
+    const d = pointToSegmentDistance(p.x, p.y, sb.x1, sb.y1, sb.x2, sb.y2);
+    if (d < bestD) {
+      bestD = d;
+      base = sb;
+    }
+  }
+  if (!base) return true;
+  // 自分の線の、 交点より手前と先の点を取る。 交点の近くの点は側が定まらないので飛ばす。
+  const pts: Array<{ x: number; y: number }> = [];
+  for (const sa of aFlat) {
+    pts.push({ x: sa.x1, y: sa.y1 }, { x: sa.x2, y: sa.y2 });
+  }
+  const idx = pts.findIndex((q) => Math.abs(q.x - p.x) <= tol && Math.abs(q.y - p.y) <= tol);
+  const before =
+    idx >= 0 ? pts.slice(0, idx) : pts.filter((q) => q.x < p.x || (q.x === p.x && q.y < p.y));
+  const after =
+    idx >= 0 ? pts.slice(idx + 1) : pts.filter((q) => q.x > p.x || (q.x === p.x && q.y > p.y));
+  const sideBefore = [...before]
+    .reverse()
+    .map((q) => sideOf(base, q.x, q.y))
+    .find((v) => v !== 0);
+  const sideAfter = after.map((q) => sideOf(base, q.x, q.y)).find((v) => v !== 0);
+  // 片側しか無い (端で接している) 形は交差ではない。
+  if (sideBefore === undefined || sideAfter === undefined) return false;
+  return sideBefore !== sideAfter;
+}
+
+/**
+ * 辺どうしの交差を **実際に描かれる曲線** で数える (軸 11、 #385)。
+ *
+ * 弦のまま数えていた頃は、 弦どうしが平行で弧だけが交わる形を落としていた (#383 の反例 =
+ * 弦 0 件 / 実曲線 2 件)。
+ *
+ * 折れ線に開くだけでは直らない。 `segmentsIntersect` は端点の接触を交差に数えないため、
+ * 交差が分割点にちょうど乗ると隣り合う 2 本の分割片が両方とも端点接触になり、 交差が
+ * **消える** (#384 実測 = `M 0 0 Q 80 80, 160 160` と y=40/80/120 の 3 本で 弦 3 件 → 折れ線
+ * 0 件)。 端点を数える判定に替えると、 今度は同じ節から出る辺どうしの共有端点を数える。
+ *
+ * そこで交点の **座標** を返す判定を使い、 辺の元の端点に一致する交点だけを除く。 分割で
+ * 生まれた節は除かない。 残りを座標で重複排除すると、 分割点に乗った交差が 2 度数えられる
+ * ことも無くなる。
+ *
+ * 関数に切り出してあるのは、 計算量を test から直接測れるようにするため。 検証全体の時間で
+ * 測ると、 曲線では他の軸も分割の分だけ重くなって本軸の寄与が読めない (実測 = 全体の差 138ms に
+ * 対し本軸の寄与は 41ms)。
+ *
+ * @param warnAt 数えるのをやめる件数。 判定は「この件数以上か」 だけなので、 達したら打ち切る。
+ * @returns `complete` は最後まで数え切れたか。 比較回数の上限で止めた時は `false` になり、
+ *   「交差が無い」 と「数え切れなかった」 を呼出側が区別できる。
+ */
+export function countEdgeCrossings(
+  edges: ReadonlyArray<{ id: string; d: string; from?: string; to?: string }>,
+  warnAt = 3,
+): { count: number; pairs: string[]; complete: boolean } {
+  /** 同じ点とみなす距離。 分割で生まれた節の両側から同じ交点が出るのを 1 件にまとめる。 */
+  const SAME_POINT_TOL = 0.5;
+  /** 経路が重なっているとみなす距離。 曲がり角を折れ線に開く刻みの差を吸収する分だけ持たせる。 */
+  const MERGE_TOL = 2;
+  /**
+   * 分割片どうしの比較回数の上限。
+   *
+   * 辺の総当たりで、 各対の分割片を全比較する。 曲線 380 本の図では 1850 万回になり 264ms
+   * かかった (実測)。 1 図あたりの予算は `PERF_BUDGET_PER_DIAGRAM_MS` = 100 で、 他の軸が
+   * 150ms 前後使うため本軸に使えるのは僅か。
+   *
+   * **上限に達したら数えるのをやめる**。 包囲箱で絞れないのは曲線どうしが広く重なる図で、
+   * その形は総当たり以外に手が無い。 打ち切ると警告が出ないが、 出ない状態は弦で数えていた
+   * 頃と同じで、 見逃しが増えるわけではない。
+   */
+  const MAX_CHECKS = 500_000;
+  /**
+   * 1 対あたりの比較回数の上限。
+   *
+   * 全体の上限だけだと、 先頭の対が上限を使い切って後続を 1 本も見ない。 交差の無い扇 64 本で
+   * 「打ち切った」 警告が出ていた (実測)。 対ごとに配れば、 重い対があっても他の対は見る。
+   *
+   * 分割は最小 16 / 最大 4096。 通常の辺どうし (16x16 = 256) の 100 倍を上限に置く。
+   *
+   * これでも辺が数十本を超えると全体の上限に達する (実測 = 扇 64 本 / 2016 対)。 見本の最大は
+   * 8 辺 (28 対) で完走する。 それを超える規模で見落とすのは、 全体の上限が持つ性質と同じ。
+   */
+  const MAX_CHECKS_PER_PAIR = 25_600;
+  let checks = 0;
+  let count = 0;
+  let complete = true;
+  const pairs: string[] = [];
+  const prepared = edges.map((e) => {
+    const flat = flattenPathSegments(extractPathSegments(e.d));
+    const first = flat[0];
+    const last = flat[flat.length - 1];
+    return {
+      id: e.id,
+      ref: e,
+      flat,
+      // 辺そのものの端点。 同じ節から出る辺どうしの共有端点を交差に数えないために使う。
+      ends:
+        first && last
+          ? [
+              { x: first.x1, y: first.y1 },
+              { x: last.x2, y: last.y2 },
+            ]
+          : [],
+      box: segmentsBBox(flat),
+    };
+  });
+  outer: for (let i = 0; i < prepared.length; i++) {
+    const a = prepared[i]!;
+    for (let j = i + 1; j < prepared.length; j++) {
+      const b = prepared[j]!;
+      // 包囲箱が離れていれば分割片を 1 本も比べない。
+      if (!bboxOverlaps(a.box, b.box)) continue;
+      // 節を共有する辺どうしも、 **一律には除かない** (#408)。
+      //
+      // #385 では扇 (同じ節から出る) と合流 (同じ節へ入る) の誤検知を避けるため、 節を共有する
+      // 対をまとめて外していた。 代償として、 共有節と無関係な場所で交わる形まで消えていた。
+      //
+      // その後 #385 の Round 1 で足した 2 つの判定が、 扇と合流を別経路で捌くようになった。
+      //
+      // - 辺の端点に一致する交点を除く (`isNearAny`)
+      // - 触れて同じ側へ戻る形を除く (`crossesSides`)
+      //
+      // 見本の `pattern-fan-out` / `pattern-fan-in` で実測 = 対の除外を外しても 0 件のまま。
+      // 一律の除外は要らなくなった。
+      // 節を共有する辺は、 その節に向かって経路が重なる区間の交点だけを除く。
+      //
+      // 経路が最後まで重なる対 (engine が作る扇 / 合流のうち、 分かれる前に交点が無い形) は
+      // 交点そのものが出ない。 分割片の総当たりだけが残って比較回数を食うので、 先に外す。
+      // 実測 = 扇 64 本で上限に達し、 交差の無い図でも「打ち切った」 警告が出ていた。
+      const 共有側 = sharedSides(a.ref, a.ends, b.ref, b.ends);
+      const hits: Array<{ x: number; y: number }> = [];
+      /** 上限で止めたか。 止めた時も、 それまでに見つけた交点は捨てない。 */
+      let aborted = false;
+      /** この対で使った比較回数。 1 対が全体の上限を使い切らないようにする。 */
+      let pairChecks = 0;
+      /** この対を上限で切ったか。 */
+      let pairAborted = false;
+      for (const sa of a.flat) {
+        if (aborted || pairAborted) break;
+        // 分割片の包囲箱も見る。 辺の包囲箱が重なっていても、 実際に近いのはその一部だけ。
+        const saMinX = Math.min(sa.x1, sa.x2);
+        const saMaxX = Math.max(sa.x1, sa.x2);
+        const saMinY = Math.min(sa.y1, sa.y2);
+        const saMaxY = Math.max(sa.y1, sa.y2);
+        for (const sb of b.flat) {
+          // 除外そのものも回数に数える。 除外した分を数えないと、 包囲箱の判定が 1850 万回
+          // そのまま残って上限が効かない (実測 = 552ms)。
+          if (++checks > MAX_CHECKS) {
+            aborted = true;
+            complete = false;
+            break;
+          }
+          // 1 対が上限を使い切ると後続の対を 1 本も見ない。 対ごとに切って次へ進む。
+          //
+          // **`complete` は下げる**。 その対を最後まで見ていないので、 後ろに交点があっても
+          // 気付けない。 「見ていない」 ことを黙って隠すと、 呼出側が 0 件を「交差なし」 と
+          // 読む (codex review Round 2 の指摘)。
+          if (++pairChecks > MAX_CHECKS_PER_PAIR) {
+            pairAborted = true;
+            complete = false;
+            break;
+          }
+          if (Math.min(sb.x1, sb.x2) > saMaxX || Math.max(sb.x1, sb.x2) < saMinX) continue;
+          if (Math.min(sb.y1, sb.y2) > saMaxY || Math.max(sb.y1, sb.y2) < saMinY) continue;
+          const p = segmentIntersection(sa, sb);
+          if (!p) continue;
+          // 触れて同じ側へ戻る形は交差ではない。 分割点で相手に接するだけの曲線を数えると、
+          // 実際には交わらない図で警告が出る (実測 = 水平線に下から触れて戻る曲線 3 本で 3 件)。
+          // 両方向で見る。 片方向だけだと辺の並べ順で結果が変わる (実測 = 同じ接線の形で
+          // 曲線→水平線は 0 件、 水平線→曲線は 1 件)。
+          //
+          // **この判定も経路を全部見る**。 交点 1 つにつき片の数の和だけ手間がかかるので、
+          // 予算から引く。 引かないと、 同じ場所で何度も交わる形でここが上限を素通りする
+          // (実測 = 片 1000 本どうしが同じ 2 点を往復する形で 220ms、 軸が前提にする 100ms 超)。
+          const 側の手間 = a.flat.length + b.flat.length;
+          if (checks + 側の手間 > MAX_CHECKS) {
+            aborted = true;
+            complete = false;
+            break;
+          }
+          if (pairChecks + 側の手間 > MAX_CHECKS_PER_PAIR) {
+            pairAborted = true;
+            complete = false;
+            break;
+          }
+          checks += 側の手間;
+          pairChecks += 側の手間;
+          if (!crossesSides(a.flat, b.flat, p, SAME_POINT_TOL)) continue;
+          if (!crossesSides(b.flat, a.flat, p, SAME_POINT_TOL)) continue;
+
+          // 辺の端点で接しているだけなら数えない (同じ節から出る 2 辺)。
+          if (isNearAny(p, a.ends, SAME_POINT_TOL) || isNearAny(p, b.ends, SAME_POINT_TOL))
+            continue;
+          // 共有する節に向かって経路が重なる区間なら数えない (扇の根元 / 合流点)。
+          //
+          // 判定は外側と同じ予算から引く。 使った分を戻して外側の counter に足すことで、
+          // 合流の判定だけが上限を素通りして時間を食い潰す形にならない。
+          if (共有側.length > 0) {
+            const 枠 = Math.min(MAX_CHECKS - checks, MAX_CHECKS_PER_PAIR - pairChecks);
+            const 予算 = { 残り: Math.max(0, 枠) };
+            const 判定 = mergesTowardShared(a.flat, b.flat, p, 共有側, MERGE_TOL, 予算);
+            const 使った = Math.max(0, 枠) - 予算.残り;
+            checks += 使った;
+            pairChecks += 使った;
+            if (判定 === "merged") continue;
+            // **打ち切った時は交点を捨てない**。 合流かどうかを見ていないので、 捨てると
+            // 「見ていない」 が「交差なし」 に化ける。 数えた上で `complete` を下げる。
+            if (判定 === "aborted") complete = false;
+          }
+          // 分割で生まれた節に交差が乗ると、 両側の分割片から同じ点が出る。
+          if (isNearAny(p, hits, SAME_POINT_TOL)) continue;
+          hits.push(p);
+        }
+      }
+      if (hits.length > 0) {
+        count += hits.length;
+        pairs.push(`${a.id}×${b.id}(${hits.length})`);
+        if (count >= warnAt) break outer;
+      }
+      // 上限で止めた時は、 この対の分を確定させてから抜ける。 途中で捨てると、 交差のある辺を
+      // 末尾に置いた図で 0 件になる (実測 = 同じ辺集合で並べ順を変えると 0 と 3 に割れた)。
+      if (aborted) break outer;
+    }
+  }
+  return { count, pairs, complete };
+}
+
+export function visualValidateLaid(
+  laid: LaidDiagram,
+  diag: CdlDiagram,
+  opts?: ValidateOptions,
+): VisualValidationReport {
+  const violations: Violation[] = [];
+  const counts = emptyCounts();
+  const profile = opts?.profile ?? "production";
+  const skipped = SKIPPED_AXES[profile];
+  const push = (axis: VisualAxis, detail: string, severity: "error" | "warn" = "error") => {
+    // 用途に合わない軸は数えない。
+    if (skipped.has(axis)) return;
+    // `diag` は壊れた形でも渡りうる (`#393`)。 報告そのものが例外になると、 壊れている
+    // ことを伝える手段が無くなる。
+    violations.push({ axis, diagramId: safeDiagramId(diag), detail, severity });
+    counts[axis]++;
+  };
+
+  return visualValidateInner(laid, diag, violations, counts, push, profile, [...skipped]);
+}
+
+/**
+ * 1 つの cdl diagram を 6 軸で視覚検証する。
+ *
+ * layout 計算込みで実行する。 `diag` は CdlDiagram (compile 前の builder 出力)。
+ * layout 中の console.warn ([cdl layout] overlap / near) は本 validator が再判定するため抑止する。
+ */
+export function visualValidate(diag: CdlDiagram, opts?: ValidateOptions): VisualValidationReport {
+  const violations: Violation[] = [];
+  const counts = emptyCounts();
+  const profile = opts?.profile ?? "production";
+  const skipped = SKIPPED_AXES[profile];
+  const push = (axis: VisualAxis, detail: string, severity: "error" | "warn" = "error") => {
+    // 用途に合わない軸は数えない。 見なかった軸は report の `skippedAxes` に載せる。
+    if (skipped.has(axis)) return;
+    violations.push({ axis, diagramId: safeDiagramId(diag), detail, severity });
+    counts[axis]++;
+  };
+
+  // `diag` の検査と正規化は **`layout()` より前に** 行う。 後ろに置くと、 壊れた `diag` は
+  // `layout()` の中で例外になり `clearance` として報告されて `malformed-input` に届かない。
+  // 本 API が公開の入口なので、 ここを通らないと変更の目的を果たさない (`#393`)。
+  const diagProblems = findMalformedInput(undefined, diag).filter((p) =>
+    p.where.startsWith("diag"),
+  );
+  for (const p of diagProblems) push("malformed-input", p.detail, "error");
+  const safeDiag =
+    diagProblems.length > 0 ? normalizeForValidation(diag, diagProblems, "diag") : diag;
+
+  // layout を 1 回計算
+  let laid: LaidDiagram;
+  // layout 内の console.warn を一時抑止 (本 validator が同じ判定をやり直す)
+  const origWarn = console.warn;
+  console.warn = () => {};
+  try {
+    laid = layout(safeDiag);
+  } catch (err) {
+    console.warn = origWarn;
+    // 正規化しても `layout()` が落ちる形は入力の破綻として報告する。 `clearance` に混ぜると
+    // 「間隔の問題」 と読めてしまう。
+    push("malformed-input", `layout が例外で落ちた: ${describeError(err)}`, "error");
+    return {
+      diagramId: safeDiagramId(safeDiag),
+      ok: false,
+      violations,
+      counts,
+      profile,
+      skippedAxes: [...skipped],
+    };
+  } finally {
+    console.warn = origWarn;
+  }
+
+  return visualValidateInner(laid, safeDiag, violations, counts, push, profile, [...skipped]);
+}
+
+/**
+ * 入口で形を見る top-level の配列。 `[所有者, field 名]` の組で持つ。
+ *
+ * 基準は **`LaidDiagram` / `CdlDiagram` が必須の配列として宣言している field を全て** で、
+ * 「どの軸が読むか」 では選ばない。 読む側で選ぶと、 軸を足した時に一覧の更新が要る
+ * (`laid.states` は現在どの軸も読まないが、 読み始めた時に追記を忘れれば穴が開く)。
+ * 型から導ける基準にすることで、 その drift を作らない。
+ *
+ * **optional な配列は入れない**。 `undefined` が正当なので「配列でない」 が壊れている印に
+ * ならない。 個別に列挙すると型に追随できないので、 条件で書く (`RequiredArrayKeys<T>` が
+ * `undefined` を含む key を落とすため、 一覧と型の突き合わせも自動で optional を除く)。
+ *
+ * 深さ 1 段までしか見ない。 要素の中の field が壊れた形 (`phases[0].tweens` 欠落 等) は
+ * 入口を通り抜けて受け止め側に落ちる。 深くしていくと静的検査の非収束に入るため、
+ * ここで止める (`#393`)。
+ */
+/**
+ * `T` が **必須** の配列として宣言している key の union。
+ *
+ * optional (`?:`) は `undefined` を含むので `readonly unknown[]` に代入できず、 自動的に外れる。
+ * 一覧の網羅を型で確かめるために使う (正規表現で型定義を読む形は、 宣言の書き方が変わると
+ * 黙って拾えなくなる)。
+ */
+type RequiredArrayKeys<T> = {
+  [K in keyof T]-?: undefined extends T[K] ? never : T[K] extends readonly unknown[] ? K : never;
+}[keyof T];
+
+/** 一覧が両型の必須配列を **過不足なく** 覆うことを compile 時に確かめる。 */
+type LaidArrayKey = RequiredArrayKeys<LaidDiagram> & string;
+type DiagArrayKey = RequiredArrayKeys<CdlDiagram> & string;
+
+export const VALIDATED_ARRAY_FIELDS = [
+  ["laid", "lanes"],
+  ["laid", "nodes"],
+  ["laid", "edges"],
+  ["laid", "states"],
+  ["laid", "phases"],
+  ["laid", "bboxes"],
+  ["laid", "collisions"],
+  ["laid", "nearCollisions"],
+  ["diag", "lanes"],
+  ["diag", "nodes"],
+  ["diag", "edges"],
+  ["diag", "states"],
+  ["diag", "phases"],
+] as const;
+
+// 一覧が両型の必須配列を **過不足なく** 覆うことを compile 時に確かめる。
+//
+// `as const` で literal を保つのが要 (`ReadonlyArray<...>` と注釈すると literal が消えて
+// 突き合わせが恒真になり、 key を落としても通ってしまう = 一度これで空振りさせた)。
+type CoveredLaid = Extract<(typeof VALIDATED_ARRAY_FIELDS)[number], readonly ["laid", string]>[1];
+type CoveredDiag = Extract<(typeof VALIDATED_ARRAY_FIELDS)[number], readonly ["diag", string]>[1];
+
+// 足りない key があれば `never` でなくなり、 `true` を代入できずに型検査が落ちる。
+const _noMissingLaid: Exclude<LaidArrayKey, CoveredLaid> extends never ? true : never = true;
+const _noMissingDiag: Exclude<DiagArrayKey, CoveredDiag> extends never ? true : never = true;
+// 逆向き = 型に無い key を一覧に書いていないか。
+const _noExtraLaid: Exclude<CoveredLaid, LaidArrayKey> extends never ? true : never = true;
+const _noExtraDiag: Exclude<CoveredDiag, DiagArrayKey> extends never ? true : never = true;
+void _noMissingLaid;
+void _noMissingDiag;
+void _noExtraLaid;
+void _noExtraDiag;
+
+/** `viewBox` に要る数値。 1 つでも欠けると座標の比較が `undefined` との比較になる。 */
+const VIEWBOX_KEYS = ["x", "y", "w", "h"] as const;
+
+/**
+ * `phases[i]` の中で、 軸が **反復する** 配列。
+ *
+ * 深さ 2 だが、 **3 つに閉じているので非収束にならない**。 「要素の中を一般に検査する」 の
+ * ではなく、 反復される配列を名指しする。 塞ぐ価値が高いのは、 ここが `#392` の事故そのもの
+ * だから (`p.activate` の無条件反復で 68 軸が巻き添えになった)。
+ *
+ * 増やす時は「軸が反復するか」 で判断する。 反復しない field を足すと、 壊れていても実害の
+ * 無い形まで報告することになる。
+ */
+const VALIDATED_PHASE_ARRAY_FIELDS = ["activate", "tweens", "sets"] as const;
+
+export interface MalformedInputProblem {
+  /** `laid.edges` のような、 どこが壊れているかの名前。 */
+  where: string;
+  detail: string;
+}
+
+/**
+ * 検査に渡された図の形を見て、 壊れている箇所を挙げる (`#393`)。
+ *
+ * 見るのは top-level の配列 13 個と `viewBox` の数値 4 つ。 配列でない field と、 要素に
+ * object でないものが混ざる場合を挙げる。
+ *
+ * **正規化はここでは行わない**。 呼出側が「報告してから差し替える」 を順に行う。
+ */
+export function findMalformedInput(laid: unknown, diag: unknown): MalformedInputProblem[] {
+  const out: MalformedInputProblem[] = [];
+  // `typeof null` は `"object"` なので、 そのまま出すと「object でない (object)」 になる。
+  // 値そのものは出さない = 入力に秘密が入っていても報告に流れない。 `String(v)` を使うと
+  // `Symbol.toPrimitive` / `toString` が走り、 そこで例外が出ると **検査自体が落ちる**
+  // (層 2 の受け止めより前なので拾えない)。
+  const kindOf = (v: unknown): string => {
+    if (v === null) return "null";
+    if (typeof v !== "number") return typeof v;
+    return Number.isNaN(v) ? "NaN" : Number.isFinite(v) ? "number" : "Infinity";
+  };
+  const owners: Record<"laid" | "diag", unknown> = { laid, diag };
+
+  for (const [owner, field] of VALIDATED_ARRAY_FIELDS) {
+    const holder = owners[owner];
+    if (typeof holder !== "object" || holder === null) {
+      // 所有者ごと壊れている場合は field を見ても意味がない。 1 度だけ挙げて次へ。
+      if (!out.some((p) => p.where === owner)) {
+        out.push({ where: owner, detail: `${owner} が object でない (${kindOf(holder)})` });
+      }
+      continue;
+    }
+    const read = safeRead(holder, field);
+    if (!read.ok) {
+      out.push({ where: `${owner}.${field}`, detail: `${owner}.${field} の読取が例外になった` });
+      continue;
+    }
+    const value = read.value;
+    if (!Array.isArray(value)) {
+      out.push({
+        where: `${owner}.${field}`,
+        detail: `${owner}.${field} が配列でない (${kindOf(value)})`,
+      });
+      continue;
+    }
+    // 要素の読取も保護する。 配列は index に getter を差せるので、 走査そのものが落ちうる。
+    let badIndex = -1;
+    let badKind = "";
+    try {
+      const lenRead = safeLength(value);
+      if (!lenRead.ok) {
+        out.push({
+          where: `${owner}.${field}`,
+          detail: `${owner}.${field} の長さの読取が例外になった`,
+        });
+        continue;
+      }
+      for (let i = 0; i < lenRead.value; i++) {
+        const v = value[i];
+        if (typeof v !== "object" || v === null) {
+          badIndex = i;
+          badKind = kindOf(v);
+          break;
+        }
+      }
+    } catch {
+      out.push({
+        where: `${owner}.${field}`,
+        detail: `${owner}.${field} の要素の読取が例外になった`,
+      });
+      continue;
+    }
+    if (badIndex >= 0) {
+      out.push({
+        where: `${owner}.${field}[${badIndex}]`,
+        detail: `${owner}.${field}[${badIndex}] が object でない (${badKind})`,
+      });
+    }
+  }
+
+  // phase の中の配列 3 つ。 `diag.phases` が配列として通った時だけ見る。
+  const phasesRead =
+    typeof diag === "object" && diag !== null ? safeRead(diag, "phases") : ({ ok: false } as const);
+  const phases = phasesRead.ok ? phasesRead.value : undefined;
+  if (Array.isArray(phases)) {
+    const phLen = safeLength(phases);
+    if (!phLen.ok) {
+      out.push({ where: "diag.phases", detail: "diag.phases の長さの読取が例外になった" });
+    }
+    for (let i = 0; phLen.ok && i < phLen.value; i++) {
+      const phRead = safeRead(phases, String(i));
+      if (!phRead.ok) continue; // 読取の失敗は上で挙げた
+      const ph = phRead.value;
+      if (typeof ph !== "object" || ph === null) continue; // 要素そのものは上で挙げた
+      for (const f of VALIDATED_PHASE_ARRAY_FIELDS) {
+        const rd = safeRead(ph, f);
+        if (!rd.ok) {
+          out.push({
+            where: `diag.phases[${i}].${f}`,
+            detail: `diag.phases[${i}].${f} の読取が例外になった`,
+          });
+          continue;
+        }
+        const v = rd.value;
+        if (!Array.isArray(v)) {
+          out.push({
+            where: `diag.phases[${i}].${f}`,
+            detail: `diag.phases[${i}].${f} が配列でない (${kindOf(v)})`,
+          });
+        }
+      }
+    }
+  }
+
+  const vbRead =
+    typeof laid === "object" && laid !== null
+      ? safeRead(laid, "viewBox")
+      : ({ ok: false } as const);
+  if (!vbRead.ok) out.push({ where: "laid.viewBox", detail: "laid.viewBox の読取が例外になった" });
+  const vb = vbRead.ok ? vbRead.value : undefined;
+  if (typeof vb !== "object" || vb === null) {
+    out.push({ where: "laid.viewBox", detail: `laid.viewBox が object でない (${kindOf(vb)})` });
+  } else {
+    for (const k of VIEWBOX_KEYS) {
+      const nr = safeRead(vb, k);
+      if (!nr.ok) {
+        out.push({ where: `laid.viewBox.${k}`, detail: `laid.viewBox.${k} の読取が例外になった` });
+        continue;
+      }
+      const n = nr.value;
+      if (typeof n !== "number" || !Number.isFinite(n)) {
+        out.push({
+          where: `laid.viewBox.${k}`,
+          detail: `laid.viewBox.${k} が有限の数値でない (${kindOf(n)})`,
+        });
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * 壊れた箇所を、 検査が反復できる形に差し替える。
+ *
+ * 元の object は書き換えない (呼出側が渡したものを検査の副作用で変えない)。 配列でない field は
+ * 空配列に、 object でない要素は取り除く。 `viewBox` は原点と 0 幅に倒す = 「何も含まない枠」
+ * として扱われ、 枠の内外を見る軸は全 node を外と判定する。 これは誤判定ではなく、 枠が
+ * 壊れている以上「収まっている」 とは言えないため。
+ */
+function normalizeForValidation<T>(
+  value: T,
+  problems: MalformedInputProblem[],
+  owner: "laid" | "diag",
+): T {
+  if (problems.length === 0) return value;
+  if (typeof value !== "object" || value === null) {
+    return (
+      owner === "laid"
+        ? {
+            id: "",
+            topic: "",
+            viewBox: { x: 0, y: 0, w: 0, h: 0 },
+            nodes: [],
+            edges: [],
+            lanes: [],
+            phases: [],
+            states: [],
+            bboxes: [],
+            collisions: [],
+            nearCollisions: [],
+          }
+        : {
+            id: "",
+            topic: "",
+            viewport: {},
+            nodes: [],
+            edges: [],
+            lanes: [],
+            phases: [],
+            states: [],
+          }
+    ) as T;
+  }
+  const next = safeShallowCopy(value as object);
+  for (const [o, field] of VALIDATED_ARRAY_FIELDS) {
+    if (o !== owner) continue;
+    const v = next[field];
+    if (!Array.isArray(v)) {
+      next[field] = [];
+      continue;
+    }
+    // 要素の読取も落ちうる (index に getter を差せる)。 読めた要素だけを残す。
+    const kept: unknown[] = [];
+    // 長さが読めなければ空に倒す (読めなかったことは `findMalformedInput` が報告済)。
+    const len = safeLength(v as readonly unknown[]);
+    for (let i = 0; len.ok && i < len.value; i++) {
+      const r = safeRead(v as unknown as object, String(i));
+      if (!r.ok) continue;
+      if (typeof r.value === "object" && r.value !== null) kept.push(r.value);
+    }
+    next[field] = kept;
+  }
+  if (owner === "diag" && Array.isArray(next["phases"])) {
+    next["phases"] = (next["phases"] as unknown[]).map((ph) => {
+      // ここへ来る配列は上の loop が作り直したもの = 読めた要素だけが入っている。
+      if (typeof ph !== "object" || ph === null) return ph;
+      const rec = safeShallowCopy(ph as object);
+      if (VALIDATED_PHASE_ARRAY_FIELDS.every((f) => Array.isArray(rec[f]))) return ph;
+      const copy = rec;
+      for (const f of VALIDATED_PHASE_ARRAY_FIELDS) {
+        if (!Array.isArray(copy[f])) copy[f] = [];
+      }
+      return copy;
+    });
+  }
+  if (owner === "laid") {
+    const vb = next["viewBox"];
+    const ok =
+      typeof vb === "object" &&
+      vb !== null &&
+      VIEWBOX_KEYS.every((k) => {
+        // getter が例外を投げる形でも落ちない。 ここは受け止めの外側なので、 落ちると
+        // 報告を返せない。
+        const r = safeRead(vb, k);
+        return r.ok && typeof r.value === "number" && Number.isFinite(r.value);
+      });
+    if (!ok) next["viewBox"] = { x: 0, y: 0, w: 0, h: 0 };
+  }
+  return next as T;
+}
+
+function visualValidateInner(
+  laid: LaidDiagram,
+  diag: CdlDiagram,
+  violations: Violation[],
+  counts: Record<VisualAxis, number>,
+  push: (axis: VisualAxis, detail: string, severity?: "error" | "warn") => void,
+  profile: ValidationProfile,
+  skippedAxes: VisualAxis[],
+): VisualValidationReport {
+  // 層 1 = 入口の検査 (top-level の配列 13 個と `viewBox`)。 壊れている箇所を報告してから、
+  // 検査が反復できる形に差し替える。
+  // 報告を先に出すのは、 差し替えた後は「元が壊れていた」 と「元から空だった」 が
+  // 区別できなくなるため。
+  const problems = findMalformedInput(laid, diag);
+  for (const p of problems) push("malformed-input", p.detail, "error");
+  if (problems.length > 0) {
+    laid = normalizeForValidation(laid, problems, "laid");
+    diag = normalizeForValidation(diag, problems, "diag");
+  }
+
+  // 層 2 = すり抜けの受け止め。 入口は深さ 1 段までしか見ないので、 要素の中の field が
+  // 壊れた形は例外になりうる。 例外を外に出すと **その図の全軸の結果が失われる**
+  // (`#392` で実際に起きた = 1 軸の例外が 68 軸を巻き添えにした)。
+  //
+  // 途中までに見つけた違反は `violations` に積まれているので保持される。 例外を投げた軸より
+  // 後ろの軸は走らない = 「検査できなかった」 ことを報告に出す。
+  try {
+    return runAxes(laid, diag, violations, counts, push, profile, skippedAxes);
+  } catch (err) {
+    // 入口が既に破綻を見つけていたなら入力側、 何も見つけていなければ検査側の欠陥。
+    // 直す先が違うので軸を分ける。 まとめると「入力が悪い」 と誤読して本 file の bug を
+    // 見逃す。
+    // 入口が破綻を見つけていれば入力側と分かる。 見つけていない時は **決められない**
+    // (入口が届かない破綻 = getter が例外を投げる形 も、 検査側の欠陥も、 同じに見える)。
+    // 判定は `problems` ではなく `counts` を見る。 `visualValidate` は `layout()` の前にも
+    // `diag` を検査して報告を積むので、 ここの入口検査だけを見ると **前段の発見を見落とす**。
+    //
+    // 節を持たない図では `layout()` の出力が汚れず (`viewBox` が有限のまま)、 ここの入口が
+    // 何も見つけない。 その状態で後段が落ちると、 既に分かっている入力の破綻を「判別不能」
+    // と報告してしまう (実測で再現した)。 `counts` は前段の push も数えている。
+    const known = counts["malformed-input"] > 0;
+    const axis: VisualAxis = known ? "malformed-input" : "validation-interrupted";
+    const cause = known
+      ? "入力の破綻が原因"
+      : "原因は入力の深部の破綻か検査側の欠陥のどちらか (入口では判別できない)";
+    push(
+      axis,
+      `検査が例外で中断した (ここまでの ${violations.length} 件は有効、 以降の軸は未実行、 ${cause}): ` +
+        `${describeError(err)}${describeErrorOrigin(err)}`,
+      "error",
+    );
+    return { diagramId: safeDiagramId(diag), ok: false, violations, counts, profile, skippedAxes };
+  }
+}
+
+function runAxes(
+  laid: LaidDiagram,
+  diag: CdlDiagram,
+  violations: Violation[],
+  counts: Record<VisualAxis, number>,
+  push: (axis: VisualAxis, detail: string, severity?: "error" | "warn") => void,
+  profile: ValidationProfile,
+  skippedAxes: VisualAxis[],
+): VisualValidationReport {
+  // ───────────────────────────────────────────────────────────
+  // Axis 1: node-visibility (bbox 面積 / 最小寸法)
+  //
+  // sequence preset の lifeline (w=2 の極細 node) は線として描画される intentional 実装で
+  // 視覚的に正しい。 w < 8 の node は lifeline / 装飾線扱いとして判定対象外。
+  // ───────────────────────────────────────────────────────────
+  const LIFELINE_W_THRESHOLD = 8;
+  for (const n of laid.nodes) {
+    if (n.w < LIFELINE_W_THRESHOLD) continue;
+    if (n.w < MIN_NODE_W || n.h < MIN_NODE_H) {
+      push(
+        "node-visibility",
+        `node "${n.id}" size ${n.w}x${n.h} 未満 (要 ${MIN_NODE_W}x${MIN_NODE_H} 以上)`,
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 2: edge-label-overlap (edge label ↔ node の AABB collision)
+  // ───────────────────────────────────────────────────────────
+  const bboxes = collectBBoxes(laid.lanes, laid.nodes, laid.edges);
+  const collisions = detectCollisions(bboxes, laid.edges);
+  for (const c of collisions) {
+    const involvesEdgeLabel = c.a.kind === "edge-label" || c.b.kind === "edge-label";
+    if (!involvesEdgeLabel) continue;
+    push(
+      "edge-label-overlap",
+      `${c.a.kind}:${c.a.id} ↔ ${c.b.kind}:${c.b.id} overlap=${c.overlap_area}`,
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 3: text-readability (font size 固定判定)
+  // ───────────────────────────────────────────────────────────
+  // cdl render は各 kind で font size を hard-code (kinds/*.tsx) しているため、
+  // ここでは「title 文字長 vs node 幅」 を見て切れる可能性を warn する。
+  for (const n of laid.nodes) {
+    // spacer node (id 末尾 "-spacer" or title 空/whitespace のみ) は幅 2px で意図的に不可視配置、
+    // false positive 発火を回避するため text-readability 判定対象外
+    if (n.id.endsWith("-spacer")) continue;
+    // 文字を描かない種別は title が幅を超えて切れることが起きない。
+    if (!rendersTitleText(n.kind)) continue;
+    // 常に非表示の node の文字は画面に出ないので、 切れようがない。
+    if (!isRenderedNode(n)) continue;
+    const titleTrimmed = n.title?.trim() ?? "";
+    if (!titleTrimmed) continue;
+    // 日本語 1 文字 ~22px (kinds/storage.tsx の fontSize 22 を基準) 想定
+    // title 長 * 22 + padding 52 > node.w なら切れる
+    const titleLen = titleTrimmed.length;
+    const expectedW = titleLen * 22 + 52;
+    if (expectedW > n.w + 8) {
+      push(
+        "text-readability",
+        `node "${n.id}" title "${n.title}" が node 幅 ${n.w}px を超過する可能性 (期待 ${expectedW}px)`,
+        "warn",
+      );
+    }
+  }
+  // edge label の font size は collisions.ts で BBox 計算済、 ここでは MIN_FONT_SIZE 違反のみ check
+  // (実装では cdl が 12px 以下を render することはないので no-op、 将来拡張用)
+  void MIN_FONT_SIZE;
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 4: row-format (rows[] format + placeholder 解決)
+  //
+  // 例外行 ... divider (`─` のみで構成、 classDiagram preset で attributes と methods を区切る視覚要素)
+  //          / 区切りラベル目的の単一非 ASCII 行は format 判定対象外。
+  // ───────────────────────────────────────────────────────────
+  // 行を描かない種別の `rows` は画面に出ないので、 形式を要求しても意味がない。 書かれている
+  // こと自体が破綻なのは Axis 68 (`rows-not-rendered`) が別に見る。
+  const DIVIDER_ONLY = /^[─━—-]+$/;
+  const stateIds = new Set(diag.states.map((s) => s.id));
+  for (const n of diag.nodes) {
+    if (!n.rows) continue;
+    if (!rendersRows(n.kind)) continue;
+    if (!isRenderedNode(n)) continue;
+    for (const row of n.rows) {
+      if (DIVIDER_ONLY.test(row)) continue;
+      if (!ROW_FORMAT.test(row)) {
+        push("row-format", `node "${n.id}" row "${row}" が "key: value" 形式でない`);
+      }
+      let m: RegExpExecArray | null;
+      const re = new RegExp(PLACEHOLDER_RE);
+      while ((m = re.exec(row)) !== null) {
+        const id = m[1];
+        if (id && !stateIds.has(id)) {
+          push("row-format", `node "${n.id}" row "${row}" placeholder "{${id}}" が未定義 state`);
+        }
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 5: alignment (同 lane 内 node の cx 一致)
+  // ───────────────────────────────────────────────────────────
+  const byLane = new Map<string, typeof laid.nodes>();
+  for (const n of laid.nodes) {
+    const list = byLane.get(n.lane) ?? [];
+    list.push(n);
+    byLane.set(n.lane, list);
+  }
+  for (const [laneId, nodes] of byLane) {
+    if (nodes.length < 2) continue;
+    const cx0 = nodes[0]!.cx;
+    for (const n of nodes.slice(1)) {
+      if (Math.abs(n.cx - cx0) > 1) {
+        push(
+          "alignment",
+          `lane "${laneId}" 内 node "${n.id}" cx=${n.cx} が他 node cx=${cx0} と不一致`,
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 6: clearance (near collision 0 件、 CLEARANCE_POLICY 違反)
+  // ───────────────────────────────────────────────────────────
+  const nears = detectNearCollisions(bboxes, laid.edges);
+  for (const n of nears) {
+    push(
+      "clearance",
+      `${n.a.kind}:${n.a.id} ↔ ${n.b.kind}:${n.b.id} gap=${n.gap.toFixed(1)}px (need ${n.required}px)`,
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 7: edge-label-proximity (label が自分の線の近くにある)
+  //
+  // label が自分の線から離れすぎると「どの辺の label か」 が読み取れなくなる。
+  //
+  // 判定 = label pill の箱から、 実際に描かれる線までの最短距離。 3 点が要る。
+  //
+  // 1. **箱から測る** — 中心から測ると、 線に貼り付いた長い label ほど遠く出る。
+  //    実測 (dragon flow-demo) = 縦線の右に置いた 3 本の label は箱の左端が全て 44 world
+  //    (見た目の隙間は同一) なのに、 中心までは 110 / 134 / 159 と label の長さで開く。
+  //    同 file の `clearance` 軸は既に箱の 8 点から測っており、 本軸だけが中心だった。
+  // 2. **曲線を開く** — `extractPathSegments` は `Q` / `C` を弦に落とすが、 弦は描かれない。
+  //    膨らむ側にある label は実際より遠く、 へこむ側は近く出る (誤検知と見逃しの両方)。
+  // 3. **文字を描く辺だけ見る** — label も sub も空なら pill は描かれない。
+  //
+  // 閾値は箱で測ることを前提に定数で置く。 旧実装が持っていた補正項 (label 半 h / fontSize /
+  // node 干渉逃げ) は「中心から測る」 ための換算で、 箱で測れば要らない。 実測でも節の寸法と
+  // 箱までの距離は連動しない (節 426 の図でも 44 world)。
+  //
+  // warn は `DIST_LABEL_PATH_MAX` (見た目の隙間の上限として engine が持つ SSOT 定数、 80) を
+  // そのまま使う。 error はその 2 倍 = 旧実装の warn 80 : error 160 の比を保つ。
+  // ───────────────────────────────────────────────────────────
+  const PROXIMITY_WARN_THRESHOLD = DIST_LABEL_PATH_MAX;
+  const PROXIMITY_ERROR_THRESHOLD = DIST_LABEL_PATH_MAX * 2;
+  for (const e of laid.edges) {
+    if (!hasRenderedLabel(e)) continue;
+    const segs = extractPathSegments(e.d);
+    if (segs.length === 0) continue;
+    const minDist = measurePathLabelGapSegs(flattenPathSegments(segs), computeLabelBBoxWorld(e));
+    if (!Number.isFinite(minDist)) continue;
+    if (minDist > PROXIMITY_ERROR_THRESHOLD) {
+      push(
+        "edge-label-proximity",
+        `edge "${e.id}" label の箱が線から ${minDist.toFixed(0)}px 離れている (labelX=${e.labelX.toFixed(0)}, labelY=${e.labelY.toFixed(0)}、 error 閾値 ${PROXIMITY_ERROR_THRESHOLD}px)`,
+      );
+    } else if (minDist > PROXIMITY_WARN_THRESHOLD) {
+      push(
+        "edge-label-proximity",
+        `edge "${e.id}" label の箱が線から ${minDist.toFixed(0)}px 離れている (border、 label 位置調整推奨、 warn 閾値 ${PROXIMITY_WARN_THRESHOLD}px)`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 8: arrow-endpoint-anchoring (arrow の始点 / 終点が node bbox 縁と一致)
+  //
+  // 判定 = edge path の最初 / 最後 point が from / to node bbox の縁 (±4 world) にあるか。
+  // node 内側に沈み込む (endpoint が node bbox 中心方向にはみ出す) or 縁から遠すぎる (10 world 超)
+  // 場合は矢印がどこから出てるか視覚的に判別不能になる。
+  // ───────────────────────────────────────────────────────────
+  const nodeById = new Map<string, LaidDiagram["nodes"][number]>();
+  for (const n of laid.nodes) nodeById.set(n.id, n);
+  const ENDPOINT_ANCHOR_TOL = 4;
+  const ENDPOINT_FAR_LIMIT = 40;
+  for (const e of laid.edges) {
+    const segs = extractPathSegments(e.d);
+    if (segs.length === 0) continue;
+    const start = { x: segs[0]!.x1, y: segs[0]!.y1 };
+    const end = { x: segs[segs.length - 1]!.x2, y: segs[segs.length - 1]!.y2 };
+    for (const [side, pt] of [
+      ["from", start],
+      ["to", end],
+    ] as const) {
+      const nodeId = side === "from" ? e.from : e.to;
+      const node = nodeById.get(nodeId);
+      if (!node) continue;
+      const rect = { x: node.cx - node.w / 2, y: node.cy - node.h / 2, w: node.w, h: node.h };
+      const distToEdge = pointRectEdgeDistance(pt.x, pt.y, rect);
+      const inside =
+        pt.x > rect.x + ENDPOINT_ANCHOR_TOL &&
+        pt.x < rect.x + rect.w - ENDPOINT_ANCHOR_TOL &&
+        pt.y > rect.y + ENDPOINT_ANCHOR_TOL &&
+        pt.y < rect.y + rect.h - ENDPOINT_ANCHOR_TOL;
+      if (inside) {
+        push(
+          "arrow-endpoint-anchoring",
+          `edge "${e.id}" ${side} endpoint が node "${nodeId}" 内側に沈み込み (pt=${pt.x.toFixed(0)},${pt.y.toFixed(0)}、 node bbox=${rect.x.toFixed(0)},${rect.y.toFixed(0)}+${rect.w.toFixed(0)}x${rect.h.toFixed(0)})`,
+        );
+      } else if (distToEdge > ENDPOINT_FAR_LIMIT) {
+        push(
+          "arrow-endpoint-anchoring",
+          `edge "${e.id}" ${side} endpoint が node "${nodeId}" 縁から ${distToEdge.toFixed(0)} world 離れている (許容 ${ENDPOINT_FAR_LIMIT} world)`,
+          "warn",
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 9: label-char-range (edge label bbox が label text 実占有領域を最小限含む)
+  //
+  // 判定 = engine 予測 label bbox の width が measureTextWidth 実測値 + padding より
+  // 極端に狭い場合、 実 render 時に text が bbox からはみ出す (rect stroke 内に文字が入らない)。
+  // engine boxW = max(mainW, subW) + 36 で 4 world tolerance を許容、 未満なら error。
+  // ───────────────────────────────────────────────────────────
+  for (const e of laid.edges) {
+    if (!hasRenderedLabel(e)) continue;
+    const mainW = measureTextWidth(e.label ?? "", { fontSize: EDGE_LABEL_TEXT.main.fontSize });
+    const subW = e.sub
+      ? measureTextWidth(e.sub, { fontSize: EDGE_LABEL_TEXT.sub.fontSize, fontFamily: "mono" })
+      : 0;
+    const expectedBoxW = Math.max(mainW, subW) + LABEL_PILL_PAD_X * 2;
+    const bbox = bboxes.find((b) => b.kind === "edge-label" && b.id === e.id);
+    if (!bbox) continue;
+    if (bbox.w + 4 < expectedBoxW) {
+      push(
+        "label-char-range",
+        `edge "${e.id}" label bbox width ${bbox.w.toFixed(0)} が実測 char range ${expectedBoxW.toFixed(0)} world より狭い (text 溢れ)`,
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 10: node-overlap (node bbox 同士の重なり + z-order 崩壊)
+  //
+  // 判定 = 2 node bbox が overlap 面積 > 0 で検知。 node は装飾線 (lifeline w<8) を除き
+  // 論理的に重ならないべき (視覚的に混同する)。 spacer / marker (id endsWith "-spacer" or
+  // /^s\d+-/) は判定対象外。
+  // ───────────────────────────────────────────────────────────
+  const nodeList = laid.nodes.filter(
+    (n) => n.w >= 8 && !n.id.endsWith("-spacer") && !/^s\d+-/.test(n.id),
+  );
+  for (let i = 0; i < nodeList.length; i++) {
+    const a = nodeList[i]!;
+    const aRect = { x: a.cx - a.w / 2, y: a.cy - a.h / 2, w: a.w, h: a.h };
+    for (let j = i + 1; j < nodeList.length; j++) {
+      const b = nodeList[j]!;
+      const bRect = { x: b.cx - b.w / 2, y: b.cy - b.h / 2, w: b.w, h: b.h };
+      const overlap = rectRectOverlapArea(aRect, bRect);
+      if (overlap > 0) {
+        push(
+          "node-overlap",
+          `node "${a.id}" ↔ "${b.id}" が overlap 面積 ${overlap.toFixed(0)} world² で重なり (a=${a.cx.toFixed(0)},${a.cy.toFixed(0)} b=${b.cx.toFixed(0)},${b.cy.toFixed(0)})`,
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 11: edge-crossing (edge path 間の交差数、 単一 diagram 内で多すぎると読解性低下)
+  //
+  // 判定 = 全 edge pair について path segments 間の line-line intersection を数え、
+  // diagram あたり 3 件超で warn (視覚的に読みにくい)。 単純な交差 1-2 件は避けられない場合が
+  // 多いので許容、 4 件以上を warn 対象。
+  // ───────────────────────────────────────────────────────────
+  // catalog 114 diagram 実測分布 = nonzero 4 件 / max 2 crossings / p95=2 (PR #80 計測)。
+  // 現状 4 件超は dead threshold (実際に発火しない)、 3 件以上で warn 化して実効性を回復。
+  //
+  // 実際に描かれる曲線で交差を数える (#385)。 実装は `countEdgeCrossings` (計算量を直接測れる
+  // ように切り出してある)。
+  const CROSSING_WARN = 3;
+  const {
+    count: crossingCount,
+    pairs: crossingPairs,
+    complete: crossingComplete,
+  } = countEdgeCrossings(laid.edges, CROSSING_WARN);
+  if (!crossingComplete && crossingCount < CROSSING_WARN) {
+    // 数え切れなかったことを黙って「交差なし」 にしない。 上限で止めた図は、 実際には交差が
+    // あっても警告が出ない。
+    push(
+      "edge-crossing",
+      `diagram edge 交差の走査が比較回数の上限で打ち切られた (数えた分 ${crossingCount} 件、 実際はこれより多い可能性がある)`,
+      "warn",
+    );
+  }
+  if (crossingCount >= CROSSING_WARN) {
+    push(
+      "edge-crossing",
+      `diagram edge 交差 ${crossingCount} 件 (pairs: ${crossingPairs.slice(0, 5).join(", ")}${crossingPairs.length > 5 ? " 他" : ""})、 CROSSING_WARN=${CROSSING_WARN}`,
+      "warn",
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 12: edge-node-cross (edge path が「関係ない node」 の bbox を貫通)
+  //
+  // 判定 = edge の from / to 以外の node bbox を edge path segment が横切ると誤読を起こす
+  // (edge の中継点として誤解される)。 lifeline / spacer は除外。
+  //
+  // 曲線は `flattenPathSegments` で開く。 弦のままだと、 弦が節を外れて実際の弧だけが節に入る
+  // 形を見逃す (#383 実測 = 節 618..938 / 128..278 に対し `M 350 60 Q 778 438, 1206 60` は
+  // 頂点 y=249 が節の中を通るのに 0 件)。 本軸は `error` で見本一括検査が止める対象のため、
+  // 見逃しはそのまま「見えない破綻が通る」 になる。
+  // ───────────────────────────────────────────────────────────
+  for (const e of laid.edges) {
+    const segs = flattenPathSegments(extractPathSegments(e.d));
+    if (segs.length === 0) continue;
+    for (const n of nodeList) {
+      if (n.id === e.from || n.id === e.to) continue;
+      const rect = { x: n.cx - n.w / 2, y: n.cy - n.h / 2, w: n.w, h: n.h };
+      if (segmentsCrossRect(segs, rect)) {
+        push(
+          "edge-node-cross",
+          `edge "${e.id}" (from=${e.from} to=${e.to}) が関係ない node "${n.id}" を貫通`,
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 13: edge-segment-orthogonality (L 字 routing segment の水平 / 垂直度)
+  //
+  // 判定 = 各 segment の傾き角度 (degrees) を計算、 水平 / 垂直 / 45° 対角以外の
+  // 中途半端な傾き (5-40° / 50-85° / 95-130° / 140-175°) は L 字破綻の可能性。
+  // ただし bezier ("C" / "Q") / 短い segment (<20 world) は除外。 warn only。
+  // ───────────────────────────────────────────────────────────
+  for (const e of laid.edges) {
+    // bezier ("C" 三次 / "Q" 二次) を含む path は曲線制御点で角度が非直交になるのが intentional、
+    // Axis 13 の判定対象外 (前 comment には書いてあったが実装 chek 抜けの bug、 PR #80 で修正)。
+    if (/[CcQq]/.test(e.d)) continue;
+    const segs = extractPathSegments(e.d);
+    for (const s of segs) {
+      const len = Math.hypot(s.x2 - s.x1, s.y2 - s.y1);
+      if (len < 20) continue;
+      const angle = Math.abs((Math.atan2(s.y2 - s.y1, s.x2 - s.x1) * 180) / Math.PI);
+      // 0° / 90° / 180° に近い (±5°) or 45° / 135° に近い (±3°) は許容
+      const near = (target: number, tol: number) => Math.abs(angle - target) < tol;
+      const orthogonal = near(0, 5) || near(90, 5) || near(180, 5);
+      const diagonal = near(45, 3) || near(135, 3);
+      if (!orthogonal && !diagonal) {
+        push(
+          "edge-segment-orthogonality",
+          `edge "${e.id}" segment 角度 ${angle.toFixed(1)}° (0/45/90/135/180 のいずれにも近くない、 L 字破綻の可能性)`,
+          "warn",
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 14: label-inside-viewbox (label bbox が diagram viewBox 内に収まる)
+  //
+  // 判定 = viewBox 外に label が飛ぶと clip されて視覚破綻。 label bbox の
+  // いずれかの辺が viewBox 外なら error。
+  // ───────────────────────────────────────────────────────────
+  const vb = laid.viewBox;
+  for (const b of bboxes) {
+    if (b.kind !== "edge-label") continue;
+    if (b.x < vb.x || b.y < vb.y || b.x + b.w > vb.x + vb.w || b.y + b.h > vb.y + vb.h) {
+      push(
+        "label-inside-viewbox",
+        `edge-label "${b.id}" bbox (${b.x.toFixed(0)},${b.y.toFixed(0)} ${b.w.toFixed(0)}x${b.h.toFixed(0)}) が viewBox (${vb.x.toFixed(0)},${vb.y.toFixed(0)} ${vb.w.toFixed(0)}x${vb.h.toFixed(0)}) から食み出し`,
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 53: node-inside-viewbox (node bbox が diagram viewBox 内に収まる、 Axis 14 の node 版)
+  //
+  // 判定 = viewBox 外に node bbox が飛ぶと clip されて視覚破綻。 node bbox (cx±w/2, cy±h/2) の
+  // いずれかの辺が viewBox 外なら error。 Axis 14 は edge-label 対象、 本 axis は node 対象で棲み分け。
+  // spacer node (id endsWith "-spacer" or /^s\d+-/) は layout 補助用の非表示 node なので判定対象外。
+  // ───────────────────────────────────────────────────────────
+  for (const n of laid.nodes) {
+    if (n.id.endsWith("-spacer") || /^s\d+-/.test(n.id)) continue;
+    const nodeLeft = n.cx - n.w / 2;
+    const nodeTop = n.cy - n.h / 2;
+    const nodeRight = n.cx + n.w / 2;
+    const nodeBottom = n.cy + n.h / 2;
+    if (nodeLeft < vb.x || nodeTop < vb.y || nodeRight > vb.x + vb.w || nodeBottom > vb.y + vb.h) {
+      const overflows = [];
+      if (nodeLeft < vb.x) overflows.push(`left ${(vb.x - nodeLeft).toFixed(0)}px`);
+      if (nodeTop < vb.y) overflows.push(`top ${(vb.y - nodeTop).toFixed(0)}px`);
+      if (nodeRight > vb.x + vb.w)
+        overflows.push(`right ${(nodeRight - vb.x - vb.w).toFixed(0)}px`);
+      if (nodeBottom > vb.y + vb.h)
+        overflows.push(`bottom ${(nodeBottom - vb.y - vb.h).toFixed(0)}px`);
+      push(
+        "node-inside-viewbox",
+        `node "${n.id}" bbox (${nodeLeft.toFixed(0)},${nodeTop.toFixed(0)} ${n.w.toFixed(0)}x${n.h.toFixed(0)}) が viewBox (${vb.x.toFixed(0)},${vb.y.toFixed(0)} ${vb.w.toFixed(0)}x${vb.h.toFixed(0)}) から食み出し (${overflows.join(" / ")})`,
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 54: node-inside-lane (contain / lifeline lane の内側に node bbox が収まる)
+  //
+  // 判定 = contain: true or lifeline: true な lane は「node を包含する」 期待 (boundary 描画あり)
+  // なので、 node 4 辺が lane 4 辺の内側に収まっている必要がある。 default lane は header
+  // 領域のみ height を持つ (SPEC 5 プリミティブ)、 これは node 内包の判定対象外。
+  // Axis 15 (lane-cx-consistency) は中心 x のみ、 本 axis は 4 辺の包含関係を contain lane 限定で見る。
+  // ───────────────────────────────────────────────────────────
+  const laneByIdForInside = new Map<string, LaidDiagram["lanes"][number]>();
+  for (const l of laid.lanes) laneByIdForInside.set(l.id, l);
+  for (const n of laid.nodes) {
+    if (n.id.endsWith("-spacer") || /^s\d+-/.test(n.id)) continue;
+    if (!n.lane) continue;
+    const lane = laneByIdForInside.get(n.lane);
+    if (!lane) continue;
+    // contain / lifeline lane のみ対象、 default lane は header 領域のみで node 内包対象外
+    if (!lane.contain && !lane.lifeline) continue;
+    const nodeLeft = n.cx - n.w / 2;
+    const nodeTop = n.cy - n.h / 2;
+    const nodeRight = n.cx + n.w / 2;
+    const nodeBottom = n.cy + n.h / 2;
+    const laneRight = lane.x + lane.width;
+    const laneBottom = lane.y + lane.height;
+    if (nodeLeft < lane.x || nodeRight > laneRight || nodeTop < lane.y || nodeBottom > laneBottom) {
+      const overflows = [];
+      if (nodeLeft < lane.x) overflows.push(`left ${(lane.x - nodeLeft).toFixed(0)}px`);
+      if (nodeRight > laneRight) overflows.push(`right ${(nodeRight - laneRight).toFixed(0)}px`);
+      if (nodeTop < lane.y) overflows.push(`top ${(lane.y - nodeTop).toFixed(0)}px`);
+      if (nodeBottom > laneBottom)
+        overflows.push(`bottom ${(nodeBottom - laneBottom).toFixed(0)}px`);
+      push(
+        "node-inside-lane",
+        `node "${n.id}" bbox (${nodeLeft.toFixed(0)},${nodeTop.toFixed(0)} ${n.w.toFixed(0)}x${n.h.toFixed(0)}) が ${lane.contain ? "contain" : "lifeline"} lane "${lane.id}" bbox (${lane.x.toFixed(0)},${lane.y.toFixed(0)} ${lane.width.toFixed(0)}x${lane.height.toFixed(0)}) から食み出し (${overflows.join(" / ")})`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 55: edge-inside-viewbox (edge path 全 segment 端点が viewBox 内に収まる)
+  //
+  // 判定 = edge の SVG path を segment 化し、 全端点 (x1,y1) / (x2,y2) が viewBox 内に
+  // 収まっているか。 Axis 14 (label-inside-viewbox) は edge-label のみ、 Axis 53
+  // (node-inside-viewbox) は node のみ対象、 本 axis は path 幾何学的 clip 検知。
+  //
+  // 端点だけを見れば足りるのは直線の時だけで、 これは viewBox が矩形 = 凸だから成り立つ
+  // (両端が中にあれば線分は丸ごと中)。 曲線は凸性が効かないので `flattenPathSegments` で開く。
+  // 弦のままだと、 両端が中にあって弧だけが外へ出る形を見逃す (#383 実測 = viewBox 上端 -34 に
+  // 対し `M 350 60 Q 778 -2034, 1206 60` は頂点 y=-987 が 953 world 外へ出るのに 0 件)。
+  //
+  // 診断は「最初に見つけた 3 件の座標」 ではなく「最も外へ出た 1 点とその量」 を出す。 曲線を
+  // 開くと 1 本の弧が 16 の分割片になり、 先頭 3 件は弧の入口付近に固まって、 どこがどれだけ
+  // 外へ出たのかが読めなくなる。
+  // ───────────────────────────────────────────────────────────
+  for (const e of laid.edges) {
+    const segs = flattenPathSegments(extractPathSegments(e.d));
+    if (segs.length === 0) continue;
+    /** viewBox の外へどれだけ出たか。 中なら 0。 */
+    const outBy = (x: number, y: number): number =>
+      Math.max(vb.x - x, 0, x - (vb.x + vb.w), vb.y - y, 0, y - (vb.y + vb.h));
+    let worst = 0;
+    let worstAt = "";
+    let outCount = 0;
+    for (const s of segs) {
+      for (const p of [
+        { x: s.x1, y: s.y1 },
+        { x: s.x2, y: s.y2 },
+      ]) {
+        const over = outBy(p.x, p.y);
+        if (over <= 0) continue;
+        outCount += 1;
+        if (over > worst) {
+          worst = over;
+          worstAt = `(${p.x.toFixed(0)},${p.y.toFixed(0)})`;
+        }
+      }
+    }
+    if (outCount > 0) {
+      push(
+        "edge-inside-viewbox",
+        `edge "${e.id}" が viewBox (${vb.x.toFixed(0)},${vb.y.toFixed(0)} ${vb.w.toFixed(0)}x${vb.h.toFixed(0)}) の外へ出る : 最も外は ${worstAt} で ${worst.toFixed(0)} world`,
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 56: lane-label-inside-viewbox (lane label bbox が viewBox 内に収まる)
+  //
+  // 判定 = lane 上部に描画される label が viewBox 外に飛ぶと clip、 lane 識別不能。
+  // Axis 14 (label-inside-viewbox) は edge-label のみ、 本 axis は lane-label 対象で棲み分け。
+  // ───────────────────────────────────────────────────────────
+  for (const b of bboxes) {
+    if (b.kind !== "lane-label") continue;
+    if (b.x < vb.x || b.y < vb.y || b.x + b.w > vb.x + vb.w || b.y + b.h > vb.y + vb.h) {
+      push(
+        "lane-label-inside-viewbox",
+        `lane-label "${b.id}" bbox (${b.x.toFixed(0)},${b.y.toFixed(0)} ${b.w.toFixed(0)}x${b.h.toFixed(0)}) が viewBox (${vb.x.toFixed(0)},${vb.y.toFixed(0)} ${vb.w.toFixed(0)}x${vb.h.toFixed(0)}) から食み出し`,
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 67: lane-label-overlap (帯の名前同士が重なる / 近すぎる)
+  //
+  // 判定 = 帯の名前 (`lane.label`) の bbox が別の帯の名前の bbox と重なる、 または
+  // 水平方向の間隔が CLEARANCE_LANE_LABEL (24 world) を下回る。
+  //
+  // 名前は `lane.contain` の有無に関わらず常に描かれる (`render/stage.tsx`)。 一方で
+  // 重なるかどうかは **名前の文字幅** で決まり、 帯の間隔とは独立している。 帯を 200 world
+  // 離しても、 名前が 300 world 分の長さなら隣の名前に食い込む。
+  //
+  // 経緯 = 帯の間隔を見る axis 19 (lane-lane-gap) が「間隔 40 world 未満」 を警告することで
+  // 偶然この一部を拾っていたが、 axis 19 は #353 で枠が描かれる帯の対に絞った。 そもそも
+  // axis 19 は名前の検出器ではない (間隔が広くて名前が長い組合せは以前から素通りしていた)。
+  // 名前の重なりは文字幅で判定する本 axis の担当とする。
+  //
+  // 縦の重なりを先に確かめてから横の間隔を見る。 帯を横に並べる図では名前が全て上端に
+  // 同じ高さで描かれるので縦は必ず重なるが、 `lane.posY` で座標を固定した図では帯が縦に
+  // ずれ、 名前も縦に離れる。 横だけで判定すると、 上下に離れて置いた名前を「重なっている」
+  // と誤判定する。
+  //
+  // 対は隣接だけでなく総当たりで見る。 縦に離れた名前を挟むと、 x 昇順の隣接では
+  // 「間に別の名前がある」 ように見えて実際に重なっている対を取り逃がす。 帯の本数は
+  // 図あたり数本なので総当たりで問題ない (見本 512 図の最大が 7 本)。
+  // ───────────────────────────────────────────────────────────
+  {
+    const laneLabels = bboxes.filter((b) => b.kind === "lane-label").sort((a, b) => a.x - b.x);
+    for (let i = 0; i < laneLabels.length; i++) {
+      for (let j = i + 1; j < laneLabels.length; j++) {
+        const left = laneLabels[i]!;
+        const right = laneLabels[j]!;
+        const vOverlap = Math.min(left.y + left.h, right.y + right.h) - Math.max(left.y, right.y);
+        if (vOverlap <= 0) continue;
+        const gap = right.x - (left.x + left.w);
+        if (gap >= CLEARANCE_LANE_LABEL) continue;
+        push(
+          "lane-label-overlap",
+          gap < 0
+            ? `lane-label "${left.id}" と "${right.id}" が ${(-gap).toFixed(0)} world 重なっている`
+            : `lane-label "${left.id}" と "${right.id}" の水平 gap ${gap.toFixed(0)} world が ${CLEARANCE_LANE_LABEL} 未満`,
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 57: row-alignment (CAR-421 positive-check)
+  //
+  // 判定 = 同 stack index を持つ横並び node 群 (= 同 row) の cy が
+  // MIN_ROW_ALIGNMENT_TOLERANCE 以内で揃っているか。
+  //
+  // 同 row 定義 = 同 stack index を持つ node 群 (lane が異なっても、 layout engine が
+  // 同一 stack index で cy を揃える設計)。 spacer / lifeline (id 末尾 -spacer or ^s\d+-)
+  // は intentional な cy 差を持つので判定対象外。
+  //
+  // 発火 0 = 正常状態、 発火 = engine が row cy を揃え損ねている症状 (regression 検知)。
+  // ───────────────────────────────────────────────────────────
+  {
+    const byStack = new Map<number, LaidDiagram["nodes"]>();
+    for (const n of laid.nodes) {
+      if (n.id.endsWith("-spacer") || /^s\d+-/.test(n.id)) continue;
+      const list = byStack.get(n.stack) ?? [];
+      list.push(n);
+      byStack.set(n.stack, list);
+    }
+    for (const [stack, group] of byStack) {
+      if (group.length < 2) continue;
+      const cy0 = group[0]!.cy;
+      for (const n of group.slice(1)) {
+        const diff = Math.abs(n.cy - cy0);
+        if (diff > MIN_ROW_ALIGNMENT_TOLERANCE) {
+          push(
+            "row-alignment",
+            `stack=${stack} row 内 node "${n.id}" cy=${n.cy.toFixed(1)} が row 基準 cy=${cy0.toFixed(1)} と ${diff.toFixed(1)} world 差 (許容 ${MIN_ROW_ALIGNMENT_TOLERANCE})`,
+          );
+        }
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 58: column-alignment (CAR-421 positive-check)
+  //
+  // 判定 = 同 lane 内で縦積みされた node 群 (= 同 column) の cx が
+  // MIN_COLUMN_ALIGNMENT_TOLERANCE 以内で揃っているか。
+  //
+  // Axis 5 (alignment) は同 lane 内 node の相対的 cx 一致を見るが、 本 axis は
+  // spec.ts SSOT (MIN_COLUMN_ALIGNMENT_TOLERANCE = 1 world) の厳格 tolerance で判定。
+  // Axis 5 は tolerance 1 で hard error、 本 axis は tolerance を SSOT 値と同期する
+  // positive-check 経路 (両者 同 tolerance を持つが、 SSOT 経由で spec-driven 判定にする)。
+  //
+  // spacer / lifeline は intentional な cx 差を持つので判定対象外。
+  // ───────────────────────────────────────────────────────────
+  {
+    const byLaneCol = new Map<string, LaidDiagram["nodes"]>();
+    for (const n of laid.nodes) {
+      if (n.id.endsWith("-spacer") || /^s\d+-/.test(n.id)) continue;
+      const list = byLaneCol.get(n.lane) ?? [];
+      list.push(n);
+      byLaneCol.set(n.lane, list);
+    }
+    for (const [laneId, group] of byLaneCol) {
+      if (group.length < 2) continue;
+      const cx0 = group[0]!.cx;
+      for (const n of group.slice(1)) {
+        const diff = Math.abs(n.cx - cx0);
+        if (diff > MIN_COLUMN_ALIGNMENT_TOLERANCE) {
+          push(
+            "column-alignment",
+            `lane "${laneId}" column 内 node "${n.id}" cx=${n.cx.toFixed(1)} が column 基準 cx=${cx0.toFixed(1)} と ${diff.toFixed(1)} world 差 (許容 ${MIN_COLUMN_ALIGNMENT_TOLERANCE})`,
+          );
+        }
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 59 (edge-label-clearance) は #386 で畳んだ。
+  //
+  // 「label pill の 4 隅から自分の線までの距離」 を測っていたが、 **測る量が見える破綻と
+  // 結びついていなかった**。 幅 438 の pill の中心を縦に貫く線で 4 隅からの距離は 219 world に
+  // なり、 pill の中を線が通っているのに「219 離れている」 と読む。
+  //
+  // 測り方を変える候補を 3 つ試し、 見本 412 図でいずれも発火 0 だった (実測)。
+  //
+  // - 面として測る (pill の中を通るのを異常とする) → 53 本が該当するが全て正常な中置き label
+  // - 角の近くを通る場合だけ見る → 0 件
+  // - pill の外に出た部分だけ見る → 中置き label は境界に接するので 0 になり異常にならない
+  //
+  // 「label と線が近すぎる」 が異常になる形を定義できない。 中置き label は線の上に載るのが
+  // 普通の配置で、 pill が背景を塗って線を隠す。
+  //
+  // 同じ量 (箱と実際に描かれる線の距離) は軸 7 `edge-label-proximity` が測っており、 そちらは
+  // **離れすぎ** を見る。 近すぎ側に異常が無い以上、 軸を分ける理由が無い。
+  //
+  // pill が完全な不透明でない点 (`render/edges.tsx` の `opacity=0.92` で背後の線が 8% 残る) は
+  // 描画の設定の話で、 幾何の検査では捉えられない。
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 60: edge-stubout-min (CAR-421 positive-check)
+  //
+  // 判定 = 各 edge の起点から、 進行が起点 side の軸方向に進み続ける距離が
+  // EDGE_STUB_OUT world 以上あるか (水平 or 垂直方向どちらでも判定 OK)。
+  //
+  // 起点即折れ (起点 stub < EDGE_STUB_OUT) は「起点がどの node 由来か視覚判別困難」
+  // 症状。 本 axis で「起点 stub が spec 満たすか」 を positive-check する。
+  //
+  // corner の弧を含めて測る (Issue #202)。 engine は `L exitX - corner` → `Q exitX ...` で
+  // 曲がり、 exitX = 起点 + EDGE_STUB_OUT に到達する (edges.ts の CAR-472 SSOT)。
+  // 直線部分は corner 半径 (14) だけ短くなるため、 第 1 segment 長だけを見ると
+  // 26 world と読めて誤検知する (catalog 実測 = fsm-demo / sm2-demo / 認証-fsm-dsl の 3 件)。
+  //
+  // 例外 = 直線 edge (segments.length === 1) は起点 stub 概念不在、 判定対象外。
+  //        極短 edge (from-to 距離自体が短く stub 長さも短い場合) は自然な結果、 warn 化。
+  // ───────────────────────────────────────────────────────────
+  {
+    for (const e of laid.edges) {
+      const segs = extractPathSegments(e.d);
+      // 単一 segment = 直線、 stub 概念なし
+      if (segs.length <= 1) continue;
+      const stubLen = measureStubOut(segs);
+      if (stubLen < EDGE_STUB_OUT) {
+        // from-to 距離自体が短い場合は自然な結果、 warn に降格
+        const fromNode = nodeById.get(e.from);
+        const toNode = nodeById.get(e.to);
+        const nodeDist =
+          fromNode && toNode
+            ? Math.hypot(toNode.cx - fromNode.cx, toNode.cy - fromNode.cy)
+            : Infinity;
+        const severity = nodeDist < EDGE_STUB_OUT * 3 ? "warn" : "error";
+        push(
+          "edge-stubout-min",
+          `edge "${e.id}" 起点 stub 長 ${stubLen.toFixed(1)} world が spec ${EDGE_STUB_OUT} 未満 (from-to 距離 ${nodeDist === Infinity ? "?" : nodeDist.toFixed(0)})`,
+          severity,
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 61: fan-origin-single-point (CAR-421 positive-check)
+  //
+  // 判定 = 同一 node から出る (from が同 node の) 複数 edge の 起点 (path 第 1 point) の
+  // Y 座標が全て一致 (±0.5 world) しているか。
+  //
+  // fan-out で engine が起点 Y を Y offset で分散すると、 「1 node から複数線が発散する」
+  // 視覚が「異なる node から出ているように見える」 現象になる。 起点は 1 point に
+  // 収束し、 分岐は起点直後で発生するのが正しい fan 表現。
+  //
+  // 発火 0 = 正常状態、 発火 = fan-out engine が起点 Y を offset している (regression 検知)。
+  // ───────────────────────────────────────────────────────────
+  {
+    const byFrom = new Map<
+      string,
+      Array<{ e: LaidDiagram["edges"][number]; startX: number; startY: number }>
+    >();
+    for (const e of laid.edges) {
+      const segs = extractPathSegments(e.d);
+      if (segs.length === 0) continue;
+      const list = byFrom.get(e.from) ?? [];
+      list.push({ e, startX: segs[0]!.x1, startY: segs[0]!.y1 });
+      byFrom.set(e.from, list);
+    }
+    for (const [fromId, group] of byFrom) {
+      if (group.length < 2) continue;
+      // 例外 = 同 node から異なる side (top/bottom/left/right) に出る fan は起点 Y が異なるのが正しい、
+      //       side が同一な edge のみ判定対象にする。 horizontal side (left/right) = 起点 Y 一致、
+      //       vertical side (top/bottom) = 起点 X 一致で判定軸を切り替える。
+      const bySide = new Map<string, typeof group>();
+      for (const g of group) {
+        const list = bySide.get(g.e.fromSide) ?? [];
+        list.push(g);
+        bySide.set(g.e.fromSide, list);
+      }
+      for (const [side, sameSide] of bySide) {
+        if (sameSide.length < 2) continue;
+        const ref = sameSide[0]!;
+        const isHorizontalSide = side === "left" || side === "right";
+        for (const g of sameSide.slice(1)) {
+          const refVal = isHorizontalSide ? ref.startY : ref.startX;
+          const gVal = isHorizontalSide ? g.startY : g.startX;
+          const diff = Math.abs(gVal - refVal);
+          if (diff > 0.5) {
+            const axisName = isHorizontalSide ? "Y" : "X";
+            push(
+              "fan-origin-single-point",
+              `node "${fromId}" side=${side} 起点 ${axisName} が edge "${g.e.id}" (${gVal.toFixed(1)}) と "${ref.e.id}" (${refVal.toFixed(1)}) で ${diff.toFixed(1)} world 差 (fan 起点は同点収束が正しい)`,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 15: lane-cx-consistency (lane 内 node の cx が lane 中心と一致)
+  //
+  // 判定 = lane 中心 (lane.x + lane.width/2) と node.cx の差が 2 world 以上あれば
+  // 「同 lane 内 node が水平 stack から外れている」 症状の可能性。 Axis 5 (alignment) は
+  // 同 lane 内 node 同士の cx 一致 (相対) を見るが、 本 axis は lane 中心との絶対整合を見る。
+  // ───────────────────────────────────────────────────────────
+  const laneById = new Map<string, LaidDiagram["lanes"][number]>();
+  for (const l of laid.lanes) laneById.set(l.id, l);
+  for (const n of laid.nodes) {
+    if (n.id.endsWith("-spacer") || /^s\d+-/.test(n.id)) continue;
+    // 座標を明示した node は lane 中心から外れているのが指定どおりの状態なので対象外。
+    // 「lane 中心と一致しない」 を症状として報告すると、 意図した配置が毎回 warn になる。
+    if (n.posX !== undefined && n.posY !== undefined) continue;
+    const lane = laneById.get(n.lane);
+    if (!lane) continue;
+    const laneCx = lane.x + lane.width / 2;
+    if (Math.abs(n.cx - laneCx) > 2) {
+      push(
+        "lane-cx-consistency",
+        `node "${n.id}" cx=${n.cx.toFixed(0)} が lane "${n.lane}" 中心 cx=${laneCx.toFixed(0)} と ${Math.abs(n.cx - laneCx).toFixed(0)} world 不一致`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 16: row-vertical-spacing (rows の最終行が node の枠内に収まる)
+  //
+  // 判定 = 行を描く種別で、 最終行の baseline が node の下端を越えていないか。 越えると
+  // 最後の行が枠の外に出て読めない。
+  //
+  // 行の縦位置は `rowBaselineY` (`layout/spec.ts`) が SSOT で、 描画側の式をそのまま持つ。
+  // 群ごとに違う (`storage` は `130 + i * 56`、 `GenericNode` に回る 21 種は `100 + i * 28`)
+  // ので、 1 つの式で全種別を測ることはできない。 旧実装は `100 + 行数 * 40` という、 どちらの
+  // 描画とも一致しない式で全種別を測っていた (#387)。
+  //
+  // `storage` は `layout/nodes.ts` の `autoStorageHeight` が行数から h を伸ばすので、 著者が
+  // h を明示した時だけ不足しうる。 `GenericNode` 側は h を自動で伸ばさないため、 行数が増えると
+  // そのまま枠外に出る。
+  // ───────────────────────────────────────────────────────────
+  for (const n of laid.nodes) {
+    if (!n.rows || n.rows.length === 0) continue;
+    if (!rendersRows(n.kind)) continue;
+    if (!isRenderedNode(n)) continue;
+    const lastBaseline = rowBaselineY(n.kind, n.rows.length - 1);
+    if (lastBaseline === null) continue;
+    // baseline は文字の下端ではない。 字形が下へ伸びるので、 baseline が枠の内側にある
+    // だけでは文字が枠線に重なる。 閾値は字形の深さの **見込み** (`rowGlyphDepth`) で、
+    // レイアウトが確保する余白 (`ROW_LAYOUT_BOTTOM_PAD` = 20) より小さい。 後者を閾値に使うと、
+    // 実際には文字が収まっている高さまで警告する。
+    //
+    // 見込みが押さえるのは preset が行に出す文字の範囲まで。 著者が結合文字などを直接書くと
+    // 仮定の外に出る。 文字列ごとの実寸は layout 出力からは取れず、 実 DOM を読む経路も
+    // 現状は行の文字を見ていないため、 その場合の枠外描画は **どこでも検査していない** (#390)。
+    const glyphDepth = rowGlyphDepth(n.kind) ?? 0;
+    const needed = lastBaseline + glyphDepth;
+    if (needed > n.h) {
+      push(
+        "row-vertical-spacing",
+        `node "${n.id}" (kind=${n.kind}) の ${n.rows.length} 行目 baseline y=${lastBaseline} + 字形の深さ ${glyphDepth} が node 高さ ${n.h} を ${(needed - n.h).toFixed(0)} world 越え、 文字が枠外に出る`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 68: rows-not-rendered (行を描かない種別に rows が書かれている)
+  //
+  // 判定 = `rendersRows` が偽の種別に `rows` が 1 行以上あるか。 書いた内容が画面に出ないまま
+  // 消えるので、 著者は書いたつもりでいる。
+  //
+  // Axis 4 (`row-format`) / Axis 16 (`row-vertical-spacing`) が描く種別だけを見るのと対になる。
+  // 「描かない種別に対して行の検査をしない」 だけだと、 消えていること自体を誰も見なくなる。
+  // ───────────────────────────────────────────────────────────
+  for (const n of diag.nodes) {
+    if (!n.rows || n.rows.length === 0) continue;
+    if (rendersRows(n.kind)) continue;
+    // 常時非表示の node は対象外。 本軸が扱うのは「書いた行が表示される機会を失う」 形で、
+    // 常時非表示の node の行にはそもそも表示される局面が無い。 行が出ない原因が種別ではなく
+    // node ごと出ないことにある以上、 本軸の内容消失には当たらない。
+    //
+    // かつ「固定の偽で隠す」 は意図的な書き方として実在する (見本 412 図に 17 件。 parts の
+    // 例が `w: 1, h: 1, visibleIf: "0"` の anchor node を配置の足場に使う)。
+    //
+    // なお非表示 node も layout の対象で、 `rows` は自動幅に効く (実測 320 → 670)。 行が
+    // 何の影響も持たないわけではない。
+    if (!isRenderedNode(n)) continue;
+    push(
+      "rows-not-rendered",
+      `node "${n.id}" (kind=${n.kind ?? "未指定"}) が rows ${n.rows.length} 行を持つが、 この種別は行を描かない (書いた内容が画面に出ない)`,
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 17: group-boundary-clearance (topology group の boundary padding + 外部 clearance)
+  //
+  // 判定 = lane.contain=true の lane 境界と内部 node の padding が 24 world 未満、
+  // または外部 node との clearance が 16 world 未満なら group boundary が乱れる。
+  // ───────────────────────────────────────────────────────────
+  // Axis 17 の閾値実測 tune。 patterns 系 (pattern-passthrough / pattern-branch / pattern-fan-in) の
+  // contain=true lane は実測 padding 20 world で intentional な密着 design を採用しているため、
+  // 閾値を 24 → 20 world に緩め、 実効に「明確な破綻」 のみ warn 化。
+  const GROUP_INTERNAL_PAD = 20;
+  const GROUP_EXTERNAL_CLEAR = 16;
+  for (const lane of laid.lanes) {
+    // contain: true (topology group / infrastructure zone) のみ boundary 検査対象、
+    // 通常の swim lane / flow lane は lane.height が動的で node と一致しない設計のため対象外。
+    if (!lane.contain) continue;
+    const contained = laid.nodes.filter((n) => n.lane === lane.id);
+    if (contained.length === 0) continue;
+    // 内部 padding = lane 境界と内部 node の最短距離、 GROUP_INTERNAL_PAD 未満で warn
+    for (const n of contained) {
+      const nodeLeft = n.cx - n.w / 2;
+      const nodeTop = n.cy - n.h / 2;
+      const nodeRight = n.cx + n.w / 2;
+      const nodeBottom = n.cy + n.h / 2;
+      const padLeft = nodeLeft - lane.x;
+      const padTop = nodeTop - lane.y;
+      const padRight = lane.x + lane.width - nodeRight;
+      const padBottom = lane.y + lane.height - nodeBottom;
+      const minPad = Math.min(padLeft, padTop, padRight, padBottom);
+      if (minPad < GROUP_INTERNAL_PAD) {
+        push(
+          "group-boundary-clearance",
+          `lane "${lane.id}" 内部 node "${n.id}" との padding ${minPad.toFixed(0)} world が ${GROUP_INTERNAL_PAD} 未満`,
+          "warn",
+        );
+      }
+    }
+    // 外部 clearance = lane 境界と他 lane の外部 node の最短距離
+    const externalNodes = laid.nodes.filter((n) => n.lane !== lane.id);
+    for (const n of externalNodes) {
+      const laneRect = { x: lane.x, y: lane.y, w: lane.width, h: lane.height };
+      const nodeRect = { x: n.cx - n.w / 2, y: n.cy - n.h / 2, w: n.w, h: n.h };
+      const dx = Math.max(
+        0,
+        Math.max(laneRect.x - (nodeRect.x + nodeRect.w), nodeRect.x - (laneRect.x + laneRect.w)),
+      );
+      const dy = Math.max(
+        0,
+        Math.max(laneRect.y - (nodeRect.y + nodeRect.h), nodeRect.y - (laneRect.y + laneRect.h)),
+      );
+      const clear = Math.hypot(dx, dy);
+      const overlap = dx === 0 && dy === 0;
+      if (!overlap && clear < GROUP_EXTERNAL_CLEAR) {
+        push(
+          "group-boundary-clearance",
+          `lane "${lane.id}" と外部 node "${n.id}" の clearance ${clear.toFixed(0)} world が ${GROUP_EXTERNAL_CLEAR} 未満`,
+          "warn",
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 18: node-vertical-clearance (同 lane 内隣接 node の垂直 gap)
+  //
+  // 判定 = 同 lane 内 stack 隣接 node ペアの垂直 gap (下 top - 上 bottom) が
+  // NODE_V_CLEAR (40 world) 未満なら視覚判別困難。 lifeline / spacer / -spacer 除外。
+  // ───────────────────────────────────────────────────────────
+  const NODE_V_CLEAR = 40;
+  const laneNodesMap = new Map<string, LaidDiagram["nodes"]>();
+  for (const n of laid.nodes) {
+    if (n.w < 8 || n.id.endsWith("-spacer") || /^s\d+-/.test(n.id)) continue;
+    const list = laneNodesMap.get(n.lane) ?? [];
+    list.push(n);
+    laneNodesMap.set(n.lane, list);
+  }
+  for (const [laneId, nodesInLane] of laneNodesMap) {
+    const sorted = [...nodesInLane].sort((a, b) => a.cy - b.cy);
+    for (let i = 0; i + 1 < sorted.length; i++) {
+      const upper = sorted[i]!;
+      const lower = sorted[i + 1]!;
+      const upperBottom = upper.cy + upper.h / 2;
+      const lowerTop = lower.cy - lower.h / 2;
+      const gap = lowerTop - upperBottom;
+      if (gap < NODE_V_CLEAR) {
+        push(
+          "node-vertical-clearance",
+          `lane "${laneId}" 内 node "${upper.id}" ↔ "${lower.id}" の垂直 gap ${gap.toFixed(0)} world が ${NODE_V_CLEAR} 未満`,
+          "warn",
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 19: lane-lane-gap (隣接 lane 間の水平 gap)
+  //
+  // 判定 = x 昇順で並べた lane 隣接ペアの水平 gap が LANE_H_GAP (40 world) 未満なら
+  // lane boundary が判別困難。 ただし同 x (重なり) は spec 上 intentional として除外。
+  //
+  // 対象は **枠が描かれる lane の対のみ**。 render は `lane.contain` が true の lane にだけ
+  // 破線の boundary rect を描き、 それ以外は fill / stroke とも none の不可視 rect しか出さない
+  // (`render/stage.tsx`)。 枠が無ければ「lane boundary」 も無いので、 間隔が狭いこと自体が
+  // 画面に現れない。
+  //
+  // 経緯 = contain の有無を見ずに全対を測っていた頃、 dragon の見本 512 図で 99 件の warn が出て、
+  // 実測するとその全件が枠なしの対だった (枠ありの対 0 件)。 描かれていない境界の間隔を測って
+  // いたことになる。 枠なし lane に並ぶ node 同士の見た目の間隔は node-node clearance が担保し、
+  // 検査の下限 70 (`NEAR_COLLISION_POLICY["node|node"]`) に対して `expandLanesForNodes` が
+  // 目標 80 (`targetNodeNodeClearance`) で lane 余白を逆算する。 座標を固定した lane と
+  // overlay は逆算の対象外だが、 そこは node-node clearance の軸が下限割れを報告する。
+  //
+  // lane.label は contain と無関係に常に描かれるが (`render/stage.tsx`)、 label 同士の
+  // 重なりは lane 間隔ではなく label の文字幅で決まる (間隔 200 でも長い label なら重なる)。
+  // 本 axis を label の検出器として兼用すると両方の精度が落ちるため、 label 重なりは
+  // 別 axis の担当とする (dragon 見本での実測は 0 件)。
+  // ───────────────────────────────────────────────────────────
+  const LANE_H_GAP = 40;
+  // gantt / quadrant 等の preset は lane 密着 (日付範囲 / 象限 grid) が intentional design、
+  // lane id prefix で allowlist 化して対象外にする。
+  const DENSE_LANE_PREFIXES = ["gantt-", "quadrant-", "funnel-", "chart-"];
+  // 重ねることが目的の lane (role: "overlay") は鎖から除く。 group を囲む枠や gantt の
+  // timeline 帯がこれにあたり、 間隔を空けるのは配置の意図に反する。 単に「その対を見ない」
+  // だけだと帯を挟んだ両隣の column lane 同士が隣接と判定されず、 詰まりを見逃す
+  // (`expandLanesForNodes` が columnChain を組む時と同じ理由)。
+  const sortedLanes = [...laid.lanes].filter((l) => l.role !== "overlay").sort((a, b) => a.x - b.x);
+  for (let i = 0; i + 1 < sortedLanes.length; i++) {
+    const left = sortedLanes[i]!;
+    const right = sortedLanes[i + 1]!;
+    if (DENSE_LANE_PREFIXES.some((p) => left.id.startsWith(p) || right.id.startsWith(p))) continue;
+    if (!left.contain && !right.contain) continue;
+    const gap = right.x - (left.x + left.width);
+    if (gap > 0 && gap < LANE_H_GAP) {
+      push(
+        "lane-lane-gap",
+        `lane "${left.id}" と "${right.id}" の水平 gap ${gap.toFixed(0)} world が ${LANE_H_GAP} 未満`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 20: arrow-marker-clearance (arrow head と to node bbox の clearance)
+  //
+  // 判定 = edge の最終 segment 終点 (arrow head 位置) と to node bbox 縁の distance が
+  // ARROW_MARKER_MIN (4 world) 未満で「食い込み」、 ARROW_MARKER_MAX (30 world) 超で「離れすぎ」。
+  // sequence lifeline (w<10) は arrow が横に伸びる intentional 構造で対象外。
+  // ───────────────────────────────────────────────────────────
+  const ARROW_MARKER_MIN = 4;
+  const ARROW_MARKER_MAX = 30;
+  for (const e of laid.edges) {
+    const segs = extractPathSegments(e.d);
+    if (segs.length === 0) continue;
+    const lastSeg = segs[segs.length - 1]!;
+    const endPt = { x: lastSeg.x2, y: lastSeg.y2 };
+    const toNode = nodeById.get(e.to);
+    if (!toNode) continue;
+    if (toNode.w < 10 || toNode.h < 10) continue;
+    const rect = {
+      x: toNode.cx - toNode.w / 2,
+      y: toNode.cy - toNode.h / 2,
+      w: toNode.w,
+      h: toNode.h,
+    };
+    const inside =
+      endPt.x > rect.x &&
+      endPt.x < rect.x + rect.w &&
+      endPt.y > rect.y &&
+      endPt.y < rect.y + rect.h;
+    const distToEdge = pointRectEdgeDistance(endPt.x, endPt.y, rect);
+    if (inside) {
+      const depth = Math.min(
+        endPt.x - rect.x,
+        rect.x + rect.w - endPt.x,
+        endPt.y - rect.y,
+        rect.y + rect.h - endPt.y,
+      );
+      if (depth > ARROW_MARKER_MIN) {
+        push(
+          "arrow-marker-clearance",
+          `edge "${e.id}" arrow head が node "${e.to}" 内側に ${depth.toFixed(0)} world 食い込み`,
+          "warn",
+        );
+      }
+    } else if (distToEdge > ARROW_MARKER_MAX) {
+      push(
+        "arrow-marker-clearance",
+        `edge "${e.id}" arrow head が node "${e.to}" 縁から ${distToEdge.toFixed(0)} world 離れすぎ (max ${ARROW_MARKER_MAX})`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 21: grid-alignment (格子に載せる図の箱が格子に載るか)
+  //
+  // 判定 = chart / funnel / quadrant が作る箱の **4 辺** が GRID_SIZE (16 world) の倍数
+  // (±2 world) に載るか。 左上と寸法の両方を見る (左上だけだと、 寸法が 16 の倍数でない時に
+  // 右下が外れる)。
+  //
+  // 中心ではなく左上を見る。 箱が格子に載るかは原点と寸法で決まり、 中心は寸法が
+  // 32 の倍数でない限り必ず半目ずれる (高さ 360 の chart は上端 128 で載っているのに
+  // 中心 308 では 4 ずれる)。
+  //
+  // 対象は節の **種別** で絞る。 元は節の id が `chart-` 等で始まるかで見ていたが、 id は
+  // `{図の id}-chart` の形で作られるため、 図の id を変えるだけで検査対象から外れていた。
+  // ───────────────────────────────────────────────────────────
+  const GRID_SIZE = 16;
+  const GRID_TOL = 2;
+  for (const n of laid.nodes) {
+    if (!GRID_ALIGNED_KINDS.has(n.kind)) continue;
+    if (n.w < 8) continue;
+    const offGrid = (v: number): number => Math.abs(v - Math.round(v / GRID_SIZE) * GRID_SIZE);
+    const left = n.cx - n.w / 2;
+    const top = n.cy - n.h / 2;
+    const rx = Math.max(offGrid(left), offGrid(left + n.w));
+    const ry = Math.max(offGrid(top), offGrid(top + n.h));
+    if (rx > GRID_TOL || ry > GRID_TOL) {
+      push(
+        "grid-alignment",
+        `node "${n.id}" 箱 (${left.toFixed(0)},${top.toFixed(0)} ${n.w}x${n.h}) の辺が grid ${GRID_SIZE} 倍数から (dx=${rx.toFixed(1)}, dy=${ry.toFixed(1)}) 外れ`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 22: phase-layout-stability (phase 別 layout が node cx / cy を動かさない)
+  //
+  // 判定 = diag に複数 phase がある場合、 phase 別 layout 実行で node cx / cy が
+  // ±PHASE_STABILITY_TOL (1 world) 以内で安定するか。 layout() 自身が phase 非依存なので
+  // 実質「同一 layout 再計算の deterministic 性」 を確認する gate。
+  // ───────────────────────────────────────────────────────────
+  const PHASE_STABILITY_TOL = 1;
+  if (diag.phases.length > 1) {
+    let secondLaid: LaidDiagram;
+    try {
+      const origWarn2 = console.warn;
+      console.warn = () => {};
+      try {
+        secondLaid = layout(diag);
+      } finally {
+        console.warn = origWarn2;
+      }
+      const secondById = new Map(secondLaid.nodes.map((n) => [n.id, n]));
+      for (const n of laid.nodes) {
+        const s = secondById.get(n.id);
+        if (!s) continue;
+        const dx = Math.abs(n.cx - s.cx);
+        const dy = Math.abs(n.cy - s.cy);
+        if (dx > PHASE_STABILITY_TOL || dy > PHASE_STABILITY_TOL) {
+          push(
+            "phase-layout-stability",
+            `node "${n.id}" が 2 回目 layout で (dx=${dx.toFixed(1)}, dy=${dy.toFixed(1)}) drift、 phase 間不安定`,
+            "warn",
+          );
+        }
+      }
+    } catch {
+      // 再 layout 失敗は他 axis が捕捉
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 23: responsive-viewport (viewBox の過剰扁平回避)
+  //
+  // 判定 = viewBox aspect ratio が RESPONSIVE_MAX_ASPECT (6:1) を超えると横長すぎで
+  // responsive 破綻。 縦 1 段の図に lane を並べ続けると高さが伸びないまま幅だけ増え、
+  // 親幅に収めた時に帯状に潰れて中身が読めなくなる。
+  //
+  // viewBox width の下限は見ない。 render は `w-full` + `preserveAspectRatio="xMidYMid meet"`
+  // で親要素の幅いっぱいに伸ばすため (`render/stage.tsx`)、 画面上の文字サイズは
+  //
+  //   画面上の文字サイズ = 文字の world 寸法 × (親要素の幅 px ÷ viewBox width)
+  //
+  // で決まる。 viewBox width が小さいほど倍率が上がって読みやすくなるので、 「幅が小さい =
+  // 識別不能」 は成り立たない。 以前は 400 world 未満を warn にしていたが、 dragon の見本で
+  // 発火した 17 件は全て単体部品の図 (271-390 world) で、 幅 375px の携帯では 1.0-1.38 倍に
+  // 拡大される最も読みやすい部類だった。 閾値を下げても判定の向きが誤ったまま残るため、
+  // 判定ごと外している。
+  //
+  // 幅の下限を外した分、 描画不能な寸法 (0 / 負値 / 非有限) だけは別に拾う。 縦横比は
+  // 0 幅で NaN、 負値で符号が反転して比較が素通りするため、 比を出す前に弾く。
+  // ───────────────────────────────────────────────────────────
+  const RESPONSIVE_MAX_ASPECT = 6;
+  const vbResp = laid.viewBox;
+  if (
+    !(vbResp.w > 0) ||
+    !(vbResp.h > 0) ||
+    !Number.isFinite(vbResp.w) ||
+    !Number.isFinite(vbResp.h)
+  ) {
+    push(
+      "responsive-viewport",
+      `viewBox 寸法 ${vbResp.w}×${vbResp.h} が描画不能 (正の有限値である必要がある)`,
+      "warn",
+    );
+  } else {
+    // 横長と縦長を同じ尺度で見る。 縦長を aspect のまま報告すると detail が
+    // 「aspect 0.1 が 6:1 超え」 のように読めない値になる。
+    const worstAspect = Math.max(vbResp.w / vbResp.h, vbResp.h / vbResp.w);
+    if (worstAspect > RESPONSIVE_MAX_ASPECT) {
+      push(
+        "responsive-viewport",
+        `viewBox aspect ${worstAspect.toFixed(1)}:1 が RESPONSIVE_MAX_ASPECT ${RESPONSIVE_MAX_ASPECT}:1 超え`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 24: accessibility-basics (図の代替説明が十分か)
+  //
+  // cdl の図は `<svg role="img">` で描く = 支援技術には **1 枚の絵** として渡り、 中の節や辺は
+  // 個別に公開されない (WAI-ARIA の `img` role は子孫を公開しない)。 読み上げの質はこの 1 文で
+  // 決まるため、 本軸はその 1 文が組み立つかを見る (#363)。
+  //
+  // 元は「節ごとに title があるか」 を見ていた。 節の文字は絵の中の点でしかなく、 支援技術が
+  // 節ごとの名前として読む保証が無いため、 0 件でも実際の読み上げ可能性を表していなかった。
+  //
+  // 操作できる部品 (スライダー等) は `<svg>` の外の HTML なので、 絵として扱っても隠れない。
+  //
+  // 見るのは 2 点。 どちらも「有無」 で、 長さは見ない (長ければ良いという判定は空洞化する)。
+  //   1. 図が何を示すか (`topic`)
+  //   2. 今どの段かと、 その段が何を説明するか (段の `title` または `body`)
+  // ───────────────────────────────────────────────────────────
+  if (!(diag.topic?.trim() ?? "")) {
+    push(
+      "accessibility-basics",
+      `diagram "${diag.id}" topic 空、 読み上げる説明が組み立たない`,
+      "warn",
+    );
+  }
+  // 段を足しても文が伸びない = その段は読み上げに何も足していない。
+  const altTopicOnly = buildDiagramAltText(diag.topic, undefined);
+  for (const p of diag.phases) {
+    if (buildDiagramAltText(diag.topic, p) === altTopicOnly) {
+      push(
+        "accessibility-basics",
+        `diagram "${diag.id}" phase "${p.id}" に title / body がなく、 段を読み上げても題名しか伝わらない`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 25: animation-frame-integrity (phase tween の progress 単調性 + sets 一貫性)
+  //
+  // 判定 = 各 phase の tween について from → to が数値で単調 (from == to 例外)、
+  // sets の重複 stateId 内競合 (同 phase 内で同 stateId が tween + sets 両方) を検知。
+  // ───────────────────────────────────────────────────────────
+  const stateIds2 = new Set(diag.states.map((s) => s.id));
+  for (const p of diag.phases) {
+    const tweenIds = new Map<string, { from: number; to: number }>();
+    for (const t of p.tweens) {
+      if (!stateIds2.has(t.stateId)) {
+        push(
+          "animation-frame-integrity",
+          `phase "${p.id}" tween "${t.stateId}" が未定義 state を参照`,
+          "warn",
+        );
+        continue;
+      }
+      if (!Number.isFinite(t.from) || !Number.isFinite(t.to)) {
+        push(
+          "animation-frame-integrity",
+          `phase "${p.id}" tween "${t.stateId}" from/to が数値でない (from=${t.from}, to=${t.to})`,
+          "warn",
+        );
+        continue;
+      }
+      if (tweenIds.has(t.stateId)) {
+        push(
+          "animation-frame-integrity",
+          `phase "${p.id}" tween "${t.stateId}" が同 phase 内で重複定義`,
+          "warn",
+        );
+      }
+      tweenIds.set(t.stateId, { from: t.from, to: t.to });
+    }
+    for (const s of p.sets) {
+      if (!stateIds2.has(s.stateId)) {
+        push(
+          "animation-frame-integrity",
+          `phase "${p.id}" sets "${s.stateId}" が未定義 state を参照`,
+          "warn",
+        );
+        continue;
+      }
+      if (tweenIds.has(s.stateId)) {
+        push(
+          "animation-frame-integrity",
+          `phase "${p.id}" 同 stateId "${s.stateId}" が tween + sets 両方で定義 (競合)`,
+          "warn",
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 26: i18n-cjk-detection (CJK 文字 + RTL 文字の検知)
+  //
+  // 判定 = label / title / sub / lane label に RTL 文字 (Arabic U+0600-06FF /
+  // Hebrew U+0590-05FF) が含まれると現状の LTR-only 描画で崩れる。 CJK は
+  // サポート済だが「未サポート script」 の early detection。
+  // ───────────────────────────────────────────────────────────
+  const rtlRe = /[֐-׿؀-ۿ]/;
+  const rtlTexts: Array<{ where: string; text: string }> = [];
+  for (const n of diag.nodes) {
+    // 文字を描かない種別の title は画面に出ないので、 描画の崩れも起きない。
+    if (n.title && rendersTitleText(n.kind) && rtlRe.test(n.title)) {
+      rtlTexts.push({ where: `node "${n.id}" title`, text: n.title });
+    }
+    if (n.eyebrow && rtlRe.test(n.eyebrow))
+      rtlTexts.push({ where: `node "${n.id}" eyebrow`, text: n.eyebrow });
+    if (n.subtitle && rtlRe.test(n.subtitle))
+      rtlTexts.push({ where: `node "${n.id}" subtitle`, text: n.subtitle });
+  }
+  for (const e of diag.edges) {
+    if (e.label && rtlRe.test(e.label))
+      rtlTexts.push({ where: `edge "${e.id}" label`, text: e.label });
+    if (e.sub && rtlRe.test(e.sub)) rtlTexts.push({ where: `edge "${e.id}" sub`, text: e.sub });
+  }
+  for (const l of diag.lanes) {
+    if (l.label && rtlRe.test(l.label))
+      rtlTexts.push({ where: `lane "${l.id}" label`, text: l.label });
+  }
+  for (const r of rtlTexts) {
+    push(
+      "i18n-cjk-detection",
+      `${r.where} に RTL 文字 (Arabic / Hebrew) 検出: "${r.text}" — 現状 LTR-only 描画で崩れる可能性`,
+      "warn",
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 27: contrast-basics (edge label の文字と背景の対比)
+  //
+  // 判定 = 文字色と背景色の相対輝度から contrast ratio (最大 21) を出し、 WCAG AA の閾値未満なら
+  // warn。 閾値は文字の大きさで分かれる (large text = 24px 以上 or 太字 18.66px 以上 → 3:1、
+  // それ以外 → 4.5:1)。
+  //
+  // **状態が 2 つ、 行が 2 種**。 `render/edges.tsx` の edge label は 2 行を描き、 どちらも
+  // `fill={active ? color : "var(--cdl-text-dim, ...)"}`。 大きさと太さと不透明度は
+  // `label-text.ts` の `EDGE_LABEL_TEXT` が SSOT で、 ここには写さない (写すと片方だけが
+  // 変わった時に検知できない)。
+  //
+  // **tone の色が文字になるのは活性時だけ**。 非活性時は tone に依らず `--cdl-text-dim`。
+  // 旧実装は tone 対 `#ffffff` だけを見ており、 実際には最も多く画面に出る非活性時の組合せを
+  // 一度も測っていなかった (#388)。
+  //
+  // **行ごとに閾値と合成を導く**。 旧実装は全 label を large text と見なしていた (#388)。
+  // 現在はどちらの行も large text で不透明だが、 それは `EDGE_LABEL_TEXT` がそう定めている
+  // からで、 判定は仕様から計算する (#391)。
+  //
+  // **どちらの状態が起きるかは phase が決める**。 `render/stage.tsx` は
+  // `activeSet = new Set(currentPhase?.activate ?? [])` で、 phase が無ければ全て非活性。
+  // 一度も activate されない辺の tone は label の文字として一度も描かれないので測らない。
+  //
+  // 非活性の pill は `opacity={0.92}` で背後の色が 8% 混ざるが、 判定では混ぜていない。
+  // 既定の stage 背景 `#fafafa` との合成では対比 6.15 → 6.10 で、 背後が純黒でも 5.16。
+  // 閾値 3.0 に対して十分離れており、 混ぜても判定は変わらない (実測値は test に固定)。
+  //
+  // **測るのは cdl の既定値どうしの対比だけ**。 背景は `var(--cdl-label-bg, #ffffff)`、 文字は
+  // `var(--cdl-text-dim, #5a6270)` / `var(--cdl-tone-*, ...)` で、 いずれも下流が上書きできる。
+  // さらに下流は `[data-cdl-role="edge-label"]` / `[data-cdl-role="edge-label-bg"]` に
+  // `fill: ... !important` を当てて変数ごと迂回できる (dragon の 6 主題は実際にそうしている)。
+  // 本軸は下流の CSS を知らないので、 下流側の対比は下流の test が見る。
+  // ───────────────────────────────────────────────────────────
+  // render/tone.ts SSOT を import して 2 度書き回避 (前 visual-validate 内 hardcode は drift 元凶)。
+  const TONE_COLORS = TONE_SSOT;
+  for (const f of evaluateLabelContrast({
+    edges: laid.edges,
+    phases: laid.phases,
+    // 描画側と同じ解決。 `TONE` は CSS 変数を含む文字列なので、 対比計算には hex の SSOT を使う。
+    toneColor: (tone) =>
+      hasTone(tone) ? (TONE_COLORS as Record<string, string>)[tone]! : TONE_FALLBACK,
+    labelBg: LABEL_BG_DEFAULT,
+    inactiveText: LABEL_TEXT_INACTIVE_DEFAULT,
+  })) {
+    push("contrast-basics", f.detail, "warn");
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 28: print-media-compat (mono / high-contrast 印刷で edge tone 別判別可能か)
+  //
+  // 判定 = mono print で edge tone を色抜きすると全て同色 (gray) になり判別不能。
+  // edge style ("solid" / "dotted-flow") で最低限 2 種類使い分けているか、
+  // edge が 3 本以上あるならその区別が必要。 単一 style だと mono で全 edge 同見え。
+  // ───────────────────────────────────────────────────────────
+  // print-media は「機能的差異が edge にある state machine / sequence」 系のみ判定対象。
+  // 装飾的 flow / topology は edge 差異が意図的に均一な design が多く、 false positive 回避。
+  // 判定対象 = edge に guard / cardinality / sub のいずれかが 1 本でもある = 機能差 diagram。
+  const hasFunctionalEdge = laid.edges.some((e) => e.guard || e.cardinality || e.sub);
+  if (hasFunctionalEdge && laid.edges.length >= 5) {
+    const styles = new Set(laid.edges.map((e) => e.style ?? "solid"));
+    const tones = new Set(laid.edges.map((e) => e.tone));
+    if (styles.size === 1 && tones.size === 1) {
+      push(
+        "print-media-compat",
+        `機能差 edges ${laid.edges.length} 本が全て単一 style "${[...styles][0]}" + 単一 tone "${[...tones][0]}"、 mono print で識別不能`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 31: color-blind-safety (protanopia / deuteranopia シミュレーションで tone 判別可能)
+  //
+  // 判定 = 同 diagram 内で使用される tone ペアを protanopia (P-type) / deuteranopia (D-type)
+  // 変換した後の CIE Lab 距離 (Δ_L) が COLOR_BLIND_MIN (10) 未満だと色覚異常下で
+  // 判別困難。 実装 = 単純な RGB → Machado (2009) 系 protanopia matrix 変換 → RGB → 輝度差。
+  // ───────────────────────────────────────────────────────────
+  function applyProtanopia(rgb: [number, number, number]): [number, number, number] {
+    // Machado (2009) protanopia matrix (0.85 severity)
+    const [r, g, b] = rgb;
+    return [
+      r * 0.152 + g * 1.053 + b * -0.205,
+      r * 0.115 + g * 0.786 + b * 0.099,
+      r * -0.004 + g * -0.048 + b * 1.052,
+    ];
+  }
+  function applyDeuteranopia(rgb: [number, number, number]): [number, number, number] {
+    const [r, g, b] = rgb;
+    return [
+      r * 0.367 + g * 0.861 + b * -0.228,
+      r * 0.28 + g * 0.673 + b * 0.047,
+      r * -0.012 + g * 0.043 + b * 0.969,
+    ];
+  }
+  function colorDiff(a: [number, number, number], b: [number, number, number]): number {
+    return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+  }
+  const COLOR_BLIND_MIN = 30;
+  const tonesInUse = Array.from(new Set(laid.edges.map((e) => e.tone)));
+  for (let i = 0; i < tonesInUse.length; i++) {
+    for (let j = i + 1; j < tonesInUse.length; j++) {
+      const tA = tonesInUse[i]!;
+      const tB = tonesInUse[j]!;
+      const cA = TONE_COLORS[tA];
+      const cB = TONE_COLORS[tB];
+      if (!cA || !cB) continue;
+      const rgbA = hexToRgb(cA);
+      const rgbB = hexToRgb(cB);
+      const dP = colorDiff(applyProtanopia(rgbA), applyProtanopia(rgbB));
+      const dD = colorDiff(applyDeuteranopia(rgbA), applyDeuteranopia(rgbB));
+      const minDiff = Math.min(dP, dD);
+      if (minDiff < COLOR_BLIND_MIN) {
+        push(
+          "color-blind-safety",
+          `tone pair "${tA}" ↔ "${tB}" が protanopia/deuteranopia 下で色差 ${minDiff.toFixed(1)} (min ${COLOR_BLIND_MIN} 未満)、 判別困難`,
+          "warn",
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 32: marker-gradient-def-integrity (marker id 参照と TONE 定義の整合)
+  //
+  // 判定 = edge の tone が TONE_COLORS に定義された key と一致するか。 tone 値が typo /
+  // 追加漏れで marker id "cdl-arrow-${unknown}" になると SVG marker が hit しない dead ref。
+  // 現状 edge.tone は型 (Tone union) で制約済だが、 runtime で拡張 preset が渡す string で
+  // typo する余地があるので gate として先取り。
+  // ───────────────────────────────────────────────────────────
+  for (const e of laid.edges) {
+    if (!TONE_COLORS[e.tone]) {
+      push(
+        "marker-gradient-def-integrity",
+        `edge "${e.id}" tone "${e.tone}" が TONE_COLORS 定義に存在しない、 marker "cdl-arrow-${e.tone}" dead ref`,
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 33: subpixel-precision (node / edge label 座標の subpixel drift 検知)
+  //
+  // 判定 = node cx / cy / edge labelX / labelY / lane x / y が SUBPIXEL_TOL (0.5 world) を
+  // 超えて小数点を持つ (e.g. 100.7) と subpixel render 時に SVG 描画が blur を生む。
+  // 整数化 or 0.5 刻みが理想。 label は shift 経路の結果として非整数が出やすい。
+  // ───────────────────────────────────────────────────────────
+  const SUBPIXEL_TOL = 0.5;
+  function isSubpixel(v: number): boolean {
+    // 整数と 0.5 刻みの両方を許容する。
+    //
+    // 0.5 は SVG では「にじむ座標」 ではない。 幅 1 の線は中心を .5 に置くと 1 pixel に
+    // ちょうど収まって輪郭が立つ (逆に整数に置くと 2 pixel に半分ずつ跨いでぼやける)。
+    // 本 axis の説明も「整数化 or 0.5 刻みが理想」 としており、 判定側だけが 0.5 を
+    // 弾いていた。 説明に合わせる。
+    //
+    // 判定は「最も近い 0.5 の倍数からの距離」 で見る。 0.05 以下は float 演算の誤差として許容。
+    const nearestHalf = Math.round(v * 2) / 2;
+    return Math.abs(v - nearestHalf) > SUBPIXEL_TOL / 10;
+  }
+  for (const n of laid.nodes) {
+    if (n.id.endsWith("-spacer") || /^s\d+-/.test(n.id)) continue;
+    if (isSubpixel(n.cx) || isSubpixel(n.cy)) {
+      push(
+        "subpixel-precision",
+        `node "${n.id}" 座標 (${n.cx.toFixed(2)}, ${n.cy.toFixed(2)}) が非整数、 subpixel blur リスク`,
+        "warn",
+      );
+    }
+  }
+  for (const e of laid.edges) {
+    if (isSubpixel(e.labelX) || isSubpixel(e.labelY)) {
+      push(
+        "subpixel-precision",
+        `edge "${e.id}" label 座標 (${e.labelX.toFixed(2)}, ${e.labelY.toFixed(2)}) が非整数、 subpixel blur リスク`,
+        "warn",
+      );
+    }
+  }
+  for (const l of laid.lanes) {
+    if (isSubpixel(l.x) || isSubpixel(l.y)) {
+      push(
+        "subpixel-precision",
+        `lane "${l.id}" 座標 (${l.x.toFixed(2)}, ${l.y.toFixed(2)}) が非整数、 subpixel blur リスク`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 34: dom-complexity-budget (1 diagram あたりの element 総数)
+  //
+  // 判定 = node / edge / lane / phase の合計が DOM_COMPLEXITY_BUDGET (400) を超えると
+  // render 遅延 / DOM node 過多で performance 破綻。 実 render は 1 element ≈ 5-10 SVG 要素
+  // (rect + text + filter + marker 分) なので 400 element ≈ 2000-4000 SVG node。
+  // ───────────────────────────────────────────────────────────
+  const DOM_COMPLEXITY_BUDGET = 400;
+  const totalElements =
+    laid.nodes.length + laid.edges.length + laid.lanes.length + diag.phases.length;
+  if (totalElements > DOM_COMPLEXITY_BUDGET) {
+    push(
+      "dom-complexity-budget",
+      `diagram element 総数 ${totalElements} が budget ${DOM_COMPLEXITY_BUDGET} 超過 (nodes=${laid.nodes.length} edges=${laid.edges.length} lanes=${laid.lanes.length} phases=${diag.phases.length})`,
+      "warn",
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 35: reduced-motion-compat (phase duration の最小値 / 累計動作時間)
+  //
+  // 判定 = phase の duration が MIN_PHASE_DURATION_MS (400ms) 未満だと prefers-reduced-motion
+  // 非対応時に flicker / seizure リスク (WCAG 2.3.1 相当)。 かつ全 phase 累計が
+  // MAX_TOTAL_ANIMATION_MS (60000ms=1min) 超だと user attention を過度に奪う。
+  // ───────────────────────────────────────────────────────────
+  const MIN_PHASE_DURATION_MS = 400;
+  const MAX_TOTAL_ANIMATION_MS = 60000;
+  let totalDuration = 0;
+  for (const p of diag.phases) {
+    if (p.duration < MIN_PHASE_DURATION_MS) {
+      push(
+        "reduced-motion-compat",
+        `phase "${p.id}" duration ${p.duration}ms が MIN ${MIN_PHASE_DURATION_MS}ms 未満、 flicker / seizure リスク`,
+        "warn",
+      );
+    }
+    totalDuration += p.duration;
+  }
+  if (totalDuration > MAX_TOTAL_ANIMATION_MS) {
+    push(
+      "reduced-motion-compat",
+      `diagram 全 phase 累計 ${totalDuration}ms が MAX ${MAX_TOTAL_ANIMATION_MS}ms 超え、 user attention 過負荷`,
+      "warn",
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 36: touch-target-size (interactive element の最小 target size)
+  //
+  // 判定 = phase indicator (header の phase button 相当、 直接 render に data-cdl-* interactive
+  // attribute はないが、 conceptual に header は user click で phase 切替可能な interactive element)。
+  // 各 phase 分の button は横並びで幅 = viewBox width / phase count。 WCAG 2.5.5 Level AAA
+  // 44 world 未満なら target size 不足、 mobile touch で誤タップ発生。
+  //
+  // 実装 = phase 数 * TOUCH_TARGET_MIN (44 world) を横並び時の最小要求幅と扱い、
+  // viewBox width がそれ未満なら「target size 不足」 warn。
+  // ───────────────────────────────────────────────────────────
+  const TOUCH_TARGET_MIN = 44;
+  if (diag.phases.length > 0) {
+    const requiredW = diag.phases.length * TOUCH_TARGET_MIN;
+    if (laid.viewBox.w < requiredW) {
+      push(
+        "touch-target-size",
+        `phases ${diag.phases.length} 個 × TOUCH_TARGET_MIN ${TOUCH_TARGET_MIN} = ${requiredW} world 要求、 viewBox width ${laid.viewBox.w.toFixed(0)} が不足で touch target 過小`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 37: row-content-typing (node.rows[] の値型別 validation)
+  //
+  // 判定 = row が "key: value" 形式のとき、 key 名から期待型を推測 (url / email /
+  // duration / percent / count / rate / date) → value が期待 pattern に一致するか。
+  // 型検査失敗は warn (docs / catalog で見せる例が実務用途に耐えるかの mini gate)。
+  // ───────────────────────────────────────────────────────────
+  const TYPE_PATTERNS: Array<{ keyRe: RegExp; label: string; valueRe: RegExp }> = [
+    { keyRe: /^url$|url:|url_/i, label: "URL", valueRe: /^\{[^}]+\}$|^(https?:\/\/|\/)\S+/ },
+    {
+      keyRe: /^email$|email:|_email/i,
+      label: "email",
+      valueRe: /^\{[^}]+\}$|^[\w.+-]+@[\w-]+\.[\w.-]+$/,
+    },
+    {
+      keyRe: /^(duration|timeout|ttl|latency|elapsed)/i,
+      label: "duration",
+      valueRe: /^\{[^}]+\}$|^\d+(\.\d+)?\s*(ms|s|m|h|d)$|^\d+$/,
+    },
+    {
+      keyRe: /^(pct|percent|rate|ratio)$|^(pct|percent|rate|ratio):/i,
+      label: "percent",
+      valueRe: /^\{[^}]+\}$|^\d+(\.\d+)?%?$/,
+    },
+    { keyRe: /^count$|count:|^total$|^n$/i, label: "count", valueRe: /^\{[^}]+\}$|^\d+$/ },
+  ];
+  // ER / classDiagram の schema 宣言 (`email: string` / `total: number` 等) は実データでなく
+  // 型名を書く design、 Axis 37 の型判定対象外。 value が schema 型キーワードなら skip。
+  const SCHEMA_KEYWORDS =
+    /^(string|number|boolean|text|enum|timestamp|date|datetime|json|blob|PK|FK|UUID|BIGINT|INT|FLOAT|VARCHAR|TEXT|DATETIME)$|^enum\(|^varchar\(/i;
+  for (const n of diag.nodes) {
+    if (!n.rows) continue;
+    for (const row of n.rows) {
+      const m = row.match(/^([^:]+):\s*(.+)$/);
+      if (!m) continue;
+      const [, key, value] = m;
+      const keyTrim = key!.trim();
+      const valTrim = value!.trim();
+      if (SCHEMA_KEYWORDS.test(valTrim)) continue; // schema 宣言 skip
+      for (const t of TYPE_PATTERNS) {
+        if (t.keyRe.test(keyTrim)) {
+          if (!t.valueRe.test(valTrim)) {
+            push(
+              "row-content-typing",
+              `node "${n.id}" row "${row}" — key "${keyTrim}" は ${t.label} 型を期待するが value "${valTrim}" が pattern 不一致`,
+              "warn",
+            );
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 38: terminal-safe-text (制御文字 / zero-width 混入検知)
+  //
+  // 判定 = title / label / eyebrow / subtitle / row / lane label に
+  //   - 制御文字 U+0000-001F (TAB / LF / CR は許容) → 実 render で無表示になり見えない bug
+  //   - zero-width chars U+200B (ZWSP) / U+200C (ZWNJ) / U+200D (ZWJ) → 文字列比較の
+  //     silent equality break、 label bbox 予測に含まれない
+  //   - Byte Order Mark U+FEFF → 先頭以外で表示崩れ
+  // ───────────────────────────────────────────────────────────
+  //
+  // 本 regex は「制御文字 / zero-width 文字を検知する」 のが目的 SSOT。
+  // 検知したい文字を regex literal に直接書くと source に NUL byte が残り、
+  // ripgrep / ugrep が file 全体を binary と誤判定して検索対象から無言で外す。
+  // 同じ code point を unicode escape で書く (match する集合は完全に等価)。
+  // eslint-disable-next-line no-control-regex
+  const CTRL_RE = /[\u0000-\u0008\u000b-\u000c\u000e-\u001f]/;
+  const ZW_RE = /[\u200b-\u200d\ufeff]/;
+  function checkTerminalSafe(text: string | undefined, where: string): void {
+    if (!text) return;
+    if (CTRL_RE.test(text)) {
+      push(
+        "terminal-safe-text",
+        `${where} に制御文字 (U+0000-001F) 混入、 実 render で無表示 bug`,
+        "warn",
+      );
+    }
+    if (ZW_RE.test(text)) {
+      push(
+        "terminal-safe-text",
+        `${where} に zero-width / BOM 文字 混入、 silent equality break + bbox 予測崩れ`,
+        "warn",
+      );
+    }
+  }
+  for (const n of diag.nodes) {
+    checkTerminalSafe(n.title, `node "${n.id}" title`);
+    checkTerminalSafe(n.eyebrow, `node "${n.id}" eyebrow`);
+    checkTerminalSafe(n.subtitle, `node "${n.id}" subtitle`);
+    if (n.rows) for (const r of n.rows) checkTerminalSafe(r, `node "${n.id}" row`);
+  }
+  for (const e of diag.edges) {
+    checkTerminalSafe(e.label, `edge "${e.id}" label`);
+    checkTerminalSafe(e.sub, `edge "${e.id}" sub`);
+  }
+  for (const l of diag.lanes) {
+    checkTerminalSafe(l.label, `lane "${l.id}" label`);
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 39: gpu-layer-efficiency (edge style の GPU 加速可否)
+  //
+  // 判定 = dotted-flow style は particle animation を伴い、 transform / opacity で
+  // GPU compositing 効果を得る前提。 実装上は engine SVG は transform / opacity のみ
+  // 使うため gate は「dotted-flow 使用時に animation phase が存在するか」 を検査。
+  // dotted-flow で phase 空 = animation なしで無駄 style。
+  // ───────────────────────────────────────────────────────────
+  const dottedEdges = laid.edges.filter((e) => e.style === "dotted-flow");
+  if (dottedEdges.length > 0 && diag.phases.length === 0) {
+    push(
+      "gpu-layer-efficiency",
+      `dotted-flow style edge ${dottedEdges.length} 本あるが phase 0、 particle animation 発火せず無駄 style (GPU layer promotion 不必要)`,
+      "warn",
+    );
+  }
+  // 5 edge 以上の dotted-flow は GPU layer が dot ごとに promotion → 30+ layer で GPU thrash
+  const MAX_DOTTED_EDGES = 8;
+  if (dottedEdges.length > MAX_DOTTED_EDGES) {
+    push(
+      "gpu-layer-efficiency",
+      `dotted-flow edges ${dottedEdges.length} 本 > MAX ${MAX_DOTTED_EDGES}、 particle GPU layer 過多で thrash リスク`,
+      "warn",
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 40: memory-budget (diagram size 総和による React re-render 負荷)
+  //
+  // 判定 = nodes×h×w + edges×path segment 数 + phases×(tweens + sets 数) の推定 memory 単位
+  // が MEMORY_BUDGET (10^7) を超えると React re-render で GC pressure。 catalog 内 diagram は
+  // 10^5-10^6 が実測、 10^7 で明確な破綻。
+  // ───────────────────────────────────────────────────────────
+  const MEMORY_BUDGET = 1_000_000;
+  let nodeMemUnit = 0;
+  for (const n of laid.nodes) nodeMemUnit += n.w * n.h;
+  let edgeMemUnit = 0;
+  for (const e of laid.edges) {
+    const segs = extractPathSegments(e.d);
+    edgeMemUnit += segs.length * 100; // 1 segment ≈ 100 memory unit (SVG path + marker + label)
+  }
+  let phaseMemUnit = 0;
+  for (const p of diag.phases) phaseMemUnit += (p.tweens.length + p.sets.length) * 50;
+  const totalMemUnit = nodeMemUnit + edgeMemUnit + phaseMemUnit;
+  if (totalMemUnit > MEMORY_BUDGET) {
+    push(
+      "memory-budget",
+      `diagram memory unit 推定 ${totalMemUnit.toFixed(0)} > budget ${MEMORY_BUDGET} (nodes=${nodeMemUnit.toFixed(0)} edges=${edgeMemUnit.toFixed(0)} phases=${phaseMemUnit.toFixed(0)})`,
+      "warn",
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 41: svg-injection-safety (XSS / script injection 検知、 error severity)
+  //
+  // 判定 = label / title / eyebrow / subtitle / row / lane label / sub / topic に
+  // XSS-shaped 文字列 (`<script>` / `javascript:` / `data:text/html` / `on\w+=`) が
+  // 混入すると SVG DOM 内で実行可能 = security 破綻。 error severity で block。
+  // ───────────────────────────────────────────────────────────
+  const XSS_PATTERNS: Array<{ re: RegExp; label: string }> = [
+    { re: /<script\b/i, label: "<script> tag" },
+    { re: /javascript:/i, label: "javascript: URI" },
+    { re: /data:text\/html/i, label: "data:text/html URI" },
+    { re: /\bon\w+\s*=/i, label: "inline event handler (on*=)" },
+    { re: /<iframe\b/i, label: "<iframe> tag" },
+    { re: /<embed\b/i, label: "<embed> tag" },
+    { re: /<object\b/i, label: "<object> tag" },
+  ];
+  function checkXss(text: string | undefined, where: string): void {
+    if (!text) return;
+    for (const p of XSS_PATTERNS) {
+      if (p.re.test(text)) {
+        push(
+          "svg-injection-safety",
+          `${where} に XSS pattern ${p.label} 検出、 実 render で script 実行の恐れ`,
+        );
+      }
+    }
+  }
+  checkXss(diag.topic, `diagram "${diag.id}" topic`);
+  for (const n of diag.nodes) {
+    checkXss(n.title, `node "${n.id}" title`);
+    checkXss(n.eyebrow, `node "${n.id}" eyebrow`);
+    checkXss(n.subtitle, `node "${n.id}" subtitle`);
+    if (n.rows) for (const r of n.rows) checkXss(r, `node "${n.id}" row`);
+  }
+  for (const e of diag.edges) {
+    checkXss(e.label, `edge "${e.id}" label`);
+    checkXss(e.sub, `edge "${e.id}" sub`);
+  }
+  for (const l of diag.lanes) {
+    checkXss(l.label, `lane "${l.id}" label`);
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 42: seo-metadata-quality (topic / id の SEO / OGP meta 品質)
+  //
+  // 判定 = SEO_MIN_TOPIC (3 char) / SEO_MAX_TOPIC (60 char) 範囲外は SEO meta title
+  // として不適切。 id の長さ (2-40 char) / 命名 (kebab-case 推奨) も検査。
+  // 空 id / 空 topic は明確な error、 長すぎは warn。
+  // ───────────────────────────────────────────────────────────
+  const SEO_MIN_TOPIC = 3;
+  const SEO_MAX_TOPIC = 60;
+  const SEO_ID_MIN = 2;
+  const SEO_ID_MAX = 40;
+  const topicLen = diag.topic?.trim().length ?? 0;
+  if (topicLen === 0) {
+    push("seo-metadata-quality", `diagram "${diag.id}" topic 空、 OGP meta title 生成不可`);
+  } else if (topicLen < SEO_MIN_TOPIC) {
+    push(
+      "seo-metadata-quality",
+      `diagram "${diag.id}" topic 長 ${topicLen} < ${SEO_MIN_TOPIC}、 SEO title として短すぎ`,
+      "warn",
+    );
+  } else if (topicLen > SEO_MAX_TOPIC) {
+    push(
+      "seo-metadata-quality",
+      `diagram "${diag.id}" topic 長 ${topicLen} > ${SEO_MAX_TOPIC}、 SEO title で truncate される`,
+      "warn",
+    );
+  }
+  const idLen = diag.id.length;
+  if (idLen < SEO_ID_MIN || idLen > SEO_ID_MAX) {
+    push(
+      "seo-metadata-quality",
+      `diagram id "${diag.id}" 長 ${idLen} が [${SEO_ID_MIN}, ${SEO_ID_MAX}] 外`,
+      "warn",
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 43: bidi-hyphenation (bidi bracket 崩れ + 長 label 折返し)
+  //
+  // 判定 =
+  //  - LTR 内 RTL 単語混入 (Arabic / Hebrew) が bidi bracket 制御なしだと表示順崩れ
+  //  - 単一 label が LABEL_TOO_LONG (40 char) 超えかつ空白ゼロ = ハイフネーション補助不可
+  // ───────────────────────────────────────────────────────────
+  const bidiRtlWord = /[֐-׿؀-ۿ]+/;
+  const bidiLtrWord = /[a-zA-Z]{3,}/;
+  const LABEL_TOO_LONG = 40;
+  function checkBidiHyphen(text: string | undefined, where: string): void {
+    if (!text) return;
+    const hasRtl = bidiRtlWord.test(text);
+    const hasLtr = bidiLtrWord.test(text);
+    if (hasRtl && hasLtr) {
+      // LRM (U+200E) / RLM (U+200F) / Isolate (U+2066-2069) の 4 種のいずれもなければ bidi 崩れ潜在
+      const hasBidiControl = /[‎‏⁦-⁩]/.test(text);
+      if (!hasBidiControl) {
+        push(
+          "bidi-hyphenation",
+          `${where} に LTR + RTL 単語混在、 bidi 制御文字なしで表示順崩れリスク`,
+          "warn",
+        );
+      }
+    }
+    if (text.length > LABEL_TOO_LONG && !/[\s\-/,]/.test(text)) {
+      push(
+        "bidi-hyphenation",
+        `${where} 長 ${text.length} 超で空白/ハイフン無し、 折返し補助不可で clip リスク`,
+        "warn",
+      );
+    }
+  }
+  for (const n of diag.nodes) {
+    // 文字を描かない種別の title は画面に出ないので、 折返しや表示順の崩れも起きない。
+    if (rendersTitleText(n.kind)) checkBidiHyphen(n.title, `node "${n.id}" title`);
+    checkBidiHyphen(n.eyebrow, `node "${n.id}" eyebrow`);
+    checkBidiHyphen(n.subtitle, `node "${n.id}" subtitle`);
+  }
+  for (const e of diag.edges) {
+    checkBidiHyphen(e.label, `edge "${e.id}" label`);
+    checkBidiHyphen(e.sub, `edge "${e.id}" sub`);
+  }
+  for (const l of diag.lanes) {
+    checkBidiHyphen(l.label, `lane "${l.id}" label`);
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 44: structured-data-extraction (schema.org 抽出可能性)
+  //
+  // 判定 = diagram を schema.org DataFeed / TechArticle 抽出する際、
+  // 必須 field (id / topic / node.title の非空 sample 3 個以上 / phase 1 個以上) が
+  // 揃うか。 これらが揃えば SEO / OGP / structured-data JSON-LD 生成可能。
+  // ───────────────────────────────────────────────────────────
+  // docs 説明用 mini diagram (kind- / style- / tone- prefix / -demo suffix + 4 node 未満) は
+  // 「単一 kind の見本」 として意図的に極小、 structured-data 抽出対象外に allowlist。
+  // 5 節以下の primitive / pattern / lane / stack / k- (kind mini) / kind- は全て「説明用 mini」、
+  // structured-data 抽出対象外。 実務 diagram (topology / sequence / cookbook 系) のみ対象化。
+  // 全 showcase 型 prefix + 4 node 未満の text-dsl / animation showcase を allowlist に集約。
+  // 実務 diagram = topology / sequence / cookbook / flow-demo 等の 4+ node は残す。
+  const isMiniShowcase =
+    /^(kind-|style-|tone-|edge-|primitive-|pattern-|lane-|stack-|k-|state-|tween-|set-|badge-|mixed-)/.test(
+      diag.id,
+    ) ||
+    diag.id.endsWith("-dsl") ||
+    (diag.nodes.length < 4 && /-demo$|-example$|-showcase$/.test(diag.id));
+
+  // 抽出対象外は **著者の宣言** で決める (`structuredData: "exclude"`)。
+  //
+  // 図の形から推測しようとすると必ず盲点ができる。 実際に試して分かったこと。
+  //   - id の prefix (`parts-` 等) で除外 ... 同じ prefix を持つ中身のある図まで巻き込む
+  //     (実測 = dragon の `parts-` 80 図のうち 18 図は node 複数、 うち 16 図は名前を持つ)
+  //   - 「名前が 1 つも無い図」 を除外 ... 名前の欠落は本 axis が検知すべきものそのもので、
+  //     「意図的に文字を持たない図」 と「付け忘れた図」 を engine からは区別できない
+  //
+  // 意図は図の形に現れないため、 著者に宣言してもらう。 既定は `"extract"` で、
+  // 宣言を忘れても検知が緩まない向きに倒している。
+  //
+  // 本条件は Axis 44 だけに効かせる。
+  const excludedByAuthor = diag.structuredData === "exclude";
+
+  if (!isMiniShowcase && !excludedByAuthor) {
+    const namedNodes = diag.nodes.filter((n) => (n.title?.trim() ?? "").length > 0);
+    if (namedNodes.length < 3) {
+      push(
+        "structured-data-extraction",
+        `diagram "${diag.id}" 有名 node 数 ${namedNodes.length} < 3、 structured-data 抽出に必要な最小要素不足`,
+        "warn",
+      );
+    }
+    if (diag.phases.length === 0 && diag.nodes.length > 0) {
+      push(
+        "structured-data-extraction",
+        `diagram "${diag.id}" phase 0、 TechArticle "articleBody" 相当の time-series meta 不足`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 45: diagram-version-semver (diagram.version field の semver 準拠)
+  //
+  // 判定 = CdlDiagram 型に version field は現状無いが、 拡張 diagram (as any) で
+  // 追加している場合の semver 準拠検査。 major.minor.patch 3 数字形式、
+  // pre-release / build-metadata 対応 (SemVer 2.0.0)。
+  // ───────────────────────────────────────────────────────────
+  const anyDiag = diag as unknown as { version?: string };
+  if (typeof anyDiag.version === "string") {
+    const SEMVER_RE =
+      /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+    if (!SEMVER_RE.test(anyDiag.version)) {
+      push(
+        "diagram-version-semver",
+        `diagram "${diag.id}" version "${anyDiag.version}" が SemVer 2.0.0 準拠でない`,
+        "warn",
+      );
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 46: migration-path-consistency (旧 diagram id 参照の残存)
+  //
+  // 判定 = diagram に migratedFrom field (旧 id list) がある場合、 その旧 id が
+  // edge の from / to や row placeholder で参照されていないか (breaking change 未反映) を検査。
+  // ───────────────────────────────────────────────────────────
+  const anyDiagMig = diag as unknown as { migratedFrom?: string[] };
+  if (Array.isArray(anyDiagMig.migratedFrom)) {
+    const oldIds = new Set(anyDiagMig.migratedFrom);
+    for (const e of diag.edges) {
+      if (oldIds.has(e.from)) {
+        push(
+          "migration-path-consistency",
+          `edge "${e.id}" from "${e.from}" が旧 id (migratedFrom 対象)、 新 id へ update 必要`,
+        );
+      }
+      if (oldIds.has(e.to)) {
+        push(
+          "migration-path-consistency",
+          `edge "${e.id}" to "${e.to}" が旧 id (migratedFrom 対象)、 新 id へ update 必要`,
+        );
+      }
+    }
+    for (const n of diag.nodes) {
+      if (!n.rows) continue;
+      for (const row of n.rows) {
+        for (const oid of oldIds) {
+          if (row.includes(`{${oid}}`)) {
+            push(
+              "migration-path-consistency",
+              `node "${n.id}" row "${row}" に旧 id placeholder "{${oid}}" 残存`,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  // Axis 47 / 48 は「全 diagram を横断集計する engine-meta 判定」 で per-diagram 判定不可、
+  // 本 file 末尾の validateMetaAxes() で計算し、 visualValidateAll の sweep 結果に含める。
+
+  // contain=false lane も「水平方向のみ」 検査対象。
+  // swim lane / flow lane は縦方向 (h) は動的なので padTop / padBottom は検査不可、
+  // 水平方向 (padLeft / padRight) のみ node.cx が lane 幅からはみ出したら warn。
+  // spacer (id endsWith "-spacer" or /^s\d+-/) と lifeline (w<8) は intentional 極細 node で
+  // 検査対象外。
+  for (const lane of laid.lanes) {
+    if (lane.contain) continue; // contain=true は上で処理済
+    const laneNodes = laid.nodes.filter(
+      (n) => n.lane === lane.id && n.w >= 8 && !n.id.endsWith("-spacer") && !/^s\d+-/.test(n.id),
+    );
+    for (const n of laneNodes) {
+      const nodeLeft = n.cx - n.w / 2;
+      const nodeRight = n.cx + n.w / 2;
+      const padLeft = nodeLeft - lane.x;
+      const padRight = lane.x + lane.width - nodeRight;
+      const minHorPad = Math.min(padLeft, padRight);
+      // 水平方向 padding が負 = node が lane 幅を左右にはみ出す視覚破綻
+      if (minHorPad < 0) {
+        push(
+          "group-boundary-clearance",
+          `lane "${lane.id}" 内 node "${n.id}" が lane 幅から水平方向に ${Math.abs(minHorPad).toFixed(0)} world はみ出し`,
+          "warn",
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 62: detour-slot-distinct (CAR-422 positive-check)
+  //
+  // 判定 = 上方 or 下方 detour path 同士の peak Y (縦方向の極端点) が
+  // DETOUR_SLOT_GAP 以上離れているか。
+  //
+  // detour path 定義 = ≥3 segments を持ち、 かつ start / end の中間点で
+  // Y 軸に「山」 or 「谷」 を持つ path。 山 = peak Y < min(startY, endY)、
+  // 谷 = peak Y > max(startY, endY)。 山 / 谷 は別 slot として棲み分け判定する。
+  //
+  // 同 obstacle 判定 = 以下 2 経路のいずれかで「同一 obstacle を迂回している視覚関係」
+  // と見なす。 その場合 peak Y 差が DETOUR_SLOT_GAP 未満なら「上下重なり」 症状で fail。
+  //
+  //   経路 1 (peak 点) = 2 detour の peak X が ±60 world に収まる。
+  //   経路 2 (crest 区間) = 2 detour の水平 crest 区間が X 方向に
+  //     DETOUR_CREST_OVERLAP_MIN world を超えて重なる。
+  //
+  // 経路 2 は経路 1 の穴を埋める。 peak 点は crest の端点 1 個しか見ないため、 peak X を
+  // 60 world 超ずらすだけで crest が同 Y で完全に重なっていても素通りする (dragon #890、
+  // interactive-kpi-dashboard で `side: "left"` が crest y=78 の重なりを残したまま
+  // validator を通過した実例)。 crest を区間として比較すればこの穴が閉じる。
+  //
+  // crest 区間 = peak Y と同じ高さの水平 segment 全て。 最長の 1 本だけを持つと、 同じ高さに
+  // crest が 2 本ある形 (段差を挟んで戻る折れ線) で短い方の重なりを見落とす。 逆に全区間を
+  // min/max で 1 本に丸めると、 離れた 2 本の間の隙間まで重なり扱いになる。 区間の列として
+  // 持ち、 列同士の全組合せで重なりを見る。 水平 segment を持たない detour (斜めの折れ線等)
+  // は peak 点に縮退させ、 経路 1 と同じ判定に落ちる。
+  //
+  // 発火 0 = 通常状態 or detour 不在、 発火 = 複数 detour path が同 obstacle 上で
+  // Y 分離されずに描画される regression 症状。
+  // ───────────────────────────────────────────────────────────
+  {
+    interface DetourInfo {
+      edgeId: string;
+      peakX: number;
+      peakY: number;
+      /** peak Y と同じ高さの水平 crest 区間の列。 水平 segment 不在なら peak 点 1 個に縮退。 */
+      crests: ReadonlyArray<{ minX: number; maxX: number }>;
+      direction: "up" | "down"; // 山 (up) or 谷 (down)
+    }
+    /**
+     * peak Y と同じ高さの水平 crest 区間を全て返す。
+     *
+     * 直線 (L) はそのまま判定するが、 曲線 (Q / C) は端点を結ぶ弦しか分からないため、 制御点も
+     * 同じ高さにある場合だけ「真っ直ぐな水平線」 として扱う。 弦だけを見ると、 端点が同じ高さで
+     * 途中が大きく膨らむ曲線を水平線と誤認する (実測 = `Q 250 300 400 100` の弦は y100 の水平線
+     * に見えるが、 実曲線は中点で y200 まで垂れる)。
+     *
+     * 曲線の X 区間は端点の範囲で近似する。 制御点 X が端点の外にあると曲線は端点より外へ張り出す
+     * (実測 = `Q 1000 100 400 100` は t=0.6 で x=640 まで届く) ため、 張り出した分の重なりは
+     * 見落とす。 端点の範囲は必ず実際の到達範囲の部分集合なので、 見落とす方向にしか外れない
+     * = 重なりを報告した時それは必ず実在する。 実 catalog (442 edge / Q 144 件) に端点も制御点も
+     * 同じ高さの曲線は 0 件で、 張り出しを厳密に求める計算は現状どの図も通らない。
+     */
+    const crestSpans = (
+      segs: ReadonlyArray<{
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+        cmd: "L" | "Q" | "C";
+        ctrl?: ReadonlyArray<{ x: number; y: number }>;
+      }>,
+      peakY: number,
+    ): Array<{ minX: number; maxX: number }> => {
+      const out: Array<{ minX: number; maxX: number }> = [];
+      for (const s of segs) {
+        if (Math.abs(s.y1 - s.y2) > 1) continue;
+        if (Math.abs(s.y1 - peakY) > 1) continue;
+        if (s.cmd !== "L" && !(s.ctrl ?? []).every((c) => Math.abs(c.y - peakY) <= 1)) continue;
+        out.push({ minX: Math.min(s.x1, s.x2), maxX: Math.max(s.x1, s.x2) });
+      }
+      return out;
+    };
+    const detours: DetourInfo[] = [];
+    for (const e of laid.edges) {
+      const segs = extractPathSegments(e.d);
+      if (segs.length < 3) continue;
+      // 全 point 列 (segments の x1,y1 + 最終 x2,y2) を取得
+      const points: Array<{ x: number; y: number }> = [];
+      points.push({ x: segs[0]!.x1, y: segs[0]!.y1 });
+      for (const s of segs) points.push({ x: s.x2, y: s.y2 });
+      const startY = points[0]!.y;
+      const endY = points[points.length - 1]!.y;
+      // 中間 point の中で Y 極端値を探す (start/end 以外)
+      let peakUp: { x: number; y: number } | null = null; // 上方 detour = 最小 Y
+      let peakDown: { x: number; y: number } | null = null; // 下方 detour = 最大 Y
+      for (let i = 1; i < points.length - 1; i++) {
+        const p = points[i]!;
+        if (p.y < Math.min(startY, endY) - 4) {
+          if (!peakUp || p.y < peakUp.y) peakUp = p;
+        }
+        if (p.y > Math.max(startY, endY) + 4) {
+          if (!peakDown || p.y > peakDown.y) peakDown = p;
+        }
+      }
+      for (const [peak, direction] of [
+        [peakUp, "up"],
+        [peakDown, "down"],
+      ] as const) {
+        if (!peak) continue;
+        const spans = crestSpans(segs, peak.y);
+        detours.push({
+          edgeId: e.id,
+          peakX: peak.x,
+          peakY: peak.y,
+          crests: spans.length > 0 ? spans : [{ minX: peak.x, maxX: peak.x }],
+          direction,
+        });
+      }
+    }
+    // 同方向 pair で「peak X が ±60 world」 or 「crest 区間が重なる」 かつ
+    // peak Y 差 < DETOUR_SLOT_GAP を検知。 1 pair につき 1 件だけ報告する。
+    const OBSTACLE_X_OVERLAP = 60;
+    for (let i = 0; i < detours.length; i++) {
+      const a = detours[i]!;
+      for (let j = i + 1; j < detours.length; j++) {
+        const b = detours[j]!;
+        if (a.direction !== b.direction) continue;
+        if (a.edgeId === b.edgeId) continue;
+        const yDiff = Math.abs(a.peakY - b.peakY);
+        if (yDiff >= DETOUR_SLOT_GAP) continue;
+        const nearPeak = Math.abs(a.peakX - b.peakX) <= OBSTACLE_X_OVERLAP;
+        // crest 区間の列同士を全組合せで比較し、 最も長く重なる組を採る。
+        let overlap = Number.NEGATIVE_INFINITY;
+        for (const ca of a.crests) {
+          for (const cb of b.crests) {
+            const o = Math.min(ca.maxX, cb.maxX) - Math.max(ca.minX, cb.minX);
+            if (o > overlap) overlap = o;
+          }
+        }
+        const crestOverlap = overlap > DETOUR_CREST_OVERLAP_MIN;
+        if (!nearPeak && !crestOverlap) continue;
+        const reason = nearPeak
+          ? `peak X 差 ${Math.abs(a.peakX - b.peakX).toFixed(1)} world`
+          : `crest 区間の重なり ${overlap.toFixed(1)} world`;
+        push(
+          "detour-slot-distinct",
+          `edge "${a.edgeId}" と "${b.edgeId}" が同 obstacle を ${a.direction === "up" ? "上方" : "下方"} detour (${reason})、 peak Y 差 ${yDiff.toFixed(1)} world が spec ${DETOUR_SLOT_GAP} 未満 (path 重なり)`,
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 63: arrow-endpoint-center (CAR-422 positive-check)
+  //
+  // 判定 = arrow 終点 が終点 node の toSide 辺中央 (±ARROW_ENDPOINT_CENTER_TOL) に
+  // 収束しているか。
+  //
+  // Axis 8 (arrow-endpoint-anchoring) は「node bbox 縁に沿っているか / 内側 or 遠すぎ」
+  // を判定するが、 本 axis は「その側の辺の 4 隅 (角) に近接していないか」 を判定する。
+  // 4 隅 に矢頭 が刺さると 2 辺 のどちら由来か視覚判別困難、 中央着地が正しい。
+  //
+  // 対象 = 終点 (edge path 最終 point) のみ、 始点は fan-out で意図的に分散する場合が
+  // あるため対象外 (fan-origin-single-point axis で別軸判定)。
+  // ───────────────────────────────────────────────────────────
+  {
+    for (const e of laid.edges) {
+      const segs = extractPathSegments(e.d);
+      if (segs.length === 0) continue;
+      const toNode = nodeById.get(e.to);
+      if (!toNode) continue;
+      const end = { x: segs[segs.length - 1]!.x2, y: segs[segs.length - 1]!.y2 };
+      // toSide 辺中央を計算
+      let sideCenterX = toNode.cx;
+      let sideCenterY = toNode.cy;
+      switch (e.toSide) {
+        case "top":
+          sideCenterY = toNode.cy - toNode.h / 2;
+          break;
+        case "bottom":
+          sideCenterY = toNode.cy + toNode.h / 2;
+          break;
+        case "left":
+          sideCenterX = toNode.cx - toNode.w / 2;
+          break;
+        case "right":
+          sideCenterX = toNode.cx + toNode.w / 2;
+          break;
+      }
+      // toSide が horizontal 側 (left/right) = Y 距離、 vertical 側 (top/bottom) = X 距離で判定
+      const isHorizontalSide = e.toSide === "left" || e.toSide === "right";
+      const centerDist = isHorizontalSide
+        ? Math.abs(end.y - sideCenterY)
+        : Math.abs(end.x - sideCenterX);
+      // 辺の半分 - tolerance = 4 隅 判定閾値
+      const halfSide = isHorizontalSide ? toNode.h / 2 : toNode.w / 2;
+      const cornerZone = halfSide - ARROW_ENDPOINT_CENTER_TOL;
+      if (centerDist > cornerZone && cornerZone > 0) {
+        push(
+          "arrow-endpoint-center",
+          `edge "${e.id}" 終点 (${end.x.toFixed(0)},${end.y.toFixed(0)}) が node "${e.to}" toSide=${e.toSide} 辺中央 (${sideCenterX.toFixed(0)},${sideCenterY.toFixed(0)}) から ${centerDist.toFixed(1)} world 離れ、 4 隅 zone 判定 (許容 ${cornerZone.toFixed(1)})`,
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 64: lane-border-clearance (CAR-422 positive-check)
+  //
+  // 判定 = edge-label bbox の左右端が「その label 所属 edge が発着する lane 以外」 の
+  // lane border (lane.x / lane.x+width) を貫通していないか。
+  //
+  // edge-label が lane 境界線と交差すると label が「別 lane に侵入している」 ように
+  // 見えて論理誤読を招く。 発着 lane 以外の lane border と bbox が overlap する場合、
+  // LANE_BORDER_CLEARANCE_TOL の余裕がなければ fail。
+  //
+  // 例外 = edge 発着 node の lane (from lane / to lane) 内は判定対象外、 その 2 lane 内なら
+  // label が lane 縁近くにあっても違和感なし。
+  // ───────────────────────────────────────────────────────────
+  {
+    for (const e of laid.edges) {
+      if (!hasRenderedLabel(e)) continue;
+      const fromNode = nodeById.get(e.from);
+      const toNode = nodeById.get(e.to);
+      // from / to どちらも解決不能な edge は「所属 lane 不明」 で判定対象外
+      // (dangling edge = 通常 validate 側で検知される構造破綻、 本 axis で二重発火しない)
+      if (!fromNode && !toNode) continue;
+      const allowedLanes = new Set<string>();
+      if (fromNode) allowedLanes.add(fromNode.lane);
+      if (toNode) allowedLanes.add(toNode.lane);
+      // label bbox 復元 (Axis 59 と同 logic、 lane border 判定は x 軸のみ使うので高さ不要)
+      const boxW = computeLabelBoxW(e.label, e.sub);
+      const anchor = e.labelAnchor;
+      const boxLeftX = anchor === "start" ? 0 : anchor === "end" ? -boxW : -boxW / 2;
+      const bx = e.labelX + boxLeftX;
+      const bxRight = bx + boxW;
+      for (const lane of laid.lanes) {
+        if (allowedLanes.has(lane.id)) continue;
+        const laneLeft = lane.x;
+        const laneRight = lane.x + lane.width;
+        // border 貫通 = bbox が border 線と交差 (border 左端 と bbox 左/右端 の関係)
+        // 左 border 貫通 = bx < laneLeft && bxRight > laneLeft + TOL
+        // 右 border 貫通 = bx < laneRight - TOL && bxRight > laneRight
+        const crossesLeft =
+          bx < laneLeft - LANE_BORDER_CLEARANCE_TOL &&
+          bxRight > laneLeft + LANE_BORDER_CLEARANCE_TOL;
+        const crossesRight =
+          bx < laneRight - LANE_BORDER_CLEARANCE_TOL &&
+          bxRight > laneRight + LANE_BORDER_CLEARANCE_TOL;
+        if (crossesLeft || crossesRight) {
+          push(
+            "lane-border-clearance",
+            `edge "${e.id}" label bbox (${bx.toFixed(0)}..${bxRight.toFixed(0)}) が非発着 lane "${lane.id}" (${laneLeft.toFixed(0)}..${laneRight.toFixed(0)}) の ${crossesLeft ? "左" : "右"} border を貫通`,
+          );
+          break; // 1 edge 1 発火に留める
+        }
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 65: row-gap-uniform (CAR-422 positive-check)
+  //
+  // 判定 = 同 stack index を持つ node 群を cx 昇順に並べたとき、 隣接 node cx 差
+  // (= gap) の max - min が ROW_GAP_VARIANCE_TOL 以下か。
+  //
+  // Axis 57 (row-alignment) は cy 揃いを見るが、 本 axis は「横方向 gap の均一性」 を
+  // 見る positive-check。 gap が片寄っている layout は「意図的分割」 or 「engine layout
+  // 破綻」 のどちらかで、 通常 diagram は前者が発生しない前提で発火 = 後者検知。
+  //
+  // 対象 = 同 stack index 内 3 node 以上 (2 node なら gap 1 個で variance 概念なし)。
+  // spacer / lifeline は cx 差を意図的に持つので判定対象外。
+  // ───────────────────────────────────────────────────────────
+  {
+    const byStack = new Map<number, LaidDiagram["nodes"]>();
+    for (const n of laid.nodes) {
+      if (n.id.endsWith("-spacer") || /^s\d+-/.test(n.id)) continue;
+      const list = byStack.get(n.stack) ?? [];
+      list.push(n);
+      byStack.set(n.stack, list);
+    }
+    // lane diagram では node.cx が lane 中心に固定されるため、 node が同じ lane 集合に載る
+    // stack はすべて同一の cx 列を持つ。 stack ごとに報告すると同じ違反が stack 数だけ
+    // 重複計上されるので、 cx 列が既出なら 1 度目のみ報告する。
+    const reportedCxSignatures = new Set<string>();
+    for (const [stack, group] of byStack) {
+      if (group.length < 3) continue;
+      const sorted = [...group].sort((a, b) => a.cx - b.cx);
+      const gaps: number[] = [];
+      for (let i = 1; i < sorted.length; i++) {
+        gaps.push(sorted[i]!.cx - sorted[i - 1]!.cx);
+      }
+      const maxGap = Math.max(...gaps);
+      const minGap = Math.min(...gaps);
+      const variance = maxGap - minGap;
+      if (variance > ROW_GAP_VARIANCE_TOL) {
+        const cxSignature = sorted.map((n) => n.cx.toFixed(3)).join(",");
+        if (reportedCxSignatures.has(cxSignature)) continue;
+        reportedCxSignatures.add(cxSignature);
+        push(
+          "row-gap-uniform",
+          `stack=${stack} 内 node 間 gap variance ${variance.toFixed(1)} world が spec ${ROW_GAP_VARIANCE_TOL} 超過 (min=${minGap.toFixed(0)} max=${maxGap.toFixed(0)})`,
+        );
+      }
+    }
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // Axis 66: column-gap-uniform (CAR-422 positive-check)
+  //
+  // 判定 = 同 lane 内 node 群を cy 昇順に並べたとき、 隣接 node の端間 gap
+  // (下の node の上端 - 上の node の下端) の max - min が COLUMN_GAP_VARIANCE_TOL 以下か。
+  //
+  // Axis 58 (column-alignment) は cx 揃いを見るが、 本 axis は「縦方向 gap の均一性」 を
+  // 見る positive-check。 縦積み layout で gap が不均等なら engine layout 破綻疑い。
+  //
+  // 端間 gap で測る理由 (Issue #202)。
+  // 初版は cy 差 (中心間距離) を gap として扱っていた。 しかし node 高さは kind ごとに
+  // 異なるため、 中心間距離は端間 gap が完全に均一でも node 高さ差の分だけばらつく。
+  // 実測 = scene-nft-mint (node 高さ 220 / 280 / 320) で端間 variance 0、 中心間 variance 50。
+  // engine が制御しているのは端間 gap であり、 検査もそれに合わせる。
+  //
+  // 対象 = 同 lane 内 3 node 以上。 spacer / lifeline は cy 差を意図的に持つので対象外。
+  // ───────────────────────────────────────────────────────────
+  {
+    const byLane = new Map<string, LaidDiagram["nodes"]>();
+    for (const n of laid.nodes) {
+      if (n.id.endsWith("-spacer") || /^s\d+-/.test(n.id)) continue;
+      const list = byLane.get(n.lane) ?? [];
+      list.push(n);
+      byLane.set(n.lane, list);
+    }
+    for (const [laneId, group] of byLane) {
+      if (group.length < 3) continue;
+      const sorted = [...group].sort((a, b) => a.cy - b.cy);
+      const gaps: number[] = [];
+      for (let i = 1; i < sorted.length; i++) {
+        const prev = sorted[i - 1]!;
+        const cur = sorted[i]!;
+        gaps.push(cur.cy - cur.h / 2 - (prev.cy + prev.h / 2));
+      }
+      const maxGap = Math.max(...gaps);
+      const minGap = Math.min(...gaps);
+      const variance = maxGap - minGap;
+      if (variance > COLUMN_GAP_VARIANCE_TOL) {
+        push(
+          "column-gap-uniform",
+          `lane "${laneId}" 内 node 間の端間 gap variance ${variance.toFixed(1)} world が spec ${COLUMN_GAP_VARIANCE_TOL} 超過 (min=${minGap.toFixed(0)} max=${maxGap.toFixed(0)})`,
+        );
+      }
+    }
+  }
+
+  return {
+    diagramId: diag.id,
+    ok: violations.filter((v) => v.severity === "error").length === 0,
+    violations,
+    counts,
+    profile,
+    skippedAxes,
+  };
+}
+
+/**
+ * 複数 diagram を sweep して合計 report を返す。
+ */
+export interface SweepReport {
+  total: number;
+  pass: number;
+  fail: number;
+  reports: VisualValidationReport[];
+  totalCounts: Record<VisualAxis, number>;
+  /** Axis 47 / 48 meta 判定結果 (per-diagram でなく engine 全体) */
+  metaViolations: Violation[];
+  /** 検査した用途。 */
+  profile: ValidationProfile;
+  /** 用途によって見なかった軸。 `totalCounts` はこれらも 0 を返す。 */
+  skippedAxes: VisualAxis[];
+}
+
+export function visualValidateAll(diagrams: CdlDiagram[], opts?: ValidateOptions): SweepReport {
+  // Axis 52 用 = 各 diagram の validate 実行時間 (ms) を計測。 performance budget 超過検知。
+  const durations: number[] = [];
+  const reports = diagrams.map((d) => {
+    const start = Date.now();
+    const r = visualValidate(d, opts);
+    durations.push(Date.now() - start);
+    return r;
+  });
+  const fail = reports.filter((r) => !r.ok).length;
+  const totalCounts = emptyCounts();
+  for (const r of reports) {
+    for (const axis of Object.keys(r.counts) as VisualAxis[]) {
+      totalCounts[axis] += r.counts[axis];
+    }
+  }
+
+  // Axis 47/48/49/50/52 = engine meta 判定
+  const metaViolations = validateMetaAxes(totalCounts, diagrams, durations, reports);
+
+  return {
+    total: reports.length,
+    pass: reports.length - fail,
+    fail,
+    reports,
+    totalCounts,
+    profile: opts?.profile ?? "production",
+    skippedAxes: [...SKIPPED_AXES[opts?.profile ?? "production"]],
+    metaViolations,
+  };
+}
+
+/**
+ * Axis 47 axis-coverage-meta + Axis 48 axis-documentation-completeness の meta 判定。
+ *
+ * 47: catalog 全 diagram 走査後の totalCounts で「発火経路が 0 の axis」 = dead axis 検知。
+ *     dead axis = catalog に該当 diagram が無い or 判定 logic の bug、 gate として実効性なし。
+ *     ただし svg-injection-safety / migration-path-consistency 等 catalog に自然発火なしの
+ *     security / migration 系は dead 許容 (allowlist)。
+ *
+ * 48: 手で並べた `allAxes` の要素数が `EXPECTED_AXIS_COUNT` と一致するかだけを見る。
+ *     元は「全 axis が『Axis N: <name>』 コメントブロックを持つか」 を狙った軸だが、 実行時に
+ *     source を読めない (build 後は minified) ため、 実装は要素数の一致に留まる。
+ *     `VisualAxis` / `emptyCounts` / `allAxes` の 3 つが揃っているかは見ない (#381)。
+ */
+function validateMetaAxes(
+  totalCounts: Record<VisualAxis, number>,
+  diagrams: CdlDiagram[] = [],
+  durations: number[] = [],
+  reports: VisualValidationReport[] = [],
+): Violation[] {
+  const out: Violation[] = [];
+
+  // ─── Axis 49: fixture-drift-detection (catalog 全体の error / warn 分布 baseline drift) ───
+  // 判定 = 現状 catalog は全 axis error 0 が期待、 error > 0 なら drift。
+  // 過去にあった warn は許容、 error は絶対 0 が SSOT。
+  const totalErrors = reports.reduce(
+    (sum, r) => sum + r.violations.filter((v) => v.severity === "error").length,
+    0,
+  );
+  const KNOWN_ERROR_BUDGET = 1; // pattern-passthrough / pattern-hook の edge-node-cross 1 件を allowlist
+  if (totalErrors > KNOWN_ERROR_BUDGET) {
+    out.push({
+      axis: "fixture-drift-detection",
+      diagramId: "__meta__",
+      detail: `catalog 全 diagram error 総数 ${totalErrors} > KNOWN_ERROR_BUDGET ${KNOWN_ERROR_BUDGET}、 baseline drift`,
+      severity: "warn",
+    });
+  }
+
+  // ─── Axis 50: locale-parity (JA/EN docs sample 数 parity は per-engine 判定不可) ───
+  // 判定 = engine 内では diagram の locale field 有無を確認するのみ。 実際の JA/EN sample
+  // 数 parity は dragon side docs-samples-validate.test.ts が担当。
+  // 本 axis は 空 (engine 単体で判定材料なし)、 発火経路として先取り。
+
+  // ─── Axis 52: validate-performance-budget (validate 実行時間) ───
+  const PERF_BUDGET_PER_DIAGRAM_MS = 100;
+  const PERF_BUDGET_TOTAL_MS = 5000;
+  const overBudgetIdx = durations.findIndex((d) => d > PERF_BUDGET_PER_DIAGRAM_MS);
+  if (overBudgetIdx >= 0) {
+    const did = diagrams[overBudgetIdx]?.id ?? "?";
+    out.push({
+      axis: "validate-performance-budget",
+      diagramId: did,
+      detail: `diagram "${did}" validate ${durations[overBudgetIdx]}ms > ${PERF_BUDGET_PER_DIAGRAM_MS}ms budget`,
+      severity: "warn",
+    });
+  }
+  const totalDur = durations.reduce((s, d) => s + d, 0);
+  if (totalDur > PERF_BUDGET_TOTAL_MS) {
+    out.push({
+      axis: "validate-performance-budget",
+      diagramId: "__meta__",
+      detail: `visualValidateAll 全 diagram 累計 ${totalDur}ms > ${PERF_BUDGET_TOTAL_MS}ms budget`,
+      severity: "warn",
+    });
+  }
+
+  // Axis 47: dead axis 検知
+  // security / migration 系は自然発火なしを許容 (実データに XSS / migration 混入は稀)
+  const DEAD_ALLOWLIST: VisualAxis[] = [
+    // catalog で自然発火なしを許容する security / migration / performance / meta / dev-quality axis 群。
+    // 実 diagram に該当データ (XSS / migration list / oversized / broken doc) が混入するのが稀なため。
+    "node-visibility",
+    "edge-label-overlap",
+    "edge-label-proximity",
+    "text-readability",
+    "row-format",
+    "alignment",
+    "clearance",
+    "arrow-endpoint-anchoring",
+    "label-char-range",
+    "node-overlap",
+    "edge-crossing",
+    "edge-node-cross",
+    "edge-segment-orthogonality",
+    "label-inside-viewbox",
+    "lane-cx-consistency",
+    "row-vertical-spacing",
+    // 行を描かない種別に rows を書く形は稀。 正常な catalog では 0 件が期待値。
+    "rows-not-rendered",
+    // 正常な catalog は layout の出力をそのまま渡すので 0 件が期待値。 発火するのは
+    // 型どおりでない入力を作った時 (test の変異 等)。
+    "malformed-input",
+    // 正常な入力かつ検査側に欠陥が無ければ 0 件。
+    "validation-interrupted",
+    "group-boundary-clearance",
+    "node-vertical-clearance",
+    "lane-lane-gap",
+    "arrow-marker-clearance",
+    "grid-alignment",
+    "phase-layout-stability",
+    "responsive-viewport",
+    "accessibility-basics",
+    "animation-frame-integrity",
+    "i18n-cjk-detection",
+    "contrast-basics",
+    "print-media-compat",
+    "color-blind-safety",
+    "marker-gradient-def-integrity",
+    "subpixel-precision",
+    "dom-complexity-budget",
+    "reduced-motion-compat",
+    "touch-target-size",
+    "row-content-typing",
+    "terminal-safe-text",
+    "gpu-layer-efficiency",
+    "memory-budget",
+    "svg-injection-safety",
+    "seo-metadata-quality",
+    "bidi-hyphenation",
+    "structured-data-extraction",
+    "diagram-version-semver",
+    "migration-path-consistency",
+    "axis-coverage-meta",
+    "axis-documentation-completeness",
+    "fixture-drift-detection",
+    "locale-parity",
+    "validate-performance-budget",
+    "node-inside-viewbox",
+    "node-inside-lane",
+    "edge-inside-viewbox",
+    "lane-label-inside-viewbox",
+    "lane-label-overlap",
+    // CAR-421 positive-check axis 群 = catalog で「常に pass」 が正常状態、 発火 = 実データ異常。
+    // dead axis 判定は「発火 0 が異常 (= dead)」 の logic だが、 本 5 axis は発火 0 = 正常なので allowlist。
+    "row-alignment",
+    "column-alignment",
+    "edge-stubout-min",
+    "fan-origin-single-point",
+    // CAR-422 positive-check axis 群 = 同上、 catalog で発火 0 が正常。
+    "detour-slot-distinct",
+    "arrow-endpoint-center",
+    "lane-border-clearance",
+    "row-gap-uniform",
+    "column-gap-uniform",
+  ];
+  const allAxes: VisualAxis[] = [
+    "node-visibility",
+    "edge-label-overlap",
+    "edge-label-proximity",
+    "text-readability",
+    "row-format",
+    "alignment",
+    "clearance",
+    "arrow-endpoint-anchoring",
+    "label-char-range",
+    "node-overlap",
+    "edge-crossing",
+    "edge-node-cross",
+    "edge-segment-orthogonality",
+    "label-inside-viewbox",
+    "lane-cx-consistency",
+    "row-vertical-spacing",
+    "group-boundary-clearance",
+    "node-vertical-clearance",
+    "lane-lane-gap",
+    "arrow-marker-clearance",
+    "grid-alignment",
+    "phase-layout-stability",
+    "responsive-viewport",
+    "accessibility-basics",
+    "animation-frame-integrity",
+    "i18n-cjk-detection",
+    "contrast-basics",
+    "print-media-compat",
+    "color-blind-safety",
+    "marker-gradient-def-integrity",
+    "subpixel-precision",
+    "dom-complexity-budget",
+    "reduced-motion-compat",
+    "touch-target-size",
+    "row-content-typing",
+    "terminal-safe-text",
+    "gpu-layer-efficiency",
+    "memory-budget",
+    "svg-injection-safety",
+    "seo-metadata-quality",
+    "bidi-hyphenation",
+    "structured-data-extraction",
+    "diagram-version-semver",
+    "migration-path-consistency",
+    "axis-coverage-meta",
+    "axis-documentation-completeness",
+    "fixture-drift-detection",
+    "locale-parity",
+    "validate-performance-budget",
+    "node-inside-viewbox",
+    "node-inside-lane",
+    "edge-inside-viewbox",
+    "lane-label-inside-viewbox",
+    "lane-label-overlap",
+    "row-alignment",
+    "column-alignment",
+    "edge-stubout-min",
+    "fan-origin-single-point",
+    "detour-slot-distinct",
+    "arrow-endpoint-center",
+    "lane-border-clearance",
+    "row-gap-uniform",
+    "column-gap-uniform",
+    "rows-not-rendered",
+    "malformed-input",
+    "validation-interrupted",
+  ];
+  for (const axis of allAxes) {
+    if (totalCounts[axis] === 0 && !DEAD_ALLOWLIST.includes(axis)) {
+      out.push({
+        axis: "axis-coverage-meta",
+        diagramId: "__meta__",
+        detail: `axis "${axis}" は catalog 全 diagram で発火 0 = dead axis 疑い`,
+        severity: "warn",
+      });
+    }
+  }
+
+  // Axis 48: 手で並べた `allAxes` の要素数が期待値と一致するか。
+  // `VisualAxis` 型との網羅性や重複は見ない = `allAxes` への追記漏れは捕まらない (#381)。
+  //
+  // **数は定数側 (`EXPECTED_AXIS_COUNT`) が正で、 この comment に書き写さない**。
+  // 以前は comment に 69、 定数に 68 と別の数が書かれており、 どちらが正か読めなかった。
+  //
+  // 削除済 = engine-meta 51 (mermaid-parity、 #366) / 軸 29 (svg-filter-integrity) /
+  // 軸 30 (neumorphism-shadow-budget、 どちらも #426 で主題の廃止に伴い削除)。
+  const EXPECTED_AXIS_COUNT = 66;
+  if (allAxes.length !== EXPECTED_AXIS_COUNT) {
+    out.push({
+      axis: "axis-documentation-completeness",
+      diagramId: "__meta__",
+      detail: `期待 axis 数 ${EXPECTED_AXIS_COUNT} vs 実装 ${allAxes.length} で不一致、 SSOT 文書化 drift`,
+      severity: "warn",
+    });
+  }
+
+  return out;
+}