# -*- coding: utf-8 -*-
u"""R2 刀片 PCB 的铺铜（M4c-3）。

    /c/Python314/python .claude/r2/pcb_pour.py            # 只算 + 自检
    /c/Python314/python .claude/r2/pcb_pour.py --push     # 清旧铜面 + 重建 + 重填
    /c/Python314/python .claude/r2/pcb_pour.py --rebuild  # 只重填（铜面没改，只是扇出/布线改了）

## 叠层（方案 §7.1）

| 设计 | EasyEDA | id | 内容 |
|---|---|---|---|
| L1 | Top Layer  |  1 | 功率 + 信号；**D± 走这层、以 L2 为参考** |
| L2 | Inner1     | 15 | **完整地平面，不许割断** |
| L3 | Inner2     | 16 | `VO_P` 岛 + `+12V` 岛，其余 GND 底填 |
| L4 | Bottom     |  2 | 控制信号 + GND 底填 |

## 三个只有这块板才有的约束

1. **金手指区不许铺外层铜**：`J1` 的 64 个指是 L1/L2 上的焊盘，间距只有 0.3 mm。
   外层铜面一旦下探到 y < 指顶(5.6)+间距，就会把相邻的指连起来 —— 而且**是不是短路
   要看它连到哪两根**，DRC 只报间距不报「这两根本来就该分开」。
   ⇒ 外层铜面一律 `y >= TOP_POUR_Y`（11.5，比缺口顶 7.45 还高一截）。
   内层（L2/L3）没有指，可以一直铺到板边内缩，只要避开缺口。

2. **缺口要挖掉**：防呆缺口是真的铣穿的，四层都要让开（含 0.5 mm 内缩）。

3. **优先级是「数字小的先铺、先占地盘」**（R1 `pcb_pour.py` 头上那条已经查清的翻案）。
   ⇒ `VO_P` / `+12V` 两个岛给 1 / 2，GND 底填给 9。

## 三个 API 坑（全部照抄 R1 `pcb_pour.py` 的结论，别再踩一遍）

· 多边形**必须显式闭合**（末尾把首点再写一遍），否则 `create()` 一块都不建；
· `create()` **抛异常不等于失败** —— 判据只能是建完 `getAll()` 按名字（会被转成大写）核对；
· `rebuildCopperRegion()` 是坏的，**只能走 GUI**：工具 → 铺铜管理器... → 重建所有 → 确认。
  判据是 `pcb_PrimitivePoured` 的数量，不是 `pcb_PrimitivePour`。
"""
import json
import math
import os
import sys
import time

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
import fp_edge                                                   # noqa: E402

PCB = B.PCB
MIL = B.MIL
L_TOP, L_GND, L_PWR, L_BOT = 1, 15, 16, 2

INSET = 0.5                      # 铜面离板边
TOP_POUR_Y = 11.5                # 外层铜面的下沿（金手指区一点外层铜都不许有）
# ⛔ 2026-09-12：板框开了台阶（`pcb_blade.STEP_H` / `TONGUE_X0/X1`）之后，**舌头两侧根本没有板材**
#    ⇒ 那两段的铜下沿必须抬到 `STEP_H + INSET`，否则铜会悬在被切掉的地方。
#    舌头那一段仍按 TOP_POUR_Y / INSET 走（外层不进金手指区、内层绕缺口）。
STEP_POUR_Y = round(B.STEP_H + INSET, 3)
NOTCH_KEEP = 0.5                 # 缺口周围再让 0.5

# L3 两个岛（x0, y0, x1, y1）
# ⛔⛔ 2026-09-11 晚（方案 §35）：主板转 180°、功率链转 180° ⇒ 两个岛上下对调。
#   · `VO_P` 岛在**上半**：功率链顶上的 Rs1 / U3 → 西去 J5 / 阻尼组 / DIS → 两槽之间的 C60。
#     电池槽是铣穿的，岛做成**绕开电池槽的 U 形单环**（三块矩形拼，`VO_RECTS`），不用带洞多边形。
#   · `+12V` 岛在**下半**：金手指 12V 三指的 launch 孔（x 28.5~30.5, y 11.75）→ 东去 F1 的 +12V 脚（功率链最底）。
#     12V 从此**不在 L1 / L4 上走线**（原来那根 L4 x≈42.5 的竖线把整块板东西切成两半）。
#     下沿 9.0：金手指地母线的孔在 y 7.0 / 8.2，孔 + 净距到 8.8；上沿 20：信号 launch 孔在 y 11.75 一字排开
#     （1 mm 一个，反焊盘把 11.25~12.25 那一条几乎切断），电流要从它上面 8 mm 宽的那条过。
VO_Y0 = 38.0                       # 岛主体下沿（DIS / 阻尼组最南到 ~39.8）
VO_TOP_Y = round(B.SLOT_Y[0] - 0.56, 3)   # 主体上沿：离电池槽底 0.56（槽边到铜 ≥ 0.5）
_bat = B.flex_slots()['BAT']
VO_RECTS = [
    (26.0, VO_Y0, B.BW - 0.5, VO_TOP_Y),                         # 主体：J5 / 阻尼组 / DIS / U2 以北
    (25.6, VO_TOP_Y, round(_bat[0] - 0.56, 3), B.BH - 0.5),      # 两槽之间往上：C60
    (round(_bat[2] + 0.56, 3), VO_TOP_Y, B.BW - 0.5, B.BH - 0.5),  # 电池槽以东往上：Rs1 / U3 / C13
]
VO_ISLAND, VO_LOBE = VO_RECTS[0], VO_RECTS[1]     # 老名字留给别的脚本（board_check 等）
# ⛔ 2026-09-12 台阶之后改成**阶梯形**：舌头那一段（x TONGUE_X0~TONGUE_X1）仍下探到 9.0 去接
#    12V 三指的 launch 孔（x 28.5~30.5 / y 11.75，全在舌头内）；舌头以东那一段抬到 STEP_POUR_Y
#    —— 那边的板材已经被台阶铣掉了。断面：东段由 11.0 收到 7.5 mm 宽（1 oz 内层，1.5 A 峰值远够）。
# ⛔ 2026-09-12 晚：x0 原来写死 27.0（= 当时的 TONGUE_X0）。舌头一改（36.0 → 34.5）
#    `v12_poly()` 里的 `assert x0 >= B.TONGUE_X0` 就会失败。**改成直接跟着舌头走**，
#    从此不会再因为舌头变动而漏改这一处。12V 三指的 launch 孔在 x 28.5~30.5，
#    比任何合理的 TONGUE_X0 都靠内，覆盖不受影响。
V12_ISLAND = (B.TONGUE_X0, 9.0, 84.0, 20.0)   # 老名字留着（board_check 等按它取包围盒）
V12_LOW_Y, V12_TOP_Y = 9.0, 20.0


def mil(v):
    return round(v * MIL, 4)


def rrect(x0, y0, x1, y1, r=0.0, seg=8):
    u"""圆角矩形点列（逆时针，闭合）。r=0 就是普通矩形。"""
    if r <= 0:
        pts = [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]
    else:
        pts = []
        for cx, cy, a0 in ((x1 - r, y0 + r, 270), (x1 - r, y1 - r, 0),
                           (x0 + r, y1 - r, 90), (x0 + r, y0 + r, 180)):
            for k in range(seg + 1):
                a = math.radians(a0 + 90.0 * k / seg)
                pts.append((cx + r * math.cos(a), cy + r * math.sin(a)))
    out = [pts[0]]
    for p in pts[1:]:
        if abs(p[0] - out[-1][0]) > 1e-9 or abs(p[1] - out[-1][1]) > 1e-9:
            out.append(p)
    out.append(out[0])                       # ⚠ 必须显式闭合
    return out


def notch_cut():
    u"""缺口在铜面里要挖掉的矩形（含让位）。"""
    ml, mr = B.notch_break()
    return (ml - NOTCH_KEEP, -1.0, mr + NOTCH_KEEP, fp_edge.NOTCH_D + NOTCH_KEEP)


def inner_poly():
    u"""内层铜面：板框内缩 INSET，底边在缺口处绕过去（一条闭合折线，不用挖孔）。"""
    d = INSET
    r = B.CORNER_R - d
    x0, y0, x1, y1 = d, d, B.BW - d, B.BH - d
    nx0, _ny0, nx1, ny1 = notch_cut()
    pts = [(nx1, y0)]                                     # 缺口右侧起步，沿底边往右
    pts.append((x1 - r, y0))
    for cx, cy, a0 in ((x1 - r, y0 + r, 270), (x1 - r, y1 - r, 0),
                       (x0 + r, y1 - r, 90), (x0 + r, y0 + r, 180)):
        for k in range(9):
            a = math.radians(a0 + 90.0 * k / 8)
            pts.append((cx + r * math.cos(a), cy + r * math.sin(a)))
    pts.append((nx0, y0))                                 # 底边左段走到缺口左沿
    pts.append((nx0, ny1))                                # 绕缺口
    pts.append((nx1, ny1))
    out = [pts[0]]
    for p in pts[1:]:
        if abs(p[0] - out[-1][0]) > 1e-9 or abs(p[1] - out[-1][1]) > 1e-9:
            out.append(p)
    out.append(out[0])
    return out


def outer_poly():
    u"""外层铜面：只在 y >= TOP_POUR_Y 的部分，金手指区一点铜都没有。"""
    d = INSET
    r = B.CORNER_R - d
    x0, x1, y1 = d, B.BW - d, B.BH - d
    pts = [(x0, TOP_POUR_Y), (x1, TOP_POUR_Y)]
    for cx, cy, a0 in ((x1 - r, y1 - r, 0), (x0 + r, y1 - r, 90)):
        for k in range(9):
            a = math.radians(a0 + 90.0 * k / 8)
            pts.append((cx + r * math.cos(a), cy + r * math.sin(a)))
    out = [pts[0]]
    for p in pts[1:]:
        if abs(p[0] - out[-1][0]) > 1e-9 or abs(p[1] - out[-1][1]) > 1e-9:
            out.append(p)
    out.append(out[0])
    return out


def src(pts):
    u"""点列 -> TPCB_PolygonSourceArray（mil）: x1 y1 'L' x2 y2 'L' ..."""
    a = [mil(pts[0][0]), mil(pts[0][1])]
    for p in pts[1:]:
        a += ['L', mil(p[0]), mil(p[1])]
    return a


def gnd_tiles(y_lo):
    u"""地铜的**若干块单环矩形**，绕开铣穿的排线槽。

    ⛔ **不能用带洞的复杂多边形**：`pcb_MathPolygon.createComplexPolygon()` 传多个环时
       会把客户端挂死 —— 请求 30 s 超时、铺铜边框停在半路、进度恒为 0/0，
       和「GUI 按钮失灵」完全无法区分（2026-09-08 在这上面绕了很久）。
       ⇒ 一律单环。要挖洞就拆成几块矩形拼，铜面之间同网互相接壤会自然连成一片。

    做法：按所有槽的 x 边把板切成竖条，每条里按 y 找槽之间的空隙。
    （2026-09-09 改：原来的「上下横带」写法假设各窗 y 区间不重叠，两条并排的排线槽
      会把槽本身当成一条带铺进去。）
    `y_lo` = 这一层铜面的下沿（外层 11.5 / 内层 0.5）。
    """
    d = INSET
    x0, x1 = d, B.BW - d
    y1 = B.BH - d
    cuts = [(a - INSET, b - INSET, c + INSET, e + INSET) for (a, b, c, e) in B.mill_cuts()]
    # ⛔ 台阶两端也是切分点：舌头外的竖条下沿要抬到 STEP_POUR_Y（那边没有板材）
    xs = sorted(set([x0, x1, B.TONGUE_X0, B.TONGUE_X1] + [v for c in cuts for v in (c[0], c[2])]))
    tiles = []
    for xa, xb in zip(xs, xs[1:]):
        if xb - xa < 0.6:
            continue
        in_tongue = (xa >= B.TONGUE_X0 - 1e-9 and xb <= B.TONGUE_X1 + 1e-9)
        ys = [y_lo if in_tongue else max(y_lo, STEP_POUR_Y)]
        for c in sorted(cuts, key=lambda c: c[1]):
            if c[0] < xb - 1e-9 and xa < c[2] - 1e-9:
                ys += [c[1], c[3]]
        ys.append(y1)
        for k in range(0, len(ys) - 1, 2):
            ya, yb = ys[k], ys[k + 1]
            if yb - ya > 0.6:
                tiles.append((xa, ya, xb, yb))
    # ⛔ 内层的下沿会盖住金手指的**防呆缺口**（铣穿的）。把缺口那一段单独让开：
    #    y 抬到缺口顶之上，再补两块把缺口左右两侧的底部填回来。
    nx0, _a, nx1, ny1 = notch_cut()
    if y_lo < ny1:
        cut = ny1
        out = []
        for (a, b, c, e) in tiles:
            if e <= cut:
                continue
            if b < cut and (a < nx1 and c > nx0):
                out.append((a, cut, c, e))
                if a < nx0:
                    out.append((a, b, nx0, cut))
                if c > nx1:
                    out.append((nx1, b, c, cut))
            else:
                out.append((a, b, c, e))
        tiles = [t for t in out if t[2] - t[0] > 0.6 and t[3] - t[1] > 0.6]
    return tiles


def v12_poly():
    u"""`+12V` 岛（L3）：**阶梯形单环**。舌头段下探到 V12_LOW_Y 接金手指的 launch 孔，
    舌头以东抬到 STEP_POUR_Y（板框台阶把那块板材铣掉了）。

    ⛔ 一律单环（带洞的复杂多边形会把客户端挂死，见 `gnd_tiles` 的说明）。"""
    x0, x1 = V12_ISLAND[0], V12_ISLAND[2]
    xt = B.TONGUE_X1
    assert x0 >= B.TONGUE_X0 and xt < x1, u'+12V 岛的阶梯点跑到舌头外了'
    pts = [(x0, V12_LOW_Y), (xt, V12_LOW_Y), (xt, STEP_POUR_Y), (x1, STEP_POUR_Y),
           (x1, V12_TOP_Y), (x0, V12_TOP_Y)]
    out = [pts[0]]
    for q in pts[1:]:
        if abs(q[0] - out[-1][0]) > 1e-9 or abs(q[1] - out[-1][1]) > 1e-9:
            out.append(q)
    out.append(out[0])
    return out


def vo_poly():
    u"""VO_P 岛：主体 + 两个上叶（夹着电池槽），拼成一个 U 形**单环**（逆时针，显式闭合）。

    2026-09-11 晚起（方案 §35）。上叶 w 骑在主体上沿、西沿可以比主体再往西一点（C60 的 VO_P 盘）。"""
    a, w, e = VO_RECTS
    assert abs(a[3] - w[1]) < 1e-9 and abs(a[3] - e[1]) < 1e-9 and e[2] == a[2] and w[2] < e[0], u'上叶必须骑在主体上沿'
    pts = [(a[0], a[1]), (a[2], a[1]), (e[2], e[3]), (e[0], e[3]), (e[0], a[3]),
           (w[2], a[3]), (w[2], w[3]), (w[0], w[3]), (w[0], a[3]), (a[0], a[3])]
    out = [pts[0]]
    for q in pts[1:]:
        if abs(q[0] - out[-1][0]) > 1e-9 or abs(q[1] - out[-1][1]) > 1e-9:
            out.append(q)
    out.append(out[0])
    return out


def plan():
    u"""[(name, net, layer, [环...], priority)]，priority 小的先铺、先占地盘。"""
    outs = []
    outs.append(('VO-L3', 'VO_P', L_PWR, [src(vo_poly())], 1))
    outs.append(('V12-L3', '+12V', L_PWR, [src(v12_poly())], 2))
    for tag, layer, y_lo in (('L2', L_GND, INSET), ('TOP', L_TOP, TOP_POUR_Y),
                             ('BOT', L_BOT, TOP_POUR_Y)):
        for k, (a, b, c, d2) in enumerate(gnd_tiles(y_lo)):
            outs.append(('GND-%s-%d' % (tag, k), 'GND', layer,
                         [src(rrect(a, b, c, d2))], 9))
    return outs


def _ring_pts(ring):
    u"""`src()` 生成的 [x, y, 'L', x, y, 'L', ...]（mil）还原成 [(x, y)] 点列（mm）。"""
    pts = [(float(ring[0]) / MIL, float(ring[1]) / MIL)]
    for k in range(3, len(ring), 3):
        pts.append((float(ring[k]) / MIL, float(ring[k + 1]) / MIL))
    return pts


def selfcheck(ps):
    bad = []
    for name, _net, _lay, rings, _p in ps:
        for k, s in enumerate(rings):
            if s[0] != s[-2] or s[1] != s[-1]:
                bad.append(u'%s 第 %d 个环没闭合' % (name, k))
    # 外层铜面不许下探进金手指区
    top = fp_edge.EDGE_CLR + fp_edge.LONG_L
    if TOP_POUR_Y <= top:
        bad.append(u'外层铜下沿 %.2f 压到指顶 %.2f' % (TOP_POUR_Y, top))
    if TOP_POUR_Y <= fp_edge.NOTCH_D:
        bad.append(u'外层铜下沿 %.2f 低于缺口顶 %.2f' % (TOP_POUR_Y, fp_edge.NOTCH_D))
    # ⛔ 台阶：舌头两侧不许有任何铜低于 STEP_POUR_Y（那块板材已经铣掉了）。
    #    ⚠ 判据必须**逐边**走，不能按整个环的包围盒判：`+12V` 岛是阶梯形，
    #      它的 y=9.0 那一段只在舌头内，按包围盒（min y 9.0 且 max x 84）会误报。
    for name, _net, _lay, rings, _p in ps:
        for ring in rings:
            pts = _ring_pts(ring)
            worst = None
            for (ax, ay), (bx, by) in zip(pts, pts[1:]):
                n = max(2, int(math.hypot(bx - ax, by - ay) / 0.25) + 1)
                for i in range(n + 1):
                    t = i / float(n)
                    x, y = ax + (bx - ax) * t, ay + (by - ay) * t
                    if y < STEP_POUR_Y - 1e-6 and (x < B.TONGUE_X0 - 1e-6 or x > B.TONGUE_X1 + 1e-6):
                        if worst is None or y < worst[1]:
                            worst = (x, y)
            if worst:
                bad.append(u'%s 伸进台阶切掉的区域（最深处 x %.2f / y %.2f < %.2f）'
                           % (name, worst[0], worst[1], STEP_POUR_Y))
    # 内层铜面必须绕开缺口
    nx0, _a, nx1, ny1 = notch_cut()
    if nx1 - nx0 < fp_edge.NOTCH_W + 2 * fp_edge.LEAD_IN:
        bad.append(u'缺口挖得比口部还窄')
    # 两个岛不许互相重叠（同层，优先级只有 1/2 之差，重叠就说不清谁裁谁）
    b = V12_ISLAND
    for a in VO_RECTS:
        if a[0] < b[2] and b[0] < a[2] and a[1] < b[3] and b[1] < a[3]:
            bad.append(u'VO 岛和 +12V 岛在 L3 上重叠')
    # 岛不许压到铣穿的槽（含 0.5 净距）—— 客户端会自己让，但让出来的形状谁也没核过
    for (x0, y0, x1, y1) in B.mill_cuts():
        for a in VO_RECTS + [b]:
            if a[0] < x1 + 0.5 and x0 - 0.5 < a[2] and a[1] < y1 + 0.5 and y0 - 0.5 < a[3]:
                bad.append(u'L3 岛 %s 压到槽 (%.1f~%.1f, %.1f~%.1f)' % (a, x0, x1, y0, y1))
    return bad


OPEN = ("await eda.dmt_EditorControl.openDocument('%s');"
        "await new Promise(r=>setTimeout(r,2000));" % PCB)

JS_DEL = OPEN + u"""
let n = 0;
for (const old of await eda.pcb_PrimitivePour.getAll()) {
  await eda.pcb_PrimitivePour.delete(old.primitiveId); n++; }
return {deleted: n};
"""

JS_MAKE = OPEN + u"""
const PLAN = %s;
for (const p of PLAN) {
  const poly = await eda.pcb_MathPolygon.createComplexPolygon(p.src);
  if (!poly) continue;
  try { await eda.pcb_PrimitivePour.create(p.net, p.layer, poly, 'solid', false,
                                           p.name, p.prio, 10); } catch (e) {}
}
return {made: (await eda.pcb_PrimitivePour.getAll())
                .map(x => String(x.pourName || '').toUpperCase())};
"""

JS_PRIO = OPEN + u"""
const P = %s;
let k = 0;
for (const o of await eda.pcb_PrimitivePour.getAll()) {
  const want = P[String(o.pourName || '').toUpperCase()];
  if (want === undefined) continue;
  try { await eda.pcb_PrimitivePour.modify(o.primitiveId, {pourPriority: want}); k++; }
  catch (e) {}
}
return {set: k, now: (await eda.pcb_PrimitivePour.getAll())
          .map(o => [String(o.pourName||''), o.pourPriority])};
"""

JS_REBUILD = OPEN + u"""
const sleep = ms => new Promise(r => setTimeout(r, ms));
const propsOf = el => { for (const k of Object.keys(el)) if (k.startsWith('__reactProps$')) return el[k]; return null; };
const fire = (el) => { let t = el; for (let i=0;i<8&&t;i++){const q=propsOf(t);
  if(q&&typeof q.onClick==='function'){q.onClick({target:t,currentTarget:t,stopPropagation(){},preventDefault(){},nativeEvent:{},button:0,detail:1});return true;} t=t.parentElement;} return false; };
const leaf = (txt) => { for (const el of document.querySelectorAll('*'))
  if (el.children.length===0 && (el.textContent||'').trim()===txt) return el; return null; };
const btn = (txt) => { for (const b of document.querySelectorAll('button'))
  if ((b.innerText||'').trim()===txt && b.offsetParent!==null) return b; return null; };
if (!fire(leaf('工具'))) return {err: 'no 工具'};
await sleep(900);
if (!fire(leaf('铺铜管理器...'))) return {err: 'no 铺铜管理器'};
await sleep(2500);
const b = btn('重建所有');
if (!b) return {err: 'no 重建所有'};
return {fired: fire(b)};
"""

JS_POLL = u"return {poured: (await eda.pcb_PrimitivePoured.getAll()).length};"

JS_DONE = u"""
const propsOf = el => { for (const k of Object.keys(el)) if (k.startsWith('__reactProps$')) return el[k]; return null; };
const fire = (el) => { let t = el; for (let i=0;i<8&&t;i++){const q=propsOf(t);
  if(q&&typeof q.onClick==='function'){q.onClick({target:t,currentTarget:t,stopPropagation(){},preventDefault(){},nativeEvent:{},button:0,detail:1});return true;} t=t.parentElement;} return false; };
let ok = null;
for (const b of document.querySelectorAll('button'))
  if ((b.innerText||'').trim()==='确认' && b.offsetParent!==null) { ok = b; break; }
if (ok) fire(ok);
await new Promise(r => setTimeout(r, 1500));
await eda.pcb_Document.save();
return {poured: (await eda.pcb_PrimitivePoured.getAll()).length,
        pour: (await eda.pcb_PrimitivePour.getAll()).length};
"""


def call(js, timeout=120):
    r = run(js, timeout=timeout)
    if not r.get('success'):
        print(u'失败: ' + json.dumps(r, ensure_ascii=False)[:600])
        sys.exit(1)
    return r['result']


def main():
    ps = plan()
    print(u'计划建 %d 块铜面：' % len(ps))
    for name, net, layer, rings, prio in ps:
        npt = sum((len(r) + 1) // 3 for r in rings)
        print(u'  %-8s net=%-6s layer=%-3d %d 环 / %3d 点  prio=%d'
              % (name, net, layer, len(rings), npt, prio))
    bad = selfcheck(ps)
    if bad:
        print(u'[X] 自检不过:')
        for b in bad:
            print(u'   ' + b)
        sys.exit(1)
    print(u'[OK] 自检通过：多边形全闭合 / 外层铜不进金手指区 / 内层绕开缺口 / 两岛不重叠')
    if '--push' not in sys.argv and '--rebuild' not in sys.argv:
        print(u'（未加 --push，没有下发）')
        return

    if '--rebuild' not in sys.argv:
        print(u'清掉旧铜面: %d 块' % call(JS_DEL)['deleted'])
        for k in range(0, len(ps), 3):                    # 3 块一批，稳在超时以内
            batch = [{'name': n, 'net': net, 'layer': l, 'src': s, 'prio': pr}
                     for n, net, l, s, pr in ps[k:k + 3]]
            made = call(JS_MAKE % json.dumps(batch), timeout=180)['made']
            print(u'  已建 %d 块' % len(made))
        want = {n.upper() for n, _, _, _, _ in ps}
        got = set(call("return (await eda.pcb_PrimitivePour.getAll())"
                       ".map(x=>String(x.pourName||'').toUpperCase());"))
        if not want <= got:
            print(u'[X] 没建上: %s' % (want - got))
            sys.exit(1)
        # ⚠ create() 的 pourPriority 参数不生效（R1 skill §9j），建完再逐块设
        r = call(JS_PRIO % json.dumps({n.upper(): pr for n, _, _, _, pr in ps}), timeout=180)
        print(u'  优先级已设 %d 块: %s' % (r['set'], r['now']))

    before = len(call("return (await eda.pcb_PrimitivePour.getAll()).map(o=>o.pourName);"))
    r = call(JS_REBUILD, timeout=120)
    if r.get('err'):
        print(u'[X] 打不开铺铜管理器: %s' % r['err'])
        sys.exit(1)
    # ⚠ 退出条件是「**数量稳定**」，不是「全部填上」。
    #   有的铜面本来就填不出来（`V12-L3` 在 `+12V` 还没有过孔扎进 L3 之前是孤岛，
    #   会被「移除孤岛」删掉），写成 `n >= len(ps)` 的话每次都要空转满 200 秒，
    #   而且看上去像是卡死。
    prev, same = -1, 0
    for _i in range(40):
        time.sleep(5)
        n = call(JS_POLL, timeout=60)['poured']
        print(u'  填充 %d / %d' % (n, len(ps)))
        if n >= len(ps):
            break
        same = same + 1 if n == prev else 0
        prev = n
        if same >= 2 and n > 0:
            print(u'  （%d 块已稳定，另 %d 块没有可接的铜，属正常）' % (n, len(ps) - n))
            break
    fin = call(JS_DONE, timeout=120)
    print(u'  收尾: %s' % fin)
    # ⛔ 铺铜**边框**会莫名其妙变少（实测 6→3、5→2）。哪一步删的还没查清，
    #    但「静默变少」是最坏的形态：铜面没了，DRC 只报连接性，看上去像布线没做完。
    #    这里把它变成硬报错。
    if fin['pour'] < before:
        print(u'  [X] 铺铜边框从 %d 变成 %d —— 有东西把它们删了，**不要在这个状态下导出**'
              % (before, fin['pour']))
        sys.exit(1)


if __name__ == '__main__':
    main()