CoreBluetooth writeWithoutResponse flow control with peripheralIsReady(toSendWriteWithoutResponse:)

[Linqa2]

CBPeripheral.writeValue(_:type: .withoutResponse) requires explicit flow control to avoid overfilling CoreBluetooth’s internal transmit buffer.

CoreBluetooth provides two related mechanisms for this:

• CBPeripheral.canSendWriteWithoutResponse
• peripheralIsReady(toSendWriteWithoutResponse:)

This issue tracks the absence of a flow-controlled, async-safe writeWithoutResponse mechanism that correctly accounts for CoreBluetooth readiness signaling via canSendWriteWithoutResponse and peripheralIsReady(toSendWriteWithoutResponse:).

[Linqa2]

Proposed Solution: Flow-Controlled Write Without Response

Architecture

The solution transforms write-without-response from a fire-and-forget operation into an async permit-based system. Callers suspend until the peripheral has buffer space available, then send exactly one write. This eliminates data loss while maintaining performance through a fast-path optimization when buffer space is immediately available.

Core Mechanism

The implementation maintains a FIFO queue of waiters. Each waiter consists of a unique identifier, a TimedOperation managing the continuation lifecycle, and optional timeout configuration. Critically, callers retain their own data payloads—no payload queue is created. When CoreBluetooth's peripheralIsReady(toSendWriteWithoutResponse:) delegate fires, waiters are dequeued and resumed in order, granting permission to send.

Key Design Elements

Serialization: All writes serialize at the peripheral level regardless of target characteristic, matching CoreBluetooth's actual shared buffer architecture. This FIFO ordering ensures fairness and predictable behavior under concurrent load.

Race Prevention: After enqueuing each waiter, a drain function immediately processes the queue if the peripheral is ready. This eliminates the missed-signal race where the delegate callback could fire between checking readiness and enqueueing.

Timeout Integration: Timeouts apply to permit acquisition, not transmission. Uses the library's existing TimedOperation infrastructure for consistency. On timeout, the waiter is removed from the queue and receives a connectionTimeout error.

Task Cancellation: Implements withTaskCancellationHandler to remove cancelled waiters from the queue and cancel their TimedOperation. This prevents resource leaks and ensures cancelled operations don't occupy queue positions.

Resource Cleanup: On disconnect, cancelAllPendingOperations resumes all waiters with peripheralNotConnected errors, ensuring no leaked continuations or lingering timeout tasks.

Implementation Invariants

The correctness relies on: FIFO queue processing without reordering, single-shot resumption via TimedOperation semantics, idempotent drain function callable from any context, and MainActor isolation for all state mutations. These guarantee predictable behavior under concurrent writes, timeouts, cancellations, and unexpected disconnections.

Trade-offs

The breaking API change from synchronous to async is justified because it makes previously-silent buffer overflow failures visible and handleable. The fast-path optimization preserves performance when buffer space is available—serialization only adds delay when the peripheral's buffer is actually full, the exact scenario that caused silent data loss previously.