@tryterra/react-native 0.0.0-stage → 2.1.0

package/ios/TerraBridgeCore/Generated/BridgeOps.swift

@@ -0,0 +1,795 @@
+// Generated from surface/terra-surface.json by surface/gen. Do not edit by hand.
+// Regenerate with: node surface/gen/src/cli.ts generate
+
+import Foundation
+
+/// Every op the schema declares, including the ones this platform does not implement.
+///
+/// The unsupported ones are cases here rather than absent so that `dispatch` can answer
+/// `bridge.unsupported_on_platform` deliberately, instead of failing to parse the op and
+/// answering something that reads like a bug in the caller.
+public enum BridgeOp: String, CaseIterable, Sendable {
+    case clientAttach = "client.attach"
+    case clientConnect = "client.connect"
+    case clientConnections = "client.connections"
+    case clientDisconnect = "client.disconnect"
+    case tokenSetProviderPresent = "token.setProviderPresent"
+    case tokenResolve = "token.resolve"
+    case tokenReject = "token.reject"
+    case permissionsRequest = "permissions.request"
+    case permissionsStatus = "permissions.status"
+    case permissionsWriteStatus = "permissions.writeStatus"
+    case permissionsRequested = "permissions.requested"
+    case permissionsStatuses = "permissions.statuses"
+    case permissionsBackgroundReadStatus = "permissions.backgroundReadStatus"
+    case permissionsHistoryReadStatus = "permissions.historyReadStatus"
+    case diagnosticsState = "diagnostics.state"
+    case diagnosticsLastDelivery = "diagnostics.lastDelivery"
+    case diagnosticsReport = "diagnostics.report"
+    case diagnosticsSend = "diagnostics.send"
+    case backgroundIsRegistered = "background.isRegistered"
+    case backgroundCancel = "background.cancel"
+    case bodyHeartRate = "body.heartRate"
+    case bodyLogHeartRate = "body.logHeartRate"
+    case bodyLog = "body.log"
+    case bodyDelete = "body.delete"
+    case dailySteps = "daily.steps"
+    case dailyLog = "daily.log"
+    case dailyDelete = "daily.delete"
+    case sleepSegments = "sleep.segments"
+    case sleepLog = "sleep.log"
+    case sleepDelete = "sleep.delete"
+    case activityWorkouts = "activity.workouts"
+    case activityLog = "activity.log"
+    case activityDelete = "activity.delete"
+    case nutritionLog = "nutrition.log"
+    case nutritionDelete = "nutrition.delete"
+    case plannedWorkoutsPlanned = "plannedWorkouts.planned"
+    case plannedWorkoutsMarkComplete = "plannedWorkouts.markComplete"
+    case plannedWorkoutsDelete = "plannedWorkouts.delete"
+    case plannedWorkoutsSchedulingStatus = "plannedWorkouts.schedulingStatus"
+    case plannedWorkoutsRequestScheduling = "plannedWorkouts.requestScheduling"
+
+    /// Whether this platform implements the op.
+    public var isSupported: Bool {
+        switch self {
+        case .clientAttach: return true
+        case .clientConnect: return true
+        case .clientConnections: return true
+        case .clientDisconnect: return true
+        case .tokenSetProviderPresent: return true
+        case .tokenResolve: return true
+        case .tokenReject: return true
+        case .permissionsRequest: return true
+        case .permissionsStatus: return true
+        case .permissionsWriteStatus: return true
+        case .permissionsRequested: return true
+        case .permissionsStatuses: return false
+        case .permissionsBackgroundReadStatus: return false
+        case .permissionsHistoryReadStatus: return false
+        case .diagnosticsState: return true
+        case .diagnosticsLastDelivery: return true
+        case .diagnosticsReport: return true
+        case .diagnosticsSend: return true
+        case .backgroundIsRegistered: return true
+        case .backgroundCancel: return false
+        case .bodyHeartRate: return true
+        case .bodyLogHeartRate: return true
+        case .bodyLog: return true
+        case .bodyDelete: return true
+        case .dailySteps: return true
+        case .dailyLog: return true
+        case .dailyDelete: return true
+        case .sleepSegments: return true
+        case .sleepLog: return true
+        case .sleepDelete: return true
+        case .activityWorkouts: return true
+        case .activityLog: return true
+        case .activityDelete: return true
+        case .nutritionLog: return true
+        case .nutritionDelete: return true
+        case .plannedWorkoutsPlanned: return true
+        case .plannedWorkoutsMarkComplete: return true
+        case .plannedWorkoutsDelete: return true
+        case .plannedWorkoutsSchedulingStatus: return true
+        case .plannedWorkoutsRequestScheduling: return true
+        }
+    }
+}
+
+/// What P3 implements. One method per op this platform supports, and no `default` anywhere:
+/// an op added to the schema breaks this build rather than reaching a customer as a rejection.
+public protocol TerraBridgeOps: Sendable {
+    /// Reports the native client the JS side is attaching to. Idempotent, and safe to call after a
+    /// JS reload.
+    func clientAttach(_ request: Empty) async throws -> BootstrapState
+    func clientConnect(_ request: ConnectRequest) async throws -> Connection
+    func clientConnections(_ request: Empty) async throws -> ConnectionList
+    func clientDisconnect(_ request: SourceRequest) async throws -> Empty
+    /// Tells the broker whether JS can answer at all. Without it a link asks a provider that is not
+    /// there and waits out the timeout.
+    func tokenSetProviderPresent(_ request: TokenProviderRequest) async throws -> Empty
+    /// An unknown or already-settled requestId is ignored rather than rejected, so a reload cannot
+    /// fail a link that has already moved on.
+    func tokenResolve(_ request: TokenResolveRequest) async throws -> Empty
+    func tokenReject(_ request: TokenRejectRequest) async throws -> Empty
+    func permissionsRequest(_ request: PermissionRequest) async throws -> PermissionGrant
+    func permissionsStatus(_ request: CategoryRequest) async throws -> StatusResult
+    func permissionsWriteStatus(_ request: CategoryRequest) async throws -> StatusResult
+    func permissionsRequested(_ request: SourceRequest) async throws -> HealthAccess
+    func diagnosticsState(_ request: SourceRequest) async throws -> DiagnosticsState
+    func diagnosticsLastDelivery(_ request: SourceRequest) async throws -> LastDeliveryResult
+    func diagnosticsReport(_ request: SourceRequest) async throws -> SupportReport
+    func diagnosticsSend(_ request: SourceRequest) async throws -> Empty
+    /// False means bootstrap did not run. The SDK reports the same thing independently as
+    /// backgroundRefreshUnscheduled.
+    func backgroundIsRegistered(_ request: Empty) async throws -> BoolResult
+    func bodyHeartRate(_ request: RangeRequest) async throws -> HeartRateList
+    /// Its own op rather than an overload: Swift overloads log by element type and JS cannot.
+    func bodyLogHeartRate(_ request: HeartRateEntryList) async throws -> RecordIdList
+    func bodyLog(_ request: BodyEntryList) async throws -> RecordIdList
+    func bodyDelete(_ request: RecordIdRequest) async throws -> Empty
+    func dailySteps(_ request: RangeRequest) async throws -> StepCountList
+    func dailyLog(_ request: StepEntryList) async throws -> RecordIdList
+    func dailyDelete(_ request: RecordIdRequest) async throws -> Empty
+    func sleepSegments(_ request: RangeRequest) async throws -> SleepSegmentList
+    func sleepLog(_ request: SleepEntryList) async throws -> RecordIdList
+    func sleepDelete(_ request: RecordIdRequest) async throws -> Empty
+    func activityWorkouts(_ request: RangeRequest) async throws -> WorkoutList
+    func activityLog(_ request: WorkoutEntryList) async throws -> RecordIdList
+    func activityDelete(_ request: RecordIdRequest) async throws -> Empty
+    func nutritionLog(_ request: NutritionEntryList) async throws -> RecordIdList
+    func nutritionDelete(_ request: RecordIdRequest) async throws -> Empty
+    /// Available on ios only.
+    func plannedWorkoutsPlanned(_ request: Empty) async throws -> PlannedWorkoutList
+    /// Available on ios only.
+    func plannedWorkoutsMarkComplete(_ request: MarkCompleteRequest) async throws -> Empty
+    /// Available on ios only.
+    func plannedWorkoutsDelete(_ request: RecordIdRequest) async throws -> Empty
+    /// Never prompts.
+    ///
+    /// Available on ios only.
+    func plannedWorkoutsSchedulingStatus(_ request: Empty) async throws -> WorkoutScheduling
+    /// Shows WorkoutKit's sheet if the person has not been asked, and reconciles straight away once
+    /// authorized.
+    ///
+    /// Available on ios only.
+    func plannedWorkoutsRequestScheduling(_ request: Empty) async throws -> WorkoutScheduling
+}
+
+/// Decodes one side of an exchange and re-encodes it, for the bridge-vector runner.
+///
+/// The runner cannot name the request and response types itself without keeping a second copy
+/// of the op table, and a second copy of the op table is the thing this schema exists to
+/// remove. A round trip is also exactly what a vector asserts: the bytes in are the bytes out,
+/// which pins the DTOs and their coders against the same file the other two runners read.
+public enum BridgeCodecs {
+    public static func roundTripRequest(_ op: BridgeOp, _ payload: Data) throws -> Data {
+        let decoder = BridgeDispatch.makeDecoder()
+        let encoder = BridgeDispatch.makeEncoder()
+        switch op {
+        case .clientAttach:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .clientConnect:
+            let value = try decoder.decode(ConnectRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .clientConnections:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .clientDisconnect:
+            let value = try decoder.decode(SourceRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .tokenSetProviderPresent:
+            let value = try decoder.decode(TokenProviderRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .tokenResolve:
+            let value = try decoder.decode(TokenResolveRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .tokenReject:
+            let value = try decoder.decode(TokenRejectRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsRequest:
+            let value = try decoder.decode(PermissionRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsStatus:
+            let value = try decoder.decode(CategoryRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsWriteStatus:
+            let value = try decoder.decode(CategoryRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsRequested:
+            let value = try decoder.decode(SourceRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsStatuses:
+            let value = try decoder.decode(SourceRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsBackgroundReadStatus:
+            let value = try decoder.decode(SourceRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsHistoryReadStatus:
+            let value = try decoder.decode(SourceRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .diagnosticsState:
+            let value = try decoder.decode(SourceRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .diagnosticsLastDelivery:
+            let value = try decoder.decode(SourceRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .diagnosticsReport:
+            let value = try decoder.decode(SourceRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .diagnosticsSend:
+            let value = try decoder.decode(SourceRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .backgroundIsRegistered:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .backgroundCancel:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .bodyHeartRate:
+            let value = try decoder.decode(RangeRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .bodyLogHeartRate:
+            let value = try decoder.decode(HeartRateEntryList.self, from: payload)
+            return try encoder.encode(value)
+        case .bodyLog:
+            let value = try decoder.decode(BodyEntryList.self, from: payload)
+            return try encoder.encode(value)
+        case .bodyDelete:
+            let value = try decoder.decode(RecordIdRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .dailySteps:
+            let value = try decoder.decode(RangeRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .dailyLog:
+            let value = try decoder.decode(StepEntryList.self, from: payload)
+            return try encoder.encode(value)
+        case .dailyDelete:
+            let value = try decoder.decode(RecordIdRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .sleepSegments:
+            let value = try decoder.decode(RangeRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .sleepLog:
+            let value = try decoder.decode(SleepEntryList.self, from: payload)
+            return try encoder.encode(value)
+        case .sleepDelete:
+            let value = try decoder.decode(RecordIdRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .activityWorkouts:
+            let value = try decoder.decode(RangeRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .activityLog:
+            let value = try decoder.decode(WorkoutEntryList.self, from: payload)
+            return try encoder.encode(value)
+        case .activityDelete:
+            let value = try decoder.decode(RecordIdRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .nutritionLog:
+            let value = try decoder.decode(NutritionEntryList.self, from: payload)
+            return try encoder.encode(value)
+        case .nutritionDelete:
+            let value = try decoder.decode(RecordIdRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsPlanned:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsMarkComplete:
+            let value = try decoder.decode(MarkCompleteRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsDelete:
+            let value = try decoder.decode(RecordIdRequest.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsSchedulingStatus:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsRequestScheduling:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        }
+    }
+
+    public static func roundTripResponse(_ op: BridgeOp, _ payload: Data) throws -> Data {
+        let decoder = BridgeDispatch.makeDecoder()
+        let encoder = BridgeDispatch.makeEncoder()
+        switch op {
+        case .clientAttach:
+            let value = try decoder.decode(BootstrapState.self, from: payload)
+            return try encoder.encode(value)
+        case .clientConnect:
+            let value = try decoder.decode(Connection.self, from: payload)
+            return try encoder.encode(value)
+        case .clientConnections:
+            let value = try decoder.decode(ConnectionList.self, from: payload)
+            return try encoder.encode(value)
+        case .clientDisconnect:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .tokenSetProviderPresent:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .tokenResolve:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .tokenReject:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsRequest:
+            let value = try decoder.decode(PermissionGrant.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsStatus:
+            let value = try decoder.decode(StatusResult.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsWriteStatus:
+            let value = try decoder.decode(StatusResult.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsRequested:
+            let value = try decoder.decode(HealthAccess.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsStatuses:
+            let value = try decoder.decode(StatusesResult.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsBackgroundReadStatus:
+            let value = try decoder.decode(StatusResult.self, from: payload)
+            return try encoder.encode(value)
+        case .permissionsHistoryReadStatus:
+            let value = try decoder.decode(StatusResult.self, from: payload)
+            return try encoder.encode(value)
+        case .diagnosticsState:
+            let value = try decoder.decode(DiagnosticsState.self, from: payload)
+            return try encoder.encode(value)
+        case .diagnosticsLastDelivery:
+            let value = try decoder.decode(LastDeliveryResult.self, from: payload)
+            return try encoder.encode(value)
+        case .diagnosticsReport:
+            let value = try decoder.decode(SupportReport.self, from: payload)
+            try SupportReportEnvelope.validate(value)
+            return try encoder.encode(value)
+        case .diagnosticsSend:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .backgroundIsRegistered:
+            let value = try decoder.decode(BoolResult.self, from: payload)
+            return try encoder.encode(value)
+        case .backgroundCancel:
+            let value = try decoder.decode(BoolResult.self, from: payload)
+            return try encoder.encode(value)
+        case .bodyHeartRate:
+            let value = try decoder.decode(HeartRateList.self, from: payload)
+            return try encoder.encode(value)
+        case .bodyLogHeartRate:
+            let value = try decoder.decode(RecordIdList.self, from: payload)
+            return try encoder.encode(value)
+        case .bodyLog:
+            let value = try decoder.decode(RecordIdList.self, from: payload)
+            return try encoder.encode(value)
+        case .bodyDelete:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .dailySteps:
+            let value = try decoder.decode(StepCountList.self, from: payload)
+            return try encoder.encode(value)
+        case .dailyLog:
+            let value = try decoder.decode(RecordIdList.self, from: payload)
+            return try encoder.encode(value)
+        case .dailyDelete:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .sleepSegments:
+            let value = try decoder.decode(SleepSegmentList.self, from: payload)
+            return try encoder.encode(value)
+        case .sleepLog:
+            let value = try decoder.decode(RecordIdList.self, from: payload)
+            return try encoder.encode(value)
+        case .sleepDelete:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .activityWorkouts:
+            let value = try decoder.decode(WorkoutList.self, from: payload)
+            return try encoder.encode(value)
+        case .activityLog:
+            let value = try decoder.decode(RecordIdList.self, from: payload)
+            return try encoder.encode(value)
+        case .activityDelete:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .nutritionLog:
+            let value = try decoder.decode(RecordIdList.self, from: payload)
+            return try encoder.encode(value)
+        case .nutritionDelete:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsPlanned:
+            let value = try decoder.decode(PlannedWorkoutList.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsMarkComplete:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsDelete:
+            let value = try decoder.decode(Empty.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsSchedulingStatus:
+            let value = try decoder.decode(WorkoutScheduling.self, from: payload)
+            return try encoder.encode(value)
+        case .plannedWorkoutsRequestScheduling:
+            let value = try decoder.decode(WorkoutScheduling.self, from: payload)
+            return try encoder.encode(value)
+        }
+    }
+
+    /// One message as a subscription actually delivers it: the envelope, and the element inside.
+    ///
+    /// Both halves, because checking only the envelope would accept a `data` carrying anything
+    /// at all, and checking only the element would accept a stream that never says it failed.
+    public static func roundTripStreamMessage(_ stream: String, _ payload: Data) throws -> Data {
+        let decoder = BridgeDispatch.makeDecoder()
+        let encoder = BridgeDispatch.makeEncoder()
+        let message = try decoder.decode(StreamMessage.self, from: payload)
+        guard case .data(let element) = message else { return try encoder.encode(message) }
+        let inner = try roundTripStreamElement(stream, try encoder.encode(element))
+        let checked = try decoder.decode(BridgeJSON.self, from: inner)
+        return try encoder.encode(StreamMessage.data(element: checked))
+    }
+
+    /// One element of a stream, by that stream's declared type.
+    public static func roundTripStreamElement(_ stream: String, _ payload: Data) throws -> Data {
+        let decoder = BridgeDispatch.makeDecoder()
+        let encoder = BridgeDispatch.makeEncoder()
+        switch stream {
+        case "diagnostics.events":
+            let value = try decoder.decode(TerraEvent.self, from: payload)
+            try TerraEventEnvelope.validate(value)
+            return try encoder.encode(value)
+        case "body.changes":
+            let value = try decoder.decode(HealthChange.self, from: payload)
+            return try encoder.encode(value)
+        case "daily.changes":
+            let value = try decoder.decode(HealthChange.self, from: payload)
+            return try encoder.encode(value)
+        case "sleep.changes":
+            let value = try decoder.decode(HealthChange.self, from: payload)
+            return try encoder.encode(value)
+        case "activity.changes":
+            let value = try decoder.decode(HealthChange.self, from: payload)
+            return try encoder.encode(value)
+        case "bridge.tokenRequest":
+            let value = try decoder.decode(TokenRequest.self, from: payload)
+            return try encoder.encode(value)
+        default:
+            throw BridgeError.unsupportedOnPlatform(op: stream)
+        }
+    }
+}
+
+/// Turns an op string and a JSON payload into a typed call and a JSON answer.
+///
+/// The encoder and decoder are built once and configured for ISO 8601: an instant spelled two
+/// ways between a request and its response is a bug the vectors would catch and the compiler
+/// would not.
+public struct BridgeDispatch: Sendable {
+    private let ops: any TerraBridgeOps
+
+    public init(ops: any TerraBridgeOps) { self.ops = ops }
+
+    public static func makeDecoder() -> JSONDecoder { JSONDecoder() }
+
+    /// Sorted keys, so that two encodings of one value are the same bytes. That is what lets a
+    /// vector be compared rather than parsed and walked, and what makes the three runners
+    /// compare like for like.
+    public static func makeEncoder() -> JSONEncoder {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.sortedKeys]
+        return encoder
+    }
+
+    public static func decodeRequest<Request: Decodable>(
+        _ type: Request.Type,
+        from payload: Data,
+        validate: (Request) throws -> Void = { _ in }
+    ) throws -> Request {
+        do {
+            let request = try makeDecoder().decode(Request.self, from: payload)
+            try validate(request)
+            return request
+        } catch let error as DecodingError {
+            throw BridgeError.invalidPayload(path: path(of: error))
+        }
+    }
+
+    static func path(of error: DecodingError) -> String {
+        let keys: [any CodingKey]
+        switch error {
+        case .typeMismatch(_, let context), .valueNotFound(_, let context), .dataCorrupted(let context):
+            keys = context.codingPath
+        case .keyNotFound(let key, let context):
+            keys = context.codingPath + [key]
+        @unknown default:
+            keys = []
+        }
+        return keys.reduce("$") { path, key in
+            if let index = key.intValue { return "\(path)[\(index)]" }
+            return "\(path).\(key.stringValue)"
+        }
+    }
+
+    public func callAsFunction(op: String, payload: Data) async throws -> Data {
+        // An op string no version of the schema declared: a wrapper and a native half that
+        // disagree. Reported as the same code an op this platform lacks gets, because from the
+        // caller's side the two are indistinguishable and both mean "not available here".
+        guard let known = BridgeOp(rawValue: op) else { throw BridgeError.unsupportedOnPlatform(op: op) }
+        return try await dispatch(known, payload)
+    }
+
+    private func dispatch(_ op: BridgeOp, _ payload: Data) async throws -> Data {
+        let encoder = Self.makeEncoder()
+        switch op {
+        case .clientAttach:
+            let request = try Self.decodeRequest(Empty.self, from: payload)
+            let response = try await ops.clientAttach(request)
+            return try encoder.encode(response)
+        case .clientConnect:
+            let request = try Self.decodeRequest(ConnectRequest.self, from: payload)
+            let response = try await ops.clientConnect(request)
+            return try encoder.encode(response)
+        case .clientConnections:
+            let request = try Self.decodeRequest(Empty.self, from: payload)
+            let response = try await ops.clientConnections(request)
+            return try encoder.encode(response)
+        case .clientDisconnect:
+            let request = try Self.decodeRequest(SourceRequest.self, from: payload)
+            let response = try await ops.clientDisconnect(request)
+            return try encoder.encode(response)
+        case .tokenSetProviderPresent:
+            let request = try Self.decodeRequest(TokenProviderRequest.self, from: payload)
+            let response = try await ops.tokenSetProviderPresent(request)
+            return try encoder.encode(response)
+        case .tokenResolve:
+            let request = try Self.decodeRequest(TokenResolveRequest.self, from: payload)
+            let response = try await ops.tokenResolve(request)
+            return try encoder.encode(response)
+        case .tokenReject:
+            let request = try Self.decodeRequest(TokenRejectRequest.self, from: payload)
+            let response = try await ops.tokenReject(request)
+            return try encoder.encode(response)
+        case .permissionsRequest:
+            let request = try Self.decodeRequest(PermissionRequest.self, from: payload)
+            let response = try await ops.permissionsRequest(request)
+            return try encoder.encode(response)
+        case .permissionsStatus:
+            let request = try Self.decodeRequest(CategoryRequest.self, from: payload)
+            let response = try await ops.permissionsStatus(request)
+            return try encoder.encode(response)
+        case .permissionsWriteStatus:
+            let request = try Self.decodeRequest(CategoryRequest.self, from: payload)
+            let response = try await ops.permissionsWriteStatus(request)
+            return try encoder.encode(response)
+        case .permissionsRequested:
+            let request = try Self.decodeRequest(SourceRequest.self, from: payload)
+            let response = try await ops.permissionsRequested(request)
+            return try encoder.encode(response)
+        case .permissionsStatuses:
+            throw BridgeError.unsupportedOnPlatform(op: op.rawValue)
+        case .permissionsBackgroundReadStatus:
+            throw BridgeError.unsupportedOnPlatform(op: op.rawValue)
+        case .permissionsHistoryReadStatus:
+            throw BridgeError.unsupportedOnPlatform(op: op.rawValue)
+        case .diagnosticsState:
+            let request = try Self.decodeRequest(SourceRequest.self, from: payload)
+            let response = try await ops.diagnosticsState(request)
+            return try encoder.encode(response)
+        case .diagnosticsLastDelivery:
+            let request = try Self.decodeRequest(SourceRequest.self, from: payload)
+            let response = try await ops.diagnosticsLastDelivery(request)
+            return try encoder.encode(response)
+        case .diagnosticsReport:
+            let request = try Self.decodeRequest(SourceRequest.self, from: payload)
+            let response = try await ops.diagnosticsReport(request)
+            try SupportReportEnvelope.validate(response)
+            return try encoder.encode(response)
+        case .diagnosticsSend:
+            let request = try Self.decodeRequest(SourceRequest.self, from: payload)
+            let response = try await ops.diagnosticsSend(request)
+            return try encoder.encode(response)
+        case .backgroundIsRegistered:
+            let request = try Self.decodeRequest(Empty.self, from: payload)
+            let response = try await ops.backgroundIsRegistered(request)
+            return try encoder.encode(response)
+        case .backgroundCancel:
+            throw BridgeError.unsupportedOnPlatform(op: op.rawValue)
+        case .bodyHeartRate:
+            let request = try Self.decodeRequest(RangeRequest.self, from: payload)
+            let response = try await ops.bodyHeartRate(request)
+            return try encoder.encode(response)
+        case .bodyLogHeartRate:
+            let request = try Self.decodeRequest(HeartRateEntryList.self, from: payload)
+            let response = try await ops.bodyLogHeartRate(request)
+            return try encoder.encode(response)
+        case .bodyLog:
+            let request = try Self.decodeRequest(BodyEntryList.self, from: payload)
+            let response = try await ops.bodyLog(request)
+            return try encoder.encode(response)
+        case .bodyDelete:
+            let request = try Self.decodeRequest(RecordIdRequest.self, from: payload)
+            let response = try await ops.bodyDelete(request)
+            return try encoder.encode(response)
+        case .dailySteps:
+            let request = try Self.decodeRequest(RangeRequest.self, from: payload)
+            let response = try await ops.dailySteps(request)
+            return try encoder.encode(response)
+        case .dailyLog:
+            let request = try Self.decodeRequest(StepEntryList.self, from: payload)
+            let response = try await ops.dailyLog(request)
+            return try encoder.encode(response)
+        case .dailyDelete:
+            let request = try Self.decodeRequest(RecordIdRequest.self, from: payload)
+            let response = try await ops.dailyDelete(request)
+            return try encoder.encode(response)
+        case .sleepSegments:
+            let request = try Self.decodeRequest(RangeRequest.self, from: payload)
+            let response = try await ops.sleepSegments(request)
+            return try encoder.encode(response)
+        case .sleepLog:
+            let request = try Self.decodeRequest(SleepEntryList.self, from: payload)
+            let response = try await ops.sleepLog(request)
+            return try encoder.encode(response)
+        case .sleepDelete:
+            let request = try Self.decodeRequest(RecordIdRequest.self, from: payload)
+            let response = try await ops.sleepDelete(request)
+            return try encoder.encode(response)
+        case .activityWorkouts:
+            let request = try Self.decodeRequest(RangeRequest.self, from: payload)
+            let response = try await ops.activityWorkouts(request)
+            return try encoder.encode(response)
+        case .activityLog:
+            let request = try Self.decodeRequest(WorkoutEntryList.self, from: payload)
+            let response = try await ops.activityLog(request)
+            return try encoder.encode(response)
+        case .activityDelete:
+            let request = try Self.decodeRequest(RecordIdRequest.self, from: payload)
+            let response = try await ops.activityDelete(request)
+            return try encoder.encode(response)
+        case .nutritionLog:
+            let request = try Self.decodeRequest(NutritionEntryList.self, from: payload)
+            let response = try await ops.nutritionLog(request)
+            return try encoder.encode(response)
+        case .nutritionDelete:
+            let request = try Self.decodeRequest(RecordIdRequest.self, from: payload)
+            let response = try await ops.nutritionDelete(request)
+            return try encoder.encode(response)
+        case .plannedWorkoutsPlanned:
+            let request = try Self.decodeRequest(Empty.self, from: payload)
+            let response = try await ops.plannedWorkoutsPlanned(request)
+            return try encoder.encode(response)
+        case .plannedWorkoutsMarkComplete:
+            let request = try Self.decodeRequest(MarkCompleteRequest.self, from: payload)
+            let response = try await ops.plannedWorkoutsMarkComplete(request)
+            return try encoder.encode(response)
+        case .plannedWorkoutsDelete:
+            let request = try Self.decodeRequest(RecordIdRequest.self, from: payload)
+            let response = try await ops.plannedWorkoutsDelete(request)
+            return try encoder.encode(response)
+        case .plannedWorkoutsSchedulingStatus:
+            let request = try Self.decodeRequest(Empty.self, from: payload)
+            let response = try await ops.plannedWorkoutsSchedulingStatus(request)
+            return try encoder.encode(response)
+        case .plannedWorkoutsRequestScheduling:
+            let request = try Self.decodeRequest(Empty.self, from: payload)
+            let response = try await ops.plannedWorkoutsRequestScheduling(request)
+            return try encoder.encode(response)
+        }
+    }
+}
+
+/// Every stream the schema declares, including the ones this platform does not publish.
+public enum BridgeStream: String, CaseIterable, Sendable {
+    case diagnosticsEvents = "diagnostics.events"
+    case bodyChanges = "body.changes"
+    case dailyChanges = "daily.changes"
+    case sleepChanges = "sleep.changes"
+    case activityChanges = "activity.changes"
+    case bridgeTokenRequest = "bridge.tokenRequest"
+
+    /// Whether this platform publishes the stream.
+    public var isSupported: Bool {
+        switch self {
+        case .diagnosticsEvents: return true
+        case .bodyChanges: return true
+        case .dailyChanges: return true
+        case .sleepChanges: return true
+        case .activityChanges: return true
+        case .bridgeTokenRequest: return true
+        }
+    }
+}
+
+/// What P3 publishes. One method per stream this platform supports, each a fresh stream per call:
+/// a subscriber that goes away cancels its own source and nobody else's.
+public protocol TerraBridgeStreams: Sendable {
+    /// Every subscriber gets its own native stream, matching the SDK's fresh-stream-per-call
+    /// contract.
+    func diagnosticsEvents(_ params: Empty) async throws -> AsyncStream<TerraEvent>
+    func bodyChanges(_ params: Empty) async throws -> AsyncStream<HealthChange>
+    func dailyChanges(_ params: Empty) async throws -> AsyncStream<HealthChange>
+    func sleepChanges(_ params: Empty) async throws -> AsyncStream<HealthChange>
+    func activityChanges(_ params: Empty) async throws -> AsyncStream<HealthChange>
+    /// Bridge-owned. The broker's ask, not an SDK stream.
+    func bridgeTokenRequest(_ params: Empty) async throws -> AsyncStream<TokenRequest>
+}
+
+public struct BridgeStreamDispatch: Sendable {
+    private let streams: any TerraBridgeStreams
+    private let errorPayload: @Sendable (any Error) -> TerraErrorPayload
+
+    public init(streams: any TerraBridgeStreams, errorPayload: @escaping @Sendable (any Error) -> TerraErrorPayload) {
+        self.streams = streams
+        self.errorPayload = errorPayload
+    }
+
+    public func open(stream: String, params: Data) async throws -> AsyncStream<Data> {
+        guard let known = BridgeStream(rawValue: stream) else { throw BridgeError.unsupportedOnPlatform(op: stream) }
+        switch known {
+        case .diagnosticsEvents:
+            let request = try BridgeDispatch.decodeRequest(Empty.self, from: params)
+            return await framed({ try await streams.diagnosticsEvents(request) }) { try TerraEventEnvelope.validate($0) }
+        case .bodyChanges:
+            let request = try BridgeDispatch.decodeRequest(Empty.self, from: params)
+            return await framed({ try await streams.bodyChanges(request) })
+        case .dailyChanges:
+            let request = try BridgeDispatch.decodeRequest(Empty.self, from: params)
+            return await framed({ try await streams.dailyChanges(request) })
+        case .sleepChanges:
+            let request = try BridgeDispatch.decodeRequest(Empty.self, from: params)
+            return await framed({ try await streams.sleepChanges(request) })
+        case .activityChanges:
+            let request = try BridgeDispatch.decodeRequest(Empty.self, from: params)
+            return await framed({ try await streams.activityChanges(request) })
+        case .bridgeTokenRequest:
+            let request = try BridgeDispatch.decodeRequest(Empty.self, from: params)
+            return await framed({ try await streams.bridgeTokenRequest(request) })
+        }
+    }
+
+    private static func frame<Element: Encodable>(_ element: Element) throws -> Data {
+        let encoder = BridgeDispatch.makeEncoder()
+        let object = try BridgeDispatch.makeDecoder().decode(BridgeJSON.self, from: try encoder.encode(element))
+        return try encoder.encode(StreamMessage.data(element: object))
+    }
+
+    private func framed<Element: Encodable & Sendable>(
+        _ open: () async throws -> AsyncStream<Element>,
+        validate: @escaping @Sendable (Element) throws -> Void = { _ in }
+    ) async -> AsyncStream<Data> {
+        let errorPayload = self.errorPayload
+        let source: AsyncStream<Element>
+        do {
+            source = try await open()
+        } catch {
+            let failed = try? BridgeDispatch.makeEncoder().encode(StreamMessage.error(error: errorPayload(error)))
+            return AsyncStream { continuation in
+                if let failed { continuation.yield(failed) }
+                continuation.finish()
+            }
+        }
+        return AsyncStream { continuation in
+            let task = Task {
+                let encoder = BridgeDispatch.makeEncoder()
+                do {
+                    for await element in source {
+                        try validate(element)
+                        continuation.yield(try Self.frame(element))
+                    }
+                    continuation.yield(try encoder.encode(StreamMessage.complete))
+                } catch {
+                    if let failed = try? encoder.encode(StreamMessage.error(error: errorPayload(error))) {
+                        continuation.yield(failed)
+                    }
+                }
+                continuation.finish()
+            }
+            continuation.onTermination = { _ in task.cancel() }
+        }
+    }
+}
+