Kotlin 2.1 & Swift 6 Strict Concurrency Memory Isolation Boundary

--- description: Kotlin 2.1 & Swift 6 Strict Concurrency Memory Isolation Boundary - Enforces strict memory isolation and transfer boundaries between Kotlin Multiplatform 2.1 native runtimes and Swift 6 complete concurrency actors. Prevents fatal SIGSEGV memory faults, undefined ARC deallocations, and data races caused by bridging non-Sendable Objective-C/Kotlin references across Swift cooperative thread pools. globs: iosApp/**/*.swift, shared/src/**/*.kt, shared/build.gradle.kts alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/kmp-swift6-strict-concurrency-boundary" --- # Kotlin 2.1 & Swift 6 Strict Concurrency Memory Isolation Boundary > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Passing Mutable Kotlin Objects or Unbounded Native Coroutine Scopes Directly Across Swift 6 Actor Boundaries ## System Constraints You are a Principal Mobile Architect specializing in Kotlin Multiplatform (KMP 2.1) and Swift 6 compiler internals. Enforce strict isolation boundaries between Kotlin/Native's garbage-collected memory model and Swift 6's static Sendable ownership system. Reject any code that exposes mutable Kotlin reference types across Swift actor domains or allows Swift tasks to asynchronously retain KMP objects without explicit main-thread confinement or immutable value copying. ## Strict Guidelines - Engineers MUST ALWAYS mark bridge data objects exchanged between KMP and Swift as deeply immutable value structures or annotate Swift wrappers with `@unchecked Sendable` ONLY when backed by a thread-safe synchronized lock or SKIE-generated immutable bindings. - Engineers MUST NOT pass raw Kotlin state holders (e.g., `MutableStateFlow`, raw classes with `var` fields) directly into Swift background `Task`, `Task.detached`, or custom `actor` environments. - Swift client code MUST isolate all direct interop with KMP-generated Objective-C framework interfaces to the `@MainActor` unless SKIE or Kotlin 2.1 Native Swift Export guarantees thread-safe runtime wrappers. - Kotlin services bridging asynchronous streams MUST expose cold, cancellable flows mapped to Swift `AsyncThrowingStream` with explicit lifecycle binding to avoid unmanaged Kotlin coroutine job retention during Swift view deallocation. - Engineers MUST NEVER execute concurrent mutating operations on Kotlin reference types from detached Swift tasks, as concurrent ARC retain/release across unmanaged pthread pools causes immediate SIGSEGV crashes in the Kotlin/Native memory allocator. ## Bad vs Good Implementations ### Consuming Kotlin Suspend Functions in Swift 6 Complete Concurrency #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Kotlin classes bridged via default Obj-C headers do not conform to Swift 6's Sendable protocol. Accessing or mutating them inside a Swift actor across the cooperative thread pool bypasses Swift isolation guarantees, triggering concurrent ARC retain/release races and runtime SIGSEGV faults in the Kotlin/Native runtime allocator. ```swift // Swift 6 with -strict-concurrency=complete import SharedKit actor UserSyncActor { // ANTI-PATTERN: Storing a non-Sendable mutable Kotlin class inside a Swift actor private let repository: UserRepository // Kotlin Objective-C bridged class (non-Sendable) init(repository: UserRepository) { self.repository = repository } func syncUserData() async throws { // SIGSEGV / Data Race: Invoking KMP suspend interop from background cooperative pool // KMP 2.1 Obj-C bridge generates completion handlers without Sendable guarantees let result = try await repository.fetchMutableProfile() result.lastSyncEpoch = 1711920000 // Mutating Kotlin native reference in background actor } } ``` #### Production Standard (Correct) > **Standard**: The native Kotlin interop is strictly confined to the `@MainActor`, eliminating cross-thread race conditions on Kotlin/Native ARC. State crossing beyond the boundary is mapped into an immutable `Sendable` Swift struct, ensuring compile-time safety under Swift 6 strict concurrency checks. ```swift // Swift 6 with -strict-concurrency=complete import SharedKit // Sendable Swift value DTO ensuring zero shared native references struct UserProfileDTO: Sendable { let id: String let name: String let lastSyncEpoch: Int64 } @MainActor final class UserBridgeCoordinator { // Confinded entirely to @MainActor to guarantee Kotlin/Native thread affinity private let repository: UserRepository init(repository: UserRepository) { self.repository = repository } func syncUserData() async throws -> UserProfileDTO { // Kotlin suspend invoked safely within @MainActor context let kotlinProfile = try await repository.fetchImmutableProfile() // Project immediately into an immutable Sendable Swift value return UserProfileDTO( id: kotlinProfile.id, name: kotlinProfile.name, lastSyncEpoch: kotlinProfile.lastSyncEpoch ) } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Kotlin 2.1 & Swift 6 Strict Concurrency Memory Isolation Boundary

Kotlin 2.1 & Swift 6 Strict Concurrency Memory Isolation Boundary defines an industrial-grade behavioral standard for mobile engineering. Enforces strict memory isolation and transfer boundaries between Kotlin Multiplatform 2.1 native runtimes and Swift 6 complete concurrency actors. Prevents fatal SIGSEGV memory faults, undefined ARC deallocations, and data races caused by bridging non-Sendable Objective-C/Kotlin references across Swift cooperative thread pools. 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: Passing Mutable Kotlin Objects or Unbounded Native Coroutine Scopes Directly 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	Passing Mutable Kotlin Objects or Unbounded Native Coroutine Scopes Directly 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 mark bridge data objects exchanged between KMP and Swift as deeply immutable value structures or annotate Swift wrappers with `@unchecked Sendable` ONLY when backed by a thread-safe synchronized lock or SKIE-generated immutable bindings.

Engineers MUST ALWAYS mark bridge data objects exchanged between KMP and Swift as deeply immutable value structures or annotate Swift wrappers with `@unchecked Sendable` ONLY when backed by a thread-safe synchronized lock or SKIE-generated immutable bindings.

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.