@tryterra/react-native 0.0.0-stage → 2.1.0

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

@@ -0,0 +1,468 @@
+package co.tryterra.sdk.bridge
+
+import co.tryterra.sdk.DataCategory
+import co.tryterra.sdk.EndUser
+import co.tryterra.sdk.BodyEntry
+import co.tryterra.sdk.HeartRateEntry
+import co.tryterra.sdk.NutritionEntry
+import co.tryterra.sdk.HeartRateSample
+import co.tryterra.sdk.PermissionStatus
+import co.tryterra.sdk.RecordId
+import co.tryterra.sdk.SampleInterval
+import co.tryterra.sdk.SampleSource
+import co.tryterra.sdk.SleepEntry
+import co.tryterra.sdk.SleepSegment
+import co.tryterra.sdk.SleepStage
+import co.tryterra.sdk.Source
+import co.tryterra.sdk.StepCount
+import co.tryterra.sdk.StepEntry
+import co.tryterra.sdk.TimeRange
+import co.tryterra.sdk.Workout
+import co.tryterra.sdk.WorkoutActivity
+import co.tryterra.sdk.WorkoutEntry
+import co.tryterra.sdk.WorkoutScope
+import co.tryterra.sdk.bridge.generated.BridgeInstant
+import co.tryterra.sdk.bridge.generated.BridgeError
+import co.tryterra.sdk.diagnostics.BackgroundRestrictionReason
+import co.tryterra.sdk.diagnostics.DiagnosticsState
+import co.tryterra.sdk.diagnostics.DiagnosticsWire
+import co.tryterra.sdk.diagnostics.SupportReport
+import co.tryterra.sdk.diagnostics.TerraEvent
+import co.tryterra.sdk.health.HealthAccess
+import co.tryterra.sdk.HealthChange
+import co.tryterra.sdk.store.StoredConnection
+import java.time.ZoneId
+import co.tryterra.sdk.bridge.generated.BackgroundRestrictionReason as WireRestriction
+import co.tryterra.sdk.bridge.generated.BodyEntry as WireBodyEntry
+import co.tryterra.sdk.bridge.generated.Connection as WireConnection
+import co.tryterra.sdk.bridge.generated.NutritionEntry as WireNutritionEntry
+import co.tryterra.sdk.bridge.generated.Nutrients as WireNutrients
+import co.tryterra.sdk.bridge.generated.DataCategory as WireCategory
+import co.tryterra.sdk.bridge.generated.DiagnosticsState as WireDiagnosticsState
+import co.tryterra.sdk.bridge.generated.EndUser as WireEndUser
+import co.tryterra.sdk.bridge.generated.HealthAccess as WireHealthAccess
+import co.tryterra.sdk.bridge.generated.HealthChange as WireHealthChange
+import co.tryterra.sdk.bridge.generated.HeartRateEntry as WireHeartRateEntry
+import co.tryterra.sdk.bridge.generated.HeartRateSample as WireHeartRateSample
+import co.tryterra.sdk.bridge.generated.MotionContext as WireMotionContext
+import co.tryterra.sdk.bridge.generated.PermissionStatus as WirePermissionStatus
+import co.tryterra.sdk.bridge.generated.SampleSource as WireSampleSource
+import co.tryterra.sdk.bridge.generated.SleepEntry as WireSleepEntry
+import co.tryterra.sdk.bridge.generated.SleepSegment as WireSleepSegment
+import co.tryterra.sdk.bridge.generated.SleepStage as WireSleepStage
+import co.tryterra.sdk.bridge.generated.Source as WireSource
+import co.tryterra.sdk.bridge.generated.StepCount as WireStepCount
+import co.tryterra.sdk.bridge.generated.StepEntry as WireStepEntry
+import co.tryterra.sdk.bridge.generated.SupportReport as WireSupportReport
+import co.tryterra.sdk.bridge.generated.TerraEvent as WireTerraEvent
+import co.tryterra.sdk.bridge.generated.TimeRange as WireTimeRange
+import co.tryterra.sdk.bridge.generated.Workout as WireWorkout
+import co.tryterra.sdk.bridge.generated.WorkoutActivity as WireWorkoutActivity
+import co.tryterra.sdk.bridge.generated.WorkoutEntry as WireWorkoutEntry
+import co.tryterra.sdk.bridge.generated.WorkoutScope as WireWorkoutScope
+
+/**
+ * Between the SDK's types and the generated wire DTOs, in one place.
+ *
+ * Every `when` here is exhaustive over a sealed type or an enum with no `else`, which is what makes
+ * a case added to the SDK a compile error in this file rather than a value that quietly maps to
+ * something plausible. That is lock 1 of the four, and it is the lock the old wrapper did not have:
+ * `TerraReactModule.java` and `TerraReact.swift` each carried a `switch` with a fall-through, and a
+ * data type stopped travelling without anything going red.
+ *
+ * The SDK's models are deliberately not `@Serializable`. Keeping the wire shape out of the SDK's
+ * public types is the better boundary, and the price of it is this file.
+ */
+internal object Conversions {
+
+    // ---- enums ------------------------------------------------------------------------------
+
+    fun source(wire: WireSource): Source = when (wire) {
+        WireSource.HEALTH -> Source.HEALTH
+        WireSource.SAMSUNG_HEALTH -> Source.SAMSUNG_HEALTH
+    }
+
+    fun source(source: Source): WireSource = when (source) {
+        Source.HEALTH -> WireSource.HEALTH
+        Source.SAMSUNG_HEALTH -> WireSource.SAMSUNG_HEALTH
+    }
+
+    /**
+     * The four categories the wrapper projects.
+     *
+     * `MENSTRUATION` is excluded in the surface with a reason, so a request naming it cannot arrive
+     * - the generated enum has no entry for it - and a value coming *out* of the SDK for it would
+     * be a category the wrapper has no type for. Refusing it names the situation instead of
+     * substituting a neighbour.
+     */
+    fun category(wire: WireCategory): DataCategory = when (wire) {
+        WireCategory.ACTIVITY -> DataCategory.ACTIVITY
+        WireCategory.BODY -> DataCategory.BODY
+        WireCategory.DAILY -> DataCategory.DAILY
+        WireCategory.SLEEP -> DataCategory.SLEEP
+        WireCategory.NUTRITION -> DataCategory.NUTRITION
+    }
+
+    fun category(category: DataCategory): WireCategory? = when (category) {
+        DataCategory.ACTIVITY -> WireCategory.ACTIVITY
+        DataCategory.BODY -> WireCategory.BODY
+        DataCategory.DAILY -> WireCategory.DAILY
+        DataCategory.SLEEP -> WireCategory.SLEEP
+        DataCategory.NUTRITION -> WireCategory.NUTRITION
+        DataCategory.MENSTRUATION -> null
+    }
+
+    /**
+     * `UNAVAILABLE` is Apple's and has no Android counterpart, so nothing here can produce it.
+     *
+     * The surface types it as iOS-only for exactly that reason: a caller narrowing on it is writing
+     * iOS-specific code, and the type says so rather than letting them discover it.
+     */
+    fun permissionStatus(status: PermissionStatus): WirePermissionStatus = when (status) {
+        PermissionStatus.GRANTED -> WirePermissionStatus.GRANTED
+        PermissionStatus.DENIED -> WirePermissionStatus.DENIED
+        PermissionStatus.NOT_DETERMINED -> WirePermissionStatus.NOT_DETERMINED
+        PermissionStatus.NOT_DISCLOSED -> WirePermissionStatus.NOT_DISCLOSED
+        PermissionStatus.UNSUPPORTED -> WirePermissionStatus.UNSUPPORTED
+    }
+
+    fun restriction(reason: BackgroundRestrictionReason): WireRestriction = when (reason) {
+        BackgroundRestrictionReason.OEM_RESTRICTED -> WireRestriction.OEM_RESTRICTED
+        BackgroundRestrictionReason.BACKGROUND_READ_DENIED -> WireRestriction.BACKGROUND_READ_DENIED
+        BackgroundRestrictionReason.HEALTH_CONNECT_FEATURE_UNAVAILABLE ->
+            WireRestriction.HEALTH_CONNECT_FEATURE_UNAVAILABLE
+        BackgroundRestrictionReason.STORE_FEATURE_UNAVAILABLE -> WireRestriction.STORE_FEATURE_UNAVAILABLE
+        BackgroundRestrictionReason.TICKS_NOT_RUNNING -> WireRestriction.TICKS_NOT_RUNNING
+    }
+
+    // ---- unions -----------------------------------------------------------------------------
+
+    fun endUser(wire: WireEndUser): EndUser = when (wire) {
+        is WireEndUser.Reference -> EndUser.Reference(wire.id)
+        WireEndUser.Anonymous -> EndUser.Anonymous
+    }
+
+    fun timeRange(wire: WireTimeRange): TimeRange = when (wire) {
+        is WireTimeRange.LastHours -> TimeRange.LastHours(wire.hours)
+        is WireTimeRange.LastDays -> TimeRange.LastDays(wire.days)
+        WireTimeRange.Today -> TimeRange.Today
+        is WireTimeRange.Between -> TimeRange.Between(
+            start = BridgeInstant.parse(wire.start),
+            end = BridgeInstant.parse(wire.end),
+        )
+    }
+
+    fun sleepStage(stage: SleepStage): WireSleepStage = when (stage) {
+        SleepStage.InBed -> WireSleepStage.InBed
+        SleepStage.Awake -> WireSleepStage.Awake
+        SleepStage.Asleep -> WireSleepStage.Asleep
+        SleepStage.Light -> WireSleepStage.Light
+        SleepStage.Deep -> WireSleepStage.Deep
+        SleepStage.Rem -> WireSleepStage.Rem
+        is SleepStage.Unknown -> WireSleepStage.Unknown(stage.raw)
+    }
+
+    fun sleepStage(wire: WireSleepStage): SleepStage = when (wire) {
+        WireSleepStage.InBed -> SleepStage.InBed
+        WireSleepStage.Awake -> SleepStage.Awake
+        WireSleepStage.Asleep -> SleepStage.Asleep
+        WireSleepStage.Light -> SleepStage.Light
+        WireSleepStage.Deep -> SleepStage.Deep
+        WireSleepStage.Rem -> SleepStage.Rem
+        is WireSleepStage.Unknown -> SleepStage.Unknown(wire.raw)
+    }
+
+    fun activity(activity: WorkoutActivity): WireWorkoutActivity = when (activity) {
+        WorkoutActivity.Running -> WireWorkoutActivity.Running
+        WorkoutActivity.Walking -> WireWorkoutActivity.Walking
+        WorkoutActivity.Cycling -> WireWorkoutActivity.Cycling
+        WorkoutActivity.Swimming -> WireWorkoutActivity.Swimming
+        WorkoutActivity.StrengthTraining -> WireWorkoutActivity.StrengthTraining
+        is WorkoutActivity.Other -> WireWorkoutActivity.Other(activity.label)
+    }
+
+    fun activity(wire: WireWorkoutActivity): WorkoutActivity = when (wire) {
+        WireWorkoutActivity.Running -> WorkoutActivity.Running
+        WireWorkoutActivity.Walking -> WorkoutActivity.Walking
+        WireWorkoutActivity.Cycling -> WorkoutActivity.Cycling
+        WireWorkoutActivity.Swimming -> WorkoutActivity.Swimming
+        WireWorkoutActivity.StrengthTraining -> WorkoutActivity.StrengthTraining
+        is WireWorkoutActivity.Other -> WorkoutActivity.Other(wire.label)
+    }
+
+    /**
+     * Android has no `devIDMismatch` state - it raises `dev_id_mismatch` instead - so nothing here
+     * produces that variant. The surface types it as iOS-only.
+     */
+    fun diagnosticsState(state: DiagnosticsState): WireDiagnosticsState = when (state) {
+        DiagnosticsState.Healthy -> WireDiagnosticsState.Healthy
+        is DiagnosticsState.Quiet -> WireDiagnosticsState.Quiet(BridgeInstant.format(state.since))
+        is DiagnosticsState.BackgroundRestricted ->
+            WireDiagnosticsState.BackgroundRestricted(restriction(state.reason))
+        DiagnosticsState.BackgroundRefreshUnscheduled -> WireDiagnosticsState.BackgroundRefreshUnscheduled
+        DiagnosticsState.PendingRetry -> WireDiagnosticsState.PendingRetry
+        DiagnosticsState.LinkRevoked -> WireDiagnosticsState.LinkRevoked
+    }
+
+    // ---- records ----------------------------------------------------------------------------
+
+    fun sampleSource(source: SampleSource): WireSampleSource = WireSampleSource(
+        name = source.name,
+        bundleId = source.bundleId,
+        productType = source.productType,
+        deviceType = source.deviceType,
+    )
+
+    fun connection(stored: StoredConnection): WireConnection = WireConnection(
+        source = source(stored.source),
+        userId = stored.userId,
+        providerUserId = stored.providerUserId,
+    )
+
+    fun heartRate(sample: HeartRateSample): WireHeartRateSample = WireHeartRateSample(
+        id = sample.id.value,
+        time = BridgeInstant.format(sample.time),
+        beatsPerMinute = sample.beatsPerMinute,
+        source = sampleSource(sample.source),
+        motionContext = sample.motionContext?.let {
+            when (it) {
+                co.tryterra.sdk.MotionContext.UNKNOWN -> WireMotionContext.UNKNOWN
+                co.tryterra.sdk.MotionContext.SEDENTARY -> WireMotionContext.SEDENTARY
+                co.tryterra.sdk.MotionContext.ACTIVE -> WireMotionContext.ACTIVE
+            }
+        },
+        userEntered = sample.userEntered,
+        timeZone = sample.timeZone?.id,
+    )
+
+    fun steps(sample: StepCount): WireStepCount = WireStepCount(
+        id = sample.id?.value,
+        start = BridgeInstant.format(sample.interval.start),
+        end = BridgeInstant.format(sample.interval.end),
+        steps = sample.steps,
+        source = sampleSource(sample.source),
+        userEntered = sample.userEntered,
+        timeZone = sample.timeZone?.id,
+    )
+
+    fun segment(segment: SleepSegment): WireSleepSegment = WireSleepSegment(
+        id = segment.id.value,
+        start = BridgeInstant.format(segment.interval.start),
+        end = BridgeInstant.format(segment.interval.end),
+        stage = sleepStage(segment.stage),
+        source = sampleSource(segment.source),
+        userEntered = segment.userEntered,
+        timeZone = segment.timeZone?.id,
+    )
+
+    fun workout(workout: Workout): WireWorkout = WireWorkout(
+        id = workout.id.value,
+        start = BridgeInstant.format(workout.interval.start),
+        end = BridgeInstant.format(workout.interval.end),
+        activity = activity(workout.activity),
+        activityTypeCode = workout.activityTypeCode,
+        indoor = workout.indoor,
+        activeEnergyKilocalories = workout.activeEnergyKilocalories,
+        distanceMeters = workout.distanceMeters,
+        source = sampleSource(workout.source),
+        userEntered = workout.userEntered,
+        timeZone = workout.timeZone?.id,
+    )
+
+    /**
+     * A change carries a day, not an instant.
+     *
+     * Sending the instant would make the receiving side re-derive the day in its own zone, and get
+     * a different one either side of midnight.
+     */
+    fun change(change: HealthChange, zone: ZoneId): WireHealthChange? =
+        category(change.category)?.let {
+            WireHealthChange(category = it, day = change.day.atZone(zone).toLocalDate().toString())
+        }
+
+    /**
+     * An event is the object `DiagnosticsWire` already produces, carried unchanged.
+     *
+     * Not reshaped into a `{kind, payload}` of the wrapper's own: that would be a hand-written
+     * second contract here and another in the Swift half, sitting between the SDK and the generated
+     * codec where no vector can reach either of them. `EventPrivacyTest` guards this object against
+     * carrying a health value, and passing it through is what keeps that guarantee the only one.
+     */
+    fun event(event: TerraEvent): WireTerraEvent = DiagnosticsWire.event(event)
+
+    fun report(report: SupportReport): WireSupportReport = WireSupportReport(
+        sdkVersion = report.sdkVersion,
+        generatedAt = BridgeInstant.format(report.generatedAt),
+        state = diagnosticsState(report.state),
+        lastDelivery = report.lastDelivery?.let { BridgeInstant.format(it) },
+        isConnected = report.isConnected,
+        requestedCategories = report.requestedCategories,
+        requestedWrites = report.requestedWrites,
+        requestedWorkouts = report.requestedWorkouts,
+        recentEvents = report.recentEvents.map(::event),
+    )
+
+    /**
+     * Sorted and merged, because a `Set` has no order and JSON has no set.
+     *
+     * Two scopes for one activity are one grant with both flags, not two entries: `HealthAccess`
+     * can hold `Running+energy` and `Running+distance` separately, and sending both would let a
+     * caller read a grant that contradicts itself depending on which it looked at first. Sorting is
+     * what makes two grants differing only in iteration order compare equal on the wire, without
+     * which the vectors would be flaky.
+     */
+    fun access(access: HealthAccess): WireHealthAccess = WireHealthAccess(
+        read = access.read.mapNotNull(::category).sortedBy { it.name },
+        write = access.write.mapNotNull(::category).sortedBy { it.name },
+        workouts = access.workouts
+            .groupBy { WorkoutActivity.reportName(it.activity) }
+            .toSortedMap()
+            .map { (_, scopes) ->
+                WireWorkoutScope(
+                    activity = activity(scopes.first().activity),
+                    energy = scopes.any { it.energy },
+                    distance = scopes.any { it.distance },
+                )
+            },
+    )
+
+    fun scope(scope: WorkoutScope): WireWorkoutScope = WireWorkoutScope(
+        activity = activity(scope.activity),
+        energy = scope.energy,
+        distance = scope.distance,
+    )
+
+    fun scope(wire: WireWorkoutScope): WorkoutScope = WorkoutScope(
+        activity = activity(wire.activity),
+        energy = wire.energy,
+        distance = wire.distance,
+    )
+
+    // ---- write entries ----------------------------------------------------------------------
+
+    /**
+     * A caller-supplied record id is honoured; an absent one is minted by the SDK's own default.
+     *
+     * Minting one here would use a different scheme from `RecordHandles.mint`, and `delete` only
+     * accepts handles that scheme produced.
+     */
+    fun entry(wire: WireHeartRateEntry): HeartRateEntry =
+        wire.recordId?.let { HeartRateEntry(BridgeInstant.parse(wire.time), wire.beatsPerMinute, RecordId(it)) }
+            ?: HeartRateEntry(BridgeInstant.parse(wire.time), wire.beatsPerMinute)
+
+    fun entry(wire: WireStepEntry): StepEntry {
+        val interval = SampleInterval(BridgeInstant.parse(wire.start), BridgeInstant.parse(wire.end))
+        return wire.recordId?.let { StepEntry(interval, wire.steps, RecordId(it)) }
+            ?: StepEntry(interval, wire.steps)
+    }
+
+    fun entry(wire: WireSleepEntry): SleepEntry {
+        val interval = SampleInterval(BridgeInstant.parse(wire.start), BridgeInstant.parse(wire.end))
+        val stage = sleepStage(wire.stage)
+        return wire.recordId?.let { SleepEntry(interval, stage, RecordId(it)) } ?: SleepEntry(interval, stage)
+    }
+
+    fun entry(wire: WireWorkoutEntry): WorkoutEntry {
+        val interval = SampleInterval(BridgeInstant.parse(wire.start), BridgeInstant.parse(wire.end))
+        val activity = activity(wire.activity)
+        return wire.recordId?.let {
+            WorkoutEntry(interval, activity, wire.totalEnergyKilocalories, wire.totalDistanceMeters, RecordId(it))
+        } ?: WorkoutEntry(interval, activity, wire.totalEnergyKilocalories, wire.totalDistanceMeters)
+    }
+
+    /**
+     * Ten optional measurements and a time, one for one with `BodyEntry`.
+     *
+     * Spelled out rather than reflected: a field added to `BodyEntry` should be a decision here,
+     * and reflection would carry it silently with whatever name the SDK happened to give it.
+     */
+    fun entry(wire: WireBodyEntry): BodyEntry {
+        val time = BridgeInstant.parse(wire.time)
+        return wire.recordId?.let {
+            BodyEntry(
+                time = time,
+                bodyMassKilograms = wire.bodyMassKilograms,
+                bodyFatPercent = wire.bodyFatPercent,
+                bodyMassIndex = wire.bodyMassIndex,
+                heightMeters = wire.heightMeters,
+                leanBodyMassKilograms = wire.leanBodyMassKilograms,
+                bodyTemperatureCelsius = wire.bodyTemperatureCelsius,
+                oxygenSaturationPercent = wire.oxygenSaturationPercent,
+                bloodGlucoseMilligramsPerDeciliter = wire.bloodGlucoseMilligramsPerDeciliter,
+                bloodPressureSystolicMillimetersOfMercury = wire.bloodPressureSystolicMillimetersOfMercury,
+                bloodPressureDiastolicMillimetersOfMercury = wire.bloodPressureDiastolicMillimetersOfMercury,
+                recordId = RecordId(it),
+            )
+        } ?: BodyEntry(
+            time = time,
+            bodyMassKilograms = wire.bodyMassKilograms,
+            bodyFatPercent = wire.bodyFatPercent,
+            bodyMassIndex = wire.bodyMassIndex,
+            heightMeters = wire.heightMeters,
+            leanBodyMassKilograms = wire.leanBodyMassKilograms,
+            bodyTemperatureCelsius = wire.bodyTemperatureCelsius,
+            oxygenSaturationPercent = wire.oxygenSaturationPercent,
+            bloodGlucoseMilligramsPerDeciliter = wire.bloodGlucoseMilligramsPerDeciliter,
+            bloodPressureSystolicMillimetersOfMercury = wire.bloodPressureSystolicMillimetersOfMercury,
+            bloodPressureDiastolicMillimetersOfMercury = wire.bloodPressureDiastolicMillimetersOfMercury,
+        )
+    }
+
+    fun entry(wire: WireNutritionEntry): NutritionEntry {
+        val interval = SampleInterval(BridgeInstant.parse(wire.start), BridgeInstant.parse(wire.end))
+        val nutrients = nutrients(wire.nutrients)
+        return wire.recordId?.let { NutritionEntry(interval, wire.name, nutrients, RecordId(it)) }
+            ?: NutritionEntry(interval, wire.name, nutrients)
+    }
+
+    /**
+     * All thirty-nine, by name.
+     *
+     * The unit is in every name on both sides, so a mismatched pair is a compile error rather than
+     * a value that arrives in the wrong unit - which is the class of bug that would be invisible in
+     * every test that did not know what the number should be.
+     */
+    private fun nutrients(wire: WireNutrients): NutritionEntry.Nutrients = NutritionEntry.Nutrients(
+        energyKilocalories = wire.energyKilocalories,
+        proteinGrams = wire.proteinGrams,
+        carbohydratesGrams = wire.carbohydratesGrams,
+        fiberGrams = wire.fiberGrams,
+        sugarGrams = wire.sugarGrams,
+        fatTotalGrams = wire.fatTotalGrams,
+        fatSaturatedGrams = wire.fatSaturatedGrams,
+        fatMonounsaturatedGrams = wire.fatMonounsaturatedGrams,
+        fatPolyunsaturatedGrams = wire.fatPolyunsaturatedGrams,
+        cholesterolMilligrams = wire.cholesterolMilligrams,
+        sodiumMilligrams = wire.sodiumMilligrams,
+        potassiumMilligrams = wire.potassiumMilligrams,
+        calciumMilligrams = wire.calciumMilligrams,
+        ironMilligrams = wire.ironMilligrams,
+        magnesiumMilligrams = wire.magnesiumMilligrams,
+        zincMilligrams = wire.zincMilligrams,
+        waterLiters = wire.waterLiters,
+        caffeineMilligrams = wire.caffeineMilligrams,
+        vitaminAMicrograms = wire.vitaminAMicrograms,
+        vitaminCMilligrams = wire.vitaminCMilligrams,
+        vitaminDMicrograms = wire.vitaminDMicrograms,
+        vitaminEMilligrams = wire.vitaminEMilligrams,
+        vitaminKMicrograms = wire.vitaminKMicrograms,
+        vitaminB6Milligrams = wire.vitaminB6Milligrams,
+        vitaminB12Micrograms = wire.vitaminB12Micrograms,
+        folateMicrograms = wire.folateMicrograms,
+        thiaminMilligrams = wire.thiaminMilligrams,
+        riboflavinMilligrams = wire.riboflavinMilligrams,
+        niacinMilligrams = wire.niacinMilligrams,
+        biotinMicrograms = wire.biotinMicrograms,
+        pantothenicAcidMilligrams = wire.pantothenicAcidMilligrams,
+        phosphorusMilligrams = wire.phosphorusMilligrams,
+        iodineMicrograms = wire.iodineMicrograms,
+        chromiumMicrograms = wire.chromiumMicrograms,
+        copperMilligrams = wire.copperMilligrams,
+        manganeseMilligrams = wire.manganeseMilligrams,
+        molybdenumMicrograms = wire.molybdenumMicrograms,
+        seleniumMicrograms = wire.seleniumMicrograms,
+        chlorideMilligrams = wire.chlorideMilligrams,
+    )
+
+
+}

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

@@ -0,0 +1,41 @@
+package co.tryterra.sdk.bridge
+
+import co.tryterra.sdk.Source
+
+/**
+ * Which activity's launcher presents a permission sheet: the most recently started one that is
+ * still started.
+ *
+ * Creation order is not that. An app with two tasks, or one that returns to an older activity,
+ * keeps a newer activity alive but stopped, and a sheet launched through it would not be seen.
+ */
+internal class LauncherSlots<A : Any, L : Any> {
+    private val made = HashMap<A, Map<Source, L>>()
+    private val started = LinkedHashSet<A>()
+
+    @Synchronized
+    fun created(activity: A, launchers: Map<Source, L>) {
+        made[activity] = launchers
+    }
+
+    @Synchronized
+    fun started(activity: A) {
+        started.remove(activity)
+        started.add(activity)
+    }
+
+    @Synchronized
+    fun stopped(activity: A) {
+        started.remove(activity)
+    }
+
+    /** Forgets [activity], answering the launchers it held so the caller can unregister them. */
+    @Synchronized
+    fun destroyed(activity: A): Map<Source, L>? {
+        started.remove(activity)
+        return made.remove(activity)
+    }
+
+    @Synchronized
+    fun current(source: Source): L? = started.toList().asReversed().firstNotNullOfOrNull { made[it]?.get(source) }
+}

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

@@ -0,0 +1,150 @@
+package co.tryterra.sdk.bridge
+
+import co.tryterra.sdk.NetworkFailure
+import co.tryterra.sdk.TerraError
+import co.tryterra.sdk.bridge.generated.BridgeError
+import co.tryterra.sdk.bridge.generated.Source
+import co.tryterra.sdk.bridge.generated.TerraErrorPayload
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+
+/**
+ * How a thrown error becomes something a caller in another language can switch on.
+ *
+ * The code comes from the SDK - [TerraError.code] is the vocabulary in `docs/sdk-reference.md`, and
+ * the surface asserts this module speaks exactly it - so there is no mapping table here to drift.
+ * What this file owns is the *detail bag*: which pieces of an error's associated values are safe to
+ * send, and which are not.
+ *
+ * Nothing here may put a health value in `details`. An error reaches a customer's crash reporter and
+ * their logs, so the bag carries identifiers, counts and reasons, never a sample.
+ */
+internal object Rejections {
+
+    /** The payload for any throwable, including one that is not a [TerraError]. */
+    fun of(thrown: Throwable): TerraErrorPayload = when (thrown) {
+        is TerraError -> ofTerraError(thrown)
+        is BridgeError -> TerraErrorPayload(
+            code = thrown.code,
+            retryable = thrown.isRetryable,
+            message = thrown.message ?: thrown.code,
+            details = bridgeDetails(thrown),
+        )
+        else -> TerraErrorPayload(
+            code = "platform",
+            retryable = false,
+            message = "a platform call failed (${thrown::class.java.name})",
+        )
+    }
+
+    private fun ofTerraError(error: TerraError): TerraErrorPayload = TerraErrorPayload(
+        code = error.code,
+        retryable = error.isRetryable,
+        message = message(error),
+        source = sourceOf(error),
+        details = details(error),
+    )
+
+    /**
+     * The text that crosses, which is not always the exception's own.
+     *
+     * Two cases wrap a throwable this SDK did not raise, and `Exception.message` embeds it: a
+     * platform failure's comes from whatever library was reading health records, and a token
+     * provider's is as likely to carry the token it was minting as to describe the failure.
+     * Dropping the details bag for those was not enough while the message still carried the same
+     * text, which is what the test that found this asserts.
+     */
+    private fun message(error: TerraError): String = when (error) {
+        is TerraError.TokenProviderFailed -> "the host's token provider failed"
+        is TerraError.Platform -> "a platform call failed"
+        else -> error.message ?: error.code
+    }
+
+    /** Only the cases that carry one: a default here would be a claim about where a failure happened. */
+    private fun sourceOf(error: TerraError): Source? = when (error) {
+        is TerraError.NotConnected -> wire(error.source)
+        is TerraError.LinkRevoked -> wire(error.source)
+        is TerraError.DevIdMismatch -> wire(error.source)
+        is TerraError.LinkAlreadyRunning -> wire(error.source)
+        is TerraError.ReadQuotaExceeded -> wire(error.source)
+        else -> null
+    }
+
+    private fun wire(source: co.tryterra.sdk.Source): Source = when (source) {
+        co.tryterra.sdk.Source.HEALTH -> Source.HEALTH
+        co.tryterra.sdk.Source.SAMSUNG_HEALTH -> Source.SAMSUNG_HEALTH
+    }
+
+    /**
+     * Exhaustive over the sealed hierarchy with no `else`, which is the point.
+     *
+     * A case added to [TerraError] stops this module compiling until someone decides what, if
+     * anything, of it is safe to send. An `else` here would answer that question with silence.
+     */
+    private fun details(error: TerraError): JsonObject? = when (error) {
+        is TerraError.HealthDataUnavailable -> obj("availability" to JsonPrimitive(error.reason::class.java.simpleName))
+        is TerraError.PermissionDenied -> obj("category" to JsonPrimitive(error.category.name.lowercase()))
+        is TerraError.RouteAwaitingConverter -> obj("dataType" to JsonPrimitive(error.dataType.wire))
+        is TerraError.SyncAlreadyRunning -> obj("dataType" to JsonPrimitive(error.dataType.wire))
+        is TerraError.SampleNotFound -> obj("id" to JsonPrimitive(error.id.value))
+        is TerraError.DeviceKeyUnavailable -> obj("reason" to JsonPrimitive(error.reason))
+        // The cause travels as a code: a nested throwable carries a stack and a message.
+        is TerraError.RollbackIncomplete -> obj(
+            "remaining" to JsonPrimitive(error.remaining.size),
+            "cause" to JsonPrimitive(error.underlying.code),
+        )
+        is TerraError.DistanceNotAttributable -> obj(
+            "activity" to JsonPrimitive(co.tryterra.sdk.WorkoutActivity.reportName(error.activity)),
+        )
+        // No message. The host's own provider threw, and the text it chose is as likely to contain
+        // the token it was minting as it is to describe the failure - `IllegalStateException(
+        // "token=...")` is not a hypothetical. The host already knows why its provider failed; what
+        // it needs from here is the code.
+        is TerraError.TokenProviderFailed -> null
+        // No message, for the same reason with a different source. A platform failure's text comes
+        // from whatever library raised it, which on this path has been reading health records.
+        is TerraError.Platform -> null
+        is TerraError.Network -> networkDetails(error.failure)
+
+        is TerraError.NotConnected,
+        is TerraError.LinkRevoked,
+        is TerraError.DevIdMismatch,
+        is TerraError.LinkAlreadyRunning,
+        is TerraError.ReadQuotaExceeded,
+        -> null
+
+        TerraError.TokenRejected,
+        TerraError.TokenUnavailable,
+        TerraError.SignatureRejected,
+        TerraError.ClockSkewed,
+        TerraError.UserLimitReached,
+        TerraError.LinkConflict,
+        TerraError.UpgradeRequired,
+        TerraError.StoreLocked,
+        TerraError.StoreUnreadable,
+        TerraError.DeadlineExceeded,
+        TerraError.AuthorizationNotDetermined,
+        TerraError.BloodPressureIncomplete,
+        TerraError.AuthorizationUnavailableInExtension,
+        -> null
+    }
+
+    private fun networkDetails(failure: NetworkFailure): JsonObject? = when (failure) {
+        is NetworkFailure.ServerError -> obj("status" to JsonPrimitive(failure.status))
+        is NetworkFailure.Throttled -> failure.retryAfterSeconds?.let { obj("retryAfterSeconds" to JsonPrimitive(it)) }
+        // The IOException's message names a host and sometimes a path; the code alone is the signal.
+        is NetworkFailure.Transport -> null
+        NetworkFailure.MalformedResponse -> null
+    }
+
+    private fun bridgeDetails(error: BridgeError): JsonObject? = when (error) {
+        is BridgeError.NotBootstrapped -> obj("line" to JsonPrimitive(error.line))
+        is BridgeError.UnsupportedOnPlatform -> obj("op" to JsonPrimitive(error.op))
+        is BridgeError.TokenTimeout -> obj("timeoutMs" to JsonPrimitive(error.timeoutMs))
+        is BridgeError.InvalidPayload -> obj("path" to JsonPrimitive(error.path))
+        BridgeError.NoActivity -> null
+        BridgeError.PermissionSheetUnavailable -> null
+    }
+
+    private fun obj(vararg pairs: Pair<String, JsonPrimitive>): JsonObject = JsonObject(pairs.toMap())
+}