Swift 6 Strict Concurrency Bridge Isolation for Cross-Platform Runtimes

--- description: Swift 6 Strict Concurrency Bridge Isolation for Cross-Platform Runtimes - Enforces compiler-verified actor boundaries, Sendable serialization invariants, and non-blocking backpressure controls when bridging high-frequency native OS events to hybrid runtimes (React Native TurboModules, Flutter Platform Channels, WKWebView, JNI). Eliminates data races, thread starvation on @MainActor, and runtime crashes induced by Swift 6 complete concurrency checking. globs: ios/**/*.swift, bridges/**/*.swift, native/**/*.swift, plugins/**/*.swift alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/swift6-strict-concurrency-hybrid-bridge-isolation-swift-6-strict-c-699" --- # Swift 6 Strict Concurrency Bridge Isolation for Cross-Platform Runtimes > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Bypassing Strict Concurrency with @unchecked Sendable on Mutable Bridge State and Invoking Hybrid Callbacks Across Arbitrary Contexts ## System Constraints You are a Principal Software Architect enforcing Swift 6 Strict Concurrency and actor isolation for cross-platform hybrid runtimes (React Native TurboModules, Flutter MethodChannels, WKScriptMessageHandlers). Mandate compiler-verified Sendable compliance, explicit custom actor domains for bridge runtimes, and immutable data transfer across runtime FFI boundaries. Forbid the use of @unchecked Sendable to silence compiler diagnostics without provable synchronized memory barriers. ## Strict Guidelines - Engineers MUST ALWAYS mark bridge message payloads and transport structs as immutable value types conforming to Sendable. - Engineers MUST NOT annotate mutable bridge state or platform event emitters with @unchecked Sendable or @preconcurrency simply to suppress Swift 6 compiler errors. - Code SHOULD isolate high-frequency telemetry, sensor, and streaming event channels onto a dedicated custom Actor rather than dispatching directly onto @MainActor. - Services MUST throttle or coalesce rapid native events using AsyncStream with backpressure buffering before crossing the cross-platform serialization boundary. - Components NEVER capture non-Sendable hybrid runtime context pointers (e.g., RCTBridge, FlutterBinaryMessenger, or JSContextRef) inside unstructured Task blocks. ## Bad vs Good Implementations ### Hybrid Bridge Event Dispatching under Swift 6 Concurrency #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Declaring @unchecked Sendable silences Swift 6 diagnostics while allowing concurrent read/write mutations on cachedMetrics across detached tasks, violating memory safety. Marshalling NSDictionary directly breaches compiler Sendable boundaries and exposes the hybrid host to torn reads and runtime memory corruption. ```swift // ANTI-PATTERN: Suppressing concurrency checks and sharing mutable bridge references across arbitrary threads import Foundation public class TelemetryBridge: @unchecked Sendable { // Bypasses Swift 6 safety private var cachedMetrics: [String: Any] = [:] // Mutable state without synchronization public var eventSink: ((NSDictionary) -> Void)? public func trackEvent(name: String, value: Double) { // Unstructured task accessing mutable state without actor boundary Task.detached { self.cachedMetrics[name] = value // Data race under concurrent execution if let sink = self.eventSink { sink(self.cachedMetrics as NSDictionary) // Non-Sendable reference leaked to runtime } } } } ``` #### Production Standard (Correct) > **Standard**: State isolation is guaranteed by an actor, preventing data races without unchecked escapes. Event data is encapsulated in a Sendable immutable struct, and rapid updates are mediated by an AsyncStream with explicit backpressure, preserving Swift 6 safety and preventing hybrid thread starvation. ```swift // PRODUCTION STANDARD: Isolated actor domain, immutable Sendable payloads, and AsyncStream buffering import Foundation public struct TelemetryPayload: Sendable, Codable { public let eventName: String public let value: Double public let timestamp: UInt64 } public actor BridgeTransportCoordinator { private var metricsCache: [String: Double] = [:] private var continuation: AsyncStream<TelemetryPayload>.Continuation? public nonisolated let stream: AsyncStream<TelemetryPayload> public init(bufferLimit: Int = 100) { var localContinuation: AsyncStream<TelemetryPayload>.Continuation? self.stream = AsyncStream(bufferingPolicy: .bufferingNewest(bufferLimit)) { cont in localContinuation = cont } self.continuation = localContinuation } public func record(name: String, value: Double) { metricsCache[name] = value let payload = TelemetryPayload(eventName: name, value: value, timestamp: DispatchTime.now().uptimeNanoseconds) continuation?.yield(payload) } } @MainActor public final class NativeBridgeEmitter { private let coordinator: BridgeTransportCoordinator public init(coordinator: BridgeTransportCoordinator) { self.coordinator = coordinator } public func startEmitting(to hybridSink: @escaping @Sendable (TelemetryPayload) -> Void) { Task { [weak self, coordinator] in for await payload in coordinator.stream { guard self != nil else { break } hybridSink(payload) } } } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Swift 6 Strict Concurrency Bridge Isolation for Cross-Platform Runtimes

Swift 6 Strict Concurrency Bridge Isolation for Cross-Platform Runtimes defines an industrial-grade behavioral standard for mobile engineering. Enforces compiler-verified actor boundaries, Sendable serialization invariants, and non-blocking backpressure controls when bridging high-frequency native OS events to hybrid runtimes (React Native TurboModules, Flutter Platform Channels, WKWebView, JNI). Eliminates data races, thread starvation on @MainActor, and runtime crashes induced by Swift 6 complete concurrency checking. 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 Strict Concurrency with @unchecked Sendable on Mutable Bridge State and Invoking Hybrid Callbacks Across Arbitrary Contexts 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 Strict Concurrency with @unchecked Sendable on Mutable Bridge State and Invoking Hybrid Callbacks Across Arbitrary Contexts	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 message payloads and transport structs as immutable value types conforming to Sendable.

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.