expo-modules-core 57.0.9 → 57.0.11

package/CHANGELOG.md

@@ -10,6 +10,19 @@
 
 ### 💡 Others
 
+## 57.0.11 — 2026-08-14
+
+### 🎉 New features
+
+- [iOS] Added `SceneGeometry.foregroundScene()` for resolving the foregrounded scene without a view. ([#48318](https://github.com/expo/expo/pull/48318) by [@alanjhughes](https://github.com/alanjhughes))
+- [iOS] Added `SceneGeometry` for reading bounds, safe area, display scale and interface orientation from the scene a view belongs to. ([#48168](https://github.com/expo/expo/pull/48168) by [@alanjhughes](https://github.com/alanjhughes))
+
+## 57.0.10 — 2026-08-06
+
+### 💡 Others
+
+- [Android] Ignore already-settled promises. ([#46770](https://github.com/expo/expo/pull/46770) by [@jakex7](https://github.com/jakex7))
+
 ## 57.0.9 — 2026-08-04
 
 ### 🎉 New features
@@ -19,6 +32,7 @@
 
 ### 🐛 Bug fixes
 
+- [iOS] Fixed the tap that closes a SwiftUI menu also pressing the React Native view underneath it. ([#48419](https://github.com/expo/expo/issues/48419) by [@bohdanstefaniuk](https://github.com/bohdanstefaniuk)) ([#48463](https://github.com/expo/expo/pull/48463) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
 - [Android] Fixed hosted Compose views missing layout after reattachment or in-place configuration changes. ([#48370](https://github.com/expo/expo/issues/48370) by [@lujjjh](https://github.com/lujjjh))
 - [iOS] Fixed infinite recursion and `EXC_BAD_ACCESS` when encoding native `Date` values to JavaScript. ([#48239](https://github.com/expo/expo/issues/48239), [#48240](https://github.com/expo/expo/pull/48240) by [@samuelcorsan](https://github.com/samuelcorsan))
 - [iOS] Fixed a stack overflow crash when converting to JavaScript a `Convertible` value that keeps the default `convertResult` implementation, such as `CMTime`. The value now converts to `undefined` and logs a warning. ([#48266](https://github.com/expo/expo/pull/48266) by [@tsapeta](https://github.com/tsapeta))
@@ -88,6 +102,7 @@ _This version does not introduce any user-facing changes._
 - [iOS] `@ExpoModule` now synthesizes the module's JavaScript name from the class name or its `@ExpoModule("CustomName")` argument, so a `Name(…)` definition entry is no longer required. ([#46938](https://github.com/expo/expo/pull/46938) by [@tsapeta](https://github.com/tsapeta))
 - [iOS] Added `SharedObject.native(from:)` that recovers the native shared object paired with a JavaScript object, with a generic overload that returns the concrete subclass directly. ([#47054](https://github.com/expo/expo/pull/47054) by [@tsapeta](https://github.com/tsapeta))
 - [iOS] Added `Module.emit` that sends an event directly to the module's own JavaScript object, mirroring `SharedObject.emit`. Both now share an `EventEmitter` protocol. ([#46555](https://github.com/expo/expo/pull/46555) by [@tsapeta](https://github.com/tsapeta))
+- Add `useReleasingSharedObjectWithLifecycle` hook. ([#46494](https://github.com/expo/expo/pull/46494) by [@behenate](https://github.com/behenate))
 
 ### 🐛 Bug fixes
 

package/android/build.gradle

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

package/android/src/main/java/expo/modules/kotlin/jni/PromiseImpl.kt

@@ -1,11 +1,8 @@
 package expo.modules.kotlin.jni
 
-import expo.modules.BuildConfig
 import expo.modules.core.interfaces.DoNotStrip
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.Promise
-import expo.modules.kotlin.exception.PromiseAlreadySettledException
-import expo.modules.kotlin.logger
 import java.lang.ref.WeakReference
 
 @DoNotStrip
@@ -61,17 +58,7 @@ class PromiseImpl @DoNotStrip internal constructor(
 
   private inline fun checkIfWasSettled(body: () -> Unit) {
     if (wasSettled) {
-      val exception = PromiseAlreadySettledException(fullFunctionName ?: "unknown")
-      val jsLogger = appContextHolder?.get()?.jsLogger
-      // We want to report that a promise was settled twice in the development build.
-      // However, in production, the app should crash.
-      if (BuildConfig.DEBUG && jsLogger != null) {
-        jsLogger.error("Trying to resolve promise that was already settled", exception)
-        logger.error("Trying to resolve promise that was already settled", exception)
-        return
-      }
-
-      throw exception
+      return
     }
 
     body()

package/build/hooks/useReleasingSharedObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useReleasingSharedObject.d.ts","sourceRoot":"","sources":["../../src/hooks/useReleasingSharedObject.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAG5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,SAAS,YAAY,EACzE,OAAO,EAAE,MAAM,aAAa,EAC5B,YAAY,EAAE,cAAc,GAC3B,aAAa,CAoDf"}
+{"version":3,"file":"useReleasingSharedObject.d.ts","sourceRoot":"","sources":["../../src/hooks/useReleasingSharedObject.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAG5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,SAAS,YAAY,EACzE,OAAO,EAAE,MAAM,aAAa,EAC5B,YAAY,EAAE,cAAc,GAC3B,aAAa,CAOf"}

package/build/hooks/useReleasingSharedObjectWithLifecycle.d.ts

@@ -0,0 +1,49 @@
+import type { DependencyList } from 'react';
+import type { SharedObject } from '../ts-declarations/SharedObject';
+export type ReleasingSharedObjectLifecycleContext = {
+    /**
+     * The dependency values from the last committed object lifecycle decision.
+     */
+    previousDependencies: DependencyList;
+    /**
+     * The dependency values from the current render.
+     */
+    dependencies: DependencyList;
+};
+export type ReleasingSharedObjectLifecycle<TSharedObject extends SharedObject> = {
+    /**
+     * Creates the shared object when the hook initializes or when `shouldRecreate` returns `true`.
+     */
+    factory: () => TSharedObject;
+    /**
+     * Called during render when dependencies change to decide whether to replace the object.
+     * Return `false` to keep the current object and handle the dependency change with the `update` function.
+     * When omitted or `true`, dependency changes recreate the object, matching `useReleasingSharedObject`.
+     *
+     * Must be a pure function with no side effects — it is called during the render phase and
+     * React may invoke it more than once with the same inputs.
+     */
+    shouldRecreate?: (object: TSharedObject, context: ReleasingSharedObjectLifecycleContext) => boolean;
+    /**
+     * Called after commit when dependencies changed and `shouldRecreate` returned `false`.
+     * Has no effect unless `shouldRecreate` is provided and returns `false` for the changed
+     * dependencies.
+     *
+     * If the returned `Promise` rejects, the error is logged with `console.error`. Handle errors
+     * inside `update` if specific error handling is needed.
+     *
+     * If a subsequent dependency change or unmount requires the object to be released while an
+     * async update is still in-flight, the release is deferred until the update settles.
+     */
+    update?: (object: TSharedObject, context: ReleasingSharedObjectLifecycleContext) => void | Promise<void>;
+    /**
+     * Releases an object after it has been replaced or when the component unmounts.
+     * When omitted, the object's `release` method is called.
+     */
+    release?: (object: TSharedObject) => void;
+};
+/**
+ * Returns a shared object, delegating dependency changes to lifecycle callbacks.
+ */
+export declare function useReleasingSharedObjectWithLifecycle<TSharedObject extends SharedObject>(lifecycle: ReleasingSharedObjectLifecycle<TSharedObject>, dependencies: DependencyList): TSharedObject;
+//# sourceMappingURL=useReleasingSharedObjectWithLifecycle.d.ts.map

package/build/hooks/useReleasingSharedObjectWithLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReleasingSharedObjectWithLifecycle.d.ts","sourceRoot":"","sources":["../../src/hooks/useReleasingSharedObjectWithLifecycle.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAG5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE,MAAM,MAAM,qCAAqC,GAAG;IAClD;;OAEG;IACH,oBAAoB,EAAE,cAAc,CAAC;IAErC;;OAEG;IACH,YAAY,EAAE,cAAc,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,8BAA8B,CAAC,aAAa,SAAS,YAAY,IAAI;IAC/E;;OAEG;IACH,OAAO,EAAE,MAAM,aAAa,CAAC;IAE7B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,CACf,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,qCAAqC,KAC3C,OAAO,CAAC;IAEb;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,CACP,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,qCAAqC,KAC3C,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1B;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;CAC3C,CAAC;AAcF;;GAEG;AACH,wBAAgB,qCAAqC,CAAC,aAAa,SAAS,YAAY,EACtF,SAAS,EAAE,8BAA8B,CAAC,aAAa,CAAC,EACxD,YAAY,EAAE,cAAc,GAC3B,aAAa,CAqGf"}

package/build/index.d.ts

@@ -17,6 +17,7 @@ export * from './PermissionsInterface';
 export * from './PermissionsHook';
 export * from './Refs';
 export * from './hooks/useReleasingSharedObject';
+export * from './hooks/useReleasingSharedObjectWithLifecycle';
 export * from './reload';
 export { CodedError } from './errors/CodedError';
 export { UnavailabilityError } from './errors/UnavailabilityError';

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,0BAA0B,CAAC;AAClC,OAAO,0BAA0B,CAAC;AAClC,OAAO,YAAY,CAAC;AAEpB,mBAAmB,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEzC,YAAY,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAElC,cAAc,QAAQ,CAAC;AAEvB,cAAc,kCAAkC,CAAC;AACjD,cAAc,UAAU,CAAC;AAGzB,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAGnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAErE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,0BAA0B,CAAC;AAClC,OAAO,0BAA0B,CAAC;AAClC,OAAO,YAAY,CAAC;AAEpB,mBAAmB,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEzC,YAAY,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAElC,cAAc,QAAQ,CAAC;AAEvB,cAAc,kCAAkC,CAAC;AACjD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,UAAU,CAAC;AAGzB,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAGnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAErE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

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

@@ -214,6 +214,14 @@ extension ExpoSwiftUI {
     public override func didMoveToWindow() {
       super.didMoveToWindow()
 
+      #if os(iOS)
+      if let window {
+        // SwiftUI content can open a menu, and UIKit passes the tap that closes it through to
+        // React Native underneath. The gate stops that tap from reaching the view below.
+        SystemMenuTouchGate.install(in: window)
+      }
+      #endif
+
       if window != nil, let parentController = reactViewController() {
         #if !os(macOS)
         if parentController as? UINavigationController == nil && parentController as? UITabBarController == nil {

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

@@ -0,0 +1,127 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#if os(iOS)
+// Also brings in the subclass header, required to set `state` from the touch callbacks
+// and to call `ignore(_:for:)` on React Native's touch handler.
+import UIKit.UIGestureRecognizerSubclass
+
+/**
+  We create a custom gesture recognizer to stop React Root listening to touches when user taps background while Menu is opened.
+  Menu when opened attaches a container view `_UIContextMenuContainerView` to the window.
+  On tapping it, React Root's `RCTSurfaceTouchHandler` also listens to the touch and causes Pressables to fire onPress.
+ */
+internal final class SystemMenuTouchGate: UIGestureRecognizer {
+  init() {
+    super.init(target: nil, action: nil)
+    // Both default to true. Never hold a touch back, and never let React Native's handler see a
+    // reason to cancel: it calls `_cancelTouches` for any outside recognizer that cancels in view.
+    delaysTouchesEnded = false
+    cancelsTouchesInView = false
+  }
+
+  // MARK: - Detecting an open menu
+
+  /**
+   The one view UIKit adds to the window for a presented context menu.
+   */
+  static func isContextMenuContainerClassName(_ className: String) -> Bool {
+    return className == "_UI".appending("ContextMenuContainerView")
+  }
+
+  /**
+    Consider Menu to be open when the container is present, still accepts interaction, and is modal.
+    UIKit turns `isUserInteractionEnabled` off the moment dismissal commits, so taps made during
+    the dismiss animation pass through to the app again. `accessibilityViewIsModal` is how UIKit
+    marks the container as blocking the content behind it — a semantic signal beside the class name.
+   */
+  static func isOpenContextMenuContainer(
+    className: String,
+    isUserInteractionEnabled: Bool,
+    accessibilityViewIsModal: Bool
+  ) -> Bool {
+    return isUserInteractionEnabled && accessibilityViewIsModal && isContextMenuContainerClassName(className)
+  }
+
+  static func isContextMenuContainer(_ view: UIView) -> Bool {
+    return isOpenContextMenuContainer(
+      className: NSStringFromClass(type(of: view)),
+      isUserInteractionEnabled: view.isUserInteractionEnabled,
+      accessibilityViewIsModal: view.accessibilityViewIsModal
+    )
+  }
+
+  /**
+   UIKit adds the container as a direct subview of the window, above the app's content, so only the
+   window's own subviews are worth checking. Anything deeper belongs to the app itself.
+   */
+  static func isShowingContextMenu(
+    in window: UIWindow,
+    isContainer: @MainActor (UIView) -> Bool = SystemMenuTouchGate.isContextMenuContainer
+  ) -> Bool {
+    for subview in window.subviews where isContainer(subview) {
+      return true
+    }
+    return false
+  }
+
+  // MARK: - Cancelling React Native's touches
+
+  /**
+   Matched by name so that this file needs no React Native headers.
+   */
+  static func isSurfaceTouchHandlerClassName(_ className: String) -> Bool {
+    return className == "RCTSurfaceTouchHandler"
+  }
+
+  static func isSurfaceTouchHandler(_ recognizer: UIGestureRecognizer) -> Bool {
+    return isSurfaceTouchHandlerClassName(NSStringFromClass(type(of: recognizer)))
+  }
+
+  /**
+   React Native's touch handlers along the touched view's superview chain.
+   */
+  static func surfaceTouchHandlers(
+    above view: UIView?,
+    isSurfaceTouchHandler: @MainActor (UIGestureRecognizer) -> Bool = SystemMenuTouchGate.isSurfaceTouchHandler
+  ) -> [UIGestureRecognizer] {
+    var handlers: [UIGestureRecognizer] = []
+    var current = view
+    while let view = current {
+      for recognizer in view.gestureRecognizers ?? [] where isSurfaceTouchHandler(recognizer) {
+        handlers.append(recognizer)
+      }
+      current = view.superview
+    }
+    return handlers
+  }
+
+  // MARK: - Installing
+
+  /**
+   Adds one gate to the window. The window owns it for as long as it lives, and the gate stays
+   inert until a menu is actually open, so there is nothing to tear down per host.
+   */
+  static func install(in window: UIWindow) {
+    let isInstalled = window.gestureRecognizers?.contains { $0 is SystemMenuTouchGate } ?? false
+    guard !isInstalled else {
+      return
+    }
+    window.addGestureRecognizer(SystemMenuTouchGate())
+  }
+
+  // MARK: - UIGestureRecognizer
+
+  override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {
+    super.touchesBegan(touches, with: event)
+
+    if let window = view as? UIWindow, Self.isShowingContextMenu(in: window) {
+      for touch in touches {
+        for handler in Self.surfaceTouchHandlers(above: touch.view) {
+          handler.ignore(touch, for: event)
+        }
+      }
+    }
+    state = .failed
+  }
+}
+#endif

package/ios/Utilities/SceneGeometry.swift

@@ -0,0 +1,85 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+#if os(iOS) || os(tvOS)
+
+import UIKit
+
+/**
+ Geometry lookups that start from the view asking the question, because iOS 27 makes iPhone apps
+ freely resizable. Neither `UIScreen.main` nor the first key window in any connected scene describes
+ the space a given view has, since either can belong to a differently sized scene.
+ */
+public enum SceneGeometry {
+  public static func windowScene(for view: UIView? = nil) -> UIWindowScene? {
+    if let scene = view?.window?.windowScene {
+      return scene
+    }
+    return foregroundScene() ?? windowScenes().first
+  }
+
+  /// Deliberately strict, for callers deciding whether to attach a window to a scene at all.
+  public static func foregroundActiveScene() -> UIWindowScene? {
+    return windowScenes().first { $0.activationState == .foregroundActive }
+  }
+
+  /// Nil when no scene is on screen, so callers don't present UI into a background scene.
+  public static func foregroundScene() -> UIWindowScene? {
+    let scenes = windowScenes()
+    return scenes.first { $0.activationState == .foregroundActive }
+      ?? scenes.first { $0.activationState == .foregroundInactive }
+  }
+
+  private static func windowScenes() -> [UIWindowScene] {
+    return UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+  }
+
+  public static func keyWindow(for view: UIView? = nil) -> UIWindow? {
+    guard let scene = windowScene(for: view) else {
+      return nil
+    }
+    return scene.windows.first { $0.isKeyWindow } ?? scene.windows.first
+  }
+
+  public static func bounds(for view: UIView? = nil) -> CGRect {
+    return (view?.window ?? keyWindow(for: view))?.bounds ?? .zero
+  }
+
+  public static func safeAreaSize(for view: UIView? = nil) -> CGSize {
+    guard let window = view?.window ?? keyWindow(for: view) else {
+      return .zero
+    }
+    let safeArea = window.safeAreaLayoutGuide.layoutFrame.size
+    if safeArea.width > 0 && safeArea.height > 0 {
+      return safeArea
+    }
+    return window.bounds.size
+  }
+
+  /// Never cache the result. Scale can differ per scene.
+  public static func displayScale(for view: UIView? = nil) -> CGFloat {
+    return resolveDisplayScale(candidates: [
+      view?.traitCollection.displayScale,
+      windowScene(for: view)?.traitCollection.displayScale,
+      UITraitCollection.current.displayScale
+    ])
+  }
+
+  /// Returns the first positive candidate. `UITraitCollection` reports an unspecified scale as 0.
+  internal static func resolveDisplayScale(candidates: [CGFloat?]) -> CGFloat {
+    for case let candidate? in candidates where candidate > 0 {
+      return candidate
+    }
+    return 1
+  }
+}
+
+#if os(iOS)
+public extension SceneGeometry {
+  /// Reads `effectiveGeometry` because `UIWindowScene.interfaceOrientation` is deprecated as of iOS 26.
+  static func interfaceOrientation(for view: UIView? = nil) -> UIInterfaceOrientation {
+    return windowScene(for: view)?.effectiveGeometry.interfaceOrientation ?? .unknown
+  }
+}
+#endif
+
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "57.0.9",
+  "version": "57.0.11",
   "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": "fb5049481ebd5cadd499c4d1f1d5e47f9ac678be",
+  "gitHead": "125b8d4472432db3dc4ae047730432d7bd5bd30c",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",

package/src/hooks/useReleasingSharedObject.ts

@@ -1,8 +1,8 @@
 'use client';
 
 import type { DependencyList } from 'react';
-import { useEffect, useMemo, useRef } from 'react';
 
+import { useReleasingSharedObjectWithLifecycle } from './useReleasingSharedObjectWithLifecycle';
 import type { SharedObject } from '../ts-declarations/SharedObject';
 
 /**
@@ -12,55 +12,10 @@ export function useReleasingSharedObject<TSharedObject extends SharedObject>(
   factory: () => TSharedObject,
   dependencies: DependencyList
 ): TSharedObject {
-  const objectRef = useRef<TSharedObject | null>(null);
-  const objectRefToRelease = useRef<TSharedObject | null>(null);
-  const isFastRefresh = useRef(false);
-  const previousDependencies = useRef<DependencyList>(dependencies);
-
-  if (objectRef.current == null) {
-    objectRef.current = factory();
-  }
-
-  const object = useMemo(() => {
-    let newObject = objectRef.current;
-    const dependenciesAreEqual =
-      previousDependencies.current?.length === dependencies.length &&
-      dependencies.every((value, index) => value === previousDependencies.current[index]);
-
-    // If the dependencies have changed, schedule the previous object for release and create a new one,
-    // otherwise this has been called because of an unrelated fast refresh, and we don't want to release the object.
-    if (!newObject || !dependenciesAreEqual) {
-      objectRefToRelease.current = objectRef.current;
-      newObject = factory();
-      objectRef.current = newObject;
-      previousDependencies.current = dependencies;
-    }
-    return newObject;
-  }, dependencies);
-
-  useEffect(() => {
-    // When the object changes, release the previous one - it is important to do this in a useEffect, so that we don't release
-    // the object during render.
-    if (objectRefToRelease.current) {
-      objectRefToRelease.current.release();
-      objectRefToRelease.current = null;
-    }
-  }, [object]);
-
-  useMemo(() => {
-    isFastRefresh.current = true;
-  }, []);
-
-  useEffect(() => {
-    isFastRefresh.current = false;
-
-    return () => {
-      // This will be called on every fast refresh and on unmount, but we only want to release the object on unmount.
-      if (!isFastRefresh.current && objectRef.current) {
-        objectRef.current.release();
-      }
-    };
-  }, []);
-
-  return object;
+  return useReleasingSharedObjectWithLifecycle(
+    {
+      factory,
+    },
+    dependencies
+  );
 }

package/src/hooks/useReleasingSharedObjectWithLifecycle.ts

@@ -0,0 +1,181 @@
+'use client';
+
+import type { DependencyList } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
+
+import type { SharedObject } from '../ts-declarations/SharedObject';
+
+export type ReleasingSharedObjectLifecycleContext = {
+  /**
+   * The dependency values from the last committed object lifecycle decision.
+   */
+  previousDependencies: DependencyList;
+
+  /**
+   * The dependency values from the current render.
+   */
+  dependencies: DependencyList;
+};
+
+export type ReleasingSharedObjectLifecycle<TSharedObject extends SharedObject> = {
+  /**
+   * Creates the shared object when the hook initializes or when `shouldRecreate` returns `true`.
+   */
+  factory: () => TSharedObject;
+
+  /**
+   * Called during render when dependencies change to decide whether to replace the object.
+   * Return `false` to keep the current object and handle the dependency change with the `update` function.
+   * When omitted or `true`, dependency changes recreate the object, matching `useReleasingSharedObject`.
+   *
+   * Must be a pure function with no side effects — it is called during the render phase and
+   * React may invoke it more than once with the same inputs.
+   */
+  shouldRecreate?: (
+    object: TSharedObject,
+    context: ReleasingSharedObjectLifecycleContext
+  ) => boolean;
+
+  /**
+   * Called after commit when dependencies changed and `shouldRecreate` returned `false`.
+   * Has no effect unless `shouldRecreate` is provided and returns `false` for the changed
+   * dependencies.
+   *
+   * If the returned `Promise` rejects, the error is logged with `console.error`. Handle errors
+   * inside `update` if specific error handling is needed.
+   *
+   * If a subsequent dependency change or unmount requires the object to be released while an
+   * async update is still in-flight, the release is deferred until the update settles.
+   */
+  update?: (
+    object: TSharedObject,
+    context: ReleasingSharedObjectLifecycleContext
+  ) => void | Promise<void>;
+
+  /**
+   * Releases an object after it has been replaced or when the component unmounts.
+   * When omitted, the object's `release` method is called.
+   */
+  release?: (object: TSharedObject) => void;
+};
+
+type PendingUpdate<TSharedObject extends SharedObject> = {
+  object: TSharedObject;
+  context: ReleasingSharedObjectLifecycleContext;
+};
+
+function dependenciesAreEqual(previousDependencies: DependencyList, dependencies: DependencyList) {
+  return (
+    previousDependencies.length === dependencies.length &&
+    dependencies.every((value, index) => value === previousDependencies[index])
+  );
+}
+
+/**
+ * Returns a shared object, delegating dependency changes to lifecycle callbacks.
+ */
+export function useReleasingSharedObjectWithLifecycle<TSharedObject extends SharedObject>(
+  lifecycle: ReleasingSharedObjectLifecycle<TSharedObject>,
+  dependencies: DependencyList
+): TSharedObject {
+  const objectRef = useRef<TSharedObject | null>(null);
+  const objectRefToRelease = useRef<TSharedObject | null>(null);
+  const pendingUpdateRef = useRef<PendingUpdate<TSharedObject> | null>(null);
+  const pendingUpdatePromiseRef = useRef<Promise<void> | null>(null);
+  const isFastRefresh = useRef(false);
+  const previousDependencies = useRef<DependencyList>(dependencies);
+  const lifecycleRef = useRef(lifecycle);
+
+  // Keep lifecycle callbacks fresh without making effects depend on the lifecycle object identity.
+  lifecycleRef.current = lifecycle;
+
+  if (objectRef.current == null) {
+    objectRef.current = lifecycleRef.current.factory();
+  }
+
+  const object = useMemo(() => {
+    let newObject = objectRef.current;
+    const context = {
+      previousDependencies: previousDependencies.current,
+      dependencies,
+    };
+
+    // If the dependencies have changed, let the caller decide whether the object should be
+    // replaced or updated in place. Otherwise this has been called because of an unrelated
+    // fast refresh, and we don't want to release the object.
+    if (!newObject || !dependenciesAreEqual(previousDependencies.current, dependencies)) {
+      if (!newObject || (lifecycleRef.current.shouldRecreate?.(newObject, context) ?? true)) {
+        objectRefToRelease.current = objectRef.current;
+        newObject = lifecycleRef.current.factory();
+        objectRef.current = newObject;
+      } else if (lifecycleRef.current.update) {
+        pendingUpdateRef.current = {
+          object: newObject,
+          context,
+        };
+      }
+      previousDependencies.current = dependencies;
+    }
+    return newObject;
+  }, dependencies);
+
+  function releaseObject(obj: TSharedObject) {
+    (lifecycleRef.current.release ?? ((o: TSharedObject) => o.release()))(obj);
+  }
+
+  useEffect(() => {
+    // When the object changes, release the previous one - it is important to do this in a useEffect, so that we don't release
+    // the object during render. If an async update is still in-flight, defer the release until it settles.
+    if (objectRefToRelease.current) {
+      const toRelease = objectRefToRelease.current;
+      objectRefToRelease.current = null;
+      const doRelease = () => releaseObject(toRelease);
+      if (pendingUpdatePromiseRef.current) {
+        pendingUpdatePromiseRef.current.then(doRelease, doRelease);
+      } else {
+        doRelease();
+      }
+    }
+
+    if (pendingUpdateRef.current) {
+      const pendingUpdate = pendingUpdateRef.current;
+      pendingUpdateRef.current = null;
+      const result = lifecycleRef.current.update?.(pendingUpdate.object, pendingUpdate.context);
+      if (result instanceof Promise) {
+        pendingUpdatePromiseRef.current = result;
+        result.then(
+          () => {
+            pendingUpdatePromiseRef.current = null;
+          },
+          (error) => {
+            pendingUpdatePromiseRef.current = null;
+            console.error(error);
+          }
+        );
+      }
+    }
+  }, dependencies);
+
+  useMemo(() => {
+    isFastRefresh.current = true;
+  }, []);
+
+  useEffect(() => {
+    isFastRefresh.current = false;
+
+    return () => {
+      // This will be called on every fast refresh and on unmount, but we only want to release the object on unmount.
+      if (!isFastRefresh.current && objectRef.current) {
+        const obj = objectRef.current;
+        const doRelease = () => releaseObject(obj);
+        if (pendingUpdatePromiseRef.current) {
+          pendingUpdatePromiseRef.current.then(doRelease, doRelease);
+        } else {
+          doRelease();
+        }
+      }
+    };
+  }, []);
+
+  return object;
+}

package/src/index.ts

@@ -25,6 +25,7 @@ export * from './PermissionsHook';
 export * from './Refs';
 
 export * from './hooks/useReleasingSharedObject';
+export * from './hooks/useReleasingSharedObjectWithLifecycle';
 export * from './reload';
 
 // Errors