@tscircuit/checks 0.0.158 → 0.0.160

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"
@@ -1789,6 +2108,132 @@ function checkPcbComponentsOutOfBoard(circuitJson) {
   return errors;
 }
 
+// lib/check-pcb-component-over-cutout.ts
+import { doBoundsOverlap } from "@tscircuit/math-utils";
+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,
+  width,
+  height,
+  rotation = 0
+}) {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const corners = [
+    { x: center.x - halfWidth, y: center.y - halfHeight },
+    { x: center.x + halfWidth, y: center.y - halfHeight },
+    { x: center.x + halfWidth, y: center.y + halfHeight },
+    { x: center.x - halfWidth, y: center.y + halfHeight }
+  ];
+  const matrix = rotateDEG3(rotation, center.x, center.y);
+  return new Flatten3.Polygon(
+    corners.map((corner) => {
+      const rotated = rotation ? applyToPoint3(matrix, corner) : corner;
+      return new Flatten3.Point(rotated.x, rotated.y);
+    })
+  );
+}
+function circlePolygon({
+  center,
+  radius
+}) {
+  return new Flatten3.Polygon(
+    Array.from({ length: CUTOUT_CIRCLE_SEGMENTS }, (_, index) => {
+      const angle = 2 * Math.PI * index / CUTOUT_CIRCLE_SEGMENTS;
+      return new Flatten3.Point(
+        center.x + Math.cos(angle) * radius,
+        center.y + Math.sin(angle) * radius
+      );
+    })
+  );
+}
+function cutoutToPolygon(cutout) {
+  if (cutout.shape === "rect") {
+    return rectanglePolygon2({
+      center: cutout.center,
+      width: cutout.width,
+      height: cutout.height,
+      rotation: cutout.rotation ?? 0
+    });
+  }
+  if (cutout.shape === "circle") {
+    return circlePolygon({ center: cutout.center, radius: cutout.radius });
+  }
+  if (cutout.shape === "polygon") {
+    return new Flatten3.Polygon(
+      cutout.points.map((point) => new Flatten3.Point(point.x, point.y))
+    );
+  }
+  return null;
+}
+function polygonBoxToBounds(polygon) {
+  return {
+    minX: polygon.box.xmin,
+    minY: polygon.box.ymin,
+    maxX: polygon.box.xmax,
+    maxY: polygon.box.ymax
+  };
+}
+function doPolygonsOverlap(polygonA, polygonB) {
+  if (!doBoundsOverlap(polygonBoxToBounds(polygonA), polygonBoxToBounds(polygonB))) {
+    return false;
+  }
+  if (polygonA.contains(polygonB) || polygonB.contains(polygonA)) return true;
+  try {
+    const intersections = Flatten3.BooleanOperations.intersect(
+      polygonA,
+      polygonB
+    );
+    if (Array.isArray(intersections)) {
+      return intersections.some((polygon) => polygon.area() > 0);
+    }
+    return intersections.area() > 0;
+  } catch {
+    return false;
+  }
+}
+function checkPcbComponentOverCutout(circuitJson) {
+  const cutouts = circuitJson.filter(
+    (element) => element.type === "pcb_cutout"
+  );
+  const components = circuitJson.filter(
+    (element) => element.type === "pcb_component"
+  );
+  if (cutouts.length === 0 || components.length === 0) return [];
+  const cutoutPolygons = cutouts.map((cutout) => ({ cutout, polygon: cutoutToPolygon(cutout) })).filter(
+    (entry) => entry.polygon !== null && entry.polygon.area() > 0
+  );
+  const errors = [];
+  for (const component of components) {
+    if (!component.center || component.width <= 0 || component.height <= 0) {
+      continue;
+    }
+    const componentPolygon = rectanglePolygon2({
+      center: component.center,
+      width: component.width,
+      height: component.height
+    });
+    for (const { cutout, polygon: cutoutPolygon } of cutoutPolygons) {
+      if (!doPolygonsOverlap(componentPolygon, cutoutPolygon)) continue;
+      const componentName = getReadableNameForComponent(
+        circuitJson,
+        component.pcb_component_id
+      );
+      const cutoutId = cutout.pcb_cutout_id;
+      errors.push({
+        type: "pcb_placement_error",
+        pcb_placement_error_id: `component_over_cutout_${component.pcb_component_id}_${cutoutId}`,
+        error_type: "pcb_placement_error",
+        message: `Component ${componentName} overlaps with pcb_cutout [${cutoutId}]`,
+        subcircuit_id: component.subcircuit_id
+      });
+    }
+  }
+  return errors;
+}
+
 // lib/check-same-net-via-spacing.ts
 import { getReadableNameForElement as getReadableNameForElement4 } from "@tscircuit/circuit-json-util";
 import {
@@ -2377,12 +2822,12 @@ import {
   getBoundsOfPcbElements as getBoundsOfPcbElements5,
   getPrimaryId as getPrimaryId2
 } from "@tscircuit/circuit-json-util";
-import { doBoundsOverlap as doBoundsOverlap2 } from "@tscircuit/math-utils";
+import { doBoundsOverlap as doBoundsOverlap3 } from "@tscircuit/math-utils";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7 } from "circuit-json-to-connectivity-map";
 
 // lib/check-pcb-components-overlap/doPcbElementsOverlap.ts
 import { getBoundsOfPcbElements as getBoundsOfPcbElements4 } from "@tscircuit/circuit-json-util";
-import { doBoundsOverlap } from "@tscircuit/math-utils";
+import { doBoundsOverlap as doBoundsOverlap2 } 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") {
     return [elem.layer];
@@ -2402,7 +2847,7 @@ function doPcbElementsOverlap(elem1, elem2) {
   }
   const bounds1 = getBoundsOfPcbElements4([elem1]);
   const bounds2 = getBoundsOfPcbElements4([elem2]);
-  return doBoundsOverlap(bounds1, bounds2);
+  return doBoundsOverlap2(bounds1, bounds2);
 }
 
 // lib/check-pcb-components-overlap/checkPcbComponentOverlap.ts
@@ -2475,7 +2920,7 @@ function checkPcbComponentOverlap(circuitJson) {
       if (!comp1.bounds || !comp2.bounds) {
         continue;
       }
-      if (!doBoundsOverlap2(comp1.bounds, comp2.bounds)) {
+      if (!doBoundsOverlap3(comp1.bounds, comp2.bounds)) {
         continue;
       }
       for (const elem1 of comp1.elements) {
@@ -3382,9 +3827,10 @@ function checkTestPointAccessibility(circuitJson) {
 // lib/run-all-checks.ts
 async function runAllPlacementChecks(circuitJson) {
   return [
-    ...checkViasOffBoard(circuitJson),
+    ...checkCopperToBoardEdgeClearance(circuitJson),
     ...checkViasInPads(circuitJson),
     ...checkPcbComponentsOutOfBoard(circuitJson),
+    ...checkPcbComponentOverCutout(circuitJson),
     ...checkPcbComponentOverlap(circuitJson),
     ...checkPadPadClearance(circuitJson),
     ...checkCourtyardOverlap(circuitJson),
@@ -3429,6 +3875,7 @@ export {
   NetManager,
   checkAllPinsInComponentAreUnderspecified,
   checkConnectorAccessibleOrientation,
+  checkCopperToBoardEdgeClearance,
   checkDifferentNetViaSpacing,
   checkEachPcbPortConnectedToPcbTraces,
   checkEachPcbTraceNonOverlapping,
@@ -3436,6 +3883,7 @@ export {
   checkNoPowerPinDefined,
   checkPadPadClearance,
   checkPadTraceClearance,
+  checkPcbComponentOverCutout,
   checkPcbComponentOverlap,
   checkPcbComponentsOutOfBoard,
   checkPcbTraceLengths,