@tscircuit/checks 0.0.116 → 0.0.118

package/dist/index.js

@@ -120,6 +120,53 @@ var getReadableNameForPort = (circuitJson, pcbPortId) => {
     "port"
   );
 };
+var getReadableNameForSourceTrace = (circuitJson, sourceTrace) => {
+  const displayName = sanitizeReadableName(
+    sourceTrace.display_name,
+    sourceTrace.source_trace_id,
+    ""
+  );
+  if (displayName) return displayName;
+  const connectedPortNames = (sourceTrace.connected_source_port_ids ?? []).map((sourcePortId) => {
+    const pcbPort = circuitJson.find(
+      (element) => element.type === "pcb_port" && element.source_port_id === sourcePortId
+    );
+    if (pcbPort?.type === "pcb_port") {
+      return getReadableNameForPort(circuitJson, pcbPort.pcb_port_id);
+    }
+    const sourcePort = circuitJson.find(
+      (element) => element.type === "source_port" && element.source_port_id === sourcePortId
+    );
+    if (sourcePort?.type !== "source_port") return null;
+    const sourceComponent = circuitJson.find(
+      (element) => element.type === "source_component" && element.source_component_id === sourcePort.source_component_id
+    );
+    const sourceComponentName = sourceComponent?.type === "source_component" ? sanitizeReadableName(
+      sourceComponent.name,
+      sourceComponent.source_component_id,
+      ""
+    ) : "";
+    const sourcePortName = firstReadableName(
+      [
+        sourcePort.name,
+        sourcePort.pin_number?.toString(),
+        sourcePort.port_hints?.[0]
+      ],
+      sourcePort.source_port_id
+    );
+    if (sourceComponentName && sourcePortName) {
+      return `${sourceComponentName}.${sourcePortName}`;
+    }
+    return sourcePortName || null;
+  }).filter((name) => Boolean(name));
+  if (connectedPortNames.length >= 2) {
+    return `${connectedPortNames[0]} to ${connectedPortNames[1]}`;
+  }
+  if (connectedPortNames.length === 1) {
+    return `trace connected to ${connectedPortNames[0]}`;
+  }
+  return `trace ${sourceTrace.source_trace_id}`;
+};
 var getReadableNameForElementId = (circuitJson, elementId) => sanitizeReadableName(
   getReadableNameForElement(circuitJson, elementId),
   elementId,
@@ -322,6 +369,8 @@ var DEFAULT_TRACE_THICKNESS = 0.15;
 var DEFAULT_VIA_BOARD_MARGIN = 0.3;
 var DEFAULT_SAME_NET_VIA_MARGIN = 0.2;
 var DEFAULT_DIFFERENT_NET_VIA_MARGIN = 0.3;
+var DEFAULT_PAD_PAD_CLEARANCE = 0.1;
+var DEFAULT_PAD_TRACE_CLEARANCE = 0.1;
 var EPSILON = 5e-3;
 
 // lib/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
@@ -1218,6 +1267,79 @@ function checkDifferentNetViaSpacing(circuitJson, {
   return errors;
 }
 
+// lib/check-source-traces-match-pcb-trace-thickness.ts
+import { cju as cju2 } 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 sourceTraces = db.source_trace.list();
+  const pcbTraces = db.pcb_trace.list();
+  const pcbPorts = db.pcb_port.list();
+  const connectivityMap = getFullConnectivityMapFromCircuitJson5(circuitJson);
+  for (const sourceTrace of sourceTraces) {
+    const requestedThickness = sourceTrace.min_trace_thickness;
+    if (requestedThickness === void 0) continue;
+    const connectedPcbPorts = pcbPorts.filter(
+      (pcbPort) => sourceTrace.connected_source_port_ids?.includes(pcbPort.source_port_id)
+    );
+    if (connectedPcbPorts.length < 2) continue;
+    const referenceNetId = connectivityMap.getNetConnectedToId(
+      connectedPcbPorts[0].pcb_port_id
+    );
+    if (!referenceNetId) continue;
+    const netElementIds = connectivityMap.getIdsConnectedToNet(referenceNetId);
+    const relatedPcbTraces = pcbTraces.filter(
+      (pcbTrace) => netElementIds.includes(pcbTrace.pcb_trace_id)
+    );
+    if (relatedPcbTraces.length === 0) continue;
+    const actualWireWidths = relatedPcbTraces.flatMap(
+      (pcbTrace) => pcbTrace.route.filter((point) => point.route_type === "wire").map((point) => point.width)
+    );
+    if (actualWireWidths.length === 0) continue;
+    const actualThickness = Math.min(...actualWireWidths);
+    if (actualThickness >= requestedThickness) continue;
+    let undersizedSegment;
+    for (const relatedPcbTrace of relatedPcbTraces) {
+      for (let i = 0; i < relatedPcbTrace.route.length - 1; i++) {
+        const point = relatedPcbTrace.route[i];
+        const nextPoint = relatedPcbTrace.route[i + 1];
+        if (!point || !nextPoint) continue;
+        if (point.route_type !== "wire" || nextPoint.route_type !== "wire") {
+          continue;
+        }
+        if (point.width !== actualThickness) continue;
+        undersizedSegment = {
+          pcb_trace_id: relatedPcbTrace.pcb_trace_id,
+          center: {
+            x: (point.x + nextPoint.x) / 2,
+            y: (point.y + nextPoint.y) / 2
+          }
+        };
+        break;
+      }
+      if (undersizedSegment) break;
+    }
+    if (!undersizedSegment) continue;
+    warnings.push({
+      type: "pcb_trace_warning",
+      pcb_trace_warning_id: `pcb_trace_warning_${sourceTrace.source_trace_id}`,
+      warning_type: "pcb_trace_warning",
+      message: `Trace [${getReadableNameForSourceTrace(circuitJson, sourceTrace)}] is routed thinner than requested (requested: ${requestedThickness}mm, actual: ${actualThickness}mm).`,
+      center: undersizedSegment.center,
+      source_trace_id: sourceTrace.source_trace_id,
+      pcb_trace_id: undersizedSegment.pcb_trace_id,
+      pcb_component_ids: Array.from(
+        new Set(
+          connectedPcbPorts.map((pcbPort) => pcbPort.pcb_component_id).filter((id) => id !== void 0)
+        )
+      ),
+      pcb_port_ids: connectedPcbPorts.map((pcbPort) => pcbPort.pcb_port_id)
+    });
+  }
+  return warnings;
+}
+
 // lib/check-source-traces-have-pcb-traces.ts
 var getSourceTraceIdsFromPcbTrace = (pcbTraceSourceTraceId) => {
   if (!pcbTraceSourceTraceId) return [];
@@ -1265,7 +1387,7 @@ function checkSourceTracesHavePcbTraces(circuitJson) {
 }
 
 // lib/check-trace-out-of-board/checkTraceOutOfBoard.ts
-import { cju as cju2 } from "@tscircuit/circuit-json-util";
+import { cju as cju3 } from "@tscircuit/circuit-json-util";
 import { segmentToSegmentMinDistance as segmentToSegmentMinDistance2 } from "@tscircuit/math-utils";
 var DEFAULT_BOARD_MARGIN = 0.2;
 function getBoardPolygonPoints(board) {
@@ -1299,7 +1421,7 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
   if (!board) return errors;
   const boardPoints = getBoardPolygonPoints(board);
   if (!boardPoints) return errors;
-  const pcbTraces = cju2(circuitJson).pcb_trace.list();
+  const pcbTraces = cju3(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++) {
@@ -1348,12 +1470,12 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
 
 // lib/check-pcb-components-overlap/checkPcbComponentOverlap.ts
 import {
-  cju as cju3,
+  cju as cju4,
   getBoundsOfPcbElements as getBoundsOfPcbElements4,
   getPrimaryId as getPrimaryId2
 } from "@tscircuit/circuit-json-util";
 import { doBoundsOverlap as doBoundsOverlap2 } from "@tscircuit/math-utils";
-import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson5 } from "circuit-json-to-connectivity-map";
+import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson6 } from "circuit-json-to-connectivity-map";
 
 // lib/check-pcb-components-overlap/doPcbElementsOverlap.ts
 import { getBoundsOfPcbElements as getBoundsOfPcbElements3 } from "@tscircuit/circuit-json-util";
@@ -1385,10 +1507,10 @@ var formatOverlapElementDescription = (circuitJson, element) => {
 };
 function checkPcbComponentOverlap(circuitJson) {
   const errors = [];
-  const connMap = getFullConnectivityMapFromCircuitJson5(circuitJson);
-  const smtPads = cju3(circuitJson).pcb_smtpad.list();
-  const platedHoles = cju3(circuitJson).pcb_plated_hole.list();
-  const holes = cju3(circuitJson).pcb_hole.list();
+  const connMap = getFullConnectivityMapFromCircuitJson6(circuitJson);
+  const smtPads = cju4(circuitJson).pcb_smtpad.list();
+  const platedHoles = cju4(circuitJson).pcb_plated_hole.list();
+  const holes = cju4(circuitJson).pcb_hole.list();
   const componentMap = /* @__PURE__ */ new Map();
   for (const pad of smtPads) {
     const componentId = pad.pcb_component_id || `standalone_pad_${getPrimaryId2(pad)}`;
@@ -1481,6 +1603,241 @@ function checkPcbComponentOverlap(circuitJson) {
   return errors;
 }
 
+// lib/check-pad-pad-clearance.ts
+import {
+  getPrimaryId as getPrimaryId3,
+  getReadableNameForElement as getReadableNameForElement6
+} from "@tscircuit/circuit-json-util";
+import {
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7
+} from "circuit-json-to-connectivity-map";
+
+// lib/check-pad-clearance/common.ts
+import {
+  cju as cju5,
+  distanceBetweenCircleAndCircle,
+  distanceBetweenCircleAndPolygon,
+  distanceBetweenPolygonAndPolygon,
+  getBoundsOfPcbElements as getBoundsOfPcbElements5
+} from "@tscircuit/circuit-json-util";
+import { midpoint } from "@tscircuit/math-utils";
+var formatMm = (value) => {
+  const rounded = Math.round(value * 1e3) / 1e3;
+  return `${Number(rounded.toFixed(3))}mm`;
+};
+var getPadBounds = (pad) => getBoundsOfPcbElements5([pad]);
+var getPadCenter = (pad) => {
+  const bounds = getPadBounds(pad);
+  return midpoint(
+    { x: bounds.minX, y: bounds.minY },
+    { x: bounds.maxX, y: bounds.maxY }
+  );
+};
+var getPadRadius = (pad) => {
+  const bounds = getPadBounds(pad);
+  return Math.min(bounds.maxX - bounds.minX, bounds.maxY - bounds.minY) / 2;
+};
+var isCircularPad = (pad) => pad.shape === "circle";
+var getCircleShape = (pad) => {
+  const center = getPadCenter(pad);
+  return {
+    kind: "circle",
+    x: center.x,
+    y: center.y,
+    radius: getPadRadius(pad)
+  };
+};
+var getPolygonShape = (pad) => {
+  const bounds = getPadBounds(pad);
+  return {
+    kind: "polygon",
+    points: [
+      { x: bounds.minX, y: bounds.minY },
+      { x: bounds.maxX, y: bounds.minY },
+      { x: bounds.maxX, y: bounds.maxY },
+      { x: bounds.minX, y: bounds.maxY }
+    ]
+  };
+};
+var getPadToPadGap = (padA, padB) => {
+  if (isCircularPad(padA) && isCircularPad(padB)) {
+    return distanceBetweenCircleAndCircle(
+      getCircleShape(padA),
+      getCircleShape(padB)
+    );
+  }
+  if (isCircularPad(padA)) {
+    return distanceBetweenCircleAndPolygon(
+      getCircleShape(padA),
+      getPolygonShape(padB)
+    );
+  }
+  if (isCircularPad(padB)) {
+    return distanceBetweenCircleAndPolygon(
+      getCircleShape(padB),
+      getPolygonShape(padA)
+    );
+  }
+  return distanceBetweenPolygonAndPolygon(
+    getPolygonShape(padA),
+    getPolygonShape(padB)
+  );
+};
+var getPads = (circuitJson) => [
+  ...cju5(circuitJson).pcb_smtpad.list(),
+  ...cju5(circuitJson).pcb_plated_hole.list()
+];
+var getTraceSegments = (circuitJson) => {
+  const pcbTraces = cju5(circuitJson).pcb_trace.list();
+  return pcbTraces.flatMap((pcbTrace) => {
+    const segments = [];
+    for (let i = 0; i < pcbTrace.route.length - 1; i++) {
+      const p1 = pcbTrace.route[i];
+      const p2 = pcbTrace.route[i + 1];
+      if (p1.route_type !== "wire") continue;
+      if (p2.route_type !== "wire") continue;
+      if (p1.layer !== p2.layer) continue;
+      segments.push({
+        type: "pcb_trace_segment",
+        pcb_trace_id: pcbTrace.pcb_trace_id,
+        _pcbTrace: pcbTrace,
+        thickness: "width" in p1 ? p1.width : "width" in p2 ? p2.width : DEFAULT_TRACE_THICKNESS,
+        layer: p1.layer,
+        x1: p1.x,
+        y1: p1.y,
+        x2: p2.x,
+        y2: p2.y
+      });
+    }
+    return segments;
+  });
+};
+
+// lib/check-pad-pad-clearance.ts
+function checkPadPadClearance(circuitJson, {
+  connMap,
+  minSpacing = DEFAULT_PAD_PAD_CLEARANCE
+} = {}) {
+  const pads = getPads(circuitJson);
+  if (pads.length < 2) return [];
+  connMap ??= getFullConnectivityMapFromCircuitJson7(circuitJson);
+  const spatialIndex = new SpatialObjectIndex({
+    objects: pads,
+    getBounds: getPadBounds,
+    getId: (pad) => getPrimaryId3(pad)
+  });
+  const errors = /* @__PURE__ */ new Map();
+  for (const padA of pads) {
+    const padAId = getPrimaryId3(padA);
+    const nearbyPads = spatialIndex.getObjectsInBounds(
+      getPadBounds(padA),
+      minSpacing
+    );
+    for (const padB of nearbyPads) {
+      const padBId = getPrimaryId3(padB);
+      if (padAId === padBId) continue;
+      if (!getLayersOfPcbElement(padA).some(
+        (layer) => getLayersOfPcbElement(padB).includes(layer)
+      )) {
+        continue;
+      }
+      if (connMap.areIdsConnected(padAId, padBId)) continue;
+      const pairId = [padAId, padBId].sort().join("_");
+      const gap = getPadToPadGap(padA, padB);
+      if (gap + EPSILON >= minSpacing) continue;
+      const centerA = getPadCenter(padA);
+      const centerB = getPadCenter(padB);
+      const nextError = {
+        type: "pcb_pad_pad_clearance_error",
+        pcb_pad_pad_clearance_error_id: `pad_pad_clearance_${pairId}`,
+        error_type: "pcb_pad_pad_clearance_error",
+        message: `Pads ${getReadableNameForElement6(circuitJson, padAId)} and ${getReadableNameForElement6(circuitJson, padBId)} are too close (clearance: ${formatMm(gap)}, minimum: ${formatMm(minSpacing)})`,
+        pcb_pad_ids: [padAId, padBId],
+        minimum_clearance: minSpacing,
+        actual_clearance: gap,
+        center: {
+          x: (centerA.x + centerB.x) / 2,
+          y: (centerA.y + centerB.y) / 2
+        }
+      };
+      if (!errors.has(pairId)) {
+        errors.set(pairId, nextError);
+      }
+    }
+  }
+  return Array.from(errors.values());
+}
+
+// lib/check-pad-trace-clearance.ts
+import {
+  getPrimaryId as getPrimaryId4,
+  getReadableNameForElement as getReadableNameForElement7
+} from "@tscircuit/circuit-json-util";
+import {
+  segmentToBoundsMinDistance as segmentToBoundsMinDistance2,
+  segmentToCircleMinDistance as segmentToCircleMinDistance2
+} from "@tscircuit/math-utils";
+import {
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson8
+} from "circuit-json-to-connectivity-map";
+function checkPadTraceClearance(circuitJson, {
+  connMap,
+  minSpacing = DEFAULT_PAD_TRACE_CLEARANCE
+} = {}) {
+  const pads = getPads(circuitJson);
+  const segments = getTraceSegments(circuitJson);
+  if (pads.length === 0 || segments.length === 0) return [];
+  connMap ??= getFullConnectivityMapFromCircuitJson8(circuitJson);
+  const spatialIndex = new SpatialObjectIndex({
+    objects: pads,
+    getBounds: getPadBounds,
+    getId: (pad) => getPrimaryId4(pad)
+  });
+  const errors = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const nearbyPads = spatialIndex.getObjectsInBounds(
+      getCollidableBounds(segment),
+      minSpacing + segment.thickness / 2
+    );
+    for (const pad of nearbyPads) {
+      const padId = getPrimaryId4(pad);
+      if (!getLayersOfPcbElement(pad).includes(segment.layer)) continue;
+      if (connMap.areIdsConnected(segment.pcb_trace_id, padId)) continue;
+      const center = getPadCenter(pad);
+      const gap = isCircularPad(pad) ? segmentToCircleMinDistance2(
+        { x: segment.x1, y: segment.y1 },
+        { x: segment.x2, y: segment.y2 },
+        { x: center.x, y: center.y, radius: getPadRadius(pad) }
+      ) - segment.thickness / 2 : segmentToBoundsMinDistance2(
+        { x: segment.x1, y: segment.y1 },
+        { x: segment.x2, y: segment.y2 },
+        getPadBounds(pad)
+      ) - segment.thickness / 2;
+      if (gap + EPSILON >= minSpacing) continue;
+      const pairId = `${padId}_${segment.pcb_trace_id}`;
+      const nextError = {
+        type: "pcb_pad_trace_clearance_error",
+        pcb_pad_trace_clearance_error_id: `pad_trace_clearance_${pairId}`,
+        error_type: "pcb_pad_trace_clearance_error",
+        message: `Pad ${getReadableNameForElement7(circuitJson, padId)} and trace ${getReadableNameForElement7(circuitJson, segment.pcb_trace_id)} are too close (clearance: ${formatMm(gap)}, minimum: ${formatMm(minSpacing)})`,
+        pcb_pad_id: padId,
+        pcb_trace_id: segment.pcb_trace_id,
+        minimum_clearance: minSpacing,
+        actual_clearance: gap,
+        center: {
+          x: (center.x + (segment.x1 + segment.x2) / 2) / 2,
+          y: (center.y + (segment.y1 + segment.y2) / 2) / 2
+        }
+      };
+      const current = errors.get(pairId);
+      if (!current || gap < current.gap) {
+        errors.set(pairId, { error: nextError, gap });
+      }
+    }
+  }
+  return Array.from(errors.values()).map(({ error }) => error);
+}
+
 // lib/check-pin-must-be-connected.ts
 function checkPinMustBeConnected(circuitJson) {
   const errors = [];
@@ -1540,7 +1897,7 @@ function checkPinMustBeConnected(circuitJson) {
 }
 
 // lib/check-all-pins-in-component-are-underspecified.ts
-import { cju as cju4 } from "@tscircuit/circuit-json-util";
+import { cju as cju6 } from "@tscircuit/circuit-json-util";
 var PIN_ATTRIBUTE_KEYS = [
   "must_be_connected",
   "provides_power",
@@ -1585,7 +1942,7 @@ function hasAnyPinAttribute(port) {
 }
 function checkAllPinsInComponentAreUnderspecified(circuitJson) {
   const warnings = [];
-  const db = cju4(circuitJson);
+  const db = cju6(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -1617,10 +1974,10 @@ function checkAllPinsInComponentAreUnderspecified(circuitJson) {
 }
 
 // lib/check-no-power-pin-defined.ts
-import { cju as cju5 } from "@tscircuit/circuit-json-util";
+import { cju as cju7 } from "@tscircuit/circuit-json-util";
 function checkNoPowerPinDefined(circuitJson) {
   const warnings = [];
-  const db = cju5(circuitJson);
+  const db = cju7(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -1652,10 +2009,10 @@ function checkNoPowerPinDefined(circuitJson) {
 }
 
 // lib/check-no-ground-pin-defined.ts
-import { cju as cju6 } from "@tscircuit/circuit-json-util";
+import { cju as cju8 } from "@tscircuit/circuit-json-util";
 function checkNoGroundPinDefined(circuitJson) {
   const warnings = [];
-  const db = cju6(circuitJson);
+  const db = cju8(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -1686,6 +2043,75 @@ function checkNoGroundPinDefined(circuitJson) {
   return warnings;
 }
 
+// lib/check-connector-accessible-orientation.ts
+import { getBoardBounds } from "@tscircuit/circuit-json-util";
+function getFacingDirection(component) {
+  if (!component.center || !component.cable_insertion_center) return null;
+  const dx = component.cable_insertion_center.x - component.center.x;
+  const dy = component.cable_insertion_center.y - component.center.y;
+  if (Math.abs(dx) < 1e-6 && Math.abs(dy) < 1e-6) return null;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx >= 0 ? "x+" : "x-";
+  }
+  return dy >= 0 ? "y+" : "y-";
+}
+function getRecommendedFacingDirection(component, bounds) {
+  if (!component.center) return null;
+  const distances = [
+    { direction: "x-", distance: component.center.x - bounds.minX },
+    { direction: "x+", distance: bounds.maxX - component.center.x },
+    { direction: "y-", distance: component.center.y - bounds.minY },
+    { direction: "y+", distance: bounds.maxY - component.center.y }
+  ];
+  distances.sort((a, b) => a.distance - b.distance);
+  return distances[0]?.direction ?? null;
+}
+function checkConnectorAccessibleOrientation(circuitJson) {
+  const board = circuitJson.find(
+    (el) => el.type === "pcb_board"
+  );
+  if (!board) return [];
+  const bounds = (() => {
+    try {
+      return getBoardBounds(board);
+    } catch {
+      return null;
+    }
+  })();
+  if (!bounds) return [];
+  const warnings = [];
+  const components = circuitJson.filter(
+    (el) => el.type === "pcb_component"
+  );
+  for (const component of components) {
+    if (!component.cable_insertion_center) continue;
+    const facingDirection = getFacingDirection(component);
+    const recommendedFacingDirection = getRecommendedFacingDirection(
+      component,
+      bounds
+    );
+    if (!facingDirection || !recommendedFacingDirection) continue;
+    if (facingDirection === recommendedFacingDirection) continue;
+    const componentName = getReadableNameForComponent(
+      circuitJson,
+      component.pcb_component_id
+    );
+    warnings.push({
+      type: "pcb_connector_not_in_accessible_orientation_warning",
+      warning_type: "pcb_connector_not_in_accessible_orientation_warning",
+      pcb_connector_not_in_accessible_orientation_warning_id: `pcb_connector_not_in_accessible_orientation_warning_${component.pcb_component_id}`,
+      message: `${componentName} is facing ${facingDirection} but should face ${recommendedFacingDirection} so the connector is accessible from the board edge`,
+      pcb_component_id: component.pcb_component_id,
+      source_component_id: component.source_component_id,
+      pcb_board_id: board.pcb_board_id,
+      facing_direction: facingDirection,
+      recommended_facing_direction: recommendedFacingDirection,
+      subcircuit_id: component.subcircuit_id
+    });
+  }
+  return warnings;
+}
+
 // lib/check-courtyard-overlap/checkCourtyardOverlap.ts
 import {
   doSegmentsIntersect,
@@ -1792,75 +2218,6 @@ function checkCourtyardOverlap(circuitJson) {
   return errors;
 }
 
-// lib/check-connector-accessible-orientation.ts
-import { getBoardBounds } from "@tscircuit/circuit-json-util";
-function getFacingDirection(component) {
-  if (!component.center || !component.cable_insertion_center) return null;
-  const dx = component.cable_insertion_center.x - component.center.x;
-  const dy = component.cable_insertion_center.y - component.center.y;
-  if (Math.abs(dx) < 1e-6 && Math.abs(dy) < 1e-6) return null;
-  if (Math.abs(dx) >= Math.abs(dy)) {
-    return dx >= 0 ? "x+" : "x-";
-  }
-  return dy >= 0 ? "y+" : "y-";
-}
-function getRecommendedFacingDirection(component, bounds) {
-  if (!component.center) return null;
-  const distances = [
-    { direction: "x-", distance: component.center.x - bounds.minX },
-    { direction: "x+", distance: bounds.maxX - component.center.x },
-    { direction: "y-", distance: component.center.y - bounds.minY },
-    { direction: "y+", distance: bounds.maxY - component.center.y }
-  ];
-  distances.sort((a, b) => a.distance - b.distance);
-  return distances[0]?.direction ?? null;
-}
-function checkConnectorAccessibleOrientation(circuitJson) {
-  const board = circuitJson.find(
-    (el) => el.type === "pcb_board"
-  );
-  if (!board) return [];
-  const bounds = (() => {
-    try {
-      return getBoardBounds(board);
-    } catch {
-      return null;
-    }
-  })();
-  if (!bounds) return [];
-  const warnings = [];
-  const components = circuitJson.filter(
-    (el) => el.type === "pcb_component"
-  );
-  for (const component of components) {
-    if (!component.cable_insertion_center) continue;
-    const facingDirection = getFacingDirection(component);
-    const recommendedFacingDirection = getRecommendedFacingDirection(
-      component,
-      bounds
-    );
-    if (!facingDirection || !recommendedFacingDirection) continue;
-    if (facingDirection === recommendedFacingDirection) continue;
-    const componentName = getReadableNameForComponent(
-      circuitJson,
-      component.pcb_component_id
-    );
-    warnings.push({
-      type: "pcb_connector_not_in_accessible_orientation_warning",
-      warning_type: "pcb_connector_not_in_accessible_orientation_warning",
-      pcb_connector_not_in_accessible_orientation_warning_id: `pcb_connector_not_in_accessible_orientation_warning_${component.pcb_component_id}`,
-      message: `${componentName} is facing ${facingDirection} but should face ${recommendedFacingDirection} so the connector is accessible from the board edge`,
-      pcb_component_id: component.pcb_component_id,
-      source_component_id: component.source_component_id,
-      pcb_board_id: board.pcb_board_id,
-      facing_direction: facingDirection,
-      recommended_facing_direction: recommendedFacingDirection,
-      subcircuit_id: component.subcircuit_id
-    });
-  }
-  return warnings;
-}
-
 // lib/check-traces-are-contiguous/check-traces-are-contiguous.ts
 import { getReadableNameForPcbPort as getReadableNameForPcbPort2 } from "@tscircuit/circuit-json-util";
 
@@ -1870,6 +2227,8 @@ async function runAllPlacementChecks(circuitJson) {
     ...checkViasOffBoard(circuitJson),
     ...checkPcbComponentsOutOfBoard(circuitJson),
     ...checkPcbComponentOverlap(circuitJson),
+    ...checkPadPadClearance(circuitJson),
+    ...checkPadTraceClearance(circuitJson),
     ...checkCourtyardOverlap(circuitJson),
     ...checkConnectorAccessibleOrientation(circuitJson)
   ];
@@ -1912,12 +2271,15 @@ export {
   checkEachPcbTraceNonOverlapping,
   checkNoGroundPinDefined,
   checkNoPowerPinDefined,
+  checkPadPadClearance,
+  checkPadTraceClearance,
   checkPcbComponentOverlap,
   checkPcbComponentsOutOfBoard,
   checkPcbTracesOutOfBoard,
   checkPinMustBeConnected,
   checkSameNetViaSpacing,
   checkSourceTracesHavePcbTraces,
+  checkSourceTracesMatchPcbTraceThickness,
   checkViasOffBoard,
   runAllChecks,
   runAllNetlistChecks,