@mmerterden/multi-agent-pipeline 20.6.0 → 20.8.0

package/pipeline/skills/shared/external/core-bluetooth/references/ble-patterns.md

@@ -1,459 +1,379 @@
-# Core Bluetooth Extended Patterns
+# BLE Patterns
 
-Overflow reference for the `core-bluetooth` skill. Contains advanced patterns that exceed the main skill file's scope.
+Longer recipes for the `core-bluetooth` skill.
 
 ## Contents
 
-- [SwiftUI BLE Integration](#swiftui-ble-integration)
-- [Reconnection Strategies](#reconnection-strategies)
-- [Data Parsing Helpers](#data-parsing-helpers)
-- [Write Flow Control](#write-flow-control)
-- [Multiple Peripheral Management](#multiple-peripheral-management)
-- [L2CAP Channels](#l2cap-channels)
-- [Peripheral Role: Responding to Requests](#peripheral-role-responding-to-requests)
+- [A SwiftUI heart-rate monitor](#a-swiftui-heart-rate-monitor)
+- [Reconnecting](#reconnecting)
+- [Parsing bytes safely](#parsing-bytes-safely)
+- [Write flow control](#write-flow-control)
+- [Several peripherals at once](#several-peripherals-at-once)
+- [L2CAP channels](#l2cap-channels)
+- [Answering requests as a peripheral](#answering-requests-as-a-peripheral)
 
-## SwiftUI BLE Integration
+## A SwiftUI heart-rate monitor
 
-### Observable Bluetooth Manager
+### Model
 
 ```swift
 import CoreBluetooth
-import SwiftUI
-
-@Observable
-@MainActor
-final class BLEViewModel: NSObject {
-    private var centralManager: CBCentralManager!
-    private var connectedPeripheral: CBPeripheral?
-
-    var isBluetoothOn = false
-    var isScanning = false
-    var isConnected = false
-    var discoveredDevices: [DiscoveredDevice] = []
-    var heartRate: Int = 0
-
-    struct DiscoveredDevice: Identifiable {
-        let id: UUID
-        let name: String
-        let rssi: Int
-        let peripheral: CBPeripheral
-    }
+import Observation
 
-    override init() {
-        super.init()
-        centralManager = CBCentralManager(delegate: self, queue: nil)
-    }
+struct NearbySensor: Identifiable {
+    let id: UUID
+    let name: String
+    var signal: Int
+    let handle: CBPeripheral
+}
+
+@Observable @MainActor
+final class PulseMonitor: NSObject {
+    private(set) var radioReady = false
+    private(set) var isScanning = false
+    private(set) var linked: NearbySensor?
+    private(set) var sensors: [NearbySensor] = []
+    private(set) var bpm: Int?
+
+    private static let heartRateService = CBUUID(string: "180D")
+    private static let measurement = CBUUID(string: "2A37")
+    @ObservationIgnored private var central: CBCentralManager?
 
-    func startScan() {
-        guard isBluetoothOn else { return }
-        discoveredDevices.removeAll()
-        isScanning = true
-        centralManager.scanForPeripherals(
-            withServices: [CBUUID(string: "180D")],
-            options: nil
-        )
+    func prepare() {
+        if central == nil { central = CBCentralManager(delegate: self, queue: nil) }
     }
 
-    func stopScan() {
-        centralManager.stopScan()
-        isScanning = false
+    func toggleScan() {
+        guard let central, radioReady else { return }
+        if isScanning {
+            central.stopScan()
+        } else {
+            sensors.removeAll()
+            central.scanForPeripherals(withServices: [Self.heartRateService])
+        }
+        isScanning.toggle()
     }
 
-    func connect(to device: DiscoveredDevice) {
-        stopScan()
-        connectedPeripheral = device.peripheral
-        centralManager.connect(device.peripheral)
+    func link(_ sensor: NearbySensor) {
+        central?.stopScan()
+        isScanning = false
+        linked = sensor
+        central?.connect(sensor.handle)
     }
 
-    func disconnect() {
-        guard let peripheral = connectedPeripheral else { return }
-        centralManager.cancelPeripheralConnection(peripheral)
+    func unlink() {
+        guard let handle = linked?.handle else { return }
+        central?.cancelPeripheralConnection(handle)
     }
 }
+```
 
-extension BLEViewModel: CBCentralManagerDelegate {
-    nonisolated func centralManagerDidUpdateState(_ central: CBCentralManager) {
-        Task { @MainActor in
-            isBluetoothOn = central.state == .poweredOn
-        }
+`prepare()` creates the manager, which is also what triggers the permission
+prompt, so call it when the user opens the feature.
+
+### Delegate callbacks
+
+`prepare()` passes `queue: nil`, and Core Bluetooth then delivers central and
+peripheral events on the main queue. The conformance is `@preconcurrency`, so
+the callbacks run as main-actor methods and update state directly. The
+`nonisolated` plus `Task { @MainActor in }` shape does not compile under
+Swift 6 here: the discovered `NearbySensor` holds a `CBPeripheral`, which is not
+`Sendable`, and the region-isolation pass rejects sending it into the task.
+With a background queue instead, keep the callbacks `nonisolated` and send only
+`Sendable` values (identifiers, numbers) across.
+
+```swift
+extension PulseMonitor: @preconcurrency CBCentralManagerDelegate, @preconcurrency CBPeripheralDelegate {
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        radioReady = central.state == .poweredOn
     }
 
-    nonisolated func centralManager(
-        _ central: CBCentralManager,
-        didDiscover peripheral: CBPeripheral,
-        advertisementData: [String: Any],
-        rssi RSSI: NSNumber
-    ) {
-        Task { @MainActor in
-            let name = peripheral.name ?? "Unknown"
-            let device = DiscoveredDevice(
-                id: peripheral.identifier,
-                name: name,
-                rssi: RSSI.intValue,
-                peripheral: peripheral
-            )
-            if !discoveredDevices.contains(where: { $0.id == device.id }) {
-                discoveredDevices.append(device)
-            }
+    func centralManager(_ central: CBCentralManager, didDiscover found: CBPeripheral,
+                        advertisementData: [String: Any], rssi: NSNumber) {
+        if let index = sensors.firstIndex(where: { $0.id == found.identifier }) {
+            sensors[index].signal = rssi.intValue
+        } else {
+            sensors.append(NearbySensor(id: found.identifier, name: found.name ?? "Unknown",
+                                        signal: rssi.intValue, handle: found))
         }
     }
 
-    nonisolated func centralManager(
-        _ central: CBCentralManager,
-        didConnect peripheral: CBPeripheral
-    ) {
-        Task { @MainActor in
-            isConnected = true
-            peripheral.delegate = self
-            peripheral.discoverServices([CBUUID(string: "180D")])
-        }
+    func centralManager(_ central: CBCentralManager, didConnect device: CBPeripheral) {
+        device.delegate = self
+        device.discoverServices([Self.heartRateService])
     }
 
-    nonisolated func centralManager(
-        _ central: CBCentralManager,
-        didDisconnectPeripheral peripheral: CBPeripheral,
-        timestamp: CFAbsoluteTime,
-        isReconnecting: Bool,
-        error: Error?
-    ) {
-        Task { @MainActor in
-            isConnected = false
-            connectedPeripheral = nil
-        }
+    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral device: CBPeripheral,
+                        timestamp: CFAbsoluteTime, isReconnecting: Bool, error: (any Error)?) {
+        linked = nil
+        bpm = nil
     }
-}
 
-extension BLEViewModel: CBPeripheralDelegate {
-    nonisolated func peripheral(
-        _ peripheral: CBPeripheral,
-        didDiscoverServices error: Error?
-    ) {
-        guard let services = peripheral.services else { return }
-        for service in services {
-            peripheral.discoverCharacteristics(
-                [CBUUID(string: "2A37")],
-                for: service
-            )
+    func peripheral(_ device: CBPeripheral, didDiscoverServices error: (any Error)?) {
+        for service in device.services ?? [] {
+            device.discoverCharacteristics([Self.measurement], for: service)
         }
     }
 
-    nonisolated func peripheral(
-        _ peripheral: CBPeripheral,
-        didDiscoverCharacteristicsFor service: CBService,
-        error: Error?
-    ) {
-        guard let characteristics = service.characteristics else { return }
-        for char in characteristics where char.properties.contains(.notify) {
-            peripheral.setNotifyValue(true, for: char)
+    func peripheral(_ device: CBPeripheral, didDiscoverCharacteristicsFor service: CBService,
+                    error: (any Error)?) {
+        for trait in service.characteristics ?? [] where trait.properties.contains(.notify) {
+            device.setNotifyValue(true, for: trait)
         }
     }
 
-    nonisolated func peripheral(
-        _ peripheral: CBPeripheral,
-        didUpdateValueFor characteristic: CBCharacteristic,
-        error: Error?
-    ) {
-        guard let data = characteristic.value, data.count >= 2 else { return }
-        let flags = data[0]
-        let bpm: Int
-        if (flags & 0x01) != 0 {
-            guard data.count >= 3 else { return }
-            bpm = Int(data[1]) | (Int(data[2]) << 8)
+    func peripheral(_ device: CBPeripheral, didUpdateValueFor trait: CBCharacteristic,
+                    error: (any Error)?) {
+        guard let bytes = trait.value, bytes.count >= 2 else { return }
+        if bytes[bytes.startIndex] & 0x01 != 0 {
+            guard let wide = bytes.uint16LE(at: 1) else { return }
+            bpm = Int(wide)
         } else {
-            bpm = Int(data[1])
-        }
-        Task { @MainActor in
-            heartRate = bpm
+            bpm = Int(bytes[bytes.startIndex + 1])
         }
     }
 }
 ```
 
-### SwiftUI View
+Discovery asks only for the `2A37` characteristic, and the byte-length checks
+run before `bpm` changes. Discovered sensors are merged by identifier so the
+list does not fill with duplicates.
+
+### View
 
 ```swift
-struct HeartRateView: View {
-    @State private var viewModel = BLEViewModel()
+struct PulseScreen: View {
+    @State private var monitor = PulseMonitor()
 
     var body: some View {
         NavigationStack {
             Group {
-                if viewModel.isConnected {
-                    VStack {
-                        Image(systemName: "heart.fill")
-                            .font(.system(size: 60))
-                            .foregroundStyle(.red)
-                        Text("\(viewModel.heartRate) BPM")
+                if let sensor = monitor.linked {
+                    VStack(spacing: 12) {
+                        Text(sensor.name).font(.headline)
+                        Text(monitor.bpm.map { "\($0) BPM" } ?? "Waiting for data")
                             .font(.largeTitle.monospacedDigit())
-                        Button("Disconnect") { viewModel.disconnect() }
+                        Button("Disconnect", role: .destructive) { monitor.unlink() }
                     }
                 } else {
-                    List(viewModel.discoveredDevices) { device in
-                        Button {
-                            viewModel.connect(to: device)
-                        } label: {
-                            HStack {
-                                Text(device.name)
-                                Spacer()
-                                Text("\(device.rssi) dBm")
-                                    .foregroundStyle(.secondary)
-                            }
+                    List(monitor.sensors) { sensor in
+                        Button { monitor.link(sensor) } label: {
+                            LabeledContent(sensor.name, value: "\(sensor.signal) dBm")
                         }
                     }
-                }
-            }
-            .navigationTitle("Heart Rate Monitor")
-            .toolbar {
-                if !viewModel.isConnected {
-                    Button(viewModel.isScanning ? "Stop" : "Scan") {
-                        viewModel.isScanning ? viewModel.stopScan() : viewModel.startScan()
+                    .toolbar {
+                        Button(monitor.isScanning ? "Stop" : "Scan") { monitor.toggleScan() }
+                            .disabled(!monitor.radioReady)
                     }
                 }
             }
+            .navigationTitle("Heart Rate")
+            .onAppear { monitor.prepare() }
         }
     }
 }
 ```
 
-## Reconnection Strategies
+## Reconnecting
 
-### Auto-Reconnect on Disconnect
+**Automatic.** In the disconnect callback, if `isReconnecting` is false and
+the user did not ask to disconnect, call `connect(_:)` again. A pending
+connect never times out, so it completes whenever the device comes back in
+range.
 
-```swift
-func centralManager(
-    _ central: CBCentralManager,
-    didDisconnectPeripheral peripheral: CBPeripheral,
-    timestamp: CFAbsoluteTime,
-    isReconnecting: Bool,
-    error: Error?
-) {
-    if !isReconnecting {
-        // Attempt to reconnect
-        central.connect(peripheral, options: nil)
-    }
-}
-```
-
-### Reconnecting to Known Peripherals
-
-Store the peripheral's UUID and reconnect at next launch using
-`retrievePeripherals(withIdentifiers:)`.
+**Remembered devices.** Save `peripheral.identifier`. On the next launch:
 
 ```swift
-func reconnectToKnownDevice(uuid: UUID) {
-    let peripherals = centralManager.retrievePeripherals(
-        withIdentifiers: [uuid]
-    )
-    if let peripheral = peripherals.first {
-        connectedPeripheral = peripheral
-        centralManager.connect(peripheral, options: nil)
-    }
+let saved: [UUID] = SensorStore.knownIdentifiers()
+for device in central.retrievePeripherals(withIdentifiers: saved) {
+    retained[device.identifier] = device
+    central.connect(device)
 }
 ```
 
-### Retrieving Already-Connected Peripherals
+**Already connected elsewhere.** A device another app (or the system) is
+already connected to shows up through
+`central.retrieveConnectedPeripherals(withServices: [heartRateService])`.
 
-If another app has connected to the peripheral, you can retrieve it by service.
-
-```swift
-func findConnectedHeartRateMonitors() -> [CBPeripheral] {
-    centralManager.retrieveConnectedPeripherals(
-        withServices: [CBUUID(string: "180D")]
-    )
-}
-```
-
-## Data Parsing Helpers
-
-### Generic Data Reader
+## Parsing bytes safely
 
 ```swift
 extension Data {
-    func readUInt8(at offset: Int) -> UInt8? {
-        guard offset < count else { return nil }
-        return self[offset]
+    func uint8(at offset: Int) -> UInt8? {
+        guard offset >= 0, offset < count else { return nil }
+        return self[startIndex + offset]
     }
 
-    func readUInt16LE(at offset: Int) -> UInt16? {
-        guard offset + 1 < count else { return nil }
-        return UInt16(self[offset]) | (UInt16(self[offset + 1]) << 8)
+    func uint16LE(at offset: Int) -> UInt16? {
+        guard let low = uint8(at: offset), let high = uint8(at: offset + 1) else { return nil }
+        return UInt16(low) | UInt16(high) << 8
     }
 
-    func readUInt32LE(at offset: Int) -> UInt32? {
-        guard offset + 3 < count else { return nil }
-        return UInt32(self[offset])
-            | (UInt32(self[offset + 1]) << 8)
-            | (UInt32(self[offset + 2]) << 16)
-            | (UInt32(self[offset + 3]) << 24)
+    func uint32LE(at offset: Int) -> UInt32? {
+        guard let low = uint16LE(at: offset), let high = uint16LE(at: offset + 2) else { return nil }
+        return UInt32(low) | UInt32(high) << 16
     }
 }
-```
 
-### Battery Level Parser
-
-```swift
-func parseBatteryLevel(_ data: Data) -> Int? {
-    data.readUInt8(at: 0).map { Int($0) }
+func batteryLevel(from bytes: Data) -> Int? {
+    bytes.uint8(at: 0).map(Int.init)
 }
 ```
 
-## Write Flow Control
+Every accessor returns `nil` instead of trapping when the value is shorter
+than expected. Battery Level is the first byte.
 
-Use `.withResponse` for commands that need delivery confirmation. Reserve
-`.withoutResponse` for streaming or fire-and-forget payloads, and pause when the
-peripheral cannot accept more unacknowledged writes.
+## Write flow control
+
+- `.withResponse` when the command must be confirmed (settings, firmware
+  control points).
+- `.withoutResponse` for streams and fire-and-forget data. The peripheral can
+  hold only so many unacknowledged writes, so pause when it is full.
 
 ```swift
-func writeChunks(_ chunks: [Data],
-                 to characteristic: CBCharacteristic,
-                 on peripheral: CBPeripheral) {
-    for chunk in chunks {
-        guard chunk.count <= peripheral.maximumWriteValueLength(for: .withoutResponse),
-              peripheral.canSendWriteWithoutResponse else { return }
-        peripheral.writeValue(chunk, for: characteristic, type: .withoutResponse)
+final class Uploader: NSObject, CBPeripheralDelegate {
+    private var pending: [Data] = []
+    private let device: CBPeripheral
+    private let target: CBCharacteristic
+
+    init(device: CBPeripheral, target: CBCharacteristic) {
+        self.device = device
+        self.target = target
     }
-}
 
-func peripheralIsReady(toSendWriteWithoutResponse peripheral: CBPeripheral) {
-    // Continue draining queued chunks here.
+    func enqueue(_ blob: Data) {
+        let size = device.maximumWriteValueLength(for: .withoutResponse)
+        pending += stride(from: 0, to: blob.count, by: size).map {
+            blob.subdata(in: $0..<Swift.min($0 + size, blob.count))
+        }
+        drain()
+    }
+
+    private func drain() {
+        while let next = pending.first, device.canSendWriteWithoutResponse {
+            guard next.count <= device.maximumWriteValueLength(for: .withoutResponse) else { return }
+            device.writeValue(next, for: target, type: .withoutResponse)
+            pending.removeFirst()
+        }
+    }
+
+    func peripheralIsReady(toSendWriteWithoutResponse device: CBPeripheral) {
+        drain()
+    }
 }
 ```
 
-## Multiple Peripheral Management
+Sending stops when the peripheral cannot take more, or a chunk is too large,
+and resumes from `peripheralIsReady(toSendWriteWithoutResponse:)`.
 
-### Managing Several Connections
+## Several peripherals at once
 
 ```swift
-@MainActor
-final class MultiDeviceManager: NSObject {
-    private var centralManager: CBCentralManager!
-    private var connectedPeripherals: [UUID: CBPeripheral] = [:]
-
-    func centralManager(
-        _ central: CBCentralManager,
-        didDiscover peripheral: CBPeripheral,
-        advertisementData: [String: Any],
-        rssi RSSI: NSNumber
-    ) {
-        let id = peripheral.identifier
-        guard connectedPeripherals[id] == nil else { return }
-        connectedPeripherals[id] = peripheral
-        central.connect(peripheral)
+final class SensorHub: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate {
+    private var central: CBCentralManager!
+    private var connected: [UUID: CBPeripheral] = [:]
+
+    func attach(_ device: CBPeripheral) {
+        guard connected[device.identifier] == nil else { return }
+        connected[device.identifier] = device
+        central.connect(device)
     }
 
-    func centralManager(
-        _ central: CBCentralManager,
-        didConnect peripheral: CBPeripheral
-    ) {
-        peripheral.delegate = self
-        peripheral.discoverServices(nil)
+    func centralManager(_ central: CBCentralManager, didConnect device: CBPeripheral) {
+        device.delegate = self
+        device.discoverServices(nil)
     }
 
-    func disconnectAll() {
-        for peripheral in connectedPeripherals.values {
-            centralManager.cancelPeripheralConnection(peripheral)
-        }
-        connectedPeripherals.removeAll()
+    func detachAll() {
+        for device in connected.values { central.cancelPeripheralConnection(device) }
+        connected.removeAll()
     }
+
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {}
 }
 ```
 
-## L2CAP Channels
+Key the dictionary by `identifier`, skip devices already tracked, and start
+discovery for each one as it connects. Passing `nil` to `discoverServices`
+here keeps the sample short; list the services you need in real code.
+
+## L2CAP channels
 
-Use L2CAP channels for higher-throughput, stream-oriented data transfer.
+An L2CAP channel is a stream between the two devices, with more throughput
+than characteristic writes for bulk data.
 
-### Central Side
+**Central side:**
 
 ```swift
-func peripheral(
-    _ peripheral: CBPeripheral,
-    didOpen channel: CBL2CAPChannel?,
-    error: Error?
-) {
-    guard let channel else { return }
-    let inputStream = channel.inputStream
-    let outputStream = channel.outputStream
-
-    inputStream.delegate = self
-    outputStream.delegate = self
-    inputStream.schedule(in: .main, forMode: .default)
-    outputStream.schedule(in: .main, forMode: .default)
-    inputStream.open()
-    outputStream.open()
+device.openL2CAPChannel(CBL2CAPPSM(0x0081))
+
+func peripheral(_ device: CBPeripheral, didOpen channel: CBL2CAPChannel?, error: (any Error)?) {
+    guard let channel, error == nil,
+          let input = channel.inputStream, let output = channel.outputStream else { return }
+    for stream in [input, output] as [Stream] {
+        stream.delegate = self
+        stream.schedule(in: .main, forMode: .default)
+        stream.open()
+    }
+    activeChannel = channel
 }
-
-// Open a channel to a known PSM
-peripheral.openL2CAPChannel(CBL2CAPPSM(0x0025))
 ```
 
-### Peripheral Side
+Keep the channel object alive while you use its streams.
+
+**Peripheral side:**
 
 ```swift
-// Publish a channel listener
-peripheralManager.publishL2CAPChannel(withEncryption: true)
-
-func peripheralManager(
-    _ peripheral: CBPeripheralManager,
-    didPublishL2CAPChannel PSM: CBL2CAPPSM,
-    error: Error?
-) {
-    // Share the PSM with centrals via a characteristic value
-    print("Published L2CAP channel on PSM: \(PSM)")
+manager.publishL2CAPChannel(withEncryption: true)
+
+func peripheralManager(_ manager: CBPeripheralManager, didPublishL2CAPChannel psm: CBL2CAPPSM,
+                       error: (any Error)?) {
+    guard error == nil else { return }
+    var value = psm.littleEndian
+    psmCharacteristic.value = Data(bytes: &value, count: MemoryLayout<CBL2CAPPSM>.size)
 }
 ```
 
-## Peripheral Role: Responding to Requests
+The system assigns the PSM. Publish it through a characteristic so centrals
+know which channel to open.
 
-When acting as a peripheral, respond to read and write requests from connected centrals.
+## Answering requests as a peripheral
 
 ```swift
-extension BLEPeripheralManager: CBPeripheralManagerDelegate {
-    func peripheralManager(
-        _ peripheral: CBPeripheralManager,
-        didReceiveRead request: CBATTRequest
-    ) {
-        if request.characteristic.uuid == charUUID {
-            let value = currentSensorData()
-            request.value = value.subdata(
-                in: request.offset..<value.count
-            )
-            peripheral.respond(to: request, withResult: .success)
-        } else {
-            peripheral.respond(to: request, withResult: .attributeNotFound)
-        }
+func peripheralManager(_ manager: CBPeripheralManager, didReceiveRead request: CBATTRequest) {
+    guard request.characteristic.uuid == ThermometerBeacon.reading else {
+        manager.respond(to: request, withResult: .attributeNotFound)
+        return
     }
-
-    func peripheralManager(
-        _ peripheral: CBPeripheralManager,
-        didReceiveWrite requests: [CBATTRequest]
-    ) {
-        for request in requests {
-            if let value = request.value {
-                handleIncomingData(value)
-            }
-        }
-        // Respond to the first request -- Core Bluetooth sends the
-        // response for all requests in the batch
-        if let first = requests.first {
-            peripheral.respond(to: first, withResult: .success)
-        }
+    let current = Thermometer.latestReading()
+    guard request.offset <= current.count else {
+        manager.respond(to: request, withResult: .invalidOffset)
+        return
     }
+    request.value = current.subdata(in: request.offset..<current.count)
+    manager.respond(to: request, withResult: .success)
+}
 
-    func peripheralManager(
-        _ peripheral: CBPeripheralManager,
-        central: CBCentral,
-        didSubscribeTo characteristic: CBCharacteristic
-    ) {
-        // Central subscribed to notifications -- start sending updates
-        startSendingUpdates()
+func peripheralManager(_ manager: CBPeripheralManager, didReceiveWrite requests: [CBATTRequest]) {
+    for request in requests {
+        if let value = request.value { Thermostat.apply(value, to: request.characteristic.uuid) }
     }
-
-    func peripheralManager(
-        _ peripheral: CBPeripheralManager,
-        central: CBCentral,
-        didUnsubscribeFrom characteristic: CBCharacteristic
-    ) {
-        stopSendingUpdates()
+    if let first = requests.first {
+        manager.respond(to: first, withResult: .success)
     }
 }
+
+func peripheralManager(_ manager: CBPeripheralManager, central: CBCentral,
+                       didSubscribeTo characteristic: CBCharacteristic) {
+    Thermometer.startStreaming(to: central)
+}
+
+func peripheralManager(_ manager: CBPeripheralManager, central: CBCentral,
+                       didUnsubscribeFrom characteristic: CBCharacteristic) {
+    Thermometer.stopStreaming(to: central)
+}
 ```
+
+Reads honour `request.offset` so long values can be fetched in pieces. For a
+batch of writes, respond once, to the first request; that single response
+covers the whole batch. Subscriptions start and stop your update stream.