expo 54.0.0-canary-20250630-547cd82 → 54.0.0-canary-20250709-136b77f

package/android/build.gradle

@@ -32,7 +32,7 @@ buildscript {
 def reactNativeVersion = project.extensions.getByType(ExpoModuleExtension).reactNativeVersion
 
 group = 'host.exp.exponent'
-version = '54.0.0-canary-20250630-547cd82'
+version = '54.0.0-canary-20250709-136b77f'
 
 expoModule {
   // We can't prebuild the module because it depends on the generated files.
@@ -43,7 +43,7 @@ android {
   namespace "expo.core"
   defaultConfig {
     versionCode 1
-    versionName "54.0.0-canary-20250630-547cd82"
+    versionName "54.0.0-canary-20250709-136b77f"
     consumerProguardFiles("proguard-rules.pro")
   }
   testOptions {
@@ -77,6 +77,8 @@ dependencies { dependencyHandler ->
   testImplementation 'androidx.test:core:1.5.0'
   testImplementation "com.google.truth:truth:1.1.2"
   testImplementation 'io.mockk:mockk:1.13.5'
+  testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2'
+  testImplementation 'org.robolectric:robolectric:4.15.1'
 
   if (useLegacyAutolinking) {
     // Link expo modules as dependencies of the adapter. It uses `api` configuration so they all will be visible for the app as well.

package/android/src/main/java/expo/modules/ReactActivityDelegateWrapper.kt

@@ -1,13 +1,20 @@
 package expo.modules
 
+import android.annotation.SuppressLint
 import android.app.Activity
 import android.content.Context
 import android.content.Intent
+import android.content.pm.ActivityInfo
 import android.content.res.Configuration
+import android.os.Build
+import android.os.Build.VERSION
 import android.os.Bundle
+import android.util.Log
 import android.view.KeyEvent
 import android.view.ViewGroup
+import androidx.annotation.VisibleForTesting
 import androidx.collection.ArrayMap
+import androidx.lifecycle.lifecycleScope
 import com.facebook.react.ReactActivity
 import com.facebook.react.ReactActivityDelegate
 import com.facebook.react.ReactDelegate
@@ -18,17 +25,27 @@ import com.facebook.react.ReactNativeHost
 import com.facebook.react.ReactRootView
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.modules.core.PermissionListener
+import expo.modules.core.interfaces.ReactActivityHandler.DelayLoadAppHandler
 import expo.modules.core.interfaces.ReactActivityLifecycleListener
 import expo.modules.kotlin.Utils
 import expo.modules.rncompatibility.ReactNativeFeatureFlags
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import java.lang.reflect.Field
 import java.lang.reflect.Method
 import java.lang.reflect.Modifier
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
 
 class ReactActivityDelegateWrapper(
   private val activity: ReactActivity,
   private val isNewArchitectureEnabled: Boolean,
-  private var delegate: ReactActivityDelegate
+  @get:VisibleForTesting internal var delegate: ReactActivityDelegate
 ) : ReactActivityDelegate(activity, null) {
   constructor(activity: ReactActivity, delegate: ReactActivityDelegate) :
     this(activity, false, delegate)
@@ -44,12 +61,32 @@ class ReactActivityDelegateWrapper(
   private val _reactHost: ReactHost? by lazy {
     delegate.reactHost
   }
+  private val delayLoadAppHandler: DelayLoadAppHandler? by lazy {
+    reactActivityHandlers.asSequence()
+      .mapNotNull { it.getDelayLoadAppHandler(activity, reactNativeHost) }
+      .firstOrNull()
+  }
+
+  /**
+   * A deferred that indicates when the app loading is ready
+   */
+  private val loadAppReady = CompletableDeferred<Unit>()
 
   /**
-   * When the app delay for `loadApp`, the ReactInstanceManager's lifecycle will be disrupted.
-   * This flag indicates we should emit `onResume` after `loadApp`.
+   * A mutex to ensure all coroutines in a scope are running in atomic way.
+   *
+   * This is to act like [Activity] lifecycle,
+   * e.g. all work in [onResume] should be executed after all work in [onCreate] finished.
    */
-  private var shouldEmitPendingResume = false
+  private val mutex = Mutex()
+
+  /**
+   * A [CoroutineScope] that binds its lifecycle as [ReactActivityDelegateWrapper].
+   * This is used for [onDestroy] because we need a longer lifecycle scope to call [onDestroy]
+   */
+  private val applicationCoroutineScope: CoroutineScope by lazy {
+    CoroutineScope(Dispatchers.Main)
+  }
 
   //region ReactActivityDelegate
 
@@ -82,53 +119,12 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun loadApp(appKey: String?) {
-    // Give modules a chance to wrap the ReactRootView in a container ViewGroup. If some module
-    // wants to do this, we override the functionality of `loadApp` and call `setContentView` with
-    // the new container view instead.
-    val rootViewContainer = reactActivityHandlers.asSequence()
-      .mapNotNull { it.createReactRootViewContainer(activity) }
-      .firstOrNull()
-    if (rootViewContainer != null) {
-      val mReactDelegate = ReactActivityDelegate::class.java.getDeclaredField("mReactDelegate")
-      mReactDelegate.isAccessible = true
-      val reactDelegate = mReactDelegate[delegate] as ReactDelegate
-
-      reactDelegate.loadApp(appKey)
-      val reactRootView = reactDelegate.reactRootView
-      (reactRootView?.parent as? ViewGroup)?.removeView(reactRootView)
-      rootViewContainer.addView(reactRootView, ViewGroup.LayoutParams.MATCH_PARENT)
-      activity.setContentView(rootViewContainer)
-      reactActivityLifecycleListeners.forEach { listener ->
-        listener.onContentChanged(activity)
-      }
-      return
-    }
-
-    val delayLoadAppHandler = reactActivityHandlers.asSequence()
-      .mapNotNull { it.getDelayLoadAppHandler(activity, reactNativeHost) }
-      .firstOrNull()
-    if (delayLoadAppHandler != null) {
-      shouldEmitPendingResume = true
-      delayLoadAppHandler.whenReady {
-        Utils.assertMainThread()
-        invokeDelegateMethod<Unit, String?>("loadApp", arrayOf(String::class.java), arrayOf(appKey))
-        reactActivityLifecycleListeners.forEach { listener ->
-          listener.onContentChanged(activity)
-        }
-        if (shouldEmitPendingResume) {
-          shouldEmitPendingResume = false
-          onResume()
-        }
-      }
-      return
-    }
-
-    invokeDelegateMethod<Unit, String?>("loadApp", arrayOf(String::class.java), arrayOf(appKey))
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onContentChanged(activity)
+    launchLifecycleScopeWithLock(start = CoroutineStart.UNDISPATCHED) {
+      loadAppImpl(appKey, supportsDelayLoad = true)
     }
   }
 
+  @SuppressLint("DiscouragedPrivateApi")
   override fun onCreate(savedInstanceState: Bundle?) {
     // Give handlers a chance as early as possible to replace the wrapped delegate object.
     // If they do, we call the new wrapped delegate's `onCreate` instead of overriding it here.
@@ -144,38 +140,50 @@ class ReactActivityDelegateWrapper(
       mDelegateField.set(activity, newDelegate)
       delegate = newDelegate
 
-      invokeDelegateMethod<Unit, Bundle?>("onCreate", arrayOf(Bundle::class.java), arrayOf(savedInstanceState))
+      delegate.onCreate(savedInstanceState)
     } else {
       // Since we just wrap `ReactActivityDelegate` but not inherit it, in its `onCreate`,
       // the calls to `createRootView()` or `getMainComponentName()` have no chances to be our wrapped methods.
       // Instead we intercept `ReactActivityDelegate.onCreate` and replace the `mReactDelegate` with our version.
       // That's not ideal but works.
-      val launchOptions = composeLaunchOptions()
-      val reactDelegate: ReactDelegate
-      if (ReactNativeFeatureFlags.enableBridgelessArchitecture) {
-        reactDelegate = ReactDelegate(
-          plainActivity,
-          reactHost,
-          mainComponentName,
-          launchOptions
-        )
-      } else {
-        reactDelegate = object : ReactDelegate(
-          plainActivity,
-          reactNativeHost,
-          mainComponentName,
-          launchOptions
-        ) {
-          override fun createRootView(): ReactRootView {
-            return this@ReactActivityDelegateWrapper.createRootView() ?: super.createRootView()
+
+      launchLifecycleScopeWithLock(start = CoroutineStart.UNDISPATCHED) {
+        awaitDelayLoadAppWhenReady(delayLoadAppHandler)
+        loadAppReady.complete(Unit)
+
+        if (VERSION.SDK_INT >= Build.VERSION_CODES.O && isWideColorGamutEnabled) {
+          activity.window.colorMode = ActivityInfo.COLOR_MODE_WIDE_COLOR_GAMUT
+        }
+
+        val launchOptions = composeLaunchOptions()
+        val reactDelegate: ReactDelegate
+        if (ReactNativeFeatureFlags.enableBridgelessArchitecture) {
+          reactDelegate = ReactDelegate(
+            plainActivity,
+            reactHost,
+            mainComponentName,
+            launchOptions
+          )
+        } else {
+          reactDelegate = object : ReactDelegate(
+            plainActivity,
+            reactNativeHost,
+            mainComponentName,
+            launchOptions,
+            isFabricEnabled
+          ) {
+            override fun createRootView(): ReactRootView {
+              return this@ReactActivityDelegateWrapper.createRootView() ?: super.createRootView()
+            }
           }
         }
-      }
-      val mReactDelegate = ReactActivityDelegate::class.java.getDeclaredField("mReactDelegate")
-      mReactDelegate.isAccessible = true
-      mReactDelegate.set(delegate, reactDelegate)
-      if (mainComponentName != null) {
-        loadApp(mainComponentName)
+
+        val mReactDelegate = ReactActivityDelegate::class.java.getDeclaredField("mReactDelegate")
+        mReactDelegate.isAccessible = true
+        mReactDelegate.set(delegate, reactDelegate)
+        if (mainComponentName != null) {
+          loadAppImpl(mainComponentName, supportsDelayLoad = false)
+        }
       }
     }
 
@@ -185,46 +193,71 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onResume() {
-    if (shouldEmitPendingResume) {
-      return
-    }
-    invokeDelegateMethod<Unit>("onResume")
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onResume(activity)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.onResume()
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onResume(activity)
+      }
     }
   }
 
   override fun onPause() {
-    // If app is stopped before the delayed `loadApp`, we should cancel the pending resume
-    // and avoid propagating the pause event because the state was never resumed.
-    if (shouldEmitPendingResume) {
-      shouldEmitPendingResume = false
-      return
-    }
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onPause(activity)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onPause(activity)
+      }
+      if (delayLoadAppHandler != null) {
+        try {
+          // For the delay load case, we may enter a different call flow than react-native.
+          // For example, Activity stopped before delay load finished.
+          // We stop before the ReactActivityDelegate gets a chance to set up.
+          // In this case, we should catch the exceptions.
+          delegate.onPause()
+        } catch (e: Exception) {
+          Log.e(TAG, "Exception occurred during onPause with delayed app loading", e)
+        }
+      } else {
+        delegate.onPause()
+      }
     }
-    return invokeDelegateMethod("onPause")
   }
 
   override fun onUserLeaveHint() {
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onUserLeaveHint(activity)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onUserLeaveHint(activity)
+      }
+      delegate.onUserLeaveHint()
     }
-    return invokeDelegateMethod("onUserLeaveHint")
   }
 
   override fun onDestroy() {
-    // If app is stopped before the delayed `loadApp`, we should cancel the pending resume
-    // and avoid propagating the destroy event because the state was never resumed.
-    if (shouldEmitPendingResume) {
-      shouldEmitPendingResume = false
-      return
-    }
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onDestroy(activity)
+    // Note: use our `coroutineScope` for onDestroy here
+    // because the lifecycleScope destroyed before the executions.
+    applicationCoroutineScope.launch {
+      mutex.withLock {
+        loadAppReady.await()
+        reactActivityLifecycleListeners.forEach { listener ->
+          listener.onDestroy(activity)
+        }
+        if (delayLoadAppHandler != null) {
+          try {
+            // For the delay load case, we may enter a different call flow than react-native.
+            // For example, Activity stopped before delay load finished.
+            // We stop before the ReactActivityDelegate gets a chance to set up.
+            // In this case, we should catch the exceptions.
+            delegate.onDestroy()
+          } catch (e: Exception) {
+            Log.e(TAG, "Exception occurred during onDestroy with delayed app loading", e)
+          }
+        } else {
+          delegate.onDestroy()
+        }
+      }
     }
-    return invokeDelegateMethod("onDestroy")
   }
 
   override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
@@ -241,20 +274,28 @@ class ReactActivityDelegateWrapper(
      *
      * TODO (@bbarthec): fix it upstream?
      */
-    if (!ReactNativeFeatureFlags.enableBridgelessArchitecture && delegate.reactInstanceManager.currentReactContext == null) {
-      val reactContextListener = object : ReactInstanceEventListener {
-        override fun onReactContextInitialized(context: ReactContext) {
-          delegate.reactInstanceManager.removeReactInstanceEventListener(this)
-          delegate.onActivityResult(requestCode, resultCode, data)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      if (!ReactNativeFeatureFlags.enableBridgelessArchitecture && delegate.reactInstanceManager.currentReactContext == null) {
+        val reactContextListener = object : ReactInstanceEventListener {
+          override fun onReactContextInitialized(context: ReactContext) {
+            delegate.reactInstanceManager.removeReactInstanceEventListener(this)
+            delegate.onActivityResult(requestCode, resultCode, data)
+          }
         }
+        return@launchLifecycleScopeWithLock delegate.reactInstanceManager.addReactInstanceEventListener(
+          reactContextListener
+        )
       }
-      return delegate.reactInstanceManager.addReactInstanceEventListener(reactContextListener)
-    }
 
-    delegate.onActivityResult(requestCode, resultCode, data)
+      delegate.onActivityResult(requestCode, resultCode, data)
+    }
   }
 
   override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     // if any of the handlers return true, intentionally consume the event instead of passing it
     // through to the delegate
     return reactActivityHandlers
@@ -263,6 +304,9 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     // if any of the handlers return true, intentionally consume the event instead of passing it
     // through to the delegate
     return reactActivityHandlers
@@ -271,6 +315,9 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onKeyLongPress(keyCode: Int, event: KeyEvent?): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     // if any of the handlers return true, intentionally consume the event instead of passing it
     // through to the delegate
     return reactActivityHandlers
@@ -279,6 +326,9 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onBackPressed(): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     val listenerResult = reactActivityLifecycleListeners
       .map(ReactActivityLifecycleListener::onBackPressed)
       .fold(false) { accu, current -> accu || current }
@@ -287,6 +337,9 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onNewIntent(intent: Intent?): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     val listenerResult = reactActivityLifecycleListeners
       .map { it.onNewIntent(intent) }
       .fold(false) { accu, current -> accu || current }
@@ -295,15 +348,24 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onWindowFocusChanged(hasFocus: Boolean) {
-    delegate.onWindowFocusChanged(hasFocus)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.onWindowFocusChanged(hasFocus)
+    }
   }
 
   override fun requestPermissions(permissions: Array<out String>?, requestCode: Int, listener: PermissionListener?) {
-    delegate.requestPermissions(permissions, requestCode, listener)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.requestPermissions(permissions, requestCode, listener)
+    }
   }
 
   override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>?, grantResults: IntArray?) {
-    delegate.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    }
   }
 
   override fun getContext(): Context {
@@ -318,12 +380,19 @@ class ReactActivityDelegateWrapper(
     return invokeDelegateMethod("isFabricEnabled")
   }
 
+  override fun isWideColorGamutEnabled(): Boolean {
+    return invokeDelegateMethod("isWideColorGamutEnabled")
+  }
+
   override fun composeLaunchOptions(): Bundle? {
     return invokeDelegateMethod("composeLaunchOptions")
   }
 
   override fun onConfigurationChanged(newConfig: Configuration?) {
-    delegate.onConfigurationChanged(newConfig)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.onConfigurationChanged(newConfig)
+    }
   }
 
   //endregion
@@ -341,8 +410,9 @@ class ReactActivityDelegateWrapper(
     return method!!.invoke(delegate) as T
   }
 
+  @VisibleForTesting
   @Suppress("UNCHECKED_CAST")
-  private fun <T, A> invokeDelegateMethod(
+  internal fun <T, A> invokeDelegateMethod(
     name: String,
     argTypes: Array<Class<*>>,
     args: Array<A>
@@ -356,5 +426,79 @@ class ReactActivityDelegateWrapper(
     return method!!.invoke(delegate, *args) as T
   }
 
+  private suspend fun loadAppImpl(appKey: String?, supportsDelayLoad: Boolean) {
+    // Give modules a chance to wrap the ReactRootView in a container ViewGroup. If some module
+    // wants to do this, we override the functionality of `loadApp` and call `setContentView` with
+    // the new container view instead.
+    val rootViewContainer = reactActivityHandlers.asSequence()
+      .mapNotNull { it.createReactRootViewContainer(activity) }
+      .firstOrNull()
+    if (rootViewContainer != null) {
+      val mReactDelegate = ReactActivityDelegate::class.java.getDeclaredField("mReactDelegate")
+      mReactDelegate.isAccessible = true
+      val reactDelegate = mReactDelegate[delegate] as ReactDelegate
+
+      reactDelegate.loadApp(appKey)
+      val reactRootView = reactDelegate.reactRootView
+      (reactRootView?.parent as? ViewGroup)?.removeView(reactRootView)
+      rootViewContainer.addView(reactRootView, ViewGroup.LayoutParams.MATCH_PARENT)
+      activity.setContentView(rootViewContainer)
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onContentChanged(activity)
+      }
+      return
+    }
+
+    if (supportsDelayLoad) {
+      awaitDelayLoadAppWhenReady(delayLoadAppHandler)
+      invokeDelegateMethod<Unit, String?>("loadApp", arrayOf(String::class.java), arrayOf(appKey))
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onContentChanged(activity)
+      }
+      return
+    }
+
+    invokeDelegateMethod<Unit, String?>("loadApp", arrayOf(String::class.java), arrayOf(appKey))
+    reactActivityLifecycleListeners.forEach { listener ->
+      listener.onContentChanged(activity)
+    }
+  }
+
+  private suspend fun awaitDelayLoadAppWhenReady(delayLoadAppHandler: DelayLoadAppHandler?) {
+    if (delayLoadAppHandler == null) {
+      return
+    }
+    suspendCoroutine { continuation ->
+      delayLoadAppHandler.whenReady {
+        Utils.assertMainThread()
+        continuation.resume(Unit)
+      }
+    }
+  }
+
+  private fun launchLifecycleScopeWithLock(
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    block: suspend CoroutineScope.() -> Unit
+  ) {
+    activity.lifecycleScope.launch(start = start) {
+      mutex.withLock {
+        block()
+      }
+    }
+  }
+
+  /**
+   * Set the [loadAppReady] to completed state.
+   * This is only for unit tests when a test setups mocks and skips the [Activity] lifecycle.
+   */
+  @VisibleForTesting
+  internal fun setLoadAppReadyForTesting() {
+    loadAppReady.complete(Unit)
+  }
+
   //endregion
+
+  companion object {
+    private val TAG = ReactActivityDelegate::class.simpleName
+  }
 }

package/android/src/test/java/expo/modules/ReactActivityDelegateWrapperDelayLoadTest.kt

@@ -0,0 +1,282 @@
+package expo.modules
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactRootView
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+import com.facebook.react.interfaces.fabric.ReactSurface
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.soloader.SoLoader
+import expo.modules.core.interfaces.Package
+import expo.modules.core.interfaces.ReactActivityHandler
+import expo.modules.core.interfaces.ReactActivityHandler.DelayLoadAppHandler
+import expo.modules.core.interfaces.ReactActivityLifecycleListener
+import io.mockk.MockKAnnotations
+import io.mockk.every
+import io.mockk.impl.annotations.RelaxedMockK
+import io.mockk.mockk
+import io.mockk.mockkObject
+import io.mockk.mockkStatic
+import io.mockk.slot
+import io.mockk.spyk
+import io.mockk.unmockkAll
+import io.mockk.verify
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.android.controller.ActivityController
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(application = MockApplication::class)
+internal class ReactActivityDelegateWrapperDelayLoadTest {
+  @RelaxedMockK
+  private lateinit var delayLoadAppHandler: DelayLoadAppHandler
+
+  private lateinit var mockPackageWithDelay: MockPackageWithDelayHandler
+  private lateinit var mockPackageWithoutDelay: MockPackageWithoutDelayHandler
+  private lateinit var activityController: ActivityController<MockActivity>
+  private val activity: MockActivity
+    get() = activityController.get()
+
+  @OptIn(ExperimentalCoroutinesApi::class)
+  @Before
+  fun setUp() {
+    SoLoader.setInTestMode()
+    mockkObject(ExpoModulesPackage.Companion)
+    mockkStatic(ReactNativeFeatureFlags::class)
+    every { ReactNativeFeatureFlags.enableBridgelessArchitecture() } returns true
+    every { ReactNativeFeatureFlags.enableFabricRenderer() } returns true
+    Dispatchers.setMain(UnconfinedTestDispatcher())
+
+    MockKAnnotations.init(this)
+
+    mockPackageWithDelay = MockPackageWithDelayHandler(delayLoadAppHandler)
+    mockPackageWithoutDelay = MockPackageWithoutDelayHandler()
+  }
+
+  @After
+  fun tearDown() {
+    unmockkAll()
+  }
+
+  @Test
+  fun `should proceed loadApp immediately when no delayLoadAppHandler`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithoutDelay)
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    verify { spyDelegateWrapper.invokeDelegateMethod("loadApp", arrayOf(String::class.java), arrayOf("main")) }
+  }
+
+  @Test
+  fun `should block loadApp until delayLoadAppHandler finished`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithDelay)
+
+    val callbackSlot = slot<Runnable>()
+    every { delayLoadAppHandler.whenReady(capture(callbackSlot)) } answers {
+      // Don't call the callback immediately to simulate delay
+    }
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+
+    verify(exactly = 0) { spyDelegateWrapper.invokeDelegateMethod("loadApp", arrayOf(String::class.java), arrayOf("main")) }
+    callbackSlot.captured.run()
+    verify(exactly = 1) { spyDelegateWrapper.invokeDelegateMethod("loadApp", arrayOf(String::class.java), arrayOf("main")) }
+  }
+
+  @Test
+  fun `should call lifecycle methods in correct order with delay load`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithDelay)
+
+    val callbackSlot = slot<Runnable>()
+    every { delayLoadAppHandler.whenReady(capture(callbackSlot)) } answers {
+      // Don't call the callback immediately to simulate delay
+    }
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    val spyDelegate = spyDelegateWrapper.delegate
+
+    verify(exactly = 1) { spyDelegateWrapper.onCreate(any()) }
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
+    verify(exactly = 0) { spyDelegate.onResume() }
+
+    callbackSlot.captured.run()
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
+    verify(exactly = 1) { spyDelegate.onResume() }
+    verify(exactly = 0) { spyDelegateWrapper.onPause() }
+    verify(exactly = 0) { spyDelegateWrapper.onDestroy() }
+    verify(exactly = 0) { spyDelegate.onPause() }
+    verify(exactly = 0) { spyDelegate.onDestroy() }
+
+    activityController.pause().stop().destroy()
+    verify(exactly = 1) { spyDelegateWrapper.onPause() }
+    verify(exactly = 1) { spyDelegateWrapper.onDestroy() }
+    verify(exactly = 1) { spyDelegate.onPause() }
+    verify(exactly = 1) { spyDelegate.onDestroy() }
+  }
+
+  @Test
+  fun `should have normal lifecycle when no delayLoadHandler`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithoutDelay)
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    val spyDelegate = spyDelegateWrapper.delegate
+
+    verify(exactly = 1) { spyDelegateWrapper.onCreate(any()) }
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
+    verify(exactly = 1) { spyDelegate.onResume() }
+
+    activityController.pause().stop().destroy()
+    verify(exactly = 1) { spyDelegateWrapper.onPause() }
+    verify(exactly = 1) { spyDelegateWrapper.onDestroy() }
+    verify(exactly = 1) { spyDelegate.onPause() }
+    verify(exactly = 1) { spyDelegate.onDestroy() }
+  }
+
+  @Test
+  fun `should cancel pending resume if activity destroy before delay load finished`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithDelay)
+
+    val callbackSlot = slot<Runnable>()
+    every { delayLoadAppHandler.whenReady(capture(callbackSlot)) } answers {
+      // Don't call the callback immediately to simulate delay
+    }
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    val spyDelegate = spyDelegateWrapper.delegate
+
+    verify(exactly = 1) { spyDelegateWrapper.onCreate(any()) }
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
+    verify(exactly = 0) { spyDelegate.onResume() }
+
+    activityController.pause().stop().destroy()
+    callbackSlot.captured.run()
+    verify(exactly = 0) { spyDelegate.onResume() }
+  }
+}
+
+internal class MockPackageWithDelayHandler(delayHandler: DelayLoadAppHandler) : Package {
+  private val reactActivityLifecycleListener = mockk<ReactActivityLifecycleListener>(relaxed = true)
+  private val reactActivityHandler = mockk<ReactActivityHandler>(relaxed = true)
+
+  init {
+    every { reactActivityHandler.createReactRootViewContainer(any()) } returns null
+    every { reactActivityHandler.onDidCreateReactActivityDelegate(any(), any()) } returns null
+    every { reactActivityHandler.getDelayLoadAppHandler(any(), any()) } returns delayHandler
+  }
+
+  override fun createReactActivityLifecycleListeners(activityContext: Context?): List<ReactActivityLifecycleListener> {
+    return listOf(reactActivityLifecycleListener)
+  }
+
+  override fun createReactActivityHandlers(activityContext: Context?): List<ReactActivityHandler> {
+    return listOf(reactActivityHandler)
+  }
+}
+
+internal class MockPackageWithoutDelayHandler : Package {
+  private val reactActivityLifecycleListener = mockk<ReactActivityLifecycleListener>(relaxed = true)
+  private val reactActivityHandler = mockk<ReactActivityHandler>(relaxed = true)
+
+  init {
+    every { reactActivityHandler.createReactRootViewContainer(any()) } returns null
+    every { reactActivityHandler.onDidCreateReactActivityDelegate(any(), any()) } returns null
+    every { reactActivityHandler.getDelayLoadAppHandler(any(), any()) } returns null
+  }
+
+  override fun createReactActivityLifecycleListeners(activityContext: Context?): List<ReactActivityLifecycleListener> {
+    return listOf(reactActivityLifecycleListener)
+  }
+
+  override fun createReactActivityHandlers(activityContext: Context?): List<ReactActivityHandler> {
+    return listOf(reactActivityHandler)
+  }
+}
+
+internal class MockApplication : Application(), ReactApplication {
+  private var currentActivity: Activity? = null
+
+  override fun onCreate() {
+    super.onCreate()
+    setTheme(androidx.appcompat.R.style.Theme_AppCompat)
+  }
+
+  internal fun bindCurrentActivity(activity: Activity?) {
+    currentActivity = activity
+  }
+
+  override val reactNativeHost: ReactNativeHost = mockk<ReactNativeHost>(relaxed = true)
+
+  override val reactHost: ReactHost by lazy {
+    mockk<ReactHost>(relaxed = true)
+      .also {
+        val mockReactSurface = mockk<ReactSurface>(relaxed = true)
+        every { mockReactSurface.view } returns ReactRootView(currentActivity)
+        every { it.createSurface(any(), any(), any()) } returns mockReactSurface
+      }
+  }
+}
+
+internal class MockActivity : ReactActivity() {
+  override fun getMainComponentName(): String = "main"
+
+  override fun createReactActivityDelegate(): ReactActivityDelegate = spyk(
+    ReactActivityDelegateWrapper(
+      this,
+      BuildConfig.IS_NEW_ARCHITECTURE_ENABLED,
+      spyk(
+        object : DefaultReactActivityDelegate(
+          this,
+          mainComponentName,
+          fabricEnabled
+        ) {}
+      )
+    )
+  )
+}

package/android/src/test/java/expo/modules/ReactActivityDelegateWrapperTest.kt

@@ -20,9 +20,9 @@ import org.junit.Before
 import org.junit.Test
 
 internal class ReactActivityDelegateWrapperTest {
-  lateinit var mockPackage0: MockPackage
+  private lateinit var mockPackage0: MockPackage
 
-  lateinit var mockPackage1: MockPackage
+  private lateinit var mockPackage1: MockPackage
 
   @RelaxedMockK
   lateinit var activity: ReactActivity
@@ -47,6 +47,7 @@ internal class ReactActivityDelegateWrapperTest {
   @Test
   fun `onBackPressed should call each handler's callback just once`() {
     val delegateWrapper = ReactActivityDelegateWrapper(activity, delegate)
+    delegateWrapper.setLoadAppReadyForTesting()
     every { mockPackage0.reactActivityLifecycleListener.onBackPressed() } returns true
 
     delegateWrapper.onBackPressed()
@@ -59,6 +60,7 @@ internal class ReactActivityDelegateWrapperTest {
   @Test
   fun `onBackPressed should return true if someone returns true`() {
     val delegateWrapper = ReactActivityDelegateWrapper(activity, delegate)
+    delegateWrapper.setLoadAppReadyForTesting()
     every { mockPackage0.reactActivityLifecycleListener.onBackPressed() } returns false
     every { mockPackage1.reactActivityLifecycleListener.onBackPressed() } returns true
     every { delegate.onBackPressed() } returns false
@@ -71,6 +73,7 @@ internal class ReactActivityDelegateWrapperTest {
   fun `onNewIntent should call each handler's callback just once`() {
     val intent = mockk<Intent>()
     val delegateWrapper = ReactActivityDelegateWrapper(activity, delegate)
+    delegateWrapper.setLoadAppReadyForTesting()
     every { mockPackage0.reactActivityLifecycleListener.onNewIntent(intent) } returns false
     every { mockPackage1.reactActivityLifecycleListener.onNewIntent(intent) } returns true
     every { delegate.onNewIntent(intent) } returns false
@@ -86,6 +89,7 @@ internal class ReactActivityDelegateWrapperTest {
   fun `onNewIntent should return true if someone returns true`() {
     val intent = mockk<Intent>()
     val delegateWrapper = ReactActivityDelegateWrapper(activity, delegate)
+    delegateWrapper.setLoadAppReadyForTesting()
     every { mockPackage0.reactActivityLifecycleListener.onNewIntent(intent) } returns false
     every { mockPackage1.reactActivityLifecycleListener.onNewIntent(intent) } returns true
     every { delegate.onNewIntent(intent) } returns false
@@ -97,7 +101,7 @@ internal class ReactActivityDelegateWrapperTest {
 
 internal class MockPackage : Package {
   val reactActivityLifecycleListener = mockk<ReactActivityLifecycleListener>(relaxed = true)
-  val reactActivityHandler = mockk<ReactActivityHandler>(relaxed = true)
+  private val reactActivityHandler = mockk<ReactActivityHandler>(relaxed = true)
 
   override fun createReactActivityLifecycleListeners(activityContext: Context?): List<ReactActivityLifecycleListener> {
     return listOf(reactActivityLifecycleListener)

package/bundledNativeModules.json

@@ -1,8 +1,8 @@
 {
-  "@expo/fingerprint": "0.13.2-canary-20250630-547cd82",
-  "@expo/metro-runtime": "6.0.0-canary-20250630-547cd82",
+  "@expo/fingerprint": "0.13.5-canary-20250709-136b77f",
+  "@expo/metro-runtime": "6.0.0-canary-20250709-136b77f",
   "@expo/vector-icons": "^14.1.0",
-  "@expo/ui": "0.1.1-canary-20250630-547cd82",
+  "@expo/ui": "0.1.1-canary-20250709-136b77f",
   "@react-native-async-storage/async-storage": "2.2.0",
   "@react-native-community/datetimepicker": "8.4.1",
   "@react-native-masked-view/masked-view": "0.3.2",
@@ -12,86 +12,86 @@
   "@react-native-picker/picker": "2.11.1",
   "@react-native-segmented-control/segmented-control": "2.5.7",
   "@stripe/stripe-react-native": "0.45.0",
-  "eslint-config-expo": "9.2.1-canary-20250630-547cd82",
+  "eslint-config-expo": "9.2.1-canary-20250709-136b77f",
   "expo-analytics-amplitude": "~11.3.0",
   "expo-app-auth": "~11.1.0",
   "expo-app-loader-provider": "~8.0.0",
-  "expo-apple-authentication": "7.2.5-canary-20250630-547cd82",
-  "expo-application": "6.1.5-canary-20250630-547cd82",
-  "expo-asset": "11.2.0-canary-20250630-547cd82",
-  "expo-audio": "0.4.8-canary-20250630-547cd82",
-  "expo-auth-session": "6.1.6-canary-20250630-547cd82",
-  "expo-av": "15.1.7-canary-20250630-547cd82",
-  "expo-background-fetch": "13.1.6-canary-20250630-547cd82",
-  "expo-background-task": "0.2.8-canary-20250630-547cd82",
-  "expo-battery": "9.1.5-canary-20250630-547cd82",
-  "expo-blur": "14.1.6-canary-20250630-547cd82",
-  "expo-brightness": "13.1.5-canary-20250630-547cd82",
-  "expo-build-properties": "0.14.7-canary-20250630-547cd82",
-  "expo-calendar": "14.1.5-canary-20250630-547cd82",
-  "expo-camera": "16.1.10-canary-20250630-547cd82",
-  "expo-cellular": "7.1.5-canary-20250630-547cd82",
-  "expo-checkbox": "4.1.5-canary-20250630-547cd82",
-  "expo-clipboard": "7.1.5-canary-20250630-547cd82",
-  "expo-constants": "17.1.7-canary-20250630-547cd82",
-  "expo-contacts": "14.2.6-canary-20250630-547cd82",
-  "expo-crypto": "14.1.6-canary-20250630-547cd82",
-  "expo-dev-client": "5.1.9-canary-20250630-547cd82",
-  "expo-device": "7.1.5-canary-20250630-547cd82",
-  "expo-document-picker": "14.0.0-canary-20250630-547cd82",
-  "expo-file-system": "18.2.0-canary-20250630-547cd82",
-  "expo-font": "13.3.2-canary-20250630-547cd82",
-  "expo-gl": "15.1.7-canary-20250630-547cd82",
+  "expo-apple-authentication": "7.2.5-canary-20250709-136b77f",
+  "expo-application": "6.1.6-canary-20250709-136b77f",
+  "expo-asset": "11.2.0-canary-20250709-136b77f",
+  "expo-audio": "0.4.9-canary-20250709-136b77f",
+  "expo-auth-session": "6.1.6-canary-20250709-136b77f",
+  "expo-av": "15.1.8-canary-20250709-136b77f",
+  "expo-background-fetch": "13.1.7-canary-20250709-136b77f",
+  "expo-background-task": "0.2.9-canary-20250709-136b77f",
+  "expo-battery": "9.1.5-canary-20250709-136b77f",
+  "expo-blur": "14.1.6-canary-20250709-136b77f",
+  "expo-brightness": "13.1.5-canary-20250709-136b77f",
+  "expo-build-properties": "0.15.0-canary-20250709-136b77f",
+  "expo-calendar": "14.1.5-canary-20250709-136b77f",
+  "expo-camera": "16.1.11-canary-20250709-136b77f",
+  "expo-cellular": "7.1.6-canary-20250709-136b77f",
+  "expo-checkbox": "4.1.5-canary-20250709-136b77f",
+  "expo-clipboard": "7.1.6-canary-20250709-136b77f",
+  "expo-constants": "17.1.8-canary-20250709-136b77f",
+  "expo-contacts": "14.2.6-canary-20250709-136b77f",
+  "expo-crypto": "14.1.6-canary-20250709-136b77f",
+  "expo-dev-client": "5.1.9-canary-20250709-136b77f",
+  "expo-device": "7.1.5-canary-20250709-136b77f",
+  "expo-document-picker": "14.0.0-canary-20250709-136b77f",
+  "expo-file-system": "18.2.0-canary-20250709-136b77f",
+  "expo-font": "13.4.0-canary-20250709-136b77f",
+  "expo-gl": "15.1.8-canary-20250709-136b77f",
   "expo-google-app-auth": "~8.3.0",
-  "expo-haptics": "14.1.5-canary-20250630-547cd82",
-  "expo-image": "2.3.1-canary-20250630-547cd82",
-  "expo-image-loader": "5.1.1-canary-20250630-547cd82",
-  "expo-image-manipulator": "13.1.8-canary-20250630-547cd82",
-  "expo-image-picker": "17.0.0-canary-20250630-547cd82",
-  "expo-intent-launcher": "12.1.6-canary-20250630-547cd82",
-  "expo-insights": "0.9.4-canary-20250630-547cd82",
-  "expo-keep-awake": "14.1.5-canary-20250630-547cd82",
-  "expo-linear-gradient": "14.1.6-canary-20250630-547cd82",
-  "expo-linking": "7.1.6-canary-20250630-547cd82",
-  "expo-local-authentication": "16.1.0-canary-20250630-547cd82",
-  "expo-localization": "16.1.6-canary-20250630-547cd82",
-  "expo-location": "18.1.6-canary-20250630-547cd82",
-  "expo-mail-composer": "14.1.6-canary-20250630-547cd82",
-  "expo-manifests": "0.16.6-canary-20250630-547cd82",
-  "expo-maps": "0.10.1-canary-20250630-547cd82",
-  "expo-media-library": "17.1.8-canary-20250630-547cd82",
-  "expo-mesh-gradient": "0.4.0-canary-20250630-547cd82",
-  "expo-module-template": "10.16.7-canary-20250630-547cd82",
-  "expo-modules-core": "2.5.0-canary-20250630-547cd82",
-  "expo-navigation-bar": "4.2.7-canary-20250630-547cd82",
-  "expo-network": "7.1.6-canary-20250630-547cd82",
-  "expo-notifications": "0.31.4-canary-20250630-547cd82",
-  "expo-print": "14.1.5-canary-20250630-547cd82",
-  "expo-live-photo": "0.1.5-canary-20250630-547cd82",
-  "expo-router": "5.2.0-canary-20250630-547cd82",
-  "expo-screen-capture": "7.2.0-canary-20250630-547cd82",
-  "expo-screen-orientation": "8.1.8-canary-20250630-547cd82",
-  "expo-secure-store": "14.2.4-canary-20250630-547cd82",
-  "expo-sensors": "14.1.5-canary-20250630-547cd82",
-  "expo-sharing": "13.1.6-canary-20250630-547cd82",
-  "expo-sms": "13.1.5-canary-20250630-547cd82",
-  "expo-speech": "13.2.0-canary-20250630-547cd82",
-  "expo-splash-screen": "0.30.10-canary-20250630-547cd82",
-  "expo-sqlite": "15.2.13-canary-20250630-547cd82",
-  "expo-status-bar": "2.2.4-canary-20250630-547cd82",
-  "expo-store-review": "8.1.6-canary-20250630-547cd82",
-  "expo-symbols": "0.4.6-canary-20250630-547cd82",
-  "expo-system-ui": "5.0.10-canary-20250630-547cd82",
-  "expo-task-manager": "13.1.6-canary-20250630-547cd82",
-  "expo-tracking-transparency": "5.2.5-canary-20250630-547cd82",
-  "expo-updates": "0.28.16-canary-20250630-547cd82",
-  "expo-video-thumbnails": "9.1.4-canary-20250630-547cd82",
-  "expo-video": "2.1.10-canary-20250630-547cd82",
-  "expo-web-browser": "14.1.7-canary-20250630-547cd82",
-  "jest-expo": "54.0.0-canary-20250630-547cd82",
+  "expo-haptics": "14.1.5-canary-20250709-136b77f",
+  "expo-image": "2.4.0-canary-20250709-136b77f",
+  "expo-image-loader": "5.1.1-canary-20250709-136b77f",
+  "expo-image-manipulator": "13.1.8-canary-20250709-136b77f",
+  "expo-image-picker": "17.0.0-canary-20250709-136b77f",
+  "expo-intent-launcher": "12.1.6-canary-20250709-136b77f",
+  "expo-insights": "0.9.4-canary-20250709-136b77f",
+  "expo-keep-awake": "14.1.5-canary-20250709-136b77f",
+  "expo-linear-gradient": "14.1.6-canary-20250709-136b77f",
+  "expo-linking": "7.1.8-canary-20250709-136b77f",
+  "expo-local-authentication": "16.1.0-canary-20250709-136b77f",
+  "expo-localization": "16.1.7-canary-20250709-136b77f",
+  "expo-location": "18.1.7-canary-20250709-136b77f",
+  "expo-mail-composer": "14.1.6-canary-20250709-136b77f",
+  "expo-manifests": "0.17.0-canary-20250709-136b77f",
+  "expo-maps": "0.10.1-canary-20250709-136b77f",
+  "expo-media-library": "17.1.8-canary-20250709-136b77f",
+  "expo-mesh-gradient": "0.4.0-canary-20250709-136b77f",
+  "expo-module-template": "10.16.8-canary-20250709-136b77f",
+  "expo-modules-core": "2.5.0-canary-20250709-136b77f",
+  "expo-navigation-bar": "4.2.8-canary-20250709-136b77f",
+  "expo-network": "7.1.6-canary-20250709-136b77f",
+  "expo-notifications": "0.31.5-canary-20250709-136b77f",
+  "expo-print": "14.1.5-canary-20250709-136b77f",
+  "expo-live-photo": "0.1.5-canary-20250709-136b77f",
+  "expo-router": "5.2.0-canary-20250709-136b77f",
+  "expo-screen-capture": "7.2.0-canary-20250709-136b77f",
+  "expo-screen-orientation": "8.1.8-canary-20250709-136b77f",
+  "expo-secure-store": "14.2.4-canary-20250709-136b77f",
+  "expo-sensors": "14.1.5-canary-20250709-136b77f",
+  "expo-sharing": "13.1.6-canary-20250709-136b77f",
+  "expo-sms": "13.1.5-canary-20250709-136b77f",
+  "expo-speech": "13.2.0-canary-20250709-136b77f",
+  "expo-splash-screen": "0.30.11-canary-20250709-136b77f",
+  "expo-sqlite": "15.2.15-canary-20250709-136b77f",
+  "expo-status-bar": "2.2.4-canary-20250709-136b77f",
+  "expo-store-review": "8.1.6-canary-20250709-136b77f",
+  "expo-symbols": "0.4.6-canary-20250709-136b77f",
+  "expo-system-ui": "5.0.11-canary-20250709-136b77f",
+  "expo-task-manager": "13.1.7-canary-20250709-136b77f",
+  "expo-tracking-transparency": "5.2.5-canary-20250709-136b77f",
+  "expo-updates": "0.29.0-canary-20250709-136b77f",
+  "expo-video-thumbnails": "9.1.4-canary-20250709-136b77f",
+  "expo-video": "2.1.10-canary-20250709-136b77f",
+  "expo-web-browser": "14.1.7-canary-20250709-136b77f",
+  "jest-expo": "54.0.0-canary-20250709-136b77f",
   "react": "19.1.0",
   "react-dom": "19.1.0",
-  "react-native": "0.80.0",
+  "react-native": "0.80.1",
   "react-native-web": "~0.20.0",
   "react-native-edge-to-edge": "1.6.0",
   "react-native-gesture-handler": "~2.26.0",
@@ -105,7 +105,7 @@
   "react-native-view-shot": "4.0.3",
   "react-native-webview": "13.13.5",
   "sentry-expo": "~7.0.0",
-  "unimodules-app-loader": "5.1.4-canary-20250630-547cd82",
+  "unimodules-app-loader": "5.1.4-canary-20250709-136b77f",
   "unimodules-image-loader-interface": "~6.1.0",
   "@shopify/react-native-skia": "v2.0.0-next.4",
   "@shopify/flash-list": "1.8.3",

package/config/paths.d.ts

@@ -0,0 +1 @@
+export * from '@expo/config/paths';

package/config/paths.js

@@ -0,0 +1 @@
+module.exports = require('@expo/config/paths');

package/ios/AppDelegates/ExpoAppDelegate.swift

@@ -9,8 +9,6 @@ import ReactAppDependencyProvider
  by forwarding `UIApplicationDelegate` events to the subscribers.
 
  Keep functions and markers in sync with https://developer.apple.com/documentation/uikit/uiapplicationdelegate
-
- TODO vonovak check macOS support once RN macOS 78 goes out
  */
 @objc(EXExpoAppDelegate)
 open class ExpoAppDelegate: NSObject, ReactNativeFactoryProvider, UIApplicationDelegate {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo",
-  "version": "54.0.0-canary-20250630-547cd82",
+  "version": "54.0.0-canary-20250709-136b77f",
   "description": "The Expo SDK",
   "main": "src/Expo.ts",
   "module": "src/Expo.ts",
@@ -30,8 +30,7 @@
     "metro-config.js",
     "metro-config.d.ts",
     "dom",
-    "config.js",
-    "config.d.ts",
+    "config",
     "config-plugins.js",
     "config-plugins.d.ts",
     "devtools.js",
@@ -74,20 +73,20 @@
   "homepage": "https://github.com/expo/expo/tree/main/packages/expo",
   "dependencies": {
     "@babel/runtime": "^7.20.0",
-    "@expo/cli": "1.0.0-canary-20250630-547cd82",
-    "@expo/config": "11.0.11-canary-20250630-547cd82",
-    "@expo/config-plugins": "10.1.0-canary-20250630-547cd82",
-    "@expo/fingerprint": "0.13.2-canary-20250630-547cd82",
-    "@expo/metro-config": "0.21.0-canary-20250630-547cd82",
+    "@expo/cli": "1.0.0-canary-20250709-136b77f",
+    "@expo/config": "11.0.14-canary-20250709-136b77f",
+    "@expo/config-plugins": "10.0.4-canary-20250709-136b77f",
+    "@expo/fingerprint": "0.13.5-canary-20250709-136b77f",
+    "@expo/metro-config": "0.21.0-canary-20250709-136b77f",
     "@expo/vector-icons": "^14.0.0",
-    "babel-preset-expo": "13.3.0-canary-20250630-547cd82",
-    "expo-asset": "11.2.0-canary-20250630-547cd82",
-    "expo-constants": "17.1.7-canary-20250630-547cd82",
-    "expo-file-system": "18.2.0-canary-20250630-547cd82",
-    "expo-font": "13.3.2-canary-20250630-547cd82",
-    "expo-keep-awake": "14.1.5-canary-20250630-547cd82",
-    "expo-modules-autolinking": "2.1.13-canary-20250630-547cd82",
-    "expo-modules-core": "2.5.0-canary-20250630-547cd82",
+    "babel-preset-expo": "13.3.0-canary-20250709-136b77f",
+    "expo-asset": "11.2.0-canary-20250709-136b77f",
+    "expo-constants": "17.1.8-canary-20250709-136b77f",
+    "expo-file-system": "18.2.0-canary-20250709-136b77f",
+    "expo-font": "13.4.0-canary-20250709-136b77f",
+    "expo-keep-awake": "14.1.5-canary-20250709-136b77f",
+    "expo-modules-autolinking": "2.1.15-canary-20250709-136b77f",
+    "expo-modules-core": "2.5.0-canary-20250709-136b77f",
     "pretty-format": "^29.7.0",
     "react-native-edge-to-edge": "1.6.0",
     "whatwg-url-without-unicode": "8.0.0-3"
@@ -96,16 +95,16 @@
     "@types/node": "^22.14.0",
     "@types/react": "~19.0.10",
     "@types/react-test-renderer": "^19.1.0",
-    "expo-module-scripts": "4.1.9-canary-20250630-547cd82",
+    "expo-module-scripts": "4.1.10-canary-20250709-136b77f",
     "react": "19.1.0",
     "react-dom": "19.1.0",
-    "react-native": "0.80.0",
+    "react-native": "0.80.1",
     "web-streams-polyfill": "^3.3.2",
     "ws": "^8.18.0"
   },
   "peerDependencies": {
-    "@expo/dom-webview": "0.1.6-canary-20250630-547cd82",
-    "@expo/metro-runtime": "6.0.0-canary-20250630-547cd82",
+    "@expo/dom-webview": "0.1.6-canary-20250709-136b77f",
+    "@expo/metro-runtime": "6.0.0-canary-20250709-136b77f",
     "metro-runtime": "*",
     "react": "*",
     "react-refresh": "*",