SwiftConcurrency

Run a structured review that checks three questions in order: which isolation domain owns each mutable value, what crosses between domains (must be Sendable), and what happens at each await. Findings are reported by file with before/after fixes, prioritizing data-race and reentrancy defects.

Reentrancy means an actor can run other queued messages at every await suspension point, so state read before the await may be stale after it. The fix is to re-validate after every await and use identity or generation guards to drop actions against replaced resources.

Have the producing actor yield Sendable values into an AsyncStream, and consume that stream from a task on the MainActor that updates the view. Hop across the boundary once with an @MainActor method or await MainActor.run rather than hopping per update.

A call like try? await clock.sleep swallows CancellationError, so the loop continues. Add guard !Task.isCancelled after the sleep, store every spawned Task handle, and cancel it in close() or deinit so the work can actually be stopped.

Mark a type Sendable whenever it crosses an isolation boundary between actors or tasks. Structs and enums of Sendable members qualify, while mutable classes should have their state moved into an actor instead of being shared across domains.