@tryterra/react-native 0.0.0-stage → 2.1.0

package/android/src/bridgeCore/kotlin/co/tryterra/sdk/bridge/generated/BridgeOps.kt

@@ -0,0 +1,493 @@
+// Generated from surface/terra-surface.json by surface/gen. Do not edit by hand.
+// Regenerate with: node surface/gen/src/cli.ts generate
+
+package co.tryterra.sdk.bridge.generated
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.serializer
+
+/**
+ * Every op the schema declares, including the ones this platform does not implement.
+ *
+ * The unsupported ones are entries here rather than absent so that dispatch can answer
+ * bridge.unsupported_on_platform deliberately, instead of failing to parse the op.
+ */
+public enum class BridgeOp(public val wire: String, public val isSupported: Boolean) {
+    CLIENT_ATTACH("client.attach", true),
+    CLIENT_CONNECT("client.connect", true),
+    CLIENT_CONNECTIONS("client.connections", true),
+    CLIENT_DISCONNECT("client.disconnect", true),
+    TOKEN_SET_PROVIDER_PRESENT("token.setProviderPresent", true),
+    TOKEN_RESOLVE("token.resolve", true),
+    TOKEN_REJECT("token.reject", true),
+    PERMISSIONS_REQUEST("permissions.request", true),
+    PERMISSIONS_STATUS("permissions.status", true),
+    PERMISSIONS_WRITE_STATUS("permissions.writeStatus", true),
+    PERMISSIONS_REQUESTED("permissions.requested", true),
+    PERMISSIONS_STATUSES("permissions.statuses", true),
+    PERMISSIONS_BACKGROUND_READ_STATUS("permissions.backgroundReadStatus", true),
+    PERMISSIONS_HISTORY_READ_STATUS("permissions.historyReadStatus", true),
+    DIAGNOSTICS_STATE("diagnostics.state", true),
+    DIAGNOSTICS_LAST_DELIVERY("diagnostics.lastDelivery", true),
+    DIAGNOSTICS_REPORT("diagnostics.report", true),
+    DIAGNOSTICS_SEND("diagnostics.send", true),
+    BACKGROUND_IS_REGISTERED("background.isRegistered", true),
+    BACKGROUND_CANCEL("background.cancel", true),
+    BODY_HEART_RATE("body.heartRate", true),
+    BODY_LOG_HEART_RATE("body.logHeartRate", true),
+    BODY_LOG("body.log", true),
+    BODY_DELETE("body.delete", true),
+    DAILY_STEPS("daily.steps", true),
+    DAILY_LOG("daily.log", true),
+    DAILY_DELETE("daily.delete", true),
+    SLEEP_SEGMENTS("sleep.segments", true),
+    SLEEP_LOG("sleep.log", true),
+    SLEEP_DELETE("sleep.delete", true),
+    ACTIVITY_WORKOUTS("activity.workouts", true),
+    ACTIVITY_LOG("activity.log", true),
+    ACTIVITY_DELETE("activity.delete", true),
+    NUTRITION_LOG("nutrition.log", true),
+    NUTRITION_DELETE("nutrition.delete", true),
+    PLANNED_WORKOUTS_PLANNED("plannedWorkouts.planned", false),
+    PLANNED_WORKOUTS_MARK_COMPLETE("plannedWorkouts.markComplete", false),
+    PLANNED_WORKOUTS_DELETE("plannedWorkouts.delete", false),
+    PLANNED_WORKOUTS_SCHEDULING_STATUS("plannedWorkouts.schedulingStatus", false),
+    PLANNED_WORKOUTS_REQUEST_SCHEDULING("plannedWorkouts.requestScheduling", false),
+    ;
+
+    public companion object {
+        private val byWire: Map<String, BridgeOp> = entries.associateBy { it.wire }
+
+        public fun of(wire: String): BridgeOp? = byWire[wire]
+    }
+}
+
+/**
+ * What P2 implements. One suspend function per op this platform supports.
+ *
+ * An op added to the schema stops this module compiling until the implementation grows a
+ * member for it, which is the whole reason the dispatch is generated from the same file.
+ */
+public interface TerraBridgeOps {
+    /**
+     * Reports the native client the JS side is attaching to. Idempotent, and safe to call after a
+     * JS reload.
+     */
+    public suspend fun clientAttach(request: Empty): BootstrapState
+    public suspend fun clientConnect(request: ConnectRequest): Connection
+    public suspend fun clientConnections(request: Empty): ConnectionList
+    public suspend fun clientDisconnect(request: SourceRequest): 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.
+     */
+    public suspend fun tokenSetProviderPresent(request: TokenProviderRequest): Empty
+    /**
+     * An unknown or already-settled requestId is ignored rather than rejected, so a reload cannot
+     * fail a link that has already moved on.
+     */
+    public suspend fun tokenResolve(request: TokenResolveRequest): Empty
+    public suspend fun tokenReject(request: TokenRejectRequest): Empty
+    public suspend fun permissionsRequest(request: PermissionRequest): PermissionGrant
+    public suspend fun permissionsStatus(request: CategoryRequest): StatusResult
+    public suspend fun permissionsWriteStatus(request: CategoryRequest): StatusResult
+    public suspend fun permissionsRequested(request: SourceRequest): HealthAccess
+    /** Available on android only. */
+    public suspend fun permissionsStatuses(request: SourceRequest): StatusesResult
+    /** Available on android only. */
+    public suspend fun permissionsBackgroundReadStatus(request: SourceRequest): StatusResult
+    /** Available on android only. */
+    public suspend fun permissionsHistoryReadStatus(request: SourceRequest): StatusResult
+    public suspend fun diagnosticsState(request: SourceRequest): DiagnosticsState
+    public suspend fun diagnosticsLastDelivery(request: SourceRequest): LastDeliveryResult
+    public suspend fun diagnosticsReport(request: SourceRequest): SupportReport
+    public suspend fun diagnosticsSend(request: SourceRequest): Empty
+    /**
+     * False means bootstrap did not run. The SDK reports the same thing independently as
+     * backgroundRefreshUnscheduled.
+     */
+    public suspend fun backgroundIsRegistered(request: Empty): BoolResult
+    /** Available on android only. */
+    public suspend fun backgroundCancel(request: Empty): BoolResult
+    public suspend fun bodyHeartRate(request: RangeRequest): HeartRateList
+    /** Its own op rather than an overload: Swift overloads log by element type and JS cannot. */
+    public suspend fun bodyLogHeartRate(request: HeartRateEntryList): RecordIdList
+    public suspend fun bodyLog(request: BodyEntryList): RecordIdList
+    public suspend fun bodyDelete(request: RecordIdRequest): Empty
+    public suspend fun dailySteps(request: RangeRequest): StepCountList
+    public suspend fun dailyLog(request: StepEntryList): RecordIdList
+    public suspend fun dailyDelete(request: RecordIdRequest): Empty
+    public suspend fun sleepSegments(request: RangeRequest): SleepSegmentList
+    public suspend fun sleepLog(request: SleepEntryList): RecordIdList
+    public suspend fun sleepDelete(request: RecordIdRequest): Empty
+    public suspend fun activityWorkouts(request: RangeRequest): WorkoutList
+    public suspend fun activityLog(request: WorkoutEntryList): RecordIdList
+    public suspend fun activityDelete(request: RecordIdRequest): Empty
+    public suspend fun nutritionLog(request: NutritionEntryList): RecordIdList
+    public suspend fun nutritionDelete(request: RecordIdRequest): Empty
+}
+
+/**
+ * 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 serializer against the same file the other two runners read.
+ */
+public object BridgeCodecs {
+    public fun roundTripRequest(op: BridgeOp, payload: String, json: Json = BridgeDispatch.defaultJson): String =
+        when (op) {
+            BridgeOp.CLIENT_ATTACH -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.CLIENT_CONNECT -> json.encodeToString(json.decodeFromString<ConnectRequest>(payload))
+            BridgeOp.CLIENT_CONNECTIONS -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.CLIENT_DISCONNECT -> json.encodeToString(json.decodeFromString<SourceRequest>(payload))
+            BridgeOp.TOKEN_SET_PROVIDER_PRESENT -> json.encodeToString(json.decodeFromString<TokenProviderRequest>(payload))
+            BridgeOp.TOKEN_RESOLVE -> json.encodeToString(json.decodeFromString<TokenResolveRequest>(payload))
+            BridgeOp.TOKEN_REJECT -> json.encodeToString(json.decodeFromString<TokenRejectRequest>(payload))
+            BridgeOp.PERMISSIONS_REQUEST -> json.encodeToString(json.decodeFromString<PermissionRequest>(payload))
+            BridgeOp.PERMISSIONS_STATUS -> json.encodeToString(json.decodeFromString<CategoryRequest>(payload))
+            BridgeOp.PERMISSIONS_WRITE_STATUS -> json.encodeToString(json.decodeFromString<CategoryRequest>(payload))
+            BridgeOp.PERMISSIONS_REQUESTED -> json.encodeToString(json.decodeFromString<SourceRequest>(payload))
+            BridgeOp.PERMISSIONS_STATUSES -> json.encodeToString(json.decodeFromString<SourceRequest>(payload))
+            BridgeOp.PERMISSIONS_BACKGROUND_READ_STATUS -> json.encodeToString(json.decodeFromString<SourceRequest>(payload))
+            BridgeOp.PERMISSIONS_HISTORY_READ_STATUS -> json.encodeToString(json.decodeFromString<SourceRequest>(payload))
+            BridgeOp.DIAGNOSTICS_STATE -> json.encodeToString(json.decodeFromString<SourceRequest>(payload))
+            BridgeOp.DIAGNOSTICS_LAST_DELIVERY -> json.encodeToString(json.decodeFromString<SourceRequest>(payload))
+            BridgeOp.DIAGNOSTICS_REPORT -> json.encodeToString(json.decodeFromString<SourceRequest>(payload))
+            BridgeOp.DIAGNOSTICS_SEND -> json.encodeToString(json.decodeFromString<SourceRequest>(payload))
+            BridgeOp.BACKGROUND_IS_REGISTERED -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.BACKGROUND_CANCEL -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.BODY_HEART_RATE -> json.encodeToString(json.decodeFromString<RangeRequest>(payload))
+            BridgeOp.BODY_LOG_HEART_RATE -> json.encodeToString(json.decodeFromString<HeartRateEntryList>(payload))
+            BridgeOp.BODY_LOG -> json.encodeToString(json.decodeFromString<BodyEntryList>(payload))
+            BridgeOp.BODY_DELETE -> json.encodeToString(json.decodeFromString<RecordIdRequest>(payload))
+            BridgeOp.DAILY_STEPS -> json.encodeToString(json.decodeFromString<RangeRequest>(payload))
+            BridgeOp.DAILY_LOG -> json.encodeToString(json.decodeFromString<StepEntryList>(payload))
+            BridgeOp.DAILY_DELETE -> json.encodeToString(json.decodeFromString<RecordIdRequest>(payload))
+            BridgeOp.SLEEP_SEGMENTS -> json.encodeToString(json.decodeFromString<RangeRequest>(payload))
+            BridgeOp.SLEEP_LOG -> json.encodeToString(json.decodeFromString<SleepEntryList>(payload))
+            BridgeOp.SLEEP_DELETE -> json.encodeToString(json.decodeFromString<RecordIdRequest>(payload))
+            BridgeOp.ACTIVITY_WORKOUTS -> json.encodeToString(json.decodeFromString<RangeRequest>(payload))
+            BridgeOp.ACTIVITY_LOG -> json.encodeToString(json.decodeFromString<WorkoutEntryList>(payload))
+            BridgeOp.ACTIVITY_DELETE -> json.encodeToString(json.decodeFromString<RecordIdRequest>(payload))
+            BridgeOp.NUTRITION_LOG -> json.encodeToString(json.decodeFromString<NutritionEntryList>(payload))
+            BridgeOp.NUTRITION_DELETE -> json.encodeToString(json.decodeFromString<RecordIdRequest>(payload))
+            BridgeOp.PLANNED_WORKOUTS_PLANNED -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.PLANNED_WORKOUTS_MARK_COMPLETE -> json.encodeToString(json.decodeFromString<MarkCompleteRequest>(payload))
+            BridgeOp.PLANNED_WORKOUTS_DELETE -> json.encodeToString(json.decodeFromString<RecordIdRequest>(payload))
+            BridgeOp.PLANNED_WORKOUTS_SCHEDULING_STATUS -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.PLANNED_WORKOUTS_REQUEST_SCHEDULING -> json.encodeToString(json.decodeFromString<Empty>(payload))
+        }
+
+    public fun roundTripResponse(op: BridgeOp, payload: String, json: Json = BridgeDispatch.defaultJson): String =
+        when (op) {
+            BridgeOp.CLIENT_ATTACH -> json.encodeToString(json.decodeFromString<BootstrapState>(payload))
+            BridgeOp.CLIENT_CONNECT -> json.encodeToString(json.decodeFromString<Connection>(payload))
+            BridgeOp.CLIENT_CONNECTIONS -> json.encodeToString(json.decodeFromString<ConnectionList>(payload))
+            BridgeOp.CLIENT_DISCONNECT -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.TOKEN_SET_PROVIDER_PRESENT -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.TOKEN_RESOLVE -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.TOKEN_REJECT -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.PERMISSIONS_REQUEST -> json.encodeToString(json.decodeFromString<PermissionGrant>(payload))
+            BridgeOp.PERMISSIONS_STATUS -> json.encodeToString(json.decodeFromString<StatusResult>(payload))
+            BridgeOp.PERMISSIONS_WRITE_STATUS -> json.encodeToString(json.decodeFromString<StatusResult>(payload))
+            BridgeOp.PERMISSIONS_REQUESTED -> json.encodeToString(json.decodeFromString<HealthAccess>(payload))
+            BridgeOp.PERMISSIONS_STATUSES -> json.encodeToString(json.decodeFromString<StatusesResult>(payload))
+            BridgeOp.PERMISSIONS_BACKGROUND_READ_STATUS -> json.encodeToString(json.decodeFromString<StatusResult>(payload))
+            BridgeOp.PERMISSIONS_HISTORY_READ_STATUS -> json.encodeToString(json.decodeFromString<StatusResult>(payload))
+            BridgeOp.DIAGNOSTICS_STATE -> json.encodeToString(json.decodeFromString<DiagnosticsState>(payload))
+            BridgeOp.DIAGNOSTICS_LAST_DELIVERY -> json.encodeToString(json.decodeFromString<LastDeliveryResult>(payload))
+            BridgeOp.DIAGNOSTICS_REPORT -> {
+                val value = json.decodeFromString<SupportReport>(payload)
+                SupportReportEnvelope.validate(value)
+                json.encodeToString(value)
+            }
+            BridgeOp.DIAGNOSTICS_SEND -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.BACKGROUND_IS_REGISTERED -> json.encodeToString(json.decodeFromString<BoolResult>(payload))
+            BridgeOp.BACKGROUND_CANCEL -> json.encodeToString(json.decodeFromString<BoolResult>(payload))
+            BridgeOp.BODY_HEART_RATE -> json.encodeToString(json.decodeFromString<HeartRateList>(payload))
+            BridgeOp.BODY_LOG_HEART_RATE -> json.encodeToString(json.decodeFromString<RecordIdList>(payload))
+            BridgeOp.BODY_LOG -> json.encodeToString(json.decodeFromString<RecordIdList>(payload))
+            BridgeOp.BODY_DELETE -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.DAILY_STEPS -> json.encodeToString(json.decodeFromString<StepCountList>(payload))
+            BridgeOp.DAILY_LOG -> json.encodeToString(json.decodeFromString<RecordIdList>(payload))
+            BridgeOp.DAILY_DELETE -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.SLEEP_SEGMENTS -> json.encodeToString(json.decodeFromString<SleepSegmentList>(payload))
+            BridgeOp.SLEEP_LOG -> json.encodeToString(json.decodeFromString<RecordIdList>(payload))
+            BridgeOp.SLEEP_DELETE -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.ACTIVITY_WORKOUTS -> json.encodeToString(json.decodeFromString<WorkoutList>(payload))
+            BridgeOp.ACTIVITY_LOG -> json.encodeToString(json.decodeFromString<RecordIdList>(payload))
+            BridgeOp.ACTIVITY_DELETE -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.NUTRITION_LOG -> json.encodeToString(json.decodeFromString<RecordIdList>(payload))
+            BridgeOp.NUTRITION_DELETE -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.PLANNED_WORKOUTS_PLANNED -> json.encodeToString(json.decodeFromString<PlannedWorkoutList>(payload))
+            BridgeOp.PLANNED_WORKOUTS_MARK_COMPLETE -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.PLANNED_WORKOUTS_DELETE -> json.encodeToString(json.decodeFromString<Empty>(payload))
+            BridgeOp.PLANNED_WORKOUTS_SCHEDULING_STATUS -> json.encodeToString(json.decodeFromString<WorkoutScheduling>(payload))
+            BridgeOp.PLANNED_WORKOUTS_REQUEST_SCHEDULING -> json.encodeToString(json.decodeFromString<WorkoutScheduling>(payload))
+        }
+
+    /** One element of a stream, by that stream's declared type. */
+    public fun roundTripStreamElement(stream: String, payload: String, json: Json = BridgeDispatch.defaultJson): String =
+        when (stream) {
+            "diagnostics.events" -> {
+                val value = json.decodeFromString<TerraEvent>(payload)
+                TerraEventEnvelope.validate(value)
+                json.encodeToString(value)
+            }
+            "body.changes" -> json.encodeToString(json.decodeFromString<HealthChange>(payload))
+            "daily.changes" -> json.encodeToString(json.decodeFromString<HealthChange>(payload))
+            "sleep.changes" -> json.encodeToString(json.decodeFromString<HealthChange>(payload))
+            "activity.changes" -> json.encodeToString(json.decodeFromString<HealthChange>(payload))
+            "bridge.tokenRequest" -> json.encodeToString(json.decodeFromString<TokenRequest>(payload))
+            else -> throw BridgeError.UnsupportedOnPlatform(stream)
+        }
+
+    /**
+     * 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 fun roundTripStreamMessage(stream: String, payload: String, json: Json = BridgeDispatch.defaultJson): String {
+        val message = json.decodeFromString<StreamMessage>(payload)
+        return when (message) {
+            is StreamMessage.Data ->
+                json.encodeToString<StreamMessage>(
+                    StreamMessage.Data(
+                        element = json.decodeFromString<JsonObject>(
+                            roundTripStreamElement(stream, json.encodeToString(message.element), json),
+                        ),
+                    ),
+                )
+            else -> json.encodeToString<StreamMessage>(message)
+        }
+    }
+}
+
+/**
+ * kotlinx's own message carries the input, which may be a health sample, so only the path is
+ * lifted out of it.
+ */
+internal inline fun <reified T> Json.decodeRequest(payload: String, validate: (T) -> Unit = {}): T =
+    try {
+        decodeFromString<T>(payload).also(validate)
+    } catch (malformed: IllegalArgumentException) {
+        throw BridgeError.InvalidPayload(BridgeDispatch.pathOf(malformed))
+    }
+
+/**
+ * Turns an op string and a JSON payload into a typed call and a JSON answer.
+ *
+ * `when` as an expression over BridgeOp, with no else: the compiler, not a test, is what
+ * notices an op the schema added and this file has not handled.
+ */
+public class BridgeDispatch(
+    private val ops: TerraBridgeOps,
+    private val json: Json = defaultJson,
+) {
+    public suspend fun dispatch(op: String, payload: String): String {
+        val known = BridgeOp.of(op) ?: throw BridgeError.UnsupportedOnPlatform(op)
+        return when (known) {
+            BridgeOp.CLIENT_ATTACH ->
+                json.encodeToString(ops.clientAttach(json.decodeRequest<Empty>(payload)))
+            BridgeOp.CLIENT_CONNECT ->
+                json.encodeToString(ops.clientConnect(json.decodeRequest<ConnectRequest>(payload)))
+            BridgeOp.CLIENT_CONNECTIONS ->
+                json.encodeToString(ops.clientConnections(json.decodeRequest<Empty>(payload)))
+            BridgeOp.CLIENT_DISCONNECT ->
+                json.encodeToString(ops.clientDisconnect(json.decodeRequest<SourceRequest>(payload)))
+            BridgeOp.TOKEN_SET_PROVIDER_PRESENT ->
+                json.encodeToString(ops.tokenSetProviderPresent(json.decodeRequest<TokenProviderRequest>(payload)))
+            BridgeOp.TOKEN_RESOLVE ->
+                json.encodeToString(ops.tokenResolve(json.decodeRequest<TokenResolveRequest>(payload)))
+            BridgeOp.TOKEN_REJECT ->
+                json.encodeToString(ops.tokenReject(json.decodeRequest<TokenRejectRequest>(payload)))
+            BridgeOp.PERMISSIONS_REQUEST ->
+                json.encodeToString(ops.permissionsRequest(json.decodeRequest<PermissionRequest>(payload)))
+            BridgeOp.PERMISSIONS_STATUS ->
+                json.encodeToString(ops.permissionsStatus(json.decodeRequest<CategoryRequest>(payload)))
+            BridgeOp.PERMISSIONS_WRITE_STATUS ->
+                json.encodeToString(ops.permissionsWriteStatus(json.decodeRequest<CategoryRequest>(payload)))
+            BridgeOp.PERMISSIONS_REQUESTED ->
+                json.encodeToString(ops.permissionsRequested(json.decodeRequest<SourceRequest>(payload)))
+            BridgeOp.PERMISSIONS_STATUSES ->
+                json.encodeToString(ops.permissionsStatuses(json.decodeRequest<SourceRequest>(payload)))
+            BridgeOp.PERMISSIONS_BACKGROUND_READ_STATUS ->
+                json.encodeToString(ops.permissionsBackgroundReadStatus(json.decodeRequest<SourceRequest>(payload)))
+            BridgeOp.PERMISSIONS_HISTORY_READ_STATUS ->
+                json.encodeToString(ops.permissionsHistoryReadStatus(json.decodeRequest<SourceRequest>(payload)))
+            BridgeOp.DIAGNOSTICS_STATE ->
+                json.encodeToString(ops.diagnosticsState(json.decodeRequest<SourceRequest>(payload)))
+            BridgeOp.DIAGNOSTICS_LAST_DELIVERY ->
+                json.encodeToString(ops.diagnosticsLastDelivery(json.decodeRequest<SourceRequest>(payload)))
+            BridgeOp.DIAGNOSTICS_REPORT -> {
+                val request = json.decodeRequest<SourceRequest>(payload)
+                val response = ops.diagnosticsReport(request)
+                SupportReportEnvelope.validate(response)
+                json.encodeToString(response)
+            }
+            BridgeOp.DIAGNOSTICS_SEND ->
+                json.encodeToString(ops.diagnosticsSend(json.decodeRequest<SourceRequest>(payload)))
+            BridgeOp.BACKGROUND_IS_REGISTERED ->
+                json.encodeToString(ops.backgroundIsRegistered(json.decodeRequest<Empty>(payload)))
+            BridgeOp.BACKGROUND_CANCEL ->
+                json.encodeToString(ops.backgroundCancel(json.decodeRequest<Empty>(payload)))
+            BridgeOp.BODY_HEART_RATE ->
+                json.encodeToString(ops.bodyHeartRate(json.decodeRequest<RangeRequest>(payload)))
+            BridgeOp.BODY_LOG_HEART_RATE ->
+                json.encodeToString(ops.bodyLogHeartRate(json.decodeRequest<HeartRateEntryList>(payload)))
+            BridgeOp.BODY_LOG ->
+                json.encodeToString(ops.bodyLog(json.decodeRequest<BodyEntryList>(payload)))
+            BridgeOp.BODY_DELETE ->
+                json.encodeToString(ops.bodyDelete(json.decodeRequest<RecordIdRequest>(payload)))
+            BridgeOp.DAILY_STEPS ->
+                json.encodeToString(ops.dailySteps(json.decodeRequest<RangeRequest>(payload)))
+            BridgeOp.DAILY_LOG ->
+                json.encodeToString(ops.dailyLog(json.decodeRequest<StepEntryList>(payload)))
+            BridgeOp.DAILY_DELETE ->
+                json.encodeToString(ops.dailyDelete(json.decodeRequest<RecordIdRequest>(payload)))
+            BridgeOp.SLEEP_SEGMENTS ->
+                json.encodeToString(ops.sleepSegments(json.decodeRequest<RangeRequest>(payload)))
+            BridgeOp.SLEEP_LOG ->
+                json.encodeToString(ops.sleepLog(json.decodeRequest<SleepEntryList>(payload)))
+            BridgeOp.SLEEP_DELETE ->
+                json.encodeToString(ops.sleepDelete(json.decodeRequest<RecordIdRequest>(payload)))
+            BridgeOp.ACTIVITY_WORKOUTS ->
+                json.encodeToString(ops.activityWorkouts(json.decodeRequest<RangeRequest>(payload)))
+            BridgeOp.ACTIVITY_LOG ->
+                json.encodeToString(ops.activityLog(json.decodeRequest<WorkoutEntryList>(payload)))
+            BridgeOp.ACTIVITY_DELETE ->
+                json.encodeToString(ops.activityDelete(json.decodeRequest<RecordIdRequest>(payload)))
+            BridgeOp.NUTRITION_LOG ->
+                json.encodeToString(ops.nutritionLog(json.decodeRequest<NutritionEntryList>(payload)))
+            BridgeOp.NUTRITION_DELETE ->
+                json.encodeToString(ops.nutritionDelete(json.decodeRequest<RecordIdRequest>(payload)))
+            BridgeOp.PLANNED_WORKOUTS_PLANNED -> throw BridgeError.UnsupportedOnPlatform(known.wire)
+            BridgeOp.PLANNED_WORKOUTS_MARK_COMPLETE -> throw BridgeError.UnsupportedOnPlatform(known.wire)
+            BridgeOp.PLANNED_WORKOUTS_DELETE -> throw BridgeError.UnsupportedOnPlatform(known.wire)
+            BridgeOp.PLANNED_WORKOUTS_SCHEDULING_STATUS -> throw BridgeError.UnsupportedOnPlatform(known.wire)
+            BridgeOp.PLANNED_WORKOUTS_REQUEST_SCHEDULING -> throw BridgeError.UnsupportedOnPlatform(known.wire)
+        }
+    }
+
+    public companion object {
+        /**
+         * encodeDefaults is on because a DTO field left at its default still has to reach the
+         * other side: a response that omitted `userEntered: false` would decode as absent there.
+         */
+        private val PATH: Regex = Regex("""at path: (\$\S*)""")
+
+        /** `$.entries[2].start`, or `$` when the failure names no path. */
+        public fun pathOf(error: Throwable): String = error.message?.let { PATH.find(it)?.groupValues?.get(1) } ?: "$"
+
+        public val defaultJson: Json = Json {
+            encodeDefaults = true
+            explicitNulls = false
+            ignoreUnknownKeys = true
+        }
+    }
+}
+
+/** Every stream the schema declares, including the ones this platform does not publish. */
+public enum class BridgeStream(public val wire: String, public val isSupported: Boolean) {
+    DIAGNOSTICS_EVENTS("diagnostics.events", true),
+    BODY_CHANGES("body.changes", true),
+    DAILY_CHANGES("daily.changes", true),
+    SLEEP_CHANGES("sleep.changes", true),
+    ACTIVITY_CHANGES("activity.changes", true),
+    BRIDGE_TOKEN_REQUEST("bridge.tokenRequest", true),
+    ;
+
+    public companion object {
+        private val byWire: Map<String, BridgeStream> = entries.associateBy { it.wire }
+
+        public fun of(wire: String): BridgeStream? = byWire[wire]
+    }
+}
+
+/**
+ * What P2 publishes. One function per stream this platform supports, each a fresh flow per
+ * call: a subscriber that goes away cancels its own collection and nobody else's.
+ */
+public interface TerraBridgeStreams {
+    /**
+     * Every subscriber gets its own native stream, matching the SDK's fresh-stream-per-call
+     * contract.
+     */
+    public fun diagnosticsEvents(params: Empty): Flow<TerraEvent>
+    public fun bodyChanges(params: Empty): Flow<HealthChange>
+    public fun dailyChanges(params: Empty): Flow<HealthChange>
+    public fun sleepChanges(params: Empty): Flow<HealthChange>
+    public fun activityChanges(params: Empty): Flow<HealthChange>
+    /** Bridge-owned. The broker's ask, not an SDK stream. */
+    public fun bridgeTokenRequest(params: Empty): Flow<TokenRequest>
+}
+
+public class BridgeStreamDispatch(
+    private val streams: TerraBridgeStreams,
+    private val errorPayload: (Throwable) -> TerraErrorPayload,
+    private val json: Json = BridgeDispatch.defaultJson,
+) {
+    public fun open(stream: String, params: String): Flow<String> {
+        val known = BridgeStream.of(stream) ?: throw BridgeError.UnsupportedOnPlatform(stream)
+        val messages = when (known) {
+            BridgeStream.DIAGNOSTICS_EVENTS -> {
+                val request = json.decodeRequest<Empty>(params)
+                flow { emitAll(streams.diagnosticsEvents(request)) }.map { element ->
+                    TerraEventEnvelope.validate(element)
+                    frame(serializer<TerraEvent>(), element)
+                }
+            }
+            BridgeStream.BODY_CHANGES -> {
+                val request = json.decodeRequest<Empty>(params)
+                flow { emitAll(streams.bodyChanges(request)) }.map { element ->
+                    frame(serializer<HealthChange>(), element)
+                }
+            }
+            BridgeStream.DAILY_CHANGES -> {
+                val request = json.decodeRequest<Empty>(params)
+                flow { emitAll(streams.dailyChanges(request)) }.map { element ->
+                    frame(serializer<HealthChange>(), element)
+                }
+            }
+            BridgeStream.SLEEP_CHANGES -> {
+                val request = json.decodeRequest<Empty>(params)
+                flow { emitAll(streams.sleepChanges(request)) }.map { element ->
+                    frame(serializer<HealthChange>(), element)
+                }
+            }
+            BridgeStream.ACTIVITY_CHANGES -> {
+                val request = json.decodeRequest<Empty>(params)
+                flow { emitAll(streams.activityChanges(request)) }.map { element ->
+                    frame(serializer<HealthChange>(), element)
+                }
+            }
+            BridgeStream.BRIDGE_TOKEN_REQUEST -> {
+                val request = json.decodeRequest<Empty>(params)
+                flow { emitAll(streams.bridgeTokenRequest(request)) }.map { element ->
+                    frame(serializer<TokenRequest>(), element)
+                }
+            }
+        }
+        return messages
+            .onCompletion { cause -> if (cause == null) emit(encode(StreamMessage.Complete)) }
+            .catch { failure -> emit(encode(StreamMessage.Error(error = errorPayload(failure)))) }
+    }
+
+    private fun <T> frame(serializer: KSerializer<T>, element: T): String =
+        encode(StreamMessage.Data(element = json.encodeToJsonElement(serializer, element).jsonObject))
+
+    private fun encode(message: StreamMessage): String = json.encodeToString(StreamMessage.serializer(), message)
+}
+