@tscircuit/checks 0.0.122 → 0.0.124

package/dist/index.js

@@ -237,7 +237,16 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
 }
 
 // lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import { getReadableNameForElement as getReadableNameForElement2, cju } from "@tscircuit/circuit-json-util";
+import { cju, getReadableNameForElement as getReadableNameForElement2 } from "@tscircuit/circuit-json-util";
+import { getPrimaryId } from "@tscircuit/circuit-json-util";
+import {
+  segmentToBoundsMinDistance,
+  segmentToCircleMinDistance
+} from "@tscircuit/math-utils";
+import { segmentToSegmentMinDistance } from "@tscircuit/math-utils";
+import {
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
+} from "circuit-json-to-connectivity-map";
 
 // lib/data-structures/SpatialIndex.ts
 var SpatialObjectIndex = class {
@@ -338,31 +347,6 @@ var SpatialObjectIndex = class {
   }
 };
 
-// lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
-} from "circuit-json-to-connectivity-map";
-
-// lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
-import { getBoundsOfPcbElements as getBoundsOfPcbElements2 } from "@tscircuit/circuit-json-util";
-var getCollidableBounds = (collidable) => {
-  if (collidable.type === "pcb_trace_segment") {
-    return {
-      minX: Math.min(collidable.x1, collidable.x2),
-      minY: Math.min(collidable.y1, collidable.y2),
-      maxX: Math.max(collidable.x1, collidable.x2),
-      maxY: Math.max(collidable.y1, collidable.y2)
-    };
-  }
-  return getBoundsOfPcbElements2([collidable]);
-};
-
-// lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import {
-  segmentToBoundsMinDistance,
-  segmentToCircleMinDistance
-} from "@tscircuit/math-utils";
-
 // node_modules/@tscircuit/jlcpcb-manufacturing-specs/lib/jlcpcb-manufacturing-specs.ts
 var jlcMinTolerances = {
   min_trace_width: 0.1,
@@ -379,39 +363,131 @@ 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/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
-function getPcbPortIdsConnectedToTrace(trace) {
-  const connectedPcbPorts = /* @__PURE__ */ new Set();
-  for (const segment of trace.route) {
-    if (segment.route_type === "wire") {
-      if (segment.start_pcb_port_id)
-        connectedPcbPorts.add(segment.start_pcb_port_id);
-      if (segment.end_pcb_port_id)
-        connectedPcbPorts.add(segment.end_pcb_port_id);
-    }
+// lib/util/getLayersOfPcbElement.ts
+import { all_layers } from "circuit-json";
+function getLayersOfPcbElement(obj) {
+  if (obj.type === "pcb_trace_segment") {
+    return [obj.layer];
   }
-  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);
-    }
+  if (obj.type === "pcb_smtpad") {
+    return [obj.layer];
   }
-  return Array.from(connectedPorts);
+  if (obj.type === "pcb_plated_hole") {
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
+  }
+  if (obj.type === "pcb_hole") {
+    return [...all_layers];
+  }
+  if (obj.type === "pcb_via") {
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
+  }
+  if (obj.type === "pcb_keepout") {
+    return Array.isArray(obj.layers) ? obj.layers : [];
+  }
+  return [];
 }
 
-// lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import { segmentToSegmentMinDistance } from "@tscircuit/math-utils";
-import { getPrimaryId } from "@tscircuit/circuit-json-util";
+// lib/check-each-pcb-trace-non-overlapping/getClosestPointBetweenSegmentAndBounds.ts
+var getClosestPointBetweenSegmentAndBounds = (segment, bounds) => {
+  const p1 = { x: segment.x1, y: segment.y1 };
+  const p2 = { x: segment.x2, y: segment.y2 };
+  const minX = bounds.minX;
+  const minY = bounds.minY;
+  const maxX = bounds.maxX;
+  const maxY = bounds.maxY;
+  if (p1.x === p2.x && p1.y === p2.y) {
+    const closestX = Math.max(minX, Math.min(maxX, p1.x));
+    const closestY = Math.max(minY, Math.min(maxY, p1.y));
+    if (closestX === p1.x && closestY === p1.y) {
+      return { x: p1.x, y: p1.y };
+    }
+    return { x: closestX, y: closestY };
+  }
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  const tMinX = dx !== 0 ? (minX - p1.x) / dx : Number.NEGATIVE_INFINITY;
+  const tMaxX = dx !== 0 ? (maxX - p1.x) / dx : Number.POSITIVE_INFINITY;
+  const tMinY = dy !== 0 ? (minY - p1.y) / dy : Number.NEGATIVE_INFINITY;
+  const tMaxY = dy !== 0 ? (maxY - p1.y) / dy : Number.POSITIVE_INFINITY;
+  const tEnter = Math.max(Math.min(tMinX, tMaxX), Math.min(tMinY, tMaxY));
+  const tExit = Math.min(Math.max(tMinX, tMaxX), Math.max(tMinY, tMaxY));
+  if (tEnter <= tExit && tExit >= 0 && tEnter <= 1) {
+    const t = Math.max(0, Math.min(1, tEnter));
+    return {
+      x: p1.x + t * dx,
+      y: p1.y + t * dy
+    };
+  }
+  const closestToP1 = {
+    x: Math.max(minX, Math.min(maxX, p1.x)),
+    y: Math.max(minY, Math.min(maxY, p1.y))
+  };
+  const closestToP2 = {
+    x: Math.max(minX, Math.min(maxX, p2.x)),
+    y: Math.max(minY, Math.min(maxY, p2.y))
+  };
+  const distToP1Squared = (closestToP1.x - p1.x) ** 2 + (closestToP1.y - p1.y) ** 2;
+  const distToP2Squared = (closestToP2.x - p2.x) ** 2 + (closestToP2.y - p2.y) ** 2;
+  const edges = [
+    { start: { x: minX, y: minY }, end: { x: maxX, y: minY } },
+    // Bottom edge
+    { start: { x: maxX, y: minY }, end: { x: maxX, y: maxY } },
+    // Right edge
+    { start: { x: maxX, y: maxY }, end: { x: minX, y: maxY } },
+    // Top edge
+    { start: { x: minX, y: maxY }, end: { x: minX, y: minY } }
+    // Left edge
+  ];
+  let minDistance = Math.min(distToP1Squared, distToP2Squared);
+  let closestPoint = distToP1Squared <= distToP2Squared ? closestToP1 : closestToP2;
+  const clamp2 = (value, min, max) => {
+    return Math.max(min, Math.min(max, value));
+  };
+  for (const edge of edges) {
+    const va = { x: p2.x - p1.x, y: p2.y - p1.y };
+    const vb = { x: edge.end.x - edge.start.x, y: edge.end.y - edge.start.y };
+    const w = { x: p1.x - edge.start.x, y: p1.y - edge.start.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 (Math.abs(denominator) < 1e-10) continue;
+    let tA = (dotAB * dotBW - dotBB * dotAW) / denominator;
+    let tB = (dotAA * dotBW - dotAB * dotAW) / denominator;
+    tA = clamp2(tA, 0, 1);
+    tB = clamp2(tB, 0, 1);
+    const closestOnSegment = {
+      x: p1.x + tA * va.x,
+      y: p1.y + tA * va.y
+    };
+    const closestOnEdge = {
+      x: edge.start.x + tB * vb.x,
+      y: edge.start.y + tB * vb.y
+    };
+    const dx2 = closestOnSegment.x - closestOnEdge.x;
+    const dy2 = closestOnSegment.y - closestOnEdge.y;
+    const distSquared = dx2 * dx2 + dy2 * dy2;
+    if (distSquared < minDistance) {
+      minDistance = distSquared;
+      closestPoint = {
+        x: (closestOnSegment.x + closestOnEdge.x) / 2,
+        y: (closestOnSegment.y + closestOnEdge.y) / 2
+      };
+    }
+  }
+  return closestPoint;
+};
 
 // lib/check-each-pcb-trace-non-overlapping/getClosestPointBetweenSegments.ts
 var getClosestPointBetweenSegments = (segmentA, segmentB) => {
@@ -558,6 +634,43 @@ 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 getBoundsOfPcbElements2 } from "@tscircuit/circuit-json-util";
+var getCollidableBounds = (collidable) => {
+  if (collidable.type === "pcb_trace_segment") {
+    return {
+      minX: Math.min(collidable.x1, collidable.x2),
+      minY: Math.min(collidable.y1, collidable.y2),
+      maxX: Math.max(collidable.x1, collidable.x2),
+      maxY: Math.max(collidable.y1, collidable.y2)
+    };
+  }
+  return getBoundsOfPcbElements2([collidable]);
+};
+
+// lib/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
+function getPcbPortIdsConnectedToTrace(trace) {
+  const connectedPcbPorts = /* @__PURE__ */ new Set();
+  for (const segment of trace.route) {
+    if (segment.route_type === "wire") {
+      if (segment.start_pcb_port_id)
+        connectedPcbPorts.add(segment.start_pcb_port_id);
+      if (segment.end_pcb_port_id)
+        connectedPcbPorts.add(segment.end_pcb_port_id);
+    }
+  }
+  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") {
@@ -577,123 +690,6 @@ var getRadiusOfCircuitJsonElement = (obj) => {
   );
 };
 
-// lib/check-each-pcb-trace-non-overlapping/getClosestPointBetweenSegmentAndBounds.ts
-var getClosestPointBetweenSegmentAndBounds = (segment, bounds) => {
-  const p1 = { x: segment.x1, y: segment.y1 };
-  const p2 = { x: segment.x2, y: segment.y2 };
-  const minX = bounds.minX;
-  const minY = bounds.minY;
-  const maxX = bounds.maxX;
-  const maxY = bounds.maxY;
-  if (p1.x === p2.x && p1.y === p2.y) {
-    const closestX = Math.max(minX, Math.min(maxX, p1.x));
-    const closestY = Math.max(minY, Math.min(maxY, p1.y));
-    if (closestX === p1.x && closestY === p1.y) {
-      return { x: p1.x, y: p1.y };
-    }
-    return { x: closestX, y: closestY };
-  }
-  const dx = p2.x - p1.x;
-  const dy = p2.y - p1.y;
-  const tMinX = dx !== 0 ? (minX - p1.x) / dx : Number.NEGATIVE_INFINITY;
-  const tMaxX = dx !== 0 ? (maxX - p1.x) / dx : Number.POSITIVE_INFINITY;
-  const tMinY = dy !== 0 ? (minY - p1.y) / dy : Number.NEGATIVE_INFINITY;
-  const tMaxY = dy !== 0 ? (maxY - p1.y) / dy : Number.POSITIVE_INFINITY;
-  const tEnter = Math.max(Math.min(tMinX, tMaxX), Math.min(tMinY, tMaxY));
-  const tExit = Math.min(Math.max(tMinX, tMaxX), Math.max(tMinY, tMaxY));
-  if (tEnter <= tExit && tExit >= 0 && tEnter <= 1) {
-    const t = Math.max(0, Math.min(1, tEnter));
-    return {
-      x: p1.x + t * dx,
-      y: p1.y + t * dy
-    };
-  }
-  const closestToP1 = {
-    x: Math.max(minX, Math.min(maxX, p1.x)),
-    y: Math.max(minY, Math.min(maxY, p1.y))
-  };
-  const closestToP2 = {
-    x: Math.max(minX, Math.min(maxX, p2.x)),
-    y: Math.max(minY, Math.min(maxY, p2.y))
-  };
-  const distToP1Squared = (closestToP1.x - p1.x) ** 2 + (closestToP1.y - p1.y) ** 2;
-  const distToP2Squared = (closestToP2.x - p2.x) ** 2 + (closestToP2.y - p2.y) ** 2;
-  const edges = [
-    { start: { x: minX, y: minY }, end: { x: maxX, y: minY } },
-    // Bottom edge
-    { start: { x: maxX, y: minY }, end: { x: maxX, y: maxY } },
-    // Right edge
-    { start: { x: maxX, y: maxY }, end: { x: minX, y: maxY } },
-    // Top edge
-    { start: { x: minX, y: maxY }, end: { x: minX, y: minY } }
-    // Left edge
-  ];
-  let minDistance = Math.min(distToP1Squared, distToP2Squared);
-  let closestPoint = distToP1Squared <= distToP2Squared ? closestToP1 : closestToP2;
-  const clamp2 = (value, min, max) => {
-    return Math.max(min, Math.min(max, value));
-  };
-  for (const edge of edges) {
-    const va = { x: p2.x - p1.x, y: p2.y - p1.y };
-    const vb = { x: edge.end.x - edge.start.x, y: edge.end.y - edge.start.y };
-    const w = { x: p1.x - edge.start.x, y: p1.y - edge.start.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 (Math.abs(denominator) < 1e-10) continue;
-    let tA = (dotAB * dotBW - dotBB * dotAW) / denominator;
-    let tB = (dotAA * dotBW - dotAB * dotAW) / denominator;
-    tA = clamp2(tA, 0, 1);
-    tB = clamp2(tB, 0, 1);
-    const closestOnSegment = {
-      x: p1.x + tA * va.x,
-      y: p1.y + tA * va.y
-    };
-    const closestOnEdge = {
-      x: edge.start.x + tB * vb.x,
-      y: edge.start.y + tB * vb.y
-    };
-    const dx2 = closestOnSegment.x - closestOnEdge.x;
-    const dy2 = closestOnSegment.y - closestOnEdge.y;
-    const distSquared = dx2 * dx2 + dy2 * dy2;
-    if (distSquared < minDistance) {
-      minDistance = distSquared;
-      closestPoint = {
-        x: (closestOnSegment.x + closestOnEdge.x) / 2,
-        y: (closestOnSegment.y + closestOnEdge.y) / 2
-      };
-    }
-  }
-  return closestPoint;
-};
-
-// lib/util/getLayersOfPcbElement.ts
-import { all_layers } from "circuit-json";
-function getLayersOfPcbElement(obj) {
-  if (obj.type === "pcb_trace_segment") {
-    return [obj.layer];
-  }
-  if (obj.type === "pcb_smtpad") {
-    return [obj.layer];
-  }
-  if (obj.type === "pcb_plated_hole") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
-  }
-  if (obj.type === "pcb_hole") {
-    return [...all_layers];
-  }
-  if (obj.type === "pcb_via") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
-  }
-  if (obj.type === "pcb_keepout") {
-    return Array.isArray(obj.layers) ? obj.layers : [];
-  }
-  return [];
-}
-
 // lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
 function checkEachPcbTraceNonOverlapping(circuitJson, {
   connMap,
@@ -743,6 +739,12 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
     getBounds: getCollidableBounds
   });
   const getReadableName = (id) => getReadableNameForElement2(circuitJson, id);
+  const constructErrorMessage = (traceName, otherName, gap) => {
+    if (gap < 0) {
+      return `PCB trace ${traceName} overlaps with ${otherName} (accidental contact)`;
+    }
+    return `PCB trace ${traceName} is too close to ${otherName} (gap: ${gap.toFixed(3)}mm)`;
+  };
   const errorIds = /* @__PURE__ */ new Set();
   for (const segmentA of pcbTraceSegments) {
     const requiredMargin = minClearance;
@@ -776,7 +778,11 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         errors.push({
           type: "pcb_trace_error",
           error_type: "pcb_trace_error",
-          message: `PCB trace ${getReadableName(segmentA.pcb_trace_id)} overlaps with ${getReadableName(segmentB.pcb_trace_id)} ${gap2 < 0 ? "(accidental contact)" : `(gap: ${gap2.toFixed(3)}mm)`}`,
+          message: constructErrorMessage(
+            getReadableName(segmentA.pcb_trace_id),
+            getReadableName(segmentB.pcb_trace_id),
+            gap2
+          ),
           pcb_trace_id: segmentA.pcb_trace_id,
           source_trace_id: "",
           pcb_trace_error_id,
@@ -811,7 +817,11 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         errors.push({
           type: "pcb_trace_error",
           error_type: "pcb_trace_error",
-          message: `PCB trace ${getReadableName(segmentA.pcb_trace_id)} overlaps with ${obj.type} "${getReadableName(getPrimaryId(obj))}" ${gap2 < 0 ? "(accidental contact)" : `(gap: ${gap2.toFixed(3)}mm)`}`,
+          message: constructErrorMessage(
+            getReadableName(segmentA.pcb_trace_id),
+            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
+            gap2
+          ),
           pcb_trace_id: segmentA.pcb_trace_id,
           center: getClosestPointBetweenSegmentAndBounds(
             segmentA,
@@ -840,7 +850,11 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         errors.push({
           type: "pcb_trace_error",
           error_type: "pcb_trace_error",
-          message: `PCB trace ${getReadableName(segmentA.pcb_trace_id)} overlaps with ${obj.type} "${getReadableName(getPrimaryId(obj))}" ${gap < 0 ? "(accidental contact)" : `(gap: ${gap.toFixed(3)}mm)`}`,
+          message: constructErrorMessage(
+            getReadableName(segmentA.pcb_trace_id),
+            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
+            gap
+          ),
           pcb_trace_id: segmentA.pcb_trace_id,
           source_trace_id: "",
           pcb_trace_error_id,
@@ -907,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;
@@ -923,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",
@@ -1187,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();
@@ -1200,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;
@@ -1236,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();
@@ -1249,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;
@@ -1402,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 }));
@@ -1427,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();
@@ -1444,7 +1460,7 @@ 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];
@@ -1729,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,
@@ -1795,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,
@@ -1876,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) {