@qualisoft/ai-skills 1.0.0

package/skills/erd-visual/engine/router.mjs

@@ -0,0 +1,401 @@
+/* 직각 배선 라우터 — Hanan 격자 + 굴곡 페널티 A* + 혼잡도 + 채널 분산
+ *
+ * 혼잡도 인식이 핵심이다. 없으면 A* 가 모든 선을 같은 격자선에 몰아넣어
+ * 완전히 겹친다. 이미 지나간 선이 쓴 레인은 비싸지고, 뒤에 오는 선이
+ * 알아서 옆 레인으로 우회한다.
+ */
+
+/** 이진 힙 — 삽입 순서를 tiebreak 으로 써서 결과를 결정적으로 만든다 */
+class Heap {
+  constructor() { this.a = []; this.n = 0; }
+  push(f, v) {
+    this.a.push([f, this.n++, v]);
+    let i = this.a.length - 1;
+    while (i > 0) {
+      const p = (i - 1) >> 1;
+      if (this.a[p][0] < this.a[i][0] || (this.a[p][0] === this.a[i][0] && this.a[p][1] <= this.a[i][1])) break;
+      [this.a[p], this.a[i]] = [this.a[i], this.a[p]];
+      i = p;
+    }
+  }
+  pop() {
+    const top = this.a[0], last = this.a.pop();
+    if (this.a.length) {
+      this.a[0] = last;
+      let i = 0;
+      for (;;) {
+        const l = 2 * i + 1, r = l + 1;
+        let s = i;
+        if (l < this.a.length && (this.a[l][0] < this.a[s][0] ||
+            (this.a[l][0] === this.a[s][0] && this.a[l][1] < this.a[s][1]))) s = l;
+        if (r < this.a.length && (this.a[r][0] < this.a[s][0] ||
+            (this.a[r][0] === this.a[s][0] && this.a[r][1] < this.a[s][1]))) s = r;
+        if (s === i) break;
+        [this.a[s], this.a[i]] = [this.a[i], this.a[s]];
+        i = s;
+      }
+    }
+    return top;
+  }
+  get size() { return this.a.length; }
+}
+
+export function simplify(pts) {
+  const out = [pts[0]];
+  for (const p of pts.slice(1)) {
+    if (out.length >= 2) {
+      const a = out[out.length - 2], b = out[out.length - 1];
+      if ((a[0] === b[0] && b[0] === p[0]) || (a[1] === b[1] && b[1] === p[1])) {
+        out[out.length - 1] = p;
+        continue;
+      }
+    }
+    const last = out[out.length - 1];
+    if (p[0] !== last[0] || p[1] !== last[1]) out.push(p);
+  }
+  return out;
+}
+
+/** 채널 분산이 남긴 미세 꺾임(1~2px 계단)을 없앤다. 직각은 유지한다. */
+export function snap(pts, eps = 3.0) {
+  if (!pts || pts.length < 3) return pts;
+  const q = pts.map(p => [p[0], p[1]]);
+  for (let i = 0; i < q.length - 1; i++) {
+    const dx = Math.abs(q[i + 1][0] - q[i][0]);
+    const dy = Math.abs(q[i + 1][1] - q[i][1]);
+    if (dx > 0 && dx < eps && dy < 0.01) {
+      if (i + 1 < q.length - 1) q[i + 1][0] = q[i][0]; else q[i][0] = q[i + 1][0];
+    } else if (dy > 0 && dy < eps && dx < 0.01) {
+      if (i + 1 < q.length - 1) q[i + 1][1] = q[i][1]; else q[i][1] = q[i + 1][1];
+    }
+  }
+  return simplify(q.map(p => [p[0], p[1]]));
+}
+
+/** 경로가 사각형 내부를 지나는가. skip 은 출발/도착 인덱스 집합. */
+export function pierces(pts, rects, skip, inset = 1.5) {
+  for (let i = 0; i < pts.length - 1; i++) {
+    const [x1, y1] = pts[i], [x2, y2] = pts[i + 1];
+    const loX = Math.min(x1, x2), hiX = Math.max(x1, x2);
+    const loY = Math.min(y1, y2), hiY = Math.max(y1, y2);
+    for (let j = 0; j < rects.length; j++) {
+      if (skip && skip.has(j)) continue;
+      const r = rects[j];
+      if (hiX <= r.x + inset || loX >= r.x + r.w - inset) continue;
+      if (hiY <= r.y + inset || loY >= r.y + r.h - inset) continue;
+      return true;
+    }
+  }
+  return false;
+}
+
+/** 직각 꺾임을 둥글게 — SVG path d */
+export function rounded(pts, r = 9) {
+  if (!pts || pts.length < 2) return '';
+  const f = n => n.toFixed(1);
+  const d = ['M' + f(pts[0][0]) + ',' + f(pts[0][1])];
+  for (let i = 1; i < pts.length - 1; i++) {
+    const a = pts[i - 1], b = pts[i], c = pts[i + 1];
+    const v1 = [b[0] - a[0], b[1] - a[1]], v2 = [c[0] - b[0], c[1] - b[1]];
+    const l1 = Math.abs(v1[0]) + Math.abs(v1[1]);
+    const l2 = Math.abs(v2[0]) + Math.abs(v2[1]);
+    const rr = Math.min(r, l1 / 2, l2 / 2);
+    if (rr < 1) { d.push('L' + f(b[0]) + ',' + f(b[1])); continue; }
+    const u1 = [l1 ? v1[0] / l1 : 0, l1 ? v1[1] / l1 : 0];
+    const u2 = [l2 ? v2[0] / l2 : 0, l2 ? v2[1] / l2 : 0];
+    const p1 = [b[0] - u1[0] * rr, b[1] - u1[1] * rr];
+    const p2 = [b[0] + u2[0] * rr, b[1] + u2[1] * rr];
+    d.push('L' + f(p1[0]) + ',' + f(p1[1]));
+    d.push('Q' + f(b[0]) + ',' + f(b[1]) + ' ' + f(p2[0]) + ',' + f(p2[1]));
+  }
+  const e = pts[pts.length - 1];
+  d.push('L' + f(e[0]) + ',' + f(e[1]));
+  return d.join(' ');
+}
+
+export class Ortho {
+  constructor(rects, W, H, { margin = 16, clear = 9, bounds = null } = {}) {
+    this.R = rects.map(r => ({ x: r.x - clear, y: r.y - clear, w: r.w + 2 * clear, h: r.h + 2 * clear }));
+    this.W = W; this.H = H; this.margin = margin;
+    // 배선이 돌아다닐 수 있는 범위. 지정하지 않으면 캔버스 가장자리 8px 안쪽.
+    // 굵은 선(번들)은 가장자리에 붙으면 테두리에 잘려 깨져 보인다.
+    this.b = bounds || { x1: 8, y1: 8, x2: W - 8, y2: H - 8 };
+    // 열 단위 공간 색인 — 같은 x/w 를 쓰는 카드를 묶어 충돌 검사를 줄인다
+    const band = new Map();
+    this.R.forEach((r, i) => {
+      const k = r.x + '|' + r.w;
+      if (!band.has(k)) band.set(k, { x: r.x, w: r.w, m: [] });
+      band.get(k).m.push([i, r.y, r.y + r.h]);
+    });
+    this.bands = [...band.values()];
+    this.lanesX = []; this.lanesY = [];
+  }
+
+  lines(extraX, extraY) {
+    const xs = new Set([this.b.x1, this.b.x2]), ys = new Set([this.b.y1, this.b.y2]);
+    for (const r of this.R) {
+      xs.add(r.x - this.margin); xs.add(r.x + r.w + this.margin);
+      ys.add(r.y - this.margin); ys.add(r.y + r.h + this.margin);
+    }
+    for (const v of extraX) xs.add(v);
+    for (const v of this.lanesX) xs.add(v);
+    for (const v of extraY) ys.add(v);
+    for (const v of this.lanesY) ys.add(v);
+    // 포트는 사각형 변이라 범위 밖일 수 있다 — 그건 통과시킨다
+    const keepX = new Set(extraX), keepY = new Set(extraY);
+    return [
+      [...xs].filter(v => keepX.has(v) || (v >= this.b.x1 && v <= this.b.x2)).sort((a, b) => a - b),
+      [...ys].filter(v => keepY.has(v) || (v >= this.b.y1 && v <= this.b.y2)).sort((a, b) => a - b),
+    ];
+  }
+
+  blocked(x1, y1, x2, y2, skip) {
+    const loX = Math.min(x1, x2), hiX = Math.max(x1, x2);
+    const loY = Math.min(y1, y2), hiY = Math.max(y1, y2);
+    for (const b of this.bands) {
+      if (hiX <= b.x || loX >= b.x + b.w) continue;
+      for (const [i, ry1, ry2] of b.m) {
+        if (skip && skip.has(i)) continue;
+        if (hiY <= ry1 || loY >= ry2) continue;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  segCost() { return 0; }   // 하위 클래스가 혼잡도를 얹는다
+
+  route(p0, p1, skip, bend = 300) {
+    const [xs, ys] = this.lines([p0[0], p1[0]], [p0[1], p1[1]]);
+    const xi = new Map(xs.map((v, i) => [v, i]));
+    const yi = new Map(ys.map((v, i) => [v, i]));
+    if (!xi.has(p0[0]) || !xi.has(p1[0]) || !yi.has(p0[1]) || !yi.has(p1[1])) return null;
+    const S = [xi.get(p0[0]), yi.get(p0[1])];
+    const T = [xi.get(p1[0]), yi.get(p1[1])];
+    const NX = xs.length, NY = ys.length;
+    const D = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+
+    const key = (x, y, dx, dy) => ((y * NX + x) * 9) + ((dx + 1) * 3 + (dy + 1));
+    const g = new Map(), prev = new Map();
+    const start = key(S[0], S[1], 0, 0);
+    g.set(start, 0);
+    const pq = new Heap();
+    pq.push(0, [S[0], S[1], 0, 0, start]);
+    let goal = null;
+
+    while (pq.size) {
+      const [f, , st] = pq.pop();
+      const [cx, cy, ddx, ddy, sk] = st;
+      if (cx === T[0] && cy === T[1]) { goal = st; break; }
+      const h0 = Math.abs(xs[T[0]] - xs[cx]) + Math.abs(ys[T[1]] - ys[cy]);
+      if ((g.get(sk) ?? Infinity) + 1e-6 < f - h0) continue;
+      for (const [dx, dy] of D) {
+        const nx = cx + dx, ny = cy + dy;
+        if (nx < 0 || nx >= NX || ny < 0 || ny >= NY) continue;
+        const x1 = xs[cx], y1 = ys[cy], x2 = xs[nx], y2 = ys[ny];
+        if (this.blocked(x1, y1, x2, y2, skip)) continue;
+        let cost = Math.abs(x2 - x1) + Math.abs(y2 - y1);
+        cost += this.segCost(dx, dy, x1, y1, x2, y2);
+        if ((ddx !== 0 || ddy !== 0) && (dx !== ddx || dy !== ddy)) cost += bend;
+        const nk = key(nx, ny, dx, dy);
+        const ng = g.get(sk) + cost;
+        if (ng < (g.get(nk) ?? Infinity) - 1e-9) {
+          g.set(nk, ng);
+          prev.set(nk, st);
+          const h = Math.abs(xs[T[0]] - x2) + Math.abs(ys[T[1]] - y2);
+          pq.push(ng + h, [nx, ny, dx, dy, nk]);
+        }
+      }
+    }
+    if (!goal) return null;
+    const pts = [];
+    let st = goal;
+    while (prev.has(st[4])) { pts.push([xs[st[0]], ys[st[1]]]); st = prev.get(st[4]); }
+    pts.push(p0);
+    pts.reverse();
+    return simplify(pts);
+  }
+}
+
+/** 혼잡도 인식 라우터 */
+export class OrthoC extends Ortho {
+  constructor(rects, W, H, opt = {}) {
+    super(rects, W, H, opt);
+    this.lanesX = opt.lanesX || [];
+    this.lanesY = opt.lanesY || [];
+    this.tol = opt.tol ?? 7.0;
+    this.congw = opt.cong ?? 90.0;
+    this.used = new Map();
+  }
+
+  cong(axis, coord, lo, hi) {
+    if (hi <= lo) return 0;
+    let tot = 0;
+    const b0 = Math.round(coord / this.tol);
+    for (let b = b0 - 1; b <= b0 + 1; b++) {
+      const list = this.used.get(axis + '|' + b);
+      if (!list) continue;
+      for (const [a0, a1, c] of list) {
+        if (Math.abs(c - coord) > this.tol) continue;
+        const ov = Math.min(hi, a1) - Math.max(lo, a0);
+        if (ov > 0) tot += ov;
+      }
+    }
+    return tot;
+  }
+
+  segCost(dx, dy, x1, y1, x2, y2) {
+    if (dx === 0) return this.congw * this.cong('v', x1, Math.min(y1, y2), Math.max(y1, y2)) / 100;
+    return this.congw * this.cong('h', y1, Math.min(x1, x2), Math.max(x1, x2)) / 100;
+  }
+
+  /** 배선된 경로를 혼잡도에 기록한다 */
+  commit(pts) {
+    for (let i = 0; i < pts.length - 1; i++) {
+      const [x1, y1] = pts[i], [x2, y2] = pts[i + 1];
+      const add = (axis, coord, lo, hi) => {
+        const k = axis + '|' + Math.round(coord / this.tol);
+        if (!this.used.has(k)) this.used.set(k, []);
+        this.used.get(k).push([lo, hi, coord]);
+      };
+      if (Math.abs(x1 - x2) < 0.5 && Math.abs(y1 - y2) >= 0.5)
+        add('v', x1, Math.min(y1, y2), Math.max(y1, y2));
+      else if (Math.abs(y1 - y2) < 0.5 && Math.abs(x1 - x2) >= 0.5)
+        add('h', y1, Math.min(x1, x2), Math.max(x1, x2));
+    }
+  }
+}
+
+/** 엣지마다 출발/도착 변과 포트 좌표를 배정한다.
+ *  같은 변을 쓰는 엣지들은 상대편 위치 순으로 정렬해 변 위에 고르게 벌린다. */
+export function ports(edges, rects, minGap = 13) {
+  const sideOf = [];
+  for (const [ai, bi] of edges) {
+    const A = rects[ai], B = rects[bi];
+    const acx = A.x + A.w / 2, acy = A.y + A.h / 2;
+    const bcx = B.x + B.w / 2, bcy = B.y + B.h / 2;
+    const dx = bcx - acx, dy = bcy - acy;
+    const ox = Math.min(A.x + A.w, B.x + B.w) - Math.max(A.x, B.x);
+    const oy = Math.min(A.y + A.h, B.y + B.h) - Math.max(A.y, B.y);
+    let sa, sb;
+    if (oy > 24 && Math.abs(dx) > 8) { sa = dx > 0 ? 'R' : 'L'; sb = dx > 0 ? 'L' : 'R'; }
+    else if (ox > 24 && Math.abs(dy) > 8) { sa = dy > 0 ? 'B' : 'T'; sb = dy > 0 ? 'T' : 'B'; }
+    else if (Math.abs(dx) >= Math.abs(dy)) { sa = dx > 0 ? 'R' : 'L'; sb = dx > 0 ? 'L' : 'R'; }
+    else { sa = dy > 0 ? 'B' : 'T'; sb = dy > 0 ? 'T' : 'B'; }
+    sideOf.push([sa, sb]);
+  }
+
+  const grp = new Map();
+  edges.forEach(([ai, bi], k) => {
+    const [sa, sb] = sideOf[k];
+    const ka = ai + '|' + sa, kb = bi + '|' + sb;
+    if (!grp.has(ka)) grp.set(ka, []);
+    if (!grp.has(kb)) grp.set(kb, []);
+    grp.get(ka).push([k, 'a']);
+    grp.get(kb).push([k, 'b']);
+  });
+
+  const pos = new Map();
+  for (const [gk, members] of grp) {
+    const ni = +gk.split('|')[0], side = gk.split('|')[1];
+    const R = rects[ni];
+    const keyOf = ([k, end]) => {
+      const oi = end === 'a' ? edges[k][1] : edges[k][0];
+      const O = rects[oi];
+      return (side === 'L' || side === 'R') ? O.y + O.h / 2 : O.x + O.w / 2;
+    };
+    members.sort((p, q) => keyOf(p) - keyOf(q));
+    const n = members.length;
+    const span = (side === 'L' || side === 'R') ? R.h : R.w;
+    const usable = Math.max(span - 18, 8);
+    const step = Math.min(minGap, usable / Math.max(n, 1));
+    const base = (side === 'L' || side === 'R') ? R.y + R.h / 2 : R.x + R.w / 2;
+    members.forEach((m, idx) => {
+      const off = (idx - (n - 1) / 2) * step;
+      let p;
+      if (side === 'L') p = [R.x, base + off];
+      else if (side === 'R') p = [R.x + R.w, base + off];
+      else if (side === 'T') p = [base + off, R.y];
+      else p = [base + off, R.y + R.h];
+      pos.set(m[0] + '|' + m[1], p);
+    });
+  }
+  return { sideOf, port: pos };
+}
+
+function laneOffsets(paths, gap, tol) {
+  const buckets = new Map();
+  paths.forEach((pts, pi) => {
+    if (!pts || pts.length < 4) return;
+    for (let i = 1; i < pts.length - 2; i++) {
+      const [x1, y1] = pts[i], [x2, y2] = pts[i + 1];
+      if (Math.abs(x1 - x2) < 0.5 && Math.abs(y1 - y2) >= 0.5) {
+        const k = 'v|' + Math.round(x1 / tol);
+        if (!buckets.has(k)) buckets.set(k, []);
+        buckets.get(k).push([pi, i, Math.min(y1, y2), Math.max(y1, y2), 'v']);
+      } else if (Math.abs(y1 - y2) < 0.5 && Math.abs(x1 - x2) >= 0.5) {
+        const k = 'h|' + Math.round(y1 / tol);
+        if (!buckets.has(k)) buckets.set(k, []);
+        buckets.get(k).push([pi, i, Math.min(x1, x2), Math.max(x1, x2), 'h']);
+      }
+    }
+  });
+  const want = new Map();
+  const bump = (pi, i, axis, v) => {
+    const k = pi + '|' + i + '|' + axis;
+    want.set(k, (want.get(k) || 0) + v);
+  };
+  for (const items of buckets.values()) {
+    if (items.length < 2) continue;
+    items.sort((a, b) => a[2] - b[2] || a[3] - b[3]);
+    const laneEnd = [], assign = [];
+    items.forEach(([, , lo, hi], k) => {
+      let put = -1;
+      for (let li = 0; li < laneEnd.length; li++) {
+        if (lo >= laneEnd[li] - 0.5) { laneEnd[li] = hi; put = li; break; }
+      }
+      if (put < 0) { laneEnd.push(hi); put = laneEnd.length - 1; }
+      assign[k] = put;
+    });
+    const n = laneEnd.length;
+    if (n < 2) continue;
+    items.forEach(([pi, i, , , axis], k) => {
+      const off = (assign[k] - (n - 1) / 2) * gap;
+      bump(pi, i, axis, off);
+      bump(pi, i + 1, axis, off);
+    });
+  }
+  return want;
+}
+
+/** 겹치는 평행선을 레인으로 벌린다.
+ *  통째로 되돌리지 않고 경로별로 배율을 낮춰가며 안 뚫리는 최대치를 쓴다.
+ *  분산은 라우팅 다음에 점을 옮기므로 관통 검사를 여기서 반드시 해야 한다. */
+export function spread(paths, rects, skips, opt = {}) {
+  const { gap = 9, tol = 6.0, rounds = 3, eps = 3.0, bounds = null } = opt;
+  // 분산은 라우팅 다음에 점을 옮긴다. 범위 검사를 안 하면
+  // 가장자리를 타던 선이 캔버스 밖으로 밀려나 잘려 보인다 — 실제로 그랬다.
+  const inBounds = pts => !bounds || pts.every(([x, y]) =>
+    x >= bounds.x1 - 0.5 && x <= bounds.x2 + 0.5 && y >= bounds.y1 - 0.5 && y <= bounds.y2 + 0.5);
+  const scales = opt.scales || [1.0, 0.78, 0.56, 0.34, 0.16];
+  let cur = paths.map(p => (p || []).map(q => [q[0], q[1]]));
+  for (let r = 0; r < rounds; r++) {
+    const want = laneOffsets(cur, gap, tol);
+    cur = cur.map((pts, pi) => {
+      if (!pts || pts.length < 4) return pts;
+      for (const sc of scales) {
+        const q = pts.map(p => [p[0], p[1]]);
+        for (let j = 1; j < q.length - 1; j++) {
+          const dv = (want.get(pi + '|' + j + '|v') || 0) * sc;
+          const dh = (want.get(pi + '|' + j + '|h') || 0) * sc;
+          if (dv) q[j][0] += dv;
+          if (dh) q[j][1] += dh;
+        }
+        const cand = snap(q, eps);
+        if (!pierces(cand, rects, skips[pi]) && inBounds(cand)) return cand;
+      }
+      return pts;
+    });
+  }
+  return cur;
+}

package/skills/erd-visual/engine/verify.mjs

@@ -0,0 +1,138 @@
+/* 검증 — 관통 · 겹침 · 텍스트 넘침
+ *
+ * 이 프로젝트에서 눈으로 못 본 결함을 전부 여기서 잡았다.
+ * 검사를 배선 '전에' 돌리면 통과한 것처럼 보인다 (채널 분산이 점을 옮기기 때문).
+ * 반드시 최종 경로로 판정한다.
+ */
+
+import { pierces } from './router.mjs';
+
+/** 한글은 1em, 라틴은 0.56em 로 본 대략적인 렌더 폭.
+ *  정확한 값은 브라우저만 안다 — verify.html 이 getBBox 로 다시 잰다. */
+export function textWidth(s, px, ko = 1.0, asc = 0.56) {
+  let w = 0;
+  for (const ch of s) w += px * (ch.codePointAt(0) > 0x2000 ? ko : asc);
+  return w;
+}
+
+/** 폭에 맞게 자른다. 글자수로 자르면 한글/영문이 제각각 깨진다. */
+export function fitText(s, maxPx, px, ko = 1.0, asc = 0.56) {
+  if (textWidth(s, px, ko, asc) <= maxPx) return s;
+  const ell = textWidth('…', px, ko, asc);
+  let out = '';
+  for (const ch of s) {
+    if (textWidth(out + ch, px, ko, asc) + ell > maxPx) break;
+    out += ch;
+  }
+  return out ? out.replace(/\s+$/, '') + '…' : '…';
+}
+
+function segments(paths) {
+  const out = [];
+  paths.forEach((pts, pi) => {
+    if (!pts) return;
+    for (let i = 0; i < pts.length - 1; i++) {
+      const [x1, y1] = pts[i], [x2, y2] = pts[i + 1];
+      if (Math.abs(x1 - x2) < 0.5 && Math.abs(y1 - y2) >= 0.5)
+        out.push([pi, 'v', x1, Math.min(y1, y2), Math.max(y1, y2)]);
+      else if (Math.abs(y1 - y2) < 0.5 && Math.abs(x1 - x2) >= 0.5)
+        out.push([pi, 'h', y1, Math.min(x1, x2), Math.max(x1, x2)]);
+    }
+  });
+  return out;
+}
+
+/** 같은 축·같은 좌표에서 실제로 겹쳐 보이는 구간 쌍을 센다 */
+export function measureOverlap(paths, tol = 2.0, minLen = 12.0) {
+  const S = segments(paths);
+  const buck = new Map();
+  for (const s of S) {
+    const k = s[1] + '|' + Math.round(s[2] / tol);
+    if (!buck.has(k)) buck.set(k, []);
+    buck.get(k).push(s);
+  }
+  let pairs = 0, total = 0;
+  for (const v of buck.values()) {
+    for (let i = 0; i < v.length; i++) {
+      for (let j = i + 1; j < v.length; j++) {
+        const a = v[i], b = v[j];
+        if (a[0] === b[0]) continue;
+        if (Math.abs(a[2] - b[2]) > tol) continue;
+        const ov = Math.min(a[4], b[4]) - Math.max(a[3], b[3]);
+        if (ov > minLen) { pairs++; total += ov; }
+      }
+    }
+  }
+  return { segments: S.length, overlapPairs: pairs, overlapLen: Math.round(total) };
+}
+
+/** 배선이 카드를 뚫는가 */
+export function checkPierce(paths, rects, skips) {
+  const bad = [];
+  paths.forEach((pts, i) => {
+    if (pts && pierces(pts, rects, skips[i], 1.5)) bad.push(i);
+  });
+  return bad;
+}
+
+/** 카드끼리 겹치는가 */
+export function checkCardOverlap(rects, names = []) {
+  const bad = [];
+  for (let i = 0; i < rects.length; i++) {
+    for (let j = i + 1; j < rects.length; j++) {
+      const a = rects[i], b = rects[j];
+      if (a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y)
+        bad.push([names[i] || i, names[j] || j]);
+    }
+  }
+  return bad;
+}
+
+/** 카드 안 텍스트가 카드 밖으로 나가는가 (추정 폭 기준) */
+export function checkTextFit(items) {
+  const bad = [];
+  for (const it of items) {
+    const w = textWidth(it.text, it.px, it.ko ?? 1.0, it.asc ?? 0.56);
+    if (w > it.maxPx + 0.5) bad.push({ ...it, width: Math.round(w), over: Math.round(w - it.maxPx) });
+  }
+  return bad;
+}
+
+/** 캔버스를 벗어나는 좌표가 있는가 */
+export function checkBounds(rects, W, H) {
+  return rects.filter(r => r.x < 0 || r.y < 0 || r.x + r.w > W || r.y + r.h > H);
+}
+
+/** 배선이 캔버스를 벗어나는가.
+ *  카드만 검사하면 놓친다 — 굵은 번들이 가장자리를 타다 밀려 나간 적이 있다. */
+export function checkPathBounds(paths, W, H, pad = 0) {
+  const bad = [];
+  paths.forEach((pts, i) => {
+    if (!pts) return;
+    for (const [x, y] of pts) {
+      if (x < -pad || y < -pad || x > W + pad || y > H + pad) {
+        bad.push({ i, at: [Math.round(x), Math.round(y)] });
+        break;
+      }
+    }
+  });
+  return bad;
+}
+
+/** 전체 판정 — 필수 항목이 하나라도 0 이 아니면 실패 */
+export function report(res) {
+  const must = [
+    ['카드 관통', res.pierce.length],
+    ['카드 겹침', res.cardOverlap.length],
+    ['텍스트 넘침', res.textFit.length],
+    ['캔버스 이탈', res.bounds.length + (res.pathBounds ? res.pathBounds.length : 0)
+      + (res.bundleBounds ? res.bundleBounds.length : 0)],
+  ];
+  const failed = must.filter(([, n]) => n > 0);
+  return {
+    ok: failed.length === 0,
+    must,
+    failed,
+    overlap: res.overlap,
+  };
+}

package/skills/erd-visual/engine/wire.mjs

@@ -0,0 +1,115 @@
+/* 배선 오케스트레이션 — Node 와 브라우저가 같은 경로를 타게 하는 단일 진입점 */
+
+import { OrthoC, ports, spread } from './router.mjs';
+import { isSys } from './layout.mjs';
+
+/** 게이트·행 사이에 레인을 깔아 A* 가 쓸 수 있는 선을 늘린다 */
+function lanes(lay) {
+  const g = lay.geo;
+  const X = [];
+  const nCol = lay.columns.length;
+  for (let i = 0; i < nCol - 1; i++) {
+    const gx = g.PAD + i * (g.CW + g.GUT) + g.CW;
+    for (let k = 1; k <= 10; k++) X.push(gx + g.GUT * k / 11);
+  }
+  X.push(g.PAD - 26, g.PAD + nCol * (g.CW + g.GUT) - g.GUT + g.CW + 26);
+
+  const Y = [g.TOP + g.HEAD - 30, g.TOP + g.HEAD - 17, lay.H - 84, lay.H - 70, lay.H - 56];
+  for (let j = 0; j < lay.maxRows; j++) {
+    const yb = g.TOP + g.HEAD + j * (g.CH + g.CG) + g.CH;
+    for (const k of [1, 2, 3]) Y.push(yb + g.CG * k / 4);
+  }
+  return { X, Y };
+}
+
+export function wire(model, lay) {
+  const g = lay.geo;
+  const nCol = lay.columns.length;
+  const names = [...lay.pos.keys()];
+  const NI = new Map(names.map((t, i) => [t, i]));
+  const RECT = names.map(t => {
+    const p = lay.pos.get(t);
+    return { x: p.x, y: p.y, w: p.w, h: p.h };
+  });
+  const EDG = model.refs.map(r => [NI.get(r.from), NI.get(r.to)]);
+  const skips = EDG.map(([a, b]) => new Set([a, b]));
+  const L = lanes(lay);
+
+  // ── 개별 배선 ────────────────────────────────────────────
+  const { port } = ports(EDG, RECT, 9);
+  const eBounds = { x1: 16, y1: g.TOP - 14, x2: lay.W - 16, y2: lay.H - g.FOOT + 40 };
+  const RT = new OrthoC(RECT, lay.W, lay.H,
+    { margin: 15, clear: 8, bounds: eBounds, lanesX: L.X, lanesY: L.Y, tol: 7.0, cong: 150.0 });
+
+  // 긴 선부터. 짧은 선이 먼저 자리를 잡으면 긴 선이 크게 돈다.
+  const order = model.refs.map((_, k) => k).sort((a, b) => {
+    const da = Math.abs(lay.pos.get(model.refs[a].from).col - lay.pos.get(model.refs[a].to).col);
+    const db = Math.abs(lay.pos.get(model.refs[b].from).col - lay.pos.get(model.refs[b].to).col);
+    return db - da;
+  });
+
+  const raw = new Array(EDG.length);
+  let fail = 0;
+  for (const k of order) {
+    const [ai, bi] = EDG[k];
+    const p0 = port.get(k + '|a'), p1 = port.get(k + '|b');
+    const pts = RT.route(p0, p1, new Set([ai, bi]), 340);
+    if (!pts) { fail++; raw[k] = [p0, p1]; } else { RT.commit(pts); raw[k] = pts; }
+  }
+  const paths = spread(raw, RECT, skips, { gap: 9, tol: 7.0, rounds: 4, bounds: eBounds });
+
+  // ── 도메인 번들 ──────────────────────────────────────────
+  const cnt = new Map();
+  for (const r of model.refs) {
+    const ga = lay.pos.get(r.from).dom, gb = lay.pos.get(r.to).dom;
+    if (ga === gb) continue;
+    // 이스케이프로 쓴다 — 이유는 layout.mjs orderColumns 주석 참조
+    const k = ga + '\u001f' + gb;
+    cnt.set(k, (cnt.get(k) || 0) + 1);
+  }
+  const DIX = new Map(lay.domBounds.map((r, i) => [r.dom, i]));
+  const bKeys = [], bEdges = [], bCount = [];
+  for (const [k, n] of cnt) {
+    const [ga, gb] = k.split('\u001f');
+    if (!DIX.has(ga) || !DIX.has(gb)) continue;
+    bKeys.push([ga, gb]);
+    bEdges.push([DIX.get(ga), DIX.get(gb)]);
+    bCount.push(n);
+  }
+  const bRect = lay.domBounds.map(r => ({ x: r.x, y: r.y, w: r.w, h: r.h }));
+  const bSkips = bEdges.map(([a, b]) => new Set([a, b]));
+
+  const bLanesX = [];
+  for (let i = 0; i < nCol - 1; i++) {
+    const gx = g.PAD + i * (g.CW + g.GUT) + g.CW;
+    for (let k = 1; k <= 6; k++) bLanesX.push(gx + g.GUT * k / 7);
+  }
+  const y0 = lay.domBounds.length ? Math.min(...lay.domBounds.map(r => r.y)) : g.TOP;
+  // 번들은 굵다(최대 7.6px). 캔버스 가장자리를 타면 테두리에 잘려 깨져 보이고,
+  // 제목·범례 위로 지나가면 글자를 덮는다. 그래서 다닐 수 있는 띠를 좁혀 준다.
+  const bBounds = { x1: 24, y1: g.TOP - 8, x2: lay.W - 24, y2: lay.H - g.FOOT + 26 };
+  const bLanesY = [y0 - 46, y0 - 30, bBounds.y2 - 30, bBounds.y2 - 16, bBounds.y2 - 4]
+    .filter(v => v >= bBounds.y1 && v <= bBounds.y2);
+
+  const bp = ports(bEdges, bRect, 16).port;
+  const BRT = new OrthoC(bRect, lay.W, lay.H,
+    { margin: 20, clear: 11, bounds: bBounds, lanesX: bLanesX, lanesY: bLanesY,
+      tol: 15.0, cong: 320.0 });
+  const bOrder = bEdges.map((_, k) => k).sort((a, b) => bCount[b] - bCount[a]);
+  const bRaw = new Array(bEdges.length);
+  for (const k of bOrder) {
+    const [ai, bi] = bEdges[k];
+    const p0 = bp.get(k + '|a'), p1 = bp.get(k + '|b');
+    const pts = BRT.route(p0, p1, new Set([ai, bi]), 380);
+    if (pts) BRT.commit(pts);
+    bRaw[k] = pts || [p0, p1];
+  }
+  const bundlePaths = spread(bRaw, bRect, bSkips,
+    { gap: 17, tol: 13.0, rounds: 4, bounds: bBounds });
+
+  return {
+    names, RECT, EDG, skips, paths, fail,
+    bundlePaths, bundleKeys: bKeys, bundleCount: bCount, bundleRect: bRect, bundleSkips: bSkips,
+    isSysRef: model.refs.map(isSys),
+  };
+}