# -*- coding: utf-8 -*-
u"""R2 刀片 PCB 摆位（M4c-2；2026-09-08 改成**双面**：器件在手机的另一面）。

    /c/Python314/python .claude/r2/pcb_place.py           # 只算 + 自检（不下发）
    /c/Python314/python .claude/r2/pcb_place.py --push    # 下发摆位
    /c/Python314/python .claude/r2/pcb_place.py --verify  # 读回校验

## ⛔ 分面：**手机在 A 面，器件全部在 B 面**（2026-09-09 用户拍板）

小米8 主板压在 **A 面**（顶层）。A 面**只剩 `K1~K4` 四个裸铜盘**（主板弹片直接压，
物理上只能在这一面）和两面都是指的 `J1`；**其余 78 件全部在 B 面**。

`J600` 的电池排线和 `J1401` 的尾插排线从接口边翻下来，落到 A 面服务带后**穿板**
（`pcb_blade.flex_slots()`，接口边外侧 y 24.8~27.8 的两条铣穿槽），U 形折回 B 面，
贴着 B 面往 +y 走到**手机投影下方**的 `J5` / `J4` —— 和 R1 的 J8n / J7n 一模一样。
排线在 B 面占的车道 `LANES` 里**一件不放**。

**高度预算分两段**（槽距 20.32，板厚 1.6，螺柱间隙 1.0）：

| B 面区域 | 对面是什么 | 净空 | 落地 |
|---|---|---|---|
| 服务带 y 12~28 | 隔壁刀片的 A 面服务带，**现在是空的** | 20.32 − 1.6 = **18.7** | `C60`(10.5) / `J2` / `J3`(5) 只能放这里 |
| 手机投影 y ≥ 29 | 隔壁刀片的手机主板 | 20.32 − 1.6 − 1.0 − 7.6 = **10.1**（h_phone 取物理上限）| `J4` BM24 + 排线、`L1` 3.0 都够 |

⚠ 以前「B 面只有 3.0」是把 `L1` 的高度当预算写的，不是净空；净空一直有 10 mm。
`HEIGHT` 里登记的超高件禁止进手机投影，自检会拦。

**`J5` / `J4` 的朝向**：排线穿槽折回是绕 x 轴翻 180°（x 不变、y 镜像），立创底层
正是「先 y 镜像再转 rot」（方案 §25.3）⇒ **底层 rot 0**，pin1 仍在西边（`J5.1 = P+`
在 −x，与 §13.5 用户实测「P+ 在左」一致）。⚠ 这是推导 + R1 §25.16 同一结论，
**装配首件仍要两点通断复核**，几何校验抓不到接反。

## 三类件，三种定位方式

1. **机械锚定件**（位置由小米8 主板决定，不许挪）：`K1~K4` 侧键触点盘、
   `J5` 电池排线焊盘、`J4` BM24 尾插座。坐标从 **`.claude/mi8_mech.json`** 换算，
   不手抄。手机主板在刀片上的落点是 `PHONE_ORG`（方案 §3.1：x 3~70.09 / y 29~73.66，
   长边水平、**接口边朝下**）。
2. **手工钉死件**：`J1` 金手指（`pcb_blade.J1_X`）、`C60` Ø10.3 的 2200 µF、
   `J2` D± 退路座、`J3` EDL 座 —— 各有各的理由，见 `ANCHORS` 的注释。
3. **其余 73 件**：按功能分组、按「电流流向」排序，塞进六个区（`REGIONS`），
   用一个简单的货架式排布器摆。**顺序是设计意图，坐标不是** ——
   要改布局改 `GROUPS` 里的顺序和区，不要去改具体坐标。

## 分区（方案 §3.1，坐标见 `pcb_blade.py`；除 K1~K4 外全部是 B 面）

| 区 | 范围 | 放什么 |
|---|---|---|
| 金手指区 | y 0~11 | **只有 J1，其余一件不放**（插槽体 ~9 mm 要让开），两面都不放 |
| 排线槽 + 车道 | BAT x 20.8~32.8 / TAIL x 46.6~66.6，y 24.8 → J5/J4 顶 | **铣穿 + 排线平贴，一件不放** |
| `KEY` | x 0.6~13 / y 22~38 | 侧键 MOS + 栅极电阻，`K1~K4` 的正背面 |
| `DIS` | x 21~34.2 / y 12~24 | `VO_P` 泄放，电池槽下方（VO-L3 岛内） |
| `CTRL` | x 54~63 / y 47~56 | I²C 上拉，跟着 `U4` 走（M7 起在板中央） |
| `SVC_M` | x 33~42.5 / y 29~50 | `VO_P` 阻尼组，电池车道东侧、`J5` 旁边（H4 螺钉头以西） |
| `SVC_R` | x 47.5~65.5 / y 35.5~46 | 尾插 USB + VBUS 开关，`J4` **北边（插头背后）** |
| `SVC_E` | x 66.6~72.5 / y 36.4~50 | EDL 模拟开关，尾插车道与功率列之间的走廊，`J3` 正北 |
| 功率列 | x 72.3~97.5 / y 12~74 | Buck / eFuse / 检流，**按「离手机越远越吵」内外分两条** |

功率列内部：外条（x 86~97.5，靠板边）放 SW 节点、电感、Cin —— 最吵的；
内条（x 72~84，贴手机）放 FB 分压、DAC 低通、INA226、eFuse 外围 —— 最怕吵的。
这是方案 §3.1 的「按离手机越远越吵排」和风险 R-12。

## M7（2026-09-09）：为「先自动布线」重排 B 面

用户拍板「B 面全部重排 → 先跑 EDA 自动布线 → 再优化」。这一版**动的是拥塞，不是拓扑**
—— §7.2 那四条关键回路（输入环路 / SW 面积 / FB 远离 SW / Kelvin）靠的是功率链手排，
一个数都没改；机械锚定件（`K1~K4` / `J5` / `J4` / `J1` / 七个孔）同样一个数没改。改的是：

| 改动 | 为什么 |
|---|---|
| 排布器节距 1.1 → **1.8** | M6 欠的 5 只脚全是「出口被自家邻脚封死」。1.1 只够过一根线；板面占用率才 6%，加节距是白捡的 |
| `U4` PCA9555 从 (76.3, 18.5) 挪到 **(48, 52)** | 它 8×8 的本体卡在「功率列内条 × 金手指北岸」那个口袋里，五只不通的脚全在它周边一圈 |
| `EFUSE_AUX` 从 9.5×11.5 扩到 **11.7×16**，东沿退到 84.0 | 给 `U2` 西边留 2.55 的扇出通道（M6 只有 1.55） |
| `U2` 上下的缝 1.8 → **2.6 / 2.4**，`U1_Y` 49.5 → **50.9** | WQFN-20 上下两排脚要横着爬出去；抬 U1 是为了不把链尾 `U3` 顶到金手指禁布区上 |
"""
import io
import json
import math
import os
import sys

sys.stdout.reconfigure(encoding='utf-8')
HERE = os.path.dirname(os.path.abspath(__file__))
# ⚠ 顺序不能反：`.claude` 下有同名的 R1 脚本（pcb_pour / pcb_rules / pcb_place），
#   先插 .claude 再插 HERE 的话，`import pcb_pour` 会拿到 R1 那一份，
#   而且**不报错**，只在调到 R2 专有的函数时才炸。
sys.path.insert(0, os.path.dirname(HERE))
sys.path.insert(0, HERE)
from eda import run                                              # noqa: E402
import pcb_blade as B                                            # noqa: E402

MIL = B.MIL
PCB = B.PCB
BBOX = os.path.join(HERE, '_blade_bbox.json')
MECH = os.path.join(os.path.dirname(HERE), 'mi8_mech.json')

GAP = 0.6                       # 件间净距（mm）：**装配**下限，自检按它判重叠
# ⛔ 排布器的**摆放节距**要比装配下限大得多 —— 0.6 的缝里塞不进一根线：
#   0.2 的线要 0.2 + 2×0.18(净距) = **0.56**，再加上 0.25 的网格吸附，
#   实际上等于没有通道。实测 0.6 排下来，17 处「出不来」里大半在 **0402 电阻**上
#   （不是细间距 IC），布线器怎么调顺序都是 28~30 条接不上。
#   1.1 能过一根线还剩余量；区里都有空地（`EFUSE_AUX` 12 件只占了 79 mm² 中的 45）。
PACK_GAP = 1.8                  # 排布器的摆放节距（M7 从 1.1 加到 1.8，见下）
# ⛔ **M7（2026-09-09）把节距从 1.1 加到 1.8**：1.1 只够过**一根** 0.2 的线
#   （0.2 + 2×0.18 = 0.56，加 0.25 网格吸附实际剩不到一根的余量），而 M6 欠的
#   5 只脚全是「出口被自家邻脚封死」——不是没地方走线，是**脚出不来**。
#   1.8 能并排走两根线还剩余量。板子一点都不挤：83 件本体面积加起来 ~430 mm²，
#   板面 7448 mm²，占用率 6%，加节距是白捡的。
# 个别区可以覆盖（值 = 该区的节距）。
PACK_GAP_BY_REGION = {
    'BUCK_FB': 1.4,             # U1 右边只有 6 mm 宽的缝，1.8 会退化成单列
}
MILL_KEEP = 0.5                 # 器件离铣穿内槽的净距
# 排线在 B 面占的车道：从槽顶到连接器顶沿，宽 = 排线宽 + 2×0.5。**一件不放**（排线要平贴）。
# ⛔ 2026-09-11 刀片 98×76 → 90×68：本文件里的手排坐标都是 M7（手机原点 (3, 29)、板宽 98）
#   那一版算出来的。**跟手机绑定的**加 (DX, DY)，**功率区**加 PX（整块西移，内部回路关系不动）。
M7_ORG = (3.0, 29.0)
DX = round(B.PHONE_ORG[0] - M7_ORG[0], 3)       # −1.5
DY = round(B.PHONE_ORG[1] - M7_ORG[1], 3)       # −6.66
PX = round(B.BW - 98.0, 3)                      # −8.0
LANE_TOP = {'BAT': round(34.5 + DY, 3), 'TAIL': round(35.0 + DY, 3)}

# 手机主板在刀片上的落点：本体 (u,v) -> 板 (x,y) = (PHONE_ORG + (u,v))
# 方案 §3.1：主板 67.09 × 44.66，长边水平、**接口边（v=0 那条，J600/J1401/侧键都在上面）朝下**。
# ⚠ 事实来源在 pcb_blade（板级），这里只做别名，不要抄第二份
PHONE_ORG = B.PHONE_ORG
PHONE_WH = B.PHONE_WH

# 焊盘外框量不到本体的几个件：给真实本体尺寸（mm）
BODY = {
    'C60': (11.0, 11.0),        # Ø10.3 铝电解，2200 µF（T2 = 高 10.5）
    'L1': (7.6, 7.0),           # SPM6530T-4R7M
    'J4': (13.2, 3.6),          # BM24-50DS
    'U4': (8.0, 8.0),
}

# ── 分面 ───────────────────────────────────────────────────────────────
# **A 面（顶层）只留这 10 件**，其余全部 B 面。理由逐条写在模块头的表里。
TOP_ONLY = ['J1', 'K1', 'K2', 'K3', 'K4']

# 装配高度（mm）。只登记**可能超手机投影预算**的件 —— 放进 B 面手机投影会顶到
# 隔壁槽的手机主板，而**几何自检和 DRC 一条都不报**。
HEIGHT = {
    'C60': 10.5,                # Ø10.3 铝电解（T2 实测）
    'J3': 5.0,                  # 1.25 mm 2P 线座（估）
    'L1': 3.0,                  # SPM6530T
}
H_B_PHONE = 20.32 - 1.6 - 1.0 - 7.6    # B 面手机投影下的净空（h_phone 取物理上限）= 10.12
H_B_SVC = 20.32 - 1.6                  # B 面服务带的净空（对面 A 面服务带是空的）= 18.72


def phone(u, v):
    return (round(PHONE_ORG[0] + u, 3), round(PHONE_ORG[1] + v, 3))


def lanes():
    u"""排线在 B 面的车道 {名字: (x0, y0, x1, y1)}：槽顶 → 连接器顶沿，一件不放。"""
    out = {}
    for k, cx in B.flex_x().items():
        hw = B.FLEX_W[k] / 2.0 + 0.5
        out[k] = (round(cx - hw, 3), B.SLOT_Y[1], round(cx + hw, 3), LANE_TOP[k])
    return out


def anchors():
    u"""机械锚定 + 手工钉死的件 -> (x, y, rot)。K1~K4 在 A 面，其余 B 面。"""
    m = json.load(io.open(MECH, encoding='utf-8'))
    sk = m['side_key_contacts']
    fx = B.flex_x()
    a = {}
    # ── 侧键触点盘：主板自己的弹片直接压在这四个裸铜盘上（R1 §22.3e 中框式）──
    #    位置**完全由主板决定**，Ø1.5 的盘只容许 0.50 mm 位置误差（pcb2_place 的算账）。
    for ref, key in (('K1', 'PWR'), ('K2', 'VUP'), ('K3', 'VDN'), ('K4', 'GND')):
        a[ref] = phone(*sk[key]) + (0,)
    # ── 电池排线焊盘 J5：B 面、电池槽正北、手机投影下方（排线穿槽后折回 +y）──
    #    y 由排线长度定：J600→接口边 4.6 + 绕边 5 + 到槽心 2.7 + 穿板 1.6 + 背面 (y−26.3)
    #    ≈ 19.6 ≤ 35（实长 38）。焊盘 4 高，底沿 30 离槽顶 27.8 有 2.2。**底层 rot 0**（见模块头）。
    a['J5'] = (fx['BAT'], round(32.0 + DY, 3), 0)
    # ── BM24 尾插座 J4：B 面、尾插槽正北。2.48 + 5 + 2.7 + 1.6 + 6.7 ≈ 18.5 ≤ 50（实长 55）。
    #    本体 2.6 高 → 31.7~34.3；H4 (44.9,30.9) 在西边 5.4 mm 外。**底层 rot 0**。
    a['J4'] = (fx['TAIL'], round(33.0 + DY, 3), 0)
    # ── C60：Ø10.3 / 高 10.5，只能在服务带（B 面净空 18.7）。夹在两条槽之间，
    #    x 取两槽正中（焊盘外沿 12.9 宽，离两侧铣槽各 0.45）。
    #    ⛔ y **贴着金手指区上沿**（本体 11 的下沿 = 11.0），不是居中：居中（上下各余 0.17）时
    #       H4 螺钉头圈只剩 2.07 < HOLE_KEEP 2.2；贴下沿之后上沿 22.0 离接口边 22.34 余 0.34，
    #       离 H4 2.24。（真实罐体 Ø10.3，比 BODY 的 11 每边还小 0.35。）
    s = B.flex_slots()
    a['C60'] = (round((s['BAT'][2] + s['TAIL'][0]) / 2.0, 3),
                round(B.ZONES['finger'][3] + BODY['C60'][1] / 2.0, 3), 0)
    # （J2 D± 退路座 2026-09-11 已删，见 b4_edge.py 表头）
    # ── J3：EDL 座。两根飞线要去主板朝上面的 TP1204/1205，只能**跟着尾插排线穿尾插槽**
    #    （R1 同一做法）⇒ 座子贴着尾插槽东头。90×68 之后车道东侧那条走廊被功率区西移吃掉了，
    #    改放**服务带里、尾插槽东头与功率列之间**（x 65.6~70.6 / y 11~22）：
    #    竖放 rot 270 ⇒ 本体 5.2×8.35，信号盘朝**西**正对槽口。
    #    ⚠ 底层「先 y 镜像再转」：rot 0 读回信号盘在南，按 p = R(rot)·(lx, −ly) 推 rot 270 在西
    #      （原 J2 实测同一结论：rot 90 在东、rot 270 在西）。放完用焊盘读回核一次。
    tail = s['TAIL']
    a['J3'] = (round(tail[2] + MILL_KEEP + GAP / 2 + 5.2 / 2 + 0.2, 3),
               round(B.ZONES['finger'][3] + GAP / 2 + 8.35 / 2 + 0.5, 3), 270)
    return a


# ── 功率级：**手排**，不交给排布器 ────────────────────────────────────
# ⛔ 上一版把功率级也交给货架排布器，结果 §7.2 的四条关键回路**破了三条**：
#    Cin 离 U1 **12.4 mm**（输入环路）、SW 从 U1 绕到 L1 走了 ~7 mm（SW 面积）、
#    FB 分压压在 SW 那一带。货架算法只会「按面积塞满」，它不认识回路。
#
# **`U1` 转 90° 是这一版的关键一步**：TPS54622 的 VIN/GND 在一条长边、SW 在对边，
# 不转的话 Cin 和电感必然分居左右两侧 —— 而 §3.1 要求 SW / 电感 / Cin **同时**
# 靠板外边（x 88~98，离手机最远）。转成横放之后 VIN/GND 朝上、SW 朝下，
# 于是竖着堆成一条：**D1/F1 → Cin ×4 → U1 → L1 → Cout → eFuse → 分流 → INA**，
# 电流自上而下，出口 `VO_P` 正好落在 `VO-L3` 岛（y ≤ 28.8）里。
#
# 三条回路各自的落地判据（改坐标前先想清楚会破哪一条）：
#   · **输入环路**：`C4/C1/C2/C3` 正压在 U1 的 VIN/GND 引脚上方，最近一颗环路 ~1.0 mm；
#   · **SW 面积**：`L1` 转 90° 让 1 号脚朝上，和 U1 的 SW 脚**焊盘对焊盘 0.6 mm**，
#     SW 铜就是那一小块 3.4 mm 宽的方块，绕不出去；
#   · **Kelvin**：`U3` 转 180° 让 9/10 脚朝上正对 `Rs1` —— **不转就是交叉**
#     （9 脚在 10 脚右边，却要接左边那个焊盘），一交叉就得打过孔，§7.2 明令不许。
STACK_GAP = 0.65                 # 手排竖直堆叠的件间净距

# (位号, rot, dx)：dx = 相对功率列中心线 PWR_X 的横向偏移；y 由 stack() 自上而下算
PWR_X = round(89.0 + PX, 3)      # 2026-09-11：板宽 98 → 90，整条功率链西移 8（81.0）
# 功率链的锚：U1 的中心 y。⚠ 抬高 2.5 mm 是**布线逼出来的**：链尾的 `U3`(INA226)
# 底边五个 0.5 mm 间距的脚要朝下扇出到金手指那一侧，原来只剩 1.0 mm 净空，
# 布线器报「INA_ALERT 一个焊盘都出不来」。抬完剩 3.5 mm，五根线排得开。
U1_Y = 50.9                      # ⚠ M7 从 49.5 抬到 50.9：U2 上下的缝各加了 0.8/0.6，
#   整条链会往下顺移同样多，而链尾 `U3`(INA226) 底边那五个 0.5 mm 间距的脚
#   离金手指禁布区只剩 1.67 mm —— 正是 M4c 当初抬高 2.5 mm 要解决的那件事。
#   抬 1.4 抵掉，U3 底沿回到 14.07（禁布区 11），扇出仍有 3.0 mm。
STACK_UP = [                     # U1 往上：Cin 由近到远，再是保险/TVS
    ('C4', 180, 0.0),            # 0402 HF，压在 VIN/GND 脚正上方
    ('C1', 180, 0.0),
    ('C2', 180, 0.0),
    ('C3', 180, 0.0),
    ('F1', 90, 0.0),             # rot=90 ⇒ p1(+12V) 朝上接 V12-L3 岛、p2(+12V_F) 朝下
]
# 第 4 个字段 = 这一件和上一件之间的净距（缺省 STACK_GAP）。
# ⚠ `U2` 上下要留 1.8：它是 WQFN-20，四条边都有脚，**上下两排要从 0.65 mm 的
#   缝里横着爬出去** —— 实测这一带堵掉了 eFuse 的 6 个信号（$1N147/$1N151/
#   $1N164/EFUSE_EN/EFUSE_PG/EFUSE_FLT）。功率链在 y 上有 15 mm 富余，加得起。
STACK_DN = [                     # U1 往下：电感 → 输出电容 → eFuse → 分流 → INA
    # ⚠ 这个 1.5 不是随便给的：U1 底边除了 SW(11/12) 还有 p9/p10/p13(BOOT)，
    #   贴到 0.65 等于把整条边封死，那三只脚**只能横着爬**而两侧都是焊盘 ——
    #   实测 `$1N136`/`$1N138` 死活出不来。1.5 给它们让出一条通道，
    #   SW 焊盘净距从 0.65 变 1.5，仍远小于 §7.2 的 2.0 判据。
    ('L1', 270, -0.25, 1.5),     # p1(SW) 朝上正对 U1 的 SW 脚
    ('C6', 0, -0.25),
    ('C7', 0, -0.25),
    ('C8', 0, -0.25),            # 输出 HF，接着 C6/C7 排在同一条线上
    # ⚠ M7 从 1.8 加到 2.6 / 2.4：U2 是 WQFN-20，上下两排脚要横着爬出去，
    #   M6 欠的 5 只脚里有 3 只（U2.15 / U2.17 / U2.2）就死在这两条缝里。
    #   功率链在 y 上还有 ~14 mm 富余（U3 底 14.06 vs 禁布区 11），加得起。
    ('U2', 180, 0.0, 2.6),       # rot=180 ⇒ VO 从上边进、$1N165 从下边出
    ('Rs1', 0, -4.2, 2.4),       # p2(右) 接 U2 的输出、p1(左) = VO_P 出岛
    ('U3', 180, -4.95, 1.4),     # rot=180 ⇒ 9/10 脚朝上，正对 Rs1 两端（不交叉）
]
# 不进竖直堆叠、但位置由引脚决定的几件
HAND = {
    # BOOT 电容：BOOT 脚（p13）在 U1 下边、SW 也在下边，但正下方被 L1 占满了。
    # ⇒ 摆到 L1 左侧，`SW` 那一脚接 **L1 的 1 号焊盘**（同一个节点，不必绕回 U1）。
    'C5': (PWR_X - 5.3, U1_Y - 6.3, 0),
    # U1 的 p9($1N135) 旁路：p9 在下边偏右，摆到 U1 右下角外
    'C9': (PWR_X + 3.45, U1_Y - 1.72, 0),   # 和 p9 同一条水平线，2.0 mm
    # TVS：竖在 Cin 堆左侧，p1(+12V_F) 朝上，和保险的出线端同一节点
    # ⚠ M7：从 U1_Y+2.5 挪到 +3.1（北移 0.6），给 `R3` 让出 U1 西边那个口袋（见下）。
    'D1': (PWR_X - 4.2, U1_Y + 3.1, 90),
    # ── 尾插那两颗（U7 ESD / U5 VBUS 开关）：J4 现在也在 B 面，排线从南边来，
    #    它们只能在 J4 **北边**（插头背后）—— 交给 SVC_R 区的排布器，U7 排第一个
    #    落在区的西南角（离 J4 的 D± 脚最近）。
    # ── PCA9555：TSSOP-24，两排各 12 只脚 0.65 mm 间距 ────────────────────
    # **M7 用户拍板：挪到左下角**（原来 M7 第一版放板中央 (48,52)，更早在功率列
    # 那个拥塞口袋 (76.3,18.5)）。左下角这块 x 4~20 / y 11.6~21 本来是空的，
    # 四面净空都 ≥ 2 mm，而且离侧键 MOS（`Q3~Q5` 在 x 2~5.5 / y 26~30）最近 ——
    # `KEY_PWR/VUP/VDN` 三根从 M6 到现在一直是布不通的钉子户，这一挪从 70 mm 变 12 mm。
    # ⛔ **y 不能照用户拖的 10.67**：本体 8×8 ⇒ 下沿会落到 **6.67**，
    #    而 y < 11 是**金手指区**，PCIe 插槽体（~9 mm 高）要从两面夹住这一段板 ——
    #    放件进去装不上，几何自检会拦（`侵入金手指区`）。抬到 15.6：下沿 11.6，
    #    离禁布区 0.6，离 KEY 区下沿（22）2.4。
    # ⚠ 用户拖过来时是 rot 180，**改成 rot 0**：两者都是「南北两排」，
    #   差别在哪一排朝哪边 —— rot180 时 `p1~p12`（`KEY_PWR/VUP/VDN`、`INT#`、
    #   `EDL_EN`、`VBUS_EN`）朝**南**，而侧键 MOS `Q3~Q5` 在**北**边（y 26~30）；
    #   同时 `p13~p24`（`SDA/SCL/+3V3` + 四路状态）朝北，而金手指在**南**边。
    #   两排正好各自背对自己的去向，等于每根线都要绕整颗芯片一圈 —— M6 在功率列
    #   上就是这么丢掉 4 处的（原 `HAND` 注释里那段「转 180」说的是同一件事）。
    'U4': (12.5, 15.6, 0),
    # PCA9555 去耦 + I²C 上拉：**跟着 U4 走**，坐标由 `pin_xy()` 从板上读回的
    # U4 引脚位置现算（见该函数的说明），不手抄。
    # ⛔ `R3`（EN 分压的下臂，`$1N128`）**必须在 U1 西边**：`U1.1`(EN) 和 `p14`(BUCK_PG)
    #   都在西短边，而 `BUCK_FB` 区在 U1 **东**边（那是给 FB/COMP 的，见 REGIONS 注释）。
    #   摆在东边的话这根线要绕整颗芯片 —— 布线器就是这么报「$1N128: U1.1 没布通」的，
    #   `place_audit.py` 也把它列在「摆错边」里。
    #   口袋是 L1 顶(47.2) / U1 西沿(86.875) / D1 南沿(50.6，已北移让路) 夹出来的那一小块。
    'R3': (round(85.95 + PX, 3), 48.8, 90),
    # INA226 的 +3V3 旁路，摆在 U3 右侧（U3 上下两排脚都被 Kelvin / I2C 占着）
    'C13': (round(86.8 + PX, 3), 18.0, 0),
    # ── U7（D± ESD）：**手排在 J4 那两只 D± 脚正北**（2026-09-11，90×68 + U7 两侧对调之后）──
    #    下排 6/4 脚（DMJ 西 / DPJ 东）正对 J4 的 4/6 脚（DMJ 51.23 西 / DPJ 51.58 东），
    #    直直往南 ~2 mm 接过去，零交叉；上排 1/3 脚（USB_DM / USB_DP）朝北，
    #    金手指来的一对在顶层掉头从北边进来、脚旁各一个孔下 B 面（手性推导见 b3b_usb.py）。
    #    J4 两只 D± 脚相对本体 (−3.85/−3.50, +1.06)，U7 焊盘排距 ±1.15（都是 dump 出来的封装常量）；
    #    本体下沿离 J4 本体顶 0.73，在尾插车道上沿（LANE_TOP）以北。
    'U7': (round(B.flex_x()['TAIL'] - 3.675, 3), round(33.0 + DY + 1.059 + 2.0 + 1.148, 3), 0),
    # EDL 模拟开关：跟着 J3 走，交给 SVC_E 区排布器（U6 排第一个）
    # ── 侧键 MOS：转 90° 让 3 脚（接触点盘那一路）朝上，排在 K1~K4 正下方 ──
    # ⚠ 90×68：y 跟手机走（+DY），**x 不动** —— Q4 本来就贴着板边（x 0.73~3.28），
    #   跟着手机左移 1.5 就出板；三颗一起不动，彼此间距不变，离 K 盘的上下余量也不变。
    'Q3': (5.5, round(29.9 + DY, 3), 90),
    'Q4': (2.0, round(29.9 + DY, 3), 90),
    'Q5': (5.5, round(26.1 + DY, 3), 90),
}


def stack(pos, sz):
    u"""把 STACK_UP / STACK_DN 按 bbox 高度自 U1 向两头堆开，返回补进去的坐标。

    ⚠ 只用 bbox 高度 + `STACK_GAP` 算 —— 不手抄 y。改一颗件的封装，
      整条链自动重排，不会留下一个「当初算好、现在对不上」的常数。
    """
    out = {'U1': (PWR_X, U1_Y, 270)}
    y = U1_Y + sz['U1'][1] / 2.0
    for item in STACK_UP:
        ref, rot, dx = item[:3]
        gap = item[3] if len(item) > 3 else STACK_GAP
        h = sz[ref][0] if rot % 180 else sz[ref][1]
        y += gap + h / 2.0
        out[ref] = (round(PWR_X + dx, 3), round(y, 3), rot)
        y += h / 2.0
    y = U1_Y - sz['U1'][1] / 2.0
    for item in STACK_DN:
        ref, rot, dx = item[:3]
        gap = item[3] if len(item) > 3 else STACK_GAP
        h = sz[ref][0] if rot % 180 else sz[ref][1]
        y -= gap + h / 2.0
        out[ref] = (round(PWR_X + dx, 3), round(y, 3), rot)
        y -= h / 2.0
    return out


# ── 分组：**顺序 = 电流/信号流向**，排布器按这个顺序摆 ──────────────────
GROUPS = [
    # (区, 组名, [位号...])
    # 功率链本体已经手排（STACK_*/HAND），这里只剩「跟着某颗 IC 走」的外围。
    ('CTRL',      u'I2C 上拉 + 去耦（正常情况下由 ctrl_hand 钉在 U4 脚上）', ['C40', 'R40', 'R41']),
    # ⚠ `VO_P` 泄放支路（R19 10Ω/1W + Q2）挪到**服务带左段**：它接的是 `VO_P`，
    #   而 `VO_P` 在 L3 上是整块岛（服务带全覆盖），放哪一头都一样近；
    #   放这里把功率列内条腾出来给 U4 的扇出带。
    ('DIS',       u'VO_P 泄放支路',        ['R19', 'Q2']),
    # ⛔ M7 三版拆成东西两组。`U2` 是 WQFN-20，**四条边都有脚**，而 M7 二版把 12 件
    #   全塞在它西边 —— 接东边 `p17~p20`（`$1N156`/`$1N158`/`$1N151`/`EFUSE_FLT`）的
    #   四件要绕整颗芯片才够得着，U2 周围本来就只有那么几个出口，一绕就把别人也堵死
    #   （M6/M7 一直布不通的 `$1N156: U2.17` 就是这么来的）。
    ('EFUSE_E',   u'eFuse 东侧（p17~p20）',  ['R11', 'C14', 'R12', 'R13']),
    # ⚠ 90×68：EDL 开关排在 EFUSE_AUX **之前** —— 两区在 J3 正北重叠，谁先摆谁先挑；
    #   第一版反过来，U6 被挤到 y 37.5（离 J3 20 mm），`$3N45: J3.2 ↔ U6.4` 没布通。
    ('SVC_E',     u'EDL 模拟开关',          ['U6', 'R63', 'C69']),
    ('EFUSE_AUX', u'eFuse 西侧 + 北侧',      ['R9', 'R10', 'R16', 'R17',
                                            'R15', 'R14', 'Q1', 'R18']),
    # ⚠ FB / 补偿**必须在这个区**：它贴着 U1 的左边（FB/COMP 脚都在左长边），
    #   同时离 SW（x 87~94、y 34~42 那一块）≥ 2 mm —— §7.2 第三条「FB 远离 SW」。
    ('BUCK_FB',   u'FB 分压 + 补偿 + DAC 低通', ['R1', 'R2', 'R7', 'R8', 'C12',
                                                 'R4', 'R5', 'R6', 'C10', 'C11']),  # R3 见 HAND
    # ⚠ 侧键组：三颗 MOS 已手排在 K1~K4 正下方，这里只剩栅极电阻，跟着 MOS 走。
    ('KEY',       u'侧键栅极电阻',          ['R42', 'R43', 'R44', 'R45', 'R46', 'R47']),
    ('SVC_M',     u'VO_P 阻尼组 + 电池外围', ['C61', 'C62', 'C63', 'C64', 'C65',
                                              'R60', 'R61']),
    ('SVC_R',     u'尾插 USB + VBUS 外围',  ['U7', 'U5', 'C66', 'C67', 'C68', 'R62', 'R64', 'R65']),
]

# ── 区（x0, y0, x1, y1），排布器在里面自下而上、自左而右铺 ────────────────
# ⚠ 三个服务带小区各自贴着自己那件连接器：
#   SVC_M ↔ J5(26.8,32)，SVC_R ↔ J4(56.6,33) 北边，SVC_E ↔ J3(69.9,33) 北边。
#   区改小是故意的：范围给大了货架排布器会把件铺到离连接器 15 mm 外去。
# ⚠ KEY 区上沿 36.6 = H1 螺钉头(4.4,38.9) 让 2.2。
REGIONS = {
    # ⚠ M7：跟着 U4 搬到板中央，落在 U4 东列（x 51.0）外侧 —— SDA/SCL 上拉
    #   就地接到 p22/p23 上，不用绕。北边到 H5(60.4,70.2) 还有 14 mm。
    # ⚠ M7 二版：跟着 U4 挪到左下角，占 U4 东边那条 4 mm 宽的缝（DIS 区从 x 21 起）。
    # ⚠ 90×68：上沿收到电池槽下沿（槽现在在 y 18.14~21.14）
    'CTRL':      (17.2, 12.0, 20.8, round(B.SLOT_Y[0] - MILL_KEEP - 0.1, 3)),
    # ⚠ 必须落在 VO-L3 岛（x ≥ 20）里：R19 的 VO_P 脚要就地扎过孔进岛，
    #   放到岛外面布线器会报「找不到落过孔的地方」。东沿 34.2 贴 C60 本体西沿 34.5。
    # ⚠ M7 上沿从 18.8 抬到 24.0（= 电池铣槽下沿 24.8 让 0.8）：节距加到 1.8 之后
    #   R19(7.4×3.5) + Q2 在 6.8 高的带子里排不下第二行。
    # ⛔ 90×68 第三版：挪到**电池车道正北、手机投影下**（B 面，R19 2512 / Q2 都 < 1 mm 高）。
    #   第一版放在电池槽正下方（y 11.2~17.6），而服务带压到 11.34 之后，**槽下那条 6.4 mm 高的带
    #   是 U4（左下角）往东去的唯一走廊** —— ~8 个网（SDA/SCL/BUCK_PG/EDL_EN/VBUS_EN/EFUSE_FLT/
    #   INA_ALERT/EFUSE_PG）要从这儿过，R19+Q2 把 B 面那一层从 x 18 到 32 整段占满，服务器上
    #   调布线顺序只能此消彼长（2026-09-11 第三轮：三个长网通了、SDA 整网断成 4 块）。
    #   新位置紧挨电池座 J5（R19 本来就接 VO_P = 电池正）、正下方是 VO-L3 岛的北叶，就地扎孔照旧。
    'DIS':       (17.5, round(LANE_TOP['BAT'] + 0.46, 3), 32.0, 35.0),
    # ⚠ M7 大改：U4 搬走腾出的整块口袋都给它（原来 9.5×11.5 塞 12 件，节距 1.1）。
    #   南沿 13.0 = 金手指禁布区 11 让 2.0；东沿 84.0 给 U2 西边留 2.55 的扇出通道
    #   （U2 本体西沿 86.55），M6 就是这条通道只有 1.55 才把 R11/R16 憋死的。
    # ⚠ 南沿定在 20.0 而不是 13.0：货架排布器是**自下而上**填的，y0 给到 13
    #   会把 12 件全堆到离 U2(y 27.2~31.1) 最远的那一头，ILIM/dV-dt 这些
    #   本该贴着芯片的件跑到 12 mm 外。y 13~20 那块留空，正好是 U3 底排
    #   五只 0.5 mm 间距脚往金手指方向扇出的地方。
    # `U2` 东边（本体东沿 91.45）到板边之间那条缝。上沿 33.5 让开 `C8`(y 32.3~32.9) 所在的
    #   功率链中心线；下沿 23.5 让开 `Rs1`(y 19.9~23.4)。4 件一列，顺序由「按连线就近落位」
    #   自动排成 p17→p20 的顺序（目标点精确到焊盘）。
    # ⚠ 北沿放到 36.0：目标驱动的排布器会为了靠近自己那只脚把件排在非对齐的 y 上，
    #   5.4×10 的框里 4 件就可能塞不下（实测 `R13` 放不下）。东边这一条本来就是空的。
    'EFUSE_E':   (round(92.0 + PX, 3), 23.0, round(97.4 + PX, 3), 36.0),
    # ⚠ 90×68：整体西移 8 会压上尾插槽 / 车道（东沿 65.58）和新的 J3 ⇒ 区整体放到 J3 **以北**、
    #   车道东沿以东，宽度保持 M7 的 11.2（东沿仍离 U2 西沿 2.55）。第一版把西沿收到 68.6（宽 7.4），
    #   R16/R17 被挤到离 U2 7~11 mm，`$1N165: R16.1` 没布通。
    'EFUSE_AUX': (64.8, 20.7, round(84.0 + PX, 3), 40.0),
    # ⚠ FB / 补偿在 U1 的**右短边**（转 270 之后 p7=FB、p8=COMP 都在 x=+1.72 那一侧），
    #   所以这个区在 U1 右边、板边那一条 6 mm 的缝里 —— 离 SW（x 87~90）≥ 2 mm。
    #   ⚠ M7 只把 y 拉长（1.4 的节距下 6.1 宽刚好两列），不动 x：再往东就是板边。
    'BUCK_FB':   (round(91.3 + PX, 3), U1_Y - 8.0, round(97.4 + PX, 3), U1_Y + 15.0),
    # ⚠ M7 东沿从 8.5 拉到 13.0：K1~K4 四个盘 + 三颗 MOS 已经占掉了西边这一条，
    #   1.8 节距下六只栅极电阻排不进去（x 9~13 这一带本来就是空的）。
    'KEY':       (0.6, round(22.0 + DY, 3), 13.0, round(38.0 + DY, 3)),
    # 电池车道东沿 31.77+0.5 → 33；H4 (44.9,30.9) 螺钉头西沿 42.7。
    # ⚠ M7 三版：北沿 **45.5**（不是 50）—— `VO-L3` 岛的北叶只到 **y=46**
    #   （`pcb_pour.VO_LOBE`），排到 48.8 的那颗阻尼电容 `VO_P` 脚就地扎不了过孔，
    #   布线器报「找不到落过孔的地方」。而且阻尼组本来就该贴着 `J5`(26.8,32)，
    #   越往北越没意义。少的高度往横里补：东沿 42.5 → 44.5（H4 螺钉头的避让圈
    #   由 blockers() 兜着）。
    'SVC_M':     (round(33.0 + DX, 3), round(29.0 + DY, 3), round(44.5 + DX, 3), round(45.5 + DY, 3)),
    # J4 北边：本体顶 34.3 + 0.6。⚠ M7 北沿收到 42.0（给 U4 的南面让出 6 mm 扇出净空），
    #   东沿从 66 收到 64.5（尾插车道东沿 66.08 之内），少的高度靠 1.8 节距下仍够 8 件。
    # ⚠ 90×68：只留 U7 换层孔空地**以东**那一块（U7 已手排）—— 第一版给了整条 18 mm，
    #   排布器的「同尺寸互换」把 C67 / C68 换到了离 U5 6~8 mm 的地方，`$5N71: U5.4` 没布通。
    'SVC_R':     (53.6, round(35.5 + DY, 3), 65.0, round(46.0 + DY, 3)),
    # ⚠ 90×68：J3 挪到服务带（尾插槽东头）之后，EDL 开关排在它**正北**那一小块
    #   （车道东沿 64.58 以东、J3 本体顶 20.45 以北）；GROUPS 里排在 EFUSE_AUX 前面。
    'SVC_E':     (64.8, 20.7, 70.4, 32.0),
}

# ⛔ 排布器的障碍**要分面**。A 面的 `J4` / `J5` / `C60` / `J2` / `J3` 挡的是 A 面，
#    把它们当成 B 面的障碍，「USB 组落在 J4 正背面」这条设计意图就永远实现不了
#    （排布器会绕开 J4 的本体框，把件推到 5 mm 以外）。
#    ⇒ 只有下面这几件对**两面**都算障碍：
#      · `K1~K4`：Ø1.5 裸铜盘，B 面要在旁边扎过孔把漏极引下来，正背面得空着；
#        而且手机弹片压在上面，底下不摆件也让受力干净。
#      · `J1`：金手指，两面都是指。
BLOCK_BOTH = ('J1', 'K1', 'K2', 'K3', 'K4')


def bottom_refs(pos=None):
    u"""B 面件 = 全部 - TOP_ONLY。"""
    d = json.load(io.open(BBOX, encoding='utf-8'))
    return [r for r in (pos or d) if r not in TOP_ONLY]


def sizes():
    d = json.load(io.open(BBOX, encoding='utf-8'))
    out = {}
    for ref, v in d.items():
        w, h = BODY.get(ref, (v['w'], v['h']))
        out[ref] = (max(w, 0.6), max(h, 0.6))
    return out


def overlaps(r, rects):
    for q in rects:
        if r[0] < q[2] and q[0] < r[2] and r[1] < q[3] and q[1] < r[3]:
            return True
    return False


def blockers():
    u"""排布器的**固定障碍**：铣穿的排线槽 + 排线车道 + 七个定位孔的螺钉头避让圈。

    ⛔ 不把它们喂进排布器，货架算法照样会往里塞件，然后自检报一堆错 ——
       窗里那几件是**摆在空气里**（内槽铣穿），孔那几件是被螺钉头压着。
    """
    out = []
    for (a, b, c, d) in B.mill_cuts():
        out.append((a - MILL_KEEP, b - MILL_KEEP, c + MILL_KEEP, d + MILL_KEEP))
    out += list(lanes().values())
    for (hx, hy) in B.phone_holes().values():
        out.append((hx - B.HOLE_KEEP, hy - B.HOLE_KEEP,
                    hx + B.HOLE_KEEP, hy + B.HOLE_KEEP))
    # D± 在顶层从北边来、在 U7 上排（1/3 脚）北边换层下 B 面 ⇒ 那一小块 B 面不放件
    ux, uy, _r = HAND['U7']
    out.append((ux - 1.8, uy + 1.7, ux + 1.8, uy + 4.2))
    return out


def wh(ref, rot, sz):
    u"""转 90/270 之后 bbox 的宽高要对调。**手排件全靠这一步**——
    忘了对调，`L1`(7.6×7.0 转 90) 和 `D1`(6.8×2.2 转 90) 的占位就是错的，
    而错的方向是「看起来更小」，于是重叠检查放行、截图上却压在一起。"""
    w, h = sz[ref]
    return (h, w) if rot % 180 else (w, h)


def plan():
    u"""返回 {位号: (x, y, rot)} 和占位矩形表。"""
    sz = sizes()
    pos = dict(anchors())
    pos['J1'] = (B.J1_X, B.J1_Y, B.J1_ROT)
    pos.update(stack(pos, sz))                   # 功率链（手排，竖直堆叠）
    pos.update(HAND)                             # 其余按引脚钉死的手排件
    pos.update(ctrl_hand(pos, sz))               # C40/R40/R41 跟着 U4 的引脚现算
    # 排布器只摆 B 面的件 ⇒ 障碍表里只放「对 B 面也成立」的东西（见 BLOCK_BOTH）
    # ⛔ M7 修掉一个 M5 遗留：这里原来把 `anchors()`（J2/J3/J4/J5/C60）从障碍表里
    #   排除掉，理由是「它们在 A 面，挡的是 A 面」—— 但 M6 已经把它们全翻到 B 面了，
    #   排除条件没跟着改。M6 没暴露是因为当时没有哪个区压到连接器上；M7 的
    #   EFUSE_AUX 一往西扩就把 Q1 摆进了 J3 的本体里（自检那一关拦下来的）。
    #   ⇒ 只要不在 TOP_ONLY 里，就是 B 面的固定障碍。
    fixed = list(BLOCK_BOTH) + sorted(set(pos) - set(TOP_ONLY))
    rects = list(blockers())
    for ref in fixed:
        x, y, r = pos[ref]
        w, h = wh(ref, r, sz)
        rects.append((x - w / 2 - GAP / 2, y - h / 2 - GAP / 2,
                      x + w / 2 + GAP / 2, y + h / 2 + GAP / 2))

    # 每个区一个 y 游标：**一个组占一条完整的横带**，下一组从带子上沿重新开始。
    # 不这么做的话小件会回填到前面组的空隙里，功能级在 y 上互相咬 ——
    # 后面 L3 要按「哪一段是 12V、哪一段是 VO」切铜面就切不出来了。
    cursor = {k: v[1] for k, v in REGIONS.items()}
    unplaced = []
    slots = {}                                   # {(区, 尺寸类): [(位号, (x,y))]}
    peers0 = net_peers()
    STEP = 0.5                                   # 候选格点的步长（和老版扫描一致）
    for region, _name, refs in GROUPS:
        x0, _y0, x1, y1 = REGIONS[region]
        gap = PACK_GAP_BY_REGION.get(region, PACK_GAP)
        y0 = cursor[region]
        todo = [r for r in refs if r not in pos]
        if not todo:
            continue
        # ⛔ **挑「离目标最近的空位」，不是「自下而上第一个空位」**。
        #   老版按面积从下往上塞，位置和这件连到哪儿毫无关系 —— 用户一眼看出来
        #   「没摆顺」（`U2` 东边四只脚的外围件全被塞到西边去了）。
        #   目标点由 `target_point()` 精确到**对端焊盘**给出。
        #   大件先挑（它们的目标最硬、可选位置最少），同尺寸按位号稳定排序。
        order = sorted(todo, key=lambda r: (-sz[r][0] * sz[r][1], r))
        band_top = y0
        for ref in order:
            w, h = sz[ref][0] + gap, sz[ref][1] + gap
            t = target_point(ref, peers0, pos, ((x0 + x1) / 2.0, (y0 + y1) / 2.0))
            best = None
            yy = y0
            while yy + h <= y1 + 1e-9:
                xx = x0
                while xx + w <= x1 + 1e-9:
                    r = (xx, yy, xx + w, yy + h)
                    if not overlaps(r, rects):
                        cx, cy = xx + w / 2, yy + h / 2
                        key = ((math.hypot(cx - t[0], cy - t[1]) if t else 0.0), yy, xx)
                        if best is None or key < best[0]:
                            best = (key, r, cx, cy)
                    xx += STEP
                yy += STEP
            if best is None:
                unplaced.append((ref, region))
                continue
            _key, r, cx, cy = best
            rects.append(r)
            pos[ref] = (round(cx, 3), round(cy, 3), 0)
            slots.setdefault((region, size_class(sz[ref])), []).append((ref, (round(cx, 3), round(cy, 3))))
            band_top = max(band_top, r[3])
        cursor[region] = band_top + 0.4
    peers = net_peers()
    if peers:
        # ⚠ 迭代 3 轮：同一组里的件互为目标点（`C68` 要贴 `U5`，而 `U5` 自己也是
        #   排布器摆的），一轮收敛不了 —— 第一轮 `C68` 按 `U5` 的**初始货架位**去靠，
        #   而 `U5` 那一轮也在动。实测第 2 轮就基本不动了，第 3 轮兜底。
        for _ in range(3):
            if not reassign(pos, slots, peers):
                break
    # ⚠ 网格微调**所有件**（含手排的功率链）：0.5 mm 间距的 QFN 不落在 0.25 格点上时，
    #   相邻两只脚的出线只能挤到 0.25，比净距（0.15+0.16）还窄，布线器就报「出不来」。
    #   `U2.19` / `U1.1` 都是这么卡住的。挪完再逐对校核净距，破了 GAP 的**退回去**。
    before = dict(pos)
    grid_snap(pos)
    # ⚠ 退回要**迭代到不动为止**：退回 A 会让它和「已经挪过、没退回」的 B 之间重新变窄
    #   （实测 C1 退回、C2 没退，缝从 0.65 变 0.55，自检报重叠）。
    done = set()
    for _ in range(6):
        bad = snap_conflicts(pos, sz) - done
        if not bad:
            break
        for ref in bad:
            pos[ref] = before[ref]
        done |= bad
    return pos, rects, unplaced, sz


def u4_local_pins():
    u"""从 `_blade_pads.json` 读回 `U4` 24 只脚**相对质心**的局部偏移 {脚号: (dx, dy)}。

    TSSOP 两排脚对称 ⇒ 质心就是本体中心，不需要另外知道当初摆在哪。
    ⚠ 这份文件是**上一次下发之后 dump 的**：改了 `U4` 的旋转角要先
      `pcb_route.py --dump` 再重跑一次 `--push`（两趟收敛），否则下面
      `ctrl_hand()` 会认出「排布方向对不上」并退回给货架排布器。
    """
    if not os.path.exists(PADS_JSON):
        return {}
    d = [r for r in json.load(io.open(PADS_JSON, encoding='utf-8')) if r[0] == 'U4']
    if len(d) != 24:
        return {}
    cx = sum(r[2] for r in d) / len(d)
    cy = sum(r[3] for r in d) / len(d)
    return {r[1]: (round(r[2] - cx, 3), round(r[3] - cy, 3)) for r in d}


def ctrl_hand(pos, sz=None):
    u"""`C40` / `R40` / `R41` 跟着 `U4` 的引脚现算位置 —— 不手抄坐标。

    · `C40` 100nF 去耦要贴 `p24(+3V3)` / `p21(GND)`：交给货架排布器它会落到区角上、
      离电源脚 5 mm 以上，去耦离得远等于没有。
    · `R40` / `R41` I²C 上拉贴 `p22(SCL)` / `p23(SDA)`。

    ⛔ 三件不能各自贴各自的脚：`p22/p23/p24` 相邻只差 **0.65 mm**，而 0402 加装配净距
      要 2 mm 才排得下 —— 第一版就是这么写的，自检直接报三处重叠。
      ⇒ 排成**一排**，间距 `ROW_PITCH`，整排贴在 `U4` 本体那一侧的外面
      （`本体半宽 + GAP + 件的半高`，从 `BODY['U4']` 现算，不写死）。

    排布方向（南北两排 / 东西两列）从局部偏移反推，和计划的 rot 对不上就返回空，
    让这三件回到 `CTRL` 区由排布器摆（下一趟 `--dump` + `--push` 自动归位）。
    """
    lp = u4_local_pins()
    if not lp or 'U4' not in pos:
        return {}
    ux, uy, urot = pos['U4']
    rows = len(set(round(v[1], 2) for v in lp.values())) == 2      # 南北两排
    if rows != (urot % 180 == 0):
        print(u'   [!] _blade_pads.json 里 U4 还是上一版的朝向，C40/R40/R41 先交给排布器；'
              u'跑一次 pcb_route.py --dump 再 --push 就归位')
        return {}
    ROW_PITCH = 2.2
    sz = sz or sizes()
    half_u = (BODY['U4'][1] if rows else BODY['U4'][0]) / 2.0
    items = [('C40', '24'), ('R41', '23'), ('R40', '22')]          # 顺序 = 脚的顺序
    pins = [lp[q] for _r, q in items if q in lp]
    if len(pins) != len(items):
        return {}
    out = {}
    # 整排放在这几只脚所在的那一侧外面；件转 90°（长边垂直于本体边），半高 0.67
    side = 1.0 if (pins[0][1] if rows else pins[0][0]) > 0 else -1.0
    # ⚠ 半高要按**转 90° 之后**的 bbox 取（0402 转 90 是 0.54 宽 × 1.43 高，半高 0.715）——
    #   写死 0.67 的那一版差 0.045 mm，自检报「R41 和 U4 重叠」。
    half_sat = max(wh(r, 90 if rows else 0, sz)[1 if rows else 0]
                   for r, _q in (('C40', '24'), ('R41', '23'), ('R40', '22'))) / 2.0
    # ⚠ 试过「贴引脚排而不是本体框」（想把这三件塞到 U4 南边、脚的正下方）：**不行**。
    #    TSSOP 的焊盘本身长 ~1.5 mm，脚心 ±3.02 加上焊盘就是 ±3.8，再加净距和件的半高，
    #    南边那一排会落到 y≈11.3 —— 而金手指禁布区上沿是 11.0，等于贴着禁区边缘，
    #    自检直接报「和 U4 重叠」。⇒ 仍按**本体框**让开，靠下面的退路走西边。
    off = half_u + GAP + half_sat
    ctr = sum((q[0] if rows else q[1]) for q in pins) / len(pins)
    # 首选：贴着这三只脚所在的那条边，排成一排。
    cand = []
    for k, (ref, _q) in enumerate(items):
        t = ctr + (k - (len(items) - 1) / 2.0) * ROW_PITCH
        cand.append((ref, (round(ux + t, 3), round(uy + side * off, 3), 90) if rows
                     else (round(ux + side * off, 3), round(uy + t, 3), 0)))
    # ⛔ 但这一排可能落进禁区：U4 挪到左下角之后，`p13~p24` 那条边朝南，
    #    往南 5.3 mm 就是**金手指区**（y < 11，插槽体要夹住）。
    #    ⇒ 退到**垂直的那条边**（离板边近的一侧），y 对齐引脚排，横着堆。
    lim = B.ZONES['finger'][3] + 0.3
    if rows and min(c[1][1] for c in cand) - 0.72 < lim:
        sx = -1.0 if ux < B.BW / 2.0 else 1.0
        py = uy + (pins[0][1] if rows else 0.0)              # 引脚排的 y
        cand = [(ref, (round(ux + sx * off, 3),
                       round(py + k * ROW_PITCH, 3), 0))
                for k, (ref, _q) in enumerate(items)]
    return dict(cand)


# ── M7：按连线就近落位（货架排完之后，在**同尺寸**的位置之间重排）────────
PADS_JSON = os.path.join(HERE, '_blade_pads.json')
SNAP_JSON = os.path.join(HERE, '_blade_pad_offsets.json')
GRID = 0.25            # 和 router.py 的网格一致
# 平面网 / 巨网：不参与「往哪儿靠」的计算
#   GND / VO_P / +12V 走铜面（`router.py` 的 SKIP / PLANE_VIA_NETS / ISLAND_NETS），
#   把它们算进去等于把所有件都往铜面中心拽，没有意义。
PLANE_NETS = ('GND', 'VO_P', '+12V', '+12V_F')


def size_class(wh_):
    u"""重排时哪些件可以互换位置。

    ⛔ 不能按「尺寸完全相同」分类：`C14`(1.88×0.54) 和 `R12`(1.43×0.54) 差 0.45 mm
      就换不了位置了，于是 `U2` 东侧那一列排成 p17→p19→p18→p20，两根线白白交叉一次。
    ⇒ 只要都是**小贴片**（≤ 2.5 × 1.5）就归一类：货架格子是按 1.8 的节距留的
      （1.43 + 1.8 = 3.23），塞个 1.88 的件进去仍有 1.35 的富余，
      而真挤到了自检那一关（同面重叠，净距 0.6）会拦下来。
    """
    w, h = wh_
    if w <= 2.5 and h <= 1.5:
        return 'SMALL'
    if h <= 2.5 and w <= 1.5:
        return 'SMALL90'
    return wh_


def net_peers():
    u"""{位号: [(网名, [(对端位号, 焊盘局部偏移 dx, dy), ...])]}，从 `_blade_pads.json` 反查。

    ⚠ 存的是**对端焊盘相对它自己本体中心的偏移**，不是绝对坐标 —— 焊盘表是上一次
      下发之后 dump 的，绝对坐标会过期；局部偏移只跟封装和旋转角有关。本体中心用
      该件所有焊盘的**质心**近似（两排对称的封装上就是精确值）。

    ⛔ 为什么非要精确到**焊盘**：按「器件中心」算目标点的话，`U2` 周围那 12 个外围件
      的目标点全是同一个点，谁摆哪儿都一样 —— 排出来就是「没摆顺」：接东边
      `p17~p20` 的件被扔到西边去，线要绕整颗芯片一圈。精确到焊盘之后
      `R11`→`p17`、`C14`→`p18`、`R12`→`p19`、`R13`→`p20`，一列排下来顺序自然就对。
    """
    if not os.path.exists(PADS_JSON):
        return {}
    d = json.load(io.open(PADS_JSON, encoding='utf-8'))
    cen = {}
    for row in d:
        cen.setdefault(row[0], []).append((row[2], row[3]))
    npin = {r: len(ps) for r, ps in cen.items()}
    cen = {r: (sum(p[0] for p in ps) / len(ps), sum(p[1] for p in ps) / len(ps))
           for r, ps in cen.items()}
    bynet = {}
    for row in d:
        ref, net = row[0], row[7]
        if not net or net in PLANE_NETS:
            continue
        cx, cy = cen[ref]
        bynet.setdefault(net, []).append((ref, round(row[2] - cx, 3), round(row[3] - cy, 3),
                                         npin[ref]))
    out = {}
    for net, items in bynet.items():
        for r in set(it[0] for it in items):
            others = [it for it in items if it[0] != r]
            if others:
                out.setdefault(r, []).append((net, others))
    return out


def target_point(ref, peers, pos, ref_pt=None):
    u"""这个件「该往哪儿去」：每个网取**离参考点最近的那个对端焊盘**，再按网平均。

    对端焊盘位置 = 对端件在本次方案里的中心 + 它的焊盘局部偏移 ⇒ 不吃过期坐标。

    ⛔ 不用「同网所有对端焊盘的质心」：`C66` 是 `U5` 的 `+5V` 输入电容，而 `+5V` 这个网上
      还挂着金手指 `J1.A19/A32`（在板子最南边）—— 质心被拽到 10 mm 外，
      排出来「去耦离电源脚 9.9 mm」。取**最近的那一个**才是人排板的做法：
      旁路电容跟着芯片的那只脚走，不管这个网还去了哪儿。

    `ref_pt` 是「从哪儿看最近」，一般给所在区的中心；不给就用件当前位置（若已摆）。
    """
    if ref not in peers:
        return None
    if ref_pt is None:
        ref_pt = pos.get(ref, (0.0, 0.0))[:2]
    xs, ys = [], []
    for _net, others in peers[ref]:
        cand = [(pos[q][0] + dx, pos[q][1] + dy, n) for q, dx, dy, n in others if q in pos]
        if not cand:
            continue
        # ⛔ 有芯片对端时**只认芯片**：`C11` 是 `U1` 的补偿电容，同网还挂着 `R6`，
        #   按「最近的对端」会跟着 `R6` 跑到 9 mm 外。旁路 / 补偿件要跟着**芯片的那只脚**。
        ic = [c for c in cand if c[2] >= 4]
        pick = ic or cand
        q = min(pick, key=lambda c: math.hypot(c[0] - ref_pt[0], c[1] - ref_pt[1]))
        xs.append(q[0])
        ys.append(q[1])
    if not xs:
        return None
    return (sum(xs) / len(xs), sum(ys) / len(ys))


def reassign(pos, slots, peers):
    u"""在**同一区、同一尺寸**的一组货架位置之间重排，让每件离自己的对端更近。

    先贪心（按「最想去的位置」排序取），再做 2-opt 交换到不能再降。
    位置只在同尺寸之间换 —— 换了尺寸货架占位就错了，而**几何自检抓不到**
    （它只看重叠，不看这个位置当初是给谁留的）。
    """
    moved = 0
    for (region, cls), items in sorted(slots.items(), key=lambda kv: (kv[0][0], str(kv[0][1]))):
        if len(items) < 2:
            continue
        refs = [r for r, _xy in items]
        pts = [xy for _r, xy in items]
        tgt = {r: target_point(r, peers, pos) for r in refs}
        if not any(tgt.values()):
            continue

        def cost(assign):
            c = 0.0
            for r, k in assign.items():
                t = tgt.get(r)
                if t:
                    c += math.hypot(pts[k][0] - t[0], pts[k][1] - t[1])
            return c

        order = sorted(range(len(refs)), key=lambda i: -(1 if tgt[refs[i]] else 0))
        assign, used = {}, set()
        for i in order:
            r = refs[i]
            t = tgt.get(r)
            cand = sorted((k for k in range(len(pts)) if k not in used),
                          key=lambda k: (math.hypot(pts[k][0] - t[0], pts[k][1] - t[1])
                                         if t else k))
            assign[r] = cand[0]
            used.add(cand[0])
        improved = True
        while improved:
            improved = False
            for a in range(len(refs)):
                for b in range(a + 1, len(refs)):
                    ra, rb = refs[a], refs[b]
                    c0 = cost(assign)
                    assign[ra], assign[rb] = assign[rb], assign[ra]
                    if cost(assign) < c0 - 1e-9:
                        improved = True
                    else:
                        assign[ra], assign[rb] = assign[rb], assign[ra]
        for r, k in assign.items():
            if pos[r][:2] != pts[k]:
                moved += 1
            pos[r] = (pts[k][0], pts[k][1], pos[r][2])
    return moved


def grid_snap(pos, only=None):
    u"""把货架排布器摆的件各挪 ≤ ±0.125 mm，让焊盘尽量落在 **0.25 mm 布线网格**上。

    `router.py` 是 0.25 网格 A*，焊盘不在格点上就要先长一段**引出脚**；
    M6 欠的 5 只脚全是「出口被自家邻脚的引出脚封死」（方案 §26.6）。
    焊盘落到格点上，这一类堵塞就没有了。

    ⚠ 一个件只有一个 (dx, dy)：**只有焊盘间距是 0.25 的整数倍时才能全对齐**
      （0402 两脚共线 ⇒ 能对齐一只；QFN 0.5 ⇒ 整排都能；TSSOP 0.65 / BM24 0.4 ⇒ 不能）。
      判据是「对齐数变多」，不是「全对齐」。

    ⛔ 手排件（功率链 `STACK_*` / `HAND`）和机械锚定件不许动：
      前者的净距是按 §7.2 的回路算死的（Cin 堆只有 0.65），两件相向挪 0.125 就破 0.6 的装配下限；
      后者的位置是小米8 主板定的。
    """
    if not os.path.exists(SNAP_JSON):
        return 0
    offs = json.load(io.open(SNAP_JSON, encoding='utf-8'))
    n = 0
    for ref, po in offs.items():
        if ref not in pos or (only is not None and ref not in only):
            continue
        x, y, r = pos[ref]

        def best(vals):
            bd, bs = 0.0, None
            for k in range(-125, 126):
                d = k / 1000.0
                sc = sum(abs((v + d) / GRID - round((v + d) / GRID)) for v in vals)
                if bs is None or sc < bs - 1e-9:
                    bd, bs = d, sc
            return bd

        dx = best([x + o[0] for o in po])
        dy = best([y + o[1] for o in po])
        if dx or dy:
            pos[ref] = (round(x + dx, 3), round(y + dy, 3), r)
            n += 1
    return n


def snap_conflicts(pos, sz):
    u"""网格微调之后，哪些件把净距挤到了 `GAP` 以下 —— 这些退回原位。

    ⛔ 不能一刀切「手排件不许动」：`U2` / `U1` 这些 0.5 间距的 QFN 恰恰**最需要**
      落在格点上。也不能一刀切「都动」：Cin 堆的缝只有 0.65，两件相向挪 0.125 就破 0.6。
      ⇒ 挪完再算一遍，只把真挤到的退回去。
    """
    bad = set()
    items = sorted(pos.items())
    rect = {}
    for ref, (x, y, r) in items:
        w, h = wh(ref, r, sz)
        rect[ref] = (x - w / 2, y - h / 2, x + w / 2, y + h / 2)
    for i in range(len(items)):
        for j in range(i + 1, len(items)):
            a, b = items[i][0], items[j][0]
            ra, rb = rect[a], rect[b]
            dx = max(ra[0] - rb[2], rb[0] - ra[2])
            dy = max(ra[1] - rb[3], rb[1] - ra[3])
            if dx < GAP and dy < GAP and (dx < 0 or dy < 0 or True):
                if max(dx, dy) < GAP:
                    bad.add(a)
                    bad.add(b)
    return bad


def bands():
    u"""每个组占的 y 带 —— L3 切铜面按这个来，别手抄坐标。"""
    pos, _r, _u, sz = plan()
    out = []
    for region, name, refs in GROUPS:
        ys = [(pos[r][1] - wh(r, pos[r][2], sz)[1] / 2,
               pos[r][1] + wh(r, pos[r][2], sz)[1] / 2) for r in refs if r in pos]
        if ys:
            out.append((region, name, round(min(a for a, _ in ys), 2),
                        round(max(b for _, b in ys), 2)))
    return out


def selfcheck(pos, rects, unplaced, sz):
    bad = []
    if unplaced:
        bad.append(u'放不下: %s' % ', '.join(u'%s(%s)' % t for t in unplaced))
    d = json.load(io.open(BBOX, encoding='utf-8'))
    missing = sorted(set(d) - set(pos))
    if missing:
        bad.append(u'没安排位置: %s' % ' '.join(missing))
    bot = set(bottom_refs(pos))
    # 重叠。⚠ K1~K4 例外：四个盘的位置是**主板定的**（实测最小间距 1.78 mm、
    #   盘 Ø1.5 ⇒ 净距 0.28），通用的 GAP=0.6 会把它们互判成重叠。
    #   它们之间改按「铜净距 ≥ 0.2」单独校核。
    # ⚠ **只判同一面**：A 面的 J4/J5/C60 和 B 面的 USB/阻尼组是**故意重叠**的
    #   （正背面），跨面判重叠会把这一版的核心设计意图全报成错。
    import math
    keys = ['K1', 'K2', 'K3', 'K4']
    rmap = {}
    for ref in pos:
        if ref in keys:
            continue
        x, y, rr = pos[ref]
        w, h = wh(ref, rr, sz)
        rmap[ref] = (x - w / 2 - GAP / 2, y - h / 2 - GAP / 2,
                     x + w / 2 + GAP / 2, y + h / 2 + GAP / 2)
    rl = sorted(rmap.items())
    for i in range(len(rl)):
        for j in range(i + 1, len(rl)):
            if (rl[i][0] in bot) != (rl[j][0] in bot):
                continue
            a, b = rl[i][1], rl[j][1]
            if a[0] < b[2] - 1e-6 and b[0] < a[2] - 1e-6 and \
               a[1] < b[3] - 1e-6 and b[1] < a[3] - 1e-6:
                bad.append(u'%s 和 %s 重叠' % (rl[i][0], rl[j][0]))
    PAD_D = 1.5
    for i in range(len(keys)):
        for j in range(i + 1, len(keys)):
            ax, ay, _ = pos[keys[i]]
            bx, by, _ = pos[keys[j]]
            gap = math.hypot(ax - bx, ay - by) - PAD_D
            if gap < 0.2:
                bad.append(u'%s/%s 铜净距 %.2f < 0.2' % (keys[i], keys[j], gap))
    # 全部在板内
    for ref, (x, y, rr) in pos.items():
        w, h = wh(ref, rr, sz)
        if ref == 'J1':
            continue
        if x - w / 2 < 0.5 or x + w / 2 > B.BW - 0.5 or \
           y - h / 2 < 0.5 or y + h / 2 > B.BH - 0.5:
            bad.append(u'%s 出板框: (%.2f,%.2f) %.1fx%.1f' % (ref, x, y, w, h))
    # 金手指区（y<11）除 J1 外一件不许有 —— 两面都是（插槽体夹住的是整块板）
    for ref, (x, y, rr) in pos.items():
        if ref == 'J1':
            continue
        if y - wh(ref, rr, sz)[1] / 2 < 11.0:
            bad.append(u'%s 侵入金手指区（y=%.2f，插槽体要 ~9 mm）' % (ref, y))
    # ⛔ 铣穿的排线槽：**两面都不许有件**（摆进去等于摆在空气里）；
    #    B 面的排线车道也一件不放（排线要平贴着走到连接器）。
    for ref, (x, y, rr) in pos.items():
        w, h = wh(ref, rr, sz)
        for (a, b, c, d2) in B.mill_cuts():
            if x + w / 2 > a - MILL_KEEP and x - w / 2 < c + MILL_KEEP and \
               y + h / 2 > b - MILL_KEEP and y - h / 2 < d2 + MILL_KEEP:
                bad.append(u'%s 落进铣穿的排线槽（那里没有板子）' % ref)
                break
        if ref in bot and ref not in ('J4', 'J5'):
            for k, (a, b, c, d2) in lanes().items():
                if x + w / 2 > a and x - w / 2 < c and y + h / 2 > b and y - h / 2 < d2:
                    bad.append(u'%s 压在 %s 排线车道上' % (ref, k))
                    break
    # A 面的手机投影里只许 K1~K4（螺柱间隙只有 1.0 mm）。
    # ⚠ **B 面不受这一条约束** —— 这正是这一版把器件翻过去的原因。
    px0, py0 = PHONE_ORG
    px1, py1 = px0 + PHONE_WH[0], py0 + PHONE_WH[1]
    for ref, (x, y, rr) in pos.items():
        if ref.startswith('K') or ref in bot:
            continue
        w, h = wh(ref, rr, sz)
        if x + w / 2 > px0 and x - w / 2 < px1 and y + h / 2 > py0 and y - h / 2 < py1:
            bad.append(u'%s 在 A 面落进手机投影（螺柱间隙只有 1.0 mm）' % ref)
    # ⛔ B 面高度预算分两段（模块头的表）。超高件进手机投影会顶到隔壁槽的手机主板，
    #    而这件事几何自检和 DRC **一条都不报**。
    for ref, hh in HEIGHT.items():
        if ref not in bot:
            continue
        x, y, rr = pos[ref]
        w, h = wh(ref, rr, sz)
        in_phone = y + h / 2 > py0 and x + w / 2 > px0 and x - w / 2 < px1
        lim = H_B_PHONE if in_phone else H_B_SVC
        if hh > lim:
            bad.append(u'%s 高 %.1f mm 放在 B 面%s（净空只有 %.1f）'
                       % (ref, hh, u'手机投影下' if in_phone else u'服务带', lim))
    # ⛔ 螺钉头避让：任何元件离主板定位孔中心都要 >= HOLE_KEEP。
    #    M4c 第一版把这七个孔整个忘了 —— 高度预算和 K1~K4 的接触压力全靠它们。
    #    ⚠ 两面都要让：螺钉过孔是 NPTH，头在 B 面、尼龙立柱在 A 面。
    for hname, (hx, hy) in B.phone_holes().items():
        for ref, (x, y, rr) in pos.items():
            w, h = wh(ref, rr, sz)
            dx = max(abs(hx - x) - w / 2.0, 0.0)
            dy = max(abs(hy - y) - h / 2.0, 0.0)
            if math.hypot(dx, dy) < B.HOLE_KEEP:
                bad.append(u'%s 离定位孔 %s 只有 %.2f < %.1f（螺钉头压上去）'
                           % (ref, hname, math.hypot(dx, dy), B.HOLE_KEEP))
    # C60 不许在手机底下（已由上一条覆盖），另外校核它确实在服务带/功率列
    cx, cy, _ = pos['C60']
    if not (B.ZONES['finger'][3] - 1e-9 <= cy - BODY['C60'][1] / 2
            and cy + BODY['C60'][1] / 2 <= B.PHONE_ORG[1] + 1e-9):
        bad.append(u'C60 不在服务带里（B 面只有服务带有 18.7 的净空）')
    return bad


OPEN_JS = (u"await eda.dmt_EditorControl.openDocument('%s');"
           u"await new Promise(r=>setTimeout(r,2500));")

# ⚠ **必须分批**：桥接服务端的单请求上限是**硬编码的 30 s**
#   （`bridge-server.mjs` 的 `REQUEST_TIMEOUT_MS`，客户端 `timeout=` 调不动它）。
#   83 件 × 2 次 modify 一口气发过去必超时，而且**超时不等于没执行** ——
#   客户端还在跑，只是结果回不来，于是「读回校验」会看到做了一半。
PUSH_JS = u"""
const MIL = %s, P = %s, BOT = %s, ONLY = %s;
const bot = new Set(BOT), only = new Set(ONLY);
let n = 0, miss = [];
for (const c of await eda.pcb_PrimitiveComponent.getAll()) {
  const d = c.designator;
  if (!only.has(d)) continue;
  if (!P[d]) { miss.push(d); continue; }
  const id = c.getState_PrimitiveId();
  await eda.pcb_PrimitiveComponent.modify(id, {layer: bot.has(d) ? 2 : 1});
  await eda.pcb_PrimitiveComponent.modify(id,
      {x: P[d][0]*MIL, y: P[d][1]*MIL, rotation: P[d][2]});
  n++;
}
await eda.pcb_Document.save();
return {n, miss};
"""

BATCH = 12


def push(pos):
    r = run(OPEN_JS % PCB + 'return 1;', timeout=120)
    if not r.get('success'):
        sys.exit(json.dumps(r, ensure_ascii=False)[:600])
    bot = json.dumps(bottom_refs(pos))
    refs = sorted(pos)
    done, miss = 0, []
    for k in range(0, len(refs), BATCH):
        chunk = refs[k:k + BATCH]
        r = run(PUSH_JS % (MIL, json.dumps(pos), bot, json.dumps(chunk)), timeout=120)
        if not r.get('success'):
            sys.exit(json.dumps(r, ensure_ascii=False)[:600])
        done += r['result']['n']
        miss += r['result']['miss']
        print(u'   %d/%d' % (done, len(refs)))
    print(u'已摆 %d 件；没找到位置的: %s' % (done, miss or u'无'))


def verify(pos, sz):
    r = run("await eda.dmt_EditorControl.openDocument('%s');"
            "await new Promise(r=>setTimeout(r,2000));"
            "return (await eda.pcb_PrimitiveComponent.getAll()).map("
            "  c=>[c.designator, c.x, c.y, c.rotation, c.layer]);" % PCB, timeout=300)
    if not r.get('success'):
        sys.exit(json.dumps(r, ensure_ascii=False)[:600])
    got = {a[0]: (a[1] / MIL, a[2] / MIL, a[3], a[4]) for a in r['result']}
    bot = set(bottom_refs(pos))
    bad = []
    for ref, (x, y, rot) in pos.items():
        if ref not in got:
            bad.append(u'板上没有 %s' % ref)
            continue
        gx, gy, grot, glay = got[ref]
        if abs(gx - x) > 0.02 or abs(gy - y) > 0.02:
            bad.append(u'%s 在 (%.2f,%.2f)，应为 (%.2f,%.2f)' % (ref, gx, gy, x, y))
        want_lay = 2 if ref in bot else 1
        if glay != want_lay:
            bad.append(u'%s 在 layer %s，应为 %s' % (ref, glay, want_lay))
    print(u'读回 %d 件（A 面 %d / B 面 %d）'
          % (len(got), sum(1 for v in got.values() if v[3] == 1),
             sum(1 for v in got.values() if v[3] == 2)))
    if bad:
        print(u'[X] %d 条不过:' % len(bad))
        for b in bad[:20]:
            print(u'   ' + b)
    else:
        print(u'[OK] %d 件位置 / 层 全部对上' % len(got))
    return bad


if __name__ == '__main__':
    pos, rects, unplaced, sz = plan()
    bad = selfcheck(pos, rects, unplaced, sz)
    bot = set(bottom_refs(pos))
    print(u'安排了 %d 件（含 J1）：A 面 %d / B 面 %d'
          % (len(pos), len(pos) - len(bot), len(bot)))
    for region, name, refs in GROUPS:
        xs = [pos[r] for r in refs if r in pos]
        if xs:
            print(u'  %-11s %-24s x %5.1f~%5.1f  y %5.1f~%5.1f  %d 件'
                  % (region, name, min(p[0] for p in xs), max(p[0] for p in xs),
                     min(p[1] for p in xs), max(p[1] for p in xs), len(xs)))
    print(u'  A 面留守: ' + '  '.join(u'%s(%.1f,%.1f)' % (k, pos[k][0], pos[k][1])
                                      for k in TOP_ONLY))
    if bad:
        print(u'[X] 自检不过 (%d):' % len(bad))
        for b in bad[:20]:
            print(u'   ' + b)
        if '--push' in sys.argv:
            sys.exit(1)
    else:
        print(u'[OK] 自检通过：同面无重叠 / 全在板内 / 金手指区干净 / 槽与车道内无件 /'
              u' A 面只有 K1~K4 / B 面高度分段达标 / 七个螺钉头都让开了')
    if '--push' in sys.argv:
        push(pos)
        verify(pos, sz)
    elif '--verify' in sys.argv:
        verify(pos, sz)