KMP StateFlow Swift-Bridge Memory Barrier and Concurrency Protocol

--- description: KMP StateFlow Swift-Bridge Memory Barrier and Concurrency Protocol - Enforces strict memory barrier synchronization and dispatch-thread alignment when bridging Kotlin Coroutine StateFlow instances to Swift async runtimes. Eliminates silent data races, thread-crossing memory leaks, and dropped frame updates caused by non-atomic runtime transitions between Kotlin/Native memory models and Swift Structured Concurrency. globs: **/iosMain/**/presentation/*.kt, **/iosMain/**/*.kt, iosApp/**/*.swift, iosApp/**/StateBridge/*.swift alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/kmp-stateflow-swift-bridge-memory-barrier" --- # KMP StateFlow Swift-Bridge Memory Barrier and Concurrency Protocol > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Directly Consuming Raw KMP StateFlow in Swift Contexts Without Actor Boundary Isolation and Cooperative Job Cancellation ## System Constraints You are a Principal Mobile Architect enforcing strict Kotlin Multiplatform (KMP) StateFlow to Swift boundary invariants. You mandate thread synchronization barriers, cancellation cooperative cleanup, and strict @MainActor dispatch confinement to prevent multi-runtime state corruption and memory access violations. ## Strict Guidelines - Engineers MUST ALWAYS isolate the Swift-side consumption of KMP StateFlow publishers or wrappers to the @MainActor or a dedicated serial Swift Actor. - Engineers MUST NOT expose raw kotlinx.coroutines.flow.StateFlow directly to Swift interfaces without a thread-confined wrapper (e.g., SKIE or explicit NativeCancellable / FlowAdapter). - Code SHOULD enforce cooperative cancellation across runtimes by binding the Kotlin Job lifecycle to the Swift Task lifecycle via Swift Task.isCancelled checks and Kotlin Job.cancel(). - Services MUST ensure that StateFlow emission values crossing the Objective-C/Swift bridge are treated as immutable values to prevent mutation races across native allocators. - Components NEVER collect cross-runtime flows from detached Task contexts without explicitly storing and disposing of the subscription tokens upon UI deinitialization. ## Bad vs Good Implementations ### Swift Bridge Consumption of KMP StateFlow #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Kotlin/Native executes the watch callback on an arbitrary background coroutine dispatcher thread. Mutating self.state off the MainActor causes UI data races, crashes in SwiftUI rendering pipelines, and leaves the collector active perpetually after deallocation, leaking Kotlin and Swift instances. ```swift // BAD: Direct collection without actor isolation, memory barrier, or Task lifecycle tracking class UserViewModel: ObservableObject { @Published var state: UserState = .initial private let sharedFlow: KMPStateFlow<UserState> init(flow: KMPStateFlow<UserState>) { self.sharedFlow = flow // Unconfined background thread dispatch from KMP Collector without Swift Task cancellation flow.watch { newState in // Directly mutating ObservableObject state from an arbitrary Kotlin runtime thread self.state = newState } } } ``` #### Production Standard (Correct) > **Standard**: The observable model uses explicit @MainActor confinement, bridges StateFlow emissions through an AsyncSequence adhering to Swift Structured Concurrency, and binds coroutine emission collection directly to the Swift Task lifecycle with deterministic deinit cleanup. ```swift // GOOD: MainActor confinement, explicit memory boundary, and cooperative lifecycle cancellation @MainActor final class UserViewModel: ObservableObject { @Published private(set) var state: UserState private var stateObservationTask: Task<Void, Never>? init(flow: StateFlowAdapter<UserState>) { self.state = flow.value self.stateObservationTask = Task { [weak self] in // SKIE or explicit AsyncSequence bridge ensuring memory barrier and proper isolation for await nextState in flow.values { guard !Task.isCancelled else { break } guard let self else { return } self.state = nextState } } } deinit { stateObservationTask?.cancel() } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: KMP StateFlow Swift-Bridge Memory Barrier and Concurrency Protocol

KMP StateFlow Swift-Bridge Memory Barrier and Concurrency Protocol defines an industrial-grade behavioral standard for mobile engineering. Enforces strict memory barrier synchronization and dispatch-thread alignment when bridging Kotlin Coroutine StateFlow instances to Swift async runtimes. Eliminates silent data races, thread-crossing memory leaks, and dropped frame updates caused by non-atomic runtime transitions between Kotlin/Native memory models and Swift Structured Concurrency. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Directly Consuming Raw KMP StateFlow in Swift Contexts Without Actor Boundary Isolation and Cooperative Job Cancellation Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Directly Consuming Raw KMP StateFlow in Swift Contexts Without Actor Boundary Isolation and Cooperative Job Cancellation	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Engineers MUST ALWAYS isolate the Swift-side consumption of KMP StateFlow publishers or wrappers to the @MainActor or a dedicated serial Swift Actor.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.