@tscircuit/checks 0.0.123 → 0.0.125

package/dist/index.js

@@ -363,12 +363,14 @@ var jlcMinTolerances = {
 var DEFAULT_TRACE_MARGIN = 0.1;
 var DEFAULT_TRACE_THICKNESS = jlcMinTolerances.min_trace_width;
 var DEFAULT_VIA_DIAMETER = jlcMinTolerances.min_via_pad_diameter;
-var DEFAULT_VIA_BOARD_MARGIN = 0.3;
+var DEFAULT_VIA_BOARD_MARGIN = jlcMinTolerances.min_board_edge_clearance;
 var DEFAULT_SAME_NET_VIA_MARGIN = jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
 var DEFAULT_DIFFERENT_NET_VIA_MARGIN = jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
 var DEFAULT_PAD_PAD_CLEARANCE = jlcMinTolerances.min_pad_edge_to_pad_edge_clearance;
 var DEFAULT_PAD_TRACE_CLEARANCE = jlcMinTolerances.min_trace_to_pad_edge_clearance;
 var EPSILON = 5e-3;
+var getPcbBoard = (circuitJson) => circuitJson.find((el) => el.type === "pcb_board");
+var getBoardDrcValue = (board, key) => board?.[key];
 
 // lib/util/getLayersOfPcbElement.ts
 import { all_layers } from "circuit-json";
@@ -570,7 +572,7 @@ var getClosestPointBetweenSegments = (segmentA, segmentB) => {
   };
   const dx = closestOnA.x - closestOnB.x;
   const dy = closestOnA.y - closestOnB.y;
-  const distance3 = Math.sqrt(dx * dx + dy * dy);
+  const distance4 = Math.sqrt(dx * dx + dy * dy);
   const averagePoint = {
     x: (closestOnA.x + closestOnB.x) / 2,
     y: (closestOnA.y + closestOnB.y) / 2
@@ -802,12 +804,12 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
       const isCircular = obj.type === "pcb_via" || obj.type === "pcb_plated_hole" && obj.shape === "circle" || obj.type === "pcb_hole" || obj.type === "pcb_smtpad" && obj.shape === "circle";
       if (isCircular) {
         const radius = getRadiusOfCircuitJsonElement(obj);
-        const distance3 = segmentToCircleMinDistance(
+        const distance4 = segmentToCircleMinDistance(
           { x: segmentA.x1, y: segmentA.y1 },
           { x: segmentA.x2, y: segmentA.y2 },
           { x: obj.x, y: obj.y, radius }
         );
-        const gap2 = distance3 - segmentA.thickness / 2;
+        const gap2 = distance4 - segmentA.thickness / 2;
         if (gap2 > minClearance - EPSILON) continue;
         const pcb_trace_error_id = `overlap_${segmentA.pcb_trace_id}_${primaryObjId}`;
         if (errorIds.has(pcb_trace_error_id)) continue;
@@ -919,11 +921,12 @@ var NetManager = class {
 // lib/check-pcb-components-out-of-board/checkViasOffBoard.ts
 import { getReadableNameForElement as getReadableNameForElement3 } from "@tscircuit/circuit-json-util";
 function checkViasOffBoard(circuitJson) {
-  const board = circuitJson.find((el) => el.type === "pcb_board");
+  const board = getPcbBoard(circuitJson);
   if (!board) return [];
   const vias = circuitJson.filter((el) => el.type === "pcb_via");
   if (vias.length === 0) return [];
   if (board.width === void 0 || board.height === void 0) return [];
+  const boardEdgeClearance = getBoardDrcValue(board, "min_board_edge_clearance") ?? jlcMinTolerances.min_board_edge_clearance;
   const boardMinX = board.center.x - board.width / 2;
   const boardMaxX = board.center.x + board.width / 2;
   const boardMinY = board.center.y - board.height / 2;
@@ -935,7 +938,7 @@ function checkViasOffBoard(circuitJson) {
     const viaMaxX = via.x + viaRadius;
     const viaMinY = via.y - viaRadius;
     const viaMaxY = via.y + viaRadius;
-    if (viaMinX < boardMinX + DEFAULT_VIA_BOARD_MARGIN || viaMaxX > boardMaxX - DEFAULT_VIA_BOARD_MARGIN || viaMinY < boardMinY + DEFAULT_VIA_BOARD_MARGIN || viaMaxY > boardMaxY - DEFAULT_VIA_BOARD_MARGIN) {
+    if (viaMinX < boardMinX + boardEdgeClearance || viaMaxX > boardMaxX - boardEdgeClearance || viaMinY < boardMinY + boardEdgeClearance || viaMaxY > boardMaxY - boardEdgeClearance) {
       const viaName = getReadableNameForElement3(circuitJson, via.pcb_via_id);
       errors.push({
         type: "pcb_placement_error",
@@ -1199,10 +1202,12 @@ function viasAreAtSameLocation(a, b) {
 // lib/check-same-net-via-spacing.ts
 function checkSameNetViaSpacing(circuitJson, {
   connMap,
-  minClearance = DEFAULT_SAME_NET_VIA_MARGIN
+  minClearance
 } = {}) {
   const vias = circuitJson.filter((el) => el.type === "pcb_via");
   if (vias.length < 2) return [];
+  const board = getPcbBoard(circuitJson);
+  minClearance ??= getBoardDrcValue(board, "min_via_hole_edge_to_via_hole_edge_clearance") ?? jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
   connMap ??= getFullConnectivityMapFromCircuitJson3(circuitJson);
   const errors = [];
   const reported = /* @__PURE__ */ new Set();
@@ -1212,7 +1217,7 @@ function checkSameNetViaSpacing(circuitJson, {
       const viaB = vias[j];
       if (viasAreAtSameLocation(viaA, viaB)) continue;
       if (!connMap.areIdsConnected(viaA.pcb_via_id, viaB.pcb_via_id)) continue;
-      const gap = distance2(viaA, viaB) - viaA.outer_diameter / 2 - viaB.outer_diameter / 2;
+      const gap = distance2(viaA, viaB) - viaA.hole_diameter / 2 - viaB.hole_diameter / 2;
       if (gap + EPSILON >= minClearance) continue;
       const pairId = [viaA.pcb_via_id, viaB.pcb_via_id].sort().join("_");
       if (reported.has(pairId)) continue;
@@ -1248,10 +1253,12 @@ import {
 } from "circuit-json-to-connectivity-map";
 function checkDifferentNetViaSpacing(circuitJson, {
   connMap,
-  minClearance = DEFAULT_DIFFERENT_NET_VIA_MARGIN
+  minClearance
 } = {}) {
   const vias = circuitJson.filter((el) => el.type === "pcb_via");
   if (vias.length < 2) return [];
+  const board = getPcbBoard(circuitJson);
+  minClearance ??= getBoardDrcValue(board, "min_via_hole_edge_to_via_hole_edge_clearance") ?? jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
   connMap ??= getFullConnectivityMapFromCircuitJson4(circuitJson);
   const errors = [];
   const reported = /* @__PURE__ */ new Set();
@@ -1261,7 +1268,7 @@ function checkDifferentNetViaSpacing(circuitJson, {
       const viaB = vias[j];
       if (viasAreAtSameLocation(viaA, viaB)) continue;
       if (connMap.areIdsConnected(viaA.pcb_via_id, viaB.pcb_via_id)) continue;
-      const gap = distance2(viaA, viaB) - viaA.outer_diameter / 2 - viaB.outer_diameter / 2;
+      const gap = distance2(viaA, viaB) - viaA.hole_diameter / 2 - viaB.hole_diameter / 2;
       if (gap + EPSILON >= minClearance) continue;
       const pairId = [viaA.pcb_via_id, viaB.pcb_via_id].sort().join("_");
       if (reported.has(pairId)) continue;
@@ -1414,7 +1421,6 @@ function checkSourceTracesHavePcbTraces(circuitJson) {
 // lib/check-trace-out-of-board/checkTraceOutOfBoard.ts
 import { cju as cju3 } from "@tscircuit/circuit-json-util";
 import { segmentToSegmentMinDistance as segmentToSegmentMinDistance2 } from "@tscircuit/math-utils";
-var DEFAULT_BOARD_MARGIN = 0.2;
 function getBoardPolygonPoints(board) {
   if (board.outline && board.outline.length > 0) {
     return board.outline.map((p) => ({ x: p.x, y: p.y }));
@@ -1439,11 +1445,9 @@ function getBoardPolygonPoints(board) {
 }
 function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
   const errors = [];
-  const margin = config.margin ?? DEFAULT_BOARD_MARGIN;
-  const board = circuitJson.find(
-    (el) => el.type === "pcb_board"
-  );
+  const board = getPcbBoard(circuitJson);
   if (!board) return errors;
+  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 = cju3(circuitJson).pcb_trace.list();
@@ -1456,18 +1460,18 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
       const traceWidth = "width" in p1 ? p1.width : "width" in p2 ? p2.width : 0.1;
       const segmentStart = { x: p1.x, y: p1.y };
       const segmentEnd = { x: p2.x, y: p2.y };
-      let minDistance = Infinity;
+      let minDistance = Number.POSITIVE_INFINITY;
       for (let j = 0; j < boardPoints.length; j++) {
         const edgeStart = boardPoints[j];
         const edgeEnd = boardPoints[(j + 1) % boardPoints.length];
-        const distance3 = segmentToSegmentMinDistance2(
+        const distance4 = segmentToSegmentMinDistance2(
           segmentStart,
           segmentEnd,
           edgeStart,
           edgeEnd
         );
-        if (distance3 < minDistance) {
-          minDistance = distance3;
+        if (distance4 < minDistance) {
+          minDistance = distance4;
         }
       }
       const minimumDistance = traceWidth / 2 + margin;
@@ -1741,10 +1745,12 @@ var getTraceSegments = (circuitJson) => {
 // lib/check-pad-pad-clearance.ts
 function checkPadPadClearance(circuitJson, {
   connMap,
-  minClearance = DEFAULT_PAD_PAD_CLEARANCE
+  minClearance
 } = {}) {
   const pads = getPads(circuitJson);
   if (pads.length < 2) return [];
+  const board = getPcbBoard(circuitJson);
+  minClearance ??= getBoardDrcValue(board, "min_pad_edge_to_pad_edge_clearance") ?? jlcMinTolerances.min_pad_edge_to_pad_edge_clearance;
   connMap ??= getFullConnectivityMapFromCircuitJson7(circuitJson);
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
@@ -1807,11 +1813,13 @@ import {
 } from "circuit-json-to-connectivity-map";
 function checkPadTraceClearance(circuitJson, {
   connMap,
-  minClearance = DEFAULT_PAD_TRACE_CLEARANCE
+  minClearance
 } = {}) {
   const pads = getPads(circuitJson);
   const segments = getTraceSegments(circuitJson);
   if (pads.length === 0 || segments.length === 0) return [];
+  const board = getPcbBoard(circuitJson);
+  minClearance ??= getBoardDrcValue(board, "min_trace_to_pad_edge_clearance") ?? jlcMinTolerances.min_trace_to_pad_edge_clearance;
   connMap ??= getFullConnectivityMapFromCircuitJson8(circuitJson);
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
@@ -1888,11 +1896,13 @@ var getClosestPointOnSegment = (point, segmentStart, segmentEnd) => {
 };
 function checkViaTraceClearance(circuitJson, {
   connMap,
-  minClearance = DEFAULT_PAD_TRACE_CLEARANCE
+  minClearance
 } = {}) {
   const vias = circuitJson.filter((el) => el.type === "pcb_via");
   const segments = getTraceSegments(circuitJson);
   if (vias.length === 0 || segments.length === 0) return [];
+  const board = getPcbBoard(circuitJson);
+  minClearance ??= getBoardDrcValue(board, "min_trace_to_pad_edge_clearance") ?? jlcMinTolerances.min_trace_to_pad_edge_clearance;
   connMap ??= getFullConnectivityMapFromCircuitJson9(circuitJson);
   const errors = /* @__PURE__ */ new Map();
   for (const via of vias) {
@@ -2338,8 +2348,210 @@ function checkCourtyardOverlap(circuitJson) {
   return errors;
 }
 
+// lib/check-traces-are-contiguous/is-point-in-pad.ts
+function distance3(x1, y1, x2, y2) {
+  return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+}
+function isPointInPad(point, pad) {
+  if (pad.type === "pcb_smtpad") {
+    if (pad.shape === "circle") {
+      return distance3(point.x, point.y, pad.x, pad.y) <= pad.radius;
+    }
+    if (pad.shape === "rect") {
+      const halfWidth = pad.width / 2;
+      const halfHeight = pad.height / 2;
+      return Math.abs(point.x - pad.x) <= halfWidth && Math.abs(point.y - pad.y) <= halfHeight;
+    }
+    if (pad.shape === "rotated_rect") {
+      const dx = point.x - pad.x;
+      const dy = point.y - pad.y;
+      const angle = -pad.ccw_rotation;
+      const rotatedX = dx * Math.cos(angle) - dy * Math.sin(angle);
+      const rotatedY = dx * Math.sin(angle) + dy * Math.cos(angle);
+      return Math.abs(rotatedX) <= pad.width / 2 && Math.abs(rotatedY) <= pad.height / 2;
+    }
+    if (pad.shape === "pill") {
+      const halfWidth = pad.width / 2;
+      const halfHeight = pad.height / 2;
+      const radius = pad.radius;
+      if (Math.abs(point.x - pad.x) <= halfWidth - radius && Math.abs(point.y - pad.y) <= halfHeight) {
+        return true;
+      }
+      const cornerX = Math.max(
+        Math.abs(point.x - pad.x) - (halfWidth - radius),
+        0
+      );
+      const cornerY = Math.max(
+        Math.abs(point.y - pad.y) - (halfHeight - radius),
+        0
+      );
+      return cornerX * cornerX + cornerY * cornerY <= radius * radius;
+    }
+  }
+  if (pad.type === "pcb_plated_hole") {
+    if (pad.shape === "circle") {
+      return distance3(point.x, point.y, pad.x, pad.y) <= pad.outer_diameter / 2;
+    }
+    if (pad.shape === "oval" || pad.shape === "pill") {
+      return Math.abs(point.x - pad.x) <= pad.outer_width / 2 && Math.abs(point.y - pad.y) <= pad.outer_height / 2;
+    }
+    if (pad.shape === "circular_hole_with_rect_pad") {
+      return Math.abs(point.x - pad.x) <= pad.rect_pad_width / 2 && Math.abs(point.y - pad.y) <= pad.rect_pad_height / 2;
+    }
+    if (pad.shape === "pill_hole_with_rect_pad") {
+      return Math.abs(point.x - pad.x) <= pad.rect_pad_width / 2 && Math.abs(point.y - pad.y) <= pad.rect_pad_height / 2;
+    }
+  }
+  return false;
+}
+
 // lib/check-traces-are-contiguous/check-traces-are-contiguous.ts
-import { getReadableNameForPcbPort as getReadableNameForPcbPort2 } from "@tscircuit/circuit-json-util";
+import {
+  getReadableNameForPcbPort as getReadableNameForPcbPort2,
+  getReadableNameForPcbTrace
+} from "@tscircuit/circuit-json-util";
+function checkTracesAreContiguous(circuitJson) {
+  const errors = [];
+  const pcbPorts = circuitJson.filter(
+    (el) => el.type === "pcb_port"
+  );
+  const pcbTraces = circuitJson.filter(
+    (el) => el.type === "pcb_trace"
+  );
+  const sourceTraces = circuitJson.filter(
+    (el) => el.type === "source_trace"
+  );
+  const pcbSmtPads = circuitJson.filter(
+    (el) => el.type === "pcb_smtpad"
+  );
+  const pcbPlatedHoles = circuitJson.filter(
+    (el) => el.type === "pcb_plated_hole"
+  );
+  const padMap = /* @__PURE__ */ new Map();
+  for (const pad of pcbSmtPads) {
+    if (pad.pcb_port_id) {
+      padMap.set(pad.pcb_port_id, pad);
+    }
+  }
+  for (const hole of pcbPlatedHoles) {
+    if (hole.pcb_port_id) {
+      padMap.set(hole.pcb_port_id, hole);
+    }
+  }
+  for (const trace of pcbTraces) {
+    if (trace.route.length === 0) continue;
+    const firstPoint = trace.route[0];
+    const lastPoint = trace.route[trace.route.length - 1];
+    const sourceTrace = sourceTraces.find(
+      (st) => st.source_trace_id === trace.source_trace_id
+    );
+    const expectedPorts = sourceTrace ? pcbPorts.filter(
+      (port) => sourceTrace.connected_source_port_ids?.includes(port.source_port_id)
+    ) : [];
+    for (let i = 1; i < trace.route.length - 1; i++) {
+      const prevPoint = trace.route[i - 1];
+      const currentPoint = trace.route[i];
+      const nextPoint = trace.route[i + 1];
+      if (currentPoint.route_type === "via") {
+        const prevIsWire = prevPoint.route_type === "wire";
+        const nextIsWire = nextPoint.route_type === "wire";
+        if (prevIsWire && nextIsWire) {
+          const prevAligned = Math.abs(prevPoint.x - currentPoint.x) < 0.01 && Math.abs(prevPoint.y - currentPoint.y) < 0.01;
+          const nextAligned = Math.abs(nextPoint.x - currentPoint.x) < 0.01 && Math.abs(nextPoint.y - currentPoint.y) < 0.01;
+          if (!prevAligned || !nextAligned) {
+            const traceName2 = getReadableNameForPcbTrace(
+              circuitJson,
+              trace.pcb_trace_id
+            );
+            errors.push({
+              type: "pcb_trace_error",
+              message: `Via in trace [${traceName2}] is misaligned at position {x: ${currentPoint.x}, y: ${currentPoint.y}}.`,
+              source_trace_id: sourceTrace?.source_trace_id || trace.source_trace_id || `!${trace.pcb_trace_id}`,
+              error_type: "pcb_trace_error",
+              pcb_trace_id: trace.pcb_trace_id,
+              pcb_trace_error_id: `misaligned_via_${trace.pcb_trace_id}_${i}`,
+              pcb_component_ids: [],
+              pcb_port_ids: []
+            });
+          }
+        }
+      }
+    }
+    const traceName = getReadableNameForPcbTrace(
+      circuitJson,
+      trace.pcb_trace_id
+    );
+    for (const port of expectedPorts) {
+      if (!port.pcb_port_id) continue;
+      const pad = padMap.get(port.pcb_port_id);
+      if (!pad) continue;
+      const isFirstPointConnected = firstPoint.route_type === "wire" && isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad);
+      const isLastPointConnected = lastPoint.route_type === "wire" && isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad);
+      if (!isFirstPointConnected && !isLastPointConnected) {
+        const portName = getReadableNameForPcbPort2(
+          circuitJson,
+          port.pcb_port_id
+        ).replace("pcb_port", "");
+        const padType = pad.type.replace(/pcb_/, "");
+        const errorCenter = {
+          x: (firstPoint.x + lastPoint.x) / 2,
+          y: (firstPoint.y + lastPoint.y) / 2
+        };
+        errors.push({
+          type: "pcb_trace_error",
+          message: `Trace [${traceName}] is missing a connection to ${padType}${portName}`,
+          source_trace_id: sourceTrace?.source_trace_id || trace.source_trace_id || `!${trace.pcb_trace_id}`,
+          error_type: "pcb_trace_error",
+          pcb_trace_id: trace.pcb_trace_id,
+          pcb_trace_error_id: `missing_connection_${trace.pcb_trace_id}_${port.pcb_port_id}`,
+          center: errorCenter,
+          pcb_component_ids: [],
+          pcb_port_ids: [port.pcb_port_id]
+        });
+      }
+    }
+    if (expectedPorts.length === 0) {
+      let firstConnectsToAnyPad = false;
+      let lastConnectsToAnyPad = false;
+      const endpointsAreSame = firstPoint.route_type === "wire" && lastPoint.route_type === "wire" && Math.abs(firstPoint.x - lastPoint.x) < 0.01 && Math.abs(firstPoint.y - lastPoint.y) < 0.01;
+      for (const [portId, pad] of padMap) {
+        if (firstPoint.route_type === "wire" && isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad)) {
+          firstConnectsToAnyPad = true;
+        }
+        if (lastPoint.route_type === "wire" && isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad)) {
+          lastConnectsToAnyPad = true;
+        }
+      }
+      if (!firstConnectsToAnyPad && firstPoint.route_type === "wire") {
+        errors.push({
+          type: "pcb_trace_error",
+          message: `Trace [${traceName}] has disconnected endpoint at (${firstPoint.x.toFixed(2)}, ${firstPoint.y.toFixed(2)})`,
+          source_trace_id: sourceTrace?.source_trace_id || trace.source_trace_id || `!${trace.pcb_trace_id}`,
+          error_type: "pcb_trace_error",
+          pcb_trace_id: trace.pcb_trace_id,
+          pcb_trace_error_id: `disconnected_endpoint_${trace.pcb_trace_id}_start`,
+          center: { x: firstPoint.x, y: firstPoint.y },
+          pcb_component_ids: [],
+          pcb_port_ids: []
+        });
+      }
+      if (!lastConnectsToAnyPad && lastPoint.route_type === "wire" && !(endpointsAreSame && !firstConnectsToAnyPad)) {
+        errors.push({
+          type: "pcb_trace_error",
+          message: `Trace [${traceName}] has disconnected endpoint at (${lastPoint.x.toFixed(2)}, ${lastPoint.y.toFixed(2)})`,
+          source_trace_id: sourceTrace?.source_trace_id || trace.source_trace_id || `!${trace.pcb_trace_id}`,
+          error_type: "pcb_trace_error",
+          pcb_trace_id: trace.pcb_trace_id,
+          pcb_trace_error_id: `disconnected_endpoint_${trace.pcb_trace_id}_end`,
+          center: { x: lastPoint.x, y: lastPoint.y },
+          pcb_component_ids: [],
+          pcb_port_ids: []
+        });
+      }
+    }
+  }
+  return errors;
+}
 
 // lib/run-all-checks.ts
 async function runAllPlacementChecks(circuitJson) {
@@ -2371,7 +2583,7 @@ async function runAllRoutingChecks(circuitJson) {
     ...checkViaTraceClearance(circuitJson),
     ...checkSameNetViaSpacing(circuitJson),
     ...checkDifferentNetViaSpacing(circuitJson),
-    // ...checkTracesAreContiguous(circuitJson),
+    ...checkTracesAreContiguous(circuitJson),
     ...checkPcbTracesOutOfBoard(circuitJson)
   ];
 }