@tryterra/react-native 2.1.0 → 2.2.1

package/README.md

@@ -18,6 +18,37 @@ There is no sync call: once connected, the SDK uploads on its own, in the backgr
 rejection is a `TerraError` with a stable `code` (see `docs/availability.md` for the full list and
 what exists on which platform).
 
+## Local reads
+
+Every read goes straight to the device's store and never touches the network:
+
+| Member | Answers | Platforms |
+|---|---|---|
+| `body.heartRate(range)` | `HeartRateSample[]` | both |
+| `body.restingHeartRate(range)` | `RestingHeartRateSample[]`, the store's own daily figure | both; Android grants it under `daily` |
+| `body.readings(range)` | `BodyReading[]`, each `kind` carrying its unit | both; `bmi` and wrist temperature iOS only |
+| `daily.steps(range)` | `StepCount[]` | both |
+| `daily.totals(range)` | `DayTotal[]`, one per metric per whole local day | both; `appleExerciseTime` iOS only |
+| `daily.intraday(range)` | `IntradaySample[]` | both; `basalEnergy` iOS only |
+| `sleep.segments(range)` | `SleepSegment[]` | both |
+| `activity.workouts(range)` | `Workout[]`, with the writer's `title` where it set one | both |
+| `activity.routes(range)` | `WorkoutRoute[]`, each naming its workout | both |
+| `activity.intensity(range)` | `WorkoutIntensitySample[]` | both; no `workoutId` on Android |
+| `nutrition.quantities(range)` | `DietaryQuantity[]`, one per nutrient, not grouped into meals | both |
+| `nutrition.hydration(range)` | `HydrationSample[]`, in millilitres | both |
+| `menstruation.flow(range)` | `MenstruationFlowDay[]`, one per logged day | both |
+| `menstruation.events(range)` | `MenstrualEvent[]`: ovulation tests, cervical mucus, intermenstrual bleeding | both |
+| `athlete?.profile()` | `AthleteProfile`, or `undefined` where the store has none | iOS; `terra.athlete` is `undefined` on Android |
+
+Ask for the category first: `permissions.request({ read: ["nutrition", "menstruation"] })`, plus
+`"athlete"` on iOS, without which HealthKit hides the characteristics and `profile()` answers
+`notSet` and nothing else. A read rejects with `not_connected` before `connect`, and with
+`permission_denied` naming the category in `details.category` when the grant was refused.
+
+`terra.availability(source?)` answers before any of them, with no connection: `available`, or why
+not - `unsupportedDevice` on iOS, and on Android the reason Health Connect gives, such as
+`providerAppMissing` when it needs installing.
+
 ## Native setup
 
 The client is built natively at launch, before any JavaScript runs, because background delivery

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

@@ -1,6 +1,11 @@
 package co.tryterra.sdk.bridge
 
 import co.tryterra.sdk.DataCategory
+import co.tryterra.sdk.DietaryQuantity
+import co.tryterra.sdk.MealSample
+import co.tryterra.sdk.MenstruationFlowDay
+import co.tryterra.sdk.MenstruationFlowSample
+import co.tryterra.sdk.Nutrient
 import co.tryterra.sdk.EndUser
 import co.tryterra.sdk.BodyEntry
 import co.tryterra.sdk.HeartRateEntry
@@ -38,6 +43,11 @@ 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.DietaryQuantity as WireDietaryQuantity
+import co.tryterra.sdk.bridge.generated.MealType as WireMealType
+import co.tryterra.sdk.bridge.generated.MenstruationFlow as WireMenstruationFlow
+import co.tryterra.sdk.bridge.generated.MenstruationFlowDay as WireMenstruationFlowDay
+import co.tryterra.sdk.bridge.generated.Nutrient as WireNutrient
 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
@@ -88,12 +98,8 @@ internal object Conversions {
     }
 
     /**
-     * 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.
+     * `ATHLETE` is HealthKit's characteristics and has no Health Connect counterpart, so a request
+     * naming it is refused as this platform lacking it rather than quietly dropped from the sheet.
      */
     fun category(wire: WireCategory): DataCategory = when (wire) {
         WireCategory.ACTIVITY -> DataCategory.ACTIVITY
@@ -101,15 +107,17 @@ internal object Conversions {
         WireCategory.DAILY -> DataCategory.DAILY
         WireCategory.SLEEP -> DataCategory.SLEEP
         WireCategory.NUTRITION -> DataCategory.NUTRITION
+        WireCategory.MENSTRUATION -> DataCategory.MENSTRUATION
+        WireCategory.ATHLETE -> throw BridgeError.UnsupportedOnPlatform("athlete")
     }
 
-    fun category(category: DataCategory): WireCategory? = when (category) {
+    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
+        DataCategory.MENSTRUATION -> WireCategory.MENSTRUATION
     }
 
     /**
@@ -255,6 +263,88 @@ internal object Conversions {
         timeZone = segment.timeZone?.id,
     )
 
+    fun nutrient(nutrient: Nutrient): WireNutrient = when (nutrient) {
+        Nutrient.ENERGY_CONSUMED -> WireNutrient.ENERGY_CONSUMED
+        Nutrient.PROTEIN -> WireNutrient.PROTEIN
+        Nutrient.CARBOHYDRATES -> WireNutrient.CARBOHYDRATES
+        Nutrient.FAT_TOTAL -> WireNutrient.FAT_TOTAL
+        Nutrient.FAT_SATURATED -> WireNutrient.FAT_SATURATED
+        Nutrient.FAT_MONOUNSATURATED -> WireNutrient.FAT_MONOUNSATURATED
+        Nutrient.FAT_POLYUNSATURATED -> WireNutrient.FAT_POLYUNSATURATED
+        Nutrient.SUGAR -> WireNutrient.SUGAR
+        Nutrient.FIBER -> WireNutrient.FIBER
+        Nutrient.CHOLESTEROL -> WireNutrient.CHOLESTEROL
+        Nutrient.SODIUM -> WireNutrient.SODIUM
+        Nutrient.POTASSIUM -> WireNutrient.POTASSIUM
+        Nutrient.CALCIUM -> WireNutrient.CALCIUM
+        Nutrient.IRON -> WireNutrient.IRON
+        Nutrient.MAGNESIUM -> WireNutrient.MAGNESIUM
+        Nutrient.ZINC -> WireNutrient.ZINC
+        Nutrient.PHOSPHORUS -> WireNutrient.PHOSPHORUS
+        Nutrient.IODINE -> WireNutrient.IODINE
+        Nutrient.MANGANESE -> WireNutrient.MANGANESE
+        Nutrient.MOLYBDENUM -> WireNutrient.MOLYBDENUM
+        Nutrient.SELENIUM -> WireNutrient.SELENIUM
+        Nutrient.COPPER -> WireNutrient.COPPER
+        Nutrient.CHROMIUM -> WireNutrient.CHROMIUM
+        Nutrient.CHLORIDE -> WireNutrient.CHLORIDE
+        Nutrient.CAFFEINE -> WireNutrient.CAFFEINE
+        Nutrient.VITAMIN_A -> WireNutrient.VITAMIN_A
+        Nutrient.VITAMIN_C -> WireNutrient.VITAMIN_C
+        Nutrient.VITAMIN_D -> WireNutrient.VITAMIN_D
+        Nutrient.VITAMIN_E -> WireNutrient.VITAMIN_E
+        Nutrient.VITAMIN_K -> WireNutrient.VITAMIN_K
+        Nutrient.VITAMIN_B6 -> WireNutrient.VITAMIN_B6
+        Nutrient.VITAMIN_B12 -> WireNutrient.VITAMIN_B12
+        Nutrient.THIAMIN -> WireNutrient.THIAMIN
+        Nutrient.RIBOFLAVIN -> WireNutrient.RIBOFLAVIN
+        Nutrient.NIACIN -> WireNutrient.NIACIN
+        Nutrient.FOLATE -> WireNutrient.FOLATE
+        Nutrient.BIOTIN -> WireNutrient.BIOTIN
+        Nutrient.PANTOTHENIC_ACID -> WireNutrient.PANTOTHENIC_ACID
+    }
+
+    fun mealType(type: MealSample.MealType): WireMealType = when (type) {
+        MealSample.MealType.BREAKFAST -> WireMealType.BREAKFAST
+        MealSample.MealType.LUNCH -> WireMealType.LUNCH
+        MealSample.MealType.DINNER -> WireMealType.DINNER
+        MealSample.MealType.SNACK -> WireMealType.SNACK
+        MealSample.MealType.UNKNOWN -> WireMealType.UNKNOWN
+    }
+
+    fun flow(flow: MenstruationFlowSample.Flow): WireMenstruationFlow = when (flow) {
+        MenstruationFlowSample.Flow.UNSPECIFIED -> WireMenstruationFlow.UNSPECIFIED
+        MenstruationFlowSample.Flow.LIGHT -> WireMenstruationFlow.LIGHT
+        MenstruationFlowSample.Flow.MEDIUM -> WireMenstruationFlow.MEDIUM
+        MenstruationFlowSample.Flow.HEAVY -> WireMenstruationFlow.HEAVY
+        MenstruationFlowSample.Flow.NONE -> WireMenstruationFlow.NO_FLOW
+    }
+
+    fun quantity(quantity: DietaryQuantity): WireDietaryQuantity = WireDietaryQuantity(
+        id = quantity.id.value,
+        nutrient = nutrient(quantity.nutrient),
+        value = quantity.value,
+        start = BridgeInstant.format(quantity.interval.start),
+        end = BridgeInstant.format(quantity.interval.end),
+        mealType = mealType(quantity.mealType),
+        name = quantity.name,
+        foodCorrelationId = quantity.foodCorrelationId?.value,
+        source = sampleSource(quantity.source),
+        userEntered = quantity.userEntered,
+        timeZone = quantity.timeZone?.id,
+    )
+
+    fun flowDay(day: MenstruationFlowDay): WireMenstruationFlowDay = WireMenstruationFlowDay(
+        id = day.id.value,
+        start = BridgeInstant.format(day.interval.start),
+        end = BridgeInstant.format(day.interval.end),
+        flow = flow(day.flow),
+        cycleStart = day.cycleStart,
+        source = sampleSource(day.source),
+        userEntered = day.userEntered,
+        timeZone = day.timeZone?.id,
+    )
+
     fun workout(workout: Workout): WireWorkout = WireWorkout(
         id = workout.id.value,
         start = BridgeInstant.format(workout.interval.start),
@@ -267,6 +357,7 @@ internal object Conversions {
         source = sampleSource(workout.source),
         userEntered = workout.userEntered,
         timeZone = workout.timeZone?.id,
+        title = workout.title,
     )
 
     /**
@@ -275,10 +366,8 @@ internal object Conversions {
      * 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())
-        }
+    fun change(change: HealthChange, zone: ZoneId): WireHealthChange =
+        WireHealthChange(category = category(change.category), day = change.day.atZone(zone).toLocalDate().toString())
 
     /**
      * An event is the object `DiagnosticsWire` already produces, carried unchanged.
@@ -312,8 +401,8 @@ internal object Conversions {
      * 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 },
+        read = access.read.map(::category).sortedBy { it.name },
+        write = access.write.map(::category).sortedBy { it.name },
         workouts = access.workouts
             .groupBy { WorkoutActivity.reportName(it.activity) }
             .toSortedMap()

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

@@ -0,0 +1,250 @@
+package co.tryterra.sdk.bridge
+
+import co.tryterra.sdk.BloodGlucoseSample
+import co.tryterra.sdk.BloodGlucoseUnit
+import co.tryterra.sdk.BodyMeasurement
+import co.tryterra.sdk.BodyReading
+import co.tryterra.sdk.BodyTemperatureSample
+import co.tryterra.sdk.DayTotal
+import co.tryterra.sdk.HydrationSample
+import co.tryterra.sdk.IntradaySample
+import co.tryterra.sdk.MenstrualEvent
+import co.tryterra.sdk.MenstruationEventSample
+import co.tryterra.sdk.RestingHeartRateSample
+import co.tryterra.sdk.Vo2MaxSample
+import co.tryterra.sdk.WorkoutIntensitySample
+import co.tryterra.sdk.WorkoutRoute
+import co.tryterra.sdk.bridge.generated.BridgeInstant
+import co.tryterra.sdk.health.StoreAvailability
+import co.tryterra.sdk.bridge.generated.BloodGlucoseUnit as WireGlucoseUnit
+import co.tryterra.sdk.bridge.generated.BodyMetric as WireBodyMetric
+import co.tryterra.sdk.bridge.generated.BodyReading as WireBodyReading
+import co.tryterra.sdk.bridge.generated.BodyReadingKind as WireBodyReadingKind
+import co.tryterra.sdk.bridge.generated.BodyTemperatureMetric as WireTemperatureMetric
+import co.tryterra.sdk.bridge.generated.DayTotal as WireDayTotal
+import co.tryterra.sdk.bridge.generated.DayTotalMetric as WireDayTotalMetric
+import co.tryterra.sdk.bridge.generated.GlucoseMealTime as WireMealTime
+import co.tryterra.sdk.bridge.generated.GlucoseSpecimen as WireSpecimen
+import co.tryterra.sdk.bridge.generated.HeartRateVariabilityMetric as WireVariabilityMetric
+import co.tryterra.sdk.bridge.generated.HydrationSample as WireHydrationSample
+import co.tryterra.sdk.bridge.generated.IntradayMetric as WireIntradayMetric
+import co.tryterra.sdk.bridge.generated.IntradaySample as WireIntradaySample
+import co.tryterra.sdk.bridge.generated.MenstrualEvent as WireMenstrualEvent
+import co.tryterra.sdk.bridge.generated.MenstrualEventKind as WireEventKind
+import co.tryterra.sdk.bridge.generated.RestingHeartRateSample as WireRestingHeartRateSample
+import co.tryterra.sdk.bridge.generated.RoutePoint as WireRoutePoint
+import co.tryterra.sdk.bridge.generated.StoreAvailability as WireStoreAvailability
+import co.tryterra.sdk.bridge.generated.VO2MaxTestType as WireTestType
+import co.tryterra.sdk.bridge.generated.WorkoutIntensityMetric as WireIntensityMetric
+import co.tryterra.sdk.bridge.generated.WorkoutIntensitySample as WireIntensitySample
+import co.tryterra.sdk.bridge.generated.WorkoutRoute as WireWorkoutRoute
+
+/**
+ * The reads that close the rest of the 1.x local-read gap, between the SDK's types and the wire's.
+ *
+ * Apart from [Conversions] only because there are many of them, and under its rules: every `when`
+ * is exhaustive with no `else`, so a case added on either side stops the build here, and a case the
+ * read never returns maps to null and is dropped rather than sent under a neighbour's name.
+ */
+internal object ReadConversions {
+
+    /** Null for the metrics `daily.totals` leaves out, which the read never hands over. */
+    fun dayTotalMetric(metric: DayTotal.Metric): WireDayTotalMetric? = when (metric) {
+        DayTotal.Metric.DISTANCE_WALKING_RUNNING -> WireDayTotalMetric.DISTANCE_WALKING_RUNNING
+        DayTotal.Metric.DISTANCE_CYCLING -> WireDayTotalMetric.DISTANCE_CYCLING
+        DayTotal.Metric.DISTANCE_SWIMMING -> WireDayTotalMetric.DISTANCE_SWIMMING
+        DayTotal.Metric.DISTANCE_WHEELCHAIR -> WireDayTotalMetric.DISTANCE_WHEELCHAIR
+        DayTotal.Metric.ACTIVE_ENERGY_BURNED -> WireDayTotalMetric.ACTIVE_ENERGY_BURNED
+        DayTotal.Metric.BASAL_ENERGY_BURNED -> WireDayTotalMetric.BASAL_ENERGY_BURNED
+        DayTotal.Metric.FLIGHTS_CLIMBED -> WireDayTotalMetric.FLIGHTS_CLIMBED
+        DayTotal.Metric.STEPS, DayTotal.Metric.SWIMMING_STROKE_COUNT -> null
+    }
+
+    fun dayTotal(total: DayTotal): WireDayTotal? = dayTotalMetric(total.metric)?.let {
+        WireDayTotal(
+            metric = it,
+            start = BridgeInstant.format(total.interval.start),
+            end = BridgeInstant.format(total.interval.end),
+            value = total.value,
+            unit = total.unit,
+            timeZone = total.timeZone?.id,
+        )
+    }
+
+    fun intradayMetric(metric: IntradaySample.Metric): WireIntradayMetric = when (metric) {
+        IntradaySample.Metric.ACTIVE_ENERGY -> WireIntradayMetric.ACTIVE_ENERGY
+        IntradaySample.Metric.DISTANCE -> WireIntradayMetric.DISTANCE
+        IntradaySample.Metric.FLOORS_CLIMBED -> WireIntradayMetric.FLOORS_CLIMBED
+    }
+
+    fun intraday(sample: IntradaySample): WireIntradaySample = WireIntradaySample(
+        id = sample.id.value,
+        metric = intradayMetric(sample.metric),
+        start = BridgeInstant.format(sample.interval.start),
+        end = BridgeInstant.format(sample.interval.end),
+        value = sample.value,
+        source = Conversions.sampleSource(sample.source),
+        userEntered = sample.userEntered,
+        timeZone = sample.timeZone?.id,
+    )
+
+    fun restingHeartRate(sample: RestingHeartRateSample): WireRestingHeartRateSample = WireRestingHeartRateSample(
+        id = sample.id.value,
+        start = BridgeInstant.format(sample.interval.start),
+        end = BridgeInstant.format(sample.interval.end),
+        beatsPerMinute = sample.beatsPerMinute,
+        source = Conversions.sampleSource(sample.source),
+        userEntered = sample.userEntered,
+        timeZone = sample.timeZone?.id,
+    )
+
+    /** Null for the three `body.readings` leaves out. */
+    fun bodyMetric(metric: BodyMeasurement.Metric): WireBodyMetric? = when (metric) {
+        BodyMeasurement.Metric.WEIGHT -> WireBodyMetric.WEIGHT
+        BodyMeasurement.Metric.HEIGHT -> WireBodyMetric.HEIGHT
+        BodyMeasurement.Metric.BODY_FAT_PERCENTAGE -> WireBodyMetric.BODY_FAT_PERCENTAGE
+        BodyMeasurement.Metric.LEAN_BODY_MASS -> WireBodyMetric.LEAN_BODY_MASS
+        BodyMeasurement.Metric.BONE_MASS,
+        BodyMeasurement.Metric.BODY_WATER_MASS,
+        BodyMeasurement.Metric.BASAL_METABOLIC_RATE,
+        -> null
+    }
+
+    fun glucoseUnit(unit: BloodGlucoseUnit): WireGlucoseUnit = when (unit) {
+        BloodGlucoseUnit.MILLIGRAMS_PER_DECILITRE -> WireGlucoseUnit.MILLIGRAMS_PER_DECILITRE
+        BloodGlucoseUnit.MILLIMOLES_PER_LITRE -> WireGlucoseUnit.MILLIMOLES_PER_LITRE
+    }
+
+    fun mealTime(time: BloodGlucoseSample.MealTime): WireMealTime = when (time) {
+        BloodGlucoseSample.MealTime.PREPRANDIAL -> WireMealTime.PREPRANDIAL
+        BloodGlucoseSample.MealTime.POSTPRANDIAL -> WireMealTime.POSTPRANDIAL
+        BloodGlucoseSample.MealTime.UNKNOWN -> WireMealTime.UNKNOWN
+    }
+
+    fun specimen(specimen: BloodGlucoseSample.Specimen): WireSpecimen = when (specimen) {
+        BloodGlucoseSample.Specimen.CAPILLARY -> WireSpecimen.CAPILLARY
+        BloodGlucoseSample.Specimen.INTERSTITIAL -> WireSpecimen.INTERSTITIAL
+        BloodGlucoseSample.Specimen.PLASMA -> WireSpecimen.PLASMA
+        BloodGlucoseSample.Specimen.SERUM -> WireSpecimen.SERUM
+        BloodGlucoseSample.Specimen.TEARS -> WireSpecimen.TEARS
+        BloodGlucoseSample.Specimen.WHOLE_BLOOD -> WireSpecimen.WHOLE_BLOOD
+        BloodGlucoseSample.Specimen.UNKNOWN -> WireSpecimen.UNKNOWN
+    }
+
+    fun temperatureMetric(metric: BodyTemperatureSample.Metric): WireTemperatureMetric = when (metric) {
+        BodyTemperatureSample.Metric.BODY -> WireTemperatureMetric.BODY
+        BodyTemperatureSample.Metric.BASAL -> WireTemperatureMetric.BASAL
+        BodyTemperatureSample.Metric.SKIN -> WireTemperatureMetric.SKIN
+    }
+
+    fun testType(type: Vo2MaxSample.TestType): WireTestType = when (type) {
+        Vo2MaxSample.TestType.MAX_EXERCISE -> WireTestType.MAX_EXERCISE
+        Vo2MaxSample.TestType.PREDICTED_SUB_MAX_EXERCISE -> WireTestType.PREDICTED_SUB_MAX_EXERCISE
+        Vo2MaxSample.TestType.PREDICTED_NON_EXERCISE -> WireTestType.PREDICTED_NON_EXERCISE
+    }
+
+    fun bodyReadingKind(kind: BodyReading.Kind): WireBodyReadingKind? = when (kind) {
+        is BodyReading.Kind.Measurement -> bodyMetric(kind.metric)?.let { WireBodyReadingKind.Measurement(it, kind.value) }
+        is BodyReading.Kind.BloodPressure ->
+            WireBodyReadingKind.BloodPressure(kind.systolicMillimetersOfMercury, kind.diastolicMillimetersOfMercury)
+        is BodyReading.Kind.BloodGlucose -> WireBodyReadingKind.BloodGlucose(
+            value = kind.value,
+            unit = glucoseUnit(kind.unit),
+            mealTime = kind.mealTime?.let(::mealTime),
+            specimen = kind.specimen?.let(::specimen),
+        )
+        is BodyReading.Kind.OxygenSaturation -> WireBodyReadingKind.OxygenSaturation(kind.fraction)
+        is BodyReading.Kind.Temperature -> WireBodyReadingKind.Temperature(temperatureMetric(kind.metric), kind.celsius)
+        // RMSSD is the only statistic Health Connect records.
+        is BodyReading.Kind.HeartRateVariability ->
+            WireBodyReadingKind.HeartRateVariability(WireVariabilityMetric.RMSSD, kind.rmssdMilliseconds)
+        is BodyReading.Kind.RespiratoryRate -> WireBodyReadingKind.RespiratoryRate(kind.breathsPerMinute)
+        is BodyReading.Kind.Vo2Max ->
+            WireBodyReadingKind.Vo2Max(kind.millilitresPerKilogramPerMinute, kind.testType?.let(::testType))
+    }
+
+    fun bodyReading(reading: BodyReading): WireBodyReading? = bodyReadingKind(reading.kind)?.let {
+        WireBodyReading(
+            id = reading.id.value,
+            kind = it,
+            start = BridgeInstant.format(reading.interval.start),
+            end = BridgeInstant.format(reading.interval.end),
+            source = Conversions.sampleSource(reading.source),
+            userEntered = reading.userEntered,
+            timeZone = reading.timeZone?.id,
+        )
+    }
+
+    fun route(route: WorkoutRoute): WireWorkoutRoute = WireWorkoutRoute(
+        id = route.id.value,
+        workoutId = route.workoutId.value,
+        start = BridgeInstant.format(route.interval.start),
+        end = BridgeInstant.format(route.interval.end),
+        points = route.points.map { WireRoutePoint(BridgeInstant.format(it.time), it.latitude, it.longitude) },
+        source = Conversions.sampleSource(route.source),
+        timeZone = route.timeZone?.id,
+    )
+
+    fun intensityMetric(metric: WorkoutIntensitySample.Metric): WireIntensityMetric = when (metric) {
+        WorkoutIntensitySample.Metric.SPEED -> WireIntensityMetric.SPEED
+        WorkoutIntensitySample.Metric.POWER -> WireIntensityMetric.POWER
+        WorkoutIntensitySample.Metric.CADENCE -> WireIntensityMetric.CADENCE
+    }
+
+    /** An instant on Health Connect, so both ends are its time, and no workout it could name. */
+    fun intensity(sample: WorkoutIntensitySample): WireIntensitySample = WireIntensitySample(
+        id = sample.id.value,
+        metric = intensityMetric(sample.metric),
+        workoutId = null,
+        start = BridgeInstant.format(sample.time),
+        end = BridgeInstant.format(sample.time),
+        value = sample.value,
+        source = Conversions.sampleSource(sample.source),
+        userEntered = sample.userEntered,
+        timeZone = sample.timeZone?.id,
+    )
+
+    fun hydration(sample: HydrationSample): WireHydrationSample = WireHydrationSample(
+        id = sample.id.value,
+        start = BridgeInstant.format(sample.interval.start),
+        end = BridgeInstant.format(sample.interval.end),
+        millilitres = sample.millilitres,
+        source = Conversions.sampleSource(sample.source),
+        userEntered = sample.userEntered,
+        timeZone = sample.timeZone?.id,
+    )
+
+    /**
+     * Which types a partner policy refuses, and which feature is missing, stay in the native report:
+     * the wire names the reason, and the remedy a wrapper app can offer is the same either way.
+     */
+    fun availability(availability: StoreAvailability): WireStoreAvailability = when (availability) {
+        StoreAvailability.Available -> WireStoreAvailability.Available
+        StoreAvailability.ModuleMissing -> WireStoreAvailability.ModuleMissing
+        StoreAvailability.ProviderAppMissing -> WireStoreAvailability.ProviderAppMissing
+        is StoreAvailability.ProviderAppTooOld -> WireStoreAvailability.ProviderAppTooOld(availability.installed)
+        is StoreAvailability.PartnerPolicyMissing -> WireStoreAvailability.PartnerPolicyMissing
+        is StoreAvailability.FeatureUnavailable -> WireStoreAvailability.FeatureUnavailable
+    }
+
+    /** Null for sexual activity, which `menstruation.events` leaves out. */
+    fun eventKind(event: MenstruationEventSample.Event): WireEventKind? = when (event) {
+        MenstruationEventSample.Event.INTERMENSTRUAL_BLEEDING -> WireEventKind.INTERMENSTRUAL_BLEEDING
+        MenstruationEventSample.Event.OVULATION_TEST -> WireEventKind.OVULATION_TEST
+        MenstruationEventSample.Event.CERVICAL_MUCUS -> WireEventKind.CERVICAL_MUCUS
+        MenstruationEventSample.Event.SEXUAL_ACTIVITY -> null
+    }
+
+    fun menstrualEvent(event: MenstrualEvent): WireMenstrualEvent? = eventKind(event.event)?.let {
+        WireMenstrualEvent(
+            id = event.id.value,
+            kind = it,
+            time = BridgeInstant.format(event.time),
+            value = event.value?.wire,
+            storeIdentifier = event.storeIdentifier,
+            source = Conversions.sampleSource(event.source),
+            userEntered = event.userEntered,
+            timeZone = event.timeZone?.id,
+        )
+    }
+}

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

@@ -12,11 +12,13 @@ import co.tryterra.sdk.bridge.generated.Connection
 import co.tryterra.sdk.bridge.generated.ConnectRequest
 import co.tryterra.sdk.bridge.generated.ConnectionList
 import co.tryterra.sdk.bridge.generated.DiagnosticsState
+import co.tryterra.sdk.bridge.generated.DietaryQuantityList
 import co.tryterra.sdk.bridge.generated.Empty
 import co.tryterra.sdk.bridge.generated.HealthAccess
 import co.tryterra.sdk.bridge.generated.HeartRateEntryList
 import co.tryterra.sdk.bridge.generated.HeartRateList
 import co.tryterra.sdk.bridge.generated.LastDeliveryResult
+import co.tryterra.sdk.bridge.generated.MenstruationFlowDayList
 import co.tryterra.sdk.bridge.generated.NutritionEntryList
 import co.tryterra.sdk.bridge.generated.PermissionGrant
 import co.tryterra.sdk.bridge.generated.PermissionRequest
@@ -37,7 +39,16 @@ import co.tryterra.sdk.bridge.generated.TokenRejectRequest
 import co.tryterra.sdk.bridge.generated.TokenResolveRequest
 import co.tryterra.sdk.bridge.generated.WorkoutEntryList
 import co.tryterra.sdk.bridge.generated.WorkoutList
+import co.tryterra.sdk.bridge.generated.AvailabilityResult
 import co.tryterra.sdk.bridge.generated.BodyEntryList
+import co.tryterra.sdk.bridge.generated.BodyReadingList
+import co.tryterra.sdk.bridge.generated.DayTotalList
+import co.tryterra.sdk.bridge.generated.HydrationList
+import co.tryterra.sdk.bridge.generated.IntradaySampleList
+import co.tryterra.sdk.bridge.generated.MenstrualEventList
+import co.tryterra.sdk.bridge.generated.RestingHeartRateList
+import co.tryterra.sdk.bridge.generated.WorkoutIntensityList
+import co.tryterra.sdk.bridge.generated.WorkoutRouteList
 import co.tryterra.sdk.bridge.generated.Source as WireSource
 import kotlinx.coroutines.CancellationException
 
@@ -78,6 +89,9 @@ internal class TerraBridgeOpsImpl(
     override suspend fun clientConnections(request: Empty): ConnectionList =
         ConnectionList(terra.connections().map(Conversions::connection))
 
+    override suspend fun clientAvailability(request: SourceRequest): AvailabilityResult =
+        AvailabilityResult(ReadConversions.availability(terra.availability(sourceOf(request.source))))
+
     override suspend fun clientDisconnect(request: SourceRequest): Empty {
         terra.disconnect(sourceOf(request.source))
         return Empty()
@@ -143,11 +157,7 @@ internal class TerraBridgeOpsImpl(
 
     override suspend fun permissionsStatuses(request: SourceRequest): StatusesResult {
         val statuses = permissionsOf(request.source).statuses()
-            .mapNotNull { (category, status) ->
-                // A category the wrapper does not project has no key to report it under. Dropping
-                // it is right: inventing one would put a name in the map that no type admits.
-                Conversions.category(category)?.let { it to Conversions.permissionStatus(status) }
-            }
+            .map { (category, status) -> Conversions.category(category) to Conversions.permissionStatus(status) }
             .toMap()
         return StatusesResult(statuses)
     }
@@ -187,6 +197,12 @@ internal class TerraBridgeOpsImpl(
     override suspend fun bodyHeartRate(request: RangeRequest): HeartRateList =
         HeartRateList(terra.body.heartRate(Conversions.timeRange(request.range)).map(Conversions::heartRate))
 
+    override suspend fun bodyRestingHeartRate(request: RangeRequest): RestingHeartRateList =
+        RestingHeartRateList(terra.body.restingHeartRate(Conversions.timeRange(request.range)).map(ReadConversions::restingHeartRate))
+
+    override suspend fun bodyReadings(request: RangeRequest): BodyReadingList =
+        BodyReadingList(terra.body.readings(Conversions.timeRange(request.range)).mapNotNull(ReadConversions::bodyReading))
+
     override suspend fun bodyLogHeartRate(request: HeartRateEntryList): RecordIdList =
         RecordIdList(terra.body.log(request.entries.map(Conversions::entry)).map { it.value })
 
@@ -203,6 +219,12 @@ internal class TerraBridgeOpsImpl(
     override suspend fun dailySteps(request: RangeRequest): StepCountList =
         StepCountList(terra.daily.steps(Conversions.timeRange(request.range)).map(Conversions::steps))
 
+    override suspend fun dailyTotals(request: RangeRequest): DayTotalList =
+        DayTotalList(terra.daily.totals(Conversions.timeRange(request.range)).mapNotNull(ReadConversions::dayTotal))
+
+    override suspend fun dailyIntraday(request: RangeRequest): IntradaySampleList =
+        IntradaySampleList(terra.daily.intraday(Conversions.timeRange(request.range)).map(ReadConversions::intraday))
+
     override suspend fun dailyLog(request: StepEntryList): RecordIdList =
         RecordIdList(terra.daily.log(request.entries.map(Conversions::entry)).map { it.value })
 
@@ -229,6 +251,12 @@ internal class TerraBridgeOpsImpl(
     override suspend fun activityWorkouts(request: RangeRequest): WorkoutList =
         WorkoutList(terra.activity.workouts(Conversions.timeRange(request.range)).map(Conversions::workout))
 
+    override suspend fun activityRoutes(request: RangeRequest): WorkoutRouteList =
+        WorkoutRouteList(terra.activity.routes(Conversions.timeRange(request.range)).map(ReadConversions::route))
+
+    override suspend fun activityIntensity(request: RangeRequest): WorkoutIntensityList =
+        WorkoutIntensityList(terra.activity.intensity(Conversions.timeRange(request.range)).map(ReadConversions::intensity))
+
     override suspend fun activityLog(request: WorkoutEntryList): RecordIdList =
         RecordIdList(terra.activity.log(request.entries.map(Conversions::entry)).map { it.value })
 
@@ -239,6 +267,9 @@ internal class TerraBridgeOpsImpl(
 
     // ---- nutrition --------------------------------------------------------------------------
 
+    override suspend fun nutritionQuantities(request: RangeRequest): DietaryQuantityList =
+        DietaryQuantityList(terra.nutrition.quantities(Conversions.timeRange(request.range)).map(Conversions::quantity))
+
     override suspend fun nutritionLog(request: NutritionEntryList): RecordIdList =
         RecordIdList(terra.nutrition.log(request.entries.map(Conversions::entry)).map { it.value })
 
@@ -247,6 +278,17 @@ internal class TerraBridgeOpsImpl(
         return Empty()
     }
 
+    override suspend fun nutritionHydration(request: RangeRequest): HydrationList =
+        HydrationList(terra.nutrition.hydration(Conversions.timeRange(request.range)).map(ReadConversions::hydration))
+
+    // ---- menstruation -----------------------------------------------------------------------
+
+    override suspend fun menstruationFlow(request: RangeRequest): MenstruationFlowDayList =
+        MenstruationFlowDayList(terra.menstruation.flow(Conversions.timeRange(request.range)).map(Conversions::flowDay))
+
+    override suspend fun menstruationEvents(request: RangeRequest): MenstrualEventList =
+        MenstrualEventList(terra.menstruation.events(Conversions.timeRange(request.range)).mapNotNull(ReadConversions::menstrualEvent))
+
     /** Absent means the default source, which is what every other entry point on the SDK assumes. */
     private fun sourceOf(wire: WireSource?): Source = wire?.let(Conversions::source) ?: Source.HEALTH
 

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

@@ -10,7 +10,6 @@ import co.tryterra.sdk.bridge.generated.TokenRequest
 import java.time.ZoneId
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.mapNotNull
 
 /**
  * The hand-written half of the streams: which SDK flow answers each stream, as typed values.
@@ -43,10 +42,9 @@ internal class TerraBridgeStreamsImpl(
             DataCategory.DAILY -> terra.daily.changes()
             DataCategory.SLEEP -> terra.sleep.changes()
             DataCategory.ACTIVITY -> terra.activity.changes()
-            // Nutrition is write-only on both platforms and has no `changes()`.
             DataCategory.NUTRITION, DataCategory.MENSTRUATION ->
                 error("no change stream for $category")
         }
-        return source.mapNotNull { change -> Conversions.change(change, deviceZone) }
+        return source.map { change -> Conversions.change(change, deviceZone) }
     }
 }