@tscircuit/checks 0.0.124 → 0.0.126

package/dist/index.js

@@ -243,7 +243,7 @@ import {
   segmentToBoundsMinDistance,
   segmentToCircleMinDistance
 } from "@tscircuit/math-utils";
-import { segmentToSegmentMinDistance } from "@tscircuit/math-utils";
+import { segmentToSegmentMinDistance as segmentToSegmentMinDistance2 } from "@tscircuit/math-utils";
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
 } from "circuit-json-to-connectivity-map";
@@ -572,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
@@ -636,6 +636,156 @@ var clamp = (value, min, max) => {
 
 // lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
 import { getBoundsOfPcbElements as getBoundsOfPcbElements2 } from "@tscircuit/circuit-json-util";
+
+// lib/check-each-pcb-trace-non-overlapping/segment-to-polygon-clearance.ts
+import {
+  distSq,
+  getSegmentIntersection,
+  isPointInsidePolygon,
+  pointToSegmentClosestPoint,
+  segmentToSegmentMinDistance
+} from "@tscircuit/math-utils";
+var rotatePoint = (point, angleDegrees) => {
+  const angle = angleDegrees * Math.PI / 180;
+  return {
+    x: point.x * Math.cos(angle) - point.y * Math.sin(angle),
+    y: point.x * Math.sin(angle) + point.y * Math.cos(angle)
+  };
+};
+var getRotatedRectPoints = ({
+  x,
+  y,
+  width,
+  height,
+  ccwRotation
+}) => {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  return [
+    { x: -halfWidth, y: -halfHeight },
+    { x: halfWidth, y: -halfHeight },
+    { x: halfWidth, y: halfHeight },
+    { x: -halfWidth, y: halfHeight }
+  ].map((point) => {
+    const rotated = rotatePoint(point, ccwRotation);
+    return { x: x + rotated.x, y: y + rotated.y };
+  });
+};
+var getPolygonPointsForPad = (pad) => {
+  if (pad.type === "pcb_smtpad") {
+    if (pad.shape === "polygon") return pad.points;
+    if (pad.shape === "rotated_rect") {
+      return getRotatedRectPoints({
+        x: pad.x,
+        y: pad.y,
+        width: pad.width,
+        height: pad.height,
+        ccwRotation: pad.ccw_rotation
+      });
+    }
+  }
+  if (pad.type === "pcb_plated_hole" && "rect_pad_width" in pad && "rect_pad_height" in pad) {
+    return getRotatedRectPoints({
+      x: pad.x,
+      y: pad.y,
+      width: pad.rect_pad_width,
+      height: pad.rect_pad_height,
+      ccwRotation: "rect_ccw_rotation" in pad && typeof pad.rect_ccw_rotation === "number" ? pad.rect_ccw_rotation : 0
+    });
+  }
+  throw new Error(
+    `Expected polygonal pad geometry, got ${pad.type} with shape "${pad.shape}"`
+  );
+};
+var getPolygonEdges = (points) => points.map(
+  (point, index) => [point, points[(index + 1) % points.length]]
+);
+var getClosestPointsBetweenSegments = (a1, a2, b1, b2) => {
+  const intersection = getSegmentIntersection(a1, a2, b1, b2);
+  if (intersection) {
+    return {
+      distance: 0,
+      pointOnA: intersection,
+      pointOnB: intersection,
+      center: intersection
+    };
+  }
+  const candidates = [
+    { pointOnA: a1, pointOnB: pointToSegmentClosestPoint(a1, b1, b2) },
+    { pointOnA: a2, pointOnB: pointToSegmentClosestPoint(a2, b1, b2) },
+    { pointOnA: pointToSegmentClosestPoint(b1, a1, a2), pointOnB: b1 },
+    { pointOnA: pointToSegmentClosestPoint(b2, a1, a2), pointOnB: b2 }
+  ];
+  let best = candidates[0];
+  let bestDistanceSquared = distSq(best.pointOnA, best.pointOnB);
+  for (const candidate of candidates.slice(1)) {
+    const candidateDistanceSquared = distSq(
+      candidate.pointOnA,
+      candidate.pointOnB
+    );
+    if (candidateDistanceSquared < bestDistanceSquared) {
+      best = candidate;
+      bestDistanceSquared = candidateDistanceSquared;
+    }
+  }
+  return {
+    distance: segmentToSegmentMinDistance(a1, a2, b1, b2),
+    pointOnA: best.pointOnA,
+    pointOnB: best.pointOnB,
+    center: {
+      x: (best.pointOnA.x + best.pointOnB.x) / 2,
+      y: (best.pointOnA.y + best.pointOnB.y) / 2
+    }
+  };
+};
+var getSegmentToPolygonClearance = (segment, polygon) => {
+  const start = { x: segment.x1, y: segment.y1 };
+  const end = { x: segment.x2, y: segment.y2 };
+  if (polygon.length < 3) {
+    return { distance: Number.POSITIVE_INFINITY, center: start };
+  }
+  const intersections = getPolygonEdges(polygon).map(
+    ([edgeStart, edgeEnd]) => getSegmentIntersection(start, end, edgeStart, edgeEnd)
+  ).filter((point) => point !== null);
+  if (intersections.length > 0) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const lengthSquared = dx * dx + dy * dy;
+    intersections.sort((a, b) => {
+      const ta = ((a.x - start.x) * dx + (a.y - start.y) * dy) / lengthSquared;
+      const tb = ((b.x - start.x) * dx + (b.y - start.y) * dy) / lengthSquared;
+      return ta - tb;
+    });
+    return { distance: 0, center: intersections[0] };
+  }
+  if (isPointInsidePolygon(start, polygon) || isPointInsidePolygon(end, polygon)) {
+    return {
+      distance: 0,
+      center: {
+        x: (start.x + end.x) / 2,
+        y: (start.y + end.y) / 2
+      }
+    };
+  }
+  let best = getClosestPointsBetweenSegments(
+    start,
+    end,
+    polygon[0],
+    polygon[1]
+  );
+  for (const [edgeStart, edgeEnd] of getPolygonEdges(polygon).slice(1)) {
+    const candidate = getClosestPointsBetweenSegments(
+      start,
+      end,
+      edgeStart,
+      edgeEnd
+    );
+    if (candidate.distance < best.distance) best = candidate;
+  }
+  return { distance: best.distance, center: best.center };
+};
+
+// lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
 var getCollidableBounds = (collidable) => {
   if (collidable.type === "pcb_trace_segment") {
     return {
@@ -645,6 +795,18 @@ var getCollidableBounds = (collidable) => {
       maxY: Math.max(collidable.y1, collidable.y2)
     };
   }
+  if (collidable.type === "pcb_smtpad" || collidable.type === "pcb_plated_hole") {
+    const isPolygon = collidable.type === "pcb_smtpad" && (collidable.shape === "rotated_rect" || collidable.shape === "polygon") || collidable.type === "pcb_plated_hole" && "rect_pad_width" in collidable && "rect_pad_height" in collidable;
+    if (isPolygon) {
+      const polygonPoints = getPolygonPointsForPad(collidable);
+      return {
+        minX: Math.min(...polygonPoints.map((point) => point.x)),
+        minY: Math.min(...polygonPoints.map((point) => point.y)),
+        maxX: Math.max(...polygonPoints.map((point) => point.x)),
+        maxY: Math.max(...polygonPoints.map((point) => point.y))
+      };
+    }
+  }
   return getBoundsOfPcbElements2([collidable]);
 };
 
@@ -763,7 +925,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         if (segmentA.layer !== segmentB.layer) continue;
         if (connMap.areIdsConnected(segmentA.pcb_trace_id, segmentB.pcb_trace_id))
           continue;
-        const gap2 = segmentToSegmentMinDistance(
+        const gap2 = segmentToSegmentMinDistance2(
           { x: segmentA.x1, y: segmentA.y1 },
           { x: segmentA.x2, y: segmentA.y2 },
           { x: segmentB.x1, y: segmentB.y1 },
@@ -804,12 +966,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;
@@ -838,6 +1000,40 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
           ].filter(Boolean)
         });
       }
+      const isPolygon = obj.type === "pcb_smtpad" && (obj.shape === "rotated_rect" || obj.shape === "polygon") || obj.type === "pcb_plated_hole" && "rect_pad_width" in obj && "rect_pad_height" in obj;
+      if (isPolygon) {
+        const padOutline = getPolygonPointsForPad(obj);
+        const { distance: distance4, center } = getSegmentToPolygonClearance(
+          segmentA,
+          padOutline
+        );
+        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;
+        errorIds.add(pcb_trace_error_id);
+        errors.push({
+          type: "pcb_trace_error",
+          error_type: "pcb_trace_error",
+          message: constructErrorMessage(
+            getReadableName(segmentA.pcb_trace_id),
+            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
+            gap2
+          ),
+          pcb_trace_id: segmentA.pcb_trace_id,
+          center,
+          source_trace_id: "",
+          pcb_trace_error_id,
+          pcb_component_ids: [
+            "pcb_component_id" in obj ? obj.pcb_component_id : void 0
+          ].filter(Boolean),
+          pcb_port_ids: [
+            ...getPcbPortIdsConnectedToTraces([segmentA._pcbTrace]),
+            "pcb_port_id" in obj ? obj.pcb_port_id : void 0
+          ].filter(Boolean)
+        });
+        continue;
+      }
       const gap = segmentToBoundsMinDistance(
         { x: segmentA.x1, y: segmentA.y1 },
         { x: segmentA.x2, y: segmentA.y2 },
@@ -1041,11 +1237,11 @@ function computeOverlapDistance(compPoly, boardPoly, componentCenter, componentW
     });
   }
   const matrix = rotateDEG(rotationDeg, componentCenter.x, componentCenter.y);
-  const rotatePoint = (pt) => {
+  const rotatePoint2 = (pt) => {
     const p = applyToPoint(matrix, pt);
     return new Flatten.Point(p.x, p.y);
   };
-  const rotatedPoints = corners.concat(midpoints).map(rotatePoint);
+  const rotatedPoints = corners.concat(midpoints).map(rotatePoint2);
   let maxDistance = 0;
   for (const pt of rotatedPoints) {
     if (!boardPoly.contains(pt)) {
@@ -1420,7 +1616,7 @@ 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";
+import { segmentToSegmentMinDistance as segmentToSegmentMinDistance3 } 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 }));
@@ -1464,14 +1660,14 @@ 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 = segmentToSegmentMinDistance2(
+        const distance4 = segmentToSegmentMinDistance3(
           segmentStart,
           segmentEnd,
           edgeStart,
           edgeEnd
         );
-        if (distance3 < minDistance) {
-          minDistance = distance3;
+        if (distance4 < minDistance) {
+          minDistance = distance4;
         }
       }
       const minimumDistance = traceWidth / 2 + margin;
@@ -2245,7 +2441,7 @@ function checkConnectorAccessibleOrientation(circuitJson) {
 // lib/check-courtyard-overlap/checkCourtyardOverlap.ts
 import {
   doSegmentsIntersect,
-  isPointInsidePolygon
+  isPointInsidePolygon as isPointInsidePolygon2
 } from "@tscircuit/math-utils";
 function getCourtyardPolygon(el) {
   if (el.type === "pcb_courtyard_rect") {
@@ -2291,8 +2487,8 @@ function getComponentName2(circuitJson, pcbComponentId) {
   return pcbComponentId;
 }
 function polygonsOverlap(polyA, polyB) {
-  if (polyA.some((p) => isPointInsidePolygon(p, polyB))) return true;
-  if (polyB.some((p) => isPointInsidePolygon(p, polyA))) return true;
+  if (polyA.some((p) => isPointInsidePolygon2(p, polyB))) return true;
+  if (polyB.some((p) => isPointInsidePolygon2(p, polyA))) return true;
   for (let i = 0; i < polyA.length; i++) {
     const a1 = polyA[i];
     const a2 = polyA[(i + 1) % polyA.length];
@@ -2348,8 +2544,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) {
@@ -2381,7 +2779,7 @@ async function runAllRoutingChecks(circuitJson) {
     ...checkViaTraceClearance(circuitJson),
     ...checkSameNetViaSpacing(circuitJson),
     ...checkDifferentNetViaSpacing(circuitJson),
-    // ...checkTracesAreContiguous(circuitJson),
+    ...checkTracesAreContiguous(circuitJson),
     ...checkPcbTracesOutOfBoard(circuitJson)
   ];
 }