Fix sync bugs and add fuel burn, warnings, presets, PDF export

Bug fixes:
- Fix SyncService station/fuel load serialization (wrong JSON format)
- Fix Google Sign-In passing empty idToken (now uses GIDSignIn SDK)
- Add auto-sync after login via onAuthenticated callback
- Add background sync on app resume via scenePhase observer

Features:
- Fuel burn CG trajectory: slider input, landing weight/CG calculation,
  dashed trajectory line on CG envelope chart with animated landing point
- Actionable remediation warnings: suggest specific fuel/weight reductions
  when over max gross (e.g. "Remove 8 gal fuel OR reduce seats by 47 lbs")
- FAA AC 120-27F passenger weight presets: seasonal adult M/F/child buttons
  on seat station rows (winter Nov-Mar, summer Apr-Oct)
- PDF load sheet export: professional W&B document with aircraft info,
  breakdown table, warnings, and share sheet integration

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: larpey

ios/PreFlightWB/PreFlightWB/App/PreFlightWBApp.swift

@@ -4,6 +4,7 @@ import SwiftData
 @main
 struct PreFlightWBApp: App {
     @State private var authManager = AuthManager()
+    @Environment(\.scenePhase) private var scenePhase
 
     let modelContainer: ModelContainer
 
@@ -21,7 +22,27 @@ struct PreFlightWBApp: App {
         WindowGroup {
             ContentView()
                 .environment(authManager)
+                .onAppear {
+                    let container = modelContainer
+                    authManager.onAuthenticated = {
+                        await syncQuietly(container: container)
+                    }
+                }
         }
         .modelContainer(modelContainer)
+        .onChange(of: scenePhase) { _, newPhase in
+            if newPhase == .active, authManager.isAuthenticated {
+                Task { @MainActor in
+                    await syncQuietly(container: modelContainer)
+                }
+            }
+        }
+    }
+
+    @MainActor
+    private func syncQuietly(container: ModelContainer) async {
+        let context = container.mainContext
+        let syncService = SyncService(modelContext: context)
+        _ = try? await syncService.syncScenarios()
     }
 }

ios/PreFlightWB/PreFlightWB/Engine/Calculator.swift

@@ -169,12 +169,20 @@ enum Calculator {
 
         // OVER_MAX_GROSS or NEAR_MAX_GROSS
         if !isWithinWeightLimit {
+            let excess = totalWeight - maxGross
+            let remediation = buildWeightRemediation(
+                excess: excess,
+                stationDetails: stationDetails,
+                fuelDetails: fuelDetails,
+                fuelTanks: aircraft.fuelTanks
+            )
             warnings.append(CalculationWarning(
                 level: .danger,
                 code: .overMaxGross,
                 message: "Aircraft exceeds maximum takeoff weight",
-                detail: "\(formatDecimal(totalWeight, decimals: 1)) lbs exceeds limit of \(formatWithComma(maxGross)) lbs by \(formatDecimal(totalWeight - maxGross, decimals: 1)) lbs",
-                regulatoryRef: "FAR 91.103"
+                detail: "\(formatDecimal(totalWeight, decimals: 1)) lbs exceeds limit of \(formatWithComma(maxGross)) lbs by \(formatDecimal(excess, decimals: 1)) lbs",
+                regulatoryRef: "FAR 91.103",
+                remediation: remediation
             ))
         } else if weightMargin < maxGross * 0.05 {
             warnings.append(CalculationWarning(
@@ -264,6 +272,134 @@ enum Calculator {
         )
     }
 
+    // MARK: - Landing Calculation
+
+    /// Calculate landing weight and CG after fuel burn.
+    ///
+    /// Distributes the fuel burn proportionally across all tanks based on
+    /// their current load. Returns nil if no fuel burn is specified.
+    ///
+    /// - Parameters:
+    ///   - takeoffResult: The takeoff calculation result.
+    ///   - aircraft: The aircraft definition.
+    ///   - fuelLoads: Current fuel loads in each tank.
+    ///   - fuelBurnGallons: Total gallons expected to burn during flight.
+    /// - Returns: A `LandingResult` with landing weight, CG, and any warnings.
+    static func calculateLanding(
+        takeoffResult: CalculationResult,
+        aircraft: Aircraft,
+        fuelLoads: [FuelLoad],
+        fuelBurnGallons: Double
+    ) -> LandingResult? {
+        guard fuelBurnGallons > 0 else { return nil }
+
+        let totalFuelGallons = fuelLoads.reduce(0.0) { $0 + max(0, $1.gallons) }
+        guard totalFuelGallons > 0 else { return nil }
+
+        // Distribute burn proportionally across tanks
+        var burnedWeight = 0.0
+        var burnedMoment = 0.0
+        var warnings: [CalculationWarning] = []
+
+        let actualBurn = min(fuelBurnGallons, totalFuelGallons)
+        if fuelBurnGallons > totalFuelGallons {
+            warnings.append(CalculationWarning(
+                level: .danger,
+                code: .negativeFuel,
+                message: "Fuel burn exceeds loaded fuel",
+                detail: "Planned burn of \(formatDecimal(fuelBurnGallons, decimals: 0)) gal exceeds \(formatDecimal(totalFuelGallons, decimals: 0)) gal loaded",
+                regulatoryRef: nil
+            ))
+        }
+
+        for load in fuelLoads {
+            guard let tank = aircraft.fuelTanks.first(where: { $0.id == load.tankId }) else { continue }
+            let proportion = load.gallons / totalFuelGallons
+            let tankBurnGallons = actualBurn * proportion
+            let tankBurnWeight = tankBurnGallons * tank.fuelWeightPerGallon
+            burnedWeight += tankBurnWeight
+            burnedMoment += tankBurnWeight * tank.arm.value
+        }
+
+        let landingWeight = takeoffResult.totalWeight - burnedWeight
+        let landingMoment = takeoffResult.totalMoment - burnedMoment
+        let landingCG = landingWeight > 0 ? landingMoment / landingWeight : 0
+
+        let isWithinEnvelope = Envelope.isPointInEnvelope(
+            weight: landingWeight,
+            cg: landingCG,
+            envelope: aircraft.cgEnvelope
+        )
+        let isWithinWeightLimit = landingWeight <= aircraft.maxGrossWeight.value
+
+        // Check landing weight limit if aircraft has one
+        if let maxLanding = aircraft.maxLandingWeight {
+            if landingWeight > maxLanding.value {
+                warnings.append(CalculationWarning(
+                    level: .warning,
+                    code: .overMaxLanding,
+                    message: "Landing weight exceeds max landing weight",
+                    detail: "\(formatDecimal(landingWeight, decimals: 0)) lbs exceeds landing limit of \(formatWithComma(maxLanding.value)) lbs",
+                    regulatoryRef: nil
+                ))
+            }
+        }
+
+        if !isWithinEnvelope {
+            warnings.append(CalculationWarning(
+                level: .danger,
+                code: .cgOutOfEnvelope,
+                message: "Landing CG outside approved envelope",
+                detail: "CG shifts to \(formatDecimal(landingCG, decimals: 2)) in after \(formatDecimal(actualBurn, decimals: 0)) gal fuel burn",
+                regulatoryRef: "FAR 91.103"
+            ))
+        }
+
+        return LandingResult(
+            landingWeight: landingWeight,
+            landingCG: landingCG,
+            fuelBurnGallons: actualBurn,
+            fuelBurnWeight: burnedWeight,
+            isWithinCGEnvelope: isWithinEnvelope,
+            isWithinWeightLimit: isWithinWeightLimit,
+            warnings: warnings
+        )
+    }
+
+    // MARK: - Remediation Helpers
+
+    /// Build actionable remediation text for an overweight condition.
+    /// Suggests removing fuel or reducing the heaviest loaded station.
+    private static func buildWeightRemediation(
+        excess: Double,
+        stationDetails: [StationDetail],
+        fuelDetails: [FuelDetail],
+        fuelTanks: [FuelTank]
+    ) -> String {
+        var suggestions: [String] = []
+
+        // Suggest fuel reduction for each tank that has fuel
+        for detail in fuelDetails where detail.weight > 0 {
+            if let tank = fuelTanks.first(where: { $0.id == detail.tankId }) {
+                let gallonsToRemove = ceil(excess / tank.fuelWeightPerGallon)
+                if gallonsToRemove <= detail.gallons {
+                    suggestions.append("Remove \(formatDecimal(gallonsToRemove, decimals: 0)) gal from \(detail.name)")
+                }
+            }
+        }
+
+        // Suggest reducing the heaviest station
+        if let heaviest = stationDetails.filter({ $0.weight > 0 }).max(by: { $0.weight < $1.weight }),
+           heaviest.weight >= excess {
+            suggestions.append("Reduce \(heaviest.name) by \(formatDecimal(excess, decimals: 0)) lbs")
+        }
+
+        if suggestions.isEmpty {
+            return "Reduce total load by \(formatDecimal(excess, decimals: 0)) lbs"
+        }
+        return suggestions.prefix(2).joined(separator: " OR ")
+    }
+
     // MARK: - Formatting Helpers
 
     /// Format a number with a fixed number of decimal places.

ios/PreFlightWB/PreFlightWB/Models/Calculation.swift

@@ -80,6 +80,16 @@ struct CalculationWarning: Codable, Sendable {
     let message: String
     let detail: String?
     let regulatoryRef: String?
+    let remediation: String?
+
+    init(level: WarningLevel, code: WarningCode, message: String, detail: String?, regulatoryRef: String?, remediation: String? = nil) {
+        self.level = level
+        self.code = code
+        self.message = message
+        self.detail = detail
+        self.regulatoryRef = regulatoryRef
+        self.remediation = remediation
+    }
 }
 
 // MARK: - Calculation Result
@@ -103,3 +113,16 @@ struct CalculationResult: Codable, Sendable {
 
     let warnings: [CalculationWarning]
 }
+
+// MARK: - Landing Result
+
+/// Result of a landing weight & CG calculation after fuel burn.
+struct LandingResult: Sendable {
+    let landingWeight: Double
+    let landingCG: Double
+    let fuelBurnGallons: Double
+    let fuelBurnWeight: Double
+    let isWithinCGEnvelope: Bool
+    let isWithinWeightLimit: Bool
+    let warnings: [CalculationWarning]
+}

ios/PreFlightWB/PreFlightWB/Services/AuthManager.swift

@@ -27,6 +27,9 @@ final class AuthManager {
     /// Non-nil when the most recent auth action failed.
     var error: String?
 
+    /// Called after successful authentication to trigger sync.
+    var onAuthenticated: (() async -> Void)?
+
     // MARK: - Keys
 
     private static let guestKey = "preflight_guest_mode"
@@ -56,6 +59,7 @@ final class AuthManager {
 
         currentUser = user
         isAuthenticated = true
+        await onAuthenticated?()
 
         // Check Apple credential state if session was established via Apple Sign-In
         if UserDefaults.standard.bool(forKey: Self.appleAuthKey),
@@ -94,6 +98,7 @@ final class AuthManager {
             currentUser = response.user
             isAuthenticated = true
             isGuest = false
+            await onAuthenticated?()
         } catch {
             self.error = "Google sign-in failed. Please try again."
         }
@@ -135,6 +140,7 @@ final class AuthManager {
             isGuest = false
             UserDefaults.standard.set(true, forKey: Self.appleAuthKey)
             UserDefaults.standard.set(appleUserId, forKey: Self.appleUserIdKey)
+            await onAuthenticated?()
         } catch {
             self.error = "Apple sign-in failed. Please try again."
         }
@@ -183,6 +189,7 @@ final class AuthManager {
             currentUser = response.user
             isAuthenticated = true
             isGuest = false
+            await onAuthenticated?()
         } catch {
             self.error = "Invalid or expired code. Please try again."
             throw error