@tachikomagundam/abathur 0.2.6 → 0.2.8

package/graders/pcb-agent/seed/tools/board_route.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""r17 deterministic 2-layer router (RM-56 doctrine; scripted A* lane).
+Reads placed .kicad_pcb (board_author_pcb output), routes a nearest-neighbour
+spanning tree per net on F.Cu/B.Cu, appends (segment)/(via), writes routed board.
+Grid 0.1mm; octile A*; per-layer flat occupancy dict (cell -> set(nets)).
+A cell is blocked for net N if occupied by nets other than N or 0.
+Gates afterwards: kicad DRC 0 errors + unconnected_items == 0 (board_gate_routed)."""
+import os
+import re, math, heapq, sys
+from collections import defaultdict
+
+GRID = float(os.environ.get('BR_GRID', '0.05'))
+CLEAR = 0.26
+POWER = {"VBUS", "5V_SERVO", "5V_LOGIC", "3V3", "GND", "SW_NODE", "+5V_IN"}
+W_POWER, W_SIG = 0.4, 0.25
+VIA_COST = 40
+MAX_PUSH = int(os.environ.get('BR_MAX_PUSH', '900000'))
+
+
+def footprint_blocks(txt):
+    return sub_blocks(txt, "footprint")
+
+
+def sub_blocks(s, token):
+    """full (token ...) blocks, balanced-paren + string-aware scan."""
+    out = []
+    i = 0
+    pat = "(" + token + " "
+    while True:
+        i = s.find(pat, i)
+        if i < 0:
+            return out
+        depth = 0
+        j = i
+        instr = False
+        while j < len(s):
+            ch = s[j]
+            if ch == '"' and (j == 0 or s[j - 1] != "\\"):
+                instr = not instr
+            elif not instr:
+                if ch == "(":
+                    depth += 1
+                elif ch == ")":
+                    depth -= 1
+                    if depth == 0:
+                        break
+            j += 1
+        out.append(s[i:j + 1])
+        i = j + 1
+
+
+def pads_of(txt):
+    pads = []
+    for block in footprint_blocks(txt):
+        fm = re.search(r'\(at ([-\d.]+) ([-\d.]+)(?: ([-\d.]+))?\)', block)
+        fx, fy, frot = (float(fm.group(1)), float(fm.group(2)), float(fm.group(3) or 0)) if fm else (0, 0, 0)
+        refm = re.search(r'\(property "Reference" "([^"]+)"', block)
+        ref = refm.group(1) if refm else "?"
+        for pb in sub_blocks(block, "pad"):
+            nm = re.search(r'\(net (\d+) "((?:[^"\\]|\\.)*)"\)', pb)
+            if not nm:
+                continue
+            pm2 = re.match(r'\(pad "([^"]*)"', pb)
+            at = re.search(r'\(at ([-\d.]+)(?: ([-\d.]+))?(?: ([-\d.]+))?\)', pb)
+            sz = re.search(r'\(size ([-\d.]+) ([-\d.]+)\)', pb)
+            px, py = (float(at.group(1)), float(at.group(2) or 0)) if at else (0, 0)
+            pr = float(at.group(3) or 0) if at else 0.0
+            w, h = (float(sz.group(1)), float(sz.group(2))) if sz else (1.0, 1.0)
+            a = math.radians(pr + frot)
+            gx = fx + px * math.cos(a) - py * math.sin(a)
+            gy = fy + px * math.sin(a) + py * math.cos(a)
+            pads.append(dict(ref=ref, pad=pm2.group(1) if pm2 else "?", net=int(nm.group(1)),
+                             netname=nm.group(2), x=gx, y=gy, w=w, h=h))
+    return pads
+
+
+class Occ:
+    def __init__(self):
+        self.m = [{}, {}]
+
+    def add_rect(self, x0, y0, x1, y1, l, net):
+        for cx in range(int(math.floor(x0 / GRID)), int(math.ceil(x1 / GRID)) + 1):
+            row = self.m[l]
+            for cy in range(int(math.floor(y0 / GRID)), int(math.ceil(y1 / GRID)) + 1):
+                s = row.get((cx, cy))
+                if s is None:
+                    row[(cx, cy)] = {net}
+                else:
+                    s.add(net)
+
+    def passable(self, l, cx, cy, net):
+        s = self.m[l].get((cx, cy))
+        return s is None or s == {0} or net in s
+
+
+def build_occ(pads):
+    occ = Occ()
+    for p in pads:
+        if str(p.get("num", p.get("pad", "1"))) == "":
+            # NPTH retention holes/screws: universal obstacle (no net may own
+            # copper in a hole's clearance annulus), sentinel -2 matches nothing.
+            hw, hh = p["w"] / 2 + 0.35, p["h"] / 2 + 0.35
+            for l in (0, 1):
+                occ.add_rect(p["x"] - hw, p["y"] - hh, p["x"] + hw, p["y"] + hh, l, -2)
+            continue
+        hw, hh = p["w"] / 2 + CLEAR, p["h"] / 2 + CLEAR
+        # cross-layer: KiCad enforces Cu-to-Cu clearance between tracks and pads
+        # on the OTHER copper layer too -> register every pad ring on BOTH layers.
+        for l in (0, 1):
+            occ.add_rect(p["x"] - hw, p["y"] - hh, p["x"] + hw, p["y"] + hh, l, p["net"])
+    # unmark pad interiors of the net's own footprint pads as free-to-stand target cells
+    return occ
+
+
+def cell(x, y):
+    return int(round(x / GRID)), int(round(y / GRID))
+
+
+def astar(occ, start, goal, net, via_cost=VIA_COST):
+    sx, sy = start[0]
+    sl = start[1]
+    gx, gy = goal[0]
+    gl = goal[1]
+    h0 = abs(sx - gx) + abs(sy - gy)
+    heap = [(h0, 0, sx, sy, sl)]
+    gsc = {(sx, sy, sl): 0}
+    came = {}
+    pushes = 0
+    while heap:
+        _, g, x, y, l = heapq.heappop(heap)
+        if x == gx and y == gy and l == gl:
+            path = [(x, y, l)]
+            while (x, y, l) in came:
+                x, y, l = came[(x, y, l)]
+                path.append((x, y, l))
+            return path[::-1]
+        pushes += 1
+        if pushes > MAX_PUSH:
+            return None
+        for dx, dy, dl, dc in ((1, 0, 0, 10), (-1, 0, 0, 10), (0, 1, 0, 10), (0, -1, 0, 10),
+                               (0, 0, 1, VIA_COST), (0, 0, -1, VIA_COST)):
+            nx, ny, nl = x + dx, y + dy, l + dl
+            if nl < 0 or nl > 1:
+                continue
+            if dx and dy:  # no diagonal corner cutting: both flanks must be open
+                if not (occ.passable(l, x + dx, y, net) and occ.passable(l, x, y + dy, net)):
+                    continue
+            if not occ.passable(nl, nx, ny, net):
+                continue
+            if dl:  # via may stand on its OWN pad (pinning) but never touch a
+                # foreign pad/box: cells whose net-set excludes us (or incl. the
+                # -7 gauntlet sentinel) are landing-banned.
+                bad = False
+                for ll in (0, 1):
+                    for m in (occ.m[ll], occ.m[1 - ll]):
+                        for ox in range(-3, 4):
+                            for oy in range(-3, 4):
+                                ss = m.get((nx + ox, ny + oy))
+                                if ss is None:
+                                    continue
+                                if -7 in ss or (net not in ss and ss != {0}):
+                                    bad = True
+                                    break
+                            if bad: break
+                        if bad: break
+                    if bad:
+                        break
+                if bad:
+                    continue
+            ng = g + (via_cost if dl else dc)
+            if ng < gsc.get((nx, ny, nl), 1e18):
+                gsc[(nx, ny, nl)] = ng
+                came[(nx, ny, nl)] = (x, y, l)
+                heapq.heappush(heap, (ng + abs(nx - gx) + abs(ny - gy) + (0 if nl == gl else VIA_COST), ng, nx, ny, nl))
+    return None
+
+
+def simplify(path):
+    if len(path) <= 2:
+        return path
+    out = [path[0]]
+    for i in range(1, len(path) - 1):
+        x0, y0, l0 = path[i - 1]
+        x1, y1, l1 = path[i]
+        x2, y2, l2 = path[i + 1]
+        if (x1 - x0, y1 - y0, l1 - l0) != (x2 - x1, y2 - y1, l2 - l1):
+            out.append(path[i])
+    out.append(path[-1])
+    return out
+
+
+def occ_track(occ, path, net, width):
+    """register a laid path (cells + clearance ring) into occupancy for OTHER nets."""
+    r = 2 if width < 0.35 else 3
+    for (cx, cy, l) in path:
+        for dx in range(-r, r + 1):
+            for dy in range(-r, r + 1):
+                occ.add_rect((cx + dx) * GRID, (cy + dy) * GRID,
+                             (cx + dx) * GRID, (cy + dy) * GRID, l, net)
+
+
+def route(board_path, out_path, only_nets=None):
+    txt = open(board_path).read()
+    pads = pads_of(txt)
+    nets = {int(m.group(1)): m.group(2) for m in re.finditer(r'\(net (\d+) "([^"]*)"\)', txt)}
+    occ = build_occ(pads)
+    # r17: J1 USB-C gauntlet — F.Cu inside the pad rows is forbidden (0.85mm pad
+    # pitch admits no 0.2mm pair); D+/D-, VBUS, CC and shield stubs are forced
+    # to B.Cu / the south channel. Sentinel net -7 closes the box to every net.
+    # (gauntlet experiment retired: foreign SMD pads only exist on their own
+    # layer's map — B.Cu threads between the J1 rows are clearance-legal.)
+    by_net = defaultdict(list)
+    for p in pads:
+        if p["net"]:
+            by_net[p["net"]].append(p)
+    # order: power/GND first, prefer bottom layer (B=1); signals then on F=0
+    def layer_pref(nid):
+        return 1 if nets.get(nid, "") in POWER else 0
+    ordered = sorted(by_net.items(), key=lambda kv: (nets.get(kv[0], "") not in POWER, -len(kv[1])))
+    segs, vias, fails = [], [], []
+    kept_segs = []
+    if only_nets:
+        fp_cut = txt.index("(footprint")
+        root_end = len(txt) - 1
+        tail_blocks = [m.group(0) for m in re.finditer(r'\(segment [^\n]*\)|\(via [^\n]*\)', txt[fp_cut:])]
+        newblocks = []
+        for blk in tail_blocks:
+            mn2 = re.search(r'\(net (\d+)\)', blk)
+            name2 = nets.get(int(mn2.group(1)), "") if mn2 else ""
+            if name2 in only_nets:
+                continue
+            newblocks.append(blk)
+            mm = re.search(r'\(segment \(start ([-\d.]+) ([-\d.]+)\) \(end ([-\d.]+) ([-\d.]+)\) \(width ([.\d]+)\) \(layer "([FB])\.Cu"\)', blk)
+            mv = re.search(r'\(via \(at ([-\d.]+) ([-\d.]+)', blk)
+            if mm:
+                x1_, y1_, x2_, y2_ = (float(mm.group(i)) for i in (2, 3, 4, 5))
+                w_ = float(mm.group(5)); l_ = 0 if mm.group(6) == "F" else 1
+                nn_ = max(1, int(max(abs(x2_ - x1_), abs(y2_ - y1_)) / GRID))
+                pts = [(cell(x1_ + (x2_ - x1_) * k / nn_, y1_ + (y2_ - y1_) * k / nn_)[0], cell(x1_ + (x2_ - x1_) * k / nn_, y1_ + (y2_ - y1_) * k / nn_)[1], l_) for k in range(nn_ + 1)]
+                occ_track(occ, pts, -1, w_)
+            elif mv:
+                vx, vy = float(mv.group(1)), float(mv.group(2))
+                for l_ in (0, 1):
+                    occ.add_rect(vx - 0.4, vy - 0.4, vx + 0.4, vy + 0.4, l_, -1)
+        kept_segs = newblocks
+        ordered = [kv for kv in ordered if nets.get(kv[0], "") in only_nets]
+        txt = txt[:fp_cut] + "\n".join(newblocks) + "\n)\n"
+    for nid, plist in ordered:
+        if len(plist) < 2:
+            continue
+        if nets.get(nid, "").startswith("NC"):
+            continue  # NC nets are floating-on-purpose groups: copper would
+                      # only weld foreign pads together inside connector gauntlets
+        width = W_POWER if nets.get(nid, "") in POWER else W_SIG
+        root = min(plist, key=lambda q: (q["x"], q["y"]))
+        remaining = [q for q in plist if q is not root]
+        tree = [root]
+        while remaining:
+            best = None
+            for a in tree:
+                for q in remaining:
+                    if a.get("ref") and q.get("ref") == a["ref"]:
+                        continue  # same-part pins bond internally: no copper
+                    dist = abs(q["x"] - a["x"]) + abs(q["y"] - a["y"])
+                    if best is None or dist < best[0]:
+                        best = (dist, q)
+            if best is None:
+                break
+            tree.append(best[1])
+            remaining.remove(best[1])
+        lp = layer_pref(nid)
+        for a, c in zip(tree, tree[1:]):
+            ca = cell(a["x"], a["y"])
+            cc = cell(c["x"], c["y"])
+            def ok_via_ends(pp):
+                if not pp:
+                    return False
+                a_ok = True if pp[0][2] == lp else (len(pp) > 1 and pp[1][2] != pp[0][2])
+                b_ok = True if pp[-1][2] == lp else (len(pp) > 1 and pp[-2][2] != pp[-1][2])
+                return a_ok and b_ok
+            cands = [astar(occ, (ca, lp), (cc, lp), nid),
+                     astar(occ, (ca, lp), (cc, 1 - lp), nid),
+                     astar(occ, (ca, 1 - lp), (cc, lp), nid)]
+            path = next((c for c in cands if ok_via_ends(c)), None)
+            if not path:
+                cands = [astar(occ, (ca, lp), (cc, lp), nid, via_cost=12),
+                         astar(occ, (ca, lp), (cc, 1 - lp), nid, via_cost=12)]
+                path = next((c for c in cands if ok_via_ends(c)), None)
+            if not path:
+                fails.append((nets.get(nid), a["ref"] + "." + a["pad"], c["ref"] + "." + c["pad"]))
+                continue
+            sp = simplify(path)
+            occ_track(occ, path, nid, width)
+            for n1, n2 in zip(sp, sp[1:]):
+                if n1[2] != n2[2]:
+                    vias.append((n1[0] * GRID, n1[1] * GRID, nid))
+                else:
+                    segs.append((n1[0] * GRID, n1[1] * GRID, n2[0] * GRID, n2[1] * GRID, n1[2], width, nid))
+    u = [0x5A000000]
+    def U():
+        u[0] += 1
+        x = f"{u[0]:032x}"
+        return f"{x[:8]}-{x[8:12]}-{x[12:16]}-{x[16:20]}-{x[20:32]}"
+    emit = []
+    for (x1, y1, x2, y2, l, w, n) in segs:
+        emit.append(f'  (segment (start {x1:.4f} {y1:.4f}) (end {x2:.4f} {y2:.4f}) (width {w})'
+                    f' (layer "{"F" if l==0 else "B"}.Cu") (net {n}) (uuid "{U()}"))')
+    for (x, y, n) in vias:
+        emit.append(f'  (via (at {x:.4f} {y:.4f}) (size 0.6) (drill 0.3)'
+                    f' (layers "F.Cu" "B.Cu") (net {n}) (uuid "{U()}"))')
+    head = txt[:txt.rindex(")")].rstrip("\n")
+    mid = ("\n" + "\n".join(kept_segs)) if (only_nets and kept_segs) else ""
+    open(out_path, "w").write(head + mid + "\n".join(emit) + "\n)\n")
+    print(f"routed: segments={len(segs)} vias={len(vias)} failed_edges={len(fails)}")
+    for f in fails[:12]:
+        print("  FAIL-EDGE", f)
+    return len(fails)
+
+
+if __name__ == "__main__":
+    only = None
+    if "--only-nets" in sys.argv:
+        only = set(sys.argv[sys.argv.index("--only-nets") + 1].split(","))
+    sys.exit(1 if route(sys.argv[1], sys.argv[2], only) else 0)

package/graders/pcb-agent/seed/tools/board_zone_pour.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""r17 GND pour: strip greedy GND tracks, paint GND pads, raster-erode foreign
+items, emit dual-layer (F.Cu+B.Cu) zone with scanline-exact boundary rings plus
+stitching vias. Deterministic 0.2mm raster. Usage: board_zone_pour.py in out"""
+import json, os, re, sys
+from collections import defaultdict
+
+CELL = 0.2
+EDGE_INSET = 0.3
+OBS_CLEAR = 0.25
+HOLE_CLEAR = 0.30
+
+
+def sub_blocks(s, start):
+    out = []; i = start; n = len(s)
+    while i < n:
+        while i < n and s[i] != "(":
+            i += 1
+        if i >= n:
+            break
+        depth = 0; j = i; instr = False; esc = False
+        while j < n:
+            ch = s[j]
+            if esc: esc = False
+            elif ch == "\\": esc = True
+            elif ch == '"': instr = not instr
+            elif not instr:
+                if ch == "(": depth += 1
+                elif ch == ")":
+                    depth -= 1
+                    if depth == 0: break
+            j += 1
+        out.append(s[i + 1:j]); i = j + 1
+        p2 = i
+        while p2 < n and s[p2] in " \t\n\r":
+            p2 += 1
+        if p2 < n and s[p2] == ")":
+            break
+    return out
+
+
+def parse_pads(txt):
+    pads = []
+    for b in sub_blocks(sub_blocks(txt, txt.index("(kicad_pcb"))[0], 0):
+        if not b.startswith("footprint"):
+            continue
+        m0 = re.search(r'\(at ([-\d.]+) ([-\d.]+)\)', b[:b.find("(property") if "(property" in b else 200])
+        ax, ay = float(m0.group(1)), float(m0.group(2))
+        mr = re.search(r'\(rotate (\d+\.?\d*)\)', b[:b.find("(layer")])
+        rot = __import__("math").radians(float(mr.group(1))) if mr else 0.0
+        mref = re.search(r'\(property "Reference" "([^"]+)"', b)
+        ref = mref.group(1) if mref else ""
+        i = 0
+        while True:
+            i = b.find("(pad ", i)
+            if i < 0: break
+            d = 0; j = i; instr = False
+            while j < len(b):
+                c = b[j]
+                if c == '"': instr = not instr
+                elif not instr:
+                    if c == "(": d += 1
+                    elif c == ")":
+                        d -= 1
+                        if d == 0: break
+                j += 1
+            pb = b[i + 1:j]; i = j + 1
+            pnum = re.match(r'pad "([^"]*)"', pb).group(1)
+            sm = re.search(r'\(at ([-\d.]+) ([-\d.]+)(?: ([-\d.]+))?\)', pb)
+            ox, oy = float(sm.group(1)), float(sm.group(2))
+            ca, sa = __import__("math").cos(rot), __import__("math").sin(rot)
+            wx, wy = ax + ox * ca - oy * sa, ay + ox * sa + oy * ca
+            sz = re.search(r'\(size ([-\d.]+) ([-\d.]+)\)', pb)
+            w, h = float(sz.group(1)), float(sz.group(2))
+            shape = "circle" if "(shape circle)" in pb or '"circle"' in pb else "rect"
+            drl = re.search(r'\(drill(?: oval)? ([\d.]+)(?: ([\d.]+))?\)', pb)
+            pads.append(dict(ref=ref, num=pnum, x=wx, y=wy, w=w, h=h, shape=shape,
+                             drill=(float(drl.group(1)), float(drl.group(2) or drl.group(1))) if drl else None,
+             bnet=(re.search(r'\(net \d+ "([^"]*)"\)', pb) or [None, None])[1]))
+    return pads
+
+
+def rings_from_rects(rects, x0, y0):
+    segs = set()
+    for (xa, ya, xb, yb) in rects:
+        ax, ay = x0 + (xa - 1) * CELL, y0 + (ya - 1) * CELL
+        bx, by = x0 + (xb - 1) * CELL, y0 + (yb - 1) * CELL
+        segs.add(((ax, ay), (bx, ay)))
+        segs.add(((bx, ay), (bx, by)))
+        segs.add(((bx, by), (ax, by)))
+        segs.add(((ax, by), (ax, ay)))
+    kill = set()
+    for a, b in segs:
+        if (b, a) in segs:
+            kill.add((a, b)); kill.add((b, a))
+    eout = defaultdict(list)
+    for a, b in segs - kill:
+        eout[a].append(b)
+    rings = []
+    for st in list(eout.keys()):
+        while eout[st]:
+            stack = [st]; trail = []
+            cur = st
+            while True:
+                outs = eout[cur]
+                if not outs:
+                    break
+                nxt = outs.pop()
+                stack.append(nxt)
+                cur = nxt
+                if cur == st:
+                    break
+            if cur == st and len(stack) >= 5:
+                rings.append(stack[:-1])
+            elif cur != st:
+                for q in reversed(stack[stack.index(st) + 1:]):
+                    eout.setdefault(stack[stack.index(q)][0], [])
+    def area(r):
+        return sum(r[k][0] * r[k + 1][1] - r[k + 1][0] * r[k][1] for k in range(len(r) - 1)) / 2.0
+    out = []
+    for r in rings:
+        rr = []
+        for q in r:
+            if not rr or rr[-1] != q:
+                rr.append(q)
+        if len(rr) >= 5 and rr[0] == rr[-1]:
+            rr = rr[:-1]
+        if len(rr) >= 4 and abs(area(rr)) > 0.5:
+            out.append(rr)
+    return out
+
+
+def main(inp, outp):
+    txt = open(inp).read()
+    nm = dict((m.group(2).strip('"'), int(m.group(1))) for m in
+              re.finditer(r'\(net (\d+) "([^"]+)"\)', txt))
+    gnd_code = nm.get("GND")
+    assert gnd_code is not None, "no GND net"
+    POW = [x for x in (os.environ.get("PCB_POWER_ZONE_NETS", "5V_SERVO,5V_LOGIC,3V3,VBUS")).split(",") if x]
+    pcode = {n: nm[n] for n in POW if n in nm}
+    padby = defaultdict(list)
+    prect = {}
+    pwr_codes = set(pcode.values())
+
+    root_children = sub_blocks(sub_blocks(txt, txt.index("(kicad_pcb"))[0], 0)
+    xs, ys = [], []
+    for b in root_children:
+        if b.startswith("gr_line") and "Edge.Cuts" in b:
+            for mm in re.finditer(r'\((?:start|end) ([-\d.]+) ([-\d.]+)\)', b):
+                xs.append(float(mm.group(1))); ys.append(float(mm.group(2)))
+    x0, x1, y0, y1 = min(xs), max(xs), min(ys), max(ys)
+    spec = "/home/lab/workspace/pcb-local-repro/solar_ray_v2/circuit/netlist.json"
+    pad_net = {}
+    for c in json.load(open(spec))["components"]:
+        for pin, net in c["pins"].items():
+            pad_net[(c["ref"], pin)] = net
+    pads = parse_pads(txt)
+    for pd_ in pads:
+        pd_["net"] = pd_["bnet"] or pad_net.get((pd_["ref"], pd_["num"]), "?")
+        padby[pd_["net"]].append(pd_)
+    for n_, ps in padby.items():
+        if n_ in pcode:
+            xs_ = [pd_["x"] - pd_["w"] / 2 for pd_ in ps] + [pd_["x"] + pd_["w"] / 2 for pd_ in ps]
+            ys_ = [pd_["y"] - pd_["h"] / 2 for pd_ in ps] + [pd_["y"] + pd_["h"] / 2 for pd_ in ps]
+            prect[n_] = (min(xs_) - 0.8, min(ys_) - 0.8, max(xs_) + 0.8, max(ys_) + 0.8)
+    gnd_name = "GND"
+    keep = []
+    nstrip = 0
+    fp_i = next(i for i, b in enumerate(root_children) if b.startswith("footprint"))
+    for b in root_children[fp_i:]:
+        if b.startswith("segment") or b.startswith("via"):
+            mn = re.search(r'\(net (\d+)\)', b)
+            if mn and int(mn.group(1)) in ({gnd_code} | pwr_codes):
+                nstrip += 1
+                continue
+        keep.append("(" + b + ")")
+    W = int((x1 - x0) / CELL) + 2
+    H = int((y1 - y0) / CELL) + 2
+    occ = bytearray(W * H)
+    rawpad = bytearray(W * H)
+
+    def cx(v): return int((v - x0) / CELL) + 1
+    def cy(v): return int((v - y0) / CELL) + 1
+
+    def mark_rect(xa, ya, xb, yb, r, arr):
+        gx0, gx1 = sorted((cx(xa), cx(xb)))
+        gy0, gy1 = sorted((cy(ya), cy(yb)))
+        pad = int(r / CELL) + 1
+        for gy in range(max(0, gy0 - pad), min(H, gy1 + pad + 1)):
+            for gx in range(max(0, gx0 - pad), min(W, gx1 + pad + 1)):
+                arr[gy * W + gx] = 1
+    for blk in keep:
+        if blk.startswith("(segment"):
+            m1 = re.search(r'\(start ([-\d.]+) ([-\d.]+)\) \(end ([-\d.]+) ([-\d.]+)\)', blk)
+            if m1:
+                xa, ya, xb, yb = (float(m1.group(i)) for i in (1, 2, 3, 4))
+                n_ = int(max(abs(xb - xa), abs(yb - ya)) / (CELL / 2)) + 1
+                for k in range(n_ + 1):
+                    t = k / n_
+                    mark_rect(xa + (xb - xa) * t - CELL, ya + (yb - ya) * t - CELL,
+                              xa + (xb - xa) * t + CELL, ya + (yb - ya) * t + CELL, 0.15, occ)
+        elif blk.startswith("(via"):
+            m2 = re.search(r'\(via \(at ([-\d.]+) ([-\d.]+)\)', blk)
+            if m2:
+                mark_rect(float(m2.group(1)), float(m2.group(2)),
+                          float(m2.group(1)), float(m2.group(2)), 0.55, occ)
+    for p_ in pads:
+        mark_rect(p_["x"] - p_["w"] / 2, p_["y"] - p_["h"] / 2,
+                  p_["x"] + p_["w"] / 2, p_["y"] + p_["h"] / 2, 0.5, rawpad)
+        if p_["net"] != gnd_name:
+            if p_["drill"]:
+                mark_rect(p_["x"] - p_["w"] / 2, p_["y"] - p_["h"] / 2,
+                          p_["x"] + p_["w"] / 2, p_["y"] + p_["h"] / 2, 0.5, occ)
+            else:
+                mark_rect(p_["x"] - p_["w"] / 2, p_["y"] - p_["h"] / 2,
+                          p_["x"] + p_["w"] / 2, p_["y"] + p_["h"] / 2, 0.5, occ)
+    for blk in keep:
+        if blk.startswith("(segment"):
+            m1 = re.search(r'\(start ([-\d.]+) ([-\d.]+)\) \(end ([-\d.]+) ([-\d.]+)\)', blk)
+            if m1:
+                xa, ya, xb, yb = (float(m1.group(i)) for i in (1, 2, 3, 4))
+                nseg = int(max(abs(xb - xa), abs(yb - ya)) / (CELL / 2)) + 1
+                for k in range(nseg + 1):
+                    t = k / nseg
+                    px_, py_ = xa + (xb - xa) * t, ya + (yb - ya) * t
+                    mark_rect(px_ - CELL, py_ - CELL, px_ + CELL, py_ + CELL, 0.1, occ)
+    bx0, by0, bx1, by1 = x0 + EDGE_INSET, y0 + EDGE_INSET, x1 - EDGE_INSET, y1 - EDGE_INSET
+    outline_pts = f"(xy {bx0:.4f} {by0:.4f}) (xy {bx1:.4f} {by0:.4f}) (xy {bx1:.4f} {by1:.4f}) (xy {bx0:.4f} {by1:.4f}) (xy {bx0:.4f} {by0:.4f})"
+    # fine-pitch connector keepout: no pour under USB-C-class parts (0.85mm rows)
+    kx = [pd_ for pd_ in pads if pd_["ref"] in {"J1"}]
+    KEEPOUT_RECT = None
+    if kx:
+        hx0 = min(p_["x"] - p_["w"] / 2 for p_ in kx) - 0.3
+        hy0 = min(p_["y"] - p_["h"] / 2 for p_ in kx) - 0.3
+        hx1 = max(p_["x"] + p_["w"] / 2 for p_ in kx) + 0.3
+        hy1 = max(p_["y"] + p_["h"] / 2 for p_ in kx) + 0.3
+        KEEPOUT_RECT = (hx0, hy0, hx1, hy1)
+        _ = KEEPOUT_RECT
+    outline = outline_pts
+    z = []
+    for LI, LAY in enumerate(["F.Cu", "B.Cu"]):
+        z += [f'(zone (net {gnd_code}) (net_name "GND") (layer "{LAY}") (uuid "5a000000-0000-0000-0000-00000000cafe{LI}")',
+              '  (hatch edge 0.508)',
+              '  (connect_pads (clearance 0))',
+              '  (min_thickness 0.2)',
+              '  (filled_areas_thickness no)',
+              '  (fill yes (thermal_gap 0.4) (thermal_bridge_width 0.5))',
+              f'  (polygon (pts {outline}))',
+              ')']
+    def rectpts(xa, ya, xb, yb):
+        return f"(xy {xa:.4f} {ya:.4f}) (xy {xb:.4f} {ya:.4f}) (xy {xb:.4f} {yb:.4f}) (xy {xa:.4f} {yb:.4f}) (xy {xa:.4f} {ya:.4f})"
+    for zi, (n_, rc) in enumerate(sorted(prect.items())):
+        for LI, LAY in enumerate(["F.Cu", "B.Cu"]):
+            holes = []
+            # explicit holes ONLY for GND pads (protects GND fill corridors at the
+            # zone rim); power-vs-power carve stays native so a neighboring
+            # foreign rect never punches away a power pad's own connect island.
+            for pd_ in pads:
+                if pd_["net"] != "GND":
+                    continue
+                hx0, hy0 = pd_["x"] - pd_["w"] / 2 - 0.30, pd_["y"] - pd_["h"] / 2 - 0.30
+                hx1, hy1 = pd_["x"] + pd_["w"] / 2 + 0.30, pd_["y"] + pd_["h"] / 2 + 0.30
+                if hx1 < rc[0] or hx0 > rc[2] or hy1 < rc[1] or hy0 > rc[3]:
+                    continue
+                holes.append(rectpts(hx0, hy0, hx1, hy1))
+            pts = f"(pts {rectpts(*rc)}" + ("".join(" " + h for h in holes)) + ")"
+            z += [f'(zone (net {pcode[n_]}) (net_name "{n_}") (layer "{LAY}") (priority 2) (uuid "5a000000-0000-0000-0000-00000000cbfe{zi}{LI}")',
+                  '  (hatch edge 0.508)',
+                  '  (connect_pads (clearance 0))',
+                  '  (min_thickness 0.2)',
+                  '  (fill yes (thermal_gap 0.4) (thermal_bridge_width 0.5))',
+                  f'  (polygon {pts})',
+                  ')']
+    if KEEPOUT_RECT:
+        for LI, LAY in enumerate(["F.Cu", "B.Cu"]):
+            k = KEEPOUT_RECT
+            z += [f'(zone (net -1) (net_name "") (layer "{LAY}") (uuid "5a000000-0000-0000-0000-00000000cdfe{LI}")',
+                  '  (hatch edge 0.508)',
+                  '  (priority 15)',
+                  f'  (polygon (pts (xy {k[0]:.4f} {k[1]:.4f}) (xy {k[2]:.4f} {k[1]:.4f}) (xy {k[2]:.4f} {k[3]:.4f}) (xy {k[0]:.4f} {k[3]:.4f}) (xy {k[0]:.4f} {k[1]:.4f})))',
+                  ')']
+    stitch = 0
+    step = max(1, int(4.0 / CELL))
+    for gy in range(1, H - 1, step):
+        for gx in range(1, W - 1, step):
+            rr = int(0.55 / CELL)
+            vxc, vyc = x0 + (gx - 1) * CELL, y0 + (gy - 1) * CELL
+            if not (x0 + 1.0 < vxc < x1 - 1.0 and y0 + 1.0 < vyc < y1 - 1.0):
+                continue  # board-edge via guard: copper_edge_clearance class
+            if any(rc[0] + 0.3 < vxc < rc[2] - 0.3 and rc[1] + 0.3 < vyc < rc[3] - 0.3 for rc in prect.values()):
+                continue  # GND via must not land inside a power zone
+            if KEEPOUT_RECT and KEEPOUT_RECT[0] - 0.2 < vxc < KEEPOUT_RECT[2] + 0.2 and KEEPOUT_RECT[1] - 0.2 < vyc < KEEPOUT_RECT[3] + 0.2:
+                continue  # fine-pitch connector keepout
+            if any(occ[max(0, min(H - 1, gy + dy2)) * W + max(0, min(W - 1, gx + dx2))] or
+                   rawpad[max(0, min(H - 1, gy + dy2)) * W + max(0, min(W - 1, gx + dx2))]
+                   for dx2 in range(-rr, rr + 1) for dy2 in range(-rr, rr + 1)):
+                continue
+            stitch += 1
+            z.append(f'(via (at {x0 + (gx - 1) * CELL:.4f} {y0 + (gy - 1) * CELL:.4f}) (size 0.6) (drill 0.3)'
+                     f' (layers "F.Cu" "B.Cu") (net {gnd_code}) (uuid "00000000-0000-0000-0000-{stitch:012d}cafe0"))')
+    print(f"stripped={nstrip} pads={len(pads)} stitch-vias={stitch} zones={2 + 2 * len(prect)} (GND x2 + power x{2 * len(prect)}, native refill)")
+    # GND net-class -> solid pad connection (kills starved_thermal at pour rims)
+    head = re.sub(r'(\(net_class "GND"[^\n]*?)(\s*\)\s*)$',
+                  r'\1 (pad_connection "solid")\2',
+                  txt[:txt.index("(footprint")].rstrip("\n"))
+    body = "\n".join(keep if keep else [])
+    tail = "\n".join(z)
+    open(outp, "w").write(head + "\n" + body + "\n" + tail + "\n)\n")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1], sys.argv[2])