@tscircuit/checks 0.0.193 → 0.0.195

package/dist/index.d.ts

@@ -57,8 +57,8 @@ declare function checkSourceTracesMatchPcbTraceThickness(circuitJson: AnyCircuit
 
 /**
  * Check that each source_trace which connects source ports has at least one
- * pcb_trace associated with it. If a source_trace has no corresponding
- * pcb_trace, return an error for that source_trace.
+ * pcb_trace associated with it, or its ports physically joined through a
+ * same-net copper pour. Otherwise return an error for that source_trace.
  */
 declare function checkSourceTracesHavePcbTraces(circuitJson: AnyCircuitElement[]): PcbTraceMissingError[];
 

package/dist/index.js

@@ -464,6 +464,169 @@ function getReadableNameForFootprintPad(circuitJson, pad, ordinal) {
   return `${padKind} #${ordinal + 1} at ${location}`;
 }
 
+// lib/copper-pour-connectivity/get-copper-pour-connectivity.ts
+import {
+  getPrimaryId,
+  copperPolygonsTouch,
+  getPlatedHolePolygon,
+  getPourPolygon,
+  getSmtPadPolygon,
+  getTraceSegmentPolygon,
+  getViaPolygon
+} from "@tscircuit/circuit-json-util";
+function getCopperPourConnectivity(circuitJson, connectivity) {
+  const scale = 1e6;
+  const tolerance = 1e-7 * scale;
+  const conductors = [];
+  const pouredNets = /* @__PURE__ */ new Set();
+  const netForId = (id) => connectivity.getNetConnectedToId(id);
+  const add = (conductor) => {
+    if (!conductor.polygon.isEmpty()) {
+      conductors.push({
+        ...conductor,
+        polygon: conductor.polygon.scale(scale, scale)
+      });
+    }
+  };
+  for (const pour of circuitJson) {
+    if (pour.type !== "pcb_copper_pour" || !pour.source_net_id) continue;
+    const netId = netForId(pour.source_net_id);
+    if (!netId) continue;
+    pouredNets.add(netId);
+    add({
+      polygon: getPourPolygon(pour),
+      layers: [pour.layer],
+      netId,
+      isPour: true
+    });
+  }
+  const components = new Map(
+    circuitJson.filter((e) => e.type === "pcb_component").map((e) => [e.pcb_component_id, e])
+  );
+  if (pouredNets.size > 0) {
+    for (const copper of circuitJson) {
+      if (copper.type === "pcb_trace") {
+        const netId2 = netForId(copper.pcb_trace_id);
+        if (!netId2 || !pouredNets.has(netId2) || copper.route_thickness_mode === "interpolated")
+          continue;
+        for (let i = 0; i < copper.route.length - 1; i++) {
+          const start = copper.route[i];
+          const end = copper.route[i + 1];
+          if (start.route_type !== "wire" || end.route_type !== "wire" || start.layer !== end.layer)
+            continue;
+          add({
+            polygon: getTraceSegmentPolygon(start, end, start.width),
+            layers: [start.layer],
+            netId: netId2
+          });
+        }
+        continue;
+      }
+      if (copper.type !== "pcb_smtpad" && copper.type !== "pcb_plated_hole" && copper.type !== "pcb_via")
+        continue;
+      const netId = netForId(getPrimaryId(copper));
+      if (!netId || !pouredNets.has(netId)) continue;
+      if (copper.type === "pcb_smtpad") {
+        add({
+          polygon: getSmtPadPolygon(copper),
+          layers: [copper.layer],
+          netId,
+          portId: copper.pcb_port_id
+        });
+      } else if (copper.type === "pcb_plated_hole") {
+        add({
+          polygon: getPlatedHolePolygon(
+            copper,
+            copper.pcb_component_id ? components.get(copper.pcb_component_id)?.rotation : 0
+          ),
+          layers: copper.layers,
+          netId,
+          portId: copper.pcb_port_id
+        });
+      } else {
+        add({
+          polygon: getViaPolygon(
+            copper,
+            copper.outer_diameter,
+            copper.hole_diameter
+          ),
+          layers: copper.layers,
+          netId
+        });
+      }
+    }
+  }
+  const parent = conductors.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  const bounds = conductors.map((c) => c.polygon.box);
+  const order = conductors.map((_, i) => i).sort((a, b) => bounds[a].xmin - bounds[b].xmin);
+  for (let a = 0; a < order.length; a++) {
+    const i = order[a];
+    for (let b = a + 1; b < order.length; b++) {
+      const j = order[b];
+      if (bounds[j].xmin > bounds[i].xmax + tolerance) break;
+      if (find(i) === find(j) || conductors[i].netId !== conductors[j].netId)
+        continue;
+      if (bounds[j].ymin > bounds[i].ymax + tolerance || bounds[j].ymax < bounds[i].ymin - tolerance)
+        continue;
+      if (!conductors[i].layers.some(
+        (layer) => conductors[j].layers.includes(layer)
+      ))
+        continue;
+      if (copperPolygonsTouch(
+        conductors[i].polygon,
+        conductors[j].polygon,
+        tolerance
+      ))
+        parent[find(j)] = find(i);
+    }
+  }
+  const pourRoots = new Set(
+    conductors.flatMap((c, i) => c.isPour ? [find(i)] : [])
+  );
+  const rootsByPort = /* @__PURE__ */ new Map();
+  for (const [i, conductor] of conductors.entries()) {
+    if (!conductor.portId || !pourRoots.has(find(i))) continue;
+    const roots = rootsByPort.get(conductor.portId) ?? /* @__PURE__ */ new Set();
+    roots.add(find(i));
+    rootsByPort.set(conductor.portId, roots);
+  }
+  const portsByNet = /* @__PURE__ */ new Map();
+  for (const port of circuitJson) {
+    if (port.type !== "pcb_port") continue;
+    const netId = netForId(port.pcb_port_id);
+    if (!netId || !pouredNets.has(netId)) continue;
+    const ports = portsByNet.get(netId) ?? [];
+    ports.push(port.pcb_port_id);
+    portsByNet.set(netId, ports);
+  }
+  return {
+    isPortConnectedToNet(portId, sourceNetIds) {
+      const roots = rootsByPort.get(portId);
+      return sourceNetIds.every(
+        (id) => [...roots ?? []].some(
+          (root) => conductors[root].netId === netForId(id) && // Distinct same-net islands are not a physical connection.
+          (portsByNet.get(conductors[root].netId) ?? []).every(
+            (peer) => rootsByPort.get(peer)?.has(root)
+          )
+        )
+      );
+    },
+    arePortsConnected(portIds) {
+      if (portIds.length < 2) return false;
+      return [...rootsByPort.get(portIds[0]) ?? []].some(
+        (root) => portIds.every((id) => rootsByPort.get(id)?.has(root))
+      );
+    }
+  };
+}
+
 // lib/check-each-pcb-port-connected-to-pcb-trace.ts
 function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
   addStartAndEndPortIdsIfMissing(circuitJson);
@@ -479,6 +642,11 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
   const errors = [];
   const connectivityMap = getFullConnectivityMapFromCircuitJson(circuitJson);
   const pcbConnectivityMap = new PcbConnectivityMap(circuitJson);
+  let pourConnectivity;
+  const getPourConnectivity = () => pourConnectivity ??= getCopperPourConnectivity(
+    circuitJson,
+    connectivityMap
+  );
   const sourcePortToPcbPort = /* @__PURE__ */ new Map();
   for (const pcbPort of pcbPorts) {
     sourcePortToPcbPort.set(pcbPort.source_port_id, pcbPort);
@@ -494,7 +662,10 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
       const connectedPcbTraces = pcbConnectivityMap.getAllTracesConnectedToPort(
         pcbPort.pcb_port_id
       );
-      if (connectedPcbTraces.length === 0) {
+      if (connectedPcbTraces.length === 0 && !getPourConnectivity().isPortConnectedToNet(
+        pcbPort.pcb_port_id,
+        sourceTrace.connected_source_net_ids
+      )) {
         const connectedNetNames = sourceTrace.connected_source_net_ids.map((sourceNetId) => sourceNetNameById.get(sourceNetId)).filter((name) => Boolean(name));
         const netDescription = connectedNetNames.length > 0 ? `net [${connectedNetNames.join(", ")}]` : "its connected net";
         errors.push({
@@ -534,7 +705,9 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
         (element) => element.type === "pcb_trace" && ("pcb_trace_id" in element && element.pcb_trace_id === id || "route_id" in element && element.route_id === id)
       )
     );
-    if (pcbTraceIds.length === 0) {
+    if (pcbTraceIds.length === 0 && !getPourConnectivity().arePortsConnected(
+      pcbPortsInTrace.map((port) => port.pcb_port_id)
+    )) {
       const uniqueComponentIds = new Set(
         pcbPortsInTrace.map((p) => p.pcb_component_id)
       );
@@ -555,7 +728,7 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
 
 // lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
 import { cju as cju2, getReadableNameForElement as getReadableNameForElement2 } from "@tscircuit/circuit-json-util";
-import { getPrimaryId } from "@tscircuit/circuit-json-util";
+import { getPrimaryId as getPrimaryId2 } from "@tscircuit/circuit-json-util";
 import {
   segmentToBoundsMinDistance,
   segmentToCircleMinDistance as segmentToCircleMinDistance2
@@ -1467,7 +1640,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         });
         continue;
       }
-      const primaryObjId = getPrimaryId(obj);
+      const primaryObjId = getPrimaryId2(obj);
       if (connMap.areIdsConnected(
         segmentA.pcb_trace_id,
         "pcb_trace_id" in obj ? obj.pcb_trace_id : primaryObjId
@@ -1519,7 +1692,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
           error_type: "pcb_trace_error",
           message: constructErrorMessage(
             getReadableName(segmentA.pcb_trace_id),
-            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
+            `${obj.type} "${getReadableName(getPrimaryId2(obj))}"`,
             gap2
           ),
           pcb_trace_id: segmentA.pcb_trace_id,
@@ -1552,7 +1725,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
           error_type: "pcb_trace_error",
           message: constructErrorMessage(
             getReadableName(segmentA.pcb_trace_id),
-            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
+            `${obj.type} "${getReadableName(getPrimaryId2(obj))}"`,
             gap
           ),
           pcb_trace_id: segmentA.pcb_trace_id,
@@ -2414,8 +2587,8 @@ function checkPcbComponentOverCutout(circuitJson) {
 }
 
 // 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);
+import { cju as cju3, getPrimaryId as getPrimaryId3 } from "@tscircuit/circuit-json-util";
+var getErrorOwnerId = (copper) => "pcb_component_id" in copper && copper.pcb_component_id ? copper.pcb_component_id : getPrimaryId3(copper);
 var getReadableCopperName = (circuitJson, copper) => {
   if ("pcb_component_id" in copper && copper.pcb_component_id) {
     const pcbComponent = circuitJson.find(
@@ -2427,7 +2600,7 @@ var getReadableCopperName = (circuitJson, copper) => {
     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)}`;
+  return copper.type === "pcb_via" ? `via ${copper.pcb_via_id}` : `${copper.type} ${getPrimaryId3(copper)}`;
 };
 function checkPcbCopperOverKeepout(circuitJson) {
   const keepouts = cju3(circuitJson).pcb_keepout.list();
@@ -2675,6 +2848,11 @@ function checkSourceTracesHavePcbTraces(circuitJson) {
     pcbPorts.map((pcbPort) => [pcbPort.source_port_id, pcbPort])
   );
   const connectivityMap = getFullConnectivityMapFromCircuitJson6(circuitJson);
+  let pourConnectivity;
+  const getPourConnectivity = () => pourConnectivity ??= getCopperPourConnectivity(
+    circuitJson,
+    connectivityMap
+  );
   for (const sourceTrace of sourceTraces) {
     if (!sourceTrace.connected_source_port_ids?.length) continue;
     if ((sourceTrace.connected_source_net_ids?.length ?? 0) > 0) continue;
@@ -2687,6 +2865,10 @@ function checkSourceTracesHavePcbTraces(circuitJson) {
     );
     if (!hasPcbTrace) {
       const connectedPcbPorts = sourceTrace.connected_source_port_ids.map((sourcePortId) => sourcePortToPcbPort.get(sourcePortId)).filter((pcbPort) => pcbPort !== void 0);
+      if (connectedPcbPorts.length === sourceTrace.connected_source_port_ids.length && getPourConnectivity().arePortsConnected(
+        connectedPcbPorts.map((port) => port.pcb_port_id)
+      ))
+        continue;
       const connectedPcbComponentIds = Array.from(
         new Set(
           connectedPcbPorts.map((port) => port.pcb_component_id).filter((id) => id !== void 0)
@@ -2721,7 +2903,7 @@ import {
 import {
   all_layers as all_layers2
 } from "circuit-json";
-import { getPrimaryId as getPrimaryId3 } from "@tscircuit/circuit-json-util";
+import { getPrimaryId as getPrimaryId4 } from "@tscircuit/circuit-json-util";
 import { pointToSegmentDistance as pointToSegmentDistance2 } from "@tscircuit/math-utils";
 var CONTACT_EPSILON = 1e-9;
 function getViaContactIndex(circuitJson, connectivity) {
@@ -2745,7 +2927,7 @@ function getViaContactIndex(circuitJson, connectivity) {
     const net = connectivity.getNetConnectedToId(id);
     if (!net) return;
     const touchesPad = pads.some((pad) => {
-      if (connectivity.getNetConnectedToId(getPrimaryId3(pad)) !== net || !getLayersOfPcbElement(pad).some((layer) => layers.includes(layer)))
+      if (connectivity.getNetConnectedToId(getPrimaryId4(pad)) !== net || !getLayersOfPcbElement(pad).some((layer) => layers.includes(layer)))
         return false;
       if (contact.radius === void 0) return isPointInPad(contact, pad);
       const viaGeometry = {
@@ -3336,7 +3518,7 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
 import {
   cju as cju6,
   getBoundsOfPcbElements as getBoundsOfPcbElements5,
-  getPrimaryId as getPrimaryId4
+  getPrimaryId as getPrimaryId5
 } from "@tscircuit/circuit-json-util";
 import { doBoundsOverlap as doBoundsOverlap3 } from "@tscircuit/math-utils";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson8 } from "circuit-json-to-connectivity-map";
@@ -3420,7 +3602,7 @@ var formatOverlapElementDescription = (circuitJson, element) => {
   if ("pcb_port_id" in element && element.pcb_port_id) {
     return getReadableNameForPort(circuitJson, element.pcb_port_id);
   }
-  const id = getPrimaryId4(element);
+  const id = getPrimaryId5(element);
   const readableName = getReadableNameForElementId(circuitJson, id);
   return readableName === "element" ? `[${id}]` : readableName;
 };
@@ -3433,7 +3615,7 @@ function checkPcbComponentOverlap(circuitJson) {
   const courtyards = circuitJson.filter(isCourtyardElement2);
   const componentMap = /* @__PURE__ */ new Map();
   for (const pad of smtPads) {
-    const componentId = pad.pcb_component_id || `standalone_pad_${getPrimaryId4(pad)}`;
+    const componentId = pad.pcb_component_id || `standalone_pad_${getPrimaryId5(pad)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
@@ -3443,7 +3625,7 @@ function checkPcbComponentOverlap(circuitJson) {
     componentMap.get(componentId).elements.push(pad);
   }
   for (const hole of platedHoles) {
-    const componentId = hole.pcb_component_id || `standalone_plated_hole_${getPrimaryId4(hole)}`;
+    const componentId = hole.pcb_component_id || `standalone_plated_hole_${getPrimaryId5(hole)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
@@ -3453,7 +3635,7 @@ function checkPcbComponentOverlap(circuitJson) {
     componentMap.get(componentId).elements.push(hole);
   }
   for (const hole of holes) {
-    const componentId = hole.pcb_component_id || `standalone_hole_${getPrimaryId4(hole)}`;
+    const componentId = hole.pcb_component_id || `standalone_hole_${getPrimaryId5(hole)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
@@ -3489,8 +3671,8 @@ function checkPcbComponentOverlap(circuitJson) {
       }
       for (const elem1 of comp1.elements) {
         for (const elem2 of comp2.elements) {
-          const id1 = getPrimaryId4(elem1);
-          const id2 = getPrimaryId4(elem2);
+          const id1 = getPrimaryId5(elem1);
+          const id2 = getPrimaryId5(elem2);
           if ((isCourtyardElement2(elem1) || isCourtyardElement2(elem2)) && !isHoleElement(elem1) && !isHoleElement(elem2)) {
             continue;
           }
@@ -3750,7 +3932,7 @@ var checkPcbTraceViaCounts = (circuitJson) => {
 
 // lib/check-pad-pad-clearance.ts
 import {
-  getPrimaryId as getPrimaryId5,
+  getPrimaryId as getPrimaryId6,
   getReadableNameForElement as getReadableNameForElement6
 } from "@tscircuit/circuit-json-util";
 import { formatMm } from "format-si-unit";
@@ -3769,17 +3951,17 @@ function checkPadPadClearance(circuitJson, {
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: (pad) => getPrimaryId5(pad)
+    getId: (pad) => getPrimaryId6(pad)
   });
   const errors = /* @__PURE__ */ new Map();
   for (const padA of pads) {
-    const padAId = getPrimaryId5(padA);
+    const padAId = getPrimaryId6(padA);
     const nearbyPads = spatialIndex.getObjectsInBounds(
       getPadBounds(padA),
       minClearance
     );
     for (const padB of nearbyPads) {
-      const padBId = getPrimaryId5(padB);
+      const padBId = getPrimaryId6(padB);
       if (padAId === padBId) continue;
       if (!getLayersOfPcbElement(padA).some(
         (layer) => getLayersOfPcbElement(padB).includes(layer)
@@ -3815,7 +3997,7 @@ function checkPadPadClearance(circuitJson, {
 
 // lib/check-pad-trace-clearance.ts
 import {
-  getPrimaryId as getPrimaryId6,
+  getPrimaryId as getPrimaryId7,
   getReadableNameForElement as getReadableNameForElement7
 } from "@tscircuit/circuit-json-util";
 import { formatMm as formatMm2 } from "format-si-unit";
@@ -3835,7 +4017,7 @@ function checkPadTraceClearance(circuitJson, {
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: (pad) => getPrimaryId6(pad)
+    getId: (pad) => getPrimaryId7(pad)
   });
   const errors = /* @__PURE__ */ new Map();
   const overlappingPairIds = /* @__PURE__ */ new Set();
@@ -3845,7 +4027,7 @@ function checkPadTraceClearance(circuitJson, {
       minClearance + segment.thickness / 2
     );
     for (const pad of nearbyPads) {
-      const padId = getPrimaryId6(pad);
+      const padId = getPrimaryId7(pad);
       if (!getLayersOfPcbElement(pad).includes(segment.layer)) continue;
       if (connMap.areIdsConnected(segment.pcb_trace_id, padId)) continue;
       const pairId = `${padId}_${segment.pcb_trace_id}`;
@@ -3931,7 +4113,7 @@ function checkViaTraceClearance(circuitJson, {
 
 // lib/check-via-pad-clearance.ts
 import {
-  getPrimaryId as getPrimaryId7,
+  getPrimaryId as getPrimaryId8,
   getReadableNameForElement as getReadableNameForElement9
 } from "@tscircuit/circuit-json-util";
 import { formatMm as formatMm4 } from "format-si-unit";
@@ -3953,7 +4135,7 @@ function checkViaPadClearance(circuitJson, {
   const padIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: getPrimaryId7
+    getId: getPrimaryId8
   });
   const errors = [];
   for (const via of vias) {
@@ -3962,7 +4144,7 @@ function checkViaPadClearance(circuitJson, {
       requiredClearance
     );
     for (const pad of nearbyPads) {
-      const padId = getPrimaryId7(pad);
+      const padId = getPrimaryId8(pad);
       if (!getLayersOfPcbElement(via).some(
         (layer) => getLayersOfPcbElement(pad).includes(layer)
       )) {
@@ -3987,7 +4169,7 @@ function checkViaPadClearance(circuitJson, {
 }
 
 // lib/check-vias-in-pads.ts
-import { getPrimaryId as getPrimaryId8 } from "@tscircuit/circuit-json-util";
+import { getPrimaryId as getPrimaryId9 } from "@tscircuit/circuit-json-util";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson13 } from "circuit-json-to-connectivity-map";
 function checkViasInPads(circuitJson) {
   const board = getPcbBoard(circuitJson);
@@ -4001,18 +4183,18 @@ function checkViasInPads(circuitJson) {
   if (vias.length === 0 || pads.length === 0) return [];
   const connMap = getFullConnectivityMapFromCircuitJson13(circuitJson);
   const padOrdinals = new Map(
-    pads.map((pad, index) => [getPrimaryId8(pad), index])
+    pads.map((pad, index) => [getPrimaryId9(pad), index])
   );
   const padIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: getPrimaryId8
+    getId: getPrimaryId9
   });
   const errors = [];
   for (const via of vias) {
     const nearbyPads = padIndex.getObjectsInBounds(getPadBounds(via));
     for (const pad of nearbyPads) {
-      const padId = getPrimaryId8(pad);
+      const padId = getPrimaryId9(pad);
       const viaLayers = getLayersOfPcbElement(via);
       const padLayers = getLayersOfPcbElement(pad);
       if (!viaLayers.some((layer) => padLayers.includes(layer))) continue;
@@ -4563,12 +4745,12 @@ function checkSchematicComponentPortsOutsideBody(circuitJson) {
 }
 
 // lib/consolidate-pcb-overlap-errors.ts
-import { getPrimaryId as getPrimaryId9 } from "@tscircuit/circuit-json-util";
+import { getPrimaryId as getPrimaryId10 } from "@tscircuit/circuit-json-util";
 function consolidatePcbOverlapErrors(circuitJson, errors) {
   const ownerByElementId = /* @__PURE__ */ new Map();
   const elementById = /* @__PURE__ */ new Map();
   for (const element of circuitJson) {
-    const id = getPrimaryId9(element);
+    const id = getPrimaryId10(element);
     elementById.set(id, element);
     if ("pcb_component_id" in element && element.pcb_component_id) {
       ownerByElementId.set(id, element.pcb_component_id);
@@ -4885,9 +5067,14 @@ function polygonsOverlap(polyA, polyB) {
   return false;
 }
 function checkCourtyardOverlap(circuitJson) {
+  const doNotPlaceComponentIds = new Set(
+    circuitJson.flatMap(
+      (el) => el.type === "pcb_component" && el.do_not_place ? [el.pcb_component_id] : []
+    )
+  );
   const courtyards = circuitJson.filter(
     (el) => el.type === "pcb_courtyard_rect" || el.type === "pcb_courtyard_circle" || el.type === "pcb_courtyard_outline"
-  );
+  ).filter((el) => !doNotPlaceComponentIds.has(el.pcb_component_id));
   const byComponent = /* @__PURE__ */ new Map();
   for (const el of courtyards) {
     const id = el.pcb_component_id;