     }
     
     TKRegionManager.shared.requireRegions { [weak self] result in
-      guard let self = self else { return }
-
-      if case .failure(let error) = result {
-        return self.handleError(error, callbackQueue: callbackQueue, completion: completion)
-      }
-      
-      // we are guaranteed to have regions
-      guard let region = TKRegionManager.shared.localRegions(start: request.from.coordinate, end: request.to.coordinate).first else {
-        return self.handleError(
-          NSError(code: 1001, // matches server
-                  message: Loc.RoutingBetweenTheseLocationsIsNotYetSupported),
-          callbackQueue: callbackQueue,
-          completion: completion)
-      }
-      
-      let paras = Self.requestParameters(
-        for: request,
-        modeIdentifiers: self.modeIdentifiers,
-        additional: additional,
-        bestOnly: bestOnly
-      )
-      
-      let server = self.server ?? .shared
-      server.hit(TKAPI.RoutingResponse.self,
-                 path: "routing.json",
-                 parameters: paras,
-                 region: region,
-                 callbackOnMain: false
-      ) { [weak self] _, _, result in
+      request.perform { [weak self] _ in
         guard let self = self else { return }
-        switch result {
-        case .success(let response):
-          if let context = request.context {
-            context.perform {
+
+        if case .failure(let error) = result {
+          return self.handleError(error, callbackQueue: callbackQueue, completion: completion)
+        }
+        
+        // we are guaranteed to have regions
+        guard let region = TKRegionManager.shared.localRegions(start: request.from.coordinate, end: request.to.coordinate).first else {
+          return self.handleError(
+            NSError(code: 1001, // matches server
+                    message: Loc.RoutingBetweenTheseLocationsIsNotYetSupported),
+            callbackQueue: callbackQueue,
+            completion: completion)
+        }
+        
+        let paras = Self.requestParameters(
+          for: request,
+          modeIdentifiers: self.modeIdentifiers,
+          additional: additional,
+          bestOnly: bestOnly
+        )
+        
+        let server = self.server ?? .shared
+        server.hit(TKAPI.RoutingResponse.self,
+                   path: "routing.json",
+                   parameters: paras,
+                   region: region,
+                   callbackOnMain: false
+        ) { [weak self] _, _, result in
+          request.perform { [weak self] _ in
+            guard let self = self else { return }
+            
+            switch result {
+            case .success(let response):
               let tripRequest = request.toTripRequest()
               self.parse(response, for: tripRequest, visibility: visibility, callbackQueue: callbackQueue, completion: completion)
+              
+            case .failure(let error):
+              self.handleError(error, callbackQueue: callbackQueue, completion: completion)
             }
-          } else {
-            let tripRequest = request.toTripRequest()
-            self.parse(response, for: tripRequest, visibility: visibility, callbackQueue: callbackQueue, completion: completion)
           }
-          
-        case .failure(let error):
-          self.handleError(error, callbackQueue: callbackQueue, completion: completion)
         }
       }
     }

  func toTripRequest() -> TripRequest
}

extension TKRouter.RoutingQuery: TKRouterRequestable {
  public func toTripRequest() -> TripRequest {
    guard let context = context else { preconditionFailure() }

          case .success:
            // Classifiers will likely heavily read from the trips, so
            // we need to switch
            request.perform { _ in
              if modes == nil {
                // We get hidden modes here in the completion block
                // since they might have changed while waiting for results
