expo-brownfield 57.0.6 → 57.0.7

package/CHANGELOG.md

@@ -10,6 +10,12 @@
 
 ### 💡 Others
 
+## 57.0.7 — 2026-07-22
+
+### 🎉 New features
+
+- [android] Add support for publishing a single fused AAR via AGP Fused Library ([#47921](https://github.com/expo/expo/pull/45878) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+
 ## 57.0.6 — 2026-07-17
 
 _This version does not introduce any user-facing changes._

package/android/build.gradle

@@ -4,7 +4,7 @@ plugins {
 }
 
 group = 'expo.modules.brownfield'
-version = '57.0.6'
+version = '57.0.7'
 
 expoModule {
   canBePublished false
@@ -14,7 +14,7 @@ android {
   namespace "expo.modules.brownfield"
   defaultConfig {
     versionCode 1
-    versionName '57.0.6'
+    versionName '57.0.7'
   }
 }
 

package/cli/src/commands/build-android.ts

@@ -17,8 +17,9 @@ const buildAndroid = async (command: Command) => {
   }
   printAndroidConfig(config);
 
+  const extraGradleArgs = config.fused ? ['-Pbrownfield.fused=true'] : [];
   for (const task of config.tasks) {
-    await runTask(task, config.verbose, config.dryRun);
+    await runTask(task, config.verbose, config.dryRun, extraGradleArgs);
   }
 };
 

package/cli/src/index.ts

@@ -16,6 +16,7 @@ program
   .option('-d, --debug', 'build debug variant')
   .option('-r, --release', 'build release variant')
   .option('-a, --all', 'build both debug and release variants')
+  .option('--fused', 'publish a single fat AAR per variant via AGP Fused Library')
   .option('--verbose', 'forward all output to the terminal')
   .option('-l, --library <library>', 'name of the brownfield library')
   .option('-t, --task <task...>', 'publishing task to be run (multiple can be passed)')

package/cli/src/utils/android.ts

@@ -7,9 +7,21 @@ import CLIError from './error';
 import { withSpinner } from './spinner';
 import type { AndroidConfig, BuildVariant } from './types';
 
-export const buildPublishingTask = (variant: BuildVariant, repository: string): string => {
-  const repositoryName = repository === 'MavenLocal' ? repository : `${repository}Repository`;
-  return `publishBrownfield${variant}PublicationTo${repositoryName}`;
+export const buildPublishingTask = (
+  variant: BuildVariant,
+  repository: string,
+  fusedOpts: { fused: boolean; library: string } = { fused: false, library: '' }
+): string => {
+  const repositoryName =
+    repository.toLowerCase() === 'mavenlocal' ? 'MavenLocal' : `${repository}Repository`;
+  const task = `publishBrownfield${variant}PublicationTo${repositoryName}`;
+  // In `--fused` mode, route the task to the matching sibling subproject:
+  // `:<lib>-fused-release` for Release, `:<lib>-fused-debug` for Debug.
+  if (fusedOpts.fused) {
+    const siblingSuffix = variant === 'Debug' ? 'debug' : 'release';
+    return `:${fusedOpts.library}-fused-${siblingSuffix}:${task}`;
+  }
+  return task;
 };
 
 export const findBrownfieldLibrary = (): string | undefined => {
@@ -59,6 +71,7 @@ export const printAndroidConfig = (config: AndroidConfig) => {
   console.log(chalk.bold('Resolved build configuration'));
   console.log(` - Build variant: ${chalk.blue(config.variant)}`);
   console.log(` - Library: ${chalk.blue(config.library)}`);
+  console.log(` - Fused: ${chalk.blue(config.fused)}`);
   console.log(` - Verbose: ${chalk.blue(config.verbose)}`);
   console.log(` - Dry run: ${chalk.blue(config.dryRun)}`);
   console.log(` - Tasks:`);
@@ -93,15 +106,33 @@ export const processTasks = (stdout: string): string[] => {
   );
 };
 
-export const runTask = async (task: string, verbose: boolean, dryRun: boolean) => {
+export const runTask = async (
+  task: string,
+  verbose: boolean,
+  dryRun: boolean,
+  extraGradleArgs: string[] = []
+) => {
+  // Fused-shaped tasks (e.g. passed manually via -t without --fused) must still
+  // activate fused mode in Gradle: without `-Pbrownfield.fused=true` the fused
+  // sibling subprojects are inert (no publications) and the conditional AGP
+  // force-bump in the root build.gradle never applies, so the build would fail
+  // mid-execution under the version catalog's AGP.
+  const fusedProperty = '-Pbrownfield.fused=true';
+  const isFusedTask = /(?:^|:)[^:\s]+-fused-(?:release|debug):/.test(task);
+  const perTaskArgs =
+    isFusedTask && !extraGradleArgs.includes(fusedProperty)
+      ? [...extraGradleArgs, fusedProperty]
+      : extraGradleArgs;
+
+  const args = [task, ...perTaskArgs];
   if (dryRun) {
-    console.log(`./gradlew ${task}`);
+    console.log(`./gradlew ${args.join(' ')}`);
     return;
   }
 
   return withSpinner({
     operation: () =>
-      spawnAsync('./gradlew', [task], {
+      spawnAsync('./gradlew', args, {
         cwd: path.join(process.cwd(), 'android'),
         stdio: verbose ? 'inherit' : 'pipe',
       }),

package/cli/src/utils/config.ts

@@ -1,4 +1,5 @@
 import type { OptionValues } from 'commander';
+import { getConfig } from 'expo/config';
 import fs from 'node:fs';
 import path from 'node:path';
 
@@ -16,12 +17,15 @@ import type {
 import { HOST_PROVIDED_FRAMEWORKS_KEY } from '../../../shared/build';
 
 export const resolveBuildConfigAndroid = (options: OptionValues): AndroidConfig => {
-  const variant = resolveVariant(options);
+  const fused = !!options.fused;
+  const variant: BuildVariant = resolveVariant(options);
+  const library = resolveLibrary(options);
   return {
     ...resolveCommonConfig(options),
-    library: resolveLibrary(options),
-    tasks: resolveTaskArray(options, variant),
+    library,
+    tasks: resolveTaskArray(options, variant, { fused, library }),
     variant,
+    fused,
   };
 };
 
@@ -157,15 +161,66 @@ const resolveLibrary = (options: OptionValues): string => {
   return options.library || findBrownfieldLibrary();
 };
 
-const resolveTaskArray = (options: OptionValues, variant: BuildVariant): string[] => {
+const resolveTaskArray = (
+  options: OptionValues,
+  variant: BuildVariant,
+  fusedOpts: { fused: boolean; library: string }
+): string[] => {
   const tasks: string[] = options.task ?? [];
-  const repoTasks = (options.repository ?? []).map((repo: string) =>
-    buildPublishingTask(variant, repo)
+  let repositories: string[] = options.repository ?? [];
+  if (tasks.length === 0 && repositories.length === 0) {
+    repositories = resolveLocalRepositoriesFromAppConfig(!!options.verbose);
+    if (repositories.length > 0) {
+      console.info(
+        `No --repo or --task specified; defaulting to local repositories from the app config: ${repositories.join(', ')}`
+      );
+    }
+  }
+  // In `--fused` mode, `--all` expands to separate Debug + Release task
+  // invocations against the matching sibling subprojects.
+  const variantsForRepoTasks: BuildVariant[] =
+    fusedOpts.fused && variant === 'All' ? ['Debug', 'Release'] : [variant];
+  const repoTasks = repositories.flatMap((repo) =>
+    variantsForRepoTasks.map((v) => buildPublishingTask(v, repo, fusedOpts))
   );
 
   return Array.from(new Set([...tasks, ...repoTasks]));
 };
 
+const resolveLocalRepositoriesFromAppConfig = (verbose: boolean): string[] => {
+  let publishing: unknown;
+  try {
+    const { exp } = getConfig(process.cwd(), { skipSDKVersionRequirement: true });
+    const plugin = exp.plugins?.find(
+      (entry): entry is [string, any] => Array.isArray(entry) && entry[0] === 'expo-brownfield'
+    );
+    publishing = plugin?.[1]?.android?.publishing;
+  } catch (error) {
+    // App config could not be evaluated here — fall through to the plugin's
+    // default publishing target below.
+    if (verbose) {
+      console.warn(
+        `Could not read \`android.publishing\` from the app config, falling back to MavenLocal: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+
+  const entries =
+    Array.isArray(publishing) && publishing.length > 0 ? publishing : [{ type: 'localMaven' }];
+  const repositories = entries.flatMap((entry) => {
+    if (entry?.type === 'localMaven') {
+      return ['MavenLocal'];
+    }
+    if (entry?.type === 'localDirectory' && typeof entry?.name === 'string') {
+      return [entry.name];
+    }
+    return [];
+  });
+  return Array.from(new Set(repositories));
+};
+
 const resolveVariant = (options: OptionValues): BuildVariant => {
   let variant: BuildVariant = 'All';
   if (options.release && !options.debug) {

package/cli/src/utils/error.ts

@@ -20,7 +20,8 @@ type ErrorType =
 class CLIError {
   private static readonly errorSymbol: string = '✖';
   private static readonly errorMessages: Record<ErrorType, string> = {
-    'android-task-repo': 'At least one task or repository must be specified',
+    'android-task-repo':
+      'At least one task or repository must be specified. The app config declares no local Maven repositories to default to, and remote repositories are never published to implicitly — pass `--repo <name>` or `-t <gradle task>` explicitly.',
     'android-directory-not-found': 'Cannot find `android` directory in the project',
     'android-library-unknown-error': 'Unknown error occurred while finding brownfield library',
     'android-library-not-found': 'Could not find brownfield library in the project',

package/cli/src/utils/prebuild.ts

@@ -17,14 +17,24 @@ export const validatePrebuild = async (
 
   if (!checkPrebuild(platform)) {
     console.info(`${chalk.yellow(`⚠ Prebuild for platform: ${platform} is missing`)}`);
-    const response = await prompts({
-      type: 'confirm',
-      name: 'shouldRunPrebuild',
-      message: 'Do you want to run the prebuild now?',
-      initial: false,
-    });
 
-    if (response.shouldRunPrebuild) {
+    let shouldRunPrebuild: boolean;
+    if (isInteractive()) {
+      const response = await prompts({
+        type: 'confirm',
+        name: 'shouldRunPrebuild',
+        message: 'Do you want to run the prebuild now?',
+        initial: false,
+      });
+      shouldRunPrebuild = !!response.shouldRunPrebuild;
+    } else {
+      console.info(
+        `Non-interactive shell detected; running \`npx expo prebuild --platform ${platform}\` automatically`
+      );
+      shouldRunPrebuild = true;
+    }
+
+    if (shouldRunPrebuild) {
       await withSpinner({
         operation: () => spawnAsync('npx', ['expo', 'prebuild', '--platform', platform]),
         loaderMessage: `Running 'npx expo prebuild' for platform: ${platform}...`,
@@ -109,3 +119,7 @@ const checkPrebuild = (platform: Platform): boolean => {
   const nativeDirectory = path.join(process.cwd(), platform);
   return fs.existsSync(nativeDirectory);
 };
+
+const isInteractive = (): boolean => {
+  return !!process.stdin.isTTY && !!process.stdout.isTTY;
+};

package/cli/src/utils/types.ts

@@ -20,6 +20,7 @@ export interface AndroidConfig extends CommonConfig {
   library: string;
   tasks: string[];
   variant: BuildVariant;
+  fused: boolean;
 }
 
 export interface PackageConfiguration {

package/gradle-plugins/brownfield/src/main/kotlin/expo/modules/plugin/ExpoBrownfieldSetupPlugin.kt

@@ -12,6 +12,7 @@ class ExpoBrownfieldSetupPlugin : Plugin<Project> {
   override fun apply(project: Project) {
     project.evaluationDependsOn(":expo")
     setupDependencySubstitution(project)
+    setupFusedModeStripping(project)
 
     project.afterEvaluate { project ->
       setupSourceSets(project)
@@ -23,6 +24,61 @@ class ExpoBrownfieldSetupPlugin : Plugin<Project> {
     }
   }
 
+  /**
+   * In `--fused` builds, strips entries from the autolinking-generated
+   * `ExpoModulesPackageList.kt` by package prefix, via
+   * `-Pbrownfield.fused.strip-packages=expo.modules.foo.,expo.modules.bar.`.
+   *
+   * This is the companion escape hatch to `-Pbrownfield.fused.skip=<project,...>`
+   * in the fused sibling's build script: a module excluded from the fat AAR still
+   * has its `Package` class referenced by `ExpoModulesPackageList.<clinit>`, which
+   * would crash the host with `NoClassDefFoundError` at startup — stripping the
+   * matching entries here keeps the package list consistent with the AAR contents.
+   * Inert unless both properties are set.
+   */
+  private fun setupFusedModeStripping(brownfieldProject: Project) {
+    if (brownfieldProject.findProperty("brownfield.fused") != "true") return
+
+    val expoProject = brownfieldProject.rootProject.findProject(":expo") ?: return
+
+    val stripPrefixes =
+      (brownfieldProject.findProperty("brownfield.fused.strip-packages") as? String)
+        ?.split(',')
+        ?.map { it.trim() }
+        ?.filter { it.isNotEmpty() }
+        ?.toSet()
+        ?: emptySet()
+
+    if (stripPrefixes.isEmpty()) return
+
+    // `:expo` is already evaluated (forced by `evaluationDependsOn(":expo")` at the
+    // top of `apply`), so we read the task directly — no afterEvaluate needed.
+    val task = expoProject.tasks.findByName("generatePackagesList") ?: return
+    task.doLast {
+      val outputFile =
+        expoProject.layout.buildDirectory
+          .file("generated/expo/src/main/java/expo/modules/ExpoModulesPackageList.kt")
+          .get()
+          .asFile
+      if (!outputFile.exists()) {
+        expoProject.logger.warn(
+          "brownfield.fused: ExpoModulesPackageList.kt not found at ${outputFile.path}; nothing to strip"
+        )
+        return@doLast
+      }
+      val original = outputFile.readText()
+      val stripped =
+        original
+          .lineSequence()
+          .filter { line -> stripPrefixes.none { prefix -> line.contains(prefix) } }
+          .joinToString("\n")
+      outputFile.writeText(stripped)
+      expoProject.logger.lifecycle(
+        "brownfield.fused: stripped ExpoModulesPackageList entries matching ${stripPrefixes.joinToString(", ")}"
+      )
+    }
+  }
+
   /**
    * Setup the dependency substitution for `react-android` and `hermes-android`.
    *

package/gradle-plugins/publish/build.gradle.kts

@@ -14,7 +14,10 @@ dependencies {
   implementation("expo.modules:expo-autolinking-plugin-shared")
   implementation("org.json:json:20250517")
   implementation(gradleApi())
-  compileOnly("com.android.tools.build:gradle:8.5.0")
+  // Matches FUSED_AGP_VERSION in the config plugin — the newest AGP the plugin can
+  // run against (forced in fused mode). Compiling against a newer major than the
+  // runtime AGP risks NoSuchMethodError on changed APIs.
+  compileOnly("com.android.tools.build:gradle:8.13.0")
 }
 
 java {

package/gradle-plugins/publish/src/main/kotlin/expo/modules/plugin/prebuilts.kt

@@ -13,6 +13,14 @@ import org.gradle.api.tasks.TaskProvider
  */
 internal fun setupPrebuiltsCopying(rootProject: Project) {
   rootProject.afterEvaluate {
+    // In `--fused` mode the user is publishing a single fat AAR via Fused Library that
+    // already merges every Expo module's classes/resources/jni inside it — the
+    // per-module mavenLocal/remote re-publish loop below would emit redundant
+    // coordinates next to the fat AAR. Skip.
+    if (rootProject.findProperty("brownfield.fused") == "true") {
+      return@afterEvaluate
+    }
+
     val configExtension = getConfigExtension(rootProject)
 
     if (configExtension.publications.isEmpty) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-brownfield",
-  "version": "57.0.6",
+  "version": "57.0.7",
   "description": "Toolkit and APIs for adding brownfield setup to Expo projects",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -41,7 +41,7 @@
     "chalk": "^4.1.2",
     "commander": "^14.0.3",
     "diff": "^5.2.0",
-    "expo-build-properties": "~57.0.6",
+    "expo-build-properties": "~57.0.7",
     "expo-manifests": "~57.0.1",
     "ora": "^5.4.1",
     "prompts": "^2.4.2"
@@ -53,15 +53,15 @@
     "@types/prompts": "^2.0.6",
     "@types/react": "~19.2.0",
     "glob": "^13.0.6",
-    "expo": "57.0.7",
-    "expo-module-scripts": "56.0.3",
-    "create-expo": "5.0.0"
+    "expo": "57.0.8",
+    "create-expo": "5.0.0",
+    "expo-module-scripts": "56.0.3"
   },
   "peerDependencies": {
     "expo": "*",
     "react": "*"
   },
-  "gitHead": "0dac79c8469fa00b76fb8f402c47ed61f3d6317e",
+  "gitHead": "a4789f1e53353f4929b0baddcfe5a7c622b99c71",
   "scripts": {
     "build": "expo-module build",
     "build:shared": "expo-module build shared",

package/plugin/src/android/plugins/withGradlePropertiesPlugin.ts

@@ -14,10 +14,63 @@ const withGradlePropertiesPlugin: ConfigPlugin = (config) => {
       }
     }
 
+    // Opt into AGP's Fused Library Preview. The `.publicationOnly=false` flag lets
+    // `include(project(...))` resolve sibling subprojects directly (no mavenLocal
+    // round-trip). No-op in non-fused mode.
+    const hasFusedOptIn = config.modResults.some(
+      (item) =>
+        item.type === 'property' && item.key === 'android.experimental.fusedLibrarySupport'
+    );
+    const hasFusedPubFlag = config.modResults.some(
+      (item) =>
+        item.type === 'property' &&
+        item.key === 'android.experimental.fusedLibrarySupport.publicationOnly'
+    );
+    if (!hasFusedOptIn || !hasFusedPubFlag) {
+      config.modResults = [
+        ...config.modResults,
+        ...getFusedLibrarySupportConfiguration(hasFusedOptIn, hasFusedPubFlag),
+      ];
+    }
+
     return config;
   });
 };
 
+const getFusedLibrarySupportConfiguration = (
+  hasFusedOptIn: boolean,
+  hasFusedPubFlag: boolean
+): AndroidConfig.Properties.PropertiesItem[] => {
+  const items: AndroidConfig.Properties.PropertiesItem[] = [];
+  if (!hasFusedOptIn) {
+    items.push(
+      {
+        type: 'comment',
+        value: "Acknowledge AGP Fused Library Preview status (required to apply the plugin)",
+      },
+      {
+        type: 'property',
+        key: 'android.experimental.fusedLibrarySupport',
+        value: 'true',
+      }
+    );
+  }
+  if (!hasFusedPubFlag) {
+    items.push(
+      {
+        type: 'comment',
+        value: 'Allow `com.android.fused-library` to include sibling project deps directly',
+      },
+      {
+        type: 'property',
+        key: 'android.experimental.fusedLibrarySupport.publicationOnly',
+        value: 'false',
+      }
+    );
+  }
+  return items;
+};
+
 const getDevMenuReleaseConfiguration = (): AndroidConfig.Properties.PropertiesItem[] => {
   return [
     {

package/plugin/src/android/plugins/withProjectBuildGradlePlugin.ts

@@ -7,27 +7,63 @@ const EXPO_APPLY_STATEMENT = 'apply plugin: "expo-root-project"';
 const PLUGIN_CLASSPATH = 'expo.modules:publish';
 const PLUGIN_NAME = 'expo-brownfield-publish';
 
+// AGP 8.12.0's Fused Library plugin's `rewriteClasses` task uses an ASM API version
+// below 9 at the call site and can't read `PermittedSubclasses` bytecode attributes
+// emitted for every Kotlin `sealed class`. AGP 8.13.0+ raises the hardcoded API
+// version. Bump only when the user opts into fused mode via `--fused` (which passes
+// `-Pbrownfield.fused=true`), so default builds keep using the version catalog's AGP.
+const FUSED_AGP_VERSION = '8.13.0';
+const FUSED_AGP_MARKER = 'brownfield.fused';
+
 const withProjectBuildGradlePlugin: ConfigPlugin<PluginConfig> = (config, pluginConfig) => {
   return withProjectBuildGradle(config, (config) => {
-    if (config.modResults.contents.includes(PLUGIN_CLASSPATH)) {
-      return config;
+    let lines = config.modResults.contents.split('\n');
+
+    if (!config.modResults.contents.includes(FUSED_AGP_MARKER)) {
+      lines = addFusedAgpResolutionStrategy(lines);
+    }
+
+    if (!config.modResults.contents.includes(PLUGIN_CLASSPATH)) {
+      lines = addPluginClasspathStatement(lines);
+      lines = addApplyStatement(lines);
+      lines = addPublicationConfiguration(
+        lines,
+        pluginConfig.publishing,
+        pluginConfig.projectRoot,
+        pluginConfig.libraryName
+      );
     }
 
-    let lines = config.modResults.contents.split('\n');
-    lines = addPluginClasspathStatement(lines);
-    lines = addApplyStatement(lines);
-    lines = addPublicationConfiguration(
-      lines,
-      pluginConfig.publishing,
-      pluginConfig.projectRoot,
-      pluginConfig.libraryName
-    );
     config.modResults.contents = lines.join('\n');
 
     return config;
   });
 };
 
+const addFusedAgpResolutionStrategy = (lines: string[]): string[] => {
+  // Appended as a sibling top-level `buildscript { ... }` block. Gradle merges multiple
+  // top-level buildscript blocks, so this composes with the project's existing one
+  // without clobbering it. The `findProperty` check makes the override conditional on
+  // `-Pbrownfield.fused=true` (set by `expo-brownfield build:android --fused`); without
+  // the flag the resolution-strategy block never runs and AGP stays at the catalog
+  // version.
+  const block = [
+    '',
+    'buildscript {',
+    '  // expo-brownfield: bump AGP only when `--fused` is active (CLI passes',
+    `  // -P${FUSED_AGP_MARKER}=true). AGP 8.12.0's Fused Library can't read Kotlin`,
+    '  // sealed-class bytecode (PermittedSubclasses requires ASM API >= 9, fixed',
+    `  // in AGP ${FUSED_AGP_VERSION}).`,
+    `  if (findProperty('${FUSED_AGP_MARKER}') == 'true') {`,
+    '    configurations.classpath {',
+    `      resolutionStrategy.force 'com.android.tools.build:gradle:${FUSED_AGP_VERSION}'`,
+    '    }',
+    '  }',
+    '}',
+  ];
+  return [...lines, ...block];
+};
+
 const addPluginClasspathStatement = (lines: string[]): string[] => {
   const statement = `    classpath('${PLUGIN_CLASSPATH}')`;
   const lastClasspathIndex = lines.findLastIndex((line) => line.includes('classpath('));

package/plugin/src/android/plugins/withProjectFilesPlugin.ts

@@ -3,7 +3,7 @@ import path from 'node:path';
 
 import { applyPatchToFile, checkPlugin, mkdir } from '../../common';
 import type { PluginConfig } from '../types';
-import { createFileFromTemplate } from '../utils';
+import { createFileFromTemplate, createFileFromTemplateAs } from '../utils';
 
 const withProjectFilesPlugin: ConfigPlugin<PluginConfig> = (config, pluginConfig) => {
   return withAndroidManifest(config, (config) => {
@@ -15,9 +15,20 @@ const withProjectFilesPlugin: ConfigPlugin<PluginConfig> = (config, pluginConfig
     const brownfieldMainPath = path.join(brownfieldPath, 'src/main/');
     const brownfieldSourcesPath = path.join(brownfieldMainPath, pluginConfig.packagePath);
 
+    const fusedReleasePath = path.join(
+      pluginConfig.projectRoot,
+      `android/${pluginConfig.libraryName}-fused-release`
+    );
+    const fusedDebugPath = path.join(
+      pluginConfig.projectRoot,
+      `android/${pluginConfig.libraryName}-fused-debug`
+    );
+
     // Create directory for the brownfield library sources
     // (and all intermediate directories)
     mkdir(brownfieldSourcesPath, true);
+    mkdir(fusedReleasePath, true);
+    mkdir(fusedDebugPath, true);
 
     // Add files from templates to the brownfield library:
     // - AndroidManifest.xml
@@ -49,6 +60,27 @@ const withProjectFilesPlugin: ConfigPlugin<PluginConfig> = (config, pluginConfig
     createFileFromTemplate('proguard-rules.pro', brownfieldPath);
     createFileFromTemplate('consumer-rules.pro', brownfieldPath);
 
+    // Emit the fused siblings' build.gradle.kts files. Same template at
+    // packages/expo-brownfield/plugin/templates/android/fused/build.gradle.kts —
+    // `fusedVariant` is the only difference: substituted as "release" or "debug",
+    // it drives the namespace suffix, publication name, and which build type the
+    // sibling resolves and fuses.
+    const fusedTemplate = path.join('fused', 'build.gradle.kts');
+    const fusedBaseVars = {
+      packageId: pluginConfig.package,
+      groupId: pluginConfig.group,
+      version: pluginConfig.version,
+      libraryName: pluginConfig.libraryName,
+    };
+    createFileFromTemplateAs(fusedTemplate, fusedReleasePath, 'build.gradle.kts', {
+      ...fusedBaseVars,
+      fusedVariant: 'release',
+    });
+    createFileFromTemplateAs(fusedTemplate, fusedDebugPath, 'build.gradle.kts', {
+      ...fusedBaseVars,
+      fusedVariant: 'debug',
+    });
+
     // Adjust ReactNativeHostManager and BrownfieldActivity to initialize dev menu
     if (checkPlugin(config, 'expo-dev-menu')) {
       applyPatchToFile(

package/plugin/src/android/plugins/withSettingsGradlePlugin.ts

@@ -4,14 +4,32 @@ import type { PluginConfig } from '../types';
 
 const withSettingsGradlePlugin: ConfigPlugin<PluginConfig> = (config, pluginConfig) => {
   return withSettingsGradle(config, (config) => {
-    config.modResults.contents += getBrownfieldIncludeStatement(pluginConfig.libraryName);
-    config.modResults.contents += getBrownfieldPluginIncludeStatement();
+    // Append line-by-line so re-running prebuild without --clean (or after
+    // upgrading from a version without the fused siblings) adds only what's
+    // missing instead of duplicating the whole block.
+    for (const line of getBrownfieldIncludeStatements(pluginConfig.libraryName)) {
+      if (!config.modResults.contents.includes(line)) {
+        config.modResults.contents += `${line}\n`;
+      }
+    }
+    if (!config.modResults.contents.includes('includeBuild(brownfieldPluginsPath)')) {
+      config.modResults.contents += getBrownfieldPluginIncludeStatement();
+    }
     return config;
   });
 };
 
-const getBrownfieldIncludeStatement = (libraryName: string) => {
-  return `include ':${libraryName}'\n`;
+// Two fused sibling Gradle subprojects (sourceless, applies `com.android.fused-library`)
+// are always emitted — one per variant — so each can be targeted on demand by
+// `expo-brownfield build:android --fused --release` / `--debug` / `--all`. Their
+// build scripts are inert unless the CLI passes `-Pbrownfield.fused=true`, so in
+// default mode they register no publications and resolve nothing.
+const getBrownfieldIncludeStatements = (libraryName: string) => {
+  return [
+    `include ':${libraryName}'`,
+    `include ':${libraryName}-fused-release'`,
+    `include ':${libraryName}-fused-debug'`,
+  ];
 };
 
 const getBrownfieldPluginIncludeStatement = () => {

package/plugin/src/common/filesystem.ts

@@ -15,6 +15,11 @@ const interpolateVariables = (str: string, variables: Record<string, unknown>):
   let match = variableRegex.exec(str);
   while (match) {
     const variable = match[0].slice(3, -2);
+    if (!(variable in variables)) {
+      throw new Error(
+        `The expo-brownfield template variable "${variable}" has no value, so the generated file would contain the literal string "undefined" and fail to build. This usually means the plugin passed an incomplete variable set for this template — report this at https://github.com/expo/expo/issues.`
+      );
+    }
     str = str.replace(match[0], String(variables[variable]));
     match = variableRegex.exec(str);
   }