@cardenelabs/cdl 0.5.0

package/src/layout/edges.ts

@@ -0,0 +1,2498 @@
+import type { CdlDiagram, CdlEdge, LaidEdge, LaidLane, LaidNode, Side } from "../types";
+import {
+  CLEARANCE_LABEL_LABEL,
+  CLEARANCE_NODE_LABEL,
+  CLEARANCE_PATH_LABEL,
+} from "./clearance-constants";
+import {
+  extractPathSegments,
+  flattenPathSegments,
+  segmentsCrossRect,
+  segmentsExcludingOwnPath,
+} from "./collisions";
+import {
+  computeLabelBBoxWorld,
+  computeLabelBoxW,
+  EDGE_STUB_OUT,
+  hasRenderedLabel,
+  labelInitClearance,
+  LANE_BORDER_CLEARANCE_TOL,
+  labelPathClearanceHorizontal,
+  labelPillH,
+  spreadWithMinimalShift,
+  PARALLEL_EDGE_BOW,
+  SYMMETRIC_PAIR_SHIFT,
+} from "./spec";
+import { DEFAULT_LABEL_MARGIN } from "./tokens";
+
+/** 縦 detour が obstacle の外側を通る時の余白 (world unit)。 */
+const VERTICAL_DETOUR_GAP = 50;
+/** 縦 detour の角の丸め半径 (world unit)。 */
+const VERTICAL_DETOUR_CORNER = 14;
+/** 縦 detour が source から曲がるまで直進する距離 (world unit)。 EDGE_STUB_OUT を上回る。 */
+const VERTICAL_DETOUR_EXIT = 45;
+
+/**
+ * 端点から進行方向へ進んだ時、 最初に当たる箱までの距離。 当たる箱が無ければ `Infinity`。
+ *
+ * 垂直に上がる (下がる) 線が走る Y 帯に掛からない箱は、 折れる位置がどこでも当たらないので
+ * 数えない。
+ *
+ * @param anchorX 折れる線が出る側の端点 X (起点なら `A.x`、 終点側なら `B.x`)
+ * @param dir 端点から折れる位置へ向かう向き (+1 で右、 -1 で左)
+ * @param verticalTop 垂直に走る区間の上端 Y
+ * @param verticalBottom 同じく下端 Y
+ */
+function nearestBoxDistance(
+  anchorX: number,
+  dir: 1 | -1,
+  verticalTop: number,
+  verticalBottom: number,
+  boxes: readonly Rect[],
+): number {
+  let nearest = Infinity;
+  for (const box of boxes) {
+    if (box.y + box.h <= verticalTop || box.y >= verticalBottom) continue;
+    // 進行方向で手前になる辺までの距離。 0 以下なら進行方向に無い
+    const near = dir === 1 ? box.x : box.x + box.w;
+    const dist = (near - anchorX) * dir;
+    if (dist <= 0) continue;
+    nearest = Math.min(nearest, dist);
+  }
+  return nearest;
+}
+
+/**
+ * 迂回 edge が折れる位置 = 端点と、 進行方向で最初に当たる箱の **中間** (#418)。
+ *
+ * 折れる位置を `EDGE_STUB_OUT` の固定値に置くと、 走る距離が長い edge ほど「箱を出た瞬間に
+ * 折れる」 見え方になり、 線が箱に貼り付く。 実測 = `swimlane` の戻り矢印は 1166 走るのに
+ * 折れ始めが 26 だった。
+ *
+ * 中間に置くと、 折れる線が箱からも隣の札からも同じだけ離れる。 端点に寄せる案 (固定 40) と
+ * 箱の限界まで離す案 (比で決めて手前で止める) の両方を実際に描いて比べ、 中間を採った
+ * (呼び出し側 user の判断)。
+ *
+ * 当たる箱は node と、 別 edge の札の両方を見る。 札を見ないと垂直の線が札を貫く。
+ *
+ * 下限は `EDGE_STUB_OUT` を割らない。 隙間が 80 未満だと中間が下限を下回るが、 そこは比を
+ * 使う前 (固定 40) と同じ位置なので従来の判断を変えない。
+ */
+function detourStub(
+  anchorX: number,
+  dir: 1 | -1,
+  verticalTop: number,
+  verticalBottom: number,
+  nodeBoxes: readonly Rect[],
+  avoidRects: readonly Rect[],
+): number {
+  const nearest = Math.min(
+    nearestBoxDistance(anchorX, dir, verticalTop, verticalBottom, nodeBoxes),
+    nearestBoxDistance(anchorX, dir, verticalTop, verticalBottom, avoidRects),
+  );
+  if (!Number.isFinite(nearest)) return EDGE_STUB_OUT;
+  return Math.max(EDGE_STUB_OUT, nearest / 2);
+}
+
+/**
+ * A → B の横線を塞ぐ node を全て返す。
+ *
+ * 1 個だけ避けると、 背の高い 2 個目を貫通する。 同じ行の node は行の高さを共有するので既定では
+ * 起きないが、 `n.h` を明示した node は行と独立に背が高くなる (Issue #229)。
+ */
+function horizontalDetourBlockers(
+  A: { x: number; y: number },
+  B: { x: number; y: number },
+  obstacles: LaidNode[],
+): LaidNode[] {
+  const minX = Math.min(A.x, B.x);
+  const maxX = Math.max(A.x, B.x);
+  return obstacles.filter((n) => {
+    const nLeft = n.cx - n.w / 2;
+    const nRight = n.cx + n.w / 2;
+    const nTop = n.cy - n.h / 2;
+    const nBottom = n.cy + n.h / 2;
+    return A.y >= nTop && A.y <= nBottom && nLeft < maxX && nRight > minX;
+  });
+}
+
+/**
+ * A → B の縦線を塞ぐ node を全て返す。 `routePath` と迂回列の割当が同じ判定を共有する。
+ *
+ * 1 個だけ避けると、 複数 node を跨ぐ edge が 2 個目を貫通する (Issue #211)。
+ */
+function verticalDetourBlockers(
+  A: { x: number; y: number },
+  B: { x: number; y: number },
+  obstacles: LaidNode[],
+): LaidNode[] {
+  const minY = Math.min(A.y, B.y);
+  const maxY = Math.max(A.y, B.y);
+  return obstacles.filter((n) => {
+    const nLeft = n.cx - n.w / 2;
+    const nRight = n.cx + n.w / 2;
+    const nTop = n.cy - n.h / 2;
+    const nBottom = n.cy + n.h / 2;
+    return A.x >= nLeft && A.x <= nRight && nTop < maxY && nBottom > minY;
+  });
+}
+
+/** 縦 detour が blocker のどちら側を回るか。 既定は右。 */
+type DetourSide = "left" | "right";
+
+/** 縦 detour が blocker の外側を通る列の X。 side に応じて左右どちらかに置く。 */
+function detourColumnFor(blockers: LaidNode[], side: DetourSide): number {
+  return side === "left"
+    ? Math.min(...blockers.map((n) => n.cx - n.w / 2)) - VERTICAL_DETOUR_GAP
+    : Math.max(...blockers.map((n) => n.cx + n.w / 2)) + VERTICAL_DETOUR_GAP;
+}
+
+export function layoutEdges(diag: CdlDiagram, nodes: LaidNode[], lanes: LaidLane[] = []): LaidEdge[] {
+  // labelMargin = author 追加余白、 path 中点 → label の垂直距離に加算 (上向き label は -=、 下向きは +=)。
+  // viewport.labelMargin 明示時はその差分、 未指定なら viewport.gap → DEFAULT_LABEL_MARGIN の順で fallback。
+  const labelMarginExtra =
+    (diag.viewport?.labelMargin ?? diag.viewport?.gap ?? DEFAULT_LABEL_MARGIN) - DEFAULT_LABEL_MARGIN;
+  const nmap = new Map(nodes.map((n) => [n.id, n]));
+  const lmap = new Map(lanes.map((l) => [l.id, l]));
+
+  // canvas pivot 新 spec (dragon canvas pivot spec §layout-role-conversion)。
+  // posX1 / posY1 / posX2 / posY2 全て set 済 edge は「user が固定した絶対 path」 = 直線 path
+  // (posX1, posY1) → (posX2, posY2) を最終 path とする。 label 位置は path 中点、 fromSide / toSide
+  // は自動推定 (from/to node 中心対比)、 routing 再計算 skip。 catalog 100+ backward compat は
+  // 全 4 field 未指定なら従来通り orthogonal L 字 routing で保証。
+  const positionedEdges: LaidEdge[] = [];
+  const autoEdges: typeof diag.edges = [];
+  for (const e of diag.edges) {
+    if (e.posX1 !== undefined && e.posY1 !== undefined && e.posX2 !== undefined && e.posY2 !== undefined) {
+      const from = nmap.get(e.from);
+      const to = nmap.get(e.to);
+      if (!from) throw new Error(`cdl layout: edge "${e.id}" の from "${e.from}" が node に無い`);
+      if (!to) throw new Error(`cdl layout: edge "${e.id}" の to "${e.to}" が node に無い`);
+      const { fromSide, toSide } = inferSides(from, to, e.side);
+      const midX = (e.posX1 + e.posX2) / 2;
+      const midY = (e.posY1 + e.posY2) / 2;
+      positionedEdges.push({
+        ...e,
+        d: `M ${e.posX1} ${e.posY1} L ${e.posX2} ${e.posY2}`,
+        fromSide,
+        toSide,
+        labelX: midX + (e.labelOffsetX ?? 0),
+        labelY: midY + (e.labelOffsetY ?? 0),
+        labelAnchor: "middle",
+      });
+    } else {
+      autoEdges.push(e);
+    }
+  }
+
+  const prepared = autoEdges.map((e) => {
+    const from = nmap.get(e.from);
+    const to = nmap.get(e.to);
+    if (!from) throw new Error(`cdl layout: edge "${e.id}" の from "${e.from}" が node に無い`);
+    if (!to) throw new Error(`cdl layout: edge "${e.id}" の to "${e.to}" が node に無い`);
+    const { fromSide, toSide } = inferSides(from, to, e.side);
+    return { e, from, to, fromSide, toSide };
+  });
+
+  // 同 from node から複数 target へ向かう edges を方角別に分散
+  const byFromNode = new Map<string, typeof prepared>();
+  for (const p of prepared) {
+    if (p.e.side) continue;
+    const list = byFromNode.get(p.e.from) ?? [];
+    list.push(p);
+    byFromNode.set(p.e.from, list);
+  }
+  for (const list of byFromNode.values()) {
+    if (list.length <= 1) continue;
+    distributeBySides(list);
+  }
+
+  // CAR-429 (CAR-426-B) ... 全 edge の起点 / 終点 / L 字 corner は node 辺 Y 中央固定 (offset=0 SSOT)。
+  // 旧 fan-in / fan-out / parallel の sidepoint 分散 (±60/±120) は削除済で、
+  // path routing (d 属性) は offset=0 固定で描画される (視覚的に起点認識明確化)。
+  //
+  // CAR-430 ... label 位置の parallel / fan-in / fan-out 分散を本 file 内で完結させる SSOT。
+  // 旧 label-shift.ts の 16 方向 × 26 段階全探索を削除、 edges.ts routePath() が返す init 位置に
+  // parallel offset を加算して最終 label 位置とする 単一権限 の設計。
+  //
+  // 分散の phase order (idx 0 の edge は offset 0 で init 位置維持)。
+  //   1. parallel (同 from + 同 to + 同 fromSide + 同 toSide) ... 最強制、 全 idx 分散
+  //   2. fan-in (同 to のみ、 parallel でない) ... to の入口が同じ = label 集中しやすい
+  //   3. fan-out (同 from のみ、 parallel でない) ... from の出口が同じ = label 集中しやすい
+
+  // parallel / fan group 検出 + label offset 計算。
+  const labelOffsetsByEdgeId = new Map<string, { dx: number; dy: number }>();
+  // 同じ節の組を結ぶ辺は、 向きも側も見ずに 1 つの group にする (#372)。 label は向きに関係なく
+  // 同じ帯に落ちるため、 向きごとに分けると帯どうしが独立に中心を取って衝突する。
+  const parallelKey = (p: (typeof prepared)[number]) =>
+    p.e.from < p.e.to ? `${p.e.from}::${p.e.to}` : `${p.e.to}::${p.e.from}`;
+  const byParallel = new Map<string, typeof prepared>();
+  for (const p of prepared) {
+    const key = parallelKey(p);
+    const list = byParallel.get(key) ?? [];
+    list.push(p);
+    byParallel.set(key, list);
+  }
+  // parallel 分散は Y 軸のみ。 CAR-636 で fan-out / fan-in は Y shift ではなく Y 揃え + X 分散に
+  // 転換した (X 方向は下部 FAN_LABEL_GAP=20 で管理)。
+  //
+  // 分散量の決め方は #372 で「group の中心から ± 一定幅」 から「自分の線の上から最小移動」 に
+  // 変えた。 一定幅は本数と最大 pill 高だけで決まるため、 線ごとに高さが違う図で動かす必要の
+  // ない label まで動かし、 向きの違う group どうしの帯が衝突していた。 実装は routing 後の
+  // `spreadParallelLabels`。
+  // CAR-472 SSOT ... fan-in / fan-out の pre-check。 target / source が同じでも path routing pattern
+  // (horizontal straight / horizontal blocking detour / vertical) が edge 毎に異なるなら、
+  // label は自動的に別 Y region に配置されるため fan offset は不要 (むしろ SSOT clearance を破る)。
+  //
+  // routing pattern 予測 = obstacle 検出のみ実施 (完全 routePath 呼出は expensive)。
+  // horizontal straight vs horizontal detour の差は Y で 100 world+ (detourGap 50 + labelHalfH 18 +
+  // clearance 22 の合算)、 CAR-636 fan Y 揃え SSOT では pattern 分裂 group は fan dispersion 全体
+  // skip (X sweep も含めて base 位置維持) することで label 集中の混乱を避ける。
+  const detectsBlockingObstacle = (p: (typeof prepared)[number]): boolean => {
+    if (p.e.style === "dotted-flow") return false;
+    const from = p.from;
+    const to = p.to;
+    const horizontalPair =
+      (p.fromSide === "right" && p.toSide === "left") ||
+      (p.fromSide === "left" && p.toSide === "right");
+    const verticalPair =
+      (p.fromSide === "bottom" && p.toSide === "top") ||
+      (p.fromSide === "top" && p.toSide === "bottom");
+    const A = sidePoint(from, p.fromSide);
+    const B = sidePoint(to, p.toSide);
+    if (horizontalPair && Math.abs(A.y - B.y) < 1) {
+      const minX = Math.min(A.x, B.x);
+      const maxX = Math.max(A.x, B.x);
+      return nodes.some((n) => {
+        if (n.id === from.id || n.id === to.id) return false;
+        const nLeft = n.cx - n.w / 2;
+        const nRight = n.cx + n.w / 2;
+        const nTop = n.cy - n.h / 2;
+        const nBottom = n.cy + n.h / 2;
+        return A.y >= nTop && A.y <= nBottom && nLeft < maxX && nRight > minX;
+      });
+    }
+    if (verticalPair && Math.abs(A.x - B.x) < 1) {
+      const minY = Math.min(A.y, B.y);
+      const maxY = Math.max(A.y, B.y);
+      return nodes.some((n) => {
+        if (n.id === from.id || n.id === to.id) return false;
+        const nLeft = n.cx - n.w / 2;
+        const nRight = n.cx + n.w / 2;
+        const nTop = n.cy - n.h / 2;
+        const nBottom = n.cy + n.h / 2;
+        return A.x >= nLeft && A.x <= nRight && nTop < maxY && nBottom > minY;
+      });
+    }
+    return false;
+  };
+  // (a) parallel = 同 (from, to, fromSide, toSide) 群 (2+ 本) を y 軸で分散。
+  //
+  // 分散方向 = y 軸統一 (path 中心 y との差)。 vertical pair でも label は path 中心と同 x で
+  // y ずらして「path 沿い」 に配置する方が視覚的関連が強い (旧 fan-in / fan-out logic 相当)。
+  // x 軸分散 (path 左右) は「path 中心線から離れて浮遊」 見えするため採用しない。
+  //
+  // 実際の分散量と対象は routing 後に決める (`spreadParallelLabels`)。 fan-in / fan-out は
+  // 実際に分散された label だけを除外する = 辺の本数だけで除外すると、 label を持たない
+  // 逆向きの辺を 1 本足しただけで無関係な fan の分散が止まる。
+  const parallelGroupedIds = new Set<string>();
+  for (const list of byParallel.values()) {
+    if (list.length < 2) continue;
+    for (const p of list) parallelGroupedIds.add(p.e.id);
+  }
+  const distributedInParallel = new Set<string>();
+  // CAR-472 SSOT ... fan-in / fan-out 共通の分散判定。 group 内 edge の routing pattern (obstacle 有無)
+  // が分裂しているなら fan offset を skip、 統一されているなら fan dispersion を適用。
+  // pattern 分裂 = label が既に空間分離済 (obstacle detour で Y 100 world+ ずれる) のため
+  // 追加 offset は不要 (SSOT 実距離を破るだけ)。
+  //
+  // 実装変遷 SSOT (時系列)。
+  //   - CAR-430 = ±FAN_STEP/2 の対称 Y shift (centeredOffset) で fan-out group を上下分散、
+  //     pill 下端が path を跨ぐ regression 発生 (SSOT LABEL_TO_PATH_CLEARANCE 破り)。
+  //   - CAR-602 = 「path 上方向 -i * FAN_STEP の階段 shift」 に変更、 idx=0 base + idx≥1 上方階段。
+  //     pill 貫通は解消したが、 同 group 内で pill 中央 Y が i * FAN_STEP world 差の階段状視覚に
+  //     なり user 主観「label 高さが違う」 症状発生 (extends label = path 上 16 world / aggregates
+  //     label = path 上 56 world = 40 world 差)。
+  //   - CAR-636 = fan Y 揃え + X 分散 shift の SSOT に転換。 全 fan-out pill を dy=0 (Y 揃え、
+  //     pill 下端 → path = LABEL_TO_PATH_CLEARANCE) に統一、 pill 同士の X 重なりを検出したら
+  //     dx で右にずらして重なり回避する SSOT。 label 高さは group 全 pill 揃え、 X 方向のみ分散。
+  //
+  // 新 SSOT (CAR-636) の詳細。
+  //   1. 全 pill を dy=0 (base Y 位置維持) に固定 = fan-out group 内で pill 中央 Y が同一。
+  //   2. group 内の全 pill の base label X を (A.x + B.x) / 2 で近似計算 (horizontal straight /
+  //      L-shape 共通の label 中心 X 近似、 CAR-472 で obstacle 分裂 case は既に除外済のため
+  //      本 branch は straight or clean L-shape のみ担当)。
+  //   3. base X で昇順 sort、 sweep で pill R + FAN_LABEL_GAP > 次 pill L なら次 pill を dx で
+  //      右 shift、 shift しない pill (X 重なりなし) は dx=0 で base 位置維持。
+  //   4. 結果 = 全 pill Y 揃え + X 方向のみ最小限 shift で重なり回避、 idx=0 pill (最左 X) は
+  //      shift 0 で SSOT LABEL_TO_PATH_CLEARANCE 維持、 他 pill も全て同 Y (path から SSOT 距離)。
+  //
+  // CAR-636 fan dispersion X 分散の pill 間 gap (world unit)。 label bbox 端 + 20 world で
+  // 視覚的に明確な間隔を確保、 SSOT clearance-constants の CLEARANCE_NODE_LABEL (16 相当) より
+  // 大きめに設定 (pill 同士の可読性重視、 node 押し出しとは別軸の SSOT)。
+  const FAN_LABEL_GAP = 20;
+
+  // CAR-541 SSOT ... 同 node の対称対 edge (out + in が同 side) を上下配置ルールで分離。
+  //
+  // 対称対 = 同 node X の同 side S に out edge (from = X, effectiveFromSide = S) と in edge
+  // (to = X, effectiveToSide = S) が両方あるとき、 両 edge の endpoint が side 中央 (n.cy or n.cx)
+  // で完全に重なり stroke 色が混ざって色識別困難になる。 flowchart Review 左辺 (submit → review 入 +
+  // review → revise 出) が典型 case。
+  //
+  // CAR-532 の初版は 中央 ±16 world で両側 endpoint を単独 shift したが、 in edge の to 側だけ
+  // shift されると horizontal 直線 edge (A.y = B.y) が A.y != B.y に変化し L-corner branch に落ちて
+  // S 字風 corner (Q + L の折れ) が挿入される bug が発生 (fc-0 submit-review が典型)。
+  //
+  // CAR-541 fix = 上下配置ルール = 上側 (upper) edge = 動かさない、 下側 (lower) edge = 両 endpoint
+  // (from + to) を perpendicular 軸で +SYMMETRIC_PAIR_SHIFT (32 world) 平行 shift。 両端同量 shift
+  // なので直線 (A.y = B.y) の直進性 SSOT が保存され、 L-corner 挿入されない。
+  //
+  // 上下判定 = direction (out / in) 別に「相手 node の座標 min」 を集計、 min が小さい direction が
+  // upper、 大きい direction が lower。 座標軸 = horizontal side (left/right) → distant Y、
+  // vertical side (top/bottom) → distant X。 tie の場合は in edge を lower とする (CAR-532 test の
+  // out=Y-16, in=Y+16 挙動を out=Y, in=Y+32 に翻訳、 tie-break で決定論的挙動維持)。
+  //
+  // 発火条件 = 「同 node の同 side に out edge 1+ 本 と in edge 1+ 本 が両方存在」 のみ。 out 単独
+  // (fan-out) / in 単独 (fan-in) は対象外で従来通り CAR-489 endpoint grouping 維持。
+  //
+  // 判定 side = effectiveFromSide / effectiveToSide (back-detour 等 routing override 適用後)。
+  // 例 = stateMachine preset の retry (error → idle back-detour) は effectiveToSide = "top"、
+  // idle → loading (out) の effectiveFromSide = "right"、 side が別なので対称対不成立で分離しない。
+  const computeEffectiveSides = (p: (typeof prepared)[number]): { effFromSide: Side; effToSide: Side } => {
+    if (p.e.routing === "back-detour") {
+      return { effFromSide: "top", effToSide: "top" };
+    }
+    return { effFromSide: p.fromSide, effToSide: p.toSide };
+  };
+  const endpointOffsetsByEdgeId = new Map<string, { fromDx: number; fromDy: number; toDx: number; toDy: number }>();
+  {
+    // key = `${nodeId}::${side}` → out / in edge の分類
+    type Bucket = { outs: typeof prepared; ins: typeof prepared };
+    const buckets = new Map<string, Bucket>();
+    const getBucket = (nodeId: string, side: Side): Bucket => {
+      const key = `${nodeId}::${side}`;
+      let b = buckets.get(key);
+      if (!b) {
+        b = { outs: [], ins: [] };
+        buckets.set(key, b);
+      }
+      return b;
+    };
+    for (const p of prepared) {
+      const { effFromSide, effToSide } = computeEffectiveSides(p);
+      getBucket(p.e.from, effFromSide).outs.push(p);
+      getBucket(p.e.to, effToSide).ins.push(p);
+    }
+    // side に対する perpendicular 軸 = horizontal side (left/right) なら Y、 vertical side (top/bottom) なら X。
+    // distant 座標 = out edge (from = X) は target node、 in edge (to = X) は source node の
+    // perpendicular 軸 (Y or X) の値。 upper / lower 判定に使う。
+    const distantCoord = (p: (typeof prepared)[number], side: Side, direction: "out" | "in"): number => {
+      const isHorizontalSide = side === "left" || side === "right";
+      const distantNode = direction === "out" ? p.to : p.from;
+      return isHorizontalSide ? distantNode.cy : distantNode.cx;
+    };
+    // perpendicular 軸方向の shift 量 (world unit) を返す。
+    const shiftVector = (side: Side, amount: number): { dx: number; dy: number } =>
+      side === "left" || side === "right"
+        ? { dx: 0, dy: amount }
+        : { dx: amount, dy: 0 };
+    // 各 edge に対して「lower か」 を bucket 横断で 1 回だけ判定 (2 node 双方向対称対で
+    // 両 edge が別 bucket の "in" 側になり両方 lower 判定される二重 shift 誤動作を防ぐ)。
+    const edgeIsLower = new Map<string, boolean>();
+
+    // CAR-421 fan-origin 保存の優先化 (CAR-1560、 dragon PR #395 で検知した visual defect の
+    // root cause fix)。 対称対 shift 対象 edge が別 bucket で fan-out / fan-in の一員 (>= 2 outs
+    // or >= 2 ins on same node/side) だと、 CAR-541 の両 endpoint shift が fan-origin の Y 揃え
+    // を破り「1 node から複数線が別 origin で発散する」 視覚 defect を生む。
+    //
+    // 判定 = 同 direction (outs/ins) の候補群のうち fan 参加者を含む direction は shift 対象と
+    // しない。 両 direction とも fan 参加者を含む場合は従来 tie-break (distant coord / id min)
+    // に fallback、 両 direction とも fan 非参加なら従来通り distant coord min で判定。
+    //
+    // trade-off = fan 非参加 edge を shift することで 認証 側の fan-origin は保存されるが、
+    // メール 側の color mixing (overlap) は本 fix 経路では解消できない。 実 visual では arrow
+    // marker の向きで方向識別可能、 fan-origin 破損の方が user 目視で顕著な defect のため
+    // 保存優先とする。
+    const participatesInFanElsewhere = (p: (typeof prepared)[number], currentKey: string): boolean => {
+      const { effFromSide, effToSide } = computeEffectiveSides(p);
+      const fromKey = `${p.e.from}::${effFromSide}`;
+      const toKey = `${p.e.to}::${effToSide}`;
+      if (fromKey !== currentKey) {
+        const b = buckets.get(fromKey);
+        if (b && b.outs.length >= 2 && b.outs.some((x) => x.e.id === p.e.id)) return true;
+      }
+      if (toKey !== currentKey) {
+        const b = buckets.get(toKey);
+        if (b && b.ins.length >= 2 && b.ins.some((x) => x.e.id === p.e.id)) return true;
+      }
+      return false;
+    };
+    // stable sort で bucket 決定的処理順、 tie-break 用に edge id 昇順 min を採用。
+    const bucketKeys = Array.from(buckets.keys()).sort();
+    for (const key of bucketKeys) {
+      const b = buckets.get(key)!;
+      if (b.outs.length === 0 || b.ins.length === 0) continue;
+      const side = key.split("::")[1]! as Side;
+      // direction 別 distant 座標 min + tie-break 用 edge id min。 min が小さい direction = upper
+      // (shift 0)、 大きい direction = lower (+32)。 distant tie なら edge id 昇順 min で
+      // globally 決定論的 tie-break (2 node 双方向対称対で edge 双方が別 bucket の "in" 側になり
+      // 両方が lower 判定される二重 shift 誤動作を防ぐ)。
+      const outMin = Math.min(...b.outs.map((p) => distantCoord(p, side, "out")));
+      const inMin = Math.min(...b.ins.map((p) => distantCoord(p, side, "in")));
+      const outIdMin = b.outs.reduce((m, p) => (m < p.e.id ? m : p.e.id), b.outs[0]!.e.id);
+      const inIdMin = b.ins.reduce((m, p) => (m < p.e.id ? m : p.e.id), b.ins[0]!.e.id);
+      // CAR-1560 = fan-origin 保存の優先化。 本 bucket に fan-out (>= 2 outs on same node/side)
+      // or fan-in (>= 2 ins on same node/side) の参加者が含まれる場合、 CAR-541 shift を bucket
+      // 全体で skip する。
+      //
+      // asymmetric 経路 (「参加者を含まない direction を shift」) は当初検討したが、 3-node
+      // topology で shift が別 bucket に propagate して A::right pair separation を collapse
+      // させる regression scenario (codex adversarial review 検出) があるため採用しない。
+      //
+      // 現行 approach = bucket 全体 skip、 fan-origin は保存、 対称対 overlap (color mixing) は
+      // 該当 bucket で許容。 実 visual では arrow marker の向きで方向識別可能、 fan-origin 破損
+      // の方が user 目視で顕著な defect のため保存優先とする。
+      const outsInFan = b.outs.some((p) => participatesInFanElsewhere(p, key));
+      const insInFan = b.ins.some((p) => participatesInFanElsewhere(p, key));
+      if (outsInFan || insInFan) continue;
+      let inIsLower: boolean;
+      if (inMin !== outMin) {
+        inIsLower = inMin > outMin;
+      } else {
+        // distant tie → 直感 (2 node 双方向対称対) では out edge が上 / in edge が下 の
+        // CAR-532 test 相当挙動を維持したい。 これを bucket 横断で決定論的にするため、
+        // direction 別に edge id 昇順 min を取り「小さい方の direction が lower」 の rule で
+        // 双方向 pair 両 bucket で同じ edge を lower 判定させる (逆 side bucket でも同じ
+        // id-min 比較結果になるため 2 node bidirectional pair で常に同一 edge が lower 選択)。
+        inIsLower = inIdMin < outIdMin;
+      }
+      const lowerEdges = inIsLower ? b.ins : b.outs;
+      for (const p of lowerEdges) {
+        // 既に別 bucket で lower 判定済みなら skip (idempotent、 2 node 双方向 pair の場合
+        // 一方の edge が bucket A で lower + bucket B で upper と割れる正常経路で double shift 回避)。
+        if (edgeIsLower.get(p.e.id)) continue;
+        edgeIsLower.set(p.e.id, true);
+      }
+    }
+    // 全 edge を走査、 lower 判定 edge にのみ perpendicular 軸 +32 平行 shift (両 endpoint 同量) を割当。
+    for (const p of prepared) {
+      if (!edgeIsLower.get(p.e.id)) continue;
+      // shift 方向 = 判定 side (effectiveFromSide か effectiveToSide の対称対該当 side)。
+      // 対称対 bucket に含まれる時点で from-side or to-side が対称 side に一致する、 実装上は
+      // どちらの side でも perpendicular 軸方向は同じ (horizontal side → Y、 vertical side → X)。
+      const { effFromSide, effToSide } = computeEffectiveSides(p);
+      // fromSide bucket 側 or toSide bucket 側どちらで lower 判定されたかを再走査。 lower 判定した
+      // bucket key の side を採用する。
+      const fromKey = `${p.e.from}::${effFromSide}`;
+      const toKey = `${p.e.to}::${effToSide}`;
+      const fromBucket = buckets.get(fromKey);
+      const toBucket = buckets.get(toKey);
+      const fromBucketQualifies = fromBucket && fromBucket.outs.length > 0 && fromBucket.ins.length > 0;
+      const toBucketQualifies = toBucket && toBucket.outs.length > 0 && toBucket.ins.length > 0;
+      // 優先順位 = from side bucket で lower 判定 → fromSide の perpendicular 軸で shift。
+      // それ以外 (to side bucket only) → toSide の perpendicular 軸で shift。
+      // horizontal side / vertical side が両側で一致するのが通常 (対称対の性質)、 例外時は
+      // fromSide 側を優先する (from 起点で軸判定安定)。
+      const shiftSide: Side = fromBucketQualifies ? effFromSide : (toBucketQualifies ? effToSide : effFromSide);
+      const off = shiftVector(shiftSide, SYMMETRIC_PAIR_SHIFT);
+      const prev = endpointOffsetsByEdgeId.get(p.e.id) ?? { fromDx: 0, fromDy: 0, toDx: 0, toDy: 0 };
+      endpointOffsetsByEdgeId.set(p.e.id, {
+        fromDx: prev.fromDx + off.dx,
+        fromDy: prev.fromDy + off.dy,
+        toDx: prev.toDx + off.dx,
+        toDy: prev.toDy + off.dy,
+      });
+    }
+  }
+
+  /**
+   * 同じ通り道を上下に走る迂回のうち、 逆向きの方を blocker の反対側へ回す (Issue #211)。
+   *
+   * 迂回する列は「塞ぐ node の右端 + 余白」 で決まるので、 同じ node を避ける edge は必ず同じ列を
+   * 通り、 重なって 1 本の線に見える。
+   *
+   * 向きが揃っているならそれでよい。 幹線から順に降りる 1 本の線として読め、 読み手は分岐を辿れる。
+   * 分けると図幅が広がるだけで得るものがない (user 目視の判断、 2026-07-10)。
+   *
+   * 向きが混ざると読めない。 重なった 1 本の線の両端に矢印が付き、 どちらがどちらの経路か
+   * 判別できない。
+   *
+   * 同じ側で列だけ分けても解けない。 上へ戻る edge の戻り口は source より手前 (図の上) にあり、
+   * その水平部が下る edge の列と角を必ず横切る。 実測でも交差が 0 件から 2 件に増えた。
+   * 上下は反対側へ分けるしかない。
+   *
+   * 逆向き = 上へ戻る edge を左へ回す。 図は上から下へ読むので、 戻りの線を左に置くと流れと
+   * 逆行することが形からも分かる。 左が node で塞がっているなら回さず、 重なりを受け入れる。
+   */
+  /**
+   * 左へ回した経路と label が置けるか。 列の X だけでなく、 幹から列へ抜ける水平部と、
+   * 列の外側に出る label まで見る。
+   *
+   * 列そのものが空いていても、 水平部の高さに node があれば貫通する。 label は列よりさらに外に
+   * 出るため、 非発着 lane の枠線を跨ぐことがある (`lane-border-clearance`)。 後段の chain 伝搬が
+   * 受け取る obstacle は node と lane-label だけで、 lane の枠線は誰も見ていない。
+   *
+   * 角の丸めは無視して折れ線で近似する。 丸めは経路を内側へ寄せるだけで、 外へは出さない。
+   */
+  const leftRouteIsBlocked = (c: {
+    e: CdlEdge;
+    from: string;
+    to: string;
+    blockers: LaidNode[];
+    yDir: 1 | -1;
+    A: { x: number; y: number };
+    B: { x: number; y: number };
+  }): boolean => {
+    const columnX = detourColumnFor(c.blockers, "left");
+    const exitY = c.A.y + c.yDir * VERTICAL_DETOUR_EXIT;
+    const lastBlockerEdge =
+      c.yDir > 0
+        ? Math.max(...c.blockers.map((n) => n.cy + n.h / 2))
+        : Math.min(...c.blockers.map((n) => n.cy - n.h / 2));
+    const returnY = lastBlockerEdge + c.yDir * VERTICAL_DETOUR_GAP;
+    const segs = [
+      { x1: c.A.x, y1: c.A.y, x2: c.A.x, y2: exitY },
+      { x1: c.A.x, y1: exitY, x2: columnX, y2: exitY },
+      { x1: columnX, y1: exitY, x2: columnX, y2: returnY },
+      { x1: columnX, y1: returnY, x2: c.B.x, y2: returnY },
+      { x1: c.B.x, y1: returnY, x2: c.B.x, y2: c.B.y },
+    ];
+    const others = nodes.filter((n) => n.id !== c.from && n.id !== c.to);
+    if (others.some((n) => segmentsCrossRect(segs, nodeRect(n)))) return true;
+
+    if (!hasRenderedLabel(c.e)) return false;
+    const boxW = computeLabelBoxW(c.e.label, c.e.sub);
+    const boxH = labelPillH(c.e.sub);
+    const centerX = columnX - (labelPathClearanceHorizontal(c.e) + boxW / 2);
+    const pill = { x: centerX - boxW / 2, y: (exitY + returnY) / 2 - boxH / 2, w: boxW, h: boxH };
+    if (others.some((n) => rectsOverlap(pill, nodeRect(n)))) return true;
+
+    // 発着 lane の枠線は跨いでよい (visual-validate の lane-border-clearance と同一規約)。
+    const endpointLanes = new Set(
+      nodes.filter((n) => n.id === c.from || n.id === c.to).map((n) => n.lane),
+    );
+    return lanes.some(
+      (l) =>
+        !endpointLanes.has(l.id) &&
+        (crossesVerticalLine(pill, l.x) || crossesVerticalLine(pill, l.x + l.width)),
+    );
+  };
+
+  const assignDetourSides = (): Map<string, DetourSide> => {
+    const out = new Map<string, DetourSide>();
+    interface Candidate {
+      id: string;
+      e: CdlEdge;
+      yDir: 1 | -1;
+      blockers: LaidNode[];
+      from: string;
+      to: string;
+      A: { x: number; y: number };
+      B: { x: number; y: number };
+      minY: number;
+      maxY: number;
+    }
+    const corridors = new Map<string, Candidate[]>();
+
+    for (const p of prepared) {
+      // dotted-flow は経由 node を貫通する semantic なので迂回しない。
+      // back-detour は fromSide / toSide を top-top に強制するため縦 detour 分岐に落ちない。
+      if (p.e.style === "dotted-flow" || p.e.routing === "back-detour") continue;
+      const verticalPair =
+        (p.fromSide === "bottom" && p.toSide === "top") ||
+        (p.fromSide === "top" && p.toSide === "bottom");
+      if (!verticalPair) continue;
+
+      const off = endpointOffsetsByEdgeId.get(p.e.id) ?? { fromDx: 0, fromDy: 0, toDx: 0, toDy: 0 };
+      const Araw = sidePoint(p.from, p.fromSide);
+      const Braw = sidePoint(p.to, p.toSide);
+      const A = { x: Araw.x + off.fromDx, y: Araw.y + off.fromDy };
+      const B = { x: Braw.x + off.toDx, y: Braw.y + off.toDy };
+      if (Math.abs(A.x - B.x) >= 1) continue;
+
+      const obstacles = nodes.filter((n) => n.id !== p.from.id && n.id !== p.to.id);
+      const blockers = verticalDetourBlockers(A, B, obstacles);
+      if (blockers.length === 0) continue;
+
+      // 通り道 = 既定 (右) の列が一致する edge。 列は塞ぐ node から決まるので、 一致すれば同じ場所を走る。
+      const corridorKey = detourColumnFor(blockers, "right").toFixed(3);
+      const list = corridors.get(corridorKey) ?? [];
+      list.push({
+        id: p.e.id,
+        e: p.e,
+        yDir: B.y > A.y ? 1 : -1,
+        blockers,
+        from: p.from.id,
+        to: p.to.id,
+        A,
+        B,
+        minY: Math.min(A.y, B.y),
+        maxY: Math.max(A.y, B.y),
+      });
+      corridors.set(corridorKey, list);
+    }
+
+    for (const list of corridors.values()) {
+      if (list.length < 2) continue;
+
+      for (const c of list) {
+        if (c.yDir !== -1) continue; // 下る edge は既定の右のまま
+        // 列が同じでも縦の範囲が重ならなければ、 実際には同じ場所を走らない。
+        // 逆向きの edge と縦に重なる時だけ回す。
+        const overlapsOpposite = list.some(
+          (o) => o.yDir === 1 && o.minY < c.maxY && o.maxY > c.minY,
+        );
+        if (!overlapsOpposite) continue;
+
+        // 左へ回した経路や label が置けないなら回さない。 重なりの方が貫通より軽い。
+        if (leftRouteIsBlocked(c)) continue;
+        out.set(c.id, "left");
+      }
+    }
+    return out;
+  };
+  const detourSides = assignDetourSides();
+
+  /**
+   * 左へ回す edge の endpoint も、 対称対の shift を左向きに揃える (幹の付け根の接触)。
+   *
+   * 同じ node の同じ辺に 1 本入り 1 本出る時、 `SYMMETRIC_PAIR_SHIFT` は下側と判定した edge を
+   * 常に正方向 (下辺なら右) へ 32 ずらす。 その edge が左を回って戻ると、 戻りの角が辺の右側に
+   * 生まれ、 同じ辺から右へ出る edge の水平部がそこを横切る。
+   *
+   * 回る側が左なら、 endpoint も左へずらす。 2 本の間隔は 32 のまま変わらない。
+   *
+   * ずらした先で塞ぐ node の集合が変われば、 割り当てた側が根拠を失う。 その時は元の向きを保つ
+   * (接触の方が経路の破綻より軽い)。
+   */
+  const alignSymmetricShiftWithDetourSide = (): void => {
+    for (const [edgeId, side] of detourSides) {
+      if (side !== "left") continue;
+      const off = endpointOffsetsByEdgeId.get(edgeId);
+      if (!off || off.fromDx <= 0) continue;
+      const p = prepared.find((x) => x.e.id === edgeId);
+      if (!p) continue;
+
+      const blockersFor = (dx: number): LaidNode[] => {
+        const Araw = sidePoint(p.from, p.fromSide);
+        const Braw = sidePoint(p.to, p.toSide);
+        const A = { x: Araw.x + dx, y: Araw.y + off.fromDy };
+        const B = { x: Braw.x + dx, y: Braw.y + off.toDy };
+        const obstacles = nodes.filter((n) => n.id !== p.from.id && n.id !== p.to.id);
+        return verticalDetourBlockers(A, B, obstacles);
+      };
+      const idsOf = (ns: LaidNode[]) => ns.map((n) => n.id).sort().join(",");
+      if (idsOf(blockersFor(-off.fromDx)) !== idsOf(blockersFor(off.fromDx))) continue;
+
+      // ずらした先が node の辺からはみ出すなら保つ。 端点は node の縁の上に載る必要がある。
+      const withinSide = (n: LaidNode, x: number) => Math.abs(x - n.cx) <= n.w / 2;
+      const fromX = sidePoint(p.from, p.fromSide).x - off.fromDx;
+      const toX = sidePoint(p.to, p.toSide).x - off.toDx;
+      if (!withinSide(p.from, fromX) || !withinSide(p.to, toX)) continue;
+
+      endpointOffsetsByEdgeId.set(edgeId, {
+        fromDx: -off.fromDx,
+        fromDy: off.fromDy,
+        toDx: -off.toDx,
+        toDy: off.toDy,
+      });
+    }
+  };
+  alignSymmetricShiftWithDetourSide();
+
+  // routing pass ... 各 edge の path と label 初期位置を確定する。
+  //
+  // fan dispersion は routing の後に走らせる (Issue #211)。 label の base Y を
+  // (A.y + B.y) / 2 で近似すると horizontal straight route では labelInitClearance 分
+  // (34 world) ずれ、 upward L 字と混在した fan で Y 帯判定を誤る。 routePath が返す
+  // 実際の label 位置を使えば近似誤差そのものが消える。
+  const routed = prepared.map(({ e, from, to, fromSide, toSide }) => {
+    // routing 用 obstacles ... dotted-flow は経由 node 貫通 semantic なので blocking 迂回発火させない (空)。
+    // solid は blocking node を検知して detour する。
+    const routingObstacles = e.style === "dotted-flow"
+      ? []
+      : nodes.filter((n) => n.id !== from.id && n.id !== to.id);
+    // dThrough 判定用 obstacles ... 常に全 node、 dotted-flow の 経由 node 貫通判定に使う。
+    const allOtherNodes = nodes.filter((n) => n.id !== from.id && n.id !== to.id);
+    const obstacles = routingObstacles;
+    const fromLane = lmap.get(from.lane);
+    const toLane = lmap.get(to.lane);
+    // routing="back-detour" は fromSide/toSide を強制的に top-top にして上方 detour を発火
+    let effectiveFromSide = fromSide;
+    let effectiveToSide = toSide;
+    if (e.routing === "back-detour") {
+      effectiveFromSide = "top";
+      effectiveToSide = "top";
+    }
+    // label retreat 用 obstacles = 全 other node。 dotted-flow でも label 位置は node と重ならない。
+    // path detour 用 obstacles と separate。
+    // CAR-541 SSOT ... endpointOffset = 同 node 対称対 lower edge の両 endpoint 平行 shift (world unit)。
+    // routePath は sidePoint(from, side) + fromOffset で起点、 sidePoint(to, side) + toOffset で
+    // 終点を計算する。 lower edge は fromOffset = toOffset (両端同量 shift、 直線 SSOT 保持)、
+    // upper edge / 非対称対 edge は entry なしで {0, 0} fallback。
+    const endpointOffset = endpointOffsetsByEdgeId.get(e.id) ?? { fromDx: 0, fromDy: 0, toDx: 0, toDy: 0 };
+    // 迂回の折れ位置は別 edge の label を避ける必要があるが、 1 巡目では label 位置が
+    // まだ無い。 同じ引数で呼び直せるようにして、 label が出そろってから `widenDetourStubs`
+    // が 2 巡目を回す (label 位置は折れ位置に依存しないので繰り返しても揺れない)。
+    const route = (avoidRects: readonly Rect[]) => routePath(
+      from,
+      to,
+      effectiveFromSide,
+      effectiveToSide,
+      obstacles,
+      detourSides.get(e.id),
+      fromLane,
+      toLane,
+      e,
+      allOtherNodes,
+      { x: endpointOffset.fromDx, y: endpointOffset.fromDy },
+      { x: endpointOffset.toDx, y: endpointOffset.toDy },
+      avoidRects,
+    );
+    const routed1 = route([]);
+    const { d, labelX, labelY, labelAnchor, labelAltX } = routed1;
+
+    // dotted-flow の glow は「経路が別 node を貫くか」 で出す / 出さないが決まる。 経路が
+    // 変われば判定も変わるため、 経路を出し直したら glow も出し直す (2 巡目、 #418)
+    const makeDThrough = (dNow: string): string | undefined => {
+      if (e.style !== "dotted-flow") return undefined;
+      const segments = extractPathSegments(dNow);
+      const hasPassThrough = allOtherNodes.some((n) => {
+        const rect = { x: n.cx - n.w / 2, y: n.cy - n.h / 2, w: n.w, h: n.h };
+        return segmentsCrossRect(segments, rect);
+      });
+      if (!hasPassThrough) return undefined;
+      // dThrough (dotted-flow glow) = source 中心 → target 中心 の直線。 CAR-429 で
+      // fan-in / fan-out offset 分散を削除したため、 中心線 (perpX/perpY = 0) 固定で描画する。
+      const dxAbs = Math.abs(to.cx - from.cx);
+      const dyAbs = Math.abs(to.cy - from.cy);
+      const isHorizontal = dxAbs > dyAbs;
+      let glowStartX = from.cx;
+      let glowStartY = from.cy;
+      let glowEndX = to.cx;
+      let glowEndY = to.cy;
+      if (isHorizontal) {
+        const dirFrom = from.cx < to.cx ? 1 : -1;
+        glowStartX = from.cx + dirFrom * (from.w / 2) - dirFrom * (from.w / 2) * 1.0;
+        glowEndX = to.cx - dirFrom * (to.w / 2) + dirFrom * (to.w / 2) * 1.0;
+      } else {
+        const dirFrom = from.cy < to.cy ? 1 : -1;
+        glowStartY = from.cy + dirFrom * (from.h / 2) - dirFrom * (from.h / 2) * 1.0;
+        glowEndY = to.cy - dirFrom * (to.h / 2) + dirFrom * (to.h / 2) * 1.0;
+      }
+      return `M ${glowStartX} ${glowStartY} L ${glowEndX} ${glowEndY}`;
+    };
+    const dThrough = makeDThrough(d);
+
+    // labelMarginExtra ... edge label を path から author 指定分だけ離す。
+    // 既存 route の label は path 中点から垂直方向にオフセット済 (上方 -36 / -50 等)、
+    // labelY < (path 中点 y) なら上向き label として扱い -=、 そうでなければ +=。
+    // path 中点 y は (A.y+B.y)/2 だが routePath からは受け取れないので、 from / to の cy 平均で近似。
+    const pathMidY = (from.cy + to.cy) / 2;
+    const marginDir = labelY < pathMidY ? -1 : 1;
+    // fan / parallel の分散 offset を除いた label 位置。 author 指定 offset と labelMargin は込み。
+    const baseLabelX = labelX + (e.labelOffsetX ?? 0);
+    const baseLabelY = labelY + (e.labelOffsetY ?? 0) + marginDir * labelMarginExtra;
+    return {
+      p: { e, from, to, fromSide, toSide },
+      e,
+      d,
+      dThrough,
+      effectiveFromSide,
+      effectiveToSide,
+      labelAnchor,
+      baseLabelX,
+      baseLabelY,
+      labelAltX,
+      route,
+      makeDThrough,
+      /** 経路が `avoidRects` を見るか。 見ない経路は 2 巡目を回しても結果が変わらない。 */
+      consultsAvoidRects: routed1.consultsAvoidRects === true,
+    };
+  });
+
+  type RoutedEdge = (typeof routed)[number];
+
+  /**
+   * 迂回する edge の折れ位置を、 別 edge の label を避けられる範囲まで外へ広げる (#418)。
+   *
+   * 1 巡目の routing は label 位置を知らないため、 走る距離の比だけで折れ位置を決める。 その
+   * ままだと隣の edge の label を垂直の線が貫くことがあるので、 label が出そろったここで
+   * 同じ routing を呼び直し、 label を避けた折れ位置に差し替える。
+   *
+   * label 位置は折れ位置に依存しない (`labelX` は端点の中点、 `labelY` は迂回帯からの距離) ため、
+   * 2 巡目で label が動くことはなく、 繰り返しても揺れない。
+   *
+   * 差し替えるのは `d` だけ。 label 位置は 1 巡目のものを保ち、 後段の post-pass に委ねる。
+   */
+  const widenDetourStubs = (list: RoutedEdge[]): void => {
+    const pillById = new Map<string, Rect>();
+    for (const r of list) {
+      if (!hasRenderedLabel(r.e)) continue;
+      const w = computeLabelBoxW(r.e.label, r.e.sub);
+      const h = labelPillH(r.e.sub);
+      pillById.set(r.e.id, { x: r.baseLabelX - w / 2, y: r.baseLabelY - h / 2, w, h });
+    }
+    // 絶対座標で置いた edge は routing を通らないが、 label は描かれる。 集合から漏らすと
+    // 迂回線がその pill を貫く
+    for (const le of positionedEdges) {
+      if (!hasRenderedLabel(le)) continue;
+      const w = computeLabelBoxW(le.label, le.sub);
+      const h = labelPillH(le.sub);
+      pillById.set(le.id, { x: le.labelX - w / 2, y: le.labelY - h / 2, w, h });
+    }
+    if (pillById.size === 0) return;
+    for (const r of list) {
+      // 迂回しない経路は `avoidRects` を見ないので、 出し直しても同じ結果になる
+      if (!r.consultsAvoidRects) continue;
+      const avoid = [...pillById].filter(([id]) => id !== r.e.id).map(([, rect]) => rect);
+      if (avoid.length === 0) continue;
+      const next = r.route(avoid);
+      if (next.d === r.d) continue;
+      // label は 1 巡目の値を保つ。 折れ位置を変えても label 位置は同じ計算式で出るため、
+      // 差し替えるのは経路と、 経路から決まる glow だけでよい
+      r.d = next.d;
+      r.dThrough = r.makeDThrough(next.d);
+    }
+  };
+  widenDetourStubs(routed);
+
+  /**
+   * 左右対称に置ける label を、 別 edge の経路が占める側から空いている側へ移す (Issue #211)。
+   *
+   * 縦 straight route は label を自 path の右に置く。 同じ node の同じ辺から出る別 edge が
+   * 間の node を右へ迂回すると、 その出口の水平部は 2 node の隙間 (= label が置かれる帯) を
+   * 必ず横切る。 出口までの直進距離は EDGE_STUB_OUT を下回れないため迂回側は label の上を
+   * 通れず、 隙間を広げても両者は同じ帯に入り続ける。
+   *
+   * label は自 path に対して左右等距離に置けるので、 空いている側へ移して解く。 移した先も
+   * 別の経路に横切られるなら移さない。 両側とも塞がっている構図は後段の chain 伝搬に委ねる。
+   *
+   * node との間隔は移動先を移動元と比べて判定する。 絶対値で「32 world 未満なら移さない」 と
+   * すると、 元から 32 を割っている label (sub 付きの背の高い pill が狭い隙間に入る等) が、
+   * 間隔を 1 world も悪化させない鏡像へすら移れず、 経路の横断が残る。
+   *
+   * lane border だけは移動前に自前で見る。 後段の chain 伝搬が受け取る obstacle は node と
+   * lane-label だけで (layout.ts)、 lane の枠線は誰も見ていないため、 ここで通すと
+   * lane-border-clearance の違反がそのまま残る。
+   *
+   * 戻り値 = 実際に反転した edge id。 後段の fan dispersion が反転を押し戻さないために使う。
+   */
+  const flipLabelToFreeSide = (list: RoutedEdge[]): Set<string> => {
+    const flipped = new Set<string>();
+    const flippable = list.filter(
+      // 作者が labelOffsetX で寄せた label は意図とみなし、 自動で左右を入れ替えない。
+      // pill が描かれる条件は render/edges.tsx と collectBBoxes の SSOT に合わせる
+      // (label が空でも sub があれば pill は描かれ、 bbox も衝突判定に載る)。
+      (r) => r.labelAltX !== undefined && hasRenderedLabel(r.e) && !r.e.labelOffsetX,
+    );
+    if (flippable.length === 0) return flipped;
+
+    const segsByEdgeId = new Map(list.map((r) => [r.e.id, extractPathSegments(r.d)]));
+    const pathBoxByEdgeId = new Map(list.map((r) => [r.e.id, segmentsBBox(segsByEdgeId.get(r.e.id)!)]));
+    const laneOfNode = new Map(nodes.map((n) => [n.id, n.lane]));
+
+    for (const r of flippable) {
+      const ownSegs = segsByEdgeId.get(r.e.id)!;
+      const boxW = computeLabelBoxW(r.e.label, r.e.sub);
+      const boxH = labelPillH(r.e.sub);
+      const pillAt = (centerX: number) => ({
+        x: centerX - boxW / 2,
+        y: r.baseLabelY - boxH / 2,
+        w: boxW,
+        h: boxH,
+      });
+      const cur = pillAt(r.baseLabelX);
+      const alt = pillAt(r.labelAltX!);
+      // cur と alt を覆う帯。 どちらかを横切る segment は必ずこの帯に入るので、 帯と交わらない
+      // path は segment 展開前に落とせる (全 edge の全 segment を毎回展開しない)。
+      const band = unionRect(cur, alt);
+      const otherSegs = list
+        .filter((o) => o.e.id !== r.e.id && rectsOverlap(pathBoxByEdgeId.get(o.e.id)!, band))
+        // 兄弟が自 path と共有する区間は 1 本の線として描かれるので衝突ではない (Issue #211)。
+        .flatMap((o) => segmentsExcludingOwnPath(segsByEdgeId.get(o.e.id)!, ownSegs));
+      if (otherSegs.length === 0) continue;
+      if (!segmentsCrossRect(otherSegs, cur)) continue;
+      if (segmentsCrossRect(otherSegs, alt)) continue;
+
+      // 許容する node 間隔 = SSOT (32) と 移動元の間隔 の小さい方。 これで「規約を満たす」 か
+      // 「元より悪くしない」 かのどちらかを常に満たす。
+      const minNodeGap = (box: Rect) =>
+        nodes.reduce((acc, n) => Math.min(acc, rectGap(box, nodeRect(n))), Infinity);
+      if (minNodeGap(alt) < Math.min(CLEARANCE_NODE_LABEL, minNodeGap(cur)) - 1e-6) continue;
+
+      // 発着 lane の枠線は跨いでよい (visual-validate の lane-border-clearance と同一規約)。
+      const endpointLanes = new Set(
+        [laneOfNode.get(r.e.from), laneOfNode.get(r.e.to)].filter((v): v is string => v !== undefined),
+      );
+      const crossesLaneBorder = lanes.some((l) => {
+        if (endpointLanes.has(l.id)) return false;
+        return crossesVerticalLine(alt, l.x) || crossesVerticalLine(alt, l.x + l.width);
+      });
+      if (crossesLaneBorder) continue;
+
+      r.baseLabelX = r.labelAltX!;
+      flipped.add(r.e.id);
+    }
+    return flipped;
+  };
+  const flippedLabelEdgeIds = flipLabelToFreeSide(routed);
+
+  /**
+   * parallel group の label を縦に分散する (#372)。 routing 後の実 label 位置を起点にする。
+   *
+   * 分ける単位は **節の組** で、 向きは見ない。 A → B と B → A は別々の group として routing
+   * されるが、 label は同じ帯に落ちるため、 向きごとに分けて分散すると帯どうしが衝突する
+   * (実測 = 往復 4 本で 3 本目と 4 本目が完全に同じ点、 往復 5 本で中心間 52 = pill 高 68 に
+   * 対して足りない)。
+   *
+   * 分散は `spreadWithMinimalShift` に任せる。 各 label は自分の線の上の位置に居たがり、 重なる
+   * 分だけ最小限ずれる。 旧実装の「group の中心から ± 一定幅」 は、 線ごとに高さが違う場合に
+   * 動かす必要のない label まで動かしていた。
+   *
+   * この時点では 4 本とも同じ直線で、 弧は後段 (`bowSharedStraightPaths`) で付く。 どの label が
+   * どの線のものかは並び順でしか読み取れないため、 弧の側を label の並びに合わせる (#374)。
+   */
+  const spreadParallelLabels = (): void => {
+    const byPair = new Map<string, RoutedEdge[]>();
+    for (const r of routed) {
+      if (!parallelGroupedIds.has(r.e.id)) continue;
+      if (!hasRenderedLabel(r.e)) continue;
+      const key = r.e.from < r.e.to ? `${r.e.from}::${r.e.to}` : `${r.e.to}::${r.e.from}`;
+      const list = byPair.get(key) ?? [];
+      list.push(r);
+      byPair.set(key, list);
+    }
+    for (const list of byPair.values()) {
+      if (list.length < 2) continue;
+      // 縦にずらす必要があるのは、 横に重なっている label だけ。 同じ節の組でも左右に分かれて
+      // 走る route の label は既に離れているので、 まとめて動かすと自分の線から引き剥がす。
+      // 横の重なりで連結成分に割り、 成分ごとに縦を解く。
+      const boxes = list.map((r) => ({
+        cx: r.baseLabelX,
+        halfW: computeLabelBoxW(r.e.label, r.e.sub) / 2,
+      }));
+      const overlapsX = (i: number, j: number): boolean =>
+        Math.abs(boxes[i]!.cx - boxes[j]!.cx) < boxes[i]!.halfW + boxes[j]!.halfW + CLEARANCE_LABEL_LABEL;
+      const componentOf = list.map((_, i) => i);
+      for (let i = 0; i < list.length; i++) {
+        for (let j = i + 1; j < list.length; j++) {
+          if (!overlapsX(i, j)) continue;
+          const from = componentOf[j]!;
+          const to = componentOf[i]!;
+          if (from === to) continue;
+          for (let k = 0; k < componentOf.length; k++) {
+            if (componentOf[k] === from) componentOf[k] = to;
+          }
+        }
+      }
+      for (const root of new Set(componentOf)) {
+        const members = list.filter((_, i) => componentOf[i] === root);
+        if (members.length < 2) continue;
+        const placed = spreadWithMinimalShift(
+          members.map((r) => ({ want: r.baseLabelY, size: labelPillH(r.e.sub) })),
+          CLEARANCE_LABEL_LABEL,
+        );
+        for (let i = 0; i < members.length; i++) {
+          const r = members[i]!;
+          labelOffsetsByEdgeId.set(r.e.id, { dx: 0, dy: placed[i]! - r.baseLabelY });
+          distributedInParallel.add(r.e.id);
+        }
+      }
+    }
+  };
+  spreadParallelLabels();
+
+  /**
+   * CAR-636 fan dispersion の X 分散。 routing 後の実 label 位置に対して走らせる (Issue #211)。
+   *
+   * pill 同士が横に重なるのは Y 帯が重なっている時だけ。 L 字 route の pill は各自の縦走の中点に
+   * 置かれるため、 fan group でも pill の Y は揃わない。 Y 帯が CLEARANCE_LABEL_LABEL 以上離れた
+   * pill まで横に押し退けると、 pill が自 path から外れて隣 lane の node に乗り上げる。
+   *
+   * flipLabelToFreeSide が反転させた pill は動かさない。 反転は「この側は別の経路が通っている」
+   * という判定の結果で、 右へ押し退けるとその経路へ戻してしまう。 押し退ける先を失った兄弟は
+   * さらに右へ回る。
+   */
+  const applyFanDispersion = (list: RoutedEdge[], tracked: Set<string> | null): void => {
+    if (list.length < 2) return;
+    const obstaclePatterns = new Set(list.map((r) => detectsBlockingObstacle(r.p)));
+    if (obstaclePatterns.size > 1) return;
+    // CAR-615 SSOT ... group 内に overlay:true edge が 1 本でもあれば fan dispersion skip。
+    // overlay:true (flowchart 等の true/false condition label、 CAR-549) は「label を path 上に
+    // 重ねる」 semantic を持つため、 fan offset を加えると pill が path から離れて overlay 意図が
+    // 破壊される。 fan 内 mixed (overlay 有無混在) case は overlay 優先で全体 skip、 non-overlay
+    // edge も fan offset を諦めて base 位置維持。 group 内 label 集中は post-pass 2 chain shift が担当。
+    if (list.some((r) => r.e.overlay)) return;
+    const items = list.map((r) => ({
+      r,
+      baseX: r.baseLabelX,
+      baseY: r.baseLabelY,
+      w: computeLabelBoxW(r.e.label, r.e.sub),
+      h: labelPillH(r.e.sub),
+    }));
+    items.sort((a, b) => a.baseX - b.baseX);
+    // X sweep = 最左 pill を base 位置 (dx=0) 固定、 順次右隣 pill の左端が前 pill 右端 +
+    // FAN_LABEL_GAP より小さければ dx で右にずらす。 押し退けの対象は Y 帯が重なる pill のみ。
+    const placed: Array<{ right: number; baseY: number; h: number }> = [];
+    for (const item of items) {
+      const halfW = item.w / 2;
+      const baseLeft = item.baseX - halfW;
+      let shift = 0;
+      if (!flippedLabelEdgeIds.has(item.r.e.id)) {
+        for (const prev of placed) {
+          const yGap = Math.abs(prev.baseY - item.baseY) - (prev.h + item.h) / 2;
+          if (yGap >= CLEARANCE_LABEL_LABEL) continue;
+          shift = Math.max(shift, prev.right + FAN_LABEL_GAP - baseLeft);
+        }
+      }
+      labelOffsetsByEdgeId.set(item.r.e.id, { dx: shift, dy: 0 });
+      tracked?.add(item.r.e.id);
+      placed.push({ right: item.baseX + shift + halfW, baseY: item.baseY, h: item.h });
+    }
+  };
+
+  // (b) fan-in = 同 to (parallel でない) 群。
+  const byToNode = new Map<string, RoutedEdge[]>();
+  for (const r of routed) {
+    if (distributedInParallel.has(r.e.id)) continue;
+    const list = byToNode.get(r.e.to) ?? [];
+    list.push(r);
+    byToNode.set(r.e.to, list);
+  }
+  const distributedInFanIn = new Set<string>();
+  for (const list of byToNode.values()) applyFanDispersion(list, distributedInFanIn);
+  // (c) fan-out = 同 from (parallel / fan-in でない) 群。
+  const byFromNodeFanOut = new Map<string, RoutedEdge[]>();
+  for (const r of routed) {
+    if (distributedInParallel.has(r.e.id) || distributedInFanIn.has(r.e.id)) continue;
+    const list = byFromNodeFanOut.get(r.e.from) ?? [];
+    list.push(r);
+    byFromNodeFanOut.set(r.e.from, list);
+  }
+  for (const list of byFromNodeFanOut.values()) applyFanDispersion(list, null);
+
+  const autoResults = routed.map((r) => {
+    // parallel / fan group の分散 offset (CAR-430 SSOT、 idx 0 は offset 0 で init 位置維持)。
+    const parallelOffset = labelOffsetsByEdgeId.get(r.e.id) ?? { dx: 0, dy: 0 };
+    return {
+      ...r.e,
+      d: r.d,
+      dThrough: r.dThrough,
+      fromSide: r.effectiveFromSide,
+      toSide: r.effectiveToSide,
+      labelX: r.baseLabelX + parallelOffset.dx,
+      labelY: r.baseLabelY + parallelOffset.dy,
+      labelAnchor: r.labelAnchor,
+    };
+  });
+  // canvas pivot 新 spec = positionedEdges (posX1/Y1/X2/Y2 set 済) を最終結果に merge。
+  // 元 diag.edges の順序を保持するため id 順で lookup、 positioned は auto より先に列挙。
+  const laidById = new Map<string, LaidEdge>();
+  for (const le of autoResults) laidById.set(le.id, le);
+  for (const le of positionedEdges) laidById.set(le.id, le);
+  return diag.edges.map((e) => laidById.get(e.id)!).filter((e) => e !== undefined);
+}
+
+/**
+ * `M x1 y1 L x2 y2` の 1 本だけの直線か判定し、 両端を返す。 それ以外は null。
+ *
+ * 数値は JavaScript の通常の文字列化に合わせる。 指数表記を拒むと、 極端に小さい座標
+ * (`1e-7` 等) の図で分離が起きない (実測 = 指数表記の 2 本が重畳したまま残った)。
+ */
+const PATH_NUMBER = String.raw`-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?`;
+/** 分離対象の 1 本と、 その両端。 */
+type Entry = { e: LaidEdge; seg: { x1: number; y1: number; x2: number; y2: number } };
+
+/**
+ * 同じ 2 点を結ぶ edge 群の並び順 (#430)。
+ *
+ * `bowSharedStraightPaths` が弧を振り分ける時と、 後段の置き直しが対応を辿る時で
+ * **同じ順序を使う**。 揃えないと同じ `labelY` の 2 本で対応が入れ替わる。
+ *
+ * `labelY` が同じ時も `id` で決める = 同じ入力なら同じ割当になる。
+ *
+ * `#430` まで同じ式を 2 箇所に書いており、 片方だけ変えても誰も気付かなかった。
+ */
+export function compareSharedPairOrder(
+  a: { id: string; labelY: number },
+  b: { id: string; labelY: number },
+): number {
+  return a.labelY - b.labelY || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+/** 曲線と label の間に空ける距離 (world unit)。 cdl の edge-label ↔ edge-path 規定と同じ。 */
+const BOW_LABEL_CLEARANCE = 14;
+/** 膨らみを縮める順。 どれも当たるなら分離しない。 */
+const BOW_SCALES = [1, 0.5] as const;
+/** node の縁ちょうどは当たりにしない余裕 (world unit)。 端点は縁に着くため。 */
+const BOW_NODE_MARGIN = 1;
+
+/** 閉区間の列。 t の取りうる範囲を表す。 */
+type Interval = { lo: number; hi: number };
+
+/**
+ * `a t^2 + b t + c < 0` を満たす t の範囲を [0, 1] の中で返す。
+ *
+ * 2 次 (a != 0) なら根の内側 or 外側、 1 次なら片側、 定数なら全部 or 空になる。
+ */
+function quadraticNegativeRanges(a: number, b: number, c: number): Interval[] {
+  const clip = (lo: number, hi: number): Interval[] =>
+    hi <= 0 || lo >= 1 || lo >= hi ? [] : [{ lo: Math.max(lo, 0), hi: Math.min(hi, 1) }];
+  if (Math.abs(a) < 1e-12) {
+    if (Math.abs(b) < 1e-12) return c < 0 ? [{ lo: 0, hi: 1 }] : [];
+    const root = -c / b;
+    return b > 0 ? clip(-Infinity, root) : clip(root, Infinity);
+  }
+  const disc = b * b - 4 * a * c;
+  if (disc <= 0) return a < 0 ? [{ lo: 0, hi: 1 }] : [];
+  const sq = Math.sqrt(disc);
+  const r1 = (-b - sq) / (2 * a);
+  const r2 = (-b + sq) / (2 * a);
+  const lo = Math.min(r1, r2);
+  const hi = Math.max(r1, r2);
+  // a > 0 なら根の内側が負、 a < 0 なら外側が負
+  return a > 0 ? clip(lo, hi) : [...clip(-Infinity, lo), ...clip(hi, Infinity)];
+}
+
+/** 区間の列 2 つの共通部分。 */
+function intersectRanges(as: Interval[], bs: Interval[]): Interval[] {
+  const out: Interval[] = [];
+  for (const a of as) {
+    for (const b of bs) {
+      const lo = Math.max(a.lo, b.lo);
+      const hi = Math.min(a.hi, b.hi);
+      if (lo < hi) out.push({ lo, hi });
+    }
+  }
+  return out;
+}
+
+/**
+ * 2 次曲線が矩形の内部を通るかを厳密に判定する。
+ *
+ * 曲線 = `M (x1,y1) Q (cx,cy) (x2,y2)`。 x(t) / y(t) はどちらも t の 2 次式なので、
+ * 「x が矩形の中」 「y が矩形の中」 の 4 つの不等式を t の範囲として出し、 共通部分が空でなければ
+ * 内部を通る。 端点は矩形の縁に着くことがあるので、 端点だけの接触は除く。
+ */
+function quadEntersRect(
+  seg: { x1: number; y1: number; x2: number; y2: number },
+  ctrl: { x: number; y: number },
+  rect: { x: number; y: number; w: number; h: number },
+): boolean {
+  // x(t) = (x1 - 2cx + x2) t^2 + 2(cx - x1) t + x1
+  const ax = seg.x1 - 2 * ctrl.x + seg.x2;
+  const bx = 2 * (ctrl.x - seg.x1);
+  const ay = seg.y1 - 2 * ctrl.y + seg.y2;
+  const by = 2 * (ctrl.y - seg.y1);
+  // x(t) > rect.x  ⇔  -x(t) + rect.x < 0
+  const gtX = quadraticNegativeRanges(-ax, -bx, rect.x - seg.x1);
+  // x(t) < rect.x + w  ⇔  x(t) - (rect.x + w) < 0
+  const ltX = quadraticNegativeRanges(ax, bx, seg.x1 - (rect.x + rect.w));
+  const gtY = quadraticNegativeRanges(-ay, -by, rect.y - seg.y1);
+  const ltY = quadraticNegativeRanges(ay, by, seg.y1 - (rect.y + rect.h));
+  const ranges = intersectRanges(intersectRanges(gtX, ltX), intersectRanges(gtY, ltY));
+  // 端点だけが縁に触れる場合を除く = 幅を持つ範囲が残っているか
+  return ranges.some((r) => r.hi - r.lo > 1e-9);
+}
+function singleStraightSegment(d: string): { x1: number; y1: number; x2: number; y2: number } | null {
+  const m = new RegExp(
+    `^\\s*M\\s*(${PATH_NUMBER})[\\s,]+(${PATH_NUMBER})\\s*L\\s*(${PATH_NUMBER})[\\s,]+(${PATH_NUMBER})\\s*$`,
+  ).exec(d);
+  if (!m) return null;
+  const [x1, y1, x2, y2] = [Number(m[1]), Number(m[2]), Number(m[3]), Number(m[4])];
+  if (![x1, y1, x2, y2].every(Number.isFinite)) return null;
+  if (x1 === x2 && y1 === y2) return null;
+  return { x1, y1, x2, y2 };
+}
+
+/**
+ * 同じ直線をそのまま共有している edge を、 途中だけ弓なりにして分ける (dragon #941)。
+ *
+ * 同じ 2 点を同じ向きに結ぶ edge が複数あると、 座標が完全に一致して 1 本に見える。 見えるのは
+ * 最後に描いた 1 本だけで、 何本あるのか / どの label がどの線かを追えない。
+ *
+ * 端点は動かさない。 同じ node の同じ辺から出る edge は起点を 1 点に集める規約
+ * (`fan-origin-single-point` 軸) と、 矢頭は辺の中央に着地する規約 (`arrow-endpoint-center` 軸)
+ * があるため、 端点をずらすとどちらかを破る。 中点を垂直方向へ膨らませた 2 次曲線に置き換える。
+ *
+ * 対象は「1 本の直線」 だけに限る。 折れ線や迂回は既に列の割当で分かれており、 形を触ると
+ * 迂回の判定 (`detour-slot-distinct` 等) に影響する。
+ *
+ * 衝突判定は曲線を弦 (両端を結ぶ直線) に落として見るため、 判定上の形は変更前と同じになる =
+ * 本 pass で新しい error は出ない。 分かれていることは描画された曲線でのみ確認できる。
+ *
+ * 呼ぶ場所は label の重なり解消が終わった後 (`layout.ts` の終盤)。 `layoutEdges` の中で呼ぶと
+ * label 位置が確定しておらず、 確定前の矩形で判定して分離を諦める (実測 = 4 本の label を
+ * 離した図で、 確定前の位置を見て 1 本も分離しなくなった)。
+ */
+export function bowSharedStraightPaths(
+  edges: LaidEdge[],
+  nodes: LaidNode[],
+  skipIds: ReadonlySet<string>,
+): void {
+  /**
+   * 向きを無視した線分の key。 A→B と B→A を同じ群にする。
+   *
+   * 向き別にまとめると、 逆向きの 2 本が同じ側に膨らんで world 座標で重なる (実測 = 4 本が
+   * 同じ横線を通る図で、 向き別に振り分けた結果 2 組が一致した)。
+   */
+  const groups = new Map<string, Entry[]>();
+  for (const e of edges) {
+    // 座標を明示した edge (canvas pivot) は「指定した直線が最終 path」 が公開契約なので触らない。
+    if (skipIds.has(e.id)) continue;
+    const seg = singleStraightSegment(e.d);
+    if (!seg) continue;
+    const a = `${seg.x1},${seg.y1}`;
+    const b = `${seg.x2},${seg.y2}`;
+    const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+    // 毎回 spread すると同じ線分が k 本ある群で O(k^2) の複製になる。
+    const list = groups.get(key);
+    if (list) list.push({ e, seg });
+    else groups.set(key, [{ e, seg }]);
+  }
+  for (const [key, group] of groups) {
+    if (group.length < 2) continue;
+    // 膨らむ向きは正規化した方向 (key の並び) から決める。 edge 自身の向きから決めると
+    // 逆向きの 2 本が同じ側に寄る。
+    const [pStr, qStr] = key.split("|");
+    const [px, py] = pStr!.split(",").map(Number);
+    const [qx, qy] = qStr!.split(",").map(Number);
+    const len = Math.hypot(qx! - px!, qy! - py!);
+    if (len === 0) continue;
+    // 法線の縦成分を下向き (+Y) に正規化する (#374)。 key は座標を文字列で比べて作るため、
+    // 数値の大小とは限らない (実測 = 端点 860 と 1148 では "1148" が先に来て法線が上向きになる)。
+    // 正規化しないと膨らむ向きが図によって反転し、 label の並びに合わせて振り分けても対応が
+    // 逆になる。
+    //
+    // 縦成分が 0 の線 (弧が横に分かれる) は触らない。 その場合は下の振り分けも label を見ない
+    // ので、 向きを揃えても得るものが無く、 既存の図の弧が左右入れ替わるだけになる。
+    let nx = -(qy! - py!) / len;
+    let ny = (qx! - px!) / len;
+    if (ny < 0) {
+      nx = -nx;
+      ny = -ny;
+    }
+    const midX = (px! + qx!) / 2;
+    const midY = (py! + qy!) / 2;
+    // **label の並び順** で振り分ける (#374)。 label は既に積まれており、 どの label がどの線の
+    // ものかは並び順でしか読み取れない。 id 順で振ると label の順と食い違い、 図が誤読される
+    // (実測 = 往復 4 本の見本で 2 番目と 3 番目の対応が入れ替わった)。
+    //
+    // 例外は **真横に分かれる線** (縦線) だけ。 label を積むのは縦なので (`spreadParallelLabels`
+    // は Y 軸のみ)、 弧の縦成分が 0 だと label の並びと弧の並びが別の軸になり、 対応を保つ余地が
+    // ない (実測 = 縦の 2 本で label の X 差は 5 = 文字数の差でしかない)。 その場合は従来どおり
+    // id 順で振る。 斜めの線は縦成分を持つので label の並びに合わせる。
+    //
+    // label の位置が同じ時も id で決める = 同じ入力なら同じ割当になる。
+    const byId = (a: Entry, b: Entry): number => (a.e.id < b.e.id ? -1 : a.e.id > b.e.id ? 1 : 0);
+    const ordered = [...group].sort((a, b) =>
+      // 縦成分が 0 の時だけ id 順 (上の comment)。 それ以外は置き直しと同じ順序を使う
+      ny === 0 ? byId(a, b) : compareSharedPairOrder(a.e, b.e),
+    );
+    // 膨らませた曲線が他の要素に当たるなら幅を縮める。 どの幅でも当たるなら群ごと直線のまま残す
+    // (重なって見えるのは残るが、 要素を貫くより軽い)。 衝突判定は弦しか見ないので、 ここで
+    // 実曲線を刻んで確かめないと誰も気付けない。
+    //
+    // **この群自身の label は障害物に数えない** (#376)。 群の label は弧を確定させた後に
+    // `repositionParallelLabels` が置き直すため、 今の位置は仮でしかない。 数えると
+    // 「label が線から離れている ⇒ どの膨らみも当たる ⇒ 弧を諦める」 となり、 label を線から
+    // 逃がすほど弧が消える (実測 = 平行 2-5 本の全ての図で弧が直線に戻った)。
+    const groupIds = new Set(group.map((g) => g.e.id));
+    const labelRects = edges
+      .filter((x) => hasRenderedLabel(x) && !groupIds.has(x.id))
+      .map((x) => computeLabelBBoxWorld(x));
+    const nodeRects = nodes.map((n) => ({ x: n.cx - n.w / 2, y: n.cy - n.h / 2, w: n.w, h: n.h }));
+    const build = (seg: Entry["seg"], offset: number): string => {
+      // 2 次曲線は制御点の半分の高さを通るので、 狙いの膨らみの 2 倍を制御点に与える。
+      const cx = midX + nx * offset * 2;
+      const cy = midY + ny * offset * 2;
+      return `M ${seg.x1} ${seg.y1} Q ${cx} ${cy}, ${seg.x2} ${seg.y2}`;
+    };
+    const inflate = (r: { x: number; y: number; w: number; h: number }, by: number) => ({
+      x: r.x - by,
+      y: r.y - by,
+      w: r.w + by * 2,
+      h: r.h + by * 2,
+    });
+    /**
+     * label は「直線の時点で規定の隙間を満たしていたなら、 膨らませた後も満たす」 で見る。
+     *
+     * label は path の上に白い pill として乗るのが通常の配置で、 直線の時点で矩形の中を通って
+     * いることがある。 そこへ規定の隙間を要求すると、 どの膨らみでも当たり判定になって分離が
+     * 起きない (実測 = label ありだと弓なり 0 本になった)。
+     *
+     * 距離の判定は矩形を隙間の分だけ広げて交差で見る。 角では最大 (√2 - 1) × 隙間 だけ厳しく
+     * 出るが、 厳しい側 = 分離を諦める側に外れるので安全。
+     */
+    const labelGuards = labelRects.map((r) => inflate(r, BOW_LABEL_CLEARANCE));
+    const hitsSomething = (seg: Entry["seg"], offset: number): boolean => {
+      const ctrl = { x: midX + nx * offset * 2, y: midY + ny * offset * 2 };
+      const straight = { x: (seg.x1 + seg.x2) / 2, y: (seg.y1 + seg.y2) / 2 };
+      for (const r of nodeRects) {
+        if (quadEntersRect(seg, ctrl, inflate(r, -BOW_NODE_MARGIN))) return true;
+      }
+      for (const g of labelGuards) {
+        // 直線の時点で既に近い label は対象外 (今より悪くしない)
+        if (quadEntersRect(seg, straight, g)) continue;
+        if (quadEntersRect(seg, ctrl, g)) return true;
+      }
+      return false;
+    };
+    const scale = BOW_SCALES.find((k) =>
+      ordered.every(({ seg }, i) => {
+        const offset = (i - (ordered.length - 1) / 2) * PARALLEL_EDGE_BOW * k;
+        return offset === 0 || !hitsSomething(seg, offset);
+      }),
+    );
+    if (scale === undefined) continue;
+    ordered.forEach(({ e, seg }, i) => {
+      // 中心線から等間隔に振り分ける。 2 本なら ±16、 3 本なら -32 / 0 / +32。
+      const offset = (i - (ordered.length - 1) / 2) * PARALLEL_EDGE_BOW * scale;
+      if (offset === 0) return;
+      e.d = build(seg, offset);
+    });
+  }
+}
+
+interface Rect {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+function nodeRect(n: LaidNode): Rect {
+  return { x: n.cx - n.w / 2, y: n.cy - n.h / 2, w: n.w, h: n.h };
+}
+
+/** 2 rect の最短距離 (world unit)。 重なっていれば 0。 */
+function rectGap(a: Rect, b: Rect): number {
+  const dx = Math.max(0, a.x - (b.x + b.w), b.x - (a.x + a.w));
+  const dy = Math.max(0, a.y - (b.y + b.h), b.y - (a.y + a.h));
+  return Math.hypot(dx, dy);
+}
+
+function rectsOverlap(a: Rect, b: Rect): boolean {
+  return a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
+}
+
+function unionRect(a: Rect, b: Rect): Rect {
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return { x, y, w: Math.max(a.x + a.w, b.x + b.w) - x, h: Math.max(a.y + a.h, b.y + b.h) - y };
+}
+
+function segmentsBBox(segs: Array<{ x1: number; y1: number; x2: number; y2: number }>): Rect {
+  if (segs.length === 0) return { x: 0, y: 0, w: 0, h: 0 };
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const s of segs) {
+    minX = Math.min(minX, s.x1, s.x2);
+    minY = Math.min(minY, s.y1, s.y2);
+    maxX = Math.max(maxX, s.x1, s.x2);
+    maxY = Math.max(maxY, s.y1, s.y2);
+  }
+  return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+}
+
+/**
+ * rect が縦線 x = lineX を跨ぐか。 `visual-validate` の lane-border-clearance と同一規約で、
+ * 端が線に触れるだけ (許容差 LANE_BORDER_CLEARANCE_TOL 以内) は跨いだ扱いにしない。
+ */
+function crossesVerticalLine(rect: Rect, lineX: number): boolean {
+  return rect.x < lineX - LANE_BORDER_CLEARANCE_TOL && rect.x + rect.w > lineX + LANE_BORDER_CLEARANCE_TOL;
+}
+
+function distributeBySides(
+  list: Array<{
+    e: CdlEdge;
+    from: LaidNode;
+    to: LaidNode;
+    fromSide: Side;
+    toSide: Side;
+  }>,
+): void {
+  const from = list[0]!.from;
+  const tol = 20;
+  for (const p of list) {
+    const dx = p.to.cx - from.cx;
+    const dy = p.to.cy - from.cy;
+    if (Math.abs(dx) > Math.abs(dy)) {
+      p.fromSide = dx > tol ? "right" : dx < -tol ? "left" : p.fromSide;
+      p.toSide = oppositeSide(p.fromSide);
+    } else {
+      p.fromSide = dy > tol ? "bottom" : dy < -tol ? "top" : p.fromSide;
+      p.toSide = oppositeSide(p.fromSide);
+    }
+  }
+}
+
+function inferSides(
+  from: LaidNode,
+  to: LaidNode,
+  hint: Side | undefined,
+): { fromSide: Side; toSide: Side } {
+  if (hint) {
+    return { fromSide: hint, toSide: oppositeSide(hint) };
+  }
+  if (from.lane !== to.lane) {
+    if (to.cx > from.cx) return { fromSide: "right", toSide: "left" };
+    return { fromSide: "left", toSide: "right" };
+  }
+  if (to.cy > from.cy) return { fromSide: "bottom", toSide: "top" };
+  return { fromSide: "top", toSide: "bottom" };
+}
+
+function oppositeSide(s: Side): Side {
+  switch (s) {
+    case "top":
+      return "bottom";
+    case "bottom":
+      return "top";
+    case "left":
+      return "right";
+    case "right":
+      return "left";
+  }
+}
+
+/**
+ * node の側 (top / bottom / left / right) の中央座標を返す。 CAR-429 で offset 分散を削除、
+ * 全 edge の起点 / 終点は側の中央固定 (offset=0 SSOT)。
+ */
+function sidePoint(n: LaidNode, side: Side): { x: number; y: number } {
+  switch (side) {
+    case "top":
+      return { x: n.cx, y: n.cy - n.h / 2 };
+    case "bottom":
+      return { x: n.cx, y: n.cy + n.h / 2 };
+    case "left":
+      return { x: n.cx - n.w / 2, y: n.cy };
+    case "right":
+      return { x: n.cx + n.w / 2, y: n.cy };
+  }
+}
+
+/**
+ * orthogonal routing。
+ * - 横水平 (left/right pair で y 揃い) → 真横直線
+ * - 横水平 (y 不一致) → S 字 (cubic bezier)
+ * - 縦垂直 (top/bottom pair で x 揃い) → 真縦直線
+ * - 縦垂直 (x 不一致) → L 字 (途中で 90° 曲げ + 角丸)
+ * - その他 (top→right 等の交差) → L 字
+ */
+function routePath(
+  from: LaidNode,
+  to: LaidNode,
+  fromSide: Side,
+  toSide: Side,
+  obstacles: LaidNode[] = [],
+  /** 逆向きの edge と通り道を共有する時に割り当てられる側。 未指定なら右。 */
+  detourSide?: DetourSide,
+  _fromLane?: LaidLane,
+  _toLane?: LaidLane,
+  edge?: CdlEdge,
+  labelObstacles: LaidNode[] = obstacles,
+  // CAR-541 SSOT ... 同 node 対称対 lower edge の両 endpoint 平行 shift 量 (world unit)。
+  // layoutEdges で対称対検出し lower edge に fromOffset = toOffset (両端同量) を割り当てる、
+  // upper edge / 非対称対 edge は {x=0, y=0} で従来動作を維持。 両端同量 shift なので直線 SSOT
+  // (A.y = B.y) が保存され corner 挿入されない。 side に対する perpendicular 軸 (left/right → Y、
+  // top/bottom → X) 側の値のみ non-zero、 parallel 軸側は node 側縁上を維持するため 0。
+  fromOffset: { x: number; y: number } = { x: 0, y: 0 },
+  toOffset: { x: number; y: number } = { x: 0, y: 0 },
+  /**
+   * 迂回の折れ位置が入ってはいけない箱 (別 edge の label pill)。
+   *
+   * routing の 1 巡目では label 位置が未確定なので空で呼び、 label が出そろってから
+   * `widenDetourStubs` が同じ引数に本 list を足して呼び直す。
+   */
+  avoidRects: readonly Rect[] = [],
+): {
+  d: string;
+  labelX: number;
+  labelY: number;
+  labelAnchor: "start" | "middle" | "end";
+  /**
+   * 経路が `avoidRects` を見たか。 迂回経路だけが真になる。
+   *
+   * 見ない経路は札が出そろってから呼び直しても同じ結果を返すため、 呼出側が 2 巡目を省ける。
+   */
+  consultsAvoidRects?: boolean;
+  /**
+   * 自 path を挟んで labelX と反対側にある、 等価な label 中心 X。
+   *
+   * 縦 straight route の label は path の左右どちらに置いても自 path からの距離が等しい。
+   * 既定の右側が別 edge の経路で塞がっている時に限り、 layoutEdges の post-pass が
+   * こちらへ移す (`flipLabelToFreeSide`)。 左右対称でない route は undefined。
+   */
+  labelAltX?: number;
+} {
+  // label 幅 = SSOT = spec.ts の computeLabelBoxW (CAR-431 で collections.ts labelBBox /
+  // render/edges.tsx / predict-bbox.ts の 4 箇所計算を集約)。 L 字 midX / midY を label 収納可能な
+  // 位置に押し出す判定で使う。 CLEARANCE_NODE_LABEL は clearance-constants.ts SSOT import。
+  const labelBoxW = edge ? computeLabelBoxW(edge.label, edge.sub) : 0;
+  const labelHalfW = labelBoxW / 2;
+  // CAR-518 SSOT ... solid = LABEL_INIT_CLEARANCE (34、 CAR-630 で 26 → 34 復帰)、 dotted-flow = LABEL_INIT_CLEARANCE_DOTTED_FLOW (62、 CAR-630 で 54 → 62 復帰)。
+  // routePath 内 labelY 計算 8 箇所で参照、 style 分岐を helper 経由で単一 SSOT 化する。
+  const labelInit = labelInitClearance(edge);
+  const verticalPair = (fromSide === "bottom" && toSide === "top") || (fromSide === "top" && toSide === "bottom");
+  const horizontalPair = (fromSide === "right" && toSide === "left") || (fromSide === "left" && toSide === "right");
+  // top-top routing ... back transition で fromSide=top + toSide=top で明示 detour
+  const topTopPair = fromSide === "top" && toSide === "top";
+
+  // CAR-429 SSOT ... 起点 / 終点は side の中央固定 (旧実装の verticalPair sideOffsetA /
+  // horizontalPair clampOffsetY による y 分散を削除)。 label 重複解消は post-pass 2 の
+  // resolveEdgeLabelOverlapsWithChain が担当する。
+  // CAR-541 SSOT ... 同 node 対称対 lower edge の両 endpoint 平行 shift 量 (fromOffset = toOffset)。
+  // upper edge / 非対称対 edge は fromOffset = toOffset = {0, 0} で従来動作を維持。 両端同量 shift
+  // なので直線 (A.y = B.y) の直進性 SSOT が保存され L-corner branch には落ちない。
+  const Araw = sidePoint(from, fromSide);
+  const Braw = sidePoint(to, toSide);
+  const A = { x: Araw.x + fromOffset.x, y: Araw.y + fromOffset.y };
+  const B = { x: Braw.x + toOffset.x, y: Braw.y + toOffset.y };
+
+  // edge label を path 中点に配置 (デフォルト位置)。
+  // CAR-430 SSOT ... 本 routePath() が返す (labelX, labelY) が label 位置の SSOT。
+  // 節に被る場合は post-pass 2 の resolveEdgeLabelOverlapsWithChain が chain 伝搬で
+  // 連鎖 shift 解消する。 旧 label-shift.ts の 16 方向 × 26 段階全探索は削除済。
+  if (horizontalPair && Math.abs(A.y - B.y) < 1) {
+    // 直線経路上に別 node が立ち塞がる場合、 上方 or 下方に detour path で回避する。
+    const blockers = horizontalDetourBlockers(A, B, obstacles);
+    if (blockers.length > 0) {
+      // node 上方 or 下方の近い方を選ぶ。 A.y が最初の obstacle 中心より上なら上方、 下なら下方。
+      const detourGap = 50;
+      const isUp = A.y <= blockers[0]!.cy;
+      // 迂回する高さ = 全 blocker の外端のうち最も遠いもの + gap。 1 個だけ避けると、 背の高い
+      // 2 個目を貫通する (Issue #211 の縦 detour と同じ欠陥、 横にも残っていた)。
+      const detourY = isUp
+        ? Math.min(...blockers.map((n) => n.cy - n.h / 2)) - detourGap
+        : Math.max(...blockers.map((n) => n.cy + n.h / 2)) + detourGap;
+      const corner = 14;
+      const xDir = B.x > A.x ? 1 : -1;
+      // CAR-482 SSOT ... corner 方向は「Y 進行方向」 で決定 (旧 isUp 単一 flag では 4 corner
+      // で同方向の S 字風変な折れが発生していた)。
+      // exit 側 (A.y → detourY) の corner 方向 = detourY - A.y の符号、 enter 側 (detourY → B.y)
+      // は B.y - detourY の符号。 水平 pair (A.y ≈ B.y) では exit / enter が opposite 符号になる。
+      // isUp (detourY < A.y) case = exit corner 上向き (cornerDirA = -1)、 enter corner 下向き (cornerDirB = 1)。
+      // isDown (detourY > A.y) case = exit corner 下向き (1)、 enter corner 上向き (-1)。
+      const cornerDirA: 1 | -1 = detourY < A.y ? -1 : 1;
+      const cornerDirB: 1 | -1 = B.y < detourY ? -1 : 1;
+      // CAR-472 SSOT ... 起点 / 終点で水平 EDGE_STUB_OUT (40 world) 直進を保証。
+      // 旧実装 = M A.x A.y L A.x detourY (X 変化 0 で即上折れ / 即下折れ)、
+      // 起点即折れは「起点がどの node 由来か視覚判別困難」 症状を起こすため spec.ts SSOT に統一。
+      // 新 path = 起点から水平 stubOut → 垂直 → 水平 detour → 垂直 → 終点手前で水平 stubOut → 終点。
+      //
+      // #418 ... 固定 40 だと走る距離が長い edge で「箱を出た瞬間に折れる」 見え方になるため、
+      // 走る距離の比で決める (`detourStubOut`)。 折れる位置に node が居る場合は手前へ引き戻す。
+      const vTop = Math.min(A.y, B.y, detourY);
+      const vBottom = Math.max(A.y, B.y, detourY);
+      const nodeBoxes = obstacles.filter((o) => o.id !== from.id && o.id !== to.id).map(nodeRect);
+      const exitX = A.x + xDir * detourStub(A.x, xDir, vTop, vBottom, nodeBoxes, avoidRects);
+      const enterX = B.x - xDir * detourStub(B.x, (-xDir) as 1 | -1, vTop, vBottom, nodeBoxes, avoidRects);
+      return {
+        d: `M ${A.x} ${A.y}
+          L ${exitX - xDir * corner} ${A.y}
+          Q ${exitX} ${A.y}, ${exitX} ${A.y + cornerDirA * corner}
+          L ${exitX} ${detourY - cornerDirA * corner}
+          Q ${exitX} ${detourY}, ${exitX + xDir * corner} ${detourY}
+          L ${enterX - xDir * corner} ${detourY}
+          Q ${enterX} ${detourY}, ${enterX} ${detourY + cornerDirB * corner}
+          L ${enterX} ${B.y - cornerDirB * corner}
+          Q ${enterX} ${B.y}, ${enterX + xDir * corner} ${B.y}
+          L ${B.x} ${B.y}`,
+        labelX: (A.x + B.x) / 2,
+        // CAR-468 SSOT ... 旧 ±30 magic number を LABEL_INIT_CLEARANCE (26 world、 CAR-482 で 22 → 26、 CAR-483 で 26 → 34、 CAR-570 で 34 → 26 縮小) に置換。
+        // CAR-518 SSOT ... dotted-flow style edge は 62 world (marker glow 分拡張) を labelInit で参照。
+        // isUp = 上方 detour → label は detour path の さらに上方 (-labelInit)、 isDown = 下方 detour → 下方 (+labelInit)。
+        labelY: detourY + (isUp ? -labelInit : labelInit),
+        labelAnchor: "middle",
+        consultsAvoidRects: true,
+      };
+    }
+    // horizontal straight の label 初期位置 (CAR-430 SSOT)。
+    // 旧 v7 は A.y - 30 で path 直上に置き shift 探索に逃がしていたが、 label-shift.ts 削除で
+    // init 位置が SSOT になったため、 label が from / to node bbox と label 幅方向で overlap するかを
+    // 幾何的に判定して 2 経路に分岐する。
+    //
+    // (1) label x 帯が from / to node bbox と重ならない = label center が gap 中央、 label 半幅が
+    //     min(from.right, to.left) - max(A.x + label_hw, B.x - label_hw) 内 = path 直上 30 で安全
+    // (2) label x 帯が bbox と重なる = label は node 上端の外側に置く必要あり
+    //     = A.y - max(from.h, to.h) / 2 - CLEARANCE_NODE_LABEL - label_h / 2
+    //     (v6 の nodeMaxH/2 + clearance + label_hh と同じ formula、 v10 で大型 entity の視覚関連
+    //      喪失問題は今 chain shift + parallel offset で緩和されるため、 安全側に振る)
+    const labelCx = (A.x + B.x) / 2;
+    const fromLeft = from.cx - from.w / 2;
+    const fromRight = from.cx + from.w / 2;
+    const toLeft = to.cx - to.w / 2;
+    const toRight = to.cx + to.w / 2;
+    const labelLeft = labelCx - labelHalfW;
+    const labelRight = labelCx + labelHalfW;
+    // label x 帯が from / to bbox と overlap するか。 CLEARANCE_NODE_LABEL を含めた安全境界。
+    const labelXOverlapsNode =
+      (labelLeft < fromRight + CLEARANCE_NODE_LABEL && labelRight > fromLeft - CLEARANCE_NODE_LABEL) ||
+      (labelLeft < toRight + CLEARANCE_NODE_LABEL && labelRight > toLeft - CLEARANCE_NODE_LABEL);
+    const nodeMaxH = Math.max(from.h, to.h);
+    const labelHalfH = 18;
+    // CAR-468 SSOT ... labelXOverlapsNode false case は path 直上、 旧 -30 magic number を
+    // LABEL_INIT_CLEARANCE (26 world、 CAR-482 で 22 → 26、 CAR-483 で 26 → 34、 CAR-570 で 34 → 26 縮小) に置換
+    // (label center と path center の距離)。
+    // CAR-518 SSOT ... dotted-flow は 62 world (marker glow radius 分拡張) を labelInit で参照。
+    // CAR-549 SSOT ... overlay:true (flowchart condition label 等) は label center Y = edge Y で
+    // path 上に重ねる (edge の semantic 強調)。 true case (node bbox 内 overlap) は overlay より
+    // node 押し出し優先 (label 可読性維持)。
+    // true case (node bbox 内 overlap) は node 外に押し出す geometry で SSOT 対象外。
+    const labelY = labelXOverlapsNode
+      ? A.y - nodeMaxH / 2 - CLEARANCE_NODE_LABEL - labelHalfH
+      : edge?.overlay
+        ? A.y
+        : A.y - labelInit;
+    // CAR-604 SSOT ... 水平 dotted-flow edge の marker (dotted-flow の動く点) が edge 中央
+    // (label 直下) を通過する時、 label pill と marker が視覚的に「同一縦線上」 で交差する。
+    // Y 方向は既に 36 world (LABEL_TO_PATH_CLEARANCE 8 + MARKER_GLOW_RADIUS 28) 離しているが、
+    // X 中央一致で marker と pill が交差する症状を解消する。
+    //
+    // dotted-flow ... labelX は path 内部の source 側に配置。 A→B が左→右 (B.x > A.x) なら
+    //   pill 左端 = A.x + labelPathClearanceHorizontal(edge)、 A→B が右→左 (A.x > B.x) なら
+    //   pill 左端 = B.x + labelPathClearanceHorizontal(edge) (path 端 = min(A.x, B.x) から
+    //   内部方向に offset)。 垂直 dotted-flow edge の label X (CAR-573 + CAR-601) と対称 SSOT。
+    // solid ... labelX = (A.x + B.x) / 2 (中央維持、 marker なしなので中央上配置で問題ない)。
+    //
+    // CAR-618 SSOT ... A.x > B.x (右→左方向、 sequence rows / 反射 edge 等) の case で label
+    // pill が path 右端 (B.x = source 右隣 anchor が反転側) の外側に飛び出す regression を解消。
+    // path range [min(A.x, B.x), max(A.x, B.x)] 内側に pill を保つため、 anchor 側 (min(A.x, B.x))
+    // から内部方向に offset を積む SSOT に統一する。
+    //
+    // node overlap 判定 (labelXOverlapsNode) は中央 X 前提の bbox 重なり判定、 source 右側 shift
+    // 後は node 押し出しなしで済む幾何を想定 (source node right side から離れる方向で shift)。
+    const isDottedFlow = edge?.style === "dotted-flow";
+    const anchorX = Math.min(A.x, B.x);
+    const labelXFinal = isDottedFlow ? anchorX + labelPathClearanceHorizontal(edge) + labelHalfW : labelCx;
+    return {
+      d: `M ${A.x} ${A.y} L ${B.x} ${B.y}`,
+      labelX: labelXFinal,
+      labelY,
+      labelAnchor: "middle",
+    };
+  }
+  if (horizontalPair) {
+    // A.y != B.y 時、 L 字 orthogonal routing で交差回避。
+    // CAR-429 で fan-in / fan-out offset 分散を削除、 L 字 corner は A/B 中央固定。
+    // 複数 edge の label 重複は post-pass 2 (resolveEdgeLabelOverlapsWithChain) で解消。
+    const corner = 14;
+    const xDir = B.x > A.x ? 1 : -1;
+    const yDir = B.y > A.y ? 1 : -1;
+    // routing v8 = A / B 間の水平 gap が label 幅 + clearance より狭く、 obstacle で挟まれた
+    // 幾何の場合、 L 字を諦めて水平 detour 経路を採用する。
+    // detour 判定 = A.right (or A.x) と B.left (or B.x) の間の gap を測り、 gap < label 幅 +
+    // clearance × 2 なら obstacle 帯を上迂回 or 下迂回。 上下方向はどちらが svg 内側かで決定。
+    // 例 = pattern-rollback で op.right → db.left の 71.69px 隙間に label 幅 78 + clearance 64
+    // が入らず、 tx (op の上、 db の左隣) と衝突不可避。 下迂回で commit.bottom + gap まで
+    // 水平 detour segment を伸ばし、 label をそこに配置する。
+    if (labelHalfW > 0) {
+      const gapX = Math.abs(B.x - A.x);
+      // routing v8 = engine world 座標系と DOM 描画 px スケールの乖離を吸収する経験係数。
+      //
+      // 根拠 (実測 SSOT) ...
+      //   - dragon の CdlDiagramThumbnail は display 幅 CSS 490 px、 engine 計算後 viewBox 幅 1820 world unit
+      //   - display px per world unit = 490 / 1820 = 0.269 (world unit 1 = display px 0.269)
+      //   - measureTextWidth("tentative write") = 145 world unit を返す (fontSize=17 世界単位 と同 pt スケール)
+      //   - 実 DOM 描画 label 幅 = 78 px、 world unit 換算 = 78 / 0.269 = 290 → engine 過小評価 2 倍
+      //   - CLEARANCE_NODE_LABEL=32 world unit は DOM 8.6 px 相当、 実 clearance 32 px 保証には world 119 unit 必要
+      //   - 総合逆比 ≈ 3.7-4.0、 実装では 4.0 で detour 過剰なし + border case 7 件全解消
+      //
+      // 前提 (壊れると再検証必要) ...
+      //   - dragon の CdlDiagramThumbnail display 幅を 490 px 相当に維持
+      //   - diagram viewBox 幅を 1500-2000 world unit 相当に維持 (author lane 定数 SSOT)
+      //   - font (Inter / Newsreader) が変更されて char 幅が大きくずれない
+      //
+      // dynamic 化を検討したが (viewBox 幅 / display 幅 の比を engine で自動算出)、 (a) engine は
+      // DOM display 幅を知らず author 宣言必要 (b) viewBox 幅は edges.ts 呼び出し中には未確定
+      // (label 配置に依存する chicken-and-egg) で engineering cost に見合わない、 hard-code 4.0
+      // で SSOT comment 強化する方針を採用。
+      //
+      // 大幅な display / viewBox 比変更 (thumbnail size 変更等) が発生したら本ブロックの実測 SSOT
+      // を再測定して係数を再チューニングする。
+      const WORLD_SCALE = 4.0;
+      const needX = labelBoxW * WORLD_SCALE + CLEARANCE_NODE_LABEL * 2 * WORLD_SCALE;
+      // A / B 間の x 帯 [Math.min(A.x, B.x), Math.max(A.x, B.x)] に obstacle が挟まれてる場合
+      // 判定 x 帯は label 幅 world scale 分を加算して obstacle の隣接 (tx.right = A.x のような
+      // ぴったり境界 case) も detour 対象に含める。
+      const bandExtend = labelBoxW * WORLD_SCALE / 2 + CLEARANCE_NODE_LABEL * WORLD_SCALE;
+      const xMinAB = Math.min(A.x, B.x) - bandExtend;
+      const xMaxAB = Math.max(A.x, B.x) + bandExtend;
+      const yMinAB = Math.min(A.y, B.y);
+      const yMaxAB = Math.max(A.y, B.y);
+      const midObstacles = labelObstacles.filter((o) => {
+        if (o.id === from.id || o.id === to.id) return false;
+        const oLeft = o.cx - o.w / 2;
+        const oRight = o.cx + o.w / 2;
+        const oTop = o.cy - o.h / 2;
+        const oBottom = o.cy + o.h / 2;
+        // A/B の x 帯 (label 幅 world scale 分拡張済) を跨ぐ + y も A / B 帯周辺
+        return oRight > xMinAB && oLeft < xMaxAB && oTop < yMaxAB + 20 && oBottom > yMinAB - 20;
+      });
+      // CAR-491 SSOT ... horizontal detour 発火条件を「L 字 midX の垂直 segment or L 字 corner 帯を
+      // 実際に obstacle が塞ぐ」 場合に限定する。 従来は yMinAB..yMaxAB の A/B 帯にある obstacle を
+      // 一律 midObstacle 扱いしていたため、 L 字の垂直 segment (midX = (A.x+B.x)/2 前後) から遠い
+      // obstacle でも detour が発火して mindMap root→ui / flowchart Review→Revise のような
+      // viewport 下端まで届く大迂回が発生していた。
+      //
+      // 判定 = L 字 corner の x 座標帯 (midX ± labelHalfW ± CLEARANCE_NODE_LABEL) に垂直 segment が
+      // 通り、 その帯内で midObstacle が Y 方向 A..B 帯と交差するか。 midX 上に obstacle が無いなら
+      // 通常 L (line 552 以降 midX retreat 経路) で自然に回避できるので horizontal detour は不要。
+      //
+      // A.y ≈ B.y の完全水平は既に line 347 分岐で処理済のため、 本 branch (A.y != B.y) では
+      // L 字の垂直 segment 帯を実際に obstacle が塞ぐ幾何のみ detour する。
+      const midXCandidate = A.x + (B.x - A.x) * 0.5;
+      const lBandLeft = midXCandidate - labelHalfW - CLEARANCE_NODE_LABEL;
+      const lBandRight = midXCandidate + labelHalfW + CLEARANCE_NODE_LABEL;
+      const lBlockingObstacles = midObstacles.filter((o) => {
+        const oLeft = o.cx - o.w / 2;
+        const oRight = o.cx + o.w / 2;
+        const oTop = o.cy - o.h / 2;
+        const oBottom = o.cy + o.h / 2;
+        // 垂直 segment 帯 (midX ± labelHalfW ± clearance) と obstacle が X で重なる、 かつ
+        // 垂直 segment の Y range (yMinAB..yMaxAB) と Y で重なる
+        return oRight > lBandLeft && oLeft < lBandRight && oTop < yMaxAB && oBottom > yMinAB;
+      });
+      if (gapX < needX && lBlockingObstacles.length > 0) {
+        // 下迂回 detour = 全 midObstacle bottom + gap で水平 segment を伸ばす。
+        // label はその水平 segment 上に配置 (中心 x = (A.x + B.x) / 2)。
+        // routing v10.1 = gap 44 → 94 に拡張 (+50)。 obstacle.bottom + clearance 32 world
+        // (DOM ~8px) では label bottom が obstacle bottom を 24 world 割り込む
+        // (pattern-rollback e3 の label × commit 20 px² overlap の root cause)。 gap +50 で
+        // 最終 label 位置が obstacle bottom から 66 world (DOM ~16px) 離れ、
+        // pre-existing G2/G3 gate に影響与えずに pattern-rollback を engine 側解消。
+        const gap = 94;
+        const labelBoxH = 36;
+        const labelHalfH = labelBoxH / 2;
+        // detour Y は label bbox が全 obstacle (A/B 自身含む) + clearance と干渉しない位置に置く。
+        // 全 obstacle の bottom / top の最大 / 最小を取り、 全部の下 / 上 に迂回する。
+        const labelBoxHalfHFinal = labelHalfH + CLEARANCE_NODE_LABEL;
+        const allNodes: LaidNode[] = [from, to, ...labelObstacles];
+        const allBottomsMax = allNodes.reduce((m, n) => Math.max(m, n.cy + n.h / 2), -Infinity);
+        const allTopsMin = allNodes.reduce((m, n) => Math.min(m, n.cy - n.h / 2), Infinity);
+        const detourYDown = allBottomsMax + gap + labelBoxHalfHFinal;
+        const detourYUp = allTopsMin - gap - labelBoxHalfHFinal;
+        // svg viewport 下限は自動拡張されるので下迂回 default。 上迂回は allTopsMin が
+        // viewport top (経験値 y=68 相当) より label 収納幅以上余裕がある場合のみ。
+        // pattern-rollback tx.top=128 で detourYUp=34 は viewBox y=68 の上、 clip されるため
+        // upMargin 判定で下迂回を選ぶ。
+        const upMargin = labelBoxHalfHFinal * 2 + gap + 40;
+        // CAR-429 SSOT ... offset=0 固定になったため、 fan-in slot 別 detour Y 分散
+        // (旧: detourYAdjust = |offset|/fanGap * detourSlotSize) は削除。 label 重複解消は
+        // post-pass 2 の resolveEdgeLabelOverlapsWithChain が chain 伝搬で解消する。
+        const isDownDetour = allTopsMin <= upMargin;
+        const detourY = isDownDetour ? detourYDown : detourYUp;
+        // path = A→A.right の少し外→垂直で detourY→水平で B の少し外→垂直で B.y→B
+        // sidepoint A/B の xDir 方向に少しだけ出て垂直に折れ、 detourY 帯で水平にする。
+        // CAR-472 SSOT ... 起点 stub は EDGE_STUB_OUT (40 world) 統一 (旧 30 magic number)。
+        // #418 ... 走る距離の比で決める (上の水平 detour と同じ規則)。
+        const vTop = Math.min(A.y, B.y, detourY);
+        const vBottom = Math.max(A.y, B.y, detourY);
+        const nodeBoxes = obstacles.filter((o) => o.id !== from.id && o.id !== to.id).map(nodeRect);
+        const exitX = A.x + xDir * detourStub(A.x, xDir, vTop, vBottom, nodeBoxes, avoidRects);
+        const enterX = B.x - xDir * detourStub(B.x, (-xDir) as 1 | -1, vTop, vBottom, nodeBoxes, avoidRects);
+        // CAR-472 SSOT ... label は detour segment 中央ではなく LABEL_INIT_CLEARANCE (26、 CAR-570 で 34 → 26 縮小) 上方に配置。
+        // CAR-518 SSOT ... dotted-flow は 62 world (marker glow radius 分拡張) を labelInit で参照。
+        // isDownDetour = true 時 label は detour segment の下方 +labelInit、 false (上方 detour) 時 -labelInit。
+        // detour segment 上に label pill を直接置くと path と label が重なる (旧 labelY: detourY 実装)。
+        const labelDy = isDownDetour ? labelInit : -labelInit;
+        return {
+          d: `M ${A.x} ${A.y}
+            L ${exitX - xDir * corner} ${A.y}
+            Q ${exitX} ${A.y}, ${exitX} ${A.y + (detourY > A.y ? 1 : -1) * corner}
+            L ${exitX} ${detourY - (detourY > A.y ? 1 : -1) * corner}
+            Q ${exitX} ${detourY}, ${exitX + xDir * corner} ${detourY}
+            L ${enterX - xDir * corner} ${detourY}
+            Q ${enterX} ${detourY}, ${enterX} ${detourY + (B.y > detourY ? 1 : -1) * corner}
+            L ${enterX} ${B.y - (B.y > detourY ? 1 : -1) * corner}
+            Q ${enterX} ${B.y}, ${enterX + xDir * corner} ${B.y}
+            L ${B.x} ${B.y}`,
+          labelX: (A.x + B.x) / 2,
+          labelY: detourY + labelDy,
+          labelAnchor: "middle",
+          consultsAvoidRects: true,
+        };
+      }
+    }
+    // midX の基準 = A と B の 50% (中央)。 CAR-429 で offset=0 固定になったため、
+    // 旧実装の slot 別 midX 分散 (offset * 0.5) は削除、 L 字 corner は A/B の中央固定。
+    let midX = A.x + (B.x - A.x) * 0.5;
+    // routing v8 = label 幅が obstacle 間 gap より広い場合、 midX を label 収納可能位置に押し出す。
+    // 例 = pattern-rollback の op → db 水平 route で、 midX = 319 (tx.right=283, db.left=355 の中央)
+    // に label 幅 78 半分 = 39 で label 左端 = 280、 tx.right = 283 に 3px 食い込む。
+    // fix = midX 垂直 segment 帯 [midX - labelHalfW - clearance, midX + labelHalfW + clearance]
+    // と交差する node を検出して midX を obstacle 外へ retreat。 A / B node 自身は除外。
+    if (labelHalfW > 0) {
+      const yMinRoute = Math.min(A.y, B.y);
+      const yMaxRoute = Math.max(A.y, B.y);
+      const labelBand = (mx: number): [number, number] => [
+        mx - labelHalfW - CLEARANCE_NODE_LABEL,
+        mx + labelHalfW + CLEARANCE_NODE_LABEL,
+      ];
+      const intersects = (obs: LaidNode, band: [number, number]): boolean => {
+        if (obs.id === from.id || obs.id === to.id) return false;
+        const oLeft = obs.cx - obs.w / 2;
+        const oRight = obs.cx + obs.w / 2;
+        const oTop = obs.cy - obs.h / 2;
+        const oBottom = obs.cy + obs.h / 2;
+        // 垂直 segment (midX, yMinRoute → yMaxRoute) と node bbox の交差判定に加えて、
+        // label bbox (垂直 segment 中点上下) の x 帯とも交差する node を検出。
+        if (oRight <= band[0] || oLeft >= band[1]) return false;
+        // 垂直 segment 通過帯と交差する y (obs.top < yMaxRoute && obs.bottom > yMinRoute) or
+        // label 中点 (yMid) が obs 帯に含まれる。 label 中点は verticalMidY = (A.y+B.y)/2。
+        const yMidLabel = (A.y + B.y) / 2;
+        const labelTop = yMidLabel - 25;
+        const labelBottom = yMidLabel + 25;
+        const segIntersect = oTop < yMaxRoute && oBottom > yMinRoute;
+        const labelIntersect = oTop < labelBottom && oBottom > labelTop;
+        return segIntersect || labelIntersect;
+      };
+      // xDir 方向に obstacle を避けて midX を retreat する。
+      let iter = 0;
+      while (iter < 12) {
+        const band = labelBand(midX);
+        const hit = labelObstacles.find((o) => intersects(o, band));
+        if (!hit) break;
+        // hit を xDir 方向に回避、 obstacle right/left から labelHalfW + clearance を確保
+        // xDir=1 (右向き) なら hit.right + labelHalfW + clearance より右へ、
+        // xDir=-1 (左向き) なら hit.left - labelHalfW - clearance より左へ。
+        // ただし xDir 側に既に押し出す余地が無い場合 (B の反対) は逆方向に retreat する。
+        const hitLeft = hit.cx - hit.w / 2;
+        const hitRight = hit.cx + hit.w / 2;
+        const retreatRight = hitRight + labelHalfW + CLEARANCE_NODE_LABEL + 4;
+        const retreatLeft = hitLeft - labelHalfW - CLEARANCE_NODE_LABEL - 4;
+        // 現 midX と近い方の retreat 側を選ぶ。 midX を大きく動かさない方向優先。
+        const dRight = Math.abs(retreatRight - midX);
+        const dLeft = Math.abs(retreatLeft - midX);
+        midX = dRight <= dLeft ? retreatRight : retreatLeft;
+        iter++;
+      }
+    }
+    // label 初期位置 = L 字 corner の垂直 segment 中点、 A.y と B.y の中間 高さ (routing v6)。
+    // 旧実装は labelX=(A.x+midX)/2, labelY=A.y の水平 segment 上に置いていたが、 label 幅の広い
+    // edge (幅 230px 等) では A 側 node bbox に食い込んで overlap 発生 (rollback pattern e3 の
+    // op node × label overlap=1278 が典型例)。 routing v6 では垂直 segment 中点に置いて、
+    // A 側 node からの水平距離 |midX - A.x| で node 外に確実に離す。
+    // routing v8 = verticalMidY を obstacle 帯を避ける y に調整。 label bbox 縦帯 (verticalMidY ± 25)
+    // が obstacle と交差する場合、 A.y または B.y に近い側の label-safe 位置に移動する。
+    let verticalMidY = (A.y + B.y) / 2;
+    if (labelHalfW > 0) {
+      const labelBoxH = 36;
+      const labelHalfH = labelBoxH / 2;
+      const labelCX = midX;
+      const labelBandXLeft = labelCX - labelHalfW - CLEARANCE_NODE_LABEL;
+      const labelBandXRight = labelCX + labelHalfW + CLEARANCE_NODE_LABEL;
+      const isLabelHit = (my: number): boolean => {
+        for (const o of labelObstacles) {
+          if (o.id === from.id || o.id === to.id) continue;
+          const oLeft = o.cx - o.w / 2;
+          const oRight = o.cx + o.w / 2;
+          const oTop = o.cy - o.h / 2;
+          const oBottom = o.cy + o.h / 2;
+          if (oRight <= labelBandXLeft || oLeft >= labelBandXRight) continue;
+          const labelTop = my - labelHalfH - CLEARANCE_NODE_LABEL;
+          const labelBottom = my + labelHalfH + CLEARANCE_NODE_LABEL;
+          if (oBottom <= labelTop || oTop >= labelBottom) continue;
+          return true;
+        }
+        return false;
+      };
+      if (isLabelHit(verticalMidY)) {
+        // A.y ± 40 と B.y ± 40 を試して label-safe な位置を見つける
+        const candidates = [
+          A.y + yDir * 40, // A.y から yDir 方向に 40px shift
+          A.y - yDir * 40,
+          B.y - yDir * 40,
+          B.y + yDir * 40,
+          Math.min(A.y, B.y) - 40,
+          Math.max(A.y, B.y) + 40,
+        ];
+        const safe = candidates.find((y) => !isLabelHit(y));
+        if (safe !== undefined) verticalMidY = safe;
+      }
+    }
+    // CAR-615 SSOT ... L-shape orthogonal branch (horizontalPair + A.y != B.y) の overlay:true 対応。
+    // 水平 straight branch (line 634 の `edge?.overlay ? A.y`) と垂直 straight branch (line 972 の
+    // `edge?.overlay ? A.x`) は既に overlay 実装済だが、 L 字 orthogonal branch は verticalMidY の
+    // path midpoint 経路のみで overlay flag を無視していた (flowchart fc-2-review-revise で
+    // pill 4 corner → path 最短距離 = 51 world = SSOT 8 に対し +43 の regression)。
+    //
+    // 実装 = L 字 の 3 直線 segment (exit 水平 → mid 垂直 → enter 水平、 Q corner は無視) の
+    // 長さを算出し、 最長 segment の中点に label 中心を置く。 pill 中心が最長 segment 上に載る、
+    // pill 4 corner → path 実距離 ≈ 0 world (完全 overlay) = 水平 / 垂直 straight overlay と同 SSOT。
+    //
+    // fc-2 例 ... exit 水平 (706.22→567.11) 139 world / mid 垂直 (274→546) 272 world /
+    // enter 水平 (539.11→400) 139 world、 最長 = mid 垂直、 中点 = (553.11, 410)、
+    // pill (label 幅 102 × 高さ 36) 中心 = (553.11, 410) で垂直 segment 上 straddle。
+    if (edge?.overlay) {
+      const exitEndX = midX - xDir * corner;
+      const enterStartX = midX + xDir * corner;
+      const midStartY = A.y + yDir * corner;
+      const midEndY = B.y - yDir * corner;
+      const segments = [
+        { len: Math.abs(exitEndX - A.x), midXVal: (A.x + exitEndX) / 2, midYVal: A.y },
+        { len: Math.abs(midEndY - midStartY), midXVal: midX, midYVal: (midStartY + midEndY) / 2 },
+        { len: Math.abs(B.x - enterStartX), midXVal: (enterStartX + B.x) / 2, midYVal: B.y },
+      ];
+      const longest = segments.reduce((a, b) => (b.len > a.len ? b : a));
+      return {
+        d: `M ${A.x} ${A.y}
+          L ${midX - xDir * corner} ${A.y}
+          Q ${midX} ${A.y}, ${midX} ${A.y + yDir * corner}
+          L ${midX} ${B.y - yDir * corner}
+          Q ${midX} ${B.y}, ${midX + xDir * corner} ${B.y}
+          L ${B.x} ${B.y}`,
+        labelX: longest.midXVal,
+        labelY: longest.midYVal,
+        labelAnchor: "middle",
+      };
+    }
+    return {
+      d: `M ${A.x} ${A.y}
+        L ${midX - xDir * corner} ${A.y}
+        Q ${midX} ${A.y}, ${midX} ${A.y + yDir * corner}
+        L ${midX} ${B.y - yDir * corner}
+        Q ${midX} ${B.y}, ${midX + xDir * corner} ${B.y}
+        L ${B.x} ${B.y}`,
+      labelX: midX,
+      labelY: verticalMidY,
+      labelAnchor: "middle",
+    };
+  }
+  if (verticalPair && Math.abs(A.x - B.x) < 1) {
+    const blockers = verticalDetourBlockers(A, B, obstacles);
+    if (blockers.length > 0) {
+      const detourGap = VERTICAL_DETOUR_GAP;
+      const corner = VERTICAL_DETOUR_CORNER;
+      const yDir = B.y > A.y ? 1 : -1;
+      // 迂回列 X = 全 blocker の外端 ± gap。 これで全 obstacle の外を通る。
+      // 逆向きの edge が同じ通り道を使う時だけ左へ回す (assignDetourSides、 既定は右)。
+      const side: DetourSide = detourSide ?? "right";
+      const xDir = side === "left" ? -1 : 1;
+      const column = detourColumnFor(blockers, side);
+      // A source node の 出口 = source 下端付近 (yDir 方向に h の一部進んだ場所) から出る
+      const exitY = A.y + yDir * VERTICAL_DETOUR_EXIT;
+      // 戻り点 = 進行方向で最後の (最も target 寄りの) blocker を越えた位置 + gap。
+      // 1 個目だけで折り返すと、 戻りの縦線が 2 個目の obstacle を貫く。
+      const lastBlockerEdge =
+        yDir > 0
+          ? Math.max(...blockers.map((n) => n.cy + n.h / 2))
+          : Math.min(...blockers.map((n) => n.cy - n.h / 2));
+      const returnY = lastBlockerEdge + yDir * detourGap;
+      // CAR-573 SSOT ... labelAnchor = "middle" に統一 (pill 内文字中央寄せ)。
+      // pill 中心 X = column + xDir * (labelPathClearanceHorizontal(edge) + labelHalfW)、
+      // pill の内側の端 = column + xDir * labelPathClearanceHorizontal(edge) で detour 垂直 segment X から
+      // solid=16 / dotted-flow=44 (glow radius 28 加算、 CAR-630 で 8 → 16 復帰) world 離れ、 水平 edge (pill 下端 → path Y = solid 16 / dotted-flow 44)
+      // と同一 SSOT。 旧実装 (CAR-549) は goRight + labelInit (=26) で pill 左端 → path X = 26 world、
+      // 水平 8 world と非対称だった。 CAR-573 で全方向 pill 端 → path 実距離を LABEL_TO_PATH_CLEARANCE (solid) に統一。
+      // CAR-601 で dotted-flow の MARKER_GLOW_RADIUS 加算漏れ regression を解消
+      // (`labelPathClearanceHorizontal(edge)` helper 経由で solid / dotted-flow 2 分岐を SSOT 化)。
+      // CAR-630 で LABEL_TO_PATH_CLEARANCE 8 → 16 復帰、 solid=16 / dotted-flow=44 world に変更。
+      // 旧実装 (CAR-472) は labelAnchor = "start" + labelX = goRight + EDGE_STUB_OUT * 2 (magic 80) で
+      // pill 内文字が左寄り + offset が SSOT 外 (80 world) だった。
+      // detour path 経路では垂直 segment が label 位置基準になるため overlay flag は無視、
+      // detour segment 中央 (exitY と returnY の中点) を label Y とする (path 上重ね不可能な迂回経路)。
+      return {
+        d: `M ${A.x} ${A.y}
+          L ${A.x} ${exitY - yDir * corner}
+          Q ${A.x} ${exitY}, ${A.x + xDir * corner} ${exitY}
+          L ${column - xDir * corner} ${exitY}
+          Q ${column} ${exitY}, ${column} ${exitY + yDir * corner}
+          L ${column} ${returnY - yDir * corner}
+          Q ${column} ${returnY}, ${column - xDir * corner} ${returnY}
+          L ${B.x + xDir * corner} ${returnY}
+          Q ${B.x} ${returnY}, ${B.x} ${returnY + yDir * corner}
+          L ${B.x} ${B.y}`,
+        labelX: column + xDir * (labelPathClearanceHorizontal(edge) + labelHalfW),
+        labelY: (exitY + returnY) / 2,
+        labelAnchor: "middle",
+      };
+    }
+
+    // vertical straight edge の label Y = path の中点 (A.y + B.y) / 2 (Issue #202)。
+    // A.y = 上 node の下端、 B.y = 下 node の上端なので、 これは 2 node の隙間の中点でもある。
+    // label は隙間の中央に置かれ、 上下の余白が必ず等しくなる。
+    //
+    // CAR-549 は「上下 node の中心平均」 (from.cy + to.cy) / 2 に変更していた。 node の高さが
+    // 等しければ両者は一致するが、 違うと中心平均は隙間の中点から (lower.h - upper.h) / 4 だけ
+    // ずれる。 狭い側の余白が CLEARANCE_NODE_LABEL (32) を下回り、 catalog で clearance error を
+    // 11 件発生させていた (実測。 例 = topology TCP 5432 で ECS 側 21 / RDS 側 11)。
+    //
+    // 隙間そのものが label を収めるだけの高さを持つことは、 layoutNodes の
+    // `requiredStackGapForEdgeLabels` が stack gap を先手拡張して保証する。
+    const midY = (A.y + B.y) / 2;
+    // CAR-573 SSOT ... vertical straight edge の label X = edge X + labelPathClearanceHorizontal(edge) + labelHalfW、
+    // labelAnchor = "middle" に統一 (pill 内文字中央寄せ)。
+    // pill 中心 X = A.x + labelPathClearanceHorizontal(edge) + labelHalfW、
+    // pill 左端 = A.x + labelPathClearanceHorizontal(edge) で edge から solid=16 / dotted-flow=44 world 離れ (CAR-630 復帰)、
+    // 水平 edge (pill 下端 → path Y = solid=16 / dotted-flow=44) と同一 SSOT を全方向適用。
+    // 旧実装 (CAR-549) は A.x + labelInit (=26) で pill 左端 → path X = 26 world、 水平 8 world と非対称だった。
+    // CAR-573 で全方向 pill 端 → path 実距離を LABEL_TO_PATH_CLEARANCE (solid) に統一、
+    // CAR-601 で dotted-flow の MARKER_GLOW_RADIUS (28 world) 加算漏れ regression を
+    // `labelPathClearanceHorizontal(edge)` helper で解消 (solid / dotted-flow の 2 分岐 SSOT 化)。
+    // CAR-630 で SSOT 8 → 16 復帰、 solid=16 / dotted-flow=44 world に更新。
+    // overlay:true (flowchart condition label 等) は label center を edge X に重ねる (labelX = A.x)、
+    // 垂直 dotted-flow edge は pill 左端 → path X = 44 world (glow radius 28 加算) で marker 通過帯を確保。
+    return {
+      d: `M ${A.x} ${A.y} L ${B.x} ${B.y}`,
+      labelX: edge?.overlay ? A.x : A.x + labelPathClearanceHorizontal(edge) + labelHalfW,
+      labelY: midY,
+      labelAnchor: "middle",
+      // overlay は path 上に重ねる semantic なので左右の概念を持たない。
+      labelAltX: edge?.overlay ? undefined : A.x - labelPathClearanceHorizontal(edge) - labelHalfW,
+    };
+  }
+  if (verticalPair) {
+    // 中間 node と水平 segment (y=midY) が衝突するなら midY を上下にずらす。
+    // mind-demo で root(x=180,y=203) → launch(x=620,y=703) の path midY=453 が
+    // 中間 node ui(cx=620, cy=453) を貫通する crashing bug の解消 (routing v7 追加)。
+    let midY = (A.y + B.y) / 2;
+    const xDir = B.x > A.x ? 1 : -1;
+    const xRange = [Math.min(A.x, B.x), Math.max(A.x, B.x)];
+    /** 水平部の高さ `my` を帯に含み、 かつ水平部の X 範囲と重なる node。 */
+    const midBlockersAt = (my: number): LaidNode[] =>
+      obstacles.filter((n) => {
+        const nLeft = n.cx - n.w / 2;
+        const nRight = n.cx + n.w / 2;
+        const nTop = n.cy - n.h / 2;
+        const nBottom = n.cy + n.h / 2;
+        return nRight > xRange[0]! && nLeft < xRange[1]! && my >= nTop && my <= nBottom;
+      });
+    /**
+     * 中間 node と衝突しなくなるまで、 node 下端 + gap へ midY を退避する。
+     *
+     * 1 個だけ避けると、 背の高い 2 個目を貫通する (Issue #231)。 全 blocker の下端の最大値まで
+     * 退避し、 退避先で新たに重なった node があれば繰り返す。
+     *
+     * 退避前の midY は必ずいずれかの blocker の帯の中にあるので、 退避後はその下端を越える。
+     * midY は毎回いずれかの下端を越えて単調に下がり、 同じ下端を 2 度越えることはない。
+     * したがって反復回数は相異なる下端の数を超えない。 obstacles の数で縛れば必ず止まる。
+     */
+    const retreatBelowMidBlockers = (my: number): number => {
+      const gap = 40;
+      for (let iter = 0; iter <= obstacles.length; iter++) {
+        const hits = midBlockersAt(my);
+        if (hits.length === 0) break;
+        my = Math.max(...hits.map((n) => n.cy + n.h / 2)) + gap;
+      }
+      return my;
+    };
+    midY = retreatBelowMidBlockers(midY);
+    // 経路が node を貫かない高さ。 後段の label 退避が範囲外へ出た時の戻り先に使う。
+    const pathSafeMidY = midY;
+    // routing v8 = label 高さ (label anchor middle + midY 帯 sideShift) が obstacle 縦帯と交差する場合、
+    // midY を obstacle 外へ retreat。 horizontalPair の midX retreat の 90 度回転版。
+    if (labelHalfW > 0) {
+      const yDir = B.y > A.y ? 1 : -1;
+      const labelBoxH = 36;
+      const labelHalfH = labelBoxH / 2;
+      const intersectsV = (obs: LaidNode, my: number): boolean => {
+        if (obs.id === from.id || obs.id === to.id) return false;
+        const oLeft = obs.cx - obs.w / 2;
+        const oRight = obs.cx + obs.w / 2;
+        const oTop = obs.cy - obs.h / 2;
+        const oBottom = obs.cy + obs.h / 2;
+        // label 中点は水平 segment 中央付近 (A.x → B.x の間) に配置される。
+        // label bbox = 中心 ((A.x+B.x)/2, my) + width labelBoxW / height labelBoxH。
+        const labelCX = (A.x + B.x) / 2;
+        const labelLeft = labelCX - labelHalfW - CLEARANCE_NODE_LABEL;
+        const labelRight = labelCX + labelHalfW + CLEARANCE_NODE_LABEL;
+        const labelTop = my - labelHalfH - CLEARANCE_NODE_LABEL;
+        const labelBottom = my + labelHalfH + CLEARANCE_NODE_LABEL;
+        if (oRight <= labelLeft || oLeft >= labelRight) return false;
+        if (oBottom <= labelTop || oTop >= labelBottom) return false;
+        return true;
+      };
+      let iter = 0;
+      while (iter < 12) {
+        const hit = labelObstacles.find((o) => intersectsV(o, midY));
+        if (!hit) break;
+        const hitTop = hit.cy - hit.h / 2;
+        const hitBottom = hit.cy + hit.h / 2;
+        const retreatDown = hitBottom + labelHalfH + CLEARANCE_NODE_LABEL + 4;
+        const retreatUp = hitTop - labelHalfH - CLEARANCE_NODE_LABEL - 4;
+        const dDown = Math.abs(retreatDown - midY);
+        const dUp = Math.abs(retreatUp - midY);
+        // yDir 側 (target 方向) 優先で retreat
+        midY = yDir > 0
+          ? (dDown <= dUp ? retreatDown : retreatUp)
+          : (dUp <= dDown ? retreatUp : retreatDown);
+        iter++;
+      }
+      // A.y と B.y の中間から大きく離れると path 全体が折れて視覚的に不自然、
+      // A / B 間の外に retreat した場合は clamp (path 上下端 + gap 内)
+      const yMin = Math.min(A.y, B.y) + 30;
+      const yMax = Math.max(A.y, B.y) - 30;
+      if (midY < yMin || midY > yMax) {
+        // 経路が node を貫かない高さへ戻す (残 overlap は post-pass 2 chain shift が解消)。
+        //
+        // 中点へ戻すと、 前段で避けた node の帯に水平部が入り直す (Issue #231)。 label が
+        // 中心からずれることより、 経路が node を貫くことの方が重い。
+        midY = pathSafeMidY;
+      }
+    }
+    // label 退避が水平部を node の帯へ戻した可能性がある。 経路の安全を最後に確定させる。
+    midY = retreatBelowMidBlockers(midY);
+    const corner = 14;
+    // CAR-429 で offset=0 固定 (旧: offset 符号で midY - 50 / midY - 90 分岐) 削除。
+    // CAR-468 SSOT ... 旧 midY - 50 magic number を LABEL_INIT_CLEARANCE (26、 CAR-570 で 34 → 26 縮小) に置換、
+    // path 中点上方 34 world = pill 端 と path 実距離 16 world (spec 準拠)。
+    // CAR-518 SSOT ... dotted-flow は 62 world (marker glow radius 分拡張) を labelInit で参照。
+    // fan-in / fan-out の分散は chain 伝搬 shift が担当。
+    const labelY = midY - labelInit;
+    return {
+      d: `M ${A.x} ${A.y}
+        L ${A.x} ${midY - corner}
+        Q ${A.x} ${midY}, ${A.x + xDir * corner} ${midY}
+        L ${B.x - xDir * corner} ${midY}
+        Q ${B.x} ${midY}, ${B.x} ${midY + corner}
+        L ${B.x} ${B.y}`,
+      labelX: (A.x + B.x) / 2,
+      labelY,
+      labelAnchor: "middle",
+    };
+  }
+  // top-top routing ... back transition (FSM 等で fromSide=top + toSide=top で明示 detour 経路を作る)。
+  // 両 node 上端から path を上方 detour させ、 forward path (node 中心線上) と重ならないよう描画。
+  // routing v7 = detour 高さを 200 → 100 に縮小。 200px 上に飛ぶと state から遠く label が「浮いて」 見える。
+  // 100px = state h/2 (75) + margin 25、 forward path (state 中心線) からは h/2 + 100 = 175px 離れて overlap 回避。
+  if (topTopPair) {
+    const detourY = Math.min(A.y, B.y) - 100;
+    const corner = 14;
+    const xDir = B.x > A.x ? 1 : -1;
+    return {
+      d: `M ${A.x} ${A.y}
+        L ${A.x} ${detourY + corner}
+        Q ${A.x} ${detourY}, ${A.x + xDir * corner} ${detourY}
+        L ${B.x - xDir * corner} ${detourY}
+        Q ${B.x} ${detourY}, ${B.x} ${detourY + corner}
+        L ${B.x} ${B.y}`,
+      labelX: (A.x + B.x) / 2,
+      // CAR-468 SSOT ... 旧 detourY - 30 magic number を LABEL_INIT_CLEARANCE (26、 CAR-570 で 34 → 26 縮小) に置換。
+      // CAR-518 SSOT ... dotted-flow は 62 world (marker glow radius 分拡張) を labelInit で参照。
+      // top-top detour の水平 segment 上方 labelInit world = spec 準拠距離。
+      labelY: detourY - labelInit,
+      labelAnchor: "middle",
+    };
+  }
+  const midX = fromSide === "left" || fromSide === "right" ? B.x : A.x;
+  const midY = fromSide === "top" || fromSide === "bottom" ? B.y : A.y;
+  return {
+    d: `M ${A.x} ${A.y} L ${midX} ${midY} L ${B.x} ${B.y}`,
+    labelX: (A.x + B.x) / 2,
+    // CAR-468 SSOT ... 旧 - 32 magic number を LABEL_INIT_CLEARANCE (26、 CAR-570 で 34 → 26 縮小) に置換。
+    // CAR-518 SSOT ... dotted-flow は 62 world (marker glow radius 分拡張) を labelInit で参照。
+    // fallback route の label は path 最上端から labelInit world 上方 = spec 準拠距離。
+    labelY: Math.min(A.y, B.y) - labelInit,
+    labelAnchor: "middle",
+  };
+}
+
+/**
+ * 弧を確定させた後に、 同じ節の組を結ぶ辺の label を「兄弟の線を跨がない位置」 へ置き直す (#376)。
+ *
+ * `layoutEdges` の中では線がまだ直線で、 弧は `bowSharedStraightPaths` が後から付ける。 直線を
+ * 前提に置いた label は、 弧が付いた後に貫かれる (実測 = 往復 2 本 / 4 本、 片方向 2 本 / 4 本)。
+ *
+ * 逆に label を先に線から離すと、 弧を膨らませる判定が label を障害物と見なして弧を諦める。
+ * そのため順序は「弧を先に確定 (自群の label は障害物に数えない) → label を置き直す」 にする。
+ * 呼ぶ場所は `layout.ts` の `bowSharedStraightPaths` の直後。
+ *
+ * 動かす単位と避ける対象は分ける。
+ *
+ * - **動かす単位** = 横に重なる label の塊。 横に離れている label を一緒に動かすと、 動かす
+ *   必要のない label まで自分の線から引き剥がす
+ * - **避ける対象** = 同じ節の組の **全ての線**。 塊の中の線だけ見ると、 `labelOffsetX` で横に
+ *   逃がした兄弟の線を跨いだままになる
+ *
+ * 1 つしかない塊も対象にする。 兄弟の線を跨いでいれば動かす余地がある。
+ *
+ * 置く先の良し悪しは 2 段で見る。 まず **跨る線の数**、 同じなら **動かす量**。 跨りを直すのが
+ * 目的なので数を先に見る。 数が同じなら動かさない置き方が選ばれる。
+ *
+ * 以下 2 つは満たさない置き方を捨てる。
+ *
+ * - **節との間隔を今より悪くしない**。 跨りを直すために節へ乗り上げるのは差し引きで損
+ *   (実測 = 縦の平行 2 本で節との間隔が 32 の要求に対して 21 まで詰まった)
+ * - **節の組の中での並び順を変えない**。 `bowSharedStraightPaths` は label の並び順で弧を振り
+ *   分けるため ([#374](https://github.com/cardene777/cdl/issues/374))、 順序が変わると弧と
+ *   label の対応が崩れる。 塊ごとに独立して動かすと塊をまたいで順序が入れ替わり得る
+ *
+ * @param edges 確定済 path を持つ辺。 `labelY` のみを書き換える
+ * @param nodes 節。 間隔が悪化する置き方を捨てるために使う
+ */
+export function repositionParallelLabels(edges: LaidEdge[], nodes: LaidNode[]): void {
+  // 図の全ての線 (実際に描かれる形)。 1 度だけ開いて使い回す。
+  const allSegs = new Map(
+    edges.map((e) => [e.id, flattenPathSegments(extractPathSegments(e.d))] as const),
+  );
+  /** 線の X 範囲。 label の横幅と重ならない線は判定から落とすのに使う。 */
+  const xRange = new Map<string, { min: number; max: number }>();
+  for (const [id, segs] of allSegs) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (const s of segs) {
+      min = Math.min(min, s.x1, s.x2);
+      max = Math.max(max, s.x1, s.x2);
+    }
+    xRange.set(id, { min, max });
+  }
+
+  const byPair = new Map<string, LaidEdge[]>();
+  for (const e of edges) {
+    if (!hasRenderedLabel(e)) continue;
+    const key = e.from < e.to ? `${e.from}::${e.to}` : `${e.to}::${e.from}`;
+    const list = byPair.get(key) ?? [];
+    list.push(e);
+    byPair.set(key, list);
+  }
+
+  for (const pair of byPair.values()) {
+    if (pair.length < 2) continue;
+    // 弧を振り分けた時の並び順。 置き直しでこれを変えない。 順序の定義は
+    // `compareSharedPairOrder` に集めてあり、 `bowSharedStraightPaths` も同じものを使う。
+    const pairOrder = [...pair].sort(compareSharedPairOrder);
+
+    // 横に重なる label ごとに塊を作る (1 つだけの塊も含む)。
+    const boxes = pair.map((e) => computeLabelBBoxWorld(e));
+    const componentOf = pair.map((_, i) => i);
+    for (let i = 0; i < pair.length; i++) {
+      for (let j = i + 1; j < pair.length; j++) {
+        const a = boxes[i]!;
+        const b = boxes[j]!;
+        const apart =
+          Math.abs(a.x + a.w / 2 - (b.x + b.w / 2)) >= (a.w + b.w) / 2 + CLEARANCE_LABEL_LABEL;
+        if (apart) continue;
+        const from = componentOf[j]!;
+        const to = componentOf[i]!;
+        if (from === to) continue;
+        for (let k = 0; k < componentOf.length; k++) {
+          if (componentOf[k] === from) componentOf[k] = to;
+        }
+      }
+    }
+
+    for (const root of new Set(componentOf)) {
+      const members = pair.filter((_, i) => componentOf[i] === root);
+      const placed = placeAvoidingSiblingPaths({
+        members,
+        pair,
+        pairOrder,
+        nodes,
+        allEdges: edges,
+        allSegs,
+        xRange,
+      });
+      for (let i = 0; i < members.length; i++) members[i]!.labelY = placed[i]!;
+    }
+  }
+}
+
+/**
+ * 兄弟の線を跨がない位置に label を積む (#376)。
+ *
+ * 各 label に「兄弟の線が通る帯」 を禁止区間として与える。 自分の線は除く = label が自分の線の
+ * 上に乗るのは通常の配置で、 描画側も衝突扱いしない。
+ *
+ * 帯に数えるのは **label の横幅の下を通る部分だけ**。 線を label の X 区間で切ってから Y を取る。
+ * 切らずに端点の Y を取ると、 label の外まで伸びた斜線が帯を過大にする (実測 = 同じ形の斜線を
+ * 範囲外へ伸ばしただけで配置が [132,232] から [-32,200] に動いた)。
+ *
+ * 解き方は「帯の上に何本、 下に何本」 の分け方を全通り試す。 分け目は並び順を保つ (上側は先頭
+ * から、 下側は末尾まで) ので候補は本数 + 1 通りしかない。 各側は `spreadWithMinimalShift` で
+ * 間隔を満たしてから、 帯に入らない位置まで塊ごと平行移動する。 塊を動かしても間隔は変わらない
+ * ので、 移動後も間隔は満たしたままになる。
+ *
+ * 「禁止区間に入った label を近い縁へ動かして置き直す」 反復は採らない。 置き直すたびに
+ * `spreadWithMinimalShift` が塊を帯の中心へ引き戻すため、 4 本の図で振動して収束しない (実測)。
+ */
+function placeAvoidingSiblingPaths(args: {
+  members: LaidEdge[];
+  pair: LaidEdge[];
+  pairOrder: LaidEdge[];
+  nodes: LaidNode[];
+  allEdges: LaidEdge[];
+  allSegs: Map<string, Array<{ x1: number; y1: number; x2: number; y2: number }>>;
+  xRange: Map<string, { min: number; max: number }>;
+}): number[] {
+  const { members, pair, pairOrder, nodes, allEdges, allSegs, xRange } = args;
+  const sizes = members.map((e) => labelPillH(e.sub));
+  const wants = members.map((e) => e.labelY);
+  const boxes = members.map((e) => computeLabelBBoxWorld(e));
+  const all = members.map((_, i) => i);
+  const spread = (idx: number[]): number[] =>
+    spreadWithMinimalShift(
+      idx.map((i) => ({ want: wants[i]!, size: sizes[i]! })),
+      CLEARANCE_LABEL_LABEL,
+    );
+
+  /** 線分を X 区間 [left, right] で切った時の Y 範囲。 交わらなければ null。 */
+  const clipY = (
+    s: { x1: number; y1: number; x2: number; y2: number },
+    left: number,
+    right: number,
+  ): { lo: number; hi: number } | null => {
+    const sMin = Math.min(s.x1, s.x2);
+    const sMax = Math.max(s.x1, s.x2);
+    if (sMax < left || sMin > right) return null;
+    const dx = s.x2 - s.x1;
+    if (dx === 0) return { lo: Math.min(s.y1, s.y2), hi: Math.max(s.y1, s.y2) };
+    const at = (x: number): number => s.y1 + ((x - s.x1) / dx) * (s.y2 - s.y1);
+    const a = at(Math.max(sMin, left));
+    const b = at(Math.min(sMax, right));
+    return { lo: Math.min(a, b), hi: Math.max(a, b) };
+  };
+
+  /** 各 label にとっての禁止区間。 節の組の全ての線を見る (塊の中だけでは足りない)。 */
+  const bands = members.map((e, i) => {
+    const box = boxes[i]!;
+    const left = box.x;
+    const right = box.x + box.w;
+    let lo = Infinity;
+    let hi = -Infinity;
+    for (const other of pair) {
+      if (other.id === e.id) continue;
+      for (const seg of allSegs.get(other.id) ?? []) {
+        const clipped = clipY(seg, left, right);
+        if (!clipped) continue;
+        lo = Math.min(lo, clipped.lo);
+        hi = Math.max(hi, clipped.hi);
+      }
+    }
+    if (lo > hi) return null;
+    const margin = sizes[i]! / 2 + CLEARANCE_PATH_LABEL;
+    return { lo: lo - margin, hi: hi + margin };
+  });
+
+  const nodeRects = nodes.map((n) => ({ x: n.cx - n.w / 2, y: n.cy - n.h / 2, w: n.w, h: n.h }));
+  /** label を y に置いた時の、 最も近い節との隙間。 */
+  const nodeGapAt = (i: number, y: number): number => {
+    const box = boxes[i]!;
+    const top = y - box.h / 2;
+    let min = Infinity;
+    for (const r of nodeRects) {
+      const dx = Math.max(0, r.x - (box.x + box.w), box.x - (r.x + r.w));
+      const dy = Math.max(0, r.y - (top + box.h), top - (r.y + r.h));
+      min = Math.min(min, Math.hypot(dx, dy));
+    }
+    return min;
+  };
+
+  // 判定に関わり得る線だけを残す (label の横幅と X が重なるもの)。
+  const nearby = members.map((e, i) => {
+    const box = boxes[i]!;
+    return allEdges.filter((o) => {
+      if (o.id === e.id) return false;
+      const r = xRange.get(o.id);
+      return r !== undefined && r.max >= box.x && r.min <= box.x + box.w;
+    });
+  });
+  // 自分と共有する区間を除いた線分。 候補ごとに作り直すと同じ計算を繰り返すので先に作る。
+  const probeSegs = members.map((e, i) => {
+    const own = allSegs.get(e.id) ?? [];
+    return nearby[i]!.map((other) => ({
+      id: other.id,
+      segs: segmentsExcludingOwnPath(allSegs.get(other.id) ?? [], own),
+    })).filter((x) => x.segs.length > 0);
+  });
+  /** label を y に置いた時に貫いてくる線の id 集合。 自分の線と、 共有する区間は数えない。 */
+  const crossSetAt = (i: number, y: number): Set<string> => {
+    const box = boxes[i]!;
+    const rect = { x: box.x, y: y - box.h / 2, w: box.w, h: box.h };
+    const out = new Set<string>();
+    for (const probe of probeSegs[i]!) {
+      if (segmentsCrossRect(probe.segs, rect)) out.add(probe.id);
+    }
+    return out;
+  };
+
+  const beforeGap = all.map((i) => nodeGapAt(i, wants[i]!));
+  const beforeCross = all.map((i) => crossSetAt(i, wants[i]!));
+  const beforeCrossTotal = beforeCross.reduce((acc, set) => acc + set.size, 0);
+  // 節の組のうち、 この塊に含まれない label の現在位置 (並び順の確認に使う)。
+  const outside = pair.filter((e) => !members.includes(e));
+
+  const order = [...all].sort((a, b) => wants[a]! - wants[b]!);
+  const orderPreserved = (ys: number[]): boolean => {
+    const merged = [
+      ...members.map((e, i) => ({ id: e.id, y: ys[i]! })),
+      ...outside.map((e) => ({ id: e.id, y: e.labelY })),
+    ].sort((a, b) => a.y - b.y || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return merged.every((m, i) => m.id === pairOrder[i]!.id);
+  };
+
+  let best: { cross: number; move: number; ys: number[] } | null = null;
+  const consider = (ys: number[]): void => {
+    if (
+      all.some((i) => {
+        const gap = nodeGapAt(i, ys[i]!);
+        return gap < CLEARANCE_NODE_LABEL && gap < beforeGap[i]!;
+      })
+    ) {
+      return;
+    }
+    if (!orderPreserved(ys)) return;
+    // 元は跨っていなかった線を新たに跨ぐ置き方は捨てる。 数が減っていても、 跨る相手が
+    // 入れ替わっただけなら直したことにならない。
+    let cross = 0;
+    for (const i of all) {
+      const after = crossSetAt(i, ys[i]!);
+      for (const id of after) if (!beforeCross[i]!.has(id)) return;
+      cross += after.size;
+    }
+    const move = all.reduce((acc, i) => acc + (ys[i]! - wants[i]!) ** 2, 0);
+    if (!best || cross < best.cross || (cross === best.cross && move < best.move)) {
+      best = { cross, move, ys };
+    }
+  };
+
+  // 動かさない置き方も候補に入れる (跨りが無いならこれが最善)。
+  consider([...wants]);
+  if (bands.some((b) => b !== null)) {
+    for (let split = 0; split <= order.length; split++) {
+      const above = order.slice(0, split);
+      const below = order.slice(split);
+      const out = new Array<number>(members.length);
+      for (const [idx, side] of [
+        [above, "above"],
+        [below, "below"],
+      ] as const) {
+        if (idx.length === 0) continue;
+        const ys = spread(idx);
+        // 帯に入らない位置まで塊ごと動かす。 必要な移動量が最大の label に合わせる。
+        let shift = 0;
+        for (let k = 0; k < idx.length; k++) {
+          const band = bands[idx[k]!];
+          if (!band) continue;
+          shift =
+            side === "above" ? Math.min(shift, band.lo - ys[k]!) : Math.max(shift, band.hi - ys[k]!);
+        }
+        for (let k = 0; k < idx.length; k++) out[idx[k]!] = ys[k]! + shift;
+      }
+      // 上側の末尾と下側の先頭が足りなければ、 下側を塊ごとさらに下げる。 帯を挟んでいても
+      // pill どうしの間隔は要る (実測 = 帯を挟んで 100 しか空かず、 要求の 104 に届かない図)。
+      if (above.length > 0 && below.length > 0) {
+        const lastIdx = above[above.length - 1]!;
+        const firstIdx = below[0]!;
+        const need = (sizes[lastIdx]! + sizes[firstIdx]!) / 2 + CLEARANCE_LABEL_LABEL;
+        const deficit = need - (out[firstIdx]! - out[lastIdx]!);
+        if (deficit > 0) for (const i of below) out[i]! += deficit;
+      }
+      consider(out);
+    }
+  }
+  // 間隔だけを満たす置き方も候補に入れる (帯が無い / 帯を避ける置き方が全て捨てられた時)。
+  const plain = spread(all);
+  const byIdx = new Array<number>(members.length);
+  for (let k = 0; k < all.length; k++) byIdx[all[k]!] = plain[k]!;
+  consider(byIdx);
+
+  if (!best) return [...wants];
+  const chosen: { cross: number; move: number; ys: number[] } = best;
+  // 跨りが減らないなら動かさない (無駄に動かして自分の線から離さない)。
+  return chosen.cross < beforeCrossTotal || chosen.move === 0 ? chosen.ys : [...wants];
+}