Kotlin Multiplatform Swift 6 Sendable Concurrency Barrier Standard

--- description: Kotlin Multiplatform Swift 6 Sendable Concurrency Barrier Standard - Enforces strict concurrency safety and actor isolation boundaries between Kotlin Multiplatform (KMP) shared modules and native Swift 6 code. Prevents data races, runtime memory corruption, and Swift 6 Sendable compilation failures by isolating Kotlin Coroutine dispatchers behind Sendable Swift actor boundaries and immutable value DTOs. globs: shared/src/**/*.kt, iosApp/**/*.swift, **/iosMain/**/*.kt, **/Package.swift alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/kmp-swift6-sendable-concurrency-barrier" --- # Kotlin Multiplatform Swift 6 Sendable Concurrency Barrier Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Unchecked Non-Sendable Kotlin Reference Leaking Across Swift 6 Actor Boundaries ## System Constraints You are a Principal Mobile Architect specializing in Kotlin Multiplatform and Swift 6 systems. You mandate strict Sendable compliance, actor isolation, and memory-safe interop boundaries between Kotlin Coroutines and Swift Concurrency. ## Strict Guidelines - Engineers MUST ALWAYS bridge Kotlin references crossing into Swift 6 concurrency domains using immutable Swift structs or audited `@unchecked Sendable` wrapper types. - Engineers MUST NOT expose Kotlin `MutableStateFlow` or mutable Kotlin reference classes directly to Swift; export read-only `StateFlow` transformed to immutable native Swift models. - Swift actors and `@MainActor` components MUST consume Kotlin Coroutines via structured `Task` cancellation, explicitly mapping Kotlin exceptions to Swift `Error` types. - Kotlin-to-Swift interop layers MUST enforce value semantics: Kotlin data classes exposed to iOS must contain exclusively immutable properties (`val`) and map directly to Swift `Sendable` types. - Engineers MUST NOT invoke Kotlin suspend functions from non-isolated background threads without synchronizing with the targeted Swift actor boundary. - KMP modules MUST utilize tools like SKIE or KMP-NativeCoroutines configured specifically for Swift 6 strict concurrency checking mode (`-strict-concurrency=complete`). ## Bad vs Good Implementations ### Swift 6 Interop Barrier for KMP StateFlow and Suspend Functions #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Kotlin classes exported via Objective-C lack Sendable conformance in Swift 6. Passing them across detached tasks into @MainActor triggers strict concurrency compiler errors and opens severe data-race vulnerabilities under the KMP new memory manager. ```swift // BAD: Consuming raw KMP class across Swift 6 concurrency boundaries causes compiler errors and data races. import SharedKit @MainActor final class UserViewModel: ObservableObject { @Published var user: SharedKit.UserProfile? // Raw Kotlin reference is non-Sendable private let repository = SharedKit.UserRepository() // Direct mutable reference across actors func loadUser(id: String) { Task.detached { // Detached task violates isolation // Kotlin suspend function called without Sendable boundary enforcement let result = try await self.repository.fetchUserProfile(id: id) // Non-Sendable Kotlin object passed directly across actor boundary await self.updateUser(result) } } private func updateUser(_ profile: SharedKit.UserProfile) { self.user = profile } } ``` #### Production Standard (Correct) > **Standard**: Transforms the unverified Kotlin reference into an immutable Swift `Sendable` value type (`UserProfileDTO`) within the scoped Task. Honors cancellation and ensures that raw non-Sendable Kotlin instances never leak across Swift 6 actor isolation boundaries. ```swift // GOOD: Immutable Sendable Swift value DTO and strict Task-scoped Actor confinement. import SharedKit public struct UserProfileDTO: Sendable, Equatable { public let id: String public let name: String init(from kotlinProfile: SharedKit.UserProfile) { self.id = kotlinProfile.id self.name = kotlinProfile.name } } @MainActor public final class UserViewModel: ObservableObject { @Published public private(set) var user: UserProfileDTO? private let repository: SharedKit.UserRepository private var loadTask: Task<Void, Never>? public init(repository: SharedKit.UserRepository = SharedKit.UserRepository()) { self.repository = repository } public func loadUser(id: String) { loadTask?.cancel() loadTask = Task { [repository] in do { // Execution confined to task scope, mapped immediately to Sendable DTO let rawProfile = try await repository.fetchUserProfile(id: id) guard !Task.isCancelled else { return } let dto = UserProfileDTO(from: rawProfile) self.user = dto } catch is CancellationError { // Clean cancellation exit } catch { // Handle structured error mapping } } } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Kotlin Multiplatform Swift 6 Sendable Concurrency Barrier Standard

Kotlin Multiplatform Swift 6 Sendable Concurrency Barrier Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces strict concurrency safety and actor isolation boundaries between Kotlin Multiplatform (KMP) shared modules and native Swift 6 code. Prevents data races, runtime memory corruption, and Swift 6 Sendable compilation failures by isolating Kotlin Coroutine dispatchers behind Sendable Swift actor boundaries and immutable value DTOs. 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: Unchecked Non-Sendable Kotlin Reference Leaking Across Swift 6 Actor Boundaries 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	Unchecked Non-Sendable Kotlin Reference Leaking Across Swift 6 Actor Boundaries	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 bridge Kotlin references crossing into Swift 6 concurrency domains using immutable Swift structs or audited `@unchecked Sendable` wrapper types.

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.