   }
   
   private func multiFetchTrips(request: TKRouterRequestable, modes: Set<String>? = nil, classifier: TKTripClassifier? = nil, progress: ((UInt) -> Void)? = nil, completion: @escaping (Result<TripRequest, Error>) -> Void) -> UInt {
+    let queue = DispatchQueue(label: "com.skedgo.TripKit.multi-fetch-worker")
+    self.workerQueue = queue
+    var count: UInt = 0
+    queue.sync {
+      count = self.multiFetchTripsWorker(request: request, modes: modes, classifier: classifier, progress: progress, on: queue, completion: completion)
+    }
+    return count
+  }
+    
+  private func multiFetchTripsWorker(request: TKRouterRequestable, modes: Set<String>? = nil, classifier: TKTripClassifier? = nil, progress: ((UInt) -> Void)? = nil, on queue: DispatchQueue, completion: @escaping (Result<TripRequest, Error>) -> Void) -> UInt {
     
     let includesAllModes = request.additional.contains { $0.name == "allModes" }
     if includesAllModes {

    // we'll adjust the visibility in the completion block
    tripRequest.defaultVisibility = .hidden
    
    for modeGroup in groupedIdentifier {
      if self.workers[modeGroup] != nil {
        continue
      }
      
      let worker = TKRouter()
      workers[modeGroup] = worker
      worker.server = server
      worker.modeIdentifiers = modeGroup
      
      worker.fetchTrips(for: tripRequest, additional: request.additional) { [weak self] result in
        guard let self = self else { return }
        
        self.finishedWorkers += 1
        progress?(self.finishedWorkers)
        
        switch result {
        case .failure(let error):
          self.handleMultiFetchResult(.failure(error), modes: worker.modeIdentifiers, request: tripRequest, completion: completion)
          
        case .success:
          if modes == nil {
            // We get the minimized and hidden modes here in the completion block
            // since they might have changed while waiting for results
            let minimized = TKUserProfileHelper.minimizedModeIdentifiers
            let hidden = TKUserProfileHelper.hiddenModeIdentifiers
            tripRequest.adjustVisibility(forMinimizedModeIdentifiers: minimized, hiddenModeIdentifiers: hidden)
          } else {
            tripRequest.adjustVisibility(forMinimizedModeIdentifiers: [], hiddenModeIdentifiers: [])
          }
          
          // Updating classifications before making results visible
          if let classifier = classifier {
            tripRequest.updateTripGroupClassifications(using: classifier)
          }
          
          self.handleMultiFetchResult(result, modes: worker.modeIdentifiers, request: tripRequest, completion: completion)
        }
      }
    }

    
    if workers.isEmpty {
      // Only show an error if we found nothing
      request.context?.perform {
        if request.trips.isEmpty, let error = self.lastWorkerError {
          completion(.failure(error))
        } else {
          completion(.success(request))
        }
      }
    }
  }
