@callstack/react-native-brownfield 5.1.0 → 5.1.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @callstack/react-native-brownfield
 
+## 5.1.1
+
+### Patch Changes
+
+- [#458](https://github.com/callstack/react-native-brownfield/pull/458) [`bf976fd`](https://github.com/callstack/react-native-brownfield/commit/bf976fdebc1abb228c03213c9a1b41d9967d0909) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - Bump the Brownfield Gradle Plugin version injected by the Expo config plugin to `2.0.0-alpha09`.
+
+- [#462](https://github.com/callstack/react-native-brownfield/pull/462) [`2f7d5da`](https://github.com/callstack/react-native-brownfield/commit/2f7d5daf661808fdfdd1caae89236dbdfec3f62e) Thanks [@likevy](https://github.com/likevy)! - fixes [#457](https://github.com/callstack/react-native-brownfield/issues/457), android back callbacks survived RN fragment view destruction, retaining delegates and intercepting back presses after re-entry
+
+- [#470](https://github.com/callstack/react-native-brownfield/pull/470) [`09162c2`](https://github.com/callstack/react-native-brownfield/commit/09162c27bd8455b67bc0e2890a4ffe8dae5b9eae) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - Fix `popToNative()` on iOS closing every React Native screen instead of only the topmost one.
+
+  `popToNative()` is delivered as an app-wide notification, so every live React Native surface acted on it — including surfaces buried under other screens, and each surface acted twice when hosted by SwiftUI. In a stack such as RN → native → RN, a single call tore down the whole navigation stack, taking native screens with it.
+
+  A React Native surface now acts only when it is the topmost one on screen, and only once per host.
+
+  Two consequences worth knowing about:
+  - When no React Native surface is on screen — for example one hidden behind a full-screen native modal — `popToNative()` is now a no-op instead of popping the hidden screen. It logs when this happens.
+  - `popToNative()` no longer dismisses a modally presented native screen that merely _contains_ a React Native surface. Only a surface that owns a navigation stack entry pops.
+
+- Updated dependencies []:
+  - @callstack/brownfield-cli@5.1.1
+
 ## 5.1.0
 
 ### Minor Changes

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactNativeBrownfield.kt

@@ -202,6 +202,19 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
         moduleName: String,
         reactDelegate: ReactDelegateWrapper? = null,
         launchOptions: Bundle? = null,
+    ): FrameLayout = createView(activity, moduleName, reactDelegate, launchOptions, activity)
+
+    /**
+     * Use the owner of the view when embedding React Native inside a fragment or
+     * another container whose lifetime is shorter than the activity.
+     * The four-argument overload retains its original JVM signature.
+     */
+    fun createView(
+        activity: FragmentActivity?,
+        moduleName: String,
+        reactDelegate: ReactDelegateWrapper?,
+        launchOptions: Bundle?,
+        lifecycleOwner: LifecycleOwner?,
     ): FrameLayout {
         val reactHost = shared.reactHost
         val resolvedDelegate =
@@ -215,12 +228,17 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
         }
 
         // Register back press callback
-        activity?.onBackPressedDispatcher?.addCallback(backPressedCallback)
+        if (lifecycleOwner != null) {
+            activity?.onBackPressedDispatcher?.addCallback(lifecycleOwner, backPressedCallback)
+        }
         // invoked on the last RN screen exit
         resolvedDelegate.setHardwareBackHandler {
             backPressedCallback.isEnabled = false
-            activity?.onBackPressedDispatcher?.onBackPressed()
-            backPressedCallback.isEnabled = true
+            try {
+                activity?.onBackPressedDispatcher?.onBackPressed()
+            } finally {
+                backPressedCallback.isEnabled = true
+            }
         }
 
         /**
@@ -230,7 +248,7 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
          * In such a case, we set the lifeCycle observer.
          */
         if (reactDelegate == null) {
-            activity?.lifecycle?.addObserver(getLifeCycleObserver(resolvedDelegate))
+            lifecycleOwner?.lifecycle?.addObserver(getLifeCycleObserver(resolvedDelegate))
         }
 
         resolvedDelegate.loadApp()

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactNativeFragment.kt

@@ -54,7 +54,9 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
         return ReactNativeBrownfield.shared.createView(
             activity,
             moduleName,
-            this.reactDelegate as ReactDelegateWrapper
+            this.reactDelegate as ReactDelegateWrapper,
+            launchOptions = null,
+            lifecycleOwner = viewLifecycleOwner
         )
     }
 

package/gradle-plugin/brownfield/build.gradle.kts

@@ -108,6 +108,13 @@ dependencies {
     implementation(libs.common)
     implementation(libs.asm.commons)
     implementation(libs.versioncompare)
+    testImplementation(libs.junit.jupiter)
+    testImplementation(gradleTestKit())
+    testImplementation(kotlin("test"))
+}
+
+tasks.test {
+    useJUnitPlatform()
 }
 
 tasks.named("detekt").configure {

package/gradle-plugin/brownfield/gradle/libs.versions.toml

@@ -6,6 +6,7 @@ agp = "8.5.2"
 common = "31.2.2" # do not bump it for now, as it throws an error for incompatible AGP used
 asm-commons = "9.7"
 versioncompare = "1.5.0"
+junit = "5.11.4"
 
 [plugins]
 kotlinJvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlinJvm" }
@@ -17,3 +18,4 @@ agp = { module = "com.android.tools.build:gradle", name = "agp", version.ref = "
 common = { module = "com.android.tools:common", version.ref = "common" }
 asm-commons = { module = "org.ow2.asm:asm-commons", version.ref = "asm-commons" }
 versioncompare = { module = "io.github.g00fy2:versioncompare", version.ref = "versioncompare" }
+junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit" }

package/gradle-plugin/brownfield/gradle.properties

@@ -1,6 +1,6 @@
 PROJECT_ID=com.callstack.react.brownfield
 ARTIFACT_ID=brownfield-gradle-plugin
-VERSION=2.0.0-alpha08
+VERSION=2.0.0-alpha09
 GROUP=com.callstack.react
 IMPLEMENTATION_CLASS=com.callstack.react.brownfield.plugin.RNBrownfieldPlugin
 

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/artifacts/RncTransitiveDependencyDiscoverer.kt

@@ -0,0 +1,96 @@
+package com.callstack.react.brownfield.artifacts
+
+import com.callstack.react.brownfield.shared.Logging
+import com.callstack.react.brownfield.shared.TRANSITIVE_DEPENDENCY_CONFIG_NAMES
+import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
+import com.callstack.react.brownfield.shared.VersionMediatingDependencySet
+import com.callstack.react.brownfield.shared.collectPublishableGradleDependencies
+import com.callstack.react.brownfield.shared.isPublishableCoordinate
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Dependency
+
+/**
+ * Result of [RncTransitiveDependencyDiscoverer.discover].
+ *
+ * @param dependencies The mediated set of third-party dependencies to inject.
+ * @param supersededCoordinates Coordinates the consumer declares itself that an embedded module
+ * also needs. The caller must drop their pre-existing POM/module.json entries: [dependencies]
+ * already carries the mediated (never-lower) version, so keeping both duplicates or shadows it.
+ */
+data class RncTransitiveDependencyDiscoveryResult(
+    val dependencies: VersionMediatingDependencySet,
+    val supersededCoordinates: Set<Pair<String, String>>,
+)
+
+/**
+ * Discovers third-party dependencies of the native modules embedded into the fat AAR, for
+ * publication into its POM/module metadata. The RNC-CLI counterpart to
+ * `ExpoPublishingHelper.appendExpoTransitiveDependenciesFromGradle`.
+ */
+class RncTransitiveDependencyDiscoverer(private val project: Project) {
+    fun discover(artifacts: List<UnresolvedArtifactInfo>): RncTransitiveDependencyDiscoveryResult {
+        val discovered = VersionMediatingDependencySet()
+        val supersededCoordinates = mutableSetOf<Pair<String, String>>()
+
+        artifacts
+            .filter { it.isExpoPublishDependency != true }
+            .forEach { artifact -> discoverFromArtifact(artifact, discovered, supersededCoordinates) }
+
+        return RncTransitiveDependencyDiscoveryResult(discovered, supersededCoordinates)
+    }
+
+    private fun discoverFromArtifact(
+        artifact: UnresolvedArtifactInfo,
+        discovered: VersionMediatingDependencySet,
+        supersededCoordinates: MutableSet<Pair<String, String>>,
+    ) {
+        val moduleProject = project.rootProject.findProject(":${artifact.moduleName}")
+        if (moduleProject == null) {
+            Logging.log(
+                "WARNING: Could not discover transitive dependencies for embedded module " +
+                    "'${artifact.moduleName}' - no Gradle project found at " +
+                    "':${artifact.moduleName}' in the root project",
+            )
+            return
+        }
+
+        collectPublishableGradleDependencies(moduleProject).forEach { moduleDependency ->
+            val consumerDeclaration = consumerDeclaredDependency(moduleDependency.groupId, moduleDependency.artifactId)
+
+            if (consumerDeclaration != null) {
+                // Supersede on the declaration existing, not on it having a version: a versionless
+                // one (BOM/platform) still leaves a stale entry that must be replaced, not doubled.
+                supersededCoordinates.add(moduleDependency.groupId to moduleDependency.artifactId)
+
+                // Module-side versions are already validated upstream; this is the consumer-side
+                // equivalent, keeping a dynamic version from winning mediation and being published.
+                val consumerVersioned = moduleDependency.copy(version = consumerDeclaration.version)
+                if (isPublishableCoordinate(consumerVersioned)) {
+                    discovered.add(consumerVersioned)
+                }
+            }
+
+            discovered.add(moduleDependency)
+        }
+    }
+
+    /**
+     * The consumer's own declaration of this coordinate, or null if it doesn't declare it. Returns
+     * the [Dependency], not its version, so "declared without a version" stays distinguishable from
+     * "not declared" — collapsing the two leaks duplicate POM entries.
+     *
+     * Note this narrows a dynamic declaration: consumer `appcompat:1.+` against module `1.0.0`
+     * publishes `1.0.0`, possibly lower than `1.+` would have resolved to. Intended — a published
+     * `1.+` is broken for downstream consumers.
+     */
+    private fun consumerDeclaredDependency(
+        groupId: String,
+        artifactId: String,
+    ): Dependency? {
+        return TRANSITIVE_DEPENDENCY_CONFIG_NAMES.firstNotNullOfOrNull { configName ->
+            project.configurations.findByName(configName)?.dependencies?.firstOrNull {
+                it.group == groupId && it.name == artifactId
+            }
+        }
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/expo/ExpoPublishingHelper.kt

@@ -1,20 +1,15 @@
 package com.callstack.react.brownfield.expo
 
 import com.android.utils.forEach
-import com.callstack.react.brownfield.expo.utils.DependencyInfo
 import com.callstack.react.brownfield.expo.utils.ExpoGradleProjectProjection
 import com.callstack.react.brownfield.expo.utils.LocalMavenUtils
-import com.callstack.react.brownfield.expo.utils.VersionMediatingDependencySet
 import com.callstack.react.brownfield.expo.utils.asExpoGradleProjectProjection
 import com.callstack.react.brownfield.shared.Constants
+import com.callstack.react.brownfield.shared.DependencyInfo
 import com.callstack.react.brownfield.shared.Logging
-import groovy.json.JsonOutput
-import groovy.json.JsonSlurper
-import groovy.util.NodeList
+import com.callstack.react.brownfield.shared.VersionMediatingDependencySet
+import com.callstack.react.brownfield.shared.collectPublishableGradleDependencies
 import org.gradle.api.Project
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.publish.tasks.GenerateModuleMetadata
 import org.w3c.dom.Node
 import java.io.File
 import javax.xml.parsers.DocumentBuilderFactory
@@ -29,6 +24,11 @@ fun Node.getChildNodeByName(nodeName: String): Node? {
 }
 
 open class ExpoPublishingHelper(val brownfieldAppProject: Project) {
+    /**
+     * Discovers *which* Expo projects are publishable, not their transitive dependencies: this runs
+     * during `apply()`, when those projects may not have configured their own dependencies yet.
+     * [discoverAllExpoTransitiveDependencies] handles that later.
+     */
     fun configure(): List<ExpoGradleProjectProjection> {
         val discoverableExpoProjects = getDiscoverableExpoProjects()
 
@@ -39,29 +39,10 @@ open class ExpoPublishingHelper(val brownfieldAppProject: Project) {
                 ) { it.name },
         )
 
-        val expoTransitiveDependencies =
-            discoverAllExpoTransitiveDependencies(
-                expoProjects = discoverableExpoProjects,
-            )
-
-        Logging.log(
-            "Collected a total of ${expoTransitiveDependencies.size} unique Expo transitive " +
-                "dependencies for brownfield app project publishing",
-        )
-        expoTransitiveDependencies.forEach {
-            Logging.log(
-                "(*) dependency ${it.groupId}:${it.artifactId}:${it.version} (scope: ${it.scope}, " +
-                    "${if (it.optional) "optional" else "required"})",
-            )
-        }
-
-        reconfigurePOM(expoTransitiveDependencies)
-        reconfigureGradleModuleJSON(expoTransitiveDependencies)
-
         return discoverableExpoProjects
     }
 
-    protected fun shouldExcludeDependency(
+    internal fun shouldExcludeDependency(
         groupId: String,
         artifactId: String,
     ): Boolean {
@@ -78,174 +59,6 @@ open class ExpoPublishingHelper(val brownfieldAppProject: Project) {
         return (isRootProjectArtifact || isExpoArtifact)
     }
 
-    /**
-     * Modifies the generated Gradle Module Metadata file to inject Expo transitive dependencies.
-     * @param discoveredExpoTransitiveDependencies Set of DependencyInfo
-     * representing Expo transitive dependencies to add.
-     */
-    @Suppress("LongMethod")
-    protected fun reconfigureGradleModuleJSON(discoveredExpoTransitiveDependencies: VersionMediatingDependencySet) {
-        val removeDependenciesFromModuleFileTask =
-            brownfieldAppProject.tasks.register("removeDependenciesFromModuleFile")
-        removeDependenciesFromModuleFileTask.configure { task ->
-            task.doLast {
-                val moduleBuildDir = brownfieldAppProject.layout.buildDirectory.get()
-
-                File("$moduleBuildDir/publications/mavenAar/module.json").run {
-                    val json = inputStream().use { JsonSlurper().parse(it) as Map<*, *> }
-
-                    discoveredExpoTransitiveDependencies.forEach { dependencyToAdd ->
-                        @Suppress("UNCHECKED_CAST")
-                        (json["variants"] as? List<MutableMap<String, Any>>)?.forEach { variant ->
-                            Logging.log(
-                                "Injecting dependency to Gradle module JSON for variant " +
-                                    "'${variant["name"]}': ${dependencyToAdd.groupId}:" +
-                                    "${dependencyToAdd.artifactId}:${dependencyToAdd.version}",
-                            )
-
-                            (variant["dependencies"] as? MutableList<MutableMap<String, Any>>)?.add(
-                                mutableMapOf<String, Any>(
-                                    "group" to dependencyToAdd.groupId,
-                                    "module" to dependencyToAdd.artifactId,
-                                ).apply {
-                                    dependencyToAdd.version?.let { version ->
-                                        put(
-                                            "version",
-                                            mapOf(
-                                                "requires" to version,
-                                            ),
-                                        )
-                                    }
-                                },
-                            )
-                        }
-                    }
-
-                    @Suppress("UNCHECKED_CAST")
-                    (json["variants"] as? List<MutableMap<String, Any>>)?.forEach { variant ->
-                        (variant["dependencies"] as? MutableList<Map<String, Any>>)?.removeAll {
-                            val group = it["group"] as String
-                            val module = it["module"] as String
-
-                            val shouldBeExcluded =
-                                shouldExcludeDependency(
-                                    groupId = group,
-                                    artifactId = module,
-                                )
-
-                            if (shouldBeExcluded) {
-                                Logging.log(
-                                    "Removing excluded dependency from Gradle module JSON: $group:$module",
-                                )
-                            }
-
-                            shouldBeExcluded
-                        }
-
-                        writer().use {
-                            it.write(
-                                JsonOutput.prettyPrint(
-                                    JsonOutput.toJson(
-                                        json,
-                                    ),
-                                ),
-                            )
-                        }
-                    }
-                }
-            }
-        }
-
-        brownfieldAppProject.tasks.withType(GenerateModuleMetadata::class.java)
-            .configureEach {
-                it.finalizedBy(removeDependenciesFromModuleFileTask.get())
-            }
-    }
-
-    /**
-     * Modifies the generated Maven POM file to inject Expo transitive dependencies.
-     * @param discoveredExpoTransitiveDependencies Set of DependencyInfo
-     * representing Expo transitive dependencies to add.
-     */
-    @Suppress("LongMethod")
-    protected fun reconfigurePOM(discoveredExpoTransitiveDependencies: VersionMediatingDependencySet) {
-        brownfieldAppProject.pluginManager.withPlugin("maven-publish") {
-            brownfieldAppProject.extensions.configure(PublishingExtension::class.java) { publishing ->
-                publishing.publications.withType(MavenPublication::class.java)
-                    .configureEach { pub ->
-                        Logging.log(
-                            "Configuring POM for publication '${pub.name}' to include Expo transitive dependencies",
-                        )
-
-                        pub.pom.withXml {
-                            val root = it.asNode()
-
-                            // below: obtains a view of the <dependencies> node(s)
-                            // inside the POM XML; in practice, there should be only one such node
-                            val dependenciesNodeList =
-                                root.get("dependencies") as NodeList
-                            val dependenciesNode =
-                                dependenciesNodeList.first() as groovy.util.Node
-
-                            // below: inject the discovered Expo transitive dependencies
-                            // into the POM's <dependencies> node
-                            discoveredExpoTransitiveDependencies.forEach { dependencyToAdd ->
-                                Logging.log(
-                                    "Injecting dependency to POM: ${dependencyToAdd.groupId}:" +
-                                        "${dependencyToAdd.artifactId}:${dependencyToAdd.version}",
-                                )
-
-                                val childTags =
-                                    mutableMapOf(
-                                        "groupId" to dependencyToAdd.groupId,
-                                        "artifactId" to dependencyToAdd.artifactId,
-                                        "scope" to dependencyToAdd.scope,
-                                        "optional" to dependencyToAdd.optional.toString(),
-                                    )
-
-                                if (dependencyToAdd.version?.isNotBlank() == true) {
-                                    childTags["version"] = dependencyToAdd.version
-                                }
-
-                                dependenciesNode.appendNode("dependency").let { newDepNode ->
-                                    childTags.forEach { (tagName, tagValue) ->
-                                        newDepNode.appendNode(tagName, tagValue)
-                                    }
-                                }
-                            }
-
-                            // below: filter out dependencies that should be excluded
-                            dependenciesNode.children()
-                                .filterIsInstance<groovy.util.Node>()
-                                .filter { dependency ->
-                                    val groupId =
-                                        (dependency["groupId"] as NodeList).text()
-                                    val artifactId =
-                                        (dependency["artifactId"] as NodeList).text()
-
-                                    val shouldBeExcluded =
-                                        shouldExcludeDependency(
-                                            groupId = groupId,
-                                            artifactId = artifactId,
-                                        )
-
-                                    if (shouldBeExcluded) {
-                                        Logging.log(
-                                            "Removing excluded dependency from POM: $groupId:$artifactId",
-                                        )
-                                    }
-
-                                    shouldBeExcluded
-                                }
-                                .forEach { dependency ->
-                                    dependenciesNode.remove(dependency)
-                                }
-                        }
-                    }
-            }
-        }
-    }
-
     fun discoverAllExpoTransitiveDependencies(expoProjects: Iterable<ExpoGradleProjectProjection>): VersionMediatingDependencySet {
         var discoveredExpoTransitiveDependencies = VersionMediatingDependencySet()
         expoProjects.forEach { expoProj ->
@@ -368,24 +181,7 @@ open class ExpoPublishingHelper(val brownfieldAppProject: Project) {
         pkgProject: Project,
         dependencies: VersionMediatingDependencySet,
     ) {
-        /**
-         * Not accounting for variant specific configurations as Expo packages are not
-         * using it. Should we face any issues/needs to account for it, we can do it here.
-         */
-        listOf("implementation", "api", "runtime").forEach {
-            val configuration = pkgProject.configurations.findByName(it)
-            configuration?.dependencies?.forEach { dep ->
-                if (dep.group != null) {
-                    dependencies.add(
-                        DependencyInfo.fromGradleDep(
-                            groupId = dep.group!!,
-                            artifactId = dep.name,
-                            version = dep.version,
-                        ),
-                    )
-                }
-            }
-        }
+        dependencies.addAll(collectPublishableGradleDependencies(pkgProject))
     }
 
     /**

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/expo/utils/BrownfieldPublishingInfo.kt

@@ -0,0 +1,7 @@
+package com.callstack.react.brownfield.expo.utils
+
+data class BrownfieldPublishingInfo(
+    val groupId: String,
+    val artifactId: String,
+    val version: String,
+)

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/plugin/RNBrownfieldPlugin.kt

@@ -3,6 +3,7 @@ package com.callstack.react.brownfield.plugin
 import com.android.build.api.variant.LibraryAndroidComponentsExtension
 import com.android.build.api.variant.LibraryVariant
 import com.callstack.react.brownfield.artifacts.ArtifactsResolver
+import com.callstack.react.brownfield.artifacts.RncTransitiveDependencyDiscoverer
 import com.callstack.react.brownfield.expo.ExpoPublishingHelper
 import com.callstack.react.brownfield.expo.utils.ExpoGradleProjectProjection
 import com.callstack.react.brownfield.processors.AssetTaskProcessor
@@ -15,9 +16,13 @@ import com.callstack.react.brownfield.processors.VariantHelper
 import com.callstack.react.brownfield.processors.VariantPackagesProperty
 import com.callstack.react.brownfield.processors.VariantTaskProvider
 import com.callstack.react.brownfield.shared.BaseProject
+import com.callstack.react.brownfield.shared.Constants
 import com.callstack.react.brownfield.shared.Constants.PROJECT_ID
 import com.callstack.react.brownfield.shared.Logging
+import com.callstack.react.brownfield.shared.PublishingMetadataInjector
 import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
+import com.callstack.react.brownfield.shared.VersionMediatingDependencySet
+import com.callstack.react.brownfield.shared.dropHardExcludedDependencies
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
 import com.callstack.react.brownfield.utils.DirectoryManager
 import com.callstack.react.brownfield.utils.Extension
@@ -54,8 +59,9 @@ class RNBrownfieldPlugin : Plugin<Project> {
         }
 
         var expoProjects = listOf<ExpoGradleProjectProjection>()
+        var expoPublishingHelper: ExpoPublishingHelper? = null
         if (this.isExpoProject) {
-            val expoPublishingHelper = ExpoPublishingHelper(brownfieldAppProject = project)
+            expoPublishingHelper = ExpoPublishingHelper(brownfieldAppProject = project)
             expoProjects = expoPublishingHelper.configure()
         }
 
@@ -65,6 +71,18 @@ class RNBrownfieldPlugin : Plugin<Project> {
         val artifactsResolver = ArtifactsResolver(project, isExpoProject)
         val artifacts = artifactsResolver.processDefaultDependencies(expoProjects)
 
+        // Registered eagerly: Gradle disallows registering tasks from afterEvaluate. Only the
+        // dependency set supplied below has to wait.
+        val injector = PublishingMetadataInjector(project)
+
+        // whenReady, not afterEvaluate: afterEvaluate guarantees only that *this* project is
+        // configured, not the embedded module projects we read dependencies from — theirs were
+        // empirically still empty at that point. whenReady fires once the whole task graph is
+        // resolved (so every embedded module is configured) but before any task runs.
+        project.gradle.taskGraph.whenReady {
+            configureTransitiveDependencyInjection(project, injector, expoPublishingHelper, expoProjects, artifacts)
+        }
+
         val variantTaskProvider = VariantTaskProvider(project)
 
         val androidComponents = project.extensions.getByType(LibraryAndroidComponentsExtension::class.java)
@@ -77,6 +95,79 @@ class RNBrownfieldPlugin : Plugin<Project> {
         const val EXPO_PROJECT_LOCATOR = ":expo"
     }
 
+    @Suppress("LongMethod")
+    private fun configureTransitiveDependencyInjection(
+        project: Project,
+        injector: PublishingMetadataInjector,
+        expoPublishingHelper: ExpoPublishingHelper?,
+        expoProjects: List<ExpoGradleProjectProjection>,
+        artifacts: List<UnresolvedArtifactInfo>,
+    ) {
+        val transitiveDeps = VersionMediatingDependencySet()
+        var rncSupersededCoordinates: Set<Pair<String, String>> = emptySet()
+
+        if (isExpoProject && expoPublishingHelper != null) {
+            val expoTransitiveDeps = expoPublishingHelper.discoverAllExpoTransitiveDependencies(expoProjects)
+            Logging.log("Merged ${expoTransitiveDeps.size} transitive dependencies discovered from Expo")
+            expoTransitiveDeps.forEach {
+                Logging.log(
+                    "(*) dependency ${it.groupId}:${it.artifactId}:${it.version} (scope: ${it.scope}, " +
+                        "${if (it.optional) "optional" else "required"})",
+                )
+            }
+            transitiveDeps.addAll(expoTransitiveDeps)
+        }
+        // Never on Expo: the path above already covers every embedded module there, and the RNC
+        // discoverer doesn't filter by the Expo blacklist, so running both leaks Expo coordinates.
+        if (!isExpoProject && extension.experimentalIncludeTransitiveDependencies) {
+            val rncDiscovery = RncTransitiveDependencyDiscoverer(project).discover(artifacts)
+            Logging.log(
+                "Merged ${rncDiscovery.dependencies.size} transitive dependencies discovered by the RNC discoverer",
+            )
+            transitiveDeps.addAll(rncDiscovery.dependencies)
+            rncSupersededCoordinates = rncDiscovery.supersededCoordinates
+        }
+
+        if (isExpoProject || extension.experimentalIncludeTransitiveDependencies) {
+            // Coordinates that must never be published: they're embedded in the AAR, not
+            // resolvable from Maven. Distinct from "superseded" coordinates, which ARE re-injected
+            // (replacing a stale entry) and so must not be dropped here.
+            val hardExcludePredicate: (String, String) -> Boolean = { groupId, artifactId ->
+                (expoPublishingHelper?.shouldExcludeDependency(groupId, artifactId) ?: (groupId == project.rootProject.name)) ||
+                    artifacts.any { it.moduleGroup == groupId && it.moduleName == artifactId }
+            }
+            dropHardExcludedDependencies(transitiveDeps, hardExcludePredicate)
+
+            Logging.log(
+                "Total of ${transitiveDeps.size} unique transitive dependencies merged for POM/module.json injection",
+            )
+
+            val removalPredicate: (String, String) -> Boolean = { groupId, artifactId ->
+                hardExcludePredicate(groupId, artifactId) || rncSupersededCoordinates.contains(groupId to artifactId)
+            }
+
+            injector.configure(transitiveDeps, removalPredicate)
+            Logging.log("PublishingMetadataInjector ran: injected merged transitive dependencies into POM and Gradle Module Metadata")
+
+            // Informational only — throwing would recreate the upgrade break that the namespaced
+            // task name exists to prevent. `names` avoids realizing the task from whenReady.
+            if (project.tasks.names.contains(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME)) {
+                Logging.log(
+                    "NOTE: this project still registers a hand-written " +
+                        "'${Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME}' task. The plugin now performs " +
+                        "that removal itself (plus transitive-dependency injection) via " +
+                        "'${Constants.MODULE_METADATA_POST_PROCESS_TASK_NAME}'. The hand-written task is " +
+                        "redundant and can be deleted; leaving it in place is harmless.",
+                )
+            }
+        } else {
+            Logging.log(
+                "PublishingMetadataInjector skipped: project is not an Expo project and " +
+                    "experimentalIncludeTransitiveDependencies is disabled",
+            )
+        }
+    }
+
     private fun initializers() {
         RClassTransformer.project = project
         Logging.project = project

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/Constants.kt

@@ -1,6 +1,5 @@
 package com.callstack.react.brownfield.shared
 
-import com.callstack.react.brownfield.expo.utils.DependencyInfo
 import com.callstack.react.brownfield.utils.StringMatcher
 
 /**
@@ -40,6 +39,18 @@ object Constants {
 
     const val INTERMEDIATES_TEMP_DIR = PLUGIN_NAME
 
+    /**
+     * Plugin-owned task that post-processes generated Gradle Module Metadata.
+     *
+     * Never rename to the bare [LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME]: the plugin registers
+     * during `apply()`, before the consumer's script body, so claiming that name breaks every
+     * consumer still following the setup docs with "a task with that name already exists".
+     */
+    const val MODULE_METADATA_POST_PROCESS_TASK_NAME = "brownfieldRemoveDependenciesFromModuleFile"
+
+    /** The name the setup docs tell consumers to register themselves; must stay free for them. */
+    const val LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME = "removeDependenciesFromModuleFile"
+
     val BROWNFIELD_EXPO_TRANSITIVE_DEPS_WHITELISTED_MODULES_FOR_DISCOVERY =
         setOf("expo-modules-core", "expo-constants", "expo", "expo-updates")
     val BROWNFIELD_EXPO_TRANSITIVE_DEPS_ARTIFACTS_BLACKLIST =