AsyncStream terminated when merging run effects with task effect

[jose-pay]

I have the following working scenario where a dependency is returning an async stream:

public struct PersonTile: ReducerProtocol {

    ... 

    public enum Action: Equatable {
        case task
        case didGetSalary
        case isLoaded
    }

    @Dependency(\.personService) var personService

    // Working example
    public var body: some ReducerProtocolOf<Self> {
        Reduce { state, action in
            switch action {
                case .task: // called from task view modifier
                    return .run {
                        for await _ in await personService.didGetSalary() {
                            await send(.didGetSalary)
                        }                        
                    }

                case .didGetSalary:
                    ...
                    return .none    
            }
        }
    }
}

public struct PersonService {

    public var personViewModel: () -> PersonViewModel
    public var didGetSalary: @Sendable () async -> AsyncStream<Void>
}

extension PersonService {

    // legacy view model with publishers
    public static func live(personViewModel: PersonViewModel) -> Self {
        Self(
            personViewModel: { personViewModel },
            didGetSalary: {
                AsyncStream { continuation in
                    let cancellable = personViewModel
                        .didGetSalary
                        .sink {
                            continuation.yield(())
                        }

                    continuation.onTermination = { _ in
                        cancellable.cancel()
                    }
                }
            }
        )
    }
}

Adding a second effect (task) and using EffectTask.merge will cause the async stream to be terminated almost immediately. The continuation.onTermination is called.

// Failing example
public var body: some ReducerProtocolOf<Self> {
    Reduce { state, action in
        case .task:
            return .merge(
                .task {
                    try? await Task.sleep(nanoseconds: NSEC_PER_SEC)
                    return .isLoaded
                },
                .run {
                    for await _ in await personService.didGetSalary() {
                        await send(.didGetSalary)
                    }                        
                }
            )
    }
}                    

EffectTask.merge works fine if more run effects are added, it will only fail when adding a task modifier:

// Working example
public var body: some ReducerProtocolOf<Self> {
    Reduce { state, action in
        case .task:
            return .merge(
                .run {
                    for await _ in await personService.didGetSalary() {
                        await send(.didGetSalary)
                    }                        
                },
                .run {
                    for await _ in await personService.didGetSalaryIncrease() { // simliar stream to the previous one
                        await send(.didGetSalaryIncrease)
                    }                        
                }            
            )
    }
} 

Note that all examples above will work if the task action is called from either a button tap or from onAppear instead of the task view modifier:

.onAppear {
    viewStore.send(.task)
}   

[pepejeria]

Turned out that this was solved by putting the task modifier in the view at the end (after a view modifier that applied a shimmering effect)... Tried to reproduce this in a simple isolated demo but was not successful.