gitcad-ecad 0.7.7__py3-none-any.whl

gitcad/ecad/__init__.py

@@ -0,0 +1,34 @@
+"""gitcad-ecad — the electrical domain.
+
+v0.1 scope: a text-first board model plus the fabrication outputs that let a
+user actually order a PCB — Gerber X2 per layer, Excellon drill, pick-and-place.
+Schematic capture, ERC, and the full DRC engine follow (see
+docs/research/feature-map.md Part B).
+
+Like the mechanical document, the board is canonical text (ADR-0004): the
+model diffs and merges in git, and every generated output is deterministic —
+the same board text produces byte-identical Gerbers on any machine.
+"""
+
+from gitcad.ecad.board import Board, Component, Footprint, MountingHole, Pad, Track, Via, Zone
+from gitcad.ecad.fab import export_fab
+from gitcad.ecad.bom import bom, bom_csv, mpn_component
+from gitcad.ecad.component import footprint_from_part, footprint_to_part
+from gitcad.ecad.connectivity import check_connectivity
+from gitcad.ecad.drc import Rule, RulePack, default_rules, run_drc
+from gitcad.ecad.route import pad_position, route
+from gitcad.ecad.schematic import (Pin, SchComponent, Schematic, board_parity,
+                                   merge_schematics)
+from gitcad.ecad.envelope import check_envelopes, net_voltage, power_budget
+from gitcad.ecad.netderive import derive_nets, sheet_parity
+from gitcad.ecad.spice import sim_check, to_spice
+from gitcad.ecad.schsvg import schematic_to_svg
+
+__all__ = ["Board", "Component", "Footprint", "MountingHole", "Pad", "Track", "Via", "Zone",
+           "export_fab", "Schematic", "SchComponent", "Pin", "board_parity",
+           "Rule", "RulePack", "default_rules", "run_drc", "check_connectivity",
+           "pad_position", "route", "footprint_to_part", "footprint_from_part",
+           "mpn_component", "bom", "bom_csv", "schematic_to_svg",
+           "merge_schematics", "derive_nets", "sheet_parity",
+           "check_envelopes", "net_voltage", "power_budget",
+           "to_spice", "sim_check"]

gitcad/ecad/annotate.py

@@ -0,0 +1,63 @@
+"""schematic_annotate — deterministic reference numbering (KiCad-map P4).
+
+Components with placeholder refs (``R?``, ``U?`` — the KiCad convention)
+get the lowest free number for their prefix, in a deterministic order:
+sheet position (top-to-bottom, then left-to-right) when placements exist,
+declaration order otherwise. Existing numbered refs are never touched —
+annotation fills gaps, it does not reshuffle a reviewed design. Net pin
+references follow the renames atomically.
+"""
+
+from __future__ import annotations
+
+import re
+
+from gitcad.ecad.schematic import Schematic
+from gitcad.errors import GitcadError
+
+_REF = re.compile(r"^([A-Za-z_]+)(\?|\d+)$")
+
+
+def annotate(sch: Schematic) -> dict[str, str]:
+    """Assign numbers to ``?`` refs in place; returns {old_label: new_ref}
+    keyed by a positional label (``R?@2`` for the third placeholder R).
+
+    Nets may not reference placeholders — ``R?.1`` is ambiguous when two
+    unannotated Rs exist, so we refuse rather than guess: annotate first,
+    then connect (or connect by final refs)."""
+    for net, prs in sch.nets.items():
+        for pr in prs:
+            if "?" in pr.split(".", 1)[0]:
+                raise GitcadError(
+                    f"net {net!r} references placeholder ref {pr!r} — "
+                    "annotate before connecting, or connect by the final ref")
+    used: dict[str, set[int]] = {}
+    placeholders = []
+    decl_counter: dict[str, int] = {}
+    for i, comp in enumerate(sch.components):
+        m = _REF.match(comp.ref)
+        if not m:
+            raise GitcadError(f"unparseable ref {comp.ref!r} (want PREFIX+number or PREFIX?)")
+        prefix, num = m.groups()
+        if num == "?":
+            at = comp.attrs.get("at")
+            sort_key = (at[1], at[0], i) if at else (float("inf"), float("inf"), i)
+            k = decl_counter.get(prefix, 0)          # label by DECLARATION order
+            decl_counter[prefix] = k + 1
+            placeholders.append((prefix, sort_key, f"{prefix}?@{k}", comp))
+        else:
+            used.setdefault(prefix, set()).add(int(num))
+
+    renames: dict[str, str] = {}
+    counters: dict[str, int] = {}
+    # numbering order is READING order (top-to-bottom, left-to-right)
+    for prefix, _key, label, comp in sorted(placeholders, key=lambda p: (p[0], p[1])):
+        n = counters.get(prefix, 1)
+        taken = used.setdefault(prefix, set())
+        while n in taken:
+            n += 1
+        taken.add(n)
+        counters[prefix] = n + 1
+        renames[label] = f"{prefix}{n}"
+        comp.ref = f"{prefix}{n}"
+    return renames

gitcad/ecad/autoroute.py

@@ -0,0 +1,210 @@
+"""Autorouting assist v1 — a grid maze router for agents.
+
+Not push-and-shove: a deterministic BFS over a clearance-aware obstacle
+grid (Lee router), one net at a time, through-vias for layer changes.
+The result is ordinary Tracks/Vias appended to the board — the same
+check chain that gates hand routing (DRC, connectivity) gates this.
+Honest refusal: no path means ``autoroute-no-path``, never a
+rules-violating trace.
+
+Scope v1: routes between the net's pad centers on the outer layers (or
+any copper layer list you pass), rectilinear steps on a fixed grid.
+Pour-covered boards refuse fast — a pour IS the route.
+"""
+
+from __future__ import annotations
+
+from gitcad.ecad.board import Board, Track, Via
+from gitcad.errors import GitcadError
+
+
+def autoroute(board: Board, net: str, *, grid: float = 0.25,
+              width: float = 0.25, clearance: float = 0.2,
+              layers: tuple[str, ...] | None = None,
+              via_drill: float = 0.4, via_diameter: float = 0.8) -> dict:
+    """Route every pad of ``net`` into one connected tree. Returns
+    {"tracks": n, "vias": n}. Raises GitcadError when no path exists."""
+    copper = board.copper_layers()
+    layer_list = list(layers) if layers else ["top", "bottom"]
+    for ly in layer_list:
+        if ly not in copper:
+            raise GitcadError(f"unknown layer {ly!r}")
+
+    minx, miny, maxx, maxy = board.bbox()
+    nx = int((maxx - minx) / grid) + 1
+    ny = int((maxy - miny) / grid) + 1
+    if nx * ny > 1_500_000:
+        raise GitcadError(
+            f"autoroute grid {nx}x{ny} too large — coarsen `grid`")
+
+    def cell(x: float, y: float) -> tuple[int, int]:
+        return (round((x - minx) / grid), round((y - miny) / grid))
+
+    def pos(c: tuple[int, int]) -> tuple[float, float]:
+        return (minx + c[0] * grid, miny + c[1] * grid)
+
+    # -- obstacle rasterization (other-net copper, inflated) -------------------
+    # tracks need clearance + track half-width; via barrels are wider, so
+    # via placement checks a second grid with the bigger margin
+    margin = clearance + width / 2
+    margin_via = clearance + via_diameter / 2
+    blocked: list[set] = [set() for _ in layer_list]
+    blocked_via: list[set] = [set() for _ in layer_list]
+    li = {name: i for i, name in enumerate(layer_list)}
+
+    def block_disc(x: float, y: float, r: float, idxs) -> None:
+        for grid_set, mg in ((blocked, margin), (blocked_via, margin_via)):
+            rr = r + mg
+            c0x, c0y = cell(x - rr, y - rr)
+            c1x, c1y = cell(x + rr, y + rr)
+            for cx in range(max(0, c0x), min(nx, c1x + 1)):
+                for cy in range(max(0, c0y), min(ny, c1y + 1)):
+                    px, py = pos((cx, cy))
+                    if (px - x) ** 2 + (py - y) ** 2 <= rr * rr:
+                        for i in idxs:
+                            grid_set[i].add((cx, cy))
+
+    def block_seg(x1, y1, x2, y2, half_w, idx) -> None:
+        steps = max(1, int(((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 / grid) * 2)
+        for s in range(steps + 1):
+            t = s / steps
+            block_disc(x1 + (x2 - x1) * t, y1 + (y2 - y1) * t, half_w, [idx])
+
+    all_idx = list(range(len(layer_list)))
+    for comp in board.components:
+        for pad, bx, by, rot in comp.placed_pads():
+            if comp.nets.get(pad.name, "") == net:
+                continue
+            w, h = (pad.h, pad.w) if round(rot) % 180 == 90 else (pad.w, pad.h)
+            r = max(w, h) / 2
+            if pad.drill is not None:
+                block_disc(bx, by, r, all_idx)
+            elif comp.side in li:
+                block_disc(bx, by, r, [li[comp.side]])
+    for v in board.vias:
+        if v.net == net:
+            continue
+        sp = set(v.span(copper))
+        idxs = [li[ly] for ly in layer_list if ly in sp] or all_idx
+        block_disc(v.x, v.y, v.diameter / 2, idxs)
+    for t in board.tracks:
+        if t.net == net or t.layer not in li:
+            continue
+        block_seg(t.x1, t.y1, t.x2, t.y2, t.width / 2, li[t.layer])
+    for z in board.zones:
+        if z.kind == "keepout":
+            xs = [p[0] for p in z.polygon]
+            ys = [p[1] for p in z.polygon]
+            for ly in ([z.layer] if z.layer in li else []):
+                c0, c1 = cell(min(xs), min(ys)), cell(max(xs), max(ys))
+                for cx in range(max(0, c0[0]), min(nx, c1[0] + 1)):
+                    for cy in range(max(0, c0[1]), min(ny, c1[1] + 1)):
+                        blocked[li[ly]].add((cx, cy))
+        elif z.kind == "copper" and z.net != net and z.layer in li:
+            xs = [p[0] for p in z.polygon]
+            ys = [p[1] for p in z.polygon]
+            c0, c1 = cell(min(xs), min(ys)), cell(max(xs), max(ys))
+            for cx in range(max(0, c0[0]), min(nx, c1[0] + 1)):
+                for cy in range(max(0, c0[1]), min(ny, c1[1] + 1)):
+                    blocked[li[z.layer]].add((cx, cy))
+
+    # -- terminals -------------------------------------------------------------
+    terminals: list[tuple[tuple[int, int], int]] = []   # (cell, layer idx)
+    for comp in board.components:
+        for pad, bx, by, _rot in comp.placed_pads():
+            if comp.nets.get(pad.name, "") != net:
+                continue
+            if pad.drill is not None:
+                terminals.append((cell(bx, by), 0))
+            elif comp.side in li:
+                terminals.append((cell(bx, by), li[comp.side]))
+    if len(terminals) < 2:
+        raise GitcadError(f"net {net!r} has fewer than 2 routable pads")
+
+    # -- sequential Lee routing ------------------------------------------------
+    tree: set[tuple[int, int, int]] = set()
+    first_cell, first_li = terminals[0]
+    tree.add((first_cell[0], first_cell[1], first_li))
+    tracks_added = vias_added = 0
+
+    for term_cell, term_li in terminals[1:]:
+        start = (term_cell[0], term_cell[1], term_li)
+        if start in tree:
+            continue
+        import heapq
+
+        prev: dict = {start: None}
+        dist: dict = {start: 0}
+        heap: list[tuple[int, tuple]] = [(0, start)]
+        via_cost = max(1, int(3.0 / grid))              # a via "costs" ~3 mm
+        goal = None
+        while heap:
+            d, cur = heapq.heappop(heap)
+            if d > dist.get(cur, 1 << 30):
+                continue
+            if cur in tree:
+                goal = cur
+                break
+            cx, cy, cl = cur
+            steps = [((cx + 1, cy, cl), 1), ((cx - 1, cy, cl), 1),
+                     ((cx, cy + 1, cl), 1), ((cx, cy - 1, cl), 1)]
+            for other in range(len(layer_list)):        # through-via move
+                if other != cl:
+                    steps.append(((cx, cy, other), via_cost))
+            for nxt, cost in steps:
+                tx, ty, tl = nxt
+                if not (0 <= tx < nx and 0 <= ty < ny):
+                    continue
+                if tl != cl:                            # via: all layers clear
+                    if any((tx, ty) in blocked_via[i]
+                           for i in range(len(layer_list))):
+                        continue
+                elif (tx, ty) in blocked[tl]:
+                    continue
+                nd = d + cost
+                if nd < dist.get(nxt, 1 << 30):
+                    dist[nxt] = nd
+                    prev[nxt] = cur
+                    heapq.heappush(heap, (nd, nxt))
+        if goal is None:
+            raise GitcadError(f"autoroute-no-path:{net}")
+
+        # walk back, merging straight runs into tracks
+        path = []
+        n_ = goal
+        while n_ is not None:
+            path.append(n_)
+            n_ = prev[n_]
+        run_start = path[0]
+        for a, b in zip(path, path[1:]):
+            if a[2] != b[2]:                            # layer change: via at a
+                if run_start[:2] != a[:2]:
+                    _emit(board, pos(run_start[:2]), pos(a[:2]),
+                          layer_list[a[2]], width, net)
+                    tracks_added += 1
+                board.vias.append(Via(*pos(a[:2]), drill=via_drill,
+                                      diameter=via_diameter, net=net))
+                vias_added += 1
+                run_start = b
+            elif _turns(run_start, a, b):
+                _emit(board, pos(run_start[:2]), pos(a[:2]),
+                      layer_list[a[2]], width, net)
+                tracks_added += 1
+                run_start = a
+        last = path[-1]
+        if run_start[:2] != last[:2]:
+            _emit(board, pos(run_start[:2]), pos(last[:2]),
+                  layer_list[last[2]], width, net)
+            tracks_added += 1
+        tree.update(path)
+
+    return {"tracks": tracks_added, "vias": vias_added}
+
+
+def _turns(run_start, a, b) -> bool:
+    return ((b[0] - run_start[0]) * (a[1] - run_start[1])
+            != (b[1] - run_start[1]) * (a[0] - run_start[0]))
+
+
+def _emit(board: Board, p1, p2, layer: str, width: float, net: str) -> None:
+    board.tracks.append(Track(p1[0], p1[1], p2[0], p2[1], width, layer, net))

gitcad/ecad/board.py

@@ -0,0 +1,356 @@
+"""The board model — text-first, deterministic, minimal but fab-complete.
+
+Coordinates are mm, origin bottom-left, y up (same convention as the drawing
+sheet). Rotation is degrees CCW. Sides are "top"/"bottom".
+
+Pads live on footprints; a Component instance places a footprint at (x, y, rot,
+side) — pad positions in board space are computed, never stored, so moving a
+component is a one-line diff (ADR-0004: derived data is never source).
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import re
+from dataclasses import asdict, dataclass, field
+
+from gitcad.canonical import canonical_json
+from gitcad.errors import GitcadError, ValidationReport
+
+
+@dataclass
+class Pad:
+    name: str
+    x: float                     # relative to footprint origin
+    y: float
+    w: float
+    h: float
+    shape: str = "rect"          # rect | circle | obround
+    drill: float | None = None   # None = SMD; a value = plated through hole
+    net: str = ""                # assigned per-instance via Component.nets
+
+
+@dataclass
+class Footprint:
+    name: str
+    pads: list[Pad] = field(default_factory=list)
+    courtyard: tuple[float, float] | None = None   # (w, h) centered on origin
+    height: float | None = None    # body height mm (IDF-style envelope; None = unknown)
+
+
+@dataclass
+class Component:
+    ref: str                     # designator, e.g. "R1"
+    footprint: Footprint
+    value: str = ""
+    x: float = 0.0
+    y: float = 0.0
+    rot: float = 0.0
+    side: str = "top"
+    nets: dict[str, str] = field(default_factory=dict)   # pad name -> net name
+
+    def placed_pads(self) -> list[tuple[Pad, float, float, float]]:
+        """Yield (pad, board_x, board_y, rotation) for each pad, with the
+        component's placement applied. Bottom-side placement mirrors X."""
+        out = []
+        cos, sin = math.cos(math.radians(self.rot)), math.sin(math.radians(self.rot))
+        for pad in self.footprint.pads:
+            px, py = pad.x, pad.y
+            if self.side == "bottom":
+                px = -px
+            bx = self.x + px * cos - py * sin
+            by = self.y + px * sin + py * cos
+            out.append((pad, bx, by, self.rot))
+        return out
+
+
+@dataclass
+class Track:
+    x1: float
+    y1: float
+    x2: float
+    y2: float
+    width: float
+    layer: str = "top"           # top | bottom
+    net: str = ""
+
+
+@dataclass
+class Via:
+    """A plated barrel connecting copper layers. ``layer_from``/``layer_to``
+    are the outermost copper layers the barrel touches, ordered outside-in
+    (top before in1 before ... before bottom). The defaults make a classic
+    through via; anything narrower is a blind via (touches exactly one outer
+    surface) or a buried via (touches neither)."""
+    x: float
+    y: float
+    drill: float = 0.4
+    diameter: float = 0.8
+    net: str = ""
+    layer_from: str = "top"
+    layer_to: str = "bottom"
+
+    def span(self, copper_layers: list[str]) -> list[str]:
+        """Copper layers this barrel touches, outside-in — or [] when the
+        span doesn't resolve in this stack (validate() reports which)."""
+        try:
+            i = copper_layers.index(self.layer_from)
+            j = copper_layers.index(self.layer_to)
+        except ValueError:
+            return []
+        return copper_layers[i:j + 1] if i < j else []
+
+    def kind(self, copper_layers: list[str]) -> str:
+        """through | blind | buried | invalid — derived, never stored."""
+        s = self.span(copper_layers)
+        if not s:
+            return "invalid"
+        outer = (s[0] == copper_layers[0], s[-1] == copper_layers[-1])
+        if all(outer):
+            return "through"
+        return "blind" if any(outer) else "buried"
+
+
+@dataclass
+class Zone:
+    """A zone: closed polygon on one layer. ``kind`` (KiCad-map P2):
+
+    - ``copper`` (default): a pour tied to a net — the real Altair board is
+      routed almost entirely with these.
+    - ``keepout``: a rule area FORBIDDING copper — tracks, vias, and copper
+      zones intersecting it are DRC violations; it never emits to Gerber
+      and never conducts. ``net`` is meaningless for keepouts ("")."""
+    net: str
+    layer: str                          # top | bottom
+    polygon: list[tuple[float, float]]  # closed (first != last is fine)
+    kind: str = "copper"                # copper | keepout
+
+
+# ISO 273 clearance drills -> thread (medium + close fits). Exact matches
+# only: an unrecognized drill honestly yields no thread spec, and the
+# fastener generator will report it rather than guess (dogfood finding
+# 2026-07-23: the real Altair board's 2.7mm holes are M2.5 clearance).
+_CLEARANCE_THREADS = {
+    2.2: "M2", 2.4: "M2.2", 2.7: "M2.5", 3.2: "M3", 3.4: "M3",
+    4.3: "M4", 4.5: "M4", 5.3: "M5", 5.5: "M5", 6.4: "M6", 6.6: "M6",
+}
+
+
+def _thread_from_clearance(drill: float) -> str | None:
+    return _CLEARANCE_THREADS.get(round(drill, 1))
+
+
+@dataclass
+class MountingHole:
+    """A non-plated mounting hole — and, equally, a published mech interface:
+    every mounting hole becomes a `mech.bolt` port in the board's part.json
+    (ADR-0008), which is what the enclosure mates against."""
+    name: str            # port name, e.g. "mnt_1"
+    x: float
+    y: float
+    drill: float         # NPTH diameter
+    thread: str | None = None   # clearance for e.g. "M3" — informational spec
+
+
+@dataclass
+class Board:
+    """A complete board: 2 copper layers by default, up to 16 (``layers``).
+    Copper layer names: ``top``, ``in1``..``in{n-2}``, ``bottom``. Vias
+    default to through-hole; a narrower ``layer_from``/``layer_to`` span
+    makes them blind or buried (every consumer — Gerber, drill, DRC,
+    connectivity, IPC-2581 — honors the span)."""
+
+    name: str
+    outline: list[tuple[float, float]]   # closed polygon (first != last is fine)
+    components: list[Component] = field(default_factory=list)
+    tracks: list[Track] = field(default_factory=list)
+    vias: list[Via] = field(default_factory=list)
+    zones: list[Zone] = field(default_factory=list)
+    mounting_holes: list[MountingHole] = field(default_factory=list)
+    thickness: float = 1.6               # mm — board stack height
+    mask_expansion: float = 0.05         # mm per side
+    layers: int = 2                      # copper layer count (2..16)
+    # Net classes: named net groups binding DRC constraints (KiCad-map P1).
+    # {"power": {"nets": ["VCC", "GND", "+*"], "clearance": 0.3,
+    #            "track_width_min": 0.5}} — nets may be fnmatch globs; DRC
+    # expands each class into net-scoped rules that OVERRIDE the pack's
+    # defaults for matching nets.
+    net_classes: dict[str, dict] = field(default_factory=dict)
+
+    SCHEMA = "gitcad/board@1"
+
+    # -- canonical text (the git-diffable source) -----------------------------
+
+    def dumps(self) -> str:
+        doc = {"schema": self.SCHEMA, "board": asdict(self)}
+        return canonical_json(doc, indent=2) + "\n"
+
+    @classmethod
+    def loads(cls, text: str) -> "Board":
+        doc = json.loads(text)
+        if doc.get("schema") != cls.SCHEMA:
+            raise GitcadError(f"unsupported board schema {doc.get('schema')!r}")
+        b = doc["board"]
+        return cls(
+            name=b["name"],
+            outline=[tuple(p) for p in b["outline"]],
+            components=[
+                Component(
+                    ref=c["ref"],
+                    footprint=Footprint(
+                        name=c["footprint"]["name"],
+                        pads=[Pad(**p) for p in c["footprint"]["pads"]],
+                        courtyard=tuple(c["footprint"]["courtyard"]) if c["footprint"]["courtyard"] else None,
+                        height=c["footprint"].get("height"),
+                    ),
+                    value=c["value"], x=c["x"], y=c["y"], rot=c["rot"], side=c["side"],
+                    nets=dict(c["nets"]),
+                )
+                for c in b["components"]
+            ],
+            tracks=[Track(**t) for t in b["tracks"]],
+            vias=[Via(**v) for v in b["vias"]],
+            zones=[Zone(net=z["net"], layer=z["layer"],
+                        polygon=[tuple(p) for p in z["polygon"]],
+                        kind=z.get("kind", "copper"))
+                   for z in b.get("zones", [])],
+            mounting_holes=[MountingHole(**m) for m in b.get("mounting_holes", [])],
+            thickness=b.get("thickness", 1.6),
+            mask_expansion=b.get("mask_expansion", 0.05),
+            layers=int(b.get("layers", 2)),
+            net_classes={k: dict(v) for k, v in b.get("net_classes", {}).items()},
+        )
+
+    def copper_layers(self) -> list[str]:
+        """Layer names outside-in: top, in1..in{n-2}, bottom."""
+        return (["top"] + [f"in{i}" for i in range(1, self.layers - 1)]
+                + ["bottom"])
+
+    # -- checks (the agent verification loop) ---------------------------------
+
+    def bbox(self) -> tuple[float, float, float, float]:
+        xs = [x for x, _ in self.outline]
+        ys = [y for _, y in self.outline]
+        return (min(xs), min(ys), max(xs), max(ys))
+
+    def validate(self) -> ValidationReport:
+        """Fab-readiness checks, machine-readable. Not a full DRC yet — the
+        checks that make a fab reject the files outright."""
+        violations: list[str] = []
+        # Filesystem-safe name: fab filenames derive from it, and the board
+        # text can arrive via MCP from untrusted sources (path traversal was
+        # flagged in the 2026-07-22 review).
+        if not re.fullmatch(r"[A-Za-z0-9._-]+", self.name) or ".." in self.name:
+            violations.append("board-name-not-filesystem-safe")
+        if len(self.outline) < 3:
+            violations.append("outline-degenerate")
+        if not (2 <= self.layers <= 16):
+            violations.append(f"layers-out-of-range:{self.layers}")
+        valid_layers = set(self.copper_layers())
+        minx, miny, maxx, maxy = self.bbox()
+        refs = [c.ref for c in self.components]
+        if len(refs) != len(set(refs)):
+            violations.append("components-duplicate-refs")
+        for comp in self.components:
+            # v0.1 writers can only render right-angle rotations; anything else
+            # would emit wrong copper silently — reject at the fab gate.
+            if round(comp.rot) % 90 != 0:
+                violations.append(f"rotation-not-multiple-of-90:{comp.ref}")
+            for pad, bx, by, _ in comp.placed_pads():
+                if not (minx <= bx <= maxx and miny <= by <= maxy):
+                    violations.append(f"pad-outside-outline:{comp.ref}.{pad.name}")
+                if pad.drill is not None and pad.drill >= min(pad.w, pad.h):
+                    violations.append(f"drill-exceeds-pad:{comp.ref}.{pad.name}")
+        copper_names = self.copper_layers()
+        for i, via in enumerate(self.vias):
+            if via.drill >= via.diameter:
+                violations.append(f"via-drill-exceeds-diameter:{i}")
+            if via.layer_from not in valid_layers or via.layer_to not in valid_layers:
+                violations.append(f"via-bad-layer:{i}")
+            elif not via.span(copper_names):
+                violations.append(f"via-span-inverted:{i}")
+        for i, t in enumerate(self.tracks):
+            if t.width <= 0:
+                violations.append(f"track-zero-width:{i}")
+            if (t.x1, t.y1) == (t.x2, t.y2):
+                # a zero-length track slipped through in the dogfood build
+                violations.append(f"track-degenerate:{i}")
+            if t.layer not in valid_layers:
+                violations.append(f"track-bad-layer:{i}")
+        for i, z in enumerate(self.zones):
+            if len(z.polygon) < 3:
+                violations.append(f"zone-degenerate:{i}")
+            if z.layer not in valid_layers:
+                violations.append(f"zone-bad-layer:{i}")
+            if z.kind not in ("copper", "keepout"):
+                violations.append(f"zone-bad-kind:{i}")
+            if z.kind == "keepout" and z.net:
+                violations.append(f"keepout-with-net:{i}")
+        for cname, spec in sorted(self.net_classes.items()):
+            nets = spec.get("nets")
+            if not nets or not all(isinstance(n, str) and n for n in nets):
+                violations.append(f"netclass-empty-nets:{cname}")
+            for key in spec:
+                if key == "nets":
+                    continue
+                if key not in ("clearance", "track_width_min"):
+                    violations.append(f"netclass-unknown-param:{cname}:{key}")
+                elif not isinstance(spec[key], (int, float)) or spec[key] <= 0:
+                    violations.append(f"netclass-bad-value:{cname}:{key}")
+        hole_names = [m.name for m in self.mounting_holes]
+        if len(hole_names) != len(set(hole_names)):
+            violations.append("mounting-holes-duplicate-names")
+        for m in self.mounting_holes:
+            if not (minx <= m.x <= maxx and miny <= m.y <= maxy):
+                violations.append(f"mounting-hole-outside-outline:{m.name}")
+            if m.drill <= 0:
+                violations.append(f"mounting-hole-zero-drill:{m.name}")
+        return ValidationReport(
+            ok=not violations,
+            checks={"components": len(self.components), "tracks": len(self.tracks),
+                    "vias": len(self.vias), "zones": len(self.zones),
+                    "mounting_holes": len(self.mounting_holes)},
+            violations=violations,
+        )
+
+    # -- the derived part interface (ADR-0008: domain wiring) -----------------
+
+    def to_part(self, part_id: str, version: str = "0.1.0",
+                *, schematics: list[str] | None = None):
+        """Derive this board's PCBA part from its actual geometry — the
+        Fusion-360 duality: from the OUTSIDE this is a mechanical part
+        (envelope from outline bbox × thickness, one frame + ``mech.bolt``
+        port per mounting hole, a 3D body via the bridge); ENTERING it is
+        the electrical workflow (the referenced board + schematics, checked
+        by the pcba suite). Nothing hand-authored — change the board, and
+        the interface (interface-semver, ADR-0009) follows.
+
+        ``schematics`` lists the schematic files (ADR-0017 names) that are
+        this PCBA's electrical source; pass them and the part is a full
+        PCBA, omit them and it is a bare board part."""
+        from gitcad.part import Frame, Interface, PartManifest, Port
+
+        minx, miny, maxx, maxy = self.bbox()
+        frames = {"origin": Frame()}
+        ports = {}
+        for m in self.mounting_holes:
+            frames[m.name] = Frame(origin=(m.x, m.y, 0.0))
+            spec: dict = {"drill": m.drill}
+            thread = m.thread or _thread_from_clearance(m.drill)
+            if thread:
+                spec["thread"] = thread
+            ports[m.name] = Port(m.name, "mech.bolt", m.name, spec)
+        body: dict = {"kind": "pcba", "board": f"{self.name}.board"}
+        if schematics:
+            body["schematics"] = sorted(schematics)
+        return PartManifest(
+            id=part_id, name=self.name, domain="ecad", version=version,
+            interface=Interface(
+                envelope={"origin": [minx, miny, 0.0],
+                          "dx": maxx - minx, "dy": maxy - miny, "dz": self.thickness},
+                frames=frames, ports=ports,
+                properties={"layers": 2, "components": len(self.components)},
+            ),
+            body=body,
+        )