@tscircuit/checks 0.0.184 → 0.0.186

package/dist/index.js

@@ -2705,7 +2705,7 @@ function checkSourceTracesHavePcbTraces(circuitJson) {
 }
 
 // lib/check-traces-are-contiguous/check-traces-are-contiguous.ts
-import { pointToSegmentDistance as pointToSegmentDistance2 } from "@tscircuit/math-utils";
+import { pointToSegmentDistance as pointToSegmentDistance3 } from "@tscircuit/math-utils";
 import {
   getReadableNameForPcbPort as getReadableNameForPcbPort2,
   getReadableNameForPcbTrace
@@ -2714,6 +2714,135 @@ import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7,
   PcbConnectivityMap as PcbConnectivityMap2
 } from "circuit-json-to-connectivity-map";
+
+// lib/check-traces-are-contiguous/via-contact-index.ts
+import {
+  all_layers as all_layers2
+} from "circuit-json";
+import { getPrimaryId as getPrimaryId3 } from "@tscircuit/circuit-json-util";
+import { pointToSegmentDistance as pointToSegmentDistance2 } from "@tscircuit/math-utils";
+var CONTACT_EPSILON = 1e-9;
+function getViaContactIndex(circuitJson, connectivity) {
+  const index = /* @__PURE__ */ new Map();
+  const pads = getPads(circuitJson);
+  const traces = circuitJson.filter((element) => element.type === "pcb_trace");
+  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 stack = [
+    "top",
+    ...innerLayers.slice(
+      0,
+      layerCount === void 0 ? void 0 : Math.max(0, layerCount - 2)
+    ),
+    ...layerCount === 1 ? [] : ["bottom"]
+  ];
+  const add = (id, layers, contact) => {
+    if (![contact.x, contact.y].every(Number.isFinite)) return;
+    const net = connectivity.getNetConnectedToId(id);
+    if (!net) return;
+    const touchesPad = pads.some((pad) => {
+      if (connectivity.getNetConnectedToId(getPrimaryId3(pad)) !== net || !getLayersOfPcbElement(pad).some((layer) => layers.includes(layer)))
+        return false;
+      if (contact.radius === void 0) return isPointInPad(contact, pad);
+      const viaGeometry = {
+        type: "pcb_via",
+        pcb_via_id: id,
+        x: contact.x,
+        y: contact.y,
+        outer_diameter: contact.radius * 2,
+        hole_diameter: 0,
+        layers
+      };
+      return getPadToPadGap(viaGeometry, pad) <= CONTACT_EPSILON;
+    });
+    const touchingTraceIds = /* @__PURE__ */ new Set();
+    for (const trace of traces) {
+      if (trace.route_thickness_mode === "interpolated" || connectivity.getNetConnectedToId(trace.pcb_trace_id) !== net)
+        continue;
+      for (let i = 1; i < trace.route.length; i++) {
+        const a = trace.route[i - 1], b = trace.route[i];
+        if (a.route_type !== "wire" || b.route_type !== "wire" || a.layer !== b.layer || !layers.includes(a.layer) || !Number.isFinite(a.width) || a.width <= 0 || Math.hypot(a.x - b.x, a.y - b.y) <= CONTACT_EPSILON)
+          continue;
+        const reach = contact.radius === void 0 ? 0 : contact.radius + a.width / 2;
+        if (pointToSegmentDistance2(contact, a, b) <= reach + CONTACT_EPSILON) {
+          touchingTraceIds.add(trace.pcb_trace_id);
+          break;
+        }
+      }
+    }
+    const copper = { ...contact, touchesPad, touchingTraceIds };
+    const byLayer = index.get(net) ?? /* @__PURE__ */ new Map();
+    for (const layer of layers) {
+      const contacts = byLayer.get(layer) ?? [];
+      contacts.push(copper);
+      byLayer.set(layer, contacts);
+    }
+    index.set(net, byLayer);
+  };
+  for (const via of vias) {
+    if (!Number.isFinite(via.outer_diameter) || via.outer_diameter <= 0)
+      continue;
+    add(via.pcb_via_id, getLayersOfPcbElement(via), {
+      x: via.x,
+      y: via.y,
+      ownerTraceId: via.pcb_trace_id,
+      radius: via.outer_diameter / 2
+    });
+  }
+  for (const trace of circuitJson) {
+    if (trace.type !== "pcb_trace") continue;
+    for (const point of trace.route) {
+      if (point.route_type !== "via") continue;
+      if (vias.some(
+        (via) => Math.hypot(via.x - point.x, via.y - point.y) <= CONTACT_EPSILON && (via.pcb_trace_id === trace.pcb_trace_id || !via.pcb_trace_id && connectivity.areIdsConnected(
+          via.pcb_via_id,
+          trace.pcb_trace_id
+        ))
+      ))
+        continue;
+      const from = stack.indexOf(point.from_layer);
+      const to = stack.indexOf(point.to_layer);
+      if (from < 0 || to < 0) continue;
+      const diameter = point.outer_diameter;
+      if (diameter !== void 0 && (!Number.isFinite(diameter) || diameter <= 0))
+        continue;
+      add(
+        trace.pcb_trace_id,
+        stack.slice(Math.min(from, to), Math.max(from, to) + 1),
+        {
+          x: point.x,
+          y: point.y,
+          ownerTraceId: trace.pcb_trace_id,
+          radius: diameter === void 0 ? void 0 : diameter / 2
+        }
+      );
+    }
+  }
+  return index;
+}
+function endpointTouchesVia({
+  point,
+  width,
+  ownerTrace,
+  index,
+  connectivity
+}) {
+  if (point.route_type !== "wire" || !Number.isFinite(width) || width <= 0)
+    return false;
+  const net = connectivity.getNetConnectedToId(ownerTrace.pcb_trace_id);
+  if (!net) return false;
+  return (index.get(net)?.get(point.layer) ?? []).some((via) => {
+    if (via.ownerTraceId === ownerTrace.pcb_trace_id) return false;
+    if (!via.touchesPad && ![...via.touchingTraceIds].some((id) => id !== ownerTrace.pcb_trace_id))
+      return false;
+    const contactDistance = via.radius === void 0 ? 0 : via.radius + width / 2;
+    return Math.hypot(point.x - via.x, point.y - via.y) <= contactDistance + CONTACT_EPSILON;
+  });
+}
+
+// lib/check-traces-are-contiguous/check-traces-are-contiguous.ts
 var ENDPOINT_CONTACT_EPSILON = 1e-9;
 var TRACE_SEGMENT_GEOMETRY_EPSILON = 1e-9;
 function routePointTouchesPad(point, pad) {
@@ -2775,7 +2904,7 @@ function routePointTouchesLogicallyConnectedTraceCopper({
   for (const segment of candidateSegments) {
     if (segment.trace.pcb_trace_id === ownerTrace.pcb_trace_id) continue;
     const maximumContactDistance = endpointTraceCopperWidth / 2 + segment.start.width / 2 + ENDPOINT_CONTACT_EPSILON;
-    if (pointToSegmentDistance2(point, segment.start, segment.end) <= maximumContactDistance) {
+    if (pointToSegmentDistance3(point, segment.start, segment.end) <= maximumContactDistance) {
       return true;
     }
   }
@@ -2879,6 +3008,14 @@ function checkTracesAreContiguous(circuitJson) {
     );
     return traceWireSegmentsByNetAndLayer;
   };
+  let viaContactIndex;
+  const getViaIndex = () => {
+    viaContactIndex ??= getViaContactIndex(
+      circuitJson,
+      getFullConnectivityMap()
+    );
+    return viaContactIndex;
+  };
   const checkedSourceTraceIds = /* @__PURE__ */ new Set();
   for (const pad of pcbSmtPads) {
     if (pad.pcb_port_id) {
@@ -3068,8 +3205,20 @@ function checkTracesAreContiguous(circuitJson) {
         traceWireSegmentsByNetAndLayer: getTraceWireSegmentIndex(),
         fullConnectivityMap: getFullConnectivityMap()
       });
-      const firstIsConnected = firstConnectsToAnyPad || firstConnectsToLogicallyConnectedTraceCopper;
-      const lastIsConnected = lastConnectsToAnyPad || lastConnectsToLogicallyConnectedTraceCopper;
+      const firstIsConnected = firstConnectsToAnyPad || firstConnectsToLogicallyConnectedTraceCopper || firstEndpointTraceCopperWidth !== void 0 && endpointTouchesVia({
+        point: firstPoint,
+        width: firstEndpointTraceCopperWidth,
+        ownerTrace: trace,
+        index: getViaIndex(),
+        connectivity: getFullConnectivityMap()
+      });
+      const lastIsConnected = lastConnectsToAnyPad || lastConnectsToLogicallyConnectedTraceCopper || lastEndpointTraceCopperWidth !== void 0 && endpointTouchesVia({
+        point: lastPoint,
+        width: lastEndpointTraceCopperWidth,
+        ownerTrace: trace,
+        index: getViaIndex(),
+        connectivity: getFullConnectivityMap()
+      });
       const endpointsAreSame = firstPoint.route_type === "wire" && lastPoint.route_type === "wire" && firstPoint.layer === lastPoint.layer && Math.hypot(firstPoint.x - lastPoint.x, firstPoint.y - lastPoint.y) <= ENDPOINT_CONTACT_EPSILON;
       if (!firstIsConnected && firstPoint.route_type === "wire") {
         errors.push({
@@ -3185,7 +3334,7 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
 import {
   cju as cju6,
   getBoundsOfPcbElements as getBoundsOfPcbElements5,
-  getPrimaryId as getPrimaryId3
+  getPrimaryId as getPrimaryId4
 } from "@tscircuit/circuit-json-util";
 import { doBoundsOverlap as doBoundsOverlap3 } from "@tscircuit/math-utils";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson8 } from "circuit-json-to-connectivity-map";
@@ -3221,7 +3370,7 @@ var formatOverlapElementDescription = (circuitJson, element) => {
   if ("pcb_port_id" in element && element.pcb_port_id) {
     return getReadableNameForPort(circuitJson, element.pcb_port_id);
   }
-  const id = getPrimaryId3(element);
+  const id = getPrimaryId4(element);
   const readableName = getReadableNameForElementId(circuitJson, id);
   return readableName === "element" ? `[${id}]` : readableName;
 };
@@ -3234,7 +3383,7 @@ function checkPcbComponentOverlap(circuitJson) {
   const courtyards = circuitJson.filter(isCourtyardElement);
   const componentMap = /* @__PURE__ */ new Map();
   for (const pad of smtPads) {
-    const componentId = pad.pcb_component_id || `standalone_pad_${getPrimaryId3(pad)}`;
+    const componentId = pad.pcb_component_id || `standalone_pad_${getPrimaryId4(pad)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
@@ -3244,7 +3393,7 @@ function checkPcbComponentOverlap(circuitJson) {
     componentMap.get(componentId).elements.push(pad);
   }
   for (const hole of platedHoles) {
-    const componentId = hole.pcb_component_id || `standalone_plated_hole_${getPrimaryId3(hole)}`;
+    const componentId = hole.pcb_component_id || `standalone_plated_hole_${getPrimaryId4(hole)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
@@ -3254,7 +3403,7 @@ function checkPcbComponentOverlap(circuitJson) {
     componentMap.get(componentId).elements.push(hole);
   }
   for (const hole of holes) {
-    const componentId = hole.pcb_component_id || `standalone_hole_${getPrimaryId3(hole)}`;
+    const componentId = hole.pcb_component_id || `standalone_hole_${getPrimaryId4(hole)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
@@ -3290,8 +3439,8 @@ function checkPcbComponentOverlap(circuitJson) {
       }
       for (const elem1 of comp1.elements) {
         for (const elem2 of comp2.elements) {
-          const id1 = getPrimaryId3(elem1);
-          const id2 = getPrimaryId3(elem2);
+          const id1 = getPrimaryId4(elem1);
+          const id2 = getPrimaryId4(elem2);
           if ((isCourtyardElement(elem1) || isCourtyardElement(elem2)) && elem1.type !== "pcb_hole" && elem2.type !== "pcb_hole") {
             continue;
           }
@@ -3544,7 +3693,7 @@ var checkPcbTraceViaCounts = (circuitJson) => {
 
 // lib/check-pad-pad-clearance.ts
 import {
-  getPrimaryId as getPrimaryId4,
+  getPrimaryId as getPrimaryId5,
   getReadableNameForElement as getReadableNameForElement6
 } from "@tscircuit/circuit-json-util";
 import { formatMm } from "format-si-unit";
@@ -3563,17 +3712,17 @@ function checkPadPadClearance(circuitJson, {
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: (pad) => getPrimaryId4(pad)
+    getId: (pad) => getPrimaryId5(pad)
   });
   const errors = /* @__PURE__ */ new Map();
   for (const padA of pads) {
-    const padAId = getPrimaryId4(padA);
+    const padAId = getPrimaryId5(padA);
     const nearbyPads = spatialIndex.getObjectsInBounds(
       getPadBounds(padA),
       minClearance
     );
     for (const padB of nearbyPads) {
-      const padBId = getPrimaryId4(padB);
+      const padBId = getPrimaryId5(padB);
       if (padAId === padBId) continue;
       if (!getLayersOfPcbElement(padA).some(
         (layer) => getLayersOfPcbElement(padB).includes(layer)
@@ -3609,7 +3758,7 @@ function checkPadPadClearance(circuitJson, {
 
 // lib/check-pad-trace-clearance.ts
 import {
-  getPrimaryId as getPrimaryId5,
+  getPrimaryId as getPrimaryId6,
   getReadableNameForElement as getReadableNameForElement7
 } from "@tscircuit/circuit-json-util";
 import { formatMm as formatMm2 } from "format-si-unit";
@@ -3629,7 +3778,7 @@ function checkPadTraceClearance(circuitJson, {
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: (pad) => getPrimaryId5(pad)
+    getId: (pad) => getPrimaryId6(pad)
   });
   const errors = /* @__PURE__ */ new Map();
   const overlappingPairIds = /* @__PURE__ */ new Set();
@@ -3639,7 +3788,7 @@ function checkPadTraceClearance(circuitJson, {
       minClearance + segment.thickness / 2
     );
     for (const pad of nearbyPads) {
-      const padId = getPrimaryId5(pad);
+      const padId = getPrimaryId6(pad);
       if (!getLayersOfPcbElement(pad).includes(segment.layer)) continue;
       if (connMap.areIdsConnected(segment.pcb_trace_id, padId)) continue;
       const pairId = `${padId}_${segment.pcb_trace_id}`;
@@ -3725,7 +3874,7 @@ function checkViaTraceClearance(circuitJson, {
 
 // lib/check-via-pad-clearance.ts
 import {
-  getPrimaryId as getPrimaryId6,
+  getPrimaryId as getPrimaryId7,
   getReadableNameForElement as getReadableNameForElement9
 } from "@tscircuit/circuit-json-util";
 import { formatMm as formatMm4 } from "format-si-unit";
@@ -3747,7 +3896,7 @@ function checkViaPadClearance(circuitJson, {
   const padIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: getPrimaryId6
+    getId: getPrimaryId7
   });
   const errors = [];
   for (const via of vias) {
@@ -3756,7 +3905,7 @@ function checkViaPadClearance(circuitJson, {
       requiredClearance
     );
     for (const pad of nearbyPads) {
-      const padId = getPrimaryId6(pad);
+      const padId = getPrimaryId7(pad);
       if (!getLayersOfPcbElement(via).some(
         (layer) => getLayersOfPcbElement(pad).includes(layer)
       )) {
@@ -3786,7 +3935,7 @@ function checkViaPadClearance(circuitJson, {
 }
 
 // lib/check-vias-in-pads.ts
-import { getPrimaryId as getPrimaryId7 } from "@tscircuit/circuit-json-util";
+import { getPrimaryId as getPrimaryId8 } from "@tscircuit/circuit-json-util";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson13 } from "circuit-json-to-connectivity-map";
 function checkViasInPads(circuitJson) {
   const board = getPcbBoard(circuitJson);
@@ -3800,18 +3949,18 @@ function checkViasInPads(circuitJson) {
   if (vias.length === 0 || pads.length === 0) return [];
   const connMap = getFullConnectivityMapFromCircuitJson13(circuitJson);
   const padOrdinals = new Map(
-    pads.map((pad, index) => [getPrimaryId7(pad), index])
+    pads.map((pad, index) => [getPrimaryId8(pad), index])
   );
   const padIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
-    getId: getPrimaryId7
+    getId: getPrimaryId8
   });
   const errors = [];
   for (const via of vias) {
     const nearbyPads = padIndex.getObjectsInBounds(getPadBounds(via));
     for (const pad of nearbyPads) {
-      const padId = getPrimaryId7(pad);
+      const padId = getPrimaryId8(pad);
       const viaLayers = getLayersOfPcbElement(via);
       const padLayers = getLayersOfPcbElement(pad);
       if (!viaLayers.some((layer) => padLayers.includes(layer))) continue;