@tscircuit/checks 0.0.169 → 0.0.171

package/README.md

@@ -20,6 +20,7 @@ and output an array of arrays for any issues found.
 | [`checkEachPcbTraceNonOverlapping`](./lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts) | Returns `pcb_trace_error` when `pcb_trace` segments physically overlap incompatible geometry on the same layer. Pad/via near-misses are reported by the typed clearance checks instead. |
 | [`checkPcbComponentOverlap`](./lib/check-pcb-components-overlap/checkPcbComponentOverlap.ts) | Returns `pcb_footprint_overlap_error` when footprint elements from different components overlap in disallowed ways. |
 | [`checkPcbComponentsOutOfBoard`](./lib/check-pcb-components-out-of-board/checkPcbComponentsOutOfBoard.ts) | Returns `pcb_placement_error` when PCB components do not fit inside the board area. |
+| [`checkPcbCopperOverKeepout`](./lib/check-pcb-copper-over-keepout.ts) | Returns one `pcb_placement_error` per non-excluded component or via whose copper overlaps a keepout on a shared layer. |
 | [`checkPcbTracesOutOfBoard`](./lib/check-trace-out-of-board/checkTraceOutOfBoard.ts) | Returns `pcb_trace_error` when any trace segment or via extends beyond the board boundary. |
 | [`checkPadTraceClearance`](./lib/check-pad-trace-clearance.ts) | Returns `pcb_pad_trace_clearance_error` when a pad and unrelated trace have a positive gap below the minimum clearance. Physical overlaps are reported by `checkEachPcbTraceNonOverlapping`. |
 | [`checkViaTraceClearance`](./lib/check-via-trace-clearance.ts) | Returns `pcb_via_trace_clearance_error` when a via and unrelated trace have a positive gap below the minimum clearance. Physical overlaps are reported by `checkEachPcbTraceNonOverlapping`. |
@@ -34,7 +35,7 @@ and output an array of arrays for any issues found.
 
 | Function | Description |
 | --- | --- |
-| [`runAllPlacementChecks`](./lib/run-all-checks.ts) | Runs placement checks (`checkCopperToBoardEdgeClearance`, `checkPcbComponentsOutOfBoard`, `checkPcbComponentOverlap`, `checkPadPadClearance`, `checkCourtyardOverlap`, `checkConnectorAccessibleOrientation`, and `checkTestPointAccessibility`). |
+| [`runAllPlacementChecks`](./lib/run-all-checks.ts) | Runs placement checks (`checkCopperToBoardEdgeClearance`, `checkPcbComponentsOutOfBoard`, `checkPcbCopperOverKeepout`, `checkPcbComponentOverlap`, `checkPadPadClearance`, `checkCourtyardOverlap`, `checkConnectorAccessibleOrientation`, and `checkTestPointAccessibility`). |
 | [`runAllNetlistChecks`](./lib/run-all-checks.ts) | Runs netlist connectivity checks (currently `checkPinMustBeConnected`). |
 | [`runAllPinSpecificationChecks`](./lib/run-all-checks.ts) | Runs pin specification checks (e.g. `checkAllPinsInComponentAreUnderspecified`, `checkNoPowerPinDefined`, and `checkNoGroundPinDefined`). |
 | [`runAllSchematicChecks`](./lib/run-all-checks.ts) | Runs schematic-layout checks (currently `checkSchematicComponentExcessiveVerticalPadding`). |

package/dist/index.d.ts

@@ -41,6 +41,8 @@ declare function checkPcbComponentsOutOfBoard(circuitJson: AnyCircuitElement[]):
  */
 declare function checkPcbComponentOverCutout(circuitJson: AnyCircuitElement[]): PcbPlacementError[];
 
+declare function checkPcbCopperOverKeepout(circuitJson: AnyCircuitElement[]): PcbPlacementError[];
+
 declare function checkSameNetViaSpacing(circuitJson: AnyCircuitElement[], { connMap, minClearance, }?: {
     connMap?: ConnectivityMap;
     minClearance?: number;
@@ -198,4 +200,4 @@ declare function checkConnectorAccessibleOrientation(circuitJson: AnyCircuitElem
  */
 declare function checkTestPointAccessibility(circuitJson: AnyCircuitElement[]): PcbPlacementError[];
 
-export { NetManager, checkAllPinsInComponentAreUnderspecified, checkConnectorAccessibleOrientation, checkCopperToBoardEdgeClearance, checkDifferentNetViaSpacing, checkEachPcbPortConnectedToPcbTraces, checkEachPcbTraceNonOverlapping, checkNoGroundPinDefined, checkNoPowerPinDefined, checkPadPadClearance, checkPadTraceClearance, checkPcbComponentOverCutout, checkPcbComponentOverlap, checkPcbComponentsMissingCourtyard, checkPcbComponentsOutOfBoard, checkPcbTraceLengths, checkPcbTraceViaCounts, checkPcbTracesOutOfBoard, checkPinMustBeConnected, checkSameNetViaSpacing, checkSchematicComponentExcessiveVerticalPadding, checkSourceTracesHavePcbTraces, checkSourceTracesMatchPcbTraceThickness, checkTestPointAccessibility, checkTracesAreContiguous, checkViaPadClearance, checkViaTraceClearance, checkViasInPads, checkViasOffBoard, dedupePcbDrcErrors, runAllChecks, runAllNetlistChecks, runAllPinSpecificationChecks, runAllPlacementChecks, runAllRoutingChecks, runAllSchematicChecks };
+export { NetManager, checkAllPinsInComponentAreUnderspecified, checkConnectorAccessibleOrientation, checkCopperToBoardEdgeClearance, checkDifferentNetViaSpacing, checkEachPcbPortConnectedToPcbTraces, checkEachPcbTraceNonOverlapping, checkNoGroundPinDefined, checkNoPowerPinDefined, checkPadPadClearance, checkPadTraceClearance, checkPcbComponentOverCutout, checkPcbComponentOverlap, checkPcbComponentsMissingCourtyard, checkPcbComponentsOutOfBoard, checkPcbCopperOverKeepout, checkPcbTraceLengths, checkPcbTraceViaCounts, checkPcbTracesOutOfBoard, checkPinMustBeConnected, checkSameNetViaSpacing, checkSchematicComponentExcessiveVerticalPadding, checkSourceTracesHavePcbTraces, checkSourceTracesMatchPcbTraceThickness, checkTestPointAccessibility, checkTracesAreContiguous, checkViaPadClearance, checkViaTraceClearance, checkViasInPads, checkViasOffBoard, dedupePcbDrcErrors, runAllChecks, runAllNetlistChecks, runAllPinSpecificationChecks, runAllPlacementChecks, runAllRoutingChecks, runAllSchematicChecks };

package/dist/index.js

@@ -605,8 +605,27 @@ var getPcbBoard = (circuitJson) => circuitJson.find((el) => el.type === "pcb_boa
 var getBoardDrcValue = (board, key) => board?.[key];
 
 // lib/check-pad-clearance/common.ts
-var getPadBounds = (pad) => getBoundsOfPcbElements2([pad]);
+var getPadBounds = (pad) => {
+  if (pad.type === "pcb_keepout") {
+    if (pad.shape === "circle") {
+      return {
+        minX: pad.center.x - pad.radius,
+        minY: pad.center.y - pad.radius,
+        maxX: pad.center.x + pad.radius,
+        maxY: pad.center.y + pad.radius
+      };
+    }
+    return {
+      minX: pad.center.x - pad.width / 2,
+      minY: pad.center.y - pad.height / 2,
+      maxX: pad.center.x + pad.width / 2,
+      maxY: pad.center.y + pad.height / 2
+    };
+  }
+  return getBoundsOfPcbElements2([pad]);
+};
 var getPadCenter = (pad) => {
+  if (pad.type === "pcb_keepout") return pad.center;
   const bounds = getPadBounds(pad);
   return midpoint(
     { x: bounds.minX, y: bounds.minY },
@@ -614,6 +633,7 @@ var getPadCenter = (pad) => {
   );
 };
 var getPadRadius = (pad) => {
+  if (pad.type === "pcb_keepout" && pad.shape === "circle") return pad.radius;
   const bounds = getPadBounds(pad);
   return Math.min(bounds.maxX - bounds.minX, bounds.maxY - bounds.minY) / 2;
 };
@@ -629,6 +649,32 @@ var getCircleShape = (pad) => {
   };
 };
 var getPolygonShape = (pad) => {
+  if (pad.type === "pcb_keepout") {
+    if (pad.shape !== "rect") {
+      throw new Error(`Expected rectangular keepout, got ${pad.shape}`);
+    }
+    return {
+      kind: "polygon",
+      points: [
+        {
+          x: pad.center.x - pad.width / 2,
+          y: pad.center.y - pad.height / 2
+        },
+        {
+          x: pad.center.x + pad.width / 2,
+          y: pad.center.y - pad.height / 2
+        },
+        {
+          x: pad.center.x + pad.width / 2,
+          y: pad.center.y + pad.height / 2
+        },
+        {
+          x: pad.center.x - pad.width / 2,
+          y: pad.center.y + pad.height / 2
+        }
+      ]
+    };
+  }
   if (pad.type === "pcb_smtpad" && (pad.shape === "polygon" || pad.shape === "rotated_rect")) {
     return {
       kind: "polygon",
@@ -2340,6 +2386,62 @@ function checkPcbComponentOverCutout(circuitJson) {
   return errors;
 }
 
+// lib/check-pcb-copper-over-keepout.ts
+import { cju as cju3, getPrimaryId as getPrimaryId2 } from "@tscircuit/circuit-json-util";
+var getErrorOwnerId = (copper) => "pcb_component_id" in copper && copper.pcb_component_id ? copper.pcb_component_id : getPrimaryId2(copper);
+var getReadableCopperName = (circuitJson, copper) => {
+  if ("pcb_component_id" in copper && copper.pcb_component_id) {
+    const pcbComponent = circuitJson.find(
+      (element) => element.type === "pcb_component" && element.pcb_component_id === copper.pcb_component_id
+    );
+    const sourceComponent = pcbComponent?.type === "pcb_component" ? circuitJson.find(
+      (element) => element.type === "source_component" && element.source_component_id === pcbComponent.source_component_id
+    ) : void 0;
+    const componentName = sourceComponent?.type === "source_component" && sourceComponent.name ? sourceComponent.name : getReadableNameForComponent(circuitJson, copper.pcb_component_id);
+    return `component ${componentName}`;
+  }
+  return copper.type === "pcb_via" ? `via ${copper.pcb_via_id}` : `${copper.type} ${getPrimaryId2(copper)}`;
+};
+function checkPcbCopperOverKeepout(circuitJson) {
+  const keepouts = cju3(circuitJson).pcb_keepout.list();
+  if (keepouts.length === 0) return [];
+  const copper = [
+    ...getPads(circuitJson),
+    ...cju3(circuitJson).pcb_via.list()
+  ];
+  const errors = /* @__PURE__ */ new Map();
+  for (const keepout of keepouts) {
+    const excludedComponentIds = new Set(
+      keepout.excluded_pcb_component_ids ?? []
+    );
+    for (const copperElement of copper) {
+      const copperComponentId = "pcb_component_id" in copperElement ? copperElement.pcb_component_id : void 0;
+      if (copperComponentId && excludedComponentIds.has(copperComponentId)) {
+        continue;
+      }
+      const copperLayers = getLayersOfPcbElement(copperElement);
+      if (!copperLayers.some((layer) => keepout.layers.includes(layer))) {
+        continue;
+      }
+      if (getPadToPadGap(copperElement, keepout) > EPSILON) continue;
+      const ownerId = getErrorOwnerId(copperElement);
+      const errorId = `copper_over_keepout_${ownerId}_${keepout.pcb_keepout_id}`;
+      if (errors.has(errorId)) continue;
+      errors.set(errorId, {
+        type: "pcb_placement_error",
+        pcb_placement_error_id: errorId,
+        error_type: "pcb_placement_error",
+        message: `Copper for ${getReadableCopperName(
+          circuitJson,
+          copperElement
+        )} overlaps ${keepout.description ? `PCB keepout "${keepout.description}"` : "a PCB keepout"}`,
+        subcircuit_id: copperElement.subcircuit_id ?? keepout.subcircuit_id
+      });
+    }
+  }
+  return [...errors.values()];
+}
+
 // lib/check-same-net-via-spacing.ts
 import { getReadableNameForElement as getReadableNameForElement4 } from "@tscircuit/circuit-json-util";
 import {
@@ -2457,11 +2559,11 @@ function checkDifferentNetViaSpacing(circuitJson, {
 }
 
 // lib/check-source-traces-match-pcb-trace-thickness.ts
-import { cju as cju3 } from "@tscircuit/circuit-json-util";
+import { cju as cju4 } from "@tscircuit/circuit-json-util";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson5 } from "circuit-json-to-connectivity-map";
 function checkSourceTracesMatchPcbTraceThickness(circuitJson) {
   const warnings = [];
-  const db = cju3(circuitJson);
+  const db = cju4(circuitJson);
   const sourceTraces = db.source_trace.list();
   const pcbTraces = db.pcb_trace.list();
   const pcbPorts = db.pcb_port.list();
@@ -2583,6 +2685,9 @@ import {
   getReadableNameForPcbTrace
 } from "@tscircuit/circuit-json-util";
 import { PcbConnectivityMap as PcbConnectivityMap2 } from "circuit-json-to-connectivity-map";
+function routePointTouchesPad(point, pad) {
+  return point.route_type === "wire" && getLayersOfPcbElement(pad).includes(point.layer) && isPointInPad(point, pad);
+}
 function getRoutePointCenter(point) {
   if (point.route_type === "through_pad") {
     return {
@@ -2593,15 +2698,12 @@ function getRoutePointCenter(point) {
   return { x: point.x, y: point.y };
 }
 function routePointConnectsToAnotherExpectedPort(point, expectedPorts, missingPcbPortId, padMap) {
-  if (point.route_type !== "wire") return false;
   return expectedPorts.some((expectedPort) => {
     if (!expectedPort.pcb_port_id || expectedPort.pcb_port_id === missingPcbPortId) {
       return false;
     }
     const expectedPads = padMap.get(expectedPort.pcb_port_id);
-    return expectedPads?.some(
-      (pad) => isPointInPad({ x: point.x, y: point.y }, pad)
-    ) ?? false;
+    return expectedPads?.some((pad) => routePointTouchesPad(point, pad)) ?? false;
   });
 }
 function getMissingConnectionErrorCenter({
@@ -2685,6 +2787,65 @@ function checkTracesAreContiguous(circuitJson) {
       ]);
     }
   }
+  const touchedPortIdsByTraceId = /* @__PURE__ */ new Map();
+  const traceIdsByTouchedPortId = /* @__PURE__ */ new Map();
+  for (const trace of pcbTraces) {
+    const touchedPortIds = /* @__PURE__ */ new Set();
+    const firstPoint = trace.route[0];
+    const lastPoint = trace.route.at(-1);
+    for (const point of [firstPoint, lastPoint]) {
+      if (!point) continue;
+      for (const [pcbPortId, pads] of padMap) {
+        if (pads.some((pad) => routePointTouchesPad(point, pad))) {
+          touchedPortIds.add(pcbPortId);
+        }
+      }
+    }
+    touchedPortIdsByTraceId.set(trace.pcb_trace_id, touchedPortIds);
+    for (const pcbPortId of touchedPortIds) {
+      const traceIds = traceIdsByTouchedPortId.get(pcbPortId) ?? /* @__PURE__ */ new Set();
+      traceIds.add(trace.pcb_trace_id);
+      traceIdsByTouchedPortId.set(pcbPortId, traceIds);
+    }
+  }
+  const physicallyConnectedTracesByTraceId = /* @__PURE__ */ new Map();
+  const getPhysicallyConnectedTraces = (startTrace) => {
+    const cached = physicallyConnectedTracesByTraceId.get(
+      startTrace.pcb_trace_id
+    );
+    if (cached) return cached;
+    const connectedTraceIds = /* @__PURE__ */ new Set();
+    const pendingTraceIds = [startTrace.pcb_trace_id];
+    while (pendingTraceIds.length > 0) {
+      const traceId = pendingTraceIds.pop();
+      if (connectedTraceIds.has(traceId)) continue;
+      connectedTraceIds.add(traceId);
+      for (const connectedTrace of pcbConnectivityMap.getAllTracesConnectedToTrace(
+        traceId
+      )) {
+        if (!connectedTraceIds.has(connectedTrace.pcb_trace_id)) {
+          pendingTraceIds.push(connectedTrace.pcb_trace_id);
+        }
+      }
+      for (const pcbPortId of touchedPortIdsByTraceId.get(traceId) ?? []) {
+        for (const touchingTraceId of traceIdsByTouchedPortId.get(pcbPortId) ?? []) {
+          if (!connectedTraceIds.has(touchingTraceId)) {
+            pendingTraceIds.push(touchingTraceId);
+          }
+        }
+      }
+    }
+    const connectedTraces = pcbTraces.filter(
+      (trace) => connectedTraceIds.has(trace.pcb_trace_id)
+    );
+    for (const trace of connectedTraces) {
+      physicallyConnectedTracesByTraceId.set(
+        trace.pcb_trace_id,
+        connectedTraces
+      );
+    }
+    return connectedTraces;
+  };
   for (const trace of pcbTraces) {
     if (trace.route.length === 0) continue;
     const firstPoint = trace.route[0];
@@ -2736,39 +2897,17 @@ function checkTracesAreContiguous(circuitJson) {
       if (!port.pcb_port_id) continue;
       const pads = padMap.get(port.pcb_port_id);
       if (!pads?.length) continue;
-      let isConnectedByRoutedSourceTrace = false;
-      const candidateTraces = [
-        ...pcbConnectivityMap.getAllTracesConnectedToTrace(trace.pcb_trace_id),
-        ...pcbTraces.filter(
-          (candidateTrace) => candidateTrace.source_trace_id === sourceTrace?.source_trace_id
-        )
-      ];
-      for (const candidateTrace of candidateTraces) {
-        if (candidateTrace.pcb_trace_id === trace.pcb_trace_id) continue;
-        if (!candidateTrace.source_trace_id) continue;
-        const candidateSourceTrace = sourceTraces.find(
-          (st) => st.source_trace_id === candidateTrace.source_trace_id
-        );
-        if (!sourceTrace || candidateTrace.source_trace_id !== sourceTrace.source_trace_id && !candidateSourceTrace?.connected_source_port_ids.includes(
-          port.source_port_id
-        )) {
-          continue;
-        }
-        const candidateFirstPoint = candidateTrace.route[0];
-        const candidateLastPoint = candidateTrace.route.at(-1);
-        if (getPcbPortIdsConnectedToTrace(candidateTrace).includes(
-          port.pcb_port_id
-        ) || candidateFirstPoint?.route_type === "wire" && pads.some((pad) => isPointInPad(candidateFirstPoint, pad)) || candidateLastPoint?.route_type === "wire" && pads.some((pad) => isPointInPad(candidateLastPoint, pad))) {
-          isConnectedByRoutedSourceTrace = true;
-          break;
-        }
-      }
+      const isConnectedByRoutedSourceTrace = getPhysicallyConnectedTraces(
+        trace
+      ).some(
+        (candidateTrace) => touchedPortIdsByTraceId.get(candidateTrace.pcb_trace_id)?.has(port.pcb_port_id)
+      );
       if (isConnectedByRoutedSourceTrace) continue;
-      const isFirstPointConnected = firstPoint.route_type === "wire" && pads.some(
-        (pad) => isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad)
+      const isFirstPointConnected = pads.some(
+        (pad) => routePointTouchesPad(firstPoint, pad)
       );
-      const isLastPointConnected = lastPoint.route_type === "wire" && pads.some(
-        (pad) => isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad)
+      const isLastPointConnected = pads.some(
+        (pad) => routePointTouchesPad(lastPoint, pad)
       );
       if (!isFirstPointConnected && !isLastPointConnected) {
         const portName = getReadableNameForPcbPort2(
@@ -2801,14 +2940,10 @@ function checkTracesAreContiguous(circuitJson) {
       let lastConnectsToAnyPad = false;
       const endpointsAreSame = firstPoint.route_type === "wire" && lastPoint.route_type === "wire" && Math.abs(firstPoint.x - lastPoint.x) < 0.01 && Math.abs(firstPoint.y - lastPoint.y) < 0.01;
       for (const pads of padMap.values()) {
-        if (firstPoint.route_type === "wire" && pads.some(
-          (pad) => isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad)
-        )) {
+        if (pads.some((pad) => routePointTouchesPad(firstPoint, pad))) {
           firstConnectsToAnyPad = true;
         }
-        if (lastPoint.route_type === "wire" && pads.some(
-          (pad) => isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad)
-        )) {
+        if (pads.some((pad) => routePointTouchesPad(lastPoint, pad))) {
           lastConnectsToAnyPad = true;
         }
       }
@@ -2844,7 +2979,7 @@ function checkTracesAreContiguous(circuitJson) {
 }
 
 // lib/check-trace-out-of-board/checkTraceOutOfBoard.ts
-import { cju as cju4 } from "@tscircuit/circuit-json-util";
+import { cju as cju5 } from "@tscircuit/circuit-json-util";
 import { segmentToSegmentMinDistance as segmentToSegmentMinDistance4 } from "@tscircuit/math-utils";
 function getBoardPolygonPoints(board) {
   if (board.outline && board.outline.length > 0) {
@@ -2875,7 +3010,7 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
   const margin = config.margin ?? getBoardDrcValue(board, "min_board_edge_clearance") ?? jlcMinTolerances.min_board_edge_clearance;
   const boardPoints = getBoardPolygonPoints(board);
   if (!boardPoints) return errors;
-  const pcbTraces = cju4(circuitJson).pcb_trace.list();
+  const pcbTraces = cju5(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++) {
@@ -2924,9 +3059,9 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
 
 // lib/check-pcb-components-overlap/checkPcbComponentOverlap.ts
 import {
-  cju as cju5,
+  cju as cju6,
   getBoundsOfPcbElements as getBoundsOfPcbElements5,
-  getPrimaryId as getPrimaryId2
+  getPrimaryId as getPrimaryId3
 } from "@tscircuit/circuit-json-util";
 import { doBoundsOverlap as doBoundsOverlap3 } from "@tscircuit/math-utils";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7 } from "circuit-json-to-connectivity-map";
@@ -2962,20 +3097,20 @@ var formatOverlapElementDescription = (circuitJson, element) => {
   if ("pcb_port_id" in element && element.pcb_port_id) {
     return getReadableNameForPort(circuitJson, element.pcb_port_id);
   }
-  const id = getPrimaryId2(element);
+  const id = getPrimaryId3(element);
   const readableName = getReadableNameForElementId(circuitJson, id);
   return readableName === "element" ? `[${id}]` : readableName;
 };
 function checkPcbComponentOverlap(circuitJson) {
   const errors = [];
   const connMap = getFullConnectivityMapFromCircuitJson7(circuitJson);
-  const smtPads = cju5(circuitJson).pcb_smtpad.list();
-  const platedHoles = cju5(circuitJson).pcb_plated_hole.list();
-  const holes = cju5(circuitJson).pcb_hole.list();
+  const smtPads = cju6(circuitJson).pcb_smtpad.list();
+  const platedHoles = cju6(circuitJson).pcb_plated_hole.list();
+  const holes = cju6(circuitJson).pcb_hole.list();
   const courtyards = circuitJson.filter(isCourtyardElement);
   const componentMap = /* @__PURE__ */ new Map();
   for (const pad of smtPads) {
-    const componentId = pad.pcb_component_id || `standalone_pad_${getPrimaryId2(pad)}`;
+    const componentId = pad.pcb_component_id || `standalone_pad_${getPrimaryId3(pad)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
@@ -2985,7 +3120,7 @@ function checkPcbComponentOverlap(circuitJson) {
     componentMap.get(componentId).elements.push(pad);
   }
   for (const hole of platedHoles) {
-    const componentId = hole.pcb_component_id || `standalone_plated_hole_${getPrimaryId2(hole)}`;
+    const componentId = hole.pcb_component_id || `standalone_plated_hole_${getPrimaryId3(hole)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
@@ -2995,7 +3130,7 @@ function checkPcbComponentOverlap(circuitJson) {
     componentMap.get(componentId).elements.push(hole);
   }
   for (const hole of holes) {
-    const componentId = hole.pcb_component_id || `standalone_hole_${getPrimaryId2(hole)}`;
+    const componentId = hole.pcb_component_id || `standalone_hole_${getPrimaryId3(hole)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
@@ -3031,8 +3166,8 @@ function checkPcbComponentOverlap(circuitJson) {
       }
       for (const elem1 of comp1.elements) {
         for (const elem2 of comp2.elements) {
-          const id1 = getPrimaryId2(elem1);
-          const id2 = getPrimaryId2(elem2);
+          const id1 = getPrimaryId3(elem1);
+          const id2 = getPrimaryId3(elem2);
           if ((isCourtyardElement(elem1) || isCourtyardElement(elem2)) && elem1.type !== "pcb_hole" && elem2.type !== "pcb_hole") {
             continue;
           }
@@ -3227,7 +3362,7 @@ var checkPcbTraceViaCounts = (circuitJson) => {
 
 // lib/check-pad-pad-clearance.ts
 import {
-  getPrimaryId as getPrimaryId3,
+  getPrimaryId as getPrimaryId4,
   getReadableNameForElement as getReadableNameForElement6
 } from "@tscircuit/circuit-json-util";
 import { formatMm } from "format-si-unit";
@@ -3246,17 +3381,17 @@ function checkPadPadClearance(circuitJson, {
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: (pad) => getPrimaryId3(pad)
+    getId: (pad) => getPrimaryId4(pad)
   });
   const errors = /* @__PURE__ */ new Map();
   for (const padA of pads) {
-    const padAId = getPrimaryId3(padA);
+    const padAId = getPrimaryId4(padA);
     const nearbyPads = spatialIndex.getObjectsInBounds(
       getPadBounds(padA),
       minClearance
     );
     for (const padB of nearbyPads) {
-      const padBId = getPrimaryId3(padB);
+      const padBId = getPrimaryId4(padB);
       if (padAId === padBId) continue;
       if (!getLayersOfPcbElement(padA).some(
         (layer) => getLayersOfPcbElement(padB).includes(layer)
@@ -3292,7 +3427,7 @@ function checkPadPadClearance(circuitJson, {
 
 // lib/check-pad-trace-clearance.ts
 import {
-  getPrimaryId as getPrimaryId4,
+  getPrimaryId as getPrimaryId5,
   getReadableNameForElement as getReadableNameForElement7
 } from "@tscircuit/circuit-json-util";
 import { formatMm as formatMm2 } from "format-si-unit";
@@ -3312,7 +3447,7 @@ function checkPadTraceClearance(circuitJson, {
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: (pad) => getPrimaryId4(pad)
+    getId: (pad) => getPrimaryId5(pad)
   });
   const errors = /* @__PURE__ */ new Map();
   const overlappingPairIds = /* @__PURE__ */ new Set();
@@ -3322,7 +3457,7 @@ function checkPadTraceClearance(circuitJson, {
       minClearance + segment.thickness / 2
     );
     for (const pad of nearbyPads) {
-      const padId = getPrimaryId4(pad);
+      const padId = getPrimaryId5(pad);
       if (!getLayersOfPcbElement(pad).includes(segment.layer)) continue;
       if (connMap.areIdsConnected(segment.pcb_trace_id, padId)) continue;
       const pairId = `${padId}_${segment.pcb_trace_id}`;
@@ -3408,7 +3543,7 @@ function checkViaTraceClearance(circuitJson, {
 
 // lib/check-via-pad-clearance.ts
 import {
-  getPrimaryId as getPrimaryId5,
+  getPrimaryId as getPrimaryId6,
   getReadableNameForElement as getReadableNameForElement9
 } from "@tscircuit/circuit-json-util";
 import { formatMm as formatMm4 } from "format-si-unit";
@@ -3430,7 +3565,7 @@ function checkViaPadClearance(circuitJson, {
   const padIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: getPrimaryId5
+    getId: getPrimaryId6
   });
   const errors = [];
   for (const via of vias) {
@@ -3439,7 +3574,7 @@ function checkViaPadClearance(circuitJson, {
       requiredClearance
     );
     for (const pad of nearbyPads) {
-      const padId = getPrimaryId5(pad);
+      const padId = getPrimaryId6(pad);
       if (!getLayersOfPcbElement(via).some(
         (layer) => getLayersOfPcbElement(pad).includes(layer)
       )) {
@@ -3469,7 +3604,7 @@ function checkViaPadClearance(circuitJson, {
 }
 
 // lib/check-vias-in-pads.ts
-import { getPrimaryId as getPrimaryId6 } from "@tscircuit/circuit-json-util";
+import { getPrimaryId as getPrimaryId7 } from "@tscircuit/circuit-json-util";
 function checkViasInPads(circuitJson) {
   const board = getPcbBoard(circuitJson);
   if (board && "is_via_in_pad_allowed" in board && board.is_via_in_pad_allowed === true) {
@@ -3481,12 +3616,12 @@ function checkViasInPads(circuitJson) {
   const pads = getPads(circuitJson);
   if (vias.length === 0 || pads.length === 0) return [];
   const padOrdinals = new Map(
-    pads.map((pad, index) => [getPrimaryId6(pad), index])
+    pads.map((pad, index) => [getPrimaryId7(pad), index])
   );
   const padIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: getPrimaryId6
+    getId: getPrimaryId7
   });
   const errors = [];
   for (const via of vias) {
@@ -3501,7 +3636,7 @@ function checkViasInPads(circuitJson) {
       const padLayers = getLayersOfPcbElement(pad);
       if (!viaLayers.some((layer) => padLayers.includes(layer))) continue;
       if (!isPointInPad(via, pad)) continue;
-      const padId = getPrimaryId6(pad);
+      const padId = getPrimaryId7(pad);
       const padOrdinal = padOrdinals.get(padId) ?? 0;
       const padName = getReadableNameForFootprintPad(
         circuitJson,
@@ -3600,7 +3735,7 @@ function checkPinMustBeConnected(circuitJson) {
 }
 
 // lib/check-all-pins-in-component-are-underspecified.ts
-import { cju as cju6 } from "@tscircuit/circuit-json-util";
+import { cju as cju7 } from "@tscircuit/circuit-json-util";
 var PIN_ATTRIBUTE_KEYS = [
   "must_be_connected",
   "provides_power",
@@ -3645,7 +3780,7 @@ function hasAnyPinAttribute(port) {
 }
 function checkAllPinsInComponentAreUnderspecified(circuitJson) {
   const warnings = [];
-  const db = cju6(circuitJson);
+  const db = cju7(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -3677,10 +3812,10 @@ function checkAllPinsInComponentAreUnderspecified(circuitJson) {
 }
 
 // lib/check-no-power-pin-defined.ts
-import { cju as cju7 } from "@tscircuit/circuit-json-util";
+import { cju as cju8 } from "@tscircuit/circuit-json-util";
 function checkNoPowerPinDefined(circuitJson) {
   const warnings = [];
-  const db = cju7(circuitJson);
+  const db = cju8(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -3712,10 +3847,10 @@ function checkNoPowerPinDefined(circuitJson) {
 }
 
 // lib/check-no-ground-pin-defined.ts
-import { cju as cju8 } from "@tscircuit/circuit-json-util";
+import { cju as cju9 } from "@tscircuit/circuit-json-util";
 function checkNoGroundPinDefined(circuitJson) {
   const warnings = [];
-  const db = cju8(circuitJson);
+  const db = cju9(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -4091,6 +4226,7 @@ async function runAllPlacementChecks(circuitJson) {
     ...checkViasInPads(circuitJson),
     ...checkPcbComponentsOutOfBoard(circuitJson),
     ...checkPcbComponentOverCutout(circuitJson),
+    ...checkPcbCopperOverKeepout(circuitJson),
     ...checkPcbComponentOverlap(circuitJson),
     ...checkPcbComponentsMissingCourtyard(circuitJson),
     ...checkPadPadClearance(circuitJson),
@@ -4153,6 +4289,7 @@ export {
   checkPcbComponentOverlap,
   checkPcbComponentsMissingCourtyard,
   checkPcbComponentsOutOfBoard,
+  checkPcbCopperOverKeepout,
   checkPcbTraceLengths,
   checkPcbTraceViaCounts,
   checkPcbTracesOutOfBoard,