@callstack/react-native-brownfield 6.0.0 → 6.1.0

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # @callstack/react-native-brownfield
 
+## 6.1.0
+
+### Minor Changes
+
+- [#520](https://github.com/callstack/react-native-brownfield/pull/520) [`b87cdff`](https://github.com/callstack/react-native-brownfield/commit/b87cdff0de1cb147289a7497973b6f191dc74134) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - fix: pick the right `.so` files for the Android AAR. With `useStrippedSoFiles = false`, the AAR now has `libappmodules.so` and `libreact_codegen_*.so`. Before this fix, those libs were missing and host apps crashed. The AAR also stops embedding the `.so` files of Maven dependencies. The host already gets those through the POM, so its build no longer fails with `2 files found with path 'lib/<abi>/<name>.so'`. If your app module builds or ships a `.so` of its own, list it in `reactBrownfield.dynamicLibs`, which is back. The build lists the `.so` files it left out in `<brownfield module>/build/reports/brownfield/<variant>/skipped-so.txt`. After upgrading, check that file: it lists the `.so` files that used to be in the AAR and now aren't.
+
+- [#522](https://github.com/callstack/react-native-brownfield/pull/522) [`20776bb`](https://github.com/callstack/react-native-brownfield/commit/20776bb714c2de1e962515aa7c88235b60c7dabf) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - feat: the published POM and `module.json` now follow the brownfield module's Gradle exclude rules (`configurations.all { exclude(...) }`). Before, the plugin re-added an excluded dependency when it injected the embedded libraries' dependencies, so the host app still resolved it. The excludes are also written onto every dependency the plugin injects, so the excluded library can't arrive through one of them. On Expo, list them in `android.excludeDependencies` (as `group:module` or `group`), which the config plugin writes into the generated module.
+
+### Patch Changes
+
+- [#512](https://github.com/callstack/react-native-brownfield/pull/512) [`520811c`](https://github.com/callstack/react-native-brownfield/commit/520811c47a122cacd1ec15f1b064ad08d699eebb) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - fix: package classes from libraries' local jars (`libs/*.jar`) into the Android AAR; previously host apps crashed with NoClassDefFoundError. If your app also has those classes, because it added the jar itself as a workaround or depends on a library that the jar bundles, the build now fails with duplicate classes: remove the app's copy
+
+- [#513](https://github.com/callstack/react-native-brownfield/pull/513) [`f3dbbd1`](https://github.com/callstack/react-native-brownfield/commit/f3dbbd1c2579f905a358faac0ad1677b3740cebc) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - fix: keep the resources of every library embedded in the Android AAR; previously only one library's `res/values` survived and host apps failed at resource linking. As in a regular app, the module's own `res` and `resValue`s win over a library's, and when two libraries define the same resource the first one wins (previously the last one won for files such as drawables)
+
+- [#521](https://github.com/callstack/react-native-brownfield/pull/521) [`58aedad`](https://github.com/callstack/react-native-brownfield/commit/58aedad94f38098424937533f2ce0b0c3df62067) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - fix: the AAR build no longer fails with duplicate resources when an embedded library ships the same drawables Metro generates for the app's bundle. Metro's copy wins.
+
+- [#503](https://github.com/callstack/react-native-brownfield/pull/503) [`6a258da`](https://github.com/callstack/react-native-brownfield/commit/6a258da42f2bd2cbb112f56948108323aeba74d9) Thanks [@RaphaelFakhri](https://github.com/RaphaelFakhri)! - `ReactNativeBrownfield.onMessage` no longer calls the callback a second time, with the raw message text, when the callback throws. The error now propagates instead of being swallowed.
+- Updated dependencies [[`20776bb`](https://github.com/callstack/react-native-brownfield/commit/20776bb714c2de1e962515aa7c88235b60c7dabf)]:
+  - @callstack/brownfield-cli@6.1.0
+
+## 6.0.1
+
+### Patch Changes
+
+- [#487](https://github.com/callstack/react-native-brownfield/pull/487) [`79817d1`](https://github.com/callstack/react-native-brownfield/commit/79817d1a21b0cb28ae63d41e935c57af8e7db39f) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - Support Expo modules in React Native CLI apps. `brownfield package:*` no longer runs `expo prebuild` on projects with committed `android/` and `ios/` directories, which used to delete the brownfield library module. Prebuild now runs only when the native directory is missing or gitignored. If you commit the generated directories of an Expo app, run `npx expo prebuild` yourself after changing `app.json` or config plugins. `create-react-native-brownfield` now detects Expo and sets up the iOS framework to use the Expo runtime. On a re-run after adding Expo, it also raises an existing framework target to iOS 16.4.
+
+  `--use-prebuilt-expo` now also turns Expo's precompiled modules on or off for `pod install`, and turns on Swift explicit modules so packaging works in projects that still carry the old `SWIFT_ENABLE_EXPLICIT_MODULES = NO` workaround. It defaults to building Expo from source when the app's React Native version doesn't match the one Expo's precompiled modules were built for.
+
+  `package:ios` now copies the expo-image dependency XCFrameworks (SDWebImage and libavif) as real files instead of symlinks into `node_modules`, so the package works when moved to another machine.
+
+  Re-running `create-react-native-brownfield` after `pod install` no longer adds a second Sources build phase to the framework target, which made the next `pod install` fail.
+
+  The `package:ios` script that `create-react-native-brownfield` adds now passes `--add-spm-package`, so the iOS app adds one local Swift package instead of every XCFramework. Existing scripts aren't changed.
+
+- [#508](https://github.com/callstack/react-native-brownfield/pull/508) [`7e63e20`](https://github.com/callstack/react-native-brownfield/commit/7e63e204c449ab36ce5b109ff3eb5db086260089) Thanks [@malopezr7](https://github.com/malopezr7)! - Fix an iOS crash with expo-updates 57 when updates are enabled. The Expo runtime no longer asks the Updates controller for its launch asset before the controller has started.
+
+- [#495](https://github.com/callstack/react-native-brownfield/pull/495) [`3b38aeb`](https://github.com/callstack/react-native-brownfield/commit/3b38aebb63810a8d1cc686bd70cccdeb279bf119) Thanks [@hurali97](https://github.com/hurali97)! - fix: resolve the namespace from AndroidManifest.xml `package` for libraries without a `namespace` in build.gradle
+
+- [#500](https://github.com/callstack/react-native-brownfield/pull/500) [`0f62490`](https://github.com/callstack/react-native-brownfield/commit/0f62490e7602d1aad56ee5d9eba2fd667dc0171a) Thanks [@hurali97](https://github.com/hurali97)! - fix(android): stop the scaffolded `ReactNativeHostManager` from loading React Native twice
+
+  The `ReactNativeHostManager.kt` generated by `npm create @callstack/react-native-brownfield` for React Native CLI projects called `loadReactNative(application)` and then `ReactNativeBrownfield.initialize(...)`. Both run `DefaultNewArchitectureEntryPoint.load()`, which overrides the React Native feature flags, so the app crashed on startup with `Feature flags cannot be overridden more than once`.
+
+  The generated host manager now:
+  - no longer calls `loadReactNative` (`ReactNativeBrownfield.initialize` already loads the native libraries and feature flags exactly once);
+  - passes the `ReactHost` as a factory to the non-deprecated `initialize` overload, so it is built after `SoLoader.init` instead of crashing with `SoLoader.init() not yet called`;
+  - keeps the one behavior `loadReactNative` provided on the side by flagging edge-to-edge when `IS_EDGE_TO_EDGE_ENABLED` is set.
+
+  Fixes [#492](https://github.com/callstack/react-native-brownfield/issues/492).
+
+- Updated dependencies [[`79817d1`](https://github.com/callstack/react-native-brownfield/commit/79817d1a21b0cb28ae63d41e935c57af8e7db39f), [`69fe3e3`](https://github.com/callstack/react-native-brownfield/commit/69fe3e3f05a49036cae1f3564a47ef3eed186155)]:
+  - @callstack/brownfield-cli@6.0.1
+
 ## 6.0.0
 
 ### Major Changes

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

@@ -113,10 +113,14 @@ dependencies {
     // minimum Gradle version) for every app that applies this plugin.
     compileOnly(libs.agp)
     compileOnly(libs.common)
+    compileOnly(libs.sdk.common)
+    compileOnly(libs.layoutlib.api)
     implementation(libs.asm.commons)
     implementation(libs.versioncompare)
     testImplementation(libs.agp)
     testImplementation(libs.common)
+    testImplementation(libs.sdk.common)
+    testImplementation(libs.layoutlib.api)
     testImplementation(libs.junit.jupiter)
     testImplementation(gradleTestKit())
     testImplementation(kotlin("test"))

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

@@ -19,6 +19,8 @@ detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
 [libraries]
 agp = { module = "com.android.tools.build:gradle", name = "agp", version.ref = "agp" }
 common = { module = "com.android.tools:common", version.ref = "common" }
+sdk-common = { module = "com.android.tools:sdk-common", version.ref = "common" }
+layoutlib-api = { module = "com.android.tools.layoutlib:layoutlib-api", 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-alpha10
+VERSION=2.0.0-alpha14
 GROUP=com.callstack.react
 IMPLEMENTATION_CLASS=com.callstack.react.brownfield.plugin.RNBrownfieldPlugin
 

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

@@ -19,11 +19,13 @@ 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.GradleExclude
 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.shared.gradleExcludes
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
 import com.callstack.react.brownfield.utils.DirectoryManager
 import com.callstack.react.brownfield.utils.Extension
@@ -33,6 +35,24 @@ import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.ProjectConfigurationException
 
+/**
+ * Coordinates that must never be published: embedded in the AAR (not resolvable from Maven), or
+ * excluded by the brownfield module's own Gradle rules.
+ */
+internal fun hardExcludePredicate(
+    project: Project,
+    expoPublishingHelper: ExpoPublishingHelper?,
+    artifacts: List<UnresolvedArtifactInfo>,
+    expoProjects: List<ExpoGradleProjectProjection>,
+    excludes: List<GradleExclude>,
+): (String, String) -> Boolean =
+    { groupId, artifactId ->
+        (expoPublishingHelper?.shouldExcludeDependency(groupId, artifactId) ?: (groupId == project.rootProject.name)) ||
+            artifacts.any { it.moduleGroup == groupId && it.moduleName == artifactId } ||
+            expoProjects.any { it.publication?.groupId == groupId && it.publication?.artifactId == artifactId } ||
+            excludes.any { it.matches(groupId, artifactId) }
+    }
+
 class RNBrownfieldPlugin : Plugin<Project> {
     private lateinit var extension: Extension
     private lateinit var project: Project
@@ -140,11 +160,8 @@ class RNBrownfieldPlugin : Plugin<Project> {
             // 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 } ||
-                    expoProjects.any { it.publication?.groupId == groupId && it.publication?.artifactId == artifactId }
-            }
+            val excludes = gradleExcludes(project)
+            val hardExcludePredicate = hardExcludePredicate(project, expoPublishingHelper, artifacts, expoProjects, excludes)
             dropHardExcludedDependencies(transitiveDeps, hardExcludePredicate)
 
             Logging.log(
@@ -155,7 +172,7 @@ class RNBrownfieldPlugin : Plugin<Project> {
                 hardExcludePredicate(groupId, artifactId) || rncSupersededCoordinates.contains(groupId to artifactId)
             }
 
-            injector.configure(transitiveDeps, removalPredicate)
+            injector.configure(transitiveDeps, removalPredicate, excludes)
             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
@@ -277,7 +294,7 @@ class RNBrownfieldPlugin : Plugin<Project> {
 
         /** ===== jniLibsProcessor ===== */
         val jniLibsProcessor = JNILibsProcessor(project)
-        jniLibsProcessor.processJniLibs(aarLibraries, variant)
+        jniLibsProcessor.processJniLibs(aarLibraries, variant, explodeTask)
 
         /** ===== proguardProcessor ===== */
         val proguardProcessor = ProguardProcessor(project)

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

@@ -8,8 +8,7 @@ import com.callstack.react.brownfield.exceptions.NameSpaceNotFound
 import com.callstack.react.brownfield.processors.VariantHelper
 import com.callstack.react.brownfield.utils.Extension
 import com.callstack.react.brownfield.utils.Utils
-import com.callstack.react.brownfield.utils.capitalized
-import org.gradle.api.GradleException
+import com.callstack.react.brownfield.utils.directoryGetter
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.file.DirectoryProperty
@@ -57,16 +56,9 @@ object RNSourceSets {
         // 2. Use the onVariants block to wire RN bundle outputs via the Variant Sources API
         componentsExtension.onVariants { variant ->
             val variantName = variant.name
-            val bundledAssetsVariantName =
-                VariantHelper.getBundledAssetsVariantName(
-                    variantName = variantName,
-                    buildTypeName = variant.buildType,
-                    isDebuggable = variant.debuggable,
-                )
-            val capitalizedBundledAssetsVariantName = bundledAssetsVariantName.capitalized()
             val appProject = getAppProject()
 
-            val jsBundleTaskName = "createBundle${capitalizedBundledAssetsVariantName}JsAndAssets"
+            val jsBundleTaskName = VariantHelper.getMetroBundleTaskName(variant)
 
             /**
              * Wire the bundle task's own `jsBundleDir`/`resourcesDir` outputs as *generated*
@@ -89,12 +81,7 @@ object RNSourceSets {
 
     /**
      * Wires `taskName`'s `getterName` output (expected to be a `DirectoryProperty`) as a
-     * generated source directory for `sources`.
-     *
-     * Resolving the task by name (rather than importing its class) keeps this plugin from
-     * depending on RNGP's/expo-updates' internal task types. If the task, or its expected output
-     * property, isn't there, this fails the build immediately with a clear message instead of
-     * silently producing an empty/stale source directory.
+     * generated source directory for `sources`. See [directoryGetter] for the checks.
      */
     private fun wireGeneratedSourceDirectory(
         appProject: Project,
@@ -104,27 +91,7 @@ object RNSourceSets {
     ) {
         if (sources == null) return
 
-        val task =
-            appProject.tasks.findByName(taskName)
-                ?: throw GradleException(
-                    "brownfield: expected task '$taskName' was not found in project " +
-                        "'${appProject.path}'. Check that the plugin producing it is applied there.",
-                )
-
-        val getter =
-            runCatching { task.javaClass.getMethod(getterName) }.getOrElse {
-                throw GradleException(
-                    "brownfield: task '$taskName' (${task.javaClass.name}) does not expose " +
-                        "'$getterName()'. The plugin that registers it most likely changed its " +
-                        "API; the brownfield Gradle plugin needs updating to match.",
-                    it,
-                )
-            }
-
-        check(DirectoryProperty::class.java.isAssignableFrom(getter.returnType)) {
-            "brownfield: '$taskName.$getterName()' no longer returns a DirectoryProperty."
-        }
-
+        val getter = directoryGetter(appProject, taskName, getterName)
         val taskProvider = appProject.tasks.named(taskName)
         sources.addGeneratedSourceDirectory(taskProvider) { t -> getter.invoke(t) as DirectoryProperty }
     }

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

@@ -1,28 +1,27 @@
 package com.callstack.react.brownfield.processors
 
 import com.android.build.api.variant.LibraryVariant
-import com.callstack.react.brownfield.shared.Logging
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
 import com.callstack.react.brownfield.utils.Extension
 import com.callstack.react.brownfield.utils.capitalized
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
+import org.gradle.api.Task
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.provider.ListProperty
-import org.gradle.api.provider.Property
 import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.InputDirectory
 import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.PathSensitive
 import org.gradle.api.tasks.PathSensitivity
 import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.TaskProvider
 import java.io.File
-import kotlin.collections.component1
-import kotlin.collections.component2
 
 /**
  * Below contains a list of dynamic libs which we should not embed
@@ -37,126 +36,246 @@ val IGNORE_EMBEDDED_LIBS =
         "libreactnative.so",
     )
 
+private val ABIS = listOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
+
+private const val APP_MODULES_LIB = "libappmodules.so"
+
+internal enum class SkipReason { IGNORED, NOT_EMBEDDED }
+
+/**
+ * @property copies source file for each `<abi>/<name>` that goes into the AAR
+ * @property unmatchedDynamicLibs dynamicLibs entries that match no file in the app module's output
+ * @property skipped every lib name that no ABI copies, with why
+ * @property ignoredDynamicLibs dynamicLibs entries dropped because an ignore entry matches them
+ * @property excludedAbis ABIs the embedded AARs ship but the app module did not build
+ */
+internal data class JniLibsPlan(
+    val copies: Map<String, File>,
+    val unmatchedDynamicLibs: Set<String>,
+    val skipped: Map<String, SkipReason>,
+    val ignoredDynamicLibs: Set<String> = emptySet(),
+    val excludedAbis: Set<String> = emptySet(),
+)
+
+private fun isAppOwned(name: String) = name == APP_MODULES_LIB || (name.startsWith("libreact_codegen_") && name.endsWith(".so"))
+
+private fun isIgnored(
+    name: String,
+    ignoredLibs: List<String>,
+) = ignoredLibs.any { entry -> name == entry || name.contains(entry) }
+
+private fun libNames(dir: File?): List<String> = dir?.listFiles()?.filter { it.isFile }?.map { it.name }.orEmpty()
+
+/**
+ * Picks the .so files for the AAR: the app module's own libs, the libs the embedded libraries
+ * ship, and [dynamicLibs], minus [ignoredLibs]. Libs that only come from Maven dependencies stay
+ * out, because the host app gets them through the published POM.
+ */
+internal fun planJniLibs(
+    aarJniDirs: List<File>,
+    appNativeLibsDir: File?,
+    ignoredLibs: List<String>,
+    dynamicLibs: List<String>,
+): JniLibsPlan {
+    val copies = linkedMapOf<String, File>()
+    val matchedDynamicLibs = mutableSetOf<String>()
+    val candidates = mutableMapOf<String, SkipReason>()
+    val ignoredDynamicLibs = mutableSetOf<String>()
+
+    // An ABI folder without libappmodules.so crashes on devices that pick it, so follow the app
+    // module's ABIs (it may use abiFilters) and only fall back to all of them when it built none.
+    val appAbis = ABIS.filter { abi -> appNativeLibsDir?.let { File(it, abi).isDirectory } == true }
+    val abis = appAbis.ifEmpty { ABIS }
+    val excludedAbis = ABIS.filter { abi -> abi !in abis && aarJniDirs.any { File(it, abi).isDirectory } }.toSet()
+
+    for (abi in abis) {
+        val appAbiDir = appNativeLibsDir?.let { File(it, abi) }
+        val appNames = libNames(appAbiDir).toSet()
+
+        val embedded = linkedMapOf<String, File>()
+        aarJniDirs.forEach { jniDir ->
+            val abiDir = File(jniDir, abi)
+            libNames(abiDir).forEach { name -> embedded.putIfAbsent(name, File(abiDir, name)) }
+        }
+        val extra = dynamicLibs.filter { it in appNames }
+        matchedDynamicLibs += extra
+        ignoredDynamicLibs += extra.filter { isIgnored(it, ignoredLibs) }
+
+        val wanted = appNames.filter(::isAppOwned) + (embedded.keys + extra).filterNot { isIgnored(it, ignoredLibs) }
+        wanted.forEach { name ->
+            copies["$abi/$name"] = appAbiDir?.let { File(it, name) }?.takeIf { it.isFile } ?: embedded.getValue(name)
+        }
+
+        (appNames + embedded.keys).filterNot { it in wanted }.forEach { name ->
+            val reason = if (isIgnored(name, ignoredLibs)) SkipReason.IGNORED else SkipReason.NOT_EMBEDDED
+            // IGNORED wins: once a name is ignored in one ABI it is ignored everywhere.
+            if (candidates[name] != SkipReason.IGNORED) candidates[name] = reason
+        }
+    }
+
+    val copiedNames = copies.keys.map { it.substringAfter('/') }.toSet()
+    return JniLibsPlan(
+        copies = copies,
+        unmatchedDynamicLibs = dynamicLibs.toSet() - matchedDynamicLibs,
+        skipped = candidates.filterKeys { it !in copiedNames }.toSortedMap(),
+        ignoredDynamicLibs = ignoredDynamicLibs,
+        excludedAbis = excludedAbis,
+    )
+}
+
+internal fun planWarnings(plan: JniLibsPlan): List<String> =
+    plan.unmatchedDynamicLibs.map { entry ->
+        "Brownfield: dynamicLibs entry '$entry' matches no .so file in the app module's native output."
+    } +
+        plan.ignoredDynamicLibs.map { name ->
+            "Brownfield: dynamicLibs entry '$name' is not in the AAR because an ignore entry matches it. " +
+                "Remove that entry from ignoreEmbeddedLibs to embed it."
+        }
+
+/**
+ * One line naming the libs no embedded library ships, or null when there are none. Ignored libs
+ * are left out: they are skipped on purpose and would only add noise on every build.
+ */
+internal fun skippedSummary(
+    plan: JniLibsPlan,
+    reportFile: File?,
+): String? {
+    val names = plan.skipped.filterValues { it == SkipReason.NOT_EMBEDDED }.keys.sorted()
+    if (names.isEmpty()) return null
+    val details = reportFile?.let { " Details: ${it.absolutePath}" }.orEmpty()
+    return "Brownfield: left ${names.size} .so file(s) out of the AAR because no embedded library ships them: " +
+        "${names.joinToString(", ")}. If one comes from a Maven dependency, the host app gets it through the POM. " +
+        "If not (for example, your app module builds or ships it), add it to reactBrownfield.dynamicLibs.$details"
+}
+
+internal data class AppNativeLibsSource(val relativeDir: String, val producerTaskName: String)
+
+internal fun appNativeLibsSource(
+    variantName: String,
+    useStrippedSoFiles: Boolean,
+): AppNativeLibsSource {
+    val capitalized = variantName.capitalized()
+    return if (useStrippedSoFiles) {
+        val task = "strip${capitalized}DebugSymbols"
+        AppNativeLibsSource("intermediates/stripped_native_libs/$variantName/$task/out/lib", task)
+    } else {
+        val task = "merge${capitalized}NativeLibs"
+        AppNativeLibsSource("intermediates/merged_native_libs/$variantName/$task/out/lib", task)
+    }
+}
+
 @CacheableTask
 abstract class ProcessAndCopyJniLibsTask : DefaultTask() {
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
     abstract val aarJniDirs: ConfigurableFileCollection
 
-    @get:InputDirectory
+    // @InputFiles rather than @InputDirectory: a variant without native code has no such dir,
+    // and @InputDirectory would fail validation before the task can run.
+    @get:InputFiles
     @get:Optional
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    abstract val strippedLibsDir: DirectoryProperty
+    abstract val appNativeLibsDir: DirectoryProperty
 
     @get:Input
-    abstract val useStrippedSoFiles: Property<Boolean>
+    abstract val extraIgnoredLibs: ListProperty<String>
 
     @get:Input
-    abstract val extraIgnoredLibs: ListProperty<String>
+    abstract val dynamicLibs: ListProperty<String>
 
     @get:OutputDirectory
     abstract val outputDirectory: DirectoryProperty
 
+    // A declared output, so it is restored on cache hits when nothing is logged.
+    @get:OutputFile
+    abstract val skippedReportFile: RegularFileProperty
+
     @TaskAction
     fun execute() {
         val outDir = outputDirectory.get().asFile
-        // Clear out old data to ensure clean, reproducible builds
         outDir.deleteRecursively()
         outDir.mkdirs()
 
-        val existingJNILibs =
-            listOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
-                .associateWith { mutableListOf<String>() }
-                .toMutableMap()
-
-        // 1. Scan and process duplicate libs from AAR paths
-        aarJniDirs.forEach { jniDir ->
-            if (jniDir.exists()) {
-                processNestedLibs(jniDir.listFiles(), existingJNILibs)
-
-                // If not using stripped files, copy the unstripped ones directly to our output
-                if (!useStrippedSoFiles.get()) {
-                    jniDir.copyRecursively(outDir, overwrite = true)
-                }
-            }
+        val appDir = appNativeLibsDir.orNull?.asFile
+        if (appDir != null && !appDir.exists()) {
+            logger.warn(
+                "Brownfield: $appDir does not exist, so libappmodules.so and libreact_codegen_*.so " +
+                    "were not found and are not in the AAR.",
+            )
         }
 
-        // 2. If using stripped files, copy targeted files from the stripped directory
-        if (useStrippedSoFiles.get() && strippedLibsDir.isPresent) {
-            copyStrippedSoLibs(outDir, existingJNILibs)
-        }
-    }
+        val plan =
+            planJniLibs(
+                aarJniDirs.files.toList(),
+                appDir,
+                IGNORE_EMBEDDED_LIBS + extraIgnoredLibs.getOrElse(emptyList()),
+                dynamicLibs.getOrElse(emptyList()),
+            )
 
-    private fun copyStrippedSoLibs(
-        outDir: File,
-        existingJNILibs: MutableMap<String, MutableList<String>>,
-    ) {
-        val fromDir = strippedLibsDir.get().asFile
-        if (!fromDir.exists()) return
+        plan.copies.forEach { (path, source) -> source.copyTo(File(outDir, path), overwrite = true) }
 
-        existingJNILibs.keys.forEach { arch ->
-            copyArchStrippedSoLibs(fromDir, outDir, arch)
+        writeReport(plan)
+        val reportFile = skippedReportFile.get().asFile
+        skippedSummary(plan, reportFile)?.let { logger.lifecycle(it) }
+        plan.skipped.forEach { (name, reason) -> logger.info("Brownfield: skipped $name ($reason)") }
+        planWarnings(plan).forEach { logger.warn(it) }
+        if (plan.excludedAbis.isNotEmpty()) {
+            logger.info("Brownfield: left out ABIs the app module did not build: ${plan.excludedAbis.sorted().joinToString(", ")}")
         }
     }
 
-    private fun copyArchStrippedSoLibs(
-        fromDir: File,
-        outDir: File,
-        arch: String,
-    ) {
-        val sourceArchDir = File(fromDir, arch)
-        if (!sourceArchDir.exists()) return
-
-        val destArchDir = File(outDir, arch).apply { mkdirs() }
-        sourceArchDir.listFiles()?.forEach { file ->
-            copyIfAllowed(file, destArchDir)
-        }
+    private fun writeReport(plan: JniLibsPlan) {
+        val reportFile = skippedReportFile.get().asFile
+        reportFile.parentFile.mkdirs()
+        val lines =
+            if (plan.skipped.isEmpty()) {
+                listOf("No .so files were left out.")
+            } else {
+                listOfNotNull(skippedSummary(plan, null)) + plan.skipped.map { (name, reason) -> "$name: $reason" }
+            }
+        reportFile.writeText(lines.joinToString("\n", postfix = "\n"))
     }
+}
 
-    private fun copyIfAllowed(
-        file: File,
-        destArchDir: File,
-    ) {
-        val name = file.name
-        if (!matchesAllowedLib(name)) return
+internal fun wireAarJniDirs(
+    task: ProcessAndCopyJniLibsTask,
+    jniDirs: List<File>,
+    explodeTask: TaskProvider<out Task>,
+) {
+    // The dirs are plain paths, so Gradle can't infer who fills them; without this the task can
+    // run before the AARs are unpacked and drop every embedded lib.
+    task.aarJniDirs.setFrom(jniDirs)
+    task.aarJniDirs.builtBy(explodeTask)
+}
 
-        try {
-            file.copyTo(File(destArchDir, name), overwrite = true)
-        } catch (e: java.io.IOException) {
-            Logging.error("Failed to copy $name: ${e.message}", e.cause)
-        }
-    }
+internal fun configureProcessJniTask(
+    task: ProcessAndCopyJniLibsTask,
+    project: Project,
+    appProject: Project,
+    projectExt: Extension,
+    variantName: String,
+    jniDirs: List<File>,
+    explodeTask: TaskProvider<out Task>,
+) {
+    val source = appNativeLibsSource(variantName, projectExt.useStrippedSoFiles)
 
-    private fun matchesAllowedLib(name: String): Boolean {
-        val isCodegenLib = name.startsWith("libreact_codegen_") && name.endsWith(".so")
-        val ignoredLibs = IGNORE_EMBEDDED_LIBS + extraIgnoredLibs.getOrElse(emptyList())
-        val isIgnoredLib = ignoredLibs.any { lib -> name == lib || name.contains(lib) }
-        return name == "libappmodules.so" || isCodegenLib || !isIgnoredLib
-    }
+    task.extraIgnoredLibs.set(projectExt.ignoreEmbeddedLibs)
+    task.dynamicLibs.set(projectExt.dynamicLibs)
+    wireAarJniDirs(task, jniDirs, explodeTask)
+    task.appNativeLibsDir.set(appProject.layout.buildDirectory.dir(source.relativeDir))
+    task.skippedReportFile.set(project.layout.buildDirectory.file("reports/brownfield/$variantName/skipped-so.txt"))
 
-    private fun processNestedLibs(
-        files: Array<File>?,
-        existingJNILibs: MutableMap<String, MutableList<String>>,
-    ) {
-        files?.forEach { folder ->
-            val libFiles = folder.listFiles() ?: return@forEach
-            val libList = existingJNILibs[folder.name] ?: return@forEach
-
-            libFiles.forEach { file ->
-                if (file.name in libList) {
-                    file.delete()
-                } else {
-                    libList.add(file.name)
-                }
-            }
-        }
-    }
+    task.dependsOn(
+        "${appProject.path}:${source.producerTaskName}",
+        "${project.path}:generateCodegenSchemaFromJavaScript",
+    )
 }
 
 class JNILibsProcessor(val project: Project) {
     fun processJniLibs(
         aarLibraries: Collection<AndroidArchiveLibrary>,
         variant: LibraryVariant,
+        explodeTask: TaskProvider<out Task>,
     ) {
         val variantName = variant.name
         val capitalizedVariantName = variantName.capitalized()
@@ -165,25 +284,8 @@ class JNILibsProcessor(val project: Project) {
 
         val processJniTask =
             project.tasks.register("processCustomJniLibsFor$capitalizedVariantName", ProcessAndCopyJniLibsTask::class.java) {
-                it.useStrippedSoFiles.set(projectExt.useStrippedSoFiles)
-                it.extraIgnoredLibs.set(projectExt.ignoreEmbeddedLibs)
-
-                val jniDirs =
-                    aarLibraries.map { aarLib ->
-                        aarLib.getJniDir()
-                    }
-
-                it.aarJniDirs.setFrom(jniDirs)
-
-                val fromDirProvider =
-                    appProject.layout.buildDirectory.dir(
-                        "intermediates/stripped_native_libs/$variantName/strip${capitalizedVariantName}DebugSymbols/out/lib",
-                    )
-                it.strippedLibsDir.set(fromDirProvider)
-
-                val stripTaskPath = ":${appProject.name}:strip${capitalizedVariantName}DebugSymbols"
-                val codegenTaskPath = ":${project.name}:generateCodegenSchemaFromJavaScript"
-                it.dependsOn(stripTaskPath, codegenTaskPath)
+                val jniDirs = aarLibraries.map { aarLib -> aarLib.getJniDir() }
+                configureProcessJniTask(it, project, appProject, projectExt, variantName, jniDirs, explodeTask)
             }
 
         variant.sources.jniLibs?.addGeneratedSourceDirectory(