KMP Swift 6 Strict Concurrency and Kotlin Native ARC Boundary Guardrail

--- description: KMP Swift 6 Strict Concurrency and Kotlin Native ARC Boundary Guardrail - Enforces strict Sendable crossing boundaries and prevents cross-runtime memory leaks between Swift 6 actor-isolated contexts and Kotlin/Native ARC. Mandates immutable data transfer objects, explicit lifecycle invalidation of Kotlin CoroutineScopes bridging to Swift AsyncStream, and prohibits raw pointer or mutable reference sharing across task boundaries. globs: iosApp/**/*.swift, shared/src/iosMain/kotlin/**/*.kt, shared/src/commonMain/kotlin/**/*.kt alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/kmp-swift6-actor-isolated-boundary-invariant" --- # KMP Swift 6 Strict Concurrency and Kotlin Native ARC Boundary Guardrail > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Leaking Non-Sendable Kotlin Native Objects Across Swift 6 Actor Boundaries Without Invalidation ## System Constraints You are a Principal Mobile Architect enforcing absolute isolation invariants between Swift 6 concurrency and Kotlin/Native ARC runtimes. In Swift 6 mode, types generated by Kotlin Multiplatform (cinterop/ObjCExport) lack native Sendable conformance and carry hidden Kotlin Native GC/ARC reference chains. You MUST guarantee that Kotlin instances NEVER escape isolation domains unchecked, Swift actors NEVER capture stateful KMP classes across async hops, and long-lived Flow collectors explicitly release their Kotlin Job handles to prevent permanent zombie cycles across the Swift/ObjC/Kotlin runtime divide. ## Strict Guidelines - Engineers MUST ALWAYS wrap non-final Kotlin classes exposed to Swift in Sendable-compliant Swift structs or actor-isolated facades before crossing task boundaries. - Engineers MUST NOT cross Swift 6 concurrency domains using raw Kotlin references without `@Sendable` bridging or deep-copy transformation into native Swift value types. - Swift bridging code MUST explicitly cancel KMP `Job` or `Cancellable` handles inside `withTaskCancellationHandler` or `onTermination` closures when adapting Kotlin `Flow` to `AsyncStream`. - Shared Kotlin classes intended for cross-runtime consumption MUST be pure immutable data structures (`data class` with `val`-only fields) or thread-safe state containers using `StateFlow`. - Components NEVER store direct Swift strong references to Kotlin `CoroutineScope` instances on Swift actors; scopes MUST remain anchored to their respective platform lifecycle owners. ## Bad vs Good Implementations ### Bridging Kotlin Flow to Swift 6 AsyncStream Without Leaking ARC Job Handles #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: KotlinSessionBridge and its Flow are non-Sendable ObjC-bridged types. Capturing them across unbounded Tasks without explicit cancellation handling leaks the underlying Kotlin GC root and triggers Swift 6 strict concurrency compiler diagnostics or runtime memory leaks. ```swift // ANTI-PATTERN: Captures non-Sendable Kotlin Flow collector in a detached Swift Task without teardown import SharedKit @MainActor final class SessionViewModel: ObservableObject { @Published private(set) var state: SessionState? private let sessionBridge: KotlinSessionBridge init(bridge: KotlinSessionBridge) { self.sessionBridge = bridge // Direct observation across concurrency boundary leaks KMP reference on cancellation Task { for await item in self.sessionBridge.sessionFlow { self.state = item } } } } ``` #### Production Standard (Correct) > **Standard**: Transforms non-Sendable Kotlin objects into an immutable, Sendable Swift struct at the exact point of emission, wraps subscription lifecycle in onTermination with explicit Job cancellation, and protects the Swift view model with proper Task teardown. ```swift // PRODUCTION STANDARD: Explicit Sendable boundary DTO conversion with runtime teardown import SharedKit public struct UserSessionState: Sendable { public let id: String public let isActive: Bool } @MainActor public final class SessionViewModel: ObservableObject { @Published public private(set) var state: UserSessionState? private var observationTask: Task<Void, Never>? public init(bridge: KotlinSessionBridge) { let stream = AsyncStream<UserSessionState> { continuation in let job = bridge.observeSession { nativeState in // Map non-sendable ObjC KMP reference to Sendable Swift value type immediately let sendable = UserSessionState( id: nativeState.id, isActive: nativeState.isActive ) continuation.yield(sendable) } continuation.onTermination = { @Sendable _ in job.cancel() } } self.observationTask = Task { [weak self] in for await update in stream { guard !Task.isCancelled else { break } self?.state = update } } } deinit { observationTask?.cancel() } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: KMP Swift 6 Strict Concurrency and Kotlin Native ARC Boundary Guardrail

KMP Swift 6 Strict Concurrency and Kotlin Native ARC Boundary Guardrail defines an industrial-grade behavioral standard for mobile engineering. Enforces strict Sendable crossing boundaries and prevents cross-runtime memory leaks between Swift 6 actor-isolated contexts and Kotlin/Native ARC. Mandates immutable data transfer objects, explicit lifecycle invalidation of Kotlin CoroutineScopes bridging to Swift AsyncStream, and prohibits raw pointer or mutable reference sharing across task boundaries. 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: Leaking Non-Sendable Kotlin Native Objects Across Swift 6 Actor Boundaries Without Invalidation 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	Leaking Non-Sendable Kotlin Native Objects Across Swift 6 Actor Boundaries Without Invalidation	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 wrap non-final Kotlin classes exposed to Swift in Sendable-compliant Swift structs or actor-isolated facades before crossing task boundaries.

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.