expo-dev-menu 55.0.9 → 55.0.11

package/CHANGELOG.md

@@ -10,6 +10,14 @@
 
 ### 💡 Others
 
+## 55.0.11 — 2026-03-04
+
+_This version does not introduce any user-facing changes._
+
+## 55.0.10 — 2026-02-26
+
+_This version does not introduce any user-facing changes._
+
 ## 55.0.9 — 2026-02-25
 
 _This version does not introduce any user-facing changes._

package/android/build.gradle

@@ -12,7 +12,7 @@ apply plugin: 'expo-module-gradle-plugin'
 apply plugin: 'org.jetbrains.kotlin.plugin.compose'
 
 group = 'host.exp.exponent'
-version = '55.0.9'
+version = '55.0.11'
 
 def hasDevLauncher = findProject(":expo-dev-launcher") != null
 def configureInRelease = findProperty("expo.devmenu.configureInRelease") == "true"
@@ -29,7 +29,7 @@ android {
 
   defaultConfig {
     versionCode 10
-    versionName '55.0.9'
+    versionName '55.0.11'
   }
 
   buildTypes {

package/android/src/debug/java/expo/modules/devmenu/DevMenuFragment.kt

@@ -180,10 +180,7 @@ class DevMenuFragment(
               DevMenuBottomSheet(viewModel.state, viewModel::onAction)
               MovableFloatingActionButton(
                 state = viewModel.state,
-                onRefreshPress = {
-                  viewModel.onAction(DevMenuAction.Reload)
-                },
-                onOpenMenuPress = {
+                onPress = {
                   viewModel.onAction(DevMenuAction.Open)
                 }
               )

package/android/src/debug/java/expo/modules/devmenu/DevMenuPreferences.kt

@@ -3,7 +3,6 @@ package expo.modules.devmenu
 import android.app.Application
 import android.content.Context.MODE_PRIVATE
 import android.content.SharedPreferences
-import expo.modules.core.utilities.VRUtilities
 import expo.modules.devmenu.helpers.preferences
 
 private const val DEV_SETTINGS_PREFERENCES = "expo.modules.devmenu.sharedpreferences"
@@ -90,5 +89,5 @@ class DevMenuDefaultPreferences(
     by preferences(sharedPreferences, false)
 
   override var showFab: Boolean
-    by preferences(sharedPreferences, VRUtilities.isQuest())
+    by preferences(sharedPreferences, true)
 }

package/android/src/debug/java/expo/modules/devmenu/compose/ui/ToolsSection.kt

@@ -126,7 +126,7 @@ fun ToolsSection(
           },
           content = {
             NewText(
-              text = "Show dev menu button"
+              text = "Tools button"
             )
           },
           rightComponent = {

package/android/src/debug/java/expo/modules/devmenu/fab/FabState.kt

@@ -0,0 +1,109 @@
+package expo.modules.devmenu.fab
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.VectorConverter
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.core.content.edit
+import kotlinx.coroutines.delay
+
+private const val IdleTimeoutMs = 5_000L
+private const val FAB_PREFS = "expo.modules.devmenu.sharedpreferences"
+private const val FAB_POSITION_X = "fabPositionX"
+private const val FAB_POSITION_Y = "fabPositionY"
+private const val FAB_POSITION_UNSET = -1f
+
+data class FabBounds(
+  val screen: Offset,
+  val safe: Offset,
+  val safeMinY: Float,
+  val drag: Offset,
+  val halfFab: Offset
+)
+
+class FabState(
+  initialOffset: Offset,
+  val bounds: FabBounds,
+  val prefs: SharedPreferences
+) {
+  val animatedOffset = Animatable(initialOffset, Offset.VectorConverter)
+  var isPressed by mutableStateOf(false)
+  var isDragging by mutableStateOf(false)
+  var isIdle by mutableStateOf(false)
+  var isOffScreen by mutableStateOf(false)
+  var restingOffset by mutableStateOf(initialOffset)
+  var lastInteractionTime by mutableLongStateOf(System.currentTimeMillis())
+
+  fun onInteraction() {
+    lastInteractionTime = System.currentTimeMillis()
+  }
+
+  fun savePosition(offset: Offset) {
+    val safeWidth = bounds.safe.x
+    val safeHeight = bounds.safe.y - bounds.safeMinY
+
+    // Store position as 0–1 ratios within the safe area so it survives screen size changes
+    val normalizedX = if (safeWidth > 0f) offset.x / safeWidth else 0f
+    val normalizedY = if (safeHeight > 0f) (offset.y - bounds.safeMinY) / safeHeight else 0f
+
+    prefs.edit {
+      putFloat(FAB_POSITION_X, normalizedX)
+      putFloat(FAB_POSITION_Y, normalizedY)
+    }
+  }
+}
+
+@Composable
+fun rememberFabState(screenBounds: Offset, totalFabSizePx: Offset): FabState {
+  val density = LocalDensity.current
+  val systemBarInsets = WindowInsets.systemBars
+  val safeInsetTop = with(density) { systemBarInsets.getTop(this).toFloat() }
+  val safeInsetBottom = with(density) { systemBarInsets.getBottom(this).toFloat() }
+  val halfFab = Offset(totalFabSizePx.x / 2f, totalFabSizePx.y / 2f)
+
+  val fabBounds = FabBounds(
+    screen = screenBounds,
+    safe = Offset(screenBounds.x, screenBounds.y - safeInsetBottom),
+    safeMinY = safeInsetTop,
+    drag = Offset(screenBounds.x + halfFab.x, screenBounds.y + halfFab.y),
+    halfFab = halfFab
+  )
+
+  val context = LocalContext.current
+  val prefs = remember { context.getSharedPreferences(FAB_PREFS, Context.MODE_PRIVATE) }
+
+  val initialOffset = remember(fabBounds.safe, fabBounds.safeMinY) {
+    val savedX = prefs.getFloat(FAB_POSITION_X, FAB_POSITION_UNSET)
+    val savedY = prefs.getFloat(FAB_POSITION_Y, FAB_POSITION_UNSET)
+    if (savedX != FAB_POSITION_UNSET && savedY != FAB_POSITION_UNSET) {
+      Offset(
+        x = (savedX * fabBounds.safe.x).coerceIn(0f, fabBounds.safe.x),
+        y = (savedY * (fabBounds.safe.y - fabBounds.safeMinY) + fabBounds.safeMinY).coerceIn(fabBounds.safeMinY, fabBounds.safe.y)
+      )
+    } else {
+      Offset(fabBounds.safe.x, fabBounds.safeMinY)
+    }
+  }
+
+  val state = remember { FabState(initialOffset, fabBounds, prefs) }
+
+  LaunchedEffect(state.lastInteractionTime) {
+    state.isIdle = false
+    delay(IdleTimeoutMs)
+    state.isIdle = true
+  }
+
+  return state
+}

package/android/src/debug/java/expo/modules/devmenu/fab/FabUtils.kt

@@ -1,7 +1,5 @@
 package expo.modules.devmenu.fab
 
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.interaction.PressInteraction
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.mutableStateOf
@@ -18,7 +16,8 @@ internal fun calculateTargetPosition(
   currentPosition: Offset,
   velocity: PointF,
   bounds: Offset,
-  totalFabWidth: Float
+  totalFabWidth: Float,
+  minY: Float = 0f
 ): Offset {
   // Simulate the bubble keeping the movement momentum
   // I've found that these values feel good (assume that the bubble keeps the momentum for ~100ms)
@@ -32,7 +31,7 @@ internal fun calculateTargetPosition(
   }
   val targetY = currentPosition.y + momentumOffsetY
   val newOffset = Offset(targetX, targetY)
-    .coerceIn(maxX = bounds.x, maxY = bounds.y)
+    .coerceIn(minY = minY, maxX = bounds.x, maxY = bounds.y)
   return newOffset
 }
 
@@ -60,8 +59,3 @@ internal fun <T> rememberPrevious(current: T): T? {
 
   return previousRef.value
 }
-
-internal suspend fun MutableInteractionSource.emitRelease(pressPosition: Offset) {
-  val pressInteraction = PressInteraction.Press(pressPosition)
-  this.emit(PressInteraction.Release(pressInteraction))
-}

package/android/src/debug/java/expo/modules/devmenu/fab/FloatingActionButtonContent.kt

@@ -1,148 +1,141 @@
 package expo.modules.devmenu.fab
 
-import android.annotation.SuppressLint
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.spring
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.scaleOut
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.draw.drawWithContent
 import androidx.compose.ui.draw.scale
 import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.graphics.nativeCanvas
 import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import com.composeunstyled.Icon
+import com.composeunstyled.Text
 import expo.modules.devmenu.R
-import expo.modules.devmenu.compose.newtheme.NewAppTheme
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.delay
+
+private val FabBlue = Color(0xFF007AFF)
 
-@SuppressLint("UnusedBoxWithConstraintsScope")
 @Composable
 fun FloatingActionButtonContent(
   modifier: Modifier = Modifier,
-  interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
-  onRefreshPress: () -> Unit = {},
-  onEllipsisPress: () -> Unit = {}
+  isPressed: Boolean = false,
+  isDragging: Boolean = false,
+  isIdle: Boolean = false
 ) {
-  val pillShape = RoundedCornerShape(percent = 50)
-  val horizontalPadding = 14.dp
-  val verticalPadding = 16.dp
-  val animatedRotation = remember { Animatable(0f) }
-  val animatedScale = remember { Animatable(1f) }
-  val scope = rememberCoroutineScope()
+  val scale by animateFloatAsState(
+    targetValue = if (isPressed && !isDragging) 0.9f else 1f,
+    label = "pressScale"
+  )
+
+  val idleAlpha by animateFloatAsState(
+    targetValue = if (isIdle) 0.5f else 1f,
+    label = "idleAlpha"
+  )
+
+  val idleSaturation by animateFloatAsState(
+    targetValue = if (isIdle) 0f else 1f,
+    label = "idleSaturation"
+  )
+
+  var showLabel by remember { mutableStateOf(true) }
 
-  BoxWithConstraints(
+  LaunchedEffect(Unit) {
+    delay(10_000)
+    showLabel = false
+  }
+
+  Column(
+    horizontalAlignment = Alignment.CenterHorizontally,
     modifier = modifier
-      .shadow(6.dp, pillShape)
-      .border(
-        width = 1.dp,
-        color = NewAppTheme.colors.border.default,
-        shape = pillShape
-      )
-      .background(
-        color = NewAppTheme.colors.background.default,
-        shape = pillShape
-      )
-      .clip(pillShape)
+      .scale(scale)
+      .graphicsLayer {
+        alpha = idleAlpha
+      }
+      .drawWithContent {
+        val colorMatrix = android.graphics.ColorMatrix()
+        colorMatrix.setSaturation(idleSaturation)
+        val paint = android.graphics.Paint().apply {
+          colorFilter = android.graphics.ColorMatrixColorFilter(colorMatrix)
+        }
+        drawContext.canvas.nativeCanvas.saveLayer(null, paint)
+        drawContent()
+        drawContext.canvas.nativeCanvas.restore()
+      }
   ) {
-    val iconSize = maxWidth - (horizontalPadding * 2)
-
-    Column(
-      verticalArrangement = Arrangement.SpaceBetween,
-      horizontalAlignment = Alignment.CenterHorizontally,
-      modifier = modifier
-        .border(
-          width = 1.dp,
-          color = NewAppTheme.colors.border.default,
-          shape = pillShape
+    Box(
+      contentAlignment = Alignment.Center,
+      modifier = Modifier
+        .shadow(
+          elevation = 8.dp,
+          shape = CircleShape,
+          ambientColor = Color.Black.copy(alpha = 0.4f),
+          spotColor = Color.Black.copy(alpha = 0.4f)
         )
-        .fillMaxSize()
-        .padding(horizontal = horizontalPadding, vertical = verticalPadding)
+        .size(52.dp)
+        .border(4.dp, FabBlue.copy(alpha = 0.3f), CircleShape)
+        .padding(4.dp)
+        .background(FabBlue, CircleShape)
     ) {
       Icon(
-        painter = painterResource(R.drawable.refresh_round_icon),
-        contentDescription = "Refresh",
-        tint = NewAppTheme.colors.icon.tertiary,
-        modifier = Modifier
-          .size(iconSize)
-          .rotate(animatedRotation.value)
-          .clickable(
-            interactionSource = interactionSource,
-            indication = null,
-            onClick = {
-              scope.launch {
-                animatedRotation.animateTo(
-                  targetValue = 360f,
-                  animationSpec = spring(
-                    dampingRatio = Spring.DampingRatioLowBouncy,
-                    stiffness = Spring.StiffnessVeryLow,
-                    visibilityThreshold = 5f
-                  )
-                )
-                onRefreshPress()
-                animatedRotation.snapTo(0f)
-              }
-            }
-          )
+        painter = painterResource(R.drawable.gear_fill),
+        contentDescription = "Tools",
+        tint = Color.White,
+        modifier = Modifier.size(26.dp)
       )
+    }
 
-      Icon(
-        painter = painterResource(R.drawable.ellipsis_horizontal),
-        contentDescription = "Open Dev Menu",
-        tint = NewAppTheme.colors.icon.tertiary,
+    AnimatedVisibility(
+      visible = showLabel,
+      exit = fadeOut() + scaleOut()
+    ) {
+      Box(
         modifier = Modifier
-          .size(iconSize)
-          .scale(animatedScale.value)
-          .clickable(
-            interactionSource = interactionSource,
-            // TODO @behenate: Figure out how to use ripple instead of scale animation with an interaction source shared by both buttons
-            indication = null,
-            onClick = {
-              onEllipsisPress()
-              scope.launch {
-                animatedScale.snapTo(0.9f)
-                animatedScale.animateTo(
-                  targetValue = 1f,
-                  animationSpec = spring(
-                    dampingRatio = Spring.DampingRatioMediumBouncy,
-                    stiffness = Spring.StiffnessLow
-                  )
-                )
-              }
-            }
-          )
-      )
+          .padding(top = 6.dp)
+          .shadow(4.dp, RoundedCornerShape(percent = 50))
+          .background(Color.White, RoundedCornerShape(percent = 50))
+          .padding(horizontal = 10.dp, vertical = 4.dp)
+      ) {
+        Text(
+          text = "Tools",
+          color = Color.Black,
+          fontSize = 11.sp,
+          fontWeight = FontWeight.SemiBold
+        )
+      }
     }
   }
 }
 
 @Preview(showBackground = true)
 @Composable
-fun VerticalActionPillPreview() {
-  // You would typically wrap this in your app's theme.
-  // Using a basic Column for positioning in the preview.
+fun FloatingActionButtonContentPreview() {
   Column(
-    modifier = Modifier
-      .padding(32.dp)
-      .background(NewAppTheme.colors.border.default),
+    modifier = Modifier.padding(32.dp),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
-    FloatingActionButtonContent(modifier = Modifier.size(46.dp, 92.dp))
+    FloatingActionButtonContent()
   }
 }

package/android/src/debug/java/expo/modules/devmenu/fab/MovableFloatingActionButton.kt

@@ -2,16 +2,13 @@ package expo.modules.devmenu.fab
 
 import android.annotation.SuppressLint
 import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.AnimationVector2D
 import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.VectorConverter
 import androidx.compose.animation.core.spring
+import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.foundation.gestures.awaitFirstDown
 import androidx.compose.foundation.gestures.drag
-import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.fillMaxSize
@@ -34,12 +31,10 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 
-private val FabDefaultSize = DpSize(48.dp, 92.dp)
+private val FabDefaultSize = DpSize(72.dp, 94.dp)
 private val Margin = 16.dp
 private const val ClickDragTolerance = 40f
 
-private typealias AnimatableOffset = Animatable<Offset, AnimationVector2D>
-
 /**
  * A floating action button that can be dragged across the screen and springs to the
  * nearest horizontal edge when released. A tap triggers the onClick action.
@@ -51,8 +46,7 @@ fun MovableFloatingActionButton(
   modifier: Modifier = Modifier,
   fabSize: DpSize = FabDefaultSize,
   margin: Dp = Margin,
-  onRefreshPress: () -> Unit = {},
-  onOpenMenuPress: () -> Unit = {}
+  onPress: () -> Unit = {}
 ) {
   BoxWithConstraints(modifier = modifier.fillMaxSize()) {
     val totalFabSize = DpSize(fabSize.width + margin * 2, fabSize.height + margin * 2)
@@ -63,6 +57,8 @@ fun MovableFloatingActionButton(
       x = constraints.maxWidth - totalFabSizePx.x,
       y = constraints.maxHeight - totalFabSizePx.y
     )
+
+    val fab = rememberFabState(bounds, totalFabSizePx)
     val isFabDisplayable = state.showFab &&
       !state.isInPictureInPictureMode &&
       bounds.x >= 0f &&
@@ -70,27 +66,48 @@ fun MovableFloatingActionButton(
 
     val previousBounds = rememberPrevious(bounds)
     val velocityTracker = remember { ExpoVelocityTracker() }
-    val defaultOffset = bounds.copy(y = bounds.y * 0.75f)
-    val animatedOffset = remember { Animatable(defaultOffset, Offset.VectorConverter) }
-    val pillInteractionSource = remember { MutableInteractionSource() }
+
+    LaunchedEffect(state.isOpen) {
+      if (state.isOpen) {
+        fab.restingOffset = fab.animatedOffset.value
+        val isOnLeftSide = fab.animatedOffset.value.x < fab.bounds.safe.x / 2f
+        val offScreenX = if (isOnLeftSide) -totalFabSizePx.x else constraints.maxWidth.toFloat()
+        fab.animatedOffset.animateTo(
+          targetValue = Offset(offScreenX, fab.animatedOffset.value.y),
+          animationSpec = tween(durationMillis = 500)
+        )
+        fab.isOffScreen = true
+      } else if (fab.isOffScreen) {
+        fab.animatedOffset.animateTo(
+          targetValue = fab.restingOffset,
+          animationSpec = spring(
+            dampingRatio = 0.6f,
+            stiffness = Spring.StiffnessLow
+          )
+        )
+        fab.isOffScreen = false
+        fab.onInteraction()
+      }
+    }
 
     LaunchedEffect(bounds.x, bounds.y, isFabDisplayable) {
       if (!isFabDisplayable) {
         return@LaunchedEffect
       }
       previousBounds?.let {
-        val oldX = animatedOffset.value.x
-        val oldY = animatedOffset.value.y
-        val newX = (oldX / previousBounds.x) * bounds.x
-        val newY = (oldY / previousBounds.y) * bounds.y
+        val oldX = fab.animatedOffset.value.x
+        val oldY = fab.animatedOffset.value.y
+        val newX = (oldX / previousBounds.x) * fab.bounds.safe.x
+        val newY = (oldY / previousBounds.y) * fab.bounds.safe.y
         val newTarget = calculateTargetPosition(
           currentPosition = Offset(newX, newY),
           velocity = ExpoVelocityTracker.PointF(0f, 0f),
-          bounds = bounds,
-          totalFabWidth = totalFabSizePx.x
+          bounds = fab.bounds.safe,
+          totalFabWidth = totalFabSizePx.x,
+          minY = fab.bounds.safeMinY
         )
 
-        animatedOffset.snapTo(newTarget)
+        fab.animatedOffset.snapTo(newTarget)
       }
     }
 
@@ -101,7 +118,7 @@ fun MovableFloatingActionButton(
     ) {
       Box(
         modifier = Modifier
-          .offset { animatedOffset.value.toIntOffset() }
+          .offset { fab.animatedOffset.value.toIntOffset() }
           .size(totalFabSize)
           .padding(margin)
           .pointerInput(bounds.x, bounds.y) {
@@ -110,33 +127,40 @@ fun MovableFloatingActionButton(
                 awaitPointerEventScope {
                   val firstDown = awaitFirstDown(requireUnconsumed = false)
                   val pointerId = firstDown.id
+                  fab.isPressed = true
+                  fab.isDragging = false
+                  fab.onInteraction()
 
                   launch {
-                    animatedOffset.stop()
+                    fab.animatedOffset.stop()
                   }
 
                   var dragDistance = 0f
-                  var dragOffset = animatedOffset.value
+                  var dragOffset = fab.animatedOffset.value
 
                   drag(pointerId) { change ->
                     dragOffset = (dragOffset + change.positionChange())
-                      .coerceIn(maxX = bounds.x, maxY = bounds.y)
+                      .coerceIn(minX = -fab.bounds.halfFab.x, maxX = fab.bounds.drag.x, minY = -fab.bounds.halfFab.y, maxY = fab.bounds.drag.y)
                     dragDistance += change.positionChange().getDistance()
                     velocityTracker.registerPosition(dragOffset.x, dragOffset.y)
 
                     if (dragDistance > ClickDragTolerance) {
+                      fab.isDragging = true
                       launch {
-                        animatedOffset.animateTo(dragOffset)
+                        fab.animatedOffset.animateTo(dragOffset)
                       }
                     }
                   }
+
+                  fab.isPressed = false
+                  fab.isDragging = false
+                  fab.onInteraction()
+
                   if (dragDistance < ClickDragTolerance) {
                     velocityTracker.clear()
-                    launch {
-                      pillInteractionSource.emitRelease(firstDown.position)
-                    }
+                    onPress()
                   } else {
-                    handleRelease(animatedOffset, velocityTracker, totalFabSizePx, bounds)
+                    handleRelease(fab, velocityTracker, totalFabSizePx)
                   }
                 }
               }
@@ -144,9 +168,9 @@ fun MovableFloatingActionButton(
           }
       ) {
         FloatingActionButtonContent(
-          interactionSource = pillInteractionSource,
-          onRefreshPress = onRefreshPress,
-          onEllipsisPress = onOpenMenuPress,
+          isPressed = fab.isPressed,
+          isDragging = fab.isDragging,
+          isIdle = fab.isIdle,
           modifier = Modifier.fillMaxSize()
         )
       }
@@ -158,17 +182,16 @@ fun MovableFloatingActionButton(
  * Handles the release of the FAB, calculating momentum and animating it to the nearest edge.
  */
 private fun CoroutineScope.handleRelease(
-  animatedOffset: AnimatableOffset,
+  fab: FabState,
   velocityTracker: ExpoVelocityTracker,
-  totalFabSizePx: Offset,
-  bounds: Offset
+  totalFabSizePx: Offset
 ) {
   val velocity = velocityTracker.calculateVelocity()
-  val newOffset = calculateTargetPosition(animatedOffset.value, velocity, bounds, totalFabSizePx.x)
+  val newOffset = calculateTargetPosition(fab.animatedOffset.value, velocity, fab.bounds.safe, totalFabSizePx.x, fab.bounds.safeMinY)
 
   velocityTracker.clear()
   launch {
-    animatedOffset.animateTo(
+    fab.animatedOffset.animateTo(
       targetValue = newOffset,
       animationSpec = spring(
         dampingRatio = 0.65f,
@@ -176,5 +199,6 @@ private fun CoroutineScope.handleRelease(
       ),
       initialVelocity = Offset(velocity.x, velocity.y)
     )
+    fab.savePosition(newOffset)
   }
 }

package/android/src/debug/res/drawable/gear_fill.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+  <path
+      android:fillColor="#FFFFFF"
+      android:pathData="M19.14,12.94c0.04,-0.3 0.06,-0.61 0.06,-0.94c0,-0.32 -0.02,-0.64 -0.07,-0.94l2.03,-1.58c0.18,-0.14 0.23,-0.41 0.12,-0.61l-1.92,-3.32c-0.12,-0.22 -0.37,-0.29 -0.59,-0.22l-2.39,0.96c-0.5,-0.38 -1.03,-0.7 -1.62,-0.94L14.4,2.81c-0.04,-0.24 -0.24,-0.41 -0.48,-0.41h-3.84c-0.24,0 -0.43,0.17 -0.47,0.41L9.25,5.35C8.66,5.59 8.12,5.92 7.63,6.29L5.24,5.33c-0.22,-0.08 -0.47,0 -0.59,0.22L2.74,8.87C2.62,9.08 2.66,9.34 2.86,9.48l2.03,1.58C4.84,11.36 4.8,11.69 4.8,12s0.02,0.64 0.07,0.94l-2.03,1.58c-0.18,0.14 -0.23,0.41 -0.12,0.61l1.92,3.32c0.12,0.22 0.37,0.29 0.59,0.22l2.39,-0.96c0.5,0.38 1.03,0.7 1.62,0.94l0.36,2.54c0.05,0.24 0.24,0.41 0.48,0.41h3.84c0.24,0 0.44,-0.17 0.47,-0.41l0.36,-2.54c0.59,-0.24 1.13,-0.56 1.62,-0.94l2.39,0.96c0.22,0.08 0.47,0 0.59,-0.22l1.92,-3.32c0.12,-0.22 0.07,-0.47 -0.12,-0.61L19.14,12.94zM12,15.6c-1.98,0 -3.6,-1.62 -3.6,-3.6s1.62,-3.6 3.6,-3.6s3.6,1.62 3.6,3.6S13.98,15.6 12,15.6z"/>
+</vector>

package/ios/FAB/DevMenuFABView.swift

@@ -135,6 +135,15 @@ struct DevMenuFABView: View {
   @State private var isPressed = false
   @State private var dragStartPosition: CGPoint = .zero
 
+  // Get safe area from window since .ignoresSafeArea() may zero out geometry values
+  private var windowSafeArea: UIEdgeInsets {
+    guard let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+          let window = windowScene.windows.first else {
+      return .zero
+    }
+    return window.safeAreaInsets
+  }
+
   private let dragSpring: Animation = .spring(
     response: 0.25,
     dampingFraction: 0.85,
@@ -147,7 +156,13 @@ struct DevMenuFABView: View {
 
   var body: some View {
     GeometryReader { geometry in
-      let safeArea = geometry.safeAreaInsets
+      // Use window safe area - geometry values may be incorrect initially or due to .ignoresSafeArea()
+      let safeArea = EdgeInsets(
+        top: windowSafeArea.top,
+        leading: windowSafeArea.left,
+        bottom: windowSafeArea.bottom,
+        trailing: windowSafeArea.right
+      )
 
       FabPill(isPressed: $isPressed, isDragging: $isDragging)
         .frame(width: fabSize.width, height: fabSize.height)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-dev-menu",
-  "version": "55.0.9",
+  "version": "55.0.11",
   "description": "Expo/React Native module with the developer menu.",
   "main": "build/DevMenu.js",
   "types": "build/DevMenu.d.ts",
@@ -39,7 +39,7 @@
     "@babel/preset-typescript": "^7.7.4",
     "@testing-library/react-native": "^13.3.0",
     "babel-plugin-module-resolver": "^5.0.0",
-    "babel-preset-expo": "~55.0.8",
+    "babel-preset-expo": "~55.0.10",
     "expo-module-scripts": "^55.0.2",
     "react": "19.2.0",
     "react-native": "0.83.2"
@@ -47,5 +47,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "39a7a009e215eb71a112f4a20dba2d471ab21108"
+  "gitHead": "2d0f6652717a0c88f4fb82b7b288bfcbfe0f2373"
 }