                 log("Peripheral \(peripheralObject.gattIdentifier.uuidString) did read RSSI \(rssiObject.description)")
             }
             let peripheral = Peripheral(peripheralObject)
-            guard let continuation = self.central.continuation.readRSSI[peripheral] else {
-                assertionFailure("Missing continuation")
-                return
-            }
-            if let error = error {
-                continuation.resume(throwing: error)
-            } else {
-                guard let rssi = Bluetooth.RSSI(rawValue: rssiObject.int8Value) else {
-                    assertionFailure("Invalid RSSI \(rssiObject)")
-                    continuation.resume(returning: RSSI(rawValue: -127)!)
-                    self.central.continuation.readRSSI[peripheral] = nil
-                    return
-                }
-                continuation.resume(returning: rssi)
-            }
-            self.central.continuation.readRSSI[peripheral] = nil
-        }
-        
+            self.central.dequeueReadRSSI(for: peripheral) { operation in
+                if let error = error {
+                    operation.continuation.resume(throwing: error)
+                } else {
+                    guard let rssi = Bluetooth.RSSI(rawValue: rssiObject.int8Value) else {
+                        assertionFailure("Invalid RSSI \(rssiObject)")
+                        operation.continuation.resume(returning: RSSI(rawValue: -127)!)
+                        return
+                    }
+                    operation.continuation.resume(returning: rssi)
+                }
+            }
+        }
+        /*
         func peripheral(
             _ peripheralObject: CBPeripheral,
             didDiscoverIncludedServicesFor serviceObject: CBService,

                    }
                }
            } else if characteristicObject.isNotifying {
                guard let stream = self.central.continuation.notificationStream[characteristic.id] else {
                    assertionFailure("Missing notification stream")
                    return
                }

    }
    
    private func enqueueReadRSSI(_ operation: Operation.ReadRSSI, for peripheral: Peripheral) {
        let context = continuation(for: peripheral)
        context.readRSSI.push(operation)
    }
    
    private func dequeueReadRSSI(for peripheral: Peripheral, _ body: (Operation.ReadRSSI) -> ()) {
        guard let context = self.continuation.peripherals[peripheral] else {
            assertionFailure("Missing context")
            return
        }
        context.readRSSI.pop(body)
    }
    
    private func write(
