expo-modules-core 56.0.20 → 56.0.22

package/CHANGELOG.md

@@ -10,6 +10,24 @@
 
 ### 💡 Others
 
+## 56.0.22 — 2026-07-23
+
+### 🎉 New features
+
+- [iOS] `ExpoSwiftUI.IgnoreSafeArea` that ignores the device and container safe area regions. ([#47619](https://github.com/expo/expo/pull/47619) by [@nishan](https://github.com/intergalacticspacehighway))
+
+### 🐛 Bug fixes
+
+- [iOS] Fix SwiftUI-hosted React views corrupting Fabric rendering after unmount: `UIViewHost` now hands SwiftUI a disposable isolation container instead of the React-managed view, so leaked `autoresizingMask`/frame/visibility mutations (including deferred ones from `Menu`/`ContextMenu` teardown) can no longer zero-size or hide unrelated components. ([#47707](https://github.com/expo/expo/pull/47707) by [@cvburgess](https://github.com/cvburgess))
+- [Android] Fix Compose-hosted React Native content (e.g. the `@expo/ui` community `BottomSheet`) keeping a stale size after a rapid resize such as dismissing the software keyboard, leaving bottom-anchored content stranded mid-view. The final shadow node size update could be dropped when its one-shot pre-draw listener fired without a following draw pass; the pending update is now also posted to the view so the latest size always flushes. ([#47778](https://github.com/expo/expo/issues/47778) by [@zayyartun-cgm](https://github.com/zayyartun-cgm)) ([#47810](https://github.com/expo/expo/pull/47810) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+
+## 56.0.21 — 2026-07-15
+
+### 🐛 Bug fixes
+
+- [Android] Support `android.graphics.Color` arguments and props on Android below API 26 by adding a `ColorCompat` wrapper, since the class-based `Color` API (`Color.valueOf` and the float accessors) only exists on API 26 and above. ([#47546](https://github.com/expo/expo/issues/47546) by [@anasvemmully](https://github.com/anasvemmully)) ([#47575](https://github.com/expo/expo/pull/47575) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+- [iOS] Fix a `SIGABRT` crash when unmounting a SwiftUI view tree that still holds a focused field nested inside a container (e.g. an `@expo/ui` `TextField` inside an `HStack` or `LabeledContent` in a `Form`), such as dismissing a modal from a native header button. Resigning the first responder on unmount now recurses through the removed subtree instead of only handling a top-level focusable view. ([#47682](https://github.com/expo/expo/issues/47682) by [@andreavrr](https://github.com/andreavrr)) ([#47709](https://github.com/expo/expo/pull/47709) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+
 ## 56.0.20 — 2026-07-07
 
 _This version does not introduce any user-facing changes._

package/android/build.gradle

@@ -27,7 +27,7 @@ if (shouldIncludeCompose) {
 }
 
 group = 'host.exp.exponent'
-version = '56.0.20'
+version = '56.0.22'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -94,7 +94,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "56.0.20"
+    versionName "56.0.22"
     buildConfigField "String", "EXPO_MODULES_CORE_VERSION", "\"${versionName}\""
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true"
 

package/android/src/main/java/expo/modules/kotlin/types/ColorCompat.kt

@@ -0,0 +1,148 @@
+package expo.modules.kotlin.types
+
+import android.graphics.Color
+import android.os.Build
+import androidx.annotation.ColorInt
+import androidx.annotation.RequiresApi
+
+/**
+ * Compatibility wrapper for [Color] instance APIs added in API 26.
+ *
+ * Remove this class when expo-modules-core minSdkVersion is 26 or higher. Android Lint's
+ * ObsoleteSdkInt check should flag these version gates after that bump.
+ */
+class ColorCompat private constructor() {
+  companion object {
+    private val defaultLegacyColor = LegacyColor(
+      red = 0f,
+      green = 0f,
+      blue = 0f,
+      alpha = 1f,
+      argb = Color.BLACK
+    )
+
+    @JvmStatic
+    fun valueOf(@ColorInt color: Int): Color {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.valueOf(color)
+      }
+      return LegacyColor(
+        red = Color.red(color) / 255f,
+        green = Color.green(color) / 255f,
+        blue = Color.blue(color) / 255f,
+        alpha = Color.alpha(color) / 255f,
+        argb = color
+      )
+    }
+
+    @JvmStatic
+    fun valueOf(red: Float, green: Float, blue: Float, alpha: Float): Color {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.valueOf(red, green, blue, alpha)
+      }
+      val saturatedRed = red.coerceIn(0f, 1f)
+      val saturatedGreen = green.coerceIn(0f, 1f)
+      val saturatedBlue = blue.coerceIn(0f, 1f)
+      val saturatedAlpha = alpha.coerceIn(0f, 1f)
+      return LegacyColor(
+        red = saturatedRed,
+        green = saturatedGreen,
+        blue = saturatedBlue,
+        alpha = saturatedAlpha,
+        argb = Color.argb(
+          toColorComponent(saturatedAlpha),
+          toColorComponent(saturatedRed),
+          toColorComponent(saturatedGreen),
+          toColorComponent(saturatedBlue)
+        )
+      )
+    }
+
+    @JvmStatic
+    fun toArgb(color: Color): Int {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.toArgb(color)
+      }
+      return legacyColor(color).argb
+    }
+
+    @JvmStatic
+    fun alpha(color: Color): Float {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.alpha(color)
+      }
+      return legacyColor(color).alpha
+    }
+
+    @JvmStatic
+    fun red(color: Color): Float {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.red(color)
+      }
+      return legacyColor(color).red
+    }
+
+    @JvmStatic
+    fun green(color: Color): Float {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.green(color)
+      }
+      return legacyColor(color).green
+    }
+
+    @JvmStatic
+    fun blue(color: Color): Float {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.blue(color)
+      }
+      return legacyColor(color).blue
+    }
+
+    private fun legacyColor(color: Color): LegacyColor {
+      return color as? LegacyColor ?: defaultLegacyColor
+    }
+
+    private fun toColorComponent(component: Float): Int {
+      return (component * 255f + 0.5f).toInt()
+    }
+  }
+
+  private class LegacyColor(
+    val red: Float,
+    val green: Float,
+    val blue: Float,
+    val alpha: Float,
+    @ColorInt val argb: Int
+  ) : Color()
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private object Api26Impl {
+    fun valueOf(@ColorInt color: Int): Color {
+      return Color.valueOf(color)
+    }
+
+    fun valueOf(red: Float, green: Float, blue: Float, alpha: Float): Color {
+      return Color.valueOf(red, green, blue, alpha)
+    }
+
+    fun toArgb(color: Color): Int {
+      return color.toArgb()
+    }
+
+    fun alpha(color: Color): Float {
+      return color.alpha()
+    }
+
+    fun red(color: Color): Float {
+      return color.red()
+    }
+
+    fun green(color: Color): Float {
+      return color.green()
+    }
+
+    fun blue(color: Color): Float {
+      return color.blue()
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/types/ColorTypeConverter.kt

@@ -1,8 +1,6 @@
 package expo.modules.kotlin.types
 
 import android.graphics.Color
-import android.os.Build
-import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableType
 import expo.modules.kotlin.AppContext
@@ -262,7 +260,7 @@ private fun hslToColor(h: Float, s: Float, l: Float, a: Float): Color {
     g = hueToRgb(p, q, hue)
     b = hueToRgb(p, q, hue - 1f / 3f)
   }
-  return Color.valueOf(r.coerceIn(0f, 1f), g.coerceIn(0f, 1f), b.coerceIn(0f, 1f), a)
+  return ColorCompat.valueOf(r.coerceIn(0f, 1f), g.coerceIn(0f, 1f), b.coerceIn(0f, 1f), a)
 }
 
 private fun hwbToColor(h: Float, w: Float, b: Float, a: Float): Color {
@@ -272,10 +270,10 @@ private fun hwbToColor(h: Float, w: Float, b: Float, a: Float): Color {
   val white = if (sum > 1f) ww / sum else ww
   val black = if (sum > 1f) bb / sum else bb
   val rgb = hslToColor(h, 1f, 0.5f, 1f)
-  val r = rgb.red() * (1f - white - black) + white
-  val g = rgb.green() * (1f - white - black) + white
-  val bl = rgb.blue() * (1f - white - black) + white
-  return Color.valueOf(r.coerceIn(0f, 1f), g.coerceIn(0f, 1f), bl.coerceIn(0f, 1f), a)
+  val r = ColorCompat.red(rgb) * (1f - white - black) + white
+  val g = ColorCompat.green(rgb) * (1f - white - black) + white
+  val bl = ColorCompat.blue(rgb) * (1f - white - black) + white
+  return ColorCompat.valueOf(r.coerceIn(0f, 1f), g.coerceIn(0f, 1f), bl.coerceIn(0f, 1f), a)
 }
 
 /**
@@ -292,7 +290,7 @@ private fun parseHexColor(value: String): Color? {
     val r = match.groupValues[1].repeat(2).toInt(16)
     val g = match.groupValues[2].repeat(2).toInt(16)
     val b = match.groupValues[3].repeat(2).toInt(16)
-    return Color.valueOf(r / 255f, g / 255f, b / 255f, 1f)
+    return ColorCompat.valueOf(r / 255f, g / 255f, b / 255f, 1f)
   }
 
   // #RGBA → #RRGGBBAA
@@ -301,7 +299,7 @@ private fun parseHexColor(value: String): Color? {
     val g = match.groupValues[2].repeat(2).toInt(16)
     val b = match.groupValues[3].repeat(2).toInt(16)
     val a = match.groupValues[4].repeat(2).toInt(16)
-    return Color.valueOf(r / 255f, g / 255f, b / 255f, a / 255f)
+    return ColorCompat.valueOf(r / 255f, g / 255f, b / 255f, a / 255f)
   }
 
   // #RRGGBBAA (CSS byte order: alpha is last, unlike Android's #AARRGGBB)
@@ -311,7 +309,7 @@ private fun parseHexColor(value: String): Color? {
     val g = ((hex shr 16) and 0xFF).toInt()
     val b = ((hex shr 8) and 0xFF).toInt()
     val a = (hex and 0xFF).toInt()
-    return Color.valueOf(r / 255f, g / 255f, b / 255f, a / 255f)
+    return ColorCompat.valueOf(r / 255f, g / 255f, b / 255f, a / 255f)
   }
 
   return null
@@ -329,7 +327,7 @@ private fun parseCssColorFunction(value: String): Color? {
     val g = parseRgbComponent(match.groupValues[2])
     val b = parseRgbComponent(match.groupValues[3])
     val a = parseAlpha(match.groupValues[4].ifEmpty { null })
-    return Color.valueOf(r, g, b, a)
+    return ColorCompat.valueOf(r, g, b, a)
   }
 
   // hsl/hsla
@@ -355,7 +353,6 @@ private fun parseCssColorFunction(value: String): Color? {
 
 // endregion
 
-@RequiresApi(Build.VERSION_CODES.O)
 class ColorTypeConverter : DynamicAwareTypeConverters<Color>() {
   override fun convertFromDynamic(value: Dynamic, context: AppContext?, forceConversion: Boolean): Color {
     return when (value.type) {
@@ -389,18 +386,18 @@ class ColorTypeConverter : DynamicAwareTypeConverters<Color>() {
       throw InvalidColorComponentsException(value.size)
     }
     val alpha = value.getOrNull(3) ?: 1.0
-    return Color.valueOf(value[0].toFloat(), value[1].toFloat(), value[2].toFloat(), alpha.toFloat())
+    return ColorCompat.valueOf(value[0].toFloat(), value[1].toFloat(), value[2].toFloat(), alpha.toFloat())
   }
 
   private fun colorFromInt(value: Int): Color {
-    return Color.valueOf(value)
+    return ColorCompat.valueOf(value)
   }
 
   private fun colorFromString(value: String): Color {
     val normalizedValue = value.trim().lowercase()
     val colorFromString = namedColors[normalizedValue]
     if (colorFromString != null) {
-      return Color.valueOf(
+      return ColorCompat.valueOf(
         colorFromString[0],
         colorFromString[1],
         colorFromString[2],
@@ -411,12 +408,12 @@ class ColorTypeConverter : DynamicAwareTypeConverters<Color>() {
     if (normalizedValue.startsWith('#')) {
       parseHexColor(normalizedValue)?.let { return it }
       // Fall through to toColorInt() for standard #RRGGBB / #AARRGGBB
-      return Color.valueOf(normalizedValue.toColorInt())
+      return ColorCompat.valueOf(normalizedValue.toColorInt())
     }
 
     parseCssColorFunction(normalizedValue)?.let { return it }
 
-    return Color.valueOf(normalizedValue.toColorInt())
+    return ColorCompat.valueOf(normalizedValue.toColorInt())
   }
 
   override fun getCppRequiredTypes(): ExpectedType =

package/android/src/main/java/expo/modules/kotlin/types/TypeConverterProvider.kt

@@ -275,6 +275,8 @@ object TypeConverterProviderImpl : TypeConverterProvider {
 
       Any::class.java to AnyTypeConverter(),
 
+      Color::class.java to ColorTypeConverter(),
+
       // Unit converter doesn't care about nullability.
       // It will always return Unit
       Unit::class.java to UnitTypeConverter(),
@@ -285,7 +287,6 @@ object TypeConverterProviderImpl : TypeConverterProvider {
     if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
       return converters + mapOf(
         Path::class.java to PathTypeConverter(),
-        Color::class.java to ColorTypeConverter(),
         LocalDate::class.java to DateTypeConverter()
       )
     }

package/android/src/main/java/expo/modules/kotlin/views/ShadowNodeProxy.kt

@@ -10,6 +10,7 @@ class ShadowNodeProxy(expoView: ExpoView) {
 
   private var pendingFlush: ((stateWrapper: Any) -> Unit)? = null
   private var preDrawListener: ViewTreeObserver.OnPreDrawListener? = null
+  private val flushRunnable = Runnable { drainPendingFlush() }
 
   // Schedule in predraw listener to avoid early return in re-entrancy
   // We have a proper fix [here](https://github.com/facebook/react-native/pull/56311)
@@ -29,25 +30,37 @@ class ShadowNodeProxy(expoView: ExpoView) {
 
   private fun scheduleFlush(flush: (stateWrapper: Any) -> Unit) {
     pendingFlush = flush
-    val observer = weakExpoView.get()?.viewTreeObserver?.takeIf { it.isAlive } ?: return
-
-    // Remove the previous attached listener
-    preDrawListener?.let(observer::removeOnPreDrawListener)
-
-    val listener = object : ViewTreeObserver.OnPreDrawListener {
-      override fun onPreDraw(): Boolean {
-        preDrawListener = null
-        // The view is attached while drawing, so this re-fetch returns the same
-        // observer that is dispatching us. removeOnPreDrawListener throws on a dead
-        // observer, hence the isAlive guard.
-        weakExpoView.get()?.viewTreeObserver?.takeIf { it.isAlive }?.removeOnPreDrawListener(this)
-        val flushNow = pendingFlush
-        pendingFlush = null
-        weakExpoView.get()?.stateWrapper?.let { flushNow?.invoke(it) }
-        return true
+    val view = weakExpoView.get() ?: return
+    val observer = view.viewTreeObserver?.takeIf { it.isAlive }
+
+    if (observer != null) {
+      // Remove the previous attached listener
+      preDrawListener?.let(observer::removeOnPreDrawListener)
+
+      val listener = object : ViewTreeObserver.OnPreDrawListener {
+        override fun onPreDraw(): Boolean {
+          preDrawListener = null
+          // The view is attached while drawing, so this re-fetch returns the same
+          // observer that is dispatching us. removeOnPreDrawListener throws on a dead
+          // observer, hence the isAlive guard.
+          weakExpoView.get()?.viewTreeObserver?.takeIf { it.isAlive }?.removeOnPreDrawListener(this)
+          drainPendingFlush()
+          return true
+        }
       }
+      preDrawListener = listener
+      observer.addOnPreDrawListener(listener)
     }
-    preDrawListener = listener
-    observer.addOnPreDrawListener(listener)
+
+    // Predraw listener do not get called for each keyboard transition event so we add a fallback flush to be called here
+    // https://github.com/expo/expo/issues/47778
+    view.removeCallbacks(flushRunnable)
+    view.post(flushRunnable)
+  }
+
+  private fun drainPendingFlush() {
+    val flushNow = pendingFlush ?: return
+    pendingFlush = null
+    weakExpoView.get()?.stateWrapper?.let { flushNow.invoke(it) }
   }
 }

package/ios/Core/Views/SwiftUI/ExpoSwiftUI.swift

@@ -19,6 +19,18 @@ extension ExpoSwiftUI {
     func forceResignFirstResponder()
   }
 
+  /**
+   Protocol for virtual views that can resign the first responder anywhere within their subtree,
+   not just on the view itself. Unlike `FocusableView`, this walks nested children so a focused
+   field wrapped in a container (e.g. a `TextField` inside an `HStack` or `LabeledContent`) is
+   also blurred on unmount, which `FocusableView` alone would miss.
+   See https://github.com/expo/expo/issues/47682
+   */
+  internal protocol FocusableViewContainer {
+    @MainActor
+    func resignFirstResponderInSubtree()
+  }
+
   /**
    Protocol for wrapper views (e.g., UIBaseView) that wrap an inner view.
    Used by DynamicSwiftUIViewType to resolve the underlying view through wrapper layers.

package/ios/Core/Views/SwiftUI/SwiftUIHostingView.swift

@@ -60,11 +60,6 @@ extension ExpoSwiftUI {
      */
     private let hostingController: UIHostingController<AnyView>
 
-    /**
-     Tracks whether safe area has been configured (can only be set once on mount)
-     */
-    private var hasSafeAreaBeenConfigured = false
-
     /**
      Initializes a SwiftUI hosting view with the given SwiftUI view type.
      */
@@ -121,11 +116,8 @@ extension ExpoSwiftUI {
         log.error("Updating props for \(ContentView.self) has failed: \(error.localizedDescription)")
       }
 
-      if !hasSafeAreaBeenConfigured,
-         let safeAreaProps = props as? SafeAreaControllable,
-         let ignoreSafeArea = safeAreaProps.ignoreSafeArea {
-        hostingController.disableSafeArea(ignoreSafeArea)
-        hasSafeAreaBeenConfigured = true
+      if let safeAreaProps = props as? SafeAreaControllable {
+        hostingController.setSafeAreaRegions(ignoring: safeAreaProps.ignoreSafeArea)
       }
     }
 
@@ -260,45 +252,26 @@ extension ExpoSwiftUI {
 }
 
 extension UIHostingController {
-  func disableSafeArea(_ mode: ExpoSwiftUI.IgnoreSafeArea) {
-    if #available(iOS 16.4, tvOS 16.4, macOS 13.3, *) {
+  /// Applies the `ignoreSafeArea` mode reactively, restoring the default safe area when `nil` so
+  /// clearing the prop re-enables the safe area without an app reload.
+  func setSafeAreaRegions(ignoring mode: ExpoSwiftUI.IgnoreSafeArea?) {
+    // `safeAreaRegions` needs iOS 16.4+; the precompiled xcframework targets 16.0, so no-op below it.
+    guard #available(iOS 16.4, tvOS 16.4, macOS 13.3, *) else {
+      return
+    }
+    var regions: SafeAreaRegions = .all
+    if let mode {
       switch mode {
       case .all:
-        self.safeAreaRegions.remove(.all)
+        regions = []
+      case .container:
+        regions.remove(.container)
       case .keyboard:
-        self.safeAreaRegions.remove(.keyboard)
-      }
-    } else {
-      // For older versions
-      // https://gist.github.com/steipete/da72299613dcc91e8d729e48b4bb582c
-      // https://developer.apple.com/forums/thread/658432
-      guard let viewClass = object_getClass(view) else { return }
-
-      let suffix = mode == .all ? "_IgnoresSafeArea" : "_IgnoresKeyboard"
-      let viewSubclassName = String(cString: class_getName(viewClass)).appending(suffix)
-      if let viewSubclass = NSClassFromString(viewSubclassName) {
-          object_setClass(view, viewSubclass)
-      } else {
-          guard let viewClassNameUtf8 = (viewSubclassName as NSString).utf8String else { return }
-          guard let viewSubclass = objc_allocateClassPair(viewClass, viewClassNameUtf8, 0) else { return }
-
-          if mode == .all,
-             let method = class_getInstanceMethod(UIView.self, #selector(getter: UIView.safeAreaInsets)) {
-              let safeAreaInsets: @convention(block) (AnyObject) -> UIEdgeInsets = { _ in
-                  return .zero
-              }
-              class_addMethod(viewSubclass, #selector(getter: UIView.safeAreaInsets),
-                              imp_implementationWithBlock(safeAreaInsets), method_getTypeEncoding(method))
-          }
-
-          if let method = class_getInstanceMethod(viewClass, NSSelectorFromString("keyboardWillShowWithNotification:")) {
-              let keyboardWillShow: @convention(block) (AnyObject, AnyObject) -> Void = { _, _ in }
-              class_addMethod(viewSubclass, NSSelectorFromString("keyboardWillShowWithNotification:"),
-                              imp_implementationWithBlock(keyboardWillShow), method_getTypeEncoding(method))
-          }
-          objc_registerClassPair(viewSubclass)
-          object_setClass(view, viewSubclass)
-        }
+        regions.remove(.keyboard)
       }
     }
+    if safeAreaRegions != regions {
+      safeAreaRegions = regions
+    }
+  }
 }

package/ios/Core/Views/SwiftUI/SwiftUIViewHost.swift

@@ -13,7 +13,6 @@ extension ExpoSwiftUI {
 
     #if os(macOS)
     func makeNSView(context: Context) -> NSView {
-      context.coordinator.originalAutoresizingMask = view.autoresizingMask
       return view
     }
 
@@ -23,8 +22,17 @@ extension ExpoSwiftUI {
     #endif
 
     func makeUIView(context: Context) -> UIView {
-      context.coordinator.originalAutoresizingMask = view.autoresizingMask
+      #if os(macOS)
       return view
+      #else
+      // SwiftUI mutates the view it hosts (autoresizingMask, frame, visibility), sometimes
+      // asynchronously after teardown, corrupting unmounted or recycled React views.
+      // Hand it a disposable container instead. Fixes expo/expo#47706; supersedes the #40604 mitigation.
+      let container = ReactViewIsolationContainer()
+      container.hostedView = view
+      container.addSubview(view)
+      return container
+      #endif
     }
 
     func updateUIView(_ uiView: UIView, context: Context) {
@@ -32,11 +40,7 @@ extension ExpoSwiftUI {
     }
 
     static func dismantleUIView(_ uiView: UIView, coordinator: Coordinator) {
-      // https://github.com/expo/expo/issues/40604
-      // UIViewRepresentable attaches autoresizingMask w+h to the hosted UIView
-      // This causes issues for RN views when they are recycled.
-      // So we restore the original autoresizingMask to avoid issues.
-      uiView.autoresizingMask = coordinator.originalAutoresizingMask
+      // Nothing to restore — SwiftUI only ever touched the container.
     }
 
     func makeCoordinator() -> Coordinator {
@@ -44,7 +48,6 @@ extension ExpoSwiftUI {
     }
 
     class Coordinator {
-      var originalAutoresizingMask: UIView.AutoresizingMask = []
       init() {}
     }
 
@@ -63,5 +66,24 @@ extension ExpoSwiftUI {
     }
   }
 
+  #if !os(macOS)
+  /**
+   Disposable UIView handed to SwiftUI in place of the React-managed view —
+   see `UIViewHost.makeUIView`.
+   */
+  private final class ReactViewIsolationContainer: UIView {
+    weak var hostedView: UIView?
+
+    override func layoutSubviews() {
+      super.layoutSubviews()
+      // Ignore transient zero bounds (initial layout, teardown) — never propagate them.
+      guard let hostedView, hostedView.superview === self, !bounds.isEmpty else {
+        return
+      }
+      if hostedView.frame != bounds {
+        hostedView.frame = bounds
+      }
+    }
+  }
+  #endif
 }
-

package/ios/Core/Views/SwiftUI/SwiftUIViewProps.swift

@@ -7,6 +7,7 @@ internal let GLOBAL_EVENT_NAME = "onGlobalEvent"
 extension ExpoSwiftUI {
   public enum IgnoreSafeArea: String, Enumerable {
     case all
+    case container
     case keyboard
   }
 

package/ios/Core/Views/SwiftUI/SwiftUIVirtualView.swift

@@ -123,7 +123,7 @@ extension ExpoSwiftUI {
     }
 
     override func removeFromSuperview() {
-      virtualViewRemoveFromSuperview(contentView: contentView)
+      resignFirstResponderInSubtree()
       super.removeFromSuperview()
     }
 
@@ -146,6 +146,12 @@ extension ExpoSwiftUI {
   }
 }
 
+extension ExpoSwiftUI.SwiftUIVirtualView: ExpoSwiftUI.FocusableViewContainer {
+  func resignFirstResponderInSubtree() {
+    virtualViewResignFirstResponderInSubtree(contentView: contentView, children: props.children)
+  }
+}
+
 // MARK: - ViewWrapper (Production)
 
 extension ExpoSwiftUI.SwiftUIVirtualView: @MainActor ExpoSwiftUI.ViewWrapper {
@@ -283,7 +289,7 @@ extension ExpoSwiftUI {
     }
 
     override func removeFromSuperview() {
-      virtualViewRemoveFromSuperview(contentView: contentView)
+      resignFirstResponderInSubtree()
       super.removeFromSuperview()
     }
 
@@ -306,6 +312,12 @@ extension ExpoSwiftUI {
   }
 }
 
+extension ExpoSwiftUI.SwiftUIVirtualViewDev: ExpoSwiftUI.FocusableViewContainer {
+  func resignFirstResponderInSubtree() {
+    virtualViewResignFirstResponderInSubtree(contentView: contentView, children: props.children)
+  }
+}
+
 // MARK: - ViewWrapper (Dev)
 
 extension ExpoSwiftUI.SwiftUIVirtualViewDev: @MainActor ExpoSwiftUI.ViewWrapper {
@@ -375,10 +387,14 @@ private func virtualViewUnmountChild<Props: ExpoSwiftUI.ViewProps>(_ childCompon
   }
 }
 
-private func virtualViewRemoveFromSuperview<ContentView: SwiftUI.View>(contentView: ContentView) {
-  // When the view is unmounted, the focus on TextFieldView stays active and it causes a crash, so we blur it here
-  // UIView does something similar to resign the first responder in removeFromSuperview, so we do the same for our virtual view
+@MainActor
+private func virtualViewResignFirstResponderInSubtree<ContentView: SwiftUI.View>(
+  contentView: ContentView, children: [any ExpoSwiftUI.AnyChild]?) {
+  // Mirror UIView.removeFromSuperview, which resigns the first responder for a view and its subviews;
+  // a field left first responder during SwiftUI's teardown crashes. Recurse into children so one
+  // nested in a container (HStack, LabeledContent, …) is resigned too. https://github.com/expo/expo/issues/47682
   if let focusableView = contentView as? any ExpoSwiftUI.FocusableView {
     focusableView.forceResignFirstResponder()
   }
+  children?.forEach { ($0 as? any ExpoSwiftUI.FocusableViewContainer)?.resignFirstResponderInSubtree() }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "56.0.20",
+  "version": "56.0.22",
   "description": "The core of Expo Modules architecture",
   "main": "src/index.ts",
   "types": "build/index.d.ts",
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.3"
   },
-  "gitHead": "f7fcf668bc1a31cccd73275e6c316a0d1253f4c9",
+  "gitHead": "60c9da71e15060aa859a7a6e85f4b14062b761f4",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",