expo 58.0.0-preview.0 → 58.0.0-preview.1

package/android/build.gradle

@@ -10,7 +10,7 @@ buildscript {
 }
 
 group = 'host.exp.exponent'
-version = '58.0.0-preview.0'
+version = '58.0.0-preview.1'
 
 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 "58.0.0-preview.0"
+    versionName "58.0.0-preview.1"
     consumerProguardFiles("proguard-rules.pro")
   }
   testOptions {

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

@@ -0,0 +1,19 @@
+package expo.modules
+
+import android.app.Activity
+import android.content.pm.PackageManager
+import android.os.Build
+import com.facebook.react.common.build.ReactBuildConfig
+
+// Android 17 blocks dev server traffic until the app holds the permission React Native's debug manifest declares.
+internal object LocalNetworkPermission {
+  const val PERMISSION = "android.permission.ACCESS_LOCAL_NETWORK"
+  const val REQUEST_CODE = 0x4c4e
+
+  private const val FIRST_ENFORCED_SDK = 37
+
+  fun shouldRequest(activity: Activity): Boolean =
+    ReactBuildConfig.DEBUG &&
+      Build.VERSION.SDK_INT >= FIRST_ENFORCED_SDK &&
+      activity.checkSelfPermission(PERMISSION) != PackageManager.PERMISSION_GRANTED
+}

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

@@ -30,13 +30,13 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
 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,
@@ -64,6 +64,7 @@ class ReactActivityDelegateWrapper(
    * A deferred that indicates when the app loading is ready
    */
   private val loadAppReady = CompletableDeferred<Unit>()
+  private var localNetworkPermissionResult: CompletableDeferred<Unit>? = null
 
   /**
    * A mutex to ensure all coroutines in a scope are running in atomic way.
@@ -161,6 +162,7 @@ class ReactActivityDelegateWrapper(
         mReactDelegate.isAccessible = true
         mReactDelegate.set(delegate, reactDelegate)
         if (mainComponentName != null) {
+          awaitLocalNetworkPermission()
           loadAppImpl(mainComponentName, supportsDelayLoad = false)
         }
       }
@@ -329,6 +331,10 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
+    if (requestCode == LocalNetworkPermission.REQUEST_CODE) {
+      localNetworkPermissionResult?.complete(Unit)
+      return
+    }
     launchLifecycleScopeWithLock {
       loadAppReady.await()
       delegate.onRequestPermissionsResult(requestCode, permissions, grantResults)
@@ -431,11 +437,22 @@ class ReactActivityDelegateWrapper(
     }
   }
 
+  private suspend fun awaitLocalNetworkPermission() {
+    if (!LocalNetworkPermission.shouldRequest(activity)) {
+      return
+    }
+    val result = CompletableDeferred<Unit>()
+    localNetworkPermissionResult = result
+    activity.requestPermissions(arrayOf(LocalNetworkPermission.PERMISSION), LocalNetworkPermission.REQUEST_CODE)
+    result.await()
+    localNetworkPermissionResult = null
+  }
+
   private suspend fun awaitDelayLoadAppWhenReady(delayLoadAppHandler: DelayLoadAppHandler?) {
     if (delayLoadAppHandler == null) {
       return
     }
-    suspendCoroutine { continuation ->
+    suspendCancellableCoroutine { continuation ->
       delayLoadAppHandler.whenReady {
         Utils.assertMainThread()
         continuation.resume(Unit)

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

@@ -0,0 +1,99 @@
+package expo.modules
+
+import android.content.pm.PackageManager
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlagsForTests
+import com.facebook.soloader.SoLoader
+import com.google.common.truth.Truth.assertThat
+import io.mockk.every
+import io.mockk.mockkObject
+import io.mockk.mockkStatic
+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.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.Shadows.shadowOf
+import org.robolectric.android.controller.ActivityController
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(application = MockApplication::class)
+internal class ReactActivityDelegateWrapperLocalNetworkPermissionTest {
+  private lateinit var activityController: ActivityController<MockActivity>
+  private val activity: MockActivity
+    get() = activityController.get()
+  private val wrapper: ReactActivityDelegateWrapper
+    get() = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+
+  @OptIn(ExperimentalCoroutinesApi::class)
+  @Before
+  fun setUp() {
+    SoLoader.setInTestMode()
+    mockkObject(ExpoModulesPackage.Companion)
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(MockPackageWithoutDelayHandler())
+    ReactNativeFeatureFlagsForTests.setUp()
+    mockkStatic(ReactNativeFeatureFlags::class)
+    every { ReactNativeFeatureFlags.enableBridgelessArchitecture() } returns true
+    Dispatchers.setMain(UnconfinedTestDispatcher())
+    mockkObject(LocalNetworkPermission)
+  }
+
+  @After
+  fun tearDown() {
+    unmockkAll()
+  }
+
+  private fun launchActivity() {
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also { (it.get().application as MockApplication).bindCurrentActivity(it.get()) }
+      .setup()
+  }
+
+  private fun verifyLoadApp(times: Int) {
+    verify(exactly = times) { wrapper.invokeDelegateMethod("loadApp", arrayOf(String::class.java), arrayOf("main")) }
+  }
+
+  @Test
+  fun `requests the local network permission before loading the app`() {
+    every { LocalNetworkPermission.shouldRequest(any()) } returns true
+
+    launchActivity()
+
+    verifyLoadApp(0)
+    val request = shadowOf(activity).lastRequestedPermission
+    assertThat(request.requestedPermissions.toList()).containsExactly(LocalNetworkPermission.PERMISSION)
+
+    activity.onRequestPermissionsResult(request.requestCode, request.requestedPermissions, intArrayOf(PackageManager.PERMISSION_GRANTED))
+
+    verifyLoadApp(1)
+  }
+
+  @Test
+  fun `loads the app when the local network permission is denied`() {
+    every { LocalNetworkPermission.shouldRequest(any()) } returns true
+
+    launchActivity()
+    val request = shadowOf(activity).lastRequestedPermission
+    activity.onRequestPermissionsResult(request.requestCode, request.requestedPermissions, intArrayOf(PackageManager.PERMISSION_DENIED))
+
+    verifyLoadApp(1)
+  }
+
+  @Test
+  fun `loads the app immediately when the permission is not required`() {
+    every { LocalNetworkPermission.shouldRequest(any()) } returns false
+
+    launchActivity()
+
+    assertThat(shadowOf(activity).lastRequestedPermission).isNull()
+    verifyLoadApp(1)
+  }
+}

package/build/Expo.d.ts

@@ -3,7 +3,7 @@ export { disableErrorHandling } from './errors/ExpoErrorManager';
 export { default as registerRootComponent } from './launch/registerRootComponent';
 export { isRunningInExpoGo, getExpoGoProjectConfig } from './environment/ExpoGo';
 export { EventEmitter, SharedObject, SharedRef, NativeModule, UnavailabilityError, CodedError, requireNativeModule, requireOptionalNativeModule, requireNativeViewManager as requireNativeView, registerWebModule, reloadAppAsync, installOnUIRuntime, Platform, uuid, createSnapshotFriendlyRef, useReleasingSharedObject, useReleasingSharedObjectWithLifecycle, } from 'expo-modules-core';
-export type { EventSubscription, TypedArray, IntBasedTypedArray, UintBasedTypedArray, FloatBasedTypedArray, } from 'expo-modules-core';
+export type { EventSubscription, TypedArray, IntBasedTypedArray, UintBasedTypedArray, FloatBasedTypedArray, ReleasingSharedObjectLifecycle, ReleasingSharedObjectLifecycleContext, } from 'expo-modules-core';
 export type { 
 /** @deprecated Move to `SharedRef` with a type-only import instead */
 SharedRef as SharedRefType, 

package/build/Expo.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Expo.ts"],"sourcesContent":[null],"names":["disableErrorHandling","default","registerRootComponent","isRunningInExpoGo","getExpoGoProjectConfig","EventEmitter","SharedObject","SharedRef","NativeModule","UnavailabilityError","CodedError","requireNativeModule","requireOptionalNativeModule","requireNativeViewManager","requireNativeView","registerWebModule","reloadAppAsync","installOnUIRuntime","Platform","uuid","createSnapshotFriendlyRef","useReleasingSharedObject","useReleasingSharedObjectWithLifecycle","PermissionStatus","createPermissionHook","useEvent","useEventListener"],"mappings":"AAAA,OAAO,YAAY;AAEnB,SAASA,oBAAoB,QAAQ,4BAA4B;AACjE,SAASC,WAAWC,qBAAqB,QAAQ,iCAAiC;AAElF,SAASC,iBAAiB,EAAEC,sBAAsB,QAAQ,uBAAuB;AAEjF,SACE,eAAe;AACfC,YAAY,EACZC,YAAY,EACZC,SAAS,EACTC,YAAY,EACZC,mBAAmB,EACnBC,UAAU,EAEV,UAAU;AACVC,mBAAmB,EACnBC,2BAA2B,EAC3BC,4BAA4BC,iBAAiB,EAC7CC,iBAAiB,EACjBC,cAAc,EAEd,WAAW;AACXC,kBAAkB,EAElB,QAAQ;AACRC,QAAQ,EACRC,IAAI,EACJC,yBAAyB,EACzBC,wBAAwB,EACxBC,qCAAqC,QAChC,oBAAoB;AAqB3B,SACEC,gBAAgB,QAIX,oBAAoB;AAE3B,SAASC,oBAAoB,QAAQ,oBAAoB;AAEzD,SAASC,QAAQ,EAAEC,gBAAgB,QAAQ,mBAAmB"}
+{"version":3,"sources":["Expo.ts"],"sourcesContent":[null],"names":["disableErrorHandling","default","registerRootComponent","isRunningInExpoGo","getExpoGoProjectConfig","EventEmitter","SharedObject","SharedRef","NativeModule","UnavailabilityError","CodedError","requireNativeModule","requireOptionalNativeModule","requireNativeViewManager","requireNativeView","registerWebModule","reloadAppAsync","installOnUIRuntime","Platform","uuid","createSnapshotFriendlyRef","useReleasingSharedObject","useReleasingSharedObjectWithLifecycle","PermissionStatus","createPermissionHook","useEvent","useEventListener"],"mappings":"AAAA,OAAO,YAAY;AAEnB,SAASA,oBAAoB,QAAQ,4BAA4B;AACjE,SAASC,WAAWC,qBAAqB,QAAQ,iCAAiC;AAElF,SAASC,iBAAiB,EAAEC,sBAAsB,QAAQ,uBAAuB;AAEjF,SACE,eAAe;AACfC,YAAY,EACZC,YAAY,EACZC,SAAS,EACTC,YAAY,EACZC,mBAAmB,EACnBC,UAAU,EAEV,UAAU;AACVC,mBAAmB,EACnBC,2BAA2B,EAC3BC,4BAA4BC,iBAAiB,EAC7CC,iBAAiB,EACjBC,cAAc,EAEd,WAAW;AACXC,kBAAkB,EAElB,QAAQ;AACRC,QAAQ,EACRC,IAAI,EACJC,yBAAyB,EACzBC,wBAAwB,EACxBC,qCAAqC,QAChC,oBAAoB;AAuB3B,SACEC,gBAAgB,QAIX,oBAAoB;AAE3B,SAASC,oBAAoB,QAAQ,oBAAoB;AAEzD,SAASC,QAAQ,EAAEC,gBAAgB,QAAQ,mBAAmB"}

package/build/winter/runtime.native.d.ts

@@ -1,2 +1,2 @@
-import 'react-native/Libraries/Core/InitializeCore';
+import 'react-native/setup-env';
 import '../../types';

package/build/winter/runtime.native.js

@@ -2,7 +2,7 @@
 // https://wintercg.org/
 // WARN(@kitten): We must ensure that the core react-native globals are initialized before ours
 // Otherwise we're relying on `getModulesRunBeforeMainModule` which is unstable or can be missing
-import 'react-native/Libraries/Core/InitializeCore';
+import 'react-native/setup-env';
 import '../../types';
 import { installAbortSignalPatch } from './AbortSignal';
 import { installFormDataPatch } from './FormData';

package/build/winter/runtime.native.js.map

@@ -1 +1 @@
-{"version":3,"sources":["winter/runtime.native.ts"],"sourcesContent":[null],"names":["installAbortSignalPatch","installFormDataPatch","installGlobal","install","require","TextDecoder","TextDecoderStream","TextEncoderStream","URL","URLSearchParams","DOMException","ImportMetaRegistry","default","FormData","AbortSignal","Symbol","asyncIterator","for","useRnFetch","process","env","EXPO_PUBLIC_USE_RN_FETCH","globalThis","Headers","Error","fetch"],"mappings":"AAAA,wFAAwF;AACxF,wBAAwB;AAExB,+FAA+F;AAC/F,iGAAiG;AACjG,OAAO,6CAA6C;AACpD,OAAO,cAAc;AACrB,SAASA,uBAAuB,QAAQ,gBAAgB;AACxD,SAASC,oBAAoB,QAAQ,aAAa;AAClD,SAASC,iBAAiBC,OAAO,QAAQ,kBAAkB;AAE3D,gDAAgD;AAChDA,QAAQ,eAAe,IAAMC,QAAQ,iBAAiBC,WAAW;AACjE,gEAAgE;AAChEF,QAAQ,qBAAqB,IAAMC,QAAQ,uBAAuBE,iBAAiB;AACnF,gEAAgE;AAChEH,QAAQ,qBAAqB,IAAMC,QAAQ,uBAAuBG,iBAAiB;AACnF,mCAAmC;AACnCJ,QAAQ,OAAO,IAAMC,QAAQ,SAASI,GAAG;AACzC,+CAA+C;AAC/CL,QAAQ,mBAAmB,IAAMC,QAAQ,SAASK,eAAe;AACjE,mDAAmD;AACnDN,QAAQ,gBAAgB,IAAMC,QAAQ,kBAAkBM,YAAY;AACpE,sCAAsC;AACtC,kDAAkD;AAElDP,QAAQ,4BAA4B,IAAMC,QAAQ,wBAAwBO,kBAAkB;AAE5F,8EAA8E;AAC9ER,QAAQ,mBAAmB,IAAMC,QAAQ,2BAA2BQ,OAAO;AAE3EX,qBAAqBY;AACrBb,wBAAwBc;AAExB,6CAA6C;AAC7C,+EAA+E;AAC/EC,OAAOC,aAAa,KAAKD,OAAOE,GAAG,CAAC;AAEpC,MAAMC,aACJC,QAAQC,GAAG,CAACC,wBAAwB,KAAK,OAAOF,QAAQC,GAAG,CAACC,wBAAwB,KAAK;AAE3F,IAAI,CAACH,YAAY;IACf,sEAAsE;IACtE,sEAAsE;IACtE,IAAI,CAACI,WAAWC,OAAO,EAAE;QACvB,MAAM,IAAIC,MACR;IAEJ;IACArB,QAAQ,SAAS,IAAMC,QAAQ,WAAWqB,KAAK;AACjD"}
+{"version":3,"sources":["winter/runtime.native.ts"],"sourcesContent":[null],"names":["installAbortSignalPatch","installFormDataPatch","installGlobal","install","require","TextDecoder","TextDecoderStream","TextEncoderStream","URL","URLSearchParams","DOMException","ImportMetaRegistry","default","FormData","AbortSignal","Symbol","asyncIterator","for","useRnFetch","process","env","EXPO_PUBLIC_USE_RN_FETCH","globalThis","Headers","Error","fetch"],"mappings":"AAAA,wFAAwF;AACxF,wBAAwB;AAExB,+FAA+F;AAC/F,iGAAiG;AACjG,OAAO,yBAAyB;AAChC,OAAO,cAAc;AACrB,SAASA,uBAAuB,QAAQ,gBAAgB;AACxD,SAASC,oBAAoB,QAAQ,aAAa;AAClD,SAASC,iBAAiBC,OAAO,QAAQ,kBAAkB;AAE3D,gDAAgD;AAChDA,QAAQ,eAAe,IAAMC,QAAQ,iBAAiBC,WAAW;AACjE,gEAAgE;AAChEF,QAAQ,qBAAqB,IAAMC,QAAQ,uBAAuBE,iBAAiB;AACnF,gEAAgE;AAChEH,QAAQ,qBAAqB,IAAMC,QAAQ,uBAAuBG,iBAAiB;AACnF,mCAAmC;AACnCJ,QAAQ,OAAO,IAAMC,QAAQ,SAASI,GAAG;AACzC,+CAA+C;AAC/CL,QAAQ,mBAAmB,IAAMC,QAAQ,SAASK,eAAe;AACjE,mDAAmD;AACnDN,QAAQ,gBAAgB,IAAMC,QAAQ,kBAAkBM,YAAY;AACpE,sCAAsC;AACtC,kDAAkD;AAElDP,QAAQ,4BAA4B,IAAMC,QAAQ,wBAAwBO,kBAAkB;AAE5F,8EAA8E;AAC9ER,QAAQ,mBAAmB,IAAMC,QAAQ,2BAA2BQ,OAAO;AAE3EX,qBAAqBY;AACrBb,wBAAwBc;AAExB,6CAA6C;AAC7C,+EAA+E;AAC/EC,OAAOC,aAAa,KAAKD,OAAOE,GAAG,CAAC;AAEpC,MAAMC,aACJC,QAAQC,GAAG,CAACC,wBAAwB,KAAK,OAAOF,QAAQC,GAAG,CAACC,wBAAwB,KAAK;AAE3F,IAAI,CAACH,YAAY;IACf,sEAAsE;IACtE,sEAAsE;IACtE,IAAI,CAACI,WAAWC,OAAO,EAAE;QACvB,MAAM,IAAIC,MACR;IAEJ;IACArB,QAAQ,SAAS,IAAMC,QAAQ,WAAWqB,KAAK;AACjD"}

package/bundledNativeModules.json

@@ -1,9 +1,9 @@
 {
   "@expo/dom-webview": "~58.0.0",
   "@expo/fingerprint": "~0.21.0",
-  "@expo/metro-runtime": "~58.0.0",
+  "@expo/metro-runtime": "~58.0.1",
   "@expo/vector-icons": "^15.0.2",
-  "@expo/ui": "~58.0.0",
+  "@expo/ui": "~58.0.1",
   "@react-native-async-storage/async-storage": "2.2.0",
   "@react-native-community/datetimepicker": "9.2.1",
   "@react-native-masked-view/masked-view": "0.3.2",
@@ -13,33 +13,33 @@
   "@react-native-picker/picker": "2.11.4",
   "@react-native-segmented-control/segmented-control": "2.5.7",
   "@stripe/stripe-react-native": "0.76.0",
-  "eslint-config-expo": "~58.0.0",
+  "eslint-config-expo": "~58.0.1",
   "expo-analytics-amplitude": "~11.3.0",
   "expo-app-auth": "~11.1.0",
-  "expo-app-intents": "~0.2.0",
+  "expo-app-intents": "~0.3.0",
   "expo-app-loader-provider": "~8.0.0",
-  "expo-app-metrics": "~58.0.0",
+  "expo-app-metrics": "~58.0.1",
   "expo-apple-authentication": "~58.0.0",
-  "expo-application": "~58.0.0",
-  "expo-asset": "~58.0.0",
+  "expo-application": "~58.0.1",
+  "expo-asset": "~58.0.1",
   "expo-audio": "~58.0.0",
-  "expo-auth-session": "~58.0.0",
-  "expo-background-fetch": "~58.0.0",
-  "expo-background-task": "~58.0.0",
+  "expo-auth-session": "~58.0.1",
+  "expo-background-fetch": "~58.0.1",
+  "expo-background-task": "~58.0.1",
   "expo-battery": "~58.0.0",
   "expo-blur": "~58.0.0",
   "expo-brightness": "~58.0.0",
-  "expo-brownfield": "~58.0.0",
-  "expo-build-properties": "~58.0.0",
+  "expo-brownfield": "~58.0.1",
+  "expo-build-properties": "~58.0.1",
   "expo-calendar": "~58.0.0",
-  "expo-camera": "~58.0.0",
+  "expo-camera": "~58.0.1",
   "expo-cellular": "~58.0.0",
   "expo-checkbox": "~58.0.0",
   "expo-clipboard": "~58.0.0",
-  "expo-constants": "~58.0.0",
-  "expo-contacts": "~58.0.0",
-  "expo-crypto": "~58.0.0",
-  "expo-dev-client": "~58.0.0",
+  "expo-constants": "~58.0.1",
+  "expo-contacts": "~58.0.1",
+  "expo-crypto": "~58.0.1",
+  "expo-dev-client": "~58.0.1",
   "expo-device": "~58.0.0",
   "expo-document-picker": "~58.0.0",
   "expo-eas-client": "~58.0.0",
@@ -48,60 +48,60 @@
   "expo-gl": "~58.0.0",
   "expo-glass-effect": "~58.0.0",
   "expo-google-app-auth": "~8.3.0",
-  "expo-haptics": "~58.0.0",
-  "expo-image": "~58.0.0",
-  "expo-image-loader": "~58.0.0",
-  "expo-image-manipulator": "~58.0.0",
-  "expo-image-picker": "~58.0.0",
+  "expo-haptics": "~58.0.1",
+  "expo-image": "~58.0.1",
+  "expo-image-loader": "~58.0.1",
+  "expo-image-manipulator": "~58.0.2",
+  "expo-image-picker": "~58.0.1",
   "expo-intent-launcher": "~58.0.0",
-  "expo-insights": "~58.0.0",
+  "expo-insights": "~58.0.1",
   "expo-keep-awake": "~58.0.0",
   "expo-linear-gradient": "~58.0.0",
-  "expo-linking": "~58.0.0",
+  "expo-linking": "~58.0.1",
   "expo-local-authentication": "~58.0.0",
   "expo-localization": "~58.0.0",
-  "expo-location": "~58.0.0",
+  "expo-location": "~58.0.1",
   "expo-mail-composer": "~58.0.0",
   "expo-manifests": "~58.0.0",
-  "expo-maps": "~58.0.0",
+  "expo-maps": "~58.0.1",
   "expo-mcp": "~0.2.1",
   "expo-media-library": "~58.0.0",
   "expo-mesh-gradient": "~58.0.0",
-  "expo-module-template": "~58.0.0",
-  "expo-modules-core": "~58.0.0",
+  "expo-module-template": "~58.0.1",
+  "expo-modules-core": "~58.0.1",
   "expo-navigation-bar": "~58.0.0",
   "expo-network": "~58.0.0",
-  "expo-notifications": "~58.0.0",
-  "expo-observe": "~58.0.0",
+  "expo-notifications": "~58.0.1",
+  "expo-observe": "~58.0.3",
   "expo-print": "~58.0.0",
   "expo-live-photo": "~58.0.0",
-  "expo-router": "~58.0.0",
+  "expo-router": "~58.0.2",
   "expo-screen-capture": "~58.0.0",
   "expo-screen-orientation": "~58.0.0",
   "expo-secure-store": "~58.0.0",
   "expo-sensors": "~58.0.0",
   "expo-server": "~58.0.0",
-  "expo-sharing": "~58.0.0",
+  "expo-sharing": "~58.0.3",
   "expo-sms": "~58.0.0",
   "expo-speech": "~58.0.0",
   "expo-splash-screen": "~58.0.0",
-  "expo-sqlite": "~58.0.0",
+  "expo-sqlite": "~58.0.2",
   "expo-status-bar": "~58.0.0",
   "expo-store-review": "~58.0.0",
   "expo-symbols": "~58.0.0",
-  "expo-system-ui": "~58.0.0",
-  "expo-task-manager": "~58.0.0",
+  "expo-system-ui": "~58.0.1",
+  "expo-task-manager": "~58.0.2",
   "expo-tracking-transparency": "~58.0.0",
-  "expo-updates": "~58.0.0",
+  "expo-updates": "~58.0.3",
   "expo-video-thumbnails": "~58.0.0",
-  "expo-video": "~58.0.0",
+  "expo-video": "~58.0.1",
   "expo-web-browser": "~58.0.0",
-  "expo-widgets": "~58.0.0",
-  "jest-expo": "~58.0.0",
+  "expo-widgets": "~58.0.1",
+  "jest-expo": "~58.0.1",
   "lottie-react-native": "~7.5.0",
   "react": "19.2.3",
   "react-dom": "19.2.3",
-  "react-native": "0.87.1",
+  "react-native": "0.88.0-rc.0",
   "react-native-web": "~0.21.0",
   "react-native-gesture-handler": "~3.2.1",
   "react-native-keyboard-controller": "1.22.4",

package/ios/Expo/ExpoAppSceneDelegate.swift

@@ -1,7 +1,6 @@
 // Copyright 2015-present 650 Industries. All rights reserved.
 
 import Foundation
-import ExpoModulesCore
 import React
 #if canImport(ExpoObjC)
 import ExpoObjC
@@ -15,14 +14,18 @@ import ExpoObjC
 
  Responsibilities:
  - Create the `UIWindow` from the connecting `UIWindowScene` and start React Native into it.
- - Re-feed scene life-cycle, URL, and user-activity events to the existing
-   `ExpoAppDelegateSubscriberManager`, so app delegate subscribers keep working unchanged.
+ - 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,
@@ -31,12 +34,14 @@ open class ExpoAppSceneDelegate: UIResponder, UIWindowSceneDelegate {
     guard let windowScene = scene as? UIWindowScene else {
       return
     }
-    guard let provider = UIApplication.shared.delegate as? ExpoReactNativeFactoryProvider,
+    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 doesn't provide a "
-        + "React Native factory. Make sure your AppDelegate conforms to ExpoReactNativeFactoryProvider and "
-        + "creates its RCTReactNativeFactory in application(_:didFinishLaunchingWithOptions:)."
+        "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:)."
       )
     }
 
@@ -64,43 +69,76 @@ open class ExpoAppSceneDelegate: UIResponder, UIWindowSceneDelegate {
     )
 
     // Deep links / universal links.
-    Self.route(urlContexts: connectionOptions.urlContexts)
-    connectionOptions.userActivities.forEach { Self.route(userActivity: $0) }
+    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
   }
 
-  // In the scene lifecycle UIKit no longer calls the app delegate equivalents, so we forward
-  // these to the subscriber manager to preserve existing subscriber behavior.
-
   open func sceneDidBecomeActive(_ scene: UIScene) {
-    ExpoAppDelegateSubscriberManager.applicationDidBecomeActive(UIApplication.shared)
+    forwarder.didBecomeActive()
   }
 
   open func sceneWillResignActive(_ scene: UIScene) {
-    ExpoAppDelegateSubscriberManager.applicationWillResignActive(UIApplication.shared)
+    forwarder.willResignActive()
   }
 
   open func sceneWillEnterForeground(_ scene: UIScene) {
-    ExpoAppDelegateSubscriberManager.applicationWillEnterForeground(UIApplication.shared)
+    forwarder.willEnterForeground()
   }
 
   open func sceneDidEnterBackground(_ scene: UIScene) {
-    ExpoAppDelegateSubscriberManager.applicationDidEnterBackground(UIApplication.shared)
+    forwarder.didEnterBackground()
   }
 
   open func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
-    Self.route(urlContexts: URLContexts)
+    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) {
-    Self.route(userActivity: userActivity)
+    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 & routing helpers
+// MARK: - Launch options
 
 @available(iOSApplicationExtension, unavailable)
 extension ExpoAppSceneDelegate {
@@ -132,29 +170,6 @@ extension ExpoAppSceneDelegate {
     return launchOptions.isEmpty ? nil : launchOptions
   }
 
-  /// Pass incoming URL contexts to both the subscriber manager and `RCTLinkingManager`.
-  public static func route(urlContexts: Set<UIOpenURLContext>) {
-    for context in urlContexts {
-      let options = openURLOptions(from: context.options)
-      _ = ExpoAppDelegateSubscriberManager.application(UIApplication.shared, open: context.url, options: options)
-      RCTLinkingManager.application(UIApplication.shared, open: context.url, options: options)
-    }
-  }
-
-  /// Passes an incoming `NSUserActivity` to both the subscriber manager and `RCTLinkingManager`.
-  public static func route(userActivity: NSUserActivity) {
-    _ = ExpoAppDelegateSubscriberManager.application(
-      UIApplication.shared,
-      continue: userActivity,
-      restorationHandler: { _ in }
-    )
-    RCTLinkingManager.application(
-      UIApplication.shared,
-      continue: userActivity,
-      restorationHandler: { _ in }
-    )
-  }
-
   private static func openURLOptions(
     from sceneOptions: UIScene.OpenURLOptions
   ) -> [UIApplication.OpenURLOptionsKey: Any] {

package/ios/Expo/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

@@ -1,11 +1,13 @@
 // Copyright 2025-present 650 Industries. All rights reserved.
 
+import ExpoModulesCore
+import React
 import Testing
 @testable import Expo
 
 #if os(iOS) || os(tvOS)
 
-@Suite
+@Suite(.serialized)
 struct ExpoAppSceneDelegateTests {
   @Test
   func `extends UIResponder`() {
@@ -22,6 +24,23 @@ struct ExpoAppSceneDelegateTests {
     #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`() {
@@ -54,6 +73,487 @@ struct ExpoAppSceneDelegateTests {
   func `returns nil launch options without a URL or user activity`() {
     #expect(ExpoAppSceneDelegate.launchOptions(url: nil, userActivity: nil) == nil)
   }
+
+  @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 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
+  }
+}
+
+/// 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": "58.0.0-preview.0",
+  "version": "58.0.0-preview.1",
   "description": "The Expo SDK",
   "keywords": [
     "expo"
@@ -198,40 +198,40 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.20.0",
-    "@expo/cli": "^58.0.0",
+    "@expo/cli": "^58.0.1",
     "@expo/config": "~58.0.0",
     "@expo/config-plugins": "~58.0.0",
     "@expo/devtools": "~58.0.0",
     "@expo/dom-webview": "~58.0.0",
     "@expo/fingerprint": "^0.21.0",
     "@expo/local-build-cache-provider": "^58.0.0",
-    "@expo/log-box": "^58.0.0",
+    "@expo/log-box": "^58.0.1",
     "@expo/log-box-utils": "^58.0.0",
     "@expo/metro": "~56.1.0",
-    "@expo/metro-config": "~58.0.0",
+    "@expo/metro-config": "~58.0.1",
     "@ungap/structured-clone": "^1.3.0",
-    "babel-preset-expo": "~58.0.0",
-    "expo-asset": "~58.0.0",
-    "expo-constants": "~58.0.0",
+    "babel-preset-expo": "~58.0.1",
+    "expo-asset": "~58.0.1",
+    "expo-constants": "~58.0.1",
     "expo-file-system": "~58.0.0",
     "expo-font": "~58.0.0",
     "expo-keep-awake": "~58.0.0",
-    "expo-modules-autolinking": "~58.0.0",
-    "expo-modules-core": "~58.0.0",
+    "expo-modules-autolinking": "~58.0.1",
+    "expo-modules-core": "~58.0.1",
     "pretty-format": "^29.7.0",
     "react-refresh": "^0.14.2",
     "whatwg-url-minimum": "^0.2.0"
   },
   "devDependencies": {
     "@expo/dom-webview": "58.0.0",
-    "@expo/metro-runtime": "58.0.0",
+    "@expo/metro-runtime": "58.0.1",
     "@types/node": "^22.14.0",
     "@types/react": "~19.2.0",
-    "expo-updates": "58.0.0",
+    "expo-updates": "58.0.3",
     "npm-run-all2": "^8.0.4",
     "react": "19.2.3",
     "react-dom": "19.2.3",
-    "react-native": "0.87.1",
+    "react-native": "0.88.0-rc.0",
     "rimraf": "^6.1.2",
     "web-streams-polyfill": "^3.3.2"
   },
@@ -267,7 +267,7 @@
   "engines": {
     "node": "^22.13.0 || ^24.3.0 || ^26.0.0 || >=27.0.0"
   },
-  "gitHead": "c543a7181fc32e14f42d89550087b80ac5c490f2",
+  "gitHead": "40afe3afa42f1dcca3dcba7ffbb3641859bdf2f0",
   "scripts": {
     "build": "../expo-module-scripts/bin/expo-build src",
     "clean": "rimraf build",

package/src/Expo.ts

@@ -38,6 +38,8 @@ export type {
   IntBasedTypedArray,
   UintBasedTypedArray,
   FloatBasedTypedArray,
+  ReleasingSharedObjectLifecycle,
+  ReleasingSharedObjectLifecycleContext,
 } from 'expo-modules-core';
 
 export type {

package/src/winter/runtime.native.ts

@@ -3,7 +3,7 @@
 
 // WARN(@kitten): We must ensure that the core react-native globals are initialized before ours
 // Otherwise we're relying on `getModulesRunBeforeMainModule` which is unstable or can be missing
-import 'react-native/Libraries/Core/InitializeCore';
+import 'react-native/setup-env';
 import '../../types';
 import { installAbortSignalPatch } from './AbortSignal';
 import { installFormDataPatch } from './FormData';