Feat: build 16

Tiny/App/ContentView.swift

@@ -11,15 +11,21 @@ import SwiftData
 struct ContentView: View {
     @AppStorage("hasShownOnboarding") var hasShownOnboarding: Bool = false
     @StateObject private var heartbeatSoundManager = HeartbeatSoundManager()
-    @State private var showTimeline = false
-
+
     @Environment(\.modelContext) private var modelContext
+    @EnvironmentObject var authService: AuthenticationService
+    @EnvironmentObject var syncManager: HeartbeatSyncManager
 
     var body: some View {
         Group {
             if hasShownOnboarding {
-                HeartbeatMainView()
+                // After onboarding → always go to RootView (SignIn → Onboarding → Main)
+                RootView()
+                    .environmentObject(heartbeatSoundManager)
+                    .environmentObject(authService)
+                    .environmentObject(syncManager)
             } else {
+                // Onboarding only
                 OnBoardingView(hasShownOnboarding: $hasShownOnboarding)
             }
         }
@@ -31,6 +37,25 @@ struct ContentView: View {
     }
 }
 
+struct RootView: View {
+    @EnvironmentObject var authService: AuthenticationService
+
+    var body: some View {
+        Group {
+            if !authService.isAuthenticated {
+                // Step 1: Landing screen with Sign in with Apple
+                SignInView()
+            } else if authService.currentUser?.role == nil {
+                // Step 2-4: Onboarding flow (role selection, name input, room code)
+                OnboardingCoordinator()
+            } else {
+                // Step 5: Main app - go to HeartbeatMainView
+                HeartbeatMainView()
+            }
+        }
+    }
+}
+
 #Preview {
     ContentView()
         .modelContainer(for: SavedHeartbeat.self, inMemory: true)

Tiny/App/tinyApp.swift

@@ -7,16 +7,26 @@
 
 import SwiftUI
 import SwiftData
+import FirebaseCore
 
 @main
 struct TinyApp: App {
     @StateObject var heartbeatSoundManager = HeartbeatSoundManager()
+    @StateObject private var themeManager = ThemeManager()
+    @StateObject var authService = AuthenticationService()
+    @StateObject var syncManager = HeartbeatSyncManager()
+
     @State private var isShowingSplashScreen: Bool = true // Add state to control splash screen
 
+    init() {
+        FirebaseApp.configure()
+    }
+
     // Define the container configuration
     var sharedModelContainer: ModelContainer = {
         let schema = Schema([
-            SavedHeartbeat.self
+            SavedHeartbeat.self,
+            SavedMoment.self
         ])
         let modelConfiguration = ModelConfiguration(schema: schema, isStoredInMemoryOnly: false)
 
@@ -31,10 +41,15 @@ struct TinyApp: App {
         WindowGroup {
             if isShowingSplashScreen {
                 SplashScreenView(isShowingSplashScreen: $isShowingSplashScreen)
+                    .environmentObject(themeManager)
                     .preferredColorScheme(.dark)
             } else {
                 ContentView()
                     .environmentObject(heartbeatSoundManager)
+                    .environmentObject(authService)
+                    .environmentObject(syncManager)
+                    .environmentObject(themeManager)
+                    .preferredColorScheme(.dark)
             }
         }
         .modelContainer(sharedModelContainer)

Tiny/Core/Animation/TimelineAnimationController.swift

@@ -0,0 +1,97 @@
+//
+//  TimelineAnimationController.swift
+//  Tiny
+//
+//  Animation state management for timeline first-time experience
+//
+
+import SwiftUI
+internal import Combine
+
+enum AnimationPhase {
+    case empty
+    case drawingPath
+    case showingDots
+    case transformingOrb
+    case showingProfile
+    case complete
+}
+
+class TimelineAnimationController: ObservableObject {
+    @Published var currentPhase: AnimationPhase = .empty
+    @Published var pathProgress: CGFloat = 0.0
+    @Published var dotsVisible: [Bool] = [false, false, false]
+    @Published var orbVisible: Bool = false
+    @Published var profileVisible: Bool = false
+
+    // Timing constants (in seconds) - Slowed down for better visibility
+    private let pathDuration: Double = 2.5  // Was 1.5
+    private let dotDelay: Double = 0.9      // Was 0.33
+    private let dotDuration: Double = 0.9   // Was 0.3
+    private let transformDuration: Double = 1.0  // Was 0.7
+    private let profileDuration: Double = 0.8    // Was 0.6
+
+    func startAnimation() {
+        currentPhase = .drawingPath
+        animatePathDrawing()
+    }
+
+    private func animatePathDrawing() {
+        withAnimation(.easeInOut(duration: pathDuration)) {
+            pathProgress = 1.0
+        }
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + pathDuration) {
+            self.currentPhase = .showingDots
+            self.animateDotsAppearing()
+        }
+    }
+
+    private func animateDotsAppearing() {
+        // Show dots sequentially
+        for index in 0..<3 {
+            DispatchQueue.main.asyncAfter(deadline: .now() + (Double(index) * dotDelay)) {
+                withAnimation(.easeOut(duration: self.dotDuration)) {
+                    self.dotsVisible[index] = true
+                }
+            }
+        }
+
+        // After all dots appear, transform first dot to orb
+        let totalDotTime = Double(3) * dotDelay + dotDuration
+        DispatchQueue.main.asyncAfter(deadline: .now() + totalDotTime) {
+            self.currentPhase = .transformingOrb
+            self.animateOrbTransform()
+        }
+    }
+
+    private func animateOrbTransform() {
+        withAnimation(.spring(response: 0.6, dampingFraction: 0.75)) {
+            dotsVisible[0] = false
+            orbVisible = true
+        }
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + transformDuration) {
+            self.currentPhase = .showingProfile
+            self.animateProfileAppear()
+        }
+    }
+
+    private func animateProfileAppear() {
+        withAnimation(.easeIn(duration: profileDuration)) {
+            profileVisible = true
+        }
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + profileDuration) {
+            self.currentPhase = .complete
+        }
+    }
+
+    func skipAnimation() {
+        currentPhase = .complete
+        pathProgress = 1.0
+        dotsVisible = [false, false, false]
+        orbVisible = true
+        profileVisible = true
+    }
+}

Tiny/Core/Components/BokehEffectView.swift

@@ -9,6 +9,7 @@ import SwiftUI
 internal import Combine
 
 struct BokehEffectView: View {
+    @EnvironmentObject var themeManager: ThemeManager
     @Binding var amplitude: Float
 
     private var pulseOpacity: Double {
@@ -19,13 +20,17 @@ struct BokehEffectView: View {
     private var pulseScale: CGFloat {
         return 1.0 + CGFloat(amplitude) * 0.3
     }
+
+    private var bokehColor: Color {
+        themeManager.selectedOrbStyle.bokehColor
+    }
 
     var body: some View {
         ZStack {
             // Layer 1: The Base Glow (Shifted Left)
             // This is the bottom layer, slightly less bright.
             Circle()
-                .fill(Color.orbLightYellow)
+                .fill(bokehColor)
                 .frame(width: 30)
                 .opacity(pulseOpacity * 0.5)
                 .scaleEffect(pulseScale * 1)
@@ -34,7 +39,7 @@ struct BokehEffectView: View {
             // Layer 2: The Core/Highlight (Shifted Right)
             // *** We apply .blendMode(.screen) here to brighten the overlap ***
             Circle()
-                .fill(Color.orbLightYellow)
+                .fill(bokehColor)
                 .frame(width: 30)
                 .opacity(pulseOpacity * 0.5)
                 .scaleEffect(pulseScale * 1.1)