Kotlin Multiplatform 2.1 Swift Export ARC Cycle Sentinel

--- description: Kotlin Multiplatform 2.1 Swift Export ARC Cycle Sentinel - Enforces strict memory boundary decoupling between Swift Automatic Reference Counting (ARC) and Kotlin/Native tracing GC across Kotlin 2.1 Swift Export boundaries. Cross-runtime strong references form uncollectible islands because neither Swift ARC nor Kotlin GC can traverse the foreign runtime heap. Mandates unidirectional event streaming and explicit RAII cancellation tokens over bidirectional callback or delegate retention. globs: shared/src/commonMain/kotlin/**/*.kt, shared/src/iosMain/kotlin/**/*.kt, iosApp/**/*.swift alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/kmp-2-1-swift-export-arc-cycle-sentinel" --- # Kotlin Multiplatform 2.1 Swift Export ARC Cycle Sentinel > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Cross-Runtime Retain Cycles Between Swift ARC and Kotlin/Native Tracing Garbage Collector ## System Constraints You are a Principal Mobile Architect enforcing the Kotlin Multiplatform 2.1 Swift Export ARC Cycle Sentinel. Cross-heap reference cycles between Kotlin Native's Garbage Collector and Apple Swift ARC cause permanent, silent native heap leaks that survive view teardown. You must mandate clean lifecycle-bound token observation, prohibit direct Swift object references passed into persistent Kotlin objects without explicit disposal semantics, and enforce RAII-based Swift Task lifecycle management for exported asynchronous streams. ## Strict Guidelines - Engineers MUST ALWAYS enforce unidirectional data flow across the Swift Export boundary by exposing read-only Kotlin `StateFlow` or `SharedFlow` exposed via Swift `AsyncSequence` instead of passing stateful Swift callback delegates into Kotlin. - Engineers MUST NOT pass Swift class instances or escaping closures directly into long-lived Kotlin singletons or domain repositories as listeners, delegates, or observers. - Code SHOULD utilize Swift's `Task` cancellation and Kotlin's `DisposableHandle` or `AutoCloseable` to cleanly sever FFI references when a Swift View, Presenter, or ViewModel deinitializes. - Services MUST emit scalar values, immutably serialized data transfer objects, or detached value types across the exported interface rather than maintaining shared mutable state across runtime boundaries. - Components NEVER store a bidirectional strong pointer across the C-interop/Swift Export FFI boundary without a deterministic teardown mechanism invoked on Swift `deinit`. ## Bad vs Good Implementations ### Uncollectible Cross-Runtime Delegate Cycle (Swift ARC <-> Kotlin GC) #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Kotlin Native holds a strong FFI reference to the Swift instance via the delegate bridge, while Swift holds a strong ARC reference to the Kotlin Presenter. Because Kotlin GC and Swift ARC operate on distinct memory heaps with independent collection semantics, this circular graph is invisible to both collectors, creating an irrecoverable leak. ```swift // Swift View/Presenter retaining Kotlin Presenter, and Kotlin retaining Swift Delegate final class ProfileViewController: UIViewController, ProfileKotlinDelegate { private let presenter = ProfilePresenter() // Kotlin object exported to Swift override func viewDidLoad() { super.viewDidLoad() // CRITICAL BUG: presenter holds strong reference to self via ObjC/Swift bridge. // Kotlin GC cannot inspect Swift ARC; Swift ARC sees presenter retained by self. // Result: Permanent uncollectible heap island across the FFI runtime boundary. presenter.setDelegate(delegate: self) } func onProfileLoaded(profile: ProfileData) { // UI updates } } ``` #### Production Standard (Correct) > **Standard**: The Swift consumer observes updates via an asynchronous stream without registering a long-lived reverse pointer in the Kotlin heap. Cancellation inside Swift's `deinit` immediately releases the native continuation handle, preserving strict single-direction dependency flow and preventing cross-heap retention. ```swift // Unidirectional, RAII-governed observation across Swift Export final class ProfileViewController: UIViewController { private let presenter = ProfilePresenter() // Kotlin 2.1 exported class private var observationTask: Task<Void, Never>? override func viewDidLoad() { super.viewDidLoad() // Consume Kotlin StateFlow as a native Swift AsyncSequence observationTask = Task { [weak self] in for await state in self?.presenter.stateFlow ?? AsyncStream.never { guard !Task.isCancelled else { break } self?.render(state: state) } } } deinit { // Deterministic cancellation severs the Swift-to-Kotlin coroutine subscription observationTask?.cancel() } private func render(state: ProfileUiState) { // UI updates } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Kotlin Multiplatform 2.1 Swift Export ARC Cycle Sentinel

Kotlin Multiplatform 2.1 Swift Export ARC Cycle Sentinel defines an industrial-grade behavioral standard for mobile engineering. Enforces strict memory boundary decoupling between Swift Automatic Reference Counting (ARC) and Kotlin/Native tracing GC across Kotlin 2.1 Swift Export boundaries. Cross-runtime strong references form uncollectible islands because neither Swift ARC nor Kotlin GC can traverse the foreign runtime heap. Mandates unidirectional event streaming and explicit RAII cancellation tokens over bidirectional callback or delegate retention. 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: Cross-Runtime Retain Cycles Between Swift ARC and Kotlin/Native Tracing Garbage Collector 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	Cross-Runtime Retain Cycles Between Swift ARC and Kotlin/Native Tracing Garbage Collector	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 enforce unidirectional data flow across the Swift Export boundary by exposing read-only Kotlin `StateFlow` or `SharedFlow` exposed via Swift `AsyncSequence` instead of passing stateful Swift callback delegates into Kotlin.

Engineers MUST ALWAYS enforce unidirectional data flow across the Swift Export boundary by exposing read-only Kotlin `StateFlow` or `SharedFlow` exposed via Swift `AsyncSequence` instead of passing stateful Swift callback delegates into Kotlin.

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.