@tryterra/react-native 0.0.0-stage → 2.2.1

package/ios/TerraBridgeCore/Conversions.swift

@@ -0,0 +1,594 @@
+import Foundation
+import TerraSDK
+
+/// Between the SDK's types and the generated wire DTOs.
+///
+/// Every `switch` is exhaustive with no `default`, so a case added on either side is a compile
+/// error here rather than a value that maps to something plausible. Unqualified names are the
+/// generated wire types; the SDK's are spelled `TerraSDK.`.
+enum Conversions {
+
+    // MARK: Input the decoder accepted and the SDK cannot
+
+    /// A string field that decoded but is not the instant or id it names. Reported as the same
+    /// `bridge.invalid_payload` the generated decoder raises, with the path and never the value.
+    static func instant(_ text: String, at path: String) throws -> Date {
+        guard let date = BridgeInstant.parse(text) else { throw BridgeError.invalidPayload(path: path) }
+        return date
+    }
+
+    static func uuid(_ text: String, at path: String) throws -> UUID {
+        guard let id = UUID(uuidString: text) else { throw BridgeError.invalidPayload(path: path) }
+        return id
+    }
+
+    static func interval(start: String, end: String, at path: String) throws -> DateInterval {
+        let from = try instant(start, at: "\(path).start")
+        let to = try instant(end, at: "\(path).end")
+        guard from <= to else { throw BridgeError.invalidPayload(path: "\(path).end") }
+        return DateInterval(start: from, end: to)
+    }
+
+    /// The calendar day an instant falls on in `zone`, as `yyyy-MM-dd`.
+    static func localDate(_ date: Date, in zone: TimeZone) -> String {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = zone
+        let parts = calendar.dateComponents([.year, .month, .day], from: date)
+        return day(year: parts.year ?? 0, month: parts.month ?? 0, day: parts.day ?? 0)
+    }
+
+    static func localDate(_ components: DateComponents) -> String {
+        day(year: components.year ?? 0, month: components.month ?? 0, day: components.day ?? 0)
+    }
+
+    private static func day(year: Int, month: Int, day: Int) -> String {
+        String(format: "%04d-%02d-%02d", year, month, day)
+    }
+
+    // MARK: Enums
+
+    // Swift 6 requires `@unknown default` for TerraSDK's non-frozen binary enums.
+
+    static func source(_ wire: Source?) throws -> TerraSDK.Source {
+        switch wire ?? .health {
+        case .health: return .health
+        case .samsungHealth: throw BridgeError.unsupportedOnPlatform(op: "samsungHealth")
+        }
+    }
+
+    static func source(_ source: TerraSDK.Source) -> Source {
+        switch source {
+        case .health: return .health
+        @unknown default: return .health
+        }
+    }
+
+    static func endUser(_ wire: EndUser) -> TerraSDK.EndUser {
+        switch wire {
+        case .reference(let id): return .reference(id)
+        case .anonymous: return .anonymous
+        }
+    }
+
+    static func category(_ wire: DataCategory) -> TerraSDK.DataCategory {
+        switch wire {
+        case .activity: return .activity
+        case .body: return .body
+        case .daily: return .daily
+        case .sleep: return .sleep
+        case .nutrition: return .nutrition
+        case .menstruation: return .menstruation
+        case .athlete: return .athlete
+        }
+    }
+
+    /// Nil for the categories the surface excludes: there is no wire name to report them under.
+    static func category(_ category: TerraSDK.DataCategory) -> DataCategory? {
+        switch category {
+        case .activity: return .activity
+        case .body: return .body
+        case .daily: return .daily
+        case .sleep: return .sleep
+        case .nutrition: return .nutrition
+        case .menstruation: return .menstruation
+        case .athlete: return .athlete
+        case .healthObservation: return nil
+        @unknown default: return nil
+        }
+    }
+
+    static func permissionStatus(_ status: TerraSDK.PermissionStatus) -> PermissionStatus {
+        switch status {
+        case .granted: return .granted
+        case .denied: return .denied
+        case .notDetermined: return .notDetermined
+        case .notDisclosed: return .notDisclosed
+        case .unavailable: return .unavailable
+        case .unsupported: return .unsupported
+        @unknown default: return .unavailable
+        }
+    }
+
+    static func motionContext(_ context: TerraSDK.MotionContext) -> MotionContext {
+        switch context {
+        case .unknown: return .unknown
+        case .sedentary: return .sedentary
+        case .active: return .active
+        @unknown default: return .unknown
+        }
+    }
+
+    static func deviceType(_ type: TerraSDK.DeviceType) -> String {
+        switch type {
+        case .phone: return "phone"
+        case .scale: return "scale"
+        case .sensor: return "sensor"
+        @unknown default: return "unknown"
+        }
+    }
+
+    // MARK: Unions
+
+    static func timeRange(_ wire: TimeRange, at path: String) throws -> TerraSDK.TimeRange {
+        switch wire {
+        case .lastHours(let hours): return .lastHours(hours)
+        case .lastDays(let days): return .lastDays(days)
+        case .today: return .today
+        case .between(let start, let end):
+            let window = try interval(start: start, end: end, at: path)
+            return .between(window.start, window.end)
+        }
+    }
+
+    static func sleepStage(_ stage: TerraSDK.SleepStage) -> SleepStage {
+        switch stage {
+        case .inBed: return .inBed
+        case .awake: return .awake
+        case .asleep: return .asleep
+        case .light: return .light
+        case .deep: return .deep
+        case .rem: return .rem
+        case .unknown(let raw): return .unknown(raw: raw)
+        @unknown default: return .unknown(raw: String(describing: stage))
+        }
+    }
+
+    static func sleepStage(_ wire: SleepStage) -> TerraSDK.SleepStage {
+        switch wire {
+        case .inBed: return .inBed
+        case .awake: return .awake
+        case .asleep: return .asleep
+        case .light: return .light
+        case .deep: return .deep
+        case .rem: return .rem
+        case .unknown(let raw): return .unknown(raw)
+        }
+    }
+
+    static func activity(_ activity: TerraSDK.WorkoutActivity) -> WorkoutActivity {
+        switch activity {
+        case .running: return .running
+        case .walking: return .walking
+        case .cycling: return .cycling
+        case .swimming: return .swimming
+        case .strengthTraining: return .strengthTraining
+        case .other(let label): return .other(label: label)
+        @unknown default: return .other(label: String(describing: activity))
+        }
+    }
+
+    static func activity(_ wire: WorkoutActivity) -> TerraSDK.WorkoutActivity {
+        switch wire {
+        case .running: return .running
+        case .walking: return .walking
+        case .cycling: return .cycling
+        case .swimming: return .swimming
+        case .strengthTraining: return .strengthTraining
+        case .other(let label): return .other(label)
+        }
+    }
+
+    /// The order a grant is listed in. Android sorts by the same names, so one grant is one byte
+    /// sequence on both platforms.
+    static func sortKey(_ activity: WorkoutActivity) -> String {
+        switch activity {
+        case .running: return "Running"
+        case .walking: return "Walking"
+        case .cycling: return "Cycling"
+        case .swimming: return "Swimming"
+        case .strengthTraining: return "Strength Training"
+        case .other(let label): return label
+        }
+    }
+
+    static func diagnosticsState(_ state: TerraSDK.DiagnosticsState) -> DiagnosticsState {
+        switch state {
+        case .healthy: return .healthy
+        case .quiet(let since): return .quiet(since: BridgeInstant.format(since))
+        // Apple does not disclose why, so the reason is absent rather than guessed.
+        case .backgroundRestricted: return .backgroundRestricted(reason: nil)
+        case .backgroundRefreshUnscheduled: return .backgroundRefreshUnscheduled
+        case .pendingRetry: return .pendingRetry
+        case .linkRevoked: return .linkRevoked
+        case .devIDMismatch: return .devIDMismatch
+        @unknown default: return .pendingRetry
+        }
+    }
+
+    // MARK: Records
+
+    static func connection(_ connection: TerraSDK.Connection) -> Connection {
+        Connection(source: source(connection.source), userId: connection.userID)
+    }
+
+    static func sampleSource(_ source: TerraSDK.SampleSource) -> SampleSource {
+        SampleSource(
+            name: source.name,
+            bundleId: source.bundleID,
+            productType: source.productType,
+            deviceType: source.deviceType.map(deviceType))
+    }
+
+    static func heartRate(_ sample: TerraSDK.HeartRateSample) -> HeartRateSample {
+        HeartRateSample(
+            id: sample.id.uuidString,
+            time: BridgeInstant.format(sample.time),
+            beatsPerMinute: sample.beatsPerMinute,
+            source: sampleSource(sample.source),
+            motionContext: sample.motionContext.map(motionContext),
+            userEntered: sample.userEntered,
+            timeZone: sample.timeZone?.identifier)
+    }
+
+    static func steps(_ sample: TerraSDK.StepCount) -> StepCount {
+        StepCount(
+            id: sample.id,
+            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?.identifier)
+    }
+
+    static func segment(_ segment: TerraSDK.SleepSegment) -> SleepSegment {
+        SleepSegment(
+            id: segment.id.uuidString,
+            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?.identifier)
+    }
+
+    static func workout(_ workout: TerraSDK.Workout) -> Workout {
+        Workout(
+            id: workout.id.uuidString,
+            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?.identifier,
+            title: workout.title)
+    }
+
+    static func nutrient(_ nutrient: TerraSDK.Nutrient) -> Nutrient? {
+        switch nutrient {
+        case .energyConsumed: return .energyConsumed
+        case .protein: return .protein
+        case .carbohydrates: return .carbohydrates
+        case .fatTotal: return .fatTotal
+        case .fatSaturated: return .fatSaturated
+        case .fatMonounsaturated: return .fatMonounsaturated
+        case .fatPolyunsaturated: return .fatPolyunsaturated
+        case .sugar: return .sugar
+        case .fiber: return .fiber
+        case .cholesterol: return .cholesterol
+        case .sodium: return .sodium
+        case .potassium: return .potassium
+        case .calcium: return .calcium
+        case .iron: return .iron
+        case .magnesium: return .magnesium
+        case .zinc: return .zinc
+        case .phosphorus: return .phosphorus
+        case .iodine: return .iodine
+        case .manganese: return .manganese
+        case .molybdenum: return .molybdenum
+        case .selenium: return .selenium
+        case .copper: return .copper
+        case .chromium: return .chromium
+        case .chloride: return .chloride
+        case .caffeine: return .caffeine
+        case .vitaminA: return .vitaminA
+        case .vitaminC: return .vitaminC
+        case .vitaminD: return .vitaminD
+        case .vitaminE: return .vitaminE
+        case .vitaminK: return .vitaminK
+        case .vitaminB6: return .vitaminB6
+        case .vitaminB12: return .vitaminB12
+        case .thiamin: return .thiamin
+        case .riboflavin: return .riboflavin
+        case .niacin: return .niacin
+        case .folate: return .folate
+        case .biotin: return .biotin
+        case .pantothenicAcid: return .pantothenicAcid
+        @unknown default: return nil
+        }
+    }
+
+    static func mealType(_ type: TerraSDK.MealType) -> MealType {
+        switch type {
+        case .breakfast: return .breakfast
+        case .lunch: return .lunch
+        case .dinner: return .dinner
+        case .snack: return .snack
+        case .unknown: return .unknown
+        @unknown default: return .unknown
+        }
+    }
+
+    static func flow(_ flow: TerraSDK.MenstruationFlowDay.Flow) -> MenstruationFlow {
+        switch flow {
+        case .unspecified: return .unspecified
+        case .light: return .light
+        case .medium: return .medium
+        case .heavy: return .heavy
+        case .noFlow: return .noFlow
+        @unknown default: return .unspecified
+        }
+    }
+
+    static func biologicalSex(_ sex: TerraSDK.AthleteProfile.BiologicalSex) -> BiologicalSex {
+        switch sex {
+        case .female: return .female
+        case .male: return .male
+        case .other: return .other
+        case .notSet: return .notSet
+        @unknown default: return .notSet
+        }
+    }
+
+    static func moveMode(_ mode: TerraSDK.AthleteProfile.ActivityMoveMode) -> ActivityMoveMode? {
+        switch mode {
+        case .activeEnergy: return .activeEnergy
+        case .appleMoveTime: return .appleMoveTime
+        @unknown default: return nil
+        }
+    }
+
+    static func quantity(_ quantity: TerraSDK.DietaryQuantity) -> DietaryQuantity? {
+        guard let nutrient = nutrient(quantity.nutrient) else { return nil }
+        return DietaryQuantity(
+            id: quantity.id.uuidString,
+            nutrient: 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?.uuidString,
+            source: sampleSource(quantity.source),
+            userEntered: quantity.userEntered,
+            timeZone: quantity.timeZone?.identifier)
+    }
+
+    static func flowDay(_ day: TerraSDK.MenstruationFlowDay) -> MenstruationFlowDay {
+        MenstruationFlowDay(
+            id: day.id.uuidString,
+            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?.identifier)
+    }
+
+    /// The birth date is a calendar day. HealthKit hands back components, which the store turns into
+    /// a `Date` at midnight in the device's zone, so the same zone reads the same day back out.
+    static func athleteProfile(_ profile: TerraSDK.AthleteProfile, zone: TimeZone) -> AthleteProfile {
+        AthleteProfile(
+            biologicalSex: biologicalSex(profile.biologicalSex),
+            dateOfBirth: profile.dateOfBirth.map { localDate($0, in: zone) },
+            wheelchairUse: profile.wheelchairUse,
+            activityMoveMode: profile.activityMoveMode.flatMap(moveMode))
+    }
+
+    /// A day, not an instant: sending the instant would let the receiver re-derive the day in its
+    /// own zone and get a different one either side of midnight.
+    static func change(_ change: TerraSDK.HealthChange, zone: TimeZone) -> HealthChange? {
+        category(change.category).map { HealthChange(category: $0, day: localDate(change.day, in: zone)) }
+    }
+
+    /// `@unknown default` because the binary SDK is built with library evolution, where this enum
+    /// can grow; `SchemaParityTests` is what fails when it does. A status this build predates
+    /// reads as one it cannot schedule on.
+    static func schedulingStatus(_ status: TerraSDK.WorkoutSchedulingStatus) -> WorkoutSchedulingStatus {
+        switch status {
+        case .unsupported: .unsupported
+        case .notDetermined: .notDetermined
+        case .denied: .denied
+        case .authorized: .authorized
+        @unknown default: .unsupported
+        }
+    }
+
+    static func plannedWorkout(_ plan: TerraSDK.PlannedWorkout) -> PlannedWorkout {
+        PlannedWorkout(
+            id: plan.id,
+            plannedOn: localDate(plan.plannedOn),
+            activity: activity(plan.activity),
+            title: plan.title,
+            completedAt: plan.completedAt.map(BridgeInstant.format))
+    }
+
+    /// Sorted, because a `Set` has no order and JSON has no set.
+    static func access(_ access: TerraSDK.HealthAccess) -> HealthAccess {
+        HealthAccess(
+            read: access.read.compactMap(category).sorted { $0.rawValue < $1.rawValue },
+            write: access.write.compactMap(category).sorted { $0.rawValue < $1.rawValue },
+            workouts: ordered(access.workouts
+                .map { WorkoutScope(activity: activity($0.activity), energy: $0.energy, distance: $0.distance) }))
+    }
+
+    static func ordered(_ scopes: [WorkoutScope]) -> [WorkoutScope] {
+        scopes.sorted { ($0.sortKey, $0.wireKey) < ($1.sortKey, $1.wireKey) }
+    }
+
+    static func scope(_ wire: WorkoutScope) -> TerraSDK.WorkoutScope {
+        TerraSDK.WorkoutScope(activity: activity(wire.activity), energy: wire.energy, distance: wire.distance)
+    }
+
+    // MARK: Diagnostics
+
+    /// The SDK's own `Encodable` spelling, with the bridge's instant format. Not reshaped: a second
+    /// encoding here would be a contract no vector pins.
+    static func event(_ event: TerraSDK.TerraEvent) throws -> TerraEvent {
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .custom { date, encoder in
+            var container = encoder.singleValueContainer()
+            try container.encode(BridgeInstant.format(date))
+        }
+        let json = try BridgeDispatch.makeDecoder().decode(TerraEvent.self, from: encoder.encode(event))
+        try TerraEventEnvelope.validate(json)
+        return json
+    }
+
+    static func report(_ report: TerraSDK.SupportReport) throws -> SupportReport {
+        SupportReport(
+            sdkVersion: report.sdkVersion,
+            generatedAt: BridgeInstant.format(report.generatedAt),
+            state: diagnosticsState(report.state),
+            lastDelivery: report.lastDelivery.map(BridgeInstant.format),
+            isConnected: report.isConnected,
+            requestedCategories: report.requestedCategories,
+            requestedWrites: report.requestedWrites,
+            requestedWorkouts: report.requestedWorkouts,
+            recentEvents: try report.recentEvents.map(event))
+    }
+
+    // MARK: Write entries
+
+    /// An absent record id is left to the SDK's own default rather than minted here.
+    static func entry(_ wire: HeartRateEntry, at path: String) throws -> TerraSDK.HeartRateEntry {
+        let time = try instant(wire.time, at: "\(path).time")
+        guard let id = wire.recordId else { return .init(time: time, beatsPerMinute: wire.beatsPerMinute) }
+        return .init(time: time, beatsPerMinute: wire.beatsPerMinute, recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    static func entry(_ wire: StepEntry, at path: String) throws -> TerraSDK.StepEntry {
+        let interval = try Self.interval(start: wire.start, end: wire.end, at: path)
+        guard let id = wire.recordId else { return .init(interval: interval, steps: wire.steps) }
+        return .init(interval: interval, steps: wire.steps, recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    static func entry(_ wire: SleepEntry, at path: String) throws -> TerraSDK.SleepEntry {
+        let interval = try Self.interval(start: wire.start, end: wire.end, at: path)
+        let stage = sleepStage(wire.stage)
+        guard let id = wire.recordId else { return .init(interval: interval, stage: stage) }
+        return .init(interval: interval, stage: stage, recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    static func entry(_ wire: WorkoutEntry, at path: String) throws -> TerraSDK.WorkoutEntry {
+        let interval = try Self.interval(start: wire.start, end: wire.end, at: path)
+        let activity = Self.activity(wire.activity)
+        guard let id = wire.recordId else {
+            return .init(
+                interval: interval, activity: activity,
+                totalEnergyKilocalories: wire.totalEnergyKilocalories,
+                totalDistanceMeters: wire.totalDistanceMeters)
+        }
+        return .init(
+            interval: interval, activity: activity,
+            totalEnergyKilocalories: wire.totalEnergyKilocalories,
+            totalDistanceMeters: wire.totalDistanceMeters,
+            recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    static func entry(_ wire: BodyEntry, at path: String) throws -> TerraSDK.BodyEntry {
+        let time = try instant(wire.time, at: "\(path).time")
+        var entry = try wire.recordId.map { TerraSDK.BodyEntry(time: time, recordID: try uuid($0, at: "\(path).recordId")) }
+            ?? TerraSDK.BodyEntry(time: time)
+        entry.bodyMassKilograms = wire.bodyMassKilograms
+        entry.bodyFatPercent = wire.bodyFatPercent
+        entry.bodyMassIndex = wire.bodyMassIndex
+        entry.heightMeters = wire.heightMeters
+        entry.leanBodyMassKilograms = wire.leanBodyMassKilograms
+        entry.bodyTemperatureCelsius = wire.bodyTemperatureCelsius
+        entry.oxygenSaturationPercent = wire.oxygenSaturationPercent
+        entry.bloodGlucoseMilligramsPerDeciliter = wire.bloodGlucoseMilligramsPerDeciliter
+        entry.bloodPressureSystolicMillimetersOfMercury = wire.bloodPressureSystolicMillimetersOfMercury
+        entry.bloodPressureDiastolicMillimetersOfMercury = wire.bloodPressureDiastolicMillimetersOfMercury
+        return entry
+    }
+
+    static func entry(_ wire: NutritionEntry, at path: String) throws -> TerraSDK.NutritionEntry {
+        let interval = try Self.interval(start: wire.start, end: wire.end, at: path)
+        let nutrients = Self.nutrients(wire.nutrients)
+        guard let id = wire.recordId else {
+            return .init(interval: interval, name: wire.name, nutrients: nutrients)
+        }
+        return .init(
+            interval: interval, name: wire.name, nutrients: nutrients, recordID: try uuid(id, at: "\(path).recordId"))
+    }
+
+    /// All thirty-nine, by name. The unit is in every name on both sides, so a mismatched pair
+    /// does not compile.
+    private static func nutrients(_ wire: Nutrients) -> TerraSDK.NutritionEntry.Nutrients {
+        var out = TerraSDK.NutritionEntry.Nutrients()
+        out.energyKilocalories = wire.energyKilocalories
+        out.proteinGrams = wire.proteinGrams
+        out.carbohydratesGrams = wire.carbohydratesGrams
+        out.fiberGrams = wire.fiberGrams
+        out.sugarGrams = wire.sugarGrams
+        out.fatTotalGrams = wire.fatTotalGrams
+        out.fatSaturatedGrams = wire.fatSaturatedGrams
+        out.fatMonounsaturatedGrams = wire.fatMonounsaturatedGrams
+        out.fatPolyunsaturatedGrams = wire.fatPolyunsaturatedGrams
+        out.cholesterolMilligrams = wire.cholesterolMilligrams
+        out.sodiumMilligrams = wire.sodiumMilligrams
+        out.potassiumMilligrams = wire.potassiumMilligrams
+        out.calciumMilligrams = wire.calciumMilligrams
+        out.ironMilligrams = wire.ironMilligrams
+        out.magnesiumMilligrams = wire.magnesiumMilligrams
+        out.zincMilligrams = wire.zincMilligrams
+        out.waterLiters = wire.waterLiters
+        out.caffeineMilligrams = wire.caffeineMilligrams
+        out.vitaminAMicrograms = wire.vitaminAMicrograms
+        out.vitaminCMilligrams = wire.vitaminCMilligrams
+        out.vitaminDMicrograms = wire.vitaminDMicrograms
+        out.vitaminEMilligrams = wire.vitaminEMilligrams
+        out.vitaminKMicrograms = wire.vitaminKMicrograms
+        out.vitaminB6Milligrams = wire.vitaminB6Milligrams
+        out.vitaminB12Micrograms = wire.vitaminB12Micrograms
+        out.folateMicrograms = wire.folateMicrograms
+        out.thiaminMilligrams = wire.thiaminMilligrams
+        out.riboflavinMilligrams = wire.riboflavinMilligrams
+        out.niacinMilligrams = wire.niacinMilligrams
+        out.biotinMicrograms = wire.biotinMicrograms
+        out.pantothenicAcidMilligrams = wire.pantothenicAcidMilligrams
+        out.phosphorusMilligrams = wire.phosphorusMilligrams
+        out.iodineMicrograms = wire.iodineMicrograms
+        out.chromiumMicrograms = wire.chromiumMicrograms
+        out.copperMilligrams = wire.copperMilligrams
+        out.manganeseMilligrams = wire.manganeseMilligrams
+        out.molybdenumMicrograms = wire.molybdenumMicrograms
+        out.seleniumMicrograms = wire.seleniumMicrograms
+        out.chlorideMilligrams = wire.chlorideMilligrams
+        return out
+    }
+}
+
+private extension WorkoutScope {
+    var sortKey: String { Conversions.sortKey(activity) }
+
+    var wireKey: String {
+        (try? BridgeDispatch.makeEncoder().encode(self)).map { String(decoding: $0, as: UTF8.self) } ?? ""
+    }
+}