Replace Combine with @Observable and AsyncStream

.claude/agents/change-reviewer.md

@@ -14,10 +14,11 @@ Review all recent code changes thoroughly and provide a structured, actionable a
 
 ## Project Context
 
-- **Branch**: feature/navigation-stack — Pure SwiftUI, NavigationPath, single AppCoordinator (ObservableObject), Combine
+- **Branch**: feature/observation — Pure SwiftUI, @Observable, AsyncSequence + StreamBroadcaster, zero Combine
 - **Packages**: `FunCore` → `FunModel` → `FunViewModel` / `FunServices` → `FunUI` → `FunCoordinator`
 - **Dependency direction**: Never import upward. ViewModel must NOT import UI or Coordinator.
 - **UIKit**: Zero UIKit in this branch — flag any `import UIKit` as a critical issue
+- **Combine**: Zero Combine in this branch — flag any `import Combine` as critical
 - **DI**: ServiceLocator with `@Service` property wrapper, session-scoped (LoginSession / AuthenticatedSession)
 - **Testing**: Swift Testing framework, mocks in FunModelTestSupport
 - **Lint**: SwiftLint with custom rules (no_print, weak_coordinator_in_viewmodel, no_direct_userdefaults)
@@ -38,19 +39,23 @@ Review all recent code changes thoroughly and provide a structured, actionable a
 ### Step 3: Architecture Check
 - Package dependency direction respected?
 - No `import UIKit` — pure SwiftUI branch
+- No `import Combine` — pure AsyncSequence branch
 - No coordinator references in ViewModels (except weak closures)
 - No `print()` — use LoggerService
 - No `UserDefaults.standard` outside Services
 - Navigation logic only in Coordinators (AppCoordinator)
 - NavigationPath mutations only in coordinator, not in Views
 - Protocols in Core (reusable) or Model (domain), never in Services/ViewModel/UI/Coordinator
-- Reactive pattern: Combine (`@Published`, `@StateObject`, `@ObservedObject`, `.sink`)
+- Reactive pattern: `@Observable`, `AsyncStream`, `StreamBroadcaster`, `for await`, `Task`
+- `@ObservationIgnored` on services and non-UI state
+- `@State` (not `@StateObject`) for owning @Observable objects
 
 ### Step 4: Correctness Check
 - **Logic errors**: Algorithms, conditions, control flow
 - **Type safety**: Force unwraps, force casts, unsafe assumptions
 - **Concurrency**: `@MainActor` isolation, `Sendable` conformance, Swift 6 strict
-- **Memory management**: `[weak self]` and `[weak coordinator]` in closures
+- **Memory management**: `[weak self]` and `[weak coordinator]` in closures, `guard let self` inside `for await` loops
+- **Stream lifecycle**: Tasks stored for cancellation? Cleaned up properly?
 - **API contracts**: Public interfaces used correctly
 
 ### Step 5: Quality Check

.claude/skills/pull-request/SKILL.md

@@ -18,8 +18,7 @@ Create a draft PR following the team's quality standards.
 2. **Review changes**
    - `git diff main...HEAD` to review all changes
    - Verify package dependency direction isn't violated
-   - Check for any `print()`, `UserDefaults.standard`, or other anti-patterns
-   - Verify zero UIKit imports (this branch is pure SwiftUI)
+   - Check for any `print()`, `UserDefaults.standard`, `import Combine`, or `import UIKit`
 
 3. **Accessibility checklist** (for UI changes)
    - Dynamic Type: Do text elements scale with user font size preference?

.claude/skills/review/SKILL.md

@@ -21,12 +21,13 @@ Review all recent code changes for completeness, correctness, and consistency wi
 3. **Architecture check**
    - Verify package dependency direction: `Coordinator → UI → ViewModel → Model → Core`, `Services → Model → Core`
    - No `import UIKit` anywhere — this branch is pure SwiftUI
+   - No `import Combine` anywhere — this branch uses AsyncSequence, zero Combine
    - No coordinator references in ViewModels (except weak closures)
    - No `print()` — use LoggerService
    - No `UserDefaults.standard` outside Services
    - Navigation logic only in Coordinators
    - Protocols in Core (reusable) or Model (domain), never in Services/ViewModel/UI/Coordinator
-   - Branch-specific: Combine + NavigationPath + single AppCoordinator (ObservableObject)
+   - Branch-specific: @Observable + AsyncStream + StreamBroadcaster (no Combine, no ObservableObject)
 
 4. **Similar pattern search**
    - Search the codebase for code that follows the same pattern as what changed
@@ -35,6 +36,7 @@ Review all recent code changes for completeness, correctness, and consistency wi
 5. **Correctness check**
    - Logic errors, type safety, concurrency (Swift 6 strict), memory management (`[weak self]`, `[weak coordinator]`)
    - Verify `@MainActor` isolation, `Sendable` conformance where needed
+   - Check `@ObservationIgnored` on properties that shouldn't trigger view updates
 
 6. **Cross-platform parity**
    - Compare with `~/Documents/Source/Fun-Android/` for the same feature

CLAUDE.md

@@ -46,42 +46,43 @@ Never import upward. ViewModel must NOT import UI or Coordinator. Model must NOT
 
 ## Anti-Patterns (Red Flags)
 - `import UIKit` anywhere — this branch is pure SwiftUI, zero UIKit
+- `import Combine` anywhere — this branch uses AsyncSequence, zero Combine
 - Coordinator references in ViewModels (except weak optional closures) — retain cycle risk
 - `print()` anywhere — use LoggerService
 - `UserDefaults.standard` outside Services — use FeatureToggleService
 - Adding `fatalError()` for missing services — ServiceLocator.resolve() already crashes with `fatalError` if a service isn't registered; don't add redundant guards
 - Navigation logic in Views — all navigation (push, pop, tab switch, modal present/dismiss) must go through named AppCoordinator methods (`showDetail`, `selectTab`, `showProfile`, etc.), never inline property manipulation like `coordinator.homePath.append(item)` or `coordinator.isProfilePresented = true`
 - Protocol definitions in Services — domain protocols go in Model, reusable abstractions in Core
-- Wrong ownership annotations — tab content wrappers must use `@StateObject` to own ViewModels (not `@ObservedObject`). `@ObservedObject` on a ViewModel means it gets recreated on every re-render. Conversely, the coordinator must be `let` or `@ObservedObject` (not `@StateObject`) since the wrapper doesn't own it.
+- Wrong ownership annotations — tab content wrappers must use `@State` to own ViewModels (not bare `var`). `@State` ensures the ViewModel survives re-renders. The coordinator must be `let` (not `@Bindable` or `@State`) since the wrapper doesn't own it.
 
-## Architecture (this branch: feature/navigation-stack)
+## Architecture (this branch: feature/observation)
 - **Entry point**: SwiftUI `@main App` struct (`FunApp.swift`) — no AppDelegate or SceneDelegate
-- **Navigation**: Single `AppCoordinator: ObservableObject, SessionProvider` with per-tab `NavigationPath`
+- **Navigation**: Single `@Observable AppCoordinator` with per-tab `NavigationPath`
 - **Views**: Pure SwiftUI views, no UIHostingController or UIViewControllers
-- **Reactive**: Combine (`@Published`, `@StateObject`, `@ObservedObject`, `.sink`)
+- **Reactive**: AsyncSequence + `StreamBroadcaster` (zero Combine). Services yield events via `StreamBroadcaster.yield()`, consumers iterate with `for await event in stream`
+- **Observation**: `@Observable` (not ObservableObject), `@ObservationIgnored` for non-observed state, `@State` (not @StateObject) in app entry
 - **ViewModel → Coordinator**: Optional closures wired in tab content wrappers via `.task { viewModel.onShowDetail = { ... } }`
 - **Tab bar**: SwiftUI `TabView(selection: $coordinator.selectedTab)`
 - **Push nav**: `coordinator.showDetail(item, in: .home)` — named methods on AppCoordinator
 - **Modals**: `.sheet(isPresented: $coordinator.isProfilePresented)`
-- **DI**: Session-scoped ServiceLocator — no `.shared` singleton. Each `Session` creates and owns its own `ServiceLocator`. On session transition, the old ServiceLocator is released with the session (no stale services). `@Service` property wrapper resolves via `static subscript(_enclosingInstance:)` from the enclosing type's `serviceLocator` (requires `ServiceLocatorProvider` conformance). Coordinators and ViewModels receive the current session via constructor injection.
+- **DI**: Session-scoped ServiceLocator — no `.shared` singleton. Each `Session` creates and owns its own `ServiceLocator`. On session transition, the old ServiceLocator is released with the session (no stale services). `@Service` property wrapper resolves via `static subscript(_enclosingInstance:)` from the enclosing type's `serviceLocator` (requires `SessionProvider` conformance + `@ObservationIgnored` on `@Service` properties since `@Observable` can't observe them). Coordinators and ViewModels receive the current session via constructor injection.
 - **Coordinator-owned views**: `AppRootView`, `MainTabView`, and tab content wrappers live in `Coordinator` (not `FunUI`) because they depend on `AppCoordinator`. Moving them to `FunUI` would create a circular dependency (`Coordinator → UI → Coordinator`). Pure reusable views (`HomeView`, `DetailView`, etc.) stay in `FunUI`.
-- **Ownership wrappers**: Tab content wrappers (`HomeTabContent`, `ItemsTabContent`, etc.) use `@StateObject` to **own** their ViewModel and `@ObservedObject` (or `let`) for the coordinator passed from the parent. `@StateObject` ensures the ViewModel survives re-renders; `@ObservedObject` means the wrapper doesn't own the coordinator. Pure views in `FunUI` take `@ObservedObject var viewModel` since the wrapper owns it.
+- **Ownership wrappers**: Tab content wrappers (`HomeTabContent`, `ItemsTabContent`, etc.) use `@State` to **own** their ViewModel and `let` for the coordinator passed from the parent. `@State` ensures the ViewModel survives re-renders; `let` means the wrapper doesn't own the coordinator. Pure views in `FunUI` take the ViewModel as a parameter since the wrapper owns it.
 
 ## Rule Index
 Consult these files for detailed guidance (not auto-loaded — read on demand):
 - `ai-rules/general.md` — Architecture deep-dive, MVVM-C patterns, DI, sessions, testing
-- `ai-rules/swift-style.md` — Swift 6 concurrency, naming, Combine patterns, SwiftLint rules
+- `ai-rules/swift-style.md` — Swift 6 concurrency, naming, AsyncSequence patterns, SwiftLint rules
 - `ai-rules/ci-cd.md` — GitHub Actions CI workflow patterns
 
 ## Code Style
 - Swift 6 strict concurrency, iOS 17+
-- Pure SwiftUI (NavigationStack), MVVM-C with Combine
-- Single AppCoordinator: ObservableObject with @Published NavigationPath per tab
-- ViewModels use closures for navigation, wired in tab content wrappers
+- Pure SwiftUI (NavigationStack), MVVM-C with AsyncSequence + @Observable
+- Zero Combine — AsyncStream + StreamBroadcaster for reactive service events, @Observable for ViewModel state
+- Navigation closures on ViewModels, wired by single AppCoordinator
 - Navigation logic ONLY in Coordinators, never in Views
 - Protocol placement: Core = reusable abstractions, Model = domain-specific
-- Session-scoped ServiceLocator with `@Service` property wrapper — ViewModels conform to `SessionProvider`, store `let session: Session`
-- Combine over NotificationCenter for reactive state
+- Session-scoped ServiceLocator with `@Service` property wrapper — ViewModels conform to `SessionProvider`, store `let session: Session` (use `@ObservationIgnored` on `@Service` properties)
 
 ## Testing
 - Swift Testing framework (`import Testing`, `@Test`, `#expect`, `@Suite`)

Coordinator/Package.swift

@@ -4,8 +4,8 @@ import PackageDescription
 let package = Package(
     name: "Coordinator",
     platforms: [
-        .iOS(.v16),
-        .macCatalyst(.v16),
+        .iOS(.v17),
+        .macCatalyst(.v17),
     ],
     products: [
         .library(name: "FunCoordinator", targets: ["FunCoordinator"]),

Coordinator/Sources/Coordinator/AppCoordinator.swift

@@ -5,51 +5,52 @@
 //  SwiftUI-based coordinator managing navigation state and app flow
 //
 
-import Combine
+import Observation
 import SwiftUI
 
 import FunCore
 import FunModel
 
 @MainActor
-public final class AppCoordinator: ObservableObject, SessionProvider {
+@Observable
+public final class AppCoordinator: SessionProvider {
 
     // MARK: - DI
 
     public private(set) var session: Session
-    @Service(.logger) private var logger: LoggerService
-    @Service(.featureToggles) private var featureToggleService: FeatureToggleServiceProtocol
-    @Service(.toast) private var toastService: ToastServiceProtocol
+    @ObservationIgnored @Service(.logger) private var logger: LoggerService
+    @ObservationIgnored @Service(.featureToggles) private var featureToggleService: FeatureToggleServiceProtocol
+    @ObservationIgnored @Service(.toast) private var toastService: ToastServiceProtocol
 
     // MARK: - Session Management
 
-    private let sessionFactory: SessionFactory
+    @ObservationIgnored private let sessionFactory: SessionFactory
 
     // MARK: - App Flow State
 
-    @Published public var currentFlow: AppFlow = .login
+    public var currentFlow: AppFlow = .login
 
     // MARK: - Navigation State
 
-    @Published public var selectedTab: TabIndex = .home
-    @Published public var homePath = NavigationPath()
-    @Published public var itemsPath = NavigationPath()
-    @Published public var settingsPath = NavigationPath()
-    @Published public var isProfilePresented = false
+    public var selectedTab: TabIndex = .home
+    public var homePath = NavigationPath()
+    public var itemsPath = NavigationPath()
+    public var settingsPath = NavigationPath()
+    public var isProfilePresented = false
 
     // MARK: - Deep Link
 
-    private var pendingDeepLink: DeepLink?
+    @ObservationIgnored private var pendingDeepLink: DeepLink?
 
     // MARK: - Toast
 
-    @Published public var activeToast: ToastEvent?
-    private var toastCancellable: AnyCancellable?
+    public var activeToast: ToastEvent?
+    @ObservationIgnored private var toastObservation: Task<Void, Never>?
 
     // MARK: - Dark Mode
 
-    @Published public var appearanceMode: AppearanceMode = .system
-    private var darkModeCancellable: AnyCancellable?
+    public var appearanceMode: AppearanceMode = .system
+    @ObservationIgnored private var darkModeObservation: Task<Void, Never>?
 
     // MARK: - Init
 
@@ -58,6 +59,11 @@ public final class AppCoordinator: ObservableObject, SessionProvider {
         self.session = sessionFactory.makeSession(for: .login)
     }
 
+    deinit {
+        toastObservation?.cancel()
+        darkModeObservation?.cancel()
+    }
+
     // MARK: - Start
 
     public func start() {
@@ -110,7 +116,8 @@ public final class AppCoordinator: ObservableObject, SessionProvider {
 
     // Centralised routing table — called from both homeTab and itemsTab
     // .navigationDestination closures, so destination logic lives in one place.
-    // As destination types grow, expand with a switch:
+    // @ViewBuilder not required for a single expression today, but keeps
+    // this method ready for switch/if-else routing as destination types grow.
     //
     //   switch item.category {
     //   case .article: ArticleDetailView(item: item)
@@ -130,16 +137,22 @@ public final class AppCoordinator: ObservableObject, SessionProvider {
         observeToastEvents()
         subscribeToDarkMode()
 
+        // Execute pending deep link after main flow is ready
         if let deepLink = pendingDeepLink {
             pendingDeepLink = nil
-            executeDeepLink(deepLink)
+            Task { @MainActor [weak self] in
+                try? await Task.sleep(nanoseconds: 100_000_000)
+                self?.executeDeepLink(deepLink)
+            }
         }
     }
 
     public func transitionToLoginFlow() {
         currentFlow = .login
         pendingDeepLink = nil
         activateSession(for: .login)
+        subscribeToDarkMode()
+        toastObservation?.cancel()
 
         // Reset navigation state
         popToRoot()
@@ -180,11 +193,14 @@ public final class AppCoordinator: ObservableObject, SessionProvider {
     // MARK: - Toast
 
     private func observeToastEvents() {
-        toastCancellable?.cancel()
-        toastCancellable = toastService.toastPublisher
-            .sink { [weak self] event in
-                self?.activeToast = event
+        toastObservation?.cancel()
+        let stream = toastService.toastStream
+        toastObservation = Task { [weak self] in
+            for await event in stream {
+                guard let self else { break }
+                self.activeToast = event
             }
+        }
     }
 
     public func dismissToast() {
@@ -194,10 +210,14 @@ public final class AppCoordinator: ObservableObject, SessionProvider {
     // MARK: - Dark Mode Observation
 
     private func subscribeToDarkMode() {
-        darkModeCancellable?.cancel()
-        darkModeCancellable = featureToggleService.appearanceModePublisher
-            .sink { [weak self] mode in
-                self?.appearanceMode = mode
+        darkModeObservation?.cancel()
+        appearanceMode = featureToggleService.appearanceMode
+        let stream = featureToggleService.appearanceModeStream
+        darkModeObservation = Task { [weak self] in
+            for await mode in stream {
+                guard let self else { break }
+                self.appearanceMode = mode
             }
+        }
     }
 }

Coordinator/Sources/Coordinator/AppRootView.swift

@@ -15,7 +15,8 @@ import FunUI
 import FunViewModel
 
 public struct AppRootView: View {
-    @ObservedObject var coordinator: AppCoordinator
+    // Plain var — only reads coordinator properties, no $ bindings needed
+    var coordinator: AppCoordinator
 
     public init(coordinator: AppCoordinator) {
         self.coordinator = coordinator