Update for Swift Concurrency in Swift 6

[itsniper]

Summary

Modernizes ReliaBLE for Swift 6 with complete concurrency checking. This is the umbrella PR for issue #10, landing the 5-step migration:

1. Introduce BluetoothActor to serialize all CoreBluetooth state (replaces ad-hoc queue hopping).
2. Make Peripheral a Sendable value type (no CBPeripheral reference escapes the actor).
3. Replace Combine event surfaces with per-subscriber AsyncStream broadcasters (replay-on-subscribe for state & discovered peripherals).
4. Collapse BluetoothManager + PeripheralManager into ReliaBLEManager (a nonisolated, Sendable façade forwarding to the actor).
5. Enable strict/complete concurrency checking in Package.swift.

New supporting types: AdvertisementData, PeripheralError, CBUUID+Sendable.

Architecture notes

• All mutable BLE state (CBCentralManager, continuations, discovered peripherals, live CBPeripheral registry) is owned exclusively by @BluetoothActor.
• Delegate callbacks arrive on CoreBluetooth's queue and hop into the actor via a nonisolated BluetoothDelegateShim.
• Lazy authorization is preserved: the central manager is only created when already .allowedAlways or when authorizeBluetooth() is called, so the integrating app controls the permission prompt.
• CBCentralManagerFactory.instance(..., forceMock: true) is retained (load-bearing for the ReliaBLEMock test target).

Breaking changes

Source-breaking for consumers: Combine publishers → AsyncStream, several operations are now async, the manager split is removed, and Peripheral is now a value snapshot. Should ship as a major version.

🤖 Generated with Claude Code

[itsniper]

Code Review — Swift 6 Concurrency Migration

Summary: A well-executed strict-concurrency migration — the two managers collapse into a single @BluetoothActor, Peripheral/AdvertisementData become pure Sendable value snapshots, Combine is replaced by per-subscriber AsyncStream broadcasters with replay-on-subscribe, and the lazy-authorization + CBCentralManagerFactory(forceMock:) constraints are preserved. The architecture is sound; the items below are reachable correctness/lifecycle edges, not structural flaws.

🔴 Must-fix

• BluetoothActor.peripheralDiscoveriesStream() — unbounded buffer. It uses the default (.unbounded) buffering policy while stateStream() and discoveredPeripheralsStream() use .bufferingNewest(1). BLE advertisements arrive at high frequency, so a slow or abandoned for await consumer grows memory without bound. Use AsyncStream(bufferingPolicy: .bufferingNewest(N)) or explicitly document the unbounded tradeoff. (The docstring covers no-replay, but not buffering.)

• BluetoothActor.handlePeripheralDiscovered — name-based identity collapses distinct devices. Identity is keyed on name ?? localName ?? identifier.uuidString, and Peripheral is Hashable/== on id only. Two physical devices advertising the same name collapse into one discoveredPeripherals entry, and cbPeripherals[resolvedId] = cbPeripheral overwrites the live reference — so connect(to:) can target whichever was seen last. The cbIdentifier fallback branch only rescues the same device with a changed name, not this collision. Prefer keying the live registry/dedup on the stable cbPeripheral.identifier. (Partly acknowledged by the FR-8.5 TODO — at minimum surface it as a documented limitation.)

• ReliaBLEManager.init — fire-and-forget init ordering race. Task { await BluetoothActor.shared.initialize(...) } isn't ordered before a caller's immediate await startScanning(); actors give no cross-Task FIFO guarantee, so an early scan can no-op against centralManager == nil. The inline comment acknowledges this. Consider an actor-side ensureInitialized() that scanning/authorize funnel through (preserving lazy permission) rather than relying on the guard's silent no-op.

🟡 Suggestions

• authorize() / authorizeBluetooth() returns before resolution. For .notDetermined it calls setupCentralManager() and returns immediately — the user can still deny the system prompt after try await authorizeBluetooth() has succeeded. Either suspend until the authorization callback resolves, or rename/document it as "request authorization" and point callers to the state stream for the result.

• BluetoothDelegateShim — delegate ordering. Each callback spawns an independent Task { @BluetoothActor in … }. Handlers run atomically (no internal awaits), but a didDiscover task can be scheduled after a resetting→invalidatePeripherals() task, repopulating cbPeripherals post-invalidation. Low probability; consider funneling delegate events through one ordered sequence to guarantee CB-queue order.

• LoggingService.enabled — mutable var on a Sendable class. Forwards straight to Willow.Logger.enabled. Safe only if Willow synchronizes that property internally — worth confirming; otherwise make enablement configure-once.

• Tests. Good Sendable/replay coverage, but the highest-risk paths above are untested. Add: init→immediate-scan ordering, stream cancellation pruning continuations, same-name duplicate peripherals, and authorizeBluetooth() from .notDetermined through denial.

• Breaking API. Combine→AsyncStream, several ops now async, Peripheral now a value snapshot, manager split removed — source-breaking, so release as a major version and confirm README/DocC examples match.

❓ Questions

• Is collapsing same-named devices an accepted interim behavior pending FR-8.5, or should cbIdentifier become the dedup key now?
• Should connect(to:) with a nil central manager throw (it currently logs and silently returns, unlike the notFound throw path)?

Authored-By: Claude Opus 4.8 [email protected]

[itsniper]

Must-fix

• BluetoothActor.peripheralDiscoveriesStream() -- unbounded buffer. Implement a very high N so it's not fully unbounded, but unlikely to be hit. I'm open to ideas but some N that would bound it at ~10MB.
• BluetoothActor.handlePeripheralDiscovered -- name-based identity collapses distinct devices. Since this library is not yet published or used in any production apps, we can leave it and address it with FR8.5. In the meantime expand the TODO comment with a bit more detail on the issue that needs to be addressed.
• ReliaBLEManager.init -- fire-and-forget init ordering race. I like the idea of an actor-side ensureInitialized() that scanning/authorize funnel through (preserving lazy permission). Please implement this.

Suggestions

• authorize() / authorizeBluetooth() returns before resolution. Take whichever approach you think provides the best experience for developers of the consuming app. But I personally lean towards suspending until the authorization callback resolves.
• BluetoothDelegateShim -- delegate ordering. Agreed please implement this.
• LoggingService.enabled -- mutable var on a Sendable class. This has been confirmed in the Willow library. I want to preserve the ability to enable logs at runtime, which means configure-once is not an acceptable approach.
• Tests. Please add tests as you see fit.
• Breaking API. Given this library has not been published and has no consumers, breaking changes are 100% acceptable.

Questions

• Is collapsing same-named devices an accepted interim behavior pending FR-8.5, or should cbIdentifier become the dedup key now? As mentioned above yes, this is acceptable for now.
• Should connect(to:) with a nil central manager throw (it currently logs and silently returns, unlike the notFound throw path)? Yes it should throw. Please implement this.