gitcad 0.7.7__py3-none-any.whl

gitcad/merge3.py

@@ -0,0 +1,289 @@
+"""Semantic 3-way merge for design documents (ADR-0016).
+
+Merge units are semantic, keyed by stable identity: features by id for
+models, components by ref and connectivity by PIN for schematics. Both
+sides touching different units merges cleanly; both sides changing the
+same unit differently is a structured conflict — never a text marker
+inside canonical JSON (that would make the file unparseable for every
+tool including the resolver).
+
+Result contract: ``{"ok": bool, "merged": text|None, "conflicts": [...]}``.
+A clean merge's output is re-parsed through the document's own loader
+before being returned — a merge that doesn't rebuild is a driver bug,
+never shipped state.
+"""
+
+from __future__ import annotations
+
+import json
+
+from gitcad.canonical import canonical_json
+from gitcad.release import _kind
+
+
+def _cell3(base, ours, theirs):
+    """Classic 3-way cell. Values are canonical strings (None = absent).
+    Returns ("take", value) or ("conflict", ours, theirs)."""
+    if ours == theirs:
+        return ("take", ours)
+    if ours == base:
+        return ("take", theirs)
+    if theirs == base:
+        return ("take", ours)
+    return ("conflict", ours, theirs)
+
+
+def merge_documents(base: str, ours: str, theirs: str) -> dict:
+    kind_b = _kind(base)
+    if not (_kind(ours) == _kind(theirs) == kind_b):
+        return {"ok": False, "merged": None, "conflicts": [
+            {"unit": "document", "reason": "kind changed between branches"}]}
+    if kind_b == "document":
+        return _merge_model(base, ours, theirs)
+    if kind_b == "schematic":
+        return _merge_schematic(base, ours, theirs)
+    if kind_b == "board":
+        return _merge_board(base, ours, theirs)
+    # parts: whole-document 3-way, honest coarse fallback (ADR-0016)
+    verdict = _cell3(base, ours, theirs)
+    if verdict[0] == "take":
+        return {"ok": True, "merged": verdict[1], "conflicts": []}
+    return {"ok": False, "merged": None, "conflicts": [
+        {"unit": kind_b, "reason": "both branches changed this document "
+         "(fine-grained merge for this kind is a later stage)"}]}
+
+
+# -- boards: refs/names are identity; copper's CONTENT is its identity --------
+
+def _merge_board(base: str, ours: str, theirs: str) -> dict:
+    """Fine-grained board merge (ADR-0016 upgrade):
+
+    - components by ref, mounting holes by name, net classes by class name —
+      classic 3-way cells (both changed differently = conflict);
+    - tracks/vias/zones have no stable id, and don't need one: their content
+      IS their identity, so they merge as element SETS — a moved track is a
+      removal plus an addition and merges cleanly; the only way to conflict
+      is at the named units above (or the outline, a whole-value cell);
+    - outline/thickness/mask_expansion: whole-value cells.
+    """
+    from gitcad.ecad.board import Board
+
+    bb, bo, bt = (Board.loads(x) for x in (base, ours, theirs))
+    conflicts: list[dict] = []
+
+    def keyed_merge(unit: str, base_map: dict, ours_map: dict, theirs_map: dict,
+                    canon) -> dict:
+        out = {}
+        for k in {**base_map, **ours_map, **theirs_map}:
+            verdict = _cell3(canon(base_map.get(k)), canon(ours_map.get(k)),
+                             canon(theirs_map.get(k)))
+            if verdict[0] == "conflict":
+                side = lambda v: json.loads(v) if v else None  # noqa: E731
+                conflicts.append({"unit": unit, "key": k,
+                                  "ours": side(verdict[1]),
+                                  "theirs": side(verdict[2])})
+            elif verdict[1] is not None:
+                out[k] = json.loads(verdict[1])
+        return out
+
+    from dataclasses import asdict
+
+    canon_d = lambda x: canonical_json(asdict(x)) if x is not None else None  # noqa: E731
+    comps = keyed_merge("component",
+                        {c.ref: c for c in bb.components},
+                        {c.ref: c for c in bo.components},
+                        {c.ref: c for c in bt.components}, canon_d)
+    holes = keyed_merge("mounting_hole",
+                        {m.name: m for m in bb.mounting_holes},
+                        {m.name: m for m in bo.mounting_holes},
+                        {m.name: m for m in bt.mounting_holes}, canon_d)
+    canon_j = lambda x: canonical_json(x) if x is not None else None  # noqa: E731
+    classes = keyed_merge("net_class", bb.net_classes, bo.net_classes,
+                          bt.net_classes, canon_j)
+
+    def element_set(unit: str, base_l: list, ours_l: list, theirs_l: list) -> list:
+        b_set = {canonical_json(asdict(x)) for x in base_l}
+        o_set = {canonical_json(asdict(x)) for x in ours_l}
+        t_set = {canonical_json(asdict(x)) for x in theirs_l}
+        # element-wise 3-way: keep if (in base and neither side removed it)
+        # or (added by either side)
+        kept = ((b_set & o_set & t_set)
+                | (o_set - b_set) | (t_set - b_set))
+        return [json.loads(x) for x in sorted(kept)]
+
+    tracks = element_set("track", bb.tracks, bo.tracks, bt.tracks)
+    vias = element_set("via", bb.vias, bo.vias, bt.vias)
+    zones = element_set("zone", bb.zones, bo.zones, bt.zones)
+
+    scalars = {}
+    for attr in ("name", "outline", "thickness", "mask_expansion"):
+        verdict = _cell3(canonical_json(getattr(bb, attr)),
+                         canonical_json(getattr(bo, attr)),
+                         canonical_json(getattr(bt, attr)))
+        if verdict[0] == "conflict":
+            conflicts.append({"unit": attr,
+                              "ours": json.loads(verdict[1]),
+                              "theirs": json.loads(verdict[2])})
+        else:
+            scalars[attr] = json.loads(verdict[1])
+
+    if conflicts:
+        return {"ok": False, "merged": None, "conflicts": conflicts}
+
+    merged_doc = {"schema": Board.SCHEMA, "board": {
+        **scalars,
+        "components": [comps[k] for k in sorted(comps)],
+        "tracks": tracks, "vias": vias, "zones": zones,
+        "mounting_holes": [holes[k] for k in sorted(holes)],
+        "net_classes": classes,
+    }}
+    text = canonical_json(merged_doc, indent=2) + "\n"
+    Board.loads(text)   # the rebuild gate
+    return {"ok": True, "merged": text, "conflicts": []}
+
+
+# -- models: features by stable id --------------------------------------------
+
+def _merge_model(base: str, ours: str, theirs: str) -> dict:
+    from gitcad.document import Document
+
+    b = {f.id: f for f in Document.loads(base).features}
+    o = {f.id: f for f in Document.loads(ours).features}
+    t = {f.id: f for f in Document.loads(theirs).features}
+    canon = lambda f: canonical_json(f.to_dict()) if f else None  # noqa: E731
+
+    conflicts: list[dict] = []
+    keep: dict[str, dict] = {}
+    for fid in {**b, **o, **t}:
+        verdict = _cell3(canon(b.get(fid)), canon(o.get(fid)), canon(t.get(fid)))
+        if verdict[0] == "conflict":
+            side = lambda v: json.loads(v) if v else None  # noqa: E731
+            conflicts.append({"unit": "feature", "id": fid,
+                              "op": (o.get(fid) or t.get(fid) or b.get(fid)).op,
+                              "ours": side(verdict[1]), "theirs": side(verdict[2])})
+        elif verdict[1] is not None:
+            keep[fid] = json.loads(verdict[1])
+    if conflicts:
+        return {"ok": False, "merged": None, "conflicts": conflicts}
+
+    # Order: base survivors, then ours-added, then theirs-added…
+    order = [fid for fid in b if fid in keep]
+    order += [fid for fid in o if fid in keep and fid not in b]
+    order += [fid for fid in t if fid in keep and fid not in b and fid not in o]
+    # …then a stable topological pass so inputs precede their users.
+    placed: list[str] = []
+    ready: set[str] = set()
+    pending = list(order)
+    while pending:
+        progressed = False
+        for fid in list(pending):
+            if all(ref in ready for ref in keep[fid].get("inputs", [])):
+                placed.append(fid)
+                ready.add(fid)
+                pending.remove(fid)
+                progressed = True
+        if not progressed:
+            return {"ok": False, "merged": None, "conflicts": [
+                {"unit": "feature", "id": pending[0],
+                 "reason": "input dependency cycle or input deleted by the "
+                           "other branch"}]}
+    merged_text = canonical_json(
+        {"schema": "gitcad/document@1",
+         "features": [keep[fid] for fid in placed]}, indent=2) + "\n"
+    Document.loads(merged_text)   # the rebuild gate: must parse or we crash here
+    return {"ok": True, "merged": merged_text, "conflicts": []}
+
+
+# -- schematics: components by ref, connectivity by pin -----------------------
+
+def _pin_map(sch) -> dict[str, str]:
+    return {pr: net for net, prs in sch.nets.items() for pr in prs}
+
+
+def _merge_schematic(base: str, ours: str, theirs: str) -> dict:
+    from gitcad.ecad.schematic import Schematic
+
+    sb, so, st = (Schematic.loads(x) for x in (base, ours, theirs))
+    canon = lambda c: canonical_json(  # noqa: E731
+        {"ref": c.ref, "value": c.value, "footprint": c.footprint,
+         "pins": [p.__dict__ for p in c.pins], "attrs": c.attrs}) if c else None
+
+    conflicts: list[dict] = []
+    comps: dict[str, dict] = {}
+    cb = {c.ref: c for c in sb.components}
+    co = {c.ref: c for c in so.components}
+    ct = {c.ref: c for c in st.components}
+    for ref in {**cb, **co, **ct}:
+        verdict = _cell3(canon(cb.get(ref)), canon(co.get(ref)), canon(ct.get(ref)))
+        if verdict[0] == "conflict":
+            side = lambda v: json.loads(v) if v else None  # noqa: E731
+            conflicts.append({"unit": "component", "ref": ref,
+                              "ours": side(verdict[1]), "theirs": side(verdict[2])})
+        elif verdict[1] is not None:
+            comps[ref] = json.loads(verdict[1])
+
+    pb, po, pt = _pin_map(sb), _pin_map(so), _pin_map(st)
+    pins: dict[str, str] = {}
+    for pr in {**pb, **po, **pt}:
+        verdict = _cell3(pb.get(pr), po.get(pr), pt.get(pr))
+        if verdict[0] == "conflict":
+            conflicts.append({"unit": "pin", "pin": pr,
+                              "ours": verdict[1], "theirs": verdict[2]})
+        elif verdict[1] is not None and pr.split(".", 1)[0] in comps:
+            pins[pr] = verdict[1]
+
+    specs: dict[str, dict] = {}
+    for key in {**sb.net_specs, **so.net_specs, **st.net_specs}:
+        cj = lambda d: canonical_json(d) if d is not None else None  # noqa: E731
+        verdict = _cell3(cj(sb.net_specs.get(key)), cj(so.net_specs.get(key)),
+                         cj(st.net_specs.get(key)))
+        if verdict[0] == "conflict":
+            conflicts.append({"unit": "net_spec", "net": key,
+                              "ours": verdict[1], "theirs": verdict[2]})
+        elif verdict[1] is not None:
+            specs[key] = json.loads(verdict[1])
+
+    if conflicts:
+        return {"ok": False, "merged": None, "conflicts": conflicts}
+
+    name3 = _cell3(sb.name, so.name, st.name)
+    merged = Schematic(name=name3[1] if name3[0] == "take" else so.name)
+    from gitcad.ecad.schematic import Pin, SchComponent
+
+    for ref in sorted(comps):
+        c = comps[ref]
+        merged.components.append(SchComponent(
+            ref=c["ref"], value=c["value"], footprint=c["footprint"],
+            pins=[Pin(**p) for p in c["pins"]], attrs=c["attrs"]))
+    for pr, net in pins.items():
+        merged.connect(net, pr)
+    merged.net_specs = specs
+    text = merged.dumps()
+    Schematic.loads(text)   # the rebuild gate
+    return {"ok": True, "merged": text, "conflicts": []}
+
+
+def main() -> None:  # pragma: no cover - git merge driver entrypoint
+    """git merge driver: gitcad-merge %O %A %B — result written to %A.
+
+    .gitattributes:  *.gitcad.json merge=gitcad
+    .git/config:     [merge "gitcad"]
+                       name = gitcad semantic merge
+                       driver = gitcad-merge %O %A %B
+    """
+    import sys
+    from pathlib import Path
+
+    base_p, ours_p, theirs_p = (Path(p) for p in sys.argv[1:4])
+    result = merge_documents(base_p.read_text(encoding="utf-8"),
+                             ours_p.read_text(encoding="utf-8"),
+                             theirs_p.read_text(encoding="utf-8"))
+    if result["ok"]:
+        ours_p.write_text(result["merged"], encoding="utf-8")
+        sys.exit(0)
+    report = ours_p.with_suffix(ours_p.suffix + ".gitcad-conflict.json")
+    report.write_text(canonical_json({"conflicts": result["conflicts"]},
+                                     indent=2) + "\n", encoding="utf-8")
+    print(f"gitcad-merge: {len(result['conflicts'])} semantic conflict(s) — "
+          f"see {report.name}", file=sys.stderr)
+    sys.exit(1)

gitcad/pcba.py

@@ -0,0 +1,114 @@
+"""PCBA parts — the Fusion-360 duality, gitcad-style.
+
+At the assembly level a PCBA is a mechanical part: envelope, mounting-hole
+ports, a 3D body. ``pcba_verify`` is what "entering" it means for checks —
+one call runs the complete electrical workflow gate over the part's
+referenced sources:
+
+- ERC + electrical envelopes (ADR-0015) per schematic
+- board validation + DRC + copper connectivity
+- schematic↔board parity (the ECO check) for every schematic
+
+The part manifest is the front door; the electrical truth lives in the
+files it references, exactly like a mech part references its .model.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from gitcad.errors import GitcadError
+
+
+def is_pcba(part_text: str) -> bool:
+    try:
+        doc = json.loads(part_text)
+    except Exception:
+        return False
+    return (doc.get("schema", "").startswith("gitcad/part")
+            and (doc.get("body") or {}).get("kind") == "pcba")
+
+
+def pcba_sources(part_text: str, root: str) -> dict:
+    """Resolve the PCBA's referenced files: {"board": Path, "schematics": [Path]}."""
+    from gitcad.part import PartManifest
+
+    part = PartManifest.loads(part_text)
+    body = part.body or {}
+    if body.get("kind") != "pcba":
+        raise GitcadError(f"part {part.name!r} is not a pcba (body.kind="
+                          f"{body.get('kind')!r})")
+    rootp = Path(root)
+    board = rootp / body.get("board", "")
+    if not body.get("board") or not board.is_file():
+        raise GitcadError(f"pcba board file missing: {body.get('board')!r}")
+    schematics = []
+    for rel in body.get("schematics", []):
+        p = rootp / rel
+        if not p.is_file():
+            raise GitcadError(f"pcba schematic file missing: {rel!r}")
+        schematics.append(p)
+    return {"part": part, "board": board, "schematics": schematics}
+
+
+def pcba_verify(part_text: str, root: str) -> dict:
+    """The electrical workflow's gate, as one call.
+
+    Multi-schematic semantics: a board's netlist can span many sheets, so
+    ERC, envelopes, and parity run on the MERGED system schematic (nets
+    union by name — the cross-sheet contract, ADR proved on the real
+    4-sheet Altair where per-sheet checks flag inter-sheet signals as
+    false positives). Per-sheet checks would lie; the merged system is
+    the electrical truth of this PCBA. Coverage is honest: zero referenced
+    schematics is visible, never silently green."""
+    from gitcad.ecad import (Board, Schematic, board_parity, check_connectivity,
+                             check_envelopes, merge_schematics)
+    from gitcad.ecad.drc import run_drc
+
+    src = pcba_sources(part_text, root)
+    board = Board.loads(src["board"].read_text(encoding="utf-8"))
+    checks: dict = {}
+    violations: list[str] = []
+
+    r = board.validate()
+    checks["board:validate"] = "ok" if r.ok else "FAIL"
+    violations += [f"board:{v}" for v in r.violations]
+    d = run_drc(board)
+    checks["board:drc"] = "ok" if d.ok else "FAIL"
+    violations += [f"drc:{v}" for v in d.violations]
+    c = check_connectivity(board)
+    checks["board:connectivity"] = "ok" if c.ok else "FAIL"
+    violations += [f"connectivity:{v}" for v in c.violations]
+
+    sheets = [Schematic.loads(p.read_text(encoding="utf-8"))
+              for p in src["schematics"]]
+    if sheets:
+        system = sheets[0] if len(sheets) == 1 else \
+            merge_schematics(f"{src['part'].name}-system", sheets)
+        e = system.erc()
+        checks["system:erc"] = "ok" if e.ok else "FAIL"
+        violations += [f"erc:{v}" for v in e.violations]
+        env = check_envelopes(system)
+        checks["system:envelope"] = "ok" if env.ok else "FAIL"
+        violations += [f"envelope:{v}" for v in env.violations]
+        p = board_parity(system, board)
+        checks["system:parity"] = "ok" if p.ok else "FAIL"
+        violations += [f"parity:{v}" for v in p.violations]
+
+    checks["schematics_checked"] = len(sheets)
+
+    # waivers: <partname>.waivers next to the part — suppression that shows
+    waivers_file = Path(root) / f"{src['part'].name}.waivers"
+    waived: list[dict] = []
+    if waivers_file.is_file():
+        from gitcad.waivers import load_waivers, waive
+
+        ws = load_waivers(waivers_file.read_text(encoding="utf-8"))
+        violations, waived, unused = waive(violations, ws)
+        checks["waived"] = len(waived)
+        if unused:
+            violations += [f"waiver-unused:{m}" for m in unused]
+
+    return {"ok": not violations, "part": src["part"].name,
+            "checks": checks, "violations": violations, "waived": waived}

gitcad/release.py

@@ -0,0 +1,223 @@
+"""Release machinery + semantic diff — the git-native thesis, completed.
+
+``release()`` is Project-Releaser-as-code (feature-map A8/B5): run EVERY
+check the project defines — model validation, ERC, schematic-board parity,
+DRC, fab-readiness — and only on all-green produce the immutable artifact
+set (STEP/STL/drawings for models, Gerber/drill/PnP for boards) plus a
+manifest pinning every input and output by sha256. A release either passes
+everything or it does not exist; there is no "release with known failures".
+
+``semantic_diff()`` is the PR review surface ADR-0004 promised: not a text
+diff but a *meaning* diff — features added/removed/changed by stable id,
+volume delta from real geometry, board item deltas, and for parts the
+interface-semver classification with the required version bump.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from gitcad.canonical import canonical_json
+from gitcad.document import Document
+from gitcad.errors import GitcadError
+from gitcad.kernel import get_kernel
+from gitcad.seams import Kernel
+
+from gitcad._version import __version__ as _gitcad_version
+
+
+def _kind(text: str) -> str:
+    schema = json.loads(text).get("schema", "")
+    for k in ("document", "board", "schematic", "part"):
+        if schema.startswith(f"gitcad/{k}"):
+            return k
+    raise GitcadError(f"unknown schema {schema!r}")
+
+
+def _sha(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+# -- semantic diff ------------------------------------------------------------
+
+def semantic_diff(old_text: str, new_text: str, kernel: Kernel | None = None) -> dict:
+    """A meaning-level diff between two revisions of the same document."""
+    kind_old, kind_new = _kind(old_text), _kind(new_text)
+    if kind_old != kind_new:
+        return {"kind": "mixed", "error": f"cannot diff {kind_old} against {kind_new}"}
+    out: dict = {"kind": kind_old}
+
+    if kind_old == "document":
+        old, new = Document.loads(old_text), Document.loads(new_text)
+        old_ids = {f.id: f for f in old.features}
+        new_ids = {f.id: f for f in new.features}
+        out["features_added"] = [{"id": i, "op": new_ids[i].op} for i in new_ids if i not in old_ids]
+        out["features_removed"] = [{"id": i, "op": old_ids[i].op} for i in old_ids if i not in new_ids]
+        out["features_changed"] = [
+            {"id": i, "op": new_ids[i].op}
+            for i in new_ids
+            if i in old_ids and canonical_json(new_ids[i].to_dict()) != canonical_json(old_ids[i].to_dict())
+        ]
+        kernel = kernel or get_kernel()
+        if not kernel.name.startswith("null"):
+            try:
+                v_old = kernel.measure(old.build(kernel).final(old))["volume"] if len(old) else 0.0
+                v_new = kernel.measure(new.build(kernel).final(new))["volume"] if len(new) else 0.0
+                out["volume_mm3"] = {"old": round(v_old, 3), "new": round(v_new, 3),
+                                     "delta": round(v_new - v_old, 3)}
+            except Exception as exc:
+                out["volume_mm3"] = {"error": f"{type(exc).__name__}: {exc}"}
+
+    elif kind_old == "board":
+        from gitcad.ecad import Board
+
+        old_b, new_b = Board.loads(old_text), Board.loads(new_text)
+        old_refs = {c.ref for c in old_b.components}
+        new_refs = {c.ref for c in new_b.components}
+        out["components_added"] = sorted(new_refs - old_refs)
+        out["components_removed"] = sorted(old_refs - new_refs)
+        out["tracks"] = {"old": len(old_b.tracks), "new": len(new_b.tracks)}
+        out["vias"] = {"old": len(old_b.vias), "new": len(new_b.vias)}
+        out["outline_changed"] = old_b.outline != new_b.outline
+
+    elif kind_old == "part":
+        from gitcad.part import PartManifest, classify_change
+
+        old_p, new_p = PartManifest.loads(old_text), PartManifest.loads(new_text)
+        bump, reasons = classify_change(old_p.interface, new_p.interface)
+        out["required_bump"] = bump
+        out["reasons"] = reasons
+        out["version"] = {"old": old_p.version, "new": new_p.version}
+
+    else:  # schematic
+        from gitcad.ecad import Schematic
+
+        old_s, new_s = Schematic.loads(old_text), Schematic.loads(new_text)
+        out["components_added"] = sorted({c.ref for c in new_s.components}
+                                         - {c.ref for c in old_s.components})
+        out["components_removed"] = sorted({c.ref for c in old_s.components}
+                                           - {c.ref for c in new_s.components})
+        out["nets"] = {"old": len(old_s.nets), "new": len(new_s.nets)}
+
+    out["identical"] = old_text == new_text
+    return out
+
+
+# -- release ------------------------------------------------------------------
+
+@dataclass
+class ReleaseResult:
+    version: str
+    ok: bool
+    checks: dict = field(default_factory=dict)
+    failures: list[str] = field(default_factory=list)
+    artifacts: dict[str, str] = field(default_factory=dict)   # name -> sha256
+    manifest_path: str = ""
+
+
+def release(sources: list[str], outdir: str, version: str) -> ReleaseResult:
+    """Check everything, then (and only then) produce the artifact set."""
+    out = Path(outdir)
+    result = ReleaseResult(version=version, ok=False)
+    kernel = None
+
+    docs: list[tuple[Path, str, str]] = []   # (path, kind, text)
+    for src in sources:
+        p = Path(src)
+        text = p.read_text(encoding="utf-8")
+        docs.append((p, _kind(text), text))
+
+    schematics = [(p, t) for p, k, t in docs if k == "schematic"]
+    boards = [(p, t) for p, k, t in docs if k == "board"]
+
+    # -- phase 1: every check must pass ---------------------------------------
+    for p, kind, text in docs:
+        label = p.name
+        if kind == "document":
+            kernel = kernel or get_kernel(require="occt")
+            doc = Document.loads(text)
+            build = doc.build(kernel)
+            for fid, shape in build.shapes.items():
+                r = kernel.validate(shape)
+                if not r.ok:
+                    result.failures.append(f"{label}:validate:{fid}:{r.violations}")
+            result.checks[f"{label}:validate"] = "ok"
+        elif kind == "board":
+            from gitcad.ecad import Board, check_connectivity, run_drc
+
+            board = Board.loads(text)
+            r = board.validate()
+            if not r.ok:
+                result.failures.extend(f"{label}:fab:{v}" for v in r.violations)
+            d = run_drc(board)
+            if not d.ok:
+                result.failures.extend(f"{label}:drc:{v}" for v in d.violations)
+            c = check_connectivity(board)
+            if not c.ok:
+                result.failures.extend(f"{label}:connectivity:{v}" for v in c.violations)
+            result.checks[f"{label}:fab"] = "ok" if r.ok else "FAIL"
+            result.checks[f"{label}:drc"] = "ok" if d.ok else "FAIL"
+            result.checks[f"{label}:connectivity"] = "ok" if c.ok else "FAIL"
+        elif kind == "schematic":
+            from gitcad.ecad import Schematic
+
+            r = Schematic.loads(text).erc()
+            if not r.ok:
+                result.failures.extend(f"{label}:erc:{v}" for v in r.violations)
+            result.checks[f"{label}:erc"] = "ok" if r.ok else "FAIL"
+
+    # cross-checks: every schematic against every board (parity)
+    if schematics and boards:
+        from gitcad.ecad import Board, Schematic, board_parity
+
+        for sp, st in schematics:
+            for bp, bt in boards:
+                r = board_parity(Schematic.loads(st), Board.loads(bt))
+                key = f"parity:{sp.name}<->{bp.name}"
+                result.checks[key] = "ok" if r.ok else "FAIL"
+                if not r.ok:
+                    result.failures.extend(f"{key}:{v}" for v in r.violations)
+
+    if result.failures:
+        return result   # no artifacts on red — a release either passes or isn't
+
+    # -- phase 2: artifacts ----------------------------------------------------
+    out.mkdir(parents=True, exist_ok=True)
+    for p, kind, text in docs:
+        stem = p.name.replace(".gitcad.json", "").replace(".json", "")
+        if kind == "document":
+            from gitcad.drawing import make_drawing
+
+            doc = Document.loads(text)
+            shape = doc.build(kernel).final(doc)
+            step = out / f"{stem}.step"
+            kernel.export_step(shape, str(step))
+            stl = out / f"{stem}.stl"
+            kernel.export_stl(shape, str(stl))
+            pdf = out / f"{stem}.pdf"
+            pdf.write_bytes(make_drawing(shape, kernel, title=f"{stem} {version}").to_pdf())
+            for f in (step, stl, pdf):
+                result.artifacts[f.name] = _sha(f)
+        elif kind == "board":
+            from gitcad.ecad import Board, export_fab
+
+            files = export_fab(Board.loads(text), str(out / f"{stem}-fab"))
+            for _, fpath in files.items():
+                fp = Path(fpath)
+                result.artifacts[f"{stem}-fab/{fp.name}"] = _sha(fp)
+
+    manifest = {
+        "generator": f"gitcad {_gitcad_version}",
+        "version": version,
+        "sources": {p.name: hashlib.sha256(t.encode()).hexdigest() for p, _, t in docs},
+        "checks": result.checks,
+        "artifacts": result.artifacts,
+    }
+    mpath = out / "release-manifest.json"
+    mpath.write_text(canonical_json(manifest, indent=2) + "\n", newline="\n", encoding="utf-8")
+    result.manifest_path = str(mpath)
+    result.ok = True
+    return result