@tscircuit/capacity-autorouter 0.0.42 → 0.0.43

package/dist/index.js

@@ -68,6 +68,9 @@ var BaseSolver = class {
   }
   _step() {
   }
+  getConstructorParams() {
+    throw new Error("getConstructorParams not implemented");
+  }
   solve() {
     const startTime = Date.now();
     while (!this.solved && !this.failed) {
@@ -1938,6 +1941,86 @@ function distance(p1, p2) {
   return Math.sqrt(dx * dx + dy * dy);
 }
 
+// node_modules/@tscircuit/math-utils/dist/chunk-MHHTZHOJ.js
+function getBoundingBox(box) {
+  const halfWidth = box.width / 2;
+  const halfHeight = box.height / 2;
+  return {
+    minX: box.center.x - halfWidth,
+    maxX: box.center.x + halfWidth,
+    minY: box.center.y - halfHeight,
+    maxY: box.center.y + halfHeight
+  };
+}
+function computeDistanceBetweenBoxes(boxA, boxB) {
+  const a = getBoundingBox(boxA);
+  const b = getBoundingBox(boxB);
+  const dx = Math.max(a.minX - b.maxX, b.minX - a.maxX, 0);
+  const dy = Math.max(a.minY - b.maxY, b.minY - a.maxY, 0);
+  const pointA = { x: 0, y: 0 };
+  const pointB = { x: 0, y: 0 };
+  if (dx === 0 && dy === 0) {
+    return { distance: 0, pointA: boxA.center, pointB: boxB.center };
+  }
+  pointA.x = clamp(boxA.center.x, b.minX, b.maxX);
+  pointA.y = clamp(boxA.center.y, b.minY, b.maxY);
+  pointB.x = clamp(boxB.center.x, a.minX, a.maxX);
+  pointB.y = clamp(boxB.center.y, a.minY, a.maxY);
+  const distance6 = Math.hypot(pointA.x - pointB.x, pointA.y - pointB.y);
+  return { distance: distance6, pointA, pointB };
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// node_modules/@tscircuit/math-utils/dist/chunk-OMVVSGKD.js
+function segmentToBoundsMinDistance(a, b, bounds) {
+  const topLeft = { x: bounds.minX, y: bounds.minY };
+  const topRight = { x: bounds.maxX, y: bounds.minY };
+  const bottomLeft = { x: bounds.minX, y: bounds.maxY };
+  const bottomRight = { x: bounds.maxX, y: bounds.maxY };
+  if (doSegmentsIntersect(a, b, topLeft, topRight) || doSegmentsIntersect(a, b, topRight, bottomRight) || doSegmentsIntersect(a, b, bottomRight, bottomLeft) || doSegmentsIntersect(a, b, bottomLeft, topLeft)) {
+    return 0;
+  }
+  if (a.x >= bounds.minX && a.x <= bounds.maxX && a.y >= bounds.minY && a.y <= bounds.maxY && b.x >= bounds.minX && b.x <= bounds.maxX && b.y >= bounds.minY && b.y <= bounds.maxY) {
+    return 0;
+  }
+  const distances = [
+    pointToSegmentDistance(topLeft, a, b),
+    pointToSegmentDistance(topRight, a, b),
+    pointToSegmentDistance(bottomLeft, a, b),
+    pointToSegmentDistance(bottomRight, a, b)
+  ];
+  if (a.x >= bounds.minX && a.x <= bounds.maxX && a.y >= bounds.minY && a.y <= bounds.maxY) {
+    return 0;
+  }
+  if (b.x >= bounds.minX && b.x <= bounds.maxX && b.y >= bounds.minY && b.y <= bounds.maxY) {
+    return 0;
+  }
+  if (a.x < bounds.minX || a.x > bounds.maxX || a.y < bounds.minY || a.y > bounds.maxY) {
+    const closestX = clamp(a.x, bounds.minX, bounds.maxX);
+    const closestY = clamp(a.y, bounds.minY, bounds.maxY);
+    distances.push(distance(a, { x: closestX, y: closestY }));
+  }
+  if (b.x < bounds.minX || b.x > bounds.maxX || b.y < bounds.minY || b.y > bounds.maxY) {
+    const closestX = clamp(b.x, bounds.minX, bounds.maxX);
+    const closestY = clamp(b.y, bounds.minY, bounds.maxY);
+    distances.push(distance(b, { x: closestX, y: closestY }));
+  }
+  return Math.min(...distances);
+}
+function segmentToBoxMinDistance(a, b, box) {
+  const halfWidth = box.width / 2;
+  const halfHeight = box.height / 2;
+  const bounds = {
+    minX: box.center.x - halfWidth,
+    maxX: box.center.x + halfWidth,
+    minY: box.center.y - halfHeight,
+    maxY: box.center.y + halfHeight
+  };
+  return segmentToBoundsMinDistance(a, b, bounds);
+}
+
 // lib/data-structures/SingleRouteCandidatePriorityQueue.ts
 var SingleRouteCandidatePriorityQueue = class {
   heap = [];
@@ -3573,13 +3656,13 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
     x: (A.x + B.x + C.x) / 3,
     y: (A.y + B.y + C.y) / 3
   };
-  const distance5 = (p1, p2) => {
+  const distance6 = (p1, p2) => {
     return Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2);
   };
   const isValidPoint = (point) => {
-    const distToA = distance5(point, A);
-    const distToB = distance5(point, B);
-    const distToC = distance5(point, C);
+    const distToA = distance6(point, A);
+    const distToB = distance6(point, B);
+    const distToC = distance6(point, C);
     const withinBounds = point.x >= bounds.minX && point.x <= bounds.maxX && point.y >= bounds.minY && point.y <= bounds.maxY;
     return distToA >= radius && distToB >= radius && distToC >= radius && withinBounds;
   };
@@ -3623,10 +3706,10 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
     };
     const result = [];
     const epsilon = 1e-6;
-    if (Math.abs(distance5(intersection1, c1) - r) < epsilon && Math.abs(distance5(intersection1, c2) - r) < epsilon) {
+    if (Math.abs(distance6(intersection1, c1) - r) < epsilon && Math.abs(distance6(intersection1, c2) - r) < epsilon) {
       result.push(intersection1);
     }
-    if (Math.abs(distance5(intersection2, c1) - r) < epsilon && Math.abs(distance5(intersection2, c2) - r) < epsilon) {
+    if (Math.abs(distance6(intersection2, c1) - r) < epsilon && Math.abs(distance6(intersection2, c2) - r) < epsilon) {
       result.push(intersection2);
     }
     return result;
@@ -3650,7 +3733,7 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
     const interiorCandidates = validCandidates.filter((p) => !isOnBoundary(p));
     if (interiorCandidates.length > 0) {
       interiorCandidates.sort(
-        (a, b) => distance5(a, avgPoint) - distance5(b, avgPoint)
+        (a, b) => distance6(a, avgPoint) - distance6(b, avgPoint)
       );
       return interiorCandidates[0];
     }
@@ -3662,7 +3745,7 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
     for (let y = bounds.minY + 1; y < bounds.maxY; y += gridStep) {
       const point = { x, y };
       if (isValidPoint(point)) {
-        const dist = distance5(point, avgPoint);
+        const dist = distance6(point, avgPoint);
         if (dist < bestDistance) {
           bestDistance = dist;
           bestPoint = point;
@@ -3697,7 +3780,7 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
   const validBoundaryPoints = boundaryPoints.filter(isValidPoint);
   if (validBoundaryPoints.length > 0) {
     validBoundaryPoints.sort(
-      (a, b) => distance5(a, avgPoint) - distance5(b, avgPoint)
+      (a, b) => distance6(a, avgPoint) - distance6(b, avgPoint)
     );
     return validBoundaryPoints[0];
   }
@@ -3705,9 +3788,9 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
   let leastBadPoint = { x: bounds.minX, y: bounds.minY };
   for (const point of [...allCandidates, ...boundaryPoints]) {
     if (point.x >= bounds.minX && point.x <= bounds.maxX && point.y >= bounds.minY && point.y <= bounds.maxY) {
-      const violationA = Math.max(0, radius - distance5(point, A));
-      const violationB = Math.max(0, radius - distance5(point, B));
-      const violationC = Math.max(0, radius - distance5(point, C));
+      const violationA = Math.max(0, radius - distance6(point, A));
+      const violationB = Math.max(0, radius - distance6(point, B));
+      const violationC = Math.max(0, radius - distance6(point, C));
       const totalViolation = violationA + violationB + violationC;
       if (totalViolation < minViolation) {
         minViolation = totalViolation;
@@ -3722,12 +3805,62 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
 function findPointToGetAroundCircle(A, C, Q) {
   const B = computeTangentPoint(C, A, Q.center, Q.radius);
   const D = computeTangentPoint(A, C, Q.center, Q.radius);
-  const E = computeIntersection(
-    { x: C.x, y: C.y },
-    { x: B.x, y: B.y },
-    { x: A.x, y: A.y },
-    { x: D.x, y: D.y }
-  );
+  const distBC = distance2(B, C);
+  const distAD = distance2(A, D);
+  const minDistThreshold = 1e-6;
+  const BIsValid = distBC > minDistThreshold;
+  const DIsValid = distAD > minDistThreshold;
+  let E;
+  if (!BIsValid || !DIsValid) {
+    const midAC = {
+      x: (A.x + C.x) / 2,
+      y: (A.y + C.y) / 2
+    };
+    const distFromCenter = distance2(midAC, Q.center);
+    if (distFromCenter < Q.radius * 1.1) {
+      const dirFromCenter = {
+        x: (midAC.x - Q.center.x) / distFromCenter,
+        y: (midAC.y - Q.center.y) / distFromCenter
+      };
+      E = {
+        x: Q.center.x + dirFromCenter.x * Q.radius * 1.2,
+        y: Q.center.y + dirFromCenter.y * Q.radius * 1.2
+      };
+    } else {
+      E = midAC;
+    }
+  } else {
+    E = {
+      x: (B.x + D.x) / 2,
+      y: (B.y + D.y) / 2
+    };
+    const distBE = distance2(B, E);
+    const distDE = distance2(D, E);
+    if (Math.abs(distBE - distDE) > Math.min(distBE, distDE) * 0.5) {
+      const distAB = distance2(A, B);
+      const distCD = distance2(C, D);
+      const totalDist = distAB + distCD;
+      if (totalDist > minDistThreshold) {
+        const weightB = distCD / totalDist;
+        const weightD = distAB / totalDist;
+        E = {
+          x: B.x * weightB + D.x * weightD,
+          y: B.y * weightB + D.y * weightD
+        };
+      }
+    }
+    const distEToCenter = distance2(E, Q.center);
+    if (distEToCenter < Q.radius * 1.05) {
+      const dirFromCenter = {
+        x: (E.x - Q.center.x) / distEToCenter,
+        y: (E.y - Q.center.y) / distEToCenter
+      };
+      E = {
+        x: Q.center.x + dirFromCenter.x * Q.radius * 1.2,
+        y: Q.center.y + dirFromCenter.y * Q.radius * 1.2
+      };
+    }
+  }
   return { B, D, E };
 }
 function computeTangentPoint(observationPoint, referencePoint, circleCenter, radius) {
@@ -3736,8 +3869,29 @@ function computeTangentPoint(observationPoint, referencePoint, circleCenter, rad
     circleCenter.y - observationPoint.y
   ];
   const CQLength = Math.sqrt(CQ[0] * CQ[0] + CQ[1] * CQ[1]);
-  if (CQLength < radius) {
-    return observationPoint;
+  if (CQLength <= radius) {
+    if (CQLength < 1e-8) {
+      const refVec = [
+        referencePoint.x - observationPoint.x,
+        referencePoint.y - observationPoint.y
+      ];
+      const refLength = Math.sqrt(refVec[0] * refVec[0] + refVec[1] * refVec[1]);
+      if (refLength < 1e-8) {
+        return {
+          x: circleCenter.x + radius,
+          y: circleCenter.y
+        };
+      }
+      return {
+        x: circleCenter.x + refVec[0] / refLength * radius,
+        y: circleCenter.y + refVec[1] / refLength * radius
+      };
+    }
+    const CQUnit2 = [CQ[0] / CQLength, CQ[1] / CQLength];
+    return {
+      x: circleCenter.x - CQUnit2[0] * radius,
+      y: circleCenter.y - CQUnit2[1] * radius
+    };
   }
   const CR = [
     referencePoint.x - observationPoint.x,
@@ -3761,23 +3915,108 @@ function computeTangentPoint(observationPoint, referencePoint, circleCenter, rad
     y: observationPoint.y + d * unitToTangent[1]
   };
 }
-function computeIntersection(p1, p2, p3, p4) {
-  const a1 = p2.y - p1.y;
-  const b1 = p1.x - p2.x;
-  const c1 = a1 * p1.x + b1 * p1.y;
-  const a2 = p4.y - p3.y;
-  const b2 = p3.x - p4.x;
-  const c2 = a2 * p3.x + b2 * p3.y;
-  const det = a1 * b2 - a2 * b1;
-  if (Math.abs(det) < 1e-8) {
-    return {
-      x: (p1.x + p3.x) / 2,
-      y: (p1.y + p3.y) / 2
-    };
+function distance2(p1, p2) {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+// lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/calculateSideTraversal.ts
+var EPSILON = 1e-9;
+function calculateSegmentTraversal(startPoint, endPoint, bounds) {
+  const startAngle = pointToAngle(startPoint, bounds);
+  let endAngle = pointToAngle(endPoint, bounds);
+  if (endAngle < startAngle) {
+    endAngle += 2 * Math.PI;
+  }
+  if (Math.abs(endAngle - startAngle) < EPSILON) {
+    return { left: 0, top: 0, right: 0, bottom: 0 };
+  }
+  return calculateSidePercentages(startAngle, endAngle, bounds);
+}
+function calculateTraversalPercentages(A, B, C, bounds) {
+  const percentagesAB = calculateSegmentTraversal(A, B, bounds);
+  const percentagesBC = calculateSegmentTraversal(B, C, bounds);
+  const totalPercentages = {
+    left: Math.min(1, percentagesAB.left + percentagesBC.left),
+    top: Math.min(1, percentagesAB.top + percentagesBC.top),
+    right: Math.min(1, percentagesAB.right + percentagesBC.right),
+    bottom: Math.min(1, percentagesAB.bottom + percentagesBC.bottom)
+  };
+  for (const key in totalPercentages) {
+    if (Math.abs(totalPercentages[key]) < EPSILON) {
+      totalPercentages[key] = 0;
+    }
+  }
+  return totalPercentages;
+}
+function pointToAngle(point, bounds) {
+  const width = bounds.maxX - bounds.minX;
+  const height = bounds.maxY - bounds.minY;
+  if (width < EPSILON && height < EPSILON) return 0;
+  const perimeter = 2 * (width + height);
+  if (perimeter < EPSILON) return 0;
+  let distance6 = 0;
+  if (Math.abs(point.y - bounds.maxY) < EPSILON && point.x >= bounds.minX - EPSILON && point.x <= bounds.maxX + EPSILON) {
+    distance6 = Math.max(0, Math.min(width, point.x - bounds.minX));
+  } else if (Math.abs(point.x - bounds.maxX) < EPSILON && point.y >= bounds.minY - EPSILON && point.y <= bounds.maxY + EPSILON) {
+    distance6 = width + Math.max(0, Math.min(height, bounds.maxY - point.y));
+  } else if (Math.abs(point.y - bounds.minY) < EPSILON && point.x >= bounds.minX - EPSILON && point.x <= bounds.maxX + EPSILON) {
+    distance6 = width + height + Math.max(0, Math.min(width, bounds.maxX - point.x));
+  } else if (Math.abs(point.x - bounds.minX) < EPSILON && point.y >= bounds.minY - EPSILON && point.y <= bounds.maxY + EPSILON) {
+    distance6 = width + height + width + Math.max(0, Math.min(height, point.y - bounds.minY));
+  } else {
+    throw new Error(
+      `Point (${point.x}, ${point.y}) does not lie on the boundary defined by ${JSON.stringify(bounds)}`
+    );
   }
-  const x = (b2 * c1 - b1 * c2) / det;
-  const y = (a1 * c2 - a2 * c1) / det;
-  return { x, y };
+  distance6 = Math.max(0, Math.min(perimeter, distance6));
+  return perimeter > EPSILON ? distance6 / perimeter * (2 * Math.PI) : 0;
+}
+function calculateSidePercentages(startAngle, endAngle, bounds) {
+  const width = bounds.maxX - bounds.minX;
+  const height = bounds.maxY - bounds.minY;
+  if (width < EPSILON && height < EPSILON)
+    return { left: 0, top: 0, right: 0, bottom: 0 };
+  const perimeter = 2 * (width + height);
+  if (perimeter < EPSILON) return { left: 0, top: 0, right: 0, bottom: 0 };
+  const angleTopEnd = width / perimeter * (2 * Math.PI);
+  const angleRightEnd = (width + height) / perimeter * (2 * Math.PI);
+  const angleBottomEnd = (width + width + height) / perimeter * (2 * Math.PI);
+  const angleLeftEnd = 2 * Math.PI;
+  const sides = [
+    { name: "top", start: 0, end: angleTopEnd, length: width },
+    { name: "right", start: angleTopEnd, end: angleRightEnd, length: height },
+    {
+      name: "bottom",
+      start: angleRightEnd,
+      end: angleBottomEnd,
+      length: width
+    },
+    { name: "left", start: angleBottomEnd, end: angleLeftEnd, length: height }
+    // Ends at 2PI
+  ];
+  const result = { left: 0, top: 0, right: 0, bottom: 0 };
+  const totalAngleTraversal = endAngle - startAngle;
+  if (totalAngleTraversal < EPSILON) return result;
+  for (const side of sides) {
+    const sideAngleRange = side.end - side.start;
+    if (sideAngleRange < EPSILON || side.length < EPSILON) continue;
+    const overlapStart = Math.max(startAngle, side.start);
+    const overlapEnd = Math.min(endAngle, side.end);
+    if (overlapStart < overlapEnd - EPSILON) {
+      const traversedAngleOnSide = overlapEnd - overlapStart;
+      const percentage = traversedAngleOnSide / sideAngleRange;
+      result[side.name] += Math.max(0, percentage);
+    }
+  }
+  for (const key in result) {
+    result[key] = Math.max(
+      0,
+      Math.min(1, result[key])
+    );
+  }
+  return result;
 }
 
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/SingleTransitionCrossingRouteSolver.ts
@@ -3864,17 +4103,30 @@ var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
     const ntrP1 = transitionRoute.A.z !== flatRouteZ ? transitionRoute.A : transitionRoute.B;
     const marginFromBorderWithTrace = this.obstacleMargin * 2 + this.viaDiameter / 2 + this.traceThickness;
     const marginFromBorderWithoutTrace = this.obstacleMargin + this.viaDiameter / 2;
+    const A = flatRoute.A;
+    const B = ntrP1;
+    const C = flatRoute.B;
+    const sideTraversal = calculateTraversalPercentages(A, B, C, this.bounds);
+    const viaBounds = {
+      minX: this.bounds.minX + (sideTraversal.left > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
+      minY: this.bounds.minY + (sideTraversal.bottom > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
+      maxX: this.bounds.maxX - (sideTraversal.right > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
+      maxY: this.bounds.maxY - (sideTraversal.top > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace)
+    };
+    if (viaBounds.maxY < viaBounds.minY) {
+      viaBounds.minY = (viaBounds.minY + viaBounds.maxY) / 2;
+      viaBounds.maxY = viaBounds.minY;
+    }
+    if (viaBounds.maxX < viaBounds.minX) {
+      viaBounds.minX = (viaBounds.minX + viaBounds.maxX) / 2;
+      viaBounds.maxX = viaBounds.minX;
+    }
     return findClosestPointToABCWithinBounds(
-      flatRoute.A,
-      flatRoute.B,
-      ntrP1,
+      A,
+      B,
+      C,
       marginFromBorderWithTrace,
-      {
-        minX: this.bounds.minX + marginFromBorderWithoutTrace,
-        minY: this.bounds.minY + marginFromBorderWithoutTrace,
-        maxX: this.bounds.maxX - marginFromBorderWithTrace,
-        maxY: this.bounds.maxY - marginFromBorderWithTrace
-      }
+      viaBounds
     );
   }
   /**
@@ -4662,13 +4914,13 @@ function buildMinimumSpanningTree(points) {
       if (point.x === neighbor.x && point.y === neighbor.y) {
         continue;
       }
-      const distance5 = Math.sqrt(
+      const distance6 = Math.sqrt(
         (point.x - neighbor.x) ** 2 + (point.y - neighbor.y) ** 2
       );
       edges.push({
         from: point,
         to: neighbor,
-        weight: distance5
+        weight: distance6
       });
     }
   }
@@ -6489,11 +6741,11 @@ var CapacityPathingSolver = class extends BaseSolver {
         let closestNode = this.nodes[0];
         let minDistance = Number.MAX_VALUE;
         for (const node of nodesWithTargets) {
-          const distance5 = Math.sqrt(
+          const distance6 = Math.sqrt(
             (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
           );
-          if (distance5 < minDistance) {
-            minDistance = distance5;
+          if (distance6 < minDistance) {
+            minDistance = distance6;
             closestNode = node;
           }
         }
@@ -7085,7 +7337,7 @@ var CapacityNodeTree = class {
 };
 
 // lib/solvers/SingleLayerNodeMerger/SingleLayerNodeMergerSolver.ts
-var EPSILON = 5e-3;
+var EPSILON2 = 5e-3;
 var SingleLayerNodeMergerSolver = class extends BaseSolver {
   nodeMap;
   currentBatchNodeIds;
@@ -7244,7 +7496,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToLeft.reduce((acc, adjNode) => {
           return acc + adjNode.height;
         }, 0) - rootNode.height
-      ) < EPSILON;
+      ) < EPSILON2;
       if (leftAdjNodesTakeUpEntireHeight && leftAdjNodesAreAllSameSize) {
         rootNode.width += leftAdjNodeWidth;
         rootNode.center.x = rootNode.center.x - leftAdjNodeWidth / 2;
@@ -7264,7 +7516,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToRight.reduce((acc, adjNode) => {
           return acc + adjNode.height;
         }, 0) - rootNode.height
-      ) < EPSILON;
+      ) < EPSILON2;
       if (rightAdjNodesTakeUpEntireHeight && rightAdjNodesAreAllSameSize) {
         rootNode.width += rightAdjNodeWidth;
         rootNode.center.x = rootNode.center.x + rightAdjNodeWidth / 2;
@@ -7284,7 +7536,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToTop.reduce((acc, adjNode) => {
           return acc + adjNode.width;
         }, 0) - rootNode.width
-      ) < EPSILON;
+      ) < EPSILON2;
       if (topAdjNodesTakeUpEntireWidth && topAdjNodesAreAllSameSize) {
         rootNode.height += topAdjNodeHeight;
         rootNode.center.y = rootNode.center.y + topAdjNodeHeight / 2;
@@ -7304,7 +7556,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToBottom.reduce((acc, adjNode) => {
           return acc + adjNode.width;
         }, 0) - rootNode.width
-      ) < EPSILON;
+      ) < EPSILON2;
       if (bottomAdjNodesTakeUpEntireWidth && bottomAdjNodesAreAllSameSize) {
         rootNode.height += bottomAdjNodeHeight;
         rootNode.center.y = rootNode.center.y - bottomAdjNodeHeight / 2;
@@ -7401,6 +7653,15 @@ var SingleSimplifiedPathSolver = class extends BaseSolver {
     this.newRoute = [this.inputRoute.route[0]];
     this.newVias = [];
   }
+  getConstructorParams() {
+    return {
+      inputRoute: this.inputRoute,
+      otherHdRoutes: this.otherHdRoutes,
+      obstacles: this.obstacles,
+      connMap: this.connMap.netMap,
+      colorMap: this.colorMap
+    };
+  }
   get simplifiedRoute() {
     return {
       connectionName: this.inputRoute.connectionName,
@@ -7541,23 +7802,23 @@ function pointToSegmentDistance4(P, Q1, Q2) {
   const w = { x: P.x - Q1.x, y: P.y - Q1.y };
   const c1 = dotProduct(w, v);
   if (c1 <= 0) {
-    return distance4(P, Q1);
+    return distance5(P, Q1);
   }
   const c2 = dotProduct(v, v);
   if (c2 <= c1) {
-    return distance4(P, Q2);
+    return distance5(P, Q2);
   }
   const b = c1 / c2;
   const Pb = {
     x: Q1.x + b * v.x,
     y: Q1.y + b * v.y
   };
-  return distance4(P, Pb);
+  return distance5(P, Pb);
 }
 function dotProduct(v1, v2) {
   return v1.x * v2.x + v1.y * v2.y;
 }
-function distance4(p1, p2) {
+function distance5(p1, p2) {
   const dx = p2.x - p1.x;
   const dy = p2.y - p1.y;
   return Math.sqrt(dx * dx + dy * dy);
@@ -7617,6 +7878,7 @@ var SegmentTree = class {
   }
   buckets;
   CELL_SIZE = 0.4;
+  SEGMENT_MARGIN = 0.2;
   getBucketKey(x, y) {
     return `${Math.floor(x / this.CELL_SIZE)}x${Math.floor(y / this.CELL_SIZE)}`;
   }
@@ -7626,10 +7888,10 @@ var SegmentTree = class {
   getSegmentsThatCouldIntersect(A, B) {
     const segments = [];
     const alreadyAddedSegments = /* @__PURE__ */ new Set();
-    const minX = Math.min(A.x, B.x);
-    const minY = Math.min(A.y, B.y);
-    const maxX = Math.max(A.x, B.x);
-    const maxY = Math.max(A.y, B.y);
+    const minX = Math.min(A.x, B.x) - this.SEGMENT_MARGIN;
+    const minY = Math.min(A.y, B.y) - this.SEGMENT_MARGIN;
+    const maxX = Math.max(A.x, B.x) + this.SEGMENT_MARGIN;
+    const maxY = Math.max(A.y, B.y) + this.SEGMENT_MARGIN;
     const bucketMinX = Math.floor(minX / this.CELL_SIZE) * this.CELL_SIZE;
     const bucketMinY = Math.floor(minY / this.CELL_SIZE) * this.CELL_SIZE;
     for (let x = bucketMinX; x <= maxX; x += this.CELL_SIZE) {
@@ -7669,7 +7931,8 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
   filteredObstaclePathSegments = [];
   filteredVias = [];
   segmentTree;
-  OBSTACLE_MARGIN = 0.15;
+  OBSTACLE_MARGIN = 0.1;
+  TRACE_THICKNESS = 0.15;
   TAIL_JUMP_RATIO = 0.8;
   constructor(params) {
     super(params);
@@ -7689,6 +7952,14 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       },
       { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity }
     );
+    const boundsBox = {
+      center: {
+        x: (bounds.minX + bounds.maxX) / 2,
+        y: (bounds.minY + bounds.maxY) / 2
+      },
+      width: bounds.maxX - bounds.minX,
+      height: bounds.maxY - bounds.minY
+    };
     this.filteredObstacles = this.obstacles.filter(
       (obstacle) => !obstacle.connectedTo.some(
         (id) => this.connMap.areIdsConnected(this.inputRoute.connectionName, id)
@@ -7699,11 +7970,11 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       )) {
         return false;
       }
-      const obstacleMinX = obstacle.center.x - obstacle.width / 2 - this.OBSTACLE_MARGIN;
-      const obstacleMaxX = obstacle.center.x + obstacle.width / 2 + this.OBSTACLE_MARGIN;
-      const obstacleMinY = obstacle.center.y - obstacle.height / 2 - this.OBSTACLE_MARGIN;
-      const obstacleMaxY = obstacle.center.y + obstacle.height / 2 + this.OBSTACLE_MARGIN;
-      return obstacleMinX <= bounds.maxX && obstacleMaxX >= bounds.minX && obstacleMinY <= bounds.maxY && obstacleMaxY >= bounds.minY;
+      const { distance: distance6 } = computeDistanceBetweenBoxes(boundsBox, obstacle);
+      if (distance6 < this.OBSTACLE_MARGIN + 0.5) {
+        return true;
+      }
+      return false;
     });
     this.filteredObstaclePathSegments = this.otherHdRoutes.flatMap(
       (hdRoute) => {
@@ -7775,15 +8046,15 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     return p1.x === p2.x && p1.y === p2.y && p1.z === p2.z;
   }
   // Get point at a specific distance along the path
-  getPointAtDistance(distance5) {
-    distance5 = Math.max(0, Math.min(distance5, this.totalPathLength));
+  getPointAtDistance(distance6) {
+    distance6 = Math.max(0, Math.min(distance6, this.totalPathLength));
     const segment = this.pathSegments.find(
-      (seg) => distance5 >= seg.startDistance && distance5 <= seg.endDistance
+      (seg) => distance6 >= seg.startDistance && distance6 <= seg.endDistance
     );
     if (!segment) {
       return this.inputRoute.route[this.inputRoute.route.length - 1];
     }
-    const factor = (distance5 - segment.startDistance) / segment.length;
+    const factor = (distance6 - segment.startDistance) / segment.length;
     return {
       x: segment.start.x + factor * (segment.end.x - segment.start.x),
       y: segment.start.y + factor * (segment.end.y - segment.start.y),
@@ -7792,17 +8063,17 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     };
   }
   // Find nearest index in the original route for a given distance
-  getNearestIndexForDistance(distance5) {
-    if (distance5 <= 0) return 0;
-    if (distance5 >= this.totalPathLength)
+  getNearestIndexForDistance(distance6) {
+    if (distance6 <= 0) return 0;
+    if (distance6 >= this.totalPathLength)
       return this.inputRoute.route.length - 1;
     const segmentIndex = this.pathSegments.findIndex(
-      (seg) => distance5 >= seg.startDistance && distance5 <= seg.endDistance
+      (seg) => distance6 >= seg.startDistance && distance6 <= seg.endDistance
     );
     if (segmentIndex === -1) return 0;
     const segment = this.pathSegments[segmentIndex];
     const midDistance = (segment.startDistance + segment.endDistance) / 2;
-    return distance5 > midDistance ? segmentIndex + 1 : segmentIndex;
+    return distance6 > midDistance ? segmentIndex + 1 : segmentIndex;
   }
   // Check if a path segment is valid
   isValidPathSegment(start, end) {
@@ -7810,49 +8081,27 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       if (!obstacle.zLayers?.includes(start.z)) {
         continue;
       }
-      const obstacleLeft = obstacle.center.x - obstacle.width / 2 - this.OBSTACLE_MARGIN;
-      const obstacleRight = obstacle.center.x + obstacle.width / 2 + this.OBSTACLE_MARGIN;
-      const obstacleTop = obstacle.center.y - obstacle.height / 2 - this.OBSTACLE_MARGIN;
-      const obstacleBottom = obstacle.center.y + obstacle.height / 2 + this.OBSTACLE_MARGIN;
-      if (doSegmentsIntersect(
-        { x: start.x, y: start.y },
-        { x: end.x, y: end.y },
-        { x: obstacleLeft, y: obstacleTop },
-        { x: obstacleRight, y: obstacleTop }
-      ) || doSegmentsIntersect(
-        { x: start.x, y: start.y },
-        { x: end.x, y: end.y },
-        { x: obstacleRight, y: obstacleTop },
-        { x: obstacleRight, y: obstacleBottom }
-      ) || doSegmentsIntersect(
-        { x: start.x, y: start.y },
-        { x: end.x, y: end.y },
-        { x: obstacleRight, y: obstacleBottom },
-        { x: obstacleLeft, y: obstacleBottom }
-      ) || doSegmentsIntersect(
-        { x: start.x, y: start.y },
-        { x: end.x, y: end.y },
-        { x: obstacleLeft, y: obstacleBottom },
-        { x: obstacleLeft, y: obstacleTop }
-      )) {
+      const distToObstacle = segmentToBoxMinDistance(start, end, obstacle);
+      if (distToObstacle < this.OBSTACLE_MARGIN + this.TRACE_THICKNESS / 2) {
         return false;
       }
     }
     const segmentsThatCouldIntersect = this.segmentTree.getSegmentsThatCouldIntersect(start, end);
-    for (const [otherSegA, otherSegB] of segmentsThatCouldIntersect) {
+    for (const [otherSegA, otherSegB, segId] of segmentsThatCouldIntersect) {
       if (otherSegA.z === start.z && otherSegB.z === start.z) {
-        if (minimumDistanceBetweenSegments(
+        const distBetweenSegments = minimumDistanceBetweenSegments(
           { x: start.x, y: start.y },
           { x: end.x, y: end.y },
           { x: otherSegA.x, y: otherSegA.y },
           { x: otherSegB.x, y: otherSegB.y }
-        ) < this.OBSTACLE_MARGIN) {
+        );
+        if (distBetweenSegments < this.OBSTACLE_MARGIN + this.TRACE_THICKNESS) {
           return false;
         }
       }
     }
     for (const via of this.filteredVias) {
-      if (pointToSegmentDistance(via, start, end) < this.OBSTACLE_MARGIN + via.diameter / 2) {
+      if (pointToSegmentDistance(via, start, end) < this.OBSTACLE_MARGIN + via.diameter / 2 + this.TRACE_THICKNESS / 2) {
         return false;
       }
     }
@@ -7904,10 +8153,10 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     }
     this.currentStepSize = this.maxStepSize;
   }
-  moveHead(distance5) {
-    this.lastHeadMoveDistance = distance5;
+  moveHead(distance6) {
+    this.lastHeadMoveDistance = distance6;
     this.headDistanceAlongPath = Math.min(
-      this.headDistanceAlongPath + distance5,
+      this.headDistanceAlongPath + distance6,
       this.totalPathLength
     );
   }
@@ -8045,9 +8294,9 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       color: "red",
       label: ["Tentative Head", `z: ${tentativeHead.z}`].join("\n")
     });
-    let distance5 = 0;
-    while (distance5 < this.totalPathLength) {
-      const point = this.getPointAtDistance(distance5);
+    let distance6 = 0;
+    while (distance6 < this.totalPathLength) {
+      const point = this.getPointAtDistance(distance6);
       graphics.circles.push({
         center: {
           x: point.x,
@@ -8056,7 +8305,7 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
         radius: 0.05,
         fill: "rgba(100, 100, 100, 0.5)"
       });
-      distance5 += this.totalPathLength / 20;
+      distance6 += this.totalPathLength / 20;
     }
     if (this.lastValidPath && this.lastValidPath.length > 1) {
       for (let i = 0; i < this.lastValidPath.length - 1; i++) {