@cardenelabs/cdl 0.5.0

package/src/layout/collisions.ts

@@ -0,0 +1,2078 @@
+import type { BBox, LaidEdge, LaidLane, LaidNode } from "../types";
+import { CHAIN_SHIFT_MAX_ACCUMULATED, computeLabelBBoxWorld, EDGE_STUB_OUT, hasRenderedLabel, LABEL_TO_PATH_CLEARANCE, requiredNearClearance } from "./spec";
+import { measureTextWidth } from "./text-width";
+
+/**
+ * lane-label 横方向 near miss を解消する時に、 要求 clearance ちょうどではなく
+ * わずかに超えて押し出すための余裕幅。 浮動小数の丸めで再び閾値 undershoot するのを防ぐ。
+ */
+const LANE_LABEL_CLEARANCE_MARGIN = 2;
+
+/**
+ * 全要素の AABB を集約。 engine が「キャンバスに何があるか」 を全部把握する SSOT。
+ */
+export function collectBBoxes(lanes: LaidLane[], nodes: LaidNode[], edges: LaidEdge[]): BBox[] {
+  const out: BBox[] = [];
+
+  for (const lane of lanes) {
+    if (!lane.label) continue;
+    out.push({
+      kind: "lane-label",
+      id: lane.id,
+      x: lane.x + 16,
+      y: lane.y + 8,
+      w: measureTextWidth(lane.label, { fontSize: 20, letterSpacing: 2 }) + 24,
+      h: 28,
+    });
+  }
+
+  for (const n of nodes) {
+    out.push({
+      kind: "node",
+      id: n.id,
+      x: n.cx - n.w / 2,
+      y: n.cy - n.h / 2,
+      w: n.w,
+      h: n.h,
+    });
+  }
+
+  for (const e of edges) {
+    if (!hasRenderedLabel(e)) continue;
+    // SSOT = spec.ts の computeLabelBBoxWorld (CAR-431 で render / layout / predict-bbox 3 箇所の
+    // bbox 計算 drift を解消)。 旧実装は boxH = e.sub ? 64 : 36 + y = labelY - boxH/2 (centered)
+    // だったが、 render 側は boxH = 68 + yOffset shifted で描画するため実測 bbox と layout 予測が
+    // 乖離、 near-collision detection の偽陰性を生んでいた。 本 SSOT 統一で render 実 rect 位置と
+    // 一致する。
+    const bbox = computeLabelBBoxWorld(e);
+    out.push({
+      kind: "edge-label",
+      id: e.id,
+      x: bbox.x,
+      y: bbox.y,
+      w: bbox.w,
+      h: bbox.h,
+    });
+  }
+
+  for (const e of edges) {
+    const points = extractPathPoints(e.d);
+    if (points.length === 0) continue;
+    const xs = points.map((p) => p.x);
+    const ys = points.map((p) => p.y);
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minY = Math.min(...ys);
+    const maxY = Math.max(...ys);
+    out.push({
+      kind: "edge-path",
+      id: e.id,
+      x: minX - 2,
+      y: minY - 2,
+      w: maxX - minX + 4,
+      h: maxY - minY + 4,
+    });
+  }
+
+  return out;
+}
+
+/** SVG path d 文字列から M/L/C/Q コマンドの座標点を抽出する軽量 parser */
+export function extractPathPoints(d: string): Array<{ x: number; y: number }> {
+  const out: Array<{ x: number; y: number }> = [];
+  const tokens = d.replace(/[A-Za-z]/g, " ").trim().split(/[\s,]+/).filter(Boolean);
+  for (let i = 0; i + 1 < tokens.length; i += 2) {
+    const x = parseFloat(tokens[i]!);
+    const y = parseFloat(tokens[i + 1]!);
+    if (Number.isFinite(x) && Number.isFinite(y)) {
+      out.push({ x, y });
+    }
+  }
+  return out;
+}
+
+/**
+ * SVG path d 文字列を (dx, dy) 平行移動する (CAR-485 導入)。
+ *
+ * chain 伝搬 shift で `label ↔ edge-path (別 edge) near-collision` を解消するとき、
+ * label 側は labelX / labelY 加算で済むが、 path 側は d 文字列内の全 (x, y) coord ペアに
+ * (dx, dy) を加算する必要がある。 edges.ts の routePath() は M / L / Q コマンドで
+ * 全 coord を absolute 表記するため、 command tokenizer で数値 pair を舐めて加算する。
+ *
+ * 対応 command = M / L / Q (Q は controlX/Y + endX/Y の 2 pair)。 C は 3 pair (control1 +
+ * control2 + end)。 Z (closepath) は座標なしで pass through。 大文字 / 小文字は routePath()
+ * の出力に合わせて大文字のみ想定。
+ *
+ * dx = 0 かつ dy = 0 は no-op (元 d を返す)。
+ */
+export function translatePathD(d: string, dx: number, dy: number): string {
+  if (dx === 0 && dy === 0) return d;
+  return rebuildPathD(d, (x, y) => [x + dx, y + dy]);
+}
+
+/**
+ * `d` の座標 pair を `map` で置換して組み直す。 command 構造と順序は保つ。
+ *
+ * `idx` は path 先頭からの座標 pair の通し番号 (Q の control 点も 1 pair として数える)。
+ */
+function rebuildPathD(d: string, map: (x: number, y: number, idx: number) => [number, number]): string {
+  const commandRegex = /([MLCQZmlcqz])([^MLCQZmlcqz]*)/g;
+  let out = "";
+  let idx = 0;
+  let m: RegExpExecArray | null;
+  while ((m = commandRegex.exec(d)) !== null) {
+    const cmd = m[1]!;
+    const argsStr = (m[2] ?? "").trim();
+    if (argsStr === "" || cmd === "Z" || cmd === "z") {
+      out += cmd + " ";
+      continue;
+    }
+    const args = argsStr.split(/[\s,]+/).filter(Boolean).map(parseFloat);
+    const translated: number[] = [];
+    for (let i = 0; i + 1 < args.length; i += 2) {
+      const [nx, ny] = map(args[i]!, args[i + 1]!, idx);
+      translated.push(nx, ny);
+      idx += 1;
+    }
+    out += cmd + " " + translated.join(" ") + " ";
+  }
+  return out.trim();
+}
+
+/**
+ * `d` 内の座標 pair のうち、 先頭の Q の終点 index と 末尾の Q の制御点 index を返す。
+ *
+ * Q は `control` と `end` の 2 pair を持つ。 corner が無ければ両方 -1。
+ */
+function cornerBoundaryIndices(d: string): { firstCornerEnd: number; lastCornerStart: number } {
+  const commandRegex = /([MLCQZmlcqz])([^MLCQZmlcqz]*)/g;
+  let idx = 0;
+  let firstCornerEnd = -1;
+  let lastCornerStart = -1;
+  let m: RegExpExecArray | null;
+  while ((m = commandRegex.exec(d)) !== null) {
+    const cmd = m[1]!;
+    const argsStr = (m[2] ?? "").trim();
+    if (argsStr === "" || cmd === "Z" || cmd === "z") continue;
+    const pairs = argsStr.split(/[\s,]+/).filter(Boolean).length >> 1;
+    if ((cmd === "Q" || cmd === "q") && pairs >= 2) {
+      if (firstCornerEnd < 0) firstCornerEnd = idx + 1;
+      lastCornerStart = idx;
+    }
+    idx += pairs;
+  }
+  return { firstCornerEnd, lastCornerStart };
+}
+
+/**
+ * 端点領域を index で一体固定して path を平行移動する (Issue #216)。
+ *
+ * ## 背景
+ *
+ * `CAR-489` は「端点の Y は動かさない」 ために **座標値の一致** で固定点を決めていた。
+ * 端点と同じ Y を持つ点が全て固定されるため、 端点から出る直線は水平に保たれる。
+ * しかし corner (`Q control end`) の control 点は直線の延長上にあり端点と同じ Y を持つ一方、
+ * end 点は持たない。 control だけが取り残されて曲がりの向きが反転する。
+ *
+ * ```
+ * M 100 200 L 126 200 Q 140 200, 140 214 L 140 286   に dy = -30
+ *
+ * 座標値ベース ... control (140,200) 固定 / end (140,214) → 184   Δy が +14 から -16 に反転
+ * ```
+ *
+ * ## 設計
+ *
+ * corner を分断せず、 **端点から出る直線と それに続く corner を「端点領域」 として一体固定** する。
+ * ずれは corner の先の直線が長さを変えて吸収する。
+ *
+ * ```
+ * M 100 200 L 126 200 Q 140 200, 140 214   L 140 286
+ * └──────── 端点領域 (固定) ─────────┘   └ 長さで吸収 ┘
+ * ```
+ *
+ * 固定範囲は **軸ごとに変わる**。 端点から出る直線の向きを基準に決める。
+ *
+ * - shift が直線と **平行** ... 端点だけ固定する。 直線が長さを変えて吸収する
+ * - shift が直線と **直交** ... 端点領域 (端点 → 最初の corner の終点) を固定する。
+ *   corner の先の直線 (shift と平行) が長さを変えて吸収する
+ *
+ * 末尾も同様に、 最後の corner の制御点から終点までを端点領域とする。
+ *
+ * corner を持たない直線だけの path は、 直交方向に動かすと必ず端点が node の辺から外れる。
+ * よって両端が固定されて 1 点も動かない。 これは正しい挙動で、 呼び元 (`pathShiftIsSafe`) が
+ * 「1 点も動かない向き」 として検出し別の向きを試す。
+ *
+ * `dx = 0` かつ `dy = 0` は no-op。
+ */
+export function translatePathDPreservingEndpoints(d: string, dx: number, dy: number): string {
+  if (dx === 0 && dy === 0) return d;
+  const pts = extractPathPoints(d);
+  if (pts.length < 2) return d;
+
+  const { firstCornerEnd, lastCornerStart } = cornerBoundaryIndices(d);
+  const last = pts.length - 1;
+
+  /** 2 点を結ぶ向きが指定軸に沿っているか (直交する軸方向の差が小さいか)。 */
+  const alongAxis = (a: { x: number; y: number }, b: { x: number; y: number }, axis: "x" | "y"): boolean =>
+    axis === "x"
+      ? Math.abs(b.x - a.x) >= Math.abs(b.y - a.y)
+      : Math.abs(b.y - a.y) > Math.abs(b.x - a.x);
+
+  /** 指定軸で固定する index 範囲 (head は 0..headEnd、 tail は tailStart..last)。 */
+  const frozenRange = (axis: "x" | "y"): { headEnd: number; tailStart: number } => {
+    const headParallel = alongAxis(pts[0]!, pts[1]!, axis);
+    const tailParallel = alongAxis(pts[last - 1]!, pts[last]!, axis);
+    // 平行なら端点だけ、 直交なら端点領域 (corner ごと) を固定する。
+    // corner が無い path は直交方向に動かせないので全点を固定する。
+    //
+    // head の端点領域は「端点 → 直線 → corner の終点」、 tail は「corner の入口点 → corner → 端点」。
+    // corner の入口点は `Q` の制御点の 1 つ前の座標 pair なので `lastCornerStart - 1` になる。
+    // 入口点を外すと corner の始点だけが動いて曲がりが引き伸ばされる。
+    const headEnd = headParallel ? 0 : firstCornerEnd >= 0 ? firstCornerEnd : last;
+    const tailStart = tailParallel ? last : lastCornerStart >= 1 ? lastCornerStart - 1 : 0;
+    return { headEnd, tailStart };
+  };
+
+  const rangeX = frozenRange("x");
+  const rangeY = frozenRange("y");
+  const frozen = (idx: number, r: { headEnd: number; tailStart: number }): boolean =>
+    idx <= r.headEnd || idx >= r.tailStart;
+
+  return rebuildPathD(d, (x, y, idx) => [
+    frozen(idx, rangeX) ? x : x + dx,
+    frozen(idx, rangeY) ? y : y + dy,
+  ]);
+}
+
+/**
+ * node-node overlap を保守的に解消する。
+ *
+ * 設計指針 ... sequence preset の lifeline / spacer / 同 stack 配置を壊さないため
+ * 「同じ kind 同士の collision のみ resolve、 異なる kind は skip」 の保守的方針。
+ * BBox kind = "node" 同士の overlap だけを対象、 edge-path / edge-label / lane-label
+ * 絡みの overlap は元の routing 結果に任せる (それらは layout 側 detour で別途吸収)。
+ *
+ * 後勝ち戦略 ... overlap pair (a, b) のうち BBox 配列で後ろに居る方 (= diag.nodes の後 declare)
+ * を node h + 16px 下に shift。 同 node が複数 collision で被ヒットする場合は累積 shift し、
+ * shift 量を Map で管理する。
+ *
+ * sequence preset の golden 100 件は node-node overlap = 0 のため、 既存 snapshot 不変。
+ * author が manual lane.x で意図的に lane を被せた / lane.width 過小指定 etc. の場合のみ発火。
+ */
+export function resolveOverlaps(
+  nodes: LaidNode[],
+  collisions: Array<{ a: BBox; b: BBox; overlap_area: number }>,
+): LaidNode[] {
+  if (collisions.length === 0) return nodes;
+  const nodeOrder = new Map<string, number>();
+  const isAbsolute = new Map<string, boolean>();
+  nodes.forEach((n, idx) => {
+    nodeOrder.set(n.id, idx);
+    // 2026-07-24 fix (dragon editor canvas pivot、 parts merge trophy が seq preset step boxes に
+    // 累積 shift されて cy=2076 に飛ぶ bug の root fix) = posX/posY 両方 set 済の node は
+    // user 明示絶対配置と判定して shift 対象から除外する。 従来 resolveOverlaps は「後勝ち一発 shift」
+    // で全 node 対象、 絶対配置 node (parts drop + canvas pivot) も強制下方 shift されていた。
+    isAbsolute.set(n.id, n.posX !== undefined && n.posY !== undefined);
+  });
+  const additionalY = new Map<string, number>();
+  for (const c of collisions) {
+    if (c.a.kind !== "node" || c.b.kind !== "node") continue;
+    if (c.a.id === c.b.id) continue;
+    const orderA = nodeOrder.get(c.a.id);
+    const orderB = nodeOrder.get(c.b.id);
+    if (orderA == null || orderB == null) continue;
+    // 後勝ち ... 後 declare の node を下方 shift、 先 declare は据え置き。
+    //
+    // 但し座標を明示した node は動かさない (指定した位置に置くのが仕様)。 その場合は
+    // 相手が自動配置なら相手を動かして重なりを解く。 両方とも明示なら、 どちらを動かしても
+    // 指定を破ることになるので重なりを残す。
+    const later = orderA > orderB ? c.a : c.b;
+    const earlier = orderA > orderB ? c.b : c.a;
+    const move = !isAbsolute.get(later.id)
+      ? later
+      : !isAbsolute.get(earlier.id)
+        ? earlier
+        : null;
+    if (!move) continue;
+    const prev = additionalY.get(move.id) ?? 0;
+    additionalY.set(move.id, prev + move.h + 16);
+  }
+  if (additionalY.size === 0) return nodes;
+  return nodes.map((n) => {
+    const dy = additionalY.get(n.id);
+    if (!dy) return n;
+    return { ...n, cy: n.cy + dy };
+  });
+}
+
+/**
+ * chain 伝搬 shift で node-node overlap を解消する (CAR-421 導入)。
+ *
+ * `resolveOverlaps` (後勝ち一発 shift) との違い ...
+ *   1. 検出 → shift → 再検出 → 影響先 shift の loop、 CHAIN_SHIFT_MAX_ITER で強制収束
+ *   2. shift 方向 = 後 declare node を「overlap 軸の逆方向」 に押し出す
+ *   3. shift 後に 他 node と新規 overlap した場合、 その他 node も 同方向同量 shift 連鎖
+ *   4. 収束条件 = 1 iter で shift が 1 件も発生しない、 or MAX_ITER 到達
+ *
+ * 保守性 = `resolveOverlaps` と同じく node-node のみ対象。 edge-path / edge-label
+ * との衝突は下流の resolveEdgeLabelOverlapsWithChain / detour routing に任せる。
+ *
+ * shift 量 = overlap 距離 (軸方向) + minClearance。 shift 後の gap は
+ * 少なくとも minClearance 保証、 shift 累積で「押し切った」 状態を作る。
+ *
+ * 適用範囲 = `layout()` の pipeline で `resolveOverlaps` の後に opt-in で呼ぶ経路を
+ * 想定。 sequence preset (lifeline stacking) を壊さないため、 現状 default OFF、
+ * 呼び出し側で明示的に有効化する。
+ *
+ * @param nodes 元 LaidNode 列 (順序保存で返す)
+ * @param minClearance shift 後の最小 gap (world unit、 default 16)
+ * @param maxIter 収束上限 iteration 数 (default 20)
+ * @returns shift 済 LaidNode 列 (input の順序を保持)
+ */
+export function resolveOverlapsWithChain(
+  nodes: LaidNode[],
+  minClearance = 16,
+  maxIter = 20,
+): LaidNode[] {
+  if (nodes.length < 2) return nodes;
+  const nodeOrder = new Map<string, number>();
+  nodes.forEach((n, idx) => nodeOrder.set(n.id, idx));
+
+  // 累積 shift 量を Map で管理、 nodes 配列は immutable 扱いで最後に 1 回 apply。
+  const shiftMap = new Map<string, { dx: number; dy: number }>();
+  const getCx = (n: LaidNode): number => n.cx + (shiftMap.get(n.id)?.dx ?? 0);
+  const getCy = (n: LaidNode): number => n.cy + (shiftMap.get(n.id)?.dy ?? 0);
+
+  // 全 pair の overlap 検出 + 軸決定 (Y or X)、 shift 方向 = overlap 軸の逆方向。
+  // 軸判定 = |dxOverlap| vs |dyOverlap| の小さい方が「押し出しやすい軸」 とみなす。
+  type Pair = { moveId: string; axis: "x" | "y"; sign: 1 | -1; amount: number };
+  const detectPairs = (): Pair[] => {
+    const out: Pair[] = [];
+    for (let i = 0; i < nodes.length; i++) {
+      for (let j = i + 1; j < nodes.length; j++) {
+        const a = nodes[i]!;
+        const b = nodes[j]!;
+        const aCx = getCx(a);
+        const aCy = getCy(a);
+        const bCx = getCx(b);
+        const bCy = getCy(b);
+        // AABB overlap
+        const dxOverlap = Math.min(aCx + a.w / 2, bCx + b.w / 2) - Math.max(aCx - a.w / 2, bCx - b.w / 2);
+        const dyOverlap = Math.min(aCy + a.h / 2, bCy + b.h / 2) - Math.max(aCy - a.h / 2, bCy - b.h / 2);
+        if (dxOverlap <= 0 || dyOverlap <= 0) continue;
+
+        // 後勝ち = declare 後の node を shift、 先 declare は据え置き。
+        const orderA = nodeOrder.get(a.id)!;
+        const orderB = nodeOrder.get(b.id)!;
+        const moveIsA = orderA > orderB;
+        const moveId = moveIsA ? a.id : b.id;
+        // 軸選択 = overlap 面積が小さい方の軸 (= 押し出しが少ない = 影響最小)
+        const axis: "x" | "y" = dxOverlap < dyOverlap ? "x" : "y";
+        // shift 方向 = static から move へのベクトル (move を static から遠ざける)。
+        // axis=x なら Cx 差分、 axis=y なら Cy 差分の符号 で決定。
+        const moveVal = axis === "x" ? (moveIsA ? aCx : bCx) : (moveIsA ? aCy : bCy);
+        const staticVal = axis === "x" ? (moveIsA ? bCx : aCx) : (moveIsA ? bCy : aCy);
+        const sign: 1 | -1 = moveVal >= staticVal ? 1 : -1;
+        const amount = (axis === "x" ? dxOverlap : dyOverlap) + minClearance;
+        out.push({ moveId, axis, sign, amount });
+      }
+    }
+    return out;
+  };
+
+  // chain 伝搬 = shift された node と新規に overlap した「別 node」 も同方向同量 shift。
+  // 単純 loop で全 pair 再検出 + shift 適用、 shift 発生 0 で収束判定。
+  for (let iter = 0; iter < maxIter; iter++) {
+    const pairs = detectPairs();
+    if (pairs.length === 0) return applyShifts(nodes, shiftMap);
+
+    // 同 node に複数 shift 命令が来る場合、 各軸 max を採用 (累積せず「必要最小限で1回」)。
+    const shiftThisIter = new Map<string, { dx: number; dy: number }>();
+    for (const p of pairs) {
+      const prev = shiftThisIter.get(p.moveId) ?? { dx: 0, dy: 0 };
+      if (p.axis === "x") {
+        prev.dx = p.sign > 0 ? Math.max(prev.dx, p.amount) : Math.min(prev.dx, -p.amount);
+      } else {
+        prev.dy = p.sign > 0 ? Math.max(prev.dy, p.amount) : Math.min(prev.dy, -p.amount);
+      }
+      shiftThisIter.set(p.moveId, prev);
+    }
+
+    // 累積 shift Map に足し込み
+    for (const [id, s] of shiftThisIter) {
+      const prev = shiftMap.get(id) ?? { dx: 0, dy: 0 };
+      shiftMap.set(id, { dx: prev.dx + s.dx, dy: prev.dy + s.dy });
+    }
+  }
+
+  // MAX_ITER 到達 = 最大 iter でも収束せず (稀な densely packed layout)、 現時点 shift を返す。
+  return applyShifts(nodes, shiftMap);
+}
+
+function applyShifts(
+  nodes: LaidNode[],
+  shiftMap: Map<string, { dx: number; dy: number }>,
+): LaidNode[] {
+  if (shiftMap.size === 0) return nodes;
+  return nodes.map((n) => {
+    const s = shiftMap.get(n.id);
+    if (!s || (s.dx === 0 && s.dy === 0)) return n;
+    return { ...n, cx: n.cx + s.dx, cy: n.cy + s.dy };
+  });
+}
+
+export function detectCollisions(
+  bboxes: BBox[],
+  edges: LaidEdge[],
+): Array<{ a: BBox; b: BBox; overlap_area: number }> {
+  const edgeMap = new Map(edges.map((e) => [e.id, e]));
+  const out: Array<{ a: BBox; b: BBox; overlap_area: number }> = [];
+  // path 別の segments cache (同じ edge を多 bbox と比較するので 1 回展開)。
+  const segmentsCache = new Map<string, Array<{ x1: number; y1: number; x2: number; y2: number }>>();
+  const getSegments = (edgeId: string): Array<{ x1: number; y1: number; x2: number; y2: number }> | null => {
+    if (segmentsCache.has(edgeId)) return segmentsCache.get(edgeId)!;
+    const edge = edgeMap.get(edgeId);
+    if (!edge) return null;
+    const segs = extractPathSegments(edge.d);
+    segmentsCache.set(edgeId, segs);
+    return segs;
+  };
+
+  /**
+   * label と比べる時だけ使う、 曲線を **実際に描かれる形に開いた** segment 列 (#376)。
+   *
+   * 弦のままだと 2 つの見落としが出る。
+   *   1. 膨らんだ弧が pill を貫いても、 弦が pill の外なら見えない
+   *   2. 端点が同じ弧は弦が完全に一致するため、 `segmentsExcludingOwnPath` が兄弟の弧を丸ごと
+   *      「自分の線」 として取り除く (実測 = 往復 4 本の図で 3 本の弧が label を貫いても 0 件)
+   *
+   * path どうしの交差判定には使わない。 兄弟が共有する区間は 1 本の線として描かれるのが設計
+   * (CAR-429) で、 開いた形で比べると端点付近のほぼ平行な小片が交差として出る。
+   */
+  const curveCache = new Map<string, Array<{ x1: number; y1: number; x2: number; y2: number }>>();
+  const getCurveSegments = (edgeId: string): Array<{ x1: number; y1: number; x2: number; y2: number }> | null => {
+    if (curveCache.has(edgeId)) return curveCache.get(edgeId)!;
+    const edge = edgeMap.get(edgeId);
+    if (!edge) return null;
+    const segs = flattenPathSegments(extractPathSegments(edge.d));
+    curveCache.set(edgeId, segs);
+    return segs;
+  };
+
+  // overlap 検出は spatial hash で隣接 cell のみ比較 (O(n²) → O(n * k))。
+  const visit = (a: BBox, b: BBox): void => {
+    if (a.id === b.id) return;
+    if (isLegitContact(a, b, edgeMap)) return;
+
+    const pathSide = a.kind === "edge-path" ? a : b.kind === "edge-path" ? b : null;
+    const otherSide = pathSide === a ? b : pathSide === b ? a : null;
+    if (pathSide && otherSide && (otherSide.kind === "edge-label" || otherSide.kind === "node")) {
+      const isLabel = otherSide.kind === "edge-label";
+      const segments = isLabel ? getCurveSegments(pathSide.id) : getSegments(pathSide.id);
+      if (segments) {
+        // label 側は自 path と重なる segment を除外する (Issue #211、 segmentsExcludingOwnPath SSOT)。
+        const ownSegs = isLabel ? getCurveSegments(otherSide.id) : null;
+        const effective = ownSegs ? segmentsExcludingOwnPath(segments, ownSegs) : segments;
+        const rect = { x: otherSide.x, y: otherSide.y, w: otherSide.w, h: otherSide.h };
+        if (segmentsCrossRect(effective, rect)) {
+          out.push({ a, b, overlap_area: -1 });
+        }
+      }
+      return;
+    }
+
+    // edge-path × edge-path は segments 同士の実 line 交差判定。
+    // 同 from / 同 to の別 edge は sidepoint 一致で交点計算 t=0 or u=0 になるが、 legit 分岐なので除外。
+    if (a.kind === "edge-path" && b.kind === "edge-path") {
+      const edgeA = edgeMap.get(a.id);
+      const edgeB = edgeMap.get(b.id);
+      const shareFrom = edgeA && edgeB && edgeA.from === edgeB.from;
+      const shareTo = edgeA && edgeB && edgeA.to === edgeB.to;
+      const segsA = getSegments(a.id);
+      const segsB = getSegments(b.id);
+      if (segsA && segsB) {
+        for (const sa of segsA) {
+          for (const sb of segsB) {
+            if (segmentsIntersect(sa.x1, sa.y1, sa.x2, sa.y2, sb.x1, sb.y1, sb.x2, sb.y2)) {
+              // 同 from / 同 to 起因の 端点接触は legit として除外
+              if (shareFrom || shareTo) {
+                const eps = 0.5;
+                const isEndpointTouch =
+                  (Math.abs(sa.x1 - sb.x1) < eps && Math.abs(sa.y1 - sb.y1) < eps) ||
+                  (Math.abs(sa.x2 - sb.x2) < eps && Math.abs(sa.y2 - sb.y2) < eps) ||
+                  (Math.abs(sa.x1 - sb.x2) < eps && Math.abs(sa.y1 - sb.y2) < eps) ||
+                  (Math.abs(sa.x2 - sb.x1) < eps && Math.abs(sa.y2 - sb.y1) < eps);
+                if (isEndpointTouch) continue;
+              }
+              out.push({ a, b, overlap_area: -1 });
+              return;
+            }
+          }
+        }
+      }
+      return;
+    }
+
+    const overlapArea = computeOverlapArea(a, b);
+    if (overlapArea > 0) {
+      out.push({ a, b, overlap_area: overlapArea });
+    }
+  };
+
+  forEachCandidatePair(bboxes, 0, visit);
+  return out;
+}
+
+/**
+ * path d 文字列を、 描画する線分の列に分解
+ *
+ * 曲線 (Q / C) は端点を結ぶ弦に落とす。 交差判定には十分だが、 弦は実際の曲線が通る場所とは
+ * ずれる。 「この線分は本当に真っ直ぐか」 を知る必要がある呼出側のために、 由来の command
+ * (`cmd`) と制御点 (`ctrl`、 曲線のみ) を併せて返す。 弦を直線として扱うと、 端点が同じ高さで
+ * 大きく膨らむ曲線を「水平な直線」 と誤認する。
+ */
+export function extractPathSegments(
+  d: string,
+): Array<{
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  cmd: "L" | "Q" | "C";
+  ctrl?: Array<{ x: number; y: number }>;
+}> {
+  const segs: Array<{
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    cmd: "L" | "Q" | "C";
+    ctrl?: Array<{ x: number; y: number }>;
+  }> = [];
+  const commandRegex = /([MLCQZmlcqz])([^MLCQZmlcqz]*)/g;
+  let cur: { x: number; y: number } = { x: 0, y: 0 };
+  let m: RegExpExecArray | null;
+  while ((m = commandRegex.exec(d)) !== null) {
+    const cmd = m[1]!;
+    const args = (m[2] ?? "").trim().split(/[\s,]+/).filter(Boolean).map(parseFloat);
+    // 引数が足りない command は読み飛ばす。 `args[n]!` で埋めると undefined が座標に入り、
+    // 以降の segment が全て NaN になる = 距離判定が黙って対象外になる (#370)。
+    const need = cmd === "M" || cmd === "L" ? 2 : cmd === "Q" ? 4 : cmd === "C" ? 6 : 0;
+    if (need > 0 && (args.length < need || !args.slice(0, need).every(Number.isFinite))) continue;
+    if (cmd === "M") {
+      cur = { x: args[0]!, y: args[1]! };
+    } else if (cmd === "L") {
+      const next = { x: args[0]!, y: args[1]! };
+      segs.push({ x1: cur.x, y1: cur.y, x2: next.x, y2: next.y, cmd: "L" });
+      cur = next;
+    } else if (cmd === "Q") {
+      const next = { x: args[2]!, y: args[3]! };
+      segs.push({
+        x1: cur.x, y1: cur.y, x2: next.x, y2: next.y, cmd: "Q",
+        ctrl: [{ x: args[0]!, y: args[1]! }],
+      });
+      cur = next;
+    } else if (cmd === "C") {
+      const next = { x: args[4]!, y: args[5]! };
+      segs.push({
+        x1: cur.x, y1: cur.y, x2: next.x, y2: next.y, cmd: "C",
+        ctrl: [{ x: args[0]!, y: args[1]! }, { x: args[2]!, y: args[3]! }],
+      });
+      cur = next;
+    }
+  }
+  return segs;
+}
+
+/**
+ * 曲線 (Q / C) を、 実際に描かれる線に沿った折れ線に開く。
+ *
+ * `extractPathSegments` は曲線を端点どうしの弦に落とす。 交差判定はそれで足りるが、
+ * 「線からどれだけ離れているか」 を測る用途では弦は使えない = 弦は描かれていないため、
+ * 膨らむ側にある物は実際より遠く、 へこむ側にある物は実際より近く出る。
+ *
+ * 分割数は曲がり方から決める。 等分割した折れ線と真の曲線の差には閉じた形の上限がある。
+ * 二次曲線は `B(t) − 弦(t) = 2t(1−t) · (P1 − (P0+P2)/2)` なので、 `2t(1−t)` の最大 1/2 から
+ * `‖P0 − 2P1 + P2‖ / 4`。 n 等分すると各片の 2 階差分が 1/n² になるので `/(4n²)`。 三次曲線は
+ * `3 · max(‖P0 − 2P1 + P2‖, ‖P1 − 2P2 + P3‖) / (4n²)`。
+ *
+ * 分子は制御点の振れ幅で上限が無い。 そのため分割数を固定すると誤差も青天井になる
+ * (#384 実測 = `M 0 0 Q 50 -320, 100 9600` は 16 分割だと t=1/32 の y=-10 を両隣の分割点 y=0 が
+ * 挟んで消す)。 そこで上の式を n について解き、 誤差が `FLATTEN_TOLERANCE` 以下になる最小の n を
+ * 取る。 許容差 0.25 world は、 この折れ線を使う判定の閾値 (14 / 16 / 32 / 80 world) の 1/50 以下。
+ *
+ * 係数 4 は `test/label-proximity.test.ts` が確かめている。 対称な弧では標本探索の値が式の
+ * 上限の 9 割を超える = 式が緩すぎない。 8 で置くと n が √2 倍小さく出るので、 この形で
+ * 許容差を超える。
+ *
+ * 式が押さえるのは「同じ t での曲線と弦の差」 で、 実際に要る「曲線から折れ線までの距離」 は
+ * それ以下になる。 安全側にずれる。 どれだけ余裕が出るかは形で変わり、 対称な弧では上限に迫る。
+ * 上限からどれだけ下に来るかは形しだいで、 保証には使えない。
+ *
+ * 下限 `FLATTEN_MIN_DIVISIONS` = 16 を置く。 式どおりに取ると緩い弧では 16 を下回り
+ * (膨らみ 8 world の弧なら 4 分割)、 許容差の範囲では正しくても **これまでより粗くなる**。
+ * 交差判定のように閾値 0 で使う呼出元 (`collisions.ts` の label × 線、 `edges.ts` の兄弟 path
+ * 回避) は許容差を織り込んでいないので、 粗くなった分がそのまま判定の変化になる
+ * (#384 実測 = `M 0 0 Q 500 -8, 1000 0` と矩形 `{x:121, y:-1.8, w:8, h:0.1}` は 16 分割なら
+ * 交差、 4 分割だと素通り)。 精度を落とす変更にはしない。
+ *
+ * 上限 `FLATTEN_MAX_DIVISIONS` は、 極端な制御点で分割数が爆発して判定が止まるのを防ぐ安全弁。
+ * **上限に当たると許容差の保証は切れる**。 保証が効くのは `dev ≤ 4 · 許容差 · 上限²`
+ * = 16,777,216 まで。 これを超えるには二次曲線で制御点を 8,000,000 world 振る必要があり、
+ * `edges.ts` が出す弧 (辺の本数に比例、 1026 本並べても `dev` は 65,600 = 257 分割) では届かない。
+ * 上限に当たった時にどうなるかは `test/label-proximity.test.ts` が形を 2 つ並べて固定している。
+ *
+ * 制御点の数が command と合わない segment は弦に落とす。 足りない分を補うと、 元の d 文字列に
+ * 無い形を勝手に作ることになる。
+ *
+ * @param segs `extractPathSegments()` の出力
+ * @returns 直線のみからなる segment 列。 `L` はそのまま。 曲線は `FLATTEN_MIN_DIVISIONS` 以上
+ *   `FLATTEN_MAX_DIVISIONS` 以下の本数に開く。 誤差が `FLATTEN_TOLERANCE` 以下に収まるのは、
+ *   必要な分割数が上限以下に収まる曲線 (`dev ≤ 4 · 許容差 · 上限²`) に限る。 上限を超える
+ *   曲線では保証されず、 許容差を超えることがある (幅 4e7 の対称な弧では式の上限が 0.596
+ *   world で、 標本探索の値も許容差を超える)
+ */
+export const FLATTEN_TOLERANCE = 0.25;
+export const FLATTEN_MIN_DIVISIONS = 16;
+export const FLATTEN_MAX_DIVISIONS = 4096;
+
+export function flattenPathSegments(
+  segs: ReadonlyArray<{
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    cmd: "L" | "Q" | "C";
+    ctrl?: ReadonlyArray<{ x: number; y: number }>;
+  }>,
+): Array<{ x1: number; y1: number; x2: number; y2: number }> {
+  const out: Array<{ x1: number; y1: number; x2: number; y2: number }> = [];
+  for (const s of segs) {
+    const ctrl = s.ctrl ?? [];
+    const need = s.cmd === "Q" ? 1 : s.cmd === "C" ? 2 : 0;
+    if (need === 0 || ctrl.length < need) {
+      out.push({ x1: s.x1, y1: s.y1, x2: s.x2, y2: s.y2 });
+      continue;
+    }
+    // 2 階差分の大きさ = 曲がり具合。 誤差上限 dev / (4n²) ≤ tol を n について解く。
+    const secondDiff = (
+      p0: { x: number; y: number },
+      p1: { x: number; y: number },
+      p2: { x: number; y: number },
+    ): number => Math.hypot(p0.x - 2 * p1.x + p2.x, p0.y - 2 * p1.y + p2.y);
+    const p0 = { x: s.x1, y: s.y1 };
+    const p3 = { x: s.x2, y: s.y2 };
+    const dev =
+      s.cmd === "Q"
+        ? secondDiff(p0, ctrl[0]!, p3)
+        : 3 * Math.max(secondDiff(p0, ctrl[0]!, ctrl[1]!), secondDiff(ctrl[0]!, ctrl[1]!, p3));
+    const DIVISIONS = Math.min(
+      FLATTEN_MAX_DIVISIONS,
+      Math.max(FLATTEN_MIN_DIVISIONS, Math.ceil(Math.sqrt(dev / (4 * FLATTEN_TOLERANCE)))),
+    );
+    const at = (t: number): { x: number; y: number } => {
+      const u = 1 - t;
+      if (s.cmd === "Q") {
+        const c = ctrl[0]!;
+        return {
+          x: u * u * s.x1 + 2 * u * t * c.x + t * t * s.x2,
+          y: u * u * s.y1 + 2 * u * t * c.y + t * t * s.y2,
+        };
+      }
+      const c1 = ctrl[0]!;
+      const c2 = ctrl[1]!;
+      return {
+        x: u * u * u * s.x1 + 3 * u * u * t * c1.x + 3 * u * t * t * c2.x + t * t * t * s.x2,
+        y: u * u * u * s.y1 + 3 * u * u * t * c1.y + 3 * u * t * t * c2.y + t * t * t * s.y2,
+      };
+    };
+    let prev = { x: s.x1, y: s.y1 };
+    for (let i = 1; i <= DIVISIONS; i++) {
+      const p = at(i / DIVISIONS);
+      out.push({ x1: prev.x, y1: prev.y, x2: p.x, y2: p.y });
+      prev = p;
+    }
+  }
+  return out;
+}
+
+/**
+ * path 全 segment の total length と、 中央 t=0.5 地点の座標 + tangent + normal を返す。
+ * routing v10 (2026-07-02) = label 配置の hard 基準として、 label は中心 ± 20% の t 範囲に限定する。
+ * tangent = path 進行方向、 normal = tangent の 90° 左 (SVG y 軸下方向を正とする座標系での up 方向)。
+ * normal は tangent を反時計 90° 回転 = (-dy, dx) / len。 SVG 座標では画面上向き。
+ */
+export function pathCenterFrame(
+  segs: Array<{ x1: number; y1: number; x2: number; y2: number }>,
+): { cx: number; cy: number; tx: number; ty: number; nx: number; ny: number; totalLen: number } | null {
+  if (segs.length === 0) return null;
+  const lens = segs.map((s) => Math.hypot(s.x2 - s.x1, s.y2 - s.y1));
+  const totalLen = lens.reduce((a, b) => a + b, 0);
+  if (totalLen === 0) return null;
+  const halfLen = totalLen / 2;
+  let acc = 0;
+  for (let i = 0; i < segs.length; i++) {
+    const l = lens[i]!;
+    if (acc + l >= halfLen) {
+      const t = (halfLen - acc) / l;
+      const s = segs[i]!;
+      const cx = s.x1 + (s.x2 - s.x1) * t;
+      const cy = s.y1 + (s.y2 - s.y1) * t;
+      const dx = s.x2 - s.x1;
+      const dy = s.y2 - s.y1;
+      const tx = dx / l;
+      const ty = dy / l;
+      // normal = tangent 反時計 90° = (-ty, tx)、 SVG 座標系では画面上向き
+      const nx = -ty;
+      const ny = tx;
+      return { cx, cy, tx, ty, nx, ny, totalLen };
+    }
+    acc += l;
+  }
+  const last = segs[segs.length - 1]!;
+  return { cx: last.x2, cy: last.y2, tx: 0, ty: 0, nx: 0, ny: 0, totalLen };
+}
+
+/**
+ * label center が「path 中央 t=0.5 ± 20% の範囲」 かつ「normal 方向 ± 20°」 に配置されているか判定。
+ * anchor 範囲外 = label が edge の端寄り or 側面に外れて「どの edge の label か視覚上不明」 状態。
+ * routing v10 hard 制約 = このいずれか false なら label 位置は無効候補。
+ */
+export function isLabelInCenterAnchor(
+  labelCx: number,
+  labelCy: number,
+  frame: { cx: number; cy: number; tx: number; ty: number; nx: number; ny: number; totalLen: number },
+  opts: { tTolerance?: number; normalAngleTolDeg?: number } = {},
+): boolean {
+  const tTol = opts.tTolerance ?? 0.2; // ±20% of totalLen
+  const angleTol = opts.normalAngleTolDeg ?? 30; // ±30° from normal
+  const rx = labelCx - frame.cx;
+  const ry = labelCy - frame.cy;
+  // tangent 方向成分 = path center からの弧上変位、 |t 成分| ≤ tTol * totalLen なら中央 anchor 内
+  const tComp = rx * frame.tx + ry * frame.ty;
+  if (Math.abs(tComp) > tTol * frame.totalLen) return false;
+  // normal 方向成分 = path から離れた距離 (符号あり)、 tangent 方向より normal 方向が dominant なら OK
+  const nComp = rx * frame.nx + ry * frame.ny;
+  const totalDist = Math.hypot(rx, ry);
+  if (totalDist === 0) return true;
+  // normal 方向との角度差 (0°=真上 or 真下、 90°=真横)
+  const cosAngle = Math.abs(nComp) / totalDist;
+  const angleDeg = Math.acos(Math.max(-1, Math.min(1, cosAngle))) * (180 / Math.PI);
+  return angleDeg <= angleTol;
+}
+
+/** 線分の列が矩形と 1 つでも交差するか判定 (Liang-Barsky) */
+export function segmentsCrossRect(
+  segs: Array<{ x1: number; y1: number; x2: number; y2: number }>,
+  rect: { x: number; y: number; w: number; h: number },
+): boolean {
+  for (const s of segs) {
+    if (segmentIntersectsRect(s, rect)) return true;
+  }
+  return false;
+}
+
+function segmentIntersectsRect(
+  seg: { x1: number; y1: number; x2: number; y2: number },
+  rect: { x: number; y: number; w: number; h: number },
+): boolean {
+  if (pointInRect(seg.x1, seg.y1, rect)) return true;
+  if (pointInRect(seg.x2, seg.y2, rect)) return true;
+  const x1 = rect.x;
+  const y1 = rect.y;
+  const x2 = rect.x + rect.w;
+  const y2 = rect.y + rect.h;
+  return (
+    segmentsIntersect(seg.x1, seg.y1, seg.x2, seg.y2, x1, y1, x2, y1) ||
+    segmentsIntersect(seg.x1, seg.y1, seg.x2, seg.y2, x2, y1, x2, y2) ||
+    segmentsIntersect(seg.x1, seg.y1, seg.x2, seg.y2, x2, y2, x1, y2) ||
+    segmentsIntersect(seg.x1, seg.y1, seg.x2, seg.y2, x1, y2, x1, y1)
+  );
+}
+
+function pointInRect(x: number, y: number, rect: { x: number; y: number; w: number; h: number }): boolean {
+  return x >= rect.x && x <= rect.x + rect.w && y >= rect.y && y <= rect.y + rect.h;
+}
+
+function segmentsIntersect(
+  x1: number, y1: number, x2: number, y2: number,
+  x3: number, y3: number, x4: number, y4: number,
+): boolean {
+  const denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+  if (denom === 0) return false;
+  const t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / denom;
+  const u = -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / denom;
+  return t >= 0 && t <= 1 && u >= 0 && u <= 1;
+}
+
+function isLegitContact(a: BBox, b: BBox, edgeMap: Map<string, LaidEdge>): boolean {
+  const pathSide = a.kind === "edge-path" ? a : b.kind === "edge-path" ? b : null;
+  const nodeSide = a.kind === "node" ? a : b.kind === "node" ? b : null;
+  if (pathSide && nodeSide) {
+    const edge = edgeMap.get(pathSide.id);
+    if (edge && (edge.from === nodeSide.id || edge.to === nodeSide.id)) {
+      return true;
+    }
+    // dotted-flow は経由 node 貫通 semantic なので path が中間 node と接触するのは legit。
+    if (edge && edge.style === "dotted-flow") {
+      return true;
+    }
+  }
+  return false;
+}
+
+type Seg = { x1: number; y1: number; x2: number; y2: number };
+
+/**
+ * 同一直線とみなす垂直距離の誤差 (world unit)。
+ *
+ * 兄弟 edge が共有する segment は `routePath` が同じ式で計算するため座標が完全に一致する。
+ * よって許容するのは浮動小数の端数だけでよい。 これを視覚的に無視できる距離 (1 world 等) まで
+ * 緩めると、 長い segment が終端で 1 world ずれているだけで「同一直線」 と誤判定し、
+ * 別の path が判定から丸ごと消える。
+ */
+const COINCIDENT_SEGMENT_EPSILON = 1e-6;
+
+/** 点に潰れた segment とみなす長さ (world unit)。 浮動小数の端数だけを落とす。 */
+const DEGENERATE_SEGMENT_EPSILON = 1e-9;
+
+/**
+ * `base` 上で `other` と同一直線上に重なる区間を、 `base` の媒介変数 [0, 1] で返す。
+ * 同一直線でない場合と、 重なりが 1 点 (端点接触) しかない場合は null。
+ */
+function coincidentInterval(
+  base: Seg,
+  other: Seg,
+  eps = COINCIDENT_SEGMENT_EPSILON,
+): [number, number] | null {
+  const adx = base.x2 - base.x1;
+  const ady = base.y2 - base.y1;
+  const bdx = other.x2 - other.x1;
+  const bdy = other.y2 - other.y1;
+  const aLen = Math.hypot(adx, ady);
+  const bLen = Math.hypot(bdx, bdy);
+  if (aLen < eps || bLen < eps) return null;
+  const cross = (ux: number, uy: number, vx: number, vy: number): number => ux * vy - uy * vx;
+  // 平行か
+  if (Math.abs(cross(adx, ady, bdx, bdy)) > eps * Math.max(aLen, bLen)) return null;
+  // other の両端点が base の直線上に載るか
+  if (Math.abs(cross(adx, ady, other.x1 - base.x1, other.y1 - base.y1)) > eps * aLen) return null;
+  if (Math.abs(cross(adx, ady, other.x2 - base.x1, other.y2 - base.y1)) > eps * aLen) return null;
+  const lenSq = aLen * aLen;
+  const t1 = ((other.x1 - base.x1) * adx + (other.y1 - base.y1) * ady) / lenSq;
+  const t2 = ((other.x2 - base.x1) * adx + (other.y2 - base.y1) * ady) / lenSq;
+  const lo = Math.max(0, Math.min(t1, t2));
+  const hi = Math.min(1, Math.max(t1, t2));
+  if (hi - lo <= eps / aLen) return null;
+  return [lo, hi];
+}
+
+/** `base` の媒介変数区間 [t0, t1] を切り出した部分 segment。 */
+function subSegment(base: Seg, t0: number, t1: number): Seg {
+  const adx = base.x2 - base.x1;
+  const ady = base.y2 - base.y1;
+  return {
+    x1: base.x1 + adx * t0,
+    y1: base.y1 + ady * t0,
+    x2: base.x1 + adx * t1,
+    y2: base.y1 + ady * t1,
+  };
+}
+
+/**
+ * Issue #211 SSOT ... 別 edge の segments から「自 path と重なっている区間」 を切り落として返す。
+ *
+ * L 字経路の label pill は `routePath` の設計で自分の縦走に跨って置かれる (`labelX = midX`)。
+ * fan-out / fan-in の兄弟 edge は同じ node から出る (入る) ため、 corner までの水平部と
+ * 縦走の共通部分が座標レベルで一致する。 pill が自 path に跨れば必然的に兄弟の path にも跨るが、
+ * 描画上は 1 本の線に pill が載っているだけで視覚欠陥ではない。
+ *
+ * よって「自 path と同一直線上で重なる区間」 は自 path の一部として扱い、 label ↔ path の
+ * 衝突判定と押し出しの対象から外す。
+ *
+ * 差し引くのは **共有区間だけ** で、 その先へ伸びた非共有区間は残す。 兄弟の縦走が自分より先まで
+ * 伸びていて、 その延長部分が pill を貫くなら、 1 本の線に pill が載っているのではなく別の線が
+ * pill を横切っている状態であり、 視覚欠陥として検出しなければならない。
+ */
+export function segmentsExcludingOwnPath(otherSegs: Seg[], ownSegs: Seg[]): Seg[] {
+  if (ownSegs.length === 0) return otherSegs;
+  const out: Seg[] = [];
+  for (const s of otherSegs) {
+    const covered: Array<[number, number]> = [];
+    for (const own of ownSegs) {
+      const iv = coincidentInterval(s, own);
+      if (iv) covered.push(iv);
+    }
+    if (covered.length === 0) {
+      out.push(s);
+      continue;
+    }
+    covered.sort((a, b) => a[0] - b[0]);
+    let cursor = 0;
+    for (const [lo, hi] of covered) {
+      if (lo > cursor) out.push(subSegment(s, cursor, lo));
+      cursor = Math.max(cursor, hi);
+      if (cursor >= 1) break;
+    }
+    if (cursor < 1) out.push(subSegment(s, cursor, 1));
+  }
+  // 切り落とした残りが点に潰れたものだけを捨てる。 長さを持つ残差は、 たとえ 1 world 未満でも
+  // 「兄弟が自 path より先へ伸びた区間」 なので判定対象に残す (COINCIDENT_SEGMENT_EPSILON は
+  // 同一直線の判定誤差であって、 残差の採否の閾値ではない)。
+  return out.filter((s) => Math.hypot(s.x2 - s.x1, s.y2 - s.y1) > DEGENERATE_SEGMENT_EPSILON);
+}
+
+function isSameEdgePathLabelPair(a: BBox, b: BBox): boolean {
+  return (
+    ((a.kind === "edge-path" && b.kind === "edge-label") ||
+      (a.kind === "edge-label" && b.kind === "edge-path")) &&
+    a.id === b.id
+  );
+}
+
+function computeOverlapArea(a: BBox, b: BBox): number {
+  const xOverlap = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x));
+  const yOverlap = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+  return xOverlap * yOverlap;
+}
+
+/**
+ * near-collision 用 clearance を返す。 SSOT は `spec.ts` `NEAR_COLLISION_POLICY`。
+ *
+ * CAR-424 で local `CLEARANCE_POLICY` を `spec.ts` に集約、 本関数は BBox pair を
+ * kind 文字列に変換して spec 側 `requiredNearClearance()` に委譲する薄い adapter。
+ */
+function requiredClearance(a: BBox, b: BBox): number {
+  return requiredNearClearance(a.kind, b.kind);
+}
+
+function computeGap(a: BBox, b: BBox): number {
+  const dx = Math.max(0, Math.max(a.x - (b.x + b.w), b.x - (a.x + a.w)));
+  const dy = Math.max(0, Math.max(a.y - (b.y + b.h), b.y - (a.y + a.h)));
+  return Math.hypot(dx, dy);
+}
+
+/** edge-path × edge-label pair 用の実 segment 距離 (AABB gap は detour path で false negative) */
+function computePathLabelGap(pathBox: BBox, labelBox: BBox, edgeMap: Map<string, LaidEdge>): number {
+  const edge = edgeMap.get(pathBox.id);
+  if (!edge) return computeGap(pathBox, labelBox);
+  const segs = extractPathSegments(edge.d);
+  if (segs.length === 0) return computeGap(pathBox, labelBox);
+  return measurePathLabelGapSegs(segs, labelBox);
+}
+
+/**
+ * label の矩形から path segment 列までの最短距離を返す (CAR-485 export)。
+ *
+ * private `computePathLabelGap` の実 gap 計算部を独立化。 chain 伝搬 shift (CAR-485)
+ * で label ↔ edge-path (別 edge) near-collision 判定を BBox AABB ではなく segment 実距離で
+ * 実施するために本 helper を使う (detour path で AABB は false negative を出しやすい)。
+ *
+ * segment が pill を貫いている場合は 0 を返す (Issue #216)。 判定側 (`segmentsCrossRect`) は
+ * 貫通を衝突と見なすので、 押し出し側も同じ基準に揃える。
+ *
+ * **矩形を面として扱う** (#370)。 元は矩形の 4 隅 + 4 辺中央の 8 点だけを probe にしていたが、
+ * 8 点は矩形の代表点でしかなく、 線が probe と probe の間に寄ると実際より遠い値を返す。 幅 438
+ * の pill の上辺中央から 144 ずれた位置に線の端点があると、 真の距離 79 に対して 109 を返した。
+ * 誤差は矩形が大きいほど開くため、 「長い label ほど遠く出る」 という本来消したい歪みが残る。
+ *
+ * 線分と凸多角形の最短距離は「線分の端点 → 多角形」 と「多角形の頂点 → 線分」 のどちらかで
+ * 達する。 矩形は凸なので、 この 2 通りを取れば厳密値になる。
+ *
+ * @param segs `extractPathSegments()` で分解した line segment 列
+ * @param labelBox { x, y, w, h } 形式の label 矩形 (BBox でも同 shape の object でも可)
+ * @returns 貫通していれば 0、 それ以外は矩形と segment 列の厳密な最短ユークリッド距離
+ */
+export function measurePathLabelGapSegs(
+  segs: Array<{ x1: number; y1: number; x2: number; y2: number }>,
+  labelBox: { x: number; y: number; w: number; h: number },
+): number {
+  if (segs.length === 0) return Infinity;
+  if (segmentsCrossRect(segs, labelBox)) return 0;
+  const x2 = labelBox.x + labelBox.w;
+  const y2 = labelBox.y + labelBox.h;
+  const corners = [
+    { x: labelBox.x, y: labelBox.y },
+    { x: x2, y: labelBox.y },
+    { x: labelBox.x, y: y2 },
+    { x: x2, y: y2 },
+  ];
+  /** 点から矩形 (面) までの距離。 内側なら 0。 */
+  const pointToRect = (px: number, py: number): number =>
+    Math.hypot(Math.max(labelBox.x - px, 0, px - x2), Math.max(labelBox.y - py, 0, py - y2));
+  let minDist = Infinity;
+  for (const s of segs) {
+    const dx = s.x2 - s.x1;
+    const dy = s.y2 - s.y1;
+    const lenSq = dx * dx + dy * dy;
+    for (const p of corners) {
+      let t = lenSq === 0 ? 0 : ((p.x - s.x1) * dx + (p.y - s.y1) * dy) / lenSq;
+      t = Math.max(0, Math.min(1, t));
+      const d = Math.hypot(p.x - (s.x1 + t * dx), p.y - (s.y1 + t * dy));
+      if (d < minDist) minDist = d;
+    }
+    const dEnd = Math.min(pointToRect(s.x1, s.y1), pointToRect(s.x2, s.y2));
+    if (dEnd < minDist) minDist = dEnd;
+  }
+  return minDist;
+}
+
+export function detectNearCollisions(
+  bboxes: BBox[],
+  edges: LaidEdge[],
+): Array<{ a: BBox; b: BBox; gap: number; required: number }> {
+  const edgeMap = new Map(edges.map((e) => [e.id, e]));
+  const out: Array<{ a: BBox; b: BBox; gap: number; required: number }> = [];
+  // max clearance 70px (node|node) を超える距離の pair は near 判定不要、
+  // bbox を 70px margin 膨張させて spatial hash に積めば隣接 cell のみで網羅できる。
+  const NEAR_MARGIN = MAX_CLEARANCE;
+  const visit = (a: BBox, b: BBox): void => {
+    if (a.id === b.id) return;
+    if (isLegitContact(a, b, edgeMap)) return;
+    if (isSameEdgePathLabelPair(a, b)) return;
+    if (computeOverlapArea(a, b) > 0) return;
+    // edge-path × edge-label pair は segment 距離で判定 (AABB gap は detour path で false negative)
+    const isPathLabelPair =
+      (a.kind === "edge-path" && b.kind === "edge-label") ||
+      (a.kind === "edge-label" && b.kind === "edge-path");
+    let gap: number;
+    if (isPathLabelPair) {
+      const path = a.kind === "edge-path" ? a : b;
+      const label = a.kind === "edge-label" ? a : b;
+      gap = computePathLabelGap(path, label, edgeMap);
+    } else {
+      gap = computeGap(a, b);
+    }
+    const required = requiredClearance(a, b);
+    if (required > 0 && gap < required) {
+      out.push({ a, b, gap, required });
+    }
+  };
+  forEachCandidatePair(bboxes, NEAR_MARGIN, visit);
+  return out;
+}
+
+/**
+ * spatial hash で「同 cell or 隣接 cell に居る pair」 のみ visit に流す helper。
+ * - cell size は CELL_SIZE (200px)、 box が複数 cell に跨る場合は全 cell に挿入。
+ * - margin > 0 では box を margin 分膨張させて挿入 (near 検出で gap < margin の pair を網羅)。
+ * - 大きい box (lane-label / edge-path) は cell 数が多くなるので、 一定 cell 数を超える box は
+ *   全件 fallback ループに回す (huge case で edge-path が長 1000px+ になっても安全)。
+ *
+ * 重複 visit 防止 ... 同 pair が複数 cell で出会うことがあるので、 (i, j) の dedupe set を使う。
+ */
+const CELL_SIZE = 200;
+const MAX_CLEARANCE = 70;
+const CELL_FALLBACK_THRESHOLD = 64;
+
+function forEachCandidatePair(
+  bboxes: BBox[],
+  margin: number,
+  visit: (a: BBox, b: BBox) => void,
+): void {
+  const n = bboxes.length;
+  if (n < 2) return;
+  // 小サイズは spatial hash overhead が逆効果、 直接全比較。
+  if (n < 64) {
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        visit(bboxes[i]!, bboxes[j]!);
+      }
+    }
+    return;
+  }
+
+  const grid = new Map<number, number[]>();
+  const oversized: number[] = [];
+
+  const cellKey = (cx: number, cy: number): number => cx * 1_000_003 + cy;
+
+  for (let i = 0; i < n; i++) {
+    const b = bboxes[i]!;
+    const minCx = Math.floor((b.x - margin) / CELL_SIZE);
+    const maxCx = Math.floor((b.x + b.w + margin) / CELL_SIZE);
+    const minCy = Math.floor((b.y - margin) / CELL_SIZE);
+    const maxCy = Math.floor((b.y + b.h + margin) / CELL_SIZE);
+    const cellCount = (maxCx - minCx + 1) * (maxCy - minCy + 1);
+    if (cellCount > CELL_FALLBACK_THRESHOLD) {
+      oversized.push(i);
+      continue;
+    }
+    for (let cx = minCx; cx <= maxCx; cx++) {
+      for (let cy = minCy; cy <= maxCy; cy++) {
+        const key = cellKey(cx, cy);
+        let bucket = grid.get(key);
+        if (!bucket) {
+          bucket = [];
+          grid.set(key, bucket);
+        }
+        bucket.push(i);
+      }
+    }
+  }
+
+  // 同 cell 内 pair (重複 cell に同 pair が乗るので Set で dedupe)。
+  const seen = new Set<number>();
+  for (const bucket of grid.values()) {
+    if (bucket.length < 2) continue;
+    for (let i = 0; i < bucket.length; i++) {
+      for (let j = i + 1; j < bucket.length; j++) {
+        const ia = bucket[i]!;
+        const ib = bucket[j]!;
+        const lo = ia < ib ? ia : ib;
+        const hi = ia < ib ? ib : ia;
+        const pairKey = lo * 1_000_003 + hi;
+        if (seen.has(pairKey)) continue;
+        seen.add(pairKey);
+        visit(bboxes[lo]!, bboxes[hi]!);
+      }
+    }
+  }
+
+  // 巨大 bbox は全件と pair を作る (cell 数膨張回避)。
+  if (oversized.length > 0) {
+    for (const oi of oversized) {
+      for (let j = 0; j < n; j++) {
+        if (oi === j) continue;
+        const lo = oi < j ? oi : j;
+        const hi = oi < j ? j : oi;
+        const pairKey = lo * 1_000_003 + hi;
+        if (seen.has(pairKey)) continue;
+        seen.add(pairKey);
+        visit(bboxes[lo]!, bboxes[hi]!);
+      }
+    }
+  }
+}
+
+/**
+ * chain 伝搬 shift で edge-label overlap を解消する (CAR-426 導入、 CAR-482 で node / lane-label
+ * 伝搬拡張)。
+ *
+ * `resolveOverlapsWithChain` の edge-label 拡張版。 node-node overlap は
+ * `resolveOverlapsWithChain` が担当、 本 function は edge-label ↔ edge-label /
+ * edge-label ↔ node / edge-label ↔ lane-label の overlap を chain 伝搬解消する。
+ *
+ * 設計指針。
+ *   1. edge-label が obstacles (node / lane-label) と overlap する場合、
+ *      label を path 側 normal 方向に押し出す (path から遠ざける方向)。
+ *   2. edge-label 同士が overlap する場合、 後 declare の label を normal 方向 shift。
+ *   3. shift 後に新規 overlap が生じた場合、 同方向で連鎖 shift (chain propagation)。
+ *   4. CAR-482 拡張 ... label が shift 方向に node / lane-label と衝突する場合、 その node /
+ *      lane-label も同方向同量 shift 連鎖 (旧 fixedObstacles → 可変 obstacles)。
+ *   5. 収束条件 = 1 iter で shift が 1 件も発生しない、 or MAX_ITER 到達。
+ *
+ * label 位置権限フロー (CAR-430 SSOT)。
+ *   1. `edges.ts routePath()` = 初期 label 位置を SSOT で決定
+ *   2. 本 function = overlap 検出時のみ chain 伝搬 shift で連鎖解消
+ *
+ * pipeline 配線 (`layout.ts` post-pass、 escape hatch = env `CDL_DISABLE_CHAIN_EDGE_LABEL=1`
+ * で OFF にすると edges.ts init 位置がそのまま最終 label 位置)。 CAR-429 で edges.ts の
+ * fan-in / fan-out offset 分散削除、 CAR-430 で label-shift.ts の shift 探索削除に伴い、
+ * label overlap 解消の単一 SSOT になった。
+ *
+ * @param edges 元 LaidEdge 列 (順序保存で返す)
+ * @param fixedObstacles 障害物 (node / lane-label の BBox 列)。 CAR-482 以前は不動、
+ *   現在は shift 対象 (CAR-482 chain 伝搬拡張)。 後方互換のため名前は fixedObstacles のまま。
+ * @param minClearance shift 後の最小 gap (world unit、 default 16)
+ * @param maxIter 収束上限 iter 数 (default 20、 spec.CHAIN_SHIFT_MAX_ITER と同値)
+ * @returns shift 済 LaidEdge 列 (input 順序を保持、 label 位置のみ変更、 path d は不変)
+ */
+export function resolveEdgeLabelOverlapsWithChain(
+  edges: LaidEdge[],
+  fixedObstacles: BBox[],
+  minClearance = 16,
+  maxIter = 20,
+): LaidEdge[] {
+  if (edges.length === 0) return edges;
+
+  // label bbox 生成は SSOT = spec.ts の computeLabelBBoxWorld に集約 (CAR-431 で collectBBoxes /
+  // 本 function / render/edges.tsx / predict-bbox.ts 4 箇所の drift を解消)。 shift 探索中の
+  // offsetX / offsetY 追加は label 位置探索の temporal offset なので helper 呼出後に加算する。
+  const labelBBox = (e: LaidEdge, offsetX: number, offsetY: number): BBox => {
+    const base = computeLabelBBoxWorld(e);
+    return {
+      kind: "edge-label",
+      id: e.id,
+      x: base.x + offsetX,
+      y: base.y + offsetY,
+      w: base.w,
+      h: base.h,
+    };
+  };
+
+  const edgeOrder = new Map<string, number>();
+  edges.forEach((e, idx) => edgeOrder.set(e.id, idx));
+
+  // label 空 (視覚上何も描画されない) edge は shift 対象外 = original 位置固定。
+  const labeledIds = new Set(
+    edges.filter((e) => e.label?.trim() || e.sub?.trim()).map((e) => e.id),
+  );
+
+  // 累積 shift Map (label 位置のみ、 path d は不変)。
+  const shiftMap = new Map<string, { dx: number; dy: number }>();
+  const getShift = (id: string): { dx: number; dy: number } =>
+    shiftMap.get(id) ?? { dx: 0, dy: 0 };
+
+  // 各 iter で edge-label bbox を再構築 (累積 shift を反映)。
+  const buildLabelBBoxes = (): BBox[] => {
+    const out: BBox[] = [];
+    for (const e of edges) {
+      if (!labeledIds.has(e.id)) continue;
+      const s = getShift(e.id);
+      out.push(labelBBox(e, s.dx, s.dy));
+    }
+    return out;
+  };
+
+  // detect: label ↔ fixed obstacle と label ↔ label の overlap を列挙。
+  // return: shift 命令 (moveId + axis + sign + amount)。
+  type ShiftInstr = { moveId: string; axis: "x" | "y"; sign: 1 | -1; amount: number };
+
+  const detectShifts = (): ShiftInstr[] => {
+    const out: ShiftInstr[] = [];
+    const labels = buildLabelBBoxes();
+
+    // label ↔ fixed obstacle (node / lane-label)。 label を fixed 逆方向に押し出す。
+    for (const label of labels) {
+      for (const obs of fixedObstacles) {
+        if (obs.kind !== "node" && obs.kind !== "lane-label") continue;
+        const dxOverlap = Math.min(label.x + label.w, obs.x + obs.w) - Math.max(label.x, obs.x);
+        const dyOverlap = Math.min(label.y + label.h, obs.y + obs.h) - Math.max(label.y, obs.y);
+        if (dxOverlap <= 0 || dyOverlap <= 0) continue;
+        const axis: "x" | "y" = dxOverlap < dyOverlap ? "x" : "y";
+        const labelCenter = axis === "x" ? label.x + label.w / 2 : label.y + label.h / 2;
+        const obsCenter = axis === "x" ? obs.x + obs.w / 2 : obs.y + obs.h / 2;
+        const sign: 1 | -1 = labelCenter >= obsCenter ? 1 : -1;
+        const amount = (axis === "x" ? dxOverlap : dyOverlap) + minClearance;
+        out.push({ moveId: label.id, axis, sign, amount });
+      }
+    }
+
+    // label ↔ label。 後 declare の label を先 declare から離れる方向に shift。
+    for (let i = 0; i < labels.length; i++) {
+      for (let j = i + 1; j < labels.length; j++) {
+        const a = labels[i]!;
+        const b = labels[j]!;
+        const dxOverlap = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x);
+        const dyOverlap = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y);
+        if (dxOverlap <= 0 || dyOverlap <= 0) continue;
+        const orderA = edgeOrder.get(a.id)!;
+        const orderB = edgeOrder.get(b.id)!;
+        const moveIsA = orderA > orderB;
+        const moveBox = moveIsA ? a : b;
+        const staticBox = moveIsA ? b : a;
+        const axis: "x" | "y" = dxOverlap < dyOverlap ? "x" : "y";
+        const moveCenter = axis === "x" ? moveBox.x + moveBox.w / 2 : moveBox.y + moveBox.h / 2;
+        const staticCenter = axis === "x" ? staticBox.x + staticBox.w / 2 : staticBox.y + staticBox.h / 2;
+        const sign: 1 | -1 = moveCenter >= staticCenter ? 1 : -1;
+        const amount = (axis === "x" ? dxOverlap : dyOverlap) + minClearance;
+        out.push({ moveId: moveBox.id, axis, sign, amount });
+      }
+    }
+
+    return out;
+  };
+
+  // chain 伝搬 loop = shift → 再検出 → 再 shift の iterative、 MAX_ITER で強制収束。
+  for (let iter = 0; iter < maxIter; iter++) {
+    const instrs = detectShifts();
+    if (instrs.length === 0) return applyEdgeLabelShifts(edges, shiftMap);
+
+    // 同 label に複数命令が来る場合、 各軸 max (符号別) を採用。
+    const iterShift = new Map<string, { dx: number; dy: number }>();
+    for (const p of instrs) {
+      const prev = iterShift.get(p.moveId) ?? { dx: 0, dy: 0 };
+      if (p.axis === "x") {
+        prev.dx = p.sign > 0 ? Math.max(prev.dx, p.amount) : Math.min(prev.dx, -p.amount);
+      } else {
+        prev.dy = p.sign > 0 ? Math.max(prev.dy, p.amount) : Math.min(prev.dy, -p.amount);
+      }
+      iterShift.set(p.moveId, prev);
+    }
+    // 累積 shift Map に足し込み。
+    for (const [id, s] of iterShift) {
+      const prev = getShift(id);
+      shiftMap.set(id, { dx: prev.dx + s.dx, dy: prev.dy + s.dy });
+    }
+  }
+
+  // MAX_ITER 到達 = 発散防止で現時点 shift を返す。
+  return applyEdgeLabelShifts(edges, shiftMap);
+}
+
+function applyEdgeLabelShifts(
+  edges: LaidEdge[],
+  shiftMap: Map<string, { dx: number; dy: number }>,
+): LaidEdge[] {
+  if (shiftMap.size === 0) return edges;
+  return edges.map((e) => {
+    const s = shiftMap.get(e.id);
+    if (!s || (s.dx === 0 && s.dy === 0)) return e;
+    // labelX / labelY は path 上 anchor 位置 (edges.ts SSOT)、 shift を加算しても
+    // path d は不変。 label pill の視覚位置のみが移動する。
+    return { ...e, labelX: e.labelX + s.dx, labelY: e.labelY + s.dy };
+  });
+}
+
+/**
+ * CAR-508 SSOT = 累積 shift を各軸方向 `maxMagnitude` 内に clamp する helper。
+ *
+ * chain 伝搬 loop で label / node / lane-label / edge-path の shift 累積が
+ * `maxMagnitude` を超えないよう、 軸別に絶対値を clip する。 |shift.dx| > maxMagnitude
+ * なら符号を保って maxMagnitude に丸め、 dy も同様。
+ *
+ * 発散防止の SSOT gate、 通常の chain 伝搬 shift (30-80 world 程度) には影響せず、
+ * Fan-out / Fan-in / Rollback pattern の暴走 shift (数百 world) を止める。
+ */
+function clampShiftMagnitude(
+  shift: { dx: number; dy: number },
+  maxMagnitude: number,
+): { dx: number; dy: number } {
+  const clampAxis = (v: number): number => {
+    if (v > maxMagnitude) return maxMagnitude;
+    if (v < -maxMagnitude) return -maxMagnitude;
+    return v;
+  };
+  return { dx: clampAxis(shift.dx), dy: clampAxis(shift.dy) };
+}
+
+/**
+ * chain 伝搬 shift の拡張版 (CAR-482 導入、 CAR-485 で edge-path 拡張)。 label だけでなく node /
+ * lane-label / edge-path (別 edge) も同方向同量 shift 連鎖。
+ *
+ * `resolveEdgeLabelOverlapsWithChain` は edge-label のみ shift、 obstacles (node / lane-label) は不動。
+ * 本 function は「label が shift 方向にある obstacle / edge-path に衝突するなら、 その要素も同方向同量 shift 連鎖」
+ * を実装、 「押した先にある要素も押し出す」 user 期待に応える。
+ *
+ * shift 対象。
+ *   1. edge-label ... `resolveEdgeLabelOverlapsWithChain` と同経路
+ *   2. node ... label shift 方向にある node は同方向同量 shift、 chain 伝搬で再検出 → 再 shift
+ *   3. lane-label ... 同上
+ *   4. edge-path (別 edge、 CAR-485) ... label 近接 (LABEL_TO_PATH_CLEARANCE 未達) or 直接 overlap で
+ *      label を path 逆方向に shift + shift 方向にある edge-path も同方向連鎖 shift (path.d 平行移動)
+ *
+ * 保守性 = 収束条件は maxIter で強制、 発散防止。 shift 累積は各要素ごと Map で管理。
+ * 既存 preset で label overlap 発生しないなら shift 0 で edges / nodes / laneLabels / edgePathShifts 素通し。
+ *
+ * 自 edge の label × path は legit として shift 対象外 (routePath init 位置 = LABEL_INIT_CLEARANCE 34 world (CAR-630 で 26 → 34 復帰)
+ * で自 path から離した設計、 自 pair の近接判定はここでは無視する)。
+ *
+ * @param edges 元 LaidEdge 列 (順序保存で返す)
+ * @param obstacles 障害物 (node / lane-label の BBox 列)。 shift 対象。
+ * @param minClearance shift 後の最小 gap (default 16)
+ * @param maxIter 収束上限 iter 数 (default 20)
+ * @returns { edges, nodeShifts, laneLabelShifts, edgePathShifts } shift 済 edges + kind 別 shift map。
+ *   edgePathShifts は edge id → (dx, dy) の shift 量。 caller は `translatePathD(edge.d, dx, dy)` で
+ *   path.d を平行移動する。
+ */
+export function resolveEdgeLabelOverlapsWithChainAndPropagate(
+  edges: LaidEdge[],
+  obstacles: BBox[],
+  minClearance = 16,
+  maxIter = 20,
+  /**
+   * CAR-485 = label × edge-path (別 edge) near-collision 判定に使う clearance (world unit)。
+   * `minClearance` は label × node / lane-label / label 用 (大きめ 32-36)、 本値は path 用
+   * (SSOT `LABEL_TO_PATH_CLEARANCE` = 16)、 pair 別 clearance を分離する事で fan-in / fan-out
+   * などで label が sibling path 近傍 (LABEL_INIT_CLEARANCE 26) にある正常状態を誤検知しない。
+   */
+  pathLabelClearance = LABEL_TO_PATH_CLEARANCE,
+): {
+  edges: LaidEdge[];
+  nodeShifts: Map<string, { dx: number; dy: number }>;
+  laneLabelShifts: Map<string, { dx: number; dy: number }>;
+  edgePathShifts: Map<string, { dx: number; dy: number }>;
+} {
+  if (edges.length === 0) {
+    return {
+      edges,
+      nodeShifts: new Map<string, { dx: number; dy: number }>(),
+      laneLabelShifts: new Map<string, { dx: number; dy: number }>(),
+      edgePathShifts: new Map<string, { dx: number; dy: number }>(),
+    };
+  }
+
+  // CAR-508 SSOT (spec.ts CHAIN_SHIFT_MAX_ACCUMULATED)。 累積 shift 上限 = 発散防止 guard。
+  const MAX_ACCUMULATED_SHIFT = CHAIN_SHIFT_MAX_ACCUMULATED;
+
+  // label bbox 生成 helper (spec.ts SSOT、 shift offset 込み)。
+  const labelBBox = (e: LaidEdge, offsetX: number, offsetY: number): BBox => {
+    const base = computeLabelBBoxWorld(e);
+    return {
+      kind: "edge-label",
+      id: e.id,
+      x: base.x + offsetX,
+      y: base.y + offsetY,
+      w: base.w,
+      h: base.h,
+    };
+  };
+
+  const edgeOrder = new Map<string, number>();
+  edges.forEach((e, idx) => edgeOrder.set(e.id, idx));
+
+  // label 空 (視覚上何も描画されない) edge は shift 対象外。
+  const labeledIds = new Set(
+    edges.filter((e) => e.label?.trim() || e.sub?.trim()).map((e) => e.id),
+  );
+
+  // 累積 shift Map (edge-label / node / lane-label / edge-path ごとに別 Map)。
+  const labelShiftMap = new Map<string, { dx: number; dy: number }>();
+  const nodeShiftMap = new Map<string, { dx: number; dy: number }>();
+  const laneLabelShiftMap = new Map<string, { dx: number; dy: number }>();
+  const edgePathShiftMap = new Map<string, { dx: number; dy: number }>();
+
+  /**
+   * chain 伝搬の起点として数える label shift だけを別に累積する (Issue #211)。
+   *
+   * label ↔ node の「近接」 解消 (rule 1c) は数 world の微調整で、 周囲の node や path を
+   * 巻き込む必要がない。 一方「重なり」 解消 (rule 1) は label の逃げ先に空間を作る必要が
+   * あるため node / path を同方向へ送る。
+   *
+   * 両者を 1 つの累積 map で扱うと近接の微調整まで chain 伝搬の起点になり、 node が連鎖して
+   * 動いて node 間 gap や lane pitch が崩れる (catalog 実測 = 1 → 11 件に悪化)。
+   */
+  const labelChainShiftMap = new Map<string, { dx: number; dy: number }>();
+
+  const getLabelShift = (id: string): { dx: number; dy: number } =>
+    labelShiftMap.get(id) ?? { dx: 0, dy: 0 };
+  const getLabelChainShift = (id: string): { dx: number; dy: number } =>
+    labelChainShiftMap.get(id) ?? { dx: 0, dy: 0 };
+  const getObstacleShift = (obs: BBox): { dx: number; dy: number } => {
+    if (obs.kind === "node") return nodeShiftMap.get(obs.id) ?? { dx: 0, dy: 0 };
+    if (obs.kind === "lane-label") return laneLabelShiftMap.get(obs.id) ?? { dx: 0, dy: 0 };
+    return { dx: 0, dy: 0 };
+  };
+  const getEdgePathShift = (id: string): { dx: number; dy: number } =>
+    edgePathShiftMap.get(id) ?? { dx: 0, dy: 0 };
+
+  // shift 済 bbox 位置を返す (元 bbox に累積 shift を反映)。
+  const shiftedObstacleBBox = (obs: BBox): BBox => {
+    const s = getObstacleShift(obs);
+    if (s.dx === 0 && s.dy === 0) return obs;
+    return { ...obs, x: obs.x + s.dx, y: obs.y + s.dy };
+  };
+
+  const edgeById = new Map<string, LaidEdge>();
+  for (const e of edges) edgeById.set(e.id, e);
+
+  /**
+   * 累積 edge-path shift を適用した後の segments (一様平行移動)。
+   *
+   * 適用側 (`applyEdgeLabelAndPathShifts`) は端点固定 (`translatePathDPreservingEndpoints`) を通すため、
+   * 端点と同じ座標を持つ点は動かない。 つまり本関数が返す geometry と描画される geometry は
+   * 形状によって乖離する。
+   *
+   * 判定側も端点固定を通して統一すると、 CAR-485 の押し出し量 (`(clearance - gap) + clearance`) が
+   * 「動かない点」 を基準に計算されるようになり、 累積上限まで押し続けて描画が悪化する
+   * (catalog 実測 = infra-demo の `edge-label ↔ edge-path` が再発)。
+   *
+   * 押し出しは一様平行移動を前提に設計されており (CAR-485)、 端点固定 (CAR-489) と本質的に
+   * 両立しない。 根本解決は端点固定を座標値ベースから index ベースに変えること (Issue #216)。
+   * それまでは判定を一様平行移動のままに保ち、 `pathShiftIsSafe` が「1 点も動かない向き」 と
+   * 「path を壊す向き」 を弾くことで実害を抑える。
+   */
+  const shiftedSegments = (edgeId: string, edgeD: string): Seg[] => {
+    const s = getEdgePathShift(edgeId);
+    if (s.dx === 0 && s.dy === 0) return extractPathSegments(edgeD);
+    return extractPathSegments(translatePathDPreservingEndpoints(edgeD, s.dx, s.dy));
+  };
+
+  // shift 命令 = 対象要素 (label / node / lane-label / edge-path) + 軸 + 符号 + 量。
+  type ShiftInstr = {
+    target: { kind: "label" | "node" | "lane-label" | "edge-path"; id: string };
+    axis: "x" | "y";
+    sign: 1 | -1;
+    amount: number;
+    /** false なら chain 伝搬の起点に数えない (label だけを動かす、 Issue #211)。 default = true。 */
+    chain?: boolean;
+  };
+
+  // 各 iter で label bboxes を再構築 (累積 label shift を反映)。
+  const buildLabelBBoxes = (): BBox[] => {
+    const out: BBox[] = [];
+    for (const e of edges) {
+      if (!labeledIds.has(e.id)) continue;
+      const s = getLabelShift(e.id);
+      out.push(labelBBox(e, s.dx, s.dy));
+    }
+    return out;
+  };
+
+  // bbox overlap 検出 + shift 方向計算の共通 helper。 move box を static box から遠ざける方向に押し出す。
+  // axis 選択 = overlap 面積が小さい方 (= 押し出しが少ない = 影響最小)。
+  const computeOverlapShift = (
+    moveBox: BBox,
+    staticBox: BBox,
+  ): { axis: "x" | "y"; sign: 1 | -1; amount: number } | null => {
+    const dxOverlap = Math.min(moveBox.x + moveBox.w, staticBox.x + staticBox.w) - Math.max(moveBox.x, staticBox.x);
+    const dyOverlap = Math.min(moveBox.y + moveBox.h, staticBox.y + staticBox.h) - Math.max(moveBox.y, staticBox.y);
+    if (dxOverlap <= 0 || dyOverlap <= 0) return null;
+    const axis: "x" | "y" = dxOverlap < dyOverlap ? "x" : "y";
+    const moveCenter = axis === "x" ? moveBox.x + moveBox.w / 2 : moveBox.y + moveBox.h / 2;
+    const staticCenter = axis === "x" ? staticBox.x + staticBox.w / 2 : staticBox.y + staticBox.h / 2;
+    const sign: 1 | -1 = moveCenter >= staticCenter ? 1 : -1;
+    const amount = (axis === "x" ? dxOverlap : dyOverlap) + minClearance;
+    return { axis, sign, amount };
+  };
+
+  const detectShifts = (): ShiftInstr[] => {
+    const out: ShiftInstr[] = [];
+    const labels = buildLabelBBoxes();
+    const shiftedObstacles = obstacles.map(shiftedObstacleBBox);
+
+    // (1) label ↔ obstacle (node / lane-label) 直接 overlap。 label を obstacle 逆方向に shift。
+    const labelsWithOverlap = new Set<string>();
+    for (const label of labels) {
+      for (const obs of shiftedObstacles) {
+        if (obs.kind !== "node" && obs.kind !== "lane-label") continue;
+        const shift = computeOverlapShift(label, obs);
+        if (!shift) continue;
+        labelsWithOverlap.add(label.id);
+        out.push({ target: { kind: "label", id: label.id }, ...shift });
+      }
+    }
+
+    // (1c) label ↔ node の近接 (重なってはいないが requiredNearClearance 未満、 Issue #211)。
+    //
+    // visualValidate の clearance 軸は node ↔ edge-label に 32 world を要求するが、 engine は
+    // (1) の重なり解消しか持たず、 角に斜めから寄った pill (実測 gap 29.8) を残していた。
+    // 判定側と押し出し側で同じ policy 表 (requiredNearClearance) を引き、 閾値の drift を防ぐ。
+    //
+    // node を requiredNearClearance だけ四方に膨らませた矩形との重なり量を押し出し量とする。
+    // 膨張は矩形中心を変えないので押し出す向きは (1) と同じ。
+    //
+    // 重なりが残っている label は対象外。 重なりの押し出しと逆向きの近接調整が同 iter に並ぶと
+    // label が上下に振れて収束しない。 重なりを (1) と (3) で先に解消し、 残った近接を本 rule が拾う。
+    //
+    // chain: false = この微調整は node / path の連鎖を起こさない。 label だけが動く。
+    for (const label of labels) {
+      if (labelsWithOverlap.has(label.id)) continue;
+      for (const obs of shiftedObstacles) {
+        if (obs.kind !== "node") continue;
+        const required = requiredNearClearance(label.kind, obs.kind);
+        const inflated: BBox = {
+          ...obs,
+          x: obs.x - required,
+          y: obs.y - required,
+          w: obs.w + required * 2,
+          h: obs.h + required * 2,
+        };
+        const shift = computeOverlapShift(label, inflated);
+        if (!shift) continue;
+        // computeOverlapShift は minClearance を上乗せするが、 膨張分で確保済なので差し引く。
+        const amount = shift.amount - minClearance;
+        if (amount <= 0) continue;
+        out.push({
+          target: { kind: "label", id: label.id },
+          axis: shift.axis,
+          sign: shift.sign,
+          amount,
+          chain: false,
+        });
+      }
+    }
+
+    // (1b) label ↔ lane-label の横方向 near miss (重なってはいないが CLEARANCE_LANE_LABEL 未満)。
+    //
+    // 動機 = lane を横断する edge (例 loading → error で done を跨ぐ) の label は中間 lane の
+    // 上端 band に置かれることがあり、 その lane の title と横に並ぶ。 重なっていないので (1) は
+    // 発火せず、 しかし clearance 軸は lane-label ↔ edge-label の gap 不足を error 判定する。
+    //
+    // lane-label は lane 左上角に固定 anchor で横移動できない (動かすと lane 外にはみ出る)。
+    // 縦方向は (3) chain 伝搬が lane-label ごと下方へ送る経路を既に持つ。
+    // よって横方向の自由度は edge-label 側にしかない、 ここでは label を lane-label から離す。
+    //
+    // raw overlap 済 pair は (1) が処理するため除外、 既存 diagram の label 位置は変えない。
+    for (const label of labels) {
+      for (const obs of shiftedObstacles) {
+        if (obs.kind !== "lane-label") continue;
+        if (computeOverlapShift(label, obs)) continue;
+        const yOverlap = Math.min(label.y + label.h, obs.y + obs.h) - Math.max(label.y, obs.y);
+        if (yOverlap <= 0) continue;
+        const gapX =
+          label.x >= obs.x + obs.w
+            ? label.x - (obs.x + obs.w)
+            : obs.x >= label.x + label.w
+              ? obs.x - (label.x + label.w)
+              : 0;
+        // 要求値は clearance 定数を直接読まず、 near-collision 判定と同じ policy 表から引く。
+        // 判定側 (visualValidate) と押し出し側 (本 loop) の閾値が drift しないことを保証する。
+        const required = requiredNearClearance(label.kind, obs.kind);
+        if (gapX <= 0 || gapX >= required) continue;
+        const sign: 1 | -1 = label.x >= obs.x + obs.w ? 1 : -1;
+        out.push({
+          target: { kind: "label", id: label.id },
+          axis: "x",
+          sign,
+          amount: required - gapX + LANE_LABEL_CLEARANCE_MARGIN,
+        });
+      }
+    }
+
+    // (2) label ↔ label overlap。 後 declare の label を先 declare から離れる方向に shift。
+    for (let i = 0; i < labels.length; i++) {
+      for (let j = i + 1; j < labels.length; j++) {
+        const a = labels[i]!;
+        const b = labels[j]!;
+        const orderA = edgeOrder.get(a.id)!;
+        const orderB = edgeOrder.get(b.id)!;
+        const moveBox = orderA > orderB ? a : b;
+        const staticBox = orderA > orderB ? b : a;
+        const shift = computeOverlapShift(moveBox, staticBox);
+        if (!shift) continue;
+        out.push({ target: { kind: "label", id: moveBox.id }, ...shift });
+      }
+    }
+
+    // (3) CAR-482 chain 伝搬 = label が shift 方向にある obstacle と衝突するなら、
+    // obstacle も同方向同量 shift 連鎖。 label ↔ obstacle が既に (1) で処理されているため、
+    // ここでは「shift 済 label の shift 累積方向にある obstacle」 を検出、 obstacle 側 shift 発火。
+    //
+    // 判定 = label 累積 shift 量ベクトル方向にある obstacle (中心距離が近接、 直交軸で band 重なり)。
+    for (const label of labels) {
+      const currentShift = getLabelChainShift(label.id);
+      if (currentShift.dx === 0 && currentShift.dy === 0) continue;
+      for (const obs of shiftedObstacles) {
+        if (obs.kind !== "node" && obs.kind !== "lane-label") continue;
+        propagateAlongAxis(out, label, obs, currentShift, "y");
+        propagateAlongAxis(out, label, obs, currentShift, "x");
+      }
+    }
+
+    // (4) CAR-485 = label ↔ edge-path (別 edge) 近接検出 → 別 edge の path を label から遠ざける方向に shift。
+    //   基本方針 = label の位置は routePath init SSOT (LABEL_INIT_CLEARANCE 34 world、 CAR-630 で 26 → 34 復帰) で自 path と適切に離しているため、
+    //   別 edge の path 近接時は label を動かさず path 側を shift する経路を採用する (own-path invariant を守るため)。
+    //   判定 = segment 実距離ベース (AABB gap は detour path で false negative)。
+    //   自 edge (label と path が同 id) は routePath 設計 SSOT で init 位置に離しているため対象外。
+    //
+    //   除外 = 同 (from, to) parallel edge pair (CAR-429 SSOT で意図的に path 完全重畳)。
+    //   parallel edge の label 分散は label ↔ label overlap 経路 (step 2) で解消される。
+    //
+    //   shift 方向 = label bbox 4 辺のうち path segments まで最短距離の辺の外側方向。
+    //     top 辺が最短 ⇒ path は label 上方 ⇒ path shift 上方 (Y-)、 label 上方向に path を追いやる。
+    //     bottom 辺 ⇒ 下方 (Y+)、 left ⇒ 左方 (X-)、 right ⇒ 右方 (X+)。
+    //   shift 量 = 現 gap から pathLabelClearance まで押し + 余裕 (pathLabelClearance)。
+    //   軸選択 = 中心距離ではなく、 上記 4 辺 probe 最小距離辺の軸 (horizontal 長 path で center 距離 X 優位でも Y 方向 collision 検知可能)。
+    // label が跨っている自 path の segments (Issue #211)。 兄弟 edge と共有する segment の除外に使う。
+    const ownSegsOf = (labelId: string): Seg[] => {
+      const own = edgeById.get(labelId);
+      return own ? shiftedSegments(own.id, own.d) : [];
+    };
+    // Issue #211 SSOT ... path を node の中へ押し込む shift 命令を捨てる。
+    //
+    // 4 辺 probe が left / right で同距離になると、 押しても label から離れない向き (label を
+    // 横切る水平 segment を横へずらす等) が選ばれ、 累積上限 (100 world) まで path が引きずられる。
+    // 実測 = T06 microservice mesh で detour が x=440 から x=340 へ動き、 svc1 / svc2 を貫いた。
+    //
+    // 従来は chain 伝搬が node も動かし `layoutEdges` を再実行していたため、 押し込まれた path が
+    // 捨てられて症状が出なかった。 label shift を保持する設計では path 側で判断する必要がある。
+    const nodeObstacles = shiftedObstacles.filter((o) => o.kind === "node");
+
+    /** 端点領域の固定を含めて実際に適用される形で path を平行移動し、 segments を返す。 */
+    const simulateShiftedSegments = (e: LaidEdge, dx: number, dy: number): Seg[] =>
+      extractPathSegments(translatePathDPreservingEndpoints(e.d, dx, dy));
+
+    /** 2 つの segment 列が座標として異なるか (浮動小数の端数は無視)。 */
+    const segmentsDiffer = (a: Seg[], b: Seg[]): boolean => {
+      if (a.length !== b.length) return true;
+      for (let i = 0; i < a.length; i++) {
+        const p = a[i]!;
+        const q = b[i]!;
+        if (
+          Math.abs(p.x1 - q.x1) > DEGENERATE_SEGMENT_EPSILON ||
+          Math.abs(p.y1 - q.y1) > DEGENERATE_SEGMENT_EPSILON ||
+          Math.abs(p.x2 - q.x2) > DEGENERATE_SEGMENT_EPSILON ||
+          Math.abs(p.y2 - q.y2) > DEGENERATE_SEGMENT_EPSILON
+        ) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    /** 端点から出る最初 / 最後の直線 segment の長さ。 stub の長さに相当する。 */
+    const stubLengths = (segs: Seg[]): [number, number] => {
+      const len = (s: Seg): number => Math.hypot(s.x2 - s.x1, s.y2 - s.y1);
+      if (segs.length === 0) return [0, 0];
+      return [len(segs[0]!), len(segs[segs.length - 1]!)];
+    };
+
+    /**
+     * Issue #211 SSOT ... path を指定方向へ押しても壊れないか判定する。
+     *
+     * 3 条件を全て満たす向きだけを採用する。
+     *
+     * 1. **1 点も動かない向きは採らない**。 端点領域の固定 (Issue #216) により、 corner を持たない
+     *    直線 path は直交方向へ動かせない。 「壊れないから安全」 と判定して探索を止めると、
+     *    実際に動かせる別の軸を試さないまま近接が残る。
+     * 2. **起点 stub が `EDGE_STUB_OUT` を割らない**。 端点が固定されたまま path を押すと、 端点に
+     *    続く直線が長さを変える。 縮む向きに押し続けると stub が潰れる。
+     * 3. **無関係な node を新たに貫かない**。 label の近接より path の貫通の方が視覚的に重い。
+     *
+     * 押し出し量は累積するため、 累積後の総量で判定する。 実際の適用と同じ関数を通すので、
+     * 素の平行移動を模擬した場合に生じる端点まわりのずれがない。
+     *
+     * 端点が node の辺から外れないことは `translatePathDPreservingEndpoints` が構造的に保証する
+     * (両端の座標 pair は常に固定される)。 呼び元で `side` を見る必要はない。
+     */
+    const pathShiftIsSafe = (
+      edgeId: string,
+      axis: "x" | "y",
+      sign: 1 | -1,
+      amount: number,
+    ): boolean => {
+      const edge = edgeById.get(edgeId);
+      if (!edge) return false;
+      const acc = getEdgePathShift(edgeId);
+      const dx = acc.dx + (axis === "x" ? sign * amount : 0);
+      const dy = acc.dy + (axis === "y" ? sign * amount : 0);
+      const before = simulateShiftedSegments(edge, acc.dx, acc.dy);
+      const after = simulateShiftedSegments(edge, dx, dy);
+      if (after.length === 0) return false;
+
+      // path が 1 点も動かない向きは採らない。 corner を持たない直線 path は直交方向へ動かせず、
+      // これを「安全」 と判定して採用すると、 実際に動かせる別の軸を試さないまま止まる。
+      if (!segmentsDiffer(before, after)) return false;
+
+      const [beforeHead, beforeTail] = stubLengths(before);
+      const [afterHead, afterTail] = stubLengths(after);
+      if (afterHead < EDGE_STUB_OUT && afterHead < beforeHead) return false;
+      if (afterTail < EDGE_STUB_OUT && afterTail < beforeTail) return false;
+
+      for (const o of nodeObstacles) {
+        if (edge.from === o.id || edge.to === o.id) continue; // 端点 node への接触は legit
+        const rect = { x: o.x, y: o.y, w: o.w, h: o.h };
+        if (!segmentsCrossRect(before, rect) && segmentsCrossRect(after, rect)) return false;
+      }
+      return true;
+    };
+    for (const label of labels) {
+      const labelEdge = edgeById.get(label.id);
+      for (const e of edges) {
+        if (label.id === e.id) continue; // 自 edge の label × path は shift 対象外 (legit)
+        // parallel edge (同 from + 同 to) は path 完全重畳が CAR-429 SSOT、 shift 対象外。
+        if (labelEdge && labelEdge.from === e.from && labelEdge.to === e.to) continue;
+        // fan 兄弟と共有する segment は自 path 扱い (Issue #211)。 除外後に残る segment のみで測る。
+        const segs = segmentsExcludingOwnPath(shiftedSegments(e.id, e.d), ownSegsOf(label.id));
+        if (segs.length === 0) continue;
+        const gap = measurePathLabelGapSegs(segs, label);
+        // 直接 overlap or 近接 (pathLabelClearance 未達) の判定 = gap < pathLabelClearance
+        // 正常 fan-in / fan-out で label が sibling path 近傍 (LABEL_INIT_CLEARANCE 26) にある case は
+        // 誤検知しない (gap=16-34 → pathLabelClearance=16 なら pass、 minClearance=36 なら誤発火)。
+        if (gap >= pathLabelClearance) continue;
+        // 軸選択 = label bbox 4 辺 (top/bottom/left/right) の中央 probe から path segments までの最短距離を求め、
+        // 最小距離の辺を選ぶ (辺方向 = penetration 方向)。 例 = 上辺が最も近い ⇒ path は上方 ⇒ path shift 上方 (Y-)。
+        // 単純に中心距離の大小で軸選ぶと horizontal 長 path で X 軸が dominant になり Y 方向 collision を見逃す。
+        const labelCenterY = label.y + label.h / 2;
+        const labelCenterX = label.x + label.w / 2;
+        const edgeProbes = [
+          { side: "top", x: labelCenterX, y: label.y, axis: "y", sign: -1 as 1 | -1 },
+          { side: "bottom", x: labelCenterX, y: label.y + label.h, axis: "y", sign: 1 as 1 | -1 },
+          { side: "left", x: label.x, y: labelCenterY, axis: "x", sign: -1 as 1 | -1 },
+          { side: "right", x: label.x + label.w, y: labelCenterY, axis: "x", sign: 1 as 1 | -1 },
+        ] as const;
+        let bestSideIdx = -1;
+        let bestSideDist = Infinity;
+        const probeDist: number[] = [];
+        for (let idx = 0; idx < edgeProbes.length; idx++) {
+          const p = edgeProbes[idx]!;
+          let minD = Infinity;
+          for (const s of segs) {
+            const dx = s.x2 - s.x1;
+            const dy = s.y2 - s.y1;
+            const lenSq = dx * dx + dy * dy;
+            let t = lenSq === 0 ? 0 : ((p.x - s.x1) * dx + (p.y - s.y1) * dy) / lenSq;
+            t = Math.max(0, Math.min(1, t));
+            const cx = s.x1 + t * dx;
+            const cy = s.y1 + t * dy;
+            const d = Math.hypot(p.x - cx, p.y - cy);
+            if (d < minD) minD = d;
+          }
+          probeDist.push(minD);
+          if (minD < bestSideDist) {
+            bestSideDist = minD;
+            bestSideIdx = idx;
+          }
+        }
+        if (bestSideIdx < 0) continue;
+        const amount = (pathLabelClearance - gap) + pathLabelClearance;
+        // Issue #211 SSOT ... probe を近い順に見て、 path を壊さない最初の向きを採る。
+        // どの向きも安全でないなら path を動かさない (label の近接より path の破損の方が重い)。
+        const ordered = edgeProbes
+          .map((p, idx) => ({ p, idx }))
+          .sort((a, b) => probeDist[a.idx]! - probeDist[b.idx]!);
+        for (const { p } of ordered) {
+          const axis = p.axis as "x" | "y";
+          if (!pathShiftIsSafe(e.id, axis, p.sign, amount)) continue;
+          out.push({ target: { kind: "edge-path", id: e.id }, axis, sign: p.sign, amount });
+          break;
+        }
+      }
+    }
+
+    // (5) CAR-485 edge-path chain propagate = shift 済 label の shift 方向にある別 edge の path も
+    //     同方向連鎖 shift (CAR-482 semantic を edge-path 対象に拡張)。
+    //     判定 = label 累積 shift 方向にある path (segment 実距離ベースで近接) → path 側 shift 発火。
+    //     path shift amount = pathLabelClearance (label × path の clearance と対称)。
+    //     除外 = parallel edge (同 from + 同 to) は path 完全重畳が CAR-429 SSOT、 chain 対象外。
+    for (const label of labels) {
+      const currentShift = getLabelChainShift(label.id);
+      if (currentShift.dx === 0 && currentShift.dy === 0) continue;
+      const labelEdge = edgeById.get(label.id);
+      for (const e of edges) {
+        if (label.id === e.id) continue; // 自 edge は対象外
+        if (labelEdge && labelEdge.from === e.from && labelEdge.to === e.to) continue;
+        // fan 兄弟と共有する segment は自 path 扱い (Issue #211)。
+        const segs = segmentsExcludingOwnPath(shiftedSegments(e.id, e.d), ownSegsOf(label.id));
+        if (segs.length === 0) continue;
+        const before = out.length;
+        propagateEdgePathAlongAxis(out, label, e.id, segs, currentShift, "y", pathLabelClearance);
+        propagateEdgePathAlongAxis(out, label, e.id, segs, currentShift, "x", pathLabelClearance);
+        // path を壊す向きの命令は捨てる (Issue #211、 pathShiftIsSafe SSOT)。
+        for (let i = out.length - 1; i >= before; i--) {
+          const instr = out[i]!;
+          if (!pathShiftIsSafe(e.id, instr.axis, instr.sign, instr.amount)) out.splice(i, 1);
+        }
+      }
+    }
+
+    return out;
+  };
+
+  // chain 伝搬 helper。 label 累積 shift の指定軸 (x or y) 方向にある obstacle への propagate 命令発行。
+  //   - shift 累積 0 の軸なら no-op
+  //   - 直交軸で label bbox と obstacle bbox の band 重なりなし (すれ違い) なら no-op
+  //   - obstacle 中心が label 中心の shift 方向反対側 (逆方向) なら no-op
+  //   - 中心距離が半径合計 + margin (2 * minClearance) 超なら no-op (chain 伝搬圏外)
+  // 通過時に obstacle 側 shift 命令 (amount = minClearance) を out に push。
+  function propagateAlongAxis(
+    out: ShiftInstr[],
+    label: BBox,
+    obs: BBox,
+    currentShift: { dx: number; dy: number },
+    axis: "x" | "y",
+  ): void {
+    const shiftVal = axis === "y" ? currentShift.dy : currentShift.dx;
+    if (shiftVal === 0) return;
+    // 直交軸 band 重なり判定
+    const bandOverlap = axis === "y"
+      ? label.x < obs.x + obs.w && label.x + label.w > obs.x
+      : label.y < obs.y + obs.h && label.y + label.h > obs.y;
+    if (!bandOverlap) return;
+    const shiftSign: 1 | -1 = shiftVal > 0 ? 1 : -1;
+    // 中心座標 (指定軸)
+    const labelCenter = axis === "y" ? label.y + label.h / 2 : label.x + label.w / 2;
+    const obsCenter = axis === "y" ? obs.y + obs.h / 2 : obs.x + obs.w / 2;
+    // obstacle が shift 方向にあるか
+    const obsIsInShiftDirection =
+      (shiftSign === 1 && obsCenter > labelCenter) || (shiftSign === -1 && obsCenter < labelCenter);
+    if (!obsIsInShiftDirection) return;
+    // 近接判定
+    const centerDist = Math.abs(obsCenter - labelCenter);
+    const halfSum = axis === "y" ? label.h / 2 + obs.h / 2 : label.w / 2 + obs.w / 2;
+    if (centerDist >= halfSum + 2 * minClearance) return;
+    // shift 命令 = 同方向、 amount は minClearance
+    out.push({
+      target: { kind: obs.kind as "node" | "lane-label", id: obs.id },
+      axis,
+      sign: shiftSign,
+      amount: minClearance,
+    });
+  }
+
+  /**
+   * CAR-485 edge-path chain propagate 用 helper。 label 累積 shift の指定軸方向にある edge-path
+   * segment 集合が近接している場合、 その edge-path も同方向 shift 命令を発行する。
+   *
+   * 判定条件 (`propagateAlongAxis` の edge-path 版)。
+   *   - label 累積 shift の指定軸成分が 0 なら no-op
+   *   - segment 集合の bbox 中心が label 中心の shift 方向反対側 (逆方向) なら no-op
+   *   - label と path segments の距離 (segment 実距離ベース) が近接 (< 2 * minClearance) なら shift 発火
+   */
+  function propagateEdgePathAlongAxis(
+    out: ShiftInstr[],
+    label: BBox,
+    edgeId: string,
+    segs: Array<{ x1: number; y1: number; x2: number; y2: number }>,
+    currentShift: { dx: number; dy: number },
+    axis: "x" | "y",
+    pathClearance: number,
+  ): void {
+    const shiftVal = axis === "y" ? currentShift.dy : currentShift.dx;
+    if (shiftVal === 0) return;
+    const shiftSign: 1 | -1 = shiftVal > 0 ? 1 : -1;
+    // path segments の中心 (端点平均) を近似
+    let sumPx = 0;
+    let sumPy = 0;
+    let n = 0;
+    for (const s of segs) {
+      sumPx += s.x1 + s.x2;
+      sumPy += s.y1 + s.y2;
+      n += 2;
+    }
+    if (n === 0) return;
+    const pathCenter = axis === "y" ? sumPy / n : sumPx / n;
+    const labelCenter = axis === "y" ? label.y + label.h / 2 : label.x + label.w / 2;
+    // path が shift 方向にあるか (shift 方向 = label が動く方向、 その方向にある path も動かす)
+    const pathIsInShiftDirection =
+      (shiftSign === 1 && pathCenter > labelCenter) || (shiftSign === -1 && pathCenter < labelCenter);
+    if (!pathIsInShiftDirection) return;
+    // 近接判定 = segment 実距離が閾値内なら shift 対象。 閾値 = 2 * pathClearance で余裕。
+    const gap = measurePathLabelGapSegs(segs, label);
+    if (gap >= 2 * pathClearance) return;
+    // shift 命令 = 同方向、 amount は pathClearance
+    out.push({
+      target: { kind: "edge-path", id: edgeId },
+      axis,
+      sign: shiftSign,
+      amount: pathClearance,
+    });
+  }
+
+  // chain 伝搬 loop = shift → 再検出 → 再 shift の iterative、 MAX_ITER で強制収束。
+  for (let iter = 0; iter < maxIter; iter++) {
+    const instrs = detectShifts();
+    if (instrs.length === 0) {
+      return {
+        edges: applyEdgeLabelAndPathShifts(edges, labelShiftMap, edgePathShiftMap),
+        nodeShifts: nodeShiftMap,
+        laneLabelShifts: laneLabelShiftMap,
+        edgePathShifts: edgePathShiftMap,
+      };
+    }
+
+    // 同 target に複数命令が来る場合、 各軸 max (符号別) を採用。
+    const iterShift = new Map<string, { kind: "label" | "node" | "lane-label" | "edge-path"; dx: number; dy: number }>();
+    // chain 伝搬の起点として数える label shift だけを別集計する (Issue #211、 labelChainShiftMap SSOT)。
+    const iterChainLabelShift = new Map<string, { dx: number; dy: number }>();
+    const merge = (target: { dx: number; dy: number }, p: ShiftInstr): void => {
+      if (p.axis === "x") {
+        target.dx = p.sign > 0 ? Math.max(target.dx, p.amount) : Math.min(target.dx, -p.amount);
+      } else {
+        target.dy = p.sign > 0 ? Math.max(target.dy, p.amount) : Math.min(target.dy, -p.amount);
+      }
+    };
+    for (const p of instrs) {
+      const key = `${p.target.kind}::${p.target.id}`;
+      const entry = iterShift.get(key) ?? { kind: p.target.kind, dx: 0, dy: 0 };
+      merge(entry, p);
+      iterShift.set(key, entry);
+      if (p.target.kind === "label" && p.chain !== false) {
+        const chainEntry = iterChainLabelShift.get(p.target.id) ?? { dx: 0, dy: 0 };
+        merge(chainEntry, p);
+        iterChainLabelShift.set(p.target.id, chainEntry);
+      }
+    }
+    for (const [id, delta] of iterChainLabelShift) {
+      const prev = labelChainShiftMap.get(id) ?? { dx: 0, dy: 0 };
+      labelChainShiftMap.set(
+        id,
+        clampShiftMagnitude({ dx: prev.dx + delta.dx, dy: prev.dy + delta.dy }, MAX_ACCUMULATED_SHIFT),
+      );
+    }
+
+    // 累積 shift Map に足し込み (kind::id key から id 抽出、 kind 別 Map に加算)。
+    // CAR-508 = accumulate 後に |dx| / |dy| ≤ MAX_ACCUMULATED_SHIFT で clamp、 発散抑止。
+    // clamp で「shift 差分 = 0」 になると anyShift 更新せず、 loop 終了条件を満たす。
+    //
+    // kind 別に累積先 Map が異なるが、 accumulate + clamp + Map.set の共通処理を
+    // `accumulate` closure に集約、 4 kind 分岐は Map 選択と edge-path の label sync のみ。
+    // 戻り値 = 実際に累積が更新されたかどうか (clamp で no-op なら false)。
+    const accumulate = (
+      map: Map<string, { dx: number; dy: number }>,
+      id: string,
+      delta: { dx: number; dy: number },
+    ): { prev: { dx: number; dy: number }; next: { dx: number; dy: number }; changed: boolean } => {
+      const prev = map.get(id) ?? { dx: 0, dy: 0 };
+      const next = clampShiftMagnitude(
+        { dx: prev.dx + delta.dx, dy: prev.dy + delta.dy },
+        MAX_ACCUMULATED_SHIFT,
+      );
+      const changed = next.dx !== prev.dx || next.dy !== prev.dy;
+      if (changed) map.set(id, next);
+      return { prev, next, changed };
+    };
+    let anyShift = false;
+    for (const [key, s] of iterShift) {
+      if (s.dx === 0 && s.dy === 0) continue;
+      const [kind, id] = key.split("::") as [
+        "label" | "node" | "lane-label" | "edge-path",
+        string,
+      ];
+      if (kind === "label") {
+        if (accumulate(labelShiftMap, id, s).changed) anyShift = true;
+      } else if (kind === "node") {
+        // node / lane-label も同 clamp 適用。 chain 伝搬で node が発散的に shift されるのを防ぐ。
+        if (accumulate(nodeShiftMap, id, s).changed) anyShift = true;
+      } else if (kind === "lane-label") {
+        if (accumulate(laneLabelShiftMap, id, s).changed) anyShift = true;
+      } else if (kind === "edge-path") {
+        // CAR-508 review (MAJOR) = path shift 時は自 label の headroom で先に cap してから apply。
+        // 旧 = path を先に累積 → label へ同 delta apply、 label 側 clamp で吸収、 これでは path と
+        // label の相対距離が LABEL_INIT_CLEARANCE から逸脱 (CAR-485 same-delta invariant 違反)。
+        // 新 = 自 label の残 headroom で先に path delta を cap、 両者に同じ effective delta を apply。
+        if (labeledIds.has(id)) {
+          const labelPrev = labelShiftMap.get(id) ?? { dx: 0, dy: 0 };
+          const labelNext = clampShiftMagnitude(
+            { dx: labelPrev.dx + s.dx, dy: labelPrev.dy + s.dy },
+            MAX_ACCUMULATED_SHIFT,
+          );
+          const effectiveDelta = { dx: labelNext.dx - labelPrev.dx, dy: labelNext.dy - labelPrev.dy };
+          if (effectiveDelta.dx === 0 && effectiveDelta.dy === 0) continue;
+          const path = accumulate(edgePathShiftMap, id, effectiveDelta);
+          if (path.changed) {
+            anyShift = true;
+            accumulate(labelShiftMap, id, effectiveDelta);
+          }
+        } else {
+          const path = accumulate(edgePathShiftMap, id, s);
+          if (path.changed) anyShift = true;
+        }
+      }
+    }
+    if (!anyShift) break;
+  }
+
+  return {
+    edges: applyEdgeLabelAndPathShifts(edges, labelShiftMap, edgePathShiftMap),
+    nodeShifts: nodeShiftMap,
+    laneLabelShifts: laneLabelShiftMap,
+    edgePathShifts: edgePathShiftMap,
+  };
+}
+
+/**
+ * CAR-485 = label shift + edge-path shift を同時 apply する helper。
+ * label shift は labelX / labelY 加算、 edge-path shift は path.d の shift。
+ *
+ * edge path shift は端点領域保持型 `translatePathDPreservingEndpoints` を通す (Issue #216)。
+ * 両端の座標 pair は常に固定されるため、 起点 / 終点が node の辺から外れない。
+ *
+ * CAR-489 以前 (CAR-485) は `translatePathD` (全 point 平行移動) を採用していたため、
+ * horizontal detour path (retry 相当) で起点 / 終点が node bbox 外に飛ぶ regression があった。
+ */
+function applyEdgeLabelAndPathShifts(
+  edges: LaidEdge[],
+  labelShiftMap: Map<string, { dx: number; dy: number }>,
+  edgePathShiftMap: Map<string, { dx: number; dy: number }>,
+): LaidEdge[] {
+  if (labelShiftMap.size === 0 && edgePathShiftMap.size === 0) return edges;
+  return edges.map((e) => {
+    const ls = labelShiftMap.get(e.id);
+    const ps = edgePathShiftMap.get(e.id);
+    const hasLabelShift = ls && (ls.dx !== 0 || ls.dy !== 0);
+    const hasPathShift = ps && (ps.dx !== 0 || ps.dy !== 0);
+    if (!hasLabelShift && !hasPathShift) return e;
+    let next = e;
+    if (hasLabelShift) {
+      next = { ...next, labelX: next.labelX + ls!.dx, labelY: next.labelY + ls!.dy };
+    }
+    if (hasPathShift) {
+      next = { ...next, d: translatePathDPreservingEndpoints(next.d, ps!.dx, ps!.dy) };
+    }
+    return next;
+  });
+}
+