@tscircuit/checks 0.0.207 → 0.0.209

package/dist/index.js

@@ -1,3 +1,321 @@
+// lib/check-pcb-trace-self-shorts.ts
+import { cju } from "@tscircuit/circuit-json-util";
+import { segmentToSegmentMinDistance } from "@tscircuit/math-utils";
+import {
+  all_layers
+} from "circuit-json";
+
+// lib/check-each-pcb-trace-non-overlapping/getClosestPointBetweenSegments.ts
+var getClosestPointBetweenSegments = (segmentA, segmentB) => {
+  const a1 = { x: segmentA.x1, y: segmentA.y1 };
+  const a2 = { x: segmentA.x2, y: segmentA.y2 };
+  const b1 = { x: segmentB.x1, y: segmentB.y1 };
+  const b2 = { x: segmentB.x2, y: segmentB.y2 };
+  const va = { x: a2.x - a1.x, y: a2.y - a1.y };
+  const vb = { x: b2.x - b1.x, y: b2.y - b1.y };
+  const lenSqrA = va.x * va.x + va.y * va.y;
+  const lenSqrB = vb.x * vb.x + vb.y * vb.y;
+  if (lenSqrA === 0 || lenSqrB === 0) {
+    if (lenSqrA === 0 && lenSqrB === 0) {
+      return {
+        x: (a1.x + b1.x) / 2,
+        y: (a1.y + b1.y) / 2
+      };
+    }
+    if (lenSqrA === 0) {
+      const t2 = clamp(
+        ((a1.x - b1.x) * vb.x + (a1.y - b1.y) * vb.y) / lenSqrB,
+        0,
+        1
+      );
+      const closestOnB2 = {
+        x: b1.x + t2 * vb.x,
+        y: b1.y + t2 * vb.y
+      };
+      return {
+        x: (a1.x + closestOnB2.x) / 2,
+        y: (a1.y + closestOnB2.y) / 2
+      };
+    }
+    const t = clamp(
+      ((b1.x - a1.x) * va.x + (b1.y - a1.y) * va.y) / lenSqrA,
+      0,
+      1
+    );
+    const closestOnA2 = {
+      x: a1.x + t * va.x,
+      y: a1.y + t * va.y
+    };
+    return {
+      x: (closestOnA2.x + b1.x) / 2,
+      y: (closestOnA2.y + b1.y) / 2
+    };
+  }
+  const w = { x: a1.x - b1.x, y: a1.y - b1.y };
+  const dotAA = va.x * va.x + va.y * va.y;
+  const dotAB = va.x * vb.x + va.y * vb.y;
+  const dotAW = va.x * w.x + va.y * w.y;
+  const dotBB = vb.x * vb.x + vb.y * vb.y;
+  const dotBW = vb.x * w.x + vb.y * w.y;
+  const denominator = dotAA * dotBB - dotAB * dotAB;
+  if (denominator < 1e-10) {
+    return closestPointsParallelSegments(
+      a1,
+      a2,
+      b1,
+      b2,
+      va,
+      vb,
+      lenSqrA,
+      lenSqrB
+    );
+  }
+  let tA = (dotAB * dotBW - dotBB * dotAW) / denominator;
+  let tB = (dotAA * dotBW - dotAB * dotAW) / denominator;
+  tA = clamp(tA, 0, 1);
+  tB = clamp(tB, 0, 1);
+  tB = (tA * dotAB + dotBW) / dotBB;
+  tB = clamp(tB, 0, 1);
+  tA = (tB * dotAB - dotAW) / dotAA;
+  tA = clamp(tA, 0, 1);
+  const closestOnA = {
+    x: a1.x + tA * va.x,
+    y: a1.y + tA * va.y
+  };
+  const closestOnB = {
+    x: b1.x + tB * vb.x,
+    y: b1.y + tB * vb.y
+  };
+  const dx = closestOnA.x - closestOnB.x;
+  const dy = closestOnA.y - closestOnB.y;
+  const distance3 = Math.sqrt(dx * dx + dy * dy);
+  const averagePoint = {
+    x: (closestOnA.x + closestOnB.x) / 2,
+    y: (closestOnA.y + closestOnB.y) / 2
+  };
+  return averagePoint;
+};
+var closestPointsParallelSegments = (a1, a2, b1, b2, va, vb, lenSqrA, lenSqrB) => {
+  let tA = ((b1.x - a1.x) * va.x + (b1.y - a1.y) * va.y) / lenSqrA;
+  tA = clamp(tA, 0, 1);
+  const pointOnA1 = { x: a1.x + tA * va.x, y: a1.y + tA * va.y };
+  let tA2 = ((b2.x - a1.x) * va.x + (b2.y - a1.y) * va.y) / lenSqrA;
+  tA2 = clamp(tA2, 0, 1);
+  const pointOnA2 = { x: a1.x + tA2 * va.x, y: a1.y + tA2 * va.y };
+  let tB = ((a1.x - b1.x) * vb.x + (a1.y - b1.y) * vb.y) / lenSqrB;
+  tB = clamp(tB, 0, 1);
+  const pointOnB1 = { x: b1.x + tB * vb.x, y: b1.y + tB * vb.y };
+  let tB2 = ((a2.x - b1.x) * vb.x + (a2.y - b1.y) * vb.y) / lenSqrB;
+  tB2 = clamp(tB2, 0, 1);
+  const pointOnB2 = { x: b1.x + tB2 * vb.x, y: b1.y + tB2 * vb.y };
+  const distances = [
+    {
+      pointA: pointOnA1,
+      pointB: b1,
+      distance: Math.sqrt(
+        (pointOnA1.x - b1.x) ** 2 + (pointOnA1.y - b1.y) ** 2
+      )
+    },
+    {
+      pointA: pointOnA2,
+      pointB: b2,
+      distance: Math.sqrt(
+        (pointOnA2.x - b2.x) ** 2 + (pointOnA2.y - b2.y) ** 2
+      )
+    },
+    {
+      pointA: a1,
+      pointB: pointOnB1,
+      distance: Math.sqrt(
+        (a1.x - pointOnB1.x) ** 2 + (a1.y - pointOnB1.y) ** 2
+      )
+    },
+    {
+      pointA: a2,
+      pointB: pointOnB2,
+      distance: Math.sqrt(
+        (a2.x - pointOnB2.x) ** 2 + (a2.y - pointOnB2.y) ** 2
+      )
+    }
+  ];
+  const closestPair = distances.reduce(
+    (closest, current) => current.distance < closest.distance ? current : closest
+  );
+  return {
+    x: (closestPair.pointA.x + closestPair.pointB.x) / 2,
+    y: (closestPair.pointA.y + closestPair.pointB.y) / 2
+  };
+};
+var clamp = (value, min, max) => {
+  return Math.max(min, Math.min(max, value));
+};
+
+// lib/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
+function getPcbPortIdsConnectedToRoutePoint(routePoint) {
+  if (routePoint.route_type !== "wire") return [];
+  return [routePoint.start_pcb_port_id, routePoint.end_pcb_port_id].filter(
+    (portId) => Boolean(portId)
+  );
+}
+function getPcbPortIdsConnectedToTrace(trace) {
+  const connectedPcbPorts = /* @__PURE__ */ new Set();
+  for (const segment of trace.route) {
+    for (const portId of getPcbPortIdsConnectedToRoutePoint(segment)) {
+      connectedPcbPorts.add(portId);
+    }
+  }
+  return Array.from(connectedPcbPorts);
+}
+function getPcbPortIdsConnectedToTraces(traces) {
+  const connectedPorts = /* @__PURE__ */ new Set();
+  for (const trace of traces) {
+    for (const portId of getPcbPortIdsConnectedToTrace(trace)) {
+      connectedPorts.add(portId);
+    }
+  }
+  return Array.from(connectedPorts);
+}
+
+// lib/check-pcb-trace-self-shorts.ts
+function checkPcbTraceSelfShorts(circuitJson) {
+  const matchedSourceTraceIds = new Set(
+    circuitJson.flatMap(
+      (element) => element.type === "source_bus" && element.max_length_skew !== void 0 ? element.source_trace_ids : []
+    )
+  );
+  const db = cju(circuitJson);
+  const errors = [];
+  for (const trace of circuitJson) {
+    if (trace.type !== "pcb_trace") continue;
+    if (!trace.source_trace_id || !matchedSourceTraceIds.has(trace.source_trace_id))
+      continue;
+    const segments = [];
+    const routeDistances = [];
+    let distance3 = 0;
+    let run = 0;
+    for (let i = 0; i < trace.route.length - 1; i++) {
+      routeDistances[i] = distance3;
+      const a = trace.route[i];
+      const b = trace.route[i + 1];
+      if (a.route_type !== "wire" || b.route_type !== "wire" || a.layer !== b.layer) {
+        run++;
+        continue;
+      }
+      const length = Math.hypot(b.x - a.x, b.y - a.y);
+      if (length === 0) continue;
+      segments.push({
+        type: "pcb_trace_segment",
+        _pcbTrace: trace,
+        pcb_trace_id: trace.pcb_trace_id,
+        thickness: a.width,
+        layer: a.layer,
+        x1: a.x,
+        y1: a.y,
+        x2: b.x,
+        y2: b.y,
+        run,
+        startDistance: distance3,
+        endDistance: distance3 + length
+      });
+      distance3 += length;
+    }
+    routeDistances[trace.route.length - 1] = distance3;
+    let shortCenter;
+    pairs: for (let i = 0; i < segments.length; i++) {
+      const a = segments[i];
+      for (let j = i + 1; j < segments.length; j++) {
+        const b = segments[j];
+        if (a.layer !== b.layer) continue;
+        const contactDistance = (a.thickness + b.thickness) / 2;
+        const dot = (a.x2 - a.x1) * (b.x2 - b.x1) + (a.y2 - a.y1) * (b.y2 - b.y1);
+        const cross = (a.x2 - a.x1) * (b.y2 - b.y1) - (a.y2 - a.y1) * (b.x2 - b.x1);
+        const adjacent = a.run === b.run && b.startDistance === a.endDistance;
+        if (adjacent && !(dot < 0 && Math.abs(cross) < 1e-9)) continue;
+        if (!adjacent && a.run === b.run && b.startDistance - a.endDistance < contactDistance && dot >= 0)
+          continue;
+        const gap = segmentToSegmentMinDistance(
+          { x: a.x1, y: a.y1 },
+          { x: a.x2, y: a.y2 },
+          { x: b.x1, y: b.y1 },
+          { x: b.x2, y: b.y2 }
+        ) - contactDistance;
+        if (gap > 1e-9) continue;
+        shortCenter = getClosestPointBetweenSegments(a, b);
+        break pairs;
+      }
+    }
+    if (!shortCenter) {
+      const board = circuitJson.find((e) => e.type === "pcb_board");
+      const stack = [
+        "top",
+        ...all_layers.filter((layer) => layer.startsWith("inner")).slice(0, board ? Math.max(0, board.num_layers - 2) : void 0),
+        ...board?.num_layers === 1 ? [] : ["bottom"]
+      ];
+      vias: for (let i = 0; i < trace.route.length; i++) {
+        const point2 = trace.route[i];
+        if (point2.route_type !== "via") continue;
+        const materialized = db.pcb_via.list().find(
+          (via) => (via.pcb_trace_id === trace.pcb_trace_id || !via.pcb_trace_id && via.source_trace_id === trace.source_trace_id) && Math.hypot(via.x - point2.x, via.y - point2.y) <= 1e-9
+        );
+        const diameter = materialized?.outer_diameter ?? point2.outer_diameter;
+        if (diameter === void 0 || !Number.isFinite(diameter) || diameter <= 0)
+          continue;
+        const from = stack.indexOf(point2.from_layer);
+        const to = stack.indexOf(point2.to_layer);
+        const layers = materialized?.layers ?? (from >= 0 && to >= 0 ? stack.slice(Math.min(from, to), Math.max(from, to) + 1) : []);
+        for (const segment of segments) {
+          if (!layers.includes(segment.layer)) continue;
+          const reach = (diameter + segment.thickness) / 2;
+          const alongRouteGap = Math.max(
+            segment.startDistance - routeDistances[i],
+            routeDistances[i] - segment.endDistance,
+            0
+          );
+          if (alongRouteGap <= reach + 1e-9) continue;
+          const viaSegment = {
+            ...segment,
+            x1: point2.x,
+            y1: point2.y,
+            x2: point2.x,
+            y2: point2.y
+          };
+          const gap = segmentToSegmentMinDistance(
+            point2,
+            point2,
+            { x: segment.x1, y: segment.y1 },
+            { x: segment.x2, y: segment.y2 }
+          ) - reach;
+          if (gap > 1e-9) continue;
+          shortCenter = getClosestPointBetweenSegments(segment, viaSegment);
+          break vias;
+        }
+      }
+    }
+    if (shortCenter) {
+      const sourceTrace = db.source_trace.get(trace.source_trace_id);
+      const endpointNames = (sourceTrace?.connected_source_port_ids ?? []).map((id) => {
+        const port = db.source_port.get(id);
+        const component = port?.source_component_id ? db.source_component.get(port.source_component_id) : void 0;
+        return component?.name && port?.name ? `${component.name}.${port.name}` : void 0;
+      }).filter((name) => Boolean(name));
+      const traceName = sourceTrace?.name || sourceTrace?.display_name || endpointNames.join(" \u2192 ") || "unnamed";
+      errors.push({
+        type: "pcb_trace_error",
+        error_type: "pcb_trace_error",
+        pcb_trace_error_id: `self_short_${trace.pcb_trace_id}`,
+        pcb_trace_id: trace.pcb_trace_id,
+        source_trace_id: trace.source_trace_id,
+        message: `PCB trace "${traceName}" shorts to itself, bypassing part of its length-matched route`,
+        center: shortCenter,
+        pcb_component_ids: [],
+        pcb_port_ids: getPcbPortIdsConnectedToTraces([trace]),
+        subcircuit_id: trace.subcircuit_id
+      });
+    }
+  }
+  return errors;
+}
+
 // lib/check-copper-pour-shorts.ts
 import Flatbush from "flatbush";
 import "@flatten-js/core";
@@ -696,25 +1014,190 @@ function checkCopperPourShorts(circuitJson, { connMap } = {}) {
       const id = `copper_pour_short_${[pour.elementId, other.elementId].sort().join("_")}`;
       if (errors.has(id) || !pour.shapes.some((shape) => touchesPour(shape, otherShape)))
         continue;
-      errors.set(id, {
-        type: "pcb_placement_error",
-        pcb_placement_error_id: id,
-        error_type: "pcb_placement_error",
-        message: `Copper pour ${pour.elementId} (${netNames.get(netId) ?? netId ?? "unassigned net"}) shorts to ${getReadableNameForElement(circuitJson, other.elementId)} (${other.elementId}) on ${pour.layer} (accidental copper contact)`,
-        subcircuit_id: element.subcircuit_id
-      });
+      errors.set(id, {
+        type: "pcb_placement_error",
+        pcb_placement_error_id: id,
+        error_type: "pcb_placement_error",
+        message: `Copper pour ${pour.elementId} (${netNames.get(netId) ?? netId ?? "unassigned net"}) shorts to ${getReadableNameForElement(circuitJson, other.elementId)} (${other.elementId}) on ${pour.layer} (accidental copper contact)`,
+        subcircuit_id: element.subcircuit_id
+      });
+    }
+  }
+  return [...errors.values()];
+}
+
+// lib/util/create-indexed-pcb-connectivity-map.ts
+import {
+  ConnectivityMap,
+  findConnectedNetworks,
+  PcbConnectivityMap
+} from "circuit-json-to-connectivity-map";
+import Flatbush3 from "flatbush";
+
+// lib/util/get-via-and-pour-connections.ts
+import { all_layers as all_layers2 } from "circuit-json";
+import {
+  getPourPolygon,
+  getTraceSegmentPolygon,
+  getViaPolygon
+} from "@tscircuit/circuit-json-util";
+import Flatbush2 from "flatbush";
+
+// lib/copper-pour-connectivity/create-copper-polygon-contact-tester.ts
+import {
+  Box
+} from "@flatten-js/core";
+function createCopperPolygonContactTester(tolerance) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const getGeometry = (polygon) => {
+    let geometry = cache.get(polygon);
+    if (!geometry) {
+      geometry = {
+        box: polygon.box,
+        facePoints: [...polygon.faces].map((face) => face.first.start),
+        edges: [...polygon.edges].map((edge) => edge.shape),
+        edgeIndex: polygon.edges
+      };
+      cache.set(polygon, geometry);
+    }
+    return geometry;
+  };
+  return (a, b) => {
+    if (a.isEmpty() || b.isEmpty()) return false;
+    const ga = getGeometry(a);
+    const gb = getGeometry(b);
+    if (ga.box.xmin > gb.box.xmax + tolerance || ga.box.xmax < gb.box.xmin - tolerance || ga.box.ymin > gb.box.ymax + tolerance || ga.box.ymax < gb.box.ymin - tolerance)
+      return false;
+    if (ga.facePoints.some(
+      (point2) => gb.box.contains(point2) && b.contains(point2)
+    ) || gb.facePoints.some((point2) => ga.box.contains(point2) && a.contains(point2)))
+      return true;
+    const [small, large] = ga.edges.length <= gb.edges.length ? [ga, gb] : [gb, ga];
+    for (const edge of small.edges) {
+      const box = edge.box;
+      const queryBox = new Box(
+        box.xmin - tolerance,
+        box.ymin - tolerance,
+        box.xmax + tolerance,
+        box.ymax + tolerance
+      );
+      const candidates = large.edgeIndex.search(
+        queryBox
+      );
+      for (const candidate of candidates) {
+        if (edge.distanceTo(candidate.shape)[0] <= tolerance) return true;
+      }
+    }
+    return false;
+  };
+}
+
+// lib/util/get-via-and-pour-connections.ts
+function getViaAndPourConnections(circuit) {
+  if (!circuit.some(
+    (e) => e.type === "pcb_via" || e.type === "pcb_copper_pour" || e.type === "pcb_trace" && e.route.some((p) => p.route_type === "via")
+  ))
+    return [];
+  const conductors = [];
+  const connections = [];
+  const scale = 1e6;
+  const tolerance = 1e-7 * scale;
+  const touches = createCopperPolygonContactTester(tolerance);
+  const add = (id, layers, polygon, bridges = false) => {
+    if (!polygon.isEmpty())
+      conductors.push({
+        id,
+        layers,
+        polygon: polygon.scale(scale, scale),
+        bridges
+      });
+  };
+  const vias = circuit.filter((e) => e.type === "pcb_via");
+  const board = circuit.find((e) => e.type === "pcb_board");
+  const stack = [
+    "top",
+    ...all_layers2.filter((l) => l.startsWith("inner")).slice(0, board ? Math.max(0, board.num_layers - 2) : void 0),
+    ...board?.num_layers === 1 ? [] : ["bottom"]
+  ];
+  for (const copper of circuit) {
+    if (copper.type === "pcb_via") {
+      add(
+        copper.pcb_via_id,
+        copper.layers,
+        getViaPolygon(copper, copper.outer_diameter, 0),
+        true
+      );
+      if (copper.pcb_trace_id)
+        connections.push([copper.pcb_via_id, copper.pcb_trace_id]);
+    } else if (copper.type === "pcb_copper_pour") {
+      add(
+        copper.pcb_copper_pour_id,
+        [copper.layer],
+        getPourPolygon(copper),
+        true
+      );
+    } else if (copper.type === "pcb_trace") {
+      if (copper.route_thickness_mode === "interpolated") continue;
+      for (let i = 0; i < copper.route.length; i++) {
+        const a = copper.route[i], b = copper.route[i + 1];
+        if (a.route_type === "wire" && b?.route_type === "wire" && a.layer === b.layer && (a.x !== b.x || a.y !== b.y)) {
+          add(
+            copper.pcb_trace_id,
+            [a.layer],
+            getTraceSegmentPolygon(a, b, a.width)
+          );
+        } else if (a.route_type === "via") {
+          if (vias.some(
+            (v) => v.pcb_trace_id === copper.pcb_trace_id && Math.hypot(v.x - a.x, v.y - a.y) < 1e-9
+          ))
+            continue;
+          const from = stack.indexOf(a.from_layer), to = stack.indexOf(a.to_layer);
+          if (from < 0 || to < 0 || !a.outer_diameter) continue;
+          const via = {
+            type: "pcb_via",
+            pcb_via_id: `${copper.pcb_trace_id}_via_${i}`,
+            x: a.x,
+            y: a.y,
+            outer_diameter: a.outer_diameter,
+            hole_diameter: 0,
+            layers: stack.slice(Math.min(from, to), Math.max(from, to) + 1)
+          };
+          add(
+            copper.pcb_trace_id,
+            via.layers,
+            getViaPolygon(via, via.outer_diameter, 0),
+            true
+          );
+        }
+      }
+    }
+  }
+  if (!conductors.length) return connections;
+  const index = new Flatbush2(conductors.length);
+  for (const { polygon } of conductors) {
+    const b = polygon.box;
+    index.add(b.xmin, b.ymin, b.xmax, b.ymax);
+  }
+  index.finish();
+  for (const [i, a] of conductors.entries()) {
+    if (!a.bridges) continue;
+    const box = a.polygon.box;
+    for (const j of index.search(
+      box.xmin - tolerance,
+      box.ymin - tolerance,
+      box.xmax + tolerance,
+      box.ymax + tolerance
+    )) {
+      const b = conductors[j];
+      if (i === j || a.id === b.id || b.bridges && j < i || !a.layers.some((l) => b.layers.includes(l)))
+        continue;
+      if (touches(a.polygon, b.polygon)) connections.push([a.id, b.id]);
     }
   }
-  return [...errors.values()];
+  return connections;
 }
 
 // lib/util/create-indexed-pcb-connectivity-map.ts
-import {
-  ConnectivityMap,
-  findConnectedNetworks,
-  PcbConnectivityMap
-} from "circuit-json-to-connectivity-map";
-import Flatbush2 from "flatbush";
 function createIndexedPcbConnectivityMap(circuitJson) {
   const map = new PcbConnectivityMap();
   map.circuitJson = circuitJson;
@@ -756,7 +1239,7 @@ function createIndexedPcbConnectivityMap(circuitJson) {
   }
   const candidates = traces.map(() => /* @__PURE__ */ new Set());
   for (const bounds of boundsByLayer.values()) {
-    const index = new Flatbush2(bounds.length);
+    const index = new Flatbush3(bounds.length);
     for (const box of bounds) index.add(box.minX, box.minY, box.maxX, box.maxY);
     index.finish();
     for (const box of bounds) {
@@ -795,6 +1278,7 @@ function createIndexedPcbConnectivityMap(circuitJson) {
     for (const connection of connectionsByPort.get(portId) ?? [])
       connections.push(connection);
   }
+  connections.push(...getViaAndPourConnections(circuitJson));
   map.connMap = new ConnectivityMap(findConnectedNetworks(connections));
   return map;
 }
@@ -808,7 +1292,7 @@ import {
   getSegmentIntersection,
   isPointInsidePolygon,
   pointToSegmentClosestPoint,
-  segmentToSegmentMinDistance
+  segmentToSegmentMinDistance as segmentToSegmentMinDistance2
 } from "@tscircuit/math-utils";
 var rotatePoint = (point2, angleDegrees) => {
   const angle = angleDegrees * Math.PI / 180;
@@ -908,7 +1392,7 @@ var getClosestPointsBetweenSegments = (a1, a2, b1, b2) => {
     }
   }
   return {
-    distance: segmentToSegmentMinDistance(a1, a2, b1, b2),
+    distance: segmentToSegmentMinDistance2(a1, a2, b1, b2),
     pointOnA: best.pointOnA,
     pointOnB: best.pointOnB,
     center: {
@@ -1264,63 +1748,14 @@ function getReadableNameForFootprintPad(circuitJson, pad, ordinal) {
   return `${padKind} #${ordinal + 1} at ${location}`;
 }
 
-// lib/copper-pour-connectivity/create-copper-polygon-contact-tester.ts
-import {
-  Box
-} from "@flatten-js/core";
-function createCopperPolygonContactTester(tolerance) {
-  const cache = /* @__PURE__ */ new WeakMap();
-  const getGeometry = (polygon) => {
-    let geometry = cache.get(polygon);
-    if (!geometry) {
-      geometry = {
-        box: polygon.box,
-        facePoints: [...polygon.faces].map((face) => face.first.start),
-        edges: [...polygon.edges].map((edge) => edge.shape),
-        edgeIndex: polygon.edges
-      };
-      cache.set(polygon, geometry);
-    }
-    return geometry;
-  };
-  return (a, b) => {
-    if (a.isEmpty() || b.isEmpty()) return false;
-    const ga = getGeometry(a);
-    const gb = getGeometry(b);
-    if (ga.box.xmin > gb.box.xmax + tolerance || ga.box.xmax < gb.box.xmin - tolerance || ga.box.ymin > gb.box.ymax + tolerance || ga.box.ymax < gb.box.ymin - tolerance)
-      return false;
-    if (ga.facePoints.some(
-      (point2) => gb.box.contains(point2) && b.contains(point2)
-    ) || gb.facePoints.some((point2) => ga.box.contains(point2) && a.contains(point2)))
-      return true;
-    const [small, large] = ga.edges.length <= gb.edges.length ? [ga, gb] : [gb, ga];
-    for (const edge of small.edges) {
-      const box = edge.box;
-      const queryBox = new Box(
-        box.xmin - tolerance,
-        box.ymin - tolerance,
-        box.xmax + tolerance,
-        box.ymax + tolerance
-      );
-      const candidates = large.edgeIndex.search(
-        queryBox
-      );
-      for (const candidate of candidates) {
-        if (edge.distanceTo(candidate.shape)[0] <= tolerance) return true;
-      }
-    }
-    return false;
-  };
-}
-
 // lib/copper-pour-connectivity/get-copper-pour-connectivity.ts
 import {
   getPrimaryId,
   getPlatedHolePolygon,
-  getPourPolygon,
+  getPourPolygon as getPourPolygon2,
   getSmtPadPolygon,
-  getTraceSegmentPolygon,
-  getViaPolygon
+  getTraceSegmentPolygon as getTraceSegmentPolygon2,
+  getViaPolygon as getViaPolygon2
 } from "@tscircuit/circuit-json-util";
 function getCopperPourConnectivity(circuitJson, connectivity) {
   const scale = 1e6;
@@ -1343,7 +1778,7 @@ function getCopperPourConnectivity(circuitJson, connectivity) {
     if (!netId) continue;
     pouredNets.add(netId);
     add({
-      polygon: getPourPolygon(pour),
+      polygon: getPourPolygon2(pour),
       layers: [pour.layer],
       netId,
       isPour: true
@@ -1364,7 +1799,7 @@ function getCopperPourConnectivity(circuitJson, connectivity) {
           if (start.route_type !== "wire" || end.route_type !== "wire" || start.layer !== end.layer)
             continue;
           add({
-            polygon: getTraceSegmentPolygon(start, end, start.width),
+            polygon: getTraceSegmentPolygon2(start, end, start.width),
             layers: [start.layer],
             netId: netId2
           });
@@ -1394,7 +1829,7 @@ function getCopperPourConnectivity(circuitJson, connectivity) {
         });
       } else {
         add({
-          polygon: getViaPolygon(
+          polygon: getViaPolygon2(
             copper,
             copper.outer_diameter,
             copper.hole_diameter
@@ -1578,20 +2013,20 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson, {
 }
 
 // lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import { cju as cju2, getReadableNameForElement as getReadableNameForElement3 } from "@tscircuit/circuit-json-util";
+import { cju as cju3, getReadableNameForElement as getReadableNameForElement3 } from "@tscircuit/circuit-json-util";
 import { getPrimaryId as getPrimaryId2 } from "@tscircuit/circuit-json-util";
 import {
   segmentToBoundsMinDistance,
   segmentToCircleMinDistance as segmentToCircleMinDistance2
 } from "@tscircuit/math-utils";
-import { segmentToSegmentMinDistance as segmentToSegmentMinDistance3 } from "@tscircuit/math-utils";
+import { segmentToSegmentMinDistance as segmentToSegmentMinDistance4 } from "@tscircuit/math-utils";
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson3
 } from "circuit-json-to-connectivity-map";
 
 // lib/check-pad-clearance/common.ts
 import {
-  cju,
+  cju as cju2,
   distanceBetweenCircleAndCircle,
   distanceBetweenCircleAndPolygon,
   distanceBetweenPolygonAndPolygon,
@@ -1601,7 +2036,7 @@ import {
   midpoint,
   pointToSegmentClosestPoint as pointToSegmentClosestPoint2,
   segmentToCircleMinDistance,
-  segmentToSegmentMinDistance as segmentToSegmentMinDistance2
+  segmentToSegmentMinDistance as segmentToSegmentMinDistance3
 } from "@tscircuit/math-utils";
 
 // node_modules/@tscircuit/jlcpcb-manufacturing-specs/lib/jlcpcb-manufacturing-specs.ts
@@ -1768,7 +2203,7 @@ var getPadToPadGap = (padA, padB) => {
   if (isPillPad(padA) && isPillPad(padB)) {
     const pillA = getPillCenterLineForPad(padA);
     const pillB = getPillCenterLineForPad(padB);
-    return segmentToSegmentMinDistance2(
+    return segmentToSegmentMinDistance3(
       pillA.start,
       pillA.end,
       pillB.start,
@@ -1823,11 +2258,11 @@ var getPadToPadGap = (padA, padB) => {
   );
 };
 var getPads = (circuitJson) => [
-  ...cju(circuitJson).pcb_smtpad.list(),
-  ...cju(circuitJson).pcb_plated_hole.list()
+  ...cju2(circuitJson).pcb_smtpad.list(),
+  ...cju2(circuitJson).pcb_plated_hole.list()
 ];
 var getTraceSegments = (circuitJson) => {
-  const pcbTraces = cju(circuitJson).pcb_trace.list();
+  const pcbTraces = cju2(circuitJson).pcb_trace.list();
   return pcbTraces.flatMap((pcbTrace) => {
     const segments = [];
     for (let i = 0; i < pcbTrace.route.length - 1; i++) {
@@ -2045,7 +2480,7 @@ var SpatialObjectIndex = class {
 };
 
 // lib/util/getLayersOfPcbElement.ts
-import { all_layers } from "circuit-json";
+import { all_layers as all_layers3 } from "circuit-json";
 function getLayersOfPcbElement(obj) {
   if (obj.type === "pcb_trace_segment") {
     return [obj.layer];
@@ -2054,13 +2489,13 @@ function getLayersOfPcbElement(obj) {
     return [obj.layer];
   }
   if (obj.type === "pcb_plated_hole") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers3];
   }
   if (obj.type === "pcb_hole") {
-    return [...all_layers];
+    return [...all_layers3];
   }
   if (obj.type === "pcb_via") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers3];
   }
   if (obj.type === "pcb_keepout") {
     return Array.isArray(obj.layers) ? obj.layers : [];
@@ -2161,151 +2596,6 @@ var getClosestPointBetweenSegmentAndBounds = (segment, bounds) => {
   return closestPoint;
 };
 
-// lib/check-each-pcb-trace-non-overlapping/getClosestPointBetweenSegments.ts
-var getClosestPointBetweenSegments = (segmentA, segmentB) => {
-  const a1 = { x: segmentA.x1, y: segmentA.y1 };
-  const a2 = { x: segmentA.x2, y: segmentA.y2 };
-  const b1 = { x: segmentB.x1, y: segmentB.y1 };
-  const b2 = { x: segmentB.x2, y: segmentB.y2 };
-  const va = { x: a2.x - a1.x, y: a2.y - a1.y };
-  const vb = { x: b2.x - b1.x, y: b2.y - b1.y };
-  const lenSqrA = va.x * va.x + va.y * va.y;
-  const lenSqrB = vb.x * vb.x + vb.y * vb.y;
-  if (lenSqrA === 0 || lenSqrB === 0) {
-    if (lenSqrA === 0 && lenSqrB === 0) {
-      return {
-        x: (a1.x + b1.x) / 2,
-        y: (a1.y + b1.y) / 2
-      };
-    }
-    if (lenSqrA === 0) {
-      const t2 = clamp(
-        ((a1.x - b1.x) * vb.x + (a1.y - b1.y) * vb.y) / lenSqrB,
-        0,
-        1
-      );
-      const closestOnB2 = {
-        x: b1.x + t2 * vb.x,
-        y: b1.y + t2 * vb.y
-      };
-      return {
-        x: (a1.x + closestOnB2.x) / 2,
-        y: (a1.y + closestOnB2.y) / 2
-      };
-    }
-    const t = clamp(
-      ((b1.x - a1.x) * va.x + (b1.y - a1.y) * va.y) / lenSqrA,
-      0,
-      1
-    );
-    const closestOnA2 = {
-      x: a1.x + t * va.x,
-      y: a1.y + t * va.y
-    };
-    return {
-      x: (closestOnA2.x + b1.x) / 2,
-      y: (closestOnA2.y + b1.y) / 2
-    };
-  }
-  const w = { x: a1.x - b1.x, y: a1.y - b1.y };
-  const dotAA = va.x * va.x + va.y * va.y;
-  const dotAB = va.x * vb.x + va.y * vb.y;
-  const dotAW = va.x * w.x + va.y * w.y;
-  const dotBB = vb.x * vb.x + vb.y * vb.y;
-  const dotBW = vb.x * w.x + vb.y * w.y;
-  const denominator = dotAA * dotBB - dotAB * dotAB;
-  if (denominator < 1e-10) {
-    return closestPointsParallelSegments(
-      a1,
-      a2,
-      b1,
-      b2,
-      va,
-      vb,
-      lenSqrA,
-      lenSqrB
-    );
-  }
-  let tA = (dotAB * dotBW - dotBB * dotAW) / denominator;
-  let tB = (dotAA * dotBW - dotAB * dotAW) / denominator;
-  tA = clamp(tA, 0, 1);
-  tB = clamp(tB, 0, 1);
-  tB = (tA * dotAB + dotBW) / dotBB;
-  tB = clamp(tB, 0, 1);
-  tA = (tB * dotAB - dotAW) / dotAA;
-  tA = clamp(tA, 0, 1);
-  const closestOnA = {
-    x: a1.x + tA * va.x,
-    y: a1.y + tA * va.y
-  };
-  const closestOnB = {
-    x: b1.x + tB * vb.x,
-    y: b1.y + tB * vb.y
-  };
-  const dx = closestOnA.x - closestOnB.x;
-  const dy = closestOnA.y - closestOnB.y;
-  const distance3 = Math.sqrt(dx * dx + dy * dy);
-  const averagePoint = {
-    x: (closestOnA.x + closestOnB.x) / 2,
-    y: (closestOnA.y + closestOnB.y) / 2
-  };
-  return averagePoint;
-};
-var closestPointsParallelSegments = (a1, a2, b1, b2, va, vb, lenSqrA, lenSqrB) => {
-  let tA = ((b1.x - a1.x) * va.x + (b1.y - a1.y) * va.y) / lenSqrA;
-  tA = clamp(tA, 0, 1);
-  const pointOnA1 = { x: a1.x + tA * va.x, y: a1.y + tA * va.y };
-  let tA2 = ((b2.x - a1.x) * va.x + (b2.y - a1.y) * va.y) / lenSqrA;
-  tA2 = clamp(tA2, 0, 1);
-  const pointOnA2 = { x: a1.x + tA2 * va.x, y: a1.y + tA2 * va.y };
-  let tB = ((a1.x - b1.x) * vb.x + (a1.y - b1.y) * vb.y) / lenSqrB;
-  tB = clamp(tB, 0, 1);
-  const pointOnB1 = { x: b1.x + tB * vb.x, y: b1.y + tB * vb.y };
-  let tB2 = ((a2.x - b1.x) * vb.x + (a2.y - b1.y) * vb.y) / lenSqrB;
-  tB2 = clamp(tB2, 0, 1);
-  const pointOnB2 = { x: b1.x + tB2 * vb.x, y: b1.y + tB2 * vb.y };
-  const distances = [
-    {
-      pointA: pointOnA1,
-      pointB: b1,
-      distance: Math.sqrt(
-        (pointOnA1.x - b1.x) ** 2 + (pointOnA1.y - b1.y) ** 2
-      )
-    },
-    {
-      pointA: pointOnA2,
-      pointB: b2,
-      distance: Math.sqrt(
-        (pointOnA2.x - b2.x) ** 2 + (pointOnA2.y - b2.y) ** 2
-      )
-    },
-    {
-      pointA: a1,
-      pointB: pointOnB1,
-      distance: Math.sqrt(
-        (a1.x - pointOnB1.x) ** 2 + (a1.y - pointOnB1.y) ** 2
-      )
-    },
-    {
-      pointA: a2,
-      pointB: pointOnB2,
-      distance: Math.sqrt(
-        (a2.x - pointOnB2.x) ** 2 + (a2.y - pointOnB2.y) ** 2
-      )
-    }
-  ];
-  const closestPair = distances.reduce(
-    (closest, current) => current.distance < closest.distance ? current : closest
-  );
-  return {
-    x: (closestPair.pointA.x + closestPair.pointB.x) / 2,
-    y: (closestPair.pointA.y + closestPair.pointB.y) / 2
-  };
-};
-var clamp = (value, min, max) => {
-  return Math.max(min, Math.min(max, value));
-};
-
 // lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
 import { getBoundsOfPcbElements as getBoundsOfPcbElements3 } from "@tscircuit/circuit-json-util";
 var getCollidableBounds = (collidable) => {
@@ -2341,32 +2631,6 @@ var getCollidableBounds = (collidable) => {
   return getBoundsOfPcbElements3([collidable]);
 };
 
-// lib/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
-function getPcbPortIdsConnectedToRoutePoint(routePoint) {
-  if (routePoint.route_type !== "wire") return [];
-  return [routePoint.start_pcb_port_id, routePoint.end_pcb_port_id].filter(
-    (portId) => Boolean(portId)
-  );
-}
-function getPcbPortIdsConnectedToTrace(trace) {
-  const connectedPcbPorts = /* @__PURE__ */ new Set();
-  for (const segment of trace.route) {
-    for (const portId of getPcbPortIdsConnectedToRoutePoint(segment)) {
-      connectedPcbPorts.add(portId);
-    }
-  }
-  return Array.from(connectedPcbPorts);
-}
-function getPcbPortIdsConnectedToTraces(traces) {
-  const connectedPorts = /* @__PURE__ */ new Set();
-  for (const trace of traces) {
-    for (const portId of getPcbPortIdsConnectedToTrace(trace)) {
-      connectedPorts.add(portId);
-    }
-  }
-  return Array.from(connectedPorts);
-}
-
 // lib/check-each-pcb-trace-non-overlapping/getRadiusOfCircuitJsonElement.ts
 var getRadiusOfCircuitJsonElement = (obj) => {
   if (obj.type === "pcb_via") {
@@ -2396,12 +2660,12 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
   connMap,
   minClearance
 } = {}) {
-  const errors = [];
+  const errors = checkPcbTraceSelfShorts(circuitJson);
   addStartAndEndPortIdsIfMissing(circuitJson);
   connMap ??= getFullConnectivityMapFromCircuitJson3(circuitJson);
   const board = getPcbBoard(circuitJson);
   minClearance ??= getBoardDrcValue(board, "min_trace_to_pad_edge_clearance") ?? DEFAULT_TRACE_MARGIN;
-  const pcbTraces = cju2(circuitJson).pcb_trace.list();
+  const pcbTraces = cju3(circuitJson).pcb_trace.list();
   const pcbTraceSegments = pcbTraces.flatMap((pcbTrace) => {
     const segments = [];
     for (let i = 0; i < pcbTrace.route.length - 1; i++) {
@@ -2424,12 +2688,12 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
     }
     return segments;
   });
-  const pcbSmtPads = cju2(circuitJson).pcb_smtpad.list();
-  const pcbPlatedHoles = cju2(circuitJson).pcb_plated_hole.list();
-  const pcbPorts = cju2(circuitJson).pcb_port.list();
-  const pcbHoles = cju2(circuitJson).pcb_hole.list();
-  const pcbVias = cju2(circuitJson).pcb_via.list();
-  const pcbKeepouts = cju2(circuitJson).pcb_keepout.list().filter((keepout) => !keepout.allow_traces);
+  const pcbSmtPads = cju3(circuitJson).pcb_smtpad.list();
+  const pcbPlatedHoles = cju3(circuitJson).pcb_plated_hole.list();
+  const pcbPorts = cju3(circuitJson).pcb_port.list();
+  const pcbHoles = cju3(circuitJson).pcb_hole.list();
+  const pcbVias = cju3(circuitJson).pcb_via.list();
+  const pcbKeepouts = cju3(circuitJson).pcb_keepout.list().filter((keepout) => !keepout.allow_traces);
   const pcbComponentConnectionElements = [
     ...pcbPorts,
     ...pcbSmtPads,
@@ -2490,7 +2754,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         if (segmentA.layer !== segmentB.layer) continue;
         if (connMap.areIdsConnected(segmentA.pcb_trace_id, segmentB.pcb_trace_id))
           continue;
-        const gap2 = segmentToSegmentMinDistance3(
+        const gap2 = segmentToSegmentMinDistance4(
           { x: segmentA.x1, y: segmentA.y1 },
           { x: segmentA.x2, y: segmentA.y2 },
           { x: segmentB.x1, y: segmentB.y1 },
@@ -3149,7 +3413,7 @@ function checkPcbComponentOverCutout(circuitJson) {
 }
 
 // lib/check-pcb-copper-over-keepout.ts
-import { cju as cju3, getPrimaryId as getPrimaryId3 } from "@tscircuit/circuit-json-util";
+import { cju as cju4, 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) {
@@ -3165,11 +3429,11 @@ var getReadableCopperName = (circuitJson, 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();
+  const keepouts = cju4(circuitJson).pcb_keepout.list();
   if (keepouts.length === 0) return [];
   const copper = [
     ...getPads(circuitJson),
-    ...cju3(circuitJson).pcb_via.list()
+    ...cju4(circuitJson).pcb_via.list()
   ];
   const errors = /* @__PURE__ */ new Map();
   for (const keepout of keepouts) {
@@ -3346,11 +3610,11 @@ function checkDifferentNetViaSpacing(circuitJson, {
 }
 
 // lib/check-source-traces-match-pcb-trace-thickness.ts
-import { cju as cju4 } from "@tscircuit/circuit-json-util";
+import { cju as cju5 } from "@tscircuit/circuit-json-util";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson6 } from "circuit-json-to-connectivity-map";
 function checkSourceTracesMatchPcbTraceThickness(circuitJson) {
   const warnings = [];
-  const db = cju4(circuitJson);
+  const db = cju5(circuitJson);
   const sourceTraces = db.source_trace.list();
   const pcbTraces = db.pcb_trace.list();
   const pcbPorts = db.pcb_port.list();
@@ -3489,7 +3753,7 @@ import {
 
 // lib/check-traces-are-contiguous/via-contact-index.ts
 import {
-  all_layers as all_layers2
+  all_layers as all_layers4
 } from "circuit-json";
 import { getPrimaryId as getPrimaryId4 } from "@tscircuit/circuit-json-util";
 import { pointToSegmentDistance as pointToSegmentDistance2 } from "@tscircuit/math-utils";
@@ -3501,7 +3765,7 @@ function getViaContactIndex(circuitJson, connectivity) {
   const vias = circuitJson.filter((element) => element.type === "pcb_via");
   const board = circuitJson.find((element) => element.type === "pcb_board");
   const layerCount = board?.num_layers;
-  const innerLayers = all_layers2.filter((layer) => layer.startsWith("inner"));
+  const innerLayers = all_layers4.filter((layer) => layer.startsWith("inner"));
   const stack = [
     "top",
     ...innerLayers.slice(
@@ -4027,8 +4291,8 @@ function checkTracesAreContiguous(circuitJson, {
 }
 
 // lib/check-trace-out-of-board/checkTraceOutOfBoard.ts
-import { cju as cju5 } from "@tscircuit/circuit-json-util";
-import { segmentToSegmentMinDistance as segmentToSegmentMinDistance4 } from "@tscircuit/math-utils";
+import { cju as cju6 } from "@tscircuit/circuit-json-util";
+import { segmentToSegmentMinDistance as segmentToSegmentMinDistance5 } from "@tscircuit/math-utils";
 function getBoardPolygonPoints(board) {
   if (board.outline && board.outline.length > 0) {
     return board.outline.map((p) => ({ x: p.x, y: p.y }));
@@ -4058,7 +4322,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 = cju5(circuitJson).pcb_trace.list();
+  const pcbTraces = cju6(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++) {
@@ -4072,7 +4336,7 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
       for (let j = 0; j < boardPoints.length; j++) {
         const edgeStart = boardPoints[j];
         const edgeEnd = boardPoints[(j + 1) % boardPoints.length];
-        const distance3 = segmentToSegmentMinDistance4(
+        const distance3 = segmentToSegmentMinDistance5(
           segmentStart,
           segmentEnd,
           edgeStart,
@@ -4107,7 +4371,7 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
 
 // lib/check-pcb-components-overlap/checkPcbComponentOverlap.ts
 import {
-  cju as cju6,
+  cju as cju7,
   getBoundsOfPcbElements as getBoundsOfPcbElements5,
   getPrimaryId as getPrimaryId5
 } from "@tscircuit/circuit-json-util";
@@ -4205,9 +4469,9 @@ function checkPcbComponentOverlap(circuitJson) {
     )
   );
   const connMap = getFullConnectivityMapFromCircuitJson9(circuitJson);
-  const smtPads = cju6(circuitJson).pcb_smtpad.list();
-  const platedHoles = cju6(circuitJson).pcb_plated_hole.list();
-  const holes = cju6(circuitJson).pcb_hole.list();
+  const smtPads = cju7(circuitJson).pcb_smtpad.list();
+  const platedHoles = cju7(circuitJson).pcb_plated_hole.list();
+  const holes = cju7(circuitJson).pcb_hole.list();
   const courtyards = circuitJson.filter(isCourtyardElement2);
   const componentMap = /* @__PURE__ */ new Map();
   for (const pad of smtPads) {
@@ -4949,7 +5213,7 @@ function checkTwoTerminalSwitchContactsOnDifferentNets(circuitJson) {
 }
 
 // lib/check-all-pins-in-component-are-underspecified.ts
-import { cju as cju7 } from "@tscircuit/circuit-json-util";
+import { cju as cju8 } from "@tscircuit/circuit-json-util";
 var PIN_ATTRIBUTE_KEYS = [
   "must_be_connected",
   "provides_power",
@@ -4994,7 +5258,7 @@ function hasAnyPinAttribute(port) {
 }
 function checkAllPinsInComponentAreUnderspecified(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();
@@ -5026,7 +5290,7 @@ function checkAllPinsInComponentAreUnderspecified(circuitJson) {
 }
 
 // lib/check-no-power-pin-defined.ts
-import { cju as cju8 } from "@tscircuit/circuit-json-util";
+import { cju as cju9 } from "@tscircuit/circuit-json-util";
 
 // lib/util/should-check-chip-power-ground-pins.ts
 var shouldCheckChipPowerGroundPins = (component, ports) => component.ftype === "simple_chip" && ports.filter((port) => port.do_not_connect !== true).length >= 2;
@@ -5034,7 +5298,7 @@ var shouldCheckChipPowerGroundPins = (component, ports) => component.ftype === "
 // lib/check-no-power-pin-defined.ts
 function checkNoPowerPinDefined(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();
@@ -5065,10 +5329,10 @@ function checkNoPowerPinDefined(circuitJson) {
 }
 
 // lib/check-no-ground-pin-defined.ts
-import { cju as cju9 } from "@tscircuit/circuit-json-util";
+import { cju as cju10 } from "@tscircuit/circuit-json-util";
 function checkNoGroundPinDefined(circuitJson) {
   const warnings = [];
-  const db = cju9(circuitJson);
+  const db = cju10(circuitJson);
   const sourceComponents = db.source_component.list();
   const sourcePorts = db.source_port.list();
   const portsByComponent = /* @__PURE__ */ new Map();
@@ -5929,6 +6193,7 @@ export {
   checkPcbComponentsOutOfBoard,
   checkPcbCopperOverKeepout,
   checkPcbTraceLengths,
+  checkPcbTraceSelfShorts,
   checkPcbTraceViaCounts,
   checkPcbTracesOutOfBoard,
   checkPinMustBeConnected,