@tscircuit/checks 0.0.208 → 0.0.210

package/dist/index.js

@@ -1,3 +1,325 @@
+// 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 directionLengthProduct = Math.hypot(a.x2 - a.x1, a.y2 - a.y1) * Math.hypot(b.x2 - b.x1, b.y2 - b.y1);
+        const isForwardOrRightAngle = dot >= -1e-9 * directionLengthProduct;
+        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 && // A right-angle connector can have sqrt(2) times the straight-line
+        // distance. Its local copper overlap is still part of the same bend.
+        b.startDistance - a.endDistance <= Math.SQRT2 * contactDistance && isForwardOrRightAngle)
+          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";
@@ -717,7 +1039,7 @@ import {
 import Flatbush3 from "flatbush";
 
 // lib/util/get-via-and-pour-connections.ts
-import { all_layers } from "circuit-json";
+import { all_layers as all_layers2 } from "circuit-json";
 import {
   getPourPolygon,
   getTraceSegmentPolygon,
@@ -798,7 +1120,7 @@ function getViaAndPourConnections(circuit) {
   const board = circuit.find((e) => e.type === "pcb_board");
   const stack = [
     "top",
-    ...all_layers.filter((l) => l.startsWith("inner")).slice(0, board ? Math.max(0, board.num_layers - 2) : void 0),
+    ...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) {
@@ -974,7 +1296,7 @@ import {
   getSegmentIntersection,
   isPointInsidePolygon,
   pointToSegmentClosestPoint,
-  segmentToSegmentMinDistance
+  segmentToSegmentMinDistance as segmentToSegmentMinDistance2
 } from "@tscircuit/math-utils";
 var rotatePoint = (point2, angleDegrees) => {
   const angle = angleDegrees * Math.PI / 180;
@@ -1074,7 +1396,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: {
@@ -1695,20 +2017,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,
@@ -1718,7 +2040,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
@@ -1885,7 +2207,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,
@@ -1940,11 +2262,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++) {
@@ -2162,7 +2484,7 @@ var SpatialObjectIndex = class {
 };
 
 // lib/util/getLayersOfPcbElement.ts
-import { all_layers as all_layers2 } from "circuit-json";
+import { all_layers as all_layers3 } from "circuit-json";
 function getLayersOfPcbElement(obj) {
   if (obj.type === "pcb_trace_segment") {
     return [obj.layer];
@@ -2171,13 +2493,13 @@ function getLayersOfPcbElement(obj) {
     return [obj.layer];
   }
   if (obj.type === "pcb_plated_hole") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers2];
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers3];
   }
   if (obj.type === "pcb_hole") {
-    return [...all_layers2];
+    return [...all_layers3];
   }
   if (obj.type === "pcb_via") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers2];
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers3];
   }
   if (obj.type === "pcb_keepout") {
     return Array.isArray(obj.layers) ? obj.layers : [];
@@ -2278,151 +2600,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) => {
@@ -2458,32 +2635,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") {
@@ -2513,12 +2664,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++) {
@@ -2541,12 +2692,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,
@@ -2607,7 +2758,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 },
@@ -3266,7 +3417,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) {
@@ -3282,11 +3433,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) {
@@ -3463,11 +3614,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();
@@ -3606,7 +3757,7 @@ import {
 
 // lib/check-traces-are-contiguous/via-contact-index.ts
 import {
-  all_layers as all_layers3
+  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";
@@ -3618,7 +3769,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_layers3.filter((layer) => layer.startsWith("inner"));
+  const innerLayers = all_layers4.filter((layer) => layer.startsWith("inner"));
   const stack = [
     "top",
     ...innerLayers.slice(
@@ -4144,8 +4295,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 }));
@@ -4175,7 +4326,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++) {
@@ -4189,7 +4340,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,
@@ -4224,7 +4375,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";
@@ -4322,9 +4473,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) {
@@ -5066,7 +5217,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",
@@ -5111,7 +5262,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();
@@ -5143,7 +5294,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;
@@ -5151,7 +5302,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();
@@ -5182,10 +5333,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();
@@ -6046,6 +6197,7 @@ export {
   checkPcbComponentsOutOfBoard,
   checkPcbCopperOverKeepout,
   checkPcbTraceLengths,
+  checkPcbTraceSelfShorts,
   checkPcbTraceViaCounts,
   checkPcbTracesOutOfBoard,
   checkPinMustBeConnected,