@tscircuit/checks 0.0.117 → 0.0.119

package/README.md

@@ -19,6 +19,7 @@ and output an array of arrays for any issues found.
 | [`checkPcbComponentOverlap`](./lib/check-pcb-components-overlap/checkPcbComponentOverlap.ts) | Returns `pcb_footprint_overlap_error` when footprint elements from different components overlap in disallowed ways. |
 | [`checkPcbComponentsOutOfBoard`](./lib/check-pcb-components-out-of-board/checkPcbComponentsOutOfBoard.ts) | Returns `pcb_placement_error` when PCB components do not fit inside the board area. |
 | [`checkPcbTracesOutOfBoard`](./lib/check-trace-out-of-board/checkTraceOutOfBoard.ts) | Returns `pcb_trace_error` when any trace segment or via extends beyond the board boundary. |
+| [`checkViaTraceClearance`](./lib/check-via-trace-clearance.ts) | Returns `pcb_via_trace_clearance_error` when a via and unrelated trace segment violate minimum clearance. |
 | [`checkPinMustBeConnected`](./lib/check-pin-must-be-connected.ts) | Returns `pcb_trace_error` when required source pins are not connected. |
 | [`checkSameNetViaSpacing`](./lib/check-same-net-via-spacing.ts) | Returns `pcb_via_clearance_error` if vias on the same net are closer than the allowed margin. |
 | [`checkSourceTracesHavePcbTraces`](./lib/check-source-traces-have-pcb-traces.ts) | Returns `pcb_trace_error` when source traces are missing corresponding `pcb_trace` routes. |
@@ -32,7 +33,7 @@ and output an array of arrays for any issues found.
 | [`runAllPlacementChecks`](./lib/run-all-checks.ts) | Runs all placement checks (`checkViasOffBoard`, `checkPcbComponentsOutOfBoard`, `checkPcbComponentOverlap`, and `checkConnectorAccessibleOrientation`). |
 | [`runAllNetlistChecks`](./lib/run-all-checks.ts) | Runs netlist connectivity checks (currently `checkPinMustBeConnected`). |
 | [`runAllPinSpecificationChecks`](./lib/run-all-checks.ts) | Runs pin specification checks (e.g. `checkAllPinsInComponentAreUnderspecified`, `checkNoPowerPinDefined`, and `checkNoGroundPinDefined`). |
-| [`runAllRoutingChecks`](./lib/run-all-checks.ts) | Runs all routing checks currently enabled (`checkEachPcbPortConnectedToPcbTraces`, `checkSourceTracesHavePcbTraces`, `checkEachPcbTraceNonOverlapping`, same/different net via spacing, and `checkPcbTracesOutOfBoard`). |
+| [`runAllRoutingChecks`](./lib/run-all-checks.ts) | Runs all routing checks currently enabled (`checkEachPcbPortConnectedToPcbTraces`, `checkSourceTracesHavePcbTraces`, `checkEachPcbTraceNonOverlapping`, `checkViaTraceClearance`, same/different net via spacing, and `checkPcbTracesOutOfBoard`). |
 | [`runAllChecks`](./lib/run-all-checks.ts) | Runs placement, netlist, pin specification, and routing checks and returns a combined list of issues. |
 
 ## Implementation Details

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as circuit_json from 'circuit-json';
-import { AnyCircuitElement, PcbPortNotConnectedError, PcbTraceError, PcbPlacementError, PcbComponentOutsideBoardError, PcbViaClearanceError, PcbTraceWarning, PcbTraceMissingError, PcbFootprintOverlapError, SourceComponentPinsUnderspecifiedWarning, SourceNoPowerPinDefinedWarning, SourceNoGroundPinDefinedWarning, PcbConnectorNotInAccessibleOrientationWarning } from 'circuit-json';
+import { AnyCircuitElement, PcbPortNotConnectedError, PcbTraceError, PcbPlacementError, PcbComponentOutsideBoardError, PcbViaClearanceError, PcbTraceWarning, PcbTraceMissingError, PcbFootprintOverlapError, PcbPadPadClearanceError, PcbPadTraceClearanceError, PcbViaTraceClearanceError, SourceComponentPinsUnderspecifiedWarning, SourceNoPowerPinDefinedWarning, SourceNoGroundPinDefinedWarning, PcbConnectorNotInAccessibleOrientationWarning } from 'circuit-json';
 import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 
 declare function checkEachPcbPortConnectedToPcbTraces(circuitJson: AnyCircuitElement[]): PcbPortNotConnectedError[];
@@ -61,6 +61,21 @@ declare function checkPcbTracesOutOfBoard(circuitJson: AnyCircuitElement[], conf
  */
 declare function checkPcbComponentOverlap(circuitJson: AnyCircuitElement[]): PcbFootprintOverlapError[];
 
+declare function checkPadPadClearance(circuitJson: AnyCircuitElement[], { connMap, minSpacing, }?: {
+    connMap?: ConnectivityMap;
+    minSpacing?: number;
+}): PcbPadPadClearanceError[];
+
+declare function checkPadTraceClearance(circuitJson: AnyCircuitElement[], { connMap, minSpacing, }?: {
+    connMap?: ConnectivityMap;
+    minSpacing?: number;
+}): PcbPadTraceClearanceError[];
+
+declare function checkViaTraceClearance(circuitJson: AnyCircuitElement[], { connMap, minSpacing, }?: {
+    connMap?: ConnectivityMap;
+    minSpacing?: number;
+}): PcbViaTraceClearanceError[];
+
 type SourcePinMustBeConnectedError = {
     type: "source_pin_must_be_connected_error";
     source_pin_must_be_connected_error_id: string;
@@ -96,7 +111,7 @@ declare function checkNoPowerPinDefined(circuitJson: AnyCircuitElement[]): Sourc
  */
 declare function checkNoGroundPinDefined(circuitJson: AnyCircuitElement[]): SourceNoGroundPinDefinedWarning[];
 
-declare function runAllPlacementChecks(circuitJson: AnyCircuitElement[]): Promise<(circuit_json.PcbPlacementError | circuit_json.PcbComponentOutsideBoardError | circuit_json.PcbFootprintOverlapError | circuit_json.PcbCourtyardOverlapError | circuit_json.PcbConnectorNotInAccessibleOrientationWarning)[]>;
+declare function runAllPlacementChecks(circuitJson: AnyCircuitElement[]): Promise<(circuit_json.PcbPlacementError | circuit_json.PcbComponentOutsideBoardError | circuit_json.PcbFootprintOverlapError | circuit_json.PcbPadPadClearanceError | circuit_json.PcbPadTraceClearanceError | circuit_json.PcbConnectorNotInAccessibleOrientationWarning | circuit_json.PcbCourtyardOverlapError)[]>;
 declare function runAllNetlistChecks(circuitJson: AnyCircuitElement[]): Promise<{
     type: "source_pin_must_be_connected_error";
     source_pin_must_be_connected_error_id: string;
@@ -107,8 +122,8 @@ declare function runAllNetlistChecks(circuitJson: AnyCircuitElement[]): Promise<
     subcircuit_id?: string;
 }[]>;
 declare function runAllPinSpecificationChecks(circuitJson: AnyCircuitElement[]): Promise<(circuit_json.SourceComponentPinsUnderspecifiedWarning | circuit_json.SourceNoPowerPinDefinedWarning | circuit_json.SourceNoGroundPinDefinedWarning)[]>;
-declare function runAllRoutingChecks(circuitJson: AnyCircuitElement[]): Promise<(circuit_json.PcbPortNotConnectedError | circuit_json.PcbTraceError | circuit_json.PcbViaClearanceError | circuit_json.PcbTraceMissingError)[]>;
-declare function runAllChecks(circuitJson: AnyCircuitElement[]): Promise<(circuit_json.PcbPortNotConnectedError | circuit_json.PcbTraceError | circuit_json.PcbPlacementError | circuit_json.PcbComponentOutsideBoardError | circuit_json.PcbViaClearanceError | circuit_json.PcbTraceMissingError | circuit_json.PcbFootprintOverlapError | {
+declare function runAllRoutingChecks(circuitJson: AnyCircuitElement[]): Promise<(circuit_json.PcbPortNotConnectedError | circuit_json.PcbTraceError | circuit_json.PcbViaClearanceError | circuit_json.PcbTraceMissingError | circuit_json.PcbViaTraceClearanceError)[]>;
+declare function runAllChecks(circuitJson: AnyCircuitElement[]): Promise<(circuit_json.PcbPortNotConnectedError | circuit_json.PcbTraceError | circuit_json.PcbPlacementError | circuit_json.PcbComponentOutsideBoardError | circuit_json.PcbViaClearanceError | circuit_json.PcbTraceMissingError | circuit_json.PcbFootprintOverlapError | circuit_json.PcbPadPadClearanceError | circuit_json.PcbPadTraceClearanceError | circuit_json.PcbViaTraceClearanceError | {
     type: "source_pin_must_be_connected_error";
     source_pin_must_be_connected_error_id: string;
     error_type: "source_pin_must_be_connected_error";
@@ -116,8 +131,8 @@ declare function runAllChecks(circuitJson: AnyCircuitElement[]): Promise<(circui
     source_component_id: string;
     source_port_id: string;
     subcircuit_id?: string;
-} | circuit_json.SourceComponentPinsUnderspecifiedWarning | circuit_json.SourceNoPowerPinDefinedWarning | circuit_json.SourceNoGroundPinDefinedWarning | circuit_json.PcbCourtyardOverlapError | circuit_json.PcbConnectorNotInAccessibleOrientationWarning)[]>;
+} | circuit_json.SourceComponentPinsUnderspecifiedWarning | circuit_json.SourceNoPowerPinDefinedWarning | circuit_json.SourceNoGroundPinDefinedWarning | circuit_json.PcbConnectorNotInAccessibleOrientationWarning | circuit_json.PcbCourtyardOverlapError)[]>;
 
 declare function checkConnectorAccessibleOrientation(circuitJson: AnyCircuitElement[]): PcbConnectorNotInAccessibleOrientationWarning[];
 
-export { NetManager, checkAllPinsInComponentAreUnderspecified, checkConnectorAccessibleOrientation, checkDifferentNetViaSpacing, checkEachPcbPortConnectedToPcbTraces, checkEachPcbTraceNonOverlapping, checkNoGroundPinDefined, checkNoPowerPinDefined, checkPcbComponentOverlap, checkPcbComponentsOutOfBoard, checkPcbTracesOutOfBoard, checkPinMustBeConnected, checkSameNetViaSpacing, checkSourceTracesHavePcbTraces, checkSourceTracesMatchPcbTraceThickness, checkViasOffBoard, runAllChecks, runAllNetlistChecks, runAllPinSpecificationChecks, runAllPlacementChecks, runAllRoutingChecks };
+export { NetManager, checkAllPinsInComponentAreUnderspecified, checkConnectorAccessibleOrientation, checkDifferentNetViaSpacing, checkEachPcbPortConnectedToPcbTraces, checkEachPcbTraceNonOverlapping, checkNoGroundPinDefined, checkNoPowerPinDefined, checkPadPadClearance, checkPadTraceClearance, checkPcbComponentOverlap, checkPcbComponentsOutOfBoard, checkPcbTracesOutOfBoard, checkPinMustBeConnected, checkSameNetViaSpacing, checkSourceTracesHavePcbTraces, checkSourceTracesMatchPcbTraceThickness, checkViaTraceClearance, checkViasOffBoard, runAllChecks, runAllNetlistChecks, runAllPinSpecificationChecks, runAllPlacementChecks, runAllRoutingChecks };

package/dist/index.js

@@ -369,6 +369,8 @@ var DEFAULT_TRACE_THICKNESS = 0.15;
 var DEFAULT_VIA_BOARD_MARGIN = 0.3;
 var DEFAULT_SAME_NET_VIA_MARGIN = 0.2;
 var DEFAULT_DIFFERENT_NET_VIA_MARGIN = 0.3;
+var DEFAULT_PAD_PAD_CLEARANCE = 0.1;
+var DEFAULT_PAD_TRACE_CLEARANCE = 0.1;
 var EPSILON = 5e-3;
 
 // lib/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
@@ -1601,6 +1603,318 @@ function checkPcbComponentOverlap(circuitJson) {
   return errors;
 }
 
+// lib/check-pad-pad-clearance.ts
+import {
+  getPrimaryId as getPrimaryId3,
+  getReadableNameForElement as getReadableNameForElement6
+} from "@tscircuit/circuit-json-util";
+import {
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7
+} from "circuit-json-to-connectivity-map";
+
+// lib/check-pad-clearance/common.ts
+import {
+  cju as cju5,
+  distanceBetweenCircleAndCircle,
+  distanceBetweenCircleAndPolygon,
+  distanceBetweenPolygonAndPolygon,
+  getBoundsOfPcbElements as getBoundsOfPcbElements5
+} from "@tscircuit/circuit-json-util";
+import { midpoint } from "@tscircuit/math-utils";
+var formatMm = (value) => {
+  const rounded = Math.round(value * 1e3) / 1e3;
+  return `${Number(rounded.toFixed(3))}mm`;
+};
+var getPadBounds = (pad) => getBoundsOfPcbElements5([pad]);
+var getPadCenter = (pad) => {
+  const bounds = getPadBounds(pad);
+  return midpoint(
+    { x: bounds.minX, y: bounds.minY },
+    { x: bounds.maxX, y: bounds.maxY }
+  );
+};
+var getPadRadius = (pad) => {
+  const bounds = getPadBounds(pad);
+  return Math.min(bounds.maxX - bounds.minX, bounds.maxY - bounds.minY) / 2;
+};
+var isCircularPad = (pad) => pad.shape === "circle";
+var getCircleShape = (pad) => {
+  const center = getPadCenter(pad);
+  return {
+    kind: "circle",
+    x: center.x,
+    y: center.y,
+    radius: getPadRadius(pad)
+  };
+};
+var getPolygonShape = (pad) => {
+  const bounds = getPadBounds(pad);
+  return {
+    kind: "polygon",
+    points: [
+      { x: bounds.minX, y: bounds.minY },
+      { x: bounds.maxX, y: bounds.minY },
+      { x: bounds.maxX, y: bounds.maxY },
+      { x: bounds.minX, y: bounds.maxY }
+    ]
+  };
+};
+var getPadToPadGap = (padA, padB) => {
+  if (isCircularPad(padA) && isCircularPad(padB)) {
+    return distanceBetweenCircleAndCircle(
+      getCircleShape(padA),
+      getCircleShape(padB)
+    );
+  }
+  if (isCircularPad(padA)) {
+    return distanceBetweenCircleAndPolygon(
+      getCircleShape(padA),
+      getPolygonShape(padB)
+    );
+  }
+  if (isCircularPad(padB)) {
+    return distanceBetweenCircleAndPolygon(
+      getCircleShape(padB),
+      getPolygonShape(padA)
+    );
+  }
+  return distanceBetweenPolygonAndPolygon(
+    getPolygonShape(padA),
+    getPolygonShape(padB)
+  );
+};
+var getPads = (circuitJson) => [
+  ...cju5(circuitJson).pcb_smtpad.list(),
+  ...cju5(circuitJson).pcb_plated_hole.list()
+];
+var getTraceSegments = (circuitJson) => {
+  const pcbTraces = cju5(circuitJson).pcb_trace.list();
+  return pcbTraces.flatMap((pcbTrace) => {
+    const segments = [];
+    for (let i = 0; i < pcbTrace.route.length - 1; i++) {
+      const p1 = pcbTrace.route[i];
+      const p2 = pcbTrace.route[i + 1];
+      if (p1.route_type !== "wire") continue;
+      if (p2.route_type !== "wire") continue;
+      if (p1.layer !== p2.layer) continue;
+      segments.push({
+        type: "pcb_trace_segment",
+        pcb_trace_id: pcbTrace.pcb_trace_id,
+        _pcbTrace: pcbTrace,
+        thickness: "width" in p1 ? p1.width : "width" in p2 ? p2.width : DEFAULT_TRACE_THICKNESS,
+        layer: p1.layer,
+        x1: p1.x,
+        y1: p1.y,
+        x2: p2.x,
+        y2: p2.y
+      });
+    }
+    return segments;
+  });
+};
+
+// lib/check-pad-pad-clearance.ts
+function checkPadPadClearance(circuitJson, {
+  connMap,
+  minSpacing = DEFAULT_PAD_PAD_CLEARANCE
+} = {}) {
+  const pads = getPads(circuitJson);
+  if (pads.length < 2) return [];
+  connMap ??= getFullConnectivityMapFromCircuitJson7(circuitJson);
+  const spatialIndex = new SpatialObjectIndex({
+    objects: pads,
+    getBounds: getPadBounds,
+    getId: (pad) => getPrimaryId3(pad)
+  });
+  const errors = /* @__PURE__ */ new Map();
+  for (const padA of pads) {
+    const padAId = getPrimaryId3(padA);
+    const nearbyPads = spatialIndex.getObjectsInBounds(
+      getPadBounds(padA),
+      minSpacing
+    );
+    for (const padB of nearbyPads) {
+      const padBId = getPrimaryId3(padB);
+      if (padAId === padBId) continue;
+      if (!getLayersOfPcbElement(padA).some(
+        (layer) => getLayersOfPcbElement(padB).includes(layer)
+      )) {
+        continue;
+      }
+      if (connMap.areIdsConnected(padAId, padBId)) continue;
+      const pairId = [padAId, padBId].sort().join("_");
+      const gap = getPadToPadGap(padA, padB);
+      if (gap + EPSILON >= minSpacing) continue;
+      const centerA = getPadCenter(padA);
+      const centerB = getPadCenter(padB);
+      const nextError = {
+        type: "pcb_pad_pad_clearance_error",
+        pcb_pad_pad_clearance_error_id: `pad_pad_clearance_${pairId}`,
+        error_type: "pcb_pad_pad_clearance_error",
+        message: `Pads ${getReadableNameForElement6(circuitJson, padAId)} and ${getReadableNameForElement6(circuitJson, padBId)} are too close (clearance: ${formatMm(gap)}, minimum: ${formatMm(minSpacing)})`,
+        pcb_pad_ids: [padAId, padBId],
+        minimum_clearance: minSpacing,
+        actual_clearance: gap,
+        center: {
+          x: (centerA.x + centerB.x) / 2,
+          y: (centerA.y + centerB.y) / 2
+        }
+      };
+      if (!errors.has(pairId)) {
+        errors.set(pairId, nextError);
+      }
+    }
+  }
+  return Array.from(errors.values());
+}
+
+// lib/check-pad-trace-clearance.ts
+import {
+  getPrimaryId as getPrimaryId4,
+  getReadableNameForElement as getReadableNameForElement7
+} from "@tscircuit/circuit-json-util";
+import {
+  segmentToBoundsMinDistance as segmentToBoundsMinDistance2,
+  segmentToCircleMinDistance as segmentToCircleMinDistance2
+} from "@tscircuit/math-utils";
+import {
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson8
+} from "circuit-json-to-connectivity-map";
+function checkPadTraceClearance(circuitJson, {
+  connMap,
+  minSpacing = DEFAULT_PAD_TRACE_CLEARANCE
+} = {}) {
+  const pads = getPads(circuitJson);
+  const segments = getTraceSegments(circuitJson);
+  if (pads.length === 0 || segments.length === 0) return [];
+  connMap ??= getFullConnectivityMapFromCircuitJson8(circuitJson);
+  const spatialIndex = new SpatialObjectIndex({
+    objects: pads,
+    getBounds: getPadBounds,
+    getId: (pad) => getPrimaryId4(pad)
+  });
+  const errors = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const nearbyPads = spatialIndex.getObjectsInBounds(
+      getCollidableBounds(segment),
+      minSpacing + segment.thickness / 2
+    );
+    for (const pad of nearbyPads) {
+      const padId = getPrimaryId4(pad);
+      if (!getLayersOfPcbElement(pad).includes(segment.layer)) continue;
+      if (connMap.areIdsConnected(segment.pcb_trace_id, padId)) continue;
+      const center = getPadCenter(pad);
+      const gap = isCircularPad(pad) ? segmentToCircleMinDistance2(
+        { x: segment.x1, y: segment.y1 },
+        { x: segment.x2, y: segment.y2 },
+        { x: center.x, y: center.y, radius: getPadRadius(pad) }
+      ) - segment.thickness / 2 : segmentToBoundsMinDistance2(
+        { x: segment.x1, y: segment.y1 },
+        { x: segment.x2, y: segment.y2 },
+        getPadBounds(pad)
+      ) - segment.thickness / 2;
+      if (gap + EPSILON >= minSpacing) continue;
+      const pairId = `${padId}_${segment.pcb_trace_id}`;
+      const nextError = {
+        type: "pcb_pad_trace_clearance_error",
+        pcb_pad_trace_clearance_error_id: `pad_trace_clearance_${pairId}`,
+        error_type: "pcb_pad_trace_clearance_error",
+        message: `Pad ${getReadableNameForElement7(circuitJson, padId)} and trace ${getReadableNameForElement7(circuitJson, segment.pcb_trace_id)} are too close (clearance: ${formatMm(gap)}, minimum: ${formatMm(minSpacing)})`,
+        pcb_pad_id: padId,
+        pcb_trace_id: segment.pcb_trace_id,
+        minimum_clearance: minSpacing,
+        actual_clearance: gap,
+        center: {
+          x: (center.x + (segment.x1 + segment.x2) / 2) / 2,
+          y: (center.y + (segment.y1 + segment.y2) / 2) / 2
+        }
+      };
+      const current = errors.get(pairId);
+      if (!current || gap < current.gap) {
+        errors.set(pairId, { error: nextError, gap });
+      }
+    }
+  }
+  return Array.from(errors.values()).map(({ error }) => error);
+}
+
+// lib/check-via-trace-clearance.ts
+import { getReadableNameForElement as getReadableNameForElement8 } from "@tscircuit/circuit-json-util";
+import { segmentToCircleMinDistance as segmentToCircleMinDistance3 } from "@tscircuit/math-utils";
+import {
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson9
+} from "circuit-json-to-connectivity-map";
+var getClosestPointOnSegment = (point, segmentStart, segmentEnd) => {
+  const dx = segmentEnd.x - segmentStart.x;
+  const dy = segmentEnd.y - segmentStart.y;
+  const lengthSquared = dx * dx + dy * dy;
+  if (lengthSquared === 0) return segmentStart;
+  const t = Math.max(
+    0,
+    Math.min(
+      1,
+      ((point.x - segmentStart.x) * dx + (point.y - segmentStart.y) * dy) / lengthSquared
+    )
+  );
+  return {
+    x: segmentStart.x + t * dx,
+    y: segmentStart.y + t * dy
+  };
+};
+function checkViaTraceClearance(circuitJson, {
+  connMap,
+  minSpacing = DEFAULT_PAD_TRACE_CLEARANCE
+} = {}) {
+  const vias = circuitJson.filter((el) => el.type === "pcb_via");
+  const segments = getTraceSegments(circuitJson);
+  if (vias.length === 0 || segments.length === 0) return [];
+  connMap ??= getFullConnectivityMapFromCircuitJson9(circuitJson);
+  const errors = /* @__PURE__ */ new Map();
+  for (const via of vias) {
+    const viaRadius = via.outer_diameter / 2;
+    for (const segment of segments) {
+      if (!getLayersOfPcbElement(via).includes(segment.layer)) continue;
+      if (connMap.areIdsConnected(segment.pcb_trace_id, via.pcb_via_id))
+        continue;
+      const gap = segmentToCircleMinDistance3(
+        { x: segment.x1, y: segment.y1 },
+        { x: segment.x2, y: segment.y2 },
+        {
+          x: via.x,
+          y: via.y,
+          radius: viaRadius
+        }
+      ) - segment.thickness / 2;
+      if (gap + EPSILON >= minSpacing) continue;
+      const closestPoint = getClosestPointOnSegment(
+        { x: via.x, y: via.y },
+        { x: segment.x1, y: segment.y1 },
+        { x: segment.x2, y: segment.y2 }
+      );
+      const pairId = `${via.pcb_via_id}_${segment.pcb_trace_id}`;
+      const nextError = {
+        type: "pcb_via_trace_clearance_error",
+        pcb_via_trace_clearance_error_id: `via_trace_clearance_${pairId}`,
+        error_type: "pcb_via_trace_clearance_error",
+        message: `Via ${getReadableNameForElement8(circuitJson, via.pcb_via_id)} and trace ${getReadableNameForElement8(circuitJson, segment.pcb_trace_id)} are too close (clearance: ${formatMm(gap)}, minimum: ${formatMm(minSpacing)})`,
+        pcb_via_id: via.pcb_via_id,
+        pcb_trace_id: segment.pcb_trace_id,
+        minimum_clearance: minSpacing,
+        actual_clearance: gap,
+        center: {
+          x: (via.x + closestPoint.x) / 2,
+          y: (via.y + closestPoint.y) / 2
+        }
+      };
+      const current = errors.get(pairId);
+      if (!current || gap < current.gap) {
+        errors.set(pairId, { error: nextError, gap });
+      }
+    }
+  }
+  return Array.from(errors.values()).map(({ error }) => error);
+}
+
 // lib/check-pin-must-be-connected.ts
 function checkPinMustBeConnected(circuitJson) {
   const errors = [];
@@ -1660,7 +1974,7 @@ function checkPinMustBeConnected(circuitJson) {
 }
 
 // lib/check-all-pins-in-component-are-underspecified.ts
-import { cju as cju5 } from "@tscircuit/circuit-json-util";
+import { cju as cju6 } from "@tscircuit/circuit-json-util";
 var PIN_ATTRIBUTE_KEYS = [
   "must_be_connected",
   "provides_power",
@@ -1705,7 +2019,7 @@ function hasAnyPinAttribute(port) {
 }
 function checkAllPinsInComponentAreUnderspecified(circuitJson) {
   const warnings = [];
-  const db = cju5(circuitJson);
+  const db = cju6(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -1737,10 +2051,10 @@ function checkAllPinsInComponentAreUnderspecified(circuitJson) {
 }
 
 // lib/check-no-power-pin-defined.ts
-import { cju as cju6 } from "@tscircuit/circuit-json-util";
+import { cju as cju7 } from "@tscircuit/circuit-json-util";
 function checkNoPowerPinDefined(circuitJson) {
   const warnings = [];
-  const db = cju6(circuitJson);
+  const db = cju7(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -1772,10 +2086,10 @@ function checkNoPowerPinDefined(circuitJson) {
 }
 
 // lib/check-no-ground-pin-defined.ts
-import { cju as cju7 } from "@tscircuit/circuit-json-util";
+import { cju as cju8 } from "@tscircuit/circuit-json-util";
 function checkNoGroundPinDefined(circuitJson) {
   const warnings = [];
-  const db = cju7(circuitJson);
+  const db = cju8(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -1806,6 +2120,75 @@ function checkNoGroundPinDefined(circuitJson) {
   return warnings;
 }
 
+// lib/check-connector-accessible-orientation.ts
+import { getBoardBounds } from "@tscircuit/circuit-json-util";
+function getFacingDirection(component) {
+  if (!component.center || !component.cable_insertion_center) return null;
+  const dx = component.cable_insertion_center.x - component.center.x;
+  const dy = component.cable_insertion_center.y - component.center.y;
+  if (Math.abs(dx) < 1e-6 && Math.abs(dy) < 1e-6) return null;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx >= 0 ? "x+" : "x-";
+  }
+  return dy >= 0 ? "y+" : "y-";
+}
+function getRecommendedFacingDirection(component, bounds) {
+  if (!component.center) return null;
+  const distances = [
+    { direction: "x-", distance: component.center.x - bounds.minX },
+    { direction: "x+", distance: bounds.maxX - component.center.x },
+    { direction: "y-", distance: component.center.y - bounds.minY },
+    { direction: "y+", distance: bounds.maxY - component.center.y }
+  ];
+  distances.sort((a, b) => a.distance - b.distance);
+  return distances[0]?.direction ?? null;
+}
+function checkConnectorAccessibleOrientation(circuitJson) {
+  const board = circuitJson.find(
+    (el) => el.type === "pcb_board"
+  );
+  if (!board) return [];
+  const bounds = (() => {
+    try {
+      return getBoardBounds(board);
+    } catch {
+      return null;
+    }
+  })();
+  if (!bounds) return [];
+  const warnings = [];
+  const components = circuitJson.filter(
+    (el) => el.type === "pcb_component"
+  );
+  for (const component of components) {
+    if (!component.cable_insertion_center) continue;
+    const facingDirection = getFacingDirection(component);
+    const recommendedFacingDirection = getRecommendedFacingDirection(
+      component,
+      bounds
+    );
+    if (!facingDirection || !recommendedFacingDirection) continue;
+    if (facingDirection === recommendedFacingDirection) continue;
+    const componentName = getReadableNameForComponent(
+      circuitJson,
+      component.pcb_component_id
+    );
+    warnings.push({
+      type: "pcb_connector_not_in_accessible_orientation_warning",
+      warning_type: "pcb_connector_not_in_accessible_orientation_warning",
+      pcb_connector_not_in_accessible_orientation_warning_id: `pcb_connector_not_in_accessible_orientation_warning_${component.pcb_component_id}`,
+      message: `${componentName} is facing ${facingDirection} but should face ${recommendedFacingDirection} so the connector is accessible from the board edge`,
+      pcb_component_id: component.pcb_component_id,
+      source_component_id: component.source_component_id,
+      pcb_board_id: board.pcb_board_id,
+      facing_direction: facingDirection,
+      recommended_facing_direction: recommendedFacingDirection,
+      subcircuit_id: component.subcircuit_id
+    });
+  }
+  return warnings;
+}
+
 // lib/check-courtyard-overlap/checkCourtyardOverlap.ts
 import {
   doSegmentsIntersect,
@@ -1912,75 +2295,6 @@ function checkCourtyardOverlap(circuitJson) {
   return errors;
 }
 
-// lib/check-connector-accessible-orientation.ts
-import { getBoardBounds } from "@tscircuit/circuit-json-util";
-function getFacingDirection(component) {
-  if (!component.center || !component.cable_insertion_center) return null;
-  const dx = component.cable_insertion_center.x - component.center.x;
-  const dy = component.cable_insertion_center.y - component.center.y;
-  if (Math.abs(dx) < 1e-6 && Math.abs(dy) < 1e-6) return null;
-  if (Math.abs(dx) >= Math.abs(dy)) {
-    return dx >= 0 ? "x+" : "x-";
-  }
-  return dy >= 0 ? "y+" : "y-";
-}
-function getRecommendedFacingDirection(component, bounds) {
-  if (!component.center) return null;
-  const distances = [
-    { direction: "x-", distance: component.center.x - bounds.minX },
-    { direction: "x+", distance: bounds.maxX - component.center.x },
-    { direction: "y-", distance: component.center.y - bounds.minY },
-    { direction: "y+", distance: bounds.maxY - component.center.y }
-  ];
-  distances.sort((a, b) => a.distance - b.distance);
-  return distances[0]?.direction ?? null;
-}
-function checkConnectorAccessibleOrientation(circuitJson) {
-  const board = circuitJson.find(
-    (el) => el.type === "pcb_board"
-  );
-  if (!board) return [];
-  const bounds = (() => {
-    try {
-      return getBoardBounds(board);
-    } catch {
-      return null;
-    }
-  })();
-  if (!bounds) return [];
-  const warnings = [];
-  const components = circuitJson.filter(
-    (el) => el.type === "pcb_component"
-  );
-  for (const component of components) {
-    if (!component.cable_insertion_center) continue;
-    const facingDirection = getFacingDirection(component);
-    const recommendedFacingDirection = getRecommendedFacingDirection(
-      component,
-      bounds
-    );
-    if (!facingDirection || !recommendedFacingDirection) continue;
-    if (facingDirection === recommendedFacingDirection) continue;
-    const componentName = getReadableNameForComponent(
-      circuitJson,
-      component.pcb_component_id
-    );
-    warnings.push({
-      type: "pcb_connector_not_in_accessible_orientation_warning",
-      warning_type: "pcb_connector_not_in_accessible_orientation_warning",
-      pcb_connector_not_in_accessible_orientation_warning_id: `pcb_connector_not_in_accessible_orientation_warning_${component.pcb_component_id}`,
-      message: `${componentName} is facing ${facingDirection} but should face ${recommendedFacingDirection} so the connector is accessible from the board edge`,
-      pcb_component_id: component.pcb_component_id,
-      source_component_id: component.source_component_id,
-      pcb_board_id: board.pcb_board_id,
-      facing_direction: facingDirection,
-      recommended_facing_direction: recommendedFacingDirection,
-      subcircuit_id: component.subcircuit_id
-    });
-  }
-  return warnings;
-}
-
 // lib/check-traces-are-contiguous/check-traces-are-contiguous.ts
 import { getReadableNameForPcbPort as getReadableNameForPcbPort2 } from "@tscircuit/circuit-json-util";
 
@@ -1990,6 +2304,8 @@ async function runAllPlacementChecks(circuitJson) {
     ...checkViasOffBoard(circuitJson),
     ...checkPcbComponentsOutOfBoard(circuitJson),
     ...checkPcbComponentOverlap(circuitJson),
+    ...checkPadPadClearance(circuitJson),
+    ...checkPadTraceClearance(circuitJson),
     ...checkCourtyardOverlap(circuitJson),
     ...checkConnectorAccessibleOrientation(circuitJson)
   ];
@@ -2009,6 +2325,7 @@ async function runAllRoutingChecks(circuitJson) {
     ...checkEachPcbPortConnectedToPcbTraces(circuitJson),
     ...checkSourceTracesHavePcbTraces(circuitJson),
     ...checkEachPcbTraceNonOverlapping(circuitJson),
+    ...checkViaTraceClearance(circuitJson),
     ...checkSameNetViaSpacing(circuitJson),
     ...checkDifferentNetViaSpacing(circuitJson),
     // ...checkTracesAreContiguous(circuitJson),
@@ -2032,6 +2349,8 @@ export {
   checkEachPcbTraceNonOverlapping,
   checkNoGroundPinDefined,
   checkNoPowerPinDefined,
+  checkPadPadClearance,
+  checkPadTraceClearance,
   checkPcbComponentOverlap,
   checkPcbComponentsOutOfBoard,
   checkPcbTracesOutOfBoard,
@@ -2039,6 +2358,7 @@ export {
   checkSameNetViaSpacing,
   checkSourceTracesHavePcbTraces,
   checkSourceTracesMatchPcbTraceThickness,
+  checkViaTraceClearance,
   checkViasOffBoard,
   runAllChecks,
   runAllNetlistChecks,