enginehall 2.0.0__py3-none-any.whl

pcba/adapters/altium_house.py

@@ -0,0 +1,591 @@
+"""Newmatik house DFM for Altium boards (Class C helper of the Altium drive; never on the review path).
+
+Two halves:
+
+- **Rules Altium can check.** `HOUSE_RULES` holds the house values for Altium design-rule kinds.
+  `rul_text()` writes them as an Altium rules file (`.RUL`, Design > Rules > Import Rules), with
+  the record syntax Altium itself stores in a PcbDoc; `house_ops()` gives the typed operations
+  that apply the same values through `enginehall altium mcp`. The rules keep Altium's default names, so
+  an import replaces the defaults instead of competing with them.
+- **What Altium's rule system cannot express**: fiducials, and the house layout checks review kept
+  finding by hand. `check_fiducials()` takes what the drive reads from a board (`pcb_components`,
+  `pcb_pads`, the outline) and requires three global fiducials on every side that carries SMD
+  parts; `check_layout()` adds silkscreen beyond the edge, track angles, vias in pads, same-net
+  via spacing, 3D models and the barcode field from `pcb_primitives` and `pcb_bodies`.
+
+Values marked ``proposed`` are starting points until Newmatik process engineering confirms them;
+`status()` lists them so nobody mistakes them for confirmed capability. This module never claims
+manufacturability: it reports.
+"""
+
+from __future__ import annotations
+
+import itertools
+import math
+from dataclasses import dataclass, field
+
+from pcba.house import (  # noqa: F401  (re-exported: the drive and its tests read them here)
+    FIDUCIAL_STATUS,
+    FIDUCIALS,
+    HOUSE,
+    LAYOUT,
+    LAYOUT_STATUS,
+    VERSION,
+)
+from pcba.house import angles as _angles
+from pcba.house import distance_to_pad as _house_distance_to_pad
+from pcba.house import edge_distance as _edge_distance
+from pcba.house import inside as _inside
+
+MM_PER_MIL = 0.0254
+
+
+@dataclass(frozen=True)
+class HouseRule:
+    kind: str                     # Altium RULEKIND
+    name: str                     # Altium's default rule name, so an import replaces the default
+    fields: tuple                 # (KEY, value) pairs after the common header; mm floats become mils
+    why: str
+    netscope: str = "AnyNet"
+    scope1: str = "All"
+    scope2: str = "All"
+    status: str = "proposed"
+
+
+def _mm(value: float) -> str:
+    """Altium writes rule lengths in mils with up to four decimals."""
+    mils = round(value / MM_PER_MIL, 4)
+    text = f"{mils:.4f}".rstrip("0").rstrip(".")
+    return f"{text}mil"
+
+
+HOUSE_RULES: tuple[HouseRule, ...] = (
+    HouseRule("Clearance", "Clearance",
+              (("GAP", 0.15), ("GENERICCLEARANCE", 0.15), ("IGNOREPADTOPADCLEARANCEINFOOTPRINT", "FALSE"),
+               ("OBJECTCLEARANCES", "")),
+              "Copper to copper, different nets, all layers.", netscope="DifferentNets"),
+    HouseRule("Width", "Width", (("MAXLIMIT", 5.0), ("MINLIMIT", 0.15), ("PREFEREDWIDTH", 0.2)),
+              "Track width; wider power and EMC nets get their own rules above this one."),
+    HouseRule("RoutingVias", "RoutingVias",
+              (("HOLEWIDTH", 0.3), ("WIDTH", 0.6), ("VIASTYLE", "Through Hole"), ("MINHOLEWIDTH", 0.25),
+               ("MINWIDTH", 0.5), ("MAXHOLEWIDTH", 0.8), ("MAXWIDTH", 1.4)),
+              "Through vias only; 0.125 mm minimum annular ring at the minimum sizes."),
+    HouseRule("HoleSize", "HoleSize",
+              (("ABSOLUTEVALUES", "TRUE"), ("MAXLIMIT", 6.4), ("MINLIMIT", 0.2), ("MAXPERCENT", "80.000"),
+               ("MINPERCENT", "20.000")),
+              "Drilled holes from 0.2 mm up to M6 clearance."),
+    HouseRule("HoleToHoleClearance", "HoleToHoleClearance", (("GAP", 0.25), ("ALLOWSTACKEDMICROVIAS", "TRUE")),
+              "Drill web between holes."),
+    HouseRule("MinimumSolderMaskSliver", "MinimumSolderMaskSliver", (("MINSOLDERMASKWIDTH", 0.1),),
+              "Narrowest solder-mask dam the mask process holds."),
+    HouseRule("SolderMaskExpansion", "SolderMaskExpansion", (("EXPANSION", 0.05), ("ISTENTINGTOP", "FALSE")),
+              "Mask opening around pads; vias are tented per board."),
+    HouseRule("PasteMaskExpansion", "PasteMaskExpansion", (("EXPANSION", 0.0),),
+              "Paste follows the pad; stencil apertures are tuned at assembly."),
+    HouseRule("SilkToSolderMaskClearance", "SilkToSolderMaskClearance",
+              (("MINSILKSCREENTOMASKGAP", 0.15), ("CLEARANCETOEXPOSEDCOPPER", "TRUE")),
+              "Silkscreen kept off pads and mask openings.", scope1="IsPad"),
+    HouseRule("SilkToSilkClearance", "SilkToSilkClearance", (("SILKTOSILKCLEARANCE", 0.15),),
+              "Legible, non-overlapping silkscreen."),
+    HouseRule("ComponentClearance", "ComponentClearance",
+              (("GAP", 0.25), ("COLLISIONCHECKMODE", "3"), ("VERTICALGAP", 0.25), ("SHOWDISTANCES", "FALSE")),
+              "Body to body for placement and rework."),
+    HouseRule("PlaneClearance", "PlaneClearance", (("CLEARANCE", 0.3),), "Antipad in power and ground planes."),
+)
+
+_HEADER = ("SELECTION=FALSE", "LAYER=TOP", "LOCKED=FALSE", "POLYGONOUTLINE=FALSE", "USERROUTED=TRUE",
+           "KEEPOUT=FALSE", "UNIONINDEX=0")
+
+
+def _unique_id(rule: HouseRule) -> str:
+    """Eight capitals, stable per rule, like the ids Altium writes."""
+    seed = sum((i + 1) * ord(c) for i, c in enumerate(rule.kind + rule.name))
+    letters = []
+    for _ in range(8):
+        seed = (seed * 1103515245 + 12345) % (1 << 31)
+        letters.append(chr(ord("A") + seed % 26))
+    return "".join(letters)
+
+
+# Altium's Export Rules ends every record with the rule set name and a pilcrow (0xB6), writes an
+# empty value as one space, and encodes the file as ISO-8859-1. Its importer rejects other forms,
+# a leading "|" included, as "Invalid RUL file structure" (Altium Designer Develop 26.10).
+RULE_SET = "Default Rule Set"
+RECORD_END = "¶"
+
+
+def rul_record(rule: HouseRule) -> str:
+    parts = list(_HEADER) + [
+        f"RULEKIND={rule.kind}", f"NETSCOPE={rule.netscope}", "LAYERKIND=SameLayer",
+        f"SCOPE1EXPRESSION={rule.scope1}", f"SCOPE2EXPRESSION={rule.scope2}", f"NAME={rule.name}",
+        "ENABLED=TRUE", "PRIORITY=1", f"COMMENT={HOUSE} v{VERSION} ({rule.status})",
+        f"UNIQUEID={_unique_id(rule)}", "DEFINEDBYLOGICALDOCUMENT=FALSE",
+    ]
+    for key, value in rule.fields:
+        text = _mm(value) if isinstance(value, float) else value
+        parts.append(f"{key}={text or ' '}")
+    parts.append(f"CUSTOMRULESETNAME={RULE_SET}")
+    return "|".join(parts) + RECORD_END
+
+
+def rul_text() -> str:
+    """The `.RUL` file: one record per line and exactly one line break at the end (Altium's
+    importer fails on a second blank line)."""
+    return "\r\n".join(rul_record(rule) for rule in HOUSE_RULES) + "\r\n"
+
+
+def rul_bytes() -> bytes:
+    return rul_text().encode("latin-1")
+
+
+# Altium exposes no writable property for the silk-to-mask gap to scripts; that one rule reaches a
+# board only through the .RUL import.
+RUL_ONLY = ("SilkToSolderMaskClearance",)
+
+
+def house_ops() -> list[dict]:
+    """Every house rule except RUL_ONLY as typed operations. Apply them before a board's own
+    rules: Altium gives the most recently added rule the highest priority."""
+    values = {r.name: dict(r.fields) for r in HOUSE_RULES}
+    via = values["RoutingVias"]
+    hole = values["HoleSize"]
+    return [
+        {"op": "pcb_rule_clearance", "name": "Clearance", "gap": values["Clearance"]["GAP"]},
+        {"op": "pcb_rule_width", "name": "Width", "scope": "All", "min": values["Width"]["MINLIMIT"],
+         "preferred": values["Width"]["PREFEREDWIDTH"], "max": values["Width"]["MAXLIMIT"]},
+        {"op": "pcb_rule_via", "name": "RoutingVias", "scope": "All", "hole_min": via["MINHOLEWIDTH"],
+         "hole": via["HOLEWIDTH"], "hole_max": via["MAXHOLEWIDTH"], "diameter_min": via["MINWIDTH"],
+         "diameter": via["WIDTH"], "diameter_max": via["MAXWIDTH"]},
+        {"op": "pcb_rule_hole_size", "name": "HoleSize", "min": hole["MINLIMIT"], "max": hole["MAXLIMIT"]},
+        {"op": "pcb_rule_mask_sliver", "name": "MinimumSolderMaskSliver",
+         "gap": values["MinimumSolderMaskSliver"]["MINSOLDERMASKWIDTH"]},
+        {"op": "pcb_rule_silk_to_silk", "name": "SilkToSilkClearance",
+         "gap": values["SilkToSilkClearance"]["SILKTOSILKCLEARANCE"]},
+        {"op": "pcb_rule_value", "name": "HoleToHoleClearance", "kind": "hole_to_hole",
+         "value": values["HoleToHoleClearance"]["GAP"]},
+        {"op": "pcb_rule_value", "name": "ComponentClearance", "kind": "component_clearance",
+         "value": values["ComponentClearance"]["GAP"], "vertical": values["ComponentClearance"]["VERTICALGAP"]},
+        {"op": "pcb_rule_value", "name": "SolderMaskExpansion", "kind": "solder_mask_expansion",
+         "value": values["SolderMaskExpansion"]["EXPANSION"]},
+        {"op": "pcb_rule_value", "name": "PasteMaskExpansion", "kind": "paste_mask_expansion",
+         "value": values["PasteMaskExpansion"]["EXPANSION"]},
+        {"op": "pcb_rule_value", "name": "PlaneClearance", "kind": "plane_clearance",
+         "value": values["PlaneClearance"]["CLEARANCE"]},
+    ]
+
+
+def status() -> dict:
+    """Which values are Newmatik requirements and which are still proposals."""
+    return {
+        "house": HOUSE,
+        "version": VERSION,
+        "rules": [{"kind": r.kind, "name": r.name, "status": r.status, "why": r.why,
+                   "values": {k: (v if not isinstance(v, float) else round(v, 4)) for k, v in r.fields}}
+                  for r in HOUSE_RULES],
+        "fiducials": {k: {"value": v, "status": FIDUCIAL_STATUS.get(k, "proposed")} for k, v in FIDUCIALS.items()},
+        "layout": {k: {"value": v, "status": LAYOUT_STATUS.get(k, "proposed")} for k, v in LAYOUT.items()},
+        "not_in_rul": "fiducials, silkscreen past the board edge, track angles, vias in pads, same-net via spacing, "
+                      "3D models and the barcode field: Altium has no rule kind for them; altium_dfm checks them",
+    }
+
+
+# --- fiducial check ------------------------------------------------------------------------------
+
+
+@dataclass
+class Finding:
+    rule_id: str
+    severity: str        # error | warning
+    side: str
+    message: str
+    evidence: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {"rule_id": self.rule_id, "severity": self.severity, "side": self.side,
+                "message": self.message, "evidence": self.evidence}
+
+
+SMD_LAYERS = {"top": 1, "bottom": 32}
+
+
+def is_fiducial(component: dict) -> bool:
+    return ("FIDUCIAL" in str(component.get("footprint", "")).upper()
+            or str(component.get("designator", "")).upper().startswith("FID"))
+
+
+def _side(component: dict) -> str:
+    return "bottom" if component.get("bottom") else "top"
+
+
+def check_fiducials(components: list[dict], pads: list[dict], outline: list[list[float]] | None = None) -> dict:
+    """Fiducial findings for a board read through the drive (lengths in mm).
+
+    A side needs fiducials when a non-fiducial part on it has an SMD pad. Returns
+    ``{"sides": {...}, "findings": [...], "passed": bool}``; ``passed`` ignores warnings.
+    """
+    policy = FIDUCIALS
+    by_des = {c["designator"]: c for c in components}
+    pads_by_des: dict[str, list[dict]] = {}
+    for pad in pads:
+        pads_by_des.setdefault(pad.get("designator", ""), []).append(pad)
+
+    findings: list[Finding] = []
+    sides = {}
+    for side in ("top", "bottom"):
+        smd_parts = sorted(
+            des for des, comp in by_des.items()
+            if _side(comp) == side and not is_fiducial(comp)
+            and any(not p.get("hole") and p.get("layer") in SMD_LAYERS.values() for p in pads_by_des.get(des, []))
+        )
+        fids = sorted((des for des, comp in by_des.items() if _side(comp) == side and is_fiducial(comp)))
+        sides[side] = {"smd_parts": len(smd_parts), "fiducials": fids}
+        if not smd_parts:
+            continue
+        need = policy["per_smd_side"]
+        if len(fids) < need:
+            findings.append(Finding(
+                "NM-FID-001", "error", side,
+                f"{side} carries {len(smd_parts)} SMD parts but {len(fids)} fiducial(s); "
+                f"the house rule is {need} per SMD side",
+                {"smd_parts": smd_parts[:10], "fiducials": fids}))
+        points = {}
+        for des in fids:
+            comp = by_des[des]
+            points[des] = (comp["x"], comp["y"])
+            fpads = pads_by_des.get(des, [])
+            if len(fpads) != 1:
+                findings.append(Finding("NM-FID-002", "error", side, f"{des} has {len(fpads)} pads; a fiducial has one",
+                                        {"designator": des}))
+                continue
+            pad = fpads[0]
+            size = max(pad.get("w", 0), pad.get("h", 0))
+            if (abs(pad.get("w", 0) - pad.get("h", 0)) > 1e-3
+                    or abs(size - policy["copper_mm"]) > policy["copper_tolerance_mm"]):
+                findings.append(Finding("NM-FID-002", "error", side,
+                                        f"{des} copper is {pad.get('w')} x {pad.get('h')} mm; "
+                                        f"the house fiducial is a {policy['copper_mm']} mm round pad",
+                                        {"designator": des}))
+            # The bridge names the pad shape; a square 1.0 mm pad has the right size and is still wrong.
+            if pad.get("shape", "round") != "round":
+                findings.append(Finding("NM-FID-002", "error", side,
+                                        f"{des} is a {pad['shape']} pad; "
+                                        f"the house fiducial is a {policy['copper_mm']} mm round pad",
+                                        {"designator": des, "shape": pad["shape"]}))
+            if pad.get("hole"):
+                findings.append(Finding("NM-FID-002", "error", side, f"{des} is drilled; a fiducial is a bare SMD pad",
+                                        {"designator": des}))
+            if pad.get("net"):
+                findings.append(Finding("NM-FID-004", "error", side,
+                                        f"{des} is on net {pad['net']}; a fiducial carries no net",
+                                        {"designator": des, "net": pad["net"]}))
+            if "mask_mode" in pad:
+                opening = size + 2 * (pad.get("mask", 0.0) if pad["mask_mode"] == 2 else 0.0)
+                if pad["mask_mode"] != 2 or abs(opening - policy["mask_opening_mm"]) > policy["mask_tolerance_mm"]:
+                    findings.append(Finding("NM-FID-003", "error", side,
+                                            f"{des} mask opening is {opening:.2f} mm; the house fiducial needs "
+                                            f"{policy['mask_opening_mm']} mm (manual expansion on the pad)",
+                                            {"designator": des, "mask_mode": pad["mask_mode"]}))
+                if pad.get("paste_mode") != 2 or pad.get("paste", 0.0) > -size / 2:
+                    findings.append(Finding("NM-FID-004", "error", side,
+                                            f"{des} would get solder paste; a fiducial has none",
+                                            {"designator": des}))
+            if outline and not _inside(points[des], outline):
+                findings.append(Finding("NM-FID-006", "error", side, f"{des} lies outside the board outline",
+                                        {"designator": des}))
+            elif outline:
+                d = _edge_distance(points[des], outline)
+                if d < policy["edge_min_mm"]:
+                    findings.append(Finding("NM-FID-006", "warning", side,
+                                            f"{des} is {d:.2f} mm from the board edge; "
+                                            f"house target {policy['edge_min_mm']} mm",
+                                            {"designator": des, "distance_mm": round(d, 3)}))
+        if len(points) >= 3:
+            pts = list(points.values())
+            # With more than three, the best-conditioned triple is the one a machine would use.
+            best = max(min(_angles(a, b, c)) for a, b, c in itertools.combinations(pts, 3))
+            if best < policy["min_angle_deg"]:
+                findings.append(Finding("NM-FID-005", "error", side,
+                                        f"the {side} fiducials are nearly in a line (smallest angle {best:.1f} deg); "
+                                        "a machine cannot resolve rotation from them",
+                                        {"fiducials": sorted(points)}))
+            if outline:
+                xs = [p[0] for p in outline]
+                ys = [p[1] for p in outline]
+                fx = [p[0] for p in pts]
+                fy = [p[1] for p in pts]
+                sx = (max(fx) - min(fx)) / max(1e-9, max(xs) - min(xs))
+                sy = (max(fy) - min(fy)) / max(1e-9, max(ys) - min(ys))
+                if min(sx, sy) < policy["min_spread"]:
+                    findings.append(Finding("NM-FID-005", "warning", side,
+                                            f"the {side} fiducials span {sx:.0%} of the board width and "
+                                            f"{sy:.0%} of its depth; house target {policy['min_spread']:.0%} each",
+                                            {"fiducials": sorted(points)}))
+    return {
+        "policy": dict(policy),
+        "sides": sides,
+        "findings": [f.to_dict() for f in findings],
+        "passed": not any(f.severity == "error" for f in findings),
+    }
+
+
+# --- house layout checks ------------------------------------------------------------------------
+#
+# What review found one correction at a time on the first boards built with the drive, and what
+# Altium's DRC does not check: silkscreen beyond the board edge (the fabricator cuts it off, so a
+# board name lost its end), copper tracks at free angles, vias in or touching pads, two vias of
+# one net side by side, components without a real 3D model, and a missing barcode field. All of
+# them read the board through the drive (pcb_primitives, pcb_pads, pcb_bodies, the outline).
+
+OVERLAYS = {33: "top", 34: "bottom"}
+COPPER = set(range(1, 33))
+
+
+def _outline_points(outline: list[list[float]] | None) -> list[tuple[float, float]]:
+    return [(float(x), float(y)) for x, y in outline or []]
+
+
+def _outside_by(point, outline) -> float:
+    """How far a point lies outside the outline polygon (0 when inside or on it)."""
+    return 0.0 if _inside(point, outline) else _edge_distance(point, outline)
+
+
+def _silk_points(p: dict) -> list[tuple[float, float]]:
+    """The points of a silkscreen primitive that must lie on the board. A line counts by its centre
+    line (a barrier mark may end on the edge); text, fills and regions by their extent."""
+    if p["kind"] == "track":
+        return [(p["x1"], p["y1"]), (p["x2"], p["y2"])]
+    if p["kind"] == "arc":
+        r = p["r"]
+        ends = [(p["xc"] + r * math.cos(math.radians(a)), p["yc"] + r * math.sin(math.radians(a)))
+                for a in (p.get("start", 0), p.get("end", 360))]
+        return ends + [(p["xc"] + dx * r, p["yc"] + dy * r) for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1))
+                       if _arc_covers(p, dx, dy)]
+    return [(p["box_left"], p["box_bottom"]), (p["box_right"], p["box_bottom"]),
+            (p["box_right"], p["box_top"]), (p["box_left"], p["box_top"])]
+
+
+def _arc_covers(p: dict, dx: int, dy: int) -> bool:
+    angle = math.degrees(math.atan2(dy, dx)) % 360
+    start, end = p.get("start", 0) % 360, p.get("end", 360) % 360 or 360
+    return start <= angle <= end if start <= end else angle >= start or angle <= end
+
+
+def check_silkscreen(primitives: list[dict], outline: list[list[float]] | None) -> list[Finding]:
+    """NM-SILK-001: silkscreen beyond the board outline. Hidden component texts do not print."""
+    poly = _outline_points(outline)
+    if len(poly) < 3:
+        return []
+    tol = LAYOUT["silk_tolerance_mm"]
+    findings = []
+    for p in primitives:
+        side = OVERLAYS.get(p.get("layer"))
+        if side is None or p.get("kind") not in ("track", "arc", "text", "fill", "region") or p.get("hidden"):
+            continue
+        worst = max(_outside_by(pt, poly) for pt in _silk_points(p))
+        if worst > tol:
+            what = f"text '{p['text']}'" if p["kind"] == "text" else p["kind"]
+            owner = " of a component" if p.get("in_component") else ""
+            findings.append(Finding("NM-SILK-001", "error", side,
+                                    f"{side} silkscreen {what}{owner} reaches {worst:.2f} mm beyond the board outline; "
+                                    "the fabricator cuts it off",
+                                    {"box": [p.get("box_left"), p.get("box_bottom"),
+                                             p.get("box_right"), p.get("box_top")],
+                                     "beyond_mm": round(worst, 3)}))
+    return findings
+
+
+def check_track_angles(primitives: list[dict]) -> list[Finding]:
+    """NM-ROUTE-001: a routed copper track not at a multiple of 45 degrees (footprint copper and
+    polygon pours excepted)."""
+    step, tol = LAYOUT["track_angle_step_deg"], LAYOUT["track_angle_tolerance_deg"]
+    findings = []
+    for p in primitives:
+        if p.get("kind") != "track" or p.get("layer") not in COPPER or p.get("in_component") or p.get("in_polygon"):
+            continue
+        dx, dy = p["x2"] - p["x1"], p["y2"] - p["y1"]
+        if math.hypot(dx, dy) < 1e-4:
+            continue
+        angle = math.degrees(math.atan2(dy, dx)) % 180
+        off = abs(angle - round(angle / step) * step)
+        if off > tol:
+            findings.append(Finding("NM-ROUTE-001", "error", "copper",
+                                    f"track on {p.get('layer_name', p['layer'])} "
+                                    f"(net {p.get('net') or 'none'}) runs at "
+                                    f"{angle:.1f} deg; house routing is 0, 45 or 90 deg",
+                                    {"from": [p["x1"], p["y1"]], "to": [p["x2"], p["y2"]]}))
+    return findings
+
+
+# A joint and a track end closer than this are the same point (Altium's internal unit is
+# 0.0000254 mm; read-back rounds to it).
+SAME_POINT_MM = 1e-5
+
+
+def _anchors(primitives: list[dict], pads: list[dict]) -> list[tuple[float, float, int | None, str, str, int]]:
+    """Every point a track end may join: (x, y, layer or None for all copper, net, what, owner),
+    owner being the track's index in `primitives` (-1 for vias and pads)."""
+    points: list[tuple[float, float, int | None, str, str, int]] = []
+    for i, p in enumerate(primitives):
+        if p.get("kind") == "via":
+            points.append((p["x"], p["y"], None, p.get("net") or "", "via", -1))
+        elif p.get("kind") == "track" and p.get("layer") in COPPER and not p.get("in_polygon"):
+            for end in (1, 2):
+                points.append((p[f"x{end}"], p[f"y{end}"], p["layer"], p.get("net") or "", "track", i))
+    for pad in pads:
+        layer = pad.get("layer")
+        points.append((pad["x"], pad["y"], None if layer == 74 else layer, pad.get("net") or "", "pad", -1))
+    return points
+
+
+def near_miss_joins(primitives: list[dict], pads: list[dict], tolerance: float | None = None) -> list[dict]:
+    """Track ends that sit next to a joint of their own net (another track end on the layer, a via,
+    a pad centre) without being on it: Altium reports them as net antennae and the copper may not
+    join. Each comes with the point to snap to, a pad or via centre before another track end."""
+    tol = LAYOUT["join_tolerance_mm"] if tolerance is None else tolerance
+    anchors = _anchors(primitives, pads)
+    grid: dict[tuple[int, int], list[int]] = {}
+    for i, (x, y, *_rest) in enumerate(anchors):
+        grid.setdefault((int(x // tol), int(y // tol)), []).append(i)
+    rank = {"pad": 0, "via": 1, "track": 2}
+    misses, seen = [], set()
+    for index, p in enumerate(primitives):
+        if p.get("kind") != "track" or p.get("layer") not in COPPER or p.get("in_component") or p.get("in_polygon"):
+            continue
+        for end in (1, 2):
+            x, y = p[f"x{end}"], p[f"y{end}"]
+            gx, gy = int(x // tol), int(y // tol)
+            best = None
+            for dx in (-1, 0, 1):
+                for dy in (-1, 0, 1):
+                    for i in grid.get((gx + dx, gy + dy), []):
+                        ax, ay, layer, net, what, owner = anchors[i]
+                        # A track's own other end is no joint: snapping onto it would remove the track.
+                        if owner == index or (layer is not None and layer != p["layer"]) or net != (p.get("net") or ""):
+                            continue
+                        d = math.hypot(ax - x, ay - y)
+                        # On the point already (its own end included), or too far to be a near miss.
+                        if d <= SAME_POINT_MM or d > tol:
+                            continue
+                        # Two track ends apart: only one of them moves, onto the other.
+                        if what == "track" and (ax, ay) > (x, y):
+                            continue
+                        if best is None or (rank[what], d) < (rank[best[2]], best[3]):
+                            best = (ax, ay, what, d)
+            if best is None:
+                continue
+            key = (p["layer"], round(x, 6), round(y, 6))
+            if key in seen:
+                continue
+            seen.add(key)
+            misses.append({"layer": p["layer"], "layer_name": p.get("layer_name"), "net": p.get("net") or "",
+                           "at": [x, y], "snap_to": [best[0], best[1]], "target": best[2],
+                           "gap_mm": round(best[3], 6)})
+    return misses
+
+
+def check_joins(primitives: list[dict], pads: list[dict]) -> list[Finding]:
+    """NM-ROUTE-002: a track end a fraction of a micron off its joint (net antenna)."""
+    return [Finding("NM-ROUTE-002", "warning", "copper",
+                    f"track end on {m['layer_name'] or m['layer']} (net {m['net'] or 'none'}) "
+                    f"is {m['gap_mm'] * 1000:.2f} µm "
+                    f"off a {m['target']}; snap it (altium_snap_joins)", {"at": m["at"], "snap_to": m["snap_to"]})
+            for m in near_miss_joins(primitives, pads)]
+
+
+def _distance_to_pad(x: float, y: float, pad: dict) -> float:
+    """Distance from a point to a pad's copper (see `pcba.house.distance_to_pad`)."""
+    return _house_distance_to_pad(x, y, pad)
+
+
+def check_vias(primitives: list[dict], pads: list[dict]) -> list[Finding]:
+    """NM-VIA-001: a via in or touching a pad. NM-VIA-002: two vias of one net closer than the
+    house distance (they could be one)."""
+    vias = [p for p in primitives if p.get("kind") == "via"]
+    findings = []
+    for v in vias:
+        r = v["diameter"] / 2
+        for pad in pads:
+            if _distance_to_pad(v["x"], v["y"], pad) <= r:
+                findings.append(Finding("NM-VIA-001", "error", "copper",
+                                        f"via of net {v.get('net') or 'none'} at ({v['x']:.2f}, {v['y']:.2f}) "
+                                        f"touches pad {pad.get('designator')}-{pad.get('pad')}; "
+                                        "house rule: no via in or touching a pad",
+                                        {"via": [v["x"], v["y"]], "pad": f"{pad.get('designator')}-{pad.get('pad')}"}))
+                break
+    limit = LAYOUT["same_net_via_min_mm"]
+    for a, b in itertools.combinations(vias, 2):
+        if a.get("net") and a.get("net") == b.get("net"):
+            gap = math.hypot(a["x"] - b["x"], a["y"] - b["y"])
+            if gap < limit:
+                findings.append(Finding("NM-VIA-002", "warning", "copper",
+                                        f"two vias of net {a['net']} are {gap:.2f} mm apart (house {limit:.1f} mm); "
+                                        "one via, or neighbouring pins sharing one, usually does",
+                                        {"vias": [[a["x"], a["y"]], [b["x"], b["y"]]]}))
+    return findings
+
+
+def check_models(bodies: list[dict], components: list[dict]) -> list[Finding]:
+    """NM-3D-001: a component without a STEP model (none, or only a drawn extrusion)."""
+    models: dict[str, list[str]] = {}
+    for b in bodies:
+        models.setdefault(b.get("designator", ""), []).append(b.get("model", ""))
+    findings = []
+    for c in components:
+        des = c.get("designator", "")
+        if is_fiducial(c):
+            continue
+        kinds = models.get(des, [])
+        if not any(m and m != "extruded" for m in kinds):
+            what = "only a drawn extrusion" if kinds else "no 3D body"
+            findings.append(Finding("NM-3D-001", "warning", _side(c),
+                                    f"{des} ({c.get('footprint')}) has {what}; use the manufacturer's STEP model or a "
+                                    "recognised library's, or one built from the data sheet, and say which",
+                                    {"bodies": kinds}))
+    return findings
+
+
+def check_barcode(primitives: list[dict]) -> list[Finding]:
+    """NM-BC-001: a square silkscreen field with "BC" for the serial label, at least 5 mm (7 mm
+    preferred), top side preferred."""
+    texts = [p for p in primitives if p.get("kind") == "text" and str(p.get("text", "")).strip().upper() == "BC"
+             and p.get("layer") in OVERLAYS and not p.get("in_component") and not p.get("hidden")]
+    best = None
+    for t in texts:
+        cx, cy = (t["box_left"] + t["box_right"]) / 2, (t["box_bottom"] + t["box_top"]) / 2
+        lines = [p for p in primitives if p.get("kind") == "track" and p.get("layer") == t["layer"]
+                 and not p.get("in_component")]
+        horizontal = [p for p in lines if abs(p["y1"] - p["y2"]) < 1e-3
+                      and min(p["x1"], p["x2"]) <= cx <= max(p["x1"], p["x2"])]
+        vertical = [p for p in lines if abs(p["x1"] - p["x2"]) < 1e-3
+                    and min(p["y1"], p["y2"]) <= cy <= max(p["y1"], p["y2"])]
+        below = [p["y1"] for p in horizontal if p["y1"] < cy]
+        above = [p["y1"] for p in horizontal if p["y1"] > cy]
+        left = [p["x1"] for p in vertical if p["x1"] < cx]
+        right = [p["x1"] for p in vertical if p["x1"] > cx]
+        if below and above and left and right:
+            side = min(min(above) - max(below), min(right) - max(left))
+            if best is None or side > best[0]:
+                best = (side, OVERLAYS[t["layer"]])
+    if best is None:
+        return [Finding("NM-BC-001", "warning", "board",
+                        "no barcode field: a square silkscreen frame with \"BC\" inside, "
+                        f"{LAYOUT['barcode_preferred_mm']:.0f} x {LAYOUT['barcode_preferred_mm']:.0f} mm "
+                        f"(at least {LAYOUT['barcode_min_mm']:.0f} mm), top side preferred", {})]
+    if best[0] + 1e-3 < LAYOUT["barcode_min_mm"]:
+        return [Finding("NM-BC-001", "warning", best[1],
+                        f"the barcode field is {best[0]:.1f} mm; "
+                        f"the house minimum is {LAYOUT['barcode_min_mm']:.0f} mm",
+                        {"side_mm": round(best[0], 2)})]
+    return []
+
+
+def check_layout(primitives: list[dict], pads: list[dict], components: list[dict], bodies: list[dict],
+                 outline: list[list[float]] | None) -> dict:
+    """Every house layout check on one board read through the drive (lengths in mm)."""
+    findings = (check_silkscreen(primitives, outline) + check_track_angles(primitives) + check_joins(primitives, pads)
+                + check_vias(primitives, pads) + check_models(bodies, components) + check_barcode(primitives))
+    return {
+        "policy": dict(LAYOUT),
+        "findings": [f.to_dict() for f in findings],
+        "passed": not any(f.severity == "error" for f in findings),
+    }