         return false
     }
     
-    private func process(var path: String, var parameters: [String: String], var route: (RouteHandler, Parameters), routes: [RouteType]) {
+    private func process(var path: String, var parameters: [String: String], var route: (RouteHandler, Parameters), routes: [Route]) {
+        var proxies: [Proxy]!
+        dispatch_sync(accessQueue) {
+            proxies = self.proxies
+        }
+        
         dispatch_async(routingQueue) {
             let semaphore = dispatch_semaphore_create(0)
             // TODO: allow proxy to abort
-            routes  /* Proxies */
-                .map { closure -> (ProxyHandler?, Parameters) in
-                    if case let .Proxy(f) = closure { return f(path) }
-                    else { return (nil, [String : String]())}
-                }
+            proxies
+                .map { $0(path) }
                 .filter { $0.0 != nil }
                 .map { ($0!, $1) }
                 .forEach { (h, var p) in

    public typealias Parameters = [String: String]
    public typealias Completed = () -> Void
    
    private enum RouteType {
        case Proxy((String) -> (ProxyHandler?, Parameters))
        case Route((String) -> (RouteHandler?, Parameters))
    }
    
    private var accessQueue: dispatch_queue_t!
    private var routingQueue: dispatch_queue_t!
    private var callbackQueue: dispatch_queue_t!
    private var routes: [RouteType] = [RouteType]()
    
    public init(accessQueue: dispatch_queue_t = dispatch_queue_create("Routing Access Queue", DISPATCH_QUEUE_CONCURRENT),
        routingQueue: dispatch_queue_t = dispatch_queue_create("Routing Queue", DISPATCH_QUEUE_SERIAL),

        
        // TODO: extract common pattern
        let route = routes
            .map { $0(URLString) }
            .filter { $0.0 != nil }
            .first
            .map { ($0!, $1) }
