         _ services: Set<BluetoothUUID> = [],
         for peripheral: Peripheral
     ) async throws -> [DarwinCentral.Service] {
-        return try await withThrowingContinuation(for: peripheral) { [weak self] continuation in
-            guard let self = self else { return }
-            self.async {
-                self.stopScan()
-                let context = self.continuation(for: peripheral)
-                context.operation?.cancel()
-                context.operation = nil
-                let operation = Operation.DiscoverServices(
-                    peripheral: peripheral,
-                    services: services,
-                    continuation: continuation
-                )
-                if self.execute(operation) {
-                    context.operation = .discoverServices(operation)
+        try await queue(for: peripheral) {
+            try await withThrowingContinuation(for: peripheral) { [weak self] continuation in
+                guard let self = self else { return }
+                self.async {
+                    self.stopScan()
+                    let context = self.continuation(for: peripheral)
+                    context.operation?.cancel()
+                    context.operation = nil
+                    let operation = Operation.DiscoverServices(
+                        peripheral: peripheral,
+                        services: services,
+                        continuation: continuation
+                    )
+                    if self.execute(operation) {
+                        context.operation = .discoverServices(operation)
+                    }
                 }
             }
         }

        ) {
            log("Did connect to peripheral \(corePeripheral.id.uuidString)")
            assert(corePeripheral.state != .disconnected, "Should be connected")
            assert(self.central != nil)
            assert(self.central?.centralManager === centralManager)
            let peripheral = Peripheral(corePeripheral)
            let context = self.central.continuation(for: peripheral)
            guard case let .connect(operation) = context.operation else {

        _ services: Set<BluetoothUUID> = [],
        for service: DarwinCentral.Service
    ) async throws -> [DarwinCentral.Service] {
        try await queue(for: service.peripheral) {
            try await withThrowingContinuation(for: service.peripheral) { [weak self] continuation in
                guard let self = self else { return }
                self.async {
                    self.stopScan()
                    let context = self.continuation(for: service.peripheral)
                    context.operation?.cancel()
                    context.operation = nil
                    let operation = Operation.DiscoverIncludedServices(
                        service: service,
                        services: services,
                        continuation: continuation
                    )
                    if self.execute(operation) {
                        context.operation = .discoverIncludedServices(operation)
                    }
                }
            }
        }
