expo 57.0.22 → 57.0.23

package/android/build.gradle

@@ -10,7 +10,7 @@ buildscript {
 }
 
 group = 'host.exp.exponent'
-version = '57.0.22'
+version = '57.0.23'
 
 expoModule {
   // We can't prebuild the module because it depends on the generated files.
@@ -21,7 +21,7 @@ android {
   namespace "expo.core"
   defaultConfig {
     versionCode 1
-    versionName "57.0.22"
+    versionName "57.0.23"
     consumerProguardFiles("proguard-rules.pro")
   }
   testOptions {

package/bundledNativeModules.json

@@ -17,19 +17,19 @@
   "expo-analytics-amplitude": "~11.3.0",
   "expo-app-auth": "~11.1.0",
   "expo-app-loader-provider": "~8.0.0",
-  "expo-app-metrics": "~57.0.18",
+  "expo-app-metrics": "~57.0.19",
   "expo-apple-authentication": "~57.0.2",
   "expo-application": "~57.0.3",
   "expo-asset": "~57.0.17",
   "expo-audio": "~57.0.5",
   "expo-auth-session": "~57.0.12",
-  "expo-background-fetch": "~57.0.17",
-  "expo-background-task": "~57.0.17",
+  "expo-background-fetch": "~57.0.18",
+  "expo-background-task": "~57.0.18",
   "expo-battery": "~57.0.3",
   "expo-blur": "~57.0.3",
   "expo-brightness": "~57.0.2",
-  "expo-brownfield": "~57.0.19",
-  "expo-build-properties": "~57.0.17",
+  "expo-brownfield": "~57.0.20",
+  "expo-build-properties": "~57.0.18",
   "expo-calendar": "~57.0.3",
   "expo-camera": "~57.0.5",
   "expo-cellular": "~57.0.2",
@@ -50,28 +50,28 @@
   "expo-haptics": "~57.0.3",
   "expo-image": "~57.0.5",
   "expo-image-loader": "~57.0.1",
-  "expo-image-manipulator": "~57.0.17",
-  "expo-image-picker": "~57.0.17",
+  "expo-image-manipulator": "~57.0.18",
+  "expo-image-picker": "~57.0.18",
   "expo-intent-launcher": "~57.0.1",
-  "expo-insights": "~57.0.17",
+  "expo-insights": "~57.0.18",
   "expo-keep-awake": "~57.0.2",
   "expo-linear-gradient": "~57.0.2",
   "expo-linking": "~57.0.10",
   "expo-local-authentication": "~57.0.3",
   "expo-localization": "~57.0.2",
-  "expo-location": "~57.0.17",
+  "expo-location": "~57.0.18",
   "expo-mail-composer": "~57.0.2",
   "expo-manifests": "~57.0.2",
   "expo-maps": "~57.0.3",
   "expo-mcp": "~0.2.1",
   "expo-media-library": "~57.0.5",
   "expo-mesh-gradient": "~57.0.2",
-  "expo-module-template": "~57.0.11",
+  "expo-module-template": "~57.0.12",
   "expo-modules-core": "~57.0.18",
   "expo-navigation-bar": "~57.0.2",
   "expo-network": "~57.0.2",
-  "expo-notifications": "~57.0.18",
-  "expo-observe": "~57.0.21",
+  "expo-notifications": "~57.0.19",
+  "expo-observe": "~57.0.22",
   "expo-print": "~57.0.2",
   "expo-live-photo": "~57.0.2",
   "expo-router": "~57.0.21",
@@ -80,7 +80,7 @@
   "expo-secure-store": "~57.0.4",
   "expo-sensors": "~57.0.3",
   "expo-server": "~57.0.3",
-  "expo-sharing": "~57.0.19",
+  "expo-sharing": "~57.0.20",
   "expo-sms": "~57.0.2",
   "expo-speech": "~57.0.3",
   "expo-splash-screen": "~57.0.9",
@@ -89,7 +89,7 @@
   "expo-store-review": "~57.0.3",
   "expo-symbols": "~57.0.3",
   "expo-system-ui": "~57.0.4",
-  "expo-task-manager": "~57.0.17",
+  "expo-task-manager": "~57.0.18",
   "expo-tracking-transparency": "~57.0.2",
   "expo-updates": "~57.0.22",
   "expo-video-thumbnails": "~57.0.2",

package/ios/AppDelegates/ExpoAppSceneDelegate.swift

@@ -0,0 +1,181 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import Foundation
+import React
+
+#if os(iOS) || os(tvOS)
+
+/**
+`UIWindowSceneDelegate` base class for Expo apps. Required by the iOS 27, which
+ asserts at launch unless the app adopts the scene-based life cycle.
+
+ Responsibilities:
+ - Create the `UIWindow` from the connecting `UIWindowScene` and start React Native into it.
+ - Re-feed scene life-cycle, URL, user-activity, and quick-action events to the app delegate.
+
+ Requires the app delegate to be an `ExpoAppDelegate`; it forwards every event to the subscribers,
+ so one call reaches both subscribers and `AppDelegate` overrides.
+ */
+@available(iOSApplicationExtension, unavailable)
+@objc(EXExpoAppSceneDelegate)
+open class ExpoAppSceneDelegate: UIResponder, UIWindowSceneDelegate {
+  open var window: UIWindow?
+
+  let forwarder = SceneEventForwarder()
+
+  open func scene(
+    _ scene: UIScene,
+    willConnectTo session: UISceneSession,
+    options connectionOptions: UIScene.ConnectionOptions
+  ) {
+    guard let windowScene = scene as? UIWindowScene else {
+      return
+    }
+    guard let appDelegate = UIApplication.shared.delegate as? ExpoAppDelegate,
+      let provider = appDelegate as? ExpoReactNativeFactoryProvider,
+      let factory = provider.reactNativeFactory else {
+      fatalError(
+        "ExpoAppSceneDelegate couldn't start React Native because the app delegate isn't an "
+        + "ExpoAppDelegate that provides a React Native factory. Make sure your AppDelegate subclasses "
+        + "ExpoAppDelegate, conforms to ExpoReactNativeFactoryProvider and creates its "
+        + "RCTReactNativeFactory in application(_:didFinishLaunchingWithOptions:)."
+      )
+    }
+
+    let window = UIWindow(windowScene: windowScene)
+    self.window = window
+
+    // Mirror the window onto the app delegate so code that reads
+    // `UIApplication.shared.delegate?.window` keeps working (e.g. expo-system-ui).
+    provider.window = window
+
+    // Under the scene life cycle UIKit passes cold-start URLs and activities in `connectionOptions`
+    // rather than in the app delegate's launch options. React Native's `Linking.getInitialURL()`
+    // only reads them from launch options, so rebuild them here; otherwise a link that cold-starts
+    // the app is delivered to no one, because the `url` event routed below fires before JS is ready.
+    let browsingWebActivity = connectionOptions.userActivities.first {
+      $0.activityType == NSUserActivityTypeBrowsingWeb
+    }
+    factory.startReactNative(
+      withModuleName: provider.reactNativeFactoryModuleName,
+      in: window,
+      launchOptions: Self.launchOptions(
+        url: connectionOptions.urlContexts.first?.url,
+        userActivity: browsingWebActivity
+      )
+    )
+
+    // Deep links / universal links.
+    connectionOptions.urlContexts.forEach {
+      forwarder.open(url: $0.url, options: Self.openURLOptions(from: $0.options))
+    }
+    connectionOptions.userActivities.forEach { forwarder.continue($0) }
+
+#if os(iOS)
+    // A quick action that cold-starts the app arrives here instead of in
+    // `windowScene(_:performActionFor:completionHandler:)`, which UIKit only calls while running.
+    if let shortcutItem = connectionOptions.shortcutItem {
+      forwarder.perform(shortcutItem) { _ in }
+    }
+#endif
+  }
+
+  open func sceneDidDisconnect(_ scene: UIScene) {
+    window = nil
+  }
+
+  open func sceneDidBecomeActive(_ scene: UIScene) {
+    forwarder.didBecomeActive()
+  }
+
+  open func sceneWillResignActive(_ scene: UIScene) {
+    forwarder.willResignActive()
+  }
+
+  open func sceneWillEnterForeground(_ scene: UIScene) {
+    forwarder.willEnterForeground()
+  }
+
+  open func sceneDidEnterBackground(_ scene: UIScene) {
+    forwarder.didEnterBackground()
+  }
+
+  open func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
+    URLContexts.forEach { forwarder.open(url: $0.url, options: Self.openURLOptions(from: $0.options)) }
+  }
+
+  open func scene(_ scene: UIScene, willContinueUserActivityWithType userActivityType: String) {
+    forwarder.willContinueUserActivity(withType: userActivityType)
+  }
+
+  open func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
+    forwarder.continue(userActivity)
+  }
+
+  open func scene(
+    _ scene: UIScene,
+    didFailToContinueUserActivityWithType userActivityType: String,
+    error: Error
+  ) {
+    forwarder.didFailToContinueUserActivity(withType: userActivityType, error: error)
+  }
+
+  open func scene(_ scene: UIScene, didUpdate userActivity: NSUserActivity) {
+    forwarder.didUpdate(userActivity)
+  }
+
+#if os(iOS)
+  open func windowScene(
+    _ windowScene: UIWindowScene,
+    performActionFor shortcutItem: UIApplicationShortcutItem,
+    completionHandler: @escaping (Bool) -> Void
+  ) {
+    forwarder.perform(shortcutItem, completionHandler: completionHandler)
+  }
+#endif
+  // MARK: - Launch options
+
+  /// Rebuilds the launch options that `Linking.getInitialURL()` reads from a scene's connection
+  /// options. Returns `nil` when the app wasn't cold-started by a URL or a browsing-web activity,
+  /// so it can be forwarded to `startReactNative` as-is.
+  static func launchOptions(
+    url: URL?,
+    userActivity: NSUserActivity?
+  ) -> [UIApplication.LaunchOptionsKey: Any]? {
+    // Build the keys from their underlying constant strings rather than the `UIApplication`
+    // accessors (`.url`, `.userActivityDictionary`): those accessors are deprecated as of iOS 26
+    // in favor of the scene APIs, but React Native's `getInitialURL` still reads the launch options
+    // by these exact keys, so this is the shape it expects.
+    var launchOptions: [UIApplication.LaunchOptionsKey: Any] = [:]
+    if let url {
+      let urlKey = UIApplication.LaunchOptionsKey(rawValue: "UIApplicationLaunchOptionsURLKey")
+      launchOptions[urlKey] = url
+    }
+    if let userActivity {
+      let userActivityDictionaryKey = UIApplication.LaunchOptionsKey(
+        rawValue: "UIApplicationLaunchOptionsUserActivityDictionaryKey"
+      )
+      launchOptions[userActivityDictionaryKey] = [
+        "UIApplicationLaunchOptionsUserActivityTypeKey": userActivity.activityType,
+        "UIApplicationLaunchOptionsUserActivityKey": userActivity
+      ]
+    }
+    return launchOptions.isEmpty ? nil : launchOptions
+  }
+
+  private static func openURLOptions(
+    from sceneOptions: UIScene.OpenURLOptions
+  ) -> [UIApplication.OpenURLOptionsKey: Any] {
+    var options: [UIApplication.OpenURLOptionsKey: Any] = [:]
+    if let sourceApplication = sceneOptions.sourceApplication {
+      options[.sourceApplication] = sourceApplication
+    }
+    if let annotation = sceneOptions.annotation {
+      options[.annotation] = annotation
+    }
+    options[.openInPlace] = sceneOptions.openInPlace
+    return options
+  }
+}
+
+#endif

package/ios/AppDelegates/ExpoReactNativeFactoryProvider.swift

@@ -0,0 +1,30 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import React
+
+/**
+ Conformed to by the application's `AppDelegate` so that the scene delegate can retrieve
+ the React Native factory it created during `application(_:didFinishLaunchingWithOptions:)`.
+
+ In the scene-based life cycle the window is created by the scene delegate, but the factory
+ is still owned by the app delegate. This protocol is the bridge between the two.
+ */
+@MainActor
+public protocol ExpoReactNativeFactoryProvider: AnyObject {
+  /// The app's window. The scene delegate creates the window and assigns it here so that code
+  /// reading `UIApplication.shared.delegate?.window` keeps working (e.g. expo-system-ui).
+  /// This is the same `var window: UIWindow?` the app delegate already declares for `UIApplicationDelegate`.
+  var window: UIWindow? { get set }
+
+  /// The factory created in `application(_:didFinishLaunchingWithOptions:)`.
+  var reactNativeFactory: RCTReactNativeFactory? { get }
+
+  /// The registered React Native module name. Defaults to `"main"`.
+  var reactNativeFactoryModuleName: String { get }
+}
+
+public extension ExpoReactNativeFactoryProvider {
+  var reactNativeFactoryModuleName: String {
+    return "main"
+  }
+}

package/ios/AppDelegates/SceneEventForwarder.swift

@@ -0,0 +1,154 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import Foundation
+import React
+
+#if os(iOS) || os(tvOS)
+
+/**
+ Re-feeds scene events to the app delegate. Under the scene life cycle UIKit no longer calls the
+ app delegate's URL, user-activity, life-cycle and quick-action methods, so overrides in the app's
+ `AppDelegate: ExpoAppDelegate` would never run; `ExpoAppDelegate` forwards every event to the
+ subscribers, so one call reaches both.
+
+ Main-actor isolated: `UIWindowSceneDelegate` hands these events over on the main actor, and every
+ `ExpoAppDelegate` method they reach is main-actor isolated too.
+ */
+@MainActor
+@available(iOSApplicationExtension, unavailable)
+struct SceneEventForwarder {
+  var appDelegate: () -> ExpoAppDelegate? = { UIApplication.shared.delegate as? ExpoAppDelegate }
+
+  func open(url: URL, options: [UIApplication.OpenURLOptionsKey: Any]) {
+    let application = UIApplication.shared
+    let delegate = appDelegate()
+
+    notifyLinkingManagerUnlessAlreadyNotified(of: url) {
+      _ = delegate?.application(application, open: url, options: options)
+    } notify: {
+      RCTLinkingManager.application(application, open: url, options: options)
+    }
+  }
+
+  func `continue`(_ userActivity: NSUserActivity) {
+    let application = UIApplication.shared
+    let delegate = appDelegate()
+
+    // `RCTLinkingManager` only announces browsing-web activities, so there is nothing to dedupe
+    // against for the other activity types.
+    notifyLinkingManagerUnlessAlreadyNotified(of: userActivity.webpageURL) {
+      _ = delegate?.application(application, continue: userActivity, restorationHandler: { _ in })
+    } notify: {
+      RCTLinkingManager.application(application, continue: userActivity, restorationHandler: { _ in })
+    }
+  }
+
+  func willContinueUserActivity(withType userActivityType: String) {
+    // The scene callback has no return value, unlike its app-delegate counterpart. Calling the app
+    // delegate still lets every subscriber prepare; its aggregated result is intentionally ignored.
+    _ = appDelegate()?.application(
+      UIApplication.shared,
+      willContinueUserActivityWithType: userActivityType
+    )
+  }
+
+  func didFailToContinueUserActivity(withType userActivityType: String, error: Error) {
+    appDelegate()?.application(
+      UIApplication.shared,
+      didFailToContinueUserActivityWithType: userActivityType,
+      error: error
+    )
+  }
+
+  func didUpdate(_ userActivity: NSUserActivity) {
+    appDelegate()?.application(UIApplication.shared, didUpdate: userActivity)
+  }
+
+  func didBecomeActive() {
+    appDelegate()?.applicationDidBecomeActive(UIApplication.shared)
+  }
+
+  func willResignActive() {
+    appDelegate()?.applicationWillResignActive(UIApplication.shared)
+  }
+
+  func willEnterForeground() {
+    appDelegate()?.applicationWillEnterForeground(UIApplication.shared)
+  }
+
+  func didEnterBackground() {
+    appDelegate()?.applicationDidEnterBackground(UIApplication.shared)
+  }
+
+#if os(iOS)
+  /// UIKit waits on `completionHandler`, so it has to run exactly once.
+  func perform(
+    _ shortcutItem: UIApplicationShortcutItem,
+    completionHandler: @escaping (Bool) -> Void
+  ) {
+    guard let delegate = appDelegate() else {
+      completionHandler(false)
+      return
+    }
+    delegate.application(
+      UIApplication.shared,
+      performActionFor: shortcutItem,
+      completionHandler: completionHandler
+    )
+  }
+#endif
+
+  /// Runs `body`, then calls `notify` unless `RCTLinkingManager` was already notified about `url`
+  /// while `body` ran. Always calls `notify` when `url` is `nil`.
+  ///
+  /// App delegates generated by SDK 57 and older call `RCTLinkingManager` themselves, which would
+  /// deliver the JS `url` event twice now that their overrides run again, and no static check can
+  /// tell such an override apart — so listen for what `RCTLinkingManager` announces instead.
+  private func notifyLinkingManagerUnlessAlreadyNotified(
+    of url: URL?,
+    during body: () -> Void,
+    notify: () -> Void
+  ) {
+    guard let url else {
+      body()
+      notify()
+      return
+    }
+    let observer = LinkingManagerObserver(url: url)
+    body()
+    if !observer.wasNotified {
+      notify()
+    }
+  }
+}
+
+/// Observes the notification `RCTLinkingManager` posts for every link it handles. The name is
+/// private to React Native's `RCTLinkingManager.mm` — expo-router spells it out the same way in
+/// `ExpoHeadAppDelegateSubscriber.swift`. If React Native renames it, legacy overrides deliver a
+/// duplicate `url` event again; a link is never lost.
+private final class LinkingManagerObserver: NSObject {
+  private let expectedURL: String
+  private(set) var wasNotified = false
+
+  init(url: URL) {
+    expectedURL = url.absoluteString
+    super.init()
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(linkingManagerDidOpenURL(_:)),
+      name: Notification.Name("RCTOpenURLNotification"),
+      object: nil
+    )
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  @objc
+  private func linkingManagerDidOpenURL(_ notification: Notification) {
+    wasNotified = wasNotified || notification.userInfo?["url"] as? String == expectedURL
+  }
+}
+
+#endif

package/ios/Tests/ExpoAppSceneDelegateTests.swift

@@ -0,0 +1,602 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import React
+import Testing
+@testable import Expo
+
+#if os(iOS) || os(tvOS)
+
+@Suite(.serialized)
+struct ExpoAppSceneDelegateTests {
+  @Test
+  func `extends UIResponder`() {
+    // Assert that `ExpoAppSceneDelegate` extends from `UIResponder` so it doesn't regress in the future.
+    // UIKit instantiates the scene delegate by name and expects a responder; losing this would break
+    // responder-chain behavior such as key presses.
+    #expect(ExpoAppSceneDelegate.self is UIResponder.Type)
+  }
+
+  @Test
+  func `conforms to UIWindowSceneDelegate`() {
+    // The iOS 27 SDK asserts at launch unless the app's scene delegate adopts the scene life cycle.
+    // Conforming to `UIWindowSceneDelegate` is what makes the class usable as the scene delegate.
+    #expect(ExpoAppSceneDelegate.self is UIWindowSceneDelegate.Type)
+  }
+
+  @Test
+  @MainActor
+  func `exposes scene user activity callbacks to UIKit`() {
+    let sceneDelegate = ExpoAppSceneDelegate()
+    #expect(
+      sceneDelegate.responds(
+        to: #selector(UISceneDelegate.scene(_:willContinueUserActivityWithType:))
+      )
+    )
+    #expect(sceneDelegate.responds(to: #selector(UISceneDelegate.scene(_:didUpdate:))))
+    #expect(
+      sceneDelegate.responds(
+        to: #selector(UISceneDelegate.scene(_:didFailToContinueUserActivityWithType:error:))
+      )
+    )
+  }
+
+  @Test
+  @MainActor
+  func `builds launch options carrying a cold-start URL`() {
+    // Under the scene life cycle the URL that cold-started the app arrives in the scene connection
+    // options, not in the app delegate's launch options. Synthesizing launch options from it is
+    // what lets `Linking.getInitialURL()` (which reads `UIApplicationLaunchOptionsURLKey`) return
+    // the URL, matching the app-delegate life cycle it replaced.
+    let url = URL(string: "bareexpo://test-suite/run?tests=AppMetrics")!
+    let launchOptions = ExpoAppSceneDelegate.launchOptions(url: url, userActivity: nil)
+    let urlKey = UIApplication.LaunchOptionsKey(rawValue: "UIApplicationLaunchOptionsURLKey")
+    #expect(launchOptions?[urlKey] as? URL == url)
+  }
+
+  @Test
+  @MainActor
+  func `builds launch options carrying a browsing-web user activity`() {
+    let userActivity = NSUserActivity(activityType: NSUserActivityTypeBrowsingWeb)
+    userActivity.webpageURL = URL(string: "https://expo.dev/link")!
+    let launchOptions = ExpoAppSceneDelegate.launchOptions(url: nil, userActivity: userActivity)
+    let userActivityDictionaryKey = UIApplication.LaunchOptionsKey(
+      rawValue: "UIApplicationLaunchOptionsUserActivityDictionaryKey"
+    )
+    let activityDictionary = launchOptions?[userActivityDictionaryKey] as? [AnyHashable: Any]
+    #expect(activityDictionary?["UIApplicationLaunchOptionsUserActivityTypeKey"] as? String == NSUserActivityTypeBrowsingWeb)
+    #expect((activityDictionary?["UIApplicationLaunchOptionsUserActivityKey"] as? NSUserActivity) === userActivity)
+  }
+
+  @Test
+  @MainActor
+  func `returns nil launch options without a URL or user activity`() {
+    #expect(ExpoAppSceneDelegate.launchOptions(url: nil, userActivity: nil) == nil)
+  }
+
+  @Test
+  @MainActor
+  func `an app delegate can provide the React Native factory`() {
+    let appDelegate = FactoryProvidingAppDelegate()
+    #expect(appDelegate.reactNativeFactory == nil)
+    #expect(appDelegate.reactNativeFactoryModuleName == "main")
+  }
+
+  @Test
+  @MainActor
+  func `routes an opened URL through the app delegate`() {
+    let spy = SpyAppDelegate()
+    let url = URL(string: "bareexpo://scene-delegate/open-url")!
+    SceneEventForwarder(appDelegate: { spy }).open(url: url, options: [.sourceApplication: "dev.expo.Payments"])
+    #expect(spy.openedURLs.count == 1)
+    #expect(spy.openedURLs.first?.url == url)
+    #expect(spy.openedURLs.first?.options[.sourceApplication] as? String == "dev.expo.Payments")
+  }
+
+  @Test
+  @MainActor
+  func `routes a continued user activity through the app delegate`() {
+    let spy = SpyAppDelegate()
+    let subscriber = UserActivityRecordingSubscriber()
+    ExpoAppDelegateSubscriberRepository.registerSubscriber(subscriber)
+    let userActivity = NSUserActivity(activityType: NSUserActivityTypeBrowsingWeb)
+    userActivity.webpageURL = URL(string: "https://expo.dev/scene-delegate")!
+    SceneEventForwarder(appDelegate: { spy }).continue(userActivity)
+    #expect(spy.continuedUserActivities.count == 1)
+    #expect(spy.continuedUserActivities.first === userActivity)
+    #expect(subscriber.continuations.filter { $0 === userActivity }.count == 1)
+  }
+
+  @Test
+  @MainActor
+  func `asks every subscriber to prepare for a scene user activity`() {
+    let activityType = "dev.expo.scene-delegate.prepare.\(UUID().uuidString)"
+    let firstSubscriber = UserActivityRecordingSubscriber(willContinueResult: false)
+    let handlingSubscriber = UserActivityRecordingSubscriber(willContinueResult: true)
+    let lastSubscriber = UserActivityRecordingSubscriber(willContinueResult: false)
+    ExpoAppDelegateSubscriberRepository.registerSubscriber(firstSubscriber)
+    ExpoAppDelegateSubscriberRepository.registerSubscriber(handlingSubscriber)
+    ExpoAppDelegateSubscriberRepository.registerSubscriber(lastSubscriber)
+
+    let spy = SpyAppDelegate()
+    SceneEventForwarder(appDelegate: { spy }).willContinueUserActivity(withType: activityType)
+
+    #expect(spy.preparations.count == 1)
+    #expect(isSharedApplication(spy.preparations.first?.application))
+    #expect(spy.preparations.first?.activityType == activityType)
+    #expect(spy.continuedUserActivities.isEmpty)
+    for subscriber in [firstSubscriber, handlingSubscriber, lastSubscriber] {
+      let preparations = subscriber.preparations.filter { $0.activityType == activityType }
+      #expect(preparations.count == 1)
+      #expect(isSharedApplication(preparations.first?.application))
+      #expect(subscriber.continuations.isEmpty)
+    }
+  }
+
+  @Test
+  @MainActor
+  func `forwards scene user activity updates and failures without continuing`() {
+    let activityType = "dev.expo.scene-delegate.failure.\(UUID().uuidString)"
+    let userActivity = NSUserActivity(
+      activityType: "dev.expo.scene-delegate.update.\(UUID().uuidString)"
+    )
+    let error = NSError(
+      domain: "dev.expo.scene-delegate.handoff",
+      code: 17,
+      userInfo: [NSLocalizedDescriptionKey: "Handoff transfer failed"]
+    )
+    let subscriber = UserActivityRecordingSubscriber()
+    ExpoAppDelegateSubscriberRepository.registerSubscriber(subscriber)
+
+    let spy = SpyAppDelegate()
+    let forwarder = SceneEventForwarder(appDelegate: { spy })
+    forwarder.didUpdate(userActivity)
+    forwarder.didFailToContinueUserActivity(withType: activityType, error: error)
+
+    #expect(spy.updatedUserActivities.count == 1)
+    #expect(isSharedApplication(spy.updatedUserActivities.first?.application))
+    #expect(spy.updatedUserActivities.first?.userActivity === userActivity)
+    #expect(spy.userActivityFailures.count == 1)
+    #expect(isSharedApplication(spy.userActivityFailures.first?.application))
+    #expect(spy.userActivityFailures.first?.activityType == activityType)
+    #expect((spy.userActivityFailures.first?.error as NSError?) === error)
+    #expect(spy.preparations.isEmpty)
+    #expect(spy.continuedUserActivities.isEmpty)
+    #expect(subscriber.updates.count == 1)
+    #expect(isSharedApplication(subscriber.updates.first?.application))
+    #expect(subscriber.updates.first?.userActivity === userActivity)
+    #expect(subscriber.failures.count == 1)
+    #expect(isSharedApplication(subscriber.failures.first?.application))
+    #expect(subscriber.failures.first?.activityType == activityType)
+    #expect((subscriber.failures.first?.error as NSError?) === error)
+    #expect(subscriber.preparations.isEmpty)
+    #expect(subscriber.continuations.isEmpty)
+  }
+
+  @Test
+  @MainActor
+  func `routes life cycle events through the app delegate`() {
+    let spy = SpyAppDelegate()
+    let forwarder = SceneEventForwarder(appDelegate: { spy })
+    forwarder.didBecomeActive()
+    forwarder.willResignActive()
+    forwarder.willEnterForeground()
+    forwarder.didEnterBackground()
+    #expect(spy.lifeCycleEvents == [
+      "applicationDidBecomeActive",
+      "applicationWillResignActive",
+      "applicationWillEnterForeground",
+      "applicationDidEnterBackground"
+    ])
+  }
+
+#if os(iOS)
+  @Test
+  @MainActor
+  func `routes a quick action through the app delegate`() async {
+    let spy = SpyAppDelegate()
+    let shortcutItem = UIApplicationShortcutItem(
+      type: "dev.expo.bareexpo.run-tests",
+      localizedTitle: "Run tests"
+    )
+    var handled: [Bool] = []
+    // The subscriber manager completes on the next main-queue turn when a subscriber handles the
+    // action, so wait for the first reply instead of assuming a synchronous one.
+    await withCheckedContinuation { continuation in
+      var didResume = false
+      SceneEventForwarder(appDelegate: { spy }).perform(shortcutItem) { succeeded in
+        handled.append(succeeded)
+        if !didResume {
+          didResume = true
+          continuation.resume()
+        }
+      }
+    }
+    await drainMainQueue()
+    #expect(spy.shortcutItemTypes == [shortcutItem.type])
+    #expect(handled == [false])
+  }
+#endif
+
+  @Test
+  @MainActor
+  func `notifies RCTLinkingManager once per routed URL`() {
+    let url = URL(string: "bareexpo://scene-delegate/linking")!
+    let recorder = OpenURLNotificationRecorder()
+    let spy = SpyAppDelegate()
+    SceneEventForwarder(appDelegate: { spy }).open(url: url, options: [:])
+    #expect(recorder.count(of: url) == 1)
+  }
+
+  @Test
+  @MainActor
+  func `notifies RCTLinkingManager for a universal link without a legacy linking override`() {
+    let delegate = SpyAppDelegate()
+    let url = URL(string: "https://expo.dev/scene-delegate/fallback-activity")!
+    let activity = NSUserActivity(activityType: NSUserActivityTypeBrowsingWeb)
+    activity.webpageURL = url
+    let recorder = OpenURLNotificationRecorder()
+
+    SceneEventForwarder(appDelegate: { delegate }).continue(activity)
+
+    #expect(delegate.continuedUserActivities.first === activity)
+    #expect(recorder.count(of: url) == 1)
+  }
+
+  @Test
+  @MainActor
+  func `delivers repeated opens of the same URL once for each invocation`() {
+    let delegate = LegacyLinkingAppDelegate()
+    let url = URL(string: "bareexpo://scene-delegate/repeated-url")!
+    let recorder = OpenURLNotificationRecorder()
+    let forwarder = SceneEventForwarder(appDelegate: { delegate })
+
+    forwarder.open(url: url, options: [:])
+    forwarder.open(url: url, options: [:])
+
+    #expect(delegate.openedURLs == [url, url])
+    #expect(recorder.count(of: url) == 2)
+  }
+
+  @Test
+  @MainActor
+  func `notifies RCTLinkingManager once when the delegate notifies it too`() {
+    let delegate = LegacyLinkingAppDelegate()
+    let url = URL(string: "bareexpo://scene-delegate/legacy-open-url")!
+    let recorder = OpenURLNotificationRecorder()
+    SceneEventForwarder(appDelegate: { delegate }).open(url: url, options: [:])
+    #expect(delegate.openedURLs == [url])
+    #expect(recorder.count(of: url) == 1)
+  }
+
+  @Test
+  @MainActor
+  func `notifies RCTLinkingManager once per user activity when the delegate notifies it too`() {
+    let delegate = LegacyLinkingAppDelegate()
+    let webpageURL = URL(string: "https://expo.dev/scene-delegate/legacy-activity")!
+    let userActivity = NSUserActivity(activityType: NSUserActivityTypeBrowsingWeb)
+    userActivity.webpageURL = webpageURL
+    let recorder = OpenURLNotificationRecorder()
+    SceneEventForwarder(appDelegate: { delegate }).continue(userActivity)
+    #expect(delegate.continuedUserActivities.count == 1)
+    #expect(recorder.count(of: webpageURL) == 1)
+  }
+
+  @Test
+  @MainActor
+  func `does not notify subscribers without an ExpoAppDelegate`() {
+    let subscriber = URLRecordingSubscriber()
+    ExpoAppDelegateSubscriberRepository.registerSubscriber(subscriber)
+
+    let url = URL(string: "bareexpo://scene-delegate/no-app-delegate")!
+    let recorder = OpenURLNotificationRecorder()
+    SceneEventForwarder(appDelegate: { nil }).open(url: url, options: [:])
+    #expect(subscriber.count(of: url) == 0)
+    #expect(recorder.count(of: url) == 1)
+  }
+
+#if os(iOS)
+  @Test
+  @MainActor
+  func `completes a quick action with false without an ExpoAppDelegate`() async {
+    let shortcutItem = UIApplicationShortcutItem(
+      type: "dev.expo.bareexpo.unhandled-action",
+      localizedTitle: "Unhandled action"
+    )
+    var handled: [Bool] = []
+    await withCheckedContinuation { continuation in
+      var didResume = false
+      SceneEventForwarder(appDelegate: { nil }).perform(shortcutItem) { succeeded in
+        handled.append(succeeded)
+        if !didResume {
+          didResume = true
+          continuation.resume()
+        }
+      }
+    }
+    await drainMainQueue()
+    #expect(handled == [false])
+  }
+#endif
+
+  @Test
+  @MainActor
+  func `forwards to the app delegate of the running application`() {
+    let forwarder = ExpoAppSceneDelegate().forwarder
+    #expect(forwarder.appDelegate() === UIApplication.shared.delegate as? ExpoAppDelegate)
+  }
+}
+
+@MainActor
+private func isSharedApplication(_ application: UIApplication?) -> Bool {
+  // A hostless XCTest runner can bridge `UIApplication.shared` as nil despite its nonoptional
+  // Swift declaration. Evaluate identity outside `#expect` so the macro does not capture it.
+  let sharedApplication: UIApplication? = UIApplication.shared
+  return application === sharedApplication
+}
+
+/// Records user-activity callbacks delivered through the app-delegate subscriber compatibility
+/// layer. Subscribers cannot be unregistered, so tests use unique activity types and retain these
+/// instances for the remainder of the test process.
+private final class UserActivityRecordingSubscriber: NSObject, ExpoAppDelegateSubscriberProtocol {
+  struct Preparation {
+    let application: UIApplication?
+    let activityType: String
+  }
+
+  struct ActivityUpdate {
+    let application: UIApplication?
+    let userActivity: NSUserActivity
+  }
+
+  struct Failure {
+    let application: UIApplication?
+    let activityType: String
+    let error: Error
+  }
+
+  let willContinueResult: Bool
+  var preparations: [Preparation] = []
+  var continuations: [NSUserActivity] = []
+  var updates: [ActivityUpdate] = []
+  var failures: [Failure] = []
+
+  init(willContinueResult: Bool = false) {
+    self.willContinueResult = willContinueResult
+  }
+
+  func application(
+    _ application: UIApplication,
+    willContinueUserActivityWithType userActivityType: String
+  ) -> Bool {
+    preparations.append(Preparation(application: application, activityType: userActivityType))
+    return willContinueResult
+  }
+
+  func application(
+    _ application: UIApplication,
+    continue userActivity: NSUserActivity,
+    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
+  ) -> Bool {
+    continuations.append(userActivity)
+    restorationHandler(nil)
+    return false
+  }
+
+  func application(_ application: UIApplication, didUpdate userActivity: NSUserActivity) {
+    updates.append(ActivityUpdate(application: application, userActivity: userActivity))
+  }
+
+  func application(
+    _ application: UIApplication,
+    didFailToContinueUserActivityWithType userActivityType: String,
+    error: Error
+  ) {
+    failures.append(Failure(application: application, activityType: userActivityType, error: error))
+  }
+}
+
+/// App delegate shaped like the SDK ≤ 57 templates, which call `RCTLinkingManager` from their own
+/// overrides. See `packages/expo-updates/e2e/fixtures/custom_init/AppDelegate.swift`.
+private final class LegacyLinkingAppDelegate: ExpoAppDelegate {
+  var openedURLs: [URL] = []
+  var continuedUserActivities: [NSUserActivity] = []
+
+  override func application(
+    _ app: UIApplication,
+    open url: URL,
+    options: [UIApplication.OpenURLOptionsKey: Any]
+  ) -> Bool {
+    openedURLs.append(url)
+    let handled = super.application(app, open: url, options: options)
+    RCTLinkingManager.application(app, open: url, options: options)
+    return handled
+  }
+
+  override func application(
+    _ application: UIApplication,
+    continue userActivity: NSUserActivity,
+    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
+  ) -> Bool {
+    continuedUserActivities.append(userActivity)
+    let handled = super.application(application, continue: userActivity, restorationHandler: restorationHandler)
+    RCTLinkingManager.application(application, continue: userActivity, restorationHandler: restorationHandler)
+    return handled
+  }
+}
+
+/// Lets the main-queue blocks scheduled so far run, so a late duplicate reply is recorded before
+/// the assertions.
+@MainActor
+private func drainMainQueue() async {
+  await withCheckedContinuation { continuation in
+    DispatchQueue.main.async { continuation.resume() }
+  }
+}
+
+/// Records the URLs a module subscriber receives. Registration is permanent for the process, so it
+/// reports not having handled the URL to leave the other delegates' behavior untouched.
+private final class URLRecordingSubscriber: NSObject, ExpoAppDelegateSubscriberProtocol {
+  private var urls: [URL] = []
+
+  func application(
+    _ app: UIApplication,
+    open url: URL,
+    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
+  ) -> Bool {
+    urls.append(url)
+    return false
+  }
+
+  func count(of url: URL) -> Int {
+    return urls.filter { $0 == url }.count
+  }
+}
+
+private final class FactoryProvidingAppDelegate: ExpoAppDelegate, ExpoReactNativeFactoryProvider {
+  var window: UIWindow?
+  var reactNativeFactory: RCTReactNativeFactory?
+}
+
+/// Records the events an `ExpoAppDelegate` subclass receives, then forwards them to `super` the way
+/// an app's own `AppDelegate` override would.
+private final class SpyAppDelegate: ExpoAppDelegate {
+  struct OpenedURL {
+    let url: URL
+    let options: [UIApplication.OpenURLOptionsKey: Any]
+  }
+
+  struct Preparation {
+    let application: UIApplication?
+    let activityType: String
+  }
+
+  struct ActivityUpdate {
+    let application: UIApplication?
+    let userActivity: NSUserActivity
+  }
+
+  struct UserActivityFailure {
+    let application: UIApplication?
+    let activityType: String
+    let error: Error
+  }
+
+  var openedURLs: [OpenedURL] = []
+  var continuedUserActivities: [NSUserActivity] = []
+  var preparations: [Preparation] = []
+  var updatedUserActivities: [ActivityUpdate] = []
+  var userActivityFailures: [UserActivityFailure] = []
+  var lifeCycleEvents: [String] = []
+  var shortcutItemTypes: [String] = []
+
+  override func application(
+    _ app: UIApplication,
+    open url: URL,
+    options: [UIApplication.OpenURLOptionsKey: Any]
+  ) -> Bool {
+    openedURLs.append(OpenedURL(url: url, options: options))
+    return super.application(app, open: url, options: options)
+  }
+
+  override func application(
+    _ application: UIApplication,
+    willContinueUserActivityWithType userActivityType: String
+  ) -> Bool {
+    preparations.append(Preparation(application: application, activityType: userActivityType))
+    return super.application(application, willContinueUserActivityWithType: userActivityType)
+  }
+
+  override func application(
+    _ application: UIApplication,
+    continue userActivity: NSUserActivity,
+    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
+  ) -> Bool {
+    continuedUserActivities.append(userActivity)
+    return super.application(application, continue: userActivity, restorationHandler: restorationHandler)
+  }
+
+  override func application(_ application: UIApplication, didUpdate userActivity: NSUserActivity) {
+    updatedUserActivities.append(ActivityUpdate(application: application, userActivity: userActivity))
+    super.application(application, didUpdate: userActivity)
+  }
+
+  override func application(
+    _ application: UIApplication,
+    didFailToContinueUserActivityWithType userActivityType: String,
+    error: Error
+  ) {
+    userActivityFailures.append(
+      UserActivityFailure(application: application, activityType: userActivityType, error: error)
+    )
+    super.application(
+      application,
+      didFailToContinueUserActivityWithType: userActivityType,
+      error: error
+    )
+  }
+
+  override func applicationDidBecomeActive(_ application: UIApplication) {
+    lifeCycleEvents.append("applicationDidBecomeActive")
+    super.applicationDidBecomeActive(application)
+  }
+
+  override func applicationWillResignActive(_ application: UIApplication) {
+    lifeCycleEvents.append("applicationWillResignActive")
+    super.applicationWillResignActive(application)
+  }
+
+  override func applicationWillEnterForeground(_ application: UIApplication) {
+    lifeCycleEvents.append("applicationWillEnterForeground")
+    super.applicationWillEnterForeground(application)
+  }
+
+  override func applicationDidEnterBackground(_ application: UIApplication) {
+    lifeCycleEvents.append("applicationDidEnterBackground")
+    super.applicationDidEnterBackground(application)
+  }
+
+#if os(iOS)
+  override func application(
+    _ application: UIApplication,
+    performActionFor shortcutItem: UIApplicationShortcutItem,
+    completionHandler: @escaping (Bool) -> Void
+  ) {
+    shortcutItemTypes.append(shortcutItem.type)
+    super.application(application, performActionFor: shortcutItem, completionHandler: completionHandler)
+  }
+#endif
+}
+
+/// Counts the notifications `RCTLinkingManager` posts for handled URLs. React Native keeps the
+/// notification name private to its implementation file, so it's spelled out here.
+private final class OpenURLNotificationRecorder: NSObject {
+  private var urls: [String] = []
+
+  override init() {
+    super.init()
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(record(_:)),
+      name: Notification.Name("RCTOpenURLNotification"),
+      object: nil
+    )
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  func count(of url: URL) -> Int {
+    return urls.filter { $0 == url.absoluteString }.count
+  }
+
+  @objc
+  private func record(_ notification: Notification) {
+    if let url = notification.userInfo?["url"] as? String {
+      urls.append(url)
+    }
+  }
+}
+
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo",
-  "version": "57.0.22",
+  "version": "57.0.23",
   "description": "The Expo SDK",
   "main": "src/Expo.ts",
   "module": "src/Expo.ts",
@@ -68,7 +68,7 @@
   "homepage": "https://github.com/expo/expo/tree/main/packages/expo",
   "dependencies": {
     "@babel/runtime": "^7.20.0",
-    "@expo/cli": "^57.0.24",
+    "@expo/cli": "^57.0.25",
     "@expo/config": "~57.0.9",
     "@expo/config-plugins": "~57.0.9",
     "@expo/devtools": "~57.0.1",
@@ -79,7 +79,7 @@
     "@expo/metro": "~56.0.2",
     "@expo/metro-config": "~57.0.12",
     "@ungap/structured-clone": "^1.3.0",
-    "babel-preset-expo": "~57.0.11",
+    "babel-preset-expo": "~57.0.12",
     "expo-asset": "~57.0.17",
     "expo-constants": "~57.0.18",
     "expo-file-system": "~57.0.7",
@@ -139,7 +139,7 @@
       "scripts/resolveAppEntry.js"
     ]
   },
-  "gitHead": "9e5319c0f821a27b7924841903abae50e2b41790",
+  "gitHead": "f6f5af06b95cb7d511b52641885b2fb5adad525d",
   "scripts": {
     "build": "tsc",
     "clean": "rimraf build",