@tscircuit/checks 0.0.143 → 0.0.145

package/dist/index.js

@@ -118,7 +118,12 @@ var getClosestPointsBetweenSegments = (a1, a2, b1, b2) => {
 };
 var getSegmentToPolygonClearanceFromPoints = (start, end, polygon) => {
   if (polygon.length < 3) {
-    return { distance: Number.POSITIVE_INFINITY, center: start };
+    return {
+      distance: Number.POSITIVE_INFINITY,
+      center: start,
+      tracePoint: start,
+      obstaclePoint: start
+    };
   }
   const intersections = getPolygonEdges(polygon).map(
     ([edgeStart, edgeEnd]) => getSegmentIntersection(start, end, edgeStart, edgeEnd)
@@ -132,15 +137,23 @@ var getSegmentToPolygonClearanceFromPoints = (start, end, polygon) => {
       const tb = ((b.x - start.x) * dx + (b.y - start.y) * dy) / lengthSquared;
       return ta - tb;
     });
-    return { distance: 0, center: intersections[0] };
+    return {
+      distance: 0,
+      center: intersections[0],
+      tracePoint: intersections[0],
+      obstaclePoint: intersections[0]
+    };
   }
   if (isPointInsidePolygon(start, polygon) || isPointInsidePolygon(end, polygon)) {
+    const center = {
+      x: (start.x + end.x) / 2,
+      y: (start.y + end.y) / 2
+    };
     return {
       distance: 0,
-      center: {
-        x: (start.x + end.x) / 2,
-        y: (start.y + end.y) / 2
-      }
+      center,
+      tracePoint: center,
+      obstaclePoint: center
     };
   }
   let best = getClosestPointsBetweenSegments(
@@ -158,13 +171,13 @@ var getSegmentToPolygonClearanceFromPoints = (start, end, polygon) => {
     );
     if (candidate.distance < best.distance) best = candidate;
   }
-  return { distance: best.distance, center: best.center };
+  return {
+    distance: best.distance,
+    center: best.center,
+    tracePoint: best.pointOnA,
+    obstaclePoint: best.pointOnB
+  };
 };
-var getSegmentToPolygonClearance = (segment, polygon) => getSegmentToPolygonClearanceFromPoints(
-  { x: segment.x1, y: segment.y1 },
-  { x: segment.x2, y: segment.y2 },
-  polygon
-);
 var getSegmentToPillClearance = (segment, pad) => {
   const pill = getPillCenterLineForPad(pad);
   const closest = getClosestPointsBetweenSegments(
@@ -176,7 +189,9 @@ var getSegmentToPillClearance = (segment, pad) => {
   return {
     distance: closest.distance,
     center: closest.center,
-    radius: pill.radius
+    radius: pill.radius,
+    tracePoint: closest.pointOnA,
+    obstaclePoint: closest.pointOnB
   };
 };
 
@@ -193,6 +208,17 @@ function isPointOnSegment(point, segment) {
   const squaredLength = (segment.end.x - segment.start.x) ** 2 + (segment.end.y - segment.start.y) ** 2;
   return dotProduct <= squaredLength + POINT_ON_SEGMENT_TOLERANCE_MM;
 }
+function isPointInPolygon(point, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const pi = polygon[i];
+    const pj = polygon[j];
+    if (isPointOnSegment(point, { start: pi, end: pj })) return true;
+    const intersects = pi.y > point.y !== pj.y > point.y && point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y) + pi.x;
+    if (intersects) inside = !inside;
+  }
+  return inside;
+}
 function isPointInPad(point, pad) {
   if (pad.type === "pcb_smtpad") {
     if (pad.shape === "circle") {
@@ -204,12 +230,7 @@ function isPointInPad(point, pad) {
       return Math.abs(point.x - pad.x) <= halfWidth && Math.abs(point.y - pad.y) <= halfHeight;
     }
     if (pad.shape === "rotated_rect") {
-      const dx = point.x - pad.x;
-      const dy = point.y - pad.y;
-      const angle = -pad.ccw_rotation;
-      const rotatedX = dx * Math.cos(angle) - dy * Math.sin(angle);
-      const rotatedY = dx * Math.sin(angle) + dy * Math.cos(angle);
-      return Math.abs(rotatedX) <= pad.width / 2 && Math.abs(rotatedY) <= pad.height / 2;
+      return isPointInPolygon(point, getPolygonPointsForPad(pad));
     }
     if (pad.shape === "pill" || pad.shape === "rotated_pill") {
       if (pad.shape === "rotated_pill") {
@@ -233,30 +254,19 @@ function isPointInPad(point, pad) {
       return cornerX * cornerX + cornerY * cornerY <= radius * radius;
     }
     if (pad.shape === "polygon") {
-      let inside = false;
-      for (let i = 0, j = pad.points.length - 1; i < pad.points.length; j = i++) {
-        const pi = pad.points[i];
-        const pj = pad.points[j];
-        if (isPointOnSegment(point, { start: pi, end: pj })) return true;
-        const intersects = pi.y > point.y !== pj.y > point.y && point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y) + pi.x;
-        if (intersects) inside = !inside;
-      }
-      return inside;
+      return isPointInPolygon(point, pad.points);
     }
   }
   if (pad.type === "pcb_plated_hole") {
     if (pad.shape === "circle") {
       return getDistanceBetweenPoints(point, pad) <= pad.outer_diameter / 2;
     }
+    if ("rect_pad_width" in pad && "rect_pad_height" in pad) {
+      return isPointInPolygon(point, getPolygonPointsForPad(pad));
+    }
     if (pad.shape === "oval" || pad.shape === "pill") {
       return Math.abs(point.x - pad.x) <= pad.outer_width / 2 && Math.abs(point.y - pad.y) <= pad.outer_height / 2;
     }
-    if (pad.shape === "circular_hole_with_rect_pad") {
-      return Math.abs(point.x - pad.x) <= pad.rect_pad_width / 2 && Math.abs(point.y - pad.y) <= pad.rect_pad_height / 2;
-    }
-    if (pad.shape === "pill_hole_with_rect_pad") {
-      return Math.abs(point.x - pad.x) <= pad.rect_pad_width / 2 && Math.abs(point.y - pad.y) <= pad.rect_pad_height / 2;
-    }
   }
   return false;
 }
@@ -502,17 +512,284 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
 }
 
 // lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import { cju, getReadableNameForElement as getReadableNameForElement2 } from "@tscircuit/circuit-json-util";
+import { cju as cju2, getReadableNameForElement as getReadableNameForElement2 } from "@tscircuit/circuit-json-util";
 import { getPrimaryId } from "@tscircuit/circuit-json-util";
 import {
   segmentToBoundsMinDistance,
-  segmentToCircleMinDistance
+  segmentToCircleMinDistance as segmentToCircleMinDistance2
 } from "@tscircuit/math-utils";
-import { segmentToSegmentMinDistance as segmentToSegmentMinDistance2 } from "@tscircuit/math-utils";
+import { segmentToSegmentMinDistance as segmentToSegmentMinDistance3 } from "@tscircuit/math-utils";
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
 } from "circuit-json-to-connectivity-map";
 
+// lib/check-pad-clearance/common.ts
+import {
+  cju,
+  distanceBetweenCircleAndCircle,
+  distanceBetweenCircleAndPolygon,
+  distanceBetweenPolygonAndPolygon,
+  getBoundsOfPcbElements as getBoundsOfPcbElements2
+} from "@tscircuit/circuit-json-util";
+import {
+  midpoint,
+  pointToSegmentClosestPoint as pointToSegmentClosestPoint2,
+  segmentToCircleMinDistance,
+  segmentToSegmentMinDistance as segmentToSegmentMinDistance2
+} from "@tscircuit/math-utils";
+
+// node_modules/@tscircuit/jlcpcb-manufacturing-specs/lib/jlcpcb-manufacturing-specs.ts
+var jlcMinTolerances = {
+  min_trace_width: 0.1,
+  min_via_hole_edge_to_via_hole_edge_clearance: 0.1,
+  min_plated_hole_drill_edge_to_drill_edge_clearance: 0.15,
+  min_trace_to_pad_edge_clearance: 0.1,
+  min_pad_edge_to_pad_edge_clearance: 0.1,
+  min_board_edge_clearance: 0.2,
+  min_via_hole_diameter: 0.2,
+  min_via_pad_diameter: 0.3
+};
+
+// lib/drc-defaults.ts
+var DEFAULT_TRACE_MARGIN = 0.1;
+var DEFAULT_TRACE_THICKNESS = jlcMinTolerances.min_trace_width;
+var DEFAULT_VIA_DIAMETER = jlcMinTolerances.min_via_pad_diameter;
+var DEFAULT_VIA_BOARD_MARGIN = jlcMinTolerances.min_board_edge_clearance;
+var DEFAULT_SAME_NET_VIA_MARGIN = jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
+var DEFAULT_DIFFERENT_NET_VIA_MARGIN = jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
+var DEFAULT_PAD_PAD_CLEARANCE = jlcMinTolerances.min_pad_edge_to_pad_edge_clearance;
+var EPSILON = 5e-3;
+var getPcbBoard = (circuitJson) => circuitJson.find((el) => el.type === "pcb_board");
+var getBoardDrcValue = (board, key) => board?.[key];
+
+// lib/check-pad-clearance/common.ts
+var formatMm = (value) => {
+  const rounded = Math.round(value * 1e3) / 1e3;
+  return `${Number(rounded.toFixed(3))}mm`;
+};
+var getPadBounds = (pad) => getBoundsOfPcbElements2([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 isPillPad = (pad) => pad.type === "pcb_smtpad" && (pad.shape === "pill" || pad.shape === "rotated_pill");
+var getCircleShape = (pad) => {
+  const center = getPadCenter(pad);
+  return {
+    kind: "circle",
+    x: center.x,
+    y: center.y,
+    radius: getPadRadius(pad)
+  };
+};
+var getPolygonShape = (pad) => {
+  if (pad.type === "pcb_smtpad" && (pad.shape === "polygon" || pad.shape === "rotated_rect")) {
+    return {
+      kind: "polygon",
+      points: getPolygonPointsForPad(pad)
+    };
+  }
+  if (pad.type === "pcb_plated_hole" && "rect_pad_width" in pad && "rect_pad_height" in pad) {
+    return {
+      kind: "polygon",
+      points: getPolygonPointsForPad(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 (isPillPad(padA) && isPillPad(padB)) {
+    const pillA = getPillCenterLineForPad(padA);
+    const pillB = getPillCenterLineForPad(padB);
+    return segmentToSegmentMinDistance2(
+      pillA.start,
+      pillA.end,
+      pillB.start,
+      pillB.end
+    ) - pillA.radius - pillB.radius;
+  }
+  if (isPillPad(padA) && isCircularPad(padB)) {
+    const pill = getPillCenterLineForPad(padA);
+    return segmentToCircleMinDistance(pill.start, pill.end, getCircleShape(padB)) - pill.radius;
+  }
+  if (isCircularPad(padA) && isPillPad(padB)) {
+    const pill = getPillCenterLineForPad(padB);
+    return segmentToCircleMinDistance(pill.start, pill.end, getCircleShape(padA)) - pill.radius;
+  }
+  if (isPillPad(padA)) {
+    const pill = getPillCenterLineForPad(padA);
+    return getSegmentToPolygonClearanceFromPoints(
+      pill.start,
+      pill.end,
+      getPolygonShape(padB).points
+    ).distance - pill.radius;
+  }
+  if (isPillPad(padB)) {
+    const pill = getPillCenterLineForPad(padB);
+    return getSegmentToPolygonClearanceFromPoints(
+      pill.start,
+      pill.end,
+      getPolygonShape(padA).points
+    ).distance - pill.radius;
+  }
+  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) => [
+  ...cju(circuitJson).pcb_smtpad.list(),
+  ...cju(circuitJson).pcb_plated_hole.list()
+];
+var getTraceSegments = (circuitJson) => {
+  const pcbTraces = cju(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;
+  });
+};
+var getTraceCenter = (segment) => {
+  const routePoints = segment._pcbTrace.route.flatMap((routePoint) => {
+    if (routePoint.route_type === "through_pad") {
+      return [routePoint.start, routePoint.end];
+    }
+    return [{ x: routePoint.x, y: routePoint.y }];
+  });
+  const firstPoint = routePoints[0];
+  const lastPoint = routePoints[routePoints.length - 1];
+  if (!firstPoint || !lastPoint) {
+    return midpoint(
+      { x: segment.x1, y: segment.y1 },
+      { x: segment.x2, y: segment.y2 }
+    );
+  }
+  return midpoint(firstPoint, lastPoint);
+};
+var getCenterBetweenCopperEdges = ({
+  tracePoint,
+  obstaclePoint,
+  traceRadius,
+  obstacleRadius
+}) => {
+  const dx = obstaclePoint.x - tracePoint.x;
+  const dy = obstaclePoint.y - tracePoint.y;
+  const distance3 = Math.hypot(dx, dy);
+  if (distance3 === 0) return midpoint(tracePoint, obstaclePoint);
+  const unitX = dx / distance3;
+  const unitY = dy / distance3;
+  const traceEdge = {
+    x: tracePoint.x + unitX * traceRadius,
+    y: tracePoint.y + unitY * traceRadius
+  };
+  const obstacleEdge = {
+    x: obstaclePoint.x - unitX * obstacleRadius,
+    y: obstaclePoint.y - unitY * obstacleRadius
+  };
+  return midpoint(traceEdge, obstacleEdge);
+};
+var getTraceObstacleClearance = (segment, obstacle) => {
+  const start = { x: segment.x1, y: segment.y1 };
+  const end = { x: segment.x2, y: segment.y2 };
+  const traceRadius = segment.thickness / 2;
+  if (obstacle.type === "pcb_via" || isCircularPad(obstacle)) {
+    const circle = obstacle.type === "pcb_via" ? {
+      x: obstacle.x,
+      y: obstacle.y,
+      radius: obstacle.outer_diameter / 2
+    } : getCircleShape(obstacle);
+    const closestPoint = pointToSegmentClosestPoint2(circle, start, end);
+    return {
+      gap: segmentToCircleMinDistance(start, end, circle) - traceRadius,
+      center: getCenterBetweenCopperEdges({
+        tracePoint: closestPoint,
+        obstaclePoint: circle,
+        traceRadius,
+        obstacleRadius: circle.radius
+      })
+    };
+  }
+  if (isPillPad(obstacle)) {
+    const clearance2 = getSegmentToPillClearance(segment, obstacle);
+    return {
+      gap: clearance2.distance - traceRadius - clearance2.radius,
+      center: getCenterBetweenCopperEdges({
+        tracePoint: clearance2.tracePoint,
+        obstaclePoint: clearance2.obstaclePoint,
+        traceRadius,
+        obstacleRadius: clearance2.radius
+      })
+    };
+  }
+  const clearance = getSegmentToPolygonClearanceFromPoints(
+    start,
+    end,
+    getPolygonShape(obstacle).points
+  );
+  return {
+    gap: clearance.distance - traceRadius,
+    center: getCenterBetweenCopperEdges({
+      tracePoint: clearance.tracePoint,
+      obstaclePoint: clearance.obstaclePoint,
+      traceRadius,
+      obstacleRadius: 0
+    })
+  };
+};
+var isTraceObstacleOverlap = (gap) => gap <= 0;
+
 // lib/data-structures/SpatialIndex.ts
 var SpatialObjectIndex = class {
   buckets;
@@ -612,31 +889,6 @@ var SpatialObjectIndex = class {
   }
 };
 
-// node_modules/@tscircuit/jlcpcb-manufacturing-specs/lib/jlcpcb-manufacturing-specs.ts
-var jlcMinTolerances = {
-  min_trace_width: 0.1,
-  min_via_hole_edge_to_via_hole_edge_clearance: 0.1,
-  min_plated_hole_drill_edge_to_drill_edge_clearance: 0.15,
-  min_trace_to_pad_edge_clearance: 0.1,
-  min_pad_edge_to_pad_edge_clearance: 0.1,
-  min_board_edge_clearance: 0.2,
-  min_via_hole_diameter: 0.2,
-  min_via_pad_diameter: 0.3
-};
-
-// lib/drc-defaults.ts
-var DEFAULT_TRACE_MARGIN = 0.1;
-var DEFAULT_TRACE_THICKNESS = jlcMinTolerances.min_trace_width;
-var DEFAULT_VIA_DIAMETER = jlcMinTolerances.min_via_pad_diameter;
-var DEFAULT_VIA_BOARD_MARGIN = jlcMinTolerances.min_board_edge_clearance;
-var DEFAULT_SAME_NET_VIA_MARGIN = jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
-var DEFAULT_DIFFERENT_NET_VIA_MARGIN = jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
-var DEFAULT_PAD_PAD_CLEARANCE = jlcMinTolerances.min_pad_edge_to_pad_edge_clearance;
-var DEFAULT_PAD_TRACE_CLEARANCE = jlcMinTolerances.min_trace_to_pad_edge_clearance;
-var EPSILON = 5e-3;
-var getPcbBoard = (circuitJson) => circuitJson.find((el) => el.type === "pcb_board");
-var getBoardDrcValue = (board, key) => board?.[key];
-
 // lib/util/getLayersOfPcbElement.ts
 import { all_layers } from "circuit-json";
 function getLayersOfPcbElement(obj) {
@@ -900,7 +1152,7 @@ var clamp = (value, min, max) => {
 };
 
 // lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
-import { getBoundsOfPcbElements as getBoundsOfPcbElements2 } from "@tscircuit/circuit-json-util";
+import { getBoundsOfPcbElements as getBoundsOfPcbElements3 } from "@tscircuit/circuit-json-util";
 var getCollidableBounds = (collidable) => {
   if (collidable.type === "pcb_trace_segment") {
     return {
@@ -931,7 +1183,7 @@ var getCollidableBounds = (collidable) => {
       };
     }
   }
-  return getBoundsOfPcbElements2([collidable]);
+  return getBoundsOfPcbElements3([collidable]);
 };
 
 // lib/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
@@ -989,7 +1241,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
   connMap ??= getFullConnectivityMapFromCircuitJson2(circuitJson);
   const board = getPcbBoard(circuitJson);
   minClearance ??= getBoardDrcValue(board, "min_trace_to_pad_edge_clearance") ?? DEFAULT_TRACE_MARGIN;
-  const pcbTraces = cju(circuitJson).pcb_trace.list();
+  const pcbTraces = cju2(circuitJson).pcb_trace.list();
   const pcbTraceSegments = pcbTraces.flatMap((pcbTrace) => {
     const segments = [];
     for (let i = 0; i < pcbTrace.route.length - 1; i++) {
@@ -1012,11 +1264,11 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
     }
     return segments;
   });
-  const pcbSmtPads = cju(circuitJson).pcb_smtpad.list();
-  const pcbPlatedHoles = cju(circuitJson).pcb_plated_hole.list();
-  const pcbHoles = cju(circuitJson).pcb_hole.list();
-  const pcbVias = cju(circuitJson).pcb_via.list();
-  const pcbKeepouts = cju(circuitJson).pcb_keepout.list();
+  const pcbSmtPads = cju2(circuitJson).pcb_smtpad.list();
+  const pcbPlatedHoles = cju2(circuitJson).pcb_plated_hole.list();
+  const pcbHoles = cju2(circuitJson).pcb_hole.list();
+  const pcbVias = cju2(circuitJson).pcb_via.list();
+  const pcbKeepouts = cju2(circuitJson).pcb_keepout.list();
   const allObjects = [
     ...pcbTraceSegments,
     ...pcbSmtPads,
@@ -1031,7 +1283,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
   });
   const getReadableName = (id) => getReadableNameForElement2(circuitJson, id);
   const constructErrorMessage = (traceName, otherName, gap) => {
-    if (gap < 0) {
+    if (isTraceObstacleOverlap(gap)) {
       return `PCB trace ${traceName} overlaps with ${otherName} (accidental contact)`;
     }
     return `PCB trace ${traceName} is too close to ${otherName} (gap: ${gap.toFixed(3)}mm)`;
@@ -1054,7 +1306,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         if (segmentA.layer !== segmentB.layer) continue;
         if (connMap.areIdsConnected(segmentA.pcb_trace_id, segmentB.pcb_trace_id))
           continue;
-        const gap2 = segmentToSegmentMinDistance2(
+        const gap2 = segmentToSegmentMinDistance3(
           { x: segmentA.x1, y: segmentA.y1 },
           { x: segmentA.x2, y: segmentA.y2 },
           { x: segmentB.x1, y: segmentB.y1 },
@@ -1092,50 +1344,9 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         "pcb_trace_id" in obj ? obj.pcb_trace_id : primaryObjId
       ))
         continue;
-      const isCircular = obj.type === "pcb_via" || obj.type === "pcb_plated_hole" && obj.shape === "circle" || obj.type === "pcb_hole" || obj.type === "pcb_smtpad" && obj.shape === "circle";
-      if (isCircular) {
-        const radius = getRadiusOfCircuitJsonElement(obj);
-        const distance3 = segmentToCircleMinDistance(
-          { x: segmentA.x1, y: segmentA.y1 },
-          { x: segmentA.x2, y: segmentA.y2 },
-          { x: obj.x, y: obj.y, radius }
-        );
-        const gap2 = distance3 - segmentA.thickness / 2;
-        if (gap2 > minClearance - EPSILON) continue;
-        const pcb_trace_error_id = `overlap_${segmentA.pcb_trace_id}_${primaryObjId}`;
-        if (errorIds.has(pcb_trace_error_id)) continue;
-        errorIds.add(pcb_trace_error_id);
-        errors.push({
-          type: "pcb_trace_error",
-          error_type: "pcb_trace_error",
-          message: constructErrorMessage(
-            getReadableName(segmentA.pcb_trace_id),
-            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
-            gap2
-          ),
-          pcb_trace_id: segmentA.pcb_trace_id,
-          center: getClosestPointBetweenSegmentAndBounds(
-            segmentA,
-            getCollidableBounds(obj)
-          ),
-          source_trace_id: "",
-          pcb_trace_error_id,
-          pcb_component_ids: [
-            "pcb_component_id" in obj ? obj.pcb_component_id : void 0
-          ].filter(Boolean),
-          pcb_port_ids: [
-            ...getPcbPortIdsConnectedToTraces([segmentA._pcbTrace]),
-            "pcb_port_id" in obj ? obj.pcb_port_id : void 0
-          ].filter(Boolean)
-        });
-      }
-      if (obj.type === "pcb_smtpad" && (obj.shape === "pill" || obj.shape === "rotated_pill")) {
-        const { distance: distance3, center, radius } = getSegmentToPillClearance(
-          segmentA,
-          obj
-        );
-        const gap2 = distance3 - segmentA.thickness / 2 - radius;
-        if (gap2 > minClearance - EPSILON) continue;
+      if (obj.type === "pcb_smtpad" || obj.type === "pcb_plated_hole" || obj.type === "pcb_via") {
+        const { gap: gap2, center } = getTraceObstacleClearance(segmentA, obj);
+        if (!isTraceObstacleOverlap(gap2)) continue;
         const pcb_trace_error_id = `overlap_${segmentA.pcb_trace_id}_${primaryObjId}`;
         if (errorIds.has(pcb_trace_error_id)) continue;
         errorIds.add(pcb_trace_error_id);
@@ -1144,7 +1355,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
           error_type: "pcb_trace_error",
           message: constructErrorMessage(
             getReadableName(segmentA.pcb_trace_id),
-            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
+            `${obj.type} "${getReadableName(primaryObjId)}"`,
             gap2
           ),
           pcb_trace_id: segmentA.pcb_trace_id,
@@ -1161,12 +1372,13 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         });
         continue;
       }
-      const isPolygon = obj.type === "pcb_smtpad" && (obj.shape === "rotated_rect" || obj.shape === "polygon") || obj.type === "pcb_plated_hole" && "rect_pad_width" in obj && "rect_pad_height" in obj;
-      if (isPolygon) {
-        const padOutline = getPolygonPointsForPad(obj);
-        const { distance: distance3, center } = getSegmentToPolygonClearance(
-          segmentA,
-          padOutline
+      const isCircular = obj.type === "pcb_hole";
+      if (isCircular) {
+        const radius = getRadiusOfCircuitJsonElement(obj);
+        const distance3 = segmentToCircleMinDistance2(
+          { x: segmentA.x1, y: segmentA.y1 },
+          { x: segmentA.x2, y: segmentA.y2 },
+          { x: obj.x, y: obj.y, radius }
         );
         const gap2 = distance3 - segmentA.thickness / 2;
         if (gap2 > minClearance - EPSILON) continue;
@@ -1182,7 +1394,10 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
             gap2
           ),
           pcb_trace_id: segmentA.pcb_trace_id,
-          center,
+          center: getClosestPointBetweenSegmentAndBounds(
+            segmentA,
+            getCollidableBounds(obj)
+          ),
           source_trace_id: "",
           pcb_trace_error_id,
           pcb_component_ids: [
@@ -1193,7 +1408,6 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
             "pcb_port_id" in obj ? obj.pcb_port_id : void 0
           ].filter(Boolean)
         });
-        continue;
       }
       const gap = segmentToBoundsMinDistance(
         { x: segmentA.x1, y: segmentA.y1 },
@@ -1657,11 +1871,11 @@ function checkDifferentNetViaSpacing(circuitJson, {
 }
 
 // lib/check-source-traces-match-pcb-trace-thickness.ts
-import { cju as cju2 } from "@tscircuit/circuit-json-util";
+import { cju as cju3 } from "@tscircuit/circuit-json-util";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson5 } from "circuit-json-to-connectivity-map";
 function checkSourceTracesMatchPcbTraceThickness(circuitJson) {
   const warnings = [];
-  const db = cju2(circuitJson);
+  const db = cju3(circuitJson);
   const sourceTraces = db.source_trace.list();
   const pcbTraces = db.pcb_trace.list();
   const pcbPorts = db.pcb_port.list();
@@ -2044,8 +2258,8 @@ function checkTracesAreContiguous(circuitJson) {
 }
 
 // lib/check-trace-out-of-board/checkTraceOutOfBoard.ts
-import { cju as cju3 } from "@tscircuit/circuit-json-util";
-import { segmentToSegmentMinDistance as segmentToSegmentMinDistance3 } from "@tscircuit/math-utils";
+import { cju as cju4 } from "@tscircuit/circuit-json-util";
+import { segmentToSegmentMinDistance as segmentToSegmentMinDistance4 } from "@tscircuit/math-utils";
 function getBoardPolygonPoints(board) {
   if (board.outline && board.outline.length > 0) {
     return board.outline.map((p) => ({ x: p.x, y: p.y }));
@@ -2075,7 +2289,7 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
   const margin = config.margin ?? getBoardDrcValue(board, "min_board_edge_clearance") ?? jlcMinTolerances.min_board_edge_clearance;
   const boardPoints = getBoardPolygonPoints(board);
   if (!boardPoints) return errors;
-  const pcbTraces = cju3(circuitJson).pcb_trace.list();
+  const pcbTraces = cju4(circuitJson).pcb_trace.list();
   for (const trace of pcbTraces) {
     if (trace.route.length < 2) continue;
     for (let i = 0; i < trace.route.length - 1; i++) {
@@ -2089,7 +2303,7 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
       for (let j = 0; j < boardPoints.length; j++) {
         const edgeStart = boardPoints[j];
         const edgeEnd = boardPoints[(j + 1) % boardPoints.length];
-        const distance3 = segmentToSegmentMinDistance3(
+        const distance3 = segmentToSegmentMinDistance4(
           segmentStart,
           segmentEnd,
           edgeStart,
@@ -2124,15 +2338,15 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
 
 // lib/check-pcb-components-overlap/checkPcbComponentOverlap.ts
 import {
-  cju as cju4,
-  getBoundsOfPcbElements as getBoundsOfPcbElements4,
+  cju as cju5,
+  getBoundsOfPcbElements as getBoundsOfPcbElements5,
   getPrimaryId as getPrimaryId2
 } from "@tscircuit/circuit-json-util";
 import { doBoundsOverlap as doBoundsOverlap2 } from "@tscircuit/math-utils";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7 } from "circuit-json-to-connectivity-map";
 
 // lib/check-pcb-components-overlap/doPcbElementsOverlap.ts
-import { getBoundsOfPcbElements as getBoundsOfPcbElements3 } from "@tscircuit/circuit-json-util";
+import { getBoundsOfPcbElements as getBoundsOfPcbElements4 } from "@tscircuit/circuit-json-util";
 import { doBoundsOverlap } from "@tscircuit/math-utils";
 function getElementLayers(elem) {
   if (elem.type === "pcb_courtyard_circle" || elem.type === "pcb_courtyard_outline" || elem.type === "pcb_courtyard_polygon" || elem.type === "pcb_courtyard_rect") {
@@ -2148,8 +2362,8 @@ function doPcbElementsOverlap(elem1, elem2) {
   const layers1 = getElementLayers(elem1);
   const layers2 = getElementLayers(elem2);
   if (!doLayersOverlap(layers1, layers2)) return false;
-  const bounds1 = getBoundsOfPcbElements3([elem1]);
-  const bounds2 = getBoundsOfPcbElements3([elem2]);
+  const bounds1 = getBoundsOfPcbElements4([elem1]);
+  const bounds2 = getBoundsOfPcbElements4([elem2]);
   return doBoundsOverlap(bounds1, bounds2);
 }
 
@@ -2166,9 +2380,9 @@ var formatOverlapElementDescription = (circuitJson, element) => {
 function checkPcbComponentOverlap(circuitJson) {
   const errors = [];
   const connMap = getFullConnectivityMapFromCircuitJson7(circuitJson);
-  const smtPads = cju4(circuitJson).pcb_smtpad.list();
-  const platedHoles = cju4(circuitJson).pcb_plated_hole.list();
-  const holes = cju4(circuitJson).pcb_hole.list();
+  const smtPads = cju5(circuitJson).pcb_smtpad.list();
+  const platedHoles = cju5(circuitJson).pcb_plated_hole.list();
+  const holes = cju5(circuitJson).pcb_hole.list();
   const courtyards = circuitJson.filter(isCourtyardElement);
   const componentMap = /* @__PURE__ */ new Map();
   for (const pad of smtPads) {
@@ -2212,7 +2426,7 @@ function checkPcbComponentOverlap(circuitJson) {
   }
   for (const [componentId, componentData] of componentMap) {
     if (componentData.elements.length > 0) {
-      componentData.bounds = getBoundsOfPcbElements4(componentData.elements);
+      componentData.bounds = getBoundsOfPcbElements5(componentData.elements);
     }
   }
   const componentsWithElements = Array.from(componentMap.values());
@@ -2285,160 +2499,6 @@ import {
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson8
 } 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,
-  segmentToCircleMinDistance as segmentToCircleMinDistance2,
-  segmentToSegmentMinDistance as segmentToSegmentMinDistance4
-} 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 isPillPad = (pad) => pad.type === "pcb_smtpad" && (pad.shape === "pill" || pad.shape === "rotated_pill");
-var getCircleShape = (pad) => {
-  const center = getPadCenter(pad);
-  return {
-    kind: "circle",
-    x: center.x,
-    y: center.y,
-    radius: getPadRadius(pad)
-  };
-};
-var getPolygonShape = (pad) => {
-  if (pad.type === "pcb_smtpad" && (pad.shape === "polygon" || pad.shape === "rotated_rect")) {
-    return {
-      kind: "polygon",
-      points: getPolygonPointsForPad(pad)
-    };
-  }
-  if (pad.type === "pcb_plated_hole" && "rect_pad_width" in pad && "rect_pad_height" in pad) {
-    return {
-      kind: "polygon",
-      points: getPolygonPointsForPad(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 (isPillPad(padA) && isPillPad(padB)) {
-    const pillA = getPillCenterLineForPad(padA);
-    const pillB = getPillCenterLineForPad(padB);
-    return segmentToSegmentMinDistance4(
-      pillA.start,
-      pillA.end,
-      pillB.start,
-      pillB.end
-    ) - pillA.radius - pillB.radius;
-  }
-  if (isPillPad(padA) && isCircularPad(padB)) {
-    const pill = getPillCenterLineForPad(padA);
-    return segmentToCircleMinDistance2(pill.start, pill.end, getCircleShape(padB)) - pill.radius;
-  }
-  if (isCircularPad(padA) && isPillPad(padB)) {
-    const pill = getPillCenterLineForPad(padB);
-    return segmentToCircleMinDistance2(pill.start, pill.end, getCircleShape(padA)) - pill.radius;
-  }
-  if (isPillPad(padA)) {
-    const pill = getPillCenterLineForPad(padA);
-    return getSegmentToPolygonClearanceFromPoints(
-      pill.start,
-      pill.end,
-      getPolygonShape(padB).points
-    ).distance - pill.radius;
-  }
-  if (isPillPad(padB)) {
-    const pill = getPillCenterLineForPad(padB);
-    return getSegmentToPolygonClearanceFromPoints(
-      pill.start,
-      pill.end,
-      getPolygonShape(padA).points
-    ).distance - pill.radius;
-  }
-  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,
   minClearance
@@ -2500,10 +2560,6 @@ import {
   getPrimaryId as getPrimaryId4,
   getReadableNameForElement as getReadableNameForElement7
 } from "@tscircuit/circuit-json-util";
-import {
-  segmentToBoundsMinDistance as segmentToBoundsMinDistance2,
-  segmentToCircleMinDistance as segmentToCircleMinDistance3
-} from "@tscircuit/math-utils";
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson9
 } from "circuit-json-to-connectivity-map";
@@ -2523,6 +2579,7 @@ function checkPadTraceClearance(circuitJson, {
     getId: (pad) => getPrimaryId4(pad)
   });
   const errors = /* @__PURE__ */ new Map();
+  const overlappingPairIds = /* @__PURE__ */ new Set();
   for (const segment of segments) {
     const nearbyPads = spatialIndex.getObjectsInBounds(
       getCollidableBounds(segment),
@@ -2532,24 +2589,15 @@ function checkPadTraceClearance(circuitJson, {
       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 = pad.type === "pcb_smtpad" && (pad.shape === "pill" || pad.shape === "rotated_pill") ? (() => {
-        const { distance: distance3, radius } = getSegmentToPillClearance(
-          segment,
-          pad
-        );
-        return distance3 - segment.thickness / 2 - radius;
-      })() : isCircularPad(pad) ? segmentToCircleMinDistance3(
-        { 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 >= minClearance) continue;
       const pairId = `${padId}_${segment.pcb_trace_id}`;
+      const { gap } = getTraceObstacleClearance(segment, pad);
+      if (isTraceObstacleOverlap(gap)) {
+        errors.delete(pairId);
+        overlappingPairIds.add(pairId);
+        continue;
+      }
+      if (overlappingPairIds.has(pairId)) continue;
+      if (gap + EPSILON >= minClearance) continue;
       const nextError = {
         type: "pcb_pad_trace_clearance_error",
         pcb_pad_trace_clearance_error_id: `pad_trace_clearance_${pairId}`,
@@ -2559,10 +2607,7 @@ function checkPadTraceClearance(circuitJson, {
         pcb_trace_id: segment.pcb_trace_id,
         minimum_clearance: minClearance,
         actual_clearance: gap,
-        center: {
-          x: (center.x + (segment.x1 + segment.x2) / 2) / 2,
-          y: (center.y + (segment.y1 + segment.y2) / 2) / 2
-        }
+        center: getTraceCenter(segment)
       };
       const current = errors.get(pairId);
       if (!current || gap < current.gap) {
@@ -2575,27 +2620,9 @@ function checkPadTraceClearance(circuitJson, {
 
 // lib/check-via-trace-clearance.ts
 import { getReadableNameForElement as getReadableNameForElement8 } from "@tscircuit/circuit-json-util";
-import { segmentToCircleMinDistance as segmentToCircleMinDistance4 } from "@tscircuit/math-utils";
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson10
 } 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,
   minClearance
@@ -2607,28 +2634,21 @@ function checkViaTraceClearance(circuitJson, {
   minClearance ??= getBoardDrcValue(board, "min_trace_to_pad_edge_clearance") ?? jlcMinTolerances.min_trace_to_pad_edge_clearance;
   connMap ??= getFullConnectivityMapFromCircuitJson10(circuitJson);
   const errors = /* @__PURE__ */ new Map();
+  const overlappingPairIds = /* @__PURE__ */ new Set();
   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 = segmentToCircleMinDistance4(
-        { 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 >= minClearance) 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 { gap } = getTraceObstacleClearance(segment, via);
+      if (isTraceObstacleOverlap(gap)) {
+        errors.delete(pairId);
+        overlappingPairIds.add(pairId);
+        continue;
+      }
+      if (overlappingPairIds.has(pairId)) continue;
+      if (gap + EPSILON >= minClearance) continue;
       const nextError = {
         type: "pcb_via_trace_clearance_error",
         pcb_via_trace_clearance_error_id: `via_trace_clearance_${pairId}`,
@@ -2638,10 +2658,7 @@ function checkViaTraceClearance(circuitJson, {
         pcb_trace_id: segment.pcb_trace_id,
         minimum_clearance: minClearance,
         actual_clearance: gap,
-        center: {
-          x: (via.x + closestPoint.x) / 2,
-          y: (via.y + closestPoint.y) / 2
-        }
+        center: getTraceCenter(segment)
       };
       const current = errors.get(pairId);
       if (!current || gap < current.gap) {
@@ -2652,6 +2669,27 @@ function checkViaTraceClearance(circuitJson, {
   return Array.from(errors.values()).map(({ error }) => error);
 }
 
+// lib/dedupe-pcb-drc-errors.ts
+var dedupePcbDrcErrors = (errors) => {
+  const specificallyReportedPairIds = /* @__PURE__ */ new Set();
+  for (const error of errors) {
+    if (error.type === "pcb_pad_trace_clearance_error" && typeof error.pcb_trace_id === "string" && typeof error.pcb_pad_id === "string") {
+      specificallyReportedPairIds.add(
+        `overlap_${error.pcb_trace_id}_${error.pcb_pad_id}`
+      );
+    }
+    if (error.type === "pcb_via_trace_clearance_error" && typeof error.pcb_trace_id === "string" && typeof error.pcb_via_id === "string") {
+      specificallyReportedPairIds.add(
+        `overlap_${error.pcb_trace_id}_${error.pcb_via_id}`
+      );
+    }
+  }
+  return errors.filter((element) => {
+    const error = element;
+    return !(error.type === "pcb_trace_error" && typeof error.pcb_trace_error_id === "string" && specificallyReportedPairIds.has(error.pcb_trace_error_id));
+  });
+};
+
 // lib/check-pin-must-be-connected.ts
 function checkPinMustBeConnected(circuitJson) {
   const errors = [];
@@ -3057,7 +3095,6 @@ async function runAllPlacementChecks(circuitJson) {
     ...checkPcbComponentsOutOfBoard(circuitJson),
     ...checkPcbComponentOverlap(circuitJson),
     ...checkPadPadClearance(circuitJson),
-    ...checkPadTraceClearance(circuitJson),
     ...checkCourtyardOverlap(circuitJson),
     ...checkConnectorAccessibleOrientation(circuitJson)
   ];
@@ -3077,6 +3114,7 @@ async function runAllRoutingChecks(circuitJson) {
     ...checkEachPcbPortConnectedToPcbTraces(circuitJson),
     ...checkSourceTracesHavePcbTraces(circuitJson),
     ...checkEachPcbTraceNonOverlapping(circuitJson),
+    ...checkPadTraceClearance(circuitJson),
     ...checkViaTraceClearance(circuitJson),
     ...checkSameNetViaSpacing(circuitJson),
     ...checkDifferentNetViaSpacing(circuitJson),
@@ -3113,6 +3151,7 @@ export {
   checkTracesAreContiguous,
   checkViaTraceClearance,
   checkViasOffBoard,
+  dedupePcbDrcErrors,
   runAllChecks,
   runAllNetlistChecks,
   runAllPinSpecificationChecks,