     /// Get the maximum transmission unit for the specified peripheral.
     func maximumTransmissionUnit(for peripheral: Peripheral) -> AnyPublisher<ATTMaximumTransmissionUnit, Error> {
         
-        let future = Future<ATTMaximumTransmissionUnit, Error> { [unowned self] (completion) in
-            self.centralManager { (central) in
-                self.peripheral(for: peripheral) { (corePeripheral) in
-                    let mtu = corePeripheral.maximumWriteValueLength(for: .withoutResponse) + 3
-                    
-                }
-            }
-        }
-        
-        
-        
-        let future = Future<ATTMaximumTransmissionUnit, Error>()
-        self.accessQueue.async {
-            do {
-                guard state == .poweredOn
-                    else { throw DarwinCentralError.invalidState(state) }
-                
-            }
-            catch {
-                
-            }
-        }
-        return subject
-        
-        
-        
-        let corePeripheral = try accessQueue.sync { [unowned self] in
-            try self.connectedPeripheral(peripheral)
-        }
-        
-        let mtu = corePeripheral.maximumWriteValueLength(for: .withoutResponse) + 3
-        assert((corePeripheral.value(forKey: "mtuLength") as! NSNumber).intValue == mtu)
-        return ATTMaximumTransmissionUnit(rawValue: UInt16(mtu)) ?? .default
+        return self.centralManager.tryMap { _ in
+            guard self.state == .poweredOn else { throw DarwinCentralError.invalidState(self.state) }
+        }
+        .flatMap { _ in
+            self.peripheral(for: peripheral)
+        }
+        .tryMap {
+            let mtu = $0.maximumWriteValueLength(for: .withoutResponse) + 3
+            assert(($0.value(forKey: "mtuLength") as! NSNumber).intValue == mtu)
+            return ATTMaximumTransmissionUnit(rawValue: UInt16(mtu)) ?? .default
+        }
+        .eraseToAnyPublisher()
     }
     
     // MARK: - Private Methods
     
-    private func centralManager(_ block: (CBCentralManager) -> ()) {
-        self.queue.async { [unowned self] in
-            block(self.internalManager)
-        }
-    }
-    
-    private func peripheral(for peripheral: Peripheral, block: (CBPeripheral) -> ()) throws {
-        // should only call from `self.queue`
-        guard let corePeripheral = self.cache.peripherals[peripheral]
-            else { throw CentralError.unknownPeripheral }
-        self.queue(for: peripheral).async {
-            block(corePeripheral)
-        }
+    private lazy var centralManager: AnyPublisher<CBCentralManager, Never> = Just(self.internalManager)
+            .receive(on: self.queue)
+            .eraseToAnyPublisher()
+    
+    private func peripheral(for peripheral: Peripheral) -> AnyPublisher<CBPeripheral, Error> {
+        return self.centralManager.tryMap { _ in
+            if let corePeripheral = self.cache.peripherals[peripheral] {
+                return corePeripheral
+            } else {
+                throw CentralError.unknownPeripheral
+            }
+        }
+        .receive(on: queue(for: peripheral))
+        .eraseToAnyPublisher()
     }
     
     private func queue(for peripheral: Peripheral) -> DispatchQueue {
         return self.peripheralQueue[peripheral, default: DispatchQueue(label: "Peripheral \(peripheral) Queue")]
     }
-    
-    
 }
 
 // MARK: - Supporting Types

    typealias State = DarwinBluetoothState
    
    typealias AttributeID = ObjectIdentifier
    
    /// Central Peer
    ///

    /// CoreBluetooth Central Manager Options
    public let options: Options
    
    private lazy var internalManager = CBCentralManager(
        delegate: self.delegate,
        queue: self.managerQueue,
        options: self.options.optionsDictionary
    )
    
    private lazy var managerQueue = DispatchQueue(label: "\(type(of: self)) Manager Queue")
    
    private lazy var queue = DispatchQueue(label: "\(type(of: self)) Queue")
    
    private var peripheralQueue = [Peripheral: DispatchQueue]()
    
    private lazy var delegate = Delegate(self)

    private var cache = Cache()
    
    private var combine = Combine()
    
    // MARK: - Initialization
    
