@callstack/react-native-brownfield 5.1.0 → 5.2.0

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/shared/PublishingMetadataInjectorTest.kt

@@ -0,0 +1,222 @@
+package com.callstack.react.brownfield.shared
+
+import groovy.util.NodeList
+import groovy.xml.XmlParser
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class PublishingMetadataInjectorTaskRegistrationTest {
+    @Test
+    fun `does not claim the task name the setup docs tell consumers to register`() {
+        val project = ProjectBuilder.builder().build()
+
+        PublishingMetadataInjector(project)
+
+        assertNull(
+            project.tasks.findByName(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME),
+            "the plugin must leave this name free: the published setup docs tell every bare-RN " +
+                "consumer to register it themselves, and the plugin applies before their script body",
+        )
+        assertNotNull(
+            project.tasks.findByName(Constants.MODULE_METADATA_POST_PROCESS_TASK_NAME),
+        )
+    }
+
+    @Test
+    fun `a not-yet-migrated consumer can still register the legacy task after the plugin has run`() {
+        // The upgrade path at the task-container level: plugin registers during apply(), then the
+        // consumer's script body registers the task the docs told them to. Must not throw.
+        val project = ProjectBuilder.builder().build()
+
+        PublishingMetadataInjector(project)
+        project.tasks.register(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME)
+
+        assertNotNull(project.tasks.findByName(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME))
+        assertNotNull(project.tasks.findByName(Constants.MODULE_METADATA_POST_PROCESS_TASK_NAME))
+    }
+}
+
+class MutatePomDependenciesNodeTest {
+    private fun dependenciesNodeFrom(xml: String): groovy.util.Node {
+        val root = XmlParser().parseText(xml)
+        return (root.get("dependencies") as NodeList).first() as groovy.util.Node
+    }
+
+    private fun versionsFor(
+        dependenciesNode: groovy.util.Node,
+        groupId: String,
+        artifactId: String,
+    ): List<String> {
+        return dependenciesNode.children()
+            .filterIsInstance<groovy.util.Node>()
+            .filter {
+                (it["groupId"] as NodeList).text() == groupId && (it["artifactId"] as NodeList).text() == artifactId
+            }
+            .map { (it["version"] as NodeList).text() }
+    }
+
+    @Test
+    fun `appends new dependencies with no pre-existing entries`() {
+        val dependenciesNode = dependenciesNodeFrom("<project><dependencies/></project>")
+        val toInject = VersionMediatingDependencySet()
+        toInject.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        mutatePomDependenciesNode(dependenciesNode, toInject) { _, _ -> false }
+
+        assertEquals(listOf("1.17.0"), versionsFor(dependenciesNode, "androidx.core", "core-ktx"))
+    }
+
+    @Test
+    fun `injects into a POM that has no dependencies element at all`() {
+        // Must call resolveOrCreateDependenciesNode — inlining the fallback here would make this
+        // pass even with the production path reverted to first().
+        val root = XmlParser().parseText("<project/>")
+        val toInject = VersionMediatingDependencySet()
+        toInject.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        val dependenciesNode = resolveOrCreateDependenciesNode(root)
+        mutatePomDependenciesNode(dependenciesNode, toInject) { _, _ -> false }
+
+        assertEquals(listOf("1.17.0"), versionsFor(dependenciesNode, "androidx.core", "core-ktx"))
+    }
+
+    @Test
+    fun `reuses the existing dependencies element instead of appending a second one`() {
+        val root =
+            XmlParser().parseText(
+                """
+                <project>
+                  <dependencies>
+                    <dependency>
+                      <groupId>androidx.core</groupId>
+                      <artifactId>core-ktx</artifactId>
+                      <version>1.17.0</version>
+                    </dependency>
+                  </dependencies>
+                </project>
+                """.trimIndent(),
+            )
+
+        val dependenciesNode = resolveOrCreateDependenciesNode(root)
+
+        assertEquals(
+            1,
+            (root.get("dependencies") as NodeList).size,
+            "a POM that already has <dependencies> must not gain a second one",
+        )
+        assertEquals(listOf("1.17.0"), versionsFor(dependenciesNode, "androidx.core", "core-ktx"))
+    }
+
+    @Test
+    fun `removes an unrelated excluded entry that is not being re-injected`() {
+        val dependenciesNode =
+            dependenciesNodeFrom(
+                """
+                <project>
+                  <dependencies>
+                    <dependency>
+                      <groupId>com.rnapp</groupId>
+                      <artifactId>brownfieldlib</artifactId>
+                      <version>unspecified</version>
+                    </dependency>
+                  </dependencies>
+                </project>
+                """.trimIndent(),
+            )
+
+        mutatePomDependenciesNode(dependenciesNode, VersionMediatingDependencySet()) { groupId, _ ->
+            groupId == "com.rnapp"
+        }
+
+        assertTrue(versionsFor(dependenciesNode, "com.rnapp", "brownfieldlib").isEmpty())
+    }
+
+    @Test
+    fun `a superseded stale entry is replaced by the mediated version, not left duplicated or missing`() {
+        // Consumer hand-declares 1.6.0, embedded module needs 1.7.1, so the coordinate is
+        // superseded and shouldExclude matches it. The mediated 1.7.1 must survive exactly once.
+        val dependenciesNode =
+            dependenciesNodeFrom(
+                """
+                <project>
+                  <dependencies>
+                    <dependency>
+                      <groupId>androidx.appcompat</groupId>
+                      <artifactId>appcompat</artifactId>
+                      <version>1.6.0</version>
+                      <scope>runtime</scope>
+                    </dependency>
+                  </dependencies>
+                </project>
+                """.trimIndent(),
+            )
+        val mediated = VersionMediatingDependencySet()
+        mediated.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        mutatePomDependenciesNode(dependenciesNode, mediated) { groupId, artifactId ->
+            groupId == "androidx.appcompat" && artifactId == "appcompat"
+        }
+
+        assertEquals(listOf("1.7.1"), versionsFor(dependenciesNode, "androidx.appcompat", "appcompat"))
+    }
+}
+
+class MutateModuleJsonVariantsTest {
+    private fun jsonWithVariant(dependencies: MutableList<MutableMap<String, Any>>): MutableMap<String, Any> {
+        return mutableMapOf(
+            "variants" to
+                mutableListOf(
+                    mutableMapOf<String, Any>(
+                        "name" to "runtimeElements",
+                        "dependencies" to dependencies,
+                    ),
+                ),
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun dependenciesOf(json: Map<*, *>): List<Map<String, Any>> {
+        val variants = json["variants"] as List<Map<String, Any>>
+        return variants.first()["dependencies"] as List<Map<String, Any>>
+    }
+
+    @Test
+    fun `appends new dependencies with no pre-existing entries`() {
+        val json = jsonWithVariant(mutableListOf())
+        val toInject = VersionMediatingDependencySet()
+        toInject.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        mutateModuleJsonVariants(json, toInject) { _, _ -> false }
+
+        val deps = dependenciesOf(json)
+        assertEquals(1, deps.size)
+        assertEquals("androidx.core", deps.first()["group"])
+        assertEquals("core-ktx", deps.first()["module"])
+    }
+
+    @Test
+    fun `a superseded stale entry is replaced by the mediated version, not left duplicated or missing`() {
+        val json =
+            jsonWithVariant(
+                mutableListOf(
+                    mutableMapOf("group" to "androidx.appcompat", "module" to "appcompat"),
+                ),
+            )
+        val mediated = VersionMediatingDependencySet()
+        mediated.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        mutateModuleJsonVariants(json, mediated) { group, module ->
+            group == "androidx.appcompat" && module == "appcompat"
+        }
+
+        val deps = dependenciesOf(json)
+        assertEquals(1, deps.size, "expected exactly one entry, not zero (deleted) or two (duplicated)")
+        @Suppress("UNCHECKED_CAST")
+        val version = (deps.first()["version"] as? Map<String, Any>)?.get("requires")
+        assertEquals("1.7.1", version)
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/shared/TransitiveDependencyFilteringTest.kt

@@ -0,0 +1,37 @@
+package com.callstack.react.brownfield.shared
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class TransitiveDependencyFilteringTest {
+    @Test
+    fun `drops a hard-excluded coordinate the RNC discoverer found, even though it has no Expo awareness`() {
+        // The RNC discoverer has no Expo blacklist, so an embedded module depending on an Expo
+        // coordinate would otherwise be published as a Maven dependency that resolves nowhere.
+        val transitiveDeps = VersionMediatingDependencySet()
+        transitiveDeps.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+        transitiveDeps.add(DependencyInfo("host.exp.exponent", "expo.modules.device", "56.0.4", "compile", false))
+
+        val hardExcludePredicate: (String, String) -> Boolean = { groupId, _ -> groupId == "host.exp.exponent" }
+        dropHardExcludedDependencies(transitiveDeps, hardExcludePredicate)
+
+        assertTrue(transitiveDeps.contains(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false)))
+        assertFalse(transitiveDeps.any { it.groupId == "host.exp.exponent" })
+        assertEquals(1, transitiveDeps.size)
+    }
+
+    @Test
+    fun `does not drop a superseded coordinate that is meant to still be injected`() {
+        // hardExcludePredicate must never include the supersede check, or a mediated
+        // replacement for a consumer's stale hand-declared dependency would be dropped too.
+        val transitiveDeps = VersionMediatingDependencySet()
+        transitiveDeps.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        dropHardExcludedDependencies(transitiveDeps) { _, _ -> false }
+
+        assertTrue(transitiveDeps.contains(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false)))
+        assertEquals(1, transitiveDeps.size)
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/shared/VersionMediatingDependencySetTest.kt

@@ -0,0 +1,42 @@
+package com.callstack.react.brownfield.shared
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class VersionMediatingDependencySetTest {
+    @Test
+    fun `keeps the higher version when the same coordinate is added twice`() {
+        val set = VersionMediatingDependencySet()
+
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.6.0", "compile", false))
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        assertEquals(1, set.size)
+        assertTrue(set.contains(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false)))
+    }
+
+    @Test
+    fun `does not downgrade when a lower version is added second`() {
+        val set = VersionMediatingDependencySet()
+
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.6.0", "compile", false))
+
+        val kept = set.first { it.groupId == "androidx.appcompat" }
+        assertEquals("1.7.1", kept.version)
+    }
+
+    @Test
+    fun `removeAll removes matching entries and returns them`() {
+        val set = VersionMediatingDependencySet()
+        set.add(DependencyInfo("host.exp.exponent", "expo", "1.0.0", "compile", false))
+        set.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        val removed = set.removeAll { it.groupId == "host.exp.exponent" }
+
+        assertEquals(1, removed.size)
+        assertEquals(1, set.size)
+        assertTrue(set.contains(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false)))
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/utils/ExtensionTest.kt

@@ -0,0 +1,11 @@
+package com.callstack.react.brownfield.utils
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertTrue
+
+class ExtensionTest {
+    @Test
+    fun `experimentalIncludeTransitiveDependencies defaults to true`() {
+        assertTrue(Extension().experimentalIncludeTransitiveDependencies)
+    }
+}

package/ios/BrownfieldSurfaceRegistry.swift

@@ -0,0 +1,93 @@
+import Foundation
+
+/// Identifies one live React Native surface. Vended by `BrownfieldSurfaceRegistry`.
+struct BrownfieldSurfaceID: Hashable, CustomStringConvertible {
+  fileprivate let rawValue: UInt64
+
+  var description: String { "surface#\(rawValue)" }
+}
+
+/// Decides which React Native surface may act on a `popToNative()` request.
+///
+/// `popToNative()` is delivered as an app-wide notification, so every live React
+/// Native surface receives it — including ones buried under other screens. Acting
+/// on all of them tears down the whole navigation stack
+/// (https://github.com/callstack/react-native-brownfield/issues/354).
+///
+/// The registry resolves that to a single surface: whichever on-screen surface
+/// was shown most recently.
+///
+/// Visibility is asked for at query time instead of being cached from lifecycle
+/// callbacks. Hosts recreate view controllers — SwiftUI does it freely — and a
+/// cached flag is stale exactly when the notification arrives.
+///
+/// Deliberately free of UIKit so it can be unit tested on macOS via `swift test`.
+/// Internal, like the sibling `BrownfieldBundleSupport` target: it is an
+/// implementation detail of the pod, not API for host apps.
+final class BrownfieldSurfaceRegistry {
+  static let shared = BrownfieldSurfaceRegistry()
+
+  private struct Surface {
+    let isOnScreen: () -> Bool
+    var shownAt: UInt64
+  }
+
+  private let lock = NSLock()
+  private var nextSurfaceValue: UInt64 = 0
+  private var nextShownValue: UInt64 = 0
+  private var surfaces: [BrownfieldSurfaceID: Surface] = [:]
+
+  init() {}
+
+  /// - Parameter isOnScreen: queried on every `popTarget()`. Capture the host
+  ///   weakly so a released surface stops winning the election.
+  func register(isOnScreen: @escaping () -> Bool) -> BrownfieldSurfaceID {
+    lock.lock()
+    defer { lock.unlock() }
+
+    nextSurfaceValue += 1
+    let id = BrownfieldSurfaceID(rawValue: nextSurfaceValue)
+    surfaces[id] = Surface(isOnScreen: isOnScreen, shownAt: 0)
+    return id
+  }
+
+  func unregister(_ surface: BrownfieldSurfaceID) {
+    lock.lock()
+    defer { lock.unlock() }
+
+    surfaces.removeValue(forKey: surface)
+  }
+
+  /// Records that a surface was just shown, ordering it ahead of other on-screen
+  /// surfaces. Only a tiebreaker — a surface never marked shown can still win
+  /// when it is the one on screen.
+  func markShown(_ surface: BrownfieldSurfaceID) {
+    lock.lock()
+    defer { lock.unlock() }
+
+    guard var entry = surfaces[surface] else { return }
+
+    nextShownValue += 1
+    entry.shownAt = nextShownValue
+    surfaces[surface] = entry
+  }
+
+  /// The single surface allowed to handle `popToNative()`, or `nil` when no
+  /// React Native surface is on screen.
+  func popTarget() -> BrownfieldSurfaceID? {
+    lock.lock()
+    let candidates = surfaces
+    lock.unlock()
+
+    return candidates
+      .filter { $0.value.isOnScreen() }
+      .max { lhs, rhs in
+        (lhs.value.shownAt, lhs.key.rawValue) < (rhs.value.shownAt, rhs.key.rawValue)
+      }?
+      .key
+  }
+
+  func isPopTarget(_ surface: BrownfieldSurfaceID) -> Bool {
+    popTarget() == surface
+  }
+}

package/ios/Views/ReactNativeView.swift

@@ -1,20 +1,38 @@
 import SwiftUI
 
+/**
+ Links a SwiftUI `ReactNativeView` to the view controller it hosts, so the
+ SwiftUI layer can ask whether this surface may act on `popToNative()`.
+ */
+final class BrownfieldSurfaceHost {
+  weak var controller: ReactNativeViewController?
+
+  var isPopTarget: Bool { controller?.isPopTarget ?? false }
+}
+
 /**
  A UIViewControllerRepresentable that bridges ReactNativeViewController to SwiftUI.
  */
 struct ReactNativeViewRepresentable: UIViewControllerRepresentable {
   var moduleName: String
   var initialProperties: [String: Any] = [:]
+  var host: BrownfieldSurfaceHost
 
   func makeUIViewController(context: Context) -> UIViewController {
-    return ReactNativeViewController(
+    let controller = ReactNativeViewController(
       moduleName: moduleName,
       initialProperties: initialProperties
     )
+    controller.isHostedBySwiftUI = true
+    host.controller = controller
+    return controller
   }
 
-  func updateUIViewController(_ uiViewController: UIViewController, context: Context) {}
+  func updateUIViewController(_ uiViewController: UIViewController, context: Context) {
+    if let controller = uiViewController as? ReactNativeViewController {
+      host.controller = controller
+    }
+  }
 }
 
 /**
@@ -24,6 +42,7 @@ struct ReactNativeViewRepresentable: UIViewControllerRepresentable {
 @available(iOS 15.0, *)
 public struct ReactNativeView: View {
   @Environment(\.dismiss) var dismiss
+  @State private var host = BrownfieldSurfaceHost()
   var moduleName: String
   var initialProperties: [String: Any] = [:]
 
@@ -35,11 +54,21 @@ public struct ReactNativeView: View {
   public var body: some View {
     ReactNativeViewRepresentable(
       moduleName: moduleName,
-      initialProperties: initialProperties
+      initialProperties: initialProperties,
+      host: host
     )
     .ignoresSafeArea(.all)
-    .onReceive(NotificationCenter.default.publisher(for: NSNotification.Name.popToNative))
-    { notification in
+    // `.popToNative` is public API and may be posted from any thread, while
+    // `host.isPopTarget` reads UIKit state — so deliver on main.
+    .onReceive(
+      NotificationCenter.default
+        .publisher(for: NSNotification.Name.popToNative)
+        .receive(on: DispatchQueue.main)
+    ) { _ in
+      // Every live surface receives this app-wide notification; only the
+      // topmost on-screen one may dismiss.
+      // https://github.com/callstack/react-native-brownfield/issues/354
+      guard host.isPopTarget else { return }
       dismiss()
     }
   }

package/ios/Views/ReactNativeViewController.swift

@@ -7,6 +7,25 @@ internal import EXUpdates
 @objc public class ReactNativeViewController: UIViewController {
   private var moduleName: String
   private var initialProperties: [String: Any]?
+  /// Identifies this surface in `BrownfieldSurfaceRegistry`, which decides
+  /// which single surface may act on `popToNative()`.
+  private var surfaceID: BrownfieldSurfaceID?
+
+  /// Set by `ReactNativeView`. SwiftUI owns its navigation state, so an
+  /// imperative `popViewController` is reverted; the SwiftUI host dismisses
+  /// instead and this controller stands down.
+  internal var isHostedBySwiftUI = false
+
+  /// True from the start of a disappearance transition until the surface next
+  /// appears. `view.window` stays non-nil for the whole animation, so this is
+  /// what distinguishes "the host already dismissed us" from "nothing happened".
+  private var isDisappearing = false
+
+  /// Whether this surface is the one allowed to act on `popToNative()`.
+  internal var isPopTarget: Bool {
+    guard let surfaceID else { return false }
+    return BrownfieldSurfaceRegistry.shared.isPopTarget(surfaceID)
+  }
 
 #if canImport(EXUpdates)
   private let expoUpdatesDelegate = ReactNativeExpoUpdatesDelegate()
@@ -39,6 +58,12 @@ internal import EXUpdates
 #if !canImport(EXUpdates)
       renderReactNativeView()
 #endif
+
+      // Visibility is resolved live: SwiftUI recreates hosted controllers, so a
+      // cached lifecycle flag is stale when the notification arrives.
+      surfaceID = BrownfieldSurfaceRegistry.shared.register { [weak self] in
+        self?.viewIfLoaded?.window != nil
+      }
         
       NotificationCenter.default.addObserver(
         self,
@@ -56,8 +81,31 @@ internal import EXUpdates
     }
   }
 
+  public override func viewWillAppear(_ animated: Bool) {
+    super.viewWillAppear(animated)
+
+    isDisappearing = false
+
+    // Ordered here rather than in `viewDidAppear`: during a modal presentation
+    // the covered surface is still in a window, so waiting for `viewDidAppear`
+    // would let it out-rank the surface being presented over it.
+    if let surfaceID {
+      BrownfieldSurfaceRegistry.shared.markShown(surfaceID)
+    }
+  }
+
+  public override func viewWillDisappear(_ animated: Bool) {
+    super.viewWillDisappear(animated)
+
+    isDisappearing = true
+  }
+
   deinit {
     NotificationCenter.default.removeObserver(self)
+
+    if let surfaceID {
+      BrownfieldSurfaceRegistry.shared.unregister(surfaceID)
+    }
   }
 
   @objc private func togglePopGestureRecognizer(_ notification: Notification) {
@@ -73,11 +121,82 @@ internal import EXUpdates
     guard let userInfo = notification.userInfo,
           let animated = userInfo["animated"] as? Bool else { return }
 
+    // `.popToNative` is public API, so a host may post it from any thread.
+    // Everything below reads UIKit state — including the registry's visibility
+    // check — so hop to main first.
     DispatchQueue.main.async { [weak self] in
-      self?.navigationController?.popViewController(animated: animated)
+      guard let self else { return }
+
+      // The notification is app-wide, so every live surface receives it. Only
+      // the topmost visible one may act, otherwise surfaces buried under other
+      // screens tear down the whole navigation stack.
+      // https://github.com/callstack/react-native-brownfield/issues/354
+      let target = BrownfieldSurfaceRegistry.shared.popTarget()
+
+      guard let surfaceID = self.surfaceID, target == surfaceID else {
+        if target == nil {
+          NSLog("[ReactBrownfield] popToNative(): no React Native surface is on screen; ignoring.")
+        }
+        return
+      }
+
+      guard self.isHostedBySwiftUI else {
+        self.popFromNativeNavigationStack(animated: animated)
+        return
+      }
+
+      // SwiftUI owns its navigation state and reverts an imperative pop, so the
+      // SwiftUI host dismisses instead. It cannot always succeed though — a
+      // `ReactNativeView` inside a `UIHostingController` pushed onto a UIKit
+      // navigation stack has nothing for `dismiss()` to act on. Give the host a
+      // moment, then fall back, so `popToNative()` is never silently inert.
+      //
+      // `isDisappearing` — not the delay — is what makes this safe: a dismiss
+      // that is merely slow has already begun its transition by the time this
+      // runs, so a late timer stands down instead of popping a second entry.
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+        guard let self,
+              !self.isDisappearing,
+              self.viewIfLoaded?.window != nil,
+              // Re-established: the entitlement was resolved before the wait.
+              self.isPopTarget else { return }
+
+        self.popFromNativeNavigationStack(animated: animated)
+      }
     }
   }
 
+  /// Pops this surface off the host's `UINavigationController`.
+  ///
+  /// Deliberately does not fall back to `dismiss()` when there is no navigation
+  /// stack: `presentingViewController` is inherited, so an inline surface hosted
+  /// inside a presented native screen would tear down that whole screen — the
+  /// same over-dismissal this fix exists to prevent.
+  private func popFromNativeNavigationStack(animated: Bool) {
+    guard let navigationController else { return }
+
+    // This controller is usually a child of a host controller (SwiftUI wraps it
+    // in one), so find the stack entry containing it rather than assuming it is
+    // itself on the stack — and pop to the entry below that, so a screen pushed
+    // while we were waiting is not the one that gets popped.
+    let stack = navigationController.viewControllers
+    guard let index = stack.firstIndex(where: { $0 === self || self.isDescendant(of: $0) }),
+          index > 0 else { return }
+
+    navigationController.popToViewController(stack[index - 1], animated: animated)
+  }
+
+  private func isDescendant(of controller: UIViewController) -> Bool {
+    var ancestor = parent
+
+    while let current = ancestor {
+      if current === controller { return true }
+      ancestor = current.parent
+    }
+
+    return false
+  }
+
   private func renderReactNativeView() {
     guard !moduleName.isEmpty else { return }
     

package/lib/commonjs/expo-config-plugin/android/utils/constants.js

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,"__esModule",{value:true});exports.brownfieldGradlePluginDependency=exports.BROWNFIELD_PLUGIN_VERSION=void 0;var BROWNFIELD_PLUGIN_VERSION=exports.BROWNFIELD_PLUGIN_VERSION='2.0.0-alpha08';var brownfieldGradlePluginDependency=exports.brownfieldGradlePluginDependency=`classpath("com.callstack.react:brownfield-gradle-plugin:${BROWNFIELD_PLUGIN_VERSION}")`;
+Object.defineProperty(exports,"__esModule",{value:true});exports.brownfieldGradlePluginDependency=exports.BROWNFIELD_PLUGIN_VERSION=void 0;var BROWNFIELD_PLUGIN_VERSION=exports.BROWNFIELD_PLUGIN_VERSION='2.0.0-alpha10';var brownfieldGradlePluginDependency=exports.brownfieldGradlePluginDependency=`classpath("com.callstack.react:brownfield-gradle-plugin:${BROWNFIELD_PLUGIN_VERSION}")`;
 //# sourceMappingURL=constants.js.map