@tscircuit/checks 0.0.138 → 0.0.139

package/dist/index.js

@@ -1,3 +1,266 @@
+// lib/check-traces-are-contiguous/is-point-in-pad.ts
+import { pointToSegmentDistance } from "@tscircuit/math-utils";
+
+// lib/check-each-pcb-trace-non-overlapping/segment-to-polygon-clearance.ts
+import {
+  distSq,
+  getSegmentIntersection,
+  isPointInsidePolygon,
+  pointToSegmentClosestPoint,
+  segmentToSegmentMinDistance
+} from "@tscircuit/math-utils";
+var rotatePoint = (point, angleDegrees) => {
+  const angle = angleDegrees * Math.PI / 180;
+  return {
+    x: point.x * Math.cos(angle) - point.y * Math.sin(angle),
+    y: point.x * Math.sin(angle) + point.y * Math.cos(angle)
+  };
+};
+var getRotatedRectPoints = ({
+  x,
+  y,
+  width,
+  height,
+  ccwRotation
+}) => {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  return [
+    { x: -halfWidth, y: -halfHeight },
+    { x: halfWidth, y: -halfHeight },
+    { x: halfWidth, y: halfHeight },
+    { x: -halfWidth, y: halfHeight }
+  ].map((point) => {
+    const rotated = rotatePoint(point, ccwRotation);
+    return { x: x + rotated.x, y: y + rotated.y };
+  });
+};
+var getPillCenterLineForPad = (pad) => {
+  const ccwRotation = pad.shape === "rotated_pill" ? pad.ccw_rotation : 0;
+  const halfLineLength = Math.max(
+    Math.max(pad.width, pad.height) / 2 - pad.radius,
+    0
+  );
+  const axis = pad.width >= pad.height ? { x: halfLineLength, y: 0 } : { x: 0, y: halfLineLength };
+  const rotatedAxis = rotatePoint(axis, ccwRotation);
+  return {
+    start: { x: pad.x - rotatedAxis.x, y: pad.y - rotatedAxis.y },
+    end: { x: pad.x + rotatedAxis.x, y: pad.y + rotatedAxis.y },
+    radius: pad.radius
+  };
+};
+var getPolygonPointsForPad = (pad) => {
+  if (pad.type === "pcb_smtpad") {
+    if (pad.shape === "polygon") return pad.points;
+    if (pad.shape === "rotated_rect") {
+      return getRotatedRectPoints({
+        x: pad.x,
+        y: pad.y,
+        width: pad.width,
+        height: pad.height,
+        ccwRotation: pad.ccw_rotation
+      });
+    }
+  }
+  if (pad.type === "pcb_plated_hole" && "rect_pad_width" in pad && "rect_pad_height" in pad) {
+    return getRotatedRectPoints({
+      x: pad.x,
+      y: pad.y,
+      width: pad.rect_pad_width,
+      height: pad.rect_pad_height,
+      ccwRotation: "rect_ccw_rotation" in pad && typeof pad.rect_ccw_rotation === "number" ? pad.rect_ccw_rotation : 0
+    });
+  }
+  throw new Error(
+    `Expected polygonal pad geometry, got ${pad.type} with shape "${pad.shape}"`
+  );
+};
+var getPolygonEdges = (points) => points.map(
+  (point, index) => [point, points[(index + 1) % points.length]]
+);
+var getClosestPointsBetweenSegments = (a1, a2, b1, b2) => {
+  const intersection = getSegmentIntersection(a1, a2, b1, b2);
+  if (intersection) {
+    return {
+      distance: 0,
+      pointOnA: intersection,
+      pointOnB: intersection,
+      center: intersection
+    };
+  }
+  const candidates = [
+    { pointOnA: a1, pointOnB: pointToSegmentClosestPoint(a1, b1, b2) },
+    { pointOnA: a2, pointOnB: pointToSegmentClosestPoint(a2, b1, b2) },
+    { pointOnA: pointToSegmentClosestPoint(b1, a1, a2), pointOnB: b1 },
+    { pointOnA: pointToSegmentClosestPoint(b2, a1, a2), pointOnB: b2 }
+  ];
+  let best = candidates[0];
+  let bestDistanceSquared = distSq(best.pointOnA, best.pointOnB);
+  for (const candidate of candidates.slice(1)) {
+    const candidateDistanceSquared = distSq(
+      candidate.pointOnA,
+      candidate.pointOnB
+    );
+    if (candidateDistanceSquared < bestDistanceSquared) {
+      best = candidate;
+      bestDistanceSquared = candidateDistanceSquared;
+    }
+  }
+  return {
+    distance: segmentToSegmentMinDistance(a1, a2, b1, b2),
+    pointOnA: best.pointOnA,
+    pointOnB: best.pointOnB,
+    center: {
+      x: (best.pointOnA.x + best.pointOnB.x) / 2,
+      y: (best.pointOnA.y + best.pointOnB.y) / 2
+    }
+  };
+};
+var getSegmentToPolygonClearanceFromPoints = (start, end, polygon) => {
+  if (polygon.length < 3) {
+    return { distance: Number.POSITIVE_INFINITY, center: start };
+  }
+  const intersections = getPolygonEdges(polygon).map(
+    ([edgeStart, edgeEnd]) => getSegmentIntersection(start, end, edgeStart, edgeEnd)
+  ).filter((point) => point !== null);
+  if (intersections.length > 0) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const lengthSquared = dx * dx + dy * dy;
+    intersections.sort((a, b) => {
+      const ta = ((a.x - start.x) * dx + (a.y - start.y) * dy) / lengthSquared;
+      const tb = ((b.x - start.x) * dx + (b.y - start.y) * dy) / lengthSquared;
+      return ta - tb;
+    });
+    return { distance: 0, center: intersections[0] };
+  }
+  if (isPointInsidePolygon(start, polygon) || isPointInsidePolygon(end, polygon)) {
+    return {
+      distance: 0,
+      center: {
+        x: (start.x + end.x) / 2,
+        y: (start.y + end.y) / 2
+      }
+    };
+  }
+  let best = getClosestPointsBetweenSegments(
+    start,
+    end,
+    polygon[0],
+    polygon[1]
+  );
+  for (const [edgeStart, edgeEnd] of getPolygonEdges(polygon).slice(1)) {
+    const candidate = getClosestPointsBetweenSegments(
+      start,
+      end,
+      edgeStart,
+      edgeEnd
+    );
+    if (candidate.distance < best.distance) best = candidate;
+  }
+  return { distance: best.distance, center: best.center };
+};
+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(
+    { x: segment.x1, y: segment.y1 },
+    { x: segment.x2, y: segment.y2 },
+    pill.start,
+    pill.end
+  );
+  return {
+    distance: closest.distance,
+    center: closest.center,
+    radius: pill.radius
+  };
+};
+
+// lib/check-traces-are-contiguous/is-point-in-pad.ts
+function getDistanceBetweenPoints(pointA, pointB) {
+  return Math.sqrt((pointB.x - pointA.x) ** 2 + (pointB.y - pointA.y) ** 2);
+}
+var POINT_ON_SEGMENT_TOLERANCE_MM = 1e-9;
+function isPointOnSegment(point, segment) {
+  const crossProduct = (point.y - segment.start.y) * (segment.end.x - segment.start.x) - (point.x - segment.start.x) * (segment.end.y - segment.start.y);
+  if (Math.abs(crossProduct) > POINT_ON_SEGMENT_TOLERANCE_MM) return false;
+  const dotProduct = (point.x - segment.start.x) * (segment.end.x - segment.start.x) + (point.y - segment.start.y) * (segment.end.y - segment.start.y);
+  if (dotProduct < -POINT_ON_SEGMENT_TOLERANCE_MM) return false;
+  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 isPointInPad(point, pad) {
+  if (pad.type === "pcb_smtpad") {
+    if (pad.shape === "circle") {
+      return getDistanceBetweenPoints(point, pad) <= pad.radius;
+    }
+    if (pad.shape === "rect") {
+      const halfWidth = pad.width / 2;
+      const halfHeight = pad.height / 2;
+      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;
+    }
+    if (pad.shape === "pill" || pad.shape === "rotated_pill") {
+      if (pad.shape === "rotated_pill") {
+        const pill = getPillCenterLineForPad(pad);
+        return pointToSegmentDistance(point, pill.start, pill.end) <= pill.radius;
+      }
+      const halfWidth = pad.width / 2;
+      const halfHeight = pad.height / 2;
+      const radius = pad.radius;
+      if (Math.abs(point.x - pad.x) <= halfWidth - radius && Math.abs(point.y - pad.y) <= halfHeight) {
+        return true;
+      }
+      const cornerX = Math.max(
+        Math.abs(point.x - pad.x) - (halfWidth - radius),
+        0
+      );
+      const cornerY = Math.max(
+        Math.abs(point.y - pad.y) - (halfHeight - radius),
+        0
+      );
+      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;
+    }
+  }
+  if (pad.type === "pcb_plated_hole") {
+    if (pad.shape === "circle") {
+      return getDistanceBetweenPoints(point, pad) <= pad.outer_diameter / 2;
+    }
+    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;
+}
+
 // lib/add-start-and-end-port-ids-if-missing.ts
 function distance(x1, y1, x2, y2) {
   return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
@@ -20,6 +283,8 @@ var addStartAndEndPortIdsIfMissing = (soup) => {
           return Math.abs(point.x - pad.x) < pad.width / 2 + traceWidth / 2 && Math.abs(point.y - pad.y) < pad.height / 2 + traceWidth / 2;
         } else if (pad.shape === "circle") {
           return distance(point.x, point.y, pad.x, pad.y) < pad.radius;
+        } else if (pad.shape === "pill" || pad.shape === "rotated_pill") {
+          return isPointInPad(point, pad);
         }
       });
       if (smtPad) return smtPad.pcb_port_id ?? null;
@@ -636,156 +901,6 @@ var clamp = (value, min, max) => {
 
 // lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
 import { getBoundsOfPcbElements as getBoundsOfPcbElements2 } from "@tscircuit/circuit-json-util";
-
-// lib/check-each-pcb-trace-non-overlapping/segment-to-polygon-clearance.ts
-import {
-  distSq,
-  getSegmentIntersection,
-  isPointInsidePolygon,
-  pointToSegmentClosestPoint,
-  segmentToSegmentMinDistance
-} from "@tscircuit/math-utils";
-var rotatePoint = (point, angleDegrees) => {
-  const angle = angleDegrees * Math.PI / 180;
-  return {
-    x: point.x * Math.cos(angle) - point.y * Math.sin(angle),
-    y: point.x * Math.sin(angle) + point.y * Math.cos(angle)
-  };
-};
-var getRotatedRectPoints = ({
-  x,
-  y,
-  width,
-  height,
-  ccwRotation
-}) => {
-  const halfWidth = width / 2;
-  const halfHeight = height / 2;
-  return [
-    { x: -halfWidth, y: -halfHeight },
-    { x: halfWidth, y: -halfHeight },
-    { x: halfWidth, y: halfHeight },
-    { x: -halfWidth, y: halfHeight }
-  ].map((point) => {
-    const rotated = rotatePoint(point, ccwRotation);
-    return { x: x + rotated.x, y: y + rotated.y };
-  });
-};
-var getPolygonPointsForPad = (pad) => {
-  if (pad.type === "pcb_smtpad") {
-    if (pad.shape === "polygon") return pad.points;
-    if (pad.shape === "rotated_rect") {
-      return getRotatedRectPoints({
-        x: pad.x,
-        y: pad.y,
-        width: pad.width,
-        height: pad.height,
-        ccwRotation: pad.ccw_rotation
-      });
-    }
-  }
-  if (pad.type === "pcb_plated_hole" && "rect_pad_width" in pad && "rect_pad_height" in pad) {
-    return getRotatedRectPoints({
-      x: pad.x,
-      y: pad.y,
-      width: pad.rect_pad_width,
-      height: pad.rect_pad_height,
-      ccwRotation: "rect_ccw_rotation" in pad && typeof pad.rect_ccw_rotation === "number" ? pad.rect_ccw_rotation : 0
-    });
-  }
-  throw new Error(
-    `Expected polygonal pad geometry, got ${pad.type} with shape "${pad.shape}"`
-  );
-};
-var getPolygonEdges = (points) => points.map(
-  (point, index) => [point, points[(index + 1) % points.length]]
-);
-var getClosestPointsBetweenSegments = (a1, a2, b1, b2) => {
-  const intersection = getSegmentIntersection(a1, a2, b1, b2);
-  if (intersection) {
-    return {
-      distance: 0,
-      pointOnA: intersection,
-      pointOnB: intersection,
-      center: intersection
-    };
-  }
-  const candidates = [
-    { pointOnA: a1, pointOnB: pointToSegmentClosestPoint(a1, b1, b2) },
-    { pointOnA: a2, pointOnB: pointToSegmentClosestPoint(a2, b1, b2) },
-    { pointOnA: pointToSegmentClosestPoint(b1, a1, a2), pointOnB: b1 },
-    { pointOnA: pointToSegmentClosestPoint(b2, a1, a2), pointOnB: b2 }
-  ];
-  let best = candidates[0];
-  let bestDistanceSquared = distSq(best.pointOnA, best.pointOnB);
-  for (const candidate of candidates.slice(1)) {
-    const candidateDistanceSquared = distSq(
-      candidate.pointOnA,
-      candidate.pointOnB
-    );
-    if (candidateDistanceSquared < bestDistanceSquared) {
-      best = candidate;
-      bestDistanceSquared = candidateDistanceSquared;
-    }
-  }
-  return {
-    distance: segmentToSegmentMinDistance(a1, a2, b1, b2),
-    pointOnA: best.pointOnA,
-    pointOnB: best.pointOnB,
-    center: {
-      x: (best.pointOnA.x + best.pointOnB.x) / 2,
-      y: (best.pointOnA.y + best.pointOnB.y) / 2
-    }
-  };
-};
-var getSegmentToPolygonClearance = (segment, polygon) => {
-  const start = { x: segment.x1, y: segment.y1 };
-  const end = { x: segment.x2, y: segment.y2 };
-  if (polygon.length < 3) {
-    return { distance: Number.POSITIVE_INFINITY, center: start };
-  }
-  const intersections = getPolygonEdges(polygon).map(
-    ([edgeStart, edgeEnd]) => getSegmentIntersection(start, end, edgeStart, edgeEnd)
-  ).filter((point) => point !== null);
-  if (intersections.length > 0) {
-    const dx = end.x - start.x;
-    const dy = end.y - start.y;
-    const lengthSquared = dx * dx + dy * dy;
-    intersections.sort((a, b) => {
-      const ta = ((a.x - start.x) * dx + (a.y - start.y) * dy) / lengthSquared;
-      const tb = ((b.x - start.x) * dx + (b.y - start.y) * dy) / lengthSquared;
-      return ta - tb;
-    });
-    return { distance: 0, center: intersections[0] };
-  }
-  if (isPointInsidePolygon(start, polygon) || isPointInsidePolygon(end, polygon)) {
-    return {
-      distance: 0,
-      center: {
-        x: (start.x + end.x) / 2,
-        y: (start.y + end.y) / 2
-      }
-    };
-  }
-  let best = getClosestPointsBetweenSegments(
-    start,
-    end,
-    polygon[0],
-    polygon[1]
-  );
-  for (const [edgeStart, edgeEnd] of getPolygonEdges(polygon).slice(1)) {
-    const candidate = getClosestPointsBetweenSegments(
-      start,
-      end,
-      edgeStart,
-      edgeEnd
-    );
-    if (candidate.distance < best.distance) best = candidate;
-  }
-  return { distance: best.distance, center: best.center };
-};
-
-// lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
 var getCollidableBounds = (collidable) => {
   if (collidable.type === "pcb_trace_segment") {
     return {
@@ -806,6 +921,15 @@ var getCollidableBounds = (collidable) => {
         maxY: Math.max(...polygonPoints.map((point) => point.y))
       };
     }
+    if (collidable.type === "pcb_smtpad" && collidable.shape === "rotated_pill") {
+      const pill = getPillCenterLineForPad(collidable);
+      return {
+        minX: Math.min(pill.start.x, pill.end.x) - pill.radius,
+        minY: Math.min(pill.start.y, pill.end.y) - pill.radius,
+        maxX: Math.max(pill.start.x, pill.end.x) + pill.radius,
+        maxY: Math.max(pill.start.y, pill.end.y) + pill.radius
+      };
+    }
   }
   return getBoundsOfPcbElements2([collidable]);
 };
@@ -1005,6 +1129,38 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
           ].filter(Boolean)
         });
       }
+      if (obj.type === "pcb_smtpad" && obj.shape === "rotated_pill") {
+        const { distance: distance3, center, radius } = getSegmentToPillClearance(
+          segmentA,
+          obj
+        );
+        const gap2 = distance3 - segmentA.thickness / 2 - radius;
+        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,
+          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)
+        });
+        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);
@@ -1872,7 +2028,11 @@ import {
   distanceBetweenPolygonAndPolygon,
   getBoundsOfPcbElements as getBoundsOfPcbElements5
 } from "@tscircuit/circuit-json-util";
-import { midpoint } from "@tscircuit/math-utils";
+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`;
@@ -1890,6 +2050,7 @@ var getPadRadius = (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 {
@@ -1900,6 +2061,18 @@ var getCircleShape = (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",
@@ -1912,6 +2085,40 @@ var getPolygonShape = (pad) => {
   };
 };
 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),
@@ -2029,7 +2236,7 @@ import {
 } from "@tscircuit/circuit-json-util";
 import {
   segmentToBoundsMinDistance as segmentToBoundsMinDistance2,
-  segmentToCircleMinDistance as segmentToCircleMinDistance2
+  segmentToCircleMinDistance as segmentToCircleMinDistance3
 } from "@tscircuit/math-utils";
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson9
@@ -2060,7 +2267,13 @@ function checkPadTraceClearance(circuitJson, {
       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(
+      const gap = pad.type === "pcb_smtpad" && 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) }
@@ -2096,7 +2309,7 @@ function checkPadTraceClearance(circuitJson, {
 
 // lib/check-via-trace-clearance.ts
 import { getReadableNameForElement as getReadableNameForElement8 } from "@tscircuit/circuit-json-util";
-import { segmentToCircleMinDistance as segmentToCircleMinDistance3 } from "@tscircuit/math-utils";
+import { segmentToCircleMinDistance as segmentToCircleMinDistance4 } from "@tscircuit/math-utils";
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson10
 } from "circuit-json-to-connectivity-map";
@@ -2134,7 +2347,7 @@ function checkViaTraceClearance(circuitJson, {
       if (!getLayersOfPcbElement(via).includes(segment.layer)) continue;
       if (connMap.areIdsConnected(segment.pcb_trace_id, via.pcb_via_id))
         continue;
-      const gap = segmentToCircleMinDistance3(
+      const gap = segmentToCircleMinDistance4(
         { x: segment.x1, y: segment.y1 },
         { x: segment.x2, y: segment.y2 },
         {
@@ -2571,83 +2784,6 @@ function checkCourtyardOverlap(circuitJson) {
   return errors;
 }
 
-// lib/check-traces-are-contiguous/is-point-in-pad.ts
-function getDistanceBetweenPoints(pointA, pointB) {
-  return Math.sqrt((pointB.x - pointA.x) ** 2 + (pointB.y - pointA.y) ** 2);
-}
-var POINT_ON_SEGMENT_TOLERANCE_MM = 1e-9;
-function isPointOnSegment(point, segment) {
-  const crossProduct = (point.y - segment.start.y) * (segment.end.x - segment.start.x) - (point.x - segment.start.x) * (segment.end.y - segment.start.y);
-  if (Math.abs(crossProduct) > POINT_ON_SEGMENT_TOLERANCE_MM) return false;
-  const dotProduct = (point.x - segment.start.x) * (segment.end.x - segment.start.x) + (point.y - segment.start.y) * (segment.end.y - segment.start.y);
-  if (dotProduct < -POINT_ON_SEGMENT_TOLERANCE_MM) return false;
-  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 isPointInPad(point, pad) {
-  if (pad.type === "pcb_smtpad") {
-    if (pad.shape === "circle") {
-      return getDistanceBetweenPoints(point, pad) <= pad.radius;
-    }
-    if (pad.shape === "rect") {
-      const halfWidth = pad.width / 2;
-      const halfHeight = pad.height / 2;
-      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;
-    }
-    if (pad.shape === "pill") {
-      const halfWidth = pad.width / 2;
-      const halfHeight = pad.height / 2;
-      const radius = pad.radius;
-      if (Math.abs(point.x - pad.x) <= halfWidth - radius && Math.abs(point.y - pad.y) <= halfHeight) {
-        return true;
-      }
-      const cornerX = Math.max(
-        Math.abs(point.x - pad.x) - (halfWidth - radius),
-        0
-      );
-      const cornerY = Math.max(
-        Math.abs(point.y - pad.y) - (halfHeight - radius),
-        0
-      );
-      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;
-    }
-  }
-  if (pad.type === "pcb_plated_hole") {
-    if (pad.shape === "circle") {
-      return getDistanceBetweenPoints(point, pad) <= pad.outer_diameter / 2;
-    }
-    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;
-}
-
 // lib/check-traces-are-contiguous/check-traces-are-contiguous.ts
 import {
   getReadableNameForPcbPort as getReadableNameForPcbPort2,