Swift 6 Strict Concurrency and MainActor Boundary Enforcement

--- description: Swift 6 Strict Concurrency and MainActor Boundary Enforcement - Enforces complete compile-time data race safety under Swift 6 strict concurrency across UI-bound MainActor states and background telemetry tasks. Mandates strict Sendable adherence, explicit actor domain boundaries, and prohibits capturing mutable reference state within detached Tasks or unisolated async contexts. globs: **/*.swift alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/swift6-strict-concurrency-mainactor-boundary-guardrail" --- # Swift 6 Strict Concurrency and MainActor Boundary Enforcement > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Escaping Non-Sendable Mutable State and Premature MainActor De-Isolation in Background Telemetry ## System Constraints You are a Principal Software Architect specializing in Swift 6 language mechanics and runtime concurrency verification. Your mandate is to enforce strict compile-time data-race safety across MainActor UI domains and background async execution graphs. You must reject any code violating Sendable contracts, escaping mutable references into Task.detached, or incorrectly bridging asynchronous telemetry boundaries without proper actor isolation. ## Strict Guidelines - Engineers MUST ALWAYS mark telemetry event payloads and transport models with immutable value semantics conforming explicitly to Sendable. - Engineers MUST NOT capture mutable class instances or unisolated references inside Task closures originating from @MainActor contexts. - Background aggregation and dispatch services MUST be encapsulated within dedicated actor boundaries or unisolated async functions accepting strictly Sendable payloads. - Code MUST NEVER use @unchecked Sendable as a workaround for compiler errors unless audited and protected by an OSAllocatedUnfairLock or dispatch queue barrier with exhaustive architectural documentation. - UI components and ViewModels MUST declare explicit @MainActor isolation at the class or protocol definition level to ensure synchronous state mutations remain bound to the main thread. ## Bad vs Good Implementations ### Telemetry Dispatch from MainActor View Model #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: TelemetryBatch is a non-Sendable mutable class. Capturing self and self.batch within Task.detached causes an intentional data-race condition under Swift 6, as the background task reads batch.events concurrently with MainActor writes. ```swift import SwiftUI final class TelemetryBatch { var events: [String] = [] func add(_ event: String) { events.append(event) } } @MainActor final class DashboardViewModel: ObservableObject { @Published var displayTitle = "Overview" private let batch = TelemetryBatch() func logInteraction(action: String) { batch.add(action) // ANTI-PATTERN: Capturing mutable non-Sendable class across actor boundary in detached Task Task.detached { print("Logging batch: \(self.batch.events.count)") await NetworkClient.shared.send(batch: self.batch) } } } ``` #### Production Standard (Correct) > **Standard**: Data models are modeled as immutable Sendable value types (TelemetryEvent). Concurrent state collection is isolated inside an actor (TelemetryAggregator), preventing race conditions at compile time and respecting Swift 6 strict concurrency checks without blocking the @MainActor. ```swift import SwiftUI struct TelemetryEvent: Sendable, Identifiable { let id: UUID let action: String let timestamp: Date } actor TelemetryAggregator { private var events: [TelemetryEvent] = [] func enqueue(_ event: TelemetryEvent) async { events.append(event) if events.count >= 10 { await flush() } } private func flush() async { let snapshot = events events.removeAll() await NetworkClient.shared.send(snapshot: snapshot) } } @MainActor final class DashboardViewModel: ObservableObject { @Published var displayTitle = "Overview" private let telemetry: TelemetryAggregator init(telemetry: TelemetryAggregator) { self.telemetry = telemetry } func logInteraction(action: String) { let event = TelemetryEvent(id: UUID(), action: action, timestamp: Date()) Task { // SAFE: TelemetryEvent is Sendable and TelemetryAggregator isolates state mutations await self.telemetry.enqueue(event) } } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Swift 6 Strict Concurrency and MainActor Boundary Enforcement

Swift 6 Strict Concurrency and MainActor Boundary Enforcement defines an industrial-grade behavioral standard for mobile engineering. Enforces complete compile-time data race safety under Swift 6 strict concurrency across UI-bound MainActor states and background telemetry tasks. Mandates strict Sendable adherence, explicit actor domain boundaries, and prohibits capturing mutable reference state within detached Tasks or unisolated async contexts. 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: Escaping Non-Sendable Mutable State and Premature MainActor De-Isolation in Background Telemetry 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	Escaping Non-Sendable Mutable State and Premature MainActor De-Isolation in Background Telemetry	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 telemetry event payloads and transport models with immutable value semantics conforming explicitly 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.