expo-dev-launcher 5.2.0-canary-20250709-136b77f → 5.2.0-canary-20250713-8f814f8

package/android/build.gradle

@@ -20,13 +20,13 @@ expoModule {
 }
 
 group = "host.exp.exponent"
-version = "5.2.0-canary-20250709-136b77f"
+version = "5.2.0-canary-20250713-8f814f8"
 
 android {
   namespace "expo.modules.devlauncher"
   defaultConfig {
     versionCode 9
-    versionName "5.2.0-canary-20250709-136b77f"
+    versionName "5.2.0-canary-20250713-8f814f8"
   }
 
   buildTypes {

package/android/src/debug/java/expo/modules/devlauncher/compose/HomeViewModel.kt

@@ -7,7 +7,6 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import expo.modules.devlauncher.DevLauncherController
 import expo.modules.devlauncher.MeQuery
-import expo.modules.devlauncher.services.HttpClientService
 import expo.modules.devlauncher.services.PackagerInfo
 import expo.modules.devlauncher.services.PackagerService
 import expo.modules.devlauncher.services.SessionService
@@ -19,6 +18,7 @@ import kotlinx.coroutines.launch
 
 sealed interface HomeAction {
   class OpenApp(val url: String) : HomeAction
+  object RefetchRunningApps : HomeAction
 }
 
 typealias HomeActionHandler = (HomeAction) -> Unit
@@ -26,15 +26,14 @@ typealias HomeActionHandler = (HomeAction) -> Unit
 data class HomeState(
   val appName: String = "BareExpo",
   val runningPackagers: Set<PackagerInfo> = emptySet(),
+  val isFetchingPackagers: Boolean = false,
   val currentAccount: MeQuery.Account? = null
 )
 
 class HomeViewModel() : ViewModel() {
-  val httpClientService = inject<HttpClientService>()
   val devLauncherController = inject<DevLauncherController>()
   val sessionService = inject<SessionService>()
-
-  val packagerService = PackagerService(httpClientService.httpClient, viewModelScope)
+  val packagerService = inject<PackagerService>()
 
   private var _state = mutableStateOf(
     HomeState(
@@ -50,6 +49,10 @@ class HomeViewModel() : ViewModel() {
     get() = _state.value
 
   init {
+    viewModelScope.launch {
+      packagerService.refetchedPackager()
+    }
+
     packagerService.runningPackagers.onEach { newPackagers ->
       _state.value = _state.value.copy(
         runningPackagers = newPackagers
@@ -67,6 +70,12 @@ class HomeViewModel() : ViewModel() {
         )
       }
     }.launchIn(viewModelScope)
+
+    packagerService.isLoading.onEach { isLoading ->
+      _state.value = _state.value.copy(
+        isFetchingPackagers = isLoading
+      )
+    }.launchIn(viewModelScope)
   }
 
   fun onAction(action: HomeAction) {
@@ -79,6 +88,8 @@ class HomeViewModel() : ViewModel() {
             Log.e("DevLauncher", "Failed to open app: ${action.url}", e)
           }
         }
+
+      HomeAction.RefetchRunningApps -> viewModelScope.launch { packagerService.refetchedPackager() }
     }
   }
 }

package/android/src/debug/java/expo/modules/devlauncher/compose/screens/HomeScreen.kt

@@ -1,21 +1,32 @@
 package expo.modules.devlauncher.compose.screens
 
 import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
 import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.displayCutoutPadding
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.systemBarsPadding
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.composables.core.Dialog
+import com.composables.core.DialogPanel
+import com.composables.core.Icon
+import com.composables.core.Scrim
+import com.composables.core.rememberDialogState
 import com.composeunstyled.Button
 import com.composeunstyled.TextField
 import expo.modules.devlauncher.R
@@ -23,14 +34,18 @@ import expo.modules.devlauncher.compose.HomeAction
 import expo.modules.devlauncher.compose.HomeState
 import expo.modules.devlauncher.compose.primitives.Accordion
 import expo.modules.devlauncher.compose.ui.AppHeader
+import expo.modules.devlauncher.compose.ui.DevelopmentSessionHelper
 import expo.modules.devlauncher.compose.ui.RunningAppCard
 import expo.modules.devlauncher.compose.ui.ScreenHeaderContainer
 import expo.modules.devlauncher.compose.ui.SectionHeader
 import expo.modules.devmenu.compose.primitives.Divider
+import expo.modules.devmenu.compose.primitives.Heading
 import expo.modules.devmenu.compose.primitives.RoundedSurface
+import expo.modules.devmenu.compose.primitives.RowLayout
 import expo.modules.devmenu.compose.primitives.Spacer
 import expo.modules.devmenu.compose.primitives.Text
 import expo.modules.devmenu.compose.theme.Theme
+import expo.modules.devmenu.compose.ui.MenuButton
 
 @Composable
 fun HomeScreen(
@@ -38,6 +53,45 @@ fun HomeScreen(
   onAction: (HomeAction) -> Unit,
   onProfileClick: () -> Unit
 ) {
+  val hasPackager = state.runningPackagers.isNotEmpty()
+  val dialogState = rememberDialogState(initiallyVisible = false)
+
+  Dialog(state = dialogState) {
+    Scrim()
+
+    DialogPanel(
+      modifier = Modifier
+        .displayCutoutPadding()
+        .systemBarsPadding()
+        .clip(RoundedCornerShape(12.dp))
+        .background(Theme.colors.background.default)
+    ) {
+      Column {
+        RowLayout(
+          rightComponent = {
+            Button(onClick = {
+              dialogState.visible = false
+            }) {
+              Icon(
+                painterResource(R.drawable._expodevclientcomponents_assets_xicon),
+                contentDescription = "Close dialog"
+              )
+            }
+          },
+          modifier = Modifier.padding(Theme.spacing.medium)
+        ) {
+          Heading("Development servers")
+        }
+
+        Divider()
+
+        Row(modifier = Modifier.padding(Theme.spacing.medium)) {
+          DevelopmentSessionHelper()
+        }
+      }
+    }
+  }
+
   Column {
     ScreenHeaderContainer(modifier = Modifier.padding(Theme.spacing.medium)) {
       AppHeader(
@@ -65,10 +119,16 @@ fun HomeScreen(
             )
           },
           rightIcon = {
-            Image(
-              painter = painterResource(R.drawable._expodevclientcomponents_assets_infoicon),
-              contentDescription = "Terminal Icon"
-            )
+            if (hasPackager) {
+              Button(onClick = {
+                dialogState.visible = true
+              }) {
+                Image(
+                  painter = painterResource(R.drawable._expodevclientcomponents_assets_infoicon),
+                  contentDescription = "Terminal Icon"
+                )
+              }
+            }
           }
         )
       }
@@ -77,15 +137,35 @@ fun HomeScreen(
 
       RoundedSurface {
         Column {
-          for (packager in state.runningPackagers) {
-            RunningAppCard(
-              appIp = packager.url
-            ) {
-              onAction(HomeAction.OpenApp(packager.url))
+          if (hasPackager) {
+            for (packager in state.runningPackagers) {
+              RunningAppCard(
+                appIp = packager.url,
+                appName = packager.description
+              ) {
+                onAction(HomeAction.OpenApp(packager.url))
+              }
+              Divider()
+            }
+          } else {
+            Box(modifier = Modifier.padding(Theme.spacing.medium)) {
+              DevelopmentSessionHelper()
             }
             Divider()
           }
 
+          MenuButton(
+            onClick = {
+              onAction(HomeAction.RefetchRunningApps)
+            },
+            enabled = !state.isFetchingPackagers,
+            label = if (state.isFetchingPackagers) {
+              "Searching for development servers..."
+            } else {
+              "Fetch development servers"
+            }
+          )
+
           Accordion("Enter URL manually", initialState = false) {
             val url = remember { mutableStateOf("") }
 
@@ -116,9 +196,12 @@ fun HomeScreen(
 
               Spacer(Theme.spacing.tiny)
 
-              Button(onClick = {
-                onAction(HomeAction.OpenApp(url.value))
-              }, modifier = Modifier.fillMaxWidth()) {
+              Button(
+                onClick = {
+                  onAction(HomeAction.OpenApp(url.value))
+                },
+                modifier = Modifier.fillMaxWidth()
+              ) {
                 Row(modifier = Modifier.padding(vertical = Theme.spacing.small)) {
                   Text("Connect")
                 }

package/android/src/debug/java/expo/modules/devlauncher/compose/ui/BottomTabButton.kt

@@ -20,7 +20,7 @@ fun BottomTabButton(
   modifier: Modifier = Modifier,
   onClick: () -> Unit
 ) {
-  Button(onClick = onClick, modifier = modifier) {
+  Button(onClick = onClick, enabled = !isSelected, modifier = modifier) {
     Column(horizontalAlignment = Alignment.Companion.CenterHorizontally, modifier = Modifier.Companion.padding(Theme.spacing.small)) {
       Icon(
         painter = icon,

package/android/src/debug/java/expo/modules/devlauncher/compose/ui/DevelopmentServerHelp.kt

@@ -0,0 +1,52 @@
+package expo.modules.devlauncher.compose.ui
+
+import androidx.compose.foundation.BorderStroke
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import expo.modules.devmenu.compose.primitives.Mono
+import expo.modules.devmenu.compose.primitives.RoundedSurface
+import expo.modules.devmenu.compose.primitives.Spacer
+import expo.modules.devmenu.compose.primitives.Text
+import expo.modules.devmenu.compose.theme.Theme
+
+@Composable
+fun DevelopmentSessionHelper() {
+  Column {
+    Text("Start a local development server with:")
+
+    Spacer(Theme.spacing.small)
+
+    RoundedSurface(
+      color = Theme.colors.background.secondary,
+      border = BorderStroke(
+        width = Theme.sizing.border.default,
+        color = Theme.colors.border.default
+      ),
+      modifier = Modifier
+        .fillMaxWidth()
+    ) {
+      Box(modifier = Modifier.padding(Theme.spacing.medium)) {
+        Mono("npx expo start")
+      }
+    }
+
+    Spacer(Theme.spacing.small)
+
+    Text("Then, select the local server when it appears here.")
+
+    Spacer(Theme.spacing.small)
+
+    Text("Alternatively, open the Camera app and scan the QR code that appears in your terminal")
+  }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun DevelopmentSessionHelperPreview() {
+  DevelopmentSessionHelper()
+}

package/android/src/debug/java/expo/modules/devlauncher/compose/ui/RunningAppCard.kt

@@ -5,6 +5,7 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.painterResource
@@ -33,10 +34,8 @@ fun RunningAppCard(
     onClick = { onClick(appIp) },
     backgroundColor = Theme.colors.background.default
   ) {
-    Column {
+    Column(modifier = Modifier.padding(Theme.spacing.medium)) {
       RowLayout(
-        modifier = Modifier
-          .padding(Theme.spacing.medium),
         leftComponent = {
           val iconColor = Theme.colors.status.success
 
@@ -65,8 +64,10 @@ fun RunningAppCard(
       }
 
       if (description != null) {
+        Spacer(Theme.spacing.tiny)
+
         Row {
-          Spacer(Theme.spacing.small + Theme.sizing.icon.extraSmall)
+          Spacer(modifier = Modifier.width(Theme.sizing.icon.extraSmall))
 
           Text(
             text = description,

package/android/src/debug/java/expo/modules/devlauncher/services/ApolloClientService.kt

@@ -3,12 +3,16 @@ package expo.modules.devlauncher.services
 import com.apollographql.apollo.ApolloClient
 import com.apollographql.apollo.api.ApolloResponse
 import com.apollographql.apollo.api.http.HttpHeader
+import com.apollographql.apollo.network.okHttpClient
 import expo.modules.devlauncher.MeQuery
 
-class ApolloClientService {
+class ApolloClientService(
+  httpClientService: HttpClientService
+) {
   private var _client = ApolloClient
     .Builder()
     .serverUrl("https://exp.host/--/graphql")
+    .okHttpClient(httpClientService.httpClient)
     .build()
 
   val client: ApolloClient

package/android/src/debug/java/expo/modules/devlauncher/services/DependencyInjection.kt

@@ -28,6 +28,9 @@ object DependencyInjection {
   var devLauncherController: DevLauncherController? = null
     private set
 
+  var packagerService: PackagerService? = null
+    private set
+
   fun init(context: Context, devLauncherController: DevLauncherController) = synchronized(this) {
     if (wasInitialized) {
       return
@@ -46,14 +49,17 @@ object DependencyInjection {
       httpClientService = httpClient
     )
 
-    val apolloClient = ApolloClientService()
+    val apolloClient = ApolloClientService(httpClient)
 
     apolloClientService = apolloClient
 
     sessionService = SessionService(
       sessionStore = context.applicationContext.getSharedPreferences("expo.modules.devlauncher.session", Context.MODE_PRIVATE),
-      apolloClientService = apolloClient
+      apolloClientService = apolloClient,
+      httpClientService = httpClient
     )
+
+    packagerService = PackagerService(httpClient)
   }
 }
 
@@ -65,6 +71,7 @@ internal inline fun <reified T> injectService(): T {
     ImageLoaderService::class -> DependencyInjection.imageLoaderService
     HttpClientService::class -> DependencyInjection.httpClientService
     DevLauncherController::class -> DependencyInjection.devLauncherController
+    PackagerService::class -> DependencyInjection.packagerService
     else -> throw IllegalArgumentException("Unknown service type: ${T::class}")
   } as T
 }

package/android/src/debug/java/expo/modules/devlauncher/services/HttpClientService.kt

@@ -1,9 +1,84 @@
 package expo.modules.devlauncher.services
 
+import androidx.core.net.toUri
+import expo.modules.devlauncher.helpers.await
 import okhttp3.OkHttpClient
+import okhttp3.Request
+import org.json.JSONObject
 
-class HttpClientService {
-  val httpClient = OkHttpClient
-    .Builder()
+private const val restEndpoint = "https://exp.host/--/api/v2"
+
+data class DevelopmentSession(
+  val description: String,
+  val source: String,
+  val url: String
+) {
+  constructor(json: JSONObject) : this(
+    description = json.getString("description"),
+    source = json.getString("source"),
+    url = json.getString("url").let { url ->
+      val parsed = url.toUri()
+
+      if (parsed.host != "expo-development-client") {
+        return@let url
+      }
+
+      val urlParameter = parsed.getQueryParameter("url")
+      urlParameter ?: url
+    }
+  )
+}
+
+class HttpClientService() {
+  private var currentSession: String? = null
+
+  val httpClient = OkHttpClient.Builder()
+    .addInterceptor { chain ->
+      val originalRequest = chain.request()
+      val session = currentSession
+      if (session == null || !originalRequest.url.toString().startsWith(restEndpoint)) {
+        return@addInterceptor chain.proceed(originalRequest)
+      }
+
+      val newRequest = originalRequest.newBuilder()
+        .header("expo-session", session)
+        .build()
+      chain.proceed(newRequest)
+    }
     .build()
+
+  internal fun setSession(sessionSecret: String?) {
+    currentSession = sessionSecret
+  }
+
+  suspend fun fetchDevelopmentSession(): List<DevelopmentSession> {
+    if (currentSession === null) {
+      return emptyList()
+    }
+
+    val request = Request.Builder()
+      .url("$restEndpoint/development-sessions")
+      .header("content-type", "application/json")
+      .build()
+
+    val response = request.await(httpClient)
+
+    if (!response.isSuccessful) {
+      throw IllegalStateException("Failed to fetch development session: ${response.code} ${response.message}")
+    }
+
+    val body = response.body?.string()
+    if (body == null) {
+      return emptyList()
+    }
+
+    return buildList {
+      val json = JSONObject(body)
+      val data = json.getJSONArray("data")
+      for (index in 0 until data.length()) {
+        val item = data.getJSONObject(index)
+        add(DevelopmentSession(json = item))
+      }
+    }
+  }
 }

package/android/src/debug/java/expo/modules/devlauncher/services/PackagerService.kt

@@ -1,18 +1,17 @@
 package expo.modules.devlauncher.services
 
+import androidx.core.net.toUri
 import expo.modules.core.utilities.EmulatorUtilities
 import expo.modules.devlauncher.helpers.await
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import okhttp3.OkHttpClient
+import kotlinx.coroutines.withContext
 import okhttp3.Request
-import kotlin.time.Duration.Companion.seconds
 
 private val portsToCheck = arrayOf(8081, 8082, 8083, 8084, 8085, 19000, 19001, 19002)
 private val hostToCheck = if (EmulatorUtilities.isRunningOnEmulator()) {
@@ -22,65 +21,121 @@ private val hostToCheck = if (EmulatorUtilities.isRunningOnEmulator()) {
 }
 
 data class PackagerInfo(
-  val host: String,
-  val port: Int
+  val url: String,
+  val description: String? = null,
+  val isDevelopmentSession: Boolean = false
 ) {
+  internal val port = url.toUri().port
+
   internal fun createStatusPageRequest(): Request {
-    val url = "http://$host:$port/status"
+    val url = "$url/status"
     return Request.Builder()
       .url(url)
       .build()
   }
-
-  val url: String
-    get() = "http://$host:$port"
 }
 
-private val defaultDelay = 3.seconds
-
 /*
  * Class responsible for discovering running packagers.
  */
 class PackagerService(
-  private val httpClient: OkHttpClient,
-  scope: CoroutineScope
+  private val httpClientService: HttpClientService
 ) {
-  private val packagersToCheck = portsToCheck.map { PackagerInfo(hostToCheck, it) }
+  private val packagersToCheck = portsToCheck.map { port -> PackagerInfo("http://$hostToCheck:$port") }
 
   private val _runningPackagers = MutableStateFlow<Set<PackagerInfo>>(emptySet())
+  private val _isLoading = MutableStateFlow(false)
 
   val runningPackagers = _runningPackagers.asStateFlow()
+  val isLoading = _isLoading.asStateFlow()
+
+  private fun addPackager(packager: PackagerInfo) {
+    _runningPackagers.update { packagers ->
+      // The packager list contains a development session packager, which the same port and we are trying to add local packager.
+      // In this case, we can ignore the local packager, because the development session is more important.
+      val canBeIgnored = packagers.any { it.port == packager.port && it.isDevelopmentSession && !packager.isDevelopmentSession }
+      if (canBeIgnored) {
+        return@update packagers
+      }
+
+      if (!packagers.contains(packager)) {
+        packagers.plus(packager)
+      } else {
+        packagers
+      }
+    }
+  }
+
+  private fun removePackager(packager: PackagerInfo) {
+    _runningPackagers.update { packagers ->
+      if (packagers.contains(packager)) {
+        packagers.minus(packager)
+      } else {
+        packagers
+      }
+    }
+  }
+
+  private suspend fun fetchedLocalPackagers(): Unit = coroutineScope {
+    val jobs = packagersToCheck.map { packager ->
+      async {
+        val statusPageRequest = packager.createStatusPageRequest()
+        val isSuccessful = runCatching { statusPageRequest.await(httpClientService.httpClient) }
+          .getOrNull()
+          ?.use { response -> response.isSuccessful }
+          ?: false
 
-  init {
-    scope.launch(Dispatchers.IO) {
-      while (isActive) {
-        for (packager in packagersToCheck) {
-          val statusPageRequest = packager.createStatusPageRequest()
-          launch {
-            val data = runCatching { statusPageRequest.await(httpClient) }.getOrNull()
-            val isSuccessful = data?.isSuccessful == true
-            data?.close()
-            if (isSuccessful) {
-              _runningPackagers.update {
-                if (!it.contains(packager)) {
-                  it.plus(packager)
-                } else {
-                  it
-                }
-              }
-            } else {
-              _runningPackagers.update {
-                if (it.contains(packager)) {
-                  it.minus(packager)
-                } else {
-                  it
-                }
-              }
-            }
-          }
+        if (isSuccessful) {
+          addPackager(packager)
+        } else {
+          removePackager(packager)
         }
-        delay(defaultDelay)
       }
     }
+
+    jobs.awaitAll()
+  }
+
+  private suspend fun fetchedDevelopmentSession() {
+    val developmentSession = httpClientService.fetchDevelopmentSession()
+    val newPackagers = developmentSession.map { session ->
+      PackagerInfo(
+        url = session.url,
+        description = session.description,
+        isDevelopmentSession = true
+      )
+    }
+
+    _runningPackagers.update { packagers ->
+      // We remove all existing development session packagers and
+      // also local packagers with the same port as the new development session packagers
+      val filteredPackager = packagers.filter {
+        !it.isDevelopmentSession || newPackagers.all { newPackager -> newPackager.port != it.port }
+      }
+
+      filteredPackager.plus(
+        developmentSession.map { session ->
+          PackagerInfo(
+            url = session.url,
+            description = session.description,
+            isDevelopmentSession = true
+          )
+        }
+      ).toSet()
+    }
+  }
+
+  suspend fun refetchedPackager() {
+    // It's loading already, so we don't need to do anything.
+    if (isLoading.value) {
+      return
+    }
+
+    _isLoading.update { true }
+    withContext(context = Dispatchers.Default) {
+      fetchedDevelopmentSession()
+      fetchedLocalPackagers()
+      _isLoading.update { false }
+    }
   }
 }

package/android/src/debug/java/expo/modules/devlauncher/services/SessionService.kt

@@ -25,7 +25,8 @@ sealed interface UserState {
 
 class SessionService(
   val sessionStore: SharedPreferences,
-  private val apolloClientService: ApolloClientService
+  private val apolloClientService: ApolloClientService,
+  private val httpClientService: HttpClientService
 ) {
   data class User(
     val isFetching: Boolean = false,
@@ -73,6 +74,7 @@ class SessionService(
   fun setSession(newSession: Session?) {
     newSession.saveToPreferences(sessionStore)
     apolloClientService.setSession(newSession?.sessionSecret)
+    httpClientService.setSession(newSession?.sessionSecret)
     _session.update { newSession }
   }
 
@@ -95,6 +97,7 @@ class SessionService(
   private fun restoreSession(): Session? {
     val newSession = Session.loadFromPreferences(sessionStore)
     apolloClientService.setSession(newSession?.sessionSecret)
+    httpClientService.setSession(newSession?.sessionSecret)
     return newSession
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "expo-dev-launcher",
   "title": "Expo Development Launcher",
-  "version": "5.2.0-canary-20250709-136b77f",
+  "version": "5.2.0-canary-20250713-8f814f8",
   "description": "Pre-release version of the Expo development launcher package for testing.",
   "repository": {
     "type": "git",
@@ -15,10 +15,10 @@
   "license": "MIT",
   "homepage": "https://docs.expo.dev",
   "dependencies": {
-    "expo-dev-menu": "6.2.0-canary-20250709-136b77f",
-    "expo-manifests": "0.17.0-canary-20250709-136b77f"
+    "expo-dev-menu": "6.2.0-canary-20250713-8f814f8",
+    "expo-manifests": "0.17.0-canary-20250713-8f814f8"
   },
   "peerDependencies": {
-    "expo": "54.0.0-canary-20250709-136b77f"
+    "expo": "54.0.0-canary-20250713-8f814f8"
   }
 }