Validation incorrectly detects need for web browser engine entitlement, causes "corrupted binaries" error

CRITICAL UPDATE: I've now removed ALL web-related code:

• No WKWebView
• No WebKit imports
• No SafariServices imports
• No web functionality whatsoever

Still getting the EXACT SAME browser entitlement/arm64e error. This is clearly a critical bug in Apple's validation system affecting app submissions.

Are you specifically trying to use the new arm64e enhanced security that we enabled with iOS 26 beta? For more on that, see Enabling enhanced security for your app.

The reason I ask is that arm64e on iOS was previously limited to folks creating a third-party browser engine using BrowserKit. But it sounds like you’re not in that business at all. If I’m right, then my advice is to disable arm64e until App Store Connect is set up to receive iOS 26 beta submissions. In the past that’s happened at the Release Candidate stage, although I can’t make concrete statements as to what’ll happen this year.

Share and Enjoy
—
Quinn “The Eskimo!” @ Developer Technical Support @ Apple
let myEmail = "eskimo" + "1" + "@" + "apple.com"

Thank you for the response! However, I've found the actual root cause of the issue.

To clarify: I'm not using iOS 26 beta or arm64e architecture - I verified this multiple times in my build settings. My app targets iOS 15+ and uses standard architectures.

Root Cause Identified: The web browser engine entitlement requirement is being incorrectly triggered by a complex async pattern in my SwiftUI code. Specifically, this .task block with nested withCheckedContinuation, actor, and withObservationTracking:

.task {
    if isLoading {
        // Wait for AuthManager to complete user state determination
        print("🕐 SkydenApp: Waiting for AuthManager to complete user state determination...")
        
        // Use withObservationTracking to wait for isUserStateReady
        await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
            actor ContinuationState {
                private var hasResumed = false
                
                func tryResume(_ continuation: CheckedContinuation<Void, Never>) -> Bool {
                    if !hasResumed {
                        hasResumed = true
                        continuation.resume()
                        return true
                    }
                    return false
                }
                
                func shouldContinue() -> Bool {
                    return !hasResumed
                }
            }
            
            let state = ContinuationState()
            
            @MainActor func checkReadyState() {
                withObservationTracking {
                    let isReady = appContext.authManager.isUserStateReady
                    print("🔍 SkydenApp: AuthManager.isUserStateReady = \(isReady)")
                    
                    if isReady {
                        Task {
                            if await state.tryResume(continuation) {
                                print("✅ SkydenApp: AuthManager user state ready!")
                            }
                        }
                    }
                } onChange: {
                    // Re-check when state changes, but only if we haven't resumed yet
                    Task {
                        if await state.shouldContinue() {
                            await MainActor.run {
                                checkReadyState()
                            }
                        }
                    }
                }
            }
            
            // Start checking on main actor
            Task { @MainActor in
                checkReadyState()
            }
        }
        
        // Non-blocking: Start app initialization in background
        Task {
            await performAppInitialization()
        }
        isLoading = false

        // Small delay to ensure main content is ready before fade
        try? await Task.sleep(for: .milliseconds(500))
        
        // Trigger fade out animation
        shouldFadeOutSplash = true
    }
}

When I simplified this to a basic async pattern, the entitlement requirement disappeared completely.

This appears to be a bug in Apple's static analysis/validation tools - they're incorrectly flagging this complex async pattern as requiring web browser engine capabilities, when it's actually just waiting for an observable property to change.

Impact: This could affect other developers using similar advanced async patterns with SwiftUI observation, even when they have no web browser functionality in their apps.

Reproduction: The above code should reliably reproduce the issue when validating with App Store Connect.

I hope this helps the validation team identify and fix this edge case in the static analysis tools!

I’m glad you’re making progress. However, I’m not able to reproduce this. I created a new test project from the iOS > Mac template, set the deployment target to iOS 18.0, and then added your code (I’ve included the final ContentView.swift below). When I validate an archive, I get some errors related to icon problems, but nothing like the error you’re seeing.

This is Xcode 16.4 on macOS 15.5.

Share and Enjoy
—
Quinn “The Eskimo!” @ Developer Technical Support @ Apple
let myEmail = "eskimo" + "1" + "@" + "apple.com"

import SwiftUI

func performAppInitialization() async { }

class AuthManager {
    var isUserStateReady: Bool = false
}

class AppContext {
    var authManager: AuthManager = .init()
}

struct ContentView: View {
    var body: some View {
        @State var appContext: AppContext = AppContext()
        @State var isLoading: Bool = false
        @State var shouldFadeOutSplash: Bool = false
        VStack {
            Text("Hello, world!")
        }
        .padding()
        .task {
            if isLoading {
                // Wait for AuthManager to complete user state determination
                print(
                    "🕐 SkydenApp: Waiting for AuthManager to complete user state determination..."
                )

                // Use withObservationTracking to wait for isUserStateReady
                await withCheckedContinuation {
                    (continuation: CheckedContinuation<Void, Never>) in
                    actor ContinuationState {
                        private var hasResumed = false

                        func tryResume(
                            _ continuation: CheckedContinuation<Void, Never>
                        ) -> Bool {
                            if !hasResumed {
                                hasResumed = true
                                continuation.resume()
                                return true
                            }
                            return false
                        }

                        func shouldContinue() -> Bool {
                            return !hasResumed
                        }
                    }

                    let state = ContinuationState()

                    @MainActor func checkReadyState() {
                        withObservationTracking {
                            let isReady = appContext.authManager
                                .isUserStateReady
                            print(
                                "🔍 SkydenApp: AuthManager.isUserStateReady = \(isReady)"
                            )

                            if isReady {
                                Task {
                                    if await state.tryResume(continuation) {
                                        print(
                                            "✅ SkydenApp: AuthManager user state ready!"
                                        )
                                    }
                                }
                            }
                        } onChange: {
                            // Re-check when state changes, but only if we haven't resumed yet
                            Task {
                                if await state.shouldContinue() {
                                    await MainActor.run {
                                        checkReadyState()
                                    }
                                }
                            }
                        }
                    }

                    // Start checking on main actor
                    Task { @MainActor in
                        checkReadyState()
                    }
                }

                // Non-blocking: Start app initialization in background
                Task {
                    await performAppInitialization()
                }
                isLoading = false

                // Small delay to ensure main content is ready before fade
                try? await Task.sleep(for: .milliseconds(500))

                // Trigger fade out animation
                shouldFadeOutSplash = true
            }
        }
    }
}