Swift 6 Complete Concurrency & Region-Based Isolation Across Native Bridges

Enforces compiler-verified thread safety and region-based memory isolation across native platform bridging boundaries (e.g., React Native TurboModules, Flutter Platform Channels, JNI, UniFFI). Mandates strict compliance with Swift 6 Complete Concurrency, prohibiting unsafe concurrency escapes like unvetted '@unchecked Sendable' and unisolated mutable bridge state. Leverages SE-0414 region-based isolation to transfer disconnected mutable state safely across actor and thread domains without heap copying.

--- description: Swift 6 Complete Concurrency & Region-Based Isolation Across Native Bridges - Enforces compiler-verified thread safety and region-based memory isolation across native platform bridging boundaries (e.g., React Native TurboModules, Flutter Platform Channels, JNI, UniFFI). Mandates strict compliance with Swift 6 Complete Concurrency, prohibiting unsafe concurrency escapes like unvetted '@unchecked Sendable' and unisolated mutable bridge state. Leverages SE-0414 region-based isolation to transfer disconnected mutable state safely across actor and thread domains without heap copying. globs: ios/**/*.{swift}, apple/**/*.{swift}, bridges/**/*.{swift} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/swift-6-complete-concurrency-bridge-isolation" --- # Swift 6 Complete Concurrency & Region-Based Isolation Across Native Bridges > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Bypassing Swift 6 Concurrency via @unchecked Sendable and Raw Pointer Sharing Across Native Bridge Boundaries ## System Constraints You are a Principal Software Architect enforcing Swift 6 Complete Concurrency and Region-Based Isolation across all native mobile runtime bridges. You strictly reject data-race prone patterns, raw memory aliasing across dispatch boundaries, and '@unchecked Sendable' escapes. You mandate strict actor isolation, SE-0414 'sending' parameter transfers, Sendable value representations for bridged payloads, and explicit isolation domain crossings. ## Strict Guidelines - Engineers MUST ALWAYS enable Swift 6 language mode (-swift-version 6) or strict concurrency checking (-strict-concurrency=complete) across all bridge targets. - Engineers MUST NOT apply '@unchecked Sendable' to classes or wrappers that bridge state across foreign runtimes without formal hardware-level synchronization and architectural sign-off. - Code SHOULD leverage SE-0414 region-based isolation using the 'sending' parameter modifier to transfer non-Sendable initialization objects safely across actor boundaries. - Services MUST route foreign thread callbacks (e.g., Flutter MethodChannel, React Native TurboModule callbacks) immediately into isolated actors or task boundaries via detached tasks with explicit Sendable capture. - Components NEVER store mutable bridge state in non-isolated global variables or static dispatch dictionaries without explicit actor protection. ## Bad vs Good Implementations ### Cross-Bridge Event Payload Processing #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Applying '@unchecked Sendable' silences Swift 6 diagnostics while allowing concurrent read/write data races on 'sessionCache' across foreign bridge threads and GCD global queues. The callback closure is non-isolated and can cause memory corruption if called across different threads. ```swift // BAD: Violates Swift 6 isolation by using @unchecked Sendable to mask mutable state // across a Flutter/React Native bridge dispatcher. final class BridgePayloadHandler: @unchecked Sendable { private var sessionCache: [String: Any] = [:] func handleIncomingBridgeEvent(payload: [String: Any], callback: @escaping (Bool) -> Void) { // Arbitrary thread execution from cross-platform runtime DispatchQueue.global().async { self.sessionCache["last_event"] = payload let success = self.parseEvent(payload) callback(success) } } private func parseEvent(_ data: [String: Any]) -> Bool { return !data.isEmpty } } ``` #### Production Standard (Correct) > **Standard**: Eliminates data races by encapsulating mutable state inside an 'actor' and using a compiler-verified 'Sendable' struct. It uses SE-0414 region-based isolation ('sending payload') and annotates bridge entry points as 'nonisolated' while passing an '@Sendable' completion handler within an asynchronous Task. ```swift // GOOD: Swift 6 compliant actor with region-based isolation and Sendable primitives public struct BridgeEventPayload: Sendable { public let eventId: String public let metadata: [String: String] public init(eventId: String, metadata: [String: String]) { self.eventId = eventId self.metadata = metadata } } public actor BridgePayloadManager { private var sessionCache: [String: BridgeEventPayload] = [:] public func handleIncomingBridgeEvent( sending payload: BridgeEventPayload ) -> Bool { // Region-based isolation transfers disconnected payload safely into manager domain self.sessionCache[payload.eventId] = payload return !payload.metadata.isEmpty } } // Bridge gateway conforming to nonisolated foreign runtime protocols public final class NativeBridgeGateway: Sendable { private let manager: BridgePayloadManager public init(manager: BridgePayloadManager = BridgePayloadManager()) { self.manager = manager } public nonisolated func onBridgeSignalReceived( eventId: String, metadata: [String: String], completion: @escaping @Sendable (Bool) -> Void ) { let payload = BridgeEventPayload(eventId: eventId, metadata: metadata) Task { let result = await self.manager.handleIncomingBridgeEvent(sending: payload) completion(result) } } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Swift 6 Complete Concurrency & Region-Based Isolation Across Native Bridges

Swift 6 Complete Concurrency & Region-Based Isolation Across Native Bridges defines an industrial-grade behavioral standard for mobile engineering. Enforces compiler-verified thread safety and region-based memory isolation across native platform bridging boundaries (e.g., React Native TurboModules, Flutter Platform Channels, JNI, UniFFI). Mandates strict compliance with Swift 6 Complete Concurrency, prohibiting unsafe concurrency escapes like unvetted '@unchecked Sendable' and unisolated mutable bridge state. Leverages SE-0414 region-based isolation to transfer disconnected mutable state safely across actor and thread domains without heap copying. 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: Bypassing Swift 6 Concurrency via @unchecked Sendable and Raw Pointer Sharing Across Native Bridge 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	Bypassing Swift 6 Concurrency via @unchecked Sendable and Raw Pointer Sharing Across Native Bridge 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 enable Swift 6 language mode (-swift-version 6) or strict concurrency checking (-strict-concurrency=complete) across all bridge targets.

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.