@tscircuit/capacity-autorouter 0.0.41 → 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 = [];
@@ -3567,6 +3650,709 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
   }
 };
 
+// lib/utils/findClosestPointToABCWithinBounds.ts
+function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
+  const avgPoint = {
+    x: (A.x + B.x + C.x) / 3,
+    y: (A.y + B.y + C.y) / 3
+  };
+  const distance6 = (p1, p2) => {
+    return Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2);
+  };
+  const isValidPoint = (point) => {
+    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;
+  };
+  const isOnBoundary = (point) => {
+    const epsilon = 1e-6;
+    return Math.abs(point.x - bounds.minX) < epsilon || Math.abs(point.x - bounds.maxX) < epsilon || Math.abs(point.y - bounds.minY) < epsilon || Math.abs(point.y - bounds.maxY) < epsilon;
+  };
+  if (isValidPoint(avgPoint)) {
+    return avgPoint;
+  }
+  const pointOnCircle = (center, constraint, r) => {
+    const vx = center.x - constraint.x;
+    const vy = center.y - constraint.y;
+    const dist = Math.sqrt(vx * vx + vy * vy);
+    if (dist < 1e-10) {
+      return { x: constraint.x + r, y: constraint.y };
+    }
+    return {
+      x: constraint.x + vx / dist * r,
+      y: constraint.y + vy / dist * r
+    };
+  };
+  const findCircleIntersections = (c1, c2, r) => {
+    const dx = c2.x - c1.x;
+    const dy = c2.y - c1.y;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    if (dist > 2 * r - 1e-10 || dist < 1e-10) {
+      return [];
+    }
+    const a = dist * dist / (2 * dist);
+    const h = Math.sqrt(Math.max(0, r * r - a * a));
+    const midX = c1.x + dx * a / dist;
+    const midY = c1.y + dy * a / dist;
+    const intersection1 = {
+      x: midX + h * dy / dist,
+      y: midY - h * dx / dist
+    };
+    const intersection2 = {
+      x: midX - h * dy / dist,
+      y: midY + h * dx / dist
+    };
+    const result = [];
+    const epsilon = 1e-6;
+    if (Math.abs(distance6(intersection1, c1) - r) < epsilon && Math.abs(distance6(intersection1, c2) - r) < epsilon) {
+      result.push(intersection1);
+    }
+    if (Math.abs(distance6(intersection2, c1) - r) < epsilon && Math.abs(distance6(intersection2, c2) - r) < epsilon) {
+      result.push(intersection2);
+    }
+    return result;
+  };
+  const candidateA = pointOnCircle(avgPoint, A, radius);
+  const candidateB = pointOnCircle(avgPoint, B, radius);
+  const candidateC = pointOnCircle(avgPoint, C, radius);
+  const intersectionsAB = findCircleIntersections(A, B, radius);
+  const intersectionsBC = findCircleIntersections(B, C, radius);
+  const intersectionsCA = findCircleIntersections(C, A, radius);
+  const allCandidates = [
+    candidateA,
+    candidateB,
+    candidateC,
+    ...intersectionsAB,
+    ...intersectionsBC,
+    ...intersectionsCA
+  ];
+  const validCandidates = allCandidates.filter(isValidPoint);
+  if (validCandidates.length > 0) {
+    const interiorCandidates = validCandidates.filter((p) => !isOnBoundary(p));
+    if (interiorCandidates.length > 0) {
+      interiorCandidates.sort(
+        (a, b) => distance6(a, avgPoint) - distance6(b, avgPoint)
+      );
+      return interiorCandidates[0];
+    }
+  }
+  const gridStep = 5;
+  let bestPoint = null;
+  let bestDistance = Infinity;
+  for (let x = bounds.minX + 1; x < bounds.maxX; x += gridStep) {
+    for (let y = bounds.minY + 1; y < bounds.maxY; y += gridStep) {
+      const point = { x, y };
+      if (isValidPoint(point)) {
+        const dist = distance6(point, avgPoint);
+        if (dist < bestDistance) {
+          bestDistance = dist;
+          bestPoint = point;
+        }
+      }
+    }
+  }
+  if (bestPoint !== null) {
+    return bestPoint;
+  }
+  const numSamples = 100;
+  const boundaryPoints = [];
+  for (let i = 0; i <= numSamples; i++) {
+    const t = i / numSamples;
+    boundaryPoints.push({
+      x: bounds.minX + t * (bounds.maxX - bounds.minX),
+      y: bounds.minY
+    });
+    boundaryPoints.push({
+      x: bounds.maxX,
+      y: bounds.minY + t * (bounds.maxY - bounds.minY)
+    });
+    boundaryPoints.push({
+      x: bounds.maxX - t * (bounds.maxX - bounds.minX),
+      y: bounds.maxY
+    });
+    boundaryPoints.push({
+      x: bounds.minX,
+      y: bounds.maxY - t * (bounds.maxY - bounds.minY)
+    });
+  }
+  const validBoundaryPoints = boundaryPoints.filter(isValidPoint);
+  if (validBoundaryPoints.length > 0) {
+    validBoundaryPoints.sort(
+      (a, b) => distance6(a, avgPoint) - distance6(b, avgPoint)
+    );
+    return validBoundaryPoints[0];
+  }
+  let minViolation = Infinity;
+  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 - 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;
+        leastBadPoint = point;
+      }
+    }
+  }
+  return leastBadPoint;
+}
+
+// lib/utils/findPointToGetAroundCircle.ts
+function findPointToGetAroundCircle(A, C, Q) {
+  const B = computeTangentPoint(C, A, Q.center, Q.radius);
+  const D = computeTangentPoint(A, C, Q.center, Q.radius);
+  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) {
+  const CQ = [
+    circleCenter.x - observationPoint.x,
+    circleCenter.y - observationPoint.y
+  ];
+  const CQLength = Math.sqrt(CQ[0] * CQ[0] + CQ[1] * CQ[1]);
+  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,
+    referencePoint.y - observationPoint.y
+  ];
+  const d = Math.sqrt(CQLength * CQLength - radius * radius);
+  const CQUnit = [CQ[0] / CQLength, CQ[1] / CQLength];
+  const perp1 = [-CQUnit[1], CQUnit[0]];
+  const perp2 = [CQUnit[1], -CQUnit[0]];
+  const dot1 = CR[0] * perp1[0] + CR[1] * perp1[1];
+  const dot2 = CR[0] * perp2[0] + CR[1] * perp2[1];
+  const perp = dot1 > dot2 ? perp1 : perp2;
+  const sinTheta = radius / CQLength;
+  const cosTheta = d / CQLength;
+  const unitToTangent = [
+    CQUnit[0] * cosTheta + perp[0] * sinTheta,
+    CQUnit[1] * cosTheta + perp[1] * sinTheta
+  ];
+  return {
+    x: observationPoint.x + d * unitToTangent[0],
+    y: observationPoint.y + d * unitToTangent[1]
+  };
+}
+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)}`
+    );
+  }
+  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
+var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
+  // Input parameters
+  nodeWithPortPoints;
+  routes;
+  // Configuration parameters
+  viaDiameter;
+  traceThickness;
+  obstacleMargin;
+  layerCount = 2;
+  debugViaPositions;
+  // Solution state
+  solvedRoutes = [];
+  // Bounds
+  bounds;
+  constructor(params) {
+    super();
+    this.nodeWithPortPoints = params.nodeWithPortPoints;
+    this.viaDiameter = params?.viaDiameter ?? 0.6;
+    this.traceThickness = params?.traceThickness ?? 0.15;
+    this.obstacleMargin = params?.obstacleMargin ?? 0.1;
+    this.layerCount = params?.layerCount ?? 2;
+    this.debugViaPositions = [];
+    this.routes = this.extractRoutesFromNode();
+    this.bounds = this.calculateBounds();
+    if (this.routes.length !== 2) {
+      this.failed = true;
+      return;
+    }
+    const [routeA, routeB] = this.routes;
+    const routeAHasTransition = routeA.A.z !== routeA.B.z;
+    const routeBHasTransition = routeB.A.z !== routeB.B.z;
+    if (routeAHasTransition && routeBHasTransition || !routeAHasTransition && !routeBHasTransition) {
+      this.failed = true;
+      return;
+    }
+  }
+  /**
+   * Extract routes that need to be connected from the node data
+   */
+  extractRoutesFromNode() {
+    const routes = [];
+    const connectedPorts = this.nodeWithPortPoints.portPoints;
+    const connectionGroups = /* @__PURE__ */ new Map();
+    for (const connectedPort of connectedPorts) {
+      const { connectionName } = connectedPort;
+      if (!connectionGroups.has(connectionName)) {
+        connectionGroups.set(connectionName, []);
+      }
+      connectionGroups.get(connectionName)?.push(connectedPort);
+    }
+    for (const [connectionName, points] of connectionGroups.entries()) {
+      if (points.length === 2) {
+        routes.push({
+          A: { ...points[0], z: points[0].z ?? 0 },
+          B: { ...points[1], z: points[1].z ?? 0 },
+          connectionName
+        });
+      }
+    }
+    return routes;
+  }
+  /**
+   * Calculate the bounding box of the node
+   */
+  calculateBounds() {
+    return {
+      minX: this.nodeWithPortPoints.center.x - this.nodeWithPortPoints.width / 2,
+      maxX: this.nodeWithPortPoints.center.x + this.nodeWithPortPoints.width / 2,
+      minY: this.nodeWithPortPoints.center.y - this.nodeWithPortPoints.height / 2,
+      maxY: this.nodeWithPortPoints.center.y + this.nodeWithPortPoints.height / 2
+    };
+  }
+  /**
+   * Check if two routes are crossing
+   */
+  doRoutesCross(routeA, routeB) {
+    return doSegmentsIntersect(routeA.A, routeA.B, routeB.A, routeB.B);
+  }
+  calculateViaPosition(transitionRoute, flatRoute) {
+    const flatRouteZ = flatRoute.A.z;
+    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(
+      A,
+      B,
+      C,
+      marginFromBorderWithTrace,
+      viaBounds
+    );
+  }
+  /**
+   * Create a single transition route with properly placed via
+   */
+  createTransitionRoute(start, end, via, connectionName) {
+    const route = [
+      { x: start.x, y: start.y, z: start.z ?? 0 },
+      { x: via.x, y: via.y, z: start.z ?? 0 },
+      { x: via.x, y: via.y, z: end.z ?? 0 },
+      { x: end.x, y: end.y, z: end.z ?? 0 }
+    ];
+    return {
+      connectionName,
+      route,
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: [via]
+    };
+  }
+  /**
+   * Create the non-transition route
+   */
+  createFlatRoute(flatStart, flatEnd, via, otherRouteStart, otherRouteEnd, flatRouteConnectionName) {
+    const ntrP1 = otherRouteStart.z !== flatStart.z ? otherRouteStart : otherRouteEnd;
+    const middle = (a, b) => {
+      return {
+        x: (a.x + b.x) / 2,
+        y: (a.y + b.y) / 2
+      };
+    };
+    const middleWithMargin = (a, aMargin, b, bMargin) => {
+      const dx = b.x - a.x;
+      const dy = b.y - a.y;
+      const effectiveA = {
+        x: a.x + dx * aMargin,
+        y: a.y + dy * aMargin
+      };
+      const effectiveB = {
+        x: b.x - dx * bMargin,
+        y: b.y - dy * bMargin
+      };
+      return middle(effectiveA, effectiveB);
+    };
+    const traceBounds = {
+      maxX: this.bounds.maxX - this.obstacleMargin - this.traceThickness / 2,
+      maxY: this.bounds.maxY - this.obstacleMargin - this.traceThickness / 2,
+      minX: this.bounds.minX + this.obstacleMargin + this.traceThickness / 2,
+      minY: this.bounds.minY + this.obstacleMargin + this.traceThickness / 2
+    };
+    const minDistFromViaToTrace = this.viaDiameter / 2 + this.traceThickness / 2 + this.obstacleMargin;
+    const p2 = middleWithMargin(
+      via,
+      this.viaDiameter,
+      otherRouteStart.z !== flatStart.z ? otherRouteStart : otherRouteEnd,
+      this.traceThickness
+    );
+    const p1 = findPointToGetAroundCircle(flatStart, p2, {
+      center: { x: via.x, y: via.y },
+      radius: minDistFromViaToTrace
+    }).E;
+    const p3 = findPointToGetAroundCircle(p2, flatEnd, {
+      center: { x: via.x, y: via.y },
+      radius: minDistFromViaToTrace
+    }).E;
+    const p1IsNeeded = pointToSegmentDistance(via, flatStart, p2) < minDistFromViaToTrace;
+    const p3IsNeeded = pointToSegmentDistance(via, p2, flatEnd) < minDistFromViaToTrace;
+    return {
+      connectionName: flatRouteConnectionName,
+      route: [
+        { x: flatStart.x, y: flatStart.y, z: flatStart.z ?? 0 },
+        ...p1IsNeeded ? [{ x: p1.x, y: p1.y, z: flatStart.z ?? 0 }] : [],
+        { x: p2.x, y: p2.y, z: flatStart.z ?? 0 },
+        ...p3IsNeeded ? [{ x: p3.x, y: p3.y, z: flatStart.z ?? 0 }] : [],
+        { x: flatEnd.x, y: flatEnd.y, z: flatEnd.z ?? 0 }
+      ],
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: []
+    };
+  }
+  /**
+   * Try to solve with one route having a transition and the other staying flat
+   */
+  trySolve() {
+    const [routeA, routeB] = this.routes;
+    const routeAHasTransition = routeA.A.z !== routeA.B.z;
+    const transitionRoute = routeAHasTransition ? routeA : routeB;
+    const flatRoute = routeAHasTransition ? routeB : routeA;
+    const viaPosition = this.calculateViaPosition(transitionRoute, flatRoute);
+    if (viaPosition) {
+      this.debugViaPositions.push({ via: viaPosition });
+    } else {
+      return false;
+    }
+    const transitionRouteSolution = this.createTransitionRoute(
+      transitionRoute.A,
+      transitionRoute.B,
+      viaPosition,
+      transitionRoute.connectionName
+    );
+    const flatRouteSolution = this.createFlatRoute(
+      flatRoute.A,
+      flatRoute.B,
+      viaPosition,
+      transitionRoute.A,
+      transitionRoute.B,
+      flatRoute.connectionName
+    );
+    this.solvedRoutes.push(transitionRouteSolution, flatRouteSolution);
+    return true;
+  }
+  /**
+   * Main step method that attempts to solve the routes
+   */
+  _step() {
+    if (!this.doRoutesCross(this.routes[0], this.routes[1])) {
+      this.failed = true;
+      this.error = "Can only solve routes that have a single transition crossing";
+      return;
+    }
+    if (this.trySolve()) {
+      this.solved = true;
+      return;
+    }
+    this.failed = true;
+  }
+  /**
+   * Visualization for debugging
+   */
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    graphics.rects.push({
+      center: {
+        x: (this.bounds.minX + this.bounds.maxX) / 2,
+        y: (this.bounds.minY + this.bounds.maxY) / 2
+      },
+      width: this.bounds.maxX - this.bounds.minX,
+      height: this.bounds.maxY - this.bounds.minY,
+      stroke: "rgba(0, 0, 0, 0.5)",
+      fill: "rgba(240, 240, 240, 0.1)",
+      label: "PCB Bounds"
+    });
+    for (const route of this.routes) {
+      graphics.points.push({
+        x: route.A.x,
+        y: route.A.y,
+        label: `${route.connectionName} start (z=${route.A.z})`,
+        color: "orange"
+      });
+      graphics.points.push({
+        x: route.B.x,
+        y: route.B.y,
+        label: `${route.connectionName} end (z=${route.B.z})`,
+        color: "orange"
+      });
+      graphics.lines.push({
+        points: [route.A, route.B],
+        strokeColor: "rgba(255, 0, 0, 0.5)",
+        label: `${route.connectionName} direct`
+      });
+    }
+    for (let i = 0; i < this.debugViaPositions.length; i++) {
+      const { via } = this.debugViaPositions[i];
+      graphics.circles.push({
+        center: via,
+        radius: this.viaDiameter / 2,
+        fill: "rgba(255, 165, 0, 0.7)",
+        stroke: "rgba(0, 0, 0, 0.5)",
+        label: `Computed Via (attempt ${i + 1})`
+      });
+      const safetyMargin = this.viaDiameter / 2 + this.obstacleMargin;
+      graphics.circles.push({
+        center: via,
+        radius: safetyMargin,
+        stroke: "rgba(255, 165, 0, 0.7)",
+        fill: "rgba(0, 0, 0, 0)",
+        label: "Safety Margin"
+      });
+    }
+    for (let si = 0; si < this.solvedRoutes.length; si++) {
+      const route = this.solvedRoutes[si];
+      const routeColor = si % 2 === 0 ? "rgba(0, 255, 0, 0.75)" : "rgba(255, 0, 255, 0.75)";
+      for (let i = 0; i < route.route.length - 1; i++) {
+        const pointA = route.route[i];
+        const pointB = route.route[i + 1];
+        graphics.lines.push({
+          points: [pointA, pointB],
+          strokeColor: routeColor,
+          strokeDash: pointA.z !== route.route[0].z ? [0.2, 0.2] : void 0,
+          strokeWidth: route.traceThickness,
+          label: `${route.connectionName} z=${pointA.z}`
+        });
+      }
+      for (const via of route.vias) {
+        graphics.circles.push({
+          center: via,
+          radius: this.viaDiameter / 2,
+          fill: "rgba(0, 0, 255, 0.8)",
+          stroke: "black",
+          label: "Solved Via"
+        });
+        graphics.circles.push({
+          center: via,
+          radius: this.viaDiameter / 2 + this.obstacleMargin,
+          fill: "rgba(0, 0, 255, 0.3)",
+          stroke: "black",
+          label: "Via Margin"
+        });
+      }
+    }
+    return graphics;
+  }
+  /**
+   * Get the solved routes
+   */
+  getSolvedRoutes() {
+    return this.solvedRoutes;
+  }
+};
+
 // lib/solvers/HyperHighDensitySolver/HyperSingleIntraNodeSolver.ts
 var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
   constructorParams;
@@ -3582,7 +4368,7 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
   }
   getCombinationDefs() {
     return [
-      ["closedFormTwoTraceSameLayer"],
+      ["closedFormTwoTrace"],
       ["majorCombinations", "orderings6", "cellSizeFactor"],
       ["noVias"],
       ["orderings50"],
@@ -3673,10 +4459,13 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
         }))
       },
       {
-        name: "closedFormTwoTraceSameLayer",
+        name: "closedFormTwoTrace",
         possibleValues: [
           {
             CLOSED_FORM_TWO_TRACE_SAME_LAYER: true
+          },
+          {
+            CLOSED_FORM_TWO_TRACE_TRANSITION_CROSSING: true
           }
         ]
       }
@@ -3694,6 +4483,11 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
         nodeWithPortPoints: this.nodeWithPortPoints
       });
     }
+    if (hyperParameters.CLOSED_FORM_TWO_TRACE_TRANSITION_CROSSING) {
+      return new SingleTransitionCrossingRouteSolver({
+        nodeWithPortPoints: this.nodeWithPortPoints
+      });
+    }
     return new IntraNodeRouteSolver({
       ...this.constructorParams,
       hyperParameters
@@ -4120,13 +4914,13 @@ function buildMinimumSpanningTree(points) {
       if (point.x === neighbor.x && point.y === neighbor.y) {
         continue;
       }
-      const distance4 = Math.sqrt(
+      const distance6 = Math.sqrt(
         (point.x - neighbor.x) ** 2 + (point.y - neighbor.y) ** 2
       );
       edges.push({
         from: point,
         to: neighbor,
-        weight: distance4
+        weight: distance6
       });
     }
   }
@@ -5387,6 +6181,7 @@ ${isMutable ? "MUTABLE" : "IMMUTABLE"}`,
       for (const connectedPointId of segmentPoint.directlyConnectedSegmentPointIds) {
         if (segmentPointId < connectedPointId) {
           const connectedPoint = modifiedSegmentPoints.get(connectedPointId);
+          if (!connectedPoint) continue;
           const sameLayer = segmentPoint.z === connectedPoint.z;
           const commonLayer = segmentPoint.z;
           let strokeDash;
@@ -5946,11 +6741,11 @@ var CapacityPathingSolver = class extends BaseSolver {
         let closestNode = this.nodes[0];
         let minDistance = Number.MAX_VALUE;
         for (const node of nodesWithTargets) {
-          const distance4 = Math.sqrt(
+          const distance6 = Math.sqrt(
             (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
           );
-          if (distance4 < minDistance) {
-            minDistance = distance4;
+          if (distance6 < minDistance) {
+            minDistance = distance6;
             closestNode = node;
           }
         }
@@ -6542,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;
@@ -6701,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;
@@ -6721,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;
@@ -6741,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;
@@ -6761,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;
@@ -6858,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,
@@ -6998,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 distance3(P, Q1);
+    return distance5(P, Q1);
   }
   const c2 = dotProduct(v, v);
   if (c2 <= c1) {
-    return distance3(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 distance3(P, Pb);
+  return distance5(P, Pb);
 }
 function dotProduct(v1, v2) {
   return v1.x * v2.x + v1.y * v2.y;
 }
-function distance3(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);
@@ -7074,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)}`;
   }
@@ -7083,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) {
@@ -7126,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);
@@ -7146,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)
@@ -7156,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) => {
@@ -7232,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(distance4) {
-    distance4 = Math.max(0, Math.min(distance4, this.totalPathLength));
+  getPointAtDistance(distance6) {
+    distance6 = Math.max(0, Math.min(distance6, this.totalPathLength));
     const segment = this.pathSegments.find(
-      (seg) => distance4 >= seg.startDistance && distance4 <= seg.endDistance
+      (seg) => distance6 >= seg.startDistance && distance6 <= seg.endDistance
     );
     if (!segment) {
       return this.inputRoute.route[this.inputRoute.route.length - 1];
     }
-    const factor = (distance4 - 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),
@@ -7249,17 +8063,17 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     };
   }
   // Find nearest index in the original route for a given distance
-  getNearestIndexForDistance(distance4) {
-    if (distance4 <= 0) return 0;
-    if (distance4 >= 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) => distance4 >= seg.startDistance && distance4 <= 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 distance4 > midDistance ? segmentIndex + 1 : segmentIndex;
+    return distance6 > midDistance ? segmentIndex + 1 : segmentIndex;
   }
   // Check if a path segment is valid
   isValidPathSegment(start, end) {
@@ -7267,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;
       }
     }
@@ -7361,10 +8153,10 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     }
     this.currentStepSize = this.maxStepSize;
   }
-  moveHead(distance4) {
-    this.lastHeadMoveDistance = distance4;
+  moveHead(distance6) {
+    this.lastHeadMoveDistance = distance6;
     this.headDistanceAlongPath = Math.min(
-      this.headDistanceAlongPath + distance4,
+      this.headDistanceAlongPath + distance6,
       this.totalPathLength
     );
   }
@@ -7502,9 +8294,9 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       color: "red",
       label: ["Tentative Head", `z: ${tentativeHead.z}`].join("\n")
     });
-    let distance4 = 0;
-    while (distance4 < this.totalPathLength) {
-      const point = this.getPointAtDistance(distance4);
+    let distance6 = 0;
+    while (distance6 < this.totalPathLength) {
+      const point = this.getPointAtDistance(distance6);
       graphics.circles.push({
         center: {
           x: point.x,
@@ -7513,7 +8305,7 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
         radius: 0.05,
         fill: "rgba(100, 100, 100, 0.5)"
       });
-      distance4 += this.totalPathLength / 20;
+      distance6 += this.totalPathLength / 20;
     }
     if (this.lastValidPath && this.lastValidPath.length > 1) {
       for (let i = 0; i < this.lastValidPath.length - 1; i++) {