@tscircuit/capacity-autorouter 0.0.31 → 0.0.33

package/dist/index.js

@@ -1403,6 +1403,7 @@ var CapacityMeshNodeSolver2_NodeUnderObstacle = class extends CapacityMeshNodeSo
     this.opts = opts;
   }
   VIA_DIAMETER = 0.6;
+  OBSTACLE_MARGIN = 0.1;
   isNodeCompletelyOutsideBounds(node) {
     return node.center.x + node.width / 2 < this.srj.bounds.minX || node.center.x - node.width / 2 > this.srj.bounds.maxX || node.center.y + node.height / 2 < this.srj.bounds.minY || node.center.y - node.height / 2 > this.srj.bounds.maxY;
   }
@@ -1507,7 +1508,7 @@ var CapacityMeshNodeSolver2_NodeUnderObstacle = class extends CapacityMeshNodeSo
     const unfinishedNewNodes = [];
     for (const childNode of childNodes) {
       const shouldBeXYSubdivided = this.shouldNodeBeXYSubdivided(childNode);
-      const shouldBeZSubdivided = childNode.availableZ.length > 1 && !shouldBeXYSubdivided && (childNode._containsObstacle || childNode.width < this.VIA_DIAMETER);
+      const shouldBeZSubdivided = childNode.availableZ.length > 1 && !shouldBeXYSubdivided && (childNode._containsObstacle || childNode.width < this.VIA_DIAMETER + this.OBSTACLE_MARGIN);
       if (shouldBeXYSubdivided) {
         unfinishedNewNodes.push(childNode);
       } else if (!shouldBeXYSubdivided && !childNode._containsObstacle && !shouldBeZSubdivided) {
@@ -2782,6 +2783,687 @@ var HyperParameterSupervisorSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/findCircleLineIntersections.ts
+var findCircleLineIntersections = (circle, line) => {
+  const cx = circle.x;
+  const cy = circle.y;
+  const r = circle.r;
+  const x1 = line.p1.x;
+  const y1 = line.p1.y;
+  const x2 = line.p2.x;
+  const y2 = line.p2.y;
+  if (Math.abs(x2 - x1) < 1e-3) {
+    const x = x1;
+    const a = r * r - (x - cx) ** 2;
+    if (a < 0) return [];
+    if (Math.abs(a) < 1e-3) {
+      const y = cy;
+      if (y >= Math.min(y1, y2) && y <= Math.max(y1, y2)) {
+        return [{ x, y }];
+      }
+      return [];
+    }
+    const y_12 = cy + Math.sqrt(a);
+    const y_22 = cy - Math.sqrt(a);
+    const points2 = [];
+    if (y_12 >= Math.min(y1, y2) && y_12 <= Math.max(y1, y2)) {
+      points2.push({ x, y: y_12 });
+    }
+    if (y_22 >= Math.min(y1, y2) && y_22 <= Math.max(y1, y2)) {
+      points2.push({ x, y: y_22 });
+    }
+    return points2;
+  }
+  const m = (y2 - y1) / (x2 - x1);
+  const b = y1 - m * x1;
+  const A = 1 + m * m;
+  const B = 2 * (m * b - m * cy - cx);
+  const C = cx * cx + (b - cy) * (b - cy) - r * r;
+  const discriminant = B * B - 4 * A * C;
+  if (discriminant < 0) return [];
+  if (Math.abs(discriminant) < 1e-3) {
+    const x = -B / (2 * A);
+    const y = m * x + b;
+    if (x >= Math.min(x1, x2) && x <= Math.max(x1, x2) && y >= Math.min(y1, y2) && y <= Math.max(y1, y2)) {
+      return [{ x, y }];
+    }
+    return [];
+  }
+  const x_1 = (-B + Math.sqrt(discriminant)) / (2 * A);
+  const x_2 = (-B - Math.sqrt(discriminant)) / (2 * A);
+  const y_1 = m * x_1 + b;
+  const y_2 = m * x_2 + b;
+  const points = [];
+  if (x_1 >= Math.min(x1, x2) && x_1 <= Math.max(x1, x2) && y_1 >= Math.min(y1, y2) && y_1 <= Math.max(y1, y2)) {
+    points.push({ x: x_1, y: y_1 });
+  }
+  if (x_2 >= Math.min(x1, x2) && x_2 <= Math.max(x1, x2) && y_2 >= Math.min(y1, y2) && y_2 <= Math.max(y1, y2)) {
+    points.push({ x: x_2, y: y_2 });
+  }
+  return points;
+};
+
+// lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/TwoCrossingRoutesHighDensitySolver.ts
+var TwoCrossingRoutesHighDensitySolver = 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 routeAStartsAndEndsOnSameLayer = routeA.startPort.z === routeA.endPort.z;
+    if (!routeAStartsAndEndsOnSameLayer) {
+      this.failed = true;
+      return;
+    }
+    const routeBStartsAndEndsOnSameLayer = routeB.startPort.z === routeB.endPort.z;
+    if (!routeBStartsAndEndsOnSameLayer) {
+      this.failed = true;
+      return;
+    }
+    const routesAreSameLayer = routeA.startPort.z === routeB.startPort.z;
+    if (!routesAreSameLayer) {
+      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({
+          startPort: { ...points[0], z: points[0].z ?? 0 },
+          endPort: { ...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.startPort,
+      routeA.endPort,
+      routeB.startPort,
+      routeB.endPort
+    );
+  }
+  calculateViaPositions(routeA, routeB) {
+    const outerBox = {
+      width: this.bounds.maxX - this.bounds.minX,
+      height: this.bounds.maxY - this.bounds.minY,
+      x: this.bounds.minX,
+      y: this.bounds.minY
+    };
+    const innerBox = {
+      width: outerBox.width - 2 * this.obstacleMargin - this.viaDiameter,
+      height: outerBox.height - 2 * this.obstacleMargin - this.viaDiameter,
+      x: outerBox.x + this.obstacleMargin + this.viaDiameter / 2,
+      y: outerBox.y + this.obstacleMargin + this.viaDiameter / 2
+    };
+    const K1 = this.viaDiameter + this.obstacleMargin;
+    const pointA = routeB.startPort;
+    const pointB = routeB.endPort;
+    const corners = [
+      { x: innerBox.x, y: innerBox.y },
+      // Top-left (0)
+      { x: innerBox.x + innerBox.width, y: innerBox.y },
+      // Top-right (1)
+      { x: innerBox.x + innerBox.width, y: innerBox.y + innerBox.height },
+      // Bottom-right (2)
+      { x: innerBox.x, y: innerBox.y + innerBox.height }
+      // Bottom-left (3)
+    ];
+    const distanceBetween = (p1, p2) => {
+      return distance(p1, p2);
+    };
+    const candidatePoints = [];
+    corners.forEach((corner, index) => {
+      if (distanceBetween(corner, pointA) >= K1 && distanceBetween(corner, pointB) >= K1) {
+        candidatePoints.push({ ...corner, type: "corner", index });
+      }
+    });
+    const edges = [
+      { p1: corners[0], p2: corners[1] },
+      // top
+      { p1: corners[1], p2: corners[2] },
+      // right
+      { p1: corners[2], p2: corners[3] },
+      // bottom
+      { p1: corners[3], p2: corners[0] }
+      // left
+    ];
+    [pointA, pointB].forEach((circleCenter, circleIndex) => {
+      edges.forEach((edge, edgeIndex) => {
+        const intersections = findCircleLineIntersections(
+          { ...circleCenter, r: K1 },
+          edge
+        );
+        intersections.forEach((point) => {
+          const otherCircle = circleIndex === 0 ? pointB : pointA;
+          if (distanceBetween(point, otherCircle) >= K1) {
+            candidatePoints.push({
+              ...point,
+              type: "intersection",
+              circle: circleIndex,
+              edge: edgeIndex
+            });
+          }
+        });
+      });
+    });
+    if (candidatePoints.length < 2) {
+      const relaxedK1 = K1 * 0.8;
+      corners.forEach((corner, index) => {
+        if (distanceBetween(corner, pointA) >= relaxedK1 && distanceBetween(corner, pointB) >= relaxedK1 && !candidatePoints.some((p) => p.x === corner.x && p.y === corner.y)) {
+          candidatePoints.push({ ...corner, type: "relaxed_corner", index });
+        }
+      });
+      if (candidatePoints.length < 2) {
+        const sortedCorners = [...corners].sort((a, b) => {
+          const aMinDist = Math.min(
+            distanceBetween(a, pointA),
+            distanceBetween(a, pointB)
+          );
+          const bMinDist = Math.min(
+            distanceBetween(b, pointA),
+            distanceBetween(b, pointB)
+          );
+          return bMinDist - aMinDist;
+        });
+        for (const corner of sortedCorners) {
+          if (!candidatePoints.some((p) => p.x === corner.x && p.y === corner.y)) {
+            candidatePoints.push({ ...corner, type: "forced_corner" });
+            if (candidatePoints.length >= 2) break;
+          }
+        }
+      }
+    }
+    if (candidatePoints.length < 2) {
+      return null;
+    }
+    let maxDist = 0;
+    let optimalPair = [
+      candidatePoints[0],
+      candidatePoints[candidatePoints.length > 1 ? 1 : 0]
+    ];
+    for (let i = 0; i < candidatePoints.length; i++) {
+      for (let j = i + 1; j < candidatePoints.length; j++) {
+        const dist = distanceBetween(candidatePoints[i], candidatePoints[j]);
+        if (dist > maxDist) {
+          maxDist = dist;
+          optimalPair = [candidatePoints[i], candidatePoints[j]];
+        }
+      }
+    }
+    let via1 = { x: optimalPair[0].x, y: optimalPair[0].y };
+    let via2 = { x: optimalPair[1].x, y: optimalPair[1].y };
+    const via1DistToStart = distance(via1, routeA.startPort);
+    const via2DistToStart = distance(via2, routeA.startPort);
+    if (via2DistToStart < via1DistToStart) {
+      ;
+      [via1, via2] = [via2, via1];
+    }
+    return {
+      via1,
+      via2
+    };
+  }
+  /**
+   * Create a route with properly placed vias
+   */
+  createRoute(start, end, via1, via2, connectionName) {
+    const middleZ = start.z === 0 ? 1 : 0;
+    const route = [
+      { x: start.x, y: start.y, z: start.z ?? 0 },
+      { x: via1.x, y: via1.y, z: start.z ?? 0 },
+      { x: via1.x, y: via1.y, z: middleZ },
+      // Via transition to layer 1
+      { x: via2.x, y: via2.y, z: middleZ },
+      // Stay on layer 1
+      { x: via2.x, y: via2.y, z: end.z ?? 0 },
+      // Via transition back
+      { x: end.x, y: end.y, z: end.z ?? 0 }
+    ];
+    return {
+      connectionName,
+      route,
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: [via1, via2]
+    };
+  }
+  /**
+   * Try to solve with routeA going over and routeB staying on layer 0
+   */
+  trySolveAOverB(routeA, routeB) {
+    const viaPositions = this.calculateViaPositions(routeA, routeB);
+    if (viaPositions) {
+      this.debugViaPositions.push(viaPositions);
+    } else {
+      return false;
+    }
+    const { via1, via2 } = this.optimizeViaPositions(viaPositions);
+    const routeASolution = this.createRoute(
+      routeA.startPort,
+      routeA.endPort,
+      via1,
+      via2,
+      routeA.connectionName
+    );
+    const midSegmentStart = { x: via1.x, y: via1.y, z: 1 };
+    const midSegmentEnd = { x: via2.x, y: via2.y, z: 1 };
+    const orthogonalPoints = this.calculateShortestOrthogonalRoutePoints(
+      routeB.startPort,
+      routeB.endPort,
+      midSegmentStart,
+      midSegmentEnd,
+      routeA.startPort,
+      routeA.endPort
+    ) ?? this.calculateConservativeOrthogonalRoutePoints(
+      routeB.startPort,
+      routeB.endPort,
+      midSegmentStart,
+      midSegmentEnd,
+      routeA.startPort,
+      routeA.endPort
+    );
+    const routeBSolution = {
+      connectionName: routeB.connectionName,
+      route: orthogonalPoints,
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: []
+    };
+    this.solvedRoutes.push(routeASolution, routeBSolution);
+    return true;
+  }
+  optimizeViaPositions(viaPositions) {
+    const { via1, via2 } = viaPositions;
+    const minRequiredDistance = (this.viaDiameter + this.traceThickness + this.obstacleMargin) * 2;
+    const currentDistance = distance(via1, via2);
+    if (currentDistance <= minRequiredDistance) {
+      return viaPositions;
+    }
+    const dirX = via2.x - via1.x;
+    const dirY = via2.y - via1.y;
+    const dirLength = Math.sqrt(dirX * dirX + dirY * dirY);
+    const normDirX = dirX / dirLength;
+    const normDirY = dirY / dirLength;
+    const midpointX = (via1.x + via2.x) / 2;
+    const midpointY = (via1.y + via2.y) / 2;
+    const moveDistance = (currentDistance - minRequiredDistance) / 2;
+    const newVia1 = {
+      x: via1.x + normDirX * moveDistance,
+      y: via1.y + normDirY * moveDistance
+    };
+    const newVia2 = {
+      x: via2.x - normDirX * moveDistance,
+      y: via2.y - normDirY * moveDistance
+    };
+    return {
+      via1: newVia1,
+      via2: newVia2
+    };
+  }
+  /**
+   * Calculate the orthogonal route points for the second route
+   */
+  calculateConservativeOrthogonalRoutePoints(start, end, via1, via2, otherRouteStart, otherRouteEnd) {
+    const outerBox = {
+      width: this.bounds.maxX - this.bounds.minX,
+      height: this.bounds.maxY - this.bounds.minY,
+      x: this.bounds.minX,
+      y: this.bounds.minY
+    };
+    const innerEdgeBox = {
+      width: outerBox.width - 2 * this.obstacleMargin - this.traceThickness,
+      height: outerBox.height - 2 * this.obstacleMargin - this.traceThickness,
+      x: outerBox.x + this.obstacleMargin + this.traceThickness / 2,
+      y: outerBox.y + this.obstacleMargin + this.traceThickness / 2
+    };
+    const midSegmentDX = via2.x - via1.x;
+    const midSegmentDY = via2.y - via1.y;
+    const orthDX = -midSegmentDY;
+    const orthDY = midSegmentDX;
+    const orthLength = Math.sqrt(orthDX * orthDX + orthDY * orthDY);
+    const normOrthDX = orthDX / orthLength;
+    const normOrthDY = orthDY / orthLength;
+    const midpointX = (via1.x + via2.x) / 2;
+    const midpointY = (via1.y + via2.y) / 2;
+    const calculateIntersections = () => {
+      const intersections2 = [];
+      const leftT = (innerEdgeBox.x - midpointX) / normOrthDX;
+      const leftY = midpointY + leftT * normOrthDY;
+      if (leftY >= innerEdgeBox.y && leftY <= innerEdgeBox.y + innerEdgeBox.height) {
+        intersections2.push({ x: innerEdgeBox.x, y: leftY });
+      }
+      const rightT = (innerEdgeBox.x + innerEdgeBox.width - midpointX) / normOrthDX;
+      const rightY = midpointY + rightT * normOrthDY;
+      if (rightY >= innerEdgeBox.y && rightY <= innerEdgeBox.y + innerEdgeBox.height) {
+        intersections2.push({
+          x: innerEdgeBox.x + innerEdgeBox.width,
+          y: rightY
+        });
+      }
+      const topT = (innerEdgeBox.y - midpointY) / normOrthDY;
+      const topX = midpointX + topT * normOrthDX;
+      if (topX >= innerEdgeBox.x && topX <= innerEdgeBox.x + innerEdgeBox.width) {
+        intersections2.push({ x: topX, y: innerEdgeBox.y });
+      }
+      const bottomT = (innerEdgeBox.y + innerEdgeBox.height - midpointY) / normOrthDY;
+      const bottomX = midpointX + bottomT * normOrthDX;
+      if (bottomX >= innerEdgeBox.x && bottomX <= innerEdgeBox.x + innerEdgeBox.width) {
+        intersections2.push({
+          x: bottomX,
+          y: innerEdgeBox.y + innerEdgeBox.height
+        });
+      }
+      return intersections2;
+    };
+    const intersections = calculateIntersections();
+    if (intersections.length < 2) {
+      return [
+        { x: start.x, y: start.y, z: start.z ?? 0 },
+        { x: end.x, y: end.y, z: end.z ?? 0 }
+      ];
+    }
+    const sortedIntersections = [...intersections].sort((a, b) => {
+      const distA = distance(a, start);
+      const distB = distance(b, start);
+      return distA - distB;
+    });
+    let middlePoint1 = sortedIntersections[0];
+    let middlePoint2 = sortedIntersections[intersections.length - 1];
+    if (doSegmentsIntersect(start, middlePoint1, otherRouteStart, via1) || doSegmentsIntersect(end, middlePoint2, otherRouteEnd, via2)) {
+      ;
+      [middlePoint1, middlePoint2] = [middlePoint2, middlePoint1];
+    }
+    return [
+      { x: start.x, y: start.y, z: start.z ?? 0 },
+      { x: middlePoint1.x, y: middlePoint1.y, z: start.z ?? 0 },
+      { x: middlePoint2.x, y: middlePoint2.y, z: start.z ?? 0 },
+      { x: end.x, y: end.y, z: end.z ?? 0 }
+    ];
+  }
+  calculateShortestOrthogonalRoutePoints(start, end, via1, via2, otherRouteStart, otherRouteEnd) {
+    const midSegmentCenter = {
+      x: (via1.x + via2.x) / 2,
+      y: (via1.y + via2.y) / 2
+    };
+    const midSegmentDirection = {
+      x: via2.x - via1.x,
+      y: via2.y - via1.y
+    };
+    const midSegmentLength = distance(via1, via2);
+    const normOrthDX = midSegmentDirection.y / midSegmentLength;
+    const normOrthDY = midSegmentDirection.x / midSegmentLength;
+    let orthogonalPoint1 = {
+      x: midSegmentCenter.x + midSegmentLength / 2 * normOrthDY,
+      y: midSegmentCenter.y - midSegmentLength / 2 * normOrthDX
+    };
+    let orthogonalPoint2 = {
+      x: midSegmentCenter.x - midSegmentLength / 2 * normOrthDY,
+      y: midSegmentCenter.y + midSegmentLength / 2 * normOrthDX
+    };
+    if (distance(orthogonalPoint2, start) < distance(orthogonalPoint1, start)) {
+      ;
+      [orthogonalPoint1, orthogonalPoint2] = [
+        orthogonalPoint2,
+        orthogonalPoint1
+      ];
+    }
+    if (doSegmentsIntersect(start, orthogonalPoint1, otherRouteStart, via1) || doSegmentsIntersect(end, orthogonalPoint2, otherRouteEnd, via2)) {
+      ;
+      [orthogonalPoint1, orthogonalPoint2] = [
+        orthogonalPoint2,
+        orthogonalPoint1
+      ];
+    }
+    if (doSegmentsIntersect(start, orthogonalPoint2, otherRouteStart, via1) || doSegmentsIntersect(end, orthogonalPoint1, otherRouteEnd, via2)) {
+      return null;
+    }
+    return [
+      { x: start.x, y: start.y, z: start.z ?? 0 },
+      { x: orthogonalPoint1.x, y: orthogonalPoint1.y, z: start.z ?? 0 },
+      { x: orthogonalPoint2.x, y: orthogonalPoint2.y, z: start.z ?? 0 },
+      { x: end.x, y: end.y, z: end.z ?? 0 }
+    ];
+  }
+  /**
+   * Main step method that attempts to solve the two crossing routes
+   */
+  _step() {
+    if (this.routes.length !== 2) {
+      this.failed = true;
+      return;
+    }
+    const [routeA, routeB] = this.routes;
+    if (!this.doRoutesCross(routeA, routeB)) {
+      const routeASolution = {
+        connectionName: routeA.connectionName,
+        route: [
+          {
+            x: routeA.startPort.x,
+            y: routeA.startPort.y,
+            z: routeA.startPort.z ?? 0
+          },
+          {
+            x: routeA.endPort.x,
+            y: routeA.endPort.y,
+            z: routeA.endPort.z ?? 0
+          }
+        ],
+        traceThickness: this.traceThickness,
+        viaDiameter: this.viaDiameter,
+        vias: []
+      };
+      const routeBSolution = {
+        connectionName: routeB.connectionName,
+        route: [
+          {
+            x: routeB.startPort.x,
+            y: routeB.startPort.y,
+            z: routeB.startPort.z ?? 0
+          },
+          {
+            x: routeB.endPort.x,
+            y: routeB.endPort.y,
+            z: routeB.endPort.z ?? 0
+          }
+        ],
+        traceThickness: this.traceThickness,
+        viaDiameter: this.viaDiameter,
+        vias: []
+      };
+      this.solvedRoutes.push(routeASolution, routeBSolution);
+      this.solved = true;
+      return;
+    }
+    if (this.trySolveAOverB(routeA, routeB)) {
+      this.solved = true;
+      return;
+    }
+    if (this.trySolveAOverB(routeB, routeA)) {
+      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.startPort.x,
+        y: route.startPort.y,
+        label: `${route.connectionName} start`,
+        color: "orange"
+      });
+      graphics.points.push({
+        x: route.endPort.x,
+        y: route.endPort.y,
+        label: `${route.connectionName} end`,
+        color: "orange"
+      });
+      graphics.lines.push({
+        points: [route.startPort, route.endPort],
+        strokeColor: "rgba(255, 0, 0, 0.5)",
+        label: `${route.connectionName} direct`
+      });
+    }
+    for (let i = 0; i < this.debugViaPositions.length; i++) {
+      const { via1, via2 } = this.debugViaPositions[i];
+      const colors = ["rgba(255, 165, 0, 0.7)", "rgba(128, 0, 128, 0.7)"];
+      const color = colors[i % colors.length];
+      graphics.circles.push({
+        center: via1,
+        radius: this.viaDiameter / 2,
+        fill: color,
+        stroke: "rgba(0, 0, 0, 0.5)",
+        label: `Computed Via A (attempt ${i + 1})`
+      });
+      graphics.circles.push({
+        center: via2,
+        radius: this.viaDiameter / 2,
+        fill: color,
+        stroke: "rgba(0, 0, 0, 0.5)",
+        label: `Computed Via B (attempt ${i + 1})`
+      });
+      const safetyMargin = this.viaDiameter / 2 + this.obstacleMargin;
+      graphics.circles.push({
+        center: via1,
+        radius: safetyMargin,
+        stroke: color,
+        fill: "rgba(0, 0, 0, 0)",
+        label: "Safety Margin"
+      });
+      graphics.circles.push({
+        center: via2,
+        radius: safetyMargin,
+        stroke: color,
+        fill: "rgba(0, 0, 0, 0)",
+        label: "Safety Margin"
+      });
+      graphics.lines.push({
+        points: [
+          this.routes[i % 2].startPort,
+          via1,
+          via2,
+          this.routes[i % 2].endPort
+        ],
+        strokeColor: `${color.substring(0, color.lastIndexOf(","))}, 0.3)`,
+        strokeDash: [5, 5],
+        label: `Potential Route (attempt ${i + 1})`
+      });
+    }
+    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 === 1 ? [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;
@@ -2797,6 +3479,7 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
   }
   getCombinationDefs() {
     return [
+      ["closedFormTwoTraceSameLayer"],
       ["majorCombinations", "orderings6", "cellSizeFactor"],
       ["noVias"],
       ["orderings50"],
@@ -2885,6 +3568,14 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
         possibleValues: Array.from({ length: 50 }, (_, i) => ({
           SHUFFLE_SEED: 100 + i
         }))
+      },
+      {
+        name: "closedFormTwoTraceSameLayer",
+        possibleValues: [
+          {
+            CLOSED_FORM_TWO_TRACE_SAME_LAYER: true
+          }
+        ]
       }
     ];
   }
@@ -2895,6 +3586,11 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
     return 1 - (solver.progress || 0);
   }
   generateSolver(hyperParameters) {
+    if (hyperParameters.CLOSED_FORM_TWO_TRACE_SAME_LAYER) {
+      return new TwoCrossingRoutesHighDensitySolver({
+        nodeWithPortPoints: this.nodeWithPortPoints
+      });
+    }
     return new IntraNodeRouteSolver({
       ...this.constructorParams,
       hyperParameters
@@ -4462,9 +5158,6 @@ var UnravelSectionSolver = class extends BaseSolver {
       );
       if (!neighbor) continue;
       neighbors.push(neighbor);
-      this.queuedOrExploredCandidatePointModificationHashes.add(
-        neighbor.candidateHash
-      );
     }
     return neighbors;
   }
@@ -6143,13 +6836,13 @@ function minimumDistanceBetweenSegments(A1, A2, B1, B2) {
   if (segmentsIntersect(A1, A2, B1, B2)) {
     return 0;
   }
-  const distA1 = pointToSegmentDistance3(A1, B1, B2);
-  const distA2 = pointToSegmentDistance3(A2, B1, B2);
-  const distB1 = pointToSegmentDistance3(B1, A1, A2);
-  const distB2 = pointToSegmentDistance3(B2, A1, A2);
+  const distA1 = pointToSegmentDistance4(A1, B1, B2);
+  const distA2 = pointToSegmentDistance4(A2, B1, B2);
+  const distB1 = pointToSegmentDistance4(B1, A1, A2);
+  const distB2 = pointToSegmentDistance4(B2, A1, A2);
   return Math.min(distA1, distA2, distB1, distB2);
 }
-function pointToSegmentDistance3(P, Q1, Q2) {
+function pointToSegmentDistance4(P, Q1, Q2) {
   const v = { x: Q2.x - Q1.x, y: Q2.y - Q1.y };
   const w = { x: P.x - Q1.x, y: P.y - Q1.y };
   const c1 = dotProduct(w, v);