@tscircuit/checks 0.0.159 → 0.0.161

package/dist/index.js

@@ -179,17 +179,17 @@ var getSegmentToPolygonClearanceFromPoints = (start, end, polygon) => {
   };
 };
 var getSegmentToPillClearance = (segment, pad) => {
-  const pill = getPillCenterLineForPad(pad);
+  const pill2 = getPillCenterLineForPad(pad);
   const closest = getClosestPointsBetweenSegments(
     { x: segment.x1, y: segment.y1 },
     { x: segment.x2, y: segment.y2 },
-    pill.start,
-    pill.end
+    pill2.start,
+    pill2.end
   );
   return {
     distance: closest.distance,
     center: closest.center,
-    radius: pill.radius,
+    radius: pill2.radius,
     tracePoint: closest.pointOnA,
     obstaclePoint: closest.pointOnB
   };
@@ -234,8 +234,8 @@ function isPointInPad(point, pad) {
     }
     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 pill2 = getPillCenterLineForPad(pad);
+        return pointToSegmentDistance(point, pill2.start, pill2.end) <= pill2.radius;
       }
       const halfWidth = pad.width / 2;
       const halfHeight = pad.height / 2;
@@ -632,28 +632,28 @@ var getPadToPadGap = (padA, padB) => {
     ) - pillA.radius - pillB.radius;
   }
   if (isPillPad(padA) && isCircularPad(padB)) {
-    const pill = getPillCenterLineForPad(padA);
-    return segmentToCircleMinDistance(pill.start, pill.end, getCircleShape(padB)) - pill.radius;
+    const pill2 = getPillCenterLineForPad(padA);
+    return segmentToCircleMinDistance(pill2.start, pill2.end, getCircleShape(padB)) - pill2.radius;
   }
   if (isCircularPad(padA) && isPillPad(padB)) {
-    const pill = getPillCenterLineForPad(padB);
-    return segmentToCircleMinDistance(pill.start, pill.end, getCircleShape(padA)) - pill.radius;
+    const pill2 = getPillCenterLineForPad(padB);
+    return segmentToCircleMinDistance(pill2.start, pill2.end, getCircleShape(padA)) - pill2.radius;
   }
   if (isPillPad(padA)) {
-    const pill = getPillCenterLineForPad(padA);
+    const pill2 = getPillCenterLineForPad(padA);
     return getSegmentToPolygonClearanceFromPoints(
-      pill.start,
-      pill.end,
+      pill2.start,
+      pill2.end,
       getPolygonShape(padB).points
-    ).distance - pill.radius;
+    ).distance - pill2.radius;
   }
   if (isPillPad(padB)) {
-    const pill = getPillCenterLineForPad(padB);
+    const pill2 = getPillCenterLineForPad(padB);
     return getSegmentToPolygonClearanceFromPoints(
-      pill.start,
-      pill.end,
+      pill2.start,
+      pill2.end,
       getPolygonShape(padA).points
-    ).distance - pill.radius;
+    ).distance - pill2.radius;
   }
   if (isCircularPad(padA) && isCircularPad(padB)) {
     return distanceBetweenCircleAndCircle(
@@ -1180,12 +1180,12 @@ var getCollidableBounds = (collidable) => {
       };
     }
     if (collidable.type === "pcb_smtpad" && collidable.shape === "rotated_pill") {
-      const pill = getPillCenterLineForPad(collidable);
+      const pill2 = 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
+        minX: Math.min(pill2.start.x, pill2.end.x) - pill2.radius,
+        minY: Math.min(pill2.start.y, pill2.end.y) - pill2.radius,
+        maxX: Math.max(pill2.start.x, pill2.end.x) + pill2.radius,
+        maxY: Math.max(pill2.start.y, pill2.end.y) + pill2.radius
       };
     }
   }
@@ -1526,40 +1526,359 @@ var NetManager = class {
 
 // lib/check-pcb-components-out-of-board/checkViasOffBoard.ts
 import { getReadableNameForElement as getReadableNameForElement3 } from "@tscircuit/circuit-json-util";
-function checkViasOffBoard(circuitJson) {
+
+// lib/check-copper-to-board-edge-clearance.ts
+import * as Flatten from "@flatten-js/core";
+import { applyToPoint, rotateDEG } from "transformation-matrix";
+var toPcbComponentId = (id) => id;
+var GEOMETRY_EPSILON = 1e-9;
+var pointsToPolygon = (points) => {
+  if (points.length < 3) return null;
+  return new Flatten.Polygon(points.map(({ x, y }) => new Flatten.Point(x, y)));
+};
+var boardToPolygon = (board) => {
+  if (board.outline && board.outline.length >= 3) {
+    return pointsToPolygon(board.outline);
+  }
+  if (!board.center || typeof board.width !== "number" || typeof board.height !== "number") {
+    return null;
+  }
+  const halfWidth = board.width / 2;
+  const halfHeight = board.height / 2;
+  return pointsToPolygon([
+    { x: board.center.x - halfWidth, y: board.center.y - halfHeight },
+    { x: board.center.x + halfWidth, y: board.center.y - halfHeight },
+    { x: board.center.x + halfWidth, y: board.center.y + halfHeight },
+    { x: board.center.x - halfWidth, y: board.center.y + halfHeight }
+  ]);
+};
+var getRectanglePolygon = ({
+  x,
+  y,
+  width,
+  height,
+  ccwRotationDegrees = 0
+}) => {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const rotationMatrix = rotateDEG(ccwRotationDegrees, x, y);
+  return pointsToPolygon(
+    [
+      { x: x - halfWidth, y: y - halfHeight },
+      { x: x + halfWidth, y: y - halfHeight },
+      { x: x + halfWidth, y: y + halfHeight },
+      { x: x - halfWidth, y: y + halfHeight }
+    ].map((point) => applyToPoint(rotationMatrix, point))
+  );
+};
+var roundedRect = ({
+  x,
+  y,
+  width,
+  height,
+  cornerRadius,
+  ccwRotationDegrees = 0
+}) => {
+  const radius = Math.max(0, Math.min(cornerRadius, width / 2, height / 2));
+  if (radius <= GEOMETRY_EPSILON) {
+    const polygon = getRectanglePolygon({
+      x,
+      y,
+      width,
+      height,
+      ccwRotationDegrees
+    });
+    return polygon ? { kind: "shapes", shapes: [polygon] } : null;
+  }
+  const shapes = [];
+  const innerWidth = width - 2 * radius;
+  const innerHeight = height - 2 * radius;
+  if (innerWidth > GEOMETRY_EPSILON) {
+    const verticalBand = getRectanglePolygon({
+      x,
+      y,
+      width: innerWidth,
+      height,
+      ccwRotationDegrees
+    });
+    if (verticalBand) shapes.push(verticalBand);
+  }
+  if (innerHeight > GEOMETRY_EPSILON) {
+    const horizontalBand = getRectanglePolygon({
+      x,
+      y,
+      width,
+      height: innerHeight,
+      ccwRotationDegrees
+    });
+    if (horizontalBand) shapes.push(horizontalBand);
+  }
+  const halfInnerWidth = innerWidth / 2;
+  const halfInnerHeight = innerHeight / 2;
+  const rotationMatrix = rotateDEG(ccwRotationDegrees, x, y);
+  const cornerCenters = [
+    { x: x - halfInnerWidth, y: y - halfInnerHeight },
+    { x: x + halfInnerWidth, y: y - halfInnerHeight },
+    { x: x + halfInnerWidth, y: y + halfInnerHeight },
+    { x: x - halfInnerWidth, y: y + halfInnerHeight }
+  ].map((point) => applyToPoint(rotationMatrix, point)).filter(
+    (point, index, points) => points.findIndex(
+      (candidate) => Math.abs(candidate.x - point.x) <= GEOMETRY_EPSILON && Math.abs(candidate.y - point.y) <= GEOMETRY_EPSILON
+    ) === index
+  );
+  shapes.push(
+    ...cornerCenters.map(
+      (center) => new Flatten.Circle(new Flatten.Point(center.x, center.y), radius)
+    )
+  );
+  return shapes.length > 0 ? { kind: "shapes", shapes } : null;
+};
+var pill = ({
+  x,
+  y,
+  width,
+  height,
+  radius,
+  ccwRotationDegrees = 0
+}) => {
+  const halfLineLength = Math.max(Math.max(width, height) / 2 - radius, 0);
+  const localAxis = width >= height ? { x: halfLineLength, y: 0 } : { x: 0, y: halfLineLength };
+  const axis = applyToPoint(rotateDEG(ccwRotationDegrees), localAxis);
+  if (halfLineLength <= GEOMETRY_EPSILON) {
+    return {
+      kind: "shapes",
+      shapes: [new Flatten.Circle(new Flatten.Point(x, y), radius)]
+    };
+  }
+  return {
+    kind: "pill",
+    centerLine: new Flatten.Segment(
+      new Flatten.Point(x - axis.x, y - axis.y),
+      new Flatten.Point(x + axis.x, y + axis.y)
+    ),
+    radius
+  };
+};
+var getSmtPadGeometry = (pad) => {
+  switch (pad.shape) {
+    case "circle":
+      return {
+        kind: "shapes",
+        shapes: [
+          new Flatten.Circle(new Flatten.Point(pad.x, pad.y), pad.radius)
+        ]
+      };
+    case "rect":
+      return roundedRect({
+        x: pad.x,
+        y: pad.y,
+        width: pad.width,
+        height: pad.height,
+        cornerRadius: pad.rect_border_radius ?? pad.corner_radius ?? 0
+      });
+    case "rotated_rect":
+      return roundedRect({
+        x: pad.x,
+        y: pad.y,
+        width: pad.width,
+        height: pad.height,
+        cornerRadius: pad.rect_border_radius ?? pad.corner_radius ?? 0,
+        ccwRotationDegrees: pad.ccw_rotation
+      });
+    case "pill":
+      return pill({
+        x: pad.x,
+        y: pad.y,
+        width: pad.width,
+        height: pad.height,
+        radius: pad.radius
+      });
+    case "rotated_pill":
+      return pill({
+        x: pad.x,
+        y: pad.y,
+        width: pad.width,
+        height: pad.height,
+        radius: pad.radius,
+        ccwRotationDegrees: pad.ccw_rotation
+      });
+    case "polygon": {
+      const polygon = pointsToPolygon(pad.points);
+      return polygon ? { kind: "shapes", shapes: [polygon] } : null;
+    }
+  }
+};
+var getPlatedHoleGeometry = (platedHole, componentCcwRotationDegrees) => {
+  switch (platedHole.shape) {
+    case "circle":
+      return {
+        kind: "shapes",
+        shapes: [
+          new Flatten.Circle(
+            new Flatten.Point(platedHole.x, platedHole.y),
+            platedHole.outer_diameter / 2
+          )
+        ]
+      };
+    case "oval":
+    case "pill":
+      return pill({
+        x: platedHole.x,
+        y: platedHole.y,
+        width: platedHole.outer_width,
+        height: platedHole.outer_height,
+        radius: Math.min(
+          platedHole.outer_width / 2,
+          platedHole.outer_height / 2
+        ),
+        ccwRotationDegrees: platedHole.ccw_rotation
+      });
+    case "circular_hole_with_rect_pad":
+    case "pill_hole_with_rect_pad":
+    case "rotated_pill_hole_with_rect_pad":
+      return roundedRect({
+        x: platedHole.x,
+        y: platedHole.y,
+        width: platedHole.rect_pad_width,
+        height: platedHole.rect_pad_height,
+        cornerRadius: platedHole.rect_border_radius ?? 0,
+        ccwRotationDegrees: "rect_ccw_rotation" in platedHole ? platedHole.rect_ccw_rotation ?? 0 : 0
+      });
+    case "hole_with_polygon_pad": {
+      const ccwRotationDegrees = platedHole.ccw_rotation ?? componentCcwRotationDegrees;
+      const rotationMatrix = rotateDEG(ccwRotationDegrees);
+      const polygon = pointsToPolygon(
+        platedHole.pad_outline.map((point) => {
+          const rotatedPoint = applyToPoint(rotationMatrix, point);
+          return {
+            x: platedHole.x + rotatedPoint.x,
+            y: platedHole.y + rotatedPoint.y
+          };
+        })
+      );
+      return polygon ? { kind: "shapes", shapes: [polygon] } : null;
+    }
+  }
+};
+var getCopperGeometry = (element, componentCcwRotationsById) => {
+  if (element.type === "pcb_via") {
+    return {
+      kind: "shapes",
+      shapes: [
+        new Flatten.Circle(
+          new Flatten.Point(element.x, element.y),
+          element.outer_diameter / 2
+        )
+      ]
+    };
+  }
+  if (element.type === "pcb_smtpad") return getSmtPadGeometry(element);
+  return getPlatedHoleGeometry(
+    element,
+    element.pcb_component_id ? componentCcwRotationsById.get(
+      toPcbComponentId(element.pcb_component_id)
+    ) ?? 0 : 0
+  );
+};
+var getCopperElementId = (element) => {
+  if (element.type === "pcb_via") return element.pcb_via_id;
+  if (element.type === "pcb_smtpad") return element.pcb_smtpad_id;
+  return element.pcb_plated_hole_id;
+};
+var getCopperElementLabel = (element) => {
+  if (element.type === "pcb_via") return "Via";
+  if (element.type === "pcb_smtpad") return "SMT pad";
+  return "Plated hole";
+};
+var measureClearance = (board, geometry) => {
+  if (geometry.kind === "shapes") {
+    const isInside2 = geometry.shapes.every((shape) => board.contains(shape));
+    return {
+      isInside: isInside2,
+      clearance: isInside2 ? Math.min(
+        ...geometry.shapes.map((shape) => board.distanceTo(shape)[0])
+      ) : 0
+    };
+  }
+  const centerLineClearance = board.distanceTo(geometry.centerLine)[0];
+  const clearance = centerLineClearance - geometry.radius;
+  const isInside = board.contains(geometry.centerLine) && clearance >= -GEOMETRY_EPSILON;
+  return {
+    isInside,
+    clearance: isInside ? Math.max(0, clearance) : 0
+  };
+};
+function checkCopperToBoardEdgeClearance(circuitJson) {
   const board = getPcbBoard(circuitJson);
   if (!board) return [];
-  const vias = circuitJson.filter((el) => el.type === "pcb_via");
-  if (vias.length === 0) return [];
-  if (board.width === void 0 || board.height === void 0) return [];
-  const boardEdgeClearance = getBoardDrcValue(board, "min_board_edge_clearance") ?? jlcMinTolerances.min_board_edge_clearance;
-  const boardMinX = board.center.x - board.width / 2;
-  const boardMaxX = board.center.x + board.width / 2;
-  const boardMinY = board.center.y - board.height / 2;
-  const boardMaxY = board.center.y + board.height / 2;
+  const boardPolygon = boardToPolygon(board);
+  if (!boardPolygon) return [];
+  const requiredClearance = getBoardDrcValue(board, "min_board_edge_clearance") ?? jlcMinTolerances.min_board_edge_clearance;
+  if (requiredClearance === void 0) return [];
+  const copperElements = circuitJson.filter(
+    (element) => element.type === "pcb_via" || element.type === "pcb_smtpad" || element.type === "pcb_plated_hole"
+  );
+  const componentCcwRotationsById = new Map(
+    circuitJson.filter(
+      (element) => element.type === "pcb_component"
+    ).map((component) => [
+      toPcbComponentId(component.pcb_component_id),
+      component.rotation
+    ])
+  );
   const errors = [];
-  for (const via of vias) {
-    const viaRadius = via.outer_diameter / 2;
-    const viaMinX = via.x - viaRadius;
-    const viaMaxX = via.x + viaRadius;
-    const viaMinY = via.y - viaRadius;
-    const viaMaxY = via.y + viaRadius;
-    if (viaMinX < boardMinX + boardEdgeClearance || viaMaxX > boardMaxX - boardEdgeClearance || viaMinY < boardMinY + boardEdgeClearance || viaMaxY > boardMaxY - boardEdgeClearance) {
-      const viaName = getReadableNameForElement3(circuitJson, via.pcb_via_id);
-      errors.push({
-        type: "pcb_placement_error",
-        pcb_placement_error_id: `out_of_board_${via.pcb_via_id}`,
-        message: `Via ${viaName} is outside or crossing the board boundary`,
-        error_type: "pcb_placement_error"
-      });
+  for (const element of copperElements) {
+    const geometry = getCopperGeometry(element, componentCcwRotationsById);
+    if (!geometry) continue;
+    const { isInside, clearance } = measureClearance(boardPolygon, geometry);
+    if (isInside && clearance + GEOMETRY_EPSILON >= requiredClearance) {
+      continue;
     }
+    const id = getCopperElementId(element);
+    const label = getCopperElementLabel(element);
+    errors.push({
+      type: "pcb_placement_error",
+      pcb_placement_error_id: `copper_too_close_to_board_edge_${id}`,
+      error_type: "pcb_placement_error",
+      message: `${label} ${id} violates copper-to-board-edge clearance (measured ${clearance.toFixed(3)}mm, required ${requiredClearance.toFixed(3)}mm)`
+    });
   }
   return errors;
 }
 
+// lib/check-pcb-components-out-of-board/checkViasOffBoard.ts
+function checkViasOffBoard(circuitJson) {
+  const vias = circuitJson.filter((element) => element.type === "pcb_via");
+  const violationsById = new Map(
+    checkCopperToBoardEdgeClearance(
+      circuitJson.filter(
+        (element) => element.type === "pcb_board" || element.type === "pcb_via"
+      )
+    ).map((error) => [
+      error.pcb_placement_error_id.replace(
+        "copper_too_close_to_board_edge_",
+        ""
+      ),
+      error
+    ])
+  );
+  return vias.flatMap((via) => {
+    const violation = violationsById.get(via.pcb_via_id);
+    if (!violation) return [];
+    const viaName = getReadableNameForElement3(circuitJson, via.pcb_via_id);
+    return [
+      {
+        ...violation,
+        pcb_placement_error_id: `out_of_board_${via.pcb_via_id}`,
+        message: `Via ${viaName} is outside or crossing the board boundary`
+      }
+    ];
+  });
+}
+
 // lib/check-pcb-components-out-of-board/checkPcbComponentsOutOfBoard.ts
-import * as Flatten from "@flatten-js/core";
-import { rotateDEG, applyToPoint } from "transformation-matrix";
+import * as Flatten2 from "@flatten-js/core";
+import { rotateDEG as rotateDEG2, applyToPoint as applyToPoint2 } from "transformation-matrix";
 function isPolygonCCW(poly) {
   return poly.area() >= 0;
 }
@@ -1573,29 +1892,29 @@ function rectanglePolygon({
   const hw = size.width / 2;
   const hh = size.height / 2;
   const corners = [
-    new Flatten.Point(cx - hw, cy - hh),
-    new Flatten.Point(cx + hw, cy - hh),
-    new Flatten.Point(cx + hw, cy + hh),
-    new Flatten.Point(cx - hw, cy + hh)
+    new Flatten2.Point(cx - hw, cy - hh),
+    new Flatten2.Point(cx + hw, cy - hh),
+    new Flatten2.Point(cx + hw, cy + hh),
+    new Flatten2.Point(cx - hw, cy + hh)
   ];
-  let poly = new Flatten.Polygon(corners);
+  let poly = new Flatten2.Polygon(corners);
   if (rotationDeg) {
-    const matrix = rotateDEG(rotationDeg, cx, cy);
+    const matrix = rotateDEG2(rotationDeg, cx, cy);
     const rotatedCorners = corners.map((pt) => {
-      const p = applyToPoint(matrix, { x: pt.x, y: pt.y });
-      return new Flatten.Point(p.x, p.y);
+      const p = applyToPoint2(matrix, { x: pt.x, y: pt.y });
+      return new Flatten2.Point(p.x, p.y);
     });
-    poly = new Flatten.Polygon(rotatedCorners);
+    poly = new Flatten2.Polygon(rotatedCorners);
   }
   if (!isPolygonCCW(poly)) poly.reverse();
   return poly;
 }
-function boardToPolygon({
+function boardToPolygon2({
   board
 }) {
   if (board.outline && board.outline.length > 0) {
-    const points = board.outline.map((p) => new Flatten.Point(p.x, p.y));
-    const poly = new Flatten.Polygon(points);
+    const points = board.outline.map((p) => new Flatten2.Point(p.x, p.y));
+    const poly = new Flatten2.Polygon(points);
     if (!isPolygonCCW(poly)) {
       poly.reverse();
     }
@@ -1625,7 +1944,7 @@ function getComponentName({
   return getReadableNameForComponent(circuitJson, component.pcb_component_id);
 }
 function computeOverlapDistance(compPoly, boardPoly, componentCenter, componentWidth, componentHeight, rotationDeg) {
-  const centerPoint = new Flatten.Point(componentCenter.x, componentCenter.y);
+  const centerPoint = new Flatten2.Point(componentCenter.x, componentCenter.y);
   if (!boardPoly.contains(centerPoint)) {
     const dist = boardPoly.distanceTo(centerPoint);
     return Array.isArray(dist) ? dist[0] : Number(dist) || 0;
@@ -1646,10 +1965,10 @@ function computeOverlapDistance(compPoly, boardPoly, componentCenter, componentW
       y: (corners[i].y + corners[next].y) / 2
     });
   }
-  const matrix = rotateDEG(rotationDeg, componentCenter.x, componentCenter.y);
+  const matrix = rotateDEG2(rotationDeg, componentCenter.x, componentCenter.y);
   const rotatePoint2 = (pt) => {
-    const p = applyToPoint(matrix, pt);
-    return new Flatten.Point(p.x, p.y);
+    const p = applyToPoint2(matrix, pt);
+    return new Flatten2.Point(p.x, p.y);
   };
   const rotatedPoints = corners.concat(midpoints).map(rotatePoint2);
   let maxDistance = 0;
@@ -1664,7 +1983,7 @@ function computeOverlapDistance(compPoly, boardPoly, componentCenter, componentW
     return maxDistance;
   }
   try {
-    const intersection = Flatten.BooleanOperations.intersect(
+    const intersection = Flatten2.BooleanOperations.intersect(
       compPoly,
       boardPoly
     );
@@ -1734,7 +2053,7 @@ function checkPcbComponentsOutOfBoard(circuitJson) {
     (el) => el.type === "pcb_board"
   );
   if (!board) return [];
-  const boardPoly = boardToPolygon({ board });
+  const boardPoly = boardToPolygon2({ board });
   if (!boardPoly) return [];
   const components = circuitJson.filter(
     (el) => el.type === "pcb_component"
@@ -1791,8 +2110,8 @@ function checkPcbComponentsOutOfBoard(circuitJson) {
 
 // lib/check-pcb-component-over-cutout.ts
 import { doBoundsOverlap } from "@tscircuit/math-utils";
-import * as Flatten2 from "@flatten-js/core";
-import { applyToPoint as applyToPoint2, rotateDEG as rotateDEG2 } from "transformation-matrix";
+import * as Flatten3 from "@flatten-js/core";
+import { applyToPoint as applyToPoint3, rotateDEG as rotateDEG3 } from "transformation-matrix";
 var CUTOUT_CIRCLE_SEGMENTS = 32;
 function rectanglePolygon2({
   center,
@@ -1808,11 +2127,11 @@ function rectanglePolygon2({
     { x: center.x + halfWidth, y: center.y + halfHeight },
     { x: center.x - halfWidth, y: center.y + halfHeight }
   ];
-  const matrix = rotateDEG2(rotation, center.x, center.y);
-  return new Flatten2.Polygon(
+  const matrix = rotateDEG3(rotation, center.x, center.y);
+  return new Flatten3.Polygon(
     corners.map((corner) => {
-      const rotated = rotation ? applyToPoint2(matrix, corner) : corner;
-      return new Flatten2.Point(rotated.x, rotated.y);
+      const rotated = rotation ? applyToPoint3(matrix, corner) : corner;
+      return new Flatten3.Point(rotated.x, rotated.y);
     })
   );
 }
@@ -1820,10 +2139,10 @@ function circlePolygon({
   center,
   radius
 }) {
-  return new Flatten2.Polygon(
+  return new Flatten3.Polygon(
     Array.from({ length: CUTOUT_CIRCLE_SEGMENTS }, (_, index) => {
       const angle = 2 * Math.PI * index / CUTOUT_CIRCLE_SEGMENTS;
-      return new Flatten2.Point(
+      return new Flatten3.Point(
         center.x + Math.cos(angle) * radius,
         center.y + Math.sin(angle) * radius
       );
@@ -1843,8 +2162,8 @@ function cutoutToPolygon(cutout) {
     return circlePolygon({ center: cutout.center, radius: cutout.radius });
   }
   if (cutout.shape === "polygon") {
-    return new Flatten2.Polygon(
-      cutout.points.map((point) => new Flatten2.Point(point.x, point.y))
+    return new Flatten3.Polygon(
+      cutout.points.map((point) => new Flatten3.Point(point.x, point.y))
     );
   }
   return null;
@@ -1863,7 +2182,7 @@ function doPolygonsOverlap(polygonA, polygonB) {
   }
   if (polygonA.contains(polygonB) || polygonB.contains(polygonA)) return true;
   try {
-    const intersections = Flatten2.BooleanOperations.intersect(
+    const intersections = Flatten3.BooleanOperations.intersect(
       polygonA,
       polygonB
     );
@@ -3238,6 +3557,77 @@ function checkNoGroundPinDefined(circuitJson) {
   return warnings;
 }
 
+// lib/check-schematic-component-excessive-vertical-padding.ts
+var DEFAULT_PIN_SPACING = 0.2;
+var MAX_VERTICAL_PADDING_IN_PIN_SPACINGS = 3;
+var FLOATING_POINT_TOLERANCE = 1e-9;
+function checkSchematicComponentExcessiveVerticalPadding(circuitJson) {
+  const schematicComponents = circuitJson.filter(
+    (element) => element.type === "schematic_component"
+  );
+  const schematicPorts = circuitJson.filter(
+    (element) => element.type === "schematic_port"
+  );
+  const sourceComponents = circuitJson.filter(
+    (element) => element.type === "source_component"
+  );
+  const sourceComponentById = new Map(
+    sourceComponents.map((component) => [
+      component.source_component_id,
+      component
+    ])
+  );
+  const portsByComponentId = /* @__PURE__ */ new Map();
+  for (const port of schematicPorts) {
+    if (!port.schematic_component_id) continue;
+    const componentPorts = portsByComponentId.get(port.schematic_component_id) ?? [];
+    componentPorts.push(port);
+    portsByComponentId.set(port.schematic_component_id, componentPorts);
+  }
+  const warnings = [];
+  for (const component of schematicComponents) {
+    if (!component.is_box_with_pins || component.size.height <= 0) continue;
+    const sidePorts = (portsByComponentId.get(component.schematic_component_id) ?? []).filter(
+      (port) => port.side_of_component === "left" || port.side_of_component === "right"
+    );
+    if (sidePorts.length < 2) continue;
+    const pinYs = sidePorts.map((port) => port.center.y);
+    const highestPinY = Math.max(...pinYs);
+    const lowestPinY = Math.min(...pinYs);
+    const componentTopY = component.center.y + component.size.height / 2;
+    const componentBottomY = component.center.y - component.size.height / 2;
+    const pinSpacing = component.pin_spacing ?? DEFAULT_PIN_SPACING;
+    const maximumPadding = pinSpacing * MAX_VERTICAL_PADDING_IN_PIN_SPACINGS;
+    const paddingBySide = {
+      top: componentTopY - highestPinY,
+      bottom: lowestPinY - componentBottomY
+    };
+    const sourceComponent = component.source_component_id ? sourceComponentById.get(component.source_component_id) : void 0;
+    const componentName = sourceComponent?.name ?? component.schematic_component_id;
+    for (const side of ["top", "bottom"]) {
+      const padding = paddingBySide[side];
+      if (padding <= maximumPadding + FLOATING_POINT_TOLERANCE || padding <= 0) {
+        continue;
+      }
+      const relativePosition = side === "top" ? "above" : "below";
+      const stylingIssueType = `excessive_${side}_padding`;
+      warnings.push({
+        type: "schematic_component_styling_warning",
+        schematic_component_styling_warning_id: `schematic_component_styling_warning_${component.schematic_component_id}_${stylingIssueType}`,
+        warning_type: "schematic_component_styling_warning",
+        message: `${componentName} has excessive empty space ${relativePosition} its pins (${padding.toFixed(2)}mm, more than ${MAX_VERTICAL_PADDING_IN_PIN_SPACINGS} pin spacings)`,
+        schematic_component_id: component.schematic_component_id,
+        styling_issue_type: stylingIssueType,
+        schematic_port_ids: sidePorts.map((port) => port.schematic_port_id),
+        source_component_id: component.source_component_id,
+        schematic_sheet_id: component.schematic_sheet_id,
+        subcircuit_id: component.subcircuit_id
+      });
+    }
+  }
+  return warnings;
+}
+
 // lib/check-connector-accessible-orientation.ts
 import { getBoardBounds } from "@tscircuit/circuit-json-util";
 function getFacingDirectionFromInsertionDirection(component) {
@@ -3508,7 +3898,7 @@ function checkTestPointAccessibility(circuitJson) {
 // lib/run-all-checks.ts
 async function runAllPlacementChecks(circuitJson) {
   return [
-    ...checkViasOffBoard(circuitJson),
+    ...checkCopperToBoardEdgeClearance(circuitJson),
     ...checkViasInPads(circuitJson),
     ...checkPcbComponentsOutOfBoard(circuitJson),
     ...checkPcbComponentOverCutout(circuitJson),
@@ -3522,6 +3912,9 @@ async function runAllPlacementChecks(circuitJson) {
 async function runAllNetlistChecks(circuitJson) {
   return [...checkPinMustBeConnected(circuitJson)];
 }
+async function runAllSchematicChecks(circuitJson) {
+  return checkSchematicComponentExcessiveVerticalPadding(circuitJson);
+}
 async function runAllPinSpecificationChecks(circuitJson) {
   return [
     ...checkAllPinsInComponentAreUnderspecified(circuitJson),
@@ -3547,6 +3940,7 @@ async function runAllRoutingChecks(circuitJson) {
 async function runAllChecks(circuitJson) {
   return [
     ...await runAllPlacementChecks(circuitJson),
+    ...await runAllSchematicChecks(circuitJson),
     ...await runAllNetlistChecks(circuitJson),
     ...await runAllPinSpecificationChecks(circuitJson),
     ...await runAllRoutingChecks(circuitJson)
@@ -3556,6 +3950,7 @@ export {
   NetManager,
   checkAllPinsInComponentAreUnderspecified,
   checkConnectorAccessibleOrientation,
+  checkCopperToBoardEdgeClearance,
   checkDifferentNetViaSpacing,
   checkEachPcbPortConnectedToPcbTraces,
   checkEachPcbTraceNonOverlapping,
@@ -3570,6 +3965,7 @@ export {
   checkPcbTracesOutOfBoard,
   checkPinMustBeConnected,
   checkSameNetViaSpacing,
+  checkSchematicComponentExcessiveVerticalPadding,
   checkSourceTracesHavePcbTraces,
   checkSourceTracesMatchPcbTraceThickness,
   checkTestPointAccessibility,
@@ -3583,6 +3979,7 @@ export {
   runAllNetlistChecks,
   runAllPinSpecificationChecks,
   runAllPlacementChecks,
-  runAllRoutingChecks
+  runAllRoutingChecks,
+  runAllSchematicChecks
 };
 //# sourceMappingURL=index.js.map