Replace Combine with AsyncSequence and @Observable

[g-enius]

Summary

Replaces all Combine usage with two independent technologies — @Observable (Observation framework) for ViewModel → View reactivity, and AsyncStream + custom StreamBroadcaster for service event streams — achieving zero import Combine across the entire codebase. Builds on the SwiftUI NavigationStack migration.

• 55 files changed (49 modified + 1 new + 5 deleted)
• 694 lines added, 591 lines removed
• Minimum deployment target raised from iOS 16 → iOS 17
• import Combine remaining: 0

Depends on: PR #3 — Migrate UIKit navigation to SwiftUI NavigationStack

Why iOS 17?

AsyncSequence and AsyncStream are available since iOS 13. The iOS 17 requirement comes from two independent things:

What	Replaces	Requires
@Observable (Observation framework)	Combine's ObservableObject + @Published	iOS 17
AsyncStream.makeStream(of:) (SE-0388)	Closure-based AsyncStream { continuation in }	iOS 17

@Observable provides per-property tracking (replacing per-object invalidation). AsyncStream.makeStream(of:) provides eager continuation registration (values yielded before iteration starts are buffered instead of lost). Neither depends on the other.

Key Changes

Reactive State

• AnyPublisher<Set<String>, Never> → AsyncStream<Set<String>>
• CurrentValueSubject / PassthroughSubject → custom StreamBroadcaster (in Core)
• .sink { }.store(in: &cancellables) → Task { for await value in stream { } }
• Set<AnyCancellable> → Task cancellation (task.cancel())
• .debounce(for:scheduler:) → didSet + Task.sleep with cancellation

ViewModel Observation

• ObservableObject + @Published → @Observable macro
• @ObservedObject → @Bindable (two-way) or plain property (read-only)
• Per-object invalidation → per-property tracking (more efficient re-renders)

What Stays the Same

• SwiftUI NavigationStack (from PR Migrate UIKit navigation to SwiftUI NavigationStack #3)
• MVVM + Coordinator architecture
• Session-scoped DI, all service protocols
• Navigation closures pattern

Key Patterns

StreamBroadcaster vs Combine Subjects

StreamBroadcaster is a custom @MainActor-isolated multi-consumer broadcaster that replaces Combine's CurrentValueSubject and PassthroughSubject for async/await code. Each consumer gets an independent AsyncStream.

	CurrentValueSubject	PassthroughSubject	StreamBroadcaster
Create	CurrentValueSubject(initial)	PassthroughSubject()	StreamBroadcaster()
Get stream	.eraseToAnyPublisher()	.eraseToAnyPublisher()	.makeStream() (new stream per caller)
Send	.send(value)	.send(value)	.yield(value)
Finish	.send(completion: .finished)	.send(completion: .finished)	.finish()
Initial value	Yes — emits on subscribe	No	No
Late subscriber	Receives current value	Misses past values	Misses past values
Thread safety	Internal locks	Internal locks	@MainActor isolation
Cleanup	Manual AnyCancellable	Manual AnyCancellable	Automatic on Task cancellation

Retain-safe observation — capture stream before Task, guard inside loop:

let stream = favoritesService.favoritesChanges
observation = Task { [weak self] in
    for await newFavorites in stream {
        guard let self else { break }
        self.favoriteIds = newFavorites
    }
}

Migration Pitfalls

Things discovered during the Combine → AsyncSequence migration that aren't obvious:

1. guard let self before for await creates a retain cycle. The guard captures self strongly, and that strong reference persists for the entire duration of the for await suspension — the ViewModel can never deallocate.

// BAD — retains self forever during suspension
Task { [weak self] in
    guard let self else { return }
    for await value in stream { self.property = value }
}

// GOOD — guard inside the loop, break if nil
Task { [weak self] in
    for await value in stream {
        guard let self else { break }
        self.property = value
    }
}

2. AsyncStream doesn't auto-emit the current value. Unlike @Published (which emits immediately on subscribe), AsyncStream only delivers future values. Read the current value directly at init time:

// Must initialize manually — stream won't deliver the current state
favoriteIds = favoritesService.favorites     // read current
let stream = favoritesService.favoritesChanges  // observe future

3. @Observable transforms stored properties into computed ones. This means @Service (a property wrapper) can't be applied directly — it conflicts with @Observable's generated accessors. Fix: mark service properties with @ObservationIgnored:

@ObservationIgnored @Service(.network) private var networkService: NetworkService

4. @StateObject doesn't work with @Observable. @StateObject requires ObservableObject conformance. Use @State instead for ownership, @Bindable for two-way binding (replaces @ObservedObject).

Test plan

• All 74 unit tests pass
• Build succeeds on iOS 17+ simulator
• Verify zero import Combine statements
• Home → Detail → back navigation
• Profile modal present/dismiss
• Favorites sync across screens
• Search debounce works correctly
• Feature toggle changes propagate

🤖 Generated with Claude Code

[g-enius]

do you really need two [weak self] here? @claude

[claude]

Claude finished @g-enius's task in 1m 20s —— View job

---

• Read StreamBroadcaster.swift to analyze the [weak self] usage
• Determine if both are necessary — no, removed the redundant one
• Commit and push (7fcc3d8)

No — the second [weak self] is redundant

// Before
continuation.onTermination = { [weak self] _ in
    Task { @MainActor [weak self] in          // ← redundant
        self?.continuations.removeValue(forKey: id)
    }
}

// After
continuation.onTermination = { [weak self] _ in
    Task { @MainActor in
        self?.continuations.removeValue(forKey: id)
    }
}

Why only one is needed:

The outer { [weak self] _ in ... } makes self a local weak optional (StreamBroadcaster?) inside that closure. The inner Task closure captures this outer self — which is already a weak optional. Capturing a weak optional in a nested closure doesn't create a new strong reference; you're just referencing the same weak variable from the outer scope.

Adding [weak self] a second time on the inner Task would re-weaken an already-weak reference — which compiles fine but is logically a no-op.

The first [weak self] is the important one — without it, onTermination would strongly capture self, creating a retain cycle:

StreamBroadcaster → continuations[id] → continuation → onTermination → StreamBroadcaster

The @MainActor annotation on the Task is still necessary (and unrelated to [weak self]) — onTermination can fire on any thread, and continuations is @MainActor-isolated, so we need the hop.
· Branch diff

[g-enius]

3 comments need to address

[g-enius]

this logic should live in NetworkService layer, also check ItemsViewModel. Fix on main and sync

[g-enius]

Moved to NetworkService on main (both HomeViewModel and ItemsViewModel). Synced.

[g-enius]

why change the default value here? it should be default true on main

[g-enius]

Fixed on main and synced.

[g-enius]

this should be changed in the Navigation-Stack branch, not here

[g-enius]

Fixed on navigation-stack and synced.